diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml index 172ab350..48782979 100644 --- a/.github/workflows/codecov.yml +++ b/.github/workflows/codecov.yml @@ -1,41 +1,29 @@ name: Coverage (Codecov) on: - push: - branches: [ "main", "develop" ] pull_request: - branches: [ "main", "develop" ] + branches: ["main", "develop"] jobs: - test: - name: Run tests and upload coverage + coverage: + name: Compute coverage runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - - name: Set up Python 3.10 - uses: actions/setup-python@v5 + - name: Install uv + uses: astral-sh/setup-uv@v7 with: - python-version: "3.10" + enable-cache: true - - name: Install pandoc - uses: pandoc/actions/setup@v1 - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install coverage - python -m pip install sphinx myst_parser sphinx-rtd-theme nbsphinx pandoc jupyter jupyterlab - pip install -e . + - name: Install the project + run: uv sync --locked --all-extras --dev - name: Tests with coverage - run: | - coverage run --omit='./results/*','./docs/*','./examples/*' -m unittest discover tests - coverage xml -o coverage.xml + run: uv run pytest --cov=nnodely --cov-branch --cov-report=xml tests - name: Upload results to Codecov - uses: codecov/codecov-action@v5 - with: - token: ${{ secrets.CODECOV_TOKEN }} - files: coverage.xml \ No newline at end of file + uses: codecov/codecov-action@v6 + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/create-release.yml b/.github/workflows/create-release.yml index 605f4a43..3207b354 100644 --- a/.github/workflows/create-release.yml +++ b/.github/workflows/create-release.yml @@ -1,130 +1,101 @@ -name: Publish New nnodely Release +name: Publish on: push: tags: - - "v*" # Push events to matching v*, i.e., v1.0, v20.15.10 + - "v*" jobs: - check-tag-version: - name: Check tag version equal to file version + publish: + name: Build and publish to both TestPyPi and PyPi runs-on: ubuntu-latest + environment: + name: pypi + permissions: + id-token: write + contents: read steps: - - name: Checkout code - uses: actions/checkout@v2 - - name: Extract tag version + - uses: actions/checkout@v6 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + with: + enable-cache: true + + - name: Validate tag matches project version run: | - TAG_NAME="${{ github.ref_name }}" - TAG_VERSION=$(echo $TAG_NAME | sed 's/v//') + TAG_VERSION="${GITHUB_REF_NAME#v}" + PROJ_VERSION=$(uv version --short) + echo "Tag version: $TAG_VERSION" - echo "TAG_VERSION=$TAG_VERSION" >> $GITHUB_ENV - - name: Extract file version - run: | - FILE_VERSION=$(awk -F"'" '/^__version__/ {print $2}' nnodely/__init__.py) - echo "File version: $FILE_VERSION" - echo "FILE_VERSION=$FILE_VERSION" >> $GITHUB_ENV - - name: Show tag and file versions - run: | - echo "The tag version: ${{ env.TAG_VERSION }}" - echo "The file version: ${{ env.FILE_VERSION }}" - - name: Check if tag and file versions match - if: ${{ env.TAG_VERSION != env.FILE_VERSION }} - run: | - echo "The tag version ${{ env.TAG_VERSION }} does not match file version ${{ env.FILE_VERSION }}" - exit 1 + echo "Project version: $PROJ_VERSION" - build: - name: Build distribution of tagged version - needs: - - check-tag-version - runs-on: ubuntu-latest + if [ "$TAG_VERSION" != "$PROJ_VERSION" ]; then + echo "Mismatch: tag=$TAG_VERSION project=$PROJ_VERSION" + exit 1 + fi - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ github.ref_name }} - - name: Set up Python - uses: actions/setup-python@v5 - with: - python-version: "3.x" - - - name: Install pypa/build - run: >- - python3 -m - pip install - build - --user - - name: Build a binary wheel and a source tarball - run: python3 -m build - - name: Store the distribution packages - uses: actions/upload-artifact@v4 - with: - name: python-package-distributions - path: dist/ - - publish-to-pypi: - name: Publish to PyPI - needs: - - build + - name: Build + run: uv build - runs-on: ubuntu-latest - environment: - name: pypi - url: https://pypi.org/p/nnodely # Replace with your PyPI project name - permissions: - id-token: write # IMPORTANT: mandatory for trusted publishing + # Check that basic features work and we didn't miss to include crucial files + - name: Basic test (wheel) + run: uv run --isolated --no-project --with dist/*.whl python -c "import nnodely" - steps: - - name: Download all the dists - uses: actions/download-artifact@v4 - with: - name: python-package-distributions - path: dist/ - - name: Publish nnodely to PyPI - uses: pypa/gh-action-pypi-publish@release/v1 + - name: Basic test (source distribution) + run: uv run --isolated --no-project --with dist/*.tar.gz python -c "import nnodely" + + - name: TestPyPi publish + run: uv publish --index testpypi + + - name: PyPI publish + run: uv publish + + - name: Upload artifacts + uses: actions/upload-artifact@v7 + with: + name: python-package-distributions + path: dist/ github-release: - name: >- - Sign the Python with Sigstore and upload them to GitHub Release - needs: - - publish-to-pypi + name: Sign the Python with Sigstore and upload them to GitHub Release runs-on: ubuntu-latest + needs: + - publish permissions: - contents: write # IMPORTANT: mandatory for making GitHub Releases - id-token: write # IMPORTANT: mandatory for sigstore + contents: write + id-token: write steps: - - name: Download all the dists - uses: actions/download-artifact@v4 - with: - name: python-package-distributions - path: dist/ - - name: Sign the dists with Sigstore - uses: sigstore/gh-action-sigstore-python@v3.0.0 - with: - inputs: >- - ./dist/*.tar.gz - ./dist/*.whl - - name: Get the branch version - run: | - TAG_NAME="${{ github.ref_name }}" - TAG_MESSAGE=${{ github.event.workflow_run.head_commit.message }} - echo "Tag message: $TAG_MESSAGE" - echo "TAG_MESSAGE=$TAG_MESSAGE" >> $GITHUB_ENV - - name: Create GitHub release - env: - GITHUB_TOKEN: ${{ github.token }} - tag: ${{ github.ref_name }} - run: | - echo "The branch version: $tag" - gh release create $tag --title "$tag" --repo ${{ github.repository }} --notes "${{ env.TAG_MESSAGE }}" - - name: Upload artifact signatures to GitHub Release - env: - GITHUB_TOKEN: ${{ github.token }} - tag: ${{ github.ref_name }} - # Upload to GitHub Release using the `gh` CLI. - # `dist/` contains the built packages, and the - # sigstore-produced signatures and certificates. - run: >- - gh release upload $tag dist/** --repo ${{ github.repository }} \ No newline at end of file + - uses: actions/download-artifact@v8 + with: + name: python-package-distributions + path: dist/ + + - name: Sign artifacts + uses: sigstore/gh-action-sigstore-python@v3.0.0 + with: + inputs: | + ./dist/*.tar.gz + ./dist/*.whl + - name: Detect prerelease + id: version + run: | + VERSION="${GITHUB_REF_NAME#v}" + + if [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then + echo "PRERELEASE=false" >> "$GITHUB_OUTPUT" + else + echo "PRERELEASE=true" >> "$GITHUB_OUTPUT" + fi + + - name: Release + uses: softprops/action-gh-release@v3 + if: github.ref_type == 'tag' + with: + files: | + dist/*.tar.gz + dist/*.whl + generate_release_notes: true + prerelease: ${{ steps.version.outputs.PRERELEASE }} diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 00000000..57db3ccc --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,23 @@ +name: Lint + +on: + pull_request: + branches: ["main", "develop"] + +jobs: + lint: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v6 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + with: + enable-cache: true + + - name: Install the project + run: uv sync --locked --all-extras --dev + + - name: Lint + run: uv run ruff check diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml index cec03b02..dccfb921 100644 --- a/.github/workflows/run-tests.yml +++ b/.github/workflows/run-tests.yml @@ -1,51 +1,29 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - name: Run Tests on: - push: - branches: [ "main", "develop" ] pull_request: - branches: [ "main", "develop"] + branches: ["main", "develop"] jobs: - build: - + test: runs-on: ${{ matrix.os }} strategy: - fail-fast: false + fail-fast: true matrix: os: [ubuntu-latest, windows-latest, macos-latest] - python-version: [ "3.10", "3.11", "3.12"] - architecture: ['x64', 'x86'] + python-version: ["3.10", "3.11", "3.12", "3.13"] steps: - - uses: actions/checkout@v4 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 - with: - python-version: ${{ matrix.python-version }} - - name: Install pandoc - uses: pandoc/actions/setup@v1 - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install flake8 pytest - python -m pip install sphinx myst_parser sphinx-rtd-theme nbsphinx pandoc jupyter jupyterlab - pip install -e . - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - name: Test with pytest - run: | - pytest - - - + - uses: actions/checkout@v6 + - name: Install uv and set the Python version + uses: astral-sh/setup-uv@v7 + with: + enable-cache: true + python-version: ${{ matrix.python-version }} + - name: Install the project + run: uv sync --locked --all-extras --dev + - name: Run tests + run: uv run pytest tests diff --git a/.gitignore b/.gitignore index 605f2ab1..71f641f1 100644 --- a/.gitignore +++ b/.gitignore @@ -1,181 +1,16 @@ -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ -cover/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ -docs/out_docs/ - -# PyBuilder -.pybuilder/ -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -# For a library or package, you might want to ignore these files since the code is -# intended to run in multiple environments; otherwise, check them in: -# .python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# poetry -# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. -# This is especially recommended for binary packages to ensure reproducibility, and is more -# commonly ignored for libraries. -# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock - -# pdm -# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. -#pdm.lock -# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it -# in version control. -# https://pdm.fming.dev/latest/usage/project/#working-with-version-control -.pdm.toml -.pdm-python -.pdm-build/ - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env +__pycache__ .venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# pytype static type analyzer -.pytype/ - -# Cython debug symbols -cython_debug/ - -# PyCharm -# JetBrains specific template is maintained in a separate JetBrains.gitignore that can -# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore -# and can be added to the global gitignore or merged into this file. For a more nuclear -# option (not recommended) you can uncomment the following to ignore the entire idea folder. .idea/ - -# vscode test .vscode +!.vscode/settings.json +!.vscode/extensions.json -# MacOS system files -.DS_Store - -# default results folder results +dist/ +docs/_build +docs/out_docs +experimental/ -# default temp folder -temp - -# Todo for testing -TODO/ - -#trained_models folder -trained_models \ No newline at end of file +.DS_Store +.coverage +coverage.xml diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..7b38cead --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,41 @@ +default_install_hook_types: + - pre-commit + - post-merge + - post-rewrite + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v2.3.0 + hooks: + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace + - repo: local + hooks: + - id: uv-sync + name: uv sync + entry: uv sync + language: system + pass_filenames: false + stages: [post-merge, post-rewrite] + - id: uv-lock + name: uv lock + entry: uv lock + language: system + pass_filenames: false + - id: ruff-check + name: ruff check + entry: uv run ruff check --fix + language: system + types: [python] + - id: ruff-format + name: ruff format + entry: uv run ruff format + language: system + types: [python] + - id: pytest + name: pytest + entry: uv run pytest tests + language: system + pass_filenames: false + types: [python] diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..24ee5b1b --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.13 diff --git a/.readthedocs.yaml b/.readthedocs.yaml index a2940afa..c0248145 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -22,5 +22,3 @@ python: - method: pip path: . - requirements: docs/requirements.txt - - diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 00000000..25a30545 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,7 @@ +{ + "recommendations": [ + "ms-python.python", + "ms-python.vscode-pylance", + "charliermarsh.ruff" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..d410bbd2 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,9 @@ +{ + "python.languageServer": "Pylance", + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": true + }, + "ruff.enable": true, + "ruff.lint.enable": true +} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..dc962b34 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,173 @@ +# Contributing + +Thanks for your interest in **nnodely**! 🎉 +We're just getting started and welcome contributions of all kinds — bug +reports, documentation fixes, examples, and new features. + +## Setup + +All you need to do is: + +- install [uv](https://docs.astral.sh/uv/) +- clone the repo +- run `uv sync --dev` +- install the hooks `uv run pre-commit install --install-hooks` + +You are now up and running, just make sure to run everything via `uv` (e.g., +`uv run ...`). + +### IDE + +We have config files for the IDEs we use, so `VSCode`, `PyCharm`, and `neovim` +should be ready to go. + +- `VSCode`: you can find a `.vscode` folder which should prompt you to install + the necessary plugins and enable them as we expect them to be. Nonetheless + know that it will use `PyLance` and not bare `pyright` so you will see + different diagnostics. It should pick up the `uv` managed environment right + away. +- `PyCharm`: enable `pyright` and `ruff` and you should be good to go. It + should also pick up `uv` automatically. +- `neovim`: you have to add the `pyright` and `ruff` (e.g., using `mason`) and + enable them (e.g., `vim.lsp.enable(...)`). To pick up `uv` just run `uv run +nvim .` in the project root. + +## Code Style + +This project follows a strict and largely automated Python code style. The goal +is to keep the codebase consistent, readable, and easy to review, while +minimising style-related discussion in PRs. + +In short: **let the tools do the work**. + +--- + +## General Principles + +- Prefer clarity over cleverness. +- Keep functions and classes small and focused. +- Be consistent with existing code. + +--- + +## Python Version + +We target all the [supported Python +versions](https://devguide.python.org/versions/). Tests will catch most of the +version specific behaviour, but please keep it in mind. + +--- + +## Linting and Formatting + +This project uses `ruff` for both linting and formatting. + +- All code **must** pass `ruff` checks. +- Formatting is enforced via `ruff format`. +- Do **not** manually fight the formatter. + +A `pre-commit` hook will take care of this, but you can also run it manually with: + +```bash +uv run ruff check --fix +uv run ruff format +``` + +### Ignoring Rules and Formatting + +Disabling rules or formatting should be rare and justified: + +```python +value = legacy_call() # noqa: PLW0603 # required by external API + +# fmt: off +table = [ + ("short", 1), + ("muchlonger", 2), +] +# fmt: on +``` + +--- + +## Naming Conventions + +We use: + +- `snake_case` for functions and variables +- `CamelCase` for classes +- `UPPERCASE` for constants + +--- + +## Type Hints + +- Required unless impractical. +- Make custom types whenever your type gets too big, for example: + + ```python + # This horrible mess + list[dict[str, list[int]]] + + # Should become + CustomType: TypeAlias = list[dict[str, list[int]]] + ``` + +- Heavily prefer strong typing (e.g., `Enum` and `dataclass`), for example: + + ```python + # Instead of this + def func(flag: str) -> None: + ... + + # Do this + class Flag(Enum): + ... + + def func(flag: Flag) -> None: + ... + ``` + +--- + +## Docstrings and Comments + +- Use docstrings for public modules, classes, and functions +- Follow the project's configured docstring style +- Comments should explain why, not what +- Avoid obvious or redundant comments + +--- + +## Branching + +### Branching Model + +- `main` is the default branch + - Always stable. + - Always releasable. + - Protected (no direct commits). +- `develop` is the rolling branch + - Put all development not quite stable yet. + - Protected (no direct commits). +- All work happens on branches created from `develop`. + +### Branch Naming + +We follow [this](https://conventional-branch.github.io). + +--- + +## Commit Messages + +We follow [this](https://www.conventionalcommits.org/en/v1.0.0/). + +--- + +## GitHub Actions + +Testing GitHub Actions is a pain, but it becomes easier if you test at least +some of their functionality with [act](https://github.com/nektos/act). + +For example, to test the `codecov.xml` action just setup `act` and run: `act +--workflows .github/workflows/codecov.yml`. diff --git a/README.md b/README.md index 46da35cb..f7d87cf0 100644 --- a/README.md +++ b/README.md @@ -12,12 +12,12 @@ Modeling, control, and estimation of physical systems are central to many engineering disciplines. While data-driven methods like neural networks offer powerful tools, they often struggle to **incorporate prior domain knowledge**, limiting their interpretability, generalizability, and safety. -To bridge this gap, we present ***nnodely*** (where "nn" can be read as "m," forming *Modely*) — a framework that facilitates the creation and deployment of **Model-Structured Neural Networks** (**MS-NNs**). +To bridge this gap, we present ***nnodely*** (where "nn" can be read as "m," forming *Modely*) — a framework that facilitates the creation and deployment of **Model-Structured Neural Networks** (**MS-NNs**). MS-NNs combine the learning capabilities of neural networks with structural **priors** grounded in **physics, control, and estimation theory**, enabling: -- **Reduced training data** requirements -- **Generalization** to unseen scenarios -- **Real-time** deployment in real-world applications +- **Reduced training data** requirements +- **Generalization** to unseen scenarios +- **Real-time** deployment in real-world applications In short: @@ -126,10 +126,10 @@ The `nnodely` main class defined in __nnodely.py__, it contains all the main pro 2. __loader.py__ contains the function for managing the dataset, the main function is `dataLoad`. 3. __trainer.py__ contains the function for training the network as the `trainModel`. 4. __exporter.py__ contains all the function for import and export: `saveModel`, `loadModel`, `exportONNX` etc.. -5. __validator.py__ contains all the function for validate the model and the `resultsAnalysis`. +5. __validator.py__ contains all the function for validate the model and the `resultsAnalysis`. 6. All the operators derive from `Network` defined in __network.py__, that contains the shared support functions for all the operators. -The folder `basic/` contains the main classes for the low level functionalities: +The folder `basic/` contains the main classes for the low level functionalities: 1. __model.py__ containts the pytorch template model for the structured network. 2. __modeldef.py__ containts the operation for work with the json model definition. 3. __loss.py__ contains the loss functions. @@ -153,14 +153,14 @@ The main basic layers without parameters are: 2. __arithmetic.py__ this file contains the aritmetic functions as: +, -, /, *., **. 3. __trigonometric.py__ this file contains all the trigonometric functions. 4. __part.py__ are used for selecting part of the data. -5. __fuzzify.py__ contains the operation for the fuzzification of a variable, +5. __fuzzify.py__ contains the operation for the fuzzification of a variable, commonly used in the local model as activation function as in [[1]](#1) with rectangular activation functions or in [[3]](#3), [[4]](#4) and [[5]](#5) with triangular activation function activation functions. Using fuzzification it is also possible create a channel coding as presented in [[2]](#2). The main basic layers with parameters are: -1. __fir.py__ this file contains the finite impulse response filter function. It is a linear operation on the time dimension (second dimension). +1. __fir.py__ this file contains the finite impulse response filter function. It is a linear operation on the time dimension (second dimension). This filter was introduced in [[1]](#1). -2. __linear.py__ this file contains the linear function. Typical Linear operation `W*x+b` operated on the space dimension (third dimension). +2. __linear.py__ this file contains the linear function. Typical Linear operation `W*x+b` operated on the space dimension (third dimension). This operation is presented in [[1]](#1). 3. __localmodel.py__ this file contains the logic for build a local model. This operation is presented in [[1]](#1), [[3]](#3), [[4]](#4) and [[5]](#5). 4. __parametricfunction.py__ are the user custom function. The function can use the pytorch syntax. A parametric function is presented in [[3]](#3), [[4]](#4), [[5]](#5). @@ -196,8 +196,8 @@ This folder contains the images used in the documentation. To contribute to the nnodely framework, you can: -- Open a pull request if you have a new feature or bug fix. -- Open an issue if you have a question or suggestion. +- Open a pull request if you have a new feature or bug fix. +- Open an issue if you have a question or suggestion. We welcome contributions and collaborations. @@ -212,53 +212,53 @@ This project is released under the license [License: MIT](https://opensource.org ## References -[1] -Mauro Da Lio, Daniele Bortoluzzi, Gastone Pietro Rosati Papini. (2019). -Modelling longitudinal vehicle dynamics with neural networks. +[1] +Mauro Da Lio, Daniele Bortoluzzi, Gastone Pietro Rosati Papini. (2019). +Modelling longitudinal vehicle dynamics with neural networks. Vehicle System Dynamics. https://doi.org/10.1080/00423114.2019.1638947 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/vehicle/model_longit_vehicle_dynamics/model_longit_vehicle_dynamics.py)) -[2] -Alice Plebe, Mauro Da Lio, Daniele Bortoluzzi. (2019). -On Reliable Neural Network Sensorimotor Control in Autonomous Vehicles. +[2] +Alice Plebe, Mauro Da Lio, Daniele Bortoluzzi. (2019). +On Reliable Neural Network Sensorimotor Control in Autonomous Vehicles. IEEE Transaction on Intelligent Transportation System. https://doi.org/10.1109/TITS.2019.2896375 -[3] -Mauro Da Lio, Riccardo Donà, Gastone Pietro Rosati Papini, Francesco Biral, Henrik Svensson. (2020). +[3] +Mauro Da Lio, Riccardo Donà, Gastone Pietro Rosati Papini, Francesco Biral, Henrik Svensson. (2020). A Mental Simulation Approach for Learning Neural-Network Predictive Control (in Self-Driving Cars). IEEE Access. https://doi.org/10.1109/ACCESS.2020.3032780 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/vehicle/model_lateral_vehicle_dynamics/model_lateral_vehicle_dynamics.ipynb)) -[4] -Edoardo Pagot, Mattia Piccinini, Enrico Bertolazzi, Francesco Biral. (2023). +[4] +Edoardo Pagot, Mattia Piccinini, Enrico Bertolazzi, Francesco Biral. (2023). Fast Planning and Tracking of Complex Autonomous Parking Maneuvers With Optimal Control and Pseudo-Neural Networks. IEEE Access. https://doi.org/10.1109/ACCESS.2023.3330431 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/vehicle/control_steer_car_parking/control_steer_car_parking.ipynb)) -[5] +[5] Mattia Piccinini, Sebastiano Taddei, Matteo Larcher, Mattia Piazza, Francesco Biral. (2023). A Physics-Driven Artificial Agent for Online Time-Optimal Vehicle Motion Planning and Control. IEEE Access. https://doi.org/10.1109/ACCESS.2023.3274836 (look [[code basic]](https://github.com/tonegas/nnodely-applications/blob/main/vehicle/control_steer_artificial_race_driver/control_steer_artificial_race_driver.ipynb) and [[code extended]](https://github.com/tonegas/nnodely-applications/blob/main/vehicle/control_steer_artificial_race_driver_extended/control_steer_artificial_race_driver_extended.ipynb)) -[6] +[6] Hector Perez-Villeda, Justus Piater, Matteo Saveriano. (2023). Learning and extrapolation of robotic skills using task-parameterized equation learner networks. Robotics and Autonomous Systems. https://doi.org/10.1016/j.robot.2022.104309 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/equation_learner/equation_learner.ipynb)) -[7] +[7] M. Raissi. P. Perdikaris b, G.E. Karniadakis a. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations Journal of Computational Physics. https://doi.org/10.1016/j.jcp.2018.10.045 (look the [[example Burger's equation]](https://github.com/tonegas/nnodely-applications/blob/main/pinn/pinn_Burgers_equation.ipynb)) -[8] +[8] Wojciech Marian Czarnecki, Simon Osindero, Max Jaderberg, Grzegorz Świrszcz, Razvan Pascanu. (2017). Sobolev Training for Neural Networks. arXiv. https://doi.org/10.48550/arXiv.1706.04859 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/sobolev/Sobolev_learning.ipynb)) -[9] +[9] Mattia Piccinini, Matteo Zumerle, Johannes Betz, Gastone Pietro Rosati Papini. (2025). A Road Friction-Aware Anti-Lock Braking System Based on Model-Structured Neural Networks. IEEE Open Journal of Intelligent Transportation Systems. https://doi.org/10.1109/OJITS.2025.3563347 (look at the [[code]](https://github.com/tonegas/nnodely-applications/tree/main/vehicle/road_friction_aware_ABS)) -[10] +[10] Mauro Da Lio, Mattia Piccinini, Francesco Biral. (2023). Robust and Sample-Efficient Estimation of Vehicle Lateral Velocity Using Neural Networks With Explainable Structure Informed by Kinematic Principles. IEEE Transactions on Intelligent Transportation Systems. https://doi.org/10.1109/TITS.2023.3303776 diff --git a/case-studies/README.md b/case-studies/README.md index f65f7b18..2ec3b9aa 100644 --- a/case-studies/README.md +++ b/case-studies/README.md @@ -8,9 +8,9 @@ The subfolders are organized as follows: Contains three Python notebooks (plus all the other relative files) relative to the lateral vehicle dynamics model: -- `lateral_dynamics_model.ipynp`: Design of the lateral vehicle dynamics model as presented in the paper +- `lateral_dynamics_model.ipynp`: Design of the lateral vehicle dynamics model as presented in the paper - `lateral_dynamics_control.ipynp`: Design and training of the lateral controller as presented in the paper -- `lateral_dynamics_model_torch.ipynp`: A comparative implementation of the lateral dynamics model developed in native **PyTorch** +- `lateral_dynamics_model_torch.ipynp`: A comparative implementation of the lateral dynamics model developed in native **PyTorch** ## 2. `mass_spring_damper` @@ -25,4 +25,4 @@ Provides an example implementation of a Physics-Informed Neural Network (PINN), ## 4. `neuralODE` -Contains a preliminary implementation of Neural ODEs within the nnodely framework, illustrating continuous-time modeling via parametric functions and integration operators for the mass-spring-damper-system. \ No newline at end of file +Contains a preliminary implementation of Neural ODEs within the nnodely framework, illustrating continuous-time modeling via parametric functions and integration operators for the mass-spring-damper-system. diff --git a/case-studies/lateral_dynamics/dataset/test/test_set.csv b/case-studies/lateral_dynamics/dataset/test/test_set.csv index 9c323599..c1555ec9 100644 --- a/case-studies/lateral_dynamics/dataset/test/test_set.csv +++ b/case-studies/lateral_dynamics/dataset/test/test_set.csv @@ -1103,4 +1103,4 @@ time,ax,ay,vx,curv,steer 55.146002028075564,1.0840258510987684,-2.6915592509185298,20.453059684147426,-0.006434242005669751,-0.3608481332433391 55.195998943798315,1.0851748822292842,-2.697148256568109,20.507079535715768,-0.006413818184476849,-0.35926049452967035 55.24600044829564,1.0880632184191892,-2.6997673049851385,20.561189941463603,-0.0063864243157048545,-0.3573006906046246 -55.2959998400224,1.0925590253392408,-2.699641748410116,20.615475400176003,-0.006352663418874661,-0.3550151089245937 \ No newline at end of file +55.2959998400224,1.0925590253392408,-2.699641748410116,20.615475400176003,-0.006352663418874661,-0.3550151089245937 diff --git a/case-studies/lateral_dynamics/dataset/training/test1.csv b/case-studies/lateral_dynamics/dataset/training/test1.csv index b9d55044..4fdce233 100644 --- a/case-studies/lateral_dynamics/dataset/training/test1.csv +++ b/case-studies/lateral_dynamics/dataset/training/test1.csv @@ -3722,4 +3722,4 @@ time,ax,ay,vx,curv,brake,gas,steer,s 186,-0.1071997657,-1.682893157,26.17891693,-0.002456563614,0,0.06283919513,-0.1276736856,2305.977185 186.05,-0.1293833256,-1.641584277,26.17271233,-0.002397477173,0,0.05899731815,-0.1237370819,2307.311642 186.1,-0.1502973288,-1.598474264,26.16544533,-0.002335893822,0,0.05537641793,-0.1197138876,2308.640748 -186.15,-0.1705370843,-1.553611755,26.15716553,-0.002271854197,0,0.05186513811,-0.1156224832,2309.964296 \ No newline at end of file +186.15,-0.1705370843,-1.553611755,26.15716553,-0.002271854197,0,0.05186513811,-0.1156224832,2309.964296 diff --git a/case-studies/lateral_dynamics/dataset/training/test2.csv b/case-studies/lateral_dynamics/dataset/training/test2.csv index dec669df..0c06446d 100644 --- a/case-studies/lateral_dynamics/dataset/training/test2.csv +++ b/case-studies/lateral_dynamics/dataset/training/test2.csv @@ -2440,4 +2440,4 @@ time,ax,ay,vx,curv,brake,gas,steer,s 121.9,0.009731287137,-1.63340795,27.77533531,-0.00211779615,0,0.08593299985,-0.1145167798,2307.353851 121.95,0.009520187043,-1.607111335,27.77551842,-0.002083710209,0,0.08586709201,-0.1123358831,2308.764477 122,0.009291882627,-1.579890013,27.77569962,-0.002048425176,0,0.08579877764,-0.1101001278,2310.169094 -122.038,0,0,0,-0.002021582034,0,0.0857468918,-0.1084142625,0.04364157261 \ No newline at end of file +122.038,0,0,0,-0.002021582034,0,0.0857468918,-0.1084142625,0.04364157261 diff --git a/case-studies/lateral_dynamics/dataset/validation/test3.csv b/case-studies/lateral_dynamics/dataset/validation/test3.csv index b8139727..046dd09c 100644 --- a/case-studies/lateral_dynamics/dataset/validation/test3.csv +++ b/case-studies/lateral_dynamics/dataset/validation/test3.csv @@ -2836,4 +2836,4 @@ time,ax,ay,vx,curv,brake,gas,steer,s 141.7,0.01632077061,-1.733056784,27.7700386,-0.002248041434,0,0.08714535087,-0.1201838106,2306.726898 141.75,0.01580184698,-1.697605133,27.77050591,-0.002202034247,0,0.08702037483,-0.1172332019,2308.139691 141.8,0.01531017479,-1.660968184,27.77096176,-0.002154490374,0,0.08689385653,-0.1142256781,2309.546658 -141.85,0.0148289185,-1.623295903,27.77140617,-0.002105606111,0,0.08676507324,-0.1111633554,2310.947616 \ No newline at end of file +141.85,0.0148289185,-1.623295903,27.77140617,-0.002105606111,0,0.08676507324,-0.1111633554,2310.947616 diff --git a/case-studies/lateral_dynamics/lateral_dynamics_control.ipynb b/case-studies/lateral_dynamics/lateral_dynamics_control.ipynb index 1d1baa0a..d4ce0344 100644 --- a/case-studies/lateral_dynamics/lateral_dynamics_control.ipynb +++ b/case-studies/lateral_dynamics/lateral_dynamics_control.ipynb @@ -1,30 +1,51 @@ { "cells": [ { - "metadata": {}, "cell_type": "markdown", - "source": "# **CONTROL MODEL FOR VEHICLE LATERAL DYNAMICS**", - "id": "4fca82a7205fafb9" + "id": "4fca82a7205fafb9", + "metadata": {}, + "source": [ + "# **CONTROL MODEL FOR VEHICLE LATERAL DYNAMICS**" + ] }, { + "cell_type": "markdown", + "id": "45be3b6d", "metadata": {}, + "source": [ + "This notebook presents the Model-Structured Neural Network lateral controller. The controlled is trained onto the MS-NN model of the vehicle and the telemetries are the same used also in *lateral_dynamics_control.ipynb*." + ] + }, + { "cell_type": "markdown", - "source": "### Import packages", - "id": "f4fe99351f149193" + "id": "f4fe99351f149193", + "metadata": {}, + "source": [ + "## Initialization" + ] }, { "cell_type": "code", + "execution_count": 1, "id": "initial_id", "metadata": { - "collapsed": true, "ExecuteTime": { - "end_time": "2025-12-09T19:50:34.537828Z", - "start_time": "2025-12-09T19:50:31.658706Z" - } + "end_time": "2025-12-09T21:57:24.873734Z", + "start_time": "2025-12-09T21:57:23.559343Z" + }, + "collapsed": true }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-- nnodely_v1.5.4 --<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n" + ] + } + ], "source": [ "# Import necessary packages\n", - "import sys, os\n", "import pandas as pd\n", "\n", "# import nnodely modules\n", @@ -35,92 +56,86 @@ "\n", "# import a library for plots\n", "import matplotlib as mpl\n", + "\n", "mpl.rcParams.update(mpl.rcParamsDefault)\n", "import matplotlib.pyplot as plt\n", - "plt.close('all')\n", + "\n", + "plt.close(\"all\")\n", "SMALL_SIZE = 14\n", "MEDIUM_SIZE = 22\n", "BIGGER_SIZE = 26\n", - "plt.rc('font', size=SMALL_SIZE) # controls default text sizes\n", - "plt.rc('axes', titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", - "plt.rc('axes', labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", - "plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('legend', fontsize=SMALL_SIZE) # legend fontsize\n", - "plt.rc('figure', titlesize=BIGGER_SIZE) # fontsize of the figure title\n", - "plt.rc('grid', linestyle=\"--\", color='grey')" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-- nnodely_v1.5.2 --<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n" - ] - } - ], - "execution_count": 1 + "plt.rc(\"font\", size=SMALL_SIZE) # controls default text sizes\n", + "plt.rc(\"axes\", titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", + "plt.rc(\"axes\", labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", + "plt.rc(\"xtick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"ytick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"legend\", fontsize=SMALL_SIZE) # legend fontsize\n", + "plt.rc(\"figure\", titlesize=BIGGER_SIZE) # fontsize of the figure title\n", + "plt.rc(\"grid\", linestyle=\"--\", color=\"grey\")" + ] }, { + "cell_type": "code", + "execution_count": 2, + "id": "ae9293c8", "metadata": {}, - "cell_type": "markdown", - "source": "### Configurations", - "id": "7f7ac76c4718c9be" + "outputs": [], + "source": [ + "# Configurations\n", + "path_folder = \"trained_models\" # folder to save the model\n", + "lat_dyna_control = nnodely(\n", + " visualizer=MPLNotebookVisualizer(), seed=1, workspace=path_folder, log_internal=True\n", + ")" + ] }, { - "metadata": { - "ExecuteTime": { - "end_time": "2025-12-09T19:50:34.550025Z", - "start_time": "2025-12-09T19:50:34.543029Z" - } - }, - "cell_type": "code", + "cell_type": "markdown", + "id": "a4b4192ab97751ff", + "metadata": {}, "source": [ - "\n", - "path_folder = os.path.join('trained_models') # folder to save the model\n", - "lat_dyna_control = nnodely(visualizer=MPLNotebookVisualizer(),seed=1,workspace=path_folder,save_history=False)" - ], - "id": "fc1700c6ad33005a", - "outputs": [], - "execution_count": 2 + "# Neural Network model" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# Neural Network model", - "id": "a4b4192ab97751ff" + "id": "d5af85a6", + "metadata": {}, + "source": [ + "The lateral controller takes as inputs the target speed and curvature and outputs the steer to apply at the vehicle. \n", + "\n", + "![](figs/fig_control.png)" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Import NN vehicle model", - "id": "92f39794ca78b53c" + "id": "92f39794ca78b53c", + "metadata": {}, + "source": [ + "### Import NN vehicle model" + ] }, { + "cell_type": "code", + "execution_count": 3, + "id": "db30f6144516ecef", "metadata": { "ExecuteTime": { - "end_time": "2025-12-09T19:50:34.582276Z", - "start_time": "2025-12-09T19:50:34.559228Z" + "end_time": "2025-12-09T21:58:16.132887Z", + "start_time": "2025-12-09T21:58:16.120119Z" } }, - "cell_type": "code", - "source": [ - "lat_dyna_control.loadModel('vehicle_model')\n", - "lat_dyna_control.neuralizeModel()" - ], - "id": "db30f6144516ecef", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m=============================== Load JSON Model ================================\u001B[0m\n", - "\u001B[32mModel loaded from: trained_models/vehicle_model.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {'SampleTime': {'dim': 1, 'values': 0.05},\n", + "\u001b[1;32m=============================== Load JSON Model ================================\u001b[0m\n", + "\u001b[32mModel loaded from: trained_models/vehicle_model.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {'SampleTime': {'dim': 1, 'values': 0.05},\n", " 'W_fir': {'dim': 1,\n", " 'sw': 30,\n", " 'values': [[0.023806948214769363],\n", @@ -153,7 +168,7 @@ " [0.9823793172836304],\n", " [0.9955654144287109],\n", " [1.0]]}},\n", - " 'Functions': {'FFuzzify7': {'centers': [8.0,\n", + " 'Functions': {'FFuzzify6': {'centers': [8.0,\n", " 10.142857142857142,\n", " 12.285714285714285,\n", " 14.428571428571429,\n", @@ -164,11 +179,11 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify8': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", + " 'FFuzzify7': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", " 'dim_out': {'dim': 5},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FParamFun6': {'code': 'def understeer_corr_local(vx, # input\\n'\n", + " 'FParamFun5': {'code': 'def understeer_corr_local(vx, # input\\n'\n", " ' A # '\n", " 'learnable parameter\\n'\n", " ' ):\\n'\n", @@ -180,7 +195,7 @@ " 'name': 'understeer_corr_local',\n", " 'params_and_consts': []}},\n", " 'Info': {'SampleTime': 0.05,\n", - " 'nnodely_version': '1.5.2',\n", + " 'nnodely_version': '1.5.4',\n", " 'ns': [30, 1],\n", " 'ntot': 31,\n", " 'num_parameters': 245},\n", @@ -211,291 +226,291 @@ " 'Outputs': {'model_curv': 'Mul72'},\n", " 'Parameters': {'A_0': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.12241744995117188]]},\n", + " 'values': [[0.10271348804235458]]},\n", " 'A_1': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13215704262256622]]},\n", + " 'values': [[0.11061573028564453]]},\n", " 'A_2': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13487723469734192]]},\n", + " 'values': [[0.11115050315856934]]},\n", " 'A_3': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13838686048984528]]},\n", + " 'values': [[0.11318214982748032]]},\n", " 'A_4': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.14319394528865814]]},\n", + " 'values': [[0.11924726516008377]]},\n", " 'Fir_0': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.08373943716287613],\n", - " [0.07128263264894485],\n", - " [0.05931668356060982],\n", - " [0.047899674624204636],\n", - " [0.03708196431398392],\n", - " [0.026911072432994843],\n", - " [0.017440231516957283],\n", - " [0.008717508055269718],\n", - " [0.0007935233297757804],\n", - " [-0.0062926579266786575],\n", - " [-0.012489699758589268],\n", - " [-0.017752693966031075],\n", - " [-0.022039905190467834],\n", - " [-0.025310339406132698],\n", - " [-0.027522850781679153],\n", - " [-0.02864413894712925],\n", - " [-0.028636261820793152],\n", - " [-0.027461817488074303],\n", - " [-0.025094198063015938],\n", - " [-0.021501963958144188],\n", - " [-0.01666117273271084],\n", - " [-0.010549379512667656],\n", - " [-0.0031512363348156214],\n", - " [0.005550689995288849],\n", - " [0.01557850744575262],\n", - " [0.0269477516412735],\n", - " [0.039668019860982895],\n", - " [0.05374666675925255],\n", - " [0.06917425990104675],\n", - " [0.08594906330108643]]},\n", + " 'values': [[0.09802747517824173],\n", + " [0.08951050788164139],\n", + " [0.08058805018663406],\n", + " [0.07134129106998444],\n", + " [0.061860695481300354],\n", + " [0.05224946513772011],\n", + " [0.04260175675153732],\n", + " [0.03301765024662018],\n", + " [0.023611901327967644],\n", + " [0.014501909725368023],\n", + " [0.005805093329399824],\n", + " [-0.0023491019383072853],\n", + " [-0.00983006414026022],\n", + " [-0.016498161479830742],\n", + " [-0.022219574078917503],\n", + " [-0.02685215137898922],\n", + " [-0.03025209531188011],\n", + " [-0.03227457404136658],\n", + " [-0.03277384489774704],\n", + " [-0.03161216527223587],\n", + " [-0.028642289340496063],\n", + " [-0.023736337199807167],\n", + " [-0.016750289127230644],\n", + " [-0.007566493935883045],\n", + " [0.003936300985515118],\n", + " [0.01786847785115242],\n", + " [0.034319307655096054],\n", + " [0.05338161811232567],\n", + " [0.0751204714179039],\n", + " [0.09959813207387924]]},\n", " 'Fir_1': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.1427392214536667],\n", - " [0.12301896512508392],\n", - " [0.10386364161968231],\n", - " [0.08541157096624374],\n", - " [0.067807637155056],\n", - " [0.05117274075746536],\n", - " [0.0356372706592083],\n", - " [0.021306047216057777],\n", - " [0.008290489204227924],\n", - " [-0.0033239584881812334],\n", - " [-0.01345659326761961],\n", - " [-0.022042429074645042],\n", - " [-0.0290205255150795],\n", - " [-0.03433607891201973],\n", - " [-0.0379483625292778],\n", - " [-0.039820596575737],\n", - " [-0.03991835564374924],\n", - " [-0.03822482004761696],\n", - " [-0.034723911434412],\n", - " [-0.029411161318421364],\n", - " [-0.022280005738139153],\n", - " [-0.013314316049218178],\n", - " [-0.002528987592086196],\n", - " [0.010067971423268318],\n", - " [0.024462005123496056],\n", - " [0.040629029273986816],\n", - " [0.058531370013952255],\n", - " [0.07813094556331635],\n", - " [0.0993867963552475],\n", - " [0.12223705649375916]]},\n", + " 'values': [[0.0997484102845192],\n", + " [0.09273143112659454],\n", + " [0.0849885642528534],\n", + " [0.07660744339227676],\n", + " [0.06767811626195908],\n", + " [0.05830444395542145],\n", + " [0.04859663546085358],\n", + " [0.038675762712955475],\n", + " [0.02867215685546398],\n", + " [0.018722297623753548],\n", + " [0.008969542570412159],\n", + " [-0.00042398733785375953],\n", + " [-0.00928482972085476],\n", + " [-0.017420383170247078],\n", + " [-0.024636657908558846],\n", + " [-0.030706603080034256],\n", + " [-0.03540678322315216],\n", + " [-0.0384904183447361],\n", + " [-0.039715200662612915],\n", + " [-0.038816485553979874],\n", + " [-0.03554098308086395],\n", + " [-0.029626278206706047],\n", + " [-0.020816311240196228],\n", + " [-0.008872822858393192],\n", + " [0.006432283204048872],\n", + " [0.02530253678560257],\n", + " [0.04791589453816414],\n", + " [0.0744224265217781],\n", + " [0.10494514554738998],\n", + " [0.13957835733890533]]},\n", " 'Fir_2': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.10938374698162079],\n", - " [0.09061797708272934],\n", - " [0.07280146330595016],\n", - " [0.056053079664707184],\n", - " [0.040493905544281006],\n", - " [0.026224011555314064],\n", - " [0.01333017647266388],\n", - " [0.0018724965630099177],\n", - " [-0.008102686144411564],\n", - " [-0.016559626907110214],\n", - " [-0.02346815913915634],\n", - " [-0.028809096664190292],\n", - " [-0.032560765743255615],\n", - " [-0.034716006368398666],\n", - " [-0.03528342396020889],\n", - " [-0.03427677974104881],\n", - " [-0.03171294927597046],\n", - " [-0.02762974426150322],\n", - " [-0.022049762308597565],\n", - " [-0.014998081140220165],\n", - " [-0.006516933906823397],\n", - " [0.0033721455838531256],\n", - " [0.014631866477429867],\n", - " [0.027193831279873848],\n", - " [0.04097696393728256],\n", - " [0.0558808408677578],\n", - " [0.07182122021913528],\n", - " [0.08871165663003922],\n", - " [0.10644236207008362],\n", - " [0.12491162121295929]]},\n", + " 'values': [[0.11963307857513428],\n", + " [0.10635463893413544],\n", + " [0.0927838608622551],\n", + " [0.0791749432682991],\n", + " [0.06574243307113647],\n", + " [0.05266417935490608],\n", + " [0.04009338840842247],\n", + " [0.028152750805020332],\n", + " [0.016954297199845314],\n", + " [0.0066026002168655396],\n", + " [-0.002807801589369774],\n", + " [-0.011179376393556595],\n", + " [-0.018413569778203964],\n", + " [-0.024410946294665337],\n", + " [-0.0290751401335001],\n", + " [-0.032300543040037155],\n", + " [-0.03399139270186424],\n", + " [-0.03403117135167122],\n", + " [-0.032298214733600616],\n", + " [-0.028663042932748795],\n", + " [-0.023000774905085564],\n", + " [-0.015166865661740303],\n", + " [-0.005037392023950815],\n", + " [0.007529286667704582],\n", + " [0.022659236565232277],\n", + " [0.040454644709825516],\n", + " [0.06098685786128044],\n", + " [0.08429399132728577],\n", + " [0.11036428064107895],\n", + " [0.13915462791919708]]},\n", " 'Fir_3': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.0036230585537850857],\n", - " [-0.004523097071796656],\n", - " [-0.012088771909475327],\n", - " [-0.018920931965112686],\n", - " [-0.02491142973303795],\n", - " [-0.02999606356024742],\n", - " [-0.03411524370312691],\n", - " [-0.037209365516901016],\n", - " [-0.03924567624926567],\n", - " [-0.04020298644900322],\n", - " [-0.04009431600570679],\n", - " [-0.038932159543037415],\n", - " [-0.03675546124577522],\n", - " [-0.03358297795057297],\n", - " [-0.02942216768860817],\n", - " [-0.02427610754966736],\n", - " [-0.018167199566960335],\n", - " [-0.011154214851558208],\n", - " [-0.003286497201770544],\n", - " [0.005432578269392252],\n", - " [0.014995560050010681],\n", - " [0.025369716808199883],\n", - " [0.03655438497662544],\n", - " [0.04851684719324112],\n", - " [0.06117192655801773],\n", - " [0.07439995557069778],\n", - " [0.08807000517845154],\n", - " [0.10204608738422394],\n", - " [0.1161910891532898],\n", - " [0.1303706169128418]]},\n", + " 'values': [[0.13824495673179626],\n", + " [0.1250022053718567],\n", + " [0.11005709320306778],\n", + " [0.09411410242319107],\n", + " [0.07777073979377747],\n", + " [0.06150287017226219],\n", + " [0.04568269103765488],\n", + " [0.03060069866478443],\n", + " [0.01651027984917164],\n", + " [0.0035778339952230453],\n", + " [-0.008057180792093277],\n", + " [-0.01828882284462452],\n", + " [-0.027004370465874672],\n", + " [-0.03409358486533165],\n", + " [-0.039423320442438126],\n", + " [-0.04285605624318123],\n", + " [-0.044259652495384216],\n", + " [-0.04348904266953468],\n", + " [-0.040390919893980026],\n", + " [-0.03483203053474426],\n", + " [-0.026673845946788788],\n", + " [-0.015783220529556274],\n", + " [-0.0020225730258971453],\n", + " [0.01471050176769495],\n", + " [0.03452245146036148],\n", + " [0.05742526054382324],\n", + " [0.08334319293498993],\n", + " [0.1121019497513771],\n", + " [0.1434130221605301],\n", + " [0.1768960952758789]]},\n", " 'Fir_4': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07145543396472931],\n", - " [-0.07197658717632294],\n", - " [-0.07205136865377426],\n", - " [-0.07167045027017593],\n", - " [-0.07080260664224625],\n", - " [-0.06943180412054062],\n", - " [-0.06752004474401474],\n", - " [-0.06503090262413025],\n", - " [-0.061952151358127594],\n", - " [-0.05824064835906029],\n", - " [-0.0538783073425293],\n", - " [-0.048865217715501785],\n", - " [-0.043194953352212906],\n", - " [-0.03686324506998062],\n", - " [-0.029858842492103577],\n", - " [-0.022180814296007156],\n", - " [-0.013852321542799473],\n", - " [-0.004839311353862286],\n", - " [0.004870493896305561],\n", - " [0.01528953481465578],\n", - " [0.026417257264256477],\n", - " [0.03824439272284508],\n", - " [0.05075015127658844],\n", - " [0.0639011487364769],\n", - " [0.07768751680850983],\n", - " [0.09206417948007584],\n", - " [0.10697998106479645],\n", - " [0.12239029258489609],\n", - " [0.1382369101047516],\n", - " [0.1544647514820099]]},\n", + " 'values': [[0.14163683354854584],\n", + " [0.13477812707424164],\n", + " [0.12437953054904938],\n", + " [0.11116994917392731],\n", + " [0.09594038873910904],\n", + " [0.07944705337285995],\n", + " [0.06234145164489746],\n", + " [0.04513232037425041],\n", + " [0.028319664299488068],\n", + " [0.01236469391733408],\n", + " [-0.00239584781229496],\n", + " [-0.01567983254790306],\n", + " [-0.027264611795544624],\n", + " [-0.036951854825019836],\n", + " [-0.04454702138900757],\n", + " [-0.04983208328485489],\n", + " [-0.05261280760169029],\n", + " [-0.05267792195081711],\n", + " [-0.04981167986989021],\n", + " [-0.043814193457365036],\n", + " [-0.0344865657389164],\n", + " [-0.021592792123556137],\n", + " [-0.004865081515163183],\n", + " [0.01573905535042286],\n", + " [0.040348030626773834],\n", + " [0.06902886927127838],\n", + " [0.10181301832199097],\n", + " [0.13870728015899658],\n", + " [0.17962424457073212],\n", + " [0.22440935671329498]]},\n", " 'Fir_5': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.045466236770153046],\n", - " [-0.04941441863775253],\n", - " [-0.05296502634882927],\n", - " [-0.05606375262141228],\n", - " [-0.058626554906368256],\n", - " [-0.06060165911912918],\n", - " [-0.06190638244152069],\n", - " [-0.062493305653333664],\n", - " [-0.06230451539158821],\n", - " [-0.061295583844184875],\n", - " [-0.05942470207810402],\n", - " [-0.05663062259554863],\n", - " [-0.05284297093749046],\n", - " [-0.0480080246925354],\n", - " [-0.042047422379255295],\n", - " [-0.03488249331712723],\n", - " [-0.02648063562810421],\n", - " [-0.01678083837032318],\n", - " [-0.005733977071940899],\n", - " [0.006724357604980469],\n", - " [0.020640479400753975],\n", - " [0.036052487790584564],\n", - " [0.053023938089609146],\n", - " [0.07156147807836533],\n", - " [0.09169284254312515],\n", - " [0.11347538977861404],\n", - " [0.13692867755889893],\n", - " [0.16205839812755585],\n", - " [0.18890884518623352],\n", - " [0.21746642887592316]]},\n", + " 'values': [[0.07319375872612],\n", + " [0.07567604631185532],\n", + " [0.07507440447807312],\n", + " [0.07157206535339355],\n", + " [0.06549695879220963],\n", + " [0.05727209523320198],\n", + " [0.04734784737229347],\n", + " [0.03615500405430794],\n", + " [0.0241051334887743],\n", + " [0.01159927248954773],\n", + " [-0.0009354146895930171],\n", + " [-0.013040401041507721],\n", + " [-0.024295810610055923],\n", + " [-0.0342605784535408],\n", + " [-0.04246646538376808],\n", + " [-0.0484670028090477],\n", + " [-0.051901403814554214],\n", + " [-0.052417121827602386],\n", + " [-0.049710728228092194],\n", + " [-0.043444205075502396],\n", + " [-0.03335171565413475],\n", + " [-0.01911710575222969],\n", + " [-0.00044568898738361895],\n", + " [0.022811029106378555],\n", + " [0.050846029072999954],\n", + " [0.08385420590639114],\n", + " [0.1220158189535141],\n", + " [0.16550478339195251],\n", + " [0.2144814133644104],\n", + " [0.26906299591064453]]},\n", " 'Fir_6': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07760659605264664],\n", - " [-0.07570715248584747],\n", - " [-0.07353810220956802],\n", - " [-0.07119432836771011],\n", - " [-0.06875365227460861],\n", - " [-0.06626567989587784],\n", - " [-0.06372548639774323],\n", - " [-0.061116475611925125],\n", - " [-0.05833817645907402],\n", - " [-0.05532317981123924],\n", - " [-0.051966723054647446],\n", - " [-0.048134833574295044],\n", - " [-0.04368661344051361],\n", - " [-0.038527000695466995],\n", - " [-0.03244928643107414],\n", - " [-0.02543233335018158],\n", - " [-0.017468007281422615],\n", - " [-0.008501219563186169],\n", - " [0.001558795920573175],\n", - " [0.01286094356328249],\n", - " [0.02560839056968689],\n", - " [0.03990352153778076],\n", - " [0.05610361695289612],\n", - " [0.07430130988359451],\n", - " [0.09463302791118622],\n", - " [0.1173117607831955],\n", - " [0.1426011621952057],\n", - " [0.17061302065849304],\n", - " [0.20156458020210266],\n", - " [0.23558014631271362]]},\n", + " 'values': [[0.07161669433116913],\n", + " [0.08292372524738312],\n", + " [0.09161170572042465],\n", + " [0.09712497889995575],\n", + " [0.09898201376199722],\n", + " [0.09701229631900787],\n", + " [0.09127453714609146],\n", + " [0.08213011175394058],\n", + " [0.07017728686332703],\n", + " [0.05622842162847519],\n", + " [0.04102401062846184],\n", + " [0.0252744872123003],\n", + " [0.009648673236370087],\n", + " [-0.005155729129910469],\n", + " [-0.01857585646212101],\n", + " [-0.030165914446115494],\n", + " [-0.039713308215141296],\n", + " [-0.04692850634455681],\n", + " [-0.0515095517039299],\n", + " [-0.05299036204814911],\n", + " [-0.05066951364278793],\n", + " [-0.043506838381290436],\n", + " [-0.030119018629193306],\n", + " [-0.00887052807956934],\n", + " [0.02178552746772766],\n", + " [0.06318464130163193],\n", + " [0.11635182797908783],\n", + " [0.1820082664489746],\n", + " [0.2605421543121338],\n", + " [0.3519956171512604]]},\n", " 'Fir_7': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.06075132265686989],\n", - " [0.05622144788503647],\n", - " [0.04827791452407837],\n", - " [0.037901245057582855],\n", - " [0.02598106488585472],\n", - " [0.013368550688028336],\n", - " [0.0007360622403211892],\n", - " [-0.011336201801896095],\n", - " [-0.02228238433599472],\n", - " [-0.03168044239282608],\n", - " [-0.039212822914123535],\n", - " [-0.0446024127304554],\n", - " [-0.047832805663347244],\n", - " [-0.04878610372543335],\n", - " [-0.04709966853260994],\n", - " [-0.042434681206941605],\n", - " [-0.03468530252575874],\n", - " [-0.023747917264699936],\n", - " [-0.009678727015852928],\n", - " [0.0075911483727395535],\n", - " [0.02810771018266678],\n", - " [0.05173402652144432],\n", - " [0.07855863869190216],\n", - " [0.10853327810764313],\n", - " [0.14130747318267822],\n", - " [0.1765713095664978],\n", - " [0.21406440436840057],\n", - " [0.25343939661979675],\n", - " [0.2944483458995819],\n", - " [0.3369137942790985]]}},\n", + " 'values': [[0.15214180946350098],\n", + " [0.15814897418022156],\n", + " [0.15724048018455505],\n", + " [0.14980405569076538],\n", + " [0.13674023747444153],\n", + " [0.1191268190741539],\n", + " [0.09820308536291122],\n", + " [0.07500811666250229],\n", + " [0.05062484368681908],\n", + " [0.026210999116301537],\n", + " [0.0027045132592320442],\n", + " [-0.018744679167866707],\n", + " [-0.037157949060201645],\n", + " [-0.05177536606788635],\n", + " [-0.0621718131005764],\n", + " [-0.0680275559425354],\n", + " [-0.06923902034759521],\n", + " [-0.06568694114685059],\n", + " [-0.05714571103453636],\n", + " [-0.04337356239557266],\n", + " [-0.0242167841643095],\n", + " [0.00032957346411421895],\n", + " [0.03000686690211296],\n", + " [0.06464923173189163],\n", + " [0.10421786457300186],\n", + " [0.14867858588695526],\n", + " [0.19784015417099],\n", + " [0.2513589560985565],\n", + " [0.3087795078754425],\n", + " [0.36944523453712463]]}},\n", " 'Relations': {'Add34': ['Add', ['Mul12', 'Mul15']],\n", " 'Add35': ['Add', ['Add34', 'Mul18']],\n", " 'Add36': ['Add', ['Add35', 'Mul21']],\n", @@ -509,16 +524,16 @@ " 'Add71': ['Add', ['Add70', 'Mul67']],\n", " 'Add82': ['Add', ['SamplePart79', 'Mul81']],\n", " 'Add92': ['Add', ['SamplePart89', 'Mul91']],\n", - " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0.05],\n", - " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0.05],\n", - " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0.05],\n", - " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0.05],\n", - " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0.05],\n", - " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0.05],\n", - " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0.05],\n", - " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0.05],\n", - " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify7'],\n", - " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify8'],\n", + " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0],\n", + " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0],\n", + " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0],\n", + " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0],\n", + " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0],\n", + " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0],\n", + " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0],\n", + " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0],\n", + " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify6'],\n", + " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify7'],\n", " 'Mul12': ['Mul', ['Fir10', 'Select11']],\n", " 'Mul15': ['Mul', ['Fir13', 'Select14']],\n", " 'Mul18': ['Mul', ['Fir16', 'Select17']],\n", @@ -541,19 +556,19 @@ " 'Mul91': ['Mul', ['Mul87', 'SampleTime']],\n", " 'ParamFun43': ['ParamFun',\n", " ['SamplePart42', 'A_0'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun48': ['ParamFun',\n", " ['SamplePart42', 'A_1'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun53': ['ParamFun',\n", " ['SamplePart42', 'A_2'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun58': ['ParamFun',\n", " ['SamplePart42', 'A_3'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun63': ['ParamFun',\n", " ['SamplePart42', 'A_4'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'SamplePart1': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", " 'SamplePart4': ['SamplePart', ['model_ax_in'], -1, [-1, 0]],\n", " 'SamplePart42': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", @@ -576,152 +591,205 @@ " 'Select51': ['Select', ['Fuzzify5'], 5, 1],\n", " 'Select56': ['Select', ['Fuzzify5'], 5, 2],\n", " 'Select61': ['Select', ['Fuzzify5'], 5, 3],\n", - " 'Select66': ['Select', ['Fuzzify5'], 5, 4]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'Select66': ['Select', ['Fuzzify5'], 5, 4]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 3 + "source": [ + "lat_dyna_control.loadModel(\"vehicle_model\")\n", + "lat_dyna_control.neuralizeModel()" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Model definition", - "id": "b6ef5ba231c37df3" + "id": "b6ef5ba231c37df3", + "metadata": {}, + "source": [ + "### Model definition" + ] }, { + "cell_type": "code", + "execution_count": 4, + "id": "a7afd97b064ac3e", "metadata": { "ExecuteTime": { - "end_time": "2025-12-09T19:50:34.845708Z", - "start_time": "2025-12-09T19:50:34.590258Z" + "end_time": "2025-12-09T21:58:19.081774Z", + "start_time": "2025-12-09T21:58:18.967587Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "# ----------------------------------------------------------------\n", "# Inputs\n", "# ----------------------------------------------------------------\n", - "curv_in = Input('controller_curv_in') # [1/m] path curvature\n", - "vx_in = Input('controller_vx_in') # [m/s] longitudinal velocity\n", - "steer_in = Input('controller_steer_in') # [rad] steering wheel angle\n", - "ax_in = Input('controller_ax_in') # [m/s^2] longitudinal acceleration\n", + "curv_in = Input(\"controller_curv_in\") # [1/m] path curvature\n", + "vx_in = Input(\"controller_vx_in\") # [m/s] longitudinal velocity\n", + "steer_in = Input(\"controller_steer_in\") # [rad] steering wheel angle\n", + "ax_in = Input(\"controller_ax_in\") # [m/s^2] longitudinal acceleration\n", "\n", "# ----------------------------------------------------------------\n", "# Hyperparameters\n", "# ----------------------------------------------------------------\n", - "samples_past_steer = 30 # number of samples in the past for the steering wheel angle prediction\n", + "samples_past_steer = (\n", + " 30 # number of samples in the past for the steering wheel angle prediction\n", + ")\n", "samples_prediction = 30 # number of samples for future manoeuvre\n", - "n_channels_vx = 8 # number of channels for activation function vx\n", - "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", - "chan_ax = [-2,-1,0.0,1.0,2.0] # centers of the channels ax\n", + "n_channels_vx = 8 # number of channels for activation function vx\n", + "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", + "chan_ax = [-2, -1, 0.0, 1.0, 2.0] # centers of the channels ax\n", "\n", "# Exponential weights for normalisation of FIR parameters during training\n", - "W_prev = np.flip(np.array([[np.exp(-(i/(samples_prediction/2))**2)] for i in range(-samples_prediction+1,1)]))\n", - "W_past = np.array([[np.exp(-(i/(samples_past_steer/2))**2)] for i in range(-samples_past_steer+2,1)])\n", + "W_prev = np.flip(\n", + " np.array(\n", + " [\n", + " [np.exp(-((i / (samples_prediction / 2)) ** 2))]\n", + " for i in range(-samples_prediction + 1, 1)\n", + " ]\n", + " )\n", + ")\n", + "W_past = np.array(\n", + " [\n", + " [np.exp(-((i / (samples_past_steer / 2)) ** 2))]\n", + " for i in range(-samples_past_steer + 2, 1)\n", + " ]\n", + ")\n", + "\n", + "W_fir_init = Constant(\"W_fir_init\", sw=(samples_past_steer - 1), values=W_past)\n", + "W_fir_target = Constant(\"W_fir_target\", sw=samples_prediction, values=W_prev)\n", "\n", - "W_fir_init = Constant('W_fir_init', sw = (samples_past_steer-1), values=W_past)\n", - "W_fir_target = Constant('W_fir_target', sw =samples_prediction, values=W_prev)\n", "\n", "# ----------------------------------------------------------------\n", "# Understeer correction function\n", "# ----------------------------------------------------------------\n", - "def understeer_corr_local_control(vx,curv, # inputs\n", - " A, # constant\n", - " ):\n", + "def understeer_corr_local_control(\n", + " vx,\n", + " curv, # inputs\n", + " A, # constant\n", + "):\n", " return curv * (1 + A * torch.pow(vx, 2))\n", "\n", + "\n", "understeer_corr = ParamFun(understeer_corr_local_control)\n", "\n", "# ----------------------------------------------------------------\n", "# Local models\n", "# ----------------------------------------------------------------\n", "# Activation functions\n", - "activ_fnc_ax = Fuzzify(centers=chan_ax, functions='Triangular')(ax_in.last())\n", - "activ_fnc_vx = Fuzzify(centers=chan_vx, functions='Triangular')(vx_in.last())\n", + "activ_fnc_ax = Fuzzify(centers=chan_ax, functions=\"Triangular\")(ax_in.last())\n", + "activ_fnc_vx = Fuzzify(centers=chan_vx, functions=\"Triangular\")(vx_in.last())\n", "\n", "# Understeer coefficient: the value of the constant is taken by the model and is function of the acceleration ax\n", - "A = Constant('A',values=[lat_dyna_control.parameters['A_0'][0][0],lat_dyna_control.parameters['A_1'][0][0],lat_dyna_control.parameters['A_2'][0][0],lat_dyna_control.parameters['A_3'][0][0],lat_dyna_control.parameters['A_4'][0][0]])\n", - "A_ax = Sum( activ_fnc_ax * A ) # Constant A function of ax\n", + "A = Constant(\n", + " \"A\",\n", + " values=[\n", + " lat_dyna_control.parameters[\"A_0\"][0][0],\n", + " lat_dyna_control.parameters[\"A_1\"][0][0],\n", + " lat_dyna_control.parameters[\"A_2\"][0][0],\n", + " lat_dyna_control.parameters[\"A_3\"][0][0],\n", + " lat_dyna_control.parameters[\"A_4\"][0][0],\n", + " ],\n", + ")\n", + "A_ax = Sum(activ_fnc_ax * A) # Constant A function of ax\n", "\n", "# FIR target trajectory\n", - "local_model_target = LocalModel(pass_indexes=True,\n", - " input_function=lambda idx: Fir(output_dimension=1,W_init = 'init_constant',W_init_params={\"value\": 0.01}, W=f'Fir_target_{idx[0]}'))\n", + "local_model_target = LocalModel(\n", + " pass_indexes=True,\n", + " input_function=lambda idx: Fir(\n", + " output_dimension=1,\n", + " W_init=\"init_constant\",\n", + " W_init_params={\"value\": 0.01},\n", + " W=f\"Fir_target_{idx[0]}\",\n", + " ),\n", + ")\n", "# FIR initial condition\n", - "delta_ic = Fir(output_dimension=1, W=\"Fir_InitCondition\", W_init=\"init_constant\", W_init_params={\"value\": 0.01})(steer_in.sw([-samples_past_steer,-1])*W_fir_init)\n", + "delta_ic = Fir(\n", + " output_dimension=1,\n", + " W=\"Fir_InitCondition\",\n", + " W_init=\"init_constant\",\n", + " W_init_params={\"value\": 0.01},\n", + ")(steer_in.sw([-samples_past_steer, -1]) * W_fir_init)\n", "\n", "# Understeer correction\n", - "out = understeer_corr( vx_in.sw([-1,(samples_prediction-1)]),curv_in.sw([-1,(samples_prediction-1)]), A_ax )\n", + "out = understeer_corr(\n", + " vx_in.sw([-1, (samples_prediction - 1)]),\n", + " curv_in.sw([-1, (samples_prediction - 1)]),\n", + " A_ax,\n", + ")\n", "\n", "# Local model\n", - "delta_target = local_model_target(out*W_fir_target , activ_fnc_vx)\n", + "delta_target = local_model_target(out * W_fir_target, activ_fnc_vx)\n", "\n", "# NN output\n", - "delta = delta_target + delta_ic\n", + "delta = delta_target + delta_ic\n", "\n", "# ----------------------------------------------------------------\n", "# Outputs\n", "# ----------------------------------------------------------------\n", - "steer_from_target = Output('controller_steer_from_target',delta_target)\n", - "steer_from_ic = Output('controller_steer_from_ic',delta_ic)\n", - "steer_control = Output('controller_steer_out',delta)\n", + "steer_from_target = Output(\"controller_steer_from_target\", delta_target)\n", + "steer_from_ic = Output(\"controller_steer_from_ic\", delta_ic)\n", + "steer_control = Output(\"controller_steer_out\", delta)\n", "\n", "# ----------------------------------------------------------------\n", "# Add controller model and connect to the vehicle model\n", "# ----------------------------------------------------------------\n", - "lat_dyna_control.addModel('control_steer',[steer_from_target,steer_from_ic,steer_control])\n", - "lat_dyna_control.addClosedLoop(steer_control,steer_in)\n", - "lat_dyna_control.addConnect(steer_control,'model_steer_in')" - ], - "id": "a7afd97b064ac3e", - "outputs": [], - "execution_count": 4 + "lat_dyna_control.addModel(\n", + " \"control_steer\", [steer_from_target, steer_from_ic, steer_control]\n", + ")\n", + "lat_dyna_control.addClosedLoop(steer_control, steer_in)\n", + "lat_dyna_control.addConnect(steer_control, \"model_steer_in\")" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Loss functions definitions", - "id": "deaac585e4481143" + "id": "deaac585e4481143", + "metadata": {}, + "source": [ + "### Loss functions definitions" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "The loss functions are the same used for the training of the vehicle model: mse error on curvature value and mse value on heading value.", - "id": "1ee10f3e9472c0e3" + "id": "1ee10f3e9472c0e3", + "metadata": {}, + "source": [ + "The loss functions are the same used for the training of the vehicle model: mse error on curvature value and mse value on heading value." + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Model neuralization", - "id": "5a60203dc386c863" + "id": "5a60203dc386c863", + "metadata": {}, + "source": [ + "### Model neuralization" + ] }, { + "cell_type": "code", + "execution_count": 5, + "id": "c909f3d5f6b02813", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T19:50:34.888875Z", "start_time": "2025-12-09T19:50:34.852077Z" } }, - "cell_type": "code", - "source": [ - "# Generate the model\n", - "lat_dyna_control.neuralizeModel(sample_time=0.05) # neuralize the model with the chosen sample time" - ], - "id": "c909f3d5f6b02813", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001B[0m\n", - "\u001B[33m[neuralizeModel] Connect on model_steer_in with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {'A': {'dim': 5,\n", - " 'values': [0.12241744995117188,\n", - " 0.13215704262256622,\n", - " 0.13487723469734192,\n", - " 0.13838686048984528,\n", - " 0.14319394528865814]},\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001b[0m\n", + "\u001b[33m[neuralizeModel] Connect on model_steer_in with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {'A': {'dim': 5,\n", + " 'values': [0.10271348804235458,\n", + " 0.11061573028564453,\n", + " 0.11115050315856934,\n", + " 0.11318214982748032,\n", + " 0.11924726516008377]},\n", " 'SampleTime': {'dim': 1, 'values': 0.05},\n", " 'W_fir': {'dim': 1,\n", " 'sw': 30,\n", @@ -833,7 +901,7 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify7': {'centers': [8.0,\n", + " 'FFuzzify6': {'centers': [8.0,\n", " 10.142857142857142,\n", " 12.285714285714285,\n", " 14.428571428571429,\n", @@ -844,7 +912,7 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify8': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", + " 'FFuzzify7': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", " 'dim_out': {'dim': 5},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", @@ -863,7 +931,7 @@ " 'n_input': 3,\n", " 'name': 'understeer_corr_local_control',\n", " 'params_and_consts': []},\n", - " 'FParamFun6': {'code': 'def understeer_corr_local(vx, # input\\n'\n", + " 'FParamFun5': {'code': 'def understeer_corr_local(vx, # input\\n'\n", " ' A # '\n", " 'learnable parameter\\n'\n", " ' ):\\n'\n", @@ -875,7 +943,7 @@ " 'name': 'understeer_corr_local',\n", " 'params_and_consts': []}},\n", " 'Info': {'SampleTime': 0.05,\n", - " 'nnodely_version': '1.5.2',\n", + " 'nnodely_version': '1.5.4',\n", " 'ns': [30, 29],\n", " 'ntot': 59,\n", " 'num_parameters': 514},\n", @@ -988,9 +1056,9 @@ " 'Add147',\n", " 'Add148']},\n", " 'vehicle_model': {'Constants': ['SampleTime', 'W_fir'],\n", - " 'Functions': ['FFuzzify7',\n", - " 'FFuzzify8',\n", - " 'FParamFun6'],\n", + " 'Functions': ['FFuzzify6',\n", + " 'FFuzzify7',\n", + " 'FParamFun5'],\n", " 'Inputs': ['Mul77_int33',\n", " 'Mul87_int34',\n", " 'model_ax_in',\n", @@ -1088,291 +1156,291 @@ " 'model_curv': 'Mul72'},\n", " 'Parameters': {'A_0': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.12241744995117188]]},\n", + " 'values': [[0.10271348804235458]]},\n", " 'A_1': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13215704262256622]]},\n", + " 'values': [[0.11061573028564453]]},\n", " 'A_2': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13487723469734192]]},\n", + " 'values': [[0.11115050315856934]]},\n", " 'A_3': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13838686048984528]]},\n", + " 'values': [[0.11318214982748032]]},\n", " 'A_4': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.14319394528865814]]},\n", + " 'values': [[0.11924726516008377]]},\n", " 'Fir_0': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.08373943716287613],\n", - " [0.07128263264894485],\n", - " [0.05931668356060982],\n", - " [0.047899674624204636],\n", - " [0.03708196431398392],\n", - " [0.026911072432994843],\n", - " [0.017440231516957283],\n", - " [0.008717508055269718],\n", - " [0.0007935233297757804],\n", - " [-0.0062926579266786575],\n", - " [-0.012489699758589268],\n", - " [-0.017752693966031075],\n", - " [-0.022039905190467834],\n", - " [-0.025310339406132698],\n", - " [-0.027522850781679153],\n", - " [-0.02864413894712925],\n", - " [-0.028636261820793152],\n", - " [-0.027461817488074303],\n", - " [-0.025094198063015938],\n", - " [-0.021501963958144188],\n", - " [-0.01666117273271084],\n", - " [-0.010549379512667656],\n", - " [-0.0031512363348156214],\n", - " [0.005550689995288849],\n", - " [0.01557850744575262],\n", - " [0.0269477516412735],\n", - " [0.039668019860982895],\n", - " [0.05374666675925255],\n", - " [0.06917425990104675],\n", - " [0.08594906330108643]]},\n", + " 'values': [[0.09802747517824173],\n", + " [0.08951050788164139],\n", + " [0.08058805018663406],\n", + " [0.07134129106998444],\n", + " [0.061860695481300354],\n", + " [0.05224946513772011],\n", + " [0.04260175675153732],\n", + " [0.03301765024662018],\n", + " [0.023611901327967644],\n", + " [0.014501909725368023],\n", + " [0.005805093329399824],\n", + " [-0.0023491019383072853],\n", + " [-0.00983006414026022],\n", + " [-0.016498161479830742],\n", + " [-0.022219574078917503],\n", + " [-0.02685215137898922],\n", + " [-0.03025209531188011],\n", + " [-0.03227457404136658],\n", + " [-0.03277384489774704],\n", + " [-0.03161216527223587],\n", + " [-0.028642289340496063],\n", + " [-0.023736337199807167],\n", + " [-0.016750289127230644],\n", + " [-0.007566493935883045],\n", + " [0.003936300985515118],\n", + " [0.01786847785115242],\n", + " [0.034319307655096054],\n", + " [0.05338161811232567],\n", + " [0.0751204714179039],\n", + " [0.09959813207387924]]},\n", " 'Fir_1': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.1427392214536667],\n", - " [0.12301896512508392],\n", - " [0.10386364161968231],\n", - " [0.08541157096624374],\n", - " [0.067807637155056],\n", - " [0.05117274075746536],\n", - " [0.0356372706592083],\n", - " [0.021306047216057777],\n", - " [0.008290489204227924],\n", - " [-0.0033239584881812334],\n", - " [-0.01345659326761961],\n", - " [-0.022042429074645042],\n", - " [-0.0290205255150795],\n", - " [-0.03433607891201973],\n", - " [-0.0379483625292778],\n", - " [-0.039820596575737],\n", - " [-0.03991835564374924],\n", - " [-0.03822482004761696],\n", - " [-0.034723911434412],\n", - " [-0.029411161318421364],\n", - " [-0.022280005738139153],\n", - " [-0.013314316049218178],\n", - " [-0.002528987592086196],\n", - " [0.010067971423268318],\n", - " [0.024462005123496056],\n", - " [0.040629029273986816],\n", - " [0.058531370013952255],\n", - " [0.07813094556331635],\n", - " [0.0993867963552475],\n", - " [0.12223705649375916]]},\n", + " 'values': [[0.0997484102845192],\n", + " [0.09273143112659454],\n", + " [0.0849885642528534],\n", + " [0.07660744339227676],\n", + " [0.06767811626195908],\n", + " [0.05830444395542145],\n", + " [0.04859663546085358],\n", + " [0.038675762712955475],\n", + " [0.02867215685546398],\n", + " [0.018722297623753548],\n", + " [0.008969542570412159],\n", + " [-0.00042398733785375953],\n", + " [-0.00928482972085476],\n", + " [-0.017420383170247078],\n", + " [-0.024636657908558846],\n", + " [-0.030706603080034256],\n", + " [-0.03540678322315216],\n", + " [-0.0384904183447361],\n", + " [-0.039715200662612915],\n", + " [-0.038816485553979874],\n", + " [-0.03554098308086395],\n", + " [-0.029626278206706047],\n", + " [-0.020816311240196228],\n", + " [-0.008872822858393192],\n", + " [0.006432283204048872],\n", + " [0.02530253678560257],\n", + " [0.04791589453816414],\n", + " [0.0744224265217781],\n", + " [0.10494514554738998],\n", + " [0.13957835733890533]]},\n", " 'Fir_2': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.10938374698162079],\n", - " [0.09061797708272934],\n", - " [0.07280146330595016],\n", - " [0.056053079664707184],\n", - " [0.040493905544281006],\n", - " [0.026224011555314064],\n", - " [0.01333017647266388],\n", - " [0.0018724965630099177],\n", - " [-0.008102686144411564],\n", - " [-0.016559626907110214],\n", - " [-0.02346815913915634],\n", - " [-0.028809096664190292],\n", - " [-0.032560765743255615],\n", - " [-0.034716006368398666],\n", - " [-0.03528342396020889],\n", - " [-0.03427677974104881],\n", - " [-0.03171294927597046],\n", - " [-0.02762974426150322],\n", - " [-0.022049762308597565],\n", - " [-0.014998081140220165],\n", - " [-0.006516933906823397],\n", - " [0.0033721455838531256],\n", - " [0.014631866477429867],\n", - " [0.027193831279873848],\n", - " [0.04097696393728256],\n", - " [0.0558808408677578],\n", - " [0.07182122021913528],\n", - " [0.08871165663003922],\n", - " [0.10644236207008362],\n", - " [0.12491162121295929]]},\n", + " 'values': [[0.11963307857513428],\n", + " [0.10635463893413544],\n", + " [0.0927838608622551],\n", + " [0.0791749432682991],\n", + " [0.06574243307113647],\n", + " [0.05266417935490608],\n", + " [0.04009338840842247],\n", + " [0.028152750805020332],\n", + " [0.016954297199845314],\n", + " [0.0066026002168655396],\n", + " [-0.002807801589369774],\n", + " [-0.011179376393556595],\n", + " [-0.018413569778203964],\n", + " [-0.024410946294665337],\n", + " [-0.0290751401335001],\n", + " [-0.032300543040037155],\n", + " [-0.03399139270186424],\n", + " [-0.03403117135167122],\n", + " [-0.032298214733600616],\n", + " [-0.028663042932748795],\n", + " [-0.023000774905085564],\n", + " [-0.015166865661740303],\n", + " [-0.005037392023950815],\n", + " [0.007529286667704582],\n", + " [0.022659236565232277],\n", + " [0.040454644709825516],\n", + " [0.06098685786128044],\n", + " [0.08429399132728577],\n", + " [0.11036428064107895],\n", + " [0.13915462791919708]]},\n", " 'Fir_3': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.0036230585537850857],\n", - " [-0.004523097071796656],\n", - " [-0.012088771909475327],\n", - " [-0.018920931965112686],\n", - " [-0.02491142973303795],\n", - " [-0.02999606356024742],\n", - " [-0.03411524370312691],\n", - " [-0.037209365516901016],\n", - " [-0.03924567624926567],\n", - " [-0.04020298644900322],\n", - " [-0.04009431600570679],\n", - " [-0.038932159543037415],\n", - " [-0.03675546124577522],\n", - " [-0.03358297795057297],\n", - " [-0.02942216768860817],\n", - " [-0.02427610754966736],\n", - " [-0.018167199566960335],\n", - " [-0.011154214851558208],\n", - " [-0.003286497201770544],\n", - " [0.005432578269392252],\n", - " [0.014995560050010681],\n", - " [0.025369716808199883],\n", - " [0.03655438497662544],\n", - " [0.04851684719324112],\n", - " [0.06117192655801773],\n", - " [0.07439995557069778],\n", - " [0.08807000517845154],\n", - " [0.10204608738422394],\n", - " [0.1161910891532898],\n", - " [0.1303706169128418]]},\n", + " 'values': [[0.13824495673179626],\n", + " [0.1250022053718567],\n", + " [0.11005709320306778],\n", + " [0.09411410242319107],\n", + " [0.07777073979377747],\n", + " [0.06150287017226219],\n", + " [0.04568269103765488],\n", + " [0.03060069866478443],\n", + " [0.01651027984917164],\n", + " [0.0035778339952230453],\n", + " [-0.008057180792093277],\n", + " [-0.01828882284462452],\n", + " [-0.027004370465874672],\n", + " [-0.03409358486533165],\n", + " [-0.039423320442438126],\n", + " [-0.04285605624318123],\n", + " [-0.044259652495384216],\n", + " [-0.04348904266953468],\n", + " [-0.040390919893980026],\n", + " [-0.03483203053474426],\n", + " [-0.026673845946788788],\n", + " [-0.015783220529556274],\n", + " [-0.0020225730258971453],\n", + " [0.01471050176769495],\n", + " [0.03452245146036148],\n", + " [0.05742526054382324],\n", + " [0.08334319293498993],\n", + " [0.1121019497513771],\n", + " [0.1434130221605301],\n", + " [0.1768960952758789]]},\n", " 'Fir_4': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07145543396472931],\n", - " [-0.07197658717632294],\n", - " [-0.07205136865377426],\n", - " [-0.07167045027017593],\n", - " [-0.07080260664224625],\n", - " [-0.06943180412054062],\n", - " [-0.06752004474401474],\n", - " [-0.06503090262413025],\n", - " [-0.061952151358127594],\n", - " [-0.05824064835906029],\n", - " [-0.0538783073425293],\n", - " [-0.048865217715501785],\n", - " [-0.043194953352212906],\n", - " [-0.03686324506998062],\n", - " [-0.029858842492103577],\n", - " [-0.022180814296007156],\n", - " [-0.013852321542799473],\n", - " [-0.004839311353862286],\n", - " [0.004870493896305561],\n", - " [0.01528953481465578],\n", - " [0.026417257264256477],\n", - " [0.03824439272284508],\n", - " [0.05075015127658844],\n", - " [0.0639011487364769],\n", - " [0.07768751680850983],\n", - " [0.09206417948007584],\n", - " [0.10697998106479645],\n", - " [0.12239029258489609],\n", - " [0.1382369101047516],\n", - " [0.1544647514820099]]},\n", + " 'values': [[0.14163683354854584],\n", + " [0.13477812707424164],\n", + " [0.12437953054904938],\n", + " [0.11116994917392731],\n", + " [0.09594038873910904],\n", + " [0.07944705337285995],\n", + " [0.06234145164489746],\n", + " [0.04513232037425041],\n", + " [0.028319664299488068],\n", + " [0.01236469391733408],\n", + " [-0.00239584781229496],\n", + " [-0.01567983254790306],\n", + " [-0.027264611795544624],\n", + " [-0.036951854825019836],\n", + " [-0.04454702138900757],\n", + " [-0.04983208328485489],\n", + " [-0.05261280760169029],\n", + " [-0.05267792195081711],\n", + " [-0.04981167986989021],\n", + " [-0.043814193457365036],\n", + " [-0.0344865657389164],\n", + " [-0.021592792123556137],\n", + " [-0.004865081515163183],\n", + " [0.01573905535042286],\n", + " [0.040348030626773834],\n", + " [0.06902886927127838],\n", + " [0.10181301832199097],\n", + " [0.13870728015899658],\n", + " [0.17962424457073212],\n", + " [0.22440935671329498]]},\n", " 'Fir_5': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.045466236770153046],\n", - " [-0.04941441863775253],\n", - " [-0.05296502634882927],\n", - " [-0.05606375262141228],\n", - " [-0.058626554906368256],\n", - " [-0.06060165911912918],\n", - " [-0.06190638244152069],\n", - " [-0.062493305653333664],\n", - " [-0.06230451539158821],\n", - " [-0.061295583844184875],\n", - " [-0.05942470207810402],\n", - " [-0.05663062259554863],\n", - " [-0.05284297093749046],\n", - " [-0.0480080246925354],\n", - " [-0.042047422379255295],\n", - " [-0.03488249331712723],\n", - " [-0.02648063562810421],\n", - " [-0.01678083837032318],\n", - " [-0.005733977071940899],\n", - " [0.006724357604980469],\n", - " [0.020640479400753975],\n", - " [0.036052487790584564],\n", - " [0.053023938089609146],\n", - " [0.07156147807836533],\n", - " [0.09169284254312515],\n", - " [0.11347538977861404],\n", - " [0.13692867755889893],\n", - " [0.16205839812755585],\n", - " [0.18890884518623352],\n", - " [0.21746642887592316]]},\n", + " 'values': [[0.07319375872612],\n", + " [0.07567604631185532],\n", + " [0.07507440447807312],\n", + " [0.07157206535339355],\n", + " [0.06549695879220963],\n", + " [0.05727209523320198],\n", + " [0.04734784737229347],\n", + " [0.03615500405430794],\n", + " [0.0241051334887743],\n", + " [0.01159927248954773],\n", + " [-0.0009354146895930171],\n", + " [-0.013040401041507721],\n", + " [-0.024295810610055923],\n", + " [-0.0342605784535408],\n", + " [-0.04246646538376808],\n", + " [-0.0484670028090477],\n", + " [-0.051901403814554214],\n", + " [-0.052417121827602386],\n", + " [-0.049710728228092194],\n", + " [-0.043444205075502396],\n", + " [-0.03335171565413475],\n", + " [-0.01911710575222969],\n", + " [-0.00044568898738361895],\n", + " [0.022811029106378555],\n", + " [0.050846029072999954],\n", + " [0.08385420590639114],\n", + " [0.1220158189535141],\n", + " [0.16550478339195251],\n", + " [0.2144814133644104],\n", + " [0.26906299591064453]]},\n", " 'Fir_6': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07760659605264664],\n", - " [-0.07570715248584747],\n", - " [-0.07353810220956802],\n", - " [-0.07119432836771011],\n", - " [-0.06875365227460861],\n", - " [-0.06626567989587784],\n", - " [-0.06372548639774323],\n", - " [-0.061116475611925125],\n", - " [-0.05833817645907402],\n", - " [-0.05532317981123924],\n", - " [-0.051966723054647446],\n", - " [-0.048134833574295044],\n", - " [-0.04368661344051361],\n", - " [-0.038527000695466995],\n", - " [-0.03244928643107414],\n", - " [-0.02543233335018158],\n", - " [-0.017468007281422615],\n", - " [-0.008501219563186169],\n", - " [0.001558795920573175],\n", - " [0.01286094356328249],\n", - " [0.02560839056968689],\n", - " [0.03990352153778076],\n", - " [0.05610361695289612],\n", - " [0.07430130988359451],\n", - " [0.09463302791118622],\n", - " [0.1173117607831955],\n", - " [0.1426011621952057],\n", - " [0.17061302065849304],\n", - " [0.20156458020210266],\n", - " [0.23558014631271362]]},\n", + " 'values': [[0.07161669433116913],\n", + " [0.08292372524738312],\n", + " [0.09161170572042465],\n", + " [0.09712497889995575],\n", + " [0.09898201376199722],\n", + " [0.09701229631900787],\n", + " [0.09127453714609146],\n", + " [0.08213011175394058],\n", + " [0.07017728686332703],\n", + " [0.05622842162847519],\n", + " [0.04102401062846184],\n", + " [0.0252744872123003],\n", + " [0.009648673236370087],\n", + " [-0.005155729129910469],\n", + " [-0.01857585646212101],\n", + " [-0.030165914446115494],\n", + " [-0.039713308215141296],\n", + " [-0.04692850634455681],\n", + " [-0.0515095517039299],\n", + " [-0.05299036204814911],\n", + " [-0.05066951364278793],\n", + " [-0.043506838381290436],\n", + " [-0.030119018629193306],\n", + " [-0.00887052807956934],\n", + " [0.02178552746772766],\n", + " [0.06318464130163193],\n", + " [0.11635182797908783],\n", + " [0.1820082664489746],\n", + " [0.2605421543121338],\n", + " [0.3519956171512604]]},\n", " 'Fir_7': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.06075132265686989],\n", - " [0.05622144788503647],\n", - " [0.04827791452407837],\n", - " [0.037901245057582855],\n", - " [0.02598106488585472],\n", - " [0.013368550688028336],\n", - " [0.0007360622403211892],\n", - " [-0.011336201801896095],\n", - " [-0.02228238433599472],\n", - " [-0.03168044239282608],\n", - " [-0.039212822914123535],\n", - " [-0.0446024127304554],\n", - " [-0.047832805663347244],\n", - " [-0.04878610372543335],\n", - " [-0.04709966853260994],\n", - " [-0.042434681206941605],\n", - " [-0.03468530252575874],\n", - " [-0.023747917264699936],\n", - " [-0.009678727015852928],\n", - " [0.0075911483727395535],\n", - " [0.02810771018266678],\n", - " [0.05173402652144432],\n", - " [0.07855863869190216],\n", - " [0.10853327810764313],\n", - " [0.14130747318267822],\n", - " [0.1765713095664978],\n", - " [0.21406440436840057],\n", - " [0.25343939661979675],\n", - " [0.2944483458995819],\n", - " [0.3369137942790985]]},\n", + " 'values': [[0.15214180946350098],\n", + " [0.15814897418022156],\n", + " [0.15724048018455505],\n", + " [0.14980405569076538],\n", + " [0.13674023747444153],\n", + " [0.1191268190741539],\n", + " [0.09820308536291122],\n", + " [0.07500811666250229],\n", + " [0.05062484368681908],\n", + " [0.026210999116301537],\n", + " [0.0027045132592320442],\n", + " [-0.018744679167866707],\n", + " [-0.037157949060201645],\n", + " [-0.05177536606788635],\n", + " [-0.0621718131005764],\n", + " [-0.0680275559425354],\n", + " [-0.06923902034759521],\n", + " [-0.06568694114685059],\n", + " [-0.05714571103453636],\n", + " [-0.04337356239557266],\n", + " [-0.0242167841643095],\n", + " [0.00032957346411421895],\n", + " [0.03000686690211296],\n", + " [0.06464923173189163],\n", + " [0.10421786457300186],\n", + " [0.14867858588695526],\n", + " [0.19784015417099],\n", + " [0.2513589560985565],\n", + " [0.3087795078754425],\n", + " [0.36944523453712463]]},\n", " 'Fir_InitCondition': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", @@ -1699,26 +1767,26 @@ " 'Add71': ['Add', ['Add70', 'Mul67']],\n", " 'Add82': ['Add', ['SamplePart79', 'Mul81']],\n", " 'Add92': ['Add', ['SamplePart89', 'Mul91']],\n", - " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0.05],\n", + " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0],\n", " 'Fir109': ['Fir', ['Mul108'], 'Fir_InitCondition', None, 0],\n", " 'Fir117': ['Fir', ['Mul116'], 'Fir_target_0', None, 0],\n", " 'Fir120': ['Fir', ['Mul116'], 'Fir_target_1', None, 0],\n", " 'Fir123': ['Fir', ['Mul116'], 'Fir_target_2', None, 0],\n", " 'Fir126': ['Fir', ['Mul116'], 'Fir_target_3', None, 0],\n", " 'Fir129': ['Fir', ['Mul116'], 'Fir_target_4', None, 0],\n", - " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0.05],\n", + " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0],\n", " 'Fir132': ['Fir', ['Mul116'], 'Fir_target_5', None, 0],\n", " 'Fir135': ['Fir', ['Mul116'], 'Fir_target_6', None, 0],\n", " 'Fir138': ['Fir', ['Mul116'], 'Fir_target_7', None, 0],\n", - " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0.05],\n", - " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0.05],\n", - " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0.05],\n", - " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0.05],\n", - " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0.05],\n", - " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0.05],\n", + " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0],\n", + " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0],\n", + " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0],\n", + " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0],\n", + " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0],\n", + " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0],\n", " 'Fuzzify101': ['Fuzzify', ['SamplePart100'], 'FFuzzify105'],\n", - " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify7'],\n", - " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify8'],\n", + " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify6'],\n", + " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify7'],\n", " 'Fuzzify98': ['Fuzzify', ['SamplePart97'], 'FFuzzify104'],\n", " 'Mul103': ['Mul', ['Fuzzify98', 'A']],\n", " 'Mul108': ['Mul', ['SamplePart106', 'W_fir_init']],\n", @@ -1756,19 +1824,19 @@ " 'FParamFun103'],\n", " 'ParamFun43': ['ParamFun',\n", " ['SamplePart42', 'A_0'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun48': ['ParamFun',\n", " ['SamplePart42', 'A_1'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun53': ['ParamFun',\n", " ['SamplePart42', 'A_2'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun58': ['ParamFun',\n", " ['SamplePart42', 'A_3'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun63': ['ParamFun',\n", " ['SamplePart42', 'A_4'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'SamplePart1': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", " 'SamplePart100': ['SamplePart',\n", " ['controller_vx_in'],\n", @@ -1820,179 +1888,215 @@ " 'Select56': ['Select', ['Fuzzify5'], 5, 2],\n", " 'Select61': ['Select', ['Fuzzify5'], 5, 3],\n", " 'Select66': ['Select', ['Fuzzify5'], 5, 4],\n", - " 'Sum104': ['Sum', ['Mul103']]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'Sum104': ['Sum', ['Mul103']]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 5 + "source": [ + "# Generate the model\n", + "lat_dyna_control.neuralizeModel(\n", + " sample_time=0.05\n", + ") # neuralize the model with the chosen sample time" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# Training", - "id": "78870bde708d1090" - }, - { + "id": "78870bde708d1090", "metadata": {}, - "cell_type": "markdown", - "source": "### Dataset Load", - "id": "d8901687b6eb84c5" + "source": [ + "# Training" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "Here, the data for the training, validation, and test sets are loaded and constructed. The dataset is constructed according to the overall architecture of the system, comprising both the model and the controller. Parentheses are used to indicate that multiple inputs refer to the same column of the CSV file.", - "id": "d48eb0e28481f7a2" + "id": "d8901687b6eb84c5", + "metadata": {}, + "source": [ + "### Dataset Load" + ] }, { + "cell_type": "code", + "execution_count": 6, + "id": "6b302b749e7668ee", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T19:50:35.076648Z", "start_time": "2025-12-09T19:50:34.895611Z" } }, - "cell_type": "code", - "source": [ - "lat_dyna_control.loadData('test_set', source='dataset/test',\n", - " format=['', ('controller_ax_in','model_ax_in'),'', ('controller_vx_in','model_vx_in'), ('model_curv_in','controller_curv_in'), ('model_steer_in','controller_steer_in')], skiplines=1)\n", - "\n", - "lat_dyna_control.loadData('training_set', source='dataset/training',\n", - " format=['', ('model_ax_in','controller_ax_in'), '', ('controller_vx_in','model_vx_in'), ('model_curv_in','controller_curv_in'), 'model_steer_in', ''],\n", - " skiplines=1)\n", - "lat_dyna_control.loadData('validation_set', source='dataset/validation',\n", - " format=['', ('model_ax_in','controller_ax_in'), '', ('controller_vx_in','model_vx_in'), ('model_curv_in','controller_curv_in'), 'model_steer_in', ''],\n", - " skiplines=1)" - ], - "id": "6b302b749e7668ee", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: test_set\u001B[0m\n", - "\u001B[32mNumber of files: 1\u001B[0m\n", - "\u001B[32mTotal number of samples: 1047\u001B[0m\n", - "\u001B[32mShape of controller_steer_in: (1047, 29, 1)\u001B[0m\n", - "\u001B[32mShape of controller_vx_in: (1047, 30, 1)\u001B[0m\n", - "\u001B[32mShape of controller_ax_in: (1047, 1, 1)\u001B[0m\n", - "\u001B[32mShape of controller_curv_in: (1047, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (1047, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (1047, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (1047, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (1047, 2, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: training_set\u001B[0m\n", - "\u001B[32mNumber of files: 4\u001B[0m\n", - "\u001B[32mTotal number of samples: 12100\u001B[0m\n", - "\u001B[32mShape of controller_vx_in: (12100, 30, 1)\u001B[0m\n", - "\u001B[32mShape of controller_ax_in: (12100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of controller_curv_in: (12100, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (12100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (12100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (12100, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (12100, 2, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: validation_set\u001B[0m\n", - "\u001B[32mNumber of files: 2\u001B[0m\n", - "\u001B[32mTotal number of samples: 5560\u001B[0m\n", - "\u001B[32mShape of controller_vx_in: (5560, 30, 1)\u001B[0m\n", - "\u001B[32mShape of controller_ax_in: (5560, 1, 1)\u001B[0m\n", - "\u001B[32mShape of controller_curv_in: (5560, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (5560, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (5560, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (5560, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (5560, 2, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: test_set\u001b[0m\n", + "\u001b[32mNumber of files: 1\u001b[0m\n", + "\u001b[32mTotal number of samples: 1047\u001b[0m\n", + "\u001b[32mShape of controller_steer_in: (1047, 29, 1)\u001b[0m\n", + "\u001b[32mShape of controller_vx_in: (1047, 30, 1)\u001b[0m\n", + "\u001b[32mShape of controller_ax_in: (1047, 1, 1)\u001b[0m\n", + "\u001b[32mShape of controller_curv_in: (1047, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (1047, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (1047, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (1047, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (1047, 2, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: training_set\u001b[0m\n", + "\u001b[32mNumber of files: 4\u001b[0m\n", + "\u001b[32mTotal number of samples: 12100\u001b[0m\n", + "\u001b[32mShape of controller_vx_in: (12100, 30, 1)\u001b[0m\n", + "\u001b[32mShape of controller_ax_in: (12100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of controller_curv_in: (12100, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (12100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (12100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (12100, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (12100, 2, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: validation_set\u001b[0m\n", + "\u001b[32mNumber of files: 2\u001b[0m\n", + "\u001b[32mTotal number of samples: 5560\u001b[0m\n", + "\u001b[32mShape of controller_vx_in: (5560, 30, 1)\u001b[0m\n", + "\u001b[32mShape of controller_ax_in: (5560, 1, 1)\u001b[0m\n", + "\u001b[32mShape of controller_curv_in: (5560, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (5560, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (5560, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (5560, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (5560, 2, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 6 + "source": [ + "lat_dyna_control.loadData(\n", + " \"test_set\",\n", + " source=\"dataset/test\",\n", + " format=[\n", + " \"\",\n", + " (\"controller_ax_in\", \"model_ax_in\"),\n", + " \"\",\n", + " (\"controller_vx_in\", \"model_vx_in\"),\n", + " (\"model_curv_in\", \"controller_curv_in\"),\n", + " (\"model_steer_in\", \"controller_steer_in\"),\n", + " ],\n", + " skiplines=1,\n", + ")\n", + "\n", + "lat_dyna_control.loadData(\n", + " \"training_set\",\n", + " source=\"dataset/training\",\n", + " format=[\n", + " \"\",\n", + " (\"model_ax_in\", \"controller_ax_in\"),\n", + " \"\",\n", + " (\"controller_vx_in\", \"model_vx_in\"),\n", + " (\"model_curv_in\", \"controller_curv_in\"),\n", + " \"model_steer_in\",\n", + " \"\",\n", + " ],\n", + " skiplines=1,\n", + ")\n", + "lat_dyna_control.loadData(\n", + " \"validation_set\",\n", + " source=\"dataset/validation\",\n", + " format=[\n", + " \"\",\n", + " (\"model_ax_in\", \"controller_ax_in\"),\n", + " \"\",\n", + " (\"controller_vx_in\", \"model_vx_in\"),\n", + " (\"model_curv_in\", \"controller_curv_in\"),\n", + " \"model_steer_in\",\n", + " \"\",\n", + " ],\n", + " skiplines=1,\n", + ")" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Training", - "id": "6c9524ead582c921" + "id": "6c9524ead582c921", + "metadata": {}, + "source": [ + "### Training" + ] }, { + "cell_type": "code", + "execution_count": 7, + "id": "fa82ab5c8f2e7f2c", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T19:50:35.086278Z", "start_time": "2025-12-09T19:50:35.082620Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "# Default training parameters definition\n", - "training_pars = {'num_of_epochs': 5,\n", - " 'val_batch_size': 64,\n", - " 'train_batch_size': 16,\n", - " 'lr': 1e-3,\n", - " 'train_dataset': 'training_set',\n", - " 'validation_dataset': 'validation_set',\n", - " 'models': 'control_steer',\n", - " 'optimizer': 'Adam',\n", - " 'shuffle_data': True,\n", - " 'select_model': select_best_model,\n", - " 'early_stopping': earlystopping.early_stop_patience,\n", - " 'early_stopping_params': {'patience': 3, 'error': 'heading_error'}}" - ], - "id": "fa82ab5c8f2e7f2c", - "outputs": [], - "execution_count": 7 + "training_pars = {\n", + " \"num_of_epochs\": 5,\n", + " \"val_batch_size\": 64,\n", + " \"train_batch_size\": 16,\n", + " \"lr\": 1e-3,\n", + " \"train_dataset\": \"training_set\",\n", + " \"validation_dataset\": \"validation_set\",\n", + " \"models\": \"control_steer\",\n", + " \"optimizer\": \"Adam\",\n", + " \"shuffle_data\": True,\n", + " \"select_model\": select_best_model,\n", + " \"early_stopping\": earlystopping.early_stop_patience,\n", + " \"early_stopping_params\": {\"patience\": 3, \"error\": \"heading_error\"},\n", + "}" + ] }, { + "cell_type": "code", + "execution_count": 8, + "id": "e949cd28ae6e34c7", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T19:53:07.861950Z", "start_time": "2025-12-09T19:50:35.092704Z" } }, - "cell_type": "code", - "source": [ - "# First training without few samples in the future\n", - "lat_dyna_control.trainModel(training_params=training_pars,\n", - " prediction_samples=5)" - ], - "id": "e949cd28ae6e34c7", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['control_steer']\u001B[0m\n", - "\u001B[32mnum of epochs: 5\u001B[0m\n", - "\u001B[32mupdate per epochs: 755\u001B[0m\n", - "\u001B[34m└>len(train_indexes)//(batch_size+step)\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mearly stopping: early_stop_patience\u001B[0m\n", - "\u001B[32mearly stopping params: {'error': 'heading_error', 'patience': 3}\u001B[0m\n", - "\u001B[32mprediction samples: 5\u001B[0m\n", - "\u001B[32mstep: 0\u001B[0m\n", - "\u001B[32mclosed loop: {}\u001B[0m\n", - "\u001B[32mconnect: {}\u001B[0m\n", - "\u001B[32mtrain dataset: training_set\u001B[0m\n", - "\u001B[32m\t- batch size: 16\u001B[0m\n", - "\u001B[32m\t- num of samples: 12100\u001B[0m\n", - "\u001B[32m\t- num of first samples: 12080\u001B[0m\n", - "\u001B[32mvalidation dataset: validation_set\u001B[0m\n", - "\u001B[32m\t- batch size: 64\u001B[0m\n", - "\u001B[32m\t- num of samples: 5560\u001B[0m\n", - "\u001B[32m\t- num of first samples: 5550\u001B[0m\n", - "\u001B[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['control_steer']\u001b[0m\n", + "\u001b[32mnum of epochs: 5\u001b[0m\n", + "\u001b[32mupdate per epochs: 755\u001b[0m\n", + "\u001b[34m└>len(train_indexes)//(batch_size+step)\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mearly stopping: early_stop_patience\u001b[0m\n", + "\u001b[32mearly stopping params: {'error': 'heading_error', 'patience': 3}\u001b[0m\n", + "\u001b[32mprediction samples: 5\u001b[0m\n", + "\u001b[32mstep: 0\u001b[0m\n", + "\u001b[32mclosed loop: {}\u001b[0m\n", + "\u001b[32mconnect: {}\u001b[0m\n", + "\u001b[32mtrain dataset: training_set\u001b[0m\n", + "\u001b[32m\t- batch size: 16\u001b[0m\n", + "\u001b[32m\t- num of samples: 12100\u001b[0m\n", + "\u001b[32m\t- num of first samples: 12080\u001b[0m\n", + "\u001b[32mvalidation dataset: validation_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 5560\u001b[0m\n", + "\u001b[32m\t- num of first samples: 5550\u001b[0m\n", + "\u001b[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", " 'B': 'Mul72',\n", " 'loss': 'mse'},\n", " 'heading_error': {'A': 'Add82',\n", " 'B': 'Add92',\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.001}\u001B[0m\n", - "\u001B[32moptimizer params: [{'lr': 0.0, 'params': 'A_0'},\n", + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.001}\u001b[0m\n", + "\u001b[32moptimizer params: [{'lr': 0.0, 'params': 'A_0'},\n", " {'lr': 0.0, 'params': 'A_1'},\n", " {'lr': 0.0, 'params': 'A_2'},\n", " {'lr': 0.0, 'params': 'A_3'},\n", @@ -2013,110 +2117,101 @@ " {'params': 'Fir_target_4'},\n", " {'params': 'Fir_target_5'},\n", " {'params': 'Fir_target_6'},\n", - " {'params': 'Fir_target_7'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=========================== nnodely Training ===========================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m curv_error |\u001B[0m\u001B[32m heading_error |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 1/5 |\u001B[0m\u001B[32m7.216e-05|\u001B[0m\u001B[32m3.451e-05|\u001B[0m\u001B[32m2.014e-04|\u001B[0m\u001B[32m5.827e-05|\u001B[0m\u001B[32m1.368e-04|\u001B[0m\u001B[32m4.639e-05|\u001B[0m\n", - "\u001B[32m| 2/5 |\u001B[0m\u001B[32m3.435e-05|\u001B[0m\u001B[32m2.168e-05|\u001B[0m\u001B[32m5.156e-05|\u001B[0m\u001B[32m3.947e-05|\u001B[0m\u001B[32m4.295e-05|\u001B[0m\u001B[32m3.058e-05|\u001B[0m\n", - "\u001B[32m| 3/5 |\u001B[0m\u001B[32m2.631e-05|\u001B[0m\u001B[32m1.536e-05|\u001B[0m\u001B[32m4.149e-05|\u001B[0m\u001B[32m3.209e-05|\u001B[0m\u001B[32m 3.39e-05|\u001B[0m\u001B[32m2.372e-05|\u001B[0m\n", - "\u001B[32m| 4/5 |\u001B[0m\u001B[32m2.243e-05|\u001B[0m\u001B[32m1.184e-05|\u001B[0m\u001B[32m3.738e-05|\u001B[0m\u001B[32m2.927e-05|\u001B[0m\u001B[32m2.991e-05|\u001B[0m\u001B[32m2.056e-05|\u001B[0m\n", - "\u001B[32m| 5/5 |\u001B[0m\u001B[32m1.901e-05|\u001B[0m\u001B[32m9.138e-06|\u001B[0m\u001B[32m3.452e-05|\u001B[0m\u001B[32m2.683e-05|\u001B[0m\u001B[32m2.677e-05|\u001B[0m\u001B[32m1.798e-05|\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 151.05759406089783\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " {'params': 'Fir_target_7'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=========================== nnodely Training ===========================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m curv_error |\u001b[0m\u001b[32m heading_error |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 1/5 |\u001b[0m\u001b[32m5.751e-05|\u001b[0m\u001b[32m2.937e-05|\u001b[0m\u001b[32m1.629e-04|\u001b[0m\u001b[32m3.695e-05|\u001b[0m\u001b[32m1.102e-04|\u001b[0m\u001b[32m3.316e-05|\u001b[0m\n", + "\u001b[32m| 2/5 |\u001b[0m\u001b[32m2.193e-05|\u001b[0m\u001b[32m1.811e-05|\u001b[0m\u001b[32m2.632e-05|\u001b[0m\u001b[32m2.277e-05|\u001b[0m\u001b[32m2.412e-05|\u001b[0m\u001b[32m2.044e-05|\u001b[0m\n", + "\u001b[32m| 3/5 |\u001b[0m\u001b[32m1.423e-05|\u001b[0m\u001b[32m1.257e-05|\u001b[0m\u001b[32m1.816e-05|\u001b[0m\u001b[32m1.735e-05|\u001b[0m\u001b[32m1.619e-05|\u001b[0m\u001b[32m1.496e-05|\u001b[0m\n", + "\u001b[32m| 4/5 |\u001b[0m\u001b[32m1.025e-05|\u001b[0m\u001b[32m8.980e-06|\u001b[0m\u001b[32m1.465e-05|\u001b[0m\u001b[32m1.494e-05|\u001b[0m\u001b[32m1.245e-05|\u001b[0m\u001b[32m1.196e-05|\u001b[0m\n", + "\u001b[32m| 5/5 |\u001b[0m\u001b[32m7.413e-06|\u001b[0m\u001b[32m6.708e-06|\u001b[0m\u001b[32m1.279e-05|\u001b[0m\u001b[32m1.308e-05|\u001b[0m\u001b[32m1.010e-05|\u001b[0m\u001b[32m9.894e-06|\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 654.2472450733185\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsIAAAHaCAYAAAAKfy+yAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAApHZJREFUeJztnQeUFNXWhTeTCEPOOSOIBJEkkoOgmDAnFLMipmcEn4oZ9Pf5TMBTVAyAOStBkYwiKEEk55xzGib1v/ZtauiZ6cnV032797dWrZqprq6+VafCrnPPObeIx+PxQAghhBBCiAgjKtgNEEIIIYQQIhhICAshhBBCiIhEQlgIIYQQQkQkEsJCCCGEECIikRAWQgghhBARiYSwEEIIIYSISCSEhRBCCCFERCIhLIQQQgghIhIJYSGEEEIIEZFICIcA3bp1Q5EiRcxUGNStW9f8FudCFBTn3OV5HGg2bNiQ9ns33XRTwH9PiLwwffr0tPPz6aefDquD98EHH6TtG/8O9LOFx8/5PR5X246FsIcYhAF8ONarV8+VbQ0YMEAntggqixYtwrfffmv+7tevH84880xZRIQUjsij4NELibAd3XMj+x4UFkJYiHC7KT/zzDNpF7mEsAg1nPOza9euEsLCenTPjex7UFgI4cqVK+Obb77J8vN//vkHTz75pPn7jDPOwPPPP5/lurVr10ZhU9jdPvSgC+EWHo+n0A4mXwwK8/eEELknUp4tFF7qCQkfwkIIlyhRwnQhZ0XZsmXT/q5YsWK26wohhBBCiMhAyXJCCCGEECIikRDOItN39erVeOihh0woBT3K/rKAt2zZgpEjR+Kaa65B06ZNUapUKcTGxhqvc/v27TFkyBBs3ry5wFUj/GWorlq1Cvfeey9OO+004xFnGzt06IDXX38diYmJ2f5eTpm9/rJ1//rrL9x8882oX78+ihUrhgoVKqB79+6mPampqcgNs2fPxrXXXouaNWuabdSoUQN9+/bFV199FbCKANu2bcMTTzyBdu3aGbsULVoU1apVQ69evfDmm2/i+PHj2X6f7XDa5HT7TZs2DVdddZUJo+H2GJrD/fjuu+8K1FbHzjzODvzb+X3fKSd7cX7DDTcYe/H88Jd5vXDhQrz44ou44IILTLIp13OOT+/evc25dOTIkQJXjXDzGObmHPF3PTF0ivvJc46/V716dVx++eWYOXMmcgPDMT7++GNz3lSqVAnFixc3x5Zt+PPPPwstk3zt2rV49NFH0bZtW5QrV87cb8qXL49GjRqhS5cuePDBB3O1T1znjjvuwOmnn27uHbwea9WqZY4Jr8eswk8yHtcZM2b4PT/zu/+HDx/Gp59+ijvvvNPsI/eN+8g28h57++23Y968eTluJ1DX7eTJk3HppZeaa4THjNu67LLL8PPPP8MNUlJSzLnJdvN5cuzYsRy/w/s97238Du/LGe//CQkJZh/vu+8+nHPOOeb85THl9nne8D7xyy+/uNL+3FaN4H6+/fbb6Ny5s7Ex7z1sy913343ly5fn+vcKum/5vefm5Vo/cOAAhg8fbva1SpUqiIuLM+dep06dMGzYMPN5dgTqeZxf1objPcgTAUybNo1H1Exdu3bN9vOhQ4d6Pv74Y0/x4sXTlvl+5vudIkWKZFon4xQXF+d59913s20f2+Ss748xY8akfc6/P/roI7/tc6YOHTp4Dh48mOXv1alTx6zHuT+4n862uJ/Dhw/3REdHZ/l7/fr18yQlJWW7j4888ki2x+uaa67xrF69Ou3/AQMGeArKe++95ylRokS29qlVq5Zn/vz5WW6D7XDWXbdunefee+/NdnuDBg3Kd3t97ZzTlJ29smojP3N45plncvU71atX9/zxxx/Ztju7a8vtY7h+/foczxHf6+n48eOeK664Itvfe/nll7Pdv8OHD3t69uyZ5fd5bbz22muZrlO34flctGjRHG0WHx+f5Tb279/vufDCC3PcRpcuXTy7d+/O9P3cnp/52f8TJ054ihUrlqvt33nnndnec9y+blNSUjy33XZbttu4//77Mz1L8sPDDz+ctg0+i3Lim2++SVt/4MCBmT6vV69ero7pJZdcYs71rMjN+Z3Ts4Xs2bPH07Zt2yzbwXNg3Lhxme5r/ijovuX3npvba/2nn37ylC9fPtvt8nOulxWBeB7nl/fC9B4UFjHCbvLbb7/hhRdeMG8ULKXGt7j4+HisWbMmXSId30Rpk8aNG5s3MXor+FYeExODHTt2mLcdlsDi2zm9GHwTvPDCCwvcvkmTJuHLL780b9CDBg0yb2X0bjDr9X//+x8OHjyI33//HQ8//DDeeeedAv/e6NGjMX78ePOmTS9LixYtEBUVZY7Tu+++ixMnTpj9fPnll/H444/73QaTE//v//7P/M3jSg/Keeedh5IlSxrP9vvvv2+8QG6+yb733nu47bbb0v4/99xzTWw435zpIaJ3b+nSpcZjTw8i94f7lh30LPNY0NtBTwPfZJOSkvDrr79i7Nixpv0jRowwnonrrrsuz23u0aOH8VxOnTrVeKsJvf5cnltoh4kTJxp78fx19one39KlS6etR09TdHS08ZR37NjR9CzwrZyeGh6fH3/8EXPmzDEe9fPPP9+cX3xbLyiBPoYZufXWW8310qxZM9Mb0aBBAxw9ehQ//PBDWom6xx57zPSm0EOTEV7jPF/ZPsJ7wS233GKuO0JvMM/ff/3rX7jiiisQKGg/ek9oH9qtT58+5pymZ4nX465du7B48WLj/dq3b5/fbRw6dMjYetmyZeZ/enCuvPJKYwN6qdatW4dPPvkEf//9t7l/0fs9d+5c46lxcJKS6RXNLvn4rLPOyvM+0va8r/Je2bNnT7Rs2dJ4R+l9379/vznWn3/+ufmb3kSezzzfC+Oco315vyM8/tdff725bzj3Xt5v2IOSmx7AnOB1+8orr5i/eZ/q379/tut/9NFHaX/feOONmT7ntc5rm/eRVq1aoU6dOub5wfOBtv7ss8+wfft241nluc1jHCh43Hnvd3pR6EnkNcrKOHyW0OM5btw44+3k+Z0TBd03N+652fUeXHLJJUhOTjb/s5eYvcc8p9kmPvN4ffF65Xq85/K6DvTzOL8sDOd7kCcCyItHmFPlypU9ixcvznabGzZs8CxatCjbdRYuXGi2xW02atTIk5qaWmCPMKczzjjDs2XLlkzrLV++3FOyZEmzTmxsrGfHjh0F9gg7x+zAgQOZ1ps+fXram2nFihWNRycjK1euNG1x2vTdd99lWufo0aOec889N91vFsQjTNs4nmB6ofkWmxG+Md9yyy1pv9esWTPj9cnOs8Tp6quv9iQkJGRaj54bZ53mzZt7CkJePYsZ7cUegX379mX7nXnz5nm2bt2a7Trcp6ioKLPNW2+9Ncv1sru23D6GefUIc3rwwQf92va5555LW+eiiy7yu633338/bZ0aNWqYXouMrF271vQs5NcbkRvosXS2/f3332e5Hu8xM2bM8PsZe12cbTz99NOe5OTkTOvwOD300ENp6/373//Ol83zA9szYcIEv7by9Sby/OZv897Daz3Q59zs2bPTerPo6Zo1a1amdbZt2+Zp0qRJut/Mr0eYtGrVKm0fue2s2Lt3r+l15LqnnXaa33V4TBMTE7PcBu+/9CI67fa3f255hF988cW0bfB4+ds3/j6Ps++xzMojXJj7lpf16X2uUqVKuust4/Of/z/11FNp63D9Q4cOBfR5XBAGhfE9SELYjxBmV5NbMCzC2S5vqAUVwjExMUZcZsVjjz2Wtu7YsWMLLITZbcOHT1bwAZPd/vl2SQ4ZMiTL7bALpGzZsq4IYQofZzt33313lutRDPPh56z77bffZvtA5YPG38PUoX379mnr+ntRKQwhzAdIQX47I/379zfb5YtFVg+cvAjhgh7DvAph/p3VCyhvwhS3Tnesv+5E3/Nj8uTJWbZ7ypQpARXCffr0MdutVKlSvr7PF3unbdm91Dh07NjRrFumTBm/9gqEEM4tviFUzz//fMDPuUsvvTTt87feeivbY+zbZV0QIfzf//43V6E7o0aNSluPL3b5haF0jvhkCEgghDDvH4445HHKztnE45wbIVyY+5aX9d944420z/v27Zvtts4777y0dRliFcjncUHoE8b3ICXLZYBdK+ymcAvf7la6+AsKwyvYjZ0Vvt1JrJ9cUNjVxnCC/P6e0/3MrhMmNGQFw0rYbekGX3/9dVoYBoP6s4JhLI888kim72UFEznYFVpYxz4/sBufCWFun7/sgmR3VUEp7GPILu2sklDZvcewJsIueSaB+MJuuiVLlpi/GfrEBMKsYFd+8+bNESgYkkH27t2br1qtH374Ydrf2V0TGbvYGWr1xx9/IJRo2LAhqlatmut7akHOOXY1//TTT+bvMmXKpAu3ygi7qbM7R/ICQzR4f3LCI3IKi+A5XpD7J8NMnPPXjeeUPxhqtXPnTvM3u7yzC0XjcfYte1oQCmPfMuL7LGHoVXb4hjDk9Awq6PO4IMSH8T1IMcIZYPxKVg9OfzA+jHFmjMtlpQnGwPDm6Q9WmSgojGXMDlZkcGAsXTB/jzc9J2aOMUDOwysrKEqcOK38wjgl5yLlCwNfbLLDNyYrp5tkYR/7/MCY9tzCl2rGEzOGllnItBWz9p2YNn/nb+vWrSPm/J0/f37a345gzg6u4whnt6HA4kOS8ayMTWVFGsa8M542NzhZ3Iy1Y3yeE6OXFVu3bk37m+syG7ywYFw6xR9jePnbtEtW1RNyc08tyDnAmEenCgOfDdkJaueFiNdUQWHcJWNpGTfKc4rPmYwjTDJvhc8dQvtkd6/jfjH2ljkmFEgUM4yV95eZ78Zzyh++1T54nLKDx5kv4dz/nAiFffOFv+vsK+OV/eUe+MLziiKTbeY9h9c4HUeh9gzqHcb3IAnhbE6k7KBYYLIag9dzO9IVRXJBoec0O3xv1PRyBfP3+EBzYJJSTrAUTEFhEoJDdp5z3wcOPT186/T9bigc+0Cev0zoZHIXvTS5Redv4M/frGCizxdffGHE4caNG3HXXXeZqUmTJibJiw8JlofL6hx1Xg55XjpJJrklq8SXQMAkOJZfyk3ZsNyek27dw+iJzoncrJNb6BFzhCA9vxmFMB0wvutmBRPFmJBGgVhY17k/AnEsQ2XfMv6Gc/7yuZeVqHXg59xXvnSxnCfLqTGJMNSeQbeE8T1IQjgDzFDODffff39aVQbW0ePbOzPwKUT4dsdljoeSNTEJsy0LSk4XldsU5Pf4huvAN+Pcdr0UBHo087o9Vq+gEM6pZm5hH/tAnb98ieP5yhsvYS3Iiy66yHQf0mvPbTBsgPhmU+v8Dfz5mxW8n9DTyOoGb731VloYx4oVK8zEyhXsSmedXFYcYJ1bX3KqVZodOdUldws+ZPlg9fV+de3a1dS45suq70Oe2eu7d+/O1TlZkOvW955QWPcwh4svvthcm/TsMZOelXec69I3ZILtYua9P+gx5guv08vDcASGJVB4cds8pk4PKKtrsJJOoOrQun0sQ2nf3HgG+X4/KyEczGdQbBjfgySE8wG7kFmqjDAek4XaWQbEH7z4IhXfm0BuPDy+wjm/sJB6Xrfn3KB9b0bhDEsKOSKYXZQsR+N73LLqnoo0gnH+5vQgeuCBB8y0cuVK481n2STefxjPTEHA0kosQcUuVpZpcuC57Xiacus9K2ycWEmKPZ6TfDnLCpakLAx87wmFfQ5QyFFU0EvOHhwO2sFShoS2p80Ju6ezun6feuqpNKFIAcN46axg2VCbjmUo7Ztbz6CM3w81YsP0HhT6Lq4QZMqUKWlvloMHD85SBJP169cjUvG9CDImIvnDubEXBN+3UMZs5wQ99vQGZ2xvOOM7CtZrr72W7Y1X52/hnr+5hfXL2VXJ2qFsG5NJnIQgdkFzxCp/ITN8EOVmtMDChucZY14dYZedCGbXc2GFa/gmnjrty47crJMXfEMefOsF51Q72KnZ64xExtj+7IQiyU8CVLCOZajtW8bkPOclmveEnLzQ/Ny5v7A3zq0kwUDTOIzuQRLC+YBv57mNY3IjccJWGETvDMLAYTN9j5s/+FZZUBjz6wzvyTdWxjLlVPTcgQXPQwHf7q/cxp8H6vxlAkqk4gyakdtz043zN78wLMtXHM2aNSvd5wwxcB66vud8fnG6nN06P/NyTrL9hdHF7XS3OyEZ9H5llQjt4Ay84haMvXQcLYyHZbc52+AMDOEMF++PPXv2pHlMczqm9N5x/UCfow4MucoO7uPs2bOz/NztfXPznstrw7l30COcUx4GP3eEIb9nQwheuN2D7DziIdRlmt1bK98GfUuGRCJOKTqe/G+88UaW6/FGlV2ZoLzAscqdC8QZ0c4fvJE6Izj5fi/Y+HYhBqK7PbfnL0MoIjm0h8lvHJHOyVr29aT7E0CBqhiRWxhL65Cx8oev1/DZZ58tcCKNc466dX7m9pxkrKC/UaQCBUVw3759zd/sOWIcZFawYkF250h+ccqiMZGKcdRMoHPiLTnCnW/ccH6OKRk6dCgCDUW9U2GAo49lV96Lxzm7mFK3983te67vs+Sll17Kdt3hw4f7/Z6N1LP0HiQhXEBPEYWUv3iXTZs2me69QMcNhjr33HNPWuIgj9X333+faR3Gi7FuZkGC6X3hEJlOMsaoUaPwwQcfZFqHFym705zauBQ8bgyB7fbNZMGCBQE9f//973/7TTiid5MJSZEOKxg4sBvQ30OXL7wcEjbQ7WAsXnaMHDky7e+MFQborXESqnjO8wWVyWZZwZdIeqo4VHt25yiTZCjQCgozz50HG+8RTlkwX/g7HG7YjXrWeeGhhx5K8z6xJqy/trFU5NVXX+1KQqk/Iez8Pj1uuQmLcLronco5LI/IMokZYXtZa7swei75HGCSufO7PF5OXWFfeJ7nVHvX7X1z+57L4Y8d0c861M8995zf9bh8woQJ5m+uH+j7SEF4MIzvQUqWywfMZmY3OmNi2PXOmzhFA2vl8uJjPVp6NymCeUH4E2KRAuOImNTw5JNPmrguxv9x0AdWLWBsKsMXxowZY2K4mBjidPkVpHuI9TTpfWZRdnqieXPhuO688FiMnDbjw8TxSNC7wDqUodIlxTgr3hT5kGCJJJajOfvss9NlWvP45ReWG2L8FrtZKTpatmxpHqg8bsxQZ7cVu2F5PCg8fMs0RRq8fpmxTw8WEwd5c6cgdrp52e1K7xWvdd7k6bEjbp9LrN/53//+19iIRfPZZV+pUiVzv2G7aEenC5aCw3egGIf33nsPq1atMomS9FwyhIgeKJ5b3BavT55zfEgxD4I1V1n+ybfXxIHd8VyP+80Xfp4/3IYj2HgO52Vgl7i4OPNi+vLLL5t2sBuVx57HmdcnPfLsXWOiMhM8ed8ojJqwTp1XvlzznsJrhmWieF2wjfQYs8Yv4yQZt8x7W06DIuQV2om/OWPGDFOL1fEA81zMaRAXJjU58bO8v1J8st2sqsCXOt73GLZGRwD3haIykFDUfPXVV+Z3aNMzzjjD3I+4LwyHYNyvcy9mKS5nMJNA75vb91y+1PF85T7wGuUzkIKcbWQ4C0OB+ExyXqpYbYHrh3Ki3NfhfA/yRAC+Qyj7G47P9/PcDovJoV7r1auXbhjIjBOHF163bl2ehoQt6PCPuRmCNi9DLOc0tGVuj93DDz/sKVKkSJbHimOQL1++PO3/++67z+PG8NYcGjg7G9WsWdMzb968LLfhO1Qrj2125HWYzpzanl2782svhwkTJmR7bPjZRx99lKt9ymmoSzePYV6HWM6J3By7w4cPe3r06JHlseJwsRwSd/To0WnLvv76a4+b1K1bN9vzwZkqVKhgbJsV3Jcbbrgh22vRd8rKplu3bk0bLtfflJ/z/8SJE+mGm82qPRxiNqd7mNvXbUpKihkWNru23X///fl6luSG9957L9Pvvfrqqzl+j8OL33LLLdm2m8OI8znlxnMoJ7uQ3bt3e9q2bZtlezjc+fjx43O8Nt3ct7zec3N7r//xxx895cqVy3a7/JzrZUUgnsf5oW4Y34NCwwVmIXyTWbhwIZ5++mnzZsQ3R06MK6S3gF3L9CDkZZS6cIaxuvRo8M2d1RnoAeKbMd+y2a1Fr5tTvYFkVUcxL9DTwMoR7P5v06aN2SbfVPnm36NHD7z++uvm7dQ3VCBUYNvpheTbcu3atc1oPG7CMkx8K2dPBruYaA/WauVQwuwCo5fLrSGvbYfeHXon6LHhecNeBXqYeA+gF4I9QPRO+YZIuXH++kJvFssSDRw40HhPmBTKc5l2Y+1neknpNeH57pTYympfnN4QemzocaUXhR4p3r/o7eEIUryvscfLyczPCK9hdiHzXOH9j56sgt7ruC/0ANJrRA8oz0cuo1eH9wkefyZZZTfEbKCgh5JeX3r1WN+Xx59tYyY8BwdgUikrsAQK9jb4eidpL4aT5QRtwuNJLyxH0eSx43nDc4beU9aD5ShovqEBgYbeVnpCGbZGbzurJLBaApPeWEea5/q1115b6PsWiHsuPcIMnXrxxRfNvnLfaTvOGTPNsm78nOuFOn+F8T2oCNVwvr4phMtw4Ib77rvP/M06ogyjEMIW+AB1usXZTc4uWiGEEKGNhLAICRgb1KpVK1OlgG+ZjDniW6IQNsAYd8bDs6oB4x3ZWySEECL0UWiECDgctIKJEVnBMipMQHJKdXHYTIlgESrw3M0uu5kJHewed4YBZdehEEIIO5BHWAScP//808ThMk6XcUT0nLH8DTOwmfXJ7Nnt27ebdRnnxWWRMsqbCH0Y98Y4c8YHM86PMYeMEWbta8YHs1KEM2QsP2csfFa1XYUQQoQWKp8mClUQc8oKCgyW7ZIIFqEGvb1MiMpupD2W86Eo9hXBFMgFGWSBSTWdOnXK9/eFEJGN7kE5I4+wCDisD8nkN4oIVipgN7OTYc8HPWODWQdwwIABJgNViFCC5ytH2ePocawywnOXyXDMKmcFEtYVZ5a7v0xpxg4XJCOf2e9ZZU0LIURO6B6UMxLCQggRIPQQEkIEE92DckZCOMLgSGvbtm1zpe6nEEIIIQoHVrtlbg3DB0NlJNRwQDHCEQZFcK1atYLdDCGEEELkAw41zsFchDtICEcYzljmvJBYucHNZCLGAbOMlOJ87UQ2tB/Z0G5kP/sJpA0PHTpkHFnOc1y4g4RwhOGEQ1AEuymEmRDnhFywtJSwD9nQfmRDu5H97KcwbKiwRndRkIkQQgghhIhIJISFEEIIIUREIiEsXCEmJsbUAuZc2IlsaD+yod3IfvYjG9qHyqdFGAy2L1OmDA4ePOhqjLAQQgghAoee34FBHmHhWqbsyJEjzVzYiWxoP7Kh3ch+9iMb2oeEsHCt0DeHouVc2IlsaD+yod3IfvYjG9qHAjotZ+DAgfjf//6HN998E/fcc0+wmyPCgOTkZL3QWOyNio+PNyWc9FJqH7JfZNkwOjoasbGxhdY24R8JYYv58ccf8fvvv5vhFoUoKEeOHEGbNm2wceNG1am0FD54O3bsiC1btsiGFiL7RZ4NWWu4YsWKytkJIhLClrJz507jDZ4wYYKp1hBs+FZ7/fXX6+3W4iSMXbt2oWnTpihfvrwZEUlF2+18CNMjJfvZiewXOTbkeklJSSZxfevWrWaZEtiDQ0gKYZ4UX3zxhRF5K1aswI4dO8zDmW9Zjz76KNq3b1/obRo7dixmzZqFv/76C0uWLDEn+pgxY3DTTTdl+Z358+dj6NCh+O2338wJ37x5czz44IO46qqrCtyem2++Gffdd5/ZZigQFRWFhg0bBrsZIp/s2bMHJUuWNOPXSwDbTfHixYPdBFEAZL/IsSHX4wh09B7zHiwhHBxCMlmO8a7/+te/sG7dOvTu3RsPPfQQOnXqhO+++w7nnHMOPvvss0Jv0xNPPIF33nnHdBtXq1Ytx/WnTZtmhPvs2bON8L3rrruMoL/66qvxn//8p0Bteeutt3D06FFzXEIFxkMNGzbMzIVd8CWNduNNmOdoampqsJsk8gltt337dtnQUmS/yLMhHQ8sacp7MO/FovAJSSHcrl07TJ8+HWvWrMG7775rBNaXX35pxCWDyxkSkBvB9fHHHxvhmhUpKSl49dVXc1Xyi+3YsGGDqYxAUZtTstHtt99uvKQzZ840Aprid/HixTjttNPw+OOPZ2rX4MGDzQWR3UToIX/uuefw4Ycfmu2HCuzm2ZEQHexmiHzA68ApBK8EK/uRDe1G9os8GzoJc869WBQuoaOkfLjsssvQtWvXTMs7d+6M7t27Y//+/SY8ITvY1UAx2q1bN79imG9rAwYMMF5VCtWc6NWrF+rUqZOr9k+dOhVr167FddddhzPPPDNtOd/6KIIpvClkfWE7li9fnu1E5s6da8Q4wxAoXDhx/+6///50v1WYHEtMxpWj5+P7E02xad+xoLRBFByFRAghROGje29wCckY4dy8OeU0lC9jHT/55BMTlkDxTA9z7dq104ngcePG4cYbb8Tdd9/tahv5W4RhHRnp06ePmc+YMSPd8kqVKpkpJ/r162cy+zNuk7HKjBsOBiXiYlCuRCw8KIJRM9fj1avLBaUdQgghhBDWe4SzYtOmTZgyZYqJ0c1Nktill15qxPDmzZuNZ5jfpwimaGTyG6scMOHN7RCD1atXm3mjRo0yfVa1alWTlOSsk1fKli2LZs2apZv4csBjkl2y2ogRI0xFgLZt2yIQPNDrNDP/bvEObNorr7CtXgm+jMk7YS+yod3IfvYjG9qHNUKYQeQ33HCDiQ1+6aWXTKxwbrjiiiuM6KUIpmf42muvNbHD11xzTcDibFkOxQmF8AeTkpx1CotBgwZh2bJlppJFIGhVuxw6NayAlFQPRkxbE5DfEIEnt9eVcOeByRf0QNkwUNsPBMy/YHuzq8ITStStW9dMvjz99NNmH5wewfyia9B+ZEO7sCI0wvHiMvGMcb8UxHmBlRqYwNa/f39TiYLhBRTH4XKy8iESbBj3XGbTbACn46sFW3BPj4aoVb5EsJsl8prwuGOH6bWIFK9wXvcz1BOZfG0o7CMSr8FwQza0jxgbRPAtt9yC8ePHGyHL4YTzc2Iygc1h6dKlZkCKQI3I5niCs/L6cvCCcuXCL462cvRRdGxQHnPW7sPI6Wsw7LIWwW6SENnCOt8Zee2118y16+8zN2ECbIkSelkMFzjEPXsanVwUIYQdxIS6CGYC2EcffWRCGj744IM8hzJQBN9xxx14//33jWeYo7AxUY5hEizHFggx7MQGMw64devW6T7j2z6HsmWJuHBkULf6Rgh/8ecWDOreEDXL6UEvQhd2Z2eE9xkKYX+fuUmTJk0Cun1RuHCYXE5CCLuIskEEU8AyrjevoQwUwXfeeaepAczqEawSwQQ5bovlzSiGWfjabZzSbz///HOmzyZPnpxunXCjde2y6NiwApJTPRg5fW2wmyOE6zGs9OQyEbdChQpmmROa9M0335gXdiat0tPLniGWfPzqq6/8btNfDC+3z+Xr16/HG2+8YcRy0aJFTenGZ555xpWBMjiC1QMPPIB69eqZbVeuXNncH//5559M6/KF4KmnnjKJtkzyZX4D94/OBN+ylAkJCaZWesuWLc1+x8fHmxhabpf10/MC68fz+LLXjNth6cqstsFhwTn4EtvEfaEQvfzyy/3uCx0f7F1s3Lix2RdOrMCTXflMDuLEBGOOAFalShUTmsfynf7wFyPse97kZb9YVahLly5mPZ5nfAY6Sd8FCZlgCBtr55911llm2xzVjOfo999/n2ld51xkOCFty3OAx9iJ43bipA8cOGC84bVq1TLVnPgi6fDDDz+Y5yzPCR5Dnh/8fYYq5vX6EiJgeEKQlJQUz4ABAxiM57nyyis9SUlJed5Gamqq58477zTbuOqqqzJtY/z48Z7o6GhP48aNPdu3b8/TtocNG2a2O2bMGL+f87fq16/vKVq0qGfhwoVpyw8cOOA57bTTPHFxcZ7169d7gsHBgwdN2zl3Ex7vhIQEM/9j3V5Pncd+9DR8/CfPlv3HXP0d4T7Hjx/3LFu2zHPs2DFz7dGGkUydOnXMNeILr1cu69ixo6d06dJm/uCDD5r71NatW806vJc0b97cLBs8eLDn1ltv9VSqVMl874033sj0O1zetWvXdMuc+97ll1/uqVixouemm27y3HfffZ7atWub5Y8//ni2baftHBv62/6uXbs8DRo0MJ9169bNtPPqq68298ISJUp4Zs2alW5b7du3T9vvf/3rX56HHnrIc8UVV3jKli3r+eWXX9LW5T2W67Vo0cJz//33ex599FHPtdde66latapn9OjROR5z5/iyvRUqVPB06dLFHN9LLrnELC9Xrpxnx44d6b6zZs0aT82aNc3nvXv3Nm274YYbzH7Ex8d75s6dm279Pn36mH2//vrrPY899ph5Pji25m9l5MMPPzSf0d63336755FHHvGcfvrpnrPOOstTrVo1811fhg4datafNm1avveLx3zixImemJgY8/y48cYbjY1oB54DLVu2zHRu5hben2lzfv/MM8/03HvvvZ677rrLU6tWLbPszTff9Hsu9u3b11O+fHlzbGnXV155xXzO/ad9W7Vq5WnUqJHn7rvvNufqhAkTzOf/+c9/zPf5Xf4O7cP1uKxfv37p7jO5ub5swfcazOs9mPNgPL8jnZAUws4NpWTJkp5///vf5v+Mk6/A9MeWLVs8lStXzlZIjxs3zjwAPv744xzbxJs5L0pOvBE6F62zLOPNfurUqZ7Y2FhPqVKlzE2UF7Vz03VuJMEgUBcSL/ydO3eaObnm7d+NGP73N3+7+jsisEI4MTEx3Q2cfx89kRTyk5viPTshzOmpp57y+721a9dmWnb48GEjjsuUKeM5evRoroVwvXr1PNu2bUtbvnv3biM+eT85ceJElm3ncXBs6G/7N998s1k+ZMiQdMt/+ukns7xhw4Zp1/Dff/+dJlr8iSrum/OCX6RIEU/r1q09ycnJ6dbj//v37/fkhO/xHT58eLrPnnjiCbOcDghfzjnnHHP/njRpUrrlK1euNMeJx92XdevWZfpdPhvOPfdcs52NGzemLef9kYKMgprbc+CxpZhle/IihHO7X2wPt8vj6ftSQiiKnW3lB75E8btPPvlkuuvl0KFDnjZt2hgHja/odM5Fvmz4HpuM1wlfMHjvyPiSQjHPZ/CmTZvSnTedOnUy3/voo4/ydH3Zgu81mFskhINLSMYIO10hjKV94YUX/K7DLpnsRlKrUaMGfv/9d5O4kNXgGxz5jV1jHPY4J2bPnp1pNLg5c+aYyeG2225L+5vdQfwOE24+++wzU/6NtY9Z+o3dXOEG92/UqFFmqGh2n93fqxF+f2cvPp/vjRWuVqZ4sJsocoDajKMW+masH09KQdOnvOE8ocyyZ/uYgV0CDY/Nv//9b7+f1a9fP9Mydr+zu5cjR7J0YW5Dop588klTG9yBXf6XXHKJuQetXLkyyzrqvjb01y3Ouurscn7iiSfSfda3b1+ce+65+OWXX8w9jd3lDuzSzgivcU6E5wp/t1ixYplyOBjOxtrnuYXhGo888ki6Zbfeeiuef/75dKUfFy5ciN9++82EOjiDFDnwfs4QBnbBM0SCtdadbWeEz4a77rrL7DdDJxjyQb799luT1Hzvvfemez6wZjufSb7Hx839mjVrlgk5YS5Lp06d0q3PdRnel59heBlSw/tzgwYNTIiNb3gFwyMY/nLxxRfj66+/NmEOvrDd2SUAvvzyy5nOESa3M/yB5z1DJhx4zvAZ2LFjRxNCkbECVHbXl833URHahKQQ5gXiG2eUX/w9mDKSGxGc3zYxIW7ixImIRM6uXwHt65XHH+v3YdT0tXj2Eu/DSAibYYxjXFxclvGqw4cPN9c8xczx48fTfb5t27Zc/07GJFtntEzCmMz8sGLFChPLy5d0f9UquJyCcNGiRUbonX766WjRooURzxyynmUnGaNKB4Sv4GXcMIX0hAkTTOzplVdeadZjbK0zEmhuybjtrPabQ80TVv/xl9TIfXXmjhA+fPgwXnnlFSNymSNy9OjRLO3jxO76E7wdOnTIcWTT/O7X33//beYZRTChoKQgZfx4XuHLE2ObmRxOIZwRCjff4+ZLdondfPnx91LGFxXir441jx+/x/MsL9eXEBElhEV4QK/wdaP/wKfzNuPubg1RtUyxYDdJ5JHisdHG22pDOwsDJkz5Y9++fUb4ceAeeruYCEVPKD2ifOAz6YqDAeUWisuMOOIrPx5BQg9ndvvgeKCd9fh7LDtJocmEP3r3CEcfpNeQnjsngfmLL77Aiy++aDyBjkeP+8CEZy7PbZm43O43jzf56aefzJQVjtilN5yibMGCBWjVqpXxRNIzzm2zB5Kedl/7OKUvmUiYEe4zv5sXcrtfzrHnMfYHbZcfIewcL5YO5ZQVGV8OnN/MCh4ff17P7M41rs/lW7duzdNvCREoJISFa2R8k+9QvwLa1S2PeRv24X8z1uLpi8/Q0Q5xMj7U+H9hhBzYQlZdne+9954Rwc8991ymsAN6iSmEC4us2uiIMXpR/cHSjr7rEQq+N99801SwoLeQwpj/M+SL3t4hQ4aY9Sh02XXPiUKNYQas+f76668bz/jbb7/t6j46bWRbMnbl+4PHnyKY4QisIuTLp59+minszakFTy9/Rihc9+7da8Lv3MbZL8dDm5GsbJfb7bKixpdffpmn72bXvZ+bc40VTzKGDnC5v5eDcAklCJf9iBRCtnyasAvGfvGh6MQNOjcDeoXJ+HmbsPNQQhBbKHKCXbf0CgZi2PFwh13thHG8GWHcZyjYkKXY2CXNmNRjx45l+twp++Uv94LXMkMlOFQ7wyeIv5JbTjwsY3dZAowx0lmtVxDat29v5swDCYR92EWf1Wf8zYzlv9zCOfaMf84Iw1P4spUfaDsKzz///NPkcwQaet2Jv+Gm//jjDxOik12Oj83oPmofeuIJV2AyButkZqxzek6DCmhTpxwSk1ONV1iELvTU8AEV6sMIhyKO14sJsr4wVICxs6FgQ/bYsM4x6wgPGzYs3WeTJk0yNc5Zj5ehHYQhA/5quDpeSYpqx3vpr24vY1IZbuCs5yaMW6UYZvwyk5EzwvsQhXhO9uE6o0ePzvR9CmYKRw7EtGrVqrTlFJEZPf5uwmPPWGDW380o8plAmd+wGIZhDBw40MSuP/zww37FMG3ozwOeH5iIzt9kwqJv7DVDVB577DHzt1OPONzQfdQ+1OcpXIE3VmY0O1UjMnqFb3hvHsb/sQkDuzZA5dKKFQ7VGzjFi7Kd8w5jTpkNzyoDDAug8GLC1a+//orLLrvMZOMXlg0ZD+qvagRhGyn+GMJAryPFJMUuY3wZ3jBmzJg0bzJjm9l2ik4OpsBtMq6TyWZchwNZEC6jB5BeVCbXMWSAoQMMR+B9gcIrEFAEM8GPwxpzWGwm6rF6Ab2mFJEU6HwpIKzCwEpDrHDgVJJgAtmPP/5oBm/IGC7A0AiGg1CsMfabv8FlXJ+/4VvRw014XBlTzdjqHj16mApD/C3ajMeZx9hJqMsrTJJjeAj3i3HVHLCDMb7c7pIlS8z5yuPmLy46r7A6Bc81xpXznODAKhzAgwKfx50vGv3790c44nsNKkTCDuQRFgGnU8OKOKt2WZxITsXbM9fpiIuwgxUAKFZ69uyJKVOmmJhYer84uiRFWKjAJCx2Td93330mXIBVFBjqwIoQXO5brYClJem948Ocwomji7Grm4mALLHGcluEApMJdRSK3Hd6Abk+hSkraDCcIhAwBIPVCeihZalNingedwp4ijwKZQeGaDC+mTGyDA156623jKeSL+9ZtY+l1DhaYKNGjUwMMSd6bLmPgaxsQAFMDz2P/+eff25GvuP5RW82PcL+YmtzAx0UtAePEUUaEyD5AjFz5kwjtlleLauyfPnhwQcfNC9DfOkYO3asiefmceN5xBcPiUQRKhRhMeFgN0IUHszm5QOLWdH5vaH6g12gTArK6BF2mLFqNwa8Pw/FYqMw69EeqFQq8zoiONBrxgQnejFZyokPScUJ2wlDApj0JhuGn/1Y/o1VFShW+dIiwucadO7BfLnLLpQoUM/vSEceYeEKfLuntymrt/wujSrizFplkZCUindmKlY4VMlrfVQResiGdkOnAkWvL/QEc2ALVuCg916ENroG7UJPPeEK7PK6++67s/zciRW+ecx8fDx3I+7s2gAVS8orHErQe+FGfKAIHrKh/fajt49eX46Yx0GhKIpZvWLZsmU444wzTFiLCF10DdqHhLBwBXosmGzBZA6nyH5Gup1WCS1rlsHiLQcxeuY6DOl7uo5+CMEoKRbUZ9KU4vfstSFLo8mG9tqPA7FwdD7GnDNWmKXaOKIckw45WAmTzghjoZm4mBOM4Q7XCg2hiK5B+5AQFq7AmzUzgumxyEoIO17hWz74Ex/9vhF3dKmPCvIKh9QNnN4oZsVLCNuJbGi//di7xgFacoovpRD2N1xyRrp27SohXIjoGrQPxQiLQqV748poUbMMjielYPSsvA8VKoQQwluHl6Irp8nfoBZCiFNICItChZ7G+3p4R5v76PcN2Hc0URYQQgghRFCQEBauCVwWUc9Nl3rP0yujWY3SOJaYgndnqa5wKOGv9J2wC9nQbmQ/+5EN7UJCWLgC49o4UlBuCs2bWOGep5m/P/xtA/bLKxwSMCaxQoUKqiFsMbKh3ch+9iMb2oeEsHAtWY6xaJznhl6nV8YZ1UvjaGIK3putWOFQgPGELNWkMXbsRTa0G9nPfmRD+5AQFq6VT2O5H85zHSvc0xsr/MFvG3DgmGKFg41u4PYjG9qN7Gc/sqF9SAiLoNG7aRWcXq00jpxIxvvyCgshhBCikJEQFkHDGyvc0Pw9Zs4GHDyWJGsIIYQQotCQEBbunEhRUWjVqlWeE616N62KJlVL4TC9wnMUKxxsOCKZsBvZ0G5kP/uRDe1CQli4QmxsLC6++GIzz9MJGHUqVphC+OBxeYWDBV9iOLxrXl9mROggG9qN7Gc/sqF96IknXCEpKQnff/+9meeV886oisZVSuFwQjI+mLNBFgkSqampOHDggJkL9/jggw9MGBDnvtStW9dMBd2OmzZ8+umnzW+Eymhkodae3Iz2xvZu2LAh5K/BrM4nLuvWrVvAfz9c0X3UPiSEhWsX/8KFC/N1A6dX+N6TscLvzV6HQwnyCgeLY8eOIZK47rrrzIP/k08+yXa9Q4cOme5OesyPHz8OW21IQcn9pcAUoUmkXYPhiGxoFxLCIiTo26waGlUuiUMJyfhQXmFRSNx6661m/v7772e7HoUyBfC1116L4sWLu/Lbv/76q5lCiXvuuQfLly9Hu3btgt0UESRo/48++kjHX0QMEsIiJPB6hb2xwu/OXo/D8gqLQqBHjx6oV68epk6dik2bNmW5niOUHeHsBhySnFMoUbFiRTRp0kTJPhEM7V+7du1gN0OIQkNCWLhCdHQ0unbtaub55YLm1dCgUrxJmPvo942yTCHDLvNSpUqZeaTAfb355ptNSM+YMWP8rrN06VLMmzcPLVq0QJs2bXDw4EG89NJL5nyvXr26GVac8xtvvBFr167N9W9nFSO8b98+3HXXXahSpYoRpG3btsU333yTrUi/5JJLzLa4/hlnnIHzzz8f06ZNS7cewyG6d+9u/n7mmWfMvjuTE9OaXUzuDz/8YL5fpkwZ4xVv2bIlXn311UyjSXJb3AbjZdesWYNLL70U5cqVQ3x8PHr16oXFixfDDXLbHsJjwWNCOxUtWtQc286dO+Odd95Jt96CBQtwxRVXGCHI9SpVqmSO/wsvvJDnQRXeeOMNIyq5nTp16phjnlXo2HfffYeePXuaIc7r169vzrVXXnkl0wBF+Tn38no++YsRdmKf169fn+v9YnjAo48+ilq1aqFYsWJo1qwZRo8e7Up4zt9//41rrrkG1apVM8eA7bj33nuxd+/eLM9Ferp5LvIYO+e8b5w0z6eOHTuae6Dvdblnzx488MAD5oWZ+1y5cmVcddVV+OeffzK1i7/DZyC/w3OxadOm5jtcLkKXmGA3QIQHMTExBU6wiD5ZQeL+Txdh9Kx1GHBOXZQsqlO0sIVwpMGHFB/KfBg+9dRTmV4EHIHseIP5QOV6FGF8sFLgrVixAuPHj8dPP/1kxBQfzPmB4oHX0ZIlS9ChQwcjeDZv3oyrr74avXv39vudQYMGGRFIkUnhtnXrVnz77bfm/6+//tqIZMLt8uH/4Ycfmu36Xq+Mfc4OPtQfeughlC9f3sRVc5+ZHMtls2bNMr+T8bjxt84++2wjzG+55RYj1Cj4eNx4DCnM8kte2kObXHTRRWYfeSwonnbv3m0E+ccff4w77rjDrLdo0SKcc845RshwPdqQiWvLli0zgvnf//53rtv3yCOPmJE2L7zwQvTp08fYg+dYYmJiJlE9ZMgQDB8+HDVq1MBll11mhD33gdv4448/8MUXX6Stm9dzLz/nkxv7RQHPdfgC0rx5c2MjCnLap6DPCdqZQpTVGWgnCm3a6K233sLkyZPNMeOLly98IeO5yLbweqdgpoB24DH++eefTZvvvvtukxNAeJ7wuPHcZbspvvky8OWXX5rjzd/r1KlTpjbSpnPnzsUFF1xgzj2KZxHCeEREcfDgQQ/NzrmbnDhxwvPxxx+beUFITkn1dH9lmqfOYz963pq62rX2iaw5fvy4Z9myZZ6jR4969uzZ40lJScm80okjeZ+Sk3wMm+RdlnjMhe0mnvp+SrIrpj3vvPPMdTFlypR0y5OSkjxVqlTxFC1a1LN3716z7MCBA2l/+zJ16lRPVFSU57bbbku3fMyYMWbbnPtSp04dM/kydOhQs+7tt9+ebvmkSZPMcn/bWbduXdrftB1tuGXLFk/16tU9jRo1SrfutGnTzDb4O/5wfp/rOaxZs8YTExPjqVy5smfTpk1pyxMSEjydOnUy63/00Udpy9evX5/W1uHDh6fb/hNPPGGWDxs2zO/vB6I9l112mVm2aNGiTNvnsXJ48MEHzXrffvtttutlx4ABA8w26tWr59m2bVva8t27d3vKli3rKVWqVLp75M8//2zW79Onj+fIkSNp9ktOTvbcdddd5rMvv/wybf28nnv5OZ+4rGvXrgXar3fffdesf/7555t9cVi6dKmnWLFi2Z6D2cFjU7p0aU+NGjU8GzZsSPfZJ598YrZ7zz33+D0Xn3rqqUzbc65NHrtffvkl0+c333yz+XzIkCHplv/0009mecOGDdPdL53jxGuPv53XezDnwXh+RzoKjRBuvVCZt2bvfbRgXuF7e3grSLw7ax2OnsjczSkCx4kTJ/x/8GL1vE8rfjj1ff7NZWOvSL/d15rnfbt/+ZR72vhbQJPmfvzxR+zcudN4nuh9JPTYOX/7Qi8dvZ9TpkzJdzuYpERP1bPPPptuOb1v7Dr3B7tsM9qQXs/LL78cq1evxsaNBQszoreR4Qb05tH75sAuX3bTE38l3dguehD9Hef58+cXenv8JTmymzy/62XHk08+aWzgG3vNc+jw4cNYuXJl2nJ6MQk9zvTuOvajN5te4owVTfJ67uXnfHJjv8aOHWvm9BL7hssxVIBhHPmF+0Nv7bBhwzL1utBbe9ZZZ+HTTz/N9L2qVatm69HnPrAHxRd6uXnsafsnnngi3Wd9+/bFueeeazzNc+bMybQ9hqIoztoe1O8sQo6LWlTHG7+uwfo9R02s8MBuoZVQJMIPPggZVsDYScZhUnBklyTHOMfXXnvNdMMyHtA3LtW3yzUv8AHPbleKBT64M8KYVn9VJtatW2eEARP+GBaR8WVm27Zt+Q7VICyLSPx1abPbmPGfDCvIyJlnnplpcJaaNWuaOUMOCqs9FEgMlWDXOLvoKQB5LCnifGF3O23KkAOGDlDodOnSxYQs5JXWrVtnWuZv39l9TgHsnGd0JBw5cgQlS5Y0IpiinKEP+Tn38ns+ubFfDDvhfnG00YwwDjdjbHZu4fEi3Hd/MdEJCQnmmHDytS9Dh7K7Lv1VSeFx5/b4kuFvpDgu/+WXX8y5xmOZ8dwX9iAhLEKOmOgo3NO9IR76YrGJFb6xQx3EK1Y4uDy+Le/fiS566u8mF3m3USRDJ9QDS/KxXZ8HWp1z4AYcEfGGG24wsaf0OA4cOBA7duzAxIkTjWfH11vEeEIKJYoVetacJDUn6Sa/HlgnLjGreEJ/MbX0SPEhzu/ywcwYR4rP0qVLm1hOTll6+fPYLn+/z33mcgrwjLAN/nIJSMYksEC258orrzSxrLTt//73P4wYMcKsx+P1n//8J020tG/f3ojMF1980ZwDTmw4k8voaXYSDXNDbvedcbMUskw4y4qjR4/m69zLz/nk1n7xt3299QX9Xd/jRWjD7OAx8xXCOf2mv8+zO8+I4xl31vOFL9XCHiSEhTsnUkyMSQpwbooF5ZIzq+PNqauxYe8xjJ27EXd2lVc40PBhSk+o36oRcd5u23wTHeOd3N5uVP6rlGSEXl+Kpffee88IYSZSUaSwqoSvZ5PJQfQ6/vXXX2jUyFvyz8Fft2xeRcauXbv8fs4QjYz897//xf79+01b+/fvbzyKTJCiOOI+UAgXFKdd/P2MnmX+Hpf7E0iBIj/tocff6cJnVzY9xLTzeeedZzx/TrIgPXt8+WHNaHodWUlg5MiRJumJVQJY0cHtfeH1Rg+m037Hfv6uw7yce/k5n9yCv81EM7d/19knJv+xCkVuyakSjr/Pfc8zf/BF2Xe9jN+NpOo7tqMYYeEKjANjfFZByqdl9AoP6u6NFX5n5jocS1SscKDhjZvdmZF6A2cXMrvPKTJYnokeQae8mi/skj399NMzCZHt27ebMIX8wocn42rp5XUesr6wkkBGnO5hpzKEY0PiL3bRuT7z4pF1urf9lVSjWGT3cWF2BRekPayKQvHLrnlWD6DI4XcywpAEhl7QY/z4448bYcxucLehF5oVDBjLnZtrMC/nXn7OJ7dgKAK9sv5CZn777bcCHS/y+++/I9CwRBxfOhjP7m+kOOf883euZfUiI0ITCWHhCkwsoOeEc7e4tFUN1C5fAnuPJmLc3KwHOxDuwFqg9B7lZ5jscMGJBWYJJZaqYkhERq8j/6e48PUUUXzRA5uUVLDhwRmewWuIJbJ8YWknf/GcTttmz56dzoaMGfZX59RJtGIJrdzCuFr29NBbznhjB7bzscceM38XZp3UvLZn5syZfoW/4yml2HHEFe2YEcfOznpuct9995k5y8tREGe8BilgeR7m99zL6/nkFtdff72ZM8nM935C7zvL9+UXvpTyZYaJb6zvnREKVieOuKAwppgjSdJbz+vJl0mTJpnSaQ0bNjQxzxnhdyL5PmobCo0QrsAuPXaFFbRqhL9Y4Ue/+htvz1yL/mfXQfE497rCRWb8DUYQSTD+ksXzHW+qv5HkWLifEz2THHyBx4zeQp779IQVZMAIDkDAbnsOPMAHPZO1KFo///xz0z3P2qUZs9PpuWaFCCZ7UejS00cR7G99erk4AAO70VllgYlO9Fxxf5wEwYxw9DvGyLJKAwd64O/Qa8mwAVYKoDeaYRmFRV7bQ7FJwcx6r4yp5f7yxYGDpLAHwKkDy22y7i2POT2pFL6sy0vByJAIJtG5Db3TrMTw3HPPGVHFuF/GtlLc0vtLWz7//PPGC5yfcy+v55NbULAyXIfbZ1s5mAnje3neMQmRtsqYSJkbGHvLSg6M++b+8vjxnGYcPOtWMxSItaApVN2A5wS3SRvQk02PNH+Hsdr0+vLa87cfBYmBF4WPPMIipLn0rBqoVb449hxJxLg/NNqcCCz0NlFYEYrKfv36+R3AgklX/JwCg5UmOFABPYo5DUyRExR0fPBykAd2l7M6AL1on332mRE+GaHIoHePYUkUPHwws0ucAoqj4PkLjXAqKFBQ0FNIIcY44+x48MEHzWAYjMtkaaw333zTeMwYOsDBBQq7Gzgv7eHgBkx0Y7jL22+/bWKDKZwociginXARelVpbx53Jp6NGjXKhBwwNILhE4GKg2ZpM7aD8cms/MGwDQpItpExwY53NT/nXl7PJ7fgMZ0wYYJ5WaF3lL/Ll0vaZ8CAAWad/B5PCnhWDqHXny98tP24ceNMoiAFOF8q3ILCm7bnyxRfTDjaH23F84TL/Q2mIeyjCIsJB7sRovBghis9PywR5eaNnTdt1r0cPHiw8TS5yafzNmHw10tQqVRRzHq0O4rFyivsJvQ+scySM5IWSy3lx1sjgg+7Y9mdLhvaSSTYj+ESrC9MoUxPcbiRHxs692CnJ6Kwn9+RTnheaaLQYfkpei44d5vLzqqJGmWLY/fhExj/h2KFAwW9aPQ0KcnDXmRDuwkn+9GbnhEOhfzGG28Y73VBh1oOVcLJhpGCYoSFK/DNlzFugSAuxltB4vFvluB/M9biuva15RUOALxxByIhSBQesqHdhJP9GGrCeFrWuS5XrpwJLWBsMJP6GJ7ibwS/cCCcbBgpSAgL10IjmMXN2D23QyPIFa1rYsS0Ndh64LgJlbipY/phZYU7XXr04rCAfLh2y0aCDVlRQDa0k3CyHxPaGM/MmHR25XMQEMYzM26YSYEOjB/OzUiDjAlmsmOoE042jBQkhIVruFk6zZ9XmEMtP/HtPxg1Yy2uaSevcCBQyoD9yIZ2Ey72Y6icb6JfVlAI52Y0RoZS2CCEw8mGkYJeV4Q1XNmmJqqVKYadh07g8z9zXwdVCCFEaMLwCQrHnKZwjSkWwUdCWFhD0Zho3N3NO9TyqOlrcSJZtRqFEEIIkX8khIUrsFoEkyMCUTXCl6va1kLV0sWw/WACPv9zS0B/K9JgkgfrZirb2V5kQ7uR/exHNrQPCWHh2sXP+oaBFlH0CjNWmIyatkZeYRdh96MzuICwF9nQbmS/yLOhYoqDi4SwcC1RjgNqBDJhzuHqtrVQpXRRbDuYgC//klfYrZs2yxqxELxuyvZC28mG9iL7RaYNee8legkKDhLCwjo4stxdXb1e4ZHT1iIxOTXYTbIahrOw5B1LHEkECyFE4cF7Lu+9vAcHOrRQ+Efl04SVXNuuNkZOX2vqCn+1YIv5X+SfihUrYsuWLSa0JT4+3tyUFStsH6xhmpycbIZsVQ1T+5D9IseGFMD0BFMEHzlyBDVq1CjUdopTSAgLq73Cz/24zAy0wQE3YqPVwZFfOG49C8DPnTvX3KAlgu32LvHBKhvah+wXeTak04EimPdgERyKeNQXGlEcOnTIJLXxQnXzwuNpxPjguLi4QnsAJySloNNL07DnyAm8dHlzXN1WXmE3bEj70ash7MPxMrGLVULYPmS/yLIhY4LzEg4RqOd3pCOPsHD1LZhd7IX1APZ6hevj+Z+W461pa3DZWfIKu2VDdavbCV9gDh8+bIazlQ3tQ/azH9nQPtSXLFyBb8CjRo1Ky34tLK5vXwcVS8Zh877j+Gbh1kL97XAjWDYU7iEb2o3sZz+yoX1ICAurKR4XjTu61Dd/M1Y4OUVd+kIIIYTIHRLCwnr6n10HFeLjsHHvMXy7aFuwmyOEEEIIS5AQFq7BRLlgUCIuBref9Aq/NXW1vMIW2lC4h2xoN7Kf/ciGdqGqERFGuGadHj2RjM4vT8O+o4l49aqWJnFOCCGECBfC9fkdbOQRFq5lyq5ZsyZoZbfii8bgts71zN9vTV2DlNTcD28pQsOGouDIhnYj+9mPbGgfEsLCtUzZcePGBbXiwI0d6qJsiVis23MUPyxWrLCNNhQFQza0G9nPfmRD+5AQFmFDyaIxuL2zN1b4jamr5RUWQgghRLZICIuw4sYOdVCmeCzW7T6KH/+WV1gIIYQQWSMhLFyBo8lVqlQp6MO6lioWi9s6eWOF31SssJU2FPlHNrQb2c9+ZEP7UNWICCMSsk4PJSSh0/CpOJSQjDevbYWLWlYPdpOEEEKIAhEJz+9gII+wcIWUlBQsWLDAzINN6WKxuLWTN1b4zamrkaoKEtbZUOQP2dBuZD/7kQ3tQ0JYuEJycjJ++OEHMw8FbupYF6WKxWDVziOY+M+OYDfHCkLNhiLvyIZ2I/vZj2xoHxLCIixhwtwtHb2xwm/8Kq+wEEIIITIjISzCFgrhUkVjsHLnYUxeKq+wEEIIIdIjISxcy5Rt0KBBSFUcKFMiFjd3rGv+fl1eYSttKPKGbGg3sp/9yIb2oaoREUakZZ0eOJaITi9Nw5ETyfhf/9Y4r1nVYDdJCCGEyDOR9vwuLOQRFq4lCEyfPj3kEq3KlohL8wozVtjj8QS7SSFLqNpQ5B7Z0G5kP/uRDe1DQli4VjJmxowZIVl669ZO9czwy8u2H8Ivy3YGuzkhSyjbUOQO2dBuZD/7kQ3tQ0JYhD30Cg84p05arLC8wkIIIYQgEsIiIritU33Ex0Vj6bZDmLJ8V7CbI4QQQogQQEJYuHMiRUWhVatWZh6KlIuPw43nOBUkVskrbKENRc7IhnYj+9mPbGgfqhoRYURy1um+o6wgMRXHElPw3oA26Hl6lWA3SQghhMgVkfz8DiRy/QhXSEpKwvfff2/moUr5+Djc0EGxwjbbUGSPbGg3sp/9yIb2ISEsXCE1NRULFy4081Dmjs71UTw2Gn9vOYjpK3cHuzkhhS02FFkjG9qN7Gc/sqF9SAiLiKJCyaJpXuHXVEFCCCGEiGgkhEXEcXvn+igWG4XFmw9gxip5hYUQQohIRUJYuEJ0dDS6du1q5qFOpVJF0b+9YoVttqHwj2xoN7Kf/ciG9qGqERGGsk697DqcgM4vTcOJ5FR8dEs7dDmtUpAtI4QQQmSNnt+BQR5h4QqJiYkYO3asmdtA5VLFcL28wlbbUGRGNrQb2c9+ZEP7kBAWrsBhi9euXWvVQBV3da2PojFR+GvjfsxZsxeRjo02FOmRDe1G9rMf2dA+JIRFxFK5dDFc2662+VujzQkhhBCRh4SwiGgGdmuAuJgozN+wH7+vlVdYCCGEiCQkhIUrxMTE4KKLLjJzm6hCr3DbWml1hSMZW20oTiEb2o3sZz+yoX2oakSEoazTzGw/eBxdX56OxJRUfHL72ejQoEIQLCOEEEJkjZ7fgUEeYeFapuzIkSOtrDhQrUxxXH3SK8xY4UjFZhsKL7Kh3ch+9iMb2oeEsHAtU3b37t3WVhxgrHBsdBHMXbcPf6yLzFhh220oZEPb0TVoP7KhfUgICwGgetniuKqN4xWO7FhhIYQQIlKQEBbiJHd3b2i8wr+t3Yv5G/bpuAghhBBhjoSwcIXY2Fhcf/31Zm4rNcoWxxWtT3qFp0SeVzgcbBjpyIZ2I/vZj2xoH6oaEWEo6zR7Nu87hu6vTEdyqgdfDeyA1nXKF5JlhBBCiKzR8zswyCMsXOHEiRMYNmyYmdtMrfIlcEXrmubv1yLMKxwuNoxkZEO7kf3sRza0Dwlh4RrhUnZrUPeGiIkqglmr92DBpv2IJMLFhpGMbGg3sp/9yIZ2ISEshB+v8GVn1YjYWGEhhBAiUpAQFsIP93RvhOioIpixajcWbT6gYySEEEKEIUqWizACFWyfmpqKPXv2oGLFioiKCo/3q4e/WIwv/9qC7o0rYczN7RDuhKMNIw3Z0G5kP/sJpA2VLBcY9LSzlIEDB6JIkSJ46623EAqwLRTYnIcL93RvaLzC01buxuII8AqHow0jDdnQbmQ/+5EN7UNC2EJ+/PFH/P7776hevTpCKTlg+PDhYZUkULdiPC4503uM34iA0ebC0YaRhmxoN7Kf/ciG9iEhbBk7d+403uCPP/5YAx8UAvf2aISoIsCvK3ZhyZaDhfGTQgghhCgkJIRzYOzYsbjzzjvRpk0bFC1a1HR7fPDBB9l+Z/78+ejbty/Kli2L+Ph4nH322fj8889dMdjNN9+M++67D82bN3dleyJ76hmv8MkKEhHgFRZCCCEiiZhgNyDUeeKJJ7Bx40YT+F6tWjXzd3ZMmzYNffr0QbFixXDNNdegVKlS+Oqrr3D11Vdj8+bNeOihh/LdFsYDHz16tEDbEHnnnh4N8d2irZiyfCf+2XoQzWqU0WEUQgghwgBVjciBKVOmoFGjRqhTp46JnxwyZAjGjBmDm266KdO6ycnJaNKkCbZs2YK5c+fizDPPNMtZoaFdu3bYsGEDVq1aZbblMHjwYLz00kvZtsHj8WDFihXo2rUr/vjjD9StW9cs5/zhhx/GPffcE/SsU7aRsVFxcXFhmWx1/6cL8d2ibejdtAreubENwpFwt2EkIBvajexnP4G0oapGBAaFRuRAr1690gnX7Jg6dSrWrl2L6667Lk0EEwrPxx9/3FwcH374Ybrv0Lu7fPnybCdCYb179240bNgQMTExZqJ3+v7770/3W8G8+CmuOQ9H7u3RELyn/bxsJ5ZtO4RwJNxtGAnIhnYj+9mPbGgfEsIuMn36dDPv3bt3ps8YLkFmzJiRbnmlSpWMFzm7ifTr1w9///03Fi1alDaxagQ9yl9++SWCTVJSEkaNGmXm4UjDyqVwYYvwriAR7jaMBGRDu5H97Ec2tA/FCLvI6tVegcRQioxUrVoVJUuWTFsnrzDxjpMvsbGxJm6ZXuKsOHHihJl8u1YyLmfRb26LFzCLgTtER0cbzzM92b5eQi7jZ77LfX/D92+nnewiyliWi11H/H5G4cWkRLbDdzm/z/VTUlJMCErG5VzGzxzc2Cen7dwW9+muTrXx49/bMGnpDizdegBNq5exfp98cbaZcbnN+xQu515u98mfDW3fp3C0U3b7RJxthcs+haOdstonZ/ucB2KfhPtICLsIu5WdUAh/MCbXWaewGDZsGJ555plMy1999VWT0EdatWqFiy++GBMnTsTChQvT1mFMcrdu3UzFC4Z8OFx00UU466yz8O6775pwDX/b9r1gWe6Nx4Qx1r7Qm83jQS+kA28ajMNet24dxo0bl85zfvfdd2Px4sX44Ycf0pY3aNAA/fv3x+zZs9N5293ap+uvv968aDj7VCeqPjaklMd/Ji3DqP6tw2KfHG699VYz/+9//xs2+xRO515u9mnv3r3pbBgO+xSOdspqn5hH4mu/cNincLRTbvaJNnR7nzKGVgp3ULJcHsgpWY4hEb/88ovx+vrz0taoUQNHjhwpVDHszyNcq1Yt7Nq1Ky1Zzi2PMKta+KtoEU5ehFU7j+CikXPN35Pu74x65Ytav08O3CZv3ky+ZHvDYZ/C6dzLzT4lJCRksqHt+xSOdspqn44fP57OfuGwT+Fop+z2iZWd+CykDelscnOfOHQzRbfbye6RjoSwi0L4yiuvNPG6f/75J1q3bp3pc5ZSK1euHDZt2oRgoazTgnP3uL8wYckOXNCiGkZcd5YLWxRCCCGyR8/vwKBkORdxYoP9xQHv2LHDeIP9xQ+HA3yrXbNmTbq323Dlvp5eG05Ysh2rdx5GuBBJNgxXZEO7kf3sRza0DwlhF2F8D/n5558zfTZ58uR064Qb7OJhzFQkVBxoUrU0zjujKthz9cbUNQgXIsmG4YpsaDeyn/3IhvYhIewiPXv2RP369TF+/HhT3syB8TwvvviiiRW68cYb3fxJEWSvMKtIrNkVPl5hIYQQIpJQ1YgcYOYpMz7JkiVL0pY5NYM7deqE2267zXswY2LMZ6wZ3KVLl3RDLHPwi1deeSVtVDhhN02rlzajzHGAjTenrsHr17QKdpOEEEIIkUckhHOAIjhjyZI5c+aYycERwqR79+7mO0OHDsVnn31mukmaN29uhlG++uqrEa4wa5bZrJE0NC+9whTC3y/ehnt7NELDyiVhM5Fow3BDNrQb2c9+ZEP7UNWICENZp+5y24d/Ysryneh3ZnW8Jq+wEEKIAKHnd2BQjLBwBdZIXLBgQbpaiZHA/SdjhekVXrf7CGwmUm0YTsiGdiP72Y9saB8SwsIVWDCcI+r4FkiPBJrXLIOeTSoj1QO8ZXkFiUi1YTghG9qN7Gc/sqF9SAgLUUDu7+X1Cn+7aCvW7zmq4ymEEEJYgoSwEAWkRc2y6N64Ulh4hYUQQohIQkJYuJYp26BBg4itOHB/r9PSvMIb99rpFY50G4YDsqHdyH72Ixvah6pGRBjKOg0cA96fhxmrduPK1jXxf1e2DOAvCSGEiDT0/A4M8ggL1xIEOMhIJCdaObHCXy/cik17j8E2ZEP7kQ3tRvazH9nQPiSEhWslY2bMmBHRpbfOql0OnRtVREqqByOm2RcrLBvaj2xoN7Kf/ciG9iEhHCGMGDECTZs2Rdu2bYPdlLDmgZNe4a8WbMHmffZ5hYUQQohIQkI4Qhg0aBCWLVuG+fPnB7spYU3rOuWNVzg51YOR0+3zCgshhBCRhISwcOdEiopCq1atzDzScUab++LPLdiy3x6vsGxoP7Kh3ch+9iMb2oeqRkQYyjotHK5/dy7mrNmL69rXxouXNi+kXxVCCBGu6PkdGOS+E66QlJSE77//3swFvcLeusJf/LkZWw8ct+KQyIb2IxvajexnP7KhfUgIC1dITU3FwoULzVwA7eqVR4f6FZCU4sEoS2KFZUP7kQ3tRvazH9nQPiSEhQhwXeHP52/B9oN2eIWFEEKISEJCWIgAcXb9CmhfrzwSU1IxavpaHWchhBAixJAQFq4QHR2Nrl27mrnI7BX+dN5m7DiYENKHRja0H9nQbmQ/+5EN7UNVIyIMZZ0WLh6PB1e/PRfzNuzDTefUxdMXn1HILRBCCBEO6PkdGOQRFq6QmJiIsWPHmrk4RZEiRdK8wuPnbcLOQ6HrFZYN7Uc2tBvZz35kQ/uQEBaueT7Xrl1r5iI95zSogDZ1yiExORX/mxG6scKyof3IhnYj+9mPbGgfEsJCFKZX+I9N2BXCXmEhhBAikpAQFqIQ6NSwIs6qXRYnklPx9sx1OuZCCCFECCAhLFwhJiYGF110kZmLrLzC3tHmxv2xEbsPnwi5wyQb2o9saDeyn/3IhvahqhERhrJOgxs7dunI37Bo8wHc3rke/n1B0yC2RgghhE3o+R0Y5BEWrmXKjhw5UlUjchkr/PHcjdhzJLS8wrKh/ciGdiP72Y9saB8SwsI1b+fu3btVNSIHup1WCS1rlkFCUipGh1issGxoP7Kh3ch+9iMbRpgQ3rx5M6ZOnYpjx46lLUtNTcVLL72Ejh07olevXvjpp5/caKcQYecV/uj3jdgbYl5hIYQQIpIokBB+8sknceWVVyI2NjZt2QsvvIAhQ4bg999/NyK5X79+mD9/vhttFSIs6N64MlrULIPjSSkYPWt9sJsjhBBCRCwFEsJz5swxXl9HCLNL4K233kKTJk2wadMmzJs3D/Hx8fi///s/t9or8smIESPQtGlTtG3bNiDHkOfA9ddfn+6lSGTtFb6vh+MV3oB9R0NjND7Z0H5kQ7uR/exHNowwIbxr1y7UqVMn7f9FixaZONF7770XNWvWRJs2beQRDhEGDRqEZcuWBcw7HxUVhYYNG5q5yJmep1dGsxqlcSwxBe/OCo1YYdnQfmRDu5H97Ec2tI8CqRbGA3NymD59uvF29ejRI21ZjRo1sGPHjoK1UoQ8J06cwLBhw8xc5M0r/OFvG7A/BLzCsqH9yIZ2I/vZj2wYYUK4du3aJvzB4dtvv0W1atXQuHHjtGUUwWXLli1YK4U1ZWNE7jm3aRU0rVYaRxNT8N7s0IgVlg3tRza0G9nPfmTDCBLCl19+uYkTvuKKK9C/f3/Mnj3bLPOF3fH169cvaDuFCE+vcE+vV/iD3zbgwDG9SAghhBDWCOGHH37YJF99/fXXGD9+PJo3b46nn3467fONGzcaj3G3bt3caKsQYUfvplXQpGopHDmRjPdDxCsshBBCRAquDLH8zz//mPnpp5+O6OjodEKYCXRMmmOssAjfIRoZK75nzx5UrFhRCXN5ZOKS7Rg4bgFKFY3B7Md6oEyJ4FTekA3tRza0G9nPfgJpQw2xHBhi3NhIs2bN/C5nRQnfqhIivLv5KbA5F3mjzxlV0bhKKazceRjvz1mPf517WlAOoWxoP7Kh3ch+9iMb2keBXlcOHz6MdevWISkpKd3yzz77zNSUve2227Bw4cKCtlFYkhwwfPhwJQnkg6ioU7HCFMIHj6e/ngoL2dB+ZEO7kf3sRzaMMCH86KOPomXLlumE8KhRo3Ddddfhk08+wfvvv49OnTphxYoVbrRViLDl/GZVcVqVkjickIwP5mwIdnOEEEKIiKBAQnjGjBlmZLkSJUqkLaNXkPHAM2fOxOeff25Gm9PIckLkcCFGFcG9J+sKvzd7HQ4lBMcrLIQQQkQSBRLC27dvR7169dL+X758OTZv3oz77rvPeIJZVu3iiy82olgIkT19m1dDw8olcSghGR/KKyyEEEKEthDmCCpxcXHpPMQMFO/du3faMtYQ3rp1a8FaKUIengeDBw9Odz6IvBFtvMINzd/vzl6Pw4XsFZYN7Uc2tBvZz35kwwgTwjVr1sTff/+d9v+PP/6I8uXLo0WLFmnL9u7di5IlSxaslSLkYQgMS7K5UI0vormwRXU0qBRvEuY++n1jof62bGg/sqHdyH72IxtGmBA+//zz8fPPP5uBNZ544glMmjQJF110Ubp1Vq1aZYZiFuENEyaZKJmxgojIj1fYGys8etY6M9BGYSEb2o9saDeyn/3IhhEmhIcMGWJE7quvvooXX3wRVapUwbPPPpv2+a5du8wQzF26dHGjrUJEBBe1rI76FeNx4FgSPvxNFSSEEEKIkBTCVatWxdKlS/H999+biclyDJdw4OgqrBhxxx13uNFWISLGK3yPEys8ax2OFqJXWAghhIgkCjyyXPHixXHhhRf6/axp06ZmEpGBEuXc4+KW1fHGr6uxYe8xEys8sFsDFAayof3IhnYj+9mPbGgXRTwuZTexMsSiRYvMWNilS5fGmWeeaeoJi9BCY5Xbw5d/bcHDXyxG+fg4zHq0O+KLujIiuhBCCAvR8zsEQyPImjVrcO6555pYYdYM7t+/v5nzf5ZR4+ci/ElNTTW25ly4Q78zq6NOhRLYdzQRY+cGvoKEbGg/sqHdyH72IxtGmBDm4BkcOOPXX39F48aNcfvtt+Opp54yMcFNmjTBlClT0LlzZ7OeCP9M2XHjxqlqhIvEREdhUHdvrPA7M9fhWGJgY4VlQ/uRDe1G9rMf2dA+CtTX+swzz5jKECNHjsSdd95pBtPw5e2338bAgQNNJYnRo0cXtK1CRByXtqqBN6euxuZ9xzFu7ibc3qV+sJskhBBChA0F8ghPnjzZ1A2+6667MolgQnHMzydOnFiQnxEuMGLECJO42LZtWx1Pi4iNjsI9J73Cb89ci+OJKcFukhBCCBE2FEgI0xvcrFmzbNfh57t37y7IzwgXGDRoEJYtW4b58+cH5HjyRahSpUp+X4hEwbjsrJqoWa449hxJxLg/AhcrLBvaj2xoN7Kf/ciGEVY1gjWD6WH85ptvslzn0ksvNeJry5Yt+f0Z4SLKOrWTT+ZtwpCvl6BSqaKmgkSx2OhgN0kIIUQhoud3CHqE+/TpYwbSeO+99/x+/v777+OHH37AeeedV5CfERaQkpKCBQsWmLlwn8vPqokaZYtj9+ETGP/HpoAcYtnQfmRDu5H97Ec2jDAhPHToUFSoUMFUiWjevDnuuecePPfcc2beokULU0WifPnyZj0R3iQnJ5uXHs6F+8TFROHu7t5BNf43Yy0Sktx/4ZAN7Uc2tBvZz35kwwirGsFawXPmzDFJcdOnTzfDLfvSvXt3/O9//0OtWrUK2k4hIp4rW9fCiKlrsO1gAj6dtwk3dawX8cdECCGECOqAGo0aNcLUqVOxceNGfPfdd/j444/NnP+zvvDXX3+Nnj17FvRnhIh46BUeeLKCxKgAeYWFEEKISMK1MVvp9fXn+V2xYoXxFovwz5Rt0KCBqkYEmKva1MTIaWuw/WACPv9zM27sUNe1bcuG9iMb2o3sZz+yYYRVjcgNN998Mz766CMlUYUIyjq1n49+34CnvluKamWKYfoj3VA0RhUkhBAi3NHzO0RDI4RwEgTo+VeyXOC5qk0tVCld9KRX2L2yhLKh/ciGdiP72Y9saB8SwsK1kjEzZsyQ578QYA3hgV29FSRGTVuDE8nuxArLhvYjG9qN7Gc/sqF9SAgLYSHXtKuNyqWKmgoSX/6lwWqEEEKI/CAhLISlXuG7TnqFR05bi8Tk1GA3SQghhAj/qhF9+/bN0/pLlizJ608IC4mKikKrVq3MXBQO17WvbcqobT1wHF8t2IJr29Uu0PZkQ/uRDe1G9rMf2TACqkbkR+iwnIiG3g0NlHUaXrw3ez2e+3EZapYrjmkPd0NstF5EhBAiHNHzOzDk+am5fv36PE/r1q0LTOtFyJCUlITvv//ezEXhcX372qhYsii27D+OrxcULFZYNrQf2dBuZD/7kQ0jQAjXqVMnX5MIb1JTU7Fw4UIzF4UdK1zf/P3WtDVISsn/8ZcN7Uc2tBvZz35kQ/tQP6qFPP300ybcxHdq06ZNsJslgsT17eugYsk4bN53HN8s3Co7CCGEELlEQthSWrZsie3bt6dNkydPDnaTRJAoHheNO7p4vcIjpq1BcgG8wkIIIUQkISFsKTExMahatWraVKFChaC2Jzo6Gl27djVzUfj0P7sOKsTHYePeY/h20bZ8bUM2tB/Z0G5kP/uRDe0j5IXwN998g3PPPdcIvWLFiqFevXq49tprsXnz5kJtx9ixY3HnnXeaEISiRYuacIQPPvgg2+/Mnz/flJsrW7Ys4uPjcfbZZ+Pzzz93pT3Lly9HtWrV0LBhQ9x8883YsWMHgi3Mu3XrZuai8CkRF4PbT3qF35q6Ol9eYdnQfmRDu5H97Ec2tI+QFcKs6kbhedlll5nKE9dccw0eeOABdO7cGb/99hs2btxYqO154okn8M4775jfpQDNiWnTpqFjx46YPXs2rrrqKtx1111GrF599dX4z3/+U6C2tG/f3ojwn3/+GW+99RaWLl2KHj164MSJEwgWiYmJ5mWBcxEcbji7DsrHx2HD3mP4fnHevcKyof3IhnYj+9mPbGgfISuE33jjDSM87777bqxcuRIjRozA8OHD8dFHHxkxSu9qTnz88cfZCmbWNn711VdzJd7effddbNiwAbt37zaiNjuSk5Nx++23m5rLM2fONPtB8bt48WKcdtppePzxxzO1a/DgwZkS4DJODueffz6uvPJKNG/eHOeddx5++ukn87Lw448/IpgvLmvXrjVzERzii8bgts71zN9vTV2DlNS82UI2tB/Z0G5kP/uRDe0jJIXw8ePH8cwzz6B+/fp4/fXX/cad5tQFv2XLFiNG2V3vTwyzxMmAAQPw0EMPGaGaE7169cp1GbipU6caUXjdddfhzDPPTFtepkwZI4IpvD/88MN032E7GO6Q3ZQVlSpVQt26dY0YFpHNjR3qomyJWKzbcxQ/5MMrLIQQQkQSIRnQyS7//fv3m9hXem05UMOqVatMrC0FKeNic6JmzZr45JNPTFhC9+7dMX36dNSuXTudCB43bhxuvPFG43V2E/4W6d27d6bP+vTpY+YzZszIJGY55QceK4p9imER2ZQsGoPbO9fH/01eiTemrsZFLasjOupUb4IQQgghQtwj/Ndff5k5PcEtWrTA5ZdfjiFDhmDgwIFo3LgxHn744Vxt59JLLzVimIl19Axv2rTJiOCbbrrJxLNef/31GDNmTL6Gjc6O1atXm3mjRo0yfcYKDyVLlkxbJz888sgjJuSCoRqMQb7kkktQo0YNk5gXLOihv+iii5QsFwLc2KEOyhSPxbrdR/Hj37n3CsuG9iMb2o3sZz+yoX2EpBDetWuXmTN+l+EE8+bNw+HDh434Y4wt421HjRqVq21dccUVRvRSBNMzzIoTjB1m8h3DE9wWweTgwYNmzrb7o3Tp0mnr5AcKe7afx4L7Q0/3lClTUKJEiSy/wxjrpk2bom3btggEfGk566yzVD4tBChVLBa3dfLGCr+Zh1hh2dB+ZEO7kf3sRza0j5AUws4wvXFxcfj222+NeKMXlRUjvvjiCyNe81J5gZUaKHrXrVtnypf169fPiGNba95++umn2LZtm4k1pijmvuQUvzxo0CAsW7bMlHQLBGzLyJEjVTUiRBjQsS5KF4vBml1HMGHJ9lx9Rza0H9nQbmQ/+5EN7SMkhbDjSWXN3urVq6f7rFmzZiaJjsloBw4cyHUWJxPYHFhubOfOnQh0+7Py+h46dChLb7Gt8BizooaqRoQGpYvF4tZO3rrCb05djdRceIVlQ/uRDe1G9rMf2dA+QlIIMw6YMDnOH85yVpfIzUl5xx134P333zeeYXpP6RlmmAS9qoHAiQ32FwfMWsJHjhzxGz9sO0U8Gto3lLipY12UKhaDVTuPYOI/wR1wRQghhAhFQlIIU6QSfyXDkpKSsGbNGjNSW05VFpxBOVgDmNUjWCWCCXKMEaZHmb+zfXvuuo3zAocadqpfZGTy5Mnp1gknLsIviPnmNuDApmA3RbBnongsbunojRV+49fceYWFEEKISCIkhXCDBg1M6TEKXopYXzioBkMiWBEiu1rCFMGsMjF69Og0EezEBDsJc44Ydnt44p49e5rwjfHjx2PRokVpyxkq8eKLL5rYZ5ZtCydij+/CmUVWIHrF98BbbYGpLwCJR4PdrIiHQrhU0Ris3HkYk5dmf57HxsaaF0XOhZ3IhnYj+9mPbGgfRTwhGtRJkXrOOeeYChIXXHABmjRpgoULF5pYXyaGzZ0715Qiy4qtW7eaKgb0vFKQ+hPNXE5ByuGK+/fvn217KMhZqowsWbIECxYsMEMoOzWNO3XqhNtuuy3dEMusGVysWDFT4aFUqVL46quvTL3fV155xQygEQyc+GSKclavcJUd/wCTBgMbZnn/L1Ud6PU00PxKIADVOUTuePVn1hRegyZVS2HCfZ0RpbrCQghhHQF9fkcynhBm06ZNnptuuslTtWpVT2xsrKdWrVqeQYMGeXbu3Jmr769du9aTlJSU7TorV67M1bYGDBjAF4YsJ36ekT/++MNz3nnneUqXLu0pXry4p127dp5PP/3UE0wOHjxo2su5myQkJHhefPFFT8Lx4x7P0u88nv8293iGlvZOo3t6PJv/dPX3RO7Zf/SE54ynJnnqPPajZ+KS7TnbMCFBh9dSZEO7kf3sJ5A2DNTzO9IJyZHlHGrVqmUGvMgvDE/ICdbizQ30GnPKC+3atcPEiRMRSWVjUKQI0PRioFFvYO4IYOZ/gC3zgXd7AC2vBXoOBUpXC3ZTI4qyJeJw0zl18da0NSZWuM8ZVVCEdsrKhsJqZEO7kf3sRza0C/VXi8AQWwzo/BBw3wLgzOu9yxZ/ArzZGpj5CpCUoCNfiNzaqR7i46KxbPsh/LIscKUDhRBCCJuQEBaBpVRVoN9I4PapQM12QNJRYOpzwIi2wGGV9CosysXHYcA5dc3fr/+6WvWehRBCiFBOlhN2BdtzNMA9e/agYsWKWQ9bzVNtyZfAlKFA+frAgB+8oRSiUNh3NBGdXpqKY4kpGH1jG5zbtErebShCGtnQbmQ/+wmkDZUsFxj0tBOuwJhTCuysYk9PrgS0uBK4Zz5w6dunRPCxfcDEwcDRPbJGACkfH4cbOzhe4VWZvMK5sqEIaWRDu5H97Ec2tA8JYeFacgBrPOcqSSAuHihT49T/M14C/hgFfHoyllgEjNs710Px2Gj8s/UQpq7YlX8bipBENrQb2c9+ZEP7kBAWwadpP6BaS6Db4FPLUlO9oRTCVSqULIobO9QxfytWWAghRKQjISyCT50OwO3TgQbeobUNv70OjLsC2L0ymC0LS27vUt94hf/echDTV+4OdnOEEEKIoCEhLEID36SCpOPAnDeANVOAkR2AiY8Bx/cHs3VhRcWSRdH/7Nrm79dUQUIIIUQEo6oREUagsk6ZeMXYqLi4OHeSrfauBX5+Alg5wft/8fJA98eB1jcD0SE9DowV7D58Ap1fnoqEpFR8cHNbdGtc2X0bikJHNrQb2c9+AmlDVY0IDPIIC9cufopr16rxVWgAXPsJcMM3QKXTgeP7gAkPA293BtZNd+c3IphKpYri+vbpY4Vdt6EodGRDu5H97Ec2tA8JYeEKSUlJGDVqlJm7SoMewF2zgb6vAMXLAbuWAR9d4q0wsW+du78VYdzZtT6KxkRh4aYDmLV6T+BsKAoN2dBuZD/7kQ3tQ0JYhD4MhWh3O3DvAqDdnUCRaGDFj8CI9sAvQ4ETh4PdQiupXKoYrmvvjRVWBQkhhBCRiISwsIcS5YG+LwMDf/N6ilMSgTmvAW+cBez4J9its5K7ujZAXEwU/tq4H7+v2xfs5gghhBCFioSwcA0mBxQKlZsA/b8Grv3MO1RzXAmgYqPC+e0wo0rpYriundcr/Nb09YiNLSQbCvuvQxEQZD/7kQ3tQlUjIoywyzpNTgQObAIqNvT+n5IM/PoM0O4OoGytYLfOCnYcTECXl6chMSUV429rj3MaVgx2k4QQQoT78ztEkEdYuEJqairWrFlj5oVKTNwpEUz+GgP89gbwfh8gRUlfuaFqmWK4pp33peGxLxbik3kbsffIiUBZTITjdShcQfazH9nQPiSEhWuZsuPGjQt+xYFa7YE6HYFO/wKiY73LWA5MJcGyZWC3BihVLAabDyZiyNf/oO0LU3DtO3Px4W8bjMdY2EHIXIciX8h+9iMb2oeEsAgvqrUAbvoJaHPrqWXLfwDePw/YuiCYLQtpqpUpju8GtsdZMVtxRrVSSPUAv6/bi6HfL8XZw37FpSPn4O0Za7Fx79FgN1UIIYRwDQ3RJcIPjubjjOhDT/D04cCupcDoHsCZ1wM9nwJKVQl2K0OOGmWLo2Xsdgy+awB2HU3B5KU7MOmfHfhr035Ta5jTsIkrcHq10jjvjKo4r1lVnFalpEahE0IIYS0SwsIVOJRkpUqVQk8UsT39vwSmPAP8/SmwaCyw7Fugy8PA2XcDMUWD3cKQtGGt8iVwW+f6Ztp1KAGTl+3E5H92GC/x8u2HzPTfKatQr2K8EcQUxi1qlgk9+0cYIXsdilwh+9mPbGgfqhoRYUR01unm+cCkx4Ctf3n/L1cX6P0C0OSCUx5kkS0HjiXiF4ripTswc/UeJCafSsqqXqYY+pwUxW3qlkd0lI6pEEK4RUQ/vwOIhHCEMGLECDOlpKRg1apVrl9I3O7ixYvRsmVLREdHI2RhNv2Sz4EpTwOHt3uX1esCnDccqHIGIpm82vDIiWRMW7ELk5buMPNjiSlpn1UsGYdzm3rDJzrUr2AG7RCBx5rrUPhF9rOfQNpQQjgw6OkUIQwaNAjLli3D/PnzA7L95ORk/PDDD2Ye0kRFAS2vAe75E+j8MBBdFFg/E/hfJ+DHB4GjexGp5NWGJYvG4KKW1THiurOw4Mlz8e6NbXD5WTVRpngs9hxJxCfzNmHA+/PQ+vlf8K/PFhkv8nEfsSyCb0MRWsh+9iMb2odihEVkUrQk0PNJ4KwbgF+eApZ9B/z5HvDPl8CVH3iHcBa5plhsNHo1rWKmpJRU/LFuHyb+sx2Tl+7EniMn8M3CrWYqHhuNbo0rGU9xjyaVUarYyRJ3QgghRBCQEBaRDeOEr/oI2DAbmDgY2L8eqBzZIRIFJTY6Cp0aVTTTs5c0w8JN+031iYn/7MDWA8fNnFNcdBQ6NqyA85tVMwK6fLyGBhZCCFG4SAgL1zJlGzRoYG+2et1OwJ0zgF3L0pdWm/kK0PQSoGIjhDuBsCET5pg4x+nfF5yOpdsOnRTF27F291FMW7nbTFFfA+3rVTCe4j5nVDWj3YnQsKEoPGQ/+5EN7UPJchGGgu3zwNqpwMeXAjHFgQeXASXKB84wEciaXYfTPMUUyL60ql02rVZxnQrxQWujEEKECnp+BwYlywnXEgSmT58eXkk6ZesAjfoArW9KL4LDdLjmwrZhw8qlcE+PRvjpvs6Y9Wh3PHHB6Whdp5z5zBm8o+v/Tcf5r8/C61NWY9XOw/CE6bF3i7C8DiMI2c9+ZEP7kBAWrpWMmTFjhpmHDRUaANd/DvR+/tSyHUuAd7oC62ch3AimDZ0BPL4aeA7mPd4Tz/Vrhk4NK5rQCmfwjt7/nYme/5mBlyatwN9bDkgUh5gNRcGR/exHNrQPxQgLkRPRPpfJtGHA9sXAhxcCp1/kFclMuBOuUbl0Mdxwdh0z7T+aiCnLTw3gsW7PUYyavtZMGsBDCCFEQZEQFiIvXPwmMK0q8NcYYPkPwKqfgXPuATo96C3JJlylXHwcrmxTy0wZB/DYdjABY+ZsMJMG8BBCCJEfJISFK0RFRaFVq1ZmHtbEVwAufBVoeyswabB3MI5Z/wEWjgN6PQ20uNo7aIeFhLoNnQE8OCUkpWDW6j0m2Y4eY2cAD06li8Wg1+lVzHDPXU+rZGocRwqhbkORPbKf/ciG9qGqERGGsk5dhIlbK34Cfv43sH+Dd1mN1t7hmmu1c/OXRDZwAI+56/YaUewM4OHAATy6N6lkSrJpAA8hhM3o+R0YJIQjjEBdSElJSZg4cSLOP/98xMZG2GhhySeAuSO9NYcTj3iXNb/K6yEuUwO2EA42TEn1YMHJATwmnRzAw4EDeHCQD5ZlC9cBPMLBhpGM7Gc/gbShhHBgUP+ZcIXU1FQsXLjQzCOOmKJAp38B9/4FnNnfu2zJ58BbbYDFn8EWwsGGrDLRtm55PHlhU8x+rDt+uKcTBnVvgPqV4pGYkoqpK3bh0a/+RtsXpuC60XPx0e8bsONgAsKFcLBhJCP72Y9saB+KERbCLUpVBfqNOBU/vHkeUKmxjm8QR3hqXrOMmR7p0wSrd3oH8GCyHQfw+G3tXjM99d1SnMUBPJpVxXlnVEPtCiVkMyGEiBAkhIVwmxpnAbdMBrb+BVQ/89Tyvz4AqrcCqrXUMQ8CjaqUMtO9PRth875jaaL4r437sWDTATO9OGEFmlYr7RXFzaqiUeWSGq5YCCHCGAlh4QrR0dHo2rWrmQvjjgRqtjl1KPauBX56GEhNBgbOAaqcEXKHKZJsyAE8bu9S30w7DyXg56VeUTx33T4s237ITK/+ssqEVDhDPTevUSbkRXEk2TAckf3sRza0DyXLRRgKtg/Wgd8G/PwkkHAQ6P9l+soTIS6uIgkO4PELB/D4Z4cpz8a4YocaZYub6hMUxRwKmvHIQghRWOj5HRiULCdcITExEWPHjjVz4YfS1YEr3gOuGX9q2dE9wOgewMqJXkEcZGRD7wAeV7Wphfduaou/nuyFN65thQuaV0OJuGhTgeL9Oetx1du/o/2Lv+Lxb5Zg5qrdpnxbqCAb2o3sZz+yoX0oNEK4gsfjwdq1a81cZHfF+ZTsmv1fYNsC4JNrgAY9gD7DgMpNgnb4ZMP0lCoWi4tbVjeTM4DHxH+2Y8oyb63i8X9sMpMzgAc9xV2CPICHbGg3sp/9yIb2ISEsRLDo+hgQFeOtQbx2KjDqHKDtbUC3wUCJ8rJLCEFxe27TKmZyBvCY+M8OE1vMUe2+XrjVTM4AHuc1q4bujSsZMS2EECJ0kRAWIlgUKw2c+wzQeoA3fnjFj8C8t701iLv/G2h9MxCtSzTUiI2OQudGlcz03CXNzAAeE5dwVDvvAB4TluwwU9oAHs2q4tzTq5iwCyGEEKGFkuUijEAF26ekpGDx4sVo2bKlMtbzy7rpwKQhwK5l3v8rnQ6cNwxo0B2FgWxY8C7Rf7YeMuETLM22bs/RtM+YWNe+Xnmc36wqep9RFVVKF0MgkA3tRvazn0DaUMlygUFCOMLQhRTipCQDCz4Apr4AHN/nXda4L9D7eaBCg2C3TuRBFK/ZdcQIYoZQsBybLxrAQwiRV/T8DgyqGiFcy5QdOXKkqkYUFIZCME74vgVA+4FAkWhg5QRgRHtgzhsIJLKhe7DesDN4x4T7O2PmI93x776nGwFMnME7uvzfNPR9fRbe+HW1GfmuoMmmsqHdyH72IxvahwIQhSvwAb57925VjXCL4uWA84cDrW8CJj8OrP0VKFMTgUQ2DBwctjkvA3ic36wamtUonecBPGRDu5H97Ec2tA8JYSFCGZZT6/8VsPE3oM45p5av+AkoXh6o0yGYrRP5gPHBN3Soa6Z9RxMxxWcAj3W7j2Lk9LVmcgbwOL95VZxVWwN4CCFEIJAQFiLUoVewbsdT/3N0uu/vA47tAa79DGh8XjBbJwpA+ZMDeHA6nJCEaSt3G1E8beWutAE8OFUsWRS9z6hivMUdGlQwlSuEEEIUHCXLRRiBCrZPTU3FunXrUL9+fURF6SEdUI7vB6Y8A2yaC9w1C4h2p1atbBg6cAAPjlrH8AkO4HEoITntMzOAR1OvKM44gIdsaDeyn/0E0oZKlgsMEsIW8vTTT+OZZ55Jt6x169b4888/c/yuLqQwIikBiD1Zhis5ERh3OdDqBqD5lV4vsggLEpO9A3hQFDsDeDhw6OfujSujT7Oq6NGkMkoWVSefEOGKnt+BQa47S2GNwu3bt6dNkydPDmp7Tpw4gWHDhpm5KCQcEUwWfAisnwl8fTvwXm9g61953pxsGJrExUQZz++LlzbHH4/3wud3dsAtHeuZGOJjiSn4acl23PfJQpz17C+4+f0/cOXQd/H9wk1YtfMwTiSnBLv5Ig/oGrQf2dA+5D6wlJiYGFStWhWhVjZGBAl6ghk7POtVYMs8YHQPoOV1QM+ngNLVcr0Z2TC04cAc7eqVN9OTF56OJVsPmlrFzgAe01btAVAN8z9bYtaPKgLUKl8C9SvGo0GlkqhfqSQaVIo384ol4/JclUIEHl2D9iMb2oU1HuGXXnrJ3LQ5zZ07t9B/f+zYsbjzzjvRpk0bFC1a1LTjgw8+yPY78+fPR9++fVG2bFnEx8fj7LPPxueff+5Ke5YvX45q1aqhYcOGuPnmm7Fjxw5Xtiss9g53eRi49y+g5bXeZYvHA2+2Bmb9xxtGIcIK3oNa1CyLR89rgl8f6oqf/9UFD/VqiAbRe9CiRmmUKhqDVA+wce8xk4T37uz1ePybJbj6nblo+8IUtHzmZ/QbMQcPfb4YI6atMWKatYwZiiGEEJGCFR7hf/75B0OHDjVi8ujRU8OWFiZPPPEENm7ciIoVKxoByr+zY9q0aejTpw+KFSuGa665BqVKlcJXX32Fq6++Gps3b8ZDDz2U77a0b9/eiPAmTZpg69ateOqpp9CjRw8sXLjQiHQRwdD7e+n/vINyTBoMbJkP/Pos8NeH3tHpTr9I8cNhKopPq1IKdcrWxb45n2LwHdcgLi4Ou4+cwNpdR7Fuz5FT891HsGX/cZOAt2jzATNl9DrXKlf8pAfZ6z12/q4QLy+yECK8CPlkuaSkJONJjY2NRaNGjYxn9vfffzfLcuLjjz9Gly5dUKdOnSzHBH/99ddxzz33mIdGdkyZMsX8Prc1fPhwDBkyBGPGjMFNN92Uad3k5GQjUrds2WK812eeeaZZzkoN7dq1w4YNG7Bq1ap07Ro8eLDxemdHVqbiQBa1a9c2x+byyy8PWtWIPXv2mBcFVY0IEVJTgX++BH55Cji83busbmfgvOFA1WZ+VpcNbSe3NmRVig17j5q6xWt3HTFhFRTI/P/IiVMVKjJSpnisEcSOMG5wMtSidvl4E8ssCsd+IjJtqGS5CPUIv/DCC1i6dCkWLFiAl19+Odffowi9/fbbjfd2+vTpmcQwT9YBAwZg3LhxRgRTDGdHr169cv3bU6dOxdq1a03IgiOCCQXo448/bsTzhx9+aDy5DvQQ+xPVuaFSpUqoW7cu1q9fj2B6pLh/ijkMIXgTbnEV0OQCYPZrwG9vABtmAW93Bs6+G+jzQrrVZUP7ya0NWXKtSdXSZsr4sr3r8AkjitfuplA+NWdd44PHk7Bw0wEzZfQi1y5fIi3++NS8pKmVLNy1nwhdZEP7CGkhTPFLIfzss8+iadOmefpuzZo18cknn+Cqq65C9+7djRim1zSjCL7xxhtx9913u9pu/hbp3bt3ps8YLkFmzJiRScxyyg/79+83oRoUw8FMDqCnnJ5thWeEGHHxQI9/A2fd4PUOL/0GKFY202qyof0U1IZ8iHPkO07nNKiYyYu83sdz7Dtn9Qp+xgnLd6X7XtkSsV4PMhP2Kp+aUzhrYBB37SeCj2xoHzGhXIKEIpUe1UcffTRf27j00kuNGL722mvRrVs3I1ApkOl5ZRjB9ddfb8Ib3O6+WL16tZkzlCIjrPRQsmTJtHXywyOPPIKLLrrICHt6vullrlGjhknMEyJLytYGrvwAaHcnUP1UTwU2z/cO0lGnqw6eyNaLfHq10mbK6EXeecjrRXY8yI5Iphf5wLEk/LVxv5l8iaEXuQIrWpREg8rxaHByzv/LyYsshIh0IcywAYrFv/76C9HRp0ZOyitXXHGFiQWm6KVnmFUfWLmBCWwMTwhEHBbjbwm7uPzB2FxnnfzAZDu2n3FIVapUQdeuXU08dIkSJbL8zogRI8zEYyEinDodTv2dmgL8+C9g5xJEnTssmK0SlkIvctUyxczUsWF6L/KxxGTjJc7oQeb8eFKKmXOasjz9NhlOcark26k5vcgxGl5aCBHuQpjJcK+88ooZQa1Zs8xJPXmFlRqYwNa/f38z9GG/fv2MR7ggAjuYfPrpp3n+zqBBg8zkBNsLYUhJBBp0A47sRGrTfsCU0d7la6cBUdFA7XOA6JC8TQgLKBEXgzOqlzGTL6mpHuw4lOAjjE/FIm87mIB9RxPN9GcGL3JstBOLnL4mMudlSygWWQiRd0LuCUfByvjdFi1amDgpN2DXHRPYHJh8t3PnTlSvXh2BwBGaWXl9KUbLlSuHcIIJh7RXTtU3RIgRW9xbVq3bEMTFljhlw6nPA1v/9MYSN+oNND4faNgLKOZepRERuddhVFQRVC9b3EydGmX2IvvzILP0W0JS6snQC5bR3JnueyztltGDzHnNcsWt8SLbYj+RNbKhfYScED5y5Eha/GxWN4MOHbxdu998843x7uYkgu+44w68//77xjPM2FoKbYZJsNZvIMSwExvM/WjdunW6zzjwBfeRZdTCCR5nCn+WjFHGs4XExcOTmuq1YflyKFK5CbB/PXBsL7Dkc+8UFQvU6ww07usVxmVqBrvVIgyvQ3qRm9UoY6aMXuTthxK85d4cD/LJ+sj0Lu89moi9R/dh3oZ9mbzIdSvQc5x5dD2WgwslwsF+kY5saB8hJ4SZKXvrrbf6/WzmzJlGXF588cVpJcNyOiE5Gty7775rqkewSgTDIRgXfMMNN6RVk2CJNTdhzO6wYcPw888/m1heXyZPnpy2TjjBes+jRo1StnO42PCSEd74YQ7IsXICsGICsHc1sHaqd5rwMFC1hbc0G0Ux/9aDO+iE83VIL3KNssXN1OW09BV2WPt4fZowPoK1rG6x64iJTz6RnIrVu46YKaMXuWLJounqITue5JrlSpiScIVNONsvUpAN7SPkhHDx4sWNcPUHqz1QCHMwi5wG1KAIHjhwIEaPHp1OBBNWkSC+YpjVHNyiZ8+eqF+/PsaPH4/77rsv3YAaL774ovF0syKGECGNiRE+2zud+yywZ7VXFK+cCGyaC+z42ztNHwaUrgkM+B6o0CDYrRYRSMmiMWhes4yZMnqRWbnCDBhiBg45NcIeK13sOeKd5q1P70WOi45C3YpOLPIpTzL/Ll0stLzIQogwE8JusW3bNhM6ceWVVxoRHBOTflcphimWKUg5ahwT6bKD4nz27Nnm7yVLlqQtc2oGd+rUCbfddpv5m7/Fz1gzmCPb+Q6xzHq/TAQMZs1fIfJFxUZAxfuBjvcDR/cAqyZ7hTE9xIlHgLI+g9YsHAdEx3rji4tnrlksRGF5kWuVL2Gmrhm8yIcTkvzWRaZoTkxOxaqdR8yUkUqlimaqiczSbzXKFQ+KF1kIUTDCVgizri6rT7DWbkYR7HDdddeZcmqnnXZajtujCGa5NV/mzJljJgdHCBN6mvmdoUOH4rPPPjPdJc2bNzfDKDNWORxRgkcE2TC+ItDqeu+UdNzrLXaqS3AocHqJD24Grv3UGzpBGGpBL7MIKLoOc0epYrFoUbOsmXxJSfVg24HjWJNOIHv/5qh7u09Of2T0IsdEoV6F+LRayM6cXmT+luwXOegatIsiHrpFRcSgscpFwElKAGa+7PUU3zzRW5mC/PqsN6zCJNv1Baq38g4DLYQlHKIX2U9FC3qWE1NSs/xe5VJF/Va0YLwzvdZC5Or8O1n+lGGWHI9AuIOEcIQRqAuJw1azRjNjowMxSIkIPAG34aiOwM5/Tv1fsirQ+Dyg8QVAvS5AbDH3fzPC0HUYHOhF3rr/uBHGa31qInPOGOSsKEovcsVTyXqMSy564iDandEAFUsVU+UICwnkNSghHBgkhCOMQF1IHBJ7+PDhyna2mIDb8Ng+YPUv3rjiNVO8ccUOsfFAwx5eT3GjPkB8Bfd/PwLQdRh6HDyelBZa4etJ3rj3WLZe5GKxUabOMr3G1ct4ay5XL1vM+3/Z4mYkPw57LSLnGpQQDgxhGyMshAgxSpQHWl7tnZJPABtmecuyMVzi8DZg+Q/eqUgUUOtsb2xxi6uBUlWC3XIh8g1rFbeqXc5MviSnpGLL/uPpKlms3nkYSzfuwnHEmcFDnCGos4Ll32pQHJfzFcsnxXPZYmaoatUjFiJ7JISFEIVPTFHvSHWcLvgPsH2RVxDTW7xjCbDpN+/EATwcIXz8AFC0lBLuRFjA0e7qVmQ4RDx6NEnvTXzw4UexLyHVlH7bdiDBJO9x4v/eZceNUHbKvy3ecjDL0AvHg+z1JpeQV1mIDEgIC1eg14GDnMj7YC9BsyF/j4lznLo/DhzYBKycBGz6HajmrcFtmPw4sPpn4LzhQPMrCreNlqDrMDzsVzQ2GnXii6NOhXi/6zHHff+xpDRx7AhlimZHLLOyBQcTYTk4Tjl5lR1vstejfEo0y6ucPxvqWWgPihGOMBRjJKyExW3ebA3sWwsM+MGbXEe2Lwa2LfKGUZSsHOxWChEynEhOwY6DCX69ys6cXuWcyOhVTh9+URzVFKtcaOj5HRgkhCOMQF1IKSkpWLx4MVq2bJk2gp+wi5C3YUoSsHEOUKejd7AOMuFRYN7bvJUBNducKs1WqXFEDvkc8jYUIWM/epUPHEtKF27h61Xm36ybnBuy8io7f1eIoFjlQNpQQjgwKDRCuEJycjJ++OEHnHHGGXoAW0rI25Dit3639MsoeBlSsW0hsGW+d/r1GaB8/ZOi+Hxv4p0z2EeYE/I2FCFjPwrTcvFxZmpWI/3Q1L5e5Z0HT6QTyumFcwKOJ6XkKlbZN4kvnL3KugbtIzKeDkKI8KTtrd7p0LaTyXYTgfUzgH3rgN/f8k7Fy3lLsjXpCzTo4U24E0LkSNGYaNSuUMJMOXmV0zzKJ8MxWFfZ8SozVpmDjnDKiool47wC+WT1C1bCiFSvsihcJISFEPZTuvopUXzisHdUO4riVZOA4/uBvz/1TtFxwKVvA80uC3aLhbCe/HqVtx2kV9kbt0zB7PUqJ5rp7yy8yhzCOs2j7Ijlk4I53LzKonCREBau3RAbNGigN3aLCRsb0uPb9BLvlJIMbP7DW5ZtxU/A/vVA1ean1l09Bdi2wLsuwywsJ2xsGKGEo/0K4lV2/qdXOTEfXmXfAUg48fNAH9twtGG4o2S5CEPB9iKiK0/sXQtUbHhq2Wc3AMu/B7o8AvR44lRSHnES8oQQQYUieOeh9CEX/rzKOZGVV9m3IkYoe5X1/A4M8ggL1xIEZs+ejU6dOiEmRqeVjYS9Demh8RXB5PSLgNRkoMmFp5atmgx8ezfQ6Fxvsh0H/SheFjYQ9jYMc2S/rAVsrfIlzJSVV5lDWWcsFbclH15lxiJnFMh58SrLhvahO6VwrWTMjBkz0KFDBz2ALSUibdjiKu/ky7rpwImDwD9feqeoGKBup1NVKMrWRqgSkTYMI2S//EFhWrZEnJnOqF4mR6/yqQoYJz3KJ/8/lpiCvUcTzbRka9axytXLpK984SuaKxSP0jVoGbpTCiGEL+e/BDS/0htXzIS7PSu94pjTxEeBKs29gphVKDjynWIBhQhbr7JvqbidhxOMoN6w95iZsqIYWuLCbYfQul6lAO6RcAsJYSGE8CUqGqjd3jud+4w3rtgk200ANs8Fdi7xTjNfBkpVBxqfB7TqD9RoreMoRIR6lR3RTK9yAmJRtrhyDGxBQli4QlRUFFq1amXmwk5kwyyo0AA4517vdHQvsPpnrzBe8ytweBvw5/tAlTNOCeGEQ9644xLlUdjIhnYj+9nvVd57+Di++GmKCZUQdqCqERGGsk6FcImkBGDDLK8o7vwwUKaGd/n8d71DP7e9Dej7sg63EMIV9PwODHLfCVdISkrC999/b+bCTmTDPBJbzFtZ4sL/nhLBZOcywJMClK52atmxfcCUZ4AtfwKpqQgUsqHdyH72Ixvah4SwcIXU1FQsXLjQzIWdyIYuceGrwP2LgVY3nFq2Zgow+1Xg3Z7Aq02A7+8DVk4Cko7DTWRDu5H97Ec2tA/FCAshhNuUq5v+/zK1gDMu8wriIzuBBR96p5jiQIMe3goUjfoAJZVlLoQQhYmEsBBCBJo6HbxTciKwcba3AgVLsx3aAqz8yTuhCFCrvbc0G2sWVzpNdhFCiAAjISxcITo6Gl27djVzYSeyYSEQE+f1AHPq+3/AjiUn6xVPALYv9pZn4zRlKND2duCCV/K0ednQbmQ/+5EN7UNVIyIMZZ0KEaIcpHd4ondaPxO45C2g5TXez/asAWb9B2h6sddjLISIOPT8DgxKlhOukJiYiLFjx5q5sBPZMMiUqQm0ux244Wvg0XXA6Ref+mzFj8Di8cC80em/w7rGPsiGdiP72Y9saB8KjRCuwELia9euNXNhJ7JhCFGsdPr/63cFzh4E1Djr1LKDW4H/ciCPs7wxxY37wlOmvq5Di9E1aD+yoX1ICAshRKhTvZV38mXLPD52ga1/eaepzyGubG1c4SmG6OnJQMWGQPl6QLl6QOnq3qGjhRBCpENCWAghbOSMS4HaHYBVk7xVKNZNR5EDm3AGP/t9Vfp1o+OAsrWByqcDV489tfzQNqB4OSBWw8EKISITCWHhzokUE4OLLrrIzIWdyIYWUqoq0Pom75R4FCnrZmH7khmoXjwRUQc2APvWAwc2ASmJwN41QFSG63P81cCOv4H+XwENe3mX7VoB7PzH60mmR5lCuUiRoOxepKFr0H5kQ/tQ1YgIQ1mnQkQYqSneihT71wMpyUCjk4KXvHqGt5bx3X8AlZt4l7E6xa/PnlqnaBmgfF3vICGOOHbmpWso5EKIQkLP78CgqhEW8vTTT6NIkSLppjZt2gQ9U3bkyJGqGmExsmGY2pCxweXqAPW7pRfB5F//AI+sAyo0PLWsZBWg9jlAqWre/08c9NY4XvYdMOc14If7gY8uBl5rDjxfBXjjLO8yX+iJdnn46EhA16D9yIb2oX5sS2nZsiUmTZqU9n9sbGzQM2V3796tqhEWIxtGoA0Z8hBfIf2yVv29E0k8BhzY6BW29Cjv3+Dz90YgNQnYtxYoXz/9Nt7pBiQcAO6e641LJpvnecM0HM9yifIKuSio/UTIIRvah4SwxXFIVatWDXYzhBDhTFwJr5B1xGzGkItDW73COKbYqeUnjlANeP8uU+vU8kXjgL8+OPV/0dJeUewbaqGQCyFEIROSoREJCQl48MEH0aVLF1SvXh3FihUzoq9jx44YM2YMkpKSCr1NHCzizjvvNCEIRYsWNeEIH3zgc1P3w/z589G3b1+ULVsW8fHxOPvss/H555+70p7ly5ejWrVqaNiwIW6++Wbs2LHDle0KIUSuYMgFK1GwxnHt9qeWFy0JDN4IPLre+7cDwy/qdARKVff+f+KQN1Evu5CLX59L/5u7VyrkQggR/slye/bsQa1atdCuXTucdtppqFSpEvbv34+JEydi48aN6N27t/k7KqrwdHzdunXNb1esWNGIWv5NUX7TTTf5XX/atGno06ePEfHXXHMNSpUqha+++sp875VXXsFDDz2U77Zw348cOYImTZpg69ateOqpp8z/CxcuNCI9GMH2qampWLduHerXr1+odhHuIRvajzU2ZPwwQysYYuGEWmQMuSBtbgEu/K/37xOHgWE1vX8P3nxq0JHVvwDHD5zyKFsccmGN/URQbKhkuQgSwjyRkpOTERcXl245l5177rmYPn06fvzxR1xwwQXZbufjjz82XuU6der4/TwlJQWvv/467rnnnky/lZEpU6agUaNGZlvDhw/HkCFDshTCbCdF6pYtWzB37lyceeaZZjnFJ8X9hg0bsGrVqnTtGjx4MF566aVs25CVqRhTVrt2beO1vvzyy7Pdhi4kIURIY0IutnlFcYkKQBVTGRnYswZ4twdQJBp4bP2p9T++DFj7a4aQizqZwy045zDWGlhEWIqe34EhJF85+RblT5gyLvbSSy81f69ZsybbbVCE3n777ejWrZvxwvoT2wMGDDCe2XfeeSfHNvXq1StLQZ2RqVOnmmFOr7vuujQRTOiJffzxx01W6YcffpjuO2wHwx2ym7KCHnN6rNev93k4FDInTpzAsGHDzFzYiWxoP2FhQxNyUQuo1+WUCCYcKW/wJuCBv9OvX/1MPyEXS4Dl3wNzXgd+fAD46BLg9RanQi5+H3nq+8mJwM5l3sTAIBMW9otwZEP7sCpZjuLVqZTQrFmzbNetWbMmPvnkE1x11VXo3r278SLTa+orgseNG4cbb7wRd999t6vt5G8RhnBkhOESZMaMGZnELKf8wLARin2K4WCSrmSTsBLZ0H7C3oZFS6X/v+dTeQu5YJWL5IRT3+FAI6M6AMXKeIW2w5IvvUl/xptc1+udLoSQi7C3XwQgG9pFTKifTC+++KIJCdi7dy9+/fVXrFixwiSH9ezZM8fv03tMMXzttdcazzAFKgUywxkYRnD99deb8Aa343hWr15t5gylyAiT/kqWLJm2Tn545JFHzChuFPb0fNPLXKNGDZOYJ4QQEQuHiubAIM7gIFmFXPhWszi21ztoCMWuLzNeAvasyj7kwql6UbomEB3Sj1MhRBaEvBB+5pln0v5npYaHH37YdB3lliuuuMLEAlP00jPMqg+s3MAENoYnBCIhgbHATiiEP5ik5qyTHzZv3mzaz6TCKlWqoGvXriYeukSJEll+Z8SIEWbisRBCiIjDCbng5Eu9zt4qFxkHAKnbGYiv5PUoH952KuSCU6Ztx3graHR7HGhxpXdZwiHviH4UyyxDJ4QISUJaCNNzSm8wQxm2bduGH374wXg/f//9d0yYMCHXVQ+uvvpqk8DWv39/k83Zr18/4xGOjo6GjXz66ad5/s6gQYPM5ATbuw0H9Bg4cGDQB/YQ+Uc2tB/ZMJ8w5CGjWL3w1VN/JyWkH1jEd87lKYnAvnXpQyc2/Q6Mvwqo0hwYOPvU8vnvnvQun/Qs+4RcyH72IxvaR0gLYQd6bRnSQKHF8mWM+33hhRdyrLLgQDHNBDaHpUuXYufOnaZGcSBwhGZWXl+K0XLlyiGcoLee+825sBPZ0H5kwwARWwyo1Ng7ZRlysQGo5BOSwXJvjDsu7xNywZjjn58EknwS8+JKnQyxqIsi5eqhXOlaKHKogXcZQzhisq9oJEILXYP2EZJVI7LDSUBzEtJyI4LvuOMOvP/++8YzTE8wvcIMk6CXORA4scH+4oA58AVr/vqLH7YZhrGwrJySBOxFNrQf2TCYVS46AyV9Ep6bX+FNvrv8vVPLmKTX7DKgTiegdA3KJiDxMLCTVS5+QJHf3kDspEdQZOxlwJtnAc9XBl5tCqzxKQ93cCuwYTZwaHvh7qfIFboG7cMKj7AvjnjNTRc8RTBHg3v33XeNF5lVIhgOQQ/zDTfckFZNgiO0uQljdhnH/PPPP5tYXl8mT56cto4QQogwJ6Zo+mS+S0ZkEXKxAcl71mDdn1PQsGIcog5sApKPe4exjvMZoW/lBGDCw0DjvsC1n5zyNHNZ6epAWSb01fXO4ytaO7iIEBEthJctW2ZKgWVM/jp27JgZepnkVCGBIpihFKNHj04nggmrSBBfMcxqDm7BihYcVWb8+PG477770g2owSoYrJHMsm1CCCEimAwhFyknTuCTv0ph8O2DUZS19I/uBiiIK5+ePjGP8cUcstq38gVjjzNtP96bxMdqF0YgZ5g7o/MJEcGEpBBmVYdXX30VnTp1MoKYSXEcSphDC7OMWufOnfGvf/0rR8/xN998gyuvvNKIYA7G4QvFMMUyBSlHjWMiXXbQqzx7tjfhYcmSJWnLnBANtvW2224zf/O3+BlrBnNkO39DLAe75q8QQogQhp7ckpW9ky9tbvZO6daNAro+5q2VTA8z54e3A0lHgd3LvZM/bvkZqN3e+/fm+cCOxUCN1kD1VgHaKSFCj5AcYvnPP/80o7399ttvRgAzppaJWC1atDCi8pZbbskkbP3BWGDW2s1uXQ51fNppp+W4LdYezjganC8coOODDz5It2zevHkYOnSo2Y+kpCQ0b97ceLQZqxxuQzTyNGJsFL3dSpizE9nQfmRDu3HVfskngAObgQMb0gtkZ358H/Dgcm84BfnlKe9IfO3uBPq+7F12bB/wyTX+vcmMcVbt5MDaMAMaYjmChLAIHIG6kFjijnWNWdUjELWZReCRDe1HNrSbQrUfq1ow9tgRa4vGm4Q9nHEp0OIq77KtC4DR3f1/nyEaFMPpBHJd77xay/Sx0RFEIG0oIRwYpFiEK9DjPWrUKDMXdiIb2o9saDeFaj8OVe3rsTzzOm/ynSOCCZPurhgD9HoaaH0z0KAHUL4BEB0HpCZ7vcvrZwILPwamPg98fRvw3rne2GaHRZ8APz0MrPOp9BTG/jddg/YRkjHCQgghhAgyJcp7y71lJDXVG4OcMdyCc1a5KOVTiWn1z8DSr72e4vrdvMu2LwY+ujhDyEVdn/9reytsCFEISAgLIYQQIvewy79MDe9U55zs12U9ZYrc2j7rUTAnHAR2/O2d/FGyilcQ+4rlltdEbMiFCBwSwsI1mBwg7EY2tB/Z0G7Czn5NLvBOvjTqA9w9138SH+cnDgFHdnqnLfNPxSS38qnuNOlxr4ju+ADQqJd3WeJRIOGQV0QHMVcl7GwY5ihZLsJQsL0QQoiQhfHDx/dnFsgcla/fyFPrvXsusGUecOWHwBn9vMuY7PdZfyC6aPb1k4uXs3KgET2/A4M8wsK1TFmWq+NAIqoaYSeyof3IhnYj+52sn8zYZE7Z1TM+/yVgz2qgVrtTy47u8dZUTjkB7F3tnfxRtPQpYVy+PtD7uVOfpSQXqCycbGgfqhohXMuU5cAlqhphL7Kh/ciGdiP75YEaZwEtrz5VB5lwoJEndgH3LQJu/A646A2g80NAsyuAmm2B+JODkzD0YucSYMWPwLJv02/3gwuAlxsAa6eeWkaPNP/fuxZITpQNwwx5hIUQQggRHkTHAuXreSd/JB4DDm4+FXaRMUSCy47tAYqVObVsxU/A5CHev+lxLlU9Q7iFT1JfXPkA7pwIBBLCQgghhIgM4koAlRp7J38wiY9iuKLPiLOxxYCKjYEDm4Dk48ChLd5p45zMm4+KRRXPNQHcAeE2EsLCFTiUZKVKlTS8ssXIhvYjG9qN7BcCFC/rnXxpc4t3YiLfkV1eQWyS+DakT+o7uAVFUpMQV7GOnoUWoaoREYayToUQQogAwES7w9uAMrUCUpVCz+/AoGQ54QopKSlYsGCBmQs7kQ3tRza0G9nPcqJjkFKqBhYsXKhnoUVICAtXSE5Oxg8//GDmwk5kQ/uRDe1G9rMf2dA+JISFEEIIIUREIiEshBBCCCEiEglh4Vq2c4MGDZQpazGyof3IhnYj+9mPbGgfqhoRYSjrVAghhLAPPb8DgzzCwrUEgenTpytZzmJkQ/uRDe1G9rMf2dA+JISFa2V/ZsyYoZIxFiMb2o9saDeyn/3IhvYhISyEEEIIISISCWEhhBBCCBGRSAgLd06kqCi0atXKzIWdyIb2IxvajexnP7KhfahqRIShrFMhhBDCPvT8Dgxy3wlXSEpKwvfff2/mwk5kQ/uRDe1G9rMf2dA+JISFK6SmpmLhwoVmLuxENrQf2dBuZD/7kQ3tQ0JYCCGEEEJEJDHBboAoXDweT1qskZucOHECCQkJZrtFixZ1dduicJAN7Uc2tBvZz34CaUPnue08x4U7KFkuwtiyZQtq1aoV7GYIIYQQIh9s3rwZNWvW1LFzCQnhCIxf2rZtG0qVKoUiRYq4+qZKgc0LtHTp0q5tVxQesqH9yIZ2I/vZTyBtSE/w4cOHUb16dZUqdRGFRkRgjcNAvknywpcQthvZ0H5kQ7uR/ewnUDYsU6aM69uMdJQsJ4QQQgghIhIJYSGEEEIIEZFICAtXYHbs0KFDVTHCYmRD+5EN7Ub2sx/Z0D6ULCeEEEIIISISeYSFEEIIIUREIiEshBBCCCEiEglhIYQQQggRkUgICyGEEEKIiERCWOSbsWPH4s4770SbNm1MpixHqvvggw90RC1h69ateO2119C7d2/Url0bcXFxqFq1Ki6//HL88ccfwW6eyAUJCQl48MEH0aVLFzPaVLFixYwNO3bsiDFjxiApKUnH0UJeeuklcz/lNHfu3GA3R+RA3bp10+yVcerWrZuOX4ijqhGiQBf/xo0bUbFiRcTHx5u/+fC96aabdFQtYPDgweaB26BBA3OzrlSpElavXo1vv/3WDOU5fvx4XH311cFupsiGPXv2mOFc27Vrh9NOO83YcP/+/Zg4caK5HvmSw785oqSwg3/++cc4F2JiYnD06FH8/vvvOPvss4PdLJHDs/DAgQN44IEH/H6mZ2JoIyEs8s2UKVPQqFEj1KlTB8OHD8eQIUMkhC3i66+/RoUKFdC1a9d0y2fNmoWePXuiZMmS2L59u2pDhzCpqalITk423nxfuOzcc8/F9OnT8eOPP+KCCy4IWhtF7qEHn6I3NjbW3FvZ6yYhHPpQ7JINGzYEuykiH8hNIPJNr169jAgWdnLZZZdlEsGkc+fO6N69u/EsLlmyJChtE7mDnt6MIpjQm3jppZeav9esWaPDaQkvvPACli5divfffx/R0dHBbo4QEUFMsBsghAg96JFyBJWw01M8adIk83ezZs2C3RyRCxYsWGCE8LPPPoumTZvqmFnGiRMnTI7Mtm3bULp0abRt2xbt27cPdrNELtBTTgiRjk2bNpmwl2rVqqF58+Y6OhaQmJiIF1980cR27927F7/++itWrFiBm2++2YS5iNAXUTfeeCPOPPNMPProo8FujsgHO3bsMNebLxTDn3zyicnDEKGLhLAQIl2M4g033GAezEykU/esPUL4mWeeSfuf2eoPP/wwhg0bFtR2idzx1FNPmUTVv/76S9echVAAM6SMvS/MrVi1ahVeffVVfPzxx+ZFlCFmpUqVCnYzRRYoRlgIkdadzuzmmTNn4vbbbzeCWNgBH770BqekpGDz5s0YMWIE3n33XVMN5NChQ8FunsgGJsO98soreOKJJxTGYilDhw5Fjx49ULlyZZQoUcJ49j/66CNzD2X1ltGjRwe7iSIbJISFEEYE33LLLaZkWv/+/fG///1PR8XS5LmaNWti4MCBeOeddzBnzhwTdypCE1b3GDBgAFq0aGHKGYrwgnX2Ca9DEbooNEKICIcimF179GBce+21JuFDdWfthzWECUuoidDkyJEjJiSC+Kv+QTp06GDm33zzDfr161eo7RMFgzX2CetBi9BFQliICMZXBHPwDMa0KS44PGD2um8FEBF6cETOW2+91e9nDFGiSL744ovNQClOrVphD84InbJdaCMhLESEh0NQBF955ZWmeL9EsF0sW7bMPGQZl+jLsWPHzNDLpG/fvkFqnciJ4sWLm1hufzBen0KYAxVpZLnQhdVZOER9xmuQyx977DHz93XXXRek1oncICEs8g1v4LNnzzZ/OwMvcJnTFdupUyfcdtttOsIhCuuVfvjhhybRisPzPv/885nWYVcsEz9EaPL555+b7HReaxTErF+6detWM6wyy6gxk/1f//pXsJspRNjy6aefmmuwS5cuZoCp+Ph4UzViwoQJpgoPX2T4mQhdJIRFvqEIppDyhUkBvokBEsKhizMcKOMUs0qooriSEA5dLrzwQhMC8dtvv5nqA7RlmTJlTPLVNddcYzz+GhRFiMDBUTiXL1+OhQsXmuHp2RvD2GD2xNx9991psfoidCniYc0dIYQQQgghIgyVTxNCCCGEEBGJhLAQQgghhIhIJISFEEIIIUREIiEshBBCCCEiEglhIYQQQggRkUgICyGEEEKIiERCWAghhBBCRCQSwkIIIYQQIiKREBZCCGFGEeQkhBCRhISwEEK4OGx1kSJFsp0kNoUQInSICXYDhBAi3GjQoAH69+/v97OyZcsWenuEEEL4R0JYCCFcpmHDhnj66ad1XIUQIsRRaIQQQgQJhkp069YNW7ZswbXXXouKFSuiRIkS6NixI6ZMmeL3O3v27MEDDzyAevXqoWjRoqhcuTKuuuoq/PPPP37XT0xMxH//+1+0bdsWpUqVQsmSJdG0aVM8+OCD2L9/f6b1jxw5gvvvvx/Vq1c322/RogW+/PLLTOsdPHgQTz31lNkWt1m6dGnzAjBgwABs3LjRhaMjhBCBp4jH4/EUwu8IIURExAhToPbp0weTJk3KlRCm0Dxw4AAqVaqEXr16Yffu3fjss8+QkJBgBGi/fv3S1udnHTp0wNq1a42APvvss7F+/XqzHkXr5MmT0alTp7T1jx8/jnPPPRdz5sxBo0aNcN5555n1Vq9ejV9++cUsP/PMM826jF1OSkpCnTp1jEBmW44dO4ZPP/3UbIf707t3b7MuHxtsxx9//GFEe7t27RAVFWUEMAX8F198Yb4vhBChjoSwEEK4LISzixGmeKUgNTfgIkXM/LrrrsPYsWPT/v/777+NB7dMmTJGXBYvXtwsv+WWWzBmzBgMGTIEL774Yto2J0yYgAsuuMB4ZFeuXGlEKXn44Yfxn//8BzfccIP5XnR0dDqPLv+nN9cRwvytSy65BJ9//jni4uLM8l9//dWIWl9xv2TJEiPgKdK/+eabdPt34sQJI6id7QohRCgjISyEEC4L4exg2MFrr73mvQEXKWLEKD289MT6ctttt+G9994z3t7LL7/chDhQGMfHx2PTpk0mhMIXemvp5Z05cyY6d+6M5ORklC9f3ohieo3LlSuXbbscIbxu3bpM+8DPDh8+jL1796YTwgznGD9+fJ6OkRBChBKKERZCCJeh95ThA/4mRwQ71K5dO5MIJhSzZOHChWa+YsUKEy7BMISMIph0797dzBctWpS2PsUrPcs5iWDfihb+hHzNmjVN+IbD6aefboTwJ598gi5duuDVV1/FggULkJqamqvfEUKIUEFCWAghgkiVKlWyXc4QBnLo0KFs169WrVq69Zzv1ahRI9dtocfZHzExMelELv+fOnUq7rnnHqxZswYPPfQQWrdujapVq+LZZ59FSkpKrn9TCCGCiYSwEEIEkZ07d2a73BGnrMqQ3fo7duxIt55Tr3jr1q0BaDVQoUIFvPnmm2b7y5Ytw1tvvWVCMYYOHYqXX345IL8phBBuIyEshBBBhPG+/sqNzZo1y8xbtWpl5k2aNEGxYsUwf/58U80hI9OnTzdzpwpE48aNjSjm+v7KpLkF45wZKjFo0CATo0y+//77gP2eEEK4iYSwEEIEEYYRPP744yZ+2IFVIz7++GNTUq1v375mGas4MDmNdYSHDRuWbhus5sDSaawawXJmTvjCnXfeaUIkmKCXMVyBy1kzOL9JgZwy4nirKdiFEMIGVDVCCCEKsXwaGTx4sBGL2dURZu3er776KlMdYZZfY2WHHj16oH379uY3WbeXQjljHWEm17GaBL3LrCN8/vnnmzrC/D7F8+zZs9PVEXb2ISOsWTxjxow0sf7tt9/isssuM4l7HFCDscEMkeByimuWVLv44ot1XgkhQh4JYSGEKMTyaYShCozhpRDu2rWrqSHMmr8MLWDYA8MhnnnmGTMYRkboEX7uuefw3XffYdu2bSaGmEKVsbnNmjXLtD7r+jJ+l7/BGsMs18ZKFRTFTzzxRFoscV6EMEfCGzFihAnHoKimkKcYbtOmDR555BEj1oUQwgYkhIUQIlg34JNC2InvFUIIUbgoRlgIIYQQQkQkEsJCCCGEECIikRAWQgghhBARSUywGyCEEJGKb8k0IYQQhY88wkIIIYQQIiKREBZCCCGEEBGJhLAQQgghhIhIJISFEEIIIUREIiEshBBCCCEiEglhIYQQQggRkUgICyGEEEKIiERCWAghhBBCRCQSwkIIIYQQApHI/wOt8ZmrR91rFQAAAABJRU5ErkJggg==" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[34mSelected the model at the epoch 5.\u001B[0m\n" + "\u001b[34mSelected the model at the epoch 5.\u001b[0m\n" ] } ], - "execution_count": 8 + "source": [ + "# First training without few samples in the future\n", + "lat_dyna_control.trainModel(training_params=training_pars, prediction_samples=5)" + ] }, { + "cell_type": "code", + "execution_count": 9, + "id": "beac2f15f1c62932", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T20:36:41.115404Z", "start_time": "2025-12-09T19:53:07.919490Z" } }, - "cell_type": "code", - "source": [ - "# Training with integral error 4s in the future\n", - "lat_dyna_control.trainModel(training_params=training_pars,\n", - " num_of_epochs=10,\n", - " prediction_samples=80, # 4s in the future\n", - " step=10)" - ], - "id": "beac2f15f1c62932", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['control_steer']\u001B[0m\n", - "\u001B[32mnum of epochs: 10\u001B[0m\n", - "\u001B[32mupdate per epochs: 453\u001B[0m\n", - "\u001B[34mâ””>len(train_indexes)//(batch_size+step)\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mearly stopping: early_stop_patience\u001B[0m\n", - "\u001B[32mearly stopping params: {'error': 'heading_error', 'patience': 3}\u001B[0m\n", - "\u001B[32mprediction samples: 80\u001B[0m\n", - "\u001B[32mstep: 10\u001B[0m\n", - "\u001B[32mclosed loop: {}\u001B[0m\n", - "\u001B[32mconnect: {}\u001B[0m\n", - "\u001B[32mtrain dataset: training_set\u001B[0m\n", - "\u001B[32m\t- batch size: 16\u001B[0m\n", - "\u001B[32m\t- num of samples: 12100\u001B[0m\n", - "\u001B[32m\t- num of first samples: 11780\u001B[0m\n", - "\u001B[32mvalidation dataset: validation_set\u001B[0m\n", - "\u001B[32m\t- batch size: 64\u001B[0m\n", - "\u001B[32m\t- num of samples: 5560\u001B[0m\n", - "\u001B[32m\t- num of first samples: 5400\u001B[0m\n", - "\u001B[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['control_steer']\u001b[0m\n", + "\u001b[32mnum of epochs: 10\u001b[0m\n", + "\u001b[32mupdate per epochs: 453\u001b[0m\n", + "\u001b[34mâ””>len(train_indexes)//(batch_size+step)\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mearly stopping: early_stop_patience\u001b[0m\n", + "\u001b[32mearly stopping params: {'error': 'heading_error', 'patience': 3}\u001b[0m\n", + "\u001b[32mprediction samples: 80\u001b[0m\n", + "\u001b[32mstep: 10\u001b[0m\n", + "\u001b[32mclosed loop: {}\u001b[0m\n", + "\u001b[32mconnect: {}\u001b[0m\n", + "\u001b[32mtrain dataset: training_set\u001b[0m\n", + "\u001b[32m\t- batch size: 16\u001b[0m\n", + "\u001b[32m\t- num of samples: 12100\u001b[0m\n", + "\u001b[32m\t- num of first samples: 11780\u001b[0m\n", + "\u001b[32mvalidation dataset: validation_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 5560\u001b[0m\n", + "\u001b[32m\t- num of first samples: 5400\u001b[0m\n", + "\u001b[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", " 'B': 'Mul72',\n", " 'loss': 'mse'},\n", " 'heading_error': {'A': 'Add82',\n", " 'B': 'Add92',\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.001}\u001B[0m\n", - "\u001B[32moptimizer params: [{'lr': 0.0, 'params': 'A_0'},\n", + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.001}\u001b[0m\n", + "\u001b[32moptimizer params: [{'lr': 0.0, 'params': 'A_0'},\n", " {'lr': 0.0, 'params': 'A_1'},\n", " {'lr': 0.0, 'params': 'A_2'},\n", " {'lr': 0.0, 'params': 'A_3'},\n", @@ -2137,85 +2232,115 @@ " {'params': 'Fir_target_4'},\n", " {'params': 'Fir_target_5'},\n", " {'params': 'Fir_target_6'},\n", - " {'params': 'Fir_target_7'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=========================== nnodely Training ===========================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m curv_error |\u001B[0m\u001B[32m heading_error |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 1/10 |\u001B[0m\u001B[32m1.346e-05|\u001B[0m\u001B[32m2.467e-06|\u001B[0m\u001B[32m1.081e-03|\u001B[0m\u001B[32m3.308e-04|\u001B[0m\u001B[32m5.473e-04|\u001B[0m\u001B[32m1.666e-04|\u001B[0m\n", - "\u001B[32m| 2/10 |\u001B[0m\u001B[32m1.211e-05|\u001B[0m\u001B[32m2.186e-06|\u001B[0m\u001B[32m4.719e-04|\u001B[0m\u001B[32m2.834e-04|\u001B[0m\u001B[32m 2.42e-04|\u001B[0m\u001B[32m1.428e-04|\u001B[0m\n", - "\u001B[32m| 3/10 |\u001B[0m\u001B[32m 1.19e-05|\u001B[0m\u001B[32m2.095e-06|\u001B[0m\u001B[32m4.269e-04|\u001B[0m\u001B[32m2.913e-04|\u001B[0m\u001B[32m2.194e-04|\u001B[0m\u001B[32m1.467e-04|\u001B[0m\n", - "\u001B[32m| 4/10 |\u001B[0m\u001B[32m1.156e-05|\u001B[0m\u001B[32m1.922e-06|\u001B[0m\u001B[32m4.108e-04|\u001B[0m\u001B[32m2.316e-04|\u001B[0m\u001B[32m2.112e-04|\u001B[0m\u001B[32m1.168e-04|\u001B[0m\n", - "\u001B[32m| 5/10 |\u001B[0m\u001B[32m1.157e-05|\u001B[0m\u001B[32m1.890e-06|\u001B[0m\u001B[32m3.791e-04|\u001B[0m\u001B[32m1.919e-04|\u001B[0m\u001B[32m1.953e-04|\u001B[0m\u001B[32m 9.69e-05|\u001B[0m\n", - "\u001B[32m| 6/10 |\u001B[0m\u001B[32m1.158e-05|\u001B[0m\u001B[32m1.828e-06|\u001B[0m\u001B[32m3.607e-04|\u001B[0m\u001B[32m1.696e-04|\u001B[0m\u001B[32m1.862e-04|\u001B[0m\u001B[32m8.570e-05|\u001B[0m\n", - "\u001B[32m| 7/10 |\u001B[0m\u001B[32m1.154e-05|\u001B[0m\u001B[32m1.845e-06|\u001B[0m\u001B[32m3.389e-04|\u001B[0m\u001B[32m1.798e-04|\u001B[0m\u001B[32m1.752e-04|\u001B[0m\u001B[32m9.084e-05|\u001B[0m\n", - "\u001B[32m| 8/10 |\u001B[0m\u001B[32m1.157e-05|\u001B[0m\u001B[32m1.719e-06|\u001B[0m\u001B[32m3.202e-04|\u001B[0m\u001B[32m1.381e-04|\u001B[0m\u001B[32m1.659e-04|\u001B[0m\u001B[32m6.992e-05|\u001B[0m\n", - "\u001B[32m| 9/10 |\u001B[0m\u001B[32m1.143e-05|\u001B[0m\u001B[32m1.718e-06|\u001B[0m\u001B[32m3.073e-04|\u001B[0m\u001B[32m1.345e-04|\u001B[0m\u001B[32m1.594e-04|\u001B[0m\u001B[32m6.813e-05|\u001B[0m\n", - "\u001B[32m| 10/10 |\u001B[0m\u001B[32m1.115e-05|\u001B[0m\u001B[32m1.688e-06|\u001B[0m\u001B[32m2.714e-04|\u001B[0m\u001B[32m1.218e-04|\u001B[0m\u001B[32m1.413e-04|\u001B[0m\u001B[32m6.175e-05|\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 2612.6510860919952\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " {'params': 'Fir_target_7'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=========================== nnodely Training ===========================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m curv_error |\u001b[0m\u001b[32m heading_error |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 1/10 |\u001b[0m\u001b[32m4.895e-06|\u001b[0m\u001b[32m2.495e-06|\u001b[0m\u001b[32m9.374e-04|\u001b[0m\u001b[32m3.025e-04|\u001b[0m\u001b[32m4.711e-04|\u001b[0m\u001b[32m1.525e-04|\u001b[0m\n", + "\u001b[32m| 2/10 |\u001b[0m\u001b[32m 2.97e-06|\u001b[0m\u001b[32m2.283e-06|\u001b[0m\u001b[32m3.314e-04|\u001b[0m\u001b[32m2.621e-04|\u001b[0m\u001b[32m1.672e-04|\u001b[0m\u001b[32m1.322e-04|\u001b[0m\n", + "\u001b[32m| 3/10 |\u001b[0m\u001b[32m 2.66e-06|\u001b[0m\u001b[32m 2.07e-06|\u001b[0m\u001b[32m 2.93e-04|\u001b[0m\u001b[32m2.328e-04|\u001b[0m\u001b[32m1.478e-04|\u001b[0m\u001b[32m1.174e-04|\u001b[0m\n", + "\u001b[32m| 4/10 |\u001b[0m\u001b[32m2.502e-06|\u001b[0m\u001b[32m1.834e-06|\u001b[0m\u001b[32m2.617e-04|\u001b[0m\u001b[32m1.678e-04|\u001b[0m\u001b[32m1.321e-04|\u001b[0m\u001b[32m8.480e-05|\u001b[0m\n", + "\u001b[32m| 5/10 |\u001b[0m\u001b[32m2.267e-06|\u001b[0m\u001b[32m1.701e-06|\u001b[0m\u001b[32m2.269e-04|\u001b[0m\u001b[32m1.458e-04|\u001b[0m\u001b[32m1.146e-04|\u001b[0m\u001b[32m7.377e-05|\u001b[0m\n", + "\u001b[32m| 6/10 |\u001b[0m\u001b[32m2.125e-06|\u001b[0m\u001b[32m1.585e-06|\u001b[0m\u001b[32m2.014e-04|\u001b[0m\u001b[32m1.291e-04|\u001b[0m\u001b[32m1.018e-04|\u001b[0m\u001b[32m6.532e-05|\u001b[0m\n", + "\u001b[32m| 7/10 |\u001b[0m\u001b[32m1.981e-06|\u001b[0m\u001b[32m1.514e-06|\u001b[0m\u001b[32m1.725e-04|\u001b[0m\u001b[32m1.269e-04|\u001b[0m\u001b[32m8.724e-05|\u001b[0m\u001b[32m6.422e-05|\u001b[0m\n", + "\u001b[32m| 8/10 |\u001b[0m\u001b[32m1.852e-06|\u001b[0m\u001b[32m1.398e-06|\u001b[0m\u001b[32m1.472e-04|\u001b[0m\u001b[32m9.547e-05|\u001b[0m\u001b[32m7.454e-05|\u001b[0m\u001b[32m4.844e-05|\u001b[0m\n", + "\u001b[32m| 9/10 |\u001b[0m\u001b[32m1.769e-06|\u001b[0m\u001b[32m1.299e-06|\u001b[0m\u001b[32m1.322e-04|\u001b[0m\u001b[32m8.054e-05|\u001b[0m\u001b[32m6.699e-05|\u001b[0m\u001b[32m4.092e-05|\u001b[0m\n", + "\u001b[32m| 10/10 |\u001b[0m\u001b[32m1.623e-06|\u001b[0m\u001b[32m1.273e-06|\u001b[0m\u001b[32m1.079e-04|\u001b[0m\u001b[32m7.150e-05|\u001b[0m\u001b[32m5.477e-05|\u001b[0m\u001b[32m3.639e-05|\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 5015.101270914078\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[34mSelected the model at the epoch 10.\u001B[0m\n" + "\u001b[34mSelected the model at the epoch 10.\u001b[0m\n" ] } ], - "execution_count": 9 + "source": [ + "# Training with integral error 4s in the future\n", + "lat_dyna_control.trainModel(\n", + " training_params=training_pars,\n", + " num_of_epochs=10,\n", + " prediction_samples=80, # 4s in the future\n", + " step=10,\n", + ")" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# Plots", - "id": "583107a320c3507e" + "id": "583107a320c3507e", + "metadata": {}, + "source": [ + "# Plots" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### FIR filters weights", - "id": "cebe84713bc43261" + "id": "cebe84713bc43261", + "metadata": {}, + "source": [ + "### FIR filters weights" + ] }, { + "cell_type": "code", + "execution_count": 10, + "id": "345b6b768a49e855", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T20:36:41.424463Z", "start_time": "2025-12-09T20:36:41.159691Z" } }, - "cell_type": "code", + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "params_fir_target = {}\n", "params_fir_ic = {}\n", @@ -2225,19 +2350,19 @@ "plt.figure()\n", "\n", "for key, value in lat_dyna_control.parameters.items():\n", - " if key.startswith('Fir_target'):\n", + " if key.startswith(\"Fir_target\"):\n", " params_fir_target[key] = lat_dyna_control.parameters[key]\n", "\n", - " if key.startswith('Fir_InitCondition'):\n", + " if key.startswith(\"Fir_InitCondition\"):\n", " params_fir_ic[key] = lat_dyna_control.parameters[key]\n", "\n", "for key, value in params_fir_target.items():\n", " vals = np.array(value).flatten()\n", " t = np.arange(0, sampling_time * len(vals), sampling_time)\n", - " plt.plot(t,vals * W_prev.flatten(), 'o', label=key)\n", + " plt.plot(t, vals * W_prev.flatten(), \"o\", label=key)\n", "\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('amplitude [m-1 rad-1]')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"amplitude [m-1 rad-1]\")\n", "plt.legend()\n", "plt.grid(True)\n", "plt.show(block=False)\n", @@ -2245,325 +2370,191 @@ "plt.figure()\n", "for key, value in params_fir_ic.items():\n", " vals = np.array(value).flatten()\n", - " t = np.arange(sampling_time, sampling_time * (len(vals)+1), sampling_time)\n", - " plt.plot(t,np.flip(vals * W_past.flatten()),'o',label=key)\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('amplitude [-]')\n", + " t = np.arange(sampling_time, sampling_time * (len(vals) + 1), sampling_time)\n", + " plt.plot(t, np.flip(vals * W_past.flatten()), \"o\", label=key)\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"amplitude [-]\")\n", "plt.legend()\n", "plt.grid(True)\n", "plt.show(block=False)" - ], - "id": "345b6b768a49e855", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAG6CAYAAAAGUjKQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1+BJREFUeJzsnQd4FNXax990khACBEjovYP03gUERRBFRbGgF7HrxYpyLeC9IngVe0VREUUUG/ipiAhIVZBy6V06BAIJIb3s9/xPOGF2dmZ2dnd2d8r5PU8YdubM7rx7ZmfeeWuEy+VykUAgEAgEAoHDiQz3AQgEAoFAIBCYAaEUCQQCgUAgEAilSCAQCAQCgaAMYSkSCAQCgUAgEEqRQCAQCAQCQRnCUiQQCAQCgUAglCKBQCAQCASCMqIvLAVeKC0tpWPHjlFSUhJFRESI70sgEAgEAguAcozZ2dlUq1YtiozUdpAJpUgnUIjq1q1rxPwIBAKBQCAIMYcPH6Y6depojhFKkU5gIeJfaqVKlchICgsL6dtvv6Wrr76aYmNjySkIucV8OwGnnudOll3IfbWp5vvcuXPMqMHv41oIpUgn3GUGhchopaigoKDcNRcXF0dOQcgt5tsJOPU8d7LsQu4kU863ntAXkX0mEAgEAoFAIJQigUAgEAgEgjKEpcgEREdH0/Dhw9nSSQi5xXw7Aaee506WXcgdTVYlwoVcNYGuQK3k5GTKysoyPKZIIBAIBAJB+O/fwlJkkkyFt99+my2dhJBbzLcTcOp57mTZhdyFZFWEUmQCYKw7deoUWzoJIbeYbyfg1PPcybILuV1kVazr+BMIBAKBboqKiqikpCTkFpPExESWou4kxUjIXRD0+Y6JiaGoqCjD31coRQKBQGDzeIrTp08zxSTU4MbYq1cvOnLkiKPaIwm5jwR9vvH+iBNKS0sz9LNEoLUJAq3RV23//v3UqFEjr31Z7ISQW8y3EwjneY7r1tGjR6lixYrs+oWn61AqJ1AOYDVBdWOnKUVC7oigfr85OTnMNVuzZk2qXLmyYfdvoRSFWSnCBfPgwYN0/vx5duGqX7++oxQjgUAQPKCMQRFCvycnKSUCZ3D06FGmHDVt2lTz/BbZZxZh+/bt9Oqrr9Inn3xCX3/9NVviNdY7AZjzX3jhhbCY9cOJkFvMd6hiiHCu4WEuXAoRHvqOHz/Olk5CyF0aku8ZBgrEyRkZKydMEmECis+XX37JNFgpeI31TlGMnJaqyxFyO4twzDe/UcBSFE6cFGAtRcgdfHhR0OLiYsPeUyhFYXqK+PnnnzXHYLvTnq4EAoHxCLeZwK5EBMECKpSiMIAYIrmFSA62Y5xAIBAIBILQIJSiMICgaiPHWRWY9e+5556wm/dDjZBbzLeTnuSrV6/uOGuVkDuCrIpQisIAssyMHGdVeJ0JJ14whdzOwanzzQlGgT0rIOS2JkIpCgNIu/eW1o/tGGf34NNp06Y5LuhYyC3m20nBxidOnDB90PGyZcuY0jp58mRHyW00LhvILZSicHzpkZE0dOhQzTHYLuoVCQQCQWD8/fffTOHR+svMzAzq19ygQQP2ZweWGaRA4vvwNi8rVqygUCPafISJVq1a0fXXX8+yzKRB17AQQSHCdoFAILACJaUu+vPAGUrPzqcaSRWoa8OqFBVpLndh48aN6eabb1bcdtlll9GOHTuoWrVqIT8upzJhwgRFZRQtad566y2qUqUKdenSJeTHJZSiMALFp0WLFrR37176/PPPacyYMdSkSRNhIRIIBJbh563HacrC7XQ8K798Xc3kCvTs8FZ0WatUMgu4tmpZN3AtFoRWKVLi5ZdfZksosBUqVKBQI9xnYQYuMpQof/LJJ9nSSS4z9EN64okn2NJJCLnFfNtJIbpnzgY3hQicyMpn6xdtO2l4w85QuoS42wsWjfvvv5/q1q3LCgZ+/PHHmu+H94LcKKuC/2PJ/8//+GchxvCNN96gIUOGsPePi4ujGjVq0DXXXEMbN270eG98NvbHcuHChazhblJSkpt7Di7D0aNHU9WqVVnCTr9+/ej3339nn4l9Ia8cbB8+fDizluEYcD966qmnKDc3t3wM9h8wYAD7/5QpU9zk4W7KQOf7ww8/ZMtx48ZROBCWIhOAoDT0VMPJaPaLh5EIucV8OwG7nudwmcFCpBRSi3WQ9LkfttOAZikUF2vdMgxolXLppZeyEikjRoxgSlFqaqquiuJoVPrss8+y9k1y60j//v3Z8syZM2x9nz596IorrmBuI/SsW7BgAf30009MWVFyI3311Vf0yy+/0JVXXkn33ntveRgG+oH17NmTtVdBKEaHDh1o165dNHjwYCaHEu+88w7dd9997HihGEEpW79+PT3//PO0dOlS9oeHORwzlB+0pIKixWUAvCkr5OaVpn1l9erVzI3ZuXNnateuHYUDoRSZAPQowkkJqwk0dKcg5Bbz7QTsep4jhkhuIZIrRtj+6+YDdEVn7YadoQBhCkruM29JL8imwg161apVFB8fr1sRRgd3WE3wmdyypPT5UIIOHTpEtWvXdlu/bds26t69O02aNIkWL17ssR/iURctWkSDBg1yW4/zDAoRFBrsy5k1a5ai9QUtpR588EG65JJLaMmSJZSSklK+DdnB8GLAkvXII4+UK0FQivB/uTzowsDl9me+uZXojjvuoHAhlCKBQCAQ+AyCqvVwOqfIFN/uvn37mMtHDiwc7du319z3xRdf1K0Q+QoUZblCBFq3bs1cVVB8oFjLi9xeddVVHgoRrFqwIMHSAyVGyu23387kgNVIynvvvcd6h0HxSZEoRODxxx+nGTNm0Ny5cz3ez2hgiUPfz4SEBLrxxhspXAilSCAQCAQ+gywzPVRLNIfrDDE7aj0nlWJsOAj2bdu2bRCPjGjTpk1MYVm5ciWzTEEJkmdk1axZ021d165dPd4HCg8UI7if5FZJWG7gVpMrRWvXrmVLKF9LlizxeE8oYzt37qRgM2/ePKYYjR071msdv2AilCKT4LRgY46Q21mI+bYPSLtHlhmCqpXiiuA8SUuuQO1rJ5GVgdXFH1eQ3n0QR8NjfVAaAAHOCI7G/t999x1t3ryZKTpylOKaeFwRjlkJpX0Q0wTgbjMCf92kZnCdAaEUmQBo9PDbOg0ht7MQ820vUIcIaffIMsNtUKoY8dsittep7W7hsBr+3OSRRSy37KgBZQRKDwoV9u7d28OKA6VI73FxC0t6erriPidPnlTdBwpVUlJgCqwvcsvjmtasWcPKIsi/g1DjnPxvE4PgNAQBYunrfgcOHKAtW7awpa/7W1VuqyPkFvNtF4a2qUnv3NyRWYSk4DXWD2mdRvn5+ZZu++APkFcqN/qgIStLLdYJqfNyZQCp8Bs2bPDpc5s3b84ePv766y8P6xKOBYqHnG7durm50fT2dFOSRy63VdLwpQilyATAf/zZZ595+JG9adZI80QWwNdff82WeI31dpbbDgi5xXzbTTFaOfFSmju+O712Q3u2xGusx80R7hknKkVSuaH0IC4ICoMc9Lg8e/YsyzbjQOF49NFHWSaXL0Ahuvbaa5lFiJcB4MyePVsxNgjp/Eihf+CBB1gWnBzUaJLWS4Is4PDhw17l1ns9/PTTT1ns0q233krhRrjPLAgUH0Tpy4H5E+vRPkS0CREIBKF0pfVo7J65JLgIYoZQ9+fyyy9n9YgQW9e3b1/2B2UE9YZgKcK1G4HdCPxGvSGkvWsFgSvxwgsv0K+//spS85cvX15ep+iHH35g5QcQbC4tEtymTRt6++236Z577mGWJtRKQkuU7OxsVi8J73HbbbfRu+++y8bDxVWrVi364osvmBJWp04d5sqDHP6431CPCcofilWqxUKFEqEUWQy4XtQyKDjYjhPXSdWxBQKBwKw8/fTTzBoExQSxQ7AEoagjlCIUX5w/fz5NnTqV5syZw1LSoUR9++239Nxzz/n8WaiKDTfZxIkTmbIFpaZTp07s/0jXB/LsrvHjx7OyBDNmzGDFIlEpOzk5merVq0cPPfQQywiTus+++eYb9v5I1YfyxNty+KMUmSXAmiOUIhMALbt69eq6AvpQKl7aQFYJbMe4hg0bkl3kthNCbjHfTsLf6sZGgfYX3tw5sMgojUH1ZiPkRjbZ+++/rzp21KhR7E8Oij7KW4rAaoM/LXDtV/ImoJgjHpbRB04OqmbPnTuX9IA4JCULFh7afZ3vH3/8kcxEhMtpzl4/gaIBzRnl+sNZQwFB1Ygh8gZ+YMGurSEQCMwL4leQgIEbZDgaawrCBypay7PAYIW65ZZbWNo/ahI56Rw/58P9W/hXTABMqcgyUMtOkIInDj3oHWcVue2EkFvMt1PAM3dOTo4jA63DKTfihFDtGu074P5CZWwoRHBvvfTSS7aV27buM2i08LsirRCWEXQR/uijj7yaDJVMeW+99RYzWyL1G4oCThTUhWjUqBGZBZRYhw8XZd15uqMayFSApqvlQsN2jDM7vshtJ4TcYr6d1gwXLTLs5CZHUUVUodaSG9WZhw0bptqENZjcfffd7NqK4G4oKQhTGDNmDIttQrxpMFi2bBlrHAu5efFJJRC7NHLkSDIrplSKnnrqKRYTg67SMAHi//5w11130QcffMBuutCYjx07xvysCDhDTQZUDrUa8Acjg0DJX8zBdhFkLRAIBMFTilAGxRtQDsKhFOHB36gK1b4oRXoCwxG0bWalyJTuMygyCHBDmh40Xn+Axor3QXQ/XDTTp09ntRBwMqOOwv33309WBen2SN2U+0bxWqTjCwQCQXBB8DOsQWp/cJEjpR4ZZk5h8uTJ5XJjqfbdyAPHzYYpLUXyzr/+MHPmTLb897//7dZvCXUikGkAaxEKVSHlMNzAzIi6EL6Yl6EYwQwKKxo3V8JlZiULkT9y2wEht5hvJyFvTOoUhNzWxDp3UD9MeYmJidSrVy/FbskA9RvMAJQ21HjwtVkmFCBE3SPLDEsrKUSByG11hNxivp0CrkkpKSmWuzYFipA7kqyKKS1FgYLAMqQkIgJfKYCXxxLt2bNH9T3QN0baO4YHNkvX48RHaXKUKZf278JnolYDAsSlUfhYh23y9bAcoFMy6kRIazzgvbEN4+U3Vewvb4+BJxMch3Q99sd4mDMR4Ctfj3XS7C+jZMJ74L3k/XekMuGzUWSsR48erGCZHWTSM094byQSdO3atXy+rS6Tnnni892zZ08233aQSc88YRsewLp3714+36GQCceO98CSf594D+7GkOLPennPQhwH/qTreTYSsp7k76E0nq/n++pZH2qZ9KzHOQC58WDO11ldplId88TnWyn7ORgy8XOc/xa1fk+OVoqQ7QBQl0AJHovDx6mVSp8yZYrHelT85PUQUD59xIgR9NNPP7n1hunXrx9z0SEYGs3+OMOHD6eOHTuyWCdpTxvEAeGiiRuGdPJQdh0yTJs2ze0YUL4dx/7OO++4XQSffPJJVpYd/cQ4yDpAbxt0WkY2AgduK1hpVq5c6WYxM0qmm266iRUIw/flTaZVq1bZTiateXr44YdZ1Vj82UUmX+YJCQ/ocWQnmbTmCZZprMdfKGVCBWXIhZ5buDngJobEFShWiKvkYBvaK6ABqfSaCKUQVh6453nVYgCFtnLlyuxBEftwoPjgD58rV95wk8RxSBVJ9NDCtRR9uqQ3MnzHuJGdOHHC7T3S0tKYsiH9XsIlE75zKDxqMqFLPc9As4tMJ3XOE8B4vE+wZcJxYj/EDSN+WO33pCco3jLFG/Fjx8XJl5R8XHRr167NXGfSCxFn8eLFrIAVMtJee+013ZYilE/Hyc6VKqOebLHviy++yOpJSP3QdrcUYdsrr7zC5OZPklaXSc888fNaOt9Wl0nPPPH5hlKI+baDTHrmCe8hn+9QyJSXl8cSVlDRmT/IhcNShJspbv5y7G4pgtypqamOsxSdVJnvYMiE4o04xxEbDMVb7fcEBQ1KnJ7ijba0FHELkZoliLvC1CxJABcvpUA5pfW4MCmhFisjX88vdFqfKQcnpNJ6nDBK63FiKLkScdIolWUPVCatY5evx//5D88uMnGUZNKab6vK5Ms88WOwk0wcJZm05juYMnHXHZbSmB7pTVqKr+vV4oSk66U3Uj3j5Z+rd30oZfLl2Pn3r3XsVpEpUsc8eZtvo2Xi5zj/zfn6e1LCutFQGsAECFMdyn8rVUvmsURmqVOEiYWZ3YnBiEJu5yDm21m/b6nLw4kIua2JbX+l8Nkj4AvxKnJ43xf4IM0AnowRS6H2hGxXhNxivp2AU89zrggjBsSJD3xCbmti+TMVvsKdO3e6BXWBO++8ky1R1lzqb0cQJ9L1EVNkllYYiFlYsGCBYuyJnRFyi/l2Ak49z7k7JTMz0yMexWzgngA3DAoQOkluoym1gdymVIqQeYGgavx99dVXHuvwf86bb75JLVu2ZEspaIB3xx13sAwfRJ9PnDiRZbygvDii6d944w0yCziBkG1j5RPJH4TcYr6dgFPPc4408ykcIBCXx6ao/eFGHky5EeyOPzuwzIsC6et8I3kJSQgIZ0FCALLOUKZFmg0aSkwZaI2MMXkKHdxgUlcYFB5vvPfee6ywIRrCIssM0elXX3016wmDFFqBQCAQOANeNkEJeA527NjB+m0KQgea6uK7R3kANM+99tprWRo+5gIlL1ByItSYUilCbxS9/VGgrapprPDrIu0efwJP8ORq5TYhAoHAJJSWEB1cTXT+JFHFVKL6PYkiPbPzwgnqPGm5x4LVPV5AqlngV111Ffv/X3/9RZdcconbdmnJi1Ai7oAmAKm9CAxXSvENFtu3b6dXX32VWeS+/vprtsRrrLez3GZAyC3m21ZsX0D0ahuiT64k+npc2RKvty9gbhbUpFJLRTe7S4i7veBeQxNx1KpD+re3h3YuNx468X8s+f/5H/8sxLwinANFPvH+KK+AgobXXHONWxFTDj4b+2MJawrq8eGzpO45uAxHjx7NQkXwwIvrLEJJ8JnYF/LKwfbhw4czaxmOAe6sp556ys0dhv0RmgJQ3FgqD3dT6p3vt99+m/UfRQ0vuUIElMp1ONZS5DQw+ahuGyqg+KDyp5LmjvWosI2Gs3aT2ywIuZ2FrecbCtGXt6Jsn/v6c8fZ+ojrZ1NSqxFkZVBn6tJLL2UWdWQRYj5RlFELrhygJMyzzz7LHjjBhAkTysfwcwIVnrG+T58+dMUVV1CVKlVYJXUE5yMxCMoKWkDJQbwtGptfeeWVrMo6r7+HLvVopYNWV0OHDmVlT3bt2kWDBw9mciiB+J377ruPZcxBMYJStn79ehZqsnTpUvaHWj84Zig/eIjmVdk52JfLrYd58+ax8aNGjWLHB1lQcBQWOxx3uHpiCqXIBOBJgSsjwT4R4DL7+eefNcdgO07MYLvSQim3mRByi/m2jcvs54meChED6yLI9fMTdKZ6d6qSUi3srvm9e/cqus9wA9YCbSzatWvHYlrj4+N1X2cRJwMFB5/JLUtKn48xsJigC4OUbdu2sX55kyZNYl0YlK7TKC8zaNAgjxYvUIig0GBfzqxZs2jcuHGKD8kIMYG1ZsmSJSzQWd5RApasRx55pFwJglKE/8vlkcqtNd+4Bm7ZsoVVmcZ7Q3GUJiI0atSIvvvuOxYTHGqE+8wEoCw5+rWEouMKTLj8iUINbMc4O8ltJoTcYr5tAWKIzh3TGOCiiHNHyYVxJgDXGrh85H9r1671ui/aMOlViDjylixqwFUlV4hA69atmasKliKlcg6Ix5ErRPhMWJBg6YESI+X222+n5s2bKyYkIX4HykmKRCECjz/+OFNc5s6dq0sWfgzegHUMVrSMjAx67rnn2PeL9iBHjhxhZXRQeBkWK7TxCDXCUuQweINCo8YJBAKHgqBqHUTlXmx2Gk4Qs6NmJVeKseEgTTzYFgtkYUExQOY1LFNyJQh1+NClQUrXrl093gduKCglnTt39mj9AlcV3GoYI4UrhbA6LVmyxOM9UXQUtQCNhFuFoBghVkuqwEFJwjHCizB//nzVjMFgIZQih4GgOyPHCQQCh4IsMx2UJFQnKwOrSzADxVevXl0e64P0dAQ44/qLz4QLafPmzYrWF6W4Ju4FwDErobQP71oPd1uokPYdRZyWHKyDUoS4JqEUORAE7sFUGIpoe6Tdo0uwlgsN20NR7TuUcpsJIbeYb1uAtPtKtcqCqhXjiiLIVakWxTe/1PTZZ1r4c+zYBzd+PftCGYHSs2LFCurdu7eHFQdKkd7j4h3gURBRCbio1PbBPSFJZ5B0oHKjPylchggKR4C2HL4OgdehRsQUmSRFG1W3Q5GajuA3b4GF2B6KoMhQym0mhNxivm0B6hANnX7hhfwmeKFL/NBplJhUydJKkT9AXtz4udz4zSs1J+exTkidlytESIXfsGGDT5+LmCG4zVD3R25dQizjmjVrPPbp1q0bW+qJrQL8eq0kj1xuLbh1TKkMDF8XjirgQikyAYjER80GaY+2YIJ0e2R88ScEDl6HKh0/HHKbBSG3mG/bgHT762cTVXKPd2EWpOtnU2mLK5nVwmktTiCvVG4oPYgLUgochlUeGVvINuNA4Xj00Ufp1Cnf4rGgEKEqNCxCvAwAZ/bs2YqxQUjnh/X6gQceYFlwclCjSVovCbKAw4cPe5Vbi7vvvrs8w03aZgUxVehAgQdzpOuHGmfZsU0KNHic/KHMwoLig7T7cFa0DofcZkDILebbdopRi2HKFa1LS8NWmTjcSOWGVQTxMZdffjmrR4QSJH379mV/UEZQoweWIjyUIrAbgd9wLSHtXSsIXIkXXniBfv31V5aav3z58vI6RT/88APzAiDYXHqdb9OmDXs4RUuN5s2bs1pJaImSnZ3N6iXhPdBz9N1332Xjcd+oVasWffHFF0wJq1OnDrMMQQ643/TON4K+H374YZoxYwYrB4BQCgSYf//990yxmjp1KjVr1oxCjVCKHAx+GA0bNgz3YQgEAqsDBahhn3AfhWlBmjmsQVBMEDvEizpCKULxRWRZQQmYM2cOJSQkMCXq22+/ZZlYvoKq2HCToQk6lC0oNZ06dWL/5w3W5V6C8ePHU/v27ZmCghIAqJSN2KB69eqxZq1jx451c59988037P2Rqg/lCSAg2teYpJdffpll9r311lvllbqhxEEBQ5/ScCCUIoFAIBDYFsSleLNGwyKjNAbVm40Alng0JlcDbiIlV5FSH1BYbfCnBR52lboWoJgjHobRB04OqmbP1VmPCHFIShYsf9ykeuQJJSKmyASgDsRNN93Elk5CyC3m2wk49TwHePJHDIoTA63DKTcqWsuBFQpVuVHwMVglVyJsMN/CUmQC1DR3uyPkdhZivp0Hbo6IkXEa4ZYbcUJwQyF2FO4uFIeEZQfurZdeesm2chuBUIpMAFIn4ctF0Jm8CqmdEXKL+XYCTj3PuTsFmVAoGhju3mdGgqKKUDTUgCsOCSzDhg1TbcIaTJDZhbggBHfn5OSwVh1jxoxhsU0IlA4Gy5YtY41jeeKOmrUIsUsjR44ksyKUIpPgtLR0jpDbWYj5dh52zC6FUoSmqN6AchAOpQgFIUNZoZorRXoCwxG0bWalyD6qu0AgEAgEIQDBz1D21P6QXYaUemSYOYXJkyeXy42l2ncjDxw3G0IpEggEAoFAIEBclMuOts0ggL4wqNuQlZXlUePBCL87qp1Wq1bNVn53bwi5xXw7gXCd56iefODAAZaeHa7gV9xeUMwPFZOtnJHkK0Lu6JDMt95z3Jf7t3PuwCbGl+aBdkLILebbCTj1POc4rbchR8htTYRSZJLgU/R/cVoQqpBbzLcTcOp5zi0m6GXlNIeEkNtFVkVknwn8dgmEs2+aQCAQCARGI5Qigc9s376dNRWEn5YDPy2aDaJYmEAgEAgEVkQ82gt8VojQU0eqEAG8xnpsFwgEAoHAiojsMxNkn8H/jHiD2NhYUwdjwmX26quveihEUvDdTJgwQZcrzSpyG42QW8y3k7LP8Ifft9N+40LuiKB/zyL7zKbgxwNly+zBiIgh0lKIALZjnJ3kNhoht5hvJ4FCfk5EyG1NhPvMBBQVFdE777zDlmYGQdVGjrOK3EYj5Bbz7aQHgFOnTpn+wQctKmDJQlVmJ8ltNC4byC2UIoFukGVm5DiBQCAINn///Xe5+07tLzMzM6jH0KBBA/ZnB5YZpECi3YfWnOBzTJt9pqfJmzf69+9Pffv2Dfh9BOEDafeIGfIWU4RxAoHAOZSUltCG9A10KvcUVU+oTh1rdKSoSHMVbWzcuDHdfPPNitsuu+wy2rFjB6s6LggtV111FbVv395jfbiUSF1KETRCaG7+msR4gJ1QitRBsLHZQfA00u6RZaYGtvtSr8gKcgcDIbezsPN8/3rwV5r25zQ6mXuyfF1qQio90fUJurTupaYJsG7SpImmdaNFixaGfp5Z5A41ET7KPXLkSLrtttvILOi+e40dO5aWLl3q899vv/1maf9iKIiLi6Mnn3ySLc0O6hBdf/31Hhl4eI31vtQpspLcRiLkFvNtJ4Xo4WUPuylEID03na3/7fBvVLNmTdMXdlVzCXG3F9xr999/P9WtW5f1cfPW6R3yQu5Dhw6x90XyCf6k7iH+WcjAfeONN2jIkCHs/XF9qFGjBl1zzTW0ceNGVbcTlgsXLqRevXpRUlKSm2UFLsPRo0dT1apVWThDv3796Pfffy83cCi5prB9+PDhzFqGY2jatCk99dRTlJubWz4G+w8YMID9f8qUKW7y4DO53Gafb0OKN+ILxxcrCE6q+/79+6lRo0aWOJmg+OCpKtCK1laT2yiE3GK+7eIyg4XIRZ4PvVgXQRE0/c/p1KN6D0qIT7Cs5aSgoIAuvfRSdq0bMWIEU4pSU1M194EhAPuhjMuzzz7LSpkAlCuRhpSAM2fOsPV9+vShK664gqpUqcKuiwsWLKCffvqJKStdunTx+IyvvvqKfvnlF7ryyivp3nvvLQ9rOHr0KPXs2ZOOHz/OLPcdOnSgXbt20eDBg5kcSiDh5b777qPKlSszxQhK2fr16+n5558vN3DA2oljhvLzySefMH2AywCwL5cbSpXe+Ybil5GRwRoHQ88YNGgQpaSkkKmVookTJ1Lv3r39/pBA93dCNtJnn31GTzzxhGWsJlBiUP/EaXIbgZBbzLcdQAyR3EIkV4xO5J6g3/f/TkNaDQm7UrR3715F9xkUBy3Qu61du3a0atUqio+P1/VZUA6g7KSlpbHP5JYlpc+HEgSLUu3atd3Wb9u2jbp3706TJk2ixYsXe+yHrgKLFi1iSoQUXE+hEEGhwb6cWbNm0bhx4zzeBwV3H3zwQbrkkktoyZIlbgoJevbBmg9L1iOPPFKuBEEpwv/l8uCBj8utd75ff/11t9f4jqFIQm8wrVL0wgsvBPQhge4vEAgEAnOBoGo9nCk4Q2Zg3759zOUjBxYOpUBfKS+++KJuhchX8EAoV4hA69atmasKig8epGJiYjwClOUKEaw0sCDB0gMlRsrtt9/O5IDVSMp7773HrDRQfFJkFprHH3+cZsyYQXPnzvV4v0DBQzV3G9apU4cpUwi3gRIGxS4hIYEeeOABCjWi95lAIBAIfAZZZnqoGlfVFN8ubr6wriihlf6NauBt27YN4pERbdq0iSksK1euZJYpee2206dPs1gdKV27dvV4Hyg8UIw6d+7sYX2H5QZuNblStHbtWraE8rVkyRKP94QytnPnTjIauN+kITlQDG+55Rbq2LEjO35Yoe655x7mrgwlQikKM65SFxX9nU3tE5qwZWzTWIqItKbv3VfwI61evXrYzeqhRsgt5tsOIO0eWWYIqlaKK0JMUY2EGtS+urYVxuzA6uLPNUrvzXz16tXlsT4oDYAAZ8Rp4jO/++472rx5M1N05CjFNfG4IhyzEkr7wEID4G4zgkCVGFjIEG7z66+/sjIJwVZIQ6YUPfbYY/TNN98wk6VAmbytpylz4T4qySqkTlSPMj/aQdnJsVR5eGOKb2P/ehkI3EOAoNMQcjsLu8436hAh7R5ZZlCApIoRXgNsr5nqbuGwGv4oRIi5VFNM5EAZgdKzYsUKj9hbWHGgFOk9Lp4VnJ6errjPyZMnVfeBQpWUlESB4IvcWvB6UTk5ORRqgpbyA3MfotQF6gpRxpwdTCGSgtdYj+1O6A20YcMGx/UIEnKL+bYLg+oPohn9ZzCLkBRYkLB+YL2B7MbmtLIskFcqd1RUlOp1DoYDpM7LFSKkwuP66AvNmzdnbrO//vrLw7qEY1mzZo3HPt26dXNzo3kDsgAleeRy+wPeF5lvIByFgJ2TB20ylxksRFpkLtzPxtkZBPehzgaWTkLILebbborRolGLaNaQWTS9z3S2/HnUz2y9aH5cdg2H0gNDAbq6y8GN/+zZsyzbTKoYPProo6yPmC9AIbr22muZRYiXAeDMnj1bMTYIVky4vBDUfOjQIY/tqNEkrZcEWcDhw4c9xvoy31Dc5EBuBFkjUxBB5vI4KlO5z/7xj3/49MYIGBMoU3Agy8NCJKckq4CNq9C4svgaBQKB6V1pXdI8a+kIykDMEKwfl19+OatHBJcqOjzgD8oI6g3BUoQCuAjsRuA36g0h7d3XHmDI9kY8DpSL5cuXl9cp+uGHH1j5AQSbS+vCtWnTht5++20W1Ny8eXNWKwktUbKzs1m9JLwHKk6/++67bDxq1NWqVYu++OILpoQhcwyuPMjhi/sNwdQoA4A/BFkjtgmftXv3bvaeH3zwQVhOH91KEa+i6YtZzGkBtHopzS40dJxAIBAIzMvTTz/NrEFQTBA7BIsIavFAKULxxfnz59PUqVNpzpw5LBUdStS3337rV99RVMWGmwx1fqBsQdHo1KkT+z/S9YG8I8H48eNZWYIZM2awYpGw4KPwZL169eihhx5iHS2k7jPEC+P9kaoP5Qmgr5wvShFS/OGyQw0mKERQFNGKBVW0H374YVa/KRxEuHRqOajlAG0OBaD08O9//5tV47RLvAiC0HCSwDQoP6F8JX9fJp2eucXruGrj29raUoTy9uijhqcjO/eGkiPkFvMdCuCqOXDgAKsHA+tDOEAxPygDuME5rWq9GeWGNQoKE+5jyHCzutz5Os9xX+7fui1FqB2wbt06VhtBjwUIqdYCZeIaJlNUcqymCy0qOY6NszNQhNS6VtsZIbezcOp8A9wYw9mywalyo6K1PB4HVihU5UbafzAUIjPIbQSRvihFiIYPRhEnp4E6REi716Ly8Ea2r1eEgGP4y50YaC3kdg5OnW8ARwTcK07MPgun3IgTQrVrtO+A+wtByyiMCPfWSy+9ZFu5jUC3pQglxdG0LS8vT9f4O+64w61ZnK/AKgWfKwpbobonCjjBzwhXi16OHTtG06dPZz5LNC+FdozCWHfddReNGTOmPLUwHKAOUcrNLcvrFEktRFCInFCnCK5V+Lt79OgR8qql4UTILebbKfCbZGJioq1iTFFUEVWoteRGA9lhw4apNmENJnfffTeLC0JwN1Lk4bnBPQ+xTQiUDgbLli1jjWN5k3C1+Ubs0siRI8ms6L4TIWIef3rp1asX+/MHfLEoyQ4f4Q033MC026+//ppGjx7N0gD19GBB1DzqL0CRw3uh8y/8ijiZb731VtZj5aOPPqJwAsWnQqsUOr/7NH332dc08qZRVLFZNdtbiAQCgcDK4D6CpqjegHIQDqUIBSGNqlDti1KkJzAcQdtmVorMEwF2AZiYEQkP3ySi4N9//316+eWXWVXPZs2asa6/sPp4AyZC1IV45ZVXWMA3LEbvvPMOKxuOiHpk0+l5n2ADBSi2YSXaH32SLZ2iECEgD98/nqiwxGuBQCCwArh/4Nql9gdrMFLq4e1wCpMnTy6XG0u17wbfnZkxRClCwScoMEYACw4qfMLUJ+1cjMhxKETI3NGjocNSBFBzQZ5FxyuHQmkyA1AAUUvCTFkKwWT79u2ssNjnn3/OXmOJ11jvBJw23xwht7Pmm4MUcyci5LYmhvxK4YZCIJcR8EJViJCXAzcYQByKnkAz8OOPP3pU50QEflpaGrVq1YrMALoQjxgxgi3tDhQfpOHzxoUcvMZ6JyhGTppvKUJuZ803V4TxIOrEBwAhtzUxXXTrnj172BIB0XKgyMBHy8d4a0iLQDNE3qOCJ6pm8pgiaPAojBUfH6+6P/rGSHvH8Ju4dD1OfFzoEQgudf8ggBuBw7BqSaPwsQ7b5OvBokWLmO9ZeqPE/xGshvHyFF/sj8+VguqiOA7peuyP8TBnSrNf+Hqsk9aSMkomvAfeS/od4v0wF1rA1YmaE/wianaZ/JknvAeU9YEDB5bPt9Vl0jNP2IakBzzwIPDWDjLpmSfwf//3fywbiM93KGTCseM9sOTfJ96DuzGk+LNe7vLGceBPuh778RoxcpTG8/V8Xz3rQy2TnvU4ByA3auLwdVaXqVTHPPHAeqVaQMGQiZ/j/Leo9XuyrFKE4kpA6UcE8GXzMVqkpqayIlWoD4IbLb8ZQxFCZH67du28lkqfMmWKx3pU/ORFouACwRM/3l/aG6Zfv34s8w6WD7gCOQj2RmkDlC+X9rRBRh32R+8b6eSh7Dq+h2nTprkdA8q34ztAjJT0Ivjkk08yt+Fnn31Wvh5ZB+htg5gsKIkclHHHd4N2LFLLm1Ey3XTTTaw6Kb4vLpOeNE38oBD/xW8yZpfJn3lCFiUyV6TZK1aXyZd5whwj2cFOMmnNEyzcGC/tdh4KmVBED3IhTAA3B/ymULsGihUqCHOwDZ3NUXJFem2FUoiaM8gm4lWLAR4qYQXBTR/7cJAQgz98rlx5wzHiOKSKJHpo4VqKPl3SawO+Y9zITpw44fFQDGVD+r2ESybIA8VeTSZ0qYdMPFvbDjKd1DlP/LOl4SnBkgnHif3QOBfVwdV+T3pCbnyuaK0FlAdEnRtRvRpPkXiahDUIFwE5qKqNL8qbYoSGcvhCYFlCsDXik+A6QwErlBFHEUqUW1dLy1eyFKF8Ok52rgUb9WSLfV988UVm1cLJoPfJtrCgkIoOZlPp+SKKrBjDMtdc5P7EayYLBJS+BQsWkDdwY2zdurVtLUUANzHpfFtdJj3zhM/AbxFKIS7KdpBJzzzhPeTzHQqZcEP++++/qUGDBuUPcuGwFOFmipu/0yxFkBsP506zFJ1Ume9gyISK1jjHkTyFe73a7wkKGpQ4Qytaa8F7pBj1XkBN6YFyoqcnChrYIasJT3p8gvCl4QmKdxBGQzs8gSmBi5dUQdFarxYbota6Qr6eX+i0PlNO/rYMjxpH55NjWVFIpRpHODGUFECcNEo1ggKVSenY9faywTjpfvgRKH0HZpDJ23pcOOTrtebbqjL5Mk/8GOwkE0dJJq35DqZMOHbIhaU0pkd6k5bi63q1OCHpeumNVM94+efqXR9KmXw5dv79ax27VWSK1DFP3ubbaJn4Oc5/c77+npQwJPptwoQJrP+IEfBYIqW4IZjpYCVSijeSAnMbgqlbtmypqLHyoHCpiT6c4OIKc7reYpJ5W09TxpwdHm1C8Brrsd2M1K9f36uWju0YZ2d8nW+7IOR21nwD3LBgFbRT4UY9CLkjyKqYLiUANwuAjr5yEIwsHaMGNyWrpdxz/63aU1eogZaL+AI9VZ1dpS5mIdIic+F+Ns5sQKsfOnSo5hhst3umii/zbSeE3M6abyCUA+sqB06db12/0tmzZ/v9AQio9AVk5DRq1IjVrkHfFl6rCO60qVOnMjOY9D3R+A7bEMTFXW8I0GrevDnt2rWLBSyi5QgHcUW894tRZQRC2TW94ECWZiNZUJJVwMZVaFyZzAbKIEBOBL5L0/JhIYJCZJYyCWaZbzsh5HbWfJu5W3ywEXJXsex861KKEJ8j1fwQyORNE+RjfFWK8DQJRQYZG4gml7b5QIwQFBoEDnKQIYLIctRKwnFyENCJgF1Ux0bsELJA8ONEoC8sRaNGjWIpsmYA3xUi5vXEvJdm60st1DsuHEDxQf8dBMND+UWhTgTVW/VHFMz5thNCbmfNN0ceHG5GUB8PD8moQI3KzE6ROxgUWFxuXUqRUo+w+fPns9obsOygJxqi7BHAjMrWqEp95ZVXMsXDH3ByIrUVJ+i8efPKG8IiVRv9z/Rw+eWXs2ay//3vf8vTZJGBgTijZ555hqWyWpHIpFhDx4ULKECIHYLijKVTFCKBQBBakJ2E2mdaoG5dMOEP8jgWq7MsCAokgNECRZfRyB1GEW817cKqFKGBmxQUQETaPGJ8Bg8e7DEe8UCw0kjdVr6ClHnUK/EG+qio9VLp0qULc1PYibiGyRSVHKvpQotKjmPjBAKBIBS4Skood/1fVHzqFEVXr04JnTtRhMkCy3ktKbVSMOiLWa2aZ+auIDTcf//9umoQBhu/Iv8Q24N4CCWFiJ9g1113Hf3nP/9hypHAyyRER7OaSnoCb9EwFmn3yDJTo/LwRpZoLOuL3HZCyC3m206c++UXOjn1BSqWFPGLTkuj1ElPUtLgwSzW0wyBt3DRa1k24NI3CshrFrlDSYSfciM8BqEUb775JlOOwolfPgsU4UMhQy2wHeME+lKVUXVTb4o26hCl3NySWYzc3ic5jq1XqlNkB7ntgpBbzLedFKKj/5zgphCB4pMn2frsxYtZlWSzKwdwCeEY5UoT3F74Q4IObta4r+Ghxlund7wX5EYcLP6PJf8//+OfhQSEN954g7mM8P7IikaV52uuuUaxbAw+G/tjiarqvXr1YnG30lhbuOkQaoJq1KjPh4xthLbgM7Ev7zEqBduHDx/OrGU4BpS+QaFjaTVs7M8TlFC0WSoPPpPL7ct8I8YX4Sy33HILDRs2jMKNX49smAB8gVpgO8YJvIMfBc+S05udAsWnQqsUlmWGoGrEEMFlZgULUSBy2wEht5hvu7jMYCEipQByrIuIYNvz2ral6qmplo0bROAw+lKiRh48H1CKEEPrLfsMJWGQVYvYGxQL5jX9OCjLAdD2AusRm3vFFVewTD0UHUZSEEJIcC9FKIicr776ioWqIH4XrWd4Nu/Ro0epZ8+eLDMbGb1IMkImNjw7kEMJtLi57777WAsNKEZQytavX0/PP/88LV26lP3hGo1jhvKD5CbeqoaDfbncUKz0zjfabuFB8bXXXrOu+2zkyJE0c+ZMpt1BW8QXyEEbDAQyo+/YnXfeaeSx2jorB9qyr9lIUIDMmHYfbLmtjpBbzLcdYDFECn2vykGjzhMnqADWDi/1yUIBsl2V3GfeaqehaDB6ZaIgsFYTcTlo+QLlAJ/JLUtKnw8l6NChQ6yFlRR4Wrp3706TJk1iMbxyEIiMuF55FjW6NkAhgkKDfTmzZs2icePGebzP9u3bWfkbNE1fsmQJK2nDQXsaZHjDkvXII4+UK0FQivB/uTxQiqTtb7yBtlvffPMNi1PG92BZpQjNUpHZ9d5777HJhq8WihEUIpx40KwRRY5xAoFAILAfCKrWQ2nGxQag4QRlMJSafMPCwevhqYHelL4oRL4AV5VcIQLo/whXFRQfZGDL299cddVVHgoR7r2wIOF+DCVGyu23387kgNVICu7jUGSg+KRIFCLw+OOPsybEc+fO9Xi/QEGWGZSxG2+8kcliFvxSiqDR/fHHHyxF/tNPP2UaLY8fQuojfIP4MtHRViAQCAT2A1lmeohMqUpmQCvNWynGhoNSLigJE0w2bdrEFBaUj4FlSt6cGC4pFCiWZ2jLgcIDxahz584eHRsQ5wO3mlwpWrt2LVtC+VqyZInHe0IZ27lzJxkNwibw3q+//jqZCb/TQKA1w3SGP/Qagz8T/lMRR+Q7ODHQmFatEaZdEXKL+XYCdj3PkXaPLDMEVSvGFaFRZ2oqVe/Xz/SB1lrA6uLr8WM8gpz17AevC4/1QeY2ApwRHI194VbavHmzYkFEpbgmHlckDWnxtg9imgDcbYGiV2643xAvBauW2cogGJIbC0VIKEP+g4A0uCCdhpDbWYj5theoQ4S0e2SZQQFyU4wu3BSxPT4xkayMPwod9oGFSQ9QRqD0rFixgnr37u1hxYFSpPe4eMNthLIogQLLavtAoUoKMDlKr9w8qw6le5SA1QrvhVguWNFCiTXTAWwGfhCIv7J6eXRfEXKL+XYCdj7PK112GdV+7VVmEZKC11hfcdAgFvSLAFwnAXmlciO7qqSkRDXWCdYVuUKEVPgNGzb49Lno+Qm32V9//eVxviHBAwlQcrp16+bmRvMGL6GiJI9cbjV69OjBgr7lf7xjRZ06ddhrlCWwjKXo8OHDrDjjr7/+ygKmeGd6KdD0fIlEdzJK358TEHI7CzHfZEvFKGngQMWK1rg5Oi27lCOVG0rP1q1bKT8/38OSgjZHu3fvZnG5CK7mCsejjz7KsnN9AQrRtddeS5999hkrAzBx4kS3xu5KsUFI50c2+QMPPMBS/OvVq+e2HTWaDhw4wFL7uSxcB/AmtxpQfpRadiHdH6298D2gXEs48EspQg0FaJfoVYKDh0aKicVkYxuCxGD2QlS/wLy4Sl2WrnMkEAjMARSgxG6egb+CMhAzhLo/6MmJekSo+YOG5/jjyggsRegUgfsoAr9Rbwhp71pB4ErAKgljBVLz0fOT1yn64YcfWPkBBJtLawghU/ztt99mJXaaN2/OaiWhJQpihXE/x3ug2fq7775bXvm7Vq1arNE6lDBYdWAAgRx2CKPxSylCWiPqCSBSHQWc8AUj3Q/1iWA6w5eL2geYGIE5ydt6mjIX7nProYYK2WghYpWK2AKBQGAFnn76aWZEgGKC2CFYglDUEUoRii+iwTraZ6FuD7K2oUShSe1zzz3n82ehKjbcZLASQdmCUtOpUyf2fwQ2S+OIOOPHj2dlCWbMmMGKRaJSNtp1wGr00EMPufU/hfsMtYXw/kjVh/IE0FfODkpRhMsP2yZqKqDCJiLjAZQiTDD+ACxHSGFEjQXUQLADCELDSQJlUH5CBYo/VUADVYi0eqeFqlWIv3JjP5TMR4VZZGnASmmlarmhnm+zIOQO7XzDVQO3B8qk6A36NRrcXhBCgSrQVs5As4vcsEZBYcJ9DNdOq8udr/Mc9+X+7ZelCBd0afM8fAHS/igwqaGkOFeaBOZpHgiXGSxEWmQu3M9aiATbleaP3LBAwvzLU08BTnKYhVu1akVWQDSLNM9NIhQ4db45TuttaAa54bGR1zWCFQpVuZH2HwyFyC7z7ddjC55wc3Jy3F4jQEoKFCUEaAn0BZ+inHooglARQyR1mSlRklXAxplNbihEX375pZtCBPAa67HdCoRyvs2EkNtZ880tByhG6LRg63DLjTghVLtGxWi4v+C1QVFluLdeeukl28ptBH5ZilBcCmmE0sqaqCuAoKxGjRqxiHn4SBGsJTAXCKo2clwoXS9q1Wg52A4LppNcUgKBIPTAC6JVPwdKAdz76Pqu1oQ1mKDJKuKCENwNA0b16tVpzJgxLLZJ6uUxkmXLlrHGsTysQc0yitgl9E+1lVKECHpUsoYlCBlm6PCLCUBDuZYtW7L+Z3h6V2p+JwgvyDIzclyoQAyR3EIkB9sxDv5lgUAgCKZShKrM3oByEA6lCAUhjahQ7atSpCcwHEHbZlaK/HqkRnYZvgDuO0TaINLzEPCKWgwoJY5+JohoF5gLpN0jy0yLqOQ4Ns5M4OnDyHECgUDgL2iEDmuQ2h+yy5BSz5OPnMDkyZPL5cZS7bvBd2e77DMnEszsM0wB4i1QuyIUwZhmyT7zRW5kGOh5MsNTiNktRaGeb7Mg5A7tfJsl+wx/kNtp57qQO8KS2Wd+WYpgDoRvUmAM+PFgskKln0LhgeIjtxjBQhQqhchXuWGF9HYyYzvGmZ1Qz7dZEHI7a745au0t7I6Q25r4pRT98ccfjp3wYIAK4O+88w5bhgooPmkTu1K18W2p6g3N2TJtYpeQFm70RW4ETyPtXgtst0KQdTjm2wwIuZ0131wRRuKNEx8AhNzWxK87CKLXEdAqsDaoQ1ShcWVKaF+DLc3e4gN1iFAGX24xwmust0qdIoFAIBDYKPsMPU7uv/9+VhdG3IgEoQTnG1fKrVrRWiAQCAQ2UopQiwgZZ927d6e77rqLtfxAxplSIB16uwi8g6BbJ+KP3FCAzB5M7Q0x387CqfMNnBRgLUXIbU38yj7DTQkTznfVmny7xB4FM/tMIBAI7Jh9JhA4ovfZM88841gtOFjVmnk1cCe5gYTcYr6dgFPPc4AHZzQIRz9MJ90zhNxxlp1vv5QiUana+Kyczz77jJ544gl28XAKQm4x307Aqec5Vw7OnDlDaWlppr5Johgx+oOh2KIR9zeryG00LhvI7azHFoFAIBA4CjQr58Uj1f6C3by8QYMG7M8OLFu2jH1ngSqPP/30E91www0scQbtwhISEtj/x40bR7t37yZLWYoEAoFAILASaFB+8803K2677LLLaMeOHVStWujqtDmdH3/8kdauXUvdunVj/VRjYmLYHKBzASyr2B6OvnFCKTIB0LrRxdiq5kZ/EXKL+XYCTjjPS0tddHxPJuWcK6DESnFUs2llirxQ9yw62hy3mSZNmmhaN4zuHm8WuUNNtE65//vf/9Ibb7zhsX7JkiU0aNAgmjhxIq1bt45CDrLPBN7JyspCqh1bClyu0pJSV97es66cjSfZEq8FAoF5yMvLc23fvp0tg8neDSddH01c6XrzriXlf3iN9WbgwIED7No9ZMgQ1TFLly5lY5599lm39fXr12d/Z8+edd13332uOnXquKKiolwfffSRT5+t9Mc/q6CgwPX666+7LrvsMvb+sbGxrurVq7uuvvpq14YNGzzeE5+N/bFcsGCBq2fPnq6KFSuy45R+7vXXX++qUqWKKzEx0dW3b1/X8uXL2WdiX8grB9uvvPJKV0pKCjuGJk2auP71r3+5cnJyysfw/ZX+8JlGgeOuXLmyYee4L/dvZ6qyJgNlCzZv3kzt2rWjqKgoMjtoKJu5cB+VZBWWr0MftcrDG/vUJsRqchuFkFvMt13YtzGdfn5vq8f6nMwCtn7InW2oZvNEFi9iVUsZsufgxkGx2BEjRjBLCOryeQs4zs3NZWngCN5+9dVX2foJEyaUj0GtP4DAZKzv06cPXXHFFVSlShWWrbhgwQIWd/P777+zWoByvvrqK/rll1/oyiuvpHvvvZelnQN0qe/ZsycdP36ctT7q0KED7dq1iwYPHqzqjkLbofvuu4/F9gwfPpxq1KhB69evp+eff56WLl3K/lBrC8eMGC24uPr161cuA8C+XO5A5nvNmjV09uxZ6t27N4UDoRSZgOLiYlq4cCG1bt3a9MoBFKKMOTs81kNBwnpfGspaSW4jEXKL+baLy2zFvD2aY1Z9tYcG3deA4uPjw64U7d27V9F95q2n4okTJ9iD26pVq5gcvjQ/RhYWPvPjjz9m65U+H0rQoUOHqHbt2m7rt23bxgokT5o0iRYvXuyx388//0yLFi1iriYpyHKEQgSFBvtyZs2axYKY5aAzxYMPPkiXXHIJc12lpKSUb5s2bRo9+eSTzM31yCOPlCtBUIrwf7k8KD8BuX2Zbyh2q1evZsrnnj176IcffmCxXa+88gqFA6EUCXTjKnUxC5EWmQv3U4VWKabvoyYQCAKDxRBlFmiOOX+2gE4fyqWatcL/be/bt4+mTJnisR4Wjvbt22vu++KLL+pWiHwFZRrkChHAwyLKBEDxQVkHBCJLueqqqzwUIigWsCDB0gMlRsrtt9/O5IDVSMp7773HHtSg+KRIFCLw+OOP04wZM2ju3Lke72cUUIpefvllt9ivL774gjp16kThQChFAt0UHMhyc5kpUZJVwMahwaxAILAvCKrWQ/55c3Q1GDJkCLOuqKWZq4FKyW3btg3ikRFt2rSJKSwrV65klikoQVJOnz5NNWvWdFvXtWtXj/eBwgPFqHPnzh41sWC5gVtNrhQhAwxA+VqyZInHe0IZ27lzZ0DyafHSSy+xP7gnYbV67rnnqFevXsyyNWbMGLKNUjR9+nT2Jf/222/B+gjbgJMV6aLhNi97ozS70NBxVpHbaITcYr7tALLM9JBUJTgWllABq4s/1yi9hTrhOuKxPigN0LRpU9boGp/53XffsbhLKDpylOKaeFwRjlkJpX0Q0wTgbjMCfwuUQmYoepAZSt2dd97J4qCQuWkLpQia5fLly4P19rYCAWxq9TPMRGRSrKHjrCK30Qi5nYVd5xtp94mV4zRdaBWrxFGLTvXK0/OtiD8KEdq5yF1RakAZgdKzYsUKj+BiWHGgFOk9Lt7XKz09XXGfkydPqu4DhSopKYkCwRe51UAgO9yGkBvB3qhhFEpERWsTAH8uzLdYmpm4hsksy0yLqOQ4Ns7MciMYEE0Et2zZwpZ4HUqsMt9GI+S213xD0ekzuqnmmF7XNaWcnPPlzcOdAuTNzs4ulxuJJGrN0RHrVLVqVQ+FCFlcGzZs8Olzmzdvziw1f/31l4d1CceCzC45KJ4odaN5gyfFKMkjl9tfjh07xpbyOCpTWYrg5/PVRyrQB04uWNV69Ohh6oJfCJ5G2r1S9hmn8vBGuoOswyE3fNaIK+BmZv6khAyUVq1aheQYrDLfRiPktt98N+5Qg4be1YZloUktRrAQ9b6+KTVsV43FyCQmJjrKTc6VAy43lJ6tW7eyru7ybu7169dnbS2QbYbgav5befTRR+nUqVM+fS4UomuvvZZVhEYZABRA5MyePVsxNgjp/DNnzqQHHniABT3Xq1fPbTtaoODhEan9ALKAw4cPe5VbC1iB4CaTg7Cbb7/9lgXA4xoZanT/QpF6ByF90QCd9CNwCki3R9q9Z52iOKYQ+VKnKNRAIfryyy891kNBwvrrr78+ZIqRQGAnxahhu+qKFa1DbYU1K4gZ4q4g1COCS7Vv377sjysjsBThGgSlCZZk1BtC2rtWELgSL7zwAv36668sNR8PX7xOEVLd8fCHh0K4uTht2rSht99+m+655x5maUKtJMR6QrlBvSS8x2233UbvvvtueeXvWrVqsQwxKGF16tRh93rI4Yv7DbWX8NkoBYD3yMnJof/973/MjQgLEQKtoVyZVilCMSakDeq1GKEYFIQT2A8oPki7R5YZgqoRQwSXmZnT8HFxVss84WA7fvDSC4ZAIPAOFKDazauIr0qFp59+mhUkhGKC+yIsQSjqCKUIxRfnz59PU6dOpTlz5rB7LZQoWEt89dCAunXrMjcZrERQtqDUIL0d/0e6vjSOiDN+/HhWlmDGjBmsWCTqx6HwJKxGDz30EI0dO9bNffbNN9+w90eqPpQngLg5X5QiyIuikDg+WMRw3cXnIcAaxSxbtmwZlvMpAmWt9QyEFgvzHiZWD6iJAHOdmh/VasCagJMEhankJ1SgIP0SlUt5UzynEEq5Yf5FwTFv4MffsGHDoB6LmG9xnocCuGpw3uN8lrtsQvkwgmsnrplOetgwq9y4j0Nhwn0M2V5Wlztf5znuy/1b91F37NiRvTGCwgTGAoUA5eOdpBCFWm7UwDByXCCI+RbnuVPAjRGxIWZSDJwgNypay4EVClW5UfAxGAqRGeQ2At1HjvoJMPUhaE4PI0eOpGeeeSaQY3MMsBygz428YJfdCaXcei8CwbpYSBHzLc5zpwDLAQJ1nRZbFG65EasD5QftO+D+Qor7LbfcwtxbKJRoV7lDGlMEvyf+9IIS5PgTeAcn0MaNG1nFVScRSrmR4QGzqTTrTA62Y1ywEfMtznMngdRyo0MOwg0KDGplWCMqBVbnYcOGqTZhDSZ33303iwtCcDcCmFEAEdWhEduEuMlgsGzZMhYjBLl58UklELsEo4lZMW1+6Lp161ggGqp94skaZdYffvhhFp3vCyhihWh8BLghhRDR7M2aNaNbb72VRdsLnAHMuci8UMo+42C7lc2+AoEgdEqRnhhFKAfhUIpQENKoCtW+KEV6AsMRt2lmpciQOwCevtHl1yigbaL3CfrAQAmC1gu33ejRo90ax3kDmjzMiG+++Sar/wAzIrRlKEbQogXOAun2OJ/kT614LdLxBQKBXtD1HtYgtT8kGCGlHg/2TmHy5MnlcmOp9t3guzMzhliKXnnlFaYhGpFphqq3SA/EEztSA3n3YsQnoS/KpEmTWHEqb24OKGrcfYfqnqiFIP8cs4AUx379+pVXCnUK4ZAbihHMxwcPHiw38+JcCqWFSMy3OM+dAlwoiGNxWs06IXcEWRXT+QrQQBYZbrDocIUIIJ0OClFhYaEusyWKUcF6NW3aNA+FCJipsiyOBUW6zHRMdpYbChBSOOGSxTLULjMx3+I8dwpCObCucuDU+TadUsSrdyLbTQ4PyNXTaHbevHlsYkaNGsWqeb7xxhv04osvsmwnKFZmAseDdEmzHVewEXKL+XYCTj3PeVJBRkaGpbOR/EHIXUpWxXSPbHv27GHLpk09Gw2mpaUxdwcfowYuPmj2iYh7KEPw60p/lI0aNWKBcrAUqIFmetKGejxrSboeFgbUnEEguPT94R6BNQDHIa2NiXXYJl+PfWEdQyEq6Xq8NxQ7+cUUJeIxTp7KjpLreC/peuyP8XBtSl2GfD3WSd2eRsmE98B7yZsSSmXCNi431ttBJj3zBOTzbXWZ9MwTn28s7SKTnnnCe8vnOxQy4djxHljy75Mfj7xmrz/r5YoOjgN/0vXYjx+znvF8Pd9Xz/pQy6RnPZebf/92kKlUxzxpzXcwZOLnOP8tav2eQqoUKR24v6DiJHeXKYGgWD5GjTNnzrALE55QEOsECxFqNODi9t5779F//vMfGj58OGuOp1YFExlrU6ZM8ViPMuh8H/SUQfFBVGVGajkHcTJwCyHTSVrsEp+JIpgffPCBW6M/nlH31ltvuU0esuPwPcAFKAU9bfAdoJWK9CL45JNPsl41aAbIgWKIhn+bN292Cy5HbxuUZUcwu9TyZpRMN910EzVp0oR9X0oyTX9hGqWWVqZGrlSa+9JHNPbJu+hc9jlLy6R3npBFyWPx7CKTL/OE9gXI/rSTTFrzxC3c0vkOhUzoPgC5Tp8+zW4OuInVrFmT3bRwjeRgW40aNVjqvPTaCqUwJSWFxd7xVg4AbShQoA8PitiHA7cJ/vC5cuUN4DikiiQai+JaevLkSbf7B75j3MjkNfHwUIzruvR7CZdM+M6RsKMmE7KeAWSzi0wndc4TwP54n2DLhM/Bfhs2bGB1FNV+T3pCbnxu8xEq4DZbvHgxswbhIiAH/dfwRWkpRseOHWPjwD//+U/WLVgKstjw5X366afsQqbXUoSeMjjZefaSkZYiKG7IjsPJYHdLUf62DMpcuJ9Kz12UKzI5lpKHNaLo5pUcYSnCTUw6306xFEExgFKIi7IdZNIzT3gP+XyHQqa8vDz6+++/qUGDBuUPcuGwFOFmipu/HDtbinAOQO7U1NTydU6xFJ1Ume9gyATrK85x9EyDF0nt9wQFDUqcnjYfpnOfcQuRmtID5aRKFe3Gg1IrE5485WAdlCIUtlJTinDxkiooWuvV2lTgwuRtfWlpCR3atoW6Nq5PZw7up3qt21JkpHt2jtJx4IRUWo8TRmk9TgylLC+cNEqBzoHIpHXseVtP05nPdnqMK80qpLOf76SUm1uyhrNWksnXecIFE08weCqTH79VZdIzTzh+yI2nPbvIJEdJJq35DqZMOHbIhaU0mUB6k5bi63q1BAXpetygcD1Wew+t91Ebb8SxByKT3vWQm8+B1rFbSSYlpJ/pbb6Nlol/v/w35+vvyXClCCa/7du3M8uMWqsGmMl9gccSwVKEzr5SYKaDlQip+Vrg4gNLEeolwNQmh6/Dk1Q42fPHavrt4/fp/JkyM+P2hfOpYtVqdOltd1LTbj3JbrhKXZS5ULt3HixIFVqlUESkdbMXvIEbI0y6TkPI7Txww8L12GkIuclZ2WdQJu644w6qU6cOq9YJa8vtt9/u9nfbbbexpa/A1w5++eUXj22LFi1yG6MFryIKpU0OXwezcjgVogUzppYrRBy8xnpstxsFB7KoJEs74K0kq4CNszMw8aJkhNOykYTczppvADcHQg6cmH0m5LYmflmK0GRu1qxZrP4PCikigMqoWjMDBw5k2WGff/45+xxeqwjutKlTpzIzmNT6hG7A2IZjkLrNUAUbMUPw5aNnG7cOwdr02muvMbMb0vXDAVxmsBBpsfST96lxl24erjQrU5pdaOg4qwITM6ysJgvnCzpCbmfNtxkL5WqVgkHTVGQqozKzU+QOBsUWl9svTebrr7+mzp0705o1awyvRgzlCpkXyNhANPkNN9zAgjLxmahCjA6/UgsPMkQQWf7RRx8x6xSnZ8+eLKAT2RpQ3uDTh4vv+++/Zxo8FCz0QAsHR3ds87AQycnOOM3G1W3tWXjSqkQmxRo6TiAQCLyBQFwUadUCGZHBhN+zcCxWZ5kBCiQekH7++WdWN3DVqlXs3o77M8JnkAiFe7daZrgplSIEDiKdNFjtGfCFI7UVXzqKMPKGsNOnT2dfmF7QJw37IdUd/Vbg50WK7LvvvktXX301hYvzmWcNHWcV4homU1RyrKYLLSo5jo0TCATWAdZv9rCXeZYqVq5CtVu2Np2Vm5dNUMt63rFjB1Wr5p7kIQgOyKK84oorWIIAdAkYQZBJhhCZf/3rX6yOIJQvnpRheqWoS5cuXgsoBgqCqVGvxBtQdrQazMF6JLUgmQFcNIwcZxUQPF15eGPKmLNDdUzl4Y1sHWTNs6tQd0Yty8quCLntOd/yhBHAE0aadO3B6tyYoe0DSrxoWTbQE9EoIK9Z5A4lETrlhkEF9QJR80uaTQ4DCMJaUAMMxozHHnuMLBFo/e9//5sFQv/www/GH5EDwFMULhpaJKVUY+PsBtLtkXYPi5HcQqSUjm9HEM+GC3Soe66FGyG3/ebbW8LI3j/XMDeI2ZUDWCVwjHKlCW4v/GVmZtL999/PatUhxMNbp3e8F+SGWwj/x5L/n//xz0ICAjovwFqC94f1BAUNr7nmGrciphzu9cASykOvXr1YiIk0rARuOnhVoKCgfg+Sk9BgHZ+JfXk7LSnYPnz4cGYtwzHAlfXUU0+5FX7E/vDkABQ3lsqDz+Rye5tvPCDBIiQvr4P1CInR287LNJaiHj16MKUI9X6QWtyuXTvFgkj4Yp5++mkjjtNWwKyMpyhcNNQYMPZO05mfjQKKD9Luz+8+TT/M+46uHD2SKjarZnsLkdR0jFg3+M3V6s7YESG3veZbT8LIb5+8Twl16rNEGKs+BOC8RTYzysHgngelCEUZvWWfoYgh7osIA+EFhCdMmFA+Bm4jgArPWN+nTx/mUoKigErqiLeBtwTKCrwzcr766it2H0YiESwuvBUVStEgphZJSEOHDmUhI+j/OXjw4PKsbDmo5n7fffexhCQoRlDKUMfv+eefp6VLl7I/JDnhmKH8II6XV2XnYF8uN74ff+ebW9DD1SDdr09F+wxocygTvmTJEvanhFCK1EEdohEPT/IwO8NCBIXIjnWKpEABim1YiXbTMba0kkKEHz6e+nCRxFNY/fr1fb4AOC0dnyPktg96EkbOZ5ym9H27mVIUbvbu3avoPoPioAUylvHgj4Dg+Ph4n4KJoSjgM7llSenzoQQdOnSovAsDZ9u2bdS9e3eaNGkS6/IgB4HKiMEZNGiQR4sXKERQaLAvBxnj48aNUyxRg0xvJCQtWbKEtdfgIHsb93pYsh555JFyJQhKEf4vl4f3IgsEHKdaU3jTKkUPPPAAC4SGVovsMCNT8p0EFB+k3R/43yb6YvYndMOtY6nhJe1tayGyA7iA4GLEn8oAngZxYW3VqlVYj00gCCV6E0Hyzpmj7hh6Yin1s4Tiwku/qIE2TL4oRL4A66FcIQKtW7dmriooPoi1kccgXnXVVR4KEaxasCDB0gMlRgrqBkIOWI2koB8o0uih+KRIFCLw+OOPM6v23LlzPd4vGMAyhuNp2bKlogIXCvzSZHBTgJYoYooCBwpQnZZtqDg5hS19UYiskPFhN4UI7WHkQEHCejT2FYqRwCnoTQSJr2SObFLE7ODepYRSjA0HMTLIYg4mmzZtYgoLjA2wTMk7RKB3l9zaptTZAQoPFCOUzJG7auG5gVtNrhStXbuWLaF8LVHw+kAZQ/P0YLNu3ToWB4V6g1DswuVq9kspgnkMX7rAGHDSodu1L9lIWhkfVnG9+SN3uIBZWO2CysF2ZLB4c6VZSW4jEXLH2DJhRMuFhnCAVt16mD7QWgtYXXw9foxHA1I9+61evbo81gcuIwQ4wy2PfZGavnnzZo9GwEAprolbsHHMSijtw7vWw90WKL7ILQXxS5Ad104oZ7CShQu/lCJEu2OiBMaAE4g30fMl40MOz/hArJIVFCNf5Q4niCGSusyUwHaM81YozkpyG4mQO8JxCSP9x46nmBhrF2P193eqt44flBEoPStWrKDevXt7WHHU7rVKx8UTnlCgWAkEQavtg+tXUlISBYqv9QuhECEIHA+eCBxXCioPJX6Fh6OqNExdb775pvFH5NDgUwS06QlC1dsiBOPsJHe4QVC1UeOsJLeRCLkLbZswIi8xAgsR1jfp0oO5g5zY0kYqNxQFFD1Wi3VC6rxcIUIq/IYNG3z63ObNmzO3019//eVhXcKxoAuFnG7durm50fQqPUryyOXWqxDhvWBp58cSTvyyFMH3iUj1f/7zn/T666+z/6ul5H/44YdGHKfA4S1Cwg3M2UaOEwjsljCiFN/otEawakDp2bp1K6vaLG9fgezV3bt3s2wz7jaCkvDoo4+yHom+AIUI/Ug/++wzVgZg4sSJ5dtmz56tGBuEdP6ZM2eyBKpffvmF6tWr57YdNZoOHDjAUvu5LODw4cMUCFDcoBAhyBsKEUr9mAG/lCJp4SqkOeJPCaEUGY9TW4SEG1y4oPhrudCwHeMEAqcBBUg8hKmDmCFYRS6//HJWjwg1f9DbE39cGYGlCMkaUJoQ+I16Q0ho0goCV+KFF16gX3/9laXmowAir1OExChkyUIBkcY9tmnTht5++20W59i8eXOWVY6WKNnZ2axeEt4DXSHQHgsgbrJWrVr0xRdfMCWsTp067F4POfS63xDHBIUICheOCSUH5GUHkBUoretkaqUIWqMgPDi1RUi4wUUEP16l7DMOtlu1QJ1AIAgeKGKMun5QTBA7BEsQijpCKULxxfnz57Mm5XPmzGH9vqBEoUntc8895/NnoSo23GSwEkHZglLTqVMn9n9kdQG5Z2f8+PGsLMGMGTNYsUhUykbcI6xGDz30EI0dO9bNffbNN9+w90eqPpQngL5yepUiPFzi+wBQ0pSSWPCAGQ6lKMLlNGevn2AScZJkZWUpugoDAVOAeAs8PXgL6kOs0Mz7xnnN+LjjzQ9Nn57vi9x2qlNkRbmNQMgd2vmGqwYPsAj8D1fHccw5/ngrCKdgVrlhjYLChPtYMFz9rhDLrfcc9+X+LSoumgCcRJgs9JzxdiLZqUWIL3K77VfqooIDWVSaXUiRSbEU1zA5ZBWxofjAfBxIRWt/5bY6Qm5nzTcHVhEnFvcNp9yoaC2vawQrFKpyI/U9mLGPJRafb11Xcpjd4Fv0l0D3tzso1IXeM/KCXf5mfFghHd8fuUHe1tN0YvqfdHrmFjrzxS62xGusDxVQgPBkgoJuWPrqMvNHbjsg5HbWfHNFGMHCTnNIhFtuxAmh2jXad8D9hcrYt9xyC3NvIXvcrnIbgS51DsFh8H8+88wzfn1IoPsLfMv4sCtQfDLm7PBYX5JVyNan3NySNZsVCASCYIKiiqhCrQaUAliShw0bptqENZjcfffdLC4Iwd05OTmsoOKYMWNYbBMs3cFg2bJlrHEst6CrWUURuzRy5EiytFLEfYT+YmWt0cw4KeMDLrPMhfs0x2Qu3E8VWqVYqrmsQCCwplKEpqjegHIQDqUIBSGNqFDtq1KkJzAcQdtmVop02/3RDRdR5/78OdGP7isIunUieuVGDBEsQlqUZBWwcVZAzLezcOp8Azte/1GWhgcVK/0hrubYsWPMQ+IUJk+eXC43lmrfjbSkjxnRlX2GWgmBntjo0HvrrbeSVQlm9lm4sFJD2dxN6SyGyBtVb2hOCe2V+/4IBE7CDNlnAoEts898LR4l8A1UfUUgeqNGjUJW58YMDWV9kRtZZnrQO85p820GhNzOmm+AZ260m0CRPztajNQQcsdZdr6d9Qs1cVYOyrKHKhuJN5SV1zriDWWx3WxyI+0+Kllb4YlKjmPjzE6o59ssCLmdNd9cOUD1YqfFlQq5XWRVhFLkMKzaUBbB05WHN9YcU3l4IxFkLRAIBAK/EUqRw/CloazZQLo90u7lFiNYiEQ6vkAgEAgCxbplJ20EfK+oIxEKH6yZGsr6IzcUI6Tdh6uitdXm20wIuZ013xwrVzcOBCG3NRG9zxyWfXZ42//oy+cmeR13/TNTHVMDSSCwIyL7TGB38oOQfSbcZyYANR02bNjAlsEGaffy9iBy0C4E4+wkt5kQcov5dlLAMSoqOzHQWshtTYRSZAKKi4tZSXYsgw1vKKtFqBrKhlJuMyHkFvPttCbATlSKhNwOVYq2b99O33zzDX366afGHJEg6NiloaxVa/UcPHiQXTSxxGuBQBBeUIsPMW+oyixwNn5HwK1bt47Gjx9PW7ZsKV+HLrzg999/p6FDh9IXX3xBI0aMMOZIBYbixIay4QYPED///DPzb4PPP/+c+bfxW2nVqlW4D08gsCV///03iznR4ttvvw3qMTRo0KD8WOygQA4YMIC1MAlEidy3bx8zpiCE4q+//mLtQerXrx/278gvpWjbtm2syR2qsz700EO0c+dO+umnn8q39+nTh6pVq0ZfffWVUIp0gCeUxo0bhzwbKdwNZcMld7gUoi+//NJjPRQkrL/++uttrxg5ab6dJjcaNqtlhKKatRnAHNx8882K2y677DLasWMHu28ZhVnkDjVxOuVesWIFTZkyhfVHbdmyJZ04cYLMgF9KEW9yB+2uSZMmTDCpUoQff48ePZg1SaCvWaTaj9XOOEVuuMhgIdIC21u0aGHrNhBOmW+nyZ239TRlLtzn1rAZtcRQbJXVFktJITOAe5WWZQO/P6PA79gscoeSSB/k7tu3L61Zs4batWtH8fHxpunP59cVePny5TRq1Ch2kqlRr149On78eCDH5qjAW5gkrRRwjIrXSO/fsWo5W/pTAduKcvsDYoe4y0wNbMc4O+OU+XaS3FCIMubscFOIAF5jfe6WU5SdnW36QGu1mCK4vfCXmZlJ999/P9WtW5fVH/LW6R3yQm6ki+N98dvGH/7P//hnFRYW0htvvEFDhgxh7w9LS40aNeiaa66hjRs3erw3Phv7Y4lElV69elFSUlK5iw7ABTV69GiqWrUqVaxYkfr168fCWvCZ2Fepnym2Dx8+nFnLcAxNmzalp556inJzc8vHYH+4zgCMIVJ58Jlcbj3zjd6P3bt3ZwqRmfDLUgShMWla5OXlOS7V2l/wPUHRhHXNCgW/jGomazW5/eX8+fOGjrMqTplvp8gNlxksRFpk/rCfXLfUocTERMu6D9HQFuEi+H0iRhZzmJqaqrkPVw5QGweelVdffZWtnzBhQvmY/v37syV6w2E9wk6uuOIKqlKlCmsYvWDBAuaBgbLSpUsXj89AeMovv/xCV155Jd17773lD15Hjx6lnj17MqME4hU7dOhAu3btosGDBzM5lHjnnXfovvvuo8qVKzPFCPf39evX0/PPP09Lly5lf7B44pih/HzyySdM0eIyAOzL5bbyfPv1C4U2Kw2wVgLBU/DhCuwFbyYrhzeTFdlrnuBJzchxAoEZQAyR3EIkpzSrkCKO5RPVorCzd+9eRfcZFActEOsCF8+qVat8tmpAUcBncsuS0udDCTp06BDVrl3bI3YXlpRJkybR4sWLFV3uixYtokGDBrmtf+KJJ5hCBIUG+3JmzZpF48aNU4x3fPDBB+mSSy6hJUuWuLm/pk2bRk8++SSzZD3yyCPlShCUIvxfLo8dsmn9cp9BM4WG+uuvvypuR+Do2rVraeTIkYEen8BEWLWZrNITbv6+TMrdlM6WeB1MkFHhrYoqtmOcQGAVEFStixxzuA2R7QSXj/wP9ypvvPjii0Fz88BVJVeIQOvWrZmrCpaioqIij+1XXXWVh0IEqxYsSLD0QImRcvvtt1Pz5s093ue9995jrl0oPimyeKDHH3+ctSSaO3cuOQW/LEXQPufPn89MfWPHji2PGn/77bdZ4BS+QPg3H374YaOP17bBaTBxmj3I1pdmsnqy2sIht7eg0GAA+fA0qpR9xsF2s8+/U85zo7Gr3Mgy00Nc1UQyA4jZUUt4UIqx4SAAuG3btj5/XkJCgu6xmzZtYorXypUr2f1UrgSdPn2aatas6baua9euHu8DNxkUo86dO3tkgcGdBbcaxkjhSiGsTkuWLPF4z5iYGJZhHgy5baMUQXOEjxx1iT788MPy9QhEA926dWOKEfypAu/gpLNCPSejm8mGWm4eFCqHB4Wm3NwyaIoR0u2Rdi+tUwScVKfIKue50dhVbqTd44FCy4UWlRxHKW1rW6phsxxYXXyNj4ECDNeZHlavXl0e64PSAAhwhisdn/ndd9/R5s2bmaIjRymuiV9b1GJ+lfZBTBOAuy1QfJHbrPgd9YfIcfhYoeFC08QXiws8FCKloDCBOngqQEDd5Zdfzi6gZgUFHo0cF0q5dQWFLtxPFVqlBO0CDsUHab8IosQTYe/evdnvyG4WBKuf50ZjV7nxO4GFVelBg1NpWEPKOlfWhNOq57k/AcOIrYGCokduKCNQelC3B9cEKbi3QinSe1zcTZ+enq64z8mTJ1X3wfEmJSVRIPgit1kJ+Kjbt29Pd999N3OpwVIkFCL/TiSkXpo9SM3oZrKhlFtPUGhJVgEbF0xwoUCiAtJzsbTqhcPO57nR2FluVofo5pbMYuRhIWKW1xS3lG4nIZUbBQrVsrER64TUeblChP2RsOQLiBmC2ww1BOXWJWSGIbxFDgwZQE9sFZcFqMlj9fl2zhVZYKtmssEKCtUdPCoQCMoVo7SJXana+LZU9YbmbJk2sUvQXNFWBEoP4oLy8/M9tiHB4uzZsyzbjAOF49FHH6VTp0759DlQiK699lpmEeJlADizZ89WjA1COj/KDDzwwAMsC04OajRJ6yVBFnD48GGyI7rcZ//4xz/8enOY96QxRwL7NJOV1ymChQgKkVmbyeoNCtU7TiAQuLvSKjS2dixJMEHMEOr+wIWKekSo+YOKzviDMoJsbliKEHeIwG4EfqPeENLetYLAlXjhhRdYZjhS8xH7y+sU/fDDDyx+EXGNUgt1mzZtWJLUPffcwyxNSKBCOR3UG4KrH+9x22230bvvvsvGIwSgVq1arLcplLA6deqwez3k8MX9BiURip/UzYx1+CzOSy+9ZGjrFcOUIrXqnfgilCpX8vVCKSLd5kgUwuJmSac0kw2l3HqDQjEu2Fhtvo1CyO2s+Qa4B+BGadVCfkbJ/fTTTzNrEBQTxA7BEoSijlCKUOIG2dxTp06lOXPmsOwtKFFoUvvcc8/5/Nlwy8NNNnHiRKZsQanp1KkT+z/S9YG8RAiauyMUZsaMGawEACplI1EKnSnQ3xRZ5tLf8TfffMPeHwlVUJ4AWtngffXON4phot6RlJycHLd1qIMUaqUowqWjHre8/QB84//85z+ZDxJLaL6IaofJDl/o66+/zqq3vvLKKyyQ1A4geAwnSVZWWdCgwHqoZZ9xgpl9JhCEGrhq0GYCHeLN0ldKEF5gjYLChPuYHYrF5us8x325f+uKKYLPU/o3b948+uOPP1hU/L/+9S+m7cLshiV6pcD/iC8e2q/AO+h9gycELJ1EqOX2HhQaGoVIzLc4z50CHqAzMjJsGWRuZrmV+o7iWouMcRR8DJZCVGqD+fYrJR9xQvB9yotJcVCdE9tnzpzJKmIKtIGxDhkIZm+aaAe5ofgg7R5ZZgiqRgwRXGahrKMi5luc505CqcaOEwin3IgTQiwRyoDA3YXSOYhNgmsLcTrBpMDi8+2XUnTkyBGv5lhsxzh/WbduHfO5orAVArBQURQVsqFs+QP8uThRjh07plnZVBAa0ArkyI6tFJ2VwZYNL2kfsqw1ERQqEAgCAUUVoWhoPfggZmbYsGGqTViDCcrkIC4Iwd2I00HB5TFjxrDYJgRKB4Nly5axxrGQmxefVAKxS2ZuAeaXUoRocwSB/fvf/1ZUjlCnANsxzh/wxUJxwXvfcMMNTLv9+uuvafTo0SwNUN7TRQ+ooQR/osAcTWV59hrOnu9eeJbVP0K6v1mz1wQCgUCqFMmDhJWAchAOpQgFIY2oUO2rUqQnMBxB22ZWivyqU3THHXewVL1evXrR999/z3yIAEucLAjm+vvvv1lEu6+gMR32Q8oggrbff/99evnll1n8UrNmzViRSHngtzegUH3++ec0ffp0MiOoETF8+HC2dIJCtGDGVI8eaniN9dhud5w031KE3M6abwBrAQJc7ZZ9hoxsWIPU/hBTA4uJvIu8nZk8eXK53FiqfTdq2eyWVooee+wx1nEXAdXXXHMN67OC8vVYjho1ipkVUWsA43zlt99+Y3EmMPXBzMbBDwsKEYJU9WjoHBS/Qv0F9GmDKdOMwOfbsWNH26dow2UGC5EWSz95n42zM06ZbzlCbmfNN4AylJiYaDulyBtC7giyKn4pRbDiINgabi6YwhDQ1aBBA7aEMgTFBtv9+SHwQlVojCcHLjWAugu++FZxMX7ttdfIrEDRQ/Esu2efsbpGMguRnOyM02ycnXHKfMsRcjtrvgEsBujDZeVsJH8QcpeSVQnInosCdPgzkj179rAlOgXLSUtLYz5aPsYbSEFEkSm49KpUqeJTTBEi6KVR9Lz7sHQ9lENYyBAILv3RQwmDqwA3AWlmFdZhm3w99oVFCzUXpOvx3lAs5TdPVEPFOHyuFFQXxXtJ12N/jEexMLgm5euxTtrDxiiZ8B54L+l3mHlKuUmhHIyrcWE/s8vkzzwB+XzrlQnHj7g6xO3BeorKslLCJZOeecJnQG4srTBPRp17eG/5fIdCJu7CwJJ/n/x45Bmf/qyXKzo4DvxJ12M//j3pGc/X8331rA+1THrWc7n5928HmUp1zJPWfAdDJn6O88/U+j3pxXRObq644IKvBAov6VFukGX24IMP0o033khXXXWVz8eBUulTpkzxWI+Knzy4HJaxESNGsA7Y0t4wUBRRnv3LL79krkAO4kjgNvnggw/cetrwjLq33nrLbfLg9sP3MG3aNLdjQPl2fAfvvPOO20XwySefZLFen332Wfl6ZB2gtw1ispCNwEEZd1QgRbd2qeXNKJluuukmatKkCfu+uExROecoXsd3//2PP1HJ8lWWkMmfeUIWJUBxU19kUir3z5UIfoEKl0y+zBOSMG699VbTz5NR5x63cEvnOxQyIeMWcqF1Am4OOEdQRgWK1ZkzZ8rHYhtCH6BoS6+tUApTUlJYjAivWgxQcbly5crsQVHa/BMJMfjD5yqlZeM4pIokemjhWoqiv9IbGb5j3MhOnDjh8VAMhVP6vYRLJnzncAuqycS71POu9HaQ6aTOeQLYH+8TbJnwOdgPjXNRJ1Ht9+RLyI2uitZyEACtFxyoL8BttnjxYmYNwkVAqQYSvihvihH6t6BTMJrs8TLhCP5G5Us9KflKliKUT8fJzitiGmkpevHFF1k5dZwMdrUUIVZo9sP30PkzZYH5SlSsmkK3zninPD3f7DL5aynCTUw6395k2rp1q2YxVMT2oYCqma0q+AwoBlAKcVE2+zwZde7hPeTzHQqZ8vLy2DUPoQ38QS4cliLcTHHzl2NnSxHOAciNTg98nVMsRSdV5jsYMsH6inMc7UjgRVL7PUFBgxKnp6K1X5YiPOHojReSXiD0wC1EakoPlBO4wrSAVoinTfR58bdvCi5eUgVFaz0uTErgwqRnPSYYT4KYVGmjPulnysH3r7Qe+yutx4mhFNiLk0YpCypQmdSO/dLb7mJZZmpge3x8gqVk8nWetOZbSSaMR98iLdAAEnW4+PuFWiY984TvH3LjadQK82TUuac138GUCZ8FubCUfq70Ji3F1/VK1yr5etygYGlQew+t91Ebb8SxByKT3vWQm8+B1rFbSSYlpJ/pbb6Nlol/v/w35+vvyTCl6JlnnlE8UG7GgiUJmV6dO3f2+b15LBEsRWhiJwVmOliJunbtqvke3PR+3XXXKW5ftGgRO/527dppFuAKFZhYJauYHUEdohEPTyqvU8RJSqlGA8Y6o06Rr/ONEhQ8pk0NbMc4WELNipPOcylOlRvgOuvEvmtCbuvil1LkrfYCzPzIQlOKyfEGfO2I58GTMQo3ypUZPkYLNKOF8iQH69C3DUUl4UKDyc0MwCSOWAG4FdSeBO0EFJ/GXbrRgf9tovmff0bXjrkppBWtA8VV6gqoTYiv8610LgcyLlw47Tx3utzcSsbdSGqWBjsi5E617HwHJdD62muvZS4sBCpyRUYvAwcOpEaNGrFiiwiU5rWKYIWaOnUqM4MhSFPa+A7bEMTFXW+ofI0/OfA9Qilq3bo1C2Q0E05Lz4YCVKdlG8pPTGZLqyhEeVtPU+bCfVSSdXG+0GC28vDGPjWU9WW+9TZvtELXa6ed506XGzitpyNHyG1NgqbKtWzZktasWePzfvANQmGBpo0g7TvvvJO19YCra/fu3UwxQuAgB4oXPgsZLQJBsBWijDk73BQigNdYj+3BoH79+l6DA7Ed4wQCge8gsxMuLydVoBaEWClCXI+/5rMBAwaw1Fa0EYFlB6myML9+8cUXfvU9EwiMcJnBQqRF5sL9bJzR4Hc0dOhQzTHYblVztUAQTOAh4AG7an+ZmZlBPQY8yEsf5q3MMgMVSLiW0S8NscSIPUPdNRhCeEkDy7jPDh06pLge6ahHjx5lvU1Q1TqQpm8IpkYGmTfwWXp7qeCkNKNJE9k2qDeilnVjV/yVG6n9rDp25lmqWLkK1W7ZOujuN8QQyS1EckqyCti4Co0rGy53q1atWD0rlJKQBl3DQgSFCNvNjjjP7fv7hmUfgf68QzqsljwzCKnQerOVgwmvJaVWCmbHjh1+ZyvLMZPcoSTCB7lxzqCGIEJsunfvzlqEIcEKnqIlS5bQ2rVr2XtZQimCcqElNBQPnIDSYmUCZUpLXXRsTyadyyikwrOZVKtpFYr0IWjXyvjTLBINY+WZaxWrVqNLbwtu5hqCqo0a54/cAIpPixYtFG8+VsBfua2O3eXevn27qrKO0Aaz9PhDBqCWdQO/LSMxi9yhJkqn3Ig7hkKEAssokMp/H++++y57aHzqqafovffeo1Dj19UUgc5Kf8g4Q4GyuXPn0pYtW0yT3WVW9m1Mp9mTVtP3r2yipbN3syVeY71Tgk9R1E5vECoUItQ4kvdPw2usx/ZggSwzo8b5Krfb+0dGsrT7tm3bsqVVFKJA5bYydpYbChGqCMtLRuA11mM7SqmY0UKvxyXE3V5wr91///2sgC/iXr15JyAv5D5w4AB7XzzI4E/qsuOfhfPijTfeYBnReH9kKKLKMwqySiu7c/DZ2B9LVFVHmAmKoUrdc3AZItkINYPw8ISMbZTKwWdiX6Xq+Ng+fPhwZi3DMcClBcVEWg0b+yO8BSC7XCoPPpPLrWe+Z86cyZbINpc+MNx1110s2QqKEgqQWsJSpNddJVAHis/P7231WJ+TWcDWD72rDTXuUEN8hRKXGSxEWiz95H2W6h8MVxrS7pFlpuVCi0qOY+MEAicA94e3zgCwBPA2RlYFcS+XXnops86iDQ2UIsS46gEtKZ599ll69dVX2esJEya4FUEGaHuB9X369GGdGFCcGO1lFixYwEJIoKx06dLF471RnBila6688krWeoYrpghh6dmzJ8vMhrUOrWZ27dpFgwcPZnIogbjd++67jx0vFCMoZevXr6fnn3+eNX7HHzK/ccxQfmDl4a1qpLLqBZWo//jjD1aFX54gAgUJxworEY4B34vplSJMErRSLUsQmlZCS/a1zYdTXGYr5mk3tV355R5q2K66Y1xp3mAxRDILkZzsjNNsXN3Wlxj++ahDhLR7ZJmpUXl4I5/qFQkEVkZvUVFYDuSNi8PB3r17Fd1n3pIYcPzIfl61ahXFx+vp3khuigI+kxsSlD4fShDidNHCSgpaVCHWZtKkSaz1lRwopFA6Bw0a5NH3DgoRFBrsy5k1axaNGzfO431gzUP5m0suuYTF8qDnGAcWTmR4w5KFJCeuBEEpwv/l8shbgaiB/mQYq9T4XV7EOdRKkV+2d5jPvFmLZs+eXW5mE7hzfE8mswhpcf5sARsnuPB9ZJ41dJw/oA5Rys0tmcVIbiHCel/qFAkEVkdvsVCp+yWc4EYMl4/8DwG93kBvSl8VIr3AVSVXiADq6eEeCiOEUv9EBCnLFSJYtWBBgqVHnql9++23M8uMHFhkkCQFxSdFohCBxx9/nAU7IyQm1I3fpeNMbynS4y+EFmjXwMJAyTlXYOg4qwJzLJ5q9PSlQZaZHvSO8xcoPhVapQRU0doXue2EkNte8623WCg6CJjhXqDVCFwpxoaDVHHE8PkC5EVTVL1yo90UFC+UooFlSq4EoaEpChRLUWp3BTcZFCO02JJXT8exwK2GMVK4Ugir05IlSxSzRnfu3BkUuR1T0ZqbvdS0QKeTWCnOkHFwwzGr07kCNrZm08qWcrdBucaTAAL7vP2IkHaPLDMtFxr6p2FcsIEC5C3t3ii57YSQ217zzYuKarnQsF3JCmIlYHXxZ97QDF2p4bGc1atXl8f6oDQAXEdQOPGZ3333HW3evJkpOnKU4pr4XOCYlVDaBzFNAO42I9Ajt57G79JxplSK/vGPf7i9xmQh4ErpC0E8EUx+l19+uTFHaTOgvCRWjtN0oVWsUqbkaAVqIy5J+h54zz6jm1omQBtPQwjwg9XEW08oBE8j7R5ZZmqgoawV2oX4IredEHLba755UVFkmWlZZzIyMixtPfDnuPEAcOrUKV1yQxmB0rNixQrq3bu3hxUHSpHe4+JuJ7Xih+hDp7YPFJGkpCQKBL1yI7sM5w+MJ0rw9WoxR6ZQiqQxRBAW5j61DvPYjmh5UadIGVhzoLwoZZ9xel/fVNXq49TMNdQhGvHwJI86RbAQQSEKZp0igUDge1FR1P6BO8jpoHaPWkkGxDohdV6uECEWa8OGDT59DmKGoHj/9ddfTNGSKuFQWJRab3Xr1o19DhSwwYMH65KFG0D8BfFZcP/hMxGwL81Aw3EisDwxMZG5AU2rFCGTjB8wtDykEP7zn/9U/MIQTQ+BBOpAaYHyIrf2wEIEhUhNqXF65hoUH6Tdh7qitUAg8L2oqN5sJLsDpWfr1q0sFR0xSlLwXaGvJ7LNEFzNFY5HH32UWV18AUoQGrKjxg/KAEycONEt+UkpNgjp/KgZ9MADD7AUf3lWOWo04f6P1H4uC4BHKBDQzgNKEbLbpMUbEfiNkgTYHqzgdkOUIqkm99FHH7Hu9aIBZWBA8YHycnD7KZr/xXd07Q0jqX4rbWXGl8y12s2DG3RsBP4EG0MBCkbafShxWpA1R8htT3hRUSWs6jYLFKnciBlCzR2ElCDFHL8DlKvBH1dGYCmC1Q1KEwK/UW8Iae9aQeBKoBjir7/+ytzzy5cvL69T9MMPPzDrHax60qKvbdq0obfffptVkW7evDmrlYSOFNnZ2Uw5wXugMDMqTQMowCixgF6kUMJ4ID3kgPtN73yPHTuW9TZFZhuULtQ9QtmEb775hp1L//nPf8gygdYQRmAMLiql09UOUut/1KHTCQepHiElMsoRmWv4QeEpwWmES261/lShQsy388D5Jc+acqLcTz/9NJ09e5YpJogdgiUIRR2hFKH44vz582nq1Kk0Z84cSkhIYErUt99+y5ql+gqqYsNNBisRlC0oNZ06dWL/R7q+NI6IM378eGbomDFjBosHRqVsBDnDaoQuFdJ7PrxBUFzw/lBooDwB9JXDPnrnG9/R999/z2ohffrppyzcBlYo1FKCQhSOvmcgwqUjvx5fEoAPEFosf60HuxRvhL8cE45oefkJ5S+/HvyVpv05jU7mXgx+S01IpSe6PkGD6rvXn+Ac3XWWvnvFs/S7nJEPdfBqKQp39hpu0ngS4UF3TiEccmv1pwpVM1kx36E9z+GqwRM4nrrlLptQgdsLj21xksXIrHLDGgWFCfcxvSUVzCy33nPcl/u3LksRTHgQEF2EmzVrVv5aD4EEY9kZKEQPL3uYXOSuk6bnprP1M/rPUFSMjMhcM0v2GrKR4EsOdRYWWoaEMyYp1HLz/lRyeH8qmOxDoRiFa77DjVPl5jdJpHxbOfvMinKjorXcYgMrFKpyI+0/GAqRGeQ2Al1K0TPPPMMERF0V6WuBf5SUljALkVwhAlgXQRE0/c/pNKDuAIqS3awDzVxzcvYaQNNYefYa6h8h3T8U2WuuUhcVHjhHjYpT2TK2WbWgtgbR058K2xEn4CRrnUBgZxAnhFgiPOzA3YVMccQmIebnpZdeCvfhWV8pkvc3UerfItDPhvQNbi4zJcXoRO4JNq5LWhfDMtecnr0GhUipzhEUJKxHun8wFaO8racpc+E+1lR2ALWmrI930vnkWNZTLVgtQvT2p8I4tUBZgUBAHnX61ErScIsJYveGDRum2oQ1mNx9990sLgjB3Tk5OSw+Z8yYMSy2CQ9AwWDZsmWscSyPWVQznCB2aeTIkeS4itYCdU7lXkyzjCh1UcvDLqpynuhsRaIddSPIdUEZkY5Ty1zzNSbITNlr+NHgxxoKqyNcZrAQabH0k/dZun8wXGlQiJSayUJBwvpg9U7T259K7zirzLeZcKrcHD1Vna2oFKEpqjegHIRDKUJBSKMqVPuiFOkJDEfQtlCKBG5UTyiLqu+6q5RuW1xK1cqC9xmnk4g+HhxJfzaPLB+nBhQgXxUXM2WvIS0VNTJCAYsh0mgRArIzTrNxRqf7w2UGC5EWmQv3s55qRrvS9MYOBCvGIFzzbSacKjeAS1at5YSVQTFjb03RncbkyZNt4UXSpcL7q+niyUipwZzT6VijI112oBKN+6as54yUqtlEj3xTSh/eUIWN8xabBBcbLEpQoDBeHoMUrL5rRoAgfJSwb9euXXmV1GCBoGojx/kCmsfCIqRFSVYBGxdIT7VA+lOFouZYKOfbTDhVbu5GQmVmpJk7yVIm5E6w7HzrUop8LR7FseqXEmwiXUS3/VpW6VX+DSHUFVtuW1JCkU8bm85vZPaaEen8xcXFzO+NKq7Bvlkgy8zIcb5Qml1o6Dij+1NheyiCrEM532bCqXJLmwCjMrGT7gdC7nh7K0WiVLux5K7/i6JPZ6pux+0p8lQmG5fYrath6fxGZq+FO53fV5B2jywzLRcaeqhhnNFEJsUaOs7o/lShqlMkCA86StEJBJbEFYRz234RcBagWGc/G6Vx0nR+pSBtioxUTec3InvNqun8CJ5G2r1S9hkHTWWDEWQd1zCZopJjNV1oUclxbFw4+lMJ7ElMTAx7Wkf2UTh6SAkEwQauWX6um0opgnkYpb5RA8GOmQZGE62zfLnSOJ7Orx6k7aI/m6un8weSvWZ0Oj8u2OixEyozK9LtkXYvr1MECxEUomCl4yN4Gmn3StlnnMrDGwW1XpG3/lShINTzbRbCJTdcdajii6aiqDIMyyCuz6E8DngZ8HmoPOwkBVzInR/U+eYxW+np6VS5cmVD3dK62nyoBQ++/vrrLAIf3X3xNjj5UTQKzePuv/9+WylIRrb5cJWU0N6+vag4Ay40pQuUi6JTKlOT31dRhGyyf9z/I339wWMsGJtke5deeP3yNZE06o7/0hWNriAjMbLFSDgJV0VraZ0iqYUIClGw6hQJnA2PbcHNQ3QXENiNypUr66qebXibDzkwvw8ZMoTWrl3LtEE0jUtNTaWTJ08yBemRRx5hDe4WLVpEiYmJ/nyErcH8pXbMoqOL8Qo6qXRCy3RUbFea5+pxKcxCxN5HLUh7cSlVuA+NZY3F6HR+WBhXrlzJ+vGEUoGGAmR02r0eoPgg7T537xnasX4rtezchhKaVA26hcgshGu+nSw3bha4ceCGAKUIxxJK8HkbNmygjh07Om7OhdzRQf2O4TILRuKCX0eNNh9oKocKmejsC6WIc+jQIdYBHN1zMe7ll1828njtwcHVVCnlGFGvCnRyQzIV512c2OiEEkrtcI4qpeSzcdSwj9uuLQ6X0hGJy4wUFCO41OocLiWqTYam9Budzo+LNDo49+jRwzEXTChA0fUr0v/NXUZtR3V3jELk1Pk2i9xQjvDZof58uO1Q5bhbt26O6vsm5O5m2fn26xeC9N7OnTuzBnNyoCCh+eHu3btp3rx5QilS4nxZGn2luvmUVDufck/FUnF+FEVXKKGE6oUUEek+Tkrpac/aRkp4G+dPSr9R6fwCgUAgEJgRvyKhMjIyaNAg9Vo4ANvRLVegQMXU8v9CAUpMLaTk+nlsWa4QycYZEaQtT+lPP3+CWh0spV7bStny1PmTbD22a6Xza+EtnV8atH1sTxbF5lVnS7y2CohJOrztf7Rj1XK2xGuBQCAQWB+/LEVNmzZlgXtaIOOhSZMm/h6Xvanfk6hSLaJzx8tjiNyJKNuOcTISOnei6LQ0Kj55ElGUCrtGUHRqKhunBE/p77KrRCF7rZQ+GRxF0xPUU/oDSedXqnNUiVrQj29uNX2dI2lTWXn2GuofId1fb/Ya4vDQwdpJ2ThAyO2s+QZizp0155E2uLb5lX324Ycf0oQJE1igNaq0ytmyZQvznyM77R//+AfZASOzzxjbFxB9eeuFF9IpuGBluX42UasRysfyyy909J8TLuwq2fdCZHbt116lSpddprjvuhPr6N3Xb/OavXb3gx9rpvT7W9Farc4Rx6x1jrhCpFXnCOn+wUrrFwgEAkHw79+R/lqK0A8NcUV33303iy1avHgxW951113UtWtX5j6Dpej33393+xNcAAoPFJ9KNd2/EliINBQiNuSyy6j2YzdTdIK7PovXWK+mEIFT2Sc1s9fwjtiOcXqa0TbrksaWel1meuocmdGVBhcZLERaLP3kfV2utKKiIlqwYAFbWq32yoEDB9hDD5a+Vrq3qtyB4lS5nSy7kLuIHOU+69+/P8tmgJHp/fffp5kzZ5Zv44Yn9PrBnxxRK0MCFJ8Ww6hw73Ja+PlMGj5mPMU26UfkrWbO9gVU6dCLlDTMJQvSLqKIQy8SbW+jqlSl7T1D8Tqy1xL3niHSDh/yGWZZ0gjSBufPFrBxZqtzxOoaabQIAdkZp9k4b+n+UCY2btzIylpYhe3btwfcJsSKchuBU+V2suxC7iFkVfxOyXdaVdqgERlFrvq9aGvECrqyfi/vChEsET9PZDYdHqTtTgTRz08wZUvpvRoWV6ETOg4L48xe5yiUoNCjkeP8xVXqooIDWax5LHqloTVIsNP6oRApNZSFgoT16Ksm+qcJBAI74JdSNHnyZOOPRKAP1C46d0xjgIvo3FHFGkcgtoZnRpsS3sYVFxXS/379grKPH6KkmvXokkE3UHSMdkNTo+schRJUvjZynHEVsWNZC5FgVcTGEy8sRFpgO/qqWTm4UiAQCIBzKqiZGFTl7Nevn77qnAq1i3wZx7PXik6cUGkwQhSTlqaavQZWfvYSRb72EVU5V0q8zeSflaZT6T9vp943Paq6n5XrHKEVCLLMtFxo6KGGcYbOt0QhUuqdBgUJ61NubhkUxQgNZKUuMyWwHeO89VXzR2474FS5nSy7kDuKrEqkEU+Sx48fZ5Wslf4E3kGVWcRp6ao2q1C7yJdx6KWWOunJMven3AUaEcHWs+0qJzUUoqr//pAqn3MPsk0+V8rWY7saRtU5QiA2+rDtXneCLUMRmI3WIEi71wJNZfX0UPNpvi+4zGAh0iJz4X42zmjQ0seocb7KbRecKreTZRdyR5PjlCJkmrVv354qVKhAderUYU+J8r9GjRoZe7Q2pbCwkH2fWOqucaRo5+E1jmor1jhyy1577VVWz0gKXmul88NlBgvRhU9RzFyLfP1jNk4NXucIFiO5hUhPOj5S+mdPWs0a0y7+cDtb4jXWBxuk2yPtHhYjuYXIl3R8n+YbLQMOZLm5zJQoySpg44ymYsWKho3zVW674FS5nSy7kLuQrIpf6txLL71EEydOZA3Z+vbtSzVr1nTck4CRIGNv37595Zl7msASMXT6hRpHEco1joZO8xqwDcUnaUB/yv1xNhUfO0TRtepRwhW3UoRGXBBiiOAyUz00IqqSVcLGdbyc12DyBIpPw3bV6eD2U/TFnPl0w83XUv1W1b1aiNRqHMEdh/WhqHEExadxl25l2WiZZ1kMEVxmeixEfs03LGPZhYaO84X69euzLDMtFxq2Y5zRctsFp8rtZNmF3C6yKn5pMm+88QbVrl2bVq9ezaxEgjDVOEIWmjToGhYkKEQaNY7K2b6AIn6eSIl8f4Qg7Xu5TOFS2R9B1TyGSAuM8wYUoFpNk6kw/hRb6nGZ6alxBGVLT82kQIAC5C3t3tDPS4o1dJxPnx0ZydLulbLPONgugqwFAoEd8Mt9hhYeo0aNEgpROIHiMmEr0dgfiEZ9WLacsEW3QsQsTfIsNrQdwXpsVwBZZnrQM85VUkJ569ZR3b8PsiVeG1XjyG4g7R5ZZlpEJcexccEA6fZIu5dXgsVrkY4vEAjshF+WombNmtHZs8Gtx+Ik4HocPny47y5IuGwU0u711jnyxKVZ5whp98gyQ1C1kjYNx1pWchR1HXSD5iGgTcnJqS9Q8YkT1AMKz5o1dCotjQV4q8UzWbnGkRRUvD6+ewd1bVyfLeu1buvV9YY6REi7V8o+41Qe3iio9YqgGCHtHllmCKpGDBFcZr5YiPw+zy2OU+V2suxC7mhyVO+zTz75hPU+27Rpk65YAjtgeO+zcHFgBdEnV3ofB8uTgsLFs89YULVC37QzT4/TTMsv79smP+289G1DlhmCqr0x8qEOpquGbVQzWeU6RXFMIQpWnSKBQCCwOkHvfTZ27FiaNGkS9ezZk55//nn64YcfPHqciV5nvmUqvP3226HJ0AiwzhEUHig+WZXcTx1YiLwpRHCRwUKkqIe7XGw9267gSuM1jrTQW+MoHCn9vJmsvM4RXmM9tnsDik/axK5UbXxbqnpDc7ZMm9jFMgpRSM9zE+FUuZ0su5C7kKxKdCCaF7QutPzQQvQ68w6UAcRphSRDI8A6RwCKT/H1D7pVtO6qo6J17vq/mMtMo5gA245xid26KtY4Uso+86XGETLYELAtjU+CsoX3Dlbmmt5msshq0+NKq9DYfMUtTXeemwinyu1k2YXcLnJc77OpU6dS9erV6YYbbhAp+VaC1zlCULViXBHqHNXSrHMEoABppd0rUZh+Uve4RI0aR3KlBhYiKER6ahyFI6XfyGayAoFAIDCZUjRr1iwWbL1u3Trdxd18Be/97LPPsrT/oqIiatu2LT388MMs20WPlo5+TAsWLKBVq1ax4FC8R9OmTWn06NHsfVB00pEYVOeIBWyjvxrcbLAqQYnyss+B6LO6UvoxroqXGkcsG+1cAeuTBpeZmVP6zdJMViAQCARBUIqQeQYLUbAUoqVLl9KQIUOY4oLPSUpKoq+//popNIcPH6ZHHnlEc/+CggK64oorKC4ujpWYx3vl5+fTokWL6F//+hd99913tGzZMkpISCAzgCKYN910E1taos4RUvYV91WvcQRONKlKSUlEVbOVg9kQrH0miSi7SVXNj49wlVLlzD1U8dQpii6tThEu9GmLMiyl3+hAbTM0kw03aAd09OhRFoeIZYMGDRxT2yjkv28T4VTZhdwx5CilCFYb9DsLBsXFxTR+/Hh2wUSwNlqJcJdd165dWYD3tddeq5n1hmZ8//nPf+jee++lKlUu3mhgLUJ9pYULF9Jbb71Fjz32GJkByNqkSZPQfiiUF6Td+2jtKa9xJHe98RpHULZUFKPqSan07uBIeuSbUqYAKWWvfTw4ku5OStWVzs+J9pLOH+6UfiObyVqR7du3M8str4oN6y0yQFD0Ean+dicsv2+T4FTZhdzWxa9HNW5t2bBhg+EH9Ntvv7Gy8GPGjClXiADS6aAQIaofJQG8aek4RqlCxNc/+eST7P/Lly8nswDL1gsvvMCWIYXXOWp7bdlSj8tMs8YRldU4wjgFOtboSAc71KQZ10Qxi5AUvMb6Qx1qsXFa6fxShQgUnzzJ1mO7GnCz6UHvuHA1k7WiQoRq2PI2IXiN9dhud8L2+zYBTpVdyF1AjnOfDR48mJnCb7nlFmrXrp1q7v+tt/oWjAu3FrhM4akfbrBAFRpuxjVbMTFLpKzCqiSvgu2Gi+jc0bJxCjWOoiKj6ImuT9DDuQ/TuqYR1OJwKVU5T3S2ItHOupHkioygGV0nsnFq6fwe9Y3YRherc4TtSQMHUkRUlGpKv5YLTW9KfyDNZOV1imAhgkKkt5lsILhKXaxpLHqkoSUIKmAHs+AjXGawEGmB7SgKaXdXmiV+30HCqbILua2JX5rBbbfdRhERESyg+cMPP2Tr8FoKtmGdr0rRnj1lwbAIipaTlpbG4pj4GH+DxNWULrmmL3264U+60vW4kEPJglsONwCp+w5KF34U0lRUrMM2+Xq+r/xpCu+N71D+44qNjWX743OlIIYK7yVdj/0xHqUR4JqUr8c6adkETZl01jgqOnuEouqXsveSy3Rp3Uvp5X4v07Q/p9H2+hc726clpNFjXR6jPml93PbhMp1bs8bDQuSGy1Wezh/XqaOiTD1HNaLFH6pXhe52dUMqKipUnSe8B94rLy+fTuw7R3nnCim+UizVbZFCUVGRXuepXvtOdOuMt+nYrh30xexPaNSNY6h+m0uYhQj7GjZPCude0a4syv6/A26FHyMrxVLylY0o8ZLqQTn3Dh06pNlIFmD73r17y6tjG/F74vNklt8TR3o8VpdJ7zxJj9cuMvkyT3xpJ5k4SjLxMfg8+fhwyxRUpeijjz6iYIHaR9xdpgQsUnyMr/z000/03nvvUcuWLWncuHGaY2HynTJlisf6GTNmlGeudejQgUaMGMHed+PGi9WW+/XrxwK84R6AK5CDcvcdO3akDz74gNXu4PCMOsQ5SSfvnnvuYd/DtGnT3I7hiSeeYN/BO++8U74OJxBcg/v376fPPvusfD3KJiC2avPmzSyWitO4cWO6+eabaeXKlW6WN02Z6uurcfTZgiXUu1IXFkuA70suU9+afWnVjlV0qsIpyo/KpwolFei/D/6Xzmefd5NVKtPvH85iLUG8UXzqFK1TkWnn8XV0rvIhSjzXmKJKL7rJImKLKSthN837aQXRT+rzhIDRiOxK9OMHf1FkycX94ytFU89rm9C8n2bqmidkPxYnp9C8HxcR4c/oeZKde/VLqtPAwrYe9aFKzhXQmc93smy7VxfONPzcQ4KEHj7//HN2ETTq94R5Ujv3wvF74hbuV155xTYy+TJPHDvJ5G2ecC2XzrkdZJqhc55ARkZGucHEDDJ5C7kJuM1HMIEFZ/HixcwapBSgV7t2bdZ7yVfFCCn+AwcOZJrjihUrqHXr1j5biurWrUvp6enlrkKjNHGsO3PmDLuJSJ8sTfd0ERlBrlfaEGUfpwiFuCIXbrtJNanw3r8oJq6C16cLvD9+PCkpKUzR1JLp3OrVdPyO8eSNep98omop4jIhPR+WnoLzxZRUJZ5S6ifwLiOa83R4ayYtmrlN9bMH/qMFNWyX4nWecCw4j3BB4fOtd55QCBKWprysLEquVo1qNGl2sZSCwrkHl9mZVzZT6Tn1JyW0Cqky4RI3V5pRliLpBVANxA/a2VKEYzxx4gSLceTzbXWZ9M4TtmdmZlJqaip7HzvIpGee8vLyyq9t/L2tLlOBjnli1+pz55jc8sLN4ZTp9OnTTAHT0+bDXIE1EguRmtKDL1weQO2N9evXM2ULXyjS8r0pRHwC8adnvVq6KSbV2/qSUhf9eSCDjp3No1pVIqlrwxSKksV5KB0HThql9ZBRaT1ODPzJwUmjFF+lJlPE5eo1jthRXz6d4uIvljpQOha+HicvTlR8H5BHS6aK3brS2UqRXpvRNu3Y3qtMiE+qkfM3FZ8+RdER1SmuSSfFOCTpPEGRWvnVXtLij28PULPONd3qHCnJBLlxDnO59c7Tgb/+1N07jR97/r5MTYUIlGQVEB3LpziFStmBnHt42sMFSMuFhu14+JE/DPj7e/J27OH4PWG+cZNQmm+ryqR3niB71apVy29yeo/dzDLpWY+HPOm1zQ4yxemYJ8w3fxBQOhazyaREwNGN0OJOnjzJngqV/nyFxxIpxQ3haQtWIqV4Iy2FCEHh0CqhEHXp0oXMws9bj1Pv6b/RjTP/oEfmb2VLvMZ608JrHFWq6b4edYo00vE9KC2hoj1L6YcXbmNLtYw1zsaMzfThoDJVrFT+VhdUtA8Hutg4LZChtnfgIDo0diwde/RRtsRrrcw1X+sceQNPMzA5++Ln9rd3GoKq9aB3nC/gAoi0ey2w3QlB1r7Ot11wquxC7kKyKn5fjf766y/mK0fgc61atahhw4Yef40aNfL5feEbBL8o3KSg1EjH6FWIoLghy6Vbt25kFqD43DNnAx3PyndbfyIrn603vWI0YSvR2B+IRn1YtpywRb9ChFpHr7ah2M+vplH0I1viNVuvwqncU/Rn80h6+ZpIxXR+rMd2jFMjkJT+cNY50ts7DePkIMtMD3rH+QrqECFmTm6yxmusd0KdIoFAYB38cp9t2rSJ+vTpw8xacEshQApp+cgOQ+0iBGkh6EmrwKIaiPuBMoXgywcffLC8VhHcaei3BjOYNKMNRSSxrWbNmm7B2VDaoBDBJwmFqEcPPWG6oQEusykLt6tW+4HVA9sHt0rzcKWZBl7jyFf8LP5YPaE6W0LxQTp/y8Ou8nT+HXUjWDq/dJzRKf3hrHMUSO80pN1HJce6ZZ0pxRRhXLCA4oO0e2SZ4XeNGCK5y0wgEAgsqxT9+9//Zss//viDZXLh4nb11VezqtMIMEMbjvnz55env/t0QNHRLPodVqi+ffu6tflAD7OXXnqJtQjgIKIdkeXIiEOpAICgZShECPCDeR6B2/iTUrlyZZowYQKFgz8PnPGwEEnBbRvbMa5H44uBu3LK4pHOUHp2PtVIqkBdG1Y1rxKlq/hjRFnxR1TaltUqQkHH1IRUSs9NJ1ck0fb67nIiognb1Qo/IlVfb0p/YreuQatzhNikY3uyKDavOlvWb+W911ogvdMQPF15eGPKmKNeiqDy8EZBrVcEcI3AQxLiJ3hQtUAgENhCKUKaHNLioBBxeMR3fHw8vfnmm6yRKypQ48nQVwYMGMA+Aw1h582bV94Qdvr06az/mTcQ2IkCkwBWIqUCcrgwh0spghIT6Di412BNkipXNZMr0LPDW9HQNrJ4HxsUfywv/LjsYaYAuSSK1YUQb5qoUviRp+rrQW0cFJc+o5vSz+9tVd239/VNNRWcfRvTWVNaKFaVqAX9+OZWpmjhfdHoNli90+LbVKOUm1tS5sJ9bhYjWIigEGF7KICVFynIvgQ92gGnyu1k2YXcseQopQjuKmm8ECLBEQDNwVMg3Gdz5871+8DQ5wy1CLzx8ccfsz8psCSZrNKAG7DqBDKOxyPJJeTxSO/c3NGcipHO4o9q4wbVH0Qz+s9ghR9P5l4cAwsRFCJsVyO6urJbzZdxUFyG3tWmXLGRWoigEGkpNlCIlBQqvA/W433V9jeidxoUnwqtUkJa0VoOfpO4dlSrVs0jC8vOOFVuJ8su5K5m2fn2y4Zdo0aNcksMQCyRPFsMXelzc3MDP0IbAjcXrDpqpwzWYzvG+RqPBLAd40wHms4GOA6Kz6JRi2jWkFk0vc90tvx51M+aChFI6NyJNY5V+1awHtsxTgsoLrf8uxsNGVqBenUoZMubn+umqRDBZQZFSouVX+5h44LZOw0KUIXGlSmhfQ22DKVCBGDxRZE6eU0Wu+NUuZ0su5C7iKxKpL+Bk7t27Sp/3atXL5YttmbNGvZ6x44drLIkgisFniDuB24uIL8t8dfYrhQf5Es8kjegOK3Zl0HfbzrKlkFXpOr3LEvd11IHK9UuG6cBXGRd0rrQFY2uYEs1l5nbO0dF0cnxw9j/lVL6AbYrBVlLQYba/sGDqeiJcRT3ykNsiddamWtGpPPz3mmwGMktRFgfit5p4QQlNQ4cOEBbtmxhS2nhNoFAIAir+2zYsGH00EMPscwvZH1NnDiRvv32W+rduzcr1AUrEi5aiCkSKAP3Ftxc8rigNC9xQUbEI4UtJgnKy1D14o+ModM8gqwVA7YRdwQ3G6xKUKK87FNSWkKTY3+m+tdE0m2LS6latntK/yeDo+hg7CL6ufQhVSWLp/TLM9h4Sj+99ipVUuipZ1Q6PxSfxl26lWWjZZ5lMURwmXmzEFmd7du3s7hAaRFIpPQjiUKk9AsEgrArRXfffTerMcIrSyMdf8mSJfT888+z3iadOnWiBx54gClPAnWgfCDtftXuE/TJvO9o7OiR1KuZdhp+oPFIYY9J4sUfkYUmDbqGBQkKkbdaR0jpV9x3uua+G9I3sDikk1op/bkn2DhYn4xM6TcynR8KkDztXi+oYxRuhcrXgFsoRLA6y4GChPVWqXXktEBjKU6VXchtTUzX+8ys4CKMOkh6eqcEE7i4UPUaCozSxEVcsDatnHiponLF91dzwXnb3zD8sPao1jjiViaNito/7v+RJq5AOQBtEKcEt5ycnD/+ZNWv9fRek6f0I1Zo9qTVXtP5b3m+p9f0fLwXc8edK2BKFEoAeNsHoOK13hYhaqCPWigDtWFtfvXVV722CUEWqUjxFwgERty/RbEQE4CLPwrb6YmTCCQeyeiYpICIjKLS+r1ob3x7ttTlMtOscQQT2BOq7ULUijrqHRdISj9P59fCWzo/z2CDcvXdKxtp8Yfb2RKvsT4YLUKk5G09TSem/0mnZ26hM1/sYku8xvpgnOcAdcm0FCKA7RhnZnyV2044VXYhdylZFaEUmSRTAd3E9WZo8HgkWHSk4LU315dRMUlGBGn7JLcvNY4U4MUfeU0jOViflpCmWvwx0JR+ns6PukRyC5FWOr48pV9ubeIp/WqKUSAtQjhQfFD8UV4VG6+xXq9i5Ot5Li3zYcS4cOGr3HbCqbILuYvIUTFFAvPEI/la0dqomKSQB2kHWOMo0OKPPKUfQdWKcUURERSdmqqZ0g/Fp0GbqrT3+9W0/Kdl1O/y/tTkqm4UFaP9M9Sb0t+wnWd17EBahHCXGYo+apG5cD+rgWS0Kw19FY0cJxAIBN4QliILAwUIbUCual+bLfXEAAVSIymsjWwNqnGE4o81EtytMrAgYb1WrSMET6dOepIVZZOrRHiN9diuldLP0/lLn7qL+qyay5be0vkDTekPpEUIQAyRVt80UJJVwMYZDarOe/P/Y7s/PRYFAoFACaEUmQBU/qxevXpIKoAGEpNkdOFIn+Q2qMaRv8UfeTPaGddEUUaS+3q8xnpsV4On88v7r/F0fi3FKJCU/kBbhCCoWg96xvl6niN4Gmn3WmC72YOsQ/n7NhtOlV3IHUFWRWSfWSz7zCj8cYEhdujGmWu9vvfc8d01G9n6TXn2GSnXONLIPjOiztGQr4ewtP6IUpdHSj9FRjKLExQsuQsO6fx7Bw5Sb0h7wfXWZMmvipamo7vOsqBqb4x8qAPVbu6u3CBWaOZ947y2CLnjzQ8V0/Pz92WyoGpvVBvfllXJDgaiTpFAIAjV/VvEFJmAkpIS2rx5M6v3FOWlonI4Y5KMCtIGsCat3XeK1m/bQ51bN6Xujat7d/8FWuPIgDpHADWNtteXH6uLTqjUOcpd/5e6QsR2dbHtGCdP5wdIu0eAtreUfoxTaxGCLDN/WoQg7T4qOVbThYbGshgXrPMcdYhQHR9ZZgiqRgwRXGZmtxCF8/dtFpwqu5C7nWXnWyhFJqC4uJgWLlxIrVu3DumJxGOS9GJEkLailWrtOv2B2lBcWgzzvcaRVp2jc8fL1mtYmk7l6kvJVxoXSDq/NKVfqaGsnpR+1CHqevV9tH7BbCotuVjKOzIqiTqPuFWzThGCpysPb8yyzNSoPLyRriDrQM5zKEANGzYkKxKu37cZcKrsQu7Wlp1vazxqCUxBoEHahgVqQwFq2Ieo7bVlSz0KURjrHAWazu+e0h/rc0o/0vX/tyyOYpLGUUzF6ygm8YqyZdI4tt5bnaP4NtUo5eaWFFnJ/bMjk2PZemwXCAQCOyAsRQKfg7ShvKh0LtMsHOktUBt7YTvceoZX0/alzhEULZU6R+m56W7p/NK0fmxXqnNkRDo/qH5qE/VcO41O51ekgthKFFd4jqpVOE/VBzxBRJ491+Tp/BERkRQVU1d3Or+UIzm76bfDMyk+twLFR1WkvJLzlJeVT5fmjKemVM30hfSs6noTCAShRShFJslUaNy4sSUyNPxtZOtrNW0ttx6UK1/rM4WzzhFP52dNYzHHUsXowpzrSefnzWilodQlERGazWh9SeeXB2nLK2KzsdIN+cTWj3h4kq5WIeE4z80QpG2l37fROFV2IXcEWRWRfebQ7LNA8UcxQfXrf36xyet7v3ZDe1Z7ydDCkQdWEH1ypdfPprE/KFqKOL8e/JWm/TmtPOgaoBI2FCJvaf0rP3uJIl/7iKqcu1gC/2xyFJU+eBv1vulR1f0CyV7bve4EawnijcHjWlGzLmke6wPNXgtX3zStZrIcqzSTFQgEgSGyzywYlLdy5Urq3bs3RUdbw3jna5C2EYHaPB5J7oDi8UiaLU54nSMEVau10sV2HXWOBtTuSxu2fEqnzh2i6pXqUce2t1BUtHYncChTDxfPJrongloejixP599ZN4JcxbNpxsH2qkpVINlraBqrB7VxgVbEBmgDgqrY0gw2ZLQhgDtY8UhwmcFCpAW2I6st2K40K/6+jcKpsgu5e1t2voVj3STpm8uXL2dLOxNIoHbAhSNhxUDaffknyT8ZvsFp3oO2ty+gqNfbUZfvH6Yrlr7KlnjNMts0ahzBugSXW1k6fyStah3JlqUXfoHT/5zOxikRSPYaT+fXQi2d34iK2Eb1TfMVMzWTdcrvWwmnyi7kLiGrIpQiQcgIpJq2L/FI3uocuSq5W5NcsBDpKfzIU/rlAds8pV9FMZLWOFI+9os1jpQIJHuNp/NroZXOH0hFbL190zDOaOzSTFYgEIQWoRQJwhKojcBsKXit5f4yqnDkz6VdqHf+a3RD4VP0YOH9bNk7/1W2Plgp/YHUOJJmr/GgbMWYorQ01ew1pOv361ZCcUXu/cnwGuu10vlrNm/F6hlpge0YZ6a+aaKZrEAg8AdrOv1sBmIaOnTo4Jg0YV5Ne83edFq84k8a3Kcr9WhSQzNQ24jCkdKYpKN08SYeca7Ie0xSACn9gdQ4MiJ7DZlrUS9OoJ4uoszKTcrT+Stn7aOI1S46V1s5cw2c3JdNURX6U2nOQtXjxnaM82gxYmDfNH+byWq50ELVTNZpv28pTpVdyB1JVsW6R24jYmJiaMSIEWzpFKAA9W6WSlPGDWdLb5lrgRaODDgmKYCUfl7jiKfuex57BMtgU6pxxIHSUvu1Vym6hrtVB1lnWK+m1CBz7eTUF5gihUICVTL3UFr6X2wZ4SrLgsN2jFNrMhsV25RiEocTRVSUHXgSW4/tSs1okWWmB73jfMFMzWSd+Pt2uuxC7hiyKkIpMgFFRUW0YMECtnQSvsgdSDySITFJaCeiB4VxvMZR2bG6H5+3GkdS/mweSffeG0WTx0TSayMi2fLeeyLZejV8yVzTykqD4hOXfIdbRey45HFsvXScFKTdl1bARygrmlhfGl82Lhgg3R5p9/ISGngdynR8p/6+nSy7kLuIrIpQikwA0oc3btzIlk7CV7n9jUcyJCbpQko/7C1KsPWVaqum9CPdfkb/GVQjwd3Sk5pQg633VuOIpfQve5hO5Ke7Za+dzD/F1mO7EoH2XZNmr/GK2FGxLdgSr7Wy11xUSuvTfyn7v0wx4q//OrmYjQsWUHwmTJhAY8eOpVGjRrElXvuiEOH8PHDgAG3ZsoUtff2dOvX37WTZhdylZFVETJHAkvFIvhaODDgmKTKKNrZ+gtqtfpBZlaQfV+Zxc9Gm1hOpg4a1Z1BOLg04fJQ2FGbQqagoql5SQh1jiymqda7mMUlT+uVgHaxNSOkfUHeAh7Up0L5rF5vRbrnQi0UiOBSbCPXstcPbt9GBjI1UmJdDHVMGUkL0RYtNbkk2bcxYQkdzd7Nx9dso1zgygkCayZqhIrZAIAgdQikSWA5/CkfymCQUelQp3cgsTloxSfduqEOXFE2gZ2NmUy266GY7QSn0XNEttHlDHVo52KWsoF1I548iF7nlueVfSOfXKAngS0p/l7QuhvddQ8+1Nts+oj2Nr6WCCheDqeMKzlLTfV9T9VO3K/ZeO7rjSNkydzcdy91D1SrUKe+bdjr/SLmSh3HelCL0cGMtS84VMFcdLFNavdqCWREbChLWi4rYAoH9EEqRCYiKiqJ+/fqxpZMIpdyBNrPlMUnHqSstLuhMXSN3Ug3KpHSqTH+WtqBSeKLV+rZ5TeePKEvnbzFMsXhkICn9gWau8UDtGqdOUPVTm92z1zL3srfA9qSBAz3fIzJBIqWLTuUfVj5wyTgl9m1MpxXzdlOF80VUIYIo30WUXzGG+oxupllOwCwVsZ36+3ay7ELuKLIqIqbIBKAcev/+/S1bFt0qchsVkwQFaG1pK1pQ2pMtmUKkMM6vdH4FAk3p9zdzTR6o7ZG9huPWCNSu26qtZ8aanIiksnEaCtHmWduoV2kp9a4YTZ0To9kSr7Ee281eEdupv28nyy7kjiarIpQiE1BYWEhz5sxhSycRDrmh+KyceCnNHd+dNZ7FEq81m8kGGpMUQDq/USn9/mSuBRqoXbt5VapYXV3hAkk1BrNxai6znfN2U5eEKGYhkoLXWL9r3m42zswVsZ36+3ay7ELuQrIqQikyAcjE2bdvn2rqsl0Jl9w8Jumq9rXZ0luQdsB92xL1uXjUxl1M6XdRhOy7Knvt0kzp9zdzzYgWI7061qWYhCsVahxVZOt7dqirGht0bNdZanYhiyVCVs2bv25SWsrGaQGl6eius7R73Qm21KNEGVkR26m/byfLLuR2kVWxro1LIAghgcQk/VnSguq7qlIanXHLWuPgHo1g7YMlLaiHRubayydP0/SUynRSYpquUVJCEzMy2XajM9cCDdRGPFLcJ1OpXXEq7W48ivKic4lcOUQRiRRfHE/N9n5LcQfmkevWSxVjmvIPZFK8hsIKxSgBMUYHMolaVtWIR9pDOZkXi0uixAAy6rTikcxUEVsgEIQOYSkSCILdty2niKYU3cr+LzdS8NdTim5h4xQpLaG8hY/RwJxcWnT4GM06fpKmp59mS7zGemxX6rsWaDNaHqhd9kKmoHgJ1ObxSDVOb6ZefzxLnbd9TW33rmbLXn9MphqnNmkWjozT+bCpNg4K0c/vbXVTiABeY71WPJKZKmILBILQISxFJgnKGz58uCODEa0mtz91kjBmUWlXukclnR8KEbbfphK3VPL3KorPO1FukuqSL2upEUFsO8ZFNepraDNawAKxX3uVZZlJq2PDQgSFSC1QWxpnxIO0vY2TUhqXSXpyWDDOY12pi1mItFj55R5q2K66qvuOV8QOpE4RstiOHDnC+n9hiXpJTlKkrPgbNwIhdzRZFeseuc3SNzt2VA+StStWldvXOkk8HumXLOV0fhdFavZt27d/HzXT8TlsnEwpCjRzjQPFJ2FAf/rfr19Q9vFDlFSzHl0y6AaKjlHvWxZo4cjcCtkUVXye4qOSPGKKeNwGikCWVvCsnstqGsksRHLOny1g4+SNbKXEFVSjKuldKSI3nUojCymyNJYq59dg630t/LhhwwbHFX606m88UITc1sU5jywmz1R4++23HZmh4QS5pX3bXLJ0frz2ViMp3eXZQkPvOJ65poW3zDWAYOyh311BY9P/S/dHzWNLvNYK0ubxSB5uN2k8UlqaauHIilWq0IaMJZptQlAVG+PkSBvUulylVFJ0mEoKd7IlXiuNU3O/5WYWUmxhZaqQX4Mt8dqb+40XfpTHJPHCj9juBJzyG5cj5C4kqyKUIhOAC/ypU6ccmaHhFLkDqZEU1aAXHXNV9YhH4mD9MVcKG+exb2QUXR/bjWWpKWWu4e+62K6azWh59po8Nik9N10zey2QeCRQq1kLysjeSatOfkt5Jdlu22Ahwnpsxzg5vEFtSeEeKsz6kCoXr6WadIAt8RrrpeP8db8pZbLpLfzohH5gTvqNSxFyu8iqCPeZQBDieKRVu0/Qh5/Np3E3XUu9mqV5LQnQtXF1+lfMHTS16EWmAHn2XSN6PWYcPd/Y0w1VUlxMV22cSw3ic+nFalXcMtdSS0rosdNn6ZK/51LJsCkUpRAH4C17DWhlr/kbjwTyN2yiVofTaUP9CDp2aA9Vi697sU1I3mH2+R0Pp7Nxid26uu2LNiDRMX9TSsEu6ljnZve+a8XnmAXqXGwM1Ww6QPGzA3G/+VL40d+ebAKBIDgIpUggCCFQgLo1rEpLo8+wpZ4aSRjTf+Q/6N7PC+kZlb5rI6/7h+J77fxjEbWmDLosj2jg4TzaUCHuYjPa/IILgcx5tA3jeg3zOXuNHYNK3zUOFB+0Aclas4a++XAWXTPuH5Tco4eqhUgagJ2WlUMdD56k7bWq0amIi21CKhQVUatjGWy7cqB2KVUr2Etda4z02IIYpV41RtK6TFhzYK3xPA4tt5q3cUYWfgxHzzeBwMkIpcgExMTE0E033cSWTkLIrX++mXttzN103YJeVPf85vJA7cMV29HT17VVdb/lnT1a/v8opcw1hXFSTuboa6PhbVyRy0XfxufR9qs6UUR8Ht3kcpF6iLZ7ADYUn9SsHDqTWIEKYqIprqiYqubkl9eHUgrUPrLlf9S2Ui/Vwo9wb7RO6sXG1WvXwWN/NbeannGJifoKP3obh5il3+ftpkxpkHdCDeobxJ5vRiN+4+KabjWEUmQCkKLbpEkTchpCbn/LAXTSXQ4gvkptXe+tNu50pj7lQGvcf1d8RZ/ueZ1cUWWp84uyiF7ZXJluafogPdbnOtX9pIUjEfuUkpOvu3Bk9qqdlBxdR/W9oRglRleirFU7iRSUIlhkUOQxJzOfKVClxUfLC09GRtdm+1esUoGNkxNTUIkiS2KZIqNYAh0u0NI4Nk5LIfr+42V0vtJeKq16MWg1uySWvv/4GF1F/XUpRuG2NInfuLOItMG9TARam4CCggJ64YUX2NJJCLkLgt6ipEW3IXSSUjSDtOGCwzglkiMaU7XiUo8gbQ7WVy8uZePUFKJP9j1HpZHutYTwGuuxXY1AArVjC/Td+NXGQXHo3DyXSgr2UEHWB1R0/isqyvmRLfEa6zs1y1VUMPLOF1HFcxduDPKv7cLriucas3FqiszPX62kc5W3lylW0m2RhWz9ovkrvbYrgWI1e9Jq+u6VjbT4w+1sidd6m+j60x5FjviNi2u61RBKkUlwWsoqR8gdXBA8fazHs5rVtI/3eFYxyBo0y9tO/8rIYP9X7rtGNCkjg42TU1hczCxEESo6DVZ9uvt1Nk4NxCOlP/IsnYlPdlufEZ/M1qsFaldrUk/1PfWMQ4uSjC+mU1HOD0QuWeyP6zxbj+0YJwcWGdQxqpTZirm8pMBChPXYruaiO7rrDGVE7Sx7Ide5Lrw+HbmLjVMjkGreRihUAErUsT1ZRFnJbBmMxr1mRlzbrIlwnwkENqfDkLG0ESnua6ZQKpUpOCA9IoUpRNiuRsukXGqdm0cz0k/TtBTP7LWJGWdpUG4elSZ59l77fPOycpeZIhFEruhMNu62ToMUh/y89Tjds7ciRQ1+nIblfE/VCk7T6bhq9GPiVVS8N5be2XpcMZ4qeWhXylr6M0XFVFIt/FhcdI6SVVp5nP9zHW1NgKzoDxdJ1SrUuZj5ln+EXFRKWxOiqOOf6yipR3e3feGiSoh3EeWmUGxBChXFZpXHBMUUJlOEiyghwaXoegN/H/ybSqM0HpIiiEqjCti4ui1TDK/mzRUqOVyhGnpXG6+uO2nPuUrUgn58c6uunnNSGUSAuSAcmFYpWrduHT377LO0evVqKioqorZt29LDDz/Myu77YrqdPn06ffrpp3T48GGqWrUqXXnllfSf//yHatSwRqCiQGAEUHxKBt7EsswQVI0YIrjM0ryU449MSmNLKD4DctWy1y6Ok3Io65iuY1MbV1LqoikLt1OnSt9SRuoa+i2aG7YPUp3idVTtZA+asrACi7OSuxEjY6LpdL0SSj1epgBJFSNeMyejXgk1jFGW/8i2/1F+bDTVTmhGHVMGKqb0H83dzca1lClFEa5SarpnPm2ufS3u7hSVk01RF+KRKCqJKCKSbY9w9VfMfCuNUOmBp3OctJwAyhZ4KGUUoVpOwIj2KIEqVf428TVKqRIKmbMxpVK0dOlSGjJkCFWoUIFuuOEGSkpKoq+//ppGjx7NlJtHHnnE63ugMNpVV11FixYtou7du9OoUaNoz5499MEHH9CSJUto7dq1VF1nG4JQZGjcc889jsw+E3KHDrjIlNLuNanfk6hSLXKdO05R5PLIXoMdJaJSrbJxMlqUaFiJdIxDf7narrm0u9Za9jlSMqIiKKPWWmp2DOPae7RdgUL1QF5FGn52J42Jr0nR8RetMsX5mTQ37wQtrNyYVpa6FOOykOUGhQip+2op/avSv2Pj5KDBbcreZVQ7/xTtT4kkF120okVQAjXKKKWUI9vYOHl9JVC3aSrRGtWvy32cRpmAgrjTZYHaEqsTAsAR7wT3nVI5gUDbo5jNSuWrUmWUQpZ+4DwN63UjW9ZuFhsyhSyc+5cGIDfbv7iYjq9aRTmnsyixWjLV7NWLIsPQQ810SlFxcTGNHz+eRbH//vvv1L59e7b+mWeeoa5du9KkSZPo2muvpfr162u+zyeffMIUohtvvJE+++yz8ifFd999l92In3rqKXrvvffIDODYkpOTFc38dkbIbYH5RkHGodMp4stbyxQgSeRw2WukxU0rGyfj6hqp9P6hYkqPiiKXgqyISYILDuOUOJF1jlmImEIk2x/vh/3PpK5h44hSPBSq41n5dLDaUYqMnEZncxpRYXEKxUZnUHLSfjqYeAsdz6rNxin1savavgN13JKqmdLfIWUgxbev5bEv6iadSE6kfVXzygKr3axUObSvKlFydiLVUmmEW79uHYorLKGCmCjV7DVsxzglcDODQoSAbDk8UBtxTUoxTYHUZwpUqQq3lco4hWw35WRyRfQIJVaOpT46yih47ku69w33/vsCkJvtv+D/aMWifMopwTmBUhUllPjl99RnSAVqPMLHBzm7BVr/9ttvtG/fPhozZky5QgSgNEAhQvAaFB5vzJw5ky2R1SW9qN11113UqFEjpijl5eWRGYBM06ZNc1xgnpDbIvPdagTR9bMpopJ77A6zEF0/u2y7AjGVatETGWc1g7QRk4RxShRlLKTTcJmpKI9QjE5FR7JxclCyYEjknzQq+T36R8M4GtP+JN3WeTtb4jXWYzvGKZESX4+5zNQeVHhKP8bJiUxJYcUmLwyU78gW22ulsHFK5G/YSJ3/hKnIpZK95qLO69awcUrUaJBIOUl7NAO1sR3jjKzPFKhS5YtCZXxrFv/3dVeqtigEt+ez9VpB6oHs67b/Wdn+ZwuCvv++QD97wf/Rz/9XgXKK3WPs8Brrsd3RStGyZcvY8jKFrBK41MDy5cs13yM/P5/++OMPat68uYdFCRezwYMHU05ODq1fv97QYxcIbAsUnwlbicb+QDTqw7LlhC2qChGjfk8aFF2FXk7PoBqyLC1YiLB+UHRVRdcbSIy5GBSuhdK4GokxNDD5M3o0tRqdlKXsw3KF9QOTP2fjlNh7IEvXZyuNy0iIY/FIWo1w82Nj2DglCtPTqc6Ro9Rq418UWeR+o8FrrMd2jFM8piVLqCS6SNnKxD6f2HaMk5PWKIliC7Ng0mLxSIWxmZRfIZ0tWVsXl4viCrPYOCUCUapCaaUycl8AZem3TzZdUFrlX3wk+95+m71JVSHzd9/y/T9Y72GVZOC1i9j2YOxfGuhnFxfT8h/LHkxwfrk1br7wRLD8xzw2zrHuM8T9gKZNm3psS0tLo4oVK5aPUQOWJsQUKb2H9L3xPn369FEN0pbWDeK9jKTr4eJDXAwCwaXNHaOioig6OppZQqSNELEO2+Tr+b7yOkV4byhxcgtSbGws2x+fKyUuLo69l3Q99sf4kpIS5pqUr8c6bOMYJRPeA++lJRPfhqVdZNIzTxzp+1hGpga9L8pUhOMs1p6nodNp0Je3siDtjRViy4O0O+QXshDjomvepNIL7yOXqUqisgVJTtWKtd2OH+/RKXI7PV0t5sJ9Rtn1NrNaNH1XsplcrkEe83SypEDmkFMG4/DZ0nnauPvgxe+AIhQy18q+///tO0q1Wrb2mKe9xXF0PjmRDldwUcLe/1FJYiVyRcdQRHERReWco8MViKonJ1JmfhR1Ky31mKczx4/r+t4wTnrsOL+y1q6lZrvn0V+drqbzlfYpxCM1pjbbvqXcv2pRhU4dPc696g0qUkxBFhXFVlJWCl0uiinMoko1Y9i+0nMvJk5fyj7GSeebn3tZGTm6lSr57+ncGc/sSSXwGdUKEjx+T0d2nqHCfCjCKjtGRFJhXiQd2HKC6rSoWr4a3/vhHad07fv31hPU6JKaHteIIztOU2FJBY39I9j2/ZuPUt1W1T2uEYe3nyrf3+UqVShUGum2v/R3dnib/n2bdKjjcY04tnwF5VEVKinaQ4W5S6kkPuLiuZ7lotiEAZQX25T+/m0p1e7XN6DrnmWVoqysrHJ3mRKVKlUqHxPIe0jHKQG325QpUzzWz5gxgwWAgw4dOtCIESPop59+oo0bL5qy+/XrR/3796cvv/ySKWic4cOHU8eOHVmwNzpHc3hG3VtvveU2eYh9ggxwrUl54okn2LG/8847bj+uJ598kvbv389cgxwEk9977720efNmWrjwopuhcePGdPPNN9PKlSvdLG9GyYS2Jahsiu/Lm0yvvPKK7WTSmidkUXK57SKT1jwd6DyZUtb/l7rkS+r9VKpNW+veQl9/ixiOrcoyuUqoet0SOh0VqR6TVEq04Y98+uX/prnJdDZ9vVv5ADl4vxPR0fTOd6/TAw/19ZCpMmVS04i+FOVKoUiFu00pnmojMmjbmq9ozboUt3n6de1GakTkNXMtJ7KC4jwdrduUDtcuu/lAYYnOzZYIze4+tK12NVq/aRc17tfJY54iMnKJqsaTN5Zs3kW/Hpnmdu4t+/BzaluBxyNFKMYjFVY4Tbu2HaBj6Sc9zr3Es0XUfM882tp6PLtJFsWdu5j5VlCJKYnN93xJrz6+mm589G63c6/a8RMUlz+ICuIqqypUcQVn6ce3n6PTNdM8zr3vFnxPyeRZnVxOhfhIj99Ti9rYz3t7lu8WzKOixec9fk/J5ytQDCn3/pOycM5syqqY7/Z72rZ6JTvjykRUVizAL1/Oo7svmeBxjWiSiVpY3bzuv+y99+lozSiPa0Tt41AO+1NJ4R4qyl3qXpcroiLFJAygqNimtPz9mXQkLdLtGrHnhx+IqCHbV02pwb7L3p9JTd6Z4nGNaHa6iEoK61Ju5AoqaNyIXDEX63pFFBVS8ckVlFBItPKb/XRgzWq/r3t6Qm7KP9clVatMANxmixcvZlYcpXLhtWvXZo0UtRQapPH36tWLXRznzJmjGG905513sh/jQw89pNtSVLduXUpPTy9Xqox6Wsd6aP7y1GG7W4owHkscB47dDjLpmSesh4sX+/D5trpMXuepsIAiDq2h4qyjFF25DsU26UfFpS6vMi3940V6fP889n+pYsRjkmY0uYn6dn3EQ6af171KE3d+RN54vumtNLzHox4ylWz5iqas+pHuP343s+tIFSMoRHj1Vs136ZleV1BU2+vc5mnrigV08LOl1DGlrIWJUjmADRlfUuOxQ6hZtyEe87T411W0bdaLXo+9+diH6IqhAzzmaeHGv2n3d7OoMK6ChnKRR01HjqPhHRq4zdOiOQtoy7Y1lBcfr7pvfG4utW/Xhy4dfbnHuff7u59RzTen0baWvWh76wZUGn3xXI4sjqZW2/6m1jtW0ZF7H6OB99/mdu7tfv0FOvP9TqZQXfji3D4XtNk2k6pe1YKaPfikx7m3ZeartG5Nfa9KVffeR6nFbfe5nXu7Z79Nf6yqx/aFJc9DsaAItm+XHofYvvLf06r/vk47jnTyqpi0rPMX9XrswfLPxfe+bOrLtP1wR69KCfa99KnHPK4RqyZPpx1neysrJnkXFZOWVVZSr8kTPa4R2H/ryVQqylnIzvWShKSL++dms3M9JnE4tUk9yfaX/s6++deTdOxkozKlJrWeh1ITd/IQJZT2oZrV99F101/0uEZ8O/k/9Pep45RfG22GLlR0LZ+vsn8qHD1G9aun0TWTn/L7unf69Gmm/ENv4Pdvy1iKuHVHTemBclKlSpWA30M6Tgn80PCnZ71aKj1OeD3rmek3K4uqVavGJl3pM+XgQqa0HvsrrceJgT85OGnwJydQmbSOna+H3JgLuES5gmB1meQoyQS5s7OzFefbqjJ5naf4BCptOoAyT59mclNkJCGG2ptMQ/s+TdGR0TRt92d0UvK1wEI0sdlNNKj3xZujlOp1exLpUIpqNuijeO6tiyqgHytvoczImXT3yeuoevHFa87p6LP0Xup8Wl1pC42KGkhdJPtBnrZVSiip2iB2UVfLXGtTbTA1SMqnKIX5qJuznbZ5PXKihvl7KDJyIPu/9NhbFO2mI6f/psLaLcqUCQXlIv70QTYuLq652zzFV8mjvIQE9Q+NiKC8xESKrXRe8dxLjc+kI3Vq09ZLcJPDzU+iTEYVsfXJ2bWpVmJ2+bnPj70opoRqnN7MFJ9dja+h7MQzVBqZS5GlCZSUU4Wa7/uWbc+LaepxnuG9StOPUNO9fzKlqrS0mAqj95fvH1vciCIjoqjp3vlU1LiWx++p+MRharr3D9rctD8V5S3zVEzi+1PTvcuotHEtt8/mv6ca8QW0P/8s5UacosK8ZZ4Wk/j+lOCqxsbJj71aXC5F5myk/MKlikoJlJWYogFUvUKe4jUit04ORR7ZSNlxG1WtLck55ym3bY7isefUPk/F+7dSUVJlVcUmInsJ5dRu4HHsRWk5lHfqT8qvjTY/Mjd1dCxbH3H0TyquFa94jThXpYiKo2p5KkTsw9mTEBWn1aTsSoVu+xl13bOEUiSN9+nUyb3R44kTJ5iVCKn5WiC7DF++WuyRVtxSOIDWC9M9TKlqNyc7IuQW860HKD4Duj9CG7Z8SqfOHaLqlepRx7a3UFS0+oWuY1oXSo2pROmFWequt7jKbJwSpyqVpeOvrrSJ1iZtpta5TahqcTKdic6ibQl7qRRlqSXjpBScr0FxCJBVjbOOoDiqSgXnS0lJ/agUU6QrJkk6TkpS5t9Ukp1DFY7u87zJFeMmd5htxzg5VSJlLU1UUBvXrGMqLdhz4bqtGHjrovWdO9KjHT2/t7hOXak44Us6UfU8nai9kUpj+bXwHOUUHqTks+epal4pG6dEbK36VOP0T5SY+RkdbFKTXOU3znMUUXSY6u89zpSq0lo9PPaNqVmPSot+p6Kc87gPKygmP1Bp0QmKqeleqJNTt3t/2vvTq7SzQQUVxWQl1fs7n+qOn+Cxb17zulS05hsqqqKulBSdXUZ5za9R/GzXpd3p/F/fXFBMZNuiY9j6qMObyHWp8v55TRpS4aZjmooNHd3Hxsmp0rYn7Tu1U1OpKUqrTVXatlD87Iq16tCx3NOK2/h7FEdHsnGhwnRKEXyDiOf55ZdfWOFGKag7xMdoER8fzxQnFGg8ePCgWwYantLgnktMTKTOnTsHSQqBQGAkUIC6dBinf3xkFD3Rawo9vOwhpgB5uN4iImhiz8lsnBLVEy/etKEAbUnc43UcZ19RDEJHvR4jxrVVWJ/Wsg3lxf0fNYlqSR1TBinEJP1Ke0u2s3FK5BaX3VRjsjMpOjtT0R0iHSelMF9f7Sy1cYdzK1BBBY14pogIKqiQwMYh7kpK026X0ZT+TSkmyf1hGJTGxNKODp3of02Inu2m3O+uyZjxNO/HxfR3i7oe21zR0Wx9ZHE6jR5zwT0nIXtQZ9r6089l1pI0BcXkxCHaWqeIOg9SvmfsqhdFe+uWKSCen122fm/JbqpVL4rkKt3B2ELKrZKsuS/RPjZOSR2MO1VEuTXraiqiuTXrsHHU0nP/hOJYKk5r5MVa04iN8/js7HimtHhTajBOiZpRdWk3aShFknGOTckfOHAgs/R8/vnntGnTpvL1cC9NnTqVmcFuvfXW8vXHjx+nnTt3erjKEDMEEIQn9TGiYCOCvRBvBOVJIBDYk0H1B9GM/q9QjUT3FiSpiWlsPbar0bFGR0pNSNXKaqe0hDQ2Ts6ZGElgtAZq4zYlxFN+09rUq8bVrHq2ZzXtqym/aR02Ton4xl3cjhOB2jHnzrBlhMo4TkL1hkwJ4G42DxD3WFTAxinxd6a+W4rSuI3pGykmoa1mfSdsxzglNmX8j/a30N4f2zFOzpG9OyinSjXKr9OYKSIeikmdxpRTpTobpyjPzi2UU6uh5mfn1GrAxsmJL4pmFiKtfQtS67JxSsRkxpQpcRolIFwxcWycEqi1xRQbjZO9ODpSsSZXRK7yQ4XecanV9FmA9I6zpVIEPy8i+hF30bdvX6bcoK1Hu3btaPfu3UwxatCgQfl4KD0tW7akb7/91u19xo4dy+oazZ07l3r27MlcU6iEjSyLhg0bsv5nZsIXn6edEHI7i1DPNxSfRaMW0awhs2h6n+ls+fOoRZoKUbmlqesTFxxYsrgg9jqCJnadqGhpSmhUhU5Fn2UB2UpgfXr0GTZOiVO5Z2hUwVVlD+4KMUlYf03BCDZOifRqRZRToZi52XCs1SvUpXqJLdmyrCa5i85XKGbj5ByPPMvcNQy5YnThNdxvGKfEyXNHFNfrGbdj7Xqi6DjNmzu2s3EKsPUxXvaPUd4/Pj9Sn2KSr3zLLDldrEsxwTg5KQn1dO2LcYqbZUqcGmrjYku9Z92pjatRDbFj3lEb16BBQ0p0xXkWKeW4iG3HOMcqRWDAgAEsZRIZZPPmzWPxNqmpqfTFF1/o6nsGEFP0/fff0+TJk1nKJNKfV61aRePGjaM1a9aYpu8ZQBwRlDsnxRMBIbeY71AAxaVLWhe6otEVbKnmMlO2NM2gGgnubQpgQcJ6NcWqY1on+qLeL0x1kitGPHPty3q/snFK1D5blQV2y5UxDtbXKK7KxilxOj+D/mh1huokNKMr695Nl9YcQz1qjGBLvMb6P1udYePkFNaMp8Ki0yweCe42t88tLiqLUyo6zcYpEVUtWpelCePkRObqS4RWGxfI/oEqJqnJyuv1jEuoqu9epDauZiV9n602LpHKSsx4I1FhXKBKTXzjKtQzplX5WPm+oGdMazbOsTFFHMQEoRaBNz7++GP2p3bTffbZZ9mfmYFVDC49HiDuFITcYr7NDhSfAXUH0Ib0DXQq9xRVT6jOXGZaihW2DR4ykp5fMJPuUshcez91Pl07ZKzqezSObkCZpF2glo9TAsdYJ6E59Uq92uNGw9xvqVfT0oTTbJycGhVTmUJ1y86W1L6gJ51zlVIeFVA8xVGlwkjaVJJHn7baTVdUVO5X16B1O9rxzVKiGs1UM99cZ/6mBq09G+02rdOC9u9f5VVujFNb7+/+idX0NXtVG9egRUv6/U/vHRIwTk6FHH1Kutq42ok1mOKRQwWqvfISKY6NU6Jeg/qUuNL7/vUa1FdVahYXoa6YLE5bh1ITERlBHUf2otLPi2ltzO6yY7gAPrN7UTPqeF1PNi5UOOcObPIsLBS0Uqt8bFeE3GK+rYA/liYoU9eOGEuPX/IGPV7vFZpWaxZbPnHJW2y9lvsuupK+J3e1cR2qdaD70kez/yuWBCCie9NHs3FyoPC1qdKVKU6JUZWoVmkValyaxpZ4jfVtq3RTjKUCndI60+7mGVT7VC4luNxdpQmuOLZ+b/MzbJycLn37U0RJkbaVqbiIjVMC66NLFPrFle9PFFPiUtw/KUm7do23cfXrNaAE8mIxoTg2Tk7thOq6rC0Yp3YeQHngY+X7AmxXO18CsdZEXFBqBha1ZfJJwWus7zhSW6mJb1ONOo/pR2PiBtAVhR1pQGFrthwTdylbj+2hxLSWIoFAILAy3Mq09shamvXlLLpv5CPUvU53r0pVXMNkikqOpeKsAkUXGmKCopMrsHFKFB88T1WL1GuwoRBlSlEyGxfd2L0JZyRF0t0nr1dVqOD+uyv9OjZOCcj2QLsnqPaJaCotcNHJqKxyS1NqSTJFVoqgtu0uV/wOoqNjqG+jTrT87/+pWB0iqG/jTmyc8mdHU9+oS+g31xZVq0WfqEvYODn16tZj7qEcV766tSSiAhunRNHBbOpR2IyWxKh/dvfCZmxclOw750qN5r4aSg3OgyZJdYiySdXa0iSprur5Eqi1Jv6CUtNoQW06ej69fL5rV0ylqtc11qXUYEytVimUciCLSrMLKTIplh1vKC1EHKEUCQQCQZDAzb9zamf6NedXttRjZcKNoPLwxpQxRznTCYpS5eGNVG8YuKnoQWlcwYEsismJ0FSoUKII4yrIbu7AVeqi+msTqZgKKCoiklmYJAfOFLr6ayuSq5/L4/ixb4sTtSm6yKV+cz9Rh41Tkh3H1Ci/BkVEtlXdv2FpDcVjh7LSvbCpF6WmqaJSw79LvDcsI1qfrfSdG6HU4HxpOKeQ6hdUpxORmeWKSVppZTZnWueLEYpN/AWlptLu0/TdZ1/TyJtGUcVm1XxSajBW6ZwKNUIpMgF4AkPgt/zJzO4IucV8OwF/znPcZFJubkmZC/dRSdbFG2lUchy7wWndpPCUrQelcYEoVAAKB45XK0i8JKtAUTHh+zakGqo3d7V9pccE5UNtf7VjD0SpkX6X3j5b6Ts3Sqnh50utrCo+nS9GWWsiIiMorlEyZdcsZctwWHmMQChFJklTRqkApyHkdhZivn0DN6kKrVKYEuDLTYq736TKlBzcLJUsD4EoVIEqVdJ1UATcrEw6PkN6TFr7Kx17IEqN/DtX+2y179xIpcaf88VIa02sDe5lItDaBKDB34YNG9waFDoBIbeYbycQyHnOb1IJ7WuwpZ4bHLc8aKFmeeA3dy20bu6BKFWBKmSBHLt0X67U8ABzrhBpyR3Idy5VatImdqVq49tS1Ruas2XaxC4+BRr7c74YSYkN7mVCKTIB6Hi8cOFCt87HTkDILebbCYTjPOeWB7mSgBs71qvdaAO9uRulmPi6b6DHbpRS4893bialJlDscE0X7jOBQCCwIf66UwKJZ/IWJK5HMfFnXyOOPZB95d/5+QACjgXhRShFAoFAYFP8jREJJD7FLIqJv8duRFxObMNKtD/6JFsKhchaCKXIBCArpXHjxo7MPhNyOwcx39b6fQcSdMuVi5w9GbR68e/Uc3BfSmyaElLFxN9jNyI1XJzrEWRVIlzSFvICVc6dO0fJycmUlZVFlSrpq34qEAgEAoHAOvdvEWhtAhCUtmzZMksHp/mDkFvMtxNw6nnuZNmF3MVkVYRSZAKQvrh8+XJLpzH6g5BbzLcTcOp57mTZhdwlZFWEUiQQCAQCgUAglCKBQCAQCASCMoSlyARERkZShw4d2NJJCLnFfDsBp57nTpZdyB1JVkVkn+lEZJ8JBAKBQGA9RPaZxSgqKqIFCxawpZMQcov5dgJOPc+dLLuQu4isinVtXDaitLSUNm7cyJZOQsgt5tsJOPU8d7LsQu5SsipCKRIIBAKBQCAQbT70wwt/wzdpNAUFBZSfn8/eOy4uzjEnppBbzLcTcOp57mTZhdznTDXf/L6tp4GHCLTWyZEjR6hu3bqBzYxAIBAIBIKwcPjwYapTp47mGKEU+eAjPnbsGCUlJRneuBVaLBQuTJiT+qoJucV8OwGnnudOll3IfdhU8w0LUXZ2NtWqVctreYjokB2VxcEX6U3DDBScRGY6kUKFkNtZiPl2HmLOnUUlE97L0BBWDyLQWiAQCAQCgUAoRQKBQCAQCARlCEuRCUCU/rPPPmuqaP1QIOQW8+0EnHqeO1l2IXccWRURaC0QCAQCgUAgLEUCgUAgEAgEZQj3mUAgEAgEAoFQigQCgUAgEAjKEJYigUAgEAgEAqEUBY9169bRFVdcQZUrV6bExETq3r07ffnllz73z3nuueeoadOmVKFCBVaN884776T09HSyo9yoOvrTTz/RPffcQ5dccgkrtpWQkEDt2rWjqVOnsh5Kdp5vKWfPnqXatWuz6ulDhw4lu8uNc/qhhx4qP9dTUlKoR48e9M4775Bd5UaF/H/+85/UqlUr9h6pqanUu3dv+vTTT6mkpITMxpw5c+iuu+6izp07s+wqnJsff/yxX90B3njjDWrbti3Fx8dT9erV6cYbb6T9+/eTGTFC7pUrV9IjjzxCnTp1Yuc2zvEWLVrQxIkTKTMzk8zKHIPmXEphYSG1b9+evRe+A9PhEhjOb7/95oqJiXElJSW5xo8f73r44Ydd9evXRyc610svvaTrPUpKSlxDhgxh+3Tv3t01ceJE1zXXXOOKiIhwNWrUyJWenm47ufPy8tjYuLg4Jvujjz7quv/++11NmzZl67t06eLKyclx2XG+5YwZM8aVmJjI3gPfhRkxSu6NGze6qlev7oqOjnZdddVVrieeeILN+8CBA12XX365y45y79u3z1WtWjX2ex46dKjr8ccfd919992utLQ09j633Xaby2xwGXHc/P8fffSRz+9zxx13sH1bt27N5L755ptdsbGxrqpVq7p2797tsqPcqamprqioKFe/fv1cEyZMcD300EOuDh06sPfC9fzEiRMuM1LfoDmXMmnSpPJrW/PmzV1mQyhFBlNUVORq3Lgxu7HjYs/JzMx0NWvWjP34//77b6/vM2vWLHbS3Hjjja7S0tLy9e+88w5bf+edd7rsJndhYaHrP//5j+vMmTMe64cPH87kfvHFF112nG8p8+fPZ7K++eabplWKjJI7KyvLVa9ePaYUbd68WfFz7Cj3Pffcw+b21VdfdVt/9uxZ9n1gm6/nTbBZvHhx+TG98MILft0goVBiv759+7oKCgrK1//4449s/WWXXeYyG0bIPW3aNNfRo0fd1uG6zs+De++912VGFhsgu5Q//viDKYf82iaUIgewaNEiNtm33367x7aPP/6YbZsyZYrX9+nRo4fihRE/JDxZQNPOzc112U1uNVavXs3eY9iwYS4zYbTcsABCQbjllltcBw4cMK1SZJTc/EL74YcfuqyAUXJzK7CSZQRWQmxbv369y6z4e4PEQx72W758uce2/v37s20HDx50mRUjFAMpx44dK7eamZ0XApQdnoAWLVowaxnuY2ZVikSgtcEsW7aMLS+77DKPbUOGDGHL5cuXa74HYmf++OMPat68OdWvX99tG/ywgwcPppycHFq/fj3ZSW4tYmJi2DI62lw9jI2W++6776aoqCh67bXXyMwYJfe8efPYOT1q1CjatWsXizV58cUXacGCBSz2wGwYJXebNm3Y8scff3Rbj/iSVatWUVpaGos1shv4/hA/1atXr6BcJ6yGWa9rwWDSpEl06NAh+vDDD9lv3qzYfyZCzJ49e9gSAaNycKGrWLFi+Rg19u3bx4IRld5D+t54nz59+pBd5NZi1qxZqjcju8iNoMZvvvmGvvvuO6pSpQplZWWRWTFCbig9W7ZsYYG2UIbQDgLnPadRo0bsu0BArt3m+7HHHqOFCxey4PKff/6ZJRacO3eOyYvkgm+//ZYFIdsJPMgdP36cKYRQ/LWua07BrNc1o/n999/Zg96MGTOocePGZGaEpchg+I0MmVNKVKpUyevNTs97SMfZRW41kJH23nvvUcuWLWncuHFkJoySG5lIDz74IMvCueqqq8jsGCH3mTNnWJZVRkYGy7KEhejkyZN05MgRevrpp+nAgQM0fPhwU2UdGjXfyDRbs2YNyyyEUgTZ3333XbbvrbfeyjIu7YYVr2vBZNOmTTRlyhSqUaMGPf7442RXcnJy6Pbbb2fZpA888ACZHaEUCUwNUp9Hjx7NLqRfffWVbRtL3nHHHcyU/vrrr5NT4FYhKEb33nsvS1nGDQKlCKAkXXfddXTw4EGaP38+2Y29e/cyF9KpU6doxYoVlJ2dTYcPH6ZnnnmG/v3vf9PAgQNNmZYvMAaUHxg2bBib4y+++IKqVatm26/20UcfZQ99sIpFRppf5TD/EVoM/hSk9rQDE7nak5Iv7yEdZxe55SBmCmZl/JAWLVpErVu3JrNhhNyffPIJs4a99dZblrk4GnmegxEjRnhs5+vMFDtn1Hl+2223MYUPLjTUJoLbrU6dOvTEE0+wp2lYkXCztBNWvK4FA1hABwwYQKdPn2YKP/5vV5YtW8YsoFD0mzVrRlZAKEUGo+UXP3HiBJ0/f141VkgaSwFFQM23rhXXYGW5peBGiIByWBOgEHXp0oXMiBFyb9y4kS1hGUEAIv9r2LAhWw/58RoFz+wkNwJuYRUCKIIoh6/Ly8sjO8kNqxCCqeEORhySHH6T5OeFXcB816xZkykFSlYwM17XgmEh6t+/P4utQrHPK6+8kuzuIuQxdNJrGw+0RnIF/q/0+w8XQikymH79+rHlL7/84rENNzfpGDUQYNm1a1d2wuBpUgpqSy1evJhdYFBl1E5yyxUiXDgRb9GtWzcyK0bIDV87YqXkf3AbAlgQ8Pqaa64hu833pZdeypbbt2/32MbXNWjQgOwkN8+qg6VACbjUgB1dxfhuEGMCpVDt++vbty/ZVSGCwguFCFmXVogdDBQE1Std23hsKKyC+D/i6ExDuGsC2A0Ud0MdIa3ibqg/I61TsWPHDrbd6sUbjZAbtVkqV67sqlixomvlypUus2OU3EqYuU6RUXKvWrWqvE4LChdyjh8/7qpdu7YrMjLStWvXLpfd5EZ9Fsg9c+ZMt/X4DlDLBdtQOM+qNWtOnTrF5MbS6sUbjZB7//79rCgnqrZ//fXXLivygp+yq2HWOkVCKQpzG4CxY8cqnmhKbT5GjRrF2gI0bNjQ8m0+lOTOyMhwValSha1H64Nnn33W4++VV15x2XG+raYUGSk39sO2unXrssq+eK8aNWqwdVOnTnXZUW4oAbhBYhvamaClzbhx41jhTqzDb91sQIGDPPjr2LEjO85evXqVr5MqePitYjuW3tp8oFApb/NhJgXYSLn5+YFrudJ1Tel7stOcKyGUIoeBcua4sVeqVMkVHx/v6tq1q+uLL77wGKd1s8jPz3dNnjyZtRXARQN9kXBBMWufnEDl5kqA1h8uLnadb6spRUbKjfWdO3d2JSQksGrtvXv3dn3zzTcuO8v9559/uq677jpXzZo1mYIE6yj6+73xxhuu4uJil9ngsqj9YbueGyQe+F577TWmFMHilpKS4ho9erRr7969LjNihNzermtmddqMNWjOraQUReCfcLvwBAKBQCAQCMKNCLQWCAQCgUAgEEqRQCAQCAQCQRnCUiQQCAQCgUAglCKBQCAQCASCMoSlSCAQCAQCgUAoRQKBQCAQCARlCEuRQCAQCAQCgVCKBAKBQCAQCMoQliKBQCAQCAQCoRQJBAIzMnnyZIqIiKBly/6/vXsPrfGPAzj+Gcf9NpcRkwiR2FzmLpdc0qJRiJJbKNdZaWpEck1oUi6F8odLlFxKjbEfEaK0MpfI5NbKZovmMrPn1+ezntPOzvE7Z3Z2Zn7vV52ec77f53yf57Ran76fz/f7/CN1xZo1a6Rdu3by+fPnKn83MzPTfu/ly5dr5N4AhIaZIgARp8GOBgEa/PwNnj9/LgcOHJC1a9dKixYtqvz9CRMmyKhRoyQ1NVV+/vxZI/cIIDiCIgB/nJUrV8qTJ09kyJAhUhds2bJFGjRoICtWrPjtMTQgysnJkdOnT4f13gCEjqAIwB9H01C9e/eWpk2byp+uoKBAzpw5I9OnT/+tWSLX5MmT7XcfOnQorPcHIHQERQAiSlNm48aNs/ebN2+2NJr7evXq1S9rirRP2xYsWGCzSFOmTJHo6Ghp3bq1zJkzR/Lz8+28O3fuyPjx46Vly5bWt3jxYikuLg54Lzdv3pSpU6daMNKoUSPp2bOnbNiwQb58+RLy7zl16pR8//5dZs6c6df37ds32bNnj8THx0urVq2kWbNm0rVrV5k1a5ZkZ2f7nKszTdOmTZNbt27JixcvQr4+gPDxhHEsAAhq7NixFuAcP35cxowZY59dGuQEk5ubKyNGjJCEhAQLeB48eGAppzdv3sjOnTtl0qRJMnHiRFm6dKkFVUePHpWysjI5duyYzzgHDx60dJdeUwOj9u3b21jbtm2TrKwsezVs2DDo/Vy7ds2Ow4YN8+ubP3++zSLFxcXJwoULLfDS+9Sx79+/b8FSRcOHD5cjR47I9evXpUePHkGvDSDMHACIsKysLEf//WzatClgv7Zrv57nys3NtTZ9paene9vLysqcxMREa4+OjnbOnz/v7SspKXHi4uIcj8fj5OXledtzcnKsLT4+3snPz/e59o4dO2ys3bt3h/RbYmJinNjYWL/2oqIiJyoqyhk0aJBTWlrq06efCwsL/b6TnZ1t1543b15I1wYQXqTPANQp3bt3l9WrV3s/a0pt9uzZ9n7AgAGSlJTkk5KaMWOGlJaWyuPHj73thw8ftrb9+/dL27Zt/QqeY2JiLC0WTElJiXz48EE6dOjg16f35TiONG7cWOrV8/1XW79+/YCzYu44b9++DXptAOFH+gxAnaKpKA04KurYsaMd+/fv73e+2/f+/Xtv2927d+2YkZHhTX9VpMHU06dPQyqyVoECHK1pSkxMtL2HBg4caDVHmiocPHiwjR9ImzZt7OjWRwGILIIiAHWKBhuVeTyeoH0/fvzwtn38+NGOWj9UHU2aNPEWVAdy9uxZ2b59u5w8eVLWr1/vvUetL9L2yqvrvn79ase6sOoO+BuRPgPwv+MGT58+fbIU169ewegMkc76uEFWZRrcbN26VV6+fGkvLfru1auX7Nu3T1JSUvzOd8fR9B2AyCMoAhBxWlOjamv35qFDh/qk0aqjb9++tiJO64v+S7du3WTRokVy48YNad68uVy8eNHvnGfPntmxX79+1b4vAFVHUAQg4tzaGV2eXhuWL19uabVVq1bJ69ev/fqLiork4cOHIY2l2wroPkWV9x3SAuxHjx75nV9YWGjnawF2Zffu3fOOCSDyqCkCEHG6W3WnTp1sfyHdu6dz585WPK1Bim5yWNN0dkefVbZs2TJLZ2lBtK5q04e5appLZ3N0k8hQdpfWnazT09Pl6tWrVkTtevfuna2G072ItDg8NjbWCrMvXLhg9U36nLTKdAzdcHL06NFh/80AgiMoAlAr6bNz587JunXrbOm7+2T5uXPnRiQoUkuWLLHVanv37rWdrS9dumTX7tKli9X76MaLodAApk+fPnLixAlJS0vztuvO1bozt27EmJmZaQGR7pytK9GSk5PtsR4V6YaWt2/ftr5As0gAal6UblYUgesAwF9LC6h1d219RMfIkSN/awx9vMiuXbvsESY6awUg8giKAKCatGBc02SaErxy5UqVv691RjqzpCk7XZkGoHZQaA0AYUgH6rPVdJbITQVWha5e05Tdxo0b+VsAtYiZIgAAAGaKAAAAypE+AwAAICgCAAAox0wRAAAAQREAAEA5ZooAAAAIigAAAMoxUwQAAEBQBAAAIOZfnzI7x/qv1DAAAAAASUVORK5CYII=" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - } - ], - "execution_count": 10 + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Analyze model", - "id": "28898a88c513d7e0" - }, - { + "id": "28898a88c513d7e0", "metadata": {}, - "cell_type": "markdown", - "source": "Below is the self-evaluation of the performance of the model and the controller connected as described in the paper on the training, validation, and test sets. The framework automatically computes relevant metrics such as MSE, FVU, and AIC (the latter being particularly useful when comparing this model with alternative controllers). Performance evaluation is conducted over a temporal window of 200 samples, corresponding to 10 seconds. The plot is also generated automatically and displays consecutive 10-second time series segments. Since the errors were computed for both curvature and heading, they are reported separately below.", - "id": "c7bc09da5e69f27d" + "source": [ + "### Analyze model" + ] }, { + "cell_type": "code", + "execution_count": 15, + "id": "eba66fd4f5ce72f7", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T20:40:06.269548Z", "start_time": "2025-12-09T20:36:41.440312Z" } }, - "cell_type": "code", - "source": [ - "lat_dyna_control.analyzeModel('training_set',prediction_samples=200) # 10s prediction\n", - "lat_dyna_control.analyzeModel('validation_set',prediction_samples=200)\n", - "lat_dyna_control.analyzeModel('test_set',prediction_samples=200)" - ], - "id": "eba66fd4f5ce72f7", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m================== nnodely Model Results for training_set =================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 1.140e-06 |\u001B[0m\u001B[32m 4.404e-03 |\u001B[0m\u001B[32m 2.391e+06 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 5.398e-04 |\u001B[0m\u001B[32m 5.965e-04 |\u001B[0m\u001B[32m 2.393e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 2.705e-04 |\u001B[0m\u001B[32m 2.500e-03 |\u001B[0m\u001B[32m 2.392e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo8AAAHaCAYAAABhO6OiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYE1XXx/8z6cn2AkvvTaUq2BEUu2IXrNgVe++94mv5XvVVFHvvDVFURBBBpPfeO2wv6WXme86dTDa7m2RTJptkd37Ps2RJsjN3ztx759xzT+FEURShoqKioqKioqKiEgV8NF9SUVFRUVFRUVFRUZVHFRUVFRUVFRWVmFAtjyoqKioqKioqKlGjKo8qKioqKioqKipRoyqPKioqKioqKioqUaMqjyoqKioqKioqKlGjKo8qKioqKioqKipRoyqPKioqKioqKioqUaMqjyoqKioqKioqKslTHmfPng2O49jP448/jrbOBx98EJAH/R4K+fNRo0a1ePtUVDKRtjTPRDOHqKgoDT2P5H7XEnTv3p2di15VMh9tqhugoqLS+qmursZ///tf9vuQIUNw9tlnp7pJbZLt27cHFFRSHtrqgpb6IvXJvLw83H777YocU+3jKukOjX2aA4hEF+Wq8qiiopJ06MH6xBNPsN8nTJigKo8pgh4c8n0g2rLyuGPHDnTr1k1R5VHt4yrprjz+9ddf7HdVecwARFFMdRNUVFRUVFQauIa0JLLFS6V1oAbMqKioqKioqKioRI2qPKqoqKioqKioqLSs8rh37148+OCDOPjgg5GVlYWcnBwMHToUTz75JOrq6qI+zpw5c3DddddhwIABzJHZaDSiS5cuOO+88/Dtt982u/3r9XoxY8YM3HvvvTjuuOPQoUMH6PV6WCwWFuF1wQUX4JtvvoEgCFG36YsvvsDJJ5+Mdu3asfb06NEDl19+ORYsWBD1MZqLtr7iiisC35FN+7NmzcKFF16Irl27wmAwsPOfdtpp+PHHH6M+708//YSxY8cyOVDb6Vjnn38+Zs6c2eIRrVu2bMH999+P4cOHo7i4mN2X9u3b4/jjj8crr7wCu90eU6Sey+XC66+/zmRK16fRaBpE8TWOJKR7/tFHH+GUU05B586dodPpQkYZ+nw+fPjhh0xu9D2SW35+PgYNGoQ777wTGzdujNjOUDLdtGkT7rrrLjY+qF8nKm+Hw4H//e9/OPHEEwN9vLCwkMn24YcfZuMx1uheuq5bbrkFffv2hdlsZu088sgj2b1xu91xt5X6M52Hxo0MyVc+f/BPc9to6TLPxIoSc0iic5vcL0ePHh14j/zzQt2HxtuLJFu6huuvv571sYKCAjZ+SHYHHXQQrr32WixcuDCq69i/fz8779FHH42ioiJ2nNzcXPTq1Yv1txtvvBG//PJLs3P08uXLcdttt2Hw4MGsPTRHduzYEaeffjree+89Jq9I8wj5OxL0GkoGsYzPePt4vHPF7t278cYbb2D8+PFM/tnZ2UyOJM/DDz8cDzzwAHbt2pVwtLXS80Rz0dZ0nY3ltGTJElx55ZXo2bMnGzs0z1EfpvZE+xyfO3cuLrroosB83qlTJ/YspbEefP/oh57FyaC2thYvvfQSazs992js0n0jWdCYuvrqq/H11183K8N4n6PyvZb9HYlQ/TOm6xdjZNasWTSzsp/HHntM/O2338SCgoLAe41/+vbtK+7evTviMauqqsQzzjgj7DHkn5EjR4plZWVhjzN69Ohmj0E/Rx11lLh///6IbbLb7eLpp58e9hgajUZ84YUXxPfffz/wHv0eCvnz4447LuTnEyZMCHxn69at4i233BKx/TfddFPEtns8HvGSSy6JeIy77rqryb1MBj6fT3zggQdErVYbsT2dO3cWFy9eHPY43bp1Y9+j123btomHHHJIk2PQZzIka/n9yspK1ndCnTeYzZs3iwcffHDEdtJ1PPXUU2Hb2VimH3/8sWgymZocJ155L1y4UOzSpUvENprNZvHdd98Ne4zGffajjz4K2Ub558gjjxRramriai/dq2jGJP2Q7DJhnokWJeeQROe2YHk290P3TMblcolGozGqv7v++uvZ3BOOX375RczOzo7qWOHk73Q6xauuukrkOC7i39M43rJlS9h5pLmfWManUn08mrmC/qa5a6cfvV4vvvPOOxHbHTxHtsQ8ETyHh4KuM1hOkyZNYmMk3PnOPvvsiP2NuOeeeyLKa/z48eKmTZsC/6dnsdIsXrxYLCkpiap/LFq0KCnP0eB7HeknlutPKNqaVn8vvvgiPB4P01iPOeYYpk1v2LCBrYxolUkrFVo5/P7772E1clqFrl27lv2/T58+bBVNVgHSqrdu3YrPP/8cK1euZBaDMWPG4N9//2UriMaQ1k0rcdKyDz30ULYSpPbYbDasW7eOafakuf/zzz8455xz2PG02tAioJXKzz//zH43mUy46qqr2KqOoPO///77uOeee9hxlIQsR5999hlbkVx22WVMDiRfshZ+8sknbLVFFrejjjoKF198cchj3HDDDfj000/Z73R9l156KbNW0Oqc5Pjuu++yVVA0q9NEochaajdBFoJx48axe0NWo9LSUibj6dOns9U0rcoWL17MVrXhIIvjueeei9WrV+OII45gllRaUVZWVmLNmjUh/+aSSy5h95pW83RfycpB1pTgVRhZtagfHjhwgP2fojCpT/fv3x9WqxW//fYbW6mSReORRx5h7XjqqaciXjv1s2eeeYat6EgOxx57LOufmzdvZlbgWKF7RzKi/kyQ1YH6CPVzuv4ffviBjTMaB7SSpXULvUbi119/ZRYrsiLcdNNNbEVL/YTG9ptvvomamhrMnz8fd999N6ZMmRJzm8na9v3337N7TZYrgq7h1ltvbfLdQw45JCPmmWhRcg5JdG4j2dJ9oHFD/ZegsUjWq1D3TIbmG6fTyawbJ5xwArP0kYWPrqeqqoqN16+++or9/tZbb7Fx/Z///KfJMWl80U4KjSWC5iOyEpaUlLD+Vl5eztpG81w46z6NPdo5kK1S1A5qP+0KUP+lOeS7775jliaaC0aOHIlly5YxC40M9WGSJVmey8rK2Geh+jWN+5bs49HOFXQvaFz369ePnYPmALI40r2mcUD3neYBsmCRRZju2xlnnIFESfY80Zi3336bPQfp/tCYp3vM8zyT0zvvvMPmX7pO6mu0GxGKp59+Gi+88AL7neRKzw3qP7RrQX2MLNRkUY9lJzJW7HY7yyxB94agsUvjk6yfdH9p3ND4pZ3GFStWJO05SrKgMUb6hfycpD7bmJieS7Fq0Y1XsB07dhRXr17d5Hv79u1jWrD8vSVLloQ8Hmn+8ncef/xx0ev1htS6yVImf++hhx4KeawZM2aINpstbNtplUJWO/k4tNILxWeffRb4Dq0Y1q1b1+Q7a9euFdu3b99AFkpYHuln3LhxbIXdGGqv/J2BAweGPNaff/4Z+E5OTo7477//NvkOreoHDx4c90o7Wt58883A8c8880xm+QnFt99+G1hRHX300SG/09hiQKvSSDReadF9D9W3ZE477bTAd+n3UP2ILCcGg4F9h+d5cf78+c2Oj3bt2okrVqwQE4XGQLC19Zprrgm56iZrg7zSJgtksBUplEVBttKEstpRv8/KymLf0el0zVrro7XORLO6Ted5JhqUnkOUmtti3W0gOVG/J9mEo7y8nFmd6JhkKdq+fXuT75CFVT7vq6++GvGcNGc5HI4m799///2BY1x77bUhv0O88sorge/RDkw8VrBU9PFo5gqS7fLlyyN+Z9myZexYdMw+ffqIgiAkbHlUYp6IxfIoPy+rq6ubfG/27NkBi2RRURGzjjdmw4YNrC1ym3788ccm36HxdOKJJ8ZteYuGr7/+OnDsO++8M+J316xZI5aWlib1OdrcPY+FhJVHUlbCMXny5MD3nn766Saf00CRP7/66qubPTcJhL6bm5sbUrmKBppku3fvzo4zZsyYkN8ZOnRooF3Tpk0Leyz6TGnlkbbfIl3b4YcfHvhuqIFMnUv+/K233gp7HBrwwSZwpZVHuoYOHTqwYw8YMCDkAA/mwQcfDLQllMIbrDyeddZZzZ4/eJAMGzYs4sNv5cqVge9SmyNtvZDSGrxt0tz4+P7770UlmDp1auCYgwYNiqgI33DDDYHv3n777REfCtQHaKINx3333Rf47ieffJKyB2umzTNKzyFKzW3JclUJ3voLdQ9oS1v+PJISHI4DBw4Ets/DXVswF198cUCZDTVPpqPyqNRcIS8i5ePOnTs3YeVRiXkiFuWRXFRoURIOMrBEur5g1y/a7g0HGVLy8vKSpjw+99xzgWOTcpjq56iSymNCATNUKSLYAbsx5NAvQ1sSjSGnYhlyBG8OcjInyEQei7N5MGTep+1Ogpy8GzvHk/MsbXUQtDVAWyvhoM9o20tJyGGctgPikSltadD2AkGOzJGcX2lb5tRTT0WyoO3Dffv2sd8pCS9tDUaCzPIytEUciVDbQZGgbRba8ggHbXUFb/nTVkA4br75ZrZdSJBjP8k8HLT1fdZZZ8XU1mjaSA71FCAUDnKolp3gg/8uFLSlFclNoLkx3BJk2jyTqjmkubktmfTu3ZttQctb8o2hLToZCoKIlS+//DIw1mirvznk+YQC4OQAwXRGybmCINcOmVD3I1Zaep6gMUjBMfGej7a0CZr3Iz0vaMufXH+ShSXBfp/M52iiJOTzSFFWkSBfNBna228M+WcQ5FdEvkiyP1I49uzZE/idvks+LaF8DGiioUjjVatWMR828rMJNZGSHxT9ULSfTHDUIPn4NAd9h3wWlCIRmZLPBPmFEeTf1VxHowcyySkZyPeWIP9CeTCHQ243EakfkNJE/p6xQP5DkQhWEE466aRmJwOamMm/hPyKSEkId8/oHihVNzaWNtKDiBYH1C937tzJJh+Kzk3GGG4J0nGeiUSy5pBE57ZEIJ/Fjz/+mCliJBOSc7jITvK7agz12Zdffpn9Tr5n9913H/M5pb4a63xC193cfNL4HqY7sc4V5GtIPnDkZ0gR2nSvyQ8w2vsRKy09TyRyPuofsj8/LczkRU2k5+Brr72GZDBmzBh2X2mMTpw4kfmwki90tD61yXqOplx5JK09EsEWtFAWGjklBH0Wa+AJBQg0hpxpyYE6lkCQxhNscJoTWk03RzTfaSmZBredgkKag9IfJIvgdB/kRJ3ovZWh1WisQQzBE00o5JUdEWl1HfwdUh4b/22s540F+Txk9WxuMpTbKCskkZTHRMdwS5Bu80xzJGMOUWJuixcKhKE0Vc2l0wo+b2MoVRFZkyhdFjnuk/WQfijwhxQFUtApfQqlTGpuPpEtw8m8hy1NtHMFBQ3RTgoFlERrWQ51P2KlpeeJ1vIcHDBgAAtSoeBKCm6jtGL0Q/MxGUHIsEFBPLRD0ZLP0ZQrj5G2AqOtBRovjfMhbdu2jU1QcjQfTch0U+ghSh2RFA55Zffqq6+y6CZ5WyMY+e8JiiyLxSytBInIVI7CTVXbk3Vvg6Eoz1hp7m+CcwRGIxOK1gv1t7GeNxbk80R7z6JtY6JjuCVIp3kmGpSeQ5Sa2+KBorjJlUOGFD2KlCaljxTT4Ie4HMEc7ryUm4/y0ZEFkqLa5WujH4qspWsgVxr6vPHDtKXvYUsT7VxBuS3laGbK7Uj9YMSIEUz5pH5E7xHBkd9K9IOWniday3OQIGWRotMnTZrEFoHygp6yd8i5JsnyTBlQ5GwMmdDvE1IeE4UecCQcCj2vqKhI6FjPPvtsYHKlLZHnnnsu7DaAnMYmXJtkollpB3fUVBM8CFLd9mA50oNi4MCBSFdkH0ZZJpF8ThsrB8F/m0zoPDRWor1nqWhjuqLkPBPt+ZQch0rNbfEgp0EhdxFK7XHmmWeG/S6lhomEnIaGfig5N6XUoW1XSr1D6UPIkkZ+xH///TfmzZvXYM4IlilZ0tpinyarM6XFISjVCy0SKOVUKMKlLWsLpNNzUIbGDf3Qljr1b+r3lCpu6dKlrN9TfycrJPV/2urOhOconw6meprYgx928SDnd6OcW3K+rHDQSjccNChlyD+hOaL5TktBec9kKOdbc1Buu5bYhmmJfJKJELylS/5DzRGchy5Y5i3RRrIiyrko062N6YqS80w0KD2HKDW3xQodS24b5aqLpDiSQhfLNhn5OlL+VaqURAEP5J9FFk25jzfO3ZdJ80my+OOPPwI5CSkoLpziqHQ/yDTS6TnYGMq7SbmJycpIuRhpW5p8f2V/xTvuuCNj+n1KlUd5sqABkWhkkJyEk7ZTIkWikrk4UjJO2gKQ+fPPP5s9bzpF8lECX3nbgszjzZmt5e2tZN5bQvYPTFeCtwrCJZkOXsmSxYSggCQqj5dubaQgmfXr1weSvkbjI9mS21AtGQWs9DwTDUrPIUrNbbHeB/m80fhlklwTSbZMvmG0hSe3j6wzyZxP5PMo2ReT3cdjuR/pPucmW0GTfWfJ7ztYbi39HGwOmp9pt0BOZE8LqeCt6mT1eyX6aEqVx2DHZ/ILSMTRVjZV00ojklDoPOHqnsor4mHDhrHf6QEc6YbRZ0pGWicK+T6Rb5QcgSbXIw1Fc9eWKOS7JA8IyuSfThbaxlBNY5nJkydHdDCn6j6yDyGlWWluizsZbaRVayQ/pueffz4wBoL/LpUEb7+0tKuHkvNMNCg9hyg1t8V6H4K3/yKNX1qkUgWLRKFgODlNVuProGAheayRTyQF3SSCLAcl+2Ky+3i094MsacHpqdoictojWtCQH3A4qB9RFoFUotPpGuxWBPd9pZ+jSvbRlCqPtEKXTba0n083nByuwyH7BoSKOiKHVLkz0MM1FPS+7DMSieDjU3m3UOWy6L3mSr+lgmCzN0UzhspTRzKiybi5B02iEx0VupetdaTUyrnvwkEDg6I6ydm7JaGSYXIuPrLeUNnHUL4yZF159NFHAys48j9rKSgSVfZ3IesSpX0Idf9owSD3cXIWJwf7dID8DeXIX0oz0pLWRyXnmWhRcg5Rcm4j66UM+VtFgtKJyA+bqVOnMj+txjgcDlb+VA6ACccTTzzRrHWSykPKVhfK7dl4+07O10fRtDSfNLfdSONEDhoJJwfygSVLfSb0cbkfEFSuM5T/Ll0LuRekky9+KqB8vPIuHMmK+m9jaI6nuT6RoJTmIMWVgs4i7QLSXCOPH+rnwZHmSj9HYxn/aR0wQ1CdZZpEaaDTdhzVdCZrCSW7JY2b/ADIx4uESz4flLOKwu+pQwRDCTTl7TxSmsgUTZFoZMKmAUX1VxctWsR8x+ghHGnrj/IwUc1L6nCkTNDWZKi6tHQzKfVHqBqRqYKiGemBRHIlCxo54dLkTqkwgmtb08OTas2SXJIVTUcJzykxKq2YaKKnWpzU+SmvHQ0S8t0iPymyvNA2FU24BHX8loYiGMlaRH2N6oRSHWyqlUxRn+QnR/2FJgH5gfDQQw81iYxLJnR/KK8bpXegBwOl6qCHOSW4pTFDcvzxxx8DSeLliSvaPHotAd13SlpOFjTqe5Tvj5LZyz58pOTRAzid55loUXIOUXJuy8/PZ/2cHhx0HFKuyEE/OACFtsoo+pfcMmgMU/1gkg+9T4UH6D7RQ438FMnCRb5YdG+p1ni4nIJ0LnoIkt8mzQGkHJI7BfVrkg8pljNmzAh8P1S9Ygocku8ftZ+U27Fjx7I5jq6dFFO5Rjadj+43bfNTqqHG0DXLCgXJnyLKyfojz4O0LRxPGrZk9nGKdKf+QwYBCjii66cId9ryp50I6lNkRaP5ge5TpJ2n1g7N27TQpzru1HfJZ1eubU19nfoqjT/yOUzmc3Dp0qVsjNCigvo9jT3qZzS2aL6hoBnqh/KiKlS/V/I5Sv1etsSSnkDGhWB3GGpb1EE5sZakibW8VXOl+Yi6ujrxsssuC9Tkbe4n3LGoZm2kv6OySFT7NrgcYKjav4Tdbm9Q77jxD5W9evHFFxuUcFKiPGG49shEcz4qUyaX5wr3QzV8qV6u/P+XX35ZTAZUV/X5559ndZajubdUq5RKRiVaTiyeMkxUYu2ggw6K2D4q0/Xkk0+GPUayyr/JLFy4sEEt51A/JGsqT5ZIH4q35FokqExgpH5AssuEeSZalJxDlJzbfv311walSRv/BP8dlUM75ZRTmpUTlZKLNEZHjRoVlcwtFov43nvvhZWp2+1mc1ek9jeWSyisVqvYv3//sH8X79hNZh8n6N706NEj4jVTab6tW7c2O25jKU+oxDwRS3nCYDmFIlrZ3X333RHHO9W8p1K98v9vvfVWUUmuuOKKqPop1d8OVdZT6ecolbUNvu+Nf2KZ49MiyRttjVDyWFox0sqaVmdkDaByW7T1RtYTqlBAK1dadVFqh1A89thjzEGdVhm0KiezNR2HVmuUY4k0ctkXqTlo5U0WKMo/Rto6+eOQ5Y7aQpY8MjVTmbh0hORGTri0oqGyUrTap5UOrVLI2kKWlcbbHsmy+NCqiErC0QqP7gHJkqLhSJb0Q/eJclzRCmjatGlsS6q5BLHJgiwNZNmgFSnJjdpJcqNVI21tkwWIUmDQajZV0NYVWVRo9UgrT7mfk0WJVqS0cqWI8XR0qRg0aBDbciFrF1lLyHqlVAWelpxnokXJOUTJuY2sFrLVmqyrkXLhUf+nayDLLe1e0Fig98hCQVYcsqpQuyKVkiOoKg5ZV2kM0XHksSVfB1kPaWub+jZZ/MNB36e5i7bmyLJEf0cWTDoW+XxTu6hiCEUjk/Ux3NY29T2y1NExDjvsMHZdSlidkt3HyWJOx6c+Sueie0c/lOia+hRdM80NLTmu0pkXXniBWffIuij3ObJSU9/95ptvmKsElSFN1nNw8uTJbDeIXJxovqZAHuqnNOfQuWj80mf0XKHdrGQ/R8nCSFZ+GkP0fWoDtSUeONIg4/pLlYyHHlxyyTCakBr7GamoqKioqLRmqDSh7E9LCxxaoKk0j6o8tlFotUV5wsj3kVb+tFKJdwWioqKioqKSaZA/JPkjk+WPrNpUE12OblaJTFpsW6soCyWIJYfqcFB0GUWfyhGn11xzjao4qqioqKi0GijamIK6wkEpuyiITa7GQ8m7VcUxelTLYyuEfDkoFQ/5NFCEJPnyke8N5X6kqC2KApXTE9Bn5C+V7PqeKioqKioqLQVVcCEfcfJpJX9DisCmPKKUp5eyKtBzkCL9CfLZpffaejWuWFD3KVsplLphzpw57CccZK6n9C6NFccffvgh7vOS8zYFHaioqKioqKSDEkk/4aBUNfQcbKw4UkqoaGpjh6O1+06qlsdWCK2sKCch5U0jkzzlPqM8UBRpRZHXtBqjqGvaug4VYZhIpB5FklJEmIqKioqKSqpwuVwsAIainSmLBrlpyRlGKBKZjCeUUH3ChAksCjtUZHsk96/maO2xyKryqNK0U6jKo4qKiopKG0ZVHiOjKo8JQFnhKUqZMtarebVUVFRUVFQyA7IM0i4dbVcno8Jaa0f1eUwAUhwp6aeKioqKiopK5kHlNamAhkpsqMpjAsj1YKnzURSXUlARdfLVoJqroXwxVFRZqX0qeajjT5WT2qda/9irra1lxp/guu4q0aMqjwkgb1WT4qik8kiOvvJ2OJUeUlFlpfaplkMdf6qc1D7Vdsae6nIWH+pGv4qKioqKioqKStSoyqOKioqKioqKikrUqMpjGkI1pin/lFprWpWV2qfU8ZeuqPOUKiu1T7Vd1FQ9CTrc5ubmoqamRlGfRxUVFRUVFZXkoT6/E0O1PKZpxNkbb7zBXlVUWal9Sh1/6Yg6T6myUvtU20VVHtM0eSmVUmrt5Y2UQJWVKie1T6ljL91R5ylVTq0NVXlUUVFRUVFRUVGJGlV5VFFRUVFRUVFRiRo1YCYNHW6pZvbWrVvRs2dPteamKiu1T7Uw6vhT5aT2qdY/9tSAmcRQlccEUDufioqKiopK5qE+vxND3bZO0xJNzz33HHtVUWWl9il1/KUj6jylykrtU20XVXlMU9Q0Paqs1D6ljr90R52nVFmpfaptoiqPKioqKioqKioqUaMqjyoqKioqKioqKlGjBsykabR1eXk5ioqK1GhrVVZqn2ph1PGnykntU61/7KkBM4mhTfDvVZIAx3FMKaVXFVVWap9qWdTxp5Ccln8GuOqA/qcDuZ3RllH7lCqn1oa6bZ2mTuiTJk1q9c7oNKGOGjUqqbJS4hytgbbSp5SgTctq1yLg38mAz5u4nOa9Aky/F6jcirZOm+5TMaDKKXNQlccMY8mSJbj66qvRp08fWCwWmEwm9OrVC5dddhlmzJiBtsaJJ56Ixx9/HJnIk08+yZRbnU6H/fv3K7YVc+edd6Jbt24wGAzo3r077rnnHlitViQbOhddT/APtaFHjx647rrrsH379oRTw5DMqO8bjUZ07NiRHbe0tFSR9m/ZsoX1pfPOOw8vvfQSOwddU7xs3LgRF154IduCo3E6ePBgTJ48OWzN+lTeuwA5HYBtc4AVnyd+rD4nAQefA2R3UKJlKioqaYS6bZ1BviB33303/u///g9arRbHH388xo4dyxQPysj/888/45NPPmEP10ceeSTVzU0b1q1bB7PZjHSDFIj333+fKVherxcffvgh7rvvvoSOabPZcNxxx2H58uU46aSTcNFFF2HZsmV48cUXMXv2bJx88smKtT8cGo0GDz/8cOD/1dXVWLBgAd5++2189913WLp0Kbp27RpX/z/rrLPw22+/4YgjjmAK3qZNm/DOO+9g5syZ+Pfff1FcXJxQ2//++2888cQT7BoKCwuZPONl7dq1OOqoo+BwOJgCSYoujdEbb7yRffbaa69Ffe/++usvzJkzhymzSWfrbODAasBUAAy7LLFjnfSUUq1SUVFJN0SVuKmpqSETAntVEqfTKT7++OPsVeaBBx5g5xoyZIi4efPmJn9jt9vF//znP+J9990nZgp0Pccdd1xCxzj22GPZcYJllQnMmDGDtfu6664Tc3JyxL59+yZ8zEcffZQds3EfoP/T+yeccEJS5dStWzfRYDCE/OzGG29kbXjkkUfiOvZ7773H/v6iiy4SBUEIvD958uSAHBNly5Yt4vz588Wqqio2/uha6JriYeTIkaxdv/zyS+A9l8sV6K///PNPTPfu2WefFVuEXYtFce4rorhjflzzVDDXfrhIPOSxX8Uflu0W2zrNyUql5eWUrOd3W0FVHtOw89HDkQaP/JDctGmTqNFoxMLCQnH//v0R/5b+btnOKvGq9xeKL/2+QSwrKxNvu+02sXv37qJerxeLi4vFCy64QFy1alWTv50wYQK7HnqIvvjii+KAAQPY39D7BD1I6YcerjfddJPYuXNn1q73338/cIwVK1aI48aNE0tKSkSdTid27dpVvPnmm8Xy8vKolMcNGzaI99xzjzh06FCxoKCAPcD79OnDHqJ1dXVN/j7Uj9zecOcg4pHL1q1bxVdeeUXs168f+xu6NprofD6fGCvjx49nx1y8eLF49dVXs9/nzJkjxgv1lY4dO4pZWVmi1Wpt8Bn9n97v0aNHA8WrJZXHqVOnsmucOHFiXMc+8sgj2d9v3769wft0PT179hQtFgtbQCk5/uJVHqkPU1tHjx7d5LPZs2ezz6688sqY7h1dY9Ip3SCKm2eKYmVDGUc7TzX6ULx88p9i9/umij8u3yO2dSLKSiUlclKVx8RQfR7TENJ5KP2P7Bv1wQcfwOfz4frrr0f79u0j/i35Su2osGHm+lLMXbWFbfG98sorzH+K/Klou5u2Dw8//HDMnTs35DFuueUWPPvsszjssMNw++23Y+DAgQ38zugYv//+O9s2v+mmmwJtmjp1KkaMGMFeKUhF/tv//e9/OPLII1FVVdXstVPb3n33XfTs2RMTJkzADTfcgIKCAjz//PPMv9Hj8QS++9hjjzH/MOLRRx9l/6efs88+O+I5ysrK4pIL+Z899dRT7FqoXQT5yMXqJlBZWYnvv/8eBx10EA499FBcfvnl7H267nihLdy9e/fi6KOPZr6wwdD/aQt127Zt2LlzJ1IB9Rdi2LBhMf+t0+lkW9/9+vUL3G8Z2vanfkHbvosXL27yWTwZC+TxFy/kIkDQ9nNjjjnmGHY/aCs62ntH75Nryq5du5BUVnwGfHwONvzwPAQhtF9mpHmqAV4nPtx/NrYZL0U2HGjrRJSViiqnTCRB5bNN01Lb1qNGjWLn+eOPP6L6+w/mbBB73vej2P+4sezvaMs7mJ9//pm937t37wZWM9nCRhbFHTt2NDkuWWHo85NPPrmJlYcsi7T92qlTpybWoc8//5z9HVkggwllFdy9ezfb3mvME088wb7/ySefxLRtHeocZPWJRy5kudu7d28D62VeXp6YnZ0dss3hePXVV9nxnnvuOfZ/WmWTBdRsNsfdl6ZNmxZSxjJk8aPPp0+fLiYL6h9kiX7ssccCP3fccYd49NFHizzPM4t0LHKSWb16NWv7GWecEfJzspLT5++++26D92VLdLzjL17L4913383O+80334T8/JBDDmHy8Hg8Ud07ep8+nzlzpphMPN9NFMXHcsTfHh4t/vvLR6LossW/xWirYMein7kbIu+WtAXUbev0k5NqeUwM1fKYAciRuJ07R5crrWT7VKzTXYpt86Yxx//gAAbitNNOY9aazZs3Y968eSEtbJGCGv7zn/+w6NFgPvroIxYt+txzzzWxDo0fP55ZnL744otm296pUyfo9fom7998883s9Y8//kCiqSA+//zzuORCFsYOHeojRymKloI46urqsGHDhqjbQBZGSoB76aWXsv+TdYx+t9vtUckoFLKljPLuhSI7O5u90j1KJmQhp6AT+YcCvEiWBx98MMaNGxfy3iZ6bXKC/sbWQgqWop+WJpr2UgAQ9Ztovx/8vWRhr5TmmZM0S3D4gpuBqm3xH8wtBRu5RB1MxtjvuYqKSnqjRlu3QkRHBdaXC3B5BRw/YkTIaOPRo0ez1D4U3Xnsscc2+Iy2nsNBEZ/B29gyFO1K0PYipTwJtfVIlQPk6gHNRSHTVv3q1avZA5MetDK0vZcI69evZ22h649VLrTF3BhZoaeo4migrdUVK1bghBNOaLAYoK3rp59+mimWlH4mVdB1/Pe//23yfrTpkMhtguQrQ2lm1qxZgwceeADnnnsuXn31VeYW0RL079+/Rc7TWvDVSSmPvvSOwtaSk/BAXuxR8QE80la1A3qY9RqlmqiiopImqMpjmhJsoSkpKWFKz549e5jfV3NoHBWodUm+NeF8JGULWihLVCS/ynbt2oX0IyM/PuL111+P2DbyTYukPN56663MR7JLly7Mp5LaSQoJQZYs8rlMBPl645FLqBKUlDZJtrhFg+zXKPs5ylDuQvLDJCWclC2y1MWCbLUKZ52SrVzNldEk5ZHk3Jh4c2lmZWUxP1LyJyVlmay9lKc0lvRJzV2bfK/CWe7iIR4LaSztpTEkW4NTcX2h4B0V7PVL3yjUuA7GAwapfXHJySNZHu0wwKRTlceIslKJrk+ppBXqtnUaQsoSWWpkpYkc5gnKZxcNWlcVcgySgnfgwIGIW+GhlIlIQQbhPpOPs2rVKmY9DPfTeEs7GEr2TMrnoEGDmLJM1kfaBifFRQ5QaYxc/1SWVXPI7YxHLolCOf9oy5ygYKDGCbVl6208gTOkfMrBF6GggAuiOaWUAohC3bdEycvLYwsfUoQoeXYsUPAU3edw1ya/L8tAqfEXL5HuBS0yKHCJEqfLC4/m7p3S1xcOvVdaYFQjC6V1rpjnqWBEt529OkQDTKrlMaKsVKLrUyrphao8piG0TUt+d/J27RVXXMESF0+ZMoVFCkeCLHMGdw36F/Ew6HVYtGgR86ULFxE6ZMgQRdpM1iVi/vz5cR+DFBxSVMaMGdPEMkUJnENBciGCo7Cb28qkrfeWkksw33zzDbMu0bHJ+hbqh9r28ccfx1zGjBQLSkRN/oWNk1vT/+l9svyRT2mqkKPtg90QooH8a8mVgvxKd+zY0eAz6i/kZkBRyZQdQMnxFy+U7Ds4wjwYiuSXE4LHcu9I2SRrfNIQRRh80rnrRBPqnF44Pb6Y5qlgPE7pWE62ba1ucEWSlUp0fUolvVCVxzSEFKFPP/00oBD17t0b9957L/MXPPXUU5nlojHkZ/byyy8zK53JVwu9hsPYMUeyvyHrXTC//vorq9RBx5Wtmoly5ZVXsm24hx56iG27NoYUNdmyFg7ZKvnPP/80mDx2794d1hJEFq1gy1o0WyJUvaOl5BKMbFGk+0SVUUL9nHPOOaxtlO4oFshyec011zAfQ0onFAz9n94ny1+0SrbSUGoi6rf5+fk45JBDYv572Q+U+kGwJfStt95i9/6SSy5pEsRF1mv6iXf8RUOoc5CcR44ciVmzZmH69OmB92lBIKd1onsVy7279tprkVQ8dvCQxpwVkhxLa10xzVPBuBxSSUWHum3drKxUoutTKumFuiTMECiYghREil6lhxPlJaSHMJUnpIcyRSFXVFSw72W56wAOePzuG7Fk/W72HilkZB2k+sJff/01s+xRYIq87ZsoVBqOtmQvuOACVsP3lFNOYVY+soTSOSmvHeUaJAUtHORvSGXnvv32W2ZFoqAS2l6eNm0a+z1UIA7lkyR/OlIIKVqaLHd0/jPPPDPseShnJLWnJeQiQ6tpKjFH28LU5khKOMmRFM3zzz8/pnPQAuPHH39k10el7SjCncoBkgWM5Ek+lUpid3tRaXOjc369lZhKLQb7R5LljBYTdN9JSaKyfPH4NNE2/5dffslkQ/2dLHckU7r3ZJWje9mYAQMGsNdot91JaacSoLS1TO4X9ACj98jyL0PlAoN9dsOd44033mALEMo5SlHm1LepPCHJgjIH0FiI9t4NHz6c5UxNKi5py9onckzhI8ptLnQtjK+0p8chHc8JAzR87Lk2VVRU0pwEU/20aVqyPKHMokWLxKuuuorlIjSZTCwXHeUIvPjii1nJO7vLK5Y+2oXlV7PtWMpyEd56660sXx1VfCkqKhLPP//8iJVUtm3bFrJdcoWZSKxfv55VTKHvURWW/Px8ceDAgawNCxcubDYHI1WRueuuu9g1ydVlnnrqKdHtdof8PlXgoDyCXbp0EbVabUwVZpSQC+UypM9mzZoVUS5yeUn6fiQovyRdC+UB3Llzpxgr1dXV4u23386OIVf4IXnS9SqdP43KznW7b5p446dLGuQBDf6he9KhQwfxvPPOE+fNm6fIuOjVqxfrW1TF6JprrglbdSnWPI90f8NVLZJ/GveBSOegsUB9Sq6UROPg9ddfD1s9I9y9q62tFZNO2UY2Z1Q/WiL2fvBn8dCnfhfnbS6Le5468Ocb7HgzHzshiY3OHNQ8j+knJzXPY2Jw9E+qFdhMhZz/KQKS/NiUDLCg7S3awqStrFitNPuq7Sj8v87Qcz6It68Gl5dEP6k0IBFZtSWSIaebPluKn1fuw42jeuHeU1pPWpy22KfE3UvAvXM8dotF4O5YjU55DV0AYpXT3ukvoOOCp/EbfyxOfnQa2jptsU+lu5yS9fxuK6jb1mkIDZobb7wxrr+tralGB05ydOfMBWjtJCKrtoTScqI156JtUnqm4/oWozXRFvuU01bNPB2togldzbqE5eRzScFoHk3zSmhboC32qXhQ5ZQ5tKmAGcqTSAmQqeYsVVChjko5FMnPjpJbpwvkc0X+TtHmDgzGVi1FY7uhA3Tx+StlEonIqi2htJz21TjhrStDT/4ABnVKbv7BlqYt9imnVcoxaYMp6ryMkeQkuKRoa5/GqHBLM5O22KfiQZVT5tCmLI/krE8O6b169WIKJAV5UA61H374gf189tlnzLk91VDQwU8//cRy8smpaKKlDHkY63oKw0q0eDxCvsbWQiKySneoT1Klm+agAJxIQTjJkNPK3dWoRA66tSuCyVUGGOrLNkYDpUSS0yJFgtIaUdBJS9Ka+1Q4KrqciMOdH6LIKOKfKOeNSHLa3uVsPLkiC3mFvXBWktqcSbTFPhUPqpwyhzalPFKuOHpgBedYk3MIUjTvxIkT2YMqkxOUVro4rBR7oV1eu1Q3RUUB5fHDDz+M6rvNKY9Ks7Vcsix171AM5MSmOBI0DkNVsgkVZd3SymNbxOrysd0KzqjMNnOZoStmCodipKV1uTSoqKi0wW1rqq3bWHEkqIYx1TSmJMaUoiOTqbZL+bFyTW3XKfv1WZvxxuzNqHVmdq4wqrATqVqP/BNv6cBE2FEu+bR1izOVC7U5mmsjGagkH6vTy14tBmWsYg5/gnGzWppQRaVV0qaUx0hQvkRCLhmWSigfHm2tRyoTGA5z6VJcq5mGId4VaAuEktX/zdiI//y6AXaX6l8USU6J0HHPz/hJ/yBOqPoSrQ2lZZUJ5Gz8Bi/p3sAJ4gJF5FS07y+cy89BJ5Qq3NLMpC32qXhQ5ZQ5pF5TSgN27tzJkmxTIt+BAwemujkskOfSSy+N6287lM/HBN1nWFNLlqHL0dppLCuvT4BXkLJPGXXq2iicnBIlv3YjBvLbUeYLXSM8k1FaVpmApXQpztPMxXfooYicDt7+EU7VL8KXHnKfORVtnbbYp+JBlVPm0OaVR6oicdlll7FKKBRME8mZmb5DP8F5ohq/T5VJyIpJxw0usUfHJasm5bEKTq1J79Fnwe+T0/DChQvZdnrj6Dw6Nq3OGtc+pkFHf78ZnWHzHY2i/MFSnWuDgbUjuNwT/T19n45N52r8Pr0XfF4lrkluOx0rWIbRXFPjUlXB10RtpXraVLGDqsPYXR5M1EwFR7mbHSPg1uZm3DUl4z4RVFWHqszI1vV4r8nhdOEd+0jM47riiYFjAlvMLX1NybpP8vijCjGN0+Bm6jU11/c2FZ2ALzZroM06jB0vmmui79HYO/LII9l7wde0y9QP2ypdcBjbs79rbeMp1vtEf09+viQrefxl+jUl4z5Re6mMLbmX0XGSfU0q8dOmlUfqaFR6jMrGUe1YUiIjQbWQQzn5U61iKotHDB06FGPHjmU1banMmAwNBgpq+OqrrxqU2aMyelSKjBKjlpVJaXZkSCGiYwd3cgrqocSmkyZNavDd+++/nyU7/Wh3R+wXbsJxq7dg7taXWS1gqv0bXKuXoswp59iKFStYBKAMbavQ6nju3LlM0ZBR6pqo/jDVjY71miZPnhx4jyaPUNe0YcMG3HTTTVi6YhUm+8ay92yvvYE+vTP3mpS8T/TQou/TT6LX9OTzL2GnOAQ7xWKUfP0nHnxgREquKZn3iejTp0+gHnlruKZIfW+hqzve852BPjvK4Jw0KaZrmjdvXpNrmu8+DOt9p2GsTQcq7pgp42nt7G+RjxpUIB9dh52g2H3q0qULkxP9tPQ1pXvfa3xNxDHHHMNKeSbzmqINRlQJTZutMEOK41VXXcU6EHVIem2unnEoyyNNCqWlpYEM9Uqs7OgcVMOaBlxjmlvZnfLK39h4wIr3Lh+Ko3sVtvrVqiyrO++8E9nZ2dhdacMx/5kNnYbD6kdPyMhrSsZ9ou/RhH7HHXcEsgnEe02rdlVi7Bv/It+sw7/3HdfqLCVyn6J6043nhEy9JiLSfZo0fR3e/GsrLj+iCx46tV9U12S325mcqE+ZTKYG1/TA92vw3fJ9uPvEPrj5hL4ZM57w51PQ/vNfeA+7DuLJzyp2n+gYjcdfus0R6TDvBT/76NzJvCaqW0/Kt1phJj7apOWROtiVV16Jjz76CBdddBGL6GxOcZQ7eqg0PqHelwNwGhOu5FK498OlDQr1Pg0uwV4DHUQU51gC36FrC/V9GkChtulpcIUKHErVNYV6v/E1yeeiCaQzVwqt1tzg80y8JiXvkzzZhuqrsV5Tnc2KKzXToTO0h0F/Il1QSq4p2fcpXNsz+ZrC3ae8qtUYzO1FsaFjg88jXZP8PXqVr0V+dfmf4VlGXUaNp986TcT03qfiqMJ8XNjomqJte6SyeqHGX7rMEZl0n5J5TSrRwbdlxZESgn/88cdpl7SVBhOZ4qNRaBszxX0fNhkvR3HlIrQFGstKqN6BuYbb8TN3a6qb1mr6VGPsZTvxmO5j3O58gymOrQ0lZZUpnL/tMfxoeBRd3FsVkdPzm8dileFqFHv3IZNYv68OP6yuwLJ9yvrDtcU+FQ+qnDIHbVvcqibF8YILLsAnn3ySdoqjvIIiH45Y8QkisiDl3zNa8tAWaCwrr9PBXt3Qw5LCdrWWPhUKZ9V+9mrVFqA1FsBUUlaZglaQxo3enJW4nEQRJsEGDSdAa8isHmJ1Sdun2UZt6vuU4AP49Hs+JZO2OPYylTa1DHryySeZb2NWVhb69u2Lp59+miUrDv6JphxcsqGt16lTpzbxD2kOq8uLbL/yaMrJR1ugsaw8Lun63VzmVglKpz4VCm+dlJ7HaShEa0RJWWUKBll5NGUnLiefBxpI+9Z6Y/TKaDpwxI4peFn3Bnq61qe2T634Ani2EzDrWbQl2uLYy1TalOVx+/bt7NVqteKZZ54J+Z3u3buzerqptpBS1NjJJ58c099Z7Q504qTtFoOlbSiPjWXlU5XHqOSUCBq7FHXpbqXKo5KyyghEEQbRyX41mLMTl5NHKl1JGM2ZZf/vVfsvumvWYQbOT2mfEv96AZzXAfz1PHDkzYBRCshs7bS5sZfBtCnLYzTl3ih1T6biqK2q/48h+odAa8LnkR6CHl51hk4WOmeFJGNTUdLOodKCeBzgKS8qc3dRQElx+63/ogYGfwqzTEHvkxRfrTGF86e9Elzl5vr/74q+6o+KSkvRppTH1o6jrlJ6hQHQhI48a+3Ilkevum2dNIwuSXkULMXJO4lKy+GRxgxhisHyGP54jsA8ZNZnls+e3ifJQmdOnaVPqKgPWqoQs2Gv3JuytqiohENVHtMQCuKhBKexBvM4bdXs1c5l1laRkrIS/A8uD6/6PEaSUyKYPdIihWulymM0sqp1enDnl8vx1LS1TarQZBxuydrmEPXINhsSl5N/25opj7rM8owyitL8oTPnpmz8VeyS/C2XCz1xqOtN/GU+CW0FJecpleSiKo9pCOWwosz4oXJZRcLjVx6dGkublZXgliZ/nybDlMcN04FV3wC1e9OqT4XC4LNKx7QUoDUSjazK61z4btkefLloF8tfl8n4XNL9tMMAi0GbsJxEvzJqFw0w6jPoEUNR4n7l0ZiVm7LxZzsgVUPZJHSmJRqW7ZLm9baAkvOUSnLJoJHddqCM+JRGKNbamx57DXt1ajIrwlFJWYl+y6OPzyxfK+YY/+3VwL6VadWnQmH2K4/6VhqUFY2squxSNGi+JfPdQ5z2OvZqF43IikF5DCcnj1NSHp1s2zqDlACPPRAlrrTyGMv4c9VI2QxKIaVbW76zmim2bQEl5ymV5KIqj2kIbYNRLc5Yt8MEh6Q8erRZbVdWfuVR0GSW8nigtJS9ztvtSas+FQqzKCkHpuzWqTxGI6sqq1SWrcCc+YFZTlttYJvZoOUTlpPLXm/JNOkyaPvRb4EVRA4WJQKH4hx/PqvkU5xb0B4Paj/FK/sugW/NVLQFlJynVJKLqjy2IkSnpDx6dWkWae3zAFXbAUdQNHiy8ErR1oI2sx7qRsH/4ErzKHm3V0A2bG0ql2gofAfWYK3hSrxScxsyHZdNsjw6eZMiW/Aep3Q8FwzQ8Jmzpe92SEq0DcZAWcVUoHFKPsXtSzqhUONAB64ClZsXImOwVwKfXgjMe7XNWEzbIqry2JpwSpOfT59eCoirbAvwymC4XhrIquC0hPIoakzIJIxCchz1labO4UYWpLaas1unz2M0eGpLYeZcMHKZn8zY7ZCUPbdCrh5e/7a1UsdrKZzW6oDyGIvvp9IY3FI7tNlFWNz+fFzoegSzii9FxrB/JbDpN2Dxu62yfKmKhKo8piHkLHzmmWfG7DTMu6WHgJhmymNdtbQNU+YxQGlDRGNZcbLyqM2gB5fPCwMkHx+jJTet+lRjrNY67EMhakUztObWWQIzGlmJNqlPO/WZb32VLYUe3qyInDJXeZR2buwwQafhUzb+RMHLXg3ZRSjodSgWigOwZF8GLVIOrJVe2x+SsnlKJfmodygNoTQFw4YNi/nv/rCcjvf2dcP53Y9AamvkNKRK3x4vea6GQW/E4wqvRBvLanbBOPxn10EY22koDkfmcCd/LwSnFROT5EcYb59qTJ2gxxmuV9Eu24CF+syqW6ykrA6gAN/6jkG7/EPQHZnN1g5jcZGzEAO75OFIBeRUWjIS/3HfCOR2QibVCXHZ/b6fnCml4+8a0/9he1ktPu40DIPd0k7N8kyKuB48Hmg3gLZRUjZPqSQf1fKYhlCk2RtvvBFzxNk2oR3mCIMhFPZDOlHFFeBz3wmYYzkp6bIq4wuxTOwDdxalucgQNFr87B6GH4RjYDEZ0qpPNcbp8bHXTEv+rLSs1moPwl2eG7G293XIdOp8GpQjF74YKwaFk1OVuTvry5vNg5FJePzKo5s3pXT8Vds98EGDPIsJQ7rm4YieBThhQLvMCSIxFwC9RgNdD0/ZPKWSfFTLYxpCk0RZWVnMk4XVKW13xJJuoyWodUhbLtkmXdJl5fL4U21kUJSnxyfA5RWSeu/i7VONcfiVx0ySbzJkVesfa9kpDKxQCodbuhZzjPc0nJwcbv8CI8MShFfrijDNdziqTb0wNEXjjz6vdtSngWqXbcQX18ViD04Pbvx0CWv7xFG90D7H2OLzlEryyazRrRKRYdbZ6K+pRoGvGzmcpI20fGUbcTS/Cu21/ZN+rkHVf6CDZjuKHbRlkhkbilR+7Cx+LrP+WAynIp0x7l2AH/SPYo9zAICRaKt47dXMTzXbmPlTaMedP+Ex7d9weU4EcGjCxzMcWIYx/BLk8JlledybOww3e27DiLwCpCo8xVq5D+9qJqFGY0G++RRkHD4PHDP/A8vaanzsOxa3ntAn1S1SSRLqtnUr4mLXV3he9zbybPW1UdOBkm3f4VP9czjT8WPSz3V07S94WPcpim0bkCm496zCK/o38KjuE8Ud9ZWGs+7HEH4Legg70Za5ueIZbDBegd77fkKm077iX1yp/Q09PZsUOV7PzR/iHf1LOML1LzIJeecmO4U7N/aaCozSrMBx/IrMtO7X7Ibpn//gae376F6UjQJLZqVMU4mezF82t0J0Oh0uueQS9hoLC8SDscNXgL65HZBO1CAH64UusJs7JV1Wy3RDsdFuQUluZlgdCTtnwlzfwSjTlqBfmvWpxuzNGYpr3Hehd0lHHITWSTSyMgi2jEitFA3rco7BrL1a5OUNVUROVYZOqBZ6w24sQSZhdzjAQUhKmp5ox59Dl4+73DfApOPxNDIQXouV7c/Ghj2VGNatIGXzlEryUZXHNITnefTu3Tvmv3vSczncPgHzOsSeIiGZzC4ch/fWj8ANXXrh9CTL6mvjeVhZXoP32ivttZQ8yvMG41LPQ+iabcY5adanGlOlKcQfwqHQZ2eWYqC0rC4Xn4TXWYfveo9GprPMcgw+83bF7YV9FJHTnC434L8bTsDFRV2RSQxf9xy2Gb/HbzXXAwp7PUY7/uyaHHwrjESRzpCZymNeF0zJvQ3TduzDg+2zUjZPqSSf9N4ja6O4XC4899xz7DVavD6BKY7xOL4nm1qn5ACem4SAmcaykgNmDNr0kkEkbC5puyyZiYnj6VORoq0zcktNIVmRM3+dS0AdzMiyWJDpyAEulhjrUIeTU33ATGb1Ec4tVXni9caUjT+nVx5fmfto3lomWeV7FGWlbJ5SST6Z20NbObGmKrC7veAhKU6mNEujUuOPHswxaZMuK42nFnp4YNRmTmUDq195zDIk974pkf4iq2oNzubnoqdnC1ozkWTl9Ajw+isltYZo6+y6rejJ7UWWxqOInBwZms7py4734VDnZGzudG7Kxp9YtQuj+WU4iM9Mn2LRVo4D5VIC/Z7F8S2s1DQ9mYGqPLYSHHYbthovxQbDBBh80sovXbh99x34Q383ujiSH8Tyif1GbDROQE7dZmQKXVe9iuWGa3Gp4xOkOz0P/I7/6t/AYbW/o61SZ3fgf7pXMUn3Nixc5ltIbtj/CP403I2O9nWKHO+a9VdjnuEWdHZtRCZR7dGiArkwJKnKUzRYdv+F9/Uv4Cr3Z8hEXN9cjyWaCRivnY2uBa2ziICKhOrz2Epw2qUSYwaqtatPr6209p49KOIrUNsCVhoDpIe5zpA5ta15RxXyOBuSbHhUBM4r1bUWtZkjX6Vx2apxhsYfSazJ/GhSg1xX3ahMWdMcdxnyuAoYMyzPo9XvXpPKPLmiS9o6d2kyU/Hy1h5gr5ylKO0zR6gkRmaN7jYCRZpNnDgxpogzl195dEEHA59eWohZlCyhxuzCpMvKILoBjh6EsfvbpAy/r5Wos6RVnwoF71ceuThKj2UKzcnKbZNKxTmhh1GT+dvWelGqB68zZSkiJ71fGdUaMmgMAji7fApGaatR7LsPQJfUjD//XODVZObijLeXsVdNdvuUzlMqyUddGqQhHMchNzeXvUaL2yFNOk4o7+ydED4PzJAeTuac/KTKSvS6oeX8FWbM6WV9jQTv8bsZJPFhG0+fCgXvle4l9Jn5cFNCVl57DXu1InP6WCRMfuXRYM5WRE56UbL+a2NURlPNsfY/MEE7AzmwpW78uaVzezUZ2LdEEQan5O9oyCtJ6TylknxU5TENIYfhSZMmxeQ4LCuPLi45tZHjxeeQHrREdm7seb9ikZXLUT/pG0yZM/nyHjt75QzKbBsq1adCofG1fstjc7KSlUc73wpkQAsuSAEuelN24nIKPl4mWf9pwSlKfTsZPo/Rjj9etjxmoluIsxoaUdr6txR2SOk8pZJ8VOWxleD1K49uPr0mHVuNtBK1ikZkm5PbNqddkoEgcjBmkM+j1ispvXwGbPNpfZKVite3AsUpwQWRk2sFMvArK4QxRstjSDyZuYCDIAR2SIwpDJiB3y1E0GZg37JKW9a1ognt8vNS3RqVJKMqj60Er9/R2s2n17a1rbaSvdbBAr02ud3N5bQFfNG0GZTnUeePjteYcpDuaAVpS1KTQcq50oiuuowOaghG9Fu93aIGZrMCc4dHUn48ogYGUwb1kSCl15ydOuWR80rjS9Sm1zweFbZS9lIu5qJjXga2XyUmVOWxleBzSZOfJ80crZ11kvJo45NvhXD7t62dXGZFwBp80gNcF+O2YSrQCZJ1RmPIIKuSwvjcfgUpzRZq8eBySNfigh7mGJOEh8Qt9WUHO17mLOBcflcEn8jBooQFNk44v2Wf06aX+1FUWP3KI3LRITe9nkMqyqMqj2mIXq/H/fffz16jRfArj+kWpeeyVrFXZ5KUx2BZuf0ycCOzJl6DICuPOWnVp0Khk4MhWrHy2JysBL+C5EuzsRYPzkCgnQ6mGCvChJST34LngAHmDErV47DWslcbTLAYtSkbf7zP7+uXgZZHjz9NT5lIyqMxpfOUSvJRlcc0hMqf1dTUsNeo8UfppdsDzWOVLI9OTXbSZeV1+rfgMszyaEqio35CfSoEBv+2tdbYepXH5mQl+i2PPk3mPeAb43JK1+KGHhqeS1hOol+xtosGGPWZ83hxWqX0SzYYoU1CfsJoxx/vcyWtRGKysVdJlsdaLifuUrRKzVMqySdzRncbwuPxYPLkyew1WuRJW0izKFifXZqUPbqcpMvK65KVxwyaeH0eVk6RMCVReYynT0VKwq5vxcpjs7Ly+wkKrUF59Lt6eOJYcIWSU33KMIMy2+AthNsuWR4dSQqCinb8BZRHXeb1LZdNMhS4dfGn2lFqnlJJPqry2Erg/A+0dKv8ITqkbWuvPvl+RLLy6OX1mRntmpX+ATMG/7Z1pqVhURLOHxQipNlYiwe3f8zEozyGPJ5febTDEPM2eFiWfQL8ci+wfS6ShcchKY9OLrX3VCMHpOkyy/WG8Pl3mQRDCqPVVVoMVXlsJXB+X6NkVimJC6c0KftaYELx+a2vmRTIEIjcFbWwJDmVUaKIggAvNCyowGBOLwt3i+JPlC5moHWoMR7/trVSCy63s75YQazb4OEoX/YzsPAt7N24BMnCJ1tMU5y7U0sVsti2dXrPBZEMBTApXwxCJf3InH2FNkasDsNzs07Gl/tKcGKnozAM6cOyrJH4dbcOPYqOSrqsducOx3/d96F3+44YiMzAzmfjUfcN0HFePJrkmrqJOqG7BRGDXO/QYwIrc+OrIJEpRJLVXkN3zPAdCndWL2Q6ewsPx82uF9C3JA+TFZBTXf5AvOKZAJu+CEcr1MayykoUAVhX4UNHJAeffxHnTqLPeDTj7752U7B4yz48UzwUmcafPe7CT7tH4ZDCxNquBstkBqrymIYYDAY88MADMf3NFq4bZgomHFt4MNKJ5dpBmOorwsPtByRdVjXaAswRBsOclTmKDUV3fiuMBBlpnlNqm0+hPtUYp1sq/UjFw00Z5M+mtKz+zhmLrz3DcE+Hfsh0rIIeW8ROaG8uVEROtVnd8ZHvZHRUMOBD609lxSUxib4v4PJiTOn4s3k5NicYMjBgZquvPRaIAzA0v1NK5ymVlkHdtk5DBEHA5s2b2Wu02N1SSTBTmuVWq3FIjs/xRt/FIitnmsogElaXl71a9Nqk1nONp081xuGR5KvlOeiSEJGaLjQnK6dXel8xn74UIs8b8eRkDCUn+XhGBcegzl8SM5m5RWt17TDHNxD7jL1SOv5c/r5lzMC+VWGT/DWLsvQpnadUWobW+wTIYCjS7NNPP40p4qyPbRFO5Rcg31uOdKKkdgUGcluRr5OUpGTKKrdyBcZpZqG3Zz0yBVflLozml2Goflfa9anGuCt34kPdJPyf7g20ZpqTlcvtydgHfGNyDizEndqvcLjrX2XkVLEJh3Pr0E0jlSVVAr3f8qg1Ji/obnPxCbjc8wBmFV+S0vF3a+2L+I/2LZh90jZ6xiCKOGrvh7hUMwPtjNICIlXzlErL0Hr3ntoYF1o/xSH6dVhf2xfAYKQL99Y8g0JDFVZ5hgDokdRzdS39ExfqPsL8WgrSGY9MQLtjDt7Xv4DFAvkJXYN0xmutwHGalShD23aIv3vPbXjNsBFLKl4BcCkymfyKpbhV+wMWsR2CWxI+Xvv1n+BLw8f4zkPj7zxF2qgXpQAlXRIrvwR2blKZ2FwUcaJnFnsqr9BkmOXN48C42vcxTgfMM9+W6taotACq8thK2IDusAki8rLTy99vv1gAl8jBlFuU/HPpuuAP31C4s3ojU7DBjBVCT+w1dUW6U2dojzvdNyAvy4hH0XahEo0GzgudLoNSQoVht7EvPvSeiKzcwzBcgePZtbnYInSAVR+7D2U4jP6SmPoklu90BFxeUrgZJ4p4mb8SHpcDZ5rTP21XAwQvfuBOgM5bh+55bXtx2VZQlcc0hHzfiouLY/KBexZXo8Ltxq9dRiBdoCoBZ7mfhlcQMb9d96TL6t+cU/CF52Dc2Ymsr5nB9uLjcbu7AEd3LcTYNOtTjbHxOfhOGIm+ptad47E5Wd2f/Sx27CvD8x2OQKaz3jIC73mLcUP7XorIaWmP6/DIiqNwSkEJLleigaIII/wVmJKoPI7e8CSuNvyBfypvBJKQqyGq8cfz+EA4FbU+L843pVnKtWYQDdm4y3UNfIKIf7OMKZ2nVDJQeTz++ONx9NFH46mnnlLysG0OSlVw4400icXh+J5G9WRtbh9THJMZMBMsq0DwSZJT3iQrYCbd+lS4gJnWECiSiKwqfGbsRyH0GfaAD4XT6w9w0fGKyMnh9iobtCaKeBLXscTsE3KUs2Y2RuuxIodzQKflUzr+5GAsQ5LakSzqXF6mOBJ5Zl1K5ymVlkHRHrpgwQL4fPE7y6pIkAyXLl0atSwFQax/sKdRpLEcaa3TcElTOIJl5XBJ58sypI8MmsPmVx6zkqzwxtqnQlKzG8fzS9EfW9GaaU5WTk/8Cle6wTsoh2INLLxXETkpnvWB5/GZ+zh86DsZJnPylPWvSu7AKNdL2NHhtJSNP8FlxyG+9TiI255xwVi1tbWwwAG9lkuo7YrMUyotgqKzX//+/bFjxw4lD9km8Xq9+Omnn9hrtNaD5YZrschwAyzu9Im2du1YjBn6ezBZ/2rStiGCZXXXvjux3jABPSv+QqZw2Pr/4G/9bRhp/SWt+lQocvb9g/f0L+Ii68dozTQnq5udU/Cw9mOYhfrSkpnK2H2vYrFxIgbv/0YROZ289n78qr8PAxwrFGmf2ysEdi+SWSu7QsjGdrEDeHN+ysYfZTP4zvA4Ptc/nXHKI7fme6wxXo33dC+kfJ5SyUDl8ZZbbsGPP/6ItWvXKnlYlWawOxzI42wo5mphNKZP2ThXzQH04fegK1faIucz+Owwch7oDZlT2svoOIAufBksmvRfaQv+8o8+TeYlMFYMUcR4cTqu0U6Hic+wiNgQaHxSMIpGoVKLeY4d6M/vgkmrTH+211XiOH4FhnCb48pFGS3yzk0yFdRo64y7oIcxw7at3f661m5N6/aHVqlH0ZHSs2dPjBo1CkcccQSuv/56DB8+HO3btw9pdRo5cqSSp27TOG31OcH4JCbSjXdCcbbQhGIQJMd6fRJTeiiN1mtLevUMpRA9knx9SSzhlil1rQlDK/B55AVlaylr/Qm9lZqH3Ac24EP989glFkOnaZQCxm0Dln4M9BgJtD8oofOMqfgcw7TlKPAUA+iCVNYZd0EHbYYl4ffZpLnepcuwKHGV9FAeSXEkRZGibF966aWIW5WqT0N4SG69evWKeqvXZZeURw800GnTJ32Iz1ad9AklWFZGUVYec5EpaL2StUGTZOUx1j4VEr/lUdS2bstjJFl5nDbI4QDGVqA8agSpKgivMykiJ53fkqnVKyMbpxdYLXRHFZ/fVKX743Fg4RQgqz1w+ypAa4j7PKNtv6CDdh8WeS9Cqsaf2yXNX+5AD8scREcVe/Xqc1I/T6lknvL46KOPqjddASji7NJLo08+7HJIyqMThrSadgS7f0LRZbeIrEykPHKA0ZI5lkedv3qGJolpSOLpUyHxSg83oZUrj5Fk5XJY2RhziVoYDOmzUIsXnV951MTh6hFKTnp/TkaNURnlsTL3YJztfhad8kyYF/yBzwPv8i+kB5j1ALBnKdDtyLjPoxclOeiaa7ezBpj5FMtriBOfAIy5io0/r39x5uEysF+RXOi26HNTP0+pZJ7y+Pjjjyt5uDYLOQvPnTsXxxxzDLTa5m+Rxy457rs4I9JJbRL9E4pgyE26rI488khYOOkBYLRkjuXRIEgPDJ0pJ636VCg4j9/yqEsfv9qWlhUpj2QjdkKPnAzzSwuF1r9trYlj2zqUnALVYBRaDNn92Qga+zuKB1ZD66ZKUhK2rf/CkpDy6LeYNqc8/nIvsPILoKAnUL0TKBmo2PjzuqQ2eDNQedS4pLkepryUz1MqLUPmz36tENrS/+uvv6Le2ve66pXHdIL3TyiiMbEJJRpZWWulLXLCkp1JyqNkzdMluaJErH0qFLzf8ght6/Z5jCQrj8MWsPK3hq01nd/ipjWYE5eT1w0tpN/1ClkeA/lrG6Wyqty0oMH/y/ZuT+g8RkhKtCFSAvy6AxBXfcV+XX705KgVx2jHn9e/be3hM0951LqluZ5PUHlUYp5SaRmSotrbbDb88MMPWL58Ocv/lJOTgyFDhuDss8+GxZL5fkLpBvlhEW4+vR7qGr9lgEtwQokGp9+/0idyMCj04GoJ2FY7s5amv6M55w8W4eNQNFoLgYhYLn7/unRCJ/pzsSqRocBvmSb0ClUhKtr4GWbrJ2OFYxSAowPvV29eCEoZTqUVX/COw1XFg3BnvCfxeaCDt/kgqHVTwYkClgm9cc7XFXjaswOXHtEt3rOGaIZsecy8vqX3SgYMTZJSHam0AeXx22+/xXXXXYfq6moWOCNDq/S8vDy8/fbbOPfcc5U+bZvG51cePWmWQkXvqW2xCcXhjzi309Y9nyEGdZ8XBr/Fw5iVfAU7UTT+SFqNvu0qj155oZaBD/hQGMjyyJHyaFZMefSKPIxGZeYi3laG7vwB7OAa5tTUVEmJ6pcKfWCFGTsq6xXXWBE9dhIBw2gOr/S61/8GsglO90lVwL9ftgcXj+gKnucUVR59GWh51PukcaHPIJchlTRSHv/55x+MHz8eGo0G11xzDUaPHo0OHTpg//79mDVrFj788EP2OZmlyUdNJTQ8z2Po0KHsNRoESllBk7YmvR7qBp+k0Omz8pMuK48/aMgBU1r5fUbEXf9ANCXZ8hhrn4qYEzCN0kG1tKxam/Koh2R51MeRH7aJnPwBH3YYmmwzx4von9sEbcP2ZTt2sdd2XfsD24EdFfErj26nDXQ3BZGD0RRGDoIAcddC9uuBguGYdOxAnDusc9SKYzTjT/Arj0IGKo+y77YpwUWwEvOUSgYqj88++ywMBgPmzZuHwYMHN/hs3LhxrGblUUcdxb5HWeRTwSeffIK///4bS5YswapVq+B2u/H+++/jiiuuQLqg0+kwduzYqL8v+n0evWmWf8/sVx4N2YVJl9XKv6ey/zv4zFFsXPYa9tByixpkJbH0Wjx9KhQaX/z+cZlEJFl5/dvWbj69rPzx4PEJAct3PMpjEzn5LY8OGJQrRyorj7qg8eFxoNAnVdLqf9BgPLv7cXQtqwHs3wLmgphP4bKTukvt1sMULkl4xWYYPDVwiHoMGHoUxo/oqvj4E9x+5VGTYcqjIATcb0zZeSmfp1RaBkXV+/nz5zMlsbHiKDNo0CBceOGFzEKZKh5++GFMmTKFlVEkq2g64vF4MHXqVPYaFf4Vf+PVeaqxiNLEb86OfUKPVVbOGulh4tBkjN0RDqu0rW+DCZYk1+OOuU9Figw3pn9C82TJKmDl5zPf8uh0e2Dg/L5+cSiPjeUkWwkdokGx2tacRzqmGKQ8Wg9sYa+1ogkjDu6DkzRLcAyWwl21O65zyKnOqLKLLkxybu+uRex1pdgTxx/cOSnjT07CL6SZ+1GzeGzgIbmoWbLzUz5PqWSg8mi321lFmUjQ5/S9VPHOO+9g+/btKCsrww033IB0RBAELFu2jL1GhX+CFeJI9JssRMGHLFG6z5bcwqTLyuOvcOBOYk5JpXHZJOXRDmPSK0rE3KdCYJDTsGRQBR+lZSWXaPRm2gM+BE5H/TxsCLddG4OcPE6r4pZHjT+JPhfkZ1teWY11Qles43qhU74ZrwgX4F7Ptajk4lNc3HIEfQRXhMptUq3uLXwP9C7OSsr4E72SZV/MMMuj6KoL+LrmZGenfJ5SycBt6+7du2PGjBlsWzocM2fOZN9LFWPGjEFrY1XW0fjFw2FYu+EYhvTA5nTjNe945HA2XJVPJb+SywbzMHzmvhWDuvfAIGQG1boivOm5jAUrPIj050zxv0xB+LHTYWir1GkLsEDojwOGHsh0nIIW57ieQJbWi4+Dt4XjxGHpglc8F6IaWXhSoRrRvN8aF1y+c7uhL65wT8KADjmYznP4w3w69tU4cbEvGyVxnMPl92N1sc3r0CzSD8cW7wF4Oh2hWIBMYxZ2moAbNwzFqSU9cBwyB6c2F1e6H4YRLrxuzizFVyV+FDV30JY0+RJOmDABe/fubfDZvn37mF8hfU5b2yrKsUXbC1/4jkdVsRQFmA7UuIG3fGfiFfFixSIvI7FbbIefhSNQXnwEMoUqTRHe952KP8ynId2hzAlWt8C22LPM6WPhbmk2F43BOPej+L34yqhkdsvny/DyjI2odabfNpxLAJaJfbBSO4giFRI+njWrG173nY2vuZOgUUjBClRgClIe99dIFvAOudK80i5bUvrK6iTLXawEgqAiuCLMsPXGy94Loe+bPONDnWjCPhRCMCXPzScZ1Pk0+Fc4CHPEoU2Suau0XhS1PN5333349ddf8fHHH+PLL79E79692Tb1gQMHsHnzZhacMmLECPa9TMTlcrEfGcph2fh9ihIjp1/y2Qg2vVMEOmXMJxkEpzCi9+iz4Pcpy/7IkSPZ+8HnI+jYlPaIvi9j8z+YDFq+yfcpgInaEexDQn9PZaAoESudq/H79F5wktZI1+Twivhg7lYUWHQ4f1inwDVV26X25Zika5bbTseK5poIagvJpLH/S/A1UVuPPvpo/FLuP59R2+D48VxTtPcp0WuqrJOsKrK/YzLvE/1Q1Ybg48RyTW6vAK8gfYcSQQd/Fs19SsY1Jes+yeOP3m/8fYfHnwRbI437SNe0v9aFn1bshZbncPWRneEibS1N+h5Ra5OUMNpijuc+yWOPXqkdDrf0PZOuvk2JXpPWrzzyBgv7Hn1/d6W0PV6cpWPv9TTZkcWvgnu7F65ep8Tc96w+LZYLvVCm64ruQbIMvk8bD0hbsz2LjOxvY70mel+WVbj7RLs17D5p+SZtT+fxVFnrd08yaAPfiWcuJ6i9NE/ROVvimlTSRHk0m82YM2cOnn/+eXz00UdYu3Yt+yF69uzJLJL33nsv6zCZyHPPPYcnnniiyfsvv/xywLpGaQYoWmz69OnMd0PmuOOOw6hRo/DVV19hyxbJ4Zs488wzMWzYMOaLSX6YMpdccgnr5C+88EKDTj5x4kTk5uZi0qRJgfd8bh2O4XkY6rIxadJHgfdpoD3wwAPYunUrPv3008D7xcXFLPJ9xYoVDaLeqSA91RWl8lCUTkkm0jV1GnAoXvpjMwzwYvPvHweuyWvMwSHcVnhsekya9E/gmmhBQfJq7pqI+++/HzU1NZg8eXKz16QROZzKe8Hvd2LSpM8TuqZY71O811Tl5XEYZwYO0Hg4Nqn3ia6JrP8vvvhiXNfkEwX8TzcfdtGI1/9vAcBp4rpPSl9TMu8T5aptfE3Gw85jv69btQKTNvwU8ZpcRf0oqQw6WDj896UX0uKagu+TzcfhGs1+aFGArVu7xX2fKLsGXVOf/v0xgNsBm9MUOHei13SlUMfyULoFScmi4w7zLsAM/Xb8uGIU3Gf+H452zsb5+tfxz7+DMGnR8pj7nqu4Pz5zP4XeZh7/BMlMvk+//fQtCg5sRzeuGDO/WwVL1RFxXdOiRYuYrMLdpyzPPjysrYbZehbKywszZjx5nDW4VONEqTsf5eVDE57L6ZpOOOEELF26NKnXRKkDVeKHE4NVcoWpq6sLVJjJTtCRNhlQB6fOG22qnlCWxy5duqC0tJRdo1IrO/qdKvTQ9n7j2xPKqrD2pVMx1L0Ey4Y+g4NOubZFV6tLdtZg3JR/0b3QjN9uPSpwTSv/+ARD59+K9dr+6HHPnKRZHulvvv/+ewzc/T6Gupdi6dBncHCQDNLJotX4mlZ+9RSGb3kN87NOxJF3f5PU+0T//+KLL3DOOeewv431mvbv2Y5uH41gFXy8D+ynRsR0n5JxTcm6T/L4u+CCC5qUIFz93o3otv93LOx6NU649IGI17RtysXQlq3F7K4347LLrknpNYW6T6sW/YXD/rgApVwRih7ZFPN9cjgcbOxRn6LF8/6fn0OX5S9hmvZEnHjPp4pck3VSfxSKlVh88g849IhR7PtbXj4JB7mWY+4hT+Po827Gz5+9ijM2PYotlqHofOtvMfe9aav2465vVuOongV4f8KwJvdpz9Jf0WnqOGwVO6D9fctg0OtiviY6X+Px1/g+bfjfeRhU9zf+6nM/jr3ovowZT1tnvosBCx/AIs1QHPrQn3HP5YQ8n8v5opN5TeXl5UxRJaVWfn6rpMjySDeEbrq8iiCFMR2Vxnihjh7KahrqferMoZAnjubep9UYdfhwVtrg9/fz7bFO6AIuu13I79PgCvW+vJ3ZGBpcoYrSh7omy9rPMVP/PywTR8JgGB143+byYa9YgDp90zZFc03BE0Zz17Rt2zaYdV3hEWwwFnYL+f1YrimW+xSp7c1dk50zYZvQHnZTh6TfJ5rkSU7U/sbniOaaPLpsPOaZgDy9gDtC+LBGc5+UvqZk3icaf6GuSeeuQRFXC5Om6d80vqaC2nVox+/FxuL8kOdNZd8jXLpcfOc7BvqsApwRx32i9sh9iq7FBS3KxFw4tLlR97Hmrsnrzx9osOQE2v561i2orNuK67pJrgXarCLpO56aBueNtu95BGmBYDboQn6/vM4Bh9ARZfrO6Bnk7xvLNdFcHm78yf9fljUS86ry0Dnv4LBtT8fxZDWWsKo71ZZ+GO73nY13LidITiSvVF2TSgqUR9LeyRKn0rK8pL8Bm6ut+Kzb4S0v+po96MXvw06+YfmwtXnH4VJXe5xzUCe0RBjPi7gM+90uTO1eX/823fmn4FxMcA/BNd164ASkN+TM/6HvZHQ2mnAH2i4/tpuIu/ePwfgOw1C/VArN9dqnkW1bjxv7pGc1rSpTF9zpuRGH5xXgDAWOt6nXlZj472AM75CPC6AMBkgWSIOp3gix3l2ELYIJtxV2blCEwOyTfNBjpfvmjzDP8B5W15wKoGkmgTXGQ/Gg+0Uc37Mdknkn55qOxwzvwXim6BBkEjtzR+AujwEjC4txUaobo5KZyiMFw5DvhUrL4nBLJnyzQukxYmF5u7F4anUhhvbs3eBhWuOQtiFyTaFXg0ojny/PlDmryVqntCWTbWwZGSWC3d/HLCnoY+lEKQqwUewCWCKnn7K5vFhWRdaUwfi/rh2Rjjg90hafUaGcjHIfCVulJVZEES8LF4P3uXBhUPLpart/rJulcWPMke6FJU7lUeusRCeuAtsgWTkbs6/G0SC6O1k4/cFYRm1mRSxbXf55TKGSlCptMFXP448/jj///JMFy6jED5nkyak3lGk+FHIEaCrSJOz15WOBOADOvD4hlbmcJCuPJKMxJ58WkEFhVuYoj3X+KPlsozbt+lRjPDUHMIJbh96afWjtRJKV/IBvroLK+v11gTQyhVnpGSDodDlZbWujllNETvIYpGhrJaDg/sme0/A/3zmB2u9UfGC862tcqpmBPJ2k/JryJOWRlVr0J3GPhUXF52Gs6yks7hDabra3WopK75hnSur4y3XuQVfuAMx8+qV1ioTdQcq1iCwFlMdE5ymVlkPRO0QJwim66corr8Rrr72G4cOHs1Q9jZ3O6f+PPPIIUgFFjVG0FkG1reX3Zs+ezX6nNAHXXFPv3J4KyM+DosGi5Qvv7dDofTDZf6Bqr2hJqh0NrQAyx+18HefoF6Oqjqr49E2qrLqW5GOj4WQcQCEs+o3IFCbsehQT9TtRansSQI+06lONseybj68MT2GtjUqPtu48rZFkNbLyGwzQlKHATVul4esb25d9jbu081BV0NzmdurosnsaNhofw9oDI2j2TlhOA9e+hK/0/2Kla0LI7d9YcXp9ZHxskM7KWleDe7RfSp+bnmavubkF8Iga6Dgf4KgCgqrRREM5l4+VYi8clRXa5eqSrffgav1+lPqeAdA7aePv3srH0NWwE0tryPiSOUnoj133BK4z/IoZNbdTEeKUzlMqGao8kuVRhpKB008oUqk8kuLYOESf0icEp1BItfJI0WGk0FI7mnPqFQQR3bEPet6HSkPLW90G7P8Jl2kOoCPXMLFtsX0LhvCbsJizJ11WP379CW7mfDBSnd5GC5V0psS9HV34XbDp0qtPhcLnlLYEPZrWnyA8kqyOr/sJnXS7scBzVsRj5O/4FbdoZ+IPXex1kFsKwS1Z1IQ463Q3llNu3SZ05zdgJ9fQ/zlebNY6DOU2wQpTYCu3rroC5P3oFjUwmqSqOHlmPatqU4waeKzl0OVK+WajpbmdmxLXdnTkD8CXZUzq+NOKUoSyRp9ZY4x3W6HhRGj1xpTPUyoZqjzOmjUL6c4HH3zAftIZijSjnFrRZFGirSczrbhp2yYFNYePr/gcl+l2Yq6vYUEtg1fattNa4qs3Gy0s/UNdGXPAqNUUIvmFEJXDLEiVLQxZyZVRrH0q5N+7pLb6tLHXQM40IslKJ/qTVxsil/PLtm6Tvt++ZXcCYkH0SsqjqDEoIifefzxOp4zy4y3biu8Nj6FczAXPX8/es9VWSa+cBXr/QpFcY7aIWSjmamCvKUOMuiP6lv+B6zQb0NF1DoCG7jd0bblCDcs1WVAsZUVI1vjT+ZVHrSGzlEetV5obeGN2yucplQxVHsmiSBHXQ4YMUfKwKhFw2uogP85NKVAe5QhHQ05Dy6PJJymPhqzkl9oy+R3d7Xop6jJTsIiShcaQnf7lyESX1FafAjWQMxm9X3nUGSPIQRBQ4tnNfs3pchDSFo/f8qhVJhCE90nH42PcNg6Hw+PFTqEYdXwOpGQ8gL22UnrlzZCXXFQKkb4D7IG9ugy5MZ7n0KrpuEK3AP/YBwA4uWEb7FZYOOm68oqSG/ik9yuP+gxTHnVeaW7QmGKVvEomo2jAzOjRozFlyhQlD6nSDE67pKSRzw+va2HHfFEMKECmHHl6l7CI0mrUnJt8hc4iSlvjHlMG2R29LhjJwZ/a30jxTks80v0UtW1beTTIyqMpvILkrtzJgjdcohadulOVmTRFtjwqpDxqfA5Flceq7D4Y6X4FN1peCrznddSwVydfX+uacGikhbOrriLm82j9Sq8mRLury6UAMdomN2fnIZnoIPmP64yZpTwafNLcoDOribbbEooqj+3atQuU6VOJH0p2SuWfwiU9DcblVx6dnKHl/f08dughpWmw5NYrj7TlkO1XKs1JVoxIRp1z/bWhLe2QKdj8FhQiv6Ch4p3qPhXOr4kQ9a0n6X/MshJFmPx5B/XGhspLMGU7pJKsu9EOxbnpq2xzfuURWoMictIK8pa+SdnUP0GphARZedQ0lKtbK/VLj6065vNoBb/yaGiqPNqqDrDXai4XnD8BdrLGn170K48h2pHOGARp0aBXQHlMdJ5SyVDl8cQTT2RRy6q/QmJQxn2qG0qvzeFx+JVHtLzSLjqkidor8rBk1W9ZWG1WGDl/Gpq85CpGJKMs8kmi37PbI1OoriwLJN+2GPVp1adC/r3HH/jUjK9fayCsrGRliyWtDq881uzdzF4r9R2bZJpIJzi/xQ1akyJy0gWUR4ui+WuD0yIJ/sAtt6ah/DdYDsN73lOwzxy7j6nOrzxqQ7gi2Kv2s9c6TV5Sx5/o80DLSamH9BlmeTT5d34MWXkpn6dUWg5e6VrRFRUVuO6661BZWW9ZUYkNKiX33HPPNalZGwq3Q7IIubiWVx5lq6cdRpiDEl1TRCQhiByMluRu9ZCMtFZpgtfnlSBTqK0uZ682PqtFFIxY+lQoNF7pAcHpwytNrYVwshKDcgga/JG+If++XAqWcZhjjNxoYTif5DbBxxkl21hOshKmieQPGgO5O3/HVP1DuNr+bhPfW28j94k1RafgSe/l2JJ9aMzn0ctKb4h2e2pL2atdm5fU8ed2BfWtTFIeBR/MkO670ZKb8nlKJUMDZi699FLk5eXhvffewyeffIIePXqEzfM4c+ZMJU/d6mhcWD4cPqdfeeRNKfG3pMeODUa0C9pastVKyqOVMyOnBVaQBZCsEeaC9KzkEQpblWR5tPt9tdKpT4VC7/dr0kSwuLUmQsnK5bSy/k6+jCZj+K1ermYnexXzuiGd0SRoeWwsJzmYSK+Q8qixHcAgfhs8QqcmCryga7i1KxcjqHVIbjRxBUGF2C72USYHuuf6gqSOP5fDAblHGTNp29rvzkKYFLA8JjpPqWSo8ign2iZo5bB+/Xr205h03srJNLz+lbibb3nLo9suKW1OGFjEo4zDrzzauCwk24XaJ4go5KRt65yi9M2p1xh3jeRLZddlRoS4zh8MoVEgHUem4rbTMglwQQ+zNvyiyGLfy151hd2Rzmh9ktKkUSA/H3xe6Pz+z5GssrEguKU+5wvOLep3nxAbKbw5/p2PWn/VpvjqZzddGIl2aS7zGpPru+12SoszWpjodZlTXcVtq4He3+5sS9tYWKpIKNpLBUHy2VBpOXz+SScVyZvdgWCdhud2y8qjJvnRdzXV1eggp9Jol97bhMEIVkl5dBsyINKabe1JD21dG1YenQ4rWwyRjShHE155LPBIEbqW9j2Rzmj827W8EkmpvfV1oXURgoliQfQrjw1SCXn852mUS/KG43riqmO6IzeOcqgsgp4LbTHlnNLClEtyGhq3U7ouN3QwZJBxxWGtZsojLaty/FWAVNoGqldqGkKRZhMnTowq4kx0S8qjV9PyWx1u/5a5s5HV02OT/F1d/gjIZGL1O7ST36XWlDmpIjibtB3mMxenXZ8KhVF0tJl0HOFk5bJJioSj0WIpGNpWLRSlRNb5HeMrZddSyNHRfJxJvRvIyZ8zkjBFSGMUE34/2+BUQpxfSeUapdWhKjPtso0w+CvRRIvgcUPvL7JgNDdVejmXtLuiMecldfx5/En4XVxmVVVxWqUxYYMZ2ggLqpaap1RagfJotVqxdOlS/P3338k6RauFtvVzc3Oj2t4PJG9OwG8pXmR/S08jf0vBLj083brkJ421VkpbhNV88qu0KInOIQXMcFnt0q5PhcLkVx5TUcWopQknK6dNUiQcfHjlqHrf1kAUffuS+CuStASJlsNrICf/drJD1MNsUGZDi/NbGcWgqkZ1ohl7xEKIJmUs9i7/zg1hDLHtKifA1iaoPDY3/jxOSfn2MDte5uD0p0aKtKBqyXlKJYOVx+3bt+Oss85Cfn4+hg8fzhKHy1D96IMOOqiBb6RKaIdhilyPxnF4W/YwPOu5COsKjm9xUXpl5bHRlvk2fV+87h2LrYUjk96GbWIJrnffjq/zrkYmMVN7LF72nA9Xx8PTrk+FYoz3vzjS+Rq07fqitRNOVg5Bi7VCN+zThvetLa1z4WffCPzDD4MhzX3XXtVMwHXuO+ApGZawnESdGVO8p+Mj34kN8jImgmxlFIMsox/lXIujXa9hT89xipyDKsgEMkOECFT5WXsi/uO5EJ72g5M6/mpyeuNk1yQ8ZHoImURFVj/Wh94zTkiLeUql5VB0dtu5cyeOOOIIlq6HFMj9+/dj/vz5gc8PP/xwlJeX4/PPP8eoUaOUPHWbZbuhP6b49LimsEeLn9spaLFbLIK1UdDHOu0AfOq14LZODevEJoM9Lgt+E0bAWJw5aXqI371Dsc3XF192HY50x+MTUOGlB7gJWaYMSiOiMLvzR+BG93MY3jEf4ZZqW8WOuMlzO4aU5DUqdJd+LPb1RpXQDffkJZ6lwGUowLPeS9jvFwflZUwEXt6iDoqslnM/WhTyr3M5JMujk4KgQmy7/iYOxy7fITih5BAkE7uoxwaxKzhDZln2q/lc/C4Mx6CgPL8qbQNFLY+PPfYYqqqq8Ndff+Gbb75hScOD0Wq1OPbYY5kFUkUZHB5pMjUrNGHHwrqO5+IY16v4uvjWBu/XOKSIx3ic12Ol3Cr5bRVntXBpxgQpr5PaXZSd/u2WK300Ttjc1rC6/NWUImzL7qmWFJ5O+emvZLu8UoBjrH6CoXD65yFCKcujXCubC9pWt/n7olmvjN3D5fZgi9ABu7nQi886p3TPc4zJtSI7Pf57oZDsWgpZPlkKuSqoZA6K3vHffvsN55xzDo466qiw3+nWrRv+/PNPJU/bprHUbcUgbjvy0PKl+exu+WHacMIz1m5HV64a+frYqz3ESmHpvziN34Ue2sxJE+F0e3CwZyXKuRwUWdLfMdxRU4pntW/DymVBrz0dbRWbq/kH5YFK8gET0Skv/ZXHk4S/IfICjAJZvxMLcnHYatEJZXBrLIoETgTXnA6ulX1P7XMo0O+HvuYFACckfI5acxeMdb/E7ldjkwZVSuvvWo0azogsnYhkoi9fg1s134HzkFvI0UjnBdSIZ/6AQctj/gMnQF+6EmP5eSgEbesfkermqWSq8khVZbp3j5zbjAakmj0+Mnq9Hvfffz97bY6T9k3BfYa/Mb/yQQDDU2KRamwFuKb8ebxoWI8VNa8D6JXUNhxT8TVu1S/EcidtnR+HTKCybB++0D/N/Kw4w1Vp16ca46ouxcXaWahG5ijoyZDVQRvewJ/6qVhdR/52of0Ez9jwIO42LMJC+xMABiCdXRGe1LyHHK0ddc7LgDgWnw3ktGU25hlvw3KQ8nOBsspjkC9iT2E7uvN7sNWfUzJR5G1wo66pwut0efCF7gl/wYNzyf6YtPFnrliDO3XfYLlzBID7kK6QhZnmffrRa3h02PULXtV/hNmOCwGMS+k8pZLB29ZUTWbTpk0Rv7Nq1Sp07dpVydO2OkjBrqmpiapGeC2XxfwORXPL5wscvvm/+EH/CIbZ5jQJLLCJBhiyk9+m9WIXLBT6QVuU3jn1gqmurmZbZXv4EnAaXdr1qcZQCcWXPOfjS+1ZaAuEk5XBsQ89+f3I9ucVDYXZVQ4D50VWbkHab1nPEw7GXN/B0MVZGSRYTh6PG05RB4+CZVK1cs3pIMvjk9xEXO2+C75iZRRzu3+7PZQ7htVay8ZpmZgLS3Z+UsdfpbELPvMej/WW9PaBlt0T9FoePM+hTNcB83wHo8bSI+XzlEoGK4/k4zht2jSsXLky5OeUtoe2rE877TQlT9vq8Hg8mDx5MnttjtezbmN+h9U9zkBLk2/bhiH8FuSivkQVcSUew8Gu98F3PybpbZjkHocL3Y+B75H8cynFXq49TnC/hBsL3knLPtWYak0+XvOdi2/MykS4pjvhZDWj6HKc73oUWzqEn7+u4p/G0c5XoO2V3lZwl8eHiZ47cKnnIehzOyQsp/2dT0F/14e4z/ykYm3Uy8qjoT5590JfX8wUDoUuS5nKTFk7Z2O6/n7can+jyWc1gpGN0xO4t8FpDUkdf7uyBuFB7zX4p0gZq22y/WSN/gpL8/LOwiWeh7CxM1lmUztPqWSw8vjwww/DZDJh5MiReOaZZ7B582b2/vTp0/HII4/glFNOQVFREe655x4lT9umkZ34UxEw80vhlcwKcKC43sdVEETUygEzZn3SV8G1foftoqw03uZY8Bbw59NA+aYGQT5p3eYg7C6/e0Ibd4rfIxZjsdgfYm7onRPq+/tsAvagGEWF6W95DLYgKeX/bFKwj/ykPZGl/0F+vbzdQe1WBFspBvA7USJKSfuDqfOXOsz2lz5sEaUsxPZ5OuG2VeFUfgFGalY3eP5kGdLfd1tFWRR9GpC/IwXNjB8/nimLlOiTzM9nnHEGe6XtaorC7tAhvZPnZhI2d+qi3TZre2KmYMZxuV0C71ndXgj+HYdkR1uX1znAQaDKYkmPhkyE0r/eRjv7Jmw0HIy+RX2ClMf0j7QmPHVl6M/tRKfMCgRNXmRpmL5WZXfD6+/8hRZDRmw/UuCDksdTKtKa+Eg8HaVeF34ukPzoRUHA+ZgBB6+HHsey1FGJsiPvcPzX/QAGdu6MQY0+kxWj7BaYWwRnLdvBsWjqo9bTEbFyBybrX0G5QNv4d8HazJhQab0ofscplyP5Pf70009YsGABC6LJyclh71PuR9URNjqildNL9oeg1TuQ5fiAquqiJbG5mj4w6kp34Tv9o6hAPoy65Ebm1u5eh42GCdguloDjTkK6IrikGuAVHume9t/8Dn7RT8cu+3iARSm2DPGOvcJdv+JXw1NYWktRoG0j2jqUrA6v+B6dNFa040JbHqt2b8BLujewX9sl7aPSfTV7scEwAXamgO1KWE5FW77DO7qvsd1N+XuPCqtgknId7UJXTkMmzy8ulwPP6t5lv9dx90IJKrgCzBMGon1Opyaf6XfMwXT9Y9jtohyPI5M6/obveBu3GD/D/AOUK7PpFnq64BK1zMfco89DEYC7d07EJMNurKp9jXKpKHIOVUfIDJKyXKB8jpSyh36igXwkly9fjssvvzwZzck4DAYDHnjggai+20/Yimzegb0p2O44tOZ3FPBW5HL1EdWO6v0Yxm9GORIr5xUNtoo90HE+5n9DMktXjIJUuk1nlhLpWqzbcRC/AzZeej/d+lRjRH8lIV9QmbjWTDhZnWf9DIW6KqzA+SH/zr5/E87TzMVWLnLGiXTA43LCwHngg0YROZmrN+IwzTLMEEJnV6ixuTHtxSuQz1lx9O2fITenmch9UURHz07UUfJurbSt7nZRBXsJvdGscMaIpnIQ6/ZjAL8Lglic9PHHef1BWEF1vNORKksPXOV+DAOLc/ETzWW+WuRxNhgNxpTPUyotS1o4WHz//fe48sorU92MtEEQBOYvSq+R8PkEmCBtgRotLV+ZYELtW/g//WTk+SoC7zlrpZrNVj757XFV72evdXxus7JKJYG60BYp1YfRJclLm9Mu7fpUKES3VIXDp6sPXGjNhJSVKCJblCzIlrzQyoSrWqqzbtUrE8yRTDwu6Z66Ob0ichL9dagFbeit5LXL5uAS8WecJvyFDX9/3Xz7PC78prsb/xhvDYwfj93fZlEDvV6ZxWJh5RJcpJmJnh7JPz9U+VWv1pL08cd7pXkcuvRWHuVk5rJvpsF/b/SW3JTPUyptUHlUaQhFmn366afNRpzZHTZoOWmQmVNQHkqe1PWmekXRba1krw5N8pVHb+0B9lrq0qVvdJ7Pixpko040wWiRrLEWjyQjY25J2vWpUHBu6SEqthHlMZSsRLcVen9uwey80Eq/r2Yfe3UaErdUJYuyOherAOVx+hUy6JWRk195RFAd6mAc25cEfq/es7HZYzvtNlSJWSz9j9FiaaDwuqBn/vRK0Kd0Bp7TvYuDahqmGyN8/vMJQeURkzX+eH9kOZfmlkeXV86LKVlqjaLUbqN/YZzKeUqlZVG9XDMYh60OsopmMLdwAmfBBz2kAW4w1yuKXr/y6NImX5nl7VKEZC3SWKnRaHGM5w24fQL+8VuscoUq9mouzIzAMc5ja1PKYyjqqspYimjy+crNDd23Oau0mPGZW77aU7Rc9Pa/2FxqxQsjbDiMHta8MhH/gW3XMMojb5Wssl96R+FT9+lozkPZobFghGsKKBB8i97YQJkj5VGppalcPzu4io2M6D8fFFAem22HT7Y8pndlonY7fsYiwzPYWHU4IHwJM6T7blLI8qiSOajKYwbjsNZIr9DD1ELJpgP4tzIJY5DiKtglxcitT/5kondIW+S2NFYeKUiAFEc5ItHt8SFfrAGFiOcWNXXST0c0fuWRM7SNCjOhsFVLyiNZkduFqausc/jTvWS3nEU5Vh6vewJavR3lrKoM4OUMiiphXBjlR+OQFpX7UYB1+2rZuJCtV6FwuoVAsIxsZfS4HAlvtTdpt8/fbn2IOcTTcsqjxq888mmuPMJZg2KuBnvhgOC2BbYuzdnKWB5VMgd12zoNocmyuLi42a0Zt5Xq6AL2BOvSxoPsB0cl9szBVk+n1CafIfnKo8EtPZB8xgLFtrGURk73QVj0WlRWlkLPSVs/OS1oeYy2T4VC67W3KeUxlKzs1ZJiWMeHl4HJJS1mdHnpa1EeKKzHEfw6aEVJWfHwBkXkxPlLCXIhLHiE3iWN1QoxGx6fiDV7a6OLtA4KZPG5pXN4OOUWyhpfeMujrBCLoRRLhcefRpDuh8ZvZU1XRLc0FwgaI+z+5w89A7IU8rlPZJ5SaVlUy2MaQqkKbrzxxma/57JJg9fBtbzy6HZYQY8dOwwNkkfzTsnyKBqTH21t8kqW14Ejjk3b9A6u3Svwjf5x7OI6QsOfjtqyvSC7VB3MyNab0q5PhULrkx4YGmPbUB5DycpVJymGdk34RVGOVwqEMuWnp/Io+ITANqPG/2z2JbBtHSwnuQ61JozyaPJI88KJmmUYp5kN29/nAN2kutGhEEvX4RPdM6gUO9Jfsfe8HukcXiinPAbaHVQ/W0bjXzTxCiiPzY0/bUB5TO+MBvWBUaQ81rJq9xQDb1Eov2ci85RKy6JaHtMQn8+HpUuXstdIeB2S8uTUtPyE47RLkacOUh6DtvF0bqlNnCmxWrDRYPZJ1ovSanuzskoVnur9OIzfiIP57ez/tkrJ96uWT75yHU+fCoU+oDy2fER/KgglK3edpBg6tWG250QR+X5f1uyizkhHbHYrS21FaCBtC/s0BkXk1JzymOWT5oW8bDMO5nfAtG9h5GPXleIYzRoMFDfUv+d2s1cvr5zyqPNbHkMtjGSLOx9UHjFZ408ruDPD8uhXHkWdCU6rNP/aOaNilsJE5imVlkVVHtMQr9fLkqzTa8TvOaTB64ywlZYsXEHKoyaovJneI7VJm5V85THLnzpl2ar1zcoqVZRl9cX17tvxvnFCIA8mYdXGmNBdEFD+44N44ou/UVrnD05IQp8KhV6QHhg6U9vwawolK29dKXv1GEL3a1tdFcycZD0qKAmdRDzV2OuknQqCE6Vr8yWwbR0sp8C2awgLHmEWJUWspu+FmOi+DY/6rop4bDk4xsPXK1M+v+XRp6DPo96/fa8zNlUQtfKWtgLKY3PjTydGll+6wPmVR4oKd9j9zx9OuR2UROYplZZFVR4zGNGvPLoVyEMWz7Y14eIarpSNXqlN+iyqP5A8vF4fckTpAeNV0AdKaaq4PPwmjMC6rMPZ/321khLiMsSmPO756WkULXsd/Va/iB+XSdbLlsLoT8mkC4qqb2sEIqktoSOpqw5IVVqsogmWrPRUsh1+HzUrVZXx5xUk3zUl0PtTzWhDKGE+QQxsl3c/aDh+FQ/HsmozKvxlOkPhddmb+GQKsvKooOVRbrc+RLvlz1rC4q4XJcujzpDeATP1UfVmuP0GBBef3m1WacXKI9XEHjky8fJPbQ3RJSlqXm3LWx49YZRHiyBNKIac5CZKrq2pCuS49KWx627j+riiTfKd85qil4+zYheKllH5L6CuaDBG9ChITZLzNmJ5DIXOISn9XFboSOq68j3stZLPT1tnfzk7g518pP1KgJjAtnUoC54+hJXO4fYGlMeiwgL0Kpbmq+W76i2h4SyP3gaWR5filkejv116U9M51OC3uIdSiJVGD1l5THPLo989gdeb4HFIc72HT+82q7Ri5XHChAmYNWtWqpuRNtDDp1evXs0+hER/zWSfLgXKo7/6glvTcNWZJUjvm5OtPFZJ0a9O6NCjd/+0fWAbSldgLP8P+nKSZYp3SL5zgil6y+y2qc/CADeWcwMw/vqHMbhLXtL6VBNEESZ/ImC5Qk5rJ5SszM1EUjv8vqwxuyO0IHKAHW0zcn4rnphAUupgOQW2f01NFS27zRpY6FFO2JPa1+EmzQ9wzX877LEFf1SvL8gySsVNKNl+4zknXkRRhEVeGIVwszH4+71OgUCx5safIUMsj3J0ukZvgldWHsNUFYqHuOcplRZHUZPNVVdF9mMheJ5HTk4O+vXrhzPOOAOdOmVGrruWhCLOLr300ma/t8U8BAu9Z6N9weE4Ei2LXLrLE7Rl4fH68KHvROTBhtMKKUoyeVTBgufct6NzFodHopBVqui0axpe1X+G2faLAJyPeboj8a9Hj2Edj47q72n7rvOOH9jvpUNuwRCTPql9KtSW42j3y8xy9EWaRhErTShZHRDzYBILYSroEvJvDgg5+MU3AmJBfxyE9MQrZ2fQZGNF9rGYtkuHw0tGYIgCcprGHwveY0N/S37ItDv/9Z6LPI0bV+izMKawHMN0X2Hz7u4QxYdCKgrBKWFkNnU4E+MW9MDJvdtjBBLH7XEH/FQNWU0XZJ8KJ6JAqMQZhd0SPlek8UdK7BWe+2CECy/mpffzMJCP0mDGdv0gfOW5Hr0698RghY4f7zylkuHK4wcffBCYCGhANIY+C37/lltuwaOPPoqHH35YyWZkPOQsPHfuXBxzzDHQasPfotXGYfjMW4Tb2/dBS+P2+vxWgHpLQ63Tixe849nv4/OSa3mscBuYL+Gg7BzMnj27WVnJCIII6qIttbLVuKStQp9Bejj9LRyC1b6ueLcr1fdonr+21uE/rkdxgWEBLj7lgqT3qcY4vAJ2i1JlHLNRmS3OdCeUrG7w3oU6lxd/9Bwe8m9W6gZhsud2XNG9O05HeiLY5epP2dih7YnvfAb0LeyviJwe9V0Lq8eL2TlNLepWQYf/es9HO5MBV/Aa9DvsBOBfoIdvB7bs3o/eXZouSkLVynZ7JeulXqtMWhhbbTVLN0ZYshsqj/ScettzMhneca4CymOk8ecVRCwS+rHfjSG2z9MJrezbqjdjH98R3/iOw0UFygWIxTtPqWT4tvWWLVuYNbFdu3Z49tln8ddff2H9+vXslf7fvn17jB07FgsWLMCUKVPQsWNHPPbYY/jyyy+VbEbGQ2kKSGbNpSuw+/3pLGEqXiSTdZ3Ox0DXu/iw5MHAe1V2qVxhjlHbIAI7GVQ7/Ocy6aKSFTFlzhb0e2Q6Ln13Aatw0RJo/amL5LyXVTap3QWW6CyI3yzZjQ1iV+w77F6YDfqk96nG2N1SHyNd26BNCy+XpNNYVtRX6pySHIqzjWFrRkufp6+CLfqrP7l0uXA2qlGciJzogS8n9TYHJfWWsbulzyz+fLCWoi4o05ZAw4lYPvu70Af32Jtsq7v8yqNS/dBmtTKLcrWYBY2u4X1zegSmOErXlPj8Gmn8Bc9FBl16jzGdP6peZzTD6vI08OdWgnjnKZWWR1Gtg5RAUgxXrFjBFEWZvn374thjj8UVV1yBIUOGMP/Ge++9F6eeeioOOuggvPHGGxg3bpySTWkTWKzb0Z2rQI625S2PNr/iGvywqKutQlfuALJMkqUqmfDl63EGPx8duUP8FbYjs6XMiknT10MQgXmbK/DJvztwzbE9k95OnT91EW+WlMduthWwcCYUGpt/SFTb3Zi5TgrUOG9YanIHuit3437tZ6hlgSDpalNLLqW1/q1NLc8WRqGorakEByG9lUeHpDx6DXkosa7DKH478j1kKeye0HE9Hi/Mgg1O6GEMoTw6bbXoze1Ge019sJG9z1hg3RQUbf4GFdZrUJjVUG68rDwGlQbsvft7fKT7AZU1JwMKbJRWa4twpusNlOQYyRDaALvLjX7cTlYEwaTlkp4z9wrNryztmUF7GtKZ+gj0LGTvWotR/Hp0FGn3aUCqm6bSwii6zHn33Xdx4YUXNlAcgykpKcEFF1yAt9+WHKXJ35EslaRsqsTOVQeexWzDXehWu7jFxVfrt/zlmurTZnA75mGO4Q684nk86ecv2fcn/qd/DSfWSf6AzbF52st4VfsKhnCb0Z/bCevcN0O6ViiNQU5dZClgD6SP+Sfwu+E+FGokZ/NIrP11Cp7h3sB5xbtxUMfUBKt4K3fhBu00XMz/hraKfeMszNHfhlcMb4Z1d3ho763YYJiAPo70ncu2aXvgW98xqMofhJOrv8AH+hfQtWxOwsd1lW/HKuM1WGa4DuYQlkzDvsX4w3AvnrE9Fnivy+hr2OuxWIbXvviR+daGKg0IXb1bTI5tG0ZqVqGdW4psT5Q6pydQc74xjroq/Ga4H38b7ggkVE8WnrpyPK77CE9q692+koIv8dyJU8Rz8JTnUvDF/TD8wNesDx1SNVOR5qm0Ycvj7t27YTBEXnkbjUb2PZmuXbvC6Yw96XFrhoKKhg4dyl4j4RD1qBVN0JlbXrE4dMv/8JFuGcpc9BA4RGqPwwGraIRLk/y8aJVcAf4VBqA2qzeG9owsK49PQK8dX6O3Zif69R2APls+gNOpw8bdd6Jfl9CpV5TC5JOURGNOISorq+AUO6AAdcjPDZ0vMJjcDd/gKO0ydCoe2mJ9KsD+1UDNblidwBTv6eBNOZAe962fxrJyHNiC/nwZKrXhFf5coYrVLM/Ob/6+poq5+pH42dMHj3c7CO49K7BC6Akhq13CcnL50+o4YUCWpmn/cnk8qBSz4NDUz1N8u36o7n4a8rb/grN3Pof/TOuDB8bW93PenxIGQRVrVuaPwRc7sjGoeASOQuKQj3a4bVeX045yMYfd0xyNLqnjzyVq8ZPvCGg1GpyK5LFufx1zITi0R3w5eGmx/Z17BNu9ua6wKw5wxVgp9IA3S7ngyJjnKZWUoegdIkviDz/8EFYZpPfp8+AI69LSUuTnJ78aSSah0+mYbyi9RuJmw9MY5HoXQlclptLYKKlbw6wAhVz9A3Vt3igc4noPb3d7Mennn59zMsa7H8Ha7pc3K6v5m8txr+sqfMCdje7nPIZSbQcYOQ92Lvo56e20+FMXmXKKUOkzYIz7RZxm+BCcVt9sfsgXbKfiLe/p6HjUuBbrUzJV894BPh+HXZtW4VnvJfjafDHaCo1ltdhyLM51PY7ZHa8N+X2vT8AI1+s40vkacjuna6w1UGmT0sHkW/R413glznI/jepupyYsJ2vuAPRxfoRzNVIu0sZsyzsSw1xT8GqX/2vwft5Zk+DW52Gp7jBccHivBp9p/JZHLkh53GXog++FY1GVezCUwLJrNr7SP4GrnR82+axWW4jDXG/iVOMnipwr0viz6Qpxi+dWPK6/E4oj+Nji+T+/rscZr8/H3d+sgsvv7xor5HMqG4hNeg0+M1+Cse5nUN7zLMWaG+s8pdJKlMerr76aBc1QpNTUqVNRUSHltKNX+j+9v3Xr1gYpff7++28MHqxUoH/rwOPxMHnRayRkJ34lHZaj5ZusS3Cn+wbYSg5r4KNH5FqMLZZ826zjm5XVb2sPYKnYFxsG3gVdVgHK2klpcsQd/yS3kV4XTJD85bLzilDhf3hHEyzz98YyzPYegs9zr0W3Xge1WJ+SWVWbheVCTyyuMgUeFm2FxrLaWqdl/UfoeGjI79N9dYtaHOAKUZDT8tWeooWz7ocOXuSZ9QEFIpHgE1lONXYXPNBCDFOJRQ6YaRJ4kt8N+tuX4eL730Tv9g13T5brh+EL7yg483oH3nNRokcWVKJMX+Rrd2MEvwFdfVIO1mAcgTYrc65I46/+Xig8xkQRwodj8c1r92Hy7E3MNWBAxxzYXfEpjw6XB8fwqzCM2wizRgzIyKJgwGas85RKK1EeKQiGcjRRYfNzzjmHRV3TCoJe6f/0/kUXXYT777+fff/AgQM4/fTTcccddyjZjIxHEAQsW7aMvUanPLb8Km2h2B/fCSOhL6oPOqn2R1vnBflBJgurs155jCQrSs0zY61UWu7kg6UtanNvSXksqVmRVL9Hl9WfEFzkkJtfhKoYlMdZG6RAmTED2iviBxVtn5KZXXQxznY/jQPZB6MjylGobTuuJY1ltbtKCt7onGeKGGldlNWwznu68Ubtzcwvs4NrW33kcgKKmCwnOerWEkaJCGSFMIQ4l7kgZMT3NMPpuN97HRwl9RkdS6yrMYZfggK3VB8+UTZmDWd1tue3G9+0zQorj5HGn9PtZcFWRqUjrbfOBr9jLs6peh+ddDa8cckwvHHJoczyHA8Oex0+0T+H7wyPQwsfbP5MDErJKJ55SiV1KGqy0mg0+Oijj1hU9ccff4yVK1eitraWJQUn6+Ill1yCE044IfB9Cqz5v/9ruJWhEh3Oukp8oXkYdbwZ2fp6mYbihz/+Quk/n6Bg5LU4f5QS6XWBslpJmSjMqp+Ijtj1DkbrlsFrJ8uylLcsWTyw50ZMMuzHetur2BLheys3b8ftjtcx1zACR/U8hb3XaeBoYA4wQNyK3WVV6NIuOVVB6ipLWR65WpiRY9KjaOsPmK5/E9vsowBIta7D0X3jexjJt8cxPQchFcjR9Mfafsf/jG/g39rRACL3s9bKCQfeRzeNEV0toS3Azm3/4GXdG9ivI9/fMUhHRLKCi07wnAhLQUe8bL8Q7fSlcFe+A3Sj/hg/xt3z8X+6d1Hho77atMxs3z3f4VPdT6itOiPgH90ccuqfYIv3qLLPcIf+b/xbRaPqGCTKXhRjunA4Ohf1aPKZYf9ifKl/EpWOfoqcKxKW3X9hm/EabLD1BbBIseNuM/TDa56JLMH/45eMxpiDQgeyRovT6cA6oSvMvBvdtEa8ar0bOfpquOto2z+6ogcqrYek7Hcef/zx7EdFeShCkCwdemsphvGb4RR10EdI3kyr2kF/X4+e3D78OnMbakZMR65Zl3B1mWOtv2IvX4DOufX3uZNtDYZolmOxKOU2TCZmXx2KuVps10deRe9dNBUXa//Ecfrt0OseYO/pi7rji9xrsFPbHWP9W2HJwF61j71WcXnI4zlo6/ZgAL8LNlGySIbjwIH9uNH9AW7UA9aSK5EKrH6rglyiLbjSR1uCKp1c4f4c0AE7s8P4pO1fjXM1c7GkBaL346XaxWGY633kw4r57UoAsRSd+DLsUsBoZKjeiHM087DAF/pgubZtOFqzBou90SXGJ/SuSmTB3SBNDi9Ilnu+UU7GeIm0c8Nb9+Fwfj02eJO/i+JzSf6dIqfs4/j9JZX4zncsju/fLmHFkbDyORjrnoQOuUbM5zi0F8tQzFdjdwryDKukHvWupyFkwT3uuOPYa2OWrliOb378AR1zDSBVyMaZYYywVbZ6yRwcxu3DJqETbvXcjJc3l+GMQYlFxx3YsQHP66agVjQjK1tyQSCM/rQ05FeYbIyCtJVozMoNKyv2+Z557LWm00gEwrQ4DuPveCnpbXRWSdtrNRp/QJhLko+gjxwdv2XF36Cpfi/fAR0LOiS9T4Xi9u034X59GdZ5JKuLqGD92nQnWFbVezaB7h5lEWhfEnrcCDXSfXa1QH7TeNlb44AIHnxWEQw6LfRUS5mjWsqWhOWEXTPY/73a0NVReK80VqGP/lxTbLeh2FiFTXXTySFAOo4gbY9zWmWUx04V/+J0fhdKRLrDDXPlCi4p0M2rqQ/YSdb487kl5dHHx18EoDFUjef7pVJKo6uObmpZjQeb31eStqlFueY9BxgtuVCKWOcplVamPO7fvx9LlixBdXV12Ezxl19+eTJO3SqgskyjRoXeStriKcJPwlG40rIXcEjKY6RCgLZNkvK0Q2wHN3T4Z0tFQsojTRpr5k9nitheXTf0D1JcLT5JOTLmJP8haoJkEbNk52PgoaGjL8kRvYdtJZvg8gbQtmvLYrfbmNJh10nKNO+SItNFY+TJ1rFd2rqqyCV/w+T3qVDkew+giK/AZlIyWLLmtqM8Bsuqyq887uPaoY8u9HTJ2yWfWtGcvml69lVL46Uk18jGsAHuQKWQROW05F2pSoxPF1p51HqkVD6cPvrSe/pA++oVTo0oKY+8Thkr+KiKz3CLfhmW2GmUNcxYIbgkhder0KIp0vgT3NK98fLKJZjfOutDXOxdgKVZR+CoXoWK5sUkS62LEsP7gwGNFuVSs8U6T6m0EuWRUvFce+21+OKLL8I6vNLERQEAqvIYHrfbja+++oolXKdC8cHsrpJWqcV6aXJ18pFX85qKDey1IqsvUAWs2ZPYlvKcXz7H8dteYgqZu/ORDT7LEiXlyJQbXx6xqBF8gShmrcGETz75JKSstm3biv7cPgjg0GHgcWhplhScjrNdPXBm33bs0aT1V5vhmlEesytWsVexY+L5HaPpU6Ew+S275Bgv/dJ2lMdgWdlLt7H3qvTh1Xido5y9cjnNbw1uWjYHuqk3wMGZobv4E/TuHX9t6VjIXvYW3tTNwSbtWfD4joYxhHIWr5z6OaQ5hTOEViK0PqkvaaI8Fz0jDnW/zSyNf7Wvj7bW+LetG5cSjBeTV2q3PjvEfOW2NamtnazxJ/ots4JGOeVRu/JTPKBbhO/bdwSvUBAX7eLM1D+E/bYBcNjeg5GT3DRMCloeY52nVFqJ8khR1J9++ikrR0hR1Z07d1aLm8cBTZ6U8ihUJLCtbBuzGuRppNWqWxN5Qs63bmavPTq2xxvW/yKnzAmfMCeuqFCH3Y7+ix6ClhOwI+cwDBxfX0mG6tvmiFamVGblJdfy6HLUskAUwmTJCSurqk3z2esubTd0M7V8LtFSf1BRsT99i84jKdeaCEnd6Tq6uiSFP6dX5KAapfpUEwQBFjJr0wTht/agDVkeg2Xlq9zO3rNZ6nPTNsbslnxYDbmRXQx8Xi/MP12HTuI+QAQWfHUbej+YpMo9Xjew+F2gbj+gz8Lhm14CNABvGQOX241sTloU6BOwPMpyOtgilT3kzaHHmM6vPPJhUvk0hupKS8HgOmSb6hUquS8q5fMo75SY85pajDm/tVTQmpM+/kSPS1m/YkFASd1a9mvJAOWCfQRrOXrx++AT28Fhq2EWecokoQnKxdmi85RK61EeacVAtappy7q5SjMq8XHn7tvwnKEcv7uvaVZ5FAUBXbw7mELX+ZCjMWLLq2ywb99fhp4dY99i2/znBxiISpSiEJ1u+gmcoX7SqKupQr5/JZqTH155/HdrBZ6bvh7XHtsj7u1ze52kPHpFHmZT+InLs3c1e63M7oduaHlK/Slc2uVIY8Hgk/yotGEessSe/aXoDEkZ6dg3+gADJRFdtdRlGDp/5XBe33aUx2C0tTvZqy+na9jv5Pgq2au5IHK1ojVzvsUgQQqiIg53/4sNG9ejX1/lrY9bZn2EXvPq/ZFlDP3HwOW0QVbjDAkojzImv/LM54S+fr3gX4hEqTzW+VP/0PrWEhRtrfW7UGj1iStZpJzk0k4JLXZDVAXi5NraMfhpxt0WjyQfQSFfzrq965ENG6tA1neQcgtQn1Na/Pq0ZrjskuLt4AywqNVg2iSKJpYiH8dTTjlFVRyThOhxothXztJtyCnTvGH8jNj9qKpADidNgoX9j8Zk8/W40nMvtlVISk2s6NZJvk2rO50PbZDiSNRVSX5fdtHAtpLD8fPUL/Hwgdvx87cfsRyM8eCwSttNNpigjZBY11QlWfB8xcpUpIiV87Y/gfd0/0Ef7GD/N/qVR70lvPK4e/NK9lrJ5UGflZrKS646yZJEDx+tHOGqoHUhkzDbpVKq+hDpXOQFWr5QzX7PKeoc8VjiUqlayfx247DJOJD9fmDB10gG5Wv/Yq9uUYMvvaMw0zcUL3BXYviQIXA7JKsawekSv69ZXkl5NuSFtrwa/MqjzhSdz6O9Yjem6F7CJMP7DXKcypZHjT5xJavOWgczJ82DuYUligT5xI1X2qEQFbI87l3zN3vdqOmFQgWT1gtOaf4StBa4bH7lEW1zUamisPLYr18/lvg73Vm0aBFOO+005OXlwWKx4IgjjmBW03SBnIbPPPPMJlv+FXs2McXRJhpg4KQ0E4I+/Gq+Yp/kr1WNLBhM2VjVaRz+EgZjR430t7HgttWgp3UZ+73d8AuafG6vkfy+6vjw7aEKB5dVvo7h/EY8irewYb80AcUKbZkQTs4YVlasnQ4pA6S+Y3S55ZRmkGMRjtcsR6FFetiZRTlCPC/s39j2+X1UjcraSiPJqUkbasoC/UYnSA82TaPFQrpSVb6fKXRKyUpOSJ3XsWH5PJm62gro/WOxoH3niMFTvesWsN/zj7gM2wbehqvcd+Nj+xFIBoU1ktX9n6EvoPe178NxwWcYd/OzrMqLx58axkX5hxKwGpF8zjjtVBT7pP5S0KF7yO8Z/eme9BHcNYJxVe3DSZolGI0lDc/nVx6VsDzWHdgeWOyGGo9av/IYS5BPvOOPk5VHrTLKo2v7QvZanistUJRCdEvKo6g3w+2QfnfyppTNUyqpRdE7dM899+CGG27A5s2b0bt3vaNzOjFr1iycfPLJMBqNGD9+PLKzs/Htt99i3Lhx2LVrF+66665UN5GlKRg2bFiT9w9sXMySVuzUdIPG7Y/cjaA81pVKFq8qTRFoeuxSICkAOyv9q+oY2DB/KgZyXuxECQ4a2LRMm6tW2rqyRVAey6qq0ZeXLDkduErMW7caAzrGnlzWbZeu3cmZwsqKSnO1E6SFTE5HSr7bspACc49wMwp9pbi6g3R+i2hj22Sm3PDRj1yF5KPqyA79II6XsHIKgaPWvxDgsqARJOuMpiUsMHHicVqxZf5UeBa8i36OZbgz/794euLFsBi0CcnKY69GLqS+1r5r6K3l6tI9IJWI0lblmMPLaN386TiUc6Gcy0e/IUdDKLHiz7/NyN4nBIIIlcJqrUV333bW1w4ZPhpFnRqmzvI4pfHvgj7gOxyvnLrla2DgPEwJK+kWujCAWXSwtuhN0W1bu6yS5dveKBhQdqHQKaE8+ufGUr4Y3UPIXlYe+QRSGUU7/jifNMY4hZTHnIoV0vE6K+v2EsgWYciFxyEt/F0KK4+xzFMqrcjySAEypJiNGDECTz75JKZNm4Y5c+aE/EkFFNRB0eA8z7M2TJkyBS+99BJWrFjBgnwefPBB7NghTSqphCLO3njjDfba4P1dkuVvn7kvvH6fEytM2FZevw0VjKtCqtlap5eiQPubajCW/wc5u2fH3CbXmp/Z667i48BrGnYbOv++/Xul9vA5YduzYcP6Bv+vWDML8XCgXFJUHZwJy7eX4b+v/q+JrGy1lTD5I0qLOiqriEVDhd2D39wD8blwAjq3L8CGPRWw+LfJ9ti0YWVkrt3KXsXC3i3Sp0Lh8iuPNi4LWp9kFalw8WHbnCoElw2r3rkBnud6ov9fEzHQuRhf+kbDlj8gbsUxWFZ7tq5h/68Ss9GuKLTCX1cm5dKr4cNbkwnXOspXCOwoOAYcz6NXOwsLWqNE1ftqlC39uH3lXBbUVoYCFHWqLx8qs6+8MqA8rt5TE/d9JTkt+eJZ9vsq/WAY9U0Tam8+UMcqnBC7bdH1IY/N7zahqVc26e/0omTh3VXjS7gvOsoky2O1f24Mho7Ne6XjV3r0ivT7cOOPju31K/N1Pk3C56Kk9p3c0hxSPEDZqi86jz+q3piLqqqqwO5PIn0okXlKpRVZHik/E62gaSX9+OOPR1xNh8v/mEz+/PNPFsl15ZVXYsiQIYH3c3NzmeJIZRU//PBDPProo0gVNAir62woKyvDmj3VyMu2oEeRtPrNPiBte02v6ogT+GUsevKvHU5c++JszLp7VOB78nHqSiVn/1pdMfv/wc6lOEf/PyysoJXdTVG3p9buQs8qKV+kt/dJTT4f/eJsXK7ZhFN0wC6nATeFac9b0+bguKDsC7mli7C51Ire7bIafE8ujUeQEtD4OD/NX4lResDj9WDXu5eiRnsUtpVb0a9jvYVlzYb1oEKMNaIFu2oEWJy2BseJ5lyJfKfSJimKHXNN2FvtxLjXZmC537Aw7qM18GJDSBnlO6V7VmPuxv6vVHs6ZmtZn5KjGCMdx2OVlIsyrwkFXDlbYtYs/BRn/6PBD3ef0aTNSsgwGoKPY6/ch6IfL8FA72Zm1dqNdthWNBqDRt6Ik7onFoBCMiJZbVq/BrTsOKBpj+oKe8g2l+7bAfKordYUoGZPTchr21pmRZfyuez36k6jA/d1fO5aFNauw86NReg4ovnAhmhlvXfVX6wI4DbTQbA26kP0+ZvTF+FYA/lD8tj55nl4wHNtk/saDTTmhniWMPmvLzkT7UKc67T/m4mNRmmuv+rz9ajDzpD9Pvi6KiqkbXCPP+k4fX72i9Ow0CBZHst+ehQ3eq+Ks83Suar3bW2wsG48n/2gt7F+/9nyCsxcGno+i6VPy30qOIpYvq7XdHvZXG7fsZz9P5Ex5tgyD8PhQ6mYhz6N0kDJ36mqrsHeOe+jePBJOP6ohunWIiFni7DxWfhz2TqM0QFelwN7wvSheMZ9KDmptAHlkZQuJbdflGb2bMnidtJJDRUggiymxF9/SY7mqUCeTO7RfgFoD8HWdyfgBe94fHTrGSj2laInpXDhgCW+PrhI8yf7m2HcRvyEIxsMUvk4/6dbyialmspS3PTiNHxymhTdXOiV/Lh27N6NvD/uhrl0GezthqJ6zIvo1rlzk+M8oP0Eg7W1qBVNuGOWC98eWv+QoPPmworhnGRVpPyL9P/g9sjf685J55U5kl+LJburA8ojne+sF6fhKs10jNPOxjKhd8NJSRDw6Z+L0YeTrD0+aHA8vxxLcRTsja7/rR9mYoQeqBCzQz4g5Wt7Tvc2hvKbm54rxu88rX0H3fkD2CW2Y9956kgO5/FLIOSOYNdewknWUtree1X3GvtO43t21os/Yb5hL7vH1Qs+xS3zjGHb04fbjU1i56jb/NWtJza5r+Guy2eXlEcRHIycZAEYxG1l37e5TmlynGe0byObc8IGY1wyjKUv0rlMnAeD+a0o4mpRIeZg5fDncdyp49FZw7PjGL+7Ap4wx4nmXNsrJCuKffl3bIas8BhwY5iH+j/LVmK0DnC63CgL089uevkDTDfsh0fUwL70C5y9MIt95zJMQ3/dMvy1fRB2dOwU1fVH0xc/0v/OFJ8DdR5c26jd1OfGaiRFltpzEr+ElV4Mvq/R3o+rX/0Bc42SBcq6dSHOfrF9k3O1g9SXiOe1b+IB73Uh56obNFMxRrOE9em1QnecRIqJUQoYo+8/rX074Od9DL+6SV+MduFJ53pW+zYKOSubG+dXZqFzedP5LBuSNfB0fj4WC/1Ctpna0JPbi61ix2b7dE0Rufo03NanY9IxLJzkg9qeqww7xqKdp4pRza5rhdATvWtd6FGkbfCdp7TvIJ+zY5xmNTb/+gW29l6Inu2yo7r3Jq+kPHp0uRjOSUE5osiF7EN0vvNe/BHv6V9AB64CS4S+UY370pGSJVuljSmPZG1MZzZt2sRe+/RpWIqKKCkpQVZWVuA7oXC5XOxHpra2tsn7tCWu0+ng8XgaJEonXw5yAiZzfPCqit6jz+h9sjg+rXsPr3vPwhP8hzhcux7naf8BptwqfZkDFmoPxZ3arzDfdxBWCT3QG3vY34jiyex8dF75OKTIzPENRB5Xx/7vMUv3pyPKmVVz21tXogBW7EcfDLCuxua3roJw2/fokmdglmH5OLWCCWViLnYJxXhC9xGq606EK1tqN/G07l1UCjn4xHsCsmDHM7p3AJzS4Fo9bhdKUIEZvmEwwoOj+NXoxpfiiw1rIAzpyBYddL7TNAswTxiIU8TFOITbimd1b6O6bjQ7n6NiFx5eOxYf4gTc67kWPbAPPXWSQur1SFYJud1DuU34zncM9PDgFH4RBB0XOA67dzYnLtb8gVe956I/twvP6N6TrtU+hh47gftxjeZnthVKbXpC+wF8Or7Bceocblym+Q2Pe6/EiZrFeET7KTtOybYCvKT/BTMEJzzuY3EePwcvei5AHupwuXYGfHQ/3KMD/YYeJPdpP8cioT9TskfzK5hcaUKmayKXC2rPrdrv8ITncuYz+rnuKXYuuT3U9+g4j2o/wm++4fjaNwqvaP/H7ofdJVXYofNV1znZtfzpG4pvfcfhee1bDY4j2KQHPiVXv8s9ES5o2eeDuS2oFMVAm6k9D2g/xUu+8ciBDf/TvdrgOJSui+RD79F1/eA7Fndov2YPuTr7iXC5tAFlbeNbV8EuGrFDPA5nWOdjy1tXwznxc/Qszmbjie7XE9r38b7vVLym/x9THHcI7bBxzPsYefhwZoXefsCGTW9dCZ3ow0YcgSPr1mLfFuk4fUrymHw27K3ExreuRh6s2CYOxKC69diz5Qo4J36F7oXSQ62mTvYJ1GGJ0Ie9yteFIkuDcZYDO6b5DmfJ1Gk3IPj6qU/T/Tid/xfbhPZwwIDjNSvxDCfd191Fo7ByWw7K6szY8eZt6MSVoz1nQE/bTKz0Xz+1ieYIOs7lmt/ws+8IbBE7swUWjQ06TvD9uErzC2svpeQawm9u0B5Kuky+uKTov+w5D1mcAxO0fzClpEwQAseh+7Hhzaswhl8KF6eBdtusQHt6FGWx49TanbhG+wue8VyMjlw5LtbMRA9+P2ptYwJjg8b8DdqpeM97CpsXTtcsxNOc1O+pT9P8UWO1sz70gnccBvLb0BWl0PDSvOkxtWNtouMM4rfhGc94eKDHndpvcDC3A5VuF5tf6GfT/mpc/OqveFz3IQZyW7FG6IaHvNfgy1tPqr+vVjse1H6C13zn4FfDg9JcyJWjxupg95XGGJ2LZParbzjyBBsO49bjGd27DcYqXfsT2vdY3WhSHGm8vat7Ad43X8TS4bfikNHjmFWW+hktbjWcC+btMwFNP2zaV4U+HSSlmO4F3SMag1N9R2EUvwIH8ztQK4pN5vK9YiEWegfgNH5+yD5GY3yl0AuH8tLzq0rMYu/TNQXP5RuErhivkYwovfm9mLtzEzrlHhx4Pm3cV4UZb94PC3zoxxdgmG0G1rx1BVwTv4ZRkANmLCgTc/CE5zJ04w5gALeLtZvuB7Vbnssv0MzGbqEY2bwDJ/JLIOrQYO6kfjb3zTvhEzVox/fCibZZWLPlZkArWeHleU+Gjkt9T74mmUSeuSrxw4ltyD5MFscZM2YwBTFUQE+nTp1gtVpRU1MTVjl+4oknQiZHpwAcYujQoRg7diymTp2KZcskH0WC6nXStj5VQ6GtcxmKLCMHYfLzIHM98ZNzAN7S/ScwEcjsFoqw+Kg3MHT+zXhCvBk2UY+ufDWyeDfGXj4RnSzA5MmTA9/f5MlHJ3Ene2D9qzmaRSs+hNfYZ3+MXQjNjzdjpncQOnClKOdK0FlTg8OvfQHlm5Y1sMDucuuxzNcNl+r+Rq22pME1FfUZigVv34MFwgCUCRa0560Yx01H8XXfYM6PnwauiejiXY9qwYxNfH/cxX+A3txuPOK5Erfc9iBzHZg0aRJWeDrgZu4THK9ZgWrRgtnCYKzQShGpuUI5buc+wmpfN2xHZ/zJj0QuL03o2XkFuPO2W7B06VL89NNPKPVZsM1XwM7xqvYl/ITRWMrVV2zp3vdgdF7zKnrwB1CDLEzVjGXvDxh6OC4ce0rgPok+J07Fn0yROpJfh1dxJaq4+hQ6R59yNop+noD2XA1T6J7DRLg5Ey7STENf70a87LsYddoSeEQeFYIZF4k/oL9mDyZzEwLHoAnxzMtvxPa3xuMV3zh2rpH67cgXq3D8tU/AfWALuybCJwJXCJ+hJ78fv4tHYj5fv+1Efa/nocdh+ZSb0EPYinzOim/5MzEEa9Dt6vfx7/SvsW+flGeQRv0xvlnowpVhJo5FmaY+zcrpOatxWM3veN93GnZq+we+P9C3BD2vegdTP6rvY8Rgz784W/sPvhTGYL1mUOCaHnjgAfyxYAXm/foDentWoi+/E4vEITiHn4HFIz/F0rl/BI7RWdyDLO9+1p5/uOGwaQobjKcPP/8G2zeuwSJPZ3QXtuF0zSIcwm3EtK6PonSPtNVPjBTmYrsvD3r4sIPrCo9WuleXXHIJG/PPPPscvB43RE8NemM7LJwTw/hN+IC/tME1jRH+wEJfX3whnIj+mlL01FZBq9PjoQcfYAGBVAyB2O7LR7nPgBv4b9FBY8NPXP2uRq9evTBk9Jn4ePIkTPcdhsHa3eitrUY/cSMOufYNfDhtDr7exqMrX4WjNevQQ9zG8vP5tAXYwnVvMEfo2/fCr28+iNO5v1COfPypGYNThd9gvm46fvqo3kdshy8PK92FuEY7HQd0fZvMU0s27cGMbz+u73uiC4N9C6E/4yV2n2R4bx1yxHImx1Jd7wbXdOmll+Krqb/i7yWr2P3QQMR9+u8wXFyM3/u/yO6TzBBhGY7Hv/gEZ6OU79Bk3nv5lddYAJ/Ha8XrulcbtPcD4Qzs0EjXcIh3CU7hF+BF/sYm10TzNc177EnmKYcBHlyjmYY/cAQ2auojjmmOGF/xEn4VDsdV2l+Zgv0w7kCXLl0x8Zor2c6UPO9RFrGDxPU4D7/iG+40bODqZUlzxLFLbmBK30TNj9D489sStbDg46L7UF4hpW/Sew6gPcpxELcDf2hOgo+rt9eceN5lqPhyIpZqG5ZGDDWXH+Wdwxanc3yDMEtLC1yJ4uJijDzrEpRNOR9LfL1wt/Zz9v6rvgtx/A0vNpnLyzwcFnu741/jLez//xUuQ42mOPB8mvzO+6jeQXs5y7EZXTFUsx0dxD34vOAunF/xKrrypXhVvAxFwn6cxf2Fl7jrIfL1vq4TJ04MzOVerwM38l8y31qaGzeLnfANf07guzSehjpmsjG/TyzCfO1I9r4pKxt333E7li9fHpj3gvte8H1K5JlL8Q5333036z85OdFlAlCpR1UeY1AeQ1keu3TpgtLS0kDnS2QVRNbA3e9dxlarJs4Fj8DhF2EESi78L0qMPuS364IKN4/1r52DUfwq5hRPibL/FIbg4Fu/RfdCMzvv2r01gePQw5Fyvf0mDEfnqz5Gnw8HMyvAtGN/BGY/g2LU4HDNBvzjOwgVyEaPG75G//YWtrKTjzOGXwIdfHCIOswWh7LjHNQxl7V7V7ULq185B8fzKwLtmSUMwsG3/YBOObrAtdIqc/PkC3Eyv4RNoA5Bi2+FkfjMdwL+d8s49O+Qw4Jf6Hx9sBsaTkAffi873iLTMbAMPgti3X4MXvsCs6bWwYhD+B1YKfTE454J+PzWU9G3Yz5r98qdFYHr13Fe8KKAX4XD0OmqT1m7ifX7rdjy9qU4V/sPKsVs9sAhOXa99jMM7loYuB+b370KF2j/ZtG05Pg/ncnxk8BxNpTasXvKBejKlbL2LPT1QxlyMUazjB1z2Zm/w9yhDzZOvoi1x8w52XYh3Y++fssSsanciR1vntfovg5m92NASRZbbcv3ozNXhqH8Fqz0dccOlATuB7Osldqx/c0LcBy/EtmcA5t8HbEBndH9hm/Qt9jE7od8nKHcZnTmy7HK1x3bg47zwRdfYO/GJVgjdMUE7QwM4rcyOT/suRLf33UGu6+EfByyKA/XbMIWoQOz+HS5WjoOWR5X7qrCjinj0YPbj0P47Vjg64cK5KDztV+hX3tL0HEuRSdUYJhmM/5lMsxn7Tmkcz4bTyt2VGDnOxfjcG4d6z/5qGX3q+PVX2BAh+zAcfa8d0mgT8/zHYRKOtdVH2NwtyImn2XbSlmb81GHYzRrMN/XH5XIRserPgvcUzrO3vcuxon8UoicJjDG6DhDe7QLWIXk6yeLI+UMdIla/C4cFpAjWUo2ljmw/c3zMZpfCQ4icwWYJQxG9xu+xr5qG679eBm6F5pwU83LrJ+tpN0Ebg9mCsMCx6E5Yt1+K1ZOvhwXa2djr1iAXNgxWxiIbjd8iz5F0sJVbs9IbgVEjmdjVm43HYcUevK/vPDln5iFrv6+XoXv7jwNnXP1geNsePdqjNfOwX4xH9lwBI5zcKc8dpwVOyuw8+2LJcsaBHZls4Qh6HTNl+hfkhUY85smj8Mp/GIIHA+PqGXHoX7fu700f9CYJ7/lI7k1WCn2YqmtZNaMmoLeR57NjnPhq7/jWd07Dcb8Z7eegr4d8lmfXrGjHAUfHI32qIKR86BUzIEHWpResSBwX9ftq8Xedy9iK6FczoG1QleU8FXocvWnGNK9iI2xLaW1gbFKKZg4NncMR5+JXwTG6voDVux5exy6Yx8LSqKKX/vEQozV/MMUyRVjPoPQaTi7F2SZI6vpEl9v7EVR4F4Qu2vcOPfln/G07v3AvaDr+vqusU3mctpGH6VZiaW+XtiD4pB9jCx4p2oWohT5mO0biCETPww5l5eLeazPk+vH730exXHn3xx4Pi3fXo6t71yOc7XzsFTojYO57ZgpDEXJVZ+hxwdD2YJ0+Rk/44pvdrP7cXCj+0EWfmoT3df579yBG3XTmKsORcr/LhzaZJxtfPdqjNPOYZb5dlwN6x9drv4EQ7oXJ93yWF5ezpRvVXlMQbR1z5492Wpg27Ztgf9H80N/kwpoRUSEUw5JGZS/Ewp6GJKSGPwjvy//UCcm6DX4fTlvFXX+4PflrV96n4JjaCKnATQJN+F3cQQe916Fko5d0aPvIcjLy0Wvdtk45PoP4O0xGry5gL0Ouv5d9CzOYoOIjikf5y9hIPaJ+fhDGMb+T+/XaqSgEnfNfjzkuQYUC0lUgf7mavY7tTX4OPRQIIXob3FQ4DjyNZH/yqDr32vQnoHXv8/eD75WCmahdtt6nMy+x/U8DrO63owtYid8v3wvmxjk821FB5jgZIoYKVJHOudg0IK7mOJIuIoPYQ/NuusWs0n0vJwd6FYoXQfJM/j6yeeRJi26Vrnd7D5ajHjFex77mwKuDr/7hrK/yTEbG9yPV73SSpmSrf/sO4zJKPg42SY98+VZL0gVSHI4G77xHcsUxwNiHvodMoxdO90jko3XXAJHj5PY/+l9+Tjkn/Wg51rW5krRwl7pXPQ+XVPw/dgmStZfO4wN7gf1Ofr+Q56rmbJLrBB7smvXcT620ibk41RBeshvFDs1OM5i7mB86DsZx445Cz1u+IrJmV5/uPtM1s/kNsvH2S/mMQWLSpe97jsrcByC5EPfkduzXyxg8so2B40ZvYFdaw2kh3O5mMv+ht6XxxPdL3pvsUgWIIGNETpObpapwXHoWuXjUN+Wj0Njg41Ldq6r2LYeQVvJJHd6Xz6O2aDFfM1xTMGvvxeSfIjG42y2MIiNM3rIBsuR+pB0P65hx6iBmb3S/WH+eMW0aHFDV7cbcwXJQqaBj1nb5XbLcwR9n+4JUYha/CUcwtr9/+2dBZjc5NbH/8m4rEtt695SKlShQAWHFvfiWrj3IsUvbi3f5eKuxSlO0QLFbktpoQYFWuou6zIu+Z7zJtmd3Z1Zncxkdt7f82xnm5mdJCdvkn/Oe4SWNzwei6X94IG53nbT+3SO0fXjvesaHtfj2PJIO84LTZHthWDt99Bytd8wnSckGB4SLsVeZLNrBB0POk6R5zxdC+icF+z5tdcqWq5e97Kc8jFaJg3CYHErfgjJdvBJJvQcMaX2e2jsqec8bTPtAy2nfWLiwWxhDy5+JRKL/n51uG+940rrom2EIMAhuFkcMq2bxpB63Ys8V2HPZ9s+7LKX6p2rtO/0PVvQBQPE7UyI3Rk8Dytt8gyJd/uq2nFGhfaJbVIhlhrkVoHq95DNab8ijwXtV7RreYUypsmzGWuMBWDAjYFL8GjgBPwneCZbHu1abhSCbFaHXed8ZfXuT0aTCUvDg2qPPY1p2ldfCCw0hRjStw8+vG4aekQ5HrTd6rX89ZDsIaUHq2/CI9l4jbx2ko3eDx1S+xkaZzSmPnvzBeakUa976o869tR9isc9l5OkmEc1viHW/2ORrJlyNdaRpq0POKB+rcI9e/YwryOVGUoWJLjoQk5xIStefZoJo48isq1VWOD6+W+z30nqZsX4HoqHojQNkjUfKcHjG8x5gGcHRPc+VKIvNkhFOAwr2bQBTd9Gljhp6ntasz2xPnfuH3uwaNNyvPvrdlx7+IB666NJH7skYcmWXxH87QP02fc1umEf+9vC8adhv27yWugiMz9QP3alJdtNv8+ddQb8T94IM4LIPOYefDRgSKPPvHLtqQg8eT0TX7knPIiPevVr9Bla15atQxCafzAGiTvw75xvqf0N1tlH4xCLqd3HrOFnVnzrAf5cjPGGtbhlUCXWfPMafgv44A9JGDTxRPl7nnoACJcia/Tp+GjicSzbWp3aVL+n+Pm5VFEYmf0PwkfH1gWyl9bI3vWBnTJq7RyNyG1e+8px2M//G67uty/qNm9/5WOg+k84uw3GR6fWD5qnMUdjb6PUFZOxGjvQqdFYJE/MeVNHIrfvPJRajFHto37P31J3HIEVzBvU8HvUzyyXBmIalsINW5R1OWASwuz8KzVbYo771hyzaJ+p2bMR66znwyuZcBmuUf5CwBUB+feG5+L/XXYyMPdmljhSdM7z+Ci3U4vX1XC7m4LWW6E0MCTvZaztIU/T28+vR9l5i9HDbGnTtaHhNmd5avDjwgeRM/AgDMsuaNU2k8hZaLmOPRL8Eh6Iu4Lns22Kti72/zZez2LZed/7PwK7lyBcurl2nBWzCrv0ENePjSl6MGn4XU2hruvPd5YD+5bAmtMVH51b//yJ3B41v/qKZsZh6L3rgPLfYfOXNbIjef2JMMTaY0+evvuDZyHf6MXMjDz0bqaVIq1vzvlHI/zWNayxRe9zn8VHOV0bna97IIenOOFh66LxRmElnA4uHrds2dLk//UGxUDMnj0bX331FSsQHsmCBQtqP5NM6OSigOL59ISnTP219XuiEbDl07UVNl8pvrvuImx671tgDzAgR8R359UvR9HU98SDKQPzMS1jPbq5/8Lnvw/BSaOKGq+v6DBg4mFM+Cz9+nWYbFkYNVb2ijRFS7a7d4ETe8Q8dA7vRVaQRM+YRp/pU5iJEjET+VI58oTKqN9Ly3rnD8Pyr8fhAO/P6OeS4258Q09rdhtavc35DkgTDkf4D4FdlE9ff32997dufgrBS36E35RJGR/IEuQSM5HhFur37HPks89khCrqrXtQ5f8AwYICe/NFhtW/W9X3COCv39Bpzw9RP7M7I59cgXCGq6KOMSqF8vc734KeD4blhvHduRFj0VuJiuePx87d43DdL1Px3Y2HwdSg1mjk92xgN3FgQDbw3fn1x7T6mfUL1gHrga62AL67qvG4RwvPv5Yes2g48rqxV5pmPX10D+A3INPgx6f/nBi1rMn+PQtZiAV5yjsJ5eiU37iGYzzOVyZUzxgLfAjmQY+1Peo0bnuuU423OQvo93CbvoPEUeAJOREmb+pV+GjYwZpdz6J9z96c3mzc2V3basfZzpdfZg+SB/W046fddTZr7bq2Z2axc4NmZGJdg1qzzT9ld6LpJhi8pY0+c/ak4cBPQIHBVXvsK9x+vBg6Ft0ybJjZwh7cw3vSw5sDOahBb4cflijH4pHzJwNvgdXA/XTmGJhMRrz9fF3cIidNioTrnalTp7Jp8zfffJMF46rQNPb999/P3NjnnnsuOjJhu/w0L7iK2cmbkSk/Gdvh0VQoRsNYtR2PB+7ADcZ5+GKR3FIrFnRsxh17IUZNkaea40W1uZC9ukrkgurRqDIoJUPK5GSTWBgPv4PF9xCLxVE48LCToAV9unfD8j6XY4elH7bZBmGLfRg2ZxxAE6Asxmr9J/+F3yz7S0JK5nTTY0H26DL8Ltzvm40PLHciz9ryGYKeE+R9Her/Dbv31SVJqQh22cNg9MmJBA2hsedQPE3OcHX9sbj6beSUrsRlxk8wfWRRVOEY+T3qmG7qRltYKB93e7hxLc1EIZisKGf9aQCbUba1TfIwb2+0baJZnRJRtmNNcV2SkBb0LJTHPHWP2a9rZtJs1BpoG4OCPBXZySEmfJvNBbKYz/HLDRNo/UalJ7zT0L66xkarvC8Gted2OxFt8rgzBuQM6ki6dpEfajKk6tqxWOGWq1lk2xsXgo9FptWIGiUsqqoi+nVoSO8ilrhE9HIG2iSuOckhrRpIUgzECy+8wGo6HnLIIfXaE1JnmQcffBC9eiW+G0lDKHaDstbUWI644pSL4lp8chcR0SrHfhkC8bkotYrc3vD1Oxrvrwvgj13V+H1HJYYVxZ4m1cJWflsnwPs7/OVy7choeE25QHATvBX161Q2ZPgBB2KJ9CV2rluGUVNPhcOqwfFTGHPeHAD0U8eGL59Gv59vQt+9X6IiT84sD3vKY9pJdMpizeStu7B73dX4M9yPlaApzKnf1q4pcroPwW5DV3QJ7cLaxfPR5UQ5frZ2XQ5Z9Jj98vZEw+CQBYtZ6WTBkCR4l80FRaK+FT4MMw9q7G1riGhVplyVLiHRsCjrsoVqEnv+NaDGkIWcUBWCfrnWn03pAx0LKvgP/xZ4S+U2n1phiuhlHvR7YbTYkmqnlhIUTFSgFCF/fLv2tITMwu7sNStUN8YlkxxDLYZ8mDnzhjbbyqCMaWNIHiftRbRmxjxH7MpDHKt1GQoCBiNcFftY+bNe5pbfH+lhxy0o9TOrylAXhFAHdSWiWOAsuFBTUYzCnC66G1McDcQjtSBsCzSobrvtNiSDyZMnY9GiRbjjjjswb948lqE1bNgwPPDAA6y/tR4g+1DijhYF1w0Zsnh0+GXxaFSeQE2hJIhHuomf/RaWzluFXat24dUlW/CfU4cn1FZSRhc2fSNUx/Yq+q3yVH+oOsJDF4MJo0cB9JMEehx4CvDzTeiPbfhekMt/CIp4jGYnU5aceGPz101dlSILJ/nvhtkgYl1rxC95xbpORpftb0BYTyEg9cWjmaataV3B6MlqbHucssC0huT6qYzdq2At/ZMlQNQMPAmFmc33/zXanM2OaVumLIzt1G88gedfQ9ymHCC0HWGfu7bIvhQOQRDloP6GuCyFoK6bwcrYDzvxwKKUHiP8Pk9U8ZhIO7VKPJLHXRHjiSS7QC6iTkXGSbwazFZIar/qoLddtjIpD/nxEo8me1bMcyQjWz5XiaCrDMbMQth2/oQPLXdgQyUlNJ3Q4vX4DHbq5gCfK/qMA1EtOJl4dFeW6nJMcTQQj9GKgkce9MjEGHU5LUumeCQoKeaLL+Res3qE4vuoThbVMGtPLFE0zFny85/aLcCkiEdzODnikUTHuRN64eNVu/Dhyp24fFJf9C2oa1eota1MOd2AbYDZvTfmZySKDSQN5mo8HasnzJkFuD/3XnywKw+3YjVbZlCmiaPZyZatPEgE6zwle5Q+ywUZcnZuaygYNR3Y/gaGun5GpcuHLEfd8bAp484RKQwbYMnIa/QZ37K5oG+hcimnHFRXs68pjC0Y0/ZM2fOYIdWwYs3UbzoR519D/JZcsNbPPllUUxyr210NuzN6r+ygvROLHW3qYScemM114jHAhG1jL3Qi7dRSgqKZiZVwoH6MbyLIyi1gZbgoua66dDeyu/Sm+Wb2nhDwtMtWBovswbOE4yMezYp4tIYbPzxl2K2sOgJVmKipLEF2ZiHr4EVNIlzWulqdLcFncLLjEXDFfmisETOB8F74qkp0OaY4GsQ8fvfdd41+jj32WOZyvvDCCzF37lwm0uiV+knTcirQST2mOcnBnpXPLgzVYaW8gT0jrheltnBAzxxc2Lsc14lv4PaPfkeYKvQmCEe+XGInwx/bqyhmyPFxJo/srdU1/Q5DmZCFKkGedjQFYos1Z57crjI7XOcV2FUhj4Nu2Y09Tc3RedgUuGBHgVCJX755N/pUWFh+aImGLSu/VtAx/G4Iv7/Hfl2ceTTG9m7ZNLrZntnsmHZGJKu4q2LHhWpN2CYLZtFTXhv75a6JfczELPmYGWuaDqFoL0ajgWWBq57HVEGNeQwHEy8eTUYjvsBBmBechAqvUp/QKJ9HYqh90+gmmyweTVJ8MpEtGbmshieVxWq0LoPIMsUJd4V8XVxmPwQH+x/FN4PvbdV6/Ep/8pAntufRZZS3IVij74dzThw9jw0zkymekKq/L1++HEOHDq33HiWiXHXVVTjwwANx/PHHJz2rOV2x9z8Y+/uofSCwNhCCzaEE7EtJ8jwSnnLcWjwLotGLZVuH4Y9dQ1od+9hWsjv3ZK/54VLWziuyHImKOcr0rl6ZeWhfXH1Yf2z8sQwoBqzB2EIkq0AWIuRh8LjdsNnt6LryISyyfIhfwpQpXte9pkUYzdja8yQM2fo6+57ig45GQb4sjjJzZC8ntcQL+L0wRXi2VJyKwGRTtwEPsPlHmEM12CnlYdjEaS32hFqUByJKPomFze5ktR6p6HF18TY4IqbqEolkq4sFpbqdVLLE24R4tBX0Av4GMrxyUoaWUGcQaiUa9CU+frCthJVuJ+FAcrb5Qce1rGPO+2IeKDpQVMZ5e8WjUfU8SvERxZZu+2O870nYTAb8FeV9lyEDCO9jcYhEuVsWrdn21tVGDJkzqCAtwt7YY9pnymKhGOEa/V9fORplWz/66KMsCaWhcFSh2EJ6/+GHW1+KgRMfMqhwrCjfhCmDzurIqg3UT1qnSlsOxNFyjNx/h2xMmHAknPlykHuhUI49lZ4mS6pkBvV/cctxmGE3G2HNkL10tlBsT19GVj78kiyWy/fJ2eamyq0oEkqQbWnbpaHP8TejBg4MwUase+p0VHnlLM2MnHyEFM9aZWn0EIHM7Nzaz3iqSlHym1w+63/SCBw/Uo4nawkWR3azySeJzFxuCtEpi1arrwweQRYaXnfsG212t4HstTC0mwrrarptAaWVnjxtnRqERHmqU0rCtDWRo2Qjl7vkcS+YlOYF4fZtj1nxPFqptlYccCoPyZ5ACKEoMz1exRvoaiAe1f1rKWESj+wLY49pv1np9e1O3gwAJ8nikXq+5uXJF+RY0PuRfSY50cvSUMyHFhXwWfV/5emxzOWHzSl7Hqn1ni/QvnIS7eKQ64DpTyDnjGcTaytKmGElSYIoLY7uzcnMl4VLnlQOf1DbG3a8sGfVnyaOZieK8ytWBFT1PrlGq80j28CQI4vq1mLNLULN9Bdwn3gZznf/EwvWyNOr1NWhUpCnsGrKo4cI2FjmpXyTrKkogbTxO/a7q+hgZLYieafWmy74myw4XGmUbeQt256w868hxgw1BrkcXkGe4vQ3IR47de/H2o1S/UVvmbai1w95/wMxPI+JtFNLCYvqtHVyPI/ZNhMTeJXVSgyrWeleE/a1y1Zqwgx55eUm3u3DZq5LyPJGue4HLfIDmL9KDtW5cM/9+Mh8G/q5f2vVejz2rvgr3APlYvQYXrYuq/ygK3rLdDmmOAkQj9QnkmIcY3mwqAMNvZ+fn5wpolSB7Ee1J7XyBD6C/+Bj861wFW9hgfnrwkVYJfVDjTuJHgZ7LjDqHOr9llhbGc14OesK/Mv/D+x1R193ZufeeCF0LJ4IHo+S6tSYwiMR90LwaLwYPJp5FmLZ6Uv78XggcAb2SLKIzPbLXkFrAfXfaBudRx0DHHA+gjDij111Quhz01F4JjgN5SFrzAebT8WpbLtd1ZUo9G5mcYD9xx3TqvXbM7JYi7VvQyPg8sSeut7uGIaFoZHYF85K6PkXiUXNQg9VY6OpP9tutxKPHI1spw0PYwau8c/ELo+25Uw2iz1Zr20/omd+J9JOrclepzAHmnJPBpdXP4a11gvQfd1c9n/JUYBV4T7YLha1y1aUTHae/0ac5rsNktT+B1iLQcD75jvwhfkmeJS4xkh25k7A3OAR2GCQS2P1Cm7ECHEjcmytS6Lb1PM0HO2fgy+yz475mdL8MXgkeBJWOibqckxxEiAezzrrLPz2228sKWb1ajnbU4WKctPyNWvW4OyzYw8kDlj5oKeffpq9asGQ8HoMFzfBU7GX1cQ7Cf/Fyf67UBOMfpPo6LZa3eU0zA8fiF0xxKNoy8KL9otYh4V9NanROsuZ2wn3Bs/B06HpqPEFY9ppRdcz2Wc2BPIgBf3IDcuehuwuzddTbAo1Y35zSV025wc5F2BO8EzsFWI/PL7ivJBt964NsodjDfpg7JB+rVq3xWrHjNAduDBwA1zh2CLil54X4aLA9VhlHZfQ8y8Se5bSni1cg6fybsbp/tux2zE45udJYP+Qeyo+DB+MjdXalum9w3k7pvvvQ0Vm9O1JpJ1ayudFV+Mg3+NYXSj3pE806jSt4JU9j+5uB+EE/714zHp5u2xltVrxQ3g4lkmDWZ/p9kKzDkOErRgsboPf0zi0ZU+fk3Fn8Hz8KuzHPJP5kjylnFUgh/C0plA4Ua0mEEUh0G0cHgmegkXCAbocU5zoxPXqQ6V7KFnm888/Zx5Gh8PBvJHFxcVwuVzsaeKwww5jNRY5yePN/KuwYkcVjjHKU7ZOqxEuf4iJjHSkk1I7cG9V7HiiwgwLdld6sa8qNTyPFqMBZqPIptmrvQFY7dEfDIpy5Gm1HeVuVOzZjBxIrKZi9+7tK5bfN7QBD5qeQXAfJcrI/eJzHbKQK1e6VUQjh4VUuBDcIFdk2JI5BvubWv9QQ3GflZ4A3P5gk8eU2FednPg4wqmEF2RSLw5lKrGpbSYGds7An7ursG5PFQ4fIiciaYHFKD9M+YJJDGdpJTTmCX8oOeElv/S6BJduOwyndhoEanZqVcZutKnh1mBV9ovw+EO139sebjRchzKvhDuMcsxhtGvi7koPSkrLUCTIs1IZhXKCYUvJUMJN1NjnaOQ75fOwpCZ55yEnyeKRno6ob/Qrr7yCV199lXkht23bxop+jhkzBueccw7OO+88XgA0yWzMOxTfbtuJ8SFbbfD0XvjSVjz2MZXhMHE5rMXkLRgS9TN97W5IwkZUF9PNWs6+1ju9LdVAqBQ11ZUooLCAKPTMEjFI2AbD7nKUZFtBt5HtYlf0s7RvSrRArMEYw49Y7+1Rt8waRpFQDG8F1SisWx5Jl0wzOqMUEzw/AAIg9J3cpvXTmCbxWNOEm6Ywg26QEuuekSwcBT1wpv9WVEgOdFfaLja1zcSwQiP2imtgW/8XMOU6zcVjqsT56mGbLfZsuGBDjV8+hqrI87Vze4wGEScZf4JTqoavejjgaHkCWSyWm8dgp9sDt9TYO98j18aKnRv27UVlsQm0Ntovh7V1yYxdvX9joXkW/Hvp75ZG/UyBw4C+wk4UVmwFMLrN+8NJLHGf96BplfPPP5/9cNqOlgHDGcpUQo0ylTDbdx+KLBuwc/sTQJ9jkW62GlH2BU43P45vi4+g4Iuon7mw8gnsZ/kB3267PmUucM+F70JPyw78tbMn0GlqVDvt5/8NX1puwqY9vVCdKfcNL7H2QusmihuT0X0Y7g+cyWIpHw5LMIgCTih7EbMt8/DTpnMA1J8qVjnB+xEetz6Oz0Jj8WrwSNw+akqb1v9M4N/oZ9mAjVtfBLpPj/qZ7hkCVlkuRfZ2F+DZSlXTa99LVMA+lXJ58t9Xsem9/z3zD9xn+RTrNl4ATLwr5t8Mt5XgQvP9qN7tAKRZrNC+FlxZ8xj6m5dj39ZbgaHRr+d6S2w4oPRTHGt+GyU7DgfwQMLXT7M4BHn7iQzXViyy/At+rxXzLDPa9d03Gt5EJ6EMO8rOBDoXxS1phjKuG9LP4cdq66VAEFi8/Sm2rMyQr6SztWYdZvQVd6O8iW5PnUweLLRcz8r1eIMzdDemONFJq97WqQJV1r/55ps1+/6+wQ04QVwKexlNEwxELqrQVSjD9hQslRAPWxkKB2D1H32wJRi7UoDf0RW7K3KbjN3RG1WGHJQGKuHxuGPaKavbAFRLNuwJZcJevJYt82T3b/e6aXrrudA09vs93iCyqMSHLYdNifubyIAWc3shuE1EsZSNP83DMKgoWkfc5rEIIZZtHS2eS6Vnpzz4YUJQEiFWbIeoiEetz7+GqNP5diHACqyv98Xu/010HzQKGz/vgr+l7pjkqoLNqU1pqxypEj3EYuzzRi/wnGg7tYSsUClL7FjmjT6DoDVd/Fsxx/gcHHtp3L4Aq9mIbkIJ3FL7bfWTOAqmYDUGofUF/KMxUVqB0YYdCFdQvdf6177MvE6oggMuyYLKjbLH0GVpfYiEmN+XJfkYHTl4M8Zncgs6o0yiuqsZ6OSt0d2Y4iRYPIZCIZSUlMDnix7H0KNH9GkrjpyVvmnTJvTp0wdiK7OPW8Koss9xnnkevikhD9BJeLPgGizbVIxznCNj+IM6tq3M+5+CwxbkwRIWcYHSPrMha4ffgpM2TcNUcyGOR2rwQOf/YtGGEjycMxwjYtipc++hGBp4ETSr9m3ZjWyZtah1/cVjxZ7RFCJN11G8E4nHzYMvx+lrD8HUjEJMivF3xv6TMW7pk6zH9uS+Ocxj2RaeKbgFy7aUY1bWOMTqNN4124rjgrdicygfC6192dRcIs6/WPzWfQbu2D4Kh+YOg9yZPDoFWRk4zvIEi9Wcty+IcS3v5tkqPsq7GPdsPAoz8idF9bUny05NsaXzkXhhvQODsocqkbaJJVuqwmHG77HLrXQCyi7CdN898IsWPLFhQ7ts9ZDtSmwv8+B9R+viDmNxlvdtDDCtxfJ9IwCMrP+mIODKwtfxv20eXFv8EUutDTpb15pQLcZPST4ZwdhSw24xYyxeQo0/iG9CGVTzT1djihOduB8dSpg58sgj4XQ60bVrV/Tu3bvRDw0MTmwo0+yNN97QLuPMIt9thIDcBq4iaxDWSH1QHo7PE22q2SrPKXt+SOi4lVglPSZXtDU8gbylsexkMRkxsHMmclCFPpJc77DTfrGkXesYa9mKieLvqKmRx1m2w1qv4HA0RvXvCb9F9oIcM6z1NysVr7M7dkiFqGripkVxZIHc/qysy5YSd+LOvxiEM4uwVuqB4lDTapAebsb0kmNYf9mi3WxBmb0PVkr9UWWI7tlMlp2awpPRGwvDB2Crse2lptqDWWm6YFG6G1mtdvwm9cXaUBFee/3NdtmKusEQ8arHGxDl8zHkjz6l3K+77GkskuTar1Ju3zYlrhF0XW2q/E6Bcn3dXe7S3ZjiJEA8Ujmegw8+GEuWLMERRxzBBsv+++/PfqfajvR/aktIiTOc5GGwyuUkDAFXbdcZgtrzpSOU5WpmyQoSyl3RxWFhpioeUyPbuqF4bIrh3bPRQ9iHzeFO+FvohV7d21YgvCHPhu7A6+bZ8CnFrOVM6qazrak95BuXjMPDpw/HyaOK2t1Bo7kksD5KSaG1e2IX5k4UamvMliSujelFqU0Stqz/Q9OM/XgkeyQSi0lM6jarBeqtinhUt4cIUgZYO6DkGwFheHzxKRcWMjQtHscqDygDBfmhMqv7kDbFVZ5rWIDLhI/gd8fub02zAMSuitTpo57uxHXa+p577mGvS5cuxeDBg5nb+cQTT8Ttt98Oj8eDWbNm4b333sNLL70Uz9Vy2igeTUFZPA7wrcHlhu9QsG88i4FMN1hxavNN6BHeia27FwK5jadtO0sleMd8FyzeIELh5W2eTk0kE2u+xAmmj1Cz5SjgwJtifu64fhacs/IF9Bb34suiazEgTvvmEjNgD3vhq5FvGgWhvXje9CAMNSRKYns39y/KZj/tYYT3V/Qxfof8PbSe2Ok/w7tlYvTfD+HY/60BRnwFZCQvk74wuBP/MHyI/LJOzSZljesq4lfLTGTvqkHAPRkme/zjHgf4fsfFhp9QUEJxo633OiWDbN9unCT+iK7VPZKS2Garbfcqd4Kh0I2LjZ/BIXlRidbVSGzIv2vuxzjrYvy24R5g6L/ava1hRTxK/uiCbVx3O141zcZQkbKgga4DqfhQ6x/MbzDOg1PworJ8FiyOxmWBiFOkr3Gz+T2UrTkaa+MU08lJIc/jokWLMH36dCYcVVRXtc1mwxNPPMGmsm+55ZZ4rrZDihmqjxkt9i4emGzyBc6kZMANdC3DTaa30afsR6SrrZyCD1YhAE/5zqjv52ZlYKy4DsPFjSirqit8rWcKQ8U40PAnsmo2NWmnCfv1x5ahV+K9LrMw4Qw57jEe+JVpMZ+StJJpEXG4YQXGS78hHKWfbjzp71mFy42foEvZL01+bmTPXIwX/2KJDtiwMCHnXyxy/XtwneldTK7+pNnPDujZA17BCqMQxoZf5e2ON/tV/4RbTW+ge0n060Ky7NQUnap/x0PmZ3B05bykrN+eIXseRUFiHj2yzVWGD3CN6X10yrK2y1aSKJfPCsfwFLaWkFEWaVKM78vNzsLgDFlYVth7wpjf+nAzk0GEB/Ksjdcjh69Eo7PFh/3ELbBUbtLdmOIkQDxSW6HIeEaTyVQb78RWJoqYNGkSFi7U5mLXUaBSBVdccYVmJQtMdvkCZ1HEo2DJrDeNnY62chtkb6yvujTq+0ZnAYJKm7ayfTuQCghW5Ubmr27STnShPvr0y3HKZbcjS4lLjAdBg3xzCig3DWdOIXu1Cz7UuGPfSOKBYJaLiohKXG8s9i/KYp07CPdfCxJy/sXC5JC9rbZw8+cheb53Zsuetao1X2qzQUZ5/4VQ9FCOZNmpKURFEBnCyekE5XDK1xGCWmwSXkEWT8cccVi7bKVOM4cD8RGPYcVWCMSeKi449xWEhp2B7HNeb/N6fMr++92xKx9Yc2SvrNW7T3djipMA8VhYWIjy8royE507d8b69evrfcbr9cKdzB7KKQBlqq9YsYK9aoGldmpFPg7UopAwBrW9oevZVn6TLLT8rhhxOaKIckGecqkuSQ3xKNqU4xpwaT6mmhKPIZ8shqzOHFYWh6gul9sgaoVgkfddbOaBiDpg7C08mP1u3PQtEPQnxVaELUNOFHJILTsPjYOOZq/di79nU6TxRjJamhSPybJTUxjMssAySskRjxaTiZW3IdwuOY7Wp3jeNqz7q122qhV7cfI8wqhMWwebiDPsvB8MJz8LdNm/zavxCfJ6/N7Y4zqzUK6+ku3fq7sxxUmAeBwyZAjWrVtX+/+DDjqIdZyhBBrir7/+wjvvvINBgwbFc7UdjmAwiE8++YS9aoFaF84ODwKhcK14tIRcaWuroCIeQ67Y2avVJvnm7i2NPrWtN4x22ZNlDtVoPqaiEVLEo6SIRyr/US3ICSruimJN121QhXOw+Rtt0bBDsE/KhjlYDWz+ISm2IpzZcoKCA15IoeazTQccOJ3Vzewq7cXWv36N+/YIirgQg9HFY7Ls1BQGU3LFI+FRxZJL9jwGRFk8/r7q13bZqs5TGCfxaJK/T2xKPMYxfMXfxLR1p977sddu0h58MP/TWju9tmQL3lq2LaUSFdOFuIrHY489Fj/++CN276b2Y8CNN97IYh4nTpzI4hiGDRuGiooKHvOYZCxKRiDdpKiEgkGJgTQ30QWgoxNW2m5JntgZgR5LPnsNVMqlK/SOWUmiSNZDQchob3SzqxFlUeep1NbzaFLEY0vG9GFDOmNBSJ4C9v/+IVC1E6Ok34CqxB7njKy6Qs3e6ormP5+ZjbV2uYrltiXvxX+DFPEoJGkKuC0YzLIgMidRPHqVhA+1QL1fmbY1ULuWdiAp55PQxDRz28SjtsKstiSQ+hAZBWdBD7ghx/AawnX799i3G3DzB79jRznPwu7Q4vHyyy/Hzp07kZcnXwSHDx/O4huPOuooVqrnsMMOY0+qlIHNSR4mmyoePfAGQjAq/7eF01c8wip76QSv7C2IRsAux+yhei9SAasSQ2dN0nENKzcnyV930/AosaX+muixpfGO6zW3YN/7FTrxW+ah7Hfpr88g/vY2puEbVM67jJ0ficJpt9VOedZUttA+g49jL0U7PkU4FN/yNKJJET3h1KltarDIQsWUTM+jWD/WVxVPRrRzLCleVSFOnkJBFY8hrcWjvJ6gt4mHWEFAsUUufu6QZNFdWuND95rfWQ3aAZ3qYkk5HVA8UoJMp06d6gW7Hnjggfjss8/YlPWXX37JvJOcpqEEhr59+2qWcabGg5mFENwed62HSo2BTEdbiXY5ntHojy0e4ZTLuBjd+5AKWJ2yeLRLbs3HVFRM9kZxh16jPNYCGovH2jHdguQTskmvAw5nLdIsgQqY/if3RH5sX/s77bQG2o4aQU70cVW1zD4DJ58DD8zoLe3A7798F9/tUTyPhlB0IZaUMdUMRotsPzM1Sk4SflUsKZ5HVTzmZtrbZSvBrJxPcRKPovJ9Bo3FY22iTxOeR8KTJZeD6mquYXb6fWcl+ok7cVvGJ3CGkl+HlVMf3v9Hh5D4njFDwwbxingkqAaf2SbHoVmoNlma2sqgiEdLMPZFypgli0erT9t4vXiLR/IwG40mbcdUNEyORjc7v1neJknjPurWDCV+sIUPRNNG9MS80OTa/5OQrOwzjRVmTiRuUT4XvdUts481Iwdrs+WameWL41s/V1SST2J5HjW/TrUBkzJtbUmi59EvyqIs7JM9j0FFPPXrVdQ+W5niK/YMitA2hbSdElZLAjVXYsjWUw4d6RHaxq5Xv+2oxDuhyfix7/WAXT6fOR1YPFKg68MPP4yxY8ciMzMTRqOxXgcaSsP/+++/473aDgXZ8Pvvv9cuEF00sPiSaskGv9cNq0O+YdkoUF+DrM1UsJUqHm2hJspJ5ModTzIC2nrN4oU9QxHEQhBV1VXajqloqJ6NiKSVkEUpZu2pq8qgpXjMhAvBYPPThT3y7FjU+VwsCg1FiZSJmwKX4IgRiW+j6lHEo6+m5fYpPPRi9jqu6its2rolbtsiNpN8ovl1qg1YrLJQoZqtWmSgt4RNtiH4KnQAKo159YpxF+/a2i5bGSzy+WSMk9gTrU52D/BKcv1IrQgrsZqR4SvR6LqfXPVgqPQ3/txZjlXb5bjfYe1sGMBJAfFIXWQmT56M6667Dlu3bmXiMVKMUF/rl19+Ga+++mo8V9vhoDIFP/zwg6blCk7KegfDfC+i0twJNnvdNLbX60tLW5mcstByhGNnBDrzZfGYFy5JCZFtdUTUnKsq03xMNURUai0aIm52klW2s8HXfEJIe7BnyjdukxCCqyb2A0EkFx82AjMC/8Zo3zP4WRqGyQPqElgShd8oH7OAq+XisduII7DFPAA2wY+1798ft7Gplr0xhANJu061FpPVXidu/cnJ0P06/3xcGpiFrVlj61UdqCje0y5bqdPMxnB89svV+yh2D7jZ+m9oiWRqvp4kYeo2An6YkCdUY/GypRA3fYuRwnqM7yFfRzgdWDzef//9WLx4MWbPno09e/bg4ovlJ2KVrKws1tt6wQK5GC8nediUPrqUba2KR8LTRCHXjoxFEY/WJqY5s7vIMTkFQiUqq/QfgyMYjHBJsgDwKi0CE4moTItFekpqY0s1Fo8UihGQ5ClnV4zC7w2ZPKiQ9dQ+c0wRDjevZ90xEk3AJJ+LoVaIR0o2ME+V208Wl5VhwR/xSegyqGIliVPArcViqxOPPm9yYripJZ96bY0ssWMWgnGJ5zTFKYHJpoRkeAMa9wFXptuF5koMGc2oUFrD7l3xGW7Gy/jQcgeGuONfhorTfuJ6dZw3bx7zPN5www0s4DVacDB1oNm2bVs8V8tpxwXO4w+xrMqQJB8rj8adP/SKTSlfZJNiT91bM/PhgizGyndvRirgEuz1as4lksoBJ2O092nca76mdpnBKXvzLAGNxXdE8om3heKROHFkEe48bhAyxeR44IOW7DZN63cdexLeGvkGdh54Dw4ZIJeUai9GsyXpmcutxWK2IqxcyygkJxnYVPHok8WipIhHE5qv3dkUBquSDBRRyiYe2+nRuKJAwJKHHVJ+7fnYFBkjjmevU8UVWCP1hteYCaHnBE23j9M26gIS4wCJwubK8GRkZLA2hpzYUBvHkSNHsletOLfqBVxqWgdv8U2A0A1bhW4Ih8MQfKlzo4inrWx53XBr4AJUSXbMCYRgN0c5NQQBb1lPx87qMI7wW9Eb+ucr81R43TUYLmZoPqYaYrFnogRZsAQjYqryB+Ct4GRU2PpDLgusHWsNA2AIVMPul3R3/sXC4+yBv/b1QDlaWZpEEHDm8XLZnnhhtGRgj5SDMiELcqqYfuwUC4NBRCXsEKQw/L7kTFtPLX0Td1iexZr104Ej5sJvy8fGcBdW6qs9tgrn9sM//f+APSsPcj2A9uH07sFc0wMIB+ladzi0YmOv03HBH/vj+LyukFO7YmPc7wQsXbUCTxvORmF+AY48YTBgkR9iOB1YPJIw3Lev6TImGzduZAXDOU2XPJo+fbqmJurv/wt9DGvwTc0e9v/z7I9je5kHH5iVWoZpZiubMwdvhg9HWAJu9Qaji0cASzqfg4UV+9DPY0MqPA/Pyzgfv1dV4iV7EaZPPyBJ03d103XGbiNwc/ASdA1bMVPj9d+XfSfW7KzCy7beujv/YrGp7zm4cO1oTHd2xVFIMoUDMd73JPIcZizXmZ2a4iC8jBpfEN/ZuyZl/UaDkcWPq/UY1/U8Exf9NQqnDivCSaa2J6eYnXn4JHwguklKDGE7sRokTDKshluysNkWrUou2RpM4zeFKbcHxv1rLsZpsiWceBLXR8bx48ezIuDURSYa27dvx+eff45DDjkknqvtcAQCAcyfP5+9asUPhTNwrf9y7LT2Z/93KGKJprHT0VZ04XQqcaDVynRTNLrnytPA28pSoyamwyJfuCtdPs3HVEOc3l240zgXVwTrEuSybPLNs9Kj/XZkWOR1VbVyXYk4/2KR55RLuZS6kp+4ZlZiPn3BsO7s1BRWk7rdybmWbehxMsZ7H8c7hf9i/3co19YNW7a1y1bxnma2ZHfGLP/lmBW4POYxjudDZEsK7ut1THE0Fo/XX389ysvLMXXqVJY4o5YlcLvdrNPMkUceyZZde+218Vxth4Omj1euXMletWJr/iH4IHwI9hkK612YXE0Ip45uq4nmvzFVXA53deywij6ZEoYLG2DYmRpB3LnGADqhDP6acs3HVEPsoRqcb/wKxwv/Q4hcupR0ZDPCCTdyArs1v0Fk29smVBNx/sUi3ylP0ZVUJz98xNKMCEumnZrCYpSvZT6tE0Ga6Cm/B3moDFvrXVuLy6vaZSubQcKR4jIcFvgeCLX/Om21Z+D98CH4IjxOU6dBl6rf8LH5Vly+795mP6vXMcXReNqaPIpPPPEErrrqqnreRZrOJgwGA5566ikccEBip884zU8lXF3zKDqZ/0TprruAoSenpclmBx5AlrkaK8oOB/p0i/qZEb5fca7ldvy5ZzCAc6B3zq94HE9Zv8KSrf/C2vie7s1iyS3Co8ETUSk5MSsQgsNiRIbViN8sl0AUJJSWTUVepx6arf+Uqtdwp+VDrF83A5hwH1KBzijDN+brYKskcbA+qdtCTQPeN98BCwII+SfX9o3WO7NCLyDftA3invuA7nLbyUSiFpZXr63dK5fjC/Nt2C51olHZ9u81AM+aH2G/S/7rIdjaV//QIAowG0X4g2HmzZTrIMQfmxjEcHETtgZSyzHBaZq4301mzpyJSZMm4ZlnnsHSpUtRVlbG6j2OGzeOFQgfOnRovFfJaQPdAtuYl81ZRRe4oegU3oNB4nYscqVGAWwt2GzsB/iq4G7CY5HVtR92S7nYFczAEOgfKtAblEQEg+R9S7B4zCrEI6FTWa3mmX5ZPNIDZIXgYB1AairKNBWPDkMQnYQKbHKnRkcgIic7G/niLvZ70OeGUSkMnQwsZjMOEGUB6/F6YEsR8bhfeB0GGDbg95rktBEt9G7BrcbXYCvrAmAs7GIQg8VtQDudaTabDUvDg+CTTBgbCEGph94uphp/gxCugdc1mqYFoAWhgqG4wH897Fn5eFKTNXCSgSZ3k8GDB+PRRx/V4qvTArrBUj1MetWKkXvfwwzzPCwoI+/ZdHzR6TLcvX4HjskYhYlIT1v9p9McLN5QikdtvWJ+pmDgeAzxPcF+X+0OIEuZGtUrC3tfhzN2nYpLCnvj0D7Fmo6paHGkVEuOPDCR02Kn2F7ChvIg3rf2QE8N17+p1+m4Z8tgjMwa2qrkpkScf7HIyS3A2f5/Y5+UhTe8EgqTmGhqMVtwqf8a+GDGo4IZNh3ZqSnedZyN4pJinJQxICnrzwoW42LjF9jslhO1gp2GY4b/ZhisGXixHbYij+bp/tvZ7ysNGUrRsPYxB48hy1yDvytOBLqRZzT+mDPy8V14JDqFmh/Meh1TnMYk1hXBaRHU0pG8twkp3KpkBO7L2h8/hbMxAUr7uDS0lVo0t6n4H8rCpri0khofS5oZZte3vexWumAL8ATD2o+pKAw27YEvUA23l/In5TFnszuA8krNk2aMeb3wh1SFAr9df+dfE6Vm1tlHoqTGjxJXCIVJHF5GowELMZbFq/olo67s1BS/OSZg6b4yTDUlp6qHqbaYt1wqyJxZiEXhYehistZr19tajAaRJTH5Q/GbZvYLFkCqQcDbdOvA9lCb6NOCuEq9jilOgsQjdZdZvnw5y7qO1Y7p3HPP1WLVHQK/34933nkHp512GsxmOfsy3qitrsSgt55wcmtcMFbPtlJjlZrLZuyRa5PFY6kLw4qyUiLbmjKOX3/9dU3HVDReD90Am8WHNRWHAt3y6yWyVLg1TpixtW09iTj/mkJ+OPGzMZZsLEaReY6jZeMm207NncdaZhA3hVlpkWiW5ONnV87B8mo3s1l7bEVCzO+RxWM88DHxCAS1FI9CACeLP8IZ8gPSEawmaSz0OqY4GotHr9eLSy65BG+//XbMbCm1nhQXj7EhG1E9TC37JwuKeDSEZPHYx/cXzjIsRl4ZtScchHS01RklT+Amyw9Yt/0fAOq6ojTkYukDDLd8iE2rzgGG3wU906f6Vzxreg7evUOwqjI/4T25fYIVNsmHQETby2N9n+Fc0/9g2HImMOpSzdZNbSQvN8xHbgWJyIN0df41xWGGVTjcsBqh7QIw4BgkkyMNv8BoqEKgej8gt6eu7BSLvqHNMInrYKqkrlFyP/pEQq0xCQtk8eiAF2caFsKMACQST+3gJdyF/paNKN3yMlBwdLu3NSBaWSxmwKedeLQbQviv+Rl5ff77YbLEjq3U65jiaCweb7rpJrzxxhsYMGAAzjzzTBQVFbXLTc/RDtXzaFSmVoZWfIsZptfxPatfeEZamt4puVAklGCjp6zJzxU6BHQTSrG17G/onexQGUYbfsVvnjBWNdvfIf54BRsgVcLvqROPvUNbMc6wAkvKta26kCtU4ybT2ygPULUHOU41FZgU+AGjTd/g512U8Z9c8Xi99Cq6mvZhY9mxQE8tI1Tjx1HV72Ks+Wss200OjIOT1l+bksIIu+DDbNOL7PfqwAPtaphC35UpeLDHG582sgFR3piQhuLRqohpwuOpaVI8clKHuCo7cjcPGTKETVlbeEshXZOTJU+39soU6sVAikoMZDoimZQQ9GZsYO08CNgCZLi2Qu8YrfKF2xRKTlHzgEH2bAQjxKNklcee4I3eTCBeOHIp2xXIQTVCwQAMRn0nN6kEbQVAFSC5kp8lHhDM8rSmPzmt/tpCWBFEUiA526x6Hq1CAOFQCDZ7hHjyupDhtLdP7IXjN80cJM8jE4/aXR9ICwQkA0xCCH5XDZDNO8x1BOJaJJxiHI866iguHNsJeWunTZumqde2IFeuEdbd2WAaO8XEY1xtZbS26KaT11MuN9UlsKO2+LVeMdnkGquWsEfzMRWNgCh7GeoF5FvlsWfwa9vjPiu3EGFJfjiqKZPbcOrl/GsSh3xzNXpKkGwCgiy4g36P/uwUA8mouPaCyYkZtdrkhBnC53XXJtAQAW+dHUtrfFi8oQR/7qpq9fkUL7EXMsjfF/ZrJx4pTM0LOX7R62la9Op1THE0Fo8DBw7E3r174/mVaQmVKRg1apS25QoUTyMCnnrT2GoMZFrayihfSAUliSgWhb3kCo/5QiV27t4NPWOuFY9e7cdUFIIGeVyFfXWeR4NdzhM1+Vt+02wL1Hu5HPL+V5ft1df51wSmLLlkisWb/JqrQVG+6YeieB6TbadYSOTtJpo5jxMxTetz1wAGI/zKJF/AVyceV2yrwNkvLMUtH/7e4u8OKvsW8sfH8xhSvk+K0/c1mZhDCTHNeEz1OqY4CWhP+PHHH2PDhg3x/Nq0gzLOqBMPvWpGv8OAf+8BLv6G/Ve0pKZ4jKutlCLIagZ6LAy2LJQKuez33ZvWQM9YHLJ4ssKr/ZiKQtCoise6m4bRIdvOEtRWPBKVouzldJXt1tf51wSWbHm63RFoOvY2EQRp2pqOn/KQqSc7xUTxPDb3EKgVBqOxtrSRVxFLXsjbVFNdF6qhZkyrlS5aI/Yiz6f2EFYemBHFsxxPWEkgtpqmYzV1O6Y4jWiXb/jHH3+s939KkKH+1WPHjsXVV1/NniCou0w0ItsXcupDmWbFxcXaZpwZTPKPgrFBAk062ko0KeIx1PyFtNTWC3nuMri2k9egfRmUWmK1y+efTfJi3z6Nx1QUwoqHW4q42VkyZPFoC9V5I7XCZcwBAtvgqdijr/OvCZx5XdlrZrgcySakeB7DUUI5km2n5sJPhFDySh15BQvMCCKgiCWqOgDJBb+77oHJq4hHq9JDvCVIitiT4iT21O9DUNuYaLmeJEUSNC16dTumOPEVj1TMk+IZGkIH/s4774z6nkqs+o+c5GBsUNg2HREVz2NLvK/u3MGAewXEfS2fckoGNmdmbZZmMqreSbXhEXU3DWtmHnt1hOOTMdoUXksuEAD8VclpVdcWsgrkvuo5UhX8gSDMpuTFf4WU5JOwP/k1J1uMkvgmJlE8UlcewIWA1x1RdYBm0t2NxKNaRLs1nkIpTjGKkvLALETxLMcTv1oSKGL/OalNu65Kt99+e5MCkZM6GJUgb7WwbTpiUOM+w83bwNZ9BLDjDWRX6btcj9VR5/kXkYQHNrM8roRA3U3DmSWLxwypprbuq1aErLlADRCuSX7mckvJyu3MXo1CGHtLdqNTl+5J25aQQfY8SkmaAm4LguJ5FFtwHmuFWnzbr4glVTwFvXXe9ry9izHf/B9UlYwAMLdlX2yKs6dQFY8aH9+6rG5tYys5KSIeybvI0SbQ/+yzz2aviULNCEw18RhPWxkVz6OpBR6LLgPGAEuAPqFNqHT7kWXXZzcEOq6UcSwKEo496oiEjikiJzsH2Ab0zqybhsrILqwtZVLjdsHpqEswiDcSZS6XAIKrRNfnXySiyYwKZCAb1ago3pVU8dhU2Ztk2ykWouJ5NCbR8/i3cQB2+HJgg2ybACWOBcmOdaLP4C7B/uJmrA/InZda1VY2XmWI1O/T2Fa1iT7NiEe9jimOxgkznPggiiL69evHXhOFRa1NlmLiMZ62MlhlAW1sgQ0yuw9lGZRUsHfD339AtwgCPEqwemFeVkLHFFHUexDQbTT69htcu8zqzERIKaFTXaFtORpDhlz2xuwt0fX515Aqg5yR7irbhWQiNeF51IOdoiGo4SdJ9Dw+knUjzvDfhtJMuVtXwNg49ldSporDhpZXDVdLqsWrHu/mfuehj/d1PJ9zLbSkNtGnmel2vY4pTmP4EdIhPp8Ps2fPZq8JF4/wIRBKTk/YZNvKpPSkNbXkpmM0Y6+5F/u1ZMNy6BkP5Av3u2+/kdAxxRg5A7hkITDx6tpFgmhAtSALdVeFttPJlix5CtjeiszlZJx/DXGZ5KQib3nLE320oFbYRKmZqAc7RcOgTMUawsnL2LUa5ThGj1++lgaVeoohT13CjOrNlZRp9pagllRrSVJfi7bTakUYcv9yLQkbWharqdcxxWkMF486JdGlCix2+WZug7+2hES62aq1U/c1ObI3LbRrNfQMC9aP8HToAZcgP6x4qrStZWjPVTKXg60re5PsUiE+ixwXGqzeq+vM5WTbKRpGiw7Eo5IEoybFhIxKofDIeoqK91Bqhecx3vV47cp2an3ND5qcqJTsULR0k+hxTHHSWDyuWrUKt9xyCyslVFBQwIL0KVucI2OyOlAt2VAJBzy+QFqaxZjXGw8EzsCzoWkt+rx3+Lm42D8LT3umQM/8bJ6Ad4KHohp1nS6SzTLbwXgzOBnlYe3iHYnMgu5YH+6GdeFuCOu8G1Ak7oze+DPcE6WBdjRCjgOU3euWLAimzmQEzMoMgjGJ09YXlT+K5ZbL0G3zPPb/gDkbxVImvFLdLVdQvblqW9QW4CkciVsCF+Fj20lx2c68mnV43PQYZlS9AC35tu/1GO57AYvyz9B0PZzEkTY9gD766CPmDjebzRgwYABKSpLf+ktPCI58HIhXUO0L4vtA6txk44k5pwhPh6az3+8JhWEyNP1s1XfUZCz8JACpHNhX7UVhRstvAonkrexLsLyyHJPN+ine/2nhZVhYtg9zTD00XU921z4Y5/8P+32lJ4Achz4TmxqyYeg/cfuGKTjK3BknJnE7lve6DDM2TMbZnXvgQKQGoaJxGOR9GVkZGViapG2g0lh5QjU2KNnVS/v8E2duOQanZHfFkcpnioUc/BoeAMEph7+0iNw+eDM0FfuJ0esntxZnqArTDD9jQ6AntMSulJtyp9isFic2aeN5PPXUU7F8+XLU1NTg66+/hp6hTLOZM2cmPONMnWrROv5Fr7aymutOB3W6qSkyrSYM7CR3cFmxta5zhN5Qp6YmTTlcN1mMWXZ5Oyo82nq5LUYDspV1Fdf4dH3+RVLgtLRqm7XCbJTPCV8U16Me7BQNu9XCOrq4WzJHqhELO1+CI3wP4PdCeRYjw6b0do54MF9oOxqn+O/E5gEXtvh7bXG+RosF/XFn4Fw8h/h4MmNhU66t3ma2W69jipPGnsehQ4ciVaAp9aysrITX0ExU/ItebWUWwthf3ASz5IfHPwUZ1uYvYBce1BveYAjDirKgV2xGAXZ4YRC0ranYGrKtRmTCBU9VeUKEWIU7gH1VPgxQxL4ez79ICjIU8VidXPFoaUI86sFO0XBY6rxcWtcRjYXH0Q1/S0FUQg7LcFrlbXL5g+1qT+gUvJgg/oECL/1N+8OuTDndMTd0FCwBEf8H7ehf8T+8ZnoeFXsOAPBYzM/pdUxxEuR5pIDXzz//HA899BDuueee2uVeL7VI24dwOIUCaJIA2W/OnDkJDxy+1/8fvGO+C+HSzUhHW1Eh6/nmW/Ge5W74vC1LLjltTHecO6EXumUrxXt1yMWlD+JP64WQvrlHN8HoR+97Ab9ZL8HYrc9ovq5bg4/jF8vlMP/9ia7Pv0i6BLZhoXkWXnD9I6mt2npULsNLpv/D0Xuf06WdomEX/PiP8Rk8Zng4aVm7VkUQehRPW1HZEswz341T9z3ervaEGb59eMt8H+4OPBRXhwE9HIQ0jAnODJThYMMadPU2HTqj1zHFSYDncf78+bj00ktr+1PSE8Rtt93G3vvtt98wYcIEvPbaazjrrLPivWpOOxkcWod8sQQ/u5PfUzcpmOzYgzy4wyaEfanTUaM5QkohYIugn0QowSZ7agW/9i0KMw1+FAhVWF+R3JqJrSE3Jwc2cTf8kgE13kDttGeiyQiWY5xhFdZ4UyfCiaatTzX+yH4vd1WzcjSJprdnDa4yfIHCklEAhiADHuwvrsUaf50dr658AEMsv6Ny113A4PNa9L0WZxbWhruz5LcxcdhOu0HCaGEtbALNthwBZwtmW9pCdZcJuGr5FcjM7QvyPXJSn7iKx8WLF+OUU05Bly5d8Oijj+Lnn3/GW2+9Vfv+2LFjWQHQ999/PyXFIz3FRj7JVlVVNVpOxU0pXiMQCNTzsBoMBhiNRvZEFelJoGX0XuTyyHU0fHKm7yZB3vDJjBKB6O9pvZFYLBa2HZHL6e/p89RfPBism0Z5OetKbNxbieMMneqtNx77pG47fVc890n9LvpbWt5wn9R9pWWR/dRj7dNJluexq9KL94OmetuZyH1q7ji1dp++7XYFLtg5Hf2NpThKJ/u0o/8MnP37CIzq2hkH+Hyt3qfWjL3FRZfillVH4bCMMWxdze2Tut+0voY20PI4Re6TaM/D+dLt2O7PwLOVHiYek3GcqvKG47rAZcjO7Yn+DY6Tul561ds14r/hs1EdMuECdxB2p0+z4xRrn7pXr8IZpvfxS1k1wuErEOw8Elf4/wXJ2QmPKPuWFSpHZ6Ec1eE6WzZ3nMzZXXGU/wH2/zVuD8xGQ7v2SfBVspkWYp/3SphFSZPjFM7pg4/DEzEUGfX+puHYi3wvEceJoxPxSFPU2dnZLDElPz8fpaWNa7iNHj0aS5e2LQdu1qxZrZqGuOqqq9C/f3/EC8rWvuuuuxotp+l59el25MiRmD59Or744gusXLmy9jOHHnooKw30zjvvYOPGjbXLp02bhlGjRuGFF15g3tpo3x05yCmYmGJCyLUfyU033YTKyko8/fTTtcvoRLv55puxadMmvPHGG7XLqVTRFVdcgdWrV+OTT+qm8pYY98fasBldNu7G8q/er10er32itlP08KDFPr366qu48sorG+1T3759MWPGDCxatAg//PBDs/skifLz/OdfLcSne9YldZ9iHafW7lNxlwksgSAoGfDwww/rYp9KiovhgxnrNm/HnDlftXqfWjP2fg90wl9STwzymFq8TwRdv1588cWEHaeG+7TCvx+qJCuWrPoT/Y6akJTjtLFcwnuhQ1GwuwahOXOi7hONKb1dI94znYhSvx/VL7yKHNGr6XGKtk+2PVtxkAjUVJQw25pyivB5eDwsVYHafVgmzAR8FRi2aDtsP81p0XHas3Nb7bL7/++/KCrMbdc+iVII8rwg4HNV451P52tynKaccRl73bF7X+17scaeitbH6ZVXXmm0Tk7LEaQ4BtTk5OQwz+Pzzz/P/k9C6+677673lEAnxhNPPMGynluL0+mEy9Xyxurfffdd1FqOe/bsYd5RGlzff/99uzyP3bt3Z3GcmZly6YR4PIHTK/2QIG34dKSlR+uad3/H52v24rZjB2HG2KLa5XrzKkTuE72veh3j4Xk88Zml+HN3NV48ZyQm9stLyj41d5xau0/P/m8LHvpmA04a3hn3nzi0Nhg9mfu0fEspTn7mZ3TLtuLbayZq6nn8ePVu3PDBH5jYLx8vnjOi2X1S/47ei7S71sep4T6d8cIvWLm9Ek+dNQLH7N8tKcfpu7V7cMHc5Rjc2YmPZo6vt0/0Q+ug/9O26+kaMfWRxdhR7sG8i8dgRPeshHsel3/4GCb8dQ9W2sZj+PVfsNmMiQ98B5NBwJrbp7LPj7rvO7j8IXx91YHokWtv0XGi7Rt42wIEwxJ+nDURnbNs7d4nw+wuMCKE9TOWoWeP3pocp/Xbd+Oxl+Yi027FfddfE3PsqftN93paruVxonJ99EBBQl29f3OS5HmkgdTcQaioqGhz38q2CM54ogqUliyPVWqABn9zy+kEoIEda33qOhtCJ1e05WTvaMvpBKIflSHhdTCIf8JSY4fF0rfR59uzT81te1v3iWxFIp4uNtH2KfKCQT/N7dMd7tnINO9AafnjsFgmJWWfGtLeferj/QMPml4G9vaH2fxgo/MvGfuUL5Xiv6anYPQYYLFMbfU+Nbftkct7m6twheFjZJU4YbGMa3af1POPZk8SeZwabvtkYTkOMayGYS8dr25JOU5OeDBJXIlCnwMWy6H19on+Rj331DGll2vEEMNOdBP2QvIOgMVSqOlxira8rNcxmLwqG4O7FOEpUYRT8OEY8WdYJT9gOBImUayteZjttDfa/ljHibZ7vvkWZErVCFV/DnPBwHbvUw0scMINn7tGs+OU6dmO58wPY3eQzqmbYo499XrucDgScpw4bSeuUdB9+vTBL7/80uRnlixZgkGD5GbxnOjQExRNWTR88tSaw0rewOPmJ1BYsixtbVUU2o7B4jZIHv3WbWwteYHdOMXwI3qULU74mIpFlhk42bAIR2AJghr3Ui8UynGDaR6mez/W9fnXkEM9C3GN6X3Y99VNxSWaDPc2zDX/B7O8T+jWTtG40fsI5lnugXnPiqSsf+L+/fH8NWfgzjPlB1BToBpPmR/Dg6Zn4fIGWHmvy8T57KHGEWrdtaYrSlAklMDvruuT3R58ghxyFfRq55wx2+SHe0szrV/1PKY4GorHk08+mSXNvPzyy1Hff/DBB7FmzRqcfvrp8VwtJ46tyAjJr58eyIkmKCpPwL6Wh0foHdEstyW0Qj8B4o6sfPZKWZ5VNdraOqtADsHIlSrgT6EapiGLPIsjeSuTtg1mpU+0iTxmKYRftGkuiJoiy2ZCv0InCjNlYWa0yuJJFCS4amrg8oVwpfFj9lBjDchdaFqKT5CvUX5PfM4bnyhvo9+r3XlosdZdg1KpTSgnQdPW119/Pcukvvjii/Hmm2/WxkPccMMNzOP4008/YcSIEfjHP/6BRLN27draQF2Px1O77Pzzz6/9zNy5c5HOSKp4DLiRrgSVC2nI33FsYFBuXHoSjyZ7NsKSIN9MK0qQm9V88e62kpnflb1ahCD2lBWjc6fOSAUkS7b8iyd54tFolq8JZqSWJyhokLc75EtuqFMtJlvteHfXVCJksCIHSoUOS+t6zvvJUygBvjgJ44AiRrUU2lZ7Rm3bRiqU7tCoJBAnRcUjxb7873//Y+KQMpzUoFbyOFIMx2mnnYannnoqZpyEllCSTMPsqr1799ZbpifxmJR4DKUeoBhMLc9jPG1FF3Ui3IG8r6rXg7x8ukEUUSPYWZcZVxX1me+t3arMNlTDjgy4UVm8o0XiUQ/xUIJV9jwa/MkTjyarfE2grkt6tVM0Qka7vmYQBBEeWOCAF15XJUKWDBgFJVzD1LoGAwGaHQmT2IvPA26AhHYQCGnpebTVCWSPxwWHVXkwSqExxdG4SDhlXFPa/WOPPcbiH8vKylgSzZgxY9CpUyckC8q6TmanhtZA4ppKGCQcxcsgBFJHOMXbVkHlptORvK8mRTzaxUBSHtxi4RKdyAy74K0q03xdlYYcZITcqCndrd/zrwEGRy57NQXiE9vWFizKtLVZCCEcCkGMSGDQi52aEo+STjyPZCuXaIND8sLnrkTImlP3phJW0lKC9IAbBIJxEsbs+5iXVjvxKJrrsskpMQc50cWjnscUpz6atQ3Iy8vDUUcdxYqBH3fccUkVjqkGZZxt2LAh4W0cBdXzGPKmra3CRmttq8KOgqk2WN2rq9agHlGeyvLVNK4HG29cRrnskrd8t27Pv4YYHfIN1hxsXUxcPDHb6m76fp9bl3aKRli5lsGvD88j2cirJKb43TXwKckuQRgAg6lNoTXx8qqGlCl+TR+YDUb4FV+VrwkPp57HFKc+qdNzKo2gTDPy3iY640x9OjSk0LR1vG0lKRdSpJD3tTksdmXaWvIioKOuCl6TPC0bdGnfDtNnlcVjsGqvbs+/hlicsufRlkTxaFGmrQm/EiuuNztFxSyPeejkIZBsVBOUvbYBT3Vtsoua6dwaQkpserzissOql1ZjoU2NCghfE4k+uh5THO2mradMmdKiz1H848KFC+O5ak4cEC3yRcQYTh3PY7yRlPgjUSc3nXhgtSuxc4KEYIiC9BPf6zcaARKPHiCcgF7qQVsBUAkIrubFo16wZcri0R5OnvfMZDIjKIksPs/XwPOYChUGxIA+PI8EdVQigt5qwCNPp/tFioNsHeHauOx4iUflgVnjJEE/JeZIrrhliXM6kHhsrlsLiUaKO1Q7XHD0hUH1PDKBkZ5IynSXEOo4nkc105EIuKthccgdN5JNyCxvRyJqagpOuVC0wU3JOamBWs7ICRerhWk0JGeiyA8TjPDB702dc0JUS+ME9SN4vYp4DHlrEFYym9Up6LY84MZL7KnXPK1nW9Qs8YBO4lA57SOuVyOKU4j2Q11lvv32W4wbN461L+QNyZuGxDW1TUq0yDYqnkeT5E1bWwm1U/epY4PmsFkt8EkmzWu5tZawVRaPok978WjIlDOsbf4S3Z5/DXEqnkfKSK/yJC/cwCcoHrMGnke92CkaRqWuoFEn4pFsFDLUJfGQgCT8BkcbSqrFV+yt7n8FRnifxSc550JLWJY487zGvgbpeUxx6pOQR1nKtqZs5wULFmDZsmW47777ErHalIVKFVCz+0SXLDApF1xzCk1bx9tWatKQoQN5HqmfrluJNwoF9HNsBaVch8GnfTaxKVNO2HMGy3V7/jXEqGRbU7iBuzp55Xr8isfM7/Po0k7RMFplb7tRJ+cx2SizsJv8H38NJK885gPG1otHQQ2tiVNsusmegwpkoDqgrRwIKF7WpkoM6XlMceqT0HmQjIwMHH300TE70HBkqD7mihUr6jV/T+TTurmZFlId2VZq0pBJJzedeEBP8WqwOtWY0wuiQy5XYk5AKRpTtux5zAqV6fb8a4TJCh9kj7GnWvtyRrEIqJ7HBrVPdWOnKJiVJDFzWB/nMdmo2i9700QSj8rUbdCoJPa0BuUaJcTJq2o3y4k8nkAQWlJbEqgJj6mexxSnPgkPoqEm6Lt3N18uI50JBoP45JNP2GsiUQu5ChKFG0hpaStvwTA8FZyOH00HoiOxVByBL0NjUBPSzxO9lNcfn4XGYrU4WPN12fOKsC5MP911e/5FY6PYG3+Ge8Lj9SZdPIYaTFvryU4NMdvkJDGLTsQj2WhnaQ18kpH9Line9rC59Z2VKjofiDmBM7DEclBctq1z9W+4z/giplS8Dy15sdd/0Mv7BtbmHhbzM3oeUxyNi4Q3xaZNm/Duu++iV69eiVwtp4WYeo1Hb+/rkCDiz2AIdnNCh4cuCHQeif8L+tBPdOI6dBwesv0D28o8eNOhXSeX1iL1PAhXBkT0gB0XaryujILuOND/f+z3tYEQrKa6Ytd65sach/H7zkq8bO6WxG14CCt2uvBs3jjsh9TA0HMcxnmfgM9gx0qdJGl+ikNwre9ijLJlY3poIf4Od0PA2frj6kbce3QAAEzwSURBVO08Gs+ERBwgRhQabwc5nu0427gQy73a1lu1WMjzKMDt517FjkBc1cGFF14Y+6lr504sWrSI1W+6++6747laTpywmkxMOBJ0gqejeLQposLTwS5w6n55A/rZryybPCVb6dG+ppvTYoRBFBAKS6hwB9A5KzXEI203Ue1LoifG5EAQPvhCqTEbobbK3YtcIAT4gmFdPCzQ1ZVw+UL43HY47vQfgCdHjMLQVn6PTbkux0uEBTsNw0OBU1Bt7oEDoB3q/URP1yBO24mrOmiuN/TAgQMxa9YsXHzxxfFcbYeDnpL79u2b8KdlURRgNYnwBsIpI57ibSubGEQPYS/yA8m/2cRfPErw+PUzHZRpNUGgJr3eShYmQeNPK2h8ZNtMKHX5UeHxo3OWVXfnXzScVvkSXeNN3nGzmOQHSl8wpFs7NcQR8eBb4wsmXTySjXoXdQE2AdXeQKMHqNbghBv7CZvQyUNhRge3f9sKh+Kx0EnID1twB7RjZPmXeNL0Odx7jgIQPVRFz2OKo6F43Lx5c8w4x+zsbJYww2keyjSbMWNG4k3ld+Ex46MwwAuPj2L+6rpLpIutMiv/xo+Wa7A7SB1JzkNH4Vr3IzjQshB/brwJGHEj9ECm4MYGyzksm7jKcwwyHa3PPG0NT+M+9LZsxL4tLwCdj9Tf+ReFc8qfxs3mRdi87Wpg3MykbMMxro9xsmklMndfAIw8TZd2aoghHMDdltdhCbnhqhmPfGdye7ozW00ajAO2XwuX14E50tVtFo/5ZSvxqeVW/OXtQ/N98UuY0fjBsot3I0YYluE7V9+Yn9HzmOJomDDTs2fPqD/du3fnwrEV0DQ/FVxPeNCwIOIIaQmmGlbC59ZPPcBE2or6QNdIVrgkCyto31EQRLlLiFpfTg9YHdlQ/QvV5doX784RXCgQquCrLtXn+ReFbKkCfcQ9EN37krYNA/1rcILhJ9irNurWTo0QDThX+BynG7+Hu0b7OqLNQTba/MdyHG5YjvH4HTd4HsJX5uvRac8Prf4ukyMbu6RclEhyUlB7sYtBDBC2o3dwo6bXvN2dp+DWwAX41TYx5md0PaY49eC9rXUIlSn44YcfEl+uwGjF49ZLcX3gUrhCYlraytRlMPbzvYTD/A8ikEIxXs3xacGlGOt9Ess713mOko4o4hjTCxjonYtyQa75qCWvFFyHo3xzsCXjAH2ef1H4pceFONV3O1ZktKz1qxasyDkSdwfOwQ7ncN3aqRGiAa+ZT8P/BU5DtQ5CUMhGi1dvwK3Bi3FH4Hz0EPZhgLgTDmPrbWfoOR4H+p7Aef4b4iL2HJ6d+MpyI1433cfiQ7WiutMYvB46HH8ZB8b8jK7HFCd+09avvvpqm//23HO1rWbPaQOCgK8cx+P3ikocE06/ZBnCaqy70XgCIZiNqSGimyNky8M++FATav00mZYE7QXw1dSgKiIOTCtqsgZgrbQLpX592aApvDkD8YsE9A7Hx8vUFjblHoI31/fCNdb+SCXeyzofq6sqMEpS2vklGZ9gxQLbFBRX+7Eh0BVdhHK80qf1JcFsyjQzVVOLRzKQxSbXmrTBx5JwtIoPVZP23DqKu+a0nXYphPPPP7/Vga1qb2suHvWJemFK13IK1I1Fzcr1UVZgG2KSdJ1FrrNMRzXmqyoBGdeZ6roSIFTjRYaaMJPEbGuLMXrCjN7JsCTfdg3JsZuZeNwodUO1sw8MSuej1mCPEHeeOIg9o9IH3CIEUeLzIcehTS3YLKkS44S/0N1FswwTNFkHJ0XEI+8Uow2UYDRy5Ej2mmgGSZtgFzcjVEPFlLsg3WxFj0JzTQ/ALHnhqx4OZBahIzDA/wduN36E3D009dja4iDacWLgc5xlWgnzjguB/U7WdF0DfGvwD8M36LJvLEXy6fL8a0hX32acb/gSWeWUZKBlIZXY5IVLMUr4G44aul0M0qWdotHdUIahwhb4qulalrw6mZG2ErauRR9xFxaH90NhZtu8ycZANT603AGr5IPLd2j7xZ7SkpXwuquBXG0SWzuV/oJ5lnvwe80QANErruh9THHiJB7PO6/jZKPqCZPJhOnTpydl3ReXP4Qe5g1YWNITwP5IO1sJAsYIf8Iq+LHRpX3bvERRFNiKycYv8UeFfhJmiGGB1RhuWIRFZbGD6ONFf9cKzDC9i6Wl1K3lUl2efw3pUrUad5pexdKq8QDkDN1EM7rkY/zD8gJ+3n0igCN1aadoXFw8B30tq/DVntlJv5aptjr43n7IMRfji9AY7MVEQJrIrjmtQjRipLCePelucNcAuW1ocRiJ0YIwBIiQ4CPxqBEGmyxKreHYbRX1PqY4dXB5r0OokPr8+fPZa6LxGZSnTm9V2tpK7QMd0FFmcnuRFO+CIU79cONFyCx7X8KeBPTctmbWem70ev41xKS02TOHknjcjHJNTCHk062dohE0yaJK0sG1TLWVzywnhh1t+AVnlD/XeuFIGOtiOH0kHtuLINRe83we7apsmG1Z7NUmxW4ZqfcxxamDi0cdEg6HsXLlSvaaaPwmWTwKvgTczHVqK48gC62gO/klPuKFaJZrKBpD+uj1qxK2ZCVsvAlWeV3mYI1uz7+GmOxqj+bkiUfBKAsLMeTXrZ2iETbJY17yJf8hULVVyNG5dplfEZKtRhThhTl+4lFJ5iECnhrNx3JT4lHvY4qjoXjcvn07LrvsMlYl3mazwWAwNPoxGtMzkzcVCBpl8Sj6kv+0nixcouyxCCXCG5YgRIt8IzWF9SUeoQi6RIw3NTFAbwK6KSwO+YZrbeKGqzWCSfZ0iQ08j3pHMivTuf7ki0cVa05E7GVm13aLPX+cZkf8ovbiUR3LDnhYRylOahNXFbdp0yaMGzcO5eXlGDp0KHw+HysSbrVa2Xvkih4+fDjrNsPRJ0GzLB4Nfu1iX/SO1+BgPXElb8cRj0ar7E01hyneTz+INvlaYApoLx5NSsyVSWc2aAqro26qT61UkWhEkywsDOHUEo+wyOJR1JF4zCrsDvwt/57RJXanlRaJvVAV/N74TDPL3wcEfdpNW9szctirVQig2utFhl0fJZQ4OvA83nXXXaisrMTChQuxevVqtuyCCy7AX3/9hS1btrBAWJfLhffeey+eq+1wkHf20EMPZa+JJqRMIxoTcDPXq618JB51EisVL8xK7JxF0pdwom4ZhLmZOMR4YLbJx9XcjPc1medfQyyKeCRvjZYFnJtCNKvi0a9bO0VDsMgPC8ZA8sWjaishhxIRZYTsXm3+voDiKYxXx6ig+n0aikfV80h4aqI/mOt9THE0Eo/ffPMNjjnmGHbwVdQK+F26dMG8efPY77fccks8V9vhoGn9SZMmJWV6X7LIJ7ipmbiwjmwrNWlI6ECeR4tTFiFWvYlHp+KNCGk/3sxKzFVzNkjm+dcQW6149MKVpPqUBrPsITI28DzqyU7RMCgPTMZg8lutqrYy9Iyob1g0pt3iMRgnz2PQIB/jkM+taeysX5nsjCUe9T6mOBqJx5KSEgwaVFcHjAaA2103GC0WCw4//HB8+umn8Vxth8Pv9+P1119nrwlHEY+WYHXa2sqvxH0KHSjuU1Ti1qzw0RMd9ILVmctebWHtxaPVntEi8ZjU868BolUJIxEkuF3JeaAzKJ5Ho+TXrZ2iYVTEoymZmeoNbZXZAzjyfmDitUDfyW3+vpBB8RT64yMeQ0oGtxSn74uFG/J6vK7o4lHvY4pTR1zlfX5+PpuWjvw/TVdHQoKyoqLjZLFqAXlrN27Utkl9LAQlBs2SIp5HLWwVrM04Tw0B3RLMVnnKlmq5IeAhNxz0gD1TFo9OyaV5TJ9VmTajNmzBUBhGg6i7868RZkdtDT6Pi66b+QnfBIMyVkwNPI+6slNToRpJzFSPaqsJV7b7+0IG+ZhIcfIUhhMkHj2CDdlSNXwxxKPexxRHI89j//792YFXGTt2LBYsWMCSZYji4mIW70iZ2Bx9ItiVm3m440zZthZJqQdo8HccG1jtdYWEtb5BtAZnVh57zYALHo173todSsKMEILLkyIZ14IAD2Qvky9JRetNFnn9Jim1au/VhinoQDzGm7CSxCT547Nvi/pci4N9D+PnzKOhJT5RFr0BDYuRc1JQPB599NH47rvvaj2LV199Naqrq7H//vtjzJgxGDBgAPbs2YN//vOf8VwtJ46YsuQ6ZNmhsrS1q1grHjvOBc5uMcMryb2d/RqW42gtNsXzaBZCqKzWVhxZlGxrwl2TOiEJXkH2Cvk8yRmPRsXzaEZqTSValThfu+RhnuaOhGRUPI+B+IhHKaMLtkudUBmSa3pqhV/xmAY9qXP+cTQSj1SOR2XmzJn4/vvvazOlKPD17bffZuV61qxZg06dOuGxxx7DJZdc0t7Vdmhoan/atGlJCRrOyJdrj9nhBXTkoUqkrUR7jm6yNONFht0Cl+LBYv1rdYJgdiKoXIZclRo/sBjNCMDQrBBL5vkXDZ9oS6q3RvU8mhvEPOrNTg2xOuUQHIfggcsfSuq2xNtWkhLDLFAIShywm+XzwhPQ1k4BpZJFKEYlC72PKU4d7T5ClEV91lln4cILL8SoUaNYncdITj31VPbDaTkkvsmWySAnOw8eyQy6zYaqimHOl0/2dLJVOLcP3ghOhWTtj37oGJhNRqyUBsIedqNPSIDsk9EBgoCfDGNR7Q+jq1f7G/xG9IAUDkL0BXR5/kWjwliAcNCn+Y09FmaL6nkM6NpOsaatnfCizBdElk32vCeDeNuquNPB+G5rAG7TEBwTh+/rXr0KNxrfQ7iceoAfAK14s/sd+Pi3Pfhn3ggcGOV9vY8pThw9j16vF0899RSblqaD/uSTT/KEmHZCmWZk02RknGXbzZjofwz9fa+h3FzXSiudbCUVDMW/gxfhXeM0dBTIPv8IXoWzArei2tH2+nJa8N/c23Fl4GqUCLLHV0suczyMo/0PoMbWRZfnXzSe7PEwJvoewzYH3dgTjzGnCBO8j+Mg32P1pn/1ZqdGZHbDKeLDmOL7L2q82sbTNke8bVXW/Qj8X/AMrDTGZ0x0ql6DmcZPsJ/rZ2gJzerUwA6XP3oYge7HFCd+4nHv3r14+umnMXr0aKxatQr/+te/0LVrV+aNpGLhnNZDmWaUXJSMjDNRFCA48hGGiNIaf1raKlPxUFQl+YYTT8g+BkneH3eSp/AaonqEKj3aJ2TYTMr0XIybV7LPv2g4LPI2J2vq1WIxYzfyUIZM+CPEo97s1AiDCcW23mzba5rwNCeCeNvKpkwzx+tc9hYOxwvBo7HUqK3Xz2GRJztrfNG3W/djihM/8ZiRkcF6WS9dupTFNV5zzTXIyspisY5HHHEEevfujXvuuYf1vOakBnkOOWi61JVi7cjiRKbNCCfcyPJsA4L6F9AtxYiwLsVjptUIAWFUu7TPgLYo4tGbpCngtmA3yzdct8bZ6LGwGOu6fXgDqZV44lTESnUHehAknIIXPYS9cHp3x+X7fN0OxL3Bc/ClMBFaMsT1M+YYn8PgPR9ruh5OimVbDxkyBA8++CB27NiBDz74AMceeyx27tyJO+64g4lIysamUj3U45qjX6YaVuAJ02PI+u0lpCOZVhN+svwLH4X+CalMLjPVEbjb+BJWWi5F1t/vQE9cWPx/2GA5Bz23yB2otORfrsew0DwLGdu/RaowueRNfGS+FQN3fpiU9RtEAbea3sA9xpfgr0mtKgxnBj7Ev42vI1ixEx2Jbjs+x4+Wa3C565n4Jsxo/GDZxbcJZxi/R4/qFZquh5Ni4jEy6PWEE07A/PnzmcfxgQceYGV6qObj6aefjm7dummx2g6DyWTC2WefzV6TQV9jCY4z/AznHm3jX/RqK5q2LpEy4ZIs8Ls7Rq1Hsk+OVUCOUAPJo699MpjMrINKIrarMFyCvuJuwF2q2/OvITmhYowQN8HuTp4AOlv8GucYv0GQFSrXp52icaTnM1xi/BxSxY6kbke8bWWwZaBassEbjk8PaLshhC4oRZZvD7SksnAs/i9wGn6yHhL1/VQYUxwZzfPhqTzP9ddfj6OOOgpXXHEFFi9ejNLS2BduDsUdiujXL3l5vlWdx+OenWXomjkOfdLQVg6zAccE/8MuzD/nDIf+04ZaZqf5hZfh7k3TcWWXiRgK/bCq/79w8bYjMSmzP6ZqvK75BZfg3g1H45ScCahfF0I/519DtvQ4BY9s7o7ujv1xWJK24TXxeLgDIRyjlA3So52isSz7GGzfsw85QnLrC8TbVsHBJ2HYZ7nIsBjxexy+L6tkJZZY/4mNEpVqOxta4e98AJ4KCRgr5uKaKO+nwpjiaOh5VKEC4c8++yzrNDNixAgmHB0OB84//3wtV5vyUO3M2bNn16uhmUhsRfvjxdCx+DEwGOloK2qR57TL5UlKajpG3CfZZ8XWamyQilAl6av8kjmrEMXIRplPu9aEKqXOQVgqDUa5KNcA1OP51xB//hB8Gx6FLVLsDHGtecVyFh4JngKPIUu3dorGkqILMSd4FnYJyX0EjLet1MQvEvTxSC5RC+hb4Ne0oHpdwkz0GNRUGFMcDT2P1GXmpZdewocffgiPx8MG9/jx43HRRRexaWuns65VGic6ySxV0D1XFk7by91pa6t8p5kJx1JXx0mYEXWabd0n34GjhnbG8O6xBV38E2aavkHqqVQIecIJV4wbbiKwGGU/gy8Y1q2douG0mJoUK4kknrZSs61DYQmBkASzsX0PXha7o7Y5BAnSzBh939tLhsGPIcIWdPOYARwc9TN6H1OcOItHSpJ5+eWXMXfuXGzZsoUJxoKCAlx++eVMNA4erH8vFkeme44dXVGC4RU/I7QzC4ZuI9PONEcZfsENpvnIXTkFGHAHOgLDhI2YZvweRbtGA7gSemFcnzz2kwj6+/7EeYbFyCulDhf9kQrkBvfiJPFHOF2dgKillbWnm6EMolCMAIsBlltKpgK5Ri+KhH0I18gFwzsKNtdOvGKaAx9M8PiPgFkR923FbJMdOnb4UOkPsaRBLcip2YjPLbdgjzcfAO80l9bicd68eczL+O233yIUCrGYhSOPPJIJxuOPP563GUpBuuXYcKX5M5wtLkDFUjeyT0o/8djNWI0phlXYXKx94epEMVjYgksNH+OPkmpdicdEMrTqR1xoeh1LSmha7EykAvmVv+Mh8zNY5aZI1WuTsg13uu5FX8tGrNiTAwztjVRh0pZHcKnlQ8wvviimpysVoV7whxp+Q5VkgysQRBZM7W4TSliFAHazmphyS8p4Y3XIYQ82SfuyXBydi8czz5QvwFSK54ILLmDxjEVFRfHYtrSFMs2oT3iyMs6oNMfunAOAygUwblwASA+yNnLpZCvJ2RnYC5g9e9ERIPt069Uf2A6IwdQIR9ACQe0JHPLq9vxriMkme80s4eTdcIMCTTMCoYBXt3ZqShQJAVdStyPutlLGsQ1+lMQjDEX5PsLLeqjLMZDxxpohP4w74EEwGIIxooZoqowpjowYD/H4zTffYOPGjbj11lu5cIxTwgYVWqfXZOHtOYX1uHa6tgM7fkW62UrMoqxDwO4rRkeA7GNWnvoNwTR+6jfKHhUh6NP1+ReJxSGLR2sSvTUhUW4cEPJ7dWunaIhWWQQZAjVJ3Y6428okx6WbhBDLK2g3xjrx6HNrZyu7Ux7LRiEMl7uxoE+FMcWJk3h84403MGXKFG7POEIBw3PmzElq4PDoAUV4LXQ41gu9IHUdgXSzlTVHzmzNDJYC4dTqqhENss/qP/5mvxtD6SseBbN8kxSb8Dzq4fyLxGKXBZANXpYgkQxCoux5lCI8j3qzUzQMing0BZPreYy7rRTxSPg8cdg3UYQX8jH2e7QTjxbFi054aupqhqbSmOIkoFQPJ3U5ZEABHhfOxEXeq/Dh6o4xddsanPldEZYEGKiln7sEHYGAEhdlSuL0Z7IRa8Vj6pQCsSkeY5YJm6QWhWGD7HkMB1LHboTRLosVc6iDhWoYTAgpt2+/h6aZ249PkL3y/niI0ViIIlxKPKU3injkpA5cPHJi9tM9c0I/bJM64daP1qCsA5WsaQn5mU78JvXGKmEQEOgYYisoyPFF5jT2PKri0diE51FvmBXPowNeuLzJFY9SioU81MWLdjDxKAjwxlns+ZUC8EFffMRoLDyQ1+NzUcUDTqqieYcZTupy3RED2TRZ/0Inch3ylEa60CnTijH+e1me0PrM7h3iRAkpe2GRUkc4xRujWZ7uM4ZTx4OmJn2wFo4s2akuPi1RhA3qtHXq2K1evGjYzcrHdaRYugCJR8mNkC8+08wBimsNAUGvtkLbI9qBcDn8bi4eUxnuedQhZrMZN910E3tN6nYYRdx23BCcMbYH0s1WeQ4zyzqn5g0lNanvdSX7HHfCyUh38Siq4lHy6f78ixbf1sWanPhbSfE8IiLRSHd2ioLVKReed8IDTyB5xfG1sJVflD2PgTiJvaBBfigJ+bSND1U9nNGm21NhTHFkuHjUIfSEXFlZGZe2Ux0drWwligIKM+Qb5p6q1BdbZJ9gWPa62ODrEElAbcFokW9c5rA/dc4/UQSu+g24fiNgT0wx9UYo4jGyxJHu7BQFi12OF3UIXtQkacpfK1sFFPEYjJPnMWiQv0/yayseA4pIDXobb3cqjCmODBePOiQQCODpp59mr5zk2erIoZ1x6gFFcFrq1yJLRcg+H3/yed2CFItdixeCoxCLQ0PxmzAgtc6/nJ6AI18WkkkscRTpedSlnRogWNR4UQ+qk9iiUAtbqZ5CKU6ews+6X4djffdhY8ZYaEnAIHvSQ97GnsdUGFMcmY4QytUsNBDnz5/PfpYtW4bt27ez2JchQ4awouaXXnopDIbUFwic+HLndOro0XEQhDrhQVNTBrPczzad6DN0NLoN/LG2VzOnhRgtKZelzrDI8aJOeLHJ07EESUgR9GF/fKatK5398IdkwERB2+tCyCiLx3AUzyMndUgL8UgFzE855RQ4nU5MnToV06dPZ67xTz75BFdccQU+//xzJiw7UjA1h9MQI8JwSxbYBR9c1ZXIzChMOyMZDSL74bSxuHqqiUcl2UgUJFRXU1/ujtNuNKx6HuMkHtX+2L6AtiEtYaMsTqU4TbdzkkNaiMeMjAw8+eSTOO+88+Bw1D1V/fe//8WkSZPw6aef4r333sOpp54KvcADhrmt4o3NYsJabw+YwwHk+YOoK9fL4edf0wgma1TPo+6vU2YHwhAh0oNTdXLrCsbbVjvyD8LPJRbUGOPTDrhPzQpcYfgeuRUHUhd4aMWSXlfgH7uOwLG5Q6N2G9f9mOIwBCnNI1PfeustnHXWWbjyyivxxBNPtOpvq6qqWCsl8mJmZma2eAo9FEpe1h+nPhSukE59VEff+zXLHv/y6oMxqDOXj5yW8dmS1Xhs/k8Y0LsnHr/0mJQy2wPPv4JvNnlx3rSpmHFgP3QUXvjfJtz72V+YPrwrHjtzZLu/b9ULV2LEjtfxfd4ZmPTPZ6EVT363Af9ZsI7Fk//n1OFIFm25f3PSzPPYFKpwMBqNmg/UkpIS+Hy+lmXGBoNsm/hUuva2slgsyM/P79AXkHA4jE2bNsFhMTLxmMzM01SxVZ8+fSAmK0FFbzgKsU7qgSwpJ+XsVJI9AuulHahM4oy7FraiRg5EvEoQleYMx7wtO+A2D8QkaIfTIm+3K0q3pFQZUxwuHvHSSy+xcXDEEUc0Ox5I+EWKPxKEDZfTgCdBSh5GOhGImpoa7N27l02f5+Xl1RM69Eo/6mdVQVRaWsoETUPUv2voMI61nLaHlsVjeeQ2xtr2ti5v6z6ptiK7khexNftE3089VOnJc8eOHejUqRN7EqXjQ8sjP0/L6PsbLqdjTd/f8KGAlqvf33BKhv6+YTYhCViyS+Ry+nv6PHmqSSA3XE7LIr3Y0cYeQdtNn6M+9PYs+bZQVu1hy1J5n7Q6TvQZstUNN9zQ6AaWqvvU3uNkoOrR1FJOueHTMrfbzex0zTXXwGaz6XafnGb5GJbXyGWGknGc6DtUW9G2xeM4mcNe5KAKgtcal33a1e1I3PZLNxxhLcBZiv21OE5dqn/Dv41vQSzuD+CAevuknntU65HWrfVx4rSdtPY8Pvfcc/jiiy8wZcoUHHNM81Mxs2fPxl133dVo+UMPPQSrVY4JGjlyJEvIoe9duXIlWzZ69GgMGjQIRUVFKCsrg8tVV1qBxArFYe7bt6/eiUIDnL6TRGfkwC8oKGADf8+ePfW2oXPnzuyEKi4urneydenSBV6vF+Xl5fW+u7CwkG0HCafIixOJsOrqavajYrfbkZ2djYqKCnbDUCExTD8k3iIvIrH2KTc3l+3T7t2747pPtD+0L23ZJ9puWjd9788//8y2m+Jg33nnHZZopTJt2jSMGjUKL7zwQr3tOfvss9GvXz82BiIvRjNnzmR2mDNnTr19oosibR+Vo1ChC+LNN9/MnrjpwhlpF0roWr16NUvuUunbty9mzJiBRYsW4YcffqhdHm3sEYceeigmTJjAfp9R+hgONq/GV+9OxOoT/pXS+6TlcSJoXL/44osdZp/ac5yCIT/+adiDYCkloBxcb58efvhhXe+TOViKfxlc2LZyIDBtv6Qcp+7du9faKl7Haf/QSqy0focFZUdj9eqcdu+TxdGX/f7nuvWYM+cLzY5Tt9BmXGL8HD+V7Qfg7kZjT0Xr4/TKK680Wieng8Y8zpo1q0XTvipXXXUV+venp5vGUJLMSSedhK5du2LJkiVMkLTF80gXBRJJ6pRnw6cgEk9bt25Ft27d2EnVEm8cHRISjSSeGsI9j409j2Qr8hq21vMY6U2lY7lr1y707t2beVH06P1pr+eRLuhT7GtwsOsrrOj3Dww/8+6U3ictPY90k+eex7rjtGHJfAz9/mL8LfbBgNtX1noeyU569zzufuEM9Cr+Fm/m/RNn/fPepHke6fyLp+dx22f/Qf/f/oOvzIdh6o3vtHufPlu9E/9+dxnG9srF0xdM1Ow4rf7lR6z4ci5qMvriuhvvbuR5pDGVCM8jhZHRQxKPeUwDz+Ozzz5bz2vXHFSeJ5p4pNI89B4Jjm+//bZFwlE9edUTv7nlaiyl2k9VzSCLFccRuZxOADUGM9bnY8X3RVuuCtT2Lm/JtrdneVv2SbVVwzCAWJ+PtS10/CI/EyvjL9byaOMi1nJaR7TltC3RltOFLlodUtrvaLG60RKAyE50ofyf/Sw8XHYgTuh0EEYp35mq+9TUtrdnn2hfVG94tO9JxX1q73Ey5vXCm8EpqLR0wYCImRGyE72q+6LHfarsOhFv7gY2CUVJO07qmCJbNXy/rcepcsQl6LNsOHo4nDgiDvvUd8cHWGO9E0vLD4TFMlWz42ToPhpzgn50F2y4rsE+qXai12SdT5wOKB4pdrC9fPbZZzj55JNZPOF3333HAnMTQWuSOehkoilYTuJs1dETk+hCSdOQd3y8BiskMw6S5LZtnNi24kRQMAi3BC9GnsWMmSlmp7Ih5+CWpYMwNJy8hDgtbGW1WFkZonglzAhKIXhDE60745ow42u83akypjhp1p5QFY4Ue0fCkWI29Ah5K8nDmkIRBUmD26pl0DTPihUrYDfLT/LVPNu6WVvxklp1qB15fMFwytkp0yp7pCqT2GFGC1up57LbH5/vNJhkT5xB0tZODmMYRcI+dPJtbfReqowpThqJRwqmJeGYk5PDhGOsWEg9wJvDc1vFG4oTouDzzsFduMjwOQbu/TTu6+hotoqMt0p3yFmUhRpkBktSzk5ZVgMy4YLBU5q0bdDCVhmV6/C46TFcG3o5Lt9nMFkSIh4zfbuxyHI13jHcikCofg5AqowpTopNW7eVtWvX4sQTT2TBuJR9RYXBG9KrVy/W55rD6ch0C2zFeabXsblkEIAbk705nBTB7t6N1dZLWXvLUPgsGMTUCfMo3DIfv1mvxP/CwxAOnwIxhba9KWzBKkwz/Iz14W5MhJna2XZTVLoIGcPaikebUw6ZccCLKm8A2Y7ocZMcfZMW4pFKwKhZYW+//XbUz1BaPxePieHCCy/Eyy+/zMIHKMM5VtB1S6Fs61tvvZV5l6l8T8+ePXHuueeybNl06h7TEox2+cJtCfG+spyWY7LKfZQt8MMXCMJuSZ3zypaZy14z4GLhGln21Nn2pjDb5Fa7NsHHpq6zbO0TjwazIh419jyarBm1/cZdrmouHlOUtJi2Jm9jZGmXaD/ff/899ER7BZVeoVqLVHeLElSo5uVHH33U7gcDqts1d+5cHHjggbj66quZKCUxSRn1PG5UhuxNddJMTrlDiJ2Lx2Zt1dGTqFqD2WJnrwZBgs/nTyk7mezymM+EO2lxj1rYymSlmpuADT544hD3aFSmrY3Q2EYmeSwRHldd7d1UGlOcNBGPqZhBTIWtO2J7pnnz5rFkIKp3RvsXWYS5LVDh3J07d+Kpp57C+++/z2qp/fTTTzjjjDMwf/78mJ7mdIOyGKnAbkZ2Afu/Xaqh4Npkb5aubcVLedRhVLxShN/nSS07WWVve6aQPPGoha0EsyzC7CQe45BxbTTL3mWTxp5HiCLckMeTxyV3aVNJmTHF4eJRj5C3jDx0HdFrRmKRanTRlPLkyZOxcOFCVkS9LZCNSIxSvOqll15au5yeWtUOB88//3zctj2VoQB08q5bnNns/2YEgaDcro0T3VY8aD8CQ91MiN/nTi07KeIxCy6Uu5LT4FoTW5nUaWs/3Io3uD1QoXciw6h9prNXkMWjv4F4TJkxxeHiUY90VPH4559/shaA1EecCrRTXCIVr6b4x7ZAnYEolnXiRLkbQiQU9zhw4EAsXryYl31QSmBQSy+HIwMhSZ4SCrsr2ntIO7SteLmQCEQRfiVEPqB4HlPGTop4NAkhVFbVtS5NJJrYyiSLPcLnrWsb21aynLIYzTZrf9/xifK2Bzz1xWPKjCkOF4/JhMSh2x+M+kPTELHeS/RPvESsOkV9zjnnsFdqD0m9pEk8Nmzb2BLWr1/PXqmlYDSoHBO1pmqrZ7MjkmW3oBrydJerKnmlSziphx/yVGLAK4vHlMHsQEi51VVXdKAxHxE76HdXx+H7bEBGVyCzK7TGXyseeeJeqpIW2dZ6hQTikNsXQO/8efeRsJvbN1So7+hrr73GeoCfcMIJbJnT6WQllF5//XV88803zCPZGqgnKaH2FW+Iulz9HAcwG0XshRPZcMFVUYKM7twqnJbhF0yABAT87fdyJRRBgNeYCUewAp7qMnQYqLc0zHIGvKflbXtjktMLmPUXEkHAYAfl5YR8cRC9nKTQ8TIyOLrk448/RnFxMU499VTW31WFpq6J9iTO8ODq5qHkpJEjR7LXGlEuleGpqiv4zIluK04dAcXzGPR5U85OAZM85r1JEo9a2covyrGoIW9qefCCJB5p9s1Xf7tTaUylO9zzmERsJgPz6qXCdrYXVRyqYlFl6tSp6NatGxOXVLqHyuy0lKysrFqvZrSLTVVVVb3PpTNU73L69Onsd7chE5Qv46/pQFN4GtmKU0dQNAMhIOj3pJydQuZMwAOEXMkRj1rZys8ST6oRiEPMYyIJGuVpa6mBFzuVxlS6w+V9EqGsYJoObvhjNYrwu2vYa7T3E/3T3ppb27dvx1dffVVbjJ2+T/0xGAys1A4lvtD0dWtQW0yuWbMmaswkxUSSV7JHjx5Id0hgU+kieqUpPCJYzcVjc7biRNhFkD2PIb835ewk2eSHUsmTHPGola2CBnkWJ9jAg6d3JIMiHgP1xWMqjal0h4tHneJ2p9aTZFNQAW8Sd5QVfdFFFzX6Oe+889o0dT1+/HgmDqlXecOkHkqSWbduHQ466CBWGijdIfuvXLmSvf6RdQgeDZ6E7Y6hyd4s3duKU0eIPI9kn4An5ewkOvLYqzFJ4lErWwWUxJOwUj4pVQgrmeKCMpZql6fQmEp3+F2Voykk6iibmryMr7zyCvr06RP1c3///TcrvfPrr79i9OjRLfpuSog5/fTTWSLOs88+iyuuuKJ2nVQ8nLjkkkviuDcdg00Fh2Pe1kG4zjIg2ZvCSSFCDTyPqYTJKYtHk79jlafanDUOy135qBSiJw3qldW9LsIN28ZhfOYQTEn2xnDaBBePHE359ttvsXnzZjZdHUs4EhdccAETj+R9bKl4JGbPns0Kjf/jH/9g6+rXrx+rE0b1JKltIXWa4dRH7e2brG4bnNTkg05XYvn6XTg56wCkGoZxl+CUZd2wTeqEGf5gu6tH6IWfev8DT2/diAvN0cuV6ZVQZhHWSVXoL8mJTJzUg09b6xDy0mVkZHSI/p7qVPT555/f5OfIg0gdDt566y14PC2vI9e1a1fWkYC+f9GiRXj44YdRWlqKe+65B++9916HsGE8oNhSEvD0evmhfbH0lqmYdcTAZG+W7m3FqWOfczB+kQbVerlSyU62LoOwxjgE+5CDkur2d2NpLVrZSk1m9ARSqyOLut3eBm0VU2lMpTsd4/Grg4rHjsCbb77JfloyBd2WOE+yFSXOvPTSS23cwvSA4j4nTZrEfs/lZ32LbcWpw2KUb+i+YDjl7ETXicIMK7aVubG32oseeXUFthOBVraymw0wIgifUj4pVejsXot/Gj6AuYKSHsfULk+lMZXucM+jDqFgYfKe8aBhbqt4QZ12KJudXjncVm1hoGcVzjMsQE75b6k3pmr24TzDVzjXsAB7qxIvtLSy1SHrZ2OD9Vwcuq91lSqSTWHVn5hleg9jXN/XW55SYyrN4eJRp1DpGg63VbygJKKNGzd2uH7pWsBtFZ0RFV/jLtMrKCr7OfXsVLMXF1U/hX8aP8SeysSLR61sJRjlUj1iMLU8j4G8gXgzOAXLDCPrLU+pMZXm8Aksju7K+mzZsqXZz1GLwxEjRiRkmzgcDlCWtR8+2bMXlcYU7GmZ0QV/5kzGsmJTUjyPWrFl2L9wyp8TMaiwM6YhdQh0G4dbgmH0Eu34V7I3htMmuHjk6E48UrZ0c/Tq1YuLRw4ngWzpdSruXjMU02xdMSPVLO/Ix7apz2Dtun04tEcOOgpmRzYq4UR1ILUmEW1mOX7W7a+fMMNJHbh41GlwN7XUS8dMYcqcbg3pbKvWQIHoVLqIF0zntmorDotyw/cFU3JMHbVfZ/aTDLSyVV22dWqJMJsByEIN7IH6nXFSbUylM/wI6RASQg6HI9mbkRJwW7UMKn0xatQojY9Gx4DbKjpUG1FEGH6lm0nK2Yni6DzlAMUJmhObba2VrfLKV+N+4wvY5+kJIHWylDMr/sRq66XYJVHx9tNrl6fcmEpjUsvXnSZQlvW+fft4tjW3Vdyg7MWnnnqKZzFyW7WZAdvfwSbrDFxW+kBqjqm5xwH/1xtYvyDhq9bKVg73dpxl/BbjQ78ilbDY5FJ0VvgQCNW1Iky5MZXGcPGoU4LB1Cr6mky4rZqHsheLi4t5FiO3VZsxWmRvnSnkSc0xpfS3prI9iUYrW5mtTvk1nFpJQGa7PLNmg7/elHvKjak0hotHDofD4TSLSfEWWcIt7wClK/L6A52GUZYJOgpmmyrC6nvw9I7Zqmy34IdXiaHlpBY85pHD4XA4HV88Tr1N/ulAmGzO2ulf8uCZDKnhDxJMdTGnHo8LyLIldXs4rSc1RloaJoHk5ubyDGJuq7hhMplw9tlns1cOt1VbsNrlntY2ycOmFfmYSv75F+nB86RS2RtTnVjsZKubouZjKnXgnkedikerVe4cwOG2igeiKKJfv358OHFbtRmLQxaPdsHH+ltbTQY+ppJ8/glm2fNohw9lqSQeRQPQfRwgmmA11pVZ49ep1IF7HnWabb17926ebc1tFdd2l7Nnz+ZtL7mt2u15tMMLly/Ix5Qezj/Fg0fT1ilXcPuir4ALPmMF3FX4dSp14OJRp/BsM26reMPLX3BbtQfRWuflcnkDfEzp4fxT6lWahRA8vtTKuI4Fv06lBlw8chIC9aum6fiGP1QMff/998ddd92Fmpr63QZaA3lqL7roInTp0oVN+Q8cOBD33XcfAgH5JsfhcNqJkuQgChJqXNXcnHogIvHE72779ZPDaS085pGTUPr27YsZM2bUq+n1xRdf4M4778SXX36JRYsWsS4DrYEKqk+fPh07duzAiSeeiP79+7P+2LfeeiuWLVuGjz76iCcfcThxFCquqkqgcy63abIxmBGCCAN1/vFwQc9JHFw86hDyyBUUFHRIwUNB4yQUI6E4lwkTJuDnn39mom/KlCkt/j6y0X//+19s374dTz/9NC6//PJaYXrWWWfh7bffZj9nnnkm0hnKYpw5cybPtua2ajuiCK9ghVXyorq6go8pPZx/ggCfYIVdciPgdSHV4dep1IFPW+uU1nrfUhmLxYLJkyez30tKSlr1t9XV1Xj33XfRp08fXHbZZfVE5Zw5c9jvzz//PNIdskdWVlaHfCCJN9xWsfGJcoKGu6aK20knYyogWOTXDiAe+bmXOnDxqEPIa7Znz560SZqhAOnvv/+eXThGjBjRqr/96aefmOfysMMOa3Rh7tmzJ4t9XLx4MUKhFMtE1MDGJKZ5MDq3VXsIGOS6gt6acj6mdHL+rXeMxHeh4XCHU7+GK79OpQ582loP+Bs8MYbDEAJuebkYQ98bLIBBOXyhIBDyAYJYr/hqo+9tCQYzYFAuQuGQXI8rjmzYsKF22prEMXkaFyxYgJ07d+L//u//MGDAgFZ/H0FxjtGg5evWrcPWrVuZd5LD4bSd73rPwme/78Jg9OBm1Anv9LwT7xTvwPWmomRvCieN4OJRD9zftd5/SS52ae5vTp0LDD1R/n3tJ8C75wM9J8p1s1QeGQa4S1u3Lcc8CIy9RP59609A74MRTzZu3Mgyqxty3HHHMe9ha6msrGSvmZlyDbqGqMvVz3E4nLZT0W0Svl/9F7L9vImBXrCZ5Af8lOoww0l5+LQ1J6EceeSRzOOo/pDn8eOPP8aaNWtw0EEHYenSpfyIcDg6Jc9pZq/7quNc7JrTZmxm2QdEva05nETBPY964JZd9f6rCiu1FmLMaWuVQdPk76Bp60iu/r1t09YqPQ+E1uTl5bEyO3a7HYcffjgrr/P111+3+O8pCJ2oqqqK+r66XP1cumI2m3HTTTexVw63VVvpL+7EyeKP8JUUwWwex8eUDs6/EzbdgX9ZvsPne64FMASpDL9OpQ5cPOoBsxyEXoskIRQMwmg0slIMzUKxj2r8Y1Pf21riHO/YFOPGjWOvv/zyS6v+To11XL9+fdT3aTldkHr0SO8YLXoYoan7/Px8nnHNbdVmepV8j/+an8E7rkNR5roEIXcVH1NJPv9MQpj1GxfaEuOuM/h1KnXg09Y6RC2enS7Z1kR5eXltX+/Wik4Sh998800je1GSDCXL0HQ4E+JpDHXaoTqYvOMOt1V7cHQdgv+Fh2OdVIQD7l2Iax9/h4+pJI+pVUOux0TfI/jBcQRSHX6dSh24eOTogoceeoi9HnLIIa36O0qIoWnvTZs24dlnn61dTkLy5ptvZr9fcomSAMThcNqFOGQaHu0yBy+GjmX/zxXd3KLJJqMrdkiFKA/ykBRO4khvdwwn4USW6iHKyspYHcYVK1YgJycHDzzwQKu/85ZbbmGJNldccQXzQFIXG+pUQx1rpk2bhjPOOCPOe8HhpC+njemOX7eWY2yvbOTu8SR7c9Ieu1kOL/LyhBlOAuHiUad01E4gDUv1UHeZoqIi1rqLAsrbEpvYuXNnLFmyBLfffjs+++wzfPLJJ6xA+D333IMbbrihw9qytfBkGW6reHDa6O4Y382CbLsFTz71Y1y+Mx3Q6vzrXPErbjLOQ0X1YADaJzlqDb9OpQaClE6BdXGGMnkpi5cCoWPVGfR6vdi8eTN69+4Nq5XXRtMr/DhxOC3kucnArhXAkfcD469oWVIfRzO2zZ+NHivmYIFxMo689SNu6Tjevzmx4TGPOoT0PIkZruu5reIFJSJRyEBrE5LSEW6rZuiklINZcAs2//YTH1NJHlMZGbLw6Z2V+rdzfu6lDqk/2jogJBopFpCLR26reGYxvvHGGzwzltuq/Uy8Fuh5EIKTb8erH33Dx1SSx1ROtlzDdkBu4kqraQW/TqUOPOaRozvmzp2LLVu2NPu5E044Afvvv39CtonD4Sjk9QUu+Bwhnw/4fg43S7Ix2eXXAE9e4iQOLh45uhSPlC3dHL169eLikcPhpDeqeOwARcI5qQMXjzolnYtaf//9962KkUlnW7UUyjgvKCjgmefcVnxMdbTzz+IErFnt7yimA/h1KnXg2dbtgGdbdxx4tjWHw+GkDzzbun3whBkdQokyLpeLJ8xwW8WNUCjECrHTK4fbio+pxMLPP26njkbaiEfKdDvxxBPRt29fZGRkwOl0YujQobjmmmuwc+dO6LE5PM+25raKF8FgkBVPp1cOtxUfU4mFn3/cTh2NtAkWe/vtt7F+/XqMHz8eXbp0YcJs1apVePTRR1mCxqJFi5iY1AouBPUNPz4cDofD4bSMtBGP7777btQOLy+++CIuvvhi1m+ZPhNvDAZDbf0qm80W9+/nxAe1/pp6vDgcDofD4aT5tHWs1oCnnnoqe6Xq/1pgMplY/+bWTkPT33ASYys1TIC+h45XR4SyGClkg/f55rbiY4qff3qFX6dSh7TPtn7rrbdw1llnYcaMGXjttdc0ydaiz1FcJcVZ0udJoPCbePIh0UgeRzp+NTU16NatG+9xyuFwOGkAz7ZuH2kzba3yzjvv4M8//4Tb7cYff/yBBQsWoHfv3rj77rub/Vufz8d+Igdfw+WiKDJxSKJE7WNKHq3OnTujvLwcO3bsaPS9JCQjvZL0u9/vj+lRa/j5WMtSfXlLPqvaymw2M9u3ZZ30t4WFhczeFNhOdSPpOyP/hpbRlHbD5XSsab2R40JdTt9Pn4+E1qWK1kho3TReIpfT39PnKVMzMtFFXU7LIrOno429yKl4KrxOMb9qXcxU3yetjhNtw7Jly3DQQQc1Gjepuk9aHCda75IlSzBhwgS2rCPsk1bHif6e6teSrdTzL9X3SYvjRNv7888/49BDD2Xfo/U+cdpOWorH999/v/b/o0ePZsk0JCCbY/bs2bjrrrsaLX/ooYdqp8VHjhyJ6dOn44svvsDKlStrP0Mnw6RJk5inMzK7e/LkySxR580332T9rCO59NJL8fLLL9c74c4880yWLf7cc881+mx1dTX7fhU6oS677DJs3bqVZdqq5ObmMm8riefvvvuudnmPHj3YttONk35UhgwZgilTpuDbb79lwltl7Nix7Gf+/PnYtm1bs/s0bdo09OzZE88++2zc9yknJwdnn312q/fpm2++wfLlyxsdJxonGzdurLfto0aNwgsvvIDi4uLa5bTOfv36sTEQeTGaOXMm8zLPmVO/fdtNN93EPJ1PP/107TK6IN58883YtGkTqwqgQkWFr7jiCqxevbrevtL0M3nKKckrshNPU2OPblr0efrpKPuk5XEi+vfvz2KiO8o+aXWcFi9e3OH2Kd7HqXv37sxO9NNR9kmr40RMnDiRXcu13KdXXnml3jo5HXjaetasWY2edJriqquuYjeAaFRUVLCB9u9//5sJog8++ICJidZ6HumisG/fvtrpzng82dE6Hn74YXbCNYQ/rdZ/WlVtde211zIB2lGewCO3PR77RJ+jCzqVplI92qm+T1odJ3VM3XDDDexvOsI+aXGcaPaG7ERjipIBO8I+aXWc6Dsann+pvk9aHKfIex+tW8t9KikpYeK7ubAzTgfwPJLHiopnt5RTTjklpnjMzs5mHrIvv/wSAwcOxLnnnovNmzc3mTBBAz3aVHK05bG+hwZ/a5bHmrqOtpxOrmjL6eSKtpxOoGjZxXRyRWv5p+d9UtfVkfZJJR77pF5so43VVN2nprY9HvsUa9tTeZ/ieZzUz0cmmqX6Pml5nNTtb7hNqbxPHfU4cTpYtjUlNdATREt/yGXdHPTEQXFgNJWsVcZ1a6GTiVzxDb0eHG4rPqb4+acX+HWK24qPqfQlpaattWLcuHEsHo6KiFMcR0vh2VocDofD4aQe/P7dPtLCtUVJF+vWrYv63ksvvcSEI01vt0Y4agnFblASSsP4EA63FR9T/PzTC/w6xW3Fx1T6khbisbS0FIMHD2aZwRTbSBlel19+OQ444ABcdNFFbOpaT5lXFPRLyTyRwb8cbis+pvj5pyf4dYrbio+p9CWlEmbaCmVU3XbbbazO1tdff83EJAXL9urVi2W/UaZuUVFRsjeTw+FwOBwOR/ekhXh0OBxR6zO2FzVcVC0WHi+oXIHX62Xfy9sUclvxMZVY+PnH7cTHVMc/99T7Nk/7aBs8YaYdULcYqvPI4XA4HA4n9di+fTufeWwDXDy2M+Zn165drDh1PHtVq8XHaVDz4qXcVnxMJRZ+/nE78THV8c898jhSMm3Xrl15Wbw2kBbT1lrWOdMyVpJOHi4eua34mEoO/PzjduJjqmOfe9RKkdM20iLbmsPhcDgcDocTH7h45HA4HA6Hw+G0GC4edQhlmd1xxx0805rbio8pfv7pFn6d4rbiYyp94QkzHA6Hw+FwOJwWwz2PHA6Hw+FwOJwWw8Ujh8PhcDgcDqfFcPHI4XA4HA6Hw2kxXDxyOBwOh8PhcFoMF4864pdffsExxxyD7Oxs1o97/PjxeOedd9CRef3113HZZZdh9OjRLHuTOvXMnTu3yQ4E1157LXr27Mk+36tXL1x//fWoqamJ2QXo8ccfx7Bhw2Cz2VBQUIAzzzwTmzZtQiqxc+dOPPLIIzjiiCPQo0cPmM1mdO7cGSeffDKWLl0a9W/S1VbUG5f2+5BDDmHdI6xWK7PVQQcdhJdffhmBQKDR36SrraLxwAMPsPOQfn7++edG76errWg/Vbs0/Jk0aVLUPs133303+vfvz8YgjcVLL70U+/bti7mON954A2PHjmXX/5ycHBx33HFYsWIFUpEPP/wQhx9+OPLy8tj+9+7dmx136h4TSbqOp5RH4uiCb7/9VjKZTFJGRoZ0ySWXSNdee63Us2dPiQ7Rgw8+KHVU1H3Mz8+v/f3ll1+O+tmamhppxIgR7DNHHHGEdOONN7JX+v+YMWMkj8fT6G8uvvhi9v7QoUOlG264QZoxY4ZkNpul3Nxc6e+//5ZSBdpX2o++fftKF110kXTTTTdJJ598smQwGCRRFKW333673ufT2VbFxcWS1WqVDjnkELZPN998s3T55ZfXji+yQygUqv18OtuqIb///rtksVgkh8PB9m/JkiX13k9nW9H4ycrKku64445GPw2vWTS+jjzySLbf48ePZ3Y66aSTJEEQpD59+kj79u1r9P333nsv+zyth67/dB+g+wEdj0WLFkmpQjgcli699NLa69UVV1zB9v+cc86RevToIf3vf/+r/Ww6j6dUh4tHHRAIBNhJRheJlStX1i6vqKiQBgwYwE6MLVu2SB2Rr7/+unbfZs+e3aR4vP3229n7dIGJJqzuv//+RoKclpOI8Pl8tcs///zz2otVqvD+++9L33//faPlP/74I3voyMnJkbxeb+3ydLYV3bgj9yHyPJs0aRLbn08//bR2eTrbKhK/3y+NGjVKGjduHLshRxOP6WwrEnX00xJeeukltn9nnnkmE1MqTz/9NFtO4ioSEj1Go5Fd7+m6r0L3A7ovDB48uN4Dj5555JFH2D6SaAwGg1HPQ5V0Hk+pDhePOmDBggVs4F9wwQWN3ps7dy5776677pI6Ok2JR7oAd+3aVXI6nexpNRL6Py2nJ/pI6MJN3/fDDz80+j5VRGzdulVKddQn9V9++YX9n9sqNo8++iizFd3guK3qQx40Eip//PGHdN555zUSj+k+rlojHidMmMD2reFDP9mQbESeXbfbXbucvOP0+VdeeaXRd51//vkxbag3aJ/oQZb2MVIkRiPdx1Oqw2MedcD333/PXimerSFHHnkke/3hhx+Qzqxfvx67du1icWsUDxQJ/Z+WU8xLZDwN2VV9ryPb1WQysVej0cheua0QM1bqyy+/ZL/vt99+3FYRUFzdfffdxzpbDRkyJKr9+LiS4xgpJvv+++/HE088ETXemGJuafnAgQNZHF8kFB9JcYAulwu//vprh7sHfPXVVygvL8cJJ5yAUCiEDz74AHPmzMEzzzyDDRs21PssH0+pjXy34SQVOokICqxuCAX6O53O2s+kK03ZSF2+YMEC9rnu3buzi/Pu3buZSDAYDFE/H/m9qcq2bdvwzTffoEuXLiyAnOC2kvH7/ewmTzMspaWlWLhwIdauXYsLLrgAU6dO5baKEETnnnsuRowYgRtuuCHmWOPjCtizZw8bP5GMGTMGb731Fvr27cv+v3HjRvag0tS1SrXnwQcfXPs7Xefpet/U5/XO8uXL2Stdc/fff3/8/fffte+JoohrrrkGDz74IPs/H0+pDRePOqCyspK9ZmVlRX0/MzOz9jPpSktsFPm51n4+FaGs4XPOOYfd/ClDVhXJ3FZ14vGuu+6q5/W57rrrMHv27Npl3FbA7bffzm7kdOOP9qDFbSVDopHEHj2QktAjYfTQQw/htddeYw8jv//+OzIyMtp07aHfCwsLW/x5vaJmkpNdRo0ahWXLlmHw4MFYuXIlyzT/73//y0T2zJkz+bmX4vBpaw4nBSHPxvnnn48ff/wRl1xyCRORnPrQDZ68jjR9RuEMTz75JF544QVWVoXKg3CAJUuWME/QrbfeWjuVz4kOTelPmTKFiTy73c48ta+++io797Zu3Yrnn38+7U1H1yWCSol99NFHzCtL5yGJ7nfffZd5H0lAclIfLh51gPqEGuvJkm50sZ5i04WW2Cjyc639fKpdoC+88EK8+eabmDFjBosnioTbqj50wyoqKmLejueeew6LFy9m8X3pbqtgMIjzzjuPTS/edNNNzX4+nW3VFFSnlqBx1db9pt87gp3UbaS6vVTXMhJ6OOnTpw+b1q+oqODjKcXh4lEHNBXTQjE2VCw1VvxMutBc3E/D+BlKlKE4wM2bNzPPU3OfTyXhSNNnr7zyCiuMS8H7JI4i4baKjZqQoCYopLOt6LpC27tq1SrmKYosek3ji5gwYQL7P3mR0tlWTZGfn89eKc6aIIFE52RL7aT+TseDrvct+bxeoSQhghpdRENd7vF4+HhKcbh41AGHHnpobaZaQygJJPIz6QpdOOlJlp7u1Yu0Cv2fllMHA0qWUSGbqe/Fsit1IUk14UhTZaeffjqLtYqVDJTutooFZexHZqins62om8dFF10U9UcVKtOnT2f/p64f6WyrplAzrslGBHU9oS4x69atY9PZkVAYxddff82ENXnnOto9YPLkyez1r7/+ihqjTRnXtO/UFYaPpxQn2bWCOHLRVKpn1VSR8M2bN3d4U/Ei4bGhAsFq7b1TTz212Rpq6Vx8l+oUulyuRstp2VFHHcX257777qtdns62ikW0Oo/pbKu//vor6pii5Z07d25Ue7C1RcLXrVvXYYqEq3Vnn3/++XrL7777bracCtCn+3jqCHDxqBPStT0hXWDoRkU/1N2C9veggw6qXRZ5AaLCscOHD6+9SFCLvshWVpFFd2O1sqIWWWorK7pgp1IBZ9oPKpz773//O2qLtMgHj3S3FZ1HRx99tDRz5kx2I6IbVl5eHtu/gw8+uN7+p7OtWise09VW6pg69thjWeeU66+/Xjr++OPZNZv2jYp8N9eekNqJUnvC3r17d+j2hBs2bJAKCwvZvpC9Zs2aJU2ZMqV233bv3i2l+3jqCHDxqCOWLl3KPCOZmZmSzWaTxo4d26hncUdDvUnF+qH3I6Gn8quvvlrq3r07u3BTr1S6OFVVVUX9frqIU1cRutDQRZgExOmnn84ucB3JTtE686SrrajTDt14aT+ys7OZR4f2ZfLkydKzzz4b1WubrrZqrXhMV1tRa9DTTjtN6t+/P7s+05gijyMJSOoQFg1qF3rnnXey1rMkbujzJHz27NkTcz2vv/66NHr0aHb9pz7axxxzjLR8+XIp1di2bRvrjEP7TGOExsqVV14p7d27t9Fn03E8dQQE+ifZU+ccDofD4XA4nNSAJ8xwOBwOh8PhcFoMF48cDofD4XA4nBbDxSOHw+FwOBwOp8Vw8cjhcDgcDofDaTFcPHI4HA6Hw+FwWgwXjxwOh8PhcDicFsPFI4fD4XA4HA6nxXDxyOFwOBwOh8NpMVw8cjgcDofD4XBaDBePHA4npZg0aRIEQUCqQE28DjjgABxxxBFt+vtbb70VGRkZ2Lt3b9y3jcPhcNoCF48cDidpkAhszU8q8uqrr2LFihW4++672/T3s2bNgiiKuOOOO+K+bRwOh9MWeG9rDoeTNO68885Gyx555BFUVlZGFUv0+W3btsHtdmPQoEHQO+FwGH379kX37t3x448/tvl7SEA++uij2LhxI3r27BnXbeRwOJzWwsUjh8PRFb169cLWrVvZdG+q89lnn+G4447D888/j4svvrjN37Ny5UqMGjWKTWHfc889cd1GDofDaS182prD4aR8zOPcuXPZMnr95JNPMG7cONjtdnTr1g233XYb8wASr7zyCoYPHw6bzYYePXrgP//5T9R1kHB96aWXcNBBByEzM5N91+jRo9my1vDyyy+z7Tr55JMbvbd7925cddVV6N+/P9ue7OxsDB48GJdffjnzvEYycuRI9OvXj+0fh8PhJBtjsjeAw+Fw4sWHH36Ir776CieccAITfuT5u/fee5kYzMrKYr8ff/zxTIC+//77uOGGG9CpUyece+65td9Bnz377LPx1ltvMWF31llnwWw24+uvv8ZFF12EP//8Ew8++GCz20Lf891332HgwIHIycmp9x5Nu9P2bdmyhSXSnHjiifD7/di8eTNee+01XHfddWx7I5kwYQJ77++//8aAAQP4oOFwOMlD4nA4HB3Rs2dPmq+O+f6hhx7a6P2XX36ZLTOZTNKyZctql1dVVUmFhYWS3W6XOnfuLG3cuLH2vW3btklms1kaNmxYve967rnn2HddcMEFkt/vr13u8/mkadOmsfd+/fXXZvfjjz/+YJ89++yzG703f/589t7VV1/d6L3q6mrJ6/U2Wv7oo4+yv3nppZeaXTeHw+FoCZ+25nA4HYYZM2ZgzJgxtf+nEjcUc0ievpkzZ6JPnz6171ESy8SJE5knMRgM1i5/4okn4HA48OSTT8JkMtUuJ+/jfffdx34nr2Rz7Nixg72SZzMWNF3dEKfTCYvF0mi5+j3q93I4HE6y4NPWHA6nwzBixIhGy7p06dLke6FQiNVQpPhIEpm///47unbtigceeKDR5wOBAHtdu3Zts9tSWlrKXimWsSGHHHIIW/ecOXOwevVqJnAPPfRQFvMYqyRRbm4uey0pKWl23RwOh6MlXDxyOJwOAyW3NMRoNDb7nioKy8vLWazizp07cdddd8Vcj8vlanZbVK+i1+tt9B7FM/7888+4/fbbWYLP559/XusNvemmm3DFFVc0+huPx8NeKXmHw+FwkgmftuZwOBwFVWBSRxgSkbF+KBGmOQoKCthrWVlZ1Pcp25uyp4uLi1kpHvJ0Ulb4lVdeGXVaXP0e9Xs5HA4nWXDxyOFwOBExkjR1/Ndff6GioqJddhk6dCjrDLNu3bqmL8KiyKbUKfNbFY3z589v9Dn1e4YNG8aPF4fDSSpcPHI4HE4E//rXv1js4yWXXBJ1eprK6VCJneagWMf9998fv/76a22dSZU//vgjaq9qdZnVam303tKlS9k0+4EHHsiPF4fDSSo85pHD4XAiuOyyy1g8IhUUX7x4MQ477DCWQEPCjhJlSMS9+eabrBNOc1D9RmqzSN8XKfqoZuT111/Paj1Szca8vDxs2rSJeRxJONLUdSQ1NTXsOw4//HCWCc7hcDjJhHseORwOJwK1U828efPY1POnn36Khx56iAk+EnZUIJwEZUugloTkLXz99dfrLT/yyCOZQKyqqsIHH3yAhx9+mHkoTz/9dCxfvpx1s4mECppTwgwJWw6Hw0k2vLc1h8PhaMg555zDOt1Qv26KqWwLBx98MPN8UiymwWCI+zZyOBxOa+CeRw6Hw9EQaolIXsPHH3+8TX+/cOFCLFq0iGVjc+HI4XD0ABePHA6HoyE9e/Zk8ZNt9TpWVlayqXKKn+RwOBw9wKetORwOh8PhcDgthnseORwOh8PhcDgthotHDofD4XA4HE6L4eKRw+FwOBwOh9NiuHjkcDgcDofD4bQYLh45HA6Hw+FwOC2Gi0cOh8PhcDgcTovh4pHD4XA4HA6H02K4eORwOBwOh8PhtBguHjkcDofD4XA4aCn/D2RrAvFgJCIbAAAAAElFTkSuQmCC" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[1;32m================= nnodely Model Results for validation_set ================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 9.094e-07 |\u001B[0m\u001B[32m 3.294e-03 |\u001B[0m\u001B[32m 1.076e+06 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 6.473e-04 |\u001B[0m\u001B[32m 6.261e-04 |\u001B[0m\u001B[32m 1.078e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 3.241e-04 |\u001B[0m\u001B[32m 1.96e-03 |\u001B[0m\u001B[32m 1.077e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" + "\u001b[1;32m==================== nnodely Model Results for test_set ===================\u001b[0m\n", + "\u001b[32m| Loss |\u001b[0m\u001b[32m mse |\u001b[0m\u001b[32m FVU |\u001b[0m\u001b[32m AIC |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m small better |\u001b[0m\u001b[32m small better |\u001b[0m\u001b[32m lower better |\u001b[0m\n", + "\u001b[32m|-------------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| curv_error |\u001b[0m\u001b[32m 2.795e-07 |\u001b[0m\u001b[32m 1.134e-03 |\u001b[0m\u001b[32m 1.771e+05 |\u001b[0m\n", + "\u001b[32m|heading_error|\u001b[0m\u001b[32m 3.503e-04 |\u001b[0m\u001b[32m 4.191e-04 |\u001b[0m\u001b[32m 2.193e+05 |\u001b[0m\n", + "\u001b[32m|-------------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| Total |\u001b[0m\u001b[32m 1.753e-04 |\u001b[0m\u001b[32m 7.767e-04 |\u001b[0m\u001b[32m 1.982e+05 |\u001b[0m\n", + "\u001b[32m|-------------------------------------------------------------------------|\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, + "output_type": "display_data" + } + ], + "source": [ + "lat_dyna_control.analyzeModel(\"test_set\", prediction_samples=200) # 10s prediction" + ] + }, + { + "cell_type": "markdown", + "id": "ff7c6cbf56193020", + "metadata": {}, + "source": [ + "### Plot: curvature comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f1e195980e10ddfd", + "metadata": { + "ExecuteTime": { + "end_time": "2025-12-09T20:44:36.155503Z", + "start_time": "2025-12-09T20:44:31.326411Z" + } + }, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m==================== nnodely Model Results for test_set ===================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 4.818e-07 |\u001B[0m\u001B[32m 1.589e-03 |\u001B[0m\u001B[32m 2.147e+05 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 9.289e-04 |\u001B[0m\u001B[32m 8.999e-04 |\u001B[0m\u001B[32m 2.664e+05 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 4.647e-04 |\u001B[0m\u001B[32m 1.245e-03 |\u001B[0m\u001B[32m 2.405e+05 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" + "\u001b[33m[__call__] Different number of samples between inputs [MAX 1105 = 1105; MIN 1076 = 1076]\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" } ], - "execution_count": 11 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "### Plot: curvature comparison", - "id": "ff7c6cbf56193020" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-12-09T20:44:36.155503Z", - "start_time": "2025-12-09T20:44:31.326411Z" - } - }, - "cell_type": "code", "source": [ "data = pd.read_csv(\"dataset/test/test_set.csv\")\n", "\n", "sample_test_set = {\n", - " 'controller_vx_in' : np.array(data['vx']),\n", - " 'model_vx_in' : np.array(data['vx']),\n", - " 'controller_curv_in' : np.array(data['curv']),\n", - " 'model_curv_in' : np.array(data['curv']),\n", - " 'controller_steer_in' : np.array(data['steer']),\n", - " 'model_steer_in': np.array(data['steer']),\n", - " 'model_ax_in' : np.array(data['ax']),\n", - " 'controller_ax_in': np.array(data['ax'])\n", + " \"controller_vx_in\": np.array(data[\"vx\"]),\n", + " \"model_vx_in\": np.array(data[\"vx\"]),\n", + " \"controller_curv_in\": np.array(data[\"curv\"]),\n", + " \"model_curv_in\": np.array(data[\"curv\"]),\n", + " \"controller_steer_in\": np.array(data[\"steer\"]),\n", + " \"model_steer_in\": np.array(data[\"steer\"]),\n", + " \"model_ax_in\": np.array(data[\"ax\"]),\n", + " \"controller_ax_in\": np.array(data[\"ax\"]),\n", "}\n", "\n", - "out_nn_test_set = lat_dyna_control(sample_test_set, sampled=False, prediction_samples=1100)\n", + "out_nn_test_set = lat_dyna_control(\n", + " sample_test_set, sampled=False, prediction_samples=1100\n", + ")\n", "\n", "# plot the results\n", "plt.figure()\n", - "plt.plot(data['steer'],label='telem')\n", - "plt.plot(out_nn_test_set['controller_steer_out'],label='control')\n", - "plt.xlabel('samples')\n", - "plt.ylabel('steer (rad)')\n", + "plt.plot(data[\"steer\"], label=\"telem\")\n", + "plt.plot(out_nn_test_set[\"controller_steer_out\"], label=\"control\")\n", + "plt.xlabel(\"samples\")\n", + "plt.ylabel(\"steer (rad)\")\n", "plt.legend()\n", "plt.grid()\n", "\n", "plt.figure()\n", - "plt.plot(data['curv'],label='telem')\n", - "plt.plot(out_nn_test_set['model_curv'],label='control')\n", - "plt.xlabel('samples')\n", - "plt.ylabel('curvature (rad)')\n", + "plt.plot(data[\"curv\"], label=\"telem\")\n", + "plt.plot(out_nn_test_set[\"model_curv\"], label=\"control\")\n", + "plt.xlabel(\"samples\")\n", + "plt.ylabel(\"curvature (rad)\")\n", "plt.legend()\n", "plt.grid()" - ], - "id": "f1e195980e10ddfd", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[33m[__call__] Different number of samples between inputs [MAX 1105 = 1105; MIN 1076 = 1076]\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - } - ], - "execution_count": 17 + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# Export ONNX", - "id": "3d9052e0787f7564" + "id": "3d9052e0787f7564", + "metadata": {}, + "source": [ + "# Export ONNX" + ] }, { + "cell_type": "code", + "execution_count": 17, + "id": "d2fd6c9e3bc23d6a", "metadata": { "ExecuteTime": { "end_time": "2025-12-09T20:44:55.789536Z", "start_time": "2025-12-09T20:44:53.780921Z" } }, - "cell_type": "code", - "source": [ - "# Save json model\n", - "lat_dyna_control.saveModel('control_model')\n", - "\n", - "# Remove Minimize\n", - "lat_dyna_control.removeMinimize(['heading_error','curv_error'])\n", - "lat_dyna_control.neuralizeModel()\n", - "\n", - "# Export ONNX\n", - "lat_dyna_control.exportONNX(['controller_curv_in', 'controller_vx_in','controller_ax_in','controller_steer_in'],['controller_steer_out','controller_steer_from_ic','controller_steer_from_target'],'controller',models='control_steer')\n" - ], - "id": "d2fd6c9e3bc23d6a", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m=============================== Save JSON Model ================================\u001B[0m\n", - "\u001B[32mModel saved in: trained_models/control_model.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Connect on model_steer_in with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {'A': {'dim': 5,\n", - " 'values': [0.12241744995117188,\n", - " 0.13215704262256622,\n", - " 0.13487723469734192,\n", - " 0.13838686048984528,\n", - " 0.14319394528865814]},\n", + "\u001b[1;32m=============================== Save JSON Model ================================\u001b[0m\n", + "\u001b[32mModel saved in: trained_models/control_model.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Connect on model_steer_in with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {'A': {'dim': 5,\n", + " 'values': [0.10271348804235458,\n", + " 0.11061573028564453,\n", + " 0.11115050315856934,\n", + " 0.11318214982748032,\n", + " 0.11924726516008377]},\n", " 'W_fir': {'dim': 1,\n", " 'sw': 30,\n", " 'values': [[0.023806948214769363],\n", @@ -2674,7 +2665,7 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify7': {'centers': [8.0,\n", + " 'FFuzzify6': {'centers': [8.0,\n", " 10.142857142857142,\n", " 12.285714285714285,\n", " 14.428571428571429,\n", @@ -2685,7 +2676,7 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify8': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", + " 'FFuzzify7': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", " 'dim_out': {'dim': 5},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", @@ -2704,7 +2695,7 @@ " 'n_input': 3,\n", " 'name': 'understeer_corr_local_control',\n", " 'params_and_consts': []},\n", - " 'FParamFun6': {'code': 'def understeer_corr_local(vx, # input\\n'\n", + " 'FParamFun5': {'code': 'def understeer_corr_local(vx, # input\\n'\n", " ' A # '\n", " 'learnable parameter\\n'\n", " ' ):\\n'\n", @@ -2716,7 +2707,7 @@ " 'name': 'understeer_corr_local',\n", " 'params_and_consts': []}},\n", " 'Info': {'SampleTime': 0.05,\n", - " 'nnodely_version': '1.5.2',\n", + " 'nnodely_version': '1.5.4',\n", " 'ns': [30, 29],\n", " 'ntot': 59,\n", " 'num_parameters': 514},\n", @@ -2812,9 +2803,9 @@ " 'Add147',\n", " 'Add148']},\n", " 'vehicle_model': {'Constants': ['SampleTime', 'W_fir'],\n", - " 'Functions': ['FFuzzify7',\n", - " 'FFuzzify8',\n", - " 'FParamFun6'],\n", + " 'Functions': ['FFuzzify6',\n", + " 'FFuzzify7',\n", + " 'FParamFun5'],\n", " 'Inputs': ['Mul77_int33',\n", " 'Mul87_int34',\n", " 'model_ax_in',\n", @@ -2912,596 +2903,596 @@ " 'model_curv': 'Mul72'},\n", " 'Parameters': {'A_0': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.12241744995117188]]},\n", + " 'values': [[0.10271348804235458]]},\n", " 'A_1': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13215704262256622]]},\n", + " 'values': [[0.11061573028564453]]},\n", " 'A_2': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13487723469734192]]},\n", + " 'values': [[0.11115050315856934]]},\n", " 'A_3': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.13838686048984528]]},\n", + " 'values': [[0.11318214982748032]]},\n", " 'A_4': {'dim': [1, 1],\n", " 'init_values': [[9.999999747378752e-06]],\n", - " 'values': [[0.14319394528865814]]},\n", + " 'values': [[0.11924726516008377]]},\n", " 'Fir_0': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.08373943716287613],\n", - " [0.07128263264894485],\n", - " [0.05931668356060982],\n", - " [0.047899674624204636],\n", - " [0.03708196431398392],\n", - " [0.026911072432994843],\n", - " [0.017440231516957283],\n", - " [0.008717508055269718],\n", - " [0.0007935233297757804],\n", - " [-0.0062926579266786575],\n", - " [-0.012489699758589268],\n", - " [-0.017752693966031075],\n", - " [-0.022039905190467834],\n", - " [-0.025310339406132698],\n", - " [-0.027522850781679153],\n", - " [-0.02864413894712925],\n", - " [-0.028636261820793152],\n", - " [-0.027461817488074303],\n", - " [-0.025094198063015938],\n", - " [-0.021501963958144188],\n", - " [-0.01666117273271084],\n", - " [-0.010549379512667656],\n", - " [-0.0031512363348156214],\n", - " [0.005550689995288849],\n", - " [0.01557850744575262],\n", - " [0.0269477516412735],\n", - " [0.039668019860982895],\n", - " [0.05374666675925255],\n", - " [0.06917425990104675],\n", - " [0.08594906330108643]]},\n", + " 'values': [[0.09802747517824173],\n", + " [0.08951050788164139],\n", + " [0.08058805018663406],\n", + " [0.07134129106998444],\n", + " [0.061860695481300354],\n", + " [0.05224946513772011],\n", + " [0.04260175675153732],\n", + " [0.03301765024662018],\n", + " [0.023611901327967644],\n", + " [0.014501909725368023],\n", + " [0.005805093329399824],\n", + " [-0.0023491019383072853],\n", + " [-0.00983006414026022],\n", + " [-0.016498161479830742],\n", + " [-0.022219574078917503],\n", + " [-0.02685215137898922],\n", + " [-0.03025209531188011],\n", + " [-0.03227457404136658],\n", + " [-0.03277384489774704],\n", + " [-0.03161216527223587],\n", + " [-0.028642289340496063],\n", + " [-0.023736337199807167],\n", + " [-0.016750289127230644],\n", + " [-0.007566493935883045],\n", + " [0.003936300985515118],\n", + " [0.01786847785115242],\n", + " [0.034319307655096054],\n", + " [0.05338161811232567],\n", + " [0.0751204714179039],\n", + " [0.09959813207387924]]},\n", " 'Fir_1': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.1427392214536667],\n", - " [0.12301896512508392],\n", - " [0.10386364161968231],\n", - " [0.08541157096624374],\n", - " [0.067807637155056],\n", - " [0.05117274075746536],\n", - " [0.0356372706592083],\n", - " [0.021306047216057777],\n", - " [0.008290489204227924],\n", - " [-0.0033239584881812334],\n", - " [-0.01345659326761961],\n", - " [-0.022042429074645042],\n", - " [-0.0290205255150795],\n", - " [-0.03433607891201973],\n", - " [-0.0379483625292778],\n", - " [-0.039820596575737],\n", - " [-0.03991835564374924],\n", - " [-0.03822482004761696],\n", - " [-0.034723911434412],\n", - " [-0.029411161318421364],\n", - " [-0.022280005738139153],\n", - " [-0.013314316049218178],\n", - " [-0.002528987592086196],\n", - " [0.010067971423268318],\n", - " [0.024462005123496056],\n", - " [0.040629029273986816],\n", - " [0.058531370013952255],\n", - " [0.07813094556331635],\n", - " [0.0993867963552475],\n", - " [0.12223705649375916]]},\n", + " 'values': [[0.0997484102845192],\n", + " [0.09273143112659454],\n", + " [0.0849885642528534],\n", + " [0.07660744339227676],\n", + " [0.06767811626195908],\n", + " [0.05830444395542145],\n", + " [0.04859663546085358],\n", + " [0.038675762712955475],\n", + " [0.02867215685546398],\n", + " [0.018722297623753548],\n", + " [0.008969542570412159],\n", + " [-0.00042398733785375953],\n", + " [-0.00928482972085476],\n", + " [-0.017420383170247078],\n", + " [-0.024636657908558846],\n", + " [-0.030706603080034256],\n", + " [-0.03540678322315216],\n", + " [-0.0384904183447361],\n", + " [-0.039715200662612915],\n", + " [-0.038816485553979874],\n", + " [-0.03554098308086395],\n", + " [-0.029626278206706047],\n", + " [-0.020816311240196228],\n", + " [-0.008872822858393192],\n", + " [0.006432283204048872],\n", + " [0.02530253678560257],\n", + " [0.04791589453816414],\n", + " [0.0744224265217781],\n", + " [0.10494514554738998],\n", + " [0.13957835733890533]]},\n", " 'Fir_2': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.10938374698162079],\n", - " [0.09061797708272934],\n", - " [0.07280146330595016],\n", - " [0.056053079664707184],\n", - " [0.040493905544281006],\n", - " [0.026224011555314064],\n", - " [0.01333017647266388],\n", - " [0.0018724965630099177],\n", - " [-0.008102686144411564],\n", - " [-0.016559626907110214],\n", - " [-0.02346815913915634],\n", - " [-0.028809096664190292],\n", - " [-0.032560765743255615],\n", - " [-0.034716006368398666],\n", - " [-0.03528342396020889],\n", - " [-0.03427677974104881],\n", - " [-0.03171294927597046],\n", - " [-0.02762974426150322],\n", - " [-0.022049762308597565],\n", - " [-0.014998081140220165],\n", - " [-0.006516933906823397],\n", - " [0.0033721455838531256],\n", - " [0.014631866477429867],\n", - " [0.027193831279873848],\n", - " [0.04097696393728256],\n", - " [0.0558808408677578],\n", - " [0.07182122021913528],\n", - " [0.08871165663003922],\n", - " [0.10644236207008362],\n", - " [0.12491162121295929]]},\n", + " 'values': [[0.11963307857513428],\n", + " [0.10635463893413544],\n", + " [0.0927838608622551],\n", + " [0.0791749432682991],\n", + " [0.06574243307113647],\n", + " [0.05266417935490608],\n", + " [0.04009338840842247],\n", + " [0.028152750805020332],\n", + " [0.016954297199845314],\n", + " [0.0066026002168655396],\n", + " [-0.002807801589369774],\n", + " [-0.011179376393556595],\n", + " [-0.018413569778203964],\n", + " [-0.024410946294665337],\n", + " [-0.0290751401335001],\n", + " [-0.032300543040037155],\n", + " [-0.03399139270186424],\n", + " [-0.03403117135167122],\n", + " [-0.032298214733600616],\n", + " [-0.028663042932748795],\n", + " [-0.023000774905085564],\n", + " [-0.015166865661740303],\n", + " [-0.005037392023950815],\n", + " [0.007529286667704582],\n", + " [0.022659236565232277],\n", + " [0.040454644709825516],\n", + " [0.06098685786128044],\n", + " [0.08429399132728577],\n", + " [0.11036428064107895],\n", + " [0.13915462791919708]]},\n", " 'Fir_3': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.0036230585537850857],\n", - " [-0.004523097071796656],\n", - " [-0.012088771909475327],\n", - " [-0.018920931965112686],\n", - " [-0.02491142973303795],\n", - " [-0.02999606356024742],\n", - " [-0.03411524370312691],\n", - " [-0.037209365516901016],\n", - " [-0.03924567624926567],\n", - " [-0.04020298644900322],\n", - " [-0.04009431600570679],\n", - " [-0.038932159543037415],\n", - " [-0.03675546124577522],\n", - " [-0.03358297795057297],\n", - " [-0.02942216768860817],\n", - " [-0.02427610754966736],\n", - " [-0.018167199566960335],\n", - " [-0.011154214851558208],\n", - " [-0.003286497201770544],\n", - " [0.005432578269392252],\n", - " [0.014995560050010681],\n", - " [0.025369716808199883],\n", - " [0.03655438497662544],\n", - " [0.04851684719324112],\n", - " [0.06117192655801773],\n", - " [0.07439995557069778],\n", - " [0.08807000517845154],\n", - " [0.10204608738422394],\n", - " [0.1161910891532898],\n", - " [0.1303706169128418]]},\n", + " 'values': [[0.13824495673179626],\n", + " [0.1250022053718567],\n", + " [0.11005709320306778],\n", + " [0.09411410242319107],\n", + " [0.07777073979377747],\n", + " [0.06150287017226219],\n", + " [0.04568269103765488],\n", + " [0.03060069866478443],\n", + " [0.01651027984917164],\n", + " [0.0035778339952230453],\n", + " [-0.008057180792093277],\n", + " [-0.01828882284462452],\n", + " [-0.027004370465874672],\n", + " [-0.03409358486533165],\n", + " [-0.039423320442438126],\n", + " [-0.04285605624318123],\n", + " [-0.044259652495384216],\n", + " [-0.04348904266953468],\n", + " [-0.040390919893980026],\n", + " [-0.03483203053474426],\n", + " [-0.026673845946788788],\n", + " [-0.015783220529556274],\n", + " [-0.0020225730258971453],\n", + " [0.01471050176769495],\n", + " [0.03452245146036148],\n", + " [0.05742526054382324],\n", + " [0.08334319293498993],\n", + " [0.1121019497513771],\n", + " [0.1434130221605301],\n", + " [0.1768960952758789]]},\n", " 'Fir_4': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07145543396472931],\n", - " [-0.07197658717632294],\n", - " [-0.07205136865377426],\n", - " [-0.07167045027017593],\n", - " [-0.07080260664224625],\n", - " [-0.06943180412054062],\n", - " [-0.06752004474401474],\n", - " [-0.06503090262413025],\n", - " [-0.061952151358127594],\n", - " [-0.05824064835906029],\n", - " [-0.0538783073425293],\n", - " [-0.048865217715501785],\n", - " [-0.043194953352212906],\n", - " [-0.03686324506998062],\n", - " [-0.029858842492103577],\n", - " [-0.022180814296007156],\n", - " [-0.013852321542799473],\n", - " [-0.004839311353862286],\n", - " [0.004870493896305561],\n", - " [0.01528953481465578],\n", - " [0.026417257264256477],\n", - " [0.03824439272284508],\n", - " [0.05075015127658844],\n", - " [0.0639011487364769],\n", - " [0.07768751680850983],\n", - " [0.09206417948007584],\n", - " [0.10697998106479645],\n", - " [0.12239029258489609],\n", - " [0.1382369101047516],\n", - " [0.1544647514820099]]},\n", + " 'values': [[0.14163683354854584],\n", + " [0.13477812707424164],\n", + " [0.12437953054904938],\n", + " [0.11116994917392731],\n", + " [0.09594038873910904],\n", + " [0.07944705337285995],\n", + " [0.06234145164489746],\n", + " [0.04513232037425041],\n", + " [0.028319664299488068],\n", + " [0.01236469391733408],\n", + " [-0.00239584781229496],\n", + " [-0.01567983254790306],\n", + " [-0.027264611795544624],\n", + " [-0.036951854825019836],\n", + " [-0.04454702138900757],\n", + " [-0.04983208328485489],\n", + " [-0.05261280760169029],\n", + " [-0.05267792195081711],\n", + " [-0.04981167986989021],\n", + " [-0.043814193457365036],\n", + " [-0.0344865657389164],\n", + " [-0.021592792123556137],\n", + " [-0.004865081515163183],\n", + " [0.01573905535042286],\n", + " [0.040348030626773834],\n", + " [0.06902886927127838],\n", + " [0.10181301832199097],\n", + " [0.13870728015899658],\n", + " [0.17962424457073212],\n", + " [0.22440935671329498]]},\n", " 'Fir_5': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.045466236770153046],\n", - " [-0.04941441863775253],\n", - " [-0.05296502634882927],\n", - " [-0.05606375262141228],\n", - " [-0.058626554906368256],\n", - " [-0.06060165911912918],\n", - " [-0.06190638244152069],\n", - " [-0.062493305653333664],\n", - " [-0.06230451539158821],\n", - " [-0.061295583844184875],\n", - " [-0.05942470207810402],\n", - " [-0.05663062259554863],\n", - " [-0.05284297093749046],\n", - " [-0.0480080246925354],\n", - " [-0.042047422379255295],\n", - " [-0.03488249331712723],\n", - " [-0.02648063562810421],\n", - " [-0.01678083837032318],\n", - " [-0.005733977071940899],\n", - " [0.006724357604980469],\n", - " [0.020640479400753975],\n", - " [0.036052487790584564],\n", - " [0.053023938089609146],\n", - " [0.07156147807836533],\n", - " [0.09169284254312515],\n", - " [0.11347538977861404],\n", - " [0.13692867755889893],\n", - " [0.16205839812755585],\n", - " [0.18890884518623352],\n", - " [0.21746642887592316]]},\n", + " 'values': [[0.07319375872612],\n", + " [0.07567604631185532],\n", + " [0.07507440447807312],\n", + " [0.07157206535339355],\n", + " [0.06549695879220963],\n", + " [0.05727209523320198],\n", + " [0.04734784737229347],\n", + " [0.03615500405430794],\n", + " [0.0241051334887743],\n", + " [0.01159927248954773],\n", + " [-0.0009354146895930171],\n", + " [-0.013040401041507721],\n", + " [-0.024295810610055923],\n", + " [-0.0342605784535408],\n", + " [-0.04246646538376808],\n", + " [-0.0484670028090477],\n", + " [-0.051901403814554214],\n", + " [-0.052417121827602386],\n", + " [-0.049710728228092194],\n", + " [-0.043444205075502396],\n", + " [-0.03335171565413475],\n", + " [-0.01911710575222969],\n", + " [-0.00044568898738361895],\n", + " [0.022811029106378555],\n", + " [0.050846029072999954],\n", + " [0.08385420590639114],\n", + " [0.1220158189535141],\n", + " [0.16550478339195251],\n", + " [0.2144814133644104],\n", + " [0.26906299591064453]]},\n", " 'Fir_6': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[-0.07760659605264664],\n", - " [-0.07570715248584747],\n", - " [-0.07353810220956802],\n", - " [-0.07119432836771011],\n", - " [-0.06875365227460861],\n", - " [-0.06626567989587784],\n", - " [-0.06372548639774323],\n", - " [-0.061116475611925125],\n", - " [-0.05833817645907402],\n", - " [-0.05532317981123924],\n", - " [-0.051966723054647446],\n", - " [-0.048134833574295044],\n", - " [-0.04368661344051361],\n", - " [-0.038527000695466995],\n", - " [-0.03244928643107414],\n", - " [-0.02543233335018158],\n", - " [-0.017468007281422615],\n", - " [-0.008501219563186169],\n", - " [0.001558795920573175],\n", - " [0.01286094356328249],\n", - " [0.02560839056968689],\n", - " [0.03990352153778076],\n", - " [0.05610361695289612],\n", - " [0.07430130988359451],\n", - " [0.09463302791118622],\n", - " [0.1173117607831955],\n", - " [0.1426011621952057],\n", - " [0.17061302065849304],\n", - " [0.20156458020210266],\n", - " [0.23558014631271362]]},\n", + " 'values': [[0.07161669433116913],\n", + " [0.08292372524738312],\n", + " [0.09161170572042465],\n", + " [0.09712497889995575],\n", + " [0.09898201376199722],\n", + " [0.09701229631900787],\n", + " [0.09127453714609146],\n", + " [0.08213011175394058],\n", + " [0.07017728686332703],\n", + " [0.05622842162847519],\n", + " [0.04102401062846184],\n", + " [0.0252744872123003],\n", + " [0.009648673236370087],\n", + " [-0.005155729129910469],\n", + " [-0.01857585646212101],\n", + " [-0.030165914446115494],\n", + " [-0.039713308215141296],\n", + " [-0.04692850634455681],\n", + " [-0.0515095517039299],\n", + " [-0.05299036204814911],\n", + " [-0.05066951364278793],\n", + " [-0.043506838381290436],\n", + " [-0.030119018629193306],\n", + " [-0.00887052807956934],\n", + " [0.02178552746772766],\n", + " [0.06318464130163193],\n", + " [0.11635182797908783],\n", + " [0.1820082664489746],\n", + " [0.2605421543121338],\n", + " [0.3519956171512604]]},\n", " 'Fir_7': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 1}},\n", " 'sw': 30,\n", - " 'values': [[0.06075132265686989],\n", - " [0.05622144788503647],\n", - " [0.04827791452407837],\n", - " [0.037901245057582855],\n", - " [0.02598106488585472],\n", - " [0.013368550688028336],\n", - " [0.0007360622403211892],\n", - " [-0.011336201801896095],\n", - " [-0.02228238433599472],\n", - " [-0.03168044239282608],\n", - " [-0.039212822914123535],\n", - " [-0.0446024127304554],\n", - " [-0.047832805663347244],\n", - " [-0.04878610372543335],\n", - " [-0.04709966853260994],\n", - " [-0.042434681206941605],\n", - " [-0.03468530252575874],\n", - " [-0.023747917264699936],\n", - " [-0.009678727015852928],\n", - " [0.0075911483727395535],\n", - " [0.02810771018266678],\n", - " [0.05173402652144432],\n", - " [0.07855863869190216],\n", - " [0.10853327810764313],\n", - " [0.14130747318267822],\n", - " [0.1765713095664978],\n", - " [0.21406440436840057],\n", - " [0.25343939661979675],\n", - " [0.2944483458995819],\n", - " [0.3369137942790985]]},\n", + " 'values': [[0.15214180946350098],\n", + " [0.15814897418022156],\n", + " [0.15724048018455505],\n", + " [0.14980405569076538],\n", + " [0.13674023747444153],\n", + " [0.1191268190741539],\n", + " [0.09820308536291122],\n", + " [0.07500811666250229],\n", + " [0.05062484368681908],\n", + " [0.026210999116301537],\n", + " [0.0027045132592320442],\n", + " [-0.018744679167866707],\n", + " [-0.037157949060201645],\n", + " [-0.05177536606788635],\n", + " [-0.0621718131005764],\n", + " [-0.0680275559425354],\n", + " [-0.06923902034759521],\n", + " [-0.06568694114685059],\n", + " [-0.05714571103453636],\n", + " [-0.04337356239557266],\n", + " [-0.0242167841643095],\n", + " [0.00032957346411421895],\n", + " [0.03000686690211296],\n", + " [0.06464923173189163],\n", + " [0.10421786457300186],\n", + " [0.14867858588695526],\n", + " [0.19784015417099],\n", + " [0.2513589560985565],\n", + " [0.3087795078754425],\n", + " [0.36944523453712463]]},\n", " 'Fir_InitCondition': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 29,\n", - " 'values': [[-0.005676846019923687],\n", - " [-5.078164394944906e-05],\n", - " [0.007623068057000637],\n", - " [0.015457557514309883],\n", - " [0.0211738720536232],\n", - " [0.026559188961982727],\n", - " [0.03333593159914017],\n", - " [0.041086673736572266],\n", - " [0.04691801965236664],\n", - " [0.051395390182733536],\n", - " [0.05676743760704994],\n", - " [0.061077240854501724],\n", - " [0.06495276093482971],\n", - " [0.06868331879377365],\n", - " [0.07179466634988785],\n", - " [0.07229167222976685],\n", - " [0.07215118408203125],\n", - " [0.07177411019802094],\n", - " [0.07180652767419815],\n", - " [0.07127676159143448],\n", - " [0.0690212994813919],\n", - " [0.06502213329076767],\n", - " [0.06130627170205116],\n", - " [0.05942361429333687],\n", - " [-0.20321491360664368],\n", - " [-0.10378878563642502],\n", - " [-0.2889885902404785],\n", - " [-0.506409227848053],\n", - " [-0.10591235756874084]]},\n", + " 'values': [[-0.1880173534154892],\n", + " [-0.16834662854671478],\n", + " [-0.14862865209579468],\n", + " [-0.12898388504981995],\n", + " [-0.10955444723367691],\n", + " [-0.0903860479593277],\n", + " [-0.07154607772827148],\n", + " [-0.053144682198762894],\n", + " [-0.035281211137771606],\n", + " [-0.01806611754000187],\n", + " [-0.0016446828376501799],\n", + " [0.013837791047990322],\n", + " [0.02824844978749752],\n", + " [0.04143502190709114],\n", + " [0.05324811115860939],\n", + " [0.06358851492404938],\n", + " [0.07237707078456879],\n", + " [0.07952549308538437],\n", + " [0.08503401279449463],\n", + " [0.08897425979375839],\n", + " [0.09132202714681625],\n", + " [0.09213884174823761],\n", + " [0.09197454154491425],\n", + " [0.0913749560713768],\n", + " [-0.06078016757965088],\n", + " [-0.0063238972797989845],\n", + " [-0.15908004343509674],\n", + " [-0.42562299966812134],\n", + " [-0.12217527627944946]]},\n", " 'Fir_target_0': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[1.0860881805419922],\n", - " [1.0301192998886108],\n", - " [0.9732351303100586],\n", - " [0.9155109524726868],\n", - " [0.8570305109024048],\n", - " [0.7978867888450623],\n", - " [0.7381616830825806],\n", - " [0.6779631972312927],\n", - " [0.6173838973045349],\n", - " [0.5565256476402283],\n", - " [0.4954935610294342],\n", - " [0.43438994884490967],\n", - " [0.3733194172382355],\n", - " [0.3123920261859894],\n", - " [0.2517073452472687],\n", - " [0.19137363135814667],\n", - " [0.13149100542068481],\n", - " [0.07216159254312515],\n", - " [0.01348485890775919],\n", - " [-0.044451192021369934],\n", - " [-0.10155246406793594],\n", - " [-0.15772926807403564],\n", - " [-0.21290872991085052],\n", - " [-0.2670043408870697],\n", - " [-0.3199438750743866],\n", - " [-0.3716489374637604],\n", - " [-0.4220503866672516],\n", - " [-0.47107553482055664],\n", - " [-0.5186495184898376],\n", - " [-0.5646901726722717]]},\n", + " 'values': [[1.0387601852416992],\n", + " [0.9801400899887085],\n", + " [0.920475959777832],\n", + " [0.8598429560661316],\n", + " [0.7983449697494507],\n", + " [0.7360644340515137],\n", + " [0.6731131076812744],\n", + " [0.6095992922782898],\n", + " [0.5456321835517883],\n", + " [0.48132771253585815],\n", + " [0.41680553555488586],\n", + " [0.3521793484687805],\n", + " [0.2875766456127167],\n", + " [0.2231156826019287],\n", + " [0.1589183509349823],\n", + " [0.09510575979948044],\n", + " [0.03179887682199478],\n", + " [-0.030892541632056236],\n", + " [-0.09284970164299011],\n", + " [-0.15397101640701294],\n", + " [-0.21415086090564728],\n", + " [-0.27328842878341675],\n", + " [-0.33129364252090454],\n", + " [-0.38807374238967896],\n", + " [-0.44354093074798584],\n", + " [-0.49761220812797546],\n", + " [-0.5502008199691772],\n", + " [-0.6012230515480042],\n", + " [-0.6505866050720215],\n", + " [-0.6981837153434753]]},\n", " 'Fir_target_1': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.8347728252410889],\n", - " [0.7831745147705078],\n", - " [0.7308439016342163],\n", - " [0.6778424382209778],\n", - " [0.6242359280586243],\n", - " [0.570091724395752],\n", - " [0.5154778957366943],\n", - " [0.46047136187553406],\n", - " [0.4051465094089508],\n", - " [0.34957823157310486],\n", - " [0.29384687542915344],\n", - " [0.23803307116031647],\n", - " [0.18221771717071533],\n", - " [0.1264772117137909],\n", - " [0.07089433073997498],\n", - " [0.015551033429801464],\n", - " [-0.03947228193283081],\n", - " [-0.09409701079130173],\n", - " [-0.1482478678226471],\n", - " [-0.20184631645679474],\n", - " [-0.25481826066970825],\n", - " [-0.30708977580070496],\n", - " [-0.358586847782135],\n", - " [-0.4092375636100769],\n", - " [-0.45896923542022705],\n", - " [-0.5077088475227356],\n", - " [-0.5553777813911438],\n", - " [-0.6018968820571899],\n", - " [-0.6471809148788452],\n", - " [-0.6911268830299377]]},\n", + " 'values': [[0.8267313838005066],\n", + " [0.770578920841217],\n", + " [0.7136641144752502],\n", + " [0.6560629606246948],\n", + " [0.59786057472229],\n", + " [0.5391441583633423],\n", + " [0.4799962341785431],\n", + " [0.4205167889595032],\n", + " [0.36080023646354675],\n", + " [0.3009415864944458],\n", + " [0.24103914201259613],\n", + " [0.18119029700756073],\n", + " [0.12149219214916229],\n", + " [0.062043074518442154],\n", + " [0.00293826125562191],\n", + " [-0.05573037266731262],\n", + " [-0.11386998742818832],\n", + " [-0.17139428853988647],\n", + " [-0.2282174527645111],\n", + " [-0.2842567265033722],\n", + " [-0.33943283557891846],\n", + " [-0.39367035031318665],\n", + " [-0.4468955993652344],\n", + " [-0.499035120010376],\n", + " [-0.5500161647796631],\n", + " [-0.5997688174247742],\n", + " [-0.6482182741165161],\n", + " [-0.6952864527702332],\n", + " [-0.7408808469772339],\n", + " [-0.7849005460739136]]},\n", " 'Fir_target_2': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.5733448266983032],\n", - " [0.5387258529663086],\n", - " [0.5038601160049438],\n", - " [0.4687975347042084],\n", - " [0.4335801303386688],\n", - " [0.3982495069503784],\n", - " [0.3628474473953247],\n", - " [0.3274137079715729],\n", - " [0.2919822633266449],\n", - " [0.256589412689209],\n", - " [0.2212648093700409],\n", - " [0.1860395222902298],\n", - " [0.1509401649236679],\n", - " [0.11599166691303253],\n", - " [0.0812096893787384],\n", - " [0.04661747068166733],\n", - " [0.012225558049976826],\n", - " [-0.021954987198114395],\n", - " [-0.055915407836437225],\n", - " [-0.08965113759040833],\n", - " [-0.1231599673628807],\n", - " [-0.15644104778766632],\n", - " [-0.18949411809444427],\n", - " [-0.22231924533843994],\n", - " [-0.25491759181022644],\n", - " [-0.287289023399353],\n", - " [-0.3194332718849182],\n", - " [-0.35134485363960266],\n", - " [-0.3830169439315796],\n", - " [-0.4144284725189209]]},\n", + " 'values': [[0.5552957057952881],\n", + " [0.519085705280304],\n", + " [0.4827147126197815],\n", + " [0.44623440504074097],\n", + " [0.4096929132938385],\n", + " [0.37313494086265564],\n", + " [0.33659613132476807],\n", + " [0.3001234829425812],\n", + " [0.26374924182891846],\n", + " [0.22750544548034668],\n", + " [0.19142229855060577],\n", + " [0.15552835166454315],\n", + " [0.11984214186668396],\n", + " [0.08438146859407425],\n", + " [0.04915693774819374],\n", + " [0.014178977347910404],\n", + " [-0.02054668217897415],\n", + " [-0.055020902305841446],\n", + " [-0.08924373984336853],\n", + " [-0.12321994453668594],\n", + " [-0.15695610642433167],\n", + " [-0.19045856595039368],\n", + " [-0.2237362563610077],\n", + " [-0.25679537653923035],\n", + " [-0.2896433472633362],\n", + " [-0.32228338718414307],\n", + " [-0.3547160029411316],\n", + " [-0.38693124055862427],\n", + " [-0.4189126491546631],\n", + " [-0.45062556862831116]]},\n", " 'Fir_target_3': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.3524777293205261],\n", - " [0.33502820134162903],\n", - " [0.31745919585227966],\n", - " [0.2998187839984894],\n", - " [0.2821652889251709],\n", - " [0.2645634114742279],\n", - " [0.24707533419132233],\n", - " [0.2297789752483368],\n", - " [0.21274466812610626],\n", - " [0.19604426622390747],\n", - " [0.1797492951154709],\n", - " [0.16392557322978973],\n", - " [0.1486373245716095],\n", - " [0.13394057750701904],\n", - " [0.11988916248083115],\n", - " [0.10652604699134827],\n", - " [0.09388204663991928],\n", - " [0.08198556303977966],\n", - " [0.07084733992815018],\n", - " [0.06047321856021881],\n", - " [0.050854846835136414],\n", - " [0.04197553172707558],\n", - " [0.03381021320819855],\n", - " [0.026326296851038933],\n", - " [0.01948302797973156],\n", - " [0.013237235136330128],\n", - " [0.007539053447544575],\n", - " [0.0023330524563789368],\n", - " [-0.0024375305511057377],\n", - " [-0.006836494896560907]]},\n", + " 'values': [[0.3838592767715454],\n", + " [0.35854512453079224],\n", + " [0.33313339948654175],\n", + " [0.30771154165267944],\n", + " [0.28236857056617737],\n", + " [0.2572004497051239],\n", + " [0.23230907320976257],\n", + " [0.2077978104352951],\n", + " [0.1837717443704605],\n", + " [0.1603350043296814],\n", + " [0.1375877410173416],\n", + " [0.11562300473451614],\n", + " [0.09452544897794724],\n", + " [0.07436997443437576],\n", + " [0.05522245541214943],\n", + " [0.037135280668735504],\n", + " [0.020145833492279053],\n", + " [0.004282208159565926],\n", + " [-0.010443741455674171],\n", + " [-0.02402907982468605],\n", + " [-0.03648657724261284],\n", + " [-0.04784063994884491],\n", + " [-0.05812521278858185],\n", + " [-0.06738566607236862],\n", + " [-0.07567368447780609],\n", + " [-0.08304674178361893],\n", + " [-0.0895688459277153],\n", + " [-0.09530612081289291],\n", + " [-0.10032443702220917],\n", + " [-0.1046900749206543]]},\n", " 'Fir_target_4': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.29996585845947266],\n", - " [0.2844270169734955],\n", - " [0.2686833441257477],\n", - " [0.2527642548084259],\n", - " [0.23669418692588806],\n", - " [0.22050198912620544],\n", - " [0.20421387255191803],\n", - " [0.187852144241333],\n", - " [0.17144276201725006],\n", - " [0.15500293672084808],\n", - " [0.1385558396577835],\n", - " [0.12212695926427841],\n", - " [0.10573706030845642],\n", - " [0.0894150361418724],\n", - " [0.07319120317697525],\n", - " [0.0570993646979332],\n", - " [0.04117598384618759],\n", - " [0.02546309307217598],\n", - " [0.01000835932791233],\n", - " [-0.0051408628933131695],\n", - " [-0.01993296481668949],\n", - " [-0.03431183472275734],\n", - " [-0.048220764845609665],\n", - " [-0.061600446701049805],\n", - " [-0.0743916928768158],\n", - " [-0.08653859794139862],\n", - " [-0.09798769652843475],\n", - " [-0.10869012773036957],\n", - " [-0.11859968304634094],\n", - " [-0.1276792734861374]]},\n", + " 'values': [[0.3199537992477417],\n", + " [0.2997092008590698],\n", + " [0.2792358100414276],\n", + " [0.2585664987564087],\n", + " [0.23775364458560944],\n", + " [0.21685174107551575],\n", + " [0.19590967893600464],\n", + " [0.1749841868877411],\n", + " [0.15412446856498718],\n", + " [0.13337405025959015],\n", + " [0.11276727169752121],\n", + " [0.0923302099108696],\n", + " [0.07209018617868423],\n", + " [0.052073974162340164],\n", + " [0.032317422330379486],\n", + " [0.012858239933848381],\n", + " [-0.006254269275814295],\n", + " [-0.02496303804218769],\n", + " [-0.04320341721177101],\n", + " [-0.06090416759252548],\n", + " [-0.077987439930439],\n", + " [-0.0943683385848999],\n", + " [-0.10995753109455109],\n", + " [-0.12466397136449814],\n", + " [-0.13839669525623322],\n", + " [-0.15106824040412903],\n", + " [-0.16258956491947174],\n", + " [-0.17287954688072205],\n", + " [-0.18185637891292572],\n", + " [-0.18944132328033447]]},\n", " 'Fir_target_5': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.31530195474624634],\n", - " [0.29468315839767456],\n", - " [0.273494690656662],\n", - " [0.25176700949668884],\n", - " [0.22953493893146515],\n", - " [0.20682759582996368],\n", - " [0.18348942697048187],\n", - " [0.15865054726600647],\n", - " [0.13493667542934418],\n", - " [0.111105777323246],\n", - " [0.08720876276493073],\n", - " [0.06333461403846741],\n", - " [0.03958143666386604],\n", - " [0.01604893058538437],\n", - " [-0.007159021683037281],\n", - " [-0.029941871762275696],\n", - " [-0.05220096558332443],\n", - " [-0.0738447830080986],\n", - " [-0.09479029476642609],\n", - " [-0.11496301740407944],\n", - " [-0.13430044054985046],\n", - " [-0.1527561992406845],\n", - " [-0.17031586170196533],\n", - " [-0.18727216124534607],\n", - " [-0.2037562131881714],\n", - " [-0.21811345219612122],\n", - " [-0.23139715194702148],\n", - " [-0.2435224950313568],\n", - " [-0.25440123677253723],\n", - " [-0.26392608880996704]]},\n", + " 'values': [[0.2713383734226227],\n", + " [0.254989892244339],\n", + " [0.23802605271339417],\n", + " [0.220574751496315],\n", + " [0.20251241326332092],\n", + " [0.18375982344150543],\n", + " [0.16227440536022186],\n", + " [0.1411118507385254],\n", + " [0.12092932313680649],\n", + " [0.10048046708106995],\n", + " [0.07985305786132812],\n", + " [0.05917029827833176],\n", + " [0.03856793791055679],\n", + " [0.018185418099164963],\n", + " [-0.001833103015087545],\n", + " [-0.021345697343349457],\n", + " [-0.04021443426609039],\n", + " [-0.058308184146881104],\n", + " [-0.07550574094057083],\n", + " [-0.09170244634151459],\n", + " [-0.10680893063545227],\n", + " [-0.12075857818126678],\n", + " [-0.13352638483047485],\n", + " [-0.14548160135746002],\n", + " [-0.15634390711784363],\n", + " [-0.16485154628753662],\n", + " [-0.17187784612178802],\n", + " [-0.1772894263267517],\n", + " [-0.18092989921569824],\n", + " [-0.18259692192077637]]},\n", " 'Fir_target_6': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.28236696124076843],\n", - " [0.25818634033203125],\n", - " [0.23391760885715485],\n", - " [0.20979410409927368],\n", - " [0.1860314905643463],\n", - " [0.16271598637104034],\n", - " [0.1379116028547287],\n", - " [0.11588051915168762],\n", - " [0.09518630057573318],\n", - " [0.07580560445785522],\n", - " [0.0577576644718647],\n", - " [0.041072387248277664],\n", - " [0.02577033080160618],\n", - " [0.011852824129164219],\n", - " [-0.0006969108944758773],\n", - " [-0.011910236440598965],\n", - " [-0.021831152960658073],\n", - " [-0.030516035854816437],\n", - " [-0.038026582449674606],\n", - " [-0.04442623630166054],\n", - " [-0.049773529171943665],\n", - " [-0.05411948636174202],\n", - " [-0.057508137077093124],\n", - " [-0.05997495353221893],\n", - " [-0.06154481694102287],\n", - " [-0.06223170459270477],\n", - " [-0.062035489827394485],\n", - " [-0.06094639003276825],\n", - " [-0.05894255265593529],\n", - " [-0.05598975718021393]]},\n", + " 'values': [[0.26023319363594055],\n", + " [0.2383199781179428],\n", + " [0.2158694565296173],\n", + " [0.19317659735679626],\n", + " [0.17053475975990295],\n", + " [0.14802980422973633],\n", + " [0.12368645519018173],\n", + " [0.10257009416818619],\n", + " [0.08292077481746674],\n", + " [0.06470581144094467],\n", + " [0.04797719791531563],\n", + " [0.03278421610593796],\n", + " [0.019153311848640442],\n", + " [0.007080273237079382],\n", + " [-0.003467648522928357],\n", + " [-0.012545413337647915],\n", + " [-0.02022290788590908],\n", + " [-0.02658195234835148],\n", + " [-0.03170917183160782],\n", + " [-0.0356876403093338],\n", + " [-0.03858949989080429],\n", + " [-0.04047015309333801],\n", + " [-0.041368063539266586],\n", + " [-0.04130169376730919],\n", + " [-0.04026899114251137],\n", + " [-0.0382453016936779],\n", + " [-0.035180721431970596],\n", + " [-0.031000707298517227],\n", + " [-0.025607699528336525],\n", + " [-0.01886836066842079]]},\n", " 'Fir_target_7': {'dim': 1,\n", " 'init_fun': {'name': 'init_constant',\n", " 'params': {'value': 0.01}},\n", " 'sw': 30,\n", - " 'values': [[0.17653429508209229],\n", - " [0.16239482164382935],\n", - " [0.14905300736427307],\n", - " [0.13639730215072632],\n", - " [0.12432683259248734],\n", - " [0.11275620013475418],\n", - " [0.10160979628562927],\n", - " [0.09082990884780884],\n", - " [0.08037010580301285],\n", - " [0.0701960027217865],\n", - " [0.060282137244939804],\n", - " [0.050608839839696884],\n", - " [0.041154809296131134],\n", - " [0.03190069645643234],\n", - " [0.02282974123954773],\n", - " [0.013926276937127113],\n", - " [0.005177393089979887],\n", - " [-0.003427061252295971],\n", - " [-0.01189208310097456],\n", - " [-0.020217526704072952],\n", - " [-0.028400296345353127],\n", - " [-0.03643697127699852],\n", - " [-0.04432457312941551],\n", - " [-0.05205713212490082],\n", - " [-0.05962911993265152],\n", - " [-0.06703425943851471],\n", - " [-0.07426738739013672],\n", - " [-0.08131909370422363],\n", - " [-0.08817297965288162],\n", - " [-0.09478789567947388]]}},\n", + " 'values': [[0.14649136364459991],\n", + " [0.13674713671207428],\n", + " [0.12753035128116608],\n", + " [0.11871398985385895],\n", + " [0.11017750203609467],\n", + " [0.1018131822347641],\n", + " [0.09353037923574448],\n", + " [0.08525724709033966],\n", + " [0.07694268226623535],\n", + " [0.06857160478830338],\n", + " [0.06195080652832985],\n", + " [0.05333733186125755],\n", + " [0.0445517934858799],\n", + " [0.03560711815953255],\n", + " [0.026500780135393143],\n", + " [0.017233457416296005],\n", + " [0.007810278329998255],\n", + " [-0.0017624588217586279],\n", + " [-0.011490654200315475],\n", + " [-0.022908199578523636],\n", + " [-0.03302088752388954],\n", + " [-0.04297829046845436],\n", + " [-0.05295383557677269],\n", + " [-0.06293241679668427],\n", + " [-0.07289058715105057],\n", + " [-0.08280278742313385],\n", + " [-0.09264323115348816],\n", + " [-0.10237952321767807],\n", + " [-0.11197207123041153],\n", + " [-0.12134005129337311]]}},\n", " 'Relations': {'Add141': ['Add', ['Mul119', 'Mul122']],\n", " 'Add142': ['Add', ['Add141', 'Mul125']],\n", " 'Add143': ['Add', ['Add142', 'Mul128']],\n", @@ -3521,26 +3512,26 @@ " 'Add69': ['Add', ['Add68', 'Mul57']],\n", " 'Add70': ['Add', ['Add69', 'Mul62']],\n", " 'Add71': ['Add', ['Add70', 'Mul67']],\n", - " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0.05],\n", + " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0],\n", " 'Fir109': ['Fir', ['Mul108'], 'Fir_InitCondition', None, 0],\n", " 'Fir117': ['Fir', ['Mul116'], 'Fir_target_0', None, 0],\n", " 'Fir120': ['Fir', ['Mul116'], 'Fir_target_1', None, 0],\n", " 'Fir123': ['Fir', ['Mul116'], 'Fir_target_2', None, 0],\n", " 'Fir126': ['Fir', ['Mul116'], 'Fir_target_3', None, 0],\n", " 'Fir129': ['Fir', ['Mul116'], 'Fir_target_4', None, 0],\n", - " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0.05],\n", + " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0],\n", " 'Fir132': ['Fir', ['Mul116'], 'Fir_target_5', None, 0],\n", " 'Fir135': ['Fir', ['Mul116'], 'Fir_target_6', None, 0],\n", " 'Fir138': ['Fir', ['Mul116'], 'Fir_target_7', None, 0],\n", - " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0.05],\n", - " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0.05],\n", - " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0.05],\n", - " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0.05],\n", - " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0.05],\n", - " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0.05],\n", + " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0],\n", + " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0],\n", + " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0],\n", + " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0],\n", + " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0],\n", + " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0],\n", " 'Fuzzify101': ['Fuzzify', ['SamplePart100'], 'FFuzzify105'],\n", - " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify7'],\n", - " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify8'],\n", + " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify6'],\n", + " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify7'],\n", " 'Fuzzify98': ['Fuzzify', ['SamplePart97'], 'FFuzzify104'],\n", " 'Mul103': ['Mul', ['Fuzzify98', 'A']],\n", " 'Mul108': ['Mul', ['SamplePart106', 'W_fir_init']],\n", @@ -3573,19 +3564,19 @@ " 'FParamFun103'],\n", " 'ParamFun43': ['ParamFun',\n", " ['SamplePart42', 'A_0'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun48': ['ParamFun',\n", " ['SamplePart42', 'A_1'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun53': ['ParamFun',\n", " ['SamplePart42', 'A_2'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun58': ['ParamFun',\n", " ['SamplePart42', 'A_3'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun63': ['ParamFun',\n", " ['SamplePart42', 'A_4'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'SamplePart1': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", " 'SamplePart100': ['SamplePart',\n", " ['controller_vx_in'],\n", @@ -3631,40 +3622,64 @@ " 'Select56': ['Select', ['Fuzzify5'], 5, 2],\n", " 'Select61': ['Select', ['Fuzzify5'], 5, 3],\n", " 'Select66': ['Select', ['Fuzzify5'], 5, 4],\n", - " 'Sum104': ['Sum', ['Mul103']]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m========================== Export Python Torch Model ===========================\u001B[0m\n", - "\u001B[32mModel exported in: trained_models/onnx/controller.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m======================== Export Python Onnx Torch Model ========================\u001B[0m\n", - "\u001B[32mModel exported in: trained_models/onnx/controller_onnx.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m============================== Export Onnx Model ===============================\u001B[0m\n", - "\u001B[32mModel exported in: trained_models/onnx/controller.onnx\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'Sum104': ['Sum', ['Mul103']]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m========================== Export Python Torch Model ===========================\u001b[0m\n", + "\u001b[32mModel exported in: trained_models/onnx/controller.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m======================== Export Python Onnx Torch Model ========================\u001b[0m\n", + "\u001b[32mModel exported in: trained_models/onnx/controller_onnx.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m============================== Export Onnx Model ===============================\u001b[0m\n", + "\u001b[32mModel exported in: trained_models/onnx/controller.onnx\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 18 + "source": [ + "# Save json model\n", + "lat_dyna_control.saveModel(\"control_model\")\n", + "\n", + "# Remove Minimize\n", + "lat_dyna_control.removeMinimize([\"heading_error\", \"curv_error\"])\n", + "lat_dyna_control.neuralizeModel()\n", + "\n", + "# Export ONNX\n", + "lat_dyna_control.exportONNX(\n", + " [\n", + " \"controller_curv_in\",\n", + " \"controller_vx_in\",\n", + " \"controller_ax_in\",\n", + " \"controller_steer_in\",\n", + " ],\n", + " [\n", + " \"controller_steer_out\",\n", + " \"controller_steer_from_ic\",\n", + " \"controller_steer_from_target\",\n", + " ],\n", + " \"controller\",\n", + " models=\"control_steer\",\n", + ")" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "nnodely", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.18" } }, "nbformat": 4, diff --git a/case-studies/lateral_dynamics/lateral_dynamics_model.ipynb b/case-studies/lateral_dynamics/lateral_dynamics_model.ipynb index 08d3a3aa..83e20531 100644 --- a/case-studies/lateral_dynamics/lateral_dynamics_model.ipynb +++ b/case-studies/lateral_dynamics/lateral_dynamics_model.ipynb @@ -1,30 +1,52 @@ { "cells": [ { - "metadata": {}, "cell_type": "markdown", - "source": "# **FORWARD MODEL OF VEHICLE LATERAL DYNAMICS**", - "id": "4fca82a7205fafb9" + "id": "4fca82a7205fafb9", + "metadata": {}, + "source": [ + "# **FORWARD MODEL OF VEHICLE LATERAL DYNAMICS**" + ] }, { + "cell_type": "markdown", + "id": "9841d13d", "metadata": {}, + "source": [ + "This notebook presents the Model-Structured Neural Network model of a vehicle lateral dynamics. The dataset used to train the network was collected in CarMaker14 using a 14 Dof vehicle model, the Kia_EV6_demo, an electric car. The training and validation set were collected on a custom track with a spread range of cruvature values and different corner types, from constant radius corner to clothoids. Three different driver profiles were adopted in order to cover a larger values of accelerations, \"normal\", \"aggressive\" and \"prudent\" respectively. Every dataset was then mirrored in order to avoid offsets in the training, assuming that the vehicle can be approximated to be reasonably symmetric in right and left corners.\n", + "Finally, the test telemetries were collected on a different track to proove the robustness of the trained network." + ] + }, + { "cell_type": "markdown", - "source": "### Import packages", - "id": "f4fe99351f149193" + "id": "f4fe99351f149193", + "metadata": {}, + "source": [ + "## Initialization" + ] }, { "cell_type": "code", + "execution_count": 1, "id": "initial_id", "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2025-12-02T13:54:32.200191Z", "start_time": "2025-12-02T13:54:30.406048Z" - } + }, + "collapsed": true }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-- nnodely_v1.5.4 --<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n" + ] + } + ], "source": [ "# Import necessary packages\n", - "import sys, os\n", "import pandas as pd\n", "\n", "# import nnodely modules\n", @@ -35,211 +57,246 @@ "\n", "# import a library for plots\n", "import matplotlib as mpl\n", + "\n", "mpl.rcParams.update(mpl.rcParamsDefault)\n", "import matplotlib.pyplot as plt\n", - "plt.close('all')\n", + "\n", + "plt.close(\"all\")\n", "SMALL_SIZE = 14\n", "MEDIUM_SIZE = 22\n", "BIGGER_SIZE = 26\n", - "plt.rc('font', size=SMALL_SIZE) # controls default text sizes\n", - "plt.rc('axes', titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", - "plt.rc('axes', labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", - "plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('legend', fontsize=SMALL_SIZE) # legend fontsize\n", - "plt.rc('figure', titlesize=BIGGER_SIZE) # fontsize of the figure title\n", - "plt.rc('grid', linestyle=\"--\", color='grey')" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-- nnodely_v1.5.2 --<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n" - ] - } - ], - "execution_count": 1 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "### Configurations", - "id": "7f7ac76c4718c9be" + "plt.rc(\"font\", size=SMALL_SIZE) # controls default text sizes\n", + "plt.rc(\"axes\", titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", + "plt.rc(\"axes\", labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", + "plt.rc(\"xtick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"ytick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"legend\", fontsize=SMALL_SIZE) # legend fontsize\n", + "plt.rc(\"figure\", titlesize=BIGGER_SIZE) # fontsize of the figure title\n", + "plt.rc(\"grid\", linestyle=\"--\", color=\"grey\")" + ] }, { + "cell_type": "code", + "execution_count": 2, + "id": "fc1700c6ad33005a", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.215293Z", "start_time": "2025-12-02T13:54:32.207438Z" } }, - "cell_type": "code", - "source": [ - "path_folder = 'trained_models' # folder to save the model\n", - "lat_dyna_model = nnodely(visualizer=MPLNotebookVisualizer(),seed=1,workspace=path_folder,save_history=False)" - ], - "id": "fc1700c6ad33005a", "outputs": [], - "execution_count": 2 + "source": [ + "# Configurations\n", + "path_folder = \"trained_models\" # folder to save the model\n", + "lat_dyna_model = nnodely(\n", + " visualizer=MPLNotebookVisualizer(), seed=1, workspace=path_folder, log_internal=True\n", + ")" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Neural Network model", - "id": "a4b4192ab97751ff" + "id": "a4b4192ab97751ff", + "metadata": {}, + "source": [ + "# MS-NN model" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Model definition", - "id": "b6ef5ba231c37df3" + "id": "e0f01495", + "metadata": {}, + "source": [ + "The structure of the Model-Structured Neural Network is derived from the description of the lateral dynamic performance of the vehicles through the understeering gradient that describe the correction to be applied with respect to the kinematic (or Ackermann) steering. In particular, denoting with $\\delta$ the steering angle at wheels (note that $\\delta = \\delta_{sw}/\\tau_{sw}$, where $\\delta_{sw}$ is the steering wheel angle and $\\tau_{sw}$ is the steering ratio), the relationship between steer angle and curvature $\\kappa$ is:\n", + "$$\n", + "\\kappa = \\frac{\\delta}{1+A v_x^2}\n", + "$$\n", + "where the parameter $A$ is generally called \"understeering gradient\". \n", + "\n", + "The **local_input_model** is a *LoacalModel* composed of *FIR filters* activated by *Fuzzy triangular memebership functions* on forward speed takes into account the dynamic response of the system that is function of the speed. \n", + "The **local_osus_corr** is another *LocalModel* that implements the algebraic relation above as function of the learnable parameter **A** that varies as function of the longitudinal acceleration. \n", + "Hence, the output curvature is the product of the two local models outputs.\n", + "\n", + "![](figs/fig_model.png)" + ] }, { + "cell_type": "code", + "execution_count": 3, + "id": "a7afd97b064ac3e", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.396841Z", "start_time": "2025-12-02T13:54:32.221943Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "# ----------------------------------------------------------------\n", "# Inputs\n", "# ----------------------------------------------------------------\n", - "curv_in = Input('model_curv_in') # [1/m] path curvature\n", - "vx_in = Input('model_vx_in') # [m/s] longitudinal velocity\n", - "steer_in = Input('model_steer_in') # [rad] steering wheel angle\n", - "ax_in = Input('model_ax_in') # [m/s^2] lateral acceleration\n", + "vx_in = Input(\"model_vx_in\") # [m/s] longitudinal velocity\n", + "steer_in = Input(\"model_steer_in\") # [rad] steering wheel angle\n", + "ax_in = Input(\"model_ax_in\") # [m/s^2] lateral acceleration\n", "\n", "# ----------------------------------------------------------------\n", "# Hyperparameters\n", "# ----------------------------------------------------------------\n", - "samples_past_steer = 30 # number of samples in the past for the steering wheel angle prediction\n", - "n_channels_vx = 8 # number of channels for activation function vx\n", - "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", - "chan_ax = [-2,-1,0.0,1.0,2.0] # centers of the channels ax\n", + "samples_past_steer = (\n", + " 30 # number of samples in the past for the steering wheel angle prediction\n", + ")\n", + "n_channels_vx = 8 # number of channels for activation function vx\n", + "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", + "chan_ax = [-2, -1, 0.0, 1.0, 2.0] # centers of the channels ax\n", "\n", "# Exponential weights for normalisation of FIR parameters during training\n", - "W_fir = np.array([[np.exp(-(i/(samples_past_steer/2))**2)] for i in range(-samples_past_steer+1,1)])\n", - "W_constant = Constant('W_fir',sw=30, values=W_fir)\n", + "W_fir = np.array(\n", + " [\n", + " [np.exp(-((i / (samples_past_steer / 2)) ** 2))]\n", + " for i in range(-samples_past_steer + 1, 1)\n", + " ]\n", + ")\n", + "W_constant = Constant(\"W_fir\", sw=30, values=W_fir)\n", + "\n", "\n", "# ----------------------------------------------------------------\n", "# Understeer correction function\n", "# ----------------------------------------------------------------\n", - "def understeer_corr_local(vx, # input\n", - " A # learnable parameter\n", - " ):\n", + "def understeer_corr_local(\n", + " vx, # input\n", + " A, # learnable parameter\n", + "):\n", " return 1 / (1 + A * torch.pow(vx, 2))\n", "\n", + "\n", "understeer_corr = ParamFun(understeer_corr_local)\n", "\n", "# ----------------------------------------------------------------\n", "# Local models\n", "# ----------------------------------------------------------------\n", "# Activation functions\n", - "fuzzy_vx = Fuzzify(centers=chan_vx, functions='Triangular')(vx_in.last())\n", - "fuzzy_ax = Fuzzify(centers=chan_ax, functions='Triangular')(ax_in.last())\n", + "fuzzy_vx = Fuzzify(centers=chan_vx, functions=\"Triangular\")(vx_in.last())\n", + "fuzzy_ax = Fuzzify(centers=chan_ax, functions=\"Triangular\")(ax_in.last())\n", + "\n", "\n", "# FIR input functions\n", "def Input_Function_Gen(idx):\n", " def fir_out(fir_input):\n", - " out = Fir(W_init='init_constant', W_init_params={\"value\": 1}, dropout=0.05, W=f'Fir_{idx[0]}')(fir_input)\n", + " out = Fir(\n", + " W_init=\"init_constant\", W_init_params={\"value\": 1}, W=f\"Fir_{idx[0]}\"\n", + " )(fir_input)\n", " return out\n", "\n", " return fir_out\n", "\n", + "\n", + "# Local Input Model\n", "local_input_model = LocalModel(pass_indexes=True, input_function=Input_Function_Gen)\n", - "out_input_model = local_input_model((steer_in.sw(samples_past_steer) * W_constant ), fuzzy_vx)\n", + "out_input_model = local_input_model(\n", + " (steer_in.sw(samples_past_steer) * W_constant), fuzzy_vx\n", + ")\n", + "\n", "\n", "# Parametric functions: Understeer correction\n", "def Understeer_Function_Gen(idx):\n", " def osus_out(vx_input):\n", - " A = Parameter('A_' + str(idx[0]), values=[[1e-5]])\n", + " A = Parameter(\"A_\" + str(idx[0]), values=[[1e-5]])\n", " return understeer_corr(vx_input, A)\n", + "\n", " return osus_out\n", "\n", + "\n", + "# Local Understeer Correction Model\n", "local_osus_corr = LocalModel(pass_indexes=True, input_function=Understeer_Function_Gen)\n", "out_osus = local_osus_corr(vx_in.last(), fuzzy_ax)\n", "\n", "# ----------------------------------------------------------------\n", "# Outputs\n", "# ----------------------------------------------------------------\n", - "curv_out = Output('model_curv', out_input_model*out_osus) # output of the model\n", + "curv_out = Output(\"model_curv\", out_input_model * out_osus) # output of the model\n", "\n", "# ----------------------------------------------------------------\n", "# Add model\n", "# ----------------------------------------------------------------\n", - "lat_dyna_model.addModel('vehicle_model', curv_out)" - ], - "id": "a7afd97b064ac3e", - "outputs": [], - "execution_count": 3 + "lat_dyna_model.addModel(\"vehicle_model\", curv_out)" + ] }, { + "cell_type": "markdown", + "id": "deaac585e4481143", "metadata": {}, + "source": [ + "### Loss functions definitions" + ] + }, + { "cell_type": "markdown", - "source": "### Loss functions definitions", - "id": "deaac585e4481143" + "id": "64f1bcf8", + "metadata": {}, + "source": [ + "Two loss terms are defined, both of them use the MSE as loss function. \n", + "The first loss is evaluated on the curvature error: the next-step curvature predicted by the model is compared to the dataset curvature. \n", + "The second loss is evaluated on the heading error*: both reference heading and predicted heading are evaluated starting form the curvature values. \n", + "\n", + "*assuming steady-state curvature, the following relation holds: $\\psi = \\int \\kappa v_x \\, \\mathrm{d}t$, where $\\psi$ denotes the heading angle.\n", + "\n", + "The second loss term provided more robustness to the network, reducing possible biases. The dependency to forward speed, moreover, weights the loss term reducing the bias espetially for high speed, where a bias is more determinant in the tracking error of the desired trajectory." + ] }, { + "cell_type": "code", + "execution_count": 4, + "id": "e3cb0383034fec4", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.486772Z", "start_time": "2025-12-02T13:54:32.403013Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "# ------------------------------------------------------------------------\n", "# Targets\n", "# ------------------------------------------------------------------------\n", + "curv_in = Input(\"model_curv_in\") # [1/m] path curvature\n", + "\n", "# Definition of heading as integral of curvature multiplied by the longitudinal speed\n", - "heading_target = Integrate(curv_in.next()*vx_in.next())\n", - "heading_nn = Integrate(out_input_model*out_osus*vx_in.next())\n", + "heading_target = Integrate(curv_in.next() * vx_in.next())\n", + "heading_nn = Integrate(out_input_model * out_osus * vx_in.next())\n", "\n", "# Add a loss function: mean squared error for the curvature prediction\n", - "lat_dyna_model.addMinimize('curv_error',\n", - " curv_in.next(),\n", - " curv_out,\n", - " loss_function='mse')\n", + "lat_dyna_model.addMinimize(\"curv_error\", curv_in.next(), curv_out, loss_function=\"mse\")\n", "# Add a loss function: mean squared error for the heading prediction\n", - "lat_dyna_model.addMinimize('heading_error',\n", - " heading_target,\n", - " heading_nn)" - ], - "id": "e3cb0383034fec4", - "outputs": [], - "execution_count": 4 + "lat_dyna_model.addMinimize(\"heading_error\", heading_target, heading_nn)" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Model neuralization", - "id": "5a60203dc386c863" + "id": "5a60203dc386c863", + "metadata": {}, + "source": [ + "### Model neuralization" + ] }, { + "cell_type": "code", + "execution_count": 5, + "id": "c909f3d5f6b02813", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.516890Z", "start_time": "2025-12-02T13:54:32.494761Z" } }, - "cell_type": "code", - "source": [ - "# Generate the model\n", - "lat_dyna_model.neuralizeModel(sample_time=0.05) # neuralize the model with the chosen sample time" - ], - "id": "c909f3d5f6b02813", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {'SampleTime': {'dim': 1, 'values': 0.05},\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul87_int34 with sample in the future.\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on Mul77_int33 with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {'SampleTime': {'dim': 1, 'values': 0.05},\n", " 'W_fir': {'dim': 1,\n", " 'sw': 30,\n", " 'values': [[0.023806948214769363],\n", @@ -272,7 +329,7 @@ " [0.9823793172836304],\n", " [0.9955654144287109],\n", " [1.0]]}},\n", - " 'Functions': {'FFuzzify7': {'centers': [8.0,\n", + " 'Functions': {'FFuzzify6': {'centers': [8.0,\n", " 10.142857142857142,\n", " 12.285714285714285,\n", " 14.428571428571429,\n", @@ -283,11 +340,11 @@ " 'dim_out': {'dim': 8},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FFuzzify8': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", + " 'FFuzzify7': {'centers': [-2.0, -1.0, 0.0, 1.0, 2.0],\n", " 'dim_out': {'dim': 5},\n", " 'functions': 'Triangular',\n", " 'names': 'Triangular'},\n", - " 'FParamFun6': {'code': 'def understeer_corr_local(vx, # input\\n'\n", + " 'FParamFun5': {'code': 'def understeer_corr_local(vx, # input\\n'\n", " ' A # '\n", " 'learnable parameter\\n'\n", " ' ):\\n'\n", @@ -299,7 +356,7 @@ " 'name': 'understeer_corr_local',\n", " 'params_and_consts': []}},\n", " 'Info': {'SampleTime': 0.05,\n", - " 'nnodely_version': '1.5.2',\n", + " 'nnodely_version': '1.5.4',\n", " 'ns': [30, 1],\n", " 'ntot': 31,\n", " 'num_parameters': 245},\n", @@ -628,16 +685,16 @@ " 'Add71': ['Add', ['Add70', 'Mul67']],\n", " 'Add82': ['Add', ['SamplePart79', 'Mul81']],\n", " 'Add92': ['Add', ['SamplePart89', 'Mul91']],\n", - " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0.05],\n", - " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0.05],\n", - " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0.05],\n", - " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0.05],\n", - " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0.05],\n", - " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0.05],\n", - " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0.05],\n", - " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0.05],\n", - " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify7'],\n", - " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify8'],\n", + " 'Fir10': ['Fir', ['Mul9'], 'Fir_0', None, 0],\n", + " 'Fir13': ['Fir', ['Mul9'], 'Fir_1', None, 0],\n", + " 'Fir16': ['Fir', ['Mul9'], 'Fir_2', None, 0],\n", + " 'Fir19': ['Fir', ['Mul9'], 'Fir_3', None, 0],\n", + " 'Fir22': ['Fir', ['Mul9'], 'Fir_4', None, 0],\n", + " 'Fir25': ['Fir', ['Mul9'], 'Fir_5', None, 0],\n", + " 'Fir28': ['Fir', ['Mul9'], 'Fir_6', None, 0],\n", + " 'Fir31': ['Fir', ['Mul9'], 'Fir_7', None, 0],\n", + " 'Fuzzify2': ['Fuzzify', ['SamplePart1'], 'FFuzzify6'],\n", + " 'Fuzzify5': ['Fuzzify', ['SamplePart4'], 'FFuzzify7'],\n", " 'Mul12': ['Mul', ['Fir10', 'Select11']],\n", " 'Mul15': ['Mul', ['Fir13', 'Select14']],\n", " 'Mul18': ['Mul', ['Fir16', 'Select17']],\n", @@ -660,19 +717,19 @@ " 'Mul91': ['Mul', ['Mul87', 'SampleTime']],\n", " 'ParamFun43': ['ParamFun',\n", " ['SamplePart42', 'A_0'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun48': ['ParamFun',\n", " ['SamplePart42', 'A_1'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun53': ['ParamFun',\n", " ['SamplePart42', 'A_2'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun58': ['ParamFun',\n", " ['SamplePart42', 'A_3'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'ParamFun63': ['ParamFun',\n", " ['SamplePart42', 'A_4'],\n", - " 'FParamFun6'],\n", + " 'FParamFun5'],\n", " 'SamplePart1': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", " 'SamplePart4': ['SamplePart', ['model_ax_in'], -1, [-1, 0]],\n", " 'SamplePart42': ['SamplePart', ['model_vx_in'], -1, [-1, 0]],\n", @@ -695,166 +752,174 @@ " 'Select51': ['Select', ['Fuzzify5'], 5, 1],\n", " 'Select56': ['Select', ['Fuzzify5'], 5, 2],\n", " 'Select61': ['Select', ['Fuzzify5'], 5, 3],\n", - " 'Select66': ['Select', ['Fuzzify5'], 5, 4]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'Select66': ['Select', ['Fuzzify5'], 5, 4]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 5 + "source": [ + "# Generate the model\n", + "lat_dyna_model.neuralizeModel(\n", + " sample_time=0.05\n", + ") # neuralize the model with the chosen sample time" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# Training", - "id": "78870bde708d1090" - }, - { + "id": "78870bde708d1090", "metadata": {}, - "cell_type": "markdown", - "source": "### Dataset Load", - "id": "d8901687b6eb84c5" + "source": [ + "# Training" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "Here, the data for the training, validation, and test sets are loaded and constructed. The dataset is structured according to the architecture of the network. Specifically, the different columns of the CSV file are mapped to the corresponding Input variables of the network.", - "id": "8ee04d586d61cdd1" + "id": "d3a7dee5", + "metadata": {}, + "source": [ + "The training is done in two steps. The first training has not prediction samples in the future, that corresponds to train the network uniquely on the curvature loss function. In this way the network weights are adjusted. The second step of training is more a refining of the network weigths, including a future time window on which the integral error is evaluated." + ] }, { + "cell_type": "code", + "execution_count": 6, + "id": "6b302b749e7668ee", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.631856Z", "start_time": "2025-12-02T13:54:32.525699Z" } }, - "cell_type": "code", - "source": [ - "lat_dyna_model.loadData('training_set', source='dataset/training',\n", - " format=['', 'model_ax_in', '', 'model_vx_in', 'model_curv_in', '', '', 'model_steer_in', ''],\n", - " skiplines=1)\n", - "lat_dyna_model.loadData('validation_set', source='dataset/validation',\n", - " format=['', 'model_ax_in', '', 'model_vx_in', 'model_curv_in', '', '', 'model_steer_in', ''],\n", - " skiplines=1)\n", - "lat_dyna_model.loadData('test_set', source='dataset/test',\n", - " format=['', 'model_ax_in', '','model_vx_in', 'model_curv_in', 'model_steer_in'], skiplines=1)" - ], - "id": "6b302b749e7668ee", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: training_set\u001B[0m\n", - "\u001B[32mNumber of files: 4\u001B[0m\n", - "\u001B[32mTotal number of samples: 12212\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (12212, 2, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (12212, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (12212, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (12212, 1, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: validation_set\u001B[0m\n", - "\u001B[32mNumber of files: 2\u001B[0m\n", - "\u001B[32mTotal number of samples: 5616\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (5616, 2, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (5616, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (5616, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (5616, 1, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: test_set\u001B[0m\n", - "\u001B[32mNumber of files: 1\u001B[0m\n", - "\u001B[32mTotal number of samples: 1075\u001B[0m\n", - "\u001B[32mShape of model_vx_in: (1075, 2, 1)\u001B[0m\n", - "\u001B[32mShape of model_ax_in: (1075, 1, 1)\u001B[0m\n", - "\u001B[32mShape of model_steer_in: (1075, 30, 1)\u001B[0m\n", - "\u001B[32mShape of model_curv_in: (1075, 1, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: training_set\u001b[0m\n", + "\u001b[32mNumber of files: 4\u001b[0m\n", + "\u001b[32mTotal number of samples: 12212\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (12212, 2, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (12212, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (12212, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (12212, 1, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: validation_set\u001b[0m\n", + "\u001b[32mNumber of files: 2\u001b[0m\n", + "\u001b[32mTotal number of samples: 5616\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (5616, 2, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (5616, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (5616, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (5616, 1, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 6 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "### Training", - "id": "6c9524ead582c921" + "source": [ + "# Dataset loading: all the csv files in the folders defined in 'source' are loaded, with the format defined in 'format'\n", + "# (the order of the columns in the csv files) and skipping the number of lines defined in 'skiplines'\n", + "lat_dyna_model.loadData(\n", + " \"training_set\",\n", + " source=\"dataset/training\",\n", + " format=[\n", + " \"\",\n", + " \"model_ax_in\",\n", + " \"\",\n", + " \"model_vx_in\",\n", + " \"model_curv_in\",\n", + " \"\",\n", + " \"\",\n", + " \"model_steer_in\",\n", + " \"\",\n", + " ],\n", + " skiplines=1,\n", + ")\n", + "lat_dyna_model.loadData(\n", + " \"validation_set\",\n", + " source=\"dataset/validation\",\n", + " format=[\n", + " \"\",\n", + " \"model_ax_in\",\n", + " \"\",\n", + " \"model_vx_in\",\n", + " \"model_curv_in\",\n", + " \"\",\n", + " \"\",\n", + " \"model_steer_in\",\n", + " \"\",\n", + " ],\n", + " skiplines=1,\n", + ")" + ] }, { + "cell_type": "code", + "execution_count": 7, + "id": "fa82ab5c8f2e7f2c", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:54:32.673595Z", "start_time": "2025-12-02T13:54:32.668666Z" } }, - "cell_type": "code", + "outputs": [], "source": [ "# Default training parameters definition\n", - "training_pars = { 'num_of_epochs': 50,\n", - " 'val_batch_size': 64,\n", - " 'train_batch_size': 16,\n", - " 'lr': 1e-3 ,\n", - " 'train_dataset': 'training_set',\n", - " 'validation_dataset': 'validation_set',\n", - " 'optimizer': 'Adam',\n", - " 'shuffle_data': True,\n", - " 'select_model': select_best_model,\n", - " 'early_stopping': earlystopping.early_stop_patience,\n", - " 'early_stopping_params': {'patience': 5,'error': 'heading_error'}}" - ], - "id": "fa82ab5c8f2e7f2c", - "outputs": [], - "execution_count": 7 + "training_pars = {\n", + " \"num_of_epochs\": 150,\n", + " \"val_batch_size\": 64,\n", + " \"train_batch_size\": 64,\n", + " \"lr\": 1e-3,\n", + " \"train_dataset\": \"training_set\",\n", + " \"validation_dataset\": \"validation_set\",\n", + " \"optimizer\": \"Adam\",\n", + " \"shuffle_data\": True,\n", + " \"prediction_samples\": -1, # force to do not evaluate the integral\n", + " \"select_model\": select_best_model,\n", + " \"early_stopping\": earlystopping.early_stop_patience,\n", + " \"early_stopping_params\": {\"patience\": 20, \"error\": \"curv_error\"},\n", + "}" + ] }, { + "cell_type": "code", + "execution_count": 8, + "id": "e949cd28ae6e34c7", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T13:57:00.869647Z", "start_time": "2025-12-02T13:54:32.682537Z" } }, - "cell_type": "code", - "source": [ - "# First training without samples in the future\n", - "lat_dyna_model.trainModel(training_params=training_pars)" - ], - "id": "e949cd28ae6e34c7", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['vehicle_model']\u001B[0m\n", - "\u001B[32mnum of epochs: 50\u001B[0m\n", - "\u001B[32mupdate per epochs: 763\u001B[0m\n", - "\u001B[34mâ””>len(train_indexes)//(batch_size+step)\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mearly stopping: early_stop_patience\u001B[0m\n", - "\u001B[32mearly stopping params: {'error': 'heading_error', 'patience': 5}\u001B[0m\n", - "\u001B[32mprediction samples: 0\u001B[0m\n", - "\u001B[32mstep: 0\u001B[0m\n", - "\u001B[32mclosed loop: {}\u001B[0m\n", - "\u001B[32mconnect: {}\u001B[0m\n", - "\u001B[32mtrain dataset: training_set\u001B[0m\n", - "\u001B[32m\t- batch size: 16\u001B[0m\n", - "\u001B[32m\t- num of samples: 12212\u001B[0m\n", - "\u001B[32m\t- num of first samples: 12212\u001B[0m\n", - "\u001B[32mvalidation dataset: validation_set\u001B[0m\n", - "\u001B[32m\t- batch size: 64\u001B[0m\n", - "\u001B[32m\t- num of samples: 5616\u001B[0m\n", - "\u001B[32m\t- num of first samples: 5616\u001B[0m\n", - "\u001B[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['vehicle_model']\u001b[0m\n", + "\u001b[32mnum of epochs: 150\u001b[0m\n", + "\u001b[32mupdate per epochs: 190\u001b[0m\n", + "\u001b[34mâ””>(n_samples-batch_size)/batch_size+1\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mearly stopping: early_stop_patience\u001b[0m\n", + "\u001b[32mearly stopping params: {'error': 'curv_error', 'patience': 20}\u001b[0m\n", + "\u001b[32mtrain dataset: training_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 12212\u001b[0m\n", + "\u001b[32mvalidation dataset: validation_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 5616\u001b[0m\n", + "\u001b[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", " 'B': 'Mul72',\n", " 'loss': 'mse'},\n", " 'heading_error': {'A': 'Add82',\n", " 'B': 'Add92',\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.001}\u001B[0m\n", - "\u001B[32moptimizer params: [{'params': 'A_0'},\n", + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.001}\u001b[0m\n", + "\u001b[32moptimizer params: [{'params': 'A_0'},\n", " {'params': 'A_1'},\n", " {'params': 'A_2'},\n", " {'params': 'A_3'},\n", @@ -866,140 +931,246 @@ " {'params': 'Fir_4'},\n", " {'params': 'Fir_5'},\n", " {'params': 'Fir_6'},\n", - " {'params': 'Fir_7'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=========================== nnodely Training ===========================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m curv_error |\u001B[0m\u001B[32m heading_error |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 1/50 |\u001B[0m\u001B[32m5.127e+00|\u001B[0m\u001B[32m1.218e+00|\u001B[0m\u001B[32m1.336e+00|\u001B[0m\u001B[32m3.627e-01|\u001B[0m\u001B[32m3.232e+00|\u001B[0m\u001B[32m7.902e-01|\u001B[0m\n", - "\u001B[32m| 2/50 |\u001B[0m\u001B[32m9.836e-01|\u001B[0m\u001B[32m5.206e-01|\u001B[0m\u001B[32m2.512e-01|\u001B[0m\u001B[32m1.577e-01|\u001B[0m\u001B[32m6.174e-01|\u001B[0m\u001B[32m3.392e-01|\u001B[0m\n", - "\u001B[32m| 3/50 |\u001B[0m\u001B[32m4.482e-01|\u001B[0m\u001B[32m2.608e-01|\u001B[0m\u001B[32m1.189e-01|\u001B[0m\u001B[32m8.098e-02|\u001B[0m\u001B[32m2.836e-01|\u001B[0m\u001B[32m1.709e-01|\u001B[0m\n", - "\u001B[32m| 4/50 |\u001B[0m\u001B[32m2.178e-01|\u001B[0m\u001B[32m1.309e-01|\u001B[0m\u001B[32m6.146e-02|\u001B[0m\u001B[32m4.217e-02|\u001B[0m\u001B[32m1.396e-01|\u001B[0m\u001B[32m8.651e-02|\u001B[0m\n", - "\u001B[32m| 5/50 |\u001B[0m\u001B[32m1.002e-01|\u001B[0m\u001B[32m6.118e-02|\u001B[0m\u001B[32m3.106e-02|\u001B[0m\u001B[32m2.091e-02|\u001B[0m\u001B[32m6.562e-02|\u001B[0m\u001B[32m4.105e-02|\u001B[0m\n", - "\u001B[32m| 6/50 |\u001B[0m\u001B[32m4.213e-02|\u001B[0m\u001B[32m2.500e-02|\u001B[0m\u001B[32m1.505e-02|\u001B[0m\u001B[32m9.404e-03|\u001B[0m\u001B[32m2.859e-02|\u001B[0m\u001B[32m1.720e-02|\u001B[0m\n", - "\u001B[32m| 7/50 |\u001B[0m\u001B[32m1.569e-02|\u001B[0m\u001B[32m8.622e-03|\u001B[0m\u001B[32m6.977e-03|\u001B[0m\u001B[32m3.780e-03|\u001B[0m\u001B[32m1.134e-02|\u001B[0m\u001B[32m6.201e-03|\u001B[0m\n", - "\u001B[32m| 8/50 |\u001B[0m\u001B[32m5.671e-03|\u001B[0m\u001B[32m2.657e-03|\u001B[0m\u001B[32m3.245e-03|\u001B[0m\u001B[32m1.416e-03|\u001B[0m\u001B[32m4.458e-03|\u001B[0m\u001B[32m2.037e-03|\u001B[0m\n", - "\u001B[32m| 9/50 |\u001B[0m\u001B[32m2.219e-03|\u001B[0m\u001B[32m7.963e-04|\u001B[0m\u001B[32m1.528e-03|\u001B[0m\u001B[32m5.110e-04|\u001B[0m\u001B[32m1.874e-03|\u001B[0m\u001B[32m6.536e-04|\u001B[0m\n", - "\u001B[32m| 10/50 |\u001B[0m\u001B[32m9.144e-04|\u001B[0m\u001B[32m2.457e-04|\u001B[0m\u001B[32m7.006e-04|\u001B[0m\u001B[32m1.815e-04|\u001B[0m\u001B[32m8.075e-04|\u001B[0m\u001B[32m2.136e-04|\u001B[0m\n", - "\u001B[32m| 11/50 |\u001B[0m\u001B[32m3.629e-04|\u001B[0m\u001B[32m8.477e-05|\u001B[0m\u001B[32m2.979e-04|\u001B[0m\u001B[32m6.751e-05|\u001B[0m\u001B[32m3.304e-04|\u001B[0m\u001B[32m7.614e-05|\u001B[0m\n", - "\u001B[32m| 12/50 |\u001B[0m\u001B[32m1.388e-04|\u001B[0m\u001B[32m3.572e-05|\u001B[0m\u001B[32m1.180e-04|\u001B[0m\u001B[32m2.753e-05|\u001B[0m\u001B[32m1.284e-04|\u001B[0m\u001B[32m3.162e-05|\u001B[0m\n", - "\u001B[32m| 13/50 |\u001B[0m\u001B[32m5.586e-05|\u001B[0m\u001B[32m1.906e-05|\u001B[0m\u001B[32m4.578e-05|\u001B[0m\u001B[32m1.274e-05|\u001B[0m\u001B[32m5.082e-05|\u001B[0m\u001B[32m1.590e-05|\u001B[0m\n", - "\u001B[32m| 14/50 |\u001B[0m\u001B[32m3.037e-05|\u001B[0m\u001B[32m1.257e-05|\u001B[0m\u001B[32m2.103e-05|\u001B[0m\u001B[32m 6.71e-06|\u001B[0m\u001B[32m2.570e-05|\u001B[0m\u001B[32m9.638e-06|\u001B[0m\n", - "\u001B[32m| 15/50 |\u001B[0m\u001B[32m2.025e-05|\u001B[0m\u001B[32m9.265e-06|\u001B[0m\u001B[32m1.088e-05|\u001B[0m\u001B[32m3.991e-06|\u001B[0m\u001B[32m1.556e-05|\u001B[0m\u001B[32m6.628e-06|\u001B[0m\n", - "\u001B[32m| 16/50 |\u001B[0m\u001B[32m1.528e-05|\u001B[0m\u001B[32m6.909e-06|\u001B[0m\u001B[32m6.359e-06|\u001B[0m\u001B[32m2.605e-06|\u001B[0m\u001B[32m1.082e-05|\u001B[0m\u001B[32m4.757e-06|\u001B[0m\n", - "\u001B[32m| 17/50 |\u001B[0m\u001B[32m1.336e-05|\u001B[0m\u001B[32m5.465e-06|\u001B[0m\u001B[32m4.685e-06|\u001B[0m\u001B[32m1.998e-06|\u001B[0m\u001B[32m9.024e-06|\u001B[0m\u001B[32m3.732e-06|\u001B[0m\n", - "\u001B[32m| 18/50 |\u001B[0m\u001B[32m1.283e-05|\u001B[0m\u001B[32m3.688e-06|\u001B[0m\u001B[32m4.229e-06|\u001B[0m\u001B[32m1.375e-06|\u001B[0m\u001B[32m8.528e-06|\u001B[0m\u001B[32m2.532e-06|\u001B[0m\n", - "\u001B[32m| 19/50 |\u001B[0m\u001B[32m 1.04e-05|\u001B[0m\u001B[32m3.215e-06|\u001B[0m\u001B[32m3.423e-06|\u001B[0m\u001B[32m1.252e-06|\u001B[0m\u001B[32m6.909e-06|\u001B[0m\u001B[32m2.233e-06|\u001B[0m\n", - "\u001B[32m| 20/50 |\u001B[0m\u001B[32m1.062e-05|\u001B[0m\u001B[32m1.878e-06|\u001B[0m\u001B[32m3.451e-06|\u001B[0m\u001B[32m7.453e-07|\u001B[0m\u001B[32m7.035e-06|\u001B[0m\u001B[32m1.312e-06|\u001B[0m\n", - "\u001B[32m| 21/50 |\u001B[0m\u001B[32m1.113e-05|\u001B[0m\u001B[32m1.534e-06|\u001B[0m\u001B[32m3.522e-06|\u001B[0m\u001B[32m6.341e-07|\u001B[0m\u001B[32m7.327e-06|\u001B[0m\u001B[32m1.084e-06|\u001B[0m\n", - "\u001B[32m| 22/50 |\u001B[0m\u001B[32m 9.54e-06|\u001B[0m\u001B[32m1.826e-06|\u001B[0m\u001B[32m3.082e-06|\u001B[0m\u001B[32m6.705e-07|\u001B[0m\u001B[32m6.311e-06|\u001B[0m\u001B[32m1.248e-06|\u001B[0m\n", - "\u001B[32m| 23/50 |\u001B[0m\u001B[32m8.368e-06|\u001B[0m\u001B[32m1.293e-06|\u001B[0m\u001B[32m2.873e-06|\u001B[0m\u001B[32m5.385e-07|\u001B[0m\u001B[32m5.620e-06|\u001B[0m\u001B[32m9.155e-07|\u001B[0m\n", - "\u001B[32m| 24/50 |\u001B[0m\u001B[32m1.002e-05|\u001B[0m\u001B[32m1.738e-06|\u001B[0m\u001B[32m3.224e-06|\u001B[0m\u001B[32m6.828e-07|\u001B[0m\u001B[32m6.621e-06|\u001B[0m\u001B[32m1.211e-06|\u001B[0m\n", - "\u001B[32m| 25/50 |\u001B[0m\u001B[32m1.024e-05|\u001B[0m\u001B[32m9.122e-07|\u001B[0m\u001B[32m 3.11e-06|\u001B[0m\u001B[32m3.571e-07|\u001B[0m\u001B[32m6.677e-06|\u001B[0m\u001B[32m6.347e-07|\u001B[0m\n", - "\u001B[32m| 26/50 |\u001B[0m\u001B[32m9.158e-06|\u001B[0m\u001B[32m1.484e-06|\u001B[0m\u001B[32m2.877e-06|\u001B[0m\u001B[32m6.146e-07|\u001B[0m\u001B[32m6.018e-06|\u001B[0m\u001B[32m1.049e-06|\u001B[0m\n", - "\u001B[32m| 27/50 |\u001B[0m\u001B[32m9.300e-06|\u001B[0m\u001B[32m2.128e-06|\u001B[0m\u001B[32m2.816e-06|\u001B[0m\u001B[32m7.661e-07|\u001B[0m\u001B[32m6.058e-06|\u001B[0m\u001B[32m1.447e-06|\u001B[0m\n", - "\u001B[32m| 28/50 |\u001B[0m\u001B[32m9.755e-06|\u001B[0m\u001B[32m5.414e-07|\u001B[0m\u001B[32m3.028e-06|\u001B[0m\u001B[32m2.875e-07|\u001B[0m\u001B[32m6.391e-06|\u001B[0m\u001B[32m4.145e-07|\u001B[0m\n", - "\u001B[32m| 29/50 |\u001B[0m\u001B[32m8.737e-06|\u001B[0m\u001B[32m9.855e-07|\u001B[0m\u001B[32m2.843e-06|\u001B[0m\u001B[32m4.870e-07|\u001B[0m\u001B[32m 5.79e-06|\u001B[0m\u001B[32m7.363e-07|\u001B[0m\n", - "\u001B[32m| 30/50 |\u001B[0m\u001B[32m8.872e-06|\u001B[0m\u001B[32m1.570e-06|\u001B[0m\u001B[32m2.915e-06|\u001B[0m\u001B[32m5.141e-07|\u001B[0m\u001B[32m5.894e-06|\u001B[0m\u001B[32m1.042e-06|\u001B[0m\n", - "\u001B[32m| 31/50 |\u001B[0m\u001B[32m1.007e-05|\u001B[0m\u001B[32m3.200e-07|\u001B[0m\u001B[32m3.048e-06|\u001B[0m\u001B[32m1.537e-07|\u001B[0m\u001B[32m6.558e-06|\u001B[0m\u001B[32m2.369e-07|\u001B[0m\n", - "\u001B[32m| 32/50 |\u001B[0m\u001B[32m8.050e-06|\u001B[0m\u001B[32m6.159e-07|\u001B[0m\u001B[32m2.644e-06|\u001B[0m\u001B[32m2.102e-07|\u001B[0m\u001B[32m5.347e-06|\u001B[0m\u001B[32m4.131e-07|\u001B[0m\n", - "\u001B[32m| 33/50 |\u001B[0m\u001B[32m1.026e-05|\u001B[0m\u001B[32m6.565e-07|\u001B[0m\u001B[32m3.128e-06|\u001B[0m\u001B[32m2.579e-07|\u001B[0m\u001B[32m6.695e-06|\u001B[0m\u001B[32m4.572e-07|\u001B[0m\n", - "\u001B[32m| 34/50 |\u001B[0m\u001B[32m9.869e-06|\u001B[0m\u001B[32m3.346e-07|\u001B[0m\u001B[32m3.034e-06|\u001B[0m\u001B[32m1.679e-07|\u001B[0m\u001B[32m6.451e-06|\u001B[0m\u001B[32m2.513e-07|\u001B[0m\n", - "\u001B[32m| 35/50 |\u001B[0m\u001B[32m7.978e-06|\u001B[0m\u001B[32m9.402e-07|\u001B[0m\u001B[32m2.488e-06|\u001B[0m\u001B[32m3.308e-07|\u001B[0m\u001B[32m5.233e-06|\u001B[0m\u001B[32m6.355e-07|\u001B[0m\n", - "\u001B[34mStopping the training at epoch 35 due to early stopping.\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 146.46113395690918\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " {'params': 'Fir_7'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=========================== nnodely Training ===========================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m curv_error |\u001b[0m\u001b[32m heading_error |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 1/150 |\u001b[0m\u001b[32m1.291e+01|\u001b[0m\u001b[32m4.561e+00|\u001b[0m\u001b[32m3.364e+00|\u001b[0m\u001b[32m1.339e+00|\u001b[0m\u001b[32m8.138e+00|\u001b[0m\u001b[32m 2.95e+00|\u001b[0m\n", + "\u001b[32m| 2/150 |\u001b[0m\u001b[32m3.952e+00|\u001b[0m\u001b[32m2.586e+00|\u001b[0m\u001b[32m9.729e-01|\u001b[0m\u001b[32m7.603e-01|\u001b[0m\u001b[32m2.463e+00|\u001b[0m\u001b[32m1.673e+00|\u001b[0m\n", + "\u001b[32m| 3/150 |\u001b[0m\u001b[32m2.486e+00|\u001b[0m\u001b[32m1.776e+00|\u001b[0m\u001b[32m6.135e-01|\u001b[0m\u001b[32m5.242e-01|\u001b[0m\u001b[32m 1.55e+00|\u001b[0m\u001b[32m1.150e+00|\u001b[0m\n", + "\u001b[32m| 4/150 |\u001b[0m\u001b[32m 1.77e+00|\u001b[0m\u001b[32m1.323e+00|\u001b[0m\u001b[32m4.398e-01|\u001b[0m\u001b[32m3.923e-01|\u001b[0m\u001b[32m1.105e+00|\u001b[0m\u001b[32m8.578e-01|\u001b[0m\n", + "\u001b[32m| 5/150 |\u001b[0m\u001b[32m1.336e+00|\u001b[0m\u001b[32m1.033e+00|\u001b[0m\u001b[32m3.351e-01|\u001b[0m\u001b[32m3.078e-01|\u001b[0m\u001b[32m8.356e-01|\u001b[0m\u001b[32m6.703e-01|\u001b[0m\n", + "\u001b[32m| 6/150 |\u001b[0m\u001b[32m1.046e+00|\u001b[0m\u001b[32m8.281e-01|\u001b[0m\u001b[32m2.646e-01|\u001b[0m\u001b[32m2.483e-01|\u001b[0m\u001b[32m6.551e-01|\u001b[0m\u001b[32m5.382e-01|\u001b[0m\n", + "\u001b[32m| 7/150 |\u001b[0m\u001b[32m8.374e-01|\u001b[0m\u001b[32m6.755e-01|\u001b[0m\u001b[32m2.142e-01|\u001b[0m\u001b[32m2.039e-01|\u001b[0m\u001b[32m5.258e-01|\u001b[0m\u001b[32m4.397e-01|\u001b[0m\n", + "\u001b[32m| 8/150 |\u001b[0m\u001b[32m 6.81e-01|\u001b[0m\u001b[32m5.583e-01|\u001b[0m\u001b[32m1.761e-01|\u001b[0m\u001b[32m1.697e-01|\u001b[0m\u001b[32m4.285e-01|\u001b[0m\u001b[32m3.640e-01|\u001b[0m\n", + "\u001b[32m| 9/150 |\u001b[0m\u001b[32m5.571e-01|\u001b[0m\u001b[32m4.652e-01|\u001b[0m\u001b[32m1.459e-01|\u001b[0m\u001b[32m1.425e-01|\u001b[0m\u001b[32m3.515e-01|\u001b[0m\u001b[32m3.039e-01|\u001b[0m\n", + "\u001b[32m| 10/150 |\u001b[0m\u001b[32m4.586e-01|\u001b[0m\u001b[32m3.897e-01|\u001b[0m\u001b[32m1.218e-01|\u001b[0m\u001b[32m1.204e-01|\u001b[0m\u001b[32m2.902e-01|\u001b[0m\u001b[32m2.551e-01|\u001b[0m\n", + "\u001b[32m| 11/150 |\u001b[0m\u001b[32m3.794e-01|\u001b[0m\u001b[32m3.273e-01|\u001b[0m\u001b[32m1.023e-01|\u001b[0m\u001b[32m1.021e-01|\u001b[0m\u001b[32m2.409e-01|\u001b[0m\u001b[32m2.147e-01|\u001b[0m\n", + "\u001b[32m| 12/150 |\u001b[0m\u001b[32m 3.14e-01|\u001b[0m\u001b[32m2.752e-01|\u001b[0m\u001b[32m8.606e-02|\u001b[0m\u001b[32m8.670e-02|\u001b[0m\u001b[32m2.000e-01|\u001b[0m\u001b[32m 1.81e-01|\u001b[0m\n", + "\u001b[32m| 13/150 |\u001b[0m\u001b[32m2.593e-01|\u001b[0m\u001b[32m2.315e-01|\u001b[0m\u001b[32m7.247e-02|\u001b[0m\u001b[32m7.375e-02|\u001b[0m\u001b[32m1.659e-01|\u001b[0m\u001b[32m1.526e-01|\u001b[0m\n", + "\u001b[32m| 14/150 |\u001b[0m\u001b[32m2.142e-01|\u001b[0m\u001b[32m1.945e-01|\u001b[0m\u001b[32m6.106e-02|\u001b[0m\u001b[32m6.273e-02|\u001b[0m\u001b[32m1.376e-01|\u001b[0m\u001b[32m1.286e-01|\u001b[0m\n", + "\u001b[32m| 15/150 |\u001b[0m\u001b[32m 1.76e-01|\u001b[0m\u001b[32m1.630e-01|\u001b[0m\u001b[32m5.135e-02|\u001b[0m\u001b[32m5.328e-02|\u001b[0m\u001b[32m1.137e-01|\u001b[0m\u001b[32m1.082e-01|\u001b[0m\n", + "\u001b[32m| 16/150 |\u001b[0m\u001b[32m1.445e-01|\u001b[0m\u001b[32m1.360e-01|\u001b[0m\u001b[32m 4.32e-02|\u001b[0m\u001b[32m4.514e-02|\u001b[0m\u001b[32m9.387e-02|\u001b[0m\u001b[32m9.059e-02|\u001b[0m\n", + "\u001b[32m| 17/150 |\u001b[0m\u001b[32m1.179e-01|\u001b[0m\u001b[32m1.130e-01|\u001b[0m\u001b[32m3.626e-02|\u001b[0m\u001b[32m3.811e-02|\u001b[0m\u001b[32m 7.71e-02|\u001b[0m\u001b[32m7.556e-02|\u001b[0m\n", + "\u001b[32m| 18/150 |\u001b[0m\u001b[32m9.568e-02|\u001b[0m\u001b[32m9.340e-02|\u001b[0m\u001b[32m3.030e-02|\u001b[0m\u001b[32m3.208e-02|\u001b[0m\u001b[32m6.299e-02|\u001b[0m\u001b[32m6.274e-02|\u001b[0m\n", + "\u001b[32m| 19/150 |\u001b[0m\u001b[32m7.698e-02|\u001b[0m\u001b[32m7.676e-02|\u001b[0m\u001b[32m2.521e-02|\u001b[0m\u001b[32m 2.69e-02|\u001b[0m\u001b[32m 5.11e-02|\u001b[0m\u001b[32m5.183e-02|\u001b[0m\n", + "\u001b[32m| 20/150 |\u001b[0m\u001b[32m6.170e-02|\u001b[0m\u001b[32m6.270e-02|\u001b[0m\u001b[32m2.095e-02|\u001b[0m\u001b[32m2.245e-02|\u001b[0m\u001b[32m4.132e-02|\u001b[0m\u001b[32m4.258e-02|\u001b[0m\n", + "\u001b[32m| 21/150 |\u001b[0m\u001b[32m4.912e-02|\u001b[0m\u001b[32m5.086e-02|\u001b[0m\u001b[32m1.734e-02|\u001b[0m\u001b[32m1.865e-02|\u001b[0m\u001b[32m3.323e-02|\u001b[0m\u001b[32m3.476e-02|\u001b[0m\n", + "\u001b[32m| 22/150 |\u001b[0m\u001b[32m3.891e-02|\u001b[0m\u001b[32m 4.1e-02 |\u001b[0m\u001b[32m1.431e-02|\u001b[0m\u001b[32m1.542e-02|\u001b[0m\u001b[32m2.661e-02|\u001b[0m\u001b[32m2.821e-02|\u001b[0m\n", + "\u001b[32m| 23/150 |\u001b[0m\u001b[32m3.057e-02|\u001b[0m\u001b[32m3.276e-02|\u001b[0m\u001b[32m1.175e-02|\u001b[0m\u001b[32m1.267e-02|\u001b[0m\u001b[32m2.116e-02|\u001b[0m\u001b[32m2.271e-02|\u001b[0m\n", + "\u001b[32m| 24/150 |\u001b[0m\u001b[32m2.404e-02|\u001b[0m\u001b[32m2.602e-02|\u001b[0m\u001b[32m9.661e-03|\u001b[0m\u001b[32m1.036e-02|\u001b[0m\u001b[32m1.685e-02|\u001b[0m\u001b[32m1.819e-02|\u001b[0m\n", + "\u001b[32m| 25/150 |\u001b[0m\u001b[32m 1.88e-02|\u001b[0m\u001b[32m2.053e-02|\u001b[0m\u001b[32m7.908e-03|\u001b[0m\u001b[32m8.422e-03|\u001b[0m\u001b[32m1.335e-02|\u001b[0m\u001b[32m1.448e-02|\u001b[0m\n", + "\u001b[32m| 26/150 |\u001b[0m\u001b[32m1.465e-02|\u001b[0m\u001b[32m1.609e-02|\u001b[0m\u001b[32m6.446e-03|\u001b[0m\u001b[32m6.807e-03|\u001b[0m\u001b[32m1.055e-02|\u001b[0m\u001b[32m1.145e-02|\u001b[0m\n", + "\u001b[32m| 27/150 |\u001b[0m\u001b[32m1.142e-02|\u001b[0m\u001b[32m1.253e-02|\u001b[0m\u001b[32m5.244e-03|\u001b[0m\u001b[32m5.468e-03|\u001b[0m\u001b[32m8.331e-03|\u001b[0m\u001b[32m8.997e-03|\u001b[0m\n", + "\u001b[32m| 28/150 |\u001b[0m\u001b[32m8.889e-03|\u001b[0m\u001b[32m9.709e-03|\u001b[0m\u001b[32m4.255e-03|\u001b[0m\u001b[32m4.369e-03|\u001b[0m\u001b[32m6.572e-03|\u001b[0m\u001b[32m7.039e-03|\u001b[0m\n", + "\u001b[32m| 29/150 |\u001b[0m\u001b[32m6.896e-03|\u001b[0m\u001b[32m7.487e-03|\u001b[0m\u001b[32m3.427e-03|\u001b[0m\u001b[32m3.468e-03|\u001b[0m\u001b[32m5.162e-03|\u001b[0m\u001b[32m5.477e-03|\u001b[0m\n", + "\u001b[32m| 30/150 |\u001b[0m\u001b[32m5.353e-03|\u001b[0m\u001b[32m5.751e-03|\u001b[0m\u001b[32m2.755e-03|\u001b[0m\u001b[32m2.737e-03|\u001b[0m\u001b[32m4.054e-03|\u001b[0m\u001b[32m4.244e-03|\u001b[0m\n", + "\u001b[32m| 31/150 |\u001b[0m\u001b[32m4.144e-03|\u001b[0m\u001b[32m4.387e-03|\u001b[0m\u001b[32m2.199e-03|\u001b[0m\u001b[32m2.139e-03|\u001b[0m\u001b[32m3.171e-03|\u001b[0m\u001b[32m3.263e-03|\u001b[0m\n", + "\u001b[32m| 32/150 |\u001b[0m\u001b[32m3.189e-03|\u001b[0m\u001b[32m3.325e-03|\u001b[0m\u001b[32m1.741e-03|\u001b[0m\u001b[32m1.657e-03|\u001b[0m\u001b[32m2.465e-03|\u001b[0m\u001b[32m2.491e-03|\u001b[0m\n", + "\u001b[32m| 33/150 |\u001b[0m\u001b[32m2.439e-03|\u001b[0m\u001b[32m2.502e-03|\u001b[0m\u001b[32m1.365e-03|\u001b[0m\u001b[32m1.270e-03|\u001b[0m\u001b[32m1.902e-03|\u001b[0m\u001b[32m1.886e-03|\u001b[0m\n", + "\u001b[32m| 34/150 |\u001b[0m\u001b[32m1.854e-03|\u001b[0m\u001b[32m1.862e-03|\u001b[0m\u001b[32m1.063e-03|\u001b[0m\u001b[32m9.611e-04|\u001b[0m\u001b[32m1.459e-03|\u001b[0m\u001b[32m1.412e-03|\u001b[0m\n", + "\u001b[32m| 35/150 |\u001b[0m\u001b[32m1.391e-03|\u001b[0m\u001b[32m1.366e-03|\u001b[0m\u001b[32m8.151e-04|\u001b[0m\u001b[32m7.161e-04|\u001b[0m\u001b[32m1.103e-03|\u001b[0m\u001b[32m1.041e-03|\u001b[0m\n", + "\u001b[32m| 36/150 |\u001b[0m\u001b[32m1.033e-03|\u001b[0m\u001b[32m9.864e-04|\u001b[0m\u001b[32m6.186e-04|\u001b[0m\u001b[32m 5.25e-04|\u001b[0m\u001b[32m8.257e-04|\u001b[0m\u001b[32m7.557e-04|\u001b[0m\n", + "\u001b[32m| 37/150 |\u001b[0m\u001b[32m7.527e-04|\u001b[0m\u001b[32m6.982e-04|\u001b[0m\u001b[32m4.616e-04|\u001b[0m\u001b[32m3.776e-04|\u001b[0m\u001b[32m6.071e-04|\u001b[0m\u001b[32m5.379e-04|\u001b[0m\n", + "\u001b[32m| 38/150 |\u001b[0m\u001b[32m5.403e-04|\u001b[0m\u001b[32m4.814e-04|\u001b[0m\u001b[32m3.392e-04|\u001b[0m\u001b[32m2.653e-04|\u001b[0m\u001b[32m4.397e-04|\u001b[0m\u001b[32m3.733e-04|\u001b[0m\n", + "\u001b[32m| 39/150 |\u001b[0m\u001b[32m3.811e-04|\u001b[0m\u001b[32m3.246e-04|\u001b[0m\u001b[32m2.459e-04|\u001b[0m\u001b[32m1.831e-04|\u001b[0m\u001b[32m3.135e-04|\u001b[0m\u001b[32m2.538e-04|\u001b[0m\n", + "\u001b[32m| 40/150 |\u001b[0m\u001b[32m2.637e-04|\u001b[0m\u001b[32m2.123e-04|\u001b[0m\u001b[32m1.758e-04|\u001b[0m\u001b[32m1.233e-04|\u001b[0m\u001b[32m2.198e-04|\u001b[0m\u001b[32m1.678e-04|\u001b[0m\n", + "\u001b[32m| 41/150 |\u001b[0m\u001b[32m1.791e-04|\u001b[0m\u001b[32m1.353e-04|\u001b[0m\u001b[32m1.241e-04|\u001b[0m\u001b[32m8.161e-05|\u001b[0m\u001b[32m1.516e-04|\u001b[0m\u001b[32m1.085e-04|\u001b[0m\n", + "\u001b[32m| 42/150 |\u001b[0m\u001b[32m1.194e-04|\u001b[0m\u001b[32m8.410e-05|\u001b[0m\u001b[32m8.665e-05|\u001b[0m\u001b[32m5.323e-05|\u001b[0m\u001b[32m1.030e-04|\u001b[0m\u001b[32m6.867e-05|\u001b[0m\n", + "\u001b[32m| 43/150 |\u001b[0m\u001b[32m7.913e-05|\u001b[0m\u001b[32m5.166e-05|\u001b[0m\u001b[32m6.068e-05|\u001b[0m\u001b[32m3.465e-05|\u001b[0m\u001b[32m6.991e-05|\u001b[0m\u001b[32m4.315e-05|\u001b[0m\n", + "\u001b[32m| 44/150 |\u001b[0m\u001b[32m5.232e-05|\u001b[0m\u001b[32m3.178e-05|\u001b[0m\u001b[32m4.263e-05|\u001b[0m\u001b[32m2.276e-05|\u001b[0m\u001b[32m4.748e-05|\u001b[0m\u001b[32m2.727e-05|\u001b[0m\n", + "\u001b[32m| 45/150 |\u001b[0m\u001b[32m3.491e-05|\u001b[0m\u001b[32m2.022e-05|\u001b[0m\u001b[32m3.024e-05|\u001b[0m\u001b[32m1.537e-05|\u001b[0m\u001b[32m3.258e-05|\u001b[0m\u001b[32m 1.78e-05|\u001b[0m\n", + "\u001b[32m| 46/150 |\u001b[0m\u001b[32m2.395e-05|\u001b[0m\u001b[32m1.357e-05|\u001b[0m\u001b[32m2.185e-05|\u001b[0m\u001b[32m1.076e-05|\u001b[0m\u001b[32m 2.29e-05|\u001b[0m\u001b[32m1.216e-05|\u001b[0m\n", + "\u001b[32m| 47/150 |\u001b[0m\u001b[32m1.713e-05|\u001b[0m\u001b[32m9.878e-06|\u001b[0m\u001b[32m1.623e-05|\u001b[0m\u001b[32m7.892e-06|\u001b[0m\u001b[32m1.668e-05|\u001b[0m\u001b[32m8.885e-06|\u001b[0m\n", + "\u001b[32m| 48/150 |\u001b[0m\u001b[32m1.270e-05|\u001b[0m\u001b[32m7.720e-06|\u001b[0m\u001b[32m1.216e-05|\u001b[0m\u001b[32m5.988e-06|\u001b[0m\u001b[32m1.243e-05|\u001b[0m\u001b[32m6.854e-06|\u001b[0m\n", + "\u001b[32m| 49/150 |\u001b[0m\u001b[32m9.818e-06|\u001b[0m\u001b[32m6.392e-06|\u001b[0m\u001b[32m9.231e-06|\u001b[0m\u001b[32m4.676e-06|\u001b[0m\u001b[32m9.525e-06|\u001b[0m\u001b[32m5.534e-06|\u001b[0m\n", + "\u001b[32m| 50/150 |\u001b[0m\u001b[32m7.848e-06|\u001b[0m\u001b[32m5.483e-06|\u001b[0m\u001b[32m7.102e-06|\u001b[0m\u001b[32m3.706e-06|\u001b[0m\u001b[32m7.475e-06|\u001b[0m\u001b[32m4.595e-06|\u001b[0m\n", + "\u001b[32m| 51/150 |\u001b[0m\u001b[32m6.378e-06|\u001b[0m\u001b[32m4.798e-06|\u001b[0m\u001b[32m5.393e-06|\u001b[0m\u001b[32m2.955e-06|\u001b[0m\u001b[32m5.885e-06|\u001b[0m\u001b[32m3.876e-06|\u001b[0m\n", + "\u001b[32m| 52/150 |\u001b[0m\u001b[32m5.277e-06|\u001b[0m\u001b[32m4.270e-06|\u001b[0m\u001b[32m4.069e-06|\u001b[0m\u001b[32m2.379e-06|\u001b[0m\u001b[32m4.673e-06|\u001b[0m\u001b[32m3.325e-06|\u001b[0m\n", + "\u001b[32m| 53/150 |\u001b[0m\u001b[32m4.423e-06|\u001b[0m\u001b[32m3.843e-06|\u001b[0m\u001b[32m3.060e-06|\u001b[0m\u001b[32m1.932e-06|\u001b[0m\u001b[32m3.742e-06|\u001b[0m\u001b[32m2.888e-06|\u001b[0m\n", + "\u001b[32m| 54/150 |\u001b[0m\u001b[32m3.778e-06|\u001b[0m\u001b[32m3.520e-06|\u001b[0m\u001b[32m2.301e-06|\u001b[0m\u001b[32m1.604e-06|\u001b[0m\u001b[32m3.039e-06|\u001b[0m\u001b[32m2.562e-06|\u001b[0m\n", + "\u001b[32m| 55/150 |\u001b[0m\u001b[32m3.272e-06|\u001b[0m\u001b[32m3.234e-06|\u001b[0m\u001b[32m1.731e-06|\u001b[0m\u001b[32m1.353e-06|\u001b[0m\u001b[32m2.502e-06|\u001b[0m\u001b[32m2.293e-06|\u001b[0m\n", + "\u001b[32m| 56/150 |\u001b[0m\u001b[32m2.909e-06|\u001b[0m\u001b[32m3.045e-06|\u001b[0m\u001b[32m1.347e-06|\u001b[0m\u001b[32m1.176e-06|\u001b[0m\u001b[32m2.128e-06|\u001b[0m\u001b[32m2.111e-06|\u001b[0m\n", + "\u001b[32m| 57/150 |\u001b[0m\u001b[32m2.615e-06|\u001b[0m\u001b[32m2.861e-06|\u001b[0m\u001b[32m1.069e-06|\u001b[0m\u001b[32m1.046e-06|\u001b[0m\u001b[32m1.842e-06|\u001b[0m\u001b[32m1.953e-06|\u001b[0m\n", + "\u001b[32m| 58/150 |\u001b[0m\u001b[32m2.396e-06|\u001b[0m\u001b[32m2.687e-06|\u001b[0m\u001b[32m8.864e-07|\u001b[0m\u001b[32m9.464e-07|\u001b[0m\u001b[32m1.641e-06|\u001b[0m\u001b[32m1.817e-06|\u001b[0m\n", + "\u001b[32m| 59/150 |\u001b[0m\u001b[32m2.209e-06|\u001b[0m\u001b[32m2.611e-06|\u001b[0m\u001b[32m7.617e-07|\u001b[0m\u001b[32m8.926e-07|\u001b[0m\u001b[32m1.486e-06|\u001b[0m\u001b[32m1.752e-06|\u001b[0m\n", + "\u001b[32m| 60/150 |\u001b[0m\u001b[32m2.056e-06|\u001b[0m\u001b[32m2.466e-06|\u001b[0m\u001b[32m6.795e-07|\u001b[0m\u001b[32m8.354e-07|\u001b[0m\u001b[32m1.368e-06|\u001b[0m\u001b[32m1.651e-06|\u001b[0m\n", + "\u001b[32m| 61/150 |\u001b[0m\u001b[32m1.925e-06|\u001b[0m\u001b[32m 2.36e-06|\u001b[0m\u001b[32m6.237e-07|\u001b[0m\u001b[32m7.935e-07|\u001b[0m\u001b[32m1.274e-06|\u001b[0m\u001b[32m1.577e-06|\u001b[0m\n", + "\u001b[32m| 62/150 |\u001b[0m\u001b[32m1.802e-06|\u001b[0m\u001b[32m2.238e-06|\u001b[0m\u001b[32m5.816e-07|\u001b[0m\u001b[32m7.543e-07|\u001b[0m\u001b[32m1.192e-06|\u001b[0m\u001b[32m1.496e-06|\u001b[0m\n", + "\u001b[32m| 63/150 |\u001b[0m\u001b[32m1.685e-06|\u001b[0m\u001b[32m2.153e-06|\u001b[0m\u001b[32m5.473e-07|\u001b[0m\u001b[32m7.263e-07|\u001b[0m\u001b[32m1.116e-06|\u001b[0m\u001b[32m1.439e-06|\u001b[0m\n", + "\u001b[32m| 64/150 |\u001b[0m\u001b[32m1.576e-06|\u001b[0m\u001b[32m2.007e-06|\u001b[0m\u001b[32m5.187e-07|\u001b[0m\u001b[32m6.861e-07|\u001b[0m\u001b[32m1.047e-06|\u001b[0m\u001b[32m1.346e-06|\u001b[0m\n", + "\u001b[32m| 65/150 |\u001b[0m\u001b[32m1.461e-06|\u001b[0m\u001b[32m1.904e-06|\u001b[0m\u001b[32m4.891e-07|\u001b[0m\u001b[32m6.535e-07|\u001b[0m\u001b[32m9.751e-07|\u001b[0m\u001b[32m1.279e-06|\u001b[0m\n", + "\u001b[32m| 66/150 |\u001b[0m\u001b[32m1.360e-06|\u001b[0m\u001b[32m1.802e-06|\u001b[0m\u001b[32m4.631e-07|\u001b[0m\u001b[32m 6.23e-07|\u001b[0m\u001b[32m9.115e-07|\u001b[0m\u001b[32m1.212e-06|\u001b[0m\n", + "\u001b[32m| 67/150 |\u001b[0m\u001b[32m1.264e-06|\u001b[0m\u001b[32m1.703e-06|\u001b[0m\u001b[32m4.384e-07|\u001b[0m\u001b[32m5.938e-07|\u001b[0m\u001b[32m8.511e-07|\u001b[0m\u001b[32m1.148e-06|\u001b[0m\n", + "\u001b[32m| 68/150 |\u001b[0m\u001b[32m1.174e-06|\u001b[0m\u001b[32m 1.61e-06|\u001b[0m\u001b[32m4.152e-07|\u001b[0m\u001b[32m5.674e-07|\u001b[0m\u001b[32m7.946e-07|\u001b[0m\u001b[32m1.089e-06|\u001b[0m\n", + "\u001b[32m| 69/150 |\u001b[0m\u001b[32m1.085e-06|\u001b[0m\u001b[32m1.545e-06|\u001b[0m\u001b[32m3.919e-07|\u001b[0m\u001b[32m5.397e-07|\u001b[0m\u001b[32m7.387e-07|\u001b[0m\u001b[32m1.042e-06|\u001b[0m\n", + "\u001b[32m| 70/150 |\u001b[0m\u001b[32m1.006e-06|\u001b[0m\u001b[32m1.383e-06|\u001b[0m\u001b[32m3.704e-07|\u001b[0m\u001b[32m4.988e-07|\u001b[0m\u001b[32m6.881e-07|\u001b[0m\u001b[32m 9.41e-07|\u001b[0m\n", + "\u001b[32m| 71/150 |\u001b[0m\u001b[32m9.376e-07|\u001b[0m\u001b[32m1.336e-06|\u001b[0m\u001b[32m3.513e-07|\u001b[0m\u001b[32m4.786e-07|\u001b[0m\u001b[32m6.444e-07|\u001b[0m\u001b[32m9.074e-07|\u001b[0m\n", + "\u001b[32m| 72/150 |\u001b[0m\u001b[32m8.744e-07|\u001b[0m\u001b[32m1.265e-06|\u001b[0m\u001b[32m3.331e-07|\u001b[0m\u001b[32m4.558e-07|\u001b[0m\u001b[32m6.037e-07|\u001b[0m\u001b[32m8.604e-07|\u001b[0m\n", + "\u001b[32m| 73/150 |\u001b[0m\u001b[32m8.123e-07|\u001b[0m\u001b[32m1.200e-06|\u001b[0m\u001b[32m3.148e-07|\u001b[0m\u001b[32m4.342e-07|\u001b[0m\u001b[32m5.636e-07|\u001b[0m\u001b[32m8.172e-07|\u001b[0m\n", + "\u001b[32m| 74/150 |\u001b[0m\u001b[32m7.649e-07|\u001b[0m\u001b[32m1.101e-06|\u001b[0m\u001b[32m2.999e-07|\u001b[0m\u001b[32m4.054e-07|\u001b[0m\u001b[32m5.324e-07|\u001b[0m\u001b[32m7.532e-07|\u001b[0m\n", + "\u001b[32m| 75/150 |\u001b[0m\u001b[32m7.242e-07|\u001b[0m\u001b[32m1.063e-06|\u001b[0m\u001b[32m2.865e-07|\u001b[0m\u001b[32m3.873e-07|\u001b[0m\u001b[32m5.053e-07|\u001b[0m\u001b[32m7.251e-07|\u001b[0m\n", + "\u001b[32m| 76/150 |\u001b[0m\u001b[32m6.864e-07|\u001b[0m\u001b[32m1.032e-06|\u001b[0m\u001b[32m2.729e-07|\u001b[0m\u001b[32m3.815e-07|\u001b[0m\u001b[32m4.796e-07|\u001b[0m\u001b[32m7.069e-07|\u001b[0m\n", + "\u001b[32m| 77/150 |\u001b[0m\u001b[32m 6.55e-07|\u001b[0m\u001b[32m9.576e-07|\u001b[0m\u001b[32m2.615e-07|\u001b[0m\u001b[32m3.535e-07|\u001b[0m\u001b[32m4.582e-07|\u001b[0m\u001b[32m6.556e-07|\u001b[0m\n", + "\u001b[32m| 78/150 |\u001b[0m\u001b[32m6.267e-07|\u001b[0m\u001b[32m8.264e-07|\u001b[0m\u001b[32m2.505e-07|\u001b[0m\u001b[32m3.170e-07|\u001b[0m\u001b[32m4.386e-07|\u001b[0m\u001b[32m5.717e-07|\u001b[0m\n", + "\u001b[32m| 79/150 |\u001b[0m\u001b[32m6.014e-07|\u001b[0m\u001b[32m8.145e-07|\u001b[0m\u001b[32m2.405e-07|\u001b[0m\u001b[32m3.059e-07|\u001b[0m\u001b[32m 4.21e-07|\u001b[0m\u001b[32m5.602e-07|\u001b[0m\n", + "\u001b[32m| 80/150 |\u001b[0m\u001b[32m5.770e-07|\u001b[0m\u001b[32m7.544e-07|\u001b[0m\u001b[32m2.303e-07|\u001b[0m\u001b[32m2.897e-07|\u001b[0m\u001b[32m4.037e-07|\u001b[0m\u001b[32m5.221e-07|\u001b[0m\n", + "\u001b[32m| 81/150 |\u001b[0m\u001b[32m5.563e-07|\u001b[0m\u001b[32m7.607e-07|\u001b[0m\u001b[32m2.212e-07|\u001b[0m\u001b[32m2.863e-07|\u001b[0m\u001b[32m3.888e-07|\u001b[0m\u001b[32m5.235e-07|\u001b[0m\n", + "\u001b[32m| 82/150 |\u001b[0m\u001b[32m5.396e-07|\u001b[0m\u001b[32m7.268e-07|\u001b[0m\u001b[32m2.138e-07|\u001b[0m\u001b[32m2.744e-07|\u001b[0m\u001b[32m3.767e-07|\u001b[0m\u001b[32m5.006e-07|\u001b[0m\n", + "\u001b[32m| 83/150 |\u001b[0m\u001b[32m5.291e-07|\u001b[0m\u001b[32m6.631e-07|\u001b[0m\u001b[32m2.068e-07|\u001b[0m\u001b[32m2.555e-07|\u001b[0m\u001b[32m3.679e-07|\u001b[0m\u001b[32m4.593e-07|\u001b[0m\n", + "\u001b[32m| 84/150 |\u001b[0m\u001b[32m5.095e-07|\u001b[0m\u001b[32m7.075e-07|\u001b[0m\u001b[32m1.994e-07|\u001b[0m\u001b[32m2.696e-07|\u001b[0m\u001b[32m3.544e-07|\u001b[0m\u001b[32m4.885e-07|\u001b[0m\n", + "\u001b[32m| 85/150 |\u001b[0m\u001b[32m4.983e-07|\u001b[0m\u001b[32m 5.62e-07|\u001b[0m\u001b[32m1.933e-07|\u001b[0m\u001b[32m2.212e-07|\u001b[0m\u001b[32m3.458e-07|\u001b[0m\u001b[32m3.916e-07|\u001b[0m\n", + "\u001b[32m| 86/150 |\u001b[0m\u001b[32m4.818e-07|\u001b[0m\u001b[32m6.188e-07|\u001b[0m\u001b[32m1.861e-07|\u001b[0m\u001b[32m2.411e-07|\u001b[0m\u001b[32m3.339e-07|\u001b[0m\u001b[32m 4.3e-07 |\u001b[0m\n", + "\u001b[32m| 87/150 |\u001b[0m\u001b[32m4.705e-07|\u001b[0m\u001b[32m5.698e-07|\u001b[0m\u001b[32m1.812e-07|\u001b[0m\u001b[32m2.173e-07|\u001b[0m\u001b[32m3.259e-07|\u001b[0m\u001b[32m3.935e-07|\u001b[0m\n", + "\u001b[32m| 88/150 |\u001b[0m\u001b[32m4.614e-07|\u001b[0m\u001b[32m5.619e-07|\u001b[0m\u001b[32m1.766e-07|\u001b[0m\u001b[32m2.137e-07|\u001b[0m\u001b[32m 3.19e-07|\u001b[0m\u001b[32m3.878e-07|\u001b[0m\n", + "\u001b[32m| 89/150 |\u001b[0m\u001b[32m4.515e-07|\u001b[0m\u001b[32m 7.8e-07 |\u001b[0m\u001b[32m1.712e-07|\u001b[0m\u001b[32m2.651e-07|\u001b[0m\u001b[32m3.114e-07|\u001b[0m\u001b[32m5.225e-07|\u001b[0m\n", + "\u001b[32m| 90/150 |\u001b[0m\u001b[32m4.409e-07|\u001b[0m\u001b[32m5.846e-07|\u001b[0m\u001b[32m1.678e-07|\u001b[0m\u001b[32m2.215e-07|\u001b[0m\u001b[32m3.043e-07|\u001b[0m\u001b[32m4.030e-07|\u001b[0m\n", + "\u001b[32m| 91/150 |\u001b[0m\u001b[32m4.295e-07|\u001b[0m\u001b[32m5.964e-07|\u001b[0m\u001b[32m1.623e-07|\u001b[0m\u001b[32m2.222e-07|\u001b[0m\u001b[32m2.959e-07|\u001b[0m\u001b[32m4.093e-07|\u001b[0m\n", + "\u001b[32m| 92/150 |\u001b[0m\u001b[32m4.166e-07|\u001b[0m\u001b[32m4.621e-07|\u001b[0m\u001b[32m1.579e-07|\u001b[0m\u001b[32m1.866e-07|\u001b[0m\u001b[32m2.872e-07|\u001b[0m\u001b[32m3.244e-07|\u001b[0m\n", + "\u001b[32m| 93/150 |\u001b[0m\u001b[32m4.073e-07|\u001b[0m\u001b[32m5.416e-07|\u001b[0m\u001b[32m1.547e-07|\u001b[0m\u001b[32m2.014e-07|\u001b[0m\u001b[32m2.810e-07|\u001b[0m\u001b[32m3.715e-07|\u001b[0m\n", + "\u001b[32m| 94/150 |\u001b[0m\u001b[32m3.970e-07|\u001b[0m\u001b[32m5.998e-07|\u001b[0m\u001b[32m 1.51e-07|\u001b[0m\u001b[32m2.136e-07|\u001b[0m\u001b[32m2.740e-07|\u001b[0m\u001b[32m4.067e-07|\u001b[0m\n", + "\u001b[32m| 95/150 |\u001b[0m\u001b[32m 3.89e-07|\u001b[0m\u001b[32m 5.23e-07|\u001b[0m\u001b[32m1.481e-07|\u001b[0m\u001b[32m1.996e-07|\u001b[0m\u001b[32m2.685e-07|\u001b[0m\u001b[32m3.613e-07|\u001b[0m\n", + "\u001b[32m| 96/150 |\u001b[0m\u001b[32m3.805e-07|\u001b[0m\u001b[32m6.439e-07|\u001b[0m\u001b[32m1.449e-07|\u001b[0m\u001b[32m2.308e-07|\u001b[0m\u001b[32m2.627e-07|\u001b[0m\u001b[32m4.374e-07|\u001b[0m\n", + "\u001b[32m| 97/150 |\u001b[0m\u001b[32m3.666e-07|\u001b[0m\u001b[32m5.382e-07|\u001b[0m\u001b[32m 1.41e-07|\u001b[0m\u001b[32m1.975e-07|\u001b[0m\u001b[32m2.538e-07|\u001b[0m\u001b[32m3.679e-07|\u001b[0m\n", + "\u001b[32m| 98/150 |\u001b[0m\u001b[32m3.624e-07|\u001b[0m\u001b[32m5.748e-07|\u001b[0m\u001b[32m1.385e-07|\u001b[0m\u001b[32m2.128e-07|\u001b[0m\u001b[32m2.505e-07|\u001b[0m\u001b[32m3.938e-07|\u001b[0m\n", + "\u001b[32m| 99/150 |\u001b[0m\u001b[32m3.451e-07|\u001b[0m\u001b[32m5.213e-07|\u001b[0m\u001b[32m1.334e-07|\u001b[0m\u001b[32m 1.93e-07|\u001b[0m\u001b[32m2.393e-07|\u001b[0m\u001b[32m3.571e-07|\u001b[0m\n", + "\u001b[32m| 100/150 |\u001b[0m\u001b[32m3.449e-07|\u001b[0m\u001b[32m4.416e-07|\u001b[0m\u001b[32m1.329e-07|\u001b[0m\u001b[32m1.719e-07|\u001b[0m\u001b[32m2.389e-07|\u001b[0m\u001b[32m3.068e-07|\u001b[0m\n", + "\u001b[32m| 101/150 |\u001b[0m\u001b[32m3.268e-07|\u001b[0m\u001b[32m3.371e-07|\u001b[0m\u001b[32m1.274e-07|\u001b[0m\u001b[32m1.391e-07|\u001b[0m\u001b[32m2.271e-07|\u001b[0m\u001b[32m2.381e-07|\u001b[0m\n", + "\u001b[32m| 102/150 |\u001b[0m\u001b[32m3.142e-07|\u001b[0m\u001b[32m4.632e-07|\u001b[0m\u001b[32m1.237e-07|\u001b[0m\u001b[32m1.810e-07|\u001b[0m\u001b[32m2.189e-07|\u001b[0m\u001b[32m3.221e-07|\u001b[0m\n", + "\u001b[32m| 103/150 |\u001b[0m\u001b[32m3.023e-07|\u001b[0m\u001b[32m4.806e-07|\u001b[0m\u001b[32m1.203e-07|\u001b[0m\u001b[32m1.665e-07|\u001b[0m\u001b[32m2.113e-07|\u001b[0m\u001b[32m3.235e-07|\u001b[0m\n", + "\u001b[32m| 104/150 |\u001b[0m\u001b[32m2.964e-07|\u001b[0m\u001b[32m4.661e-07|\u001b[0m\u001b[32m1.171e-07|\u001b[0m\u001b[32m1.896e-07|\u001b[0m\u001b[32m2.067e-07|\u001b[0m\u001b[32m3.278e-07|\u001b[0m\n", + "\u001b[32m| 105/150 |\u001b[0m\u001b[32m2.900e-07|\u001b[0m\u001b[32m4.449e-07|\u001b[0m\u001b[32m1.146e-07|\u001b[0m\u001b[32m1.674e-07|\u001b[0m\u001b[32m2.023e-07|\u001b[0m\u001b[32m3.062e-07|\u001b[0m\n", + "\u001b[32m| 106/150 |\u001b[0m\u001b[32m2.675e-07|\u001b[0m\u001b[32m3.391e-07|\u001b[0m\u001b[32m 1.08e-07|\u001b[0m\u001b[32m1.361e-07|\u001b[0m\u001b[32m1.878e-07|\u001b[0m\u001b[32m2.376e-07|\u001b[0m\n", + "\u001b[32m| 107/150 |\u001b[0m\u001b[32m2.814e-07|\u001b[0m\u001b[32m3.879e-07|\u001b[0m\u001b[32m1.098e-07|\u001b[0m\u001b[32m1.530e-07|\u001b[0m\u001b[32m1.956e-07|\u001b[0m\u001b[32m2.705e-07|\u001b[0m\n", + "\u001b[32m| 108/150 |\u001b[0m\u001b[32m2.571e-07|\u001b[0m\u001b[32m3.825e-07|\u001b[0m\u001b[32m1.028e-07|\u001b[0m\u001b[32m1.461e-07|\u001b[0m\u001b[32m1.799e-07|\u001b[0m\u001b[32m2.643e-07|\u001b[0m\n", + "\u001b[32m| 109/150 |\u001b[0m\u001b[32m2.393e-07|\u001b[0m\u001b[32m2.772e-07|\u001b[0m\u001b[32m9.771e-08|\u001b[0m\u001b[32m1.123e-07|\u001b[0m\u001b[32m1.685e-07|\u001b[0m\u001b[32m1.948e-07|\u001b[0m\n", + "\u001b[32m| 110/150 |\u001b[0m\u001b[32m2.244e-07|\u001b[0m\u001b[32m 4.31e-07|\u001b[0m\u001b[32m9.272e-08|\u001b[0m\u001b[32m1.494e-07|\u001b[0m\u001b[32m1.585e-07|\u001b[0m\u001b[32m2.902e-07|\u001b[0m\n", + "\u001b[32m| 111/150 |\u001b[0m\u001b[32m2.112e-07|\u001b[0m\u001b[32m2.354e-07|\u001b[0m\u001b[32m8.774e-08|\u001b[0m\u001b[32m9.777e-08|\u001b[0m\u001b[32m1.495e-07|\u001b[0m\u001b[32m1.666e-07|\u001b[0m\n", + "\u001b[32m| 112/150 |\u001b[0m\u001b[32m2.084e-07|\u001b[0m\u001b[32m3.104e-07|\u001b[0m\u001b[32m8.548e-08|\u001b[0m\u001b[32m1.197e-07|\u001b[0m\u001b[32m1.469e-07|\u001b[0m\u001b[32m2.150e-07|\u001b[0m\n", + "\u001b[32m| 113/150 |\u001b[0m\u001b[32m1.916e-07|\u001b[0m\u001b[32m2.039e-07|\u001b[0m\u001b[32m8.067e-08|\u001b[0m\u001b[32m8.839e-08|\u001b[0m\u001b[32m1.361e-07|\u001b[0m\u001b[32m1.461e-07|\u001b[0m\n", + "\u001b[32m| 114/150 |\u001b[0m\u001b[32m1.862e-07|\u001b[0m\u001b[32m2.334e-07|\u001b[0m\u001b[32m7.677e-08|\u001b[0m\u001b[32m9.529e-08|\u001b[0m\u001b[32m1.315e-07|\u001b[0m\u001b[32m1.644e-07|\u001b[0m\n", + "\u001b[32m| 115/150 |\u001b[0m\u001b[32m1.626e-07|\u001b[0m\u001b[32m1.877e-07|\u001b[0m\u001b[32m7.034e-08|\u001b[0m\u001b[32m8.269e-08|\u001b[0m\u001b[32m1.164e-07|\u001b[0m\u001b[32m1.352e-07|\u001b[0m\n", + "\u001b[32m| 116/150 |\u001b[0m\u001b[32m1.681e-07|\u001b[0m\u001b[32m2.132e-07|\u001b[0m\u001b[32m6.988e-08|\u001b[0m\u001b[32m8.053e-08|\u001b[0m\u001b[32m 1.19e-07|\u001b[0m\u001b[32m1.469e-07|\u001b[0m\n", + "\u001b[32m| 117/150 |\u001b[0m\u001b[32m1.588e-07|\u001b[0m\u001b[32m2.456e-07|\u001b[0m\u001b[32m6.629e-08|\u001b[0m\u001b[32m9.075e-08|\u001b[0m\u001b[32m1.125e-07|\u001b[0m\u001b[32m1.682e-07|\u001b[0m\n", + "\u001b[32m| 118/150 |\u001b[0m\u001b[32m1.338e-07|\u001b[0m\u001b[32m 1.52e-07|\u001b[0m\u001b[32m5.862e-08|\u001b[0m\u001b[32m6.987e-08|\u001b[0m\u001b[32m9.620e-08|\u001b[0m\u001b[32m1.109e-07|\u001b[0m\n", + "\u001b[32m| 119/150 |\u001b[0m\u001b[32m1.387e-07|\u001b[0m\u001b[32m1.258e-07|\u001b[0m\u001b[32m5.800e-08|\u001b[0m\u001b[32m5.650e-08|\u001b[0m\u001b[32m9.834e-08|\u001b[0m\u001b[32m9.116e-08|\u001b[0m\n", + "\u001b[32m| 120/150 |\u001b[0m\u001b[32m1.354e-07|\u001b[0m\u001b[32m1.512e-07|\u001b[0m\u001b[32m5.618e-08|\u001b[0m\u001b[32m6.376e-08|\u001b[0m\u001b[32m9.576e-08|\u001b[0m\u001b[32m1.075e-07|\u001b[0m\n", + "\u001b[32m| 121/150 |\u001b[0m\u001b[32m1.367e-07|\u001b[0m\u001b[32m1.195e-07|\u001b[0m\u001b[32m5.534e-08|\u001b[0m\u001b[32m5.492e-08|\u001b[0m\u001b[32m9.602e-08|\u001b[0m\u001b[32m8.723e-08|\u001b[0m\n", + "\u001b[32m| 122/150 |\u001b[0m\u001b[32m1.042e-07|\u001b[0m\u001b[32m7.735e-08|\u001b[0m\u001b[32m4.651e-08|\u001b[0m\u001b[32m3.649e-08|\u001b[0m\u001b[32m7.535e-08|\u001b[0m\u001b[32m5.692e-08|\u001b[0m\n", + "\u001b[32m| 123/150 |\u001b[0m\u001b[32m9.559e-08|\u001b[0m\u001b[32m1.091e-07|\u001b[0m\u001b[32m4.385e-08|\u001b[0m\u001b[32m4.728e-08|\u001b[0m\u001b[32m6.972e-08|\u001b[0m\u001b[32m7.817e-08|\u001b[0m\n", + "\u001b[32m| 124/150 |\u001b[0m\u001b[32m1.033e-07|\u001b[0m\u001b[32m5.728e-08|\u001b[0m\u001b[32m 4.45e-08|\u001b[0m\u001b[32m2.872e-08|\u001b[0m\u001b[32m7.391e-08|\u001b[0m\u001b[32m 4.3e-08 |\u001b[0m\n", + "\u001b[32m| 125/150 |\u001b[0m\u001b[32m8.857e-08|\u001b[0m\u001b[32m1.073e-07|\u001b[0m\u001b[32m4.174e-08|\u001b[0m\u001b[32m4.874e-08|\u001b[0m\u001b[32m6.516e-08|\u001b[0m\u001b[32m7.804e-08|\u001b[0m\n", + "\u001b[32m| 126/150 |\u001b[0m\u001b[32m9.960e-08|\u001b[0m\u001b[32m1.600e-07|\u001b[0m\u001b[32m4.185e-08|\u001b[0m\u001b[32m5.879e-08|\u001b[0m\u001b[32m7.073e-08|\u001b[0m\u001b[32m1.094e-07|\u001b[0m\n", + "\u001b[32m| 127/150 |\u001b[0m\u001b[32m1.038e-07|\u001b[0m\u001b[32m1.018e-07|\u001b[0m\u001b[32m4.238e-08|\u001b[0m\u001b[32m4.501e-08|\u001b[0m\u001b[32m7.311e-08|\u001b[0m\u001b[32m7.343e-08|\u001b[0m\n", + "\u001b[32m| 128/150 |\u001b[0m\u001b[32m8.447e-08|\u001b[0m\u001b[32m1.069e-07|\u001b[0m\u001b[32m3.811e-08|\u001b[0m\u001b[32m4.183e-08|\u001b[0m\u001b[32m6.129e-08|\u001b[0m\u001b[32m7.434e-08|\u001b[0m\n", + "\u001b[32m| 129/150 |\u001b[0m\u001b[32m 9.55e-08|\u001b[0m\u001b[32m5.782e-08|\u001b[0m\u001b[32m4.194e-08|\u001b[0m\u001b[32m2.976e-08|\u001b[0m\u001b[32m6.872e-08|\u001b[0m\u001b[32m4.379e-08|\u001b[0m\n", + "\u001b[32m| 130/150 |\u001b[0m\u001b[32m9.159e-08|\u001b[0m\u001b[32m6.365e-08|\u001b[0m\u001b[32m3.808e-08|\u001b[0m\u001b[32m2.794e-08|\u001b[0m\u001b[32m6.484e-08|\u001b[0m\u001b[32m 4.58e-08|\u001b[0m\n", + "\u001b[32m| 131/150 |\u001b[0m\u001b[32m7.776e-08|\u001b[0m\u001b[32m5.988e-08|\u001b[0m\u001b[32m 3.62e-08|\u001b[0m\u001b[32m3.084e-08|\u001b[0m\u001b[32m5.698e-08|\u001b[0m\u001b[32m4.536e-08|\u001b[0m\n", + "\u001b[32m| 132/150 |\u001b[0m\u001b[32m7.811e-08|\u001b[0m\u001b[32m4.540e-08|\u001b[0m\u001b[32m3.540e-08|\u001b[0m\u001b[32m2.434e-08|\u001b[0m\u001b[32m5.676e-08|\u001b[0m\u001b[32m3.487e-08|\u001b[0m\n", + "\u001b[32m| 133/150 |\u001b[0m\u001b[32m8.446e-08|\u001b[0m\u001b[32m4.818e-08|\u001b[0m\u001b[32m3.717e-08|\u001b[0m\u001b[32m2.521e-08|\u001b[0m\u001b[32m6.081e-08|\u001b[0m\u001b[32m 3.67e-08|\u001b[0m\n", + "\u001b[32m| 134/150 |\u001b[0m\u001b[32m9.036e-08|\u001b[0m\u001b[32m8.339e-08|\u001b[0m\u001b[32m3.804e-08|\u001b[0m\u001b[32m3.726e-08|\u001b[0m\u001b[32m 6.42e-08|\u001b[0m\u001b[32m6.032e-08|\u001b[0m\n", + "\u001b[32m| 135/150 |\u001b[0m\u001b[32m8.379e-08|\u001b[0m\u001b[32m1.659e-07|\u001b[0m\u001b[32m3.792e-08|\u001b[0m\u001b[32m5.501e-08|\u001b[0m\u001b[32m6.086e-08|\u001b[0m\u001b[32m1.104e-07|\u001b[0m\n", + "\u001b[32m| 136/150 |\u001b[0m\u001b[32m7.168e-08|\u001b[0m\u001b[32m1.363e-07|\u001b[0m\u001b[32m3.374e-08|\u001b[0m\u001b[32m4.506e-08|\u001b[0m\u001b[32m5.271e-08|\u001b[0m\u001b[32m9.068e-08|\u001b[0m\n", + "\u001b[32m| 137/150 |\u001b[0m\u001b[32m7.573e-08|\u001b[0m\u001b[32m 7.62e-08|\u001b[0m\u001b[32m3.477e-08|\u001b[0m\u001b[32m3.365e-08|\u001b[0m\u001b[32m5.525e-08|\u001b[0m\u001b[32m5.492e-08|\u001b[0m\n", + "\u001b[32m| 138/150 |\u001b[0m\u001b[32m7.343e-08|\u001b[0m\u001b[32m4.314e-08|\u001b[0m\u001b[32m3.495e-08|\u001b[0m\u001b[32m2.281e-08|\u001b[0m\u001b[32m5.419e-08|\u001b[0m\u001b[32m3.298e-08|\u001b[0m\n", + "\u001b[32m| 139/150 |\u001b[0m\u001b[32m7.414e-08|\u001b[0m\u001b[32m4.550e-08|\u001b[0m\u001b[32m3.580e-08|\u001b[0m\u001b[32m2.356e-08|\u001b[0m\u001b[32m5.497e-08|\u001b[0m\u001b[32m3.453e-08|\u001b[0m\n", + "\u001b[32m| 140/150 |\u001b[0m\u001b[32m5.955e-08|\u001b[0m\u001b[32m3.739e-08|\u001b[0m\u001b[32m3.087e-08|\u001b[0m\u001b[32m2.158e-08|\u001b[0m\u001b[32m4.521e-08|\u001b[0m\u001b[32m2.948e-08|\u001b[0m\n", + "\u001b[32m| 141/150 |\u001b[0m\u001b[32m8.564e-08|\u001b[0m\u001b[32m1.002e-07|\u001b[0m\u001b[32m3.718e-08|\u001b[0m\u001b[32m3.741e-08|\u001b[0m\u001b[32m6.141e-08|\u001b[0m\u001b[32m6.880e-08|\u001b[0m\n", + "\u001b[32m| 142/150 |\u001b[0m\u001b[32m6.950e-08|\u001b[0m\u001b[32m4.973e-08|\u001b[0m\u001b[32m 3.37e-08|\u001b[0m\u001b[32m2.687e-08|\u001b[0m\u001b[32m 5.16e-08|\u001b[0m\u001b[32m 3.83e-08|\u001b[0m\n", + "\u001b[32m| 143/150 |\u001b[0m\u001b[32m1.065e-07|\u001b[0m\u001b[32m9.179e-08|\u001b[0m\u001b[32m4.339e-08|\u001b[0m\u001b[32m3.489e-08|\u001b[0m\u001b[32m7.493e-08|\u001b[0m\u001b[32m6.334e-08|\u001b[0m\n", + "\u001b[32m| 144/150 |\u001b[0m\u001b[32m6.112e-08|\u001b[0m\u001b[32m5.700e-08|\u001b[0m\u001b[32m3.125e-08|\u001b[0m\u001b[32m2.687e-08|\u001b[0m\u001b[32m4.618e-08|\u001b[0m\u001b[32m4.194e-08|\u001b[0m\n", + "\u001b[32m| 145/150 |\u001b[0m\u001b[32m6.469e-08|\u001b[0m\u001b[32m3.547e-08|\u001b[0m\u001b[32m3.193e-08|\u001b[0m\u001b[32m1.997e-08|\u001b[0m\u001b[32m4.831e-08|\u001b[0m\u001b[32m2.772e-08|\u001b[0m\n", + "\u001b[32m| 146/150 |\u001b[0m\u001b[32m7.421e-08|\u001b[0m\u001b[32m5.445e-08|\u001b[0m\u001b[32m3.493e-08|\u001b[0m\u001b[32m2.831e-08|\u001b[0m\u001b[32m5.457e-08|\u001b[0m\u001b[32m4.138e-08|\u001b[0m\n", + "\u001b[32m| 147/150 |\u001b[0m\u001b[32m6.893e-08|\u001b[0m\u001b[32m3.231e-08|\u001b[0m\u001b[32m3.281e-08|\u001b[0m\u001b[32m1.855e-08|\u001b[0m\u001b[32m5.087e-08|\u001b[0m\u001b[32m2.543e-08|\u001b[0m\n", + "\u001b[32m| 148/150 |\u001b[0m\u001b[32m7.248e-08|\u001b[0m\u001b[32m 4.76e-08|\u001b[0m\u001b[32m3.299e-08|\u001b[0m\u001b[32m2.538e-08|\u001b[0m\u001b[32m5.274e-08|\u001b[0m\u001b[32m3.649e-08|\u001b[0m\n", + "\u001b[32m| 149/150 |\u001b[0m\u001b[32m6.285e-08|\u001b[0m\u001b[32m1.169e-07|\u001b[0m\u001b[32m3.151e-08|\u001b[0m\u001b[32m 4.93e-08|\u001b[0m\u001b[32m4.718e-08|\u001b[0m\u001b[32m 8.31e-08|\u001b[0m\n", + "\u001b[32m| 150/150 |\u001b[0m\u001b[32m7.543e-08|\u001b[0m\u001b[32m5.819e-08|\u001b[0m\u001b[32m3.491e-08|\u001b[0m\u001b[32m2.757e-08|\u001b[0m\u001b[32m5.517e-08|\u001b[0m\u001b[32m4.288e-08|\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 424.8800139427185\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[34mSelected the model at the epoch 31.\u001B[0m\n" + "\u001b[34mSelected the model at the epoch 147.\u001b[0m\n" ] } ], - "execution_count": 8 + "source": [ + "# First training without samples in the future\n", + "lat_dyna_model.trainModel(training_params=training_pars)" + ] }, { + "cell_type": "code", + "execution_count": 9, + "id": "beac2f15f1c62932", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T14:29:18.113953Z", "start_time": "2025-12-02T13:57:00.898316Z" } }, - "cell_type": "code", - "source": [ - "# Training with intergal error 4s in the future\n", - "lat_dyna_model.trainModel(training_params=training_pars,\n", - " num_of_epochs=20,\n", - " prediction_samples=80, # 4s in the future\n", - " step=10)" - ], - "id": "beac2f15f1c62932", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['vehicle_model']\u001B[0m\n", - "\u001B[32mnum of epochs: 20\u001B[0m\n", - "\u001B[32mupdate per epochs: 457\u001B[0m\n", - "\u001B[34mâ””>len(train_indexes)//(batch_size+step)\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mearly stopping: early_stop_patience\u001B[0m\n", - "\u001B[32mearly stopping params: {'error': 'heading_error', 'patience': 5}\u001B[0m\n", - "\u001B[32mprediction samples: 80\u001B[0m\n", - "\u001B[32mstep: 10\u001B[0m\n", - "\u001B[32mclosed loop: {}\u001B[0m\n", - "\u001B[32mconnect: {}\u001B[0m\n", - "\u001B[32mtrain dataset: training_set\u001B[0m\n", - "\u001B[32m\t- batch size: 16\u001B[0m\n", - "\u001B[32m\t- num of samples: 12212\u001B[0m\n", - "\u001B[32m\t- num of first samples: 11892\u001B[0m\n", - "\u001B[32mvalidation dataset: validation_set\u001B[0m\n", - "\u001B[32m\t- batch size: 64\u001B[0m\n", - "\u001B[32m\t- num of samples: 5616\u001B[0m\n", - "\u001B[32m\t- num of first samples: 5456\u001B[0m\n", - "\u001B[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['vehicle_model']\u001b[0m\n", + "\u001b[32mnum of epochs: 20\u001b[0m\n", + "\u001b[32mupdate per epochs: 185\u001b[0m\n", + "\u001b[34mâ””>len(train_indexes)//(batch_size+step)\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mearly stopping: early_stop_patience\u001b[0m\n", + "\u001b[32mearly stopping params: {'error': 'curv_error', 'patience': 20}\u001b[0m\n", + "\u001b[32mprediction samples: 80\u001b[0m\n", + "\u001b[32mstep: 0\u001b[0m\n", + "\u001b[32mclosed loop: {}\u001b[0m\n", + "\u001b[32mconnect: {}\u001b[0m\n", + "\u001b[32mtrain dataset: training_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 12212\u001b[0m\n", + "\u001b[32m\t- num of first samples: 11892\u001b[0m\n", + "\u001b[32mvalidation dataset: validation_set\u001b[0m\n", + "\u001b[32m\t- batch size: 64\u001b[0m\n", + "\u001b[32m\t- num of samples: 5616\u001b[0m\n", + "\u001b[32m\t- num of first samples: 5456\u001b[0m\n", + "\u001b[32mminimizers: {'curv_error': {'A': 'SamplePart95',\n", " 'B': 'Mul72',\n", " 'loss': 'mse'},\n", " 'heading_error': {'A': 'Add82',\n", " 'B': 'Add92',\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.001}\u001B[0m\n", - "\u001B[32moptimizer params: [{'params': 'A_0'},\n", + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.001}\u001b[0m\n", + "\u001b[32moptimizer params: [{'params': 'A_0'},\n", " {'params': 'A_1'},\n", " {'params': 'A_2'},\n", " {'params': 'A_3'},\n", @@ -1011,86 +1182,106 @@ " {'params': 'Fir_4'},\n", " {'params': 'Fir_5'},\n", " {'params': 'Fir_6'},\n", - " {'params': 'Fir_7'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=========================== nnodely Training ===========================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m curv_error |\u001B[0m\u001B[32m heading_error |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 1/20 |\u001B[0m\u001B[32m9.480e-06|\u001B[0m\u001B[32m8.776e-08|\u001B[0m\u001B[32m2.279e-04|\u001B[0m\u001B[32m5.188e-05|\u001B[0m\u001B[32m1.187e-04|\u001B[0m\u001B[32m2.598e-05|\u001B[0m\n", - "\u001B[32m| 2/20 |\u001B[0m\u001B[32m9.335e-06|\u001B[0m\u001B[32m1.856e-07|\u001B[0m\u001B[32m2.349e-04|\u001B[0m\u001B[32m1.519e-04|\u001B[0m\u001B[32m1.221e-04|\u001B[0m\u001B[32m7.607e-05|\u001B[0m\n", - "\u001B[32m| 3/20 |\u001B[0m\u001B[32m9.387e-06|\u001B[0m\u001B[32m8.453e-08|\u001B[0m\u001B[32m2.087e-04|\u001B[0m\u001B[32m4.300e-05|\u001B[0m\u001B[32m1.090e-04|\u001B[0m\u001B[32m2.154e-05|\u001B[0m\n", - "\u001B[32m| 4/20 |\u001B[0m\u001B[32m9.402e-06|\u001B[0m\u001B[32m3.337e-07|\u001B[0m\u001B[32m2.348e-04|\u001B[0m\u001B[32m1.644e-04|\u001B[0m\u001B[32m1.221e-04|\u001B[0m\u001B[32m8.237e-05|\u001B[0m\n", - "\u001B[32m| 5/20 |\u001B[0m\u001B[32m9.379e-06|\u001B[0m\u001B[32m1.554e-07|\u001B[0m\u001B[32m2.064e-04|\u001B[0m\u001B[32m6.845e-05|\u001B[0m\u001B[32m1.079e-04|\u001B[0m\u001B[32m3.430e-05|\u001B[0m\n", - "\u001B[32m| 6/20 |\u001B[0m\u001B[32m9.494e-06|\u001B[0m\u001B[32m7.423e-08|\u001B[0m\u001B[32m2.088e-04|\u001B[0m\u001B[32m3.833e-05|\u001B[0m\u001B[32m1.091e-04|\u001B[0m\u001B[32m1.920e-05|\u001B[0m\n", - "\u001B[32m| 7/20 |\u001B[0m\u001B[32m9.541e-06|\u001B[0m\u001B[32m8.349e-08|\u001B[0m\u001B[32m2.260e-04|\u001B[0m\u001B[32m4.111e-05|\u001B[0m\u001B[32m1.178e-04|\u001B[0m\u001B[32m 2.06e-05|\u001B[0m\n", - "\u001B[32m| 8/20 |\u001B[0m\u001B[32m9.233e-06|\u001B[0m\u001B[32m1.709e-07|\u001B[0m\u001B[32m1.944e-04|\u001B[0m\u001B[32m9.026e-05|\u001B[0m\u001B[32m1.018e-04|\u001B[0m\u001B[32m4.522e-05|\u001B[0m\n", - "\u001B[32m| 9/20 |\u001B[0m\u001B[32m 9.5e-06 |\u001B[0m\u001B[32m2.025e-07|\u001B[0m\u001B[32m2.150e-04|\u001B[0m\u001B[32m1.146e-04|\u001B[0m\u001B[32m1.123e-04|\u001B[0m\u001B[32m5.741e-05|\u001B[0m\n", - "\u001B[32m| 10/20 |\u001B[0m\u001B[32m9.468e-06|\u001B[0m\u001B[32m1.847e-07|\u001B[0m\u001B[32m1.977e-04|\u001B[0m\u001B[32m9.271e-05|\u001B[0m\u001B[32m1.036e-04|\u001B[0m\u001B[32m4.645e-05|\u001B[0m\n", - "\u001B[34mStopping the training at epoch 10 due to early stopping.\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 1936.6063182353973\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " {'params': 'Fir_7'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=========================== nnodely Training ===========================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m curv_error |\u001b[0m\u001b[32m heading_error |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 1/20 |\u001b[0m\u001b[32m7.358e-08|\u001b[0m\u001b[32m5.615e-08|\u001b[0m\u001b[32m3.452e-05|\u001b[0m\u001b[32m3.451e-05|\u001b[0m\u001b[32m 1.73e-05|\u001b[0m\u001b[32m1.728e-05|\u001b[0m\n", + "\u001b[32m| 2/20 |\u001b[0m\u001b[32m5.985e-08|\u001b[0m\u001b[32m4.724e-08|\u001b[0m\u001b[32m 2.58e-05|\u001b[0m\u001b[32m2.342e-05|\u001b[0m\u001b[32m1.293e-05|\u001b[0m\u001b[32m1.173e-05|\u001b[0m\n", + "\u001b[32m| 3/20 |\u001b[0m\u001b[32m6.896e-08|\u001b[0m\u001b[32m1.483e-07|\u001b[0m\u001b[32m3.096e-05|\u001b[0m\u001b[32m7.134e-05|\u001b[0m\u001b[32m1.551e-05|\u001b[0m\u001b[32m3.574e-05|\u001b[0m\n", + "\u001b[32m| 4/20 |\u001b[0m\u001b[32m 6.36e-08|\u001b[0m\u001b[32m7.906e-08|\u001b[0m\u001b[32m2.790e-05|\u001b[0m\u001b[32m4.447e-05|\u001b[0m\u001b[32m1.398e-05|\u001b[0m\u001b[32m2.227e-05|\u001b[0m\n", + "\u001b[32m| 5/20 |\u001b[0m\u001b[32m5.667e-08|\u001b[0m\u001b[32m4.624e-08|\u001b[0m\u001b[32m2.457e-05|\u001b[0m\u001b[32m2.137e-05|\u001b[0m\u001b[32m1.231e-05|\u001b[0m\u001b[32m1.071e-05|\u001b[0m\n", + "\u001b[32m| 6/20 |\u001b[0m\u001b[32m8.774e-08|\u001b[0m\u001b[32m4.895e-08|\u001b[0m\u001b[32m3.843e-05|\u001b[0m\u001b[32m2.369e-05|\u001b[0m\u001b[32m1.926e-05|\u001b[0m\u001b[32m1.187e-05|\u001b[0m\n", + "\u001b[32m| 7/20 |\u001b[0m\u001b[32m6.722e-08|\u001b[0m\u001b[32m3.929e-08|\u001b[0m\u001b[32m2.898e-05|\u001b[0m\u001b[32m1.937e-05|\u001b[0m\u001b[32m1.453e-05|\u001b[0m\u001b[32m9.707e-06|\u001b[0m\n", + "\u001b[32m| 8/20 |\u001b[0m\u001b[32m6.038e-08|\u001b[0m\u001b[32m4.057e-08|\u001b[0m\u001b[32m2.570e-05|\u001b[0m\u001b[32m1.948e-05|\u001b[0m\u001b[32m1.288e-05|\u001b[0m\u001b[32m9.759e-06|\u001b[0m\n", + "\u001b[32m| 9/20 |\u001b[0m\u001b[32m8.325e-08|\u001b[0m\u001b[32m4.096e-08|\u001b[0m\u001b[32m3.745e-05|\u001b[0m\u001b[32m1.991e-05|\u001b[0m\u001b[32m1.877e-05|\u001b[0m\u001b[32m9.977e-06|\u001b[0m\n", + "\u001b[32m| 10/20 |\u001b[0m\u001b[32m5.821e-08|\u001b[0m\u001b[32m5.398e-08|\u001b[0m\u001b[32m2.501e-05|\u001b[0m\u001b[32m2.676e-05|\u001b[0m\u001b[32m1.254e-05|\u001b[0m\u001b[32m1.340e-05|\u001b[0m\n", + "\u001b[32m| 11/20 |\u001b[0m\u001b[32m6.367e-08|\u001b[0m\u001b[32m9.227e-08|\u001b[0m\u001b[32m2.820e-05|\u001b[0m\u001b[32m4.787e-05|\u001b[0m\u001b[32m1.413e-05|\u001b[0m\u001b[32m2.398e-05|\u001b[0m\n", + "\u001b[32m| 12/20 |\u001b[0m\u001b[32m6.326e-08|\u001b[0m\u001b[32m4.386e-08|\u001b[0m\u001b[32m2.744e-05|\u001b[0m\u001b[32m2.074e-05|\u001b[0m\u001b[32m1.375e-05|\u001b[0m\u001b[32m1.039e-05|\u001b[0m\n", + "\u001b[32m| 13/20 |\u001b[0m\u001b[32m6.197e-08|\u001b[0m\u001b[32m5.368e-08|\u001b[0m\u001b[32m2.723e-05|\u001b[0m\u001b[32m3.098e-05|\u001b[0m\u001b[32m1.365e-05|\u001b[0m\u001b[32m1.552e-05|\u001b[0m\n", + "\u001b[32m| 14/20 |\u001b[0m\u001b[32m6.138e-08|\u001b[0m\u001b[32m5.274e-08|\u001b[0m\u001b[32m2.637e-05|\u001b[0m\u001b[32m2.288e-05|\u001b[0m\u001b[32m1.322e-05|\u001b[0m\u001b[32m1.146e-05|\u001b[0m\n", + "\u001b[32m| 15/20 |\u001b[0m\u001b[32m7.998e-08|\u001b[0m\u001b[32m6.268e-08|\u001b[0m\u001b[32m3.608e-05|\u001b[0m\u001b[32m3.329e-05|\u001b[0m\u001b[32m1.808e-05|\u001b[0m\u001b[32m1.668e-05|\u001b[0m\n", + "\u001b[32m| 16/20 |\u001b[0m\u001b[32m5.651e-08|\u001b[0m\u001b[32m3.915e-08|\u001b[0m\u001b[32m2.428e-05|\u001b[0m\u001b[32m1.899e-05|\u001b[0m\u001b[32m1.217e-05|\u001b[0m\u001b[32m9.514e-06|\u001b[0m\n", + "\u001b[32m| 17/20 |\u001b[0m\u001b[32m6.432e-08|\u001b[0m\u001b[32m5.655e-08|\u001b[0m\u001b[32m2.835e-05|\u001b[0m\u001b[32m 2.98e-05|\u001b[0m\u001b[32m1.421e-05|\u001b[0m\u001b[32m1.493e-05|\u001b[0m\n", + "\u001b[32m| 18/20 |\u001b[0m\u001b[32m6.169e-08|\u001b[0m\u001b[32m3.909e-08|\u001b[0m\u001b[32m2.659e-05|\u001b[0m\u001b[32m1.825e-05|\u001b[0m\u001b[32m1.333e-05|\u001b[0m\u001b[32m9.146e-06|\u001b[0m\n", + "\u001b[32m| 19/20 |\u001b[0m\u001b[32m6.126e-08|\u001b[0m\u001b[32m 7.69e-08|\u001b[0m\u001b[32m2.647e-05|\u001b[0m\u001b[32m4.365e-05|\u001b[0m\u001b[32m1.327e-05|\u001b[0m\u001b[32m2.186e-05|\u001b[0m\n", + "\u001b[32m| 20/20 |\u001b[0m\u001b[32m6.146e-08|\u001b[0m\u001b[32m4.936e-08|\u001b[0m\u001b[32m2.649e-05|\u001b[0m\u001b[32m 2.8e-05 |\u001b[0m\u001b[32m1.327e-05|\u001b[0m\u001b[32m1.402e-05|\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 3568.3234169483185\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[34mSelected the model at the epoch 6.\u001B[0m\n" + "\u001b[34mSelected the model at the epoch 18.\u001b[0m\n" ] } ], - "execution_count": 9 + "source": [ + "# Training with intergal error 4s in the future\n", + "lat_dyna_model.trainModel(\n", + " training_params=training_pars, num_of_epochs=20, prediction_samples=80\n", + ")" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# ANALYZE MODEL", - "id": "61013b39c2abd32b" - }, - { + "id": "61013b39c2abd32b", "metadata": {}, - "cell_type": "markdown", - "source": "### FIR filters weights", - "id": "5223712c8c0b77f7" + "source": [ + "# Results Analysis" + ] }, { + "cell_type": "code", + "execution_count": 10, + "id": "38e45190d0844097", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T14:29:18.667992Z", "start_time": "2025-12-02T14:29:18.428787Z" } }, - "cell_type": "code", + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "# Analysis of the FIR parameters\n", "params_fir = {}\n", "sampling_time = 0.05\n", "\n", @@ -1098,300 +1289,154 @@ "plt.figure()\n", "\n", "for key, value in lat_dyna_model.parameters.items():\n", - " if key.startswith('Fir_'):\n", + " if key.startswith(\"Fir_\"):\n", " params_fir[key] = lat_dyna_model.parameters[key]\n", "\n", "for key, value in params_fir.items():\n", " vals = np.array(value).flatten()\n", " t = np.arange(0, sampling_time * len(vals), sampling_time)\n", - " plt.plot(t,np.flip(vals * W_fir.flatten()), 'o', label=key)\n", + " plt.plot(t, np.flip(vals * W_fir.flatten()), \"o\", label=key)\n", "t = np.arange(0, sampling_time * samples_past_steer, sampling_time)\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('amplitude [m-1 rad-1]')\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"amplitude [m-1 rad-1]\")\n", "plt.legend()\n", - "plt.grid(True)" - ], - "id": "38e45190d0844097", - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - } - ], - "execution_count": 10 + "plt.grid(True)\n", + "plt.show()" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "### Analyze model", - "id": "856a457e2372543f" - }, - { + "id": "8b9f1ebb69812b43", "metadata": {}, - "cell_type": "markdown", - "source": "Below is the self-evaluation of the model’s performance on the training, validation, and test sets. The framework automatically computes relevant metrics such as MSE, FVU, and AIC (the latter being particularly useful when comparing this model with alternative models). Performance evaluation is conducted over a temporal window of 200 samples, corresponding to 10 seconds. The plot is also generated automatically and displays consecutive 10-second time series segments. Since the errors were computed for both curvature and heading, they are reported separately below.", - "id": "60f97c83ef7473ce" + "source": [ + "### Test set: curvature comparison" + ] }, { + "cell_type": "code", + "execution_count": 11, + "id": "7db898659ee8183f", "metadata": { "ExecuteTime": { - "end_time": "2025-12-02T14:33:07.623162Z", - "start_time": "2025-12-02T14:29:18.687232Z" + "end_time": "2025-12-02T14:33:10.620735Z", + "start_time": "2025-12-02T14:33:07.689031Z" } }, - "cell_type": "code", - "source": [ - "lat_dyna_model.analyzeModel('training_set',prediction_samples=200) # 10 s prediction\n", - "lat_dyna_model.analyzeModel('validation_set',prediction_samples=200)\n", - "lat_dyna_model.analyzeModel('test_set',prediction_samples=200)" - ], - "id": "8910741402314add", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m================== nnodely Model Results for training_set =================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 1.426e-07 |\u001B[0m\u001B[32m 5.633e-04 |\u001B[0m\u001B[32m 2.412e+06 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 2.229e-04 |\u001B[0m\u001B[32m 2.533e-04 |\u001B[0m\u001B[32m 2.414e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 1.115e-04 |\u001B[0m\u001B[32m 4.083e-04 |\u001B[0m\u001B[32m 2.413e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[1;32m================= nnodely Model Results for validation_set ================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 7.635e-08 |\u001B[0m\u001B[32m 2.847e-04 |\u001B[0m\u001B[32m 1.087e+06 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 1.553e-04 |\u001B[0m\u001B[32m 1.550e-04 |\u001B[0m\u001B[32m 1.092e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 7.771e-05 |\u001B[0m\u001B[32m 2.198e-04 |\u001B[0m\u001B[32m 1.089e+06 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: test_set\u001b[0m\n", + "\u001b[32mNumber of files: 1\u001b[0m\n", + "\u001b[32mTotal number of samples: 1075\u001b[0m\n", + "\u001b[32mShape of model_vx_in: (1075, 2, 1)\u001b[0m\n", + "\u001b[32mShape of model_ax_in: (1075, 1, 1)\u001b[0m\n", + "\u001b[32mShape of model_steer_in: (1075, 30, 1)\u001b[0m\n", + "\u001b[32mShape of model_curv_in: (1075, 1, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[__call__] Different number of samples between inputs [MAX 1000 = 1000; MIN 0 = 0]\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "
" - ], - "image/png": "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" + "
" + ] }, "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[1;32m==================== nnodely Model Results for test_set ===================\u001B[0m\n", - "\u001B[32m| Loss |\u001B[0m\u001B[32m mse |\u001B[0m\u001B[32m FVU |\u001B[0m\u001B[32m AIC |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m small better |\u001B[0m\u001B[32m lower better |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| curv_error |\u001B[0m\u001B[32m 9.887e-08 |\u001B[0m\u001B[32m 4.011e-04 |\u001B[0m\u001B[32m 1.872e+05 |\u001B[0m\n", - "\u001B[32m|heading_error|\u001B[0m\u001B[32m 1.387e-04 |\u001B[0m\u001B[32m 1.989e-04 |\u001B[0m\u001B[32m 1.907e+05 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| Total |\u001B[0m\u001B[32m 6.941e-05 |\u001B[0m\u001B[32m 3.e-04 |\u001B[0m\u001B[32m 1.889e+05 |\u001B[0m\n", - "\u001B[32m|-------------------------------------------------------------------------|\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } + "output_type": "display_data" } ], - "execution_count": 11 - }, - { - "metadata": {}, - "cell_type": "markdown", - "source": "### Plot: curvature comparison", - "id": "8b9f1ebb69812b43" - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-12-02T14:33:10.620735Z", - "start_time": "2025-12-02T14:33:07.689031Z" - } - }, - "cell_type": "code", "source": [ - "data = pd.read_csv(\"dataset/test/test_set.csv\")\n", - "\n", - "sample_test_set = {\n", - " 'model_steer_in': np.array(data['steer']),\n", - " 'model_vx_in' : np.array(data['vx']),\n", - " 'model_curv_in' : np.array(data['curv']),\n", - " 'model_ax_in' : np.array(data['ax'])\n", - "}\n", + "# Dataset extraction\n", + "lat_dyna_model.loadData(\n", + " \"test_set\",\n", + " source=\"dataset/test\",\n", + " format=[\"\", \"model_ax_in\", \"\", \"model_vx_in\", \"model_curv_in\", \"model_steer_in\"],\n", + " skiplines=1,\n", + ")\n", + "data_in = lat_dyna_model.getSamples(\"test_set\", index=1, window=1000)\n", "\n", "# Model inference\n", - "out_nn = lat_dyna_model(sample_test_set, sampled=False, prediction_samples=-1)\n", + "out_nn = lat_dyna_model(data_in, sampled=True)\n", + "\n", + "dataset = pd.read_csv(\"dataset/test/test_set.csv\")\n", "\n", "# Plot\n", - "plt.figure()\n", - "plt.plot(out_nn['model_curv'])\n", - "plt.plot(np.array(data['curv'])[30:])\n", - "plt.xlabel('time (s)')\n", - "plt.ylabel('curvature [m-1]')\n", - "plt.grid(True)" - ], - "id": "7db898659ee8183f", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001B[33m[__call__] Different number of samples between inputs [MAX 1105 = 1105; MIN 1076 = 1076]\u001B[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data", - "jetTransient": { - "display_id": null - } - } - ], - "execution_count": 12 + "plt.figure(figsize=(12, 6))\n", + "plt.plot(\n", + " 0.05 * np.arange(len(np.array(dataset[\"curv\"])[30:])),\n", + " np.array(dataset[\"curv\"])[30:],\n", + " label=\"target\",\n", + ")\n", + "plt.plot(\n", + " 0.05 * np.arange(len(out_nn[\"model_curv\"])),\n", + " out_nn[\"model_curv\"],\n", + " \"--\",\n", + " label=\"prediction\",\n", + ")\n", + "plt.xlabel(\"time (s)\")\n", + "plt.ylabel(\"curvature [1/m]\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] }, { - "metadata": {}, "cell_type": "markdown", - "source": "# SAVE MODEL", - "id": "e52ef4f02f48fb3f" + "id": "e52ef4f02f48fb3f", + "metadata": {}, + "source": [ + "# SAVE MODEL" + ] }, { + "cell_type": "code", + "execution_count": 12, + "id": "8cf9e78e5e359eeb", "metadata": { "ExecuteTime": { "end_time": "2025-12-02T14:33:10.650450Z", "start_time": "2025-12-02T14:33:10.634850Z" } }, - "cell_type": "code", - "source": [ - "# Save json model: will be used in the controller training\n", - "lat_dyna_model.saveModel('vehicle_model')" - ], - "id": "8cf9e78e5e359eeb", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m=============================== Save JSON Model ================================\u001B[0m\n", - "\u001B[32mModel saved in: trained_models/vehicle_model.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + "\u001b[1;32m=============================== Save JSON Model ================================\u001b[0m\n", + "\u001b[32mModel saved in: trained_models/vehicle_model.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 13 + "source": [ + "# Save json model: will be used in the controller training\n", + "lat_dyna_model.saveModel(\"vehicle_model\")" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "nnodely", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.18" } }, "nbformat": 4, diff --git a/case-studies/lateral_dynamics/lateral_dynamics_model_torch.ipynb b/case-studies/lateral_dynamics/lateral_dynamics_model_torch.ipynb index 4bd1ef67..733b2a73 100644 --- a/case-studies/lateral_dynamics/lateral_dynamics_model_torch.ipynb +++ b/case-studies/lateral_dynamics/lateral_dynamics_model_torch.ipynb @@ -49,7 +49,6 @@ ], "source": [ "# Import necessary packages\n", - "import os\n", "import numpy as np\n", "import torch\n", "from torch import nn\n", @@ -57,20 +56,22 @@ "\n", "# import a library for plots\n", "import matplotlib as mpl\n", + "\n", "mpl.rcParams.update(mpl.rcParamsDefault)\n", "import matplotlib.pyplot as plt\n", - "plt.close('all')\n", + "\n", + "plt.close(\"all\")\n", "SMALL_SIZE = 14\n", "MEDIUM_SIZE = 22\n", "BIGGER_SIZE = 26\n", - "plt.rc('font', size=SMALL_SIZE) # controls default text sizes\n", - "plt.rc('axes', titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", - "plt.rc('axes', labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", - "plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels\n", - "plt.rc('legend', fontsize=SMALL_SIZE) # legend fontsize\n", - "plt.rc('figure', titlesize=BIGGER_SIZE) # fontsize of the figure title\n", - "plt.rc('grid', linestyle=\"--\", color='grey')\n", + "plt.rc(\"font\", size=SMALL_SIZE) # controls default text sizes\n", + "plt.rc(\"axes\", titlesize=MEDIUM_SIZE) # fontsize of the axes title\n", + "plt.rc(\"axes\", labelsize=SMALL_SIZE) # fontsize of the x and y labels\n", + "plt.rc(\"xtick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"ytick\", labelsize=SMALL_SIZE) # fontsize of the tick labels\n", + "plt.rc(\"legend\", fontsize=SMALL_SIZE) # legend fontsize\n", + "plt.rc(\"figure\", titlesize=BIGGER_SIZE) # fontsize of the figure title\n", + "plt.rc(\"grid\", linestyle=\"--\", color=\"grey\")\n", "\n", "# Congigurations\n", "device = \"cpu\"\n", @@ -79,7 +80,7 @@ "torch.manual_seed(1)\n", "np.random.seed(1)\n", "\n", - "path_folder = 'trained_models' # folder to save the model" + "path_folder = \"trained_models\" # folder to save the model" ] }, { @@ -117,14 +118,14 @@ "source": [ "# triangular activation function\n", "class TriangularMembershipFunction(nn.Module):\n", - " def __init__(self,centers: list) -> None:\n", + " def __init__(self, centers: list) -> None:\n", " super().__init__()\n", " self.centers = torch.tensor(centers, dtype=torch.float32) # (C,)\n", " self.C = self.centers.numel()\n", "\n", " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", " \"\"\"\n", - " x: (batch,1) \n", + " x: (batch,1)\n", " out: (batch,C) -> membership per channel/centre\n", " \"\"\"\n", " # get sizes\n", @@ -133,39 +134,45 @@ " centers = self.centers\n", "\n", " # triangural membership function initalization\n", - " phi = torch.zeros(batch,self.C)\n", - " x = x.squeeze(1) # (C,)\n", + " phi = torch.zeros(batch, self.C)\n", + " x = x.squeeze(1) # (C,)\n", "\n", " # evaluate channel width and ceneters\n", " x_contig = x.contiguous()\n", - " idx0 = torch.clip(torch.bucketize(x_contig,centers)-1, 0, C-2) # [0, C-2] \n", - " idx1 = idx0 + 1 # [1, C-1]\n", - " c0 = centers[idx0] # left center\n", - " c1 = centers[idx1] # right center\n", - " ch_w = c1 - c0 # channels distance\n", + " idx0 = torch.clip(torch.bucketize(x_contig, centers) - 1, 0, C - 2) # [0, C-2]\n", + " idx1 = idx0 + 1 # [1, C-1]\n", + " c0 = centers[idx0] # left center\n", + " c1 = centers[idx1] # right center\n", + " ch_w = c1 - c0 # channels distance\n", "\n", " b = torch.arange(batch)\n", "\n", - " phi[b,idx0] = torch.clip( (c1 - x) / ch_w , 0 , 1 ) # left channel weight\n", - " phi[b,idx1] = torch.clip( (x - c0) / ch_w , 0 , 1 ) # right channel width\n", + " phi[b, idx0] = torch.clip((c1 - x) / ch_w, 0, 1) # left channel weight\n", + " phi[b, idx1] = torch.clip((x - c0) / ch_w, 0, 1) # right channel width\n", "\n", " return phi # (batch, C)\n", "\n", "\n", "class FirFuzzyLayer(nn.Module):\n", - " def __init__(self,channels: list,window: int) -> None:\n", + " def __init__(self, channels: list, window: int) -> None:\n", " super().__init__()\n", " self.C = len(channels)\n", - " self.phi_layer = TriangularMembershipFunction(channels) # activation functon weights\n", - " self.fir_layer = nn.Conv1d( # parallel fir filters\n", + " self.phi_layer = TriangularMembershipFunction(\n", + " channels\n", + " ) # activation functon weights\n", + " self.fir_layer = nn.Conv1d( # parallel fir filters\n", " in_channels=self.C,\n", " out_channels=self.C,\n", " kernel_size=window,\n", " groups=self.C,\n", - " bias=False) \n", + " bias=False,\n", + " )\n", " nn.init.constant_(self.fir_layer.weight, 1.0)\n", - " self.W_fir = torch.tensor([[np.exp(-(i/(window/2))**2)] for i in range(-window+1,1)],dtype=torch.float32).view(1,1,-1)\n", - " \n", + " self.W_fir = torch.tensor(\n", + " [[np.exp(-((i / (window / 2)) ** 2))] for i in range(-window + 1, 1)],\n", + " dtype=torch.float32,\n", + " ).view(1, 1, -1)\n", + "\n", " def forward(self, x: torch.Tensor, a: torch.Tensor) -> torch.Tensor:\n", " \"\"\"\n", " x: (batch,window) -> input signal with time windows\n", @@ -173,24 +180,25 @@ " out: (batch,1) -> interpolated fir output\n", " \"\"\"\n", " # evaluate membership function\n", - " phi = self.phi_layer(a) # (batch, C)\n", + " phi = self.phi_layer(a) # (batch, C)\n", "\n", " # replicate input for Conv1d\n", - " x_fir = x.unsqueeze(1)*self.W_fir # (batch, 1, window)\n", - " x_fir = x_fir.repeat(1,self.C, 1) # (batch, C, window)\n", - " y = self.fir_layer(x_fir) # (batch, C, 1)\n", + " x_fir = x.unsqueeze(1) * self.W_fir # (batch, 1, window)\n", + " x_fir = x_fir.repeat(1, self.C, 1) # (batch, C, window)\n", + " y = self.fir_layer(x_fir) # (batch, C, 1)\n", " # evaluate weightet output\n", - " y = y.squeeze(-1) # (batch, C)\n", + " y = y.squeeze(-1) # (batch, C)\n", " y = phi * y\n", "\n", - " return y.sum(dim=1).unsqueeze(-1) # (batch,1)\n", - " \n", + " return y.sum(dim=1).unsqueeze(-1) # (batch,1)\n", + "\n", + "\n", "class UsFuzzyLayer(nn.Module):\n", - " def __init__(self,channels: list) -> None:\n", + " def __init__(self, channels: list) -> None:\n", " super().__init__()\n", " self.C = len(channels)\n", - " self.phi_layer = TriangularMembershipFunction(channels)\n", - " self.A = nn.Parameter(1e-5*torch.ones(1,self.C)) \n", + " self.phi_layer = TriangularMembershipFunction(channels)\n", + " self.A = nn.Parameter(1e-5 * torch.ones(1, self.C))\n", "\n", " def forward(self, x: torch.Tensor, a: torch.Tensor) -> torch.Tensor:\n", " \"\"\"\n", @@ -199,35 +207,37 @@ " out: (batch,1) -> output\n", " \"\"\"\n", " # evaluate membership function\n", - " phi = self.phi_layer(a) # (batch,1)\n", + " phi = self.phi_layer(a) # (batch,1)\n", "\n", " # replicate for channels\n", - " x = x.repeat(1,self.C) # (batch,C)\n", + " x = x.repeat(1, self.C) # (batch,C)\n", "\n", " # evaluate parametric function\n", - " y = 1 / (1 + self.A * x**2) \n", + " y = 1 / (1 + self.A * x**2)\n", " y = phi * y\n", "\n", - " return y.sum(dim=1).unsqueeze(-1) #(batch,1)\n", - " \n", + " return y.sum(dim=1).unsqueeze(-1) # (batch,1)\n", + "\n", "\n", "class LateralDynamics(nn.Module):\n", " def __init__(self, chan_vx: list, chan_ax: list, window: int) -> None:\n", " super().__init__()\n", - " self.fir_layer = FirFuzzyLayer(chan_vx,window)\n", - " self.us_layer = UsFuzzyLayer(chan_ax)\n", + " self.fir_layer = FirFuzzyLayer(chan_vx, window)\n", + " self.us_layer = UsFuzzyLayer(chan_ax)\n", "\n", - " def forward(self, steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor) -> torch.Tensor:\n", + " def forward(\n", + " self, steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor\n", + " ) -> torch.Tensor:\n", " \"\"\"\n", - " steer: (batch,window) -> steer time window \n", + " steer: (batch,window) -> steer time window\n", " vx: (batch,1) -> vx last\n", " ax: (batch,1) -> ax last\n", " out: (batch,1) -> rho next\n", " \"\"\"\n", " # apply fir\n", - " rho_kin = self.fir_layer(steer,vx)\n", + " rho_kin = self.fir_layer(steer, vx)\n", " # apply us correction\n", - " corr_kus = self.us_layer(vx,ax)\n", + " corr_kus = self.us_layer(vx, ax)\n", "\n", " return rho_kin * corr_kus" ] @@ -247,17 +257,19 @@ "# ----------------------------------------------------------------\n", "# Hyperparameters\n", "# ----------------------------------------------------------------\n", - "samples_past_steer = 30 # number of samples in the past for the steering wheel angle prediction\n", - "n_channels_vx = 8 # number of channels for activation function vx\n", - "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", - "chan_ax = [-2,-1,0.0,1.0,2.0] # centers of the channels ax\n", + "samples_past_steer = (\n", + " 30 # number of samples in the past for the steering wheel angle prediction\n", + ")\n", + "n_channels_vx = 8 # number of channels for activation function vx\n", + "chan_vx = list(np.linspace(8, 23, num=n_channels_vx)) # centers of the channels vx\n", + "chan_ax = [-2, -1, 0.0, 1.0, 2.0] # centers of the channels ax\n", "\n", - "prediction = 80 # 4s prediction\n", + "prediction = 80 # 4s prediction\n", "\n", "# ----------------------------------------------------------------\n", "# MODEL\n", "# ----------------------------------------------------------------\n", - "model = LateralDynamics(chan_vx,chan_ax,samples_past_steer)" + "model = LateralDynamics(chan_vx, chan_ax, samples_past_steer)" ] }, { @@ -284,16 +296,18 @@ "outputs": [], "source": [ "data_training = \"dataset/training/*.csv\"\n", - "data_valid = \"dataset/validation/*.csv\"\n", - "data_test = \"dataset/test/*.csv\"\n", + "data_valid = \"dataset/validation/*.csv\"\n", + "data_test = \"dataset/test/*.csv\"\n", "\n", - "head = ['ax', 'vx', 'curv', 'steer']\n", + "head = [\"ax\", \"vx\", \"curv\", \"steer\"]\n", "sampling = 0.05\n", "\n", "\n", "# loading of csv datasets\n", "import pandas as pd\n", "import glob\n", + "\n", + "\n", "def load_csv_list(data_path: str):\n", " dfs = []\n", " for file in glob.glob(data_path):\n", @@ -302,6 +316,7 @@ " dfs.append(df)\n", " return dfs\n", "\n", + "\n", "class VehicleDataset(Dataset):\n", " def __init__(self, df: pd.DataFrame, past_samples: int, prediction: int):\n", " self.lb = past_samples\n", @@ -309,9 +324,9 @@ " self.df = df\n", "\n", " self.steer = torch.tensor(df[\"steer\"].values, dtype=torch.float32)\n", - " self.vx = torch.tensor(df[\"vx\"].values, dtype=torch.float32)\n", - " self.ax = torch.tensor(df[\"ax\"].values, dtype=torch.float32)\n", - " self.curv = torch.tensor(df[\"curv\"].values, dtype=torch.float32)\n", + " self.vx = torch.tensor(df[\"vx\"].values, dtype=torch.float32)\n", + " self.ax = torch.tensor(df[\"ax\"].values, dtype=torch.float32)\n", + " self.curv = torch.tensor(df[\"curv\"].values, dtype=torch.float32)\n", "\n", " def __len__(self):\n", " return len(self.df) - self.lb - self.lf - 1\n", @@ -320,17 +335,18 @@ " steer = self.steer[i : i + self.lb + self.lf]\n", "\n", " if self.lf > 0:\n", - " vx = self.vx[i + self.lb -1: i + self.lb + self.lf -1]\n", - " ax = self.ax[i + self.lb -1: i + self.lb + self.lf -1]\n", + " vx = self.vx[i + self.lb - 1 : i + self.lb + self.lf - 1]\n", + " ax = self.ax[i + self.lb - 1 : i + self.lb + self.lf - 1]\n", " curv = self.curv[i + self.lb : i + self.lb + self.lf]\n", " else:\n", - " vx = self.vx[i + self.lb -1].unsqueeze(-1)\n", - " ax = self.ax[i + self.lb -1].unsqueeze(-1)\n", + " vx = self.vx[i + self.lb - 1].unsqueeze(-1)\n", + " ax = self.ax[i + self.lb - 1].unsqueeze(-1)\n", " curv = self.curv[i + self.lb].unsqueeze(-1)\n", "\n", " return steer, vx, ax, curv\n", "\n", - "# Concatenate datasets \n", + "\n", + "# Concatenate datasets\n", "def build_dataset(csv_path, past_samples, prediction):\n", " dfs = load_csv_list(csv_path)\n", " datasets = [\n", @@ -340,6 +356,7 @@ " ]\n", " return ConcatDataset(datasets)\n", "\n", + "\n", "# non recurrent dataset\n", "train_dataset = build_dataset(data_training, samples_past_steer, prediction=0)\n", "valid_dataset = build_dataset(data_valid, samples_past_steer, prediction=0)\n", @@ -573,33 +590,35 @@ "# ------------------------------------------------------------------------\n", "# Non-recurrent training\n", "# ------------------------------------------------------------------------\n", - "EPOCHS = 150\n", + "EPOCHS = 150\n", "\n", "train_loss_list = []\n", "valid_loss_list = []\n", "\n", - "def inference(steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor, curv: torch.Tensor):\n", + "\n", + "def inference(\n", + " steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor, curv: torch.Tensor\n", + "):\n", "\n", " # Make one-step prediction\n", - " output = model(steer,vx, ax)\n", + " output = model(steer, vx, ax)\n", " # Compute the loss\n", " loss = loss_fn(output, curv)\n", "\n", " return loss\n", "\n", "\n", - "\n", "def train_one_epoch():\n", " avg_loss = 0.0\n", "\n", " for i, data in enumerate(train_dataloader):\n", " steer, vx, ax, curv = data\n", - " \n", + "\n", " # Zero your gradients for every batch!\n", " optimizer.zero_grad()\n", "\n", " # compute loss and its gradient\n", - " loss = inference(steer,vx,ax,curv)\n", + " loss = inference(steer, vx, ax, curv)\n", " loss.backward()\n", "\n", " avg_loss += loss.item()\n", @@ -609,7 +628,7 @@ " return avg_loss / len(train_dataloader)\n", "\n", "\n", - "print('| {:^7} | {:^12} | {:^12} |'.format('EPOCHS','train_loss','valid_loss'))\n", + "print(\"| {:^7} | {:^12} | {:^12} |\".format(\"EPOCHS\", \"train_loss\", \"valid_loss\"))\n", "for epoch in range(EPOCHS):\n", " # Make sure gradient tracking is on, and do a pass over the data\n", " model.train(True)\n", @@ -619,29 +638,29 @@ " # statistics for batch normalization.\n", " model.eval()\n", " avg_vloss = 0.0\n", - " \n", + "\n", " with torch.no_grad():\n", " for i, vdata in enumerate(valid_dataloader):\n", " steer, vx, ax, curv = vdata\n", - " \n", - " vloss = inference(steer,vx,ax,curv)\n", + "\n", + " vloss = inference(steer, vx, ax, curv)\n", " avg_vloss += vloss.item()\n", " avg_vloss /= len(valid_dataloader)\n", - " \n", + "\n", " # save the total losses\n", " train_loss_list.append(avg_loss)\n", " valid_loss_list.append(avg_vloss)\n", "\n", - " print('| {:^7} | {:^12.6e} | {:^12.6e} |'.format(epoch+1, avg_loss, avg_vloss))\n", + " print(\"| {:^7} | {:^12.6e} | {:^12.6e} |\".format(epoch + 1, avg_loss, avg_vloss))\n", " epoch += 1\n", "\n", "plt.figure()\n", - "plt.title('Non recurrent training')\n", - "plt.plot(train_loss_list, label='train loss')\n", - "plt.plot(valid_loss_list, '--', label='validation loss')\n", - "plt.yscale('log')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", + "plt.title(\"Non recurrent training\")\n", + "plt.plot(train_loss_list, label=\"train loss\")\n", + "plt.plot(valid_loss_list, \"--\", label=\"validation loss\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Epochs\")\n", + "plt.ylabel(\"Loss\")\n", "plt.legend()\n", "plt.grid()\n", "plt.show()\n", @@ -708,36 +727,39 @@ "# ------------------------------------------------------------------------\n", "# Recurrent training\n", "# ------------------------------------------------------------------------\n", - "EPOCHS = 20\n", + "EPOCHS = 20\n", "\n", "curv_loss_list = []\n", "head_loss_list = []\n", "curv_vloss_list = []\n", "head_vloss_list = []\n", "\n", - "def inference_rec(steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor, curv: torch.Tensor):\n", + "\n", + "def inference_rec(\n", + " steer: torch.Tensor, vx: torch.Tensor, ax: torch.Tensor, curv: torch.Tensor\n", + "):\n", "\n", " # recurrent training\n", - " psi0_ref = 0\n", - " psi_ref = 0\n", + " psi0_ref = 0\n", + " psi_ref = 0\n", " psi0_comp = 0\n", - " psi_comp = 0\n", + " psi_comp = 0\n", " loss_curv = 0\n", " loss_head = 0\n", "\n", " for j in range(prediction):\n", - " steer_k = steer[:,j:j+samples_past_steer]\n", - " vx_k = vx[:,j].unsqueeze(-1)\n", - " ax_k = ax[:,j].unsqueeze(-1)\n", - " curv_k = curv[:,j].unsqueeze(-1)\n", + " steer_k = steer[:, j : j + samples_past_steer]\n", + " vx_k = vx[:, j].unsqueeze(-1)\n", + " ax_k = ax[:, j].unsqueeze(-1)\n", + " curv_k = curv[:, j].unsqueeze(-1)\n", "\n", " # Make one-step prediction\n", - " output = model(steer_k,vx_k, ax_k)\n", + " output = model(steer_k, vx_k, ax_k)\n", " # Compute the loss\n", " loss_curv += loss_fn(output, curv_k)\n", - " psi_ref = psi0_ref + curv_k*vx_k*sampling\n", - " psi_comp = psi0_comp + output*vx_k*sampling\n", - " loss_head += loss_fn(psi_ref,psi_comp)\n", + " psi_ref = psi0_ref + curv_k * vx_k * sampling\n", + " psi_comp = psi0_comp + output * vx_k * sampling\n", + " loss_head += loss_fn(psi_ref, psi_comp)\n", "\n", " psi0_comp = psi_comp\n", " psi0_ref = psi_ref\n", @@ -750,7 +772,6 @@ " return loss, loss_curv, loss_head\n", "\n", "\n", - "\n", "def train_one_epoch_rec():\n", " avg_loss = 0.0\n", " avg_curv_loss = 0.0\n", @@ -762,7 +783,7 @@ " optimizer.zero_grad()\n", "\n", " # compute loss and its gradient\n", - " loss, loss_curv, loss_head = inference_rec(steer,vx,ax,curv)\n", + " loss, loss_curv, loss_head = inference_rec(steer, vx, ax, curv)\n", " loss.backward()\n", "\n", " avg_loss += loss.item()\n", @@ -773,10 +794,14 @@ " # Adjust learning weights\n", " optimizer.step()\n", "\n", - " return avg_loss / len(train_dataloader_rec), avg_curv_loss / len(train_dataloader_rec), avg_head_loss / len(train_dataloader_rec)\n", + " return (\n", + " avg_loss / len(train_dataloader_rec),\n", + " avg_curv_loss / len(train_dataloader_rec),\n", + " avg_head_loss / len(train_dataloader_rec),\n", + " )\n", "\n", "\n", - "print('| {:^7} | {:^12} | {:^12} |'.format('EPOCHS','train_loss','valid_loss'))\n", + "print(\"| {:^7} | {:^12} | {:^12} |\".format(\"EPOCHS\", \"train_loss\", \"valid_loss\"))\n", "for epoch in range(EPOCHS):\n", " # Make sure gradient tracking is on, and do a pass over the data\n", " model.train(True)\n", @@ -795,8 +820,8 @@ " with torch.no_grad():\n", " for i, vdata in enumerate(valid_dataloader_rec):\n", " steer, vx, ax, curv = vdata\n", - " \n", - " vloss, vloss_curv, vloss_head = inference_rec(steer,vx,ax,curv)\n", + "\n", + " vloss, vloss_curv, vloss_head = inference_rec(steer, vx, ax, curv)\n", " avg_vloss += vloss.item()\n", " avg_vloss_curv += vloss_curv.item()\n", " avg_vloss_head += vloss_head.item()\n", @@ -806,29 +831,29 @@ " avg_vloss_head /= len(valid_dataloader_rec)\n", " head_vloss_list.append(avg_vloss_head)\n", " curv_vloss_list.append(avg_vloss_curv)\n", - " \n", - " print('| {:^7} | {:^12.6e} | {:^12.6e} |'.format(epoch+1, avg_loss, avg_vloss))\n", + "\n", + " print(\"| {:^7} | {:^12.6e} | {:^12.6e} |\".format(epoch + 1, avg_loss, avg_vloss))\n", " epoch += 1\n", "\n", "\n", "plt.figure()\n", - "plt.title('Recurrent training')\n", - "plt.plot(curv_loss_list, label='train curvature loss')\n", - "plt.plot(curv_vloss_list, '--', label='validation curvature loss')\n", - "plt.yscale('log')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", + "plt.title(\"Recurrent training\")\n", + "plt.plot(curv_loss_list, label=\"train curvature loss\")\n", + "plt.plot(curv_vloss_list, \"--\", label=\"validation curvature loss\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Epochs\")\n", + "plt.ylabel(\"Loss\")\n", "plt.legend()\n", "plt.grid()\n", "plt.show()\n", "\n", "plt.figure()\n", - "plt.title('Recurrent training')\n", - "plt.plot(head_loss_list, label='train heading loss')\n", - "plt.plot(head_vloss_list, '--', label='validation heading loss')\n", - "plt.yscale('log')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", + "plt.title(\"Recurrent training\")\n", + "plt.plot(head_loss_list, label=\"train heading loss\")\n", + "plt.plot(head_vloss_list, \"--\", label=\"validation heading loss\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Epochs\")\n", + "plt.ylabel(\"Loss\")\n", "plt.legend()\n", "plt.grid()\n", "plt.show()\n", @@ -865,14 +890,14 @@ ], "source": [ "# inference\n", - "model = LateralDynamics(chan_vx,chan_ax,samples_past_steer)\n", + "model = LateralDynamics(chan_vx, chan_ax, samples_past_steer)\n", "model.load_state_dict(torch.load(path_folder + \"/vehicle_model_torch.pt\"))\n", "\n", "curv_targ = []\n", "curv_out = []\n", "\n", - "for i,data in enumerate(test_dataloader_analyse):\n", - " steer, vx, ax , curv = data\n", + "for i, data in enumerate(test_dataloader_analyse):\n", + " steer, vx, ax, curv = data\n", "\n", " model.eval()\n", " curv_ = model(steer, vx, ax)\n", @@ -880,16 +905,25 @@ " curv_targ.append(curv)\n", " curv_out.append(curv_)\n", "\n", - "curv_targ = torch.cat(curv_targ,dim=0).squeeze().numpy()\n", - "curv_out = torch.cat(curv_out,dim=0).squeeze().detach().numpy()\n", + "curv_targ = torch.cat(curv_targ, dim=0).squeeze().numpy()\n", + "curv_out = torch.cat(curv_out, dim=0).squeeze().detach().numpy()\n", "\n", "# Plot comparison\n", - "plt.figure(figsize=(12,6))\n", - "plt.plot(sampling*np.linspace(0,len(curv_targ),len(curv_targ)),curv_targ, label='Target curvature')\n", - "plt.plot(sampling*np.linspace(0,len(curv_out),len(curv_out)),curv_out, '--', label='Predicted curvature')\n", - "plt.xlabel('Time (s)')\n", - "plt.ylabel('Curvature (1/m)')\n", - "plt.title('Curvature Prediction vs Target')\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(\n", + " sampling * np.linspace(0, len(curv_targ), len(curv_targ)),\n", + " curv_targ,\n", + " label=\"Target curvature\",\n", + ")\n", + "plt.plot(\n", + " sampling * np.linspace(0, len(curv_out), len(curv_out)),\n", + " curv_out,\n", + " \"--\",\n", + " label=\"Predicted curvature\",\n", + ")\n", + "plt.xlabel(\"Time (s)\")\n", + "plt.ylabel(\"Curvature (1/m)\")\n", + "plt.title(\"Curvature Prediction vs Target\")\n", "plt.legend()\n", "plt.grid()\n", "plt.show()" @@ -922,19 +956,25 @@ ], "source": [ "sampling = 0.05\n", - "W_fir = torch.tensor([[np.exp(-(i/(samples_past_steer/2))**2)] for i in range(-samples_past_steer+1,1)],dtype=torch.float32).squeeze(-1)\n", + "W_fir = torch.tensor(\n", + " [\n", + " [np.exp(-((i / (samples_past_steer / 2)) ** 2))]\n", + " for i in range(-samples_past_steer + 1, 1)\n", + " ],\n", + " dtype=torch.float32,\n", + ").squeeze(-1)\n", "\n", "for name, param in model.named_parameters():\n", - " if name.startswith('fir_layer'):\n", + " if name.startswith(\"fir_layer\"):\n", " fir_param = param\n", "\n", "plt.figure()\n", "\n", - "for i in range(fir_param[:,0,0].detach().numpy().size):\n", - " weight_loc = fir_param[i,0,:]*W_fir\n", + "for i in range(fir_param[:, 0, 0].detach().numpy().size):\n", + " weight_loc = fir_param[i, 0, :] * W_fir\n", " weight_loc = weight_loc.detach().numpy()\n", - " time = np.linspace(0,sampling*(len(weight_loc)-1),len(weight_loc))\n", - " plt.plot(time, np.flip(weight_loc),'o',label=f\"Fir_{i}\")\n", + " time = np.linspace(0, sampling * (len(weight_loc) - 1), len(weight_loc))\n", + " plt.plot(time, np.flip(weight_loc), \"o\", label=f\"Fir_{i}\")\n", "plt.legend()\n", "plt.grid(True)\n", "plt.show()" diff --git a/case-studies/mass_spring_damper/comparison/mass_spring_damper_nnodely.ipynb b/case-studies/mass_spring_damper/comparison/mass_spring_damper_nnodely.ipynb index 19e7df06..c1106b78 100644 --- a/case-studies/mass_spring_damper/comparison/mass_spring_damper_nnodely.ipynb +++ b/case-studies/mass_spring_damper/comparison/mass_spring_damper_nnodely.ipynb @@ -103,22 +103,25 @@ "T_x = 0.1\n", "\n", "# Define the neural model\n", - "x = Input('x') # MSNN input (Mass position)\n", - "F = Input('F') # MSNN input (Force)\n", - "x_free = Fir(W_init = 'init_negexp', W_init_params = {'first_value':0.1,'size_index':0,'lambda':3})(x.tw(T_x))\n", + "x = Input(\"x\") # MSNN input (Mass position)\n", + "F = Input(\"F\") # MSNN input (Force)\n", + "x_free = Fir(\n", + " W_init=\"init_negexp\",\n", + " W_init_params={\"first_value\": 0.1, \"size_index\": 0, \"lambda\": 3},\n", + ")(x.tw(T_x))\n", "x_force = Fir(F.tw(T_x))\n", - "x_n = Output('x_n', x_free + x_force)\n", + "x_n = Output(\"x_n\", x_free + x_force)\n", "\n", "# Add the neural models to the nnodely structure\n", - "msd = Modely(seed=42, workspace='saved')\n", - "msd.addModel('neural_msd', x_n)\n", + "msd = Modely(seed=42, workspace=\"saved\")\n", + "msd.addModel(\"neural_msd\", x_n)\n", "\n", "# These functions are used to impose the minimization objectives.\n", "# Here it is minimized the error between the future position of x get from the dataset\n", "# and the estimator designed using the neural network.\n", "# The minimization is imposed via MSE error.\n", - "x_t = Input('x_t') # Real position\n", - "msd.addMinimize('x[t]', x_t.next(), x_n)\n", + "x_t = Input(\"x_t\") # Real position\n", + "msd.addMinimize(\"x[t]\", x_t.next(), x_n)\n", "\n", "# Nauralize the model and getting the neural network.\n", "# The sampling time depends on the datasets.\n", @@ -277,20 +280,22 @@ } ], "source": [ - "data_struct = ['time', ('x','x_t'), '', 'F']\n", - "msd.loadData(name = 'simulations',\n", - " source = '../msd-data/data',\n", - " format = data_struct, delimiter = ';')\n", + "data_struct = [\"time\", (\"x\", \"x_t\"), \"\", \"F\"]\n", + "msd.loadData(\n", + " name=\"simulations\", source=\"../msd-data/data\", format=data_struct, delimiter=\";\"\n", + ")\n", "\n", "# Neural network train\n", - "param_model = {'num_of_epochs' : 80,\n", - " 'train_batch_size' : 128,\n", - " 'lr' : 0.0005,\n", - " 'splits' : [70,20,10]}\n", - "msd.trainModel(training_params = param_model)\n", + "param_model = {\n", + " \"num_of_epochs\": 80,\n", + " \"train_batch_size\": 128,\n", + " \"lr\": 0.0005,\n", + " \"splits\": [70, 20, 10],\n", + "}\n", + "msd.trainModel(training_params=param_model)\n", "\n", "# Save the neural model\n", - "msd.exportPythonModel(name = 'msd_preliminary')" + "msd.exportPythonModel(name=\"msd_preliminary\")" ] }, { @@ -322,13 +327,15 @@ ], "source": [ "# Show the network performance on the test dataset\n", - "samples = msd.getSamples(dataset='simulations', window=2000-10, index=50*2000-450)\n", - "result = msd(samples, sampled=True, prediction_samples=2000-10, closed_loop={'x':'x_n'})\n", + "samples = msd.getSamples(dataset=\"simulations\", window=2000 - 10, index=50 * 2000 - 450)\n", + "result = msd(\n", + " samples, sampled=True, prediction_samples=2000 - 10, closed_loop={\"x\": \"x_n\"}\n", + ")\n", "\n", - "plt.figure(figsize=(10,5))\n", - "t = np.arange(len(result['x_n'])) * 0.01\n", - "plt.plot(t, result['x_n'], label=\"pred\", linewidth=2)\n", - "plt.plot(t, np.array(samples['x_t'])[:,0,0], '--', label=\"target\", linewidth=2)\n", + "plt.figure(figsize=(10, 5))\n", + "t = np.arange(len(result[\"x_n\"])) * 0.01\n", + "plt.plot(t, result[\"x_n\"], label=\"pred\", linewidth=2)\n", + "plt.plot(t, np.array(samples[\"x_t\"])[:, 0, 0], \"--\", label=\"target\", linewidth=2)\n", "plt.legend()\n", "plt.grid()\n", "plt.title(\"Model Rollout vs Target\")\n", @@ -412,10 +419,17 @@ ], "source": [ "# Refine weights with recurrent train\n", - "msd.trainModel(num_of_epochs = 10, prediction_samples = 1500, step = 500, lr=0.00001, closed_loop={'x':'x_n'}, training_params = param_model)\n", + "msd.trainModel(\n", + " num_of_epochs=10,\n", + " prediction_samples=1500,\n", + " step=500,\n", + " lr=0.00001,\n", + " closed_loop={\"x\": \"x_n\"},\n", + " training_params=param_model,\n", + ")\n", "\n", "# Save the neural model in json format\n", - "msd.saveModel(name = 'msd_final')" + "msd.saveModel(name=\"msd_final\")" ] }, { @@ -437,13 +451,15 @@ ], "source": [ "# Show the network performance on the test dataset after recurrent training\n", - "samples = msd.getSamples(dataset='simulations', window=2000-10, index=50*2000-450)\n", - "result = msd(samples, sampled=True, prediction_samples=2000-10, closed_loop={'x':'x_n'})\n", + "samples = msd.getSamples(dataset=\"simulations\", window=2000 - 10, index=50 * 2000 - 450)\n", + "result = msd(\n", + " samples, sampled=True, prediction_samples=2000 - 10, closed_loop={\"x\": \"x_n\"}\n", + ")\n", "\n", - "plt.figure(figsize=(10,5))\n", - "t = np.arange(len(result['x_n'])) * 0.01\n", - "plt.plot(t, result['x_n'], label=\"pred\", linewidth=2)\n", - "plt.plot(t, np.array(samples['x_t'])[:,0,0], '--', label=\"target\", linewidth=2)\n", + "plt.figure(figsize=(10, 5))\n", + "t = np.arange(len(result[\"x_n\"])) * 0.01\n", + "plt.plot(t, result[\"x_n\"], label=\"pred\", linewidth=2)\n", + "plt.plot(t, np.array(samples[\"x_t\"])[:, 0, 0], \"--\", label=\"target\", linewidth=2)\n", "plt.legend()\n", "plt.grid()\n", "plt.title(\"Model Rollout vs Target\")\n", @@ -587,14 +603,14 @@ } ], "source": [ - "x_m = Input('x_m') # measured position\n", - "kp = Parameter('P', values=0.5)\n", - "ki = Parameter('I', values=0.5)\n", - "kd = Parameter('D', values=0.5)\n", - "e = x_t.next()-x_m.next()\n", - "c = e*kp+Integrate(e)*ki+Differentiate(e)*kd\n", - "controlForce = Output('F_PID', c)\n", - "msd.addModel('PID',controlForce)\n", + "x_m = Input(\"x_m\") # measured position\n", + "kp = Parameter(\"P\", values=0.5)\n", + "ki = Parameter(\"I\", values=0.5)\n", + "kd = Parameter(\"D\", values=0.5)\n", + "e = x_t.next() - x_m.next()\n", + "c = e * kp + Integrate(e) * ki + Differentiate(e) * kd\n", + "controlForce = Output(\"F_PID\", c)\n", + "msd.addModel(\"PID\", controlForce)\n", "\n", "# Neuralization of the whole models\n", "msd.neuralizeModel()" @@ -679,16 +695,21 @@ ], "source": [ "# Train the PID controller\n", - "msd.trainModel(models = 'PID',\n", - " closed_loop = {'x' : 'x_n', 'x_m' : 'x_n'},\n", - " connect = {'F' : 'F_PID'},\n", - " prediction_samples = 500,\n", - " step = 500, num_of_epochs = 20,\n", - " lr = 0.05,\n", - " training_params = param_model)\n", + "msd.trainModel(\n", + " models=\"PID\",\n", + " closed_loop={\"x\": \"x_n\", \"x_m\": \"x_n\"},\n", + " connect={\"F\": \"F_PID\"},\n", + " prediction_samples=500,\n", + " step=500,\n", + " num_of_epochs=20,\n", + " lr=0.05,\n", + " training_params=param_model,\n", + ")\n", "\n", "# Print the parameter of the PID\n", - "print(f\"The PID controller kp = {msd.parameters['P']} ki = {msd.parameters['I']} kd = {msd.parameters['D']}\")" + "print(\n", + " f\"The PID controller kp = {msd.parameters['P']} ki = {msd.parameters['I']} kd = {msd.parameters['D']}\"\n", + ")" ] }, { @@ -698,7 +719,7 @@ "metadata": {}, "outputs": [], "source": [ - "msd.exportPythonModel(name = 'msd_final_with_PID')" + "msd.exportPythonModel(name=\"msd_final_with_PID\")" ] }, { @@ -741,16 +762,20 @@ ], "source": [ "# Test the controller on step and triangular signal\n", - "tt = np.linspace(0, 5, int(5/0.01), endpoint=False)\n", - "data_target = np.concat([np.ones(511,dtype=np.float32)*1.0, # Step\n", - " -2*np.ones(500,dtype=np.float32)*1.0,\n", - " 2 * np.abs( 2 * (tt*1/5 - np.floor(tt*1/5 + 0.5)) ) - 1,\n", - " 2 * np.abs( 2 * (tt*1/2.5 - np.floor(tt*1/2.5 + 0.5)) ) - 1])\n", - "msd.loadData('test_control', {'x_t': data_target})\n", + "tt = np.linspace(0, 5, int(5 / 0.01), endpoint=False)\n", + "data_target = np.concat(\n", + " [\n", + " np.ones(511, dtype=np.float32) * 1.0, # Step\n", + " -2 * np.ones(500, dtype=np.float32) * 1.0,\n", + " 2 * np.abs(2 * (tt * 1 / 5 - np.floor(tt * 1 / 5 + 0.5))) - 1,\n", + " 2 * np.abs(2 * (tt * 1 / 2.5 - np.floor(tt * 1 / 2.5 + 0.5))) - 1,\n", + " ]\n", + ")\n", + "msd.loadData(\"test_control\", {\"x_t\": data_target})\n", "\n", "vis = MPLNotebookVisualizer()\n", "vis.setModely(msd)\n", - "vis.showResult('test_control')\n" + "vis.showResult(\"test_control\")" ] } ], diff --git a/case-studies/mass_spring_damper/comparison/mass_spring_damper_torch.ipynb b/case-studies/mass_spring_damper/comparison/mass_spring_damper_torch.ipynb index 62616256..50482538 100644 --- a/case-studies/mass_spring_damper/comparison/mass_spring_damper_torch.ipynb +++ b/case-studies/mass_spring_damper/comparison/mass_spring_damper_torch.ipynb @@ -54,11 +54,11 @@ "\n", " if init_negexp:\n", " t = torch.arange(window_size).float()\n", - " w = torch.exp(-3*t)\n", + " w = torch.exp(-3 * t)\n", " w = 0.1 * w / w.sum()\n", " self.weight.data[:] = w.flip(0)\n", " else:\n", - " self.weight.data.uniform_(.0, 1.0)\n", + " self.weight.data.uniform_(0.0, 1.0)\n", "\n", " def forward(self, x):\n", " # x: (B, T)\n", @@ -82,7 +82,7 @@ "\n", " def step(self, x, u):\n", " return self.x_free(x) + self.x_force(u)\n", - " \n", + "\n", " def forward(self, x, u):\n", " return self.step(x, u)\n", "\n", @@ -90,9 +90,9 @@ " preds = []\n", "\n", " for k in range(horizon):\n", - " u_k = u_seq[:, k:k+self.window_dim]\n", + " u_k = u_seq[:, k : k + self.window_dim]\n", "\n", - " x_next = self.step(x, u_k) # (B,1)\n", + " x_next = self.step(x, u_k) # (B,1)\n", "\n", " preds.append(x_next.squeeze(1))\n", "\n", @@ -120,23 +120,25 @@ "outputs": [], "source": [ "def load_simulation_file(path):\n", - " data = np.loadtxt(path, delimiter=';')\n", + " data = np.loadtxt(path, delimiter=\";\")\n", "\n", - " time = data[:,0]\n", - " x = data[:,1]\n", - " v = data[:,2]\n", - " u = data[:,3]\n", + " time = data[:, 0]\n", + " x = data[:, 1]\n", + " v = data[:, 2]\n", + " u = data[:, 3]\n", "\n", " return x, v, u\n", "\n", + "\n", "from torch.utils.data import Dataset\n", "from torch.utils.data import DataLoader\n", "from torch.utils.data import random_split\n", "\n", + "\n", "class MSDSimDataset(Dataset):\n", " def __init__(self, folder, window_dim, horizon=1, stride=1):\n", " self.window_dim = window_dim\n", - " self.data = [] # file list\n", + " self.data = [] # file list\n", " self.index_map = [] # global window map\n", " self.horizon = horizon\n", " self.stride = stride\n", @@ -147,9 +149,9 @@ " for f in files:\n", " x, v, u = load_simulation_file(f)\n", "\n", - " x = torch.tensor(x, dtype=torch.float32)\n", + " x = torch.tensor(x, dtype=torch.float32)\n", " v = torch.tensor(v, dtype=torch.float32)\n", - " u = torch.tensor(u, dtype=torch.float32)\n", + " u = torch.tensor(u, dtype=torch.float32)\n", "\n", " self.data.append((x, v, u))\n", "\n", @@ -174,23 +176,24 @@ " return (\n", " x[start : start + W],\n", " x[start + W : start + W + H],\n", - " u[start : start + W + H - 1]\n", + " u[start : start + W + H - 1],\n", " )\n", "\n", + "\n", "WINDOW_DIM = 10\n", "HORIZON = 1\n", "\n", "dataset = MSDSimDataset(\"../msd-data/data\", window_dim=WINDOW_DIM, horizon=HORIZON)\n", "n = len(dataset)\n", - "n_train = int(0.7*n)\n", - "n_val = int(0.2*n)\n", - "n_test = n - n_train - n_val\n", + "n_train = int(0.7 * n)\n", + "n_val = int(0.2 * n)\n", + "n_test = n - n_train - n_val\n", "\n", - "train_ds, val_ds, test_ds = random_split(dataset, [n_train,n_val,n_test])\n", + "train_ds, val_ds, test_ds = random_split(dataset, [n_train, n_val, n_test])\n", "\n", "train_loader = DataLoader(train_ds, batch_size=128, shuffle=True)\n", - "val_loader = DataLoader(val_ds, batch_size=128, shuffle=False)\n", - "test_loader = DataLoader(test_ds, batch_size=128, shuffle=False)" + "val_loader = DataLoader(val_ds, batch_size=128, shuffle=False)\n", + "test_loader = DataLoader(test_ds, batch_size=128, shuffle=False)" ] }, { @@ -222,7 +225,7 @@ "opt = torch.optim.Adam(model.parameters(), lr=5e-4)\n", "loss_fn = nn.MSELoss()\n", "\n", - "best_val_loss = float('inf')\n", + "best_val_loss = float(\"inf\")\n", "\n", "train_losses = []\n", "val_losses = []\n", @@ -258,7 +261,9 @@ " best_val_loss = val_loss\n", " torch.save(model.state_dict(), \"saved/best_model.pth\")\n", " val_losses.append(val_loss)\n", - " pbar.set_description(f\"Epoch {epoch+1} | train loss: {total_loss/len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\")" + " pbar.set_description(\n", + " f\"Epoch {epoch + 1} | train loss: {total_loss / len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\"\n", + " )" ] }, { @@ -294,13 +299,15 @@ "best_model = NeuralMSD(window_dim=WINDOW_DIM)\n", "best_model.load_state_dict(torch.load(\"saved/best_model.pth\"))\n", "\n", - "preds = best_model.rollout(x[:WINDOW_DIM].unsqueeze(0), u.unsqueeze(0), horizon=len(x)-WINDOW_DIM).squeeze(0)\n", + "preds = best_model.rollout(\n", + " x[:WINDOW_DIM].unsqueeze(0), u.unsqueeze(0), horizon=len(x) - WINDOW_DIM\n", + ").squeeze(0)\n", "\n", "target = x[WINDOW_DIM:]\n", "t = np.arange(len(preds)) * 0.01\n", - "plt.figure(figsize=(12,6))\n", + "plt.figure(figsize=(12, 6))\n", "plt.plot(t, preds.detach().numpy(), label=\"pred\", linewidth=2)\n", - "plt.plot(t, target.numpy(), '--', label=\"target\", linewidth=2)\n", + "plt.plot(t, target.numpy(), \"--\", label=\"target\", linewidth=2)\n", "plt.legend()\n", "plt.grid()\n", "plt.title(\"Model Rollout vs Target\")\n", @@ -331,17 +338,19 @@ "# Recurrent dataset\n", "HORIZON = 1500\n", "\n", - "dataset = MSDSimDataset(\"../msd-data/data\", window_dim=WINDOW_DIM, horizon=HORIZON, stride=5)\n", + "dataset = MSDSimDataset(\n", + " \"../msd-data/data\", window_dim=WINDOW_DIM, horizon=HORIZON, stride=5\n", + ")\n", "n = len(dataset)\n", - "n_train = int(0.7*n)\n", - "n_val = int(0.2*n)\n", - "n_test = n - n_train - n_val\n", + "n_train = int(0.7 * n)\n", + "n_val = int(0.2 * n)\n", + "n_test = n - n_train - n_val\n", "\n", - "train_ds, val_ds, test_ds = random_split(dataset, [n_train,n_val,n_test])\n", + "train_ds, val_ds, test_ds = random_split(dataset, [n_train, n_val, n_test])\n", "\n", "train_loader = DataLoader(train_ds, batch_size=128, shuffle=True)\n", - "val_loader = DataLoader(val_ds, batch_size=128, shuffle=False)\n", - "test_loader = DataLoader(test_ds, batch_size=128, shuffle=False)" + "val_loader = DataLoader(val_ds, batch_size=128, shuffle=False)\n", + "test_loader = DataLoader(test_ds, batch_size=128, shuffle=False)" ] }, { @@ -364,7 +373,7 @@ "opt = torch.optim.Adam(model.parameters(), lr=1e-5)\n", "loss_fn = nn.MSELoss()\n", "\n", - "best_val_loss = float('inf')\n", + "best_val_loss = float(\"inf\")\n", "\n", "train_losses = []\n", "val_losses = []\n", @@ -400,7 +409,9 @@ " best_val_loss = val_loss\n", " torch.save(model.state_dict(), \"saved/best_model.pth\")\n", " val_losses.append(val_loss)\n", - " pbar.set_description(f\"Epoch {epoch+1} | train loss: {total_loss/len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\")" + " pbar.set_description(\n", + " f\"Epoch {epoch + 1} | train loss: {total_loss / len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\"\n", + " )" ] }, { @@ -427,13 +438,15 @@ "best_model = NeuralMSD(window_dim=WINDOW_DIM)\n", "best_model.load_state_dict(torch.load(\"saved/best_model.pth\"))\n", "\n", - "preds = best_model.rollout(x[:WINDOW_DIM].unsqueeze(0), u.unsqueeze(0), horizon=len(x)-WINDOW_DIM).squeeze(0)\n", + "preds = best_model.rollout(\n", + " x[:WINDOW_DIM].unsqueeze(0), u.unsqueeze(0), horizon=len(x) - WINDOW_DIM\n", + ").squeeze(0)\n", "\n", "target = x[WINDOW_DIM:]\n", "t = np.arange(len(preds)) * 0.01\n", - "plt.figure(figsize=(12,6))\n", + "plt.figure(figsize=(12, 6))\n", "plt.plot(t, preds.detach().numpy(), label=\"pred\", linewidth=2)\n", - "plt.plot(t, target.numpy(), '--', label=\"target\", linewidth=2)\n", + "plt.plot(t, target.numpy(), \"--\", label=\"target\", linewidth=2)\n", "plt.legend()\n", "plt.grid()\n", "plt.title(\"Model Rollout vs Target\")\n", @@ -476,7 +489,7 @@ " def reset_state(self, batch_size, device=None):\n", " device = device or self.kp.device\n", " self.integ_state = torch.zeros((batch_size, 1), device=device)\n", - " self.prev_error = torch.zeros((batch_size, 1), device=device)\n", + " self.prev_error = torch.zeros((batch_size, 1), device=device)\n", "\n", " def forward(self, e):\n", " \"\"\"\n", @@ -492,11 +505,7 @@ "\n", " self.prev_error = e\n", "\n", - " u = (\n", - " self.kp * e +\n", - " self.ki * self.integ_state +\n", - " self.kd * deriv\n", - " )\n", + " u = self.kp * e + self.ki * self.integ_state + self.kd * deriv\n", "\n", " return u" ] @@ -521,11 +530,11 @@ " self.pid.reset_state(batch_size=x0.shape[0], device=x0.device)\n", "\n", " for k in range(target.shape[1]):\n", - " e = target[:,k] - x[:, -1]\n", + " e = target[:, k] - x[:, -1]\n", " # shift control sequence and append new control\n", " u_seq = torch.cat([u_seq[:, 1:], self.pid(e.unsqueeze(1))], dim=1)\n", " x_next = self.plant.step(x, u_seq)\n", - " \n", + "\n", " # shift state sequence and append new state\n", " x = torch.cat([x[:, 1:], x_next], dim=1)\n", " xs.append(x_next.squeeze(1))\n", @@ -553,17 +562,19 @@ "# PID dataset\n", "HORIZON = 500\n", "\n", - "dataset = MSDSimDataset(\"../msd-data/data\", window_dim=WINDOW_DIM, horizon=HORIZON, stride=5)\n", + "dataset = MSDSimDataset(\n", + " \"../msd-data/data\", window_dim=WINDOW_DIM, horizon=HORIZON, stride=5\n", + ")\n", "n = len(dataset)\n", - "n_train = int(0.7*n)\n", - "n_val = int(0.2*n)\n", - "n_test = n - n_train - n_val\n", + "n_train = int(0.7 * n)\n", + "n_val = int(0.2 * n)\n", + "n_test = n - n_train - n_val\n", "\n", - "train_ds, val_ds, test_ds = random_split(dataset, [n_train,n_val,n_test])\n", + "train_ds, val_ds, test_ds = random_split(dataset, [n_train, n_val, n_test])\n", "\n", "train_loader = DataLoader(train_ds, batch_size=128, shuffle=True)\n", - "val_loader = DataLoader(val_ds, batch_size=2048, shuffle=False)\n", - "test_loader = DataLoader(test_ds, batch_size=2048, shuffle=False)" + "val_loader = DataLoader(val_ds, batch_size=2048, shuffle=False)\n", + "test_loader = DataLoader(test_ds, batch_size=2048, shuffle=False)" ] }, { @@ -589,7 +600,7 @@ "opt = torch.optim.Adam(pid.parameters(), lr=0.05)\n", "loss_fn = nn.MSELoss()\n", "\n", - "best_val_loss = float('inf')\n", + "best_val_loss = float(\"inf\")\n", "\n", "train_losses = []\n", "val_losses = []\n", @@ -625,7 +636,9 @@ " best_val_loss = val_loss\n", " torch.save(pid.state_dict(), \"saved/best_controller.pth\")\n", " val_losses.append(val_loss)\n", - " pbar.set_description(f\"Epoch {epoch+1} | train loss: {total_loss/len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\")" + " pbar.set_description(\n", + " f\"Epoch {epoch + 1} | train loss: {total_loss / len(train_loader):.3e} | val_loss: {val_loss:.3e} | best_val_loss: {best_val_loss:.3e}\"\n", + " )" ] }, { @@ -644,7 +657,9 @@ ], "source": [ "# Print the parameter of the PID\n", - "print(f\"Trained PID parameters: kp={pid.kp.item():.3f}, ki={pid.ki.item():.3f}, kd={pid.kd.item():.3f}\")" + "print(\n", + " f\"Trained PID parameters: kp={pid.kp.item():.3f}, ki={pid.ki.item():.3f}, kd={pid.kd.item():.3f}\"\n", + ")" ] }, { @@ -668,13 +683,20 @@ "best_pid.load_state_dict(torch.load(\"saved/best_controller.pth\"))\n", "best_system = ControlledSystem(best_model, best_pid)\n", "\n", - "tt = torch.linspace(0, 5, int(5/0.01))\n", - "data_target = torch.cat([torch.ones(511,dtype=torch.float32)*1.0, # Step\n", - " -2*torch.ones(500,dtype=torch.float32)*1.0,\n", - " 2 * torch.abs( 2 * (tt*1/5 - torch.floor(tt*1/5 + 0.5)) ) - 1, # Triangle\n", - " 2 * torch.abs( 2 * (tt*1/2.5 - torch.floor(tt*1/2.5 + 0.5)) ) - 1])\n", + "tt = torch.linspace(0, 5, int(5 / 0.01))\n", + "data_target = torch.cat(\n", + " [\n", + " torch.ones(511, dtype=torch.float32) * 1.0, # Step\n", + " -2 * torch.ones(500, dtype=torch.float32) * 1.0,\n", + " 2 * torch.abs(2 * (tt * 1 / 5 - torch.floor(tt * 1 / 5 + 0.5))) - 1, # Triangle\n", + " 2 * torch.abs(2 * (tt * 1 / 2.5 - torch.floor(tt * 1 / 2.5 + 0.5))) - 1,\n", + " ]\n", + ")\n", "best_system.eval()\n", - "preds = best_system(torch.zeros_like(data_target[1:WINDOW_DIM+1].unsqueeze(0)), data_target[WINDOW_DIM+1:].unsqueeze(0))" + "preds = best_system(\n", + " torch.zeros_like(data_target[1 : WINDOW_DIM + 1].unsqueeze(0)),\n", + " data_target[WINDOW_DIM + 1 :].unsqueeze(0),\n", + ")" ] }, { @@ -697,18 +719,39 @@ "source": [ "df = pd.read_csv(\"PID_test_nnodely.csv\")\n", "\n", - "plt.figure(figsize=(12,6))\n", + "plt.figure(figsize=(12, 6))\n", "t = torch.arange(len(preds.squeeze(0).detach().numpy())) * 0.01\n", - "plt.plot(t.numpy(), data_target[WINDOW_DIM+1:].numpy(), '-', label=\"Target\", linewidth=1, color='black')\n", - "plt.plot(t.numpy(), df['estimate'].to_numpy(), '--', label=\"nnodely PID\", linewidth=3, color='tab:blue')\n", - "plt.plot(t.numpy(), preds.squeeze(0).detach().numpy(), '-.', label=\"PyTorch PID\", linewidth=3, color='tab:orange')\n", + "plt.plot(\n", + " t.numpy(),\n", + " data_target[WINDOW_DIM + 1 :].numpy(),\n", + " \"-\",\n", + " label=\"Target\",\n", + " linewidth=1,\n", + " color=\"black\",\n", + ")\n", + "plt.plot(\n", + " t.numpy(),\n", + " df[\"estimate\"].to_numpy(),\n", + " \"--\",\n", + " label=\"nnodely PID\",\n", + " linewidth=3,\n", + " color=\"tab:blue\",\n", + ")\n", + "plt.plot(\n", + " t.numpy(),\n", + " preds.squeeze(0).detach().numpy(),\n", + " \"-.\",\n", + " label=\"PyTorch PID\",\n", + " linewidth=3,\n", + " color=\"tab:orange\",\n", + ")\n", "plt.xlim(0, 20)\n", "plt.ylim(-3.5, 1.5)\n", "plt.grid()\n", "plt.title(\"PID Controller Performance Comparison\")\n", "plt.xlabel(\"Time [s]\")\n", "plt.ylabel(\"Position [m]\")\n", - "plt.legend(loc='lower right', fontsize=24)\n", + "plt.legend(loc=\"lower right\", fontsize=24)\n", "plt.show()" ] } diff --git a/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.json b/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.json index 8a4622e2..46ab942d 100644 --- a/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.json +++ b/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.json @@ -111,4 +111,4 @@ "Sub13": ["Sub", ["SamplePart10", "SamplePart12"]], "Sub29": ["Sub", ["SamplePart26", "SamplePart28"]], "TimePart1": ["TimePart", ["x"], -1, [-0.1, 0]], - "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} \ No newline at end of file + "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} diff --git a/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.py b/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.py index 1d916b74..1704b63d 100644 --- a/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.py +++ b/case-studies/mass_spring_damper/comparison/saved/msd_final_with_PID.py @@ -1,107 +1,241 @@ import torch + def nnodely_basic_model_update_state(data_in, rel): data_out = data_in.clone() max_dim = min(rel.size(1), data_in.size(1)) data_out[:, -max_dim:, :] = rel[:, -max_dim:, :] return data_out + def nnodely_basic_model_timeshift(data_in): return torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1) + class TracerModel(torch.nn.Module): def __init__(self): super().__init__() self.all_parameters = {} self.all_constants = {} - self.all_constants["SampleTime"] = torch.tensor(0.009999999776482582, requires_grad=False) - self.all_parameters["D"] = torch.nn.Parameter(torch.tensor([8.177507400512695]), requires_grad=True) - self.all_parameters["I"] = torch.nn.Parameter(torch.tensor([18.563440322875977]), requires_grad=True) - self.all_parameters["P"] = torch.nn.Parameter(torch.tensor([16.827768325805664]), requires_grad=True) - self.all_parameters["PFir3W"] = torch.nn.Parameter(torch.tensor([[-0.18469615280628204], [-0.12608873844146729], [-0.06660982221364975], [-0.005940185859799385], [0.05625353008508682], [0.1205686405301094], [0.18780383467674255], [0.2590898871421814], [0.3359234631061554], [0.4205183684825897]]), requires_grad=True) - self.all_parameters["PFir5W"] = torch.nn.Parameter(torch.tensor([[-1.662617978581693e-05], [4.8189936933340505e-05], [7.177559018600732e-05], [5.9527203120524064e-05], [0.00011585278843995184], [0.00019496057939250022], [0.00014330405974760652], [0.00018421869026497006], [0.00017740165640134364], [8.003542461665347e-05]]), requires_grad=True) + self.all_constants["SampleTime"] = torch.tensor( + 0.009999999776482582, requires_grad=False + ) + self.all_parameters["D"] = torch.nn.Parameter( + torch.tensor([8.177507400512695]), requires_grad=True + ) + self.all_parameters["I"] = torch.nn.Parameter( + torch.tensor([18.563440322875977]), requires_grad=True + ) + self.all_parameters["P"] = torch.nn.Parameter( + torch.tensor([16.827768325805664]), requires_grad=True + ) + self.all_parameters["PFir3W"] = torch.nn.Parameter( + torch.tensor( + [ + [-0.18469615280628204], + [-0.12608873844146729], + [-0.06660982221364975], + [-0.005940185859799385], + [0.05625353008508682], + [0.1205686405301094], + [0.18780383467674255], + [0.2590898871421814], + [0.3359234631061554], + [0.4205183684825897], + ] + ), + requires_grad=True, + ) + self.all_parameters["PFir5W"] = torch.nn.Parameter( + torch.tensor( + [ + [-1.662617978581693e-05], + [4.8189936933340505e-05], + [7.177559018600732e-05], + [5.9527203120524064e-05], + [0.00011585278843995184], + [0.00019496057939250022], + [0.00014330405974760652], + [0.00018421869026497006], + [0.00017740165640134364], + [8.003542461665347e-05], + ] + ), + requires_grad=True, + ) self.all_constants["SamplePart10"] = torch.tensor([[1.0]], requires_grad=True) self.all_constants["SamplePart12"] = torch.tensor([[1.0]], requires_grad=True) self.all_constants["SamplePart17"] = torch.tensor([[1.0]], requires_grad=True) - self.all_constants["SamplePart26"] = torch.tensor([[0.0, 1.0]], requires_grad=True) - self.all_constants["SamplePart28"] = torch.tensor([[1.0, 0.0]], requires_grad=True) + self.all_constants["SamplePart26"] = torch.tensor( + [[0.0, 1.0]], requires_grad=True + ) + self.all_constants["SamplePart28"] = torch.tensor( + [[1.0, 0.0]], requires_grad=True + ) self.all_constants["SamplePart8"] = torch.tensor([[1.0]], requires_grad=True) - self.all_constants["TimePart1"] = torch.tensor([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True) - self.all_constants["TimePart4"] = torch.tensor([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True) + self.all_constants["TimePart1"] = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ], + requires_grad=True, + ) + self.all_constants["TimePart4"] = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ], + requires_grad=True, + ) self.all_parameters = torch.nn.ParameterDict(self.all_parameters) self.all_constants = torch.nn.ParameterDict(self.all_constants) def update(self, closed_loop={}, connect={}, disconnect=False): pass - + def forward(self, kwargs): - getitem = kwargs['x_m'] + getitem = kwargs["x_m"] relation_forward_sample_part12_w = self.all_constants.SamplePart12 - einsum = torch.functional.einsum('bij,ki->bkj', getitem, relation_forward_sample_part12_w); getitem = relation_forward_sample_part12_w = None - getitem_1 = kwargs['x_t'] + einsum = torch.functional.einsum( + "bij,ki->bkj", getitem, relation_forward_sample_part12_w + ) + getitem = relation_forward_sample_part12_w = None + getitem_1 = kwargs["x_t"] relation_forward_sample_part10_w = self.all_constants.SamplePart10 - einsum_1 = torch.functional.einsum('bij,ki->bkj', getitem_1, relation_forward_sample_part10_w); getitem_1 = relation_forward_sample_part10_w = None - sub = einsum_1 - einsum; einsum_1 = einsum = None - getitem_2 = kwargs['Sub13_int14'] - update_state = nnodely_basic_model_update_state(getitem_2, sub); getitem_2 = None + einsum_1 = torch.functional.einsum( + "bij,ki->bkj", getitem_1, relation_forward_sample_part10_w + ) + getitem_1 = relation_forward_sample_part10_w = None + sub = einsum_1 - einsum + einsum_1 = einsum = None + getitem_2 = kwargs["Sub13_int14"] + update_state = nnodely_basic_model_update_state(getitem_2, sub) + getitem_2 = None relation_forward_sample_part28_w = self.all_constants.SamplePart28 - einsum_2 = torch.functional.einsum('bij,ki->bkj', update_state, relation_forward_sample_part28_w); relation_forward_sample_part28_w = None + einsum_2 = torch.functional.einsum( + "bij,ki->bkj", update_state, relation_forward_sample_part28_w + ) + relation_forward_sample_part28_w = None relation_forward_sample_part26_w = self.all_constants.SamplePart26 - einsum_3 = torch.functional.einsum('bij,ki->bkj', update_state, relation_forward_sample_part26_w); relation_forward_sample_part26_w = None - sub_1 = einsum_3 - einsum_2; einsum_3 = einsum_2 = None + einsum_3 = torch.functional.einsum( + "bij,ki->bkj", update_state, relation_forward_sample_part26_w + ) + relation_forward_sample_part26_w = None + sub_1 = einsum_3 - einsum_2 + einsum_3 = einsum_2 = None all_constants_sample_time = self.all_constants.SampleTime - truediv = sub_1 / all_constants_sample_time; sub_1 = None + truediv = sub_1 / all_constants_sample_time + sub_1 = None all_parameters_d = self.all_parameters.D - mul = truediv * all_parameters_d; truediv = all_parameters_d = None - mul_1 = sub * all_constants_sample_time; all_constants_sample_time = None - getitem_3 = kwargs['Sub13_int13'] + mul = truediv * all_parameters_d + truediv = all_parameters_d = None + mul_1 = sub * all_constants_sample_time + all_constants_sample_time = None + getitem_3 = kwargs["Sub13_int13"] relation_forward_sample_part17_w = self.all_constants.SamplePart17 - einsum_4 = torch.functional.einsum('bij,ki->bkj', getitem_3, relation_forward_sample_part17_w); getitem_3 = relation_forward_sample_part17_w = None - add = einsum_4 + mul_1; einsum_4 = mul_1 = None + einsum_4 = torch.functional.einsum( + "bij,ki->bkj", getitem_3, relation_forward_sample_part17_w + ) + getitem_3 = relation_forward_sample_part17_w = None + add = einsum_4 + mul_1 + einsum_4 = mul_1 = None all_parameters_i = self.all_parameters.I - mul_2 = add * all_parameters_i; all_parameters_i = None + mul_2 = add * all_parameters_i + all_parameters_i = None all_parameters_p = self.all_parameters.P - mul_3 = sub * all_parameters_p; sub = all_parameters_p = None - add_1 = mul_3 + mul_2; mul_3 = mul_2 = None - add_2 = add_1 + mul; add_1 = mul = None - getitem_4 = kwargs['F'] + mul_3 = sub * all_parameters_p + sub = all_parameters_p = None + add_1 = mul_3 + mul_2 + mul_3 = mul_2 = None + add_2 = add_1 + mul + add_1 = mul = None + getitem_4 = kwargs["F"] relation_forward_time_part4_w = self.all_constants.TimePart4 - einsum_5 = torch.functional.einsum('bij,ki->bkj', getitem_4, relation_forward_time_part4_w); getitem_4 = relation_forward_time_part4_w = None + einsum_5 = torch.functional.einsum( + "bij,ki->bkj", getitem_4, relation_forward_time_part4_w + ) + getitem_4 = relation_forward_time_part4_w = None size = einsum_5.size(0) relation_forward_fir5_weights = self.all_parameters.PFir5W size_1 = relation_forward_fir5_weights.size(1) - squeeze = einsum_5.squeeze(-1); einsum_5 = None - matmul = torch.matmul(squeeze, relation_forward_fir5_weights); squeeze = relation_forward_fir5_weights = None - to = matmul.to(dtype = torch.float32); matmul = None - view = to.view(size, 1, size_1); to = size = size_1 = None - getitem_5 = kwargs['x'] + squeeze = einsum_5.squeeze(-1) + einsum_5 = None + matmul = torch.matmul(squeeze, relation_forward_fir5_weights) + squeeze = relation_forward_fir5_weights = None + to = matmul.to(dtype=torch.float32) + matmul = None + view = to.view(size, 1, size_1) + to = size = size_1 = None + getitem_5 = kwargs["x"] relation_forward_time_part1_w = self.all_constants.TimePart1 - einsum_6 = torch.functional.einsum('bij,ki->bkj', getitem_5, relation_forward_time_part1_w); getitem_5 = relation_forward_time_part1_w = None + einsum_6 = torch.functional.einsum( + "bij,ki->bkj", getitem_5, relation_forward_time_part1_w + ) + getitem_5 = relation_forward_time_part1_w = None size_2 = einsum_6.size(0) relation_forward_fir2_weights = self.all_parameters.PFir3W size_3 = relation_forward_fir2_weights.size(1) - squeeze_1 = einsum_6.squeeze(-1); einsum_6 = None - matmul_1 = torch.matmul(squeeze_1, relation_forward_fir2_weights); squeeze_1 = relation_forward_fir2_weights = None - to_1 = matmul_1.to(dtype = torch.float32); matmul_1 = None - view_1 = to_1.view(size_2, 1, size_3); to_1 = size_2 = size_3 = None - add_3 = view_1 + view; view_1 = view = None - getitem_6 = kwargs['x_t']; kwargs = None + squeeze_1 = einsum_6.squeeze(-1) + einsum_6 = None + matmul_1 = torch.matmul(squeeze_1, relation_forward_fir2_weights) + squeeze_1 = relation_forward_fir2_weights = None + to_1 = matmul_1.to(dtype=torch.float32) + matmul_1 = None + view_1 = to_1.view(size_2, 1, size_3) + to_1 = size_2 = size_3 = None + add_3 = view_1 + view + view_1 = view = None + getitem_6 = kwargs["x_t"] + kwargs = None relation_forward_sample_part8_w = self.all_constants.SamplePart8 - einsum_7 = torch.functional.einsum('bij,ki->bkj', getitem_6, relation_forward_sample_part8_w); getitem_6 = relation_forward_sample_part8_w = None - return ({'F_PID': add_2, 'x_n': add_3}, {'SamplePart8': einsum_7, 'Add6': add_3}, {'Sub13_int13': add}, {'Sub13_int14': update_state}) - + einsum_7 = torch.functional.einsum( + "bij,ki->bkj", getitem_6, relation_forward_sample_part8_w + ) + getitem_6 = relation_forward_sample_part8_w = None + return ( + {"F_PID": add_2, "x_n": add_3}, + {"SamplePart8": einsum_7, "Add6": add_3}, + {"Sub13_int13": add}, + {"Sub13_int14": update_state}, + ) + + class RecurrentModel(torch.nn.Module): def __init__(self): super().__init__() self.Cell = TracerModel() - self.inputs = ['x_m', 'x_t', 'F', 'x', ] + self.inputs = [ + "x_m", + "x_t", + "F", + "x", + ] self.states = dict() def forward(self, kwargs): n_samples = min([kwargs[key].size(0) for key in self.inputs]) - self.states['Sub13_int14'] = kwargs['Sub13_int14'] - self.states['Sub13_int13'] = kwargs['Sub13_int13'] - results = {'F_PID':[], 'x_n':[], } + self.states["Sub13_int14"] = kwargs["Sub13_int14"] + self.states["Sub13_int13"] = kwargs["Sub13_int13"] + results = { + "F_PID": [], + "x_n": [], + } X = dict() for idx in range(n_samples): for key in self.inputs: @@ -113,7 +247,9 @@ def forward(self, kwargs): results[key].append(out[key]) for key, val in closed_loop.items(): self.states[key] = nnodely_basic_model_timeshift(self.states[key]) - self.states[key] = nnodely_basic_model_update_state(self.states[key], val) + self.states[key] = nnodely_basic_model_update_state( + self.states[key], val + ) for key, val in connect.items(): self.states[key] = nnodely_basic_model_timeshift(val) return results diff --git a/case-studies/mass_spring_damper/mass_spring_damper.py b/case-studies/mass_spring_damper/mass_spring_damper.py index 60122de7..7261091d 100644 --- a/case-studies/mass_spring_damper/mass_spring_damper.py +++ b/case-studies/mass_spring_damper/mass_spring_damper.py @@ -12,94 +12,117 @@ T_x = 0.1 # Define the neural model -x = Input('x') # MSNN input (Mass position) -F = Input('F') # MSNN input (Force) -x_free = Fir(W_init = 'init_negexp', W_init_params = {'first_value':0.1,'size_index':0,'lambda':3})(x.tw(T_x)) +x = Input("x") # MSNN input (Mass position) +F = Input("F") # MSNN input (Force) +x_free = Fir( + W_init="init_negexp", + W_init_params={"first_value": 0.1, "size_index": 0, "lambda": 3}, +)(x.tw(T_x)) x_force = Fir(F.tw(T_x)) -x_n = Output('x_n', x_free + x_force) +x_n = Output("x_n", x_free + x_force) # Add the neural models to the nnodely structure -msd = Modely(seed = 42, workspace = 'saved') -msd.addModel('neural_msd', x_n) +msd = Modely(seed=42, workspace="saved") +msd.addModel("neural_msd", x_n) # These functions are used to impose the minimization objectives. # Here it is minimized the error between the future position of x get from the dataset # and the estimator designed using the neural network. # The minimization is imposed via MSE error. -x_t = Input('x_t') # Real position -msd.addMinimize('x[t]', x_t.next(), x_n) +x_t = Input("x_t") # Real position +msd.addMinimize("x[t]", x_t.next(), x_n) # Nauralize the model and getting the neural network. # The sampling time depends on the datasets. msd.neuralizeModel(0.01) # Data load carica i file CSV e costruisce automaticamente il dataset compatibile con la struttura della rete. -data_struct = ['time', ('x','x_t'), '', 'F'] -msd.loadData(name = 'simulations', - source = 'msd-data/data', - format = data_struct, delimiter = ';') +data_struct = ["time", ("x", "x_t"), "", "F"] +msd.loadData( + name="simulations", source="msd-data/data", format=data_struct, delimiter=";" +) # Neural network train -default_par = {'num_of_epochs' : 80, - 'train_batch_size' : 128, - 'lr' : 0.0005, - 'splits' : [70,20,10]} -msd.trainModel(training_params = default_par) +default_par = { + "num_of_epochs": 80, + "train_batch_size": 128, + "lr": 0.0005, + "splits": [70, 20, 10], +} +msd.trainModel(training_params=default_par) # Save the neural model in json format -msd.saveModel(name = 'msd_preliminary') +msd.saveModel(name="msd_preliminary") # Show the network performance on the test dataset -msd.analyzeModel(splits = [70,20,10]) +msd.analyzeModel(splits=[70, 20, 10]) vis = MPLVisualizer() vis.setModely(msd) vis.showResult("simulations_test") # Refine weights with recurrent train and analyze the model showing the performance (mse, FVU, AIC). -msd.trainAndAnalyze(num_of_epochs = 10, prediction_samples = 1500, step = 500, lr=0.00001, - closed_loop={'x':'x_n'}, training_params = default_par) +msd.trainAndAnalyze( + num_of_epochs=10, + prediction_samples=1500, + step=500, + lr=0.00001, + closed_loop={"x": "x_n"}, + training_params=default_par, +) # Show the network performance on the test dataset on recurrent vis.showResult("simulations_test") # Save the neural model in json format -msd.saveModel(name = 'msd_final') +msd.saveModel(name="msd_final") # Definition of the PID controller network -x_m = Input('x_m') # measured position -kp = Parameter('P', values=0.5) -ki = Parameter('I', values=0.5) -kd = Parameter('D', values=0.5) -e = x_t.next()-x_m.next() -c = e*kp+Integrate(e)*ki+Differentiate(e)*kd -controlForce = Output('F_PID', c) -msd.addModel('PID',controlForce) +x_m = Input("x_m") # measured position +kp = Parameter("P", values=0.5) +ki = Parameter("I", values=0.5) +kd = Parameter("D", values=0.5) +e = x_t.next() - x_m.next() +c = e * kp + Integrate(e) * ki + Differentiate(e) * kd +controlForce = Output("F_PID", c) +msd.addModel("PID", controlForce) # Neuralization of the whole models msd.neuralizeModel() # Train the PID controller -msd.trainModel(models = 'PID', - closed_loop = {'x' : 'x_n','x_m' : 'x_n'}, - connect = {'F' : 'F_PID'}, - prediction_samples = 500, - step = 500, num_of_epochs = 20, - lr = 0.05, - training_params = default_par) +msd.trainModel( + models="PID", + closed_loop={"x": "x_n", "x_m": "x_n"}, + connect={"F": "F_PID"}, + prediction_samples=500, + step=500, + num_of_epochs=20, + lr=0.05, + training_params=default_par, +) # Print the parameter of the PID -print(f"The PID controller kp = {msd.parameters['P']} ki = {msd.parameters['I']} kd = {msd.parameters['D']}") +print( + f"The PID controller kp = {msd.parameters['P']} ki = {msd.parameters['I']} kd = {msd.parameters['D']}" +) # Test the controller on step and triangular signal import numpy as np -tt = np.linspace(0, 5, int(5/0.01), endpoint=False) -data_target = np.concatenate([np.ones(511,dtype=np.float32)*1.0, # Step - -2*np.ones(500,dtype=np.float32)*1.0, - 2 * np.abs( 2 * (tt*1/5 - np.floor(tt*1/5 + 0.5)) ) - 1, - 2 * np.abs( 2 * (tt*1/2.5 - np.floor(tt*1/2.5 + 0.5)) ) - 1]) -msd.loadData('test_control', {'x_t': data_target}) -msd.analyzeModel('test_control', - prediction_samples = 2000, - closed_loop = {'x' : 'x_n','x_m' : 'x_n'}, - connect = {'F' : 'F_PID'}, - batch_size = 1) -vis.showResult('test_control') \ No newline at end of file + +tt = np.linspace(0, 5, int(5 / 0.01), endpoint=False) +data_target = np.concatenate( + [ + np.ones(511, dtype=np.float32) * 1.0, # Step + -2 * np.ones(500, dtype=np.float32) * 1.0, + 2 * np.abs(2 * (tt * 1 / 5 - np.floor(tt * 1 / 5 + 0.5))) - 1, + 2 * np.abs(2 * (tt * 1 / 2.5 - np.floor(tt * 1 / 2.5 + 0.5))) - 1, + ] +) +msd.loadData("test_control", {"x_t": data_target}) +msd.analyzeModel( + "test_control", + prediction_samples=2000, + closed_loop={"x": "x_n", "x_m": "x_n"}, + connect={"F": "F_PID"}, + batch_size=1, +) +vis.showResult("test_control") diff --git a/case-studies/mass_spring_damper/msd-data/stats.txt b/case-studies/mass_spring_damper/msd-data/stats.txt index 765759d4..c13bd6c6 100644 --- a/case-studies/mass_spring_damper/msd-data/stats.txt +++ b/case-studies/mass_spring_damper/msd-data/stats.txt @@ -1 +1 @@ -{"model_attributes":["linear"],"num_simulations":100,"elapsed_time":5.742344375,"total_samples":200100,"params":{"time":20,"sampling_time":0.001,"data_sampling_time":0.01,"m":1,"k":3,"c":0.175,"a1":3,"a2":2,"d":0.5,"s":1,"x0":[0,1],"v0":[0,0.5],"force":[-3,3]}} \ No newline at end of file +{"model_attributes":["linear"],"num_simulations":100,"elapsed_time":5.742344375,"total_samples":200100,"params":{"time":20,"sampling_time":0.001,"data_sampling_time":0.01,"m":1,"k":3,"c":0.175,"a1":3,"a2":2,"d":0.5,"s":1,"x0":[0,1],"v0":[0,0.5],"force":[-3,3]}} diff --git a/case-studies/mass_spring_damper/saved/msd_final.json b/case-studies/mass_spring_damper/saved/msd_final.json index df315ad3..602f2f30 100644 --- a/case-studies/mass_spring_damper/saved/msd_final.json +++ b/case-studies/mass_spring_damper/saved/msd_final.json @@ -44,4 +44,4 @@ "Fir5": ["Fir", ["TimePart4"], "PFir5W", null, 0], "SamplePart8": ["SamplePart", ["x_t"], -1, [0, 1]], "TimePart1": ["TimePart", ["x"], -1, [-0.1, 0]], - "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} \ No newline at end of file + "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} diff --git a/case-studies/mass_spring_damper/saved/msd_preliminary.json b/case-studies/mass_spring_damper/saved/msd_preliminary.json index 9b325312..afd36bae 100644 --- a/case-studies/mass_spring_damper/saved/msd_preliminary.json +++ b/case-studies/mass_spring_damper/saved/msd_preliminary.json @@ -44,4 +44,4 @@ "Fir5": ["Fir", ["TimePart4"], "PFir5W", null, 0], "SamplePart8": ["SamplePart", ["x_t"], -1, [0, 1]], "TimePart1": ["TimePart", ["x"], -1, [-0.1, 0]], - "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} \ No newline at end of file + "TimePart4": ["TimePart", ["F"], -1, [-0.1, 0]]}} diff --git a/case-studies/neuralODE/neuralODE_msd.ipynb b/case-studies/neuralODE/neuralODE_msd.ipynb index 3743ea1b..a9ede6aa 100644 --- a/case-studies/neuralODE/neuralODE_msd.ipynb +++ b/case-studies/neuralODE/neuralODE_msd.ipynb @@ -12,6 +12,7 @@ }, { "cell_type": "code", + "execution_count": 1, "id": "67c44ae2", "metadata": { "ExecuteTime": { @@ -19,20 +20,6 @@ "start_time": "2026-02-27T15:24:10.484610Z" } }, - "source": [ - "import os\n", - "from nnodely import *\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from nnodely.support import earlystopping\n", - "from nnodely.support.odeint.adjoint import odeint_adjoint\n", - "\n", - "def init_random_range(indexes, params_size, dict_param={'min_value': 0.0, 'max_value': 1.0}):\n", - " import numpy as np\n", - " min_val = dict_param.get('min_value', 0.0)\n", - " max_val = dict_param.get('max_value', 1.0)\n", - " return np.random.uniform(low=min_val, high=max_val)" - ], "outputs": [ { "name": "stdout", @@ -42,7 +29,21 @@ ] } ], - "execution_count": 1 + "source": [ + "from nnodely import *\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def init_random_range(\n", + " indexes, params_size, dict_param={\"min_value\": 0.0, \"max_value\": 1.0}\n", + "):\n", + " import numpy as np\n", + "\n", + " min_val = dict_param.get(\"min_value\", 0.0)\n", + " max_val = dict_param.get(\"max_value\", 1.0)\n", + " return np.random.uniform(low=min_val, high=max_val)" + ] }, { "cell_type": "markdown", @@ -58,6 +59,7 @@ }, { "cell_type": "code", + "execution_count": 2, "id": "dcc7da2c", "metadata": { "ExecuteTime": { @@ -65,6 +67,7 @@ "start_time": "2026-02-27T15:24:11.102685Z" } }, + "outputs": [], "source": [ "def ode_func_torch(t, state, weight_fir):\n", " import torch\n", @@ -98,9 +101,7 @@ " out = torch.cat((state[:, 1:, :], out), dim=1)\n", "\n", " return out" - ], - "outputs": [], - "execution_count": 2 + ] }, { "cell_type": "markdown", @@ -117,6 +118,7 @@ }, { "cell_type": "code", + "execution_count": 3, "id": "616f6513", "metadata": { "ExecuteTime": { @@ -124,38 +126,14 @@ "start_time": "2026-02-27T15:24:11.275795Z" } }, - "source": [ - "model_name = 'neuralODE_msd'\n", - "msd = Modely(seed=42, workspace='saved')\n", - "\n", - "x = Input('x') # MSNN input (Mass position)\n", - "F = Input('F') # MSNN input (Force)\n", - "T_x = 0.1\n", - "init_value = 0.1\n", - "weight_fir = Parameter('weight_fir', dimensions=(2, 1, 10), init=init_random_range, init_params={'min_value': -init_value, 'max_value': init_value})\n", - "paramFun = ParamFun(ode_func_torch)\n", - "neuOde = NeuralODE(func=paramFun, dt=0.01, rtol=1e-7, atol=1e-9, method='dopri5')\n", - "state = Concatenate(x.tw(T_x), F.tw(T_x))\n", - "ans = neuOde(state, weight_fir)\n", - "x_est = TimePart(Select(ans, 0), 0.09, 0.1)\n", - "x_est.closedLoop(x)\n", - "\n", - "# Output and loss\n", - "x_n = Output('x_n', x_est)\n", - "\n", - "x_t = Input('x_t')\n", - "msd.addModel('msd', [x_n])\n", - "msd.addMinimize('x[t]', x_t.next(), x_n, loss_function='mse')\n", - "msd.neuralizeModel(sample_time = 0.01)" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[33m[neuralizeModel] Closed loop on x with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {},\n", + "\u001b[33m[neuralizeModel] Closed loop on x with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {},\n", " 'Functions': {'FNeuralODE5': {'atol': 1e-09,\n", " 'code': 'def FNeuralODE5(state, *weights):\\n'\n", " ' from '\n", @@ -288,12 +266,40 @@ " 'Select7': ['Select', ['NeuralODE5'], 2, 0],\n", " 'TimePart1': ['TimePart', ['x'], -1, [-0.1, 0]],\n", " 'TimePart3': ['TimePart', ['F'], -1, [-0.1, 0]],\n", - " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 3 + "source": [ + "model_name = \"neuralODE_msd\"\n", + "msd = Modely(seed=42, workspace=\"saved\")\n", + "\n", + "x = Input(\"x\") # MSNN input (Mass position)\n", + "F = Input(\"F\") # MSNN input (Force)\n", + "T_x = 0.1\n", + "init_value = 0.1\n", + "weight_fir = Parameter(\n", + " \"weight_fir\",\n", + " dimensions=(2, 1, 10),\n", + " init=init_random_range,\n", + " init_params={\"min_value\": -init_value, \"max_value\": init_value},\n", + ")\n", + "paramFun = ParamFun(ode_func_torch)\n", + "neuOde = NeuralODE(func=paramFun, dt=0.01, rtol=1e-7, atol=1e-9, method=\"dopri5\")\n", + "state = Concatenate(x.tw(T_x), F.tw(T_x))\n", + "ans = neuOde(state, weight_fir)\n", + "x_est = TimePart(Select(ans, 0), 0.09, 0.1)\n", + "x_est.closedLoop(x)\n", + "\n", + "# Output and loss\n", + "x_n = Output(\"x_n\", x_est)\n", + "\n", + "x_t = Input(\"x_t\")\n", + "msd.addModel(\"msd\", [x_n])\n", + "msd.addMinimize(\"x[t]\", x_t.next(), x_n, loss_function=\"mse\")\n", + "msd.neuralizeModel(sample_time=0.01)" + ] }, { "cell_type": "markdown", @@ -310,6 +316,7 @@ }, { "cell_type": "code", + "execution_count": 4, "id": "f0f3f7be", "metadata": { "ExecuteTime": { @@ -317,29 +324,26 @@ "start_time": "2026-02-27T15:24:13.191582Z" } }, - "source": [ - "data_struct = ['time', ('x_t', 'x'), '', 'F']\n", - "msd.loadData(name = 'simulations',\n", - " source = 'data',\n", - " format = data_struct, delimiter = ';')" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: simulations\u001B[0m\n", - "\u001B[32mNumber of files: 100\u001B[0m\n", - "\u001B[32mTotal number of samples: 199100\u001B[0m\n", - "\u001B[32mShape of x: (199100, 10, 1)\u001B[0m\n", - "\u001B[32mShape of F: (199100, 10, 1)\u001B[0m\n", - "\u001B[32mShape of x_t: (199100, 1, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: simulations\u001b[0m\n", + "\u001b[32mNumber of files: 100\u001b[0m\n", + "\u001b[32mTotal number of samples: 199100\u001b[0m\n", + "\u001b[32mShape of x: (199100, 10, 1)\u001b[0m\n", + "\u001b[32mShape of F: (199100, 10, 1)\u001b[0m\n", + "\u001b[32mShape of x_t: (199100, 1, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 4 + "source": [ + "data_struct = [\"time\", (\"x_t\", \"x\"), \"\", \"F\"]\n", + "msd.loadData(name=\"simulations\", source=\"data\", format=data_struct, delimiter=\";\")" + ] }, { "cell_type": "markdown", @@ -354,6 +358,7 @@ }, { "cell_type": "code", + "execution_count": 6, "id": "7fab61e7", "metadata": { "ExecuteTime": { @@ -361,36 +366,23 @@ "start_time": "2026-02-27T15:24:39.965159Z" } }, - "source": [ - "msd.exportPythonModel(name = model_name)\n", - "msd.importPythonModel(name = model_name)\n", - "msd.neuralizeModel(sample_time=0.01)\n", - "param_model = {'num_of_epochs' : 20,\n", - " 'train_batch_size' : 128,\n", - " 'lr' : 1e-3,\n", - " 'splits' : [70, 20, 10]}\n", - "msd.trainModel(training_params = param_model, minimize_gain=None)\n", - "\n", - "# Save the neural model\n", - "msd.exportPythonModel(name = model_name)" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m=============================== Save JSON Model ================================\u001B[0m\n", - "\u001B[32mModel saved in: saved/neuralODE_msd.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m========================== Export Python Torch Model ===========================\u001B[0m\n", - "\u001B[32mModel exported in: saved/neuralODE_msd.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=============================== Load JSON Model ================================\u001B[0m\n", - "\u001B[32mModel loaded from: saved/neuralODE_msd.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on x with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {},\n", + "\u001b[1;32m=============================== Save JSON Model ================================\u001b[0m\n", + "\u001b[32mModel saved in: saved/neuralODE_msd.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m========================== Export Python Torch Model ===========================\u001b[0m\n", + "\u001b[32mModel exported in: saved/neuralODE_msd.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=============================== Load JSON Model ================================\u001b[0m\n", + "\u001b[32mModel loaded from: saved/neuralODE_msd.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on x with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {},\n", " 'Functions': {'FNeuralODE5': {'atol': 1e-09,\n", " 'code': 'def FNeuralODE5(state, *weights):\\n'\n", " ' from '\n", @@ -523,14 +515,14 @@ " 'Select7': ['Select', ['NeuralODE5'], 2, 0],\n", " 'TimePart1': ['TimePart', ['x'], -1, [-0.1, 0]],\n", " 'TimePart3': ['TimePart', ['F'], -1, [-0.1, 0]],\n", - " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m========================== Import Python Torch Model ===========================\u001B[0m\n", - "\u001B[32mModel imported from: saved/neuralODE_msd.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on x with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {},\n", + " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m========================== Import Python Torch Model ===========================\u001b[0m\n", + "\u001b[32mModel imported from: saved/neuralODE_msd.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on x with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {},\n", " 'Functions': {'FNeuralODE5': {'atol': 1e-09,\n", " 'code': 'def FNeuralODE5(state, *weights):\\n'\n", " ' from '\n", @@ -663,76 +655,90 @@ " 'Select7': ['Select', ['NeuralODE5'], 2, 0],\n", " 'TimePart1': ['TimePart', ['x'], -1, [-0.1, 0]],\n", " 'TimePart3': ['TimePart', ['F'], -1, [-0.1, 0]],\n", - " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['msd']\u001B[0m\n", - "\u001B[32mnum of epochs: 20\u001B[0m\n", - "\u001B[32mupdate per epochs: 1088\u001B[0m\n", - "\u001B[34mâ””>len(train_indexes)//(batch_size+step)\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mprediction samples: 0\u001B[0m\n", - "\u001B[32mstep: 0\u001B[0m\n", - "\u001B[32mclosed loop: {}\u001B[0m\n", - "\u001B[32mconnect: {}\u001B[0m\n", - "\u001B[32mtrain dataset: simulations_train\u001B[0m\n", - "\u001B[32m\t- batch size: 128\u001B[0m\n", - "\u001B[32m\t- num of samples: 139370\u001B[0m\n", - "\u001B[32m\t- num of first samples: 139370\u001B[0m\n", - "\u001B[32mvalidation dataset: simulations_val\u001B[0m\n", - "\u001B[32m\t- batch size: 128\u001B[0m\n", - "\u001B[32m\t- num of samples: 39820\u001B[0m\n", - "\u001B[32m\t- num of first samples: 39820\u001B[0m\n", - "\u001B[32mtest dataset: simulations_test\u001B[0m\n", - "\u001B[32m\t- num of samples: 19910\u001B[0m\n", - "\u001B[32m\t- num of first samples: 19910\u001B[0m\n", - "\u001B[32mminimizers: {'x[t]': {'A': 'SamplePart10',\n", + " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['msd']\u001b[0m\n", + "\u001b[32mnum of epochs: 20\u001b[0m\n", + "\u001b[32mupdate per epochs: 1088\u001b[0m\n", + "\u001b[34mâ””>len(train_indexes)//(batch_size+step)\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mprediction samples: 0\u001b[0m\n", + "\u001b[32mstep: 0\u001b[0m\n", + "\u001b[32mclosed loop: {}\u001b[0m\n", + "\u001b[32mconnect: {}\u001b[0m\n", + "\u001b[32mtrain dataset: simulations_train\u001b[0m\n", + "\u001b[32m\t- batch size: 128\u001b[0m\n", + "\u001b[32m\t- num of samples: 139370\u001b[0m\n", + "\u001b[32m\t- num of first samples: 139370\u001b[0m\n", + "\u001b[32mvalidation dataset: simulations_val\u001b[0m\n", + "\u001b[32m\t- batch size: 128\u001b[0m\n", + "\u001b[32m\t- num of samples: 39820\u001b[0m\n", + "\u001b[32m\t- num of first samples: 39820\u001b[0m\n", + "\u001b[32mtest dataset: simulations_test\u001b[0m\n", + "\u001b[32m\t- num of samples: 19910\u001b[0m\n", + "\u001b[32m\t- num of first samples: 19910\u001b[0m\n", + "\u001b[32mminimizers: {'x[t]': {'A': 'SamplePart10',\n", " 'B': 'TimePart8',\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.001}\u001B[0m\n", - "\u001B[32moptimizer params: [{'params': 'weight_fir'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m================= nnodely Training =================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m x[t] |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m val |\u001B[0m\n", - "\u001B[32m|--------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 1/20 |\u001B[0m\u001B[32m2.946e-05|\u001B[0m\u001B[32m3.003e-05|\u001B[0m\u001B[32m2.946e-05|\u001B[0m\u001B[32m3.003e-05|\u001B[0m\n", - "\u001B[32m| 2/20 |\u001B[0m\u001B[32m2.333e-05|\u001B[0m\u001B[32m2.359e-05|\u001B[0m\u001B[32m2.333e-05|\u001B[0m\u001B[32m2.359e-05|\u001B[0m\n", - "\u001B[32m| 3/20 |\u001B[0m\u001B[32m1.811e-05|\u001B[0m\u001B[32m1.807e-05|\u001B[0m\u001B[32m1.811e-05|\u001B[0m\u001B[32m1.807e-05|\u001B[0m\n", - "\u001B[32m| 4/20 |\u001B[0m\u001B[32m1.361e-05|\u001B[0m\u001B[32m1.329e-05|\u001B[0m\u001B[32m1.361e-05|\u001B[0m\u001B[32m1.329e-05|\u001B[0m\n", - "\u001B[32m| 5/20 |\u001B[0m\u001B[32m9.822e-06|\u001B[0m\u001B[32m9.341e-06|\u001B[0m\u001B[32m9.822e-06|\u001B[0m\u001B[32m9.341e-06|\u001B[0m\n", - "\u001B[32m| 6/20 |\u001B[0m\u001B[32m6.726e-06|\u001B[0m\u001B[32m6.203e-06|\u001B[0m\u001B[32m6.726e-06|\u001B[0m\u001B[32m6.203e-06|\u001B[0m\n", - "\u001B[32m| 7/20 |\u001B[0m\u001B[32m4.319e-06|\u001B[0m\u001B[32m3.798e-06|\u001B[0m\u001B[32m4.319e-06|\u001B[0m\u001B[32m3.798e-06|\u001B[0m\n", - "\u001B[32m| 8/20 |\u001B[0m\u001B[32m2.513e-06|\u001B[0m\u001B[32m2.064e-06|\u001B[0m\u001B[32m2.513e-06|\u001B[0m\u001B[32m2.064e-06|\u001B[0m\n", - "\u001B[32m| 9/20 |\u001B[0m\u001B[32m1.273e-06|\u001B[0m\u001B[32m9.422e-07|\u001B[0m\u001B[32m1.273e-06|\u001B[0m\u001B[32m9.422e-07|\u001B[0m\n", - "\u001B[32m| 10/20 |\u001B[0m\u001B[32m5.204e-07|\u001B[0m\u001B[32m3.270e-07|\u001B[0m\u001B[32m5.204e-07|\u001B[0m\u001B[32m3.270e-07|\u001B[0m\n", - "\u001B[32m| 11/20 |\u001B[0m\u001B[32m1.508e-07|\u001B[0m\u001B[32m6.744e-08|\u001B[0m\u001B[32m1.508e-07|\u001B[0m\u001B[32m6.744e-08|\u001B[0m\n", - "\u001B[32m| 12/20 |\u001B[0m\u001B[32m2.458e-08|\u001B[0m\u001B[32m5.847e-09|\u001B[0m\u001B[32m2.458e-08|\u001B[0m\u001B[32m5.847e-09|\u001B[0m\n", - "\u001B[32m| 13/20 |\u001B[0m\u001B[32m1.724e-09|\u001B[0m\u001B[32m1.689e-10|\u001B[0m\u001B[32m1.724e-09|\u001B[0m\u001B[32m1.689e-10|\u001B[0m\n", - "\u001B[32m| 14/20 |\u001B[0m\u001B[32m1.613e-10|\u001B[0m\u001B[32m 2.83e-11|\u001B[0m\u001B[32m1.613e-10|\u001B[0m\u001B[32m 2.83e-11|\u001B[0m\n", - "\u001B[32m| 15/20 |\u001B[0m\u001B[32m4.815e-11|\u001B[0m\u001B[32m6.983e-12|\u001B[0m\u001B[32m4.815e-11|\u001B[0m\u001B[32m6.983e-12|\u001B[0m\n", - "\u001B[32m| 16/20 |\u001B[0m\u001B[32m1.415e-11|\u001B[0m\u001B[32m1.566e-12|\u001B[0m\u001B[32m1.415e-11|\u001B[0m\u001B[32m1.566e-12|\u001B[0m\n", - "\u001B[32m| 17/20 |\u001B[0m\u001B[32m1.537e-11|\u001B[0m\u001B[32m2.816e-12|\u001B[0m\u001B[32m1.537e-11|\u001B[0m\u001B[32m2.816e-12|\u001B[0m\n", - "\u001B[32m| 18/20 |\u001B[0m\u001B[32m2.932e-11|\u001B[0m\u001B[32m3.224e-12|\u001B[0m\u001B[32m2.932e-11|\u001B[0m\u001B[32m3.224e-12|\u001B[0m\n", - "\u001B[32m| 19/20 |\u001B[0m\u001B[32m2.718e-11|\u001B[0m\u001B[32m7.241e-11|\u001B[0m\u001B[32m2.718e-11|\u001B[0m\u001B[32m7.241e-11|\u001B[0m\n", - "\u001B[32m| 20/20 |\u001B[0m\u001B[32m2.717e-11|\u001B[0m\u001B[32m1.739e-12|\u001B[0m\u001B[32m2.717e-11|\u001B[0m\u001B[32m1.739e-12|\u001B[0m\n", - "\u001B[32m|--------------------------------------------------|\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 685.4026439189911\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[34mThe selected model is the LAST model of the training.\u001B[0m\n", - "\u001B[1;32m=============================== Save JSON Model ================================\u001B[0m\n", - "\u001B[32mModel saved in: saved/neuralODE_msd.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m========================== Export Python Torch Model ===========================\u001B[0m\n", - "\u001B[32mModel exported in: saved/neuralODE_msd.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.001}\u001b[0m\n", + "\u001b[32moptimizer params: [{'params': 'weight_fir'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m================= nnodely Training =================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m x[t] |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m val |\u001b[0m\n", + "\u001b[32m|--------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 1/20 |\u001b[0m\u001b[32m2.946e-05|\u001b[0m\u001b[32m3.003e-05|\u001b[0m\u001b[32m2.946e-05|\u001b[0m\u001b[32m3.003e-05|\u001b[0m\n", + "\u001b[32m| 2/20 |\u001b[0m\u001b[32m2.333e-05|\u001b[0m\u001b[32m2.359e-05|\u001b[0m\u001b[32m2.333e-05|\u001b[0m\u001b[32m2.359e-05|\u001b[0m\n", + "\u001b[32m| 3/20 |\u001b[0m\u001b[32m1.811e-05|\u001b[0m\u001b[32m1.807e-05|\u001b[0m\u001b[32m1.811e-05|\u001b[0m\u001b[32m1.807e-05|\u001b[0m\n", + "\u001b[32m| 4/20 |\u001b[0m\u001b[32m1.361e-05|\u001b[0m\u001b[32m1.329e-05|\u001b[0m\u001b[32m1.361e-05|\u001b[0m\u001b[32m1.329e-05|\u001b[0m\n", + "\u001b[32m| 5/20 |\u001b[0m\u001b[32m9.822e-06|\u001b[0m\u001b[32m9.341e-06|\u001b[0m\u001b[32m9.822e-06|\u001b[0m\u001b[32m9.341e-06|\u001b[0m\n", + "\u001b[32m| 6/20 |\u001b[0m\u001b[32m6.726e-06|\u001b[0m\u001b[32m6.203e-06|\u001b[0m\u001b[32m6.726e-06|\u001b[0m\u001b[32m6.203e-06|\u001b[0m\n", + "\u001b[32m| 7/20 |\u001b[0m\u001b[32m4.319e-06|\u001b[0m\u001b[32m3.798e-06|\u001b[0m\u001b[32m4.319e-06|\u001b[0m\u001b[32m3.798e-06|\u001b[0m\n", + "\u001b[32m| 8/20 |\u001b[0m\u001b[32m2.513e-06|\u001b[0m\u001b[32m2.064e-06|\u001b[0m\u001b[32m2.513e-06|\u001b[0m\u001b[32m2.064e-06|\u001b[0m\n", + "\u001b[32m| 9/20 |\u001b[0m\u001b[32m1.273e-06|\u001b[0m\u001b[32m9.422e-07|\u001b[0m\u001b[32m1.273e-06|\u001b[0m\u001b[32m9.422e-07|\u001b[0m\n", + "\u001b[32m| 10/20 |\u001b[0m\u001b[32m5.204e-07|\u001b[0m\u001b[32m3.270e-07|\u001b[0m\u001b[32m5.204e-07|\u001b[0m\u001b[32m3.270e-07|\u001b[0m\n", + "\u001b[32m| 11/20 |\u001b[0m\u001b[32m1.508e-07|\u001b[0m\u001b[32m6.744e-08|\u001b[0m\u001b[32m1.508e-07|\u001b[0m\u001b[32m6.744e-08|\u001b[0m\n", + "\u001b[32m| 12/20 |\u001b[0m\u001b[32m2.458e-08|\u001b[0m\u001b[32m5.847e-09|\u001b[0m\u001b[32m2.458e-08|\u001b[0m\u001b[32m5.847e-09|\u001b[0m\n", + "\u001b[32m| 13/20 |\u001b[0m\u001b[32m1.724e-09|\u001b[0m\u001b[32m1.689e-10|\u001b[0m\u001b[32m1.724e-09|\u001b[0m\u001b[32m1.689e-10|\u001b[0m\n", + "\u001b[32m| 14/20 |\u001b[0m\u001b[32m1.613e-10|\u001b[0m\u001b[32m 2.83e-11|\u001b[0m\u001b[32m1.613e-10|\u001b[0m\u001b[32m 2.83e-11|\u001b[0m\n", + "\u001b[32m| 15/20 |\u001b[0m\u001b[32m4.815e-11|\u001b[0m\u001b[32m6.983e-12|\u001b[0m\u001b[32m4.815e-11|\u001b[0m\u001b[32m6.983e-12|\u001b[0m\n", + "\u001b[32m| 16/20 |\u001b[0m\u001b[32m1.415e-11|\u001b[0m\u001b[32m1.566e-12|\u001b[0m\u001b[32m1.415e-11|\u001b[0m\u001b[32m1.566e-12|\u001b[0m\n", + "\u001b[32m| 17/20 |\u001b[0m\u001b[32m1.537e-11|\u001b[0m\u001b[32m2.816e-12|\u001b[0m\u001b[32m1.537e-11|\u001b[0m\u001b[32m2.816e-12|\u001b[0m\n", + "\u001b[32m| 18/20 |\u001b[0m\u001b[32m2.932e-11|\u001b[0m\u001b[32m3.224e-12|\u001b[0m\u001b[32m2.932e-11|\u001b[0m\u001b[32m3.224e-12|\u001b[0m\n", + "\u001b[32m| 19/20 |\u001b[0m\u001b[32m2.718e-11|\u001b[0m\u001b[32m7.241e-11|\u001b[0m\u001b[32m2.718e-11|\u001b[0m\u001b[32m7.241e-11|\u001b[0m\n", + "\u001b[32m| 20/20 |\u001b[0m\u001b[32m2.717e-11|\u001b[0m\u001b[32m1.739e-12|\u001b[0m\u001b[32m2.717e-11|\u001b[0m\u001b[32m1.739e-12|\u001b[0m\n", + "\u001b[32m|--------------------------------------------------|\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 685.4026439189911\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[34mThe selected model is the LAST model of the training.\u001b[0m\n", + "\u001b[1;32m=============================== Save JSON Model ================================\u001b[0m\n", + "\u001b[32mModel saved in: saved/neuralODE_msd.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m========================== Export Python Torch Model ===========================\u001b[0m\n", + "\u001b[32mModel exported in: saved/neuralODE_msd.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 6 + "source": [ + "msd.exportPythonModel(name=model_name)\n", + "msd.importPythonModel(name=model_name)\n", + "msd.neuralizeModel(sample_time=0.01)\n", + "param_model = {\n", + " \"num_of_epochs\": 20,\n", + " \"train_batch_size\": 128,\n", + " \"lr\": 1e-3,\n", + " \"splits\": [70, 20, 10],\n", + "}\n", + "msd.trainModel(training_params=param_model, minimize_gain=None)\n", + "\n", + "# Save the neural model\n", + "msd.exportPythonModel(name=model_name)" + ] }, { "cell_type": "markdown", @@ -744,6 +750,7 @@ }, { "cell_type": "code", + "execution_count": 7, "id": "5dd1d858", "metadata": { "ExecuteTime": { @@ -751,47 +758,17 @@ "start_time": "2026-02-27T15:39:15.286428Z" } }, - "source": [ - "# Recursive plot using getSamples\n", - "msd.importPythonModel(name = model_name)\n", - "msd.neuralizeModel(sample_time=0.01)\n", - "samples = msd.getSamples(dataset='simulations', window=2000-10, index=0)\n", - "result = msd(samples, sampled=True, prediction_samples=2000-10)\n", - "\n", - "#region Plotting\n", - "t = np.arange(len(result['x_n'])) * 0.01\n", - "plt.figure(figsize=(12, 7))\n", - "plt.subplot(2, 1, 1)\n", - "plt.plot(t, result['x_n'], label=r'Estimated $x$', linewidth=2)\n", - "plt.plot(t, np.array(samples['x_t']).squeeze(-1).squeeze(-1), label=r'True $x$', linestyle='--', linewidth=2)\n", - "plt.title('Position estimation')\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel(r'$x$ [m]')\n", - "plt.grid()\n", - "plt.legend()\n", - "plt.subplot(2, 1, 2)\n", - "plt.plot(t, np.array(samples['F'])[:, 0, 0], label=r'Applied force $F$')\n", - "plt.title('Applied force')\n", - "plt.xlabel('Time [s]')\n", - "plt.ylabel('Force [N]')\n", - "plt.grid()\n", - "plt.legend()\n", - "plt.tight_layout()\n", - "#endregion\n", - "\n", - "plt.show()" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m=============================== Load JSON Model ================================\u001B[0m\n", - "\u001B[32mModel loaded from: saved/neuralODE_msd.json\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on x with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {},\n", + "\u001b[1;32m=============================== Load JSON Model ================================\u001b[0m\n", + "\u001b[32mModel loaded from: saved/neuralODE_msd.json\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on x with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {},\n", " 'Functions': {'FNeuralODE5': {'atol': 1e-09,\n", " 'code': 'def FNeuralODE5(state, *weights):\\n'\n", " ' from '\n", @@ -924,14 +901,14 @@ " 'Select7': ['Select', ['NeuralODE5'], 2, 0],\n", " 'TimePart1': ['TimePart', ['x'], -1, [-0.1, 0]],\n", " 'TimePart3': ['TimePart', ['F'], -1, [-0.1, 0]],\n", - " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m========================== Import Python Torch Model ===========================\u001B[0m\n", - "\u001B[32mModel imported from: saved/neuralODE_msd.py\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[neuralizeModel] Closed loop on x with sample in the future.\u001B[0m\n", - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {},\n", + " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m========================== Import Python Torch Model ===========================\u001b[0m\n", + "\u001b[32mModel imported from: saved/neuralODE_msd.py\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[neuralizeModel] Closed loop on x with sample in the future.\u001b[0m\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {},\n", " 'Functions': {'FNeuralODE5': {'atol': 1e-09,\n", " 'code': 'def FNeuralODE5(state, *weights):\\n'\n", " ' from '\n", @@ -1064,33 +1041,68 @@ " 'Select7': ['Select', ['NeuralODE5'], 2, 0],\n", " 'TimePart1': ['TimePart', ['x'], -1, [-0.1, 0]],\n", " 'TimePart3': ['TimePart', ['F'], -1, [-0.1, 0]],\n", - " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'TimePart8': ['TimePart', ['Select7'], 0.1, [0.09, 0.1]]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAKyCAYAAAAEvm1SAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XV0FFcbx/HvbjwhQRIgaAjuGqy4e3F3KS1eKLRQtFhxKVCgUCAUL+5Wgru7B4dAIO7JzvvHwlJeKJrkZpPnc849nZnM7Pw2Cdvss1d0gIYQQgghhBBCCCGEEPFIrzqAEEIIIYQQQgghhEh6pCglhBBCCCGEEEIIIeKdFKWEEEIIIYQQQgghRLyTopQQQgghhBBCCCGEiHdSlBJCCCGEEEIIIYQQ8U6KUkIIIYQQQgghhBAi3klRSgghhBBCCCGEEELEOylKCSGEEEIIIYQQQoh4J0UpIYQQQgghhBBCCBHvpCglhBBCiATPy8sLTdPeaBEREdy9e5eZM2eSIkWKWL1fhQoV0DSNChUqAJAhQwY2b96Mm5ub6Rxvb28WLlwYq/eNS6qfQ7169fD09DTt///3WAghhBBJjw7QVIcQQgghhHgfLy8vnJyc6N69u+mYtbU1xYoVY+zYsZw5c4YyZcrE2v0cHR3Jmzcvly9fJigoiPbt27No0SKyZMnC3bt3AShcuDCBgYHcvn071u4bl1Q/By8vLwAqVaoEvP09FkIIIUTSY6k6gBBCCCHExwgMDOTYsWNvHDtw4ADJkiVj1KhRlCxZ8q2vf66goKAPPtbZs2dj5V4qqXwOH/M9FkIIIUTiJsP3hBBCCGHWTp48CfDGsLRmzZpx4sQJgoKCePz4MbNnz35jiJ+trS2zZs3i/v37hIeHc+XKFX744QfT1/89tOxVDyOAO3fumIa7/f/QNycnJyZPnszNmzcJCwvjwoULdOzY8Y2s3t7ejBgxggkTJvDkyRNCQ0PZtm0b2bNnf+9z1Ol0/PTTT9y4cYPw8HCuXbtGz5493zgna9asbNiwAV9fX0JCQjh8+DC1atUC+Kjn4ObmhqZpNG7cmHXr1hEcHMyTJ08YPHgwjo6OzJ8/H39/f548ecK4cePeuLebmxuenp48fPiQyMhIfHx88PT0JFWqVICxl1TFihWpWLGi6fv6ruF7xYoVY9u2bfj6+hIQEMDGjRvJmzfvWz+XypUrs2PHDkJCQnj8+DHjxo1Dr5c/a4UQQghzpEmTJk2aNGnSpCXk5uXlpXl5eb3za3369NE0TdOKFSumAdrgwYO1mJgYbcaMGVr16tW17777Tnv27Jl29uxZzdbWVgO0OXPmaLdv39aaN2+uVahQQRs3bpymaZrWoUMHDdAqVKigaZqmVahQQXNxcdFGjhypaZqmNWjQQMuaNasGaN7e3trChQs1QLO1tdXOnz+vPXnyROvatatWvXp17ffff9c0TdMGDRpkyurt7a35+flpmzZt0mrWrKm1atVKe/bsmXb48OH3Pv85c+ZoERER2vDhw7Vq1appo0eP1qKjo7UhQ4ZogKbT6bTLly9ru3fv1mrVqqVVrVpV27RpkxYVFaVly5bto56Dm5ubpmma5ufnp40cOVKrVKmStmTJEk3TNO3KlSvajBkztMqVK2uzZs3SNE3TmjRpogGanZ2d5u3trR0/flxr0KCBVrFiRe3nn3/WIiMjtdmzZ2uAlidPHu3UqVPaqVOntJIlS2qOjo5vfI8BrWLFilpERIS2fft2rV69elrTpk21M2fOaP7+/lquXLne+Lk8fvxYGzJkiFapUiVt8uTJmqZpWteuXZX/nkqTJk2aNGnSPrkpDyBNmjRp0qRJk/be5uXlpe3du1ezsLAwtdSpU2tNmjTRnj17ph06dEgDtBQpUmhhYWGmYsirVrZsWU3TNK1bt24aoF25ckWbO3fuG+cMGTJEq127tga8VTBp3769pmma5ubmZjr/3wWd7777TtM0TStVqtQbjzlv3jwtNDRUS5kypema27dva3q93nTO0KFDNU3TtFSpUr3zuefIkUOLiYnRfvzxxzeOjxw5UgsNDdVSpUqlpU2bVtM0TWvZsqXp605OTtrkyZO1vHnzftRzeFWUWr58uenradKk0TRN0/bt2/fGvf39/bWpU6dqgFaoUCFt//79mru7+xvnbNiwQbty5cobP8N/Fxb//3t89OhR7eLFi298b5InT675+vpqK1eufOOakSNHvnGvW7duaRs3blT+eypNmjRp0qRJ+7Qm/ZyFEEIIYRYqVKhAdHS0qT19+pQVK1Zw6tQpWrZsCUCpUqWwtbVl+fLlb1x78OBB7ty5Q8WKFQHjcLKuXbuyZcsWevToQZYsWRg9ejRbt279rGwVK1bE29ubo0ePvnF8yZIl2NnZUapUKdOxEydOYDAYTPsPHjwAwMHB4Z2PXblyZfR6PZs2bcLCwsLUNm7ciJ2dHeXKlcPHx4dLly4xb948Fi1aRMuWLdHr9fzwww9cvnz5k57L4cOHTdtPnz4FeGvuJz8/P9NwyHPnzlG+fHnu3LlD9uzZqVWrFj/88AN58uTBxsbmo+5pb29P8eLFWbVq1Rvfm4CAADZt2mT6ub1y5MiRN/YfPHjwn98/IYQQQiRcUpQSQgghhFk4deoUHh4eeHh4UKxYMfLly0eKFCmoWbMm9+7dAzDNYfTkyZO3rn/y5ImpkPL9998zePBg3N3dmTlzJt7e3hw6dIiCBQt+VrZUqVL95z2BN+azCg0NfeOcV0WY/5oTydnZGYDLly+/UZQ7ceIEAOnTpwegWrVqeHp6UqNGDZYtW4aPjw8rVqx4494fIzAw8K1jISEh772mb9++PH36lBs3brBgwQIqVqxISEgIOp3uo+6ZIkUK9Hr9B39ur7zreyhzSgkhhBDmR1bfE0IIIYRZCAoK4tSpU+8958WLFwC4urpy/fr1N76WLl06bt++DUBkZCRjx45l7NixZMqUiXr16jF06FCWLVtG/vz5Pznbixcv3jlZebp06QDw9fX95Md8xd/fH4BKlSoRFBT01tdfFeQeP35Mjx496NGjB4UKFaJJkyYMHDgQX1/ftyZFj00tW7ZkypQpDBgwgIULF/L8+XMAVq5cSYkSJT7qMfz9/TEYDLi6ur71tXTp0n3R908IIYQQCZd8pCSEEEKIROPYsWOEh4ebhvO9UrZsWdzc3Dh48CC2trZcu3aNfv36AXD//n1+//13li9f/sYKfv8WExPz3vvu27cPd3f3N4bpAbRp04aIiAiOHz/+2c9p//79ALi4uHDq1ClTS506NaNGjcLZ2ZlSpUrx5MkTPDw8AOOQuqFDh3LhwgXTc/rQc/hcZcuWxc/Pj0mTJpkKUg4ODpQtW/aN3kvvu39oaCgnT56kWbNmb1zj5ORE3bp1OXjwYJxkF0IIIYRa0lNKCCGEEImGn58f48aNY9iwYURFRbFp0ybc3d0ZNWoUly5dwtPTk/DwcE6dOsXw4cOJjIzk/Pnz5MqViw4dOrB69ep3Pu6r3kqNGjVi69atXLt27Y2vL1q0iB49erB+/XqGDRuGt7c3X3/9NZ07d2bEiBEEBAR89nO6ePEif/31F/PmzSNLliycPHmSXLlyMXbsWLy9vbl+/TpWVlaEhoby119/MWLECJ48eULVqlUpUqQI06dP/6jn8LmOHz9O9+7dmTRpEps2bSJ9+vQMGDAAV1dX/Pz8TOf5+/tTunRpKlWqxJkzZ956nEGDBrFjxw62bt3KrFmzsLa2ZtCgQdjY2DBy5MhYySqEEEKIhEf5bOvSpEmTJk2aNGnva/+/ctuH2rfffqtdvHhRCw8P1x4+fKjNnDlTS5EihenryZIl06ZNm6bduXNHCw8P1+7du6dNmDBBs7W11eDtleEcHBy0nTt3auHh4drmzZs1eHPlOkBzdnbW5s2bp/n4+GhhYWHamTNntI4dO76R6/+vgXevivf/zcLCQhsyZIh28+ZNLSIiQrt37542a9Ys06p+gJY9e3Zt9erV2pMnT7Tw8HDtwoUL2jfffGP6+oeew6vV99q3b//GvTVN04YPH/7e5zFixAjt3r17WmhoqHbjxg1t2rRpWpcuXTRN07TcuXNrgFaxYkXT97tly5ZvfY9ffd/37dunhYSEaC9evNDWr19vWj3wXT+Xz/39kCZNmjRp0qQljKZ7uSGEEEIIIYQQQgghRLyROaWEEEIIIYQQQgghRLyTopQQQgghhBBCCCGEiHdSlBJCCCGEEEIIIYQQ8c6silI2NjbMnz8fPz8/Hj16ZFrK+X3c3NwICgqiQoUK8ZBQCCGEEEIIIYQQQnwMS9UBPsXEiRPx8PCgcuXKuLm54enpyd27d1mzZs1/XjN79mySJUsWjymFEEIIIYQQQgghxIeYTU8pe3t7unTpQp8+fThz5gzr169nwoQJ9OzZ8z+vadWqFY6OjvGYUgghhBBCCCGEEEJ8DLPpKVWoUCGsrKw4fPiw6djBgwcZPHgwOp0OTdPeOD9VqlRMmDCB6tWrc+nSpc+6Z/r06QkKCvqi3EIIIYQQQgghhBBJjaOjI48ePXrvOWZTlEqXLh2+vr5ERUWZjvn4+GBnZ4ezszO+vr5vnD9lyhQ8PT25fPnyZ90vffr0PHz48IsyCyGEEEIIIYQQQiRVGTJkeG9hymyKUvb29kRERLxx7NW+jY3NG8erVKlC2bJlyZ8//2ff71UPqQwZMkhvKSGEEEIIIYQQQoiP5OjoyMOHDz9YTzGbolR4ePhbxadX+6GhoaZjtra2zJ07l+7duxMeHv7F9w0KCpKilBBCCCGEEEIIIUQsM5uJzh8+fIiLiwsWFhamY66uroSGhuLv7286VqJECbJly8aaNWveKCht27aN2bNnx3dsIYQQQgghhBBCCPEOZtNT6uzZs0RFRVGqVCkOHToEQNmyZTlx4sQbk5wfP36c7Nmzv3HtzZs36dKlC7t27YrXzEIIIYQQQgghhBDi3cymKBUWFoanpydz5syhY8eOZMiQgf79+9OxY0cA0qZNS0BAAOHh4dy6deut6x8+fMizZ8/iO7YQQgghhBBCCCGEeAezKUoB9OvXj9mzZ+Pl5UVAQADDhw9n3bp1ADx58oQOHTrg6empOKUQQgghhBBCCJE02dvb4+Ligk6nUx1FxBFN0/D19X1jfu/PpQO0D56VBDk6OhIYGIiTk5NMdC6EEEIIIYQQQryHTqejY8eOVKxYUXUUEU/27t3LwoUL35hS6ZWPramYVU8pIYQQQgghhBBCJDwdO3akQoUKrFy5kqtXrxIdHa06kogjlpaW5M6dm2bNmgGwYMGCz3+s2AolhBBCCCGEEEKIpMfBwYGKFSuycuVKtmzZojqOiAev5vJu3rw5K1as+OyhfPrYDCWEEOZGp9djbWenOoYQQgghhBBmy9nZGYCrV68qTiLi06uft4uLy2c/hvSUEkIkOY7OqWjUvQ21vy5FLndnbC0hNFJjhdd9jmzcxYkNWwgPDlEdUwghhBBCCLPwalJzGbKXtLz6eX/JpPZSlBJCJBl6Sws6D+/NDz2qkzPlq/9hRgIQEaPDNW8+GuTNT43uXdg8dRbH1mx856R9QgghhBBCCCG+nAzfE0IkCSnSpuHvY38x6+fK/ypIvXbneTQaxgq/nZMjTYcP5JtZE2VonxBCCCGEEELEESlKCSESvXTZ3dl9ah4Nizpi+fJV70VgBKPHraVUyR9wz9KZKkU6MaF+S05u3AaAjd7A6I55WX10IQ4pkitML4QQQgghhIhL3t7eaJr2zlahQoUPXl+oUCFKly4NgJubG5qm4ebmFus5/32fTzV8+HC8vLxiOdGXk6KUECJRc8mUnl2HfqNohtcvd38s2kfGtK0YNmghx49f5+7dpzx69AKf23dYPngkC3v+QO30frjYxlC3oAN/75+Djb29wmchhBBCCCGEiEt9+vTB1dX1rXb48OEPXrtu3Tpy5swJwP3793F1deX+/fuxnvHf90kspCglhEi07JM70XnWFAIxDsGLjtFo23EG33WcRHh45H9ed3HfYZbP32jar1kgGX9un4FOLy+ZQgghhBBCJEYBAQH4+Pi81aKioj547b8n+jYYDPj4+GAwGGI945dMKJ5QyTssIUSipNPpaDVuBGnc3Tjy1IG15yJo3HQ8Sxft/KjrBw/4g+Fj1pn2W5RNQ9+J/eMqrhBCCCGEECIB69WrF3fu3CEsLIwTJ05QpkwZALy8vMiSJQuLFi1i4cKFbwzfe7Vdu3ZtvL29CQoKYtq0aeTLl48TJ04QHBzMpk2bSJYsGQBfffUVBw4cICQkhODgYLZs2YKrq+s77wOQMWNGNmzYQEhICN7e3gwbNgz9yw/S8+TJY3qsf/75BxcXl/c+vxYtWhAaGmq6H8CCBQs4d+4cTk5Osf79/DdN2tvN0dFR0zRNc3R0VJ5FmjRpn96qdGmvTb5wRJt84Yg2Yu8WLWV61896nLmeP2kGbZNm0DZpgZGbtVK1Kip/btKkSZMmTZo0adKkJaTm5uamLV68WHNzc1Oe5XOat7e31r59+//8euHChbXw8HCtdu3ampubmzZlyhTt0aNHmk6n01KmTKndu3dP6927t+bk5KS5ublpmqZpbm5upu39+/drBQoU0Fq0aKFpmqZdv35dq1q1qvbVV19pvr6+2vfff685OTlpfn5+2tChQ7UsWbJoX331lXbt2jVt+vTpGvDWfQDt+PHj2rx587ScOXNqFSpU0K5evaoNGTJEs7a21m7fvq15enpquXLl0rp166ZFRkZqXl5e7/0+nD17Vvvtt980QBsxYoR27949LX369J/1c//YmoolQgiRyOQqVoCmfTsSYjB2n106cAR+j5581mN16ziRYsVzUDRPWpJZacxf2JdiWY8TERoay6mFEEIIIYRIXApWr0zNHt9g4xB/87NGhISyfeYfnN/l9UnXzZkzh5kzZ75x7O7du+TPn58sWbKgaRp3797l7t27DBkyhM2bN6PX6/Hz8yMmJoaAgAACAwNJmTLlW489atQoLly4wIULF5g2bRrLly9n9+7dAOzevZvcuXNjZ2fHqFGjmDJlCgB37txhzZo1lChRAuCt+1SuXBk3NzdKliyJpmlcv36d/v37s2jRIk6fPo2zszPdunUjNDSUa9euUbFiRdKkSfPe78HgwYNZvXo1T548oVevXpQrV45Hjx590vfxU0lRSgiRqOgtLViwchjFsgRxyMfApHEruHH0xGc/nsFgoE6lAVz3XoijnQV50+oZu2A4P7T4KRZTCyGEEEIIkfhU6tCatFmzxPt9K3Zo/clFqWHDhrF27do3jr2aT2rHjh1cuHCBixcvcvr0aTZs2MC8efOIiYn5qMe+ffu2aTssLIw7d+68sW9jY4OPjw+enp707duXwoULkzdvXgoVKsShQ4fe+Zh58uTB2dmZwMBA0zG9Xo+9vT358+fnxo0bhP7rg/QTJ05Qp06d9+bcsmULly9fZtiwYVSvXp3Lly9/1PP7ElKUEkIkKn3G9qF0NlsAvkoTzKWNG774MX18/Oj9/XwWzv0WgG8b52N+8YJcOXH+ix9bCCGEEEKIxMpr4RJq9uwa7z2l9i5a+snXPX36lFu3br3za2FhYZQsWZIKFSpQr149OnbsSLdu3ShWrNhH9SSKjo5+Y/9dk6CnT5+ekydPcurUKXbt2sW8efOoU6cOpUqVeudjWlpacvXqVerXr//W1xo2bPjWpOiRkf+90NMrNWrUIHfu3FhYWODj4/PB82ODFKWEEImGa5aMDOlVGePwZBgzfgP37sbOi6nnH5vp0KUWFYpn5mGIFV/368aVlt1i5bGFEEIIIYRIjM7v8vrkHksJUalSpahcuTJjx45l7969DBo0CB8fH8qWLcuqVavQNO2L79GwYUNevHhBvXr1TMd69er1RnHp3/e5du0amTNn5tmzZ6beUlWrVqVDhw4sW7aMnDlz4uTkZPpakSJF3nv/IkWKsGrVKjp37kyHDh0YNWoUzZo1++Ln9SGy+p4QItGYsnAIKW2NL9SXvf0YM3RBrD5+h2YjmXckgs33nUiTvzAFqlSI1ccXQgghhBBCqJE8eXLSpk37VrO3tycsLIzhw4fTuXNn3NzcaNGiBcmSJeP8eePIiZCQEHLnzv3O+aQ+1vPnz8mcOTOVK1fG3d2dH3/8kcaNG2NjY2M659/32blzJ3fv3mXJkiXkz5+fsmXL8scffxAaGsrOnTu5d+8ef/75J7lz56Z9+/Y0b978P+/t5ubGli1bGDt2LCtWrGDYsGE0btz4g4Ws2KJ8pvuE2GT1PWnSzKsVrVhSC4verBm0TVq0YZPmUTJPnNwnX8WyplX9Bm39W9NbWih/7tKkSZMmTZo0adKkqWyJYfW9/zJ48GAN0Fq3bq1dvXpVCwsL065evao1b97cdH23bt20oKAgbc2aNe9cfe/f35f/X+lv4cKF2sKFCzW9Xq/9/vvv2osXL7Tnz59r27dv1/r06aP5+/tr1tbWb90H0Nzd3bXNmzdrISEhmo+PjzZz5kzN1tZWA7QsWbJou3fv1kJDQ7WjR49qEydOfOfqeylTptSuXLmizZ49+43jmzdv1rZt2/bZP/dPqKmo/wVIiE2KUtKkmVc7cH2FZtA2aQZtk7Zu16Q4vdd382aYClMlGtZT/tylSZMmTZo0adKkSVPZzL0oJS32f+4fW1OR4XtCCLNXs1VdSmd3ACAiSqNbu7Fxer9tM+eiQyNn8gimTu2E3tIiTu8nhBBCCCGEEImRFKWEEGbvlzHt0b+c/++Pvw7y5PGLOL3f3XMXqep0jzqZgijtZknbvu3i9H5CCCGEEEIIkRhJUUoIYdaKVa9Ivox2AIREGBjcZ0a83Hfpop2m7YH966O3kN5SQgghhBBCCPEppCglhDBrZTu2ZeH1lBzysee3P/YQHBwWL/edMnoxz4OiAciVxoL6HRvGy32FEEIIIYQQIrGQopQQwmzlLleazPnzEmnQs+7AAwb3nh5v946Kiub3ebtN+wN+ahJv9xZCCCGEEEKIxMCsilI2NjbMnz8fPz8/Hj16RL9+/f7z3FatWnHt2jVCQ0M5dOgQxYsXj8ekQoj4ULlzW9P2rjkL4v3+E4b9SWikBoBHVgeKlJfXGSGEEEIIIYT4WGZVlJo4cSIeHh5UrlyZ7t27M3z4cBo3bvzWeWXLluXPP/9k5MiR5MuXj8OHD7Nt2zYcHBwUpBZCxIV8pYqQt3ghAHxu3+Hinv3xniEkJJy1W88DYKmHwWO6xHsGIYQQQgghhDBXZlOUsre3p0uXLvTp04czZ86wfv16JkyYQM+ePd8619XVlVGjRrF06VK8vb0ZOXIkzs7O5M2bV0FyIURcGDW5G11yvaBiumAubFyPpmlKcgzr/zuGl7euWTIDzunTKskhhBBCCCGEEObGbIpShQoVwsrKisOHD5uOHTx4kJIlS6LT6d44d/Xq1YwdOxYAW1tb+vbti4+PD5cvX47XzEKIuJEuS0aql0iPtQUUTBnOZa/47yX1yp1bjzhw+iEA9lYa3w+X3lJCCCGEEEII8THMpiiVLl06fH19iYqKMh3z8fHBzs4OZ2fnd15TuXJlgoODGT58ON9//z0hISHxFVcIEYd+ntADe0tj96R9J+9z9/ZjpXkm/7rctF2+msdbhXIhhBBCCCGEEG8zm6KUvb09ERERbxx7tW9jY/POay5evEixYsUYNmwYixYtomTJknGeUwgRt2zs7WlRp4Bpf/jAPxSmMdq8Zh9rj/qy8HpKToa4kqOUTHguhBBCCCGEOVi4cCGapv1nq1ChguqIiZrZFKXCw8PfKj692g8NDX3nNU+fPuXcuXOMGTOGXbt28d1338V5TiFE3Oo6sD3O9sZeUpfuBHDI66zaQC/9MmQR/pEWAJRqUl9xGiGEEEIIIcTH6NOnD66urri6utKnTx/u379v2nd1dX1jCiER+yxVB/hYDx8+xMXFBQsLC2JiYgDjhOahoaH4+/u/ca6HhwcxMTGcOXPGdOzy5csy0bkQiUDnjlVM29OnrlOY5E2X9h0k0Pc5Ti7O5K9UnmSpUhL8wk91LCGEEEIIIcR7BAYGEhgYCEBAQAAxMTH4+PgoTpV0mE1PqbNnzxIVFUWpUqVMx8qWLcuJEyfeWnWrc+fO/Prrr28cK1asGFeuXImXrEKIuOFRqST5Mxh7SPqHxrDo9/VqA/2LITqGkxu2AGBhZUHZRrUUJxJCCCGEEEJ8KTc3NzRNY8iQIbx48YIZM2aYjrm5uZnOGz58OF5eXgBkzJiRDRs2EBISgre3N8OGDUOv/+/yS4sWLQgNDcXV1dV0bMGCBZw7dw4nJ6e4e3IJgNkUpcLCwvD09GTOnDl4eHhQv359+vfvz/Tp0wFImzYttra2APzxxx9UrlyZ3r17kz17dkaMGEGJEiWYNm2awmcghPhSA4a1Q/9yDvHVm84SHR2jNtD/ubR7D6XThNAxpx/jhjdSHUcIIYQQQggRS8qUKYOHh4epBvE+a9eu5enTpxQpUoQOHTrQqlUrfv755/88f8WKFVy/ft10zogRI6hatSq1atUy9eJKrMxm+B5Av379mD17Nl5eXgQEBDB8+HDWrTMO33ny5AkdOnTA09OTM2fO0LBhQ8aOHcu4ceO4ePEiNWrU4NGjR4qfgRDiczmkcKLGV26AhkGDcUPmqY70lnuXb5DHMYTk1noc09uQq0herp25rDqWEEIIIYQQyvTtW5++/Rp88LzTp2/RoP7oN46t3zCEokWzffDaqVPWM3Xqhs+N+FGmTZvG7du3Ad7oIfX/KleujJubGyVLlkTTNK5fv07//v1ZtGgRo0eP/s/rBg8ezOrVq3ny5Am9evWiXLlySaKGYVZFqbCwMDp06ECHDh3e+tr/L8G+ZcsWtmzZEk/JhBBxrWT9Wpz3s6NAynCu3XrK7ZsPVUd6i8FgYLvXVZrXzouFHnoNbEPP5v/9iYgQQgghhBCJnZOTPRkzunzwvPv3fd86ljp18o+61snJ/rOyfYo7d+581Hl58uTB2dn5jR5Oer0ee3t7UqVKxYsXL9553ZYtW7h8+TLDhg2jevXqXL6cND7cNquilBAi6Spavx4nntlz8pkd8zsPUh3nP/02fhnNaxs/AalbPR+9dLq35r0TQgghhBAiqQgMDOXBg7cLTv/v2bOAdx77mGsDA0M/K9unCA8PN22/6+97S0tL03+vXr1K/fpvr8gdEPD2c3ylRo0a5M6dGwsLiyQ10boUpYQQCZ5bofyky2Hstnv79HkuHz+vONF/O7L/HA+eR5DR2YbMKfRUbFAZr3X/qI4lhBBCCCGEElOnbvjsoXX/P5wvoYiMjATA0dHRdCxr1qwAXLt2jcyZM/Ps2TNTb6mqVavSoUMH2rVr987HK1KkCKtWraJz58506NCBUaNG0axZszh+FgmD2Ux0LoRIuorXr2PaPrpmo8IkH2f1+hOm7W69ZcJzEf90Oh1ps7lTqGoFqrZpROHqlUiXMzu696z6IoQQQgghPo6Pjw/37t1jwIABuLu70759e+rUMb5n2blzJ3fv3mXJkiXkz5+fsmXL8scffxAaGorBYHjrsdzc3NiyZQtjx45lxYoVDBs2jMaNG1OkSJH4flpKyF+nQogEzcrWlu86VSS5dQwRoaGc3+WlOtIHTR+7mFc9eiuWyIze0kJtIJFkpHF3o+Ggfgz32szifQs4s6s/O//qyOkd/bh2cTrnfTYxaeVE3PLnVh1VCCGEEMJsaZpG586dKVGiBJcvX6Zp06aMGTMGMM4z+/XXX6PX6zl27Bhr1qxh69at9O7d+63HSZkyJdu3b2fDhg2MHz8egOPHj7Nt2zbGjh0br89JFRm+J4RI0Nr1akFlt2jAj81HHhEZFqY60gfdvf2Y6w+CyZUpGS72UKt5TbYslYUXRNyxc3Kidu9vKdW0AfqXvaEeh0a/cU4yKwP5XCBfs9x803Ayy3beZlCXUfg/eaoishBCCCFEguPp6Ymnp+cbx+7evfvWwmoAu3fvJk+ePG8cmzhxIgDe3t7UrVv3g/fz8/N76zGAj7o2sZCeUkKIBK1j52qm7d2bDylM8mnWbjxu2m7XpbbCJCKxK1CuOMeuL6FD1zqmglRkWDj7tx/h1GUfjp59wKVbzwmLjDFd42hl4Ns6WTh7dQFVmiedP3qEEEIIIUTCIj2lhBAJVnr3jHhkdwIgPEpj3tSVihN9vLmTlzOwe2WiDDrSZXVDb2GBISbmwxcK8Qkad2vFH1Nbk9LGQJaoEK48iWL73L848vc6wgKDWPCvcy0s9NSoVZyff2nPV0UzAZA5ucbav7rRJk06Ns2Yp+ZJCCGEEEKIJEt6SgkhEqxeQzpg/XI6pj1H7xAWFqE20Ce45/2EcX/fYs7VVJwIdCabR9KYqFDEn04/f4vnb61IaWOcMFNniGLToIHs+XMxYYFBb50fE2Ng6+ZjlC3Wnbr1x+IbGIlBgz2PHKjYtRONBveP76cghBBCCCGSOClKCSESrKZfe5i2p09coTDJ51m1YBMxmnH8ecFqlRSnEYlJ0+6tmDmyHvaWxhn1vR8HUzBvNw78c+qjrt+68Qg53doxZNo+bgfZAFCmRWPq9O0eZ5mFEEIIIYT4f1KUEkIkSGVqlSOri7Gb1BP/KHZtOqw40ae7sv8QkWHhABSoWhGdXl5yxZcr93UV5k1tha2FsSB18eZziuTujPftx5/0OP7+IYzrN4mlg0aYlieu3KktDXp3jvXMQgghhBBCvIu8QxJCJEi9BjQ3ba/Z+HG9PxKayLBwrhwwFtNSuKSkQLkSihMJc5cxexZWLeuLk7WxIHXrYRClC39HYGDoZz/m6c07WDNqAgCFUoWxbEpDaraSyc+FEEII8fFefcBlY2OjOImIT69+3jFfMHeuTHQuhEhwLCwtqVbKDQBNg8kjFypO9PlCbpynXhcP3JJFkuLHZnTYd1R1JGGmLKysWLVjImkdjAUpH/8Iynr0ICQk/Isf++jqDdSqmo/K35YGwHPedxQ/dYV712598WMLIYQQIvF7/Pgx4eHhfPfdd6xatYqnT59+UaFCJGwWFhakSZOGZs2aER4ezpMnTz77sXSAFnvREg9HR0cCAwNxcnIiKOjtCWOFEHGn+XdNWT67HQAX7wRS0L214kSfL0/BbFw6Nw2Ae34GsqSqrzaQMFs/z/2F0V2LAhAZrVGixA+cP3Mj1h7fwcGWK3f+IqOLLQBn70dSPFsLYqKiYu0eQgghhEi8UqdOzTfffEPu3LlVRxHx5OrVq8ybN49nz5699bWPralITykhRILjkLMgW+8nI3fyCJYs3ac6zhe5cv4WD19EkiGVNZlS6MlXPD+XTlxUHUuYmewliuH8VTX+eRhOhXQhDBi8PFYLUgAhIeHUrPwTJ09Nw9ZKR+FM1oxfOJz+bYbE6n2EEEIIkTg9e/aMX3/9leTJk+Pk5IROp1MdScQRTdMIDAwkICAATfuyfk7SU+o/SE8pIdSwtrNlxN6t2NjbERoQyIiKdYiJjlYd64ssWj+WdvULADB50QkGdBypOJEwJ1a2NvRfuwSXTBkBOPTHHNbO8Iyz+3Xq0ZD5MzsBEBEDlWuP58jOg3F2PyGEEEIIkfh8bE1FJjoXQiQoeSuUxcbeDoBzu/aYfUEKYMn8LabtGlULKEwizFGN7t+YClK3T51l3czFcXq/BbPWsevIHQBsLGDRkv5YyqSlQgghhBAiDkhRSgiRoBSpXc20fWbrLoVJYs8/Ww4TGGZckSRXelvSZEqrOJEwF3k88tP02yYAREVEsGrEr1/cRfpjNK/zM/4hxslJc6S2YNTsgXF+TyGEEEIIkfRIUUoIkWAkd0lFn5aFyJIskqCnz7h96qzqSLFC0zQOnb4PgJUe2nZrojiRMBczFw2kTY4gqqYP4sSyZTy7cy9e7uvvF0SP3n+Y9nu0KY573uzxcm8hhBBCCJF0SFFKCJFgfPNDKwq6RNEwSyClHB6iGQyqI8WaVcv3mLbrf11SYRJhLuq2/ZoKeZOj00Eup3BOrN0Yr/dfvmArR86/Wt5XR6dfvo/X+wshhBBCiMRPilJCiASjWdOypu2lC3coTBL7Vv65mUjjaCiK5EyFtZ2d2kAiQdNbWjBxUkf0Lxet+WPJYe7defL+i+JAuya/cOiuAc8bKbDPXYxcX0lBVQghhBBCxB4pSgkhEgRXt/QUcncAICRSY/mfmxQnil3h4ZGcvf4cgEiDjrJ1KihOJBKyrgM7kyuNJQAvgqP5sdsUJTlu3XhAr+9mEGkw/rlQp293Wd5ZCCGEEELEGilKCSEShG4/tcXq5SuS17G7REfHqA0UB8ZO3MiC6ylZdCMVyXPmUx1HJFAWlpb82LeOaX/0r2sJD49Ulufcjn+4f+kKABly56RInerKsgghhBBCiMRFilJCiASh0dfFTdvzZq5TmCTu7Fi1nRchxpXTcpctpTiNSKi6DelCllTG/z0/9ovkt3FLlebRNI0tU38HwMEyhnFTumFhZaU0kxBCCCGESBzMqihlY2PD/Pnz8fPz49GjR/Tr1+8/z61duzZnzpwhKCiIc+fOUa9evXhMKoT4FDkK5CR3ehsA/EJj2Py3l+JEcSMiJBTvM+cAcMmUERe3TIoTiYTGwsqK/n1qmfbHjP0bQwKY8P/GsZOkeXGZjjn9qJrDgkGTvlcdSQghhBBCJAJmVZSaOHEiHh4eVK5cme7duzN8+HAaN2781nkFChRg7dq1LFiwgMKFCzN37lxWr15NwYIFFaQWQnxI9x9bY/Fympqd+66jaZraQHHo6sEjpu185UorTCISot4jviNzCuP/mh8+j2D25JWKE722Y+kG0xDbnp3KY2VrqzaQEEIIIYRIFDRzaPb29lpoaKhWoUIF07HBgwdrXl5eb53766+/alu3bn3j2Pbt27XRo0d/9P0cHR01TdM0R0dH5c9dmrTE3m4+W6cZtE2aQduklataXHmeuGzZCufVjj7drT0J3aodub5MeR5pCafp9Hrt3KP1pn8LXfs0VZ7p/9u1BytM+X6e0k95HmnSpEmTJk2aNGkJs31sTcVsekoVKlQIKysrDh8+bDp28OBBSpYs+dZKQJ6engwcOPCtx0iePHmc5xRCfJoiZYuS1cW4ytgT/ygO7D6hOFHcunPhKgVShJLGLoaC7o5Y29mpjiQSiAJVKrDneRq23nfkxM0g5v22WnWkt/wy/PX8Vj26VJS5pYQQQgghxBcxm6JUunTp8PX1JSoqynTMx8cHOzs7nJ2d3zj36tWrnD9/3rSfN29eqlSpwj///BNveYUQHyddsZIsvZmCU762LFt7SnWcOBcTY+Dc9ecA2FlCw3a1FScSCUXFDq0xoONagA1t201NkMNYl/25CW+fMADSOer4/pdvFScSQgghhBDmzGyKUvb29kRERLxx7NW+jY3Nf17n7OzMmjVrOHToEBs2bIjTjEKIT1e4ZlWehlvi9cCWEQN+Vx0nXmzb9rr41qhZBYVJRELhXqQgbgXzAfDo2g2uH0m4PQZHj349z1WfbtXQW1ooTCOSEhsHe+p/05y5m6dz5PYabvht4X7wVu4EbuX0g/WsObKAXmP6kNY9s+qoQgghhPhIZlOUCg8Pf6v49Go/NDT0ndekSZOGPXv2oNfradKkSYL81FmIpMytUH6cM6YH4OaxkwS/8FOcKH4smbvetF26qJu6ICLBqP1tG9P23kXLFCb5sIUz13Df1/ihUMYUerr0b6c4kUjsUqZzpfHQH1l0eiPr/mjDN3WyUtLdmmwpDGRwiCGzYwyFM1jQsFRqpv9clVvXf2fmzgXkLF1CdXQhhBBCfIDZFKUePnyIi4sLFhavP5F1dXUlNDQUf3//t85Pnz49+/fvx8bGhooVK+Lr6xuPaYUQH6No7eqm7TPbdilMEr+8bz7gwYtIwPimPneRPIoTCZWy5c/J5C55qJspkGRhTzm7fbfqSB80cfJ603bvXnXUBRGJmpWtDfV+6MXALav4qllDfKLsCY/RffA6e0sNO7ecfPvHdLov+h3X7FnjIa0QQgghPofZFKXOnj1LVFQUpUqVMh0rW7YsJ06ceKsHlL29Pdu3b8dgMFChQgUeP34c33GFEB+gt7BgVN9KFHEOw8YQxoV/9qmOFK8OHL1l2m7RSd7UJ2UDx3TF2gJyJI/EOeAmMdHRqiN90OyJy3gREgNAljS2FKpQUnEikdgUKl+c2V5LqNihFZYvJ9QPCQplzT+3mDhjJ+Ur/Exql9ZYWdYnmUMT8uXtTu/+f7H3xD1uPovGP9L4IWa2YkXou3Ihtbt3Qm8hQ02FEEKIhMZSdYCPFRYWhqenJ3PmzKFjx45kyJCB/v3707FjRwDSpk1LQEAA4eHh/Pzzz2TLlo2KFSuavvbqMQIDA1U9BSHEvzRoV4e8qSEvIaSJCiY8OER1pHi1/u+9tKxt7CFVpXJBRqiNIxSxsrWlYbVcpv3RP89TmObjxcQYmDL7Hyq2bMhlf1uKNmrIuX3HVMcSiUTbHzowY2wTbC3gr5sxPA+OZp/ncvZ6LifsHX/HhYZGcOXKfa5cuc/MyavQ6/UUqFaJmj2+IY27G1bWVsyb2JSLXSvSuFIvgv0CFDwrIYQQQvwXzVyanZ2dtmjRIi0oKEh78OCB1qdPH9PXNE3T2rdvrwHalStXtHdZuHDhR9/L0dFR0zRNc3R0VP68pUlLjG3T4bmaQdukGbRN2vDJvZTnie9mY2OlhUcbn39AxCZNb2GhPJO0+G89hnU1/Ts4f3uJ8jyf0iwsLbWhuzdoky8c0SaeO6S5ZM6oPJM0829jFo7UImI2mf5dnLqzSkvj7vZZj2Vpba3V7tNN2/twt+nxrvqs17Lmz6H8eUqTJk2aNGmJvX1sTcVshu+BsadThw4dcHR0JGPGjEyfPt30NZ1Oh6enJwB58uRBp9O91V71qhJCqGVta0v5osYJzmMMMGvCUsWJ4l9ERBRX7xk/8be3glLVSn3gCpEYde1SzbQ9a8ZmhUk+XUx0NAeX/Q2AXq+nXJvmihMJczdt1QR+al8Eq5d/nV6960+9Mt156n33sx4vOjKSrdNns3PRSmIMxmM501hw4PAU8hTLF0uphRBCCPElzKooJYRIHFp1a4Ljy8U0z970w9fnhdpAisxdtJ8Ndx2ZfSUV9plzqI4j4plHpRLky2gLQECYgfm/rVKc6NMdXb2BiNAwAMo1qkmy5I6KEwlz9dvqifRqkgf9y3nMt+27QeGcHXn08MsXqhk7eB71m0wgOMJYmUrnCHv3jaNA6cJf/NhCCCGE+DJSlBJCxLt2Haqatpct3asuiGIr5m/gdpANUQa9LF2eBP00vL3pDfjfm84S86orhxkJCwzC5/h+amYMomeRcL7/5RvVkYQZGjJzEN0b5Ub38t/Dyk3nqVOxH5GRsTfp/9Z1Byhf9kcCQo0T9Kd2gB07RuKW2z3W7iGEEEKITydFKSFEvEqW3JGSeZ0BiIyBedNWKE6kjt+jJ/jeewCAW6H8WNvZKU4k4outgz3VSmUGwKDB2EF/KE70+R4cP0qeFBFY6qFD63Kq4wgz07Zfe4Z2+8pUoF2+8Rwtvx4cJ/c6e/IapUv2Na0c6eqo45+DU3FOlzpO7ieEEEKID5OilBAiXnXp1xq7l+t+Hr3gQ3BgqNpAil0/chwASysrsnoUVhtGxJvOP7TG6eUQ1tPXX3Dn9kO1gb7Amr+288Q/CoCsLpbUaFrtA1cIYVS4nAe/j2tqmkNqz7G7tGkwNE7vefWiN5XL/0hwhAZAVmcLth2cgd7SIk7vK4QQQoh3k6KUECJetWj5uieF54IdCpMkDA/OniFPinBqZgzihwFNVMcR8SRnqRL4hBnfBP/5xzbFab7c4hWHTds/DGqpMIkwF3ZOTtQd/DPn/WzRNLjk7U/t8t+jaVqc3/v86evUrz+GyGjjvbJlcKTN8B/i/L5CCCGEeJsUpYQQ8SZFGmcKZnUCICRSY8mcdYoTqffsxnVqZgwmT4oIqpbJqjqOiAcp07kSnSk/y26l5Lf94SyYsVp1pC82Yeh8Io0joihfMDXp3NKpDSQSNJ1OR6uxw0iZIR1Hnzow+5/nVCndO1bnkPoQrx3H6DVgCTcDLFl+KwWFGjSkeP3a8XZ/IYQQQhhJUUoIEW/yVCzPwuup2P0wGUu3XCEqKv7egCRUt6/d47G/8fuQKaUlmbJlUpxIxDWPf73x3bRkc6L4d/DC15/dR+8BYG0BP435TnEikZCVb9uCvBXKABD8wo8hbX7kqY9fvOeYN20VbTv9ToTB+Odw46E/4pojW7znEEIIIZIyKUoJIeJNkdrVCI/Rc8HPlpGD5quOk2AcO2t8M6/XQfNO9RSnEXFJp9OZemMYDAZObTT/oXuvjBuxyLTd7OvC6F4tpSbEv+Qplo82P3YBjP8Glg4cgb/PU2V5jq3dxOFVxl67VjY2tBk3AmtbW2V5hBBCiKRGilJCiHiRIm0ashUrAoDP7Ts8unZDcaKEY8v61/PxVKtRVGESEdfK1KlA3hxpAI0bR08ofTMe2w7uPsGtJ2EAuDrq+bptHcWJREKjt7BgyZoRtM8TiodLKAeXrjQt9qDShvHTeHzjFsksY+hVPTVz14xVHUkIIYRIMqQoJYSIF4VrVjVtn966U2GShOdvz63EGIzbRfOkURtGxKkff25Jq2wBtMvuT+AF9W/GY9uS5QdN2z36NFSYRCREw2cNpIibLZZ6KJYqhBPLV6iOBEB0ZCQbR4+jdTZ/MiWLok2tHDTqWF91LCGEECJJkKKUECJeTBvdiCrpg8lgH8WZrbtUx0lQAv2DuO1j7GHibK+jQMkCihOJuGBtZ0eFYukBSGEdg9faxLf65LRRC4mMgefhFsSkyoStYzLVkUQCkatIHn7oXNq0/9PQ5Ty6n3B6Cl4/fZG1284DYKGDWb91JllyR8WphBBCiMTPUnUAIUTiV6h0QQpksEGnCyetZTDP7z9QHSnBOXryNjnq5QOgcesaXDh2QXEiEdva9miCo7Vx+/SNF/g8eq42UBwI8Aui9+TD5KpdD9BRpGY1jvwtq2wKmLdsCPaWGgCHzj5h1oTlihO9rXOTYZR/tILMLjakTabjj9VjaFWtt+pYIolxzpSB3IVykTVnJpySJyMyKgo/3wAunLrG3Ss3CA8OUR1RCCFilRSlhBBxrnv/lrya83jLrktqwyRQW9cfpO3LolTFivkVpxFxoU27KqbtpX95KUwStzYvWE2u2l8DUKJhXSlKCVr3bkXZ3E4AhEdptG40VHGid4uKiqZd6wns2T4UvQ6aVnZnYaMq7Fr7j+poIhGzsrWhZqu6tOtUkyJ5XcngpMPGQnvrvGgDTL+YkkdXb3Lj6AlOb90p83MKIRIFHfD2q57A0dGRwMBAnJycCAoKUh1HCLN2328DGVIYRwsXLTmQs8elMPX/7OxtCQj6G0s9+IWBs72swpeYOKZ0wufpUmwtISIaXFI2IyQ4THWsONN35SIy5s0FwMRGbXhy45biREIVu2QO3Hi4nPROxk8mxs/6h0E9p6kN9QGeG36l7dfGDwfuvYghR/rmREVEKE4lEhun1C6Ua9OMIf3rUjJ9zAfPfxFhgeeNlG8+RoA3+9dsY+lvyzDEfPgxhBAiPn1sTUXmlBJCxKkqDSqZClJ3n0VIQeo/hIWGs/vscw48sWfbo+SkzZpFdSQRi7r0a43ty77JRy88SdQFKYDj6zYB4GITTbeB7RWnESpNWjjEVJC67xvOkD6/KU70Yd+2GIFPYDQAmVNZMO6PgYoTicTE2s6Wmj278vO21VTu1JZ7EQ5vfN0vOJrjl3xYv+sqnqtPsXTDObYf9ObAibs8vHL9X2dqNCiWAs8pzbjyeA1NujaN3ycihBCxRIbvCSHiVI++TUzbf69PfKuNxabx03fw9QDj/CXZS3rgc/uO2kAi1rRoUc607fnndoVJ4sf5nXtYOa8T6ZMZCMxchNHdrImKjFQdS8SzTDmy0L5+AV51yv/umxnEvFpqNAELD4ugW7fZrF3aC4DvWnnw29gs3L12R20wYfaqNq1JzV7foUuZ1nTsjp/GvsBnHNl3hvm/reb2rcfvfQyHFMkpWL0yjTo2wDl/KgBypLZgxZx2HOhdnw5NhnL3qnecPg8hhIhN0lNKCBFnrGxsqFIyMwAxBpg+2lNxooTt5olTpu3sxYsqTCJiU5qMaSmc1biKV0ikxpK569UGigdBL/x48uQFAE420KlfK8WJhAqtfvyWKM3YS2rf6UdsW79fcaKPt37ZTvaf9QHAzhJG/DZAcSJhziytrZm5dhKbl/egaVEbQCM6Kop9i5czukZjKhXuxM99ZnywIAUQ4h/AkVXrGFy/M4PHbOBZYBQAeh1UyJecs2d/o9OPHeL2CQkhRCySopQQIs50+r4FjjbG7TM3/Xh4z0dtoATu0bWbhAYGApCteFF0r2aHF2at249tsXr5f9v9J+4THZ005v1Y+Ocu03a7f03yLpKG9Lly4FKiPJ43UrLb24JuHcarjvTJOjYfyZNgWH/XiRfpi+JetJDqSMIMOadPy8HLS+jeMBfWFpDJIZq0fleZ2LA1Gyf+RpDv563EGhkZza9D5pPRpRlT/9hHRLSxR2JyG/hjXGPWHJiLtZ1dbD4VIYSIE1KUEkLEmfYdq5m2PRfues+ZAkAzGPA+dYa0tlGUz25FsQoeqiOJWOCQNTdX/a2JMsC839erjhNv/py+kjDjB/gUy5kCl3Sp1QYS8apu3+7o9XpiNB2jRyzm6oXbqiN9Mu/r92jU6U+8g6wBaDioH3oLC8WphDkpUt6DU5fmUSLb6+LQpj3X+bZWd3zv3o+Ve0RFRfPDt5MoWKAnV+4ZP9jS66Bh2fScuLYY18zpYuU+QggRV6QoJYSIE47OKcmR2bhKTGiUxvxpKxUnMg9FU4XRKnsA5V1Dad6uhuo44gs5OqdClykP2x44MXJbMBuW71YdKd6Eh0Ww96TxTZe1BfQc1E5xIhFfcpYuQa4ypQB4/uARh5avUZzo8x1bs5H7l68CkCF3TorXr604kTAXFetX5p+dI8icwtjrOTJGo1vfxdSv8gMhIeGxfr8bV+9RwL0tMxcdxvBybfUCmWwZv342rjmyxfr9hBAitkhRSggRJwrVqMLiWyn529uJ2SvPEREukxx/jM3rXs+5Uq5sboVJRGzIX6UCer3xf7WntnuhaZriRPHrj5nrTdtNG5dSF0TEq19nfk9ya+Mw1W0z5hITFaU40efTDAY2jJv6ao9uQ74hWfJkSjOJhK9mi9psWNWPFDbG13y/kBiqVBvG3Gl/x+l9DQYDvTv+SuvOcwiL0jjkY4+vVVq6L5hFxrzyN4UQImGSopQQIk54fF0b0PEgxJpJIxaojmM2dm/YT7hxJXLyZUmOTi8v0+asYLVKpu1zO/coTKLGhmU7eR5iXG0tVzpb8haVN0WJXdNvGtOwqCMdcvhR0PI+Z7eZ/9Bt7zPneX7mKI2zBNKuiI5xc39SHUkkYHXb1OXvxd1xtDYWpB69iKBwvm855HU23jKsXLiFokX7snrPHcC4Yt9382eQpVCBeMsghBAfS97tCCFiXdps7mTKlweA+5eu4HNLlib+WNHRMVy9a5wTwsEKKtUtpziR+FxpMqShZpV8WOo0fO894PH1m6ojKbF1j3Hok14HvQa2UZxGxLVhw1sCxp/34W0HEk3vwKMrV5M5mbHHV8dGhUnvll5xIpEQZSlUgPHTe+BgZfy9v/s0jGL5unL/bvwv9HLt4i3mdOnFrZNnALBzTMaYFZOp3KDSB64UQoj4ZVZFKRsbG+bPn4+fnx+PHj2iX79+H7ymTJky3Lp1Kx7SCSFeqdC8vmn75MatCpOYp/2Hrpi26zeVPx7NVefvW1LfPZTv8jwnXXDSLEgBzBi/zLRdr3p+hUlEXGv6TWPyZTAuueoXGsOYgbMVJ4o9e7YcYv9ZY2HBzgpmeP6sOJFIaFyzZ6Xz75PY/Tg5twOt8H4SSrG8XfB58kJZpojQUOZ168u1Q0fJ5hhB05wRrFvRj+KViivLJIQQ/8+silITJ07Ew8ODypUr0717d4YPH07jxo3/8/z8+fOzevVq03weQoi4Z21rw9xhVWjq7k92hxDObDX/oRvxbcPK18O8yn6VS2ES8SUaNigJgJUeDu88rDiNOicPnePGk3BuBFhz0j8FGfPK73RiNXxES9P2jLn/EBkZrTBN7OvecQLRxtGo1CvnRsESUmQVRo4uznwzZyr2Tk5Eazomr7pGiYLf8uJ5oOpoRIVHsLDPQArYPcNSD442sG3LMPIWy6s6mhBCAKADzKJftb29Pb6+vtSqVYt9+/YBMHjwYKpWrUqlSm/3JOjatSuTJk3i9u3bJE+eHHd390+6n6OjI4GBgTg5OREUFBQrz0GIpKDn0C78NtLYU+r0TX88crRVnMj86HQ6giI2Ym8FYdHgZN+QmKjE9eYusUuZJhWPH3libQEhkRop7BsQE2NQHUuZUk2+punwQQDs+2sFGydMV5xIxLZmXRuzYm4HwNhLyjVFE6IS4evWyp1TaFotBwB7zjylatHOihMJ1SysrOizeBYZ8hvna7p34TJzuvQiIjRUcbI3pc+UlpMX5uCa3BKARwEGCufpgu/jZ4qTicTOwsoKt4L5KF3ZgyoV8+Pu5kIyBxvsbCwBAyFh0QQGR3Dn7lMunPVm344jnD98JtEM/07KPramYjZdiAoVKoSVlRWHD7/+tPngwYOULFkSnU731vm1atWiffv2TJ069a2vCSHiTpfOVU3bc37fojCJ+dI0jUu3/QCws4TqDWUIn7np1Ls51hbG7cNnHyXpghTAuZ1eREcaV+AsUqsaegsLxYlEbBsytIVpe8bcfxJlQQqgT6dfTYtRVCicBo/yRdUGEsr9tX0aP9XPiJNVDH6Pn/Bnz/4JriAF8Oi+D2VLfs+Ll4tPpE+uZ9eRmVhZWytOJhIjGwd7SjSsR5fZUxh1cAc9Fs2mXZ/WdKidjQr5klMsiy1501mSN501xbPaU6VgSjrXy8W0oTU5c/AXph3bSrvJYyhYrRKW8jua6JlNUSpdunT4+voS9a9lhX18fLCzs8PZ2fmt8xs2bMi6deviM6IQSV5+j3zkz+wAgH+YgYW/rVKcyHztP3DZtF23UXmFScTnaNT4K9P2ssUyhDUsMIjL+w4B4OTiTI6SHooTidhUo1l18me0BcA/1MCYnxLPXFL/78mDZ6zaegkACx1MntlbcSKh0o8T+9K8UmZS28XQIqs/a4YMJ/iFn+pY/+n2tbvUrT3CVFgt5GbPGq/f1IYSiUruYvlZ7vU7j3xX0XXcT+QpWxobezsA/CI+7gOpgEg90XbJKVS9Mu2njGWE12b6zhhOjgI54zK6UMhsilL29vZERES8cezVvo2NjYpIQoj/8+MvndC/7Li4YcflJN875Ets/NuLoCg9V/xtiHBIrTqO+ASOKZwomiMFAOFRsHzeRrWBEohTm3dgodPI7hRBv59bqY4jYtHQX9qZtv9ceijR9pJ6pX/XCYS9/Iy0TH5nylQrpTaQUKJC3Qr80rcyrwZsLFp2iCvHz6sN9RGO7j9D5+7zMbwcGVX3qwxM+HOI2lDC7OUrWYgtJxZy9tg4mlfMREpbjbwpwgEI8HnGiQ1bmTtsGj8M+ZtKVYeTPds3uKZti2vatuTO3Y3qdcYwaPQGVm69zI5jDwkNeD3Uy87JkR86luLimclsPfEnBUsVVPU0RRyxVB3gY4WHh79VfHq1H5oAu8gKkdRYWVtTt7LxEwyDBuOH/ak4kXk7sPMYUw4acErtSHjq7OgtLDDExKiOJT5Cu15NsXn5YeDRi0+IjIx6/wVJxI0jx+iY4zmO1hCaLit97O0IDw1THUt8oUx5cpDHPSVgIDRKY+SAWaojxTlfnxcsWX+Wb5oWRq+DPsM6cWjXUdWxRDxyck7BkiX9TK/1B88+pleHX9WG+gTL520gd74sDO1jnHKhb4eSHN1fj7WemxQnE+bGyTklUz2H0bJmDmwtNF5NV61pEHr/NtPaT+X+pderSnu94zGePvXn+rUH7N76+nVUp9eTvUQxitWtSYV6FUjvYPywo6ZHGqocGsNarzv0bj+aZw994vLpiXhiNj2lHj58iIuLCxb/mofC1dWV0NBQ/P391QUTQgDQ+YdWpDCO3uD87UCuXripNlAicOvkGQBsHRzIkFu6LJuLho3KmLZXLd+rLkgCExEWzvnrzwGwt4IOvZspTiRiQ5nWzVl8IyXb7ifj98XHCAoIUR0pXvzUbRJXn8Gq28m5n6IA6XPlUB1JxKMV26eQIbnxbdTTgCjqVuyrONGnG/79dNZ53QaMZYRWP3bFKbWL2lDCrLTt25YbdxfTsU72lwUpiDZobPjnOnny9qCqR9c3ClKfQjMYuHH0BCuGjGJcow6s++cGUS8/m7XSQ/MqWbhxaz4Dfu0ZW09HKGQ2RamzZ88SFRVFqVKvu0iXLVuWEydOyMz8QiQA3bvVMm3PnbtVYZLE41VRCiCbRxGFScTHsrCypERe43DLqBj4a85axYkSlmVL/jFtt2otE/ibuxRp01C0dg0M6Dh9L5IhvaaojhRv/J8H0PV7Tx6GWgFQo0cXxYlEfOk3thc1PYyv89EGaNZkLIFmWoxtUbM/x28Gsco7OXcNLrSbNBq9pSxEId4vRepUrDs8n4WTm5Ha4fXxbQduky3rNzSs+gPXr96LtfvdvfWAxlX74e7eiTW7b/BqdhAnGxg/sAbHby4ne77ssXY/Ef/MpigVFhaGp6cnc+bMwcPDg/r169O/f3+mTzcuK502bVpsbW0VpxQiaSpTvRT5M9kD4BdqYP6UFYoTJQ63T50FwEqvUb6GzFliDnKXLMYlfzt8wy244O1PSJAMT/u3hTNWmSbYLZ7HGaeUTmoDiS9Srm1zLKyMM0EcWrGGyLCk9ft+dPVG/J8Yh47kr1SedDnlTVFil694fkb2r2HanzhrN/t3n1SY6MtERUZRpXg3rt429mJ1L1qIOt93V5xKJGSZC+Tl5zULqVHC1TSP7O3HIVSqPpI65ftw/27cDad7dP8ZTav1o8RXP3H2pr/puEe2ZJw+PZXO/dvG2b1F3DKbohRAv379OHXqFF5eXsyaNYvhw4ebVth78uQJzZs3V5xQiKSpZIM63A40flq8bO0pYmTuo1jhc8ubeul96Z7nOT82cUenN6uX7CQp21elOPzUgb9upqRn/6Wq4yQ44aERHLlg/IPVxgI6922hOJH4XCnTpKJ2m3oARIVHcHDZ34oTxb/oyEi8Fi55uafRftC3SvOIuKW3sGDZ2uHYWxlHaBy/4svg3tMVp/pyIf4BLP5hMNEvVziv2L4VRaqWU5xKJEQlG9Wjx6LZWKRMw55HyYgxwMxFh8iVqRX7dp2Itxxnjl2maI629P9lPaGRxn+PyayhYe9ONBzUD0tr63jLImKHWb3DCQsLo0OHDjg6OpIxY0ZTLykAnU6Hp6fnW9d4enri7u4enzGFSFIcUqYgTYlybLiXnNmnrfil/0zVkRKVYP9A9DrjHDwVa5f58AVCqfyVjH/Ix0RFc87rkOI0CdPihTtN282bl1eYRHyJn8f1oGvBCOpmCuTR4T0Ev/BTHUmJo2s2kcbwnJZZAxjdPjfFKxRTHUnEkUodWxFlmwKAoAiNBtUGqA0Ui+5duMymSTPQo/FVmhD2bPqRzDkyqY4lEgi9hQWNBven2S8/mwo+2/ZcoWjJH+ndcZyy1banjPiTvLm/49ztQM6/sOVagC1lWzWl24KZODqnUpJJfB6zKkoJIRKeUk3qY/VyJczty7bg6/NCcaLE5fCR66btuo0rKEwiPiRtNnecM2YAjEMvwwKDPnBF0rR0zlpCIo3bRbInxzmt/OFobvQWFrRpUhydDnIkj+TSrn8+fFEiFR0RQfiNc7jaR6PXwa9TZehTYpQ2mzvVu3Vh35NkrLyZjJ59F/Hkoa/qWLHq4LK/yRN9g5JpwkhuC+t3TECn06mOJRSztrNl64k/Gfh9TdOxg8v+Zk6XXlw4+XmTmMeme96PKJq9DT17zCYqIgKALIUK0Gf5n+T2KKA4nfhYUpQSQnw2C0tLyjRvDIAhJoZDK1YrTpT4bFq737Rd5qvcCpOID2nQ/muSWxuHrl702v+Bs5Ou6KhoDpx+CBhX0Pm2f2vFicSn6tCnJWkdjW9Wbz4O45/NSbtX4M+9ppjmSqtQKA35PfKqDSRild7CgpZjhpp6iCz9fTV/zU6ci1j0bD2CUOMoPgq7J2Pin4PVBhJKJXdJxcFLnlQv4oyHSxiFUwazfPAo1v06hZjoaNXxTDRN4+CKtcxo09U0z1+JXCk5dWQsHfvK3xjmQIpSQojP1n1IF4rndEKHxqW9B3nx8LHqSInOPxv3E/Hy//t5sySXTy0TsB+6lqdTTj/aZffj0bnTquMkaAvnvV6hs0njrxQmEZ+jV+96pu3fZ29TmCRhePb4OWt3XgPAQg/jfuutOJGITRXaNidTvjwA+Ny+w/ZZ8xQnijs3L3vzw+CVpv1e7UtSvpa8RidFqTOm5djF+Xi4GxcyMmiwe9EqTm5MuCtsP7x6nWktOhF97yo1MgZhZwl/TG7B4El9VEcTHyBFKSHEZ9Hp9QzsW4s6mYLokMOPc+sT56eGqkVHx3D9QTBgnMTxq6olFScS75I5eyaypjF+im6IiuT2pVuKEyVsaxZt5o6fxrGndpwNT4d9clmFz1yUrFyCgpmNb1ICwgzMGveX4kQJw8AeU4h8ucZH9ZIZyJY3q9pAIla458nK37NbUThVGJohhhVDRxMdGak6VpyaO3EJmw/eA4y9Wf9aMgArGyvFqUR8Sp0xLYdOzyFnWuPPPSoGOnWfz69DEn5BNuj5C35t24eLtwMAsNDByH5VmbxoqOJk4n2kKCWE+CzdB3cknZPxJeRFQBhn9h5XnCjxOnzshmm7XtNKCpOI/9KhZxPT0sj7j99RmsUcGAwGeo/eyeGnDvjF2FCgisyXZi4Gj+7Mqw6bKzecISoq4QzhUOnBnUds3n8bAEs9TJjVV3EiERsW/v0LqWw1KqUPIYvfWe6dv6Q6UrxoWftHfIKMVdZMqSz5Y9VoxYlEfHlVkMqe2hKA8CiN+o0nsHjOBsXJPp7/i0BK5G7PjqMPANDpoG/7EizaPElxMvFfpCglhPgsP/SuY9qeOGm9uiBJwNb1B03bZcvmUZhE/Je6tT1M28sX73zPmeKVs9t3m7YL16qmMIn4WGkypKFq8fQARBvglwG/K06UsPzUcyrRLxehqlMuC5ncM6gNJL5Iuz6tKJ8vBQAR0Ro/fjNObaB4FBIUQpdvZmLQjPtt6ualagP58CCxS5nGmYOn/r8gNZ7tGw4oTvbpYmJiqFW6G8u3XTMda1cnF6v3/KYwlfgvn1SUio6O/uQWFRUVV9mFEIq06d6ULC7GLr2P/aP5Y9JSxYkStx3r9pqGheTPmlJtGPGWZMmTUTCrcfhZaKTGxmU7FCcyDw8uX8X3nvFTzOzFi8ryzWbg5/E9sDW+V2HvyYc8fvBUbaAE5tblO+w6ZvydtraAsTO/VxtIfDbHlE5MGNPCtD9ljhe3bzxQmCj+bVm5m1U7jCsAW+hh0cK+2NrbKU4l4oqtgz17TswhR5o3C1K7Npn3Qhata/fn96UnTPuNKrmzcvc0dYHEO31SUUqn09GkSRMqV678Ua1p06bo9dIZS4jEZuiw5qbtGXN2ommawjSJX2REJDcehgAQoVmQvWAuxYnEv7X6thHWFsbtE5efEh0dozaQGTmzfRfJrWIomTaC3kM6qo4j3sPCypKWDYqY9kcNWaAwTcL1U+/fTL1LGlbLjVNKmS/NHP2+bCRpHIzjVG/7hDG0z3TFidTo3Hgwj/yNQ3StbK1p+kNXxYlEXNBbWtBnzq9kT2csOkZGQ4PGE8y+IPVKzzYjGTfn9arITatkY/HWyQoTif9n+Skn79ixgz179hAYGPhR5ydPnpwdO+QTYyESk8792pAjrQ0Az4JjmDQs4U96mBiMn72X0u3aEh6jxyVnbm6ev/bhi0S8aNSknGl77eqD7zlT/L/Aq+fplMsPgLQtSjFGpuFJsPJXKseJF44U0YUT8CKAA7tkHsF3uXjyCocu+pLOLT0nn9lRoGZ1Di1frTqW+ARFyxalWfVsgHHFsY5tJ2IwGBSnUiMsNJwO7afyy9whnHiejIKNm5Jp7U7uX7qiOpqIJTqdjua/DCZN4RKs9I7h64z+9OzxOzs3Ja6/Z37uNhG9Xs+PXcsSbQCHPB7U7NWV7TP+UB1NADrgs7o42Nvb06VLF3Lnzo2Njc1bX+/cufOXZlPK0dGRwMBAnJycCAoKUh1HiARBp9Ph7buWzKmM9ewfR29i0lB5MY8PmQvmo8/S+QCc3rKDpQNHqA0kAOO/iRehG0lua5xjJ3XqNgS8CFAdy6w8CVxPGkcLNA3yFOrH9Qs3PnyRiHdd50wlV5lSACz5vj9n/kkcn6DHhfS5svPDauOqhM8fPGJc3WYYYqQHpbk4fnM5HtmSAbD2nxs0qdpPcSL1qnbtQK1e3wLw6NoNprboiEF6BScKtft0o0qXdgBERUTwZ48fuHHslOJUcWfC/EFkrVKTu8HGFZO3TPudPX/KKrJx5WNrKp89tm7FihUMHTqUlClTotPp3mpCiMSnz4hvTAWph35RTJZeUvHmweWrRISGAZDVo8gHzhbxpWqDiiS3NW5fuR8sBanPsHO/cc4SnQ66D2ipOI14l1QZ0pkKUr73H3B2z2HFiRK2R9ducuWA8XvknDE9BavJqqnmon2fVqaCVEikxretRilOlDDs+fMvHl4xvlanz5WDiu1bK04kYkOjbi2p0qUtAIaYGJb8ODxRF6QAfuzyK1MHvZ7svM733SnZqJ7CRAK+oChVqVIl6tWrR8uWLenUqdNbTQiRuOgtLajVrIZproxRY1bLXFLxyBAdw91zFwBIkTYNzhllVaeEIIdHYW4HWhFlgJ27z6uOY5b+mL7GtF2vZiGFScR/KfGvP9iPrdkkr/0fwWvBEtN2pY5tFCYRH8vS2prBQ17PmTlp5k6eP/VTmCjhMMTEsGrEWAwxMTjbRLNwagtKVfb48IUiwarWqApLZ7SiTqYgLHUa68dP4+KefapjxYtDK9awZdrr1WNHT+9D3xHfKEwkPrsodeXKFezsZAUGIZKKMs0bczE6PYtvpGDbWX/+mLxMdaQkx/D4FlXTB9Ehxwt69m+mOo4ALLPkY8O95My+4szUMdL9+3Mc3HWMxwHGYSDuqa3J75FXcSLxbxaWlgwbUJcM9lHEREVxYv1m1ZHMwq2TZ3hw8TI5k0fwY700dOjd/MMXCaUqtGvJzqcunPa1xftpBKMG/P7hi5KQB5evEXRsN62z+5PJMYbFS3+SBa3MVI6COVmx5HtsLCBn8kgy+J5JcnPf7fnzL/Z6LqN0mhCqZAxj/NCvadO9sepYSdZnv5J06NCB2bNnM2zYMNq3b0/btm3faEKIxMMhZQpqdO8CgF+kJd+1/VVxoqQp8P5dCqSKIKWNgfIV8quOk+QlS5WSTPnzAHD/2i0eeSet5cJj03av15Pmdv+hxXvOFPGtQ58WlMqko1nWAIpbehP0/IXqSGYj+vJh6mQKIq1dDAMGNFIdR7yHU5rUVPmmHREGPV4P7ahQcVCSndz8faYPmkJAmLGnZHZXW8bM6q84kfhUTqmSs/2f8aR82bfknm8EHeoNUBtKkc2TZxL++B4AlnqY91sHajWprDhV0vTZRalvvvmGHDly0K1bN4YPH84vv/xiaiNGjIjFiEII1Wr27IqdkyMAx9dv5v7Fy4oTJU2bVuwi+uXfyIVyplYbRpDrq5KmT4mvHpA5dr7EnKmrTNu1q0nBNSH59rtapu01K/YoTGJ+fv/VE98Q44t2noz21Gwkb3YSqrp9u2Njbw/A4VXreHBFFlx4l4AXgfT76fXQ1D5dypEzfzaFicSn0Ol0bNo/E3cX4/ywgeEGqpTtR3BQqOJkamiaRo2S33LmtnECbhsLWLW0L8XLylQC8e2zi1KdO3emZcuWpEuXjqxZs77RsmWTFychEouKdcrSq1t1LHQa4cEhbJ02W3WkJCs0OBRvn3AAUtnryFskt+JESVvl+hXR64yfGF85cERxGvN2Yv8ZHvhFA5DZ2YqiZQoqTiQAcuTPQZFsTgAERWjMnSTDtj9FTHQ0fy55/dowbEwHdWHEfypV/SvK1q8OQGhAIDtmySIu77N45iq8zj4FwNYSlq37RXEi8bEmLx5BuXwpAIiKgUZNxnPr2j2lmVSLioiiQtFvufEkAgAHa9iyfSSZ3NMrTpa0WH7uhb6+vly6dCk2s4gExDaZA2kypiV3HjecU6fAOXUKbO1s0FvosdDr0VvoiIqKISgghKCAEA4evkJIQBBBvs8JDw5RHV/EEr2FBfMW9CVbmjAKpIrg+xGbZOiGYifO3CVHulwANGxVnctnripOlDRZWFoyrF0+LC1ecPW5jgEvJ6EXn2/bP5f4ponx08lufZvzzSGZOF61ASM7YfFyQeUtXteJioxSG8gMjf5xJj06liGZNZTIlZKiXxXk9GH53U5I5s7/npzp/Tjpa8ewiQsIDQhUHSnBa9dgCFeu/0EyayiaPTl9R3zD1BFSzEvImnRpRM9WRU37g0auZc8W6eUNEBwQRPni3Tl96Q/SOVng4qDH6+hvFMrenpAgeV8bHz67KNWjRw9mzZrFyJEj8fb2Jjo6+o2v379//4vDibhjYWlJ4ZL5KFWhCIWK5iBbVld2Xw0j2j4VKVzTYOvgQHanCOplDvqox5t+0RkDxr9co8IjyGPvR4E0Bh4/C8bb+xlXr97jwunrHD9wlsf3nsTlUxOxaNKCwWRLYw2AITqatTMXK04kdmw5SqvaxqJUxUoFGKM4T1JVp3l1HKwBNKIC/DBEx6iOZPZ+n7ySKjU8uB5gg7c+k+o4SZ7ewoKGNfKZ9scNW6AwjfkKCQxm1ZaLdGqYH70ORk/uRu3S3VTHEi+17tmcApnsAI38TsEcW7tRdSSz8PDuY0ZN2sr4n2sD8MvAeiyfv4EnD54qTibeJUeBHMyf2RHLl2Ok1u2+wZSRC9WGSmB8HjylRpWfOXhwPE42kDWNDf+cmM1XeTvI/HLxQAd81rq+MTGv/wD/99LAOp0OTdOwtPzseleC4OjoSGBgIE5OTgQFfVxhJqHS6/WUquRB9a/LUKpUbvJkT4NrCkus/m/w5to7TtwNtjbtZ3aIpLH7hz8tijHAb5dd3jhWKV0whZ3D33m+X5iG98MgLl55wN4951j91zaCn8uSuwlN4dIFOXpgDNYWxv1W38xnxfwNakMJnFI68tx3GRZ6eBZsIK1jfdWRkqS/tk6mda2cAIyZuZehvSYrTpQ49Fn2J5kLGFff+7VuM3zvygdcqnTo05IF01oBcPleMPndWipOZL7SZXbl9u152FhAlAFy5uzG3VuyMIJqOr2e28/W4JbK+J5l+KQdjBowU3Eq83Lq1jKKZDXOObr75GOqF++qOJH4f5Y2Nuy/vIRSWW0BuP4olAJZWhMVFf2BK5OmGo0qs35VX2xevv9ZseMGrWr2UxvKjH1sTeWzK0fu7u6fe6mIR1/368GycTWxt/rwucmsDESGheP/xIcAn2c81EJwLJyKwKAwAgNCCQ2LwBBjwGDQQNOwtLbEwd4GKxtrDuzfg52TI04uzji6OKNzSfGf90lppyNldieKZs/LVxUKU6BzL57duYf3mfPcPn2W0Ad3uHRShoaqpNPpWPr3EFNBasexh1KQSiAC/YK46xtB1jQ2pE6mJ0e+bNy4dEt1rCSnfMmspu3Fc9YpTJK4nN2+21SUKlyjCrv/WKQ2UBL2Xfc6pu15f+5SmMT8Pb73hG2H7tKgvBtWehg9vQ9t6ybN1a4SkgFju5sKUo/9oxjz0++KE5mfdk1HcfL4BGwsoHKxdJSvU4H9W/apjiX+pfHg/pwKT0/qwGBSW0dQs8IPUpB6jx1r99Dn54z8Pq4podF6orMVp2Sjehxbu0l1tETtk3pKbdmyhZYtWxIY+HFjrZMnT86yZcuoU6fOh09OYBJDT6lkzin5Ze9W2mTzI7Xdv3u2gW+IgXtPgrh+04cL525z8shFzh6/jO/jZ7F2fzsHO4qWLkDhEnnJk8+d7NnTkc0tFRldbEzV5yM+9hx9Zm+6RodG9zwvCI8ycPraM3ZsO8XyeRu4d/thrOUSH/bb0l9M484DwjSyZ+nA86cyl1RCsXzHFJpXzwHAwF+3MuFnmXw+PmXLl40bF6cB8MAvisypZKn32JLCNS1Dd60H4PGNW0xq1EZtoCTKPU9Wrl+cjoUegiM1UidvSkR4hOpYZi1f0TycPTkBCx2ERUGGdG3wfx6gOlaSZetgzz2fFbg4GKee+KbvEv6ctlJxKvM0ZdEw2jQvxe6HyTh9/h5Tm3UgJlqKHglB8QZ1aDFqCAARoaGs+fEnTu07qTiVeRgy7Qcy1WxIcJSFcdGKHv25dviY6lhmJ056StWsWZOKFSvi5/dxQ61SpUpFjRo1PuUWIhYFP/fjyOr1FGlTkuS6ME6dvcPe3afYsXZvvBQYwkLCOLT7OId2H3/juF6vp1i5wlSsVoJgy+RYpM9Kpvx5sLSyIrVtDNYWGtYWOioWSkPFQrUY+1MtHvhFcejEHVb+tZNNy3fK2N44VLtZNbq1eD0RYr+BS6UglcDs2nbcVJSqWLkwExTnSWradn09ZPLgMW+FSRIf/yc+3Dt3gXJlclG9YhqOVS/FgZ1HVcdKcnoOaofFyyH+2/belIJULLh0+gqHLvpSLr8L90OtKd+0HhvnLFEdK8kaM6u/qSB17WGoFKS+wIAuY3lo/wfp8+QhXY5sVOzQmn/me6qOleSlcXej4aAfTPt//zKeM1KQ+mijv5/M1z9GU6FtCywsLWk3ZQwz233L4+syOiEufFJPqX/PI/WxzHV+qcTQU8qcWNrYkClfbmo0qEiP9qXJmcEBK4t3nxsUoXHswhN+HrKUM3sOExMlqwHFlrQZ03Dh6jxcHIzvRtbuuU2TKn0UpxL/L1XqlKw/t4pHYTacu/SAX79upTpSknL02l+UyJkCgMbtfmfdX9vUBkpkJi8cQt8OJQFYtvUaber0V5woadHpdPy8bQ35c7iQP0UYHeoN4JSsFhcrPCoWp9vcqfhHWuB7/wHj67XA8Bl/W4sv45IuNbfvLCDZy2lU6zadytbVe9SGMnMZcuekz/I/sbC0JCoigkmN2uB7T+ZNU8XWwZ7tZzy5GpOOkGgLjqxez+pfxquOZXZ0ej3tJo2mYLVK6NAo5vCM7o1/5NKZa6qjmY2Prano//Mr72BhYfHJLTYLUjY2NsyfPx8/Pz8ePXpEv37/PelY4cKFOXr0KCEhIRw/fpyiRYv+57lCveiICLxPn2POsOkUcGtBqpQtaN9zMWv33Oah/5tdgB1tdJQunJ5Wk35l5IFttJ00mqJ1qmPn5KgofeKgt7Dg99UTTAWpu76RtK77o+JU4l1ePPNjtdddHoZa4eLuTrJUKVVHSjJsbG0omDUFYByCs2mFzLUT2+ZMXsGr9VOqlc+hNkwSlLN0CVJlSMejUCumr7woBalYdHLvCY7uOQGAS6aMFKhaUW2gJGrqgkGmgtSxK8+lIBULHl69zv6/jL3NrG2sGbdoJDqdTnGqpGvp1omUz2FLm+z+2PvdYcP4aaojmSXNYGDZz7/w+PJlvnYLpJy7nl1e40iTzuXDF4tP8klFKdUmTpyIh4cHlStXpnv37gwfPpzGjRu/dZ69vT1bt27lwIEDFCtWjMOHD7Nlyxbs7e3f8agiIQoJCuGvWX/TpEofMqVsSM78fRg9cy9nbgcRZYDbgdZo6LB1cKBwjSq0HvcLF+6v4vzdFYyd/SNZcmZW/RTMTt1+PbjjkJOjT+0IjYKGdYcTESZDNhKqWydPm7azehRRmCRpadiuNrYvP2s5c/050TJZaKy7cfEmN54YV29NnUxP1frlFSdKWko1eT089ehqWeAitnktfD1kr1InmTMtvjmnd6V2RePKqQYNenaZojhR4rFz9nwsAx7TPGsAnSqlZtxs6eWqwreDOtKwvPF9kI1eY/3UOUTJEOzPFhUewcqfh+OojwTANbklXsdnYmNrozhZ4mI2RSl7e3u6dOlCnz59OHPmDOvXr2fChAn07NnzrXObN29OWFgYAwYM4OrVq3z//fcEBQXRtGlTBclFbLh56TbDek2mWLZWpE3Tht5dp3JiwxZC/PwBsLUwkMUxmvyZHRj4XTluXZ3Ftcd/M81zKPmK5lYb3gyUa92MCu1aAjoOPrShXI0xnD12UXUs8R63TrwuSmWTolS8yVeyMAGRxv91bt0qczPElY1bz5i2u/RooC5IEuPk4ky+iuUACHzmy+X9hxQnSnxuHj/F/UtX0KNRrXQWWn4rCyXEp6rdOrP0dkqOPLVj/V5v6QkYiyLDwjmxYgXp7I0f1vTuXJ6c+bN+4CoRm/IUyc2kX16/psxafIQd62Q1xC91/9YD6tb5hZCXM8bkyejAlkMz1YZKZMymKFWoUCGsrKw4fPiw6djBgwcpWbLkW91DS5UqxcGDB984dujQIUqXLh0vWUXc8n8ewL4121gxZDQjKtVlVsfueO/eQWD46+nRdDrI4WpL73YluHBqInd81zJv9RhKVCymMHnCVK7Z1zQY2Ne0v2bMRM54ycTCCZ33mfOksoqkcKow+naU17b4EpgqOwuup2ThVSf+/O1v1XESrd8nLMXw8iW9aplsasMkIb/O/J7WuYLJlzKcc1u2YYiW+Y7iwtUtG+mY049amYIZPqyF6jhJhmuObHh8XZsog549N2No22CI6kiJzpKZq/A65wuAjSUsWTNCbaAkxMramnVbx+BgZdw/eyuAvp1+VRsqETmx7xQdvp1H9Mu1tioXdWXe6tFqQyUin12USpYsWWzm+KB06dLh6+tL1L8mtfbx8cHOzg5nZ+e3zn306NEbx3x8fMiYMWO8ZBXxxxATw+2TZ5jUeySp7L+mTtNprNx1k2fBb67Ol9nZis6NC3LUawQjtiylRvcupMuZXVHqhGPg+B5sW9qVDPbGf1c7fp/PsTUbFacSHyMiJJSKLs+plD6EstltcMueSXWkRC9leldcs2cFdJw5cRWfBz6qIyVad67f5dqjMABS2eup06yK4kSJn06no3GdgqSzj6Z6hmAenTyiOlKitXPZJsIjjb1Jcqa3o27zqooTJQ21e3+HXm9867Nn/mLCAgMVJ0qc2jcaQrBxpBMeOVPSc1A7tYGSiAUbxpPT1ThZWkCYRt3KP6BpH72emfgIaxZuZPCE7ab9zo0L8dPY7xQmSjw+uyh14MAB0qZNG5tZ3sve3p6IiDfHw77at7Gx+ahz//88kfhsW/0PLav3Ja1jfSrUGMOiDZd46Pd6zpdHoZY4Zs5K9W6d6b/mLwZt/Ztf5v9Cg7a1TX+oJBVjZv/ImAE1sbfUaJQlgAde29g5+0/VscQnOHXuvmm7YZuaCpMkDbnLvu6RduXA4fecKWLDuo2vh0d2+u5rhUmShubfNCRNMuP/B68/CuP4vjMfuEJ8LkNMDPP/ej00ctjI9grTJA2VG1ahZFXja7j/Ex8OLFutOFHi9eD2Q36d/noRkNHDmuCSVhZkiUttezajZQ3jh+0GDTp3nc2je/LBWVyYOGgW89a+nuJk9E91aNqhjsJEicNnvws/c+YMx44dI1euXG8cL1SoEFu2bPniYP8vPDz8raLSq/3Q0NCPOvf/zxOJ24GdR+nUYCCZUjWkWJnB/L78NDtPPX3jHJdMGejd1oO1i7vhF7qeLUfm0KZbE6ysrRSljnt6CwtW7JrGoO/K8Wrk697Tj/mt7xi1wcQn27n99Zv2qtVlhdG4VqRyWdP21QPSiySuzZm4lJiXH/JWLuUuKznFsR69X09wvmjxXnVBkoixP80i8OXnp8VypKBEeZkbMC7N/r0bHXP6USZtCF7zFhIdIRM/x6Vff/yNC/eMvV2dbHV4rpVhTnHFPbc7Mye1Rf/yf5EL1pxl7ZJtakMlct82HsTu08b3lBZ6WPTHd/Ia/oU+uyjVqVMnFi1axMGDBylTpgw5cuRg5cqVnDp1ipiY2J+D4OHDh7i4uGBhYWE65urqSmhoKP7+/m+d6+rq+sYxV1dXHj9+HOu5hHk4c/g8PVsNp1P59vxSuR5rRk/k+tETuFhFkNzaONTP0UZHrVIZWPx7e/yC17LnzJ9892M77JMlnlUbM7ln4NTNJTSr+nqOlnV7valevGuc/LsVcWvdkm2meXeK5E2nNkwi5+DowJQuOWmVzZ881s94ePW66kiJ3gPvh1y+HwJAcjsdX7eqoThR4pXRPQMl86QCICwKfhu9UHGixC80KIQVm4yTbOt0MHqSDAGJK90GdSCHqw2WeshqF8yx9VtVR0oS2rUYTeTLPy1rfZWZBq2qqw2UCOn0ekbPH47jy74Yl++H8F3z4WpDJRF1v+rGpfvGwqt/lCV1Bv2EnZOj4lTm64vGK40YMYIpU6awa9cuLl68iKOjI6VLl+brr2O/m/3Zs2eJioqiVKlSpmNly5blxIkTb42XPXr0KF999dUbx8qUKcPRozJ5szCuKHR45VrmftObn6q1YORvezh7O8g0cR2AvRVULJyG38c35bnfSg5d9qRC0zrY2Jtvgapzv1ZcvDKHQlmM88EZNPht8XEaV+qtOJn4XM8e+/LghXE+sHTJLcicNYPiRIlXs85fY20Bae2isQl5pjpOkvHXsoOc9rVl+a3kGNLlUB0n0fpx1DdYvvyLcOdhb0JDwtQGSiKGff8b4S9nGKhYLD3ZcrupDZQIWVpbMXRgQ9P+mIkbiYqMes8VIracO3Ke+avPmfZn/94NG1trhYkSn6pdO/AkeS623HPEN0SjbpUBGAyGD18ovlhkRCSVS/Vg741IVnsnJ1lGN9pPGYuFpaXqaGbps4tSadKkYdq0aQwZMoTLly8TFRXFokWLOHHiRGzmMwkLC8PT05M5c+bg4eFB/fr16d+/P9OnTwcgbdq02NraArB69WpSpEjBtGnTyJMnD9OmTcPBwYFVq1bFSTZhvp7c92FEn6kUzdaKdOnaM3DsVo5d9TN9sgPG1UOK5HSmwfDBjDq4g56L51KzZ1fK1qmIg6ODuvAfKUf+HBy5+hfzJrc0fZISGgWdei/m+/aj1IYTX+zUhYem7UZtaylMkrg1bFLOtL15k3zAEV9m/bqYPfdteRJmRaHqlWUIXxxp+vXrYQcTRy1WmCRpefrQhy0H7gBgqYex0+VDotg2bMr3uDoZ3+7ceRbB9JELFCdKWvq2G8m9F9FoGjyKTka5lo1VR0o0snoUofp3nQC46mfJV5WGc+fG/Q9cJWLTs0fPaFK5F36+fgDkKOlB0xGDFKcyT59dlPL29qZ8+fI0bdoUDw8PGjduzB9//EH//v1jM98b+vXrx6lTp/Dy8mLWrFkMHz6cdevWAfDkyROaN28OQFBQEHXr1qVcuXKcOnWKUqVKUbt2bZlTSrzX86cvmDB4NqXztMPFuRU9Bq1m37lnhEXB7UBrDJoOCytL3IsUpNq3HVmyYiB+/iu48nAVS7ZO4tsBbRNUT5WU6VxpNLg/3Rb/Qf6sryeYvHgvhCJFvmfxTFnOPjHYue31BwGVq8m8UnGlVGHjv22DBkvnrlOcJukICwzk+tHjgPE1za1gfsWJEp/Gnb4mraPxz8GbT8I5/M/JD1whYtPQvjNNPbW/rpwT5zQyIXRscUrpRK/O5U37Awd6KkyTNEVFRvLNN7NYcTs5ex8no/J3XUjhGn8LZSVWDimS03rcCPQvp7XZMftPbp6QxSlUePHgEQt6DSAq3DhPXdmGNZm2dKTiVOZHB3zWWpHNmzdn5cqVbxwrUqQImzdvZt26dfTs2TM28inj6OhIYGAgTk5OBAUFqY4jFLK2taZwhVJkKFacHCU9SJs1CxY6je55npuGO/zb8xAD1+74ceHifc6cvMqOTYe5e807XrKmcE5O625NiMiQj1ylS5j+Z5U3RThl0wQzfd4+hvScFC9ZRPxIkyE1j+4vQK+DxwHRZEjR8MMXiU9SvEJRju39BYDrj8PJnb6p4kRJi8fXtWk5ZigA+5esZMP4aWoDJTJ7zy+kfAEXAIZO2smYATMUJ0p6dp9ZQOXCqTFoMHjKHsb3n6o6UqIwd/VYvmlcAICztwMpmq214kRJV+MhA/iqeSMALu09yIJeAxQnMm8HLi8hMFkGrgbYcuPYSeZ27YMmw/aUKlClAj1njKKRezDOtjFMnLufn76bqDqWch9bU/nsotR/cXNzY9u2beTNmzc2HzbeSVFK/BenNKkpXq0Mg/vXo3Cu1KSwe/9wkrV3nLj6OBKfW9743n+AfVQQ7i4WXL96j+uXbvPg9iMe3XvyyWPArW2tKVAsD19VLoZHidyULOZO1rS2WOrhr5sp8A03jmmOCA3l8Mo1HF/5N08fylw4idGd52vJnMq4YmRm9295cOeR4kSJy7TFw+jdtjgAc1eeoVuLYYoTJS22yRyYdHgzeV000lsFkz9dQ6KjZWGG2GCf3IkTt1eSK2U0EdGQ1qUlwYHBqmMlOWWql2LGslGc9rXjtrcP4+o2wyCLj3yRjO4ZuHZ9DnaWoGlQqdYY9u+Qodeq2Dom46cNy3FKbSyAL/tpKKe27lacyjxNXjSUvu1LAHD0AdQo0oEg3+eKUwmAsXN/ZmDX0oDxdaf3oJXMGr9EcSq1PramEuszcd29e/etScaFSEwCnz7jn6Xr+WfpegDye+SlRoPylC2Xn/y5XcnsYoPVv3pQPQ+3wM4xGVkKFyBL4QIUSBlG1QwhbzymQTOueBQSaSAyykBUtIHHfpEs2vMYLcaAhZUlFlZWtC3ngltqG5zsLLC3Mq7Y8y55U4Sz/lQQx9dv5tDy1YQGBMbRd0MkBPuO3aHkV/l4EGJFpgL5pCgVy6pWymfaXrZQVm2Kb+HBIZSwfYRHOidAR8uuDfjr9zWqYyUKxerVYvujFBx4GsOjA7ulIKXIoZ1H+f3vC+QpWxrnjOkpWK0SZ7fLG/Yv8dvCQdi9fJez96yPFKQUCw8KZt2vU+gwZQyFncPpvKYPRQpew1vmQPok1RtVplfbEqb9xTNWSUEqAfn527HkzDWLRhUyo9PBtLHNef7MnxULNquOluDFek+pxEJ6SonPZWtnS/lapSnxVQHyFXRn940YXLNnJVX6dACUSRtCidQfXtnIJ8ySZbdSvHGsubs/6R2i//Oa5yEGTl32YcEfW/n7zw1vrUwpEqd8FcvSaYaxi/D+v1ayYcI0tYESkZQuKfDx+QtLPfiHaaSyj/3VZcWHDRjbjfGDagOw++RjqhfvqjhR4jBg3VJcs2cFYPzXLXjqfVdxoqQrW/GidF8wC4CHV64zpVl7xYnMV5osGbl8ZS6pbA1EGaBQkX5cPX9DdSwBrD2ygAalUgNw9NIzvsrfSXEi8+GcNhWXby4kdTLjJ98b99+hQYVeilOJ/6e3sGDv+UWUzZsCgMgYqN9kIjvW71cbTBFlPaWESOrCw8LZudaLnWu93jhubWdLynSufFWxMKW/ykNWd1fSpHEihZMdjg7WONpZYm+tw0oPFnqIecdovhhNR7QBgiM0/EOi8PUL48YtH06fvM4/Ww5x9ujFeHqWIiG5ffocBoMBvV5PNo8iH75AfLRWXRuY5o47dv6x2jBJ2LzJyxn1Y22sLaBMoXRY21gTGRGpOpZZy1K4oKkgdevUGSlIKXbrxGnuXbxM5vx5yZQ3BxUbVmXvOukt9TmqfdeFJbdSUjhVGN6nTktBKgHp12EU1S78hoMVlMqXmq59m/PH1JUfvlCwbvcUU0Hq/vMoWtSKu8XFxOczxMRQvURXjlxeRKHM9lhbwJpV/alaNYij+2Uy+v8iRSkh4klkWDg+t++w7vYd1i1Y/95z9Xo9tg52GNBhYWFBdFQUMVHR9I+OlokMxVvCAoN4dPUGGfPmIl2u7Ng5OREWKEM2Y0Px8kUwaKDXwcb1h1XHSbL8n/tz+oY/pXKnwM4K2nZrxJ/TVqiOZdZa9myBHg0DOo6t3qg6jgAOeC5jyoKfKeoSztezvyWbFKU+WYbcOSlapwYxGuy/GcnYliNURxL/cueaN5Pm7md4T+OqiOPHtGLtsp34+vgpTpawjZjej7L5nQGIiIFG9UcQHhqhOJX4L+EhYVQs+i3HLy0gR1or7K10bNs+grJf9efSWSmSv8s71g4TQqhmMBgIDQohPCiYEP8AIkJCiY6MlIKU+E+3Tp3BQqeR2TGaqo0qq46TaNzUZ2b2lVSsv2XL8nnrVcdJ0laueN31vU37qgqTmL+0GdMwokMBuuR6QWFHP87t8vrwRSLOndnpRQ6HYJJZGXBPa0uLTvVURzI7dX94vfr3rrkLCQ8Oec/ZQoWRfSZz+aGxoJLcTs/KreMVJ0rYvqpakoE9Kpn2h4/fwqlD5xUmEh8j4Lk/FUr04IG/cdGK5HZ69h6YSOasGRQnS5ikKCWEEImAY6gP3fM8p6l7IF06V1MdJ1FIm82dlOlciTTo2b77Iv7PA1RHStL+nLac8JdT6pXMnxY7B1u1gcxY/1++wcoCHKw0wh7dJTpCPnFPCDSDgTkL9pr2h/3SWl0YM9Sg/deUKF8UgOcPHnJ41TrFicS7aAYDrZuOJOLl63mlouno/qP8rr+LYwpHVq0ehLWFcf+fU4+ZMHiO2lDioz2595hKZfvzLMQ4x+/DSAcajx2FnZOj4mQJjxSlhBAiEfhnw170L1djLJY/vdowiUSecq9Xkr1y4IjCJAIgOCCYk9deAGBrCe17NFGcyHy1bFTctD3l12UKk4j/N27g7/i+fAOTO6MDDVpVV5zIPOgtLPhtakfa5fCjYrpg9syZT0xUlOpY4j+cO3KeSfMOmvbHj2pOZvd0ChMlTN/8+hNO9lYA+ATG0LjqD4oTiU9169JNqlQezN47Ov555EDGfHn4dt5v2Dk5qY6WoEhRSgghEoEn95/wyN/4sWO65Jaky5xWcSLzl6dcadP2lQMyn1RCsHzZXtN2qzYyTPVz1GtZnfQpjB+733kWyZ5NBxQnEv8WFRHB3MWv36yPHNNBXRgzMmh8DzKmtMRCB6n1QRzftFN1JPEBw3pM4Mwd4/BKB2sda7aNU5woYSnZqB4ZylZh6a0U3PTX06zprwT6y4rw5uji8Qu0rNKTQF/jB2uZ8ubmOylMvUGKUkIIkUicuvAQAJ0OGretrTiNeUudzplxbbJQPUMQKUIf4nvvgepIAlj02yrCXg758MiTGhtbG7WBzFDv/s1M20tWHlKYRPyX0f1n8CLMuJ0/iyO1Gld6/wVJnINTMvp1fz3P3M9DlmKQOTgTPE3TaF5vCMEvF1LN5u5Cufoy/QBAxry5aPizsVdUaLSe5q2mcWDnMcWpxJfwuX2H2Z16EOj7HIAiRbNx7Y4nhTxyK06WMEhRSgghEondO0+ZtqvWKKYwiflr820jHK018qWMIHXUU9VxxEthwSGs3X+ffx46sOhGKtyLF1Udyay4uDpTrpCxF2VENEwZ8afiROJdIkLDmL/sqGl/zPjOCtMkfBP/+JGUdsbx6xfuBrPk9zWKE4mPdfPiTUZM2s75F7YsuZmSyn1645AiuepYSjm7pqb95LFY2Rg/dDmwdBVntu1SnErEhqfed5ndqQd2Yb40yRJAxpSWHDg4gYo1SqiOppwUpYQQIpFY+9c2NONUJBTLL6t7fIm6X5c0ba9fc/A9Z4r4Nm70cs772REWo6dwDVmF71P0H/mNacJcr1MPZfL+BGxUv+n4hxu3C2dLTpW6ZdQGSqAyuKWjfeMiAGga9Ok+U3Ei8ammDJ7FjBXniDLocErtQvNRQ1RHUkav17P7yG90KuOArYWBO+cusGnSDNWxRCx66n2X33v+jH+YsTdnMhsd2zYPoVGbGoqTqSVFKSGESCQe33vCw5fzSqVPIfNKfS6dTodH3jQARMXAyj83Kk4k/u3qwaOEBQUDkL9yeSytrRUnMh+tm7wutk4bv1JhEvEhIYHBLPr7de/X0RO6KkyTcM3w/Bk7S+P23rNP2btVhqSao1XDfyXouXG+nXwVy1K+TbMPXJE4zVszhkJZkuHuGEX9jC9Y/MNgYqKjVccSsezi8QuULt4H7+cxANhY6ljh2ZPvB7dTnEwdKUoJIUQicvriI8A4r1SjNrUUpzFP1RpUwNHGOBTk8r1gQgKDFScS/xYTFcXFPfsBsHNMRq6vpNv7x6jbvDoZUhrfvd99HsXOdV6KE4kPGd57Cs/D4LSvLWcMWUiVUVZW/bfCpfJTt1wWwPgBQs9O49UGEp8tyPc5ywePAsDJKoZlczrQqks9xaniV/dBHejYID9g7PU3ZMgSAnyeKU4l4srda96ULPANFx9GAGCphymjm7Jw9Uh0Op3idPFPilJCCJGI7N5x0rRdrYaHwiTmq3nb112od++5oDCJ+C/ndu4mg30UldIFM2O6zLfzMTKVLM3JZ3aERev4a7msJmkOgvwDadN/PfueJCNMs6Zql/aqIyUoM+f3x/LlO5m1/9zkytnragOJL3Lt0FGubVpH6+z+pHeIYc7Mb3DLmjQKsRVqfcXkUY1N+3+uu8Ci36Q3a2Ln+/gZpfJ0YP/l10Pp2zcuwuELf+KU3EFhsvgnRSkhhEhE1v61HYMGLyIs0Cd3Vh3HLFUok8O0vWT+JoVJxH+5efQUNTMEUNg5nHL5XcjgJkNV38c2mQOZylTggI8Dv520ZsKQOaojiY+076+VhAUal4H3qF8bl8wZFSdKGHJ4FCJnNuMw65Ao6NNxjOJEIjYsGD6VW0+Mk6kls9GxZc8k9PrE/XY1k3t61qz+CZuX8/0dvvyCro1/VhtKxJvQoGAqF2rP/I3XMbycF7ZkvtScub6IZKlSqg0XjxL3v3IhhEhiHt17zMitgXjeSMk1MmGbLGl90vKlMmZJj3tq44o3PoExnDsqPaUSoqjISP45dg8ACz30GdxBbaAErmidGtjY2wFwYvNOggNkSKq5CA8KZu/i5QBYWFrydR+ZWwqg5vc9WHIzBXseOfDbgkM8feSrOpKIBdFRUTSq9TOBxhFN5HVzZPGGsWpDxSFrW2t2HZpOKnvjW/J7L6KoVaan4lQivhmiY+ha/wf6jt5K+MspxC6Hp6b1uBFKc8UnKUoJIUQic/6gcQif3sKCbB5FFKcxL22+bcCrofyHT99XG0a81+xpq03bTRoUV5gk4SvdtIFp+8jf65XlEJ/nwF8rCfd/gYdLKDN6F6VBq+qqIylVtE51shQqgIaOHSeeMLTnRNWRRCy6ceE6vQeuMPUaaVU3H31+TpwTQG85MJOc6WwBCIqAWpUHEuQfpDiVUGXGsNnUaTqVnTfheqANtsmSqY4Ub6QoJYQQicyNY6/nlcpeUuaV+hRVqhc1ba/7e7/CJOJDdq/z4mGAcUnlLKltKF62kOJECVPtZtWoXzYD9pYG7p67yOPrN1VHEp8oIjSUmIsHKOcaip2lxviJnVRHUsbazpY6fXuY9jdOmI4hOkZhIhEXFk9bytw1F037E0Y2pVzVxPX3zNh5Q6jikQ6AaAO06zyLK+dkXrSkzmv9Hhp5tGbJT8OZ3+MH1XHijRSlhBAikbl18gyGGOMf6YXLSQ+Sj6XT6TgU5MqyW8nZ/8CK1Ys2q44kPmDTjtfDK3sPbK0wScL1488tKZs2lC65XhB59bjqOOIzje43nachxq4jOdI70K5bQ8WJ1BgzdxA53FIBcHnfIa4dPqY4kYgrPZsP5uCVQACsLGDd+iGky5hacarYUaxuTexK1+ayn3G6gGGTdrJh6XbFqURCERoQyJmtOwnx81cdJd5IUUoIIRKZ8KBg3KLu0ja7H8PrOJG7QHbVkcxChjy5cHR2xifMCs+1ZwkPDVMdSXzA9LGLTUM86lTKlSSXUX4f10xpKV3A+CYuMgaWzlyhOJH4XJFhYUybs8e0P2pk6yT3+17AIy99WheldTZ/KqYNZOOk31RHEnFIMxioV74X9/yMPWJTOVjgdXQG1tZWipN9mVxflaT5yMEYNB07Hibj+wlejPtphupYQiglRSkhhEiEIp49wcXW2FuqWcfaitOYhzzlvzJtXzlwRGES8bGunbvO5YfG4mEKez1N2svv+r/9NLorVi//0ttz/L7MVWLmJgycYRqymsnFhr5DO6gNFM/++GsglnrQ6eDO5es8u3NPdSQRxwJ8X9Dg6xEERRoLsE8tUlOj93eKU30+twJ5aT91LBZWlgAcWrGW336aojiVEOpJUUoIIRKhLesPmrarVi2sLogZyV22lGn7qhSlzMbKvw+btrv2+FphkoSnRYNipu0Jo5YoTCJigyE6hrETN5r2B//UADt7W4WJ4k/rbo0pmdu4PHpwJHRvM0pxIhFfzh48Q4fv5rP1rj0nfO2p2L4VZVs1VR3rk9VtVpWTx8aTLqU1AOd3ebHuVylICQFmVpT69ddfefr0Kc+fP2f8+PEf1W05W7ZshIaGxkM6IYRIODYs3UHky7lfC+V0URvGDLjnzMwP9TNRzCWUqMfe+Ps8VR1JfKRZv3oS8fJ3vWCe9KZPoJO6ph3rkdbJAoCbPhEc2H74A1cIczBn7AIuP4oAIKW9nkl/DFCcKO7Z2dsyZXxb0/6MPw/g80Beo5OSdQvXM6rfNNN+/Z++p0ht81mFslqDCqxa2gdnO2jqHkDQ9QssHfQLmsGgOpoQCYLZFKX69etHq1ataNiwIY0bN6Z169b069fvvddkzJiRzZs3Y2dnF08phRAiYQgLCeX6I2NB3tFGx1dVZMLz92n7XQMyJ4umvGsobviojiM+gf8zP/7afZ/V3k4s9XYmZ+mSqiMlCH1+aGza9lx6QGESEZs0TaNfn7mmudQ6NS9BZvd0akPFsZlLhpHa0Vhg9X4WydBekxUnEiocW7uJXXMXAqDX6xk2cyBT5/+kONWH1WxUkfWr+mP78vOSe8/CmfrNAKIjItQGEyIBMZuiVJ8+fRg2bBiHDh1i7969/PTTT/Ts2fM/z69fvz6nTp0iQv7BCyGSqAOHXy8t3Lh1NYVJEr5atV4Pc1q9wkthEvE5pv26jPsh1mjoKF5f5pXKlicLJfM6AxASBdNH/qk4kYhNO1fvYu/55wDYWMLUPwcqThR3ipQqQNv6BQAwaND1m99Mq8uKpGf7zD84tGIN2RwjqJslhD6dyzJ1fsLtLdjym/qsX/UDdi/nZr/pE0mZQt8Q8CJAbTAhEhizKEqlS5eOzJkzs3//ftOxgwcPkiVLFlxdXd95TZ06dRg6dCh9+vSJr5hCCJGgbFi117RdoVxedUESOCtrKwplNy4xHhYNG5ZsU5xIfKqrh44Q9PwFAPkqlcMhZQq1gRQbMu47LF7OcLB1322CA4LVBhKxrkeH8YRE6Tj21I47TgVIkTaN6khxYtHyQVi+fLey6cA9/tmwT20g8T/27jwuqur/4/h72EHBDWVxQcS9RStNS8q0zTTTstJWs2y3b2WWlpXftm+lLdpqZZlaWflV61tW1s9wTzMTMzcQFUUWBVF2ZDm/P3CmCFBUZi4Dr+fjcR7N3Dlz7/s2DMN8POdcyy38z6vK2r7J8TvuwTsu1FuzHrc2VCXGPDFSs6aPlk/ZID/Fpx3R+WfdrcwDmdYGA2ohtylKSVJycrJjW1pa2fSKVq1aVfqcu+66S++//77zwwFALfV/Xy9VblHZ7a5tG8nLy9PaQLXUNbdc4RhWv3HHIRUfKbI2EE5YaXGJfvv6O0mSl7e3oq+70uJE1vHw9NQV/cuK0KVGen4ifwvVRdtjt2rUpP/T6v0NJF9/DXr4Pqsj1biHnr5DZ7QNlCQdLpBGX/+UxYlQGxhjNHLAvzT357+uvnjfredrwU+vyNOzdny1nTrzCU17/lpHQTV2d656dr1d6Snp1gYDaqna8c6V5Ofnp6ioqEpbw4YNJancVDz7bV9fX0vyAkBtV1pSos27yoaI+3lJA4b1szhR7XT9TRc7bn/33W8WJsGp+PWrb9WxUaGubXtYc1+/Th4eteZPHJc67aJofbknWEv2NdCPGzK06dfNVkeCkyx6+0PlHir7HX/2oMsV1fNsixPVHL+GDdRuwGCl5JX9i8FzryxSRtpBi1OhtjDG6OZLH9CcH3c5tg29pJNWbfxAgUENLMvl4empH9a8q3/ddp7s1+Na8edBndf1NmUxZQ+oUq35i61Xr17asWNHpe3cc8+VVL4AZb/NlfUAoGpLl5d9IS0plc6/mAWgKxPdM0JS2aiSWW/PtzgNTtb+XYlqo/1q3bBIjQM8dPM9Q62OZIk+N1yrolKb/sj010Nj3rE6DpwoPytb370x3XH/rhcfU7PgRhYmqjlXjh2josAQfbGzkd7/KVWvPTX9+E9CvWJKSzXy8n9pyqzfVXL0InbnntZC2xNn65xeXVyeJ7BZU9357msyLTs7tn2xZLf6db9dhfkFLs8DuJNaU5RatmyZbDZbpe3TTz+VpHLrR9lvp6SkWJIXANzB7Pe/0YLdQXpnazPtLGlmdZxa59wLuqt5w7JpjTv3F2rvziSLE+FUzJq91HH73vuvsi6IRUKiItWhVw9JZUW6+DXrLE4EZ1v736+VtOlP9Wqep4f7NdCHXz5jdaRT1qFXD5133VBJZVeSfXwk0/ZQtfG3TdJDz3+vgqPr34c29tGqlS/r1vuucVmGrn2j9cj8Oep43rnacshPa1J9NfHVn3XDJQ+wMD9QDbWmKHUsKSkpSkxMVHR0tGNbdHS0EhMTlZqaamEyAKjdtqz7U3/sPKxiY1O7s7vL08vL6ki1yq13D3HcXrJ8u4VJUBOmvzxLOUfKbvfo3Eyt24ZZG8jF+t1yneP2qs/nyxhjYRq4gjFGy997Xz2C8+TlIQ2+KEoXDzrP6lgnrWnzJhrxzF+LVi96/R1lpvC3Po7t7UnvaNC1U5Vqv6aDzUPnj3lIg8c9IC8nLvVyVq+uWrByuu54a7ICm5VdMCXrQLpuGvSoXhz3utOOC9Q1blGUkqR3331XL7/8svr27au+ffvqpZde0rRp0xyPBwcHq0ED6+YQA0BtFb+2bJ0k3wB/tTnzNIvT1C6X9Pvr/8cnM761MAlqQl52rn5as1eS5OkhPfrM7RYncp2WEWH6aOIFurRlthopR7/97zurI8FF1i9bp0+/j5ck2WzSRx8/Im9v9/wHiPk/TtG/+vorxL9IO9b9rl++XGh1JLiJmK+W6KzT79Yv8blakRag3BJvXTTyRj321afqPuASeXrW3MVewls119xFL+vX1S9raJ+W6hhU9q8hf/68TK8Mu0W7ft9YY8cC6gO3KUpNmTJFX3zxhRYuXKh58+Zpzpw5ev31vyrQ69at07hx4yxMCAC10461fy3e3bF3TwuT1C6+DQL0U0YLLU5qqLV7SrTqx1+sjoQa8PqLnzluXze0h4VJXOvJl++Rn5d0epNCBR+KV0FOrtWR4EL/unmSUrPLRsa1DvbV23MmWpzoxI179k717R6iZn4lujrisBa9/Bqj/XBC0hKTFd35Rr3wxAwVHb0oVrNWLXXXa88o9dB8vTFzgkLDmp70/rucHqm5303Wrt0favjArrJf7O/Mxjn6ctJ/NPPBCcrNPFQDZwLULzZJ/LavRGBgoLKyshQUFKTs7Gyr4wDASWsc0kJzf/tCbQOPyJafrc5h11odqVY489J+GvnafyRJKz+bp4UvvmZxItSUuLQFat/CW5J0zU1v6qvPfrQ4kXP5+Poo7dB/1cjPJmOk8y95Vmt/Zj2p+mbY6GH6/P3b5Gkru3DDxZc/q2U/ucfPwRnndNava6bI9+gAr39PW6pnH3rV2lBway0iIzR0wsPqdH4vXRiao3OCyxYbLy41Wrc5Tf/9fJm+nP2D9iWlV7kPm82mrmdE6qY7r9JVg3uqa0RQuceLS6VvViXpnhv+rQP70px6PoA7qm5NhaJUFShKAahL9hz8Sq2alA1dj+p4v3bF77E4kfVGPP+Ueg4ZKEl6/+6HtH31WosToaZMevNRTRpzoSRp9Z8HFH1G3Z7G9/hL9+qF8WU/y7G7c3V25AiLE8Eq85a9q2EXtpIk7TtYqKiwETpypNjiVMfm7e2lrXvnql2InyRp9dZDiu56i8WpUFd0PO9cffzJo+oV6SebreLjh3KLlZSWo9T9h7V4RYLW/ZmigEZBahwSoosv7Kw7Lgiq8JziUmlJbLqeeOgtbVix3gVnAbin6tZU3Gb6HgDg5K3+PdFx+6a76t9Vyf7J5uGhLheULQZckJurHet+tzgRatKrT013LHje+7TmatehlbWBnOy+uy513J780jwLk8Bqo4ZOUMrRaXwtm/rqk69fsDjR8X04/3lHQepgvtG1lz9qcSLUJXG//Krzo67TJde+oe/WZyi3qHxlqnEDL53errEu6R2hq265UkMefVCX3jVKPYcMVEnziHJ9M/JtmrN4p7r3fkJXnDOKghRQQyhKAUA98NW85Y7blw84x8IktcPQmwboqtO81bbhEe1cu04lRUVWR0INyjmUrR9WlRViE3O8dd6QARYncp6b775aLZuUTVVMPFisz9+bb3EiWCkn87Duvv8DFZeW3b92QFfdMeYaa0Mdw12P3KCbB5ddcKLESHeN+VCpe7naHmpezIKfdGWP2xQeerPumvi1vlmbpp0HpYKSSoZPHZVdKK3fW6RPFu/UkFEfKqzxNRo54EFtWbfJhcmBuo/pe1Vg+h6AusTX30+ZWfPk5yXlFRkF+Q1VaWmp1bEssyDmDQ29KFKS9OQrP+k/j75hcSLUtK49z9Ajn7yrQ0c8tX9XoiYPuaFOLpq8cddnOqNtoCRpwsuLNXnCWxYnQm3w9vyXde81XZVR4KlP1+Vp/BW3qjA3z+pY5fToc4ZWLP2PYx2pGV9t0V1Xj7c2FOqdhk2bqHWHtorq1EY5BSU6dDhfeVlZys7I1IHEvSo+umA6gBPHmlKniKIUgLpm3Y7PdE5U2ZfXQde+ru/n/2xxIuvsz/5KwQ09VWKktu3u0b7d+6yOBCe498O31P7cspGB7931L8X94h6LPlfXBZf20rIfn5QkZeYbhTa+VkVHjlicCrWBp5eXPls9W6kBbVVsbIpdvERzxj1pdSwH/wYB2rnvU4U0KqtIrduRrd6dbpapx/9YAgB1DWtKAQDK+TnmT8ft6266xMIk1urV9ywFNyxb9D0hrZCCVB226vO/prL1GTHMwiTO8e+XRjtuf7pwAwUpOJQUF+veqx9R9uEcSVL3yy/WJXePsjhVGZvNpmv//bg25jRWqZFSs40GXfggBSkAqKcoSgFAPTF35iLH7QvO72BhEmvdevcQx+0ly7ZZmATO9mfMch1OOyCbjAYPPle9+55ldaQa06BxI+U3iVBmoYfyi6Vnx71pdSTUMgf3pWjuxGcdU7UHP3CnHn72LotTSYMevl/dB1yizZl+mhfnq2uvfVHpKQesjgUAsAhFKQCoJ2JXb1RadtmXk8gWfgoJD7Y4kTUu63+a4/acD76xMAmcrbS4RKmrf9aojpkaGpmrl16/z+pINeaCm4dre26gPo5voken/aL0lHSrI6EW2rx0pb6b+o4aeJXo+naH9OpTg/XwxFssy3PBTder36ibJEmlJSV69q5ntPrHXyzLAwCwHkUpAKhHfv0jWZLkYZOG3z7Y4jSuF9mhjaKOXno8LbtUa5astTgRnG3+u5/K21a2fGZ091B1Oj3S4kSnzi+woaJvvE6SVFxUrM9e+dDiRKjNYmZ+Kp/EDQrxL5EkTXnuet398HUuz/Hp/17UUy/f67g//4VXtHX5KpfnAADULhSlAKAe+fSTn7U8NUCz4xtrb0kTq+O43J0PX++4vXTNLguTwFUyUg7om+Vlr7WHTXrh9QcsTnTqom+4Vv6BDSVJv339nQ6lplmcCLXdnYPHKmZzlqSy98Fbr9yqW+++ymXHn/vtS7ph8Om6pGWOTm9SoB/f/VBr5n3lsuMDAGovilIAUI98PWeRfk3xUUahlzr16W11HJcbPOgcx+1PPvrewiRwpafHvqWio2soX9mvg4JbuG9BNrx1iF597loF+xarpLhYP384x+pIcAMlRUUaeO5orY7PlSR5ekgfvXun06fy+fh46cdf3tbwQX9Nm96yfJUWvzPDqccFALgPilIAUI8U5uZpV+wfkqTmEa3VrFVLixO5Tkh4sDq3KhtdkpkvffflTxYngqvE/7Fdy/4oW3PJx1N69jX3HS318jsP64wWRrd0OKTGyRuUkcTVI1E9hXn5uvScO/TbrgJJZSOmXn3+er3x4WOy2Ww1frywlsH6PW6WLundRpJkjDT1s1g9fOOTNX4sAID7oigFAPXM9lVrHLe79u1jYRLXCj3tdP13dyOtT/fTohW7uPx4PfPM4x+qtGxpKd107Tny8/OxNtBJaB7aVNcOKBtxUlIqvfMCa0nhxORn5+qis27X0i3Zjm1jbr9Av/zxgZoFN6qx4wwdcbG2xn+orhFBkqSiUunfb6/U2JueqrFjAADqBopSAFDPbF66Us39itW7eZ5efGqo1XFcpmu/C5Wc563lqQ31wrOfWR0HLrbqh5XasDtPkhTo66GJf1tw2V289sF4+XqV3V72R7piV2+0NhDcUt7hbF121m36YlmyzNFC7bmnh+g/X05Vi8iIU9p3k6aBWvDTK5r/2UMK8i/7mpFzxKZRD32m5x54+VSjAwDqIIpSAFDPpCXs0iUhB3VeSJ7O7xSoiHbhVkdyOk8vL53WN1qSlJ+dox1rf7M4Eazwn+c/d9wec2d/+fp6W5jmxLSNaqnrr+gqSSoulcb/6y2LE8GdFR85ohv73aPxry1VXrFNO7O8ldO8kx6ZP0eDHr5PDZo0PuF9drngfH2+YoaGXtJJ9tmA8QdK1Oeiifrszbk1ewIAgDqDohQA1EMrf9vjuD3y/mEWJnGNqJ5nyz8oUJK0dfkqlRQXW5wIVlj40UJtSiqUJAX6eWjkgzdanKj63pg5Qd6eZbd/+i1V61estzYQ3J4xRq+Me1WXDn5Z/12fI8kmL29v9b/9Fj21eL5id8zWC6/dp86dW1W65lRQUIC6dOug6Buv09gvZ2n0O69qp0crFZdKR0psmvXDTp3Z9kZt+oURfQCAqtkkGatD1EaBgYHKyspSUFCQsrOzj/8EAHAj194xVF/OuEOS9Nv2TJ3b+VaLEznXrB+mqeUZZyghy0dv/+sp/fFTjNWRYJGrRw3V86/dpzX7A7T5jwS9fv1tMqZ2/yl0xjmd9Puvr8jTQzpSIp1x1ljFb4q3OhbqEG8/X11y1yhddNuN8vL2VmTgEQ2NyHI8nn+kVPsz85Wde0Q+3p5qHOir4EY+Ssjy1bd7g8rtKyRvt9566m2t+XGlq08DAFCLVLemQlGqChSlANRlXt7eOpizQA19yr7kNg68VgX5hVbHcgofH28dylkgP2+poFhq1mSE8nNyrY4FCz342Ydqc0bZVLiPH5qgTUuWWZzo2JbFztAF3UIkSV8s2a0bLnHfqweidmsU0lwX3XaTHvvXAJ0XXnTc/tlFHpqxvakkac+mLVoyY7Y2xyyv9YVeAIDzVbemwvQ9AKiHiouK9HvcQUmSj6d0wx2DLU7kPCNGXyW/o0sHxe44TEEKWvzuDMfty++/Ux6enhamObZB1/ZzFKTyiqRH7njR4kSoyw6nHdDXL09V/w7X6Jq75mjeihRt2V+qrCMeKv7bBUsLSmxKzfVQbEKWYmZ8rMlDbtC0G+/Qnz8voyAFADghXlYHAABY45v/rdWFp18hSRo24iLNfOu/FidyjltGXea4PX/BaguToLbYtuIXJW78UxHdTlerju101xN3aPpz71sdq1K9rh+mtHxPhfiX6MP/xio5MdnqSKgHCvPy9NUHX+qrD76UJDVo0lgNmzZR4+AmKsjLV1ZGpg7vP6DS4hKLkwIA3B3T96rA9D0AdV3zliHat2eGvDykQ3mlatpgiNWRapyvn48ys/4rP2+bCkuk0JBbdDjjkNWxUAtEnnWm3vjqDV0Qmit/z1Kd1vU+7Yjba3WscjpfcJ7ufOc12WQUXrpft51/gwpy862OBQAAcFxM3wMAHNOBfWnanlIgSWoc4KF+A3pbnKjm3XLP1fLzLrtq1Pr4QxSk4LBrwx/y3L9TQT6l8vaUpn/yhNWRyvHw8tSQRx+UJBnZ9PKEtylIAQCAOoeiFADUYz8u+dNxe9R9Q60L4iQ3j7zUcfvLL1ZYmAS10f23vai84rKiZf+erXTxgF4WJ/pLv9tuVIvICEnSrt83asP3P1mcCAAAoOa5VVHqxRdf1P79+5WRkaGXX35ZNputyr69evXSqlWrlJ2drW3btumOO+5wYVIAcA8z3pin7Yd99O2eQG3Ma2Z1nBrlH+CnXqeXLRBdUCx99PpcixOhttm1OV6fLtrmuP/h7Efk5WX9oueDhl2kT6eNUKh/kUpLSvTVy69bHQkAAMAp3KYoNXbsWN144426+uqrNWzYMN10000aO3ZspX1DQkL0/fffa+nSpTrrrLM0adIkvfnmmxo4cKCLUwNA7bZ1/RbNWLJf8Vm+Cj/tdDUKaW51pBozasy18j16OY912w4q5zDrA6KiR0Y9p5SjPxptmvvrpbcesjSPn5+PPpjxL7UIKNWIdod1cPWPStqy3dJMAAAAzuI2RakHH3xQTz/9tFatWqWlS5dq/PjxGjNmTKV9hw4dqtTUVE2cOFE7duzQF198odmzZ+vGG290cWoAqP02/RTjuH3GxRdZF6SG3XBzf8ftuXOXWZgEtVlO5mE99uTnKj162Zcxo/uqU9e2luV5e86TCm3sLUlKOlyq1x99xbIsAAAAzuYWRamwsDC1adNGy5cvd2xbuXKl2rZtq9DQ0Ar9f/jhB40aNarC9kaNGjk1JwC4o41/K0qdeWk/C5PUHA9PT63NDdWS5AaKz/TU7De/sDoSarFP3/hUMZsOSZJ8PG36/OtnjrlEgLMMvPpCjRx2liSpxEj3j3lfBbl5Ls8BAADgKm5TlJKk5ORkx7a0tDRJUqtWrSr0T0xM1Nq1ax33mzdvrhEjRmjJkiVOTgoA7ictYZcy9ySqfVCh7h8Spe7ndrE60inr0KuHbA2b6I+D/nr+w/XKy861OhJquTuue0pZR8oKUd3aN9ULUysfje0sTYODNHvOWHkcrYXNX7ZX3366yKUZAAAAXK3WFKX8/PwUFRVVaWvYsKEkqbCw0NHfftvX1/e4+50/f75SU1P13nvvOe8EAMCNtS7YrcFtstWlyRHd/dD1Vsc5ZecMHuC4zVXLUB174nbr36+V/awcKbGp4yWXqUGTxi47/tf/94qaNihbZH1XRolGDX7UZccGAACwSq0pSvXq1Us7duyotJ177rmSyheg7Lfz8qoe1t6gQQN9++236tixo6688krl5+c79yQAwE199PZCx+0rLj3DwiSnzjcgwLE2Vu6hw9q6fLW1geA2pj3xhj5dvl+fJDRWYmmwbnjhKdk8nP+n0rSPxqtPt7JR4QXFNt04/GXl5zC6DwAA1H21pii1bNky2Wy2Stunn34qSeXWj7LfTklJqXR/gYGBWrx4sU4//XT1799fO3bscP5JAICbWvvzWiUdLpUktQn2VdczoyxOdPKemnyvBrQrVph/kWJ/+D+VFBdbHQluwhij+655VEkphyVJXS44X1c8cLdTj3nrPVfpgVHRR48vPfNmjNYu+cWpxwQAAKgtak1R6lhSUlKUmJio6Ohox7bo6GglJiYqNTW1Qn+bzaYFCxaoXbt26tu3r7Zs2eLKuADglv5vxV/F+wcm3GxhklNzy4jz1a1ZgUZEHdaB2F+tjgM3k51xUJ9O+LejmHnx6Ft01+O3O+VYjUND1G/0KBWV1YP15bIkvTz2VaccCwAAoDZyi6KUJL377rt6+eWX1bdvX/Xt21cvvfSSpk2b5ng8ODhYDRo0kCTdcccd6tevn0aPHq1Dhw4pJCREISEhatKkiVXxAaDWe2/qPMftq67oZmGSk9en39lq3cxHkrQns0QrFi0/zjOAiuLXrNP/prwhD5vRJeE5mv6fq/XurAk1eoyGTZvo7ven6aBvqBbubqRfEvJ1y4CHavQYAAAAtZ3bFKWmTJmiL774QgsXLtS8efM0Z84cvf76647H161bp3HjxkmShg0bJk9PTy1atEipqamOtmDBAqviA0Ctt3bJGu3KKJEkhTX21gWX9LA40Yl7YPyNjttf/7DJwiRwdys/m6e8Dct1RtOyC6vcfWsfvTmjZhYfD2rRXPfMeFMtIiMkSbFbU3V5r7tV/LcLugAAANQHNknG6hC1UWBgoLKyshQUFKTs7Gyr4wCAS7z+ybN68KazJEnzFm/X8AHjLE5UfZ6eHsrIWaggPw+VlEqdu41Vwp/xVseCG/Pw9NSHP7ypkZe0dmxb9PN2Dbtigo4cObm1yu761zW6dexIrc1uLsmmQ6lpeuvWe5SZUnE5AgAAAHdV3ZqK24yUAgA431svzVHJ0fVtLruwgzxccOWxmnLDHYMV5FeW98+9+RSkcMpKS0p0xxUP6LOlyY5tg/p30sa4merctc0J7atBAz99ueg/mj5tlM6P8FDP4Hyl703SO7ePoSAFAADqLff5tgEAcLqEP+O1ZV+BJKmRv4cGXd/f4kTVd/+DQx23P/18hXVBUKeUFpfo1kvu05TPNjsWJO8U0VixG9/SWx+OU1BQwDGf7+XlqXsfGqbE1M907cAz/tqed1Bv3nKXMvYmOTM+AABArUZRCgBQzqzPVurXA/6aHd9YpWEdrY5TLRHtwtWzS7AkKfuITe+8MNPiRKhLSktKNP6mCbr3qW+VWVD2p5OPl0333d5Xe9M+U6+rB6lhs7KLqXh4eKh9+zANvSZaH33+lFIyvtTbr9+mpg29JUlFpdJ73ybootNvVU5GpmXnBAAAUBuwplQVWFMKQH3VsGkTPb3kf/L08tLhtAN6/vKrVVpSYnWsY3rn06d1z409JUnzl+3RdRfdb3Ei1FXtunXVh18+o+j2fvL0kLZk+mrxvkBJUnbGQSk/W08PaFDpc+PSjcY9+rG+/ZgLrwAAgLqNNaUAACcl52Cmtq5YLUlqFNJcnfr0tjjR8fXrd6YkyRjp1ec/sTgN6rKdG7eof5fhGnb3J/plV5H+OOjneCywWVM1bl1+rakSI21Pl8ZOWapuESMoSAEAAPyNl9UBAAC1z9r53+j0fhdKknoPG6yty1dZnKhq4Z066LuMcG0qKJJ/dorW/N8vVkdCHWdKS/W/GV/ofzO+UORZZ6rLhX0UedaZahwWIv/AhtqUJqWl52rT5j2aN+sHrftphUqKiqyODQAAUOtQlAIAVLBt5S8qzjyg3h0aaORdZ2jr/G5as3yj1bEq1fvaIZJs2pvro/8+/4XVcVDP7Nrwh3Zt+KPctictygIAAOBumL4HAKigtKREDVL/1AWheWrqV6rHnh5pdaRK+TVsoHMGD5AkFebl6/fvFlucCAAAAEB1UZQCAFTqlX9/qKLSstuXX9he/v6+1gaqxIDbrpNfg7JFpdd/+4MKc/MsTgQAAACguihKAQAqtXtLgtbvKLtShr+3Tf96/BaLE5UXGNRAn752ja6PPKR2gYVa8QlT9wAAAAB3QlEKAFCld9/9znH7vnsvtzBJRROev1P+3ja1bFCspnlJ2r8r0epIAAAAAE4ARSkAQJU+fWuukg4bSVLrYD8NGd7f4kRlbDabRo+80HF/ygufW5gGAAAAwMmgKAUAqFJpcYk+/vwXx/0nJtWOKXy33TdUzYO8JUnx+4v17affWpwIAAAAwImiKAUAOKYpT0xXVqFNktSjc7BO697e4kTSxCdHOG6/9+HPFiYBAAAAcLIoSgEAjin7YKa+jkmQJNls0nNT7rU0z/W3DlC70ABJUkq29MYz71uaBwAAAMDJoSgFADiu58a/o6JS6UiJTUGR7eXp7W1Zlmeev9Vxe/qsFSouLLQsCwAAAICTR1EKAHBcO/7Yrne+3aMP45poY34LnTv0SktyXHVdP3VqHShJOpAnTR7/liU5AAAAAJw6ilIAgGp59fE3VVBS9rHRf/Qt8vTycnmGKa/f5bj94dxfVZiX5/IMAAAAAGoGRSkAQLUkbdmmLctXSZKahoep59BBLj1+eKcOWpMXrsQcb+3PlZ4f+7pLjw8AAACgZlGUAgBU24/vfiRJ8vUs1Suv3K52HVq67NgDH7pX6YU+WrC7kW5/ZJ7ysnJcdmwAAAAANY+iFACg2vb+uUVH4n7X7R0ydX6Eh96f84RLjtuhd091iT5PknRwX4oWfzTXJccFAAAA4DwUpQAAJ+SjZ99S6dHb/Xu1Ub/Lejr1eM2CG+n6Jx9x3P/h7Q9UUlTk1GMCAAAAcD6KUgCAExK/cas+/S7Ocf+9jx6Wh4fzPk6+XPQfjb0kUG0aHNHujZv0+7c/OO1YAAAAAFzHrYpSL774ovbv36+MjAy9/PLLstlsVfa97LLLFBsbq7y8PMXGxmrAgAEuTAoAddujdzyvA3llv4PbtwzUM1Puccpxrr3pEvU7t42a+JZqYOtsff/qNBljnHIsAAAAAK7lNkWpsWPH6sYbb9TVV1+tYcOG6aabbtLYsWMr7RsVFaWFCxfq448/1mmnnaZZs2bpq6++UkREhItTA0DdlJV+UP+e8r3s9aFHHxygzl1r9nds8xaN9cH7Yxz3ZyzcrB0bNtfoMQAAAABYy7hDS0xMNCNHjnTcv+mmm8yuXbsq7du3b1/z+uuvl9uWkZFhrrvuumofLzAw0BhjTGBgoOXnTqPRaLWx2Ww2E7Nlrik135hS8435c+ds4+npUWP7X7XhPce+tx/42vg1bGD5OdNoNBqNRqPRaLTjt+rWVNxipFRYWJjatGmj5cuXO7atXLlSbdu2VWhoaIX+y5Yt08MPPyxJ8vLy0u233y5fX1/9+uuvLssMAHWdMUa3Xfu0DhWWTePrGtlE786aUCP7fmby3Tqve7gkKa/YpptveFkFObk1sm8AAAAAtYPbFKUkKTk52bEtLS1NktSqVasqnxcVFaX8/Hx9+OGHevbZZ5WYmOjcoABQzyRuidfEl39QiSm7f/uN5+nsPmee0j6vvaG/Jo670nF/8odrte7/Vp/SPgEAAADUPl5WB7Dz8/NTy5YtK32sYcOGkqTCwkLHNvttX1/fKvd54MAB9ezZU+edd55ee+017dixQwsWLKjB1ACAdye9pT59z9T1F4Tph6RAXTZhorbferdyMw+d8L76XdpDc2Y/JI+j17H4YeNhPT/mPzUbGAAAAECtUGuKUr169dLSpUsrfezRRx+VVFaA+mcxKi8vr8p9ZmVlKTY2VrGxserataseeOABilIA4ASjr3xYKV99KI+QYDVv20Z3Tn9dH9zz8AkVpoKaNdb8r56Ur1dZRerP1BJd32+MSotLnJQaAAAAgJVqzfS9ZcuWyWazVdo+/fRTSSq3fpT9dkpKSoV9de3aVdHR0eW2bdmyRcHBwU48AwCovwpycvXCzQ/qcNoBSVLrrp31wKzpGnXvkGo9Pziite6dOV1LDzSRMdKOg9LAvmOVcxKjrQAAAAC4h1pTlDqWlJQUJSYmlis0RUdHKzExUampqRX6Dx48WB988EG5beecc462bt3q9KwAUF8dSk3T9Dsf0KG0/ZKky3s014fvjNZvf76v8/p0qfQ5zUMaK/rG6zT2y4/VIjJCu7J99OVmmy6NHqukuJ2ujA8AAADAxWwquwxfrTd+/Hg98MADuummmyRJn376qV599VW9/vrrkqTg4GDl5+crNzdXLVu21ObNmzV9+nTNmDFDl112mV577TWdd9552rBhQ7WOFxgYqKysLAUFBSk7O9tp5wUAdU2TsFA9PPN1Tbi0obz+9k8fe1KytWZdvPanZapFSBP1PreDAgIbas6uYJV9HEkp8Qn6cMw4ZSZX/AcHAAAAAO6hujUVtylKeXh4aMqUKRo1apSKi4v14Ycf6vHHH3c8vmvXLn388cd65plnJJWtUTV16lSdeeaZ2r17tyZMmKBvvvmm2sejKAUAJ8/H309Pv/dv3Tf8DDX2KT1m368TA7Uz21erPp+vRa+/o8JjrBUIAAAAoParc0UpV6MoBQCnLuqsMzRp6kPqd064wgOKZbP99VipkVLzvPTF/+3UG5PeVeLGP60LCgAAAKDGUJQ6RRSlAKDmBDUPVo/L+ur0s9qrWXAjHczI0u9rt2jj0l+Utf+A1fEAAAAA1CCKUqeIohQAAAAAAMCJq25NxS2uvgcAAAAAAIC6haIUAAAAAAAAXI6iFAAAAAAAAFyOohQAAAAAAABcjqIUAAAAAAAAXI6iFAAAAAAAAFyOohQAAAAAAABcjqIUAAAAAAAAXM7L6gC1XWBgoNURAAAAAAAA3EZ1aykUpapg/x+4b98+i5MAAAAAAAC4n8DAQGVnZ1f5uE2ScV0c9xIeHn7M/3kAAAAAAACoKDAwUMnJycfsQ1EKAAAAAAAALsdC5wAAAAAAAHA5ilIAAAAAAABwOYpSAAAAAAAAcDmKUgAAAAAAAHA5ilIAAAAAAABwOYpSAAAAAAAAcDmKUgAAAAAAAHA5ilJ1gK+vr2bMmKHMzEwlJydr7NixVfbt3r271qxZo9zcXP366686++yzXZgUNS08PFzz5s1TRkaGkpKS9Oqrr8rX17fSvl999ZWMMeXaoEGDXJwYNWXo0KEVXs958+ZV2vfiiy/Wpk2blJubqyVLligyMtLFaVETRo4cWeE1N8aopKSk0v6xsbEV+p522mkuTo1T5ePjo02bNqlv376ObW3bttVPP/2knJwcbd68WZdeeukx9zFixAjt2LFDubm5WrBggZo1a+bs2KgBlb32vXr10qpVq5Sdna1t27bpjjvuOOY+MjMzK/weaNCggbOj4xRV9tpPnTq1wmt5//33V7mPBx98UElJScrKytKMGTPk7+/viug4Rf987WfOnFnpZ/+SJUsqfX7jxo0r9D1w4IArTwEn4Fjf5erbZ72huXd74403TGxsrDnrrLPM0KFDzeHDh82wYcMq9AsICDDJyclmypQppnPnzmbq1KkmJSXFBAQEWH4OtJNrq1evNosWLTJdu3Y10dHRJi4uzkyePLnSvnFxcebGG280ISEhjubj42P5OdBOrj3xxBPm66+/Lvd6NmrUqEK/1q1bm+zsbDN27FjTtWtX8/nnn5uNGzdanp924s3Pz6/c692qVSsTFxdnXnvttQp9PTw8TF5enrngggvKPcfT09Py86BVv/n6+pr58+cbY4zp27evY3tsbKyZM2eO6dy5s5kwYYLJyckxrVu3rnQfPXv2NLm5ueaWW24xZ5xxhomJiTHffPON5edGO/HXPiQkxBw8eNC88MILpn379mb48OEmLy/PDBw4sNJ9hIeHG2OMiYyMLPd7wOpzo534ay/J/Pjjj2b8+PHlXkt/f/9K93HNNdeYzMxMM2jQINOjRw/z559/mjfffNPyc6Od+GsfFBRU7jXv1auXyc/PN0OGDKl0H+eff745cOBAuec0b97c8nOjVd6O9V2unn3WWx6AdgotICDA5OXllfvQmjhxoomJianQd9SoUSYhIaHctri4ODNy5EjLz4N24q1Tp07GGGNatGjh2DZixAiTlJRUoa+Pj48pKioyHTp0sDw3rWbanDlzzAsvvHDcfs8880y53wf+/v7m8OHD5X5n0NyzTZgwwcTHx1daXI6KijLFxcXG19fX8py0k2tdunQxGzZsMLGxseW+oPTr189kZ2eX+weln376yUyaNKnS/cyaNcvMnDnTcb9Vq1ampKTEtG3b1vJzpJ3Ya3/33XebLVu2lOs7ffp088knn1S6n4svvtjs27fP8vOhnfprL8ns3bvXXHrppdXaz7Jly8r9TujTp4/Jzc2tsohFs74d67X/e/vhhx/M7Nmzq9zPHXfcYVatWmX5+dCO3471Xa6+fdYzfc/NdevWTd7e3lq9erVj28qVK9WrVy/ZbLZyfXv37q2VK1eW27Zq1Sqdd955LsmKmpWamqrLL79c+/fvL7e9UaNGFfp26tRJxhjt3LnTVfHgZF27dlVcXNxx+/Xu3VvLly933M/Pz9fvv//O+97NNWnSROPHj9eECRN05MiRCo937dpVe/fuVWFhoQXpUBP69u2rmJiYCu/V3r176/fff1deXp5j28qVK6t8T//zd0BSUpL27Nmj3r17Oyc4TllVr/0PP/ygUaNGVehf2ee+VP3PCdQeVb32gYGBatWqVbVeTw8PD/Xs2bPc+37NmjXy8fFRt27dajwzakZVr/3f9e/fXxdeeKGeeOKJKvvwvncfx/ouV98+6ylKubmwsDClp6erqKjIsS0tLU3+/v4V5pGGhYUpOTm53La0tDS1atXKJVlRsw4fPqwff/zRcd9ms2nMmDGVzjHv0qWLDh8+rDlz5ig5OVlr167VgAEDXBkXNaxTp066/PLLtX37du3YsUMvvviivL29K/TjfV833XvvvUpOTtb8+fMrfbxLly46cuSIvvnmG6WkpGjp0qXq2bOni1PiVEyfPl1jx45Vfn5+ue0n+p7md4D7qeq1T0xM1Nq1ax33mzdvrhEjRlS5tkyXLl0UEBCgmJgYJScna9GiRerQoYNTs+PUVPXad+nSRaWlpZo4caL27t2r2NhY3XrrrZXuo3HjxvL39y/3vi8pKVFGRgbv+1qsqtf+7yZMmKCPP/5YSUlJVfbp0qWLWrVqpbVr1yopKUlz585VaGioMyLjFB3ru1x9+6ynKOXmAgICKvxLuP3+Pxe8rqpvVQtjw71MnjxZZ599tiZOnFjhsc6dOysgIECLFy/WgAED9N133+mbb77ROeecY0FSnKo2bdqoQYMGKiws1PXXX69x48bppptu0pQpUyr05X1fN40ePVpvvvlmlY937txZTZo00YwZMzRw4EBt2bJFS5YscZs/TlC1E31P8zugbvLz89P8+fOVmpqq9957r9I+nTt3VtOmTfX8889ryJAhys/P15IlS9SwYUMXp8Wp6ty5s4wx2rZtmwYOHKgZM2bo/fff19ChQyv0DQgIkCTe93VMZGSk+vfvf8zPfqnsZyUoKEgPP/ywhg8frvDwcH377bfy8OBrf2339+9y9e2z3svqADg1BQUFFX7Y7Pf/PtzvWH3/2Q/u56WXXtJDDz2k4cOHa/PmzRUef+655/TGG2/o0KFDkqQ//vhD55xzju666y7dfffdLk6LU7Vnzx41bdpUmZmZkqSNGzfKw8NDn3zyicaOHavS0lJH36re9/afBbifHj16qFWrVvr888+r7HPnnXcqICBA2dnZkqT77rtPffr00S233KIXX3zRVVHhBAUFBRVGQh/rs5zP/rqnQYMG+vrrr9WxY0dFR0dXObJiwIAB8vb2Vm5uriTppptu0t69ezV48GDNnTvXlZFximbPnq1vvvnG8bm/adMmdezYUffee6+++uqrcn0LCgokVfzHad737m3YsGGKjY3V1q1bj9nvtNNOkzHG8XNw7bXXKiUlRb169dIvv/ziiqg4Cf/8LlffPuspmbq5ffv2KTg4WJ6eno5toaGhysvLq/Clc9++fRWGb4aGhiolJcUVUeEkb7zxhh555BHdfPPNWrBgQaV9jDEVfh62bt2qli1buiAhnMH+h6nd1q1b5e/vr6ZNm5bbzvu+7hkwYICWL19+zMJiSUmJoyBlt23bNt7zdcCJvqf5HVC3BAYGavHixTr99NPVv39/7dixo8q+R44ccRSkpLJ/Nd+1axe/B9xUZZ/7lb2WGRkZys/PL/e+9/T0VLNmzXjfu7EBAwZUKEBWJj8/31GQkqQDBw4oIyOD930tVtl3ufr2WU9Rys3FxsaqqKio3CJm0dHRWrdunYwx5fquWbNG559/frltffr00Zo1a1ySFTXv6aef1j333KMRI0boiy++qLLfzJkz9eGHH5bb1r17d23bts3ZEeEEl112mdLT0+Xv7+/Y1r17d6Wnpys9Pb1c3zVr1ig6Otpx39/fX2eddRbvezfWq1cvrVq16ph9fv75Zz399NOO+zabTWeeeSbv+TpgzZo1Ovvss+Xn5+fYFh0dXeV7+p+/A1q1aqXWrVvzO8AN2Ww2LViwQO3atVPfvn21ZcuWY/bfsWOHRo4c6bgfEBCgDh068HvADT3zzDP66aefym2r6u84Y4zWrVtX7n1/3nnnqaioSBs3bnR6VjhHz549j/vZHxgYqIMHD+qiiy5ybAsPD1dwcDDv+1qqqu9y9fGz3vJLANJOrb377rtm06ZNpkePHmbIkCHm0KFD5uqrrzaSTEhIiPHz8zOSTGBgoElLSzNTp041Xbp0MVOnTjXJycnlLjVJc5/WuXNnU1RUZJ599lkTEhJSrv3ztb/66qtNYWGhueWWW0xUVJR56qmnTG5uromIiLD8PGgn3ho2bGj27t1rPv30U9OxY0czYMAAk5SUZB599FHj4eFhQkJCjLe3t5FkIiIiTF5enhk/frzp2rWr+fzzz01sbKzl50A7+bZr1y4zfPjwctv++bo//PDDJjMz0wwePNh07NjRvP322yYlJcU0bNjQ8vy0E29/vzy4h4eH+fPPP83cuXNN165dzfjx401WVpZp3bq1kWS8vb1NSEiI8fDwMJJM7969TUFBgbn99tvNGWecYX7++Wfz9ddfW35OtBN/7UePHm2Ki4vNwIEDy33mN2nSpNLXftq0aWb37t2mb9++pmvXrmb+/Pnmjz/+cDxOq93t7699jx49zJEjR8wjjzxi2rVrZ+655x6Tn59vevfubSQZPz8/x99/kszw4cPNoUOHzJAhQ0yPHj3Mpk2bzLRp0yw/J9qJv/ZS2d9yxphyr7G9/fO1//rrr82GDRtMjx49zFlnnWWWL19uFi1aZPk50Sq2Y32Xq4ef9ZYHoJ1i8/f3Nx9//LHJzs42SUlJ5sEHH3Q8ZowxI0eOdNzv2bOnWb9+vcnLyzNr1qwx3bt3tzw/7eTa+PHjTVUqe+3vuOMOs337dpOfn29+++03c8EFF1h+DrSTb127djU//vijycrKMvv27TNPP/20kf76w+Xvf8wMGDDAbNu2zeTm5pqffvrJtG3b1vL8tJNveXl55rLLLiu3rbLX/fHHHze7d+82+fn5ZunSpea0006zPDvt5No/X9uoqCizdOlSk5+fbzZt2mQuvvhix2N9+/Y1xphy/+gwcuRIk5iYaLKzs838+fNN06ZNLT8n2om/9t9//32ln/kxMTGVvva+vr7mlVdeMfv27TM5OTnmf//7n2nVqpXl50Q78ddekrnqqqtMbGysycvLM1u2bHH8A7RU9h63//1nb+PHjzepqakmMzPTzJgxw/j6+lp+TrSTe+3PPfdcY4wxPj4+Ffr+87Vv3Lix+fDDD83+/fvN4cOHzezZs03jxo0tPydaxXa873L16bPedvQGAAAAAAAA4DKsKQUAAAAAAACXoygFAAAAAAAAl6MoBQAAAAAAAJejKAUAAAAAAACXoygFAAAAAAAAl6MoBQAAAAAAAJejKAUAAAAAAACXoygFAAAAAAAAl6MoBQAA4AQzZ86UMabKNnLkSBljFBER4fQsMTExMsYoPz//mP3effddRz5X5AIAAPWbTZKxOgQAAEBdExQUJH9/f0nS8OHDNW7cOPXs2dPxeGZmppo0aaIDBw6otLTUqVliYmL022+/acqUKdq/f3+V/QIDA9WpUyetW7dObdu2VWJiolNzAQCA+s3L6gAAAAB1UVZWlrKysiRJhw8fVklJidLS0sr1+ed9Z8rJyTlmQUqSsrOzdeDAARclAgAA9R3T9wAAACwQERFRbpqcMUbXXnuttmzZotzcXH322Wdq27atlixZotzcXC1fvlzh4eGO5w8dOlSbN29Wbm6u1q5dqwsvvLDax+7Xr582bNig/Px8JSQk6K677qrx8wMAADgeilIAAAC1xLPPPqvbbrtNgwYN0rBhw7R69Wq9++67Ov/88xUWFqbHHntMknTmmWdq1qxZev7553XmmWfqk08+0ffff6+oqKjjHsPDw0Pz5s3TvHnz1LlzZz311FN655131KVLF2efHgAAQDlM3wMAAKglXn/9df3666+SpA0bNmj79u3673//K0maP3++unfvLkkaN26cPvjgA82dO1eS9Oabb6pv37669957NW7cuGMeo1GjRmrWrJnS0tKUmJioxMREJScnKyUlxXknBgAAUAlGSgEAANQSO3fudNzOz8/X7t27y9339fWVJHXp0kVjxoxRdna2ow0ePFgdO3Y87jEyMzP1zjvvaMaMGdq9e7fefPNNHT58WIcOHarp0wEAADgmilIAAAC1RHFxcbn7VV2Vz8vLSy+//LK6d+/uaF27dtU999xTrePcf//9Ou200/T++++rV69eWrt2rQYMGHDK+QEAAE4ERSkAAAA3s337dkVGRiohIcHR7rrrLl1xxRXHfW5ISIjeeust7dixQ//5z3907rnnasmSJbrqqqtckBwAAOAvrCkFAADgZl5//XWtWLFC69at06JFizR48GCNHTtW/fv3P+5zDx48qGuuuUY2m02vvvqqWrZsqe7du2vBggUuSA4AAPAXRkoBAAC4mbVr1+qWW27Rfffdpy1btuiuu+7SDTfcoBUrVhz3uUVFRbrqqqvUvXt3/fHHH/ryyy/14YcfasaMGS5IDgAA8BebJGN1CAAAADhPTEyMli5dqmeeeea4fSMiIrR79261bdtWiYmJLkgHAADqK0ZKAQAA1AMNGzZUixYtjtknMDBQzZs3d1EiAABQ31GUAgAAqAfGjRt33JFPkydP1rp161yUCAAA1HdM3wMAAAAAAIDLMVIKAAAAAAAALkdRCgAAAAAAAC5HUQoAAAAAAAAuR1EKAAAAAAAALkdRCgAAAAAAAC5HUQoAAAAAAAAuR1EKAAAAAAAALkdRCgAAAAAAAC5HUQoAAAAAAAAuR1EKAAAAAAAALkdRCgAAAAAAAC5HUQoAAAAAAAAuR1EKAAAAAAAALkdRCgAAAAAAAC5HUQoAAOCoTz75RMYYjR071mnHGDlypIwxioiIkCTNnDlTu3btOuX9RkREyBijkSNHVtnH09NTM2fOVFZWlg4fPqyLLrrolI8LAABwsihKAQAASAoKCtLVV1+tP/74Q3fddZfLjvvcc8/p6quvdsmxBgwYoNtuu02vv/66rrzySq1bt84lxwUAAKgMRSkAAABJN9xwgyTpwQcfVKdOndS/f3+XHHfnzp2KjY11ybGaNWsmqWx01ooVK5Sbm+uS4wIAAFSGohQAAICk22+/XUuWLNHSpUsVHx+vu+++u9zjMTExmjlzph5//HGlpqbq0KFDWrhwodq0aePoM2nSJO3atUuDBg3S1q1blZubq19++UV9+/at8riVTd+744479Oeff6qgoECJiYmaNGmSPDzK/9l29dVXKzY2Vnl5eVq/fr26d+9+zPObOXOmZs2aJUnatWuXYmJiJEm+vr568skntXXrVuXn5ysuLk6PPfaYbDZbuXOfM2eO5s2bp5ycHP3444+SpMDAQL3xxhtKSkpSTk6Ofv31Vw0cOPCEzwUAANRfhkaj0Wg0Gq0+t65duxpjjBk2bJiRZCZOnGgKCwtNixYtHH1iYmLMwYMHTVxcnLnuuuvMiBEjzO7du83OnTuNv7+/kWQmTZpkcnJyTEZGhnnggQfMwIEDzZIlS0xBQYHp1q2bkWRGjhxpjDEmIiLCSDIzZ840u3btchxnwoQJpqSkxEydOtVceuml5tFHHzV5eXlmxowZjj5XXnmlKSkpMbNnzzaXXXaZGT9+vMnOzjbGGDNy5MhKz7Fdu3bm2WefNcYYM3ToUNOlSxcjyfz4448mKyvLPPLII+aSSy4xL7zwgikqKjLvvfdeuXM/cuSI+eijj0z//v3NJZdcYjw8PMwvv/xiMjIyzP33328uvvhiM3v2bHPkyBETHR1d7XOh0Wg0Go1Wr5vlAWg0Go1Go9Esba+88oo5cOCA8fb2NpJMq1atTHFxsXn88ccdfWJiYkxhYaGJjIx0bOvevbsxxpi7777bSGVFKWOMufnmmx19/Pz8THJyspk7d66Rjl2UCgoKMrm5ueadd94pl+/22283xhjTtWtXI8n8+uuv5pdffinX57HHHjtmUaqyYw8YMMAYY8zw4cPL9Zs4cWK548XExJicnBzj4+Pj6DNo0CBjjDFXXXWVY5vNZjOrVq0yTz/9dLXPhUaj0Wg0Wv1tjJ0GAAD1mpeXl26++WZ99dVXCggIUKNGjZSdna2VK1fqzjvvLDeNbeXKleWm2sXGxiohIaHc9LyioiLNnTvXcb+goEDffffdMafw2Z133nkKCAjQ//73P3l6ejraN998I0m69NJL5efnp3POOcexze7LL7884XO/6KKLVFRUpHnz5pXb/sknn0hSucxbt27VkSNHHPejo6N15MiRcjmMMerTp4+effbZap0LAACo37ysDgAAAGClK6+8UiEhIRo9erRGjx5d4fHLL79cP/zwgyRp3759FR7fv3+/mjZt6rifmpqqkpKSY/apin0h8u+//77Sx8PDw9WkSRN5eHgoPT293GMpKSnH3f8/NW3aVOnp6SotLS23PTU1VZLUuHFjx7acnJwKWTMyMmSMqXTf1TkXAABQv1GUAgAA9dqoUaOUkJCgO+64o9x2m82mhQsX6p577nEUpYKDgys8PyQkRDt27HDctxdj/tln//79x81y6NAhSdKNN96ouLi4Co+npaXp4MGDKikpUUhISLnHKjvu8Rw8eFDBwcHy8PAoV5gKCwuTpAqFr39mreyY3bt3l81mq9a5AACA+o3pewAAoN4KCQnRFVdcoc8//1zLli0r15YuXap58+Zp0KBBjlE90dHR5UY8nX322WrXrp2WLFni2BYQEKDLLrvMcd/Pz08DBw4s16cqa9asUWFhoVq2bKn169c7WnFxsV588UVFRkaqsLBQq1ev1rBhw8o9d/DgwSd8/suWLZO3t7euu+66cttvvvlmSWXTFauyYsUK+fj4aMCAAeW2z5w5U0888US1zgUAANRvjJQCAAD11q233ipvb+9ya0D93ezZs3XnnXfqzjvvlCQ1aNBAP/zwg55//nkFBgbqP//5j/744w999tln5Z738ccfa+LEidq/f78effRRNWjQQM8///xx8xw8eFCTJ0/Wc889p6CgIC1dulQtW7bUc889J2OMNm7cKEl64okn9PPPP2vBggV677331KlTJ02cOPGEz//777/Xzz//rA8++EAtW7bUxo0b1bdvX02YMEEff/yxtm7dWuVzFy1apNWrV2vWrFl68skntXPnTt1yyy3q0qWL7rrrrmqfCwAAqN8sX22dRqPRaDQazYq2ZcsWs2nTpmP2SUhIMHv37jXLly83S5cuNU8//bRJT0836enp5qOPPjJNmzZ19LVffW/IkCFm586dJicnxyxevNiceeaZjj7Huvqevd17773mzz//NAUFBSYlJcXMmTPHtG7dulyfiy++2Kxdu9bk5eWZzZs3O66GdyJX35Nk/P39zZQpU8zevXtNQUGB2bp1q3nkkUeMzWZz9ImJiTExMTEV9hcUFGTeeecdk5qaarKzs83KlSvNhRdeeMLnQqPRaDQarX4229EbAAAAOIaYmBhJUr9+/arsM2nSJP373/8ud8U+AAAAVI41pQAAAAAAAOByFKUAAAAAAADgckzfAwAAAAAAgMsxUgoAAAAAAAAuR1EKAAAAAAAALkdRCgAAAAAAAC7nZXWA2iw8PFzZ2dlWxwAAAAAAAHArgYGBSk5OPmYfilJVCA8P1759+6yOAQAAAAAA4JZatmx5zMIURakq2EdItWzZktFSAAAAAAAA1RQYGKh9+/Ydt55CUeo4srOzKUoBAAAAAADUMBY6BwAAAAAAgMtRlAIAAAAAAIDLUZQCAAAAAACAy7GmFAAAAAAA9VhAQICCg4Nls9msjgI3YIxRenq68vLyTnlfFKUAAAAAAKiHbDabRo0apYsuusjqKHBDS5cu1cyZM2WMOel9UJQCAAAAAKAeGjVqlPr27asvvvhC27ZtU3FxsdWR4Aa8vLzUuXNnXX/99ZKkjz766OT3VVOhAAAAAACAe2jQoIEuuugiffHFF1q0aJHVceBmEhISJEnDhw/X559/ftJT+VjoHIBT+QcFyTcgwOoYAAAAAP6mWbNmkqRt27ZZnATuyv6zExwcfNL7oCgFwGn8gwL1xHfz9PAXM+Xj7291HAAAAABH2Rc1Z8oeTpb9Z+dUFsinKAXAaVqf1kUBjYLUvG0b9Rw6yOo4AAAAAIBahKIUAKcJ79jecbv1aZ0tTAIAAAAAqG0oSgFwmrC/FaXCOrQ/Rk8AAAAAOHEjR46UMUa33357je0zIiJCxhhFRESUu30yJk2apJiYmCofHzx4sPbu3avc3FxddtllJxvZbVGUAuA04Z3+KkSFto+Uh5enhWkAAAAA1DU33HCDduzYoVtvvdUp+9+7d69CQ0O1d+9ep+z/2Wef1eLFi9WlSxctX77cKceorqVLl8oYU64VFxerQYMGTjsmRSkATuHp5aUW7do67nv5+Kh5RBvrAgEAAACoU5o3b66LL75YzzzzjC644AK1bdu2xo9RWlqqtLQ0lZaW1vi+JalRo0ZauXKl9uzZo4KCAqcco7rOOussPfLIIwoNDXW0sLAw5ebmOu2YFKUAOEWLdhHy8vZWfla2dsdukiSFd+pgcSoAAAAAdcV1112nQ4cO6dNPP1VycnK50VL2aXc33HCDkpKSlJmZqalTp8rT0/OYj/3TP6fvtWrVSl9//bVyc3O1a9cuPf300/Lw+Ku00qVLF61YsUK5ublasmSJgoODq8y/a9cuRUZGaubMmdq1a5ckqWXLlvriiy+UkZGhAwcOaNq0afLx8XHkePLJJ3Xw4EG9+eabkqSoqCh9//33ys7OVmJioh544AHH/o+X9e86dOigoKAgLV++XGlpaY524MCBE3hFTpyXU/cOoN6yryeVHL9DaTt2qW33MxTeMUobvrM4GAAAAIBj8vH3c9mxjuSf/OigESNGaNGiRTLG6H//+59uvfVWPfvss+X6TJo0ScOHD5e3t7fmzJmjnJwcffDBB1U+9uSTTx7zmAsWLNDGjRt11llnKSwsTO+9955KS0v1/PPPy8fHR4sWLdKKFSs0evRo9e/fX9OmTdOqVasq3VfPnj31+++/65VXXtFnn30mb29v/fzzz4qPj1ffvn3VvHlzffDBBzLG6PXXX5ck9enTRz169JCHh4d8fX31448/6vfff1evXr3Url07zZ07Vzt37tSiRYuOmfWfzjnnHBUVFemPP/44mZfipFGUAuAU4R3LRkWlbN+h1B1lVf8wRkoBAAAAtdqY2e8p8qwzXXa8Xb9v1Fsj7znh57Vq1Up9+vTRa6+9JqmsWHTfffcpOjpaK1eudPR77LHHHEWhp556Si+//LJmzJhR5WPHKkr1799fERER6tWrl4wxiouL07hx4/Txxx/r+eef1yWXXKJmzZrp3nvvVV5enrZv366LLrpILVq0qHR/6enpKikp0eHDh5Wenq7BgwerZcuW6tWrlw4dOiRJuv/++/XNN984CmlTp07Vzp07JZUtkt68eXONGjVKOTk52rJlix544AGVlJQcN+s/nX322fL09FRGRoZj28aNGxUdHV2t1+NkUZQC4BThHaMkSclxZSOlJCmcK/ABAAAAtZsxVieolhEjRqigoECLFy+WVLZI98GDBzVy5MhyRam/j1L67bff1KJFC8eUumM9VpkuXbqoWbNmysrKcmzz8PBQQECAmjZtqq5duyo+Pl55eXmOx9etW6dBgwZV65y6dOmiuLg4R0FKklavXi1vb295eZWVb3bv3u14rFOnToqLi1NOTo5j28cffyyprJh1rKwHDx4sd+yzzz5bc+fO1aRJkxzbnLmWlB1FKQBO4Zi+t32H9u/cLUlqFNJcDRo3Uu6hwxYmAwAAAFCVt0be4xbT92644QYFBASUK7p4eXnpuuuuK7euUlFRkeO2fc0o+6Llx3qsMl5eXtq2bZuGDBlS4bHDh8u+49hstnLbjxw5Uu1zqmyhc3su+3//3ufv+U8m69+dffbZevzxx5WQkFDtvDWBhc4B1LiGTZsoqHlw2ZUqEnaqMC9P6XuTJP1VrAIAAABQOx3JL3BZOxkdOnTQ2WefrQceeEDdu3d3tOHDh6tRo0a6+uqrHX27d+/uuN2jRw/t27fPMUWtssf+OYLo77Zv3642bdrowIEDSkhIUEJCgiIjI/XMM8/IGKM///xTHTt2VFBQkOM5Z511VrXPa/v27erYsaOaNGni2HbeeeepqKhIJSUlFfrHx8erffv28vf3d2ybMmWKpk2bdtysfxcZGakmTZpow4YN1c5aUyhKAahx9sJTxp4kxwdN8vYd5R4DAAAAgJNxww03KCMjQ++//742b97saF9++aU2b96skSNHOvpOmzZN55xzji6++GI9++yzevvtt6v1WGV+/PFHJSYm6pNPPtHpp5+u6Ohovf/++8rLy1Npaan+7//+T3v27NGHH36ozp07a+TIkRo+fHi1z+unn37Szp07NWfOHJ1++um66KKL9Oabb+qzzz4rN6XPbvHixUpNTdV7772nTp06afDgwbrnnnu0ePHi42b9u3POOUfFxcUuX+RcoigFwAnC7VP34nY4tqUcvR3eiaIUAAAAgJM3YsQIffLJJ5VOjXv33Xd1ySWXqGXLlpKkL774QosWLdLcuXM1Y8YMvfTSS46+x3qsMqWlpbrqqqvk4eGhtWvXav78+fruu+/0r3/9S5JUXFysQYMGqUmTJvr999917733HrfQVdn+JWnt2rX6/PPP9fXXX+vuu++utH9JSYmGDBmi8PBwbdiwQdOmTdO4ceP03XffHTfr35199tnatm1bpdMHXcHQKrbAwEBjjDGBgYGWZ6HR3K2NeP4p8+qmX8wld49ybDvj4r7m1U2/mIe+mGl5PhqNRqPRaDQarb63iIgIM3v2bBMREWF5FmednzGm0vM71mO0E/t/XNXPUHVrKoyUAlDj7COlUrbHO7bZp++FRkXK4+gifQAAAACA+ouiFIAa5eHlqZCotpLKT987uC9ZBbm58vb1VfOI1halAwAAAADUFhSlANSoFm0j5OXjo/zsHGUmpzq2G2OUGr9TEoudAwAAAHCuxMRE2Ww2JSYmntBjcC2KUgBqlH0h85S/jZKyS3Ysdt7BpZkAAAAAALUPRSkANco+CiolPqHCY8lH15gK6xjl0kwAAAAAgNqHohSAGhXesWwUVPLfFjm3S4krK1QxUgoAAAAAQFEKQI2yj4JKrmT6Xkp82bbGIS0U0CjIpbkAAAAAALULRSkANaZBk8Zq1KK5SktLHYua/11hbp4ykvZJksI6MIUPAAAAsIoxRpLk5eVlcRK4K/vPjv1n6WS4VVHK19dXM2bMUGZmppKTkzV27Ngq+w4dOlRbtmxRdna2VqxYobPOOsuFSYH6KfzoelIZe/fpSH5+pX1SWOwcAAAAsFxGRoYkqXPnzhYngbuy/+ykp6ef9D7cqiQ6ZcoU9ejRQ/3791dERIRmzZqlxMREzZ8/v1y/rl276rPPPtPdd9+tVatW6eGHH9aiRYsUFRWl/Cq+KAM4dY5FziuZumeXvH2HTu/f19EXAAAAgOvl5uZq6dKluv766yVJ27ZtU3FxscWp4A68vLzUuXNnXX/99Vq6dKny8vJOfl81mMupAgICNHr0aF1xxRXasGGDNmzYoMmTJ2vMmDEVilKXXXaZNm/erDlz5kiSHn/8cY0ZM0Zdu3bV+vXrrYgP1AvhncoKTZWtJ2WX7BgpRVEKAAAAsNLMmTMlScOHD7c4CdzR0qVLHT9DJ8ttilLdunWTt7e3Vq9e7di2cuVKTZw4UTabrdwcxoyMDJ122mk6//zz9csvv2jUqFE6fPiwEhIqXqIeQM0J63D8kVL2x0Kj2snD01OlJSUuyQYAAACgPGOMPvroI33++ecKDg6WzWazOhLcgDFG6enppzRCys5tilJhYWFKT09XUVGRY1taWpr8/f3VrFmzcnMYv/jiC1111VVatWqViouLVVpaqkGDBunQoUMWJAfqBw9PT4W2j5QkJW+Pr7Jfxt59KszLl2+Av4LbtNL+XYmuiggAAACgEnl5edqzZ4/VMVAPuc1C5wEBASosLCy3zX7f19e33PZmzZopNDRU999/v3r16qXZs2dr5syZat68ucvyAvVN87Zt5OXjo4KcXGUmp1bZzxij1PiyUYvhrCsFAAAAAPWW2xSlCgoKKhSf7Pf/OWTs5Zdf1qZNm/TOO+/o999/11133aXc3FyNGjXKZXmB+ib8b4ucH++SoPZ1pVjsHAAAAADqL7cpSu3bt0/BwcHy9PR0bAsNDVVeXl6FaXnnnHOONm7c6LhvjNHGjRsVERHhqrhAvVOdRc7tUhyLnXdwaiYAAAAAQO3lNkWp2NhYFRUVqXfv3o5t0dHRWrduXYVRGcnJyeratWu5bZ06ddKuXbtckhWoj8IcI6WOf0EB+5pTYR2jnJoJAAAAAFB7uc1C5/n5+Zo1a5amT5+uUaNGqWXLlho3bpxjSl5ISIgOHz6sgoICffDBB/r444+1bt06/fLLLxo9erQiIiI0a9Ysi88CqLvCO5aNekqOq3qRc7uUo2tKNQkLlX9QkPKzspyaDQAAAABQ+7jNSClJGjt2rNavX6+YmBi9/fbbmjRpkhYuXChJSk1N1fDhwyVJX375pcaMGaMnnnhCGzZsUJ8+fdS/f38dOHDAyvhAndWgcSM1Cim7kEBq/M7j9i/IydXBfSmSGC0FAAAAAPWV24yUkspGS91222267bbbKjxms9nK3f/oo4/00UcfuSgZUL+FdigrLKXvSVLhPy48UJXkuHg1bRmm8I5R2vnbBmfGAwAAAADUQm41UgpA7WRfsLw6i5zb2deesk/7AwAAAADULxSlAJyycMci59UvSv212Hl7p2QCAAAAANRuFKUAnLKwTmWFpeTtJ1CUOlrACm3fTjYPfhUBAAAAQH3DN0EAp8TD01OhUZGSTmykVMbefTqSXyAffz8Ft2nlrHgAAAAAgFqKohSAU9I8orW8fX1VkJurg/uSq/08U1qqlPij60p1Yl0pAAAAAKhvKEoBOCX2NaFS43fKGHNCz7WPrArrGFXjuQAAAAAAtRtFKQCnxF6Usi9cfiLs60qFd2CxcwAAAACobyhKATgl4fZFzk9gPSk7x0ipThSlAAAAAKC+oSgF4JSEHx0plRKXcMLPtReymoaHyS+wYY3mAgAAAADUbhSlAJw0/6AgNQ4NkSSlxJ/4SKmC7BwdTE6R9FdxCwAAAABQP1CUAnDSwo8uUJ6RtE+FuXkntQ/7CKswilIAAAAAUK9QlAJw0v5a5PzER0nZJcfFH90XV+ADAAAAgPqEohSAkxbeqYOkvxYsPxn2kVLhHTvUSCYAAAAAgHugKAXgpNlHN53MlffskreXjZQKbd9ONg9+JQEAAABAfcE3QAAnxcPTU2HtjxalTmH6XvqeJBUVFMo3wF/NWresqXgAAAAAgFqOohSAkxLcppW8/XxVmJeng0n7Tno/prRUKTvsU/hY7BwAAAAA6guKUgBOir2AlBKfIGPMKe0r5ehIK/saVQAAAACAuo+iFICTYr/ynn2h8lNhX5OKK/ABAAAAQP1BUQrASbEXpewLlZ8KR1GqA9P3AAAAAKC+oCgF4KSEd7KPlDr5Rc7t7Pto1ipcfg0bnPL+AAAAAAC1H0UpACfMPyhQTcJCJZWtKXWq8rOylZmSKkkK68AUPgAAAACoDyhKAThh9ql7GUnJKsjJrZF92temYrFzAAAAAKgfKEoBOGHhRxckT4k/9al7dn8tds66UgAAAABQH1CUAnDC7AuSJ2+vuaJUytEF07kCHwAAAADUDxSlAJww+xS7mljk3O6vK/BFyWaz1dh+AQAAAAC1E0UpACfE5uGh0PbtJP1VSKoJ6XuSVFRQKN+AADVt1bLG9gsAAAAAqJ0oSgE4IcFtWsnH30+FefnK2LuvxvZbWlKi1ISdkqTwTqwrBQAAAAB1HUUpACfEvhB56o6dMqWlNbpvxxX4WOwcAAAAAOo8ilIAToh9FFNyXHyN7zv56GLnjJQCAAAAgLqPohSAExJ+9Mp79lFNNcmx2DkjpQAAAACgzqMoBeCE2AtG9lFNNcl+Nb9mrVrKt0FAje8fAAAAAFB7UJQCUG1+gQ3VtGWYJCklvuZHSuUdztKhtP2SpLAOjJYCAAAAgLqMohSAagvrECVJOpicooLsHKccwz4CK6xjlFP2DwAAAACoHShKAai28E4dJEkp23c47RiOK/AdPRYAAAAAoG6iKAWg2uyjl5LjnVmUKtt3OIudAwAAAECdRlEKQLXZr7yX7MSRUvbpe6Ed2slmszntOAAAAAAAa1GUAlAtNg8PhR5dU8o+mskZDiTuVVFhofwaNFDTluFOOw4AAAAAwFoUpQBUS7NW4fIN8NeR/AKl70ly2nFKS0qUmrBLkhTGFD4AAAAAqLMoSgGoFvvC46k7dsqUljr1WI51pTpRlAIAAACAuoqiFIBqsY9acubUPTv7mlWMlAIAAACAuouiFIBqsY9aSo6Ld/qxGCkFAAAAAHWfWxWlfH19NWPGDGVmZio5OVljx46tsu/pp5+uFStWKC8vT3/88Ycuuugi1wUF6qAw+5X34hKcfix7USq4dSv5BgQ4/XgAAAAAANdzq6LUlClT1KNHD/Xv31/33XefJk2apGHDhlXoFxQUpJ9++klbtmzRGWecoQULFmjhwoVq3ry5BakB9+fXsIGatSq7Ep4rpu/lHjqsw2kHJEmhHdo5/XgAAAAAANdzm6JUQECARo8erQcffFAbNmzQV199pcmTJ2vMmDEV+o4cOVI5OTm69957lZCQoH//+9+Kj49Xjx49LEgOuL+wDlGSpMyUVOVnZbvkmMnxR6fwdezgkuMBAAAAAFzLbYpS3bp1k7e3t1avXu3YtnLlSvXq1Us2m61c34suukhff/21Sv92hbBzzz1X33//vcvyAnXJX4ucO3/qnl3K9vijx45y2TEBAAAAAK7jNkWpsLAwpaenq6ioyLEtLS1N/v7+atasWbm+7dq104EDB/Tee+8pJSVFv/zyi84//3xXRwbqjPBOZaOVkrc7f5FzO/vaVfZjAwAAAADqFrcpSgUEBKiwsLDcNvt9X1/fctsbNmyoCRMmKCUlRVdccYWWLVumH3/8Ua1atXJZXqAusY9WcsV6Unb2Y4V1iKowGhIAAAAA4P7cpihVUFBQofhkv5+Xl1due3FxsTZs2KB///vfio2N1YQJExQXF6dbbrnFZXmBusJmsznWlEp2YVFq/+5EFR85Ir+GDdSkZZjLjgsAAAAAcA23KUrt27dPwcHB8vT0dGwLDQ1VXl6eDh06VK5vSkqKtm3bVm5bXFycWrdu7YqoQJ3StFVL+QYEqKigUOl7klx23NLiEqUl7JYkhR9d0woAAAAAUHe4TVEqNjZWRUVF6t27t2NbdHS01q1bJ2NMub5r1qxRt27dym3r3Lmzdu/e7YqoQJ0Sbp+6tyNBpSUlLj12cpx9sXOKUgAAAABQ17hNUSo/P1+zZs3S9OnT1aNHDw0ZMkTjxo3TtGnTJEkhISHy8/OTJE2fPl1nnnmmJk2apKioKD3zzDNq166dPvnkEytPAXBL9oXGXXnlPTv7dEFGSgEAAABA3eM2RSlJGjt2rNavX6+YmBi9/fbbmjRpkhYuXChJSk1N1fDhwyVJe/bs0eWXX67Bgwfrzz//1ODBgzVo0CAlJydbGR9wS/ZRSq5c5NwuZfuOchkAAAAAAHWHl9UBTkR+fr5uu+023XbbbRUe++fVuVavXq0ePXq4KBlQd4V3KisIJW+Pd/mx7SOlmrVuKR9/fx3Jz3d5BgAAAACAc7jVSCkAruXbIEDNWrWUJCVbMH0vN/OQsg6ky8PDQ6Ed2rn8+AAAAAAA56EoBaBKYe3LFjk/lJqm/KwsSzIkb2ddKQAAAACoiyhKAahSmH3qngXrSdnZ17KyL7gOAAAAAKgbKEoBqFK4Y5Fz10/ds0uOK1vLKqxDlGUZAAAAAAA1j6IUgCrZRydZsci5nX0tK67ABwAAAAB1i1OuvnfBBRec1PNWrFhRw0kAnCybzeZYXDzFwul7B3YlqrioSP6BDdUkPFSZyamWZQEAAAAA1BynFKWWLl0qY4xsNlu1n1NaWipvb29nxAFwEpq2DJdfgwYqKizUgcS9luUoKS5WWsIutezcUeGdOlCUAgAAAIA6wmnT98LDw+Xp6VmtFh4eLg8PZhICtYl9ulxqwi6VlpRYmiWFKXwAAAAAUOc4pRL0+OOPK+sELh+flZWlxx9/3BlRAJyk8I5lC4unbLdu6p6dfU2rcIpSAAAAAFBnOGX63ty5c9W8efNq9d27d6/y8/M1efJkZ0QBcJLC7IucW7ielF1KfFkGilIAAAAAUHc4pSi1e/duGWMqbLfZbBW2e3k5JQKAU2QvAFm5yLld8tHRWs3atJKPv5+O5BdYnAgAAAAAcKqcUhGKjIys8rHu3bvr9ddfV8uWLfXKK6844/AATpFvQICC27SSVDuKUjkHM5WVnqGg4GYKbd9OezZtsToSAAAAAOAUOaUotWfPngrbAgIC9Nxzz2nMmDFavny5Bg4cqO3btzvj8ABOUWiHdpKkw2kHlHvosMVpyqTE7VBQcDOFdWxPUQoAAAAA6gCXXPLu2muv1bZt23TDDTdo1KhRuvTSSylIAbWY/Sp3yXHxFif5i30KH+tKAQAAAEDd4NSiVLt27fTDDz9o7ty5+vrrr9W5c2d99tlnzjwkgBpQm9aTsrNnCetEUQoAAAAA6gKnFKW8vb01adIkbdq0SY0bN9a5556rBx54QFlZWc44HIAaFu4YKZVgcZK/2EdthXegKAUAAAAAdYFT1pTasmWLIiMjtXv3bn3//fe68sordeWVV1ba97nnnnNGBAAnyWaz/TV9b3vtmb63f2eiSoqK5R8UqCZhocpMSbU6EgAAAADgFDilKJWUlKS9e/dKkvr27VtlP2MMRSmglmkSHiq/hg1UfOSIDiRWvGiBVUqKi5W2a7fCO7ZXWMf2FKUAAAAAwM05pSjVr18/Z+wWgAuEd+ogSUrdsUulxSUWpykveXu8wju2V3in9tqybKXVcQAAAAAAp8Apa0rl5uaqWbNm1e7fvHlz5ebmOiMKgBNkn7qXEl97Fjm3Szm6xlUYV+ADAAAAALfnlJFSfn5+euyxx5STk1Ot/g0bNpSvr68zogA4QWEdoiRJydtrX1HKvsZVOEUpAAAAAHB7TilKLV++XD179jzh5wCwnn36Xkpc7StK2TMFt2klbz9fFRUUWpwIAAAAAHCyWFMKgIOPv7+atW4pSUquhUWp7IyDys44qMBmTRUa1U57N2+1OhIAAAAA4CQ5ZU0pAO4ptEM7eXh46PD+A8rNPGR1nErZR0uFd2IKHwAAAAC4M4pSABzsazXZFxSvjewjuFjsHAAAAADcG0UpAA729aSS4+ItTlI1+wLsFKUAAAAAwL1RlALgYL/yXm1c5NyO6XsAAAAAUDe4pCgVGRmpyZMna+HChQoNDdWoUaPUp08fVxwawAmwjz6yj0aqjdJ27lZJUbECgoLUOKSF1XEAAAAAACfJ6UWpCy64QH/88YciIyM1YMAA+fv7q3Pnzvr555919dVXO/vwAKqpSXio/AMbqrioSPt3J1odp0olf8sXdnS6IQAAAADA/Ti9KDV58mRNmDBB1113nYqKiiRJ48eP12OPPaZnn33W2YcHUE32Rc7TEnaptLjE4jTHlry9bM2rcNaVAgAAAAC35fSi1BlnnKHvvvuuwvb//e9/ioqKcvbhAVSTfdRRbZ66Z8e6UgAAAADg/pxelNq9e7d69uxZYfugQYO0e/duZx8eQDXZRx3V5kXO7ZLjEiRxBT4AAAAAcGdezj7Ak08+qY8//lg9evSQl5eXbr31VkVGRuqGG27QzTff7OzDA6gm+5X3kt2hKHV0+l7ziNby8vVVcWGhxYkAAAAAACfK6SOlvvrqK1144YUKCQnRn3/+qSFDhsjX11cXXHCB5s2b5+zDA6gGH38/BUe0luQeI6Wy0zOUczBTHp6eCo2KtDoOAAAAAOAkOL0oJUkpKSl6/vnnde655+rss8/WggULlJhYe6/uBdQ3IVHt5OHhoayjxR53YB/RxWLnAAAAAOCenF6U6tevn3bs2KGbbrrJse3BBx/U1q1bdf755zv78ACqwb5geMrRaXHuwD6iK4zFzgEAAADALTm9KPXqq6/qhRde0L///W/HtujoaE2ePFlTp0519uEBVIN9tJF9AXF3kMJIKQAAAABwa04vSnXs2FH//e9/K2z/8ssvddpppzn78ACqwT7aKDnOfUZKJW8/OlKKohQAAAAAuCWnF6W2bdum66+/vsL2wYMHKyHBfUZlAHVZeIej0/fcYJFzu7Sdu1VSXKwGjRupUUhzq+MAAAAAAE6Ql7MPMHHiRP3vf//TpZdeqvXr10uSunXrpgsuuEDDhg1z9uEBHEfj0BD5BwWquKhI+3e6zwUIio8c0f5diQrrEKWwju11OO2A1ZEAAAAAACfA6SOlFi9erO7du2vDhg3q0qWL2rdvr9jYWJ122mn6/vvvnX14AMcR3qmDJGn/0ZFH7iQlvmy0ZXjHDhYnAQAAAACcKKcXpRYuXKjS0lKNGzdOgwcP1jXXXKPx48dr165dJ7wvX19fzZgxQ5mZmUpOTtbYsWOP+5yIiAhlZ2erb9++JxMfqPPCOkZJkpLdaOqeXfLRqwWGHz0HAAAAAID7cPr0vT59+qi4hkZfTJkyRT169FD//v0VERGhWbNmKTExUfPnz6/yOe+++64aNmxYI8cH6iL7SKmU7e5XlLKvgRXWiZFSAAAAAOBunF6Ueuedd/TFF19o+vTpSkxMVEFBQbnHV6xYUa39BAQEaPTo0briiiu0YcMGbdiwQZMnT9aYMWOqLErdeOONCgwMPOVzAOqy8I72K++5X1EqOa5s+l6Ltm3k5eOj4iNHLE4EAAAAAKgupxelnnrqKUnSe++9V+ExY4y8vKoXoVu3bvL29tbq1asd21auXKmJEyfKZrPJGFOuf9OmTTV58mRddtll2rx58ymcAVB3efv5KrhNK0lScly8xWlOXNb+A8rNPKQGTRorJKqt9m2NszoSAAAAAKCanL6mlKenZ5WtugUpSQoLC1N6erqKiooc29LS0uTv769mzZpV6P/aa69p1qxZ2rJlS42cB1AXhUa1k4enp7IzDionI9PqOCfFPsIrnCl8AAAAAOBWnD5SSpL8/Px08803q0uXLvL09NS2bdv0xRdfKDOz+l+CAwICVFhYWG6b/b6vr2+57RdffLGio6N1+umnn3p4oA4LOzp1L8UNp+7ZJcftUIdePRznAgAAAABwD04fKXXaaacpPj5eTz75pCIiIhQREaEnnnhC27ZtU5cuXaq9n4KCggrFJ/v9vLw8xzY/Pz+99957uu+++yqsXwWgvPBOR9eTcsNFzu3sBbVwilIAAAAA4FacXpSaNm2afvrpJ0VFRenaa6/V1VdfrcjISH333XeaOnVqtfezb98+BQcHy9PT07EtNDRUeXl5OnTokGPbueeeq6ioKM2fP1/Z2dnKzs6WJH3//fd69913a+q0gDohzI0XObejKAUAAAAA7snp0/fOO+883XfffSopKXFsKykp0UsvvaTffvut2vuJjY1VUVGRevfurVWrVkmSoqOjtW7dunKLnP/6669q3778l9MdO3Zo9OjR+umnn07xbIC65a+RUu63yLld6o5dKi0pUYMmjRXUormy9h+wOhIAAAAAoBqcXpRKSUlR+/btFRdX/qpY7du3V1ZWVrX3k5+fr1mzZmn69OkaNWqUWrZsqXHjxmnUqFGSpJCQEB0+fFgFBQVKSEio8Px9+/bpwAG+rAJ2jUNaKCAoSCVFxdq/K9HqOCet+MgR7d+9R6FRkQrvGEVRCgAAAADchNOn702fPl0zZszQ7bffrtNPP12nn366Ro8erQ8++EAzZsw4oX2NHTtW69evV0xMjN5++21NmjRJCxculCSlpqZq+PDhzjgFoE6yT91L27VbJX+7qqU7Sjk60ovFzgEAAADAfTh9pNQrr7yiBg0a6OWXX1bTpk0lSWlpaXrttdf06quvntC+8vPzddttt+m2226r8JjNZqvyecd6DKivwjt1kOTeV96zS45L0FkD/zonAAAAAEDt5/SilCQ988wzeuaZZ9S8eXMVFBQ4Fh8HYJ2wjlGS6kpR6uhIqQ5RFicBAAAAAFSXU6bvLVu2TI0aNSq3zc/PTwcOHKAgBdQS9lFFydvdvyhlL6y1iIyQl4+PxWkAAAAAANXhlKJUdHS0fP7xxTAtLU2RkZHOOByAE+Tl66vmEa0lScl1YKTU4bQDyjucJU8vL4W0a2t1HAAAAABANTh9oXM71nUCao/QqLby8PRUdsZBZadnWB2nRiSz2DkAAAAAuBWXFaUA1B7hHY8uch6fYHGSmmMf8RXeiaIUAAAAALgDilJAPWQfTWQfXVQXpBxdG4uRUgAAAADgHpx29b3rr79eWVlZjvuenp66+uqrdeDAgXL95syZ46wIAKpgH02UElcHR0pRlAIAAAAAt+CUotSePXv0yCOPlNuWlpamMWPGlNtmjKEoBVjAPpoopQ4scm6XmrBLpSUlati0iQKDm9WZtbIAAAAAoK5ySlGKq+wBtVejkOZq0LiRSoqLlZqwy+o4Naa4sFAHEvcqpF1bhXfqoO0UpQAAAACgVmNNKaCesY+S2r8rUSVFRRanqVkpjil8URYnAQAAAAAcD0UpoJ4Jr4NT9+ySWewcAAAAANwGRSmgnrEXpZLrYlHKPlKqUweLkwAAAAAAjoeiFFDP1MVFzu1StsdLklq0jZCnt7fFaQAAAAAAx0JRCqhHvHx81LxtG0l/TXWrSw6l7VdeVpY8vb0U0q6t1XEAAAAAAMdAUQqoR0Ki2srTy0u5mYeUdSDd6jhOkRKXIIl1pQAAAACgtqMoBdQj9rWW6uIoKbvko1P4wilKAQAAAECtRlEKqEfso4eS4+tuUSrFsdg5RSkAAAAAqM0oSgH1SHiHo4ucHx1NVBfZR4ExfQ8AAAAAajeKUkA9Yh89lFwHr7xnl5qwU6UlJQps1lSBzZpaHQcAAAAAUAWKUkA9EdQ8WA2aNFZJcbHSEnZbHcdpigoKlb4nSRKjpQAAAACgNqMoBdQT9lFSB3bvUfGRIxanca5kx7pSHSxOAgAAAACoCkUpoJ6wjxpKqcNT9+zs5xjWMcriJAAAAACAqlCUAuqJ8I51fz0pO/ti5+FM3wMAAACAWouiFFBPhNWjopR9pFSLdm3l6eVlcRoAAAAAQGUoSgH1gKe3t1pERkiqH9P3MlNSlZ+VLS9vb7VoF2F1HAAAAABAJShKAfVAaFSkPL28lHvosA6nHbA6jkskx9un8LHYOQAAAADURhSlgHqgPi1ybpcSlyDpr3MHAAAAANQuFKWAeiC809H1pLbXn6JU8vZ4SVI4V+ADAAAAgFqJohRQD9TPkVJl5xrWiel7AAAAAFAbUZQC6oFwx5X34i1O4jqpO3aqtLRUQcHN1LBZE6vjAAAAAAD+gaIUUMcFBjdTw6ZNVFpSotSE3VbHcZkj+QXK2JMk6a+iHAAAAACg9qAoBdRx9oLMgcS9Ki4stDiNayXbp/B1oCgFAAAAALUNRSmgjvtrkfP6M3XPzl6UCmddKQAAAACodShKAXXcX4ucJ1icxPUci51zBT4AAAAAqHUoSgF1nL0oVS9HSh0955CoSHl4eVqcBgAAAADwdxSlgDrM09tbIZFtJf01aqg+yUxOVX52jry8vdXi6P8HAAAAAEDtQFEKqMNaREbI09tLeVlZOpS23+o4lrAX48KZwgcAAAAAtQpFKaAOsy/wnby9/o2SskuJL1tLK7wji50DAAAAQG1CUQqow8Idi5zX36JUsmOx8/YWJwEAAAAA/B1FKaAOC+9kX+S8Hhelji52bv9/AQAAAACoHShKAXVYGCOllBq/U6WlpQpqHqyGTZtYHQcAAAAAcJRbFaV8fX01Y8YMZWZmKjk5WWPHjq2y78CBA7VhwwZlZ2dr48aNGjx4sAuTAtZr2KyJAps1VWlJiVITdlodxzJH8vOVsXefJCmsA4udAwAAAEBt4VZFqSlTpqhHjx7q37+/7rvvPk2aNEnDhg2r0O+MM87QggUL9NFHH6l79+5677339N///ldnnnmmBakBa9gX9k7fk6SigkKL01jLPlIsjCl8AAAAAFBruE1RKiAgQKNHj9aDDz6oDRs26KuvvtLkyZM1ZsyYCn1vvPFG/fzzz3rzzTeVkJCgd955RzExMbr++ustSA5Yw77IeXI9nrpnZ/9/EM5i5wAAAABQa3hZHaC6unXrJm9vb61evdqxbeXKlZo4caJsNpuMMY7ts2bNko+PT4V9NGrUyCVZgdogzLHIebzFSayX4ihKdbA4CQAAAADAzm1GSoWFhSk9PV1FRUWObWlpafL391ezZs3K9d22bZv++OMPx/2uXbvq4osv1pIlS1yWF7BauGOR8wSLk1jPPlIqJKqtPLw8LU4DAAAAAJDcqCgVEBCgwsLy6+LY7/v6+lb5vGbNmmn+/PlatWqVvv76a6dmBGoLTy8vtWjXVhIjpSQpc1+KCnJy5eXjo+YRbayOAwAAAACQGxWlCgoKKhSf7Pfz8vIqfU6LFi30888/y8PDQ9dee225KX5AXdaiXYS8vL2Vl5WlQ6lpVsexnDFGKfFlI8bCOzGFDwAAAABqA7cpSu3bt0/BwcHy9Pxr6k1oaKjy8vJ06NChCv3Dw8O1fPly+fr66qKLLlJ6eroL0wLWCmPqXgX2EWPhHaMsTgIAAAAAkNyoKBUbG6uioiL17t3bsS06Olrr1q2rMAIqICBAP/zwg0pLS9W3b1+lpKS4Oi5gKfuC3ilcec/BXqALY6QUAAAAANQKbnP1vfz8fM2aNUvTp0/XqFGj1LJlS40bN06jRo2SJIWEhOjw4cMqKCjQE088oaioKF100UWOx+z7yMrKsuoUAJexjwZKpijl4LgCX4f2FicBAAAAAEhuNFJKksaOHav169crJiZGb7/9tiZNmqSFCxdKklJTUzV8+HBJ0rBhwxQQEKBff/1VqampjjZt2jQr4wMuYx8NlLydopSdfU2pRiHN1aBxI4vTAAAAAADcZqSUVDbS6bbbbtNtt91W4TGbzea43aVLFxemAmqXhs2aKCi4mUpLS5WWsNPqOLVGYV6e0vcmKbh1K4V1bK8dv663OhIAAAAA1GtuNVIKwPGFHZ2elp64V0fyCyxOU7vYR47ZF4IHAAAAAFiHohRQx4Tbr7wXz5X3/smxrlQnilIAAAAAYDWKUkAdYx8FxCLnFTFSCgAAAABqD4pSQB1jHwWUsj3e4iS1j32kVGhUpDw8PS1OAwAAAAD1G0UpoA7x8PJUSFSkJEZKVebgvmQV5ObK29dXzSNaWx0HAAAAAOo1ilJAHdIisq28vL2Vn52jzORUq+PUOsYYpcaXXZGQKXwAAAAAYC2KUkAdEt4xStJf09RQUbJjsfMOFicBAAAAgPqNohRQh7DI+fElH11rK+xoAQ8AAAAAYA2KUkAdEt6xbPQPI6WqlhKXIImRUgAAAABgNYpSQB1iH/3DSKmqpcSX/b9pHNJCAY2CLE4DAAAAAPUXRSmgjmjQpLEatWiu0tJSx2LeqKgwN08ZSfsksdg5AAAAAFiJohRQR4QfLbBk7N2nI/n5Fqep3ezTG8MpSgEAAACAZShKAXWEY5Hzowt5o2rJ28uKUoyUAgAAAADrUJQC6ojwTmUFlpT4BIuT1H72Nbfs/88AAAAAAK5HUQqoI8I6HC1Kscj5cdlHSoVGtZOHp6fFaQAAAACgfqIoBdQBHl6eCm0fKYnpe9VxMGmfCvPy5e3nq+A2rayOAwAAAAD1EkUpoA5oHtFGXj4+KsjJVWZyqtVxaj1jjFKPTnNksXMAAAAAsAZFKaAOCO/UQVLZ1D1jjMVp3IN9XSkWOwcAAAAAa1CUAuqA8I5Rkv4qtOD4UhyLnXewOAkAAAAA1E8UpYA6wD7ah6JU9dnX3go7WtADAAAAALgWRSmgDgjv+Nf0PVRPytE1pZqEhco/KMjiNAAAAABQ/1CUAtxcg8aN1CikuSQpNX6nxWncR0FOrjKSkiUxWgoAAAAArEBRCnBz9ql76XuSVJiXZ3Ea95ISf3RdKRY7BwAAAACXoygFuDnWkzp5KXFlU/goSgEAAACA61GUAtycvaCScnThblTfX4udU5QCAAAAAFejKAW4ubBO9pFSCRYncT/20WWh7dvJ5sGvQwAAAABwJb6FAW7Mw9NToVGRkqTkOEZKnaiMvftUmJcvH38/BbdpZXUcAAAAAKhXKEoBbqx5RGt5+/qqIDdXmftSrI7jdkxpqVJ3lF2xMLxTB4vTAAAAAED9QlEKcGP2tZBS43fKGGNxGveUcnQKX1jHKIuTAAAAAED9QlEKcGP20T3JLHJ+0uzrSoV3ZKQUAAAAALgSRSnAjdlH99gLKzhxjJQCAAAAAGtQlALcWPjR6Xsp2ylKnSx7Qa9peJj8AhtanAYAAAAA6g+KUoCb8g8KUuPQEElSyo4Ei9O4r4LsHB1MLlsk3l7kAwAAAAA4H0UpwE2FH51ulpG0T4W5eRancW/2kWZhFKUAAAAAwGUoSgFu6q9Fzpm6d6qS4+2LnVOUAgAAAABXoSgFuCn7qJ4UFjk/ZSlxZdMfGSkFAAAAAK5DUQpwU+GdygooydvjLU7i/uz/D0Pbt5PNg1+LAAAAAOAKfPsC3JCHp6dCo9pJkpLjWOT8VKXvSdKR/AL5BvirWeuWVscBAAAAgHqBohTghoLbtJK3n68K8/J0MGmf1XHcniktVeqOnZJYVwoAAAAAXIWiFOCG7IWTlPgEGWMsTlM32Nfmsi8gDwAAAABwLopSgBv6a5Fzpu7VlOSjRamwjlEWJwEAAACA+sGtilK+vr6aMWOGMjMzlZycrLFjx1bZt3v37lqzZo1yc3P166+/6uyzz3ZhUsC57KN5WOS85tiLUuEdGSkFAAAAAK7gVkWpKVOmqEePHurfv7/uu+8+TZo0ScOGDavQLyAgQN99951WrFihc845R6tXr9aiRYsUEBBgQWqg5tlH89innOHU2f9fNm0ZJr+GDSxOAwAAAAB1n9sUpQICAjR69Gg9+OCD2rBhg7766itNnjxZY8aMqdB3+PDhys/P16OPPqpt27bpoYceUnZ2tq677joLkgM1yz8oUE3CQiWVrSmFmpGfla3MlFRJUlgHpvABAAAAgLO5TVGqW7du8vb21urVqx3bVq5cqV69eslms5Xr27t3b61cubLctlWrVum8885zSVbAmVp27ihJykhKVkFOrsVp6hb7Gl0sdg4AAAAAzudldYDqCgsLU3p6uoqKihzb0tLS5O/vr2bNmik9Pb1c382bN5d7flpamk4//XSX5a0t/IMC1e6c7hUKd3Bfp/W7QJK0548/LU5S9yRt2aauffvojEsu0uH9B6yOAwAAAKCeKSoo1I51v6vkb7WPusxtilIBAQEqLCwst81+39fXt1p9/9mvPrhl8rPq1Ke31THgBLs3UpSqaRt/itFl996hDr16qEOvHlbHAQAAAFAPLX77A/04/SOrY7iE2xSlCgoKKhSV7Pfz8vKq1fef/eqD3779Qd5+frJ5uM1MTVRDbmamfl+02OoYdU5qfIL+7/2PFdWTq3UCAAAAcL2iwkJtW7XG6hgu4zZFqX379ik4OFienp4qKSmRJIWGhiovL0+HDh2q0Dc0NLTcttDQUKWkpLgqbq3x+7eL9fu3FC+A6vr+zfesjgAAAAAA9YLbDJ+JjY1VUVGRevf+aypadHS01q1bJ2NMub5r1qzR+eefX25bnz59tGZN/ak2AgAAAAAA1GZuU5TKz8/XrFmzNH36dPXo0UNDhgzRuHHjNG3aNElSSEiI/Pz8JEn//e9/1bhxY02dOlVdunTR1KlT1aBBA3355ZdWngIAAAAAAACOcpuilCSNHTtW69evV0xMjN5++21NmjRJCxculCSlpqZq+PDhkqTs7GxdeeWVuuCCC7R+/Xr17t1bAwcOrJdrSgEAAAAAANRGNknmuL3qocDAQGVlZSkoKEjZ2dlWxwEAAAAAAHAL1a2puNVIKQAAAAAAANQNFKUAAAAAAADgchSlAAAAAAAA4HIUpQAAAAAAAOByFKUAAAAAAADgcl5WB6jtAgMDrY4AAAAAAADgNqpbS6EoVQX7/8B9+/ZZnAQAAAAAAMD9BAYGKjs7u8rHbZKM6+K4l/Dw8GP+zwMAAAAAAEBFgYGBSk5OPmYfilIAAAAAAABwORY6BwAAAAAAgMtRlAIAAAAAAIDLUZQCAAAAAACAy1GUAgAAAAAAgMtRlAIAAAAAAIDLUZQCAAAAAACAy1GUqgN8fX01Y8YMZWZmKjk5WWPHjq2yb/fu3bVmzRrl5ubq119/1dlnn+3CpKhp4eHhmjdvnjIyMpSUlKRXX31Vvr6+lfb96quvZIwp1wYNGuTixKgpQ4cOrfB6zps3r9K+F198sTZt2qTc3FwtWbJEkZGRLk6LmjBy5MgKr7kxRiUlJZX2j42NrdD3tNNOc3FqnCofHx9t2rRJffv2dWxr27atfvrpJ+Xk5Gjz5s269NJLj7mPESNGaMeOHcrNzdWCBQvUrFkzZ8dGDajste/Vq5dWrVql7Oxsbdu2TXfccccx95GZmVnh90CDBg2cHR2nqLLXfurUqRVey/vvv7/KfTz44INKSkpSVlaWZsyYIX9/f1dExyn652s/c+bMSj/7lyxZUunzGzduXKHvgQMHXHkKOAHH+i5X3z7rDc292xtvvGFiY2PNWWedZYYOHWoOHz5shg0bVqFfQECASU5ONlOmTDGdO3c2U6dONSkpKSYgIMDyc6CdXFu9erVZtGiR6dq1q4mOjjZxcXFm8uTJlfaNi4szN954owkJCXE0Hx8fy8+BdnLtiSeeMF9//XW517NRo0YV+rVu3dpkZ2ebsWPHmq5du5rPP//cbNy40fL8tBNvfn5+5V7vVq1ambi4OPPaa69V6Ovh4WHy8vLMBRdcUO45np6elp8HrfrN19fXzJ8/3xhjTN++fR3bY2NjzZw5c0znzp3NhAkTTE5OjmndunWl++jZs6fJzc01t9xyiznjjDNMTEyM+eabbyw/N9qJv/YhISHm4MGD5oUXXjDt27c3w4cPN3l5eWbgwIGV7iM8PNwYY0xkZGS53wNWnxvtxF97SebHH38048ePL/da+vv7V7qPa665xmRmZppBgwaZHu6NgtgAABAsSURBVD16mD///NO8+eablp8b7cRf+6CgoHKvea9evUx+fr4ZMmRIpfs4//zzzYEDB8o9p3nz5pafG63ydqzvcvXss97yALRTaAEBASYvL6/ch9bEiRNNTExMhb6jRo0yCQkJ5bbFxcWZkSNHWn4etBNvnTp1MsYY06JFC8e2ESNGmKSkpAp9fXx8TFFRkenQoYPluWk10+bMmWNeeOGF4/Z75plnyv0+8Pf3N4cPHy73O4Pmnm3ChAkmPj6+0uJyVFSUKS4uNr6+vpbnpJ1c69Kli9mwYYOJjY0t9wWlX79+Jjs7u9w/KP30009m0qRJle5n1qxZZubMmY77rVq1MiUlJaZt27aWnyPtxF77u+++22zZsqVc3+nTp5tPPvmk0v1cfPHFZt++fZafD+3UX3tJZu/evebSSy+t1n6WLVtW7ndCnz59TG5ubpVFLJr17Viv/d/bDz/8YGbPnl3lfu644w6zatUqy8+Hdvx2rO9y9e2znul7bq5bt27y9vbW6tWrHdtWrlypXr16yWazlevbu3dvrVy5sty2VatW6bzzznNJVtSs1NRUXX755dq/f3+57Y0aNarQt1OnTjLGaOfOna6KByfr2rWr4uLijtuvd+/eWr58ueN+fn6+fv/9d973bq5JkyYaP368JkyYoCNHjlR4vGvXrtq7d68KCwstSIea0LdvX8XExFR4r/bu3Vu///678vLyHNtWrlxZ5Xv6n78DkpKStGfPHvXu3ds5wXHKqnrtf/jhB40aNapC/8o+96Xqf06g9qjqtQ8MDFSrVq2q9Xp6eHioZ8+e5d73a9askY+Pj7p161bjmVEzqnrt/65///668MIL9cQTT1TZh/e9+zjWd7n69llPUcrNhYWFKT09XUVFRY5taWlp8vf3rzCPNCwsTMnJyeW2paWlqVWrVi7Jipp1+PBh/fjjj477NptNY8aMqXSOeZcuXXT48GHNmTNHycnJWrt2rQYMGODKuKhhnTp10uWXX67t27drx44devHFF+Xt7V2hH+/7uunee+9VcnKy5s+fX+njXbp00ZEjR/TNN98oJSVFS5cuVc+ePV2cEqdi+vTpGjt2rPLz88ttP9H3NL8D3E9Vr31iYqLWrl3ruN+8eXONGDGiyrVlunTpooCAAMXExCg5OVmLFi1Shw4dnJodp6aq175Lly4qLS3VxIkTtXfvXsXGxurWW2+tdB+NGzeWv79/ufd9SUmJMjIyeN/XYlW99n83YcIEffzxx0pKSqqyT5cuXdSqVSutXbtWSUlJmjt3rkJDQ50RGafoWN/l6ttnPUUpNxcQEFDhX8Lt9/+54HVVfataGBvuZfLkyTr77LM1ceLECo917txZAQEBWrx4sQYMGKDvvvtO33zzjc455xwLkuJUtWnTRg0aNFBhYaGuv/56jRs3TjfddJOmTJlSoS/v+7pp9OjRevPNN6t8vHPnzmrSpIlmzJihgQMHasuWLVqyZInb/HGCqp3oe5rfAXWTn5+f5s+fr9TUVL333nuV9uncubOaNm2q559/XkOGDFF+fr6WLFmihg0bujgtTlXnzp1ljNG2bds0cOBAzZgxQ++//76GDh1aoW9AQIAk8b6vYyIjI9W/f/9jfvZLZT8rQUFBevjhhzV8+HCFh4fr22+/lYcHX/tru79/l6tvn/VeVgfAqSkoKKjww2a///fhfsfq+89+cD8vvfSSHnroIQ0fPlybN2+u8Phzzz2nN954Q4cOHZIk/fHHHzrnnHN011136e6773ZxWpyqPXv2qGnTpsrMzJQkbdy4UR4eHvrkk080duxYlZaWOvpW9b63/yzA/fTo0UOtWrXS559/XmWfO++8UwEBAcrOzpYk3XffferTp49uueUWvfjii66KCicoKCioMBL6WJ/lfPbXPQ0aNNDXX3+tjh07Kjo6usqRFQMGDJC3t7dyc3MlSTfddJP27t2rwYMHa+7cua6MjFM0e/ZsffPNN47P/U2bNqljx46699579dVXX5XrW1BQIKniP07zvndvw4YNU2xsrLZu3XrMfqeddpqMMY6fg2uvvVYpKSnq1auXfvnlF1dExUn453e5+vZZT8nUze3bt0/BwcHy9PR0bAsNDVVeXl6FL5379u2rMHwzNDRUKSkprogKJ3njjTf0yCOP6Oabb9aCBQsq7WOMqfDzsHXrVrVs2dIFCeEM9j9M7bZu3Sp/f381bdq03Hbe93XPgAEDtHz58mMWFktKShwFKbtt27bxnq8DTvQ9ze+AuiUwMFCLFy/W6aefrv79+2vHjh1V9j1y5Mj/t3f/oVXVfxzHX1vatthKs7pkyl2OprvSuMamZqv1A2Qlm6nB6g9ZVIz1A6Jajf5woETQL1QsB7VhRWWlEwxESHRDMe66xpar4UDzXvJHc9P98u5Us97fP/p27c79aNbO3drzAS/YOfdzue8PH849577vvbvRhpT0x7vmx48f53lgghrsvD/YWp49e1aO48Qc91dccYVmzJjBcT+BFRQUXNKAHIzjONGGlCS1t7fr7NmzHPfj2GCv5SbbuZ6m1ATX1NSk/v7+mH9ilpeXp2AwKDOLGRsIBLRkyZKYfXfccYcCgYArteLfV1lZqbKyMj388MP67LPPhhy3ZcsW1dTUxOzz+/06cuTIWJeIMbB06VJ1dHQoJSUlus/v96ujo0MdHR0xYwOBgPLy8qLbKSkpWrBgAcf9BLZo0SIdPHhw2DH79u1TZWVldDshIUHZ2dkc8/8BgUBAt912m5KTk6P78vLyhjymBz4HzJo1S7Nnz+Y5YAJKSEjQjh07NGfOHOXn56ulpWXY8UePHlVJSUl0+6qrrtItt9zC88AEtHbtWu3Zsydm31DXcWamYDAYc9zffvvt6u/v17fffjvmtWJs5ObmjnjuT0tL07lz53T33XdH982cOVPXXXcdx/04NdRrucl4ro/7TwCSf5aqqiprbm62nJwcW758uXV1ddmKFStMknk8HktOTjZJlpaWZm1tbbZhwwbLysqyDRs22KlTp2J+apJMnMybN8/6+/tt3bp15vF4YjJw7VesWGG//PKLrV692jIyMmzNmjUWiUTM6/XGfR5k9ElNTbUff/zRPv74Y8vMzLSCggI7ceKEvfjii5aYmGgej8emTp1qkszr9VpfX59VVFSYz+ezTz/91JqamuI+B3L5OX78uBUXF8fsG7juzz33nHV2dlphYaFlZmbaO++8Y6dPn7bU1NS4109Gn7/+PHhiYqJ99913tnXrVvP5fFZRUWE9PT02e/Zsk2RTp041j8djiYmJJskWL15sP//8sz322GN266232r59+2znzp1xnxMZ/do/8cQTduHCBXvggQdizvnTp08fdO03btxooVDI8vPzzefzWW1trR0+fDh6Oxnf+eva5+Tk2K+//movvPCCzZkzx8rKysxxHFu8eLFJsuTk5Oj1nyQrLi62rq4uW758ueXk5Fhzc7Nt3Lgx7nMio1976Y9rOTOLWeM/M3Dtd+7caY2NjZaTk2MLFiyw/fv3265du+I+J3JphnstNwnP9XEvgPzDpKSk2Pvvv2+9vb124sQJe/bZZ6O3mZmVlJREt3Nzc+2bb76xvr4+CwQC5vf7414/ubxUVFTYUAZb+8cff9xaW1vNcRw7dOiQ3XnnnXGfA7n8+Hw++/LLL62np8dOnjxplZWVJl28cPnrxUxBQYEdOXLEIpGI7dmzx9LT0+NeP7n89PX12dKlS2P2DbbuL7/8soVCIXMcx+rr623+/Plxr51cXgaubUZGhtXX15vjONbc3Gz33Xdf9Lb8/Hwzs5g3HUpKSiwcDltvb6/V1tbatddeG/c5kdGv/e7duwc959fV1Q269klJSfbmm2/ayZMn7fz58/bFF1/YrFmz4j4nMvq1l2RFRUXW1NRkfX191tLSEn0DWvrjGP/z+u/PVFRU2E8//WSdnZ1WXV1tSUlJcZ8Tuby1X7hwoZmZXXnllZeMHbj206ZNs5qaGjtz5ox1d3fbhx9+aNOmTYv7nMilGem13GQ61yf8/w8AAAAAAADANfxPKQAAAAAAALiOphQAAAAAAABcR1MKAAAAAAAArqMpBQAAAAAAANfRlAIAAAAAAIDraEoBAAAAAADAdTSlAAAAAAAA4DqaUgAAAAAAAHAdTSkAAIAxsGXLFpnZkCkpKZGZyev1jnktdXV1MjM5jjPsuKqqqmh9btQFAAAmtwRJFu8iAAAA/muuvvpqpaSkSJKKi4tVXl6u3Nzc6O2dnZ2aPn262tvb9fvvv49pLXV1dTp06JDeeOMNnTlzZshxaWlpmjt3roLBoNLT0xUOh8e0LgAAMLlNiXcBAAAA/0U9PT3q6emRJHV3d+u3335TW1tbzJiB22Pp/PnzwzakJKm3t1ft7e0uVQQAACY7vr4HAAAQB16vN+Zrcmamhx56SC0tLYpEIvrkk0+Unp6uvXv3KhKJaP/+/Zo5c2b0/g8++KC+//57RSIRNTQ06K677vrbj33PPfeosbFRjuPo2LFjKi0t/dfnBwAAMBKaUgAAAOPEunXr9Oijj2rZsmVatWqVvvrqK1VVVWnJkiW68cYb9dJLL0mSsrOz9cEHH+iVV15Rdna2PvroI+3evVsZGRkjPkZiYqK2bdumbdu2ad68eVqzZo02b96srKyssZ4eAABADL6+BwAAME6sX79eX3/9tSSpsbFRra2t2r59uySptrZWfr9fklReXq733ntPW7dulSRt2rRJ+fn5evLJJ1VeXj7sY1xzzTWaMWOG2traFA6HFQ6HderUKZ0+fXrsJgYAADAIPikFAAAwTvzwww/Rvx3HUSgUitlOSkqSJGVlZemZZ55Rb29vNIWFhcrMzBzxMTo7O7V582ZVV1crFApp06ZN6u7uVldX1789HQAAgGHRlAIAABgnLly4ELM91K/yTZkyRa+99pr8fn80Pp9PZWVlf+txnn76ac2fP1/vvvuuFi1apIaGBhUUFPzj+gEAAEaDphQAAMAE09raqptvvlnHjh2LprS0VPfff/+I9/V4PHr77bd19OhRvfrqq1q4cKH27t2roqIiFyoHAAC4iP8pBQAAMMGsX79eBw4cUDAY1K5du1RYWKjnn39e995774j3PXfunFauXKmEhAS99dZbuummm+T3+7Vjxw4XKgcAALiIT0oBAABMMA0NDVq9erWeeuoptbS0qLS0VI888ogOHDgw4n37+/tVVFQkv9+vw4cP6/PPP1dNTY2qq6tdqBwAAOCiBEkW7yIAAAAwdurq6lRfX6+1a9eOONbr9SoUCik9PV3hcNiF6gAAwGTFJ6UAAAAmgdTUVN1www3DjklLS9P111/vUkUAAGCyoykFAAAwCZSXl4/4yafXX39dwWDQpYoAAMBkx9f3AAAAAAAA4Do+KQUAAAAAAADX0ZQCAAAAAACA62hKAQAAAAAAwHU0pQAAAAAAAOA6mlIAAAAAAABwHU0pAAAAAAAAuI6mFAAAAAAAAFxHUwoAAAAAAACuoykFAAAAAAAA1/0P5zvcc6mdAc0AAAAASUVORK5CYII=" + ] }, - "metadata": {}, - "output_type": "display_data", "jetTransient": { "display_id": null - } + }, + "metadata": {}, + "output_type": "display_data" } ], - "execution_count": 7 + "source": [ + "# Recursive plot using getSamples\n", + "msd.importPythonModel(name=model_name)\n", + "msd.neuralizeModel(sample_time=0.01)\n", + "samples = msd.getSamples(dataset=\"simulations\", window=2000 - 10, index=0)\n", + "result = msd(samples, sampled=True, prediction_samples=2000 - 10)\n", + "\n", + "# region Plotting\n", + "t = np.arange(len(result[\"x_n\"])) * 0.01\n", + "plt.figure(figsize=(12, 7))\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(t, result[\"x_n\"], label=r\"Estimated $x$\", linewidth=2)\n", + "plt.plot(\n", + " t,\n", + " np.array(samples[\"x_t\"]).squeeze(-1).squeeze(-1),\n", + " label=r\"True $x$\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + ")\n", + "plt.title(\"Position estimation\")\n", + "plt.xlabel(\"Time [s]\")\n", + "plt.ylabel(r\"$x$ [m]\")\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(t, np.array(samples[\"F\"])[:, 0, 0], label=r\"Applied force $F$\")\n", + "plt.title(\"Applied force\")\n", + "plt.xlabel(\"Time [s]\")\n", + "plt.ylabel(\"Force [N]\")\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "# endregion\n", + "\n", + "plt.show()" + ] }, { - "metadata": {}, "cell_type": "code", - "outputs": [], "execution_count": null, - "source": "", - "id": "439c02826528ca8" + "id": "439c02826528ca8", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/case-studies/neuralODE/saved/neuralODE_msd.json b/case-studies/neuralODE/saved/neuralODE_msd.json index 47ab6487..32187883 100644 --- a/case-studies/neuralODE/saved/neuralODE_msd.json +++ b/case-studies/neuralODE/saved/neuralODE_msd.json @@ -54,4 +54,4 @@ "Select7": ["Select", ["NeuralODE5"], 2, 0], "TimePart1": ["TimePart", ["x"], -1, [-0.1, 0]], "TimePart3": ["TimePart", ["F"], -1, [-0.1, 0]], - "TimePart8": ["TimePart", ["Select7"], 0.1, [0.09, 0.1]]}} \ No newline at end of file + "TimePart8": ["TimePart", ["Select7"], 0.1, [0.09, 0.1]]}} diff --git a/case-studies/neuralODE/saved/neuralODE_msd.py b/case-studies/neuralODE/saved/neuralODE_msd.py index d87c5470..8517e971 100644 --- a/case-studies/neuralODE/saved/neuralODE_msd.py +++ b/case-studies/neuralODE/saved/neuralODE_msd.py @@ -1,16 +1,20 @@ import torch + def nnodely_basic_model_update_state(data_in, rel): data_out = data_in.clone() max_dim = min(rel.size(1), data_in.size(1)) data_out[:, -max_dim:, :] = rel[:, -max_dim:, :] return data_out + def nnodely_basic_model_timeshift(data_in): return torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1) + def nnodely_layers_neuralODE_FNeuralODE5(state, *weights): from nnodely.support.odeint.adjoint import odeint_adjoint as odeint + def ode_func_torch(t, state, weight_fir): import torch import torch.nn.functional as F @@ -20,80 +24,190 @@ def ode_func_torch(t, state, weight_fir): # 2 channels = [position_window, force_window] # # weight_fir: FIR weights applied independently to each channel - + # Apply two independent FIR filters (grouped convolution): # this produces one-step predictions for each channel # (B, W, 2) -> (B, 2, W) -> conv -> (B, 2, 1) out = F.conv1d(state.transpose(1, 2), weight_fir, groups=2) - + # Restore time dimension ordering # (B, 2, 1) -> (B, 1, 2) out = out.transpose(1, 2) - + # Combine the two FIR contributions: # next_velocity = free_response + forced_response out[:, :, 0] = out[:, :, 0] + out[:, :, -1] - + # Set the force prediction to zero, for the intermediate time steps done in the integration process (if a variable step integrator, such as Dopri5, is used) out[:, :, -1] = 0.0 - + # Shift the sliding window forward by one step # drop the oldest sample and append the new prediction # resulting shape: (B, W, 2) out = torch.cat((state[:, 1:, :], out), dim=1) - + return out - - ans = odeint(lambda t, y: ode_func_torch(t, y, *weights), state, t=torch.tensor([0.0, 0.01]), rtol=1e-07, atol=1e-09, method='dopri5', adjoint_params=list(weights)) + + ans = odeint( + lambda t, y: ode_func_torch(t, y, *weights), + state, + t=torch.tensor([0.0, 0.01]), + rtol=1e-07, + atol=1e-09, + method="dopri5", + adjoint_params=list(weights), + ) return ans[-1] + class TracerModel(torch.nn.Module): def __init__(self): super().__init__() self.all_parameters = {} self.all_constants = {} - self.all_parameters["weight_fir"] = torch.nn.Parameter(torch.tensor([[[-5.0214056968688965, -4.025257587432861, -3.0458261966705322, -1.9209206104278564, -0.7650308012962341, 0.5171442031860352, 1.7535150051116943, 3.087076187133789, 4.083190441131592, 5.219380855560303]], [[0.00026014805189333856, 0.0007117472123354673, 0.0013745456235483289, 0.002709923079237342, 0.003882204182446003, 0.005919742863625288, 0.0070823198184370995, 0.008177743293344975, 0.009529106318950653, 0.008549299091100693]]]), requires_grad=True) + self.all_parameters["weight_fir"] = torch.nn.Parameter( + torch.tensor( + [ + [ + [ + -5.0214056968688965, + -4.025257587432861, + -3.0458261966705322, + -1.9209206104278564, + -0.7650308012962341, + 0.5171442031860352, + 1.7535150051116943, + 3.087076187133789, + 4.083190441131592, + 5.219380855560303, + ] + ], + [ + [ + 0.00026014805189333856, + 0.0007117472123354673, + 0.0013745456235483289, + 0.002709923079237342, + 0.003882204182446003, + 0.005919742863625288, + 0.0070823198184370995, + 0.008177743293344975, + 0.009529106318950653, + 0.008549299091100693, + ] + ], + ] + ), + requires_grad=True, + ) self.all_constants["SamplePart10"] = torch.tensor([[1.0]], requires_grad=True) self.all_constants["Select7"] = torch.tensor([1.0, 0.0], requires_grad=True) - self.all_constants["TimePart1"] = torch.tensor([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True) - self.all_constants["TimePart3"] = torch.tensor([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True) - self.all_constants["TimePart8"] = torch.tensor([[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True) + self.all_constants["TimePart1"] = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ], + requires_grad=True, + ) + self.all_constants["TimePart3"] = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ], + requires_grad=True, + ) + self.all_constants["TimePart8"] = torch.tensor( + [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]], requires_grad=True + ) self.all_parameters = torch.nn.ParameterDict(self.all_parameters) self.all_constants = torch.nn.ParameterDict(self.all_constants) def update(self, closed_loop={}, connect={}, disconnect=False): pass + def forward(self, kwargs): - getitem = kwargs['x_t'] + getitem = kwargs["x_t"] relation_forward_sample_part10_w = self.all_constants.SamplePart10 - einsum = torch.functional.einsum('bij,ki->bkj', getitem, relation_forward_sample_part10_w); getitem = relation_forward_sample_part10_w = None - getitem_1 = kwargs['x'] + einsum = torch.functional.einsum( + "bij,ki->bkj", getitem, relation_forward_sample_part10_w + ) + getitem = relation_forward_sample_part10_w = None + getitem_1 = kwargs["x"] relation_forward_time_part1_w = self.all_constants.TimePart1 - einsum_1 = torch.functional.einsum('bij,ki->bkj', getitem_1, relation_forward_time_part1_w); getitem_1 = relation_forward_time_part1_w = None - getitem_2 = kwargs['F']; kwargs = None + einsum_1 = torch.functional.einsum( + "bij,ki->bkj", getitem_1, relation_forward_time_part1_w + ) + getitem_1 = relation_forward_time_part1_w = None + getitem_2 = kwargs["F"] + kwargs = None relation_forward_time_part3_w = self.all_constants.TimePart3 - einsum_2 = torch.functional.einsum('bij,ki->bkj', getitem_2, relation_forward_time_part3_w); getitem_2 = relation_forward_time_part3_w = None - cat = torch.cat((einsum_1, einsum_2), dim = 2); einsum_1 = einsum_2 = None + einsum_2 = torch.functional.einsum( + "bij,ki->bkj", getitem_2, relation_forward_time_part3_w + ) + getitem_2 = relation_forward_time_part3_w = None + cat = torch.cat((einsum_1, einsum_2), dim=2) + einsum_1 = einsum_2 = None all_parameters_weight_fir = self.all_parameters.weight_fir - fneural_ode5 = nnodely_layers_neuralODE_FNeuralODE5(cat, all_parameters_weight_fir); cat = all_parameters_weight_fir = None + fneural_ode5 = nnodely_layers_neuralODE_FNeuralODE5( + cat, all_parameters_weight_fir + ) + cat = all_parameters_weight_fir = None relation_forward_select7_w = self.all_constants.Select7 - einsum_3 = torch.functional.einsum('ijk,k->ij', fneural_ode5, relation_forward_select7_w); fneural_ode5 = relation_forward_select7_w = None - unsqueeze = einsum_3.unsqueeze(2); einsum_3 = None + einsum_3 = torch.functional.einsum( + "ijk,k->ij", fneural_ode5, relation_forward_select7_w + ) + fneural_ode5 = relation_forward_select7_w = None + unsqueeze = einsum_3.unsqueeze(2) + einsum_3 = None relation_forward_time_part8_w = self.all_constants.TimePart8 - einsum_4 = torch.functional.einsum('bij,ki->bkj', unsqueeze, relation_forward_time_part8_w); unsqueeze = relation_forward_time_part8_w = None - return ({'x_n': einsum_4}, {'SamplePart10': einsum, 'TimePart8': einsum_4}, {'x': einsum_4}, {}) - + einsum_4 = torch.functional.einsum( + "bij,ki->bkj", unsqueeze, relation_forward_time_part8_w + ) + unsqueeze = relation_forward_time_part8_w = None + return ( + {"x_n": einsum_4}, + {"SamplePart10": einsum, "TimePart8": einsum_4}, + {"x": einsum_4}, + {}, + ) + + class RecurrentModel(torch.nn.Module): def __init__(self): super().__init__() self.Cell = TracerModel() - self.inputs = ['F', 'x_t', ] + self.inputs = [ + "F", + "x_t", + ] self.states = dict() - def forward(self, kwargs, n_samples = None): - n_samples = n_samples if n_samples else min([kwargs[key].size(0) for key in self.inputs]) - self.states['x'] = kwargs['x'] - results = {'x_n':[], } + def forward(self, kwargs, n_samples=None): + n_samples = ( + n_samples + if n_samples + else min([kwargs[key].size(0) for key in self.inputs]) + ) + self.states["x"] = kwargs["x"] + results = { + "x_n": [], + } X = dict() for idx in range(n_samples): for key in self.inputs: @@ -105,7 +219,9 @@ def forward(self, kwargs, n_samples = None): results[key].append(out[key]) for key, val in closed_loop.items(): self.states[key] = nnodely_basic_model_timeshift(self.states[key]) - self.states[key] = nnodely_basic_model_update_state(self.states[key], val) + self.states[key] = nnodely_basic_model_update_state( + self.states[key], val + ) for key, val in connect.items(): self.states[key] = nnodely_basic_model_timeshift(val) return results diff --git a/case-studies/pinn/pinn_Burgers_equation.ipynb b/case-studies/pinn/pinn_Burgers_equation.ipynb index 9a320310..2cb39068 100644 --- a/case-studies/pinn/pinn_Burgers_equation.ipynb +++ b/case-studies/pinn/pinn_Burgers_equation.ipynb @@ -18,6 +18,7 @@ }, { "cell_type": "code", + "execution_count": 1, "id": "19b3470f12bc42b4", "metadata": { "ExecuteTime": { @@ -25,10 +26,6 @@ "start_time": "2026-02-25T17:39:06.884462Z" } }, - "source": [ - "from nnodely import *\n", - "import numpy as np" - ], "outputs": [ { "name": "stdout", @@ -38,7 +35,10 @@ ] } ], - "execution_count": 1 + "source": [ + "from nnodely import *\n", + "import numpy as np" + ] }, { "cell_type": "markdown", @@ -50,6 +50,7 @@ }, { "cell_type": "code", + "execution_count": 2, "id": "f6f28e7b27c45c9e", "metadata": { "ExecuteTime": { @@ -57,24 +58,29 @@ "start_time": "2026-02-25T17:39:07.631468Z" } }, + "outputs": [], "source": [ - "t = Input('t')\n", - "x = Input('x')\n", + "t = Input(\"t\")\n", + "x = Input(\"x\")\n", "x_last = x.last()\n", "t_last = t.last()\n", "\n", - "xt = Concatenate(x_last,t_last)\n", + "xt = Concatenate(x_last, t_last)\n", "for hidden in range(4):\n", - " xt = Tanh(Linear(20, b = True, b_init = 'init_constant', b_init_params = {'value':0})(xt))\n", - "u = Linear(1, b = True, b_init = 'init_constant', b_init_params = {'value':0})(xt)\n", + " xt = Tanh(\n", + " Linear(20, b=True, b_init=\"init_constant\", b_init_params={\"value\": 0})(xt)\n", + " )\n", + "u = Linear(1, b=True, b_init=\"init_constant\", b_init_params={\"value\": 0})(xt)\n", "\n", - "f = Differentiate(u,t_last) + Differentiate(u,x_last) * u - (0.01 / np.pi) * Differentiate(Differentiate(u,x_last),x_last)\n", + "f = (\n", + " Differentiate(u, t_last)\n", + " + Differentiate(u, x_last) * u\n", + " - (0.01 / np.pi) * Differentiate(Differentiate(u, x_last), x_last)\n", + ")\n", "\n", - "U = Output('U',u)\n", - "F = Output('F',f)" - ], - "outputs": [], - "execution_count": 2 + "U = Output(\"U\", u)\n", + "F = Output(\"F\", f)" + ] }, { "cell_type": "markdown", @@ -86,6 +92,7 @@ }, { "cell_type": "code", + "execution_count": 3, "id": "3997a16202edbedd", "metadata": { "ExecuteTime": { @@ -93,12 +100,11 @@ "start_time": "2026-02-25T17:39:07.654224Z" } }, - "source": [ - "u_target = Input('u_target').last()\n", - "bound_cond = Input('b').last()" - ], "outputs": [], - "execution_count": 3 + "source": [ + "u_target = Input(\"u_target\").last()\n", + "bound_cond = Input(\"b\").last()" + ] }, { "cell_type": "markdown", @@ -110,6 +116,7 @@ }, { "cell_type": "code", + "execution_count": 4, "id": "bca4c69105a806fb", "metadata": { "ExecuteTime": { @@ -117,20 +124,13 @@ "start_time": "2026-02-25T17:39:07.658898Z" } }, - "source": [ - "pinn = Modely(visualizer=TextVisualizer(), seed=42)\n", - "pinn.addModel('pinn',[U,F])\n", - "pinn.addMinimize('errorU',u * bound_cond, u_target * bound_cond)\n", - "pinn.addMinimize('errorF',f, bound_cond * 0)\n", - "pinn.neuralizeModel()" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m================================ nnodely Model =================================\u001B[0m\n", - "\u001B[32m{'Constants': {'Constant18': {'dim': 1, 'values': [0.0031830989755690098]},\n", + "\u001b[1;32m================================ nnodely Model =================================\u001b[0m\n", + "\u001b[32m{'Constants': {'Constant18': {'dim': 1, 'values': [0.0031830989755690098]},\n", " 'Constant23': {'dim': 1, 'values': [0.0]}},\n", " 'Functions': {},\n", " 'Info': {'SampleTime': 1,\n", @@ -1555,12 +1555,18 @@ " 'Tanh10': ['Tanh', ['Linear9']],\n", " 'Tanh12': ['Tanh', ['Linear11']],\n", " 'Tanh6': ['Tanh', ['Linear5']],\n", - " 'Tanh8': ['Tanh', ['Linear7']]}}\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n" + " 'Tanh8': ['Tanh', ['Linear7']]}}\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n" ] } ], - "execution_count": 4 + "source": [ + "pinn = Modely(visualizer=TextVisualizer(), seed=42)\n", + "pinn.addModel(\"pinn\", [U, F])\n", + "pinn.addMinimize(\"errorU\", u * bound_cond, u_target * bound_cond)\n", + "pinn.addMinimize(\"errorF\", f, bound_cond * 0)\n", + "pinn.neuralizeModel()" + ] }, { "cell_type": "markdown", @@ -1572,6 +1578,7 @@ }, { "cell_type": "code", + "execution_count": 5, "id": "b5e35e8f7b0e19a2", "metadata": { "ExecuteTime": { @@ -1579,24 +1586,26 @@ "start_time": "2026-02-25T17:39:07.704197Z" } }, + "outputs": [], "source": [ "import torch\n", + "\n", "# Create boundary conditions\n", "Nu = 100\n", - "tt_0 = torch.zeros(Nu//2, dtype=torch.float32)\n", - "xx_0 = 2 * torch.rand(Nu//2, dtype=torch.float32) - 1\n", + "tt_0 = torch.zeros(Nu // 2, dtype=torch.float32)\n", + "xx_0 = 2 * torch.rand(Nu // 2, dtype=torch.float32) - 1\n", "uu_0 = -torch.sin(torch.pi * xx_0)\n", - "b_0 = torch.ones(Nu//2, dtype=torch.float32)\n", + "b_0 = torch.ones(Nu // 2, dtype=torch.float32)\n", "#\n", - "tt_1 = torch.rand(Nu//4, dtype=torch.float32)\n", - "xx_1 = torch.ones(Nu//4, dtype=torch.float32)\n", - "uu_1 = torch.zeros(Nu//4, dtype=torch.float32)\n", - "b_1 = torch.ones(Nu//4, dtype=torch.float32)\n", + "tt_1 = torch.rand(Nu // 4, dtype=torch.float32)\n", + "xx_1 = torch.ones(Nu // 4, dtype=torch.float32)\n", + "uu_1 = torch.zeros(Nu // 4, dtype=torch.float32)\n", + "b_1 = torch.ones(Nu // 4, dtype=torch.float32)\n", "#\n", - "tt_2 = torch.rand(Nu//4, dtype=torch.float32)\n", - "xx_2 = -torch.ones(Nu//4, dtype=torch.float32)\n", - "uu_2 = torch.zeros(Nu//4, dtype=torch.float32)\n", - "b_2 = torch.ones(Nu//4, dtype=torch.float32)\n", + "tt_2 = torch.rand(Nu // 4, dtype=torch.float32)\n", + "xx_2 = -torch.ones(Nu // 4, dtype=torch.float32)\n", + "uu_2 = torch.zeros(Nu // 4, dtype=torch.float32)\n", + "b_2 = torch.ones(Nu // 4, dtype=torch.float32)\n", "# Internal points\n", "Nf = 10000\n", "tt_3 = torch.rand(Nf, dtype=torch.float32)\n", @@ -1604,13 +1613,13 @@ "uu_3 = torch.zeros(Nf, dtype=torch.float32)\n", "b_3 = torch.zeros(Nf, dtype=torch.float32)\n", "\n", - "data = {'x':torch.cat((xx_0, xx_1, xx_2, xx_3)),\n", - " 't':torch.cat((tt_0, tt_1, tt_2, tt_3)),\n", - " 'u_target':torch.cat((uu_0, uu_1, uu_2, uu_3)),\n", - " 'b':torch.cat((b_0, b_1, b_2, b_3))}" - ], - "outputs": [], - "execution_count": 5 + "data = {\n", + " \"x\": torch.cat((xx_0, xx_1, xx_2, xx_3)),\n", + " \"t\": torch.cat((tt_0, tt_1, tt_2, tt_3)),\n", + " \"u_target\": torch.cat((uu_0, uu_1, uu_2, uu_3)),\n", + " \"b\": torch.cat((b_0, b_1, b_2, b_3)),\n", + "}" + ] }, { "cell_type": "markdown", @@ -1622,6 +1631,7 @@ }, { "cell_type": "code", + "execution_count": 6, "id": "4a20e7b55167eb6c", "metadata": { "ExecuteTime": { @@ -1629,52 +1639,43 @@ "start_time": "2026-02-25T17:39:07.718011Z" } }, - "source": [ - "from nnodely.support import earlystopping\n", - "pinn.loadData('dataset2',data)\n", - "pinn.trainModel(train_dataset='dataset2', train_batch_size=128, num_of_epochs=5000, lr=0.0005, \n", - " minimize_gain={'errorU':1,'errorF':0.0005}, \n", - " early_stopping=earlystopping.early_stop_patience, \n", - " early_stopping_params={'patience':500, 'error':'errorU'}, \n", - " select_model=earlystopping.select_best_model)" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[1;32m============================ nnodely Model Dataset =============================\u001B[0m\n", - "\u001B[32mDataset Name: dataset2\u001B[0m\n", - "\u001B[32mNumber of files: 1\u001B[0m\n", - "\u001B[32mTotal number of samples: 10100\u001B[0m\n", - "\u001B[32mShape of b: (10100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of x: (10100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of t: (10100, 1, 1)\u001B[0m\n", - "\u001B[32mShape of u_target: (10100, 1, 1)\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[_setup_recurrent_variables] The value of the prediction_samples=0 but the network has no recurrent variables.\u001B[0m\n", - "\u001B[1;32m======================== nnodely Model Train Parameters ========================\u001B[0m\n", - "\u001B[32mmodels: ['pinn']\u001B[0m\n", - "\u001B[32mnum of epochs: 5000\u001B[0m\n", - "\u001B[32mupdate per epochs: 78\u001B[0m\n", - "\u001B[34mâ””>(n_samples-batch_size)/batch_size+1\u001B[0m\n", - "\u001B[32mshuffle data: True\u001B[0m\n", - "\u001B[32mearly stopping: early_stop_patience\u001B[0m\n", - "\u001B[32mearly stopping params: {'error': 'errorU', 'patience': 500}\u001B[0m\n", - "\u001B[32mtrain dataset: dataset2\u001B[0m\n", - "\u001B[32m\t- batch size: 128\u001B[0m\n", - "\u001B[32m\t- num of samples: 10100\u001B[0m\n", - "\u001B[32mminimizers: {'errorF': {'A': 'Sub22',\n", + "\u001b[1;32m============================ nnodely Model Dataset =============================\u001b[0m\n", + "\u001b[32mDataset Name: dataset2\u001b[0m\n", + "\u001b[32mNumber of files: 1\u001b[0m\n", + "\u001b[32mTotal number of samples: 10100\u001b[0m\n", + "\u001b[32mShape of b: (10100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of x: (10100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of t: (10100, 1, 1)\u001b[0m\n", + "\u001b[32mShape of u_target: (10100, 1, 1)\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[_setup_recurrent_variables] The value of the prediction_samples=0 but the network has no recurrent variables.\u001b[0m\n", + "\u001b[1;32m======================== nnodely Model Train Parameters ========================\u001b[0m\n", + "\u001b[32mmodels: ['pinn']\u001b[0m\n", + "\u001b[32mnum of epochs: 5000\u001b[0m\n", + "\u001b[32mupdate per epochs: 78\u001b[0m\n", + "\u001b[34mâ””>(n_samples-batch_size)/batch_size+1\u001b[0m\n", + "\u001b[32mshuffle data: True\u001b[0m\n", + "\u001b[32mearly stopping: early_stop_patience\u001b[0m\n", + "\u001b[32mearly stopping params: {'error': 'errorU', 'patience': 500}\u001b[0m\n", + "\u001b[32mtrain dataset: dataset2\u001b[0m\n", + "\u001b[32m\t- batch size: 128\u001b[0m\n", + "\u001b[32m\t- num of samples: 10100\u001b[0m\n", + "\u001b[32mminimizers: {'errorF': {'A': 'Sub22',\n", " 'B': 'Mul30',\n", " 'gain': 0.0005,\n", " 'loss': 'mse'},\n", " 'errorU': {'A': 'Mul27',\n", " 'B': 'Mul28',\n", " 'gain': 1,\n", - " 'loss': 'mse'}}\u001B[0m\n", - "\u001B[32moptimizer: Adam\u001B[0m\n", - "\u001B[32moptimizer defaults: {'lr': 0.0005}\u001B[0m\n", - "\u001B[32moptimizer params: [{'params': 'PLinear12W'},\n", + " 'loss': 'mse'}}\u001b[0m\n", + "\u001b[32moptimizer: Adam\u001b[0m\n", + "\u001b[32moptimizer defaults: {'lr': 0.0005}\u001b[0m\n", + "\u001b[32moptimizer params: [{'params': 'PLinear12W'},\n", " {'params': 'PLinear12b'},\n", " {'params': 'PLinear15W'},\n", " {'params': 'PLinear15b'},\n", @@ -1683,92 +1684,106 @@ " {'params': 'PLinear6W'},\n", " {'params': 'PLinear6b'},\n", " {'params': 'PLinear9W'},\n", - " {'params': 'PLinear9b'}]\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[1;32m=========================== nnodely Training ===========================\u001B[0m\n", - "\u001B[32m| Epoch |\u001B[0m\u001B[32m errorU |\u001B[0m\u001B[32m errorF |\u001B[0m\u001B[32m Total |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\u001B[32m Loss |\u001B[0m\n", - "\u001B[32m| |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m train |\u001B[0m\u001B[32m train |\u001B[0m\n", - "\u001B[32m|----------------------------------------------------------------------|\u001B[0m\n", - "\u001B[32m| 50/5000 |\u001B[0m\u001B[32m 9.018e-02 |\u001B[0m\u001B[32m 1.413e+00 |\u001B[0m\u001B[32m 7.515e-01 |\u001B[0m\n", - "\u001B[32m| 100/5000 |\u001B[0m\u001B[32m 1.886e-02 |\u001B[0m\u001B[32m 4.612e-02 |\u001B[0m\u001B[32m 3.249e-02 |\u001B[0m\n", - "\u001B[32m| 150/5000 |\u001B[0m\u001B[32m 3.863e-03 |\u001B[0m\u001B[32m 1.532e-03 |\u001B[0m\u001B[32m 2.698e-03 |\u001B[0m\n", - "\u001B[32m| 200/5000 |\u001B[0m\u001B[32m 1.946e-03 |\u001B[0m\u001B[32m 3.386e-04 |\u001B[0m\u001B[32m 1.142e-03 |\u001B[0m\n", - "\u001B[32m| 250/5000 |\u001B[0m\u001B[32m 1.838e-03 |\u001B[0m\u001B[32m 5.892e-04 |\u001B[0m\u001B[32m 1.214e-03 |\u001B[0m\n", - "\u001B[32m| 300/5000 |\u001B[0m\u001B[32m 1.732e-03 |\u001B[0m\u001B[32m 3.606e-04 |\u001B[0m\u001B[32m 1.046e-03 |\u001B[0m\n", - "\u001B[32m| 350/5000 |\u001B[0m\u001B[32m 1.636e-03 |\u001B[0m\u001B[32m 4.242e-04 |\u001B[0m\u001B[32m 1.030e-03 |\u001B[0m\n", - "\u001B[32m| 400/5000 |\u001B[0m\u001B[32m 1.564e-03 |\u001B[0m\u001B[32m 2.444e-04 |\u001B[0m\u001B[32m 9.043e-04 |\u001B[0m\n", - "\u001B[32m| 450/5000 |\u001B[0m\u001B[32m 1.543e-03 |\u001B[0m\u001B[32m 1.600e-04 |\u001B[0m\u001B[32m 8.514e-04 |\u001B[0m\n", - "\u001B[32m| 500/5000 |\u001B[0m\u001B[32m 1.53e-03 |\u001B[0m\u001B[32m 1.101e-04 |\u001B[0m\u001B[32m 8.200e-04 |\u001B[0m\n", - "\u001B[32m| 550/5000 |\u001B[0m\u001B[32m 1.505e-03 |\u001B[0m\u001B[32m 6.108e-05 |\u001B[0m\u001B[32m 7.830e-04 |\u001B[0m\n", - "\u001B[32m| 600/5000 |\u001B[0m\u001B[32m 1.504e-03 |\u001B[0m\u001B[32m 3.504e-05 |\u001B[0m\u001B[32m 7.694e-04 |\u001B[0m\n", - "\u001B[32m| 650/5000 |\u001B[0m\u001B[32m 3.171e-04 |\u001B[0m\u001B[32m 1.438e-04 |\u001B[0m\u001B[32m 2.304e-04 |\u001B[0m\n", - "\u001B[32m| 700/5000 |\u001B[0m\u001B[32m 8.892e-05 |\u001B[0m\u001B[32m 1.083e-04 |\u001B[0m\u001B[32m 9.863e-05 |\u001B[0m\n", - "\u001B[32m| 750/5000 |\u001B[0m\u001B[32m 4.373e-05 |\u001B[0m\u001B[32m 8.569e-05 |\u001B[0m\u001B[32m 6.471e-05 |\u001B[0m\n", - "\u001B[32m| 800/5000 |\u001B[0m\u001B[32m 2.790e-05 |\u001B[0m\u001B[32m 5.551e-05 |\u001B[0m\u001B[32m 4.170e-05 |\u001B[0m\n", - "\u001B[32m| 850/5000 |\u001B[0m\u001B[32m 3.441e-05 |\u001B[0m\u001B[32m 5.859e-05 |\u001B[0m\u001B[32m 4.650e-05 |\u001B[0m\n", - "\u001B[32m| 900/5000 |\u001B[0m\u001B[32m 6.985e-06 |\u001B[0m\u001B[32m 1.973e-05 |\u001B[0m\u001B[32m 1.336e-05 |\u001B[0m\n", - "\u001B[32m| 950/5000 |\u001B[0m\u001B[32m 6.454e-06 |\u001B[0m\u001B[32m 1.649e-05 |\u001B[0m\u001B[32m 1.147e-05 |\u001B[0m\n", - "\u001B[32m|1000/5000 |\u001B[0m\u001B[32m 7.318e-06 |\u001B[0m\u001B[32m 1.616e-05 |\u001B[0m\u001B[32m 1.174e-05 |\u001B[0m\n", - "\u001B[32m|1050/5000 |\u001B[0m\u001B[32m 7.773e-06 |\u001B[0m\u001B[32m 1.579e-05 |\u001B[0m\u001B[32m 1.178e-05 |\u001B[0m\n", - "\u001B[32m|1100/5000 |\u001B[0m\u001B[32m 5.03e-06 |\u001B[0m\u001B[32m 1.188e-05 |\u001B[0m\u001B[32m 8.453e-06 |\u001B[0m\n", - "\u001B[32m|1150/5000 |\u001B[0m\u001B[32m 3.668e-06 |\u001B[0m\u001B[32m 8.326e-06 |\u001B[0m\u001B[32m 5.997e-06 |\u001B[0m\n", - "\u001B[32m|1200/5000 |\u001B[0m\u001B[32m 2.6e-06 |\u001B[0m\u001B[32m 7.771e-06 |\u001B[0m\u001B[32m 5.185e-06 |\u001B[0m\n", - "\u001B[32m|1250/5000 |\u001B[0m\u001B[32m 8.389e-06 |\u001B[0m\u001B[32m 1.483e-05 |\u001B[0m\u001B[32m 1.161e-05 |\u001B[0m\n", - "\u001B[32m|1300/5000 |\u001B[0m\u001B[32m 2.944e-06 |\u001B[0m\u001B[32m 6.592e-06 |\u001B[0m\u001B[32m 4.768e-06 |\u001B[0m\n", - "\u001B[32m|1350/5000 |\u001B[0m\u001B[32m 4.007e-06 |\u001B[0m\u001B[32m 8.243e-06 |\u001B[0m\u001B[32m 6.125e-06 |\u001B[0m\n", - "\u001B[32m|1400/5000 |\u001B[0m\u001B[32m 4.226e-06 |\u001B[0m\u001B[32m 8.995e-06 |\u001B[0m\u001B[32m 6.610e-06 |\u001B[0m\n", - "\u001B[32m|1450/5000 |\u001B[0m\u001B[32m 2.225e-05 |\u001B[0m\u001B[32m 2.984e-05 |\u001B[0m\u001B[32m 2.604e-05 |\u001B[0m\n", - "\u001B[32m|1500/5000 |\u001B[0m\u001B[32m 1.576e-05 |\u001B[0m\u001B[32m 2.343e-05 |\u001B[0m\u001B[32m 1.959e-05 |\u001B[0m\n", - "\u001B[32m|1550/5000 |\u001B[0m\u001B[32m 5.138e-06 |\u001B[0m\u001B[32m 1.073e-05 |\u001B[0m\u001B[32m 7.933e-06 |\u001B[0m\n", - "\u001B[32m|1600/5000 |\u001B[0m\u001B[32m 2.006e-06 |\u001B[0m\u001B[32m 4.534e-06 |\u001B[0m\u001B[32m 3.270e-06 |\u001B[0m\n", - "\u001B[32m|1650/5000 |\u001B[0m\u001B[32m 3.014e-06 |\u001B[0m\u001B[32m 7.368e-06 |\u001B[0m\u001B[32m 5.191e-06 |\u001B[0m\n", - "\u001B[32m|1700/5000 |\u001B[0m\u001B[32m 1.711e-06 |\u001B[0m\u001B[32m 3.738e-06 |\u001B[0m\u001B[32m 2.724e-06 |\u001B[0m\n", - "\u001B[32m|1750/5000 |\u001B[0m\u001B[32m 1.402e-06 |\u001B[0m\u001B[32m 3.050e-06 |\u001B[0m\u001B[32m 2.226e-06 |\u001B[0m\n", - "\u001B[32m|1800/5000 |\u001B[0m\u001B[32m 5.405e-06 |\u001B[0m\u001B[32m 6.894e-06 |\u001B[0m\u001B[32m 6.15e-06 |\u001B[0m\n", - "\u001B[32m|1850/5000 |\u001B[0m\u001B[32m 4.134e-06 |\u001B[0m\u001B[32m 4.535e-06 |\u001B[0m\u001B[32m 4.334e-06 |\u001B[0m\n", - "\u001B[32m|1900/5000 |\u001B[0m\u001B[32m 1.579e-06 |\u001B[0m\u001B[32m 2.762e-06 |\u001B[0m\u001B[32m 2.171e-06 |\u001B[0m\n", - "\u001B[32m|1950/5000 |\u001B[0m\u001B[32m 2.646e-06 |\u001B[0m\u001B[32m 5.012e-06 |\u001B[0m\u001B[32m 3.829e-06 |\u001B[0m\n", - "\u001B[32m|2000/5000 |\u001B[0m\u001B[32m 1.381e-06 |\u001B[0m\u001B[32m 1.573e-06 |\u001B[0m\u001B[32m 1.477e-06 |\u001B[0m\n", - "\u001B[32m|2050/5000 |\u001B[0m\u001B[32m 1.613e-06 |\u001B[0m\u001B[32m 3.587e-06 |\u001B[0m\u001B[32m 2.6e-06 |\u001B[0m\n", - "\u001B[32m|2100/5000 |\u001B[0m\u001B[32m 2.693e-06 |\u001B[0m\u001B[32m 3.447e-06 |\u001B[0m\u001B[32m 3.07e-06 |\u001B[0m\n", - "\u001B[32m|2150/5000 |\u001B[0m\u001B[32m 1.465e-06 |\u001B[0m\u001B[32m 1.942e-06 |\u001B[0m\u001B[32m 1.704e-06 |\u001B[0m\n", - "\u001B[32m|2200/5000 |\u001B[0m\u001B[32m 1.141e-06 |\u001B[0m\u001B[32m 1.933e-06 |\u001B[0m\u001B[32m 1.537e-06 |\u001B[0m\n", - "\u001B[32m|2250/5000 |\u001B[0m\u001B[32m 4.073e-06 |\u001B[0m\u001B[32m 3.550e-06 |\u001B[0m\u001B[32m 3.812e-06 |\u001B[0m\n", - "\u001B[32m|2300/5000 |\u001B[0m\u001B[32m 2.918e-06 |\u001B[0m\u001B[32m 2.235e-06 |\u001B[0m\u001B[32m 2.576e-06 |\u001B[0m\n", - "\u001B[32m|2350/5000 |\u001B[0m\u001B[32m 2.835e-06 |\u001B[0m\u001B[32m 1.932e-06 |\u001B[0m\u001B[32m 2.384e-06 |\u001B[0m\n", - "\u001B[32m|2400/5000 |\u001B[0m\u001B[32m 7.148e-06 |\u001B[0m\u001B[32m 6.592e-06 |\u001B[0m\u001B[32m 6.870e-06 |\u001B[0m\n", - "\u001B[32m|2450/5000 |\u001B[0m\u001B[32m 8.410e-07 |\u001B[0m\u001B[32m 1.945e-06 |\u001B[0m\u001B[32m 1.393e-06 |\u001B[0m\n", - "\u001B[32m|2500/5000 |\u001B[0m\u001B[32m 6.379e-07 |\u001B[0m\u001B[32m 9.164e-07 |\u001B[0m\u001B[32m 7.772e-07 |\u001B[0m\n", - "\u001B[32m|2550/5000 |\u001B[0m\u001B[32m 1.717e-06 |\u001B[0m\u001B[32m 2.593e-06 |\u001B[0m\u001B[32m 2.155e-06 |\u001B[0m\n", - "\u001B[32m|2600/5000 |\u001B[0m\u001B[32m 2.722e-06 |\u001B[0m\u001B[32m 7.063e-06 |\u001B[0m\u001B[32m 4.892e-06 |\u001B[0m\n", - "\u001B[32m|2650/5000 |\u001B[0m\u001B[32m 5.706e-07 |\u001B[0m\u001B[32m 1.253e-06 |\u001B[0m\u001B[32m 9.120e-07 |\u001B[0m\n", - "\u001B[32m|2700/5000 |\u001B[0m\u001B[32m 3.990e-07 |\u001B[0m\u001B[32m 1.038e-06 |\u001B[0m\u001B[32m 7.186e-07 |\u001B[0m\n", - "\u001B[32m|2750/5000 |\u001B[0m\u001B[32m 9.519e-07 |\u001B[0m\u001B[32m 1.662e-06 |\u001B[0m\u001B[32m 1.307e-06 |\u001B[0m\n", - "\u001B[32m|2800/5000 |\u001B[0m\u001B[32m 4.111e-06 |\u001B[0m\u001B[32m 3.098e-06 |\u001B[0m\u001B[32m 3.605e-06 |\u001B[0m\n", - "\u001B[32m|2850/5000 |\u001B[0m\u001B[32m 1.347e-06 |\u001B[0m\u001B[32m 1.464e-06 |\u001B[0m\u001B[32m 1.405e-06 |\u001B[0m\n", - "\u001B[32m|2900/5000 |\u001B[0m\u001B[32m 5.103e-07 |\u001B[0m\u001B[32m 1.178e-06 |\u001B[0m\u001B[32m 8.44e-07 |\u001B[0m\n", - "\u001B[32m|2950/5000 |\u001B[0m\u001B[32m 5.521e-07 |\u001B[0m\u001B[32m 1.155e-06 |\u001B[0m\u001B[32m 8.536e-07 |\u001B[0m\n", - "\u001B[32m|3000/5000 |\u001B[0m\u001B[32m 5.444e-07 |\u001B[0m\u001B[32m 7.651e-07 |\u001B[0m\u001B[32m 6.548e-07 |\u001B[0m\n", - "\u001B[32m|3050/5000 |\u001B[0m\u001B[32m 4.684e-07 |\u001B[0m\u001B[32m 6.802e-07 |\u001B[0m\u001B[32m 5.743e-07 |\u001B[0m\n", - "\u001B[32m|3100/5000 |\u001B[0m\u001B[32m 7.432e-07 |\u001B[0m\u001B[32m 1.625e-06 |\u001B[0m\u001B[32m 1.184e-06 |\u001B[0m\n", - "\u001B[32m|3150/5000 |\u001B[0m\u001B[32m 1.323e-06 |\u001B[0m\u001B[32m 2.188e-06 |\u001B[0m\u001B[32m 1.755e-06 |\u001B[0m\n", - "\u001B[32m|3200/5000 |\u001B[0m\u001B[32m 1.093e-06 |\u001B[0m\u001B[32m 1.363e-06 |\u001B[0m\u001B[32m 1.228e-06 |\u001B[0m\n", - "\u001B[32m|3250/5000 |\u001B[0m\u001B[32m 1.243e-06 |\u001B[0m\u001B[32m 1.959e-06 |\u001B[0m\u001B[32m 1.601e-06 |\u001B[0m\n", - "\u001B[32m|3300/5000 |\u001B[0m\u001B[32m 1.701e-06 |\u001B[0m\u001B[32m 3.564e-06 |\u001B[0m\u001B[32m 2.632e-06 |\u001B[0m\n", - "\u001B[32m|3350/5000 |\u001B[0m\u001B[32m 5.400e-07 |\u001B[0m\u001B[32m 7.495e-07 |\u001B[0m\u001B[32m 6.448e-07 |\u001B[0m\n", - "\u001B[32m|3400/5000 |\u001B[0m\u001B[32m 6.398e-07 |\u001B[0m\u001B[32m 1.927e-06 |\u001B[0m\u001B[32m 1.283e-06 |\u001B[0m\n", - "\u001B[32m|3450/5000 |\u001B[0m\u001B[32m 7.234e-06 |\u001B[0m\u001B[32m 1.095e-05 |\u001B[0m\u001B[32m 9.094e-06 |\u001B[0m\n", - "|3485/5000 | 6.045e-07 | 9.439e-07 | 7.742e-07 |\u001B[34mStopping the training at epoch 3485 due to early stopping.\u001B[0m\n", - "\u001B[1;32m============================ nnodely Training Time =============================\u001B[0m\n", - "\u001B[32mTotal time of Training: 694.5884737968445\u001B[0m\n", - "\u001B[32m================================================================================\u001B[0m\n", - "\u001B[33m[trainModel] If not validation set is provided the selected model can differ from the optimal.\u001B[0m\n", - "\u001B[34mSelected the model at the epoch 3461.\u001B[0m\n" + " {'params': 'PLinear9b'}]\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[1;32m=========================== nnodely Training ===========================\u001b[0m\n", + "\u001b[32m| Epoch |\u001b[0m\u001b[32m errorU |\u001b[0m\u001b[32m errorF |\u001b[0m\u001b[32m Total |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\u001b[32m Loss |\u001b[0m\n", + "\u001b[32m| |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m train |\u001b[0m\u001b[32m train |\u001b[0m\n", + "\u001b[32m|----------------------------------------------------------------------|\u001b[0m\n", + "\u001b[32m| 50/5000 |\u001b[0m\u001b[32m 9.018e-02 |\u001b[0m\u001b[32m 1.413e+00 |\u001b[0m\u001b[32m 7.515e-01 |\u001b[0m\n", + "\u001b[32m| 100/5000 |\u001b[0m\u001b[32m 1.886e-02 |\u001b[0m\u001b[32m 4.612e-02 |\u001b[0m\u001b[32m 3.249e-02 |\u001b[0m\n", + "\u001b[32m| 150/5000 |\u001b[0m\u001b[32m 3.863e-03 |\u001b[0m\u001b[32m 1.532e-03 |\u001b[0m\u001b[32m 2.698e-03 |\u001b[0m\n", + "\u001b[32m| 200/5000 |\u001b[0m\u001b[32m 1.946e-03 |\u001b[0m\u001b[32m 3.386e-04 |\u001b[0m\u001b[32m 1.142e-03 |\u001b[0m\n", + "\u001b[32m| 250/5000 |\u001b[0m\u001b[32m 1.838e-03 |\u001b[0m\u001b[32m 5.892e-04 |\u001b[0m\u001b[32m 1.214e-03 |\u001b[0m\n", + "\u001b[32m| 300/5000 |\u001b[0m\u001b[32m 1.732e-03 |\u001b[0m\u001b[32m 3.606e-04 |\u001b[0m\u001b[32m 1.046e-03 |\u001b[0m\n", + "\u001b[32m| 350/5000 |\u001b[0m\u001b[32m 1.636e-03 |\u001b[0m\u001b[32m 4.242e-04 |\u001b[0m\u001b[32m 1.030e-03 |\u001b[0m\n", + "\u001b[32m| 400/5000 |\u001b[0m\u001b[32m 1.564e-03 |\u001b[0m\u001b[32m 2.444e-04 |\u001b[0m\u001b[32m 9.043e-04 |\u001b[0m\n", + "\u001b[32m| 450/5000 |\u001b[0m\u001b[32m 1.543e-03 |\u001b[0m\u001b[32m 1.600e-04 |\u001b[0m\u001b[32m 8.514e-04 |\u001b[0m\n", + "\u001b[32m| 500/5000 |\u001b[0m\u001b[32m 1.53e-03 |\u001b[0m\u001b[32m 1.101e-04 |\u001b[0m\u001b[32m 8.200e-04 |\u001b[0m\n", + "\u001b[32m| 550/5000 |\u001b[0m\u001b[32m 1.505e-03 |\u001b[0m\u001b[32m 6.108e-05 |\u001b[0m\u001b[32m 7.830e-04 |\u001b[0m\n", + "\u001b[32m| 600/5000 |\u001b[0m\u001b[32m 1.504e-03 |\u001b[0m\u001b[32m 3.504e-05 |\u001b[0m\u001b[32m 7.694e-04 |\u001b[0m\n", + "\u001b[32m| 650/5000 |\u001b[0m\u001b[32m 3.171e-04 |\u001b[0m\u001b[32m 1.438e-04 |\u001b[0m\u001b[32m 2.304e-04 |\u001b[0m\n", + "\u001b[32m| 700/5000 |\u001b[0m\u001b[32m 8.892e-05 |\u001b[0m\u001b[32m 1.083e-04 |\u001b[0m\u001b[32m 9.863e-05 |\u001b[0m\n", + "\u001b[32m| 750/5000 |\u001b[0m\u001b[32m 4.373e-05 |\u001b[0m\u001b[32m 8.569e-05 |\u001b[0m\u001b[32m 6.471e-05 |\u001b[0m\n", + "\u001b[32m| 800/5000 |\u001b[0m\u001b[32m 2.790e-05 |\u001b[0m\u001b[32m 5.551e-05 |\u001b[0m\u001b[32m 4.170e-05 |\u001b[0m\n", + "\u001b[32m| 850/5000 |\u001b[0m\u001b[32m 3.441e-05 |\u001b[0m\u001b[32m 5.859e-05 |\u001b[0m\u001b[32m 4.650e-05 |\u001b[0m\n", + "\u001b[32m| 900/5000 |\u001b[0m\u001b[32m 6.985e-06 |\u001b[0m\u001b[32m 1.973e-05 |\u001b[0m\u001b[32m 1.336e-05 |\u001b[0m\n", + "\u001b[32m| 950/5000 |\u001b[0m\u001b[32m 6.454e-06 |\u001b[0m\u001b[32m 1.649e-05 |\u001b[0m\u001b[32m 1.147e-05 |\u001b[0m\n", + "\u001b[32m|1000/5000 |\u001b[0m\u001b[32m 7.318e-06 |\u001b[0m\u001b[32m 1.616e-05 |\u001b[0m\u001b[32m 1.174e-05 |\u001b[0m\n", + "\u001b[32m|1050/5000 |\u001b[0m\u001b[32m 7.773e-06 |\u001b[0m\u001b[32m 1.579e-05 |\u001b[0m\u001b[32m 1.178e-05 |\u001b[0m\n", + "\u001b[32m|1100/5000 |\u001b[0m\u001b[32m 5.03e-06 |\u001b[0m\u001b[32m 1.188e-05 |\u001b[0m\u001b[32m 8.453e-06 |\u001b[0m\n", + "\u001b[32m|1150/5000 |\u001b[0m\u001b[32m 3.668e-06 |\u001b[0m\u001b[32m 8.326e-06 |\u001b[0m\u001b[32m 5.997e-06 |\u001b[0m\n", + "\u001b[32m|1200/5000 |\u001b[0m\u001b[32m 2.6e-06 |\u001b[0m\u001b[32m 7.771e-06 |\u001b[0m\u001b[32m 5.185e-06 |\u001b[0m\n", + "\u001b[32m|1250/5000 |\u001b[0m\u001b[32m 8.389e-06 |\u001b[0m\u001b[32m 1.483e-05 |\u001b[0m\u001b[32m 1.161e-05 |\u001b[0m\n", + "\u001b[32m|1300/5000 |\u001b[0m\u001b[32m 2.944e-06 |\u001b[0m\u001b[32m 6.592e-06 |\u001b[0m\u001b[32m 4.768e-06 |\u001b[0m\n", + "\u001b[32m|1350/5000 |\u001b[0m\u001b[32m 4.007e-06 |\u001b[0m\u001b[32m 8.243e-06 |\u001b[0m\u001b[32m 6.125e-06 |\u001b[0m\n", + "\u001b[32m|1400/5000 |\u001b[0m\u001b[32m 4.226e-06 |\u001b[0m\u001b[32m 8.995e-06 |\u001b[0m\u001b[32m 6.610e-06 |\u001b[0m\n", + "\u001b[32m|1450/5000 |\u001b[0m\u001b[32m 2.225e-05 |\u001b[0m\u001b[32m 2.984e-05 |\u001b[0m\u001b[32m 2.604e-05 |\u001b[0m\n", + "\u001b[32m|1500/5000 |\u001b[0m\u001b[32m 1.576e-05 |\u001b[0m\u001b[32m 2.343e-05 |\u001b[0m\u001b[32m 1.959e-05 |\u001b[0m\n", + "\u001b[32m|1550/5000 |\u001b[0m\u001b[32m 5.138e-06 |\u001b[0m\u001b[32m 1.073e-05 |\u001b[0m\u001b[32m 7.933e-06 |\u001b[0m\n", + "\u001b[32m|1600/5000 |\u001b[0m\u001b[32m 2.006e-06 |\u001b[0m\u001b[32m 4.534e-06 |\u001b[0m\u001b[32m 3.270e-06 |\u001b[0m\n", + "\u001b[32m|1650/5000 |\u001b[0m\u001b[32m 3.014e-06 |\u001b[0m\u001b[32m 7.368e-06 |\u001b[0m\u001b[32m 5.191e-06 |\u001b[0m\n", + "\u001b[32m|1700/5000 |\u001b[0m\u001b[32m 1.711e-06 |\u001b[0m\u001b[32m 3.738e-06 |\u001b[0m\u001b[32m 2.724e-06 |\u001b[0m\n", + "\u001b[32m|1750/5000 |\u001b[0m\u001b[32m 1.402e-06 |\u001b[0m\u001b[32m 3.050e-06 |\u001b[0m\u001b[32m 2.226e-06 |\u001b[0m\n", + "\u001b[32m|1800/5000 |\u001b[0m\u001b[32m 5.405e-06 |\u001b[0m\u001b[32m 6.894e-06 |\u001b[0m\u001b[32m 6.15e-06 |\u001b[0m\n", + "\u001b[32m|1850/5000 |\u001b[0m\u001b[32m 4.134e-06 |\u001b[0m\u001b[32m 4.535e-06 |\u001b[0m\u001b[32m 4.334e-06 |\u001b[0m\n", + "\u001b[32m|1900/5000 |\u001b[0m\u001b[32m 1.579e-06 |\u001b[0m\u001b[32m 2.762e-06 |\u001b[0m\u001b[32m 2.171e-06 |\u001b[0m\n", + "\u001b[32m|1950/5000 |\u001b[0m\u001b[32m 2.646e-06 |\u001b[0m\u001b[32m 5.012e-06 |\u001b[0m\u001b[32m 3.829e-06 |\u001b[0m\n", + "\u001b[32m|2000/5000 |\u001b[0m\u001b[32m 1.381e-06 |\u001b[0m\u001b[32m 1.573e-06 |\u001b[0m\u001b[32m 1.477e-06 |\u001b[0m\n", + "\u001b[32m|2050/5000 |\u001b[0m\u001b[32m 1.613e-06 |\u001b[0m\u001b[32m 3.587e-06 |\u001b[0m\u001b[32m 2.6e-06 |\u001b[0m\n", + "\u001b[32m|2100/5000 |\u001b[0m\u001b[32m 2.693e-06 |\u001b[0m\u001b[32m 3.447e-06 |\u001b[0m\u001b[32m 3.07e-06 |\u001b[0m\n", + "\u001b[32m|2150/5000 |\u001b[0m\u001b[32m 1.465e-06 |\u001b[0m\u001b[32m 1.942e-06 |\u001b[0m\u001b[32m 1.704e-06 |\u001b[0m\n", + "\u001b[32m|2200/5000 |\u001b[0m\u001b[32m 1.141e-06 |\u001b[0m\u001b[32m 1.933e-06 |\u001b[0m\u001b[32m 1.537e-06 |\u001b[0m\n", + "\u001b[32m|2250/5000 |\u001b[0m\u001b[32m 4.073e-06 |\u001b[0m\u001b[32m 3.550e-06 |\u001b[0m\u001b[32m 3.812e-06 |\u001b[0m\n", + "\u001b[32m|2300/5000 |\u001b[0m\u001b[32m 2.918e-06 |\u001b[0m\u001b[32m 2.235e-06 |\u001b[0m\u001b[32m 2.576e-06 |\u001b[0m\n", + "\u001b[32m|2350/5000 |\u001b[0m\u001b[32m 2.835e-06 |\u001b[0m\u001b[32m 1.932e-06 |\u001b[0m\u001b[32m 2.384e-06 |\u001b[0m\n", + "\u001b[32m|2400/5000 |\u001b[0m\u001b[32m 7.148e-06 |\u001b[0m\u001b[32m 6.592e-06 |\u001b[0m\u001b[32m 6.870e-06 |\u001b[0m\n", + "\u001b[32m|2450/5000 |\u001b[0m\u001b[32m 8.410e-07 |\u001b[0m\u001b[32m 1.945e-06 |\u001b[0m\u001b[32m 1.393e-06 |\u001b[0m\n", + "\u001b[32m|2500/5000 |\u001b[0m\u001b[32m 6.379e-07 |\u001b[0m\u001b[32m 9.164e-07 |\u001b[0m\u001b[32m 7.772e-07 |\u001b[0m\n", + "\u001b[32m|2550/5000 |\u001b[0m\u001b[32m 1.717e-06 |\u001b[0m\u001b[32m 2.593e-06 |\u001b[0m\u001b[32m 2.155e-06 |\u001b[0m\n", + "\u001b[32m|2600/5000 |\u001b[0m\u001b[32m 2.722e-06 |\u001b[0m\u001b[32m 7.063e-06 |\u001b[0m\u001b[32m 4.892e-06 |\u001b[0m\n", + "\u001b[32m|2650/5000 |\u001b[0m\u001b[32m 5.706e-07 |\u001b[0m\u001b[32m 1.253e-06 |\u001b[0m\u001b[32m 9.120e-07 |\u001b[0m\n", + "\u001b[32m|2700/5000 |\u001b[0m\u001b[32m 3.990e-07 |\u001b[0m\u001b[32m 1.038e-06 |\u001b[0m\u001b[32m 7.186e-07 |\u001b[0m\n", + "\u001b[32m|2750/5000 |\u001b[0m\u001b[32m 9.519e-07 |\u001b[0m\u001b[32m 1.662e-06 |\u001b[0m\u001b[32m 1.307e-06 |\u001b[0m\n", + "\u001b[32m|2800/5000 |\u001b[0m\u001b[32m 4.111e-06 |\u001b[0m\u001b[32m 3.098e-06 |\u001b[0m\u001b[32m 3.605e-06 |\u001b[0m\n", + "\u001b[32m|2850/5000 |\u001b[0m\u001b[32m 1.347e-06 |\u001b[0m\u001b[32m 1.464e-06 |\u001b[0m\u001b[32m 1.405e-06 |\u001b[0m\n", + "\u001b[32m|2900/5000 |\u001b[0m\u001b[32m 5.103e-07 |\u001b[0m\u001b[32m 1.178e-06 |\u001b[0m\u001b[32m 8.44e-07 |\u001b[0m\n", + "\u001b[32m|2950/5000 |\u001b[0m\u001b[32m 5.521e-07 |\u001b[0m\u001b[32m 1.155e-06 |\u001b[0m\u001b[32m 8.536e-07 |\u001b[0m\n", + "\u001b[32m|3000/5000 |\u001b[0m\u001b[32m 5.444e-07 |\u001b[0m\u001b[32m 7.651e-07 |\u001b[0m\u001b[32m 6.548e-07 |\u001b[0m\n", + "\u001b[32m|3050/5000 |\u001b[0m\u001b[32m 4.684e-07 |\u001b[0m\u001b[32m 6.802e-07 |\u001b[0m\u001b[32m 5.743e-07 |\u001b[0m\n", + "\u001b[32m|3100/5000 |\u001b[0m\u001b[32m 7.432e-07 |\u001b[0m\u001b[32m 1.625e-06 |\u001b[0m\u001b[32m 1.184e-06 |\u001b[0m\n", + "\u001b[32m|3150/5000 |\u001b[0m\u001b[32m 1.323e-06 |\u001b[0m\u001b[32m 2.188e-06 |\u001b[0m\u001b[32m 1.755e-06 |\u001b[0m\n", + "\u001b[32m|3200/5000 |\u001b[0m\u001b[32m 1.093e-06 |\u001b[0m\u001b[32m 1.363e-06 |\u001b[0m\u001b[32m 1.228e-06 |\u001b[0m\n", + "\u001b[32m|3250/5000 |\u001b[0m\u001b[32m 1.243e-06 |\u001b[0m\u001b[32m 1.959e-06 |\u001b[0m\u001b[32m 1.601e-06 |\u001b[0m\n", + "\u001b[32m|3300/5000 |\u001b[0m\u001b[32m 1.701e-06 |\u001b[0m\u001b[32m 3.564e-06 |\u001b[0m\u001b[32m 2.632e-06 |\u001b[0m\n", + "\u001b[32m|3350/5000 |\u001b[0m\u001b[32m 5.400e-07 |\u001b[0m\u001b[32m 7.495e-07 |\u001b[0m\u001b[32m 6.448e-07 |\u001b[0m\n", + "\u001b[32m|3400/5000 |\u001b[0m\u001b[32m 6.398e-07 |\u001b[0m\u001b[32m 1.927e-06 |\u001b[0m\u001b[32m 1.283e-06 |\u001b[0m\n", + "\u001b[32m|3450/5000 |\u001b[0m\u001b[32m 7.234e-06 |\u001b[0m\u001b[32m 1.095e-05 |\u001b[0m\u001b[32m 9.094e-06 |\u001b[0m\n", + "|3485/5000 | 6.045e-07 | 9.439e-07 | 7.742e-07 |\u001b[34mStopping the training at epoch 3485 due to early stopping.\u001b[0m\n", + "\u001b[1;32m============================ nnodely Training Time =============================\u001b[0m\n", + "\u001b[32mTotal time of Training: 694.5884737968445\u001b[0m\n", + "\u001b[32m================================================================================\u001b[0m\n", + "\u001b[33m[trainModel] If not validation set is provided the selected model can differ from the optimal.\u001b[0m\n", + "\u001b[34mSelected the model at the epoch 3461.\u001b[0m\n" ] } ], - "execution_count": 6 + "source": [ + "from nnodely.support import earlystopping\n", + "\n", + "pinn.loadData(\"dataset2\", data)\n", + "pinn.trainModel(\n", + " train_dataset=\"dataset2\",\n", + " train_batch_size=128,\n", + " num_of_epochs=5000,\n", + " lr=0.0005,\n", + " minimize_gain={\"errorU\": 1, \"errorF\": 0.0005},\n", + " early_stopping=earlystopping.early_stop_patience,\n", + " early_stopping_params={\"patience\": 500, \"error\": \"errorU\"},\n", + " select_model=earlystopping.select_best_model,\n", + ")" + ] }, { "cell_type": "markdown", @@ -1780,6 +1795,7 @@ }, { "cell_type": "code", + "execution_count": 7, "id": "51fa79586fe9b9be", "metadata": { "ExecuteTime": { @@ -1787,153 +1803,155 @@ "start_time": "2026-02-25T17:50:42.919168Z" } }, - "source": [ - "# Custom visualizer for results\n", - "class FunctionVisualizer(TextVisualizer):\n", - " def showResults(self):\n", - " import matplotlib.pyplot as plt\n", - " plt.figure()\n", - " plt.title('Initial Condition')\n", - " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", - " t = torch.zeros(100, dtype=torch.float32)\n", - " u_target = -torch.sin(torch.pi * x)\n", - " u = self.modely({'x':x.tolist(),'t':t.tolist()})\n", - " plt.plot(x.tolist(), u['U'], label=f'network')\n", - " plt.plot(x.tolist(), u_target.tolist(), label=f'target')\n", - " plt.grid(True)\n", - " plt.legend(loc='best')\n", - " plt.xlabel('x[t=0]')\n", - " plt.ylabel('u')\n", - "\n", - " plt.figure()\n", - " plt.title('U value at t=[0.25,0.5,0.75,1]')\n", - " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", - " t = torch.ones(100, dtype=torch.float32)*0.25\n", - " u = self.modely({'x':x.tolist(),'t':t.tolist()})\n", - " plt.plot(x.tolist(), u['U'], label=f'network t=0.25')\n", - " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", - " t = torch.ones(100, dtype=torch.float32)*0.5\n", - " u = self.modely({'x':x.tolist(),'t':t.tolist()})\n", - " plt.plot(x.tolist(), u['U'], label=f'network t=0.5')\n", - " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", - " t = torch.ones(100, dtype=torch.float32)*0.75\n", - " u = self.modely({'x':x.tolist(),'t':t.tolist()})\n", - " plt.plot(x.tolist(), u['U'], label=f'network t=0.75')\n", - " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", - " t = torch.ones(100, dtype=torch.float32)\n", - " u = self.modely({'x':x.tolist(),'t':t.tolist()})\n", - " plt.plot(x.tolist(), u['U'], label=f'network t=1')\n", - " plt.grid(True)\n", - " plt.legend(loc='best')\n", - " plt.xlabel('x')\n", - " plt.ylabel('u')\n", - "\n", - " plt.figure()\n", - " plt.title('Boudary Condition')\n", - " t_1 = torch.linspace(0, 1, steps=100, dtype=torch.float32)\n", - " x_1 = torch.ones(100, dtype=torch.float32)\n", - " u_1_target = torch.zeros(100, dtype=torch.float32)\n", - " u_1 = self.modely({'x': x_1.tolist(), 't': t_1.tolist()})\n", - " plt.plot(t_1.tolist(), u_1['U'], label=f'network x=1')\n", - " plt.plot(t_1.tolist(), u_1_target.tolist(), label=f'target x=1')\n", - " t_2 = torch.linspace(0, 1, steps=100, dtype=torch.float32)\n", - " x_2 = -torch.ones(100, dtype=torch.float32)\n", - " u_2_target = torch.zeros(100, dtype=torch.float32)\n", - " u_2 = self.modely({'x': x_2.tolist(), 't': t_2.tolist()})\n", - " plt.plot(t_2.tolist(), u_2['U'], label=f'network x=-1')\n", - " plt.plot(t_2.tolist(), u_2_target.tolist(), label=f'target x=-1')\n", - " plt.grid(True)\n", - " plt.legend(loc='best')\n", - " plt.xlabel('x[t]')\n", - " plt.ylabel('u')\n", - "\n", - " plt.figure()\n", - " plt.title('Function Integration')\n", - " t_3 = torch.linspace(0, 1, steps=100, dtype=torch.float32).numpy()\n", - " x_3 = torch.linspace(-1, 1, steps=100, dtype=torch.float32).numpy()\n", - " T, X = np.meshgrid(t_3, x_3)\n", - " u_2 = self.modely({'x': X.flatten().tolist(), 't': T.flatten().tolist()})\n", - " plt.contourf(T, X, np.array(u_2['U']).reshape(100,100))\n", - " plt.xlabel('t')\n", - " plt.ylabel('x')\n", - " plt.show()\n", - "\n", - "res = FunctionVisualizer()\n", - "res.setModely(pinn)\n", - "res.showResults()" - ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n", - "\u001B[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001B[0m\n" + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n", + "\u001b[33m[__call__] Inputs not provided: ['u_target', 'b']. Autofilling with zeros..\u001b[0m\n" ] }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {}, - "output_type": "display_data", "jetTransient": { "display_id": null - } + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {}, - "output_type": "display_data", "jetTransient": { "display_id": null - } + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {}, - "output_type": "display_data", "jetTransient": { "display_id": null - } + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, - "metadata": {}, - "output_type": "display_data", "jetTransient": { "display_id": null - } + }, + "metadata": {}, + "output_type": "display_data" } ], - "execution_count": 7 + "source": [ + "# Custom visualizer for results\n", + "class FunctionVisualizer(TextVisualizer):\n", + " def showResults(self):\n", + " import matplotlib.pyplot as plt\n", + "\n", + " plt.figure()\n", + " plt.title(\"Initial Condition\")\n", + " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", + " t = torch.zeros(100, dtype=torch.float32)\n", + " u_target = -torch.sin(torch.pi * x)\n", + " u = self.modely({\"x\": x.tolist(), \"t\": t.tolist()})\n", + " plt.plot(x.tolist(), u[\"U\"], label=\"network\")\n", + " plt.plot(x.tolist(), u_target.tolist(), label=\"target\")\n", + " plt.grid(True)\n", + " plt.legend(loc=\"best\")\n", + " plt.xlabel(\"x[t=0]\")\n", + " plt.ylabel(\"u\")\n", + "\n", + " plt.figure()\n", + " plt.title(\"U value at t=[0.25,0.5,0.75,1]\")\n", + " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", + " t = torch.ones(100, dtype=torch.float32) * 0.25\n", + " u = self.modely({\"x\": x.tolist(), \"t\": t.tolist()})\n", + " plt.plot(x.tolist(), u[\"U\"], label=\"network t=0.25\")\n", + " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", + " t = torch.ones(100, dtype=torch.float32) * 0.5\n", + " u = self.modely({\"x\": x.tolist(), \"t\": t.tolist()})\n", + " plt.plot(x.tolist(), u[\"U\"], label=\"network t=0.5\")\n", + " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", + " t = torch.ones(100, dtype=torch.float32) * 0.75\n", + " u = self.modely({\"x\": x.tolist(), \"t\": t.tolist()})\n", + " plt.plot(x.tolist(), u[\"U\"], label=\"network t=0.75\")\n", + " x = torch.linspace(-1, 1, steps=100, dtype=torch.float32)\n", + " t = torch.ones(100, dtype=torch.float32)\n", + " u = self.modely({\"x\": x.tolist(), \"t\": t.tolist()})\n", + " plt.plot(x.tolist(), u[\"U\"], label=\"network t=1\")\n", + " plt.grid(True)\n", + " plt.legend(loc=\"best\")\n", + " plt.xlabel(\"x\")\n", + " plt.ylabel(\"u\")\n", + "\n", + " plt.figure()\n", + " plt.title(\"Boudary Condition\")\n", + " t_1 = torch.linspace(0, 1, steps=100, dtype=torch.float32)\n", + " x_1 = torch.ones(100, dtype=torch.float32)\n", + " u_1_target = torch.zeros(100, dtype=torch.float32)\n", + " u_1 = self.modely({\"x\": x_1.tolist(), \"t\": t_1.tolist()})\n", + " plt.plot(t_1.tolist(), u_1[\"U\"], label=\"network x=1\")\n", + " plt.plot(t_1.tolist(), u_1_target.tolist(), label=\"target x=1\")\n", + " t_2 = torch.linspace(0, 1, steps=100, dtype=torch.float32)\n", + " x_2 = -torch.ones(100, dtype=torch.float32)\n", + " u_2_target = torch.zeros(100, dtype=torch.float32)\n", + " u_2 = self.modely({\"x\": x_2.tolist(), \"t\": t_2.tolist()})\n", + " plt.plot(t_2.tolist(), u_2[\"U\"], label=\"network x=-1\")\n", + " plt.plot(t_2.tolist(), u_2_target.tolist(), label=\"target x=-1\")\n", + " plt.grid(True)\n", + " plt.legend(loc=\"best\")\n", + " plt.xlabel(\"x[t]\")\n", + " plt.ylabel(\"u\")\n", + "\n", + " plt.figure()\n", + " plt.title(\"Function Integration\")\n", + " t_3 = torch.linspace(0, 1, steps=100, dtype=torch.float32).numpy()\n", + " x_3 = torch.linspace(-1, 1, steps=100, dtype=torch.float32).numpy()\n", + " T, X = np.meshgrid(t_3, x_3)\n", + " u_2 = self.modely({\"x\": X.flatten().tolist(), \"t\": T.flatten().tolist()})\n", + " plt.contourf(T, X, np.array(u_2[\"U\"]).reshape(100, 100))\n", + " plt.xlabel(\"t\")\n", + " plt.ylabel(\"x\")\n", + " plt.show()\n", + "\n", + "\n", + "res = FunctionVisualizer()\n", + "res.setModely(pinn)\n", + "res.showResults()" + ] }, { "cell_type": "code", + "execution_count": 7, "id": "938ccccb00979139", "metadata": { "ExecuteTime": { @@ -1941,9 +1959,8 @@ "start_time": "2026-02-25T17:50:52.695142Z" } }, - "source": [], "outputs": [], - "execution_count": 7 + "source": [] } ], "metadata": { diff --git a/codecov.yml b/codecov.yml index 1575fa2e..f3dc1ddf 100644 --- a/codecov.yml +++ b/codecov.yml @@ -3,4 +3,8 @@ coverage: project: default: target: auto - threshold: 1% # the leniency in hitting the target \ No newline at end of file + threshold: 1% + patch: + default: + target: 90% + threshold: 0% diff --git a/docs/_autodoc/dataset_creation/index.rst b/docs/_autodoc/dataset_creation/index.rst index b3fc20fc..490fe0b6 100644 --- a/docs/_autodoc/dataset_creation/index.rst +++ b/docs/_autodoc/dataset_creation/index.rst @@ -13,7 +13,7 @@ Once loaded, via the :func:`loadData() `, such as interpolation, as well as utilities for extracting specific temporal intervals. These features enable controlled experimentation under different operating conditions while maintaining alignment with the model's temporal structure. .. rubric:: Multi-File handling - + The framework also supports a multi-file dataset mode, where a directory of data files is treated as a single logical dataset. Data from different files are processed independently and concatenated while preserving temporal coherence, ensuring that valid temporal windows are constructed separately for each sequence. This capability is essential for recurrent training and closed-loop prediction scenarios, where temporal consistency across multiple trajectories must be strictly maintained. .. .. rubric:: Key Benefits diff --git a/docs/_autodoc/dataset_creation/loader_module.rst b/docs/_autodoc/dataset_creation/loader_module.rst index 2a65971e..87ba3a52 100644 --- a/docs/_autodoc/dataset_creation/loader_module.rst +++ b/docs/_autodoc/dataset_creation/loader_module.rst @@ -11,4 +11,4 @@ Data Loader module .. autofunction:: nnodely.operators.loader.Loader.loadData For more examples of how to use the data loader, please refer to the -:doc:`relative tutorial <../tutorials/examples/dataset>`. \ No newline at end of file +:doc:`relative tutorial <../tutorials/examples/dataset>`. diff --git a/docs/_autodoc/export/exporter_module.rst b/docs/_autodoc/export/exporter_module.rst index 5ac63a59..ddd3775f 100644 --- a/docs/_autodoc/export/exporter_module.rst +++ b/docs/_autodoc/export/exporter_module.rst @@ -15,4 +15,4 @@ Export module .. autofunction:: nnodely.operators.exporter.Exporter.onnxInference .. autofunction:: nnodely.operators.exporter.Exporter.exportReport -For more examples of how to use the export module, please refer to the :doc:`export tutorial <../tutorials/examples/export>`. \ No newline at end of file +For more examples of how to use the export module, please refer to the :doc:`export tutorial <../tutorials/examples/export>`. diff --git a/docs/_autodoc/export/index.rst b/docs/_autodoc/export/index.rst index ebe5da0f..6d85bd35 100644 --- a/docs/_autodoc/export/index.rst +++ b/docs/_autodoc/export/index.rst @@ -69,7 +69,7 @@ research workflows and real-world deployment, ensuring that models can be easily integrated into diverse application environments. .. rubric:: Additional tools - + Training and validation reports (PDF) can be generated from results using :func:`exportReport() `. diff --git a/docs/_autodoc/getting_started/index.rst b/docs/_autodoc/getting_started/index.rst index 534c95bf..121b2b06 100644 --- a/docs/_autodoc/getting_started/index.rst +++ b/docs/_autodoc/getting_started/index.rst @@ -174,13 +174,13 @@ Reacher Estimator Here is simple two-joint planar manipulator. The inputs are the joint angles :math:`\theta_1` and :math:`\theta_2`, while the outputs are the end-effector coordinates :math:`(x, y)`. The link lengths :math:`l_1` and :math:`l_2` are unknown and are estimated from data using *nnodely* as learnable parameters. - + The kinematic model is given by: -.. math:: - x = l_1 \cos(\theta_1) + l_2 \cos(\theta_1 + \theta_2), \quad +.. math:: + x = l_1 \cos(\theta_1) + l_2 \cos(\theta_1 + \theta_2), \quad y = l_1 \sin(\theta_1) + l_2 \sin(\theta_1 + \theta_2). @@ -188,7 +188,7 @@ The kinematic model is given by: **Local Module Path Configuration and Package Import** -First, we ensure Python can locate modules in the current working directory, +First, we ensure Python can locate modules in the current working directory, enabling the import of nnodely components for use in the script. .. code-block:: python @@ -204,8 +204,8 @@ enabling the import of nnodely components for use in the script. - - Input variables are created using the :class:`Input` class. The learnable parameters are given within the :class:`Parameter`. The :class:`Output` class defines the model output and takes two arguments: + + Input variables are created using the :class:`Input` class. The learnable parameters are given within the :class:`Parameter`. The :class:`Output` class defines the model output and takes two arguments: the name of the output and its structure. @@ -219,7 +219,7 @@ enabling the import of nnodely components for use in the script. l1 = Parameter('l1') #parameters to be estimated l2 = Parameter('l2') #parameters to be estimated - + x_out = Output('x_out', (l1 * Cos(theta1.last())) + (l2 * Cos(theta1.last() + theta2.last()))) y_out = Output('y_out', (l1 * Sin(theta1.last())) + @@ -227,21 +227,21 @@ enabling the import of nnodely components for use in the script. **Model composition** -:class:`addModel` adds the defined output to the model. -:class:`addMinimize` defines the loss function. This function uses the following inputs: The first input is the name of the error (`x-error` and `y-error` in this case). The second and third inputs are the variables whose -difference we want to minimize. The fourth input is the loss function to be used, in this case the mean square error (`mse`). +:class:`addModel` adds the defined output to the model. +:class:`addMinimize` defines the loss function. This function uses the following inputs: The first input is the name of the error (`x-error` and `y-error` in this case). The second and third inputs are the variables whose +difference we want to minimize. The fourth input is the loss function to be used, in this case the mean square error (`mse`). :class:`neuralizeModel` builds the discrete-time MS-NN where its input parameter is the sampling time. .. code-block:: python - # Model composition + # Model composition model = Modely(seed=0) model.addModel('x_out', x_out) model.addModel('y_out', y_out) model.addMinimize('x-error', x_tip.last(), x_out, 'mse') # Objectives model.addMinimize('y-error', y_tip.last(), y_out, 'mse') # Objectives - model.neuralizeModel(sample_time=0.02) + model.neuralizeModel(sample_time=0.02) **Data loading** @@ -251,15 +251,15 @@ difference we want to minimize. The fourth input is the loss function to be used data_struct = ['step', 'T1','T2','theta1', 'theta2', 'x_tip', 'y_tip', 'thetadot1', 'thetadot2', 'thetaddot1', 'thetaddot2'] # dataset creation - + data_folder = os.path.join(os.getcwd(), 'dataset', 'data') - + model.loadData(name='reacher_data', source=data_folder, - format=data_struct, delimiter=';') # Data loading + format=data_struct, delimiter=';') # Data loading **Training** -Trains the model for `200` epochs (batch size `128`, learning rate `0.01`) using a `70/20/10` +Trains the model for `200` epochs (batch size `128`, learning rate `0.01`) using a `70/20/10` train-validation-test split. @@ -279,7 +279,7 @@ train-validation-test split. Code

- + -------------------------------------------------------- Applications @@ -318,4 +318,3 @@ For the tutorial please refer to the link below. Tutorials

- diff --git a/docs/_autodoc/glossary/index.rst b/docs/_autodoc/glossary/index.rst index c344a89f..be52db67 100644 --- a/docs/_autodoc/glossary/index.rst +++ b/docs/_autodoc/glossary/index.rst @@ -15,8 +15,8 @@ An MS‑NN architecture defined through inputs, outputs, and building blocks (re .. rubric:: Input / Output / Parameter -- **Input**: variables entering the model. -- **Output**: signals predicted or calculated by the model. +- **Input**: variables entering the model. +- **Output**: signals predicted or calculated by the model. - **Parameter**: quantities learned during training or fixed constants. .. rubric:: Stream @@ -61,4 +61,4 @@ Operations to save and/or convert a trained MS‑NN into standard formats (e.g., .. rubric:: Dataset -Collection of data (training / test / validation) used to train and evaluate the model. \ No newline at end of file +Collection of data (training / test / validation) used to train and evaluate the model. diff --git a/docs/_autodoc/inference/index.rst b/docs/_autodoc/inference/index.rst index a369793e..dce30664 100644 --- a/docs/_autodoc/inference/index.rst +++ b/docs/_autodoc/inference/index.rst @@ -6,4 +6,4 @@ The framework supports both single forward pass and recursive temporal horizon i .. toctree:: :maxdepth: 1 - inference_module \ No newline at end of file + inference_module diff --git a/docs/_autodoc/inference/inference_module.rst b/docs/_autodoc/inference/inference_module.rst index a11e82c4..d876a051 100644 --- a/docs/_autodoc/inference/inference_module.rst +++ b/docs/_autodoc/inference/inference_module.rst @@ -5,4 +5,4 @@ Inference module .. automethod:: Composer.__call__ -For more examples of how to use the export module, please refer to the :doc:`inference tutorial <../tutorials/examples/inference>`. \ No newline at end of file +For more examples of how to use the export module, please refer to the :doc:`inference tutorial <../tutorials/examples/inference>`. diff --git a/docs/_autodoc/model_composition/composer_module.rst b/docs/_autodoc/model_composition/composer_module.rst index 50aee0ae..ee07a62a 100644 --- a/docs/_autodoc/model_composition/composer_module.rst +++ b/docs/_autodoc/model_composition/composer_module.rst @@ -37,4 +37,4 @@ Key Composer operators: .. autofunction:: nnodely.operators.composer.Composer.removeConnection .. autofunction:: nnodely.operators.composer.Composer.neuralizeModel -For further examples please refer to the :doc:`relative tutorial <../tutorials/examples/states>`. \ No newline at end of file +For further examples please refer to the :doc:`relative tutorial <../tutorials/examples/states>`. diff --git a/docs/_autodoc/model_composition/index.rst b/docs/_autodoc/model_composition/index.rst index b2b59253..515914d9 100644 --- a/docs/_autodoc/model_composition/index.rst +++ b/docs/_autodoc/model_composition/index.rst @@ -72,4 +72,4 @@ distinct levels: relation_module composer_module - modely_execution_model \ No newline at end of file + modely_execution_model diff --git a/docs/_autodoc/model_composition/modely_execution_model.rst b/docs/_autodoc/model_composition/modely_execution_model.rst index 723ec159..ac147bd0 100644 --- a/docs/_autodoc/model_composition/modely_execution_model.rst +++ b/docs/_autodoc/model_composition/modely_execution_model.rst @@ -25,7 +25,7 @@ This dynamic composition can be performed by calling one of the following method .. code-block:: python msd.trainAndAnalyze(models='PID', closed_loop={'x':'x_n', 'x_m':'x_n'}, connect={'F':'F_PID'}, ...) - + .. .. automethod:: nnodely.nnodely.Modely.trainAndAnalyze .. :no-index: diff --git a/docs/_autodoc/model_composition/relation_module.rst b/docs/_autodoc/model_composition/relation_module.rst index cd310cff..34937ebe 100644 --- a/docs/_autodoc/model_composition/relation_module.rst +++ b/docs/_autodoc/model_composition/relation_module.rst @@ -23,7 +23,7 @@ Common Stream operators: :meth:`~nnodely.basic.relation.Stream.sw` (sample window) and :meth:`~nnodely.basic.relation.Stream.tw` (time window). These are the primitives used by temporal building blocks (FIR, recurrent windows, etc.). - + .. automodule:: nnodely.basic.relation :undoc-members: :no-inherited-members: diff --git a/docs/_autodoc/model_definition/index.rst b/docs/_autodoc/model_definition/index.rst index 17a62ea5..a8f359ff 100644 --- a/docs/_autodoc/model_definition/index.rst +++ b/docs/_autodoc/model_definition/index.rst @@ -12,9 +12,9 @@ In addition to these core components, **nnodely** provides a library of reusable .. toctree:: :maxdepth: 1 - + msnn_ins_out_param/input_module msnn_ins_out_param/parameter_module msnn_ins_out_param/initializer_module msnn_ins_out_param/output_module - layers/index \ No newline at end of file + layers/index diff --git a/docs/_autodoc/model_definition/layers/equationlearner_module.rst b/docs/_autodoc/model_definition/layers/equationlearner_module.rst index 69060cbc..475e8060 100644 --- a/docs/_autodoc/model_definition/layers/equationlearner_module.rst +++ b/docs/_autodoc/model_definition/layers/equationlearner_module.rst @@ -11,4 +11,4 @@ EquationLearner module :undoc-members: :no-inherited-members: -For more examples of how to use the equation learner module, please refer to the :doc:`EquationLearner tutorial <../../tutorials/examples/equation_learner>`. \ No newline at end of file +For more examples of how to use the equation learner module, please refer to the :doc:`EquationLearner tutorial <../../tutorials/examples/equation_learner>`. diff --git a/docs/_autodoc/model_definition/layers/fir_module.rst b/docs/_autodoc/model_definition/layers/fir_module.rst index a482ecf1..753c7aac 100644 --- a/docs/_autodoc/model_definition/layers/fir_module.rst +++ b/docs/_autodoc/model_definition/layers/fir_module.rst @@ -10,4 +10,4 @@ FIR module :undoc-members: :no-inherited-members: -For more examples of how to use the FIR module, please refer to the :doc:`FIR tutorial <../../tutorials/examples/fir>`. \ No newline at end of file +For more examples of how to use the FIR module, please refer to the :doc:`FIR tutorial <../../tutorials/examples/fir>`. diff --git a/docs/_autodoc/model_definition/layers/fuzzify_module.rst b/docs/_autodoc/model_definition/layers/fuzzify_module.rst index ba2078e5..61d0f69c 100644 --- a/docs/_autodoc/model_definition/layers/fuzzify_module.rst +++ b/docs/_autodoc/model_definition/layers/fuzzify_module.rst @@ -10,4 +10,4 @@ Fuzzify module :undoc-members: :no-inherited-members: -For more examples of how to use the fuzzify module, please refer to the :doc:`Fuzzify tutorial <../../tutorials/examples/fuzzify>`. \ No newline at end of file +For more examples of how to use the fuzzify module, please refer to the :doc:`Fuzzify tutorial <../../tutorials/examples/fuzzify>`. diff --git a/docs/_autodoc/model_definition/layers/linear_module.rst b/docs/_autodoc/model_definition/layers/linear_module.rst index dc1630c0..de0a0359 100644 --- a/docs/_autodoc/model_definition/layers/linear_module.rst +++ b/docs/_autodoc/model_definition/layers/linear_module.rst @@ -11,4 +11,4 @@ Linear module :undoc-members: :no-inherited-members: -For more examples of how to use the linear module, please refer to the :doc:`Linear tutorial <../../tutorials/examples/linear>`. \ No newline at end of file +For more examples of how to use the linear module, please refer to the :doc:`Linear tutorial <../../tutorials/examples/linear>`. diff --git a/docs/_autodoc/model_definition/layers/localmodel_module.rst b/docs/_autodoc/model_definition/layers/localmodel_module.rst index 8168d4f6..e687c318 100644 --- a/docs/_autodoc/model_definition/layers/localmodel_module.rst +++ b/docs/_autodoc/model_definition/layers/localmodel_module.rst @@ -11,4 +11,4 @@ Localmodel module :undoc-members: :no-inherited-members: -For more examples of how to use the local model module, please refer to the :doc:`LocalModel tutorial <../../tutorials/examples/localmodel>`. \ No newline at end of file +For more examples of how to use the local model module, please refer to the :doc:`LocalModel tutorial <../../tutorials/examples/localmodel>`. diff --git a/docs/_autodoc/model_definition/layers/parametricfunction_module.rst b/docs/_autodoc/model_definition/layers/parametricfunction_module.rst index c518882b..2f2084e3 100644 --- a/docs/_autodoc/model_definition/layers/parametricfunction_module.rst +++ b/docs/_autodoc/model_definition/layers/parametricfunction_module.rst @@ -11,4 +11,4 @@ Parametric Function module :undoc-members: :no-inherited-members: -For more examples of how to use the parametric function module, please refer to the :doc:`Parametric Function tutorial <../../tutorials/examples/parametric_functions>`. \ No newline at end of file +For more examples of how to use the parametric function module, please refer to the :doc:`Parametric Function tutorial <../../tutorials/examples/parametric_functions>`. diff --git a/docs/_autodoc/model_definition/layers/part_module.rst b/docs/_autodoc/model_definition/layers/part_module.rst index d8e611e6..23cc18a8 100644 --- a/docs/_autodoc/model_definition/layers/part_module.rst +++ b/docs/_autodoc/model_definition/layers/part_module.rst @@ -27,4 +27,4 @@ Part module :undoc-members: :no-inherited-members: -For more examples and tutorials, see :doc:`Partitioning tutorial <../../tutorials/examples/partitioning>`. \ No newline at end of file +For more examples and tutorials, see :doc:`Partitioning tutorial <../../tutorials/examples/partitioning>`. diff --git a/docs/_autodoc/model_definition/layers/trigonometric_module.rst b/docs/_autodoc/model_definition/layers/trigonometric_module.rst index c583acdf..2a2a4ca8 100644 --- a/docs/_autodoc/model_definition/layers/trigonometric_module.rst +++ b/docs/_autodoc/model_definition/layers/trigonometric_module.rst @@ -29,4 +29,4 @@ Trigonometric module .. autoclass:: nnodely.layers.trigonometric.Sech :undoc-members: - :no-inherited-members: \ No newline at end of file + :no-inherited-members: diff --git a/docs/_autodoc/model_definition/msnn_ins_out_param/parameter_module.rst b/docs/_autodoc/model_definition/msnn_ins_out_param/parameter_module.rst index ac01447b..ea2bedff 100644 --- a/docs/_autodoc/model_definition/msnn_ins_out_param/parameter_module.rst +++ b/docs/_autodoc/model_definition/msnn_ins_out_param/parameter_module.rst @@ -33,4 +33,4 @@ In addition to standard random initialization, **nnodely** provides structured i :undoc-members: :no-inherited-members: -For more examples of how to use the parameter module, please refer to the :doc:`relative tutorial <../../tutorials/examples/parameter>`. \ No newline at end of file +For more examples of how to use the parameter module, please refer to the :doc:`relative tutorial <../../tutorials/examples/parameter>`. diff --git a/docs/_autodoc/training/earlystopping_module.rst b/docs/_autodoc/training/earlystopping_module.rst index 24dd1e39..47929be8 100644 --- a/docs/_autodoc/training/earlystopping_module.rst +++ b/docs/_autodoc/training/earlystopping_module.rst @@ -8,4 +8,4 @@ Early Stopping module .. autofunction:: nnodely.support.earlystopping.early_stop_patience .. autofunction:: nnodely.support.earlystopping.select_best_model .. autofunction:: nnodely.support.earlystopping.mean_stopping - .. autofunction:: nnodely.support.earlystopping.standard_early_stopping \ No newline at end of file + .. autofunction:: nnodely.support.earlystopping.standard_early_stopping diff --git a/docs/_autodoc/training/optimizer_module.rst b/docs/_autodoc/training/optimizer_module.rst index cce81064..064efc5d 100644 --- a/docs/_autodoc/training/optimizer_module.rst +++ b/docs/_autodoc/training/optimizer_module.rst @@ -13,4 +13,4 @@ Optimizer module .. autoclass:: nnodely.basic.optimizer.Adam :undoc-members: :inherited-members: - :exclude-members: add_option_to_params, replace_key_with_params, get_torch_optimizer \ No newline at end of file + :exclude-members: add_option_to_params, replace_key_with_params, get_torch_optimizer diff --git a/docs/_autodoc/training/trainer_module.rst b/docs/_autodoc/training/trainer_module.rst index b28779f8..ff1041a0 100644 --- a/docs/_autodoc/training/trainer_module.rst +++ b/docs/_autodoc/training/trainer_module.rst @@ -11,7 +11,7 @@ This modality is suitable for architectures without internal feedback, where predictions depend only on the provided inputs. .. rubric:: Recurrent Training - + Targets architectures with closed-loop dependencies, such as feedback connections or coupled multi-model structures. In this modality, training is performed over a finite prediction horizon. The model is rolled out forward in time, and parameter updates are applied only after completing the full rollout using :func:`trainModel `. Early stopping strategies from the :doc:`Early Stopping module ` can be applied to control convergence in long-horizon training. @@ -25,4 +25,4 @@ Early stopping strategies from the :doc:`Early Stopping module `. \ No newline at end of file +For more example please refer to the :doc:`training tutorial <../tutorials/examples/training>`. diff --git a/docs/_autodoc/tutorials/examples/data/example.csv b/docs/_autodoc/tutorials/examples/data/example.csv index 6e0457f6..6dd01025 100644 --- a/docs/_autodoc/tutorials/examples/data/example.csv +++ b/docs/_autodoc/tutorials/examples/data/example.csv @@ -29,4 +29,4 @@ time,x,x_s,F 27,28,29,30 28,29,30,31 29,30,31,32 -30,31,32,33 \ No newline at end of file +30,31,32,33 diff --git a/docs/_autodoc/tutorials/examples/dataset.ipynb b/docs/_autodoc/tutorials/examples/dataset.ipynb index 12dbb739..675003d7 100644 --- a/docs/_autodoc/tutorials/examples/dataset.ipynb +++ b/docs/_autodoc/tutorials/examples/dataset.ipynb @@ -99,13 +99,13 @@ } ], "source": [ - "in1 = Input('in1')\n", - "target = Input('target')\n", + "in1 = Input(\"in1\")\n", + "target = Input(\"target\")\n", "relation = Fir(in1.tw(0.05))\n", - "output = Output('out', relation)\n", + "output = Output(\"out\", relation)\n", "\n", "model = Modely(visualizer=TextVisualizer())\n", - "model.addMinimize('out', output, target.last())\n", + "model.addMinimize(\"out\", output, target.last())\n", "model.neuralizeModel(0.01)" ] }, @@ -145,9 +145,9 @@ } ], "source": [ - "train_folder = 'data'\n", - "data_struct = ['in1', '', 'target']\n", - "model.loadData(name='dataset', source=train_folder, format=data_struct)" + "train_folder = \"data\"\n", + "data_struct = [\"in1\", \"\", \"target\"]\n", + "model.loadData(name=\"dataset\", source=train_folder, format=data_struct)" ] }, { @@ -182,7 +182,14 @@ } ], "source": [ - "model.loadData(name='dataset_2', source=train_folder, format=data_struct, skiplines=4, delimiter='\\t', header=None)" + "model.loadData(\n", + " name=\"dataset_2\",\n", + " source=train_folder,\n", + " format=data_struct,\n", + " skiplines=4,\n", + " delimiter=\"\\t\",\n", + " header=None,\n", + ")" ] }, { @@ -220,12 +227,13 @@ ], "source": [ "import numpy as np\n", + "\n", "data_x = np.array(range(10))\n", "data_a = 2\n", "data_b = -3\n", - "dataset = {'in1': data_x, 'target': (data_a*data_x) + data_b}\n", + "dataset = {\"in1\": data_x, \"target\": (data_a * data_x) + data_b}\n", "\n", - "model.loadData(name='dataset_3', source=dataset)" + "model.loadData(name=\"dataset_3\", source=dataset)" ] }, { @@ -263,12 +271,16 @@ ], "source": [ "import pandas as pd\n", + "\n", "# Create a DataFrame with random values for each input\n", - "df = pd.DataFrame({\n", - " 'in1': np.linspace(1,100,100, dtype=np.float32),\n", - " 'target': np.linspace(1,100,100, dtype=np.float32)})\n", + "df = pd.DataFrame(\n", + " {\n", + " \"in1\": np.linspace(1, 100, 100, dtype=np.float32),\n", + " \"target\": np.linspace(1, 100, 100, dtype=np.float32),\n", + " }\n", + ")\n", "\n", - "model.loadData(name='dataset_4', source=df)" + "model.loadData(name=\"dataset_4\", source=df)" ] }, { @@ -305,12 +317,17 @@ } ], "source": [ - "df = pd.DataFrame({\n", - " 'time': np.array([1.0,1.5,2.0,4.0,4.5,5.0,7.0,7.5,8.0,8.5], dtype=np.float32),\n", - " 'in1': np.linspace(1,10,10, dtype=np.float32),\n", - " 'target': np.linspace(1,10,10, dtype=np.float32)})\n", + "df = pd.DataFrame(\n", + " {\n", + " \"time\": np.array(\n", + " [1.0, 1.5, 2.0, 4.0, 4.5, 5.0, 7.0, 7.5, 8.0, 8.5], dtype=np.float32\n", + " ),\n", + " \"in1\": np.linspace(1, 10, 10, dtype=np.float32),\n", + " \"target\": np.linspace(1, 10, 10, dtype=np.float32),\n", + " }\n", + ")\n", "\n", - "model.loadData(name='dataset_resampled', source=df, resampling=True)" + "model.loadData(name=\"dataset_resampled\", source=df, resampling=True)" ] }, { @@ -348,7 +365,7 @@ } ], "source": [ - "sample = model.getSamples(dataset='dataset_4', window=5)\n", + "sample = model.getSamples(dataset=\"dataset_4\", window=5)\n", "model(sample, sampled=True)" ] } diff --git a/docs/_autodoc/tutorials/examples/dataset/other_data/weights_keras.json b/docs/_autodoc/tutorials/examples/dataset/other_data/weights_keras.json index e1c9212d..20b0e9af 100644 --- a/docs/_autodoc/tutorials/examples/dataset/other_data/weights_keras.json +++ b/docs/_autodoc/tutorials/examples/dataset/other_data/weights_keras.json @@ -1 +1 @@ -{"weights_Phi_layer": [[0.012685388824826905]], "weights_y_layer": [[-0.1854345338982826, 0.8310009650237228]], "weights_lateral_force_Fy_layer": [[-0.19011648493285369, -0.08908118349376112, 1.336387850702053, 1.2920572574778424, -0.09438500021422562, 6.008296562778322e-05, -0.2602301908451158, -0.14530553136816854, 1.3363877377724573, 1.4067596762669665, 0.7879800384173099, 0.3761416745650699, -6.00737156551326e-05], [-0.36005925993705845, 0.31715296267094517, -0.6690789258949266, -0.2554781443995069, 0.31625396631947944, -0.3083455766488089, 0.15216951805631235, -0.4206261340059274, -0.6689552394638391, 0.22550729485249751, 0.1626431985847517, 1.033870940161089, 0.3083458634524217], [0.18802284870005584, -0.31661460582086853, 0.8534668520952942, -0.9812678363224603, 0.24311718237352536, -0.24094412228551954, 0.3072880036082372, 0.17855881988596073, 0.8535322187062506, 0.14222280861767367, 0.3735082621873329, 0.4281402634564149, 0.24090550284449572], [0.7059571634884887, 0.831036154928734, -1.5520232570684374, -1.1949558744521236, 1.0878698744282658, -1.418785910127414, 1.1105076474360718, 0.7796338840890075, -1.5520090193775626, 1.4340218664669733, 1.4600207192669248, 2.0975927853738883, -1.4191253818247085], [1.5256341940706433, 0.9566175382540345, 1.6143430229487328, -1.5732299938434673, 1.4456796215396086, 1.2677360377185034, -1.1754116849251022, 0.9002310736225679, -1.614095846537853, -1.5902608121180453, -1.6560649232874438, 1.4212434156973413, -1.2677278329655355], [-0.2943392917601912, -0.20962344102468206, -0.39777282371248085, -0.24818156146119716, 0.25709724945468077, 0.7976733265366256, -0.47110536863291785, -0.4547936310130406, 0.3977737195448417, 0.05919297447455203, 0.5504838589795269, 0.48094966877918677, 0.7976733529905506], [0.2882358412363946, -0.1769694998492831, 0.31494048781607825, 0.4120887280056081, 0.02440918889325766, 0.11130295760561043, 0.844947413739056, -0.27388447106061653, -0.31488950511700137, 0.44670920167256334, 0.27619535288612646, 0.031508029779568555, 0.1109016477647062], [-0.17117628439315022, 0.8712691462442139, 1.154838105565089, -0.5919095645359649, -0.6519344279453698, 0.22211601204221534, 0.08262748151809965, 0.3598295238234417, -1.1550202286608042, -0.9517794739723651, 0.163217589777445, -0.12628295768104714, 0.22201749256009923], [1.4506073395342782, -0.9325832775205263, -2.1979358075291233, 2.8070465077590003, -1.1346862854456579, 1.3769406818632672, 2.475248535808836, 2.0976190504310988, 2.19821296078414, 2.0255837749393124, 3.083828011008372, 2.50001192339801, -1.3769242385855402], [1.9357170786694566, -1.0112798443932023, 2.000754627001145, 2.4634621666033816, -1.694712934160906, -1.3599774709358892, -1.4821823368748877, 0.1430931122186942, 2.000786017219198, -1.9266467245466596, -2.175009991370894, 0.7244597098063941, -1.3599925425879837], [-0.999649832233769, 1.1789553679187095, -1.0439958121675497, 0.6859639814252193, -1.207373719896859, 1.4355651469453192, -1.0252723585630958, -1.0277168693514158, -1.0439392352227312, 1.1185833489292838, 1.2486301466781338, 1.2271341647965177, -1.4355998395140415], [0.5472048599834014, -0.2964604823481814, -0.755279693792939, 0.496730028445273, 0.03189984598977768, -0.011526076792924516, 0.13793532007135406, -0.3922534852030546, 0.7552757947568585, 0.541882492971732, 1.3892197075267785, 0.029209525577498854, 0.011427767016954781], [-0.33289867240184234, -0.8250106024590829, 1.3307613450025935, -0.17274867992122075, 1.167809311448035, 0.11023086130586764, 1.387883975990627, 1.6525955037269457, 1.330712816962725, -1.1008274196962873, 0.12774339481905536, 1.6778832697823363, -0.1102327756404915], [1.3799212851947305, -0.11798177584035434, -1.2706691824287746, 1.3389620861547382, -0.07167511836865471, 0.574528497078781, 1.053126427807511, 0.525765012439538, 1.2706790577938978, 1.323968682481893, 1.395683119845944, 0.9919769987157268, -0.5745468641121597], [1.470852592611058, -0.2753007632206784, 1.3267311312902044, 1.4002748745291318, -0.32148568082965384, -0.2445208276668468, -1.6411299244249362, 1.665228483180153, 1.326825077761312, -1.3355204169065926, -1.6876677699164133, 1.709701263209955, -0.24440222805773965], [0.061201334164515474, -0.2613894929273045, 0.17194839021789546, 0.357392249323869, -0.1969047844516283, -0.40138265636368453, 0.054160782803064425, 0.04499566865007523, 0.17179140127081347, 0.28445081911658165, 0.26876231918645477, 0.2834999443210322, 0.40140992216043186], [-0.7383867680261166, 0.28140178858383064, -1.0607846672606085, 1.1293524025011914, -0.38584968559452604, 0.6814052979441493, -0.8472337078996004, -0.8521757690270018, -1.0603091109428728, 1.1219117352503318, 1.161103667708072, 1.1370906079460585, -0.6814279198878799], [-0.5754205744199418, 0.7515354938234574, -0.7427595435202464, 0.08173230816182779, -0.5818699059495528, -0.8576746961203272, 0.9107580156302137, -0.4636739933720752, -0.7435719493943217, 0.9818698110846921, -1.39877838441067, 0.10852623836507357, -0.8577092093212803], [1.1803303176988844, -0.8602509152319485, 2.08823235980041, 0.5640822448256174, -1.1113029573112245, -1.783096430959948, 0.38542138435556245, 0.8968062265303769, -2.0880454626597094, 1.5287272459021344, 0.6517334709095841, 1.3030554584249463, 1.7831668896262234], [0.9965967442529087, -0.9555740352345297, 0.9315736169296287, 0.952402105850403, -1.0038521933218492, -1.0384630844945648, -1.2568415867731368, 1.359454269250626, 0.9315953305928442, -1.0105122965663116, -1.4543433160625407, 1.5251210878543582, -1.0382923330987461], [-0.0003252008154921961, -0.0007757975430400393, 0.00027610923975581776, -0.000492314483248814, 0.00037227465197929875, 0.00012994623625124898, 0.00014116358428038455, 0.0005370449387972119, -4.011652901164747e-05, 0.0005026686325048509, 0.00042415295448027955, 0.0006194169481779365, -0.00014805157424955308], [0.25408255894477966, 0.4008486804612262, -0.9585384454176571, 0.07462983204257474, 0.20304621135962272, -0.7509778599485446, 0.1957008083070563, 0.21407418595698074, -0.9583716769231316, 1.1536953456759063, 0.5223846802781359, 0.4893487538764833, -0.7512212443147893], [0.5872378239364147, -1.028692570295371, -1.1345470507881132, 0.9921306627222031, -1.431783879088534, -0.5131283754255125, 0.031786765651124815, -0.24578096239017852, 1.1346001691321415, 1.3546533350024696, -0.04328366980497708, -0.9381339085116982, 0.5132369498728799], [-0.14295606844165948, -0.01877309912889, 0.5876429218771214, 0.48027938625599703, -0.3365035305830312, -0.9956153538141037, -0.4515785924356622, 0.5789253255140729, 0.5882234039953237, -0.05064944535197737, -0.592386760754478, 0.6410803440586128, -0.9955860588207823], [0.000787086437955529, -8.908694807142095e-06, -0.0006681074216258374, 0.0002151332500077205, -0.0005916405206218054, 0.0009121619779000141, 0.0002014354532319387, -3.0046087688955496e-05, 0.00039327018433161, 4.262729131982468e-05, 0.0016545339586900472, 0.0007591541430962376, 0.00018828612339093865]], "weights_rolling_resis_Fr_layer": [[0.009512348136131527, 0.015974305622861035, 0.012354668768985456, -0.02350446610289629, -0.021171149395172454], [0.04485560728012199, -0.005721244207683364, 0.009212919587585475, 0.056730803145390786, 0.08301125650143018], [-0.027671052741331956, 0.0005604850752721769, 7.768705209179708e-05, 0.019376156352589505, -0.0036748612480807553], [0.13136716489951636, -0.00505070341472879, 0.05868154169374028, -0.09000068012576608, -0.015475440377495217], [0.13123488929110713, 0.04738146152770957, -0.09140000602220295, -0.06928203303665631, -0.02297547485706099], [-0.1292347084279552, -0.09376875839320302, 0.09143687406062925, -0.042666819353032216, -0.08618952991465577], [0.03811870391839511, 0.04299551986113498, -0.015645139143944567, -0.005474475667232196, -0.10268401640164736], [0.010408554061713201, -0.01680342808995886, -0.026197713491986078, 0.007333479240267465, 0.024039377702831342], [0.03636583768453933, 0.019818467772646533, -0.0037000940948564843, 0.03470735249075659, 0.035761192938559644], [0.10914620691295635, 0.0681068573436399, -0.06704391198934014, -0.0058835924268194634, -0.0900478676267965], [-0.18273868602774165, -0.018173976405129886, -0.033806530873410706, -0.014822716241073402, 0.0011868321653409092], [0.08779567256832134, -0.0007543581153410836, -0.026161440641287743, -0.0008218318939369428, -0.05193780327764801], [0.0794895474049251, 0.013610288551551318, 0.00965207990980787, -0.09109264333425719, 0.07350332727372452], [0.11045172299216201, 0.10204791507802281, -0.01748638178864372, 0.0892068942348556, -0.11044337166665709], [0.2592527992617235, -0.059380721328938506, -0.36878016964982613, -0.08994677022091373, 0.536723089245246], [0.1481965010752139, 0.009199935103273497, 0.006816411716118778, 0.07245631603959318, -0.016350624468557635], [0.09861027451021276, 0.003809132398771833, 0.05702825577816732, 0.004509477844508769, -0.04145490208647068], [0.10552877411008127, 0.04774693387230193, -0.019785790434331273, -0.033777708832308954, 0.08008065558794654], [-0.009534395253850227, 0.2371943342468657, 0.05340427321482067, 0.054605243213691625, 0.22608070427496613], [0.5809629742447168, 0.03565806917804284, -0.2612010705948309, 0.28708726638020116, 0.062365224169860664], [9.396158363284712e-05, 0.00010777149932499175, 9.883206328784566e-05, 9.817530963461989e-05, 9.044142390143377e-05], [0.15581565021743365, 0.13103577835449093, -0.07876624531554803, -0.210951410006127, -0.0012785118547123297], [0.13182698748047716, 0.1762004260101664, 0.09210441306630922, 0.2060755656713025, 0.013773614352975106], [0.14984011485073506, 0.13626731231521377, -0.017230767623647506, 0.10871804112668679, 0.06346689814508452], [0.0001097756900344383, 9.740100575111105e-05, 0.00011760808818914617, 0.00010664388733340848, 8.993184159731601e-05]], "weights_FC1_layer_steer": [[0.38688127715207987, -0.3871187885731928, -0.3870036745961848, 0.38676281255272826, 0.38703086352404237, -0.3868947521837845, 0.3871124432809551, -0.3869712978151479, 0.38692919331713455, 0.38688800029402004]], "biases_FC1_layer_steer": [0.6827290688825456, -0.6837825068595632, -0.6832820008581203, 0.6822021789791652, 0.6833963624234348, -0.68279452477573, 0.6837620722967017, -0.6831272126615047, 0.682948780966369, 0.6827714454347539], "weights_FC2_layer_steer": [[2.0884597157646563], [-2.087764579846399], [-2.085872928095188], [2.089101087015271], [2.0872048698362446], [-2.087166620124699], [2.0860502186132233], [-2.0884596607292907], [2.0867457700638337], [2.085633475017681]], "biases_FC2_layer_steer": [-1.361573075727897], "lambda_forget_weight": [[0.995]], "max_Tyf_engine": 399.59648198652155, "max_Tyf_brake": 2317.418462624429, "max_Tyr_brake": 941.7535062079378, "max_vx": 22.441584159075212, "min_vx": 4.0, "max_ax": 2.870634750517449, "min_ax": -1.8177452194551227, "max_ay": 4.319774302260081, "max_steer": 7.41147685692138} \ No newline at end of file +{"weights_Phi_layer": [[0.012685388824826905]], "weights_y_layer": [[-0.1854345338982826, 0.8310009650237228]], "weights_lateral_force_Fy_layer": [[-0.19011648493285369, -0.08908118349376112, 1.336387850702053, 1.2920572574778424, -0.09438500021422562, 6.008296562778322e-05, -0.2602301908451158, -0.14530553136816854, 1.3363877377724573, 1.4067596762669665, 0.7879800384173099, 0.3761416745650699, -6.00737156551326e-05], [-0.36005925993705845, 0.31715296267094517, -0.6690789258949266, -0.2554781443995069, 0.31625396631947944, -0.3083455766488089, 0.15216951805631235, -0.4206261340059274, -0.6689552394638391, 0.22550729485249751, 0.1626431985847517, 1.033870940161089, 0.3083458634524217], [0.18802284870005584, -0.31661460582086853, 0.8534668520952942, -0.9812678363224603, 0.24311718237352536, -0.24094412228551954, 0.3072880036082372, 0.17855881988596073, 0.8535322187062506, 0.14222280861767367, 0.3735082621873329, 0.4281402634564149, 0.24090550284449572], [0.7059571634884887, 0.831036154928734, -1.5520232570684374, -1.1949558744521236, 1.0878698744282658, -1.418785910127414, 1.1105076474360718, 0.7796338840890075, -1.5520090193775626, 1.4340218664669733, 1.4600207192669248, 2.0975927853738883, -1.4191253818247085], [1.5256341940706433, 0.9566175382540345, 1.6143430229487328, -1.5732299938434673, 1.4456796215396086, 1.2677360377185034, -1.1754116849251022, 0.9002310736225679, -1.614095846537853, -1.5902608121180453, -1.6560649232874438, 1.4212434156973413, -1.2677278329655355], [-0.2943392917601912, -0.20962344102468206, -0.39777282371248085, -0.24818156146119716, 0.25709724945468077, 0.7976733265366256, -0.47110536863291785, -0.4547936310130406, 0.3977737195448417, 0.05919297447455203, 0.5504838589795269, 0.48094966877918677, 0.7976733529905506], [0.2882358412363946, -0.1769694998492831, 0.31494048781607825, 0.4120887280056081, 0.02440918889325766, 0.11130295760561043, 0.844947413739056, -0.27388447106061653, -0.31488950511700137, 0.44670920167256334, 0.27619535288612646, 0.031508029779568555, 0.1109016477647062], [-0.17117628439315022, 0.8712691462442139, 1.154838105565089, -0.5919095645359649, -0.6519344279453698, 0.22211601204221534, 0.08262748151809965, 0.3598295238234417, -1.1550202286608042, -0.9517794739723651, 0.163217589777445, -0.12628295768104714, 0.22201749256009923], [1.4506073395342782, -0.9325832775205263, -2.1979358075291233, 2.8070465077590003, -1.1346862854456579, 1.3769406818632672, 2.475248535808836, 2.0976190504310988, 2.19821296078414, 2.0255837749393124, 3.083828011008372, 2.50001192339801, -1.3769242385855402], [1.9357170786694566, -1.0112798443932023, 2.000754627001145, 2.4634621666033816, -1.694712934160906, -1.3599774709358892, -1.4821823368748877, 0.1430931122186942, 2.000786017219198, -1.9266467245466596, -2.175009991370894, 0.7244597098063941, -1.3599925425879837], [-0.999649832233769, 1.1789553679187095, -1.0439958121675497, 0.6859639814252193, -1.207373719896859, 1.4355651469453192, -1.0252723585630958, -1.0277168693514158, -1.0439392352227312, 1.1185833489292838, 1.2486301466781338, 1.2271341647965177, -1.4355998395140415], [0.5472048599834014, -0.2964604823481814, -0.755279693792939, 0.496730028445273, 0.03189984598977768, -0.011526076792924516, 0.13793532007135406, -0.3922534852030546, 0.7552757947568585, 0.541882492971732, 1.3892197075267785, 0.029209525577498854, 0.011427767016954781], [-0.33289867240184234, -0.8250106024590829, 1.3307613450025935, -0.17274867992122075, 1.167809311448035, 0.11023086130586764, 1.387883975990627, 1.6525955037269457, 1.330712816962725, -1.1008274196962873, 0.12774339481905536, 1.6778832697823363, -0.1102327756404915], [1.3799212851947305, -0.11798177584035434, -1.2706691824287746, 1.3389620861547382, -0.07167511836865471, 0.574528497078781, 1.053126427807511, 0.525765012439538, 1.2706790577938978, 1.323968682481893, 1.395683119845944, 0.9919769987157268, -0.5745468641121597], [1.470852592611058, -0.2753007632206784, 1.3267311312902044, 1.4002748745291318, -0.32148568082965384, -0.2445208276668468, -1.6411299244249362, 1.665228483180153, 1.326825077761312, -1.3355204169065926, -1.6876677699164133, 1.709701263209955, -0.24440222805773965], [0.061201334164515474, -0.2613894929273045, 0.17194839021789546, 0.357392249323869, -0.1969047844516283, -0.40138265636368453, 0.054160782803064425, 0.04499566865007523, 0.17179140127081347, 0.28445081911658165, 0.26876231918645477, 0.2834999443210322, 0.40140992216043186], [-0.7383867680261166, 0.28140178858383064, -1.0607846672606085, 1.1293524025011914, -0.38584968559452604, 0.6814052979441493, -0.8472337078996004, -0.8521757690270018, -1.0603091109428728, 1.1219117352503318, 1.161103667708072, 1.1370906079460585, -0.6814279198878799], [-0.5754205744199418, 0.7515354938234574, -0.7427595435202464, 0.08173230816182779, -0.5818699059495528, -0.8576746961203272, 0.9107580156302137, -0.4636739933720752, -0.7435719493943217, 0.9818698110846921, -1.39877838441067, 0.10852623836507357, -0.8577092093212803], [1.1803303176988844, -0.8602509152319485, 2.08823235980041, 0.5640822448256174, -1.1113029573112245, -1.783096430959948, 0.38542138435556245, 0.8968062265303769, -2.0880454626597094, 1.5287272459021344, 0.6517334709095841, 1.3030554584249463, 1.7831668896262234], [0.9965967442529087, -0.9555740352345297, 0.9315736169296287, 0.952402105850403, -1.0038521933218492, -1.0384630844945648, -1.2568415867731368, 1.359454269250626, 0.9315953305928442, -1.0105122965663116, -1.4543433160625407, 1.5251210878543582, -1.0382923330987461], [-0.0003252008154921961, -0.0007757975430400393, 0.00027610923975581776, -0.000492314483248814, 0.00037227465197929875, 0.00012994623625124898, 0.00014116358428038455, 0.0005370449387972119, -4.011652901164747e-05, 0.0005026686325048509, 0.00042415295448027955, 0.0006194169481779365, -0.00014805157424955308], [0.25408255894477966, 0.4008486804612262, -0.9585384454176571, 0.07462983204257474, 0.20304621135962272, -0.7509778599485446, 0.1957008083070563, 0.21407418595698074, -0.9583716769231316, 1.1536953456759063, 0.5223846802781359, 0.4893487538764833, -0.7512212443147893], [0.5872378239364147, -1.028692570295371, -1.1345470507881132, 0.9921306627222031, -1.431783879088534, -0.5131283754255125, 0.031786765651124815, -0.24578096239017852, 1.1346001691321415, 1.3546533350024696, -0.04328366980497708, -0.9381339085116982, 0.5132369498728799], [-0.14295606844165948, -0.01877309912889, 0.5876429218771214, 0.48027938625599703, -0.3365035305830312, -0.9956153538141037, -0.4515785924356622, 0.5789253255140729, 0.5882234039953237, -0.05064944535197737, -0.592386760754478, 0.6410803440586128, -0.9955860588207823], [0.000787086437955529, -8.908694807142095e-06, -0.0006681074216258374, 0.0002151332500077205, -0.0005916405206218054, 0.0009121619779000141, 0.0002014354532319387, -3.0046087688955496e-05, 0.00039327018433161, 4.262729131982468e-05, 0.0016545339586900472, 0.0007591541430962376, 0.00018828612339093865]], "weights_rolling_resis_Fr_layer": [[0.009512348136131527, 0.015974305622861035, 0.012354668768985456, -0.02350446610289629, -0.021171149395172454], [0.04485560728012199, -0.005721244207683364, 0.009212919587585475, 0.056730803145390786, 0.08301125650143018], [-0.027671052741331956, 0.0005604850752721769, 7.768705209179708e-05, 0.019376156352589505, -0.0036748612480807553], [0.13136716489951636, -0.00505070341472879, 0.05868154169374028, -0.09000068012576608, -0.015475440377495217], [0.13123488929110713, 0.04738146152770957, -0.09140000602220295, -0.06928203303665631, -0.02297547485706099], [-0.1292347084279552, -0.09376875839320302, 0.09143687406062925, -0.042666819353032216, -0.08618952991465577], [0.03811870391839511, 0.04299551986113498, -0.015645139143944567, -0.005474475667232196, -0.10268401640164736], [0.010408554061713201, -0.01680342808995886, -0.026197713491986078, 0.007333479240267465, 0.024039377702831342], [0.03636583768453933, 0.019818467772646533, -0.0037000940948564843, 0.03470735249075659, 0.035761192938559644], [0.10914620691295635, 0.0681068573436399, -0.06704391198934014, -0.0058835924268194634, -0.0900478676267965], [-0.18273868602774165, -0.018173976405129886, -0.033806530873410706, -0.014822716241073402, 0.0011868321653409092], [0.08779567256832134, -0.0007543581153410836, -0.026161440641287743, -0.0008218318939369428, -0.05193780327764801], [0.0794895474049251, 0.013610288551551318, 0.00965207990980787, -0.09109264333425719, 0.07350332727372452], [0.11045172299216201, 0.10204791507802281, -0.01748638178864372, 0.0892068942348556, -0.11044337166665709], [0.2592527992617235, -0.059380721328938506, -0.36878016964982613, -0.08994677022091373, 0.536723089245246], [0.1481965010752139, 0.009199935103273497, 0.006816411716118778, 0.07245631603959318, -0.016350624468557635], [0.09861027451021276, 0.003809132398771833, 0.05702825577816732, 0.004509477844508769, -0.04145490208647068], [0.10552877411008127, 0.04774693387230193, -0.019785790434331273, -0.033777708832308954, 0.08008065558794654], [-0.009534395253850227, 0.2371943342468657, 0.05340427321482067, 0.054605243213691625, 0.22608070427496613], [0.5809629742447168, 0.03565806917804284, -0.2612010705948309, 0.28708726638020116, 0.062365224169860664], [9.396158363284712e-05, 0.00010777149932499175, 9.883206328784566e-05, 9.817530963461989e-05, 9.044142390143377e-05], [0.15581565021743365, 0.13103577835449093, -0.07876624531554803, -0.210951410006127, -0.0012785118547123297], [0.13182698748047716, 0.1762004260101664, 0.09210441306630922, 0.2060755656713025, 0.013773614352975106], [0.14984011485073506, 0.13626731231521377, -0.017230767623647506, 0.10871804112668679, 0.06346689814508452], [0.0001097756900344383, 9.740100575111105e-05, 0.00011760808818914617, 0.00010664388733340848, 8.993184159731601e-05]], "weights_FC1_layer_steer": [[0.38688127715207987, -0.3871187885731928, -0.3870036745961848, 0.38676281255272826, 0.38703086352404237, -0.3868947521837845, 0.3871124432809551, -0.3869712978151479, 0.38692919331713455, 0.38688800029402004]], "biases_FC1_layer_steer": [0.6827290688825456, -0.6837825068595632, -0.6832820008581203, 0.6822021789791652, 0.6833963624234348, -0.68279452477573, 0.6837620722967017, -0.6831272126615047, 0.682948780966369, 0.6827714454347539], "weights_FC2_layer_steer": [[2.0884597157646563], [-2.087764579846399], [-2.085872928095188], [2.089101087015271], [2.0872048698362446], [-2.087166620124699], [2.0860502186132233], [-2.0884596607292907], [2.0867457700638337], [2.085633475017681]], "biases_FC2_layer_steer": [-1.361573075727897], "lambda_forget_weight": [[0.995]], "max_Tyf_engine": 399.59648198652155, "max_Tyf_brake": 2317.418462624429, "max_Tyr_brake": 941.7535062079378, "max_vx": 22.441584159075212, "min_vx": 4.0, "max_ax": 2.870634750517449, "min_ax": -1.8177452194551227, "max_ay": 4.319774302260081, "max_steer": 7.41147685692138} diff --git a/docs/_autodoc/tutorials/examples/equation_learner.ipynb b/docs/_autodoc/tutorials/examples/equation_learner.ipynb index f2e52ea4..2ce52bfa 100644 --- a/docs/_autodoc/tutorials/examples/equation_learner.ipynb +++ b/docs/_autodoc/tutorials/examples/equation_learner.ipynb @@ -109,9 +109,9 @@ } ], "source": [ - "x = Input('x')\n", + "x = Input(\"x\")\n", "equation_learner = EquationLearner(functions=[Tan, Sin, Cos])\n", - "Output('out',equation_learner(x.last()))" + "Output(\"out\", equation_learner(x.last()))" ] }, { @@ -171,10 +171,10 @@ } ], "source": [ - "x = Input('x')\n", + "x = Input(\"x\")\n", "input_layer = Linear(output_dimension=3)\n", "equation_learner = EquationLearner(functions=[Tan, Sin, Cos], linear_in=input_layer)\n", - "Output('out', equation_learner(x.last()))" + "Output(\"out\", equation_learner(x.last()))" ] }, { @@ -235,11 +235,13 @@ } ], "source": [ - "x = Input('x')\n", + "x = Input(\"x\")\n", "input_layer = Linear(output_dimension=3)\n", "output_layer = Linear(output_dimension=1)\n", - "equation_learner = EquationLearner(functions=[Tan, Sin, Cos], linear_in=input_layer, linear_out=output_layer)\n", - "Output('out', equation_learner(x.last()))" + "equation_learner = EquationLearner(\n", + " functions=[Tan, Sin, Cos], linear_in=input_layer, linear_out=output_layer\n", + ")\n", + "Output(\"out\", equation_learner(x.last()))" ] }, { @@ -307,10 +309,10 @@ } ], "source": [ - "x = Input('x')\n", - "F = Input('F')\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "equation_learner = EquationLearner(functions=[Tan, Sin, Cos])\n", - "Output('out',equation_learner(inputs=(x.last(),F.last())))" + "Output(\"out\", equation_learner(inputs=(x.last(), F.last())))" ] }, { @@ -382,12 +384,14 @@ } ], "source": [ - "x = Input('x')\n", - "F = Input('F')\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "\n", "linear_layer_in_1 = Linear(output_dimension=7)\n", - "equation_learner_1 = EquationLearner(functions=[Tan, Add, Sin, Mul, Identity], linear_in=linear_layer_in_1)\n", - "Output('out',equation_learner_1(x.last()))" + "equation_learner_1 = EquationLearner(\n", + " functions=[Tan, Add, Sin, Mul, Identity], linear_in=linear_layer_in_1\n", + ")\n", + "Output(\"out\", equation_learner_1(x.last()))" ] }, { @@ -461,17 +465,20 @@ "source": [ "import torch\n", "\n", + "\n", "def func1(K1):\n", " return torch.sin(K1)\n", "\n", + "\n", "def func2(K2):\n", " return torch.cos(K2)\n", "\n", - "x = Input('x')\n", + "\n", + "x = Input(\"x\")\n", "parfun1 = ParamFun(func1)\n", "parfun2 = ParamFun(func2)\n", "equation_learner = EquationLearner([parfun1, parfun2])\n", - "Output('out',equation_learner(x.last()))" + "Output(\"out\", equation_learner(x.last()))" ] }, { @@ -557,18 +564,19 @@ } ], "source": [ - "def myFun(K1,K2,p1,p2):\n", - " return K1*p1+K2*p2\n", + "def myFun(K1, K2, p1, p2):\n", + " return K1 * p1 + K2 * p2\n", + "\n", "\n", - "x = Input('x')\n", - "F = Input('F')\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "\n", - "K1 = Parameter('k1', dimensions = 1, sw = 1, values=[[2.0]])\n", - "K2 = Parameter('k2', dimensions = 1, sw = 1, values=[[3.0]])\n", - "parfun = ParamFun(myFun, parameters_and_constants=[K1,K2])\n", + "K1 = Parameter(\"k1\", dimensions=1, sw=1, values=[[2.0]])\n", + "K2 = Parameter(\"k2\", dimensions=1, sw=1, values=[[3.0]])\n", + "parfun = ParamFun(myFun, parameters_and_constants=[K1, K2])\n", "\n", "equation_learner = EquationLearner([parfun, Sin, Add])\n", - "Output('out',equation_learner((x.last(),F.last())))" + "Output(\"out\", equation_learner((x.last(), F.last())))" ] }, { @@ -645,18 +653,19 @@ } ], "source": [ - "def myFun(K1,p1):\n", - " return K1*p1\n", + "def myFun(K1, p1):\n", + " return K1 * p1\n", "\n", - "x = Input('x')\n", - "F = Input('F')\n", "\n", - "K = Parameter('k', dimensions = 1, sw = 1,values=[[2.0]])\n", - "parfun = ParamFun(myFun, parameters_and_constants = [K])\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "\n", - "fuzzi = Fuzzify(centers=[0,1,2,3])\n", + "K = Parameter(\"k\", dimensions=1, sw=1, values=[[2.0]])\n", + "parfun = ParamFun(myFun, parameters_and_constants=[K])\n", + "\n", + "fuzzi = Fuzzify(centers=[0, 1, 2, 3])\n", "equation_learner = EquationLearner([parfun, fuzzi])\n", - "Output('out',equation_learner((x.last(),F.last())))" + "Output(\"out\", equation_learner((x.last(), F.last())))" ] }, { @@ -779,23 +788,43 @@ } ], "source": [ - "x = Input('x')\n", - "F = Input('F')\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", + "\n", + "\n", + "def myFun(K1, K2, p1, p2):\n", + " return K1 * p1 + K2 * p2\n", "\n", - "def myFun(K1,K2,p1,p2):\n", - " return K1*p1+K2*p2\n", "\n", - "K1 = Parameter('k1', dimensions = 1, sw = 1, values=[[2.0]])\n", - "K2 = Parameter('k2', dimensions = 1, sw = 1, values=[[3.0]])\n", - "parfun = ParamFun(myFun, parameters_and_constants = [K1,K2])\n", + "K1 = Parameter(\"k1\", dimensions=1, sw=1, values=[[2.0]])\n", + "K2 = Parameter(\"k2\", dimensions=1, sw=1, values=[[3.0]])\n", + "parfun = ParamFun(myFun, parameters_and_constants=[K1, K2])\n", "\n", - "input_layer_1 = Linear(output_dimension=5, W_init='init_constant', W_init_params={'value':1}, b_init='init_constant', b_init_params={'value':0})\n", - "input_layer_2 = Linear(output_dimension=7, W_init='init_constant', W_init_params={'value':1}, b_init='init_constant', b_init_params={'value':0})\n", - "output_layer = Linear(output_dimension=1, W_init='init_constant', W_init_params={'value':1}, b=True)\n", + "input_layer_1 = Linear(\n", + " output_dimension=5,\n", + " W_init=\"init_constant\",\n", + " W_init_params={\"value\": 1},\n", + " b_init=\"init_constant\",\n", + " b_init_params={\"value\": 0},\n", + ")\n", + "input_layer_2 = Linear(\n", + " output_dimension=7,\n", + " W_init=\"init_constant\",\n", + " W_init_params={\"value\": 1},\n", + " b_init=\"init_constant\",\n", + " b_init_params={\"value\": 0},\n", + ")\n", + "output_layer = Linear(\n", + " output_dimension=1, W_init=\"init_constant\", W_init_params={\"value\": 1}, b=True\n", + ")\n", "equation_learner = EquationLearner([parfun, Sin, Add], linear_in=input_layer_1)\n", - "equation_learner_2 = EquationLearner(functions=[Tan, Add, Sin, Mul, Identity], linear_in=input_layer_2, linear_out=output_layer)\n", + "equation_learner_2 = EquationLearner(\n", + " functions=[Tan, Add, Sin, Mul, Identity],\n", + " linear_in=input_layer_2,\n", + " linear_out=output_layer,\n", + ")\n", "\n", - "Output('out',equation_learner_2(equation_learner((x.sw(1),F.sw(1)))))" + "Output(\"out\", equation_learner_2(equation_learner((x.sw(1), F.sw(1)))))" ] } ], diff --git a/docs/_autodoc/tutorials/examples/export.ipynb b/docs/_autodoc/tutorials/examples/export.ipynb index 6cb1b98e..d2ee24ba 100644 --- a/docs/_autodoc/tutorials/examples/export.ipynb +++ b/docs/_autodoc/tutorials/examples/export.ipynb @@ -86,22 +86,24 @@ } ], "source": [ - "x = Input('x')\n", - "y = Input('y')\n", - "z = Input('z')\n", + "x = Input(\"x\")\n", + "y = Input(\"y\")\n", + "z = Input(\"z\")\n", "\n", - "def myFun(K1,p1,p2):\n", - " return K1*p1*p2\n", "\n", - "K_x = Parameter('k_x', dimensions=1, tw=1)\n", - "c_v = Constant('c_v', tw=1, values=[[1],[2]])\n", - "parfun = ParamFun(myFun, parameters_and_constants = [K_x,c_v])\n", + "def myFun(K1, p1, p2):\n", + " return K1 * p1 * p2\n", "\n", - "out = Output('out', Fir(parfun(x.tw(1)))+Fir(parfun(y.tw(1)))+Fir(parfun(z.tw(1))))\n", "\n", - "result_path = './results'\n", + "K_x = Parameter(\"k_x\", dimensions=1, tw=1)\n", + "c_v = Constant(\"c_v\", tw=1, values=[[1], [2]])\n", + "parfun = ParamFun(myFun, parameters_and_constants=[K_x, c_v])\n", + "\n", + "out = Output(\"out\", Fir(parfun(x.tw(1))) + Fir(parfun(y.tw(1))) + Fir(parfun(z.tw(1))))\n", + "\n", + "result_path = \"./results\"\n", "model = Modely(workspace=result_path)\n", - "model.addModel('model', out)" + "model.addModel(\"model\", out)" ] }, { @@ -163,7 +165,7 @@ } ], "source": [ - "model.saveModel(name='model_definition', model_folder=result_path)" + "model.saveModel(name=\"model_definition\", model_folder=result_path)" ] }, { @@ -244,7 +246,7 @@ ], "source": [ "model.neuralizeModel(0.5)\n", - "model.saveTorchModel(name='model_parameters', model_folder=result_path)" + "model.saveTorchModel(name=\"model_parameters\", model_folder=result_path)" ] }, { @@ -275,7 +277,7 @@ } ], "source": [ - "model.loadTorchModel(name='model_parameters', model_folder=result_path)" + "model.loadTorchModel(name=\"model_parameters\", model_folder=result_path)" ] }, { @@ -311,7 +313,7 @@ } ], "source": [ - "model.exportPythonModel(name='pytorch_model', model_folder=result_path)" + "model.exportPythonModel(name=\"pytorch_model\", model_folder=result_path)" ] }, { @@ -394,7 +396,7 @@ } ], "source": [ - "model.importPythonModel(name='pytorch_model', model_folder=result_path)" + "model.importPythonModel(name=\"pytorch_model\", model_folder=result_path)" ] }, { @@ -485,7 +487,7 @@ ], "source": [ "model.neuralizeModel(0.5)\n", - "model.exportONNX(name='model_onnx', model_folder=result_path)" + "model.exportONNX(name=\"model_onnx\", model_folder=result_path)" ] }, { @@ -522,7 +524,7 @@ } ], "source": [ - "model.exportONNX(inputs_order=['x','y','z'], outputs_order=['out'])" + "model.exportONNX(inputs_order=[\"x\", \"y\", \"z\"], outputs_order=[\"out\"])" ] }, { @@ -558,12 +560,20 @@ "import numpy as np\n", "import os\n", "\n", - "val = np.random.rand(1,2,1).astype(np.float32)\n", + "val = np.random.rand(1, 2, 1).astype(np.float32)\n", "\n", - "data = {'x':val, 'y':val, 'z':val}\n", - "output_onnx = Modely().onnxInference(data, name = 'net', model_folder = os.path.join(result_path, 'onnx'))\n", - "output = model({'x':val.squeeze(-1).tolist()[0], 'y':val.squeeze(-1).tolist()[0], 'z':val.squeeze(-1).tolist()[0]})\n", - "print(f'model out : {output} | onnx out : {output_onnx}')" + "data = {\"x\": val, \"y\": val, \"z\": val}\n", + "output_onnx = Modely().onnxInference(\n", + " data, name=\"net\", model_folder=os.path.join(result_path, \"onnx\")\n", + ")\n", + "output = model(\n", + " {\n", + " \"x\": val.squeeze(-1).tolist()[0],\n", + " \"y\": val.squeeze(-1).tolist()[0],\n", + " \"z\": val.squeeze(-1).tolist()[0],\n", + " }\n", + ")\n", + "print(f\"model out : {output} | onnx out : {output_onnx}\")" ] }, { @@ -596,7 +606,7 @@ } ], "source": [ - "model.exportReport(name='model_report', model_folder=result_path)" + "model.exportReport(name=\"model_report\", model_folder=result_path)" ] }, { @@ -939,38 +949,50 @@ ], "source": [ "clearNames()\n", - "vehicle = nnodely(visualizer=TextVisualizer(), seed=2, workspace='results')\n", + "vehicle = nnodely(visualizer=TextVisualizer(), seed=2, workspace=\"results\")\n", "\n", "# Dimensions of the layers\n", - "n = 25\n", + "n = 25\n", "na = 21\n", "\n", - "#Create neural model inputs\n", - "velocity = Input('vel')\n", - "brake = Input('brk')\n", - "gear = Input('gear')\n", - "torque = Input('trq')\n", - "altitude = Input('alt',dimensions=na)\n", - "acc = Input('acc')\n", + "# Create neural model inputs\n", + "velocity = Input(\"vel\")\n", + "brake = Input(\"brk\")\n", + "gear = Input(\"gear\")\n", + "torque = Input(\"trq\")\n", + "altitude = Input(\"alt\", dimensions=na)\n", + "acc = Input(\"acc\")\n", "\n", "# Create neural network relations\n", - "air_drag_force = Linear(b=True)(velocity.last()**2)\n", - "breaking_force = -Relu(Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})(brake.sw(n)))\n", - "gravity_force = Linear(W_init = 'init_constant', W_init_params={'value':0}, dropout=0.1, W='gravity')(altitude.last())\n", - "fuzzi_gear = Fuzzify(6, range=[2,7], functions='Rectangular')(gear.last())\n", - "local_model = LocalModel(input_function=lambda: Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3}))\n", + "air_drag_force = Linear(b=True)(velocity.last() ** 2)\n", + "breaking_force = -Relu(\n", + " Fir(\n", + " W_init=\"init_negexp\",\n", + " W_init_params={\"size_index\": 0, \"first_value\": 0.002, \"lambda\": 3},\n", + " )(brake.sw(n))\n", + ")\n", + "gravity_force = Linear(\n", + " W_init=\"init_constant\", W_init_params={\"value\": 0}, dropout=0.1, W=\"gravity\"\n", + ")(altitude.last())\n", + "fuzzi_gear = Fuzzify(6, range=[2, 7], functions=\"Rectangular\")(gear.last())\n", + "local_model = LocalModel(\n", + " input_function=lambda: Fir(\n", + " W_init=\"init_negexp\",\n", + " W_init_params={\"size_index\": 0, \"first_value\": 0.002, \"lambda\": 3},\n", + " )\n", + ")\n", "engine_force = local_model(torque.sw(n), fuzzi_gear)\n", "\n", "# Create neural network output\n", - "out = Output('acc_hat', air_drag_force+breaking_force+gravity_force+engine_force)\n", + "out = Output(\"acc_hat\", air_drag_force + breaking_force + gravity_force + engine_force)\n", "\n", "# Add the neural model to the nnodely structure and neuralization of the model\n", - "vehicle.addModel('vehicle',[out])\n", - "vehicle.addMinimize('acc_error', acc.last(), out, loss_function='rmse')\n", + "vehicle.addModel(\"vehicle\", [out])\n", + "vehicle.addMinimize(\"acc_error\", acc.last(), out, loss_function=\"rmse\")\n", "vehicle.neuralizeModel(0.05)\n", "\n", "## Export the Onnx Model\n", - "vehicle.exportONNX(['vel','brk','gear','trq','alt'],['acc_hat'],models='vehicle')" + "vehicle.exportONNX([\"vel\", \"brk\", \"gear\", \"trq\", \"alt\"], [\"acc_hat\"], models=\"vehicle\")" ] }, { @@ -1328,44 +1350,62 @@ ], "source": [ "clearNames()\n", - "vehicle = nnodely(visualizer=MPLVisualizer(),seed=2, workspace=os.path.join(os.getcwd(), 'results'))\n", + "vehicle = nnodely(\n", + " visualizer=MPLVisualizer(), seed=2, workspace=os.path.join(os.getcwd(), \"results\")\n", + ")\n", "# Dimensions of the layers\n", - "n = 25\n", + "n = 25\n", "na = 21\n", "\n", - "#Create neural model inputs\n", - "velocity = Input('vel')\n", - "brake = Input('brk')\n", - "gear = Input('gear')\n", - "torque = Input('trq')\n", - "altitude = Input('alt',dimensions=na)\n", - "acc = Input('acc')\n", + "# Create neural model inputs\n", + "velocity = Input(\"vel\")\n", + "brake = Input(\"brk\")\n", + "gear = Input(\"gear\")\n", + "torque = Input(\"trq\")\n", + "altitude = Input(\"alt\", dimensions=na)\n", + "acc = Input(\"acc\")\n", "\n", "# Create neural network relations\n", - "air_drag_force = Linear(b=True)(velocity.last()**2)\n", - "breaking_force = -Relu(Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})(brake.sw(n)))\n", - "gravity_force = Linear(W_init = 'init_constant', W_init_params={'value':0}, dropout=0.1, W='gravity')(altitude.last())\n", - "fuzzi_gear = Fuzzify(6, range=[2,7], functions='Rectangular')(gear.last())\n", - "local_model = LocalModel(input_function=lambda: Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3}))\n", + "air_drag_force = Linear(b=True)(velocity.last() ** 2)\n", + "breaking_force = -Relu(\n", + " Fir(\n", + " W_init=\"init_negexp\",\n", + " W_init_params={\"size_index\": 0, \"first_value\": 0.002, \"lambda\": 3},\n", + " )(brake.sw(n))\n", + ")\n", + "gravity_force = Linear(\n", + " W_init=\"init_constant\", W_init_params={\"value\": 0}, dropout=0.1, W=\"gravity\"\n", + ")(altitude.last())\n", + "fuzzi_gear = Fuzzify(6, range=[2, 7], functions=\"Rectangular\")(gear.last())\n", + "local_model = LocalModel(\n", + " input_function=lambda: Fir(\n", + " W_init=\"init_negexp\",\n", + " W_init_params={\"size_index\": 0, \"first_value\": 0.002, \"lambda\": 3},\n", + " )\n", + ")\n", "engine_force = local_model(torque.sw(n), fuzzi_gear)\n", "\n", - "acc_hat = air_drag_force+breaking_force+gravity_force+engine_force\n", - "vel_hat = acc_hat.s(-1,int_name='vel_init')\n", + "acc_hat = air_drag_force + breaking_force + gravity_force + engine_force\n", + "vel_hat = acc_hat.s(-1, int_name=\"vel_init\")\n", "\n", "# Closing the loop\n", "vel_hat.closedLoop(velocity)\n", "\n", "# Create neural network output\n", - "out1 = Output('acc_hat', acc_hat)\n", - "out2 = Output('vel_hat', vel_hat)\n", + "out1 = Output(\"acc_hat\", acc_hat)\n", + "out2 = Output(\"vel_hat\", vel_hat)\n", "\n", "# Add the neural model to the nnodely structure and neuralization of the model\n", - "vehicle.addModel('vehicle',[out1,out2])\n", - "vehicle.addMinimize('acc_error', acc.last(), out1, loss_function='rmse')\n", + "vehicle.addModel(\"vehicle\", [out1, out2])\n", + "vehicle.addMinimize(\"acc_error\", acc.last(), out1, loss_function=\"rmse\")\n", "vehicle.neuralizeModel(0.05)\n", "\n", "## Export the Onnx Model\n", - "vehicle.exportONNX(['brk','gear','trq','alt','vel','vel_init'],['acc_hat','vel_hat'],models='vehicle')" + "vehicle.exportONNX(\n", + " [\"brk\", \"gear\", \"trq\", \"alt\", \"vel\", \"vel_init\"],\n", + " [\"acc_hat\", \"vel_hat\"],\n", + " models=\"vehicle\",\n", + ")" ] }, { @@ -1388,11 +1428,27 @@ ], "source": [ "## Make inference using the onnx model\n", - "data = {'vel_init':np.random.rand(1,1,1).astype(np.float32),'vel':np.random.rand(1,1,1).astype(np.float32), 'brk':np.random.rand(1,1,25,1).astype(np.float32), 'gear':np.random.rand(1,1,1,1).astype(np.float32), 'trq':np.random.rand(1,1,25,1).astype(np.float32), 'alt':np.random.rand(1,1,1,21).astype(np.float32)}\n", - "output_onnx = Modely().onnxInference(data,'net_vehicle','results/onnx')\n", + "data = {\n", + " \"vel_init\": np.random.rand(1, 1, 1).astype(np.float32),\n", + " \"vel\": np.random.rand(1, 1, 1).astype(np.float32),\n", + " \"brk\": np.random.rand(1, 1, 25, 1).astype(np.float32),\n", + " \"gear\": np.random.rand(1, 1, 1, 1).astype(np.float32),\n", + " \"trq\": np.random.rand(1, 1, 25, 1).astype(np.float32),\n", + " \"alt\": np.random.rand(1, 1, 1, 21).astype(np.float32),\n", + "}\n", + "output_onnx = Modely().onnxInference(data, \"net_vehicle\", \"results/onnx\")\n", "\n", - "output = vehicle({'vel_init':data['vel_init'].squeeze(-1).tolist()[0], 'vel':data['vel'].squeeze(-1).tolist()[0], 'brk':data['brk'].squeeze(-1).tolist()[0][0], 'gear':data['gear'].squeeze(-1).tolist()[0], 'trq':data['trq'].squeeze(-1).tolist()[0][0], 'alt':data['alt'].squeeze(1).tolist()[0]})\n", - "print(f'model out : {output} | onnx out : {output_onnx}')" + "output = vehicle(\n", + " {\n", + " \"vel_init\": data[\"vel_init\"].squeeze(-1).tolist()[0],\n", + " \"vel\": data[\"vel\"].squeeze(-1).tolist()[0],\n", + " \"brk\": data[\"brk\"].squeeze(-1).tolist()[0][0],\n", + " \"gear\": data[\"gear\"].squeeze(-1).tolist()[0],\n", + " \"trq\": data[\"trq\"].squeeze(-1).tolist()[0][0],\n", + " \"alt\": data[\"alt\"].squeeze(1).tolist()[0],\n", + " }\n", + ")\n", + "print(f\"model out : {output} | onnx out : {output_onnx}\")" ] } ], diff --git a/docs/_autodoc/tutorials/examples/fir.ipynb b/docs/_autodoc/tutorials/examples/fir.ipynb index b832c001..0b2397e6 100644 --- a/docs/_autodoc/tutorials/examples/fir.ipynb +++ b/docs/_autodoc/tutorials/examples/fir.ipynb @@ -74,11 +74,11 @@ "metadata": {}, "outputs": [], "source": [ - "input = Input('x')\n", + "input = Input(\"x\")\n", "fir_layer = Fir(b=True)\n", - "output = Output('out', fir_layer(input.tw(0.05)))\n", + "output = Output(\"out\", fir_layer(input.tw(0.05)))\n", "# Inplace creation with default initialization\n", - "output = Output('out2', Fir(input.tw(0.05)))" + "output = Output(\"out2\", Fir(input.tw(0.05)))" ] }, { @@ -105,9 +105,9 @@ } ], "source": [ - "input = Input('x')\n", - "fir_layer = Fir(b='b', W='w')\n", - "output = Output('out', fir_layer(input.tw(0.05)))" + "input = Input(\"x\")\n", + "fir_layer = Fir(b=\"b\", W=\"w\")\n", + "output = Output(\"out\", fir_layer(input.tw(0.05)))" ] }, { @@ -136,13 +136,13 @@ } ], "source": [ - "input = Input('x')\n", + "input = Input(\"x\")\n", "\n", - "weight = Parameter('w', dimensions=3, sw=2, init='init_constant')\n", - "bias = Parameter('b', dimensions=3, init='init_constant')\n", + "weight = Parameter(\"w\", dimensions=3, sw=2, init=\"init_constant\")\n", + "bias = Parameter(\"b\", dimensions=3, init=\"init_constant\")\n", "\n", "fir_layer = Fir(W=weight, b=bias)(input.sw(2))\n", - "output = Output('out', fir_layer)" + "output = Output(\"out\", fir_layer)" ] }, { @@ -173,13 +173,18 @@ } ], "source": [ - "x = Input('x')\n", - "F = Input('F')\n", - "\n", - "fir_x = Fir(W_init=init_negexp, b_init=init_exp)(x.tw(0.2)) \n", - "fir_F = Fir(W_init=init_constant, W_init_params={'value':1}, b_init=init_constant, b_init_params={'value':0})(F.last())\n", - "\n", - "output = Output('out', fir_x + fir_F)" + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", + "\n", + "fir_x = Fir(W_init=init_negexp, b_init=init_exp)(x.tw(0.2))\n", + "fir_F = Fir(\n", + " W_init=init_constant,\n", + " W_init_params={\"value\": 1},\n", + " b_init=init_constant,\n", + " b_init_params={\"value\": 0},\n", + ")(F.last())\n", + "\n", + "output = Output(\"out\", fir_x + fir_F)" ] }, { @@ -207,12 +212,12 @@ } ], "source": [ - "input = Input('x')\n", + "input = Input(\"x\")\n", "\n", - "weight = Parameter('w', dimensions=3, sw=2, init=init_constant)\n", + "weight = Parameter(\"w\", dimensions=3, sw=2, init=init_constant)\n", "\n", "fir_layer = Fir(W=weight, b=False, dropout=0.2)(input.sw(2))\n", - "output = Output('out', fir_layer)" + "output = Output(\"out\", fir_layer)" ] } ], diff --git a/docs/_autodoc/tutorials/examples/fuzzify.ipynb b/docs/_autodoc/tutorials/examples/fuzzify.ipynb index 0b9fa8e8..70702921 100644 --- a/docs/_autodoc/tutorials/examples/fuzzify.ipynb +++ b/docs/_autodoc/tutorials/examples/fuzzify.ipynb @@ -95,14 +95,14 @@ } ], "source": [ - "x = Input('x')\n", - "fuz = Fuzzify(5,[1,5])\n", - "out = Output('out',fuz(x.last()))\n", + "x = Input(\"x\")\n", + "fuz = Fuzzify(5, [1, 5])\n", + "out = Output(\"out\", fuz(x.last()))\n", "\n", "example = Modely(visualizer=MPLNotebookVisualizer())\n", - "example.addModel('model',out)\n", + "example.addModel(\"model\", out)\n", "example.neuralizeModel()\n", - "example.visualizer.showFunctions(list(example._model_def['Functions'].keys()))" + "example.visualizer.showFunctions(list(example._model_def[\"Functions\"].keys()))" ] }, { @@ -159,14 +159,14 @@ } ], "source": [ - "x = Input('x')\n", - "fuz = Fuzzify(6,[1,6], functions = 'Rectangular')\n", - "out = Output('out',fuz(x.last()))\n", + "x = Input(\"x\")\n", + "fuz = Fuzzify(6, [1, 6], functions=\"Rectangular\")\n", + "out = Output(\"out\", fuz(x.last()))\n", "\n", "example = Modely(visualizer=MPLNotebookVisualizer())\n", - "example.addModel('model',out)\n", + "example.addModel(\"model\", out)\n", "example.neuralizeModel()\n", - "example.visualizer.showFunctions(list(example._model_def['Functions'].keys()))" + "example.visualizer.showFunctions(list(example._model_def[\"Functions\"].keys()))" ] }, { @@ -235,16 +235,18 @@ "source": [ "def fun(x):\n", " import torch\n", + "\n", " return torch.tanh(x)\n", "\n", - "x = Input('x')\n", - "fuz = Fuzzify(output_dimension=11, range=[-5,5], functions=fun)\n", - "out = Output('out',fuz(x.last()))\n", + "\n", + "x = Input(\"x\")\n", + "fuz = Fuzzify(output_dimension=11, range=[-5, 5], functions=fun)\n", + "out = Output(\"out\", fuz(x.last()))\n", "\n", "example = Modely(visualizer=MPLNotebookVisualizer())\n", - "example.addModel('model',out)\n", + "example.addModel(\"model\", out)\n", "example.neuralizeModel()\n", - "example.visualizer.showFunctions(list(example._model_def['Functions'].keys()))" + "example.visualizer.showFunctions(list(example._model_def[\"Functions\"].keys()))" ] }, { @@ -306,20 +308,24 @@ "source": [ "def fun1(x):\n", " import torch\n", + "\n", " return torch.sin(x)\n", "\n", + "\n", "def fun2(x):\n", " import torch\n", + "\n", " return torch.cos(x)\n", "\n", - "x = Input('x')\n", - "fuz = Fuzzify(2,range=[-1,5],functions=[fun1,fun2])\n", - "out = Output('out',fuz(x.last()))\n", + "\n", + "x = Input(\"x\")\n", + "fuz = Fuzzify(2, range=[-1, 5], functions=[fun1, fun2])\n", + "out = Output(\"out\", fuz(x.last()))\n", "\n", "example = Modely(visualizer=MPLNotebookVisualizer())\n", - "example.addModel('model',out)\n", + "example.addModel(\"model\", out)\n", "example.neuralizeModel()\n", - "example.visualizer.showFunctions(list(example._model_def['Functions'].keys()))" + "example.visualizer.showFunctions(list(example._model_def[\"Functions\"].keys()))" ] }, { @@ -386,21 +392,25 @@ "source": [ "import torch\n", "\n", + "\n", "def fun1(x):\n", " return torch.sin(x)\n", + "\n", + "\n", "def fun2(x):\n", " return torch.cos(x)\n", "\n", - "x = Input('x')\n", - "F = Input('F')\n", "\n", - "fuz = Fuzzify(centers=[-1,0,3,5],functions=[fun1,fun2,fun1,fun2])\n", - "out = Output('out',fuz(x.last())+fuz(F.last()))\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", + "\n", + "fuz = Fuzzify(centers=[-1, 0, 3, 5], functions=[fun1, fun2, fun1, fun2])\n", + "out = Output(\"out\", fuz(x.last()) + fuz(F.last()))\n", "\n", "example = Modely(visualizer=MPLNotebookVisualizer())\n", - "example.addModel('model',out)\n", + "example.addModel(\"model\", out)\n", "example.neuralizeModel()\n", - "example.visualizer.showFunctions(list(example._model_def['Functions'].keys()))" + "example.visualizer.showFunctions(list(example._model_def[\"Functions\"].keys()))" ] } ], diff --git a/docs/_autodoc/tutorials/examples/inference.ipynb b/docs/_autodoc/tutorials/examples/inference.ipynb index 0c7395e5..4f21d720 100644 --- a/docs/_autodoc/tutorials/examples/inference.ipynb +++ b/docs/_autodoc/tutorials/examples/inference.ipynb @@ -98,15 +98,15 @@ ], "source": [ "## Model definition\n", - "x = Input('x')\n", - "F = Input('F')\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "\n", - "next_x = Fir()(x.tw(0.5))+Fir()(F.last())\n", + "next_x = Fir()(x.tw(0.5)) + Fir()(F.last())\n", "\n", - "out = Output('next_x', next_x)\n", + "out = Output(\"next_x\", next_x)\n", "\n", "model = Modely()\n", - "model.addModel('model',[out])\n", + "model.addModel(\"model\", [out])\n", "model.neuralizeModel(0.05)" ] }, @@ -125,7 +125,9 @@ ], "source": [ "## Inference\n", - "results = model(inputs={'F':[[9]],'x':[[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11]]})\n", + "results = model(\n", + " inputs={\"F\": [[9]], \"x\": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]]}\n", + ")\n", "print(results)" ] }, @@ -143,7 +145,12 @@ } ], "source": [ - "results = model(inputs={'F':[[5],[4],[9]],'x':[[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13]]})\n", + "results = model(\n", + " inputs={\n", + " \"F\": [[5], [4], [9]],\n", + " \"x\": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13]],\n", + " }\n", + ")\n", "print(results)" ] }, @@ -170,7 +177,16 @@ } ], "source": [ - "results = model(inputs={'F':[[5],[2]],'x':[[1,2,3,4,5,6,7,8,9,10],[12,13,14,15,16,17,18,19,20,21]]}, sampled=True)\n", + "results = model(\n", + " inputs={\n", + " \"F\": [[5], [2]],\n", + " \"x\": [\n", + " [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n", + " [12, 13, 14, 15, 16, 17, 18, 19, 20, 21],\n", + " ],\n", + " },\n", + " sampled=True,\n", + ")\n", "print(results)" ] }, @@ -215,15 +231,15 @@ } ], "source": [ - "input1 = Input('in1')\n", - "W = Parameter('W', sw=3, values=[[1], [2], [3]])\n", - "out = Output('out',Fir(W=W)(input1.sw(3)))\n", + "input1 = Input(\"in1\")\n", + "W = Parameter(\"W\", sw=3, values=[[1], [2], [3]])\n", + "out = Output(\"out\", Fir(W=W)(input1.sw(3)))\n", "\n", "model = Modely(visualizer=TextVisualizer(), seed=42)\n", - "model.addModel('model', [out])\n", + "model.addModel(\"model\", [out])\n", "model.neuralizeModel()\n", "\n", - "result = model({'in1': [1, 2, 3]}, closed_loop={'in1':'out'})\n", + "result = model({\"in1\": [1, 2, 3]}, closed_loop={\"in1\": \"out\"})\n", "print(result)" ] }, @@ -277,14 +293,14 @@ } ], "source": [ - "input2 = Input('in2')\n", - "K = Parameter('K', sw=3, values=[[1], [2], [3]])\n", - "out2 = Output('out2',Fir(W=K)(input2.sw(3)))\n", + "input2 = Input(\"in2\")\n", + "K = Parameter(\"K\", sw=3, values=[[1], [2], [3]])\n", + "out2 = Output(\"out2\", Fir(W=K)(input2.sw(3)))\n", "\n", - "model.addModel('model2', [out2])\n", + "model.addModel(\"model2\", [out2])\n", "model.neuralizeModel()\n", "\n", - "result = model(inputs={'in1': [1, 2, 3]}, connect={'in2':'out'})\n", + "result = model(inputs={\"in1\": [1, 2, 3]}, connect={\"in2\": \"out\"})\n", "print(result)" ] }, @@ -313,7 +329,9 @@ } ], "source": [ - "result = model({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=3)\n", + "result = model(\n", + " {\"in1\": [1, 2, 3, 4, 5]}, closed_loop={\"in1\": \"out\"}, prediction_samples=3\n", + ")\n", "print(result)" ] }, @@ -342,7 +360,12 @@ } ], "source": [ - "result = model({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=3, num_of_samples = 5)\n", + "result = model(\n", + " {\"in1\": [1, 2, 3, 4, 5]},\n", + " closed_loop={\"in1\": \"out\"},\n", + " prediction_samples=3,\n", + " num_of_samples=5,\n", + ")\n", "print(result)" ] } diff --git a/docs/_autodoc/tutorials/examples/interpolation.ipynb b/docs/_autodoc/tutorials/examples/interpolation.ipynb index 7a015245..b365bffc 100644 --- a/docs/_autodoc/tutorials/examples/interpolation.ipynb +++ b/docs/_autodoc/tutorials/examples/interpolation.ipynb @@ -46,9 +46,11 @@ "metadata": {}, "outputs": [], "source": [ - "x = Input('x')\n", - "interpolation = Interpolation(x_points=[1.0, 2.0, 3.0, 4.0],y_points=[1.0, 4.0, 9.0, 16.0])(x.last())\n", - "out = Output('out',interpolation)" + "x = Input(\"x\")\n", + "interpolation = Interpolation(\n", + " x_points=[1.0, 2.0, 3.0, 4.0], y_points=[1.0, 4.0, 9.0, 16.0]\n", + ")(x.last())\n", + "out = Output(\"out\", interpolation)" ] }, { @@ -76,9 +78,11 @@ } ], "source": [ - "y = Input('y')\n", - "interpolation = Interpolation(x_points=[1.0, 4.0, 3.0, 2.0],y_points=[1.0, 16.0, 9.0, 4.0], mode='linear')(y.last())\n", - "out = Output('out',interpolation)" + "y = Input(\"y\")\n", + "interpolation = Interpolation(\n", + " x_points=[1.0, 4.0, 3.0, 2.0], y_points=[1.0, 16.0, 9.0, 4.0], mode=\"linear\"\n", + ")(y.last())\n", + "out = Output(\"out\", interpolation)" ] } ], diff --git a/docs/_autodoc/tutorials/examples/linear.ipynb b/docs/_autodoc/tutorials/examples/linear.ipynb index 065ba3e0..45f5c44d 100644 --- a/docs/_autodoc/tutorials/examples/linear.ipynb +++ b/docs/_autodoc/tutorials/examples/linear.ipynb @@ -69,7 +69,7 @@ "metadata": {}, "outputs": [], "source": [ - "x = Input('x').tw(0.05)\n", + "x = Input(\"x\").tw(0.05)\n", "linear = Linear(output_dimension=5)(x)" ] }, @@ -96,10 +96,10 @@ } ], "source": [ - "x = Input('x').last()\n", + "x = Input(\"x\").last()\n", "\n", - "weight = Parameter('W', values=[[1]])\n", - "bias = Parameter('b', values=[1])\n", + "weight = Parameter(\"W\", values=[[1]])\n", + "bias = Parameter(\"b\", values=[1])\n", "\n", "linear = Linear(W=weight, b=bias)(x)" ] @@ -131,8 +131,14 @@ } ], "source": [ - "x = Input('x').last()\n", - "linear = Linear(output_dimension=5, b=True, W_init=init_negexp, b_init=init_constant, b_init_params={'value':1})(x)" + "x = Input(\"x\").last()\n", + "linear = Linear(\n", + " output_dimension=5,\n", + " b=True,\n", + " W_init=init_negexp,\n", + " b_init=init_constant,\n", + " b_init_params={\"value\": 1},\n", + ")(x)" ] }, { @@ -158,9 +164,9 @@ } ], "source": [ - "input = Input('x')\n", + "input = Input(\"x\")\n", "linear = Linear(output_dimension=10, dropout=0.2)(input.sw(2))\n", - "output = Output('out', linear)" + "output = Output(\"out\", linear)" ] } ], diff --git a/docs/_autodoc/tutorials/examples/localmodel.ipynb b/docs/_autodoc/tutorials/examples/localmodel.ipynb index b62da3e0..9e6f94a5 100644 --- a/docs/_autodoc/tutorials/examples/localmodel.ipynb +++ b/docs/_autodoc/tutorials/examples/localmodel.ipynb @@ -59,11 +59,11 @@ "metadata": {}, "outputs": [], "source": [ - "c = Input('c')\n", - "x = Input('x')\n", - "activation = Fuzzify(2,[0,1],functions='Triangular')(c.last())\n", + "c = Input(\"c\")\n", + "x = Input(\"x\")\n", + "activation = Fuzzify(2, [0, 1], functions=\"Triangular\")(c.last())\n", "loc = LocalModel(input_function=Fir())\n", - "out = Output('out', loc(x.tw(1), activation))" + "out = Output(\"out\", loc(x.tw(1), activation))" ] }, { @@ -93,11 +93,13 @@ } ], "source": [ - "c = Input('c')\n", - "x = Input('x')\n", - "activation = Fuzzify(2,[0,1],functions='Triangular')(c.last())\n", - "loc = LocalModel(input_function = lambda:Fir, output_function = lambda:Fir)(x.last(), activation)\n", - "out = Output('out', loc)" + "c = Input(\"c\")\n", + "x = Input(\"x\")\n", + "activation = Fuzzify(2, [0, 1], functions=\"Triangular\")(c.last())\n", + "loc = LocalModel(input_function=lambda: Fir, output_function=lambda: Fir)(\n", + " x.last(), activation\n", + ")\n", + "out = Output(\"out\", loc)" ] }, { @@ -125,14 +127,17 @@ } ], "source": [ - "def myFun(in1,p1,p2):\n", - " return p1*in1+p2\n", + "def myFun(in1, p1, p2):\n", + " return p1 * in1 + p2\n", "\n", - "c = Input('c')\n", - "x = Input('x')\n", - "activation = Fuzzify(2,[0,1],functions='Triangular')(c.last())\n", - "loc = LocalModel(input_function = lambda:ParamFun(myFun), output_function = lambda:Fir)(x.last(), activation)\n", - "out = Output('out', loc)" + "\n", + "c = Input(\"c\")\n", + "x = Input(\"x\")\n", + "activation = Fuzzify(2, [0, 1], functions=\"Triangular\")(c.last())\n", + "loc = LocalModel(input_function=lambda: ParamFun(myFun), output_function=lambda: Fir)(\n", + " x.last(), activation\n", + ")\n", + "out = Output(\"out\", loc)" ] }, { @@ -160,17 +165,21 @@ } ], "source": [ - "c = Input('c')\n", - "d = Input('d')\n", - "activationA = Fuzzify(2,[0,1],functions='Triangular')(c.tw(1))\n", - "activationB = Fuzzify(2,[0,1],functions='Triangular')(d.tw(1))\n", + "c = Input(\"c\")\n", + "d = Input(\"d\")\n", + "activationA = Fuzzify(2, [0, 1], functions=\"Triangular\")(c.tw(1))\n", + "activationB = Fuzzify(2, [0, 1], functions=\"Triangular\")(d.tw(1))\n", + "\n", "\n", - "def myFun(in1,p1,p2):\n", - " return p1*in1+p2\n", + "def myFun(in1, p1, p2):\n", + " return p1 * in1 + p2\n", "\n", - "x = Input('x')\n", - "loc = LocalModel(input_function = lambda:ParamFun(myFun), output_function = Fir(3))(x.tw(1),(activationA,activationB))\n", - "out = Output('out', loc)" + "\n", + "x = Input(\"x\")\n", + "loc = LocalModel(input_function=lambda: ParamFun(myFun), output_function=Fir(3))(\n", + " x.tw(1), (activationA, activationB)\n", + ")\n", + "out = Output(\"out\", loc)" ] }, { @@ -203,32 +212,45 @@ } ], "source": [ - "c = Input('c')\n", - "d = Input('d')\n", - "activationA = Fuzzify(2,[0,1],functions='Triangular')(c.tw(1))\n", - "activationB = Fuzzify(2,[0,1],functions='Triangular')(d.tw(1))\n", + "c = Input(\"c\")\n", + "d = Input(\"d\")\n", + "activationA = Fuzzify(2, [0, 1], functions=\"Triangular\")(c.tw(1))\n", + "activationB = Fuzzify(2, [0, 1], functions=\"Triangular\")(d.tw(1))\n", + "\n", + "\n", + "def myFun(in1, p1, p2):\n", + " return p1 * in1 + p2\n", "\n", - "def myFun(in1,p1,p2):\n", - " return p1*in1+p2\n", "\n", "def input_function_gen(idx_list):\n", - " if idx_list == [0,0]:\n", - " p1, p2 = Parameter('p1_0',values=[[1]]), Parameter('p2_0',values=[[2]])\n", - " if idx_list == [0,1]:\n", - " p1, p2 = Parameter('p1_0',values=[[1]]), Parameter('p2_1',values=[[3]])\n", - " if idx_list == [1,0]:\n", - " p1, p2 = Parameter('p1_1',values=[[2]]), Parameter('p2_0',values=[[2]])\n", + " if idx_list == [0, 0]:\n", + " p1, p2 = Parameter(\"p1_0\", values=[[1]]), Parameter(\"p2_0\", values=[[2]])\n", + " if idx_list == [0, 1]:\n", + " p1, p2 = Parameter(\"p1_0\", values=[[1]]), Parameter(\"p2_1\", values=[[3]])\n", + " if idx_list == [1, 0]:\n", + " p1, p2 = Parameter(\"p1_1\", values=[[2]]), Parameter(\"p2_0\", values=[[2]])\n", " if idx_list == [1, 1]:\n", - " p1, p2 = Parameter('p1_1',values=[[2]]), Parameter('p2_1',values=[[3]])\n", - " return ParamFun(myFun,parameters_and_constants=[p1,p2])\n", + " p1, p2 = Parameter(\"p1_1\", values=[[2]]), Parameter(\"p2_1\", values=[[3]])\n", + " return ParamFun(myFun, parameters_and_constants=[p1, p2])\n", + "\n", "\n", "def output_function_gen(idx_list):\n", - " pfir = Parameter('pfir_'+str(idx_list),tw=1,dimensions=2,values=[[1+idx_list[0],2+idx_list[1]],[3+idx_list[0],4+idx_list[1]]])\n", - " return Fir(2,W=pfir)\n", + " pfir = Parameter(\n", + " \"pfir_\" + str(idx_list),\n", + " tw=1,\n", + " dimensions=2,\n", + " values=[[1 + idx_list[0], 2 + idx_list[1]], [3 + idx_list[0], 4 + idx_list[1]]],\n", + " )\n", + " return Fir(2, W=pfir)\n", + "\n", "\n", - "x = Input('x')\n", - "loc = LocalModel(input_function=input_function_gen, output_function= output_function_gen, pass_indexes = True)(x.tw(1),(activationA,activationB))\n", - "out = Output('out', loc)" + "x = Input(\"x\")\n", + "loc = LocalModel(\n", + " input_function=input_function_gen,\n", + " output_function=output_function_gen,\n", + " pass_indexes=True,\n", + ")(x.tw(1), (activationA, activationB))\n", + "out = Output(\"out\", loc)" ] } ], diff --git a/docs/_autodoc/tutorials/examples/parameter.ipynb b/docs/_autodoc/tutorials/examples/parameter.ipynb index 32f3ed14..ee3c001d 100644 --- a/docs/_autodoc/tutorials/examples/parameter.ipynb +++ b/docs/_autodoc/tutorials/examples/parameter.ipynb @@ -73,8 +73,8 @@ }, "outputs": [], "source": [ - "g = Constant('g', values=[9.81])\n", - "k = Parameter('k', tw=4)" + "g = Constant(\"g\", values=[9.81])\n", + "k = Parameter(\"k\", tw=4)" ] }, { @@ -107,14 +107,14 @@ } ], "source": [ - "x = Input('x')\n", + "x = Input(\"x\")\n", "\n", - "k = Parameter('k', dimensions=3, tw=4)\n", + "k = Parameter(\"k\", dimensions=3, tw=4)\n", "\n", "fir1 = Fir(W=k)\n", "fir2 = Fir(3, W=k)\n", "\n", - "out = Output('out', fir1(x.tw(4))+fir2(x.tw(4)))" + "out = Output(\"out\", fir1(x.tw(4)) + fir2(x.tw(4)))" ] }, { @@ -147,17 +147,19 @@ } ], "source": [ - "x= Input('x')\n", + "x = Input(\"x\")\n", + "\n", + "g = Parameter(\"g\", dimensions=3, values=[[4, 5, 6]])\n", + "t = Parameter(\"t\", dimensions=3, values=[[1, 2, 3]])\n", "\n", - "g = Parameter('g', dimensions=3, values=[[4,5,6]])\n", - "t = Parameter('t', dimensions=3, values=[[1,2,3]])\n", "\n", "def fun(x, k, t):\n", - " return x+(k+t)\n", + " return x + (k + t)\n", + "\n", "\n", - "p = ParamFun(fun, parameters_and_constants=[g,t])\n", + "p = ParamFun(fun, parameters_and_constants=[g, t])\n", "\n", - "out = Output('out', p(x.tw(1)))" + "out = Output(\"out\", p(x.tw(1)))" ] }, { @@ -190,10 +192,10 @@ } ], "source": [ - "g = Parameter('g', sw=1, values=[[1,2,3,4]])\n", - "o = Constant('o', sw=1, values=[[1,2,3,4]])\n", - "x = Input('x', dimensions=4)\n", - "out = Output('out', x.last()+g+o)" + "g = Parameter(\"g\", sw=1, values=[[1, 2, 3, 4]])\n", + "o = Constant(\"o\", sw=1, values=[[1, 2, 3, 4]])\n", + "x = Input(\"x\", dimensions=4)\n", + "out = Output(\"out\", x.last() + g + o)" ] }, { @@ -226,8 +228,8 @@ ], "source": [ "dt = SampleTime()\n", - "x = Input('x')\n", - "out = Output('out', x.last() + dt)" + "x = Input(\"x\")\n", + "out = Output(\"out\", x.last() + dt)" ] }, { @@ -250,7 +252,7 @@ }, "outputs": [], "source": [ - "p = Parameter('p', dimensions=4, init=init_constant, init_params={'value':4})" + "p = Parameter(\"p\", dimensions=4, init=init_constant, init_params={\"value\": 4})" ] } ], diff --git a/docs/_autodoc/tutorials/examples/parametric_functions.ipynb b/docs/_autodoc/tutorials/examples/parametric_functions.ipynb index 0ba8e250..aeeecda1 100644 --- a/docs/_autodoc/tutorials/examples/parametric_functions.ipynb +++ b/docs/_autodoc/tutorials/examples/parametric_functions.ipynb @@ -59,15 +59,17 @@ "metadata": {}, "outputs": [], "source": [ - "def myFun(K1,K2,p1,p2):\n", + "def myFun(K1, K2, p1, p2):\n", " import torch\n", - " return p1*K1+p2*torch.sin(K2)\n", "\n", - "x = Input('x')\n", - "F = Input('F')\n", + " return p1 * K1 + p2 * torch.sin(K2)\n", + "\n", + "\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", "\n", "parfun = ParamFun(myFun)\n", - "out = Output('out',parfun(x.last(),F.last()))" + "out = Output(\"out\", parfun(x.last(), F.last()))" ] }, { @@ -94,14 +96,16 @@ } ], "source": [ - "def myFun(K1,K2,p1):\n", + "def myFun(K1, K2, p1):\n", " import torch\n", - " return torch.stack([K1,2*K1,3*K1,4*K1],dim=2).squeeze(-1)*p1+K2\n", "\n", - "x=Input('x')\n", - "F=Input('F')\n", - "parfun = ParamFun(myFun, parameters_and_constants = {'p1':(1,4)})\n", - "out = Output('out',parfun(x.last(),F.last()))" + " return torch.stack([K1, 2 * K1, 3 * K1, 4 * K1], dim=2).squeeze(-1) * p1 + K2\n", + "\n", + "\n", + "x = Input(\"x\")\n", + "F = Input(\"F\")\n", + "parfun = ParamFun(myFun, parameters_and_constants={\"p1\": (1, 4)})\n", + "out = Output(\"out\", parfun(x.last(), F.last()))" ] }, { @@ -128,13 +132,14 @@ } ], "source": [ - "def myFun(K1,p1):\n", - " return K1*p1\n", + "def myFun(K1, p1):\n", + " return K1 * p1\n", "\n", - "x = Input('x')\n", - "K = Parameter('k', dimensions = 1, sw = 1,values=[[2.0]])\n", + "\n", + "x = Input(\"x\")\n", + "K = Parameter(\"k\", dimensions=1, sw=1, values=[[2.0]])\n", "parfun = ParamFun(myFun, parameters_and_constants=[K])\n", - "out = Output('out',parfun(x.sw(1)))" + "out = Output(\"out\", parfun(x.sw(1)))" ] }, { @@ -161,15 +166,16 @@ } ], "source": [ - "def myFun(K1,p1):\n", - " return K1*p1\n", + "def myFun(K1, p1):\n", + " return K1 * p1\n", + "\n", "\n", - "K = Parameter('k1', dimensions = 1, tw = 1, values=[[2.0],[3.0],[4.0],[5.0]])\n", - "R = Parameter('r1', dimensions = 1, tw = 1, values=[[5.0],[4.0],[3.0],[2.0]])\n", + "K = Parameter(\"k1\", dimensions=1, tw=1, values=[[2.0], [3.0], [4.0], [5.0]])\n", + "R = Parameter(\"r1\", dimensions=1, tw=1, values=[[5.0], [4.0], [3.0], [2.0]])\n", "\n", - "x = Input('x')\n", + "x = Input(\"x\")\n", "parfun = ParamFun(myFun)\n", - "out = Output('out',parfun(x.tw(1),K)+parfun(x.tw(1),R))" + "out = Output(\"out\", parfun(x.tw(1), K) + parfun(x.tw(1), R))" ] }, { @@ -196,13 +202,14 @@ } ], "source": [ - "def myFun(K1,p1):\n", - " return K1*p1\n", + "def myFun(K1, p1):\n", + " return K1 * p1\n", + "\n", "\n", "parfun = ParamFun(myFun)\n", - "x = Input('x')\n", - "c = Constant('c',values=[[5.0],[4.0],[3.0],[2.0]])\n", - "out = Output('out',parfun(x.sw(4),c))" + "x = Input(\"x\")\n", + "c = Constant(\"c\", values=[[5.0], [4.0], [3.0], [2.0]])\n", + "out = Output(\"out\", parfun(x.sw(4), c))" ] }, { @@ -232,13 +239,14 @@ ], "source": [ "def myFun(k, p1):\n", - " print(f'k:{k.shape}')\n", - " print(f'p1:{p1.shape}')\n", + " print(f\"k:{k.shape}\")\n", + " print(f\"p1:{p1.shape}\")\n", " return k * p1\n", "\n", - "x = Input('x')\n", + "\n", + "x = Input(\"x\")\n", "parfun = ParamFun(myFun, map_over_batch=True)\n", - "out = Output('out',parfun(x.sw(4)))" + "out = Output(\"out\", parfun(x.sw(4)))" ] } ], diff --git a/docs/_autodoc/tutorials/examples/partitioning.ipynb b/docs/_autodoc/tutorials/examples/partitioning.ipynb index e3a0708d..c916415b 100644 --- a/docs/_autodoc/tutorials/examples/partitioning.ipynb +++ b/docs/_autodoc/tutorials/examples/partitioning.ipynb @@ -80,13 +80,13 @@ } ], "source": [ - "x = Input('x', dimensions=10).last()\n", + "x = Input(\"x\", dimensions=10).last()\n", "sub = Part(x, 0, 2)\n", - "out = Output('out', sub)\n", + "out = Output(\"out\", sub)\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out])\n", + "test.addModel(\"test\", [out])\n", "test.neuralizeModel()\n", - "test({'x': [[1,2,3,4,5,6,7,8,9,10]]})" + "test({\"x\": [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]})" ] }, { @@ -130,13 +130,13 @@ } ], "source": [ - "x = Input('x', dimensions=3).last()\n", + "x = Input(\"x\", dimensions=3).last()\n", "sub = Select(x, 1)\n", - "out = Output('out', sub)\n", + "out = Output(\"out\", sub)\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out])\n", + "test.addModel(\"test\", [out])\n", "test.neuralizeModel()\n", - "test({'x': [[1,2,3]]})" + "test({\"x\": [[1, 2, 3]]})" ] }, { @@ -180,14 +180,14 @@ } ], "source": [ - "x = Input('x', dimensions=3).last()\n", - "y = Input('y', dimensions=5).last()\n", + "x = Input(\"x\", dimensions=3).last()\n", + "y = Input(\"y\", dimensions=5).last()\n", "cat = Concatenate(x, y)\n", - "out = Output('out', cat)\n", + "out = Output(\"out\", cat)\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out])\n", + "test.addModel(\"test\", [out])\n", "test.neuralizeModel()\n", - "test({'x': [[1,2,3]],'y': [[4,5,6,7,8]]})" + "test({\"x\": [[1, 2, 3]], \"y\": [[4, 5, 6, 7, 8]]})" ] }, { @@ -231,16 +231,16 @@ } ], "source": [ - "x = Input('x')\n", + "x = Input(\"x\")\n", "x_sw10 = x.sw(10)\n", "relation = SamplePart(x_sw10, 0, 3)\n", - "out = Output('out', relation)\n", - "out2 = Output('out2', x.last())\n", + "out = Output(\"out\", relation)\n", + "out2 = Output(\"out2\", x.last())\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out,out2])\n", + "test.addModel(\"test\", [out, out2])\n", "test.neuralizeModel()\n", "# Test 1 input in time\n", - "test({'x': [1,2,3,4,5,6,7,8,9,10]})" + "test({\"x\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})" ] }, { @@ -266,7 +266,7 @@ ], "source": [ "# Test 2 input in time\n", - "test({'x': [1,2,3,4,5,6,7,8,9,10,11]})" + "test({\"x\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]})" ] }, { @@ -310,13 +310,13 @@ } ], "source": [ - "x = Input('x').sw(10)\n", + "x = Input(\"x\").sw(10)\n", "relation = SampleSelect(x, 5)\n", - "out = Output('out', relation)\n", + "out = Output(\"out\", relation)\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out])\n", + "test.addModel(\"test\", [out])\n", "test.neuralizeModel()\n", - "test({'x': [1,2,3,4,5,6,7,8,9,10]})" + "test({\"x\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]})" ] }, { @@ -349,9 +349,9 @@ ], "source": [ "test = Modely(visualizer=None)\n", - "test.addModel('test', [out, Output('out2', relation.sw(2))])\n", + "test.addModel(\"test\", [out, Output(\"out2\", relation.sw(2))])\n", "test.neuralizeModel()\n", - "test({'x': [1,2,3,4,5,6,7,8,9,10,11]})" + "test({\"x\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]})" ] }, { @@ -396,16 +396,16 @@ } ], "source": [ - "x = Input('x').sw(5)\n", - "y = Input('y').sw(3)\n", + "x = Input(\"x\").sw(5)\n", + "y = Input(\"y\").sw(3)\n", "cat = TimeConcatenate(x, y)\n", "cat2 = TimeConcatenate(Fir(x), y)\n", - "out = Output('out', cat)\n", - "out2 = Output('out2', cat2)\n", + "out = Output(\"out\", cat)\n", + "out2 = Output(\"out2\", cat2)\n", "test = Modely(visualizer=None)\n", - "test.addModel('test', [out,out2])\n", + "test.addModel(\"test\", [out, out2])\n", "test.neuralizeModel()\n", - "test({'x': [1,2,3,4,5],'y': [1,2,3]})" + "test({\"x\": [1, 2, 3, 4, 5], \"y\": [1, 2, 3]})" ] } ], diff --git a/docs/_autodoc/tutorials/examples/states.ipynb b/docs/_autodoc/tutorials/examples/states.ipynb index 2087b0ec..5b2f16b0 100644 --- a/docs/_autodoc/tutorials/examples/states.ipynb +++ b/docs/_autodoc/tutorials/examples/states.ipynb @@ -65,8 +65,8 @@ }, "outputs": [], "source": [ - "clearNames('x_state')\n", - "x_state = Input('x_state', dimensions=1)\n", + "clearNames(\"x_state\")\n", + "x_state = Input(\"x_state\", dimensions=1)\n", "x_out = Fir(x_state.tw(0.5))" ] }, @@ -90,9 +90,9 @@ }, "outputs": [], "source": [ - "clearNames('out')\n", + "clearNames(\"out\")\n", "x_out.closedLoop(x_state)\n", - "out = Output('out',x_out)" + "out = Output(\"out\", x_out)" ] }, { @@ -113,9 +113,9 @@ }, "outputs": [], "source": [ - "clearNames('out')\n", + "clearNames(\"out\")\n", "x_out = ClosedLoop(x_out, x_state)\n", - "out = Output('out',x_out)" + "out = Output(\"out\", x_out)" ] }, { @@ -143,7 +143,7 @@ "clearNames()\n", "x_out = Fir(x_state.tw(0.5))\n", "x_out.connect(x_state)\n", - "out = Output('out',x_out)" + "out = Output(\"out\", x_out)" ] }, { @@ -164,9 +164,9 @@ }, "outputs": [], "source": [ - "clearNames('out')\n", + "clearNames(\"out\")\n", "x_out = Connect(x_out, x_state)\n", - "out = Output('out',x_out)" + "out = Output(\"out\", x_out)" ] }, { @@ -366,52 +366,64 @@ } ], "source": [ - "clearNames(['a','b_t','c','d_t','b_in','shared','b','A','B','C','D','d'])\n", + "clearNames([\"a\", \"b_t\", \"c\", \"d_t\", \"b_in\", \"shared\", \"b\", \"A\", \"B\", \"C\", \"D\", \"d\"])\n", "import numpy as np\n", "\n", + "\n", "def linear_function(x, k1, k2):\n", - " return x*k1 + k2\n", + " return x * k1 + k2\n", + "\n", "\n", - "data_a = np.arange(1,101, dtype=np.float32)\n", + "data_a = np.arange(1, 101, dtype=np.float32)\n", "data_b_t = linear_function(data_a, 2, 3)\n", "\n", - "data_c = np.arange(1,101, dtype=np.float32)\n", - "data_b_in = np.arange(5,105, dtype=np.float32)\n", + "data_c = np.arange(1, 101, dtype=np.float32)\n", + "data_b_in = np.arange(5, 105, dtype=np.float32)\n", "data_d_t = linear_function(data_c, 5, 1)\n", "\n", - "dataset = {'a': data_a, 'b_t': data_b_t, 'c':data_c, 'b_in': data_b_in, 'd_t':data_d_t }\n", + "dataset = {\n", + " \"a\": data_a,\n", + " \"b_t\": data_b_t,\n", + " \"c\": data_c,\n", + " \"b_in\": data_b_in,\n", + " \"d_t\": data_d_t,\n", + "}\n", "## Model a\n", - "a = Input('a')\n", - "b_t = Input('b_t')\n", - "shared = Parameter('shared',dimensions=(1,1))\n", - "output_relation = Linear(W=shared)(a.last())+Linear(W='A')(Fir(W='B')(a.tw(0.5)))\n", - "b = Output('b',output_relation)\n", + "a = Input(\"a\")\n", + "b_t = Input(\"b_t\")\n", + "shared = Parameter(\"shared\", dimensions=(1, 1))\n", + "output_relation = Linear(W=shared)(a.last()) + Linear(W=\"A\")(Fir(W=\"B\")(a.tw(0.5)))\n", + "b = Output(\"b\", output_relation)\n", "\n", "model = Modely(seed=42)\n", - "model.addModel('b_model', b)\n", - "model.addMinimize('b_min', b, b_t.last())\n", + "model.addModel(\"b_model\", b)\n", + "model.addMinimize(\"b_min\", b, b_t.last())\n", "model.neuralizeModel(0.1)\n", "\n", "# Model d\n", - "c = Input('c')\n", - "d_t = Input('d_t')\n", - "b_in = Input('b_in')\n", + "c = Input(\"c\")\n", + "d_t = Input(\"d_t\")\n", + "b_in = Input(\"b_in\")\n", "output_relation.connect(b_in)\n", - "d = Output('d',Linear(W=shared)(c.last())+Fir(W='C')(c.tw(0.5))+Fir(W='D')(b_in.tw(0.3)))\n", + "d = Output(\n", + " \"d\", Linear(W=shared)(c.last()) + Fir(W=\"C\")(c.tw(0.5)) + Fir(W=\"D\")(b_in.tw(0.3))\n", + ")\n", "\n", - "model.addModel('d_model', [b,d])\n", - "model.addMinimize('d_min', d, d_t.last())\n", + "model.addModel(\"d_model\", [b, d])\n", + "model.addMinimize(\"d_min\", d, d_t.last())\n", "model.neuralizeModel(0.1)\n", - "model.loadData('dataset', dataset)\n", + "model.loadData(\"dataset\", dataset)\n", "\n", - "params = {'num_of_epochs': 1,\n", - " 'train_batch_size': 8,\n", - " 'val_batch_size': 8,\n", - " 'test_batch_size':1,\n", - " 'lr':0.1}\n", + "params = {\n", + " \"num_of_epochs\": 1,\n", + " \"train_batch_size\": 8,\n", + " \"val_batch_size\": 8,\n", + " \"test_batch_size\": 1,\n", + " \"lr\": 0.1,\n", + "}\n", "\n", "## training dei parametri di tutti i modelli\n", - "_ = model.trainModel(splits=[100,0,0], training_params=params, prediction_samples=4)" + "_ = model.trainModel(splits=[100, 0, 0], training_params=params, prediction_samples=4)" ] }, { @@ -551,29 +563,35 @@ ], "source": [ "import numpy as np\n", - "clearNames(['x','x_state','y_state','out'])\n", - "x = Input('x', dimensions=3)\n", - "x_state = Input('x_state', dimensions=3)\n", - "y_state = Input('y_state', dimensions=3)\n", + "\n", + "clearNames([\"x\", \"x_state\", \"y_state\", \"out\"])\n", + "x = Input(\"x\", dimensions=3)\n", + "x_state = Input(\"x_state\", dimensions=3)\n", + "y_state = Input(\"y_state\", dimensions=3)\n", "x_out = Linear(output_dimension=3)(x_state.tw(0.5))\n", "y_out = Linear(output_dimension=3)(y_state.tw(0.5))\n", "x_out.closedLoop(x_state)\n", "y_out.closedLoop(y_state)\n", - "out = Output('out',x_out+y_out)\n", + "out = Output(\"out\", x_out + y_out)\n", "\n", "test = Modely(seed=42)\n", - "test.addModel('model', out)\n", - "test.addMinimize('error', out, x.tw(0.5))\n", + "test.addModel(\"model\", out)\n", + "test.addMinimize(\"error\", out, x.tw(0.5))\n", "\n", "test.neuralizeModel(0.1)\n", "\n", - "dataset = {'x':np.array([np.random.uniform(1,4,300)]).reshape(100,3).tolist()}\n", - "test.loadData(name='dataset', source=dataset)\n", + "dataset = {\"x\": np.array([np.random.uniform(1, 4, 300)]).reshape(100, 3).tolist()}\n", + "test.loadData(name=\"dataset\", source=dataset)\n", "\n", "# Training non ricorrente\n", - "params = {'num_of_epochs': 10, 'train_batch_size': 1, 'val_batch_size':1, 'lr':0.01}\n", - "tp = test.trainModel(splits=[70,20,10], prediction_samples=5, shuffle_data=False, training_params=params)\n", - "print('finale state: ', test._states)" + "params = {\"num_of_epochs\": 10, \"train_batch_size\": 1, \"val_batch_size\": 1, \"lr\": 0.01}\n", + "tp = test.trainModel(\n", + " splits=[70, 20, 10],\n", + " prediction_samples=5,\n", + " shuffle_data=False,\n", + " training_params=params,\n", + ")\n", + "print(\"finale state: \", test._states)" ] }, { @@ -605,7 +623,7 @@ ], "source": [ "test.resetStates()\n", - "print('finale state: ', test.states)" + "print(\"finale state: \", test.states)" ] }, { @@ -728,29 +746,42 @@ ], "source": [ "import numpy as np\n", + "\n", "clearNames()\n", - "x = Input('x', dimensions=3)\n", - "x_s = Input('x_s', dimensions=3)\n", - "y_s = Input('y_s', dimensions=3)\n", + "x = Input(\"x\", dimensions=3)\n", + "x_s = Input(\"x_s\", dimensions=3)\n", + "y_s = Input(\"y_s\", dimensions=3)\n", "x_out = Linear(output_dimension=3)(x_s.tw(0.5))\n", "y_out = Linear(output_dimension=3)(y_s.tw(0.5))\n", - "out = Output('out',x_out+y_out)\n", - "out_x = Output('out_x',x_out)\n", - "out_y = Output('out_y',y_out)\n", + "out = Output(\"out\", x_out + y_out)\n", + "out_x = Output(\"out_x\", x_out)\n", + "out_y = Output(\"out_y\", y_out)\n", "\n", "test = Modely(seed=42)\n", - "test.addModel('model', [out,out_x,out_y])\n", - "test.addMinimize('error', out, x.tw(0.5))\n", + "test.addModel(\"model\", [out, out_x, out_y])\n", + "test.addMinimize(\"error\", out, x.tw(0.5))\n", "\n", "test.neuralizeModel(0.1)\n", "\n", - "dataset = {'x':np.array([np.random.uniform(1,4,300)]).reshape(100,3).tolist()}\n", - "test.loadData(name='dataset', source=dataset)\n", + "dataset = {\"x\": np.array([np.random.uniform(1, 4, 300)]).reshape(100, 3).tolist()}\n", + "test.loadData(name=\"dataset\", source=dataset)\n", "\n", "# Training non ricorrente\n", - "params = {'num_of_epochs': 10, 'train_batch_size': 4, 'val_batch_size':4, 'test_batch_size':1, 'lr':0.01}\n", - "test.trainModel(splits=[70,20,10], prediction_samples=3, shuffle_data=False, closed_loop={'x_s':'out_x','y_s':'out_y'}, training_params=params)\n", - "print('finale state: ', test.states)" + "params = {\n", + " \"num_of_epochs\": 10,\n", + " \"train_batch_size\": 4,\n", + " \"val_batch_size\": 4,\n", + " \"test_batch_size\": 1,\n", + " \"lr\": 0.01,\n", + "}\n", + "test.trainModel(\n", + " splits=[70, 20, 10],\n", + " prediction_samples=3,\n", + " shuffle_data=False,\n", + " closed_loop={\"x_s\": \"out_x\", \"y_s\": \"out_y\"},\n", + " training_params=params,\n", + ")\n", + "print(\"finale state: \", test.states)" ] } ], diff --git a/docs/_autodoc/tutorials/examples/training.ipynb b/docs/_autodoc/tutorials/examples/training.ipynb index 2a29fa7f..085eed9e 100644 --- a/docs/_autodoc/tutorials/examples/training.ipynb +++ b/docs/_autodoc/tutorials/examples/training.ipynb @@ -203,19 +203,19 @@ ], "source": [ "## Create a neural network model and Load a dataset\n", - "in1 = Input('in1')\n", - "target = Input('target')\n", + "in1 = Input(\"in1\")\n", + "target = Input(\"target\")\n", "relation = Fir(in1.tw(0.05))\n", - "output = Output('out', relation)\n", + "output = Output(\"out\", relation)\n", "\n", "model = Modely(visualizer=TextVisualizer())\n", - "model.addMinimize('error', output, target.last())\n", - "model.addModel('model', output)\n", + "model.addMinimize(\"error\", output, target.last())\n", + "model.addModel(\"model\", output)\n", "model.neuralizeModel(0.01)\n", "\n", - "train_folder = 'data'\n", - "data_struct = ['in1', '', 'target']\n", - "model.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=1)" + "train_folder = \"data\"\n", + "data_struct = [\"in1\", \"\", \"target\"]\n", + "model.loadData(name=\"dataset\", source=train_folder, format=data_struct, skiplines=1)" ] }, { @@ -384,7 +384,14 @@ } ], "source": [ - "training_parameters = model.trainModel(models='model', train_dataset='dataset', num_of_epochs=10, lr=0.01, shuffle_data=True, train_batch_size=4)" + "training_parameters = model.trainModel(\n", + " models=\"model\",\n", + " train_dataset=\"dataset\",\n", + " num_of_epochs=10,\n", + " lr=0.01,\n", + " shuffle_data=True,\n", + " train_batch_size=4,\n", + ")" ] }, { @@ -414,7 +421,14 @@ } ], "source": [ - "training_parameters = model.trainModel(models='model', dataset='dataset', splits=[70, 20, 10], num_of_epochs=10, shuffle_data=True, train_batch_size=4)" + "training_parameters = model.trainModel(\n", + " models=\"model\",\n", + " dataset=\"dataset\",\n", + " splits=[70, 20, 10],\n", + " num_of_epochs=10,\n", + " shuffle_data=True,\n", + " train_batch_size=4,\n", + ")" ] }, { @@ -479,19 +493,43 @@ } ], "source": [ - "target = Input('target')\n", - "x = Input('x')\n", + "target = Input(\"target\")\n", + "x = Input(\"x\")\n", "relation = Fir(x.last())\n", "relation.closedLoop(x)\n", - "output = Output('out', relation)\n", + "output = Output(\"out\", relation)\n", "\n", "test = Modely(visualizer=TextVisualizer(), seed=42)\n", - "test.addModel('model', output)\n", - "test.addMinimize('error', target.next(), relation)\n", + "test.addModel(\"model\", output)\n", + "test.addMinimize(\"error\", target.next(), relation)\n", "test.neuralizeModel(0.01)\n", "\n", - "dataset = {'x': [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], 'target': [21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]}\n", - "test.loadData(name='dataset', source=dataset)" + "dataset = {\n", + " \"x\": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],\n", + " \"target\": [\n", + " 21,\n", + " 22,\n", + " 23,\n", + " 24,\n", + " 25,\n", + " 26,\n", + " 27,\n", + " 28,\n", + " 29,\n", + " 30,\n", + " 31,\n", + " 32,\n", + " 33,\n", + " 34,\n", + " 35,\n", + " 36,\n", + " 37,\n", + " 38,\n", + " 39,\n", + " 40,\n", + " ],\n", + "}\n", + "test.loadData(name=\"dataset\", source=dataset)" ] }, { @@ -548,7 +586,15 @@ } ], "source": [ - "training_parameters = test.trainModel(train_dataset='dataset', lr=0.01, num_of_epochs=10, train_batch_size=4, prediction_samples=2, step=1, shuffle_data=True)" + "training_parameters = test.trainModel(\n", + " train_dataset=\"dataset\",\n", + " lr=0.01,\n", + " num_of_epochs=10,\n", + " train_batch_size=4,\n", + " prediction_samples=2,\n", + " step=1,\n", + " shuffle_data=True,\n", + ")" ] }, { @@ -615,7 +661,9 @@ } ], "source": [ - "training_parameters = test.trainModel(train_dataset='dataset', minimize_gain={'error':0})" + "training_parameters = test.trainModel(\n", + " train_dataset=\"dataset\", minimize_gain={\"error\": 0}\n", + ")" ] }, { @@ -683,12 +731,14 @@ } ], "source": [ - "optimizer_defaults = {\n", - " 'lr': 0.1,\n", - " 'betas': (0.5, 0.99)\n", - " }\n", + "optimizer_defaults = {\"lr\": 0.1, \"betas\": (0.5, 0.99)}\n", "\n", - "training_parameters = test.trainModel(train_dataset='dataset', optimizer='Adam', optimizer_defaults=optimizer_defaults, num_of_epochs=10)" + "training_parameters = test.trainModel(\n", + " train_dataset=\"dataset\",\n", + " optimizer=\"Adam\",\n", + " optimizer_defaults=optimizer_defaults,\n", + " num_of_epochs=10,\n", + ")" ] }, { @@ -759,7 +809,13 @@ ], "source": [ "from nnodely.support.earlystopping import early_stop_patience, select_best_model\n", - "training_parameters = test.trainModel(train_dataset='dataset', minimize_gain={'error':0}, early_stopping=early_stop_patience, select_model=select_best_model)" + "\n", + "training_parameters = test.trainModel(\n", + " train_dataset=\"dataset\",\n", + " minimize_gain={\"error\": 0},\n", + " early_stopping=early_stop_patience,\n", + " select_model=select_best_model,\n", + ")" ] }, { @@ -863,12 +919,22 @@ } ], "source": [ - "test_folder = 'data'\n", - "data_struct = ['in1', '', 'target']\n", - "model.loadData(name='dataset_test', source=test_folder, format=data_struct, skiplines=1)\n", - "model.loadData(name='dataset_val', source=test_folder, format=data_struct, skiplines=1)\n", + "test_folder = \"data\"\n", + "data_struct = [\"in1\", \"\", \"target\"]\n", + "model.loadData(name=\"dataset_test\", source=test_folder, format=data_struct, skiplines=1)\n", + "model.loadData(name=\"dataset_val\", source=test_folder, format=data_struct, skiplines=1)\n", "\n", - "training_parameters = model.trainAndAnalyze(models='model', train_dataset='dataset', validation_dataset='dataset_val', train_batch_size=4, test_dataset='dataset_test', test_batch_size=1, num_of_epochs=10, lr=0.01, shuffle_data=True)" + "training_parameters = model.trainAndAnalyze(\n", + " models=\"model\",\n", + " train_dataset=\"dataset\",\n", + " validation_dataset=\"dataset_val\",\n", + " train_batch_size=4,\n", + " test_dataset=\"dataset_test\",\n", + " test_batch_size=1,\n", + " num_of_epochs=10,\n", + " lr=0.01,\n", + " shuffle_data=True,\n", + ")" ] }, { @@ -924,6 +990,7 @@ ], "source": [ "import pprint\n", + "\n", "print(\"Training completed with parameters:\", pprint.pprint(training_parameters))" ] } diff --git a/docs/_autodoc/tutorials/examples/vehicle_data/vehicle.csv b/docs/_autodoc/tutorials/examples/vehicle_data/vehicle.csv index 5625a587..3d80578b 100644 --- a/docs/_autodoc/tutorials/examples/vehicle_data/vehicle.csv +++ b/docs/_autodoc/tutorials/examples/vehicle_data/vehicle.csv @@ -98,4 +98,4 @@ 13.473333333333336,12.779200000000001,0.,5,-0.7460835566787409,-0.6602761975976819,-0.5746327099489577,-0.48922828574131927,-0.4061226600199461,-0.3259584416340431,-0.2506976788511679,-0.18109245144700026,-0.11566989947226602,-0.05551166846061051,0.,0.04959411345004128,0.09326429982348827,0.12985450593151882,0.16023045483507303,0.1832476556463689,0.20626485645772163,0.22928205726901751,0.2522992580803134,0.2753164588916661,0.298333659702962,0.09911902783658734 13.474444444444448,13.0928,0.,5,-0.7485232229184362,-0.6627158638373771,-0.5770452306900893,-0.4916408064824509,-0.4081821510060877,-0.32801793262018464,-0.25204581648097246,-0.18244058907686167,-0.11638159820341798,-0.05622336719181931,0.,0.04959411345004128,0.09414036583672214,0.13073057194475268,0.162020926674586,0.1850381274858819,0.2080553282972346,0.2310725291085305,0.25408972991982637,0.2771069307311791,0.30012413154247497,0.11169376341230414 13.496111111111112,13.014400000000002,0.,5,-0.7509649513013414,-0.6651575922202255,-0.5794597906294712,-0.4940553664218328,-0.41024338278987216,-0.3300791644039691,-0.2533950936325482,-0.1837898662284374,-0.11709389850244634,-0.05693566749079082,0.,0.04959411345004128,0.09501717235025353,0.13160737845828407,0.16381291192163872,0.1868301127329346,0.20984731354423047,0.2328645143555832,0.2558817151668791,0.2788989159782318,0.3019161167895277,0.1517397792930878 -13.51277777777778,13.0928,0.,5,-0.7534101501202031,-0.667602791039144,-0.581877782390336,-0.49647335818269767,-0.41230754420877247,-0.3321433258228126,-0.2547462885158893,-0.18514106111177853,-0.11780721119600912,-0.05764898018441045,0.,0.04959411345004128,0.09589522507155834,0.13248543117953204,0.16560744412277018,0.18862464493406605,0.21164184574541878,0.23465904655671466,0.2576762473680674,0.28069344817936326,0.30371064899065914,0.19856692399271794 \ No newline at end of file +13.51277777777778,13.0928,0.,5,-0.7534101501202031,-0.667602791039144,-0.581877782390336,-0.49647335818269767,-0.41230754420877247,-0.3321433258228126,-0.2547462885158893,-0.18514106111177853,-0.11780721119600912,-0.05764898018441045,0.,0.04959411345004128,0.09589522507155834,0.13248543117953204,0.16560744412277018,0.18862464493406605,0.21164184574541878,0.23465904655671466,0.2576762473680674,0.28069344817936326,0.30371064899065914,0.19856692399271794 diff --git a/docs/_autodoc/validation/validator_module.rst b/docs/_autodoc/validation/validator_module.rst index eb9284bb..0382b11a 100644 --- a/docs/_autodoc/validation/validator_module.rst +++ b/docs/_autodoc/validation/validator_module.rst @@ -5,4 +5,4 @@ Validation Module :undoc-members: :no-inherited-members: -.. autofunction:: nnodely.operators.validator.Validator.analyzeModel \ No newline at end of file +.. autofunction:: nnodely.operators.validator.Validator.analyzeModel diff --git a/docs/conf.py b/docs/conf.py index 1d6e9dda..28c8aec6 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -4,29 +4,36 @@ # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- import os + + def read_version(): - version_file = os.path.join(os.path.dirname(__file__), '..', 'nnodely', '__init__.py') - with open(version_file, 'r') as f: + version_file = os.path.join( + os.path.dirname(__file__), "..", "nnodely", "__init__.py" + ) + with open(version_file, "r") as f: for line in f: - if line.startswith('__version__'): + if line.startswith("__version__"): delim = '"' if '"' in line else "'" return line.split(delim)[1] raise RuntimeError("Unable to find version string.") + def skip_nnodely(app, what, name, obj, skip, options): # Skip the alias nnodely if name == "nnodely": return True # esclude questo membro dalla documentazione return skip + def setup(app): app.connect("autodoc-skip-member", skip_nnodely) + # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = __package__ -author = 'tonegas' +author = "tonegas" release = read_version() version = read_version() @@ -34,12 +41,12 @@ def setup(app): # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ -# 'sphinx.ext.autodoc', - 'sphinx.ext.napoleon', - 'sphinx.ext.viewcode', - 'sphinx.ext.mathjax', - 'myst_parser', - 'nbsphinx', + # 'sphinx.ext.autodoc', + "sphinx.ext.napoleon", + "sphinx.ext.viewcode", + "sphinx.ext.mathjax", + "myst_parser", + "nbsphinx", ] templates_path = [] @@ -60,8 +67,8 @@ def setup(app): } -html_static_path = ['_static'] -html_logo = '_static/logo.png' +html_static_path = ["_static"] +html_logo = "_static/logo.png" # -- Options for EPUB output ------------------------------------------------- -epub_copyright = '2024, tonegas' # Add this line +epub_copyright = "2024, tonegas" # Add this line diff --git a/docs/examples_basics/compser_module_ex/addClosedLoop.rst b/docs/examples_basics/compser_module_ex/addClosedLoop.rst index 17ed8fdf..a00e934d 100644 --- a/docs/examples_basics/compser_module_ex/addClosedLoop.rst +++ b/docs/examples_basics/compser_module_ex/addClosedLoop.rst @@ -5,4 +5,3 @@ y = Input('y') relation = Fir(x.last()) model.addClosedLoop(relation, y) - \ No newline at end of file diff --git a/docs/examples_basics/compser_module_ex/addConnect.rst b/docs/examples_basics/compser_module_ex/addConnect.rst index f1a96826..89e0fab6 100644 --- a/docs/examples_basics/compser_module_ex/addConnect.rst +++ b/docs/examples_basics/compser_module_ex/addConnect.rst @@ -4,4 +4,4 @@ x = Input('x') y = Input('y') relation = Fir(x.last()) - model.addConnect(relation, y) \ No newline at end of file + model.addConnect(relation, y) diff --git a/docs/examples_basics/compser_module_ex/addModel.rst b/docs/examples_basics/compser_module_ex/addModel.rst index ad9f410f..5cb910f5 100644 --- a/docs/examples_basics/compser_module_ex/addModel.rst +++ b/docs/examples_basics/compser_module_ex/addModel.rst @@ -3,4 +3,4 @@ model = Modely() x = Input('x') out = Output('out', Fir(x.last())) - model.addModel('example_model', [out]) \ No newline at end of file + model.addModel('example_model', [out]) diff --git a/docs/examples_basics/compser_module_ex/neuralizeModel.rst b/docs/examples_basics/compser_module_ex/neuralizeModel.rst index a0f66cc0..6795679d 100644 --- a/docs/examples_basics/compser_module_ex/neuralizeModel.rst +++ b/docs/examples_basics/compser_module_ex/neuralizeModel.rst @@ -1,4 +1,4 @@ .. code-block:: python - + model = Modely(name='example_model') - model.neuralizeModel(sample_time=0.1, clear_model=True) \ No newline at end of file + model.neuralizeModel(sample_time=0.1, clear_model=True) diff --git a/docs/examples_basics/compser_module_ex/removeConnection.rst b/docs/examples_basics/compser_module_ex/removeConnection.rst index ca03e376..8d59d09b 100644 --- a/docs/examples_basics/compser_module_ex/removeConnection.rst +++ b/docs/examples_basics/compser_module_ex/removeConnection.rst @@ -5,4 +5,4 @@ y = Input('y') relation = Fir(x.last()) model.addConnect(relation, y) - model.removeConnection(y) \ No newline at end of file + model.removeConnection(y) diff --git a/docs/examples_basics/compser_module_ex/removeModel.rst b/docs/examples_basics/compser_module_ex/removeModel.rst index 11e4652a..c9d853a2 100644 --- a/docs/examples_basics/compser_module_ex/removeModel.rst +++ b/docs/examples_basics/compser_module_ex/removeModel.rst @@ -1,3 +1,3 @@ .. code-block:: python - model.removeModel(['sub_model1', 'sub_model2']) \ No newline at end of file + model.removeModel(['sub_model1', 'sub_model2']) diff --git a/docs/examples_basics/export_module_ex/exportONNX.rst b/docs/examples_basics/export_module_ex/exportONNX.rst index ba84c3c2..120879aa 100644 --- a/docs/examples_basics/export_module_ex/exportONNX.rst +++ b/docs/examples_basics/export_module_ex/exportONNX.rst @@ -6,4 +6,4 @@ model = Modely() model.neuralizeModel() - model.exportONNX(inputs_order=['input1', 'input2'], outputs_order=['output1'], name='example_model', model_folder='path/to/export') \ No newline at end of file + model.exportONNX(inputs_order=['input1', 'input2'], outputs_order=['output1'], name='example_model', model_folder='path/to/export') diff --git a/docs/examples_basics/export_module_ex/exportPythonModel.rst b/docs/examples_basics/export_module_ex/exportPythonModel.rst index 172f2258..7ad98f22 100644 --- a/docs/examples_basics/export_module_ex/exportPythonModel.rst +++ b/docs/examples_basics/export_module_ex/exportPythonModel.rst @@ -2,4 +2,4 @@ model = Modely(name='example_model') model.neuralizeModel() - model.exportPythonModel(name='example_model', model_folder='folder/') \ No newline at end of file + model.exportPythonModel(name='example_model', model_folder='folder/') diff --git a/docs/examples_basics/export_module_ex/exportReport.rst b/docs/examples_basics/export_module_ex/exportReport.rst index 9e5483ce..79de92ac 100644 --- a/docs/examples_basics/export_module_ex/exportReport.rst +++ b/docs/examples_basics/export_module_ex/exportReport.rst @@ -3,4 +3,4 @@ model = Modely() model.neuralizeModel() model.trainModel(train_dataset='train_dataset', validation_dataset='val_dataset', num_of_epochs=10) - model.exportReport(name='example_model', model_folder='path/to/export') \ No newline at end of file + model.exportReport(name='example_model', model_folder='path/to/export') diff --git a/docs/examples_basics/export_module_ex/importPythonModel.rst b/docs/examples_basics/export_module_ex/importPythonModel.rst index a85613f4..21d8ab85 100644 --- a/docs/examples_basics/export_module_ex/importPythonModel.rst +++ b/docs/examples_basics/export_module_ex/importPythonModel.rst @@ -1,4 +1,4 @@ .. code-block:: python model = Modely() - model.importPythonModel(name='example_model', model_folder='path/to/import') \ No newline at end of file + model.importPythonModel(name='example_model', model_folder='path/to/import') diff --git a/docs/examples_basics/export_module_ex/loadModel.rst b/docs/examples_basics/export_module_ex/loadModel.rst index dfcddf2f..2b70c2db 100644 --- a/docs/examples_basics/export_module_ex/loadModel.rst +++ b/docs/examples_basics/export_module_ex/loadModel.rst @@ -1,4 +1,4 @@ .. code-block:: python model = Modely() - model.loadModel(name='example_model', model_folder='path/to/load') \ No newline at end of file + model.loadModel(name='example_model', model_folder='path/to/load') diff --git a/docs/examples_basics/export_module_ex/loadTorchModel.rst b/docs/examples_basics/export_module_ex/loadTorchModel.rst index 5f6fff2d..bcbf93f1 100644 --- a/docs/examples_basics/export_module_ex/loadTorchModel.rst +++ b/docs/examples_basics/export_module_ex/loadTorchModel.rst @@ -2,4 +2,4 @@ model = Modely() model.neuralizeModel() - model.loadTorchModel(name='example_model', model_folder='path/to/load') \ No newline at end of file + model.loadTorchModel(name='example_model', model_folder='path/to/load') diff --git a/docs/examples_basics/export_module_ex/onnxInference.rst b/docs/examples_basics/export_module_ex/onnxInference.rst index 3f9b4091..c627a2db 100644 --- a/docs/examples_basics/export_module_ex/onnxInference.rst +++ b/docs/examples_basics/export_module_ex/onnxInference.rst @@ -33,4 +33,4 @@ Example - Recurrent: 'y': np.ones(shape=(1, 1, 1)).astype(np.float32) } - predictions = Modely().onnxInference(dummy_input, model_folder) \ No newline at end of file + predictions = Modely().onnxInference(dummy_input, model_folder) diff --git a/docs/examples_basics/export_module_ex/saveModel.rst b/docs/examples_basics/export_module_ex/saveModel.rst index bde2f989..74ab3185 100644 --- a/docs/examples_basics/export_module_ex/saveModel.rst +++ b/docs/examples_basics/export_module_ex/saveModel.rst @@ -2,4 +2,4 @@ model = Modely() model.neuralizeModel() - model.saveModel(name='example_model', model_folder='folder/') \ No newline at end of file + model.saveModel(name='example_model', model_folder='folder/') diff --git a/docs/examples_basics/export_module_ex/saveTorchModel.rst b/docs/examples_basics/export_module_ex/saveTorchModel.rst index 9f2017ef..29188790 100644 --- a/docs/examples_basics/export_module_ex/saveTorchModel.rst +++ b/docs/examples_basics/export_module_ex/saveTorchModel.rst @@ -2,4 +2,4 @@ model = Modely() model.neuralizeModel() - model.saveTorchModel(name='example_model', model_folder='path/to/save') \ No newline at end of file + model.saveTorchModel(name='example_model', model_folder='path/to/save') diff --git a/docs/examples_basics/inference_module_ex/inference.rst b/docs/examples_basics/inference_module_ex/inference.rst index c7cc4a89..81a34023 100644 --- a/docs/examples_basics/inference_module_ex/inference.rst +++ b/docs/examples_basics/inference_module_ex/inference.rst @@ -5,4 +5,4 @@ out = Output('out', Fir(x.last())) model.addModel('example_model', [out]) model.neuralizeModel() - predictions = model(inputs={'x': [1, 2, 3]}) \ No newline at end of file + predictions = model(inputs={'x': [1, 2, 3]}) diff --git a/docs/examples_basics/input_module_ex/z.rst b/docs/examples_basics/input_module_ex/z.rst index a3509cda..5da83cc6 100644 --- a/docs/examples_basics/input_module_ex/z.rst +++ b/docs/examples_basics/input_module_ex/z.rst @@ -8,4 +8,4 @@ where the time vector 0 represents the last passed instant. T.z(-1) # = 1 T.z(0) # = 0 # the last passed instant - T.z(2) # = -2 \ No newline at end of file + T.z(2) # = -2 diff --git a/docs/examples_basics/layer_module_ex/activation_module_ex/elu.rst b/docs/examples_basics/layer_module_ex/activation_module_ex/elu.rst index 6ee67c07..eed00e15 100644 --- a/docs/examples_basics/layer_module_ex/activation_module_ex/elu.rst +++ b/docs/examples_basics/layer_module_ex/activation_module_ex/elu.rst @@ -1,3 +1,3 @@ .. code-block:: python - x = ELU(x) \ No newline at end of file + x = ELU(x) diff --git a/docs/examples_basics/layer_module_ex/activation_module_ex/identity.rst b/docs/examples_basics/layer_module_ex/activation_module_ex/identity.rst index f384ed96..82597e0b 100644 --- a/docs/examples_basics/layer_module_ex/activation_module_ex/identity.rst +++ b/docs/examples_basics/layer_module_ex/activation_module_ex/identity.rst @@ -1,3 +1,3 @@ .. code-block:: python - x = Identity(x) \ No newline at end of file + x = Identity(x) diff --git a/docs/examples_basics/layer_module_ex/activation_module_ex/relu.rst b/docs/examples_basics/layer_module_ex/activation_module_ex/relu.rst index 7c4d311f..e5ba89b8 100644 --- a/docs/examples_basics/layer_module_ex/activation_module_ex/relu.rst +++ b/docs/examples_basics/layer_module_ex/activation_module_ex/relu.rst @@ -1,3 +1,3 @@ .. code-block:: python - x = Relu(x) \ No newline at end of file + x = Relu(x) diff --git a/docs/examples_basics/layer_module_ex/activation_module_ex/sigmoid.rst b/docs/examples_basics/layer_module_ex/activation_module_ex/sigmoid.rst index 6810a2fc..64c9e56e 100644 --- a/docs/examples_basics/layer_module_ex/activation_module_ex/sigmoid.rst +++ b/docs/examples_basics/layer_module_ex/activation_module_ex/sigmoid.rst @@ -1,3 +1,3 @@ .. code-block:: python - x = Sigmoid(x) \ No newline at end of file + x = Sigmoid(x) diff --git a/docs/examples_basics/layer_module_ex/activation_module_ex/softmax.rst b/docs/examples_basics/layer_module_ex/activation_module_ex/softmax.rst index 1126dd3a..d3a14be8 100644 --- a/docs/examples_basics/layer_module_ex/activation_module_ex/softmax.rst +++ b/docs/examples_basics/layer_module_ex/activation_module_ex/softmax.rst @@ -1,3 +1,3 @@ .. code-block:: python - x = Softmax(x) \ No newline at end of file + x = Softmax(x) diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/add.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/add.rst index 227b1ec5..324d6e0a 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/add.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/add.rst @@ -2,4 +2,4 @@ add = Add(relation1, relation2) # or - add = relation1 + relation2 \ No newline at end of file + add = relation1 + relation2 diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/div.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/div.rst index d3a20424..ebd84aac 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/div.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/div.rst @@ -2,4 +2,4 @@ div = Div(relation1, relation2) # or - div = relation1 / relation2 \ No newline at end of file + div = relation1 / relation2 diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst index 547b9164..d5b556bf 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst @@ -2,4 +2,4 @@ mul = Mul(relation1, relation2) # or - mul = relation1 * relation2 \ No newline at end of file + mul = relation1 * relation2 diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst index 68ce98a9..2326e9d8 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst @@ -1,3 +1,3 @@ .. code-block :: python - x = Neg(x) \ No newline at end of file + x = Neg(x) diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst index b7ae9085..c342a3e4 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst @@ -2,4 +2,4 @@ pow = Pow(relation, exp) # or - pow = relation1 ** relation2 \ No newline at end of file + pow = relation1 ** relation2 diff --git a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst index e10dcfad..ff47ab7c 100644 --- a/docs/examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst +++ b/docs/examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst @@ -2,4 +2,4 @@ sub = Sub(relation1, relation2) # or - sub = relation1 - relation2 \ No newline at end of file + sub = relation1 - relation2 diff --git a/docs/examples_basics/layer_module_ex/fir.rst b/docs/examples_basics/layer_module_ex/fir.rst index aab246cc..e140e08c 100644 --- a/docs/examples_basics/layer_module_ex/fir.rst +++ b/docs/examples_basics/layer_module_ex/fir.rst @@ -16,8 +16,8 @@ Passing a parameter: Parameters initialization: .. code-block:: python - + x = Input('x') F = Input('F') fir_x = Fir(W_init='init_negexp')(x.tw(0.2)) - fir_F = Fir(W_init='init_constant', W_init_params={'value':1})(F.last()) \ No newline at end of file + fir_F = Fir(W_init='init_constant', W_init_params={'value':1})(F.last()) diff --git a/docs/examples_basics/layer_module_ex/part_module/part.rst b/docs/examples_basics/layer_module_ex/part_module/part.rst index fb05be16..80b30327 100644 --- a/docs/examples_basics/layer_module_ex/part_module/part.rst +++ b/docs/examples_basics/layer_module_ex/part_module/part.rst @@ -1,4 +1,4 @@ .. code-block:: python - + x = Input('x', dimensions=3).last() - relation = Part(x, 0, 1) \ No newline at end of file + relation = Part(x, 0, 1) diff --git a/docs/examples_basics/layer_module_ex/part_module/sample_part.rst b/docs/examples_basics/layer_module_ex/part_module/sample_part.rst index 496eeeae..3ce85bc8 100644 --- a/docs/examples_basics/layer_module_ex/part_module/sample_part.rst +++ b/docs/examples_basics/layer_module_ex/part_module/sample_part.rst @@ -1,4 +1,4 @@ .. code-block:: python - + x = Input('x').sw(3) - relation = SamplePart(x, 0, 1) \ No newline at end of file + relation = SamplePart(x, 0, 1) diff --git a/docs/examples_basics/layer_module_ex/part_module/sample_select.rst b/docs/examples_basics/layer_module_ex/part_module/sample_select.rst index a531ba1b..e9e40a50 100644 --- a/docs/examples_basics/layer_module_ex/part_module/sample_select.rst +++ b/docs/examples_basics/layer_module_ex/part_module/sample_select.rst @@ -1,4 +1,4 @@ .. code-block:: python x = Input('x').sw(3) - relation = SampleSelect(x, 1) \ No newline at end of file + relation = SampleSelect(x, 1) diff --git a/docs/examples_basics/layer_module_ex/part_module/select.rst b/docs/examples_basics/layer_module_ex/part_module/select.rst index 13cf44f4..8bcc809c 100644 --- a/docs/examples_basics/layer_module_ex/part_module/select.rst +++ b/docs/examples_basics/layer_module_ex/part_module/select.rst @@ -1,4 +1,4 @@ .. code-block:: python x = Input('x', dimensions=3).last() - relation = Select(x, 1) \ No newline at end of file + relation = Select(x, 1) diff --git a/docs/examples_basics/layer_module_ex/part_module/time_part.rst b/docs/examples_basics/layer_module_ex/part_module/time_part.rst index 87a3297b..08d66d61 100644 --- a/docs/examples_basics/layer_module_ex/part_module/time_part.rst +++ b/docs/examples_basics/layer_module_ex/part_module/time_part.rst @@ -1,4 +1,4 @@ .. code-block:: python x = Input('x').sw(10) - time_part = TimePart(x, i=0, j=5) \ No newline at end of file + time_part = TimePart(x, i=0, j=5) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/cos.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/cos.rst index ba879cb6..304216ff 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/cos.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/cos.rst @@ -1,3 +1,3 @@ .. code-block:: python - cos = Cos(relation) \ No newline at end of file + cos = Cos(relation) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/cosh.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/cosh.rst index 1f1852d4..975a677c 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/cosh.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/cosh.rst @@ -1,3 +1,3 @@ .. code-block:: python - cosh = Cosh(relation) \ No newline at end of file + cosh = Cosh(relation) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/sech.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/sech.rst index c3445322..76c4e6fb 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/sech.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/sech.rst @@ -1,3 +1,3 @@ .. code-block:: python - sech = Sech(relation) \ No newline at end of file + sech = Sech(relation) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/sin.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/sin.rst index 1ee6cb4e..1f64a417 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/sin.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/sin.rst @@ -1,3 +1,3 @@ .. code-block:: python - sin = Sin(relation) \ No newline at end of file + sin = Sin(relation) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/tan.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/tan.rst index 420ff4c1..c816c5ac 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/tan.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/tan.rst @@ -1,3 +1,3 @@ .. code-block:: python - tan = Tan(relation) \ No newline at end of file + tan = Tan(relation) diff --git a/docs/examples_basics/layer_module_ex/trig_module_ex/tanh.rst b/docs/examples_basics/layer_module_ex/trig_module_ex/tanh.rst index bc3285c6..4191bf64 100644 --- a/docs/examples_basics/layer_module_ex/trig_module_ex/tanh.rst +++ b/docs/examples_basics/layer_module_ex/trig_module_ex/tanh.rst @@ -1,3 +1,3 @@ .. code-block:: python - tanh = Tanh(relation) \ No newline at end of file + tanh = Tanh(relation) diff --git a/docs/examples_basics/parameter_module_ex/sample_time.rst b/docs/examples_basics/parameter_module_ex/sample_time.rst index 994f1290..171b6e00 100644 --- a/docs/examples_basics/parameter_module_ex/sample_time.rst +++ b/docs/examples_basics/parameter_module_ex/sample_time.rst @@ -1,3 +1,3 @@ .. code-block:: python - dt = SampleTime() \ No newline at end of file + dt = SampleTime() diff --git a/docs/examples_basics/trainer_module_ex/addMinimize.rst b/docs/examples_basics/trainer_module_ex/addMinimize.rst index a61c02a6..941f46b8 100644 --- a/docs/examples_basics/trainer_module_ex/addMinimize.rst +++ b/docs/examples_basics/trainer_module_ex/addMinimize.rst @@ -1,3 +1,3 @@ .. code-block:: python - model.addMinimize('minimize_op', streamA, streamB, loss_function='mse') \ No newline at end of file + model.addMinimize('minimize_op', streamA, streamB, loss_function='mse') diff --git a/docs/examples_basics/trainer_module_ex/removeMinimize.rst b/docs/examples_basics/trainer_module_ex/removeMinimize.rst index 7999e263..3f66f480 100644 --- a/docs/examples_basics/trainer_module_ex/removeMinimize.rst +++ b/docs/examples_basics/trainer_module_ex/removeMinimize.rst @@ -1,3 +1,3 @@ .. code-block:: python - model.removeMinimize(['minimize_op1', 'minimize_op2']) \ No newline at end of file + model.removeMinimize(['minimize_op1', 'minimize_op2']) diff --git a/docs/examples_basics/trainer_module_ex/trainModel.rst b/docs/examples_basics/trainer_module_ex/trainModel.rst index a835dea3..57d55385 100644 --- a/docs/examples_basics/trainer_module_ex/trainModel.rst +++ b/docs/examples_basics/trainer_module_ex/trainModel.rst @@ -36,4 +36,4 @@ Example - recurrent training: mass_spring_damper.loadData(name='mass_spring_dataset', source=data_folder, format=data_struct, delimiter=';') params = {'num_of_epochs': 100, 'train_batch_size': 128, 'lr': 0.001} - mass_spring_damper.trainModel(splits=[70, 20, 10], prediction_samples=10, training_params=params) \ No newline at end of file + mass_spring_damper.trainModel(splits=[70, 20, 10], prediction_samples=10, training_params=params) diff --git a/docs/index.rst b/docs/index.rst index d0b78a50..1497c358 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -8,15 +8,15 @@ Welcome to nnodely's documentation! .. image:: https://raw.githubusercontent.com/tonegas/nnodely/main/imgs/logo_white_info.png :target: https://github.com/tonegas/nnodely - :alt: Open + :alt: Open -*nnodely* is a framework designed to facilitate the creation and deployment of **Model-Structured Neural Networks** (**MSNNs**). -Modeling, control, and estimation of physical systems impose constraints that differ fundamentally from typical -deep-learning tasks (e.g., images or text). In engineering applications, models often need to respect -known physical laws or constraints, operate in real time, remain interpretable, and generalize reliably -even when only limited experimental data are available. MS-NNs combine the learning capabilities of neural -networks with structural priors grounded in physics, control and estimation theory, enabling: +*nnodely* is a framework designed to facilitate the creation and deployment of **Model-Structured Neural Networks** (**MSNNs**). +Modeling, control, and estimation of physical systems impose constraints that differ fundamentally from typical +deep-learning tasks (e.g., images or text). In engineering applications, models often need to respect +known physical laws or constraints, operate in real time, remain interpretable, and generalize reliably +even when only limited experimental data are available. MS-NNs combine the learning capabilities of neural +networks with structural priors grounded in physics, control and estimation theory, enabling: - **Data Efficiency**: By embedding structural priors, MS-NNs can learn effectively from limited data, reducing the need for extensive datasets. @@ -66,7 +66,7 @@ Overview .. sidebar:: Overview - + Overview of the *nnodely* development pipeline. It spans model design (:ref:`PH1 `), dataset construction aligned with the network architecture (:ref:`PH2 `), training (:ref:`PH3 `), domain-specific validation (:ref:`PH4 `), model export (:ref:`PH5 `), and composition of complex models (:ref:`PH6 `). Ellipses indicate the pipeline phases, while rectangles denote the artifacts produced at each phase. @@ -99,4 +99,3 @@ Indices and tables * :ref:`genindex` * :ref:`modindex` * :ref:`search` - diff --git a/docs/requirements.txt b/docs/requirements.txt index 8e66700e..415be759 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,4 +3,4 @@ myst_parser nbsphinx pandoc jupyter -jupyterlab \ No newline at end of file +jupyterlab diff --git a/mplplots/__init__.py b/mplplots/__init__.py index eb1f48f8..9d18dea1 100644 --- a/mplplots/__init__.py +++ b/mplplots/__init__.py @@ -1 +1,7 @@ -from mplplots.plots import plot_training, plot_results, plot_fuzzy, plot_2d_function, plot_3d_function \ No newline at end of file +from mplplots.plots import ( + plot_training, + plot_results, + plot_fuzzy, + plot_2d_function, + plot_3d_function, +) diff --git a/mplplots/plots.py b/mplplots/plots.py index 9eea6db0..b5babfee 100644 --- a/mplplots/plots.py +++ b/mplplots/plots.py @@ -2,22 +2,30 @@ import matplotlib.colors as mcolors -def plot_training(ax, title, key, data_train, data_val = None, last = None): + +def plot_training(ax, title, key, data_train, data_val=None, last=None): # Plot data if last is not None: - ax.set_title(f'{title} - epochs last {last}') + ax.set_title(f"{title} - epochs last {last}") else: - ax.set_title(f'{title}') + ax.set_title(f"{title}") - ax.plot([i + 1 for i in range(len(data_train))], data_train, label=f'Train loss {key}') + ax.plot( + [i + 1 for i in range(len(data_train))], data_train, label=f"Train loss {key}" + ) if data_val: - ax.plot([i + 1 for i in range(len(data_val))], data_val, '-.', label=f'Validation loss {key}') + ax.plot( + [i + 1 for i in range(len(data_val))], + data_val, + "-.", + label=f"Validation loss {key}", + ) - ax.set_yscale('log') + ax.set_yscale("log") ax.grid(True) - ax.legend(loc='best') - ax.set_xlabel('Epochs') - ax.set_ylabel('Loss') + ax.legend(loc="best") + ax.set_xlabel("Epochs") + ax.set_ylabel("Loss") # Set plot limits data_train = np.nan_to_num(data_train, nan=np.nan, posinf=np.nan, neginf=np.nan) if data_val: @@ -32,13 +40,13 @@ def plot_training(ax, title, key, data_train, data_val = None, last = None): def plot_results(ax, name_data, key, A, B, data_idxs, sample_time): # Plot data - ax.set_title(f'{key} on the dataset {name_data}') + ax.set_title(f"{key} on the dataset {name_data}") A_t = np.transpose(np.array(A)) B_t = np.transpose(np.array(B)) idxs_t = np.transpose(np.array(data_idxs)) - color_A = 'tab:blue' + color_A = "tab:blue" rgb_A = mcolors.to_rgb(color_A) - color_B = 'tab:orange' + color_B = "tab:orange" rgb_B = mcolors.to_rgb(color_B) delta = 0.1 @@ -47,64 +55,136 @@ def plot_results(ax, name_data, key, A, B, data_idxs, sample_time): time_array = [] num_samples = A_t.shape[2] for o in range(A_t.shape[1]): - time_array.append(np.linspace(0, (num_samples - 1) * sample_time, num_samples) + sample_time * o) + time_array.append( + np.linspace(0, (num_samples - 1) * sample_time, num_samples) + + sample_time * o + ) time_array = np.array(time_array) for ind_dim in range(A_t.shape[0]): # Print the marker only if the output have a time window - ax.plot(time_array[0,:], A_t[ind_dim, 0, :], - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), - marker='s' if A_t.shape[1] > 1 else None, markersize=2, - label=f'A_{ind_dim}') - ax.plot(time_array[0,:], B_t[ind_dim, 0, :], '-.', - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), - marker='o' if A_t.shape[1] > 1 else None, markersize=2, - label=f'B_{ind_dim}') - if A_t.shape[1] > 1 : - correlation = np.empty((A_t.shape[0],A_t.shape[2])) + ax.plot( + time_array[0, :], + A_t[ind_dim, 0, :], + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), + marker="s" if A_t.shape[1] > 1 else None, + markersize=2, + label=f"A_{ind_dim}", + ) + ax.plot( + time_array[0, :], + B_t[ind_dim, 0, :], + "-.", + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), + marker="o" if A_t.shape[1] > 1 else None, + markersize=2, + label=f"B_{ind_dim}", + ) + if A_t.shape[1] > 1: + correlation = np.empty((A_t.shape[0], A_t.shape[2])) for ind_el in range(A_t.shape[2]): - ax.plot(time_array[:,ind_el], A_t[ind_dim,:,ind_el], color=tuple((x + delta*ind_dim)%1.0001 for x in rgb_A)) - ax.plot(time_array[:,ind_el], B_t[ind_dim,:,ind_el], '-.', color=tuple((x + delta*ind_dim)%1.0001 for x in rgb_B)) - correlation[ind_dim, ind_el] = np.corrcoef(A_t[ind_dim,:,ind_el], B_t[ind_dim,:,ind_el])[0, 1] - ax.text(0.05, 0.95 - 0.05 * ind_dim, - f'Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=1)[ind_dim]:.2f}', - transform=ax.transAxes, verticalalignment='top') + ax.plot( + time_array[:, ind_el], + A_t[ind_dim, :, ind_el], + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), + ) + ax.plot( + time_array[:, ind_el], + B_t[ind_dim, :, ind_el], + "-.", + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), + ) + correlation[ind_dim, ind_el] = np.corrcoef( + A_t[ind_dim, :, ind_el], B_t[ind_dim, :, ind_el] + )[0, 1] + ax.text( + 0.05, + 0.95 - 0.05 * ind_dim, + f"Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=1)[ind_dim]:.2f}", + transform=ax.transAxes, + verticalalignment="top", + ) else: correlation = np.empty((A_t.shape[0],)) - correlation[ind_dim] = np.corrcoef(A_t[ind_dim, 0], B_t[ind_dim, 0])[0, 1] - ax.text(0.05, 0.95-0.05*ind_dim, f'Correlation A_{ind_dim} - B_{ind_dim}: {correlation[ind_dim]:.2f}', transform=ax.transAxes, verticalalignment='top') + correlation[ind_dim] = np.corrcoef(A_t[ind_dim, 0], B_t[ind_dim, 0])[ + 0, 1 + ] + ax.text( + 0.05, + 0.95 - 0.05 * ind_dim, + f"Correlation A_{ind_dim} - B_{ind_dim}: {correlation[ind_dim]:.2f}", + transform=ax.transAxes, + verticalalignment="top", + ) else: correlation = np.empty(A_t.shape) for ind_dim in range(A_t.shape[0]): first = True - ax.scatter(idxs_t[:,0] * sample_time, A_t[ind_dim, 0, :, 0], marker='s', s=6, - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A)) - ax.scatter(idxs_t[:,0] * sample_time, B_t[ind_dim, 0, :, 0], marker='o', s=6, - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B)) + ax.scatter( + idxs_t[:, 0] * sample_time, + A_t[ind_dim, 0, :, 0], + marker="s", + s=6, + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), + ) + ax.scatter( + idxs_t[:, 0] * sample_time, + B_t[ind_dim, 0, :, 0], + marker="o", + s=6, + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), + ) for ind_el in range(A_t.shape[2]): time_array = idxs_t[ind_el] * sample_time # Print the marker only if the output have a time window - ax.plot(time_array, A_t[ind_dim, 0, ind_el], marker = 's' if A_t.shape[1] > 1 else None, markersize=2, + ax.plot( + time_array, + A_t[ind_dim, 0, ind_el], + marker="s" if A_t.shape[1] > 1 else None, + markersize=2, + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), + label=f"A_{ind_dim}" if first else None, + ) + ax.plot( + time_array, + B_t[ind_dim, 0, ind_el], + "-.", + marker="o" if A_t.shape[1] > 1 else None, + markersize=2, + color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), + label=f"B_{ind_dim}" if first else None, + ) + for ind_pred in range(A_t.shape[3]): + time_array = idxs_t[ind_el, ind_pred] * sample_time + np.linspace( + 0, (A_t.shape[1] - 1) * sample_time, A_t.shape[1] + ) + ax.plot( + time_array, + A_t[ind_dim, :, ind_el, ind_pred], color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A), - label=f'A_{ind_dim}' if first else None) - ax.plot(time_array, B_t[ind_dim, 0, ind_el], '-.', marker = 'o' if A_t.shape[1] > 1 else None, markersize=2, + ) + ax.plot( + time_array, + B_t[ind_dim, :, ind_el, ind_pred], + "-.", color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B), - label=f'B_{ind_dim}' if first else None) - for ind_pred in range(A_t.shape[3]): - time_array = idxs_t[ind_el,ind_pred] * sample_time + np.linspace(0, (A_t.shape[1] - 1) * sample_time, A_t.shape[1]) - ax.plot(time_array, A_t[ind_dim, :, ind_el,ind_pred], - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A)) - ax.plot(time_array, B_t[ind_dim, :, ind_el,ind_pred], '-.', - color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B)) + ) first = False for ind_win in range(A_t.shape[1]): - correlation[ind_dim,ind_win,ind_el] = np.corrcoef(A_t[ind_dim,ind_win,ind_el], B_t[ind_dim,ind_win,ind_el])[0, 1] - ax.text(0.05, 0.95-0.05*ind_dim, f'Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=(1, 2, 3))[ind_dim]:.2f}', transform=ax.transAxes, verticalalignment='top') - + correlation[ind_dim, ind_win, ind_el] = np.corrcoef( + A_t[ind_dim, ind_win, ind_el], B_t[ind_dim, ind_win, ind_el] + )[0, 1] + ax.text( + 0.05, + 0.95 - 0.05 * ind_dim, + f"Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=(1, 2, 3))[ind_dim]:.2f}", + transform=ax.transAxes, + verticalalignment="top", + ) ax.grid(True) - ax.legend(loc='best') - ax.set_xlabel('Time [s]') - ax.set_ylabel(f'Value {key}') + ax.legend(loc="best") + ax.set_xlabel("Time [s]") + ax.set_ylabel(f"Value {key}") # min_val = min([min(A), min(B)]) # max_val = max([max(A), max(B)]) @@ -152,28 +232,38 @@ def plot_fuzzy(ax, name, x, y, chan_centers): tableau_colors = mcolors.TABLEAU_COLORS num_of_colors = len(list(tableau_colors.keys())) for ind in range(len(y)): - ax.axvline(x=chan_centers[ind], color=tableau_colors[list(tableau_colors.keys())[ind % num_of_colors]], - linestyle='--') - ax.plot(x, y[ind], label=f'Channel {int(ind) + 1}', linewidth=2) - ax.legend(loc='best') - ax.set_xlabel('Input') - ax.set_ylabel('Value') - ax.set_title(f'Function {name}') + ax.axvline( + x=chan_centers[ind], + color=tableau_colors[list(tableau_colors.keys())[ind % num_of_colors]], + linestyle="--", + ) + ax.plot(x, y[ind], label=f"Channel {int(ind) + 1}", linewidth=2) + ax.legend(loc="best") + ax.set_xlabel("Input") + ax.set_ylabel("Value") + ax.set_title(f"Function {name}") def plot_3d_function(plt, name, x0, x1, params, output, input_names): fig = plt.figure() # Clear the current plot plt.clf() - ax = fig.add_subplot(111, projection='3d') - ax.plot_surface(np.array(x0), np.array(x1), np.array(output), cmap='viridis') + ax = fig.add_subplot(111, projection="3d") + ax.plot_surface(np.array(x0), np.array(x1), np.array(output), cmap="viridis") ax.set_xlabel(input_names[0]) ax.set_ylabel(input_names[1]) - ax.set_zlabel(f'{name} output') + ax.set_zlabel(f"{name} output") for ind in range(len(input_names) - 2): - fig.text(0.01, 0.9 - 0.05 * ind, f"{input_names[ind + 2]} ={params[ind]}", fontsize=10, color='blue', - style='italic') - plt.title(f'Function {name}') + fig.text( + 0.01, + 0.9 - 0.05 * ind, + f"{input_names[ind + 2]} ={params[ind]}", + fontsize=10, + color="blue", + style="italic", + ) + plt.title(f"Function {name}") + def plot_2d_function(plt, name, x, params, output, input_names): fig = plt.figure() @@ -181,8 +271,14 @@ def plot_2d_function(plt, name, x, params, output, input_names): plt.clf() plt.plot(np.array(x), np.array(output), linewidth=2) plt.xlabel(input_names[0]) - plt.ylabel(f'{name} output') + plt.ylabel(f"{name} output") for ind in range(len(input_names) - 1): - fig.text(0.01, 0.9 - 0.05 * ind, f"{input_names[ind + 1]} ={params[ind]}", fontsize=10, color='blue', - style='italic') - plt.title(f'Function {name}') \ No newline at end of file + fig.text( + 0.01, + 0.9 - 0.05 * ind, + f"{input_names[ind + 1]} ={params[ind]}", + fontsize=10, + color="blue", + style="italic", + ) + plt.title(f"Function {name}") diff --git a/nnodely/basic/loss.py b/nnodely/basic/loss.py deleted file mode 100644 index 11f46a35..00000000 --- a/nnodely/basic/loss.py +++ /dev/null @@ -1,27 +0,0 @@ -import torch.nn as nn -import torch -from nnodely.support.utils import check - -available_losses = ['mse', 'rmse', 'mae', 'cross_entropy'] - -class CustomLoss(nn.Module): - def __init__(self, loss_type='mse', **kwargs): - super(CustomLoss, self).__init__() - check(loss_type in available_losses, TypeError, f'The \"{loss_type}\" loss is not available. Possible losses are: {available_losses}.') - self.loss_type = loss_type - self.loss = nn.MSELoss(**kwargs) - if callable(loss_type): - self.loss = loss_type - elif self.loss_type == 'mae': - self.loss = nn.L1Loss(**kwargs) - elif self.loss_type == 'cross_entropy': - self.loss = nn.CrossEntropyLoss(**kwargs) - - def forward(self, inA, inB): - if self.loss_type == 'cross_entropy': - inB = inB.squeeze().float() if inA.shape == inB.shape else inB.squeeze().long() - inA = inA.squeeze() - res = self.loss(inA,inB) - if self.loss_type == 'rmse': - res = torch.sqrt(res) - return res \ No newline at end of file diff --git a/nnodely/basic/model.py b/nnodely/basic/model.py deleted file mode 100644 index 81f66bd1..00000000 --- a/nnodely/basic/model.py +++ /dev/null @@ -1,220 +0,0 @@ -import torch -import copy - -import torch.nn as nn -import numpy as np - -from itertools import product - -from nnodely.support.utils import TORCH_DTYPE -from nnodely.support import initializer - -@torch.fx.wrap -def update_state(data_in, rel): - #virtual = torch.roll(data_in, shifts=-1, dims=1) - max_dim = min(rel.size(1), data_in.size(1)) - data_out = data_in.clone() - data_out[:, -max_dim:, :] = rel[:, -max_dim:, :] - return data_out - -class Model(nn.Module): - def __init__(self, model_def): - super(Model, self).__init__() - model_def = copy.deepcopy(model_def) - - self.states = {key: value for key, value in model_def['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())} - - self.inputs = model_def['Inputs'] - self.outputs = model_def['Outputs'] - self.relations = model_def['Relations'] - self.params = model_def['Parameters'] - self.constants = model_def['Constants'] - self.sample_time = model_def['Info']['SampleTime'] - self.functions = model_def['Functions'] - - self.minimizers = model_def['Minimizers'] if 'Minimizers' in model_def else {} - self.minimizers_keys = [self.minimizers[key]['A'] for key in self.minimizers] + [self.minimizers[key]['B'] for key in self.minimizers] - - self.input_ns_backward = {key:value['ns'][0] for key, value in model_def['Inputs'].items()} - self.input_n_samples = {key:value['ntot'] for key, value in model_def['Inputs'].items()} - - ## Build the network - self.all_parameters = {} - self.all_constants = {} - self.relation_forward = {} - self.relation_inputs = {} - self.closed_loop_update = {} - self.connect_update = {} - - ## Update the connect_update and closed_loop_update - self.update() - - ## Define the correct slicing - for _, items in self.relations.items(): - if items[0] == 'SamplePart': - if items[1][0] in self.inputs.keys(): - items[3][0] = self.input_ns_backward[items[1][0]] + items[3][0] - items[3][1] = self.input_ns_backward[items[1][0]] + items[3][1] - if len(items) > 4: ## Offset - items[4] = self.input_ns_backward[items[1][0]] + items[4] - if items[0] == 'TimePart': - if items[1][0] in self.inputs.keys(): - items[3][0] = self.input_ns_backward[items[1][0]] + round(items[3][0]/self.sample_time) - items[3][1] = self.input_ns_backward[items[1][0]] + round(items[3][1]/self.sample_time) - if len(items) > 4: ## Offset - items[4] = self.input_ns_backward[items[1][0]] + round(items[4]/self.sample_time) - else: - items[3][0] = round(items[3][0]/self.sample_time) - items[3][1] = round(items[3][1]/self.sample_time) - if len(items) > 4: ## Offset - items[4] = round(items[4]/self.sample_time) - - ## Create all the parameters - for name, param_data in self.params.items(): - window = 'tw' if 'tw' in param_data.keys() else ('sw' if 'sw' in param_data.keys() else None) - aux_sample_time = self.sample_time if 'tw' == window else 1 - sample_window = round(param_data[window] / aux_sample_time) if window else None - if sample_window is None: - param_size = tuple(param_data['dim']) if type(param_data['dim']) is list else (param_data['dim'],) - else: - param_size = (sample_window,)+tuple(param_data['dim']) if type(param_data['dim']) is list else (sample_window, param_data['dim']) - if 'values' in param_data: - self.all_parameters[name] = nn.Parameter(torch.tensor(param_data['values'], dtype=TORCH_DTYPE), requires_grad=True) - # TODO clean code - elif 'init_fun' in param_data: - if 'code' in param_data['init_fun'].keys(): - exec(param_data['init_fun']['code'], globals()) - function_to_call = globals()[param_data['init_fun']['name']] - else: - function_to_call = getattr(initializer, param_data['init_fun']['name']) - values = np.zeros(param_size) - for indexes in product(*(range(v) for v in param_size)): - if 'params' in param_data['init_fun']: - values[indexes] = function_to_call(indexes, param_size, param_data['init_fun']['params']) - else: - values[indexes] = function_to_call(indexes, param_size) - self.all_parameters[name] = nn.Parameter(torch.tensor(values.tolist(), dtype=TORCH_DTYPE), requires_grad=True) - else: - self.all_parameters[name] = nn.Parameter(torch.rand(size=param_size, dtype=TORCH_DTYPE), requires_grad=True) - - ## Create all the constants - for name, param_data in self.constants.items(): - self.all_constants[name] = nn.Parameter(torch.tensor(param_data['values'], dtype=TORCH_DTYPE), requires_grad=False) - all_params_and_consts = self.all_parameters | self.all_constants - - ## Create all the relations - for relation, inputs in self.relations.items(): - ## Take the relation name and the inputs needed to solve the relation - rel_name, input_var = inputs[0], inputs[1] - ## Create All the Relations - func = getattr(self,rel_name) - if func: - layer_inputs = [] - for item in inputs[2:]: - if item in list(self.params.keys()): ## the relation takes parameters - layer_inputs.append(self.all_parameters[item]) - elif item in list(self.constants.keys()): ## the relation takes a constant - layer_inputs.append(self.all_constants[item]) - elif item in list(self.functions.keys()): ## the relation takes a custom function - layer_inputs.append(self.functions[item]) - if 'params_and_consts' in self.functions[item].keys() and len(self.functions[item]['params_and_consts']) >= 0: ## Parametric function that takes parameters - layer_inputs.append([all_params_and_consts[par] for par in self.functions[item]['params_and_consts']]) - if 'map_over_dim' in self.functions[item].keys(): - layer_inputs.append(self.functions[item]['map_over_dim']) - else: - layer_inputs.append(item) - - if rel_name == 'SamplePart': - if layer_inputs[0] == -1: - layer_inputs[0] = self.input_n_samples[input_var[0]] - elif rel_name == 'TimePart': - if layer_inputs[0] == -1: - layer_inputs[0] = self.input_n_samples[input_var[0]] - else: - layer_inputs[0] = round(layer_inputs[0] / self.sample_time) - ## Initialize the relation - self.relation_forward[relation] = func(*layer_inputs) - ## Save the inputs needed for the relative relation - self.relation_inputs[relation] = input_var - - ## Add the gradient to all the relations and parameters that requires it - self.relation_forward = nn.ParameterDict(self.relation_forward) - self.all_constants = nn.ParameterDict(self.all_constants) - self.all_parameters = nn.ParameterDict(self.all_parameters) - ## list of network outputs - self.network_output_predictions = set(self.outputs.values()) - ## list of network minimization outputs - self.network_output_minimizers = [] - for _,value in self.minimizers.items(): - self.network_output_minimizers.append(self.outputs[value['A']]) if value['A'] in self.outputs.keys() else self.network_output_minimizers.append(value['A']) - self.network_output_minimizers.append(self.outputs[value['B']]) if value['B'] in self.outputs.keys() else self.network_output_minimizers.append(value['B']) - self.network_output_minimizers = set(self.network_output_minimizers) - ## list of all the network Outputs - self.network_outputs = self.network_output_predictions.union(self.network_output_minimizers) - - def forward(self, kwargs): - result_dict = {} - - ## Initially i have only the inputs from the dataset, the parameters, and the constants - available_inputs = [key for key in self.inputs.keys() if key not in self.connect_update.keys()] ## remove connected inputs - available_keys = set(available_inputs + list(self.all_parameters.keys()) + list(self.all_constants.keys())) - - ## Forward pass through the relations - while not self.network_outputs.issubset(available_keys): ## i need to climb the relation tree until i get all the outputs - for relation in self.relations.keys(): - ## if i have all the variables i can calculate the relation - if set(self.relation_inputs[relation]).issubset(available_keys) and (relation not in available_keys): - ## Collect all the necessary inputs for the relation - layer_inputs = [] - for key in self.relation_inputs[relation]: - if key in self.all_constants.keys(): ## relation that takes a constant - layer_inputs.append(self.all_constants[key]) - elif key in available_inputs: ## relation that takes inputs - layer_inputs.append(kwargs[key]) - elif key in self.all_parameters.keys(): ## relation that takes parameters - layer_inputs.append(self.all_parameters[key]) - else: ## relation than takes another relation or a connect variable - layer_inputs.append(result_dict[key]) - - ## Execute the current relation - result_dict[relation] = self.relation_forward[relation](*layer_inputs) - available_keys.add(relation) - - ## Check if the relation is inside the connect - for connect_input, connect_rel in self.connect_update.items(): - if relation == connect_rel: - result_dict[connect_input] = update_state(kwargs[connect_input], result_dict[relation]) - available_keys.add(connect_input) - - ## Return a dictionary with all the connected inputs - connect_update_dict = {key: result_dict[key] for key in self.connect_update.keys()} - ## Return a dictionary with all the relations that updates the state variables - closed_loop_update_dict = {key: result_dict[value] for key, value in self.closed_loop_update.items()} - ## Return a dictionary with all the outputs final values - output_dict = {key: result_dict[value] for key, value in self.outputs.items()} - ## Return a dictionary with the minimization relations - minimize_dict = {} - for key in self.minimizers_keys: - minimize_dict[key] = result_dict[self.outputs[key]] if key in self.outputs.keys() else result_dict[key] - return output_dict, minimize_dict, closed_loop_update_dict, connect_update_dict - - def update(self, *, closed_loop = {}, connect = {}, disconnect = False): - self.closed_loop_update = {} - self.connect_update = {} - - if disconnect: - return - - for key, state in self.states.items(): - if 'connect' in state.keys(): - self.connect_update[key] = state['connect'] - elif 'closedLoop' in state.keys(): - self.closed_loop_update[key] = state['closedLoop'] - - # Get relation from outputs - for connect_in, connect_rel in connect.items(): - set_relation = self.outputs[connect_rel] if connect_rel in self.outputs.keys() else connect_rel - self.connect_update[connect_in] = set_relation - for close_in, close_rel in closed_loop.items(): - set_relation = self.outputs[close_rel] if close_rel in self.outputs.keys() else close_rel - self.closed_loop_update[close_in] = set_relation diff --git a/nnodely/basic/modeldef.py b/nnodely/basic/modeldef.py deleted file mode 100644 index 438771c1..00000000 --- a/nnodely/basic/modeldef.py +++ /dev/null @@ -1,230 +0,0 @@ -import copy - -import numpy as np - -from nnodely.support.utils import check, check_and_get_list -from nnodely.support.jsonutils import merge, subjson_from_model, subjson_from_minimize, check_model, get_models_json -from nnodely.basic.relation import MAIN_JSON, Stream, check_names -from nnodely.layers.output import Output -from nnodely.layers.input import Input - -from nnodely.support.logger import logging, nnLogger -log = nnLogger(__name__, logging.INFO) - - -class ModelDef: - def __init__(self, model_def = MAIN_JSON): - # Models definition - self.__json_base = copy.deepcopy(model_def) - - # Initialize the model definition - self.__json = copy.deepcopy(self.__json_base) - if "SampleTime" in self.__json['Info']: - self.__sample_time = self.__json['Info']["SampleTime"] - else: - self.__sample_time = None - - def __contains__(self, key): - return key in self.__json - - def __getitem__(self, key): - if key in self.__json: - return self.__json[key] - else: - return None - - def __setitem__(self, key, value): - self.__json[key] = value - - def __rebuild_json(self, models_names, minimizers): - models_json = subjson_from_model(self.__json, list(models_names)) - if 'Minimizers' in self.__json and len(minimizers) > 0: - minimizers_json = subjson_from_minimize(self.__json, list(minimizers)) - models_json = merge(models_json, minimizers_json) - return copy.deepcopy(models_json) - - def recurrentInputs(self): - return {key:value for key, value in self.__json['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())} - - def getJson(self, models:list|str|None = None) -> dict: - if models is None: - return copy.deepcopy(self.__json) - else: - json = subjson_from_model(self.__json, models) - check_model(json) - return copy.deepcopy(json) - - def getSampleTime(self): - check(self.__sample_time is not None, AttributeError, "Sample time is not defined the model is not neuralized!") - return self.__sample_time - - def isDefined(self): - return self.__json is not None - - def addConnection(self, stream_out:str|Output|Stream, input_in:str|Input, type:str, local:bool = False): - outputs = self.__json['Outputs'] - - if isinstance(stream_out, (Output, Stream)): - stream_name = outputs[stream_out.name] if stream_out.name in outputs.keys() else stream_out.name - else: - output_name = check_and_get_list(stream_out, set(outputs.keys()), - lambda name: f"The name {name} is not part of the available Outputs")[0] - stream_name = outputs[output_name] - - if isinstance(input_in, Input): - input_name = input_in.name - else: - input_name = input_in #TODO Add tests - - input_name = check_and_get_list(input_name, set(self.__json['Inputs'].keys()), - lambda name: f"The name {name} is not part of the available Inputs")[0] - stream_name = check_and_get_list(stream_name, set(self.__json['Relations'].keys()), - lambda name: f"The name {name} is not part of the available Relations")[0] - self.__json['Inputs'][input_name][type] = stream_name - self.__json['Inputs'][input_name]['local'] = int(local) - - def removeConnection(self, name_list:str|list[str]): - name_list = check_and_get_list(name_list, set(self.__json['Inputs'].keys()), lambda name: f"The name {name} is not part of the available Inputs") - for input_in in name_list: - if 'closedLoop' in self.__json['Inputs'][input_in].keys(): - del self.__json['Inputs'][input_in]['closedLoop'] - del self.__json['Inputs'][input_in]['local'] - elif 'connect' in self.__json['Inputs'][input_in].keys(): - del self.__json['Inputs'][input_in]['connect'] - del self.__json['Inputs'][input_in]['local'] - else: - raise ValueError(f"The input '{input_in}' has no connection or closed loop defined") - - def addModel(self, name:str, stream_list): - if isinstance(stream_list, Output): - stream_list = [stream_list] - - json = MAIN_JSON - for stream in stream_list: - json = merge(json, stream.json) - check_model(json) - - if 'Models' not in self.__json: - self.__json = merge(self.__json, json) - self.__json['Models'] = name - else: - models_names = set((self.__json['Models'],)) if type(self.__json['Models']) is str else set(self.__json['Models'].keys()) - check_names(name, models_names, 'Models') - if type(self.__json['Models']) is str: - self.__json['Models'] = {self.__json['Models']: get_models_json(self.__json)} - self.__json = merge(self.__json, json) - self.__json['Models'][name] = get_models_json(json) - - def removeModel(self, name_list): - if 'Models' not in self.__json: - raise ValueError("No Models are defined") - models_names = {self.__json['Models']} if type(self.__json['Models']) is str else set(self.__json['Models'].keys()) - name_list = check_and_get_list(name_list, models_names, lambda name: f"The name {name} is not part of the available models") - models_names -= set(name_list) - minimizers = set(self.__json['Minimizers'].keys()) if 'Minimizers' in self.__json else None - self.__json = self.__rebuild_json(models_names, minimizers) - - def addMinimize(self, name, streamA, streamB, loss_function='mse'): - if 'Minimizers' not in self.__json: - self.__json['Minimizers'] = {} - check_names(name, set(self.__json['Minimizers'].keys()), 'Minimizers') - - if isinstance(streamA, str): - streamA_name = streamA - else: - check(isinstance(streamA, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream') - streamA_name = streamA.json['Outputs'][streamA.name] if isinstance(streamA, Output) else streamA.name - self.__json = merge(self.__json, streamA.json) - - if isinstance(streamB, str): - streamB_name = streamB - else: - check(isinstance(streamB, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream') - streamB_name = streamB.json['Outputs'][streamB.name] if isinstance(streamB, Output) else streamB.name - self.__json = merge(self.__json, streamB.json) - #check(streamA.dim == streamB.dim, ValueError, f'Dimension of streamA={streamA.dim} and streamB={streamB.dim} are not equal.') - - self.__json['Minimizers'][name] = {} - self.__json['Minimizers'][name]['A'] = streamA_name - self.__json['Minimizers'][name]['B'] = streamB_name - self.__json['Minimizers'][name]['loss'] = loss_function - - def removeMinimize(self, name_list): - if 'Minimizers' not in self.__json: - raise ValueError("No Minimizers are defined") - name_list = check_and_get_list(name_list, self.__json['Minimizers'].keys(), lambda name: f"The name {name} is not part of the available minimizers") - models_names = {self.__json['Models']} if type(self.__json['Models']) is str else set(self.__json['Models'].keys()) - remaining_minimizers = set(self.__json['Minimizers'].keys()) - set(name_list) if 'Minimizers' in self.__json else None - self.__json = self.__rebuild_json(models_names, remaining_minimizers) - - def setBuildWindow(self, sample_time = None): - check(self.__json is not None, RuntimeError, "No model is defined!") - if sample_time is not None: - check(sample_time > 0, RuntimeError, 'Sample time must be strictly positive!') - self.__sample_time = sample_time - else: - if self.__sample_time is None: - self.__sample_time = 1 - - self.__json['Info'] = {"SampleTime": self.__sample_time} - if 'SampleTime' in self.__json['Constants']: - self.__json['Constants']['SampleTime'] = {'dim': 1, 'values': self.__sample_time} - - check(self.__json['Inputs'] != {}, RuntimeError, "No model is defined!") - json_inputs = self.__json['Inputs'] - - input_ns_backward, input_ns_forward = {}, {} - for key, value in json_inputs.items(): - if 'sw' not in value and 'tw' not in value: - assert False, f"Input '{key}' has no time window or sample window" - if 'sw' not in value and self.__sample_time is not None: - ## check if value['tw'] is a multiple of sample_time - absolute_tw = abs(value['tw'][0]) + abs(value['tw'][1]) - check(round(absolute_tw % self.__sample_time) == 0, ValueError, - f"Time window of input '{key}' is not a multiple of sample time. This network cannot be neuralized") - input_ns_backward[key] = round(-value['tw'][0] / self.__sample_time) - input_ns_forward[key] = round(value['tw'][1] / self.__sample_time) - elif self.__sample_time is not None: - if 'tw' in value: - input_ns_backward[key] = max(round(-value['tw'][0] / self.__sample_time), -value['sw'][0]) - input_ns_forward[key] = max(round(value['tw'][1] / self.__sample_time), value['sw'][1]) - else: - input_ns_backward[key] = -value['sw'][0] - input_ns_forward[key] = value['sw'][1] - else: - check(value['tw'] == [0,0], RuntimeError, f"Sample time is not defined for input '{key}'") - input_ns_backward[key] = -value['sw'][0] - input_ns_forward[key] = value['sw'][1] - value['ns'] = [input_ns_backward[key], input_ns_forward[key]] - value['ntot'] = sum(value['ns']) - - self.__json['Info']['ns'] = [max(input_ns_backward.values()), max(input_ns_forward.values())] - self.__json['Info']['ntot'] = sum(self.__json['Info']['ns']) - if self.__json['Info']['ns'][0] < 0: - log.warning( - f"The input is only in the far past the max_samples_backward is: {self.__json['Info']['ns'][0]}") - if self.__json['Info']['ns'][1] < 0: - log.warning( - f"The input is only in the far future the max_sample_forward is: {self.__json['Info']['ns'][1]}") - - for k, v in (self.__json['Parameters'] | self.__json['Constants']).items(): - if 'values' in v: - window = 'tw' if 'tw' in v.keys() else ('sw' if 'sw' in v.keys() else None) - if window == 'tw': - check(np.array(v['values']).shape[0] == v['tw'] / self.__sample_time, ValueError, - f"{k} has a different number of values for this sample time.") - if v['values'] == "SampleTime": - v['values'] = self.__sample_time - - def updateParameters(self, model = None, *, clear_model = False): - if clear_model: - for key in self.__json['Parameters'].keys(): - if 'init_values' in self.__json['Parameters'][key]: - self.__json['Parameters'][key]['values'] = self.__json['Parameters'][key]['init_values'] - elif 'values' in self.__json['Parameters'][key]: - del self.__json['Parameters'][key]['values'] - elif model is not None: - for key in self.__json['Parameters'].keys(): - if key in model.all_parameters: - self.__json['Parameters'][key]['values'] = model.all_parameters[key].tolist() - diff --git a/nnodely/exporter/export.py b/nnodely/exporter/export.py deleted file mode 100644 index fbfa1ce2..00000000 --- a/nnodely/exporter/export.py +++ /dev/null @@ -1,406 +0,0 @@ -import sys, os, torch, importlib, json - -from torch.fx import symbolic_trace - -from pprint import PrettyPrinter - -class JsonPrettyPrinter(PrettyPrinter): - def _format(self, object, *args): - if isinstance(object, str): - width = self._width - self._width = sys.maxsize - try: - super()._format(object.replace('\'','_"_'), *args) - finally: - self._width = width - else: - super()._format(object, *args) - -def save_model(model, model_path): - # Export the dictionary as a JSON file - with open(model_path, 'w') as json_file: - # json.dump(self.model_def, json_file, indent=4) - json_file.write(JsonPrettyPrinter().pformat(model) - .replace('\'', '\"') - .replace('_"_', '\'') - .replace('None', 'null') - .replace('False', 'false') - .replace('True', 'true')) - # json_file.write(JsonPrettyPrinter().pformat(model).replace('None','null')) - # data = json.dumps(self.model_def) - # json_file.write(pformat(data).replace('\\\\n', '\\n').replace('\'', '').replace('(','').replace(')','')) - # json_file.write(pformat(data).replace('\'', '\"')) - -def load_model(model_path): - import json - with open(model_path, 'r', encoding='UTF-8') as file: - model_def = json.load(file) - return model_def - -def export_python_model(model_def, model, model_path): - package_name = __package__.split('.')[0] - - # Get the symbolic tracer - with torch.no_grad(): - trace = symbolic_trace(model) - - recurrent_inputs = {key:value for key, value in model_def['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())} - inputs = {key: value for key, value in model_def['Inputs'].items() if ('closedLoop' not in value.keys() and 'connect' not in value.keys())} - attributes = sorted(set([line for line in trace.code.split() if 'self.' in line])) - - saved_functions = [] - - with open(model_path, 'w') as file: - file.write("import torch\n\n") - - ## write the connect wrap function - # file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n") - # file.write(" virtual = torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n") - # file.write(" max_dim = min(rel.size(1), data_in.size(1))\n") - # file.write(" virtual[:, -max_dim:, :] = rel[:, -max_dim:, :]\n") - # file.write(" return virtual\n\n") - file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n") - file.write(" data_out = data_in.clone()\n") - file.write(" max_dim = min(rel.size(1), data_in.size(1))\n") - file.write(" data_out[:, -max_dim:, :] = rel[:, -max_dim:, :]\n") - file.write(" return data_out\n\n") - - file.write(f"def {package_name}_basic_model_timeshift(data_in):\n") - file.write(" return torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n\n") - - for name in model_def['Functions'].keys(): - if 'Fuzzify' in name: - if 'slicing' not in saved_functions: - #file.write("@torch.fx.wrap\n") - file.write(f"def {package_name}_layers_fuzzify_slicing(res, i, x):\n") - file.write(" res[:, :, i:i+1] = x\n\n") - saved_functions.append('slicing') - - function_name = model_def['Functions'][name]['names'] - function_code = model_def['Functions'][name]['functions'] - if isinstance(function_code, list): - for i, fun_code in enumerate(function_code): - if fun_code != 'Rectangular' and fun_code != 'Triangular': - if function_name[i] not in saved_functions: - fun_code = fun_code.replace(f'def {function_name[i]}', - f'def {package_name}_layers_fuzzify_{function_name[i]}') - #file.write("@torch.fx.wrap\n") - file.write(fun_code) - file.write("\n") - saved_functions.append(function_name[i]) - else: - if (function_name != 'Rectangular') and (function_name != 'Triangular') and (function_name not in saved_functions): - function_code = function_code.replace(f'def {function_name}', - f'def {package_name}_layers_fuzzify_{function_name}') - #file.write("@torch.fx.wrap\n") - file.write(function_code) - file.write("\n") - saved_functions.append(function_name) - - - elif 'ParamFun' in name: - function_name = model_def['Functions'][name]['name'] - if function_name not in saved_functions: - code = model_def['Functions'][name]['code'] - code = code.replace(f'def {function_name}', f'def {package_name}_layers_parametricfunction_{function_name}') - file.write(code) - file.write("\n") - saved_functions.append(function_name) - - elif 'NeuralODE' in name: - function_name = model_def['Functions'][name]['name'] - if function_name not in saved_functions: - code = model_def['Functions'][name]['code'] - code = code.replace(f'def {function_name}', f'def {package_name}_layers_neuralODE_{function_name}') - file.write(code) - file.write("\n") - saved_functions.append(function_name) - - - file.write("class TracerModel(torch.nn.Module):\n") - file.write(" def __init__(self):\n") - file.write(" super().__init__()\n") - file.write(" self.all_parameters = {}\n") - file.write(" self.all_constants = {}\n") - for attr in attributes: - if 'all_constant' in attr: - key = attr.split('.')[-1] - file.write(f" self.all_constants[\"{key}\"] = torch.tensor({model.all_constants[key].tolist()}, requires_grad=False)\n") - elif 'relation_forward' in attr: - key = attr.split('.')[2] - if 'Fir' in key or 'Linear' in key: - if 'weights' in attr.split('.')[3]: - param = model_def['Relations'][key][2] - value = model.all_parameters[param] - file.write(f" self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.tensor({value.tolist()}), requires_grad=True)\n") - elif 'bias' in attr.split('.')[3]: - param = model_def['Relations'][key][3] - file.write(f" self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.tensor({model.all_parameters[param].tolist()}), requires_grad=True)\n") - elif 'dropout' in attr.split('.')[3]: - param = model_def['Relations'][key][4] - file.write(f" self.{key} = torch.nn.Dropout(p={param})\n") - # param = model_def['Relations'][key][2] if 'weights' in attr.split('.')[3] else model_def['Relations'][key][3] - # value = model.all_parameters[param].data.squeeze(0) if 'Linear' in key else model.all_parameters[param].data - # file.write(f" self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.{value}, requires_grad=True)\n") - elif 'Part' in key or 'Select' in key: # any(element in key for element in ['Part', 'Select']): - value = model.relation_forward[key].W - temp_value = json.dumps(value.tolist()) - file.write(f" self.all_constants[\"{key}\"] = torch.tensor({temp_value}, requires_grad=True)\n") - elif 'all_parameters' in attr: - key = attr.split('.')[-1] - file.write(f" self.all_parameters[\"{key}\"] = torch.nn.Parameter(torch.tensor({model.all_parameters[key].tolist()}), requires_grad=True)\n") - elif '_tensor_constant' in attr: - key = attr.split('.')[-1] - file.write(f" {attr} = torch.tensor({getattr(model,key).item()})\n") - - file.write(" self.all_parameters = torch.nn.ParameterDict(self.all_parameters)\n") - file.write(" self.all_constants = torch.nn.ParameterDict(self.all_constants)\n\n") - file.write(" def update(self, closed_loop={}, connect={}, disconnect=False):\n") - file.write(" pass\n") - - for line in trace.code.split("\n")[len(saved_functions) + 2:]: - if 'self.relation_forward' in line: - if 'Part' in line or 'Select' in line: - attribute = [x for x in line.split() if 'self.relation_forward' in x][0].split('.')[2] - old_line = f"self.relation_forward.{attribute}.W" - new_line = f"self.all_constants.{attribute}" - file.write(f" {line.replace(old_line, new_line)}\n") - elif 'dropout' in line: - attribute = line.split()[0] - layer = attribute.split('_')[2].capitalize() - old_line = f"self.relation_forward.{layer}.dropout" - new_line = f"self.{layer}" - file.write(f" {line.replace(old_line, new_line)}\n") - else: - attribute = line.split()[-1] - relation = attribute.split('.')[2] - relation_type = attribute.split('.')[3] - param = model_def['Relations'][relation][2] if 'weights' == relation_type else \ - model_def['Relations'][relation][3] - new_attribute = f'self.all_parameters.{param}' - file.write(f" {line.replace(attribute, new_attribute)}\n") - else: - file.write(f" {line}\n") - - if len(recurrent_inputs) > 0: - file.write("class RecurrentModel(torch.nn.Module):\n") - file.write(" def __init__(self):\n") - file.write(" super().__init__()\n") - file.write(" self.Cell = TracerModel()\n") - list_inputs = " self.inputs = [" - for key in inputs.keys(): - list_inputs += f"'{key}', " - list_inputs += "]\n" - file.write(list_inputs) - file.write(" self.states = dict()\n") - file.write("\n") - file.write(" def forward(self, kwargs, n_samples = None):\n") - file.write(" n_samples = n_samples if n_samples else min([kwargs[key].size(0) for key in self.inputs])\n") - for key in recurrent_inputs.keys(): - file.write(f" self.states['{key}'] = kwargs['{key}']\n") - result_str = "" - for key, value in model_def['Outputs'].items(): - result_str += f"'{key}':[], " - file.write(f" results = {{{result_str}}}\n") - file.write(" X = dict()\n") - file.write(" for idx in range(n_samples):\n") - file.write(f" for key in self.inputs:\n") - file.write(f" X[key] = kwargs[key][idx]\n") - file.write(f" for key, value in self.states.items():\n") - file.write(f" X[key] = value\n") - file.write(" out, _, closed_loop, connect = self.Cell(X)\n") - file.write(" for key, value in results.items():\n") - file.write(" results[key].append(out[key])\n") - file.write(" for key, val in closed_loop.items():\n") - file.write(" self.states[key] = nnodely_basic_model_timeshift(self.states[key])\n") - file.write(" self.states[key] = nnodely_basic_model_update_state(self.states[key], val)\n") - file.write(" for key, val in connect.items():\n") - file.write(" self.states[key] = nnodely_basic_model_timeshift(val)\n") - file.write(" return results\n") - -def export_pythononnx_model(model_def, model_path, model_onnx_path, input_order=None, outputs_order=None): - closed_loop_states, connect_states = [], [] - for key, value in model_def['Inputs'].items(): - if 'closedLoop' in value.keys(): - closed_loop_states.append(key) - if 'connect' in value.keys(): - connect_states.append(key) - - model_inputs = input_order if input_order else list(model_def['Inputs'].keys()) - model_outputs = outputs_order if outputs_order else list(model_def['Outputs'].keys()) - model_losses = [] - if model_def['Minimizers']: - model_losses = [loss_dict['A'] for loss_dict in model_def['Minimizers'].values() if 'A' in loss_dict.keys()] + [loss_dict['B'] for loss_dict in model_def['Minimizers'].values() if 'A' in loss_dict.keys()] - recurrent_inputs = [key for key, value in model_def['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())] - inputs = [key for key in model_inputs if key not in recurrent_inputs] - - # Define the mapping dictionary input - trace_mapping_input = {} - forward = 'def forward(self,' - for i, key in enumerate(model_inputs): - value = f'kwargs[\'{key}\']' - trace_mapping_input[value] = key - forward = forward + f' {key}' + (',' if i < len(model_inputs) - 1 else '') - forward = forward + '):' - # Define the mapping dictionary output - outputs = ' return (' - for i, key in enumerate(model_outputs): - outputs += f'outputs[0][\'{key}\']' + (',' if i < len(model_outputs) - 1 else ',)') - outputs += ', (' - for i, key in enumerate(model_losses): - outputs += f'outputs[1][\'{key}\'], '# + (',' if i < len(model_outputs) - 1 else ',)') - outputs += '), (' - for key in closed_loop_states: - outputs += f'outputs[2][\'{key}\'], ' - outputs += '), (' - for key in connect_states: - outputs += f'outputs[3][\'{key}\'], ' - outputs += ')\n' - - # Open and read the file - file_content = [] - with open(model_path, 'r') as file: - for line in file: - if 'return ({' in line: - file_content.append(line) - break - file_content.append(line) - file_content = ''.join(file_content) - - # Replace the forward header - file_content = file_content.replace('def forward(self, kwargs):', forward) - # Perform the substitution - for key, value in trace_mapping_input.items(): - file_content = file_content.replace(key, value) - # Write the modified content back to a new file - # Replace the return statement - last_return_index = file_content.rfind('return') - if last_return_index != -1: - file_content = file_content[:last_return_index] + 'outputs =' + file_content[last_return_index + len('return'):] - file_content += outputs - with open(model_onnx_path, 'w') as file: - file.write(file_content) - - if len(recurrent_inputs) > 0: - file.write('\n') - file.write("class RecurrentModel(torch.nn.Module):\n") - file.write(" def __init__(self):\n") - file.write(" super().__init__()\n") - file.write(" self.Cell = TracerModel()\n") - - forward_str = " def forward(self, " - for key in model_inputs: - forward_str += f"{key}, " - forward_str += "):\n" - file.write(forward_str) - - if model_inputs: - file.write(" n_samples = min([" + ", ".join([f"{key}.size(0)" for key in inputs]) + "])\n") - else: - file.write(" n_samples = 1\n") - - for key in model_outputs: - file.write(f" results_{key} = []\n") - file.write(" for idx in range(n_samples):\n") - call_str = " out, losses, closed_loop, connect = self.Cell(" - for key in model_inputs: - call_str += f"{key}[idx], " if key in inputs else f"{key}, " - call_str += ")\n" - file.write(call_str) - for idx, key in enumerate(model_outputs): - file.write(f" results_{key}.append(out[{idx}])\n") - for idx, key in enumerate(closed_loop_states): - file.write(f" {key} = nnodely_basic_model_timeshift({key})\n") - file.write(f" {key} = nnodely_basic_model_update_state({key}, closed_loop[{idx}])\n") - for idx, key in enumerate(connect_states): - file.write(f" {key} = nnodely_basic_model_timeshift(connect[{idx}])\n") - #file.write(f" {key} = connect[{idx}]\n") - for idx, key in enumerate(model_outputs): - file.write(f" results_{key} = torch.stack(results_{key}, dim=0)\n") - return_str = " return " - for key in model_outputs: - return_str += f"results_{key}, " - file.write(return_str) - -def import_python_model(name, model_folder): - sys.path.insert(0, model_folder) - module_name = os.path.basename(name) - if module_name in sys.modules: - # Reload the module if it is already loaded - module = importlib.reload(sys.modules[module_name]) - else: - # Import the module if it is not loaded - module = importlib.import_module(module_name) - return module.TracerModel() - -def export_onnx_model(model_def, model, model_path, input_order=None, output_order=None, name='net_onnx'): - sys.path.insert(0, model_path) - module_name = os.path.basename(name) - - recurrent_inputs = {key:value for key, value in model_def['Inputs'].items() if - ('closedLoop' in value.keys() or 'connect' in value.keys())} - inputs = {key:value for key, value in model_def['Inputs'].items() if - ('closedLoop' not in value.keys() and 'connect' not in value.keys())} - - if module_name in sys.modules: - # Reload the module if it is already loaded - module = importlib.reload(sys.modules[module_name]) - else: - # Import the module if it is not loaded - module = importlib.import_module(module_name) - model = torch.jit.script(module.RecurrentModel()) if len(recurrent_inputs) > 0 else module.TracerModel() - model.eval() - dummy_inputs = [] - input_names = [] - dynamic_axes = {} - onnx_inputs = input_order if input_order else model_def['Inputs'].keys() - for key in onnx_inputs: - input_names.append(key) - window_size = model_def['Inputs'][key]['ntot'] - dim = model_def['Inputs'][key]['dim'] - if len(recurrent_inputs) > 0 != {}: - if key in inputs.keys(): - dummy_inputs.append(torch.randn(size=(1, 1, window_size, dim))) - dynamic_axes[key] = {0: 'horizon', 1: 'batch_size'} - elif key in recurrent_inputs.keys(): - dummy_inputs.append(torch.randn(size=(1, window_size, dim))) - dynamic_axes[key] = {0: 'batch_size'} - else: - dummy_inputs.append(torch.randn(size=(1, window_size, dim))) - dynamic_axes[key] = {0: 'batch_size'} - output_names = output_order if output_order else list(model_def['Outputs'].keys()) - dummy_inputs = tuple(dummy_inputs) - - torch.onnx.export( - model, # The model to be exported - dummy_inputs, # Tuple of inputs to match the forward signature - model_path, # File path to save the ONNX model - export_params = True, # Store the trained parameters in the model file - opset_version = 17, # ONNX version to export to (you can use 11 or higher) - do_constant_folding=False, # Optimize constant folding for inference - input_names = input_names, # Name each input as they will appear in ONNX - output_names = output_names, # Name the output - dynamic_axes = dynamic_axes, - ) - -def onnx_inference(inputs, path, optimize_graph=False): - import onnxruntime as ort - # Create an ONNX Runtime session - # Define session options - ## TODO: Warning when using constant folding in inference CanUpdateImplicitInputNameInSubgraphs] - ## TODO: Implicit input name Cell.all_constants.Constant75 cannot be safely updated to Cell.all_constants.Constant76 in one of the subgraphs. - if optimize_graph == False: - session_options = ort.SessionOptions() - # Set graph optimization level to disable all optimizations - session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_DISABLE_ALL - session = ort.InferenceSession(path, sess_options=session_options) - else: - session = ort.InferenceSession(path) - output_data = [] - for item in session.get_outputs(): - output_data.append(item.name) - input_data = {} - for item in session.get_inputs(): - input_data[item.name] = inputs[item.name] - # Run inference - return session.run(output_data, input_data) \ No newline at end of file diff --git a/nnodely/exporter/reporter.py b/nnodely/exporter/reporter.py deleted file mode 100644 index 31f1e35a..00000000 --- a/nnodely/exporter/reporter.py +++ /dev/null @@ -1,55 +0,0 @@ -import io - -import matplotlib.pyplot as plt -from reportlab.lib.pagesizes import letter -from reportlab.pdfgen import canvas -from reportlab.lib.utils import ImageReader - -from mplplots import plots - - -class Reporter: - def __init__(self, modely): - self.modely = modely - - def exportReport(self, report_path): - c = canvas.Canvas(report_path, pagesize=letter) - width, height = letter - - if 'Minimizers' in self.modely._model_def: - for key, value in self.modely._model_def['Minimizers'].items(): - fig = plt.figure(figsize=(10, 5)) - ax = fig.add_subplot(111) - if 'val' in self.modely._training[key]: - plots.plot_training(ax, f"Training Loss of {key}", key, self.modely._training[key]['train'], self.modely._training[key]['val']) - else: - plots.plot_training(ax, f"Training Loss of {key}", key, self.modely._training[key]['train']) - training = io.BytesIO() - plt.savefig(training, format='png') - training.seek(0) - plt.close() - c.drawString(100, height - 30, f"Training Loss of {key}") - c.drawImage(ImageReader(training), 50, height - 290, width=500, height=250) - c.showPage() - - if len(self.modely.prediction) > 0: - for key in self.modely._model_def['Minimizers'].keys(): - c.drawString(100, height - 30, f"Prediction of {key}") - for ind, name_data in enumerate(self.modely.prediction.keys()): - fig = plt.figure(figsize=(10, 5)) - ax = fig.add_subplot(111) - idxs = None - if 'idxs' in self.modely.prediction[name_data]: - idxs = self.modely.prediction[name_data]['idxs'] - plots.plot_results(ax, name_data, key, self.modely.prediction[name_data][key]['A'], - self.modely.prediction[name_data][key]['B'], idxs, self.modely._model_def['Info']["SampleTime"]) - # Add a text box with correlation coefficient - results = io.BytesIO() - plt.savefig(results, format='png') - results.seek(0) - plt.close() - c.drawImage(ImageReader(results), 50, height - 290 - 245*ind, width=500, height=250) - c.showPage() - else: - c.drawString(100, height - 30, f"No Minimize") - c.save() diff --git a/nnodely/exporter/standardexporter.py b/nnodely/exporter/standardexporter.py deleted file mode 100644 index 7db7ba59..00000000 --- a/nnodely/exporter/standardexporter.py +++ /dev/null @@ -1,117 +0,0 @@ -import os, torch - -from nnodely.visualizer import EmptyVisualizer -from nnodely.exporter.emptyexporter import EmptyExporter -from nnodely.exporter.reporter import Reporter -from nnodely.exporter.export import save_model, load_model, export_python_model, export_pythononnx_model, export_onnx_model, import_python_model, onnx_inference -from nnodely.support.utils import check, enforce_types - -from nnodely.support.logger import logging, nnLogger -log = nnLogger(__name__, logging.INFO) - -class StandardExporter(EmptyExporter): - @enforce_types - def __init__(self, workspace:str|None=None, visualizer:EmptyVisualizer|None=None, *, save_history:bool=False): - super().__init__(workspace, visualizer, save_history) - - def getWorkspace(self): - return self.workspace_folder if hasattr(self,'workspace_folder') else '.' - - def saveTorchModel(self, model, name = 'net', model_folder = None): - file_name = name + ".pt" - model_path = os.path.join(self.getWorkspace(), file_name) if model_folder is None else os.path.join(model_folder,file_name) - #TODO check if the folder exist - torch.save(model.state_dict(), model_path) - self.visualizer.saveModel('Torch Model', model_path) - - def loadTorchModel(self, model, name = 'net', model_folder = None): - file_name = name + ".pt" - model_path = os.path.join(self.getWorkspace(), file_name) if model_folder is None else os.path.join(model_folder,file_name) - check(os.path.exists(model_path), FileNotFoundError, f"The model {name} it is not found in the folder {model_folder}") - model.load_state_dict(torch.load(model_path, weights_only=True)) - self.visualizer.loadModel('Torch Model',model_path) - #TODO Update the model parameters.... - - def saveModel(self, model_def, name = 'net', model_folder = None): - # Combine the folder path and file name to form the complete file path - model_folder = self.getWorkspace() if model_folder is None else model_folder - # Specify the JSON file name - file_name = name + ".json" - # Combine the folder path and file name to form the complete file path - model_path = os.path.join(model_folder, file_name) - save_model(model_def, model_path) - self.visualizer.saveModel('JSON Model', model_path) - - def loadModel(self, name = 'net', model_folder = None): - # Combine the folder path and file name to form the complete file path - model_folder = self.getWorkspace() if model_folder is None else model_folder - model_def = None - try: - file_name = name + ".json" - model_path = os.path.join(model_folder, file_name) - model_def = load_model(model_path) - self.visualizer.loadModel('JSON Model', model_path) - except Exception as e: - check(False, FileNotFoundError, f"The file {model_path} it is not found or not conformed.\n Error: {e}") - return model_def - - def exportPythonModel(self, model_def, model, name = 'net', model_folder = None): - file_name = name + ".py" - model_path = os.path.join(self.getWorkspace(), file_name) if model_folder is None else os.path.join(model_folder, file_name) - ## Export to python file - export_python_model(model_def.getJson(), model, model_path) - self.visualizer.exportModel('Python Torch Model', model_path) - - def importPythonModel(self, name = 'net', model_folder = None): - try: - model_folder = self.getWorkspace() if model_folder is None else model_folder - model = import_python_model(name, model_folder) - self.visualizer.importModel('Python Torch Model', os.path.join(model_folder,name+'.py')) - except Exception as e: - model = None - check(False, FileNotFoundError, f"The model {name} it is not found in the folder {model_folder}.\nError: {e}") - return model - - def exportONNX(self, model_def, model, inputs_order=None, outputs_order=None, name = 'net', model_folder = None): - if inputs_order is None: - log.info(f"The inputs order for the export is not specified, the order will set equal to {set(model_def['Inputs'].keys())}.") - elif set(inputs_order) != set(model_def['Inputs'].keys()): - raise ValueError(f'The inputs are not the same as the model inputs {set(model_def["Inputs"].keys())}.') - if outputs_order is None: - log.info(f"The outputs order for the export is not specified, the order will set equal to {set(model_def['Outputs'].keys())}") - elif set(outputs_order) != set(model_def['Outputs'].keys()): - log.info(f'The outputs are not the same as the model outputs {set(model_def["Outputs"].keys())}.') - file_name = name + ".py" - model_folder = os.path.join(self.getWorkspace(), 'onnx') if model_folder is None else model_folder - os.makedirs(model_folder, exist_ok=True) - model_path = os.path.join(model_folder, file_name) - onnx_python_model_path = model_path.replace('.py', '_onnx.py') - onnx_model_path = model_path.replace('.py', '.onnx') - ## Export to python file (onnx compatible) - export_python_model(model_def, model, model_path) - self.visualizer.exportModel('Python Torch Model', model_path) - export_pythononnx_model(model_def, model_path, onnx_python_model_path, inputs_order, outputs_order) - self.visualizer.exportModel('Python Onnx Torch Model', onnx_python_model_path) - ## Export to onnx file (onnx compatible) - model = import_python_model(file_name.replace('.py', '_onnx'), model_folder) - export_onnx_model(model_def, model, onnx_model_path, inputs_order, outputs_order, name=name+'_onnx') - self.visualizer.exportModel('Onnx Model', onnx_model_path) - - def onnxInference(self, inputs, name:str='net', model_folder:str|None=None): - model_folder = os.path.join(self.getWorkspace(), 'onnx') if model_folder is None else model_folder - file_name = name + ".onnx" - onnx_model_path = os.path.join(model_folder, file_name) - check(os.path.exists(onnx_model_path), FileNotFoundError, f"The model {file_name} it is not found in the folder {model_folder}") - return onnx_inference(inputs, onnx_model_path) - - def exportReport(self, n4m, name = 'net', model_folder = None): - # Combine the folder path and file name to form the complete file path - model_folder = self.getWorkspace() if model_folder is None else model_folder - # Specify the JSON file name - file_name = name + ".pdf" - # Combine the folder path and file name to form the complete file path - report_path = os.path.join(model_folder, file_name) - reporter = Reporter(n4m) - reporter.exportReport(report_path) - self.visualizer.exportReport('Training Results', report_path) - diff --git a/nnodely/layers/arithmetic.py b/nnodely/layers/arithmetic.py deleted file mode 100644 index 0b2f5877..00000000 --- a/nnodely/layers/arithmetic.py +++ /dev/null @@ -1,332 +0,0 @@ -import torch.nn as nn -import torch - -from nnodely.basic.relation import ToStream, Stream, toStream -from nnodely.basic.model import Model -from nnodely.support.utils import check, enforce_types -from nnodely.layers.parameter import Parameter, Constant -from nnodely.support.jsonutils import merge, binary_cheks - - -# Binary operators -add_relation_name = 'Add' -sub_relation_name = 'Sub' -mul_relation_name = 'Mul' -div_relation_name = 'Div' -pow_relation_name = 'Pow' - -# Unary operators -neg_relation_name = 'Neg' -sign_relation_name = 'Sign' - -# Merge operator -sum_relation_name = 'Sum' - -class Add(Stream, ToStream): - """ - Implement the addition function between two tensors. - (it is also possible to use the classical math operator '+') - - See also: - Official PyTorch Add documentation: - `torch.add `_ - - :param input1: the first element of the addition - :type obj: Tensor - :param input2: the second element of the addition - :type obj: Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/add.rst - """ - @enforce_types - def __init__(self, obj1:Stream|Parameter|Constant|int|float, obj2:Stream|Parameter|Constant|int|float) -> Stream: - obj1, obj2, dim = binary_cheks(self, obj1, obj2, 'addition operators (+)') - super().__init__(add_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [add_relation_name,[obj1.name,obj2.name]] - -## TODO: check the scalar dimension, helpful for the offset -class Sub(Stream, ToStream): - """ - Implement the subtraction function between two tensors. - (it is also possible to use the classical math operator '-') - - :param input1: the first element of the subtraction - :type obj: Tensor - :param input2: the second element of the subtraction - :type obj: Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst - """ - @enforce_types - def __init__(self, obj1:Stream|Parameter|Constant|int|float, obj2:Stream|Parameter|Constant|int|float) -> Stream: - obj1, obj2, dim = binary_cheks(self, obj1, obj2, 'subtraction operators (-)') - super().__init__(sub_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [sub_relation_name,[obj1.name,obj2.name]] - -class Mul(Stream, ToStream): - """ - Implement the multiplication function between two tensors. - (it is also possible to use the classical math operator '*') - - :param input1: the first element of the multiplication - :type obj: Tensor - :param input2: the second element of the multiplication - :type obj: Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst - """ - @enforce_types - def __init__(self, obj1:Stream|Parameter|Constant|int|float, obj2:Stream|Parameter|Constant|int|float) -> Stream: - obj1, obj2, dim = binary_cheks(self, obj1, obj2, 'multiplication operators (*)') - super().__init__(mul_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [mul_relation_name,[obj1.name,obj2.name]] - -class Div(Stream, ToStream): - """ - Implement the division function between two tensors. - (it is also possible to use the classical math operator '/') - - :param input1: the numerator of the division - :type obj: Tensor - :param input2: the denominator of the division - :type obj: Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/div.rst - """ - @enforce_types - def __init__(self, obj1:Stream|Parameter|Constant|int|float, obj2:Stream|Parameter|Constant|int|float) -> Stream: - obj1, obj2, dim = binary_cheks(self, obj1, obj2, 'division operators (/) ') - super().__init__(div_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [div_relation_name,[obj1.name,obj2.name]] - -class Pow(Stream, ToStream): - """ - Implement the power function given an input and an exponent. - (it is also possible to use the classical math operator '**') - - See also: - Official PyTorch pow documentation: - `torch.pow `_ - - :param input: the base of the power function - :type obj: Tensor - :param exp: the exponent of the power function - :type obj: float or Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst - """ - @enforce_types - def __init__(self, obj1:Stream|Parameter|Constant|int|float, obj2:Stream|Parameter|Constant|int|float) -> Stream: - obj1, obj2, dim = binary_cheks(self, obj1, obj2, 'pow operators (**)') - super().__init__(pow_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [pow_relation_name,[obj1.name,obj2.name]] - -class Neg(Stream, ToStream): - """ - Implement the negate function given an input. - - :param input: the input to negate - :type obj: Tensor - - Example: - -------- - .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst - """ - @enforce_types - def __init__(self, obj:Stream|Parameter|Constant) -> Stream: - obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for neg operation.") - super().__init__(neg_relation_name+str(Stream.count), obj.json, obj.dim) - self.json['Relations'][self.name] = [neg_relation_name,[obj.name]] - -class Sign(Stream, ToStream): - """ - Implement the sign function given an input. - - :param input: the input for the sign function - :type obj: Tensor - - Example: - >>> x = Sign(x) - """ - @enforce_types - def __init__(self, obj:Stream|Parameter|Constant) -> Stream: - obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for sign operation.") - super().__init__(sign_relation_name+str(Stream.count), obj.json, obj.dim) - self.json['Relations'][self.name] = [sign_relation_name,[obj.name]] - -class Sum(Stream, ToStream): - @enforce_types - def __init__(self, obj:Stream|Parameter|Constant) -> Stream: - obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for sum operation.") - obj.dim['dim'] = 1 - super().__init__(sum_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [sum_relation_name,[obj.name]] - -class Add_Layer(nn.Module): - #: :noindex: - def __init__(self): - super(Add_Layer, self).__init__() - - def forward(self, *inputs): - results = inputs[0] - for input in inputs[1:]: - results = results + input - return results - -def createAdd(name, *inputs): - """ - :noindex: - """ - return Add_Layer() - -class Sub_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Sub_Layer, self).__init__() - - def forward(self, *inputs): - # Perform element-wise subtraction - results = inputs[0] - for input in inputs[1:]: - results = results - input - return results - -def createSub(self, *inputs): - """ - :noindex: - """ - return Sub_Layer() - - -class Mul_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Mul_Layer, self).__init__() - - def forward(self, *inputs): - results = inputs[0] - for input in inputs[1:]: - results = results * input - return results - -def createMul(name, *inputs): - """ - :noindex: - """ - return Mul_Layer() - -class Div_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Div_Layer, self).__init__() - - def forward(self, *inputs): - results = inputs[0] - for input in inputs[1:]: - results = results / input - return results - -def createDiv(name, *inputs): - """ - :noindex: - """ - return Div_Layer() - -class Pow_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Pow_Layer, self).__init__() - - def forward(self, *inputs): - return torch.pow(inputs[0], inputs[1]) - -def createPow(name, *inputs): - """ - :noindex: - """ - return Pow_Layer() - -class Neg_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Neg_Layer, self).__init__() - - def forward(self, x): - return -x - -def createNeg(self, *inputs): - """ - :noindex: - """ - return Neg_Layer() - -class Sign_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Sign_Layer, self).__init__() - - def forward(self, x): - return torch.sign(x) - -def createSign(self, *inputs): - """ - :noindex: - """ - return Sign_Layer() - -class Sum_Layer(nn.Module): - """ - :noindex: - """ - def __init__(self): - super(Sum_Layer, self).__init__() - - def forward(self, inputs): - return torch.sum(inputs, dim = 2, keepdim = True) - -def createSum(name, *inputs): - """ - :noindex: - """ - return Sum_Layer() - -setattr(Model, add_relation_name, createAdd) -setattr(Model, sub_relation_name, createSub) -setattr(Model, mul_relation_name, createMul) -setattr(Model, div_relation_name, createDiv) -setattr(Model, pow_relation_name, createPow) - -setattr(Model, neg_relation_name, createNeg) -setattr(Model, sign_relation_name, createSign) - -setattr(Model, sum_relation_name, createSum) - - diff --git a/nnodely/layers/localmodel.py b/nnodely/layers/localmodel.py deleted file mode 100644 index 095cd0b9..00000000 --- a/nnodely/layers/localmodel.py +++ /dev/null @@ -1,110 +0,0 @@ -import inspect - -from collections.abc import Callable - -from nnodely.basic.relation import NeuObj, Stream -from nnodely.layers.part import Select -from nnodely.support.utils import check, enforce_types - -localmodel_relation_name = 'LocalModel' - -class LocalModel(NeuObj): - """ - Represents a Local Model relation in the neural network model. - - Parameters - ---------- - input_function : Callable, optional - A callable function to process the inputs. - output_function : Callable, optional - A callable function to process the outputs. - pass_indexes : bool, optional - A boolean indicating whether to pass indexes to the functions. Default is False. - - Attributes - ---------- - relation_name : str - The name of the relation. - pass_indexes : bool - A boolean indicating whether to pass indexes to the functions. - input_function : Callable - The function to process the inputs. - output_function : Callable - The function to process the outputs. - - Examples - -------- - - .. include:: /examples_basics/layer_module_ex/localmodel.rst - """ - @enforce_types - def __init__(self, input_function:Callable|None = None, - output_function:Callable|None = None, *, - pass_indexes:bool = False): - - self.relation_name = localmodel_relation_name - self.pass_indexes = pass_indexes - super().__init__(localmodel_relation_name + str(NeuObj.count)) - self.json['Functions'][self.name] = {} - if input_function is not None: - check(callable(input_function), TypeError, 'The input_function must be callable') - self.input_function = input_function - if output_function is not None: - check(callable(output_function), TypeError, 'The output_function must be callable') - self.output_function = output_function - - @enforce_types - def __call__(self, inputs:Stream|tuple, activations:Stream|tuple= None): - out_sum = [] - if type(activations) is not tuple: - activations = (activations,) - self.___activations_matrix(activations,inputs,out_sum) - - out = out_sum[0] - for ind in range(1,len(out_sum)): - out = out + out_sum[ind] - return out - - # Definisci una funzione ricorsiva per annidare i cicli for - def ___activations_matrix(self, activations, inputs, out, idx=0, idx_list=[]): - if idx != len(activations): - for i in range(activations[idx].dim['dim']): - self.___activations_matrix(activations, inputs, out, idx+1, idx_list+[i]) - else: - if self.input_function is not None: - if len(inspect.signature(self.input_function).parameters) == 0: - if type(inputs) is tuple: - out_in = self.input_function()(*inputs) - else: - out_in = self.input_function()(inputs) - else: - if self.pass_indexes: - if type(inputs) is tuple: - out_in = self.input_function(idx_list)(*inputs) - else: - out_in = self.input_function(idx_list)(inputs) - else: - if type(inputs) is tuple: - out_in = self.input_function(*inputs) - else: - out_in = self.input_function(inputs) - else: - check(type(inputs) is not tuple, TypeError, 'The input cannot be a tuple without input_function') - out_in = inputs - - act = Select(activations[0], idx_list[0]) - for ind, i in enumerate(idx_list[1:]): - act = act * Select(activations[ind+1], i) - - prod = out_in * act - - if self.output_function is not None: - if len(inspect.signature(self.output_function).parameters) == 0: - out.append(self.output_function()(prod)) - else: - if self.pass_indexes: - out.append(self.output_function(idx_list)(prod)) - else: - out.append(self.output_function(prod)) - else: - out.append(prod) diff --git a/nnodely/operators/network.py b/nnodely/operators/network.py deleted file mode 100644 index 2d60497c..00000000 --- a/nnodely/operators/network.py +++ /dev/null @@ -1,426 +0,0 @@ -import copy -from collections import defaultdict - -import numpy as np -import torch, random - -from nnodely.support.utils import TORCH_DTYPE, NP_DTYPE, check, enforce_types, tensor_to_list -from nnodely.basic.modeldef import ModelDef - -from nnodely.support.logger import logging, nnLogger -log = nnLogger(__name__, logging.WARNING) - -class Network: - @enforce_types - def __init__(self): - check(type(self) is not Network, TypeError, "Loader class cannot be instantiated directly") - - # Models definition - self._model_def = ModelDef() - self._model = None - self._neuralized = False - self._traced = False - - # Model components - self._states = {} - self._input_n_samples = {} - self._input_ns_backward = {} - self._input_ns_forward = {} - self._max_samples_backward = None - self._max_samples_forward = None - self._max_n_samples = 0 - - # Dataset information - self._data_loaded = False - self._file_count = 0 - self._num_of_samples = {} - self._data = {} - self._multifile = {} - - # Training information - self._standard_train_parameters = { - 'models': None, - 'train_dataset': None, 'validation_dataset': None, - 'dataset': None, 'splits': [100, 0, 0], - 'closed_loop': {}, 'connect': {}, 'step': 0, 'prediction_samples': 0, - 'shuffle_data': True, - 'early_stopping': None, 'early_stopping_params': {}, - 'select_model': 'last', 'select_model_params': {}, - 'minimize_gain': {}, - 'num_of_epochs': 100, - 'train_batch_size': 128, 'val_batch_size': 128, - 'optimizer': 'Adam', - 'lr': 0.001, 'lr_param': {}, - 'optimizer_params': [], 'add_optimizer_params': [], - 'optimizer_defaults': {}, 'add_optimizer_defaults': {} - } - self._training = {} - - # Save internal - self._log_internal = False - self._internals = {} - - def _save_internal(self, key, value): - self._internals[key] = tensor_to_list(value) - - def _set_log_internal(self, log_internal:bool): - self._log_internal = log_internal - - def _clean_log_internal(self): - self._internals = {} - - def _remove_virtual_states(self, connect, closed_loop): - if connect or closed_loop: - for key in (connect.keys() | closed_loop.keys()): - if key in self._states.keys(): - del self._states[key] - - def _update_state(self, X, out_closed_loop, out_connect): - for key, value in out_connect.items(): - X[key] = torch.roll(value, shifts=-1, dims=1) ## Roll the time window - X[key][:, -1, :] = float('inf') ## inf value to make clear that the last state value - self._states[key] = X[key].clone().detach() - for key, val in out_closed_loop.items(): - shift = val.shape[1] #+ self._input_ns_forward[key] ## take the output time dimension + forward samples - X[key] = torch.roll(X[key], shifts=-1, dims=1) ## Roll the time window - X[key][:, -shift:, :] = val ## substitute with the predicted value - self._states[key] = X[key].clone().detach() - - def _get_gradient_on_inference(self): - for key, value in self._model_def['Inputs'].items(): - if 'type' in value.keys(): - return True - return False - - def _get_mandatory_inputs(self, connect, closed_loop): - model_inputs = list(self._model_def['Inputs'].keys()) - non_mandatory_inputs = list(closed_loop.keys()) + list(connect.keys()) + list(self._model_def.recurrentInputs().keys()) - mandatory_inputs = list(set(model_inputs) - set(non_mandatory_inputs)) - return mandatory_inputs, non_mandatory_inputs - - def _get_batch_indexes(self, datasets:str|list|dict|None, n_samples:int=0, prediction_samples:int=0): - if datasets is None: - return [] - batch_indexes = list(range(n_samples)) - if prediction_samples > 0 and not isinstance(datasets, dict): - datasets = [datasets] if type(datasets) is str else datasets - forbidden_idxs = [] - n_samples_count = 0 - for dataset in datasets: - if dataset in self._multifile.keys(): ## i have some forbidden indexes - for i in self._multifile[dataset]: - if i+n_samples_count < batch_indexes[-1]: - forbidden_idxs.extend(range((i+n_samples_count) - prediction_samples, (i+n_samples_count), 1)) - n_samples_count += self._num_of_samples[dataset] - batch_indexes = [idx for idx in batch_indexes if idx not in forbidden_idxs] - batch_indexes = batch_indexes[:-prediction_samples] - return batch_indexes - - def _get_data(self, dataset:str|list|dict|None): - if dataset is None: - return {} - if isinstance(dataset, dict): - self.__check_data_integrity(dataset) - return dataset - dataset = [dataset] if type(dataset) is str else dataset - loaded_datasets = list(self._data.keys()) - check(len([data for data in dataset if data in loaded_datasets]) > 0, KeyError, f'the datasets: {dataset} are not loaded!') - total_data = defaultdict(list) - for data in dataset: - if data not in loaded_datasets: - log.warning(f'{data} is not loaded. Ignoring this dataset...') - dataset.remove(data) - continue - for k, v in self._data[data].items(): - total_data[k].append(v) - total_data = {key: np.concatenate(arrays) for key, arrays in total_data.items()} - total_data = {key: torch.from_numpy(val).to(TORCH_DTYPE) for key, val in total_data.items()} - return total_data - - def _clip_step(self, step, batch_indexes, batch_size): - clipped_step = copy.deepcopy(step) - if clipped_step < 0: ## clip the step to zero - log.warning(f"The step is negative ({clipped_step}). The step is set to zero.", stacklevel=5) - clipped_step = 0 - if clipped_step > (len(batch_indexes) - batch_size): ## Clip the step to the maximum number of samples - log.warning(f"The step ({clipped_step}) is greater than the number of available samples ({len(batch_indexes) - batch_size}). The step is set to the maximum number.", stacklevel=5) - clipped_step = len(batch_indexes) - batch_size - check((batch_size + clipped_step) > 0, ValueError, f"The sum of batch_size={batch_size} and the step={clipped_step} must be greater than 0.") - return clipped_step - - def _clip_batch_size(self, n_samples, batch_size=None): - batch_size = batch_size if batch_size <= n_samples else max(0, n_samples) - check((n_samples - batch_size + 1) > 0, ValueError, f"The number of available sample are {n_samples - batch_size + 1}") - check(batch_size > 0, ValueError, f'The batch_size must be greater than 0.') - return batch_size - - def __split_dataset(self, dataset:str|list|dict, splits:list): - check(len(splits) == 3, ValueError, '3 elements must be inserted for the dataset split in training, validation and test') - check(sum(splits) == 100, ValueError, 'Training, Validation and Test splits must sum up to 100.') - check(splits[0] > 0, ValueError, 'The training split cannot be zero.') - train_size, val_size, test_size = splits[0] / 100, splits[1] / 100, splits[2] / 100 - XY_train, XY_val, XY_test = {}, {}, {} - if isinstance(dataset, dict): - self.__check_data_integrity(dataset) - num_of_samples = next(iter(dataset.values())).size(0) - XY_train = {key: value[:round(num_of_samples*train_size), :, :] for key, value in dataset.items()} - XY_val = {key: value[round(num_of_samples*train_size):round(num_of_samples*(train_size + val_size)), :, :] for key, value in dataset.items()} - XY_test = {key: value[round(num_of_samples*(train_size + val_size)):, :, :] for key, value in dataset.items()} - else: - dataset = [dataset] if type(dataset) is str else dataset - check(len([data for data in dataset if data in self._data.keys()]) > 0, KeyError, f'the datasets: {dataset} are not loaded!') - for data in dataset: - if data not in self._data.keys(): - log.warning(f'{data} is not loaded. The training will continue without this dataset.') - dataset.remove(data) - - num_of_samples = sum([self._num_of_samples[data] for data in dataset]) - n_samples_train, n_samples_val = round(num_of_samples * train_size), round(num_of_samples * val_size) - n_samples_test = num_of_samples - n_samples_train - n_samples_val - check(n_samples_train > 0, ValueError, f'The number of train samples {n_samples_train} must be greater than 0.') - total_data = defaultdict(list) - for data in dataset: - for k, v in self._data[data].items(): - total_data[k].append(v) - total_data = {key: np.concatenate(arrays, dtype=NP_DTYPE) for key, arrays in total_data.items()} - for key, samples in total_data.items(): - if val_size == 0.0 and test_size == 0.0: ## we have only training set - XY_train[key] = torch.from_numpy(samples).to(TORCH_DTYPE) - elif val_size == 0.0 and test_size != 0.0: ## we have only training and test set - XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to(TORCH_DTYPE) - XY_test[key] = torch.from_numpy(samples[n_samples_train:]).to(TORCH_DTYPE) - elif val_size != 0.0 and test_size == 0.0: ## we have only training and validation set - XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to(TORCH_DTYPE) - XY_val[key] = torch.from_numpy(samples[n_samples_train:]).to(TORCH_DTYPE) - else: ## we have training, validation and test set - XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to(TORCH_DTYPE) - XY_val[key] = torch.from_numpy(samples[n_samples_train:-n_samples_test]).to(TORCH_DTYPE) - XY_test[key] = torch.from_numpy(samples[n_samples_train + n_samples_val:]).to(TORCH_DTYPE) - return XY_train, XY_val, XY_test - - def _get_tag(self, dataset: str | list | dict | None) -> str: - """ - Helper function to get the tag for a dataset. - """ - if isinstance(dataset, str): - return dataset - elif isinstance(dataset, list): - return f"{dataset[0]}_{len(dataset)}" if len(dataset) > 1 else f"{dataset[0]}" - elif isinstance(dataset, dict): - return "custom_dataset" - return dataset - - def _setup_dataset(self, train_dataset:str|list|dict, validation_dataset:str|list|dict, test_dataset:str|list|dict, dataset:str|list|dict, splits:list): - if train_dataset is None: ## use the splits - train_dataset = list(self._data.keys()) if dataset is None else dataset - return self.__split_dataset(train_dataset, splits) - else: ## use each dataset - return self._get_data(train_dataset), self._get_data(validation_dataset), self._get_data(test_dataset) - - def __check_data_integrity(self, dataset:dict): - if bool(dataset): - check(len(set([t.size(0) for t in dataset.values()])) == 1, ValueError, "All the tensors in the dataset must have the same number of samples.") - #TODO check why is wrong - #check(len([t for t in self._model_def['Inputs'].keys() if t in dataset.keys()]) == len(list(self._model_def['Inputs'].keys())), ValueError, "Some inputs are missing.") - for key, value in dataset.items(): - if key not in self._model_def['Inputs']: - log.warning(f"The key '{key}' is not an input of the network. It will be ignored.") - else: - check(isinstance(value, torch.Tensor), TypeError, f"The value of the input '{key}' must be a torch.Tensor.") - check(value.size(1) == self._model_def['Inputs'][key]['ntot'], ValueError, f"The time size of the input '{key}' is not correct. Expected {self._model_def['Inputs'][key]['ntot']}, got {value.size(1)}.") - check(value.size(2) == self._model_def['Inputs'][key]['dim'], ValueError, f"The dimension of the input '{key}' is not correct. Expected {self._model_def['Inputs'][key]['dim']}, got {value.size(2)}.") - - def _get_not_mandatory_inputs(self, data, X, non_mandatory_inputs, remaning_indexes, batch_size, step, shuffle = False): - related_indexes = random.sample(remaning_indexes, batch_size) if shuffle else remaning_indexes[:batch_size] - for num in related_indexes: - remaning_indexes.remove(num) - if step > 0: - if len(remaning_indexes) >= step: - step_idxs = random.sample(remaning_indexes, step) if shuffle else remaning_indexes[:step] - for num in step_idxs: - remaning_indexes.remove(num) - else: - remaning_indexes.clear() - for key in non_mandatory_inputs: - if key in data.keys(): ## with data - X[key] = data[key][related_indexes] - else: ## with zeros - window_size = self._input_n_samples[key] - dim = self._model_def['Inputs'][key]['dim'] - if 'type' in self._model_def['Inputs'][key]: - X[key] = torch.zeros(size=(batch_size, window_size, dim), dtype=TORCH_DTYPE, requires_grad=True) - else: - X[key] = torch.zeros(size=(batch_size, window_size, dim), dtype=TORCH_DTYPE, requires_grad=False) - self._states[key] = X[key] - return related_indexes - - def _inference(self, data, n_samples, batch_size, loss_gains, loss_functions, - shuffle = False, optimizer = None, - total_losses = None, A = None, B = None): - if shuffle: - randomize = torch.randperm(n_samples) - data = {key: val[randomize] for key, val in data.items()} - - ## Initialize the train losses vector - aux_losses = torch.zeros([len(self._model_def['Minimizers']), n_samples // batch_size]) - for idx in range(0, (n_samples - batch_size + 1), batch_size): - ## Build the input tensor - XY = {} - for key, val in data.items(): - if self._model_def['Inputs'].get(key, None): - if self._model_def['Inputs'][key].get('type', None) == 'derivate': - XY[key] = val[idx:idx + batch_size].detach().requires_grad_(True) - else: - XY[key] = val[idx:idx + batch_size] - #XY = {key: val[idx:idx + batch_size].detach().requires_grad_(True) for key, val in data.items()} - for key in self._model_def.recurrentInputs().keys(): - if key not in XY.keys(): - window_size = self._input_n_samples[key] - dim = self._model_def['Inputs'][key]['dim'] - XY[key] = torch.zeros(size=(batch_size, window_size, dim), dtype=TORCH_DTYPE, requires_grad=True) - ## Reset gradient - if optimizer: - optimizer.zero_grad() - ## Model Forward - out, minimize_out, _, _ = self._model(XY) ## Forward pass - - if self._log_internal: - internals_dict = {'XY': tensor_to_list(XY), 'out': out, 'param': self._model.all_parameters} - - ## Loss Calculation - total_loss = 0 - for ind, (key, value) in enumerate(self._model_def['Minimizers'].items()): - if A is not None: - A[key].append(minimize_out[value['A']].detach().numpy()) - if B is not None: - B[key].append(minimize_out[value['B']].detach().numpy()) - loss = loss_functions[key](minimize_out[value['A']], minimize_out[value['B']]) - loss = (loss * loss_gains[key]) if key in loss_gains.keys() else loss - if total_losses is not None: - total_losses[key].append(loss.detach().numpy()) - aux_losses[ind][idx // batch_size] = loss.item() - total_loss += loss - - if self._log_internal: - self._save_internal('inout_' + str(idx), internals_dict) - - ## Gradient step - if optimizer: - total_loss.backward() ## Backpropagate the error - optimizer.step() - self.visualizer.showWeightsInTrain(batch=idx // batch_size) - - ## return the losses - return aux_losses - - def _recurrent_inference(self, data, batch_indexes, batch_size, loss_gains, prediction_samples, - step, non_mandatory_inputs, mandatory_inputs, loss_functions, - shuffle = False, optimizer = None, - total_losses = None, A = None, B = None, idxs = None): - indexes = copy.deepcopy(batch_indexes) - aux_losses = torch.zeros([len(self._model_def['Minimizers']), round((len(indexes) + step) / (batch_size + step))]) - X = {} - batch_idx = 0 - while len(indexes) >= batch_size: - selected_indexes = self._get_not_mandatory_inputs(data, X, non_mandatory_inputs, indexes, batch_size, step, shuffle) - horizon_losses = {ind: [] for ind in range(len(self._model_def['Minimizers']))} - if optimizer: - optimizer.zero_grad() ## Reset the gradient - - for horizon_idx in range(prediction_samples + 1): - # Save the indexes - if idxs is not None: - idxs[horizon_idx].append([idx + horizon_idx for idx in selected_indexes]) - ## Get data - for key in mandatory_inputs: - X[key] = data[key][[idx + horizon_idx for idx in selected_indexes]] - ## Forward pass - out, minimize_out, out_closed_loop, out_connect = self._model(X) - - if self._log_internal: - internals_dict = {'XY': tensor_to_list(X), 'out': out, 'param': self._model.all_parameters, - 'closedLoop': self._model.closed_loop_update, 'connect': self._model.connect_update} - - ## Loss Calculation - for ind, (key, value) in enumerate(self._model_def['Minimizers'].items()): - if A is not None: - A[key][horizon_idx].append(minimize_out[value['A']].detach().numpy()) - if B is not None: - B[key][horizon_idx].append(minimize_out[value['B']].detach().numpy()) - loss = loss_functions[key](minimize_out[value['A']], minimize_out[value['B']]) - loss = (loss * loss_gains[key]) if key in loss_gains.keys() else loss - horizon_losses[ind].append(loss) - - ## Update - self._update_state(X, out_closed_loop, out_connect) - - if self._log_internal: - internals_dict['state'] = self._states - self._save_internal('inout_' + str(batch_idx) + '_' + str(horizon_idx), internals_dict) - - ## Calculate the total loss - total_loss = 0 - for ind, key in enumerate(self._model_def['Minimizers'].keys()): - loss = sum(horizon_losses[ind]) / (prediction_samples + 1) - aux_losses[ind][batch_idx] = loss.item() - if total_losses is not None: - total_losses[key].append(loss.detach().numpy()) - total_loss += loss - - ## Gradient Step - if optimizer: - total_loss.backward() ## Backpropagate the error - optimizer.step() - self.visualizer.showWeightsInTrain(batch=batch_idx) - batch_idx += 1 - - ## return the losses - return aux_losses - - def _setup_recurrent_variables(self, prediction_samples, closed_loop, connect): - ## Prediction samples - check(prediction_samples == 'auto' or prediction_samples >= -1, KeyError, "The sample horizon must be positive, -1, 'auto', for disconnect connection!") - ## Close loop information - for input, output in closed_loop.items(): - check(input in self._model_def['Inputs'], ValueError, f'the tag {input} is not an input variable.') - check(output in self._model_def['Outputs'], ValueError, f'the tag {output} is not an output of the network') - log.info(f'Recurrent train: closing the loop between the the input ports {input} and the output ports {output} for {prediction_samples} samples') - if self._input_ns_forward[input] > 0: - log.warning(f"Closed loop on variable '{input}' with sample in the future.") - ## Connect information - for input, output in connect.items(): - check(input in self._model_def['Inputs'], ValueError, f'the tag {input} is not an input variable.') - check(output in self._model_def['Outputs'], ValueError, f'the tag {output} is not an output of the network') - log.info(f'Recurrent train: connecting the input ports {input} with output ports {output} for {prediction_samples} samples') - if self._input_ns_forward[input] > 0: - log.warning(f"Connect on variable '{input}' with sample in the future.") - ## Disable recurrent training if there are no recurrent variables - if len(connect|closed_loop|self._model_def.recurrentInputs()) == 0: - if type(prediction_samples) is not str and prediction_samples >= 0: - log.warning(f"The value of the prediction_samples={prediction_samples} but the network has no recurrent variables.") - prediction_samples = -1 - return prediction_samples - - @enforce_types - def resetStates(self, states:set={}, *, batch:int=1) -> None: - """ - Resets the state of all the recurrent inputs of the network to zero. - Parameters - ---------- - states : set, optional - A set of recurrent inputs names to reset. If provided, only those inputs will be resetted. - batch : int, optional - The batch size for the reset states. Default is 1. - """ - if states: ## reset only specific states - for key in states: - window_size = self._input_n_samples[key] - dim = self._model_def['Inputs'][key]['dim'] - self._states[key] = torch.zeros(size=(batch, window_size, dim), dtype=TORCH_DTYPE, requires_grad=False) - else: ## reset all states - self._states = {} - for key, state in self._model_def.recurrentInputs().items(): - window_size = self._input_n_samples[key] - dim = state['dim'] - self._states[key] = torch.zeros(size=(batch, window_size, dim), dtype=TORCH_DTYPE, requires_grad=False) - diff --git a/nnodely/support/fixstepsolver.py b/nnodely/support/fixstepsolver.py deleted file mode 100644 index 01158271..00000000 --- a/nnodely/support/fixstepsolver.py +++ /dev/null @@ -1,35 +0,0 @@ -from nnodely.layers.parameter import SampleTime - -class FixedStepSolver(): - def __init__(self, int_name:str|None = None, der_name:str|None = None): - self.dt = SampleTime() - self.int_name = int_name - self.der_name = der_name - -class Euler(FixedStepSolver): - def __init__(self, int_name:str|None = None, der_name:str|None = None): - super().__init__(int_name, der_name) - def integrate(self, obj): - from nnodely.layers.input import Input - integral = Input(self.int_name, dimensions=obj.dim['dim']) - return (integral.last() + obj * self.dt).closedLoop(integral) - - def derivate(self, obj): - from nnodely.layers.input import Input - obj = Input(self.int_name, dimensions=obj.dim['dim']).connect(obj) - return (obj.last() - obj.sw([-2, -1])) / self.dt - -class Trapezoidal(FixedStepSolver): - def __init__(self, int_name:str|None = None, der_name:str|None = None): - super().__init__(int_name, der_name) - def integrate(self, obj): - from nnodely.layers.input import Input - integral = Input(self.int_name, dimensions=obj.dim['dim']) - obj = Input(self.der_name, dimensions=obj.dim['dim']).connect(obj) - return (integral.last() + (obj.last() + obj.sw([-2,-1])) * 0.5 * self.dt).closedLoop(integral) - - def derivate(self, obj): - from nnodely.layers.input import Input - obj = Input(self.int_name, dimensions=obj.dim['dim']).connect(obj) - derivative = Input(self.der_name, dimensions=obj.dim['dim']) - return (((obj.last() - obj.sw([-2, -1])) * 2.0) / self.dt - derivative.last()).closedLoop(derivative) \ No newline at end of file diff --git a/nnodely/support/jsonutils.py b/nnodely/support/jsonutils.py deleted file mode 100644 index ec294fae..00000000 --- a/nnodely/support/jsonutils.py +++ /dev/null @@ -1,459 +0,0 @@ -import copy -from pprint import pformat - - -from nnodely.support.utils import check - -from nnodely.support.logger import logging, nnLogger -log = nnLogger(__name__, logging.WARNING) - -def get_window(obj): - return 'tw' if 'tw' in obj.dim else ('sw' if 'sw' in obj.dim else None) - -# Codice per comprimere le relazioni - #print(self.json['Relations']) - # used_rel = {string for values in self.json['Relations'].values() for string in values[1]} - # if obj1.name not in used_rel and obj1.name in self.json['Relations'].keys() and self.json['Relations'][obj1.name][0] == add_relation_name: - # self.json['Relations'][self.name] = [add_relation_name, self.json['Relations'][obj1.name][1]+[obj2.name]] - # del self.json['Relations'][obj1.name] - # else: - # Devo aggiungere un operazione che rimuove un operazione di Add,Sub,Mul,Div se può essere unita ad un'altra operazione dello stesso tipo - # -def merge(source, destination, main = True): - if main: - for key, value in destination["Functions"].items(): - if key in source["Functions"].keys() and 'n_input' in value.keys() and 'n_input' in source["Functions"][key].keys(): - check(value == {} or source["Functions"][key] == {} or value['n_input'] == source["Functions"][key]['n_input'], - TypeError, - f"The ParamFun {key} is present multiple times, with different number of inputs. " - f"The ParamFun {key} is called with {value['n_input']} parameters and with {source['Functions'][key]['n_input']} parameters.") - for key, value in destination["Parameters"].items(): - if key in source["Parameters"].keys(): - if 'dim' in value.keys() and 'dim' in source["Parameters"][key].keys(): - check(value['dim'] == source["Parameters"][key]['dim'], - TypeError, - f"The Parameter {key} is present multiple times, with different dimensions. " - f"The Parameter {key} is called with {value['dim']} dimension and with {source['Parameters'][key]['dim']} dimension.") - window_dest = 'tw' if 'tw' in value else ('sw' if 'sw' in value else None) - window_source = 'tw' if 'tw' in source["Parameters"][key] else ('sw' if 'sw' in source["Parameters"][key] else None) - if window_dest is not None: - check(window_dest == window_source and value[window_dest] == source["Parameters"][key][window_source] , - TypeError, - f"The Parameter {key} is present multiple times, with different window. " - f"The Parameter {key} is called with {window_dest}={value[window_dest]} dimension and with {window_source}={source['Parameters'][key][window_source]} dimension.") - - log.debug("Merge Source") - log.debug("\n"+pformat(source)) - log.debug("Merge Destination") - log.debug("\n"+pformat(destination)) - result = copy.deepcopy(destination) - else: - result = destination - for key, value in source.items(): - if isinstance(value, dict): - # get node or create one - node = result.setdefault(key, {}) - merge(value, node, False) - else: - if key in result and type(result[key]) is list: - if key == 'tw' or key == 'sw': - if result[key][0] > value[0]: - result[key][0] = value[0] - if result[key][1] < value[1]: - result[key][1] = value[1] - else: - result[key] = value - if main == True: - log.debug("Merge Result") - log.debug("\n" + pformat(result)) - return result - -def get_models_json(json): - model_json = {} - model_json['Parameters'] = list(json['Parameters'].keys()) - model_json['Constants'] = list(json['Constants'].keys()) - model_json['Inputs'] = list(json['Inputs'].keys()) - model_json['Outputs'] = list(json['Outputs'].keys()) - model_json['Functions'] = list(json['Functions'].keys()) - model_json['Relations'] = list(json['Relations'].keys()) - return model_json - -def check_model(json): - all_inputs = json['Inputs'].keys() - all_outputs = json['Outputs'].keys() - - from nnodely.basic.relation import MAIN_JSON - subjson = MAIN_JSON - for name in all_outputs: - subjson = merge(subjson, subjson_from_output(json, name)) - needed_inputs = subjson['Inputs'].keys() - extenal_inputs = set(all_inputs) - set(needed_inputs) - - check(all_inputs == needed_inputs, RuntimeError, - f'Connect or close loop operation on the inputs {list(extenal_inputs)}, that are not used in the model.') - return json - -def binary_cheks(self, obj1, obj2, name): - from nnodely.basic.relation import Stream, toStream - obj1,obj2 = toStream(obj1),toStream(obj2) - check(type(obj1) is Stream,TypeError, - f"The type of {obj1} is {type(obj1)} and is not supported for add operation.") - check(type(obj2) is Stream,TypeError, - f"The type of {obj2} is {type(obj2)} and is not supported for add operation.") - window_obj1 = get_window(obj1) - window_obj2 = get_window(obj2) - if window_obj1 is not None and window_obj2 is not None: - check(window_obj1==window_obj2, TypeError, - f"For {name} the time window type must match or None but they were {window_obj1} and {window_obj2}.") - check(obj1.dim[window_obj1] == obj2.dim[window_obj2], ValueError, - f"For {name} the time window must match or None but they were {window_obj1}={obj1.dim[window_obj1]} and {window_obj2}={obj2.dim[window_obj2]}.") - check(obj1.dim['dim'] == obj2.dim['dim'] or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError, - f"For {name} the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.") - dim = obj1.dim | obj2.dim - dim['dim'] = max(obj1.dim['dim'], obj2.dim['dim']) - return obj1, obj2, dim - -def subjson_from_relation(json, relation): - json = copy.deepcopy(json) - # Get all the inputs needed to compute a specific relation from the json graph - inputs = set() - relations = set() - constants = set() - parameters = set() - functions = set() - - def search(rel): - if rel in json['Inputs']: # Found an input - inputs.add(rel) - if rel in json['Inputs']: - if 'connect' in json['Inputs'][rel] and json['Inputs'][rel]['local'] == 1: - search(json['Inputs'][rel]['connect']) - if 'closed_loop' in json['Inputs'][rel] and json['Inputs'][rel]['local'] == 1: - search(json['Inputs'][rel]['closed_loop']) - # if 'init' in json['Inputs'][rel]: - # search(json['Inputs'][rel]['init']) - elif rel in json['Constants']: # Found a constant or parameter - constants.add(rel) - elif rel in json['Parameters']: - parameters.add(rel) - elif rel in json['Functions']: - functions.add(rel) - if 'params_and_consts' in json['Functions'][rel]: - for sub_rel in json['Functions'][rel]['params_and_consts']: - search(sub_rel) - elif rel in json['Relations']: # Another relation - relations.add(rel) - for sub_rel in json['Relations'][rel][1]: - search(sub_rel) - for sub_rel in json['Relations'][rel][2:]: - if json['Relations'][rel][0] in ('Fir', 'Linear'): - search(sub_rel) - if json['Relations'][rel][0] in ('Fuzzify'): - search(sub_rel) - if json['Relations'][rel][0] in ('ParamFun'): - search(sub_rel) - - search(relation) - from nnodely.basic.relation import MAIN_JSON - sub_json = copy.deepcopy(MAIN_JSON) - sub_json['Relations'] = {key: value for key, value in json['Relations'].items() if key in relations} - sub_json['Inputs'] = {key: value for key, value in json['Inputs'].items() if key in inputs} - sub_json['Constants'] = {key: value for key, value in json['Constants'].items() if key in constants} - sub_json['Parameters'] = {key: value for key, value in json['Parameters'].items() if key in parameters} - sub_json['Functions'] = {key: value for key, value in json['Functions'].items() if key in functions} - sub_json['Outputs'] = {} - sub_json['Info'] = {} - return sub_json - - -def subjson_from_output(json, outputs:str|list): - json = copy.deepcopy(json) - from nnodely.basic.relation import MAIN_JSON - sub_json = copy.deepcopy(MAIN_JSON) - if type(outputs) is str: - outputs = [outputs] - for output in outputs: - sub_json = merge(sub_json, subjson_from_relation(json,json['Outputs'][output])) - sub_json['Outputs'][output] = json['Outputs'][output] - return sub_json - -def subjson_from_model(json, models:str|list): - from nnodely.basic.relation import MAIN_JSON - json = copy.deepcopy(json) - sub_json = copy.deepcopy(MAIN_JSON) - models_names = set([json['Models']]) if type(json['Models']) is str else set(json['Models'].keys()) - if type(models) is str or len(models) == 1: - if len(models) == 1: - models = models[0] - check(models in models_names, AttributeError, f"Model [{models}] not found!") - if type(json['Models']) is str: - outputs = set(json['Outputs'].keys()) - else: - outputs = set(json['Models'][models]['Outputs']) - sub_json['Models'] = models - else: - outputs = set() - sub_json['Models'] = {} - for model in models: - check(model in models_names, AttributeError, f"Model [{model}] not found!") - outputs |= set(json['Models'][model]['Outputs']) - sub_json['Models'][model] = {key: value for key, value in json['Models'][model].items()} - - # Remove the extern connections not keys in the graph - final_json = merge(sub_json, subjson_from_output(json, outputs)) - for key, value in final_json['Inputs'].items(): - if 'connect' in value and (value['local'] == 0 and value['connect'] not in final_json['Relations'].keys()): - del final_json['Inputs'][key]['connect'] - del final_json['Inputs'][key]['local'] - log.warning(f'The input {key} is "connect" outside the model connection removed for subjson') - if 'closedLoop' in value and (value['local'] == 0 and value['closedLoop'] not in final_json['Relations'].keys()): - del final_json['Inputs'][key]['closedLoop'] - del final_json['Inputs'][key]['local'] - log.warning(f'The input {key} is "closedLoop" outside the model connection removed for subjson') - return final_json - -def subjson_from_minimize(json, minimizers:str|list): - from nnodely.basic.relation import MAIN_JSON - json = copy.deepcopy(json) - sub_json = copy.deepcopy(MAIN_JSON) - - if 'Minimizers' in json: - rel_A = [json['Minimizers'][key]['A'] for key in minimizers] - rel_B = [json['Minimizers'][key]['B'] for key in minimizers] - relations_name = set(rel_A) | set(rel_B) - for rel_name in relations_name: - minimizers_json = subjson_from_relation(json, rel_name) - sub_json = merge(sub_json, minimizers_json) - sub_json['Minimizers'] = { key : json['Minimizers'][key] for key in minimizers } - - return sub_json - -def stream_to_str(obj, type = 'Stream'): - from nnodely.visualizer.emptyvisualizer import color, GREEN - from pprint import pformat - stream = f" {type} " - stream_name = f" {obj.name} {obj.dim} " - - title = color((stream).center(80, '='), GREEN, True) - json = color(pformat(obj.json), GREEN) - stream = color((stream_name).center(80, '-'), GREEN, True) - return title + '\n' + json + '\n' + stream - -def plot_structure(json, filename='nnodely_graph', library='matplotlib', view=True): - #json = self.modely.json if json is None else json - # if json is None: - # raise ValueError("No JSON model definition provided. Please provide a valid JSON model definition.") - if library not in ['matplotlib', 'graphviz']: - raise ValueError("Invalid library specified. Use 'matplotlib' or 'graphviz'.") - if library == 'matplotlib': - plot_matplotlib_structure(json, filename, view=view) - elif library == 'graphviz': - plot_graphviz_structure(json, filename, view=view) - -def plot_matplotlib_structure(json, filename='nnodely_graph', view=True): - import matplotlib.pyplot as plt - from matplotlib import patches - from matplotlib.lines import Line2D - layer_positions = {} - x, y = 0, 0 # Initial position - dy, dx = 1.5, 2.5 # Spacing - - ## Layer Inputs: - for input_name, input_type in json['Inputs'].items(): - layer_positions[input_name] = (x, y) - y -= dy - for constant_name in json['Constants'].keys(): - layer_positions[constant_name] = (x, y) - y -= dy - y_limit = abs(y) - - # Layers Relations: - available_inputs = list(json['Inputs'].keys() | json['Constants'].keys()) - available_outputs = list(set(json['Outputs'].values())) - while available_outputs: - x += dx - y = 0 - inputs_to_add, outputs_to_remove = [], [] - for relation_name, (relation_type, dependencies, *_) in json['Relations'].items(): - if all(dep in available_inputs for dep in dependencies) and (relation_name not in available_inputs): - inputs_to_add.append(relation_name) - if relation_name in available_outputs: - outputs_to_remove.append(relation_name) - layer_positions[relation_name] = (x, y) - y -= dy - y_limit = max(y_limit, abs(y)) - available_inputs.extend(inputs_to_add) - available_outputs = [out for out in available_outputs if out not in outputs_to_remove] - - ## Layer Outputs: - x += dx - y = 0 - for idx, output_name in enumerate(json['Outputs'].keys()): - layer_positions[output_name] = (x, y) - y -= dy # Move down for the next input - x_limit = abs(x) - y_limit = max(y_limit, abs(y)) - - # Create the plot - fig, ax = plt.subplots(figsize=(x_limit, y_limit)) - #fig.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.05) - - # Plot rectangles for each layer - colors, labels = ['lightgreen', 'lightblue', 'orange', 'lightgray'], ['Inputs', 'Relations', 'Outputs', 'Constants'] - legend_info = [patches.Patch(facecolor=color, edgecolor='black', label=label) for color, label in zip(colors, labels)] - for layer in (json['Inputs'].keys() | json['Outputs'].keys() | json['Relations'].keys() | json['Constants'].keys()): - x1, y1 = layer_positions[layer] - if layer in json['Inputs'].keys(): - color = 'lightgreen' - tag = f'{layer}\ndim: {json["Inputs"][layer]["dim"]}\nWindow: {json["Inputs"][layer]["ntot"]}' - elif layer in json['Outputs'].keys(): - color = 'orange' - tag = layer - elif layer in json['Constants'].keys(): - color = 'lightgray' - tag = f'{layer}\ndim: {json["Constants"][layer]["dim"]}' - else: - color = 'lightblue' - tag = f'{json["Relations"][layer][0]}\n({layer})' - rect = patches.Rectangle((x1, y1), 2, 1, edgecolor='black', facecolor=color) - ax.add_patch(rect) - ax.text(x1 + 1, y1 + 0.5, f"{tag}", ha='center', va='center', fontsize=8, fontweight='bold') - - # Draw arrows for dependencies - for layer, (_, dependencies, *_) in json['Relations'].items(): - x1, y1 = layer_positions[layer] # Get position of the current layer - for dep in dependencies: - if dep in layer_positions: - x2, y2 = layer_positions[dep] # Get position of the dependent layer - ax.annotate("", xy=(x1, y1), xytext=(x2 + 2, y2 + 0.5), arrowprops=dict(arrowstyle="->", color='black', lw=1)) - for out_name, rel_name in json['Outputs'].items(): - x1, y1 = layer_positions[out_name] - x2, y2 = layer_positions[rel_name] - ax.annotate("", xy=(x1, y1 + 0.5), xytext=(x2 + 2, y2 + 0.5), - arrowprops=dict(arrowstyle="->", color='black', lw=1)) - for key, state in json['Inputs'].items(): - if 'closedLoop' in state.keys(): - x1, y1 = layer_positions[key] - x2, y2 = layer_positions[state['closedLoop']] - #ax.annotate("", xy=(x2+1, y2), xytext=(x2+1, y_limit), arrowprops=dict(arrowstyle="-", color='red', lw=1, linestyle='dashed')) - ax.add_patch(patches.FancyArrowPatch((x2+1, y2), (x2+1, -y_limit), arrowstyle='-', mutation_scale=15, color='red', linestyle='dashed')) - ax.add_patch(patches.FancyArrowPatch((x2+1, -y_limit), (x1-1, -y_limit), arrowstyle='-', mutation_scale=15, color='red', linestyle='dashed')) - ax.add_patch(patches.FancyArrowPatch((x1-1, -y_limit), (x1-1, y1+0.5), arrowstyle='-', mutation_scale=15, color='red', linestyle='dashed')) - ax.add_patch(patches.FancyArrowPatch((x1-1, y1+0.5), (x1, y1+0.5), arrowstyle='->', mutation_scale=15, color='red', linestyle='dashed')) - elif 'connect' in state.keys(): - x1, y1 = layer_positions[key] - x2, y2 = layer_positions[state['connect']] - ax.add_patch(patches.FancyArrowPatch((x1, y1), (x2, y2), arrowstyle='->', mutation_scale=15, color='green', linestyle='dashed')) - - legend_info.extend([Line2D([0], [0], color='black', lw=2, label='Dependency'), - Line2D([0], [0], color='red', lw=2, linestyle='dashed', label='Closed Loop'), - Line2D([0], [0], color='green', lw=2, linestyle='dashed', label='Connect')]) - - # Adjust the plot limits - ax.set_xlim(-dx, x_limit+dx) - ax.set_ylim(-y_limit, dy) - ax.set_aspect('equal') - ax.legend(handles=legend_info, loc='lower right') - ax.axis('off') # Hide axes - - plt.title(f"Neural Network Diagram - Sampling [{json['Info']['SampleTime']}]", fontsize=12, fontweight='bold') - ## Save the figure - plt.savefig(filename, format="png", bbox_inches='tight') - if view: - plt.show() - -def plot_graphviz_structure(json, filename='nnodely_graph', view=True): # pragma: no cover - import shutil - from graphviz import view - from graphviz import Digraph - - # Check if Graphviz is installed - if shutil.which('dot') is None: - # raise RuntimeError( - # "Graphviz does not appear to be installed on your system. " - # "Please install it from https://graphviz.org/download/" - # ) - log.warning( - "Graphviz does not appear to be installed on your system. " - "Please install it from https://graphviz.org/download/" - ) - return - - dot = Digraph(comment='Structured Neural Network') - - # Set graph attributes for top-down layout and style - dot.attr(rankdir='LR', size='21') - dot.attr('node', shape='box', style='filled', color='lightgray', fontname='Helvetica') - - # Add metadata/info box - if 'Info' in json: - info = json['Info'] - info_text = '\n'.join([f"{k}: {v}" for k, v in info.items()]) - dot.node('INFO_BOX', label=f"Model Info\n{info_text}", shape='note', fillcolor='white', fontsize='10') - - # Add input nodes - for inp, data in json['Inputs'].items(): - dim = data['dim'] - window = data['sw'] if 'sw' in data else data['tw'] - window_tag = 'sw' if 'sw' in data else 'tw' - label = f"{inp}\nDim: {dim}\nWindow({window_tag}): {window}" - dot.node(inp, label=label, fillcolor='lightgreen') - if 'connect' in data.keys(): - dot.edge(data['connect'], inp, label='connect', color='blue', fontcolor='blue') - if 'closedLoop' in data.keys(): - dot.edge(data['closedLoop'], inp, label='closedLoop', color='red', fontcolor='red') - - # Add constant nodes - if 'Constants' in json: - for const, data in json['Constants'].items(): - dim = data['dim'] - label = f"{const}\nDim: {dim}" - dot.node(const, label=label, fillcolor='lightgray') - - # Add relation nodes - for name, rel in json['Relations'].items(): - op_type = rel[0] - parents = rel[1] - param1 = rel[2] if len(rel) > 2 else None - param2 = rel[3] if len(rel) > 3 else None - label = f"{name}\nType: {op_type}" - dot.node(name, label=label, fillcolor='lightblue') - for i in [param1,param2]: - if isinstance(i, str): - if i in json['Parameters']: - param_dim = json['Parameters'][i]['dim'] - dot.node(i, label=f"{i}\nDim: {param_dim}", shape='ellipse', fillcolor='orange') - dot.edge(i, name, label='Parameter', color='orange', fontcolor='orange') - elif i in json['Functions']: - dot.node(i, label=f"{param1}", shape='ellipse', fillcolor='darkorange') - dot.edge(i, name, label='function', color='darkorange', fontcolor='darkorange') - for parent in parents: - dot.edge(parent, name) - - # Add output nodes - for out, rel in json['Outputs'].items(): - dot.node(out, fillcolor='lightcoral') - dot.edge(rel, out) - - # Add Minimize nodes if present - if 'Minimizers' in json: - for name, rel in json['Minimizers'].items(): - rel_a, rel_b = rel['A'], rel['B'] - loss = rel['loss'] - dot.node(name, label=f"{name}\nLoss:{loss}", shape='ellipse', fillcolor='purple') - dot.edge(rel_a, name, label='Minimize', color='purple', fontcolor='purple') - dot.edge(rel_b, name, label='Minimize', color='purple', fontcolor='purple') - - # Add a legend as a subgraph - # with dot.subgraph(name='cluster_legend') as legend: - # legend.attr(label='Legend', style='dashed') - # legend.node('LegendInput', 'Inputs', shape='box', fillcolor='lightgreen', style='filled') - # legend.node('LegendRel', 'Relation', shape='box', fillcolor='lightblue', style='filled') - # legend.node('LegendOutput', 'Outputs', shape='box', fillcolor='lightcoral', style='filled') - # # Hide the edges inside the legend box - # legend.attr('edge', style='invis') - # legend.edge('LegendInput', 'LegendRel') - # legend.edge('LegendRel', 'LegendOutput') - - # Render the graph - dot.render(filename=filename, view=view, format='svg') # opens in default viewer and saves as SVG \ No newline at end of file diff --git a/nnodely/support/odeint/dopri5.py b/nnodely/support/odeint/dopri5.py deleted file mode 100644 index 9d6e3024..00000000 --- a/nnodely/support/odeint/dopri5.py +++ /dev/null @@ -1,35 +0,0 @@ -import torch -from nnodely.support.odeint.rk_solvers import _ButcherTableau, RKAdaptiveStepsizeODESolver - -_DORMAND_PRINCE_SHAMPINE_TABLEAU = _ButcherTableau( - alpha=torch.tensor([1 / 5, 3 / 10, 4 / 5, 8 / 9, 1., 1.], dtype=torch.float32), - beta=[ - torch.tensor([1 / 5], dtype=torch.float32), - torch.tensor([3 / 40, 9 / 40], dtype=torch.float32), - torch.tensor([44 / 45, -56 / 15, 32 / 9], dtype=torch.float32), - torch.tensor([19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729], dtype=torch.float32), - torch.tensor([9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656], dtype=torch.float32), - torch.tensor([35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84], dtype=torch.float32), - ], - c_sol=torch.tensor([35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0], dtype=torch.float32), - c_error=torch.tensor([ - 35 / 384 - 1951 / 21600, - 0, - 500 / 1113 - 22642 / 50085, - 125 / 192 - 451 / 720, - -2187 / 6784 - -12231 / 42400, - 11 / 84 - 649 / 6300, - -1. / 60., - ], dtype=torch.float32), -) - -DPS_C_MID = torch.tensor([ - 6025192743 / 30085553152 / 2, 0, 51252292925 / 65400821598 / 2, -2691868925 / 45128329728 / 2, - 187940372067 / 1594534317056 / 2, -1776094331 / 19743644256 / 2, 11237099 / 235043384 / 2 -], dtype=torch.float32) - - -class Dopri5Solver(RKAdaptiveStepsizeODESolver): - order = 5 - tableau = _DORMAND_PRINCE_SHAMPINE_TABLEAU - mid = DPS_C_MID \ No newline at end of file diff --git a/nnodely/visualizer/textvisualizer.py b/nnodely/visualizer/textvisualizer.py deleted file mode 100644 index f574abee..00000000 --- a/nnodely/visualizer/textvisualizer.py +++ /dev/null @@ -1,319 +0,0 @@ -import numpy as np -from pprint import pformat - -from nnodely.support.utils import is_notebook -from nnodely.visualizer.emptyvisualizer import EmptyVisualizer, color, GREEN, RED, BLUE - -class TextVisualizer(EmptyVisualizer): - def __init__(self, verbose=1): - self.verbose = verbose - - def __title(self,msg, lenght = 80): - print(color((msg).center(lenght, '='), GREEN, True)) - - def __subtitle(self,msg, lenght = 80): - print(color((msg).center(lenght, '-'), GREEN, True)) - - def __line(self): - print(color('='.center(80, '='),GREEN)) - - def __singleline(self): - print(color('-'.center(80, '-'),GREEN)) - - def __info(self,name, dim =30): - print(color((name).ljust(dim),BLUE)) - - def __paramjson(self,name, value, dim =30): - lines = pformat(value, width=80 - dim).strip().splitlines() - vai = ('\n' + (' ' * dim)).join(x for x in lines) - # pformat(value).strip().splitlines().rjust(40) - print(color((name).ljust(dim) + vai,GREEN)) - - def __param(self,name, value, dim =30): - print(color((name).ljust(dim) + value,GREEN)) - - def showModel(self, model): - if self.verbose >= 1: - self.__title(" nnodely Model ") - print(color(pformat(model),GREEN)) - self.__line() - - def showMinimize(self,variable_name): - if self.verbose >= 2: - self.__title(f" Minimize Error of {variable_name} between" - f" {self.modely._model_def['Minimizers'][variable_name]['A']} and" - f" {self.modely._model_def['Minimizers'][variable_name]['B']} with {self.modely._model_def['Minimizers'][variable_name]['loss']} ") - self.__line() - - def showModelInputWindow(self): - if self.verbose >= 2: - input_ns_backward = {key: value['ns'][0] for key, value in self.modely._model_def['Inputs'].items()} - input_ns_forward = {key: value['ns'][1] for key, value in self.modely._model_def['Inputs'].items()} - self.__title(" nnodely Model Input Windows ") - #self.__paramjson("time_window_backward:",self.modely.input_tw_backward) - #self.__paramjson("time_window_forward:",self.modely.input_tw_forward) - self.__paramjson("sample_window_backward:", input_ns_backward) - self.__paramjson("sample_window_forward:", input_ns_forward) - self.__paramjson("input_n_samples:", self.modely._input_n_samples) - self.__param("max_samples [backw, forw]:", f"[{self.modely._model_def['Info']['ns'][0]},{self.modely._model_def['Info']['ns'][1]}]") - self.__param("max_samples total:",f"{self.modely._max_n_samples}") - self.__line() - - def showModelRelationSamples(self): - if self.verbose >= 2: - self.__title(" nnodely Model Relation Samples ") - self.__paramjson("Relation_samples:", self.modely.relation_samples) - self.__line() - - def showBuiltModel(self): - if self.verbose >= 2: - self.__title(" nnodely Built Model ") - print(color(pformat(self.modely._model),GREEN)) - self.__line() - - def showWeights(self, weights = None): - self.__title(" nnodely Models Weights ") - for key, param in self.modely.parameters.items(): - if weights is None or key in weights: - self.__paramjson(key,param) - self.__line() - - def showWeightsInTrain(self, batch = None, epoch = None, weights = None): - if self.verbose >= 2: - par = self.modely.running_parameters - dim = len(self.modely._model_def['Minimizers']) - COLOR = BLUE - if epoch is not None: - print(color('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|',COLOR), end='') - print(color((f' Params end epochs {epoch + 1} ').center(20 * (dim + 1) - 1, '-') + '|',COLOR)) - - if batch is not None: - print(color('|' + (f"{batch + 1}").center(10, ' ') + '|', COLOR), end='') - print(color((f' Params end batch {batch + 1} ').center(20 * (dim + 1) - 1, '-') + '|', COLOR)) - - for key, param in self.modely.parameters.items(): - if weights is None or key in weights: - print(color('|' + (f"{key}").center(10, ' ') + '|', COLOR), end='') - print(color((f'{param}').center(20 * (dim + 1) - 1, ' ') + '|', COLOR)) - - if epoch is not None: - print(color('|'+(f'').center(10+20*(dim+1), '-') + '|')) - - def showDataset(self, name): - if self.verbose >= 1: - self.__title(" nnodely Model Dataset ") - self.__param("Dataset Name:", name) - self.__param("Number of files:", f'{self.modely._file_count}') - self.__param("Total number of samples:", f'{self.modely._num_of_samples[name]}') - for key in self.modely._model_def['Inputs'].keys(): - if key in self.modely._data[name].keys(): - self.__param(f"Shape of {key}:", f'{self.modely._data[name][key].shape}') - self.__line() - - def showStartTraining(self): - if self.verbose >= 1: - par = self.modely.running_parameters - dim = len(self.modely._model_def['Minimizers']) - self.__title(" nnodely Training ", 12+(len(self.modely._model_def['Minimizers'])+1)*20) - print(color('|'+(f'Epoch').center(10,' ')+'|'),end='') - for key in self.modely._model_def['Minimizers'].keys(): - print(color((f'{key}').center(19, ' ') + '|'), end='') - print(color((f'Total').center(19, ' ') + '|')) - - print(color('|' + (f' ').center(10, ' ') + '|'), end='') - for key in self.modely._model_def['Minimizers'].keys(): - print(color((f'Loss').center(19, ' ') + '|'),end='') - print(color((f'Loss').center(19, ' ') + '|')) - - print(color('|' + (f' ').center(10, ' ') + '|'), end='') - for key in self.modely._model_def['Minimizers'].keys(): - if par['n_samples_val']: - print(color((f'train').center(9, ' ') + '|'),end='') - print(color((f'val').center(9, ' ') + '|'),end='') - else: - print(color((f'train').center(19, ' ') + '|'), end='') - if par['n_samples_val']: - print(color((f'train').center(9, ' ') + '|'), end='') - print(color((f'val').center(9, ' ') + '|')) - else: - print(color((f'train').center(19, ' ') + '|')) - - print(color('|'+(f'').center(10+20*(dim+1), '-') + '|')) - - def showTraining(self, epoch, train_losses, val_losses): - if self.verbose >= 1: - eng = lambda val: np.format_float_scientific(val, precision=3) - par = self.modely.running_parameters - show_epoch = 1 if par['num_of_epochs'] <= 100 else int(par['num_of_epochs']/100) - dim = len(self.modely._model_def['Minimizers']) - if epoch < par['num_of_epochs']: - print('', end='\r') - print('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|', end='') - train_loss = [] - val_loss = [] - for key in self.modely._model_def['Minimizers'].keys(): - train_loss.append(train_losses[key][epoch]) - if val_losses: - val_loss.append(val_losses[key][epoch]) - print((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '|', end='') - print((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '|', end='') - else: - print((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '|', end='') - - if val_losses: - print((f'{eng(np.mean(train_loss))}').center(9, ' ') + '|', end='') - print((f'{eng(np.mean(val_loss))}').center(9, ' ') + '|', end='') - else: - print((f'{eng(np.mean(train_loss))}').center(19, ' ') + '|', end='') - - if (epoch + 1) % show_epoch == 0: - print('', end='\r') - print(color('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|'), end='') - for key in self.modely._model_def['Minimizers'].keys(): - if val_losses: - print(color((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '|'), end='') - print(color((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '|'), end='') - else: - print(color((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '|'), end='') - if val_losses: - print(color((f'{eng(np.mean(train_loss))}').center(9, ' ') + '|'), end='') - print(color((f'{eng(np.mean(val_loss))}').center(9, ' ') + '|')) - else: - print(color((f'{eng(np.mean(train_loss))}').center(19, ' ') + '|')) - - if epoch+1 == par['num_of_epochs']: - print(color('|'+(f'').center(10+20*(dim+1), '-') + '|')) - - def showTrainingTime(self, time): - if self.verbose >= 1: - self.__title(" nnodely Training Time ") - self.__param("Total time of Training:", f'{time}') - self.__line() - - def showTrainParams(self): - if self.verbose >= 1: - self.__title(" nnodely Model Train Parameters ") - par = self.modely.getTrainingInfo() - - self.__paramjson("models:", par['models']) - self.__param("num of epochs:", str(par['num_of_epochs'])) - self.__param("update per epochs:", str(par['update_per_epochs'])) - if par['prediction_samples'] >= 0: - self.__info("└>len(train_indexes)//(batch_size+step)") - else: - self.__info("└>(n_samples-batch_size)/batch_size+1") - - if par['shuffle_data']: - self.__param('shuffle data:', str(par['shuffle_data'])) - - if 'early_stopping' in par and par['early_stopping']: - self.__param('early stopping:', par['early_stopping']) - self.__paramjson('early stopping params:', par['early_stopping_params']) - - if par['prediction_samples'] >= 0: - self.__param("prediction samples:", f"{par['prediction_samples']}") - self.__param("step:", f"{par['train_step']}") - self.__paramjson("closed loop:", par['closed_loop']) - self.__paramjson("connect:", par['connect']) - - self.__param("train dataset:", f"{par['train_tag']}") - self.__param("\t- batch size:", f"{par['train_batch_size']}") - self.__param("\t- num of samples:", f"{par['n_samples_train']}") - if par['prediction_samples'] >= 0: - self.__param("\t- num of first samples:", f"{par['n_first_samples_train']}") - - if par['n_samples_val'] > 0: - self.__param("validation dataset:", f"{par['val_tag']}") - self.__param("\t- batch size:", f"{par['val_batch_size']}") - self.__param("\t- num of samples:", f"{par['n_samples_val']}") - if par['prediction_samples'] >= 0: - self.__param("\t- num of first samples:", f"{par['n_first_samples_val']}") - - if par['n_samples_test'] > 0: - self.__param("test dataset:", f"{par['test_tag']}") - self.__param("\t- num of samples:", f"{par['n_samples_test']}") - if 'test_batch_size' in par: - self.__param("\t- batch size:", f"{par['test_batch_size']}") - if par['prediction_samples'] >= 0: - self.__param("\t- num of first samples:", f"{par['n_first_samples_test']}") - - self.__paramjson('minimizers:', par['minimizers']) - - self.__param("optimizer:", par['optimizer']) - self.__paramjson("optimizer defaults:", par['optimizer_defaults']) - if par['optimizer_params'] is not None: - self.__paramjson("optimizer params:", par['optimizer_params']) - - self.__line() - - def showResult(self, name_data): - eng = lambda val: np.format_float_scientific(val, precision=3) - if self.verbose >= 1: - dim_loss = max(5,len(max(self.modely._model_def['Minimizers'].keys(),key=len))) - loss_type_list = set([value["loss"] for ind, (key, value) in enumerate(self.modely._model_def['Minimizers'].items())]) - self.__title(f" nnodely Model Results for {name_data} ", dim_loss + 2 + (len(loss_type_list) + 2) * 20) - print(color('|' + (f'Loss').center(dim_loss, ' ') + '|'), end='') - for loss in loss_type_list: - print(color((f'{loss}').center(19, ' ') + '|'), end='') - print(color((f'FVU').center(19, ' ') + '|'), end='') - print(color((f'AIC').center(19, ' ') + '|')) - - print(color('|' + (f'').center(dim_loss, ' ') + '|'), end='') - for i in range(len(loss_type_list)): - print(color((f'small better').center(19, ' ') + '|'), end='') - print(color((f'small better').center(19, ' ') + '|'), end='') - print(color((f'lower better').center(19, ' ') + '|')) - - print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|')) - for ind, (key, value) in enumerate(self.modely._model_def['Minimizers'].items()): - print(color('|'+(f'{key}').center(dim_loss, ' ') + '|'), end='') - for loss in list(loss_type_list): - if value["loss"] == loss: - print(color((f'{eng(self.modely.performance[name_data][key][value["loss"]])}').center(19, ' ') + '|'), end='') - else: - print(color((f' ').center(19, ' ') + '|'), end='') - print(color((f'{eng(self.modely.performance[name_data][key]["fvu"]["total"])}').center(19, ' ') + '|'), end='') - print(color((f'{eng(self.modely.performance[name_data][key]["aic"]["value"])}').center(19, ' ') + '|')) - - print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|')) - print(color('|'+(f'Total').center(dim_loss, ' ') + '|'), end='') - print(color((f'{eng(self.modely.performance[name_data]["total"]["mean_error"])}').center(len(loss_type_list)*20-1, ' ') + '|'), end='') - print(color((f'{eng(self.modely.performance[name_data]["total"]["fvu"])}').center(19, ' ') + '|'), end='') - print(color((f'{eng(self.modely.performance[name_data]["total"]["aic"])}').center(19, ' ') + '|')) - - print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|')) - - if self.verbose >= 2: - self.__title(" Detalied Results ") - print(color(pformat(self.modely.performance), GREEN)) - self.__line() - - def saveModel(self, name, path): - if self.verbose >= 1: - self.__title(f" Save {name} ") - self.__param("Model saved in:", path) - self.__line() - - def loadModel(self, name, path): - if self.verbose >= 1: - self.__title(f" Load {name} ") - self.__param("Model loaded from:", path) - self.__line() - - def exportModel(self, name, path): - if self.verbose >= 1: - self.__title(f" Export {name} ") - self.__param("Model exported in:", path) - self.__line() - - def importModel(self, name, path): - if self.verbose >= 1: - self.__title(f" Import {name} ") - self.__param("Model imported from:", path) - self.__line() - - def exportReport(self, name, path): - if self.verbose >= 1: - self.__title(f" Export {name} Report ") - self.__param("Report exported in:", path) - self.__line() \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 74e01be3..9a13b455 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,20 +1,21 @@ [build-system] -requires = ["setuptools>=61", "wheel"] -build-backend = "setuptools.build_meta" +requires = ["uv_build>=0.11.6,<0.12.0"] +build-backend = "uv_build" [project] name = "nnodely" +version = "1.5.5.dev1" description = "Model-structured neural network framework for the modeling and control of physical systems" readme = "README.md" -requires-python = ">=3.10, <3.13" -license = {file = "LICENSE"} +requires-python = ">=3.10,<3.14" +license = "MIT" +license-files = ["LICENSE"] authors = [ - {name = "Gastone Pietro Rosati Papini", email = "tonegas@gmail.com"} + { name = "Gastone Pietro Rosati Papini", email = "tonegas@gmail.com" }, ] classifiers = [ "Programming Language :: Python :: 3", - "License :: OSI Approved :: MIT License", - "Operating System :: OS Independent" + "Operating System :: OS Independent", ] dependencies = [ "numpy == 1.26.4; platform_machine == 'x86_64' and python_version == '3.10'", @@ -26,24 +27,18 @@ dependencies = [ "reportlab", "matplotlib", "onnxruntime", - "graphviz" + "graphviz", ] -dynamic = ["version"] [project.urls] "Homepage" = "https://github.com/tonegas/nnodely" +"Repository" = "https://github.com/tonegas/nnodely" -[tool.setuptools] -packages = ["nnodely", - "nnodely.basic", - "nnodely.exporter", - "nnodely.layers", - "nnodely.operators", - "nnodely.support", - "nnodely.visualizer", - "nnodely.visualizer.dynamicmpl", - "mplplots"] +[dependency-groups] +dev = ["pre-commit>=4.5.1", "pytest-cov>=7.1.0", "ruff>=0.15.10"] -#[tool.setuptools.data-files] -#"imgs" = ["imgs/*"] -#"data" = ["tests/data/*","tests/test_data/*","tests/val_data/*","tests/vector_data/*"] \ No newline at end of file +[[tool.uv.index]] +name = "testpypi" +url = "https://test.pypi.org/simple/" +publish-url = "https://test.pypi.org/legacy/" +explicit = true diff --git a/setup.py b/setup.py index 0ceefd2c..7f68bd37 100644 --- a/setup.py +++ b/setup.py @@ -10,18 +10,20 @@ # with open(version_file, 'w') as f: # f.write(content_new) + def read_version(): - version_file = os.path.join(os.path.dirname(__file__), 'nnodely', '__init__.py') - with open(version_file, 'r') as f: + version_file = os.path.join(os.path.dirname(__file__), "nnodely", "__init__.py") + with open(version_file, "r") as f: for line in f: - if line.startswith('__version__'): + if line.startswith("__version__"): delim = '"' if '"' in line else "'" return line.split(delim)[1] raise RuntimeError("Unable to find version string.") + setup( - name='nnodely', + name="nnodely", version=read_version(), packages=find_packages(exclude=["docs*", "tests*", "imgs*"]), - include_package_data=True -) \ No newline at end of file + include_package_data=True, +) diff --git a/nnodely/__init__.py b/src/nnodely/__init__.py similarity index 51% rename from nnodely/__init__.py rename to src/nnodely/__init__.py index 26201190..a08714a0 100644 --- a/nnodely/__init__.py +++ b/src/nnodely/__init__.py @@ -14,7 +14,15 @@ from nnodely.layers.trigonometric import Sin, Cos, Tan, Cosh, Tanh, Sech from nnodely.layers.parametricfunction import ParamFun from nnodely.layers.fuzzify import Fuzzify -from nnodely.layers.part import Part, Select, Concatenate, SamplePart, SampleSelect, TimePart, TimeConcatenate +from nnodely.layers.part import ( + Part, + Select, + Concatenate, + SamplePart, + SampleSelect, + TimePart, + TimeConcatenate, +) from nnodely.layers.localmodel import LocalModel from nnodely.layers.equationlearner import EquationLearner from nnodely.layers.timeoperation import Integrate, Differentiate @@ -37,43 +45,85 @@ major, minor = sys.version_info.major, sys.version_info.minor logger.LOG_LEVEL = logging.INFO -__version__ = '1.5.4' +__version__ = "1.5.4" if major < 3: - sys.exit("Sorry, Python 2 is not supported. You need Python >= 3.10 for "+__package__+".") + sys.exit( + "Sorry, Python 2 is not supported. You need Python >= 3.10 for " + + __package__ + + "." + ) elif minor < 9: - sys.exit("Sorry, You need Python >= 3.10 for "+__package__+".") + sys.exit("Sorry, You need Python >= 3.10 for " + __package__ + ".") else: - print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>' + - f' {__package__}_v{__version__} '.center(20, '-') + - '<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<') + print( + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + + f" {__package__}_v{__version__} ".center(20, "-") + + "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" + ) __all__ = [ - 'nnodely', 'Modely', 'clearNames', - 'Input', 'Connect', 'ClosedLoop', - 'Parameter', 'Constant', 'SampleTime', - 'Output', - 'Relu', 'ELU', 'Softmax', 'Sigmoid', 'Identity', - 'Fir', - 'Linear', - 'NeuralODE', - 'Add', 'Sum', 'Sub', 'Mul', 'Div', 'Pow', 'Neg', 'Sign', - 'Sin', 'Cos', 'Tan', 'Cosh', 'Tanh', 'Sech', - 'ParamFun', - 'Fuzzify', - 'Part', 'Select', 'Concatenate', - 'SamplePart', 'SampleSelect', - 'TimePart', 'TimeConcatenate', - 'LocalModel', - 'EquationLearner', - 'Integrate', 'Differentiate', - 'Interpolation', - 'ForwardEuler', 'RK2', 'RK4', - 'TextVisualizer', 'MPLVisualizer', 'MPLNotebookVisualizer', - 'StandardExporter', - 'SGD', 'Adam', 'Optimizer', - 'init_negexp', 'init_lin', 'init_constant', 'init_exp', + "nnodely", + "Modely", + "clearNames", + "Input", + "Connect", + "ClosedLoop", + "Parameter", + "Constant", + "SampleTime", + "Output", + "Relu", + "ELU", + "Softmax", + "Sigmoid", + "Identity", + "Fir", + "Linear", + "NeuralODE", + "Add", + "Sum", + "Sub", + "Mul", + "Div", + "Pow", + "Neg", + "Sign", + "Sin", + "Cos", + "Tan", + "Cosh", + "Tanh", + "Sech", + "ParamFun", + "Fuzzify", + "Part", + "Select", + "Concatenate", + "SamplePart", + "SampleSelect", + "TimePart", + "TimeConcatenate", + "LocalModel", + "EquationLearner", + "Integrate", + "Differentiate", + "Interpolation", + "ForwardEuler", + "RK2", + "RK4", + "TextVisualizer", + "MPLVisualizer", + "MPLNotebookVisualizer", + "StandardExporter", + "SGD", + "Adam", + "Optimizer", + "init_negexp", + "init_lin", + "init_constant", + "init_exp", # Main nnodely classes - '__version__' + "__version__", ] diff --git a/nnodely/basic/__init__.py b/src/nnodely/basic/__init__.py similarity index 100% rename from nnodely/basic/__init__.py rename to src/nnodely/basic/__init__.py diff --git a/src/nnodely/basic/loss.py b/src/nnodely/basic/loss.py new file mode 100644 index 00000000..2ec49f3b --- /dev/null +++ b/src/nnodely/basic/loss.py @@ -0,0 +1,36 @@ +import torch.nn as nn +import torch +from nnodely.support.utils import check + +available_losses = ["mse", "rmse", "mae", "cross_entropy"] + + +class CustomLoss(nn.Module): + def __init__(self, loss_type="mse", **kwargs): + super(CustomLoss, self).__init__() + check( + loss_type in available_losses, + TypeError, + f'The "{loss_type}" loss is not available. Possible losses are: {available_losses}.', + ) + self.loss_type = loss_type + self.loss = nn.MSELoss(**kwargs) + if callable(loss_type): + self.loss = loss_type + elif self.loss_type == "mae": + self.loss = nn.L1Loss(**kwargs) + elif self.loss_type == "cross_entropy": + self.loss = nn.CrossEntropyLoss(**kwargs) + + def forward(self, inA, inB): + if self.loss_type == "cross_entropy": + inB = ( + inB.squeeze().float() + if inA.shape == inB.shape + else inB.squeeze().long() + ) + inA = inA.squeeze() + res = self.loss(inA, inB) + if self.loss_type == "rmse": + res = torch.sqrt(res) + return res diff --git a/src/nnodely/basic/model.py b/src/nnodely/basic/model.py new file mode 100644 index 00000000..4937bd9e --- /dev/null +++ b/src/nnodely/basic/model.py @@ -0,0 +1,324 @@ +import torch +import copy + +import torch.nn as nn +import numpy as np + +from itertools import product + +from nnodely.support.utils import TORCH_DTYPE +from nnodely.support import initializer + + +@torch.fx.wrap +def update_state(data_in, rel): + # virtual = torch.roll(data_in, shifts=-1, dims=1) + max_dim = min(rel.size(1), data_in.size(1)) + data_out = data_in.clone() + data_out[:, -max_dim:, :] = rel[:, -max_dim:, :] + return data_out + + +class Model(nn.Module): + def __init__(self, model_def): + super(Model, self).__init__() + model_def = copy.deepcopy(model_def) + + self.states = { + key: value + for key, value in model_def["Inputs"].items() + if ("closedLoop" in value.keys() or "connect" in value.keys()) + } + + self.inputs = model_def["Inputs"] + self.outputs = model_def["Outputs"] + self.relations = model_def["Relations"] + self.params = model_def["Parameters"] + self.constants = model_def["Constants"] + self.sample_time = model_def["Info"]["SampleTime"] + self.functions = model_def["Functions"] + + self.minimizers = model_def["Minimizers"] if "Minimizers" in model_def else {} + self.minimizers_keys = [ + self.minimizers[key]["A"] for key in self.minimizers + ] + [self.minimizers[key]["B"] for key in self.minimizers] + + self.input_ns_backward = { + key: value["ns"][0] for key, value in model_def["Inputs"].items() + } + self.input_n_samples = { + key: value["ntot"] for key, value in model_def["Inputs"].items() + } + + ## Build the network + self.all_parameters = {} + self.all_constants = {} + self.relation_forward = {} + self.relation_inputs = {} + self.closed_loop_update = {} + self.connect_update = {} + + ## Update the connect_update and closed_loop_update + self.update() + + ## Define the correct slicing + for _, items in self.relations.items(): + if items[0] == "SamplePart": + if items[1][0] in self.inputs.keys(): + items[3][0] = self.input_ns_backward[items[1][0]] + items[3][0] + items[3][1] = self.input_ns_backward[items[1][0]] + items[3][1] + if len(items) > 4: ## Offset + items[4] = self.input_ns_backward[items[1][0]] + items[4] + if items[0] == "TimePart": + if items[1][0] in self.inputs.keys(): + items[3][0] = self.input_ns_backward[items[1][0]] + round( + items[3][0] / self.sample_time + ) + items[3][1] = self.input_ns_backward[items[1][0]] + round( + items[3][1] / self.sample_time + ) + if len(items) > 4: ## Offset + items[4] = self.input_ns_backward[items[1][0]] + round( + items[4] / self.sample_time + ) + else: + items[3][0] = round(items[3][0] / self.sample_time) + items[3][1] = round(items[3][1] / self.sample_time) + if len(items) > 4: ## Offset + items[4] = round(items[4] / self.sample_time) + + ## Create all the parameters + for name, param_data in self.params.items(): + window = ( + "tw" + if "tw" in param_data.keys() + else ("sw" if "sw" in param_data.keys() else None) + ) + aux_sample_time = self.sample_time if "tw" == window else 1 + sample_window = ( + round(param_data[window] / aux_sample_time) if window else None + ) + if sample_window is None: + param_size = ( + tuple(param_data["dim"]) + if type(param_data["dim"]) is list + else (param_data["dim"],) + ) + else: + param_size = ( + (sample_window,) + tuple(param_data["dim"]) + if type(param_data["dim"]) is list + else (sample_window, param_data["dim"]) + ) + if "values" in param_data: + self.all_parameters[name] = nn.Parameter( + torch.tensor(param_data["values"], dtype=TORCH_DTYPE), + requires_grad=True, + ) + # TODO clean code + elif "init_fun" in param_data: + if "code" in param_data["init_fun"].keys(): + exec(param_data["init_fun"]["code"], globals()) + function_to_call = globals()[param_data["init_fun"]["name"]] + else: + function_to_call = getattr( + initializer, param_data["init_fun"]["name"] + ) + values = np.zeros(param_size) + for indexes in product(*(range(v) for v in param_size)): + if "params" in param_data["init_fun"]: + values[indexes] = function_to_call( + indexes, param_size, param_data["init_fun"]["params"] + ) + else: + values[indexes] = function_to_call(indexes, param_size) + self.all_parameters[name] = nn.Parameter( + torch.tensor(values.tolist(), dtype=TORCH_DTYPE), requires_grad=True + ) + else: + self.all_parameters[name] = nn.Parameter( + torch.rand(size=param_size, dtype=TORCH_DTYPE), requires_grad=True + ) + + ## Create all the constants + for name, param_data in self.constants.items(): + self.all_constants[name] = nn.Parameter( + torch.tensor(param_data["values"], dtype=TORCH_DTYPE), + requires_grad=False, + ) + all_params_and_consts = self.all_parameters | self.all_constants + + ## Create all the relations + for relation, inputs in self.relations.items(): + ## Take the relation name and the inputs needed to solve the relation + rel_name, input_var = inputs[0], inputs[1] + ## Create All the Relations + func = getattr(self, rel_name) + if func: + layer_inputs = [] + for item in inputs[2:]: + if item in list( + self.params.keys() + ): ## the relation takes parameters + layer_inputs.append(self.all_parameters[item]) + elif item in list( + self.constants.keys() + ): ## the relation takes a constant + layer_inputs.append(self.all_constants[item]) + elif item in list( + self.functions.keys() + ): ## the relation takes a custom function + layer_inputs.append(self.functions[item]) + if ( + "params_and_consts" in self.functions[item].keys() + and len(self.functions[item]["params_and_consts"]) >= 0 + ): ## Parametric function that takes parameters + layer_inputs.append( + [ + all_params_and_consts[par] + for par in self.functions[item]["params_and_consts"] + ] + ) + if "map_over_dim" in self.functions[item].keys(): + layer_inputs.append(self.functions[item]["map_over_dim"]) + else: + layer_inputs.append(item) + + if rel_name == "SamplePart": + if layer_inputs[0] == -1: + layer_inputs[0] = self.input_n_samples[input_var[0]] + elif rel_name == "TimePart": + if layer_inputs[0] == -1: + layer_inputs[0] = self.input_n_samples[input_var[0]] + else: + layer_inputs[0] = round(layer_inputs[0] / self.sample_time) + ## Initialize the relation + self.relation_forward[relation] = func(*layer_inputs) + ## Save the inputs needed for the relative relation + self.relation_inputs[relation] = input_var + + ## Add the gradient to all the relations and parameters that requires it + self.relation_forward = nn.ParameterDict(self.relation_forward) + self.all_constants = nn.ParameterDict(self.all_constants) + self.all_parameters = nn.ParameterDict(self.all_parameters) + ## list of network outputs + self.network_output_predictions = set(self.outputs.values()) + ## list of network minimization outputs + self.network_output_minimizers = [] + for _, value in self.minimizers.items(): + self.network_output_minimizers.append(self.outputs[value["A"]]) if value[ + "A" + ] in self.outputs.keys() else self.network_output_minimizers.append( + value["A"] + ) + self.network_output_minimizers.append(self.outputs[value["B"]]) if value[ + "B" + ] in self.outputs.keys() else self.network_output_minimizers.append( + value["B"] + ) + self.network_output_minimizers = set(self.network_output_minimizers) + ## list of all the network Outputs + self.network_outputs = self.network_output_predictions.union( + self.network_output_minimizers + ) + + def forward(self, kwargs): + result_dict = {} + + ## Initially i have only the inputs from the dataset, the parameters, and the constants + available_inputs = [ + key for key in self.inputs.keys() if key not in self.connect_update.keys() + ] ## remove connected inputs + available_keys = set( + available_inputs + + list(self.all_parameters.keys()) + + list(self.all_constants.keys()) + ) + + ## Forward pass through the relations + while not self.network_outputs.issubset( + available_keys + ): ## i need to climb the relation tree until i get all the outputs + for relation in self.relations.keys(): + ## if i have all the variables i can calculate the relation + if set(self.relation_inputs[relation]).issubset(available_keys) and ( + relation not in available_keys + ): + ## Collect all the necessary inputs for the relation + layer_inputs = [] + for key in self.relation_inputs[relation]: + if ( + key in self.all_constants.keys() + ): ## relation that takes a constant + layer_inputs.append(self.all_constants[key]) + elif key in available_inputs: ## relation that takes inputs + layer_inputs.append(kwargs[key]) + elif ( + key in self.all_parameters.keys() + ): ## relation that takes parameters + layer_inputs.append(self.all_parameters[key]) + else: ## relation than takes another relation or a connect variable + layer_inputs.append(result_dict[key]) + + ## Execute the current relation + result_dict[relation] = self.relation_forward[relation]( + *layer_inputs + ) + available_keys.add(relation) + + ## Check if the relation is inside the connect + for connect_input, connect_rel in self.connect_update.items(): + if relation == connect_rel: + result_dict[connect_input] = update_state( + kwargs[connect_input], result_dict[relation] + ) + available_keys.add(connect_input) + + ## Return a dictionary with all the connected inputs + connect_update_dict = { + key: result_dict[key] for key in self.connect_update.keys() + } + ## Return a dictionary with all the relations that updates the state variables + closed_loop_update_dict = { + key: result_dict[value] for key, value in self.closed_loop_update.items() + } + ## Return a dictionary with all the outputs final values + output_dict = {key: result_dict[value] for key, value in self.outputs.items()} + ## Return a dictionary with the minimization relations + minimize_dict = {} + for key in self.minimizers_keys: + minimize_dict[key] = ( + result_dict[self.outputs[key]] + if key in self.outputs.keys() + else result_dict[key] + ) + return output_dict, minimize_dict, closed_loop_update_dict, connect_update_dict + + def update(self, *, closed_loop={}, connect={}, disconnect=False): + self.closed_loop_update = {} + self.connect_update = {} + + if disconnect: + return + + for key, state in self.states.items(): + if "connect" in state.keys(): + self.connect_update[key] = state["connect"] + elif "closedLoop" in state.keys(): + self.closed_loop_update[key] = state["closedLoop"] + + # Get relation from outputs + for connect_in, connect_rel in connect.items(): + set_relation = ( + self.outputs[connect_rel] + if connect_rel in self.outputs.keys() + else connect_rel + ) + self.connect_update[connect_in] = set_relation + for close_in, close_rel in closed_loop.items(): + set_relation = ( + self.outputs[close_rel] + if close_rel in self.outputs.keys() + else close_rel + ) + self.closed_loop_update[close_in] = set_relation diff --git a/src/nnodely/basic/modeldef.py b/src/nnodely/basic/modeldef.py new file mode 100644 index 00000000..9c9e4956 --- /dev/null +++ b/src/nnodely/basic/modeldef.py @@ -0,0 +1,345 @@ +import copy + +import numpy as np + +from nnodely.support.utils import check, check_and_get_list +from nnodely.support.jsonutils import ( + merge, + subjson_from_model, + subjson_from_minimize, + check_model, + get_models_json, +) +from nnodely.basic.relation import MAIN_JSON, Stream, check_names +from nnodely.layers.output import Output +from nnodely.layers.input import Input + +from nnodely.support.logger import logging, nnLogger + +log = nnLogger(__name__, logging.INFO) + + +class ModelDef: + def __init__(self, model_def=MAIN_JSON): + # Models definition + self.__json_base = copy.deepcopy(model_def) + + # Initialize the model definition + self.__json = copy.deepcopy(self.__json_base) + if "SampleTime" in self.__json["Info"]: + self.__sample_time = self.__json["Info"]["SampleTime"] + else: + self.__sample_time = None + + def __contains__(self, key): + return key in self.__json + + def __getitem__(self, key): + if key in self.__json: + return self.__json[key] + else: + return None + + def __setitem__(self, key, value): + self.__json[key] = value + + def __rebuild_json(self, models_names, minimizers): + models_json = subjson_from_model(self.__json, list(models_names)) + if "Minimizers" in self.__json and len(minimizers) > 0: + minimizers_json = subjson_from_minimize(self.__json, list(minimizers)) + models_json = merge(models_json, minimizers_json) + return copy.deepcopy(models_json) + + def recurrentInputs(self): + return { + key: value + for key, value in self.__json["Inputs"].items() + if ("closedLoop" in value.keys() or "connect" in value.keys()) + } + + def getJson(self, models: list | str | None = None) -> dict: + if models is None: + return copy.deepcopy(self.__json) + else: + json = subjson_from_model(self.__json, models) + check_model(json) + return copy.deepcopy(json) + + def getSampleTime(self): + check( + self.__sample_time is not None, + AttributeError, + "Sample time is not defined the model is not neuralized!", + ) + return self.__sample_time + + def isDefined(self): + return self.__json is not None + + def addConnection( + self, + stream_out: str | Output | Stream, + input_in: str | Input, + type: str, + local: bool = False, + ): + outputs = self.__json["Outputs"] + + if isinstance(stream_out, (Output, Stream)): + stream_name = ( + outputs[stream_out.name] + if stream_out.name in outputs.keys() + else stream_out.name + ) + else: + output_name = check_and_get_list( + stream_out, + set(outputs.keys()), + lambda name: f"The name {name} is not part of the available Outputs", + )[0] + stream_name = outputs[output_name] + + if isinstance(input_in, Input): + input_name = input_in.name + else: + input_name = input_in # TODO Add tests + + input_name = check_and_get_list( + input_name, + set(self.__json["Inputs"].keys()), + lambda name: f"The name {name} is not part of the available Inputs", + )[0] + stream_name = check_and_get_list( + stream_name, + set(self.__json["Relations"].keys()), + lambda name: f"The name {name} is not part of the available Relations", + )[0] + self.__json["Inputs"][input_name][type] = stream_name + self.__json["Inputs"][input_name]["local"] = int(local) + + def removeConnection(self, name_list: str | list[str]): + name_list = check_and_get_list( + name_list, + set(self.__json["Inputs"].keys()), + lambda name: f"The name {name} is not part of the available Inputs", + ) + for input_in in name_list: + if "closedLoop" in self.__json["Inputs"][input_in].keys(): + del self.__json["Inputs"][input_in]["closedLoop"] + del self.__json["Inputs"][input_in]["local"] + elif "connect" in self.__json["Inputs"][input_in].keys(): + del self.__json["Inputs"][input_in]["connect"] + del self.__json["Inputs"][input_in]["local"] + else: + raise ValueError( + f"The input '{input_in}' has no connection or closed loop defined" + ) + + def addModel(self, name: str, stream_list): + if isinstance(stream_list, Output): + stream_list = [stream_list] + + json = MAIN_JSON + for stream in stream_list: + json = merge(json, stream.json) + check_model(json) + + if "Models" not in self.__json: + self.__json = merge(self.__json, json) + self.__json["Models"] = name + else: + models_names = ( + set((self.__json["Models"],)) + if type(self.__json["Models"]) is str + else set(self.__json["Models"].keys()) + ) + check_names(name, models_names, "Models") + if type(self.__json["Models"]) is str: + self.__json["Models"] = { + self.__json["Models"]: get_models_json(self.__json) + } + self.__json = merge(self.__json, json) + self.__json["Models"][name] = get_models_json(json) + + def removeModel(self, name_list): + if "Models" not in self.__json: + raise ValueError("No Models are defined") + models_names = ( + {self.__json["Models"]} + if type(self.__json["Models"]) is str + else set(self.__json["Models"].keys()) + ) + name_list = check_and_get_list( + name_list, + models_names, + lambda name: f"The name {name} is not part of the available models", + ) + models_names -= set(name_list) + minimizers = ( + set(self.__json["Minimizers"].keys()) + if "Minimizers" in self.__json + else None + ) + self.__json = self.__rebuild_json(models_names, minimizers) + + def addMinimize(self, name, streamA, streamB, loss_function="mse"): + if "Minimizers" not in self.__json: + self.__json["Minimizers"] = {} + check_names(name, set(self.__json["Minimizers"].keys()), "Minimizers") + + if isinstance(streamA, str): + streamA_name = streamA + else: + check( + isinstance(streamA, (Output, Stream)), + TypeError, + "streamA must be an instance of Output or Stream", + ) + streamA_name = ( + streamA.json["Outputs"][streamA.name] + if isinstance(streamA, Output) + else streamA.name + ) + self.__json = merge(self.__json, streamA.json) + + if isinstance(streamB, str): + streamB_name = streamB + else: + check( + isinstance(streamB, (Output, Stream)), + TypeError, + "streamA must be an instance of Output or Stream", + ) + streamB_name = ( + streamB.json["Outputs"][streamB.name] + if isinstance(streamB, Output) + else streamB.name + ) + self.__json = merge(self.__json, streamB.json) + # check(streamA.dim == streamB.dim, ValueError, f'Dimension of streamA={streamA.dim} and streamB={streamB.dim} are not equal.') + + self.__json["Minimizers"][name] = {} + self.__json["Minimizers"][name]["A"] = streamA_name + self.__json["Minimizers"][name]["B"] = streamB_name + self.__json["Minimizers"][name]["loss"] = loss_function + + def removeMinimize(self, name_list): + if "Minimizers" not in self.__json: + raise ValueError("No Minimizers are defined") + name_list = check_and_get_list( + name_list, + self.__json["Minimizers"].keys(), + lambda name: f"The name {name} is not part of the available minimizers", + ) + models_names = ( + {self.__json["Models"]} + if type(self.__json["Models"]) is str + else set(self.__json["Models"].keys()) + ) + remaining_minimizers = ( + set(self.__json["Minimizers"].keys()) - set(name_list) + if "Minimizers" in self.__json + else None + ) + self.__json = self.__rebuild_json(models_names, remaining_minimizers) + + def setBuildWindow(self, sample_time=None): + check(self.__json is not None, RuntimeError, "No model is defined!") + if sample_time is not None: + check( + sample_time > 0, RuntimeError, "Sample time must be strictly positive!" + ) + self.__sample_time = sample_time + else: + if self.__sample_time is None: + self.__sample_time = 1 + + self.__json["Info"] = {"SampleTime": self.__sample_time} + if "SampleTime" in self.__json["Constants"]: + self.__json["Constants"]["SampleTime"] = { + "dim": 1, + "values": self.__sample_time, + } + + check(self.__json["Inputs"] != {}, RuntimeError, "No model is defined!") + json_inputs = self.__json["Inputs"] + + input_ns_backward, input_ns_forward = {}, {} + for key, value in json_inputs.items(): + if "sw" not in value and "tw" not in value: + assert False, f"Input '{key}' has no time window or sample window" + if "sw" not in value and self.__sample_time is not None: + ## check if value['tw'] is a multiple of sample_time + absolute_tw = abs(value["tw"][0]) + abs(value["tw"][1]) + check( + round(absolute_tw % self.__sample_time) == 0, + ValueError, + f"Time window of input '{key}' is not a multiple of sample time. This network cannot be neuralized", + ) + input_ns_backward[key] = round(-value["tw"][0] / self.__sample_time) + input_ns_forward[key] = round(value["tw"][1] / self.__sample_time) + elif self.__sample_time is not None: + if "tw" in value: + input_ns_backward[key] = max( + round(-value["tw"][0] / self.__sample_time), -value["sw"][0] + ) + input_ns_forward[key] = max( + round(value["tw"][1] / self.__sample_time), value["sw"][1] + ) + else: + input_ns_backward[key] = -value["sw"][0] + input_ns_forward[key] = value["sw"][1] + else: + check( + value["tw"] == [0, 0], + RuntimeError, + f"Sample time is not defined for input '{key}'", + ) + input_ns_backward[key] = -value["sw"][0] + input_ns_forward[key] = value["sw"][1] + value["ns"] = [input_ns_backward[key], input_ns_forward[key]] + value["ntot"] = sum(value["ns"]) + + self.__json["Info"]["ns"] = [ + max(input_ns_backward.values()), + max(input_ns_forward.values()), + ] + self.__json["Info"]["ntot"] = sum(self.__json["Info"]["ns"]) + if self.__json["Info"]["ns"][0] < 0: + log.warning( + f"The input is only in the far past the max_samples_backward is: {self.__json['Info']['ns'][0]}" + ) + if self.__json["Info"]["ns"][1] < 0: + log.warning( + f"The input is only in the far future the max_sample_forward is: {self.__json['Info']['ns'][1]}" + ) + + for k, v in (self.__json["Parameters"] | self.__json["Constants"]).items(): + if "values" in v: + window = ( + "tw" if "tw" in v.keys() else ("sw" if "sw" in v.keys() else None) + ) + if window == "tw": + check( + np.array(v["values"]).shape[0] == v["tw"] / self.__sample_time, + ValueError, + f"{k} has a different number of values for this sample time.", + ) + if v["values"] == "SampleTime": + v["values"] = self.__sample_time + + def updateParameters(self, model=None, *, clear_model=False): + if clear_model: + for key in self.__json["Parameters"].keys(): + if "init_values" in self.__json["Parameters"][key]: + self.__json["Parameters"][key]["values"] = self.__json[ + "Parameters" + ][key]["init_values"] + elif "values" in self.__json["Parameters"][key]: + del self.__json["Parameters"][key]["values"] + elif model is not None: + for key in self.__json["Parameters"].keys(): + if key in model.all_parameters: + self.__json["Parameters"][key]["values"] = model.all_parameters[ + key + ].tolist() diff --git a/nnodely/basic/optimizer.py b/src/nnodely/basic/optimizer.py similarity index 78% rename from nnodely/basic/optimizer.py rename to src/nnodely/basic/optimizer.py index 15889697..9bde7f47 100644 --- a/nnodely/basic/optimizer.py +++ b/src/nnodely/basic/optimizer.py @@ -3,6 +3,7 @@ from nnodely.support.utils import check + class Optimizer: """ Represents an optimizer for training neural network models. @@ -29,7 +30,8 @@ class Optimizer: params_to_train : list or None A list of parameters to be trained. """ - def __init__(self, name, optimizer_defaults = {}, optimizer_params = []): + + def __init__(self, name, optimizer_defaults={}, optimizer_params=[]): """ Initializes the Optimizer object. @@ -64,9 +66,9 @@ def set_params_to_train(self, all_params, params_to_train): if self.optimizer_params == []: for param_name in self.all_params.keys(): if param_name in self.params_to_train: - self.optimizer_params.append({'params': param_name}) + self.optimizer_params.append({"params": param_name}) else: - self.optimizer_params.append({'params': param_name, 'lr': 0.0}) + self.optimizer_params.append({"params": param_name, "lr": 0.0}) def set_defaults(self, optimizer_defaults): """ @@ -110,18 +112,18 @@ def unfold(self, params): If the params argument is not a list. """ optimizer_params = [] - check(type(params) is list, KeyError, f'The params {params} must be a list') + check(type(params) is list, KeyError, f"The params {params} must be a list") for param in params: - if type(param['params']) is list: + if type(param["params"]) is list: par_copy = copy.deepcopy(param) - del par_copy['params'] - for par in param['params']: - optimizer_params.append({'params':par}|par_copy) + del par_copy["params"] + for par in param["params"]: + optimizer_params.append({"params": par} | par_copy) else: optimizer_params.append(param) return optimizer_params - def add_defaults(self, option_name, params, overwrite = True): + def add_defaults(self, option_name, params, overwrite=True): """ Adds default settings to the optimizer. @@ -140,41 +142,48 @@ def add_defaults(self, option_name, params, overwrite = True): elif option_name not in self.optimizer_defaults: self.optimizer_defaults[option_name] = params - def add_option_to_params(self, option_name, params, overwrite = True): + def add_option_to_params(self, option_name, params, overwrite=True): if params is None: return for key, value in params.items(): - check(self.all_params is not None, RuntimeError, "Call set_params before add_option_to_params") + check( + self.all_params is not None, + RuntimeError, + "Call set_params before add_option_to_params", + ) old_key = False for param in self.optimizer_params: - if param['params'] == key: + if param["params"] == key: old_key = True if overwrite: param[option_name] = value elif option_name not in param: param[option_name] = value if old_key == False: - self.optimizer_params.append({'params': key, option_name: value}) + self.optimizer_params.append({"params": key, option_name: value}) def replace_key_with_params(self): params = copy.deepcopy(self.optimizer_params) for param in params: - if type(param['params']) is list: - for ind, par in enumerate(param['params']): - param['params'][ind] = self.all_params[par] + if type(param["params"]) is list: + for ind, par in enumerate(param["params"]): + param["params"][ind] = self.all_params[par] else: - param['params'] = self.all_params[param['params']] + param["params"] = self.all_params[param["params"]] return params def get_torch_optimizer(self): - raise NotImplemented('The function get_torch_optimizer must be implemented.') + raise NotImplementedError( + "The function get_torch_optimizer must be implemented." + ) + class SGD(Optimizer): """ Stochastic Gradient Descent (SGD) optimizer. See also: - Official PyTorch SGD documentation: + Official PyTorch SGD documentation: `torch.optim.SGD `_ Parameters @@ -201,18 +210,22 @@ class SGD(Optimizer): nesterov : bool, optional Enables Nesterov momentum. Default is False. """ - def __init__(self, optimizer_defaults = {}, optimizer_params = []): - super(SGD, self).__init__('SGD', optimizer_defaults, optimizer_params) + + def __init__(self, optimizer_defaults={}, optimizer_params=[]): + super(SGD, self).__init__("SGD", optimizer_defaults, optimizer_params) def get_torch_optimizer(self): - return torch.optim.SGD(self.replace_key_with_params(), **self.optimizer_defaults) + return torch.optim.SGD( + self.replace_key_with_params(), **self.optimizer_defaults + ) + class Adam(Optimizer): """ Stochastic Gradient Descent (SGD) optimizer. See also: - Official PyTorch Adam documentation: + Official PyTorch Adam documentation: `torch.optim.Adam `_ Parameters @@ -239,8 +252,11 @@ class Adam(Optimizer): amsgrad : bool, optional Whether to use the AMSGrad variant of this algorithm. Default is False. """ - def __init__(self, optimizer_defaults = {}, optimizer_params = []): - super(Adam, self).__init__('Adam', optimizer_defaults, optimizer_params) + + def __init__(self, optimizer_defaults={}, optimizer_params=[]): + super(Adam, self).__init__("Adam", optimizer_defaults, optimizer_params) def get_torch_optimizer(self): - return torch.optim.Adam(self.replace_key_with_params(), **self.optimizer_defaults) \ No newline at end of file + return torch.optim.Adam( + self.replace_key_with_params(), **self.optimizer_defaults + ) diff --git a/nnodely/basic/relation.py b/src/nnodely/basic/relation.py similarity index 62% rename from nnodely/basic/relation.py rename to src/nnodely/basic/relation.py index b99a7d50..8e4e2011 100644 --- a/nnodely/basic/relation.py +++ b/src/nnodely/basic/relation.py @@ -6,42 +6,56 @@ from nnodely.support.jsonutils import merge, stream_to_str from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) MAIN_JSON = { - 'Info' : {}, - 'Inputs' : {}, - 'Constants': {}, - 'Parameters' : {}, - 'Functions' : {}, - 'Relations': {}, - 'Outputs': {} - } + "Info": {}, + "Inputs": {}, + "Constants": {}, + "Parameters": {}, + "Functions": {}, + "Relations": {}, + "Outputs": {}, +} CHECK_NAMES = False if is_notebook() else True + def toStream(obj): from nnodely.layers.parameter import Parameter, Constant - if type(obj) in (int,float,list,np.ndarray): - obj = Constant('Constant'+str(NeuObj.count), obj) - #obj = Stream(obj, MAIN_JSON, {'dim': 1}) if type(obj) in (int, float) else obj + + if type(obj) in (int, float, list, np.ndarray): + obj = Constant("Constant" + str(NeuObj.count), obj) + # obj = Stream(obj, MAIN_JSON, {'dim': 1}) if type(obj) in (int, float) else obj if type(obj) is Parameter or type(obj) is Constant: obj = Stream(obj.name, obj.json, obj.dim) return obj -def check_names(name:str, name_list, list_type): - check(name not in ForbiddenTags, NameError, f"The name '{name}' is a forbidden tag.") + +def check_names(name: str, name_list, list_type): + check( + name not in ForbiddenTags, NameError, f"The name '{name}' is a forbidden tag." + ) if CHECK_NAMES == True: - check(name not in name_list, NameError, f"The name '{name}' is already used as {list_type}.") + check( + name not in name_list, + NameError, + f"The name '{name}' is already used as {list_type}.", + ) elif name in name_list: - log.warning(f"The name '{name}' is already in defined as {list_type} but it is overwritten.") + log.warning( + f"The name '{name}' is already in defined as {list_type} but it is overwritten." + ) -class NeuObj(): + +class NeuObj: count = 0 names = [] + @classmethod @enforce_types - def clearNames(cls, names:str|list|None=None): + def clearNames(cls, names: str | list | None = None): if names is None: NeuObj.count = 0 NeuObj.names = [] @@ -54,10 +68,10 @@ def clearNames(cls, names:str|list|None=None): if names in NeuObj.names: NeuObj.names.remove(names) - def __init__(self, name='', json={}, dim=0): + def __init__(self, name="", json={}, dim=0): NeuObj.count += 1 - if name == '': - name = 'Auto'+str(NeuObj.count) + if name == "": + name = "Auto" + str(NeuObj.count) check_names(name, NeuObj.names, "NeuObj") NeuObj.names.append(name) self.name = name @@ -67,63 +81,82 @@ def __init__(self, name='', json={}, dim=0): else: self.json = copy.deepcopy(MAIN_JSON) -class Relation(): + +class Relation: def __add__(self, obj): from nnodely.layers.arithmetic import Add + return Add(self, obj) def __radd__(self, obj): from nnodely.layers.arithmetic import Add + return Add(obj, self) def __sub__(self, obj): from nnodely.layers.arithmetic import Sub + return Sub(self, obj) def __rsub__(self, obj): from nnodely.layers.arithmetic import Sub + return Sub(obj, self) def __truediv__(self, obj): from nnodely.layers.arithmetic import Div + return Div(self, obj) def __rtruediv__(self, obj): from nnodely.layers.arithmetic import Div + return Div(obj, self) def __mul__(self, obj): from nnodely.layers.arithmetic import Mul + return Mul(self, obj) def __rmul__(self, obj): from nnodely.layers.arithmetic import Mul + return Mul(obj, self) def __pow__(self, obj): from nnodely.layers.arithmetic import Pow + return Pow(self, obj) def __rpow__(self, obj): from nnodely.layers.arithmetic import Pow + return Pow(obj, self) def __neg__(self): from nnodely.layers.arithmetic import Neg + return Neg(self) + class Stream(Relation): """ Represents a stream of data inside the neural network. A Stream is automatically create when you operate over a Input, Parameter, or Constant object. """ + count = 0 + @classmethod def resetCount(cls): Stream.count = 0 - def __init__(self, name, json, dim, count = 1): + def __init__(self, name, json, dim, count=1): Stream.count += count - check(name not in ForbiddenTags, NameError, f"The name '{name}' is a forbidden tag.") + check( + name not in ForbiddenTags, + NameError, + f"The name '{name}' is a forbidden tag.", + ) self.name = name self.json = copy.deepcopy(json) self.dim = dim @@ -135,7 +168,13 @@ def __repr__(self): return self.__str__() @enforce_types - def tw(self, tw:float|int|list, offset:float|int|None = None, *, name:str|None = None) -> "Stream": + def tw( + self, + tw: float | int | list, + offset: float | int | None = None, + *, + name: str | None = None, + ) -> "Stream": """ Selects a time window on Stream. It is possible to create a smaller or bigger time window on the stream. The Time Window must be in the past not in the future. @@ -157,19 +196,28 @@ def tw(self, tw:float|int|list, offset:float|int|None = None, *, name:str|None = """ from nnodely.layers.input import Input from nnodely.layers.part import TimePart + if name is None: - name = self.name+"_tw"+str(NeuObj.count) + name = self.name + "_tw" + str(NeuObj.count) if type(tw) is list: - check(0 >= tw[1] > tw[0] and tw[0] < 0, ValueError, "The dimension of the sample window must be in the past.") - if 'tw' not in self.dim: - self.dim['tw'] = 0 + check( + 0 >= tw[1] > tw[0] and tw[0] < 0, + ValueError, + "The dimension of the sample window must be in the past.", + ) + if "tw" not in self.dim: + self.dim["tw"] = 0 if type(tw) is not list: - tw = [-tw,0] - delayed_input = Input(name, dimensions=self.dim['dim']).connect(self).tw([tw[0],0], offset) - return TimePart(delayed_input,tw[0]-tw[0],tw[1]-tw[0]) + tw = [-tw, 0] + delayed_input = ( + Input(name, dimensions=self.dim["dim"]).connect(self).tw([tw[0], 0], offset) + ) + return TimePart(delayed_input, tw[0] - tw[0], tw[1] - tw[0]) @enforce_types - def sw(self, sw:int|list, offset:int|None = None, *, name:str|None = None) -> "Stream": + def sw( + self, sw: int | list, offset: int | None = None, *, name: str | None = None + ) -> "Stream": """ Selects a sample window on Stream. It is possible to create a smaller or bigger window on the stream. The Sample Window must be in the past not in the future. @@ -191,19 +239,26 @@ def sw(self, sw:int|list, offset:int|None = None, *, name:str|None = None) -> "S """ from nnodely.layers.input import Input from nnodely.layers.part import SamplePart + if name is None: - name = self.name+"_sw"+str(NeuObj.count) + name = self.name + "_sw" + str(NeuObj.count) if type(sw) is list: - check(0 >= sw[1] > sw[0] and sw[0] < 0, ValueError, "The dimension of the sample window must be in the past.") - if 'sw' not in self.dim: - self.dim['sw'] = 0 + check( + 0 >= sw[1] > sw[0] and sw[0] < 0, + ValueError, + "The dimension of the sample window must be in the past.", + ) + if "sw" not in self.dim: + self.dim["sw"] = 0 if type(sw) is not list: - sw = [-sw,0] - delayed_input = Input(name, dimensions=self.dim['dim']).connect(self).sw([sw[0],0], offset) - return SamplePart(delayed_input,sw[0]-sw[0],sw[1]-sw[0]) + sw = [-sw, 0] + delayed_input = ( + Input(name, dimensions=self.dim["dim"]).connect(self).sw([sw[0], 0], offset) + ) + return SamplePart(delayed_input, sw[0] - sw[0], sw[1] - sw[0]) @enforce_types - def z(self, delay:int|float, *, name:str|None = None) -> "Stream": + def z(self, delay: int | float, *, name: str | None = None) -> "Stream": # TODO fix the convetion z-1 means a dealy z+1 means unitary advance """ Considering the Zeta transform notation. The function is used to delay a Stream. @@ -220,11 +275,15 @@ def z(self, delay:int|float, *, name:str|None = None) -> "Stream": A Stream representing the delayed Stream """ check(delay > 0, ValueError, "The delay must be a positive integer") - check('sw' in self.dim, TypeError, "The stream is not defined in samples but in time") - return self.sw([-self.dim['sw']-delay,-delay], name = name) + check( + "sw" in self.dim, + TypeError, + "The stream is not defined in samples but in time", + ) + return self.sw([-self.dim["sw"] - delay, -delay], name=name) @enforce_types - def delay(self, delay:int|float, *, name:str|None = None) -> "Stream": + def delay(self, delay: int | float, *, name: str | None = None) -> "Stream": """ The function is used to delay a Stream. The value of the delay can be only positive. @@ -240,11 +299,22 @@ def delay(self, delay:int|float, *, name:str|None = None) -> "Stream": A Stream representing the delayed Stream """ check(delay > 0, ValueError, "The delay must be a positive integer") - check('tw' in self.dim, TypeError, "The stream is not defined in time but in sample") - return self.tw([-self.dim['tw']-delay,-delay], name = name) + check( + "tw" in self.dim, + TypeError, + "The stream is not defined in time but in sample", + ) + return self.tw([-self.dim["tw"] - delay, -delay], name=name) @enforce_types - def s(self, order:int, *, int_name:str|None = None, der_name:str|None = None, method:str = 'euler') -> "Stream": + def s( + self, + order: int, + *, + int_name: str | None = None, + der_name: str | None = None, + method: str = "euler", + ) -> "Stream": """ Considering the Laplace transform notation. The function is used to operate an integral or derivate operation on a Stream. The order of the integral or the derivative operation is indicated by the order parameter. @@ -262,13 +332,20 @@ def s(self, order:int, *, int_name:str|None = None, der_name:str|None = None, me A Stream of the signal represents the integral or derivation operation. """ from nnodely.layers.timeoperation import Differentiate, Integrate - check(order != 0, ValueError, "The order must be a positive or negative integer not a zero") + + check( + order != 0, + ValueError, + "The order must be a positive or negative integer not a zero", + ) if order > 0: for i in range(order): - o = Differentiate(self, der_name = der_name, int_name = int_name, method = method) + o = Differentiate( + self, der_name=der_name, int_name=int_name, method=method + ) elif order < 0: for i in range(-order): - o = Integrate(self, der_name = der_name, int_name = int_name, method = method) + o = Integrate(self, der_name=der_name, int_name=int_name, method=method) return o def connect(self, obj) -> "Stream": @@ -293,13 +370,21 @@ def connect(self, obj) -> "Stream": If the input variable is already connected. """ from nnodely.layers.input import Input - check(type(obj) is Input, TypeError, - f"The {obj} must be a Input and not a {type(obj)}.") + + check( + type(obj) is Input, + TypeError, + f"The {obj} must be a Input and not a {type(obj)}.", + ) self.json = merge(self.json, obj.json) - check('closedLoop' not in self.json['Inputs'][obj.name] or 'connect' not in self.json['Inputs'][obj.name], KeyError, - f"The input variable {obj.name} is already connected.") - self.json['Inputs'][obj.name]['connect'] = self.name - self.json['Inputs'][obj.name]['local'] = 1 + check( + "closedLoop" not in self.json["Inputs"][obj.name] + or "connect" not in self.json["Inputs"][obj.name], + KeyError, + f"The input variable {obj.name} is already connected.", + ) + self.json["Inputs"][obj.name]["connect"] = self.name + self.json["Inputs"][obj.name]["local"] = 1 return self def closedLoop(self, obj) -> "Stream": @@ -324,27 +409,38 @@ def closedLoop(self, obj) -> "Stream": If the input variable is already connected. """ from nnodely.layers.input import Input - check(type(obj) is Input, TypeError, - f"The {obj} must be a Input and not a {type(obj)}.") + + check( + type(obj) is Input, + TypeError, + f"The {obj} must be a Input and not a {type(obj)}.", + ) self.json = merge(self.json, obj.json) - check('closedLoop' not in self.json['Inputs'][obj.name] or 'connect' not in self.json['Inputs'][obj.name], - KeyError, - f"The input variable {obj.name} is already connected.") - self.json['Inputs'][obj.name]['closedLoop'] = self.name - self.json['Inputs'][obj.name]['local'] = 1 + check( + "closedLoop" not in self.json["Inputs"][obj.name] + or "connect" not in self.json["Inputs"][obj.name], + KeyError, + f"The input variable {obj.name} is already connected.", + ) + self.json["Inputs"][obj.name]["closedLoop"] = self.name + self.json["Inputs"][obj.name]["local"] = 1 return self -class ToStream(): + +class ToStream: def __new__(cls, *args, **kwargs): - out = super(ToStream,cls).__new__(cls) + out = super(ToStream, cls).__new__(cls) out.__init__(*args, **kwargs) - return Stream(out.name,out.json,out.dim,0) + return Stream(out.name, out.json, out.dim, 0) + -class AutoToStream(): - def __new__(cls, *args, **kwargs): - if len(args) > 0 and (issubclass(type(args[0]),NeuObj) or type(args[0]) is Stream): +class AutoToStream: + def __new__(cls, *args, **kwargs): + if len(args) > 0 and ( + issubclass(type(args[0]), NeuObj) or type(args[0]) is Stream + ): instance = super().__new__(cls) - #instance.__init__(**kwargs) + # instance.__init__(**kwargs) instance.__init__() return instance(args[0]) instance = super().__new__(cls) diff --git a/nnodely/exporter/__init__.py b/src/nnodely/exporter/__init__.py similarity index 100% rename from nnodely/exporter/__init__.py rename to src/nnodely/exporter/__init__.py diff --git a/nnodely/exporter/emptyexporter.py b/src/nnodely/exporter/emptyexporter.py similarity index 56% rename from nnodely/exporter/emptyexporter.py rename to src/nnodely/exporter/emptyexporter.py index 6c6dbcf6..57406d2e 100644 --- a/nnodely/exporter/emptyexporter.py +++ b/src/nnodely/exporter/emptyexporter.py @@ -3,9 +3,9 @@ from datetime import datetime from nnodely.visualizer import EmptyVisualizer -class EmptyExporter: - def __init__(self, workspace = None, visualizer = None, save_history = False): +class EmptyExporter: + def __init__(self, workspace=None, visualizer=None, save_history=False): # Export parameters if workspace is not None: self.workspace = workspace @@ -22,26 +22,28 @@ def __init__(self, workspace = None, visualizer = None, save_history = False): else: self.visualizer = EmptyVisualizer() - def saveTorchModel(self, model, name = 'net', model_folder = None): + def saveTorchModel(self, model, name="net", model_folder=None): pass - def loadTorchModel(self, name = 'net', model_folder = None): + def loadTorchModel(self, name="net", model_folder=None): pass - def saveModel(self, model, name = 'net', model_folder = None): + def saveModel(self, model, name="net", model_folder=None): pass - def loadModel(self, name = 'net', model_folder = None): + def loadModel(self, name="net", model_folder=None): pass - def exportPythonModel(self, name = 'net', model_folder = None): + def exportPythonModel(self, name="net", model_folder=None): pass - def importPythonModel(self, name = 'net', model_folder = None): + def importPythonModel(self, name="net", model_folder=None): pass - def onnxInference(self, inputs:dict, name:str='net', model_folder:str|None=None): + def onnxInference( + self, inputs: dict, name: str = "net", model_folder: str | None = None + ): pass - def exportReport(self, name = 'net', model_folder = None): - pass \ No newline at end of file + def exportReport(self, name="net", model_folder=None): + pass diff --git a/src/nnodely/exporter/export.py b/src/nnodely/exporter/export.py new file mode 100644 index 00000000..a5575e10 --- /dev/null +++ b/src/nnodely/exporter/export.py @@ -0,0 +1,532 @@ +import sys +import os +import torch +import importlib +import json + +from torch.fx import symbolic_trace + +from pprint import PrettyPrinter + + +class JsonPrettyPrinter(PrettyPrinter): + def _format(self, object, *args): + if isinstance(object, str): + width = self._width + self._width = sys.maxsize + try: + super()._format(object.replace("'", '_"_'), *args) + finally: + self._width = width + else: + super()._format(object, *args) + + +def save_model(model, model_path): + # Export the dictionary as a JSON file + with open(model_path, "w") as json_file: + # json.dump(self.model_def, json_file, indent=4) + json_file.write( + JsonPrettyPrinter() + .pformat(model) + .replace("'", '"') + .replace('_"_', "'") + .replace("None", "null") + .replace("False", "false") + .replace("True", "true") + ) + # json_file.write(JsonPrettyPrinter().pformat(model).replace('None','null')) + # data = json.dumps(self.model_def) + # json_file.write(pformat(data).replace('\\\\n', '\\n').replace('\'', '').replace('(','').replace(')','')) + # json_file.write(pformat(data).replace('\'', '\"')) + + +def load_model(model_path): + import json + + with open(model_path, "r", encoding="UTF-8") as file: + model_def = json.load(file) + return model_def + + +def export_python_model(model_def, model, model_path): + package_name = __package__.split(".")[0] + + # Get the symbolic tracer + with torch.no_grad(): + trace = symbolic_trace(model) + + recurrent_inputs = { + key: value + for key, value in model_def["Inputs"].items() + if ("closedLoop" in value.keys() or "connect" in value.keys()) + } + inputs = { + key: value + for key, value in model_def["Inputs"].items() + if ("closedLoop" not in value.keys() and "connect" not in value.keys()) + } + attributes = sorted(set([line for line in trace.code.split() if "self." in line])) + + saved_functions = [] + + with open(model_path, "w") as file: + file.write("import torch\n\n") + + ## write the connect wrap function + # file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n") + # file.write(" virtual = torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n") + # file.write(" max_dim = min(rel.size(1), data_in.size(1))\n") + # file.write(" virtual[:, -max_dim:, :] = rel[:, -max_dim:, :]\n") + # file.write(" return virtual\n\n") + file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n") + file.write(" data_out = data_in.clone()\n") + file.write(" max_dim = min(rel.size(1), data_in.size(1))\n") + file.write(" data_out[:, -max_dim:, :] = rel[:, -max_dim:, :]\n") + file.write(" return data_out\n\n") + + file.write(f"def {package_name}_basic_model_timeshift(data_in):\n") + file.write( + " return torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n\n" + ) + + for name in model_def["Functions"].keys(): + if "Fuzzify" in name: + if "slicing" not in saved_functions: + # file.write("@torch.fx.wrap\n") + file.write( + f"def {package_name}_layers_fuzzify_slicing(res, i, x):\n" + ) + file.write(" res[:, :, i:i+1] = x\n\n") + saved_functions.append("slicing") + + function_name = model_def["Functions"][name]["names"] + function_code = model_def["Functions"][name]["functions"] + if isinstance(function_code, list): + for i, fun_code in enumerate(function_code): + if fun_code != "Rectangular" and fun_code != "Triangular": + if function_name[i] not in saved_functions: + fun_code = fun_code.replace( + f"def {function_name[i]}", + f"def {package_name}_layers_fuzzify_{function_name[i]}", + ) + # file.write("@torch.fx.wrap\n") + file.write(fun_code) + file.write("\n") + saved_functions.append(function_name[i]) + else: + if ( + (function_name != "Rectangular") + and (function_name != "Triangular") + and (function_name not in saved_functions) + ): + function_code = function_code.replace( + f"def {function_name}", + f"def {package_name}_layers_fuzzify_{function_name}", + ) + # file.write("@torch.fx.wrap\n") + file.write(function_code) + file.write("\n") + saved_functions.append(function_name) + + elif "ParamFun" in name: + function_name = model_def["Functions"][name]["name"] + if function_name not in saved_functions: + code = model_def["Functions"][name]["code"] + code = code.replace( + f"def {function_name}", + f"def {package_name}_layers_parametricfunction_{function_name}", + ) + file.write(code) + file.write("\n") + saved_functions.append(function_name) + + elif "NeuralODE" in name: + function_name = model_def["Functions"][name]["name"] + if function_name not in saved_functions: + code = model_def["Functions"][name]["code"] + code = code.replace( + f"def {function_name}", + f"def {package_name}_layers_neuralODE_{function_name}", + ) + file.write(code) + file.write("\n") + saved_functions.append(function_name) + + file.write("class TracerModel(torch.nn.Module):\n") + file.write(" def __init__(self):\n") + file.write(" super().__init__()\n") + file.write(" self.all_parameters = {}\n") + file.write(" self.all_constants = {}\n") + for attr in attributes: + if "all_constant" in attr: + key = attr.split(".")[-1] + file.write( + f' self.all_constants["{key}"] = torch.tensor({model.all_constants[key].tolist()}, requires_grad=False)\n' + ) + elif "relation_forward" in attr: + key = attr.split(".")[2] + if "Fir" in key or "Linear" in key: + if "weights" in attr.split(".")[3]: + param = model_def["Relations"][key][2] + value = model.all_parameters[param] + file.write( + f' self.all_parameters["{param}"] = torch.nn.Parameter(torch.tensor({value.tolist()}), requires_grad=True)\n' + ) + elif "bias" in attr.split(".")[3]: + param = model_def["Relations"][key][3] + file.write( + f' self.all_parameters["{param}"] = torch.nn.Parameter(torch.tensor({model.all_parameters[param].tolist()}), requires_grad=True)\n' + ) + elif "dropout" in attr.split(".")[3]: + param = model_def["Relations"][key][4] + file.write( + f" self.{key} = torch.nn.Dropout(p={param})\n" + ) + # param = model_def['Relations'][key][2] if 'weights' in attr.split('.')[3] else model_def['Relations'][key][3] + # value = model.all_parameters[param].data.squeeze(0) if 'Linear' in key else model.all_parameters[param].data + # file.write(f" self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.{value}, requires_grad=True)\n") + elif ( + "Part" in key or "Select" in key + ): # any(element in key for element in ['Part', 'Select']): + value = model.relation_forward[key].W + temp_value = json.dumps(value.tolist()) + file.write( + f' self.all_constants["{key}"] = torch.tensor({temp_value}, requires_grad=True)\n' + ) + elif "all_parameters" in attr: + key = attr.split(".")[-1] + file.write( + f' self.all_parameters["{key}"] = torch.nn.Parameter(torch.tensor({model.all_parameters[key].tolist()}), requires_grad=True)\n' + ) + elif "_tensor_constant" in attr: + key = attr.split(".")[-1] + file.write( + f" {attr} = torch.tensor({getattr(model, key).item()})\n" + ) + + file.write( + " self.all_parameters = torch.nn.ParameterDict(self.all_parameters)\n" + ) + file.write( + " self.all_constants = torch.nn.ParameterDict(self.all_constants)\n\n" + ) + file.write( + " def update(self, closed_loop={}, connect={}, disconnect=False):\n" + ) + file.write(" pass\n") + + for line in trace.code.split("\n")[len(saved_functions) + 2 :]: + if "self.relation_forward" in line: + if "Part" in line or "Select" in line: + attribute = [ + x for x in line.split() if "self.relation_forward" in x + ][0].split(".")[2] + old_line = f"self.relation_forward.{attribute}.W" + new_line = f"self.all_constants.{attribute}" + file.write(f" {line.replace(old_line, new_line)}\n") + elif "dropout" in line: + attribute = line.split()[0] + layer = attribute.split("_")[2].capitalize() + old_line = f"self.relation_forward.{layer}.dropout" + new_line = f"self.{layer}" + file.write(f" {line.replace(old_line, new_line)}\n") + else: + attribute = line.split()[-1] + relation = attribute.split(".")[2] + relation_type = attribute.split(".")[3] + param = ( + model_def["Relations"][relation][2] + if "weights" == relation_type + else model_def["Relations"][relation][3] + ) + new_attribute = f"self.all_parameters.{param}" + file.write(f" {line.replace(attribute, new_attribute)}\n") + else: + file.write(f" {line}\n") + + if len(recurrent_inputs) > 0: + file.write("class RecurrentModel(torch.nn.Module):\n") + file.write(" def __init__(self):\n") + file.write(" super().__init__()\n") + file.write(" self.Cell = TracerModel()\n") + list_inputs = " self.inputs = [" + for key in inputs.keys(): + list_inputs += f"'{key}', " + list_inputs += "]\n" + file.write(list_inputs) + file.write(" self.states = dict()\n") + file.write("\n") + file.write(" def forward(self, kwargs, n_samples = None):\n") + file.write( + " n_samples = n_samples if n_samples else min([kwargs[key].size(0) for key in self.inputs])\n" + ) + for key in recurrent_inputs.keys(): + file.write(f" self.states['{key}'] = kwargs['{key}']\n") + result_str = "" + for key, value in model_def["Outputs"].items(): + result_str += f"'{key}':[], " + file.write(f" results = {{{result_str}}}\n") + file.write(" X = dict()\n") + file.write(" for idx in range(n_samples):\n") + file.write(" for key in self.inputs:\n") + file.write(" X[key] = kwargs[key][idx]\n") + file.write(" for key, value in self.states.items():\n") + file.write(" X[key] = value\n") + file.write(" out, _, closed_loop, connect = self.Cell(X)\n") + file.write(" for key, value in results.items():\n") + file.write(" results[key].append(out[key])\n") + file.write(" for key, val in closed_loop.items():\n") + file.write( + " self.states[key] = nnodely_basic_model_timeshift(self.states[key])\n" + ) + file.write( + " self.states[key] = nnodely_basic_model_update_state(self.states[key], val)\n" + ) + file.write(" for key, val in connect.items():\n") + file.write( + " self.states[key] = nnodely_basic_model_timeshift(val)\n" + ) + file.write(" return results\n") + + +def export_pythononnx_model( + model_def, model_path, model_onnx_path, input_order=None, outputs_order=None +): + closed_loop_states, connect_states = [], [] + for key, value in model_def["Inputs"].items(): + if "closedLoop" in value.keys(): + closed_loop_states.append(key) + if "connect" in value.keys(): + connect_states.append(key) + + model_inputs = input_order if input_order else list(model_def["Inputs"].keys()) + model_outputs = ( + outputs_order if outputs_order else list(model_def["Outputs"].keys()) + ) + model_losses = [] + if model_def["Minimizers"]: + model_losses = [ + loss_dict["A"] + for loss_dict in model_def["Minimizers"].values() + if "A" in loss_dict.keys() + ] + [ + loss_dict["B"] + for loss_dict in model_def["Minimizers"].values() + if "A" in loss_dict.keys() + ] + recurrent_inputs = [ + key + for key, value in model_def["Inputs"].items() + if ("closedLoop" in value.keys() or "connect" in value.keys()) + ] + inputs = [key for key in model_inputs if key not in recurrent_inputs] + + # Define the mapping dictionary input + trace_mapping_input = {} + forward = "def forward(self," + for i, key in enumerate(model_inputs): + value = f"kwargs['{key}']" + trace_mapping_input[value] = key + forward = forward + f" {key}" + ("," if i < len(model_inputs) - 1 else "") + forward = forward + "):" + # Define the mapping dictionary output + outputs = " return (" + for i, key in enumerate(model_outputs): + outputs += f"outputs[0]['{key}']" + ( + "," if i < len(model_outputs) - 1 else ",)" + ) + outputs += ", (" + for i, key in enumerate(model_losses): + outputs += ( + f"outputs[1]['{key}'], " # + (',' if i < len(model_outputs) - 1 else ',)') + ) + outputs += "), (" + for key in closed_loop_states: + outputs += f"outputs[2]['{key}'], " + outputs += "), (" + for key in connect_states: + outputs += f"outputs[3]['{key}'], " + outputs += ")\n" + + # Open and read the file + file_content = [] + with open(model_path, "r") as file: + for line in file: + if "return ({" in line: + file_content.append(line) + break + file_content.append(line) + file_content = "".join(file_content) + + # Replace the forward header + file_content = file_content.replace("def forward(self, kwargs):", forward) + # Perform the substitution + for key, value in trace_mapping_input.items(): + file_content = file_content.replace(key, value) + # Write the modified content back to a new file + # Replace the return statement + last_return_index = file_content.rfind("return") + if last_return_index != -1: + file_content = ( + file_content[:last_return_index] + + "outputs =" + + file_content[last_return_index + len("return") :] + ) + file_content += outputs + with open(model_onnx_path, "w") as file: + file.write(file_content) + + if len(recurrent_inputs) > 0: + file.write("\n") + file.write("class RecurrentModel(torch.nn.Module):\n") + file.write(" def __init__(self):\n") + file.write(" super().__init__()\n") + file.write(" self.Cell = TracerModel()\n") + + forward_str = " def forward(self, " + for key in model_inputs: + forward_str += f"{key}, " + forward_str += "):\n" + file.write(forward_str) + + if model_inputs: + file.write( + " n_samples = min([" + + ", ".join([f"{key}.size(0)" for key in inputs]) + + "])\n" + ) + else: + file.write(" n_samples = 1\n") + + for key in model_outputs: + file.write(f" results_{key} = []\n") + file.write(" for idx in range(n_samples):\n") + call_str = " out, losses, closed_loop, connect = self.Cell(" + for key in model_inputs: + call_str += f"{key}[idx], " if key in inputs else f"{key}, " + call_str += ")\n" + file.write(call_str) + for idx, key in enumerate(model_outputs): + file.write(f" results_{key}.append(out[{idx}])\n") + for idx, key in enumerate(closed_loop_states): + file.write( + f" {key} = nnodely_basic_model_timeshift({key})\n" + ) + file.write( + f" {key} = nnodely_basic_model_update_state({key}, closed_loop[{idx}])\n" + ) + for idx, key in enumerate(connect_states): + file.write( + f" {key} = nnodely_basic_model_timeshift(connect[{idx}])\n" + ) + # file.write(f" {key} = connect[{idx}]\n") + for idx, key in enumerate(model_outputs): + file.write( + f" results_{key} = torch.stack(results_{key}, dim=0)\n" + ) + return_str = " return " + for key in model_outputs: + return_str += f"results_{key}, " + file.write(return_str) + + +def import_python_model(name, model_folder): + sys.path.insert(0, model_folder) + module_name = os.path.basename(name) + if module_name in sys.modules: + # Reload the module if it is already loaded + module = importlib.reload(sys.modules[module_name]) + else: + # Import the module if it is not loaded + module = importlib.import_module(module_name) + return module.TracerModel() + + +def export_onnx_model( + model_def, model, model_path, input_order=None, output_order=None, name="net_onnx" +): + sys.path.insert(0, model_path) + module_name = os.path.basename(name) + + recurrent_inputs = { + key: value + for key, value in model_def["Inputs"].items() + if ("closedLoop" in value.keys() or "connect" in value.keys()) + } + inputs = { + key: value + for key, value in model_def["Inputs"].items() + if ("closedLoop" not in value.keys() and "connect" not in value.keys()) + } + + if module_name in sys.modules: + # Reload the module if it is already loaded + module = importlib.reload(sys.modules[module_name]) + else: + # Import the module if it is not loaded + module = importlib.import_module(module_name) + model = ( + torch.jit.script(module.RecurrentModel()) + if len(recurrent_inputs) > 0 + else module.TracerModel() + ) + model.eval() + dummy_inputs = [] + input_names = [] + dynamic_axes = {} + onnx_inputs = input_order if input_order else model_def["Inputs"].keys() + for key in onnx_inputs: + input_names.append(key) + window_size = model_def["Inputs"][key]["ntot"] + dim = model_def["Inputs"][key]["dim"] + if len(recurrent_inputs) > 0 != {}: + if key in inputs.keys(): + dummy_inputs.append(torch.randn(size=(1, 1, window_size, dim))) + dynamic_axes[key] = {0: "horizon", 1: "batch_size"} + elif key in recurrent_inputs.keys(): + dummy_inputs.append(torch.randn(size=(1, window_size, dim))) + dynamic_axes[key] = {0: "batch_size"} + else: + dummy_inputs.append(torch.randn(size=(1, window_size, dim))) + dynamic_axes[key] = {0: "batch_size"} + output_names = output_order if output_order else list(model_def["Outputs"].keys()) + dummy_inputs = tuple(dummy_inputs) + + torch.onnx.export( + model, # The model to be exported + dummy_inputs, # Tuple of inputs to match the forward signature + model_path, # File path to save the ONNX model + export_params=True, # Store the trained parameters in the model file + opset_version=17, # ONNX version to export to (you can use 11 or higher) + do_constant_folding=False, # Optimize constant folding for inference + input_names=input_names, # Name each input as they will appear in ONNX + output_names=output_names, # Name the output + dynamic_axes=dynamic_axes, + ) + + +def onnx_inference(inputs, path, optimize_graph=False): + import onnxruntime as ort + + # Create an ONNX Runtime session + # Define session options + ## TODO: Warning when using constant folding in inference CanUpdateImplicitInputNameInSubgraphs] + ## TODO: Implicit input name Cell.all_constants.Constant75 cannot be safely updated to Cell.all_constants.Constant76 in one of the subgraphs. + if optimize_graph == False: + session_options = ort.SessionOptions() + # Set graph optimization level to disable all optimizations + session_options.graph_optimization_level = ( + ort.GraphOptimizationLevel.ORT_DISABLE_ALL + ) + session = ort.InferenceSession(path, sess_options=session_options) + else: + session = ort.InferenceSession(path) + output_data = [] + for item in session.get_outputs(): + output_data.append(item.name) + input_data = {} + for item in session.get_inputs(): + input_data[item.name] = inputs[item.name] + # Run inference + return session.run(output_data, input_data) diff --git a/src/nnodely/exporter/reporter.py b/src/nnodely/exporter/reporter.py new file mode 100644 index 00000000..8259fa12 --- /dev/null +++ b/src/nnodely/exporter/reporter.py @@ -0,0 +1,81 @@ +import io + +import matplotlib.pyplot as plt +from reportlab.lib.pagesizes import letter +from reportlab.pdfgen import canvas +from reportlab.lib.utils import ImageReader + +from mplplots import plots + + +class Reporter: + def __init__(self, modely): + self.modely = modely + + def exportReport(self, report_path): + c = canvas.Canvas(report_path, pagesize=letter) + width, height = letter + + if "Minimizers" in self.modely._model_def: + for key, value in self.modely._model_def["Minimizers"].items(): + fig = plt.figure(figsize=(10, 5)) + ax = fig.add_subplot(111) + if "val" in self.modely._training[key]: + plots.plot_training( + ax, + f"Training Loss of {key}", + key, + self.modely._training[key]["train"], + self.modely._training[key]["val"], + ) + else: + plots.plot_training( + ax, + f"Training Loss of {key}", + key, + self.modely._training[key]["train"], + ) + training = io.BytesIO() + plt.savefig(training, format="png") + training.seek(0) + plt.close() + c.drawString(100, height - 30, f"Training Loss of {key}") + c.drawImage( + ImageReader(training), 50, height - 290, width=500, height=250 + ) + c.showPage() + + if len(self.modely.prediction) > 0: + for key in self.modely._model_def["Minimizers"].keys(): + c.drawString(100, height - 30, f"Prediction of {key}") + for ind, name_data in enumerate(self.modely.prediction.keys()): + fig = plt.figure(figsize=(10, 5)) + ax = fig.add_subplot(111) + idxs = None + if "idxs" in self.modely.prediction[name_data]: + idxs = self.modely.prediction[name_data]["idxs"] + plots.plot_results( + ax, + name_data, + key, + self.modely.prediction[name_data][key]["A"], + self.modely.prediction[name_data][key]["B"], + idxs, + self.modely._model_def["Info"]["SampleTime"], + ) + # Add a text box with correlation coefficient + results = io.BytesIO() + plt.savefig(results, format="png") + results.seek(0) + plt.close() + c.drawImage( + ImageReader(results), + 50, + height - 290 - 245 * ind, + width=500, + height=250, + ) + c.showPage() + else: + c.drawString(100, height - 30, "No Minimize") + c.save() diff --git a/src/nnodely/exporter/standardexporter.py b/src/nnodely/exporter/standardexporter.py new file mode 100644 index 00000000..6e17073d --- /dev/null +++ b/src/nnodely/exporter/standardexporter.py @@ -0,0 +1,196 @@ +import os +import torch + +from nnodely.visualizer import EmptyVisualizer +from nnodely.exporter.emptyexporter import EmptyExporter +from nnodely.exporter.reporter import Reporter +from nnodely.exporter.export import ( + save_model, + load_model, + export_python_model, + export_pythononnx_model, + export_onnx_model, + import_python_model, + onnx_inference, +) +from nnodely.support.utils import check, enforce_types + +from nnodely.support.logger import logging, nnLogger + +log = nnLogger(__name__, logging.INFO) + + +class StandardExporter(EmptyExporter): + @enforce_types + def __init__( + self, + workspace: str | None = None, + visualizer: EmptyVisualizer | None = None, + *, + save_history: bool = False, + ): + super().__init__(workspace, visualizer, save_history) + + def getWorkspace(self): + return self.workspace_folder if hasattr(self, "workspace_folder") else "." + + def saveTorchModel(self, model, name="net", model_folder=None): + file_name = name + ".pt" + model_path = ( + os.path.join(self.getWorkspace(), file_name) + if model_folder is None + else os.path.join(model_folder, file_name) + ) + # TODO check if the folder exist + torch.save(model.state_dict(), model_path) + self.visualizer.saveModel("Torch Model", model_path) + + def loadTorchModel(self, model, name="net", model_folder=None): + file_name = name + ".pt" + model_path = ( + os.path.join(self.getWorkspace(), file_name) + if model_folder is None + else os.path.join(model_folder, file_name) + ) + check( + os.path.exists(model_path), + FileNotFoundError, + f"The model {name} it is not found in the folder {model_folder}", + ) + model.load_state_dict(torch.load(model_path, weights_only=True)) + self.visualizer.loadModel("Torch Model", model_path) + # TODO Update the model parameters.... + + def saveModel(self, model_def, name="net", model_folder=None): + # Combine the folder path and file name to form the complete file path + model_folder = self.getWorkspace() if model_folder is None else model_folder + # Specify the JSON file name + file_name = name + ".json" + # Combine the folder path and file name to form the complete file path + model_path = os.path.join(model_folder, file_name) + save_model(model_def, model_path) + self.visualizer.saveModel("JSON Model", model_path) + + def loadModel(self, name="net", model_folder=None): + # Combine the folder path and file name to form the complete file path + model_folder = self.getWorkspace() if model_folder is None else model_folder + model_def = None + try: + file_name = name + ".json" + model_path = os.path.join(model_folder, file_name) + model_def = load_model(model_path) + self.visualizer.loadModel("JSON Model", model_path) + except Exception as e: + check( + False, + FileNotFoundError, + f"The file {model_path} it is not found or not conformed.\n Error: {e}", + ) + return model_def + + def exportPythonModel(self, model_def, model, name="net", model_folder=None): + file_name = name + ".py" + model_path = ( + os.path.join(self.getWorkspace(), file_name) + if model_folder is None + else os.path.join(model_folder, file_name) + ) + ## Export to python file + export_python_model(model_def.getJson(), model, model_path) + self.visualizer.exportModel("Python Torch Model", model_path) + + def importPythonModel(self, name="net", model_folder=None): + try: + model_folder = self.getWorkspace() if model_folder is None else model_folder + model = import_python_model(name, model_folder) + self.visualizer.importModel( + "Python Torch Model", os.path.join(model_folder, name + ".py") + ) + except Exception as e: + model = None + check( + False, + FileNotFoundError, + f"The model {name} it is not found in the folder {model_folder}.\nError: {e}", + ) + return model + + def exportONNX( + self, + model_def, + model, + inputs_order=None, + outputs_order=None, + name="net", + model_folder=None, + ): + if inputs_order is None: + log.info( + f"The inputs order for the export is not specified, the order will set equal to {set(model_def['Inputs'].keys())}." + ) + elif set(inputs_order) != set(model_def["Inputs"].keys()): + raise ValueError( + f"The inputs are not the same as the model inputs {set(model_def['Inputs'].keys())}." + ) + if outputs_order is None: + log.info( + f"The outputs order for the export is not specified, the order will set equal to {set(model_def['Outputs'].keys())}" + ) + elif set(outputs_order) != set(model_def["Outputs"].keys()): + log.info( + f"The outputs are not the same as the model outputs {set(model_def['Outputs'].keys())}." + ) + file_name = name + ".py" + model_folder = ( + os.path.join(self.getWorkspace(), "onnx") + if model_folder is None + else model_folder + ) + os.makedirs(model_folder, exist_ok=True) + model_path = os.path.join(model_folder, file_name) + onnx_python_model_path = model_path.replace(".py", "_onnx.py") + onnx_model_path = model_path.replace(".py", ".onnx") + ## Export to python file (onnx compatible) + export_python_model(model_def, model, model_path) + self.visualizer.exportModel("Python Torch Model", model_path) + export_pythononnx_model( + model_def, model_path, onnx_python_model_path, inputs_order, outputs_order + ) + self.visualizer.exportModel("Python Onnx Torch Model", onnx_python_model_path) + ## Export to onnx file (onnx compatible) + model = import_python_model(file_name.replace(".py", "_onnx"), model_folder) + export_onnx_model( + model_def, + model, + onnx_model_path, + inputs_order, + outputs_order, + name=name + "_onnx", + ) + self.visualizer.exportModel("Onnx Model", onnx_model_path) + + def onnxInference(self, inputs, name: str = "net", model_folder: str | None = None): + model_folder = ( + os.path.join(self.getWorkspace(), "onnx") + if model_folder is None + else model_folder + ) + file_name = name + ".onnx" + onnx_model_path = os.path.join(model_folder, file_name) + check( + os.path.exists(onnx_model_path), + FileNotFoundError, + f"The model {file_name} it is not found in the folder {model_folder}", + ) + return onnx_inference(inputs, onnx_model_path) + + def exportReport(self, n4m, name="net", model_folder=None): + # Combine the folder path and file name to form the complete file path + model_folder = self.getWorkspace() if model_folder is None else model_folder + # Specify the JSON file name + file_name = name + ".pdf" + # Combine the folder path and file name to form the complete file path + report_path = os.path.join(model_folder, file_name) + reporter = Reporter(n4m) + reporter.exportReport(report_path) + self.visualizer.exportReport("Training Results", report_path) diff --git a/nnodely/layers/__init__.py b/src/nnodely/layers/__init__.py similarity index 100% rename from nnodely/layers/__init__.py rename to src/nnodely/layers/__init__.py diff --git a/nnodely/layers/activation.py b/src/nnodely/layers/activation.py similarity index 53% rename from nnodely/layers/activation.py rename to src/nnodely/layers/activation.py index a6c38482..4c432fa0 100644 --- a/nnodely/layers/activation.py +++ b/src/nnodely/layers/activation.py @@ -7,80 +7,95 @@ from nnodely.support.utils import check, enforce_types -relu_relation_name = 'Relu' -elu_relation_name = 'ELU' -sigmoid_relation_name = 'Sigmoid' -identity_relation_name = 'Identity' -softmax_relation_name = 'Softmax' +relu_relation_name = "Relu" +elu_relation_name = "ELU" +sigmoid_relation_name = "Sigmoid" +identity_relation_name = "Identity" +softmax_relation_name = "Softmax" + class Relu(Stream, ToStream): """ - Implement the Rectified-Linear Unit (ReLU) relation function. + Implement the Rectified-Linear Unit (ReLU) relation function. - See also: - Official PyTorch ReLU documentation: - `torch.nn.ReLU `_ + See also: + Official PyTorch ReLU documentation: + `torch.nn.ReLU `_ - :param obj: The relation stream. - :type obj: Stream + :param obj: The relation stream. + :type obj: Stream - Example: - -------- - .. include:: /examples_basics/layer_module_ex/activation_module_ex/relu.rst + Example: + -------- + .. include:: /examples_basics/layer_module_ex/activation_module_ex/relu.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Relu operation.") - super().__init__(relu_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [relu_relation_name,[obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Relu operation.", + ) + super().__init__(relu_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [relu_relation_name, [obj.name]] + class ELU(Stream, ToStream): """ - Implement the Exponential-Linear Unit (ELU) relation function. + Implement the Exponential-Linear Unit (ELU) relation function. - See also: - Official PyTorch ReLU documentation: - `torch.nn.ELU `_ + See also: + Official PyTorch ReLU documentation: + `torch.nn.ELU `_ - :param obj: The relation stream. - :type obj: Stream + :param obj: The relation stream. + :type obj: Stream - Example: - --------- - .. include:: /examples_basics/layer_module_ex/activation_module_ex/elu.rst + Example: + --------- + .. include:: /examples_basics/layer_module_ex/activation_module_ex/elu.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream,TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Tanh operation.") - super().__init__(elu_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [elu_relation_name,[obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Tanh operation.", + ) + super().__init__(elu_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [elu_relation_name, [obj.name]] + class Identity(Stream, ToStream): """ Implement the Identity relation function that simply returns the input vector x. See also: - Official PyTorch Identity documentation: + Official PyTorch Identity documentation: `torch.nn.Identity `_ :param obj: The relation stream. - :type obj: Stream + :type obj: Stream Example: --------- .. include:: /examples_basics/layer_module_ex/activation_module_ex/identity.rst """ + @enforce_types - def __init__(self, obj: Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Identity operation.") + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Identity operation.", + ) super().__init__(identity_relation_name + str(Stream.count), obj.json, obj.dim) - self.json['Relations'][self.name] = [identity_relation_name, [obj.name]] + self.json["Relations"][self.name] = [identity_relation_name, [obj.name]] class Softmax(Stream, ToStream): @@ -98,13 +113,18 @@ class Softmax(Stream, ToStream): --------- .. include:: /examples_basics/layer_module_ex/activation_module_ex/softmax.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Softmax operation.") + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Softmax operation.", + ) super().__init__(softmax_relation_name + str(Stream.count), obj.json, obj.dim) - self.json['Relations'][self.name] = [softmax_relation_name, [obj.name]] + self.json["Relations"][self.name] = [softmax_relation_name, [obj.name]] + class Sigmoid(Stream, ToStream): r""" @@ -125,74 +145,94 @@ class Sigmoid(Stream, ToStream): --------- .. include:: /examples_basics/layer_module_ex/activation_module_ex/sigmoid.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for {sigmoid_relation_name} operation.") + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for {sigmoid_relation_name} operation.", + ) super().__init__(sigmoid_relation_name + str(Stream.count), obj.json, obj.dim) - self.json['Relations'][self.name] = [sigmoid_relation_name, [obj.name]] + self.json["Relations"][self.name] = [sigmoid_relation_name, [obj.name]] + class Relu_Layer(nn.Module): """ - :noindex: + :noindex: """ - def __init__(self,): + + def __init__( + self, + ): super(Relu_Layer, self).__init__() + def forward(self, x): return torch.relu(x) - + + def createRelu(self, *input): """ - :noindex: + :noindex: """ return Relu_Layer() - + def createELU(self, *input): """ - :noindex: + :noindex: """ return nn.ELU() + class Identity_Layer(nn.Module): """ - :noindex: + :noindex: """ + def __init__(self, *args): super(Identity_Layer, self).__init__() def forward(self, x: torch.Tensor) -> torch.Tensor: return x - + + def createIdentity(self, *input): """ - :noindex: + :noindex: """ return Identity_Layer() class Sigmoid_Layer(nn.Module): """ - :noindex: + :noindex: """ - def __init__(self,): + + def __init__( + self, + ): super(Sigmoid_Layer, self).__init__() + def forward(self, x): - return 1/(1+torch.exp(-x)) - + return 1 / (1 + torch.exp(-x)) + + def createSigmoid(self, *input): """ - :noindex: + :noindex: """ return Sigmoid_Layer() + def createSoftmax(self, *input): """ - :noindex: + :noindex: """ return nn.Softmax(dim=-1) + setattr(Model, relu_relation_name, createRelu) setattr(Model, elu_relation_name, createELU) setattr(Model, sigmoid_relation_name, createSigmoid) diff --git a/src/nnodely/layers/arithmetic.py b/src/nnodely/layers/arithmetic.py new file mode 100644 index 00000000..240116e2 --- /dev/null +++ b/src/nnodely/layers/arithmetic.py @@ -0,0 +1,407 @@ +import torch.nn as nn +import torch + +from nnodely.basic.relation import ToStream, Stream, toStream +from nnodely.basic.model import Model +from nnodely.support.utils import check, enforce_types +from nnodely.layers.parameter import Parameter, Constant +from nnodely.support.jsonutils import merge, binary_cheks + + +# Binary operators +add_relation_name = "Add" +sub_relation_name = "Sub" +mul_relation_name = "Mul" +div_relation_name = "Div" +pow_relation_name = "Pow" + +# Unary operators +neg_relation_name = "Neg" +sign_relation_name = "Sign" + +# Merge operator +sum_relation_name = "Sum" + + +class Add(Stream, ToStream): + """ + Implement the addition function between two tensors. + (it is also possible to use the classical math operator '+') + + See also: + Official PyTorch Add documentation: + `torch.add `_ + + :param input1: the first element of the addition + :type obj: Tensor + :param input2: the second element of the addition + :type obj: Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/add.rst + """ + + @enforce_types + def __init__( + self, + obj1: Stream | Parameter | Constant | int | float, + obj2: Stream | Parameter | Constant | int | float, + ) -> Stream: + obj1, obj2, dim = binary_cheks(self, obj1, obj2, "addition operators (+)") + super().__init__( + add_relation_name + str(Stream.count), merge(obj1.json, obj2.json), dim + ) + self.json["Relations"][self.name] = [add_relation_name, [obj1.name, obj2.name]] + + +## TODO: check the scalar dimension, helpful for the offset +class Sub(Stream, ToStream): + """ + Implement the subtraction function between two tensors. + (it is also possible to use the classical math operator '-') + + :param input1: the first element of the subtraction + :type obj: Tensor + :param input2: the second element of the subtraction + :type obj: Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/sub.rst + """ + + @enforce_types + def __init__( + self, + obj1: Stream | Parameter | Constant | int | float, + obj2: Stream | Parameter | Constant | int | float, + ) -> Stream: + obj1, obj2, dim = binary_cheks(self, obj1, obj2, "subtraction operators (-)") + super().__init__( + sub_relation_name + str(Stream.count), merge(obj1.json, obj2.json), dim + ) + self.json["Relations"][self.name] = [sub_relation_name, [obj1.name, obj2.name]] + + +class Mul(Stream, ToStream): + """ + Implement the multiplication function between two tensors. + (it is also possible to use the classical math operator '*') + + :param input1: the first element of the multiplication + :type obj: Tensor + :param input2: the second element of the multiplication + :type obj: Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/mul.rst + """ + + @enforce_types + def __init__( + self, + obj1: Stream | Parameter | Constant | int | float, + obj2: Stream | Parameter | Constant | int | float, + ) -> Stream: + obj1, obj2, dim = binary_cheks(self, obj1, obj2, "multiplication operators (*)") + super().__init__( + mul_relation_name + str(Stream.count), merge(obj1.json, obj2.json), dim + ) + self.json["Relations"][self.name] = [mul_relation_name, [obj1.name, obj2.name]] + + +class Div(Stream, ToStream): + """ + Implement the division function between two tensors. + (it is also possible to use the classical math operator '/') + + :param input1: the numerator of the division + :type obj: Tensor + :param input2: the denominator of the division + :type obj: Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/div.rst + """ + + @enforce_types + def __init__( + self, + obj1: Stream | Parameter | Constant | int | float, + obj2: Stream | Parameter | Constant | int | float, + ) -> Stream: + obj1, obj2, dim = binary_cheks(self, obj1, obj2, "division operators (/) ") + super().__init__( + div_relation_name + str(Stream.count), merge(obj1.json, obj2.json), dim + ) + self.json["Relations"][self.name] = [div_relation_name, [obj1.name, obj2.name]] + + +class Pow(Stream, ToStream): + """ + Implement the power function given an input and an exponent. + (it is also possible to use the classical math operator '**') + + See also: + Official PyTorch pow documentation: + `torch.pow `_ + + :param input: the base of the power function + :type obj: Tensor + :param exp: the exponent of the power function + :type obj: float or Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/pow.rst + """ + + @enforce_types + def __init__( + self, + obj1: Stream | Parameter | Constant | int | float, + obj2: Stream | Parameter | Constant | int | float, + ) -> Stream: + obj1, obj2, dim = binary_cheks(self, obj1, obj2, "pow operators (**)") + super().__init__( + pow_relation_name + str(Stream.count), merge(obj1.json, obj2.json), dim + ) + self.json["Relations"][self.name] = [pow_relation_name, [obj1.name, obj2.name]] + + +class Neg(Stream, ToStream): + """ + Implement the negate function given an input. + + :param input: the input to negate + :type obj: Tensor + + Example: + -------- + .. include:: /examples_basics/layer_module_ex/arithmetic_module_ex/neg.rst + """ + + @enforce_types + def __init__(self, obj: Stream | Parameter | Constant) -> Stream: + obj = toStream(obj) + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for neg operation.", + ) + super().__init__(neg_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [neg_relation_name, [obj.name]] + + +class Sign(Stream, ToStream): + """ + Implement the sign function given an input. + + :param input: the input for the sign function + :type obj: Tensor + + Example: + >>> x = Sign(x) + """ + + @enforce_types + def __init__(self, obj: Stream | Parameter | Constant) -> Stream: + obj = toStream(obj) + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for sign operation.", + ) + super().__init__(sign_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [sign_relation_name, [obj.name]] + + +class Sum(Stream, ToStream): + @enforce_types + def __init__(self, obj: Stream | Parameter | Constant) -> Stream: + obj = toStream(obj) + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for sum operation.", + ) + obj.dim["dim"] = 1 + super().__init__(sum_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [sum_relation_name, [obj.name]] + + +class Add_Layer(nn.Module): + #: :noindex: + def __init__(self): + super(Add_Layer, self).__init__() + + def forward(self, *inputs): + results = inputs[0] + for input in inputs[1:]: + results = results + input + return results + + +def createAdd(name, *inputs): + """ + :noindex: + """ + return Add_Layer() + + +class Sub_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Sub_Layer, self).__init__() + + def forward(self, *inputs): + # Perform element-wise subtraction + results = inputs[0] + for input in inputs[1:]: + results = results - input + return results + + +def createSub(self, *inputs): + """ + :noindex: + """ + return Sub_Layer() + + +class Mul_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Mul_Layer, self).__init__() + + def forward(self, *inputs): + results = inputs[0] + for input in inputs[1:]: + results = results * input + return results + + +def createMul(name, *inputs): + """ + :noindex: + """ + return Mul_Layer() + + +class Div_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Div_Layer, self).__init__() + + def forward(self, *inputs): + results = inputs[0] + for input in inputs[1:]: + results = results / input + return results + + +def createDiv(name, *inputs): + """ + :noindex: + """ + return Div_Layer() + + +class Pow_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Pow_Layer, self).__init__() + + def forward(self, *inputs): + return torch.pow(inputs[0], inputs[1]) + + +def createPow(name, *inputs): + """ + :noindex: + """ + return Pow_Layer() + + +class Neg_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Neg_Layer, self).__init__() + + def forward(self, x): + return -x + + +def createNeg(self, *inputs): + """ + :noindex: + """ + return Neg_Layer() + + +class Sign_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Sign_Layer, self).__init__() + + def forward(self, x): + return torch.sign(x) + + +def createSign(self, *inputs): + """ + :noindex: + """ + return Sign_Layer() + + +class Sum_Layer(nn.Module): + """ + :noindex: + """ + + def __init__(self): + super(Sum_Layer, self).__init__() + + def forward(self, inputs): + return torch.sum(inputs, dim=2, keepdim=True) + + +def createSum(name, *inputs): + """ + :noindex: + """ + return Sum_Layer() + + +setattr(Model, add_relation_name, createAdd) +setattr(Model, sub_relation_name, createSub) +setattr(Model, mul_relation_name, createMul) +setattr(Model, div_relation_name, createDiv) +setattr(Model, pow_relation_name, createPow) + +setattr(Model, neg_relation_name, createNeg) +setattr(Model, sign_relation_name, createSign) + +setattr(Model, sum_relation_name, createSum) diff --git a/nnodely/layers/equationlearner.py b/src/nnodely/layers/equationlearner.py similarity index 60% rename from nnodely/layers/equationlearner.py rename to src/nnodely/layers/equationlearner.py index fa6d1dbf..b3db8ed8 100644 --- a/nnodely/layers/equationlearner.py +++ b/src/nnodely/layers/equationlearner.py @@ -11,16 +11,35 @@ from nnodely.layers.trigonometric import Sin, Cos, Tan, Tanh, Cosh, Sech from nnodely.layers.arithmetic import Add, Mul, Sub, Neg, Pow, Sum -equationlearner_relation_name = 'EquationLearner' -Available_functions = [Sin, Cos, Tan, Cosh, Tanh, Sech, Add, Mul, Sub, Neg, Pow, Sum, Concatenate, Relu, ELU, Identity, Sigmoid] +equationlearner_relation_name = "EquationLearner" +Available_functions = [ + Sin, + Cos, + Tan, + Cosh, + Tanh, + Sech, + Add, + Mul, + Sub, + Neg, + Pow, + Sum, + Concatenate, + Relu, + ELU, + Identity, + Sigmoid, +] Initialized_functions = [ParamFun, Fuzzify] + class EquationLearner(NeuObj): """ Represents a nnodely implementation of the Task-Parametrized Equation Learner block. See also: - Task-Parametrized Equation Learner official paper: + Task-Parametrized Equation Learner official paper: `Equation Learner `_ Parameters @@ -52,8 +71,15 @@ class EquationLearner(NeuObj): .. include:: /examples_basics/layer_module_ex/eql.rst """ + @enforce_types - def __init__(self, functions:list, *, linear_in:Linear|None = None, linear_out:Linear|None = None) -> Stream: + def __init__( + self, + functions: list, + *, + linear_in: Linear | None = None, + linear_out: Linear | None = None, + ) -> Stream: self.relation_name = equationlearner_relation_name self.linear_in = linear_in self.linear_out = linear_out @@ -64,38 +90,77 @@ def __init__(self, functions:list, *, linear_in:Linear|None = None, linear_out:L self.func_parameters = {} for func_idx, func in enumerate(self.functions): - check(callable(func), TypeError, 'The activation functions must be callable') + check( + callable(func), TypeError, "The activation functions must be callable" + ) if type(func) in Initialized_functions: if type(func) == ParamFun: funinfo = inspect.getfullargspec(func.param_fun) - num_args = len(funinfo.args) - len(func.parameters_and_constants) if func.parameters_and_constants else len(funinfo.args) + num_args = ( + len(funinfo.args) - len(func.parameters_and_constants) + if func.parameters_and_constants + else len(funinfo.args) + ) elif type(func) == Fuzzify: - init_signature = inspect.signature(func.__call__) + init_signature = inspect.signature(func.__call__) parameters = list(init_signature.parameters.values()) - num_args = len([param for param in parameters if param.name != "self"]) + num_args = len( + [param for param in parameters if param.name != "self"] + ) else: - check(func in Available_functions, ValueError, f'The function {func} is not available for the EquationLearner operation') - init_signature = inspect.signature(func.__init__) + check( + func in Available_functions, + ValueError, + f"The function {func} is not available for the EquationLearner operation", + ) + init_signature = inspect.signature(func.__init__) parameters = list(init_signature.parameters.values()) num_args = len([param for param in parameters if param.name != "self"]) self.func_parameters[func_idx] = num_args self.n_activations = sum(self.func_parameters.values()) - check(self.n_activations > 0, ValueError, 'At least one activation function must be provided') + check( + self.n_activations > 0, + ValueError, + "At least one activation function must be provided", + ) def __call__(self, inputs): if type(inputs) is not tuple: inputs = (inputs,) - check(len(set([x.dim['sw'] if 'sw' in x.dim.keys() else x.dim['tw'] for x in inputs])) == 1, ValueError, 'All inputs must have the same time dimension') + check( + len( + set( + [ + x.dim["sw"] if "sw" in x.dim.keys() else x.dim["tw"] + for x in inputs + ] + ) + ) + == 1, + ValueError, + "All inputs must have the same time dimension", + ) concatenated_input = inputs[0] for inp in inputs[1:]: concatenated_input = Concatenate(concatenated_input, inp) - linear_layer = self.linear_in(concatenated_input) if self.linear_in else Linear(output_dimension=self.n_activations, b=True)(concatenated_input) + linear_layer = ( + self.linear_in(concatenated_input) + if self.linear_in + else Linear(output_dimension=self.n_activations, b=True)(concatenated_input) + ) idx, out = 0, None for func_idx, func in enumerate(self.functions): - arguments = [Select(linear_layer,idx+arg_idx) for arg_idx in range(self.func_parameters[func_idx])] + arguments = [ + Select(linear_layer, idx + arg_idx) + for arg_idx in range(self.func_parameters[func_idx]) + ] idx += self.func_parameters[func_idx] - out = func(*arguments) if func_idx == 0 else Concatenate(out, func(*arguments)) + out = ( + func(*arguments) + if func_idx == 0 + else Concatenate(out, func(*arguments)) + ) if self.linear_out: out = self.linear_out(out) return out diff --git a/nnodely/layers/fir.py b/src/nnodely/layers/fir.py similarity index 52% rename from nnodely/layers/fir.py rename to src/nnodely/layers/fir.py index b340dbe0..38066de9 100644 --- a/nnodely/layers/fir.py +++ b/src/nnodely/layers/fir.py @@ -1,4 +1,5 @@ -import copy, torch +import copy +import torch import torch.nn as nn @@ -11,9 +12,11 @@ from nnodely.support.jsonutils import merge from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) -fir_relation_name = 'Fir' +fir_relation_name = "Fir" + class Fir(NeuObj, AutoToStream): """ @@ -71,21 +74,26 @@ class Fir(NeuObj, AutoToStream): output_dimension : int The output dimension of the FIR relation. - Examples + Examples -------- .. include:: /examples_basics/layer_module_ex/fir.rst """ + @enforce_types - def __init__(self, output_dimension:int|None = None, *, - W_init:Callable|str|None = None, - W_init_params:dict|None = None, - b_init:Callable|str|None = None, - b_init_params:dict|None = None, - W:Parameter|str|None = None, - b:bool|str|Parameter|None = None, - dropout:int|float = 0): + def __init__( + self, + output_dimension: int | None = None, + *, + W_init: Callable | str | None = None, + W_init_params: dict | None = None, + b_init: Callable | str | None = None, + b_init_params: dict | None = None, + W: Parameter | str | None = None, + b: bool | str | Parameter | None = None, + dropout: int | float = 0, + ): self.W = W self.b = b @@ -93,72 +101,124 @@ def __init__(self, output_dimension:int|None = None, *, self.bname = None self.dropout = dropout - super().__init__('P'+fir_relation_name + str(NeuObj.count)) + super().__init__("P" + fir_relation_name + str(NeuObj.count)) if type(self.W) is Parameter: - check('tw' in self.W.dim or 'sw' in self.W.dim, TypeError, f'The "W" Parameter must have a time dimension or a sample dimension but got {self.W.dim}.') - #check(len(self.W.dim) == 2,ValueError,f"The values of the parameters must have two dimensions [tw/sample_rate,output_dimension] or [sw,output_dimension].") + check( + "tw" in self.W.dim or "sw" in self.W.dim, + TypeError, + f'The "W" Parameter must have a time dimension or a sample dimension but got {self.W.dim}.', + ) + # check(len(self.W.dim) == 2,ValueError,f"The values of the parameters must have two dimensions [tw/sample_rate,output_dimension] or [sw,output_dimension].") if output_dimension is None: - check(type(self.W.dim['dim']) is int, TypeError, 'Dimension of the parameter must be an integer for the Fir') - self.output_dimension = self.W.dim['dim'] + check( + type(self.W.dim["dim"]) is int, + TypeError, + "Dimension of the parameter must be an integer for the Fir", + ) + self.output_dimension = self.W.dim["dim"] else: self.output_dimension = output_dimension - check(self.W.dim['dim'] == self.output_dimension, - ValueError, - 'output_dimension must be equal to dim of the Parameter') + check( + self.W.dim["dim"] == self.output_dimension, + ValueError, + "output_dimension must be equal to dim of the Parameter", + ) self.Wname = self.W.name W_json = self.W.json else: ## Create a new default parameter self.output_dimension = 1 if output_dimension is None else output_dimension - self.Wname = W if type(W) is str else self.name + 'W' - W_json = Parameter(name=self.Wname, dimensions=self.output_dimension, init=W_init, init_params=W_init_params).json - self.json = merge(self.json,W_json) + self.Wname = W if type(W) is str else self.name + "W" + W_json = Parameter( + name=self.Wname, + dimensions=self.output_dimension, + init=W_init, + init_params=W_init_params, + ).json + self.json = merge(self.json, W_json) if self.b is not None and self.b is not False: if type(self.b) is Parameter: - check('tw' not in self.b.dim and 'sw' not in self.b.dim, TypeError, f'The "bias" must no have a time dimensions but got {self.b.dim}.') - check(type(self.b.dim['dim']) is int, ValueError, 'The "bias" dimensions must be an integer.') - check(self.b.dim['dim'] == self.output_dimension, ValueError, 'output_dimension must be equal to the dim of the "bias".') + check( + "tw" not in self.b.dim and "sw" not in self.b.dim, + TypeError, + f'The "bias" must no have a time dimensions but got {self.b.dim}.', + ) + check( + type(self.b.dim["dim"]) is int, + ValueError, + 'The "bias" dimensions must be an integer.', + ) + check( + self.b.dim["dim"] == self.output_dimension, + ValueError, + 'output_dimension must be equal to the dim of the "bias".', + ) self.bname = self.b.name b_json = self.b.json else: - self.bname = b if type(self.b) is str else self.name + 'b' - b_json = Parameter(name=self.bname, dimensions=self.output_dimension, init=b_init, init_params=b_init_params).json - self.json = merge(self.json,b_json) + self.bname = b if type(self.b) is str else self.name + "b" + b_json = Parameter( + name=self.bname, + dimensions=self.output_dimension, + init=b_init, + init_params=b_init_params, + ).json + self.json = merge(self.json, b_json) self.json_stream = {} @enforce_types - def __call__(self, obj:Stream) -> Stream: + def __call__(self, obj: Stream) -> Stream: stream_name = fir_relation_name + str(Stream.count) - check('dim' in obj.dim and obj.dim['dim'] == 1, - ValueError, - f"Input dimension is {obj.dim['dim']} and not scalar") - window = 'tw' if 'tw' in obj.dim else ('sw' if 'sw' in obj.dim else None) + check( + "dim" in obj.dim and obj.dim["dim"] == 1, + ValueError, + f"Input dimension is {obj.dim['dim']} and not scalar", + ) + window = "tw" if "tw" in obj.dim else ("sw" if "sw" in obj.dim else None) json_stream_name = window + str(obj.dim[window]) if json_stream_name not in self.json_stream: if len(self.json_stream) > 0: - log.warning(f"The Fir {self.name} was called with inputs with different dimensions. If both Fir enter in the model an error will be raised.") + log.warning( + f"The Fir {self.name} was called with inputs with different dimensions. If both Fir enter in the model an error will be raised." + ) self.json_stream[json_stream_name] = copy.deepcopy(self.json) - self.json_stream[json_stream_name]['Parameters'][self.Wname][window] = obj.dim[window] + self.json_stream[json_stream_name]["Parameters"][self.Wname][window] = obj.dim[ + window + ] if window: if type(self.W) is Parameter: - check(window in self.json['Parameters'][self.Wname], - TypeError, - f"The window \'{window}\' of the input is not in the W") - check(self.json['Parameters'][self.Wname][window] == obj.dim[window], - ValueError, - f"The window \'{window}\' of the input must be the same of the W") + check( + window in self.json["Parameters"][self.Wname], + TypeError, + f"The window '{window}' of the input is not in the W", + ) + check( + self.json["Parameters"][self.Wname][window] == obj.dim[window], + ValueError, + f"The window '{window}' of the input must be the same of the W", + ) else: if type(self.W) is Parameter: - cond = 'sw' not in self.json_stream[json_stream_name]['Parameters'][self.Wname] and 'tw' not in \ - self.json_stream[json_stream_name]['Parameters'][self.Wname] - check(cond, KeyError, 'The W have a time window and the input no') - - stream_json = merge(self.json_stream[json_stream_name],obj.json) - stream_json['Relations'][stream_name] = [fir_relation_name, [obj.name], self.Wname, self.bname, self.dropout] - return Stream(stream_name, stream_json,{'dim':self.output_dimension, 'sw': 1}) + cond = ( + "sw" + not in self.json_stream[json_stream_name]["Parameters"][self.Wname] + and "tw" + not in self.json_stream[json_stream_name]["Parameters"][self.Wname] + ) + check(cond, KeyError, "The W have a time window and the input no") + + stream_json = merge(self.json_stream[json_stream_name], obj.json) + stream_json["Relations"][stream_name] = [ + fir_relation_name, + [obj.name], + self.Wname, + self.bname, + self.dropout, + ] + return Stream(stream_name, stream_json, {"dim": self.output_dimension, "sw": 1}) class Fir_Layer(nn.Module): @@ -186,7 +246,9 @@ def forward(self, x): x = self.dropout(x) return x + def createFir(self, *inputs): return Fir_Layer(weights=inputs[0], bias=inputs[1], dropout=inputs[2]) + setattr(Model, fir_relation_name, createFir) diff --git a/nnodely/layers/fuzzify.py b/src/nnodely/layers/fuzzify.py similarity index 53% rename from nnodely/layers/fuzzify.py rename to src/nnodely/layers/fuzzify.py index 2e65ad8f..2e1063dc 100644 --- a/nnodely/layers/fuzzify.py +++ b/src/nnodely/layers/fuzzify.py @@ -1,4 +1,7 @@ -import inspect, copy, textwrap, torch +import inspect +import copy +import textwrap +import torch import numpy as np import torch.nn as nn @@ -10,7 +13,8 @@ from nnodely.support.utils import check, enforce_types from nnodely.support.jsonutils import merge -fuzzify_relation_name = 'Fuzzify' +fuzzify_relation_name = "Fuzzify" + class Fuzzify(NeuObj): """ @@ -27,7 +31,7 @@ class Fuzzify(NeuObj): The `output_dimension` will be inferred from the number of centers provided. functions : str, list, or Callable, optional The fuzzy functions to use. Can be a string specifying a predefined function type, a custom function, or a list of callable functions. Default is 'Triangular'. - + Notes ----- .. note:: @@ -48,85 +52,122 @@ class Fuzzify(NeuObj): .. include:: /examples_basics/layer_module_ex/fuzzy.rst """ + @enforce_types - def __init__(self, output_dimension: int | None = None, - range: list | None = None, *, - centers: list | None = None, - functions: str | list | Callable = 'Triangular'): + def __init__( + self, + output_dimension: int | None = None, + range: list | None = None, + *, + centers: list | None = None, + functions: str | list | Callable = "Triangular", + ): self.relation_name = fuzzify_relation_name - super().__init__('F' + fuzzify_relation_name + str(NeuObj.count)) - self.json['Functions'][self.name] = {} + super().__init__("F" + fuzzify_relation_name + str(NeuObj.count)) + self.json["Functions"][self.name] = {} if output_dimension is not None: - check(range is not None, ValueError, 'if "output_dimension" is not None, "range" must be not setted') - check(centers is None, ValueError, - 'if "output_dimension" and "range" are not None, then "centers" must be None') - self.output_dimension = {'dim': output_dimension} - interval = ((range[1] - range[0]) / (output_dimension - 1)) - self.json['Functions'][self.name]['centers'] = np.arange(range[0], range[1] + interval, interval).tolist() + check( + range is not None, + ValueError, + 'if "output_dimension" is not None, "range" must be not setted', + ) + check( + centers is None, + ValueError, + 'if "output_dimension" and "range" are not None, then "centers" must be None', + ) + self.output_dimension = {"dim": output_dimension} + interval = (range[1] - range[0]) / (output_dimension - 1) + self.json["Functions"][self.name]["centers"] = np.arange( + range[0], range[1] + interval, interval + ).tolist() else: - check(centers is not None, ValueError, 'if "output_dimension" is None and "centers" must be setted') - self.output_dimension = {'dim': len(centers)} - self.json['Functions'][self.name]['centers'] = np.array(centers).tolist() - self.json['Functions'][self.name]['dim_out'] = copy.deepcopy(self.output_dimension) + check( + centers is not None, + ValueError, + 'if "output_dimension" is None and "centers" must be setted', + ) + self.output_dimension = {"dim": len(centers)} + self.json["Functions"][self.name]["centers"] = np.array(centers).tolist() + self.json["Functions"][self.name]["dim_out"] = copy.deepcopy( + self.output_dimension + ) if type(functions) is str: - self.json['Functions'][self.name]['functions'] = functions - self.json['Functions'][self.name]['names'] = functions + self.json["Functions"][self.name]["functions"] = functions + self.json["Functions"][self.name]["names"] = functions elif type(functions) is list: - self.json['Functions'][self.name]['functions'] = [] - self.json['Functions'][self.name]['names'] = [] + self.json["Functions"][self.name]["functions"] = [] + self.json["Functions"][self.name]["names"] = [] for func in functions: - code = textwrap.dedent(inspect.getsource(func)).replace('\"', '\'') - self.json['Functions'][self.name]['functions'].append(code) - self.json['Functions'][self.name]['names'].append(func.__name__) + code = textwrap.dedent(inspect.getsource(func)).replace('"', "'") + self.json["Functions"][self.name]["functions"].append(code) + self.json["Functions"][self.name]["names"].append(func.__name__) else: - code = textwrap.dedent(inspect.getsource(functions)).replace('\"', '\'') - self.json['Functions'][self.name]['functions'] = code - self.json['Functions'][self.name]['names'] = functions.__name__ + code = textwrap.dedent(inspect.getsource(functions)).replace('"', "'") + self.json["Functions"][self.name]["functions"] = code + self.json["Functions"][self.name]["names"] = functions.__name__ @enforce_types def __call__(self, obj: Stream) -> Stream: stream_name = fuzzify_relation_name + str(Stream.count) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Fuzzify operation.") - check('dim' in obj.dim and obj.dim['dim'] == 1, ValueError, 'Input dimension must be scalar') + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Fuzzify operation.", + ) + check( + "dim" in obj.dim and obj.dim["dim"] == 1, + ValueError, + "Input dimension must be scalar", + ) output_dimension = copy.deepcopy(obj.dim) output_dimension.update(self.output_dimension) stream_json = merge(self.json, obj.json) - stream_json['Relations'][stream_name] = [fuzzify_relation_name, [obj.name], self.name] + stream_json["Relations"][stream_name] = [ + fuzzify_relation_name, + [obj.name], + self.name, + ] return Stream(stream_name, stream_json, output_dimension) + def return_fuzzify(json, xlim=None, num_points=1000): if xlim is not None: x = torch.from_numpy(np.linspace(xlim[0], xlim[1], num=num_points)) else: - x = torch.from_numpy(np.linspace(json['centers'][0] - 2, json['centers'][-1] + 2, num=num_points)) - chan_centers = np.array(json['centers']) + x = torch.from_numpy( + np.linspace(json["centers"][0] - 2, json["centers"][-1] + 2, num=num_points) + ) + chan_centers = np.array(json["centers"]) activ_fun = {} - if isinstance(json['names'], list): - n_func = len(json['names']) + if isinstance(json["names"], list): + n_func = len(json["names"]) else: n_func = 1 for i in range(len(chan_centers)): - if json['functions'] == 'Triangular': + if json["functions"] == "Triangular": activ_fun[i] = triangular(x, i, chan_centers).tolist() - elif json['functions'] == 'Rectangular': + elif json["functions"] == "Rectangular": activ_fun[i] = rectangular(x, i, chan_centers).tolist() else: - if isinstance(json['names'], list): + if isinstance(json["names"], list): if i >= n_func: func_idx = i - round(n_func * (i // n_func)) else: func_idx = i - exec(json['functions'][func_idx], globals()) - function_to_call = globals()[json['names'][func_idx]] + exec(json["functions"][func_idx], globals()) + function_to_call = globals()[json["names"][func_idx]] else: - exec(json['functions'], globals()) - function_to_call = globals()[json['names']] - activ_fun[i] = custom_function(function_to_call, x, i, chan_centers).tolist() + exec(json["functions"], globals()) + function_to_call = globals()[json["names"]] + activ_fun[i] = custom_function( + function_to_call, x, i, chan_centers + ).tolist() return x.tolist(), activ_fun + def triangular(x, idx_channel, chan_centers): # Compute the number of channels num_channels = len(chan_centers) @@ -134,19 +175,33 @@ def triangular(x, idx_channel, chan_centers): if idx_channel == 0: if num_channels != 1: ampl = chan_centers[1] - chan_centers[0] - act_fcn = torch.minimum(torch.maximum(-(x - chan_centers[0]) / ampl + 1, torch.tensor(0.0)), torch.tensor(1.0)) + act_fcn = torch.minimum( + torch.maximum(-(x - chan_centers[0]) / ampl + 1, torch.tensor(0.0)), + torch.tensor(1.0), + ) else: # In case the user only wants one channel act_fcn = 1 elif idx_channel != 0 and idx_channel == (num_channels - 1): ampl = chan_centers[-1] - chan_centers[-2] - act_fcn = torch.minimum(torch.maximum((x - chan_centers[-2]) / ampl, torch.tensor(0.0)), torch.tensor(1.0)) + act_fcn = torch.minimum( + torch.maximum((x - chan_centers[-2]) / ampl, torch.tensor(0.0)), + torch.tensor(1.0), + ) else: ampl_1 = chan_centers[idx_channel] - chan_centers[idx_channel - 1] ampl_2 = chan_centers[idx_channel + 1] - chan_centers[idx_channel] - act_fcn = torch.minimum(torch.maximum((x - chan_centers[idx_channel - 1]) / ampl_1, torch.tensor(0.0)), torch.maximum(-(x - chan_centers[idx_channel]) / ampl_2 + 1, torch.tensor(0.0))) + act_fcn = torch.minimum( + torch.maximum( + (x - chan_centers[idx_channel - 1]) / ampl_1, torch.tensor(0.0) + ), + torch.maximum( + -(x - chan_centers[idx_channel]) / ampl_2 + 1, torch.tensor(0.0) + ), + ) return act_fcn + def rectangular(x, idx_channel, chan_centers): ## compute number of channels num_channels = len(chan_centers) @@ -162,9 +217,18 @@ def rectangular(x, idx_channel, chan_centers): width = abs(chan_centers[idx_channel] - chan_centers[idx_channel - 1]) / 2 act_fcn = torch.where(x >= chan_centers[idx_channel] - width, 1.0, 0.0) else: - width_forward = abs(chan_centers[idx_channel + 1] - chan_centers[idx_channel]) / 2 - width_backward = abs(chan_centers[idx_channel] - chan_centers[idx_channel - 1]) / 2 - act_fcn = torch.where((x >= chan_centers[idx_channel] - width_backward) & (x < chan_centers[idx_channel] + width_forward), 1.0, 0.0) + width_forward = ( + abs(chan_centers[idx_channel + 1] - chan_centers[idx_channel]) / 2 + ) + width_backward = ( + abs(chan_centers[idx_channel] - chan_centers[idx_channel - 1]) / 2 + ) + act_fcn = torch.where( + (x >= chan_centers[idx_channel] - width_backward) + & (x < chan_centers[idx_channel] + width_forward), + 1.0, + 0.0, + ) return act_fcn @@ -172,39 +236,48 @@ def custom_function(func, x, idx_channel, chan_centers): act_fcn = func(x - chan_centers[idx_channel]) return act_fcn + class Fuzzify_Layer(nn.Module): def __init__(self, params): super().__init__() - self.centers = params['centers'] - self.function = params['functions'] - self.dimension = params['dim_out']['dim'] - self.name = params['names'] + self.centers = params["centers"] + self.function = params["functions"] + self.dimension = params["dim_out"]["dim"] + self.name = params["names"] if type(self.name) is list: self.n_func = len(self.name) for func, name in zip(self.function, self.name): ## Add the function to the globals try: - code = 'import torch\n@torch.fx.wrap\n' + func + code = "import torch\n@torch.fx.wrap\n" + func exec(code, globals()) except Exception as e: - check(False, RuntimeError, f"An error occurred when running the function '{name}':\n {e}") + check( + False, + RuntimeError, + f"An error occurred when running the function '{name}':\n {e}", + ) else: self.n_func = 1 - if self.name not in ['Triangular', 'Rectangular']: ## custom function + if self.name not in ["Triangular", "Rectangular"]: ## custom function ## Add the function to the globals try: - code = 'import torch\n@torch.fx.wrap\n' + self.function + code = "import torch\n@torch.fx.wrap\n" + self.function exec(code, globals()) except Exception as e: - check(False, RuntimeError, f"An error occurred when running the function '{self.name}':\n {e}") + check( + False, + RuntimeError, + f"An error occurred when running the function '{self.name}':\n {e}", + ) def forward(self, x): res = torch.zeros_like(x).repeat(1, 1, self.dimension) - if self.function == 'Triangular': + if self.function == "Triangular": for i in range(len(self.centers)): slicing(res, torch.tensor(i), triangular(x, i, self.centers)) - elif self.function == 'Rectangular': + elif self.function == "Rectangular": for i in range(len(self.centers)): slicing(res, torch.tensor(i), rectangular(x, i, self.centers)) else: ## Custom_function @@ -212,7 +285,11 @@ def forward(self, x): # Retrieve the function object from the globals dictionary function_to_call = globals()[self.name] for i in range(len(self.centers)): - slicing(res, torch.tensor(i), custom_function(function_to_call, x, i, self.centers)) + slicing( + res, + torch.tensor(i), + custom_function(function_to_call, x, i, self.centers), + ) else: ## we have multiple functions for i in range(len(self.centers)): if i >= self.n_func: @@ -220,14 +297,21 @@ def forward(self, x): else: func_idx = i function_to_call = globals()[self.name[func_idx]] - slicing(res, torch.tensor(i), custom_function(function_to_call, x, i, self.centers)) + slicing( + res, + torch.tensor(i), + custom_function(function_to_call, x, i, self.centers), + ) return res + @torch.fx.wrap def slicing(res, i, x): - res[:, :, i:i + 1] = x + res[:, :, i : i + 1] = x + def createFuzzify(self, *params): return Fuzzify_Layer(params[0]) + setattr(Model, fuzzify_relation_name, createFuzzify) diff --git a/nnodely/layers/input.py b/src/nnodely/layers/input.py similarity index 55% rename from nnodely/layers/input.py rename to src/nnodely/layers/input.py index 061f955d..1bf48f0e 100644 --- a/nnodely/layers/input.py +++ b/src/nnodely/layers/input.py @@ -6,6 +6,7 @@ from nnodely.layers.part import SamplePart, TimePart from nnodely.layers.timeoperation import Differentiate, Integrate + class Input(NeuObj): """ Represents an Input in the neural network model. @@ -30,7 +31,8 @@ class Input(NeuObj): json : dict A dictionary containing the configuration of the Input. """ - def __init__(self, name:str, *, dimensions:int = 1): + + def __init__(self, name: str, *, dimensions: int = 1): """ Initializes the Input object. @@ -44,12 +46,12 @@ def __init__(self, name:str, *, dimensions:int = 1): The number of dimensions for the Input. Default is 1. """ NeuObj.__init__(self, name) - check(type(dimensions) == int, TypeError,"The dimensions must be a integer") - self.json['Inputs'][self.name] = {'dim': dimensions } - self.dim = {'dim': dimensions} + check(type(dimensions) == int, TypeError, "The dimensions must be a integer") + self.json["Inputs"][self.name] = {"dim": dimensions} + self.dim = {"dim": dimensions} @enforce_types - def tw(self, tw:int|float|list, offset:int|float|None = None) -> Stream: + def tw(self, tw: int | float | list, offset: int | float | None = None) -> Stream: """ Selects a time window for the Input. @@ -75,23 +77,39 @@ def tw(self, tw:int|float|list, offset:int|float|None = None) -> Stream: dim = copy.deepcopy(self.dim) json = copy.deepcopy(self.json) if type(tw) is list: - check(len(tw) == 2, TypeError, "The time window must be a list of two elements.") - check(tw[1] > tw[0], ValueError, "The dimension of the sample window must be positive") - json['Inputs'][self.name]['tw'] = tw + check( + len(tw) == 2, + TypeError, + "The time window must be a list of two elements.", + ) + check( + tw[1] > tw[0], + ValueError, + "The dimension of the sample window must be positive", + ) + json["Inputs"][self.name]["tw"] = tw tw = tw[1] - tw[0] else: - json['Inputs'][self.name]['tw'] = [-tw, 0] + json["Inputs"][self.name]["tw"] = [-tw, 0] check(tw > 0, ValueError, "The time window must be positive") - dim['tw'] = tw + dim["tw"] = tw if offset is not None: - check(json['Inputs'][self.name]['tw'][0] <= offset < json['Inputs'][self.name]['tw'][1], - IndexError, - "The offset must be inside the time window") - return TimePart(Stream(self.name, json, dim), json['Inputs'][self.name]['tw'][0], json['Inputs'][self.name]['tw'][1], offset) - + check( + json["Inputs"][self.name]["tw"][0] + <= offset + < json["Inputs"][self.name]["tw"][1], + IndexError, + "The offset must be inside the time window", + ) + return TimePart( + Stream(self.name, json, dim), + json["Inputs"][self.name]["tw"][0], + json["Inputs"][self.name]["tw"][1], + offset, + ) @enforce_types - def sw(self, sw:int|list, offset:int|None = None) -> Stream: + def sw(self, sw: int | list, offset: int | None = None) -> Stream: """ Selects a sample window for the Input. @@ -119,24 +137,45 @@ def sw(self, sw:int|list, offset:int|None = None) -> Stream: dim = copy.deepcopy(self.dim) json = copy.deepcopy(self.json) if type(sw) is list: - check(len(sw) == 2, TypeError, "The sample window must be a list of two elements.") - check(type(sw[0]) == int and type(sw[1]) == int, TypeError, "The sample window must be integer") - check(sw[1] > sw[0], ValueError, "The dimension of the sample window must be positive") - json['Inputs'][self.name]['sw'] = sw + check( + len(sw) == 2, + TypeError, + "The sample window must be a list of two elements.", + ) + check( + type(sw[0]) == int and type(sw[1]) == int, + TypeError, + "The sample window must be integer", + ) + check( + sw[1] > sw[0], + ValueError, + "The dimension of the sample window must be positive", + ) + json["Inputs"][self.name]["sw"] = sw sw = sw[1] - sw[0] else: check(type(sw) == int, TypeError, "The sample window must be integer") - json['Inputs'][self.name]['sw'] = [-sw, 0] + json["Inputs"][self.name]["sw"] = [-sw, 0] check(sw > 0, ValueError, "The sample window must be positive") - dim['sw'] = sw + dim["sw"] = sw if offset is not None: - check(json['Inputs'][self.name]['sw'][0] <= offset < json['Inputs'][self.name]['sw'][1], - IndexError, - "The offset must be inside the sample window") - return SamplePart(Stream(self.name, json, dim), json['Inputs'][self.name]['sw'][0], json['Inputs'][self.name]['sw'][1], offset) + check( + json["Inputs"][self.name]["sw"][0] + <= offset + < json["Inputs"][self.name]["sw"][1], + IndexError, + "The offset must be inside the sample window", + ) + return SamplePart( + Stream(self.name, json, dim), + json["Inputs"][self.name]["sw"][0], + json["Inputs"][self.name]["sw"][1], + offset, + ) @enforce_types - def z(self, delay:int) -> Stream: + def z(self, delay: int) -> Stream: """ Considering the Zeta transform notation. The function is used to selects a unitary delay from the Input. @@ -157,9 +196,14 @@ def z(self, delay:int) -> Stream: dim = copy.deepcopy(self.dim) json = copy.deepcopy(self.json) sw = [(-delay) - 1, (-delay)] - json['Inputs'][self.name]['sw'] = sw - dim['sw'] = sw[1] - sw[0] - return SamplePart(Stream(self.name, json, dim), json['Inputs'][self.name]['sw'][0], json['Inputs'][self.name]['sw'][1], None) + json["Inputs"][self.name]["sw"] = sw + dim["sw"] = sw[1] - sw[0] + return SamplePart( + Stream(self.name, json, dim), + json["Inputs"][self.name]["sw"][0], + json["Inputs"][self.name]["sw"][1], + None, + ) @enforce_types def last(self) -> Stream: @@ -186,7 +230,14 @@ def next(self) -> Stream: return self.z(-1) @enforce_types - def s(self, order:int, *, der_name:str|None = None, int_name:str|None = None, method:str = 'euler') -> Stream: + def s( + self, + order: int, + *, + der_name: str | None = None, + int_name: str | None = None, + method: str = "euler", + ) -> Stream: """ Considering the Laplace transform notation. The function is used to operate an integral or derivate operation on the input. The order of the integral or the derivative operation is indicated by the order parameter. @@ -203,19 +254,25 @@ def s(self, order:int, *, der_name:str|None = None, int_name:str|None = None, me Stream A Stream of the signal represents the integral or derivation operation. """ - check(order != 0, ValueError, "The order must be a positive or negative integer not a zero") + check( + order != 0, + ValueError, + "The order must be a positive or negative integer not a zero", + ) if order > 0: o = self.last() for i in range(order): - o = Differentiate(o, der_name = der_name, int_name = int_name, method = method) + o = Differentiate( + o, der_name=der_name, int_name=int_name, method=method + ) elif order < 0: o = self.last() for i in range(-order): - o = Integrate(o, der_name = der_name, int_name = int_name, method = method) + o = Integrate(o, der_name=der_name, int_name=int_name, method=method) return o @enforce_types - def connect(self, obj:Stream) -> "Input": + def connect(self, obj: Stream) -> "Input": """ Update and return the current Input with a given Stream object. @@ -236,17 +293,24 @@ def connect(self, obj:Stream) -> "Input": KeyError If the Input variable is already connected. """ - check(type(obj) is Stream, TypeError, - f"The {obj} must be a Stream and not a {type(obj)}.") + check( + type(obj) is Stream, + TypeError, + f"The {obj} must be a Stream and not a {type(obj)}.", + ) self.json = merge(self.json, obj.json) - check('closedLoop' not in self.json['Inputs'][self.name] or 'connect' not in self.json['Inputs'][self.name], KeyError, - f"The Input variable {self.name} is already connected.") - self.json['Inputs'][self.name]['connect'] = obj.name - self.json['Inputs'][self.name]['local'] = 1 + check( + "closedLoop" not in self.json["Inputs"][self.name] + or "connect" not in self.json["Inputs"][self.name], + KeyError, + f"The Input variable {self.name} is already connected.", + ) + self.json["Inputs"][self.name]["connect"] = obj.name + self.json["Inputs"][self.name]["local"] = 1 return self @enforce_types - def closedLoop(self, obj:Stream) -> "Input": + def closedLoop(self, obj: Stream) -> "Input": """ Update and return the current Input in a closed loop with a given Stream object. @@ -267,41 +331,58 @@ def closedLoop(self, obj:Stream) -> "Input": KeyError If the Input variable is already connected. """ - from nnodely.layers.input import Input - check(type(obj) is Stream, TypeError, - f"The {obj} must be a Stream and not a {type(obj)}.") + + check( + type(obj) is Stream, + TypeError, + f"The {obj} must be a Stream and not a {type(obj)}.", + ) self.json = merge(self.json, obj.json) - check('closedLoop' not in self.json['Inputs'][self.name] or 'connect' not in self.json['Inputs'][self.name], - KeyError, - f"The Input variable {self.name} is already connected.") - self.json['Inputs'][self.name]['closedLoop'] = self.name - self.json['Inputs'][self.name]['local'] = 1 + check( + "closedLoop" not in self.json["Inputs"][self.name] + or "connect" not in self.json["Inputs"][self.name], + KeyError, + f"The Input variable {self.name} is already connected.", + ) + self.json["Inputs"][self.name]["closedLoop"] = self.name + self.json["Inputs"][self.name]["local"] = 1 return self def __str__(self): - return stream_to_str(self, 'Input') + return stream_to_str(self, "Input") def __repr__(self): return self.__str__() + # connect operation -connect_name = 'connect' -closedloop_name = 'closedLoop' +connect_name = "connect" +closedloop_name = "closedLoop" + class Connect(Stream, ToStream): @enforce_types - def __init__(self, obj1:Stream, obj2:Input, *, local:bool=False) -> Stream: - super().__init__(obj1.name,merge(obj1.json, obj2.json),obj1.dim) - check(closedloop_name not in self.json['Inputs'][obj2.name] or connect_name not in self.json['Inputs'][obj2.name], - KeyError,f"The input variable {obj2.name} is already connected.") - self.json['Inputs'][obj2.name][connect_name] = obj1.name - self.json['Inputs'][obj2.name]['local'] = int(local) + def __init__(self, obj1: Stream, obj2: Input, *, local: bool = False) -> Stream: + super().__init__(obj1.name, merge(obj1.json, obj2.json), obj1.dim) + check( + closedloop_name not in self.json["Inputs"][obj2.name] + or connect_name not in self.json["Inputs"][obj2.name], + KeyError, + f"The input variable {obj2.name} is already connected.", + ) + self.json["Inputs"][obj2.name][connect_name] = obj1.name + self.json["Inputs"][obj2.name]["local"] = int(local) + class ClosedLoop(Stream, ToStream): @enforce_types - def __init__(self, obj1:Stream, obj2:Input, *, local:bool=False) -> Stream: + def __init__(self, obj1: Stream, obj2: Input, *, local: bool = False) -> Stream: super().__init__(obj1.name, merge(obj1.json, obj2.json), obj1.dim) - check(closedloop_name not in self.json['Inputs'][obj2.name] or connect_name not in self.json['Inputs'][obj2.name], - KeyError, f"The input variable {obj2.name} is already connected.") - self.json['Inputs'][obj2.name][closedloop_name] = obj1.name - self.json['Inputs'][obj2.name]['local'] = int(local) \ No newline at end of file + check( + closedloop_name not in self.json["Inputs"][obj2.name] + or connect_name not in self.json["Inputs"][obj2.name], + KeyError, + f"The input variable {obj2.name} is already connected.", + ) + self.json["Inputs"][obj2.name][closedloop_name] = obj1.name + self.json["Inputs"][obj2.name]["local"] = int(local) diff --git a/nnodely/layers/interpolation.py b/src/nnodely/layers/interpolation.py similarity index 63% rename from nnodely/layers/interpolation.py rename to src/nnodely/layers/interpolation.py index 8f1e90c0..7214df22 100644 --- a/nnodely/layers/interpolation.py +++ b/src/nnodely/layers/interpolation.py @@ -7,7 +7,9 @@ from nnodely.support.utils import check, enforce_types from nnodely.support.jsonutils import merge -interpolation_relation_name = 'Interpolation' +interpolation_relation_name = "Interpolation" + + class Interpolation(NeuObj): """ Represents an Interpolation relation in the neural network model. @@ -35,40 +37,64 @@ class Interpolation(NeuObj): >>> x = Input('x') >>> rel1 = Interpolation(x_points=x_points,y_points=y_points, mode='linear')(x.last()) - + >>> out = Output('out',rel1) """ @enforce_types - def __init__(self, x_points:list, - y_points:list, *, - mode:str|None = 'linear'): + def __init__(self, x_points: list, y_points: list, *, mode: str | None = "linear"): self.relation_name = interpolation_relation_name self.x_points = x_points self.y_points = y_points self.mode = mode - self.available_modes = ['linear', 'polynomial'] - - super().__init__('P' + interpolation_relation_name + str(NeuObj.count)) - check(len(x_points) == len(y_points), ValueError, 'The x_points and y_points must have the same length.') - check(mode in self.available_modes, ValueError, f'The mode must be one of {self.available_modes}.') - check(len(torch.tensor(x_points).shape) == 1, ValueError, 'The x_points must be a 1D tensor.') - check(len(torch.tensor(y_points).shape) == 1, ValueError, 'The y_points must be a 1D tensor.') + self.available_modes = ["linear", "polynomial"] + + super().__init__("P" + interpolation_relation_name + str(NeuObj.count)) + check( + len(x_points) == len(y_points), + ValueError, + "The x_points and y_points must have the same length.", + ) + check( + mode in self.available_modes, + ValueError, + f"The mode must be one of {self.available_modes}.", + ) + check( + len(torch.tensor(x_points).shape) == 1, + ValueError, + "The x_points must be a 1D tensor.", + ) + check( + len(torch.tensor(y_points).shape) == 1, + ValueError, + "The y_points must be a 1D tensor.", + ) @enforce_types - def __call__(self, obj:Stream) -> Stream: + def __call__(self, obj: Stream) -> Stream: stream_name = interpolation_relation_name + str(Stream.count) - check(type(obj) is Stream, TypeError, f"The type of {obj} is {type(obj)} and is not supported for Interpolation operation.") - - stream_json = merge(self.json,obj.json) - stream_json['Relations'][stream_name] = [interpolation_relation_name, [obj.name], self.x_points, self.y_points, self.mode] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Interpolation operation.", + ) + + stream_json = merge(self.json, obj.json) + stream_json["Relations"][stream_name] = [ + interpolation_relation_name, + [obj.name], + self.x_points, + self.y_points, + self.mode, + ] return Stream(stream_name, stream_json, obj.dim) class Interpolation_Layer(nn.Module): - def __init__(self, x_points, y_points, mode='linear'): + def __init__(self, x_points, y_points, mode="linear"): super(Interpolation_Layer, self).__init__() self.mode = mode ## Sort the points @@ -83,13 +109,13 @@ def __init__(self, x_points, y_points, mode='linear'): self.y_points = self.y_points.unsqueeze(-1) def forward(self, x): - if self.mode == 'linear': + if self.mode == "linear": return self.linear_interpolation(x) else: raise NotImplementedError - + def linear_interpolation(self, x): - # Inputs: + # Inputs: # x: query point, a tensor of shape torch.Size([N, 1, 1]) # x_data: map of x values, sorted in ascending order, a tensor of shape torch.Size([Q, 1]) # y_data: map of y values, a tensor of shape torch.Size([Q, 1]) @@ -97,14 +123,18 @@ def linear_interpolation(self, x): # y: interpolated value at x, a tensor of shape torch.Size([N, 1, 1]) # Saturate x to the range of x_data - x = torch.min(torch.max(x,self.x_points[0]),self.x_points[-1]) + x = torch.min(torch.max(x, self.x_points[0]), self.x_points[-1]) # Find the index of the closest value in x_data - idx = torch.argmin(torch.abs(self.x_points[:-1] - x),dim=1) + idx = torch.argmin(torch.abs(self.x_points[:-1] - x), dim=1) # Linear interpolation - y = self.y_points[idx] + (self.y_points[idx+1] - self.y_points[idx])/(self.x_points[idx+1] - self.x_points[idx])*(x - self.x_points[idx]) + y = self.y_points[idx] + (self.y_points[idx + 1] - self.y_points[idx]) / ( + self.x_points[idx + 1] - self.x_points[idx] + ) * (x - self.x_points[idx]) return y + def createInterpolation(self, *inputs): return Interpolation_Layer(x_points=inputs[0], y_points=inputs[1], mode=inputs[2]) -setattr(Model, interpolation_relation_name, createInterpolation) \ No newline at end of file + +setattr(Model, interpolation_relation_name, createInterpolation) diff --git a/nnodely/layers/linear.py b/src/nnodely/layers/linear.py similarity index 51% rename from nnodely/layers/linear.py rename to src/nnodely/layers/linear.py index 0a6ac3ed..d7511107 100644 --- a/nnodely/layers/linear.py +++ b/src/nnodely/layers/linear.py @@ -12,9 +12,11 @@ from nnodely.support.jsonutils import merge from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) -linear_relation_name = 'Linear' +linear_relation_name = "Linear" + class Linear(NeuObj, AutoToStream): """ @@ -77,14 +79,18 @@ class Linear(NeuObj, AutoToStream): """ @enforce_types - def __init__(self, output_dimension:int|None = None, *, - W_init:Callable|str|None = None, - W_init_params:dict|None = None, - b_init:Callable|str|None = None, - b_init_params:dict|None = None, - W:Parameter|str|None = None, - b:bool|str|Parameter|None = None, - dropout:int|float = 0): + def __init__( + self, + output_dimension: int | None = None, + *, + W_init: Callable | str | None = None, + W_init_params: dict | None = None, + b_init: Callable | str | None = None, + b_init_params: dict | None = None, + W: Parameter | str | None = None, + b: bool | str | Parameter | None = None, + dropout: int | float = 0, + ): self.W = W self.b = b @@ -92,57 +98,113 @@ def __init__(self, output_dimension:int|None = None, *, self.Wname = None self.dropout = dropout - super().__init__('P' + linear_relation_name + str(NeuObj.count)) + super().__init__("P" + linear_relation_name + str(NeuObj.count)) if type(self.W) is Parameter: - check('tw' not in self.W.dim.keys() and 'sw' not in self.W.dim.keys(), TypeError, f'The "W" must no have time dimension but was {W.dim}.') - check(len(self.W.dim['dim']) == 2, ValueError,'The "W" dimensions must be a list of 2.') - self.output_dimension = self.W.dim['dim'][1] + check( + "tw" not in self.W.dim.keys() and "sw" not in self.W.dim.keys(), + TypeError, + f'The "W" must no have time dimension but was {W.dim}.', + ) + check( + len(self.W.dim["dim"]) == 2, + ValueError, + 'The "W" dimensions must be a list of 2.', + ) + self.output_dimension = self.W.dim["dim"][1] if output_dimension is not None: - check(self.W.dim['dim'][1] == output_dimension, ValueError, 'output_dimension must be equal to the second dim of "W".') + check( + self.W.dim["dim"][1] == output_dimension, + ValueError, + 'output_dimension must be equal to the second dim of "W".', + ) self.Wname = self.W.name W_json = W.json else: self.output_dimension = 1 if output_dimension is None else output_dimension - self.Wname = W if type(W) is str else self.name + 'W' - W_json = Parameter(name=self.Wname, dimensions=self.output_dimension, init=W_init, init_params=W_init_params).json - self.json = merge(self.json,W_json) + self.Wname = W if type(W) is str else self.name + "W" + W_json = Parameter( + name=self.Wname, + dimensions=self.output_dimension, + init=W_init, + init_params=W_init_params, + ).json + self.json = merge(self.json, W_json) if self.b is not None and self.b is not False: if type(self.b) is Parameter: - check('tw' not in self.b.dim and 'sw' not in self.b.dim, TypeError, f'The "bias" must no have a time dimensions but got {self.b.dim}.') - check(type(self.b.dim['dim']) is int, TypeError, 'The "b" dimensions must be an integer.') - check(self.b.dim['dim'] == self.output_dimension, ValueError,'output_dimension must be equal to the dim of the "b".') + check( + "tw" not in self.b.dim and "sw" not in self.b.dim, + TypeError, + f'The "bias" must no have a time dimensions but got {self.b.dim}.', + ) + check( + type(self.b.dim["dim"]) is int, + TypeError, + 'The "b" dimensions must be an integer.', + ) + check( + self.b.dim["dim"] == self.output_dimension, + ValueError, + 'output_dimension must be equal to the dim of the "b".', + ) self.bname = self.b.name b_json = self.b.json else: - self.bname = b if type(self.b) is str else self.name + 'b' - b_json = Parameter(name=self.bname, dimensions=self.output_dimension, init=b_init, init_params=b_init_params).json - self.json = merge(self.json,b_json) + self.bname = b if type(self.b) is str else self.name + "b" + b_json = Parameter( + name=self.bname, + dimensions=self.output_dimension, + init=b_init, + init_params=b_init_params, + ).json + self.json = merge(self.json, b_json) self.json_stream = {} @enforce_types - def __call__(self, obj:Stream) -> Stream: + def __call__(self, obj: Stream) -> Stream: stream_name = linear_relation_name + str(Stream.count) - check(type(obj) is Stream, TypeError,f"The type of {obj} is {type(obj)} and is not supported for Linear operation.") - window = 'tw' if 'tw' in obj.dim else ('sw' if 'sw' in obj.dim else None) - - json_stream_name = obj.dim['dim'] - if obj.dim['dim'] not in self.json_stream: + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Linear operation.", + ) + window = "tw" if "tw" in obj.dim else ("sw" if "sw" in obj.dim else None) + + json_stream_name = obj.dim["dim"] + if obj.dim["dim"] not in self.json_stream: if len(self.json_stream) > 0: - log.warning(f"The Linear {self.name} was called with inputs with different dimensions. If both Linear enter in the model an error will be raised.") + log.warning( + f"The Linear {self.name} was called with inputs with different dimensions. If both Linear enter in the model an error will be raised." + ) self.json_stream[json_stream_name] = copy.deepcopy(self.json) - self.json_stream[json_stream_name]['Parameters'][self.Wname]['dim'] = [obj.dim['dim'],self.output_dimension,] + self.json_stream[json_stream_name]["Parameters"][self.Wname]["dim"] = [ + obj.dim["dim"], + self.output_dimension, + ] if type(self.W) is Parameter: - check(self.json['Parameters'][self.Wname]['dim'][0] == obj.dim['dim'], ValueError, - 'the input dimension must be equal to the first dim of the parameter') - - stream_json = merge(self.json_stream[json_stream_name],obj.json) - stream_json['Relations'][stream_name] = [linear_relation_name, [obj.name], self.Wname, self.bname, self.dropout] - return Stream(stream_name, stream_json,{'dim': self.output_dimension, window:obj.dim[window]}) + check( + self.json["Parameters"][self.Wname]["dim"][0] == obj.dim["dim"], + ValueError, + "the input dimension must be equal to the first dim of the parameter", + ) + + stream_json = merge(self.json_stream[json_stream_name], obj.json) + stream_json["Relations"][stream_name] = [ + linear_relation_name, + [obj.name], + self.Wname, + self.bname, + self.dropout, + ] + return Stream( + stream_name, + stream_json, + {"dim": self.output_dimension, window: obj.dim[window]}, + ) class Linear_Layer(nn.Module): @@ -155,15 +217,19 @@ def __init__(self, weights, bias=None, dropout=0): def forward(self, x): # x is expected to be of shape [batch, window, input_dimension] # Using torch.einsum for batch matrix multiplication - y = torch.einsum('bwi,io->bwo', x, self.weights) # y will have shape [batch, window, output_features] + y = torch.einsum( + "bwi,io->bwo", x, self.weights + ) # y will have shape [batch, window, output_features] if self.bias is not None: - y += self.bias + y += self.bias # Add dropout if necessary if self.dropout is not None: y = self.dropout(y) return y + def createLinear(self, *inputs): return Linear_Layer(weights=inputs[0], bias=inputs[1], dropout=inputs[2]) + setattr(Model, linear_relation_name, createLinear) diff --git a/src/nnodely/layers/localmodel.py b/src/nnodely/layers/localmodel.py new file mode 100644 index 00000000..18cdad61 --- /dev/null +++ b/src/nnodely/layers/localmodel.py @@ -0,0 +1,197 @@ +import inspect + +from collections.abc import Callable + +from nnodely.basic.relation import NeuObj, Stream +from nnodely.layers.arithmetic import add_relation_name +from nnodely.layers.part import Select +from nnodely.support.jsonutils import merge +from nnodely.support.utils import check, enforce_types + +localmodel_relation_name = "LocalModel" + + +def _signature_len(fn) -> int: + return len(inspect.signature(fn).parameters) + + +def _apply(fn, x): + """Invoke ``fn`` on a Stream or on the unpacked elements of a tuple.""" + return fn(*x) if type(x) is tuple else fn(x) + + +class LocalModel(NeuObj): + """ + Represents a Local Model relation in the neural network model. + + Parameters + ---------- + input_function : Callable, optional + A callable function to process the inputs. + output_function : Callable, optional + A callable function to process the outputs. + pass_indexes : bool, optional + A boolean indicating whether to pass indexes to the functions. Default is False. + + Attributes + ---------- + relation_name : str + The name of the relation. + pass_indexes : bool + A boolean indicating whether to pass indexes to the functions. + input_function : Callable + The function to process the inputs. + output_function : Callable + The function to process the outputs. + + Examples + -------- + + .. include:: /examples_basics/layer_module_ex/localmodel.rst + """ + + @enforce_types + def __init__( + self, + input_function: Callable | None = None, + output_function: Callable | None = None, + *, + pass_indexes: bool = False, + ): + self.relation_name = localmodel_relation_name + self.pass_indexes = pass_indexes + self.input_function = input_function + self.output_function = output_function + super().__init__(localmodel_relation_name + str(NeuObj.count)) + self.json["Functions"][self.name] = {} + + @enforce_types + def __call__(self, inputs: Stream | tuple, activations: Stream | tuple = None): + if type(activations) is not tuple: + activations = (activations,) + + in_func = self.input_function + check( + in_func is not None or type(inputs) is not tuple, + TypeError, + "The input cannot be a tuple without input_function", + ) + + # ``input_function`` output is reusable across cells iff the same + # callable is invoked with the same arguments for every cell: + # ``pass_indexes`` False and not a zero-arg factory. + shared_out_in = None + if ( + in_func is not None + and not self.pass_indexes + and _signature_len(in_func) > 0 + ): + shared_out_in = _apply(in_func, inputs) + + select_cache: dict[tuple[int, int], Stream] = {} + + def cached_select(act_idx: int, i: int) -> Stream: + cached = select_cache.get((act_idx, i)) + if cached is None: + cached = Select(activations[act_idx], i) + select_cache[(act_idx, i)] = cached + return cached + + cells: list[Stream] = [] + self._build_cells( + activations, + inputs, + cells, + cached_select, + shared_out_in, + prefix=None, + idx_list=[], + depth=0, + ) + return self._nary_add(cells) + + def _build_cells( + self, + activations, + inputs, + cells, + cached_select, + shared_out_in, + *, + prefix, + idx_list, + depth, + ): + # ``prefix`` is the cached product of Selects for indices [0..depth); + # sibling subtrees reuse the same Stream, turning the per-cell K-1 + # chain of activation muls into an incremental tree build. + if depth == len(activations): + out_in = ( + shared_out_in + if shared_out_in is not None + else self._apply_fn( + self.input_function, + inputs, + idx_list, + ) + ) + cells.append( + self._apply_fn( + self.output_function, + out_in * prefix, + idx_list, + ) + ) + return + + for i in range(activations[depth].dim["dim"]): + sel = cached_select(depth, i) + new_prefix = sel if prefix is None else prefix * sel + self._build_cells( + activations, + inputs, + cells, + cached_select, + shared_out_in, + prefix=new_prefix, + idx_list=idx_list + [i], + depth=depth + 1, + ) + + def _apply_fn(self, fn, x, idx_list): + # Dispatch on the user function's signature: + # zero-arg ``fn`` is a factory producing a fresh cell callable; + # ``pass_indexes`` makes the factory idx-dependent; otherwise ``fn`` + # is already the cell callable (shared params across cells). + if fn is None: + return x + if _signature_len(fn) == 0: + cell_fn = fn() + elif self.pass_indexes: + cell_fn = fn(idx_list) + else: + cell_fn = fn + return _apply(cell_fn, x) + + @staticmethod + def _nary_add(cells: list[Stream]) -> Stream: + # Equivalent to ``cells[0] + cells[1] + ... + cells[-1]``, but folded + # into a single ``Add`` relation. ``Add_Layer.forward(*inputs)`` does + # the same left-to-right fold at runtime, so the float result is + # bit-exact to the chained binary version while the build avoids + # ``N-1`` intermediate Streams (each of which would deep-copy a + # growing JSON). + if len(cells) == 1: + return cells[0] + + combined = cells[0].json + for c in cells[1:]: + combined = merge(combined, c.json) + + name = add_relation_name + str(Stream.count) + new_stream = Stream(name, combined, cells[0].dim) + new_stream.json["Relations"][name] = [ + add_relation_name, + [c.name for c in cells], + ] + return new_stream diff --git a/nnodely/layers/neuralODE.py b/src/nnodely/layers/neuralODE.py similarity index 54% rename from nnodely/layers/neuralODE.py rename to src/nnodely/layers/neuralODE.py index 787498ff..c41017a1 100644 --- a/nnodely/layers/neuralODE.py +++ b/src/nnodely/layers/neuralODE.py @@ -1,4 +1,6 @@ -import inspect, copy, textwrap, torch, math +import inspect +import copy +import textwrap import torch.nn as nn @@ -9,9 +11,11 @@ from nnodely.support.jsonutils import merge from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) -ode_relation_name = 'NeuralODE' +ode_relation_name = "NeuralODE" + class NeuralODE(NeuObj): """Neural ODE layer implementing continuous-depth models. @@ -24,13 +28,15 @@ class NeuralODE(NeuObj): """ @enforce_types - def __init__(self, - func: ParamFun, - dt: float, - rtol: float = 1e-7, - atol: float = 1e-9, - method: str = 'dopri5') -> Stream: - super().__init__('F'+ode_relation_name + str(NeuObj.count)) + def __init__( + self, + func: ParamFun, + dt: float, + rtol: float = 1e-7, + atol: float = 1e-9, + method: str = "dopri5", + ) -> Stream: + super().__init__("F" + ode_relation_name + str(NeuObj.count)) self.func = func self.dt = dt @@ -38,21 +44,25 @@ def __init__(self, self.atol = atol self.method = method - code = textwrap.dedent(inspect.getsource(func.param_fun)).replace('\"', '\'') - code = 'def ' + f'{self.name}' + '(state, *weights):\n' + \ - ' from nnodely.support.odeint.adjoint import odeint_adjoint as odeint\n ' + \ - code.replace('\n', '\n ') + \ - '\n' + \ - f' ans = odeint(lambda t, y: {func.param_fun.__name__}(t, y, *weights), state, t=torch.tensor([0.0, {self.dt}]), rtol={self.rtol}, atol={self.atol}, method=\'{self.method}\', adjoint_params=list(weights))' + \ - f'\n return ans[-1]\n' - - self.json['Functions'][self.name] = { - 'code' : code, - 'name' : f'{self.name}', - 'rtol' : rtol, - 'atol' : atol, - 'method' : method, - 'dt' : dt + code = textwrap.dedent(inspect.getsource(func.param_fun)).replace('"', "'") + code = ( + "def " + + f"{self.name}" + + "(state, *weights):\n" + + " from nnodely.support.odeint.adjoint import odeint_adjoint as odeint\n " + + code.replace("\n", "\n ") + + "\n" + + f" ans = odeint(lambda t, y: {func.param_fun.__name__}(t, y, *weights), state, t=torch.tensor([0.0, {self.dt}]), rtol={self.rtol}, atol={self.atol}, method='{self.method}', adjoint_params=list(weights))" + + "\n return ans[-1]\n" + ) + + self.json["Functions"][self.name] = { + "code": code, + "name": f"{self.name}", + "rtol": rtol, + "atol": atol, + "method": method, + "dt": dt, } self.json_stream = {} @@ -63,28 +73,34 @@ def __call__(self, *obj: Stream) -> Stream: input_names = [] for ind, o in enumerate(obj): o = toStream(o) - check(type(o) is Stream, TypeError, - f"The type of {o} is {type(o)} and is not supported for ParamFun operation.") + check( + type(o) is Stream, + TypeError, + f"The type of {o} is {type(o)} and is not supported for ParamFun operation.", + ) stream_json = merge(stream_json, o.json) input_names.append(o.name) - stream_json['Relations'][stream_name] = [ode_relation_name, input_names, self.name] + stream_json["Relations"][stream_name] = [ + ode_relation_name, + input_names, + self.name, + ] return Stream(stream_name, stream_json, obj[0].dim) class ODE_Layer(nn.Module): - def __init__(self, func): super().__init__() - self.name = func['name'] - self.dt = func['dt'] - self.rtol = func['rtol'] - self.atol = func['atol'] - self.method = func['method'] + self.name = func["name"] + self.dt = func["dt"] + self.rtol = func["rtol"] + self.atol = func["atol"] + self.method = func["method"] ## Add the function to the globals try: - code = 'import torch\n@torch.fx.wrap\n' + func['code'] - #print(f"Defining ODE function:\n{code}") + code = "import torch\n@torch.fx.wrap\n" + func["code"] + # print(f"Defining ODE function:\n{code}") exec(code, globals()) except Exception as e: print(f"An error occurred: {e}") @@ -95,10 +111,12 @@ def forward(self, *inputs): weights = list(inputs)[1:] return function_to_call(list(inputs)[0], *weights) # Return the last state + def createODE(self, *func_params): # for key, value in func_params[0].items(): # print(f"{key}: {value}") - + return ODE_Layer(func_params[0]) -setattr(Model, ode_relation_name, createODE) \ No newline at end of file + +setattr(Model, ode_relation_name, createODE) diff --git a/nnodely/layers/output.py b/src/nnodely/layers/output.py similarity index 82% rename from nnodely/layers/output.py rename to src/nnodely/layers/output.py index f80f3670..9a28295a 100644 --- a/nnodely/layers/output.py +++ b/src/nnodely/layers/output.py @@ -5,8 +5,10 @@ from nnodely.support.jsonutils import stream_to_str from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.INFO) + class Output(NeuObj): """ Represents an output in the neural network model. This relation is what the network will give as output during inference. @@ -27,8 +29,9 @@ class Output(NeuObj): dim : dict A dictionary containing the dimensions of the output. """ + @enforce_types - def __init__(self, name:str, relation:Stream): + def __init__(self, name: str, relation: Stream): """ Initializes the Output object. @@ -41,12 +44,12 @@ def __init__(self, name:str, relation:Stream): """ super().__init__(name, relation.json, relation.dim) log.debug(f"Output {name}") - self.json['Outputs'][name] = {} - self.json['Outputs'][name] = relation.name - log.debug("\n"+pformat(self.json)) + self.json["Outputs"][name] = {} + self.json["Outputs"][name] = relation.name + log.debug("\n" + pformat(self.json)) def __str__(self): - return stream_to_str(self, 'Output') + return stream_to_str(self, "Output") def __repr__(self): - return self.__str__() \ No newline at end of file + return self.__str__() diff --git a/nnodely/layers/parameter.py b/src/nnodely/layers/parameter.py similarity index 54% rename from nnodely/layers/parameter.py rename to src/nnodely/layers/parameter.py index c3bc129f..af99160d 100644 --- a/nnodely/layers/parameter.py +++ b/src/nnodely/layers/parameter.py @@ -1,4 +1,6 @@ -import copy, inspect, textwrap +import copy +import inspect +import textwrap import numpy as np from collections.abc import Callable @@ -10,6 +12,7 @@ def is_numpy_float(var): return isinstance(var, (np.float16, np.float32, np.float64)) + class Constant(NeuObj, Relation): """ Represents a constant value in the neural network model. @@ -39,11 +42,16 @@ class Constant(NeuObj, Relation): .. include:: /examples_basics/parameter_module_ex/constant.rst """ + @enforce_types - def __init__(self, name:str, - values:list|float|int|np.ndarray, *, - tw:float|int|None = None, - sw:int|None = None): + def __init__( + self, + name: str, + values: list | float | int | np.ndarray, + *, + tw: float | int | None = None, + sw: int | None = None, + ): NeuObj.__init__(self, name) values = np.array(values, dtype=NP_DTYPE) @@ -52,26 +60,45 @@ def __init__(self, name:str, self.dim = {} if tw is not None: - check(len(shape) >= 2, ValueError, "The dimension must be at least 2 if tw is set.") + check( + len(shape) >= 2, + ValueError, + "The dimension must be at least 2 if tw is set.", + ) check(sw is None, ValueError, "If tw is set sw must be None") dimensions = shape[1] if len(shape[1:]) == 1 else list(shape[1:]) - self.dim['tw'] = tw + self.dim["tw"] = tw elif sw is not None: - check(len(shape) >= 2, ValueError, "The dimension must be at least 2 if sw is set.") - self.dim['sw'] = sw - check(shape[0] == self.dim['sw'],ValueError, f"The sw = {sw} is different from sw = {shape[0]} of the values.") + check( + len(shape) >= 2, + ValueError, + "The dimension must be at least 2 if sw is set.", + ) + self.dim["sw"] = sw + check( + shape[0] == self.dim["sw"], + ValueError, + f"The sw = {sw} is different from sw = {shape[0]} of the values.", + ) dimensions = shape[1] if len(shape[1:]) == 1 else list(shape[1:]) else: - dimensions = 1 if len(shape[0:]) == 0 else shape[0] if len(shape[0:]) == 1 else list(shape[0:]) + dimensions = ( + 1 + if len(shape[0:]) == 0 + else shape[0] + if len(shape[0:]) == 1 + else list(shape[0:]) + ) - self.dim['dim'] = dimensions + self.dim["dim"] = dimensions # deepcopy dimention information inside Parameters - self.json['Constants'][self.name] = copy.deepcopy(self.dim) - if type(values) in (float,int): - self.json['Constants'][self.name]['values'] = [values] + self.json["Constants"][self.name] = copy.deepcopy(self.dim) + if type(values) in (float, int): + self.json["Constants"][self.name]["values"] = [values] else: - self.json['Constants'][self.name]['values'] = values + self.json["Constants"][self.name]["values"] = values + class Parameter(NeuObj, Relation): """ @@ -113,29 +140,34 @@ class Parameter(NeuObj, Relation): .. include:: /examples_basics/parameter_module_ex/parameter.rst """ + @enforce_types - def __init__(self, name:str, - dimensions:int|list|tuple|None = None, *, - tw:float|int|None = None, - sw:int|None = None, - values:list|float|int|np.ndarray|None = None, - init:Callable|str|None = None, - init_params:dict|None = None): + def __init__( + self, + name: str, + dimensions: int | list | tuple | None = None, + *, + tw: float | int | None = None, + sw: int | None = None, + values: list | float | int | np.ndarray | None = None, + init: Callable | str | None = None, + init_params: dict | None = None, + ): NeuObj.__init__(self, name) dimensions = list(dimensions) if type(dimensions) is tuple else dimensions if values is None: if dimensions is None: dimensions = 1 - self.dim = {'dim': dimensions} + self.dim = {"dim": dimensions} if tw is not None: check(sw is None, ValueError, "If tw is set sw must be None") - self.dim['tw'] = tw + self.dim["tw"] = tw elif sw is not None: - self.dim['sw'] = sw + self.dim["sw"] = sw # deepcopy dimention information inside Parameters - self.json['Parameters'][self.name] = copy.deepcopy(self.dim) + self.json["Parameters"][self.name] = copy.deepcopy(self.dim) else: values = np.array(values, dtype=NP_DTYPE) shape = values.shape @@ -143,41 +175,68 @@ def __init__(self, name:str, self.dim = {} if tw is not None: - check(len(shape) >= 2, ValueError, "The dimension must be at least 2 if tw is set.") + check( + len(shape) >= 2, + ValueError, + "The dimension must be at least 2 if tw is set.", + ) check(sw is None, ValueError, "If tw is set sw must be None") dimensions = shape[1] if len(shape[1:]) == 1 else list(shape[1:]) - self.dim['tw'] = tw + self.dim["tw"] = tw elif sw is not None: - check(len(shape) >= 2, ValueError, "The dimension must be at least 2 if sw is set.") - self.dim['sw'] = sw - check(shape[0] == self.dim['sw'], ValueError, - f"The sw = {sw} is different from sw = {shape[0]} of the values.") + check( + len(shape) >= 2, + ValueError, + "The dimension must be at least 2 if sw is set.", + ) + self.dim["sw"] = sw + check( + shape[0] == self.dim["sw"], + ValueError, + f"The sw = {sw} is different from sw = {shape[0]} of the values.", + ) dimensions = shape[1] if len(shape[1:]) == 1 else list(shape[1:]) else: - dimensions = 1 if len(shape[0:]) == 0 else shape[0] if len(shape[0:]) == 1 else list(shape[0:]) + dimensions = ( + 1 + if len(shape[0:]) == 0 + else shape[0] + if len(shape[0:]) == 1 + else list(shape[0:]) + ) - self.dim['dim'] = dimensions + self.dim["dim"] = dimensions # deepcopy dimention information inside Parameters - self.json['Parameters'][self.name] = copy.deepcopy(self.dim) + self.json["Parameters"][self.name] = copy.deepcopy(self.dim) if type(values) in (int, float): - self.json['Parameters'][self.name]['init_values'] = [values] + self.json["Parameters"][self.name]["init_values"] = [values] else: - self.json['Parameters'][self.name]['init_values'] = values - self.json['Parameters'][self.name]['values'] = self.json['Parameters'][self.name]['init_values'] + self.json["Parameters"][self.name]["init_values"] = values + self.json["Parameters"][self.name]["values"] = self.json["Parameters"][ + self.name + ]["init_values"] if init is not None: - check('values' not in self.json['Parameters'][self.name], ValueError, f"The parameter {self.name} is already initialized.") - #check(inspect.isfunction(init), ValueError,f"The init parameter must be a function.") + check( + "values" not in self.json["Parameters"][self.name], + ValueError, + f"The parameter {self.name} is already initialized.", + ) + # check(inspect.isfunction(init), ValueError,f"The init parameter must be a function.") if inspect.isfunction(init): - code = textwrap.dedent(inspect.getsource(init)).replace('\"', '\'') - self.json['Parameters'][self.name]['init_fun'] = { 'code' : code, 'name' : init.__name__} + code = textwrap.dedent(inspect.getsource(init)).replace('"', "'") + self.json["Parameters"][self.name]["init_fun"] = { + "code": code, + "name": init.__name__, + } elif type(init) is str: - self.json['Parameters'][self.name]['init_fun'] = { 'name' : init } + self.json["Parameters"][self.name]["init_fun"] = {"name": init} if init_params is not None: - self.json['Parameters'][self.name]['init_fun']['params'] = init_params - -class SampleTime(): + self.json["Parameters"][self.name]["init_fun"]["params"] = init_params + + +class SampleTime: """ Represents a constant value that is equal to the sample time. @@ -194,10 +253,14 @@ class SampleTime(): ------- .. include:: /examples_basics/parameter_module_ex/sample_time.rst """ - name = 'SampleTime' + + name = "SampleTime" g = Constant(name, values=0) + def __new__(cls): - SampleTime.g.dim = {'dim': 1} - SampleTime.g.json['Constants'][SampleTime.name] = copy.deepcopy(SampleTime.g.dim) - SampleTime.g.json['Constants'][SampleTime.name]['values'] = SampleTime.name + SampleTime.g.dim = {"dim": 1} + SampleTime.g.json["Constants"][SampleTime.name] = copy.deepcopy( + SampleTime.g.dim + ) + SampleTime.g.json["Constants"][SampleTime.name]["values"] = SampleTime.name return SampleTime.g diff --git a/nnodely/layers/parametricfunction.py b/src/nnodely/layers/parametricfunction.py similarity index 55% rename from nnodely/layers/parametricfunction.py rename to src/nnodely/layers/parametricfunction.py index 8cc6d714..75335361 100644 --- a/nnodely/layers/parametricfunction.py +++ b/src/nnodely/layers/parametricfunction.py @@ -1,4 +1,8 @@ -import inspect, copy, textwrap, torch, math +import inspect +import copy +import textwrap +import torch +import math import torch.nn as nn import numpy as np @@ -13,10 +17,12 @@ from nnodely.support.jsonutils import merge from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) -paramfun_relation_name = 'ParamFun' +paramfun_relation_name = "ParamFun" + class ParamFun(NeuObj): """ @@ -56,13 +62,18 @@ class ParamFun(NeuObj): Examples -------- - + .. include:: /examples_basics/layer_module_ex/paramfun.rst """ + @enforce_types - def __init__(self, param_fun:Callable, - parameters_and_constants:list|dict|None = None, *, - map_over_batch:bool = False) -> Stream: + def __init__( + self, + param_fun: Callable, + parameters_and_constants: list | dict | None = None, + *, + map_over_batch: bool = False, + ) -> Stream: self.relation_name = paramfun_relation_name @@ -72,13 +83,13 @@ def __init__(self, param_fun:Callable, self.map_over_batch = map_over_batch self.output_dimension = {} - super().__init__('F'+paramfun_relation_name + str(NeuObj.count)) - code = textwrap.dedent(inspect.getsource(param_fun)).replace('\"', '\'') - self.json['Functions'][self.name] = { - 'code' : code, - 'name' : param_fun.__name__, + super().__init__("F" + paramfun_relation_name + str(NeuObj.count)) + code = textwrap.dedent(inspect.getsource(param_fun)).replace('"', "'") + self.json["Functions"][self.name] = { + "code": code, + "name": param_fun.__name__, } - self.json['Functions'][self.name]['params_and_consts'] = [] + self.json["Functions"][self.name]["params_and_consts"] = [] funinfo = inspect.getfullargspec(self.param_fun) @@ -86,7 +97,9 @@ def __init__(self, param_fun:Callable, if type(self.parameters_and_constants) is list: n_pc = len(self.parameters_and_constants) n_input = len(funinfo.args) - for pc, pc_name in zip(self.parameters_and_constants,funinfo.args[n_input-n_pc:]): + for pc, pc_name in zip( + self.parameters_and_constants, funinfo.args[n_input - n_pc :] + ): self.__create_parameter(pc, pc_name) # Create the parameters and constants from list @@ -99,13 +112,17 @@ def __init__(self, param_fun:Callable, self.__create_parameter(pc, key) elif first == True: p = Parameter(name=self.name + key, dimensions=1) - self.json['Functions'][self.name]['params_and_consts'].append(p.name) + self.json["Functions"][self.name]["params_and_consts"].append( + p.name + ) self.json = merge(self.json, p.json) self.json_stream = {} @enforce_types - def __call__(self, *obj:Union[Stream|Parameter|Constant|float|int]) -> Stream: + def __call__( + self, *obj: Union[Stream | Parameter | Constant | float | int] + ) -> Stream: stream_name = paramfun_relation_name + str(Stream.count) funinfo = inspect.getfullargspec(self.param_fun) @@ -121,78 +138,124 @@ def __call__(self, *obj:Union[Stream|Parameter|Constant|float|int]) -> Stream: else: obj_type = type(o) o = toStream(o) - check(type(o) is Stream, TypeError, - f"The type of {o} is {type(o)} and is not supported for ParamFun operation.") + check( + type(o) is Stream, + TypeError, + f"The type of {o} is {type(o)} and is not supported for ParamFun operation.", + ) input_types.append(obj_type) input_dimensions.append(o.dim) if n_call_input not in self.json_stream: if len(self.json_stream) > 0: - log.warning(f"The function {self.name} was called with a different number of inputs. If both functions enter in the model an error will be raised.") + log.warning( + f"The function {self.name} was called with a different number of inputs. If both functions enter in the model an error will be raised." + ) self.json_stream[n_call_input] = copy.deepcopy(self.json) - self.json_stream[n_call_input]['Functions'][self.name]['n_input'] = n_call_input + self.json_stream[n_call_input]["Functions"][self.name]["n_input"] = ( + n_call_input + ) # Create the missing parameters - n_created_parameters = len(self.json_stream[n_call_input]['Functions'][self.name]['params_and_consts']) + n_created_parameters = len( + self.json_stream[n_call_input]["Functions"][self.name][ + "params_and_consts" + ] + ) n_missing_parameters = n_parameters - n_created_parameters - check(n_missing_parameters >= 0, ValueError, f"The function is called with too many parameter and inputs.") - self.__create_missing_parameters(self.json_stream[n_call_input], n_call_input, n_missing_parameters) - - self.json_stream[n_call_input]['Functions'][self.name]['in_dim'] = copy.deepcopy(input_dimensions) - self.json_stream[n_call_input]['Functions'][self.name]['map_over_dim'] = self.__infer_map_over_batch(input_types, n_parameters) - output_dimension = self.__infer_output_dimensions(self.json_stream[n_call_input], input_types, input_dimensions) + check( + n_missing_parameters >= 0, + ValueError, + "The function is called with too many parameter and inputs.", + ) + self.__create_missing_parameters( + self.json_stream[n_call_input], n_call_input, n_missing_parameters + ) + + self.json_stream[n_call_input]["Functions"][self.name]["in_dim"] = ( + copy.deepcopy(input_dimensions) + ) + self.json_stream[n_call_input]["Functions"][self.name]["map_over_dim"] = ( + self.__infer_map_over_batch(input_types, n_parameters) + ) + output_dimension = self.__infer_output_dimensions( + self.json_stream[n_call_input], input_types, input_dimensions + ) else: map_over_batch = self.__infer_map_over_batch(input_types, n_parameters) - check(map_over_batch == self.json_stream[n_call_input]['Functions'][self.name]['map_over_dim'], ValueError, f"The function {self.name} was called with different type of input using map_over_batch=True.") - output_dimension = self.__infer_output_dimensions(self.json_stream[n_call_input], input_types, input_dimensions) + check( + map_over_batch + == self.json_stream[n_call_input]["Functions"][self.name][ + "map_over_dim" + ], + ValueError, + f"The function {self.name} was called with different type of input using map_over_batch=True.", + ) + output_dimension = self.__infer_output_dimensions( + self.json_stream[n_call_input], input_types, input_dimensions + ) # Save the all the input dimension used for call the parametric function - in_dim = self.json_stream[n_call_input]['Functions'][self.name]['in_dim'] + in_dim = self.json_stream[n_call_input]["Functions"][self.name]["in_dim"] if type(in_dim[0]) is dict: if in_dim != input_dimensions: in_dim = [in_dim, input_dimensions] - log.warning(f"The function {self.name} was called with inputs with different dimensions.") + log.warning( + f"The function {self.name} was called with inputs with different dimensions." + ) elif input_dimensions not in in_dim: in_dim.append(input_dimensions) - log.warning(f"The function {self.name} was called with inputs with different dimensions.") - self.json_stream[n_call_input]['Functions'][self.name]['in_dim'] = in_dim + log.warning( + f"The function {self.name} was called with inputs with different dimensions." + ) + self.json_stream[n_call_input]["Functions"][self.name]["in_dim"] = in_dim stream_json = copy.deepcopy(self.json_stream[n_call_input]) input_names = [] for ind, o in enumerate(obj): o = toStream(o) - check(type(o) is Stream, TypeError, - f"The type of {o} is {type(o)} and is not supported for ParamFun operation.") + check( + type(o) is Stream, + TypeError, + f"The type of {o} is {type(o)} and is not supported for ParamFun operation.", + ) stream_json = merge(stream_json, o.json) input_names.append(o.name) - stream_json['Relations'][stream_name] = [paramfun_relation_name, input_names, self.name] + stream_json["Relations"][stream_name] = [ + paramfun_relation_name, + input_names, + self.name, + ] return Stream(stream_name, stream_json, output_dimension) def __create_parameter(self, pc, pc_name): if type(pc) is Parameter: - self.json['Functions'][self.name]['params_and_consts'].append(pc.name) + self.json["Functions"][self.name]["params_and_consts"].append(pc.name) self.json = merge(self.json, pc.json) elif type(pc) is str: # TODO to remove! there is no reason to give a name to the parameter. The name of the parameter is the name of the function parameter p = Parameter(name=pc, dimensions=1) - self.json['Functions'][self.name]['params_and_consts'].append(p.name) + self.json["Functions"][self.name]["params_and_consts"].append(p.name) self.json = merge(self.json, p.json) elif type(pc) is tuple: p = Parameter(name=self.name + pc_name, dimensions=list(pc)) - self.json['Functions'][self.name]['params_and_consts'].append(p.name) + self.json["Functions"][self.name]["params_and_consts"].append(p.name) self.json = merge(self.json, p.json) elif type(pc) is Constant: - self.json['Functions'][self.name]['params_and_consts'].append(pc.name) + self.json["Functions"][self.name]["params_and_consts"].append(pc.name) self.json = merge(self.json, pc.json) elif type(pc) in (float, int, list): c = Constant(name=self.name + pc_name, values=pc) - self.json['Functions'][self.name]['params_and_consts'].append(c.name) + self.json["Functions"][self.name]["params_and_consts"].append(c.name) self.json = merge(self.json, c.json) else: - check(type(pc) in (Parameter, str, tuple, Constant, float, int, list), TypeError, - f'The element inside the \"parameters_and_constants\" list or dict must be a Parameter, str, tuple to build a Parameter or Constant, int, float or list to build a Constant but was {type(pc)}.') + check( + type(pc) in (Parameter, str, tuple, Constant, float, int, list), + TypeError, + f'The element inside the "parameters_and_constants" list or dict must be a Parameter, str, tuple to build a Parameter or Constant, int, float or list to build a Constant but was {type(pc)}.', + ) def __infer_map_over_batch(self, input_types, n_constants_and_params): input_map_dim = () @@ -211,21 +274,24 @@ def __infer_map_over_batch(self, input_types, n_constants_and_params): else: return False - def __create_missing_parameters(self, stream_json, n_call_input, n_missing_parameters): + def __create_missing_parameters( + self, stream_json, n_call_input, n_missing_parameters + ): funinfo = inspect.getfullargspec(self.param_fun) for i in range(n_missing_parameters): - p_name = self.name + funinfo.args[n_call_input+i] - stream_json['Functions'][self.name]['params_and_consts'].insert(i, p_name) - stream_json['Parameters'][p_name] = {'dim': 1} + p_name = self.name + funinfo.args[n_call_input + i] + stream_json["Functions"][self.name]["params_and_consts"].insert(i, p_name) + stream_json["Parameters"][p_name] = {"dim": 1} def __infer_output_dimensions(self, stream_json, input_types, input_dimensions): import torch + batch_dim = 5 all_inputs_dim = copy.deepcopy(input_dimensions) all_inputs_type = copy.deepcopy(input_types) - params_and_consts = stream_json['Constants'] | stream_json['Parameters'] - for name in stream_json['Functions'][self.name]['params_and_consts']: + params_and_consts = stream_json["Constants"] | stream_json["Parameters"] + for name in stream_json["Functions"][self.name]["params_and_consts"]: all_inputs_dim.append(params_and_consts[name]) all_inputs_type.append(Constant) @@ -233,7 +299,11 @@ def __infer_output_dimensions(self, stream_json, input_types, input_dimensions): is_int = False while is_int == False: n_samples_sec *= 10 - vect_input_time = [math.isclose(d['tw']*n_samples_sec,round(d['tw']*n_samples_sec)) for d in all_inputs_dim if 'tw' in d] + vect_input_time = [ + math.isclose(d["tw"] * n_samples_sec, round(d["tw"] * n_samples_sec)) + for d in all_inputs_dim + if "tw" in d + ] if len(vect_input_time) == 0: is_int = True else: @@ -244,67 +314,96 @@ def __infer_output_dimensions(self, stream_json, input_types, input_dimensions): inputs_win_type = [] inputs_win = [] - for t, dim in zip(all_inputs_type,all_inputs_dim): - window = 'tw' if 'tw' in dim else ('sw' if 'sw' in dim else None) - if window == 'tw': + for t, dim in zip(all_inputs_type, all_inputs_dim): + window = "tw" if "tw" in dim else ("sw" if "sw" in dim else None) + if window == "tw": dim_win = round(dim[window] * n_samples_sec) - elif window == 'sw': + elif window == "sw": dim_win = dim[window] else: dim_win = None if t in (Parameter, Constant) else 1 if t in (Parameter, Constant): - if type(dim['dim']) is list: + if type(dim["dim"]) is list: if dim_win is not None: - inputs.append(torch.rand(size=(dim_win,) + tuple(dim['dim']))) + inputs.append(torch.rand(size=(dim_win,) + tuple(dim["dim"]))) else: - inputs.append(torch.rand(size=tuple(dim['dim']))) + inputs.append(torch.rand(size=tuple(dim["dim"]))) else: if dim_win is not None: - inputs.append(torch.rand(size=(dim_win, dim['dim']))) + inputs.append(torch.rand(size=(dim_win, dim["dim"]))) else: - inputs.append(torch.rand(size=(dim['dim'],))) + inputs.append(torch.rand(size=(dim["dim"],))) else: - inputs.append(torch.rand(size=(batch_dim, dim_win, dim['dim']))) + inputs.append(torch.rand(size=(batch_dim, dim_win, dim["dim"]))) inputs_win_type.append(window) inputs_win.append(dim_win) if self.map_over_batch: - function_to_call = torch.func.vmap(self.param_fun,in_dims=tuple(stream_json['Functions'][self.name]['map_over_dim'])) + function_to_call = torch.func.vmap( + self.param_fun, + in_dims=tuple(stream_json["Functions"][self.name]["map_over_dim"]), + ) else: function_to_call = self.param_fun out = function_to_call(*inputs) out_shape = out.shape - check(out_shape[0] == batch_dim, ValueError, "The batch output dimension it is not correct.") + check( + out_shape[0] == batch_dim, + ValueError, + "The batch output dimension it is not correct.", + ) out_dim = list(out_shape[2:]) - check(len(out_dim) == 1, ValueError, "The output dimension of the function is bigger than a vector.") - out_win_type = 'sw' + check( + len(out_dim) == 1, + ValueError, + "The output dimension of the function is bigger than a vector.", + ) + out_win_type = "sw" out_win = out_shape[1] for idx, win in enumerate(inputs_win): - if out_shape[1] == win and all_inputs_type[idx] not in (Parameter, Constant): + if out_shape[1] == win and all_inputs_type[idx] not in ( + Parameter, + Constant, + ): out_win_type = inputs_win_type[idx] out_win = all_inputs_dim[idx][out_win_type] - return { 'dim': out_dim[0], out_win_type : out_win } + return {"dim": out_dim[0], out_win_type: out_win} -def return_standard_inputs(json, model_def, xlim = None, num_points = 1000): - check(json['n_input'] == 1 or json['n_input'] == 2, ValueError, "The function must have only one or two inputs.") + +def return_standard_inputs(json, model_def, xlim=None, num_points=1000): + check( + json["n_input"] == 1 or json["n_input"] == 2, + ValueError, + "The function must have only one or two inputs.", + ) fun_inputs = tuple() - for i in range(json['n_input']): - dim = json['in_dim'][i] - check(dim['dim'] == 1, ValueError, "The input dimension must be 1.") - if 'tw' in dim: - check(dim['tw'] == model_def['Info']['SampleTime'], ValueError, f"The input window must be 1 but was {dim['tw']}.") - elif 'sw' in dim: - check(dim['sw'] == 1, ValueError, "The input window must be 1.") + for i in range(json["n_input"]): + dim = json["in_dim"][i] + check(dim["dim"] == 1, ValueError, "The input dimension must be 1.") + if "tw" in dim: + check( + dim["tw"] == model_def["Info"]["SampleTime"], + ValueError, + f"The input window must be 1 but was {dim['tw']}.", + ) + elif "sw" in dim: + check(dim["sw"] == 1, ValueError, "The input window must be 1.") if xlim is not None: - if json['n_input'] == 2: - check(np.array(xlim).shape == (json['n_input'], 2), ValueError, - "The xlim must have the same shape as the number of inputs.") + if json["n_input"] == 2: + check( + np.array(xlim).shape == (json["n_input"], 2), + ValueError, + "The xlim must have the same shape as the number of inputs.", + ) x_value = np.linspace(xlim[i][0], xlim[i][1], num=num_points) else: - check(np.array(xlim).shape == (2,), ValueError, - "The xlim must have the same shape as the number of inputs.") + check( + np.array(xlim).shape == (2,), + ValueError, + "The xlim must have the same shape as the number of inputs.", + ) x_value = np.linspace(xlim[0], xlim[1], num=num_points) else: x_value = np.linspace(0, 1, num=num_points) @@ -313,34 +412,45 @@ def return_standard_inputs(json, model_def, xlim = None, num_points = 1000): else: x1_value = torch.from_numpy(x_value) - if json['n_input'] == 2: - x0_value, x1_value = torch.meshgrid(x0_value,x1_value,indexing="xy") + if json["n_input"] == 2: + x0_value, x1_value = torch.meshgrid(x0_value, x1_value, indexing="xy") x0_value = x0_value.flatten().unsqueeze(1).unsqueeze(1) x1_value = x1_value.flatten().unsqueeze(1).unsqueeze(1) - fun_inputs += (x0_value,x1_value,) + fun_inputs += ( + x0_value, + x1_value, + ) else: x0_value = x0_value.unsqueeze(1).unsqueeze(1) fun_inputs += (x0_value,) - for key in json['params_and_consts']: - val = model_def['Parameters'][key] if key in model_def['Parameters'] else model_def['Constants'][key] - fun_inputs += tuple([torch.from_numpy(np.array(val['values']))]) # The vector is transform in a tuple + for key in json["params_and_consts"]: + val = ( + model_def["Parameters"][key] + if key in model_def["Parameters"] + else model_def["Constants"][key] + ) + fun_inputs += tuple( + [torch.from_numpy(np.array(val["values"]))] + ) # The vector is transform in a tuple return fun_inputs + def return_function(json, fun_inputs): - exec(json['code'], globals()) - function_to_call = globals()[json['name']] + exec(json["code"], globals()) + function_to_call = globals()[json["name"]] output = function_to_call(*fun_inputs) check(output.shape[1] == 1, ValueError, "The output dimension must be 1.") check(output.shape[2] == 1, ValueError, "The output window must be 1.") funinfo = inspect.getfullargspec(function_to_call) return output, funinfo.args + class Parametric_Layer(nn.Module): def __init__(self, func, params_and_consts, map_over_batch): super().__init__() - self.name = func['name'] + self.name = func["name"] self.params_and_consts = params_and_consts if type(map_over_batch) is list: self.map_over_batch = True @@ -349,7 +459,7 @@ def __init__(self, func, params_and_consts, map_over_batch): self.map_over_batch = False ## Add the function to the globals try: - code = 'import torch\n@torch.fx.wrap\n' + func['code'] + code = "import torch\n@torch.fx.wrap\n" + func["code"] exec(code, globals()) except Exception as e: print(f"An error occurred: {e}") @@ -360,11 +470,19 @@ def forward(self, *inputs): function_to_call = globals()[self.name] # Call the function using the retrieved function object if self.map_over_batch: - function_to_call = torch.func.vmap(function_to_call,in_dims=self.input_map_dim) + function_to_call = torch.func.vmap( + function_to_call, in_dims=self.input_map_dim + ) result = function_to_call(*args) return result + def createParamFun(self, *func_params): - return Parametric_Layer(func=func_params[0], params_and_consts=func_params[1], map_over_batch=func_params[2]) + return Parametric_Layer( + func=func_params[0], + params_and_consts=func_params[1], + map_over_batch=func_params[2], + ) + setattr(Model, paramfun_relation_name, createParamFun) diff --git a/nnodely/layers/part.py b/src/nnodely/layers/part.py similarity index 55% rename from nnodely/layers/part.py rename to src/nnodely/layers/part.py index b86bd4cd..b9ee48c2 100644 --- a/nnodely/layers/part.py +++ b/src/nnodely/layers/part.py @@ -8,17 +8,16 @@ from nnodely.support.utils import check, enforce_types from nnodely.support.jsonutils import merge -part_relation_name = 'Part' -select_relation_name = 'Select' -concatenate_relation_name = 'Concatenate' +part_relation_name = "Part" +select_relation_name = "Select" +concatenate_relation_name = "Concatenate" -timepart_relation_name = 'TimePart' -timeselect_relation_name = 'TimeSelect' -timeconcatenate_relation_name = 'TimeConcatenate' - -samplepart_relation_name = 'SamplePart' -sampleselect_relation_name = 'SampleSelect' +timepart_relation_name = "TimePart" +timeselect_relation_name = "TimeSelect" +timeconcatenate_relation_name = "TimeConcatenate" +samplepart_relation_name = "SamplePart" +sampleselect_relation_name = "SampleSelect" class Part(Stream, ToStream): @@ -50,7 +49,7 @@ class Part(Stream, ToStream): Examples -------- - + .. include:: /examples_basics/layer_module_ex/part_module/part.rst Raises @@ -58,17 +57,26 @@ class Part(Stream, ToStream): IndexError If the indices i and j are out of range. """ + @enforce_types - def __init__(self, obj:Stream, i:int, j:int): + def __init__(self, obj: Stream, i: int, j: int): # check(type(obj) is Stream, TypeError, # f"The type of {obj} is {type(obj)} and is not supported for Part operation.") - check(i >= 0 and j > 0 and i < obj.dim['dim'] and j <= obj.dim['dim'], - IndexError, - f"i={i} or j={j} are not in the range [0,{obj.dim['dim']}]") + check( + i >= 0 and j > 0 and i < obj.dim["dim"] and j <= obj.dim["dim"], + IndexError, + f"i={i} or j={j} are not in the range [0,{obj.dim['dim']}]", + ) dim = copy.deepcopy(obj.dim) - dim['dim'] = j - i - super().__init__(part_relation_name + str(Stream.count),obj.json,dim) - self.json['Relations'][self.name] = [part_relation_name,[obj.name],obj.dim['dim'],[i,j]] + dim["dim"] = j - i + super().__init__(part_relation_name + str(Stream.count), obj.json, dim) + self.json["Relations"][self.name] = [ + part_relation_name, + [obj.name], + obj.dim["dim"], + [i, j], + ] + class Select(Stream, ToStream): """ @@ -97,67 +105,101 @@ class Select(Stream, ToStream): Examples -------- - + .. include:: /examples_basics/layer_module_ex/part_module/select.rst - + Raises ------ IndexError If the index i is out of range. """ + @enforce_types - def __init__(self, obj:Stream, i:int): + def __init__(self, obj: Stream, i: int): # check(type(obj) is Stream, TypeError, # f"The type of {obj} is {type(obj)} and is not supported for Select operation.") - check(i >= 0 and i < obj.dim['dim'], - IndexError, - f"i={i} are not in the range [0,{obj.dim['dim']}]") + check( + i >= 0 and i < obj.dim["dim"], + IndexError, + f"i={i} are not in the range [0,{obj.dim['dim']}]", + ) dim = copy.deepcopy(obj.dim) - dim['dim'] = 1 - super().__init__(select_relation_name + str(Stream.count),obj.json,dim) - self.json['Relations'][self.name] = [select_relation_name,[obj.name],obj.dim['dim'],i] + dim["dim"] = 1 + super().__init__(select_relation_name + str(Stream.count), obj.json, dim) + self.json["Relations"][self.name] = [ + select_relation_name, + [obj.name], + obj.dim["dim"], + i, + ] + class Concatenate(Stream, ToStream): """ - Implement the concatenate function between two tensors. + Implement the concatenate function between two tensors. - See also: - Official PyTorch Cat documentation: - `torch.cat `_ + See also: + Official PyTorch Cat documentation: + `torch.cat `_ - :param input1: the first relation to concatenate - :type obj: Tensor - :param input2: the second relation to concatenate - :type obj: Tensor + :param input1: the first relation to concatenate + :type obj: Tensor + :param input2: the second relation to concatenate + :type obj: Tensor - Examples - -------- - .. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/tonegas/nnodely/blob/main/examples/partitioning.ipynb - :alt: Open in Colab + Examples + -------- + .. image:: https://colab.research.google.com/assets/colab-badge.svg + :target: https://colab.research.google.com/github/tonegas/nnodely/blob/main/examples/partitioning.ipynb + :alt: Open in Colab - Example: - >>> cat = Concatenate(relation1, relation2) + Example: + >>> cat = Concatenate(relation1, relation2) """ + @enforce_types - def __init__(self, obj1:Stream, obj2:Stream) -> Stream: - obj1,obj2 = toStream(obj1),toStream(obj2) - check(type(obj1) is Stream,TypeError, - f"The type of {obj1} is {type(obj1)} and is not supported for the Concatenate operation.") - check(type(obj2) is Stream,TypeError, - f"The type of {obj2} is {type(obj2)} and is not supported for the Concatenate operation.") - #check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError, + def __init__(self, obj1: Stream, obj2: Stream) -> Stream: + obj1, obj2 = toStream(obj1), toStream(obj2) + check( + type(obj1) is Stream, + TypeError, + f"The type of {obj1} is {type(obj1)} and is not supported for the Concatenate operation.", + ) + check( + type(obj2) is Stream, + TypeError, + f"The type of {obj2} is {type(obj2)} and is not supported for the Concatenate operation.", + ) + # check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError, # f"For addition operators (+) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.") dim = copy.deepcopy(obj1.dim) - dim['dim'] = obj1.dim['dim']+obj2.dim['dim'] - if 'tw' in obj1.dim.keys() and 'tw' in obj2.dim.keys(): - check(obj1.dim['tw'] == obj2.dim['tw'], ValueError, 'The time window of the two inputs must be the same') - elif 'sw' in obj1.dim.keys() and 'sw' in obj2.dim.keys(): - check(obj1.dim['sw'] == obj2.dim['sw'], ValueError, 'The sample window of the two inputs must be the same') + dim["dim"] = obj1.dim["dim"] + obj2.dim["dim"] + if "tw" in obj1.dim.keys() and "tw" in obj2.dim.keys(): + check( + obj1.dim["tw"] == obj2.dim["tw"], + ValueError, + "The time window of the two inputs must be the same", + ) + elif "sw" in obj1.dim.keys() and "sw" in obj2.dim.keys(): + check( + obj1.dim["sw"] == obj2.dim["sw"], + ValueError, + "The sample window of the two inputs must be the same", + ) else: - raise(ValueError('The two inputs have different time or sample dimensions')) - super().__init__(concatenate_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [concatenate_relation_name,[obj1.name,obj2.name]] + raise ( + ValueError("The two inputs have different time or sample dimensions") + ) + super().__init__( + concatenate_relation_name + str(Stream.count), + merge(obj1.json, obj2.json), + dim, + ) + self.json["Relations"][self.name] = [ + concatenate_relation_name, + [obj1.name, obj2.name], + ] + class SamplePart(Stream, ToStream): """ @@ -190,7 +232,7 @@ class SamplePart(Stream, ToStream): Examples -------- - + .. include:: /examples_basics/layer_module_ex/part_module/sample_part.rst Raises @@ -202,34 +244,48 @@ class SamplePart(Stream, ToStream): IndexError If the offset is not within the sample window. """ + @enforce_types - def __init__(self, obj:Stream, i:int, j:int, offset:int|None = None): + def __init__(self, obj: Stream, i: int, j: int, offset: int | None = None): # check(type(obj) is Stream, TypeError, # f"The type of {obj} is {type(obj)} and is not supported for SamplePart operation.") - check('sw' in obj.dim, KeyError, 'Input must have a sample window') - check(i < j, ValueError, 'i must be smaller than j') - all_inputs = obj.json['Inputs'] + check("sw" in obj.dim, KeyError, "Input must have a sample window") + check(i < j, ValueError, "i must be smaller than j") + all_inputs = obj.json["Inputs"] if obj.name in all_inputs: - backward_idx = all_inputs[obj.name]['sw'][0] - forward_idx = all_inputs[obj.name]['sw'][1] + backward_idx = all_inputs[obj.name]["sw"][0] + forward_idx = all_inputs[obj.name]["sw"][1] else: backward_idx = 0 - forward_idx = obj.dim['sw'] - check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the sample window of the input') - check(j > backward_idx and j <= forward_idx, ValueError, 'j must be in the sample window of the input') + forward_idx = obj.dim["sw"] + check( + i >= backward_idx and i < forward_idx, + ValueError, + "i must be in the sample window of the input", + ) + check( + j > backward_idx and j <= forward_idx, + ValueError, + "j must be in the sample window of the input", + ) dim = copy.deepcopy(obj.dim) - dim['sw'] = j - i + dim["sw"] = j - i name = samplepart_relation_name + str(Stream.count) - super().__init__(name,obj.json,dim) + super().__init__(name, obj.json, dim) if obj.name in all_inputs: - rel = [samplepart_relation_name,[obj.name],-1,[i,j]] + rel = [samplepart_relation_name, [obj.name], -1, [i, j]] else: - rel = [samplepart_relation_name,[obj.name],obj.dim['sw'],[i,j]] - #rel = [samplepart_relation_name,[obj.name],[i,j]] + rel = [samplepart_relation_name, [obj.name], obj.dim["sw"], [i, j]] + # rel = [samplepart_relation_name,[obj.name],[i,j]] if offset is not None: - check(i <= offset < j, IndexError,"The offset must be inside the sample window") + check( + i <= offset < j, + IndexError, + "The offset must be inside the sample window", + ) rel.append(offset) - self.json['Relations'][self.name] = rel + self.json["Relations"][self.name] = rel + class SampleSelect(Stream, ToStream): """ @@ -258,9 +314,9 @@ class SampleSelect(Stream, ToStream): Examples -------- - + .. include:: /examples_basics/layer_module_ex/part_module/sample_select.rst - + Raises ------ IndexError @@ -270,18 +326,29 @@ class SampleSelect(Stream, ToStream): IndexError If the offset is not within the sample window. """ + @enforce_types - def __init__(self, obj:Stream, i:int): + def __init__(self, obj: Stream, i: int): # check(type(obj) is Stream, TypeError, # f"The type of {obj} is {type(obj)} and is not supported for SampleSelect operation.") - check('sw' in obj.dim, KeyError, 'Input must have a sample window') + check("sw" in obj.dim, KeyError, "Input must have a sample window") backward_idx = 0 - forward_idx = obj.dim['sw'] - check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the sample window of the input') + forward_idx = obj.dim["sw"] + check( + i >= backward_idx and i < forward_idx, + ValueError, + "i must be in the sample window of the input", + ) dim = copy.deepcopy(obj.dim) - dim['sw'] = 1 - super().__init__(sampleselect_relation_name + str(Stream.count),obj.json,dim) - self.json['Relations'][self.name] = [sampleselect_relation_name,[obj.name],obj.dim['sw'],i] + dim["sw"] = 1 + super().__init__(sampleselect_relation_name + str(Stream.count), obj.json, dim) + self.json["Relations"][self.name] = [ + sampleselect_relation_name, + [obj.name], + obj.dim["sw"], + i, + ] + class TimePart(Stream, ToStream): """ @@ -309,7 +376,7 @@ class TimePart(Stream, ToStream): Examples -------- - + .. include:: /examples_basics/layer_module_ex/part_module/time_part.rst Raises @@ -321,79 +388,113 @@ class TimePart(Stream, ToStream): IndexError If the offset is not within the time window. """ + @enforce_types - def __init__(self, obj:Stream, i:int|float, j:int|float, offset:int|float|None = None): - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for TimePart operation.") - check('tw' in obj.dim, KeyError, 'Input must have a time window') - check(i < j, ValueError, 'i must be smaller than j') - all_inputs = obj.json['Inputs'] + def __init__( + self, + obj: Stream, + i: int | float, + j: int | float, + offset: int | float | None = None, + ): + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for TimePart operation.", + ) + check("tw" in obj.dim, KeyError, "Input must have a time window") + check(i < j, ValueError, "i must be smaller than j") + all_inputs = obj.json["Inputs"] if obj.name in all_inputs: - backward_idx = all_inputs[obj.name]['tw'][0] - forward_idx = all_inputs[obj.name]['tw'][1] + backward_idx = all_inputs[obj.name]["tw"][0] + forward_idx = all_inputs[obj.name]["tw"][1] else: backward_idx = 0 - forward_idx = obj.dim['tw'] - check(i >= backward_idx and i < forward_idx, ValueError, 'i must be in the time window of the input') - check(j > backward_idx and j <= forward_idx, ValueError, 'j must be in the time window of the input') + forward_idx = obj.dim["tw"] + check( + i >= backward_idx and i < forward_idx, + ValueError, + "i must be in the time window of the input", + ) + check( + j > backward_idx and j <= forward_idx, + ValueError, + "j must be in the time window of the input", + ) dim = copy.deepcopy(obj.dim) - dim['tw'] = j - i - super().__init__(timepart_relation_name + str(Stream.count),obj.json,dim) + dim["tw"] = j - i + super().__init__(timepart_relation_name + str(Stream.count), obj.json, dim) if obj.name in all_inputs: - rel = [timepart_relation_name,[obj.name],-1,[i,j]] + rel = [timepart_relation_name, [obj.name], -1, [i, j]] else: - rel = [timepart_relation_name,[obj.name],obj.dim['tw'],[i,j]] - #rel = [timepart_relation_name,[obj.name],[i,j]] + rel = [timepart_relation_name, [obj.name], obj.dim["tw"], [i, j]] + # rel = [timepart_relation_name,[obj.name],[i,j]] if offset is not None: - check(i <= offset < j, IndexError,"The offset must be inside the time window") + check( + i <= offset < j, IndexError, "The offset must be inside the time window" + ) rel.append(offset) - self.json['Relations'][self.name] = rel + self.json["Relations"][self.name] = rel + class TimeConcatenate(Stream, ToStream): """ - Implement the concatenate function between two tensors along the time dimension (second dimension). + Implement the concatenate function between two tensors along the time dimension (second dimension). - See also: - Official PyTorch Cat documentation: - `torch.cat `_ + See also: + Official PyTorch Cat documentation: + `torch.cat `_ - :param input1: the first relation to concatenate - :type obj: Tensor - :param input2: the second relation to concatenate - :type obj: Tensor + :param input1: the first relation to concatenate + :type obj: Tensor + :param input2: the second relation to concatenate + :type obj: Tensor - Examples - -------- - .. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/tonegas/nnodely/blob/main/examples/partitioning.ipynb - :alt: Open in Colab + Examples + -------- + .. image:: https://colab.research.google.com/assets/colab-badge.svg + :target: https://colab.research.google.com/github/tonegas/nnodely/blob/main/examples/partitioning.ipynb + :alt: Open in Colab - Example: - >>> cat = TimeConcatenate(relation1, relation2) + Example: + >>> cat = TimeConcatenate(relation1, relation2) """ + @enforce_types - def __init__(self, obj1:Stream, obj2:Stream) -> Stream: - obj1,obj2 = toStream(obj1),toStream(obj2) - check(type(obj1) is Stream,TypeError, - f"The type of {obj1} is {type(obj1)} and is not supported for the Concatenate operation.") - check(type(obj2) is Stream,TypeError, - f"The type of {obj2} is {type(obj2)} and is not supported for the Concatenate operation.") - - #check('tw' in obj1.dim, KeyError, 'Input1 must have a time window') - #check('tw' in obj2.dim, KeyError, 'Input2 must have a time window') + def __init__(self, obj1: Stream, obj2: Stream) -> Stream: + obj1, obj2 = toStream(obj1), toStream(obj2) + check( + type(obj1) is Stream, + TypeError, + f"The type of {obj1} is {type(obj1)} and is not supported for the Concatenate operation.", + ) + check( + type(obj2) is Stream, + TypeError, + f"The type of {obj2} is {type(obj2)} and is not supported for the Concatenate operation.", + ) + + # check('tw' in obj1.dim, KeyError, 'Input1 must have a time window') + # check('tw' in obj2.dim, KeyError, 'Input2 must have a time window') dim = copy.deepcopy(obj1.dim) - if 'tw' in obj1.dim and 'tw' in obj2.dim: - dim['tw'] = obj1.dim['tw'] + obj2.dim['tw'] - elif 'sw' in obj1.dim and 'sw' in obj2.dim: - dim['sw'] = obj1.dim['sw'] + obj2.dim['sw'] - super().__init__(timeconcatenate_relation_name + str(Stream.count),merge(obj1.json,obj2.json),dim) - self.json['Relations'][self.name] = [timeconcatenate_relation_name,[obj1.name,obj2.name]] - + if "tw" in obj1.dim and "tw" in obj2.dim: + dim["tw"] = obj1.dim["tw"] + obj2.dim["tw"] + elif "sw" in obj1.dim and "sw" in obj2.dim: + dim["sw"] = obj1.dim["sw"] + obj2.dim["sw"] + super().__init__( + timeconcatenate_relation_name + str(Stream.count), + merge(obj1.json, obj2.json), + dim, + ) + self.json["Relations"][self.name] = [ + timeconcatenate_relation_name, + [obj1.name, obj2.name], + ] class Part_Layer(nn.Module): #: :noindex: - def __init__(self, dim:int, i:int, j:int): + def __init__(self, dim: int, i: int, j: int): super(Part_Layer, self).__init__() self.i, self.j = i, j @@ -404,12 +505,14 @@ def __init__(self, dim:int, i:int, j:int): def forward(self, x): ## assert x.ndim >= 3, 'The Part Relation Works only for 3D inputs' - return torch.einsum('bij,kj->bik', x, self.W) + return torch.einsum("bij,kj->bik", x, self.W) + ## Select elements on the third dimension in the range [i,j] def createPart(self, *inputs): return Part_Layer(dim=inputs[0], i=inputs[1][0], j=inputs[1][1]) + class Select_Layer(nn.Module): #: :noindex: def __init__(self, dim, idx): @@ -419,12 +522,14 @@ def __init__(self, dim, idx): def forward(self, x): ## assert x.ndim >= 3, 'The Part Relation Works only for 3D inputs' - return torch.einsum('ijk,k->ij', x, self.W).unsqueeze(2) + return torch.einsum("ijk,k->ij", x, self.W).unsqueeze(2) + ## Select an element i on the third dimension def createSelect(self, *inputs): return Select_Layer(dim=inputs[0], idx=inputs[1]) + class SamplePart_Layer(nn.Module): #: :noindex: def __init__(self, dim, part, offset): @@ -440,9 +545,10 @@ def __init__(self, dim, part, offset): def forward(self, x): if self.offset is not None: x = x - x[:, self.offset].unsqueeze(1) - result = torch.einsum('bij,ki->bkj', x, self.W) + result = torch.einsum("bij,ki->bkj", x, self.W) return result + class Concatenate_Layer(nn.Module): #: :noindex: def __init__(self): @@ -451,16 +557,19 @@ def __init__(self): def forward(self, *inputs): return torch.cat((inputs[0], inputs[1]), dim=2) + def createConcatenate(name, *inputs): #: :noindex: return Concatenate_Layer() + def createSamplePart(self, *inputs): if len(inputs) > 2: ## offset return SamplePart_Layer(dim=inputs[0], part=inputs[1], offset=inputs[2]) else: return SamplePart_Layer(dim=inputs[0], part=inputs[1], offset=None) + class SampleSelect_Layer(nn.Module): #: :noindex: def __init__(self, dim, idx): @@ -469,11 +578,13 @@ def __init__(self, dim, idx): self.W[idx] = 1 def forward(self, x): - return torch.einsum('ijk,j->ik', x, self.W).unsqueeze(1) + return torch.einsum("ijk,j->ik", x, self.W).unsqueeze(1) + def createSampleSelect(self, *inputs): return SampleSelect_Layer(dim=inputs[0], idx=inputs[1]) + class TimePart_Layer(nn.Module): #: :noindex: def __init__(self, dim, part, offset): @@ -489,15 +600,17 @@ def __init__(self, dim, part, offset): def forward(self, x): if self.offset is not None: x = x - x[:, self.offset].unsqueeze(1) - result = torch.einsum('bij,ki->bkj', x, self.W) + result = torch.einsum("bij,ki->bkj", x, self.W) return result + def createTimePart(self, *inputs): - if len(inputs) > 2: ## offset + if len(inputs) > 2: ## offset return TimePart_Layer(dim=inputs[0], part=inputs[1], offset=inputs[2]) else: return TimePart_Layer(dim=inputs[0], part=inputs[1], offset=None) + class TimeConcatenate_Layer(nn.Module): #: :noindex: def __init__(self): @@ -506,10 +619,12 @@ def __init__(self): def forward(self, *inputs): return torch.cat((inputs[0], inputs[1]), dim=1) + def createTimeConcatenate(name, *inputs): #: :noindex: return TimeConcatenate_Layer() + setattr(Model, part_relation_name, createPart) setattr(Model, select_relation_name, createSelect) setattr(Model, concatenate_relation_name, createConcatenate) diff --git a/nnodely/layers/rungekutta.py b/src/nnodely/layers/rungekutta.py similarity index 74% rename from nnodely/layers/rungekutta.py rename to src/nnodely/layers/rungekutta.py index 35255cfc..bc1281b4 100644 --- a/nnodely/layers/rungekutta.py +++ b/src/nnodely/layers/rungekutta.py @@ -1,19 +1,13 @@ -import torch.nn as nn -import torch - from nnodely.layers.parametricfunction import ParamFun from nnodely.layers.parameter import SampleTime -from nnodely.basic.relation import Stream, NeuObj, ToStream -from nnodely.support.utils import enforce_types, check -from nnodely.support.jsonutils import merge, subjson_from_relation -from nnodely.basic.model import Model -import textwrap, inspect +from nnodely.basic.relation import Stream, NeuObj +from nnodely.support.utils import enforce_types from collections.abc import Callable -fe_relation_name = 'ForwardEuler' -rk2_relation_name = 'RK2' -rk4_relation_name = 'RK4' +fe_relation_name = "ForwardEuler" +rk2_relation_name = "RK2" +rk4_relation_name = "RK4" # class ForwardEuler(NeuObj): # """ @@ -30,6 +24,7 @@ # 'name' : f.__name__, # } + # @enforce_types # def __call__(self, obj:Stream) -> Stream: # stream_name = fe_relation_name + str(Stream.count) @@ -42,55 +37,62 @@ class ForwardEuler(NeuObj): """ This operation perform Forward Euler Integration on a Stream """ + @enforce_types - def __init__(self, f:Callable|ParamFun) -> Stream: - super().__init__('F' + fe_relation_name + str(NeuObj.count)) + def __init__(self, f: Callable | ParamFun) -> Stream: + super().__init__("F" + fe_relation_name + str(NeuObj.count)) self.f = f if isinstance(f, ParamFun) else ParamFun(f) self.dt = SampleTime() + @enforce_types - def __call__(self, obj:Stream) -> Stream: + def __call__(self, obj: Stream) -> Stream: return obj + self.dt * self.f(obj) + class RK2(NeuObj): """ This operation perform RK2 Integration on a Stream """ + @enforce_types - def __init__(self, f:Callable|ParamFun) -> Stream: + def __init__(self, f: Callable | ParamFun) -> Stream: super().__init__(rk2_relation_name + str(NeuObj.count)) self.f = f if isinstance(f, ParamFun) else ParamFun(f) - #self.fe = ForwardEuler(self.f) + # self.fe = ForwardEuler(self.f) self.dt = SampleTime() @enforce_types - def __call__(self, obj:Stream) -> Stream: + def __call__(self, obj: Stream) -> Stream: f1 = self.f(obj) - f2 = self.f(obj + (self.dt/2) * f1) + f2 = self.f(obj + (self.dt / 2) * f1) return obj + self.dt * f2 + class RK4(NeuObj): """ This operation perform RK4 Integration on a Stream """ + @enforce_types - def __init__(self, f:Callable|ParamFun) -> Stream: + def __init__(self, f: Callable | ParamFun) -> Stream: super().__init__(rk4_relation_name + str(NeuObj.count)) self.f = f if isinstance(f, ParamFun) else ParamFun(f) self.dt = SampleTime() @enforce_types - def __call__(self, obj:Stream, t:Stream|None = None) -> Stream: - if t: ## Partial differential equation + def __call__(self, obj: Stream, t: Stream | None = None) -> Stream: + if t: ## Partial differential equation f1 = self.f(obj, t) - f2 = self.f(obj + (self.dt/2) * f1, t + (self.dt/2)) - f3 = self.f(obj + (self.dt/2) * f2, t + (self.dt/2)) + f2 = self.f(obj + (self.dt / 2) * f1, t + (self.dt / 2)) + f3 = self.f(obj + (self.dt / 2) * f2, t + (self.dt / 2)) f4 = self.f(obj + self.dt * f3, t + self.dt) - else: ## Ordinary differential equation + else: ## Ordinary differential equation f1 = self.f(obj) - f2 = self.f(obj + (self.dt/2) * f1) - f3 = self.f(obj + (self.dt/2) * f2) + f2 = self.f(obj + (self.dt / 2) * f1) + f3 = self.f(obj + (self.dt / 2) * f2) f4 = self.f(obj + self.dt * f3) - return obj + (self.dt/6) * (f1 + 2*f2 + 2*f3 + f4) + return obj + (self.dt / 6) * (f1 + 2 * f2 + 2 * f3 + f4) + # class ForwardEuler_Layer(nn.Module): # #: :noindex: @@ -108,7 +110,7 @@ def __call__(self, obj:Stream, t:Stream|None = None) -> Stream: # func = globals()[self.name] # print(f'ForwardEuler executing function name {self.name} which is {func}') # return x + self.dt * func(x) - + # def createForwardEuler(name, *inputs): # #: :noindex: # return ForwardEuler_Layer(inputs[0]) diff --git a/nnodely/layers/timeoperation.py b/src/nnodely/layers/timeoperation.py similarity index 53% rename from nnodely/layers/timeoperation.py rename to src/nnodely/layers/timeoperation.py index d85172db..ac985f43 100644 --- a/nnodely/layers/timeoperation.py +++ b/src/nnodely/layers/timeoperation.py @@ -7,14 +7,12 @@ from nnodely.basic.model import Model from nnodely.support.fixstepsolver import Euler, Trapezoidal -SOLVERS = { - 'euler': Euler, - 'trapezoidal': Trapezoidal -} +SOLVERS = {"euler": Euler, "trapezoidal": Trapezoidal} # Binary operators -int_relation_name = 'Integrate' -der_relation_name = 'Differentiate' +int_relation_name = "Integrate" +der_relation_name = "Differentiate" + class Integrate(Stream, ToStream): """ @@ -24,18 +22,28 @@ class Integrate(Stream, ToStream): ---------- method : is the integration method """ + @enforce_types - def __init__(self, output:Stream, *, - int_name:str|None = None, der_name:str|None = None, method:str = 'euler') -> Stream: + def __init__( + self, + output: Stream, + *, + int_name: str | None = None, + der_name: str | None = None, + method: str = "euler", + ) -> Stream: if int_name is None: int_name = output.name + "_int" + str(NeuObj.count) if der_name is None: der_name = output.name + "_der" + str(NeuObj.count) - check(method in SOLVERS, ValueError, f"The method '{method}' is not supported yet") - solver = SOLVERS[method](int_name,der_name) + check( + method in SOLVERS, ValueError, f"The method '{method}' is not supported yet" + ) + solver = SOLVERS[method](int_name, der_name) output_int = solver.integrate(output) super().__init__(output_int.name, output_int.json, output_int.dim) + class Differentiate(Stream, ToStream): """ This operation Differentiate a Stream with respect to time or another Stream @@ -44,25 +52,44 @@ class Differentiate(Stream, ToStream): ---------- method : is the derivative method """ + @enforce_types - def __init__(self, output:Stream, input:Stream = None, *, - int_name:str|None = None, der_name:str|None = None, method:str = 'euler') -> Stream: + def __init__( + self, + output: Stream, + input: Stream = None, + *, + int_name: str | None = None, + der_name: str | None = None, + method: str = "euler", + ) -> Stream: if input is None: if int_name is None: int_name = output.name + "_int" + str(NeuObj.count) if der_name is None: der_name = output.name + "_der" + str(NeuObj.count) - check(method in SOLVERS, ValueError, f"The method '{method}' is not supported yet") - solver = SOLVERS[method](int_name,der_name) + check( + method in SOLVERS, + ValueError, + f"The method '{method}' is not supported yet", + ) + solver = SOLVERS[method](int_name, der_name) output_der = solver.derivate(output) super().__init__(output_der.name, output_der.json, output_der.dim) else: - super().__init__(der_relation_name + str(Stream.count), merge(output.json,input.json), input.dim) - self.json['Relations'][self.name] = [der_relation_name, [output.name, input.name]] + super().__init__( + der_relation_name + str(Stream.count), + merge(output.json, input.json), + input.dim, + ) + self.json["Relations"][self.name] = [ + der_relation_name, + [output.name, input.name], + ] subjson = subjson_from_relation(self.json, input.name) - grad_inputs = subjson['Inputs'].keys() + grad_inputs = subjson["Inputs"].keys() for i in grad_inputs: - self.json['Inputs'][i]['type'] = 'derivate' + self.json["Inputs"][i]["type"] = "derivate" class Differentiate_Layer(nn.Module): @@ -71,10 +98,19 @@ def __init__(self): super(Differentiate_Layer, self).__init__() def forward(self, *inputs): - return torch.autograd.grad(inputs[0], inputs[1], grad_outputs=torch.ones_like(inputs[0]), create_graph=True, retain_graph=True, allow_unused=False)[0] + return torch.autograd.grad( + inputs[0], + inputs[1], + grad_outputs=torch.ones_like(inputs[0]), + create_graph=True, + retain_graph=True, + allow_unused=False, + )[0] + def createAdd(name, *inputs): #: :noindex: return Differentiate_Layer() + setattr(Model, der_relation_name, createAdd) diff --git a/nnodely/layers/trigonometric.py b/src/nnodely/layers/trigonometric.py similarity index 54% rename from nnodely/layers/trigonometric.py rename to src/nnodely/layers/trigonometric.py index 932cabad..9ebba516 100644 --- a/nnodely/layers/trigonometric.py +++ b/src/nnodely/layers/trigonometric.py @@ -6,19 +6,20 @@ from nnodely.support.utils import check, enforce_types from nnodely.layers.parameter import Parameter, Constant -sin_relation_name = 'Sin' -cos_relation_name = 'Cos' -tan_relation_name = 'Tan' -tanh_relation_name = 'Tanh' -cosh_relation_name = 'Cosh' -sech_relation_name = 'Sech' +sin_relation_name = "Sin" +cos_relation_name = "Cos" +tan_relation_name = "Tan" +tanh_relation_name = "Tanh" +cosh_relation_name = "Cosh" +sech_relation_name = "Sech" + class Sin(Stream, ToStream): """ Implement the sine function given an input relation. See also: - Official PyTorch Sin documentation: + Official PyTorch Sin documentation: `torch.sin `_ :param obj: the input relation stream @@ -28,20 +29,25 @@ class Sin(Stream, ToStream): -------- .. include:: /examples_basics/layer_module_ex/trig_module_ex/sin.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|int|float) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | int | float) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Sin operation.") - super().__init__(sin_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [sin_relation_name, [obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Sin operation.", + ) + super().__init__(sin_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [sin_relation_name, [obj.name]] + class Cos(Stream, ToStream): """ Implement the cosine function given an input relation. See also: - Official PyTorch Cos documentation: + Official PyTorch Cos documentation: `torch.cos `_ :param obj: the input relation stream @@ -51,20 +57,25 @@ class Cos(Stream, ToStream): -------- .. include:: /examples_basics/layer_module_ex/trig_module_ex/cos.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|int|float) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | int | float) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Cos operation.") - super().__init__(cos_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [cos_relation_name, [obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Cos operation.", + ) + super().__init__(cos_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [cos_relation_name, [obj.name]] + class Tan(Stream, ToStream): """ Implement the tangent function given an input relation. See also: - Official PyTorch Tan documentation: + Official PyTorch Tan documentation: `torch.tan `_ :param obj: the input relation stream @@ -74,20 +85,25 @@ class Tan(Stream, ToStream): -------- .. include:: /examples_basics/layer_module_ex/trig_module_ex/tan.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|int|float) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | int | float) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Tan operation.") - super().__init__(tan_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [tan_relation_name, [obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Tan operation.", + ) + super().__init__(tan_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [tan_relation_name, [obj.name]] + class Cosh(Stream, ToStream): """ Returns a new tensor with the hyperbolic cosine of the elements of input. See also: - Official PyTorch Cosh documentation: + Official PyTorch Cosh documentation: `torch.cosh `_ :param obj: the input relation stream @@ -97,12 +113,17 @@ class Cosh(Stream, ToStream): -------- .. include:: /examples_basics/layer_module_ex/trig_module_ex/cosh.rst """ - def __init__(self, obj:Stream) -> Stream: + + def __init__(self, obj: Stream) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Cosh operation.") - super().__init__(cosh_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [cosh_relation_name, [obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Cosh operation.", + ) + super().__init__(cosh_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [cosh_relation_name, [obj.name]] + class Sech(Stream, ToStream): """ @@ -115,99 +136,140 @@ class Sech(Stream, ToStream): -------- .. include:: /examples_basics/layer_module_ex/trig_module_ex/sech.rst """ - def __init__(self, obj:Stream) -> Stream: + + def __init__(self, obj: Stream) -> Stream: obj = toStream(obj) - check(type(obj) is Stream, TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Sech operation.") - super().__init__(sech_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [sech_relation_name, [obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Sech operation.", + ) + super().__init__(sech_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [sech_relation_name, [obj.name]] + class Tanh(Stream, ToStream): """ - Implement the Hyperbolic Tangent (Tanh) relation function. + Implement the Hyperbolic Tangent (Tanh) relation function. - See also: - Official PyTorch tanh documentation: - `torch.nn.Tanh `_ + See also: + Official PyTorch tanh documentation: + `torch.nn.Tanh `_ - :param obj: The relation stream. - :type obj: Stream + :param obj: The relation stream. + :type obj: Stream - Example: - -------- - .. include:: /examples_basics/layer_module_ex/trig_module_ex/tanh.rst + Example: + -------- + .. include:: /examples_basics/layer_module_ex/trig_module_ex/tanh.rst """ + @enforce_types - def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream: + def __init__(self, obj: Stream | Parameter | Constant | float | int) -> Stream: obj = toStream(obj) - check(type(obj) is Stream,TypeError, - f"The type of {obj} is {type(obj)} and is not supported for Tanh operation.") - super().__init__(tanh_relation_name + str(Stream.count),obj.json,obj.dim) - self.json['Relations'][self.name] = [tanh_relation_name,[obj.name]] + check( + type(obj) is Stream, + TypeError, + f"The type of {obj} is {type(obj)} and is not supported for Tanh operation.", + ) + super().__init__(tanh_relation_name + str(Stream.count), obj.json, obj.dim) + self.json["Relations"][self.name] = [tanh_relation_name, [obj.name]] + class Sin_Layer(nn.Module): - def __init__(self,): + def __init__( + self, + ): super(Sin_Layer, self).__init__() + def forward(self, x): return torch.sin(x) + def createSin(self, *inputs): return Sin_Layer() + class Cos_Layer(nn.Module): - def __init__(self,): + def __init__( + self, + ): super(Cos_Layer, self).__init__() + def forward(self, x): return torch.cos(x) + def createCos(self, *inputs): return Cos_Layer() + class Tan_Layer(nn.Module): - def __init__(self,): + def __init__( + self, + ): super(Tan_Layer, self).__init__() + def forward(self, x): return torch.tan(x) + def createTan(self, *inputs): return Tan_Layer() + class Cosh_Layer(nn.Module): - def __init__(self,): + def __init__( + self, + ): super(Cosh_Layer, self).__init__() + def forward(self, x): return torch.cosh(x) + def createCosh(self, *inputs): return Cosh_Layer() + class Tanh_Layer(nn.Module): """ - :noindex: + :noindex: """ - def __init__(self,): + + def __init__( + self, + ): super(Tanh_Layer, self).__init__() + def forward(self, x): return torch.tanh(x) + def createTanh(self, *input): """ - :noindex: + :noindex: """ return Tanh_Layer() + class Sech_Layer(nn.Module): - def __init__(self,): + def __init__( + self, + ): super(Sech_Layer, self).__init__() + def forward(self, x): - return 1/torch.cosh(x) + return 1 / torch.cosh(x) + def createSech(self, *inputs): return Sech_Layer() + setattr(Model, sin_relation_name, createSin) setattr(Model, cos_relation_name, createCos) setattr(Model, tan_relation_name, createTan) setattr(Model, cosh_relation_name, createCosh) setattr(Model, tanh_relation_name, createTanh) -setattr(Model, sech_relation_name, createSech) \ No newline at end of file +setattr(Model, sech_relation_name, createSech) diff --git a/nnodely/nnodely.py b/src/nnodely/nnodely.py similarity index 67% rename from nnodely/nnodely.py rename to src/nnodely/nnodely.py index 083f2e4c..417089e7 100644 --- a/nnodely/nnodely.py +++ b/src/nnodely/nnodely.py @@ -1,5 +1,7 @@ # Extern packages -import random, torch, copy +import random +import torch +import copy import numpy as np # Main operators @@ -16,13 +18,15 @@ from nnodely.support.utils import ReadOnlyDict, ParamDict, enforce_types, check from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.INFO) @enforce_types -def clearNames(names:str|list|None = None): +def clearNames(names: str | list | None = None): NeuObj.clearNames(names) + class Modely(Composer, Trainer, Loader, Validator, Exporter): """ Create the main object, the nnodely object, that will be used to create the network, train and export it. @@ -46,21 +50,25 @@ class Modely(Composer, Trainer, Loader, Validator, Exporter): ------- >>> model = Modely() """ + @enforce_types - def __init__(self, *, - visualizer:str|EmptyVisualizer|None = 'Standard', - exporter:str|EmptyExporter|None = 'Standard', - seed:int|None = None, - workspace:str|None = None, - log_internal:bool = False, - save_history:bool = False): + def __init__( + self, + *, + visualizer: str | EmptyVisualizer | None = "Standard", + exporter: str | EmptyExporter | None = "Standard", + seed: int | None = None, + workspace: str | None = None, + log_internal: bool = False, + save_history: bool = False, + ): ## Set the random seed for reproducibility if seed is not None: self.resetSeed(seed) # Visualizer - if visualizer == 'Standard': + if visualizer == "Standard": self.visualizer = TextVisualizer(1) elif visualizer != None: self.visualizer = visualizer @@ -87,7 +95,9 @@ def neuralized(self): @neuralized.setter def neuralized(self, value): - raise AttributeError("Cannot modify read-only property 'neuralized' use neuralizeModel() instead.") + raise AttributeError( + "Cannot modify read-only property 'neuralized' use neuralizeModel() instead." + ) @property def traced(self): @@ -100,24 +110,31 @@ def traced(self, value): @property def parameters(self): if self._neuralized: - return ParamDict(self._model_def['Parameters'], self._model.all_parameters) + return ParamDict(self._model_def["Parameters"], self._model.all_parameters) else: - return ParamDict(self._model_def['Parameters']) + return ParamDict(self._model_def["Parameters"]) @property def constants(self): - return ReadOnlyDict({key:value.detach().numpy().tolist() for key,value in self._model.all_constants}) + return ReadOnlyDict( + { + key: value.detach().numpy().tolist() + for key, value in self._model.all_constants + } + ) @property def states(self): - return {key:value.detach().numpy().tolist() for key,value in self._states.items()} + return { + key: value.detach().numpy().tolist() for key, value in self._states.items() + } @property def json(self): return copy.deepcopy(self._model_def._ModelDef__json) @enforce_types - def resetSeed(self, seed:int) -> None: + def resetSeed(self, seed: int) -> None: """ Resets the random seed for reproducibility. @@ -135,7 +152,13 @@ def resetSeed(self, seed:int) -> None: random.seed(seed) ## set the random module seed np.random.seed(seed) ## set the numpy seed - def trainAndAnalyze(self, *, test_dataset: str | list | dict | None = None, test_batch_size: int = 128, **kwargs): + def trainAndAnalyze( + self, + *, + test_dataset: str | list | dict | None = None, + test_batch_size: int = 128, + **kwargs, + ): """ Trains the model using the provided datasets and parameters. After training, it analyzes the results on the training, validation, and test datasets. @@ -212,38 +235,83 @@ def trainAndAnalyze(self, *, test_dataset: str | list | dict | None = None, test self.trainModel(**kwargs) params = self.running_parameters - minimize_gain = params['minimize_gain'] - closed_loop, connect, prediction_samples = params['closed_loop'], params['connect'], params['prediction_samples'] - - if kwargs.get('train_dataset', None) is None: - check(test_dataset is None, ValueError, 'If train_dataset is None, test_dataset must also be None.') + minimize_gain = params["minimize_gain"] + closed_loop, connect, prediction_samples = ( + params["closed_loop"], + params["connect"], + params["prediction_samples"], + ) + + if kwargs.get("train_dataset", None) is None: + check( + test_dataset is None, + ValueError, + "If train_dataset is None, test_dataset must also be None.", + ) else: - params['test_tag'] = self._get_tag(test_dataset) - params['XY_test'] = self._get_data(test_dataset) - params['n_samples_test'] = next(iter(params['XY_test'].values())).size(0) if params['XY_test'] else 0 - params['test_indexes'] = self._get_batch_indexes(test_dataset, params['n_samples_test'], prediction_samples) + params["test_tag"] = self._get_tag(test_dataset) + params["XY_test"] = self._get_data(test_dataset) + params["n_samples_test"] = ( + next(iter(params["XY_test"].values())).size(0) + if params["XY_test"] + else 0 + ) + params["test_indexes"] = self._get_batch_indexes( + test_dataset, params["n_samples_test"], prediction_samples + ) ## Training set Results - self._analyze(params['XY_train'], dataset_tag=params['train_tag'], indexes=params['train_indexes'], minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=params['train_step'], batch_size=params['train_batch_size']) - + self._analyze( + params["XY_train"], + dataset_tag=params["train_tag"], + indexes=params["train_indexes"], + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=params["train_step"], + batch_size=params["train_batch_size"], + ) + ## Validation set Results - if params['n_samples_val'] > 0: - self._analyze(params['XY_val'], dataset_tag=params['val_tag'], indexes=params['val_indexes'], minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=params['val_step'], batch_size=params['val_batch_size']) + if params["n_samples_val"] > 0: + self._analyze( + params["XY_val"], + dataset_tag=params["val_tag"], + indexes=params["val_indexes"], + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=params["val_step"], + batch_size=params["val_batch_size"], + ) else: - log.warning("Validation dataset is empty. Skipping validation results analysis.") + log.warning( + "Validation dataset is empty. Skipping validation results analysis." + ) ## Test set Results - if params['n_samples_test'] > 0: - params['test_batch_size'] = self._clip_batch_size(len(params['test_indexes']), test_batch_size) - params['test_step'] = self._clip_step(params['step'], params['test_indexes'], params['test_batch_size']) - self._analyze(params['XY_test'], dataset_tag=params['test_tag'], indexes=params['test_indexes'], minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=params['test_step'], batch_size=test_batch_size) + if params["n_samples_test"] > 0: + params["test_batch_size"] = self._clip_batch_size( + len(params["test_indexes"]), test_batch_size + ) + params["test_step"] = self._clip_step( + params["step"], params["test_indexes"], params["test_batch_size"] + ) + self._analyze( + params["XY_test"], + dataset_tag=params["test_tag"], + indexes=params["test_indexes"], + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=params["test_step"], + batch_size=test_batch_size, + ) else: log.warning("Test dataset is empty. Skipping test results analysis.") -nnodely = Modely \ No newline at end of file + +nnodely = Modely diff --git a/nnodely/operators/__init__.py b/src/nnodely/operators/__init__.py similarity index 100% rename from nnodely/operators/__init__.py rename to src/nnodely/operators/__init__.py diff --git a/nnodely/operators/composer.py b/src/nnodely/operators/composer.py similarity index 58% rename from nnodely/operators/composer.py rename to src/nnodely/operators/composer.py index 563777f6..b8d1e61c 100644 --- a/nnodely/operators/composer.py +++ b/src/nnodely/operators/composer.py @@ -1,4 +1,5 @@ -import copy, torch +import copy +import torch import numpy as np @@ -6,29 +7,44 @@ from nnodely.basic.modeldef import ModelDef from nnodely.basic.model import Model -from nnodely.support.utils import check, TORCH_DTYPE, NP_DTYPE, enforce_types, tensor_to_list +from nnodely.support.utils import ( + check, + TORCH_DTYPE, + NP_DTYPE, + enforce_types, + tensor_to_list, +) from nnodely.support.mathutils import argmax_dict, argmin_dict from nnodely.basic.relation import Stream from nnodely.layers.input import Input from nnodely.layers.output import Output from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) + class Composer(Network): @enforce_types def __init__(self): - check(type(self) is not Composer, TypeError, "Composer class cannot be instantiated directly") + check( + type(self) is not Composer, + TypeError, + "Composer class cannot be instantiated directly", + ) super().__init__() def __addInfo(self) -> None: - total_params = sum(p.numel() for p in self._model.parameters() if p.requires_grad) - self._model_def['Info']['num_parameters'] = total_params + total_params = sum( + p.numel() for p in self._model.parameters() if p.requires_grad + ) + self._model_def["Info"]["num_parameters"] = total_params from nnodely import __version__ - self._model_def['Info']['nnodely_version'] = __version__ + + self._model_def["Info"]["nnodely_version"] = __version__ @enforce_types - def addModel(self, name:str, stream_list:list|Output) -> None: + def addModel(self, name: str, stream_list: list | Output) -> None: """ Adds a new model with the given name along with a list of Outputs. @@ -47,7 +63,7 @@ def addModel(self, name:str, stream_list:list|Output) -> None: self._neuralized = False @enforce_types - def removeModel(self, name_list:list|str) -> None: + def removeModel(self, name_list: list | str) -> None: """ Removes models with the given list of names. @@ -64,7 +80,13 @@ def removeModel(self, name_list:list|str) -> None: self._neuralized = False @enforce_types - def addConnect(self, stream_out:str|Output|Stream, input_in:str|Input, *, local:bool=False) -> None: + def addConnect( + self, + stream_out: str | Output | Stream, + input_in: str | Input, + *, + local: bool = False, + ) -> None: """ Adds a connection from a relation stream to an input. @@ -80,11 +102,17 @@ def addConnect(self, stream_out:str|Output|Stream, input_in:str|Input, *, local: .. include:: /examples_basics/compser_module_ex/addConnect.rst """ - self._model_def.addConnection(stream_out, input_in,'connect', local) + self._model_def.addConnection(stream_out, input_in, "connect", local) self._neuralized = False @enforce_types - def addClosedLoop(self, stream_out:str|Output|Stream, input_in:str|Input, *, local:bool=False) -> None: + def addClosedLoop( + self, + stream_out: str | Output | Stream, + input_in: str | Input, + *, + local: bool = False, + ) -> None: """ Adds a closed loop connection from a relation stream to an input. @@ -100,11 +128,11 @@ def addClosedLoop(self, stream_out:str|Output|Stream, input_in:str|Input, *, loc .. include:: /examples_basics/compser_module_ex/addClosedLoop.rst """ - self._model_def.addConnection(stream_out, input_in,'closedLoop', local) + self._model_def.addConnection(stream_out, input_in, "closedLoop", local) self._neuralized = False @enforce_types - def removeConnection(self, input_in:str|Input) -> None: + def removeConnection(self, input_in: str | Input) -> None: """ Remove a closed loop or connect connection from an input. @@ -126,7 +154,13 @@ def removeConnection(self, input_in:str|Input) -> None: self._neuralized = False @enforce_types - def neuralizeModel(self, sample_time:float|int|None = None, *, clear_model:bool = False, model_def:dict|None = None) -> None: + def neuralizeModel( + self, + sample_time: float | int | None = None, + *, + clear_model: bool = False, + model_def: dict | None = None, + ) -> None: """ Neuralizes the model, preparing it for inference and training. This method creates a neural network model starting from the model definition. It will also create all the time windows and correct slicing for all the inputs defined. @@ -151,29 +185,45 @@ def neuralizeModel(self, sample_time:float|int|None = None, *, clear_model:bool .. include:: /examples_basics/compser_module_ex/neuralizeModel.rst """ if model_def is not None: - check(sample_time == None, ValueError, 'The sample_time must be None if a model_def is provided') - check(clear_model == False, ValueError, 'The clear_model must be False if a model_def is provided') + check( + sample_time == None, + ValueError, + "The sample_time must be None if a model_def is provided", + ) + check( + clear_model == False, + ValueError, + "The clear_model must be False if a model_def is provided", + ) self._model_def = ModelDef(model_def) else: - self._model_def.updateParameters(model = None, clear_model = clear_model) + self._model_def.updateParameters(model=None, clear_model=clear_model) self._model_def.setBuildWindow(sample_time) self._model = Model(self._model_def.getJson()) self.__addInfo() - self._input_ns_backward = {key:value['ns'][0] for key, value in self._model_def['Inputs'].items()} - self._input_ns_forward = {key:value['ns'][1] for key, value in self._model_def['Inputs'].items()} + self._input_ns_backward = { + key: value["ns"][0] for key, value in self._model_def["Inputs"].items() + } + self._input_ns_forward = { + key: value["ns"][1] for key, value in self._model_def["Inputs"].items() + } self._max_samples_backward = max(self._input_ns_backward.values()) self._max_samples_forward = max(self._input_ns_forward.values()) self._input_n_samples = {} - for key, value in self._model_def['Inputs'].items(): + for key, value in self._model_def["Inputs"].items(): if self._input_ns_forward[key] >= 0: - if 'closedLoop' in value: + if "closedLoop" in value: log.warning(f"Closed loop on {key} with sample in the future.") - if 'connect' in value: + if "connect" in value: log.warning(f"Connect on {key} with sample in the future.") - self._input_n_samples[key] = self._input_ns_backward[key] + self._input_ns_forward[key] - self._max_n_samples = max(self._input_ns_backward.values()) + max(self._input_ns_forward.values()) + self._input_n_samples[key] = ( + self._input_ns_backward[key] + self._input_ns_forward[key] + ) + self._max_n_samples = max(self._input_ns_backward.values()) + max( + self._input_ns_forward.values() + ) ## Initialize States self.resetStates() @@ -186,7 +236,17 @@ def neuralizeModel(self, sample_time:float|int|None = None, *, clear_model:bool self.visualizer.showBuiltModel() @enforce_types - def __call__(self, inputs:dict={}, *, sampled:bool=False, closed_loop:dict={}, connect:dict={}, prediction_samples:str|int='auto', num_of_samples:int|None=None, log_internal:bool=False) -> dict: + def __call__( + self, + inputs: dict = {}, + *, + sampled: bool = False, + closed_loop: dict = {}, + connect: dict = {}, + prediction_samples: str | int = "auto", + num_of_samples: int | None = None, + log_internal: bool = False, + ) -> dict: """ Performs inference on the model. @@ -219,99 +279,149 @@ def __call__(self, inputs:dict={}, *, sampled:bool=False, closed_loop:dict={}, c Examples -------- - + .. include:: /examples_basics/inference_module_ex/inference.rst """ ## Copy dict for avoid python bug inputs = copy.deepcopy(inputs) - all_closed_loop = copy.deepcopy(closed_loop) #| self._model_def._input_closed_loop - all_connect = copy.deepcopy(connect) #| self._model_def._input_connect + all_closed_loop = copy.deepcopy( + closed_loop + ) # | self._model_def._input_closed_loop + all_connect = copy.deepcopy(connect) # | self._model_def._input_connect ## Check neuralize check(self.neuralized, RuntimeError, "The network is not neuralized.") ## Check closed loop integrity - prediction_samples = self._setup_recurrent_variables(prediction_samples, all_closed_loop, all_connect) + prediction_samples = self._setup_recurrent_variables( + prediction_samples, all_closed_loop, all_connect + ) ## List of keys - model_inputs = list(self._model_def['Inputs'].keys()) - json_inputs = self._model_def['Inputs'] + model_inputs = list(self._model_def["Inputs"].keys()) + json_inputs = self._model_def["Inputs"] extra_inputs = list(set(list(inputs.keys())) - set(model_inputs)) - non_mandatory_inputs = list(all_closed_loop.keys()) + list(all_connect.keys()) + list(self._model_def.recurrentInputs().keys()) + non_mandatory_inputs = ( + list(all_closed_loop.keys()) + + list(all_connect.keys()) + + list(self._model_def.recurrentInputs().keys()) + ) mandatory_inputs = list(set(model_inputs) - set(non_mandatory_inputs)) ## Remove extra inputs for key in extra_inputs: log.warning( - f'The provided input {key} is not used inside the network. the inference will continue without using it') + f"The provided input {key} is not used inside the network. the inference will continue without using it" + ) del inputs[key] ## Get the number of data windows for each input - num_of_windows = {key: len(value) for key, value in inputs.items()} if sampled else { - key: len(value) - self._input_n_samples[key] + 1 for key, value in inputs.items()} + num_of_windows = ( + {key: len(value) for key, value in inputs.items()} + if sampled + else { + key: len(value) - self._input_n_samples[key] + 1 + for key, value in inputs.items() + } + ) if num_of_samples is not None and sampled == True: - log.warning(f'num_of_samples is ignored if sampled is equal to True') + log.warning("num_of_samples is ignored if sampled is equal to True") ## Get the maximum inference window if num_of_samples and not sampled: window_dim = num_of_samples for key in inputs.keys(): - input_dim = self._model_def['Inputs'][key]['dim'] - new_samples = num_of_samples - (len(inputs[key]) - self._input_n_samples[key] + 1) + input_dim = self._model_def["Inputs"][key]["dim"] + new_samples = num_of_samples - ( + len(inputs[key]) - self._input_n_samples[key] + 1 + ) if input_dim > 1: - log.warning(f'The variable {key} is filled with {new_samples} samples equal to zeros.') - inputs[key] += [[0 for _ in range(input_dim)] for _ in range(new_samples)] + log.warning( + f"The variable {key} is filled with {new_samples} samples equal to zeros." + ) + inputs[key] += [ + [0 for _ in range(input_dim)] for _ in range(new_samples) + ] else: - log.warning(f'The variable {key} is filled with {new_samples} samples equal to zeros.') + log.warning( + f"The variable {key} is filled with {new_samples} samples equal to zeros." + ) inputs[key] += [0 for _ in range(new_samples)] elif inputs: windows = [] for key in inputs.keys(): if key in mandatory_inputs: - n_samples = len(inputs[key]) if sampled else len(inputs[key]) - self._model_def['Inputs'][key]['ntot'] + 1 + n_samples = ( + len(inputs[key]) + if sampled + else len(inputs[key]) + - self._model_def["Inputs"][key]["ntot"] + + 1 + ) windows.append(n_samples) if not windows: for key in inputs.keys(): if key in non_mandatory_inputs: if key in model_inputs: - n_samples = len(inputs[key]) if sampled else len(inputs[key]) - self._model_def['Inputs'][key]['ntot'] + 1 + n_samples = ( + len(inputs[key]) + if sampled + else len(inputs[key]) + - self._model_def["Inputs"][key]["ntot"] + + 1 + ) windows.append(n_samples) window_dim = min(windows) if windows else 0 else: ## No inputs window_dim = 1 if non_mandatory_inputs else 0 - check(window_dim > 0, StopIteration, f'Missing samples in the input window') + check(window_dim > 0, StopIteration, "Missing samples in the input window") if len(set(num_of_windows.values())) > 1: max_ind_key, max_dim = argmax_dict(num_of_windows) min_ind_key, min_dim = argmin_dict(num_of_windows) log.warning( - f'Different number of samples between inputs [MAX {num_of_windows[max_ind_key]} = {max_dim}; MIN {num_of_windows[min_ind_key]} = {min_dim}]') + f"Different number of samples between inputs [MAX {num_of_windows[max_ind_key]} = {max_dim}; MIN {num_of_windows[min_ind_key]} = {min_dim}]" + ) ## Autofill the missing inputs provided_inputs = list(inputs.keys()) missing_inputs = list(set(mandatory_inputs) - set(provided_inputs)) if missing_inputs: - log.warning(f'Inputs not provided: {missing_inputs}. Autofilling with zeros..') + log.warning( + f"Inputs not provided: {missing_inputs}. Autofilling with zeros.." + ) for key in missing_inputs: inputs[key] = np.zeros( - shape=(self._input_n_samples[key] + window_dim - 1, self._model_def['Inputs'][key]['dim']), - dtype=NP_DTYPE).tolist() + shape=( + self._input_n_samples[key] + window_dim - 1, + self._model_def["Inputs"][key]["dim"], + ), + dtype=NP_DTYPE, + ).tolist() ## Transform inputs in 3D Tensors for key in inputs.keys(): - input_dim = json_inputs[key]['dim'] + input_dim = json_inputs[key]["dim"] inputs[key] = torch.from_numpy(np.array(inputs[key])).to(TORCH_DTYPE) if input_dim > 1: correct_dim = 3 if sampled else 2 - check(len(inputs[key].shape) == correct_dim, ValueError, - f'The input {key} must have {correct_dim} dimensions') - check(inputs[key].shape[correct_dim - 1] == input_dim, ValueError, - f'The second dimension of the input "{key}" must be equal to {input_dim}') - - if input_dim == 1 and inputs[key].shape[-1] != 1: ## add the input dimension + check( + len(inputs[key].shape) == correct_dim, + ValueError, + f"The input {key} must have {correct_dim} dimensions", + ) + check( + inputs[key].shape[correct_dim - 1] == input_dim, + ValueError, + f'The second dimension of the input "{key}" must be equal to {input_dim}', + ) + + if ( + input_dim == 1 and inputs[key].shape[-1] != 1 + ): ## add the input dimension inputs[key] = inputs[key].unsqueeze(-1) if inputs[key].ndim <= 1: ## add the batch dimension inputs[key] = inputs[key].unsqueeze(0) @@ -320,15 +430,24 @@ def __call__(self, inputs:dict={}, *, sampled:bool=False, closed_loop:dict={}, c ## initialize the resulting dictionary result_dict = {} - for key in self._model_def['Outputs'].keys(): + for key in self._model_def["Outputs"].keys(): result_dict[key] = [] if log_internal: - internals_dict = {'ingress': [], 'state': [], 'closedLoop': [], 'connect': []} + internals_dict = { + "ingress": [], + "state": [], + "closedLoop": [], + "connect": [], + } ## Inference - with (torch.enable_grad() if self._get_gradient_on_inference() else torch.inference_mode()): + with ( + torch.enable_grad() + if self._get_gradient_on_inference() + else torch.inference_mode() + ): ## Update with virtual states - if prediction_samples == 'auto' or prediction_samples >= 0: + if prediction_samples == "auto" or prediction_samples >= 0: self._model.update(closed_loop=all_closed_loop, connect=all_connect) else: self._model.update(disconnect=True) @@ -339,21 +458,31 @@ def __call__(self, inputs:dict={}, *, sampled:bool=False, closed_loop:dict={}, c for idx in range(window_dim): ## Get mandatory data inputs for key in mandatory_inputs: - X[key] = inputs[key][idx:idx + 1] if sampled else inputs[key][:,idx:idx + self._input_n_samples[key]] - if 'type' in json_inputs[key].keys(): + X[key] = ( + inputs[key][idx : idx + 1] + if sampled + else inputs[key][:, idx : idx + self._input_n_samples[key]] + ) + if "type" in json_inputs[key].keys(): X[key] = X[key].requires_grad_(True) ## reset states - if count == 0 or prediction_samples == 'auto': + if count == 0 or prediction_samples == "auto": count = prediction_samples for key in non_mandatory_inputs: ## Get non mandatory data (from inputs, from states, or with zeros) ## If it is given as input AND ## if prediction_samples is 'auto' and there are enough samples OR ## if prediction_samples is NOT 'auto' if key in inputs.keys() and ( - (prediction_samples == 'auto' and idx < num_of_windows[key]) or \ - (prediction_samples != 'auto') + (prediction_samples == "auto" and idx < num_of_windows[key]) + or (prediction_samples != "auto") ): - X[key] = inputs[key][idx:idx + 1] if sampled else inputs[key][:,idx:idx + self._input_n_samples[key]] + X[key] = ( + inputs[key][idx : idx + 1] + if sampled + else inputs[key][ + :, idx : idx + self._input_n_samples[key] + ] + ) # if 0 in X[key].shape: # window_size = self._input_n_samples[key] # dim = json_inputs[key]['dim'] @@ -362,47 +491,51 @@ def __call__(self, inputs:dict={}, *, sampled:bool=False, closed_loop:dict={}, c ## if prediction_samples = 'auto' and there are not enough samples OR ## it is the first iteration with prediction_samples = None elif key in self._states.keys() and ( - prediction_samples == 'auto' or - (first and prediction_samples == None) + prediction_samples == "auto" + or (first and prediction_samples == None) ): X[key] = self._states[key] else: - ## if there are no samples + ## if there are no samples window_size = self._input_n_samples[key] - dim = json_inputs[key]['dim'] - X[key] = torch.zeros(size=(1, window_size, dim), dtype=TORCH_DTYPE, requires_grad=False) - - if 'type' in json_inputs[key].keys(): + dim = json_inputs[key]["dim"] + X[key] = torch.zeros( + size=(1, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=False, + ) + + if "type" in json_inputs[key].keys(): X[key] = X[key].requires_grad_(True) first = False else: # Remove the gradient of the previous forward for key in X.keys(): - if 'type' in json_inputs[key].keys(): + if "type" in json_inputs[key].keys(): X[key] = X[key].detach().requires_grad_(True) count -= 1 ## Forward pass result, _, out_closed_loop, out_connect = self._model(X) if log_internal: - internals_dict['ingress'].append(tensor_to_list(X)) - internals_dict['closedLoop'].append(out_closed_loop) - internals_dict['connect'].append(out_connect) + internals_dict["ingress"].append(tensor_to_list(X)) + internals_dict["closedLoop"].append(out_closed_loop) + internals_dict["connect"].append(out_connect) ## Append the prediction of the current sample to the result dictionary - for key in self._model_def['Outputs'].keys(): + for key in self._model_def["Outputs"].keys(): if result[key].shape[-1] == 1: result[key] = result[key].squeeze(-1) if result[key].shape[-1] == 1: result[key] = result[key].squeeze(-1) - result_dict[key].append(result[key].detach().squeeze(dim=0).tolist()) + result_dict[key].append( + result[key].detach().squeeze(dim=0).tolist() + ) ## Update closed_loop and connect if prediction_samples: self._update_state(X, out_closed_loop, out_connect) - + ## Remove virtual states self._remove_virtual_states(connect, closed_loop) return result_dict if not log_internal else (result_dict, internals_dict) - - diff --git a/nnodely/operators/exporter.py b/src/nnodely/operators/exporter.py similarity index 69% rename from nnodely/operators/exporter.py rename to src/nnodely/operators/exporter.py index 79cbed3e..7baaebb5 100644 --- a/nnodely/operators/exporter.py +++ b/src/nnodely/operators/exporter.py @@ -9,13 +9,25 @@ class Exporter(Network): @enforce_types - def __init__(self, exporter:EmptyExporter|str|None=None, workspace:str|None=None, *, save_history:bool=False): - check(type(self) is not Exporter, TypeError, "Exporter class cannot be instantiated directly") + def __init__( + self, + exporter: EmptyExporter | str | None = None, + workspace: str | None = None, + *, + save_history: bool = False, + ): + check( + type(self) is not Exporter, + TypeError, + "Exporter class cannot be instantiated directly", + ) super().__init__() # Exporter - if exporter == 'Standard': - self.__exporter = StandardExporter(workspace, self.visualizer, save_history=save_history) + if exporter == "Standard": + self.__exporter = StandardExporter( + workspace, self.visualizer, save_history=save_history + ) elif exporter != None: self.__exporter = exporter else: @@ -26,7 +38,13 @@ def getWorkspace(self) -> str: return self.__exporter.getWorkspace() @enforce_types - def saveTorchModel(self, name:str='net', model_folder:str|None=None, *, models:str|None=None) -> None: + def saveTorchModel( + self, + name: str = "net", + model_folder: str | None = None, + *, + models: str | None = None, + ) -> None: """ Saves the neural network model in PyTorch format. @@ -49,15 +67,21 @@ def saveTorchModel(self, name:str='net', model_folder:str|None=None, *, models:s .. include:: /examples_basics/export_module_ex/saveTorchModel.rst """ - check(self._model_def.isDefined(), RuntimeError, "The network has not been defined.") - check(self._neuralized == True, RuntimeError, 'The model is not neuralized yet!') + check( + self._model_def.isDefined(), + RuntimeError, + "The network has not been defined.", + ) + check( + self._neuralized == True, RuntimeError, "The model is not neuralized yet!" + ) if models is not None: if type(models) is str: models = [models] - if name == 'net': - name += '_' + '_'.join(models) + if name == "net": + name += "_" + "_".join(models) model_def = ModelDef(self._model_def.getJson(models)) - model_def.setBuildWindow(self._model_def['Info']['SampleTime']) + model_def.setBuildWindow(self._model_def["Info"]["SampleTime"]) model_def.updateParameters(self._model) model = Model(model_def.getJson()) else: @@ -65,7 +89,9 @@ def saveTorchModel(self, name:str='net', model_folder:str|None=None, *, models:s self.__exporter.saveTorchModel(model, name, model_folder) @enforce_types - def loadTorchModel(self, name:str='net', model_folder:str|None=None) -> None: + def loadTorchModel( + self, name: str = "net", model_folder: str | None = None + ) -> None: """ Loads a neural network model from a PyTorch format file. @@ -86,11 +112,17 @@ def loadTorchModel(self, name:str='net', model_folder:str|None=None) -> None: .. include:: /examples_basics/export_module_ex/loadTorchModel.rst """ - check(self.neuralized == True, RuntimeError, 'The model is not neuralized yet.') + check(self.neuralized == True, RuntimeError, "The model is not neuralized yet.") self.__exporter.loadTorchModel(self._model, name, model_folder) @enforce_types - def saveModel(self, name:str='net', model_folder:str|None=None, *, models:str|list|None=None) -> None: + def saveModel( + self, + name: str = "net", + model_folder: str | None = None, + *, + models: str | list | None = None, + ) -> None: """ Saves the neural network model definition in a json file. @@ -113,21 +145,25 @@ def saveModel(self, name:str='net', model_folder:str|None=None, *, models:str|li .. include:: /examples_basics/export_module_ex/saveModel.rst """ - check(self._model_def.isDefined(), RuntimeError, "The network has not been defined.") + check( + self._model_def.isDefined(), + RuntimeError, + "The network has not been defined.", + ) if models is not None: if type(models) is str: models = [models] - if name == 'net': - name += '_' + '_'.join(models) + if name == "net": + name += "_" + "_".join(models) model_def = ModelDef(self._model_def.getJson(models)) - model_def.setBuildWindow(self._model_def['Info']['SampleTime']) + model_def.setBuildWindow(self._model_def["Info"]["SampleTime"]) model_def.updateParameters(self._model) else: model_def = self._model_def self.__exporter.saveModel(model_def.getJson(), name, model_folder) @enforce_types - def loadModel(self, name:str='net', model_folder:str|None=None) -> None: + def loadModel(self, name: str = "net", model_folder: str | None = None) -> None: """ Loads a neural network model from a json file containing the model definition. @@ -150,17 +186,19 @@ def loadModel(self, name:str='net', model_folder:str|None=None) -> None: """ model_def = self.__exporter.loadModel(name, model_folder) check(model_def, RuntimeError, "Error to load the network.") - new_tags = (list(model_def['Inputs'].keys()) + - list(model_def['Functions'].keys()) + - list(model_def['Relations'].keys()) + - list(model_def['Parameters'].keys())+ - list(model_def['Constants'].keys())) + new_tags = ( + list(model_def["Inputs"].keys()) + + list(model_def["Functions"].keys()) + + list(model_def["Relations"].keys()) + + list(model_def["Parameters"].keys()) + + list(model_def["Constants"].keys()) + ) ## TODO: setting the Stream.count is not enough, we need a global tag manager # old_tags = list(self._model_def['Functions'].keys()) + list(self._model_def['Relations'].keys()) + list(self._model_def['Parameters'].keys()) if self._model_def is not None else [] # check that there are no common tags # common_tags = set(new_tags).intersection(set(old_tags)) # check(len(common_tags) == 0, RuntimeError, f"The model contains some tags that are already present in the current model: {common_tags}.\n Please rename them before loading the model.") - #check(Stream.count == 0, RuntimeError, "There are some defined Stream, loadModel can be called only at the beginning, when the neural graph is empty.") + # check(Stream.count == 0, RuntimeError, "There are some defined Stream, loadModel can be called only at the beginning, when the neural graph is empty.") Stream.count = Stream.count + len(new_tags) + 1 NeuObj.count = NeuObj.count + len(new_tags) + 1 self._model_def = ModelDef(model_def) @@ -169,7 +207,13 @@ def loadModel(self, name:str='net', model_folder:str|None=None) -> None: self._traced = False @enforce_types - def exportPythonModel(self, name:str='net', model_folder:str|None=None, *, models:str|None=None) -> None: + def exportPythonModel( + self, + name: str = "net", + model_folder: str | None = None, + *, + models: str | None = None, + ) -> None: """ Exports the neural network model as a standalone PyTorch Module class. @@ -194,20 +238,31 @@ def exportPythonModel(self, name:str='net', model_folder:str|None=None, *, model .. include:: /examples_basics/export_module_ex/exportPythonModel.rst """ - check(self._model_def.isDefined(), RuntimeError, "The network has not been defined.") - check(self._traced == False, RuntimeError, - 'The model is traced and cannot be exported to Python.\n Run neuralizeModel() to recreate a standard model.') + check( + self._model_def.isDefined(), + RuntimeError, + "The network has not been defined.", + ) + check( + self._traced == False, + RuntimeError, + "The model is traced and cannot be exported to Python.\n Run neuralizeModel() to recreate a standard model.", + ) if models is not None: if type(models) is str: models = [models] - if name == 'net': - name += '_' + '_'.join(models) + if name == "net": + name += "_" + "_".join(models) model_def = ModelDef(self._model_def.getJson(models)) - model_def.setBuildWindow(self._model_def['Info']['SampleTime']) + model_def.setBuildWindow(self._model_def["Info"]["SampleTime"]) model_def.updateParameters(self._model) model = Model(model_def.getJson()) else: - check(self._neuralized == True, RuntimeError, 'The model is not neuralized yet.') + check( + self._neuralized == True, + RuntimeError, + "The model is not neuralized yet.", + ) model_def = self._model_def model = self._model model.update() @@ -215,7 +270,9 @@ def exportPythonModel(self, name:str='net', model_folder:str|None=None, *, model self.__exporter.exportPythonModel(model_def, model, name, model_folder) @enforce_types - def importPythonModel(self, name:str='net', model_folder:str|None=None) -> None: + def importPythonModel( + self, name: str = "net", model_folder: str | None = None + ) -> None: """ Imports a neural network model from a standalone PyTorch Module class. @@ -244,7 +301,15 @@ def importPythonModel(self, name:str='net', model_folder:str|None=None) -> None: self._model_def.updateParameters(self._model) @enforce_types - def exportONNX(self, inputs_order:list|None=None, outputs_order:list|None=None, name:str='net', model_folder:str|None=None, *, models:str|list|None=None) -> None: + def exportONNX( + self, + inputs_order: list | None = None, + outputs_order: list | None = None, + name: str = "net", + model_folder: str | None = None, + *, + models: str | list | None = None, + ) -> None: """ Exports the neural network model to an ONNX file. @@ -277,32 +342,52 @@ def exportONNX(self, inputs_order:list|None=None, outputs_order:list|None=None, .. include:: /examples_basics/export_module_ex/exportONNX.rst """ - check(self._model_def.isDefined(), RuntimeError, "The network has not been defined.") - check(self._traced == False, RuntimeError, - 'The model is traced and cannot be exported to ONNX.\n Run neuralizeModel() to recreate a standard model.') - check(self._neuralized == True, RuntimeError, 'The model is not neuralized yet.') + check( + self._model_def.isDefined(), + RuntimeError, + "The network has not been defined.", + ) + check( + self._traced == False, + RuntimeError, + "The model is traced and cannot be exported to ONNX.\n Run neuralizeModel() to recreate a standard model.", + ) + check( + self._neuralized == True, RuntimeError, "The model is not neuralized yet." + ) # From here -------------- if models is not None: if type(models) is str: models = [models] - if name == 'net': - name += '_' + '_'.join(models) + if name == "net": + name += "_" + "_".join(models) model_def = ModelDef(self._model_def.getJson(models)) - check(len(model_def.recurrentInputs().keys()) < len(model_def['Inputs'].keys()), TypeError, - "The network has only recurrent inputs.") - model_def.setBuildWindow(self._model_def['Info']['SampleTime']) + check( + len(model_def.recurrentInputs().keys()) + < len(model_def["Inputs"].keys()), + TypeError, + "The network has only recurrent inputs.", + ) + model_def.setBuildWindow(self._model_def["Info"]["SampleTime"]) model_def.updateParameters(self._model) model = Model(model_def.getJson()) else: model_def = self._model_def model = self._model model.update() - check(len(model_def.recurrentInputs().keys()) < len(model_def['Inputs'].keys()), TypeError, - "The network is autonomous because only recurrent variables are present.") - self.__exporter.exportONNX(model_def, model, inputs_order, outputs_order, name, model_folder) + check( + len(model_def.recurrentInputs().keys()) < len(model_def["Inputs"].keys()), + TypeError, + "The network is autonomous because only recurrent variables are present.", + ) + self.__exporter.exportONNX( + model_def, model, inputs_order, outputs_order, name, model_folder + ) @enforce_types - def onnxInference(self, inputs:dict, name:str='net', model_folder:str|None=None) -> dict: + def onnxInference( + self, inputs: dict, name: str = "net", model_folder: str | None = None + ) -> dict: """ Run an inference session using an onnx model previously exported using the nnodely framework. @@ -328,13 +413,13 @@ def onnxInference(self, inputs:dict, name:str='net', model_folder:str|None=None) Examples -------- - + .. include:: /examples_basics/export_module_ex/onnxInference.rst """ return self.__exporter.onnxInference(inputs, name, model_folder) @enforce_types - def exportReport(self, name:str='net', model_folder:str|None=None) -> None: + def exportReport(self, name: str = "net", model_folder: str | None = None) -> None: """ Generates a PDF report with plots containing the results of the training and validation of the neural network. diff --git a/nnodely/operators/loader.py b/src/nnodely/operators/loader.py similarity index 67% rename from nnodely/operators/loader.py rename to src/nnodely/operators/loader.py index 8b2d0960..6b56278a 100644 --- a/nnodely/operators/loader.py +++ b/src/nnodely/operators/loader.py @@ -1,4 +1,5 @@ -import os, random +import os +import random import pandas as pd import numpy as np @@ -10,12 +11,18 @@ from nnodely.support.utils import check, enforce_types from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.WARNING) + class Loader(Network): @enforce_types def __init__(self): - check(type(self) is not Loader, TypeError, "Loader class cannot be instantiated directly") + check( + type(self) is not Loader, + TypeError, + "Loader class cannot be instantiated directly", + ) super().__init__() # Dataaset Parameters @@ -23,7 +30,9 @@ def __init__(self): self.__datasets_loaded = set() @enforce_types - def getSamples(self, dataset:str, *, index:int|None = None, window:int=1) -> dict: + def getSamples( + self, dataset: str, *, index: int | None = None, window: int = 1 + ) -> dict: """ Retrieves a window of samples from a given dataset. @@ -53,19 +62,25 @@ def getSamples(self, dataset:str, *, index:int|None = None, window:int=1) -> dic """ if index is None: index = random.randint(0, self._num_of_samples[dataset] - window) - check(self._data_loaded, ValueError, 'The Dataset must first be loaded using function!') + check( + self._data_loaded, + ValueError, + "The Dataset must first be loaded using function!", + ) if self._data_loaded: result_dict = {} - for key in self._model_def['Inputs'].keys(): + for key in self._model_def["Inputs"].keys(): result_dict[key] = [] for idx in range(window): - for key ,samples in self._data[dataset].items(): - if key in self._model_def['Inputs'].keys(): - result_dict[key].append(samples[index+idx]) + for key, samples in self._data[dataset].items(): + if key in self._model_def["Inputs"].keys(): + result_dict[key].append(samples[index + idx]) return result_dict @enforce_types - def filterData(self, filter_function:Callable, dataset_name:str|None = None) -> None: + def filterData( + self, filter_function: Callable, dataset_name: str | None = None + ) -> None: """ Filters the data in the dataset using the provided filter function. @@ -97,7 +112,9 @@ def filterData(self, filter_function:Callable, dataset_name:str|None = None) -> idx_to_remove.append(idx) for key in self._data[name].keys(): - self._data[name][key] = np.delete(self._data[name][key], idx_to_remove, axis=0) + self._data[name][key] = np.delete( + self._data[name][key], idx_to_remove, axis=0 + ) self._num_of_samples[name] = self._data[name][key].shape[0] self.visualizer.showDataset(name=name) @@ -115,12 +132,16 @@ def filterData(self, filter_function:Callable, dataset_name:str|None = None) -> idx_to_remove.append(idx) for key in self._data[dataset_name].keys(): - self._data[dataset_name][key] = np.delete(self._data[dataset_name][key], idx_to_remove, axis=0) - self._num_of_samples[dataset_name] = self._data[dataset_name][key].shape[0] + self._data[dataset_name][key] = np.delete( + self._data[dataset_name][key], idx_to_remove, axis=0 + ) + self._num_of_samples[dataset_name] = self._data[dataset_name][ + key + ].shape[0] self.visualizer.showDataset(name=dataset_name) @enforce_types - def resamplingData(self, df:pd.DataFrame, *, scale:float = 1e9) -> None: + def resamplingData(self, df: pd.DataFrame, *, scale: float = 1e9) -> None: """ Resamples the DataFrame to a specified sample time. @@ -149,7 +170,7 @@ def resamplingData(self, df:pd.DataFrame, *, scale:float = 1e9) -> None: sample_time_ns = int(self._model_def.getSampleTime() * scale) if sample_time_ns <= 0: raise ValueError(f"Invalid resampling step: {sample_time_ns}ns") - method = 'linear' + method = "linear" if isinstance(df.index, pd.DatetimeIndex): # FORZA risoluzione ns (evita unit='s' interno) if df.index.dtype != "datetime64[ns]": @@ -177,12 +198,14 @@ def resamplingData(self, df:pd.DataFrame, *, scale:float = 1e9) -> None: df = df.resample(f"{sample_time_ns}ns").interpolate(method=method) else: - raise TypeError("No time column found in the DataFrame. Please provide a time column for resampling.") + raise TypeError( + "No time column found in the DataFrame. Please provide a time column for resampling." + ) return df - + @enforce_types def __get_format_idxs(self, format: list | None = None) -> dict: - model_inputs = self._model_def['Inputs'] + model_inputs = self._model_def["Inputs"] format_idx = {} idx = 0 for item in format: @@ -190,11 +213,17 @@ def __get_format_idxs(self, format: list | None = None) -> dict: n_cols = None for key in item: if key in model_inputs.keys(): - if n_cols is None or n_cols == model_inputs[key]['dim']: - n_cols = model_inputs[key]['dim'] + if n_cols is None or n_cols == model_inputs[key]["dim"]: + n_cols = model_inputs[key]["dim"] else: - raise ValueError(f'The variables {item} have different dimensionality.') - check(key not in format_idx, ValueError, f"The format '{format}' in not correct some variables appears more than once.") + raise ValueError( + f"The variables {item} have different dimensionality." + ) + check( + key not in format_idx, + ValueError, + f"The format '{format}' in not correct some variables appears more than once.", + ) format_idx[key] = (idx, idx + n_cols) if n_cols is not None: idx += n_cols @@ -204,30 +233,33 @@ def __get_format_idxs(self, format: list | None = None) -> dict: if item not in model_inputs.keys(): idx += 1 continue - n_cols = model_inputs[item]['dim'] - check(item not in format_idx, ValueError, - f"The format '{format}' in not correct some variables appears more than once.") + n_cols = model_inputs[item]["dim"] + check( + item not in format_idx, + ValueError, + f"The format '{format}' in not correct some variables appears more than once.", + ) format_idx[item] = (idx, idx + n_cols) idx += n_cols return format_idx - + @enforce_types - def __get_files(self, folder:str) -> list: + def __get_files(self, folder: str) -> list: try: _, _, files = next(os.walk(folder)) files.sort() - except StopIteration as e: + except StopIteration: check(False, StopIteration, f'ERROR: The path "{folder}" does not exist!') return [] return files - + @enforce_types def __stack_arrays(self, data: dict) -> tuple: ## Convert lists to numpy arrays num_of_samples = {} for key in data: data[key] = np.stack(data[key]) - if self._model_def['Inputs'][key]['dim'] > 1: + if self._model_def["Inputs"][key]["dim"] > 1: data[key] = np.array(data[key].tolist(), dtype=np.float64) if data[key].ndim == 2: ## Add the sample dimension data[key] = np.expand_dims(data[key], axis=-1) @@ -237,14 +269,17 @@ def __stack_arrays(self, data: dict) -> tuple: return num_of_samples @enforce_types - def loadData(self, name:str, - source: str | dict | pd.DataFrame, *, - format: list | None = None, - skiplines: int = 0, - delimiter: str = ',', - header: int | str | Sequence | None = None, - resampling: bool = False - ) -> None: + def loadData( + self, + name: str, + source: str | dict | pd.DataFrame, + *, + format: list | None = None, + skiplines: int = 0, + delimiter: str = ",", + header: int | str | Sequence | None = None, + resampling: bool = False, + ) -> None: """ Loads data into the model. The data can be loaded from a directory path containing the csv files or from a crafted dataset. @@ -271,15 +306,17 @@ def loadData(self, name:str, Examples -------- - + .. include:: /examples_basics/data_loader_module_ex/loadData.rst """ check(self.neuralized, ValueError, "The network is not neuralized.") - check(delimiter in ['\t', '\n', ';', ',', ' '], ValueError, 'delimiter not valid!') + check( + delimiter in ["\t", "\n", ";", ",", " "], ValueError, "delimiter not valid!" + ) - json_inputs = self._model_def['Inputs'] + json_inputs = self._model_def["Inputs"] ## Initialize the dictionary containing the data - check_names(name, self._data.keys(), f"Dataset") + check_names(name, self._data.keys(), "Dataset") if type(source) is str: ## we have a directory path containing the files ## collect column indexes @@ -299,23 +336,46 @@ def loadData(self, name:str, for file in files: try: ## read the csv - df = pd.read_csv(os.path.join(source, file), skiprows=skiplines, delimiter=delimiter, header=header) + df = pd.read_csv( + os.path.join(source, file), + skiprows=skiplines, + delimiter=delimiter, + header=header, + ) if not all(df.iloc[0].apply(lambda x: isinstance(x, (int, float)))): - log.warning(f"The file {file} does not contain a numerical column.") + log.warning( + f"The file {file} does not contain a numerical column." + ) ## Resampling if the time column is provided (must be a Datetime object) if resampling: self.resamplingData(df) except: - log.warning(f'Cannot read file {os.path.join(source, file)}') + log.warning(f"Cannot read file {os.path.join(source, file)}") continue if self._file_count > 1: - self._multifile[name].append((self._multifile[name][-1] + (len(df) - self._max_n_samples + 1)) if self._multifile[name] else len(df) - self._max_n_samples + 1) + self._multifile[name].append( + ( + self._multifile[name][-1] + + (len(df) - self._max_n_samples + 1) + ) + if self._multifile[name] + else len(df) - self._max_n_samples + 1 + ) ## Cycle through all the windows for key, idxs in format_idx.items(): - back, forw = self._input_ns_backward[key], self._input_ns_forward[key] + back, forw = ( + self._input_ns_backward[key], + self._input_ns_forward[key], + ) ## Save as numpy array the data - data = df.iloc[:, idxs[0]:idxs[1]].to_numpy() - self._data[name][key] += [data[i - back:i + forw] for i in range(self._max_samples_backward, len(df) - self._max_samples_forward + 1)] + data = df.iloc[:, idxs[0] : idxs[1]].to_numpy() + self._data[name][key] += [ + data[i - back : i + forw] + for i in range( + self._max_samples_backward, + len(df) - self._max_samples_forward + 1, + ) + ] else: ## we have a crafted dataset ## add the dataset self._data[name] = {} @@ -326,9 +386,17 @@ def loadData(self, name:str, if key not in source.keys(): continue self._data[name][key] = [] ## Initialize the dataset - back, forw = self._input_ns_backward[key], self._input_ns_forward[key] + back, forw = ( + self._input_ns_backward[key], + self._input_ns_forward[key], + ) for idx in range(len(source[key]) - self._max_n_samples + 1): - self._data[name][key].append(source[key][idx + (self._max_samples_backward - back):idx + (self._max_samples_backward + forw)]) + self._data[name][key].append( + source[key][ + idx + (self._max_samples_backward - back) : idx + + (self._max_samples_backward + forw) + ] + ) else: if resampling: source = self.resamplingData(source) @@ -336,15 +404,25 @@ def loadData(self, name:str, if key not in source.columns: continue self._data[name][key] = [] ## Initialize the dataset - back, forw = self._input_ns_backward[key], self._input_ns_forward[key] + back, forw = ( + self._input_ns_backward[key], + self._input_ns_forward[key], + ) for idx in range(len(source) - self._max_n_samples + 1): - window = source[key].iloc[idx + (self._max_samples_backward - back):idx + (self._max_samples_backward + forw)] + window = source[key].iloc[ + idx + (self._max_samples_backward - back) : idx + + (self._max_samples_backward + forw) + ] self._data[name][key].append(window.to_numpy()) ## Convert lists to numpy arrays num_of_samples = self.__stack_arrays(self._data[name]) # Check dim of the samples - check(len(set(num_of_samples.values())) == 1, ValueError, f"The number of the sample of the dataset {name} are not the same for all input in the dataset: {num_of_samples}") + check( + len(set(num_of_samples.values())) == 1, + ValueError, + f"The number of the sample of the dataset {name} are not the same for all input in the dataset: {num_of_samples}", + ) self._num_of_samples[name] = num_of_samples[list(num_of_samples.keys())[0]] ## Set the Loaded flag to True self._data_loaded = True @@ -352,4 +430,4 @@ def loadData(self, name:str, self.__n_datasets = len(self._data.keys()) self.__datasets_loaded.add(name) ## Show the dataset - self.visualizer.showDataset(name=name) \ No newline at end of file + self.visualizer.showDataset(name=name) diff --git a/src/nnodely/operators/network.py b/src/nnodely/operators/network.py new file mode 100644 index 00000000..fcf97ec7 --- /dev/null +++ b/src/nnodely/operators/network.py @@ -0,0 +1,711 @@ +import copy +from collections import defaultdict + +import numpy as np +import torch +import random + +from nnodely.support.utils import ( + TORCH_DTYPE, + NP_DTYPE, + check, + enforce_types, + tensor_to_list, +) +from nnodely.basic.modeldef import ModelDef + +from nnodely.support.logger import logging, nnLogger + +log = nnLogger(__name__, logging.WARNING) + + +class Network: + @enforce_types + def __init__(self): + check( + type(self) is not Network, + TypeError, + "Loader class cannot be instantiated directly", + ) + + # Models definition + self._model_def = ModelDef() + self._model = None + self._neuralized = False + self._traced = False + + # Model components + self._states = {} + self._input_n_samples = {} + self._input_ns_backward = {} + self._input_ns_forward = {} + self._max_samples_backward = None + self._max_samples_forward = None + self._max_n_samples = 0 + + # Dataset information + self._data_loaded = False + self._file_count = 0 + self._num_of_samples = {} + self._data = {} + self._multifile = {} + + # Training information + self._standard_train_parameters = { + "models": None, + "train_dataset": None, + "validation_dataset": None, + "dataset": None, + "splits": [100, 0, 0], + "closed_loop": {}, + "connect": {}, + "step": 0, + "prediction_samples": 0, + "shuffle_data": True, + "early_stopping": None, + "early_stopping_params": {}, + "select_model": "last", + "select_model_params": {}, + "minimize_gain": {}, + "num_of_epochs": 100, + "train_batch_size": 128, + "val_batch_size": 128, + "optimizer": "Adam", + "lr": 0.001, + "lr_param": {}, + "optimizer_params": [], + "add_optimizer_params": [], + "optimizer_defaults": {}, + "add_optimizer_defaults": {}, + } + self._training = {} + + # Save internal + self._log_internal = False + self._internals = {} + + def _save_internal(self, key, value): + self._internals[key] = tensor_to_list(value) + + def _set_log_internal(self, log_internal: bool): + self._log_internal = log_internal + + def _clean_log_internal(self): + self._internals = {} + + def _remove_virtual_states(self, connect, closed_loop): + if connect or closed_loop: + for key in connect.keys() | closed_loop.keys(): + if key in self._states.keys(): + del self._states[key] + + def _update_state(self, X, out_closed_loop, out_connect): + for key, value in out_connect.items(): + X[key] = torch.roll(value, shifts=-1, dims=1) ## Roll the time window + X[key][:, -1, :] = float( + "inf" + ) ## inf value to make clear that the last state value + self._states[key] = X[key].clone().detach() + for key, val in out_closed_loop.items(): + shift = val.shape[ + 1 + ] # + self._input_ns_forward[key] ## take the output time dimension + forward samples + X[key] = torch.roll(X[key], shifts=-1, dims=1) ## Roll the time window + X[key][:, -shift:, :] = val ## substitute with the predicted value + self._states[key] = X[key].clone().detach() + + def _get_gradient_on_inference(self): + for key, value in self._model_def["Inputs"].items(): + if "type" in value.keys(): + return True + return False + + def _get_mandatory_inputs(self, connect, closed_loop): + model_inputs = list(self._model_def["Inputs"].keys()) + non_mandatory_inputs = ( + list(closed_loop.keys()) + + list(connect.keys()) + + list(self._model_def.recurrentInputs().keys()) + ) + mandatory_inputs = list(set(model_inputs) - set(non_mandatory_inputs)) + return mandatory_inputs, non_mandatory_inputs + + def _get_batch_indexes( + self, + datasets: str | list | dict | None, + n_samples: int = 0, + prediction_samples: int = 0, + ): + if datasets is None: + return [] + batch_indexes = list(range(n_samples)) + if prediction_samples > 0 and not isinstance(datasets, dict): + datasets = [datasets] if type(datasets) is str else datasets + forbidden_idxs = [] + n_samples_count = 0 + for dataset in datasets: + if dataset in self._multifile.keys(): ## i have some forbidden indexes + for i in self._multifile[dataset]: + if i + n_samples_count < batch_indexes[-1]: + forbidden_idxs.extend( + range( + (i + n_samples_count) - prediction_samples, + (i + n_samples_count), + 1, + ) + ) + n_samples_count += self._num_of_samples[dataset] + batch_indexes = [idx for idx in batch_indexes if idx not in forbidden_idxs] + batch_indexes = batch_indexes[:-prediction_samples] + return batch_indexes + + def _get_data(self, dataset: str | list | dict | None): + if dataset is None: + return {} + if isinstance(dataset, dict): + self.__check_data_integrity(dataset) + return dataset + dataset = [dataset] if type(dataset) is str else dataset + loaded_datasets = list(self._data.keys()) + check( + len([data for data in dataset if data in loaded_datasets]) > 0, + KeyError, + f"the datasets: {dataset} are not loaded!", + ) + total_data = defaultdict(list) + for data in dataset: + if data not in loaded_datasets: + log.warning(f"{data} is not loaded. Ignoring this dataset...") + dataset.remove(data) + continue + for k, v in self._data[data].items(): + total_data[k].append(v) + total_data = {key: np.concatenate(arrays) for key, arrays in total_data.items()} + total_data = { + key: torch.from_numpy(val).to(TORCH_DTYPE) + for key, val in total_data.items() + } + return total_data + + def _clip_step(self, step, batch_indexes, batch_size): + clipped_step = copy.deepcopy(step) + if clipped_step < 0: ## clip the step to zero + log.warning( + f"The step is negative ({clipped_step}). The step is set to zero.", + stacklevel=5, + ) + clipped_step = 0 + if clipped_step > ( + len(batch_indexes) - batch_size + ): ## Clip the step to the maximum number of samples + log.warning( + f"The step ({clipped_step}) is greater than the number of available samples ({len(batch_indexes) - batch_size}). The step is set to the maximum number.", + stacklevel=5, + ) + clipped_step = len(batch_indexes) - batch_size + check( + (batch_size + clipped_step) > 0, + ValueError, + f"The sum of batch_size={batch_size} and the step={clipped_step} must be greater than 0.", + ) + return clipped_step + + def _clip_batch_size(self, n_samples, batch_size=None): + batch_size = batch_size if batch_size <= n_samples else max(0, n_samples) + check( + (n_samples - batch_size + 1) > 0, + ValueError, + f"The number of available sample are {n_samples - batch_size + 1}", + ) + check(batch_size > 0, ValueError, "The batch_size must be greater than 0.") + return batch_size + + def __split_dataset(self, dataset: str | list | dict, splits: list): + check( + len(splits) == 3, + ValueError, + "3 elements must be inserted for the dataset split in training, validation and test", + ) + check( + sum(splits) == 100, + ValueError, + "Training, Validation and Test splits must sum up to 100.", + ) + check(splits[0] > 0, ValueError, "The training split cannot be zero.") + train_size, val_size, test_size = ( + splits[0] / 100, + splits[1] / 100, + splits[2] / 100, + ) + XY_train, XY_val, XY_test = {}, {}, {} + if isinstance(dataset, dict): + self.__check_data_integrity(dataset) + num_of_samples = next(iter(dataset.values())).size(0) + XY_train = { + key: value[: round(num_of_samples * train_size), :, :] + for key, value in dataset.items() + } + XY_val = { + key: value[ + round(num_of_samples * train_size) : round( + num_of_samples * (train_size + val_size) + ), + :, + :, + ] + for key, value in dataset.items() + } + XY_test = { + key: value[round(num_of_samples * (train_size + val_size)) :, :, :] + for key, value in dataset.items() + } + else: + dataset = [dataset] if type(dataset) is str else dataset + check( + len([data for data in dataset if data in self._data.keys()]) > 0, + KeyError, + f"the datasets: {dataset} are not loaded!", + ) + for data in dataset: + if data not in self._data.keys(): + log.warning( + f"{data} is not loaded. The training will continue without this dataset." + ) + dataset.remove(data) + + num_of_samples = sum([self._num_of_samples[data] for data in dataset]) + n_samples_train, n_samples_val = ( + round(num_of_samples * train_size), + round(num_of_samples * val_size), + ) + n_samples_test = num_of_samples - n_samples_train - n_samples_val + check( + n_samples_train > 0, + ValueError, + f"The number of train samples {n_samples_train} must be greater than 0.", + ) + total_data = defaultdict(list) + for data in dataset: + for k, v in self._data[data].items(): + total_data[k].append(v) + total_data = { + key: np.concatenate(arrays, dtype=NP_DTYPE) + for key, arrays in total_data.items() + } + for key, samples in total_data.items(): + if val_size == 0.0 and test_size == 0.0: ## we have only training set + XY_train[key] = torch.from_numpy(samples).to(TORCH_DTYPE) + elif ( + val_size == 0.0 and test_size != 0.0 + ): ## we have only training and test set + XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to( + TORCH_DTYPE + ) + XY_test[key] = torch.from_numpy(samples[n_samples_train:]).to( + TORCH_DTYPE + ) + elif ( + val_size != 0.0 and test_size == 0.0 + ): ## we have only training and validation set + XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to( + TORCH_DTYPE + ) + XY_val[key] = torch.from_numpy(samples[n_samples_train:]).to( + TORCH_DTYPE + ) + else: ## we have training, validation and test set + XY_train[key] = torch.from_numpy(samples[:n_samples_train]).to( + TORCH_DTYPE + ) + XY_val[key] = torch.from_numpy( + samples[n_samples_train:-n_samples_test] + ).to(TORCH_DTYPE) + XY_test[key] = torch.from_numpy( + samples[n_samples_train + n_samples_val :] + ).to(TORCH_DTYPE) + return XY_train, XY_val, XY_test + + def _get_tag(self, dataset: str | list | dict | None) -> str: + """ + Helper function to get the tag for a dataset. + """ + if isinstance(dataset, str): + return dataset + elif isinstance(dataset, list): + return ( + f"{dataset[0]}_{len(dataset)}" if len(dataset) > 1 else f"{dataset[0]}" + ) + elif isinstance(dataset, dict): + return "custom_dataset" + return dataset + + def _setup_dataset( + self, + train_dataset: str | list | dict, + validation_dataset: str | list | dict, + test_dataset: str | list | dict, + dataset: str | list | dict, + splits: list, + ): + if train_dataset is None: ## use the splits + train_dataset = list(self._data.keys()) if dataset is None else dataset + return self.__split_dataset(train_dataset, splits) + else: ## use each dataset + return ( + self._get_data(train_dataset), + self._get_data(validation_dataset), + self._get_data(test_dataset), + ) + + def __check_data_integrity(self, dataset: dict): + if bool(dataset): + check( + len(set([t.size(0) for t in dataset.values()])) == 1, + ValueError, + "All the tensors in the dataset must have the same number of samples.", + ) + # TODO check why is wrong + # check(len([t for t in self._model_def['Inputs'].keys() if t in dataset.keys()]) == len(list(self._model_def['Inputs'].keys())), ValueError, "Some inputs are missing.") + for key, value in dataset.items(): + if key not in self._model_def["Inputs"]: + log.warning( + f"The key '{key}' is not an input of the network. It will be ignored." + ) + else: + check( + isinstance(value, torch.Tensor), + TypeError, + f"The value of the input '{key}' must be a torch.Tensor.", + ) + check( + value.size(1) == self._model_def["Inputs"][key]["ntot"], + ValueError, + f"The time size of the input '{key}' is not correct. Expected {self._model_def['Inputs'][key]['ntot']}, got {value.size(1)}.", + ) + check( + value.size(2) == self._model_def["Inputs"][key]["dim"], + ValueError, + f"The dimension of the input '{key}' is not correct. Expected {self._model_def['Inputs'][key]['dim']}, got {value.size(2)}.", + ) + + def _get_not_mandatory_inputs( + self, + data, + X, + non_mandatory_inputs, + remaning_indexes, + batch_size, + step, + shuffle=False, + ): + related_indexes = ( + random.sample(remaning_indexes, batch_size) + if shuffle + else remaning_indexes[:batch_size] + ) + for num in related_indexes: + remaning_indexes.remove(num) + if step > 0: + if len(remaning_indexes) >= step: + step_idxs = ( + random.sample(remaning_indexes, step) + if shuffle + else remaning_indexes[:step] + ) + for num in step_idxs: + remaning_indexes.remove(num) + else: + remaning_indexes.clear() + for key in non_mandatory_inputs: + if key in data.keys(): ## with data + X[key] = data[key][related_indexes] + else: ## with zeros + window_size = self._input_n_samples[key] + dim = self._model_def["Inputs"][key]["dim"] + if "type" in self._model_def["Inputs"][key]: + X[key] = torch.zeros( + size=(batch_size, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=True, + ) + else: + X[key] = torch.zeros( + size=(batch_size, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=False, + ) + self._states[key] = X[key] + return related_indexes + + def _inference( + self, + data, + n_samples, + batch_size, + loss_gains, + loss_functions, + shuffle=False, + optimizer=None, + total_losses=None, + A=None, + B=None, + ): + if shuffle: + randomize = torch.randperm(n_samples) + data = {key: val[randomize] for key, val in data.items()} + + ## Initialize the train losses vector + aux_losses = torch.zeros( + [len(self._model_def["Minimizers"]), n_samples // batch_size] + ) + for idx in range(0, (n_samples - batch_size + 1), batch_size): + ## Build the input tensor + XY = {} + for key, val in data.items(): + if self._model_def["Inputs"].get(key, None): + if self._model_def["Inputs"][key].get("type", None) == "derivate": + XY[key] = ( + val[idx : idx + batch_size].detach().requires_grad_(True) + ) + else: + XY[key] = val[idx : idx + batch_size] + # XY = {key: val[idx:idx + batch_size].detach().requires_grad_(True) for key, val in data.items()} + for key in self._model_def.recurrentInputs().keys(): + if key not in XY.keys(): + window_size = self._input_n_samples[key] + dim = self._model_def["Inputs"][key]["dim"] + XY[key] = torch.zeros( + size=(batch_size, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=True, + ) + ## Reset gradient + if optimizer: + optimizer.zero_grad() + ## Model Forward + out, minimize_out, _, _ = self._model(XY) ## Forward pass + + if self._log_internal: + internals_dict = { + "XY": tensor_to_list(XY), + "out": out, + "param": self._model.all_parameters, + } + + ## Loss Calculation + total_loss = 0 + for ind, (key, value) in enumerate(self._model_def["Minimizers"].items()): + if A is not None: + A[key].append(minimize_out[value["A"]].detach().numpy()) + if B is not None: + B[key].append(minimize_out[value["B"]].detach().numpy()) + loss = loss_functions[key]( + minimize_out[value["A"]], minimize_out[value["B"]] + ) + loss = (loss * loss_gains[key]) if key in loss_gains.keys() else loss + if total_losses is not None: + total_losses[key].append(loss.detach().numpy()) + aux_losses[ind][idx // batch_size] = loss.item() + total_loss += loss + + if self._log_internal: + self._save_internal("inout_" + str(idx), internals_dict) + + ## Gradient step + if optimizer: + total_loss.backward() ## Backpropagate the error + optimizer.step() + self.visualizer.showWeightsInTrain(batch=idx // batch_size) + + ## return the losses + return aux_losses + + def _recurrent_inference( + self, + data, + batch_indexes, + batch_size, + loss_gains, + prediction_samples, + step, + non_mandatory_inputs, + mandatory_inputs, + loss_functions, + shuffle=False, + optimizer=None, + total_losses=None, + A=None, + B=None, + idxs=None, + ): + indexes = copy.deepcopy(batch_indexes) + aux_losses = torch.zeros( + [ + len(self._model_def["Minimizers"]), + round((len(indexes) + step) / (batch_size + step)), + ] + ) + X = {} + batch_idx = 0 + while len(indexes) >= batch_size: + selected_indexes = self._get_not_mandatory_inputs( + data, X, non_mandatory_inputs, indexes, batch_size, step, shuffle + ) + horizon_losses = { + ind: [] for ind in range(len(self._model_def["Minimizers"])) + } + if optimizer: + optimizer.zero_grad() ## Reset the gradient + + for horizon_idx in range(prediction_samples + 1): + # Save the indexes + if idxs is not None: + idxs[horizon_idx].append( + [idx + horizon_idx for idx in selected_indexes] + ) + ## Get data + for key in mandatory_inputs: + X[key] = data[key][[idx + horizon_idx for idx in selected_indexes]] + ## Forward pass + out, minimize_out, out_closed_loop, out_connect = self._model(X) + + if self._log_internal: + internals_dict = { + "XY": tensor_to_list(X), + "out": out, + "param": self._model.all_parameters, + "closedLoop": self._model.closed_loop_update, + "connect": self._model.connect_update, + } + + ## Loss Calculation + for ind, (key, value) in enumerate( + self._model_def["Minimizers"].items() + ): + if A is not None: + A[key][horizon_idx].append( + minimize_out[value["A"]].detach().numpy() + ) + if B is not None: + B[key][horizon_idx].append( + minimize_out[value["B"]].detach().numpy() + ) + loss = loss_functions[key]( + minimize_out[value["A"]], minimize_out[value["B"]] + ) + loss = ( + (loss * loss_gains[key]) if key in loss_gains.keys() else loss + ) + horizon_losses[ind].append(loss) + + ## Update + self._update_state(X, out_closed_loop, out_connect) + + if self._log_internal: + internals_dict["state"] = self._states + self._save_internal( + "inout_" + str(batch_idx) + "_" + str(horizon_idx), + internals_dict, + ) + + ## Calculate the total loss + total_loss = 0 + for ind, key in enumerate(self._model_def["Minimizers"].keys()): + loss = sum(horizon_losses[ind]) / (prediction_samples + 1) + aux_losses[ind][batch_idx] = loss.item() + if total_losses is not None: + total_losses[key].append(loss.detach().numpy()) + total_loss += loss + + ## Gradient Step + if optimizer: + total_loss.backward() ## Backpropagate the error + optimizer.step() + self.visualizer.showWeightsInTrain(batch=batch_idx) + batch_idx += 1 + + ## return the losses + return aux_losses + + def _setup_recurrent_variables(self, prediction_samples, closed_loop, connect): + ## Prediction samples + check( + prediction_samples == "auto" or prediction_samples >= -1, + KeyError, + "The sample horizon must be positive, -1, 'auto', for disconnect connection!", + ) + ## Close loop information + for input, output in closed_loop.items(): + check( + input in self._model_def["Inputs"], + ValueError, + f"the tag {input} is not an input variable.", + ) + check( + output in self._model_def["Outputs"], + ValueError, + f"the tag {output} is not an output of the network", + ) + log.info( + f"Recurrent train: closing the loop between the the input ports {input} and the output ports {output} for {prediction_samples} samples" + ) + if self._input_ns_forward[input] > 0: + log.warning( + f"Closed loop on variable '{input}' with sample in the future." + ) + ## Connect information + for input, output in connect.items(): + check( + input in self._model_def["Inputs"], + ValueError, + f"the tag {input} is not an input variable.", + ) + check( + output in self._model_def["Outputs"], + ValueError, + f"the tag {output} is not an output of the network", + ) + log.info( + f"Recurrent train: connecting the input ports {input} with output ports {output} for {prediction_samples} samples" + ) + if self._input_ns_forward[input] > 0: + log.warning(f"Connect on variable '{input}' with sample in the future.") + ## Disable recurrent training if there are no recurrent variables + if len(connect | closed_loop | self._model_def.recurrentInputs()) == 0: + if type(prediction_samples) is not str and prediction_samples >= 0: + log.warning( + f"The value of the prediction_samples={prediction_samples} but the network has no recurrent variables." + ) + prediction_samples = -1 + return prediction_samples + + @enforce_types + def resetStates(self, states: set = {}, *, batch: int = 1) -> None: + """ + Resets the state of all the recurrent inputs of the network to zero. + Parameters + ---------- + states : set, optional + A set of recurrent inputs names to reset. If provided, only those inputs will be resetted. + batch : int, optional + The batch size for the reset states. Default is 1. + """ + if states: ## reset only specific states + for key in states: + window_size = self._input_n_samples[key] + dim = self._model_def["Inputs"][key]["dim"] + self._states[key] = torch.zeros( + size=(batch, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=False, + ) + else: ## reset all states + self._states = {} + for key, state in self._model_def.recurrentInputs().items(): + window_size = self._input_n_samples[key] + dim = state["dim"] + self._states[key] = torch.zeros( + size=(batch, window_size, dim), + dtype=TORCH_DTYPE, + requires_grad=False, + ) diff --git a/nnodely/operators/trainer.py b/src/nnodely/operators/trainer.py similarity index 53% rename from nnodely/operators/trainer.py rename to src/nnodely/operators/trainer.py index 2fec15e2..95f3e52b 100644 --- a/nnodely/operators/trainer.py +++ b/src/nnodely/operators/trainer.py @@ -1,4 +1,7 @@ -import copy, torch, time, inspect +import copy +import torch +import time +import inspect from collections.abc import Callable from functools import wraps @@ -13,12 +16,17 @@ from nnodely.layers.output import Output from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.INFO) class Trainer(Network): def __init__(self): - check(type(self) is not Trainer, TypeError, "Trainer class cannot be instantiated directly") + check( + type(self) is not Trainer, + TypeError, + "Trainer class cannot be instantiated directly", + ) super().__init__() ## User Parameters @@ -31,7 +39,13 @@ def __init__(self): self.__optimizer = None @enforce_types - def addMinimize(self, name:str, streamA:str|Stream|Output, streamB:str|Stream|Output, loss_function:str='mse') -> None: + def addMinimize( + self, + name: str, + streamA: str | Stream | Output, + streamB: str | Stream | Output, + loss_function: str = "mse", + ) -> None: """ Adds a minimize loss function to the model. @@ -55,7 +69,7 @@ def addMinimize(self, name:str, streamA:str|Stream|Output, streamB:str|Stream|Ou self._neuralized = False @enforce_types - def removeMinimize(self, name_list:list|str) -> None: + def removeMinimize(self, name_list: list | str) -> None: """ Removes minimize loss functions using the given list of names. @@ -72,13 +86,33 @@ def removeMinimize(self, name_list:list|str) -> None: self._neuralized = False def __preliminary_checks(self, **kwargs): - check(self._data_loaded, RuntimeError, 'There is no data loaded! The Training will stop.') - check('Models' in self._model_def.getJson(), RuntimeError, 'There are no models to train. Load a model using the addModel function.') - check(list(self._model.parameters()), RuntimeError, 'There are no modules with learnable parameters! The Training will stop.') - if kwargs.get('train_dataset', None) is None: - check(kwargs.get('validation_dataset', None) is None, ValueError, 'If train_dataset is None, validation_dataset must also be None.') - for model in kwargs['models']: - check(model in kwargs['all_models'], ValueError, f'The model {model} is not in the model definition') + check( + self._data_loaded, + RuntimeError, + "There is no data loaded! The Training will stop.", + ) + check( + "Models" in self._model_def.getJson(), + RuntimeError, + "There are no models to train. Load a model using the addModel function.", + ) + check( + list(self._model.parameters()), + RuntimeError, + "There are no modules with learnable parameters! The Training will stop.", + ) + if kwargs.get("train_dataset", None) is None: + check( + kwargs.get("validation_dataset", None) is None, + ValueError, + "If train_dataset is None, validation_dataset must also be None.", + ) + for model in kwargs["models"]: + check( + model in kwargs["all_models"], + ValueError, + f"The model {model} is not in the model definition", + ) def __fill_parameters(func): @wraps(func) @@ -89,10 +123,14 @@ def wrapper(self, *args, **kwargs): # Get standard parameters standard = self._standard_train_parameters # Get user_parameters - users = bound.arguments.get('training_params', None) + users = bound.arguments.get("training_params", None) # Fill missing (None) arguments for param in sig.parameters.values(): - if param.name == 'self' or param.name == 'lr' or param.name == 'lr_param': + if ( + param.name == "self" + or param.name == "lr" + or param.name == "lr_param" + ): continue if bound.arguments.get(param.name, None) is None: if param.name in users.keys(): @@ -100,35 +138,51 @@ def wrapper(self, *args, **kwargs): else: bound.arguments[param.name] = standard.get(param.name, None) return func(**bound.arguments) + return wrapper - def __initialize_optimizer(self, models, optimizer, training_params, optimizer_params, optimizer_defaults, add_optimizer_defaults, add_optimizer_params, lr, lr_param): + def __initialize_optimizer( + self, + models, + optimizer, + training_params, + optimizer_params, + optimizer_defaults, + add_optimizer_defaults, + add_optimizer_params, + lr, + lr_param, + ): ## Get models params_to_train = set() for model in models: - if type(self._model_def['Models']) is dict: - params_to_train |= set(self._model_def['Models'][model]['Parameters']) + if type(self._model_def["Models"]) is dict: + params_to_train |= set(self._model_def["Models"][model]["Parameters"]) else: - params_to_train |= set(self._model_def['Parameters'].keys()) + params_to_train |= set(self._model_def["Parameters"].keys()) # Get the optimizer if type(optimizer) is str: - if optimizer == 'SGD': + if optimizer == "SGD": optimizer = SGD({}, []) - elif optimizer == 'Adam': + elif optimizer == "Adam": optimizer = Adam({}, []) else: optimizer = copy.deepcopy(optimizer) - check(issubclass(type(optimizer), Optimizer), TypeError, "The optimizer must be an Optimizer or str") + check( + issubclass(type(optimizer), Optimizer), + TypeError, + "The optimizer must be an Optimizer or str", + ) optimizer.set_params_to_train(self._model.all_parameters, params_to_train) - optimizer.add_defaults('lr', self._standard_train_parameters['lr']) + optimizer.add_defaults("lr", self._standard_train_parameters["lr"]) - if training_params and 'lr' in training_params: - optimizer.add_defaults('lr', training_params['lr']) - if training_params and 'lr_param' in training_params: - optimizer.add_option_to_params('lr', training_params['lr_param']) + if training_params and "lr" in training_params: + optimizer.add_defaults("lr", training_params["lr"]) + if training_params and "lr_param" in training_params: + optimizer.add_option_to_params("lr", training_params["lr_param"]) if optimizer_defaults != {}: optimizer.set_defaults(optimizer_defaults) @@ -140,21 +194,21 @@ def __initialize_optimizer(self, models, optimizer, training_params, optimizer_p add_optimizer_params = optimizer.unfold(add_optimizer_params) for param in add_optimizer_params: - par = param['params'] - del param['params'] + par = param["params"] + del param["params"] for key, value in param.items(): optimizer.add_option_to_params(key, {par: value}) # Modify the parameter - optimizer.add_defaults('lr', lr) + optimizer.add_defaults("lr", lr) if lr_param: - optimizer.add_option_to_params('lr', lr_param) + optimizer.add_option_to_params("lr", lr_param) self.__optimizer = optimizer def __initialize_loss(self): - for name, values in self._model_def['Minimizers'].items(): - self.__loss_functions[name] = CustomLoss(values['loss']) + for name, values in self._model_def["Minimizers"].items(): + self.__loss_functions[name] = CustomLoss(values["loss"]) def getTrainingInfo(self): """ @@ -168,72 +222,109 @@ def getTrainingInfo(self): dict A dictionary containing the training parameters and information. """ - to_remove = ['XY_train','XY_val','XY_test','train_indexes','val_indexes','test_indexes'] - tp = copy.deepcopy({key:value for key, value in self.running_parameters.items() if key not in to_remove}) + to_remove = [ + "XY_train", + "XY_val", + "XY_test", + "train_indexes", + "val_indexes", + "test_indexes", + ] + tp = copy.deepcopy( + { + key: value + for key, value in self.running_parameters.items() + if key not in to_remove + } + ) ## training - tp['update_per_epochs'] = len(self.running_parameters['train_indexes']) // (tp['train_batch_size'] + tp['step']) - if tp['prediction_samples'] >= 0: # TODO - tp['n_first_samples_train'] = len(self.running_parameters['train_indexes']) - if tp['n_samples_val'] > 0: - tp['n_first_samples_val'] = len(self.running_parameters['val_indexes']) - if tp['n_samples_test'] > 0: - tp['n_first_samples_test'] = len(self.running_parameters['test_indexes']) - + tp["update_per_epochs"] = len(self.running_parameters["train_indexes"]) // ( + tp["train_batch_size"] + tp["step"] + ) + if tp["prediction_samples"] >= 0: # TODO + tp["n_first_samples_train"] = len(self.running_parameters["train_indexes"]) + if tp["n_samples_val"] > 0: + tp["n_first_samples_val"] = len(self.running_parameters["val_indexes"]) + if tp["n_samples_test"] > 0: + tp["n_first_samples_test"] = len( + self.running_parameters["test_indexes"] + ) ## optimizer - tp['optimizer'] = self.__optimizer.name - tp['optimizer_defaults'] = self.__optimizer.optimizer_defaults - tp['optimizer_params'] = self.__optimizer.optimizer_params + tp["optimizer"] = self.__optimizer.name + tp["optimizer_defaults"] = self.__optimizer.optimizer_defaults + tp["optimizer_params"] = self.__optimizer.optimizer_params ## early stopping - early_stopping = tp['early_stopping'] + early_stopping = tp["early_stopping"] if early_stopping: - tp['early_stopping'] = early_stopping.__name__ + tp["early_stopping"] = early_stopping.__name__ ## Loss functions - tp['minimizers'] = {} - for name, values in self._model_def['Minimizers'].items(): - tp['minimizers'][name] = {} - tp['minimizers'][name]['A'] = values['A'] - tp['minimizers'][name]['B'] = values['B'] - tp['minimizers'][name]['loss'] = values['loss'] - if name in tp['minimize_gain']: - tp['minimizers'][name]['gain'] = tp['minimize_gain'][name] + tp["minimizers"] = {} + for name, values in self._model_def["Minimizers"].items(): + tp["minimizers"][name] = {} + tp["minimizers"][name]["A"] = values["A"] + tp["minimizers"][name]["B"] = values["B"] + tp["minimizers"][name]["loss"] = values["loss"] + if name in tp["minimize_gain"]: + tp["minimizers"][name]["gain"] = tp["minimize_gain"][name] return tp def __check_needed_keys(self, train_data, connect, closed_loop): # Needed keys - keys = set(self._model_def['Inputs'].keys()) - keys |= ({value['A'] for value in self._model_def['Minimizers'].values()} | {value['B'] for value in self._model_def['Minimizers'].values()}) + keys = set(self._model_def["Inputs"].keys()) + keys |= {value["A"] for value in self._model_def["Minimizers"].values()} | { + value["B"] for value in self._model_def["Minimizers"].values() + } # Available keys - keys -= set(self._model_def['Outputs'].keys()|self._model_def['Relations'].keys()) + keys -= set( + self._model_def["Outputs"].keys() | self._model_def["Relations"].keys() + ) keys -= set(self._model_def.recurrentInputs().keys()) - keys -= (set(connect.keys()|closed_loop.keys())) + keys -= set(connect.keys() | closed_loop.keys()) # Check if the keys are in the dataset - check(set(keys).issubset(set(train_data.keys())), KeyError, f"Not all the mandatory keys {keys} are present in the training dataset {set(train_data.keys())}.") + check( + set(keys).issubset(set(train_data.keys())), + KeyError, + f"Not all the mandatory keys {keys} are present in the training dataset {set(train_data.keys())}.", + ) @enforce_types @__fill_parameters - def trainModel(self, *, - name: str | None = None, - models: str | list | None = None, - train_dataset: str | list | dict | None = None, validation_dataset: str | list | dict | None = None, - dataset: str | list | None = None, splits: list | None = None, - closed_loop: dict | None = None, connect: dict | None = None, step: int | None = None, prediction_samples: int | None = None, - shuffle_data: bool | None = None, - early_stopping: Callable | None = None, early_stopping_params: dict | None = None, - select_model: Callable | None = None, select_model_params: dict | None = None, - minimize_gain: dict | None = None, - num_of_epochs: int = None, - train_batch_size: int = None, val_batch_size: int = None, - optimizer: str | Optimizer | None = None, - lr: int | float | None = None, lr_param: dict | None = None, - optimizer_params: list | None = None, optimizer_defaults: dict | None = None, - add_optimizer_params: list | None = None, add_optimizer_defaults: dict | None = None, - training_params: dict | None = {} - ) -> None: + def trainModel( + self, + *, + name: str | None = None, + models: str | list | None = None, + train_dataset: str | list | dict | None = None, + validation_dataset: str | list | dict | None = None, + dataset: str | list | None = None, + splits: list | None = None, + closed_loop: dict | None = None, + connect: dict | None = None, + step: int | None = None, + prediction_samples: int | None = None, + shuffle_data: bool | None = None, + early_stopping: Callable | None = None, + early_stopping_params: dict | None = None, + select_model: Callable | None = None, + select_model_params: dict | None = None, + minimize_gain: dict | None = None, + num_of_epochs: int = None, + train_batch_size: int = None, + val_batch_size: int = None, + optimizer: str | Optimizer | None = None, + lr: int | float | None = None, + lr_param: dict | None = None, + optimizer_params: list | None = None, + optimizer_defaults: dict | None = None, + add_optimizer_params: list | None = None, + add_optimizer_defaults: dict | None = None, + training_params: dict | None = {}, + ) -> None: """ Trains the model using the provided datasets and parameters. @@ -307,21 +398,36 @@ def trainModel(self, *, .. include:: /examples_basics/trainer_module_ex/trainModel.rst """ ## Get model for train - all_models = list(self._model_def['Models'].keys()) if type(self._model_def['Models']) is dict else [self._model_def['Models']] + all_models = ( + list(self._model_def["Models"].keys()) + if type(self._model_def["Models"]) is dict + else [self._model_def["Models"]] + ) if models is None: models = all_models if isinstance(models, str): models = [models] ## Preliminary Checks - self.__preliminary_checks(models = models, all_models = all_models, train_dataset = train_dataset, validation_dataset = validation_dataset) + self.__preliminary_checks( + models=models, + all_models=all_models, + train_dataset=train_dataset, + validation_dataset=validation_dataset, + ) ## Recurret variables - prediction_samples = self._setup_recurrent_variables(prediction_samples, closed_loop, connect) + prediction_samples = self._setup_recurrent_variables( + prediction_samples, closed_loop, connect + ) ## Get the dataset - XY_train, XY_val, XY_test = self._setup_dataset(train_dataset, validation_dataset, None, dataset, splits) - self.__check_needed_keys(train_data=XY_train, connect=connect, closed_loop=closed_loop) + XY_train, XY_val, XY_test = self._setup_dataset( + train_dataset, validation_dataset, None, dataset, splits + ) + self.__check_needed_keys( + train_data=XY_train, connect=connect, closed_loop=closed_loop + ) n_samples_train = next(iter(XY_train.values())).size(0) n_samples_val = next(iter(XY_val.values())).size(0) if XY_val else 0 @@ -330,7 +436,7 @@ def trainModel(self, *, if train_dataset is not None: train_tag = self._get_tag(train_dataset) val_tag = self._get_tag(validation_dataset) - else: ## splits is used + else: ## splits is used if dataset is None: dataset = list(self._data.keys()) tag = self._get_tag(dataset) @@ -340,22 +446,50 @@ def trainModel(self, *, train_indexes, val_indexes = [], [] if train_dataset is not None: - train_indexes, val_indexes = self._get_batch_indexes(train_dataset, n_samples_train, prediction_samples), self._get_batch_indexes(validation_dataset, n_samples_val, prediction_samples) + train_indexes, val_indexes = ( + self._get_batch_indexes( + train_dataset, n_samples_train, prediction_samples + ), + self._get_batch_indexes( + validation_dataset, n_samples_val, prediction_samples + ), + ) else: dataset = list(self._data.keys()) if dataset is None else dataset - train_indexes = self._get_batch_indexes(dataset, n_samples_train, prediction_samples) - check(len(train_indexes) > 0, ValueError, - 'The number of valid train samples is less than the number of prediction samples.') + train_indexes = self._get_batch_indexes( + dataset, n_samples_train, prediction_samples + ) + check( + len(train_indexes) > 0, + ValueError, + "The number of valid train samples is less than the number of prediction samples.", + ) if n_samples_val > 0: - val_indexes = self._get_batch_indexes(dataset, n_samples_train + n_samples_val, prediction_samples) - val_indexes = [i - n_samples_train for i in val_indexes if i >= n_samples_train] + val_indexes = self._get_batch_indexes( + dataset, n_samples_train + n_samples_val, prediction_samples + ) + val_indexes = [ + i - n_samples_train for i in val_indexes if i >= n_samples_train + ] if len(val_indexes) < 0: - log.warning('The number of valid validation samples is less than the number of prediction samples.') + log.warning( + "The number of valid validation samples is less than the number of prediction samples." + ) if n_samples_test > 0: - test_indexes = self._get_batch_indexes(dataset, n_samples_train + n_samples_val + n_samples_test, prediction_samples) - test_indexes = [i - (n_samples_train+n_samples_val)for i in test_indexes if i >= (n_samples_train+n_samples_val)] + test_indexes = self._get_batch_indexes( + dataset, + n_samples_train + n_samples_val + n_samples_test, + prediction_samples, + ) + test_indexes = [ + i - (n_samples_train + n_samples_val) + for i in test_indexes + if i >= (n_samples_train + n_samples_val) + ] if len(test_indexes) < 0: - log.warning('The number of valid test samples is less than the number of prediction samples.') + log.warning( + "The number of valid test samples is less than the number of prediction samples." + ) ## clip batch size and step train_batch_size = self._clip_batch_size(len(train_indexes), train_batch_size) @@ -365,32 +499,48 @@ def trainModel(self, *, val_step = self._clip_step(step, val_indexes, val_batch_size) ## Save the training parameters - self.running_parameters = {key:value for key,value in locals().items() if key not in ['self', 'kwargs', 'training_params', 'lr', 'lr_param']} + self.running_parameters = { + key: value + for key, value in locals().items() + if key not in ["self", "kwargs", "training_params", "lr", "lr_param"] + } ## Define the optimizer - self.__initialize_optimizer(models, optimizer, training_params, optimizer_params, optimizer_defaults, add_optimizer_defaults, add_optimizer_params, lr, lr_param) + self.__initialize_optimizer( + models, + optimizer, + training_params, + optimizer_params, + optimizer_defaults, + add_optimizer_defaults, + add_optimizer_params, + lr, + lr_param, + ) torch_optimizer = self.__optimizer.get_torch_optimizer() ## Define the loss functions self.__initialize_loss() ## Define mandatory inputs - mandatory_inputs, non_mandatory_inputs = self._get_mandatory_inputs(connect, closed_loop) + mandatory_inputs, non_mandatory_inputs = self._get_mandatory_inputs( + connect, closed_loop + ) ## Check close loop and connect self._clean_log_internal() ## Create the train, validation and test loss dictionaries train_losses, val_losses = {}, {} - for key in self._model_def['Minimizers'].keys(): + for key in self._model_def["Minimizers"].keys(): train_losses[key] = [] if n_samples_val > 0: val_losses[key] = [] ## Set the gradient to true if necessary - model_inputs = self._model_def['Inputs'] + model_inputs = self._model_def["Inputs"] for key in model_inputs.keys(): - if 'type' in model_inputs[key]: + if "type" in model_inputs[key]: if key in XY_train: XY_train[key].requires_grad_(True) if key in XY_val: @@ -415,27 +565,64 @@ def trainModel(self, *, ## TRAIN self._model.train() if prediction_samples >= 0: - losses = self._recurrent_inference(XY_train, train_indexes, train_batch_size, minimize_gain, prediction_samples, train_step, non_mandatory_inputs, mandatory_inputs, self.__loss_functions, shuffle=shuffle_data, optimizer=torch_optimizer) + losses = self._recurrent_inference( + XY_train, + train_indexes, + train_batch_size, + minimize_gain, + prediction_samples, + train_step, + non_mandatory_inputs, + mandatory_inputs, + self.__loss_functions, + shuffle=shuffle_data, + optimizer=torch_optimizer, + ) else: - losses = self._inference(XY_train, n_samples_train, train_batch_size, minimize_gain, self.__loss_functions, shuffle=shuffle_data, optimizer=torch_optimizer) + losses = self._inference( + XY_train, + n_samples_train, + train_batch_size, + minimize_gain, + self.__loss_functions, + shuffle=shuffle_data, + optimizer=torch_optimizer, + ) ## save the losses - for ind, key in enumerate(self._model_def['Minimizers'].keys()): + for ind, key in enumerate(self._model_def["Minimizers"].keys()): train_losses[key].append(torch.mean(losses[ind]).tolist()) if n_samples_val > 0: ## VALIDATION self._model.eval() setted_log_internal = self._log_internal - self._set_log_internal(False) # TODO To remove when the function is moved outside the train + self._set_log_internal( + False + ) # TODO To remove when the function is moved outside the train if prediction_samples >= 0: - losses = self._recurrent_inference(XY_val, val_indexes, val_batch_size, minimize_gain, prediction_samples, val_step, - non_mandatory_inputs, mandatory_inputs, self.__loss_functions) + losses = self._recurrent_inference( + XY_val, + val_indexes, + val_batch_size, + minimize_gain, + prediction_samples, + val_step, + non_mandatory_inputs, + mandatory_inputs, + self.__loss_functions, + ) else: - losses = self._inference(XY_val, n_samples_val, val_batch_size, minimize_gain, self.__loss_functions) + losses = self._inference( + XY_val, + n_samples_val, + val_batch_size, + minimize_gain, + self.__loss_functions, + ) self._set_log_internal(setted_log_internal) ## save the losses - for ind, key in enumerate(self._model_def['Minimizers'].keys()): + for ind, key in enumerate(self._model_def["Minimizers"].keys()): val_losses[key].append(torch.mean(losses[ind]).tolist()) if callable(select_model): @@ -446,7 +633,9 @@ def trainModel(self, *, ## Early-stopping if callable(early_stopping): if early_stopping(train_losses, val_losses, early_stopping_params): - log.info(f'Stopping the training at epoch {epoch} due to early stopping.') + log.info( + f"Stopping the training at epoch {epoch} due to early stopping." + ) break ## Visualize the training... @@ -457,10 +646,10 @@ def trainModel(self, *, end = time.time() self.visualizer.showTrainingTime(end - start) - for key in self._model_def['Minimizers'].keys(): - self._training[key] = {'train': train_losses[key]} + for key in self._model_def["Minimizers"].keys(): + self._training[key] = {"train": train_losses[key]} if n_samples_val > 0: - self._training[key]['val'] = val_losses[key] + self._training[key]["val"] = val_losses[key] self.visualizer.showEndTraining(num_of_epochs - 1, train_losses, val_losses) ## Select the model @@ -469,11 +658,13 @@ def trainModel(self, *, # The model selected is updated for the last time by the final batch; # so the minimum loss (selected model) is referred to the model before the last update. # If the batch is small compared to the dataset dimension the differences in the model are small. - log.warning('If not validation set is provided the selected model can differ from the optimal.') - log.info(f'Selected the model at the epoch {best_model_epoch + 1}.') + log.warning( + "If not validation set is provided the selected model can differ from the optimal." + ) + log.info(f"Selected the model at the epoch {best_model_epoch + 1}.") self._model = Model(selected_model_def) else: - log.info('The selected model is the LAST model of the training.') + log.info("The selected model is the LAST model of the training.") ## Remove virtual states self._remove_virtual_states(connect, closed_loop) @@ -481,5 +672,6 @@ def trainModel(self, *, ## Get trained model from torch and set the model_def self._model_def.updateParameters(self._model) -#from 685 -#from 840 \ No newline at end of file + +# from 685 +# from 840 diff --git a/nnodely/operators/validator.py b/src/nnodely/operators/validator.py similarity index 52% rename from nnodely/operators/validator.py rename to src/nnodely/operators/validator.py index a2bdc583..a8e38b49 100644 --- a/nnodely/operators/validator.py +++ b/src/nnodely/operators/validator.py @@ -1,16 +1,22 @@ -import torch, warnings +import torch +import warnings import numpy as np from nnodely.support.utils import ReadOnlyDict, get_batch_size from nnodely.basic.loss import CustomLoss from nnodely.operators.network import Network -from nnodely.support.utils import check, TORCH_DTYPE, enforce_types +from nnodely.support.utils import check, enforce_types + class Validator(Network): @enforce_types def __init__(self): - check(type(self) is not Validator, TypeError, "Validator class cannot be instantiated directly") + check( + type(self) is not Validator, + TypeError, + "Validator class cannot be instantiated directly", + ) super().__init__() # Validation Parameters @@ -26,18 +32,23 @@ def prediction(self): return ReadOnlyDict(self.__prediction) @enforce_types - def _analyze(self, - dataset: dict, - dataset_tag: str, - indexes: list = None, - minimize_gain: dict = {}, - closed_loop: dict = {}, - connect: dict = {}, - prediction_samples: int | str = 0, - step: int = 0, - batch_size: int | None = None - ) -> None: - with torch.enable_grad() if self._get_gradient_on_inference() else torch.inference_mode(): + def _analyze( + self, + dataset: dict, + dataset_tag: str, + indexes: list = None, + minimize_gain: dict = {}, + closed_loop: dict = {}, + connect: dict = {}, + prediction_samples: int | str = 0, + step: int = 0, + batch_size: int | None = None, + ) -> None: + with ( + torch.enable_grad() + if self._get_gradient_on_inference() + else torch.inference_mode() + ): self._model.eval() self.__performance[dataset_tag] = {} self.__prediction[dataset_tag] = {} @@ -48,36 +59,52 @@ def _analyze(self, # Create the losses losses = {} - for name, values in self._model_def['Minimizers'].items(): - losses[name] = CustomLoss(values['loss']) + for name, values in self._model_def["Minimizers"].items(): + losses[name] = CustomLoss(values["loss"]) - #data = self._get_data(dataset) + # data = self._get_data(dataset) n_samples = len(dataset[list(dataset.keys())[0]]) batch_size = get_batch_size(n_samples, batch_size, prediction_samples) - prediction_samples = self._setup_recurrent_variables(prediction_samples, closed_loop, connect) + prediction_samples = self._setup_recurrent_variables( + prediction_samples, closed_loop, connect + ) if prediction_samples >= 0: - mandatory_inputs, non_mandatory_inputs = self._get_mandatory_inputs(connect,closed_loop) + mandatory_inputs, non_mandatory_inputs = self._get_mandatory_inputs( + connect, closed_loop + ) idxs = [] for horizon_idx in range(prediction_samples + 1): idxs.append([]) - for key, value in self._model_def['Minimizers'].items(): + for key, value in self._model_def["Minimizers"].items(): total_losses[key], A[key], B[key] = [], [], [] for horizon_idx in range(prediction_samples + 1): A[key].append([]) B[key].append([]) ## Update with virtual states - self._model.update(closed_loop = closed_loop, connect = connect) - self._recurrent_inference(dataset, indexes, batch_size, minimize_gain, prediction_samples, - step, non_mandatory_inputs, mandatory_inputs, losses, - total_losses = total_losses, A = A, B = B, idxs = idxs) + self._model.update(closed_loop=closed_loop, connect=connect) + self._recurrent_inference( + dataset, + indexes, + batch_size, + minimize_gain, + prediction_samples, + step, + non_mandatory_inputs, + mandatory_inputs, + losses, + total_losses=total_losses, + A=A, + B=B, + idxs=idxs, + ) for horizon_idx in range(prediction_samples + 1): idxs[horizon_idx] = np.concatenate(idxs[horizon_idx]) - for key, value in self._model_def['Minimizers'].items(): + for key, value in self._model_def["Minimizers"].items(): for horizon_idx in range(prediction_samples + 1): if A is not None: A[key][horizon_idx] = np.concatenate(A[key][horizon_idx]) @@ -86,65 +113,102 @@ def _analyze(self, if total_losses is not None: total_losses[key] = np.mean(total_losses[key]) else: - for key, value in self._model_def['Minimizers'].items(): + for key, value in self._model_def["Minimizers"].items(): total_losses[key], A[key], B[key] = [], [], [] self._model.update(disconnect=True) - self._inference(dataset, n_samples, batch_size, minimize_gain, losses, - total_losses = total_losses, A = A, B = B) - - for key, value in self._model_def['Minimizers'].items(): + self._inference( + dataset, + n_samples, + batch_size, + minimize_gain, + losses, + total_losses=total_losses, + A=A, + B=B, + ) + + for key, value in self._model_def["Minimizers"].items(): A[key] = np.concatenate(A[key]) B[key] = np.concatenate(B[key]) total_losses[key] = np.mean(total_losses[key]) - for ind, (key, value) in enumerate(self._model_def['Minimizers'].items()): + for ind, (key, value) in enumerate(self._model_def["Minimizers"].items()): A_np = np.array(A[key]) B_np = np.array(B[key]) self.__performance[dataset_tag][key] = {} - self.__performance[dataset_tag][key][value['loss']] = np.mean(total_losses[key]).item() - self.__performance[dataset_tag][key]['fvu'] = {} + self.__performance[dataset_tag][key][value["loss"]] = np.mean( + total_losses[key] + ).item() + self.__performance[dataset_tag][key]["fvu"] = {} # Compute FVU residual = A_np - B_np error_var = np.var(residual) error_mean = np.mean(residual) - #error_var_manual = np.sum((residual-error_mean) ** 2) / (len(self.__prediction['B'][ind]) - 0) - #print(f"{key} var np:{new_error_var} and var manual:{error_var_manual}") + # error_var_manual = np.sum((residual-error_mean) ** 2) / (len(self.__prediction['B'][ind]) - 0) + # print(f"{key} var np:{new_error_var} and var manual:{error_var_manual}") with warnings.catch_warnings(record=True) as w: - self.__performance[dataset_tag][key]['fvu']['A'] = (error_var / np.var(A_np)).item() - self.__performance[dataset_tag][key]['fvu']['B'] = (error_var / np.var(B_np)).item() - if w and np.var(A_np) == 0.0 and np.var(B_np) == 0.0: - self.__performance[dataset_tag][key]['fvu']['A'] = np.nan - self.__performance[dataset_tag][key]['fvu']['B'] = np.nan - self.__performance[dataset_tag][key]['fvu']['total'] = np.mean([self.__performance[dataset_tag][key]['fvu']['A'],self.__performance[dataset_tag][key]['fvu']['B']]).item() + self.__performance[dataset_tag][key]["fvu"]["A"] = ( + error_var / np.var(A_np) + ).item() + self.__performance[dataset_tag][key]["fvu"]["B"] = ( + error_var / np.var(B_np) + ).item() + if w and np.var(A_np) == 0.0 and np.var(B_np) == 0.0: + self.__performance[dataset_tag][key]["fvu"]["A"] = np.nan + self.__performance[dataset_tag][key]["fvu"]["B"] = np.nan + self.__performance[dataset_tag][key]["fvu"]["total"] = np.mean( + [ + self.__performance[dataset_tag][key]["fvu"]["A"], + self.__performance[dataset_tag][key]["fvu"]["B"], + ] + ).item() # Compute AIC - #normal_dist = norm(0, error_var ** 0.5) - #probability_of_residual = normal_dist.pdf(residual) - #log_likelihood_first = sum(np.log(probability_of_residual)) - p1 = -len(residual)/2.0*np.log(2*np.pi) + # normal_dist = norm(0, error_var ** 0.5) + # probability_of_residual = normal_dist.pdf(residual) + # log_likelihood_first = sum(np.log(probability_of_residual)) + p1 = -len(residual) / 2.0 * np.log(2 * np.pi) with warnings.catch_warnings(record=True) as w: - p2 = -len(residual)/2.0*np.log(error_var) - p3 = -1 / (2.0 * error_var) * np.sum(residual ** 2) + p2 = -len(residual) / 2.0 * np.log(error_var) + p3 = -1 / (2.0 * error_var) * np.sum(residual**2) if w and p2 == np.float32(np.inf) and p3 == np.float32(-np.inf): p2 = p3 = 0.0 - log_likelihood = p1+p2+p3 - #print(f"{key} log likelihood second mode:{log_likelihood} = {p1}+{p2}+{p3} first mode: {log_likelihood_first}") - total_params = sum(p.numel() for p in self._model.parameters() if p.requires_grad) - #print(f"{key} total_params:{total_params}") - aic = - 2 * log_likelihood + 2 * total_params - #print(f"{key} aic:{aic}") - self.__performance[dataset_tag][key]['aic'] = {'value':aic,'total_params':total_params,'log_likelihood':log_likelihood} + log_likelihood = p1 + p2 + p3 + # print(f"{key} log likelihood second mode:{log_likelihood} = {p1}+{p2}+{p3} first mode: {log_likelihood_first}") + total_params = sum( + p.numel() for p in self._model.parameters() if p.requires_grad + ) + # print(f"{key} total_params:{total_params}") + aic = -2 * log_likelihood + 2 * total_params + # print(f"{key} aic:{aic}") + self.__performance[dataset_tag][key]["aic"] = { + "value": aic, + "total_params": total_params, + "log_likelihood": log_likelihood, + } # Prediction and target self.__prediction[dataset_tag][key] = {} - self.__prediction[dataset_tag][key]['A'] = A_np.tolist() - self.__prediction[dataset_tag][key]['B'] = B_np.tolist() + self.__prediction[dataset_tag][key]["A"] = A_np.tolist() + self.__prediction[dataset_tag][key]["B"] = B_np.tolist() if idxs is not None: - self.__prediction[dataset_tag]['idxs'] = np.array(idxs).tolist() - self.__performance[dataset_tag]['total'] = {} - self.__performance[dataset_tag]['total']['mean_error'] = np.mean([value for key,value in total_losses.items()]) - self.__performance[dataset_tag]['total']['fvu'] = np.mean([self.__performance[dataset_tag][key]['fvu']['total'] for key in self._model_def['Minimizers'].keys()]) - self.__performance[dataset_tag]['total']['aic'] = np.mean([self.__performance[dataset_tag][key]['aic']['value']for key in self._model_def['Minimizers'].keys()]) + self.__prediction[dataset_tag]["idxs"] = np.array(idxs).tolist() + self.__performance[dataset_tag]["total"] = {} + self.__performance[dataset_tag]["total"]["mean_error"] = np.mean( + [value for key, value in total_losses.items()] + ) + self.__performance[dataset_tag]["total"]["fvu"] = np.mean( + [ + self.__performance[dataset_tag][key]["fvu"]["total"] + for key in self._model_def["Minimizers"].keys() + ] + ) + self.__performance[dataset_tag]["total"]["aic"] = np.mean( + [ + self.__performance[dataset_tag][key]["aic"]["value"] + for key in self._model_def["Minimizers"].keys() + ] + ) self.visualizer.showResult(dataset_tag) @@ -185,13 +249,12 @@ def _analyze(self, # batch_size : # The batch size use for analyse the performance of the model on the provided dataset. - # """ # # Get the dataset if is None take all datasets # if dataset is None: # dataset = list(self._data.keys()) - # data = self._get_data(dataset) + # data = self._get_data(dataset) # n_samples = len(data[list(data.keys())[0]]) # data_tag = self._get_tag(dataset) if name is None else name # indexes = list(range(n_samples)) @@ -219,19 +282,20 @@ def _analyze(self, # if n_samples_test > 0: # self._analyze(data_test, f"{data_tag}_test", indexes, minimize_gain, closed_loop, connect, prediction_samples, step, batch_size) - @enforce_types - def analyzeModel(self, - dataset: str | list | dict | None = None, *, - tag: str | None = None, - splits: list | None = None, - minimize_gain: dict = {}, - closed_loop: dict = {}, - connect: dict = {}, - prediction_samples: int | str = 0, - step: int = 0, - batch_size: int | None = None - ) -> None: + def analyzeModel( + self, + dataset: str | list | dict | None = None, + *, + tag: str | None = None, + splits: list | None = None, + minimize_gain: dict = {}, + closed_loop: dict = {}, + connect: dict = {}, + prediction_samples: int | str = 0, + step: int = 0, + batch_size: int | None = None, + ) -> None: """ The function is used to analyze the performance of the model on the provided dataset. @@ -258,13 +322,15 @@ def analyzeModel(self, """ # Get the dataset if is None take all datasets if tag is None: - tag = dataset if isinstance(dataset, str) else 'default' + tag = dataset if isinstance(dataset, str) else "default" if dataset is None: dataset = list(self._data.keys()) - if splits: ## splits is used + if splits: ## splits is used ## Get the dataset - XY_train, XY_val, XY_test = self._setup_dataset(None, None, None, dataset, splits) + XY_train, XY_val, XY_test = self._setup_dataset( + None, None, None, dataset, splits + ) n_samples_train = next(iter(XY_train.values())).size(0) n_samples_val = next(iter(XY_val.values())).size(0) if XY_val else 0 n_samples_test = next(iter(XY_test.values())).size(0) if XY_test else 0 @@ -274,31 +340,82 @@ def analyzeModel(self, test_tag = f"{tag}_test" if n_samples_test > 0 else None train_indexes, val_indexes = [], [] - train_indexes = self._get_batch_indexes(dataset, n_samples_train, prediction_samples) - check(len(train_indexes) > 0, ValueError, - 'The number of valid train samples is less than the number of prediction samples.') + train_indexes = self._get_batch_indexes( + dataset, n_samples_train, prediction_samples + ) + check( + len(train_indexes) > 0, + ValueError, + "The number of valid train samples is less than the number of prediction samples.", + ) if n_samples_val > 0: - val_indexes = self._get_batch_indexes(dataset, n_samples_train + n_samples_val, prediction_samples) - val_indexes = [i - n_samples_train for i in val_indexes if i >= n_samples_train] + val_indexes = self._get_batch_indexes( + dataset, n_samples_train + n_samples_val, prediction_samples + ) + val_indexes = [ + i - n_samples_train for i in val_indexes if i >= n_samples_train + ] if n_samples_test > 0: - test_indexes = self._get_batch_indexes(dataset, n_samples_train + n_samples_val + n_samples_test, prediction_samples) - test_indexes = [i - (n_samples_train+n_samples_val)for i in test_indexes if i >= (n_samples_train+n_samples_val)] + test_indexes = self._get_batch_indexes( + dataset, + n_samples_train + n_samples_val + n_samples_test, + prediction_samples, + ) + test_indexes = [ + i - (n_samples_train + n_samples_val) + for i in test_indexes + if i >= (n_samples_train + n_samples_val) + ] ## Training set Results - self._analyze(XY_train, dataset_tag=train_tag, indexes=train_indexes, minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=step, batch_size=batch_size) + self._analyze( + XY_train, + dataset_tag=train_tag, + indexes=train_indexes, + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=step, + batch_size=batch_size, + ) ## Validation set Results if n_samples_val > 0: - self._analyze(XY_val, dataset_tag=val_tag, indexes=val_indexes, minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=step, batch_size=batch_size) + self._analyze( + XY_val, + dataset_tag=val_tag, + indexes=val_indexes, + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=step, + batch_size=batch_size, + ) ## Test set Results if n_samples_test > 0: - self._analyze(XY_test, dataset_tag=test_tag, indexes=test_indexes, minimize_gain=minimize_gain, - closed_loop=closed_loop, connect=connect, prediction_samples=prediction_samples, - step=step, batch_size=batch_size) + self._analyze( + XY_test, + dataset_tag=test_tag, + indexes=test_indexes, + minimize_gain=minimize_gain, + closed_loop=closed_loop, + connect=connect, + prediction_samples=prediction_samples, + step=step, + batch_size=batch_size, + ) else: - data = self._get_data(dataset) + data = self._get_data(dataset) n_samples = next(iter(data.values())).size(0) indexes = self._get_batch_indexes(dataset, n_samples, prediction_samples) - self._analyze(data, tag, indexes, minimize_gain, closed_loop, connect, prediction_samples, step, batch_size) \ No newline at end of file + self._analyze( + data, + tag, + indexes, + minimize_gain, + closed_loop, + connect, + prediction_samples, + step, + batch_size, + ) diff --git a/nnodely/support/__init__.py b/src/nnodely/support/__init__.py similarity index 100% rename from nnodely/support/__init__.py rename to src/nnodely/support/__init__.py diff --git a/nnodely/support/earlystopping.py b/src/nnodely/support/earlystopping.py similarity index 83% rename from nnodely/support/earlystopping.py rename to src/nnodely/support/earlystopping.py index dae6cd2e..b65c6a12 100644 --- a/nnodely/support/earlystopping.py +++ b/src/nnodely/support/earlystopping.py @@ -22,20 +22,24 @@ def early_stop_patience(train_losses, val_losses, params): bool True if training should be stopped early, False otherwise. """ - patience = params['patience'] if 'patience' in params.keys() else 50 + patience = params["patience"] if "patience" in params.keys() else 50 if val_losses: losses = val_losses else: # if there is no validation set, use the training losses losses = train_losses - if 'error' in params.keys(): + if "error" in params.keys(): # if the type of loss to be used is provided by the user - losses_use = losses[params['error']] + losses_use = losses[params["error"]] else: # take the mean of all the losses for all the keys of the dictionary import numpy as np - losses_use = [np.mean([losses[key][index] for key in losses.keys()]) for index in range(len(losses[list(losses.keys())[0]]))] + + losses_use = [ + np.mean([losses[key][index] for key in losses.keys()]) + for index in range(len(losses[list(losses.keys())[0]])) + ] if len(losses_use) > patience: # index of the minimum validation loss min_val_loss_index = losses_use.index(min(losses_use)) @@ -69,8 +73,12 @@ def select_best_model(train_losses, val_losses, params): # if there is no validation set, use the training losses losses = train_losses import numpy as np - losses_use = [np.mean([losses[key][index] for key in losses.keys()]) for index in range(len(losses[list(losses.keys())[0]]))] - if len(losses_use)-1 == losses_use.index(min(losses_use)): + + losses_use = [ + np.mean([losses[key][index] for key in losses.keys()]) + for index in range(len(losses[list(losses.keys())[0]])) + ] + if len(losses_use) - 1 == losses_use.index(min(losses_use)): return True else: return False @@ -94,9 +102,11 @@ def mean_stopping(train_losses, val_losses, params): bool True if training should be stopped early, False otherwise. """ - tol = params['tol'] if 'tol' in params.keys() else 0.001 + tol = params["tol"] if "tol" in params.keys() else 0.001 if val_losses: - for (train_loss_name, train_loss_value), (val_loss_name, val_loss_value) in zip(train_losses.items(), val_losses.items()): + for (train_loss_name, train_loss_value), (val_loss_name, val_loss_value) in zip( + train_losses.items(), val_losses.items() + ): if abs(train_loss_value[-1] - val_loss_value[-1]) < tol: return True else: @@ -105,6 +115,7 @@ def mean_stopping(train_losses, val_losses, params): return True return False + def standard_early_stopping(train_losses, val_losses, params): """ Determines whether to stop training early based on training and validation losses. @@ -123,12 +134,14 @@ def standard_early_stopping(train_losses, val_losses, params): bool True if training should be stopped early, False otherwise. """ - n = params['tol'] if 'tol' in params.keys() else 10 + n = params["tol"] if "tol" in params.keys() else 10 if val_losses: - for (_, train_loss_value), (_, val_loss_value) in zip(train_losses.items(), val_losses.items()): + for (_, train_loss_value), (_, val_loss_value) in zip( + train_losses.items(), val_losses.items() + ): if (len(train_loss_value) <= n) and (len(val_loss_value) <= n): return False - + tol = 0.0 for train_loss, val_loss in zip(train_loss_value[-n:], val_loss_value[-n:]): if abs(train_loss - val_loss) > tol: @@ -137,13 +150,12 @@ def standard_early_stopping(train_losses, val_losses, params): return False else: for _, loss_value in train_losses.items(): - if (len(loss_value) <= n): + if len(loss_value) <= n: return False - + tol = loss_value[-n] - for loss in loss_value[-n+1:]: + for loss in loss_value[-n + 1 :]: if loss < tol: return False - + return True - \ No newline at end of file diff --git a/src/nnodely/support/fixstepsolver.py b/src/nnodely/support/fixstepsolver.py new file mode 100644 index 00000000..7f45a1b4 --- /dev/null +++ b/src/nnodely/support/fixstepsolver.py @@ -0,0 +1,48 @@ +from nnodely.layers.parameter import SampleTime + + +class FixedStepSolver: + def __init__(self, int_name: str | None = None, der_name: str | None = None): + self.dt = SampleTime() + self.int_name = int_name + self.der_name = der_name + + +class Euler(FixedStepSolver): + def __init__(self, int_name: str | None = None, der_name: str | None = None): + super().__init__(int_name, der_name) + + def integrate(self, obj): + from nnodely.layers.input import Input + + integral = Input(self.int_name, dimensions=obj.dim["dim"]) + return (integral.last() + obj * self.dt).closedLoop(integral) + + def derivate(self, obj): + from nnodely.layers.input import Input + + obj = Input(self.int_name, dimensions=obj.dim["dim"]).connect(obj) + return (obj.last() - obj.sw([-2, -1])) / self.dt + + +class Trapezoidal(FixedStepSolver): + def __init__(self, int_name: str | None = None, der_name: str | None = None): + super().__init__(int_name, der_name) + + def integrate(self, obj): + from nnodely.layers.input import Input + + integral = Input(self.int_name, dimensions=obj.dim["dim"]) + obj = Input(self.der_name, dimensions=obj.dim["dim"]).connect(obj) + return ( + integral.last() + (obj.last() + obj.sw([-2, -1])) * 0.5 * self.dt + ).closedLoop(integral) + + def derivate(self, obj): + from nnodely.layers.input import Input + + obj = Input(self.int_name, dimensions=obj.dim["dim"]).connect(obj) + derivative = Input(self.der_name, dimensions=obj.dim["dim"]) + return ( + ((obj.last() - obj.sw([-2, -1])) * 2.0) / self.dt - derivative.last() + ).closedLoop(derivative) diff --git a/nnodely/support/initializer.py b/src/nnodely/support/initializer.py similarity index 63% rename from nnodely/support/initializer.py rename to src/nnodely/support/initializer.py index 133d495e..10704e0b 100644 --- a/nnodely/support/initializer.py +++ b/src/nnodely/support/initializer.py @@ -1,5 +1,4 @@ - -def init_constant(indexes, params_size, dict_param = {'value':1}): +def init_constant(indexes, params_size, dict_param={"value": 1}): """ Initializes parameters to a constant value. @@ -10,9 +9,12 @@ def init_constant(indexes, params_size, dict_param = {'value':1}): value : int or float The constant value to initialize the parameters with. """ - return dict_param['value'] + return dict_param["value"] + -def init_negexp(indexes, params_size, dict_param = {'size_index':0, 'first_value':1, 'lambda':3}): +def init_negexp( + indexes, params_size, dict_param={"size_index": 0, "first_value": 1, "lambda": 3} +): """ Initializes parameters using a negative decay exponential function. @@ -32,12 +34,27 @@ def init_negexp(indexes, params_size, dict_param = {'size_index':0, 'first_value The decay rate parameter of the exponential function. """ import numpy as np - size_index = dict_param['size_index'] + + size_index = dict_param["size_index"] # check if the size of the list of parameters is 1, to avoid a division by zero - x = 1 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1) - return dict_param['first_value']*np.exp(-dict_param['lambda']*(1-x)) + x = ( + 1 + if params_size[size_index] - 1 == 0 + else indexes[size_index] / (params_size[size_index] - 1) + ) + return dict_param["first_value"] * np.exp(-dict_param["lambda"] * (1 - x)) -def init_exp(indexes, params_size, dict_param = {'size_index':0, 'max_value':1, 'lambda':3, 'monotonicity':'decreasing'}): + +def init_exp( + indexes, + params_size, + dict_param={ + "size_index": 0, + "max_value": 1, + "lambda": 3, + "monotonicity": "decreasing", + }, +): """ Initializes parameters using an increasing or decreasing exponential function. @@ -64,21 +81,37 @@ def init_exp(indexes, params_size, dict_param = {'size_index':0, 'max_value':1, If the monotonicity is not 'increasing' or 'decreasing'. """ import numpy as np - size_index = dict_param['size_index'] - monotonicity = dict_param['monotonicity'] - if monotonicity == 'increasing': + + size_index = dict_param["size_index"] + monotonicity = dict_param["monotonicity"] + if monotonicity == "increasing": # increasing exponential, the 'max_value' is the value at x=1, i.e, at the end of the range - x = 1 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1) - out = dict_param['max_value']*np.exp(dict_param['lambda']*(x-1)) - elif monotonicity == 'decreasing': + x = ( + 1 + if params_size[size_index] - 1 == 0 + else indexes[size_index] / (params_size[size_index] - 1) + ) + out = dict_param["max_value"] * np.exp(dict_param["lambda"] * (x - 1)) + elif monotonicity == "decreasing": # decreasing exponential, the 'max_value' is the value at x=0, i.e, at the beginning of the range - x = 0 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1) - out = dict_param['max_value']*np.exp(-dict_param['lambda']*x) + x = ( + 0 + if params_size[size_index] - 1 == 0 + else indexes[size_index] / (params_size[size_index] - 1) + ) + out = dict_param["max_value"] * np.exp(-dict_param["lambda"] * x) else: - raise ValueError('The parameter monotonicity must be either increasing or decreasing.') + raise ValueError( + "The parameter monotonicity must be either increasing or decreasing." + ) return out -def init_lin(indexes, params_size, dict_param = {'size_index':0, 'first_value':1, 'last_value':0}): + +def init_lin( + indexes, + params_size, + dict_param={"size_index": 0, "first_value": 1, "last_value": 0}, +): """ Initializes parameters using a linear function. @@ -97,6 +130,12 @@ def init_lin(indexes, params_size, dict_param = {'size_index':0, 'first_value':1 last_value : int or float The value at the end of the range. """ - size_index = dict_param['size_index'] - x = 0 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1) - return (dict_param['last_value'] - dict_param['first_value']) * x + dict_param['first_value'] + size_index = dict_param["size_index"] + x = ( + 0 + if params_size[size_index] - 1 == 0 + else indexes[size_index] / (params_size[size_index] - 1) + ) + return (dict_param["last_value"] - dict_param["first_value"]) * x + dict_param[ + "first_value" + ] diff --git a/src/nnodely/support/jsonutils.py b/src/nnodely/support/jsonutils.py new file mode 100644 index 00000000..04370b0d --- /dev/null +++ b/src/nnodely/support/jsonutils.py @@ -0,0 +1,755 @@ +import copy +from pprint import pformat + +from nnodely.support.utils import check +from nnodely.support.logger import logging, nnLogger + +log = nnLogger(__name__, logging.WARNING) + +# Sections whose inner *entries* are mutated in place by callers after merge() and +# therefore must be detached (shallow-copied) in the result: +# Inputs -> connect / closedLoop / local / ns / ntot +# Functions -> Fuzzify / LocalModel / dim_out / params_and_consts +# Parameters -> values / init_values / init_fun / dim +# Constants -> values +# All other sections (Relations / Outputs / Models / Minimizers) are append-only at +# the section level, so their inner values are shared between operands and result. +_MUTABLE_ENTRY_SECTIONS = frozenset(("Inputs", "Functions", "Parameters", "Constants")) + + +def get_window(obj): + """Return the window key (``'tw'``/``'sw'``) of ``obj.dim``, or ``None``.""" + return "tw" if "tw" in obj.dim else ("sw" if "sw" in obj.dim else None) + + +def _shallow_copy_entries(d): + """Return a fresh dict where dict-typed values are shallow-copied.""" + if not d: + return {} + return {k: dict(v) if isinstance(v, dict) else v for k, v in d.items()} + + +def _window_union(a, b): + """Return ``[min(a[0], b[0]), max(a[1], b[1])]`` without mutating *a* or *b*.""" + return [a[0] if a[0] <= b[0] else b[0], a[1] if a[1] >= b[1] else b[1]] + + +def _overlay_with_windows(dst, src): + """Overlay *src* onto a fresh copy of *dst*; union ``tw``/``sw`` lists. + + Used for the ``Info`` section and for individual ``Inputs`` descriptors, + which share the same shape (flat dict of scalars/2-element windows). + """ + out = dict(dst) if isinstance(dst, dict) else {} + if not isinstance(src, dict) or not src: + return out + for k, v in src.items(): + if ( + (k == "tw" or k == "sw") + and isinstance(v, list) + and isinstance(out.get(k), list) + ): + out[k] = _window_union(out[k], v) + else: + out[k] = v + return out + + +def _merge_section(sec, dst, src): + """Merge a single named section of the model JSON. + + Three regimes: + * ``Info`` — flat dict: scalar overlay + ``tw``/``sw`` window union. + * ``_MUTABLE_ENTRY_SECTIONS`` — union of named entries; each surviving + entry is shallow-copied so callers can mutate the result. + ``Inputs`` additionally union'es per-entry windows. + * Everything else (``Relations`` / ``Outputs`` / ``Models`` / ``Minimizers``): + union of named entries; inner values are *shared* with the operands + (callers only add new keys, never mutate inner values in place). + """ + if sec == "Info": + return _overlay_with_windows(dst, src) + + if sec in _MUTABLE_ENTRY_SECTIONS: + out = _shallow_copy_entries(dst) + if not src: + return out + if sec == "Inputs": + for k, sv in src.items(): + out[k] = _overlay_with_windows(out.get(k), sv) + else: + for k, sv in src.items(): + out[k] = dict(sv) if isinstance(sv, dict) else sv + return out + + # Shared-value sections: dict-union if both are dicts, else source overrides. + if isinstance(dst, dict) and isinstance(src, dict): + out = dict(dst) + out.update(src) + return out + if isinstance(src, dict): + return dict(src) + if isinstance(dst, dict): + return dict(dst) + return src if src is not None else dst + + +def _iter_overlap(a, b): + """Yield ``(key, a[key], b[key])`` for keys present in both dicts, scanning + the smaller side.""" + if not a or not b: + return + small, big = (a, b) if len(a) <= len(b) else (b, a) + for key, value in small.items(): + other = big.get(key) + if other is not None: + yield key, value, other + + +def _validate_compat(source, destination): + """Verify that overlapping Functions/Parameters agree on their declared shape + (``n_input``, ``dim``, ``tw``/``sw``).""" + for key, a, b in _iter_overlap( + source.get("Functions") or {}, destination.get("Functions") or {} + ): + if a and b and "n_input" in a and "n_input" in b: + check( + a["n_input"] == b["n_input"], + TypeError, + f"The ParamFun {key} is present multiple times, with different number of inputs. " + f"The ParamFun {key} is called with {a['n_input']} parameters and with {b['n_input']} parameters.", + ) + + for key, a, b in _iter_overlap( + source.get("Parameters") or {}, destination.get("Parameters") or {} + ): + if "dim" in a and "dim" in b: + check( + a["dim"] == b["dim"], + TypeError, + f"The Parameter {key} is present multiple times, with different dimensions. " + f"The Parameter {key} is called with {a['dim']} dimension and with {b['dim']} dimension.", + ) + wa = "tw" if "tw" in a else ("sw" if "sw" in a else None) + if wa is None: + continue + wb = "tw" if "tw" in b else ("sw" if "sw" in b else None) + check( + wa == wb and a[wa] == b[wb], + TypeError, + f"The Parameter {key} is present multiple times, with different window. " + f"The Parameter {key} is called with {wa}={a[wa]} dimension and with {wb}={b[wb] if wb else None} dimension.", + ) + + +def merge(source, destination): + """ + Combine two model JSONs into a fresh, independent dict. + + Complexity: ``O(|sections| + |mutable entries| + |new keys in source|)`` + per call. No recursion, no full deep-copy of *destination*. Inner values + of named sections are shared with the operands wherever safe; entries in + ``Inputs``/``Functions``/``Parameters``/``Constants`` are shallow-copied + because callers mutate them in place. ``tw``/``sw`` ranges are union'd. + """ + if source is destination: + return {sec: _merge_section(sec, v, None) for sec, v in destination.items()} + + _validate_compat(source, destination) + + sections = set(destination) | set(source) + result = { + sec: _merge_section(sec, destination.get(sec), source.get(sec)) + for sec in sections + } + + if log.isEnabledFor(logging.DEBUG): + log.debug("Merge Source\n" + pformat(source)) + log.debug("Merge Destination\n" + pformat(destination)) + log.debug("Merge Result\n" + pformat(result)) + return result + + +def get_models_json(json): + model_json = {} + model_json["Parameters"] = list(json["Parameters"].keys()) + model_json["Constants"] = list(json["Constants"].keys()) + model_json["Inputs"] = list(json["Inputs"].keys()) + model_json["Outputs"] = list(json["Outputs"].keys()) + model_json["Functions"] = list(json["Functions"].keys()) + model_json["Relations"] = list(json["Relations"].keys()) + return model_json + + +def check_model(json): + all_inputs = json["Inputs"].keys() + all_outputs = json["Outputs"].keys() + + from nnodely.basic.relation import MAIN_JSON + + subjson = MAIN_JSON + for name in all_outputs: + subjson = merge(subjson, subjson_from_output(json, name)) + needed_inputs = subjson["Inputs"].keys() + extenal_inputs = set(all_inputs) - set(needed_inputs) + + check( + all_inputs == needed_inputs, + RuntimeError, + f"Connect or close loop operation on the inputs {list(extenal_inputs)}, that are not used in the model.", + ) + return json + + +def binary_cheks(self, obj1, obj2, name): + from nnodely.basic.relation import Stream, toStream + + obj1, obj2 = toStream(obj1), toStream(obj2) + check( + type(obj1) is Stream, + TypeError, + f"The type of {obj1} is {type(obj1)} and is not supported for add operation.", + ) + check( + type(obj2) is Stream, + TypeError, + f"The type of {obj2} is {type(obj2)} and is not supported for add operation.", + ) + window_obj1 = get_window(obj1) + window_obj2 = get_window(obj2) + if window_obj1 is not None and window_obj2 is not None: + check( + window_obj1 == window_obj2, + TypeError, + f"For {name} the time window type must match or None but they were {window_obj1} and {window_obj2}.", + ) + check( + obj1.dim[window_obj1] == obj2.dim[window_obj2], + ValueError, + f"For {name} the time window must match or None but they were {window_obj1}={obj1.dim[window_obj1]} and {window_obj2}={obj2.dim[window_obj2]}.", + ) + check( + obj1.dim["dim"] == obj2.dim["dim"] + or obj1.dim == {"dim": 1} + or obj2.dim == {"dim": 1}, + ValueError, + f"For {name} the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.", + ) + dim = obj1.dim | obj2.dim + dim["dim"] = max(obj1.dim["dim"], obj2.dim["dim"]) + return obj1, obj2, dim + + +def subjson_from_relation(json, relation): + # Read-only DAG walk with iterative DFS + visited memo (relations form a DAG with + # heavy reuse, e.g. RK4 expansions: recursive untracked walks blow up exponentially). + inputs = set() + relations = set() + constants = set() + parameters = set() + functions = set() + + j_inputs = json["Inputs"] + j_constants = json["Constants"] + j_parameters = json["Parameters"] + j_functions = json["Functions"] + j_relations = json["Relations"] + + visited = set() + stack = [relation] + while stack: + rel = stack.pop() + if rel in visited: + continue + visited.add(rel) + if rel in j_inputs: + inputs.add(rel) + entry = j_inputs[rel] + if "connect" in entry and entry.get("local") == 1: + stack.append(entry["connect"]) + if "closed_loop" in entry and entry.get("local") == 1: + stack.append(entry["closed_loop"]) + elif rel in j_constants: + constants.add(rel) + elif rel in j_parameters: + parameters.add(rel) + elif rel in j_functions: + functions.add(rel) + f_entry = j_functions[rel] + pcs = ( + f_entry.get("params_and_consts") if isinstance(f_entry, dict) else None + ) + if pcs: + stack.extend(pcs) + elif rel in j_relations: + relations.add(rel) + r_entry = j_relations[rel] + stack.extend(r_entry[1]) + kind = r_entry[0] + if kind in ("Fir", "Linear", "Fuzzify", "ParamFun") and len(r_entry) > 2: + stack.extend(r_entry[2:]) + + from nnodely.basic.relation import MAIN_JSON + + sub_json = copy.deepcopy(MAIN_JSON) + sub_json["Relations"] = { + key: value for key, value in json["Relations"].items() if key in relations + } + sub_json["Inputs"] = { + key: value for key, value in json["Inputs"].items() if key in inputs + } + sub_json["Constants"] = { + key: value for key, value in json["Constants"].items() if key in constants + } + sub_json["Parameters"] = { + key: value for key, value in json["Parameters"].items() if key in parameters + } + sub_json["Functions"] = { + key: value for key, value in json["Functions"].items() if key in functions + } + sub_json["Outputs"] = {} + sub_json["Info"] = {} + return sub_json + + +def subjson_from_output(json, outputs: str | list): + from nnodely.basic.relation import MAIN_JSON + + sub_json = copy.deepcopy(MAIN_JSON) + if type(outputs) is str: + outputs = [outputs] + for output in outputs: + sub_json = merge(sub_json, subjson_from_relation(json, json["Outputs"][output])) + sub_json["Outputs"][output] = json["Outputs"][output] + return sub_json + + +def subjson_from_model(json, models: str | list): + from nnodely.basic.relation import MAIN_JSON + + sub_json = copy.deepcopy(MAIN_JSON) + models_names = ( + set([json["Models"]]) + if type(json["Models"]) is str + else set(json["Models"].keys()) + ) + if type(models) is str or len(models) == 1: + if len(models) == 1: + models = models[0] + check(models in models_names, AttributeError, f"Model [{models}] not found!") + if type(json["Models"]) is str: + outputs = set(json["Outputs"].keys()) + else: + outputs = set(json["Models"][models]["Outputs"]) + sub_json["Models"] = models + else: + outputs = set() + sub_json["Models"] = {} + for model in models: + check(model in models_names, AttributeError, f"Model [{model}] not found!") + outputs |= set(json["Models"][model]["Outputs"]) + sub_json["Models"][model] = { + key: value for key, value in json["Models"][model].items() + } + + # Remove the extern connections not keys in the graph + final_json = merge(sub_json, subjson_from_output(json, outputs)) + for key, value in final_json["Inputs"].items(): + if "connect" in value and ( + value["local"] == 0 + and value["connect"] not in final_json["Relations"].keys() + ): + del final_json["Inputs"][key]["connect"] + del final_json["Inputs"][key]["local"] + log.warning( + f'The input {key} is "connect" outside the model connection removed for subjson' + ) + if "closedLoop" in value and ( + value["local"] == 0 + and value["closedLoop"] not in final_json["Relations"].keys() + ): + del final_json["Inputs"][key]["closedLoop"] + del final_json["Inputs"][key]["local"] + log.warning( + f'The input {key} is "closedLoop" outside the model connection removed for subjson' + ) + return final_json + + +def subjson_from_minimize(json, minimizers: str | list): + from nnodely.basic.relation import MAIN_JSON + + sub_json = copy.deepcopy(MAIN_JSON) + + if "Minimizers" in json: + rel_A = [json["Minimizers"][key]["A"] for key in minimizers] + rel_B = [json["Minimizers"][key]["B"] for key in minimizers] + relations_name = set(rel_A) | set(rel_B) + for rel_name in relations_name: + minimizers_json = subjson_from_relation(json, rel_name) + sub_json = merge(sub_json, minimizers_json) + sub_json["Minimizers"] = {key: json["Minimizers"][key] for key in minimizers} + + return sub_json + + +def stream_to_str(obj, type="Stream"): + from nnodely.visualizer.emptyvisualizer import color, GREEN + from pprint import pformat + + stream = f" {type} " + stream_name = f" {obj.name} {obj.dim} " + + title = color((stream).center(80, "="), GREEN, True) + json = color(pformat(obj.json), GREEN) + stream = color((stream_name).center(80, "-"), GREEN, True) + return title + "\n" + json + "\n" + stream + + +def plot_structure(json, filename="nnodely_graph", library="matplotlib", view=True): + # json = self.modely.json if json is None else json + # if json is None: + # raise ValueError("No JSON model definition provided. Please provide a valid JSON model definition.") + if library not in ["matplotlib", "graphviz"]: + raise ValueError("Invalid library specified. Use 'matplotlib' or 'graphviz'.") + if library == "matplotlib": + plot_matplotlib_structure(json, filename, view=view) + elif library == "graphviz": + plot_graphviz_structure(json, filename, view=view) + + +def plot_matplotlib_structure(json, filename="nnodely_graph", view=True): + import matplotlib.pyplot as plt + from matplotlib import patches + from matplotlib.lines import Line2D + + layer_positions = {} + x, y = 0, 0 # Initial position + dy, dx = 1.5, 2.5 # Spacing + + ## Layer Inputs: + for input_name, input_type in json["Inputs"].items(): + layer_positions[input_name] = (x, y) + y -= dy + for constant_name in json["Constants"].keys(): + layer_positions[constant_name] = (x, y) + y -= dy + y_limit = abs(y) + + # Layers Relations: + available_inputs = list(json["Inputs"].keys() | json["Constants"].keys()) + available_outputs = list(set(json["Outputs"].values())) + while available_outputs: + x += dx + y = 0 + inputs_to_add, outputs_to_remove = [], [] + for relation_name, (relation_type, dependencies, *_) in json[ + "Relations" + ].items(): + if all(dep in available_inputs for dep in dependencies) and ( + relation_name not in available_inputs + ): + inputs_to_add.append(relation_name) + if relation_name in available_outputs: + outputs_to_remove.append(relation_name) + layer_positions[relation_name] = (x, y) + y -= dy + y_limit = max(y_limit, abs(y)) + available_inputs.extend(inputs_to_add) + available_outputs = [ + out for out in available_outputs if out not in outputs_to_remove + ] + + ## Layer Outputs: + x += dx + y = 0 + for idx, output_name in enumerate(json["Outputs"].keys()): + layer_positions[output_name] = (x, y) + y -= dy # Move down for the next input + x_limit = abs(x) + y_limit = max(y_limit, abs(y)) + + # Create the plot + fig, ax = plt.subplots(figsize=(x_limit, y_limit)) + # fig.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.05) + + # Plot rectangles for each layer + colors, labels = ( + ["lightgreen", "lightblue", "orange", "lightgray"], + ["Inputs", "Relations", "Outputs", "Constants"], + ) + legend_info = [ + patches.Patch(facecolor=color, edgecolor="black", label=label) + for color, label in zip(colors, labels) + ] + for layer in ( + json["Inputs"].keys() + | json["Outputs"].keys() + | json["Relations"].keys() + | json["Constants"].keys() + ): + x1, y1 = layer_positions[layer] + if layer in json["Inputs"].keys(): + color = "lightgreen" + tag = f"{layer}\ndim: {json['Inputs'][layer]['dim']}\nWindow: {json['Inputs'][layer]['ntot']}" + elif layer in json["Outputs"].keys(): + color = "orange" + tag = layer + elif layer in json["Constants"].keys(): + color = "lightgray" + tag = f"{layer}\ndim: {json['Constants'][layer]['dim']}" + else: + color = "lightblue" + tag = f"{json['Relations'][layer][0]}\n({layer})" + rect = patches.Rectangle((x1, y1), 2, 1, edgecolor="black", facecolor=color) + ax.add_patch(rect) + ax.text( + x1 + 1, + y1 + 0.5, + f"{tag}", + ha="center", + va="center", + fontsize=8, + fontweight="bold", + ) + + # Draw arrows for dependencies + for layer, (_, dependencies, *_) in json["Relations"].items(): + x1, y1 = layer_positions[layer] # Get position of the current layer + for dep in dependencies: + if dep in layer_positions: + x2, y2 = layer_positions[dep] # Get position of the dependent layer + ax.annotate( + "", + xy=(x1, y1), + xytext=(x2 + 2, y2 + 0.5), + arrowprops=dict(arrowstyle="->", color="black", lw=1), + ) + for out_name, rel_name in json["Outputs"].items(): + x1, y1 = layer_positions[out_name] + x2, y2 = layer_positions[rel_name] + ax.annotate( + "", + xy=(x1, y1 + 0.5), + xytext=(x2 + 2, y2 + 0.5), + arrowprops=dict(arrowstyle="->", color="black", lw=1), + ) + for key, state in json["Inputs"].items(): + if "closedLoop" in state.keys(): + x1, y1 = layer_positions[key] + x2, y2 = layer_positions[state["closedLoop"]] + # ax.annotate("", xy=(x2+1, y2), xytext=(x2+1, y_limit), arrowprops=dict(arrowstyle="-", color='red', lw=1, linestyle='dashed')) + ax.add_patch( + patches.FancyArrowPatch( + (x2 + 1, y2), + (x2 + 1, -y_limit), + arrowstyle="-", + mutation_scale=15, + color="red", + linestyle="dashed", + ) + ) + ax.add_patch( + patches.FancyArrowPatch( + (x2 + 1, -y_limit), + (x1 - 1, -y_limit), + arrowstyle="-", + mutation_scale=15, + color="red", + linestyle="dashed", + ) + ) + ax.add_patch( + patches.FancyArrowPatch( + (x1 - 1, -y_limit), + (x1 - 1, y1 + 0.5), + arrowstyle="-", + mutation_scale=15, + color="red", + linestyle="dashed", + ) + ) + ax.add_patch( + patches.FancyArrowPatch( + (x1 - 1, y1 + 0.5), + (x1, y1 + 0.5), + arrowstyle="->", + mutation_scale=15, + color="red", + linestyle="dashed", + ) + ) + elif "connect" in state.keys(): + x1, y1 = layer_positions[key] + x2, y2 = layer_positions[state["connect"]] + ax.add_patch( + patches.FancyArrowPatch( + (x1, y1), + (x2, y2), + arrowstyle="->", + mutation_scale=15, + color="green", + linestyle="dashed", + ) + ) + + legend_info.extend( + [ + Line2D([0], [0], color="black", lw=2, label="Dependency"), + Line2D( + [0], [0], color="red", lw=2, linestyle="dashed", label="Closed Loop" + ), + Line2D([0], [0], color="green", lw=2, linestyle="dashed", label="Connect"), + ] + ) + + # Adjust the plot limits + ax.set_xlim(-dx, x_limit + dx) + ax.set_ylim(-y_limit, dy) + ax.set_aspect("equal") + ax.legend(handles=legend_info, loc="lower right") + ax.axis("off") # Hide axes + + plt.title( + f"Neural Network Diagram - Sampling [{json['Info']['SampleTime']}]", + fontsize=12, + fontweight="bold", + ) + ## Save the figure + plt.savefig(filename, format="png", bbox_inches="tight") + if view: + plt.show() + + +def plot_graphviz_structure( + json, filename="nnodely_graph", view=True +): # pragma: no cover + import shutil + from graphviz import view + from graphviz import Digraph + + # Check if Graphviz is installed + if shutil.which("dot") is None: + # raise RuntimeError( + # "Graphviz does not appear to be installed on your system. " + # "Please install it from https://graphviz.org/download/" + # ) + log.warning( + "Graphviz does not appear to be installed on your system. " + "Please install it from https://graphviz.org/download/" + ) + return + + dot = Digraph(comment="Structured Neural Network") + + # Set graph attributes for top-down layout and style + dot.attr(rankdir="LR", size="21") + dot.attr( + "node", shape="box", style="filled", color="lightgray", fontname="Helvetica" + ) + + # Add metadata/info box + if "Info" in json: + info = json["Info"] + info_text = "\n".join([f"{k}: {v}" for k, v in info.items()]) + dot.node( + "INFO_BOX", + label=f"Model Info\n{info_text}", + shape="note", + fillcolor="white", + fontsize="10", + ) + + # Add input nodes + for inp, data in json["Inputs"].items(): + dim = data["dim"] + window = data["sw"] if "sw" in data else data["tw"] + window_tag = "sw" if "sw" in data else "tw" + label = f"{inp}\nDim: {dim}\nWindow({window_tag}): {window}" + dot.node(inp, label=label, fillcolor="lightgreen") + if "connect" in data.keys(): + dot.edge( + data["connect"], inp, label="connect", color="blue", fontcolor="blue" + ) + if "closedLoop" in data.keys(): + dot.edge( + data["closedLoop"], + inp, + label="closedLoop", + color="red", + fontcolor="red", + ) + + # Add constant nodes + if "Constants" in json: + for const, data in json["Constants"].items(): + dim = data["dim"] + label = f"{const}\nDim: {dim}" + dot.node(const, label=label, fillcolor="lightgray") + + # Add relation nodes + for name, rel in json["Relations"].items(): + op_type = rel[0] + parents = rel[1] + param1 = rel[2] if len(rel) > 2 else None + param2 = rel[3] if len(rel) > 3 else None + label = f"{name}\nType: {op_type}" + dot.node(name, label=label, fillcolor="lightblue") + for i in [param1, param2]: + if isinstance(i, str): + if i in json["Parameters"]: + param_dim = json["Parameters"][i]["dim"] + dot.node( + i, + label=f"{i}\nDim: {param_dim}", + shape="ellipse", + fillcolor="orange", + ) + dot.edge( + i, name, label="Parameter", color="orange", fontcolor="orange" + ) + elif i in json["Functions"]: + dot.node( + i, label=f"{param1}", shape="ellipse", fillcolor="darkorange" + ) + dot.edge( + i, + name, + label="function", + color="darkorange", + fontcolor="darkorange", + ) + for parent in parents: + dot.edge(parent, name) + + # Add output nodes + for out, rel in json["Outputs"].items(): + dot.node(out, fillcolor="lightcoral") + dot.edge(rel, out) + + # Add Minimize nodes if present + if "Minimizers" in json: + for name, rel in json["Minimizers"].items(): + rel_a, rel_b = rel["A"], rel["B"] + loss = rel["loss"] + dot.node( + name, label=f"{name}\nLoss:{loss}", shape="ellipse", fillcolor="purple" + ) + dot.edge(rel_a, name, label="Minimize", color="purple", fontcolor="purple") + dot.edge(rel_b, name, label="Minimize", color="purple", fontcolor="purple") + + # Add a legend as a subgraph + # with dot.subgraph(name='cluster_legend') as legend: + # legend.attr(label='Legend', style='dashed') + # legend.node('LegendInput', 'Inputs', shape='box', fillcolor='lightgreen', style='filled') + # legend.node('LegendRel', 'Relation', shape='box', fillcolor='lightblue', style='filled') + # legend.node('LegendOutput', 'Outputs', shape='box', fillcolor='lightcoral', style='filled') + # # Hide the edges inside the legend box + # legend.attr('edge', style='invis') + # legend.edge('LegendInput', 'LegendRel') + # legend.edge('LegendRel', 'LegendOutput') + + # Render the graph + dot.render( + filename=filename, view=view, format="svg" + ) # opens in default viewer and saves as SVG diff --git a/nnodely/support/logger.py b/src/nnodely/support/logger.py similarity index 64% rename from nnodely/support/logger.py rename to src/nnodely/support/logger.py index a94f3f21..f519fbe9 100644 --- a/nnodely/support/logger.py +++ b/src/nnodely/support/logger.py @@ -3,9 +3,9 @@ BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8) -#The background is set with 40 plus the number of the color, and the foreground with 30 +# The background is set with 40 plus the number of the color, and the foreground with 30 -#These are the sequences need to get colored ouput +# These are the sequences need to get colored ouput RESET_SEQ = "\033[0m" COLOR_SEQ = "\033[%dm" COLOR_BOLD_SEQ = "\033[1;%dm" @@ -18,7 +18,7 @@ logging.INFO: BLUE, logging.WARNING: YELLOW, logging.CRITICAL: RED, - logging.ERROR: RED + logging.ERROR: RED, } LEVEL_STRING = { logging.DEBUG: "DEBUG", @@ -26,15 +26,16 @@ logging.WARNING: "WARNING", logging.CRITICAL: "CRITICAL", logging.ERROR: "ERROR", - SUPPRESS: "SUPPRESS" + SUPPRESS: "SUPPRESS", } LOG_LEVEL = logging.INFO class JsonFormatter(logging.Formatter): - FORMAT = "[%(levelname)s][%(name)s:%(filename)s:%(funcName)s:%(lineno)d] %(message)s" # + "" + FORMAT = "[%(levelname)s][%(name)s:%(filename)s:%(funcName)s:%(lineno)d] %(message)s" # + "" FORMAT_WARNING = "[%(funcName)s] %(message)s" FORMAT_INFO = "%(message)s" + def __init__(self): logging.Formatter.__init__(self, self.FORMAT) @@ -54,39 +55,49 @@ def format(self, record): class nnLogger(logging.Logger): levels = [] loggers = [] - params = {'level':None} + params = {"level": None} + def __init__(self, name, level): logging.Logger.__init__(self, name) self.setLevel(max(level, LOG_LEVEL)) - #file = logging.FileHandler('example.log') - #color_formatter = ColoredFormatter(self.COLOR_FORMAT) + # file = logging.FileHandler('example.log') + # color_formatter = ColoredFormatter(self.COLOR_FORMAT) self.console = logging.StreamHandler(sys.stdout) color_formatter = JsonFormatter() self.console.setFormatter(color_formatter) - #self.console.setLevel(logging.CRITICAL) + # self.console.setLevel(logging.CRITICAL) - #logging.getLogger().addHandler(self.console) + # logging.getLogger().addHandler(self.console) self.addHandler(self.console) self.loggers.append(self) self.levels.append(level) - #self.addHandler(file) + # self.addHandler(file) def setAllLevel(self, level): - if self.params['level'] is None or self.params['level'] != level: - self._log(logging.INFO, - COLOR_SEQ % (30 + BLUE) + (f" Loggers to {LEVEL_STRING[level]} ").center(80, '=') + RESET_SEQ, None) - self.params['level'] = level + if self.params["level"] is None or self.params["level"] != level: + self._log( + logging.INFO, + COLOR_SEQ % (30 + BLUE) + + (f" Loggers to {LEVEL_STRING[level]} ").center(80, "=") + + RESET_SEQ, + None, + ) + self.params["level"] = level for ind, logger in enumerate(self.loggers): logger.setLevel(level) def resetAllLevel(self): - if self.params['level'] != 0: - self._log(logging.INFO, COLOR_SEQ % (30 + BLUE) + (" Standard Level Log ").center(80, '=') + RESET_SEQ, None) - self.params['level'] = None + if self.params["level"] != 0: + self._log( + logging.INFO, + COLOR_SEQ % (30 + BLUE) + + (" Standard Level Log ").center(80, "=") + + RESET_SEQ, + None, + ) + self.params["level"] = None for ind, logger in enumerate(self.loggers): logger.setLevel(self.levels[ind]) - - diff --git a/nnodely/support/mathutils.py b/src/nnodely/support/mathutils.py similarity index 88% rename from nnodely/support/mathutils.py rename to src/nnodely/support/mathutils.py index 6e6dca45..0663b1de 100644 --- a/nnodely/support/mathutils.py +++ b/src/nnodely/support/mathutils.py @@ -1,17 +1,22 @@ import torch + def argmax_max(iterable): return max(enumerate(iterable), key=lambda x: x[1]) + def argmin_min(iterable): return min(enumerate(iterable), key=lambda x: x[1]) + def argmax_dict(iterable: dict): return max(iterable.items(), key=lambda x: x[1]) + def argmin_dict(iterable: dict): return min(iterable.items(), key=lambda x: x[1]) + # Linear interpolation function, operating on batches of input data and returning batches of output data def linear_interp(x, x_data, y_data): # Inputs: @@ -28,5 +33,7 @@ def linear_interp(x, x_data, y_data): idx = torch.argmin(torch.abs(x_data[:-1] - x), dim=1) # Linear interpolation - y = y_data[idx] + (y_data[idx + 1] - y_data[idx]) / (x_data[idx + 1] - x_data[idx]) * (x - x_data[idx]) - return y \ No newline at end of file + y = y_data[idx] + (y_data[idx + 1] - y_data[idx]) / ( + x_data[idx + 1] - x_data[idx] + ) * (x - x_data[idx]) + return y diff --git a/nnodely/support/odeint/__init__.py b/src/nnodely/support/odeint/__init__.py similarity index 100% rename from nnodely/support/odeint/__init__.py rename to src/nnodely/support/odeint/__init__.py diff --git a/nnodely/support/odeint/adjoint.py b/src/nnodely/support/odeint/adjoint.py similarity index 66% rename from nnodely/support/odeint/adjoint.py rename to src/nnodely/support/odeint/adjoint.py index b68b7f14..f3525704 100644 --- a/nnodely/support/odeint/adjoint.py +++ b/src/nnodely/support/odeint/adjoint.py @@ -2,14 +2,35 @@ import torch import torch.nn as nn from nnodely.support.odeint.my_odeint import SOLVERS, odeint -from nnodely.support.odeint.utils import _check_inputs, _flat_to_shape, _mixed_norm, _all_callback_names, _all_adjoint_callback_names +from nnodely.support.odeint.utils import ( + _check_inputs, + _flat_to_shape, + _mixed_norm, + _all_callback_names, + _all_adjoint_callback_names, +) class OdeintAdjointMethod(torch.autograd.Function): - @staticmethod - def forward(ctx, shapes, func, y0, t, rtol, atol, method, options, event_fn, adjoint_rtol, adjoint_atol, adjoint_method, - adjoint_options, t_requires_grad, *adjoint_params): + def forward( + ctx, + shapes, + func, + y0, + t, + rtol, + atol, + method, + options, + event_fn, + adjoint_rtol, + adjoint_atol, + adjoint_method, + adjoint_options, + t_requires_grad, + *adjoint_params, + ): ctx.shapes = shapes ctx.func = func @@ -21,7 +42,16 @@ def forward(ctx, shapes, func, y0, t, rtol, atol, method, options, event_fn, adj ctx.event_mode = event_fn is not None with torch.no_grad(): - ans = odeint(func, y0, t, rtol=rtol, atol=atol, method=method, options=options, event_fn=event_fn) + ans = odeint( + func, + y0, + t, + rtol=rtol, + atol=atol, + method=method, + options=options, + event_fn=event_fn, + ) if event_fn is None: y = ans @@ -61,8 +91,14 @@ def backward(ctx, *grad_y): ################################## # [-1] because y and grad_y are both of shape (len(t), *y0.shape) - aug_state = [torch.zeros((), dtype=y.dtype, device=y.device), y[-1], grad_y[-1]] # vjp_t, y, vjp_y - aug_state.extend([torch.zeros_like(param) for param in adjoint_params]) # vjp_params + aug_state = [ + torch.zeros((), dtype=y.dtype, device=y.device), + y[-1], + grad_y[-1], + ] # vjp_t, y, vjp_y + aug_state.extend( + [torch.zeros_like(param) for param in adjoint_params] + ) # vjp_params ################################## # Set up backward ODE func # @@ -89,23 +125,32 @@ def augmented_dynamics(t, y_aug): # Workaround for PyTorch bug #39784 _t = torch.as_strided(t, (), ()) # noqa _y = torch.as_strided(y, (), ()) # noqa - _params = tuple(torch.as_strided(param, (), ()) for param in adjoint_params) # noqa + _params = tuple( + torch.as_strided(param, (), ()) for param in adjoint_params + ) # noqa vjp_t, vjp_y, *vjp_params = torch.autograd.grad( - func_eval, (t, y) + adjoint_params, -adj_y, - allow_unused=True, retain_graph=True + func_eval, + (t, y) + adjoint_params, + -adj_y, + allow_unused=True, + retain_graph=True, ) # autograd.grad returns None if no gradient, set to zero. vjp_t = torch.zeros_like(t) if vjp_t is None else vjp_t vjp_y = torch.zeros_like(y) if vjp_y is None else vjp_y - vjp_params = [torch.zeros_like(param) if vjp_param is None else vjp_param - for param, vjp_param in zip(adjoint_params, vjp_params)] + vjp_params = [ + torch.zeros_like(param) if vjp_param is None else vjp_param + for param, vjp_param in zip(adjoint_params, vjp_params) + ] return (vjp_t, func_eval, vjp_y, *vjp_params) # Add adjoint callbacks - for callback_name, adjoint_callback_name in zip(_all_callback_names, _all_adjoint_callback_names): + for callback_name, adjoint_callback_name in zip( + _all_callback_names, _all_adjoint_callback_names + ): try: callback = getattr(func, adjoint_callback_name) except AttributeError: @@ -132,36 +177,78 @@ def augmented_dynamics(t, y_aug): # Run the augmented system backwards in time. aug_state = odeint( - augmented_dynamics, tuple(aug_state), - t[i - 1:i + 1].flip(0), - rtol=adjoint_rtol, atol=adjoint_atol, method=adjoint_method, options=adjoint_options + augmented_dynamics, + tuple(aug_state), + t[i - 1 : i + 1].flip(0), + rtol=adjoint_rtol, + atol=adjoint_atol, + method=adjoint_method, + options=adjoint_options, ) aug_state = [a[1] for a in aug_state] # extract just the t[i - 1] value - aug_state[1] = y[i - 1] # update to use our forward-pass estimate of the state - aug_state[2] += grad_y[i - 1] # update any gradients wrt state at this time point + aug_state[1] = y[ + i - 1 + ] # update to use our forward-pass estimate of the state + aug_state[2] += grad_y[ + i - 1 + ] # update any gradients wrt state at this time point if t_requires_grad: time_vjps[0] = aug_state[0] # Only compute gradient wrt initial time when in event handling mode. if event_mode and t_requires_grad: - time_vjps = torch.cat([time_vjps[0].reshape(-1), torch.zeros_like(_t[1:])]) + time_vjps = torch.cat( + [time_vjps[0].reshape(-1), torch.zeros_like(_t[1:])] + ) adj_y = aug_state[2] adj_params = aug_state[3:] - return (None, None, adj_y, time_vjps, None, None, None, None, None, None, None, None, None, None, *adj_params) - - -def odeint_adjoint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=None, event_fn=None, - adjoint_rtol=None, adjoint_atol=None, adjoint_method=None, adjoint_options=None, adjoint_params=None): + return ( + None, + None, + adj_y, + time_vjps, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + *adj_params, + ) + + +def odeint_adjoint( + func, + y0, + t, + *, + rtol=1e-7, + atol=1e-9, + method=None, + options=None, + event_fn=None, + adjoint_rtol=None, + adjoint_atol=None, + adjoint_method=None, + adjoint_options=None, + adjoint_params=None, +): # We need this in order to access the variables inside this module, # since we have no other way of getting variables along the execution path. if adjoint_params is None and not isinstance(func, nn.Module): - raise ValueError('func must be an instance of nn.Module to specify the adjoint parameters; alternatively they ' - 'can be specified explicitly via the `adjoint_params` argument. If there are no parameters ' - 'then it is allowable to set `adjoint_params=()`.') + raise ValueError( + "func must be an instance of nn.Module to specify the adjoint parameters; alternatively they " + "can be specified explicitly via the `adjoint_params` argument. If there are no parameters " + "then it is allowable to set `adjoint_params=()`." + ) # Must come before _check_inputs as we don't want to use normalised input (in particular any changes to options) if adjoint_rtol is None: @@ -172,11 +259,17 @@ def odeint_adjoint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=No adjoint_method = method if adjoint_method != method and options is not None and adjoint_options is None: - raise ValueError("If `adjoint_method != method` then we cannot infer `adjoint_options` from `options`. So as " - "`options` has been passed then `adjoint_options` must be passed as well.") + raise ValueError( + "If `adjoint_method != method` then we cannot infer `adjoint_options` from `options`. So as " + "`options` has been passed then `adjoint_options` must be passed as well." + ) if adjoint_options is None: - adjoint_options = {k: v for k, v in options.items() if k != "norm"} if options is not None else {} + adjoint_options = ( + {k: v for k, v in options.items() if k != "norm"} + if options is not None + else {} + ) else: # Avoid in-place modifying a user-specified dict. adjoint_options = adjoint_options.copy() @@ -192,19 +285,38 @@ def odeint_adjoint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=No if len(adjoint_params) != oldlen_: # Some params were excluded. # Issue a warning if a user-specified norm is specified. - if 'norm' in adjoint_options and callable(adjoint_options['norm']): - warnings.warn("An adjoint parameter was passed without requiring gradient. For efficiency this will be " - "excluded from the adjoint pass, and will not appear as a tensor in the adjoint norm.") + if "norm" in adjoint_options and callable(adjoint_options["norm"]): + warnings.warn( + "An adjoint parameter was passed without requiring gradient. For efficiency this will be " + "excluded from the adjoint pass, and will not appear as a tensor in the adjoint norm." + ) # Convert to flattened state. - shapes, func, y0, t, rtol, atol, method, options, event_fn, decreasing_time = _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS) + shapes, func, y0, t, rtol, atol, method, options, event_fn, decreasing_time = ( + _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS) + ) # Handle the adjoint norm function. state_norm = options["norm"] handle_adjoint_norm_(adjoint_options, shapes, state_norm) - ans = OdeintAdjointMethod.apply(shapes, func, y0, t, rtol, atol, method, options, event_fn, adjoint_rtol, adjoint_atol, - adjoint_method, adjoint_options, t.requires_grad, *adjoint_params) + ans = OdeintAdjointMethod.apply( + shapes, + func, + y0, + t, + rtol, + atol, + method, + options, + event_fn, + adjoint_rtol, + adjoint_atol, + adjoint_method, + adjoint_options, + t.requires_grad, + *adjoint_params, + ) if event_fn is None: solution = ans @@ -228,10 +340,14 @@ def find_parameters(module): assert isinstance(module, nn.Module) # If called within DataParallel, parameters won't appear in module.parameters(). - if getattr(module, '_is_replica', False): + if getattr(module, "_is_replica", False): def find_tensor_attributes(module): - tuples = [(k, v) for k, v in module.__dict__.items() if torch.is_tensor(v) and v.requires_grad] + tuples = [ + (k, v) + for k, v in module.__dict__.items() + if torch.is_tensor(v) and v.requires_grad + ] return tuples gen = module._named_members(get_members_fn=find_tensor_attributes) @@ -255,20 +371,21 @@ def default_adjoint_norm(tensor_tuple): else: # `adjoint_options` was explicitly specified by the user... try: - adjoint_norm = adjoint_options['norm'] + adjoint_norm = adjoint_options["norm"] except KeyError: # ...but they did not specify the norm argument. Back to plan A: use the default norm. - adjoint_options['norm'] = default_adjoint_norm + adjoint_options["norm"] = default_adjoint_norm else: # ...and they did specify the norm argument. - if adjoint_norm == 'seminorm': + if adjoint_norm == "seminorm": # They told us they want to use seminorms. Slight modification to plan A: use the default norm, # but ignore the parameter state def adjoint_seminorm(tensor_tuple): t, y, adj_y, *adj_params = tensor_tuple # (If the state is actually a flattened tuple then this will be unpacked again in state_norm.) return max(t.abs(), state_norm(y), state_norm(adj_y)) - adjoint_options['norm'] = adjoint_seminorm + + adjoint_options["norm"] = adjoint_seminorm else: # And they're using their own custom norm. if shapes is None: @@ -285,4 +402,5 @@ def _adjoint_norm(tensor_tuple): y = _flat_to_shape(y, (), shapes) adj_y = _flat_to_shape(adj_y, (), shapes) return adjoint_norm((t, *y, *adj_y, *adj_params)) - adjoint_options['norm'] = _adjoint_norm \ No newline at end of file + + adjoint_options["norm"] = _adjoint_norm diff --git a/src/nnodely/support/odeint/dopri5.py b/src/nnodely/support/odeint/dopri5.py new file mode 100644 index 00000000..6506e280 --- /dev/null +++ b/src/nnodely/support/odeint/dopri5.py @@ -0,0 +1,60 @@ +import torch +from nnodely.support.odeint.rk_solvers import ( + _ButcherTableau, + RKAdaptiveStepsizeODESolver, +) + +_DORMAND_PRINCE_SHAMPINE_TABLEAU = _ButcherTableau( + alpha=torch.tensor([1 / 5, 3 / 10, 4 / 5, 8 / 9, 1.0, 1.0], dtype=torch.float32), + beta=[ + torch.tensor([1 / 5], dtype=torch.float32), + torch.tensor([3 / 40, 9 / 40], dtype=torch.float32), + torch.tensor([44 / 45, -56 / 15, 32 / 9], dtype=torch.float32), + torch.tensor( + [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729], dtype=torch.float32 + ), + torch.tensor( + [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656], + dtype=torch.float32, + ), + torch.tensor( + [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84], + dtype=torch.float32, + ), + ], + c_sol=torch.tensor( + [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84, 0], + dtype=torch.float32, + ), + c_error=torch.tensor( + [ + 35 / 384 - 1951 / 21600, + 0, + 500 / 1113 - 22642 / 50085, + 125 / 192 - 451 / 720, + -2187 / 6784 - -12231 / 42400, + 11 / 84 - 649 / 6300, + -1.0 / 60.0, + ], + dtype=torch.float32, + ), +) + +DPS_C_MID = torch.tensor( + [ + 6025192743 / 30085553152 / 2, + 0, + 51252292925 / 65400821598 / 2, + -2691868925 / 45128329728 / 2, + 187940372067 / 1594534317056 / 2, + -1776094331 / 19743644256 / 2, + 11237099 / 235043384 / 2, + ], + dtype=torch.float32, +) + + +class Dopri5Solver(RKAdaptiveStepsizeODESolver): + order = 5 + tableau = _DORMAND_PRINCE_SHAMPINE_TABLEAU + mid = DPS_C_MID diff --git a/nnodely/support/odeint/fixed_grid.py b/src/nnodely/support/odeint/fixed_grid.py similarity index 86% rename from nnodely/support/odeint/fixed_grid.py rename to src/nnodely/support/odeint/fixed_grid.py index 28bbf28d..e17c88bc 100644 --- a/nnodely/support/odeint/fixed_grid.py +++ b/src/nnodely/support/odeint/fixed_grid.py @@ -15,4 +15,4 @@ class RK4(FixedGridODESolver): def _step_func(self, func, t0, dt, t1, y0): f0 = func(t0, y0) - return rk4_step_func(func, t0, dt, t1, y0, f0=f0), f0 \ No newline at end of file + return rk4_step_func(func, t0, dt, t1, y0, f0=f0), f0 diff --git a/nnodely/support/odeint/my_odeint.py b/src/nnodely/support/odeint/my_odeint.py similarity index 86% rename from nnodely/support/odeint/my_odeint.py rename to src/nnodely/support/odeint/my_odeint.py index 46c9bdb6..9a9b7f7c 100644 --- a/nnodely/support/odeint/my_odeint.py +++ b/src/nnodely/support/odeint/my_odeint.py @@ -5,13 +5,15 @@ from nnodely.support.odeint.fixed_grid import Euler, RK4 SOLVERS = { - 'dopri5': Dopri5Solver, - 'euler': Euler, - 'rk4': RK4, + "dopri5": Dopri5Solver, + "euler": Euler, + "rk4": RK4, } -def odeint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=None, event_fn=None): +def odeint( + func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=None, event_fn=None +): """Integrate a system of ordinary differential equations. Solves the initial value problem for a non-stiff system of first order ODEs: @@ -52,7 +54,9 @@ def odeint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=None, even ValueError: if an invalid `method` is provided. """ - shapes, func, y0, t, rtol, atol, method, options, event_fn, t_is_reversed = _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS) + shapes, func, y0, t, rtol, atol, method, options, event_fn, t_is_reversed = ( + _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS) + ) solver = SOLVERS[method](func=func, y0=y0, rtol=rtol, atol=atol, **options) @@ -73,7 +77,9 @@ def odeint(func, y0, t, *, rtol=1e-7, atol=1e-9, method=None, options=None, even return event_t, solution -def odeint_event(func, y0, t0, *, event_fn, reverse_time=False, odeint_interface=odeint, **kwargs): +def odeint_event( + func, y0, t0, *, event_fn, reverse_time=False, odeint_interface=odeint, **kwargs +): """Automatically links up the gradient from the event time.""" if reverse_time: @@ -84,7 +90,9 @@ def odeint_event(func, y0, t0, *, event_fn, reverse_time=False, odeint_interface event_t, solution = odeint_interface(func, y0, t, event_fn=event_fn, **kwargs) # Dummy values for rtol, atol, method, and options. - shapes, _func, _, t, _, _, _, _, event_fn, _ = _check_inputs(func, y0, t, 0.0, 0.0, None, None, event_fn, SOLVERS) + shapes, _func, _, t, _, _, _, _, event_fn, _ = _check_inputs( + func, y0, t, 0.0, 0.0, None, None, event_fn, SOLVERS + ) if shapes is not None: state_t = torch.cat([s[-1].reshape(-1) for s in solution]) @@ -95,7 +103,9 @@ def odeint_event(func, y0, t0, *, event_fn, reverse_time=False, odeint_interface if reverse_time: event_t = -event_t - event_t, state_t = ImplicitFnGradientRerouting.apply(_func, event_fn, event_t, state_t) + event_t, state_t = ImplicitFnGradientRerouting.apply( + _func, event_fn, event_t, state_t + ) # Return the user expected time value. if reverse_time: @@ -103,7 +113,9 @@ def odeint_event(func, y0, t0, *, event_fn, reverse_time=False, odeint_interface if shapes is not None: state_t = _flat_to_shape(state_t, (), shapes) - solution = tuple(torch.cat([s[:-1], s_t[None]], dim=0) for s, s_t in zip(solution, state_t)) + solution = tuple( + torch.cat([s[:-1], s_t[None]], dim=0) for s, s_t in zip(solution, state_t) + ) else: solution = torch.cat([solution[:-1], state_t[None]], dim=0) @@ -111,10 +123,9 @@ def odeint_event(func, y0, t0, *, event_fn, reverse_time=False, odeint_interface class ImplicitFnGradientRerouting(torch.autograd.Function): - @staticmethod def forward(ctx, func, event_fn, event_t, state_t): - """ event_t is the solution to event_fn """ + """event_t is the solution to event_fn""" ctx.func = func ctx.event_fn = event_fn ctx.save_for_backward(event_t, state_t) @@ -144,4 +155,4 @@ def backward(ctx, grad_t, grad_state): grad_state = grad_state + dstate - return None, None, None, grad_state \ No newline at end of file + return None, None, None, grad_state diff --git a/nnodely/support/odeint/rk_solvers.py b/src/nnodely/support/odeint/rk_solvers.py similarity index 73% rename from nnodely/support/odeint/rk_solvers.py rename to src/nnodely/support/odeint/rk_solvers.py index 134a4183..69ad93e4 100644 --- a/nnodely/support/odeint/rk_solvers.py +++ b/src/nnodely/support/odeint/rk_solvers.py @@ -1,12 +1,21 @@ import collections import warnings import torch -from nnodely.support.odeint.solvers import _handle_unused_kwargs, find_event, AdaptiveStepsizeEventODESolver, FixedGridODESolver +from nnodely.support.odeint.solvers import ( + _handle_unused_kwargs, + find_event, + AdaptiveStepsizeEventODESolver, + FixedGridODESolver, +) -_ButcherTableau = collections.namedtuple('_ButcherTableau', 'alpha, beta, c_sol, c_error') +_ButcherTableau = collections.namedtuple( + "_ButcherTableau", "alpha, beta, c_sol, c_error" +) -_RungeKuttaState = collections.namedtuple('_RungeKuttaState', 'y1, f1, t0, t1, dt, interp_coeff') +_RungeKuttaState = collections.namedtuple( + "_RungeKuttaState", "y1, f1, t0, t1, dt, interp_coeff" +) # Saved state of the Runge Kutta solver. # # Attributes: @@ -18,6 +27,7 @@ # interp_coeff: list of Tensors giving coefficients for polynomial # interpolation between `t0` and `t1`. + def _interp_fit(y0, y1, y_mid, f0, f1, dt): """Fit coefficients for 4th order polynomial interpolation. @@ -41,6 +51,7 @@ def _interp_fit(y0, y1, y_mid, f0, f1, dt): e = y0 return [e, d, c, b, a] + def _interp_evaluate(coefficients, t0, t1, t): """Evaluate polynomial interpolation at the given time point. @@ -54,7 +65,9 @@ def _interp_evaluate(coefficients, t0, t1, t): Polynomial interpolation of the coefficients at time `t`. """ - assert (t0 <= t) & (t <= t1), 'invalid interpolation, fails `t0 <= t <= t1`: {}, {}, {}'.format(t0, t, t1) + assert (t0 <= t) & (t <= t1), ( + "invalid interpolation, fails `t0 <= t <= t1`: {}, {}, {}".format(t0, t, t1) + ) x = (t - t0) / (t1 - t0) x = x.to(coefficients[0].dtype) @@ -66,6 +79,7 @@ def _interp_evaluate(coefficients, t0, t1, t): return total + def _select_initial_step(func, t0, y0, order, rtol, atol, norm, f0=None): """Empirically select a good initial step. @@ -104,15 +118,17 @@ def _select_initial_step(func, t0, y0, order, rtol, atol, norm, f0=None): if d1 <= 1e-15 and d2 <= 1e-15: h1 = torch.max(torch.tensor(1e-6, dtype=dtype, device=device), h0 * 1e-3) else: - h1 = (0.01 / max(d1, d2)) ** (1. / float(order + 1)) + h1 = (0.01 / max(d1, d2)) ** (1.0 / float(order + 1)) h1 = h1.abs() return torch.min(100 * h0, h1).to(t_dtype) + def _compute_error_ratio(error_estimate, rtol, atol, y0, y1, norm): error_tol = atol + rtol * torch.max(y0.abs(), y1.abs()) return norm(error_estimate / error_tol).abs() + @torch.no_grad() def _optimal_step_size(last_step, error_ratio, safety, ifactor, dfactor, order): """Calculate the optimal size for the next step.""" @@ -121,10 +137,13 @@ def _optimal_step_size(last_step, error_ratio, safety, ifactor, dfactor, order): if error_ratio < 1: dfactor = torch.ones((), dtype=last_step.dtype, device=last_step.device) error_ratio = error_ratio.type_as(last_step) - exponent = torch.tensor(order, dtype=last_step.dtype, device=last_step.device).reciprocal() - factor = torch.min(ifactor, torch.max(safety / error_ratio ** exponent, dfactor)) + exponent = torch.tensor( + order, dtype=last_step.dtype, device=last_step.device + ).reciprocal() + factor = torch.min(ifactor, torch.max(safety / error_ratio**exponent, dfactor)) return last_step * factor + class _UncheckedAssign(torch.autograd.Function): @staticmethod def forward(ctx, scratch, value, index): @@ -136,6 +155,7 @@ def forward(ctx, scratch, value, index): def backward(ctx, grad_scratch): return grad_scratch, grad_scratch[ctx.index], None + def _runge_kutta_step(func, y0, f0, t0, dt, t1, tableau): """Take an arbitrary Runge-Kutta step and estimate error. Args: @@ -165,12 +185,12 @@ def _runge_kutta_step(func, y0, f0, t0, dt, t1, tableau): k = torch.empty(*f0.shape, len(tableau.alpha) + 1, dtype=y0.dtype, device=y0.device) k = _UncheckedAssign.apply(k, f0, (..., 0)) for i, (alpha_i, beta_i) in enumerate(zip(tableau.alpha, tableau.beta)): - if alpha_i == 1.: + if alpha_i == 1.0: # Always step to perturbing just before the end time, in case of discontinuities. ti = t1 else: ti = t0 + alpha_i * dt - yi = y0 + torch.sum(k[..., :i + 1] * (beta_i * dt), dim=-1).view_as(f0) + yi = y0 + torch.sum(k[..., : i + 1] * (beta_i * dt), dim=-1).view_as(f0) f = func(ti, yi) k = _UncheckedAssign.apply(k, f, (..., i + 1)) @@ -200,18 +220,24 @@ class RKAdaptiveStepsizeODESolver(AdaptiveStepsizeEventODESolver): tableau: _ButcherTableau mid: torch.Tensor - def __init__(self, func, y0, rtol, atol, - min_step=1e-8, - max_step=float('inf'), - first_step=None, - step_t=None, - jump_t=None, - safety=0.9, - ifactor=10.0, - dfactor=0.2, - max_num_steps=2**20, - dtype=torch.float32, - **kwargs): + def __init__( + self, + func, + y0, + rtol, + atol, + min_step=1e-8, + max_step=float("inf"), + first_step=None, + step_t=None, + jump_t=None, + safety=0.9, + ifactor=10.0, + dfactor=0.2, + max_num_steps=2**20, + dtype=torch.float32, + **kwargs, + ): super(RKAdaptiveStepsizeODESolver, self).__init__(dtype=dtype, y0=y0, **kwargs) # We use mixed precision. y has its original dtype (probably float32), whilst all 'time'-like objects use @@ -224,47 +250,79 @@ def __init__(self, func, y0, rtol, atol, self.atol = torch.as_tensor(atol, dtype=dtype, device=device) self.min_step = torch.as_tensor(min_step, dtype=dtype, device=device) self.max_step = torch.as_tensor(max_step, dtype=dtype, device=device) - self.first_step = None if first_step is None else torch.as_tensor(first_step, dtype=dtype, device=device) + self.first_step = ( + None + if first_step is None + else torch.as_tensor(first_step, dtype=dtype, device=device) + ) self.safety = torch.as_tensor(safety, dtype=dtype, device=device) self.ifactor = torch.as_tensor(ifactor, dtype=dtype, device=device) self.dfactor = torch.as_tensor(dfactor, dtype=dtype, device=device) - self.max_num_steps = torch.as_tensor(max_num_steps, dtype=torch.int32, device=device) + self.max_num_steps = torch.as_tensor( + max_num_steps, dtype=torch.int32, device=device + ) self.dtype = dtype - self.step_t = None if step_t is None else torch.as_tensor(step_t, dtype=dtype, device=device) - self.jump_t = None if jump_t is None else torch.as_tensor(jump_t, dtype=dtype, device=device) + self.step_t = ( + None + if step_t is None + else torch.as_tensor(step_t, dtype=dtype, device=device) + ) + self.jump_t = ( + None + if jump_t is None + else torch.as_tensor(jump_t, dtype=dtype, device=device) + ) # Copy from class to instance to set device - self.tableau = _ButcherTableau(alpha=self.tableau.alpha.to(device=device, dtype=y0.dtype), - beta=[b.to(device=device, dtype=y0.dtype) for b in self.tableau.beta], - c_sol=self.tableau.c_sol.to(device=device, dtype=y0.dtype), - c_error=self.tableau.c_error.to(device=device, dtype=y0.dtype)) + self.tableau = _ButcherTableau( + alpha=self.tableau.alpha.to(device=device, dtype=y0.dtype), + beta=[b.to(device=device, dtype=y0.dtype) for b in self.tableau.beta], + c_sol=self.tableau.c_sol.to(device=device, dtype=y0.dtype), + c_error=self.tableau.c_error.to(device=device, dtype=y0.dtype), + ) self.mid = self.mid.to(device=device, dtype=y0.dtype) @classmethod def valid_callbacks(cls): - return super(RKAdaptiveStepsizeODESolver, cls).valid_callbacks() | {'callback_step', - 'callback_accept_step', - 'callback_reject_step'} + return super(RKAdaptiveStepsizeODESolver, cls).valid_callbacks() | { + "callback_step", + "callback_accept_step", + "callback_reject_step", + } def _before_integrate(self, t): t0 = t[0] f0 = self.func(t[0], self.y0) if self.first_step is None: - first_step = _select_initial_step(self.func, t[0], self.y0, self.order - 1, self.rtol, self.atol, - self.norm, f0=f0) + first_step = _select_initial_step( + self.func, + t[0], + self.y0, + self.order - 1, + self.rtol, + self.atol, + self.norm, + f0=f0, + ) else: first_step = self.first_step - self.rk_state = _RungeKuttaState(self.y0, f0, t[0], t[0], first_step, [self.y0] * 5) + self.rk_state = _RungeKuttaState( + self.y0, f0, t[0], t[0], first_step, [self.y0] * 5 + ) def _advance(self, next_t): """Interpolate through the next time point, integrating as necessary.""" n_steps = 0 while next_t > self.rk_state.t1: - assert n_steps < self.max_num_steps, 'max_num_steps exceeded ({}>={})'.format(n_steps, self.max_num_steps) + assert n_steps < self.max_num_steps, ( + "max_num_steps exceeded ({}>={})".format(n_steps, self.max_num_steps) + ) self.rk_state = self._adaptive_step(self.rk_state) n_steps += 1 - return _interp_evaluate(self.rk_state.interp_coeff, self.rk_state.t0, self.rk_state.t1, next_t) + return _interp_evaluate( + self.rk_state.interp_coeff, self.rk_state.t0, self.rk_state.t1, next_t + ) def _advance_until_event(self, event_fn): """Returns t, state(t) such that event_fn(t, state(t)) == 0.""" @@ -274,11 +332,17 @@ def _advance_until_event(self, event_fn): n_steps = 0 sign0 = torch.sign(event_fn(self.rk_state.t1, self.rk_state.y1)) while sign0 == torch.sign(event_fn(self.rk_state.t1, self.rk_state.y1)): - assert n_steps < self.max_num_steps, 'max_num_steps exceeded ({}>={})'.format(n_steps, self.max_num_steps) + assert n_steps < self.max_num_steps, ( + "max_num_steps exceeded ({}>={})".format(n_steps, self.max_num_steps) + ) self.rk_state = self._adaptive_step(self.rk_state) n_steps += 1 - interp_fn = lambda t: _interp_evaluate(self.rk_state.interp_coeff, self.rk_state.t0, self.rk_state.t1, t) - return find_event(interp_fn, sign0, self.rk_state.t0, self.rk_state.t1, event_fn, self.atol) + interp_fn = lambda t: _interp_evaluate( + self.rk_state.interp_coeff, self.rk_state.t0, self.rk_state.t1, t + ) + return find_event( + interp_fn, sign0, self.rk_state.t0, self.rk_state.t1, event_fn, self.atol + ) def _adaptive_step(self, rk_state): """Take an adaptive Runge-Kutta step to integrate the ODE.""" @@ -300,10 +364,12 @@ def _adaptive_step(self, rk_state): ######################################################## # Assertions # ######################################################## - assert t0 + dt > t0, 'underflow in dt {}'.format(dt.item()) - assert torch.isfinite(y0).all(), 'non-finite values in state `y`: {}'.format(y0) + assert t0 + dt > t0, "underflow in dt {}".format(dt.item()) + assert torch.isfinite(y0).all(), "non-finite values in state `y`: {}".format(y0) - y1, f1, y1_error, k = _runge_kutta_step(self.func, y0, f0, t0, dt, t1, tableau=self.tableau) + y1, f1, y1_error, k = _runge_kutta_step( + self.func, y0, f0, t0, dt, t1, tableau=self.tableau + ) # dtypes: # y1.dtype == self.y0.dtype # f1.dtype == self.y0.dtype @@ -313,7 +379,9 @@ def _adaptive_step(self, rk_state): ######################################################## # Error Ratio # ######################################################## - error_ratio = _compute_error_ratio(y1_error, self.rtol, self.atol, y0, y1, self.norm) + error_ratio = _compute_error_ratio( + y1_error, self.rtol, self.atol, y0, y1, self.norm + ) accept_step = error_ratio <= 1 # Handle min max stepping @@ -339,7 +407,9 @@ def _adaptive_step(self, rk_state): t_next = t0 y_next = y0 f_next = f0 - dt_next = _optimal_step_size(dt, error_ratio, self.safety, self.ifactor, self.dfactor, self.order) + dt_next = _optimal_step_size( + dt, error_ratio, self.safety, self.ifactor, self.dfactor, self.order + ) dt_next = dt_next.clamp(self.min_step, self.max_step) rk_state = _RungeKuttaState(y_next, f_next, t0, t_next, dt_next, interp_coeff) return rk_state @@ -351,17 +421,28 @@ def _interp_fit(self, y0, y1, k, dt): f0 = k[..., 0] f1 = k[..., -1] return _interp_fit(y0, y1, y_mid, f0, f1, dt) - + + class FixedGridFIRKODESolver(FixedGridODESolver): order: int tableau: _ButcherTableau - def __init__(self, func, y0, step_size=None, grid_constructor=None, interp='linear', perturb=False, max_iters=100, **unused_kwargs): + def __init__( + self, + func, + y0, + step_size=None, + grid_constructor=None, + interp="linear", + perturb=False, + max_iters=100, + **unused_kwargs, + ): self.max_iters = max_iters - self.atol = unused_kwargs.pop('atol') - unused_kwargs.pop('rtol', None) - unused_kwargs.pop('norm', None) + self.atol = unused_kwargs.pop("atol") + unused_kwargs.pop("rtol", None) + unused_kwargs.pop("norm", None) _handle_unused_kwargs(self, unused_kwargs) del unused_kwargs @@ -382,13 +463,17 @@ def __init__(self, func, y0, step_size=None, grid_constructor=None, interp='line if grid_constructor is None: self.grid_constructor = self._grid_constructor_from_step_size(step_size) else: - raise ValueError("step_size and grid_constructor are mutually exclusive arguments.") - - self.tableau = _ButcherTableau(alpha=self.tableau.alpha.to(device=self.device, dtype=y0.dtype), - beta=[b.to(device=self.device, dtype=y0.dtype) for b in self.tableau.beta], - c_sol=self.tableau.c_sol.to(device=self.device, dtype=y0.dtype), - c_error=self.tableau.c_error.to(device=self.device, dtype=y0.dtype)) - + raise ValueError( + "step_size and grid_constructor are mutually exclusive arguments." + ) + + self.tableau = _ButcherTableau( + alpha=self.tableau.alpha.to(device=self.device, dtype=y0.dtype), + beta=[b.to(device=self.device, dtype=y0.dtype) for b in self.tableau.beta], + c_sol=self.tableau.c_sol.to(device=self.device, dtype=y0.dtype), + c_error=self.tableau.c_error.to(device=self.device, dtype=y0.dtype), + ) + def _step_func(self, func, t0, dt, t1, y0): if not isinstance(t0, torch.Tensor): t0 = torch.tensor(t0) @@ -397,7 +482,7 @@ def _step_func(self, func, t0, dt, t1, y0): if not isinstance(t1, torch.Tensor): t1 = torch.tensor(t1) f0 = func(t0, y0) - + t_dtype = y0.abs().dtype tol = 1e-8 if t_dtype == torch.float32: @@ -433,26 +518,30 @@ def _step_func(self, func, t0, dt, t1, y0): newf = self._residual(func, k, y, t0, dt, t1) z = newf - f f = newf - J = J + (torch.outer ((z - torch.linalg.vecdot(J,s)),s)) / (torch.dot(s,s)) + J = J + (torch.outer((z - torch.linalg.vecdot(J, s)), s)) / ( + torch.dot(s, s) + ) if not converged: - warnings.warn('Functional iteration did not converge. Solution may be incorrect.') + warnings.warn( + "Functional iteration did not converge. Solution may be incorrect." + ) dy = torch.matmul(k, dt * self.tableau.c_sol) return dy, f0 - + def _residual(self, func, K, y, t0, dt, t1): res = torch.zeros_like(K) for i, (y_i, alpha_i) in enumerate(zip(y, self.tableau.alpha)): - if alpha_i == 1.: + if alpha_i == 1.0: ti = t1 - elif alpha_i == 0.: + elif alpha_i == 0.0: if not torch.all(self.tableau.beta[i]): # Same slope as stored so skip continue ti = t0 else: ti = t0 + alpha_i * dt - res[...,i] = K[...,i] - func(ti, y_i) - return res.flatten() \ No newline at end of file + res[..., i] = K[..., i] - func(ti, y_i) + return res.flatten() diff --git a/nnodely/support/odeint/solvers.py b/src/nnodely/support/odeint/solvers.py similarity index 77% rename from nnodely/support/odeint/solvers.py rename to src/nnodely/support/odeint/solvers.py index 39ba70c3..6fb6b9e5 100644 --- a/nnodely/support/odeint/solvers.py +++ b/src/nnodely/support/odeint/solvers.py @@ -3,13 +3,18 @@ import warnings import torch + def _handle_unused_kwargs(solver, unused_kwargs): if len(unused_kwargs) > 0: - warnings.warn('{}: Unexpected arguments {}'.format(solver.__class__.__name__, unused_kwargs)) + warnings.warn( + "{}: Unexpected arguments {}".format( + solver.__class__.__name__, unused_kwargs + ) + ) + def find_event(interp_fn, sign0, t0, t1, event_fn, tol): with torch.no_grad(): - # Num iterations for the secant method until tolerance is within target. nitrs = torch.ceil(torch.log((t1 - t0) / tol) / math.log(2.0)) @@ -17,13 +22,14 @@ def find_event(interp_fn, sign0, t0, t1, event_fn, tol): t_mid = (t1 + t0) / 2.0 y_mid = interp_fn(t_mid) sign_mid = torch.sign(event_fn(t_mid, y_mid)) - same_as_sign0 = (sign0 == sign_mid) + same_as_sign0 = sign0 == sign_mid t0 = torch.where(same_as_sign0, t_mid, t0) t1 = torch.where(same_as_sign0, t1, t_mid) event_t = (t0 + t1) / 2.0 return event_t, interp_fn(event_t) + class AdaptiveStepsizeODESolver(metaclass=abc.ABCMeta): def __init__(self, dtype, y0, norm, **unused_kwargs): _handle_unused_kwargs(self, unused_kwargs) @@ -46,7 +52,9 @@ def valid_callbacks(cls): return set() def integrate(self, t): - solution = torch.empty(len(t), *self.y0.shape, dtype=self.y0.dtype, device=self.y0.device) + solution = torch.empty( + len(t), *self.y0.shape, dtype=self.y0.dtype, device=self.y0.device + ) solution[0] = self.y0 t = t.to(self.dtype) self._before_integrate(t) @@ -56,7 +64,6 @@ def integrate(self, t): class AdaptiveStepsizeEventODESolver(AdaptiveStepsizeODESolver, metaclass=abc.ABCMeta): - @abc.abstractmethod def _advance_until_event(self, event_fn): raise NotImplementedError @@ -72,10 +79,19 @@ def integrate_until_event(self, t0, event_fn): class FixedGridODESolver(metaclass=abc.ABCMeta): order: int - def __init__(self, func, y0, step_size=None, grid_constructor=None, interp="linear", perturb=False, **unused_kwargs): - self.atol = unused_kwargs.pop('atol') - unused_kwargs.pop('rtol', None) - unused_kwargs.pop('norm', None) + def __init__( + self, + func, + y0, + step_size=None, + grid_constructor=None, + interp="linear", + perturb=False, + **unused_kwargs, + ): + self.atol = unused_kwargs.pop("atol") + unused_kwargs.pop("rtol", None) + unused_kwargs.pop("norm", None) _handle_unused_kwargs(self, unused_kwargs) del unused_kwargs @@ -96,11 +112,13 @@ def __init__(self, func, y0, step_size=None, grid_constructor=None, interp="line if grid_constructor is None: self.grid_constructor = self._grid_constructor_from_step_size(step_size) else: - raise ValueError("step_size and grid_constructor are mutually exclusive arguments.") + raise ValueError( + "step_size and grid_constructor are mutually exclusive arguments." + ) @classmethod def valid_callbacks(cls): - return {'callback_step'} + return {"callback_step"} @staticmethod def _grid_constructor_from_step_size(step_size): @@ -109,10 +127,14 @@ def _grid_constructor(func, y0, t): end_time = t[-1] niters = torch.ceil((end_time - start_time) / step_size + 1).item() - t_infer = torch.arange(0, niters, dtype=t.dtype, device=t.device) * step_size + start_time + t_infer = ( + torch.arange(0, niters, dtype=t.dtype, device=t.device) * step_size + + start_time + ) t_infer[-1] = t[-1] return t_infer + return _grid_constructor @abc.abstractmethod @@ -123,7 +145,9 @@ def integrate(self, t): time_grid = self.grid_constructor(self.func, self.y0, t) assert time_grid[0] == t[0] and time_grid[-1] == t[-1] - solution = torch.empty(len(t), *self.y0.shape, dtype=self.y0.dtype, device=self.y0.device) + solution = torch.empty( + len(t), *self.y0.shape, dtype=self.y0.dtype, device=self.y0.device + ) solution[0] = self.y0 j = 1 @@ -139,7 +163,9 @@ def integrate(self, t): solution[j] = self._linear_interp(t0, t1, y0, y1, t[j]) elif self.interp == "cubic": f1 = self.func(t1, y1) - solution[j] = self._cubic_hermite_interp(t0, y0, f0, t1, y1, f1, t[j]) + solution[j] = self._cubic_hermite_interp( + t0, y0, f0, t1, y1, f1, t[j] + ) else: raise ValueError(f"Unknown interpolation method {self.interp}") j += 1 @@ -148,7 +174,9 @@ def integrate(self, t): return solution def integrate_until_event(self, t0, event_fn): - assert self.step_size is not None, "Event handling for fixed step solvers currently requires `step_size` to be provided in options." + assert self.step_size is not None, ( + "Event handling for fixed step solvers currently requires `step_size` to be provided in options." + ) t0 = t0.type_as(self.y0.abs()) y0 = self.y0 @@ -170,10 +198,14 @@ def integrate_until_event(self, t0, event_fn): interp_fn = lambda t: self._linear_interp(t0, t1, y0, y1, t) elif self.interp == "cubic": f1 = self.func(t1, y1) - interp_fn = lambda t: self._cubic_hermite_interp(t0, y0, f0, t1, y1, f1, t) + interp_fn = lambda t: self._cubic_hermite_interp( + t0, y0, f0, t1, y1, f1, t + ) else: raise ValueError(f"Unknown interpolation method {self.interp}") - event_time, y1 = find_event(interp_fn, sign0, t0, t1, event_fn, float(self.atol)) + event_time, y1 = find_event( + interp_fn, sign0, t0, t1, event_fn, float(self.atol) + ) break else: t0, y0 = t1, y1 @@ -182,14 +214,14 @@ def integrate_until_event(self, t0, event_fn): raise RuntimeError(f"Reached maximum number of iterations {max_itrs}.") solution = torch.stack([self.y0, y1], dim=0) return event_time, solution - + def _cubic_hermite_interp(self, t0, y0, f0, t1, y1, f1, t): h = (t - t0) / (t1 - t0) h00 = (1 + 2 * h) * (1 - h) * (1 - h) h10 = h * (1 - h) * (1 - h) h01 = h * h * (3 - 2 * h) h11 = h * h * (h - 1) - dt = (t1 - t0) + dt = t1 - t0 return h00 * y0 + h10 * dt * f0 + h01 * y1 + h11 * dt * f1 def _linear_interp(self, t0, t1, y0, y1, t): @@ -199,4 +231,3 @@ def _linear_interp(self, t0, t1, y0, y1, t): return y1 slope = (t - t0) / (t1 - t0) return y0 + slope * (y1 - y0) - diff --git a/nnodely/support/odeint/utils.py b/src/nnodely/support/odeint/utils.py similarity index 78% rename from nnodely/support/odeint/utils.py rename to src/nnodely/support/odeint/utils.py index 5ec8d6c5..1d4ab3b4 100644 --- a/nnodely/support/odeint/utils.py +++ b/src/nnodely/support/odeint/utils.py @@ -1,22 +1,26 @@ import torch import warnings -_all_callback_names = ['callback_step', 'callback_accept_step', 'callback_reject_step'] -_all_adjoint_callback_names = [name + '_adjoint' for name in _all_callback_names] +_all_callback_names = ["callback_step", "callback_accept_step", "callback_reject_step"] +_all_adjoint_callback_names = [name + "_adjoint" for name in _all_callback_names] _null_callback = lambda *args, **kwargs: None + def _linf_norm(tensor): return tensor.abs().max() + def _rms_norm(tensor): return tensor.abs().pow(2).mean().sqrt() + def _zero_norm(tensor): - return 0. + return 0.0 + def _mixed_norm(tensor_tuple): if len(tensor_tuple) == 0: - return 0. + return 0.0 return max([_rms_norm(tensor) for tensor in tensor_tuple]) @@ -41,8 +45,12 @@ def _tuple_tol(name, tol, shapes): except TypeError: return tol tol = tuple(tol) - assert len(tol) == len(shapes), "If using tupled {} it must have the same length as the tuple y0".format(name) - tol = [torch.as_tensor(tol_).expand(shape.numel()) for tol_, shape in zip(tol, shapes)] + assert len(tol) == len(shapes), ( + "If using tupled {} it must have the same length as the tuple y0".format(name) + ) + tol = [ + torch.as_tensor(tol_).expand(shape.numel()) for tol_, shape in zip(tol, shapes) + ] return torch.cat(tol) @@ -59,17 +67,21 @@ def _flat_to_shape(tensor, length, shapes): def _assert_floating(name, t): if not torch.is_floating_point(t): - raise TypeError('`{}` must be a floating point Tensor but is a {}'.format(name, t.type())) + raise TypeError( + "`{}` must be a floating point Tensor but is a {}".format(name, t.type()) + ) def _check_timelike(name, timelike, can_grad): - assert isinstance(timelike, torch.Tensor), '{} must be a torch.Tensor'.format(name) + assert isinstance(timelike, torch.Tensor), "{} must be a torch.Tensor".format(name) _assert_floating(name, timelike) assert timelike.ndimension() == 1, "{} must be one dimensional".format(name) if not can_grad: assert not timelike.requires_grad, "{} cannot require gradient".format(name) diff = timelike[1:] > timelike[:-1] - assert diff.all() or (~diff).all(), '{} must be strictly increasing or decreasing'.format(name) + assert diff.all() or (~diff).all(), ( + "{} must be strictly increasing or decreasing".format(name) + ) class _TupleFunc(torch.nn.Module): @@ -107,7 +119,9 @@ def _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS): if event_fn is not None: if len(t) != 2: - raise ValueError(f"We require len(t) == 2 when in event handling mode, but got len(t)={len(t)}.") + raise ValueError( + f"We require len(t) == 2 when in event handling mode, but got len(t)={len(t)}." + ) # Combine event functions if the output is multivariate. event_fn = combine_event_functions(event_fn, t[0], y0) @@ -119,10 +133,10 @@ def _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS): shapes = None is_tuple = not isinstance(y0, torch.Tensor) if is_tuple: - assert isinstance(y0, tuple), 'y0 must be either a torch.Tensor or a tuple' + assert isinstance(y0, tuple), "y0 must be either a torch.Tensor or a tuple" shapes = [y0_.shape for y0_ in y0] - rtol = _tuple_tol('rtol', rtol, shapes) - atol = _tuple_tol('atol', atol, shapes) + rtol = _tuple_tol("rtol", rtol, shapes) + atol = _tuple_tol("atol", atol, shapes) y0 = torch.cat([y0_.reshape(-1) for y0_ in y0]) func = _TupleFunc(func, shapes) if event_fn is not None: @@ -134,18 +148,21 @@ def _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS): else: options = options.copy() if method is None: - method = 'dopri5' + method = "dopri5" if method not in SOLVERS: - raise ValueError('Invalid method "{}". Must be one of {}'.format(method, - '{"' + '", "'.join(SOLVERS.keys()) + '"}.')) + raise ValueError( + 'Invalid method "{}". Must be one of {}'.format( + method, '{"' + '", "'.join(SOLVERS.keys()) + '"}.' + ) + ) if is_tuple: # We accept tupled input. This is an abstraction that is hidden from the rest of odeint (exception when # returning values), so here we need to maintain the abstraction by wrapping norm functions. - if 'norm' in options: + if "norm" in options: # If the user passed a norm then get that... - norm = options['norm'] + norm = options["norm"] else: # ...otherwise we default to a mixed Linf/L2 norm over tupled input. norm = _mixed_norm @@ -157,10 +174,11 @@ def _check_inputs(func, y0, t, rtol, atol, method, options, event_fn, SOLVERS): def _norm(tensor): y = _flat_to_shape(tensor, (), shapes) return norm(y) - options['norm'] = _norm + + options["norm"] = _norm else: - if 'norm' in options: + if "norm" in options: # No need to change the norm function. pass else: @@ -168,10 +186,10 @@ def _norm(tensor): # Technically we don't need to set that here (RKAdaptiveStepsizeODESolver has it as a default), but it # makes it easier to reason about, in the adjoint norm logic, if we know that options['norm'] is # definitely set to something. - options['norm'] = _rms_norm + options["norm"] = _rms_norm # Normalise time - _check_timelike('t', t, True) + _check_timelike("t", t, True) t_is_reversed = False if len(t) > 1 and t[0] > t[1]: t_is_reversed = True @@ -188,18 +206,20 @@ def _norm(tensor): # For fixed step solvers. try: - _grid_constructor = options['grid_constructor'] + _grid_constructor = options["grid_constructor"] except KeyError: pass else: - options['grid_constructor'] = lambda func, y0, t: -_grid_constructor(func, y0, -t) + options["grid_constructor"] = lambda func, y0, t: ( + -_grid_constructor(func, y0, -t) + ) # For RK solvers. - #_flip_option(options, 'step_t') - #_flip_option(options, 'jump_t') + # _flip_option(options, 'step_t') + # _flip_option(options, 'jump_t') # Can only do after having normalised time - assert (t[1:] > t[:-1]).all(), 't must be strictly increasing or decreasing' + assert (t[1:] > t[:-1]).all(), "t must be strictly increasing or decreasing" # Tol checking if torch.is_tensor(rtol): @@ -214,7 +234,7 @@ def _norm(tensor): # ~Backward compatibility # Add perturb argument to func. - #func = _PerturbFunc(func) + # func = _PerturbFunc(func) # Add callbacks to wrapped_func callback_names = set() @@ -229,12 +249,16 @@ def _norm(tensor): # At the moment all callbacks have the arguments (t0, y0, dt). # These will need adjusting on a per-callback basis if that changes in the future. if is_tuple: + def callback(t0, y0, dt, _callback=callback): y0 = _flat_to_shape(y0, (), shapes) return _callback(t0, y0, dt) + if t_is_reversed: + def callback(t0, y0, dt, _callback=callback): return _callback(-t0, y0, dt) + setattr(func, callback_name, callback) for callback_name in _all_adjoint_callback_names: try: @@ -246,6 +270,10 @@ def callback(t0, y0, dt, _callback=callback): invalid_callbacks = callback_names - SOLVERS[method].valid_callbacks() if len(invalid_callbacks) > 0: - warnings.warn("Solver '{}' does not support callbacks {}".format(method, invalid_callbacks)) + warnings.warn( + "Solver '{}' does not support callbacks {}".format( + method, invalid_callbacks + ) + ) - return shapes, func, y0, t, rtol, atol, method, options, event_fn, t_is_reversed \ No newline at end of file + return shapes, func, y0, t, rtol, atol, method, options, event_fn, t_is_reversed diff --git a/nnodely/support/utils.py b/src/nnodely/support/utils.py similarity index 77% rename from nnodely/support/utils.py rename to src/nnodely/support/utils.py index 0aff8e20..c50255e5 100644 --- a/nnodely/support/utils.py +++ b/src/nnodely/support/utils.py @@ -1,4 +1,5 @@ -import torch, inspect +import torch +import inspect import types from collections import OrderedDict @@ -13,6 +14,7 @@ ForbiddenTags = keyword.kwlist + class ReadOnlyDict: def __init__(self, data): self._data = data @@ -40,6 +42,7 @@ def values(self): def __repr__(self): from pprint import pformat + return pformat(self._data) def __or__(self, other): @@ -51,6 +54,7 @@ def __or__(self, other): def __str__(self): from nnodely.visualizer.emptyvisualizer import color, GREEN from pprint import pformat + return color(pformat(self._data), GREEN) def __eq__(self, other): @@ -58,19 +62,21 @@ def __eq__(self, other): return self._data == other return self._data == other._data + class ParamDict(ReadOnlyDict): - def __init__(self, data, internal_data = None): + def __init__(self, data, internal_data=None): super().__init__(data) self._internal_data = internal_data if internal_data is not None else {} def __setitem__(self, key, value): - self._data[key]['values'] = value + self._data[key]["values"] = value self._internal_data[key] = self._internal_data[key].new_tensor(value) def __getitem__(self, key): - value = self._data[key]['values'] if 'values' in self._data[key] else None + value = self._data[key]["values"] if "values" in self._data[key] else None return value + def enforce_types(func): @wraps(func) def wrapper(*args, **kwargs): @@ -81,27 +87,35 @@ def wrapper(*args, **kwargs): if len(sig) != len(args): var_type = None for ind, arg in enumerate(args): - if ind < len(list(sig.values())) and list(sig.values())[ind].kind == inspect.Parameter.VAR_POSITIONAL: + if ( + ind < len(list(sig.values())) + and list(sig.values())[ind].kind == inspect.Parameter.VAR_POSITIONAL + ): var_name = list(sig.keys())[ind] var_type = sig.pop(var_name) if var_type: - sig[var_name+str(ind)] = var_type + sig[var_name + str(ind)] = var_type all_args.update(dict(zip(sig, args))) - if 'self' in sig.keys(): - sig.pop('self') - if 'cls' in sig.keys(): - sig.pop('cls') + if "self" in sig.keys(): + sig.pop("self") + if "cls" in sig.keys(): + sig.pop("cls") for arg_name, arg in all_args.items(): - if (arg_name in hints.keys() or arg_name in sig.keys()) and not isinstance(arg,sig[arg_name].annotation): - class_name = func.__qualname__.split('.')[0] + if (arg_name in hints.keys() or arg_name in sig.keys()) and not isinstance( + arg, sig[arg_name].annotation + ): + class_name = func.__qualname__.split(".")[0] if isinstance(sig[arg_name].annotation, types.UnionType): - type_list = [val.__name__ for val in sig[arg_name].annotation.__args__] + type_list = [ + val.__name__ for val in sig[arg_name].annotation.__args__ + ] else: type_list = sig[arg_name].annotation.__name__ raise TypeError( - f"In Function or Class {class_name} the argument '{arg_name}' to be of type {type_list}, but got {type(arg).__name__}") + f"In Function or Class {class_name} the argument '{arg_name}' to be of type {type_list}, but got {type(arg).__name__}" + ) # for arg, arg_type in hints.items(): # if arg in all_args and not isinstance(all_args[arg], arg_type): @@ -112,15 +126,18 @@ def wrapper(*args, **kwargs): return wrapper + def is_notebook(): try: from IPython import get_ipython - if 'IPKernelApp' in get_ipython().config: + + if "IPKernelApp" in get_ipython().config: return True # È un notebook except Exception: pass return False # È uno script + def tensor_to_list(data): if isinstance(data, torch.Tensor): # Converte il tensore in una lista @@ -141,25 +158,35 @@ def tensor_to_list(data): # Altri tipi di dati rimangono invariati return data -def get_batch_size(n_samples, batch_size = None, predicion_samples = 0): + +def get_batch_size(n_samples, batch_size=None, predicion_samples=0): batch_size = batch_size if batch_size is not None else n_samples - predicion_samples = 0 if predicion_samples == -1 else predicion_samples #This value is used to disconnect the connect - batch_size = batch_size if batch_size <= n_samples - predicion_samples else max(0, n_samples - predicion_samples) - check(batch_size > 0, ValueError, f'The batch_size must be greater than 0.') + predicion_samples = ( + 0 if predicion_samples == -1 else predicion_samples + ) # This value is used to disconnect the connect + batch_size = ( + batch_size + if batch_size <= n_samples - predicion_samples + else max(0, n_samples - predicion_samples) + ) + check(batch_size > 0, ValueError, "The batch_size must be greater than 0.") return batch_size + def check_and_get_list(name_list, available_names, error_fun): if type(name_list) is str: name_list = [name_list] if type(name_list) is list: for name in name_list: - check(name in available_names, IndexError, error_fun(name)) + check(name in available_names, IndexError, error_fun(name)) return name_list + def check(condition, exception, string): if not condition: raise exception(string) + # Function used to verified the number of gradient operations in the graph # def count_gradient_operations(grad_fn): # count = 0 @@ -176,4 +203,4 @@ def check(condition, exception, string): # count = 0 # for key in X.keys(): # count += count_gradient_operations(X[key].grad_fn) -# return count \ No newline at end of file +# return count diff --git a/nnodely/visualizer/__init__.py b/src/nnodely/visualizer/__init__.py similarity index 95% rename from nnodely/visualizer/__init__.py rename to src/nnodely/visualizer/__init__.py index 43263770..1f668dc4 100644 --- a/nnodely/visualizer/__init__.py +++ b/src/nnodely/visualizer/__init__.py @@ -1,4 +1,4 @@ from nnodely.visualizer.emptyvisualizer import EmptyVisualizer from nnodely.visualizer.textvisualizer import TextVisualizer from nnodely.visualizer.mplvisualizer import MPLVisualizer -from nnodely.visualizer.mplnotebookvisualizer import MPLNotebookVisualizer \ No newline at end of file +from nnodely.visualizer.mplnotebookvisualizer import MPLNotebookVisualizer diff --git a/nnodely/visualizer/dynamicmpl/functionplot.py b/src/nnodely/visualizer/dynamicmpl/functionplot.py similarity index 61% rename from nnodely/visualizer/dynamicmpl/functionplot.py rename to src/nnodely/visualizer/dynamicmpl/functionplot.py index c640814a..74fe533f 100644 --- a/nnodely/visualizer/dynamicmpl/functionplot.py +++ b/src/nnodely/visualizer/dynamicmpl/functionplot.py @@ -1,4 +1,5 @@ -import sys, json +import sys +import json import matplotlib.pyplot as plt @@ -13,17 +14,17 @@ try: # Convert to float and append to buffer data_point = json.loads(line) - name = data_point['name'] - if 'x1' in data_point.keys(): - x0 = data_point['x0'] - x1 = data_point['x1'] + name = data_point["name"] + if "x1" in data_point.keys(): + x0 = data_point["x0"] + x1 = data_point["x1"] else: - x = data_point['x0'] - params = data_point['params'] - input_names = data_point['input_names'] - output = data_point['output'] + x = data_point["x0"] + params = data_point["params"] + input_names = data_point["input_names"] + output = data_point["output"] - if 'x1' in data_point.keys(): + if "x1" in data_point.keys(): plots.plot_3d_function(plt, name, x0, x1, params, output, input_names) else: plots.plot_2d_function(plt, name, x, params, output, input_names) @@ -31,4 +32,3 @@ except ValueError: pass - diff --git a/nnodely/visualizer/dynamicmpl/fuzzyplot.py b/src/nnodely/visualizer/dynamicmpl/fuzzyplot.py similarity index 68% rename from nnodely/visualizer/dynamicmpl/fuzzyplot.py rename to src/nnodely/visualizer/dynamicmpl/fuzzyplot.py index 6717f8cc..3b49f196 100644 --- a/nnodely/visualizer/dynamicmpl/fuzzyplot.py +++ b/src/nnodely/visualizer/dynamicmpl/fuzzyplot.py @@ -1,4 +1,5 @@ -import sys, json +import sys +import json import matplotlib.pyplot as plt import matplotlib.colors as mcolors @@ -14,13 +15,13 @@ try: # Convert to float and append to buffer data_point = json.loads(line) - name = data_point['name'] - x = data_point['x'] - chan_centers = data_point['chan_centers'] + name = data_point["name"] + x = data_point["x"] + chan_centers = data_point["chan_centers"] tableau_colors = mcolors.TABLEAU_COLORS num_of_colors = len(list(tableau_colors.keys())) - for ind, key in enumerate(data_point['y'].keys()): - y.append(data_point['y'][key]) + for ind, key in enumerate(data_point["y"].keys()): + y.append(data_point["y"][key]) fig, ax = plt.subplots() ax.cla() @@ -28,4 +29,4 @@ plt.show() except ValueError: - pass \ No newline at end of file + pass diff --git a/nnodely/visualizer/dynamicmpl/resultsplot.py b/src/nnodely/visualizer/dynamicmpl/resultsplot.py similarity index 68% rename from nnodely/visualizer/dynamicmpl/resultsplot.py rename to src/nnodely/visualizer/dynamicmpl/resultsplot.py index c94a167f..9db0fbc5 100644 --- a/nnodely/visualizer/dynamicmpl/resultsplot.py +++ b/src/nnodely/visualizer/dynamicmpl/resultsplot.py @@ -1,6 +1,7 @@ import json import sys import os + # append a new directory to sys.path sys.path.append(os.getcwd()) @@ -17,12 +18,12 @@ try: # Convert to float and append to buffer data_point = json.loads(line) - name_data = data_point['name_data'] - key = data_point['key'] - A = data_point['prediction_A'] - B = data_point['prediction_B'] - data_idxs = data_point['data_idxs'] - sample_time = data_point['sample_time'] + name_data = data_point["name_data"] + key = data_point["key"] + A = data_point["prediction_A"] + B = data_point["prediction_B"] + data_idxs = data_point["data_idxs"] + sample_time = data_point["sample_time"] fig, ax = plt.subplots() ax.cla() @@ -30,4 +31,4 @@ plt.show() except ValueError: - pass \ No newline at end of file + pass diff --git a/nnodely/visualizer/dynamicmpl/trainingplot.py b/src/nnodely/visualizer/dynamicmpl/trainingplot.py similarity index 78% rename from nnodely/visualizer/dynamicmpl/trainingplot.py rename to src/nnodely/visualizer/dynamicmpl/trainingplot.py index 0b3b87e4..cd153d30 100644 --- a/nnodely/visualizer/dynamicmpl/trainingplot.py +++ b/src/nnodely/visualizer/dynamicmpl/trainingplot.py @@ -1,5 +1,6 @@ import sys import os + # append a new directory to sys.path sys.path.append(os.getcwd()) @@ -19,6 +20,7 @@ # Set up the plot fig, ax = plt.subplots() + def update_graph(frame): global last, title, epoch if last > 0: @@ -28,13 +30,13 @@ def update_graph(frame): try: # Convert to float and append to buffer data = json.loads(line) - data_train.append(data['train_losses']) - if data['val_losses']: - data_val.append(data['val_losses']) - title = data['title'] - key = data['key'] - last = data['last'] - epoch = data['epoch'] + data_train.append(data["train_losses"]) + if data["val_losses"]: + data_val.append(data["val_losses"]) + title = data["title"] + key = data["key"] + last = data["last"] + epoch = data["epoch"] # Clear the current plot ax.cla() # Clear the current plot @@ -44,6 +46,7 @@ def update_graph(frame): else: pass + # Use FuncAnimation to update the plot dynamically ani = animation.FuncAnimation(fig, update_graph, interval=10, save_count=20) diff --git a/nnodely/visualizer/emptyvisualizer.py b/src/nnodely/visualizer/emptyvisualizer.py similarity index 84% rename from nnodely/visualizer/emptyvisualizer.py rename to src/nnodely/visualizer/emptyvisualizer.py index d71abb8c..ac72115a 100644 --- a/nnodely/visualizer/emptyvisualizer.py +++ b/src/nnodely/visualizer/emptyvisualizer.py @@ -8,11 +8,13 @@ BOLD_SEQ = "\033[1m" BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8) -def color(msg, color_val = GREEN, bold = False): + +def color(msg, color_val=GREEN, bold=False): if bold: return COLOR_BOLD_SEQ % (30 + color_val) + msg + RESET_SEQ return COLOR_SEQ % (30 + color_val) + msg + RESET_SEQ + class EmptyVisualizer: def __init__(self): pass @@ -23,7 +25,7 @@ def setModely(self, modely): def showModel(self, model): pass - def showaddMinimize(self,variable_name): + def showaddMinimize(self, variable_name): pass def showModelInputWindow(self): @@ -35,13 +37,13 @@ def showModelRelationSamples(self): def showBuiltModel(self): pass - def showWeights(self, weights = None): + def showWeights(self, weights=None): pass - def showFunctions(self, functions = None): + def showFunctions(self, functions=None): pass - def showWeightsInTrain(self, batch = None, epoch = None, weights = None): + def showWeightsInTrain(self, batch=None, epoch=None, weights=None): pass def showDataset(self, name): diff --git a/nnodely/visualizer/mplnotebookvisualizer.py b/src/nnodely/visualizer/mplnotebookvisualizer.py similarity index 50% rename from nnodely/visualizer/mplnotebookvisualizer.py rename to src/nnodely/visualizer/mplnotebookvisualizer.py index 4a9d4428..3d66ac53 100644 --- a/nnodely/visualizer/mplnotebookvisualizer.py +++ b/src/nnodely/visualizer/mplnotebookvisualizer.py @@ -7,80 +7,109 @@ from nnodely.support.utils import check from mplplots import plots + class MPLNotebookVisualizer(TextVisualizer): - def __init__(self, verbose = 1, *, test = False): + def __init__(self, verbose=1, *, test=False): super().__init__(verbose) self.test = test if self.test: plt.ion() def showEndTraining(self, epoch, train_losses, val_losses): - train_tag = self.modely.running_parameters['train_tag'] - val_tag = self.modely.running_parameters['val_tag'] - for key in self.modely.json['Minimizers'].keys(): + train_tag = self.modely.running_parameters["train_tag"] + val_tag = self.modely.running_parameters["val_tag"] + for key in self.modely.json["Minimizers"].keys(): fig = plt.figure() ax = fig.add_subplot(111) if val_losses: - plots.plot_training(ax, f"Training on {train_tag} and {val_tag}", key, train_losses[key], val_losses[key]) + plots.plot_training( + ax, + f"Training on {train_tag} and {val_tag}", + key, + train_losses[key], + val_losses[key], + ) else: - plots.plot_training(ax, f"Training on {train_tag}", key, train_losses[key]) + plots.plot_training( + ax, f"Training on {train_tag}", key, train_losses[key] + ) plt.show() def showResult(self, name_data): super().showResult(name_data) - for key in self.modely.json['Minimizers'].keys(): + for key in self.modely.json["Minimizers"].keys(): fig = plt.figure() ax = fig.add_subplot(111) - np_data_A = np.array(self.modely.prediction[name_data][key]['A']) + np_data_A = np.array(self.modely.prediction[name_data][key]["A"]) if len(np_data_A.shape) > 3 and np_data_A.shape[1] > 30: - np_data_B = np.array(self.modely.prediction[name_data][key]['B']) + np_data_B = np.array(self.modely.prediction[name_data][key]["B"]) indices = np.linspace(0, np_data_A.shape[1] - 1, 30, dtype=int) data_A = np_data_A[:, indices, :, :].tolist() data_B = np_data_B[:, indices, :, :].tolist() - data_idxs = np.array(self.modely.prediction[name_data]['idxs'])[:,indices].tolist() + data_idxs = np.array(self.modely.prediction[name_data]["idxs"])[ + :, indices + ].tolist() else: - data_A = self.modely.prediction[name_data][key]['A'] - data_B = self.modely.prediction[name_data][key]['B'] - data_idxs = self.modely.prediction[name_data]['idxs'] if len(np_data_A.shape) > 3 else None + data_A = self.modely.prediction[name_data][key]["A"] + data_B = self.modely.prediction[name_data][key]["B"] + data_idxs = ( + self.modely.prediction[name_data]["idxs"] + if len(np_data_A.shape) > 3 + else None + ) - plots.plot_results(ax, name_data, key, data_A, - data_B, data_idxs, self.modely._model_def['Info']["SampleTime"]) + plots.plot_results( + ax, + name_data, + key, + data_A, + data_B, + data_idxs, + self.modely._model_def["Info"]["SampleTime"], + ) plt.show() - def showWeights(self, weights = None): + def showWeights(self, weights=None): pass - def showFunctions(self, functions = None, xlim = None, num_points = 1000): + def showFunctions(self, functions=None, xlim=None, num_points=1000): check(self.modely.neuralized, ValueError, "The model has not been neuralized.") - for fun, value in self.modely._model_def['Functions'].items(): + for fun, value in self.modely._model_def["Functions"].items(): if fun in functions: - if 'functions' in self.modely._model_def['Functions'][fun]: + if "functions" in self.modely._model_def["Functions"][fun]: x, activ_fun = return_fuzzify(value, xlim, num_points) fig = plt.figure() ax = fig.add_subplot(111) - plots.plot_fuzzy(ax, fun, x, activ_fun, value['centers']) - elif 'code': - function_inputs = return_standard_inputs(value, self.modely._model_def, xlim, num_points) - function_output, function_input_list = return_function(value, function_inputs) - if value['n_input'] == 2: + plots.plot_fuzzy(ax, fun, x, activ_fun, value["centers"]) + elif "code": + function_inputs = return_standard_inputs( + value, self.modely._model_def, xlim, num_points + ) + function_output, function_input_list = return_function( + value, function_inputs + ) + if value["n_input"] == 2: x0 = function_inputs[0].reshape(num_points, num_points).tolist() x1 = function_inputs[1].reshape(num_points, num_points).tolist() - output = function_output.reshape(num_points, num_points).tolist() + output = function_output.reshape( + num_points, num_points + ).tolist() params = [] - for i, key in enumerate(value['params_and_consts']): - params += [function_inputs[i + value['n_input']].tolist()] - plots.plot_3d_function(plt, fun, x0, x1, params, output, function_input_list) + for i, key in enumerate(value["params_and_consts"]): + params += [function_inputs[i + value["n_input"]].tolist()] + plots.plot_3d_function( + plt, fun, x0, x1, params, output, function_input_list + ) else: x = function_inputs[0].reshape(num_points).tolist() output = function_output.reshape(num_points).tolist() params = [] - for i, key in enumerate(value['params_and_consts']): - params += [function_inputs[i + value['n_input']].tolist()] - plots.plot_2d_function(plt, fun, x, params, output, function_input_list) + for i, key in enumerate(value["params_and_consts"]): + params += [function_inputs[i + value["n_input"]].tolist()] + plots.plot_2d_function( + plt, fun, x, params, output, function_input_list + ) plt.show() def closePlots(self): plt.close() - - - diff --git a/nnodely/visualizer/mplvisualizer.py b/src/nnodely/visualizer/mplvisualizer.py similarity index 55% rename from nnodely/visualizer/mplvisualizer.py rename to src/nnodely/visualizer/mplvisualizer.py index c1a130ad..ef4c5321 100644 --- a/nnodely/visualizer/mplvisualizer.py +++ b/src/nnodely/visualizer/mplvisualizer.py @@ -1,4 +1,7 @@ -import subprocess, json, os, importlib +import subprocess +import json +import os +import importlib import numpy as np from nnodely.visualizer.textvisualizer import TextVisualizer @@ -8,28 +11,41 @@ from nnodely.basic.modeldef import ModelDef from nnodely.support.logger import logging, nnLogger + log = nnLogger(__name__, logging.INFO) + def get_library_path(library_name): spec = importlib.util.find_spec(library_name) if spec is None: raise ImportError(f"Library {library_name} not found") return os.path.dirname(spec.origin) + class MPLVisualizer(TextVisualizer): - def __init__(self, verbose = 1): + def __init__(self, verbose=1): super().__init__(verbose) # Path to the data visualizer script import signal import sys - get_library_path('nnodely') - self.__training_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer','dynamicmpl','trainingplot.py') - self.__time_series_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer','dynamicmpl','resultsplot.py') - self.__fuzzy_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer','dynamicmpl','fuzzyplot.py') - self.__function_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer','dynamicmpl','functionplot.py') + + get_library_path("nnodely") + self.__training_visualizer_script = os.path.join( + get_library_path("nnodely"), "visualizer", "dynamicmpl", "trainingplot.py" + ) + self.__time_series_visualizer_script = os.path.join( + get_library_path("nnodely"), "visualizer", "dynamicmpl", "resultsplot.py" + ) + self.__fuzzy_visualizer_script = os.path.join( + get_library_path("nnodely"), "visualizer", "dynamicmpl", "fuzzyplot.py" + ) + self.__function_visualizer_script = os.path.join( + get_library_path("nnodely"), "visualizer", "dynamicmpl", "functionplot.py" + ) self.__process_training = {} self.__process_results = {} self.__process_function = {} + def signal_handler(sig, frame): for key in self.__process_training.keys(): self.__process_training[key].terminate() @@ -52,28 +68,41 @@ def showStartTraining(self): def showTraining(self, epoch, train_losses, val_losses): if epoch == 0: for key in self.__process_training.keys(): - if self.__process_training[key] is not None and self.__process_training[key].poll() is None: + if ( + self.__process_training[key] is not None + and self.__process_training[key].poll() is None + ): self.__process_training[key].terminate() self.__process_training[key].wait() self.__process_training[key] = None self.__process_training = {} - for key in self.modely._model_def['Minimizers'].keys(): - self.__process_training[key] = subprocess.Popen(['python', self.__training_visualizer_script], stdin=subprocess.PIPE, text=True) - - num_of_epochs = self.modely.running_parameters['num_of_epochs'] - train_tag = self.modely.running_parameters['train_tag'] - val_tag = self.modely.running_parameters['val_tag'] - if epoch+1 <= num_of_epochs: - for key in self.modely._model_def['Minimizers'].keys(): + for key in self.modely._model_def["Minimizers"].keys(): + self.__process_training[key] = subprocess.Popen( + ["python", self.__training_visualizer_script], + stdin=subprocess.PIPE, + text=True, + ) + + num_of_epochs = self.modely.running_parameters["num_of_epochs"] + train_tag = self.modely.running_parameters["train_tag"] + val_tag = self.modely.running_parameters["val_tag"] + if epoch + 1 <= num_of_epochs: + for key in self.modely._model_def["Minimizers"].keys(): if val_losses: val_loss = val_losses[key][epoch] title = f"Training on {train_tag} and {val_tag}" else: val_loss = [] title = f"Training on {train_tag}" - data = {"title":title, "key": key, "last": num_of_epochs - (epoch + 1), "epoch": epoch, - "train_losses": train_losses[key][epoch], "val_losses": val_loss} + data = { + "title": title, + "key": key, + "last": num_of_epochs - (epoch + 1), + "epoch": epoch, + "train_losses": train_losses[key][epoch], + "val_losses": val_loss, + } try: # Send data to the visualizer process self.__process_training[key].stdin.write(f"{json.dumps(data)}\n") @@ -82,98 +111,139 @@ def showTraining(self, epoch, train_losses, val_losses): self.closeTraining() log.warning("The visualizer process has been closed.") - if epoch+1 == num_of_epochs: - for key in self.modely._model_def['Minimizers'].keys(): + if epoch + 1 == num_of_epochs: + for key in self.modely._model_def["Minimizers"].keys(): if self.__process_training[key] is not None: self.__process_training[key].stdin.close() def showResult(self, name_data): super().showResult(name_data) - check(name_data in self.modely.performance, ValueError, f"Results not available for {name_data}.") + check( + name_data in self.modely.performance, + ValueError, + f"Results not available for {name_data}.", + ) if name_data in self.__process_results: - for key in self.modely._model_def['Minimizers'].keys(): - if key in self.__process_results[name_data] and self.__process_results[name_data][key].poll() is None: + for key in self.modely._model_def["Minimizers"].keys(): + if ( + key in self.__process_results[name_data] + and self.__process_results[name_data][key].poll() is None + ): self.__process_results[name_data][key].terminate() self.__process_results[name_data][key].wait() self.__process_results[name_data][key] = None self.__process_results[name_data] = {} - for key in self.modely._model_def['Minimizers'].keys(): + for key in self.modely._model_def["Minimizers"].keys(): # Start the data visualizer process - self.__process_results[name_data][key] = subprocess.Popen(['python', self.__time_series_visualizer_script], stdin=subprocess.PIPE, - text=True) - np_data_A = np.array(self.modely.prediction[name_data][key]['A']) + self.__process_results[name_data][key] = subprocess.Popen( + ["python", self.__time_series_visualizer_script], + stdin=subprocess.PIPE, + text=True, + ) + np_data_A = np.array(self.modely.prediction[name_data][key]["A"]) if len(np_data_A.shape) > 3 and np_data_A.shape[1] > 30: - np_data_B = np.array(self.modely.prediction[name_data][key]['B']) + np_data_B = np.array(self.modely.prediction[name_data][key]["B"]) indices = np.linspace(0, np_data_A.shape[1] - 1, 30, dtype=int) data_A = np_data_A[:, indices, :, :].tolist() data_B = np_data_B[:, indices, :, :].tolist() - data_idxs = np.array(self.modely.prediction[name_data]['idxs'])[:,indices].tolist() + data_idxs = np.array(self.modely.prediction[name_data]["idxs"])[ + :, indices + ].tolist() else: - data_A = self.modely.prediction[name_data][key]['A'] - data_B = self.modely.prediction[name_data][key]['B'] - data_idxs = self.modely.prediction[name_data]['idxs'] if len(np_data_A.shape) > 3 else None + data_A = self.modely.prediction[name_data][key]["A"] + data_B = self.modely.prediction[name_data][key]["B"] + data_idxs = ( + self.modely.prediction[name_data]["idxs"] + if len(np_data_A.shape) > 3 + else None + ) - data = {"name_data": name_data, - "key": key, - "performance": self.modely.performance[name_data][key], - "prediction_A": data_A, - "prediction_B": data_B, - "data_idxs": data_idxs, - "sample_time": self.modely._model_def['Info']["SampleTime"]} + data = { + "name_data": name_data, + "key": key, + "performance": self.modely.performance[name_data][key], + "prediction_A": data_A, + "prediction_B": data_B, + "data_idxs": data_idxs, + "sample_time": self.modely._model_def["Info"]["SampleTime"], + } try: # Send data to the visualizer process - self.__process_results[name_data][key].stdin.write(f"{json.dumps(data)}\n") + self.__process_results[name_data][key].stdin.write( + f"{json.dumps(data)}\n" + ) self.__process_results[name_data][key].stdin.flush() self.__process_results[name_data][key].stdin.close() except: self.closeResult(self, name_data) log.warning(f"The visualizer {name_data} process has been closed.") - def showWeights(self, weights = None): + def showWeights(self, weights=None): pass - def showFunctions(self, functions = None, xlim = None, num_points = 1000): + def showFunctions(self, functions=None, xlim=None, num_points=1000): check(self.modely.neuralized, ValueError, "The model has not been neuralized.") - for key, value in self.modely._model_def['Functions'].items(): + for key, value in self.modely._model_def["Functions"].items(): if key in functions: - if key in self.__process_function and self.__process_function[key].poll() is None: + if ( + key in self.__process_function + and self.__process_function[key].poll() is None + ): self.__process_function[key].terminate() self.__process_function[key].wait() - if 'functions' in self.modely._model_def['Functions'][key]: + if "functions" in self.modely._model_def["Functions"][key]: x, activ_fun = return_fuzzify(value, xlim, num_points) - data = {"name": key, - "x": x, - "y": activ_fun, - "chan_centers": value['centers']} + data = { + "name": key, + "x": x, + "y": activ_fun, + "chan_centers": value["centers"], + } # Start the data visualizer process - self.__process_function[key] = subprocess.Popen(['python', self.__fuzzy_visualizer_script], - stdin=subprocess.PIPE, - text=True) - elif 'code': + self.__process_function[key] = subprocess.Popen( + ["python", self.__fuzzy_visualizer_script], + stdin=subprocess.PIPE, + text=True, + ) + elif "code": model_def = ModelDef(self.modely._model_def) model_def.updateParameters(self.modely._model) - function_inputs = return_standard_inputs(value, model_def, xlim, num_points) - function_output, function_input_list = return_function(value, function_inputs) + function_inputs = return_standard_inputs( + value, model_def, xlim, num_points + ) + function_output, function_input_list = return_function( + value, function_inputs + ) data = {"name": key} - if value['n_input'] == 2: - data['x0'] = function_inputs[0].reshape(num_points, num_points).tolist() - data['x1'] = function_inputs[1].reshape(num_points, num_points).tolist() - data['output'] = function_output.reshape(num_points, num_points).tolist() + if value["n_input"] == 2: + data["x0"] = ( + function_inputs[0].reshape(num_points, num_points).tolist() + ) + data["x1"] = ( + function_inputs[1].reshape(num_points, num_points).tolist() + ) + data["output"] = function_output.reshape( + num_points, num_points + ).tolist() else: - data['x0'] = function_inputs[0].reshape(num_points).tolist() - data['output'] = function_output.reshape(num_points).tolist() - data['params'] = [] - for i, key in enumerate(value['params_and_consts']): - data['params'] += [function_inputs[i+value['n_input']].tolist()] - data['input_names'] = function_input_list + data["x0"] = function_inputs[0].reshape(num_points).tolist() + data["output"] = function_output.reshape(num_points).tolist() + data["params"] = [] + for i, key in enumerate(value["params_and_consts"]): + data["params"] += [ + function_inputs[i + value["n_input"]].tolist() + ] + data["input_names"] = function_input_list # Start the data visualizer process - self.__process_function[key] = subprocess.Popen(['python', self.__function_visualizer_script], - stdin=subprocess.PIPE, - text=True) + self.__process_function[key] = subprocess.Popen( + ["python", self.__function_visualizer_script], + stdin=subprocess.PIPE, + text=True, + ) try: # Send data to the visualizer process self.__process_function[key].stdin.write(f"{json.dumps(data)}\n") @@ -183,7 +253,7 @@ def showFunctions(self, functions = None, xlim = None, num_points = 1000): self.closeFunctions() log.warning(f"The visualizer {functions} process has been closed.") - def closeFunctions(self, functions = None): + def closeFunctions(self, functions=None): if functions is None: for key in self.__process_function.keys(): self.__process_function[key].terminate() @@ -195,10 +265,14 @@ def closeFunctions(self, functions = None): self.__process_function[key].wait() self.__process_function.pop(key) - def closeTraining(self, minimizer = None): + def closeTraining(self, minimizer=None): if minimizer is None: - for key in self.modely._model_def['Minimizers'].keys(): - if key in self.__process_training and self.__process_training[key] is not None and self.__process_training[key].poll() is None: + for key in self.modely._model_def["Minimizers"].keys(): + if ( + key in self.__process_training + and self.__process_training[key] is not None + and self.__process_training[key].poll() is None + ): self.__process_training[key].terminate() self.__process_training[key].wait() self.__process_training[key] = None @@ -207,9 +281,13 @@ def closeTraining(self, minimizer = None): self.__process_training[minimizer].wait() self.__process_training.pop(minimizer) - def closeResult(self, name_data = None, minimizer = None): + def closeResult(self, name_data=None, minimizer=None): if name_data is None: - check(minimizer is None, ValueError, "If name_data is None, minimizer must be None.") + check( + minimizer is None, + ValueError, + "If name_data is None, minimizer must be None.", + ) for name_data in self.__process_results.keys(): for key in self.__process_results[name_data].keys(): self.__process_results[name_data][key].terminate() diff --git a/src/nnodely/visualizer/textvisualizer.py b/src/nnodely/visualizer/textvisualizer.py new file mode 100644 index 00000000..649ef1bb --- /dev/null +++ b/src/nnodely/visualizer/textvisualizer.py @@ -0,0 +1,493 @@ +import numpy as np +from pprint import pformat + +from nnodely.visualizer.emptyvisualizer import EmptyVisualizer, color, GREEN, BLUE + + +class TextVisualizer(EmptyVisualizer): + def __init__(self, verbose=1): + self.verbose = verbose + + def __title(self, msg, lenght=80): + print(color((msg).center(lenght, "="), GREEN, True)) + + def __subtitle(self, msg, lenght=80): + print(color((msg).center(lenght, "-"), GREEN, True)) + + def __line(self): + print(color("=".center(80, "="), GREEN)) + + def __singleline(self): + print(color("-".center(80, "-"), GREEN)) + + def __info(self, name, dim=30): + print(color((name).ljust(dim), BLUE)) + + def __paramjson(self, name, value, dim=30): + lines = pformat(value, width=80 - dim).strip().splitlines() + vai = ("\n" + (" " * dim)).join(x for x in lines) + # pformat(value).strip().splitlines().rjust(40) + print(color((name).ljust(dim) + vai, GREEN)) + + def __param(self, name, value, dim=30): + print(color((name).ljust(dim) + value, GREEN)) + + def showModel(self, model): + if self.verbose >= 1: + self.__title(" nnodely Model ") + print(color(pformat(model), GREEN)) + self.__line() + + def showMinimize(self, variable_name): + if self.verbose >= 2: + self.__title( + f" Minimize Error of {variable_name} between" + f" {self.modely._model_def['Minimizers'][variable_name]['A']} and" + f" {self.modely._model_def['Minimizers'][variable_name]['B']} with {self.modely._model_def['Minimizers'][variable_name]['loss']} " + ) + self.__line() + + def showModelInputWindow(self): + if self.verbose >= 2: + input_ns_backward = { + key: value["ns"][0] + for key, value in self.modely._model_def["Inputs"].items() + } + input_ns_forward = { + key: value["ns"][1] + for key, value in self.modely._model_def["Inputs"].items() + } + self.__title(" nnodely Model Input Windows ") + # self.__paramjson("time_window_backward:",self.modely.input_tw_backward) + # self.__paramjson("time_window_forward:",self.modely.input_tw_forward) + self.__paramjson("sample_window_backward:", input_ns_backward) + self.__paramjson("sample_window_forward:", input_ns_forward) + self.__paramjson("input_n_samples:", self.modely._input_n_samples) + self.__param( + "max_samples [backw, forw]:", + f"[{self.modely._model_def['Info']['ns'][0]},{self.modely._model_def['Info']['ns'][1]}]", + ) + self.__param("max_samples total:", f"{self.modely._max_n_samples}") + self.__line() + + def showModelRelationSamples(self): + if self.verbose >= 2: + self.__title(" nnodely Model Relation Samples ") + self.__paramjson("Relation_samples:", self.modely.relation_samples) + self.__line() + + def showBuiltModel(self): + if self.verbose >= 2: + self.__title(" nnodely Built Model ") + print(color(pformat(self.modely._model), GREEN)) + self.__line() + + def showWeights(self, weights=None): + self.__title(" nnodely Models Weights ") + for key, param in self.modely.parameters.items(): + if weights is None or key in weights: + self.__paramjson(key, param) + self.__line() + + def showWeightsInTrain(self, batch=None, epoch=None, weights=None): + if self.verbose >= 2: + par = self.modely.running_parameters + dim = len(self.modely._model_def["Minimizers"]) + COLOR = BLUE + if epoch is not None: + print( + color( + "|" + + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, " ") + + "|", + COLOR, + ), + end="", + ) + print( + color( + (f" Params end epochs {epoch + 1} ").center( + 20 * (dim + 1) - 1, "-" + ) + + "|", + COLOR, + ) + ) + + if batch is not None: + print( + color("|" + (f"{batch + 1}").center(10, " ") + "|", COLOR), end="" + ) + print( + color( + (f" Params end batch {batch + 1} ").center( + 20 * (dim + 1) - 1, "-" + ) + + "|", + COLOR, + ) + ) + + for key, param in self.modely.parameters.items(): + if weights is None or key in weights: + print(color("|" + (f"{key}").center(10, " ") + "|", COLOR), end="") + print( + color((f"{param}").center(20 * (dim + 1) - 1, " ") + "|", COLOR) + ) + + if epoch is not None: + print(color("|" + ("").center(10 + 20 * (dim + 1), "-") + "|")) + + def showDataset(self, name): + if self.verbose >= 1: + self.__title(" nnodely Model Dataset ") + self.__param("Dataset Name:", name) + self.__param("Number of files:", f"{self.modely._file_count}") + self.__param( + "Total number of samples:", f"{self.modely._num_of_samples[name]}" + ) + for key in self.modely._model_def["Inputs"].keys(): + if key in self.modely._data[name].keys(): + self.__param( + f"Shape of {key}:", f"{self.modely._data[name][key].shape}" + ) + self.__line() + + def showStartTraining(self): + if self.verbose >= 1: + par = self.modely.running_parameters + dim = len(self.modely._model_def["Minimizers"]) + self.__title( + " nnodely Training ", + 12 + (len(self.modely._model_def["Minimizers"]) + 1) * 20, + ) + print(color("|" + ("Epoch").center(10, " ") + "|"), end="") + for key in self.modely._model_def["Minimizers"].keys(): + print(color((f"{key}").center(19, " ") + "|"), end="") + print(color(("Total").center(19, " ") + "|")) + + print(color("|" + (" ").center(10, " ") + "|"), end="") + for key in self.modely._model_def["Minimizers"].keys(): + print(color(("Loss").center(19, " ") + "|"), end="") + print(color(("Loss").center(19, " ") + "|")) + + print(color("|" + (" ").center(10, " ") + "|"), end="") + for key in self.modely._model_def["Minimizers"].keys(): + if par["n_samples_val"]: + print(color(("train").center(9, " ") + "|"), end="") + print(color(("val").center(9, " ") + "|"), end="") + else: + print(color(("train").center(19, " ") + "|"), end="") + if par["n_samples_val"]: + print(color(("train").center(9, " ") + "|"), end="") + print(color(("val").center(9, " ") + "|")) + else: + print(color(("train").center(19, " ") + "|")) + + print(color("|" + ("").center(10 + 20 * (dim + 1), "-") + "|")) + + def showTraining(self, epoch, train_losses, val_losses): + if self.verbose >= 1: + eng = lambda val: np.format_float_scientific(val, precision=3) + par = self.modely.running_parameters + show_epoch = ( + 1 if par["num_of_epochs"] <= 100 else int(par["num_of_epochs"] / 100) + ) + dim = len(self.modely._model_def["Minimizers"]) + if epoch < par["num_of_epochs"]: + print("", end="\r") + print( + "|" + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, " ") + "|", + end="", + ) + train_loss = [] + val_loss = [] + for key in self.modely._model_def["Minimizers"].keys(): + train_loss.append(train_losses[key][epoch]) + if val_losses: + val_loss.append(val_losses[key][epoch]) + print( + (f"{eng(train_losses[key][epoch])}").center(9, " ") + "|", + end="", + ) + print( + (f"{eng(val_losses[key][epoch])}").center(9, " ") + "|", + end="", + ) + else: + print( + (f"{eng(train_losses[key][epoch])}").center(19, " ") + "|", + end="", + ) + + if val_losses: + print((f"{eng(np.mean(train_loss))}").center(9, " ") + "|", end="") + print((f"{eng(np.mean(val_loss))}").center(9, " ") + "|", end="") + else: + print((f"{eng(np.mean(train_loss))}").center(19, " ") + "|", end="") + + if (epoch + 1) % show_epoch == 0: + print("", end="\r") + print( + color( + "|" + + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, " ") + + "|" + ), + end="", + ) + for key in self.modely._model_def["Minimizers"].keys(): + if val_losses: + print( + color( + (f"{eng(train_losses[key][epoch])}").center(9, " ") + + "|" + ), + end="", + ) + print( + color( + (f"{eng(val_losses[key][epoch])}").center(9, " ") + + "|" + ), + end="", + ) + else: + print( + color( + (f"{eng(train_losses[key][epoch])}").center(19, " ") + + "|" + ), + end="", + ) + if val_losses: + print( + color((f"{eng(np.mean(train_loss))}").center(9, " ") + "|"), + end="", + ) + print(color((f"{eng(np.mean(val_loss))}").center(9, " ") + "|")) + else: + print( + color((f"{eng(np.mean(train_loss))}").center(19, " ") + "|") + ) + + if epoch + 1 == par["num_of_epochs"]: + print(color("|" + ("").center(10 + 20 * (dim + 1), "-") + "|")) + + def showTrainingTime(self, time): + if self.verbose >= 1: + self.__title(" nnodely Training Time ") + self.__param("Total time of Training:", f"{time}") + self.__line() + + def showTrainParams(self): + if self.verbose >= 1: + self.__title(" nnodely Model Train Parameters ") + par = self.modely.getTrainingInfo() + + self.__paramjson("models:", par["models"]) + self.__param("num of epochs:", str(par["num_of_epochs"])) + self.__param("update per epochs:", str(par["update_per_epochs"])) + if par["prediction_samples"] >= 0: + self.__info("└>len(train_indexes)//(batch_size+step)") + else: + self.__info("└>(n_samples-batch_size)/batch_size+1") + + if par["shuffle_data"]: + self.__param("shuffle data:", str(par["shuffle_data"])) + + if "early_stopping" in par and par["early_stopping"]: + self.__param("early stopping:", par["early_stopping"]) + self.__paramjson("early stopping params:", par["early_stopping_params"]) + + if par["prediction_samples"] >= 0: + self.__param("prediction samples:", f"{par['prediction_samples']}") + self.__param("step:", f"{par['train_step']}") + self.__paramjson("closed loop:", par["closed_loop"]) + self.__paramjson("connect:", par["connect"]) + + self.__param("train dataset:", f"{par['train_tag']}") + self.__param("\t- batch size:", f"{par['train_batch_size']}") + self.__param("\t- num of samples:", f"{par['n_samples_train']}") + if par["prediction_samples"] >= 0: + self.__param( + "\t- num of first samples:", f"{par['n_first_samples_train']}" + ) + + if par["n_samples_val"] > 0: + self.__param("validation dataset:", f"{par['val_tag']}") + self.__param("\t- batch size:", f"{par['val_batch_size']}") + self.__param("\t- num of samples:", f"{par['n_samples_val']}") + if par["prediction_samples"] >= 0: + self.__param( + "\t- num of first samples:", f"{par['n_first_samples_val']}" + ) + + if par["n_samples_test"] > 0: + self.__param("test dataset:", f"{par['test_tag']}") + self.__param("\t- num of samples:", f"{par['n_samples_test']}") + if "test_batch_size" in par: + self.__param("\t- batch size:", f"{par['test_batch_size']}") + if par["prediction_samples"] >= 0: + self.__param( + "\t- num of first samples:", f"{par['n_first_samples_test']}" + ) + + self.__paramjson("minimizers:", par["minimizers"]) + + self.__param("optimizer:", par["optimizer"]) + self.__paramjson("optimizer defaults:", par["optimizer_defaults"]) + if par["optimizer_params"] is not None: + self.__paramjson("optimizer params:", par["optimizer_params"]) + + self.__line() + + def showResult(self, name_data): + eng = lambda val: np.format_float_scientific(val, precision=3) + if self.verbose >= 1: + dim_loss = max( + 5, len(max(self.modely._model_def["Minimizers"].keys(), key=len)) + ) + loss_type_list = set( + [ + value["loss"] + for ind, (key, value) in enumerate( + self.modely._model_def["Minimizers"].items() + ) + ] + ) + self.__title( + f" nnodely Model Results for {name_data} ", + dim_loss + 2 + (len(loss_type_list) + 2) * 20, + ) + print(color("|" + ("Loss").center(dim_loss, " ") + "|"), end="") + for loss in loss_type_list: + print(color((f"{loss}").center(19, " ") + "|"), end="") + print(color(("FVU").center(19, " ") + "|"), end="") + print(color(("AIC").center(19, " ") + "|")) + + print(color("|" + ("").center(dim_loss, " ") + "|"), end="") + for i in range(len(loss_type_list)): + print(color(("small better").center(19, " ") + "|"), end="") + print(color(("small better").center(19, " ") + "|"), end="") + print(color(("lower better").center(19, " ") + "|")) + + print( + color( + "|" + + ("").center(dim_loss + 20 * (len(loss_type_list) + 2), "-") + + "|" + ) + ) + for ind, (key, value) in enumerate( + self.modely._model_def["Minimizers"].items() + ): + print(color("|" + (f"{key}").center(dim_loss, " ") + "|"), end="") + for loss in list(loss_type_list): + if value["loss"] == loss: + print( + color( + ( + f"{eng(self.modely.performance[name_data][key][value['loss']])}" + ).center(19, " ") + + "|" + ), + end="", + ) + else: + print(color((" ").center(19, " ") + "|"), end="") + print( + color( + ( + f"{eng(self.modely.performance[name_data][key]['fvu']['total'])}" + ).center(19, " ") + + "|" + ), + end="", + ) + print( + color( + ( + f"{eng(self.modely.performance[name_data][key]['aic']['value'])}" + ).center(19, " ") + + "|" + ) + ) + + print( + color( + "|" + + ("").center(dim_loss + 20 * (len(loss_type_list) + 2), "-") + + "|" + ) + ) + print(color("|" + ("Total").center(dim_loss, " ") + "|"), end="") + print( + color( + ( + f"{eng(self.modely.performance[name_data]['total']['mean_error'])}" + ).center(len(loss_type_list) * 20 - 1, " ") + + "|" + ), + end="", + ) + print( + color( + ( + f"{eng(self.modely.performance[name_data]['total']['fvu'])}" + ).center(19, " ") + + "|" + ), + end="", + ) + print( + color( + ( + f"{eng(self.modely.performance[name_data]['total']['aic'])}" + ).center(19, " ") + + "|" + ) + ) + + print( + color( + "|" + + ("").center(dim_loss + 20 * (len(loss_type_list) + 2), "-") + + "|" + ) + ) + + if self.verbose >= 2: + self.__title(" Detalied Results ") + print(color(pformat(self.modely.performance), GREEN)) + self.__line() + + def saveModel(self, name, path): + if self.verbose >= 1: + self.__title(f" Save {name} ") + self.__param("Model saved in:", path) + self.__line() + + def loadModel(self, name, path): + if self.verbose >= 1: + self.__title(f" Load {name} ") + self.__param("Model loaded from:", path) + self.__line() + + def exportModel(self, name, path): + if self.verbose >= 1: + self.__title(f" Export {name} ") + self.__param("Model exported in:", path) + self.__line() + + def importModel(self, name, path): + if self.verbose >= 1: + self.__title(f" Import {name} ") + self.__param("Model imported from:", path) + self.__line() + + def exportReport(self, name, path): + if self.verbose >= 1: + self.__title(f" Export {name} Report ") + self.__param("Report exported in:", path) + self.__line() diff --git a/tests/__init__.py b/tests/__init__.py index 9d1b47f2..210b6ce1 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -3,4 +3,5 @@ # Imposta un backend non-GUI solo su Windows if sys.platform.startswith("win"): import matplotlib - matplotlib.use("Agg") \ No newline at end of file + + matplotlib.use("Agg") diff --git a/tests/get_samples_data/data.csv b/tests/get_samples_data/data.csv index 74a9c6f3..5ba268fb 100644 --- a/tests/get_samples_data/data.csv +++ b/tests/get_samples_data/data.csv @@ -7,4 +7,4 @@ x,y 6,4 0,5 0,6 -0,7 \ No newline at end of file +0,7 diff --git a/tests/multifile/file1.csv b/tests/multifile/file1.csv index 145603d0..4141b195 100644 --- a/tests/multifile/file1.csv +++ b/tests/multifile/file1.csv @@ -8,4 +8,4 @@ x,y 10,10 10,10 10,10 -10,10 \ No newline at end of file +10,10 diff --git a/tests/multifile/file2.csv b/tests/multifile/file2.csv index ac05b0d0..9ba54d2f 100644 --- a/tests/multifile/file2.csv +++ b/tests/multifile/file2.csv @@ -18,4 +18,4 @@ x,y 20,20 20,20 20,20 -20,20 \ No newline at end of file +20,20 diff --git a/tests/multifile/file3.csv b/tests/multifile/file3.csv index 79180bf8..bc734e0d 100644 --- a/tests/multifile/file3.csv +++ b/tests/multifile/file3.csv @@ -28,4 +28,4 @@ x,y 30,30 30,30 30,30 -30,30 \ No newline at end of file +30,30 diff --git a/tests/multifile2/file1.csv b/tests/multifile2/file1.csv index 7d5eaf2f..a28e024a 100644 --- a/tests/multifile2/file1.csv +++ b/tests/multifile2/file1.csv @@ -8,4 +8,4 @@ x,y 40,40 40,40 40,40 -40,40 \ No newline at end of file +40,40 diff --git a/tests/multifile2/file2.csv b/tests/multifile2/file2.csv index 7713584e..47c5fef4 100644 --- a/tests/multifile2/file2.csv +++ b/tests/multifile2/file2.csv @@ -18,4 +18,4 @@ x,y 50,50 50,50 50,50 -50,50 \ No newline at end of file +50,50 diff --git a/tests/multifile2/file3.csv b/tests/multifile2/file3.csv index 31898748..440c03f5 100644 --- a/tests/multifile2/file3.csv +++ b/tests/multifile2/file3.csv @@ -28,4 +28,4 @@ x,y 60,60 60,60 60,60 -60,60 \ No newline at end of file +60,60 diff --git a/tests/multifile3/file1.csv b/tests/multifile3/file1.csv index bee647ba..56266193 100644 --- a/tests/multifile3/file1.csv +++ b/tests/multifile3/file1.csv @@ -48,4 +48,4 @@ x,y 125,125 126,126 127,127 -128,128 \ No newline at end of file +128,128 diff --git a/tests/test_data/testdata.dta b/tests/test_data/testdata.dta index 535ad715..405cdd02 100644 --- a/tests/test_data/testdata.dta +++ b/tests/test_data/testdata.dta @@ -15,4 +15,3 @@ x1 y1 x2 y2 A1x A1y B1x B1y A2x A2y 0.812 0.818 0.348 0.453 - 0.350 1.375 0.571 1.199 - 0.575 1.375 0.699 3.214 - 0.274 0.742 12.556 0.100 - 0.813 0.816 0.354 0.445 - 0.350 1.375 0.567 1.194 - 0.575 1.375 0.695 3.211 - 0.273 0.733 12.570 0.110 - 0.814 0.814 0.361 0.436 - 0.350 1.375 0.562 1.189 - 0.575 1.375 0.690 3.207 - 0.272 0.723 12.585 0.120 - - diff --git a/tests/test_dataset.py b/tests/test_dataset.py index d497d0c8..9971f510 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -1,4 +1,6 @@ -import sys, os, unittest +import sys +import os +import unittest import numpy as np from nnodely import * @@ -14,458 +16,1333 @@ # This file test the data loading in particular: # The shape and the value of the inputs -train_folder = os.path.join(os.path.dirname(__file__), 'data/') -val_folder = os.path.join(os.path.dirname(__file__), 'val_data/') -test_folder = os.path.join(os.path.dirname(__file__), 'test_data/') +train_folder = os.path.join(os.path.dirname(__file__), "data/") +val_folder = os.path.join(os.path.dirname(__file__), "val_data/") +test_folder = os.path.join(os.path.dirname(__file__), "test_data/") + class ModelyCreateDatasetTest(unittest.TestCase): - def test_build_dataset_simple(self): NeuObj.clearNames() - input = Input('in1') - output = Input('out') + input = Input("in1") + output = Input("out") relation = Fir(input.tw(0.05)) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), relation) + test.addMinimize("out", output.z(-1), relation) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','theta','time'] - test.loadData(name='dataset_1', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,5,1), test._data['dataset_1']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset_1']['in1'][0].tolist()) - - self.assertEqual((10,1,1), test._data['dataset_1']['out'].shape) - self.assertEqual([[1.225]], test._data['dataset_1']['out'][0].tolist()) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['dataset_1']['out'].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "theta", + "time", + ] + test.loadData( + name="dataset_1", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset_1"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset_1"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 1, 1), test._data["dataset_1"]["out"].shape) + self.assertEqual([[1.225]], test._data["dataset_1"]["out"][0].tolist()) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["dataset_1"]["out"].tolist(), + ) def test_build_dataset_tuple(self): NeuObj.clearNames() - inputA = Input('inA') - inputB = Input('inB') - out = Output('out', Fir(inputA.tw(0.05)+inputB.tw(0.05))) + inputA = Input("inA") + inputB = Input("inB") + out = Output("out", Fir(inputA.tw(0.05) + inputB.tw(0.05))) test = Modely(visualizer=None) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.01) - data_struct = ['','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3',('inA','inB'),'theta','time'] - test.loadData(name='dataset_1', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((11,5,1), test._data['dataset_1']['inA'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset_1']['inA'][0].tolist()) - self.assertEqual((11,5,1), test._data['dataset_1']['inB'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset_1']['inB'][0].tolist()) - - out = Output('out2', Fir(inputA.tw(0.05))) + data_struct = [ + "", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + ("inA", "inB"), + "theta", + "time", + ] + test.loadData( + name="dataset_1", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((11, 5, 1), test._data["dataset_1"]["inA"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset_1"]["inA"][0].tolist(), + ) + self.assertEqual((11, 5, 1), test._data["dataset_1"]["inB"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset_1"]["inB"][0].tolist(), + ) + + out = Output("out2", Fir(inputA.tw(0.05))) test2 = Modely(visualizer=None) - test2.addModel('out2', out) + test2.addModel("out2", out) test2.neuralizeModel(0.01) - data_struct = ['','y1','x2','y2','','A1x','A1y','B1x','B1y','',('A2x','f'),'A2y','B2x','out','','x3',('inA','inB'),'theta','time'] - test2.loadData(name='dataset_1', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((11,5,1), test._data['dataset_1']['inA'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset_1']['inA'][0].tolist()) + data_struct = [ + "", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + ("A2x", "f"), + "A2y", + "B2x", + "out", + "", + "x3", + ("inA", "inB"), + "theta", + "time", + ] + test2.loadData( + name="dataset_1", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((11, 5, 1), test._data["dataset_1"]["inA"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset_1"]["inA"][0].tolist(), + ) def test_build_dataset_tuple_dim(self): NeuObj.clearNames() - inputA1 = Input('inA1') - inputA = Input('inA', dimensions=3) - inputB = Input('inB', dimensions=3) - out = Output('out', inputA1.sw(1)+Fir(Linear(inputA.tw(0.05)+inputB.tw(0.05)))) + inputA1 = Input("inA1") + inputA = Input("inA", dimensions=3) + inputB = Input("inB", dimensions=3) + out = Output( + "out", inputA1.sw(1) + Fir(Linear(inputA.tw(0.05) + inputB.tw(0.05))) + ) test = Modely(visualizer=None) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.01) - data_struct = ['','y1','x2','y2','',('A1x','inA1'),'A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3',('inA','inB'),'theta','time'] - test.loadData(name='dataset_1', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((11,5,3), test._data['dataset_1']['inA'].shape) - self.assertEqual([[0.984,12.493, 0.0],[0.983,12.493, 0.01],[0.982,12.495, 0.02],[0.98,12.498, 0.03],[0.977,12.502, 0.04]], test._data['dataset_1']['inA'][0].tolist()) - self.assertEqual((11,5,3), test._data['dataset_1']['inB'].shape) - self.assertEqual([[0.984, 12.493, 0.0], [0.983, 12.493, 0.01], [0.982, 12.495, 0.02], [0.98, 12.498, 0.03], - [0.977, 12.502, 0.04]], test._data['dataset_1']['inB'][0].tolist()) + data_struct = [ + "", + "y1", + "x2", + "y2", + "", + ("A1x", "inA1"), + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + ("inA", "inB"), + "theta", + "time", + ] + test.loadData( + name="dataset_1", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((11, 5, 3), test._data["dataset_1"]["inA"].shape) + self.assertEqual( + [ + [0.984, 12.493, 0.0], + [0.983, 12.493, 0.01], + [0.982, 12.495, 0.02], + [0.98, 12.498, 0.03], + [0.977, 12.502, 0.04], + ], + test._data["dataset_1"]["inA"][0].tolist(), + ) + self.assertEqual((11, 5, 3), test._data["dataset_1"]["inB"].shape) + self.assertEqual( + [ + [0.984, 12.493, 0.0], + [0.983, 12.493, 0.01], + [0.982, 12.495, 0.02], + [0.98, 12.498, 0.03], + [0.977, 12.502, 0.04], + ], + test._data["dataset_1"]["inB"][0].tolist(), + ) with self.assertRaises(ValueError): - data_struct = ['','y1','x2','y2','',('inA1','inA'),'A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3',('inA','inB'),'theta','time'] - test.loadData(name='dataset_2', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "", + "y1", + "x2", + "y2", + "", + ("inA1", "inA"), + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + ("inA", "inB"), + "theta", + "time", + ] + test.loadData( + name="dataset_2", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) with self.assertRaises(ValueError): - data_struct = ['','y1','x2','y2','',('inA1','inA'),'A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','inB','theta','time'] - test.loadData(name='dataset_3', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "", + "y1", + "x2", + "y2", + "", + ("inA1", "inA"), + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "inB", + "theta", + "time", + ] + test.loadData( + name="dataset_3", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) def test_build_multi_dataset_simple(self): NeuObj.clearNames() - input = Input('in1') - output = Input('out') + input = Input("in1") + output = Input("out") relation = Fir(input.tw(0.05)) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), relation) + test.addMinimize("out", output.z(-1), relation) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','theta','time'] - - test.loadData(name='train_dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='validation_dataset', source=val_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='test_dataset', source=test_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "theta", + "time", + ] + + test.loadData( + name="train_dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="validation_dataset", + source=val_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="test_dataset", + source=test_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) self.assertEqual(3, test._Loader__n_datasets) - self.assertEqual((10,5,1), test._data['train_dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['train_dataset']['in1'][0].tolist()) - self.assertEqual((6,5,1), test._data['validation_dataset']['in1'].shape) - self.assertEqual([[0.884],[0.883],[0.882],[0.88],[0.877]], test._data['validation_dataset']['in1'][0].tolist()) - self.assertEqual((8,5,1), test._data['test_dataset']['in1'].shape) - self.assertEqual([[0.784],[0.783],[0.782],[0.78],[0.777]], test._data['test_dataset']['in1'][0].tolist()) - - self.assertEqual((10,1,1), test._data['train_dataset']['out'].shape) - self.assertEqual([[1.225]], test._data['train_dataset']['out'][0].tolist()) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['train_dataset']['out'].tolist()) - self.assertEqual((6,1,1), test._data['validation_dataset']['out'].shape) - self.assertEqual([[2.225]], test._data['validation_dataset']['out'][0].tolist()) - self.assertEqual([[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], test._data['validation_dataset']['out'].tolist()) - self.assertEqual((8,1,1), test._data['test_dataset']['out'].shape) - self.assertEqual([[3.225]], test._data['test_dataset']['out'][0].tolist()) - self.assertEqual([[[3.225]], [[3.224]], [[3.222]], [[3.22]], [[3.217]], [[3.214]], [[3.211]], [[3.207]]], test._data['test_dataset']['out'].tolist()) - + self.assertEqual((10, 5, 1), test._data["train_dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["train_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((6, 5, 1), test._data["validation_dataset"]["in1"].shape) + self.assertEqual( + [[0.884], [0.883], [0.882], [0.88], [0.877]], + test._data["validation_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((8, 5, 1), test._data["test_dataset"]["in1"].shape) + self.assertEqual( + [[0.784], [0.783], [0.782], [0.78], [0.777]], + test._data["test_dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 1, 1), test._data["train_dataset"]["out"].shape) + self.assertEqual([[1.225]], test._data["train_dataset"]["out"][0].tolist()) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["train_dataset"]["out"].tolist(), + ) + self.assertEqual((6, 1, 1), test._data["validation_dataset"]["out"].shape) + self.assertEqual([[2.225]], test._data["validation_dataset"]["out"][0].tolist()) + self.assertEqual( + [[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], + test._data["validation_dataset"]["out"].tolist(), + ) + self.assertEqual((8, 1, 1), test._data["test_dataset"]["out"].shape) + self.assertEqual([[3.225]], test._data["test_dataset"]["out"][0].tolist()) + self.assertEqual( + [ + [[3.225]], + [[3.224]], + [[3.222]], + [[3.22]], + [[3.217]], + [[3.214]], + [[3.211]], + [[3.207]], + ], + test._data["test_dataset"]["out"].tolist(), + ) + def test_build_dataset_medium1(self): NeuObj.clearNames() - input = Input('in1') - output = Input('out') + input = Input("in1") + output = Input("out") rel1 = Fir(input.tw(0.05)) rel2 = Fir(input.tw(0.01)) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2) + test.addMinimize("out", output.z(-1), rel1 + rel2) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','theta','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,5,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset']['in1'][0].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "theta", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["dataset"]["out"].tolist(), + ) - self.assertEqual((10,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['dataset']['out'].tolist()) - def test_build_multi_dataset_medium1(self): NeuObj.clearNames() - input = Input('in1') - output = Input('out') + input = Input("in1") + output = Input("out") rel1 = Fir(input.tw(0.05)) rel2 = Fir(input.tw(0.01)) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2) + test.addMinimize("out", output.z(-1), rel1 + rel2) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','theta','time'] - - test.loadData(name='train_dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='validation_dataset', source=val_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='test_dataset', source=test_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "theta", + "time", + ] + + test.loadData( + name="train_dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="validation_dataset", + source=val_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="test_dataset", + source=test_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) self.assertEqual(3, test._Loader__n_datasets) - self.assertEqual((10,5,1), test._data['train_dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['train_dataset']['in1'][0].tolist()) - self.assertEqual((6,5,1), test._data['validation_dataset']['in1'].shape) - self.assertEqual([[0.884],[0.883],[0.882],[0.88],[0.877]], test._data['validation_dataset']['in1'][0].tolist()) - self.assertEqual((8,5,1), test._data['test_dataset']['in1'].shape) - self.assertEqual([[0.784],[0.783],[0.782],[0.78],[0.777]], test._data['test_dataset']['in1'][0].tolist()) - - self.assertEqual((10,1,1), test._data['train_dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['train_dataset']['out'].tolist()) - self.assertEqual((6,1,1), test._data['validation_dataset']['out'].shape) - self.assertEqual([[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], test._data['validation_dataset']['out'].tolist()) - self.assertEqual((8,1,1), test._data['test_dataset']['out'].shape) - self.assertEqual([[[3.225]], [[3.224]], [[3.222]], [[3.22]], [[3.217]], [[3.214]], [[3.211]], [[3.207]]], test._data['test_dataset']['out'].tolist()) - + self.assertEqual((10, 5, 1), test._data["train_dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["train_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((6, 5, 1), test._data["validation_dataset"]["in1"].shape) + self.assertEqual( + [[0.884], [0.883], [0.882], [0.88], [0.877]], + test._data["validation_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((8, 5, 1), test._data["test_dataset"]["in1"].shape) + self.assertEqual( + [[0.784], [0.783], [0.782], [0.78], [0.777]], + test._data["test_dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 1, 1), test._data["train_dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["train_dataset"]["out"].tolist(), + ) + self.assertEqual((6, 1, 1), test._data["validation_dataset"]["out"].shape) + self.assertEqual( + [[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], + test._data["validation_dataset"]["out"].tolist(), + ) + self.assertEqual((8, 1, 1), test._data["test_dataset"]["out"].shape) + self.assertEqual( + [ + [[3.225]], + [[3.224]], + [[3.222]], + [[3.22]], + [[3.217]], + [[3.214]], + [[3.211]], + [[3.207]], + ], + test._data["test_dataset"]["out"].tolist(), + ) + def test_build_dataset_medium2(self): NeuObj.clearNames() - input1 = Input('in1') - input2 = Input('in2') - output = Input('out') + input1 = Input("in1") + input2 = Input("in2") + output = Input("out") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw(0.01)) rel3 = Fir(input2.tw(0.02)) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2 + rel3) + test.addMinimize("out", output.z(-1), rel1 + rel2 + rel3) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,5,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977]], test._data['dataset']['in1'][0].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 2, 1), test._data["dataset"]["in2"].shape) + self.assertEqual([[12.498], [12.502]], test._data["dataset"]["in2"][0].tolist()) + + self.assertEqual((10, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["dataset"]["out"].tolist(), + ) - self.assertEqual((10,2,1), test._data['dataset']['in2'].shape) - self.assertEqual([[12.498], [12.502]], test._data['dataset']['in2'][0].tolist()) - - self.assertEqual((10,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['dataset']['out'].tolist()) - def test_build_dataset_complex1(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.02])) + rel2 = Fir(input1.tw([-0.01, 0.02])) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2) + test.addMinimize("out", output.z(-1), rel1 + rel2) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((9,7,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973],[0.969]], test._data['dataset']['in1'][0].tolist()) - - self.assertEqual((9,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]]], test._data['dataset']['out'].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((9, 7, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973], [0.969]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((9, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + ], + test._data["dataset"]["out"].tolist(), + ) def test_build_multi_dataset_complex1(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.02])) + rel2 = Fir(input1.tw([-0.01, 0.02])) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2) + test.addMinimize("out", output.z(-1), rel1 + rel2) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - - test.loadData(name='train_dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='validation_dataset', source=val_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='test_dataset', source=test_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + + test.loadData( + name="train_dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="validation_dataset", + source=val_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="test_dataset", + source=test_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) self.assertEqual(3, test._Loader__n_datasets) - self.assertEqual((9,7,1), test._data['train_dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973],[0.969]], test._data['train_dataset']['in1'][0].tolist()) - self.assertEqual((5,7,1), test._data['validation_dataset']['in1'].shape) - self.assertEqual([[0.884],[0.883],[0.882],[0.88],[0.877],[0.873],[0.869]], test._data['validation_dataset']['in1'][0].tolist()) - self.assertEqual((7,7,1), test._data['test_dataset']['in1'].shape) - self.assertEqual([[0.784],[0.783],[0.782],[0.78],[0.777],[0.773],[0.769]], test._data['test_dataset']['in1'][0].tolist()) - - self.assertEqual((9,1,1), test._data['train_dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]]], test._data['train_dataset']['out'].tolist()) - self.assertEqual((5,1,1), test._data['validation_dataset']['out'].shape) - self.assertEqual([[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]]], test._data['validation_dataset']['out'].tolist()) - self.assertEqual((7,1,1), test._data['test_dataset']['out'].shape) - self.assertEqual([[[3.225]], [[3.224]], [[3.222]], [[3.22]], [[3.217]], [[3.214]], [[3.211]]], test._data['test_dataset']['out'].tolist()) - + self.assertEqual((9, 7, 1), test._data["train_dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973], [0.969]], + test._data["train_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((5, 7, 1), test._data["validation_dataset"]["in1"].shape) + self.assertEqual( + [[0.884], [0.883], [0.882], [0.88], [0.877], [0.873], [0.869]], + test._data["validation_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((7, 7, 1), test._data["test_dataset"]["in1"].shape) + self.assertEqual( + [[0.784], [0.783], [0.782], [0.78], [0.777], [0.773], [0.769]], + test._data["test_dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((9, 1, 1), test._data["train_dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + ], + test._data["train_dataset"]["out"].tolist(), + ) + self.assertEqual((5, 1, 1), test._data["validation_dataset"]["out"].shape) + self.assertEqual( + [[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]]], + test._data["validation_dataset"]["out"].tolist(), + ) + self.assertEqual((7, 1, 1), test._data["test_dataset"]["out"].shape) + self.assertEqual( + [ + [[3.225]], + [[3.224]], + [[3.222]], + [[3.22]], + [[3.217]], + [[3.214]], + [[3.211]], + ], + test._data["test_dataset"]["out"].tolist(), + ) + def test_build_dataset_complex2(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.01])) + rel2 = Fir(input1.tw([-0.01, 0.01])) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1 + rel2) + test.addMinimize("out", output.z(-1), rel1 + rel2) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,6,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973]], test._data['dataset']['in1'][0].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 6, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["dataset"]["out"].tolist(), + ) - self.assertEqual((10,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['dataset']['out'].tolist()) - def test_build_dataset_complex3(self): NeuObj.clearNames() - input1 = Input('in1') - input2 = Input('in2') - output = Input('out') + input1 = Input("in1") + input2 = Input("in2") + output = Input("out") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input2.tw(0.02)) - rel3 = Fir(input1.tw([-0.01,0.01])) + rel3 = Fir(input1.tw([-0.01, 0.01])) rel4 = Fir(input2.last()) - fun = Output('out-net',rel1+rel2+rel3+rel4) + fun = Output("out-net", rel1 + rel2 + rel3 + rel4) test = Modely(visualizer=None) - test.addModel('fun', fun) - test.addMinimize('out', output.z(-1), rel1 + rel2 + rel3 + rel4) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), rel1 + rel2 + rel3 + rel4) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,6,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973]], test._data['dataset']['in1'][0].tolist()) - - self.assertEqual((10,2,1), test._data['dataset']['in2'].shape) - self.assertEqual([[12.498], [12.502]], test._data['dataset']['in2'][0].tolist()) - - self.assertEqual((10,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['dataset']['out'].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 6, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 2, 1), test._data["dataset"]["in2"].shape) + self.assertEqual([[12.498], [12.502]], test._data["dataset"]["in2"][0].tolist()) + + self.assertEqual((10, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["dataset"]["out"].tolist(), + ) def test_build_multi_dataset_complex3(self): NeuObj.clearNames() - input1 = Input('in1') - input2 = Input('in2') - output = Input('out') + input1 = Input("in1") + input2 = Input("in2") + output = Input("out") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input2.tw(0.02)) - rel3 = Fir(input1.tw([-0.01,0.01])) + rel3 = Fir(input1.tw([-0.01, 0.01])) rel4 = Fir(input2.last()) - fun = Output('out-net',rel1+rel2+rel3+rel4) + fun = Output("out-net", rel1 + rel2 + rel3 + rel4) test = Modely(visualizer=None) - test.addModel('fun',fun) - test.addMinimize('out', output.z(-1), rel1 + rel2 + rel3 + rel4) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), rel1 + rel2 + rel3 + rel4) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='train_dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='validation_dataset', source=val_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.loadData(name='test_dataset', source=test_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="train_dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="validation_dataset", + source=val_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="test_dataset", + source=test_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) self.assertEqual(3, test._Loader__n_datasets) - self.assertEqual((10,6,1), test._data['train_dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973]], test._data['train_dataset']['in1'][0].tolist()) - self.assertEqual((6,6,1), test._data['validation_dataset']['in1'].shape) - self.assertEqual([[0.884],[0.883],[0.882],[0.88],[0.877],[0.873]], test._data['validation_dataset']['in1'][0].tolist()) - self.assertEqual((8,6,1), test._data['test_dataset']['in1'].shape) - self.assertEqual([[0.784],[0.783],[0.782],[0.78],[0.777],[0.773]], test._data['test_dataset']['in1'][0].tolist()) - - self.assertEqual((10,2,1), test._data['train_dataset']['in2'].shape) - self.assertEqual([[12.498], [12.502]], test._data['train_dataset']['in2'][0].tolist()) - self.assertEqual((6,2,1), test._data['validation_dataset']['in2'].shape) - self.assertEqual([[12.498], [12.502]], test._data['validation_dataset']['in2'][0].tolist()) - self.assertEqual((8,2,1), test._data['test_dataset']['in2'].shape) - self.assertEqual([[12.498], [12.502]], test._data['test_dataset']['in2'][0].tolist()) - - self.assertEqual((10,1,1), test._data['train_dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]], [[1.2]]], test._data['train_dataset']['out'].tolist()) - self.assertEqual((6,1,1), test._data['validation_dataset']['out'].shape) - self.assertEqual([[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], test._data['validation_dataset']['out'].tolist()) - self.assertEqual((8,1,1), test._data['test_dataset']['out'].shape) - self.assertEqual([[[3.225]], [[3.224]], [[3.222]], [[3.22]], [[3.217]], [[3.214]], [[3.211]], [[3.207]]], test._data['test_dataset']['out'].tolist()) - + self.assertEqual((10, 6, 1), test._data["train_dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973]], + test._data["train_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((6, 6, 1), test._data["validation_dataset"]["in1"].shape) + self.assertEqual( + [[0.884], [0.883], [0.882], [0.88], [0.877], [0.873]], + test._data["validation_dataset"]["in1"][0].tolist(), + ) + self.assertEqual((8, 6, 1), test._data["test_dataset"]["in1"].shape) + self.assertEqual( + [[0.784], [0.783], [0.782], [0.78], [0.777], [0.773]], + test._data["test_dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((10, 2, 1), test._data["train_dataset"]["in2"].shape) + self.assertEqual( + [[12.498], [12.502]], test._data["train_dataset"]["in2"][0].tolist() + ) + self.assertEqual((6, 2, 1), test._data["validation_dataset"]["in2"].shape) + self.assertEqual( + [[12.498], [12.502]], test._data["validation_dataset"]["in2"][0].tolist() + ) + self.assertEqual((8, 2, 1), test._data["test_dataset"]["in2"].shape) + self.assertEqual( + [[12.498], [12.502]], test._data["test_dataset"]["in2"][0].tolist() + ) + + self.assertEqual((10, 1, 1), test._data["train_dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + [[1.2]], + ], + test._data["train_dataset"]["out"].tolist(), + ) + self.assertEqual((6, 1, 1), test._data["validation_dataset"]["out"].shape) + self.assertEqual( + [[[2.225]], [[2.224]], [[2.222]], [[2.22]], [[2.217]], [[2.214]]], + test._data["validation_dataset"]["out"].tolist(), + ) + self.assertEqual((8, 1, 1), test._data["test_dataset"]["out"].shape) + self.assertEqual( + [ + [[3.225]], + [[3.224]], + [[3.222]], + [[3.22]], + [[3.217]], + [[3.214]], + [[3.211]], + [[3.207]], + ], + test._data["test_dataset"]["out"].tolist(), + ) + def test_build_dataset_complex5(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.01])) - rel3 = Fir(input1.tw([-0.02,0.02])) - fun = Output('out-net',rel1+rel2+rel3) + rel2 = Fir(input1.tw([-0.01, 0.01])) + rel3 = Fir(input1.tw([-0.02, 0.02])) + fun = Output("out-net", rel1 + rel2 + rel3) test = Modely(visualizer=None) - test.addModel('fun', fun) - test.addMinimize('out', output.z(-1), fun) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), fun) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((9,7,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973],[0.969]], test._data['dataset']['in1'][0].tolist()) - - self.assertEqual((9,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]]], test._data['dataset']['out'].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((9, 7, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973], [0.969]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((9, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + ], + test._data["dataset"]["out"].tolist(), + ) def test_filter_data(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.01])) - rel3 = Fir(input1.tw([-0.02,0.02])) - fun = Output('out-net',rel1+rel2+rel3) + rel2 = Fir(input1.tw([-0.01, 0.01])) + rel3 = Fir(input1.tw([-0.02, 0.02])) + fun = Output("out-net", rel1 + rel2 + rel3) test = Modely(visualizer=None) - test.addModel('fun', fun) - test.addMinimize('out', output.z(-1), fun) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), fun) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) def filter_fn(sample): - return min(sample['in1']) > 0.957 + return min(sample["in1"]) > 0.957 test.filterData(filter_fn) - self.assertEqual((2,7,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973],[0.969]], test._data['dataset']['in1'][0].tolist()) - - self.assertEqual((2,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]]], test._data['dataset']['out'].tolist()) - - test.loadData(name='dataset2', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.filterData(filter_fn, dataset_name='dataset2') - self.assertEqual((2,7,1), test._data['dataset2']['in1'].shape) - self.assertEqual((2, 1, 1), test._data['dataset2']['out'].shape) + self.assertEqual((2, 7, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973], [0.969]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((2, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual([[[1.225]], [[1.224]]], test._data["dataset"]["out"].tolist()) + + test.loadData( + name="dataset2", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.filterData(filter_fn, dataset_name="dataset2") + self.assertEqual((2, 7, 1), test._data["dataset2"]["in1"].shape) + self.assertEqual((2, 1, 1), test._data["dataset2"]["out"].shape) def test_build_dataset_complex6(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.02])) - rel3 = Fir(input1.tw([-0.05,0.01])) - fun = Output('out-net',rel1+rel2+rel3) + rel2 = Fir(input1.tw([-0.01, 0.02])) + rel3 = Fir(input1.tw([-0.05, 0.01])) + fun = Output("out-net", rel1 + rel2 + rel3) test = Modely(visualizer=None) - test.addModel('fun',fun) - test.addMinimize('out', output.z(-1), fun) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), fun) test.neuralizeModel(0.01) - data_struct = ['x1','y1','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((9,7,1), test._data['dataset']['in1'].shape) - self.assertEqual([[0.984],[0.983],[0.982],[0.98],[0.977],[0.973],[0.969]], test._data['dataset']['in1'][0].tolist()) - - self.assertEqual((9,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[1.225]], [[1.224]], [[1.222]], [[1.22]], [[1.217]], [[1.214]], [[1.211]], [[1.207]], [[1.204]]], test._data['dataset']['out'].tolist()) + data_struct = [ + "x1", + "y1", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((9, 7, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [[0.984], [0.983], [0.982], [0.98], [0.977], [0.973], [0.969]], + test._data["dataset"]["in1"][0].tolist(), + ) + + self.assertEqual((9, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [ + [[1.225]], + [[1.224]], + [[1.222]], + [[1.22]], + [[1.217]], + [[1.214]], + [[1.211]], + [[1.207]], + [[1.204]], + ], + test._data["dataset"]["out"].tolist(), + ) def test_build_dataset_custom(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) - rel2 = Fir(input1.tw([-0.01,0.02])) - rel3 = Fir(input1.tw([-0.05,0.01])) - fun = Output('out-net',rel1+rel2+rel3) + rel2 = Fir(input1.tw([-0.01, 0.02])) + rel3 = Fir(input1.tw([-0.05, 0.01])) + fun = Output("out-net", rel1 + rel2 + rel3) test = Modely(visualizer=None) - test.addModel('fun',fun) - test.addMinimize('out', output.z(-1), fun) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), fun) test.neuralizeModel(0.01) data_x = np.array(range(10)) data_a = 2 data_b = -3 - dataset = {'in1': data_x, 'out': (data_a*data_x) + data_b} - - test.loadData(name='dataset',source=dataset) - self.assertEqual((4,7,1), test._data['dataset']['in1'].shape) - self.assertEqual([[[0],[1],[2],[3],[4],[5],[6]], - [[1],[2],[3],[4],[5],[6],[7]], - [[2],[3],[4],[5],[6],[7],[8]], - [[3],[4],[5],[6],[7],[8],[9]]], - test._data['dataset']['in1'].tolist()) - - self.assertEqual((4,1,1), test._data['dataset']['out'].shape) - self.assertEqual([[[7]],[[9]],[[11]],[[13]]], test._data['dataset']['out'].tolist()) + dataset = {"in1": data_x, "out": (data_a * data_x) + data_b} + + test.loadData(name="dataset", source=dataset) + self.assertEqual((4, 7, 1), test._data["dataset"]["in1"].shape) + self.assertEqual( + [ + [[0], [1], [2], [3], [4], [5], [6]], + [[1], [2], [3], [4], [5], [6], [7]], + [[2], [3], [4], [5], [6], [7], [8]], + [[3], [4], [5], [6], [7], [8], [9]], + ], + test._data["dataset"]["in1"].tolist(), + ) + + self.assertEqual((4, 1, 1), test._data["dataset"]["out"].shape) + self.assertEqual( + [[[7]], [[9]], [[11]], [[13]]], test._data["dataset"]["out"].tolist() + ) def test_build_multi_dataset_custom(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') + input1 = Input("in1") + output = Input("out") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw([-0.01, 0.02])) rel3 = Fir(input1.tw([-0.05, 0.01])) - fun = Output('out-net', rel1 + rel2 + rel3) + fun = Output("out-net", rel1 + rel2 + rel3) test = Modely(visualizer=None) - test.addModel('fun',fun) - test.addMinimize('out', output.z(-1), fun) + test.addModel("fun", fun) + test.addMinimize("out", output.z(-1), fun) test.neuralizeModel(0.01) train_data_x = np.array(range(10)) @@ -473,174 +1350,247 @@ def test_build_multi_dataset_custom(self): test_data_x = np.array(range(20, 30)) data_a = 2 data_b = -3 - train_dataset = {'in1': train_data_x, 'out': (data_a * train_data_x) + data_b} - val_dataset = {'in1': val_data_x, 'out': (data_a * val_data_x) + data_b} - test_dataset = {'in1': test_data_x, 'out': (data_a * test_data_x) + data_b} + train_dataset = {"in1": train_data_x, "out": (data_a * train_data_x) + data_b} + val_dataset = {"in1": val_data_x, "out": (data_a * val_data_x) + data_b} + test_dataset = {"in1": test_data_x, "out": (data_a * test_data_x) + data_b} - test.loadData(name='train_dataset', source=train_dataset) - test.loadData(name='val_dataset', source=val_dataset) - test.loadData(name='test_dataset', source=test_dataset) + test.loadData(name="train_dataset", source=train_dataset) + test.loadData(name="val_dataset", source=val_dataset) + test.loadData(name="test_dataset", source=test_dataset) self.assertEqual(3, test._Loader__n_datasets) - self.assertEqual((4, 7, 1), test._data['train_dataset']['in1'].shape) - self.assertEqual([[[0], [1], [2], [3], [4], [5], [6]], - [[1], [2], [3], [4], [5], [6], [7]], - [[2], [3], [4], [5], [6], [7], [8]], - [[3], [4], [5], [6], [7], [8], [9]]], - test._data['train_dataset']['in1'].tolist()) - self.assertEqual((4, 7, 1), test._data['val_dataset']['in1'].shape) - self.assertEqual([[[10], [11], [12], [13], [14], [15], [16]], - [[11], [12], [13], [14], [15], [16], [17]], - [[12], [13], [14], [15], [16], [17], [18]], - [[13], [14], [15], [16], [17], [18], [19]]], - test._data['val_dataset']['in1'].tolist()) - self.assertEqual((4, 7, 1), test._data['test_dataset']['in1'].shape) - self.assertEqual([[[20], [21], [22], [23], [24], [25], [26]], - [[21], [22], [23], [24], [25], [26], [27]], - [[22], [23], [24], [25], [26], [27], [28]], - [[23], [24], [25], [26], [27], [28], [29]]], - test._data['test_dataset']['in1'].tolist()) - - self.assertEqual((4, 1, 1), test._data['train_dataset']['out'].shape) - self.assertEqual([[[7]], [[9]], [[11]], [[13]]], test._data['train_dataset']['out'].tolist()) - self.assertEqual((4, 1, 1), test._data['val_dataset']['out'].shape) - self.assertEqual([[[27]], [[29]], [[31]], [[33]]], test._data['val_dataset']['out'].tolist()) - self.assertEqual((4, 1, 1), test._data['test_dataset']['out'].shape) - self.assertEqual([[[47]], [[49]], [[51]], [[53]]], test._data['test_dataset']['out'].tolist()) + self.assertEqual((4, 7, 1), test._data["train_dataset"]["in1"].shape) + self.assertEqual( + [ + [[0], [1], [2], [3], [4], [5], [6]], + [[1], [2], [3], [4], [5], [6], [7]], + [[2], [3], [4], [5], [6], [7], [8]], + [[3], [4], [5], [6], [7], [8], [9]], + ], + test._data["train_dataset"]["in1"].tolist(), + ) + self.assertEqual((4, 7, 1), test._data["val_dataset"]["in1"].shape) + self.assertEqual( + [ + [[10], [11], [12], [13], [14], [15], [16]], + [[11], [12], [13], [14], [15], [16], [17]], + [[12], [13], [14], [15], [16], [17], [18]], + [[13], [14], [15], [16], [17], [18], [19]], + ], + test._data["val_dataset"]["in1"].tolist(), + ) + self.assertEqual((4, 7, 1), test._data["test_dataset"]["in1"].shape) + self.assertEqual( + [ + [[20], [21], [22], [23], [24], [25], [26]], + [[21], [22], [23], [24], [25], [26], [27]], + [[22], [23], [24], [25], [26], [27], [28]], + [[23], [24], [25], [26], [27], [28], [29]], + ], + test._data["test_dataset"]["in1"].tolist(), + ) + + self.assertEqual((4, 1, 1), test._data["train_dataset"]["out"].shape) + self.assertEqual( + [[[7]], [[9]], [[11]], [[13]]], test._data["train_dataset"]["out"].tolist() + ) + self.assertEqual((4, 1, 1), test._data["val_dataset"]["out"].shape) + self.assertEqual( + [[[27]], [[29]], [[31]], [[33]]], test._data["val_dataset"]["out"].tolist() + ) + self.assertEqual((4, 1, 1), test._data["test_dataset"]["out"].shape) + self.assertEqual( + [[[47]], [[49]], [[51]], [[53]]], test._data["test_dataset"]["out"].tolist() + ) def test_vector_input_dataset(self): NeuObj.clearNames() - x = Input('x', dimensions=4) - y = Input('y', dimensions=3) - k = Input('k', dimensions=2) - w = Input('w') + x = Input("x", dimensions=4) + y = Input("y", dimensions=3) + k = Input("k", dimensions=2) + w = Input("w") - - out = Output('out', Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) - out2 = Output('out2', Fir(Linear(k.last() + Fir(2)(w.tw(0.05,offset=-0.02))))) + out = Output("out", Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) + out2 = Output("out2", Fir(Linear(k.last() + Fir(2)(w.tw(0.05, offset=-0.02))))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) + test.addMinimize("out", out, out2) test.neuralizeModel(0.01) ## Custom dataset - data_x = np.transpose(np.array( - [np.linspace(1,100,100, dtype=np.float32), - np.linspace(2, 101, 100, dtype=np.float32), - np.linspace(3, 102, 100, dtype=np.float32), - np.linspace(4, 103, 100, dtype=np.float32)])) - data_y = np.transpose(np.array( - [np.linspace(1,100,100, dtype=np.float32) + 10, - np.linspace(2, 101, 100, dtype=np.float32) + 10, - np.linspace(3, 102, 100, dtype=np.float32) + 10])) - data_k = np.transpose(np.array( - [np.linspace(1,100,100, dtype=np.float32) + 20, - np.linspace(2, 101, 100, dtype=np.float32) + 20])) - data_w = np.linspace(1,100,100, dtype=np.float32) + 30 - dataset = {'x': data_x, 'y': data_y, 'w': data_w, 'k': data_k} - - test.loadData(name='dataset', source=dataset) - - self.assertEqual((96, 2, 4), test._data['dataset']['x'].shape) - self.assertEqual((96, 2, 3), test._data['dataset']['y'].shape) - self.assertEqual((96, 1, 2), test._data['dataset']['k'].shape) - self.assertEqual((96, 5, 1), test._data['dataset']['w'].shape) - - self.assertEqual([[4.0, 5.0, 6.0, 7.0], [5.0, 6.0, 7.0, 8.0]], - test._data['dataset']['x'][0].tolist()) - self.assertEqual([[5.0, 6.0, 7.0, 8.0],[6.0, 7.0, 8.0, 9.0]], - test._data['dataset']['x'][1].tolist()) - self.assertEqual([[99, 100, 101, 102], [100, 101, 102, 103]], - test._data['dataset']['x'][-1].tolist()) - self.assertEqual([[98, 99, 100, 101],[99, 100, 101, 102]], - test._data['dataset']['x'][-2].tolist()) - - self.assertEqual([[14.0, 15.0, 16.0], [15.0, 16.0, 17.0]], - test._data['dataset']['y'][0].tolist()) - self.assertEqual([[15.0, 16.0, 17.0], [16.0, 17.0, 18.0]], - test._data['dataset']['y'][1].tolist()) - self.assertEqual([[109, 110, 111], [110, 111, 112]], - test._data['dataset']['y'][-1].tolist()) - self.assertEqual([[108, 109, 110], [109, 110, 111]], - test._data['dataset']['y'][-2].tolist()) - - self.assertEqual([[25.0, 26.0]], - test._data['dataset']['k'][0].tolist()) - self.assertEqual([[26.0, 27.0]], - test._data['dataset']['k'][1].tolist()) - self.assertEqual([[120, 121]], - test._data['dataset']['k'][-1].tolist()) - self.assertEqual([[119, 120]], - test._data['dataset']['k'][-2].tolist()) - - self.assertEqual([[31], [32], [33], [34], [35]], - test._data['dataset']['w'][0].tolist()) - self.assertEqual([[32], [33], [34], [35], [36]], - test._data['dataset']['w'][1].tolist()) - self.assertEqual([[126], [127], [128], [129], [130]], - test._data['dataset']['w'][-1].tolist()) - self.assertEqual([[125], [126], [127], [128], [129]], - test._data['dataset']['w'][-2].tolist()) + data_x = np.transpose( + np.array( + [ + np.linspace(1, 100, 100, dtype=np.float32), + np.linspace(2, 101, 100, dtype=np.float32), + np.linspace(3, 102, 100, dtype=np.float32), + np.linspace(4, 103, 100, dtype=np.float32), + ] + ) + ) + data_y = np.transpose( + np.array( + [ + np.linspace(1, 100, 100, dtype=np.float32) + 10, + np.linspace(2, 101, 100, dtype=np.float32) + 10, + np.linspace(3, 102, 100, dtype=np.float32) + 10, + ] + ) + ) + data_k = np.transpose( + np.array( + [ + np.linspace(1, 100, 100, dtype=np.float32) + 20, + np.linspace(2, 101, 100, dtype=np.float32) + 20, + ] + ) + ) + data_w = np.linspace(1, 100, 100, dtype=np.float32) + 30 + dataset = {"x": data_x, "y": data_y, "w": data_w, "k": data_k} + + test.loadData(name="dataset", source=dataset) + + self.assertEqual((96, 2, 4), test._data["dataset"]["x"].shape) + self.assertEqual((96, 2, 3), test._data["dataset"]["y"].shape) + self.assertEqual((96, 1, 2), test._data["dataset"]["k"].shape) + self.assertEqual((96, 5, 1), test._data["dataset"]["w"].shape) + + self.assertEqual( + [[4.0, 5.0, 6.0, 7.0], [5.0, 6.0, 7.0, 8.0]], + test._data["dataset"]["x"][0].tolist(), + ) + self.assertEqual( + [[5.0, 6.0, 7.0, 8.0], [6.0, 7.0, 8.0, 9.0]], + test._data["dataset"]["x"][1].tolist(), + ) + self.assertEqual( + [[99, 100, 101, 102], [100, 101, 102, 103]], + test._data["dataset"]["x"][-1].tolist(), + ) + self.assertEqual( + [[98, 99, 100, 101], [99, 100, 101, 102]], + test._data["dataset"]["x"][-2].tolist(), + ) + + self.assertEqual( + [[14.0, 15.0, 16.0], [15.0, 16.0, 17.0]], + test._data["dataset"]["y"][0].tolist(), + ) + self.assertEqual( + [[15.0, 16.0, 17.0], [16.0, 17.0, 18.0]], + test._data["dataset"]["y"][1].tolist(), + ) + self.assertEqual( + [[109, 110, 111], [110, 111, 112]], test._data["dataset"]["y"][-1].tolist() + ) + self.assertEqual( + [[108, 109, 110], [109, 110, 111]], test._data["dataset"]["y"][-2].tolist() + ) + + self.assertEqual([[25.0, 26.0]], test._data["dataset"]["k"][0].tolist()) + self.assertEqual([[26.0, 27.0]], test._data["dataset"]["k"][1].tolist()) + self.assertEqual([[120, 121]], test._data["dataset"]["k"][-1].tolist()) + self.assertEqual([[119, 120]], test._data["dataset"]["k"][-2].tolist()) + + self.assertEqual( + [[31], [32], [33], [34], [35]], test._data["dataset"]["w"][0].tolist() + ) + self.assertEqual( + [[32], [33], [34], [35], [36]], test._data["dataset"]["w"][1].tolist() + ) + self.assertEqual( + [[126], [127], [128], [129], [130]], test._data["dataset"]["w"][-1].tolist() + ) + self.assertEqual( + [[125], [126], [127], [128], [129]], test._data["dataset"]["w"][-2].tolist() + ) def test_vector_input_dataset_files(self): NeuObj.clearNames() - x = Input('x', dimensions=4) - y = Input('y', dimensions=3) - k = Input('k', dimensions=2) - w = Input('w') + x = Input("x", dimensions=4) + y = Input("y", dimensions=3) + k = Input("k", dimensions=2) + w = Input("w") - out = Output('out', Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) - out2 = Output('out2', Fir(Linear(k.last() + Fir(2)(w.tw(0.05,offset=-0.02))))) + out = Output("out", Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) + out2 = Output("out2", Fir(Linear(k.last() + Fir(2)(w.tw(0.05, offset=-0.02))))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) + test.addMinimize("out", out, out2) test.neuralizeModel(0.01) - data_folder = os.path.join(os.path.dirname(__file__), 'vector_data/') - data_struct = ['x', 'y', '','', '', '', 'k', '', '', '', 'w'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1, delimiter='\t', header=None) - - self.assertEqual((22, 2, 4), test._data['dataset']['x'].shape) - self.assertEqual((22, 2, 3), test._data['dataset']['y'].shape) - self.assertEqual((22, 1, 2), test._data['dataset']['k'].shape) - self.assertEqual((22, 5, 1), test._data['dataset']['w'].shape) - - self.assertEqual([[0.804, 0.825, 0.320, 0.488], [0.805, 0.825, 0.322, 0.485]], - test._data['dataset']['x'][0].tolist()) - self.assertEqual([[0.805, 0.825, 0.322, 0.485],[0.806, 0.824, 0.325, 0.481]], - test._data['dataset']['x'][1].tolist()) - self.assertEqual([[0.806, 0.824, 0.325, 0.481], [0.807, 0.823, 0.329, 0.477]], - test._data['dataset']['x'][-1].tolist()) - self.assertEqual([[0.805, 0.825, 0.322, 0.485],[0.806, 0.824, 0.325, 0.481]], - test._data['dataset']['x'][-2].tolist()) - - self.assertEqual([[0.350, 1.375, 0.586], [0.350, 1.375, 0.585]], - test._data['dataset']['y'][0].tolist()) - self.assertEqual([[0.350, 1.375, 0.585], [0.350, 1.375, 0.584]], - test._data['dataset']['y'][1].tolist()) - self.assertEqual([[0.350, 1.375, 0.584], [0.350, 1.375, 0.582]], - test._data['dataset']['y'][-1].tolist()) - self.assertEqual([[0.350, 1.375, 0.585], [0.350, 1.375, 0.584]], - test._data['dataset']['y'][-2].tolist()) - - self.assertEqual([[0.714, 1.227]], - test._data['dataset']['k'][0].tolist()) - self.assertEqual([[0.712, 1.225]], - test._data['dataset']['k'][1].tolist()) - self.assertEqual([[0.710, 1.224]], - test._data['dataset']['k'][-1].tolist()) - self.assertEqual([[0.712, 1.225]], - test._data['dataset']['k'][-2].tolist()) - - self.assertEqual([[12.493], [12.493], [12.495], [12.498], [12.502]], - test._data['dataset']['w'][0].tolist()) - self.assertEqual([[12.493], [12.495], [12.498], [12.502], [12.508]], - test._data['dataset']['w'][1].tolist()) - self.assertEqual([[12.495], [12.498], [12.502], [12.508], [12.515]], - test._data['dataset']['w'][-1].tolist()) - self.assertEqual([[12.493], [12.495], [12.498], [12.502], [12.508]], - test._data['dataset']['w'][-2].tolist()) + data_folder = os.path.join(os.path.dirname(__file__), "vector_data/") + data_struct = ["x", "y", "", "", "", "", "k", "", "", "", "w"] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=1, + delimiter="\t", + header=None, + ) + + self.assertEqual((22, 2, 4), test._data["dataset"]["x"].shape) + self.assertEqual((22, 2, 3), test._data["dataset"]["y"].shape) + self.assertEqual((22, 1, 2), test._data["dataset"]["k"].shape) + self.assertEqual((22, 5, 1), test._data["dataset"]["w"].shape) + + self.assertEqual( + [[0.804, 0.825, 0.320, 0.488], [0.805, 0.825, 0.322, 0.485]], + test._data["dataset"]["x"][0].tolist(), + ) + self.assertEqual( + [[0.805, 0.825, 0.322, 0.485], [0.806, 0.824, 0.325, 0.481]], + test._data["dataset"]["x"][1].tolist(), + ) + self.assertEqual( + [[0.806, 0.824, 0.325, 0.481], [0.807, 0.823, 0.329, 0.477]], + test._data["dataset"]["x"][-1].tolist(), + ) + self.assertEqual( + [[0.805, 0.825, 0.322, 0.485], [0.806, 0.824, 0.325, 0.481]], + test._data["dataset"]["x"][-2].tolist(), + ) + + self.assertEqual( + [[0.350, 1.375, 0.586], [0.350, 1.375, 0.585]], + test._data["dataset"]["y"][0].tolist(), + ) + self.assertEqual( + [[0.350, 1.375, 0.585], [0.350, 1.375, 0.584]], + test._data["dataset"]["y"][1].tolist(), + ) + self.assertEqual( + [[0.350, 1.375, 0.584], [0.350, 1.375, 0.582]], + test._data["dataset"]["y"][-1].tolist(), + ) + self.assertEqual( + [[0.350, 1.375, 0.585], [0.350, 1.375, 0.584]], + test._data["dataset"]["y"][-2].tolist(), + ) + + self.assertEqual([[0.714, 1.227]], test._data["dataset"]["k"][0].tolist()) + self.assertEqual([[0.712, 1.225]], test._data["dataset"]["k"][1].tolist()) + self.assertEqual([[0.710, 1.224]], test._data["dataset"]["k"][-1].tolist()) + self.assertEqual([[0.712, 1.225]], test._data["dataset"]["k"][-2].tolist()) + + self.assertEqual( + [[12.493], [12.493], [12.495], [12.498], [12.502]], + test._data["dataset"]["w"][0].tolist(), + ) + self.assertEqual( + [[12.493], [12.495], [12.498], [12.502], [12.508]], + test._data["dataset"]["w"][1].tolist(), + ) + self.assertEqual( + [[12.495], [12.498], [12.502], [12.508], [12.515]], + test._data["dataset"]["w"][-1].tolist(), + ) + self.assertEqual( + [[12.493], [12.495], [12.498], [12.502], [12.508]], + test._data["dataset"]["w"][-2].tolist(), + ) ## Load from file ## Try to train the model @@ -649,326 +1599,1145 @@ def test_vector_input_dataset_files(self): def test_multifiles(self): NeuObj.clearNames() - x = Input('x') + x = Input("x") relation = Fir()(x.tw(0.05)) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, log_internal=True) - test.addModel('model', output) - test.addMinimize('error', output, x.next()) + test.addModel("model", output) + test.addMinimize("error", output, x.next()) test.neuralizeModel(0.01) ## The folder contains 3 files with 10, 20 and 30 samples respectively - data_struct = ['x'] + data_struct = ["x"] ## each folder contains 3 files with 10, 20 and 30 samples respectively - data_folder = os.path.join(os.path.dirname(__file__), 'multifile/') - data_folder2 = os.path.join(os.path.dirname(__file__), 'multifile2/') + data_folder = os.path.join(os.path.dirname(__file__), "multifile/") + data_folder2 = os.path.join(os.path.dirname(__file__), "multifile2/") ## this folder contains only one file with 50 samples - data_folder3 = os.path.join(os.path.dirname(__file__), 'multifile3/') - test.loadData(name='dataset1', source=data_folder, format=data_struct, skiplines=1) - test.loadData(name='dataset2', source=data_folder2, format=data_struct, skiplines=1) - test.loadData(name='dataset3', source=data_folder3, format=data_struct, skiplines=1) - - self.assertListEqual(list(test._data['dataset1']['x'].shape), [45, 6, 1]) - self.assertListEqual(test._multifile['dataset1'], [5, 20, 45]) - self.assertListEqual(list(test._data['dataset2']['x'].shape), [45, 6, 1]) - self.assertListEqual(test._multifile['dataset2'], [5, 20, 45]) - self.assertListEqual(list(test._data['dataset3']['x'].shape), [45, 6, 1]) - self.assertEqual(test._num_of_samples['dataset1'], 45) ## 5 + 15 + 25 - self.assertEqual(test._num_of_samples['dataset2'], 45) ## 5 + 15 + 25 - self.assertEqual(test._num_of_samples['dataset3'], 45) ## 50 - 5 + data_folder3 = os.path.join(os.path.dirname(__file__), "multifile3/") + test.loadData( + name="dataset1", source=data_folder, format=data_struct, skiplines=1 + ) + test.loadData( + name="dataset2", source=data_folder2, format=data_struct, skiplines=1 + ) + test.loadData( + name="dataset3", source=data_folder3, format=data_struct, skiplines=1 + ) + + self.assertListEqual(list(test._data["dataset1"]["x"].shape), [45, 6, 1]) + self.assertListEqual(test._multifile["dataset1"], [5, 20, 45]) + self.assertListEqual(list(test._data["dataset2"]["x"].shape), [45, 6, 1]) + self.assertListEqual(test._multifile["dataset2"], [5, 20, 45]) + self.assertListEqual(list(test._data["dataset3"]["x"].shape), [45, 6, 1]) + self.assertEqual(test._num_of_samples["dataset1"], 45) ## 5 + 15 + 25 + self.assertEqual(test._num_of_samples["dataset2"], 45) ## 5 + 15 + 25 + self.assertEqual(test._num_of_samples["dataset3"], 45) ## 50 - 5 ## train one dataset using splits - test.trainModel(dataset='dataset1', splits=[80, 10, 10], prediction_samples=3, num_of_epochs=1) + test.trainModel( + dataset="dataset1", + splits=[80, 10, 10], + prediction_samples=3, + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 36) ## 45 * 0.8 - self.assertEqual(tp['n_samples_val'], 4) ## 45 * 0.1 - self.assertEqual(tp['n_samples_test'], 5) ## 45 * 0.1 - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]) - self.assertEqual(test.running_parameters['val_indexes'], [0]) + self.assertEqual(tp["n_samples_train"], 36) ## 45 * 0.8 + self.assertEqual(tp["n_samples_val"], 4) ## 45 * 0.1 + self.assertEqual(tp["n_samples_test"], 5) ## 45 * 0.1 + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + ], + ) + self.assertEqual(test.running_parameters["val_indexes"], [0]) ## train using one dataset for train and one for validation - test.trainModel(train_dataset='dataset1', validation_dataset='dataset2', prediction_samples=3, num_of_epochs=1) + test.trainModel( + train_dataset="dataset1", + validation_dataset="dataset2", + prediction_samples=3, + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 45) - self.assertEqual(tp['n_samples_val'], 45) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]) + self.assertEqual(tp["n_samples_train"], 45) + self.assertEqual(tp["n_samples_val"], 45) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + ], + ) ## train using two dataset for train and one for validation - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset='dataset3', prediction_samples=3, num_of_epochs=1) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset="dataset3", + prediction_samples=3, + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 45) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 45) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + ], + ) ## train using two dataset for train and two for validation - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset=['dataset2','dataset3'], prediction_samples=3, num_of_epochs=1) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset=["dataset2", "dataset3"], + prediction_samples=3, + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 90) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 90) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + ], + ) ## train using two dataset for train and two for validation (dataset4 is ignored) - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset=['dataset2','dataset3','dataset4'], num_of_epochs=1, prediction_samples=3) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset=["dataset2", "dataset3", "dataset4"], + num_of_epochs=1, + prediction_samples=3, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 90) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 90) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + ], + ) ## Use all datasets by default test.trainModel(splits=[80, 10, 10], prediction_samples=3) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 108) ## (45+45+45) * 0.8 - self.assertEqual(tp['n_samples_val'], 14) ## 135 * 0.1 - self.assertEqual(tp['n_samples_test'], 13) ## 135 * 0.1 - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + self.assertEqual(tp["n_samples_train"], 108) ## (45+45+45) * 0.8 + self.assertEqual(tp["n_samples_val"], 14) ## 135 * 0.1 + self.assertEqual(tp["n_samples_test"], 13) ## 135 * 0.1 + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + ) ## splits multifile - test.trainModel(dataset=['dataset1', 'dataset2', 'dataset3'], splits=[80, 10, 10], prediction_samples=3) + test.trainModel( + dataset=["dataset1", "dataset2", "dataset3"], + splits=[80, 10, 10], + prediction_samples=3, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 108) ## (45+45+45) * 0.8 - self.assertEqual(tp['n_samples_val'], 14) ## 90 * 0.1 - self.assertEqual(tp['n_samples_test'], 13) ## 90 * 0.1 - self.assertEqual(test.running_parameters['train_indexes'], [0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 45, 46, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104]) - self.assertEqual(test.running_parameters['val_indexes'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + self.assertEqual(tp["n_samples_train"], 108) ## (45+45+45) * 0.8 + self.assertEqual(tp["n_samples_val"], 14) ## 90 * 0.1 + self.assertEqual(tp["n_samples_test"], 13) ## 90 * 0.1 + self.assertEqual( + test.running_parameters["train_indexes"], + [ + 0, + 1, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 45, + 46, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + ], + ) + self.assertEqual( + test.running_parameters["val_indexes"], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + ) ## train one dataset using splits - test.trainModel(dataset='dataset1', splits=[80, 10, 10], num_of_epochs=1) + test.trainModel(dataset="dataset1", splits=[80, 10, 10], num_of_epochs=1) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 36) ## 45 * 0.8 - self.assertEqual(tp['n_samples_val'], 4) ## 45 * 0.1 - self.assertEqual(tp['n_samples_test'], 5) ## 45 * 0.1 - self.assertEqual(test.running_parameters['train_indexes'], list(range(36))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(4))) + self.assertEqual(tp["n_samples_train"], 36) ## 45 * 0.8 + self.assertEqual(tp["n_samples_val"], 4) ## 45 * 0.1 + self.assertEqual(tp["n_samples_test"], 5) ## 45 * 0.1 + self.assertEqual(test.running_parameters["train_indexes"], list(range(36))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(4))) ## train using one dataset for train and one for validation - test.trainModel(train_dataset='dataset1', validation_dataset='dataset2', num_of_epochs=1) + test.trainModel( + train_dataset="dataset1", validation_dataset="dataset2", num_of_epochs=1 + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 45) - self.assertEqual(tp['n_samples_val'], 45) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], list(range(45))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(45))) + self.assertEqual(tp["n_samples_train"], 45) + self.assertEqual(tp["n_samples_val"], 45) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual(test.running_parameters["train_indexes"], list(range(45))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(45))) ## train using two dataset for train and one for validation - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset='dataset3', num_of_epochs=1) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset="dataset3", + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 45) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], list(range(90))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(45))) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 45) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual(test.running_parameters["train_indexes"], list(range(90))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(45))) ## train using two dataset for train and two for validation - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset=['dataset2','dataset3'], num_of_epochs=1) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset=["dataset2", "dataset3"], + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 90) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], list(range(90))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(90))) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 90) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual(test.running_parameters["train_indexes"], list(range(90))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(90))) ## train using two dataset for train and two for validation (dataset4 is ignored) - test.trainModel(train_dataset=['dataset1', 'dataset2'], validation_dataset=['dataset2','dataset3','dataset4'], num_of_epochs=1) + test.trainModel( + train_dataset=["dataset1", "dataset2"], + validation_dataset=["dataset2", "dataset3", "dataset4"], + num_of_epochs=1, + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 90) ## 45 + 45 - self.assertEqual(tp['n_samples_val'], 90) - self.assertEqual(tp['n_samples_test'], 0) - self.assertEqual(test.running_parameters['train_indexes'], list(range(90))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(90))) + self.assertEqual(tp["n_samples_train"], 90) ## 45 + 45 + self.assertEqual(tp["n_samples_val"], 90) + self.assertEqual(tp["n_samples_test"], 0) + self.assertEqual(test.running_parameters["train_indexes"], list(range(90))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(90))) ## splits multifile - test.trainModel(dataset=['dataset1', 'dataset2', 'dataset3'], splits=[80, 10, 10]) + test.trainModel( + dataset=["dataset1", "dataset2", "dataset3"], splits=[80, 10, 10] + ) tp = test.getTrainingInfo() - self.assertEqual(tp['n_samples_train'], 108) ## (45+45+45) * 0.8 - self.assertEqual(tp['n_samples_val'], 14) ## 90 * 0.1 - self.assertEqual(tp['n_samples_test'], 13) ## 90 * 0.1 - self.assertEqual(test.running_parameters['train_indexes'], list(range(108))) - self.assertEqual(test.running_parameters['val_indexes'], list(range(14))) + self.assertEqual(tp["n_samples_train"], 108) ## (45+45+45) * 0.8 + self.assertEqual(tp["n_samples_val"], 14) ## 90 * 0.1 + self.assertEqual(tp["n_samples_test"], 13) ## 90 * 0.1 + self.assertEqual(test.running_parameters["train_indexes"], list(range(108))) + self.assertEqual(test.running_parameters["val_indexes"], list(range(14))) def test_multifiles_2(self): NeuObj.clearNames() - x = Input('x') - y = Input('y') - relation = Fir()(x.tw(0.05))+Fir(y.sw([-2,2])) + x = Input("x") + y = Input("y") + relation = Fir()(x.tw(0.05)) + Fir(y.sw([-2, 2])) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, log_internal=True) - test.addModel('model', output) - test.addMinimize('error', output, x.next()) + test.addModel("model", output) + test.addMinimize("error", output, x.next()) test.neuralizeModel(0.01) ## The folder contains 3 files with 10, 20 and 30 samples respectively - data_struct = ['x', 'y'] - data_folder = os.path.join(os.path.dirname(__file__), 'multifile/') - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) - self.assertListEqual(list(test._data['dataset']['x'].shape), [42, 6, 1]) - self.assertListEqual(list(test._data['dataset']['y'].shape), [42, 4, 1]) - self.assertListEqual(test._multifile['dataset'], [4, 18, 42]) + data_struct = ["x", "y"] + data_folder = os.path.join(os.path.dirname(__file__), "multifile/") + test.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) + self.assertListEqual(list(test._data["dataset"]["x"].shape), [42, 6, 1]) + self.assertListEqual(list(test._data["dataset"]["y"].shape), [42, 4, 1]) + self.assertListEqual(test._multifile["dataset"], [4, 18, 42]) def test_dataframe_multidimensional(self): import pandas as pd + NeuObj.clearNames() - x = Input('x', dimensions=4) - y = Input('y', dimensions=3) - k = Input('k', dimensions=2) - w = Input('w') + x = Input("x", dimensions=4) + y = Input("y", dimensions=3) + k = Input("k", dimensions=2) + w = Input("w") - out = Output('out', Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) - out2 = Output('out2', Fir(Linear(k.last() + Fir(2)(w.tw(0.05,offset=-0.02))))) + out = Output("out", Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) + out2 = Output("out2", Fir(Linear(k.last() + Fir(2)(w.tw(0.05, offset=-0.02))))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) + test.addMinimize("out", out, out2) test.neuralizeModel(0.01) # Create a DataFrame with random values for each input - df = pd.DataFrame({ - 'x': [np.array([1.0,2.0,3.0,4.0]) for _ in range(10)], - 'y': [np.array([5.0,6.0,7.0]) for _ in range(10)], - 'k': [np.array([8.0,9.0]) for _ in range(10)], - 'w': np.array([10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0])}) - - test.loadData(name='dataset', source=df) - self.assertEqual((6, 2, 4), test._data['dataset']['x'].shape) - self.assertEqual((6, 2, 3), test._data['dataset']['y'].shape) - self.assertEqual((6, 1, 2), test._data['dataset']['k'].shape) - self.assertEqual((6, 5, 1), test._data['dataset']['w'].shape) + df = pd.DataFrame( + { + "x": [np.array([1.0, 2.0, 3.0, 4.0]) for _ in range(10)], + "y": [np.array([5.0, 6.0, 7.0]) for _ in range(10)], + "k": [np.array([8.0, 9.0]) for _ in range(10)], + "w": np.array( + [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0] + ), + } + ) + + test.loadData(name="dataset", source=df) + self.assertEqual((6, 2, 4), test._data["dataset"]["x"].shape) + self.assertEqual((6, 2, 3), test._data["dataset"]["y"].shape) + self.assertEqual((6, 1, 2), test._data["dataset"]["k"].shape) + self.assertEqual((6, 5, 1), test._data["dataset"]["w"].shape) def test_dataframe_single_dimension(self): import pandas as pd + NeuObj.clearNames() - x = Input('x') - y = Input('y') - k = Input('k') - w = Input('w') + x = Input("x") + y = Input("y") + k = Input("k") + w = Input("w") - out = Output('out', Fir(x.tw(0.02) + y.tw(0.02))) - out2 = Output('out2', Fir(k.last()) + Fir(w.tw(0.05,offset=-0.02))) + out = Output("out", Fir(x.tw(0.02) + y.tw(0.02))) + out2 = Output("out2", Fir(k.last()) + Fir(w.tw(0.05, offset=-0.02))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) + test.addMinimize("out", out, out2) test.neuralizeModel(0.01) # Create a DataFrame with random values for each input - df = pd.DataFrame({ - 'x': np.linspace(1,100,100, dtype=np.float32), - 'y': np.linspace(1,100,100, dtype=np.float32), - 'k': np.linspace(1,100,100, dtype=np.float32), - 'w': np.linspace(1,100,100, dtype=np.float32)}) - - test.loadData(name='dataset', source=df) - self.assertEqual((96, 2, 1), test._data['dataset']['x'].shape) - self.assertEqual((96, 2, 1), test._data['dataset']['y'].shape) - self.assertEqual((96, 1, 1), test._data['dataset']['k'].shape) - self.assertEqual((96, 5, 1), test._data['dataset']['w'].shape) + df = pd.DataFrame( + { + "x": np.linspace(1, 100, 100, dtype=np.float32), + "y": np.linspace(1, 100, 100, dtype=np.float32), + "k": np.linspace(1, 100, 100, dtype=np.float32), + "w": np.linspace(1, 100, 100, dtype=np.float32), + } + ) + + test.loadData(name="dataset", source=df) + self.assertEqual((96, 2, 1), test._data["dataset"]["x"].shape) + self.assertEqual((96, 2, 1), test._data["dataset"]["y"].shape) + self.assertEqual((96, 1, 1), test._data["dataset"]["k"].shape) + self.assertEqual((96, 5, 1), test._data["dataset"]["w"].shape) def test_dataframe_resampling(self): import pandas as pd + NeuObj.clearNames() - x = Input('x') - y = Input('y') - k = Input('k') - w = Input('w') + x = Input("x") + y = Input("y") + k = Input("k") + w = Input("w") - out = Output('out', Fir(x.tw(1.0) + y.tw(1.0))) - out2 = Output('out2', Fir(k.last()) + Fir(w.tw(2.5,offset=-1.0))) + out = Output("out", Fir(x.tw(1.0) + y.tw(1.0))) + out2 = Output("out2", Fir(k.last()) + Fir(w.tw(2.5, offset=-1.0))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) + test.addMinimize("out", out, out2) test.neuralizeModel(0.5) # Create a DataFrame with random values for each input - df = pd.DataFrame({ - 'time': np.array([1.0,1.5,2.0,4.0,4.5,5.0,7.0,7.5,8.0,8.5], dtype=np.float32), - 'x': np.linspace(1,10,10, dtype=np.float32), - 'y': np.linspace(1,10,10, dtype=np.float32), - 'k': np.linspace(1,10,10, dtype=np.float32), - 'w': np.linspace(1,10,10, dtype=np.float32)}) - - test.loadData(name='dataset1', source=df, resampling=True) - self.assertEqual((12, 2, 1), test._data['dataset1']['x'].shape) - self.assertEqual((12, 2, 1), test._data['dataset1']['y'].shape) - self.assertEqual((12, 1, 1), test._data['dataset1']['k'].shape) - self.assertEqual((12, 5, 1), test._data['dataset1']['w'].shape) - - df['time'] = pd.to_datetime(df['time'], unit='s') - df = df.set_index('time', drop=True) - test.loadData(name='dataset2', source=df, resampling=True) - self.assertEqual((12, 2, 1), test._data['dataset2']['x'].shape) - self.assertEqual((12, 2, 1), test._data['dataset2']['y'].shape) - self.assertEqual((12, 1, 1), test._data['dataset2']['k'].shape) - self.assertEqual((12, 5, 1), test._data['dataset2']['w'].shape) - - df2 = pd.DataFrame({ - 'x': np.linspace(1,10,10, dtype=np.float32), - 'y': np.linspace(1,10,10, dtype=np.float32), - 'k': np.linspace(1,10,10, dtype=np.float32), - 'w': np.linspace(1,10,10, dtype=np.float32)}) + df = pd.DataFrame( + { + "time": np.array( + [1.0, 1.5, 2.0, 4.0, 4.5, 5.0, 7.0, 7.5, 8.0, 8.5], dtype=np.float32 + ), + "x": np.linspace(1, 10, 10, dtype=np.float32), + "y": np.linspace(1, 10, 10, dtype=np.float32), + "k": np.linspace(1, 10, 10, dtype=np.float32), + "w": np.linspace(1, 10, 10, dtype=np.float32), + } + ) + + test.loadData(name="dataset1", source=df, resampling=True) + self.assertEqual((12, 2, 1), test._data["dataset1"]["x"].shape) + self.assertEqual((12, 2, 1), test._data["dataset1"]["y"].shape) + self.assertEqual((12, 1, 1), test._data["dataset1"]["k"].shape) + self.assertEqual((12, 5, 1), test._data["dataset1"]["w"].shape) + + df["time"] = pd.to_datetime(df["time"], unit="s") + df = df.set_index("time", drop=True) + test.loadData(name="dataset2", source=df, resampling=True) + self.assertEqual((12, 2, 1), test._data["dataset2"]["x"].shape) + self.assertEqual((12, 2, 1), test._data["dataset2"]["y"].shape) + self.assertEqual((12, 1, 1), test._data["dataset2"]["k"].shape) + self.assertEqual((12, 5, 1), test._data["dataset2"]["w"].shape) + + df2 = pd.DataFrame( + { + "x": np.linspace(1, 10, 10, dtype=np.float32), + "y": np.linspace(1, 10, 10, dtype=np.float32), + "k": np.linspace(1, 10, 10, dtype=np.float32), + "w": np.linspace(1, 10, 10, dtype=np.float32), + } + ) with self.assertRaises(TypeError): - test.loadData(name='dataset3', source=df2, resampling=True) + test.loadData(name="dataset3", source=df2, resampling=True) def test_load_data_modalities(self): import pandas as pd + NeuObj.clearNames() - x = Input('x') + x = Input("x") relation = Fir()(x.tw(0.05)) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, log_internal=True) - test.addModel('model', output) - test.addMinimize('error', output, x.next()) + test.addModel("model", output) + test.addMinimize("error", output, x.next()) test.neuralizeModel(0.01) ## Case 1: directory with files - data_struct = ['x'] - data_folder = os.path.join(os.path.dirname(__file__), 'multifile/') - test.loadData(name='dataset_directory', source=data_folder, format=data_struct, skiplines=1) - self.assertListEqual(list(test._data['dataset_directory']['x'].shape), [45, 6, 1]) - self.assertListEqual(test._multifile['dataset_directory'], [5, 20, 45]) + data_struct = ["x"] + data_folder = os.path.join(os.path.dirname(__file__), "multifile/") + test.loadData( + name="dataset_directory", + source=data_folder, + format=data_struct, + skiplines=1, + ) + self.assertListEqual( + list(test._data["dataset_directory"]["x"].shape), [45, 6, 1] + ) + self.assertListEqual(test._multifile["dataset_directory"], [5, 20, 45]) ## Case 2: dictionary - train_data_x = np.array(10*[10] + 20*[20] + 30*[30], dtype=np.float32) - train_dataset = {'x': train_data_x, 'time': np.array(range(60), dtype=np.float32)} - test.loadData(name='dataset_dictionary', source=train_dataset, ) - self.assertListEqual(list(test._data['dataset_dictionary']['x'].shape), [55, 6, 1]) + train_data_x = np.array(10 * [10] + 20 * [20] + 30 * [30], dtype=np.float32) + train_dataset = { + "x": train_data_x, + "time": np.array(range(60), dtype=np.float32), + } + test.loadData( + name="dataset_dictionary", + source=train_dataset, + ) + self.assertListEqual( + list(test._data["dataset_dictionary"]["x"].shape), [55, 6, 1] + ) ## Case 3: pandas DataFrame - df = pd.DataFrame({ - 'time': np.array(range(60), dtype=np.float32), - 'x': np.array(10*[10] + 20*[20] + 30*[30], dtype=np.float32)}) - test.loadData(name='dataset_pandas', source=df, resampling=True) - self.assertListEqual(list(test._data['dataset_pandas']['x'].shape), [5896, 6, 1]) + df = pd.DataFrame( + { + "time": np.array(range(60), dtype=np.float32), + "x": np.array(10 * [10] + 20 * [20] + 30 * [30], dtype=np.float32), + } + ) + test.loadData(name="dataset_pandas", source=df, resampling=True) + self.assertListEqual( + list(test._data["dataset_pandas"]["x"].shape), [5896, 6, 1] + ) diff --git a/tests/test_documentation.py b/tests/test_documentation.py index 71d27a97..10897634 100644 --- a/tests/test_documentation.py +++ b/tests/test_documentation.py @@ -1,26 +1,32 @@ import unittest -import subprocess -import os -class TestDocumentation(unittest.TestCase): - def test_generate_docs(self): - # Path to the Sphinx documentation source directory - docs_source_dir = os.path.join(os.path.dirname(__file__), '..', 'docs') - - # Path to the output directory for the generated documentation - docs_output_dir = os.path.join(docs_source_dir, '_build', 'html') - - # Command to generate the documentation - #TODO Check fail-on-warning command = ['sphinx-build', '--fail-on-warning', '-b', 'html', docs_source_dir, docs_output_dir] - command = ['sphinx-build', '-b', 'html', docs_source_dir, docs_output_dir] - # Run the command and capture the output - result = subprocess.run(command, capture_output=True, text=True) - - # Check if the command was successful - self.assertEqual(result.returncode, 0, f"Documentation generation failed: {result.stderr}") - - # Optionally, check if the output directory contains the expected files - self.assertTrue(os.path.exists(docs_output_dir), "Output directory does not exist") - self.assertTrue(os.path.isfile(os.path.join(docs_output_dir, 'index.html')), - "index.html not found in output directory") \ No newline at end of file +class TestDocumentation(unittest.TestCase): + pass + # def test_generate_docs(self): + # # Path to the Sphinx documentation source directory + # docs_source_dir = os.path.join(os.path.dirname(__file__), "..", "docs") + # + # # Path to the output directory for the generated documentation + # docs_output_dir = os.path.join(docs_source_dir, "_build", "html") + # + # # Command to generate the documentation + # # TODO Check fail-on-warning command = ['sphinx-build', '--fail-on-warning', '-b', 'html', docs_source_dir, docs_output_dir] + # command = ["sphinx-build", "-b", "html", docs_source_dir, docs_output_dir] + # + # # Run the command and capture the output + # result = subprocess.run(command, capture_output=True, text=True) + # + # # Check if the command was successful + # self.assertEqual( + # result.returncode, 0, f"Documentation generation failed: {result.stderr}" + # ) + # + # # Optionally, check if the output directory contains the expected files + # self.assertTrue( + # os.path.exists(docs_output_dir), "Output directory does not exist" + # ) + # self.assertTrue( + # os.path.isfile(os.path.join(docs_output_dir, "index.html")), + # "index.html not found in output directory", + # ) diff --git a/tests/test_export.py b/tests/test_export.py index cd36e464..6cb0dbe6 100644 --- a/tests/test_export.py +++ b/tests/test_export.py @@ -1,8 +1,10 @@ -import os, unittest, torch, shutil +import os +import unittest +import torch +import shutil import numpy as np from nnodely import * -from nnodely.basic.relation import NeuObj from nnodely.support.logger import logging, nnLogger log = nnLogger(__name__, logging.CRITICAL) @@ -11,12 +13,17 @@ # 11 Tests # Test of export and import the network to a file in different format -class ModelyExportTest(unittest.TestCase): +class ModelyExportTest(unittest.TestCase): def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: - self.assertEqual(len(data1),len(data2)) + self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.TestAlmostEqual(pred, label, precision=precision) else: @@ -26,28 +33,32 @@ def __init__(self, *args, **kwargs): super(ModelyExportTest, self).__init__(*args, **kwargs) clearNames() - self.result_path = './results' + self.result_path = "./results" self.test = Modely(visualizer=None, seed=42, workspace=self.result_path) - x = Input('x') - y = Input('y') - z = Input('z') + x = Input("x") + y = Input("y") + z = Input("z") ## create the relations def myFun(K1, p1, p2): return K1 * p1 * p2 - K_x = Parameter('k_x', dimensions=1, tw=1, init='init_constant', init_params={'value': 1}) - K_y = Parameter('k_y', dimensions=1, tw=1) - w = Parameter('w', dimensions=1, tw=1, init='init_constant', init_params={'value': 1}) - t = Parameter('t', dimensions=1, tw=1) - c_v = Constant('c_v', tw=1, values=[[1], [2]]) + K_x = Parameter( + "k_x", dimensions=1, tw=1, init="init_constant", init_params={"value": 1} + ) + K_y = Parameter("k_y", dimensions=1, tw=1) + w = Parameter( + "w", dimensions=1, tw=1, init="init_constant", init_params={"value": 1} + ) + t = Parameter("t", dimensions=1, tw=1) + c_v = Constant("c_v", tw=1, values=[[1], [2]]) c = 5 - w_5 = Parameter('w_5', dimensions=1, tw=5) - t_5 = Parameter('t_5', dimensions=1, tw=5) + w_5 = Parameter("w_5", dimensions=1, tw=5) + t_5 = Parameter("t_5", dimensions=1, tw=5) c_5 = [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] - c_5_2 = Constant('c_5_2', tw=5, values=c_5) - parfun_x = ParamFun(myFun, parameters_and_constants=[K_x,c_v]) + c_5_2 = Constant("c_5_2", tw=5, values=c_5) + parfun_x = ParamFun(myFun, parameters_and_constants=[K_x, c_v]) parfun_y = ParamFun(myFun, parameters_and_constants=[K_y]) parfun_z = ParamFun(myFun) fir_w = Fir(W=w_5)(x.tw(5)) @@ -61,24 +72,28 @@ def fuzzyfun(x): fuzzy = Fuzzify(output_dimension=4, range=[0, 4], functions=fuzzyfun)(x.tw(1)) fuzzyTriang = Fuzzify(centers=[1, 2, 3, 7])(x.tw(1)) - out = Output('out', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1),c_v))) - out2 = Output('out2', Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) - out3 = Output('out3', Add(fir_w, fir_t)) - out4 = Output('out4', Linear(output_dimension=1)(fuzzy+fuzzyTriang)) - out5 = Output('out5', Fir(time_part) + Fir(sample_select)) - out6 = Output('out6', LocalModel(output_function=Fir())(x.tw(1), fuzzy)) + out = Output("out", Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v))) + out2 = Output("out2", Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) + out3 = Output("out3", Add(fir_w, fir_t)) + out4 = Output("out4", Linear(output_dimension=1)(fuzzy + fuzzyTriang)) + out5 = Output("out5", Fir(time_part) + Fir(sample_select)) + out6 = Output("out6", LocalModel(output_function=Fir())(x.tw(1), fuzzy)) with self.assertRaises(TypeError): parfun_z(x.tw(5), t_5, c_5) - out7 = Output('out7', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + Fir(parfun_z(x.tw(5), t_5, c_5_2))) - - self.test.addModel('modelA', out) - self.test.addModel('modelB', [out2, out3, out4]) - self.test.addModel('modelC', [out4, out5, out6]) - self.test.addModel('modelD', [out7]) - self.test.addMinimize('error1', x.last(), out) - self.test.addMinimize('error2', y.last(), out3, loss_function='rmse') - self.test.addMinimize('error3', z.last(), out6, loss_function='rmse') - self.test.addMinimize('error4', z.last(), out7, loss_function='rmse') + out7 = Output( + "out7", + Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + + Fir(parfun_z(x.tw(5), t_5, c_5_2)), + ) + + self.test.addModel("modelA", out) + self.test.addModel("modelB", [out2, out3, out4]) + self.test.addModel("modelC", [out4, out5, out6]) + self.test.addModel("modelD", [out7]) + self.test.addMinimize("error1", x.last(), out) + self.test.addMinimize("error2", y.last(), out3, loss_function="rmse") + self.test.addMinimize("error3", z.last(), out6, loss_function="rmse") + self.test.addMinimize("error4", z.last(), out7, loss_function="rmse") def test_export_pt(self): if os.path.exists(self.test.getWorkspace()): @@ -87,21 +102,36 @@ def test_export_pt(self): # Export torch file .pt # Save torch model and load it self.test.neuralizeModel(0.5) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.saveTorchModel() self.test.neuralizeModel(clear_model=True) # The new_out is different from the old_out because the model is cleared - new_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) # The new_out_after_load is the same as the old_out because the model is loaded with the same parameters self.test.loadTorchModel() - new_out_after_load = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out_after_load = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): self.assertEqual(old_out, new_out) self.assertEqual(old_out, new_out_after_load) with self.assertRaises(RuntimeError): - test2 = Modely(visualizer=None, workspace = self.result_path) + test2 = Modely(visualizer=None, workspace=self.result_path) # You need not neuralized model to load a torch model test2.loadTorchModel() @@ -116,10 +146,20 @@ def test_export_json_not_neuralized(self): # Save a not neuralized nnodely json model and load it self.test.saveModel() # Save a model without parameter values and samples values with self.assertRaises(RuntimeError): - self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.loadModel() # Load the nnodely model without parameter values with self.assertRaises(RuntimeError): - self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) test2 = Modely(visualizer=None, workspace=self.test.getWorkspace()) test2.loadModel() # Load the nnodely model with parameter values with self.assertRaises(AttributeError): @@ -139,16 +179,36 @@ def test_export_json_untrained(self): # Save a untrained nnodely json model and load it # the new_out and new_out_after_load are different because the model saved model is not trained self.test.neuralizeModel(0.5) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.saveModel() # Save a model without parameter values self.test.neuralizeModel(clear_model=True) # Create a new torch model - new_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.loadModel() # Load the nnodely model without parameter values # Use the preloaded torch model for inference with self.assertRaises(RuntimeError): - self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.neuralizeModel(0.5) - new_out_after_load = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out_after_load = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): self.assertEqual(old_out, new_out) with self.assertRaises(AssertionError): @@ -164,15 +224,35 @@ def test_export_json_trained(self): # Export json of nnodely model with parameter valuess # The old_out is the same as the new_out_after_load because the model is loaded with the same parameters self.test.neuralizeModel(0.5) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.saveModel() # Save the model with and without parameter values self.test.neuralizeModel(clear_model=True) # Create a new torch model - new_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.loadModel() # Load the nnodely model with parameter values with self.assertRaises(RuntimeError): - self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.neuralizeModel() - new_out_after_load = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out_after_load = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): self.assertEqual(old_out, new_out) with self.assertRaises(AssertionError): @@ -188,15 +268,30 @@ def test_import_json_new_object(self): os.makedirs(self.result_path, exist_ok=True) # Import nnodely json model in a new object self.test.neuralizeModel(0.5) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.neuralizeModel() self.test.saveModel() # Save the model with and without parameter values test2 = Modely(visualizer=None, workspace=self.test.getWorkspace()) test2.loadModel() # Load the nnodely model with parameter values with self.assertRaises(RuntimeError): - test2({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + test2( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) test2.neuralizeModel() - new_model_out_after_load = test2({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_model_out_after_load = test2( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.assertEqual(old_out, new_model_out_after_load) if os.path.exists(self.test.getWorkspace()): @@ -209,19 +304,34 @@ def test_export_torch_script(self): # Export and import of a torch script .py # The old_out is the same as the new_out_after_load because the model is loaded with the same parameters with self.assertRaises(RuntimeError): - self.test.exportPythonModel() # The model is not neuralized yet + self.test.exportPythonModel() # The model is not neuralized yet self.test.neuralizeModel(0.5) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.exportPythonModel() # Export the trace model self.test.neuralizeModel(clear_model=True) # Create a new torch model - new_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.importPythonModel() # Import the tracer model with self.assertRaises(RuntimeError): - self.test.exportPythonModel() # The model is traced + self.test.exportPythonModel() # The model is traced # Perform inference with the imported tracer model - new_out_after_load = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + new_out_after_load = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): - self.assertEqual(old_out, new_out) + self.assertEqual(old_out, new_out) self.assertEqual(old_out, new_out_after_load) if os.path.exists(self.test.getWorkspace()): @@ -232,15 +342,25 @@ def test_export_torch_script_new_object(self): shutil.rmtree(self.test.getWorkspace()) os.makedirs(self.result_path, exist_ok=True) # Import of a torch script .py - self.test.neuralizeModel(0.5,clear_model=True) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test.neuralizeModel(0.5, clear_model=True) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.exportPythonModel() # Export the trace model self.test.neuralizeModel(clear_model=True) test2 = Modely(visualizer=None, workspace=self.test.getWorkspace()) test2.importPythonModel() # Load the nnodely model with parameter values with self.assertRaises(RuntimeError): - test2.exportPythonModel() # The model is traced - new_out_after_load = test2({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + test2.exportPythonModel() # The model is traced + new_out_after_load = test2( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.assertEqual(old_out, new_out_after_load) if os.path.exists(self.test.getWorkspace()): @@ -254,16 +374,28 @@ def test_export_trained_torch_script(self): data_x = np.arange(0.0, 1, 0.1) data_y = np.arange(0.0, 1, 0.1) a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 1, 'lr': 0.01} - self.test.neuralizeModel(0.5,clear_model=True) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + params = {"num_of_epochs": 1, "lr": 0.01} + self.test.neuralizeModel(0.5, clear_model=True) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.exportPythonModel() # Export the trace model - self.test.loadData(name='dataset', source=dataset) # Create the dataset - self.test.trainModel(optimizer='SGD', training_params=params) # Train the traced model - new_out_after_train = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + self.test.loadData(name="dataset", source=dataset) # Create the dataset + self.test.trainModel( + optimizer="SGD", training_params=params + ) # Train the traced model + new_out_after_train = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): - self.assertEqual(old_out, new_out_after_train) + self.assertEqual(old_out, new_out_after_train) if os.path.exists(self.test.getWorkspace()): shutil.rmtree(self.test.getWorkspace()) @@ -274,25 +406,44 @@ def test_export_torch_script_new_object_train(self): os.makedirs(self.result_path, exist_ok=True) # Perform training on an imported new tracer model self.test.neuralizeModel(0.5, clear_model=True) - old_out = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + old_out = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) self.test.exportPythonModel() # Export the trace model data_x = np.arange(0.0, 1, 0.1) data_y = np.arange(0.0, 1, 0.1) a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 1, 'lr': 0.01} - self.test.loadData(name='dataset', source=dataset) # Create the dataset - self.test.trainModel(optimizer='SGD', training_params=params) # Train the traced model - old_out_after_train = self.test({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + params = {"num_of_epochs": 1, "lr": 0.01} + self.test.loadData(name="dataset", source=dataset) # Create the dataset + self.test.trainModel( + optimizer="SGD", training_params=params + ) # Train the traced model + old_out_after_train = self.test( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): - self.assertEqual(old_out, old_out_after_train) + self.assertEqual(old_out, old_out_after_train) test2 = Modely(visualizer=None, workspace=self.test.getWorkspace()) test2.importPythonModel() # Load the nnodely model with parameter values - test2.loadData(name='dataset', source=dataset) # Create the dataset - test2.trainModel(optimizer='SGD', training_params=params) # Train the traced model - new_out_after_train = test2({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'y': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}) + test2.loadData(name="dataset", source=dataset) # Create the dataset + test2.trainModel( + optimizer="SGD", training_params=params + ) # Train the traced model + new_out_after_train = test2( + { + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "y": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], + } + ) with self.assertRaises(AssertionError): - self.assertEqual(old_out, new_out_after_train) + self.assertEqual(old_out, new_out_after_train) self.assertEqual(old_out_after_train, new_out_after_train) if os.path.exists(self.test.getWorkspace()): @@ -305,17 +456,42 @@ def test_export_onnx(self): self.test.neuralizeModel(0.5, clear_model=True) # Export all network with minimize - self.test.exportONNX(inputs_order=['x', 'y', 'z'], outputs_order=['out', 'out2', 'out3', 'out4', 'out5', 'out6', 'out7']) # Export the onnx model + self.test.exportONNX( + inputs_order=["x", "y", "z"], + outputs_order=["out", "out2", "out3", "out4", "out5", "out6", "out7"], + ) # Export the onnx model # Export the all models in onnx format - self.test.exportONNX(models=['modelA','modelB','modelC','modelD'], inputs_order=['x', 'y'], outputs_order=['out', 'out2', 'out3', 'out4', 'out5', 'out6']) # Export the onnx model + self.test.exportONNX( + models=["modelA", "modelB", "modelC", "modelD"], + inputs_order=["x", "y"], + outputs_order=["out", "out2", "out3", "out4", "out5", "out6"], + ) # Export the onnx model # Export only the modelB in onnx format - self.test.exportONNX(inputs_order=['x', 'y'], outputs_order=['out3', 'out4', 'out2'], models=['modelB']) # Export the onnx model - self.assertTrue(os.path.exists(os.path.join(self.test.getWorkspace(), 'onnx', 'net.onnx'))) - self.assertTrue(os.path.exists(os.path.join(self.test.getWorkspace(), 'onnx', 'net_modelA_modelB_modelC_modelD.onnx'))) - self.assertTrue(os.path.exists(os.path.join(self.test.getWorkspace(), 'onnx', 'net_modelB.onnx'))) + self.test.exportONNX( + inputs_order=["x", "y"], + outputs_order=["out3", "out4", "out2"], + models=["modelB"], + ) # Export the onnx model + self.assertTrue( + os.path.exists(os.path.join(self.test.getWorkspace(), "onnx", "net.onnx")) + ) + self.assertTrue( + os.path.exists( + os.path.join( + self.test.getWorkspace(), + "onnx", + "net_modelA_modelB_modelC_modelD.onnx", + ) + ) + ) + self.assertTrue( + os.path.exists( + os.path.join(self.test.getWorkspace(), "onnx", "net_modelB.onnx") + ) + ) if os.path.exists(self.test.getWorkspace()): - shutil.rmtree(self.test.getWorkspace()) + shutil.rmtree(self.test.getWorkspace()) def test_export_report(self): if os.path.exists(self.test.getWorkspace()): @@ -327,18 +503,25 @@ def test_export_report(self): data_x = np.arange(0.0, 10, 0.1) data_y = np.arange(0.0, 10, 0.1) a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 20, 'lr': 0.0005} - self.test.loadData(name='dataset', source=dataset) # Create the dataset - self.test.trainModel(optimizer='SGD', training_params=params) # Train the traced model + dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + params = {"num_of_epochs": 20, "lr": 0.0005} + self.test.loadData(name="dataset", source=dataset) # Create the dataset + self.test.trainModel( + optimizer="SGD", training_params=params + ) # Train the traced model self.test.exportReport() - self.test.loadData(name='dataset2', source=dataset) # Create the dataset - self.test.trainAndAnalyze(optimizer='SGD', train_dataset='dataset', validation_dataset='dataset2', training_params=params) # Train the traced model + self.test.loadData(name="dataset2", source=dataset) # Create the dataset + self.test.trainAndAnalyze( + optimizer="SGD", + train_dataset="dataset", + validation_dataset="dataset2", + training_params=params, + ) # Train the traced model self.test.exportReport() - self.test.removeMinimize(['error1','error2','error3','error4']) + self.test.removeMinimize(["error1", "error2", "error3", "error4"]) self.test.exportReport() if os.path.exists(self.test.getWorkspace()): - shutil.rmtree(self.test.getWorkspace()) \ No newline at end of file + shutil.rmtree(self.test.getWorkspace()) diff --git a/tests/test_export_recurrent.py b/tests/test_export_recurrent.py index 0874ca54..27824ba1 100644 --- a/tests/test_export_recurrent.py +++ b/tests/test_export_recurrent.py @@ -1,4 +1,9 @@ -import sys, os, unittest, torch, shutil, torch.onnx, importlib +import os +import unittest +import torch +import shutil +import torch.onnx +import importlib import numpy as np from nnodely import * @@ -11,47 +16,65 @@ # 11 Tests # Test of export and import the network to a file in different format -class ModelyExportTest(unittest.TestCase): +class ModelyExportTest(unittest.TestCase): def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: - self.assertEqual(len(data1),len(data2)) + self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.TestAlmostEqual(pred, label, precision=precision) else: self.assertAlmostEqual(data1, data2, places=precision) - def test_export_and_import_train_python_module(self): NeuObj.clearNames() - result_path = 'results' - network_name = 'net' + result_path = "results" + network_name = "net" test = Modely(visualizer=None, seed=42, workspace=result_path) - x = Input('x') - y = Input('y') - z = Input('z') - target = Input('target') - a = Parameter('a', dimensions=1, sw=1, values=[[1]]) - b = Parameter('b', dimensions=1, sw=1, values=[[1]]) - c = Parameter('c', dimensions=1, sw=1, values=[[1]]) + x = Input("x") + y = Input("y") + z = Input("z") + target = Input("target") + a = Parameter("a", dimensions=1, sw=1, values=[[1]]) + b = Parameter("b", dimensions=1, sw=1, values=[[1]]) + c = Parameter("c", dimensions=1, sw=1, values=[[1]]) fir_x = Fir(W=a)(x.last()) fir_y = Fir(W=b)(y.last()) fir_z = Fir(W=c)(z.last()) - data_x, data_y, data_z = np.random.rand(20), np.random.rand(20), np.random.rand(20) - dataset = {'x':data_x, 'y':data_y, 'z':data_z, 'target':3*data_x + 3*data_y + 3*data_z} + data_x, data_y, data_z = ( + np.random.rand(20), + np.random.rand(20), + np.random.rand(20), + ) + dataset = { + "x": data_x, + "y": data_y, + "z": data_z, + "target": 3 * data_x + 3 * data_y + 3 * data_z, + } fir_x.connect(y) sum_rel = fir_x + fir_y + fir_z sum_rel.closedLoop(z) - out = Output('out', sum_rel) - test.addModel('model', out) - test.addMinimize('error', target.last(), out) + out = Output("out", sum_rel) + test.addModel("model", out) + test.addMinimize("error", target.last(), out) test.neuralizeModel(0.5) - test.loadData(name='test_dataset', source=dataset) + test.loadData(name="test_dataset", source=dataset) ## Train - test.trainModel(optimizer='SGD', training_params={'num_of_epochs': 1, 'lr': 0.0001, 'train_batch_size': 1}, splits=[100,0,0], prediction_samples=10) + test.trainModel( + optimizer="SGD", + training_params={"num_of_epochs": 1, "lr": 0.0001, "train_batch_size": 1}, + splits=[100, 0, 0], + prediction_samples=10, + ) ## Inference - sample = {'x':[1], 'y':[2], 'z':[3], 'target':[18]} + sample = {"x": [1], "y": [2], "z": [3], "target": [18]} train_result = test(sample) train_parameters = test.parameters # Export the model @@ -60,352 +83,520 @@ def test_export_and_import_train_python_module(self): test.importPythonModel(name=network_name) # Inference with imported model self.assertEqual(train_result, test(sample)) - self.assertEqual(train_parameters['a'], test.parameters['a']) - self.assertEqual(train_parameters['b'], test.parameters['b']) - self.assertEqual(train_parameters['c'], test.parameters['c']) + self.assertEqual(train_parameters["a"], test.parameters["a"]) + self.assertEqual(train_parameters["b"], test.parameters["b"]) + self.assertEqual(train_parameters["c"], test.parameters["c"]) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_export_and_import_python_module(self): NeuObj.clearNames() - result_path = 'results' - network_name = 'exported_model' + result_path = "results" + network_name = "exported_model" test = Modely(visualizer=None, seed=42, workspace=result_path) - x = Input('x') - y = Input('y') - z = Input('z') - a = Parameter('a', dimensions=1, sw=1, values=[[1]]) - b = Parameter('b', dimensions=1, sw=1, values=[[1]]) - c = Parameter('c', dimensions=1, sw=1, values=[[1]]) + x = Input("x") + y = Input("y") + z = Input("z") + a = Parameter("a", dimensions=1, sw=1, values=[[1]]) + b = Parameter("b", dimensions=1, sw=1, values=[[1]]) + c = Parameter("c", dimensions=1, sw=1, values=[[1]]) fir_x = Fir(W=a)(x.last()) fir_y = Fir(W=b)(y.last()) fir_z = Fir(W=c)(z.last()) fir_x.connect(y) sum_rel = fir_x + fir_y + fir_z sum_rel.closedLoop(z) - out = Output('out', sum_rel) - test.addModel('model', out) + out = Output("out", sum_rel) + test.addModel("model", out) test.neuralizeModel(0.5) ## Inference - sample = {'x':[1], 'y':[2], 'z':[3]} + sample = {"x": [1], "y": [2], "z": [3]} inference_result = test(sample) - self.assertEqual(inference_result['out'], [5.0]) + self.assertEqual(inference_result["out"], [5.0]) # Export the model test.exportPythonModel(name=network_name) ## Load the exported model.py ## Import the python exported module - #from results.exported_model import RecurrentModel - module = importlib.import_module(result_path+'.'+network_name) - RecurrentModel = getattr(module, 'RecurrentModel') + # from results.exported_model import RecurrentModel + module = importlib.import_module(result_path + "." + network_name) + RecurrentModel = getattr(module, "RecurrentModel") model = RecurrentModel() # Create dummy input data - dummy_input = {'x': torch.ones(5, 1, 1, 1), 'target': torch.ones(10, 1, 1, 1), 'y': torch.zeros(1,1,1), 'z':torch.zeros(1,1,1)} # Adjust the shape as needed + dummy_input = { + "x": torch.ones(5, 1, 1, 1), + "target": torch.ones(10, 1, 1, 1), + "y": torch.zeros(1, 1, 1), + "z": torch.zeros(1, 1, 1), + } # Adjust the shape as needed # Inference with imported model with torch.no_grad(): output = model(dummy_input) - self.assertEqual(output['out'], [torch.tensor([[[2.]]]), torch.tensor([[[4.]]]), torch.tensor([[[6.]]]), torch.tensor([[[8.]]]), torch.tensor([[[10.]]])]) + self.assertEqual( + output["out"], + [ + torch.tensor([[[2.0]]]), + torch.tensor([[[4.0]]]), + torch.tensor([[[6.0]]]), + torch.tensor([[[8.0]]]), + torch.tensor([[[10.0]]]), + ], + ) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_export_and_import_onnx_module(self): NeuObj.clearNames() - result_path = 'results' + result_path = "results" test = Modely(visualizer=None, seed=42, workspace=result_path) - x = Input('x') - y = Input('y') - z = Input('z') - a = Parameter('a', dimensions=1, sw=1, values=[[1]]) - b = Parameter('b', dimensions=1, sw=1, values=[[1]]) - c = Parameter('c', dimensions=1, sw=1, values=[[1]]) + x = Input("x") + y = Input("y") + z = Input("z") + a = Parameter("a", dimensions=1, sw=1, values=[[1]]) + b = Parameter("b", dimensions=1, sw=1, values=[[1]]) + c = Parameter("c", dimensions=1, sw=1, values=[[1]]) fir_x = Fir(W=a)(x.last()) fir_y = Fir(W=b)(y.last()) fir_z = Fir(W=c)(z.last()) fir_x.connect(y) sum_rel = fir_x + fir_y + fir_z sum_rel.closedLoop(z) - out = Output('out', sum_rel) - test.addModel('model', out) + out = Output("out", sum_rel) + test.addModel("model", out) test.neuralizeModel(0.5) ## Inference - sample = {'x':[1], 'y':[2], 'z':[3]} + sample = {"x": [1], "y": [2], "z": [3]} inference_result = test(sample) - self.assertEqual(inference_result['out'], [5.0]) + self.assertEqual(inference_result["out"], [5.0]) ## Export in ONNX format - test.exportONNX(['x','y','z'],['out']) # Export the onnx model + test.exportONNX(["x", "y", "z"], ["out"]) # Export the onnx model ## ONNX IMPORT - dummy_input = {'x':np.ones(shape=(3, 1, 1, 1)).astype(np.float32), - 'y':np.ones(shape=(1, 1, 1)).astype(np.float32), - 'z':np.ones(shape=(1, 1, 1)).astype(np.float32)} - outputs = Modely(visualizer=None,workspace=result_path).onnxInference(dummy_input) + dummy_input = { + "x": np.ones(shape=(3, 1, 1, 1)).astype(np.float32), + "y": np.ones(shape=(1, 1, 1)).astype(np.float32), + "z": np.ones(shape=(1, 1, 1)).astype(np.float32), + } + outputs = Modely(visualizer=None, workspace=result_path).onnxInference( + dummy_input + ) # Get the output - expected_output = np.array([[[[3.]]], [[[5.]]], [[[7.]]]], dtype=np.float32) + expected_output = np.array([[[[3.0]]], [[[5.0]]], [[[7.0]]]], dtype=np.float32) self.assertEqual(outputs[0].tolist(), expected_output.tolist()) # The connected variable is not needed - sample = {'x':[3],'z':[5]} + sample = {"x": [3], "z": [5]} inference_result = test(sample) - dummy_input = {'x':3*np.ones(shape=(1, 1, 1, 1)).astype(np.float32), - 'y':7*np.ones(shape=(1, 1, 1)).astype(np.float32), - 'z':5*np.ones(shape=(1, 1, 1)).astype(np.float32)} - outputs = Modely(visualizer=None, workspace=result_path).onnxInference(dummy_input) - self.assertEqual(outputs[0][0][0], inference_result['out']) + dummy_input = { + "x": 3 * np.ones(shape=(1, 1, 1, 1)).astype(np.float32), + "y": 7 * np.ones(shape=(1, 1, 1)).astype(np.float32), + "z": 5 * np.ones(shape=(1, 1, 1)).astype(np.float32), + } + outputs = Modely(visualizer=None, workspace=result_path).onnxInference( + dummy_input + ) + self.assertEqual(outputs[0][0][0], inference_result["out"]) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_export_and_import_onnx_module_easy(self): NeuObj.clearNames() - result_path = 'results' + result_path = "results" test = Modely(visualizer=None, seed=42, workspace=result_path) - num_cycle = Input('num_cycle') - x = Input('x') - fir_x = Fir()(x.last()+1.0) + num_cycle = Input("num_cycle") + x = Input("x") + fir_x = Fir()(x.last() + 1.0) fir_x.closedLoop(x) - out1 = Output('out1', fir_x) - out2 = Output('out2', num_cycle.last()+1.0) - test.addModel('model', [out1,out2]) + out1 = Output("out1", fir_x) + out2 = Output("out2", num_cycle.last() + 1.0) + test.addModel("model", [out1, out2]) test.neuralizeModel(0.5) ## Export in ONNX format - test.exportONNX(['x','num_cycle'],['out1','out2']) # Export the onnx model - output_nodely = test({'num_cycle':np.ones(shape=(10)).astype(np.float32).tolist(), 'x':np.ones(shape=(1)).astype(np.float32).tolist()}) + test.exportONNX(["x", "num_cycle"], ["out1", "out2"]) # Export the onnx model + output_nodely = test( + { + "num_cycle": np.ones(shape=(10)).astype(np.float32).tolist(), + "x": np.ones(shape=(1)).astype(np.float32).tolist(), + } + ) ## ONNX IMPORT - outputs = Modely(visualizer=None,workspace=result_path).onnxInference(inputs={'num_cycle':np.ones(shape=(10, 1, 1, 1)).astype(np.float32), 'x':np.ones(shape=(1, 1, 1)).astype(np.float32)}) - self.assertEqual(output_nodely['out1'], outputs[0].squeeze().tolist()) - self.assertEqual(output_nodely['out2'], outputs[1].squeeze().tolist()) + outputs = Modely(visualizer=None, workspace=result_path).onnxInference( + inputs={ + "num_cycle": np.ones(shape=(10, 1, 1, 1)).astype(np.float32), + "x": np.ones(shape=(1, 1, 1)).astype(np.float32), + } + ) + self.assertEqual(output_nodely["out1"], outputs[0].squeeze().tolist()) + self.assertEqual(output_nodely["out2"], outputs[1].squeeze().tolist()) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_export_and_import_onnx_module_complex(self): # Create nnodely structure - result_path = 'results' - network_name = 'vehicle' + result_path = "results" + network_name = "vehicle" vehicle = Modely(visualizer=None, seed=2, workspace=result_path) # Dimensions of the layers - n = 25 + n = 25 na = 21 - #Create neural model inputs - velocity = Input('vel') - brake = Input('brk') - gear = Input('gear') - torque = Input('trq') - altitude = Input('alt',dimensions=na) - acc = Input('acc') + # Create neural model inputs + velocity = Input("vel") + brake = Input("brk") + gear = Input("gear") + torque = Input("trq") + altitude = Input("alt", dimensions=na) + acc = Input("acc") # Create neural network relations - air_drag_force = Linear(b=True)(velocity.last()**2) - breaking_force = -Relu(Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})(brake.sw(n))) - gravity_force = Linear(W_init='init_constant', W_init_params={'value':0}, dropout=0.1, W='gravity')(altitude.last()) - fuzzi_gear = Fuzzify(6, range=[2,7], functions='Rectangular')(gear.last()) - local_model = LocalModel(input_function=lambda: Fir(W_init = 'init_negexp', W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})) + air_drag_force = Linear(b=True)(velocity.last() ** 2) + breaking_force = -Relu( + Fir( + W_init="init_negexp", + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + )(brake.sw(n)) + ) + gravity_force = Linear( + W_init="init_constant", W_init_params={"value": 0}, dropout=0.1, W="gravity" + )(altitude.last()) + fuzzi_gear = Fuzzify(6, range=[2, 7], functions="Rectangular")(gear.last()) + local_model = LocalModel( + input_function=lambda: Fir( + W_init="init_negexp", + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + ) + ) engine_force = local_model(torque.sw(n), fuzzi_gear) # Create neural network output - out = Output('accelleration', air_drag_force+breaking_force+gravity_force+engine_force) + out = Output( + "accelleration", + air_drag_force + breaking_force + gravity_force + engine_force, + ) # Add the neural model to the nnodely structure and neuralization of the model - vehicle.addModel('acc',out) - vehicle.addMinimize('acc_error', acc.last(), out, loss_function='rmse') + vehicle.addModel("acc", out) + vehicle.addMinimize("acc_error", acc.last(), out, loss_function="rmse") vehicle.neuralizeModel(0.05) # Load the training and the validation dataset - data_struct = ['vel','trq','brk','gear','alt','acc'] - data_folder = os.path.join(os.path.dirname(os.path.realpath(__file__)),'vehicle_data') - vehicle.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) + data_struct = ["vel", "trq", "brk", "gear", "alt", "acc"] + data_folder = os.path.join( + os.path.dirname(os.path.realpath(__file__)), "vehicle_data" + ) + vehicle.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) # Inference - model_sample = vehicle.getSamples('dataset', window=1) + model_sample = vehicle.getSamples("dataset", window=1) model_inference = vehicle(model_sample, sampled=True, prediction_samples=1) ## Export the Onnx Model - vehicle.exportONNX(['vel','brk','gear','trq','alt'],['accelleration'], network_name, models='acc') + vehicle.exportONNX( + ["vel", "brk", "gear", "trq", "alt"], + ["accelleration"], + network_name, + models="acc", + ) # Onnx Import - outputs = Modely(visualizer=None).onnxInference(model_sample, name=network_name, model_folder=os.path.join(result_path,'onnx')) - self.assertEqual(outputs[0][0], model_inference['accelleration']) + outputs = Modely(visualizer=None).onnxInference( + model_sample, + name=network_name, + model_folder=os.path.join(result_path, "onnx"), + ) + self.assertEqual(outputs[0][0], model_inference["accelleration"]) if os.path.exists(vehicle.getWorkspace()): shutil.rmtree(vehicle.getWorkspace()) def test_export_python_module_recurrent(self): NeuObj.clearNames() - result_path = 'results' - network_name = 'net' + result_path = "results" + network_name = "net" test = Modely(visualizer=None, seed=42, workspace=result_path) - input1 = Input('input1') - input2 = Input('input2', dimensions=3) - input3 = Input('input3') - input4 = Input('input4', dimensions=3) - state1 = Input('state1') - state2 = Input('state2', dimensions=3) + input1 = Input("input1") + input2 = Input("input2", dimensions=3) + input3 = Input("input3") + input4 = Input("input4", dimensions=3) + state1 = Input("state1") + state2 = Input("state2", dimensions=3) rel_1 = Linear(b=True)(input1.last()) + Linear(b=True)(input3.last()) rel_1.closedLoop(state1) - rel_2 = Linear(output_dimension=3, b=True)(input2.last()) + Linear(output_dimension=3, b=True)(input4.last()) + rel_2 = Linear(output_dimension=3, b=True)(input2.last()) + Linear( + output_dimension=3, b=True + )(input4.last()) rel_2.closedLoop(state2) - out1 = Output('out1', rel_1) - out2 = Output('out2', rel_2) - out3 = Output('input1-out', input1.last()) - out4 = Output('input2-out', input2.last()) - out5 = Output('input3-out', input3.sw(4)) - out6 = Output('input4-out', input4.sw(4)) - out7 = Output('state1-out', state1.last()) - out8 = Output('state2-out', state2.last()) + out1 = Output("out1", rel_1) + out2 = Output("out2", rel_2) + out3 = Output("input1-out", input1.last()) + out4 = Output("input2-out", input2.last()) + out5 = Output("input3-out", input3.sw(4)) + out6 = Output("input4-out", input4.sw(4)) + out7 = Output("state1-out", state1.last()) + out8 = Output("state2-out", state2.last()) - test.addModel('model', [out1, out2, out3, out4, out5, out6, out7, out8]) + test.addModel("model", [out1, out2, out3, out4, out5, out6, out7, out8]) test.neuralizeModel() test.exportPythonModel(name=network_name) ## Load the exported model.py ## Import the python exported module - #from results.net import RecurrentModel - module = importlib.import_module(result_path+'.'+network_name) - RecurrentModel = getattr(module, 'RecurrentModel') + # from results.net import RecurrentModel + module = importlib.import_module(result_path + "." + network_name) + RecurrentModel = getattr(module, "RecurrentModel") recurrent_model = RecurrentModel() ## Without Horizon and without batch - recurrent_sample = {'input1': torch.rand(size=(1,1,1,1), dtype=torch.float32), - 'input2': torch.rand(size=(1,1,1,3), dtype=torch.float32), - 'input3': torch.rand(size=(1,1,4,1), dtype=torch.float32), - 'input4': torch.rand(size=(1,1,4,3), dtype=torch.float32)} - recurrent_sample['state1'] = torch.rand(size=(1,1,1), dtype=torch.float32) - recurrent_sample['state2'] = torch.rand(size=(1,1,3), dtype=torch.float32) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out1']).shape), [1,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out2']).shape), [1,1,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input1-out']).shape), [1,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input2-out']).shape), [1,1,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input3-out']).shape), [1,1,4,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input4-out']).shape), [1,1,4,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state1-out']).shape), [1,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state2-out']).shape), [1,1,1,3]) + recurrent_sample = { + "input1": torch.rand(size=(1, 1, 1, 1), dtype=torch.float32), + "input2": torch.rand(size=(1, 1, 1, 3), dtype=torch.float32), + "input3": torch.rand(size=(1, 1, 4, 1), dtype=torch.float32), + "input4": torch.rand(size=(1, 1, 4, 3), dtype=torch.float32), + } + recurrent_sample["state1"] = torch.rand(size=(1, 1, 1), dtype=torch.float32) + recurrent_sample["state2"] = torch.rand(size=(1, 1, 3), dtype=torch.float32) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out1"]).shape), + [1, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out2"]).shape), + [1, 1, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input1-out"]).shape), + [1, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input2-out"]).shape), + [1, 1, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input3-out"]).shape), + [1, 1, 4, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input4-out"]).shape), + [1, 1, 4, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state1-out"]).shape), + [1, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state2-out"]).shape), + [1, 1, 1, 3], + ) ## With Horizon and without batch - recurrent_sample = {'input1': torch.rand(size=(5,1,1,1), dtype=torch.float32), - 'input2': torch.rand(size=(5,1,1,3), dtype=torch.float32), - 'input3': torch.rand(size=(5,1,4,1), dtype=torch.float32), - 'input4': torch.rand(size=(5,1,4,3), dtype=torch.float32)} - recurrent_sample['state1'] = torch.rand(size=(1,1,1), dtype=torch.float32) - recurrent_sample['state2'] = torch.rand(size=(1,1,3), dtype=torch.float32) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out1']).shape), [5,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out2']).shape), [5,1,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input1-out']).shape), [5,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input2-out']).shape), [5,1,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input3-out']).shape), [5,1,4,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input4-out']).shape), [5,1,4,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state1-out']).shape), [5,1,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state2-out']).shape), [5,1,1,3]) + recurrent_sample = { + "input1": torch.rand(size=(5, 1, 1, 1), dtype=torch.float32), + "input2": torch.rand(size=(5, 1, 1, 3), dtype=torch.float32), + "input3": torch.rand(size=(5, 1, 4, 1), dtype=torch.float32), + "input4": torch.rand(size=(5, 1, 4, 3), dtype=torch.float32), + } + recurrent_sample["state1"] = torch.rand(size=(1, 1, 1), dtype=torch.float32) + recurrent_sample["state2"] = torch.rand(size=(1, 1, 3), dtype=torch.float32) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out1"]).shape), + [5, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out2"]).shape), + [5, 1, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input1-out"]).shape), + [5, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input2-out"]).shape), + [5, 1, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input3-out"]).shape), + [5, 1, 4, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input4-out"]).shape), + [5, 1, 4, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state1-out"]).shape), + [5, 1, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state2-out"]).shape), + [5, 1, 1, 3], + ) ## With Horizon and with batch - recurrent_sample = {'input1': torch.rand(size=(5,2,1,1), dtype=torch.float32), - 'input2': torch.rand(size=(5,2,1,3), dtype=torch.float32), - 'input3': torch.rand(size=(5,2,4,1), dtype=torch.float32), - 'input4': torch.rand(size=(5,2,4,3), dtype=torch.float32)} - recurrent_sample['state1'] = torch.rand(size=(2,1,1), dtype=torch.float32) - recurrent_sample['state2'] = torch.rand(size=(2,1,3), dtype=torch.float32) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out1']).shape), [5,2,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['out2']).shape), [5,2,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input1-out']).shape), [5,2,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input2-out']).shape), [5,2,1,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input3-out']).shape), [5,2,4,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['input4-out']).shape), [5,2,4,3]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state1-out']).shape), [5,2,1,1]) - self.assertListEqual(list(torch.stack(recurrent_model(recurrent_sample)['state2-out']).shape), [5,2,1,3]) + recurrent_sample = { + "input1": torch.rand(size=(5, 2, 1, 1), dtype=torch.float32), + "input2": torch.rand(size=(5, 2, 1, 3), dtype=torch.float32), + "input3": torch.rand(size=(5, 2, 4, 1), dtype=torch.float32), + "input4": torch.rand(size=(5, 2, 4, 3), dtype=torch.float32), + } + recurrent_sample["state1"] = torch.rand(size=(2, 1, 1), dtype=torch.float32) + recurrent_sample["state2"] = torch.rand(size=(2, 1, 3), dtype=torch.float32) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out1"]).shape), + [5, 2, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["out2"]).shape), + [5, 2, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input1-out"]).shape), + [5, 2, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input2-out"]).shape), + [5, 2, 1, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input3-out"]).shape), + [5, 2, 4, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["input4-out"]).shape), + [5, 2, 4, 3], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state1-out"]).shape), + [5, 2, 1, 1], + ) + self.assertListEqual( + list(torch.stack(recurrent_model(recurrent_sample)["state2-out"]).shape), + [5, 2, 1, 3], + ) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_export_onnx_module_recurrent(self): - result_path = 'results' - test = Modely(visualizer=None, seed=42, workspace= result_path) - input1 = Input('input1') - input2 = Input('input2', dimensions=3) - input3 = Input('input3') - input4 = Input('input4', dimensions=3) - state1 = Input('state1') - state2 = Input('state2', dimensions=3) + result_path = "results" + test = Modely(visualizer=None, seed=42, workspace=result_path) + input1 = Input("input1") + input2 = Input("input2", dimensions=3) + input3 = Input("input3") + input4 = Input("input4", dimensions=3) + state1 = Input("state1") + state2 = Input("state2", dimensions=3) rel_1 = Linear(b=True)(input1.last()) + Linear(b=True)(input3.last()) rel_1.closedLoop(state1) - rel_2 = Linear(output_dimension=3, b=True)(input2.last()) + Linear(output_dimension=3, b=True)(input4.last()) + rel_2 = Linear(output_dimension=3, b=True)(input2.last()) + Linear( + output_dimension=3, b=True + )(input4.last()) rel_2.closedLoop(state2) - out1 = Output('out1', rel_1) - out2 = Output('out2', rel_2) - out3 = Output('out_input1', input1.last()) - out4 = Output('out_input2', input2.last()) - out5 = Output('out_input3', input3.sw(4)) - out6 = Output('out_input4', input4.sw(4)) - out7 = Output('out_state1', state1.last()) - out8 = Output('out_state2', state2.last()) + out1 = Output("out1", rel_1) + out2 = Output("out2", rel_2) + out3 = Output("out_input1", input1.last()) + out4 = Output("out_input2", input2.last()) + out5 = Output("out_input3", input3.sw(4)) + out6 = Output("out_input4", input4.sw(4)) + out7 = Output("out_state1", state1.last()) + out8 = Output("out_state2", state2.last()) - test.addModel('model', [out1, out2, out3, out4, out5, out6, out7, out8]) + test.addModel("model", [out1, out2, out3, out4, out5, out6, out7, out8]) test.neuralizeModel() - test.exportONNX(inputs_order=['input1','input2','input3','input4','state1','state2'],outputs_order=['out1', 'out2', 'out_input1', 'out_input2', 'out_input3', 'out_input4', 'out_state1', 'out_state2']) + test.exportONNX( + inputs_order=["input1", "input2", "input3", "input4", "state1", "state2"], + outputs_order=[ + "out1", + "out2", + "out_input1", + "out_input2", + "out_input3", + "out_input4", + "out_state1", + "out_state2", + ], + ) ## Without Horizon and without batch - recurrent_sample = {'input1': np.random.rand(1,1,1,1).astype(np.float32), - 'input2': np.random.rand(1,1,1,3).astype(np.float32), - 'input3': np.random.rand(1,1,4,1).astype(np.float32), - 'input4': np.random.rand(1,1,4,3).astype(np.float32)} - recurrent_sample['state1'] = np.random.rand(1,1,1).astype(np.float32) - recurrent_sample['state2'] = np.random.rand(1,1,3).astype(np.float32) - inference = Modely(visualizer=None).onnxInference(recurrent_sample, model_folder=os.path.join(test.getWorkspace(),'onnx')) - self.assertListEqual(list(inference[0].shape), [1,1,1,1]) - self.assertListEqual(list(inference[1].shape), [1,1,1,3]) - self.assertListEqual(list(inference[2].shape), [1,1,1,1]) - self.assertListEqual(list(inference[3].shape), [1,1,1,3]) - self.assertListEqual(list(inference[4].shape), [1,1,4,1]) - self.assertListEqual(list(inference[5].shape), [1,1,4,3]) - self.assertListEqual(list(inference[6].shape), [1,1,1,1]) - self.assertListEqual(list(inference[7].shape), [1,1,1,3]) + recurrent_sample = { + "input1": np.random.rand(1, 1, 1, 1).astype(np.float32), + "input2": np.random.rand(1, 1, 1, 3).astype(np.float32), + "input3": np.random.rand(1, 1, 4, 1).astype(np.float32), + "input4": np.random.rand(1, 1, 4, 3).astype(np.float32), + } + recurrent_sample["state1"] = np.random.rand(1, 1, 1).astype(np.float32) + recurrent_sample["state2"] = np.random.rand(1, 1, 3).astype(np.float32) + inference = Modely(visualizer=None).onnxInference( + recurrent_sample, model_folder=os.path.join(test.getWorkspace(), "onnx") + ) + self.assertListEqual(list(inference[0].shape), [1, 1, 1, 1]) + self.assertListEqual(list(inference[1].shape), [1, 1, 1, 3]) + self.assertListEqual(list(inference[2].shape), [1, 1, 1, 1]) + self.assertListEqual(list(inference[3].shape), [1, 1, 1, 3]) + self.assertListEqual(list(inference[4].shape), [1, 1, 4, 1]) + self.assertListEqual(list(inference[5].shape), [1, 1, 4, 3]) + self.assertListEqual(list(inference[6].shape), [1, 1, 1, 1]) + self.assertListEqual(list(inference[7].shape), [1, 1, 1, 3]) ## With Horizon and without batch - recurrent_sample = {'input1': np.random.rand(5,1,1,1).astype(np.float32), - 'input2': np.random.rand(5,1,1,3).astype(np.float32), - 'input3': np.random.rand(5,1,4,1).astype(np.float32), - 'input4': np.random.rand(5,1,4,3).astype(np.float32)} - recurrent_sample['state1'] = np.random.rand(1,1,1).astype(np.float32) - recurrent_sample['state2'] = np.random.rand(1,1,3).astype(np.float32) - inference = Modely(visualizer=None,workspace=result_path).onnxInference(recurrent_sample) - self.assertListEqual(list(inference[0].shape), [5,1,1,1]) - self.assertListEqual(list(inference[1].shape), [5,1,1,3]) - self.assertListEqual(list(inference[2].shape), [5,1,1,1]) - self.assertListEqual(list(inference[3].shape), [5,1,1,3]) - self.assertListEqual(list(inference[4].shape), [5,1,4,1]) - self.assertListEqual(list(inference[5].shape), [5,1,4,3]) - self.assertListEqual(list(inference[6].shape), [5,1,1,1]) - self.assertListEqual(list(inference[7].shape), [5,1,1,3]) + recurrent_sample = { + "input1": np.random.rand(5, 1, 1, 1).astype(np.float32), + "input2": np.random.rand(5, 1, 1, 3).astype(np.float32), + "input3": np.random.rand(5, 1, 4, 1).astype(np.float32), + "input4": np.random.rand(5, 1, 4, 3).astype(np.float32), + } + recurrent_sample["state1"] = np.random.rand(1, 1, 1).astype(np.float32) + recurrent_sample["state2"] = np.random.rand(1, 1, 3).astype(np.float32) + inference = Modely(visualizer=None, workspace=result_path).onnxInference( + recurrent_sample + ) + self.assertListEqual(list(inference[0].shape), [5, 1, 1, 1]) + self.assertListEqual(list(inference[1].shape), [5, 1, 1, 3]) + self.assertListEqual(list(inference[2].shape), [5, 1, 1, 1]) + self.assertListEqual(list(inference[3].shape), [5, 1, 1, 3]) + self.assertListEqual(list(inference[4].shape), [5, 1, 4, 1]) + self.assertListEqual(list(inference[5].shape), [5, 1, 4, 3]) + self.assertListEqual(list(inference[6].shape), [5, 1, 1, 1]) + self.assertListEqual(list(inference[7].shape), [5, 1, 1, 3]) # ## With Horizon and with batch - recurrent_sample = {'input1': np.random.rand(5,2,1,1).astype(np.float32), - 'input2': np.random.rand(5,2,1,3).astype(np.float32), - 'input3': np.random.rand(5,2,4,1).astype(np.float32), - 'input4': np.random.rand(5,2,4,3).astype(np.float32)} - recurrent_sample['state1'] = np.random.rand(2,1,1).astype(np.float32) - recurrent_sample['state2'] = np.random.rand(2,1,3).astype(np.float32) - inference = Modely(visualizer=None).onnxInference(recurrent_sample, model_folder=os.path.join(test.getWorkspace(),'onnx'), name='net') - self.assertListEqual(list(inference[0].shape), [5,2,1,1]) - self.assertListEqual(list(inference[1].shape), [5,2,1,3]) - self.assertListEqual(list(inference[2].shape), [5,2,1,1]) - self.assertListEqual(list(inference[3].shape), [5,2,1,3]) - self.assertListEqual(list(inference[4].shape), [5,2,4,1]) - self.assertListEqual(list(inference[5].shape), [5,2,4,3]) - self.assertListEqual(list(inference[6].shape), [5,2,1,1]) - self.assertListEqual(list(inference[7].shape), [5,2,1,3]) + recurrent_sample = { + "input1": np.random.rand(5, 2, 1, 1).astype(np.float32), + "input2": np.random.rand(5, 2, 1, 3).astype(np.float32), + "input3": np.random.rand(5, 2, 4, 1).astype(np.float32), + "input4": np.random.rand(5, 2, 4, 3).astype(np.float32), + } + recurrent_sample["state1"] = np.random.rand(2, 1, 1).astype(np.float32) + recurrent_sample["state2"] = np.random.rand(2, 1, 3).astype(np.float32) + inference = Modely(visualizer=None).onnxInference( + recurrent_sample, + model_folder=os.path.join(test.getWorkspace(), "onnx"), + name="net", + ) + self.assertListEqual(list(inference[0].shape), [5, 2, 1, 1]) + self.assertListEqual(list(inference[1].shape), [5, 2, 1, 3]) + self.assertListEqual(list(inference[2].shape), [5, 2, 1, 1]) + self.assertListEqual(list(inference[3].shape), [5, 2, 1, 3]) + self.assertListEqual(list(inference[4].shape), [5, 2, 4, 1]) + self.assertListEqual(list(inference[5].shape), [5, 2, 4, 3]) + self.assertListEqual(list(inference[6].shape), [5, 2, 1, 1]) + self.assertListEqual(list(inference[7].shape), [5, 2, 1, 3]) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) @@ -413,69 +604,98 @@ def test_export_onnx_module_recurrent(self): def test_export_and_import_python_module_complex_recurrent(self): NeuObj.clearNames() # Create nnodely structure - result_path = 'results' - network_name = 'vehicle' + result_path = "results" + network_name = "vehicle" vehicle = Modely(visualizer=None, seed=2, workspace=result_path) # Dimensions of the layers - n = 25 + n = 25 na = 21 - #Create neural model inputs - velocity = Input('vel') - brake = Input('brk') - gear = Input('gear') - torque = Input('trq') - altitude = Input('alt',dimensions=na) - acc = Input('acc') + # Create neural model inputs + velocity = Input("vel") + brake = Input("brk") + gear = Input("gear") + torque = Input("trq") + altitude = Input("alt", dimensions=na) + acc = Input("acc") # Create neural network relations - air_drag_force = Linear(b=True)(velocity.last()**2) - breaking_force = -Relu(Fir(W_init = init_negexp, W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})(brake.sw(n))) - gravity_force = Linear(W_init=init_constant, W_init_params={'value':0}, dropout=0.1, W='gravity')(altitude.last()) - fuzzi_gear = Fuzzify(6, range=[2,7], functions='Rectangular')(gear.last()) - local_model = LocalModel(input_function=lambda: Fir(W_init = init_negexp, W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})) + air_drag_force = Linear(b=True)(velocity.last() ** 2) + breaking_force = -Relu( + Fir( + W_init=init_negexp, + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + )(brake.sw(n)) + ) + gravity_force = Linear( + W_init=init_constant, W_init_params={"value": 0}, dropout=0.1, W="gravity" + )(altitude.last()) + fuzzi_gear = Fuzzify(6, range=[2, 7], functions="Rectangular")(gear.last()) + local_model = LocalModel( + input_function=lambda: Fir( + W_init=init_negexp, + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + ) + ) engine_force = local_model(torque.sw(n), fuzzi_gear) - sum_rel = air_drag_force+breaking_force+gravity_force+engine_force + sum_rel = air_drag_force + breaking_force + gravity_force + engine_force sum_rel.closedLoop(velocity) # Create neural network output - out = Output('accelleration', sum_rel) + out = Output("accelleration", sum_rel) # Add the neural model to the nnodely structure and neuralization of the model - vehicle.addModel('acc',[out]) - vehicle.addMinimize('acc_error', acc.last(), out, loss_function='rmse') + vehicle.addModel("acc", [out]) + vehicle.addMinimize("acc_error", acc.last(), out, loss_function="rmse") vehicle.neuralizeModel(0.05) # Load the training and the validation dataset - data_struct = ['vel','trq','brk','gear','alt','acc'] - data_folder = os.path.join(os.path.dirname(os.path.realpath(__file__)),'vehicle_data') - vehicle.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) + data_struct = ["vel", "trq", "brk", "gear", "alt", "acc"] + data_folder = os.path.join( + os.path.dirname(os.path.realpath(__file__)), "vehicle_data" + ) + vehicle.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) # Inference - sample = vehicle.getSamples('dataset', window=3) + sample = vehicle.getSamples("dataset", window=3) model_inference = vehicle(sample, sampled=True, prediction_samples=3) vehicle.exportPythonModel(name=network_name) loaded_vehicle = Modely(visualizer=None, workspace=vehicle.getWorkspace()) loaded_vehicle.importPythonModel(name=network_name) - model_import_inference = loaded_vehicle(sample, sampled=True, prediction_samples=3) - self.assertEqual(model_inference['accelleration'], model_import_inference['accelleration']) + model_import_inference = loaded_vehicle( + sample, sampled=True, prediction_samples=3 + ) + self.assertEqual( + model_inference["accelleration"], model_import_inference["accelleration"] + ) ## Load the exported model.py ## Import the python exported module - #from results.vehicle import RecurrentModel - module = importlib.import_module(result_path+'.'+network_name) - RecurrentModel = getattr(module, 'RecurrentModel') + # from results.vehicle import RecurrentModel + module = importlib.import_module(result_path + "." + network_name) + RecurrentModel = getattr(module, "RecurrentModel") recurrent_model = RecurrentModel() - sample = vehicle.getSamples('dataset', window=3) - recurrent_sample = {key: torch.tensor(np.array(value), dtype=torch.float32).unsqueeze(1) for key, value in sample.items()} - recurrent_sample['vel'] = torch.zeros(1,1,1) - model_sample = {key: value for key, value in sample.items() if key != 'vel'} - self.TestAlmostEqual([item.detach().item() for item in recurrent_model(recurrent_sample)['accelleration']], vehicle(model_sample, sampled=True, prediction_samples=3)['accelleration']) + sample = vehicle.getSamples("dataset", window=3) + recurrent_sample = { + key: torch.tensor(np.array(value), dtype=torch.float32).unsqueeze(1) + for key, value in sample.items() + } + recurrent_sample["vel"] = torch.zeros(1, 1, 1) + model_sample = {key: value for key, value in sample.items() if key != "vel"} + self.TestAlmostEqual( + [ + item.detach().item() + for item in recurrent_model(recurrent_sample)["accelleration"] + ], + vehicle(model_sample, sampled=True, prediction_samples=3)["accelleration"], + ) if os.path.exists(vehicle.getWorkspace()): shutil.rmtree(vehicle.getWorkspace()) @@ -483,62 +703,100 @@ def test_export_and_import_python_module_complex_recurrent(self): def test_export_and_import_onnx_module_complex_recurrent(self): NeuObj.clearNames() # Create nnodely structure - result_path = 'results' - network_name = 'vehicle' - vehicle = Modely(visualizer=None, seed=42, workspace= result_path) + result_path = "results" + network_name = "vehicle" + vehicle = Modely(visualizer=None, seed=42, workspace=result_path) # Dimensions of the layers - n = 25 + n = 25 na = 21 - #Create neural model inputs - velocity = Input('vel') - brake = Input('brk') - gear = Input('gear') - torque = Input('trq') - altitude = Input('alt',dimensions=na) - acc = Input('acc') + # Create neural model inputs + velocity = Input("vel") + brake = Input("brk") + gear = Input("gear") + torque = Input("trq") + altitude = Input("alt", dimensions=na) + acc = Input("acc") # Create neural network relations - air_drag_force = Linear(b=True)(velocity.last()**2) - breaking_force = -Relu(Fir(W_init = init_negexp, W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})(brake.sw(n))) - gravity_force = Linear(W_init=init_constant, W_init_params={'value':0}, dropout=0.1, W='gravity')(altitude.last()) - fuzzi_gear = Fuzzify(6, range=[2,7], functions='Rectangular')(gear.last()) - local_model = LocalModel(input_function=lambda: Fir(W_init = init_negexp, W_init_params={'size_index':0, 'first_value':0.002, 'lambda':3})) + air_drag_force = Linear(b=True)(velocity.last() ** 2) + breaking_force = -Relu( + Fir( + W_init=init_negexp, + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + )(brake.sw(n)) + ) + gravity_force = Linear( + W_init=init_constant, W_init_params={"value": 0}, dropout=0.1, W="gravity" + )(altitude.last()) + fuzzi_gear = Fuzzify(6, range=[2, 7], functions="Rectangular")(gear.last()) + local_model = LocalModel( + input_function=lambda: Fir( + W_init=init_negexp, + W_init_params={"size_index": 0, "first_value": 0.002, "lambda": 3}, + ) + ) engine_force = local_model(torque.sw(n), fuzzi_gear) - sum_rel = air_drag_force+breaking_force+gravity_force+engine_force + sum_rel = air_drag_force + breaking_force + gravity_force + engine_force sum_rel.closedLoop(velocity) # Create neural network output - out = Output('accelleration', sum_rel) + out = Output("accelleration", sum_rel) # Add the neural model to the nnodely structure and neuralization of the model - vehicle.addModel('acc',[out]) - vehicle.addMinimize('acc_error', acc.last(), out, loss_function='rmse') + vehicle.addModel("acc", [out]) + vehicle.addMinimize("acc_error", acc.last(), out, loss_function="rmse") vehicle.neuralizeModel(0.05) # Load the training and the validation dataset - data_struct = ['vel','trq','brk','gear','alt','acc'] - data_folder = os.path.join(os.path.dirname(os.path.realpath(__file__)),'vehicle_data') - vehicle.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) + data_struct = ["vel", "trq", "brk", "gear", "alt", "acc"] + data_folder = os.path.join( + os.path.dirname(os.path.realpath(__file__)), "vehicle_data" + ) + vehicle.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) ## Export the Onnx Model vehicle.exportONNX(name=network_name) - model_sample = vehicle.getSamples('dataset', window=1) + model_sample = vehicle.getSamples("dataset", window=1) model_inference = vehicle(model_sample, sampled=True, prediction_samples=1) ## ONNX IMPORT - onnx_sample = {key: (np.expand_dims(value, axis=1).astype(np.float32) if key != 'vel' else value) for key, value in model_sample.items()} - outputs = Modely(visualizer=None).onnxInference(onnx_sample, name=network_name, model_folder=os.path.join(result_path,'onnx')) - self.assertEqual(outputs[0][0], model_inference['accelleration']) - - model_sample = vehicle.getSamples('dataset', window=3) - onnx_sample = {key: (np.expand_dims(value, axis=1).astype(np.float32) if key != 'vel' else np.expand_dims(np.array(value[0], dtype=np.float32), axis=0)) for key, value in model_sample.items()} + onnx_sample = { + key: ( + np.expand_dims(value, axis=1).astype(np.float32) + if key != "vel" + else value + ) + for key, value in model_sample.items() + } + outputs = Modely(visualizer=None).onnxInference( + onnx_sample, + name=network_name, + model_folder=os.path.join(result_path, "onnx"), + ) + self.assertEqual(outputs[0][0], model_inference["accelleration"]) + + model_sample = vehicle.getSamples("dataset", window=3) + onnx_sample = { + key: ( + np.expand_dims(value, axis=1).astype(np.float32) + if key != "vel" + else np.expand_dims(np.array(value[0], dtype=np.float32), axis=0) + ) + for key, value in model_sample.items() + } model_inference = vehicle(model_sample, sampled=True, prediction_samples=3) - outputs = Modely(visualizer=None, workspace=result_path).onnxInference(onnx_sample, name=network_name) - self.assertEqual(outputs[0].squeeze().tolist(), model_inference['accelleration']) + outputs = Modely(visualizer=None, workspace=result_path).onnxInference( + onnx_sample, name=network_name + ) + self.assertEqual( + outputs[0].squeeze().tolist(), model_inference["accelleration"] + ) if os.path.exists(vehicle.getWorkspace()): shutil.rmtree(vehicle.getWorkspace()) @@ -547,62 +805,76 @@ def test_export_sw_on_stream_sw_complex(self): NeuObj.clearNames() Stream.resetCount() # Create nnodely structure - result_path = 'results' - network_name = 'swnet' - input = Input('inin') + result_path = "results" + network_name = "swnet" + input = Input("inin") sw_7 = input.sw(7) - out61 = Output('out61', sw_7.sw(6)) - out62 = Output('out62', SamplePart(sw_7,1,7)) + out61 = Output("out61", sw_7.sw(6)) + out62 = Output("out62", SamplePart(sw_7, 1, 7)) test = Modely(visualizer=None, workspace=result_path) - test.addModel('out', [out61,out62]) + test.addModel("out", [out61, out62]) test.neuralizeModel() sample = [14, 1, 2, 3, 4, 5, 6] - results = test({'inin':sample}) - - test.exportONNX(inputs_order=['inin','SamplePart1_sw1'],outputs_order=['out61','out62'],name=network_name) - outputs = Modely(visualizer=None, workspace=result_path).onnxInference({'inin':np.array([[[[14],[1],[2],[3],[4],[5],[6]]]]).astype(np.float32),'SamplePart1_sw1':np.array([[[0],[0],[0],[0],[0],[0]]]).astype(np.float32)}, name=network_name) - self.assertEqual(outputs[0].squeeze().tolist(), results['out61'][0]) - self.assertEqual(outputs[1].squeeze().tolist(), results['out62'][0]) - self.assertEqual(results['out61'][0], results['out62'][0]) + results = test({"inin": sample}) + + test.exportONNX( + inputs_order=["inin", "SamplePart1_sw1"], + outputs_order=["out61", "out62"], + name=network_name, + ) + outputs = Modely(visualizer=None, workspace=result_path).onnxInference( + { + "inin": np.array([[[[14], [1], [2], [3], [4], [5], [6]]]]).astype( + np.float32 + ), + "SamplePart1_sw1": np.array([[[0], [0], [0], [0], [0], [0]]]).astype( + np.float32 + ), + }, + name=network_name, + ) + self.assertEqual(outputs[0].squeeze().tolist(), results["out61"][0]) + self.assertEqual(outputs[1].squeeze().tolist(), results["out62"][0]) + self.assertEqual(results["out61"][0], results["out62"][0]) if os.path.exists(test.getWorkspace()): shutil.rmtree(test.getWorkspace()) def test_partial_model_export(self): - #We have 4 networks, A, B, C and D + # We have 4 networks, A, B, C and D # Connection inside model 1 - #Aout is connected to Bin1 - #Bout is closed_loop to Ain2 - #Bout is clodes_loop to Bin2 + # Aout is connected to Bin1 + # Bout is closed_loop to Ain2 + # Bout is clodes_loop to Bin2 # Connection inside model 2 - #Cout is connected to Din1 + # Cout is connected to Din1 # Connection outside models in model 2 - #Dout closed_loop to Cin1 - #Cout connect to Din2 + # Dout closed_loop to Cin1 + # Cout connect to Din2 # Connection outside models between models - #Dout closed_loop to Ain1 - #Aout connected to Din3 - #Bout closed_loop to Cin2 + # Dout closed_loop to Ain1 + # Aout connected to Din3 + # Bout closed_loop to Cin2 - result_path = 'results' + result_path = "results" NeuObj.clearNames() - #log.setAllLevel(logging.INFO) + # log.setAllLevel(logging.INFO) - #Network A and B -> Model1 - Ain1 = Input('Ain1') - Ain2 = Input('Ain2') - Bin1 = Input('Bin1') - Bin2 = Input('Bin2') - Bin3 = Input('Bin3') + # Network A and B -> Model1 + Ain1 = Input("Ain1") + Ain2 = Input("Ain2") + Bin1 = Input("Bin1") + Bin2 = Input("Bin2") + Bin3 = Input("Bin3") - pA = Parameter('PA', sw=1, values=[[3.0]]) - pB = Parameter('PB', sw=1, values=[[-5.0]]) + pA = Parameter("PA", sw=1, values=[[3.0]]) + pB = Parameter("PB", sw=1, values=[[-5.0]]) Aout = (Ain1.last() + Ain2.last()) * pA Aout.connect(Bin1) @@ -611,337 +883,437 @@ def test_partial_model_export(self): Bout.closedLoop(Ain2) Bout.closedLoop(Bin2) - modelA = Output('Aout',Aout) - modelB = Output('Bout',Bout) + modelA = Output("Aout", Aout) + modelB = Output("Bout", Bout) - Cin1 = Input('Cin1') - Cin2 = Input('Cin2') - Din1 = Input('Din1') - Din2 = Input('Din2') - Din3 = Input('Din3') + Cin1 = Input("Cin1") + Cin2 = Input("Cin2") + Din1 = Input("Din1") + Din2 = Input("Din2") + Din3 = Input("Din3") - pC = Parameter('PC', sw=1, values=[[-1.0]]) - pD = Parameter('PD', sw=1, values=[[2.0]]) + pC = Parameter("PC", sw=1, values=[[-1.0]]) + pD = Parameter("PD", sw=1, values=[[2.0]]) Cout = (Cin1.last() + Cin2.last()) * pC Cout.connect(Din1) Dout = (Din1.last() + Din2.last() + Din3.last()) * pD - modelC = Output('Cout',Cout) - modelD = Output('Dout',Dout) + modelC = Output("Cout", Cout) + modelD = Output("Dout", Dout) m = Modely(workspace=result_path, visualizer=None) with self.assertRaises(RuntimeError): - m.addModel('modelA', [modelA]) + m.addModel("modelA", [modelA]) with self.assertRaises(RuntimeError): - m.addModel('modelB', [modelB]) - - m.addModel('model1', [modelA, modelB]) - m.addModel('model2', [modelC, modelD]) - - init_inputs = {'Din3': [1], 'Din2': [1], 'Cin1': [1], 'Cin2': [1], 'Ain1': [1], 'Bin3': [1]} - init_states = {'Din1': [1], 'Bin2':[1], 'Ain2':[1], 'Bin1': [1]} - init_states_diff = {'Din1': [12], 'Bin2': [1], 'Ain2': [1], 'Bin1': [12]} + m.addModel("modelB", [modelB]) + + m.addModel("model1", [modelA, modelB]) + m.addModel("model2", [modelC, modelD]) + + init_inputs = { + "Din3": [1], + "Din2": [1], + "Cin1": [1], + "Cin2": [1], + "Ain1": [1], + "Bin3": [1], + } + init_states = {"Din1": [1], "Bin2": [1], "Ain2": [1], "Bin1": [1]} + init_states_diff = {"Din1": [12], "Bin2": [1], "Ain2": [1], "Bin1": [12]} # Target with states = 0.0 - results_target = {'Dout': [(-2.0 + 1.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0], - 'Bout': [(3.0 + 1.0 + 0.0) * -5.0], - 'Aout': [(1.0 + 0.0) * 3.0]} + results_target = { + "Dout": [(-2.0 + 1.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + "Bout": [(3.0 + 1.0 + 0.0) * -5.0], + "Aout": [(1.0 + 0.0) * 3.0], + } # Target with states = 1.0 - results_target_state = {'Dout': [(-2.0 + 1.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0], - 'Bout': [(6.0 + 1.0 + 1.0) * -5.0], - 'Aout': [(1.0 + 1.0) * 3.0]} + results_target_state = { + "Dout": [(-2.0 + 1.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + "Bout": [(6.0 + 1.0 + 1.0) * -5.0], + "Aout": [(1.0 + 1.0) * 3.0], + } m.neuralizeModel() self.assertEqual(results_target, m(init_inputs)) - self.assertEqual(results_target_state, m(init_inputs|init_states)) - self.assertEqual(results_target_state, m(init_inputs|init_states_diff)) + self.assertEqual(results_target_state, m(init_inputs | init_states)) + self.assertEqual(results_target_state, m(init_inputs | init_states_diff)) ## Test loading of all models m.saveTorchModel() l = Modely(workspace=result_path, visualizer=None) - l.addModel('model1', [modelA, modelB]) - l.addModel('model2', [modelC, modelD]) + l.addModel("model1", [modelA, modelB]) + l.addModel("model2", [modelC, modelD]) l.neuralizeModel() - l.parameters['PA'] = [[22.0]] + l.parameters["PA"] = [[22.0]] l.loadTorchModel() self.assertEqual(results_target, l(init_inputs)) - self.assertEqual(results_target_state, l(init_inputs|init_states)) - self.assertEqual(results_target_state, l(init_inputs|init_states_diff)) + self.assertEqual(results_target_state, l(init_inputs | init_states)) + self.assertEqual(results_target_state, l(init_inputs | init_states_diff)) m.saveModel() l = Modely(workspace=result_path, visualizer=None) l.loadModel() l.neuralizeModel() self.assertEqual(results_target, l(init_inputs)) - self.assertEqual(results_target_state, l(init_inputs|init_states)) - self.assertEqual(results_target_state, l(init_inputs|init_states_diff)) + self.assertEqual(results_target_state, l(init_inputs | init_states)) + self.assertEqual(results_target_state, l(init_inputs | init_states_diff)) m.exportPythonModel() l = Modely(workspace=result_path, visualizer=None) l.importPythonModel() self.assertEqual(results_target, l(init_inputs)) - self.assertEqual(results_target_state, l(init_inputs|init_states)) - self.assertEqual(results_target_state, l(init_inputs|init_states_diff)) - - m.exportONNX(outputs_order=['Dout', 'Cout', 'Bout', 'Aout']) - init_inputs_ox = {'Din1':np.array([[[7.0]]]).astype(np.float32), - 'Bin2':np.array([[[0]]]).astype(np.float32), - 'Ain2':np.array([[[0]]]).astype(np.float32), - 'Bin1':np.array([[[12.0]]]).astype(np.float32)} - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_ox | - {'Din2': np.array([[[[1]]]]).astype(np.float32), - 'Din3': np.array([[[[1]]]]).astype(np.float32), - 'Cin1': np.array([[[[1]]]]).astype(np.float32), - 'Cin2': np.array([[[[1]]]]).astype(np.float32), - 'Ain1':np.array([[[[1]]]]).astype(np.float32), - 'Bin3': np.array([[[[1]]]]).astype(np.float32)}) - self.assertEqual([[[[[0.0]]]], [[[[-2.0]]]], [[[[-20.0]]]], [[[[3.0]]]]], results) + self.assertEqual(results_target_state, l(init_inputs | init_states)) + self.assertEqual(results_target_state, l(init_inputs | init_states_diff)) + + m.exportONNX(outputs_order=["Dout", "Cout", "Bout", "Aout"]) + init_inputs_ox = { + "Din1": np.array([[[7.0]]]).astype(np.float32), + "Bin2": np.array([[[0]]]).astype(np.float32), + "Ain2": np.array([[[0]]]).astype(np.float32), + "Bin1": np.array([[[12.0]]]).astype(np.float32), + } + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_ox + | { + "Din2": np.array([[[[1]]]]).astype(np.float32), + "Din3": np.array([[[[1]]]]).astype(np.float32), + "Cin1": np.array([[[[1]]]]).astype(np.float32), + "Cin2": np.array([[[[1]]]]).astype(np.float32), + "Ain1": np.array([[[[1]]]]).astype(np.float32), + "Bin3": np.array([[[[1]]]]).astype(np.float32), + } + ) + self.assertEqual( + [[[[[0.0]]]], [[[[-2.0]]]], [[[[-20.0]]]], [[[[3.0]]]]], results + ) ## Testing loading of model1 - results_target_m1 = {'Bout': [-20.0], 'Aout': [3.0]} - results_target_state_m1 = {'Bout': [(6.0 + 1.0 + 1.0) * -5.0], - 'Aout': [(1.0 + 1.0) * 3.0]} - m.saveTorchModel(models='model1') + results_target_m1 = {"Bout": [-20.0], "Aout": [3.0]} + results_target_state_m1 = { + "Bout": [(6.0 + 1.0 + 1.0) * -5.0], + "Aout": [(1.0 + 1.0) * 3.0], + } + m.saveTorchModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.addModel('model1', [modelA, modelB]) + l.addModel("model1", [modelA, modelB]) l.neuralizeModel() - l.parameters['PA'] = [[22.0]] - l.loadTorchModel(name='net_model1') + l.parameters["PA"] = [[22.0]] + l.loadTorchModel(name="net_model1") self.assertEqual(results_target_m1, l(init_inputs)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states_diff)) - m.saveModel(models='model1') + m.saveModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.loadModel(name='net_model1') + l.loadModel(name="net_model1") l.neuralizeModel() self.assertEqual(results_target_m1, l(init_inputs)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states_diff)) - m.exportPythonModel(models='model1') + m.exportPythonModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.importPythonModel(name='net_model1') + l.importPythonModel(name="net_model1") self.assertEqual(results_target_m1, l(init_inputs)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states)) self.assertEqual(results_target_state_m1, l(init_inputs | init_states_diff)) - m.exportONNX(models='model1', outputs_order=['Bout', 'Aout']) - init_inputs_m1_ox = {'Bin2':np.array([[[0]]]).astype(np.float32), - 'Ain2':np.array([[[0]]]).astype(np.float32), - 'Bin1':np.array([[[12.0]]]).astype(np.float32)} - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_m1_ox | - {'Ain1':np.array([[[[1]]]]).astype(np.float32), - 'Bin3': np.array([[[[1]]]]).astype(np.float32)}, name='net_model1') + m.exportONNX(models="model1", outputs_order=["Bout", "Aout"]) + init_inputs_m1_ox = { + "Bin2": np.array([[[0]]]).astype(np.float32), + "Ain2": np.array([[[0]]]).astype(np.float32), + "Bin1": np.array([[[12.0]]]).astype(np.float32), + } + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_m1_ox + | { + "Ain1": np.array([[[[1]]]]).astype(np.float32), + "Bin3": np.array([[[[1]]]]).astype(np.float32), + }, + name="net_model1", + ) self.assertEqual([[[[[-20.0]]]], [[[[3.0]]]]], results) ### Add the connect on model2 ### - m.addConnect(Cout,Din2) - m.addClosedLoop(Dout,Cin1) + m.addConnect(Cout, Din2) + m.addClosedLoop(Dout, Cin1) m.neuralizeModel() - init_inputs_2 = {'Din3': [1], 'Cin2': [1], 'Ain1': [1], 'Bin3': [1]} - init_states_2 = {'Din1': [1], 'Cin1': [1], 'Din2': [1], 'Bin2':[1], 'Ain2':[1], 'Bin1': [1]} - init_states_diff_2 = {'Din1': [12], 'Cin1': [1], 'Din2': [30], 'Bin2': [1], 'Ain2': [1], 'Bin1': [12]} + init_inputs_2 = {"Din3": [1], "Cin2": [1], "Ain1": [1], "Bin3": [1]} + init_states_2 = { + "Din1": [1], + "Cin1": [1], + "Din2": [1], + "Bin2": [1], + "Ain2": [1], + "Bin1": [1], + } + init_states_diff_2 = { + "Din1": [12], + "Cin1": [1], + "Din2": [30], + "Bin2": [1], + "Ain2": [1], + "Bin1": [12], + } # Target with states = 0.0 - results_target_2 = {'Dout': [(-1.0 - 1.0 + 1.0) * 2.0], - 'Cout': [(0.0 + 1.0) * -1.0], - 'Bout': [(3.0 + 1.0 + 0.0) * -5.0], - 'Aout': [(1.0 + 0.0) * 3.0]} + results_target_2 = { + "Dout": [(-1.0 - 1.0 + 1.0) * 2.0], + "Cout": [(0.0 + 1.0) * -1.0], + "Bout": [(3.0 + 1.0 + 0.0) * -5.0], + "Aout": [(1.0 + 0.0) * 3.0], + } # Target with states = 1.0 - results_target_state_2 = {'Dout': [(-2.0 - 2.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0], - 'Bout': [(6.0 + 1.0 + 1.0) * -5.0], - 'Aout': [(1.0 + 1.0) * 3.0]} + results_target_state_2 = { + "Dout": [(-2.0 - 2.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + "Bout": [(6.0 + 1.0 + 1.0) * -5.0], + "Aout": [(1.0 + 1.0) * 3.0], + } self.assertEqual(results_target_2, m(init_inputs_2)) - self.assertEqual(results_target_state_2, m(init_inputs_2|init_states_2)) - self.assertEqual(results_target_state_2, m(init_inputs_2|init_states_diff_2)) + self.assertEqual(results_target_state_2, m(init_inputs_2 | init_states_2)) + self.assertEqual(results_target_state_2, m(init_inputs_2 | init_states_diff_2)) ## Test loading of all models m.saveTorchModel() l = Modely(workspace=result_path, visualizer=None) - l.addModel('model1', [modelA, modelB]) - l.addModel('model2', [modelC, modelD]) + l.addModel("model1", [modelA, modelB]) + l.addModel("model2", [modelC, modelD]) l.neuralizeModel() - l.parameters['PD'] = [[22.0]] + l.parameters["PD"] = [[22.0]] l.loadTorchModel() self.assertEqual(results_target, l(init_inputs)) - self.assertEqual(results_target_state, l(init_inputs|init_states)) - self.assertEqual(results_target_state, l(init_inputs|init_states_diff)) + self.assertEqual(results_target_state, l(init_inputs | init_states)) + self.assertEqual(results_target_state, l(init_inputs | init_states_diff)) l2 = Modely(workspace=result_path, visualizer=None) - l2.addModel('model1', [modelA, modelB]) - l2.addModel('model2', [modelC, modelD]) - l2.addConnect(Cout,Din2) - l2.addClosedLoop(Dout,Cin1) + l2.addModel("model1", [modelA, modelB]) + l2.addModel("model2", [modelC, modelD]) + l2.addConnect(Cout, Din2) + l2.addClosedLoop(Dout, Cin1) l2.neuralizeModel() - l.parameters['PA'] = [[22.0]] + l.parameters["PA"] = [[22.0]] l2.loadTorchModel() self.assertEqual(results_target_2, l2(init_inputs_2)) - self.assertEqual(results_target_state_2, l2(init_inputs_2|init_states_2)) - self.assertEqual(results_target_state_2, l2(init_inputs_2|init_states_diff_2)) + self.assertEqual(results_target_state_2, l2(init_inputs_2 | init_states_2)) + self.assertEqual(results_target_state_2, l2(init_inputs_2 | init_states_diff_2)) m.saveModel() l = Modely(workspace=result_path, visualizer=None) l.loadModel() l.neuralizeModel() self.assertEqual(results_target_2, l(init_inputs_2)) - self.assertEqual(results_target_state_2, l(init_inputs_2|init_states_2)) - self.assertEqual(results_target_state_2, l(init_inputs_2|init_states_diff_2)) + self.assertEqual(results_target_state_2, l(init_inputs_2 | init_states_2)) + self.assertEqual(results_target_state_2, l(init_inputs_2 | init_states_diff_2)) m.exportPythonModel() l = Modely(workspace=result_path, visualizer=None) l.importPythonModel() self.assertEqual(results_target_2, l(init_inputs_2)) - self.assertEqual(results_target_state_2, l(init_inputs_2|init_states_2)) - self.assertEqual(results_target_state_2, l(init_inputs_2|init_states_diff_2)) - - m.exportONNX(outputs_order=['Dout', 'Cout', 'Bout', 'Aout']) - init_inputs_2_ox = {'Din3': np.array([[[[1.0]]]]).astype(np.float32), - 'Cin2': np.array([[[[1.0]]]]).astype(np.float32), - 'Ain1': np.array([[[[1.0]]]]).astype(np.float32), - 'Bin3': np.array([[[[1.0]]]]).astype(np.float32)} - init_states_2_ox = {'Din1': np.array([[[12.0]]]).astype(np.float32), - 'Cin1': np.array([[[0.0]]]).astype(np.float32), - 'Din2': np.array([[[20.0]]]).astype(np.float32), - 'Bin2': np.array([[[0.0]]]).astype(np.float32), - 'Ain2': np.array([[[0.0]]]).astype(np.float32), - 'Bin1': np.array([[[34.0]]]).astype(np.float32)} - init_states_diff_2_ox = {'Din1': np.array([[[12.0]]]).astype(np.float32), - 'Cin1': np.array([[[1.0]]]).astype(np.float32), - 'Din2': np.array([[[23.0]]]).astype(np.float32), - 'Bin2': np.array([[[1.0]]]).astype(np.float32), - 'Ain2': np.array([[[1.0]]]).astype(np.float32), - 'Bin1': np.array([[[12.0]]]).astype(np.float32)} - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_2_ox | init_states_2_ox) - self.assertEqual([[[[[-2.0]]]], [[[[-1.0]]]], [[[[-20.0]]]], [[[[3.0]]]]], results) - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_2_ox | init_states_diff_2_ox) - self.assertEqual([[[[[-6.0]]]], [[[[-2.0]]]], [[[[-40.0]]]], [[[[6.0]]]]], results) - + self.assertEqual(results_target_state_2, l(init_inputs_2 | init_states_2)) + self.assertEqual(results_target_state_2, l(init_inputs_2 | init_states_diff_2)) + + m.exportONNX(outputs_order=["Dout", "Cout", "Bout", "Aout"]) + init_inputs_2_ox = { + "Din3": np.array([[[[1.0]]]]).astype(np.float32), + "Cin2": np.array([[[[1.0]]]]).astype(np.float32), + "Ain1": np.array([[[[1.0]]]]).astype(np.float32), + "Bin3": np.array([[[[1.0]]]]).astype(np.float32), + } + init_states_2_ox = { + "Din1": np.array([[[12.0]]]).astype(np.float32), + "Cin1": np.array([[[0.0]]]).astype(np.float32), + "Din2": np.array([[[20.0]]]).astype(np.float32), + "Bin2": np.array([[[0.0]]]).astype(np.float32), + "Ain2": np.array([[[0.0]]]).astype(np.float32), + "Bin1": np.array([[[34.0]]]).astype(np.float32), + } + init_states_diff_2_ox = { + "Din1": np.array([[[12.0]]]).astype(np.float32), + "Cin1": np.array([[[1.0]]]).astype(np.float32), + "Din2": np.array([[[23.0]]]).astype(np.float32), + "Bin2": np.array([[[1.0]]]).astype(np.float32), + "Ain2": np.array([[[1.0]]]).astype(np.float32), + "Bin1": np.array([[[12.0]]]).astype(np.float32), + } + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_2_ox | init_states_2_ox + ) + self.assertEqual( + [[[[[-2.0]]]], [[[[-1.0]]]], [[[[-20.0]]]], [[[[3.0]]]]], results + ) + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_2_ox | init_states_diff_2_ox + ) + self.assertEqual( + [[[[[-6.0]]]], [[[[-2.0]]]], [[[[-40.0]]]], [[[[6.0]]]]], results + ) ## Testing loading of model1 # Target with states = 0.0 - results_target_m2 = {'Dout': [(-2.0 + 1.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0]} - results_target_state_m2 = {'Dout': [(-2.0 + 1.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0]} - results_target_2_m2 = {'Dout': [(-1.0 - 1.0 + 1.0) * 2.0], - 'Cout': [(0.0 + 1.0) * -1.0]} - results_target_state_2_m2 = {'Dout': [(-2.0 - 2.0 + 1.0) * 2.0], - 'Cout': [(1.0 + 1.0) * -1.0]} - m.saveTorchModel(models='model2') + results_target_m2 = { + "Dout": [(-2.0 + 1.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + } + results_target_state_m2 = { + "Dout": [(-2.0 + 1.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + } + results_target_2_m2 = { + "Dout": [(-1.0 - 1.0 + 1.0) * 2.0], + "Cout": [(0.0 + 1.0) * -1.0], + } + results_target_state_2_m2 = { + "Dout": [(-2.0 - 2.0 + 1.0) * 2.0], + "Cout": [(1.0 + 1.0) * -1.0], + } + m.saveTorchModel(models="model2") l = Modely(workspace=result_path, visualizer=None) - l.addModel('model2', [modelC, modelD]) + l.addModel("model2", [modelC, modelD]) l.neuralizeModel() - l.parameters['PD'] = [[22.0]] - l.loadTorchModel(name='net_model2') + l.parameters["PD"] = [[22.0]] + l.loadTorchModel(name="net_model2") self.assertEqual(results_target_m2, l(init_inputs)) self.assertEqual(results_target_state_m2, l(init_inputs | init_states)) self.assertEqual(results_target_state_m2, l(init_inputs | init_states_diff)) l2 = Modely(workspace=result_path, visualizer=None) - l2.addModel('model2', [modelC, modelD]) - l2.addConnect(Cout,Din2) - l2.addClosedLoop(Dout,Cin1) + l2.addModel("model2", [modelC, modelD]) + l2.addConnect(Cout, Din2) + l2.addClosedLoop(Dout, Cin1) l2.neuralizeModel() - l2.parameters['PD'] = [[22.0]] + l2.parameters["PD"] = [[22.0]] with self.assertRaises(FileNotFoundError): - l2.loadTorchModel(name='net_m22',model_folder='test') - l2.loadTorchModel(name='net_model2') + l2.loadTorchModel(name="net_m22", model_folder="test") + l2.loadTorchModel(name="net_model2") self.assertEqual(results_target_2_m2, l2(init_inputs_2)) self.assertEqual(results_target_state_2_m2, l2(init_inputs_2 | init_states_2)) - self.assertEqual(results_target_state_2_m2, l2(init_inputs_2 | init_states_diff_2)) + self.assertEqual( + results_target_state_2_m2, l2(init_inputs_2 | init_states_diff_2) + ) - m.saveModel(models='model2') + m.saveModel(models="model2") l = Modely(workspace=result_path, visualizer=None) with self.assertRaises(FileNotFoundError): - l.loadModel(name='_model2') - l.loadModel(name='net_model2') + l.loadModel(name="_model2") + l.loadModel(name="net_model2") l.neuralizeModel() self.assertEqual(results_target_2_m2, l(init_inputs_2)) self.assertEqual(results_target_state_2_m2, l(init_inputs_2 | init_states_2)) - self.assertEqual(results_target_state_2_m2, l(init_inputs_2 | init_states_diff_2)) + self.assertEqual( + results_target_state_2_m2, l(init_inputs_2 | init_states_diff_2) + ) - m.exportPythonModel(models='model2') + m.exportPythonModel(models="model2") l = Modely(workspace=result_path, visualizer=None) with self.assertRaises(FileNotFoundError): - l.importPythonModel(name='net_model22') - l.importPythonModel(name='net_model2') + l.importPythonModel(name="net_model22") + l.importPythonModel(name="net_model2") self.assertEqual(results_target_2_m2, l(init_inputs_2)) self.assertEqual(results_target_state_2_m2, l(init_inputs_2 | init_states_2)) - self.assertEqual(results_target_state_2_m2, l(init_inputs_2 | init_states_diff_2)) - - m.exportONNX(models='model2', outputs_order=['Cout', 'Dout']) - init_inputs_2_ox = {'Din3': np.array([[[[1.0]]]]).astype(np.float32), - 'Cin2': np.array([[[[1.0]]]]).astype(np.float32)} - init_states_2_ox = {'Din1': np.array([[[12.0]]]).astype(np.float32), - 'Cin1': np.array([[[0.0]]]).astype(np.float32), - 'Din2': np.array([[[20.0]]]).astype(np.float32)} - init_states_diff_2_ox = {'Din1': np.array([[[12.0]]]).astype(np.float32), - 'Cin1': np.array([[[1.0]]]).astype(np.float32), - 'Din2': np.array([[[23.0]]]).astype(np.float32)} + self.assertEqual( + results_target_state_2_m2, l(init_inputs_2 | init_states_diff_2) + ) + + m.exportONNX(models="model2", outputs_order=["Cout", "Dout"]) + init_inputs_2_ox = { + "Din3": np.array([[[[1.0]]]]).astype(np.float32), + "Cin2": np.array([[[[1.0]]]]).astype(np.float32), + } + init_states_2_ox = { + "Din1": np.array([[[12.0]]]).astype(np.float32), + "Cin1": np.array([[[0.0]]]).astype(np.float32), + "Din2": np.array([[[20.0]]]).astype(np.float32), + } + init_states_diff_2_ox = { + "Din1": np.array([[[12.0]]]).astype(np.float32), + "Cin1": np.array([[[1.0]]]).astype(np.float32), + "Din2": np.array([[[23.0]]]).astype(np.float32), + } with self.assertRaises(FileNotFoundError): - Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_2_ox | init_states_2_ox, name='net_models2') - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_2_ox | init_states_2_ox, name='net_model2') + Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_2_ox | init_states_2_ox, name="net_models2" + ) + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_2_ox | init_states_2_ox, name="net_model2" + ) self.assertEqual([[[[[-1.0]]]], [[[[-2.0]]]]], results) - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs_2_ox | init_states_diff_2_ox, name='net_model2') + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs_2_ox | init_states_diff_2_ox, name="net_model2" + ) self.assertEqual([[[[[-2.0]]]], [[[[-6.0]]]]], results) - #log.setAllLevel(logging.CRITICAL) + # log.setAllLevel(logging.CRITICAL) if os.path.exists(m.getWorkspace()): shutil.rmtree(m.getWorkspace()) def test_partial_model_export_intern_extern_connection(self): - result_path = 'results' + result_path = "results" NeuObj.clearNames() - #Network A and B -> Model1 - Ain1 = Input('Ain1') - Bin1 = Input('Bin1') + # Network A and B -> Model1 + Ain1 = Input("Ain1") + Bin1 = Input("Bin1") - pA = Parameter('PA', sw=1, values=[[3.0]]) - pB = Parameter('PB', sw=1, values=[[-5.0]]) + pA = Parameter("PA", sw=1, values=[[3.0]]) + pB = Parameter("PB", sw=1, values=[[-5.0]]) - Aout = (Ain1.last() * pA).sw(1, name='AoutD').s(-1,method='trapezoidal',int_name='int_AoutD',der_name='der_AoutD') - Bout = (Bin1.last() * pB).tw(1, name='BoutD').s(1,method='trapezoidal',int_name='int_BoutD',der_name='der_BoutD') + Aout = ( + (Ain1.last() * pA) + .sw(1, name="AoutD") + .s(-1, method="trapezoidal", int_name="int_AoutD", der_name="der_AoutD") + ) + Bout = ( + (Bin1.last() * pB) + .tw(1, name="BoutD") + .s(1, method="trapezoidal", int_name="int_BoutD", der_name="der_BoutD") + ) - modelA = Output('Aout',Aout) - modelB = Output('Bout',Bout) + modelA = Output("Aout", Aout) + modelB = Output("Bout", Bout) - Cin1 = Input('Cin1') - Din1 = Input('Din1') + Cin1 = Input("Cin1") + Din1 = Input("Din1") - pC = Parameter('PC', tw=1, values=[[-1.0]]) - pD = Parameter('PD', sw=1, values=[[2.0]]) + pC = Parameter("PC", tw=1, values=[[-1.0]]) + pD = Parameter("PD", sw=1, values=[[2.0]]) - Cout = (Cin1.tw(1) * pC).delay(1, name='CoutD') # TODO Change convetion - Dout = (Din1.last() * pD).z(1, name='DoutD') + Cout = (Cin1.tw(1) * pC).delay(1, name="CoutD") # TODO Change convetion + Dout = (Din1.last() * pD).z(1, name="DoutD") - modelC = Output('Cout',Cout) - modelD = Output('Dout',Dout) + modelC = Output("Cout", Cout) + modelD = Output("Dout", Dout) m = Modely(workspace=result_path, visualizer=None) - m.addModel('model1', [modelA, modelB]) - m.addModel('model2', [modelC, modelD]) - m.addConnect(Cout,Bin1) - m.addConnect(Aout,Din1) - m.addClosedLoop(Dout,Ain1) - m.addClosedLoop(Bout,Cin1) - - init_states = {'Ain1': [1,1], 'Bin1':[2,2], 'Cin1':[3,3], 'Din1': [4,4]} - init_states_diff = {'Ain1': [1,1], 'Bin1':[12,20], 'Cin1':[3,3], 'Din1': [12,20]} + m.addModel("model1", [modelA, modelB]) + m.addModel("model2", [modelC, modelD]) + m.addConnect(Cout, Bin1) + m.addConnect(Aout, Din1) + m.addClosedLoop(Dout, Ain1) + m.addClosedLoop(Bout, Cin1) + + init_states = {"Ain1": [1, 1], "Bin1": [2, 2], "Cin1": [3, 3], "Din1": [4, 4]} + init_states_diff = { + "Ain1": [1, 1], + "Bin1": [12, 20], + "Cin1": [3, 3], + "Din1": [12, 20], + } # Target with states = 0.0 - results_target = {'Dout': [0.0, 1.5 * 2.0], - 'Cout': [0.0, 3.0 * -1.0], - 'Bout': [0.0, (-3.0 * -5.0)*2.0], - 'Aout': [(1.0 * 3.0)*0.5, (1.0 * 3.0)+(1.0 * 3.0)*0.5]} + results_target = { + "Dout": [0.0, 1.5 * 2.0], + "Cout": [0.0, 3.0 * -1.0], + "Bout": [0.0, (-3.0 * -5.0) * 2.0], + "Aout": [(1.0 * 3.0) * 0.5, (1.0 * 3.0) + (1.0 * 3.0) * 0.5], + } m.neuralizeModel() self.assertEqual(results_target, m(init_states)) @@ -951,14 +1323,14 @@ def test_partial_model_export_intern_extern_connection(self): # Test loading of all models m.saveTorchModel() l = Modely(workspace=result_path, visualizer=None) - l.addModel('model1', [modelA, modelB]) - l.addModel('model2', [modelC, modelD]) - l.addConnect(Cout,Bin1) - l.addConnect(Aout,Din1) - l.addClosedLoop(Dout,Ain1) - l.addClosedLoop(Bout,Cin1) + l.addModel("model1", [modelA, modelB]) + l.addModel("model2", [modelC, modelD]) + l.addConnect(Cout, Bin1) + l.addConnect(Aout, Din1) + l.addClosedLoop(Dout, Ain1) + l.addClosedLoop(Bout, Cin1) l.neuralizeModel() - l.parameters['PA'] = [[22.0]] + l.parameters["PA"] = [[22.0]] l.loadTorchModel() self.assertEqual(results_target, l(init_states)) l.resetStates() @@ -980,47 +1352,53 @@ def test_partial_model_export_intern_extern_connection(self): self.assertEqual(results_target, l(init_states_diff)) with self.assertRaises(TypeError): - m.exportONNX(outputs_order=['Dout', 'Cout', 'Bout', 'Aout']) + m.exportONNX(outputs_order=["Dout", "Cout", "Bout", "Aout"]) - results_target_m1 = {'Aout': [1.5, 4.5], 'Bout': [-20.0, 20.0]} + results_target_m1 = {"Aout": [1.5, 4.5], "Bout": [-20.0, 20.0]} # Test loading of Model1 - m.saveTorchModel(models='model1') + m.saveTorchModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.addModel('model1', [modelA, modelB]) + l.addModel("model1", [modelA, modelB]) l.neuralizeModel() - l.parameters['PA'] = [[22.0]] - l.loadTorchModel(name='net_model1') + l.parameters["PA"] = [[22.0]] + l.loadTorchModel(name="net_model1") self.assertEqual(results_target_m1, l(init_states)) l.resetStates() self.assertEqual(results_target_m1, l(init_states)) - m.saveModel(models='model1') + m.saveModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.loadModel(name='net_model1') + l.loadModel(name="net_model1") l.neuralizeModel() self.assertEqual(results_target_m1, l(init_states)) l.resetStates() self.assertEqual(results_target_m1, l(init_states)) - m.exportPythonModel(models='model1') + m.exportPythonModel(models="model1") l = Modely(workspace=result_path, visualizer=None) - l.importPythonModel(name='net_model1') + l.importPythonModel(name="net_model1") self.assertEqual(results_target_m1, l(init_states)) l.resetStates() self.assertEqual(results_target_m1, l(init_states)) - m.exportONNX(outputs_order=['Bout', 'Aout'],models='model1') - - init_inputs = {'Ain1': np.array([[[[1.0]]],[[[1.0]]]]).astype(np.float32), - 'Bin1': np.array([[[[2.0]]],[[[2.0]]]]).astype(np.float32)} - init_states = {'AoutD': np.array([[[0.0]]]).astype(np.float32), - 'int_AoutD': np.array([[[0.]]]).astype(np.float32), - 'der_AoutD': np.array([[[0.],[0.]]]).astype(np.float32), - 'BoutD': np.array([[[0.0]]]).astype(np.float32), - 'int_BoutD': np.array([[[0.],[0.]]]).astype(np.float32), - 'der_BoutD': np.array([[[0.]]]).astype(np.float32)} - results = Modely(workspace=result_path, visualizer=None).onnxInference(init_inputs|init_states, name = 'net_model1' ) + m.exportONNX(outputs_order=["Bout", "Aout"], models="model1") + + init_inputs = { + "Ain1": np.array([[[[1.0]]], [[[1.0]]]]).astype(np.float32), + "Bin1": np.array([[[[2.0]]], [[[2.0]]]]).astype(np.float32), + } + init_states = { + "AoutD": np.array([[[0.0]]]).astype(np.float32), + "int_AoutD": np.array([[[0.0]]]).astype(np.float32), + "der_AoutD": np.array([[[0.0], [0.0]]]).astype(np.float32), + "BoutD": np.array([[[0.0]]]).astype(np.float32), + "int_BoutD": np.array([[[0.0], [0.0]]]).astype(np.float32), + "der_BoutD": np.array([[[0.0]]]).astype(np.float32), + } + results = Modely(workspace=result_path, visualizer=None).onnxInference( + init_inputs | init_states, name="net_model1" + ) self.assertEqual([[[-20.0]]], results[0][0]) self.assertEqual([[[20.0]]], results[0][1]) self.assertEqual([[[1.5]]], results[1][0]) @@ -1031,32 +1409,45 @@ def test_partial_model_export_intern_extern_connection(self): def test_export_report_recurrent(self): NeuObj.clearNames() - result_path = 'results' + result_path = "results" test = Modely(visualizer=None, seed=42, workspace=result_path) - x = Input('x') - y = Input('y') - z = Input('z') - target = Input('target') - a = Parameter('a', dimensions=1, sw=1, values=[[1]]) - b = Parameter('b', dimensions=1, sw=1, values=[[1]]) - c = Parameter('c', dimensions=1, sw=1, values=[[1]]) + x = Input("x") + y = Input("y") + z = Input("z") + target = Input("target") + a = Parameter("a", dimensions=1, sw=1, values=[[1]]) + b = Parameter("b", dimensions=1, sw=1, values=[[1]]) + c = Parameter("c", dimensions=1, sw=1, values=[[1]]) fir_x = Fir(W=a)(x.last()) fir_y = Fir(W=b)(y.last()) fir_z = Fir(W=c)(z.last()) - data_x, data_y, data_z = np.random.rand(20), np.random.rand(20), np.random.rand(20) - dataset = {'x': data_x, 'y': data_y, 'z': data_z, 'target': 3 * data_x + 3 * data_y + 3 * data_z} + data_x, data_y, data_z = ( + np.random.rand(20), + np.random.rand(20), + np.random.rand(20), + ) + dataset = { + "x": data_x, + "y": data_y, + "z": data_z, + "target": 3 * data_x + 3 * data_y + 3 * data_z, + } fir_x.connect(y) sum_rel = fir_x + fir_y + fir_z sum_rel.closedLoop(z) - out = Output('out', sum_rel) - test.addModel('model', out) - test.addMinimize('error', target.last(), out) + out = Output("out", sum_rel) + test.addModel("model", out) + test.addMinimize("error", target.last(), out) test.neuralizeModel(0.5) - test.loadData(name='test_dataset', source=dataset) + test.loadData(name="test_dataset", source=dataset) ## Train - test.trainAndAnalyze(optimizer='SGD', training_params={'num_of_epochs': 2, 'lr': 0.0001, 'train_batch_size': 1}, - splits=[100, 0, 0], prediction_samples=10) # Train the traced model + test.trainAndAnalyze( + optimizer="SGD", + training_params={"num_of_epochs": 2, "lr": 0.0001, "train_batch_size": 1}, + splits=[100, 0, 0], + prediction_samples=10, + ) # Train the traced model test.exportReport() if os.path.exists(test.getWorkspace()): - shutil.rmtree(test.getWorkspace()) \ No newline at end of file + shutil.rmtree(test.getWorkspace()) diff --git a/tests/test_input_dimensions.py b/tests/test_input_dimensions.py index 687443ca..5e930a02 100644 --- a/tests/test_input_dimensions.py +++ b/tests/test_input_dimensions.py @@ -1,4 +1,7 @@ -import unittest, sys, os, torch +import unittest +import sys +import os +import torch import numpy as np from nnodely import * @@ -20,61 +23,61 @@ # And finally the dimensions for each relation # relation_samples -class ModelyNetworkBuildingTest(unittest.TestCase): +class ModelyNetworkBuildingTest(unittest.TestCase): def test_network_building_very_simple(self): NeuObj.clearNames() - input1 = Input('in1') + input1 = Input("in1") rel1 = Fir(input1.last()) - fun = Output('out', rel1) + fun = Output("out", rel1) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0,test.input_tw_backward['in1']) - #self.assertEqual(0,test.input_tw_forward['in1']) - self.assertEqual(1,test.json['Inputs']['in1']['ns'][0]) - self.assertEqual(0,test.json['Inputs']['in1']['ns'][1]) - self.assertEqual(1,test.json['Inputs']['in1']['ntot']) + # self.assertEqual(0,test.input_tw_backward['in1']) + # self.assertEqual(0,test.input_tw_forward['in1']) + self.assertEqual(1, test.json["Inputs"]["in1"]["ns"][0]) + self.assertEqual(0, test.json["Inputs"]["in1"]["ns"][1]) + self.assertEqual(1, test.json["Inputs"]["in1"]["ntot"]) - self.assertEqual(1,test.json['Info']['ns'][0]) - self.assertEqual(0,test.json['Info']['ns'][1]) - self.assertEqual(1,test.json['Info']['ntot']) # 5 samples + self.assertEqual(1, test.json["Info"]["ns"][0]) + self.assertEqual(0, test.json["Info"]["ns"][1]) + self.assertEqual(1, test.json["Info"]["ntot"]) # 5 samples def test_network_building_simple(self): NeuObj.clearNames() - input1 = Input('in1') + input1 = Input("in1") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw(0.01)) - fun = Output('out',rel1+rel2) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.05,test.input_tw_backward['in1']) - #self.assertEqual(0,test.input_tw_forward['in1']) - self.assertEqual(5,test.json['Inputs']['in1']['ns'][0]) - self.assertEqual(0,test.json['Inputs']['in1']['ns'][1]) - self.assertEqual(5,test.json['Inputs']['in1']['ntot']) + # self.assertEqual(0.05,test.input_tw_backward['in1']) + # self.assertEqual(0,test.input_tw_forward['in1']) + self.assertEqual(5, test.json["Inputs"]["in1"]["ns"][0]) + self.assertEqual(0, test.json["Inputs"]["in1"]["ns"][1]) + self.assertEqual(5, test.json["Inputs"]["in1"]["ntot"]) - self.assertEqual(5,test.json['Info']['ns'][0]) - self.assertEqual(0,test.json['Info']['ns'][1]) - self.assertEqual(5,test.json['Info']['ntot']) # 5 samples + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(0, test.json["Info"]["ns"][1]) + self.assertEqual(5, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw(self): NeuObj.clearNames() - input1 = Input('in1') - input2 = Input('in2') + input1 = Input("in1") + input2 = Input("in2") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw(0.01)) rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.02,0.02])) - fun = Output('out',rel1+rel2+rel3+rel4) + rel4 = Fir(input2.tw([-0.02, 0.02])) + fun = Output("out", rel1 + rel2 + rel3 + rel4) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) # self.assertEqual({'in1': 0.05, 'in2': 0.05}, test.input_tw_backward) @@ -82,109 +85,122 @@ def test_network_building_tw(self): # self.assertEqual({'in1': 5, 'in2': 5},test.input_ns_backward) # self.assertEqual({'in1': 0, 'in2': 2},test.input_ns_forward) # self.assertEqual({'in1': 5, 'in2': 7},test.input_n_samples) - self.assertEqual([5,0] ,test.json['Inputs']['in1']['ns']) - self.assertEqual([5,2],test.json['Inputs']['in2']['ns']) - self.assertEqual(5,test.json['Inputs']['in1']['ntot']) - self.assertEqual(7,test.json['Inputs']['in2']['ntot']) + self.assertEqual([5, 0], test.json["Inputs"]["in1"]["ns"]) + self.assertEqual([5, 2], test.json["Inputs"]["in2"]["ns"]) + self.assertEqual(5, test.json["Inputs"]["in1"]["ntot"]) + self.assertEqual(7, test.json["Inputs"]["in2"]["ntot"]) - self.assertEqual(5,test.json['Info']['ns'][0]) - self.assertEqual(2,test.json['Info']['ns'][1]) - self.assertEqual(7,test.json['Info']['ntot']) # 5 samples + 2 samples of the horizon + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(2, test.json["Info"]["ns"][1]) + self.assertEqual( + 7, test.json["Info"]["ntot"] + ) # 5 samples + 2 samples of the horizon def test_network_building_tw2(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.02,0.02])) - rel5 = Fir(input2.tw([-0.03,0.03])) + rel4 = Fir(input2.tw([-0.02, 0.02])) + rel5 = Fir(input2.tw([-0.03, 0.03])) rel6 = Fir(input2.tw([-0.03, 0])) rel7 = Fir(input2.tw(0.03)) - fun = Output('out',rel3+rel4+rel5+rel6+rel7) + fun = Output("out", rel3 + rel4 + rel5 + rel6 + rel7) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.05,test.input_tw_backward['in2']) - #self.assertEqual(0.03,test.input_tw_forward['in2']) - self.assertEqual(5,test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(3,test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(8,test.json['Inputs']['in2']['ntot']) # 5 samples + 3 samples of the horizon + # self.assertEqual(0.05,test.input_tw_backward['in2']) + # self.assertEqual(0.03,test.input_tw_forward['in2']) + self.assertEqual(5, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(3, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 8, test.json["Inputs"]["in2"]["ntot"] + ) # 5 samples + 3 samples of the horizon - self.assertEqual(5,test.json['Info']['ns'][0]) - self.assertEqual(3,test.json['Info']['ns'][1]) - self.assertEqual(8,test.json['Info']['ntot']) # 5 samples + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(3, test.json["Info"]["ns"][1]) + self.assertEqual(8, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw3(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.01,0.03])) - rel5 = Fir(input2.tw([-0.04,0.01])) - fun = Output('out',rel3+rel4+rel5) + rel4 = Fir(input2.tw([-0.01, 0.03])) + rel5 = Fir(input2.tw([-0.04, 0.01])) + fun = Output("out", rel3 + rel4 + rel5) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.05, test.input_tw_backward['in2']) - #self.assertEqual(0.03, test.input_tw_forward['in2']) - self.assertEqual(5, test.json['Inputs']['in2']['ns'][0],) - self.assertEqual(3, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(8, test.json['Inputs']['in2']['ntot']) # 5 samples + 3 samples of the horizon - - self.assertEqual(5, test.json['Info']['ns'][0]) - self.assertEqual(3, test.json['Info']['ns'][1]) - self.assertEqual(8, test.json['Info']['ntot']) # 5 samples + # self.assertEqual(0.05, test.input_tw_backward['in2']) + # self.assertEqual(0.03, test.input_tw_forward['in2']) + self.assertEqual( + 5, + test.json["Inputs"]["in2"]["ns"][0], + ) + self.assertEqual(3, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 8, test.json["Inputs"]["in2"]["ntot"] + ) # 5 samples + 3 samples of the horizon + + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(3, test.json["Info"]["ns"][1]) + self.assertEqual(8, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw_with_offest(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.04,0.02])) + rel4 = Fir(input2.tw([-0.04, 0.02])) rel5 = Fir(input2.tw([-0.04, 0.02], offset=-0.04)) rel6 = Fir(input2.tw([-0.04, 0.02], offset=-0.01)) rel7 = Fir(input2.tw([-0.04, 0.02], offset=0.01)) - fun = Output('out',rel3+rel4+rel5+rel6+rel7) + fun = Output("out", rel3 + rel4 + rel5 + rel6 + rel7) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.05, test.input_tw_backward['in2']) - #self.assertEqual(0.02, test.input_tw_forward['in2']) - self.assertEqual(5, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(2, test.json['Inputs']['in2']['ns'][1] ) - self.assertEqual(7, test.json['Inputs']['in2']['ntot']) # 5 samples + 2 samples of the horizon + # self.assertEqual(0.05, test.input_tw_backward['in2']) + # self.assertEqual(0.02, test.input_tw_forward['in2']) + self.assertEqual(5, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(2, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 7, test.json["Inputs"]["in2"]["ntot"] + ) # 5 samples + 2 samples of the horizon - self.assertEqual(5, test.json['Info']['ns'][0]) - self.assertEqual(2, test.json['Info']['ns'][1]) - self.assertEqual(7,test.json['Info']['ntot']) # 5 samples + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(2, test.json["Info"]["ns"][1]) + self.assertEqual(7, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw_negative(self): NeuObj.clearNames() - input2 = Input('in2') - rel1 = Fir(input2.tw([-0.05,-0.01])) - rel2 = Fir(input2.tw([-0.06,-0.03])) - fun = Output('out',rel1+rel2) + input2 = Input("in2") + rel1 = Fir(input2.tw([-0.05, -0.01])) + rel2 = Fir(input2.tw([-0.06, -0.03])) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.06,test.input_tw_backward['in2']) - #self.assertEqual( -0.01, test.input_tw_forward['in2']) - self.assertEqual(6, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(-1, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(5, test.json['Inputs']['in2']['ntot']) # 6 samples - 1 samples of the horizon + # self.assertEqual(0.06,test.input_tw_backward['in2']) + # self.assertEqual( -0.01, test.input_tw_forward['in2']) + self.assertEqual(6, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(-1, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 5, test.json["Inputs"]["in2"]["ntot"] + ) # 6 samples - 1 samples of the horizon - self.assertEqual(6, test.json['Info']['ns'][0]) - self.assertEqual(-1, test.json['Info']['ns'][1]) - self.assertEqual(5, test.json['Info']['ntot']) # 5 samples + self.assertEqual(6, test.json["Info"]["ns"][0]) + self.assertEqual(-1, test.json["Info"]["ns"][1]) + self.assertEqual(5, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw_negative_with_offset(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel1 = Fir(input2.tw([-0.05, -0.01], offset=-0.05)) rel2 = Fir(input2.tw([-0.02, -0.01], offset=-0.02)) rel3 = Fir(input2.tw([-0.06, -0.03], offset=-0.06)) @@ -195,55 +211,59 @@ def test_network_building_tw_negative_with_offset(self): input2.tw([-0.06, -0.03], offset=-0.07) with self.assertRaises(IndexError): input2.tw([-0.06, -0.01], offset=-0.01) - fun = Output('out', rel1 + rel2 + rel3 + rel4) + fun = Output("out", rel1 + rel2 + rel3 + rel4) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.06,test.input_tw_backward['in2']) - #self.assertEqual( -0.01, test.input_tw_forward['in2']) - self.assertEqual(6, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(-1, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(5, test.json['Inputs']['in2']['ntot']) # 6 samples - 1 samples of the horizon + # self.assertEqual(0.06,test.input_tw_backward['in2']) + # self.assertEqual( -0.01, test.input_tw_forward['in2']) + self.assertEqual(6, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(-1, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 5, test.json["Inputs"]["in2"]["ntot"] + ) # 6 samples - 1 samples of the horizon - self.assertEqual(6, test.json['Info']['ns'][0]) - self.assertEqual(-1, test.json['Info']['ns'][1]) - self.assertEqual(5, test.json['Info']['ntot']) # 5 samples + self.assertEqual(6, test.json["Info"]["ns"][0]) + self.assertEqual(-1, test.json["Info"]["ns"][1]) + self.assertEqual(5, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw_positive(self): NeuObj.clearNames() - input1 = Input('in1') - rel = Fir(input1.tw([0.03,0.04])) - fun = Output('out1', rel) + input1 = Input("in1") + rel = Fir(input1.tw([0.03, 0.04])) + fun = Output("out1", rel) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - input2 = Input('in2') - rel1 = Fir(input2.tw([0.01,0.04])) - rel2 = Fir(input2.tw([0.03,0.07])) - fun = Output('out2',rel1+rel2) + input2 = Input("in2") + rel1 = Fir(input2.tw([0.01, 0.04])) + rel2 = Fir(input2.tw([0.03, 0.07])) + fun = Output("out2", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(-0.01, test.input_tw_backward['in2']) - #self.assertEqual(0.07, test.input_tw_forward['in2']) - self.assertEqual(-1, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(7, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(6, test.json['Inputs']['in2']['ntot']) # -1 samples + 6 samples of the horizon + # self.assertEqual(-0.01, test.input_tw_backward['in2']) + # self.assertEqual(0.07, test.input_tw_forward['in2']) + self.assertEqual(-1, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(7, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 6, test.json["Inputs"]["in2"]["ntot"] + ) # -1 samples + 6 samples of the horizon - self.assertEqual(-1, test.json['Info']['ns'][0]) - self.assertEqual(7, test.json['Info']['ns'][1]) - self.assertEqual(6, test.json['Info']['ntot']) # 5 samples + self.assertEqual(-1, test.json["Info"]["ns"][0]) + self.assertEqual(7, test.json["Info"]["ns"][1]) + self.assertEqual(6, test.json["Info"]["ntot"]) # 5 samples def test_network_building_tw_positive_with_offset(self): NeuObj.clearNames() - input2 = Input('in2') - rel1 = Fir(input2.tw([0.01,0.04],offset=0.02)) - rel2 = Fir(input2.tw([0.03,0.07],offset=0.04)) + input2 = Input("in2") + rel1 = Fir(input2.tw([0.01, 0.04], offset=0.02)) + rel2 = Fir(input2.tw([0.03, 0.07], offset=0.04)) with self.assertRaises(ValueError): input2.tw([0.03, 0.02]) with self.assertRaises(IndexError): @@ -251,116 +271,120 @@ def test_network_building_tw_positive_with_offset(self): with self.assertRaises(IndexError): input2.tw([0.03, 0.07], offset=0) - fun = Output('out', rel1 + rel2) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(-0.01,test.input_tw_backward['in2']) - #self.assertEqual( 0.07, test.input_tw_forward['in2']) - self.assertEqual(-1, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(7, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(6, test.json['Inputs']['in2']['ntot']) # 6 samples - 1 samples of the horizon + # self.assertEqual(-0.01,test.input_tw_backward['in2']) + # self.assertEqual( 0.07, test.input_tw_forward['in2']) + self.assertEqual(-1, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(7, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual( + 6, test.json["Inputs"]["in2"]["ntot"] + ) # 6 samples - 1 samples of the horizon - self.assertEqual(-1, test.json['Info']['ns'][0]) - self.assertEqual(7, test.json['Info']['ns'][1]) - self.assertEqual(6, test.json['Info']['ntot']) # 5 samples + self.assertEqual(-1, test.json["Info"]["ns"][0]) + self.assertEqual(7, test.json["Info"]["ns"][1]) + self.assertEqual(6, test.json["Info"]["ntot"]) # 5 samples def test_network_building_sw(self): NeuObj.clearNames() - input1 = Input('in1') + input1 = Input("in1") rel3 = Fir(input1.sw(2)) - rel4 = Fir(input1.sw([-2,2])) - rel5 = Fir(input1.sw([-3,3])) + rel4 = Fir(input1.sw([-2, 2])) + rel5 = Fir(input1.sw([-3, 3])) rel6 = Fir(input1.sw([-3, 0])) rel7 = Fir(input1.sw(3)) - fun = Output('out',rel3+rel4+rel5+rel6+rel7) + fun = Output("out", rel3 + rel4 + rel5 + rel6 + rel7) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0,test.input_tw_backward['in1']) - #self.assertEqual(0,test.input_tw_forward['in1']) - self.assertEqual(3,test.json['Inputs']['in1']['ns'][0]) - self.assertEqual(3,test.json['Inputs']['in1']['ns'][1]) - self.assertEqual(6,test.json['Inputs']['in1']['ntot']) # 6 samples - 1 samples of the horizon + # self.assertEqual(0,test.input_tw_backward['in1']) + # self.assertEqual(0,test.input_tw_forward['in1']) + self.assertEqual(3, test.json["Inputs"]["in1"]["ns"][0]) + self.assertEqual(3, test.json["Inputs"]["in1"]["ns"][1]) + self.assertEqual( + 6, test.json["Inputs"]["in1"]["ntot"] + ) # 6 samples - 1 samples of the horizon - self.assertEqual(3,test.json['Info']['ns'][0]) - self.assertEqual(3,test.json['Info']['ns'][1]) - self.assertEqual(6,test.json['Info']['ntot']) # 5 samples + self.assertEqual(3, test.json["Info"]["ns"][0]) + self.assertEqual(3, test.json["Info"]["ns"][1]) + self.assertEqual(6, test.json["Info"]["ntot"]) # 5 samples def test_network_building_sw_with_offset(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.sw(5)) - rel4 = Fir(input2.sw([-4,2])) + rel4 = Fir(input2.sw([-4, 2])) rel5 = Fir(input2.sw([-4, 2], offset=0)) rel6 = Fir(input2.sw([-4, 2], offset=1)) rel7 = Fir(input2.sw([-2, 2], offset=1)) rel8 = Fir(input2.sw([-4, 2], offset=-3)) - fun = Output('out',rel3+rel4+rel5+rel6+rel7+rel8) + fun = Output("out", rel3 + rel4 + rel5 + rel6 + rel7 + rel8) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0, test.input_tw_backward['in2']) - #self.assertEqual(0, test.input_tw_forward['in2']) - self.assertEqual(5, test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(2, test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(7, test.json['Inputs']['in2']['ntot']) + # self.assertEqual(0, test.input_tw_backward['in2']) + # self.assertEqual(0, test.input_tw_forward['in2']) + self.assertEqual(5, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(2, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual(7, test.json["Inputs"]["in2"]["ntot"]) - self.assertEqual(5, test.json['Info']['ns'][0]) - self.assertEqual(2, test.json['Info']['ns'][1]) - self.assertEqual(7, test.json['Info']['ntot']) + self.assertEqual(5, test.json["Info"]["ns"][0]) + self.assertEqual(2, test.json["Info"]["ns"][1]) + self.assertEqual(7, test.json["Info"]["ntot"]) def test_network_building_sw_and_tw(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") with self.assertRaises(TypeError): - input2.sw(5)+input2.tw(0.05) + input2.sw(5) + input2.tw(0.05) - rel1 = Fir(input2.sw([-4,2]))+Fir(input2.tw([-0.01,0])) - fun = Output('out',rel1) + rel1 = Fir(input2.sw([-4, 2])) + Fir(input2.tw([-0.01, 0])) + fun = Output("out", rel1) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - #self.assertEqual(0.01,test.input_tw_backward['in2']) - #self.assertEqual(0,test.input_tw_forward['in2']) - self.assertEqual(4,test.json['Inputs']['in2']['ns'][0]) - self.assertEqual(2,test.json['Inputs']['in2']['ns'][1]) - self.assertEqual(6,test.json['Inputs']['in2']['ntot']) + # self.assertEqual(0.01,test.input_tw_backward['in2']) + # self.assertEqual(0,test.input_tw_forward['in2']) + self.assertEqual(4, test.json["Inputs"]["in2"]["ns"][0]) + self.assertEqual(2, test.json["Inputs"]["in2"]["ns"][1]) + self.assertEqual(6, test.json["Inputs"]["in2"]["ntot"]) - self.assertEqual(4,test.json['Info']['ns'][0]) - self.assertEqual(2,test.json['Info']['ns'][1]) - self.assertEqual(6,test.json['Info']['ntot']) + self.assertEqual(4, test.json["Info"]["ns"][0]) + self.assertEqual(2, test.json["Info"]["ns"][1]) + self.assertEqual(6, test.json["Info"]["ntot"]) def test_example_parametric_different_dim_input(self): NeuObj.clearNames() test = Modely(visualizer=None, seed=42) - x = Input('x') - y = Input('y') - z = Input('z') + x = Input("x") + y = Input("y") + z = Input("z") ## create the relations def myFun(K1, p1, p2): return K1 * p1 * p2 - K_x = Parameter('k_x', dimensions=1, tw=1) - K_y = Parameter('k_y', dimensions=1, tw=1) - w = Parameter('w', dimensions=1, tw=1) - t = Parameter('t', dimensions=1, tw=1) - c_v = Constant('c_v', tw=1, values=[[1], [2]]) + K_x = Parameter("k_x", dimensions=1, tw=1) + K_y = Parameter("k_y", dimensions=1, tw=1) + w = Parameter("w", dimensions=1, tw=1) + t = Parameter("t", dimensions=1, tw=1) + c_v = Constant("c_v", tw=1, values=[[1], [2]]) c = 5 - w_5 = Parameter('w_5', dimensions=1, tw=5) - t_5 = Parameter('t_5', dimensions=1, tw=5) + w_5 = Parameter("w_5", dimensions=1, tw=5) + t_5 = Parameter("t_5", dimensions=1, tw=5) c_5 = [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] - c_5_2 = Constant('c_5_2', tw=5, values=c_5) - parfun_x = ParamFun(myFun, parameters_and_constants=[K_x,c_v]) + c_5_2 = Constant("c_5_2", tw=5, values=c_5) + parfun_x = ParamFun(myFun, parameters_and_constants=[K_x, c_v]) parfun_y = ParamFun(myFun, parameters_and_constants=[K_y]) parfun_z = ParamFun(myFun) fir_w = Fir(W=w_5)(x.tw(5)) @@ -373,34 +397,37 @@ def fuzzyfun(x): fuzzy = Fuzzify(output_dimension=4, range=[0, 4], functions=fuzzyfun)(x.tw(1)) - out = Output('out', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v))) - out2 = Output('out2', Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) - out3 = Output('out3', Add(fir_w, fir_t)) - out4 = Output('out4', Linear(output_dimension=1)(fuzzy)) - out5 = Output('out5', Fir(time_part) + Fir(sample_select)) - out6 = Output('out6', LocalModel(output_function=Fir())(x.tw(1), fuzzy)) + out = Output("out", Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v))) + out2 = Output("out2", Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) + out3 = Output("out3", Add(fir_w, fir_t)) + out4 = Output("out4", Linear(output_dimension=1)(fuzzy)) + out5 = Output("out5", Fir(time_part) + Fir(sample_select)) + out6 = Output("out6", LocalModel(output_function=Fir())(x.tw(1), fuzzy)) with self.assertRaises(TypeError): parfun_z(x.tw(5), t_5, c_5) - out7 = Output('out7', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + Fir(parfun_z(x.tw(5), t_5, c_5_2))) + out7 = Output( + "out7", + Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + + Fir(parfun_z(x.tw(5), t_5, c_5_2)), + ) # parfun = ParamFun(myFun, map_over_batch=True) # p = Constant('co', values=[[2]]) # with self.assertRaises(TypeError): # Output('out-12', parfun(p, x.sw(4))) - - test.addModel('modelA', out) - test.addModel('modelB', [out2, out3, out4]) - test.addModel('modelC', [out4, out5, out6]) - test.addModel('modelD', [out7]) - test.addMinimize('error1', x.last(), out) - test.addMinimize('error2', y.last(), out3, loss_function='rmse') - test.addMinimize('error3', z.last(), out6, loss_function='rmse') + test.addModel("modelA", out) + test.addModel("modelB", [out2, out3, out4]) + test.addModel("modelC", [out4, out5, out6]) + test.addModel("modelD", [out7]) + test.addMinimize("error1", x.last(), out) + test.addMinimize("error2", y.last(), out3, loss_function="rmse") + test.addMinimize("error3", z.last(), out6, loss_function="rmse") test.neuralizeModel(0.5) - self.assertEqual([10,0],test.json['Inputs']['x']['ns']) - self.assertEqual([10,0],test.json['Inputs']['y']['ns']) - self.assertEqual([1,0],test.json['Inputs']['z']['ns']) + self.assertEqual([10, 0], test.json["Inputs"]["x"]["ns"]) + self.assertEqual([10, 0], test.json["Inputs"]["y"]["ns"]) + self.assertEqual([1, 0], test.json["Inputs"]["z"]["ns"]) # # self.assertEqual(4,test.json['Info']['ns'][0]) # self.assertEqual(2,test.json['Info']['ns'][1]) @@ -409,30 +436,51 @@ def fuzzyfun(x): def test_batch_size_and_step(self): NeuObj.clearNames() test = Modely(visualizer=None, seed=42, log_internal=True) - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") rel_out = Fir(x.last()) + Fir(y.last()) rel_out.closedLoop(y) - out = Output('out', rel_out) + out = Output("out", rel_out) - test.addModel('modelA', out) - test.addMinimize('error1', out, x.next()) + test.addModel("modelA", out) + test.addMinimize("error1", out, x.next()) test.neuralizeModel() data_x = np.random.rand(101, 1) data_y = np.random.rand(101, 1) - dataset = {'x': data_x, 'y': data_y} - test.loadData(name='dataset', source=dataset) + dataset = {"x": data_x, "y": data_y} + test.loadData(name="dataset", source=dataset) ## 100 // (step+batch) = 2 - test.trainModel(train_dataset='dataset', num_of_epochs=1, train_batch_size=10, step=30, prediction_samples=20, shuffle_data=False) + test.trainModel( + train_dataset="dataset", + num_of_epochs=1, + train_batch_size=10, + step=30, + prediction_samples=20, + shuffle_data=False, + ) self.assertEqual(2 * 21, len(test.internals.keys())) ## Clip the step to the maximum number of samples (100 - prediction_samples - batch) = 70 - test.trainModel(train_dataset='dataset', num_of_epochs=1, train_batch_size=10, step=200, prediction_samples=20, shuffle_data=True) + test.trainModel( + train_dataset="dataset", + num_of_epochs=1, + train_batch_size=10, + step=200, + prediction_samples=20, + shuffle_data=True, + ) self.assertEqual(1 * 21, len(test.internals.keys())) - ## Clip the step to 0 - test.trainModel(train_dataset='dataset', num_of_epochs=1, train_batch_size=10, step=-4, prediction_samples=20, shuffle_data=True) + ## Clip the step to 0 + test.trainModel( + train_dataset="dataset", + num_of_epochs=1, + train_batch_size=10, + step=-4, + prediction_samples=20, + shuffle_data=True, + ) self.assertEqual(8 * 21, len(test.internals.keys())) diff --git a/tests/test_json.py b/tests/test_json.py index 689107ee..0c6b2107 100644 --- a/tests/test_json.py +++ b/tests/test_json.py @@ -1,4 +1,7 @@ -import sys, os, unittest, copy +import sys +import os +import unittest +import copy import numpy as np @@ -17,685 +20,1004 @@ # the dimensions that are propagated through the relations # and the structure of the json itself -def myFun(K1,K2,p1,p2): + +def myFun(K1, K2, p1, p2): import torch - return p1*K1+p2*torch.sin(K2) -def myFun_out5(K1,p1): + return p1 * K1 + p2 * torch.sin(K2) + + +def myFun_out5(K1, p1): import torch - return torch.stack([K1,K1,K1,K1,K1],dim=2).squeeze(-1)*p1 + + return torch.stack([K1, K1, K1, K1, K1], dim=2).squeeze(-1) * p1 + def myFunPar(x, p1): import torch + if len(p1.shape) == 0: out = torch.tensor([[[1]]]).repeat((x.shape[0], 1, 1)) else: - out = torch.tensor([[p1.shape]]).repeat((x.shape[0],1,1)) + out = torch.tensor([[p1.shape]]).repeat((x.shape[0], 1, 1)) return out + NeuObj.count = 0 + class ModelyJsonTest(unittest.TestCase): def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: - self.assertEqual(len(data1),len(data2)) + self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.TestAlmostEqual(pred, label, precision=precision) else: self.assertAlmostEqual(data1, data2, places=precision) def test_input(self): - input = Input('in1') - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in1': {'dim': 1}}, 'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {}},input.json) - - #Discrete input removed - #input = Input('in', values=[2,3,4]) - #self.assertEqual({'Inputs': {'in': {'dim': 1, 'discrete': [2,3,4], 'tw': [0,0], 'sw': [0, 0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {}},input.json) + input = Input("in1") + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in1": {"dim": 1}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": {}, + }, + input.json, + ) + + # Discrete input removed + # input = Input('in', values=[2,3,4]) + # self.assertEqual({'Inputs': {'in': {'dim': 1, 'discrete': [2,3,4], 'tw': [0,0], 'sw': [0, 0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {}},input.json) def test_aritmetic(self): Stream.resetCount() NeuObj.clearNames() - input = Input('in1') + input = Input("in1") inlast = input.last() - out = inlast+inlast - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in1': {'dim': 1, 'sw': [-1, 0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {'Add2': ['Add', ['SamplePart1', 'SamplePart1']], - 'SamplePart1': ['SamplePart', ['in1'], -1, [-1, 0]]}},out.json) + out = inlast + inlast + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in1": {"dim": 1, "sw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add2": ["Add", ["SamplePart1", "SamplePart1"]], + "SamplePart1": ["SamplePart", ["in1"], -1, [-1, 0]], + }, + }, + out.json, + ) out = input.tw(1) + input.tw(1) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in1': {'dim': 1, 'tw': [-1,0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {'Add7': ['Add', ['TimePart4', 'TimePart6']], - 'TimePart4': ['TimePart', ['in1'], -1, [-1, 0]], - 'TimePart6': ['TimePart', ['in1'], -1, [-1, 0]]}},out.json) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in1": {"dim": 1, "tw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add7": ["Add", ["TimePart4", "TimePart6"]], + "TimePart4": ["TimePart", ["in1"], -1, [-1, 0]], + "TimePart6": ["TimePart", ["in1"], -1, [-1, 0]], + }, + }, + out.json, + ) out = input.tw(1) * input.tw(1) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in1': {'dim': 1, 'tw': [-1,0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {'Mul12': ['Mul', ['TimePart9', 'TimePart11']], - 'TimePart9': ['TimePart', ['in1'], -1, [-1, 0]], - 'TimePart11': ['TimePart', ['in1'], -1, [-1, 0]]}},out.json) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in1": {"dim": 1, "tw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Mul12": ["Mul", ["TimePart9", "TimePart11"]], + "TimePart9": ["TimePart", ["in1"], -1, [-1, 0]], + "TimePart11": ["TimePart", ["in1"], -1, [-1, 0]], + }, + }, + out.json, + ) out = input.tw(1) - input.tw(1) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in1': {'dim': 1, 'tw': [-1,0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {'Sub17': ['Sub', ['TimePart14', 'TimePart16']], - 'TimePart14': ['TimePart', ['in1'], -1, [-1, 0]], - 'TimePart16': ['TimePart', ['in1'], -1, [-1, 0]]}},out.json) - input = Input('in2', dimensions = 5) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in1": {"dim": 1, "tw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Sub17": ["Sub", ["TimePart14", "TimePart16"]], + "TimePart14": ["TimePart", ["in1"], -1, [-1, 0]], + "TimePart16": ["TimePart", ["in1"], -1, [-1, 0]], + }, + }, + out.json, + ) + input = Input("in2", dimensions=5) inlast = input.last() out = inlast + inlast - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in2': {'dim': 5, 'sw': [-1, 0]}},'Functions' : {}, 'Parameters' : {}, 'Outputs': {}, 'Relations': {'Add20': ['Add', ['SamplePart19', 'SamplePart19']], - 'SamplePart19': ['SamplePart', ['in2'], -1, [-1, 0]]}},out.json) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in2": {"dim": 5, "sw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add20": ["Add", ["SamplePart19", "SamplePart19"]], + "SamplePart19": ["SamplePart", ["in2"], -1, [-1, 0]], + }, + }, + out.json, + ) out = input.tw(1) + input.tw(1) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in2': {'dim': 5, 'tw': [-1, 0]}}, 'Functions': {}, 'Parameters': {},'Outputs': {}, 'Relations': {'Add25': ['Add', ['TimePart22', 'TimePart24']], - 'TimePart22': ['TimePart', ['in2'], -1, [-1, 0]], - 'TimePart24': ['TimePart', ['in2'], -1, [-1, 0]]}}, out.json) - out = input.tw([2,5]) + input.tw([3,6]) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in2': {'dim': 5, 'tw': [2, 6]}}, 'Functions': {}, 'Parameters': {},'Outputs': {}, 'Relations': {'Add30': ['Add', ['TimePart27', 'TimePart29']], - 'TimePart27': ['TimePart', ['in2'], -1, [2, 5]], - 'TimePart29': ['TimePart', ['in2'], -1, [3, 6]]}}, out.json) - out = input.tw([-5,-2]) + input.tw([-6,-3]) - self.assertEqual({'Info':{},'Constants': {},'Inputs': {'in2': {'dim': 5, 'tw': [-6, -2]}}, 'Functions': {}, 'Parameters': {},'Outputs': {}, 'Relations': {'Add35': ['Add', ['TimePart32', 'TimePart34']], - 'TimePart32': ['TimePart', ['in2'], -1, [-5, -2]], - 'TimePart34': ['TimePart', ['in2'], -1, [-6, -3]]}}, out.json) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in2": {"dim": 5, "tw": [-1, 0]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add25": ["Add", ["TimePart22", "TimePart24"]], + "TimePart22": ["TimePart", ["in2"], -1, [-1, 0]], + "TimePart24": ["TimePart", ["in2"], -1, [-1, 0]], + }, + }, + out.json, + ) + out = input.tw([2, 5]) + input.tw([3, 6]) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in2": {"dim": 5, "tw": [2, 6]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add30": ["Add", ["TimePart27", "TimePart29"]], + "TimePart27": ["TimePart", ["in2"], -1, [2, 5]], + "TimePart29": ["TimePart", ["in2"], -1, [3, 6]], + }, + }, + out.json, + ) + out = input.tw([-5, -2]) + input.tw([-6, -3]) + self.assertEqual( + { + "Info": {}, + "Constants": {}, + "Inputs": {"in2": {"dim": 5, "tw": [-6, -2]}}, + "Functions": {}, + "Parameters": {}, + "Outputs": {}, + "Relations": { + "Add35": ["Add", ["TimePart32", "TimePart34"]], + "TimePart32": ["TimePart", ["in2"], -1, [-5, -2]], + "TimePart34": ["TimePart", ["in2"], -1, [-6, -3]], + }, + }, + out.json, + ) def test_scalar_input_dimensions(self): NeuObj.clearNames() - input = Input('in1').last() - out = input+input - self.assertEqual({'dim': 1,'sw': 1}, out.dim) + input = Input("in1").last() + out = input + input + self.assertEqual({"dim": 1, "sw": 1}, out.dim) out = Fir(input) - self.assertEqual({'dim': 1,'sw': 1}, out.dim) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) out = Fir(7)(input) - self.assertEqual({'dim': 7,'sw': 1}, out.dim) - out = Fuzzify(5, [-1,1])(input) - self.assertEqual({'dim': 5,'sw': 1}, out.dim) + self.assertEqual({"dim": 7, "sw": 1}, out.dim) + out = Fuzzify(5, [-1, 1])(input) + self.assertEqual({"dim": 5, "sw": 1}, out.dim) out = ParamFun(myFun)(input) - self.assertEqual({'dim': 1,'sw': 1}, out.dim) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) out = ParamFun(myFun_out5)(input) - self.assertEqual({'dim': 5, 'sw': 1}, out.dim) + self.assertEqual({"dim": 5, "sw": 1}, out.dim) with self.assertRaises(ValueError): out = Fir(Fir(7)(input)) # with self.assertRaises(IndexError): - out = Part(input,0,4) + out = Part(input, 0, 4) inpart = ParamFun(myFun_out5)(input) - out = Part(inpart,0,4) - self.assertEqual({'dim': 4, 'sw': 1}, out.dim) - out = Part(inpart,0,1) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) - out = Part(inpart,1,3) - self.assertEqual({'dim': 2, 'sw': 1}, out.dim) - out = Select(inpart,0) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) + out = Part(inpart, 0, 4) + self.assertEqual({"dim": 4, "sw": 1}, out.dim) + out = Part(inpart, 0, 1) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) + out = Part(inpart, 1, 3) + self.assertEqual({"dim": 2, "sw": 1}, out.dim) + out = Select(inpart, 0) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) with self.assertRaises(IndexError): - out = Select(inpart,5) + out = Select(inpart, 5) with self.assertRaises(IndexError): - out = Select(inpart,-1) + out = Select(inpart, -1) with self.assertRaises(KeyError): - out = TimePart(inpart,-1,0) + out = TimePart(inpart, -1, 0) def test_scalar_input_tw_dimensions(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") out = input.tw(1) + input.tw(1) - self.assertEqual({'dim': 1, 'tw': 1}, out.dim) + self.assertEqual({"dim": 1, "tw": 1}, out.dim) out = Fir(input.tw(1)) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) out = Fir(5)(input.tw(1)) - self.assertEqual({'dim': 5, 'sw': 1}, out.dim) - out = Fuzzify(5, [0,5])(input.tw(2)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) - out = Fuzzify(5,range=[-1,5])(input.tw(2)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) - out = Fuzzify(centers=[-1,5])(input.tw(2)) - self.assertEqual({'dim': 2, 'tw': 2}, out.dim) + self.assertEqual({"dim": 5, "sw": 1}, out.dim) + out = Fuzzify(5, [0, 5])(input.tw(2)) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) + out = Fuzzify(5, range=[-1, 5])(input.tw(2)) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) + out = Fuzzify(centers=[-1, 5])(input.tw(2)) + self.assertEqual({"dim": 2, "tw": 2}, out.dim) out = ParamFun(myFun)(input.tw(1)) - self.assertEqual({'dim': 1, 'tw' : 1}, out.dim) + self.assertEqual({"dim": 1, "tw": 1}, out.dim) out = ParamFun(myFun_out5)(input.tw(2)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) - out = ParamFun(myFun_out5)(input.tw(2),input.tw(1)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) + out = ParamFun(myFun_out5)(input.tw(2), input.tw(1)) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) inpart = ParamFun(myFun_out5)(input.tw(2)) - out = Part(inpart,0,4) - self.assertEqual({'dim': 4,'tw': 2}, out.dim) - out = Part(inpart,0,1) - self.assertEqual({'dim': 1,'tw': 2}, out.dim) - out = Part(inpart,1,3) - self.assertEqual({'dim': 2,'tw': 2}, out.dim) - out = Select(inpart,0) - self.assertEqual({'dim': 1,'tw': 2}, out.dim) + out = Part(inpart, 0, 4) + self.assertEqual({"dim": 4, "tw": 2}, out.dim) + out = Part(inpart, 0, 1) + self.assertEqual({"dim": 1, "tw": 2}, out.dim) + out = Part(inpart, 1, 3) + self.assertEqual({"dim": 2, "tw": 2}, out.dim) + out = Select(inpart, 0) + self.assertEqual({"dim": 1, "tw": 2}, out.dim) with self.assertRaises(IndexError): - out = Select(inpart,5) + out = Select(inpart, 5) with self.assertRaises(IndexError): - out = Select(inpart,-1) - out = TimePart(inpart, 0,1) - self.assertEqual({'dim': 5, 'tw': 1}, out.dim) - #out = TimeSelect(inpart,0) - #self.assertEqual({'dim': 5}, out.dim) - #with self.assertRaises(ValueError): + out = Select(inpart, -1) + out = TimePart(inpart, 0, 1) + self.assertEqual({"dim": 5, "tw": 1}, out.dim) + # out = TimeSelect(inpart,0) + # self.assertEqual({'dim': 5}, out.dim) + # with self.assertRaises(ValueError): # out = TimeSelect(inpart,-3) - twinput = input.tw([-2,4]) + twinput = input.tw([-2, 4]) out = TimePart(twinput, 0, 1) - self.assertEqual({'dim': 1, 'tw': 1}, out.dim) + self.assertEqual({"dim": 1, "tw": 1}, out.dim) def test_scalar_input_tw2_dimensions(self): NeuObj.clearNames() - input = Input('in1') - out = input.tw([-1,1])+input.tw([-2,0]) - self.assertEqual({'dim': 1, 'tw': 2}, out.dim) - out = input.tw(1)+input.tw([-1,0]) - self.assertEqual({'dim': 1, 'tw': 1}, out.dim) + input = Input("in1") + out = input.tw([-1, 1]) + input.tw([-2, 0]) + self.assertEqual({"dim": 1, "tw": 2}, out.dim) + out = input.tw(1) + input.tw([-1, 0]) + self.assertEqual({"dim": 1, "tw": 1}, out.dim) out = Fir(input.tw(1) + input.tw([-1, 0])) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) - out = input.tw([-1,0])+input.tw([-4,-3])+input.tw(1) - self.assertEqual({'dim': 1,'tw': 1}, out.dim) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) + out = input.tw([-1, 0]) + input.tw([-4, -3]) + input.tw(1) + self.assertEqual({"dim": 1, "tw": 1}, out.dim) with self.assertRaises(ValueError): - out = input.tw([-2,0])-input.tw([-1,0]) + out = input.tw([-2, 0]) - input.tw([-1, 0]) with self.assertRaises(ValueError): - out = input.tw([-2,0])+input.tw([-1,0]) + out = input.tw([-2, 0]) + input.tw([-1, 0]) def test_scalar_input_sw_dimensions(self): NeuObj.clearNames() - input = Input('in1') - out = input.sw([-1,1])+input.sw([-2,0]) - self.assertEqual({'dim': 1, 'sw': 2}, out.dim) - out = input.sw(1)+input.sw([-1,0]) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) + input = Input("in1") + out = input.sw([-1, 1]) + input.sw([-2, 0]) + self.assertEqual({"dim": 1, "sw": 2}, out.dim) + out = input.sw(1) + input.sw([-1, 0]) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) out = Fir(input.sw(1) + input.sw([-1, 0])) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) - out = input.sw([-1,0])+input.sw([-4,-3])+input.sw(1) - self.assertEqual({'dim': 1,'sw': 1}, out.dim) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) + out = input.sw([-1, 0]) + input.sw([-4, -3]) + input.sw(1) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) with self.assertRaises(ValueError): - out = input.sw([-2,0])-input.sw([-1,0]) + out = input.sw([-2, 0]) - input.sw([-1, 0]) with self.assertRaises(ValueError): - out = input.sw([-2,0])+input.sw([-1,0]) + out = input.sw([-2, 0]) + input.sw([-1, 0]) with self.assertRaises(TypeError): out = input.sw(1) + input.tw([-1, 0]) with self.assertRaises(TypeError): out = input.sw(1.2) with self.assertRaises(TypeError): - out = input.sw([-1.2,0.05]) + out = input.sw([-1.2, 0.05]) def test_vector_input_dimensions(self): NeuObj.clearNames() - input = Input('in1', dimensions = 5) - self.assertEqual({'dim': 5}, input.dim) - self.assertEqual({'dim': 5, 'tw' : 2}, input.tw(2).dim) + input = Input("in1", dimensions=5) + self.assertEqual({"dim": 5}, input.dim) + self.assertEqual({"dim": 5, "tw": 2}, input.tw(2).dim) out = input.tw(1) + input.tw(1) - self.assertEqual({'dim': 5, 'tw': 1}, out.dim) + self.assertEqual({"dim": 5, "tw": 1}, out.dim) out = Relu(input.tw(1)) - self.assertEqual({'dim': 5, 'tw': 1}, out.dim) + self.assertEqual({"dim": 5, "tw": 1}, out.dim) with self.assertRaises(TypeError): Fir(7)(input) with self.assertRaises(TypeError): - Fuzzify(7,[1,7])(input) + Fuzzify(7, [1, 7])(input) out = ParamFun(myFun)(input.tw(1)) - self.assertEqual({'dim': 5, 'tw' : 1}, out.dim) + self.assertEqual({"dim": 5, "tw": 1}, out.dim) out = ParamFun(myFun)(input.tw(2)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) - out = ParamFun(myFun)(input.tw(2),input.tw(1)) - self.assertEqual({'dim': 5, 'tw': 2}, out.dim) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) + out = ParamFun(myFun)(input.tw(2), input.tw(1)) + self.assertEqual({"dim": 5, "tw": 2}, out.dim) def test_parameter_and_linear(self): NeuObj.clearNames() - input = Input('in1').last() - W15 = Parameter('W15', dimensions=(1, 5)) - b15 = Parameter('b15', dimensions=5) - input4 = Input('in4', dimensions=4).last() - W45 = Parameter('W45', dimensions=(4, 5)) - b45 = Parameter('b45', dimensions=5) + input = Input("in1").last() + W15 = Parameter("W15", dimensions=(1, 5)) + b15 = Parameter("b15", dimensions=5) + input4 = Input("in4", dimensions=4).last() + W45 = Parameter("W45", dimensions=(4, 5)) + b45 = Parameter("b45", dimensions=5) out = Linear(input) + Linear(input4) out3 = Linear(3)(input) + Linear(3)(input4) - outW = Linear(W = W15)(input) + Linear(W = W45)(input4) - outWb = Linear(W = W15,b = b15)(input) + Linear(W = W45, b = b45)(input4) - self.assertEqual({'dim': 1, 'sw': 1}, out.dim) - self.assertEqual({'dim': 3, 'sw': 1}, out3.dim) - self.assertEqual({'dim': 5, 'sw': 1}, outW.dim) - self.assertEqual({'dim': 5, 'sw': 1}, outWb.dim) + outW = Linear(W=W15)(input) + Linear(W=W45)(input4) + outWb = Linear(W=W15, b=b15)(input) + Linear(W=W45, b=b45)(input4) + self.assertEqual({"dim": 1, "sw": 1}, out.dim) + self.assertEqual({"dim": 3, "sw": 1}, out3.dim) + self.assertEqual({"dim": 5, "sw": 1}, outW.dim) + self.assertEqual({"dim": 5, "sw": 1}, outWb.dim) NeuObj.clearNames() - input2 = Input('in1').sw([-1,1]) - W15 = Parameter('W15', dimensions=(1, 5)) - b15 = Parameter('b15', dimensions=5) - input42 = Input('in4', dimensions=4).sw([-1,1]) - W45 = Parameter('W45', dimensions=(4, 5)) - b45 = Parameter('b45', dimensions=5) + input2 = Input("in1").sw([-1, 1]) + W15 = Parameter("W15", dimensions=(1, 5)) + b15 = Parameter("b15", dimensions=5) + input42 = Input("in4", dimensions=4).sw([-1, 1]) + W45 = Parameter("W45", dimensions=(4, 5)) + b45 = Parameter("b45", dimensions=5) out = Linear(input2) + Linear(input42) out3 = Linear(3)(input2) + Linear(3)(input42) - outW = Linear(W = W15)(input2) + Linear(W = W45)(input42) - outWb = Linear(W = W15,b = b15)(input2) + Linear(W = W45, b = b45)(input42) - self.assertEqual({'dim': 1, 'sw': 2}, out.dim) - self.assertEqual({'dim': 3, 'sw': 2}, out3.dim) - self.assertEqual({'dim': 5, 'sw': 2}, outW.dim) - self.assertEqual({'dim': 5, 'sw': 2}, outWb.dim) + outW = Linear(W=W15)(input2) + Linear(W=W45)(input42) + outWb = Linear(W=W15, b=b15)(input2) + Linear(W=W45, b=b45)(input42) + self.assertEqual({"dim": 1, "sw": 2}, out.dim) + self.assertEqual({"dim": 3, "sw": 2}, out3.dim) + self.assertEqual({"dim": 5, "sw": 2}, outW.dim) + self.assertEqual({"dim": 5, "sw": 2}, outWb.dim) with self.assertRaises(ValueError): Linear(input) + Linear(input42) with self.assertRaises(ValueError): Linear(3)(input2) + Linear(3)(input4) with self.assertRaises(ValueError): - Linear(W = W15)(input) + Linear(W = W45)(input42) + Linear(W=W15)(input) + Linear(W=W45)(input42) with self.assertRaises(ValueError): - Linear(W = W15,b = b15)(input2) + Linear(W = W45, b = b45)(input4) + Linear(W=W15, b=b15)(input2) + Linear(W=W45, b=b45)(input4) def test_input_paramfun_param_const(self): NeuObj.clearNames() - input2 = Input('in2') - def fun_test(x,y,z,k): - return x*y*z*k + input2 = Input("in2") + + def fun_test(x, y, z, k): + return x * y * z * k NeuObj.clearNames() out = ParamFun(fun_test)(input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0k': {'dim': 1},'FParamFun0y': {'dim': 1},'FParamFun0z': {'dim': 1}}, out.json['Parameters']) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + { + "FParamFun0k": {"dim": 1}, + "FParamFun0y": {"dim": 1}, + "FParamFun0z": {"dim": 1}, + }, + out.json["Parameters"], + ) NeuObj.clearNames() - out = ParamFun(fun_test)(input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0k': {'dim': 1}, 'FParamFun0z': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test)(input2.tw(0.01), input2.tw(0.01)) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0k": {"dim": 1}, "FParamFun0z": {"dim": 1}}, + out.json["Parameters"], + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants=['t'])(input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0z': {'dim': 1}, 't': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants=["t"])( + input2.tw(0.01), input2.tw(0.01) + ) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0z": {"dim": 1}, "t": {"dim": 1}}, out.json["Parameters"] + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants=['t','r'])(input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'r': {'dim': 1}, 't': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants=["t", "r"])( + input2.tw(0.01), input2.tw(0.01) + ) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual({"r": {"dim": 1}, "t": {"dim": 1}}, out.json["Parameters"]) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants={'k':'t'})(input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0z': {'dim': 1}, 't': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants={"k": "t"})( + input2.tw(0.01), input2.tw(0.01) + ) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0z": {"dim": 1}, "t": {"dim": 1}}, out.json["Parameters"] + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants={'k':(1,2)})(input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 2, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0k': {'dim': [1,2]}, 'FParamFun0z': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants={"k": (1, 2)})( + input2.tw(0.01), input2.tw(0.01) + ) + self.assertEqual({"dim": 2, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0k": {"dim": [1, 2]}, "FParamFun0z": {"dim": 1}}, + out.json["Parameters"], + ) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants={'k':(1,2),'y':'r'})(input2.tw(0.01),input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants={"k": (1, 2), "y": "r"})( + input2.tw(0.01), input2.tw(0.01) + ) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants=[1.0,(1,2),'gg'])(input2.tw(0.01),input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants=[1.0, (1, 2), "gg"])( + input2.tw(0.01), input2.tw(0.01) + ) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants=[(1,2),'pp','c',[[1.0]]])(input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants=[(1, 2), "pp", "c", [[1.0]]])( + input2.tw(0.01) + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants={'k':(1,2)})(input2.tw(0.01),input2.tw(0.01),input2.tw(0.01)) - self.assertEqual({'dim': 2, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0k': {'dim': [1,2]}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants={"k": (1, 2)})( + input2.tw(0.01), input2.tw(0.01), input2.tw(0.01) + ) + self.assertEqual({"dim": 2, "tw": 0.01}, out.dim) + self.assertEqual({"FParamFun0k": {"dim": [1, 2]}}, out.json["Parameters"]) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants={'z':(1,2)})(input2.tw(0.01),input2.tw(0.01),input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants={"z": (1, 2)})( + input2.tw(0.01), input2.tw(0.01), input2.tw(0.01) + ) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants={'z':'g'})(input2.tw(0.01),input2.tw(0.01),input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants={"z": "g"})( + input2.tw(0.01), input2.tw(0.01), input2.tw(0.01) + ) with self.assertRaises(ValueError): - ParamFun(fun_test,parameters_and_constants={'z':'o'})(input2.tw(0.01),input2.tw(0.01),input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants={"z": "o"})( + input2.tw(0.01), input2.tw(0.01), input2.tw(0.01) + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants=['pp','tt'])(input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0y': {'dim': 1}, 'pp': {'dim': 1},'tt': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants=["pp", "tt"])(input2.tw(0.01)) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0y": {"dim": 1}, "pp": {"dim": 1}, "tt": {"dim": 1}}, + out.json["Parameters"], + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants={'y':'pp','k':'el'})(input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'FParamFun0z': {'dim': 1}, 'pp': {'dim': 1},'el': {'dim': 1}}, out.json['Parameters']) + out = ParamFun(fun_test, parameters_and_constants={"y": "pp", "k": "el"})( + input2.tw(0.01) + ) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual( + {"FParamFun0z": {"dim": 1}, "pp": {"dim": 1}, "el": {"dim": 1}}, + out.json["Parameters"], + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants=['pp','oo',Constant('el',values=2.0)])(input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'oo': {'dim': 1}, 'pp': {'dim': 1}}, out.json['Parameters']) - self.assertEqual({'el': {'dim': 1,'values':[2.0]}}, out.json['Constants']) + out = ParamFun( + fun_test, parameters_and_constants=["pp", "oo", Constant("el", values=2.0)] + )(input2.tw(0.01)) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual({"oo": {"dim": 1}, "pp": {"dim": 1}}, out.json["Parameters"]) + self.assertEqual({"el": {"dim": 1, "values": [2.0]}}, out.json["Constants"]) with self.assertRaises(NameError): - ParamFun(fun_test,parameters_and_constants=['pp','oo','el'])(input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants=["pp", "oo", "el"])( + input2.tw(0.01) + ) with self.assertRaises(NameError): - ParamFun(fun_test,parameters_and_constants=['pp','oo','el'])(input2.tw(0.01)) + ParamFun(fun_test, parameters_and_constants=["pp", "oo", "el"])( + input2.tw(0.01) + ) NeuObj.clearNames() - out = ParamFun(fun_test,parameters_and_constants=['pp',Constant('oo',values=[[2.0]]),Constant('ll',sw=1,values=[[7.0]])])(input2.tw(0.01)) - self.assertEqual({'dim': 1, 'tw': 0.01}, out.dim) - self.assertEqual({'pp': {'dim': 1}}, out.json['Parameters']) - self.assertEqual({'oo': {'dim': [1,1],'values':[[2.0]]}, 'll': {'dim': 1,'sw': 1,'values':[[7.0]]}}, out.json['Constants']) + out = ParamFun( + fun_test, + parameters_and_constants=[ + "pp", + Constant("oo", values=[[2.0]]), + Constant("ll", sw=1, values=[[7.0]]), + ], + )(input2.tw(0.01)) + self.assertEqual({"dim": 1, "tw": 0.01}, out.dim) + self.assertEqual({"pp": {"dim": 1}}, out.json["Parameters"]) + self.assertEqual( + { + "oo": {"dim": [1, 1], "values": [[2.0]]}, + "ll": {"dim": 1, "sw": 1, "values": [[7.0]]}, + }, + out.json["Constants"], + ) NeuObj.clearNames() - pp = Parameter('pp') - ll = Constant('ll', values=[[1,2,3],[1,2,3]]) - oo = Constant('oo', values=[1,2,3]) - out = ParamFun(fun_test,parameters_and_constants=[pp,ll,oo])(input2.tw(0.01)) - self.assertEqual({'dim': 3, 'sw': 2}, out.dim) - self.assertEqual({'pp': {'dim': 1}}, out.json['Parameters']) - self.assertEqual({'oo': {'dim': 3, 'values': [1,2,3]}, 'll': {'dim': [2,3], 'values':[[1,2,3],[1,2,3]]}}, out.json['Constants']) - - out = ParamFun(fun_test,parameters_and_constants={'z':pp,'y':ll,'k':oo})(input2.tw(0.01)) - self.assertEqual({'dim': 3, 'sw': 2}, out.dim) - self.assertEqual({'pp': {'dim': 1}}, out.json['Parameters']) - self.assertEqual(['ll', 'pp', 'oo'],out.json['Functions']['FParamFun4']['params_and_consts']) - self.assertEqual({'oo': {'dim': 3, 'values': [1,2,3]}, 'll': {'dim': [2,3], 'values':[[1,2,3],[1,2,3]]}}, out.json['Constants']) + pp = Parameter("pp") + ll = Constant("ll", values=[[1, 2, 3], [1, 2, 3]]) + oo = Constant("oo", values=[1, 2, 3]) + out = ParamFun(fun_test, parameters_and_constants=[pp, ll, oo])(input2.tw(0.01)) + self.assertEqual({"dim": 3, "sw": 2}, out.dim) + self.assertEqual({"pp": {"dim": 1}}, out.json["Parameters"]) + self.assertEqual( + { + "oo": {"dim": 3, "values": [1, 2, 3]}, + "ll": {"dim": [2, 3], "values": [[1, 2, 3], [1, 2, 3]]}, + }, + out.json["Constants"], + ) + + out = ParamFun(fun_test, parameters_and_constants={"z": pp, "y": ll, "k": oo})( + input2.tw(0.01) + ) + self.assertEqual({"dim": 3, "sw": 2}, out.dim) + self.assertEqual({"pp": {"dim": 1}}, out.json["Parameters"]) + self.assertEqual( + ["ll", "pp", "oo"], out.json["Functions"]["FParamFun4"]["params_and_consts"] + ) + self.assertEqual( + { + "oo": {"dim": 3, "values": [1, 2, 3]}, + "ll": {"dim": [2, 3], "values": [[1, 2, 3], [1, 2, 3]]}, + }, + out.json["Constants"], + ) NeuObj.clearNames() Stream.resetCount() - pp = Parameter('pp') - ll = Constant('ll', values=[1,2,3]) - oo = Constant('oo', tw=0.01, values=[[1]]) - out = ParamFun(fun_test)(input2.tw(0.01),ll,oo,pp) - self.assertEqual({'dim': 3, 'tw': 0.01}, out.dim) - self.assertEqual({'pp': {'dim': 1}}, out.json['Parameters']) - self.assertEqual({'oo': {'dim': 1, 'tw':0.01, 'values': [[1]]}, 'll': {'dim': 3, 'values': [1,2,3]}}, out.json['Constants']) - self.assertEqual(['TimePart1', 'll', 'oo', 'pp'], out.json['Relations']['ParamFun2'][1]) + pp = Parameter("pp") + ll = Constant("ll", values=[1, 2, 3]) + oo = Constant("oo", tw=0.01, values=[[1]]) + out = ParamFun(fun_test)(input2.tw(0.01), ll, oo, pp) + self.assertEqual({"dim": 3, "tw": 0.01}, out.dim) + self.assertEqual({"pp": {"dim": 1}}, out.json["Parameters"]) + self.assertEqual( + { + "oo": {"dim": 1, "tw": 0.01, "values": [[1]]}, + "ll": {"dim": 3, "values": [1, 2, 3]}, + }, + out.json["Constants"], + ) + self.assertEqual( + ["TimePart1", "ll", "oo", "pp"], out.json["Relations"]["ParamFun2"][1] + ) def test_check_multiple_streams_compatibility_paramfun(self): NeuObj.clearNames() log.setAllLevel(logging.WARNING) - x = Input('x') - F = Input('F') + x = Input("x") + F = Input("F") def myFun(p1, p2, k1, k2): import torch + return k1 * torch.sin(p1) + k2 * torch.cos(p2) - K1 = Parameter('k1', dimensions=1, sw=1, values=[[2.0]]) - K2 = Parameter('k2', dimensions=1, sw=1, values=[[3.0]]) - parfun = ParamFun(myFun, parameters_and_constants=[K1,K2]) + K1 = Parameter("k1", dimensions=1, sw=1, values=[[2.0]]) + K2 = Parameter("k2", dimensions=1, sw=1, values=[[3.0]]) + parfun = ParamFun(myFun, parameters_and_constants=[K1, K2]) rel1 = parfun(x.last(), F.last()) - rel2 = parfun(Tanh(F.sw(2)+F.sw([-2,-0])+F.sw([-3,-1])+F.sw([-4,-2])), Tanh(F.sw([0,2]))) - rel3 = parfun(Tanh(F.sw([-2,1]))) - rel4 = parfun(Tanh(F.sw([-2,1])), K1) + rel2 = parfun( + Tanh(F.sw(2) + F.sw([-2, -0]) + F.sw([-3, -1]) + F.sw([-4, -2])), + Tanh(F.sw([0, 2])), + ) + rel3 = parfun(Tanh(F.sw([-2, 1]))) + rel4 = parfun(Tanh(F.sw([-2, 1])), K1) rel5 = parfun(K1, Tanh(F.sw(1))) with self.assertRaises(TypeError): parfun(Fir(3)(parfun(x.tw(0.4), x.tw(0.4)))) - out1 = Output('out1', rel1) - out2 = Output('out2', rel2) - out3 = Output('out3', rel3) - out4 = Output('out4', rel4) - out5 = Output('out5', rel5) + out1 = Output("out1", rel1) + out2 = Output("out2", rel2) + out3 = Output("out3", rel3) + out4 = Output("out4", rel4) + out5 = Output("out5", rel5) # m = MPLVisualizer(5) # m.showFunctions(list(example.json['Functions'].keys()), xlim=[[-5, 5], [-1, 1]]) exampleA = Modely(visualizer=None, seed=2) with self.assertRaises(TypeError): - exampleA.addModel('model', [out1, out2, out3]) - exampleA.addModel('model_A', [out1, out2]) + exampleA.addModel("model", [out1, out2, out3]) + exampleA.addModel("model_A", [out1, out2]) with self.assertRaises(TypeError): - exampleA.addModel('model_B', [out3]) - exampleA.addModel('model_A2', [out1, out2, out4, out5]) + exampleA.addModel("model_B", [out3]) + exampleA.addModel("model_A2", [out1, out2, out4, out5]) exampleA.neuralizeModel(0.25) exampleB = Modely(visualizer=None, seed=2) - exampleB.addModel('model_B', [out3]) + exampleB.addModel("model_B", [out3]) exampleB.neuralizeModel(1) - resultsA = exampleA({'x': [1, 3, 3]}) - self.TestAlmostEqual([4.682941913604736, 3.2822399139404297, 3.2822399139404297], resultsA['out1']) - self.TestAlmostEqual([[3.0, 3.0],[3.0 , 3.0],[3.0 , 3.0]], resultsA['out2']) - self.TestAlmostEqual([[-1.2484405040740967, -1.2484405040740967, -1.2484405040740967], - [-1.2484405040740967, -1.2484405040740967, -1.2484405040740967], - [-1.2484405040740967, -1.2484405040740967, -1.2484405040740967]], resultsA['out4']) - self.TestAlmostEqual([4.818594932556152, 4.818594932556152, 4.818594932556152], resultsA['out5']) - - resultsB = exampleB({'F': [1, 3, 4]}) - self.TestAlmostEqual([[3.831000328063965, 4.128425598144531, 4.133065223693848]], resultsB['out3']) + resultsA = exampleA({"x": [1, 3, 3]}) + self.TestAlmostEqual( + [4.682941913604736, 3.2822399139404297, 3.2822399139404297], + resultsA["out1"], + ) + self.TestAlmostEqual([[3.0, 3.0], [3.0, 3.0], [3.0, 3.0]], resultsA["out2"]) + self.TestAlmostEqual( + [ + [-1.2484405040740967, -1.2484405040740967, -1.2484405040740967], + [-1.2484405040740967, -1.2484405040740967, -1.2484405040740967], + [-1.2484405040740967, -1.2484405040740967, -1.2484405040740967], + ], + resultsA["out4"], + ) + self.TestAlmostEqual( + [4.818594932556152, 4.818594932556152, 4.818594932556152], resultsA["out5"] + ) + + resultsB = exampleB({"F": [1, 3, 4]}) + self.TestAlmostEqual( + [[3.831000328063965, 4.128425598144531, 4.133065223693848]], + resultsB["out3"], + ) log.setAllLevel(logging.CRITICAL) def test_check_multiple_streams_compatibility_linear(self): NeuObj.clearNames() log.setAllLevel(logging.WARNING) - x = Input('x',dimensions=3) - f = Input('f') + x = Input("x", dimensions=3) + f = Input("f") lin = Linear() l1out = lin(x.last()) + Fir(lin(x.tw(2.0))) + Fir(lin(x.sw(3))) l2out = lin(f.last()) + Fir(lin(f.tw(2.0))) + Fir(lin(f.sw(3))) - out1 = Output('out1', l1out) - out2 = Output('out2', l2out) + out1 = Output("out1", l1out) + out2 = Output("out2", l2out) exampleA = Modely(visualizer=None, seed=2) with self.assertRaises(TypeError): - exampleA.addModel('model', [out1, out2]) - exampleA.addModel('model_A', [out1]) + exampleA.addModel("model", [out1, out2]) + exampleA.addModel("model_A", [out1]) with self.assertRaises(TypeError): - exampleA.addModel('model_B', [out2]) + exampleA.addModel("model_B", [out2]) exampleA.neuralizeModel(1) exampleB = Modely(visualizer=None, seed=2) - exampleB.addModel('model_B', [out2]) + exampleB.addModel("model_B", [out2]) exampleB.neuralizeModel(1) - resultsA = exampleA({'x': [[1, 3, 3], [1, 2, 1], [2, 3, 4]]}) - self.TestAlmostEqual([12.507442474365234], resultsA['out1']) + resultsA = exampleA({"x": [[1, 3, 3], [1, 2, 1], [2, 3, 4]]}) + self.TestAlmostEqual([12.507442474365234], resultsA["out1"]) - resultsB = exampleB({'f': [1, 3, 3, 1, 2, 1]}) - self.TestAlmostEqual([6.585615158081055, 4.480303764343262, 4.106618881225586, 3.18161678314209], resultsB['out2']) + resultsB = exampleB({"f": [1, 3, 3, 1, 2, 1]}) + self.TestAlmostEqual( + [6.585615158081055, 4.480303764343262, 4.106618881225586, 3.18161678314209], + resultsB["out2"], + ) log.setAllLevel(logging.CRITICAL) def test_check_multiple_streams_compatibility_fir(self): NeuObj.clearNames() log.setAllLevel(logging.WARNING) - x = Input('x') + x = Input("x") fir = Fir() with self.assertRaises(TypeError): fir(x.last()) + fir(x.tw(2.0)) + fir(x.sw(3)) - out1 = Output('out1', fir(x.last())) - out2 = Output('out2', fir(x.tw(2.0))) + out1 = Output("out1", fir(x.last())) + out2 = Output("out2", fir(x.tw(2.0))) exampleA = Modely(visualizer=None, seed=2) with self.assertRaises(TypeError): - exampleA.addModel('model', [out1, out2]) - exampleA.addModel('model_A', [out1]) + exampleA.addModel("model", [out1, out2]) + exampleA.addModel("model_A", [out1]) with self.assertRaises(TypeError): - exampleA.addModel('model_B', [out2]) + exampleA.addModel("model_B", [out2]) exampleA.neuralizeModel(1) exampleB = Modely(visualizer=None, seed=2) - exampleB.addModel('model_B', [out2]) + exampleB.addModel("model_B", [out2]) exampleB.neuralizeModel(1) - resultsA = exampleA({'x': [1, 3]}) - self.TestAlmostEqual([0.6146950721740723, 1.8440852165222168], resultsA['out1']) + resultsA = exampleA({"x": [1, 3]}) + self.TestAlmostEqual([0.6146950721740723, 1.8440852165222168], resultsA["out1"]) - resultsB = exampleB({'x': [1, 4, 5]}) - self.TestAlmostEqual([2.138746500015259, 4.363844871520996], resultsB['out2']) + resultsB = exampleB({"x": [1, 4, 5]}) + self.TestAlmostEqual([2.138746500015259, 4.363844871520996], resultsB["out2"]) log.setAllLevel(logging.CRITICAL) def test_constant_and_parameter(self): NeuObj.clearNames() - c1 = Constant('c1', values=5.0) # {'dim': 1} -> shape (1,) - c11 = Constant('c11', values=5.0) # {'dim': 1} -> shape (1,) - c2 = Constant('c2', values=[5.0, 2.0, 1.0]) # {'dim': 3} -> shape (3,) - c3 = Constant('c3', values=[[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]]) # {'dim': (2,3)} -> shape (2,3) - c4 = Constant('c4', sw=2, values=[[2, 3, 4], [1, 2, 3]]) # {'sw':2, 'dim': 3} -> shape (2,3) - c5 = Constant('c5', tw=4, values=[[2, 3, 4], [1, 2, 3]]) # {'tw':4, 'dim': 3} -> shape (2,3) - c6 = Constant('c6', sw=2, values=[[[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], [[5.0, 2.0, 1.0], [3.0, 4.0,5.0]]]) # {'sw':2, 'dim': (2,3)} -> shape (2,2,3) - self.assertEqual({'dim': 1}, c1.dim) - self.assertEqual({'dim': 1}, c11.dim) - self.assertEqual({'dim': 3}, c2.dim) - self.assertEqual({'dim': [2,3]}, c3.dim) - self.assertEqual({'dim': 3, 'sw': 2}, c4.dim) - self.assertEqual({'dim': 3, 'tw': 4}, c5.dim) - self.assertEqual({'dim': [2,3], 'sw':2}, c6.dim) - - p1 = Parameter('p1', values=5.0) # {'dim': 1} -> shape (1,) - p11 = Parameter('p11', values=[5.0]) # {'dim': 1} -> shape (1,) - p111 = Parameter('p111', values=[[5.0]]) # {'dim': 1} -> shape (1,) - p2 = Parameter('p2', values=[5.0, 2.0, 1.0]) # {'dim': 3} - p22 = Parameter('p22', sw=1, values=[[2, 3, 4]]) # {'dim': 3, 'sw': 1} -> shape (1,3) - p3 = Parameter('p3', values=[[5.0, 2.0, 1.0], [3.0, 4.0, 5.0],[3.0, 4.0, 5.0],[3.0, 4.0, 5.0],[3.0, 4.0, 5.0]]) # {'dim': [5,3]} - p4 = Parameter('p4', sw=2, values=[[2, 3, 4], [1, 2, 3]]) # {'sw':2, 'dim': 3} - p5 = Parameter('p5', tw=4, values=[[2, 3, 4], [1, 2, 3]]) # {'tw':4, 'dim': 3} - p6 = Parameter('p6', sw=2, values=[[[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], [[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]]]) # {'sw':2, 'dim': (2,3)} -> shape (2,2,3) - self.assertEqual({'dim': 1}, p1.dim) - self.assertEqual({'dim': 1}, p11.dim) - self.assertEqual({'dim': [1,1]}, p111.dim) - self.assertEqual({'dim': 3}, p2.dim) - self.assertEqual({'dim': 3, 'sw':1}, p22.dim) - self.assertEqual({'dim': [5,3]}, p3.dim) - self.assertEqual({'dim': 3, 'sw': 2}, p4.dim) - self.assertEqual({'dim': 3, 'tw': 4}, p5.dim) - self.assertEqual({'dim': [2,3], 'sw':2}, p6.dim) - - x = Input('x',dimensions=5) - out1 = Output('out1', ParamFun(myFunPar, parameters_and_constants=[p1])(x.last())) - out11 = Output('out11', ParamFun(myFunPar, parameters_and_constants=[p11])(x.last())) - out111 = Output('out111', ParamFun(myFunPar, parameters_and_constants=[p111])(x.last())) - out2 = Output('out2', ParamFun(myFunPar, parameters_and_constants=[p2])(x.last())) - out22 = Output('out22', ParamFun(myFunPar, parameters_and_constants=[p22])(x.last())) - out3 = Output('out3', ParamFun(myFunPar, parameters_and_constants=[p3])(x.last())) - out4 = Output('out4', ParamFun(myFunPar, parameters_and_constants=[p4])(x.last())) - out5 = Output('out5', ParamFun(myFunPar, parameters_and_constants=[p5])(x.last())) - out6 = Output('out6', ParamFun(myFunPar, parameters_and_constants=[p6])(x.last())) + c1 = Constant("c1", values=5.0) # {'dim': 1} -> shape (1,) + c11 = Constant("c11", values=5.0) # {'dim': 1} -> shape (1,) + c2 = Constant("c2", values=[5.0, 2.0, 1.0]) # {'dim': 3} -> shape (3,) + c3 = Constant( + "c3", values=[[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]] + ) # {'dim': (2,3)} -> shape (2,3) + c4 = Constant( + "c4", sw=2, values=[[2, 3, 4], [1, 2, 3]] + ) # {'sw':2, 'dim': 3} -> shape (2,3) + c5 = Constant( + "c5", tw=4, values=[[2, 3, 4], [1, 2, 3]] + ) # {'tw':4, 'dim': 3} -> shape (2,3) + c6 = Constant( + "c6", + sw=2, + values=[ + [[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], + [[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], + ], + ) # {'sw':2, 'dim': (2,3)} -> shape (2,2,3) + self.assertEqual({"dim": 1}, c1.dim) + self.assertEqual({"dim": 1}, c11.dim) + self.assertEqual({"dim": 3}, c2.dim) + self.assertEqual({"dim": [2, 3]}, c3.dim) + self.assertEqual({"dim": 3, "sw": 2}, c4.dim) + self.assertEqual({"dim": 3, "tw": 4}, c5.dim) + self.assertEqual({"dim": [2, 3], "sw": 2}, c6.dim) + + p1 = Parameter("p1", values=5.0) # {'dim': 1} -> shape (1,) + p11 = Parameter("p11", values=[5.0]) # {'dim': 1} -> shape (1,) + p111 = Parameter("p111", values=[[5.0]]) # {'dim': 1} -> shape (1,) + p2 = Parameter("p2", values=[5.0, 2.0, 1.0]) # {'dim': 3} + p22 = Parameter( + "p22", sw=1, values=[[2, 3, 4]] + ) # {'dim': 3, 'sw': 1} -> shape (1,3) + p3 = Parameter( + "p3", + values=[ + [5.0, 2.0, 1.0], + [3.0, 4.0, 5.0], + [3.0, 4.0, 5.0], + [3.0, 4.0, 5.0], + [3.0, 4.0, 5.0], + ], + ) # {'dim': [5,3]} + p4 = Parameter("p4", sw=2, values=[[2, 3, 4], [1, 2, 3]]) # {'sw':2, 'dim': 3} + p5 = Parameter("p5", tw=4, values=[[2, 3, 4], [1, 2, 3]]) # {'tw':4, 'dim': 3} + p6 = Parameter( + "p6", + sw=2, + values=[ + [[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], + [[5.0, 2.0, 1.0], [3.0, 4.0, 5.0]], + ], + ) # {'sw':2, 'dim': (2,3)} -> shape (2,2,3) + self.assertEqual({"dim": 1}, p1.dim) + self.assertEqual({"dim": 1}, p11.dim) + self.assertEqual({"dim": [1, 1]}, p111.dim) + self.assertEqual({"dim": 3}, p2.dim) + self.assertEqual({"dim": 3, "sw": 1}, p22.dim) + self.assertEqual({"dim": [5, 3]}, p3.dim) + self.assertEqual({"dim": 3, "sw": 2}, p4.dim) + self.assertEqual({"dim": 3, "tw": 4}, p5.dim) + self.assertEqual({"dim": [2, 3], "sw": 2}, p6.dim) + + x = Input("x", dimensions=5) + out1 = Output( + "out1", ParamFun(myFunPar, parameters_and_constants=[p1])(x.last()) + ) + out11 = Output( + "out11", ParamFun(myFunPar, parameters_and_constants=[p11])(x.last()) + ) + out111 = Output( + "out111", ParamFun(myFunPar, parameters_and_constants=[p111])(x.last()) + ) + out2 = Output( + "out2", ParamFun(myFunPar, parameters_and_constants=[p2])(x.last()) + ) + out22 = Output( + "out22", ParamFun(myFunPar, parameters_and_constants=[p22])(x.last()) + ) + out3 = Output( + "out3", ParamFun(myFunPar, parameters_and_constants=[p3])(x.last()) + ) + out4 = Output( + "out4", ParamFun(myFunPar, parameters_and_constants=[p4])(x.last()) + ) + out5 = Output( + "out5", ParamFun(myFunPar, parameters_and_constants=[p5])(x.last()) + ) + out6 = Output( + "out6", ParamFun(myFunPar, parameters_and_constants=[p6])(x.last()) + ) nn = Modely(visualizer=None) - nn.addModel('model', [out1,out11,out111,out2,out22,out3,out4,out5,out6]) + nn.addModel("model", [out1, out11, out111, out2, out22, out3, out4, out5, out6]) nn.neuralizeModel(2.0) - results = nn({'x':[[1,2,3,4,5]]}) - self.assertEqual(results['out1'][0], p1.dim['dim']) - self.assertEqual(results['out11'][0], p11.dim['dim']) - self.assertEqual(results['out111'][0][0], p111.dim['dim']) - self.assertEqual(results['out2'][0], p2.dim['dim']) - self.assertEqual(results['out22'][0][0][1], p22.dim['dim']) - self.assertEqual(results['out22'][0][0][0], p22.dim['sw']) - self.assertEqual(results['out3'][0][0], p3.dim['dim']) - self.assertEqual(results['out3'][0][0][1], p4.dim['dim']) - self.assertEqual(results['out4'][0][0][0], p4.dim['sw']) - self.assertEqual(results['out5'][0][0][1], p5.dim['dim']) - self.assertEqual(results['out5'][0][0][0], p5.dim['tw']/2.0) - self.assertEqual(results['out6'][0][0][1:3], p6.dim['dim']) - self.assertEqual(results['out6'][0][0][0], p6.dim['sw']) - - NeuObj.clearNames(['x','out1','out11','out2','out22','out3','out4','out5','out6']) - x = Input('x') + results = nn({"x": [[1, 2, 3, 4, 5]]}) + self.assertEqual(results["out1"][0], p1.dim["dim"]) + self.assertEqual(results["out11"][0], p11.dim["dim"]) + self.assertEqual(results["out111"][0][0], p111.dim["dim"]) + self.assertEqual(results["out2"][0], p2.dim["dim"]) + self.assertEqual(results["out22"][0][0][1], p22.dim["dim"]) + self.assertEqual(results["out22"][0][0][0], p22.dim["sw"]) + self.assertEqual(results["out3"][0][0], p3.dim["dim"]) + self.assertEqual(results["out3"][0][0][1], p4.dim["dim"]) + self.assertEqual(results["out4"][0][0][0], p4.dim["sw"]) + self.assertEqual(results["out5"][0][0][1], p5.dim["dim"]) + self.assertEqual(results["out5"][0][0][0], p5.dim["tw"] / 2.0) + self.assertEqual(results["out6"][0][0][1:3], p6.dim["dim"]) + self.assertEqual(results["out6"][0][0][0], p6.dim["sw"]) + + NeuObj.clearNames( + ["x", "out1", "out11", "out2", "out22", "out3", "out4", "out5", "out6"] + ) + x = Input("x") with self.assertRaises(TypeError): - Output('out1', Linear(W=p1, b=p1)(x.last())) + Output("out1", Linear(W=p1, b=p1)(x.last())) with self.assertRaises(TypeError): - Output('out1', Linear(W=p11, b=p11)(x.last())) - out1 = Output('out1', Linear(W=p111, b=p1)(x.last())) - out11 = Output('out11', Linear(W=p111, b=p11)(x.last())) + Output("out1", Linear(W=p11, b=p11)(x.last())) + out1 = Output("out1", Linear(W=p111, b=p1)(x.last())) + out11 = Output("out11", Linear(W=p111, b=p11)(x.last())) with self.assertRaises(TypeError): - Output('out111', Linear(W=p111, b=p111)(x.last())) + Output("out111", Linear(W=p111, b=p111)(x.last())) - x5 = Input('x5',dimensions=5) + x5 = Input("x5", dimensions=5) with self.assertRaises(TypeError): - Output('out2', Linear(W=p1, b=p1)(x5.last())) + Output("out2", Linear(W=p1, b=p1)(x5.last())) with self.assertRaises(TypeError): - Output('out2', Linear(output_dimension=3, W=p1, b=p1)(x5.last())) - out2 = Output('out2', Linear(W=p3, b=p2)(x5.last())) - out3 = Output('out3', Linear(output_dimension=3, W=p3, b=p2)(x5.last())) + Output("out2", Linear(output_dimension=3, W=p1, b=p1)(x5.last())) + out2 = Output("out2", Linear(W=p3, b=p2)(x5.last())) + out3 = Output("out3", Linear(output_dimension=3, W=p3, b=p2)(x5.last())) with self.assertRaises(TypeError): - Output('out3', Linear(output_dimension=3, W=p3, b=p22)(x5.last())) + Output("out3", Linear(output_dimension=3, W=p3, b=p22)(x5.last())) with self.assertRaises(TypeError): - Output('out6', Linear(W=p6)(x.sw(2))) + Output("out6", Linear(W=p6)(x.sw(2))) - x2 = Input('x2', dimensions=2) + x2 = Input("x2", dimensions=2) with self.assertRaises(TypeError): - Output('out4', Linear(output_dimension=3, W=p4, b=p2)(x2.last())) + Output("out4", Linear(output_dimension=3, W=p4, b=p2)(x2.last())) - out4 = Output('out4', Fir(W=p4, b=p2)(x.sw(2))) - out41 = Output('out41', Fir(output_dimension=3, W=p4, b=p2)(x.sw(2))) + out4 = Output("out4", Fir(W=p4, b=p2)(x.sw(2))) + out41 = Output("out41", Fir(output_dimension=3, W=p4, b=p2)(x.sw(2))) with self.assertRaises(TypeError): - Output('out41', Fir(output_dimension=3, W=p5, b=p2)(x.sw(2))) + Output("out41", Fir(output_dimension=3, W=p5, b=p2)(x.sw(2))) with self.assertRaises(ValueError): - Output('out41', Fir(output_dimension=3, W=p4, b=p2)(x.sw(4))) + Output("out41", Fir(output_dimension=3, W=p4, b=p2)(x.sw(4))) with self.assertRaises(TypeError): - Output('out41', Fir(output_dimension=3, W=p4, b=p4)(x.sw(2))) - out5 = Output('out5', Fir(output_dimension=3, W=p5, b=p2)(x.tw(4))) - out51 = Output('out51', Fir(W=p5, b=p2)(x.tw(4))) + Output("out41", Fir(output_dimension=3, W=p4, b=p4)(x.sw(2))) + out5 = Output("out5", Fir(output_dimension=3, W=p5, b=p2)(x.tw(4))) + out51 = Output("out51", Fir(W=p5, b=p2)(x.tw(4))) with self.assertRaises(ValueError): - Output('out6', Fir(output_dimension=3, W=p6)(x.sw(2))) + Output("out6", Fir(output_dimension=3, W=p6)(x.sw(2))) with self.assertRaises(TypeError): - Output('out6', Fir(W=p6)(x.sw(2))) + Output("out6", Fir(W=p6)(x.sw(2))) nn = Modely(visualizer=None) - nn.addModel('model', [out1, out11, out111, out2, out22, out3, out4, out41, out5, out51, out6]) + nn.addModel( + "model", + [out1, out11, out111, out2, out22, out3, out4, out41, out5, out51, out6], + ) nn.neuralizeModel(2.0) - results = nn({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9], 'x5': [[1, 2, 3, 4, 5]]}) - self.assertEqual((1,),np.array(results['out1']).shape) - self.assertEqual((1,),np.array(results['out11']).shape) - self.assertEqual((1, 1, 3),np.array(results['out2']).shape) - self.assertEqual((1, 1, 3), np.array(results['out3']).shape) - self.assertEqual((1, 1, 3), np.array(results['out4']).shape) - self.assertEqual((1, 1, 3), np.array(results['out41']).shape) - self.assertEqual((1, 1, 3), np.array(results['out5']).shape) - self.assertEqual((1, 1, 3), np.array(results['out51']).shape) + results = nn({"x": [1, 2, 3, 4, 5, 6, 7, 8, 9], "x5": [[1, 2, 3, 4, 5]]}) + self.assertEqual((1,), np.array(results["out1"]).shape) + self.assertEqual((1,), np.array(results["out11"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out2"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out3"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out4"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out41"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out5"]).shape) + self.assertEqual((1, 1, 3), np.array(results["out51"]).shape) def test_multi_model_json_and_subjson(self): Stream.resetCount() NeuObj.clearNames() - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") + + c1 = Constant("c1", values=5.0) + c3 = Constant("c3", values=5.0) - c1 = Constant('c1', values=5.0) - c3 = Constant('c3', values=5.0) + rel2 = Linear(W=Parameter("W2", values=[[2.0]]), b=False)(y.last()) + rel4 = Linear(W=Parameter("W4", values=[[4.0]]), b=False)(y.last()) - rel2 = Linear(W=Parameter('W2', values=[[2.0]]), b=False)(y.last()) - rel4 = Linear(W=Parameter('W4', values=[[4.0]]), b=False)(y.last()) - def fun2(x, a): return x * a - + def fun4(x, b): return x + b - out1 = Output('out1', c1 + Linear(W=Parameter('W1', values=[[1.0]]), b=False)(x.last())) - out2 = Output('out2', rel2 + ParamFun(fun2, parameters_and_constants=[c1])(y.last())) - out3 = Output('out3', c3 + Linear(W=Parameter('W3', values=[[3.0]]), b=False)(x.last())) - out4 = Output('out4', rel4 + ParamFun(fun4, parameters_and_constants=[c3])(y.last())) + out1 = Output( + "out1", c1 + Linear(W=Parameter("W1", values=[[1.0]]), b=False)(x.last()) + ) + out2 = Output( + "out2", rel2 + ParamFun(fun2, parameters_and_constants=[c1])(y.last()) + ) + out3 = Output( + "out3", c3 + Linear(W=Parameter("W3", values=[[3.0]]), b=False)(x.last()) + ) + out4 = Output( + "out4", rel4 + ParamFun(fun4, parameters_and_constants=[c3])(y.last()) + ) nn = Modely(visualizer=None) - nn.addModel('model_A', [out1, out2]) - nn.addModel('model_B', [out3, out4]) - nn.addClosedLoop(rel2,y) - - subjson_A = subjson_from_model(nn.json, 'model_A') - subjson_B = subjson_from_model(nn.json, 'model_B') - self.assertEqual(subjson_A['Constants']['c1'],nn.json['Constants']['c1']) - self.assertEqual(subjson_B['Constants']['c3'],nn.json['Constants']['c3']) - self.assertEqual(subjson_A['Functions']['FParamFun11'], nn.json['Functions']['FParamFun11']) - self.assertEqual(subjson_B['Functions']['FParamFun16'], nn.json['Functions']['FParamFun16']) - self.assertEqual(subjson_A['Inputs']['x'], nn.json['Inputs']['x']) - self.assertEqual(subjson_B['Inputs']['x'], nn.json['Inputs']['x']) - self.assertEqual(subjson_A['Models'], 'model_A') - self.assertEqual(subjson_B['Models'], 'model_B') - self.assertEqual(sorted(list(subjson_A['Relations'].keys())), sorted(nn.json['Models']['model_A']['Relations'])) - self.assertEqual(sorted(list(subjson_B['Relations'].keys())), sorted(nn.json['Models']['model_B']['Relations'])) - self.assertEqual(sorted(list(subjson_A['Parameters'].keys())), sorted(['W2', 'W1'])) - self.assertEqual(sorted(list(subjson_B['Parameters'].keys())), sorted(['W3', 'W4'])) - self.assertEqual(sorted(list(subjson_A['Outputs'].keys())), sorted(['out1', 'out2'])) - self.assertEqual(sorted(list(subjson_B['Outputs'].keys())), sorted(['out3', 'out4'])) - yval = copy.deepcopy(nn.json['Inputs']['y']) - del yval['closedLoop'] - del yval['local'] - self.assertEqual(subjson_A['Inputs']['y'], nn.json['Inputs']['y']) - self.assertEqual(subjson_B['Inputs']['y'], yval) + nn.addModel("model_A", [out1, out2]) + nn.addModel("model_B", [out3, out4]) + nn.addClosedLoop(rel2, y) + + subjson_A = subjson_from_model(nn.json, "model_A") + subjson_B = subjson_from_model(nn.json, "model_B") + self.assertEqual(subjson_A["Constants"]["c1"], nn.json["Constants"]["c1"]) + self.assertEqual(subjson_B["Constants"]["c3"], nn.json["Constants"]["c3"]) + self.assertEqual( + subjson_A["Functions"]["FParamFun11"], nn.json["Functions"]["FParamFun11"] + ) + self.assertEqual( + subjson_B["Functions"]["FParamFun16"], nn.json["Functions"]["FParamFun16"] + ) + self.assertEqual(subjson_A["Inputs"]["x"], nn.json["Inputs"]["x"]) + self.assertEqual(subjson_B["Inputs"]["x"], nn.json["Inputs"]["x"]) + self.assertEqual(subjson_A["Models"], "model_A") + self.assertEqual(subjson_B["Models"], "model_B") + self.assertEqual( + sorted(list(subjson_A["Relations"].keys())), + sorted(nn.json["Models"]["model_A"]["Relations"]), + ) + self.assertEqual( + sorted(list(subjson_B["Relations"].keys())), + sorted(nn.json["Models"]["model_B"]["Relations"]), + ) + self.assertEqual( + sorted(list(subjson_A["Parameters"].keys())), sorted(["W2", "W1"]) + ) + self.assertEqual( + sorted(list(subjson_B["Parameters"].keys())), sorted(["W3", "W4"]) + ) + self.assertEqual( + sorted(list(subjson_A["Outputs"].keys())), sorted(["out1", "out2"]) + ) + self.assertEqual( + sorted(list(subjson_B["Outputs"].keys())), sorted(["out3", "out4"]) + ) + yval = copy.deepcopy(nn.json["Inputs"]["y"]) + del yval["closedLoop"] + del yval["local"] + self.assertEqual(subjson_A["Inputs"]["y"], nn.json["Inputs"]["y"]) + self.assertEqual(subjson_B["Inputs"]["y"], yval) aa = Modely(visualizer=None) - aa.addModel('model_A', [out1, out2]) + aa.addModel("model_A", [out1, out2]) aa.addClosedLoop(rel2, y) self.assertEqual(subjson_A, aa.json) bb = Modely(visualizer=None) - bb.addModel('model_B', [out3, out4]) + bb.addModel("model_B", [out3, out4]) self.assertEqual(subjson_B, bb.json) def test_add_remove_models(self): Stream.resetCount() NeuObj.clearNames() - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") - c1 = Constant('c1', values=5.0) - c3 = Constant('c3', values=5.0) + c1 = Constant("c1", values=5.0) + c3 = Constant("c3", values=5.0) - rel2 = Linear(W=Parameter('W2', values=[[2.0]]), b=False)(y.last()) - rel4 = Linear(W=Parameter('W4', values=[[4.0]]), b=False)(y.last()) + rel2 = Linear(W=Parameter("W2", values=[[2.0]]), b=False)(y.last()) + rel4 = Linear(W=Parameter("W4", values=[[4.0]]), b=False)(y.last()) def fun2(x, a): return x * a @@ -703,39 +1025,47 @@ def fun2(x, a): def fun4(x, b): return x + b - out1 = Output('out1', c1 + Linear(W=Parameter('W1', values=[[1.0]]), b=False)(x.last())) - out2 = Output('out2', rel2 + ParamFun(fun2, parameters_and_constants=[c1])(y.last())) - out3 = Output('out3', c3 + Linear(W=Parameter('W3', values=[[3.0]]), b=False)(x.last())) - out4 = Output('out4', rel4 + ParamFun(fun4, parameters_and_constants=[c3])(y.last())) + out1 = Output( + "out1", c1 + Linear(W=Parameter("W1", values=[[1.0]]), b=False)(x.last()) + ) + out2 = Output( + "out2", rel2 + ParamFun(fun2, parameters_and_constants=[c1])(y.last()) + ) + out3 = Output( + "out3", c3 + Linear(W=Parameter("W3", values=[[3.0]]), b=False)(x.last()) + ) + out4 = Output( + "out4", rel4 + ParamFun(fun4, parameters_and_constants=[c3])(y.last()) + ) nn = Modely(visualizer=None) - nn.addModel('model_A', [out1, out2]) + nn.addModel("model_A", [out1, out2]) model_A_json_1 = nn.json - nn.addModel('model_B', [out3, out4]) - nn.removeModel('model_B') + nn.addModel("model_B", [out3, out4]) + nn.removeModel("model_B") model_A_json_2 = nn.json self.assertEqual(model_A_json_1, model_A_json_2) def test_add_remove_minimize(self): clearNames() - input1 = Input('in1').last() - input2 = Input('in2').last() - input3 = Input('in3').last() - output1 = Output('out1', input1) - output2 = Output('out2', input1) - output3 = Output('out3', input1) + input1 = Input("in1").last() + input2 = Input("in2").last() + input3 = Input("in3").last() + output1 = Output("out1", input1) + output2 = Output("out2", input1) + output3 = Output("out3", input1) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1, output2, output3]) - test.addMinimize('error1', input1, output1) + test.addModel("model", [output1, output2, output3]) + test.addMinimize("error1", input1, output1) test_json_1 = test.json - test.addMinimize('error2', input2, output2) + test.addMinimize("error2", input2, output2) test_json_2 = test.json - test.addMinimize('error3', input3, output3) + test.addMinimize("error3", input3, output3) test_json_3 = test.json - test.removeMinimize('error3') + test.removeMinimize("error3") self.assertEqual(test_json_2, test.json) - test.addMinimize('error3', input3, output3) + test.addMinimize("error3", input3, output3) self.assertEqual(test_json_3, test.json) - test.removeMinimize(['error3','error2']) - self.assertEqual(test_json_1, test.json) \ No newline at end of file + test.removeMinimize(["error3", "error2"]) + self.assertEqual(test_json_1, test.json) diff --git a/tests/test_losses.py b/tests/test_losses.py index c7860722..34da3ebc 100644 --- a/tests/test_losses.py +++ b/tests/test_losses.py @@ -1,4 +1,6 @@ -import unittest, os, sys +import unittest +import os +import sys import numpy as np import torch @@ -15,11 +17,17 @@ # Test the looses comparison between closed loop and states # Test the looses comparison between connect and states -data_folder = os.path.join(os.path.dirname(__file__), '_data/') +data_folder = os.path.join(os.path.dirname(__file__), "_data/") + class ModelyTrainingTest(unittest.TestCase): def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): @@ -29,162 +37,452 @@ def TestAlmostEqual(self, data1, data2, precision=4): def test_losses_compare(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out', Fir(W=a)(input1.last())) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out", Fir(W=a)(input1.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - dataset = {'in1': [1,1,1,1,1,1,1,1,1,1], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [5,5,5,5,5,5,5,5,5,5]} - test.loadData(name='dataset', source=dataset) - test.trainAndAnalyze(optimizer='SGD', num_of_epochs=5, lr=0.5, splits=[70,20,10]) - self.TestAlmostEqual( [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual( [[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error1']['train']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error1']['val']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error2']['train']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['total']['mean_error'], - (test._training['error1']['val'][-1] + test._training['error2']['val'][-1]) / 2.0) - self.TestAlmostEqual(test.performance['dataset_test']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['total']['mean_error'], (test._training['error1']['val'][-1]+test._training['error2']['val'][-1])/2.0) + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [5, 5, 5, 5, 5, 5, 5, 5, 5, 5], + } + test.loadData(name="dataset", source=dataset) + test.trainAndAnalyze( + optimizer="SGD", num_of_epochs=5, lr=0.5, splits=[70, 20, 10] + ) + self.TestAlmostEqual( + [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error2"]["train"] + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error2"]["val"] + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["total"]["mean_error"], + (test._training["error1"]["val"][-1] + test._training["error2"]["val"][-1]) + / 2.0, + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["total"]["mean_error"], + (test._training["error1"]["val"][-1] + test._training["error2"]["val"][-1]) + / 2.0, + ) test.neuralizeModel(clear_model=True) - test.trainAndAnalyze(optimizer='SGD', splits=[60,20,20], num_of_epochs=5, lr=0.5, train_batch_size=2) - self.TestAlmostEqual( [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual( [[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([6.0, 11.0, 6.0, 11.0, 6.0], test._training['error1']['train']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error1']['val']) - self.TestAlmostEqual([11.0, 6.0, 11.0, 6.0, 11.0], test._training['error2']['train']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['error2']['mse'], test._training['error2']['val'][-1]) + test.trainAndAnalyze( + optimizer="SGD", + splits=[60, 20, 20], + num_of_epochs=5, + lr=0.5, + train_batch_size=2, + ) + self.TestAlmostEqual( + [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [6.0, 11.0, 6.0, 11.0, 6.0], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [11.0, 6.0, 11.0, 6.0, 11.0], test._training["error2"]["train"] + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error2"]["val"] + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) def test_losses_compare_closed_loop_state(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[1]]) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[1]]) relation = Fir(W=a)(input1.last()) relation.closedLoop(input1) - output1 = Output('out', relation) + output1 = Output("out", relation) - test = Modely(visualizer=None,seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + test = Modely(visualizer=None, seed=42) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - dataset = {'in1': [1,1,1,1,1,1,1,1,1,1], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [5,5,5,5,5,5,5,5,5,5]} - test.loadData(name='dataset', source=dataset) - test.trainAndAnalyze(optimizer='SGD', num_of_epochs=5, lr=0.5, shuffle_data=False, splits=[70,20,10]) - self.TestAlmostEqual([[[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual([[[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error1']['train']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error1']['val']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error2']['train']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['total']['mean_error'], - (test._training['error1']['val'][-1] + test._training['error2']['val'][-1]) / 2.0) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['total']['mean_error'], (test._training['error1']['val'][-1]+test._training['error2']['val'][-1])/2.0) + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [5, 5, 5, 5, 5, 5, 5, 5, 5, 5], + } + test.loadData(name="dataset", source=dataset) + test.trainAndAnalyze( + optimizer="SGD", + num_of_epochs=5, + lr=0.5, + shuffle_data=False, + splits=[70, 20, 10], + ) + self.TestAlmostEqual( + [[[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]]], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [[[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]]], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [[[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]]], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error2"]["train"] + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error2"]["val"] + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["total"]["mean_error"], + (test._training["error1"]["val"][-1] + test._training["error2"]["val"][-1]) + / 2.0, + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["total"]["mean_error"], + (test._training["error1"]["val"][-1] + test._training["error2"]["val"][-1]) + / 2.0, + ) test.neuralizeModel(clear_model=True) - test.trainAndAnalyze(optimizer='SGD', splits=[60,20,20], num_of_epochs=5, lr=0.5, train_batch_size=2) - self.TestAlmostEqual([[[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual([[[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([6.0, 11.0, 6.0, 11.0, 6.0], test._training['error1']['train']) - self.TestAlmostEqual([16.0, 1.0, 16.0, 1.0, 16.0], test._training['error1']['val']) - self.TestAlmostEqual([11.0, 6.0, 11.0, 6.0, 11.0], test._training['error2']['train']) - self.TestAlmostEqual([1.0, 16.0, 1.0, 16.0, 1.0], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_test']['error2']['mse'], test._training['error2']['val'][-1]) + test.trainAndAnalyze( + optimizer="SGD", + splits=[60, 20, 20], + num_of_epochs=5, + lr=0.5, + train_batch_size=2, + ) + self.TestAlmostEqual( + [[[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]]], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [[[[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]], [[6.0]]]], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [[[[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]], [[5.0]]]], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [6.0, 11.0, 6.0, 11.0, 6.0], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [16.0, 1.0, 16.0, 1.0, 16.0], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [11.0, 6.0, 11.0, 6.0, 11.0], test._training["error2"]["train"] + ) + self.TestAlmostEqual( + [1.0, 16.0, 1.0, 16.0, 1.0], test._training["error2"]["val"] + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_test"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) test.neuralizeModel(clear_model=True) with self.assertRaises(ValueError): - test.trainAndAnalyze(optimizer='SGD', splits=[60,20,20], num_of_epochs=5, lr=0.5, train_batch_size=2, prediction_samples=4) + test.trainAndAnalyze( + optimizer="SGD", + splits=[60, 20, 20], + num_of_epochs=5, + lr=0.5, + train_batch_size=2, + prediction_samples=4, + ) test.neuralizeModel(clear_model=True) - test.trainAndAnalyze(optimizer='SGD', splits=[50, 50, 0], num_of_epochs=5, lr=0.001, train_batch_size=2, prediction_samples=3) - - self.TestAlmostEqual([[[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[[1.1285]], [[1.1285]]], [[[1.2735]], [[1.2735]]], [[[1.4371]], [[1.4371]]], [[[1.6217]], [[1.6217]]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual([[[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([1.0, 0.8768, 0.75615, 0.64057, 0.533], test._training['error1']['train']) - self.TestAlmostEqual([0.8768, 0.75615, 0.64057, 0.533, 0.4368], test._training['error1']['val']) - self.TestAlmostEqual([16.0, 15.4923, 14.9602, 14.4059, 13.8328], test._training['error2']['train']) - self.TestAlmostEqual([15.4923, 14.9602, 14.4059, 13.8328, 13.2457], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) + test.trainAndAnalyze( + optimizer="SGD", + splits=[50, 50, 0], + num_of_epochs=5, + lr=0.001, + train_batch_size=2, + prediction_samples=3, + ) + + self.TestAlmostEqual( + [ + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + ], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [ + [[[1.1285]], [[1.1285]]], + [[[1.2735]], [[1.2735]]], + [[[1.4371]], [[1.4371]]], + [[[1.6217]], [[1.6217]]], + ], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [ + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + ], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [1.0, 0.8768, 0.75615, 0.64057, 0.533], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [0.8768, 0.75615, 0.64057, 0.533, 0.4368], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [16.0, 15.4923, 14.9602, 14.4059, 13.8328], + test._training["error2"]["train"], + ) + self.TestAlmostEqual( + [15.4923, 14.9602, 14.4059, 13.8328, 13.2457], + test._training["error2"]["val"], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) def test_losses_compare_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out', Fir(W=a)(input1.last())) - - test = Modely(visualizer=None,seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out", Fir(W=a)(input1.last())) + + test = Modely(visualizer=None, seed=42) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - dataset = {'in1': [1,1,1,1,1,1,1,1,1,1], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [5,5,5,5,5,5,5,5,5,5]} - test.loadData(name='dataset', source=dataset) - test.trainAndAnalyze(optimizer='SGD', splits=[50, 50, 0], num_of_epochs=5, lr=0.001, train_batch_size=2, prediction_samples=3, closed_loop={'in1': 'out'}) + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [5, 5, 5, 5, 5, 5, 5, 5, 5, 5], + } + test.loadData(name="dataset", source=dataset) + test.trainAndAnalyze( + optimizer="SGD", + splits=[50, 50, 0], + num_of_epochs=5, + lr=0.001, + train_batch_size=2, + prediction_samples=3, + closed_loop={"in1": "out"}, + ) - self.TestAlmostEqual([[[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]], [[[2.0]], [[2.0]]]], test.prediction['dataset_train']['error1']['A']) - self.TestAlmostEqual([[[[1.1285]], [[1.1285]]], [[[1.2735]], [[1.2735]]], [[[1.4371]], [[1.4371]]], [[[1.6217]], [[1.6217]]]] ,test.prediction['dataset_train']['error1']['B']) - self.TestAlmostEqual([[[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]], [[[5.0]], [[5.0]]]], test.prediction['dataset_train']['error2']['A']) - self.TestAlmostEqual([1.0, 0.8768, 0.75615, 0.64057, 0.533], test._training['error1']['train']) - self.TestAlmostEqual([0.8768, 0.75615, 0.64057, 0.533, 0.4368], test._training['error1']['val']) - self.TestAlmostEqual([16.0, 15.4923, 14.9602, 14.4059, 13.8328], test._training['error2']['train']) - self.TestAlmostEqual([15.4923, 14.9602, 14.4059, 13.8328, 13.2457], test._training['error2']['val']) - self.TestAlmostEqual(test.performance['dataset_val']['error1']['mse'], test._training['error1']['val'][-1]) - self.TestAlmostEqual(test.performance['dataset_val']['error2']['mse'], test._training['error2']['val'][-1]) + self.TestAlmostEqual( + [ + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + [[[2.0]], [[2.0]]], + ], + test.prediction["dataset_train"]["error1"]["A"], + ) + self.TestAlmostEqual( + [ + [[[1.1285]], [[1.1285]]], + [[[1.2735]], [[1.2735]]], + [[[1.4371]], [[1.4371]]], + [[[1.6217]], [[1.6217]]], + ], + test.prediction["dataset_train"]["error1"]["B"], + ) + self.TestAlmostEqual( + [ + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + [[[5.0]], [[5.0]]], + ], + test.prediction["dataset_train"]["error2"]["A"], + ) + self.TestAlmostEqual( + [1.0, 0.8768, 0.75615, 0.64057, 0.533], test._training["error1"]["train"] + ) + self.TestAlmostEqual( + [0.8768, 0.75615, 0.64057, 0.533, 0.4368], test._training["error1"]["val"] + ) + self.TestAlmostEqual( + [16.0, 15.4923, 14.9602, 14.4059, 13.8328], + test._training["error2"]["train"], + ) + self.TestAlmostEqual( + [15.4923, 14.9602, 14.4059, 13.8328, 13.2457], + test._training["error2"]["val"], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error1"]["mse"], + test._training["error1"]["val"][-1], + ) + self.TestAlmostEqual( + test.performance["dataset_val"]["error2"]["mse"], + test._training["error2"]["val"][-1], + ) def test_categorical_crossentropy(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2', dimensions=5) - - k = Parameter('k', values=[[0.1,0.1,0.1,0.1,0.6]]) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2", dimensions=5) + + k = Parameter("k", values=[[0.1, 0.1, 0.1, 0.1, 0.6]]) linear = Linear(output_dimension=5, W=k, b=False)(input1.last()) - output = Output('out', linear) + output = Output("out", linear) test = Modely(visualizer=None, seed=42, log_internal=True) - test.addModel('model', output) - test.addMinimize('error1', output, target1.last(), loss_function='cross_entropy') - test.addMinimize('error2', output, target2.last(), loss_function='cross_entropy') + test.addModel("model", output) + test.addMinimize( + "error1", output, target1.last(), loss_function="cross_entropy" + ) + test.addMinimize( + "error2", output, target2.last(), loss_function="cross_entropy" + ) test.neuralizeModel() - - dataset = {'in1': [1], 'out1': [4], 'out2':[[0.0,0.0,0.0,0.0,1.0]]} - test.loadData(name='dataset', source=dataset) - test.trainAndAnalyze(optimizer='SGD', train_dataset='dataset', train_batch_size=1, num_of_epochs=1, lr=0.0) + + dataset = {"in1": [1], "out1": [4], "out2": [[0.0, 0.0, 0.0, 0.0, 1.0]]} + test.loadData(name="dataset", source=dataset) + test.trainAndAnalyze( + optimizer="SGD", + train_dataset="dataset", + train_batch_size=1, + num_of_epochs=1, + lr=0.0, + ) loss = torch.nn.CrossEntropyLoss() - self.assertAlmostEqual(1.2314292192459106, loss(torch.tensor(test.prediction['dataset']['error1']['A']).squeeze(), torch.tensor(test.prediction['dataset']['error1']['B'], dtype=torch.long).squeeze()).item()) - self.assertAlmostEqual(1.2314292192459106, loss(torch.tensor(test.prediction['dataset']['error2']['A']).squeeze(), torch.tensor(test.prediction['dataset']['error2']['B'], dtype=torch.float32).squeeze()).item()) + self.assertAlmostEqual( + 1.2314292192459106, + loss( + torch.tensor(test.prediction["dataset"]["error1"]["A"]).squeeze(), + torch.tensor( + test.prediction["dataset"]["error1"]["B"], dtype=torch.long + ).squeeze(), + ).item(), + ) + self.assertAlmostEqual( + 1.2314292192459106, + loss( + torch.tensor(test.prediction["dataset"]["error2"]["A"]).squeeze(), + torch.tensor( + test.prediction["dataset"]["error2"]["B"], dtype=torch.float32 + ).squeeze(), + ).item(), + ) diff --git a/tests/test_model_predict.py b/tests/test_model_predict.py index 5ebf8f05..9b4bdc17 100644 --- a/tests/test_model_predict.py +++ b/tests/test_model_predict.py @@ -1,4 +1,7 @@ -import sys, os, torch, unittest +import sys +import os +import torch +import unittest import numpy as np from nnodely import * @@ -17,25 +20,35 @@ # The second dimension indicates the output time dimension for each sample. # The third is the size of the signal + def myfun(x, P): - return x*P + return x * P + -def myfun2(a, b ,c): +def myfun2(a, b, c): import torch + return torch.sin(a + b) * c + def myfun3(a, b, p1, p2): import torch - at = torch.transpose(a[:, :, 0:2],1,2) + + at = torch.transpose(a[:, :, 0:2], 1, 2) bt = torch.transpose(b, 1, 2) - return torch.matmul(p1,at+bt)+p2.t() + return torch.matmul(p1, at + bt) + p2.t() + class ModelyPredictTest(unittest.TestCase): - def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: - self.assertEqual(len(data1),len(data2)) + self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.TestAlmostEqual(pred, label, precision=precision) else: @@ -43,681 +56,942 @@ def TestAlmostEqual(self, data1, data2, precision=4): def test_single_in(self): NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') + in1 = Input("in1") + in2 = Input("in2") out_fun = Fir(in1.tw(0.1)) + Fir(in2.last()) - out = Output('out', out_fun) + out = Output("out", out_fun) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.01) - results = test({'in1': [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]],'in2': [[5]]}) - self.assertEqual(1, len(results['out'])) - self.TestAlmostEqual([33.74938201904297], results['out']) - results = test({'in1': [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]], 'in2': [[5], [7]]}) - self.assertEqual(2, len(results['out'])) - self.TestAlmostEqual([33.74938201904297, 40.309326171875], results['out']) - results = test({'in1': [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12]], 'in2': [[5], [7], [9]]}) - self.assertEqual(3, len(results['out'])) - self.TestAlmostEqual([33.74938201904297, 40.309326171875, 46.86927032470703], results['out']) + results = test( + {"in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]], "in2": [[5]]} + ) + self.assertEqual(1, len(results["out"])) + self.TestAlmostEqual([33.74938201904297], results["out"]) + results = test( + { + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]], + "in2": [[5], [7]], + } + ) + self.assertEqual(2, len(results["out"])) + self.TestAlmostEqual([33.74938201904297, 40.309326171875], results["out"]) + results = test( + { + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12]], + "in2": [[5], [7], [9]], + } + ) + self.assertEqual(3, len(results["out"])) + self.TestAlmostEqual( + [33.74938201904297, 40.309326171875, 46.86927032470703], results["out"] + ) def test_activation(self): NeuObj.clearNames() - in1 = Input('in1') + in1 = Input("in1") out_fun = ELU(in1.last()) + Relu(in1.last()) + Tanh(in1.last()) - out = Output('out', out_fun) + out = Output("out", out_fun) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel() - results = test({'in1': [-1, -0.5, 0, 0.2, 2, 10]}) - self.assertEqual(6, len(results['out'])) - self.TestAlmostEqual([-1.3937146663665771,-0.8555865287780762,0,0.5973753333091736,4.964027404785156,21.0], results['out']) + results = test({"in1": [-1, -0.5, 0, 0.2, 2, 10]}) + self.assertEqual(6, len(results["out"])) + self.TestAlmostEqual( + [ + -1.3937146663665771, + -0.8555865287780762, + 0, + 0.5973753333091736, + 4.964027404785156, + 21.0, + ], + results["out"], + ) def test_single_in_window(self): NeuObj.clearNames() # Here there is more sample for each time step but the dimensions of the input is 1 - in1 = Input('in1') + in1 = Input("in1") # Finestre nel tempo - out1 = Output('x.tw(1)', in1.tw(1)) - out2 = Output('x.tw([-1,0])', in1.tw([-1, 0])) - out3 = Output('x.tw([-3,0])', in1.tw([-3, 0])) - out4 = Output('x.tw([1,3])', in1.tw([1, 3])) - out5 = Output('x.tw([-1,3])', in1.tw([-1, 3])) - out6 = Output('x.tw([0,1])', in1.tw([0, 1])) - out7 = Output('x.tw([-3,-2])', in1.tw([-3, -2])) + out1 = Output("x.tw(1)", in1.tw(1)) + out2 = Output("x.tw([-1,0])", in1.tw([-1, 0])) + out3 = Output("x.tw([-3,0])", in1.tw([-3, 0])) + out4 = Output("x.tw([1,3])", in1.tw([1, 3])) + out5 = Output("x.tw([-1,3])", in1.tw([-1, 3])) + out6 = Output("x.tw([0,1])", in1.tw([0, 1])) + out7 = Output("x.tw([-3,-2])", in1.tw([-3, -2])) ## TODO: adjust the z function - # Finesatre nei samples - out8 = Output('x.z(-1)', in1.z(-1)) - out9 = Output('x.z(0)', in1.z(0)) - out10 = Output('x.z(2)', in1.z(2)) - out11 = Output('x.sw([-1,0])', in1.sw([-1, 0])) - out12 = Output('x.sw([1,2])', in1.sw([1, 2])) - out13 = Output('x.sw([-3,1])', in1.sw([-3, 1])) - out14 = Output('x.sw([-3,-2])', in1.sw([-3, -2])) - out15 = Output('x.sw([0,1])', in1.sw([0, 1])) + # Finesatre nei samples + out8 = Output("x.z(-1)", in1.z(-1)) + out9 = Output("x.z(0)", in1.z(0)) + out10 = Output("x.z(2)", in1.z(2)) + out11 = Output("x.sw([-1,0])", in1.sw([-1, 0])) + out12 = Output("x.sw([1,2])", in1.sw([1, 2])) + out13 = Output("x.sw([-3,1])", in1.sw([-3, 1])) + out14 = Output("x.sw([-3,-2])", in1.sw([-3, -2])) + out15 = Output("x.sw([0,1])", in1.sw([0, 1])) test = Modely(visualizer=None, seed=1) - #test.addModel('out',[out0,out1,out2,out3,out4,out5,out6,out7,out11,out12,out13,out14,out15]) - test.addModel('out',[out1, out2, out3, out4, out5, out6, out7, out8, out9, out10, out11, out12, out13, out14, out15]) + # test.addModel('out',[out0,out1,out2,out3,out4,out5,out6,out7,out11,out12,out13,out14,out15]) + test.addModel( + "out", + [ + out1, + out2, + out3, + out4, + out5, + out6, + out7, + out8, + out9, + out10, + out11, + out12, + out13, + out14, + out15, + ], + ) test.neuralizeModel(1) # Time -2,-1,0,1,2,3 # zero represent the last passed instant - results = test({'in1': [[-2],[-1],[0],[1],[7],[3]]}) + results = test({"in1": [[-2], [-1], [0], [1], [7], [3]]}) # Time window - self.assertEqual((1,), np.array(results['x.tw(1)']).shape) - self.TestAlmostEqual([0], results['x.tw(1)']) - self.assertEqual((1,), np.array(results['x.tw([-1,0])']).shape) - self.TestAlmostEqual([0], results['x.tw([-1,0])']) - self.assertEqual((1, 3), np.array(results['x.tw([-3,0])']).shape) - self.TestAlmostEqual([[-2, -1, 0]], results['x.tw([-3,0])']) - self.assertEqual((1, 2), np.array(results['x.tw([1,3])']).shape) - self.TestAlmostEqual([[7, 3]], results['x.tw([1,3])']) - self.assertEqual((1, 4), np.array(results['x.tw([-1,3])']).shape) - self.TestAlmostEqual([[0, 1, 7, 3]], results['x.tw([-1,3])']) - self.assertEqual((1,), np.array(results['x.tw([0,1])']).shape) - self.TestAlmostEqual([1], results['x.tw([0,1])']) - self.assertEqual((1,), np.array(results['x.tw([-3,-2])']).shape) - self.TestAlmostEqual([-2],results['x.tw([-3,-2])']) + self.assertEqual((1,), np.array(results["x.tw(1)"]).shape) + self.TestAlmostEqual([0], results["x.tw(1)"]) + self.assertEqual((1,), np.array(results["x.tw([-1,0])"]).shape) + self.TestAlmostEqual([0], results["x.tw([-1,0])"]) + self.assertEqual((1, 3), np.array(results["x.tw([-3,0])"]).shape) + self.TestAlmostEqual([[-2, -1, 0]], results["x.tw([-3,0])"]) + self.assertEqual((1, 2), np.array(results["x.tw([1,3])"]).shape) + self.TestAlmostEqual([[7, 3]], results["x.tw([1,3])"]) + self.assertEqual((1, 4), np.array(results["x.tw([-1,3])"]).shape) + self.TestAlmostEqual([[0, 1, 7, 3]], results["x.tw([-1,3])"]) + self.assertEqual((1,), np.array(results["x.tw([0,1])"]).shape) + self.TestAlmostEqual([1], results["x.tw([0,1])"]) + self.assertEqual((1,), np.array(results["x.tw([-3,-2])"]).shape) + self.TestAlmostEqual([-2], results["x.tw([-3,-2])"]) # Sample window - self.assertEqual((1,), np.array(results['x.z(-1)']).shape) - self.TestAlmostEqual([1], results['x.z(-1)']) - self.assertEqual((1,), np.array(results['x.z(0)']).shape) - self.TestAlmostEqual([0], results['x.z(0)']) - self.assertEqual((1,), np.array(results['x.z(2)']).shape) - self.TestAlmostEqual([-2], results['x.z(2)']) - self.assertEqual((1,), np.array(results['x.sw([-1,0])']).shape) - self.TestAlmostEqual([0], results['x.sw([-1,0])']) - self.assertEqual((1,), np.array(results['x.sw([1,2])']).shape) - self.TestAlmostEqual([7], results['x.sw([1,2])']) - self.assertEqual((1,4), np.array(results['x.sw([-3,1])']).shape) - self.TestAlmostEqual([[-2,-1,0,1]], results['x.sw([-3,1])']) - self.assertEqual((1,), np.array(results['x.sw([-3,-2])']).shape) - self.TestAlmostEqual([-2], results['x.sw([-3,-2])']) - self.assertEqual((1,), np.array(results['x.sw([0,1])']).shape) - self.TestAlmostEqual([1],results['x.sw([0,1])']) - + self.assertEqual((1,), np.array(results["x.z(-1)"]).shape) + self.TestAlmostEqual([1], results["x.z(-1)"]) + self.assertEqual((1,), np.array(results["x.z(0)"]).shape) + self.TestAlmostEqual([0], results["x.z(0)"]) + self.assertEqual((1,), np.array(results["x.z(2)"]).shape) + self.TestAlmostEqual([-2], results["x.z(2)"]) + self.assertEqual((1,), np.array(results["x.sw([-1,0])"]).shape) + self.TestAlmostEqual([0], results["x.sw([-1,0])"]) + self.assertEqual((1,), np.array(results["x.sw([1,2])"]).shape) + self.TestAlmostEqual([7], results["x.sw([1,2])"]) + self.assertEqual((1, 4), np.array(results["x.sw([-3,1])"]).shape) + self.TestAlmostEqual([[-2, -1, 0, 1]], results["x.sw([-3,1])"]) + self.assertEqual((1,), np.array(results["x.sw([-3,-2])"]).shape) + self.TestAlmostEqual([-2], results["x.sw([-3,-2])"]) + self.assertEqual((1,), np.array(results["x.sw([0,1])"]).shape) + self.TestAlmostEqual([1], results["x.sw([0,1])"]) + def test_single_in_window_offset(self): NeuObj.clearNames() # Here there is more sample for each time step but the dimensions of the input is 1 - in1 = Input('in1') + in1 = Input("in1") # Finestre nel tempo - out1 = Output('x.tw(1)', in1.tw(1,offset=-1)) - out2 = Output('x.tw([-1,0])', in1.tw([-1, 0],offset=-1)) - out3 = Output('x.tw([1,3])', in1.tw([1, 3],offset=1)) - out4 = Output('x.tw([-3,-2])', in1.tw([-3, -2],offset=-3)) + out1 = Output("x.tw(1)", in1.tw(1, offset=-1)) + out2 = Output("x.tw([-1,0])", in1.tw([-1, 0], offset=-1)) + out3 = Output("x.tw([1,3])", in1.tw([1, 3], offset=1)) + out4 = Output("x.tw([-3,-2])", in1.tw([-3, -2], offset=-3)) # Finesatre nei samples - out5 = Output('x.sw([-1,0])', in1.sw([-1, 0],offset=-1)) - out6 = Output('x.sw([-3,1])', in1.sw([-3, 1],offset=-3)) - out7 = Output('x.sw([0,1])', in1.sw([0, 1],offset=0)) - out8 = Output('x.sw([-3, 3])', in1.sw([-3, 3], offset=2)) - out9 = Output('x.sw([-3, 3])-2', in1.sw([-3, 3], offset=-1)) + out5 = Output("x.sw([-1,0])", in1.sw([-1, 0], offset=-1)) + out6 = Output("x.sw([-3,1])", in1.sw([-3, 1], offset=-3)) + out7 = Output("x.sw([0,1])", in1.sw([0, 1], offset=0)) + out8 = Output("x.sw([-3, 3])", in1.sw([-3, 3], offset=2)) + out9 = Output("x.sw([-3, 3])-2", in1.sw([-3, 3], offset=-1)) - test = Modely(visualizer = None, seed = 1) - test.addModel('out',[out1,out2,out3,out4,out5,out6,out7,out8,out9]) + test = Modely(visualizer=None, seed=1) + test.addModel("out", [out1, out2, out3, out4, out5, out6, out7, out8, out9]) test.neuralizeModel(1) # Time -2,-1,0,1,2,3 # zero represent the last passed instant - results = test({'in1': [[-2],[-1],[0],[1],[7],[3]]}) + results = test({"in1": [[-2], [-1], [0], [1], [7], [3]]}) # Time window - self.assertEqual((1,), np.array(results['x.tw(1)']).shape) - self.TestAlmostEqual([0], results['x.tw(1)']) - self.assertEqual((1,), np.array(results['x.tw([-1,0])']).shape) - self.TestAlmostEqual([0], results['x.tw([-1,0])']) - self.assertEqual((1,2), np.array(results['x.tw([1,3])']).shape) - self.TestAlmostEqual([[0, -4]], results['x.tw([1,3])']) - self.assertEqual((1,), np.array(results['x.tw([-3,-2])']).shape) - self.TestAlmostEqual([0],results['x.tw([-3,-2])']) + self.assertEqual((1,), np.array(results["x.tw(1)"]).shape) + self.TestAlmostEqual([0], results["x.tw(1)"]) + self.assertEqual((1,), np.array(results["x.tw([-1,0])"]).shape) + self.TestAlmostEqual([0], results["x.tw([-1,0])"]) + self.assertEqual((1, 2), np.array(results["x.tw([1,3])"]).shape) + self.TestAlmostEqual([[0, -4]], results["x.tw([1,3])"]) + self.assertEqual((1,), np.array(results["x.tw([-3,-2])"]).shape) + self.TestAlmostEqual([0], results["x.tw([-3,-2])"]) # # Sample window - self.assertEqual((1,), np.array(results['x.sw([-1,0])']).shape) - self.TestAlmostEqual([0], results['x.sw([-1,0])']) - self.assertEqual((1,4), np.array(results['x.sw([-3,1])']).shape) - self.TestAlmostEqual([[0,1,2,3]], results['x.sw([-3,1])']) - self.assertEqual((1,), np.array(results['x.sw([0,1])']).shape) - self.TestAlmostEqual([0],results['x.sw([0,1])']) - self.assertEqual((1,6), np.array(results['x.sw([-3, 3])']).shape) - self.TestAlmostEqual([[-5,-4,-3,-2,4,0]],results['x.sw([-3, 3])']) - self.assertEqual((1,6), np.array(results['x.sw([-3, 3])-2']).shape) - self.TestAlmostEqual([[-2,-1,0,1,7,3]],results['x.sw([-3, 3])-2']) - + self.assertEqual((1,), np.array(results["x.sw([-1,0])"]).shape) + self.TestAlmostEqual([0], results["x.sw([-1,0])"]) + self.assertEqual((1, 4), np.array(results["x.sw([-3,1])"]).shape) + self.TestAlmostEqual([[0, 1, 2, 3]], results["x.sw([-3,1])"]) + self.assertEqual((1,), np.array(results["x.sw([0,1])"]).shape) + self.TestAlmostEqual([0], results["x.sw([0,1])"]) + self.assertEqual((1, 6), np.array(results["x.sw([-3, 3])"]).shape) + self.TestAlmostEqual([[-5, -4, -3, -2, 4, 0]], results["x.sw([-3, 3])"]) + self.assertEqual((1, 6), np.array(results["x.sw([-3, 3])-2"]).shape) + self.TestAlmostEqual([[-2, -1, 0, 1, 7, 3]], results["x.sw([-3, 3])-2"]) + def test_multi_in_window_offset(self): NeuObj.clearNames() # Here there is more sample for each time step but the dimensions of the input is 1 - in1 = Input('in1',dimensions=3) + in1 = Input("in1", dimensions=3) # Finestre nel tempo - out1 = Output('x.tw(1)', in1.tw(1, offset=-1)) - out2 = Output('x.tw([-1,0])', in1.tw([-1, 0], offset=-1)) - out3 = Output('x.tw([1,3])', in1.tw([1, 3], offset=1)) - out4 = Output('x.tw([-3,-2])', in1.tw([-3, -2], offset=-3)) + out1 = Output("x.tw(1)", in1.tw(1, offset=-1)) + out2 = Output("x.tw([-1,0])", in1.tw([-1, 0], offset=-1)) + out3 = Output("x.tw([1,3])", in1.tw([1, 3], offset=1)) + out4 = Output("x.tw([-3,-2])", in1.tw([-3, -2], offset=-3)) # Finesatre nei samples - out5 = Output('x.sw([-1,0])', in1.sw([-1, 0], offset=-1)) - out6 = Output('x.sw([-3,1])', in1.sw([-3, 1], offset=-3)) - out7 = Output('x.sw([0,1])', in1.sw([0, 1], offset=0)) - out8 = Output('x.sw([-3, 3])', in1.sw([-3, 3], offset=2)) - out9 = Output('x.sw([-3, 3])-2', in1.sw([-3, 3], offset=-1)) + out5 = Output("x.sw([-1,0])", in1.sw([-1, 0], offset=-1)) + out6 = Output("x.sw([-3,1])", in1.sw([-3, 1], offset=-3)) + out7 = Output("x.sw([0,1])", in1.sw([0, 1], offset=0)) + out8 = Output("x.sw([-3, 3])", in1.sw([-3, 3], offset=2)) + out9 = Output("x.sw([-3, 3])-2", in1.sw([-3, 3], offset=-1)) - test = Modely(visualizer = None, seed = 1) - test.addModel('out',[out1, out2, out3, out4, out5, out6, out7, out8, out9]) + test = Modely(visualizer=None, seed=1) + test.addModel("out", [out1, out2, out3, out4, out5, out6, out7, out8, out9]) test.neuralizeModel(1) # Single input # Time -2, -1, 0, 1, 2, 3 # zero represent the last passed instant - results = test({'in1': [[-2,3,4],[-1,2,2],[0,0,0],[1,2,3],[2,7,3],[3,3,3]]}) + results = test( + { + "in1": [ + [-2, 3, 4], + [-1, 2, 2], + [0, 0, 0], + [1, 2, 3], + [2, 7, 3], + [3, 3, 3], + ] + } + ) # Time window - self.assertEqual((1,1,3), np.array(results['x.tw(1)']).shape) - self.TestAlmostEqual([[[0,0,0]]], results['x.tw(1)']) - self.assertEqual((1,1,3), np.array(results['x.tw([-1,0])']).shape) - self.TestAlmostEqual([[[0,0,0]]], results['x.tw([-1,0])']) - self.assertEqual((1,2,3), np.array(results['x.tw([1,3])']).shape) - self.TestAlmostEqual([[[0,0,0], [1,-4,0]]], results['x.tw([1,3])']) - self.assertEqual((1,1,3), np.array(results['x.tw([-3,-2])']).shape) - self.TestAlmostEqual([[[0,0,0]]], results['x.tw([-3,-2])']) + self.assertEqual((1, 1, 3), np.array(results["x.tw(1)"]).shape) + self.TestAlmostEqual([[[0, 0, 0]]], results["x.tw(1)"]) + self.assertEqual((1, 1, 3), np.array(results["x.tw([-1,0])"]).shape) + self.TestAlmostEqual([[[0, 0, 0]]], results["x.tw([-1,0])"]) + self.assertEqual((1, 2, 3), np.array(results["x.tw([1,3])"]).shape) + self.TestAlmostEqual([[[0, 0, 0], [1, -4, 0]]], results["x.tw([1,3])"]) + self.assertEqual((1, 1, 3), np.array(results["x.tw([-3,-2])"]).shape) + self.TestAlmostEqual([[[0, 0, 0]]], results["x.tw([-3,-2])"]) # # Sample window - self.assertEqual((1,1,3), np.array(results['x.sw([-1,0])']).shape) - self.TestAlmostEqual([[[0,0,0]]], results['x.sw([-1,0])']) - self.assertEqual((1,4,3), np.array(results['x.sw([-3,1])']).shape) - self.TestAlmostEqual([[[0,0,0], [1,-1,-2], [2,-3,-4], [3,-1,-1]]], results['x.sw([-3,1])']) - self.assertEqual((1,1,3), np.array(results['x.sw([0,1])']).shape) - self.TestAlmostEqual([[[0,0,0]]], results['x.sw([0,1])']) - self.assertEqual((1,6,3), np.array(results['x.sw([-3, 3])']).shape) - self.TestAlmostEqual([[[-5,0,1],[-4,-1,-1], [-3,-3,-3], [-2,-1,0], [-1,4,0], [0,0,0]]], results['x.sw([-3, 3])']) - self.assertEqual((1,6,3), np.array(results['x.sw([-3, 3])-2']).shape) - self.TestAlmostEqual([[[-2,3,4],[-1,2,2],[0,0,0],[1,2,3],[2,7,3],[3,3,3]]], results['x.sw([-3, 3])-2']) + self.assertEqual((1, 1, 3), np.array(results["x.sw([-1,0])"]).shape) + self.TestAlmostEqual([[[0, 0, 0]]], results["x.sw([-1,0])"]) + self.assertEqual((1, 4, 3), np.array(results["x.sw([-3,1])"]).shape) + self.TestAlmostEqual( + [[[0, 0, 0], [1, -1, -2], [2, -3, -4], [3, -1, -1]]], + results["x.sw([-3,1])"], + ) + self.assertEqual((1, 1, 3), np.array(results["x.sw([0,1])"]).shape) + self.TestAlmostEqual([[[0, 0, 0]]], results["x.sw([0,1])"]) + self.assertEqual((1, 6, 3), np.array(results["x.sw([-3, 3])"]).shape) + self.TestAlmostEqual( + [ + [ + [-5, 0, 1], + [-4, -1, -1], + [-3, -3, -3], + [-2, -1, 0], + [-1, 4, 0], + [0, 0, 0], + ] + ], + results["x.sw([-3, 3])"], + ) + self.assertEqual((1, 6, 3), np.array(results["x.sw([-3, 3])-2"]).shape) + self.TestAlmostEqual( + [[[-2, 3, 4], [-1, 2, 2], [0, 0, 0], [1, 2, 3], [2, 7, 3], [3, 3, 3]]], + results["x.sw([-3, 3])-2"], + ) # Multi input - results = test({'in1': [[-2, 3, 4], [-1, 2, 2], [0, 0, 0], [1, 2, 3], [2, 7, 3], [3, 3, 3], [2, 2, 2]]}) - self.assertEqual((2,6,3), np.array(results['x.sw([-3, 3])']).shape) - self.TestAlmostEqual([[[-5,0,1], [-4,-1,-1], [-3,-3,-3], [-2,-1,0], [-1,4,0], [0,0,0]], - [[-3,0,0], [-2,-2,-2], [-1,0,1], [0,5,1], [1,1,1], [0,0,0]]], results['x.sw([-3, 3])']) - self.assertEqual((2,6,3), np.array(results['x.sw([-3, 3])-2']).shape) - self.TestAlmostEqual([[[-2,3,4],[-1,2,2],[0,0,0],[1,2,3],[2,7,3],[3,3,3]], - [[-2,0,-1],[-1,-2,-3],[0,0,0],[1,5,0],[2,1,0],[1,0,-1]]], results['x.sw([-3, 3])-2']) - + results = test( + { + "in1": [ + [-2, 3, 4], + [-1, 2, 2], + [0, 0, 0], + [1, 2, 3], + [2, 7, 3], + [3, 3, 3], + [2, 2, 2], + ] + } + ) + self.assertEqual((2, 6, 3), np.array(results["x.sw([-3, 3])"]).shape) + self.TestAlmostEqual( + [ + [ + [-5, 0, 1], + [-4, -1, -1], + [-3, -3, -3], + [-2, -1, 0], + [-1, 4, 0], + [0, 0, 0], + ], + [[-3, 0, 0], [-2, -2, -2], [-1, 0, 1], [0, 5, 1], [1, 1, 1], [0, 0, 0]], + ], + results["x.sw([-3, 3])"], + ) + self.assertEqual((2, 6, 3), np.array(results["x.sw([-3, 3])-2"]).shape) + self.TestAlmostEqual( + [ + [[-2, 3, 4], [-1, 2, 2], [0, 0, 0], [1, 2, 3], [2, 7, 3], [3, 3, 3]], + [ + [-2, 0, -1], + [-1, -2, -3], + [0, 0, 0], + [1, 5, 0], + [2, 1, 0], + [1, 0, -1], + ], + ], + results["x.sw([-3, 3])-2"], + ) + def test_single_in_window_offset_aritmetic(self): NeuObj.clearNames() # Elementwise arithmetic, Activation, Trigonometric # the dimensions and time window remain unchanged, for the # binary operators must be equal - in1 = Input('in1') - in2 = Input('in2', dimensions=2) - out1 = Output('sum', in1.tw(1, offset=-1) + in1.tw([-1,0])) - out2 = Output('sub', in1.tw([1, 3], offset=1) - in1.tw([-3, -1], offset=-2)) - out3 = Output('mul', in1.tw([-2, 2]) * in1.tw([-3, 1], offset=-2)) + in1 = Input("in1") + in2 = Input("in2", dimensions=2) + out1 = Output("sum", in1.tw(1, offset=-1) + in1.tw([-1, 0])) + out2 = Output("sub", in1.tw([1, 3], offset=1) - in1.tw([-3, -1], offset=-2)) + out3 = Output("mul", in1.tw([-2, 2]) * in1.tw([-3, 1], offset=-2)) - out4 = Output('sum2', in2.tw(1, offset=-1) + in2.tw([-1,0])) - out5 = Output('sub2', in2.tw([1, 3], offset=1) - in2.tw([-3, -1], offset=-2)) - out6 = Output('mul2', in2.tw([-2, 2]) * in2.tw([-3, 1], offset=-2)) + out4 = Output("sum2", in2.tw(1, offset=-1) + in2.tw([-1, 0])) + out5 = Output("sub2", in2.tw([1, 3], offset=1) - in2.tw([-3, -1], offset=-2)) + out6 = Output("mul2", in2.tw([-2, 2]) * in2.tw([-3, 1], offset=-2)) test = Modely(visualizer=None) - test.addModel('out',[out1, out2, out3, out4, out5, out6]) + test.addModel("out", [out1, out2, out3, out4, out5, out6]) test.neuralizeModel(1) # Single input - #Time -2 -1 0 1 2 3 -2 -1 0 1 2 3 - results = test({'in1': [[1], [2], [8], [4], [-1], [6]], 'in2': [[-2, 3], [-1, 2], [0, 5], [1, 2], [2, 7], [3, 3]]}) - - self.assertEqual((1,), np.array(results['sum']).shape) - self.TestAlmostEqual([8], results['sum']) - self.assertEqual((1,2), np.array(results['sub']).shape) # [-1,6]+1 - [1,2]-2 - self.TestAlmostEqual([[1,7]], results['sub']) - self.assertEqual((1,4), np.array(results['mul']).shape) #[2, 8, 4, -1]*[1, 2, 8, 4]-2 - self.TestAlmostEqual([[-2,0,24,-2]], results['mul'])#[2, 8, 4, -1]*[-1, 0, 6, 2] - - self.assertEqual((1,1,2), np.array(results['sum2']).shape) - self.TestAlmostEqual([[[0,5]]], results['sum2']) - self.assertEqual((1,2,2), np.array(results['sub2']).shape) #[[2,7],[3,3]]-[2,7] - [[-2,3],[-1,2]]-[-1,2] - self.TestAlmostEqual([[[1,-1],[1,-4]]], results['sub2']) # [[0,0],[1,-4]] - [[-1,1],[0,0]] - #[[-1, 2], [0, 5], [1, 2], [2, 7]] * [[-2, 3], [-1, 2], [0, 5], [1, 2]]-[-1, 2] + # Time -2 -1 0 1 2 3 -2 -1 0 1 2 3 + results = test( + { + "in1": [[1], [2], [8], [4], [-1], [6]], + "in2": [[-2, 3], [-1, 2], [0, 5], [1, 2], [2, 7], [3, 3]], + } + ) + + self.assertEqual((1,), np.array(results["sum"]).shape) + self.TestAlmostEqual([8], results["sum"]) + self.assertEqual((1, 2), np.array(results["sub"]).shape) # [-1,6]+1 - [1,2]-2 + self.TestAlmostEqual([[1, 7]], results["sub"]) + self.assertEqual( + (1, 4), np.array(results["mul"]).shape + ) # [2, 8, 4, -1]*[1, 2, 8, 4]-2 + self.TestAlmostEqual( + [[-2, 0, 24, -2]], results["mul"] + ) # [2, 8, 4, -1]*[-1, 0, 6, 2] + + self.assertEqual((1, 1, 2), np.array(results["sum2"]).shape) + self.TestAlmostEqual([[[0, 5]]], results["sum2"]) + self.assertEqual( + (1, 2, 2), np.array(results["sub2"]).shape + ) # [[2,7],[3,3]]-[2,7] - [[-2,3],[-1,2]]-[-1,2] + self.TestAlmostEqual( + [[[1, -1], [1, -4]]], results["sub2"] + ) # [[0,0],[1,-4]] - [[-1,1],[0,0]] + # [[-1, 2], [0, 5], [1, 2], [2, 7]] * [[-2, 3], [-1, 2], [0, 5], [1, 2]]-[-1, 2] # [[-1, 2], [0, 5], [1, 2], [2, 7]] * [[-1, 1], [0, 0], [1, 3], [2, 0]] - self.assertEqual((1,4,2), np.array(results['mul2']).shape) - self.TestAlmostEqual([[[1, 2], [0, 0], [1, 6], [4, 0]]], results['mul2']) + self.assertEqual((1, 4, 2), np.array(results["mul2"]).shape) + self.TestAlmostEqual([[[1, 2], [0, 0], [1, 6], [4, 0]]], results["mul2"]) # Multi input # Time -2 -1 0 1 2 3 4 -2 -1 0 1 2 3 4 - results = test({'in1': [1, 2, 8, 4, -1, 6, 9], 'in2': [[-2, 3], [-1, 2], [0, 5], [1, 2], [2, 7], [3, 3], [0, 0]]}) - self.assertEqual((2,), np.array(results['sum']).shape) - self.TestAlmostEqual([8,4], results['sum']) + results = test( + { + "in1": [1, 2, 8, 4, -1, 6, 9], + "in2": [[-2, 3], [-1, 2], [0, 5], [1, 2], [2, 7], [3, 3], [0, 0]], + } + ) + self.assertEqual((2,), np.array(results["sum"]).shape) + self.TestAlmostEqual([8, 4], results["sum"]) # [6,9]-6 - [2,8]-8 = [0,3] - [-6,0] - self.assertEqual((2,2), np.array(results['sub']).shape) # [-1,6]+1 - [1,2]-2 - self.TestAlmostEqual([[1,7],[6,3]], results['sub']) - #[8, 4, -1, 6] * [2, 8, 4, -1]-8 = [8, 4, -1, 6] * [-6, 0, -4, -9] - self.assertEqual((2,4), np.array(results['mul']).shape) - self.TestAlmostEqual([[-2,0,24,-2],[-48,0,4,-54]], results['mul']) - - self.assertEqual((2,1,2), np.array(results['sum2']).shape) - self.TestAlmostEqual([[[0,5]],[[1, 2]]], results['sum2']) - self.assertEqual((2,2,2), np.array(results['sub2']).shape) - #[[3, 3], [0, 0]]-[3,3] - [[-1, 2], [0, 5]]-[0, 5] = [[0, 0], [-3, -3]] - [[-1, -3], [0, 0]] - self.TestAlmostEqual([[[1,-1],[1,-4]],[[1,3],[-3,-3]]], results['sub2']) - #[[0, 5], [1, 2], [2, 7], [3, 3]] * [[-1, 2], [0, 5], [1, 2], [2, 7]]-[0, 5] - #[[0, 5], [1, 2], [2, 7], [3, 3]] * [[-1, -3], [0, 0], [1, -3], [2, 2]] - self.assertEqual((2,4,2), np.array(results['mul2']).shape) - self.TestAlmostEqual([[[1, 2], [0, 0], [1, 6], [4, 0]],[[0, -15], [0, 0], [2, -21], [6, 6]]], results['mul2']) + self.assertEqual((2, 2), np.array(results["sub"]).shape) # [-1,6]+1 - [1,2]-2 + self.TestAlmostEqual([[1, 7], [6, 3]], results["sub"]) + # [8, 4, -1, 6] * [2, 8, 4, -1]-8 = [8, 4, -1, 6] * [-6, 0, -4, -9] + self.assertEqual((2, 4), np.array(results["mul"]).shape) + self.TestAlmostEqual([[-2, 0, 24, -2], [-48, 0, 4, -54]], results["mul"]) + + self.assertEqual((2, 1, 2), np.array(results["sum2"]).shape) + self.TestAlmostEqual([[[0, 5]], [[1, 2]]], results["sum2"]) + self.assertEqual((2, 2, 2), np.array(results["sub2"]).shape) + # [[3, 3], [0, 0]]-[3,3] - [[-1, 2], [0, 5]]-[0, 5] = [[0, 0], [-3, -3]] - [[-1, -3], [0, 0]] + self.TestAlmostEqual([[[1, -1], [1, -4]], [[1, 3], [-3, -3]]], results["sub2"]) + # [[0, 5], [1, 2], [2, 7], [3, 3]] * [[-1, 2], [0, 5], [1, 2], [2, 7]]-[0, 5] + # [[0, 5], [1, 2], [2, 7], [3, 3]] * [[-1, -3], [0, 0], [1, -3], [2, 2]] + self.assertEqual((2, 4, 2), np.array(results["mul2"]).shape) + self.TestAlmostEqual( + [[[1, 2], [0, 0], [1, 6], [4, 0]], [[0, -15], [0, 0], [2, -21], [6, 6]]], + results["mul2"], + ) def test_single_in_window_offset_fir(self): NeuObj.clearNames() # The input must be scalar and the time dimension is compress to 1, # Vector input not allowed, it could be done that a number of fir filters equal to the size of the vector are constructed # Should weights be shared or not? - in1 = Input('in1') - out1 = Output('Fir3', Fir(3)(in1.last())) - out2 = Output('Fir5', Fir(5)(in1.tw(1)))# - out3 = Output('Fir2', Fir(2)(in1.tw([-1,0])))# - out4 = Output('Fir1', Fir(1)(in1.tw([-3,3])))# - out5 = Output('Fir7', Fir(7)(in1.tw(3,offset=-1)))# - out6 = Output('Fir4', Fir(4)(in1.tw([2,3],offset=2)))# - out7 = Output('Fir6', Fir(6)(in1.sw([-2,-1], offset=-2)))# - - test = Modely(visualizer = None, seed = 1) - test.addModel('out',[out1,out2,out3,out4,out5,out6,out7]) + in1 = Input("in1") + out1 = Output("Fir3", Fir(3)(in1.last())) + out2 = Output("Fir5", Fir(5)(in1.tw(1))) # + out3 = Output("Fir2", Fir(2)(in1.tw([-1, 0]))) # + out4 = Output("Fir1", Fir(1)(in1.tw([-3, 3]))) # + out5 = Output("Fir7", Fir(7)(in1.tw(3, offset=-1))) # + out6 = Output("Fir4", Fir(4)(in1.tw([2, 3], offset=2))) # + out7 = Output("Fir6", Fir(6)(in1.sw([-2, -1], offset=-2))) # + + test = Modely(visualizer=None, seed=1) + test.addModel("out", [out1, out2, out3, out4, out5, out6, out7]) test.neuralizeModel(1) # Single input # Time -2 -1 0 1 2 3 - results = test({'in1': [[1], [2], [7], [4], [5], [6]]}) - self.assertEqual((1,1,3), np.array(results['Fir3']).shape) - self.assertEqual((1,1,5), np.array(results['Fir5']).shape) - self.assertEqual((1,1,2), np.array(results['Fir2']).shape) - self.assertEqual((1,), np.array(results['Fir1']).shape) - self.assertEqual((1,1,7), np.array(results['Fir7']).shape) - self.assertEqual((1,1,4), np.array(results['Fir4']).shape) - self.assertEqual((1,1,6), np.array(results['Fir6']).shape) + results = test({"in1": [[1], [2], [7], [4], [5], [6]]}) + self.assertEqual((1, 1, 3), np.array(results["Fir3"]).shape) + self.assertEqual((1, 1, 5), np.array(results["Fir5"]).shape) + self.assertEqual((1, 1, 2), np.array(results["Fir2"]).shape) + self.assertEqual((1,), np.array(results["Fir1"]).shape) + self.assertEqual((1, 1, 7), np.array(results["Fir7"]).shape) + self.assertEqual((1, 1, 4), np.array(results["Fir4"]).shape) + self.assertEqual((1, 1, 6), np.array(results["Fir6"]).shape) # Multi input there are 3 temporal instant # Time -2 -1 0 1 2 3 4 5 - results = test({'in1': [[1], [2], [7], [4], [5], [6], [7], [8]]}) - self.assertEqual((3,1,3), np.array(results['Fir3']).shape) - self.assertEqual((3,1,5), np.array(results['Fir5']).shape) - self.assertEqual((3,1,2), np.array(results['Fir2']).shape) - self.assertEqual((3,), np.array(results['Fir1']).shape) - self.assertEqual((3,1,7), np.array(results['Fir7']).shape) - self.assertEqual((3,1,4), np.array(results['Fir4']).shape) - self.assertEqual((3,1,6), np.array(results['Fir6']).shape) - + results = test({"in1": [[1], [2], [7], [4], [5], [6], [7], [8]]}) + self.assertEqual((3, 1, 3), np.array(results["Fir3"]).shape) + self.assertEqual((3, 1, 5), np.array(results["Fir5"]).shape) + self.assertEqual((3, 1, 2), np.array(results["Fir2"]).shape) + self.assertEqual((3,), np.array(results["Fir1"]).shape) + self.assertEqual((3, 1, 7), np.array(results["Fir7"]).shape) + self.assertEqual((3, 1, 4), np.array(results["Fir4"]).shape) + self.assertEqual((3, 1, 6), np.array(results["Fir6"]).shape) + def test_fir_and_parameter(self): NeuObj.clearNames() - x = Input('x') - p1 = Parameter('p1', tw=3, values=[[1],[2],[3],[6],[2],[3]]) + x = Input("x") + p1 = Parameter("p1", tw=3, values=[[1], [2], [3], [6], [2], [3]]) with self.assertRaises(TypeError): Fir(W=p1)(x) with self.assertRaises(ValueError): Fir(W=p1)(x.tw([-3, 1])) - out1 = Output('out1', Fir(W=p1)(x.tw([-2, 1]))) + out1 = Output("out1", Fir(W=p1)(x.tw([-2, 1]))) - p2 = Parameter('p2', sw=1, values=[[-2]]) + p2 = Parameter("p2", sw=1, values=[[-2]]) with self.assertRaises(TypeError): Fir(W=p2)(x.tw([-2, 1])) - out2 = Output('out2', Fir(W=p2)(x.last())) + out2 = Output("out2", Fir(W=p2)(x.last())) - p3 = Parameter('p3', dimensions=2, sw=1, values=[[-2,1]]) + p3 = Parameter("p3", dimensions=2, sw=1, values=[[-2, 1]]) with self.assertRaises(TypeError): Fir(W=p3)(x.tw([-2, 1])) - out3 = Output('out3', Fir(W=p3)(x.last())) + out3 = Output("out3", Fir(W=p3)(x.last())) - p4 = Parameter('p4', dimensions=2, tw=2, values=[[-2,1],[2,0],[0,1],[4,0]]) + p4 = Parameter( + "p4", dimensions=2, tw=2, values=[[-2, 1], [2, 0], [0, 1], [4, 0]] + ) with self.assertRaises(TypeError): Fir(W=p4)(x.sw([-2, 0])) - out4 = Output('out4', Fir(W=p4)(x.tw([-2, 0]))) + out4 = Output("out4", Fir(W=p4)(x.tw([-2, 0]))) - p5 = Parameter('p6', sw=2, dimensions=2, values=[[-2,1],[2,0]]) + p5 = Parameter("p6", sw=2, dimensions=2, values=[[-2, 1], [2, 0]]) with self.assertRaises(TypeError): - Fir(W = p5)(x) + Fir(W=p5)(x) with self.assertRaises(TypeError): - Fir(W = p5)(x.tw([-2,1])) + Fir(W=p5)(x.tw([-2, 1])) with self.assertRaises(ValueError): - Fir(W = p5)(x.sw([-2,1])) - out5 = Output('out5', Fir(W=p5)(x.sw([-2, 0]))) + Fir(W=p5)(x.sw([-2, 1])) + out5 = Output("out5", Fir(W=p5)(x.sw([-2, 0]))) test = Modely(visualizer=None) - test.addModel('out',[out1, out2, out3, out4, out5]) + test.addModel("out", [out1, out2, out3, out4, out5]) test.neuralizeModel(0.5) # Time -3, -2, -1, 0, 1, 2, 3 input = [-2, -1, 0, 1, 2, 3, 12] - results = test({'x': input}) - - self.assertEqual((2,), np.array(results['out1']).shape) - self.TestAlmostEqual([15,56], results['out1']) - self.assertEqual((2,), np.array(results['out2']).shape) - self.TestAlmostEqual([-2, -4], results['out2']) - self.assertEqual((2, 1, 2), np.array(results['out3']).shape) - self.TestAlmostEqual([[[-2,1]], [[-4,2]]], results['out3']) - self.assertEqual((2, 1, 2), np.array(results['out4']).shape) - self.TestAlmostEqual([[[6.0, -2.0]], [[10.0, 0.0]]], results['out4']) - self.assertEqual((2, 1, 2), np.array(results['out5']).shape) - self.TestAlmostEqual([[[2.0, 0.0]], [[2.0, 1.0]]], results['out5']) - + results = test({"x": input}) + + self.assertEqual((2,), np.array(results["out1"]).shape) + self.TestAlmostEqual([15, 56], results["out1"]) + self.assertEqual((2,), np.array(results["out2"]).shape) + self.TestAlmostEqual([-2, -4], results["out2"]) + self.assertEqual((2, 1, 2), np.array(results["out3"]).shape) + self.TestAlmostEqual([[[-2, 1]], [[-4, 2]]], results["out3"]) + self.assertEqual((2, 1, 2), np.array(results["out4"]).shape) + self.TestAlmostEqual([[[6.0, -2.0]], [[10.0, 0.0]]], results["out4"]) + self.assertEqual((2, 1, 2), np.array(results["out5"]).shape) + self.TestAlmostEqual([[[2.0, 0.0]], [[2.0, 1.0]]], results["out5"]) + def test_single_in_window_offset_parametric_function(self): NeuObj.clearNames() # An input dimension is temporal and does not remain unchanged unless redefined on output # If there are multiple inputs the function returns an error if the dimensions are not defined - in1 = Input('in1') + in1 = Input("in1") parfun = ParamFun(myfun) - out = Output('out', parfun(in1.last())) - test = Modely(visualizer = None, seed = 1) - test.addModel('out',out) + out = Output("out", parfun(in1.last())) + test = Modely(visualizer=None, seed=1) + test.addModel("out", out) test.neuralizeModel(0.1) - #results = test({'in1': 1}) - #self.TestAlmostEqual(results['out'], [0.7576315999031067]) - results = test({'in1': [[1]]}) - self.assertEqual((1,), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'],[0.7576315999031067]) - results = test({'in1': [2]}) - self.TestAlmostEqual(results['out'],[1.5152631998062134]) - results = test({'in1': [1,2]}) - self.assertEqual((2,), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'],[0.7576315999031067,1.5152631998062134]) - - NeuObj.clearNames('out') - out = Output('out', ParamFun(myfun)(in1.tw(0.2))) - test = Modely(visualizer=None, seed = 1) - test.addModel('out',out) + # results = test({'in1': 1}) + # self.TestAlmostEqual(results['out'], [0.7576315999031067]) + results = test({"in1": [[1]]}) + self.assertEqual((1,), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [0.7576315999031067]) + results = test({"in1": [2]}) + self.TestAlmostEqual(results["out"], [1.5152631998062134]) + results = test({"in1": [1, 2]}) + self.assertEqual((2,), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [0.7576315999031067, 1.5152631998062134]) + + NeuObj.clearNames("out") + out = Output("out", ParamFun(myfun)(in1.tw(0.2))) + test = Modely(visualizer=None, seed=1) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - results = test({'in1': [1]}) + results = test({"in1": [1]}) with self.assertRaises(StopIteration): - results = test({'in1': [2]}) - results = test({'in1': [1,2]}) - self.assertEqual((1,2), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[0.7576315999031067, 1.5152631998062134]]) - test({'in1': [[1, 2]]}, num_of_samples=5, sampled=True) - results = test({'in1': [[1,2]]}, sampled=True) - self.assertEqual((1,2), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[0.7576315999031067, 1.5152631998062134]]) - results = test({'in1': [1, 2, 3, 4, 5]})# Qui vengono costruite gli input a due a due con shift di 1 - self.assertEqual((4,2), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[0.7576315999031067, 1.5152631998062134], [1.5152631998062134, 2.272894859313965], [2.272894859313965, 3.0305263996124268], [3.0305263996124268, 3.7881579399108887]]) - results = test({'in1': [[1, 2], [2, 3], [3, 4], [4, 5]]}, sampled=True) - self.assertEqual((4,2), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[0.7576315999031067, 1.5152631998062134], [1.5152631998062134, 2.272894859313965], [2.272894859313965, 3.0305263996124268], [3.0305263996124268, 3.7881579399108887]]) - - out = Output('out2', ParamFun(myfun)(in1.last(),in1.last())) - test = Modely(visualizer=None, seed = 1) - test.addModel('out',out) + results = test({"in1": [2]}) + results = test({"in1": [1, 2]}) + self.assertEqual((1, 2), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [[0.7576315999031067, 1.5152631998062134]]) + test({"in1": [[1, 2]]}, num_of_samples=5, sampled=True) + results = test({"in1": [[1, 2]]}, sampled=True) + self.assertEqual((1, 2), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [[0.7576315999031067, 1.5152631998062134]]) + results = test( + {"in1": [1, 2, 3, 4, 5]} + ) # Qui vengono costruite gli input a due a due con shift di 1 + self.assertEqual((4, 2), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [0.7576315999031067, 1.5152631998062134], + [1.5152631998062134, 2.272894859313965], + [2.272894859313965, 3.0305263996124268], + [3.0305263996124268, 3.7881579399108887], + ], + ) + results = test({"in1": [[1, 2], [2, 3], [3, 4], [4, 5]]}, sampled=True) + self.assertEqual((4, 2), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [0.7576315999031067, 1.5152631998062134], + [1.5152631998062134, 2.272894859313965], + [2.272894859313965, 3.0305263996124268], + [3.0305263996124268, 3.7881579399108887], + ], + ) + + out = Output("out2", ParamFun(myfun)(in1.last(), in1.last())) + test = Modely(visualizer=None, seed=1) + test.addModel("out", out) test.neuralizeModel(0.1) - #results = test({'in1': 1}) - #self.TestAlmostEqual(results['out'],[1]) - results = test({'in1': [1]}) - self.TestAlmostEqual(results['out2'],[1]) - results = test({'in1': [2]}) - self.TestAlmostEqual(results['out2'],[4]) - results = test({'in1': [1,2]}) - self.TestAlmostEqual(results['out2'],[1,4]) + # results = test({'in1': 1}) + # self.TestAlmostEqual(results['out'],[1]) + results = test({"in1": [1]}) + self.TestAlmostEqual(results["out2"], [1]) + results = test({"in1": [2]}) + self.TestAlmostEqual(results["out2"], [4]) + results = test({"in1": [1, 2]}) + self.TestAlmostEqual(results["out2"], [1, 4]) - out = Output('out3', ParamFun(myfun)(in1.tw(0.1), in1.tw(0.1))) + out = Output("out3", ParamFun(myfun)(in1.tw(0.1), in1.tw(0.1))) test = Modely(visualizer=None) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) - #results = test({'in1': 2}) - #self.TestAlmostEqual(results['out'], [4]) - results = test({'in1': [2]}) - self.TestAlmostEqual(results['out3'], [4]) - results = test({'in1': [2,1]}) - self.TestAlmostEqual(results['out3'], [4,1]) + # results = test({'in1': 2}) + # self.TestAlmostEqual(results['out'], [4]) + results = test({"in1": [2]}) + self.TestAlmostEqual(results["out3"], [4]) + results = test({"in1": [2, 1]}) + self.TestAlmostEqual(results["out3"], [4, 1]) - out = Output('out4', ParamFun(myfun)(in1.tw(0.2), in1.tw(0.2))) + out = Output("out4", ParamFun(myfun)(in1.tw(0.2), in1.tw(0.2))) test = Modely(visualizer=None) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [2,4]}) - self.assertEqual((1,2), np.array(results['out4']).shape) - self.TestAlmostEqual(results['out4'], [[4,16]]) - results = test({'in1': [[1, 2], [3, 2]]}, sampled=True) - self.assertEqual((2,2), np.array(results['out4']).shape) - self.TestAlmostEqual(results['out4'], [[1.0, 4.0], [9.0, 4.0]]) + results = test({"in1": [2, 4]}) + self.assertEqual((1, 2), np.array(results["out4"]).shape) + self.TestAlmostEqual(results["out4"], [[4, 16]]) + results = test({"in1": [[1, 2], [3, 2]]}, sampled=True) + self.assertEqual((2, 2), np.array(results["out4"]).shape) + self.TestAlmostEqual(results["out4"], [[1.0, 4.0], [9.0, 4.0]]) - out = Output('out5', ParamFun(myfun)(in1.tw(0.3), in1.tw(0.3))) + out = Output("out5", ParamFun(myfun)(in1.tw(0.3), in1.tw(0.3))) test = Modely(visualizer=None) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - test({'in1': [2]}) + test({"in1": [2]}) with self.assertRaises(StopIteration): - test({'in1': [2, 4]}) - - results = test({'in1': [3,2,1]}) - self.assertEqual((1,3), np.array(results['out5']).shape) - self.TestAlmostEqual(results['out5'], [[9,4,1]]) - results = test({'in1': [[1,2,2],[3,4,5]]}, sampled=True) - self.assertEqual((2,3), np.array(results['out5']).shape) - self.TestAlmostEqual(results['out5'], [[1, 4, 4], [9, 16, 25]]) - results = test({'in1': [[3, 2, 1], [2, 1, 0]]}, sampled=True) - self.assertEqual((2,3), np.array(results['out5']).shape) - self.TestAlmostEqual(results['out5'], [[9, 4, 1],[4, 1, 0]]) - results = test({'in1': [3,2,1,0]}) - self.assertEqual((2,3), np.array(results['out5']).shape) - self.TestAlmostEqual(results['out5'], [[9, 4, 1],[4, 1, 0]]) - - out = Output('out6', ParamFun(myfun)(in1.tw(0.4), in1.tw(0.4))) + test({"in1": [2, 4]}) + + results = test({"in1": [3, 2, 1]}) + self.assertEqual((1, 3), np.array(results["out5"]).shape) + self.TestAlmostEqual(results["out5"], [[9, 4, 1]]) + results = test({"in1": [[1, 2, 2], [3, 4, 5]]}, sampled=True) + self.assertEqual((2, 3), np.array(results["out5"]).shape) + self.TestAlmostEqual(results["out5"], [[1, 4, 4], [9, 16, 25]]) + results = test({"in1": [[3, 2, 1], [2, 1, 0]]}, sampled=True) + self.assertEqual((2, 3), np.array(results["out5"]).shape) + self.TestAlmostEqual(results["out5"], [[9, 4, 1], [4, 1, 0]]) + results = test({"in1": [3, 2, 1, 0]}) + self.assertEqual((2, 3), np.array(results["out5"]).shape) + self.TestAlmostEqual(results["out5"], [[9, 4, 1], [4, 1, 0]]) + + out = Output("out6", ParamFun(myfun)(in1.tw(0.4), in1.tw(0.4))) test = Modely(visualizer=None) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - test({'in1': [[1, 2, 2], [3, 4, 5]]}) - + test({"in1": [[1, 2, 2], [3, 4, 5]]}) + def test_vectorial_input_parametric_function(self): NeuObj.clearNames() # Vector input for parametric function - in1 = Input('in1', dimensions=3) - in2 = Input('in2', dimensions=2) - p1 = Parameter('p1', sw=1, dimensions=(3,2), values=[[[1,2],[3,4],[5,6]]]) - p2 = Parameter('p2', sw=1, dimensions=(1,3), values=[[1,2,3]]) - parfun = ParamFun(myfun3, parameters_and_constants=[p1,p2]) - out = Output('out', parfun(in1.last(),in2.last())) - test = Modely(visualizer = None, seed = 1) - test.addModel('out',out) + in1 = Input("in1", dimensions=3) + in2 = Input("in2", dimensions=2) + p1 = Parameter("p1", sw=1, dimensions=(3, 2), values=[[[1, 2], [3, 4], [5, 6]]]) + p2 = Parameter("p2", sw=1, dimensions=(1, 3), values=[[1, 2, 3]]) + parfun = ParamFun(myfun3, parameters_and_constants=[p1, p2]) + out = Output("out", parfun(in1.last(), in2.last())) + test = Modely(visualizer=None, seed=1) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [[1,2,3]],'in2':[[5,6]]}) - self.assertEqual((1,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[23,52,81]]) + results = test({"in1": [[1, 2, 3]], "in2": [[5, 6]]}) + self.assertEqual((1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [[23, 52, 81]]) + + results = test({"in1": [[1, 2, 3], [5, 6, 7]], "in2": [[5, 6], [7, 8]]}) + self.assertEqual((2, 3), np.array(results["out"]).shape) + self.TestAlmostEqual(results["out"], [[23, 52, 81], [41, 94, 147]]) - results = test({'in1': [[1,2,3],[5,6,7]],'in2':[[5,6],[7,8]]}) - self.assertEqual((2,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[23,52,81],[41,94,147]]) - def test_parametric_function_and_fir(self): NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - out = Output('out', Fir(ParamFun(myfun2)(in1.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + out = Output("out", Fir(ParamFun(myfun2)(in1.tw(0.4)))) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - test({'in1': [1, 2, 2]}) - results = test({'in1': [[1], [2], [2], [4]]}) - self.TestAlmostEqual(results['out'][0], -0.03262542933225632) - results = test({'in1': [[[1], [2], [2], [4]],[[2], [2], [4], [5]]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.03262542933225632, -0.001211114227771759]) - results = test({'in1': [[1], [2], [2], [4], [5]]}) - self.TestAlmostEqual(results['out'], [-0.03262542933225632, -0.001211114227771759]) + test({"in1": [1, 2, 2]}) + results = test({"in1": [[1], [2], [2], [4]]}) + self.TestAlmostEqual(results["out"][0], -0.03262542933225632) + results = test( + {"in1": [[[1], [2], [2], [4]], [[2], [2], [4], [5]]]}, sampled=True + ) + self.TestAlmostEqual( + results["out"], [-0.03262542933225632, -0.001211114227771759] + ) + results = test({"in1": [[1], [2], [2], [4], [5]]}) + self.TestAlmostEqual( + results["out"], [-0.03262542933225632, -0.001211114227771759] + ) with self.assertRaises(RuntimeError): - Output('out', Fir(ParamFun(myfun2)(in1.tw(0.4),in2.tw(0.2)))) + Output("out", Fir(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.2)))) NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - out = Output('out', Fir(ParamFun(myfun2)(in1.tw(0.4),in2.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + out = Output("out", Fir(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.4)))) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) - with self.assertRaises(StopIteration): ## TODO: change to KeyError when checking the inputs - test({'in1': [[1, 2, 2, 4]]}) - - results = test({'in1': [1, 2, 2, 4], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [[1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [1, 2, 2, 4, 5], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [5, 5, 5, 5]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044, 0.5163354873657227]) - - results = test({'in1': [[1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [1, 2, 2, 4, 5], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [5, 5, 5, 5]]}, sampled=True) - self.TestAlmostEqual(results['out'], [-0.4379930794239044, 0.5163354873657227]) + with self.assertRaises( + StopIteration + ): ## TODO: change to KeyError when checking the inputs + test({"in1": [[1, 2, 2, 4]]}) + + results = test({"in1": [1, 2, 2, 4], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test({"in1": [[1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test({"in1": [1, 2, 2, 4, 5], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True + ) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [5, 5, 5, 5]]}, + sampled=True, + ) + self.TestAlmostEqual(results["out"], [-0.4379930794239044, 0.5163354873657227]) + + results = test({"in1": [[1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test({"in1": [1, 2, 2, 4, 5], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True + ) + self.TestAlmostEqual(results["out"], [-0.4379930794239044]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [5, 5, 5, 5]]}, + sampled=True, + ) + self.TestAlmostEqual(results["out"], [-0.4379930794239044, 0.5163354873657227]) NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - out = Output('out', Fir(3)(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + out = Output("out", Fir(3)(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.4)))) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [1, 2, 2, 4]]}, sampled=True) - self.assertEqual((2,1,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[[0.22182656824588776, -0.11421152949333191, 0.5385046601295471]], [[0.22182656824588776, -0.11421152949333191, 0.5385046601295471]]]) - - NeuObj.clearNames('out') + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [1, 2, 2, 4]]}, + sampled=True, + ) + self.assertEqual((2, 1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [[0.22182656824588776, -0.11421152949333191, 0.5385046601295471]], + [[0.22182656824588776, -0.11421152949333191, 0.5385046601295471]], + ], + ) + + NeuObj.clearNames("out") parfun = ParamFun(myfun2) with self.assertRaises(TypeError): - Output('out', parfun(Fir(3)(parfun(in1.tw(0.4), in2.tw(0.4))))) + Output("out", parfun(Fir(3)(parfun(in1.tw(0.4), in2.tw(0.4))))) parfun = ParamFun(myfun2) - out = Output('out', parfun(Fir(3)(parfun(in1.tw(0.4))))) + out = Output("out", parfun(Fir(3)(parfun(in1.tw(0.4))))) test = Modely(visualizer=None, seed=1) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [[1, 2, 2, 4], [2, 1, 1, 3]]}, sampled=True) - self.assertEqual((2,1,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], [[0.24776744842529297, 0.2278038114309311, 0.2481299340724945]]]) - - results = test({'in1': [1, 2, 2, 4, 3],'in2': [6, 2, 2, 4, 4]}) - self.assertEqual((2,1,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], [[0.1667831689119339,0.16757671535015106, 0.1605043113231659]]]) - results = test({'in1': [[1, 2, 2, 4],[2, 2, 4, 3]],'in2': [[6, 2, 2, 4],[2, 2, 4, 4]]}, sampled=True) - self.assertEqual((2,1,3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], [[0.1667831689119339, 0.16757671535015106,0.1605043113231659]]]) + results = test({"in1": [[1, 2, 2, 4], [2, 1, 1, 3]]}, sampled=True) + self.assertEqual((2, 1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], + [[0.24776744842529297, 0.2278038114309311, 0.2481299340724945]], + ], + ) + + results = test({"in1": [1, 2, 2, 4, 3], "in2": [6, 2, 2, 4, 4]}) + self.assertEqual((2, 1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], + [[0.1667831689119339, 0.16757671535015106, 0.1605043113231659]], + ], + ) + results = test( + {"in1": [[1, 2, 2, 4], [2, 2, 4, 3]], "in2": [[6, 2, 2, 4], [2, 2, 4, 4]]}, + sampled=True, + ) + self.assertEqual((2, 1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [[0.2126065045595169, 0.21099068224430084, 0.20540902018547058]], + [[0.1667831689119339, 0.16757671535015106, 0.1605043113231659]], + ], + ) def test_parametric_function_and_fir_with_parameters(self): NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - k1 = Parameter('k1', dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) - k2 = Parameter('k2', dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) - out = Output('out', Fir(ParamFun(myfun2, parameters_and_constants=[k1, k2])(in1.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + k1 = Parameter("k1", dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) + k2 = Parameter("k2", dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) + out = Output( + "out", Fir(ParamFun(myfun2, parameters_and_constants=[k1, k2])(in1.tw(0.4))) + ) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - test({'in1': [1, 2, 2]}) - results = test({'in1': [[1], [2], [2], [4]]}) - self.TestAlmostEqual(results['out'][0], 0.06549876928329468) - results = test({'in1': [[[1], [2], [2], [4]], [[2], [2], [4], [5]]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.06549876928329468, -0.38155099749565125]) - results = test({'in1': [[1], [2], [2], [4], [5]]}) - self.TestAlmostEqual(results['out'], [0.06549876928329468, -0.38155099749565125]) + test({"in1": [1, 2, 2]}) + results = test({"in1": [[1], [2], [2], [4]]}) + self.TestAlmostEqual(results["out"][0], 0.06549876928329468) + results = test( + {"in1": [[[1], [2], [2], [4]], [[2], [2], [4], [5]]]}, sampled=True + ) + self.TestAlmostEqual( + results["out"], [0.06549876928329468, -0.38155099749565125] + ) + results = test({"in1": [[1], [2], [2], [4], [5]]}) + self.TestAlmostEqual( + results["out"], [0.06549876928329468, -0.38155099749565125] + ) with self.assertRaises(RuntimeError): - Output('out', Fir(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.2)))) + Output("out", Fir(ParamFun(myfun2)(in1.tw(0.4), in2.tw(0.2)))) NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - k1 = Parameter('k1', dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) - k_fir = Parameter('k_fir', dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) - out = Output('out', Fir(W=k_fir)(ParamFun(myfun2, parameters_and_constants=[k1])(in1.tw(0.4), in2.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + k1 = Parameter("k1", dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) + k_fir = Parameter( + "k_fir", dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]] + ) + out = Output( + "out", + Fir(W=k_fir)( + ParamFun(myfun2, parameters_and_constants=[k1])( + in1.tw(0.4), in2.tw(0.4) + ) + ), + ) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.1) with self.assertRaises(StopIteration): - test({'in1': [[1, 2, 2, 4]]}) - - results = test({'in1': [1, 2, 2, 4], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [[1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [1, 2, 2, 4, 5], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [5, 5, 5, 5]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159, 1.446676254272461]) - - results = test({'in1': [[1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [1, 2, 2, 4, 5], 'in2': [1, 2, 2, 4]}) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159]) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [5, 5, 5, 5]]}, sampled=True) - self.TestAlmostEqual(results['out'], [0.3850506544113159, 1.446676254272461]) + test({"in1": [[1, 2, 2, 4]]}) + + results = test({"in1": [1, 2, 2, 4], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test({"in1": [[1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test({"in1": [1, 2, 2, 4, 5], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True + ) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [5, 5, 5, 5]]}, + sampled=True, + ) + self.TestAlmostEqual(results["out"], [0.3850506544113159, 1.446676254272461]) + + results = test({"in1": [[1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test({"in1": [1, 2, 2, 4, 5], "in2": [1, 2, 2, 4]}) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4]]}, sampled=True + ) + self.TestAlmostEqual(results["out"], [0.3850506544113159]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [5, 5, 5, 5]]}, + sampled=True, + ) + self.TestAlmostEqual(results["out"], [0.3850506544113159, 1.446676254272461]) NeuObj.clearNames() - in1 = Input('in1') - in2 = Input('in2') - k1 = Parameter('k1', dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) - k_fir = Parameter('k_fir', dimensions=3, tw=0.4, - values=[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]) - out = Output('out', Fir(3, W=k_fir)(ParamFun(myfun2, parameters_and_constants=[k1])(in1.tw(0.4), in2.tw(0.4)))) + in1 = Input("in1") + in2 = Input("in2") + k1 = Parameter("k1", dimensions=1, tw=0.4, values=[[1.0], [1.0], [1.0], [1.0]]) + k_fir = Parameter( + "k_fir", + dimensions=3, + tw=0.4, + values=[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]], + ) + out = Output( + "out", + Fir(3, W=k_fir)( + ParamFun(myfun2, parameters_and_constants=[k1])( + in1.tw(0.4), in2.tw(0.4) + ) + ), + ) test = Modely(visualizer=None) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [[1, 2, 2, 4], [1, 2, 2, 4]], 'in2': [[1, 2, 2, 4], [1, 2, 2, 4]]}, sampled=True) - self.assertEqual((2, 1, 3), np.array(results['out']).shape) - self.TestAlmostEqual(results['out'], [[[0.3850506544113159, 0.3850506544113159, 0.3850506544113159]], - [[0.3850506544113159, 0.3850506544113159, 0.3850506544113159]]]) + results = test( + {"in1": [[1, 2, 2, 4], [1, 2, 2, 4]], "in2": [[1, 2, 2, 4], [1, 2, 2, 4]]}, + sampled=True, + ) + self.assertEqual((2, 1, 3), np.array(results["out"]).shape) + self.TestAlmostEqual( + results["out"], + [ + [[0.3850506544113159, 0.3850506544113159, 0.3850506544113159]], + [[0.3850506544113159, 0.3850506544113159, 0.3850506544113159]], + ], + ) parfun = ParamFun(myfun2) with self.assertRaises(TypeError): - Output('out', parfun(Fir(3)(parfun(in1.tw(0.4), in2.tw(0.4))))) + Output("out", parfun(Fir(3)(parfun(in1.tw(0.4), in2.tw(0.4))))) parfun = ParamFun(myfun2) - out = Output('out2', parfun(Fir(3)(parfun(in1.tw(0.4))))) + out = Output("out2", parfun(Fir(3)(parfun(in1.tw(0.4))))) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) + test.addModel("out", out) test.neuralizeModel(0.1) - results = test({'in1': [[1, 2, 2, 4], [2, 1, 1, 3]]}, sampled=True) - self.assertEqual((2, 1, 3), np.array(results['out2']).shape) - self.TestAlmostEqual(results['out2'], [[[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], - [[0.8505557179450989, 0.7224123477935791, 0.77630215883255]]]) - - results = test({'in1': [1, 2, 2, 4, 3], 'in2': [6, 2, 2, 4, 4]}) - self.assertEqual((2, 1, 3), np.array(results['out2']).shape) - self.TestAlmostEqual(results['out2'], [[[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], - [[-0.09300854057073593, 0.44719645380973816, -0.03044888749718666]]]) - results = test({'in1': [[1, 2, 2, 4], [2, 2, 4, 3]], 'in2': [[6, 2, 2, 4], [2, 2, 4, 4]]}, sampled=True) - self.assertEqual((2, 1, 3), np.array(results['out2']).shape) - self.TestAlmostEqual(results['out2'], [[[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], - [[-0.09300854057073593, 0.44719645380973816, -0.03044888749718666]]]) + results = test({"in1": [[1, 2, 2, 4], [2, 1, 1, 3]]}, sampled=True) + self.assertEqual((2, 1, 3), np.array(results["out2"]).shape) + self.TestAlmostEqual( + results["out2"], + [ + [[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], + [[0.8505557179450989, 0.7224123477935791, 0.77630215883255]], + ], + ) + + results = test({"in1": [1, 2, 2, 4, 3], "in2": [6, 2, 2, 4, 4]}) + self.assertEqual((2, 1, 3), np.array(results["out2"]).shape) + self.TestAlmostEqual( + results["out2"], + [ + [[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], + [[-0.09300854057073593, 0.44719645380973816, -0.03044888749718666]], + ], + ) + results = test( + {"in1": [[1, 2, 2, 4], [2, 2, 4, 3]], "in2": [[6, 2, 2, 4], [2, 2, 4, 4]]}, + sampled=True, + ) + self.assertEqual((2, 1, 3), np.array(results["out2"]).shape) + self.TestAlmostEqual( + results["out2"], + [ + [[0.790096640586853, 0.7821592688560486, 0.8219361901283264]], + [[-0.09300854057073593, 0.44719645380973816, -0.03044888749718666]], + ], + ) def test_trigonometri_parameter_and_numeric_constant(self): NeuObj.clearNames() - in1 = Input('in1').last() - par = Parameter('par', values=5) - in4 = Input('in4', dimensions=4).last() - par4 = Parameter('par4', values=[1,2,3,4]) + in1 = Input("in1").last() + par = Parameter("par", values=5) + in4 = Input("in4", dimensions=4).last() + par4 = Parameter("par4", values=[1, 2, 3, 4]) add = in1 + par + 5.2 sub = in1 - par - 5.2 mul = in1 * par * 5.2 div = in1 / par / 5.2 - pow = in1 ** par ** 2 + pow = in1**par**2 sin1 = Sin(par) + Sin(5.2) cos1 = Cos(par) + Cos(5.2) tan1 = Tan(par) + Tan(5.2) @@ -726,17 +1000,17 @@ def test_trigonometri_parameter_and_numeric_constant(self): tot1 = add + sub + mul + div + pow + sin1 + cos1 + tan1 + relu1 + tanh1 add = 5.2 + in1 + (3 + par) - sub = - 5.2 - par + (3 - in1) + sub = -5.2 - par + (3 - in1) mul = 5.2 * in1 * (2 * par) div = 5.2 / in1 / (3 / par) - pow = (0.2 ** in1) + (2 ** par) + pow = (0.2**in1) + (2**par) tot11 = add + sub + mul + div + pow add4 = in4 + par4 + 5.2 sub4 = in4 - par4 - 5.2 mul4 = in4 * par4 * 5.2 div4 = in4 / par4 / 5.2 - pow4 = in4 ** par4 ** 2 + pow4 = in4**par4**2 sin4 = Sin(par4) + Sin(5.2) cos4 = Cos(par4) + Cos(5.2) tan4 = Tan(par4) + Tan(5.2) @@ -745,92 +1019,124 @@ def test_trigonometri_parameter_and_numeric_constant(self): tot4 = add4 + sub4 + mul4 + div4 + pow4 + sin4 + cos4 + tan4 + relu4 + tanh4 add4 = 5.2 + in4 + (3 + par4) - sub4 = - 5.2 - par4 + (3 - in4) + sub4 = -5.2 - par4 + (3 - in4) mul4 = 5.2 * in4 * (2 * par4) div4 = 5.2 / in4 / (3 / par4) - pow4 = (0.2 ** in4) + (2 ** par4) + pow4 = (0.2**in4) + (2**par4) tot41 = add4 + sub4 + mul4 + div4 + pow4 - out1 = Output('out1', tot1) - out11 = Output('out11', tot11) - out4 = Output('out4', tot4) - out41 = Output('out41', tot41) + out1 = Output("out1", tot1) + out11 = Output("out11", tot11) + out4 = Output("out4", tot4) + out41 = Output("out41", tot41) - linW = Parameter('linW', dimensions=(4,1),values=[[1],[1],[1],[1]]) - outtot = Output('outtot', tot1 + Linear(W=linW)(tot4)) + linW = Parameter("linW", dimensions=(4, 1), values=[[1], [1], [1], [1]]) + outtot = Output("outtot", tot1 + Linear(W=linW)(tot4)) test = Modely(visualizer=None, seed=1) - test.addModel('out',[out1,out4,outtot,out11,out41]) + test.addModel("out", [out1, out4, outtot, out11, out41]) test.neuralizeModel() - results = test({'in1': [1, 2, -2],'in4': [[6, 2, 2, 4], [7, 2, 2, 4], [-6, -5, 5, 4]]}) - self.assertEqual((3,), np.array(results['out1']).shape) - self.assertEqual((3,1,4), np.array(results['out4']).shape) - self.assertEqual((3,), np.array(results['outtot']).shape) - - self.TestAlmostEqual([34.8819529, 33554496.0, -33554480.0], results['out1'] ) - self.TestAlmostEqual([[[58.9539756, 46.1638031, 554.231201171875, 4294967296.0]], [[67.3462829589843, 46.16380310058594, 554.231201171875, 4294967296.0]], [[ -41.75371170043945, 567.6907348632812, 1953220.375, 4294967296.0]]], results['out4']) - self.TestAlmostEqual([4294967808.0, 4328522240.0, 4263366656.0], results['outtot']) - - self.assertEqual((3,), np.array(results['out11']).shape) - self.assertEqual((3,1,4), np.array(results['out41']).shape) - - self.TestAlmostEqual([98.86666667, 146.37333333, -45.33333333], results['out11']) - self.TestAlmostEqual([[[ 70.68895289, 53.37333333, 79.04 , 190.13493333]], - [[ 81.04763185, 53.37333333, 79.04 , 190.13493333]], - [[15570.31111111, 3030.30666667, 171.04032 , 190.13493333]]], results['out41'],precision=2) + results = test( + {"in1": [1, 2, -2], "in4": [[6, 2, 2, 4], [7, 2, 2, 4], [-6, -5, 5, 4]]} + ) + self.assertEqual((3,), np.array(results["out1"]).shape) + self.assertEqual((3, 1, 4), np.array(results["out4"]).shape) + self.assertEqual((3,), np.array(results["outtot"]).shape) + + self.TestAlmostEqual([34.8819529, 33554496.0, -33554480.0], results["out1"]) + self.TestAlmostEqual( + [ + [[58.9539756, 46.1638031, 554.231201171875, 4294967296.0]], + [[67.3462829589843, 46.16380310058594, 554.231201171875, 4294967296.0]], + [[-41.75371170043945, 567.6907348632812, 1953220.375, 4294967296.0]], + ], + results["out4"], + ) + self.TestAlmostEqual( + [4294967808.0, 4328522240.0, 4263366656.0], results["outtot"] + ) + + self.assertEqual((3,), np.array(results["out11"]).shape) + self.assertEqual((3, 1, 4), np.array(results["out41"]).shape) + + self.TestAlmostEqual( + [98.86666667, 146.37333333, -45.33333333], results["out11"] + ) + self.TestAlmostEqual( + [ + [[70.68895289, 53.37333333, 79.04, 190.13493333]], + [[81.04763185, 53.37333333, 79.04, 190.13493333]], + [[15570.31111111, 3030.30666667, 171.04032, 190.13493333]], + ], + results["out41"], + precision=2, + ) def test_check_modify_stream(self): NeuObj.clearNames() - in1 = Input('in1').last() - par = Parameter('par', values=5) - add1 = in1 + par # 1 + 5 = 6 - add2 = add1 + 5.2 # 6 + 5.2 = 11.2 - tot1 = add1 + add2 # 6 + 11.2 = 17.2 - out1 = Output('out1', tot1) # = 17.2 - tot2 = add1 + in1 # 6 + 1 = 7 - out12 = Output('out12', tot1 + tot2) # = 24.2 - out2 = Output('out2', tot2) #= 7 - test = Modely(visualizer=None,seed=1) - test.addModel('out',[out1,out12,out2]) + in1 = Input("in1").last() + par = Parameter("par", values=5) + add1 = in1 + par # 1 + 5 = 6 + add2 = add1 + 5.2 # 6 + 5.2 = 11.2 + tot1 = add1 + add2 # 6 + 11.2 = 17.2 + out1 = Output("out1", tot1) # = 17.2 + tot2 = add1 + in1 # 6 + 1 = 7 + out12 = Output("out12", tot1 + tot2) # = 24.2 + out2 = Output("out2", tot2) # = 7 + test = Modely(visualizer=None, seed=1) + test.addModel("out", [out1, out12, out2]) test.neuralizeModel() - results = test({'in1': [1]}) - self.assertEqual((1,), np.array(results['out1']).shape) - self.TestAlmostEqual([17.2], results['out1'] ) - self.TestAlmostEqual([24.2], results['out12']) - self.TestAlmostEqual([7], results['out2']) - + results = test({"in1": [1]}) + self.assertEqual((1,), np.array(results["out1"]).shape) + self.TestAlmostEqual([17.2], results["out1"]) + self.TestAlmostEqual([24.2], results["out12"]) + self.TestAlmostEqual([7], results["out2"]) def test_parameter_and_linear(self): NeuObj.clearNames() - input = Input('in1').last() - W15 = Parameter('W15', dimensions=(1, 5), values=[[1,2,3,4,5]]) - b15 = Parameter('b15', dimensions=5, values=[1,2,3,4,5]) - input4 = Input('in4', dimensions=4).last() - W45 = Parameter('W45', dimensions=(4, 5), values=[[1,2,3,4,5],[5,3,3,4,5],[1,2,3,4,7],[-8,2,3,4,5]]) - b45 = Parameter('b45', dimensions=5, values=[5,2,3,4,5]) - - o = Output('out' , Linear(input) + Linear(input4)) - o3 = Output('out3' , Linear(3)(input) + Linear(3)(input4)) - oW = Output('outW' , Linear(W = W15)(input) + Linear(W = W45)(input4)) - oWb = Output('outWb' , Linear(W = W15,b = b15)(input) + Linear(W = W45, b = b45)(input4)) + input = Input("in1").last() + W15 = Parameter("W15", dimensions=(1, 5), values=[[1, 2, 3, 4, 5]]) + b15 = Parameter("b15", dimensions=5, values=[1, 2, 3, 4, 5]) + input4 = Input("in4", dimensions=4).last() + W45 = Parameter( + "W45", + dimensions=(4, 5), + values=[ + [1, 2, 3, 4, 5], + [5, 3, 3, 4, 5], + [1, 2, 3, 4, 7], + [-8, 2, 3, 4, 5], + ], + ) + b45 = Parameter("b45", dimensions=5, values=[5, 2, 3, 4, 5]) + + o = Output("out", Linear(input) + Linear(input4)) + o3 = Output("out3", Linear(3)(input) + Linear(3)(input4)) + oW = Output("outW", Linear(W=W15)(input) + Linear(W=W45)(input4)) + oWb = Output( + "outWb", Linear(W=W15, b=b15)(input) + Linear(W=W45, b=b45)(input4) + ) n = Modely(visualizer=None, seed=1) - n.addModel('out',[o,o3,oW,oWb]) - #n.addModel('out', [oW]) + n.addModel("out", [o, o3, oW, oWb]) + # n.addModel('out', [oW]) n.neuralizeModel() - results = n({'in1': [1, 2], 'in4': [[6, 2, 2, 4], [7, 2, 2, 4]]}) - #self.assertEqual((2,), np.array(results['out']).shape) - #self.TestAlmostEqual([9.274794578552246,10.3853759765625], results['out']) - #self.assertEqual((2,1,3), np.array(results['out3']).shape) - #self.TestAlmostEqual([[[9.247159004211426, 6.103044033050537,7.719359397888184]],[[10.68740463256836, 6.687504291534424,8.585973739624023]]], results['out3']) - #W15 = torch.tensor([[1,2,3,4,5]]) - #in1 = torch.tensor([[1, 2]]) - #W45 = torch.tensor([[1, 2, 3, 4, 5], [5, 3, 3, 4, 5], [1, 2, 3, 4, 7], [-8, 2, 3, 4, 5]]) - #in4 = torch.tensor([[6, 2, 2, 4], [7, 2, 2, 4]]) - #torch.matmul(W45.t(),in4.t())+torch.matmul(W15.t(),in1) - self.assertEqual((2, 1, 5), np.array(results['outW']).shape) - self.TestAlmostEqual([[[-13.0,32.0,45.0,60.0,79.0]],[[-11.0,36.0,51.,68.,89.]]], results['outW']) + results = n({"in1": [1, 2], "in4": [[6, 2, 2, 4], [7, 2, 2, 4]]}) + # self.assertEqual((2,), np.array(results['out']).shape) + # self.TestAlmostEqual([9.274794578552246,10.3853759765625], results['out']) + # self.assertEqual((2,1,3), np.array(results['out3']).shape) + # self.TestAlmostEqual([[[9.247159004211426, 6.103044033050537,7.719359397888184]],[[10.68740463256836, 6.687504291534424,8.585973739624023]]], results['out3']) + # W15 = torch.tensor([[1,2,3,4,5]]) + # in1 = torch.tensor([[1, 2]]) + # W45 = torch.tensor([[1, 2, 3, 4, 5], [5, 3, 3, 4, 5], [1, 2, 3, 4, 7], [-8, 2, 3, 4, 5]]) + # in4 = torch.tensor([[6, 2, 2, 4], [7, 2, 2, 4]]) + # torch.matmul(W45.t(),in4.t())+torch.matmul(W15.t(),in1) + self.assertEqual((2, 1, 5), np.array(results["outW"]).shape) + self.TestAlmostEqual( + [[[-13.0, 32.0, 45.0, 60.0, 79.0]], [[-11.0, 36.0, 51.0, 68.0, 89.0]]], + results["outW"], + ) # W15 = torch.tensor([[1,2,3,4,5]]) # b15 = torch.tensor([[5, 2, 3, 4, 5]]) # in1 = torch.tensor([[1, 2]]) @@ -838,107 +1144,247 @@ def test_parameter_and_linear(self): # b45 = torch.tensor([[1, 2, 3, 4, 5]]) # in4 = torch.tensor([[6, 2, 2, 4], [7, 2, 2, 4]]) # oo = torch.matmul(W45.t(),in4.t())+b45.t()+torch.matmul(W15.t(),in1)+b15.t() - self.assertEqual((2, 1, 5), np.array(results['outWb']).shape) - self.TestAlmostEqual([[[-7, 36, 51, 68, 89]],[[-5, 40, 57, 76, 99]]], results['outWb']) + self.assertEqual((2, 1, 5), np.array(results["outWb"]).shape) + self.TestAlmostEqual( + [[[-7, 36, 51, 68, 89]], [[-5, 40, 57, 76, 99]]], results["outWb"] + ) NeuObj.clearNames() - input2 = Input('in1').sw([-1,1]) - input42 = Input('in4', dimensions=4).sw([-1,1]) - - o = Output('out' , Linear(input2) + Linear(input42)) - o3 = Output('out3' , Linear(3)(input2) + Linear(3)(input42)) - oW = Output('outW' , Linear(W = W15)(input2) + Linear(W = W45)(input42)) - oWb = Output('outWb' , Linear(W = W15,b = b15)(input2) + Linear(W = W45, b = b45)(input42)) + input2 = Input("in1").sw([-1, 1]) + input42 = Input("in4", dimensions=4).sw([-1, 1]) + + o = Output("out", Linear(input2) + Linear(input42)) + o3 = Output("out3", Linear(3)(input2) + Linear(3)(input42)) + oW = Output("outW", Linear(W=W15)(input2) + Linear(W=W45)(input42)) + oWb = Output( + "outWb", Linear(W=W15, b=b15)(input2) + Linear(W=W45, b=b45)(input42) + ) n = Modely(visualizer=None) - n.addModel('out',[o,o3,oW,oWb]) + n.addModel("out", [o, o3, oW, oWb]) n.neuralizeModel() - results = n({'in1': [1, 2], 'in4': [[6, 2, 2, 4], [7, 2, 2, 4]]}) - self.assertEqual((1, 2), np.array(results['out']).shape) - self.TestAlmostEqual([[7.3881096839904785, 7.91458797454834]], results['out']) - self.assertEqual((1, 2, 3), np.array(results['out3']).shape) - self.TestAlmostEqual([[[8.117439270019531, 6.014362812042236, 7.489190578460693], - [9.261265754699707, 6.2568135261535645, 7.929978370666504]]], results['out3']) - self.assertEqual((1, 2, 5), np.array(results['outW']).shape) - self.TestAlmostEqual([[[-13.0, 32.0, 45.0, 60.0, 79.0], [-11.0, 36.0, 51., 68., 89.]]], results['outW']) - self.assertEqual((1, 2, 5), np.array(results['outWb']).shape) - self.TestAlmostEqual([[[-7, 36, 51, 68, 89], [-5, 40, 57, 76, 99]]], results['outWb']) + results = n({"in1": [1, 2], "in4": [[6, 2, 2, 4], [7, 2, 2, 4]]}) + self.assertEqual((1, 2), np.array(results["out"]).shape) + self.TestAlmostEqual([[7.3881096839904785, 7.91458797454834]], results["out"]) + self.assertEqual((1, 2, 3), np.array(results["out3"]).shape) + self.TestAlmostEqual( + [ + [ + [8.117439270019531, 6.014362812042236, 7.489190578460693], + [9.261265754699707, 6.2568135261535645, 7.929978370666504], + ] + ], + results["out3"], + ) + self.assertEqual((1, 2, 5), np.array(results["outW"]).shape) + self.TestAlmostEqual( + [[[-13.0, 32.0, 45.0, 60.0, 79.0], [-11.0, 36.0, 51.0, 68.0, 89.0]]], + results["outW"], + ) + self.assertEqual((1, 2, 5), np.array(results["outWb"]).shape) + self.TestAlmostEqual( + [[[-7, 36, 51, 68, 89], [-5, 40, 57, 76, 99]]], results["outWb"] + ) def test_initialization(self): NeuObj.clearNames() - input = Input('in1') - W = Parameter('W', dimensions=(1,1), init='init_constant') - b = Parameter('b', dimensions=1, init='init_constant') - o = Output('out', Linear(W=W,b=b)(input.last())) - - W5 = Parameter('W5', dimensions=(1,1), init='init_constant', init_params={'value':5}) - b2 = Parameter('b2', dimensions=1, init='init_constant', init_params={'value':2}) - o52 = Output('out52', Linear(W=W5,b=b2)(input.last())) - - par = Parameter('par', dimensions=3, sw=2, init='init_constant') - opar = Output('outpar', Fir(W=par)(input.sw(2))) - - par2 = Parameter('par2', dimensions=3, sw=2, init='init_constant', init_params={'value':2}) - opar2 = Output('outpar2', Fir(W=par2, b=False)(input.sw(2))) - - ol = Output('outl', Linear(output_dimension=1,b=True,W_init='init_constant',b_init='init_constant')(input.last())) - ol52 = Output('outl52', Linear(output_dimension=1,b=True,W_init='init_constant',b_init='init_constant',W_init_params={'value':5},b_init_params={'value':2})(input.last())) - ofpar = Output('outfpar', Fir(output_dimension=3,W_init='init_constant')(input.sw(2))) - ofpar2 = Output('outfpar2', Fir(output_dimension=3,W_init='init_constant',W_init_params={'value':2})(input.sw(2))) + input = Input("in1") + W = Parameter("W", dimensions=(1, 1), init="init_constant") + b = Parameter("b", dimensions=1, init="init_constant") + o = Output("out", Linear(W=W, b=b)(input.last())) + + W5 = Parameter( + "W5", dimensions=(1, 1), init="init_constant", init_params={"value": 5} + ) + b2 = Parameter( + "b2", dimensions=1, init="init_constant", init_params={"value": 2} + ) + o52 = Output("out52", Linear(W=W5, b=b2)(input.last())) + + par = Parameter("par", dimensions=3, sw=2, init="init_constant") + opar = Output("outpar", Fir(W=par)(input.sw(2))) + + par2 = Parameter( + "par2", dimensions=3, sw=2, init="init_constant", init_params={"value": 2} + ) + opar2 = Output("outpar2", Fir(W=par2, b=False)(input.sw(2))) + + ol = Output( + "outl", + Linear( + output_dimension=1, + b=True, + W_init="init_constant", + b_init="init_constant", + )(input.last()), + ) + ol52 = Output( + "outl52", + Linear( + output_dimension=1, + b=True, + W_init="init_constant", + b_init="init_constant", + W_init_params={"value": 5}, + b_init_params={"value": 2}, + )(input.last()), + ) + ofpar = Output( + "outfpar", Fir(output_dimension=3, W_init="init_constant")(input.sw(2)) + ) + ofpar2 = Output( + "outfpar2", + Fir(output_dimension=3, W_init="init_constant", W_init_params={"value": 2})( + input.sw(2) + ), + ) + + outnegexp = Output( + "outnegexp", Fir(output_dimension=3, W_init="init_negexp")(input.sw(2)) + ) + outnegexp2 = Output( + "outnegexp2", + Fir( + output_dimension=3, + W_init="init_negexp", + W_init_params={"size_index": 1, "first_value": 3, "lambda": 1}, + )(input.sw(2)), + ) + + outexp = Output( + "outexp", Fir(output_dimension=3, W_init="init_exp")(input.sw(2)) + ) + outexp2 = Output( + "outexp2", + Fir( + output_dimension=3, + W_init="init_exp", + W_init_params={ + "size_index": 1, + "max_value": 2, + "lambda": 2, + "monotonicity": "increasing", + }, + )(input.sw(2)), + ) + outexp2D = Output( + "outexp2D", + Fir( + output_dimension=3, + W_init="init_exp", + W_init_params={ + "size_index": 1, + "max_value": 2, + "lambda": 2, + "monotonicity": "decreasing", + }, + )(input.sw(2)), + ) + + outlin = Output( + "outlin", Fir(output_dimension=3, W_init="init_lin")(input.sw(2)) + ) + outlin2 = Output( + "outlin2", + Fir( + output_dimension=3, + W_init="init_lin", + W_init_params={"size_index": 1, "first_value": 4, "last_value": 5}, + )(input.sw(2)), + ) - outnegexp = Output('outnegexp', Fir(output_dimension=3,W_init='init_negexp')(input.sw(2))) - outnegexp2 = Output('outnegexp2', Fir(output_dimension=3,W_init='init_negexp',W_init_params={'size_index':1, 'first_value':3, 'lambda':1})(input.sw(2))) - - outexp = Output('outexp', Fir(output_dimension=3,W_init='init_exp')(input.sw(2))) - outexp2 = Output('outexp2', Fir(output_dimension=3,W_init='init_exp',W_init_params={'size_index':1, 'max_value':2, 'lambda':2, 'monotonicity':'increasing'})(input.sw(2))) - outexp2D = Output('outexp2D', Fir(output_dimension=3,W_init='init_exp',W_init_params={'size_index':1, 'max_value':2, 'lambda':2, 'monotonicity':'decreasing'})(input.sw(2))) - - outlin = Output('outlin', Fir(output_dimension=3,W_init='init_lin')(input.sw(2))) - outlin2 = Output('outlin2', Fir(output_dimension=3,W_init='init_lin',W_init_params={'size_index':1, 'first_value':4, 'last_value':5})(input.sw(2))) - - n = Modely(visualizer=None,seed=1) - n.addModel('model',[o,o52,opar,opar2,ol,ol52,ofpar,ofpar2,outnegexp,outnegexp2,outexp,outexp2,outexp2D,outlin,outlin2]) + n = Modely(visualizer=None, seed=1) + n.addModel( + "model", + [ + o, + o52, + opar, + opar2, + ol, + ol52, + ofpar, + ofpar2, + outnegexp, + outnegexp2, + outexp, + outexp2, + outexp2D, + outlin, + outlin2, + ], + ) n.neuralizeModel() - results = n({'in1': [1, 1, 2]}) - self.assertEqual((2,), np.array(results['out']).shape) - self.TestAlmostEqual([2,3], results['out']) - self.assertEqual((2,), np.array(results['out52']).shape) - self.TestAlmostEqual([7,12], results['out52']) - - self.assertEqual((2,1,3), np.array(results['outpar']).shape) - self.TestAlmostEqual([[[2,2,2]],[[3,3,3]]], results['outpar']) - self.assertEqual((2,1,3), np.array(results['outpar2']).shape) - self.TestAlmostEqual([[[4,4,4]],[[6,6,6]]], results['outpar2']) - - self.assertEqual((2,), np.array(results['outl']).shape) - self.TestAlmostEqual([2,3], results['outl']) - self.assertEqual((2,), np.array(results['outl52']).shape) - self.TestAlmostEqual([7.0,12.0], results['outl52']) - - self.assertEqual((2,1,3), np.array(results['outfpar']).shape) - self.TestAlmostEqual([[[2,2,2]],[[3,3,3]]], results['outfpar']) - self.assertEqual((2,1,3), np.array(results['outfpar2']).shape) - self.TestAlmostEqual([[[4,4,4]],[[6,6,6]]], results['outfpar2']) - - self.assertEqual((2,1,3), np.array(results['outnegexp']).shape) - self.TestAlmostEqual([[[1.0497870445251465,1.0497870445251465,1.0497870445251465]],[[2.0497870445251465,2.0497870445251465,2.0497870445251465]]], results['outnegexp']) - self.assertEqual((2,1,3), np.array(results['outnegexp2']).shape) - self.TestAlmostEqual([[[2.2072765827178955,3.63918399810791,6.0]],[[3.310914993286133,5.458775997161865,9.0]]], results['outnegexp2']) - - self.assertEqual((2,1,3), np.array(results['outexp']).shape) - self.TestAlmostEqual([[[1.0497870445251465,1.0497870445251465,1.0497870445251465]],[[1.099574089050293,1.099574089050293,1.099574089050293]]], results['outexp']) - self.assertEqual((2,1,3), np.array(results['outexp2']).shape) - self.TestAlmostEqual([[[0.5413411259651184,1.47151780128479,4]],[[0.81201171875,2.2072768211364746,6]]], results['outexp2']) - self.assertEqual((2,1,3), np.array(results['outexp2D']).shape) - self.TestAlmostEqual([[[4.0,1.47151780128479,0.5413411259651184]],[[6,2.2072768211364746,0.81201171875]]], results['outexp2D']) - - self.assertEqual((2,1,3), np.array(results['outlin']).shape) - self.TestAlmostEqual([[[1,1,1]],[[1,1,1]]], results['outlin']) - self.assertEqual((2,1,3), np.array(results['outlin2']).shape) - self.TestAlmostEqual([[[8,9,10]],[[12,13.5,15.0]]], results['outlin2']) + results = n({"in1": [1, 1, 2]}) + self.assertEqual((2,), np.array(results["out"]).shape) + self.TestAlmostEqual([2, 3], results["out"]) + self.assertEqual((2,), np.array(results["out52"]).shape) + self.TestAlmostEqual([7, 12], results["out52"]) + + self.assertEqual((2, 1, 3), np.array(results["outpar"]).shape) + self.TestAlmostEqual([[[2, 2, 2]], [[3, 3, 3]]], results["outpar"]) + self.assertEqual((2, 1, 3), np.array(results["outpar2"]).shape) + self.TestAlmostEqual([[[4, 4, 4]], [[6, 6, 6]]], results["outpar2"]) + + self.assertEqual((2,), np.array(results["outl"]).shape) + self.TestAlmostEqual([2, 3], results["outl"]) + self.assertEqual((2,), np.array(results["outl52"]).shape) + self.TestAlmostEqual([7.0, 12.0], results["outl52"]) + + self.assertEqual((2, 1, 3), np.array(results["outfpar"]).shape) + self.TestAlmostEqual([[[2, 2, 2]], [[3, 3, 3]]], results["outfpar"]) + self.assertEqual((2, 1, 3), np.array(results["outfpar2"]).shape) + self.TestAlmostEqual([[[4, 4, 4]], [[6, 6, 6]]], results["outfpar2"]) + + self.assertEqual((2, 1, 3), np.array(results["outnegexp"]).shape) + self.TestAlmostEqual( + [ + [[1.0497870445251465, 1.0497870445251465, 1.0497870445251465]], + [[2.0497870445251465, 2.0497870445251465, 2.0497870445251465]], + ], + results["outnegexp"], + ) + self.assertEqual((2, 1, 3), np.array(results["outnegexp2"]).shape) + self.TestAlmostEqual( + [ + [[2.2072765827178955, 3.63918399810791, 6.0]], + [[3.310914993286133, 5.458775997161865, 9.0]], + ], + results["outnegexp2"], + ) + + self.assertEqual((2, 1, 3), np.array(results["outexp"]).shape) + self.TestAlmostEqual( + [ + [[1.0497870445251465, 1.0497870445251465, 1.0497870445251465]], + [[1.099574089050293, 1.099574089050293, 1.099574089050293]], + ], + results["outexp"], + ) + self.assertEqual((2, 1, 3), np.array(results["outexp2"]).shape) + self.TestAlmostEqual( + [ + [[0.5413411259651184, 1.47151780128479, 4]], + [[0.81201171875, 2.2072768211364746, 6]], + ], + results["outexp2"], + ) + self.assertEqual((2, 1, 3), np.array(results["outexp2D"]).shape) + self.TestAlmostEqual( + [ + [[4.0, 1.47151780128479, 0.5413411259651184]], + [[6, 2.2072768211364746, 0.81201171875]], + ], + results["outexp2D"], + ) + + self.assertEqual((2, 1, 3), np.array(results["outlin"]).shape) + self.TestAlmostEqual([[[1, 1, 1]], [[1, 1, 1]]], results["outlin"]) + self.assertEqual((2, 1, 3), np.array(results["outlin2"]).shape) + self.TestAlmostEqual([[[8, 9, 10]], [[12, 13.5, 15.0]]], results["outlin2"]) def test_sample_part_and_select(self): NeuObj.clearNames() - in1 = Input('in1') + in1 = Input("in1") # Offset before the sample window with self.assertRaises(IndexError): in1.sw([-5, -2], offset=-6) @@ -952,25 +1398,25 @@ def test_sample_part_and_select(self): with self.assertRaises(IndexError): in1.sw([0, 3], offset=3) - sw3,sw32 = in1.sw([-5, -2], offset=-4), in1.sw([0, 3], offset=0) - out_sw3 = Output('in_sw3', sw3) - out_sw32 = Output('in_sw32', sw32) - #Get after the window + sw3, sw32 = in1.sw([-5, -2], offset=-4), in1.sw([0, 3], offset=0) + out_sw3 = Output("in_sw3", sw3) + out_sw32 = Output("in_sw32", sw32) + # Get after the window with self.assertRaises(ValueError): SamplePart(sw3, 0, 4) - #Empty sample window + # Empty sample window with self.assertRaises(ValueError): SamplePart(sw3, 0, 0) - #Get before the sample window + # Get before the sample window with self.assertRaises(ValueError): SamplePart(sw3, -1, 0) # Get after the window with self.assertRaises(ValueError): SamplePart(sw32, 0, 4) - #Empty sample window + # Empty sample window with self.assertRaises(ValueError): SamplePart(sw32, 0, 0) - #Get before the sample window + # Get before the sample window with self.assertRaises(ValueError): SamplePart(sw32, -1, 0) @@ -986,13 +1432,13 @@ def test_sample_part_and_select(self): # Offset after the sample window with self.assertRaises(IndexError): SamplePart(sw32, 0, 3, offset=3) - in_SP1first = Output('in_SP1first', SamplePart(sw3, 0, 1)) - in_SP1mid = Output('in_SP1mid', SamplePart(sw3, 1, 2)) - in_SP1last = Output('in_SP1last', SamplePart(sw3, 2, 3)) - in_SP1all = Output('in_SP1all', SamplePart(sw3, 0, 3)) - in_SP1off1 = Output('in_SP1off1', SamplePart(sw3, 0, 3, offset=0)) - in_SP1off2 = Output('in_SP1off2', SamplePart(sw3, 0, 3, offset=1)) - in_SP1off3 = Output('in_SP1off3', SamplePart(sw3, 0, 3, offset=2)) + in_SP1first = Output("in_SP1first", SamplePart(sw3, 0, 1)) + in_SP1mid = Output("in_SP1mid", SamplePart(sw3, 1, 2)) + in_SP1last = Output("in_SP1last", SamplePart(sw3, 2, 3)) + in_SP1all = Output("in_SP1all", SamplePart(sw3, 0, 3)) + in_SP1off1 = Output("in_SP1off1", SamplePart(sw3, 0, 3, offset=0)) + in_SP1off2 = Output("in_SP1off2", SamplePart(sw3, 0, 3, offset=1)) + in_SP1off3 = Output("in_SP1off3", SamplePart(sw3, 0, 3, offset=2)) with self.assertRaises(ValueError): SampleSelect(sw3, -1) with self.assertRaises(ValueError): @@ -1001,75 +1447,89 @@ def test_sample_part_and_select(self): SampleSelect(sw32, -1) with self.assertRaises(ValueError): SampleSelect(sw32, 3) - in_SS1 = Output('in_SS1', SampleSelect(sw3, 0)) - in_SS2 = Output('in_SS2', SampleSelect(sw3, 1)) - in_SS3 = Output('in_SS3', SampleSelect(sw3, 2)) + in_SS1 = Output("in_SS1", SampleSelect(sw3, 0)) + in_SS2 = Output("in_SS2", SampleSelect(sw3, 1)) + in_SS3 = Output("in_SS3", SampleSelect(sw3, 2)) test = Modely(visualizer=None) - test.addModel('out',[out_sw3, out_sw32, - in_SP1first, in_SP1mid, in_SP1last, in_SP1all, in_SP1off1, in_SP1off2, in_SP1off3, - in_SS1, in_SS2, in_SS3]) + test.addModel( + "out", + [ + out_sw3, + out_sw32, + in_SP1first, + in_SP1mid, + in_SP1last, + in_SP1all, + in_SP1off1, + in_SP1off2, + in_SP1off3, + in_SS1, + in_SS2, + in_SS3, + ], + ) test.neuralizeModel() - results = test({'in1': [0, 1, 2, 3, 4, 5, 6, 7]}) - - self.assertEqual((1, 3), np.array(results['in_sw3']).shape) - self.TestAlmostEqual([[-1,0,1]], results['in_sw3']) - self.assertEqual((1, 3), np.array(results['in_sw32']).shape) - self.TestAlmostEqual([[0,1,2]], results['in_sw32']) - - self.assertEqual((1,), np.array(results['in_SP1first']).shape) - self.TestAlmostEqual([-1], results['in_SP1first']) - self.assertEqual((1,), np.array(results['in_SP1mid']).shape) - self.TestAlmostEqual([0], results['in_SP1mid']) - self.assertEqual((1,), np.array(results['in_SP1last']).shape) - self.TestAlmostEqual([1], results['in_SP1last']) - self.assertEqual((1,3), np.array(results['in_SP1all']).shape) - self.TestAlmostEqual([[-1,0,1]], results['in_SP1all']) - self.assertEqual((1,3), np.array(results['in_SP1off1']).shape) - self.TestAlmostEqual([[0,1,2]], results['in_SP1off1']) - self.assertEqual((1,3), np.array(results['in_SP1off2']).shape) - self.TestAlmostEqual([[-1,0,1]], results['in_SP1off2']) - self.assertEqual((1,3), np.array(results['in_SP1off3']).shape) - self.TestAlmostEqual([[-2,-1,0]], results['in_SP1off3']) - - self.assertEqual((1,), np.array(results['in_SS1']).shape) - self.TestAlmostEqual([-1], results['in_SS1']) - self.assertEqual((1,), np.array(results['in_SS2']).shape) - self.TestAlmostEqual([0], results['in_SS2']) - self.assertEqual((1,), np.array(results['in_SS3']).shape) - self.TestAlmostEqual([1], results['in_SS3']) - - results = test({'in1': [0, 1, 2, 3, 4, 5, 6, 7, 10]}) - - self.assertEqual((2, 3), np.array(results['in_sw3']).shape) - self.TestAlmostEqual([[-1, 0, 1],[-1, 0, 1]], results['in_sw3']) - self.assertEqual((2, 3), np.array(results['in_sw32']).shape) - self.TestAlmostEqual([[0, 1, 2],[0, 1, 4]], results['in_sw32']) - - self.assertEqual((2,), np.array(results['in_SP1first']).shape) - self.TestAlmostEqual([-1,-1], results['in_SP1first']) - self.assertEqual((2,), np.array(results['in_SP1mid']).shape) - self.TestAlmostEqual([0,0], results['in_SP1mid']) - self.assertEqual((2,), np.array(results['in_SP1last']).shape) - self.TestAlmostEqual([1,1], results['in_SP1last']) - self.assertEqual((2, 3), np.array(results['in_SP1all']).shape) - self.TestAlmostEqual([[-1, 0, 1],[-1, 0, 1]], results['in_SP1all']) - self.assertEqual((2, 3), np.array(results['in_SP1off1']).shape) - self.TestAlmostEqual([[0, 1, 2],[0, 1, 2]], results['in_SP1off1']) - self.assertEqual((2, 3), np.array(results['in_SP1off2']).shape) - self.TestAlmostEqual([[-1, 0, 1],[-1, 0, 1]], results['in_SP1off2']) - self.assertEqual((2, 3), np.array(results['in_SP1off3']).shape) - self.TestAlmostEqual([[-2, -1, 0],[-2, -1, 0]], results['in_SP1off3']) - - self.assertEqual((2,), np.array(results['in_SS1']).shape) - self.TestAlmostEqual([-1,-1], results['in_SS1']) - self.assertEqual((2,), np.array(results['in_SS2']).shape) - self.TestAlmostEqual([0,0], results['in_SS2']) - self.assertEqual((2,), np.array(results['in_SS3']).shape) - self.TestAlmostEqual([1,1], results['in_SS3']) + results = test({"in1": [0, 1, 2, 3, 4, 5, 6, 7]}) + + self.assertEqual((1, 3), np.array(results["in_sw3"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_sw3"]) + self.assertEqual((1, 3), np.array(results["in_sw32"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_sw32"]) + + self.assertEqual((1,), np.array(results["in_SP1first"]).shape) + self.TestAlmostEqual([-1], results["in_SP1first"]) + self.assertEqual((1,), np.array(results["in_SP1mid"]).shape) + self.TestAlmostEqual([0], results["in_SP1mid"]) + self.assertEqual((1,), np.array(results["in_SP1last"]).shape) + self.TestAlmostEqual([1], results["in_SP1last"]) + self.assertEqual((1, 3), np.array(results["in_SP1all"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_SP1all"]) + self.assertEqual((1, 3), np.array(results["in_SP1off1"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_SP1off1"]) + self.assertEqual((1, 3), np.array(results["in_SP1off2"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_SP1off2"]) + self.assertEqual((1, 3), np.array(results["in_SP1off3"]).shape) + self.TestAlmostEqual([[-2, -1, 0]], results["in_SP1off3"]) + + self.assertEqual((1,), np.array(results["in_SS1"]).shape) + self.TestAlmostEqual([-1], results["in_SS1"]) + self.assertEqual((1,), np.array(results["in_SS2"]).shape) + self.TestAlmostEqual([0], results["in_SS2"]) + self.assertEqual((1,), np.array(results["in_SS3"]).shape) + self.TestAlmostEqual([1], results["in_SS3"]) + + results = test({"in1": [0, 1, 2, 3, 4, 5, 6, 7, 10]}) + + self.assertEqual((2, 3), np.array(results["in_sw3"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results["in_sw3"]) + self.assertEqual((2, 3), np.array(results["in_sw32"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results["in_sw32"]) + + self.assertEqual((2,), np.array(results["in_SP1first"]).shape) + self.TestAlmostEqual([-1, -1], results["in_SP1first"]) + self.assertEqual((2,), np.array(results["in_SP1mid"]).shape) + self.TestAlmostEqual([0, 0], results["in_SP1mid"]) + self.assertEqual((2,), np.array(results["in_SP1last"]).shape) + self.TestAlmostEqual([1, 1], results["in_SP1last"]) + self.assertEqual((2, 3), np.array(results["in_SP1all"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results["in_SP1all"]) + self.assertEqual((2, 3), np.array(results["in_SP1off1"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, 2]], results["in_SP1off1"]) + self.assertEqual((2, 3), np.array(results["in_SP1off2"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results["in_SP1off2"]) + self.assertEqual((2, 3), np.array(results["in_SP1off3"]).shape) + self.TestAlmostEqual([[-2, -1, 0], [-2, -1, 0]], results["in_SP1off3"]) + + self.assertEqual((2,), np.array(results["in_SS1"]).shape) + self.TestAlmostEqual([-1, -1], results["in_SS1"]) + self.assertEqual((2,), np.array(results["in_SS2"]).shape) + self.TestAlmostEqual([0, 0], results["in_SS2"]) + self.assertEqual((2,), np.array(results["in_SS3"]).shape) + self.TestAlmostEqual([1, 1], results["in_SS3"]) def test_time_part(self): NeuObj.clearNames() - in1 = Input('in1') + in1 = Input("in1") # Offset before the time window with self.assertRaises(IndexError): in1.tw([-5, -2], offset=-6) @@ -1084,8 +1544,8 @@ def test_time_part(self): in1.tw([0, 3], offset=3) tw3, tw32 = in1.tw([-5, -2], offset=-4), in1.tw([0, 3], offset=0) - out_tw3 = Output('in_tw3', tw3) - out_tw32 = Output('in_tw32', tw32) + out_tw3 = Output("in_tw3", tw3) + out_tw32 = Output("in_tw32", tw32) # Get after the window with self.assertRaises(ValueError): TimePart(tw3, 0, 4) @@ -1118,69 +1578,81 @@ def test_time_part(self): with self.assertRaises(IndexError): TimePart(tw32, 0, 3, offset=3) - in_TP1first = Output('in_TP1first', TimePart(tw32, 0, 1)) - in_TP1mid = Output('in_TP1mid', TimePart(tw32, 1, 2)) - in_TP1last = Output('in_TP1last', TimePart(tw32, 2, 3)) - in_TP1all = Output('in_TP1all', TimePart(tw32, 0, 3)) - in_TP1off1 = Output('in_TP1off1', TimePart(tw32, 0, 3, offset=0)) - in_TP1off2 = Output('in_TP1off2', TimePart(tw32, 0, 3, offset=1)) - in_TP1off3 = Output('in_TP1off3', TimePart(tw32, 0, 3, offset=2)) + in_TP1first = Output("in_TP1first", TimePart(tw32, 0, 1)) + in_TP1mid = Output("in_TP1mid", TimePart(tw32, 1, 2)) + in_TP1last = Output("in_TP1last", TimePart(tw32, 2, 3)) + in_TP1all = Output("in_TP1all", TimePart(tw32, 0, 3)) + in_TP1off1 = Output("in_TP1off1", TimePart(tw32, 0, 3, offset=0)) + in_TP1off2 = Output("in_TP1off2", TimePart(tw32, 0, 3, offset=1)) + in_TP1off3 = Output("in_TP1off3", TimePart(tw32, 0, 3, offset=2)) test = Modely(visualizer=None) - test.addModel('out',[out_tw3, out_tw32, - in_TP1first, in_TP1mid, in_TP1last, in_TP1all, in_TP1off1, in_TP1off2, in_TP1off3]) + test.addModel( + "out", + [ + out_tw3, + out_tw32, + in_TP1first, + in_TP1mid, + in_TP1last, + in_TP1all, + in_TP1off1, + in_TP1off2, + in_TP1off3, + ], + ) test.neuralizeModel(1) - results = test({'in1': [0, 1, 2, 3, 4, 5, 6, 7]}) - - self.assertEqual((1, 3), np.array(results['in_tw3']).shape) - self.TestAlmostEqual([[-1, 0, 1]], results['in_tw3']) - self.assertEqual((1, 3), np.array(results['in_tw32']).shape) - self.TestAlmostEqual([[0, 1, 2]], results['in_tw32']) - - self.assertEqual((1,), np.array(results['in_TP1first']).shape) - self.TestAlmostEqual([0], results['in_TP1first']) - self.assertEqual((1,), np.array(results['in_TP1mid']).shape) - self.TestAlmostEqual([1], results['in_TP1mid']) - self.assertEqual((1,), np.array(results['in_TP1last']).shape) - self.TestAlmostEqual([2], results['in_TP1last']) - self.assertEqual((1, 3), np.array(results['in_TP1all']).shape) - self.TestAlmostEqual([[0, 1, 2]], results['in_TP1all']) - self.assertEqual((1, 3), np.array(results['in_TP1off1']).shape) - self.TestAlmostEqual([[0, 1, 2]], results['in_TP1off1']) - self.assertEqual((1, 3), np.array(results['in_TP1off2']).shape) - self.TestAlmostEqual([[-1, 0, 1]], results['in_TP1off2']) - self.assertEqual((1, 3), np.array(results['in_TP1off3']).shape) - self.TestAlmostEqual([[-2, -1, 0]], results['in_TP1off3']) - - results = test({'in1': [0, 1, 2, 3, 4, 5, 6, 7, 10]}) - - self.assertEqual((2, 3), np.array(results['in_tw3']).shape) - self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results['in_tw3']) - self.assertEqual((2, 3), np.array(results['in_tw32']).shape) - self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results['in_tw32']) - - self.assertEqual((2,), np.array(results['in_TP1first']).shape) - self.TestAlmostEqual([0, 0], results['in_TP1first']) - self.assertEqual((2,), np.array(results['in_TP1mid']).shape) - self.TestAlmostEqual([1, 1], results['in_TP1mid']) - self.assertEqual((2,), np.array(results['in_TP1last']).shape) - self.TestAlmostEqual([2, 4], results['in_TP1last']) - self.assertEqual((2, 3), np.array(results['in_TP1all']).shape) - self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results['in_TP1all']) - self.assertEqual((2, 3), np.array(results['in_TP1off1']).shape) - self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results['in_TP1off1']) - self.assertEqual((2, 3), np.array(results['in_TP1off2']).shape) - self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 3]], results['in_TP1off2']) - self.assertEqual((2, 3), np.array(results['in_TP1off3']).shape) - self.TestAlmostEqual([[-2, -1, 0], [-4, -3, 0]], results['in_TP1off3']) - + results = test({"in1": [0, 1, 2, 3, 4, 5, 6, 7]}) + + self.assertEqual((1, 3), np.array(results["in_tw3"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_tw3"]) + self.assertEqual((1, 3), np.array(results["in_tw32"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_tw32"]) + + self.assertEqual((1,), np.array(results["in_TP1first"]).shape) + self.TestAlmostEqual([0], results["in_TP1first"]) + self.assertEqual((1,), np.array(results["in_TP1mid"]).shape) + self.TestAlmostEqual([1], results["in_TP1mid"]) + self.assertEqual((1,), np.array(results["in_TP1last"]).shape) + self.TestAlmostEqual([2], results["in_TP1last"]) + self.assertEqual((1, 3), np.array(results["in_TP1all"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_TP1all"]) + self.assertEqual((1, 3), np.array(results["in_TP1off1"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_TP1off1"]) + self.assertEqual((1, 3), np.array(results["in_TP1off2"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_TP1off2"]) + self.assertEqual((1, 3), np.array(results["in_TP1off3"]).shape) + self.TestAlmostEqual([[-2, -1, 0]], results["in_TP1off3"]) + + results = test({"in1": [0, 1, 2, 3, 4, 5, 6, 7, 10]}) + + self.assertEqual((2, 3), np.array(results["in_tw3"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results["in_tw3"]) + self.assertEqual((2, 3), np.array(results["in_tw32"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results["in_tw32"]) + + self.assertEqual((2,), np.array(results["in_TP1first"]).shape) + self.TestAlmostEqual([0, 0], results["in_TP1first"]) + self.assertEqual((2,), np.array(results["in_TP1mid"]).shape) + self.TestAlmostEqual([1, 1], results["in_TP1mid"]) + self.assertEqual((2,), np.array(results["in_TP1last"]).shape) + self.TestAlmostEqual([2, 4], results["in_TP1last"]) + self.assertEqual((2, 3), np.array(results["in_TP1all"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results["in_TP1all"]) + self.assertEqual((2, 3), np.array(results["in_TP1off1"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, 4]], results["in_TP1off1"]) + self.assertEqual((2, 3), np.array(results["in_TP1off2"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 3]], results["in_TP1off2"]) + self.assertEqual((2, 3), np.array(results["in_TP1off3"]).shape) + self.TestAlmostEqual([[-2, -1, 0], [-4, -3, 0]], results["in_TP1off3"]) + def test_part_and_select(self): NeuObj.clearNames() - in1 = Input('in1',dimensions=4) + in1 = Input("in1", dimensions=4) tw3, tw32 = in1.tw([-5, -2], offset=-4), in1.tw([0, 3], offset=0) - out_tw3 = Output('in_tw3', tw3) - out_tw32 = Output('in_tw32', tw32) + out_tw3 = Output("in_tw3", tw3) + out_tw32 = Output("in_tw32", tw32) # Get after the window with self.assertRaises(IndexError): Part(tw3, 0, 5) @@ -1200,10 +1672,10 @@ def test_part_and_select(self): with self.assertRaises(IndexError): Part(tw32, -1, 0) - in_P1first = Output('in_P1first', Part(tw32, 0, 1)) - in_P1mid = Output('in_P1mid', Part(tw32, 1, 2)) - in_P1last = Output('in_P1last', Part(tw32, 2, 4)) - in_P1all = Output('in_P1all', Part(tw32, 0, 4)) + in_P1first = Output("in_P1first", Part(tw32, 0, 1)) + in_P1mid = Output("in_P1mid", Part(tw32, 1, 2)) + in_P1last = Output("in_P1last", Part(tw32, 2, 4)) + in_P1all = Output("in_P1all", Part(tw32, 0, 4)) with self.assertRaises(IndexError): Select(tw3, -1) @@ -1213,279 +1685,395 @@ def test_part_and_select(self): Select(tw32, -1) with self.assertRaises(IndexError): Select(tw32, 4) - in_S1 = Output('in_S1', Select(tw3, 0)) - in_S2 = Output('in_S2', Select(tw3, 1)) - in_S3 = Output('in_S3', Select(tw3, 2)) - in_S4 = Output('in_S4', Select(tw3, 3)) + in_S1 = Output("in_S1", Select(tw3, 0)) + in_S2 = Output("in_S2", Select(tw3, 1)) + in_S3 = Output("in_S3", Select(tw3, 2)) + in_S4 = Output("in_S4", Select(tw3, 3)) test = Modely(visualizer=None) - test.addModel('out',[out_tw3, out_tw32, - in_P1first, in_P1mid, in_P1last, in_P1all, - in_S1, in_S2, in_S3, in_S4]) + test.addModel( + "out", + [ + out_tw3, + out_tw32, + in_P1first, + in_P1mid, + in_P1last, + in_P1all, + in_S1, + in_S2, + in_S3, + in_S4, + ], + ) test.neuralizeModel(1) - results = test({'in1': [[0,1,2,4], [1,3,4,5], [2,5,6,7], [3,3,4,1], [4,4,6,7], [5,6,7,8], [6,7,5,4],[7,2,3,1]]}) - - self.assertEqual((1, 3, 4), np.array(results['in_tw3']).shape) - self.TestAlmostEqual([[[-1,-2,-2,-1], [0,0,0,0], [1,2,2,2]]], results['in_tw3']) - self.assertEqual((1, 3, 4), np.array(results['in_tw32']).shape) - self.TestAlmostEqual([[[0,0,0,0], [1,1,-2,-4],[2,-4,-4,-7]]], results['in_tw32']) - - self.assertEqual((1,3), np.array(results['in_P1first']).shape) - self.TestAlmostEqual([[0,1,2]], results['in_P1first']) - self.assertEqual((1,3), np.array(results['in_P1mid']).shape) - self.TestAlmostEqual([[0,1,-4]], results['in_P1mid']) - self.assertEqual((1,3,2), np.array(results['in_P1last']).shape) - self.TestAlmostEqual([[[0,0],[-2,-4],[-4,-7]]], results['in_P1last']) - self.assertEqual((1,3,4), np.array(results['in_P1all']).shape) - self.TestAlmostEqual([[[0,0,0,0], [1,1,-2,-4],[2,-4,-4,-7]]], results['in_P1all']) - - self.assertEqual((1,3), np.array(results['in_S1']).shape) - self.TestAlmostEqual([[-1,0,1]], results['in_S1']) - self.assertEqual((1,3), np.array(results['in_S2']).shape) - self.TestAlmostEqual([[-2,0,2]], results['in_S2']) - self.assertEqual((1,3), np.array(results['in_S3']).shape) - self.TestAlmostEqual([[-2,0,2]], results['in_S3']) - self.assertEqual((1,3), np.array(results['in_S4']).shape) - self.TestAlmostEqual([[-1,0,2]], results['in_S4']) - - results = test({'in1': [[0,1,2,4], [1,3,4,5], [2,5,6,7], [3,3,4,1], [4,4,6,7], [5,6,7,8], [6,7,5,4],[7,2,3,1],[0,7,0,0]]}) - - self.assertEqual((2, 3, 4), np.array(results['in_tw3']).shape) - self.TestAlmostEqual([[[-1, -2, -2, -1], [0, 0, 0, 0], [1, 2, 2, 2]], - [[-1, -2, -2, -2], [0, 0, 0, 0], [1, -2, -2, -6]]], results['in_tw3']) - self.assertEqual((2, 3, 4), np.array(results['in_tw32']).shape) - self.TestAlmostEqual([[[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]], - [[0, 0, 0, 0], [1, -5, -2, -3], [-6, 0, -5, -4]]], results['in_tw32']) - - self.assertEqual((2, 3), np.array(results['in_P1first']).shape) - self.TestAlmostEqual([[0, 1, 2],[0, 1, -6]], results['in_P1first']) - self.assertEqual((2, 3), np.array(results['in_P1mid']).shape) - self.TestAlmostEqual([[0, 1, -4],[0, -5, 0]], results['in_P1mid']) - self.assertEqual((2, 3, 2), np.array(results['in_P1last']).shape) - self.TestAlmostEqual([[[0, 0], [-2, -4], [-4, -7]], - [[0, 0], [-2, -3], [-5, -4]]], results['in_P1last']) - self.assertEqual((2, 3, 4), np.array(results['in_P1all']).shape) - self.TestAlmostEqual([[[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]], - [[0, 0, 0, 0], [1, -5, -2, -3], [-6, 0, -5, -4]]], results['in_P1all']) - - self.assertEqual((2, 3), np.array(results['in_S1']).shape) - self.TestAlmostEqual([[-1, 0, 1],[-1, 0, 1]], results['in_S1']) - self.assertEqual((2, 3), np.array(results['in_S2']).shape) - self.TestAlmostEqual([[-2, 0, 2],[-2, 0, -2]], results['in_S2']) - self.assertEqual((2, 3), np.array(results['in_S3']).shape) - self.TestAlmostEqual([[-2, 0, 2],[-2, 0, -2]], results['in_S3']) - self.assertEqual((2, 3), np.array(results['in_S4']).shape) - self.TestAlmostEqual([[-1, 0, 2],[-2, 0, -6]], results['in_S4']) + results = test( + { + "in1": [ + [0, 1, 2, 4], + [1, 3, 4, 5], + [2, 5, 6, 7], + [3, 3, 4, 1], + [4, 4, 6, 7], + [5, 6, 7, 8], + [6, 7, 5, 4], + [7, 2, 3, 1], + ] + } + ) + + self.assertEqual((1, 3, 4), np.array(results["in_tw3"]).shape) + self.TestAlmostEqual( + [[[-1, -2, -2, -1], [0, 0, 0, 0], [1, 2, 2, 2]]], results["in_tw3"] + ) + self.assertEqual((1, 3, 4), np.array(results["in_tw32"]).shape) + self.TestAlmostEqual( + [[[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]]], results["in_tw32"] + ) + + self.assertEqual((1, 3), np.array(results["in_P1first"]).shape) + self.TestAlmostEqual([[0, 1, 2]], results["in_P1first"]) + self.assertEqual((1, 3), np.array(results["in_P1mid"]).shape) + self.TestAlmostEqual([[0, 1, -4]], results["in_P1mid"]) + self.assertEqual((1, 3, 2), np.array(results["in_P1last"]).shape) + self.TestAlmostEqual([[[0, 0], [-2, -4], [-4, -7]]], results["in_P1last"]) + self.assertEqual((1, 3, 4), np.array(results["in_P1all"]).shape) + self.TestAlmostEqual( + [[[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]]], results["in_P1all"] + ) + + self.assertEqual((1, 3), np.array(results["in_S1"]).shape) + self.TestAlmostEqual([[-1, 0, 1]], results["in_S1"]) + self.assertEqual((1, 3), np.array(results["in_S2"]).shape) + self.TestAlmostEqual([[-2, 0, 2]], results["in_S2"]) + self.assertEqual((1, 3), np.array(results["in_S3"]).shape) + self.TestAlmostEqual([[-2, 0, 2]], results["in_S3"]) + self.assertEqual((1, 3), np.array(results["in_S4"]).shape) + self.TestAlmostEqual([[-1, 0, 2]], results["in_S4"]) + + results = test( + { + "in1": [ + [0, 1, 2, 4], + [1, 3, 4, 5], + [2, 5, 6, 7], + [3, 3, 4, 1], + [4, 4, 6, 7], + [5, 6, 7, 8], + [6, 7, 5, 4], + [7, 2, 3, 1], + [0, 7, 0, 0], + ] + } + ) + + self.assertEqual((2, 3, 4), np.array(results["in_tw3"]).shape) + self.TestAlmostEqual( + [ + [[-1, -2, -2, -1], [0, 0, 0, 0], [1, 2, 2, 2]], + [[-1, -2, -2, -2], [0, 0, 0, 0], [1, -2, -2, -6]], + ], + results["in_tw3"], + ) + self.assertEqual((2, 3, 4), np.array(results["in_tw32"]).shape) + self.TestAlmostEqual( + [ + [[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]], + [[0, 0, 0, 0], [1, -5, -2, -3], [-6, 0, -5, -4]], + ], + results["in_tw32"], + ) + + self.assertEqual((2, 3), np.array(results["in_P1first"]).shape) + self.TestAlmostEqual([[0, 1, 2], [0, 1, -6]], results["in_P1first"]) + self.assertEqual((2, 3), np.array(results["in_P1mid"]).shape) + self.TestAlmostEqual([[0, 1, -4], [0, -5, 0]], results["in_P1mid"]) + self.assertEqual((2, 3, 2), np.array(results["in_P1last"]).shape) + self.TestAlmostEqual( + [[[0, 0], [-2, -4], [-4, -7]], [[0, 0], [-2, -3], [-5, -4]]], + results["in_P1last"], + ) + self.assertEqual((2, 3, 4), np.array(results["in_P1all"]).shape) + self.TestAlmostEqual( + [ + [[0, 0, 0, 0], [1, 1, -2, -4], [2, -4, -4, -7]], + [[0, 0, 0, 0], [1, -5, -2, -3], [-6, 0, -5, -4]], + ], + results["in_P1all"], + ) + + self.assertEqual((2, 3), np.array(results["in_S1"]).shape) + self.TestAlmostEqual([[-1, 0, 1], [-1, 0, 1]], results["in_S1"]) + self.assertEqual((2, 3), np.array(results["in_S2"]).shape) + self.TestAlmostEqual([[-2, 0, 2], [-2, 0, -2]], results["in_S2"]) + self.assertEqual((2, 3), np.array(results["in_S3"]).shape) + self.TestAlmostEqual([[-2, 0, 2], [-2, 0, -2]], results["in_S3"]) + self.assertEqual((2, 3), np.array(results["in_S4"]).shape) + self.TestAlmostEqual([[-1, 0, 2], [-2, 0, -6]], results["in_S4"]) def test_predict_paramfun_param_const(self): NeuObj.clearNames() - input2 = Input('in2') - pp = Parameter('pp', values=[[7],[8],[9]]) - ll = Constant('ll', values=[[12],[13],[14]]) - oo = Constant('oo', values=[[1],[2],[3]]) + input2 = Input("in2") + pp = Parameter("pp", values=[[7], [8], [9]]) + ll = Constant("ll", values=[[12], [13], [14]]) + oo = Constant("oo", values=[[1], [2], [3]]) pp, oo, input2.tw(0.03), ll + def fun_test(x, y, z, k): return (x + y) * (z - k) NeuObj.clearNames() - out = Output('out',ParamFun(fun_test,parameters_and_constants=[ll,oo,pp])(input2.tw(0.03))) + out = Output( + "out", + ParamFun(fun_test, parameters_and_constants=[ll, oo, pp])(input2.tw(0.03)), + ) test = Modely(visualizer=None) - test.addModel('out',[out]) + test.addModel("out", [out]) test.neuralizeModel(0.01) - results = test({'in2': [0, 1, 2]}) - self.assertEqual((1, 3), np.array(results['out']).shape) - self.assertEqual([[-72.0, -84.0, -96.0]], results['out']) + results = test({"in2": [0, 1, 2]}) + self.assertEqual((1, 3), np.array(results["out"]).shape) + self.assertEqual([[-72.0, -84.0, -96.0]], results["out"]) NeuObj.clearNames() - out = Output('out',ParamFun(fun_test,parameters_and_constants={'z':pp,'y':ll,'k':oo})(input2.tw(0.03))) + out = Output( + "out", + ParamFun(fun_test, parameters_and_constants={"z": pp, "y": ll, "k": oo})( + input2.tw(0.03) + ), + ) test = Modely(visualizer=None) - test.addModel('out',[out]) + test.addModel("out", [out]) test.neuralizeModel(0.01) - results = test({'in2': [0, 1, 2]}) - self.assertEqual((1, 3), np.array(results['out']).shape) - self.assertEqual([[72.0, 84.0, 96.0]], results['out']) + results = test({"in2": [0, 1, 2]}) + self.assertEqual((1, 3), np.array(results["out"]).shape) + self.assertEqual([[72.0, 84.0, 96.0]], results["out"]) NeuObj.clearNames() parfun = ParamFun(fun_test) - out1 = Output('out1', parfun(input2.tw(0.03), ll, pp, oo)) - out2 = Output('out2', parfun(input2.tw(0.03), ll, oo, pp)) - out3 = Output('out3', parfun(pp, oo, input2.tw(0.03), ll)) + out1 = Output("out1", parfun(input2.tw(0.03), ll, pp, oo)) + out2 = Output("out2", parfun(input2.tw(0.03), ll, oo, pp)) + out3 = Output("out3", parfun(pp, oo, input2.tw(0.03), ll)) test = Modely(visualizer=None) - test.addModel('out',[out1,out2,out3]) + test.addModel("out", [out1, out2, out3]) test.neuralizeModel(0.01) - results = test({'in2': [0, 1, 2]}) - self.assertEqual((1, 3), np.array(results['out1']).shape) - self.assertEqual((1, 3), np.array(results['out2']).shape) - self.assertEqual((1, 3), np.array(results['out3']).shape) - self.assertEqual([[72.0, 84.0, 96.0]], results['out1']) - self.assertEqual([[-72.0, -84.0, -96.0]], results['out2']) - self.assertEqual([[-96.0, -120.0, -144.0]], results['out3']) + results = test({"in2": [0, 1, 2]}) + self.assertEqual((1, 3), np.array(results["out1"]).shape) + self.assertEqual((1, 3), np.array(results["out2"]).shape) + self.assertEqual((1, 3), np.array(results["out3"]).shape) + self.assertEqual([[72.0, 84.0, 96.0]], results["out1"]) + self.assertEqual([[-72.0, -84.0, -96.0]], results["out2"]) + self.assertEqual([[-96.0, -120.0, -144.0]], results["out3"]) def test_predict_paramfun_map_over_batch(self): NeuObj.clearNames() - input2 = Input('in2') - pp = Parameter('pp', sw=3, values=[[7],[8],[9]]) - ll = Constant('ll', sw=3, values=[[12],[13],[14]]) - oo = Constant('oo', sw=3, values=[[1],[2],[3]]) + input2 = Input("in2") + pp = Parameter("pp", sw=3, values=[[7], [8], [9]]) + ll = Constant("ll", sw=3, values=[[12], [13], [14]]) + oo = Constant("oo", sw=3, values=[[1], [2], [3]]) def fun_test(x, y, z, k): return (x + y) * (z - k) - fun_map = ParamFun(fun_test,parameters_and_constants=[ll,oo, pp]) - fun = ParamFun(fun_test, parameters_and_constants=[ll,oo, pp]) + fun_map = ParamFun(fun_test, parameters_and_constants=[ll, oo, pp]) + fun = ParamFun(fun_test, parameters_and_constants=[ll, oo, pp]) fun_map_2 = ParamFun(fun_test, map_over_batch=True) - out1 = Output('out1',fun_map(input2.tw(0.03))) - out2 = Output('out2', fun(input2.tw(0.03))) + out1 = Output("out1", fun_map(input2.tw(0.03))) + out2 = Output("out2", fun(input2.tw(0.03))) test = Modely(visualizer=None) - test.addModel('out',[out1,out2]) + test.addModel("out", [out1, out2]) test.neuralizeModel(0.01) - results = test({'in2': [0, 1, 2]}) - self.assertEqual((1, 3), np.array(results['out1']).shape) - self.assertEqual([[-72.0, -84.0, -96.0]], results['out1']) - self.assertEqual((1, 3), np.array(results['out2']).shape) - self.assertEqual([[-72.0, -84.0, -96.0]], results['out2']) - - out3 = Output('out3', fun_map_2(input2.tw(0.03), 4.0, pp, ll)) - out4 = Output('out4', fun_map_2(input2.tw(0.01), 2.0, pp, oo)) + results = test({"in2": [0, 1, 2]}) + self.assertEqual((1, 3), np.array(results["out1"]).shape) + self.assertEqual([[-72.0, -84.0, -96.0]], results["out1"]) + self.assertEqual((1, 3), np.array(results["out2"]).shape) + self.assertEqual([[-72.0, -84.0, -96.0]], results["out2"]) + + out3 = Output("out3", fun_map_2(input2.tw(0.03), 4.0, pp, ll)) + out4 = Output("out4", fun_map_2(input2.tw(0.01), 2.0, pp, oo)) with self.assertRaises(ValueError): fun_map_2(4.0, 1, pp, ll) - test.addModel('out-new', [out3,out4]) + test.addModel("out-new", [out3, out4]) with self.assertRaises(NameError): - test.addModel('out',[out1,out2]) + test.addModel("out", [out1, out2]) test.neuralizeModel(0.01) - results = test({'in2': [0, 1, 2]}) - self.assertEqual((1, 3), np.array(results['out3']).shape) - self.assertEqual((1, 3), np.array(results['out4']).shape) + results = test({"in2": [0, 1, 2]}) + self.assertEqual((1, 3), np.array(results["out3"]).shape) + self.assertEqual((1, 3), np.array(results["out4"]).shape) # ([0,1,2]+4)*([7,8,9]-[12,13,14]) -> [4,5,6]*[-5,-5,-5] - self.assertEqual([[-20.0, -25.0, -30.0]], results['out3']) - self.assertEqual([[24.0, 24.0, 24.0]], results['out4']) + self.assertEqual([[-20.0, -25.0, -30.0]], results["out3"]) + self.assertEqual([[24.0, 24.0, 24.0]], results["out4"]) def test_predict_fuzzify(self): NeuObj.clearNames() - input = Input('in1') - fuzzi = Fuzzify(6, range=[0, 5], functions='Rectangular')(input.last()) - out = Output('out', fuzzi) + input = Input("in1") + fuzzi = Fuzzify(6, range=[0, 5], functions="Rectangular")(input.last()) + out = Output("out", fuzzi) test = Modely(visualizer=None) - test.addModel('out',[out]) + test.addModel("out", [out]) test.neuralizeModel() - results = test({'in1': [0, 1, 2]}) - self.assertEqual((3, 1, 6), np.array(results['out']).shape) - self.assertEqual([[[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]],[[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]],[[0.0, 0.0, 1.0, 0.0, 0.0, 0.0]]], results['out']) + results = test({"in1": [0, 1, 2]}) + self.assertEqual((3, 1, 6), np.array(results["out"]).shape) + self.assertEqual( + [ + [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]], + [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]], + [[0.0, 0.0, 1.0, 0.0, 0.0, 0.0]], + ], + results["out"], + ) def fun(x): import torch + return torch.sign(x) - fuz = Fuzzify(output_dimension=11, range=[-5, 5], functions=[fun,fun])(input.last()) - out = Output('out2', fuz) - test.addModel('out2',[out]) + fuz = Fuzzify(output_dimension=11, range=[-5, 5], functions=[fun, fun])( + input.last() + ) + out = Output("out2", fuz) + test.addModel("out2", [out]) test.neuralizeModel() - results = test({'in1': [0, 1, 2]}) - self.assertEqual((3, 1, 11), np.array(results['out2']).shape) - self.assertEqual([[[1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, -1.0, -1.0]], - [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, -1.0]], - [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0]]], results['out2']) + results = test({"in1": [0, 1, 2]}) + self.assertEqual((3, 1, 11), np.array(results["out2"]).shape) + self.assertEqual( + [ + [[1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, -1.0, -1.0]], + [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0, -1.0]], + [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, -1.0, -1.0, -1.0]], + ], + results["out2"], + ) def test_sw_on_stream_sw_by_heand(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") sw_from_input = input.sw(7) - state = Input('state') + state = Input("state") sw_from_output = Connect(sw_from_input, state) - out_aux = Output('out_aux', sw_from_output) - out1 = Output('out1', state.sw(3)) + out_aux = Output("out_aux", sw_from_output) + out1 = Output("out1", state.sw(3)) test = Modely(visualizer=None) - test.addModel('out_A', [out_aux,out1]) + test.addModel("out_A", [out_aux, out1]) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4, 3), np.array(results['out1']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out1']) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 3), np.array(results["out1"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out1"], + ) NeuObj.clearNames() - state = Input('state') - out_aux = Output('out_aux', sw_from_input) - out1 = Output('out1', state.sw(3)) + state = Input("state") + out_aux = Output("out_aux", sw_from_input) + out1 = Output("out1", state.sw(3)) test = Modely(visualizer=None) - test.addModel('out_A', [out_aux,out1]) + test.addModel("out_A", [out_aux, out1]) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, connect={'state': 'out_aux'}) + results = test( + {"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, connect={"state": "out_aux"} + ) with self.assertRaises(ValueError): - test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, connect={'out_aux': 'state'}) - self.assertEqual((4, 3), np.array(results['out1']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out1']) + test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, connect={"out_aux": "state"}) + self.assertEqual((4, 3), np.array(results["out1"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out1"], + ) def test_sw_on_stream_sw(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") sw_from_input = input.sw(7) - out1 = Output('out1', sw_from_input.sw(3)) + out1 = Output("out1", sw_from_input.sw(3)) test = Modely(visualizer=None) - test.addModel('out_A', out1) + test.addModel("out_A", out1) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4, 3), np.array(results['out1']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out1']) - - NeuObj.clearNames(['out1','out2']) - out1 = Output('out1', sw_from_input.sw(3)) - out2 = Output('out2', sw_from_input.sw(8)) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 3), np.array(results["out1"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out1"], + ) + + NeuObj.clearNames(["out1", "out2"]) + out1 = Output("out1", sw_from_input.sw(3)) + out2 = Output("out2", sw_from_input.sw(8)) with self.assertRaises(ValueError): - Output('out3', sw_from_input.sw(-1)) + Output("out3", sw_from_input.sw(-1)) test = Modely(visualizer=None) - test.addModel('out_A', [out1,out2]) + test.addModel("out_A", [out1, out2]) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4, 3), np.array(results['out1']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out1']) - self.assertEqual((4, 8), np.array(results['out2']).shape) - self.assertEqual([[0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], - [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], - [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], - [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]], results['out2']) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 3), np.array(results["out1"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out1"], + ) + self.assertEqual((4, 8), np.array(results["out2"]).shape) + self.assertEqual( + [ + [0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], + [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], + [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], + ], + results["out2"], + ) def test_tw_on_stream_tw(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") tw_from_input = input.tw(3.5) - out1 = Output('out1', tw_from_input.tw(1.5)) + out1 = Output("out1", tw_from_input.tw(1.5)) test = Modely(visualizer=None) - test.addModel('out_A', out1) + test.addModel("out_A", out1) test.neuralizeModel(0.5) - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4, 3), np.array(results['out1']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out1']) - - out1 = Output('out11', tw_from_input.tw(1.5)) - out2 = Output('out21', tw_from_input.tw(4)) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 3), np.array(results["out1"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out1"], + ) + + out1 = Output("out11", tw_from_input.tw(1.5)) + out2 = Output("out21", tw_from_input.tw(4)) with self.assertRaises(ValueError): - Output('out3', tw_from_input.tw(-1)) + Output("out3", tw_from_input.tw(-1)) test = Modely(visualizer=None) - test.addModel('out_A', [out1,out2]) + test.addModel("out_A", [out1, out2]) test.neuralizeModel(0.5) - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4, 3), np.array(results['out11']).shape) - self.assertEqual([[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], results['out11']) - self.assertEqual((4, 8), np.array(results['out21']).shape) - self.assertEqual([[0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], - [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], - [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], - [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]], results['out21']) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 3), np.array(results["out11"]).shape) + self.assertEqual( + [[4.0, 5.0, 6.0], [5.0, 6.0, 7.0], [6.0, 7.0, 8.0], [7.0, 8.0, 9.0]], + results["out11"], + ) + self.assertEqual((4, 8), np.array(results["out21"]).shape) + self.assertEqual( + [ + [0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], + [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], + [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], + ], + results["out21"], + ) def test_sw_on_stream_sw_complex(self): NeuObj.clearNames() - input = Input('in1') - state = Input('state') + input = Input("in1") + state = Input("state") sw_3 = input.sw(3) sw_7 = input.sw(7) @@ -1493,200 +2081,317 @@ def test_sw_on_stream_sw_complex(self): state4 = state.sw(4) state8 = state.sw(8) - out21 = Output('out21', sw_3.sw(2)) - out61 = Output('out61', sw_7.sw(6)) - out22 = Output('out22', SamplePart(sw_3,1,3)) - out62 = Output('out62', SamplePart(sw_7,1,7)) + out21 = Output("out21", sw_3.sw(2)) + out61 = Output("out61", sw_7.sw(6)) + out22 = Output("out22", SamplePart(sw_3, 1, 3)) + out62 = Output("out62", SamplePart(sw_7, 1, 7)) test = Modely(visualizer=None) - test.addModel('out_A', [out21,out61,out22,out62]) + test.addModel("out_A", [out21, out61, out22, out62]) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual(results['out21'], results['out22']) - self.assertEqual(results['out61'], results['out62']) - - out31 = Output('out31', sw_3) - out71 = Output('out71', sw_7) - out32 = Output('out32', SamplePart(state4,1,4)) - out72 = Output('out72', SamplePart(state8,1,8)) - out33 = Output('out33', sw_3.sw(3)) - out73 = Output('out73', sw_7.sw(7)) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(results["out21"], results["out22"]) + self.assertEqual(results["out61"], results["out62"]) + + out31 = Output("out31", sw_3) + out71 = Output("out71", sw_7) + out32 = Output("out32", SamplePart(state4, 1, 4)) + out72 = Output("out72", SamplePart(state8, 1, 8)) + out33 = Output("out33", sw_3.sw(3)) + out73 = Output("out73", sw_7.sw(7)) test = Modely(visualizer=None) - test.addModel('out_B', [out31,out71,out32,out72,out33,out73]) + test.addModel("out_B", [out31, out71, out32, out72, out33, out73]) test.addConnect(sw_7, state) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual(results['out31'], results['out32']) - self.assertEqual(results['out32'], results['out33']) - self.assertEqual(results['out71'], results['out72']) - self.assertEqual(results['out72'], results['out73']) - - out41 = Output('out41', state4) - out42 = Output('out42', sw_3.sw(4)) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(results["out31"], results["out32"]) + self.assertEqual(results["out32"], results["out33"]) + self.assertEqual(results["out71"], results["out72"]) + self.assertEqual(results["out72"], results["out73"]) + + out41 = Output("out41", state4) + out42 = Output("out42", sw_3.sw(4)) test = Modely(visualizer=None) - test.addModel('out_C', [out41,out42]) + test.addModel("out_C", [out41, out42]) test.addConnect(sw_3, state) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual(results['out41'], results['out42']) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(results["out41"], results["out42"]) def test_sw_on_stream_tw_and_opposite(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") sw_3 = input.sw(3) tw_4 = input.tw(1) - out3tw1 = Output('out3tw1', sw_3.tw(0.2)) - out3tw10 = Output('out3tw10', sw_3.tw(2)) - out4sw2 = Output('out4sw2', tw_4.sw(2)) - out4sw6 = Output('out4sw6', tw_4.sw(6)) + out3tw1 = Output("out3tw1", sw_3.tw(0.2)) + out3tw10 = Output("out3tw10", sw_3.tw(2)) + out4sw2 = Output("out4sw2", tw_4.sw(2)) + out4sw6 = Output("out4sw6", tw_4.sw(6)) test = Modely(visualizer=None) - test.addModel('out_A', [out3tw1, out3tw10, out4sw2, out4sw6]) + test.addModel("out_A", [out3tw1, out3tw10, out4sw2, out4sw6]) test.neuralizeModel(0.2) - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9, -3]}) - self.assertEqual(results['out3tw1'], [4, 5, 6, 7, 8, 9, -3]) - self.assertEqual(results['out3tw10'], [[0, 0, 0, 0, 0, 0, 0, 2, 3, 4], - [0, 0, 0, 0, 0,0, 2, 3, 4, 5], - [0, 0, 0, 0, 0, 2, 3, 4 ,5, 6], - [0, 0, 0, 0, 2, 3, 4, 5, 6, 7], - [0, 0, 0, 2, 3, 4, 5, 6, 7, 8], - [0, 0, 2, 3, 4, 5, 6, 7, 8, 9], - [0, 2, 3, 4, 5, 6, 7, 8, 9, -3]]) - self.assertEqual(results['out4sw2'], [[3, 4],[4,5],[5,6],[6,7],[7,8],[8,9], [9,-3]]) - self.assertEqual(results['out4sw6'], [[0, 14, 1, 2, 3, 4], - [14, 1, 2, 3, 4, 5], - [1, 2, 3, 4 ,5, 6], - [2, 3, 4, 5, 6, 7], - [3, 4, 5, 6, 7, 8], - [4, 5, 6, 7, 8, 9], - [5, 6, 7, 8, 9, -3]]) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9, -3]}) + self.assertEqual(results["out3tw1"], [4, 5, 6, 7, 8, 9, -3]) + self.assertEqual( + results["out3tw10"], + [ + [0, 0, 0, 0, 0, 0, 0, 2, 3, 4], + [0, 0, 0, 0, 0, 0, 2, 3, 4, 5], + [0, 0, 0, 0, 0, 2, 3, 4, 5, 6], + [0, 0, 0, 0, 2, 3, 4, 5, 6, 7], + [0, 0, 0, 2, 3, 4, 5, 6, 7, 8], + [0, 0, 2, 3, 4, 5, 6, 7, 8, 9], + [0, 2, 3, 4, 5, 6, 7, 8, 9, -3], + ], + ) + self.assertEqual( + results["out4sw2"], + [[3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, -3]], + ) + self.assertEqual( + results["out4sw6"], + [ + [0, 14, 1, 2, 3, 4], + [14, 1, 2, 3, 4, 5], + [1, 2, 3, 4, 5, 6], + [2, 3, 4, 5, 6, 7], + [3, 4, 5, 6, 7, 8], + [4, 5, 6, 7, 8, 9], + [5, 6, 7, 8, 9, -3], + ], + ) def test_sw_on_stream_sw_delay(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") sw_3 = input.sw(3) - out21 = Output('out21', sw_3.sw(2)) - out41 = Output('out41', sw_3.sw(4)) - out22 = Output('out22', sw_3.sw([-2,0])) - out42 = Output('out42', sw_3.sw([-4,0])) + out21 = Output("out21", sw_3.sw(2)) + out41 = Output("out41", sw_3.sw(4)) + out22 = Output("out22", sw_3.sw([-2, 0])) + out42 = Output("out42", sw_3.sw([-4, 0])) - out231 = Output('out231', sw_3.sw([-3,-1])) - out451 = Output('out451', sw_3.sw([-5,-1])) + out231 = Output("out231", sw_3.sw([-3, -1])) + out451 = Output("out451", sw_3.sw([-5, -1])) - out242 = Output('out242', sw_3.sw([-4,-2])) - out462 = Output('out462', sw_3.sw([-6,-2])) + out242 = Output("out242", sw_3.sw([-4, -2])) + out462 = Output("out462", sw_3.sw([-6, -2])) test = Modely(visualizer=None) - test.addModel('out_A', [out21,out41,out22,out42,out231,out451,out242,out462]) + test.addModel( + "out_A", [out21, out41, out22, out42, out231, out451, out242, out462] + ) test.neuralizeModel() - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual(results['out21'], results['out22']) - self.assertEqual(results['out21'], [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9]]) - - self.assertEqual(results['out41'], results['out42']) - self.assertEqual(results['out41'], [[0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9]]) - - self.assertEqual(results['out231'], [[14,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8]]) - self.assertEqual(results['out451'], [[0, 0, 14, 1], [0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]) - - self.assertEqual(results['out242'], [[0,14],[14,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]) - self.assertEqual(results['out462'], [[0, 0, 0, 14], [0, 0, 14, 1], [0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7]]) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(results["out21"], results["out22"]) + self.assertEqual( + results["out21"], + [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]], + ) + + self.assertEqual(results["out41"], results["out42"]) + self.assertEqual( + results["out41"], + [ + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + [5, 6, 7, 8], + [6, 7, 8, 9], + ], + ) + + self.assertEqual( + results["out231"], + [[14, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8]], + ) + self.assertEqual( + results["out451"], + [ + [0, 0, 14, 1], + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + [5, 6, 7, 8], + ], + ) + + self.assertEqual( + results["out242"], + [[0, 14], [14, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]], + ) + self.assertEqual( + results["out462"], + [ + [0, 0, 0, 14], + [0, 0, 14, 1], + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + ], + ) def test_tw_on_stream_tw_delay(self): NeuObj.clearNames() - input = Input('in1') + input = Input("in1") tw_3 = input.tw(1.5) - out21 = Output('out21', tw_3.tw(1)) - out41 = Output('out41', tw_3.tw(2)) - out22 = Output('out22', tw_3.tw([-1,0])) - out42 = Output('out42', tw_3.tw([-2,0])) + out21 = Output("out21", tw_3.tw(1)) + out41 = Output("out41", tw_3.tw(2)) + out22 = Output("out22", tw_3.tw([-1, 0])) + out42 = Output("out42", tw_3.tw([-2, 0])) - out231 = Output('out231', tw_3.tw([-1.5,-0.5])) - out451 = Output('out451', tw_3.tw([-2.5,-0.5])) + out231 = Output("out231", tw_3.tw([-1.5, -0.5])) + out451 = Output("out451", tw_3.tw([-2.5, -0.5])) - out242 = Output('out242', tw_3.tw([-2,-1])) - out462 = Output('out462', tw_3.tw([-3,-1])) + out242 = Output("out242", tw_3.tw([-2, -1])) + out462 = Output("out462", tw_3.tw([-3, -1])) test = Modely(visualizer=None) - test.addModel('out_A', [out21,out41,out22,out42,out231,out451,out242,out462]) + test.addModel( + "out_A", [out21, out41, out22, out42, out231, out451, out242, out462] + ) test.neuralizeModel(0.5) - results = test({'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual(results['out21'], results['out22']) - self.assertEqual(results['out21'], [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9]]) - - self.assertEqual(results['out41'], results['out42']) - self.assertEqual(results['out41'], [[0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9]]) - - self.assertEqual(results['out231'], [[14,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8]]) - self.assertEqual(results['out451'], [[0, 0, 14, 1], [0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]) - - self.assertEqual(results['out242'], [[0,14],[14,1],[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]) - self.assertEqual(results['out462'], [[0, 0, 0, 14], [0, 0, 14, 1], [0, 14, 1, 2], [14, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7]]) + results = test({"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(results["out21"], results["out22"]) + self.assertEqual( + results["out21"], + [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]], + ) + + self.assertEqual(results["out41"], results["out42"]) + self.assertEqual( + results["out41"], + [ + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + [5, 6, 7, 8], + [6, 7, 8, 9], + ], + ) + + self.assertEqual( + results["out231"], + [[14, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8]], + ) + self.assertEqual( + results["out451"], + [ + [0, 0, 14, 1], + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + [5, 6, 7, 8], + ], + ) + + self.assertEqual( + results["out242"], + [[0, 14], [14, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]], + ) + self.assertEqual( + results["out462"], + [ + [0, 0, 0, 14], + [0, 0, 14, 1], + [0, 14, 1, 2], + [14, 1, 2, 3], + [1, 2, 3, 4], + [2, 3, 4, 5], + [3, 4, 5, 6], + [4, 5, 6, 7], + ], + ) def test_z_on_stream_sw(self): NeuObj.clearNames() - input = Input('inin') + input = Input("inin") sw_from_input = input.sw(5) - out2 = Output('out2', sw_from_input.z(1)) + out2 = Output("out2", sw_from_input.z(1)) with self.assertRaises(ValueError): - Output('out3', sw_from_input.z(-1)) + Output("out3", sw_from_input.z(-1)) with self.assertRaises(TypeError): - Output('out3', sw_from_input.delay(1)) + Output("out3", sw_from_input.delay(1)) test = Modely(visualizer=None) - test.addModel('out_A', [out2]) + test.addModel("out_A", [out2]) test.neuralizeModel(0.5) - results = test({'inin': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((6, 5), np.array(results['out2']).shape) - self.assertEqual( [[0.0, 14.0, 1.0, 2.0, 3.0], - [14.0, 1.0, 2.0, 3.0, 4.0], - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 3.0, 4.0, 5.0, 6.0], - [3.0, 4.0, 5.0, 6.0, 7.0], - [4.0, 5.0, 6.0, 7.0, 8.0]], results['out2']) + results = test({"inin": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((6, 5), np.array(results["out2"]).shape) + self.assertEqual( + [ + [0.0, 14.0, 1.0, 2.0, 3.0], + [14.0, 1.0, 2.0, 3.0, 4.0], + [1.0, 2.0, 3.0, 4.0, 5.0], + [2.0, 3.0, 4.0, 5.0, 6.0], + [3.0, 4.0, 5.0, 6.0, 7.0], + [4.0, 5.0, 6.0, 7.0, 8.0], + ], + results["out2"], + ) def test_delay_on_stream_tw(self): NeuObj.clearNames() - input = Input('inin') + input = Input("inin") tw_from_input = input.tw(3.5) - out1 = Output('out1', tw_from_input.delay(1)) + out1 = Output("out1", tw_from_input.delay(1)) with self.assertRaises(ValueError): - Output('out3', tw_from_input.delay(-1)) + Output("out3", tw_from_input.delay(-1)) with self.assertRaises(TypeError): - Output('out3', tw_from_input.z(1)) + Output("out3", tw_from_input.z(1)) test = Modely(visualizer=None) - test.addModel('out_A', [out1]) + test.addModel("out_A", [out1]) test.neuralizeModel(0.5) - results = test({'inin': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) - self.assertEqual((4,7), np.array(results['out1']).shape) - self.assertEqual([[0.0, 0.0, 14.0, 1.0, 2.0, 3.0, 4.0], - [0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0], - [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], - [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]], results['out1']) - #TODO add test with initialization of state variable + results = test({"inin": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual((4, 7), np.array(results["out1"]).shape) + self.assertEqual( + [ + [0.0, 0.0, 14.0, 1.0, 2.0, 3.0, 4.0], + [0.0, 14.0, 1.0, 2.0, 3.0, 4.0, 5.0], + [14.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], + ], + results["out1"], + ) + # TODO add test with initialization of state variable def test_localmodel(self): NeuObj.clearNames() - x = Input('x') - F = Input('F') - activationA = Fuzzify(2, [0, 1], functions='Triangular')(x.tw(1)) - activationB = Fuzzify(2, [0, 1], functions='Triangular')(F.tw(1)) + x = Input("x") + F = Input("F") + activationA = Fuzzify(2, [0, 1], functions="Triangular")(x.tw(1)) + activationB = Fuzzify(2, [0, 1], functions="Triangular")(F.tw(1)) def myFun(in1, p1, p2): return p1 * in1 + p2 - p1_0 = Parameter('p1_0', values=[[1]]) - p1_1 = Parameter('p1_1', values=[[2]]) - p2_0 = Parameter('p2_0', values=[[2]]) - p2_1 = Parameter('p2_1', values=[[3]]) + p1_0 = Parameter("p1_0", values=[[1]]) + p1_1 = Parameter("p1_1", values=[[2]]) + p2_0 = Parameter("p2_0", values=[[2]]) + p2_1 = Parameter("p2_1", values=[[3]]) def input_function_gen(idx_list): if idx_list == [0, 0]: @@ -1700,248 +2405,470 @@ def input_function_gen(idx_list): return ParamFun(myFun, parameters_and_constants=[p1, p2]) def output_function_gen(idx_list): - pfir = Parameter('pfir_' + str(idx_list), tw=1, dimensions=2, - values=[[1 + idx_list[0], 2 + idx_list[1]], [3 + idx_list[0], 4 + idx_list[1]]]) + pfir = Parameter( + "pfir_" + str(idx_list), + tw=1, + dimensions=2, + values=[ + [1 + idx_list[0], 2 + idx_list[1]], + [3 + idx_list[0], 4 + idx_list[1]], + ], + ) return Fir(2, W=pfir) - loc = LocalModel(input_function=input_function_gen, output_function=output_function_gen, pass_indexes=True)(x.tw(1), (activationA, activationB)) + loc = LocalModel( + input_function=input_function_gen, + output_function=output_function_gen, + pass_indexes=True, + )(x.tw(1), (activationA, activationB)) # Example of the structure of the local model - pfir00 = Parameter('N_pfir_[0, 0]', tw=1, dimensions=2, values=[[1, 2], [3, 4]]) - pfir01 = Parameter('N_pfir_[0, 1]', tw=1, dimensions=2, values=[[1, 3], [3, 5]]) - pfir10 = Parameter('N_pfir_[1, 0]', tw=1, dimensions=2, values=[[2, 2], [4, 4]]) - pfir11 = Parameter('N_pfir_[1, 1]', tw=1, dimensions=2, values=[[2, 3], [4, 5]]) + pfir00 = Parameter("N_pfir_[0, 0]", tw=1, dimensions=2, values=[[1, 2], [3, 4]]) + pfir01 = Parameter("N_pfir_[0, 1]", tw=1, dimensions=2, values=[[1, 3], [3, 5]]) + pfir10 = Parameter("N_pfir_[1, 0]", tw=1, dimensions=2, values=[[2, 2], [4, 4]]) + pfir11 = Parameter("N_pfir_[1, 1]", tw=1, dimensions=2, values=[[2, 3], [4, 5]]) parfun_00 = ParamFun(myFun, parameters_and_constants=[p1_0, p2_0])(x.tw(1)) parfun_01 = ParamFun(myFun, parameters_and_constants=[p1_0, p2_1])(x.tw(1)) parfun_10 = ParamFun(myFun, parameters_and_constants=[p1_1, p2_0])(x.tw(1)) parfun_11 = ParamFun(myFun, parameters_and_constants=[p1_1, p2_1])(x.tw(1)) - out_in_00 = Output('parfun00', parfun_00) - out_in_01 = Output('parfun01', parfun_01) - out_in_10 = Output('parfun10', parfun_10) - out_in_11 = Output('parfun11', parfun_11) - actA = Output('fuzzyA', activationA) - actB = Output('fuzzyB', activationB) + out_in_00 = Output("parfun00", parfun_00) + out_in_01 = Output("parfun01", parfun_01) + out_in_10 = Output("parfun10", parfun_10) + out_in_11 = Output("parfun11", parfun_11) + actA = Output("fuzzyA", activationA) + actB = Output("fuzzyB", activationB) act_selA0 = Select(activationA, 0) act_selA1 = Select(activationA, 1) act_selB0 = Select(activationB, 0) act_selB1 = Select(activationB, 1) - out_act_selA0 = Output('fuzzy_selA0', act_selA0) - out_act_selA1 = Output('fuzzy_selA1', act_selA1) - out_act_selB0 = Output('fuzzy_selB0', act_selB0) - out_act_selB1 = Output('fuzzy_selB1', act_selB1) + out_act_selA0 = Output("fuzzy_selA0", act_selA0) + out_act_selA1 = Output("fuzzy_selA1", act_selA1) + out_act_selB0 = Output("fuzzy_selB0", act_selB0) + out_act_selB1 = Output("fuzzy_selB1", act_selB1) mul00 = parfun_00 * act_selA0 * act_selB0 mul01 = parfun_01 * act_selA0 * act_selB1 mul10 = parfun_10 * act_selA1 * act_selB0 mul11 = parfun_11 * act_selA1 * act_selB1 - out_mul00 = Output('mul00', mul00) - out_mul01 = Output('mul01', mul01) - out_mul10 = Output('mul10', mul10) - out_mul11 = Output('mul11', mul11) + out_mul00 = Output("mul00", mul00) + out_mul01 = Output("mul01", mul01) + out_mul10 = Output("mul10", mul10) + out_mul11 = Output("mul11", mul11) fir00 = Fir(2, W=pfir00)(mul00) fir01 = Fir(2, W=pfir01)(mul01) fir10 = Fir(2, W=pfir10)(mul10) fir11 = Fir(2, W=pfir11)(mul11) - out_fir00 = Output('fir00', fir00) - out_fir01 = Output('fir01', fir01) - out_fir10 = Output('fir10', fir10) - out_fir11 = Output('fir11', fir11) + out_fir00 = Output("fir00", fir00) + out_fir01 = Output("fir01", fir01) + out_fir10 = Output("fir10", fir10) + out_fir11 = Output("fir11", fir11) sum = fir00 + fir01 + fir10 + fir11 - out_sum = Output('out_sum', sum) - out = Output('out', loc) + out_sum = Output("out_sum", sum) + out = Output("out", loc) test = Modely(visualizer=None) - test.addModel('all_out', [out_in_00, out_in_01, out_in_10, out_in_11, - out_act_selA0, out_act_selA1, out_act_selB0, out_act_selB1, - out_mul00, out_mul01, out_mul10, out_mul11, - out_fir00, out_fir01, out_fir10, out_fir11, - out_sum]) - test.addModel('out', out) + test.addModel( + "all_out", + [ + out_in_00, + out_in_01, + out_in_10, + out_in_11, + out_act_selA0, + out_act_selA1, + out_act_selB0, + out_act_selB1, + out_mul00, + out_mul01, + out_mul10, + out_mul11, + out_fir00, + out_fir01, + out_fir10, + out_fir11, + out_sum, + ], + ) + test.addModel("out", out) test.neuralizeModel(0.5) # Three semples with a dimensions 2 - result = test({'x': [0, 1, -2, 3], 'F': [-2, 2, 1, 5]}) - self.assertEqual(result['out_sum'],result['out']) + result = test({"x": [0, 1, -2, 3], "F": [-2, 2, 1, 5]}) + self.assertEqual(result["out_sum"], result["out"]) def test_integrate_derivate(self): NeuObj.clearNames() - input = Input('in1') - - in1_s = Output('in1_s', input.s(1)) - in1_s2 = Output('in1_s2', input.s(2)) - in1_s2_2 = Output('in1_s2_2', Differentiate(input.s(1))) - in1_s2_3 = Output('in1_s2_3', input.s(1).s(1)) - in1_s_2 = Output('in1_s_2', input.s(2).s(-1)) - - in1_sm = Output('in1_sm', input.s(-1)) - in1_sm2 = Output('in1_sm2', input.s(-2)) - in1_sm2_2 = Output('in1_sm2_2', Integrate(input.s(-1))) - in1_sm2_3 = Output('in1_sm2_3', input.s(-1).s(-1)) - in1_sm_2 = Output('in1_sm_2', input.s(-2).s(1)) - - in1_1 = Output('in1_1', Integrate(input.s(1))) - in1_2 = Output('in1_2', Integrate(Integrate(input.s(2)))) - in1_3 = Output('in1_3', Integrate(Integrate(Differentiate(input.s(1))))) - - in1_1_2 = Output('in1_1_2', Differentiate(input.s(-1))) - in1_2_2 = Output('in1_2_2', Differentiate(Differentiate(input.s(-2)))) - in1_3_2 = Output('in1_3_2', Differentiate(Differentiate(Integrate(input.s(-1))))) + input = Input("in1") + + in1_s = Output("in1_s", input.s(1)) + in1_s2 = Output("in1_s2", input.s(2)) + in1_s2_2 = Output("in1_s2_2", Differentiate(input.s(1))) + in1_s2_3 = Output("in1_s2_3", input.s(1).s(1)) + in1_s_2 = Output("in1_s_2", input.s(2).s(-1)) + + in1_sm = Output("in1_sm", input.s(-1)) + in1_sm2 = Output("in1_sm2", input.s(-2)) + in1_sm2_2 = Output("in1_sm2_2", Integrate(input.s(-1))) + in1_sm2_3 = Output("in1_sm2_3", input.s(-1).s(-1)) + in1_sm_2 = Output("in1_sm_2", input.s(-2).s(1)) + + in1_1 = Output("in1_1", Integrate(input.s(1))) + in1_2 = Output("in1_2", Integrate(Integrate(input.s(2)))) + in1_3 = Output("in1_3", Integrate(Integrate(Differentiate(input.s(1))))) + + in1_1_2 = Output("in1_1_2", Differentiate(input.s(-1))) + in1_2_2 = Output("in1_2_2", Differentiate(Differentiate(input.s(-2)))) + in1_3_2 = Output( + "in1_3_2", Differentiate(Differentiate(Integrate(input.s(-1)))) + ) test = Modely(visualizer=None) - test.addModel('out_A', [in1_s, in1_s2, in1_s2_2, in1_s2_3, in1_s_2, in1_sm, in1_sm2, in1_sm2_2, in1_sm2_3, in1_sm_2, in1_1, in1_2, in1_3, in1_1_2, in1_2_2, in1_3_2]) + test.addModel( + "out_A", + [ + in1_s, + in1_s2, + in1_s2_2, + in1_s2_3, + in1_s_2, + in1_sm, + in1_sm2, + in1_sm2_2, + in1_sm2_3, + in1_sm_2, + in1_1, + in1_2, + in1_3, + in1_1_2, + in1_2_2, + in1_3_2, + ], + ) test.neuralizeModel(1) - inin = {'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} + inin = {"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} results = test(inin) - self.assertEqual(results['in1_1'], inin['in1']) - self.assertEqual(results['in1_2'], inin['in1']) - self.assertEqual(results['in1_3'], inin['in1']) - self.assertEqual(results['in1_1_2'], inin['in1']) - self.assertEqual(results['in1_2_2'], inin['in1']) - self.assertEqual(results['in1_3_2'], inin['in1']) + self.assertEqual(results["in1_1"], inin["in1"]) + self.assertEqual(results["in1_2"], inin["in1"]) + self.assertEqual(results["in1_3"], inin["in1"]) + self.assertEqual(results["in1_1_2"], inin["in1"]) + self.assertEqual(results["in1_2_2"], inin["in1"]) + self.assertEqual(results["in1_3_2"], inin["in1"]) inin_s = [14, -13, 1, 1, 1, 1, 1, 1, 1, 1] inin_s2 = [14, -27, 14, 0, 0, 0, 0, 0, 0, 0] - self.assertEqual(results['in1_s'], inin_s) - self.assertEqual(results['in1_s_2'], inin_s) - self.assertEqual(results['in1_s2'], inin_s2) - self.assertEqual(results['in1_s2_2'], inin_s2) - self.assertEqual(results['in1_s2_3'], inin_s2) + self.assertEqual(results["in1_s"], inin_s) + self.assertEqual(results["in1_s_2"], inin_s) + self.assertEqual(results["in1_s2"], inin_s2) + self.assertEqual(results["in1_s2_2"], inin_s2) + self.assertEqual(results["in1_s2_3"], inin_s2) inin_sm = [14, 15, 17, 20, 24, 29, 35, 42, 50, 59] inin_sm2 = [14, 29, 46, 66, 90, 119, 154, 196, 246, 305] - self.assertEqual(results['in1_sm'], inin_sm) - self.assertEqual(results['in1_sm_2'], inin_sm) - self.assertEqual(results['in1_sm2'], inin_sm2) - self.assertEqual(results['in1_sm2_2'], inin_sm2) - self.assertEqual(results['in1_sm2_3'], inin_sm2) + self.assertEqual(results["in1_sm"], inin_sm) + self.assertEqual(results["in1_sm_2"], inin_sm) + self.assertEqual(results["in1_sm2"], inin_sm2) + self.assertEqual(results["in1_sm2_2"], inin_sm2) + self.assertEqual(results["in1_sm2_3"], inin_sm2) test = Modely(visualizer=None) - test.addModel('out_A', - [in1_s, in1_s2, in1_s2_2, in1_s2_3, in1_s_2, in1_sm, in1_sm2, in1_sm2_2, in1_sm2_3, in1_sm_2, in1_1, in1_2, in1_3, in1_1_2, in1_2_2, in1_3_2]) + test.addModel( + "out_A", + [ + in1_s, + in1_s2, + in1_s2_2, + in1_s2_3, + in1_s_2, + in1_sm, + in1_sm2, + in1_sm2_2, + in1_sm2_3, + in1_sm_2, + in1_1, + in1_2, + in1_3, + in1_1_2, + in1_2_2, + in1_3_2, + ], + ) test.neuralizeModel(0.01) - inin = {'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} + inin = {"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} results = test(inin) - self.TestAlmostEqual(results['in1_1'], inin['in1']) - self.TestAlmostEqual(results['in1_2'], inin['in1']) - self.TestAlmostEqual(results['in1_3'], inin['in1']) - self.TestAlmostEqual(results['in1_1_2'], inin['in1']) - self.TestAlmostEqual(results['in1_2_2'], inin['in1']) - self.TestAlmostEqual(results['in1_3_2'], inin['in1']) + self.TestAlmostEqual(results["in1_1"], inin["in1"]) + self.TestAlmostEqual(results["in1_2"], inin["in1"]) + self.TestAlmostEqual(results["in1_3"], inin["in1"]) + self.TestAlmostEqual(results["in1_1_2"], inin["in1"]) + self.TestAlmostEqual(results["in1_2_2"], inin["in1"]) + self.TestAlmostEqual(results["in1_3_2"], inin["in1"]) inin_s = [1400, -1300, 100, 100, 100, 100, 100, 100, 100, 100] inin_s2 = [140000, -270000, 140000, 0, 0, 0, 0, 0, 0, 0] - self.TestAlmostEqual(results['in1_s'], inin_s) - self.TestAlmostEqual(results['in1_s_2'], inin_s) - self.TestAlmostEqual(results['in1_s2'], inin_s2) - self.TestAlmostEqual(results['in1_s2_2'], inin_s2) - self.TestAlmostEqual(results['in1_s2_3'], inin_s2) + self.TestAlmostEqual(results["in1_s"], inin_s) + self.TestAlmostEqual(results["in1_s_2"], inin_s) + self.TestAlmostEqual(results["in1_s2"], inin_s2) + self.TestAlmostEqual(results["in1_s2_2"], inin_s2) + self.TestAlmostEqual(results["in1_s2_3"], inin_s2) inin_sm = [0.14, 0.15, 0.17, 0.20, 0.24, 0.29, 0.35, 0.42, 0.50, 0.59] - inin_sm2 = [0.0014, 0.0029, 0.0046, 0.0066, 0.0090, 0.0119, 0.0154, 0.0196, 0.0246, 0.0305] - self.TestAlmostEqual(results['in1_sm'], inin_sm) - self.TestAlmostEqual(results['in1_sm_2'], inin_sm) - self.TestAlmostEqual(results['in1_sm2'], inin_sm2) - self.TestAlmostEqual(results['in1_sm2_2'], inin_sm2) - self.TestAlmostEqual(results['in1_sm2_3'], inin_sm2) + inin_sm2 = [ + 0.0014, + 0.0029, + 0.0046, + 0.0066, + 0.0090, + 0.0119, + 0.0154, + 0.0196, + 0.0246, + 0.0305, + ] + self.TestAlmostEqual(results["in1_sm"], inin_sm) + self.TestAlmostEqual(results["in1_sm_2"], inin_sm) + self.TestAlmostEqual(results["in1_sm2"], inin_sm2) + self.TestAlmostEqual(results["in1_sm2_2"], inin_sm2) + self.TestAlmostEqual(results["in1_sm2_3"], inin_sm2) def test_integrate_derivate_trapezoidal(self): NeuObj.clearNames() - input = Input('in1') - - in1_s = Output('in1_s', input.s(1,method='trapezoidal')) - in1_s2 = Output('in1_s2', input.s(2,method='trapezoidal')) - in1_s2_2 = Output('in1_s2_2', Differentiate(input.s(1,method='trapezoidal'),method='trapezoidal')) - in1_s2_3 = Output('in1_s2_3', input.s(1,method='trapezoidal').s(1,method='trapezoidal')) - in1_s_2 = Output('in1_s_2', input.s(2,method='trapezoidal').s(-1,method='trapezoidal')) - - in1_sm = Output('in1_sm', input.s(-1,method='trapezoidal')) - in1_sm2 = Output('in1_sm2', input.s(-2,method='trapezoidal')) - in1_sm2_2 = Output('in1_sm2_2', Integrate(input.s(-1,method='trapezoidal'),method='trapezoidal')) - in1_sm2_3 = Output('in1_sm2_3', input.s(-1,method='trapezoidal').s(-1,method='trapezoidal')) - in1_sm_2 = Output('in1_sm_2', input.s(-2,method='trapezoidal').s(1,method='trapezoidal')) - - in1_1 = Output('in1_1', Integrate(input.s(1,method='trapezoidal'),method='trapezoidal')) - in1_2 = Output('in1_2', Integrate(Integrate(input.s(2,method='trapezoidal'),method='trapezoidal'),method='trapezoidal')) - in1_3 = Output('in1_3', Integrate(Integrate(Differentiate(input.s(1,method='trapezoidal'),method='trapezoidal'),method='trapezoidal'),method='trapezoidal')) - - in1_1_2 = Output('in1_1_2', Differentiate(input.s(-1,method='trapezoidal'),method='trapezoidal')) - in1_2_2 = Output('in1_2_2', Differentiate(Differentiate(input.s(-2,method='trapezoidal'),method='trapezoidal'),method='trapezoidal')) - in1_3_2 = Output('in1_3_2', Differentiate(Differentiate(Integrate(input.s(-1,method='trapezoidal'),method='trapezoidal'),method='trapezoidal'),method='trapezoidal')) + input = Input("in1") + + in1_s = Output("in1_s", input.s(1, method="trapezoidal")) + in1_s2 = Output("in1_s2", input.s(2, method="trapezoidal")) + in1_s2_2 = Output( + "in1_s2_2", + Differentiate(input.s(1, method="trapezoidal"), method="trapezoidal"), + ) + in1_s2_3 = Output( + "in1_s2_3", input.s(1, method="trapezoidal").s(1, method="trapezoidal") + ) + in1_s_2 = Output( + "in1_s_2", input.s(2, method="trapezoidal").s(-1, method="trapezoidal") + ) + + in1_sm = Output("in1_sm", input.s(-1, method="trapezoidal")) + in1_sm2 = Output("in1_sm2", input.s(-2, method="trapezoidal")) + in1_sm2_2 = Output( + "in1_sm2_2", + Integrate(input.s(-1, method="trapezoidal"), method="trapezoidal"), + ) + in1_sm2_3 = Output( + "in1_sm2_3", input.s(-1, method="trapezoidal").s(-1, method="trapezoidal") + ) + in1_sm_2 = Output( + "in1_sm_2", input.s(-2, method="trapezoidal").s(1, method="trapezoidal") + ) + + in1_1 = Output( + "in1_1", Integrate(input.s(1, method="trapezoidal"), method="trapezoidal") + ) + in1_2 = Output( + "in1_2", + Integrate( + Integrate(input.s(2, method="trapezoidal"), method="trapezoidal"), + method="trapezoidal", + ), + ) + in1_3 = Output( + "in1_3", + Integrate( + Integrate( + Differentiate( + input.s(1, method="trapezoidal"), method="trapezoidal" + ), + method="trapezoidal", + ), + method="trapezoidal", + ), + ) + + in1_1_2 = Output( + "in1_1_2", + Differentiate(input.s(-1, method="trapezoidal"), method="trapezoidal"), + ) + in1_2_2 = Output( + "in1_2_2", + Differentiate( + Differentiate(input.s(-2, method="trapezoidal"), method="trapezoidal"), + method="trapezoidal", + ), + ) + in1_3_2 = Output( + "in1_3_2", + Differentiate( + Differentiate( + Integrate(input.s(-1, method="trapezoidal"), method="trapezoidal"), + method="trapezoidal", + ), + method="trapezoidal", + ), + ) test = Modely(visualizer=None) - test.addModel('out_A', [in1_s, in1_s2, in1_s2_2, in1_s2_3, in1_s_2, in1_sm, in1_sm2, in1_sm2_2, in1_sm2_3, in1_sm_2, in1_1, in1_2, in1_3, in1_1_2, in1_2_2, in1_3_2]) + test.addModel( + "out_A", + [ + in1_s, + in1_s2, + in1_s2_2, + in1_s2_3, + in1_s_2, + in1_sm, + in1_sm2, + in1_sm2_2, + in1_sm2_3, + in1_sm_2, + in1_1, + in1_2, + in1_3, + in1_1_2, + in1_2_2, + in1_3_2, + ], + ) test.neuralizeModel(1) - inin = {'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} + inin = {"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} results = test(inin) - self.assertEqual(results['in1_1'], inin['in1']) - self.assertEqual(results['in1_2'], inin['in1']) - self.assertEqual(results['in1_3'], inin['in1']) - self.assertEqual(results['in1_1_2'], inin['in1']) - self.assertEqual(results['in1_2_2'], inin['in1']) - self.assertEqual(results['in1_3_2'], inin['in1']) - - inin_sm = [7., 14.5, 16., 18.5, 22., 26.5, 32., 38.5, 46., 54.5] - inin_sm2 = [ 3.5 , 14.25, 29.5 , 46.75, 67. , 91.25, 120.5 , 155.75, 198. , 248.25] - self.assertEqual(results['in1_sm'], inin_sm) - self.assertEqual(results['in1_sm_2'], inin_sm) - self.assertEqual(results['in1_sm2'], inin_sm2) - self.assertEqual(results['in1_sm2_2'], inin_sm2) - self.assertEqual(results['in1_sm2_3'], inin_sm2) + self.assertEqual(results["in1_1"], inin["in1"]) + self.assertEqual(results["in1_2"], inin["in1"]) + self.assertEqual(results["in1_3"], inin["in1"]) + self.assertEqual(results["in1_1_2"], inin["in1"]) + self.assertEqual(results["in1_2_2"], inin["in1"]) + self.assertEqual(results["in1_3_2"], inin["in1"]) + + inin_sm = [7.0, 14.5, 16.0, 18.5, 22.0, 26.5, 32.0, 38.5, 46.0, 54.5] + inin_sm2 = [3.5, 14.25, 29.5, 46.75, 67.0, 91.25, 120.5, 155.75, 198.0, 248.25] + self.assertEqual(results["in1_sm"], inin_sm) + self.assertEqual(results["in1_sm_2"], inin_sm) + self.assertEqual(results["in1_sm2"], inin_sm2) + self.assertEqual(results["in1_sm2_2"], inin_sm2) + self.assertEqual(results["in1_sm2_3"], inin_sm2) test = Modely(visualizer=None) - test.addModel('out_A', - [in1_s, in1_s2, in1_s2_2, in1_s2_3, in1_s_2, in1_sm, in1_sm2, in1_sm2_2, in1_sm2_3, in1_sm_2, in1_1, in1_2, in1_3, in1_1_2, in1_2_2, in1_3_2]) + test.addModel( + "out_A", + [ + in1_s, + in1_s2, + in1_s2_2, + in1_s2_3, + in1_s_2, + in1_sm, + in1_sm2, + in1_sm2_2, + in1_sm2_3, + in1_sm_2, + in1_1, + in1_2, + in1_3, + in1_1_2, + in1_2_2, + in1_3_2, + ], + ) test.neuralizeModel(0.01) - inin = {'in1': [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} + inin = {"in1": [14, 1, 2, 3, 4, 5, 6, 7, 8, 9]} results = test(inin) - self.TestAlmostEqual(results['in1_1'], inin['in1'], precision=4) - self.TestAlmostEqual(results['in1_2'], inin['in1'], precision=4) - self.TestAlmostEqual(results['in1_3'], inin['in1'], precision=4) - self.TestAlmostEqual(results['in1_1_2'], inin['in1'], precision=4) - self.TestAlmostEqual(results['in1_2_2'], inin['in1'], precision=3) - self.TestAlmostEqual(results['in1_3_2'], inin['in1'], precision=3) - - inin_sm = [ 0.07 , 0.145, 0.16 , 0.185, 0.22 , 0.265, 0.32 , 0.385, 0.46 , 0.545] - inin_sm2 = [0.00035 , 0.001425, 0.00295 , 0.004675, 0.0067 , 0.009125, 0.01205 , 0.015575, 0.0198 , 0.024825] - self.TestAlmostEqual(results['in1_sm'], inin_sm) - self.TestAlmostEqual(results['in1_sm_2'], inin_sm) - self.TestAlmostEqual(results['in1_sm2'], inin_sm2) - self.TestAlmostEqual(results['in1_sm2_2'], inin_sm2) - self.TestAlmostEqual(results['in1_sm2_3'], inin_sm2) + self.TestAlmostEqual(results["in1_1"], inin["in1"], precision=4) + self.TestAlmostEqual(results["in1_2"], inin["in1"], precision=4) + self.TestAlmostEqual(results["in1_3"], inin["in1"], precision=4) + self.TestAlmostEqual(results["in1_1_2"], inin["in1"], precision=4) + self.TestAlmostEqual(results["in1_2_2"], inin["in1"], precision=3) + self.TestAlmostEqual(results["in1_3_2"], inin["in1"], precision=3) + + inin_sm = [0.07, 0.145, 0.16, 0.185, 0.22, 0.265, 0.32, 0.385, 0.46, 0.545] + inin_sm2 = [ + 0.00035, + 0.001425, + 0.00295, + 0.004675, + 0.0067, + 0.009125, + 0.01205, + 0.015575, + 0.0198, + 0.024825, + ] + self.TestAlmostEqual(results["in1_sm"], inin_sm) + self.TestAlmostEqual(results["in1_sm_2"], inin_sm) + self.TestAlmostEqual(results["in1_sm2"], inin_sm2) + self.TestAlmostEqual(results["in1_sm2_2"], inin_sm2) + self.TestAlmostEqual(results["in1_sm2_3"], inin_sm2) def test_derivate_wrt_input(self): NeuObj.clearNames() - x = Input('x') + x = Input("x") x_last = x.last() def parametric_fun(x, a, b, c, d): import torch - return x ** 3 * a + x ** 2 * b + torch.sin(x) * c + d + + return x**3 * a + x**2 * b + torch.sin(x) * c + d def dx_parametric_fun(x, a, b, c, d): import torch - return (3 * x ** 2 * a) + (2 * x * b) + c * torch.cos(x) - fun = ParamFun(parametric_fun,['a','b','c','d'])(x_last) - approx_y = Output('out', fun) - approx_dy_dx = Output('d_out', Differentiate(fun, x_last)) + return (3 * x**2 * a) + (2 * x * b) + c * torch.cos(x) + + fun = ParamFun(parametric_fun, ["a", "b", "c", "d"])(x_last) + approx_y = Output("out", fun) + approx_dy_dx = Output("d_out", Differentiate(fun, x_last)) test = Modely(visualizer=None, seed=12) - test.addModel('model', [approx_dy_dx, approx_y]) + test.addModel("model", [approx_dy_dx, approx_y]) test.neuralizeModel() - results = test({'x':[1,2]}) - self.assertAlmostEqual(results['out'][0], parametric_fun(torch.tensor(1), torch.tensor(test.parameters['a']), - torch.tensor(test.parameters['b']), - torch.tensor(test.parameters['c']), - torch.tensor(test.parameters['d'])).detach().numpy().tolist()[0],places=5) - self.assertAlmostEqual(results['d_out'][0], dx_parametric_fun(torch.tensor(1), torch.tensor(test.parameters['a']), - torch.tensor(test.parameters['b']), - torch.tensor(test.parameters['c']), - torch.tensor(test.parameters['d'])).detach().numpy().tolist()[0],places=5) - self.assertAlmostEqual(results['out'][1], parametric_fun(torch.tensor(2), torch.tensor(test.parameters['a']), - torch.tensor(test.parameters['b']), - torch.tensor(test.parameters['c']), - torch.tensor(test.parameters['d'])).detach().numpy().tolist()[0],places=5) - self.assertAlmostEqual(results['d_out'][1], dx_parametric_fun(torch.tensor(2), torch.tensor(test.parameters['a']), - torch.tensor(test.parameters['b']), - torch.tensor(test.parameters['c']), - torch.tensor(test.parameters['d'])).detach().numpy().tolist()[0],places=5) - + results = test({"x": [1, 2]}) + self.assertAlmostEqual( + results["out"][0], + parametric_fun( + torch.tensor(1), + torch.tensor(test.parameters["a"]), + torch.tensor(test.parameters["b"]), + torch.tensor(test.parameters["c"]), + torch.tensor(test.parameters["d"]), + ) + .detach() + .numpy() + .tolist()[0], + places=5, + ) + self.assertAlmostEqual( + results["d_out"][0], + dx_parametric_fun( + torch.tensor(1), + torch.tensor(test.parameters["a"]), + torch.tensor(test.parameters["b"]), + torch.tensor(test.parameters["c"]), + torch.tensor(test.parameters["d"]), + ) + .detach() + .numpy() + .tolist()[0], + places=5, + ) + self.assertAlmostEqual( + results["out"][1], + parametric_fun( + torch.tensor(2), + torch.tensor(test.parameters["a"]), + torch.tensor(test.parameters["b"]), + torch.tensor(test.parameters["c"]), + torch.tensor(test.parameters["d"]), + ) + .detach() + .numpy() + .tolist()[0], + places=5, + ) + self.assertAlmostEqual( + results["d_out"][1], + dx_parametric_fun( + torch.tensor(2), + torch.tensor(test.parameters["a"]), + torch.tensor(test.parameters["b"]), + torch.tensor(test.parameters["c"]), + torch.tensor(test.parameters["d"]), + ) + .detach() + .numpy() + .tolist()[0], + places=5, + ) diff --git a/tests/test_model_predict_recurrent.py b/tests/test_model_predict_recurrent.py index 5bbb37a8..fdb17d4e 100644 --- a/tests/test_model_predict_recurrent.py +++ b/tests/test_model_predict_recurrent.py @@ -1,4 +1,7 @@ -import unittest, sys, os, torch +import unittest +import sys +import os +import torch import numpy as np from nnodely import * @@ -19,17 +22,22 @@ # The second dimension indicates the output time dimension for each sample. # The third is the size of the signal + def myfun(x, P): - out = x*P - return out[:,1:,:] + out = x * P + return out[:, 1:, :] + def myfunsum(x, P): out = x + P return out -def matmul(x,y): + +def matmul(x, y): import torch - return torch.matmul(torch.transpose(x,1,2),y) + + return torch.matmul(torch.transpose(x, 1, 2), y) + # def myfun2(a, b ,c): # import torch @@ -41,10 +49,15 @@ def matmul(x,y): # bt = torch.transpose(b, 1, 2) # return torch.matmul(p1,at+bt)+p2.t() + class ModelyRecurrentPredictTest(unittest.TestCase): - def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): @@ -54,482 +67,666 @@ def TestAlmostEqual(self, data1, data2, precision=4): def test_predict_and_states_values_fir_simple_closed_loop(self): NeuObj.clearNames() - x = Input('x') - x_state = Input('x_state') - p = Parameter('p', dimensions=1, sw=1, values=[[1.0]]) + x = Input("x") + x_state = Input("x_state") + p = Parameter("p", dimensions=1, sw=1, values=[[1.0]]) rel_x = Fir(W=p)(x_state.last()) rel_x = ClosedLoop(rel_x, x_state) - out = Output('out', rel_x) + out = Output("out", rel_x) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) - test.addMinimize('pos_x', x.next(), out) + test.addModel("out", out) + test.addMinimize("pos_x", x.next(), out) test.neuralizeModel(0.01) - result = test(inputs={'x': [2], 'x_state':[1]}) - self.assertEqual(test.states['x_state'], torch.tensor([[result['out']]]).tolist()) - self.assertEqual({'out': [1]}, result) - result = test(inputs={'x': [2]}) - self.assertEqual(test.states['x_state'], torch.tensor([[[1.0]]]).tolist()) - self.assertEqual({'out': [1.0]}, result) + result = test(inputs={"x": [2], "x_state": [1]}) + self.assertEqual( + test.states["x_state"], torch.tensor([[result["out"]]]).tolist() + ) + self.assertEqual({"out": [1]}, result) + result = test(inputs={"x": [2]}) + self.assertEqual(test.states["x_state"], torch.tensor([[[1.0]]]).tolist()) + self.assertEqual({"out": [1.0]}, result) test.resetStates() - result = test(inputs={'x': [2]}) - self.assertEqual(test.states['x_state'], torch.tensor([[[0.0]]]).tolist()) - self.assertEqual({'out': [0.0]}, result) + result = test(inputs={"x": [2]}) + self.assertEqual(test.states["x_state"], torch.tensor([[[0.0]]]).tolist()) + self.assertEqual({"out": [0.0]}, result) - test.removeConnection('x_state') + test.removeConnection("x_state") test.neuralizeModel(0.01) - result = test(inputs={'x': [2], 'x_state':[1]}) - self.assertEqual({'out': [1]}, result) - result = test(inputs={'x': [2]}) - self.assertEqual({'out': [0.0]}, result) - result = test(inputs={'x_state': [2.0]}) - self.assertEqual({'out': [2.0]}, result) - + result = test(inputs={"x": [2], "x_state": [1]}) + self.assertEqual({"out": [1]}, result) + result = test(inputs={"x": [2]}) + self.assertEqual({"out": [0.0]}, result) + result = test(inputs={"x_state": [2.0]}) + self.assertEqual({"out": [2.0]}, result) def test_predict_values_fir_simple_closed_loop_predict(self): NeuObj.clearNames() - x = Input('x') - x_in = Input('x_in') - p = Parameter('p', dimensions=1, sw=1, values=[[1.0]]) + x = Input("x") + x_in = Input("x_in") + p = Parameter("p", dimensions=1, sw=1, values=[[1.0]]) rel_x = Fir(W=p)(x_in.last()) - #rel_x = ClosedLoop(rel_x, x_state) - out = Output('out', rel_x) + # rel_x = ClosedLoop(rel_x, x_state) + out = Output("out", rel_x) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) - test.addMinimize('pos_x', x.next(), out) + test.addModel("out", out) + test.addMinimize("pos_x", x.next(), out) test.neuralizeModel(0.01) - result = test(inputs={'x': [2], 'x_in':[1]},closed_loop={'x_in':'out'}) - self.assertEqual({'out':[1]}, result) - result = test(inputs={'x': [2]}, closed_loop={'x_in':'out'}) - self.assertEqual({'out': [0.0]}, result) + result = test(inputs={"x": [2], "x_in": [1]}, closed_loop={"x_in": "out"}) + self.assertEqual({"out": [1]}, result) + result = test(inputs={"x": [2]}, closed_loop={"x_in": "out"}) + self.assertEqual({"out": [0.0]}, result) def test_predict_values_fir_closed_loop(self): NeuObj.clearNames() ## the memory is not shared between different calls - x = Input('x') - F = Input('F') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - x_out = Fir(W=p)(x.tw(0.5))+F.last() + x = Input("x") + F = Input("F") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + x_out = Fir(W=p)(x.tw(0.5)) + F.last() x_out.closedLoop(F) - out = Output('out',x_out) + out = Output("out", x_out) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) ## one sample prediction with F initialized with zeros test.resetStates() - result = test(inputs={'x':[1,2,3,4,5]}) - self.assertEqual(result['out'], [15.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [15.0]) ## 5 samples prediction with F initialized with zero only the first time test.resetStates() - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9]}) - self.assertEqual(result['out'], [15.0, 35.0, 60.0, 90.0, 125.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(result["out"], [15.0, 35.0, 60.0, 90.0, 125.0]) ## one sample prediction with F initialized with [1] test.resetStates() - result = test(inputs={'x':[1,2,3,4,5], 'F':[1]}) - self.assertEqual(result['out'], [16.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "F": [1]}) + self.assertEqual(result["out"], [16.0]) ## 5 samples prediction with F initialized with [1] only the first time test.resetStates() - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1]}) - self.assertEqual(result['out'], [16.0, 36.0, 61.0, 91.0, 126.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9], "F": [1]}) + self.assertEqual(result["out"], [16.0, 36.0, 61.0, 91.0, 126.0]) ## 5 samples prediction with F initialized with [1] the first time, [2] the second time and [3] the third time test.resetStates() - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1,2,3]}) - self.assertEqual(result['out'], [16.0, 22.0, 28.0, 58.0, 93.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9], "F": [1, 2, 3]}) + self.assertEqual(result["out"], [16.0, 22.0, 28.0, 58.0, 93.0]) ## one sample prediction with F initialized with [1] (the other values are ignored) test.resetStates() - result = test(inputs={'x':[1,2,3,4,5], 'F':[1,2,3]}) - self.assertEqual(result['out'], [16.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "F": [1, 2, 3]}) + self.assertEqual(result["out"], [16.0]) def test_predict_values_fir_closed_loop_predict(self): NeuObj.clearNames() ## the memory is not shared between different calls - x = Input('x') - F = Input('F') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - x_out = Fir(W=p)(x.tw(0.5))+F.last() - out = Output('out',x_out) + x = Input("x") + F = Input("F") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + x_out = Fir(W=p)(x.tw(0.5)) + F.last() + out = Output("out", x_out) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) ## one sample prediction with F initialized with zeros - result = test(inputs={'x':[1,2,3,4,5]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [15.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}, closed_loop={"F": "out"}) + self.assertEqual(result["out"], [15.0]) ## 5 samples prediction with F initialized with zero only the first time - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [15.0, 35.0, 60.0, 90.0, 125.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, closed_loop={"F": "out"} + ) + self.assertEqual(result["out"], [15.0, 35.0, 60.0, 90.0, 125.0]) ## one sample prediction with F initialized with [1] - result = test(inputs={'x':[1,2,3,4,5], 'F':[1]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [16.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "F": [1]}, closed_loop={"F": "out"}) + self.assertEqual(result["out"], [16.0]) ## 5 samples prediction with F initialized with [1] only the first time - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [16.0, 36.0, 61.0, 91.0, 126.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9], "F": [1]}, + closed_loop={"F": "out"}, + ) + self.assertEqual(result["out"], [16.0, 36.0, 61.0, 91.0, 126.0]) ## 5 samples prediction with F initialized with [1] the first time, [2] the second time and [3] the third time - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1,2,3]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [16.0, 22.0, 28.0, 58.0, 93.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9], "F": [1, 2, 3]}, + closed_loop={"F": "out"}, + ) + self.assertEqual(result["out"], [16.0, 22.0, 28.0, 58.0, 93.0]) ## one sample prediction with F initialized with [1] (the other values are ignored) - result = test(inputs={'x':[1,2,3,4,5], 'F':[1,2,3]}, closed_loop={'F':'out'}) - self.assertEqual(result['out'], [16.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "F": [1, 2, 3]}, closed_loop={"F": "out"} + ) + self.assertEqual(result["out"], [16.0]) def test_predict_values_2fir_closed_loop(self): NeuObj.clearNames() ## the memory is not shared between different calls - x = Input('x') - y = Input('y') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - n = Parameter('n', tw=0.5, dimensions=1, values=[[-1.0],[-1.0],[-1.0],[-1.0],[-1.0]]) + x = Input("x") + y = Input("y") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + n = Parameter( + "n", tw=0.5, dimensions=1, values=[[-1.0], [-1.0], [-1.0], [-1.0], [-1.0]] + ) fir_pos = Fir(W=p)(x.tw(0.5)) fir_neg = Fir(W=n)(y.tw(0.5)) fir_pos.closedLoop(x) fir_neg.closedLoop(y) - out_pos = Output('out_pos', fir_pos) - out_neg = Output('out_neg', fir_neg) - out = Output('out',fir_neg+fir_pos) + out_pos = Output("out_pos", fir_pos) + out_neg = Output("out_neg", fir_neg) + out = Output("out", fir_neg + fir_pos) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) - test.addModel('out_pos',out_pos) - test.addModel('out_neg',out_neg) + test.addModel("out", out) + test.addModel("out_pos", out_pos) + test.addModel("out_neg", out_neg) test.neuralizeModel(0.1) ## one sample prediction with both close loops - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5]}) - self.assertEqual(result['out'], [0.0]) - self.assertEqual(result['out_pos'], [15.0]) - self.assertEqual(result['out_neg'], [-15.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [0.0]) + self.assertEqual(result["out_pos"], [15.0]) + self.assertEqual(result["out_neg"], [-15.0]) ## three sample prediction due to the max dimensions of inputs + prediction_samples - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5]}, prediction_samples=2, num_of_samples=3) - self.assertEqual(result['out'], [0.0, 30.0, 58.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0, 56.0]) - self.assertEqual(result['out_neg'], [-15.0, 1.0, 2.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5]}, + prediction_samples=2, + num_of_samples=3, + ) + self.assertEqual(result["out"], [0.0, 30.0, 58.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0, 56.0]) + self.assertEqual(result["out_neg"], [-15.0, 1.0, 2.0]) ## three sample prediction with both close loops but y gets initialized for 3 steps ## (!! since all the inputs are recurrent we must specify the prediction horizon (defualt=1)) - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5,6,7]}, prediction_samples=2, num_of_samples=3) - self.assertEqual(result['out'], [0.0, 30.0, 58.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0, 56.0]) - self.assertEqual(result['out_neg'], [-15.0, 1.0, 2.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5, 6, 7]}, + prediction_samples=2, + num_of_samples=3, + ) + self.assertEqual(result["out"], [0.0, 30.0, 58.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0, 56.0]) + self.assertEqual(result["out_neg"], [-15.0, 1.0, 2.0]) test.resetStates() - result = test(inputs={'x': [1, 2, 3, 4, 5], 'y': [1, 2, 3, 4, 5, 6, 7]}, num_of_samples=3) - self.assertEqual(result['out'], [0.0, 9.0, 31.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0, 56.0]) - self.assertEqual(result['out_neg'], [-15.0, -20.0, -25.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5, 6, 7]}, num_of_samples=3 + ) + self.assertEqual(result["out"], [0.0, 9.0, 31.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0, 56.0]) + self.assertEqual(result["out_neg"], [-15.0, -20.0, -25.0]) def test_predict_values_2fir_closed_loop_predict(self): NeuObj.clearNames() ## the memory is not shared between different calls - x = Input('x') - y = Input('y') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - n = Parameter('n', tw=0.5, dimensions=1, values=[[-1.0],[-1.0],[-1.0],[-1.0],[-1.0]]) + x = Input("x") + y = Input("y") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + n = Parameter( + "n", tw=0.5, dimensions=1, values=[[-1.0], [-1.0], [-1.0], [-1.0], [-1.0]] + ) fir_pos = Fir(W=p)(x.tw(0.5)) fir_neg = Fir(W=n)(y.tw(0.5)) - out_pos = Output('out_pos', fir_pos) - out_neg = Output('out_neg', fir_neg) - out = Output('out',fir_neg+fir_pos) + out_pos = Output("out_pos", fir_pos) + out_neg = Output("out_neg", fir_neg) + out = Output("out", fir_neg + fir_pos) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) - test.addModel('out_pos',out_pos) - test.addModel('out_neg',out_neg) + test.addModel("out", out) + test.addModel("out_pos", out_pos) + test.addModel("out_neg", out_neg) test.neuralizeModel(0.1) ## two sample one prediction for x in close loop - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5,6]}, closed_loop={'x':'out_pos'}) - self.assertEqual(result['out'], [0.0, 9.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0]) - self.assertEqual(result['out_neg'], [-15.0, -20.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5, 6]}, + closed_loop={"x": "out_pos"}, + ) + self.assertEqual(result["out"], [0.0, 9.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0]) + self.assertEqual(result["out_neg"], [-15.0, -20.0]) ## two sample one prediction for y in close loop - result = test(inputs={'x':[1,2,3,4,5,6], 'y':[1,2,3,4,5]}, closed_loop={'y':'out_pos'}) - self.assertEqual(result['out'], [0.0, -9.0]) - self.assertEqual(result['out_pos'], [15.0, 20.0]) - self.assertEqual(result['out_neg'], [-15.0, -29.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5, 6], "y": [1, 2, 3, 4, 5]}, + closed_loop={"y": "out_pos"}, + ) + self.assertEqual(result["out"], [0.0, -9.0]) + self.assertEqual(result["out_pos"], [15.0, 20.0]) + self.assertEqual(result["out_neg"], [-15.0, -29.0]) ## one sample prediction with both close loops - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5]}, closed_loop={'x':'out_pos', 'y':'out_neg'}) - self.assertEqual(result['out'], [0.0]) - self.assertEqual(result['out_pos'], [15.0]) - self.assertEqual(result['out_neg'], [-15.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5]}, + closed_loop={"x": "out_pos", "y": "out_neg"}, + ) + self.assertEqual(result["out"], [0.0]) + self.assertEqual(result["out_pos"], [15.0]) + self.assertEqual(result["out_neg"], [-15.0]) ## three sample prediction due to the max dimensions of inputs + prediction_samples - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5]}, closed_loop={'x':'out_pos', 'y':'out_neg'}, prediction_samples=2, num_of_samples=3) - self.assertEqual(result['out'], [0.0, 30.0, 58.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0, 56.0]) - self.assertEqual(result['out_neg'], [-15.0, 1.0, 2.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5]}, + closed_loop={"x": "out_pos", "y": "out_neg"}, + prediction_samples=2, + num_of_samples=3, + ) + self.assertEqual(result["out"], [0.0, 30.0, 58.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0, 56.0]) + self.assertEqual(result["out_neg"], [-15.0, 1.0, 2.0]) ## three sample prediction with both close loops but y gets initialized for 3 steps ## (!! since all the inputs are recurrent we must specify the prediction horizon (defualt=1)) - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5,6,7]}, closed_loop={'x':'out_pos', 'y':'out_neg'}, prediction_samples=2, num_of_samples=3) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5, 6, 7]}, + closed_loop={"x": "out_pos", "y": "out_neg"}, + prediction_samples=2, + num_of_samples=3, + ) ## 1+2+3+4+5 -1-2-3-4-5 2+3+4+5+15 -2-3-4-5+15 - #self.assertEqual(result['out'], [0.0, 9.0, 31.0]) - self.assertEqual(result['out_pos'], [15.0, 29.0, 56.0]) - self.assertEqual(result['out_neg'], [-15.0, 1.0, 2.0]) + # self.assertEqual(result['out'], [0.0, 9.0, 31.0]) + self.assertEqual(result["out_pos"], [15.0, 29.0, 56.0]) + self.assertEqual(result["out_neg"], [-15.0, 1.0, 2.0]) def test_predict_values_3states_closed_loop(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - F_state = Input('F') - y_state = Input('y') - z_state = Input('z') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - x_out = Fir(W=p)(x.tw(0.5))+F_state.last()+y_state.last()+z_state.last() + x = Input("x") + F_state = Input("F") + y_state = Input("y") + z_state = Input("z") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + x_out = Fir(W=p)(x.tw(0.5)) + F_state.last() + y_state.last() + z_state.last() x_out = ClosedLoop(x_out, F_state) x_out = ClosedLoop(x_out, y_state) x_out = ClosedLoop(x_out, z_state) - out = Output('out',x_out) + out = Output("out", x_out) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]}) - self.assertEqual(result['out'], [15.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [15.0]) ## 5 sample prediction with state variables not initialized ## (the first prediction will preserve the state of the previous test [15.0]) - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9]}) - self.assertEqual(result['out'], [60.0, 200.0, 625.0, 1905.0, 5750.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual(result["out"], [60.0, 200.0, 625.0, 1905.0, 5750.0]) test.resetStates() - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9]}) - self.assertEqual(result['out'], [15.0, 65.0, 220.0, 220*3+30, (220*3+30)*3+35]) + result = test(inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9]}) + self.assertEqual( + result["out"], [15.0, 65.0, 220.0, 220 * 3 + 30, (220 * 3 + 30) * 3 + 35] + ) ## one sample prediction with state variables initialized with zero test.resetStates() - result = test(inputs={'x':[1,2,3,4,5]}) - self.assertEqual(result['out'], [15.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [15.0]) ## one sample prediction with F initialized with [1] and the others not initialized (so they will have 15.0 in the memory) - result = test(inputs={'x':[1,2,3,4,5], 'F':[1]}) - self.assertEqual(result['out'], [46.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "F": [1]}) + self.assertEqual(result["out"], [46.0]) ## one sample prediction with all the state variables initialized - result = test(inputs={'x':[1,2,3,4,5], 'F':[1], 'y':[2], 'z':[3]}) - self.assertEqual(result['out'], [21.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5], "F": [1], "y": [2], "z": [3]}) + self.assertEqual(result["out"], [21.0]) ## 5 samples prediction with state variables initialized as many times as they have values to take - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1,2,3], 'y':[2,3], 'z':[3]}) - self.assertEqual(result['out'], [21.0, 46.0, 120.0, 390.0, 1205.0]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "F": [1, 2, 3], + "y": [2, 3], + "z": [3], + } + ) + self.assertEqual(result["out"], [21.0, 46.0, 120.0, 390.0, 1205.0]) # 2 samples prediction with state variables inizialized only at %prediction_samples - result = test(inputs={'F': [1,2,3,4], 'y': [1,2], 'z': [1,2,3,4,5]}, prediction_samples=2, num_of_samples=4) + result = test( + inputs={"F": [1, 2, 3, 4], "y": [1, 2], "z": [1, 2, 3, 4, 5]}, + prediction_samples=2, + num_of_samples=4, + ) # 1+1+1 = 3, 3+3+3 = 9, 9+9+9 = 27, 4+0+4 = 8, 8+8+8 = 24 - self.assertEqual(result['out'], [3.0, 9.0, 27.0, 8.0]) - #self.assertEqual(result['out'], [3.0,9.0,27.0,8.0]) - #self.assertEqual(result['out'], [3.0, 6.0, 12.0, 20.0]) + self.assertEqual(result["out"], [3.0, 9.0, 27.0, 8.0]) + # self.assertEqual(result['out'], [3.0,9.0,27.0,8.0]) + # self.assertEqual(result['out'], [3.0, 6.0, 12.0, 20.0]) def test_predict_values_3states_closed_loop_predict(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - F_state = Input('F') - y_state = Input('y') - z_state = Input('z') - p = Parameter('p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - x_out = Fir(W=p)(x.tw(0.5))+F_state.last()+y_state.last()+z_state.last() - out = Output('out',x_out) + x = Input("x") + F_state = Input("F") + y_state = Input("y") + z_state = Input("z") + p = Parameter( + "p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + x_out = Fir(W=p)(x.tw(0.5)) + F_state.last() + y_state.last() + z_state.last() + out = Output("out", x_out) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) + test.addModel("out", out) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]},closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [15.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual(result["out"], [15.0]) ## 5 sample prediction with state variables not initialized ## (the first prediction will preserve the state of the previous test [15.0]) - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9]}, closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [15.0, 65.0, 220.0, 220*3+30, (220*3+30)*3+35]) + result = test( + inputs={"x": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual( + result["out"], [15.0, 65.0, 220.0, 220 * 3 + 30, (220 * 3 + 30) * 3 + 35] + ) ## one sample prediction with state variables initialized with zero test.resetStates() - result = test(inputs={'x':[1,2,3,4,5]}, closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [15.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual(result["out"], [15.0]) ## one sample prediction with F initialized with [1] and the others not initialized (so they will have 15.0 in the memory) - result = test(inputs={'x':[1,2,3,4,5], 'F':[1]}, closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [16.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "F": [1]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual(result["out"], [16.0]) ## one sample prediction with all the state variables initialized - result = test(inputs={'x':[1,2,3,4,5], 'F':[1], 'y':[2], 'z':[3]}, closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [21.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "F": [1], "y": [2], "z": [3]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual(result["out"], [21.0]) ## 5 samples prediction with state variables initialized as many times as they have values to take - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'F':[1,2,3], 'y':[2,3], 'z':[3]}, closed_loop={'F':'out','y':'out','z':'out'}) - self.assertEqual(result['out'], [21.0, 46.0, 120.0, 390.0, 1205.0]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "F": [1, 2, 3], + "y": [2, 3], + "z": [3], + }, + closed_loop={"F": "out", "y": "out", "z": "out"}, + ) + self.assertEqual(result["out"], [21.0, 46.0, 120.0, 390.0, 1205.0]) # 2 samples prediction with state variables inizialized only at %prediction_samples # 1+1+1 = 3, 3+3+3 = 9, 9+9+9 = 27, 4+0+4 = 8, 8+8+8 = 24 - result = test(inputs={'F': [1,2,3,4], 'y': [1,2], 'z': [1,2,3,4,5]}, closed_loop={'F':'out','y':'out','z':'out'}, prediction_samples=2, num_of_samples=4) - self.assertEqual(result['out'], [3.0,9.0,27.0,8.0]) + result = test( + inputs={"F": [1, 2, 3, 4], "y": [1, 2], "z": [1, 2, 3, 4, 5]}, + closed_loop={"F": "out", "y": "out", "z": "out"}, + prediction_samples=2, + num_of_samples=4, + ) + self.assertEqual(result["out"], [3.0, 9.0, 27.0, 8.0]) def test_predict_values_and_states_3states_more_window_closed_loop(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - y_state = Input('y') - z_state = Input('z') - x_p = Parameter('x_p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - y_p = Parameter('y_p', tw=0.5, dimensions=1, values=[[2.0],[2.0],[2.0],[2.0],[2.0]]) - z_p = Parameter('z_p', tw=0.5, dimensions=1, values=[[3.0],[3.0],[3.0],[3.0],[3.0]]) + x = Input("x") + y_state = Input("y") + z_state = Input("z") + x_p = Parameter( + "x_p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + y_p = Parameter( + "y_p", tw=0.5, dimensions=1, values=[[2.0], [2.0], [2.0], [2.0], [2.0]] + ) + z_p = Parameter( + "z_p", tw=0.5, dimensions=1, values=[[3.0], [3.0], [3.0], [3.0], [3.0]] + ) x_fir = Fir(W=x_p)(x.tw(0.5)) y_fir = Fir(W=y_p)(y_state.tw(0.5)) z_fir = Fir(W=z_p)(z_state.tw(0.5)) y_fir = ClosedLoop(y_fir, y_state) z_fir = ClosedLoop(z_fir, z_state) - out_x = Output('out_x', x_fir) - out_y = Output('out_y', y_fir) - out_z = Output('out_z', z_fir) - out = Output('out',x_fir+y_fir+z_fir) + out_x = Output("out_x", x_fir) + out_y = Output("out_y", y_fir) + out_z = Output("out_z", z_fir) + out = Output("out", x_fir + y_fir + z_fir) test = Modely(visualizer=None, seed=42) - test.addModel('out_all',[out, out_x, out_y, out_z]) + test.addModel("out_all", [out, out_x, out_y, out_z]) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]}) - self.assertEqual(result['out'], [15.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [0.0]) - self.assertEqual(result['out_z'], [0.0]) - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) - self.assertEqual(test.states['z'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [15.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [0.0]) + self.assertEqual(result["out_z"], [0.0]) + self.assertEqual(test.states["y"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["z"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) ## 1 sample prediction with state variables all initialized - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5], 'z':[1,2,3,4,5]}) - self.assertEqual(result['out'], [90.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [30.0]) - self.assertEqual(result['out_z'], [45.0]) - self.assertEqual(test.states['y'], [[[2.0], [3.0], [4.0], [5.0], [30.0]]]) - self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [5.0], [45.0]]]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5], "z": [1, 2, 3, 4, 5]} + ) + self.assertEqual(result["out"], [90.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [30.0]) + self.assertEqual(result["out_z"], [45.0]) + self.assertEqual(test.states["y"], [[[2.0], [3.0], [4.0], [5.0], [30.0]]]) + self.assertEqual(test.states["z"], [[[2.0], [3.0], [4.0], [5.0], [45.0]]]) ## clear state of y - test.resetStates({'y'}) - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) - self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [5.0], [45.0]]]) + test.resetStates({"y"}) + self.assertEqual(test.states["y"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["z"], [[[2.0], [3.0], [4.0], [5.0], [45.0]]]) ## multi-sample prediction with states initialized as many times as they have values - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'y':[1,2,3,4,5,6,7], 'z':[1,2,3,4,5,6]}) - self.assertEqual(result['out'], [90.0, 120.0, 309.0, 1101.0, 4155.0]) - self.assertEqual(result['out_x'], [15.0, 20.0, 25.0, 30.0, 35.0]) - self.assertEqual(result['out_y'], [30.0, 40.0, 50.0, 144.0, 424.0]) - self.assertEqual(result['out_z'], [45.0, 60.0, 234.0, 927.0, 3696.0]) - self.assertEqual(test.states['y'], [[[6.0], [7.0], [50.0], [144.0], [424.0]]]) - self.assertEqual(test.states['z'], [[[6.0], [60.0], [234.0], [927.0], [3696.0]]]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "y": [1, 2, 3, 4, 5, 6, 7], + "z": [1, 2, 3, 4, 5, 6], + } + ) + self.assertEqual(result["out"], [90.0, 120.0, 309.0, 1101.0, 4155.0]) + self.assertEqual(result["out_x"], [15.0, 20.0, 25.0, 30.0, 35.0]) + self.assertEqual(result["out_y"], [30.0, 40.0, 50.0, 144.0, 424.0]) + self.assertEqual(result["out_z"], [45.0, 60.0, 234.0, 927.0, 3696.0]) + self.assertEqual(test.states["y"], [[[6.0], [7.0], [50.0], [144.0], [424.0]]]) + self.assertEqual( + test.states["z"], [[[6.0], [60.0], [234.0], [927.0], [3696.0]]] + ) ## Clear all states test.resetStates() - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) - self.assertEqual(test.states['z'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["y"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["z"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) def test_predict_values_and_states_3states_more_window_closed_loop_predict(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - y_state = Input('y') - z_state = Input('z') - x_p = Parameter('x_p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - y_p = Parameter('y_p', tw=0.5, dimensions=1, values=[[2.0],[2.0],[2.0],[2.0],[2.0]]) - z_p = Parameter('z_p', tw=0.5, dimensions=1, values=[[3.0],[3.0],[3.0],[3.0],[3.0]]) + x = Input("x") + y_state = Input("y") + z_state = Input("z") + x_p = Parameter( + "x_p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + y_p = Parameter( + "y_p", tw=0.5, dimensions=1, values=[[2.0], [2.0], [2.0], [2.0], [2.0]] + ) + z_p = Parameter( + "z_p", tw=0.5, dimensions=1, values=[[3.0], [3.0], [3.0], [3.0], [3.0]] + ) x_fir = Fir(W=x_p)(x.tw(0.5)) y_fir = Fir(W=y_p)(y_state.tw(0.5)) z_fir = Fir(W=z_p)(z_state.tw(0.5)) - out_x = Output('out_x', x_fir) - out_y = Output('out_y', y_fir) - out_z = Output('out_z', z_fir) - out = Output('out',x_fir+y_fir+z_fir) + out_x = Output("out_x", x_fir) + out_y = Output("out_y", y_fir) + out_z = Output("out_z", z_fir) + out = Output("out", x_fir + y_fir + z_fir) test = Modely(visualizer=None, seed=42) - test.addModel('out_all',[out, out_x, out_y, out_z]) + test.addModel("out_all", [out, out_x, out_y, out_z]) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]}, closed_loop={'y':'out_y', 'z':'out_z'}) - self.assertEqual(result['out'], [15.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [0.0]) - self.assertEqual(result['out_z'], [0.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5]}, closed_loop={"y": "out_y", "z": "out_z"} + ) + self.assertEqual(result["out"], [15.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [0.0]) + self.assertEqual(result["out_z"], [0.0]) ## 1 sample prediction with state variables all initialized - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5], 'z':[1,2,3,4,5]}, closed_loop={'y':'out_y', 'z':'out_z'}) - self.assertEqual(result['out'], [90.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [30.0]) - self.assertEqual(result['out_z'], [45.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5], "z": [1, 2, 3, 4, 5]}, + closed_loop={"y": "out_y", "z": "out_z"}, + ) + self.assertEqual(result["out"], [90.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [30.0]) + self.assertEqual(result["out_z"], [45.0]) ## multi-sample prediction with states initialized as many times as they have values - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'y':[1,2,3,4,5,6,7], 'z':[1,2,3,4,5,6]}, closed_loop={'y':'out_y', 'z':'out_z'}) - self.assertEqual(result['out'], [90.0, 120.0, 309.0, 1101.0, 4155.0]) - self.assertEqual(result['out_x'], [15.0, 20.0, 25.0, 30.0, 35.0]) - self.assertEqual(result['out_y'], [30.0, 40.0, 50.0, 144.0, 424.0]) - self.assertEqual(result['out_z'], [45.0, 60.0, 234.0, 927.0, 3696.0]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "y": [1, 2, 3, 4, 5, 6, 7], + "z": [1, 2, 3, 4, 5, 6], + }, + closed_loop={"y": "out_y", "z": "out_z"}, + ) + self.assertEqual(result["out"], [90.0, 120.0, 309.0, 1101.0, 4155.0]) + self.assertEqual(result["out_x"], [15.0, 20.0, 25.0, 30.0, 35.0]) + self.assertEqual(result["out_y"], [30.0, 40.0, 50.0, 144.0, 424.0]) + self.assertEqual(result["out_z"], [45.0, 60.0, 234.0, 927.0, 3696.0]) def test_predict_values_and_states_2states_more_window_connect(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - y_state = Input('y') - z_state = Input('z') - x_p = Parameter('x_p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - y_p = Parameter('y_p', tw=0.5, dimensions=1, values=[[2.0],[2.0],[2.0],[2.0],[2.0]]) - z_p = Parameter('z_p', tw=0.5, dimensions=1, values=[[3.0],[3.0],[3.0],[3.0],[3.0]]) + x = Input("x") + y_state = Input("y") + z_state = Input("z") + x_p = Parameter( + "x_p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + y_p = Parameter( + "y_p", tw=0.5, dimensions=1, values=[[2.0], [2.0], [2.0], [2.0], [2.0]] + ) + z_p = Parameter( + "z_p", tw=0.5, dimensions=1, values=[[3.0], [3.0], [3.0], [3.0], [3.0]] + ) x_fir = Fir(W=x_p)(x.tw(0.5)) y_fir = Fir(W=y_p)(y_state.tw(0.5)) z_fir = Fir(W=z_p)(z_state.tw(0.5)) x_fir = Connect(x_fir, y_state) x_fir = Connect(x_fir, z_state) - out_x = Output('out_x', x_fir) - out_y = Output('out_y', y_fir) - out_z = Output('out_z', z_fir) - out = Output('out',x_fir+y_fir+z_fir) + out_x = Output("out_x", x_fir) + out_y = Output("out_y", y_fir) + out_z = Output("out_z", z_fir) + out = Output("out", x_fir + y_fir + z_fir) test = Modely(visualizer=None, seed=42) - test.addModel('out_all',[out, out_x, out_y, out_z]) + test.addModel("out_all", [out, out_x, out_y, out_z]) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]}) - self.assertEqual(result['out'], [90.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [30.0]) - self.assertEqual(result['out_z'], [45.0]) + result = test(inputs={"x": [1, 2, 3, 4, 5]}) + self.assertEqual(result["out"], [90.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [30.0]) + self.assertEqual(result["out_z"], [45.0]) # self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [15.0]]]) # self.assertEqual(test.states['z'], [[[0.0], [0.0], [0.0], [0.0], [15.0]]]) - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [15.0], [float('inf')]]]) - self.assertEqual(test.states['z'], [[[0.0], [0.0], [0.0], [15.0], [float('inf')]]]) + self.assertEqual( + test.states["y"], [[[0.0], [0.0], [0.0], [15.0], [float("inf")]]] + ) + self.assertEqual( + test.states["z"], [[[0.0], [0.0], [0.0], [15.0], [float("inf")]]] + ) # Replace insead of rolling # self.assertEqual(test.model.states['y'].numpy().tolist(), [[[0.0], [0.0], [0.0], [15.0], [0.0]]]) # self.assertEqual(test.model.states['z'].numpy().tolist(), [[[0.0], [0.0], [0.0], [15.0], [0.0]]]) ## 1 sample prediction with state variables all initialized - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5], 'z':[1,2,3,4,5]}) - self.assertEqual(result['out_x'], [15.0]) - #(1+2+3+4+5)+(2+3+4+5+(1+2+3+4+5))*2+(2+3+4+5+(1+2+3+4+5))*3 + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5], "z": [1, 2, 3, 4, 5]} + ) + self.assertEqual(result["out_x"], [15.0]) + # (1+2+3+4+5)+(2+3+4+5+(1+2+3+4+5))*2+(2+3+4+5+(1+2+3+4+5))*3 # self.assertEqual(result['out'], [160.0]) # self.assertEqual(result['out_y'], [58.0]) # self.assertEqual(result['out_z'], [87.0]) - self.assertEqual(result['out'], [140.0]) # fir_x = (1+2+3+4+5)*1 fir_y = (1+2+3+4+15)*2 fir_z = (1+2+3+4+15)*3 result total = 140 - self.assertEqual(result['out_y'], [50.0]) - self.assertEqual(result['out_z'], [75.0]) + self.assertEqual( + result["out"], [140.0] + ) # fir_x = (1+2+3+4+5)*1 fir_y = (1+2+3+4+15)*2 fir_z = (1+2+3+4+15)*3 result total = 140 + self.assertEqual(result["out_y"], [50.0]) + self.assertEqual(result["out_z"], [75.0]) # self.assertEqual(test.states['y'], [[[2.0], [3.0], [4.0], [5.0], [15.0]]]) # self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [5.0], [15.0]]]) - self.assertEqual(test.states['y'], [[[2.0], [3.0], [4.0], [15.0], [float('inf')]]]) - self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [15.0], [float('inf')]]]) + self.assertEqual( + test.states["y"], [[[2.0], [3.0], [4.0], [15.0], [float("inf")]]] + ) + self.assertEqual( + test.states["z"], [[[2.0], [3.0], [4.0], [15.0], [float("inf")]]] + ) # Replace instead of rolling - #(1+2+3+4+5)+(1+2+3+4+(1+2+3+4+5))*2+(1+2+3+4+(1+2+3+4+5))*3 + # (1+2+3+4+5)+(1+2+3+4+(1+2+3+4+5))*2+(1+2+3+4+(1+2+3+4+5))*3 # self.assertEqual(result['out'], [140.0]) # self.assertEqual(result['out_y'], [50.0]) # self.assertEqual(result['out_z'], [75.0]) # self.assertEqual(test.model.states['y'].numpy().tolist(), [[[2.0], [3.0], [4.0], [15.0], [1.0]]]) # self.assertEqual(test.model.states['z'].numpy().tolist(), [[[2.0], [3.0], [4.0], [15.0], [1.0]]]) ## clear state of y - test.resetStates({'y'}) - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + test.resetStates({"y"}) + self.assertEqual(test.states["y"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) # self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [5.0], [15.0]]]) - self.assertEqual(test.states['z'], [[[2.0], [3.0], [4.0], [15.0], [float('inf')]]]) + self.assertEqual( + test.states["z"], [[[2.0], [3.0], [4.0], [15.0], [float("inf")]]] + ) # # Replace insead of rolling # ## clear state of y # test.resetStates({'y'}) # self.assertEqual(test.model.states['y'].numpy().tolist(), [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) # self.assertEqual(test.model.states['z'].numpy().tolist(), [[[2.0], [3.0], [4.0], [15.0], [1.0]]]) ## multi-sample prediction with states initialized as many times as they have values - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'y':[1,2,3,4,5,6,7], 'z':[1,2,3,4,5,6]}) - self.assertEqual(result['out_x'], [15.0, 20.0, 25.0, 30.0, 35.0]) - self.assertEqual(result['out_y'], [2*(1+2+3+4+15), 2*(2+3+4+5+20), 2*(3+4+5+6+25), 2*(4+5+6+25+30), 2*(5+6+25+30+35)]) - self.assertEqual(result['out_z'], [3*(1+2+3+4+15), 3*(2+3+4+5+20), 3*(3+4+5+20+25), 3*(4+5+20+25+30), 3*(5+20+25+30+35)]) - self.assertEqual(result['out'], [sum(x) for x in zip(result['out_x'],result['out_y'],result['out_z'])]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "y": [1, 2, 3, 4, 5, 6, 7], + "z": [1, 2, 3, 4, 5, 6], + } + ) + self.assertEqual(result["out_x"], [15.0, 20.0, 25.0, 30.0, 35.0]) + self.assertEqual( + result["out_y"], + [ + 2 * (1 + 2 + 3 + 4 + 15), + 2 * (2 + 3 + 4 + 5 + 20), + 2 * (3 + 4 + 5 + 6 + 25), + 2 * (4 + 5 + 6 + 25 + 30), + 2 * (5 + 6 + 25 + 30 + 35), + ], + ) + self.assertEqual( + result["out_z"], + [ + 3 * (1 + 2 + 3 + 4 + 15), + 3 * (2 + 3 + 4 + 5 + 20), + 3 * (3 + 4 + 5 + 20 + 25), + 3 * (4 + 5 + 20 + 25 + 30), + 3 * (5 + 20 + 25 + 30 + 35), + ], + ) + self.assertEqual( + result["out"], + [sum(x) for x in zip(result["out_x"], result["out_y"], result["out_z"])], + ) # self.assertEqual(test.states['y'], [[[6.0], [7.0], [25.0], [30.0], [35.0]]]) # self.assertEqual(test.states['z'], [[[6.0], [20.0], [25.0], [30.0], [35.0]]]) - self.assertEqual(test.states['y'], [[[6.0], [25.0], [30.0], [35.0], [float('inf')]]]) - self.assertEqual(test.states['z'], [[[20.0], [25.0], [30.0], [35.0], [float('inf')]]]) + self.assertEqual( + test.states["y"], [[[6.0], [25.0], [30.0], [35.0], [float("inf")]]] + ) + self.assertEqual( + test.states["z"], [[[20.0], [25.0], [30.0], [35.0], [float("inf")]]] + ) # Replace instead of rolling # self.assertEqual(result['out_y'], [2*(1+2+3+4+15), 2*(2+3+4+5+20), 2*(3+4+5+6+25), 2*(4+5+6+25+30), 2*(5+6+25+30+35)]) # self.assertEqual(result['out_z'], [3*(1+2+3+4+15), 3*(2+3+4+5+20), 3*(3+4+5+20+25), 3*(4+5+20+25+30), 3*(5+20+25+30+35)]) @@ -538,354 +735,547 @@ def test_predict_values_and_states_2states_more_window_connect(self): # self.assertEqual(test.model.states['z'].numpy().tolist(), [[[20.0], [25.0], [30.0], [35.0], [5.0]]]) ## Clear all states test.resetStates() - self.assertEqual(test.states['y'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) - self.assertEqual(test.states['z'], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["y"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) + self.assertEqual(test.states["z"], [[[0.0], [0.0], [0.0], [0.0], [0.0]]]) def test_predict_values_and_states_2states_more_window_connect_predict(self): NeuObj.clearNames() ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - y_state = Input('y') - z_state = Input('z') - x_p = Parameter('x_p', tw=0.5, dimensions=1, values=[[1.0],[1.0],[1.0],[1.0],[1.0]]) - y_p = Parameter('y_p', tw=0.5, dimensions=1, values=[[2.0],[2.0],[2.0],[2.0],[2.0]]) - z_p = Parameter('z_p', tw=0.5, dimensions=1, values=[[3.0],[3.0],[3.0],[3.0],[3.0]]) + x = Input("x") + y_state = Input("y") + z_state = Input("z") + x_p = Parameter( + "x_p", tw=0.5, dimensions=1, values=[[1.0], [1.0], [1.0], [1.0], [1.0]] + ) + y_p = Parameter( + "y_p", tw=0.5, dimensions=1, values=[[2.0], [2.0], [2.0], [2.0], [2.0]] + ) + z_p = Parameter( + "z_p", tw=0.5, dimensions=1, values=[[3.0], [3.0], [3.0], [3.0], [3.0]] + ) x_fir = Fir(W=x_p)(x.tw(0.5)) y_fir = Fir(W=y_p)(y_state.tw(0.5)) z_fir = Fir(W=z_p)(z_state.tw(0.5)) - out_x = Output('out_x', x_fir) - out_y = Output('out_y', y_fir) - out_z = Output('out_z', z_fir) - out = Output('out',x_fir+y_fir+z_fir) + out_x = Output("out_x", x_fir) + out_y = Output("out_y", y_fir) + out_z = Output("out_z", z_fir) + out = Output("out", x_fir + y_fir + z_fir) test = Modely(visualizer=None, seed=42) - test.addModel('out_all',[out, out_x, out_y, out_z]) + test.addModel("out_all", [out, out_x, out_y, out_z]) test.neuralizeModel(0.1) ## one sample prediction with state variables not initialized ## (they will have the last valid state) - result = test(inputs={'x':[1,2,3,4,5]}, connect={'y':'out_x','z':'out_x'}) - self.assertEqual(result['out'], [90.0]) - self.assertEqual(result['out_x'], [15.0]) - self.assertEqual(result['out_y'], [30.0]) - self.assertEqual(result['out_z'], [45.0]) + result = test( + inputs={"x": [1, 2, 3, 4, 5]}, connect={"y": "out_x", "z": "out_x"} + ) + self.assertEqual(result["out"], [90.0]) + self.assertEqual(result["out_x"], [15.0]) + self.assertEqual(result["out_y"], [30.0]) + self.assertEqual(result["out_z"], [45.0]) ## 1 sample prediction with state variables all initialized - result = test(inputs={'x':[1,2,3,4,5], 'y':[1,2,3,4,5], 'z':[1,2,3,4,5]}, connect={'y':'out_x','z':'out_x'}) - self.assertEqual(result['out_x'], [15.0]) - #(1+2+3+4+5)+(2+3+4+5+(1+2+3+4+5))*2+(2+3+4+5+(1+2+3+4+5))*3 + result = test( + inputs={"x": [1, 2, 3, 4, 5], "y": [1, 2, 3, 4, 5], "z": [1, 2, 3, 4, 5]}, + connect={"y": "out_x", "z": "out_x"}, + ) + self.assertEqual(result["out_x"], [15.0]) + # (1+2+3+4+5)+(2+3+4+5+(1+2+3+4+5))*2+(2+3+4+5+(1+2+3+4+5))*3 # self.assertEqual(result['out'], [160.0]) # self.assertEqual(result['out_y'], [58.0]) # self.assertEqual(result['out_z'], [87.0]) # Replace instead of rolling - #(1+2+3+4+5)+(1+2+3+4+(1+2+3+4+5))*2+(1+2+3+4+(1+2+3+4+5))*3 - self.assertEqual(result['out'], [140.0]) - self.assertEqual(result['out_y'], [50.0]) - self.assertEqual(result['out_z'], [75.0]) + # (1+2+3+4+5)+(1+2+3+4+(1+2+3+4+5))*2+(1+2+3+4+(1+2+3+4+5))*3 + self.assertEqual(result["out"], [140.0]) + self.assertEqual(result["out_y"], [50.0]) + self.assertEqual(result["out_z"], [75.0]) ## multi-sample prediction with states initialized as many times as they have values - result = test(inputs={'x':[1,2,3,4,5,6,7,8,9], 'y':[1,2,3,4,5,6,7], 'z':[1,2,3,4,5,6]}, connect={'y':'out_x','z':'out_x'}) - self.assertEqual(result['out_x'], [15.0, 20.0, 25.0, 30.0, 35.0]) + result = test( + inputs={ + "x": [1, 2, 3, 4, 5, 6, 7, 8, 9], + "y": [1, 2, 3, 4, 5, 6, 7], + "z": [1, 2, 3, 4, 5, 6], + }, + connect={"y": "out_x", "z": "out_x"}, + ) + self.assertEqual(result["out_x"], [15.0, 20.0, 25.0, 30.0, 35.0]) # self.assertEqual(result['out_y'], [2*(2+3+4+5+15), 2*(3+4+5+6+20), 2*(4+5+6+7+25), 2*(5+6+7+25+30), 2*(6+7+25+30+35)]) # self.assertEqual(result['out_z'], [3*(2+3+4+5+15), 3*(3+4+5+6+20), 3*(4+5+6+20+25), 3*(5+6+20+25+30), 3*(6+20+25+30+35)]) # Reaplce instead of rolling - self.assertEqual(result['out_y'], [2*(1+2+3+4+15), 2*(2+3+4+5+20), 2*(3+4+5+6+25), 2*(4+5+6+25+30), 2*(5+6+25+30+35)]) - self.assertEqual(result['out_z'], [3*(1+2+3+4+15), 3*(2+3+4+5+20), 3*(3+4+5+20+25), 3*(4+5+20+25+30), 3*(5+20+25+30+35)]) - self.assertEqual(result['out'], [sum(x) for x in zip(result['out_x'],result['out_y'],result['out_z'])]) + self.assertEqual( + result["out_y"], + [ + 2 * (1 + 2 + 3 + 4 + 15), + 2 * (2 + 3 + 4 + 5 + 20), + 2 * (3 + 4 + 5 + 6 + 25), + 2 * (4 + 5 + 6 + 25 + 30), + 2 * (5 + 6 + 25 + 30 + 35), + ], + ) + self.assertEqual( + result["out_z"], + [ + 3 * (1 + 2 + 3 + 4 + 15), + 3 * (2 + 3 + 4 + 5 + 20), + 3 * (3 + 4 + 5 + 20 + 25), + 3 * (4 + 5 + 20 + 25 + 30), + 3 * (5 + 20 + 25 + 30 + 35), + ], + ) + self.assertEqual( + result["out"], + [sum(x) for x in zip(result["out_x"], result["out_y"], result["out_z"])], + ) def test_predict_values_and_connect_variables_2models_more_window_connect(self): clearNames() ## Model1 - input1 = Input('in1') - a = Parameter('a', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output1 = Output('out1', Fir(W=a)(input1.tw(0.05))) + input1 = Input("in1") + a = Parameter("a", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output1 = Output("out1", Fir(W=a)(input1.tw(0.05))) test = Modely(visualizer=None, seed=42) - test.addModel('model1', output1) - test.addMinimize('error1', input1.next(), output1) + test.addModel("model1", output1) + test.addMinimize("error1", input1.next(), output1) test.neuralizeModel(0.01) ## Model2 - input2 = Input('in2') - input3 = Input('in3') - b = Parameter('b', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - c = Parameter('c', dimensions=1, tw=0.03, values=[[1],[1],[1]]) - output2 = Output('out2', Fir(W=b)(input2.tw(0.05))+Fir(W=c)(input3.tw(0.03))) - - test.addModel('model2', output2) - test.addConnect(output1,input3) - test.addMinimize('error2', input2.next(), output2) + input2 = Input("in2") + input3 = Input("in3") + b = Parameter("b", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + c = Parameter("c", dimensions=1, tw=0.03, values=[[1], [1], [1]]) + output2 = Output("out2", Fir(W=b)(input2.tw(0.05)) + Fir(W=c)(input3.tw(0.03))) + + test.addModel("model2", output2) + test.addConnect(output1, input3) + test.addMinimize("error2", input2.next(), output2) test.neuralizeModel(0.01) ## Without connect - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}, prediction_samples=-1) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [21.0, 29.0, 37.0, 45.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=-1, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [21.0, 29.0, 37.0, 45.0]) ## connect out1 to in3 for 4 samples test.resetStates() - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]]}, prediction_samples=3) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [30.0, 55.0, 85.0, 105.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + }, + prediction_samples=3, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [30.0, 55.0, 85.0, 105.0]) # self.assertEqual(test.states['in3'], [[[20.], [25.], [30.]]]) # Replace insead of rolling - self.assertEqual(test.states['in3'], [[[25.], [30.], [float('inf')]]]) + self.assertEqual(test.states["in3"], [[[25.0], [30.0], [float("inf")]]]) ## connect out1 to in3 for 3 samples test.resetStates() - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]]}, prediction_samples=2) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [30.0, 55.0, 85.0, 60.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + }, + prediction_samples=2, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [30.0, 55.0, 85.0, 60.0]) # self.assertEqual(test.states['in3'], [[[0.0], [0.], [30.]]]) # Replace insead of rolling - self.assertEqual(test.states['in3'], [[[0.], [30.], [float('inf')]]]) + self.assertEqual(test.states["in3"], [[[0.0], [30.0], [float("inf")]]]) ## connect out1 to in3 for 4 samples (initialize in3 with data) test.resetStates() - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}, prediction_samples=3) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - #(1+2+3+4+5)+(2+3+15) - #(2+3+4+5+6)+(3+15+20) - #self.assertEqual(results['out2'], [35.0, 58.0, 85.0, 105.0]) - #self.assertEqual(test.states['in3'], [[[20.], [25.], [30.]]]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=3, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + # (1+2+3+4+5)+(2+3+15) + # (2+3+4+5+6)+(3+15+20) + # self.assertEqual(results['out2'], [35.0, 58.0, 85.0, 105.0]) + # self.assertEqual(test.states['in3'], [[[20.], [25.], [30.]]]) # Replace insead of rolling - #(1+2+3+4+5)+(1+2+15) - #(2+3+4+5+6)+(2+15+20) - self.assertEqual(results['out2'], [33.0, 57.0, 85.0, 105.0]) - self.assertEqual(test.states['in3'], [[[25.], [30.], [float('inf')]]]) + # (1+2+3+4+5)+(1+2+15) + # (2+3+4+5+6)+(2+15+20) + self.assertEqual(results["out2"], [33.0, 57.0, 85.0, 105.0]) + self.assertEqual(test.states["in3"], [[[25.0], [30.0], [float("inf")]]]) ## connect out1 to in3 for 3 samples (initialize in3 with data) test.resetStates() - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}, prediction_samples=2) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=2, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) # (4+5+6+7+8)+(5+6+30) # self.assertEqual(results['out2'], [35.0, 58.0, 85.0, 71.0]) # self.assertEqual(test.states['in3'], [[[5.], [6.], [30.]]]) # Replace insead of rolling # (4+5+6+7+8)+(4+5+30) - self.assertEqual(results['out2'], [33.0, 57.0, 85.0, 69.0]) - self.assertEqual(test.states['in3'], [[[5.], [30.], [float('inf')]]]) + self.assertEqual(results["out2"], [33.0, 57.0, 85.0, 69.0]) + self.assertEqual(test.states["in3"], [[[5.0], [30.0], [float("inf")]]]) ## Test remove connect - test.removeConnection('in3') + test.removeConnection("in3") test.neuralizeModel() - results = test(inputs={'in1': [[1], [2], [3], [4], [5], [6], [7], [8], [9]], - 'in2': [[1], [2], [3], [4], [5], [6], [7], [8], [9]], - 'in3': [[1], [2], [3], [4], [5], [6]]}, prediction_samples=-1) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [21.0, 29.0, 37.0, 45.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=-1, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [21.0, 29.0, 37.0, 45.0]) ## Test connect via string - test.addConnect('out1', 'in3') + test.addConnect("out1", "in3") test.neuralizeModel() - results = test(inputs={'in1': [[1], [2], [3], [4], [5], [6], [7], [8], [9]], - 'in2': [[1], [2], [3], [4], [5], [6], [7], [8], [9]]}, prediction_samples=3) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [30.0, 55.0, 85.0, 105.0]) - self.assertEqual(test.states['in3'], [[[25.], [30.], [float('inf')]]]) - - def test_predict_values_and_connect_variables_2models_more_window_connect_predict(self): + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + }, + prediction_samples=3, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [30.0, 55.0, 85.0, 105.0]) + self.assertEqual(test.states["in3"], [[[25.0], [30.0], [float("inf")]]]) + + def test_predict_values_and_connect_variables_2models_more_window_connect_predict( + self, + ): NeuObj.clearNames() ## Model1 - input1 = Input('in1') - a = Parameter('a', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output1 = Output('out1', Fir(W=a)(input1.tw(0.05))) + input1 = Input("in1") + a = Parameter("a", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output1 = Output("out1", Fir(W=a)(input1.tw(0.05))) test = Modely(visualizer=None, seed=42) - test.addModel('model1', output1) - test.addMinimize('error1', input1.next(), output1) + test.addModel("model1", output1) + test.addMinimize("error1", input1.next(), output1) test.neuralizeModel(0.01) ## Model2 - input2 = Input('in2') - input3 = Input('in3') - b = Parameter('b', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - c = Parameter('c', dimensions=1, tw=0.03, values=[[1],[1],[1]]) + input2 = Input("in2") + input3 = Input("in3") + b = Parameter("b", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + c = Parameter("c", dimensions=1, tw=0.03, values=[[1], [1], [1]]) input_connect = input3.tw(0.03) - output2 = Output('out2', Fir(W=b)(input2.tw(0.05))+Fir(W=c)(input_connect)) - output_connect = Output('out_connect', input_connect) + output2 = Output("out2", Fir(W=b)(input2.tw(0.05)) + Fir(W=c)(input_connect)) + output_connect = Output("out_connect", input_connect) - test.addModel('model2', [output2, output_connect]) - test.addMinimize('error2', input2.next(), output2) + test.addModel("model2", [output2, output_connect]) + test.addMinimize("error2", input2.next(), output2) test.neuralizeModel(0.01) ## Without connect - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [21.0, 29.0, 37.0, 45.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + } + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [21.0, 29.0, 37.0, 45.0]) ## connect out1 to in3 for 4 samples - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]]}, prediction_samples=3, connect={'in3':'out1'}) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [30.0, 55.0, 85.0, 105.0]) - self.assertEqual(results['out_connect'][-1], [20.0, 25.0, 30.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + }, + prediction_samples=3, + connect={"in3": "out1"}, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [30.0, 55.0, 85.0, 105.0]) + self.assertEqual(results["out_connect"][-1], [20.0, 25.0, 30.0]) # Replace insead of rolling # self.assertEqual(test.model.connect_variables['in3'].detach().numpy().tolist(), [[[25.], [30.], [20.]]]) ## connect out1 to in3 for 3 samples - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]]}, prediction_samples=2, connect={'in3':'out1'}) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - self.assertEqual(results['out2'], [30.0, 55.0, 85.0, 60.0]) - self.assertEqual(results['out_connect'][-1], [0.0, 0., 30.]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + }, + prediction_samples=2, + connect={"in3": "out1"}, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + self.assertEqual(results["out2"], [30.0, 55.0, 85.0, 60.0]) + self.assertEqual(results["out_connect"][-1], [0.0, 0.0, 30.0]) # Replace insead of rolling # self.assertEqual(test.model.connect_variables['in3'].detach().numpy().tolist(), [[[0.], [30.], [0.]]]) ## connect out1 to in3 for 4 samples (initialize in3 with data) - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}, prediction_samples=3, connect={'in3':'out1'}) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) - #(1+2+3+4+5)+(2+3+15) - #(2+3+4+5+6)+(3+15+20) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=3, + connect={"in3": "out1"}, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) + # (1+2+3+4+5)+(2+3+15) + # (2+3+4+5+6)+(3+15+20) # self.assertEqual(results['out2'], [35.0, 58.0, 85.0, 105.0]) - self.assertEqual(results['out_connect'][-1], [20., 25., 30.]) + self.assertEqual(results["out_connect"][-1], [20.0, 25.0, 30.0]) # Replace insead of rolling - #(1+2+3+4+5)+(1+2+15) - #(2+3+4+5+6)+(2+15+20) - self.assertEqual(results['out2'], [33.0, 57.0, 85.0, 105.0]) - #self.assertEqual(results['out_connect'][-1], [25.0, 30.0, 20.0]) + # (1+2+3+4+5)+(1+2+15) + # (2+3+4+5+6)+(2+15+20) + self.assertEqual(results["out2"], [33.0, 57.0, 85.0, 105.0]) + # self.assertEqual(results['out_connect'][-1], [25.0, 30.0, 20.0]) ## connect out1 to in3 for 3 samples (initialize in3 with data) - results = test(inputs={'in1':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in2':[[1],[2],[3],[4],[5],[6],[7],[8],[9]], 'in3':[[1],[2],[3],[4],[5],[6]]}, prediction_samples=2, connect={'in3':'out1'}) - self.assertEqual(results['out1'], [15.0, 20.0, 25.0, 30.0]) + results = test( + inputs={ + "in1": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in2": [[1], [2], [3], [4], [5], [6], [7], [8], [9]], + "in3": [[1], [2], [3], [4], [5], [6]], + }, + prediction_samples=2, + connect={"in3": "out1"}, + ) + self.assertEqual(results["out1"], [15.0, 20.0, 25.0, 30.0]) # (4+5+6+7+8)+(5+6+30) # self.assertEqual(results['out2'], [35.0, 58.0, 85.0, 71.0]) # self.assertEqual(results['out_connect'][-1], [5., 6., 30.]) - self.assertEqual(results['out_connect'][-1], [4., 5., 30.]) + self.assertEqual(results["out_connect"][-1], [4.0, 5.0, 30.0]) # Replace insead of rolling # (4+5+6+7+8)+(4+5+30) - self.assertEqual(results['out2'], [33.0, 57.0, 85.0, 69.0]) + self.assertEqual(results["out2"], [33.0, 57.0, 85.0, 69.0]) # self.assertEqual(test.model.connect_variables['in3'].detach().numpy().tolist(), [[[5.], [30.], [4.]]]) - def test_predict_values_and_states_only_state_variables_more_window_closed_loop(self): + def test_predict_values_and_states_only_state_variables_more_window_closed_loop( + self, + ): NeuObj.clearNames() - x_state = Input('x_state') - p = Parameter('p', dimensions=1, tw=0.03, values=[[1.0], [1.0], [1.0]]) + x_state = Input("x_state") + p = Parameter("p", dimensions=1, tw=0.03, values=[[1.0], [1.0], [1.0]]) rel_x = Fir(W=p)(x_state.tw(0.03)) rel_x = ClosedLoop(rel_x, x_state) - out = Output('out', rel_x) + out = Output("out", rel_x) - test = Modely(visualizer = None, seed=42) - test.addModel('out',out) + test = Modely(visualizer=None, seed=42) + test.addModel("out", out) test.neuralizeModel(0.01) - result = test(inputs={'x_state':[1, 2, 3]}) - self.assertEqual(test.states['x_state'], [[[2.],[3.],[6.]]]) + result = test(inputs={"x_state": [1, 2, 3]}) + self.assertEqual(test.states["x_state"], [[[2.0], [3.0], [6.0]]]) result = test() - self.assertEqual(test.states['x_state'], [[[3.],[6.],[11.]]]) + self.assertEqual(test.states["x_state"], [[[3.0], [6.0], [11.0]]]) def test_predict_values_linear_and_fir_2models_same_window_connect(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=1) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=1) lin_out = Linear(W=W, b=b)(input1.sw(2)) - inout = Input('inout') - a = Parameter('a', sw = 2, values=[[4],[5]]) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) lin_out.connect(inout) - output1 = Output('out1', lin_out) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - output3 = Output('out3', Fir(W=a)(lin_out)) + output1 = Output("out1", lin_out) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + output3 = Output("out3", Fir(W=a)(lin_out)) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2,output3]) + test.addModel("model", [output1, output2, output3]) test.neuralizeModel() # [[1,2],[2,3]]*[-1,-5] = [[1*-1+2*-5=-11],[2*-1+3*-5=-17]]+[1] = [-10,-16] -> [-10,-16]*[4,5] -> [-16*5+-10*4=-120] <------ - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3':[-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[-10,-16]})) - self.assertEqual({'out1': [[-10.0,-16.0]], 'out2': [-120.0], 'out3':[-120.0]}, test({'in1': [[1.0,2.0],[2.0,3.0]]})) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [-120.0], "out3": [-120.0]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [-10, -16]}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [-120.0], "out3": [-120.0]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]]}), + ) def test_predict_values_linear_and_fir_2models_same_window_connect_predict(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=[1]) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) lin_out = Linear(W=W, b=b)(input1.sw(2)) - output1 = Output('out1', lin_out) + output1 = Output("out1", lin_out) - inout = Input('inout') - a = Parameter('a', sw = 2, values=[[4],[5]]) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - output3 = Output('out3', Fir(W=a)(lin_out)) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + output3 = Output("out3", Fir(W=a)(lin_out)) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2,output3]) + test.addModel("model", [output1, output2, output3]) test.neuralizeModel() # [[1,2],[2,3]]*[-1,-5] = [[1*-1+2*-5=-11],[2*-1+3*-5=-17]]+[1] = [-10,-16] -> [-10,-16]*[4,5] -> [-16*5+-10*4=-120] <------ - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3':[-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[-10,-16]})) - self.assertEqual({'out1': [[-10.0,-16.0]], 'out2': [-120.0], 'out3':[-120.0]}, test({'in1': [[1.0,2.0],[2.0,3.0]]},connect={'inout': 'out1'})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[-30,-30]}, connect={'inout': 'out1'})) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [-120.0], "out3": [-120.0]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [-10, -16]}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [-120.0], "out3": [-120.0]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]]}, connect={"inout": "out1"}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [-120.0], "out3": [-120.0]}, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [-30, -30]}, + connect={"inout": "out1"}, + ), + ) def test_predict_values_linear_and_fir_2models_more_window_connect(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=1) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=1) lin_out = Linear(W=W, b=b)(input1.sw(2)) - inout = Input('inout') - a = Parameter('a', sw = 2, values=[[4], [5]]) - a_big = Parameter('ab', sw = 5, values=[[1], [2], [3], [4], [5]]) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) + a_big = Parameter("ab", sw=5, values=[[1], [2], [3], [4], [5]]) lin_out.connect(inout) - output1 = Output('out1', lin_out) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - output3 = Output('out3', Fir(W=a_big)(inout.sw(5))) - output4 = Output('out4', Fir(W=a)(lin_out)) + output1 = Output("out1", lin_out) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + output3 = Output("out3", Fir(W=a_big)(inout.sw(5))) + output4 = Output("out4", Fir(W=a)(lin_out)) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2,output3,output4]) + test.addModel("model", [output1, output2, output3, output4]) test.neuralizeModel() # [[1,2],[2,3]]*[-1,-5] = [[1*-1+2*-5=-11],[2*-1+3*-5=-17]]+[1] = [-10,-16] -> [-10,-16]*[4,5] -> [-16*5+-10*4=-120] <------ - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0], 'out4': [-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]]})) + self.assertEqual( + { + "out1": [[-10.0, -16.0]], + "out2": [-120.0], + "out3": [-120.0], + "out4": [-120.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0]]}), + ) test.resetStates() # out2 # = [[-10,-16]] -> 1) [-10,-16]*[4,5] -> [-16*5+-10*4=-120] # out3 # = [[-10,-16]] -> 1) [0,0,-10,-10,-16]*[1,2,3,4,5] -> [-10*3+-16*5+-10*4=-150] # self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-150.0], 'out4': [-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[0,0,0,-10,-16]})) # Replace instead of rolling - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0], 'out4': [-120.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'inout': [0, 0, 0, -10, -16]})) + self.assertEqual( + { + "out1": [[-10.0, -16.0]], + "out2": [-120.0], + "out3": [-120.0], + "out4": [-120.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [0, 0, 0, -10, -16]}), + ) test.resetStates() # out2 # = [[-10,-16],[-16,-10]] -> 1) [-10,-16]*[4,5] -> [-16*5+-10*4=-120] 2) [-16,-10]*[4,5] -> [-16*4+-10*5=-114] -> [-120,-114] # out3 # = [[-10,-16],[-16,-10]] -> 1) [0,0,0,-10,-16]*[1,2,3,4,5] -> [-16*5+-10*4=-120] 2) [0,0,-10,-16,-10]*[1,2,3,4,5] -> [-10*3+-16*4+-10*5 = -144] -> [-120,-144] - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0, -10.0]], 'out2': [-120.0,-114.0], 'out3': [-120.0,-144], 'out4': [-120.0,-114.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0], [1.0,2.0]]})) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -10.0]], + "out2": [-120.0, -114.0], + "out3": [-120.0, -144], + "out4": [-120.0, -114.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0], [1.0, 2.0]]}), + ) with self.assertRaises(ValueError): test.removeConnection(input1) test.removeConnection(inout) test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [0.0], 'out3': [0.0], 'out4': [-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]]})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0], 'out4': [-120.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'inout': [0, 0, 0, -10, -16]})) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -10.0]], 'out2': [0.0, 0.0], 'out3': [0.0, 0.0], 'out4': [-120.0, -114.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0], [1.0, 2.0]]})) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [0.0], "out3": [0.0], "out4": [-120.0]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]]}), + ) + self.assertEqual( + { + "out1": [[-10.0, -16.0]], + "out2": [-120.0], + "out3": [-120.0], + "out4": [-120.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [0, 0, 0, -10, -16]}), + ) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -10.0]], + "out2": [0.0, 0.0], + "out3": [0.0, 0.0], + "out4": [-120.0, -114.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0], [1.0, 2.0]]}), + ) def test_predict_values_linear_and_fir_2models_more_window_connect_predict(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=[1]) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) lin_out = Linear(W=W, b=b)(input1.sw(2)) - output1 = Output('out1', lin_out) + output1 = Output("out1", lin_out) - inout = Input('inout') - a = Parameter('a', sw = 2, values=[[4], [5]]) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - a_big = Parameter('ab', sw = 5, values=[[1], [2], [3], [4], [5]]) - output3 = Output('out3', Fir(W=a_big)(inout.sw(5))) - output4 = Output('out4', Fir(W=a)(lin_out)) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + a_big = Parameter("ab", sw=5, values=[[1], [2], [3], [4], [5]]) + output3 = Output("out3", Fir(W=a_big)(inout.sw(5))) + output4 = Output("out4", Fir(W=a)(lin_out)) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2,output3,output4]) + test.addModel("model", [output1, output2, output3, output4]) test.neuralizeModel() # [[1,2],[2,3]]*[-1,-5] = [[1*-1+2*-5=-11],[2*-1+3*-5=-17]]+[1] = [-10,-16] -> [-10,-16]*[4,5] -> [-16*5+-10*4=-120] <------ - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0], 'out4': [-120.0]}, test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[0,0,0,-10,-16]})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-120.0], 'out4': [-120.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]]}, connect={'inout': 'out1'})) - #self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-150.0], 'out4': [-120.0]}, + self.assertEqual( + { + "out1": [[-10.0, -16.0]], + "out2": [-120.0], + "out3": [-120.0], + "out4": [-120.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "inout": [0, 0, 0, -10, -16]}), + ) + self.assertEqual( + { + "out1": [[-10.0, -16.0]], + "out2": [-120.0], + "out3": [-120.0], + "out4": [-120.0], + }, + test({"in1": [[1.0, 2.0], [2.0, 3.0]]}, connect={"inout": "out1"}), + ) + # self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [-120.0], 'out3': [-150.0], 'out4': [-120.0]}, # test({'in1': [[1.0, 2.0], [2.0, 3.0]],'inout':[0,0,0,-10,-16]}, connect={'inout': 'out1'})) with self.assertRaises(StopIteration): self.assertEqual({}, test()) @@ -894,255 +1284,452 @@ def test_predict_values_linear_and_fir_2models_more_window_connect_predict(self) with self.assertRaises(StopIteration): self.assertEqual({}, test(prediction_samples=4)) - self.assertEqual({'out1': [[1.0, 1.0]], 'out2': [9.0], 'out3': [9.0], 'out4': [9.0]}, - test(connect={'inout': 'out1'})) - self.assertEqual({'out1': [[1.0, 1.0]], 'out2': [9.0], 'out3': [9.0], 'out4': [9.0]}, - test(connect={'inout': 'out1'}, prediction_samples=0)) - self.assertEqual({'out1': [[1.0, 1.0],[1.0, 1.0]], 'out2': [9.0,9.0], 'out3': [9.0,12.0], 'out4': [9.0,9.0]}, - test(connect={'inout': 'out1'}, prediction_samples=1, num_of_samples=2)) + self.assertEqual( + {"out1": [[1.0, 1.0]], "out2": [9.0], "out3": [9.0], "out4": [9.0]}, + test(connect={"inout": "out1"}), + ) + self.assertEqual( + {"out1": [[1.0, 1.0]], "out2": [9.0], "out3": [9.0], "out4": [9.0]}, + test(connect={"inout": "out1"}, prediction_samples=0), + ) + self.assertEqual( + { + "out1": [[1.0, 1.0], [1.0, 1.0]], + "out2": [9.0, 9.0], + "out3": [9.0, 12.0], + "out4": [9.0, 9.0], + }, + test(connect={"inout": "out1"}, prediction_samples=1, num_of_samples=2), + ) # [[1,2],[2,3]]*[-1,-5] = [[1*-1+2*-5=-11],[2*-1+3*-5=-17]]+[1] # [[2,3],[1,2]]*[-1,-5] = [[2*-1+3*-5=-17],[1*-1+2*-5=-11]]+[1] # out2 # = [[-10,-16],[-16,-10]] -> 1) [-10,-16]*[4,5] -> [-16*5+-10*4=-120] 2) [-16,-10]*[4,5] -> [-16*4+-10*5=-114] -> [-120,-114] # out3 # = [[-10,-16],[-16,-10]] -> 1) [0,0,0,-10,-16]*[1,2,3,4,5] -> [-16*5+-10*4=-120] 2) [0,0,-10,-16,-10]*[1,2,3,4,5] -> [-10*3+-16*4+-10*5 = -144] -> [-120,-144] - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0, -10.0]], 'out2': [-120.0,-114.0], 'out3': [-120.0,-144], 'out4': [-120.0,-114.0]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0], [1.0,2.0]]}, - connect={'inout': 'out1'})) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -10.0]], + "out2": [-120.0, -114.0], + "out3": [-120.0, -144], + "out4": [-120.0, -114.0], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0], [1.0, 2.0]]}, connect={"inout": "out1"} + ), + ) def test_predict_values_linear_and_fir_2models_more_window_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=1) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=1) relation1 = Linear(W=W, b=b)(input1.sw(2)) # input2 = Input('inout') #TODO loop forever # test.addConnect(output1, input1) # With this - input2 = Input('in2') - a = Parameter('a', sw=5, values=[[1,3],[2,4],[3,5],[4,6],[5,7]]) - relation2 = Fir(output_dimension=2,W=a)(input2.sw(5)) + input2 = Input("in2") + a = Parameter("a", sw=5, values=[[1, 3], [2, 4], [3, 5], [4, 6], [5, 7]]) + relation2 = Fir(output_dimension=2, W=a)(input2.sw(5)) relation1.closedLoop(input2) relation2.closedLoop(input1) - output1 = Output('out1', relation1) - output2 = Output('out2', relation2) + output1 = Output("out1", relation1) + output2 = Output("out2", relation2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) + test.addModel("model", [output1, output2]) test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]},prediction_samples=0)) - - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0,465.0]], 'out2': [[[-34.0, -86.0]],[[-140.0,-230.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=1, num_of_samples=2)) - self.assertEqual({'out1': [[465.0,1291.0]], 'out2': [[[2230.0, 3102.0]]]}, test()) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=0, + ), + ) + + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=1, + num_of_samples=2, + ), + ) + self.assertEqual( + {"out1": [[465.0, 1291.0]], "out2": [[[2230.0, 3102.0]]]}, test() + ) test.resetStates() - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0,465.0],[465.0,1291.0]], 'out2': [[[-34.0, -86.0]],[[-140.0,-230.0]],[[2230.0, 3102.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=2, num_of_samples=3)) - - def test_predict_values_linear_and_fir_2models_more_window_closed_loop_on_models(self): + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0], [465.0, 1291.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]], [[2230.0, 3102.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=2, + num_of_samples=3, + ), + ) + + def test_predict_values_linear_and_fir_2models_more_window_closed_loop_on_models( + self, + ): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=1) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=1) relation1 = Linear(W=W, b=b)(input1.sw(2)) # input2 = Input('inout') #TODO loop forever # test.addConnect(output1, input1) # With this - input2 = Input('in2') - a = Parameter('a', sw=5, values=[[1,3],[2,4],[3,5],[4,6],[5,7]]) - relation2 = Fir(output_dimension=2,W=a)(input2.sw(5)) + input2 = Input("in2") + a = Parameter("a", sw=5, values=[[1, 3], [2, 4], [3, 5], [4, 6], [5, 7]]) + relation2 = Fir(output_dimension=2, W=a)(input2.sw(5)) - output1 = Output('out1', relation1) - output2 = Output('out2', relation2) + output1 = Output("out1", relation1) + output2 = Output("out2", relation2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) + test.addModel("model", [output1, output2]) test.addClosedLoop(output1, input2) test.addClosedLoop(output2, input1) test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]},prediction_samples=0)) - - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0,465.0]], 'out2': [[[-34.0, -86.0]],[[-140.0,-230.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=1, num_of_samples=2)) - self.assertEqual({'out1': [[465.0,1291.0]], 'out2': [[[2230.0, 3102.0]]]}, test()) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=0, + ), + ) + + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=1, + num_of_samples=2, + ), + ) + self.assertEqual( + {"out1": [[465.0, 1291.0]], "out2": [[[2230.0, 3102.0]]]}, test() + ) test.resetStates() - self.assertEqual({'out1': [[-10.0, -16.0],[-16.0,465.0],[465.0,1291.0]], 'out2': [[[-34.0, -86.0]],[[-140.0,-230.0]],[[2230.0, 3102.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=2, num_of_samples=3)) - - test.removeConnection('in1') - test.removeConnection('in2') + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0], [465.0, 1291.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]], [[2230.0, 3102.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=2, + num_of_samples=3, + ), + ) + + test.removeConnection("in1") + test.removeConnection("in2") test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]})) - - test.addClosedLoop('out1', 'in2') - test.addClosedLoop('out2', 'in1') + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test({"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}), + ) + + test.addClosedLoop("out1", "in2") + test.addClosedLoop("out2", "in1") test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, 465.0], [465.0, 1291.0]], - 'out2': [[[-34.0, -86.0]], [[-140.0, -230.0]], [[2230.0, 3102.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=2, - num_of_samples=3)) - - def test_predict_values_linear_and_fir_2models_more_window_closed_loop_predict(self): + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0], [465.0, 1291.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]], [[2230.0, 3102.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=2, + num_of_samples=3, + ), + ) + + def test_predict_values_linear_and_fir_2models_more_window_closed_loop_predict( + self, + ): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=[1]) - output1 = Output('out1', Linear(W=W, b=b)(input1.sw(2))) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) + output1 = Output("out1", Linear(W=W, b=b)(input1.sw(2))) # input2 = Input('inout') #TODO loop forever # test.addConnect(output1, input1) # With this - input2 = Input('in2') - a = Parameter('a', sw=5, values=[[1,3],[2,4],[3,5],[4,6],[5,7]]) - output2 = Output('out2', Fir(output_dimension=2,W=a)(input2.sw(5))) + input2 = Input("in2") + a = Parameter("a", sw=5, values=[[1, 3], [2, 4], [3, 5], [4, 6], [5, 7]]) + output2 = Output("out2", Fir(output_dimension=2, W=a)(input2.sw(5))) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) + test.addModel("model", [output1, output2]) test.neuralizeModel() # 1*-1+2*-5+1 = -10 2*-1+3*-5+1 = -16 -10*1+-16*2+-5*3+2*4+3*5 = -34 -16*2+-10*3+-5*4+2*5+3*6 = -86 - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, closed_loop={'in1':'out2', 'in2':'out1'})) - self.assertEqual({'out1': [[-10.0, -16.0]], 'out2': [[[-34.0, -86.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=0, closed_loop={'in1':'out2', 'in2':'out1'})) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0,465.0]], 'out2': [[[-34.0, -86.0]],[[-140.0,-230.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, num_of_samples=2, prediction_samples=2, closed_loop={'in1':'out2', 'in2':'out1'})) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + closed_loop={"in1": "out2", "in2": "out1"}, + ), + ) + self.assertEqual( + {"out1": [[-10.0, -16.0]], "out2": [[[-34.0, -86.0]]]}, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=0, + closed_loop={"in1": "out2", "in2": "out1"}, + ), + ) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, 465.0]], + "out2": [[[-34.0, -86.0]], [[-140.0, -230.0]]], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + num_of_samples=2, + prediction_samples=2, + closed_loop={"in1": "out2", "in2": "out1"}, + ), + ) with self.assertRaises(StopIteration): - self.assertEqual({'out1': [[465.0, 1291.0]], 'out2': [[[2230.0, 3102.0]]]}, test()) + self.assertEqual( + {"out1": [[465.0, 1291.0]], "out2": [[[2230.0, 3102.0]]]}, test() + ) with self.assertRaises(StopIteration): - self.assertEqual({'out1': [[465.0, 1291.0]], 'out2': [[[2230.0, 3102.0]]]}, test(prediction_samples=0)) + self.assertEqual( + {"out1": [[465.0, 1291.0]], "out2": [[[2230.0, 3102.0]]]}, + test(prediction_samples=0), + ) with self.assertRaises(StopIteration): - self.assertEqual({'out1': [[465.0, 1291.0]], 'out2': [[[2230.0, 3102.0]]]}, test(prediction_samples=3)) - self.assertEqual({'out1': [[1.0, 1.0]], 'out2': [[[0.0, 0.0]]]}, - test(closed_loop={'in1': 'out2', 'in2': 'out1'})) - self.assertEqual({'out1': [[1.0, 1.0]], 'out2': [[[0.0, 0.0]]]}, - test(closed_loop={'in1': 'out2', 'in2': 'out1'},prediction_samples=0)) - self.assertEqual({'out1': [[1.0, 1.0],[1.0,1.0]], 'out2': [[[0.0, 0.0]],[[9.0,13.0]]]}, - test(closed_loop={'in1': 'out2', 'in2': 'out1'},prediction_samples=1, num_of_samples=2)) - self.assertEqual({'out1': [[1.0, 1.0],[1.0,1.0],[1.0,-73.0]], 'out2': [[[0.0, 0.0]],[[9.0,13.0]],[[12.0,18.0]]]}, - test(closed_loop={'in1': 'out2', 'in2': 'out1'},prediction_samples=2, num_of_samples=3)) - - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0,1.0], [1.0,1.0], [1.0,1.0], [1.0,1.0]], - 'out2': [[[-34.0, -86.0]],[[-8.0,-40.0]],[[8.0,8.0]],[[8.0,18.0]],[[3.0,9.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, num_of_samples=5)) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0,1.0], [1.0,1.0], [1.0,1.0], [1.0,1.0]], - 'out2': [[[-34.0, -86.0]],[[-8.0,-40.0]],[[8.0,8.0]],[[8.0,18.0]],[[3.0,9.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, prediction_samples=-1, num_of_samples=5)) - - #-34*-1+ -86*-5+1 = 465.0 - #-140*-1+ -230*-5+1 = 465.0 - #8*-1 + 18*-5+1 = -97.0 - #[[1, 3], [2, 4], [3, 5], [4, 6], [5, 7]] * [465.0, 1291.0] - #-16*1+-5*2+2*3+-10.0*4-16.0*5 = 140 - #-5*1+2*2-10*3+-16*4+465*5 = 2230 , -5*3+2*4-10*5+-16*6+465*7 = 3102 - #2*1+3*2 = 8, 2*3+3*4 = 18 - #3*1+1*4+1*5 = 12.0, 3*3+1*6+1*7 = 22.0 - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, 465.0], [465.0, 1291.0], [1.0, 1.0], [1.0, -97.0]], - 'out2': [[[-34.0, -86.0]], [[-140.0, -230.0]],[[2230.0, 3102.0]], [[8.0, 18.0]], [[12.0, 22.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0]], 'in2': [-10, -16, -5, 2, 3]}, num_of_samples=5, - prediction_samples=2, closed_loop={'in1': 'out2', 'in2': 'out1'})) + self.assertEqual( + {"out1": [[465.0, 1291.0]], "out2": [[[2230.0, 3102.0]]]}, + test(prediction_samples=3), + ) + self.assertEqual( + {"out1": [[1.0, 1.0]], "out2": [[[0.0, 0.0]]]}, + test(closed_loop={"in1": "out2", "in2": "out1"}), + ) + self.assertEqual( + {"out1": [[1.0, 1.0]], "out2": [[[0.0, 0.0]]]}, + test(closed_loop={"in1": "out2", "in2": "out1"}, prediction_samples=0), + ) + self.assertEqual( + {"out1": [[1.0, 1.0], [1.0, 1.0]], "out2": [[[0.0, 0.0]], [[9.0, 13.0]]]}, + test( + closed_loop={"in1": "out2", "in2": "out1"}, + prediction_samples=1, + num_of_samples=2, + ), + ) + self.assertEqual( + { + "out1": [[1.0, 1.0], [1.0, 1.0], [1.0, -73.0]], + "out2": [[[0.0, 0.0]], [[9.0, 13.0]], [[12.0, 18.0]]], + }, + test( + closed_loop={"in1": "out2", "in2": "out1"}, + prediction_samples=2, + num_of_samples=3, + ), + ) + + self.assertEqual( + { + "out1": [ + [-10.0, -16.0], + [-16.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], + ], + "out2": [ + [[-34.0, -86.0]], + [[-8.0, -40.0]], + [[8.0, 8.0]], + [[8.0, 18.0]], + [[3.0, 9.0]], + ], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + num_of_samples=5, + ), + ) + self.assertEqual( + { + "out1": [ + [-10.0, -16.0], + [-16.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], + ], + "out2": [ + [[-34.0, -86.0]], + [[-8.0, -40.0]], + [[8.0, 8.0]], + [[8.0, 18.0]], + [[3.0, 9.0]], + ], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + prediction_samples=-1, + num_of_samples=5, + ), + ) + + # -34*-1+ -86*-5+1 = 465.0 + # -140*-1+ -230*-5+1 = 465.0 + # 8*-1 + 18*-5+1 = -97.0 + # [[1, 3], [2, 4], [3, 5], [4, 6], [5, 7]] * [465.0, 1291.0] + # -16*1+-5*2+2*3+-10.0*4-16.0*5 = 140 + # -5*1+2*2-10*3+-16*4+465*5 = 2230 , -5*3+2*4-10*5+-16*6+465*7 = 3102 + # 2*1+3*2 = 8, 2*3+3*4 = 18 + # 3*1+1*4+1*5 = 12.0, 3*3+1*6+1*7 = 22.0 + self.assertEqual( + { + "out1": [ + [-10.0, -16.0], + [-16.0, 465.0], + [465.0, 1291.0], + [1.0, 1.0], + [1.0, -97.0], + ], + "out2": [ + [[-34.0, -86.0]], + [[-140.0, -230.0]], + [[2230.0, 3102.0]], + [[8.0, 18.0]], + [[12.0, 22.0]], + ], + }, + test( + {"in1": [[1.0, 2.0], [2.0, 3.0]], "in2": [-10, -16, -5, 2, 3]}, + num_of_samples=5, + prediction_samples=2, + closed_loop={"in1": "out2", "in2": "out1"}, + ), + ) def test_predict_parameters(self): NeuObj.clearNames() - input1 = Input('in1') - cl1 = Input('cl1') - co1 = Input('co1') - W = Parameter('W', values=[[1], [2], [3]]) + input1 = Input("in1") + cl1 = Input("cl1") + co1 = Input("co1") + W = Parameter("W", values=[[1], [2], [3]]) parfun = ParamFun(myfunsum, parameters_and_constants=[W]) matmulfun = ParamFun(matmul) parfun_out = parfun(input1.sw(3)) - output = Output('out', parfun_out) - matmul_outcl = matmulfun(parfun_out, cl1.sw(3))+1.0 + output = Output("out", parfun_out) + matmul_outcl = matmulfun(parfun_out, cl1.sw(3)) + 1.0 matmul_outcl.connect(co1) matmul_outcl.closedLoop(cl1) - outputCl = Output('outCl', matmul_outcl) - outputCo = Output('outCo', matmulfun(parfun_out, co1.sw(3))) + outputCl = Output("outCl", matmul_outcl) + outputCo = Output("outCo", matmulfun(parfun_out, co1.sw(3))) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output,outputCl,outputCo]) + test.addModel("model", [output, outputCl, outputCo]) test.neuralizeModel() # Test only one input - result = test({'in1':[1,2,3]}) - self.assertEqual((1,3), np.array(result['out']).shape) - self.assertEqual((1,), np.array(result['outCl']).shape) - self.assertEqual((1,), np.array(result['outCo']).shape) - self.assertEqual([[2.0,4.0,6.0]], result['out']) - self.assertEqual([1.0], result['outCl']) - self.assertEqual([6.0],result['outCo']) - self.assertEqual(test.states['cl1'], [[[0.], [0.], [1.]]]) + result = test({"in1": [1, 2, 3]}) + self.assertEqual((1, 3), np.array(result["out"]).shape) + self.assertEqual((1,), np.array(result["outCl"]).shape) + self.assertEqual((1,), np.array(result["outCo"]).shape) + self.assertEqual([[2.0, 4.0, 6.0]], result["out"]) + self.assertEqual([1.0], result["outCl"]) + self.assertEqual([6.0], result["outCo"]) + self.assertEqual(test.states["cl1"], [[[0.0], [0.0], [1.0]]]) # self.assertEqual(test.states['co1'], [[[0.], [0.], [1.]]]) - self.assertEqual(test.states['co1'], [[[0.], [1.], [float('inf')]]]) + self.assertEqual(test.states["co1"], [[[0.0], [1.0], [float("inf")]]]) # Test two input test.resetStates() - result = test({'in1':[1,2,3,4]}) - self.assertEqual((2,3), np.array(result['out']).shape) - self.assertEqual((2,), np.array(result['outCl']).shape) - self.assertEqual((2,), np.array(result['outCo']).shape) - self.assertEqual([[2.0,4.0,6.0],[3.0,5.0,7.0]], result['out']) - self.assertEqual([1.0,1*7+1], result['outCl']) - self.assertEqual([1 * 6.0, 1. * 5 + 7. * 8.], result['outCo']) + result = test({"in1": [1, 2, 3, 4]}) + self.assertEqual((2, 3), np.array(result["out"]).shape) + self.assertEqual((2,), np.array(result["outCl"]).shape) + self.assertEqual((2,), np.array(result["outCo"]).shape) + self.assertEqual([[2.0, 4.0, 6.0], [3.0, 5.0, 7.0]], result["out"]) + self.assertEqual([1.0, 1 * 7 + 1], result["outCl"]) + self.assertEqual([1 * 6.0, 1.0 * 5 + 7.0 * 8.0], result["outCo"]) # self.assertEqual(test.states['co1'], [[[0.], [1.], [8.]]]) - self.assertEqual(test.states['co1'], [[[1.], [8.], [float('inf')]]]) - self.assertEqual(test.states['cl1'], [[[0.], [1.], [8.]]]) + self.assertEqual(test.states["co1"], [[[1.0], [8.0], [float("inf")]]]) + self.assertEqual(test.states["cl1"], [[[0.0], [1.0], [8.0]]]) # Test two input test.resetStates() - result = test({'in1':[1,2,3,4], 'cl1':[2,2,2,2,2,2]}) - self.assertEqual((2,3), np.array(result['out']).shape) - self.assertEqual((2,), np.array(result['outCl']).shape) - self.assertEqual((2,), np.array(result['outCo']).shape) - self.assertEqual([[2.0,4.0,6.0],[3.0,5.0,7.0]], result['out']) + result = test({"in1": [1, 2, 3, 4], "cl1": [2, 2, 2, 2, 2, 2]}) + self.assertEqual((2, 3), np.array(result["out"]).shape) + self.assertEqual((2,), np.array(result["outCl"]).shape) + self.assertEqual((2,), np.array(result["outCo"]).shape) + self.assertEqual([[2.0, 4.0, 6.0], [3.0, 5.0, 7.0]], result["out"]) # 2*2+4*2+6*2+1, 2*3+5*2+7*2+1 - self.assertEqual([25.0, 31.], result['outCl']) - self.assertEqual([150.0, 342.0], result['outCo']) - self.assertEqual(test.states['cl1'], [[[2.], [2.], [31.]]]) - #self.assertEqual(test.states['co1'], [[[0.], [25.], [31.]]]) - self.assertEqual(test.states['co1'], [[[25.], [31.], [float('inf')]]]) + self.assertEqual([25.0, 31.0], result["outCl"]) + self.assertEqual([150.0, 342.0], result["outCo"]) + self.assertEqual(test.states["cl1"], [[[2.0], [2.0], [31.0]]]) + # self.assertEqual(test.states['co1'], [[[0.], [25.], [31.]]]) + self.assertEqual(test.states["co1"], [[[25.0], [31.0], [float("inf")]]]) # Test two input test.resetStates() - result = test({'in1':[1,2,3,4], 'co1':[2,2,2,2,2,2]}) - self.assertEqual((2,3), np.array(result['out']).shape) - self.assertEqual((2,), np.array(result['outCl']).shape) - self.assertEqual((2,), np.array(result['outCo']).shape) - self.assertEqual([[2.0,4.0,6.0],[3.0,5.0,7.0]], result['out']) + result = test({"in1": [1, 2, 3, 4], "co1": [2, 2, 2, 2, 2, 2]}) + self.assertEqual((2, 3), np.array(result["out"]).shape) + self.assertEqual((2,), np.array(result["outCl"]).shape) + self.assertEqual((2,), np.array(result["outCo"]).shape) + self.assertEqual([[2.0, 4.0, 6.0], [3.0, 5.0, 7.0]], result["out"]) # 2*0+4*0+6*0+1 - self.assertEqual([1.0, 7*1+1.], result['outCl']) + self.assertEqual([1.0, 7 * 1 + 1.0], result["outCl"]) # 2*2+4*2+6*1, 2*3+2*5+7*8 - self.assertEqual([18.0, 72.0], result['outCo']) - self.assertEqual(test.states['cl1'], [[[0.], [1.], [8.]]]) - #self.assertEqual(test.states['co1'], [[[2.], [2.], [8.]]]) - self.assertEqual(test.states['co1'], [[[2.], [8.], [float('inf')]]]) + self.assertEqual([18.0, 72.0], result["outCo"]) + self.assertEqual(test.states["cl1"], [[[0.0], [1.0], [8.0]]]) + # self.assertEqual(test.states['co1'], [[[2.], [2.], [8.]]]) + self.assertEqual(test.states["co1"], [[[2.0], [8.0], [float("inf")]]]) test.resetStates() - result = test({'co1':[2,2,2,2,2,2]}) - self.assertEqual((4,3), np.array(result['out']).shape) - self.assertEqual((4,), np.array(result['outCl']).shape) - self.assertEqual((4,), np.array(result['outCo']).shape) - self.assertEqual([[1.0,2.0,3.0],[1.0,2.0,3.0],[1.0,2.0,3.0],[1.0,2.0,3.0]], result['out']) - self.assertEqual(test.states['cl1'], [[[4.], [15.], [55.]]]) + result = test({"co1": [2, 2, 2, 2, 2, 2]}) + self.assertEqual((4, 3), np.array(result["out"]).shape) + self.assertEqual((4,), np.array(result["outCl"]).shape) + self.assertEqual((4,), np.array(result["outCo"]).shape) + self.assertEqual( + [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0]], + result["out"], + ) + self.assertEqual(test.states["cl1"], [[[4.0], [15.0], [55.0]]]) # self.assertEqual(test.states['co1'], [[[2.], [2.], [55.]]]) - self.assertEqual(test.states['co1'], [[[2.], [55.], [float('inf')]]]) + self.assertEqual(test.states["co1"], [[[2.0], [55.0], [float("inf")]]]) test.resetStates() - result = test({'co1':[2,2,2,2,2,2]}, prediction_samples = 2) - self.assertEqual((4,3), np.array(result['out']).shape) - self.assertEqual((4,), np.array(result['outCl']).shape) - self.assertEqual((4,), np.array(result['outCo']).shape) - + result = test({"co1": [2, 2, 2, 2, 2, 2]}, prediction_samples=2) + self.assertEqual((4, 3), np.array(result["out"]).shape) + self.assertEqual((4,), np.array(result["outCl"]).shape) + self.assertEqual((4,), np.array(result["outCo"]).shape) # Test output recurrent @@ -1209,167 +1796,336 @@ def test_predict_parameters(self): def test_parameters_predict_closed_loop_perdict(self): NeuObj.clearNames() - input1 = Input('in1') - W = Parameter('W', sw=3, values=[[1], [2], [3]]) - out = Output('out',Fir(W=W)(input1.sw(3))) + input1 = Input("in1") + W = Parameter("W", sw=3, values=[[1], [2], [3]]) + out = Output("out", Fir(W=W)(input1.sw(3))) test = Modely(visualizer=None, seed=42) - test.addModel('model', [out]) + test.addModel("model", [out]) test.neuralizeModel() - result = test({'in1':[1,2,3]}) - self.assertEqual((1,), np.array(result['out']).shape) - self.assertEqual([14.0], result['out']) - - result = test({'in1': [1, 2, 3]},closed_loop={'in1':'out'}) - self.assertEqual((1,), np.array(result['out']).shape) - self.assertEqual([14.0], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]}, closed_loop = {'in1':'out'}, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0, 3*4+2*3+2*1, 5*3+4*2+3*1, 26*3+5*2+4*1, 92*3+26*2+1*5], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=-1) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=0) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=1) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,5*3+4*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=2) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=3) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=-1, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1,0*3+5*2+4*1,0*3+0*2+5*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=0, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1,0*3+5*2+4*1,0*3+0*2+5*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=1, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,5*3+4*2+3*1,26*3+5*2+4*1,0*3+0*2+5*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=2, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1,0*3+5*2+4*1,14*3+0*2+5*1], result['out']) - - result = test({'in1': [1, 2, 3, 4, 5]},closed_loop={'in1':'out'}, prediction_samples=3, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1,181*3+50*2+14*1,0*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3]}) + self.assertEqual((1,), np.array(result["out"]).shape) + self.assertEqual([14.0], result["out"]) + + result = test({"in1": [1, 2, 3]}, closed_loop={"in1": "out"}) + self.assertEqual((1,), np.array(result["out"]).shape) + self.assertEqual([14.0], result["out"]) + + result = test({"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, num_of_samples=5 + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 26 * 3 + 5 * 2 + 4 * 1, + 92 * 3 + 26 * 2 + 1 * 5, + ], + result["out"], + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, prediction_samples=-1 + ) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, prediction_samples=0 + ) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, prediction_samples=1 + ) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, prediction_samples=2 + ) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 50 * 3 + 14 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, closed_loop={"in1": "out"}, prediction_samples=3 + ) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 50 * 3 + 14 * 2 + 3 * 1], result["out"] + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, + closed_loop={"in1": "out"}, + prediction_samples=-1, + num_of_samples=5, + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, + closed_loop={"in1": "out"}, + prediction_samples=0, + num_of_samples=5, + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, + closed_loop={"in1": "out"}, + prediction_samples=1, + num_of_samples=5, + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 26 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, + closed_loop={"in1": "out"}, + prediction_samples=2, + num_of_samples=5, + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 50 * 3 + 14 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 14 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) + + result = test( + {"in1": [1, 2, 3, 4, 5]}, + closed_loop={"in1": "out"}, + prediction_samples=3, + num_of_samples=5, + ) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 50 * 3 + 14 * 2 + 3 * 1, + 181 * 3 + 50 * 2 + 14 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) def test_parameters_predict_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1') - W = Parameter('W', sw=3, values=[[1], [2], [3]]) + input1 = Input("in1") + W = Parameter("W", sw=3, values=[[1], [2], [3]]) relation = Fir(W=W)(input1.sw(3)) relation.closedLoop(input1) - out = Output('out',relation) + out = Output("out", relation) test = Modely(visualizer=None, seed=42) - test.addModel('model', [out]) + test.addModel("model", [out]) test.neuralizeModel() - result = test({'in1':[1,2,3]}) - self.assertEqual((1,), np.array(result['out']).shape) - self.assertEqual([14.0], result['out']) + result = test({"in1": [1, 2, 3]}) + self.assertEqual((1,), np.array(result["out"]).shape) + self.assertEqual([14.0], result["out"]) test.resetStates() - result = test({'in1': [1, 2, 3]}) - self.assertEqual((1,), np.array(result['out']).shape) - self.assertEqual([14.0], result['out']) + result = test({"in1": [1, 2, 3]}) + self.assertEqual((1,), np.array(result["out"]).shape) + self.assertEqual([14.0], result["out"]) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0, 3*4+2*3+2*1, 5*3+4*2+3*1, 26*3+5*2+4*1, 92*3+26*2+1*5], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 26 * 3 + 5 * 2 + 4 * 1, + 92 * 3 + 26 * 2 + 1 * 5, + ], + result["out"], + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=-1) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=-1) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=0) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=0) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 4 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=1) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,5*3+4*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=1) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 5 * 3 + 4 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=2) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=2) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 50 * 3 + 14 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=3) - self.assertEqual((3,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=3) + self.assertEqual((3,), np.array(result["out"]).shape) + self.assertEqual( + [14.0, 3 * 14 + 2 * 3 + 2 * 1, 50 * 3 + 14 * 2 + 3 * 1], result["out"] + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=-1, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1,0*3+5*2+4*1,0*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=-1, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=0, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*4+2*3+2*1,5*3+4*2+3*1,0*3+5*2+4*1,0*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=0, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 4 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=1, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,5*3+4*2+3*1,26*3+5*2+4*1,0*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=1, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 5 * 3 + 4 * 2 + 3 * 1, + 26 * 3 + 5 * 2 + 4 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=2, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1,0*3+5*2+4*1,14*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=2, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 50 * 3 + 14 * 2 + 3 * 1, + 0 * 3 + 5 * 2 + 4 * 1, + 14 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) test.resetStates() - result = test({'in1': [1, 2, 3, 4, 5]}, prediction_samples=3, num_of_samples = 5) - self.assertEqual((5,), np.array(result['out']).shape) - self.assertEqual([14.0,3*14+2*3+2*1,50*3+14*2+3*1,181*3+50*2+14*1,0*3+0*2+5*1], result['out']) + result = test({"in1": [1, 2, 3, 4, 5]}, prediction_samples=3, num_of_samples=5) + self.assertEqual((5,), np.array(result["out"]).shape) + self.assertEqual( + [ + 14.0, + 3 * 14 + 2 * 3 + 2 * 1, + 50 * 3 + 14 * 2 + 3 * 1, + 181 * 3 + 50 * 2 + 14 * 1, + 0 * 3 + 0 * 2 + 5 * 1, + ], + result["out"], + ) def test_derivate_wrt_input_closed_loop(self): NeuObj.clearNames() - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") x_last = x.last() y_last = y.last() - p=Parameter('fir',sw=1,values=[[-0.5]]) + p = Parameter("fir", sw=1, values=[[-0.5]]) fun = Sin(x_last) + Fir(W=p)(x_last) + Cos(y_last) out_der = Differentiate(fun, x_last) + Differentiate(fun, y_last) out_der.closedLoop(x) - out = Output('out', out_der) + out = Output("out", out_der) m = Modely(visualizer=None) - m.addModel('model', [out]) + m.addModel("model", [out]) m.neuralizeModel() K = -0.5 @@ -1385,36 +2141,46 @@ def fun_data(x, y, K): x_data.append(x) y_data.append(y) - result = m({'x': [-0.2], 'y': [0.5]}, closed_loop={'y':'out'}, num_of_samples=10, prediction_samples=10) - self.TestAlmostEqual([a.tolist() for a in x_data[0:10]],result['out']) - - result = m({'x': [-0.2], 'y': [0.5]}, closed_loop={'y':'out'}, num_of_samples=10, prediction_samples='auto') - self.TestAlmostEqual([a.tolist() for a in x_data[0:10]],result['out']) + result = m( + {"x": [-0.2], "y": [0.5]}, + closed_loop={"y": "out"}, + num_of_samples=10, + prediction_samples=10, + ) + self.TestAlmostEqual([a.tolist() for a in x_data[0:10]], result["out"]) + + result = m( + {"x": [-0.2], "y": [0.5]}, + closed_loop={"y": "out"}, + num_of_samples=10, + prediction_samples="auto", + ) + self.TestAlmostEqual([a.tolist() for a in x_data[0:10]], result["out"]) def test_derivate_wrt_input_connect(self): NeuObj.clearNames() - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") x_last = x.last() y_last = y.last() - p1 = Parameter('p1', sw=1, values=[[-0.5]]) + p1 = Parameter("p1", sw=1, values=[[-0.5]]) fun = Sin(x_last) + Fir(W=p1)(x_last) + Cos(y_last) out_der = Differentiate(fun, x_last) + Differentiate(fun, y_last) - x2 = Input('x2') - y2 = Input('y2') + x2 = Input("x2") + y2 = Input("y2") x2_last = x2.last() y2_last = y2.last() - p2 = Parameter('p2', sw=1, values=[[3]]) + p2 = Parameter("p2", sw=1, values=[[3]]) fun2 = Sin(x2_last) + Fir(W=p2)(x2_last) + Cos(y2_last) out_der2 = Differentiate(fun2, x2_last) + Differentiate(fun2, y2_last) out_der.connect(x2) - out1 = Output('out1', out_der) - out2 = Output('out2', out_der2) + out1 = Output("out1", out_der) + out2 = Output("out2", out_der2) m = Modely(visualizer=None) - m.addModel('model', [out1,out2]) + m.addModel("model", [out1, out2]) m.neuralizeModel() K1 = -0.5 @@ -1424,89 +2190,150 @@ def fun_data(x, y, K): return K + np.cos(x) - np.sin(y) def fun_data2(x, y, K1, K2): - return K2 + np.cos(fun_data(x,y,K1)) - np.sin(fun_data(x,y,K1)) + return K2 + np.cos(fun_data(x, y, K1)) - np.sin(fun_data(x, y, K1)) x_data, y_data = [], [] x = [-0.2, 0, 0, 0, 0, 0, 0, 0, 0, 0] y = [0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0] - for (xi,yi) in zip(x,y): + for xi, yi in zip(x, y): r = fun_data2(xi, yi, K1, K2) x_data.append(r) y_data.append(r) - result = m({'x': [-0.2], 'y': [0.5]}, connect={'y2':'out1'}, num_of_samples=10, prediction_samples=10) - self.TestAlmostEqual([a.tolist() for a in x_data[0:10]],result['out2']) - - result = m({'x': [-0.2], 'y': [0.5]}, connect={'y2': 'out1'}, num_of_samples=10, prediction_samples='auto') - self.TestAlmostEqual([a.tolist() for a in x_data[0:10]], result['out2']) + result = m( + {"x": [-0.2], "y": [0.5]}, + connect={"y2": "out1"}, + num_of_samples=10, + prediction_samples=10, + ) + self.TestAlmostEqual([a.tolist() for a in x_data[0:10]], result["out2"]) + + result = m( + {"x": [-0.2], "y": [0.5]}, + connect={"y2": "out1"}, + num_of_samples=10, + prediction_samples="auto", + ) + self.TestAlmostEqual([a.tolist() for a in x_data[0:10]], result["out2"]) def test_inference_sampled_data(self): NeuObj.clearNames() - data_folder = os.path.join(os.path.dirname(__file__), 'get_samples_data/') + data_folder = os.path.join(os.path.dirname(__file__), "get_samples_data/") ## the state is saved inside the model so the memory is shared between different calls - x = Input('x') - y_state = Input('y') - x_p = Parameter('x_p', sw=2, dimensions=1, values=[[1.0],[1.0]]) - y_p = Parameter('y_p', sw=3, dimensions=1, values=[[2.0],[2.0],[2.0]]) + x = Input("x") + y_state = Input("y") + x_p = Parameter("x_p", sw=2, dimensions=1, values=[[1.0], [1.0]]) + y_p = Parameter("y_p", sw=3, dimensions=1, values=[[2.0], [2.0], [2.0]]) x_fir = Fir(W=x_p)(x.sw([-2, 0])) y_fir = Fir(W=y_p)(y_state.sw([0, 3])) y_fir.closedLoop(y_state) - out_x = Output('out_x', x_fir) - out_y = Output('out_y', y_fir) - out = Output('out',x_fir+y_fir) + out_x = Output("out_x", x_fir) + out_y = Output("out_y", y_fir) + out = Output("out", x_fir + y_fir) test = Modely(visualizer=None, seed=42) - test.addModel('out_all',[out, out_x, out_y]) + test.addModel("out_all", [out, out_x, out_y]) test.neuralizeModel(0.1) - data_struct = ['x','y'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) + data_struct = ["x", "y"] + test.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) ## Using vectorized data - result, logs = test(inputs={'x':[1,2,3,4,5,6], 'y':[1,2,3,4,5,6,7]}, prediction_samples=3, log_internal=True) - self.assertEqual(result['out_x'], [3.0, 5.0, 7.0, 9.0, 11.0]) - self.assertEqual(result['out_y'], [12.0, 34.0, 98.0, 288.0, 36.0]) - self.assertEqual(result['out'], [x+y for x, y in zip(result['out_x'], result['out_y'])]) - self.assertDictEqual(logs['ingress'][0], {'x': [[[1.0], [2.0]]], 'y': [[[1.0], [2.0], [3.0]]]}) - self.assertDictEqual(logs['ingress'][1], {'x': [[[2.0], [3.0]]], 'y': [[[2.0], [3.0], [12.0]]]}) - self.assertDictEqual(logs['ingress'][2], {'x': [[[3.0], [4.0]]], 'y': [[[3.0], [12.0], [34.0]]]}) - self.assertDictEqual(logs['ingress'][3], {'x': [[[4.0], [5.0]]], 'y': [[[12.0], [34.0], [98.0]]]}) - self.assertDictEqual(logs['ingress'][4], {'x': [[[5.0], [6.0]]], 'y': [[[5.0], [6.0], [7.0]]]}) - self.assertDictEqual(logs['closedLoop'][0], {'y': torch.tensor([[[12.]]])}) - self.assertDictEqual(logs['closedLoop'][1], {'y': torch.tensor([[[34.]]])}) - self.assertDictEqual(logs['closedLoop'][2], {'y': torch.tensor([[[98.]]])}) + result, logs = test( + inputs={"x": [1, 2, 3, 4, 5, 6], "y": [1, 2, 3, 4, 5, 6, 7]}, + prediction_samples=3, + log_internal=True, + ) + self.assertEqual(result["out_x"], [3.0, 5.0, 7.0, 9.0, 11.0]) + self.assertEqual(result["out_y"], [12.0, 34.0, 98.0, 288.0, 36.0]) + self.assertEqual( + result["out"], [x + y for x, y in zip(result["out_x"], result["out_y"])] + ) + self.assertDictEqual( + logs["ingress"][0], {"x": [[[1.0], [2.0]]], "y": [[[1.0], [2.0], [3.0]]]} + ) + self.assertDictEqual( + logs["ingress"][1], {"x": [[[2.0], [3.0]]], "y": [[[2.0], [3.0], [12.0]]]} + ) + self.assertDictEqual( + logs["ingress"][2], {"x": [[[3.0], [4.0]]], "y": [[[3.0], [12.0], [34.0]]]} + ) + self.assertDictEqual( + logs["ingress"][3], {"x": [[[4.0], [5.0]]], "y": [[[12.0], [34.0], [98.0]]]} + ) + self.assertDictEqual( + logs["ingress"][4], {"x": [[[5.0], [6.0]]], "y": [[[5.0], [6.0], [7.0]]]} + ) + self.assertDictEqual(logs["closedLoop"][0], {"y": torch.tensor([[[12.0]]])}) + self.assertDictEqual(logs["closedLoop"][1], {"y": torch.tensor([[[34.0]]])}) + self.assertDictEqual(logs["closedLoop"][2], {"y": torch.tensor([[[98.0]]])}) ## Using sampled data test.resetStates() - result, logs = test(inputs={'x':[[1,2],[2,3],[3,4],[4,5],[5,6]], 'y':[[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7]]}, sampled=True, prediction_samples=3, log_internal=True) - self.assertEqual(result['out_x'], [3.0, 5.0, 7.0, 9.0, 11.0]) - self.assertEqual(result['out_y'], [12.0, 34.0, 98.0, 288.0, 36.0]) - self.assertEqual(result['out'], [x+y for x, y in zip(result['out_x'], result['out_y'])]) - self.assertDictEqual(logs['ingress'][0], {'x': [[[1.0], [2.0]]], 'y': [[[1.0], [2.0], [3.0]]]}) - self.assertDictEqual(logs['ingress'][1], {'x': [[[2.0], [3.0]]], 'y': [[[2.0], [3.0], [12.0]]]}) - self.assertDictEqual(logs['ingress'][2], {'x': [[[3.0], [4.0]]], 'y': [[[3.0], [12.0], [34.0]]]}) - self.assertDictEqual(logs['ingress'][3], {'x': [[[4.0], [5.0]]], 'y': [[[12.0], [34.0], [98.0]]]}) - self.assertDictEqual(logs['ingress'][4], {'x': [[[5.0], [6.0]]], 'y': [[[5.0], [6.0], [7.0]]]}) - self.assertDictEqual(logs['closedLoop'][0], {'y': torch.tensor([[[12.]]])}) - self.assertDictEqual(logs['closedLoop'][1], {'y': torch.tensor([[[34.]]])}) - self.assertDictEqual(logs['closedLoop'][2], {'y': torch.tensor([[[98.]]])}) + result, logs = test( + inputs={ + "x": [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]], + "y": [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]], + }, + sampled=True, + prediction_samples=3, + log_internal=True, + ) + self.assertEqual(result["out_x"], [3.0, 5.0, 7.0, 9.0, 11.0]) + self.assertEqual(result["out_y"], [12.0, 34.0, 98.0, 288.0, 36.0]) + self.assertEqual( + result["out"], [x + y for x, y in zip(result["out_x"], result["out_y"])] + ) + self.assertDictEqual( + logs["ingress"][0], {"x": [[[1.0], [2.0]]], "y": [[[1.0], [2.0], [3.0]]]} + ) + self.assertDictEqual( + logs["ingress"][1], {"x": [[[2.0], [3.0]]], "y": [[[2.0], [3.0], [12.0]]]} + ) + self.assertDictEqual( + logs["ingress"][2], {"x": [[[3.0], [4.0]]], "y": [[[3.0], [12.0], [34.0]]]} + ) + self.assertDictEqual( + logs["ingress"][3], {"x": [[[4.0], [5.0]]], "y": [[[12.0], [34.0], [98.0]]]} + ) + self.assertDictEqual( + logs["ingress"][4], {"x": [[[5.0], [6.0]]], "y": [[[5.0], [6.0], [7.0]]]} + ) + self.assertDictEqual(logs["closedLoop"][0], {"y": torch.tensor([[[12.0]]])}) + self.assertDictEqual(logs["closedLoop"][1], {"y": torch.tensor([[[34.0]]])}) + self.assertDictEqual(logs["closedLoop"][2], {"y": torch.tensor([[[98.0]]])}) # ## Using get_sampled from a dataset test.resetStates() - inputs = test.getSamples('dataset', window=5) - result, logs = test(inputs=inputs, sampled=True, prediction_samples=3, log_internal=True) - self.assertEqual(result['out_x'], [3.0, 5.0, 7.0, 9.0, 11.0]) - self.assertEqual(result['out_y'], [12.0, 34.0, 98.0, 288.0, 36.0]) - self.assertEqual(result['out'], [x+y for x, y in zip(result['out_x'], result['out_y'])]) - self.assertDictEqual(logs['ingress'][0], {'x': [[[1.0], [2.0]]], 'y': [[[1.0], [2.0], [3.0]]]}) - self.assertDictEqual(logs['ingress'][1], {'x': [[[2.0], [3.0]]], 'y': [[[2.0], [3.0], [12.0]]]}) - self.assertDictEqual(logs['ingress'][2], {'x': [[[3.0], [4.0]]], 'y': [[[3.0], [12.0], [34.0]]]}) - self.assertDictEqual(logs['ingress'][3], {'x': [[[4.0], [5.0]]], 'y': [[[12.0], [34.0], [98.0]]]}) - self.assertDictEqual(logs['ingress'][4], {'x': [[[5.0], [6.0]]], 'y': [[[5.0], [6.0], [7.0]]]}) - self.assertDictEqual(logs['closedLoop'][0], {'y': torch.tensor([[[12.]]])}) - self.assertDictEqual(logs['closedLoop'][1], {'y': torch.tensor([[[34.]]])}) - self.assertDictEqual(logs['closedLoop'][2], {'y': torch.tensor([[[98.]]])}) - + inputs = test.getSamples("dataset", window=5) + result, logs = test( + inputs=inputs, sampled=True, prediction_samples=3, log_internal=True + ) + self.assertEqual(result["out_x"], [3.0, 5.0, 7.0, 9.0, 11.0]) + self.assertEqual(result["out_y"], [12.0, 34.0, 98.0, 288.0, 36.0]) + self.assertEqual( + result["out"], [x + y for x, y in zip(result["out_x"], result["out_y"])] + ) + self.assertDictEqual( + logs["ingress"][0], {"x": [[[1.0], [2.0]]], "y": [[[1.0], [2.0], [3.0]]]} + ) + self.assertDictEqual( + logs["ingress"][1], {"x": [[[2.0], [3.0]]], "y": [[[2.0], [3.0], [12.0]]]} + ) + self.assertDictEqual( + logs["ingress"][2], {"x": [[[3.0], [4.0]]], "y": [[[3.0], [12.0], [34.0]]]} + ) + self.assertDictEqual( + logs["ingress"][3], {"x": [[[4.0], [5.0]]], "y": [[[12.0], [34.0], [98.0]]]} + ) + self.assertDictEqual( + logs["ingress"][4], {"x": [[[5.0], [6.0]]], "y": [[[5.0], [6.0], [7.0]]]} + ) + self.assertDictEqual(logs["closedLoop"][0], {"y": torch.tensor([[[12.0]]])}) + self.assertDictEqual(logs["closedLoop"][1], {"y": torch.tensor([[[34.0]]])}) + self.assertDictEqual(logs["closedLoop"][2], {"y": torch.tensor([[[98.0]]])}) # def test_state_initialization_inference(self): # NeuObj.clearNames() @@ -1592,4 +2419,4 @@ def test_inference_sampled_data(self): # mass_dyn = Modely() # mass_dyn.addModel('', [mass_x, mass_y, mass_dx, mass_dy]) # mass_dyn.neuralizeModel(0.01) - # example = mass_dyn({'x0': [7], 'y0': [7], 'dx0': [5], 'dy0': [5], 'Fx': [100], 'Fy': [100]}, num_of_samples=200) \ No newline at end of file + # example = mass_dyn({'x0': [7], 'y0': [7], 'dx0': [5], 'dy0': [5], 'Fx': [100], 'Fy': [100]}, num_of_samples=200) diff --git a/tests/test_network_element.py b/tests/test_network_element.py index 150c5644..d9184e3c 100644 --- a/tests/test_network_element.py +++ b/tests/test_network_element.py @@ -1,4 +1,7 @@ -import unittest, sys, os, torch +import unittest +import sys +import os +import torch import numpy as np @@ -14,12 +17,17 @@ # 11 Tests # This file tests the dimensions and the of the element created in the pytorch environment -class ModelyNetworkBuildingTest(unittest.TestCase): +class ModelyNetworkBuildingTest(unittest.TestCase): def TestAlmostEqual(self, data1, data2, precision=4): - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2, dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) if type(data1) == type(data2) == list: - self.assertEqual(len(data1),len(data2)) + self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.TestAlmostEqual(pred, label, precision=precision) else: @@ -27,428 +35,648 @@ def TestAlmostEqual(self, data1, data2, precision=4): def test_network_building_very_simple(self): NeuObj.clearNames() - input1 = Input('in1').last() + input1 = Input("in1").last() rel1 = Fir(input1) - fun = Output('out', rel1) + fun = Output("out", rel1) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) list_of_dimensions = [[1, 1], [1, 1]] - for ind, (key, value) in enumerate({k: v for k, v in test._model.relation_forward.items() if 'Fir' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) - + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) + def test_network_building_simple(self): NeuObj.clearNames() Stream.resetCount() - input1 = Input('in1') + input1 = Input("in1") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw(0.01)) - fun = Output('out',rel1+rel2) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - - list_of_dimensions = {'Fir2':[5,1],'Fir5':[1,1]} - for key, value in {k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items(): - self.assertEqual(list_of_dimensions[key],list(value.weights.shape)) + + list_of_dimensions = {"Fir2": [5, 1], "Fir5": [1, 1]} + for key, value in { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items(): + self.assertEqual(list_of_dimensions[key], list(value.weights.shape)) def test_network_building_tw(self): NeuObj.clearNames() Stream.resetCount() - input1 = Input('in1') - input2 = Input('in2') + input1 = Input("in1") + input2 = Input("in2") rel1 = Fir(input1.tw(0.05)) rel2 = Fir(input1.tw(0.01)) rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.02,0.02])) - fun = Output('out',rel1+rel2+rel3+rel4) + rel4 = Fir(input2.tw([-0.02, 0.02])) + fun = Output("out", rel1 + rel2 + rel3 + rel4) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - - list_of_dimensions = {'Fir2':[5,1], 'Fir5':[1,1], 'Fir8':[5,1], 'Fir11':[4,1]} - for key, value in {k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items(): - self.assertEqual(list_of_dimensions[key],list(value.weights.shape)) - + + list_of_dimensions = { + "Fir2": [5, 1], + "Fir5": [1, 1], + "Fir8": [5, 1], + "Fir11": [4, 1], + } + for key, value in { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items(): + self.assertEqual(list_of_dimensions[key], list(value.weights.shape)) + def test_network_building_tw2(self): Stream.resetCount() NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.02,0.02])) - rel5 = Fir(input2.tw([-0.03,0.03])) + rel4 = Fir(input2.tw([-0.02, 0.02])) + rel5 = Fir(input2.tw([-0.03, 0.03])) rel6 = Fir(input2.tw([-0.03, 0])) rel7 = Fir(input2.tw(0.03)) - fun = Output('out',rel3+rel4+rel5+rel6+rel7) + fun = Output("out", rel3 + rel4 + rel5 + rel6 + rel7) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - self.assertEqual(test._max_n_samples, 8) # 5 samples + 3 samples of the horizon - self.assertEqual({'in2': 8} , test._input_n_samples) - - list_of_dimensions = {'Fir2':[5,1], 'Fir5':[4,1], 'Fir8':[6,1], 'Fir11':[3,1], 'Fir14':[3,1]} - for key, value in {k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items(): - self.assertEqual(list_of_dimensions[key],list(value.weights.shape)) + self.assertEqual(test._max_n_samples, 8) # 5 samples + 3 samples of the horizon + self.assertEqual({"in2": 8}, test._input_n_samples) + + list_of_dimensions = { + "Fir2": [5, 1], + "Fir5": [4, 1], + "Fir8": [6, 1], + "Fir11": [3, 1], + "Fir14": [3, 1], + } + for key, value in { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items(): + self.assertEqual(list_of_dimensions[key], list(value.weights.shape)) def test_network_building_tw3(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.01,0.03])) - rel5 = Fir(input2.tw([-0.04,0.01])) - fun = Output('out',rel3+rel4+rel5) + rel4 = Fir(input2.tw([-0.01, 0.03])) + rel5 = Fir(input2.tw([-0.04, 0.01])) + fun = Output("out", rel3 + rel4 + rel5) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = [[5,1], [4,1], [5,1]] - for ind, (key, value) in enumerate({k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) + list_of_dimensions = [[5, 1], [4, 1], [5, 1]] + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) def test_network_building_tw_with_offest(self): NeuObj.clearNames() Stream.resetCount() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.tw(0.05)) - rel4 = Fir(input2.tw([-0.04,0.02])) - rel5 = Fir(input2.tw([-0.04,0.02],offset=0)) - rel6 = Fir(input2.tw([-0.04,0.02],offset=0.01)) - fun = Output('out',rel3+rel4+rel5+rel6) - + rel4 = Fir(input2.tw([-0.04, 0.02])) + rel5 = Fir(input2.tw([-0.04, 0.02], offset=0)) + rel6 = Fir(input2.tw([-0.04, 0.02], offset=0.01)) + fun = Output("out", rel3 + rel4 + rel5 + rel6) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = {'Fir2':[5,1], 'Fir5':[6,1], 'Fir8':[6,1], 'Fir11':[6,1]} - for key, value in {k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items(): - self.assertEqual(list_of_dimensions[key],list(value.weights.shape)) + list_of_dimensions = { + "Fir2": [5, 1], + "Fir5": [6, 1], + "Fir8": [6, 1], + "Fir11": [6, 1], + } + for key, value in { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items(): + self.assertEqual(list_of_dimensions[key], list(value.weights.shape)) def test_network_building_tw_negative(self): NeuObj.clearNames() - input2 = Input('in2') - rel1 = Fir(input2.tw([-0.04,-0.01])) - rel2 = Fir(input2.tw([-0.06,-0.03])) - fun = Output('out',rel1+rel2) + input2 = Input("in2") + rel1 = Fir(input2.tw([-0.04, -0.01])) + rel2 = Fir(input2.tw([-0.06, -0.03])) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = [[3,1], [3,1]] - for ind, (key, value) in enumerate({k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) + list_of_dimensions = [[3, 1], [3, 1]] + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) def test_network_building_tw_positive(self): NeuObj.clearNames() - input2 = Input('in2') - rel1 = Fir(input2.tw([0.01,0.04])) - rel2 = Fir(input2.tw([0.03,0.06])) - fun = Output('out',rel1+rel2) + input2 = Input("in2") + rel1 = Fir(input2.tw([0.01, 0.04])) + rel2 = Fir(input2.tw([0.03, 0.06])) + fun = Output("out", rel1 + rel2) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = [[3,1], [3,1]] - for ind, (key, value) in enumerate({k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) + list_of_dimensions = [[3, 1], [3, 1]] + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) def test_network_building_sw_with_offset(self): Stream.resetCount() NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") rel3 = Fir(input2.sw(5)) - rel4 = Fir(input2.sw([-4,2])) - rel5 = Fir(input2.sw([-4,2],offset=0)) - rel6 = Fir(input2.sw([-4,2],offset=1)) - fun = Output('out',rel3+rel4+rel5+rel6) + rel4 = Fir(input2.sw([-4, 2])) + rel5 = Fir(input2.sw([-4, 2], offset=0)) + rel6 = Fir(input2.sw([-4, 2], offset=1)) + fun = Output("out", rel3 + rel4 + rel5 + rel6) test = Modely(visualizer=None, seed=1) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = {'Fir2':[5,1], 'Fir5':[6,1], 'Fir8':[6,1], 'Fir11':[6,1]} - for key, value in {k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items(): - self.assertEqual(list_of_dimensions[key],list(value.weights.shape)) + list_of_dimensions = { + "Fir2": [5, 1], + "Fir5": [6, 1], + "Fir8": [6, 1], + "Fir11": [6, 1], + } + for key, value in { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items(): + self.assertEqual(list_of_dimensions[key], list(value.weights.shape)) def test_network_building_sw_and_tw(self): NeuObj.clearNames() - input2 = Input('in2') + input2 = Input("in2") with self.assertRaises(TypeError): - input2.sw(5)+input2.tw(0.05) + input2.sw(5) + input2.tw(0.05) - rel1 = Fir(input2.sw([-4,2]))+Fir(input2.tw([-0.01,0])) - fun = Output('out',rel1) + rel1 = Fir(input2.sw([-4, 2])) + Fir(input2.tw([-0.01, 0])) + fun = Output("out", rel1) test = Modely(visualizer=None) - test.addModel('fun',fun) + test.addModel("fun", fun) test.neuralizeModel(0.01) - list_of_dimensions = [[6,1], [1,1]] - for ind, (key, value) in enumerate({k:v for k,v in test._model.relation_forward.items() if 'Fir' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) + list_of_dimensions = [[6, 1], [1, 1]] + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Fir" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) def test_network_linear(self): NeuObj.clearNames() - input = Input('in1') - rel1 = Linear(input.sw([-4,2])) + input = Input("in1") + rel1 = Linear(input.sw([-4, 2])) rel2 = Linear(5)(input.sw([-1, 2])) - fun1 = Output('out1',rel1) - fun2 = Output('out2', rel2) + fun1 = Output("out1", rel1) + fun2 = Output("out2", rel2) - input5 = Input('in5', dimensions=3) - rel15 = Linear(input5.sw([-4,2])) + input5 = Input("in5", dimensions=3) + rel15 = Linear(input5.sw([-4, 2])) rel25 = Linear(5)(input5.last()) - fun15 = Output('out51',rel15) - fun25 = Output('out52', rel25) + fun15 = Output("out51", rel15) + fun25 = Output("out52", rel25) - test = Modely(seed =1, visualizer=None) - test.addModel('fun',[fun1,fun2,fun15,fun25]) + test = Modely(seed=1, visualizer=None) + test.addModel("fun", [fun1, fun2, fun15, fun25]) test.neuralizeModel(0.01) - list_of_dimensions = [[1,1],[1,5],[3,1],[3,5]] - for ind, (key, value) in enumerate({k:v for k,v in test._model.relation_forward.items() if 'Linear' in k}.items()): - self.assertEqual(list_of_dimensions[ind],list(value.weights.shape)) + list_of_dimensions = [[1, 1], [1, 5], [3, 1], [3, 5]] + for ind, (key, value) in enumerate( + { + k: v for k, v in test._model.relation_forward.items() if "Linear" in k + }.items() + ): + self.assertEqual(list_of_dimensions[ind], list(value.weights.shape)) def test_network_linear_interpolation_train(self): NeuObj.clearNames() - x = Input('x') - param = Parameter(name='a', sw=1) - rel1 = Fir(W=param)(Interpolation(x_points=[1.0, 2.0, 3.0, 4.0],y_points=[2.0, 4.0, 6.0, 8.0], mode='linear')(x.last())) - out = Output('out',rel1) - - test = Modely(seed = 1, visualizer=None) - test.addModel('fun',[out]) - test.addMinimize('error', out, x.last()) + x = Input("x") + param = Parameter(name="a", sw=1) + rel1 = Fir(W=param)( + Interpolation( + x_points=[1.0, 2.0, 3.0, 4.0], + y_points=[2.0, 4.0, 6.0, 8.0], + mode="linear", + )(x.last()) + ) + out = Output("out", rel1) + + test = Modely(seed=1, visualizer=None) + test.addModel("fun", [out]) + test.addMinimize("error", out, x.last()) test.neuralizeModel(0.01) - dataset = {'x':np.random.uniform(1,4,100)} - test.loadData(name='dataset', source=dataset) + dataset = {"x": np.random.uniform(1, 4, 100)} + test.loadData(name="dataset", source=dataset) test.trainModel(num_of_epochs=100, train_batch_size=10) - self.assertAlmostEqual(test.parameters['a'][0][0], 0.5, places=2) + self.assertAlmostEqual(test.parameters["a"][0][0], 0.5, places=2) def test_network_linear_interpolation(self): NeuObj.clearNames() - x = Input('x') - rel1 = Interpolation(x_points=[1.0, 2.0, 3.0, 4.0],y_points=[1.0, 4.0, 9.0, 16.0], mode='linear')(x.last()) - out = Output('out',rel1) + x = Input("x") + rel1 = Interpolation( + x_points=[1.0, 2.0, 3.0, 4.0], y_points=[1.0, 4.0, 9.0, 16.0], mode="linear" + )(x.last()) + out = Output("out", rel1) - test = Modely(seed=1,visualizer=None) - test.addModel('fun',[out]) + test = Modely(seed=1, visualizer=None) + test.addModel("fun", [out]) test.neuralizeModel(0.01) - inference = test(inputs={'x':[1.5,2.5,3.5]}) - self.assertEqual(inference['out'],[2.5,6.5,12.5]) + inference = test(inputs={"x": [1.5, 2.5, 3.5]}) + self.assertEqual(inference["out"], [2.5, 6.5, 12.5]) - x1 = Input('x1') - rel1 = Interpolation(x_points=[1.0, 4.0, 3.0, 2.0],y_points=[1.0, 16.0, 9.0, 4.0], mode='linear')(x1.last()) - out = Output('out1',rel1) + x1 = Input("x1") + rel1 = Interpolation( + x_points=[1.0, 4.0, 3.0, 2.0], y_points=[1.0, 16.0, 9.0, 4.0], mode="linear" + )(x1.last()) + out = Output("out1", rel1) test = Modely(visualizer=None) - test.addModel('fun',[out]) + test.addModel("fun", [out]) test.neuralizeModel(0.01) - inference = test(inputs={'x1':[1.5,2.5,3.5]}) - self.assertEqual(inference['out1'],[2.5,6.5,12.5]) + inference = test(inputs={"x1": [1.5, 2.5, 3.5]}) + self.assertEqual(inference["out1"], [2.5, 6.5, 12.5]) def test_softmax_and_sigmoid(self): NeuObj.clearNames() - x = Input('x') - y = Input('y', dimensions=3) + x = Input("x") + y = Input("y", dimensions=3) softmax = Softmax(y.last()) sigmoid = Sigmoid(x.last()) - out = Output('softmax',softmax) - out2 = Output('sigmoid',sigmoid) + out = Output("softmax", softmax) + out2 = Output("sigmoid", sigmoid) test = Modely(visualizer=None) - test.addModel('model',[out,out2]) + test.addModel("model", [out, out2]) test.neuralizeModel(0.01) - inference = test(inputs={'x':[-1000.0, 0.0, 1000.0], 'y':[[-1.0,0.0,1.0],[-1000.0,0.0,1000.0],[1.0,2.0,3.0]]}) - self.assertEqual(inference['sigmoid'],[0.0, 0.5, 1.0]) - self.assertEqual(inference['softmax'],[[[0.09003057330846786, 0.2447284758090973, 0.6652409434318542]], - [[0.0, 0.0, 1.0]], - [[0.09003057330846786, 0.2447284758090973, 0.6652409434318542]]]) + inference = test( + inputs={ + "x": [-1000.0, 0.0, 1000.0], + "y": [[-1.0, 0.0, 1.0], [-1000.0, 0.0, 1000.0], [1.0, 2.0, 3.0]], + } + ) + self.assertEqual(inference["sigmoid"], [0.0, 0.5, 1.0]) + self.assertEqual( + inference["softmax"], + [ + [[0.09003057330846786, 0.2447284758090973, 0.6652409434318542]], + [[0.0, 0.0, 1.0]], + [[0.09003057330846786, 0.2447284758090973, 0.6652409434318542]], + ], + ) def test_sech_cosh_function(self): torch.manual_seed(1) - input = Input('in1') + input = Input("in1") sech_rel = Sech(input.last()) sech_rel_2 = Sech(input.sw(2)) cosh_rel = Cosh(input.last()) cosh_rel_2 = Cosh(input.sw(2)) - input5 = Input('in5', dimensions=5) + input5 = Input("in5", dimensions=5) sech_rel_5 = Sech(input5.last()) cosh_rel_5 = Cosh(input5.last()) - out1 = Output('sech_out_1', sech_rel) - out2 = Output('sech_out_2', sech_rel_2) - out3 = Output('sech_out_3', sech_rel_5) - out4 = Output('cosh_out_1', cosh_rel) - out5 = Output('cosh_out_2', cosh_rel_2) - out6 = Output('cosh_out_3', cosh_rel_5) + out1 = Output("sech_out_1", sech_rel) + out2 = Output("sech_out_2", sech_rel_2) + out3 = Output("sech_out_3", sech_rel_5) + out4 = Output("cosh_out_1", cosh_rel) + out5 = Output("cosh_out_2", cosh_rel_2) + out6 = Output("cosh_out_3", cosh_rel_5) test = Modely(visualizer=None) - test.addModel('model',[out1,out2,out3,out4,out5,out6]) + test.addModel("model", [out1, out2, out3, out4, out5, out6]) test.neuralizeModel(0.01) - result = test(inputs={'in1':[[3.0],[-2.0]], 'in5':[[4.0,1.0,0.0,-6.0,2.0]]}) - self.TestAlmostEqual([0.2658022344112396], result['sech_out_1']) - self.TestAlmostEqual([[0.0993279218673706, 0.2658022344112396]], result['sech_out_2']) - self.TestAlmostEqual([[[0.03661899268627167, 0.6480542421340942, 1.0, 0.004957473836839199, 0.2658022344112396]]], result['sech_out_3']) - self.TestAlmostEqual([3.762195587158203], result['cosh_out_1']) - self.TestAlmostEqual([[10.067662239074707, 3.762195587158203]], result['cosh_out_2']) - self.TestAlmostEqual([[[27.3082332611084, 1.5430806875228882, 1.0, 201.71563720703125, 3.762195587158203]]], result['cosh_out_3']) + result = test( + inputs={"in1": [[3.0], [-2.0]], "in5": [[4.0, 1.0, 0.0, -6.0, 2.0]]} + ) + self.TestAlmostEqual([0.2658022344112396], result["sech_out_1"]) + self.TestAlmostEqual( + [[0.0993279218673706, 0.2658022344112396]], result["sech_out_2"] + ) + self.TestAlmostEqual( + [ + [ + [ + 0.03661899268627167, + 0.6480542421340942, + 1.0, + 0.004957473836839199, + 0.2658022344112396, + ] + ] + ], + result["sech_out_3"], + ) + self.TestAlmostEqual([3.762195587158203], result["cosh_out_1"]) + self.TestAlmostEqual( + [[10.067662239074707, 3.762195587158203]], result["cosh_out_2"] + ) + self.TestAlmostEqual( + [ + [ + [ + 27.3082332611084, + 1.5430806875228882, + 1.0, + 201.71563720703125, + 3.762195587158203, + ] + ] + ], + result["cosh_out_3"], + ) def test_concatenate_time_concatenate(self): NeuObj.clearNames() - input = Input('in1') - input2 = Input('in2') - concatenate_rel = Concatenate(input.last(),input2.last()) - timeconcatenate_rel = TimeConcatenate(input.last(),input2.last()) - concatenate_tw_rel = Concatenate(input.tw(3),input2.tw(3)) - timeconcatenate_tw_rel = TimeConcatenate(input.tw(3),input2.tw(3)) - - input3 = Input('in3', dimensions=5) - input4 = Input('in4', dimensions=5) - - concatenate_rel_5 = Concatenate(input3.last(),input4.last()) - timeconcatenate_rel_5 = TimeConcatenate(input3.last(),input4.last()) - concatenate_tw_rel_5 = Concatenate(input3.tw(3),input4.tw(3)) - timeconcatenate_tw_rel_5 = TimeConcatenate(input3.tw(3),input4.tw(3)) - - out1 = Output('concatenate', concatenate_rel) - out2 = Output('time_concatenate', timeconcatenate_rel) - out3 = Output('concatenate_tw', concatenate_tw_rel) - out4 = Output('time_concatenate_tw', timeconcatenate_tw_rel) - out5 = Output('concatenate_5', concatenate_rel_5) - out6 = Output('time_concatenate_5', timeconcatenate_rel_5) - out7 = Output('concatenate_tw_5', concatenate_tw_rel_5) - out8 = Output('time_concatenate_tw_5', timeconcatenate_tw_rel_5) - - test = Modely(seed=1,visualizer=None) - test.addModel('model',[out1,out2,out3,out4,out5,out6,out7,out8]) + input = Input("in1") + input2 = Input("in2") + concatenate_rel = Concatenate(input.last(), input2.last()) + timeconcatenate_rel = TimeConcatenate(input.last(), input2.last()) + concatenate_tw_rel = Concatenate(input.tw(3), input2.tw(3)) + timeconcatenate_tw_rel = TimeConcatenate(input.tw(3), input2.tw(3)) + + input3 = Input("in3", dimensions=5) + input4 = Input("in4", dimensions=5) + + concatenate_rel_5 = Concatenate(input3.last(), input4.last()) + timeconcatenate_rel_5 = TimeConcatenate(input3.last(), input4.last()) + concatenate_tw_rel_5 = Concatenate(input3.tw(3), input4.tw(3)) + timeconcatenate_tw_rel_5 = TimeConcatenate(input3.tw(3), input4.tw(3)) + + out1 = Output("concatenate", concatenate_rel) + out2 = Output("time_concatenate", timeconcatenate_rel) + out3 = Output("concatenate_tw", concatenate_tw_rel) + out4 = Output("time_concatenate_tw", timeconcatenate_tw_rel) + out5 = Output("concatenate_5", concatenate_rel_5) + out6 = Output("time_concatenate_5", timeconcatenate_rel_5) + out7 = Output("concatenate_tw_5", concatenate_tw_rel_5) + out8 = Output("time_concatenate_tw_5", timeconcatenate_tw_rel_5) + + test = Modely(seed=1, visualizer=None) + test.addModel("model", [out1, out2, out3, out4, out5, out6, out7, out8]) test.neuralizeModel(1) - result = test(inputs={'in1':[[1.0],[2.0],[3.0]], 'in2':[[4.0],[5.0],[6.0]], - 'in3':[[7.0,8.0,9.0,10.0,11.0],[12.0,13.0,14.0,15.0,16.0],[17.0,18.0,19.0,20.0,21.0]], - 'in4':[[22.0,23.0,24.0,25.0,26.0],[27.0,28.0,29.0,30.0,31.0],[32.0,33.0,34.0,35.0,36.0]]}) - self.assertEqual((1,1,2), np.array(result['concatenate']).shape) - self.assertEqual([[[3.0, 6.0]]], result['concatenate']) - self.assertEqual((1,2), np.array(result['time_concatenate']).shape) - self.assertEqual([[3.0, 6.0]], result['time_concatenate']) - self.assertEqual((1,3,2), np.array(result['concatenate_tw']).shape) - self.assertEqual([[[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]], result['concatenate_tw']) - self.assertEqual((1,6), np.array(result['time_concatenate_tw']).shape) - self.assertEqual([[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]], result['time_concatenate_tw']) - self.assertEqual((1,1,10), np.array(result['concatenate_5']).shape) - self.assertEqual([[[17.0, 18.0, 19.0, 20.0, 21.0, 32.0, 33.0, 34.0, 35.0, 36.0]]], result['concatenate_5']) - self.assertEqual((1,2,5), np.array(result['time_concatenate_5']).shape) - self.assertEqual([[[17.0, 18.0, 19.0, 20.0, 21.0], [32.0, 33.0, 34.0, 35.0, 36.0]]], result['time_concatenate_5']) - self.assertEqual((1,3,10), np.array(result['concatenate_tw_5']).shape) - self.assertEqual([[[7.0, 8.0, 9.0, 10.0, 11.0, 22.0, 23.0, 24.0, 25.0, 26.0], - [12.0, 13.0, 14.0, 15.0, 16.0, 27.0, 28.0, 29.0, 30.0, 31.0], - [17.0, 18.0, 19.0, 20.0, 21.0, 32.0, 33.0, 34.0, 35.0, 36.0]]], result['concatenate_tw_5']) - self.assertEqual((1,6,5), np.array(result['time_concatenate_tw_5']).shape) - self.assertEqual([[[7.0, 8.0, 9.0, 10.0, 11.0], - [12.0, 13.0, 14.0, 15.0, 16.0], - [17.0, 18.0, 19.0, 20.0, 21.0], - [22.0, 23.0, 24.0, 25.0, 26.0], - [27.0, 28.0, 29.0, 30.0, 31.0], - [32.0, 33.0, 34.0, 35.0, 36.0]]], result['time_concatenate_tw_5']) + result = test( + inputs={ + "in1": [[1.0], [2.0], [3.0]], + "in2": [[4.0], [5.0], [6.0]], + "in3": [ + [7.0, 8.0, 9.0, 10.0, 11.0], + [12.0, 13.0, 14.0, 15.0, 16.0], + [17.0, 18.0, 19.0, 20.0, 21.0], + ], + "in4": [ + [22.0, 23.0, 24.0, 25.0, 26.0], + [27.0, 28.0, 29.0, 30.0, 31.0], + [32.0, 33.0, 34.0, 35.0, 36.0], + ], + } + ) + self.assertEqual((1, 1, 2), np.array(result["concatenate"]).shape) + self.assertEqual([[[3.0, 6.0]]], result["concatenate"]) + self.assertEqual((1, 2), np.array(result["time_concatenate"]).shape) + self.assertEqual([[3.0, 6.0]], result["time_concatenate"]) + self.assertEqual((1, 3, 2), np.array(result["concatenate_tw"]).shape) + self.assertEqual( + [[[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]], result["concatenate_tw"] + ) + self.assertEqual((1, 6), np.array(result["time_concatenate_tw"]).shape) + self.assertEqual( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]], result["time_concatenate_tw"] + ) + self.assertEqual((1, 1, 10), np.array(result["concatenate_5"]).shape) + self.assertEqual( + [[[17.0, 18.0, 19.0, 20.0, 21.0, 32.0, 33.0, 34.0, 35.0, 36.0]]], + result["concatenate_5"], + ) + self.assertEqual((1, 2, 5), np.array(result["time_concatenate_5"]).shape) + self.assertEqual( + [[[17.0, 18.0, 19.0, 20.0, 21.0], [32.0, 33.0, 34.0, 35.0, 36.0]]], + result["time_concatenate_5"], + ) + self.assertEqual((1, 3, 10), np.array(result["concatenate_tw_5"]).shape) + self.assertEqual( + [ + [ + [7.0, 8.0, 9.0, 10.0, 11.0, 22.0, 23.0, 24.0, 25.0, 26.0], + [12.0, 13.0, 14.0, 15.0, 16.0, 27.0, 28.0, 29.0, 30.0, 31.0], + [17.0, 18.0, 19.0, 20.0, 21.0, 32.0, 33.0, 34.0, 35.0, 36.0], + ] + ], + result["concatenate_tw_5"], + ) + self.assertEqual((1, 6, 5), np.array(result["time_concatenate_tw_5"]).shape) + self.assertEqual( + [ + [ + [7.0, 8.0, 9.0, 10.0, 11.0], + [12.0, 13.0, 14.0, 15.0, 16.0], + [17.0, 18.0, 19.0, 20.0, 21.0], + [22.0, 23.0, 24.0, 25.0, 26.0], + [27.0, 28.0, 29.0, 30.0, 31.0], + [32.0, 33.0, 34.0, 35.0, 36.0], + ] + ], + result["time_concatenate_tw_5"], + ) def test_equation_learner(self): NeuObj.clearNames() - x = Input('x') - F = Input('F') - - def myFun(p1,p2,k1,k2): - return k1*p1+k2*p2 - - K1 = Parameter('k1', dimensions = 1, sw = 1,values=[[2.0]]) - K2 = Parameter('k2', dimensions = 1, sw = 1,values=[[3.0]]) - parfun = ParamFun(myFun, parameters_and_constants=[K1,K2]) - parfun2 = ParamFun(myFun, parameters_and_constants=[K1,K2]) - parfun3 = ParamFun(myFun, parameters_and_constants=[K1,K2]) - fuzzi = Fuzzify(centers=[0,1,2,3]) - - linear_layer_in = Linear(output_dimension=3, W_init=init_constant, W_init_params={'value':0}, b_init=init_constant, b_init_params={'value':0}, b=False) - linear_layer_in_dim_2 = Linear(output_dimension=3, W_init=init_constant, W_init_params={'value':0}, b_init=init_constant, b_init_params={'value':0}, b=False) - linear_layer_out = Linear(output_dimension=1, W_init=init_constant, W_init_params={'value':1}, b_init=init_constant, b_init_params={'value':0}, b=False) - - equation_learner = EquationLearner(functions=[Tan, Sin, Cos], linear_in=linear_layer_in)(x.last()) - equation_learner_out = EquationLearner(functions=[Tan, Sin, Cos], linear_in=linear_layer_in, linear_out=linear_layer_out)(x.last()) - equation_learner_tw = EquationLearner(functions=[Tan, Sin, Cos], linear_in=linear_layer_in)(x.sw(2)) - equation_learner_multi_tw = EquationLearner(functions=[Tan, Sin, Cos], linear_in=linear_layer_in_dim_2)((x.sw(2),F.sw(2))) - - linear_layer_in_2 = Linear(output_dimension=5, W_init=init_constant, W_init_params={'value':1}) - linear_layer_in_2_dim_2 = Linear(output_dimension=5, W_init=init_constant, W_init_params={'value':1}) - - equation_learner_2 = EquationLearner(functions=[Add, Mul, Identity], linear_in=linear_layer_in_2)(x.last()) - equation_learner_2_tw = EquationLearner(functions=[Add, Mul, Identity], linear_in=linear_layer_in_2)(x.sw(2)) - equation_learner_2_multi_tw = EquationLearner(functions=[Add, Mul, Identity], linear_in=linear_layer_in_2_dim_2)((x.sw(2),F.sw(2))) - - linear_layer_in_3 = Linear(output_dimension=5, W_init=init_constant, W_init_params={'value':1}, b_init=init_constant, b_init_params={'value':0}, b=False) - linear_layer_in_3_dim_2 = Linear(output_dimension=5, W_init=init_constant, W_init_params={'value':1}, b_init=init_constant, b_init_params={'value':0}, b=False) - - equation_learner_3 = EquationLearner(functions=[parfun, Add, fuzzi], linear_in=linear_layer_in_3)(x.last()) - equation_learner_3_tw = EquationLearner(functions=[parfun2, Add, fuzzi], linear_in=linear_layer_in_3)(x.sw(2)) - equation_learner_3_multi_tw = EquationLearner(functions=[parfun3, Add, fuzzi], linear_in=linear_layer_in_3_dim_2)((x.sw(2),F.sw(2))) - - out = Output('el',equation_learner) - out2 = Output('el_out',equation_learner_out) - out3 = Output('el_tw',equation_learner_tw) - out4 = Output('el_multi_tw',equation_learner_multi_tw) - out5 = Output('el2',equation_learner_2) - out6 = Output('el2_tw',equation_learner_2_tw) - out7 = Output('el2_multi_tw',equation_learner_2_multi_tw) - out8 = Output('el3',equation_learner_3) - out9 = Output('el3_tw',equation_learner_3_tw) - out10 = Output('el3_multi_tw',equation_learner_3_multi_tw) + x = Input("x") + F = Input("F") + + def myFun(p1, p2, k1, k2): + return k1 * p1 + k2 * p2 + + K1 = Parameter("k1", dimensions=1, sw=1, values=[[2.0]]) + K2 = Parameter("k2", dimensions=1, sw=1, values=[[3.0]]) + parfun = ParamFun(myFun, parameters_and_constants=[K1, K2]) + parfun2 = ParamFun(myFun, parameters_and_constants=[K1, K2]) + parfun3 = ParamFun(myFun, parameters_and_constants=[K1, K2]) + fuzzi = Fuzzify(centers=[0, 1, 2, 3]) + + linear_layer_in = Linear( + output_dimension=3, + W_init=init_constant, + W_init_params={"value": 0}, + b_init=init_constant, + b_init_params={"value": 0}, + b=False, + ) + linear_layer_in_dim_2 = Linear( + output_dimension=3, + W_init=init_constant, + W_init_params={"value": 0}, + b_init=init_constant, + b_init_params={"value": 0}, + b=False, + ) + linear_layer_out = Linear( + output_dimension=1, + W_init=init_constant, + W_init_params={"value": 1}, + b_init=init_constant, + b_init_params={"value": 0}, + b=False, + ) + + equation_learner = EquationLearner( + functions=[Tan, Sin, Cos], linear_in=linear_layer_in + )(x.last()) + equation_learner_out = EquationLearner( + functions=[Tan, Sin, Cos], + linear_in=linear_layer_in, + linear_out=linear_layer_out, + )(x.last()) + equation_learner_tw = EquationLearner( + functions=[Tan, Sin, Cos], linear_in=linear_layer_in + )(x.sw(2)) + equation_learner_multi_tw = EquationLearner( + functions=[Tan, Sin, Cos], linear_in=linear_layer_in_dim_2 + )((x.sw(2), F.sw(2))) + + linear_layer_in_2 = Linear( + output_dimension=5, W_init=init_constant, W_init_params={"value": 1} + ) + linear_layer_in_2_dim_2 = Linear( + output_dimension=5, W_init=init_constant, W_init_params={"value": 1} + ) + + equation_learner_2 = EquationLearner( + functions=[Add, Mul, Identity], linear_in=linear_layer_in_2 + )(x.last()) + equation_learner_2_tw = EquationLearner( + functions=[Add, Mul, Identity], linear_in=linear_layer_in_2 + )(x.sw(2)) + equation_learner_2_multi_tw = EquationLearner( + functions=[Add, Mul, Identity], linear_in=linear_layer_in_2_dim_2 + )((x.sw(2), F.sw(2))) + + linear_layer_in_3 = Linear( + output_dimension=5, + W_init=init_constant, + W_init_params={"value": 1}, + b_init=init_constant, + b_init_params={"value": 0}, + b=False, + ) + linear_layer_in_3_dim_2 = Linear( + output_dimension=5, + W_init=init_constant, + W_init_params={"value": 1}, + b_init=init_constant, + b_init_params={"value": 0}, + b=False, + ) + + equation_learner_3 = EquationLearner( + functions=[parfun, Add, fuzzi], linear_in=linear_layer_in_3 + )(x.last()) + equation_learner_3_tw = EquationLearner( + functions=[parfun2, Add, fuzzi], linear_in=linear_layer_in_3 + )(x.sw(2)) + equation_learner_3_multi_tw = EquationLearner( + functions=[parfun3, Add, fuzzi], linear_in=linear_layer_in_3_dim_2 + )((x.sw(2), F.sw(2))) + + out = Output("el", equation_learner) + out2 = Output("el_out", equation_learner_out) + out3 = Output("el_tw", equation_learner_tw) + out4 = Output("el_multi_tw", equation_learner_multi_tw) + out5 = Output("el2", equation_learner_2) + out6 = Output("el2_tw", equation_learner_2_tw) + out7 = Output("el2_multi_tw", equation_learner_2_multi_tw) + out8 = Output("el3", equation_learner_3) + out9 = Output("el3_tw", equation_learner_3_tw) + out10 = Output("el3_multi_tw", equation_learner_3_multi_tw) example = Modely(visualizer=None) - example.addModel('model',[out,out2,out3,out4,out5,out6,out7,out8,out9,out10]) + example.addModel( + "model", [out, out2, out3, out4, out5, out6, out7, out8, out9, out10] + ) example.neuralizeModel() - result = example({'x':[[1.0],[2.0]], 'F':[[3.0],[4.0]]}) - self.assertEqual(result['el'], [[[0.0, 0.0, 1.0]]]) - self.assertEqual(result['el_out'], [1.0]) - self.assertEqual(result['el_tw'], [[[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]]) - self.assertEqual(result['el_multi_tw'], [[[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]]) - self.assertEqual(result['el2'], [[[4.0, 4.0, 2.0]]]) - self.assertEqual(result['el2_tw'], [[[2.0, 1.0, 1.0], [4.0, 4.0, 2.0]]]) - self.assertEqual(result['el2_multi_tw'], [[[8.0, 16.0, 4.0], [12.0, 36.0, 6.0]]]) - self.assertEqual(result['el3'], [[[10.0, 4.0, 0.0, 0.0, 1.0, 0.0]]]) - self.assertEqual(result['el3_tw'], [[[5.0, 2.0, 0.0, 1.0, 0.0, 0.0], [10.0, 4.0, 0.0, 0.0, 1.0, 0.0]]]) - self.assertEqual(result['el3_multi_tw'], [[[20.0, 8.0, 0.0, 0.0, 0.0, 1.0], [30.0, 12.0, 0.0, 0.0, 0.0, 1.0]]]) + result = example({"x": [[1.0], [2.0]], "F": [[3.0], [4.0]]}) + self.assertEqual(result["el"], [[[0.0, 0.0, 1.0]]]) + self.assertEqual(result["el_out"], [1.0]) + self.assertEqual(result["el_tw"], [[[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]]) + self.assertEqual(result["el_multi_tw"], [[[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]]) + self.assertEqual(result["el2"], [[[4.0, 4.0, 2.0]]]) + self.assertEqual(result["el2_tw"], [[[2.0, 1.0, 1.0], [4.0, 4.0, 2.0]]]) + self.assertEqual( + result["el2_multi_tw"], [[[8.0, 16.0, 4.0], [12.0, 36.0, 6.0]]] + ) + self.assertEqual(result["el3"], [[[10.0, 4.0, 0.0, 0.0, 1.0, 0.0]]]) + self.assertEqual( + result["el3_tw"], + [[[5.0, 2.0, 0.0, 1.0, 0.0, 0.0], [10.0, 4.0, 0.0, 0.0, 1.0, 0.0]]], + ) + self.assertEqual( + result["el3_multi_tw"], + [[[20.0, 8.0, 0.0, 0.0, 0.0, 1.0], [30.0, 12.0, 0.0, 0.0, 0.0, 1.0]]], + ) def test_localmodel(self): NeuObj.clearNames() - x = Input('x') - activationA = Fuzzify(2, [0, 1], functions='Triangular')(x.last()) + x = Input("x") + activationA = Fuzzify(2, [0, 1], functions="Triangular")(x.last()) loc = LocalModel(input_function=Fir())(x.tw(1), activationA) - out = Output('out', loc) - example = Modely(visualizer=None,seed=5) - example.addModel('out', out) + out = Output("out", loc) + example = Modely(visualizer=None, seed=5) + example.addModel("out", out) example.neuralizeModel(0.25) # The output is 2 samples - self.assertEqual({'out': [1.7170718908309937, 1.9410502910614014]}, example({'x': [-1, 0, 1, 2, 0]})) - self.assertEqual({'out': [1.7170718908309937, 1.9410502910614014]}, example({'x': [[-1, 0, 1, 2], [0, 1, 2, 0]]}, sampled=True)) + self.assertEqual( + {"out": [1.7170718908309937, 1.9410502910614014]}, + example({"x": [-1, 0, 1, 2, 0]}), + ) + self.assertEqual( + {"out": [1.7170718908309937, 1.9410502910614014]}, + example({"x": [[-1, 0, 1, 2], [0, 1, 2, 0]]}, sampled=True), + ) def test_arithmetic(self): NeuObj.clearNames() - y = Input('y', dimensions=10) + y = Input("y", dimensions=10) - k = Parameter('k', dimensions=1) + k = Parameter("k", dimensions=1) rel1 = y.last() + (5 * y.last()) rel2 = y.last() - (5 * y.last()) rel3 = y.last() + (k * y.last()) @@ -459,32 +687,32 @@ def test_arithmetic(self): rel8 = y.last() / (k * y.last()) rel9 = Sum(y.last()) - out = Output('out', rel1) - out2 = Output('out2', rel2) - out3 = Output('out3', rel3) - out4 = Output('out4', rel4) - out5 = Output('out5', rel5) - out6 = Output('out6', rel6) - out7 = Output('out7', rel7) - out8 = Output('out8', rel8) - out9 = Output('out9', rel9) + out = Output("out", rel1) + out2 = Output("out2", rel2) + out3 = Output("out3", rel3) + out4 = Output("out4", rel4) + out5 = Output("out5", rel5) + out6 = Output("out6", rel6) + out7 = Output("out7", rel7) + out8 = Output("out8", rel8) + out9 = Output("out9", rel9) example = Modely(visualizer=None, seed=42) - example.addModel('out', [out,out2,out3,out4,out5,out6,out7,out8,out9]) + example.addModel("out", [out, out2, out3, out4, out5, out6, out7, out8, out9]) example.neuralizeModel(0.25) - self.assertEqual(rel1.dim['dim'], 10) - self.assertEqual(rel2.dim['dim'], 10) - self.assertEqual(rel3.dim['dim'], 10) - self.assertEqual(rel4.dim['dim'], 10) - self.assertEqual(rel5.dim['dim'], 10) - self.assertEqual(rel6.dim['dim'], 10) - self.assertEqual(rel7.dim['dim'], 10) - self.assertEqual(rel8.dim['dim'], 10) - self.assertEqual(rel9.dim['dim'], 1) + self.assertEqual(rel1.dim["dim"], 10) + self.assertEqual(rel2.dim["dim"], 10) + self.assertEqual(rel3.dim["dim"], 10) + self.assertEqual(rel4.dim["dim"], 10) + self.assertEqual(rel5.dim["dim"], 10) + self.assertEqual(rel6.dim["dim"], 10) + self.assertEqual(rel7.dim["dim"], 10) + self.assertEqual(rel8.dim["dim"], 10) + self.assertEqual(rel9.dim["dim"], 1) def test_rungekutta(self): NeuObj.clearNames() - x = Input('x') + x = Input("x") def fun(x): return x @@ -493,24 +721,24 @@ def fun(x): rk2_rel = RK2(f=fun)(x.last()) rk4_rel = RK4(f=fun)(x.last()) - out_fe = Output('fe', fe_rel) - out_rk2 = Output('rk2', rk2_rel) - out_rk4 = Output('rk4', rk4_rel) + out_fe = Output("fe", fe_rel) + out_rk2 = Output("rk2", rk2_rel) + out_rk4 = Output("rk4", rk4_rel) model = Modely(visualizer=None) - model.addModel('model', [out_fe, out_rk2, out_rk4]) + model.addModel("model", [out_fe, out_rk2, out_rk4]) model.neuralizeModel(1) - inputs = {'x': [[1.0], [2.0]]} + inputs = {"x": [[1.0], [2.0]]} result = model(inputs=inputs) # expected: fe -> [2.0, 4.0], rk2 -> [2.5, 5.0] - self.TestAlmostEqual([2.0, 4.0], result['fe']) - self.TestAlmostEqual([2.5, 5.0], result['rk2']) - self.TestAlmostEqual([2.708333, 5.41666], result['rk4']) + self.TestAlmostEqual([2.0, 4.0], result["fe"]) + self.TestAlmostEqual([2.5, 5.0], result["rk2"]) + self.TestAlmostEqual([2.708333, 5.41666], result["rk4"]) # now test with step h = 0.1 model.neuralizeModel(0.1, clear_model=True) result = model(inputs=inputs) - self.TestAlmostEqual([1.1, 2.2], result['fe']) - self.TestAlmostEqual([1.105, 2.21], result['rk2']) - self.TestAlmostEqual([1.10517, 2.21034], result['rk4']) \ No newline at end of file + self.TestAlmostEqual([1.1, 2.2], result["fe"]) + self.TestAlmostEqual([1.105, 2.21], result["rk2"]) + self.TestAlmostEqual([1.10517, 2.21034], result["rk4"]) diff --git a/tests/test_parameters_of_train.py b/tests/test_parameters_of_train.py index ab73f05b..f99e2cf8 100644 --- a/tests/test_parameters_of_train.py +++ b/tests/test_parameters_of_train.py @@ -1,4 +1,6 @@ -import unittest, os, sys +import unittest +import os +import sys import numpy as np from nnodely import * @@ -13,239 +15,324 @@ # 13 Tests # Test the train parameter and the optimizer options -data_folder = os.path.join(os.path.dirname(__file__), 'data/') +data_folder = os.path.join(os.path.dirname(__file__), "data/") + def funIn(x, w): return x * w + def funOut(x, w): return x / w -def linear_fun(x,a,b): - return x*a+b + +def linear_fun(x, a, b): + return x * a + b + class ModelyTrainingTestParameter(unittest.TestCase): def test_network_mass_spring_damper(self): NeuObj.clearNames() - x = Input('x') # Position - F = Input('F') # Force + x = Input("x") # Position + F = Input("F") # Force # List the output of the model - x_z = Output('x_z', Fir(x.tw(0.3)) + Fir(F.last())) + x_z = Output("x_z", Fir(x.tw(0.3)) + Fir(F.last())) # Add the neural model to the nnodely structure and neuralization of the model test = Modely(visualizer=None) - test.addModel('x_z',x_z) - test.addMinimize('next-pos', x.z(-1), x_z, 'mse') + test.addModel("x_z", x_z) + test.addMinimize("next-pos", x.z(-1), x_z, "mse") # Create the neural network - test.neuralizeModel(sample_time=0.05) # The sampling time depends to the dataset + test.neuralizeModel( + sample_time=0.05 + ) # The sampling time depends to the dataset # Data load - data_struct = ['x','F','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.trainModel(splits=[80,10,10]) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.trainModel(splits=[80, 10, 10]) tp = test.getTrainingInfo() - self.assertEqual((15-6), test._num_of_samples['dataset']) - self.assertEqual(round((15-6)*80/100),tp['n_samples_train']) - self.assertEqual(round((15-6)*10/100),tp['n_samples_val']) - self.assertEqual(round((15-6)*10/100),tp['n_samples_test']) - self.assertEqual(round((15-6)*80/100),tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(1,tp['val_batch_size']) - self.assertEqual(100,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) + self.assertEqual((15 - 6), test._num_of_samples["dataset"]) + self.assertEqual(round((15 - 6) * 80 / 100), tp["n_samples_train"]) + self.assertEqual(round((15 - 6) * 10 / 100), tp["n_samples_val"]) + self.assertEqual(round((15 - 6) * 10 / 100), tp["n_samples_test"]) + self.assertEqual(round((15 - 6) * 80 / 100), tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(1, tp["val_batch_size"]) + self.assertEqual(100, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) def test_build_dataset_batch_connect(self): NeuObj.clearNames() data_x = np.random.rand(500) * 20 - 10 data_a = 2 data_b = -3 - dataset = {'in1': data_x, 'out': linear_fun(data_x, data_a, data_b)} + dataset = {"in1": data_x, "out": linear_fun(data_x, data_a, data_b)} - input1 = Input('in1') - out = Input('out') + input1 = Input("in1") + out = Input("out") rel1 = Fir(input1.tw(0.05)) - y = Output('y', rel1) + y = Output("y", rel1) test = Modely(visualizer=None, seed=42) - test.addModel('y',y) - test.addMinimize('pos', out.next(), y) + test.addModel("y", y) + test.addMinimize("pos", out.next(), y) test.neuralizeModel(0.01) - test.loadData(name='dataset',source=dataset) + test.loadData(name="dataset", source=dataset) training_params = {} - training_params['train_batch_size'] = 4 - training_params['val_batch_size'] = 4 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 - test.trainModel(splits=[70,20,10], closed_loop={'in1':'y'}, prediction_samples=5, training_params = training_params) + training_params["train_batch_size"] = 4 + training_params["val_batch_size"] = 4 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 + test.trainModel( + splits=[70, 20, 10], + closed_loop={"in1": "y"}, + prediction_samples=5, + training_params=training_params, + ) tp = test.getTrainingInfo() - self.assertEqual(346,tp['n_samples_train']) ## ((500 - 5) * 0.7) = 346 - self.assertEqual(99,tp['n_samples_val']) ## ((500 - 5) * 0.2) = 99 - self.assertEqual(50,tp['n_samples_test']) ## ((500 - 5) * 0.1) = 50 - self.assertEqual(495, test._num_of_samples['dataset']) ## 500 - 5 = 495 - self.assertEqual(4,tp['train_batch_size']) - self.assertEqual(4,tp['val_batch_size']) - self.assertEqual(5,tp['num_of_epochs']) - self.assertEqual(5, tp['prediction_samples']) - self.assertEqual(0, tp['step']) - self.assertEqual({'in1':'y'}, tp['closed_loop']) - self.assertEqual(0.1,tp['optimizer_defaults']['lr']) - self.assertEqual(((494*0.7)-tp['prediction_samples'])//4, tp['update_per_epochs']) - #self.assertEqual(1, tp['unused_samples']) + self.assertEqual(346, tp["n_samples_train"]) ## ((500 - 5) * 0.7) = 346 + self.assertEqual(99, tp["n_samples_val"]) ## ((500 - 5) * 0.2) = 99 + self.assertEqual(50, tp["n_samples_test"]) ## ((500 - 5) * 0.1) = 50 + self.assertEqual(495, test._num_of_samples["dataset"]) ## 500 - 5 = 495 + self.assertEqual(4, tp["train_batch_size"]) + self.assertEqual(4, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(5, tp["prediction_samples"]) + self.assertEqual(0, tp["step"]) + self.assertEqual({"in1": "y"}, tp["closed_loop"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual( + ((494 * 0.7) - tp["prediction_samples"]) // 4, tp["update_per_epochs"] + ) + # self.assertEqual(1, tp['unused_samples']) def test_recurrent_train_closed_loop(self): NeuObj.clearNames() data_x = np.random.rand(500) * 20 - 10 data_a = 2 data_b = -3 - dataset = {'in1': data_x, 'out': linear_fun(data_x, data_a, data_b)} + dataset = {"in1": data_x, "out": linear_fun(data_x, data_a, data_b)} - x = Input('in1') - p = Parameter('p', dimensions=1, sw=1, values=[[1.0]]) + x = Input("in1") + p = Parameter("p", dimensions=1, sw=1, values=[[1.0]]) fir = Fir(W=p)(x.last()) - out = Output('out', fir) + out = Output("out", fir) test = Modely(visualizer=None, seed=42) - test.addModel('out',out) - test.addMinimize('pos', x.next(), out) + test.addModel("out", out) + test.addMinimize("pos", x.next(), out) test.neuralizeModel(0.01) - test.loadData(name='dataset',source=dataset) + test.loadData(name="dataset", source=dataset) training_params = {} - training_params['train_batch_size'] = 4 - training_params['val_batch_size'] = 4 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 50 - - test.trainModel(splits=[100,0,0], closed_loop={'in1':'out'}, prediction_samples=3, step=1, training_params = training_params) + training_params["train_batch_size"] = 4 + training_params["val_batch_size"] = 4 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 50 + + test.trainModel( + splits=[100, 0, 0], + closed_loop={"in1": "out"}, + prediction_samples=3, + step=1, + training_params=training_params, + ) tp = test.getTrainingInfo() - self.assertEqual((len(data_x)-1)*100/100,tp['n_samples_train']) ## ((500 - 1) * 1) = 499 - self.assertEqual(0,tp['n_samples_val']) ## ((500 - 5) * 0) = 0 - self.assertEqual(0,tp['n_samples_test']) ## ((500 - 5) * 0) = 0 - self.assertEqual((len(data_x)-1) * 100 / 100, test._num_of_samples['dataset']) - self.assertEqual(4,tp['train_batch_size']) - self.assertEqual(4,tp['val_batch_size']) - self.assertEqual(50,tp['num_of_epochs']) - self.assertEqual(3, tp['prediction_samples']) - self.assertEqual(1, tp['step']) - self.assertEqual({'in1':'out'}, tp['closed_loop']) - self.assertEqual(0.1,tp['optimizer_defaults']['lr']) - - self.assertEqual(99, tp['update_per_epochs']) ## 499 // (4+1) = 99 - #self.assertEqual(100, tp['unused_samples']) ## 99 * step + 1 + self.assertEqual( + (len(data_x) - 1) * 100 / 100, tp["n_samples_train"] + ) ## ((500 - 1) * 1) = 499 + self.assertEqual(0, tp["n_samples_val"]) ## ((500 - 5) * 0) = 0 + self.assertEqual(0, tp["n_samples_test"]) ## ((500 - 5) * 0) = 0 + self.assertEqual((len(data_x) - 1) * 100 / 100, test._num_of_samples["dataset"]) + self.assertEqual(4, tp["train_batch_size"]) + self.assertEqual(4, tp["val_batch_size"]) + self.assertEqual(50, tp["num_of_epochs"]) + self.assertEqual(3, tp["prediction_samples"]) + self.assertEqual(1, tp["step"]) + self.assertEqual({"in1": "out"}, tp["closed_loop"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + + self.assertEqual(99, tp["update_per_epochs"]) ## 499 // (4+1) = 99 + # self.assertEqual(100, tp['unused_samples']) ## 99 * step + 1 def test_recurrent_train_single_close_loop(self): NeuObj.clearNames() data_x = np.array(list(range(1, 101, 1)), dtype=np.float32) - dataset = {'x': data_x, 'y': 2 * data_x} + dataset = {"x": data_x, "y": 2 * data_x} - x = Input('x') - y = Input('y') - out = Output('out', Fir(x.last())) + x = Input("x") + y = Input("y") + out = Output("out", Fir(x.last())) test = Modely(visualizer=None, seed=42) - test.addModel('out', out) - test.addMinimize('pos', y.last(), out) + test.addModel("out", out) + test.addMinimize("pos", y.last(), out) test.neuralizeModel(0.01) - test.loadData(name='dataset', source=dataset) + test.loadData(name="dataset", source=dataset) training_params = {} - training_params['train_batch_size'] = 4 - training_params['val_batch_size'] = 4 - training_params['lr'] = 0.01 - training_params['num_of_epochs'] = 50 - test.trainModel(splits=[80, 20, 0], closed_loop={'x': 'out'}, prediction_samples=3, step=2, training_params=training_params) + training_params["train_batch_size"] = 4 + training_params["val_batch_size"] = 4 + training_params["lr"] = 0.01 + training_params["num_of_epochs"] = 50 + test.trainModel( + splits=[80, 20, 0], + closed_loop={"x": "out"}, + prediction_samples=3, + step=2, + training_params=training_params, + ) tp = test.getTrainingInfo() - self.assertEqual(round((len(data_x) - 0) * 80 / 100), tp['n_samples_train']) - self.assertEqual((len(data_x) - 0) * 20 / 100, tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual((len(data_x) - 0) * 100 / 100, test._num_of_samples['dataset']) - self.assertEqual(4, tp['train_batch_size']) - self.assertEqual(4, tp['val_batch_size']) - self.assertEqual(50, tp['num_of_epochs']) - self.assertEqual(3, tp['prediction_samples']) - self.assertEqual(2, tp['step']) - self.assertEqual({'x': 'out'}, tp['closed_loop']) - self.assertEqual(0.01, tp['optimizer_defaults']['lr']) - self.assertEqual(((100*0.8)-3)//(4+2), tp['update_per_epochs']) - #self.assertEqual(100*0.8 - (tp['update_per_epochs']*4) - 3, tp['unused_samples']) + self.assertEqual(round((len(data_x) - 0) * 80 / 100), tp["n_samples_train"]) + self.assertEqual((len(data_x) - 0) * 20 / 100, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual((len(data_x) - 0) * 100 / 100, test._num_of_samples["dataset"]) + self.assertEqual(4, tp["train_batch_size"]) + self.assertEqual(4, tp["val_batch_size"]) + self.assertEqual(50, tp["num_of_epochs"]) + self.assertEqual(3, tp["prediction_samples"]) + self.assertEqual(2, tp["step"]) + self.assertEqual({"x": "out"}, tp["closed_loop"]) + self.assertEqual(0.01, tp["optimizer_defaults"]["lr"]) + self.assertEqual(((100 * 0.8) - 3) // (4 + 2), tp["update_per_epochs"]) + # self.assertEqual(100*0.8 - (tp['update_per_epochs']*4) - 3, tp['unused_samples']) def test_recurrent_train_multiple_close_loop(self): NeuObj.clearNames() data_x = np.array(list(range(1, 101, 1)), dtype=np.float32) - dataset = {'x': data_x, 'y': 2 * data_x} + dataset = {"x": data_x, "y": 2 * data_x} - x = Input('x') - y = Input('y') - out_x = Output('out_x', Fir(x.last())) - out_y = Output('out_y', Fir(y.last())) + x = Input("x") + y = Input("y") + out_x = Output("out_x", Fir(x.last())) + out_y = Output("out_y", Fir(y.last())) test = Modely(visualizer=None, seed=42) - test.addModel('out_x', out_x) - test.addModel('out_y', out_y) - test.addMinimize('pos_x', x.next(), out_x) - test.addMinimize('pos_y', y.next(), out_y) + test.addModel("out_x", out_x) + test.addModel("out_y", out_y) + test.addMinimize("pos_x", x.next(), out_x) + test.addMinimize("pos_y", y.next(), out_y) test.neuralizeModel(0.01) - test.loadData(name='dataset', source=dataset) + test.loadData(name="dataset", source=dataset) training_params = {} - training_params['train_batch_size'] = 4 - training_params['val_batch_size'] = 4 - training_params['lr'] = 0.01 - training_params['num_of_epochs'] = 32 - - test.trainModel(splits=[80, 20, 0], closed_loop={'x': 'out_x', 'y': 'out_y'}, prediction_samples=3, - training_params=training_params) + training_params["train_batch_size"] = 4 + training_params["val_batch_size"] = 4 + training_params["lr"] = 0.01 + training_params["num_of_epochs"] = 32 + + test.trainModel( + splits=[80, 20, 0], + closed_loop={"x": "out_x", "y": "out_y"}, + prediction_samples=3, + training_params=training_params, + ) tp = test.getTrainingInfo() - self.assertEqual(round((len(data_x) - 1) * 80 / 100), tp['n_samples_train']) - self.assertEqual(round((len(data_x) - 1) * 20 / 100), tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual((len(data_x) - 1) * 100 / 100, test._num_of_samples['dataset']) - self.assertEqual(4, tp['train_batch_size']) - self.assertEqual(4, tp['val_batch_size']) - self.assertEqual(32, tp['num_of_epochs']) - self.assertEqual(3, tp['prediction_samples']) - self.assertEqual(0, tp['step']) - self.assertEqual({'x': 'out_x', 'y': 'out_y'}, tp['closed_loop']) - self.assertEqual(0.01, tp['optimizer_defaults']['lr']) - self.assertEqual(19, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(round((len(data_x) - 1) * 80 / 100), tp["n_samples_train"]) + self.assertEqual(round((len(data_x) - 1) * 20 / 100), tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual((len(data_x) - 1) * 100 / 100, test._num_of_samples["dataset"]) + self.assertEqual(4, tp["train_batch_size"]) + self.assertEqual(4, tp["val_batch_size"]) + self.assertEqual(32, tp["num_of_epochs"]) + self.assertEqual(3, tp["prediction_samples"]) + self.assertEqual(0, tp["step"]) + self.assertEqual({"x": "out_x", "y": "out_y"}, tp["closed_loop"]) + self.assertEqual(0.01, tp["optimizer_defaults"]["lr"]) + self.assertEqual(19, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_build_dataset_batch(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') - rel1 = Output('out1',Fir(input1.tw(0.05))) + input1 = Input("in1") + output = Input("out") + rel1 = Output("out1", Fir(input1.tw(0.05))) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1) + test.addMinimize("out", output.z(-1), rel1) test.neuralizeModel(0.01) - data_struct = ['x','F','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,5,1), test._data['dataset']['in1'].shape) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) training_params = {} - training_params['train_batch_size'] = 1 - training_params['val_batch_size'] = 1 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 + training_params["train_batch_size"] = 1 + training_params["val_batch_size"] = 1 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 with self.assertRaises(RuntimeError): - test.trainModel(splits=[70,20,10],training_params = training_params) - test.addModel('out',rel1) + test.trainModel(splits=[70, 20, 10], training_params=training_params) + test.addModel("out", rel1) test.neuralizeModel(0.01) - test.trainModel(splits=[70,20,10],training_params = training_params) + test.trainModel(splits=[70, 20, 10], training_params=training_params) tp = test.getTrainingInfo() # 15 lines in the dataset @@ -254,47 +341,76 @@ def test_build_dataset_batch(self): # 10 / 1 * 0.2 = 2 for validation # 10 / 1 * 0.1 = 1 for test - self.assertEqual(7,tp['n_samples_train']) - self.assertEqual(2,tp['n_samples_val']) - self.assertEqual(1,tp['n_samples_test']) - self.assertEqual(10, test._num_of_samples['dataset']) - self.assertEqual(1,tp['train_batch_size']) - self.assertEqual(1,tp['val_batch_size']) - self.assertEqual(5,tp['num_of_epochs']) - self.assertEqual(0.1,tp['optimizer_defaults']['lr']) - - n_samples = tp['n_samples_train'] - batch_size = tp['train_batch_size'] + self.assertEqual(7, tp["n_samples_train"]) + self.assertEqual(2, tp["n_samples_val"]) + self.assertEqual(1, tp["n_samples_test"]) + self.assertEqual(10, test._num_of_samples["dataset"]) + self.assertEqual(1, tp["train_batch_size"]) + self.assertEqual(1, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + + n_samples = tp["n_samples_train"] + batch_size = tp["train_batch_size"] list_of_batch_indexes = range(0, n_samples - batch_size + 1, batch_size) - self.assertEqual(len(list_of_batch_indexes), tp['update_per_epochs']) - #self.assertEqual(n_samples - list_of_batch_indexes[-1] - batch_size, tp['unused_samples']) + self.assertEqual(len(list_of_batch_indexes), tp["update_per_epochs"]) + # self.assertEqual(n_samples - list_of_batch_indexes[-1] - batch_size, tp['unused_samples']) - test.trainModel(splits=[70, 20, 10], training_params=training_params, num_of_epochs=100) + test.trainModel( + splits=[70, 20, 10], training_params=training_params, num_of_epochs=100 + ) tp = test.getTrainingInfo() - self.assertEqual(100, tp['num_of_epochs']) + self.assertEqual(100, tp["num_of_epochs"]) def test_build_dataset_batch2(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') - rel1 = Output('out1',Fir(input1.tw(0.05))) + input1 = Input("in1") + output = Input("out") + rel1 = Output("out1", Fir(input1.tw(0.05))) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1) - test.addModel('model', rel1) + test.addMinimize("out", output.z(-1), rel1) + test.addModel("model", rel1) test.neuralizeModel(0.01) - data_struct = ['x','F','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset',source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10,5,1), test._data['dataset']['in1'].shape) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) training_params = {} - training_params['train_batch_size'] = 25 - training_params['val_batch_size'] = 25 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 - test.trainModel(splits=[50,0,50],training_params = training_params) + training_params["train_batch_size"] = 25 + training_params["val_batch_size"] = 25 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 + test.trainModel(splits=[50, 0, 50], training_params=training_params) tp = test.getTrainingInfo() # 15 lines in the dataset @@ -303,38 +419,64 @@ def test_build_dataset_batch2(self): # 10 / 1 * 0.5 = 5 for training # 10 / 1 * 0.0 = 0 for validation # 10 / 1 * 0.5 = 5 for test - self.assertEqual((15 - 5), test._num_of_samples['dataset']) - self.assertEqual(round((15 - 5) * 50 / 100), tp['n_samples_train']) - self.assertEqual(round((15 - 5) * 0 / 100), tp['n_samples_val']) - self.assertEqual(round((15 - 5) * 50 / 100), tp['n_samples_test']) - self.assertEqual(round((15 - 5) * 50 / 100), tp['train_batch_size']) - self.assertEqual(25, tp['val_batch_size']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual((15 - 5), test._num_of_samples["dataset"]) + self.assertEqual(round((15 - 5) * 50 / 100), tp["n_samples_train"]) + self.assertEqual(round((15 - 5) * 0 / 100), tp["n_samples_val"]) + self.assertEqual(round((15 - 5) * 50 / 100), tp["n_samples_test"]) + self.assertEqual(round((15 - 5) * 50 / 100), tp["train_batch_size"]) + self.assertEqual(25, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_build_dataset_batch3(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') - rel1 = Output('out1',Fir(input1.tw(0.05))) + input1 = Input("in1") + output = Input("out") + rel1 = Output("out1", Fir(input1.tw(0.05))) - test = Modely(workspace='results', visualizer=None) - test.addMinimize('out', output.next(), rel1) - test.addModel('model', rel1) + test = Modely(workspace="results", visualizer=None) + test.addMinimize("out", output.next(), rel1) + test.addModel("model", rel1) test.neuralizeModel(0.01) - data_struct = ['x', 'F', 'x2', 'y2', '', 'A1x', 'A1y', 'B1x', 'B1y', '', 'A2x', 'A2y', 'B2x', 'out', '', 'x3', - 'in1', 'in2', 'time'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10, 5, 1), test._data['dataset']['in1'].shape) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) training_params = {} - training_params['train_batch_size'] = 2 - training_params['val_batch_size'] = 2 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 + training_params["train_batch_size"] = 2 + training_params["val_batch_size"] = 2 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 test.trainModel(splits=[40, 30, 30], training_params=training_params) tp = test.getTrainingInfo() # 15 lines in the dataset @@ -345,38 +487,64 @@ def test_build_dataset_batch3(self): # 10 * 0.4 = 2 for training # 10 * 0.3 = 1 for validation # 10 * 0.3 = 1 for test - self.assertEqual((15 - 5), test._num_of_samples['dataset']) - self.assertEqual(round((15 - 5) * 40 / 100), tp['n_samples_train']) - self.assertEqual(round((15 - 5) * 30 / 100), tp['n_samples_val']) - self.assertEqual(round((15 - 5) * 30 / 100), tp['n_samples_test']) - self.assertEqual(2, tp['train_batch_size']) - self.assertEqual(2, tp['val_batch_size']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual(2, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual((15 - 5), test._num_of_samples["dataset"]) + self.assertEqual(round((15 - 5) * 40 / 100), tp["n_samples_train"]) + self.assertEqual(round((15 - 5) * 30 / 100), tp["n_samples_val"]) + self.assertEqual(round((15 - 5) * 30 / 100), tp["n_samples_test"]) + self.assertEqual(2, tp["train_batch_size"]) + self.assertEqual(2, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual(2, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_build_dataset_batch4(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') - rel1 = Output('out1',Fir(input1.tw(0.05))) + input1 = Input("in1") + output = Input("out") + rel1 = Output("out1", Fir(input1.tw(0.05))) test = Modely(visualizer=None) - test.addMinimize('out', output.z(-1), rel1) - test.addModel('model', rel1) + test.addMinimize("out", output.z(-1), rel1) + test.addModel("model", rel1) test.neuralizeModel(0.01) - data_struct = ['x', 'F', 'x2', 'y2', '', 'A1x', 'A1y', 'B1x', 'B1y', '', 'A2x', 'A2y', 'B2x', 'out', '', 'x3', - 'in1', 'in2', 'time'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - self.assertEqual((10, 5, 1), test._data['dataset']['in1'].shape) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + self.assertEqual((10, 5, 1), test._data["dataset"]["in1"].shape) training_params = {} - training_params['train_batch_size'] = 2 - training_params['val_batch_size'] = 2 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 + training_params["train_batch_size"] = 2 + training_params["val_batch_size"] = 2 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 test.trainModel(splits=[80, 10, 10], training_params=training_params) tp = test.getTrainingInfo() @@ -388,42 +556,44 @@ def test_build_dataset_batch4(self): # 10 * 0.8 = 8 for training # 10 * 0.1 = 1 for validation # 10 * 0.1 = 1 for test - self.assertEqual((15 - 5), test._num_of_samples['dataset']) - self.assertEqual(round((15 - 5) * 80 / 100), tp['n_samples_train']) - self.assertEqual(round((15 - 5) * 10 / 100), tp['n_samples_val']) - self.assertEqual(round((15 - 5) * 10 / 100), tp['n_samples_test']) - self.assertEqual(2, tp['train_batch_size']) - self.assertEqual(1, tp['val_batch_size']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual(4, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual((15 - 5), test._num_of_samples["dataset"]) + self.assertEqual(round((15 - 5) * 80 / 100), tp["n_samples_train"]) + self.assertEqual(round((15 - 5) * 10 / 100), tp["n_samples_val"]) + self.assertEqual(round((15 - 5) * 10 / 100), tp["n_samples_test"]) + self.assertEqual(2, tp["train_batch_size"]) + self.assertEqual(1, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual(4, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_build_dataset_from_code(self): NeuObj.clearNames() - input1 = Input('in1') - output = Input('out') - rel1 = Output('out1',Fir(input1.tw(0.05))) + input1 = Input("in1") + output = Input("out") + rel1 = Output("out1", Fir(input1.tw(0.05))) test = Modely(visualizer=None) - test.addMinimize('out', output.next(), rel1) - test.addModel('model', rel1) + test.addMinimize("out", output.next(), rel1) + test.addModel("model", rel1) test.neuralizeModel(0.01) x_size = 20 data_x = np.random.rand(x_size) * 20 - 10 data_a = 2 data_b = -3 - dataset = {'in1': data_x, 'out': data_x * data_a + data_b} + dataset = {"in1": data_x, "out": data_x * data_a + data_b} - test.loadData(name='dataset', source=dataset, skiplines=0) - self.assertEqual((15, 5, 1), test._data['dataset']['in1'].shape) ## 20 data - 5 tw = 15 sample | 0.05/0.01 = 5 in1 + test.loadData(name="dataset", source=dataset, skiplines=0) + self.assertEqual( + (15, 5, 1), test._data["dataset"]["in1"].shape + ) ## 20 data - 5 tw = 15 sample | 0.05/0.01 = 5 in1 training_params = {} - training_params['train_batch_size'] = 2 - training_params['val_batch_size'] = 2 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 + training_params["train_batch_size"] = 2 + training_params["val_batch_size"] = 2 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 test.trainModel(splits=[80, 20, 0], training_params=training_params) tp = test.getTrainingInfo() @@ -435,146 +605,200 @@ def test_build_dataset_from_code(self): # 15 * 0.8 = 12 for training # 15 * 0.2 = 3 for validation # 15 * 0.0 = 0 for test - self.assertEqual((20 - 5), test._num_of_samples['dataset']) - self.assertEqual(round((20 - 5) * 80 / 100), tp['n_samples_train']) - self.assertEqual(round((20 - 5) * 20 / 100), tp['n_samples_val']) - self.assertEqual(round((20 - 5) * 0 / 100), tp['n_samples_test']) - self.assertEqual(2, tp['train_batch_size']) - self.assertEqual(2, tp['val_batch_size']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual(6, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual((20 - 5), test._num_of_samples["dataset"]) + self.assertEqual(round((20 - 5) * 80 / 100), tp["n_samples_train"]) + self.assertEqual(round((20 - 5) * 20 / 100), tp["n_samples_val"]) + self.assertEqual(round((20 - 5) * 0 / 100), tp["n_samples_test"]) + self.assertEqual(2, tp["train_batch_size"]) + self.assertEqual(2, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual(6, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_network_multi_dataset(self): NeuObj.clearNames() - train_folder = os.path.join(os.path.dirname(__file__), 'data/') - val_folder = os.path.join(os.path.dirname(__file__), 'val_data/') - test_folder = os.path.join(os.path.dirname(__file__), 'test_data/') + train_folder = os.path.join(os.path.dirname(__file__), "data/") + val_folder = os.path.join(os.path.dirname(__file__), "val_data/") + test_folder = os.path.join(os.path.dirname(__file__), "test_data/") - x = Input('x') # Position - F = Input('F') # Force + x = Input("x") # Position + F = Input("F") # Force # List the output of the model - x_z = Output('x_z', Fir(x.tw(0.3)) + Fir(F.last())) + x_z = Output("x_z", Fir(x.tw(0.3)) + Fir(F.last())) # Add the neural model to the nnodely structure and neuralization of the model test = Modely(visualizer=None) - test.addModel('x_z', x_z) - test.addMinimize('next-pos', x.z(-1), x_z, 'mse') + test.addModel("x_z", x_z) + test.addMinimize("next-pos", x.z(-1), x_z, "mse") # Create the neural network - test.neuralizeModel(sample_time=0.05) # The sampling time depends to the dataset + test.neuralizeModel( + sample_time=0.05 + ) # The sampling time depends to the dataset # Data load - data_struct = ['x', 'F', 'x2', 'y2', '', 'A1x', 'A1y', 'B1x', 'B1y', '', 'A2x', 'A2y', 'B2x', 'out', '', 'x3', - 'in1', 'in2', 'time'] - test.loadData(name='train_dataset', source=train_folder, format=data_struct, skiplines=4, delimiter='\t', - header=None) - test.loadData(name='validation_dataset', source=val_folder, format=data_struct, skiplines=4, delimiter='\t', - header=None) - test.loadData(name='test_dataset', source=test_folder, format=data_struct, skiplines=4, delimiter='\t', - header=None) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="train_dataset", + source=train_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="validation_dataset", + source=val_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.loadData( + name="test_dataset", + source=test_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) training_params = {} - training_params['train_batch_size'] = 3 - training_params['val_batch_size'] = 2 - training_params['lr'] = 0.1 - training_params['num_of_epochs'] = 5 - #test.trainModel(train_dataset='train_dataset', validation_dataset='validation_dataset', test_dataset='test_dataset', training_params=training_params) - test.trainModel(train_dataset='train_dataset', validation_dataset='validation_dataset', training_params=training_params) + training_params["train_batch_size"] = 3 + training_params["val_batch_size"] = 2 + training_params["lr"] = 0.1 + training_params["num_of_epochs"] = 5 + # test.trainModel(train_dataset='train_dataset', validation_dataset='validation_dataset', test_dataset='test_dataset', training_params=training_params) + test.trainModel( + train_dataset="train_dataset", + validation_dataset="validation_dataset", + training_params=training_params, + ) tp = test.getTrainingInfo() - self.assertEqual(9, test._num_of_samples['train_dataset']) - self.assertEqual(5, test._num_of_samples['validation_dataset']) - #self.assertEqual(7, test._num_of_samples['test_dataset']) - self.assertEqual(9, tp['n_samples_train']) - self.assertEqual(5, tp['n_samples_val']) - self.assertEqual(3, tp['train_batch_size']) - self.assertEqual(2, tp['val_batch_size']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual(3, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(9, test._num_of_samples["train_dataset"]) + self.assertEqual(5, test._num_of_samples["validation_dataset"]) + # self.assertEqual(7, test._num_of_samples['test_dataset']) + self.assertEqual(9, tp["n_samples_train"]) + self.assertEqual(5, tp["n_samples_val"]) + self.assertEqual(3, tp["train_batch_size"]) + self.assertEqual(2, tp["val_batch_size"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual(3, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_train_vector_input(self): NeuObj.clearNames() - x = Input('x', dimensions=4) - y = Input('y', dimensions=3) - k = Input('k', dimensions=2) - w = Input('w') + x = Input("x", dimensions=4) + y = Input("y", dimensions=3) + k = Input("k", dimensions=2) + w = Input("w") - out = Output('out', Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) - out2 = Output('out2', Fir(Linear(k.last() + Fir(2)(w.tw(0.05, offset=-0.02))))) + out = Output("out", Fir(Linear(Linear(3)(x.tw(0.02)) + y.tw(0.02)))) + out2 = Output("out2", Fir(Linear(k.last() + Fir(2)(w.tw(0.05, offset=-0.02))))) test = Modely(visualizer=None) - test.addMinimize('out', out, out2) - test.addModel('model', out) + test.addMinimize("out", out, out2) + test.addModel("model", out) test.neuralizeModel(0.01) - data_folder = os.path.join(os.path.dirname(__file__), 'vector_data/') - data_struct = ['x', 'y', '', '', '', '', 'k', '', '', '', 'w'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1, delimiter='\t', header=None) + data_folder = os.path.join(os.path.dirname(__file__), "vector_data/") + data_struct = ["x", "y", "", "", "", "", "k", "", "", "", "w"] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=1, + delimiter="\t", + header=None, + ) training_params = {} - training_params['train_batch_size'] = 1 - training_params['val_batch_size'] = 1 - training_params['lr'] = 0.01 - training_params['num_of_epochs'] = 7 + training_params["train_batch_size"] = 1 + training_params["val_batch_size"] = 1 + training_params["lr"] = 0.01 + training_params["num_of_epochs"] = 7 test.trainModel(splits=[80, 10, 10], training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(22, test._num_of_samples['dataset']) - self.assertEqual(18, tp['n_samples_train']) - self.assertEqual(2, tp['n_samples_val']) - self.assertEqual(2, tp['n_samples_test']) - self.assertEqual(1, tp['train_batch_size']) - self.assertEqual(1, tp['val_batch_size']) - self.assertEqual(7, tp['num_of_epochs']) - self.assertEqual(0.01, tp['optimizer_defaults']['lr']) - self.assertEqual(18, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(22, test._num_of_samples["dataset"]) + self.assertEqual(18, tp["n_samples_train"]) + self.assertEqual(2, tp["n_samples_val"]) + self.assertEqual(2, tp["n_samples_test"]) + self.assertEqual(1, tp["train_batch_size"]) + self.assertEqual(1, tp["val_batch_size"]) + self.assertEqual(7, tp["num_of_epochs"]) + self.assertEqual(0.01, tp["optimizer_defaults"]["lr"]) + self.assertEqual(18, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) training_params = {} - training_params['train_batch_size'] = 6 - training_params['val_batch_size'] = 2 + training_params["train_batch_size"] = 6 + training_params["val_batch_size"] = 2 test.trainModel(splits=[80, 10, 10], training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(22, test._num_of_samples['dataset']) - self.assertEqual(18, tp['n_samples_train']) - self.assertEqual(2, tp['n_samples_val']) - self.assertEqual(2, tp['n_samples_test']) - self.assertEqual(6, tp['train_batch_size']) - self.assertEqual(2, tp['val_batch_size']) - self.assertEqual(100, tp['num_of_epochs']) - self.assertEqual(0.001, tp['optimizer_defaults']['lr']) - self.assertEqual(3, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(22, test._num_of_samples["dataset"]) + self.assertEqual(18, tp["n_samples_train"]) + self.assertEqual(2, tp["n_samples_val"]) + self.assertEqual(2, tp["n_samples_test"]) + self.assertEqual(6, tp["train_batch_size"]) + self.assertEqual(2, tp["val_batch_size"]) + self.assertEqual(100, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + self.assertEqual(3, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) def test_optimizer_configuration(self): NeuObj.clearNames() ## Model1 - input1 = Input('in1') - a = Parameter('a', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) - shared_w = Parameter('w', values=[[5]]) - output1 = Output('out1', - Fir(W=a)(input1.tw(0.05)) + ParamFun(funIn, parameters_and_constants={'w': shared_w})( - input1.last())) + input1 = Input("in1") + a = Parameter("a", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + shared_w = Parameter("w", values=[[5]]) + output1 = Output( + "out1", + Fir(W=a)(input1.tw(0.05)) + + ParamFun(funIn, parameters_and_constants={"w": shared_w})(input1.last()), + ) test = Modely(visualizer=None, seed=42) - test.addModel('model1', output1) - test.addMinimize('error1', input1.last(), output1) + test.addModel("model1", output1) + test.addMinimize("error1", input1.last(), output1) ## Model2 - input2 = Input('in2') - b = Parameter('b', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) - output2 = Output('out2', - Fir(W=b)(input2.tw(0.05)) + ParamFun(funOut, parameters_and_constants={'w': shared_w})( - input2.last())) - - test.addModel('model2', output2) - test.addMinimize('error2', input2.last(), output2) + input2 = Input("in2") + b = Parameter("b", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output2 = Output( + "out2", + Fir(W=b)(input2.tw(0.05)) + + ParamFun(funOut, parameters_and_constants={"w": shared_w})(input2.last()), + ) + + test.addModel("model2", output2) + test.addMinimize("error2", input2.last(), output2) test.neuralizeModel(0.01) # Dataset for train @@ -582,15 +806,25 @@ def test_optimizer_configuration(self): data_in2 = np.linspace(10, 15, 60) data_out1 = 2 data_out2 = -3 - dataset = {'in1': data_in1, 'in2': data_in2, 'out1': data_in1 * data_out1, 'out2': data_in2 * data_out2} - test.loadData(name='dataset1', source=dataset) + dataset = { + "in1": data_in1, + "in2": data_in2, + "out1": data_in1 * data_out1, + "out2": data_in2 * data_out2, + } + test.loadData(name="dataset1", source=dataset) data_in1 = np.linspace(0, 5, 100) data_in2 = np.linspace(10, 15, 100) data_out1 = 2 data_out2 = -3 - dataset = {'in1': data_in1, 'in2': data_in2, 'out1': data_in1 * data_out1, 'out2': data_in2 * data_out2} - test.loadData(name='dataset2', source=dataset) + dataset = { + "in1": data_in1, + "in2": data_in2, + "out1": data_in1 * data_out1, + "out2": data_in2 * data_out2, + } + test.loadData(name="dataset2", source=dataset) # Optimizer # Basic usage @@ -598,83 +832,93 @@ def test_optimizer_configuration(self): # We train all the models with split [100,0,0], lr =0.01 and epochs = 100 test.trainModel() tp = test.getTrainingInfo() - self.assertEqual(['model1', 'model2'], tp['models']) - self.assertEqual(152, tp['n_samples_train']) - self.assertEqual(0, tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual(100, tp['num_of_epochs']) - self.assertEqual(0.001, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(["model1", "model2"], tp["models"]) + self.assertEqual(152, tp["n_samples_train"]) + self.assertEqual(0, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(100, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) # We train only model1 with split [100,0,0] # TODO Learning rate automoatically optimized based on the mean and variance of the output # TODO num_of_epochs automatically defined # now is 0.001 for learning rate and 100 for the epochs and optimizer Adam - test.trainModel(models='model1', splits=[100, 0, 0]) + test.trainModel(models="model1", splits=[100, 0, 0]) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(100, tp['num_of_epochs']) - self.assertEqual(152, tp['n_samples_train']) - self.assertEqual(0, tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(100, tp["num_of_epochs"]) + self.assertEqual(152, tp["n_samples_train"]) + self.assertEqual(0, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) # Set number of epoch and learning rate via parameters it works only for standard parameters - test.trainModel(models='model1', splits=[100, 0, 0], lr=0.5, num_of_epochs=5) + test.trainModel(models="model1", splits=[100, 0, 0], lr=0.5, num_of_epochs=5) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(5, tp['num_of_epochs']) - self.assertEqual(152, tp['n_samples_train']) - self.assertEqual(0, tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual(0.5, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(5, tp["num_of_epochs"]) + self.assertEqual(152, tp["n_samples_train"]) + self.assertEqual(0, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(0.5, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) # Set number of epoch and learning rate via parameters it works only for standard parameters and use two different dataset one for train and one for validation - test.trainModel(models='model1', train_dataset='dataset1', validation_dataset='dataset2', lr=0.6, num_of_epochs=10) + test.trainModel( + models="model1", + train_dataset="dataset1", + validation_dataset="dataset2", + lr=0.6, + num_of_epochs=10, + ) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(10, tp['num_of_epochs']) - self.assertEqual(56, tp['n_samples_train']) - self.assertEqual(96, tp['n_samples_val']) - self.assertEqual(0, tp['n_samples_test']) - self.assertEqual(0.6,tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(10, tp["num_of_epochs"]) + self.assertEqual(56, tp["n_samples_train"]) + self.assertEqual(96, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(0.6, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) # Use dictionary for set number of epoch, learning rate, etc.. This configuration works only standard parameters (all the parameters that are input of the trainModel). training_params = { - 'models': ['model2'], - 'splits': [55, 40, 5], - 'num_of_epochs': 20, - 'lr': 0.7 + "models": ["model2"], + "splits": [55, 40, 5], + "num_of_epochs": 20, + "lr": 0.7, } test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(['model2'], tp['models']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.7, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model2"], tp["models"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.7, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) # If I add a function parameter it has the priority # In this case apply train parameter but on a different model - test.trainModel(models='model1', training_params=training_params) + test.trainModel(models="model1", training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.7, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.7, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) ################################## # Modify additional parameters in the optimizer that are not present in the standard parameter @@ -683,85 +927,102 @@ def test_optimizer_configuration(self): # max priority to the function parameter ('lr' : 0.2) # then the standard_optimizer_parameters ('lr' : 0.1) # finally the standard_train_parameters ('lr' : 0.5) - optimizer_defaults = { - 'lr': 0.1, - 'betas': (0.5, 0.99) - } - test.trainModel(training_params=training_params, optimizer_defaults=optimizer_defaults, lr=0.2) + optimizer_defaults = {"lr": 0.1, "betas": (0.5, 0.99)} + test.trainModel( + training_params=training_params, + optimizer_defaults=optimizer_defaults, + lr=0.2, + ) tp = test.getTrainingInfo() - self.assertEqual(['model2'], tp['models']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.2, tp['optimizer_defaults']['lr']) - self.assertEqual((0.5, 0.99), tp['optimizer_defaults']['betas']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - - test.trainModel(training_params=training_params, optimizer_defaults=optimizer_defaults) + self.assertEqual(["model2"], tp["models"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.2, tp["optimizer_defaults"]["lr"]) + self.assertEqual((0.5, 0.99), tp["optimizer_defaults"]["betas"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + + test.trainModel( + training_params=training_params, optimizer_defaults=optimizer_defaults + ) tp = test.getTrainingInfo() - self.assertEqual(['model2'], tp['models']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.1, tp['optimizer_defaults']['lr']) - self.assertEqual((0.5, 0.99), tp['optimizer_defaults']['betas']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model2"], tp["models"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.1, tp["optimizer_defaults"]["lr"]) + self.assertEqual((0.5, 0.99), tp["optimizer_defaults"]["betas"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(['model2'], tp['models']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.7, tp['optimizer_defaults']['lr']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model2"], tp["models"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.7, tp["optimizer_defaults"]["lr"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) ################################## # Modify the non standard args of the optimizer using the optimizer_defaults # In this case use the SGD with 0.2 of momentum - optimizer_defaults = { - 'momentum': 0.002 - } - test.trainModel(optimizer='SGD', training_params=training_params, optimizer_defaults=optimizer_defaults, lr=0.2) + optimizer_defaults = {"momentum": 0.002} + test.trainModel( + optimizer="SGD", + training_params=training_params, + optimizer_defaults=optimizer_defaults, + lr=0.2, + ) tp = test.getTrainingInfo() - self.assertEqual(['model2'], tp['models']) - self.assertEqual('SGD', tp['optimizer']) - self.assertEqual(20, tp['num_of_epochs']) - self.assertEqual(round(152 * 55 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 40 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.2, tp['optimizer_defaults']['lr']) - self.assertEqual(0.002, tp['optimizer_defaults']['momentum']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) + self.assertEqual(["model2"], tp["models"]) + self.assertEqual("SGD", tp["optimizer"]) + self.assertEqual(20, tp["num_of_epochs"]) + self.assertEqual(round(152 * 55 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 40 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.2, tp["optimizer_defaults"]["lr"]) + self.assertEqual(0.002, tp["optimizer_defaults"]["momentum"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) # Modify standard optimizer parameter for each training parameter training_params = { - 'models': ['model1'], - 'splits': [100, 0, 0], - 'num_of_epochs': 30, - 'lr': 0.5, - 'lr_param': {'a': 0.1} + "models": ["model1"], + "splits": [100, 0, 0], + "num_of_epochs": 30, + "lr": 0.5, + "lr_param": {"a": 0.1}, } test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(30, tp['num_of_epochs']) - self.assertEqual(round(152 * 100 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_val']) - self.assertEqual(152 - tp['n_samples_train'] - tp['n_samples_val'], tp['n_samples_test']) - self.assertEqual(0.5, tp['optimizer_defaults']['lr']) - self.assertEqual([{'lr': 0.1, 'params': 'a'}, - {'lr': 0.0, 'params': 'b'}, - {'params': 'w'}], tp['optimizer_params']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(30, tp["num_of_epochs"]) + self.assertEqual(round(152 * 100 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_val"]) + self.assertEqual( + 152 - tp["n_samples_train"] - tp["n_samples_val"], tp["n_samples_test"] + ) + self.assertEqual(0.5, tp["optimizer_defaults"]["lr"]) + self.assertEqual( + [{"lr": 0.1, "params": "a"}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) ################################## # Modify standard optimizer parameter for each training parameter using optimizer_params @@ -771,71 +1032,77 @@ def test_optimizer_configuration(self): # then the optimizer_params inside the train_parameters ( {'params':['a'],'lr':0.7} ) # finally the train_parameters ( 'lr_param'={'a': 0.1}) training_params = { - 'models': ['model1'], - 'splits': [100, 0, 0], - 'num_of_epochs': 40, - 'lr': 0.5, - 'lr_param': {'a': 0.1}, - 'optimizer_params': [{'params': ['a'], 'lr': 0.7}], - 'optimizer_defaults': {'lr': 0.12} - } - optimizer_params = [ - {'params': ['a'], 'lr': 0.6} - ] - optimizer_defaults = { - 'lr': 0.2 + "models": ["model1"], + "splits": [100, 0, 0], + "num_of_epochs": 40, + "lr": 0.5, + "lr_param": {"a": 0.1}, + "optimizer_params": [{"params": ["a"], "lr": 0.7}], + "optimizer_defaults": {"lr": 0.12}, } - test.trainModel(training_params=training_params, optimizer_params=optimizer_params, - optimizer_defaults=optimizer_defaults, lr_param={'a': 0.4}) + optimizer_params = [{"params": ["a"], "lr": 0.6}] + optimizer_defaults = {"lr": 0.2} + test.trainModel( + training_params=training_params, + optimizer_params=optimizer_params, + optimizer_defaults=optimizer_defaults, + lr_param={"a": 0.4}, + ) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual(40, tp['num_of_epochs']) - self.assertEqual(round(152 * 100 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_val']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_test']) - self.assertEqual(0.2, tp['optimizer_defaults']['lr']) - self.assertEqual([{'lr': 0.4, 'params': 'a'}], tp['optimizer_params']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) - - test.trainModel(training_params=training_params, optimizer_params=optimizer_params, - optimizer_defaults=optimizer_defaults) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual(40, tp["num_of_epochs"]) + self.assertEqual(round(152 * 100 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_val"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_test"]) + self.assertEqual(0.2, tp["optimizer_defaults"]["lr"]) + self.assertEqual([{"lr": 0.4, "params": "a"}], tp["optimizer_params"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) + + test.trainModel( + training_params=training_params, + optimizer_params=optimizer_params, + optimizer_defaults=optimizer_defaults, + ) tp = test.getTrainingInfo() - self.assertEqual(0.2, tp['optimizer_defaults']['lr']) - self.assertEqual([{'lr': 0.6, 'params': 'a'}], tp['optimizer_params']) + self.assertEqual(0.2, tp["optimizer_defaults"]["lr"]) + self.assertEqual([{"lr": 0.6, "params": "a"}], tp["optimizer_params"]) - test.trainModel(training_params=training_params, optimizer_params=optimizer_params) + test.trainModel( + training_params=training_params, optimizer_params=optimizer_params + ) tp = test.getTrainingInfo() - self.assertEqual(0.12, tp['optimizer_defaults']['lr']) - self.assertEqual([{'lr': 0.6, 'params': 'a'}], tp['optimizer_params']) + self.assertEqual(0.12, tp["optimizer_defaults"]["lr"]) + self.assertEqual([{"lr": 0.6, "params": "a"}], tp["optimizer_params"]) test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(0.12, tp['optimizer_defaults']['lr']) - self.assertEqual([{'params': 'a', 'lr': 0.7}], tp['optimizer_params']) + self.assertEqual(0.12, tp["optimizer_defaults"]["lr"]) + self.assertEqual([{"params": "a", "lr": 0.7}], tp["optimizer_params"]) - del training_params['optimizer_defaults'] + del training_params["optimizer_defaults"] test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(0.5, tp['optimizer_defaults']['lr']) - self.assertEqual([{'params': 'a', 'lr': 0.7}], tp['optimizer_params']) + self.assertEqual(0.5, tp["optimizer_defaults"]["lr"]) + self.assertEqual([{"params": "a", "lr": 0.7}], tp["optimizer_params"]) - del training_params['optimizer_params'] + del training_params["optimizer_params"] test.trainModel(training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual(0.5, tp['optimizer_defaults']['lr']) - self.assertEqual([{'lr': 0.1, 'params': 'a'}, - {'lr': 0.0, 'params': 'b'}, - {'params': 'w'}], tp['optimizer_params']) + self.assertEqual(0.5, tp["optimizer_defaults"]["lr"]) + self.assertEqual( + [{"lr": 0.1, "params": "a"}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) test.trainModel() tp = test.getTrainingInfo() - self.assertEqual(0.001, tp['optimizer_defaults']['lr']) - self.assertEqual([{'params': 'a'}, - {'params': 'b'}, - {'params': 'w'}], tp['optimizer_params']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + self.assertEqual( + [{"params": "a"}, {"params": "b"}, {"params": "w"}], tp["optimizer_params"] + ) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) ################################## @@ -848,65 +1115,82 @@ def test_optimizer_configuration(self): # finally the train_parameters ('lr'= 0.5) class RMSprop(Optimizer): def __init__(self, optimizer_defaults={}, optimizer_params=[]): - super(RMSprop, self).__init__('RMSprop', optimizer_defaults, optimizer_params) + super(RMSprop, self).__init__( + "RMSprop", optimizer_defaults, optimizer_params + ) def get_torch_optimizer(self): import torch - return torch.optim.RMSprop(self.replace_key_with_params(), **self.optimizer_defaults) + + return torch.optim.RMSprop( + self.replace_key_with_params(), **self.optimizer_defaults + ) training_params = { - 'models': ['model1'], - 'splits': [100, 0, 0], - 'num_of_epochs': 40, - 'lr': 0.5, - 'lr_param': {'a': 0.1}, - 'optimizer_params': [{'params': ['a'], 'lr': 0.7}], - 'optimizer_defaults': {'lr': 0.12} - } - optimizer_defaults = { - 'alpha': 0.8 + "models": ["model1"], + "splits": [100, 0, 0], + "num_of_epochs": 40, + "lr": 0.5, + "lr_param": {"a": 0.1}, + "optimizer_params": [{"params": ["a"], "lr": 0.7}], + "optimizer_defaults": {"lr": 0.12}, } + optimizer_defaults = {"alpha": 0.8} optimizer = RMSprop(optimizer_defaults) - test.trainModel(optimizer=optimizer, training_params=training_params, optimizer_defaults={'lr': 0.3}, lr=0.4) + test.trainModel( + optimizer=optimizer, + training_params=training_params, + optimizer_defaults={"lr": 0.3}, + lr=0.4, + ) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual('RMSprop', tp['optimizer']) - self.assertEqual(40, tp['num_of_epochs']) - self.assertEqual(round(152 * 100 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_val']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_test']) - self.assertEqual({'lr': 0.4}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.7, 'params': 'a'}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, optimizer_defaults={'lr': 0.1}) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual("RMSprop", tp["optimizer"]) + self.assertEqual(40, tp["num_of_epochs"]) + self.assertEqual(round(152 * 100 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_val"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_test"]) + self.assertEqual({"lr": 0.4}, tp["optimizer_defaults"]) + self.assertEqual([{"lr": 0.7, "params": "a"}], tp["optimizer_params"]) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + optimizer_defaults={"lr": 0.1}, + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.1}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.7, 'params': 'a'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.1}, tp["optimizer_defaults"]) + self.assertEqual([{"lr": 0.7, "params": "a"}], tp["optimizer_params"]) test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.12}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.7, 'params': 'a'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.12}, tp["optimizer_defaults"]) + self.assertEqual([{"lr": 0.7, "params": "a"}], tp["optimizer_params"]) - del training_params['optimizer_defaults'] + del training_params["optimizer_defaults"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.7, 'params': 'a'}], tp['optimizer_params']) + self.assertEqual({"alpha": 0.8, "lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual([{"lr": 0.7, "params": "a"}], tp["optimizer_params"]) - del training_params['optimizer_params'] + del training_params["optimizer_params"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.1, 'params': 'a'}, {'lr': 0.0, 'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"alpha": 0.8, "lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual( + [{"lr": 0.1, "params": "a"}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) test.trainModel(optimizer=optimizer) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.001}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a'}, {'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"alpha": 0.8, "lr": 0.001}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a"}, {"params": "b"}, {"params": "w"}], tp["optimizer_params"] + ) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) ################################## ################################## @@ -918,69 +1202,97 @@ def get_torch_optimizer(self): # then the train_parameters ( 'lr_param'={'a': 0.1} ) # finnaly the optimizer_paramsat the time of the optimizer initialization [{'params':['a'],'lr':0.6}] training_params = { - 'models': ['model1'], - 'splits': [100, 0, 0], - 'num_of_epochs': 40, - 'lr': 0.5, - 'lr_param': {'a': 0.1}, - 'optimizer_params': [{'params': ['a'], 'lr': 0.7}], - 'optimizer_defaults': {'lr': 0.12} - } - optimizer_defaults = { - 'alpha': 0.8 + "models": ["model1"], + "splits": [100, 0, 0], + "num_of_epochs": 40, + "lr": 0.5, + "lr_param": {"a": 0.1}, + "optimizer_params": [{"params": ["a"], "lr": 0.7}], + "optimizer_defaults": {"lr": 0.12}, } + optimizer_defaults = {"alpha": 0.8} optimizer_params = [ - {'params': ['a'], 'lr': 0.6}, {'params': 'w', 'lr': 0.12, 'alpha': 0.02} + {"params": ["a"], "lr": 0.6}, + {"params": "w", "lr": 0.12, "alpha": 0.02}, ] optimizer = RMSprop(optimizer_defaults, optimizer_params) - test.trainModel(optimizer=optimizer, training_params=training_params, optimizer_defaults={'lr': 0.3}, - optimizer_params=[{'params': ['a'], 'lr': 1.0}, {'params': ['b'], 'lr': 1.2}], - lr_param={'a': 0.2}) + test.trainModel( + optimizer=optimizer, + training_params=training_params, + optimizer_defaults={"lr": 0.3}, + optimizer_params=[ + {"params": ["a"], "lr": 1.0}, + {"params": ["b"], "lr": 1.2}, + ], + lr_param={"a": 0.2}, + ) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual('RMSprop', tp['optimizer']) - self.assertEqual(40, tp['num_of_epochs']) - self.assertEqual(round(152 * 100 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_val']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_test']) - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.2}, {'params': 'b', 'lr': 1.2}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, optimizer_defaults={'lr': 0.3}, - optimizer_params=[{'params': ['a'], 'lr': 0.1}, {'params': ['b'], 'lr': 0.2}]) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual("RMSprop", tp["optimizer"]) + self.assertEqual(40, tp["num_of_epochs"]) + self.assertEqual(round(152 * 100 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_val"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_test"]) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.2}, {"params": "b", "lr": 1.2}], + tp["optimizer_params"], + ) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + optimizer_defaults={"lr": 0.3}, + optimizer_params=[ + {"params": ["a"], "lr": 0.1}, + {"params": ["b"], "lr": 0.2}, + ], + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.1}, {'params': 'b', 'lr': 0.2}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, optimizer_defaults={'lr': 0.3}) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.1}, {"params": "b", "lr": 0.2}], + tp["optimizer_params"], + ) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + optimizer_defaults={"lr": 0.3}, + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}], tp['optimizer_params']) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual([{"params": "a", "lr": 0.7}], tp["optimizer_params"]) test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.12}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}], tp['optimizer_params']) + self.assertEqual({"lr": 0.12}, tp["optimizer_defaults"]) + self.assertEqual([{"params": "a", "lr": 0.7}], tp["optimizer_params"]) - del training_params['optimizer_defaults'] + del training_params["optimizer_defaults"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}], tp['optimizer_params']) + self.assertEqual({"alpha": 0.8, "lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual([{"params": "a", "lr": 0.7}], tp["optimizer_params"]) - del training_params['optimizer_params'] + del training_params["optimizer_params"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.1, 'params': 'a'}, {'alpha': 0.02, 'lr': 0.12, 'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"alpha": 0.8, "lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual( + [{"lr": 0.1, "params": "a"}, {"alpha": 0.02, "lr": 0.12, "params": "w"}], + tp["optimizer_params"], + ) test.trainModel(optimizer=optimizer) tp = test.getTrainingInfo() - self.assertEqual({'alpha': 0.8, 'lr': 0.001}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.6}, {'params': 'w', 'lr': 0.12, 'alpha': 0.02}], - tp['optimizer_params']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual({"alpha": 0.8, "lr": 0.001}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.6}, {"params": "w", "lr": 0.12, "alpha": 0.02}], + tp["optimizer_params"], + ) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) ################################## ################################## @@ -992,122 +1304,252 @@ def get_torch_optimizer(self): # then the train_parameters ( 'lr_param'={'a': 0.1} ) # The other parameters are the defaults training_params = { - 'models': ['model1'], - 'splits': [100, 0, 0], - 'num_of_epochs': 40, - 'lr': 0.5, - 'lr_param': {'a': 0.1}, - 'add_optimizer_params': [{'params': ['a'], 'lr': 0.7}], - 'add_optimizer_defaults': {'lr': 0.12} + "models": ["model1"], + "splits": [100, 0, 0], + "num_of_epochs": 40, + "lr": 0.5, + "lr_param": {"a": 0.1}, + "add_optimizer_params": [{"params": ["a"], "lr": 0.7}], + "add_optimizer_defaults": {"lr": 0.12}, } optimizer = RMSprop() - test.trainModel(optimizer=optimizer, training_params=training_params, add_optimizer_defaults={'lr': 0.3}, - add_optimizer_params=[{'params': ['a'], 'lr': 1.0}, {'params': ['b'], 'lr': 1.2}], - lr_param={'a': 0.2}) + test.trainModel( + optimizer=optimizer, + training_params=training_params, + add_optimizer_defaults={"lr": 0.3}, + add_optimizer_params=[ + {"params": ["a"], "lr": 1.0}, + {"params": ["b"], "lr": 1.2}, + ], + lr_param={"a": 0.2}, + ) tp = test.getTrainingInfo() - self.assertEqual(['model1'], tp['models']) - self.assertEqual('RMSprop', tp['optimizer']) - self.assertEqual(40, tp['num_of_epochs']) - self.assertEqual(round(152 * 100 / 100), tp['n_samples_train']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_val']) - self.assertEqual(round(152 * 0 / 100), tp['n_samples_test']) - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.2}, {'params': 'b', 'lr': 1.2}, {'params': 'w'}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, add_optimizer_defaults={'lr': 0.3}, - add_optimizer_params=[{'params': ['a'], 'lr': 0.23}, {'params': ['b'], 'lr': 0.2}]) + self.assertEqual(["model1"], tp["models"]) + self.assertEqual("RMSprop", tp["optimizer"]) + self.assertEqual(40, tp["num_of_epochs"]) + self.assertEqual(round(152 * 100 / 100), tp["n_samples_train"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_val"]) + self.assertEqual(round(152 * 0 / 100), tp["n_samples_test"]) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.2}, {"params": "b", "lr": 1.2}, {"params": "w"}], + tp["optimizer_params"], + ) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + add_optimizer_defaults={"lr": 0.3}, + add_optimizer_params=[ + {"params": ["a"], "lr": 0.23}, + {"params": ["b"], "lr": 0.2}, + ], + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.23}, {'params': 'b', 'lr': 0.2}, {'params': 'w'}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, add_optimizer_defaults={'lr': 0.3}, - add_optimizer_params=[{'params': ['b'], 'lr': 0.2}]) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.23}, {"params": "b", "lr": 0.2}, {"params": "w"}], + tp["optimizer_params"], + ) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + add_optimizer_defaults={"lr": 0.3}, + add_optimizer_params=[{"params": ["b"], "lr": 0.2}], + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.1}, {'params': 'b', 'lr': 0.2}, {'params': 'w'}], tp['optimizer_params']) - - test.trainModel(optimizer=optimizer, training_params=training_params, add_optimizer_defaults={'lr': 0.3}) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.1}, {"params": "b", "lr": 0.2}, {"params": "w"}], + tp["optimizer_params"], + ) + + test.trainModel( + optimizer=optimizer, + training_params=training_params, + add_optimizer_defaults={"lr": 0.3}, + ) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.3}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}, {'lr': 0.0, 'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.3}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.7}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.12}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}, {'lr': 0.0, 'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.12}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.7}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) - del training_params['add_optimizer_defaults'] + del training_params["add_optimizer_defaults"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a', 'lr': 0.7}, {'lr': 0.0, 'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a", "lr": 0.7}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) - del training_params['add_optimizer_params'] + del training_params["add_optimizer_params"] test.trainModel(optimizer=optimizer, training_params=training_params) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.5}, tp['optimizer_defaults']) - self.assertEqual([{'lr': 0.1, 'params': 'a'}, {'lr': 0.0, 'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.5}, tp["optimizer_defaults"]) + self.assertEqual( + [{"lr": 0.1, "params": "a"}, {"lr": 0.0, "params": "b"}, {"params": "w"}], + tp["optimizer_params"], + ) test.trainModel(optimizer=optimizer) tp = test.getTrainingInfo() - self.assertEqual({'lr': 0.001}, tp['optimizer_defaults']) - self.assertEqual([{'params': 'a'}, {'params': 'b'}, {'params': 'w'}], tp['optimizer_params']) + self.assertEqual({"lr": 0.001}, tp["optimizer_defaults"]) + self.assertEqual( + [{"params": "a"}, {"params": "b"}, {"params": "w"}], tp["optimizer_params"] + ) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(24, tp['unused_samples']) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(24, tp['unused_samples']) def test_train_sampled_datasets(self): NeuObj.clearNames() - x = Input('x') # Position - F = Input('F') # Force + x = Input("x") # Position + F = Input("F") # Force # List the output of the model - x_z = Output('x_z', Fir(x.tw(0.3)) + Fir(F.last())) + x_z = Output("x_z", Fir(x.tw(0.3)) + Fir(F.last())) # Add the neural model to the nnodely structure and neuralization of the model test = Modely(visualizer=None) - test.addModel('x_z',x_z) - test.addMinimize('next-pos', x.z(-1), x_z, 'mse') + test.addModel("x_z", x_z) + test.addMinimize("next-pos", x.z(-1), x_z, "mse") # Create the neural network - test.neuralizeModel(sample_time=0.05) # The sampling time depends to the dataset + test.neuralizeModel( + sample_time=0.05 + ) # The sampling time depends to the dataset # Data load - data_struct = ['x','F','x2','y2','','A1x','A1y','B1x','B1y','','A2x','A2y','B2x','out','','x3','in1','in2','time'] - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=4, delimiter='\t', header=None) - test.trainModel(train_dataset='dataset', num_of_epochs=3) + data_struct = [ + "x", + "F", + "x2", + "y2", + "", + "A1x", + "A1y", + "B1x", + "B1y", + "", + "A2x", + "A2y", + "B2x", + "out", + "", + "x3", + "in1", + "in2", + "time", + ] + test.loadData( + name="dataset", + source=data_folder, + format=data_struct, + skiplines=4, + delimiter="\t", + header=None, + ) + test.trainModel(train_dataset="dataset", num_of_epochs=3) tp = test.getTrainingInfo() - self.assertEqual((15-6), test._num_of_samples['dataset']) - self.assertEqual(round(15-6),tp['n_samples_train']) - self.assertEqual(round(0),tp['n_samples_val']) - self.assertEqual(round(0),tp['n_samples_test']) - self.assertEqual(round(15-6),tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(128,tp['val_batch_size']) - self.assertEqual(3,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) + self.assertEqual((15 - 6), test._num_of_samples["dataset"]) + self.assertEqual(round(15 - 6), tp["n_samples_train"]) + self.assertEqual(round(0), tp["n_samples_val"]) + self.assertEqual(round(0), tp["n_samples_test"]) + self.assertEqual(round(15 - 6), tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(128, tp["val_batch_size"]) + self.assertEqual(3, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) ## Passing a sampled dataset import torch - train_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080]], - [[0.8080],[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150]], - [[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150],[0.8160]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]],[[0.8190]],[[0.8180]],[[0.8160]],[[0.8140]],[[0.8130]]])} - ## Not the same number of samples + train_data = { + "x": torch.tensor( + [ + [ + [0.8030], + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + ], + [ + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + ], + [ + [0.8080], + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + ], + [ + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + [0.8160], + ], + ] + ), + "F": torch.tensor( + [ + [[0.8240]], + [[0.8230]], + [[0.8220]], + [[0.8200]], + [[0.8190]], + [[0.8180]], + [[0.8160]], + [[0.8140]], + [[0.8130]], + ] + ), + } + ## Not the same number of samples with self.assertRaises(ValueError): test.trainModel(train_dataset=train_data) with self.assertRaises(ValueError): test.trainAndAnalyze(test_dataset=train_data) - train_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8080],[0.8090],[0.8100],[0.8120],[0.8130],[0.8140]], - [[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]]])} + train_data = { + "x": torch.tensor( + [ + [[0.8030], [0.8030], [0.8040], [0.8040], [0.8050], [0.8060]], + [[0.8030], [0.8040], [0.8040], [0.8050], [0.8060], [0.8070]], + [[0.8080], [0.8090], [0.8100], [0.8120], [0.8130], [0.8140]], + [[0.8090], [0.8100], [0.8120], [0.8130], [0.8140], [0.8150]], + ] + ), + "F": torch.tensor([[[0.8240]], [[0.8230]], [[0.8220]], [[0.8200]]]), + } ## Not the correct number of dimensions with self.assertRaises(ValueError): test.trainModel(train_dataset=train_data) @@ -1117,92 +1559,327 @@ def test_train_sampled_datasets(self): test.trainAndAnalyze(test_dataset=train_data) with self.assertRaises(ValueError): test.trainAndAnalyze(train_dataset=train_data, test_dataset=train_data) - - train_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080]], - [[0.8080],[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150]], - [[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150],[0.8160]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]]]), - 't': torch.tensor([[[0.0]],[[0.05]],[[0.1]],[[0.15]]])} + + train_data = { + "x": torch.tensor( + [ + [ + [0.8030], + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + ], + [ + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + ], + [ + [0.8080], + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + ], + [ + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + [0.8160], + ], + ] + ), + "F": torch.tensor([[[0.8240]], [[0.8230]], [[0.8220]], [[0.8200]]]), + "t": torch.tensor([[[0.0]], [[0.05]], [[0.1]], [[0.15]]]), + } ## The extra sample is ignored - test.trainModel(train_dataset=train_data, validation_dataset=train_data, num_of_epochs=3) + test.trainModel( + train_dataset=train_data, validation_dataset=train_data, num_of_epochs=3 + ) - train_data = {'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]]])} + train_data = { + "F": torch.tensor([[[0.8240]], [[0.8230]], [[0.8220]], [[0.8200]]]) + } ## If there is a missing input the training fails with self.assertRaises(KeyError): - test.trainModel(train_dataset=train_data, validation_dataset=train_data, num_of_epochs=3) - - train_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080]], - [[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090]], - [[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090],[0.8100]], - [[0.8050],[0.8060],[0.8070],[0.8080],[0.8090],[0.8100],[0.8120]], - [[0.8060],[0.8070],[0.8080],[0.8090],[0.8100],[0.8120],[0.8130]], - [[0.8070],[0.8080],[0.8090],[0.8100],[0.8120],[0.8130],[0.8140]], - [[0.8080],[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150]], - [[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150],[0.8160]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]],[[0.8190]],[[0.8180]],[[0.8160]],[[0.8140]],[[0.8130]]])} - val_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080]], - [[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090]], - [[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090],[0.8100]], - [[0.8090],[0.8100],[0.8120],[0.8130],[0.8140],[0.8150],[0.8160]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]],[[0.8130]]])} - + test.trainModel( + train_dataset=train_data, validation_dataset=train_data, num_of_epochs=3 + ) + + train_data = { + "x": torch.tensor( + [ + [ + [0.8030], + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + ], + [ + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + ], + [ + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + ], + [ + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + [0.8100], + ], + [ + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + [0.8100], + [0.8120], + ], + [ + [0.8060], + [0.8070], + [0.8080], + [0.8090], + [0.8100], + [0.8120], + [0.8130], + ], + [ + [0.8070], + [0.8080], + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + ], + [ + [0.8080], + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + ], + [ + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + [0.8160], + ], + ] + ), + "F": torch.tensor( + [ + [[0.8240]], + [[0.8230]], + [[0.8220]], + [[0.8200]], + [[0.8190]], + [[0.8180]], + [[0.8160]], + [[0.8140]], + [[0.8130]], + ] + ), + } + val_data = { + "x": torch.tensor( + [ + [ + [0.8030], + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + ], + [ + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + ], + [ + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + ], + [ + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + [0.8100], + ], + [ + [0.8090], + [0.8100], + [0.8120], + [0.8130], + [0.8140], + [0.8150], + [0.8160], + ], + ] + ), + "F": torch.tensor( + [[[0.8240]], [[0.8230]], [[0.8220]], [[0.8200]], [[0.8130]]] + ), + } + test.trainModel(train_dataset=train_data, num_of_epochs=3) tp = test.getTrainingInfo() - self.assertEqual(9, test._num_of_samples['dataset']) - self.assertEqual(9,tp['n_samples_train']) - self.assertEqual(0,tp['n_samples_val']) - self.assertEqual(0,tp['n_samples_test']) - self.assertEqual(9,tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(128,tp['val_batch_size']) - self.assertEqual(3,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) - - test.trainModel(train_dataset=train_data, validation_dataset=val_data, num_of_epochs=3) + self.assertEqual(9, test._num_of_samples["dataset"]) + self.assertEqual(9, tp["n_samples_train"]) + self.assertEqual(0, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(9, tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(128, tp["val_batch_size"]) + self.assertEqual(3, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + + test.trainModel( + train_dataset=train_data, validation_dataset=val_data, num_of_epochs=3 + ) tp = test.getTrainingInfo() - self.assertEqual(9, test._num_of_samples['dataset']) - self.assertEqual(9,tp['n_samples_train']) - self.assertEqual(5,tp['n_samples_val']) - self.assertEqual(0,tp['n_samples_test']) - self.assertEqual(9,tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(5,tp['val_batch_size']) - self.assertEqual(3,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) - - test_data = {'x': torch.tensor([[[0.8030],[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070]], - [[0.8030],[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080]], - [[0.8040],[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090]], - [[0.8040],[0.8050],[0.8060],[0.8070],[0.8080],[0.8090],[0.8100]]]), - 'F': torch.tensor([[[0.8240]],[[0.8230]],[[0.8220]],[[0.8200]]])} - - test.trainAndAnalyze(test_dataset=test_data, test_batch_size=2, train_dataset=train_data, validation_dataset=val_data, num_of_epochs=3) + self.assertEqual(9, test._num_of_samples["dataset"]) + self.assertEqual(9, tp["n_samples_train"]) + self.assertEqual(5, tp["n_samples_val"]) + self.assertEqual(0, tp["n_samples_test"]) + self.assertEqual(9, tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(5, tp["val_batch_size"]) + self.assertEqual(3, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + + test_data = { + "x": torch.tensor( + [ + [ + [0.8030], + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + ], + [ + [0.8030], + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + ], + [ + [0.8040], + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + ], + [ + [0.8040], + [0.8050], + [0.8060], + [0.8070], + [0.8080], + [0.8090], + [0.8100], + ], + ] + ), + "F": torch.tensor([[[0.8240]], [[0.8230]], [[0.8220]], [[0.8200]]]), + } + + test.trainAndAnalyze( + test_dataset=test_data, + test_batch_size=2, + train_dataset=train_data, + validation_dataset=val_data, + num_of_epochs=3, + ) tp = test.getTrainingInfo() - self.assertEqual(9, test._num_of_samples['dataset']) - self.assertEqual(9,tp['n_samples_train']) - self.assertEqual(5,tp['n_samples_val']) - self.assertEqual(4,tp['n_samples_test']) - self.assertEqual(9,tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(5,tp['val_batch_size']) - self.assertEqual(3,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) - - test.trainAndAnalyze(test_dataset=test_data, test_batch_size=2, train_dataset=train_data, validation_dataset=val_data, num_of_epochs=3, prediction_samples=2) + self.assertEqual(9, test._num_of_samples["dataset"]) + self.assertEqual(9, tp["n_samples_train"]) + self.assertEqual(5, tp["n_samples_val"]) + self.assertEqual(4, tp["n_samples_test"]) + self.assertEqual(9, tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(5, tp["val_batch_size"]) + self.assertEqual(3, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) + + test.trainAndAnalyze( + test_dataset=test_data, + test_batch_size=2, + train_dataset=train_data, + validation_dataset=val_data, + num_of_epochs=3, + prediction_samples=2, + ) tp = test.getTrainingInfo() - self.assertEqual(9, test._num_of_samples['dataset']) - self.assertEqual(9,tp['n_samples_train']) - self.assertEqual(5,tp['n_samples_val']) - self.assertEqual(4,tp['n_samples_test']) - self.assertEqual(9,tp['train_batch_size']) - self.assertEqual(1, tp['update_per_epochs']) - #self.assertEqual(0, tp['unused_samples']) - self.assertEqual(5,tp['val_batch_size']) - self.assertEqual(3,tp['num_of_epochs']) - self.assertEqual(0.001,tp['optimizer_defaults']['lr']) \ No newline at end of file + self.assertEqual(9, test._num_of_samples["dataset"]) + self.assertEqual(9, tp["n_samples_train"]) + self.assertEqual(5, tp["n_samples_val"]) + self.assertEqual(4, tp["n_samples_test"]) + self.assertEqual(9, tp["train_batch_size"]) + self.assertEqual(1, tp["update_per_epochs"]) + # self.assertEqual(0, tp['unused_samples']) + self.assertEqual(5, tp["val_batch_size"]) + self.assertEqual(3, tp["num_of_epochs"]) + self.assertEqual(0.001, tp["optimizer_defaults"]["lr"]) diff --git a/tests/test_results.py b/tests/test_results.py index 62426625..4b7652bf 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -1,4 +1,6 @@ -import unittest, os, sys +import unittest +import os +import sys import numpy as np from nnodely import * @@ -15,303 +17,631 @@ # in closed loop and states cases # in connect and states cases -data_folder = os.path.join(os.path.dirname(__file__), '_data/') +data_folder = os.path.join(os.path.dirname(__file__), "_data/") + class ModelyTrainingTest(unittest.TestCase): def test_analysis_results(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out', Fir(W=a)(input1.last())) - - test = Modely(visualizer=None,seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out", Fir(W=a)(input1.last())) + + test = Modely(visualizer=None, seed=42) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - dataset = {'in1': [1,1,1,1,1,1,1,1,1,1], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [3,3,3,3,3,3,3,3,3,3]} - test.loadData(name='dataset', source=dataset) + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], + } + test.loadData(name="dataset", source=dataset) # Test prediction - test.analyzeModel('dataset') - self.assertEqual({'A': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]], - 'B': [[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]]]}, - test.prediction['dataset']['error1']) - self.assertEqual((1.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error1']['mse']) - self.assertEqual((2.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error2']['mse']) - self.assertEqual((1+4)/2.0, test.performance['dataset']['total']['mean_error']) - - test.analyzeModel('dataset', batch_size=5) - self.assertEqual({'A': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]], - 'B': [[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]]]}, - test.prediction['dataset']['error1']) - self.assertEqual((1.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error1']['mse']) - self.assertEqual((2.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error2']['mse']) - self.assertEqual((1+4)/2.0, test.performance['dataset']['total']['mean_error']) - - test.analyzeModel('dataset', batch_size=6) - self.assertEqual({'A': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]], - 'B': [[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]]]}, - test.prediction['dataset']['error1']) - self.assertEqual((1.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error1']['mse']) - self.assertEqual((2.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error2']['mse']) - self.assertEqual((1+4)/2.0, test.performance['dataset']['total']['mean_error']) - - dataset = {'in1': [1,1,1,1,1,1,2,2,3,3], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [3,3,3,3,3,3,3,3,3,3]} - test.loadData(name='dataset2', source=dataset) - - test.analyzeModel('dataset2') - self.assertAlmostEqual((1.0 ** 2.0) * 8.0 / 10.0, test.performance['dataset2']['error1']['mse'], places=6) - self.assertAlmostEqual(((2.0 ** 2) * 6.0 + (1.0 ** 2) * 2.0) / 10.0, test.performance['dataset2']['error2']['mse'], places=6) - self.assertAlmostEqual(((1.0 ** 2) * 8.0 / 10.0 + ((2.0 ** 2) * 6.0 + (1.0 ** 2) * 2.0) / 10.0 )/2.0, test.performance['dataset2']['total']['mean_error'], places=6) - - test.analyzeModel('dataset2', batch_size=5) - self.assertAlmostEqual((1.0 ** 2.0) * 8.0 / 10.0, test.performance['dataset2']['error1']['mse'], places=6) - self.assertAlmostEqual(((2.0 ** 2) * 6.0 + (1.0 ** 2) * 2.0) / 10.0, test.performance['dataset2']['error2']['mse'], places=6) - self.assertAlmostEqual(((1.0 ** 2) * 8.0 / 10.0 + ((2.0 ** 2) * 6.0 + (1.0 ** 2) * 2.0) / 10.0 )/2.0, test.performance['dataset2']['total']['mean_error'], places=6) - - test.analyzeModel('dataset2', batch_size=6) - self.assertEqual({'A': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]], - 'B': [[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]],[[1.0]]]}, - test.prediction['dataset2']['error1']) - self.assertEqual((1.0 ** 2) * 6.0 / 6.0, test.performance['dataset2']['error1']['mse']) - self.assertEqual((2.0 ** 2) * 6.0 / 6.0, test.performance['dataset2']['error2']['mse']) - self.assertEqual((1+4)/2.0, test.performance['dataset2']['total']['mean_error']) - - test.analyzeModel('dataset2', minimize_gain={'error1': 0.5, 'error2': 0.0}) - self.assertAlmostEqual((1.0 ** 2.0) * 8.0 / 10.0 * 0.5, test.performance['dataset2']['error1']['mse'], places=6) - self.assertAlmostEqual(0.0, test.performance['dataset2']['error2']['mse'], places=6) - self.assertAlmostEqual(((1.0 ** 2) * 8.0 / 10.0 * 0.5 + 0.0)/2.0, test.performance['dataset2']['total']['mean_error'], places=6) + test.analyzeModel("dataset") + self.assertEqual( + { + "A": [ + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + ], + "B": [ + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + ], + }, + test.prediction["dataset"]["error1"], + ) + self.assertEqual( + (1.0**2) * 10.0 / 10.0, test.performance["dataset"]["error1"]["mse"] + ) + self.assertEqual( + (2.0**2) * 10.0 / 10.0, test.performance["dataset"]["error2"]["mse"] + ) + self.assertEqual( + (1 + 4) / 2.0, test.performance["dataset"]["total"]["mean_error"] + ) + + test.analyzeModel("dataset", batch_size=5) + self.assertEqual( + { + "A": [ + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + ], + "B": [ + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + [[1.0]], + ], + }, + test.prediction["dataset"]["error1"], + ) + self.assertEqual( + (1.0**2) * 10.0 / 10.0, test.performance["dataset"]["error1"]["mse"] + ) + self.assertEqual( + (2.0**2) * 10.0 / 10.0, test.performance["dataset"]["error2"]["mse"] + ) + self.assertEqual( + (1 + 4) / 2.0, test.performance["dataset"]["total"]["mean_error"] + ) + + test.analyzeModel("dataset", batch_size=6) + self.assertEqual( + { + "A": [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], + "B": [[[1.0]], [[1.0]], [[1.0]], [[1.0]], [[1.0]], [[1.0]]], + }, + test.prediction["dataset"]["error1"], + ) + self.assertEqual( + (1.0**2) * 10.0 / 10.0, test.performance["dataset"]["error1"]["mse"] + ) + self.assertEqual( + (2.0**2) * 10.0 / 10.0, test.performance["dataset"]["error2"]["mse"] + ) + self.assertEqual( + (1 + 4) / 2.0, test.performance["dataset"]["total"]["mean_error"] + ) + + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 2, 2, 3, 3], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], + } + test.loadData(name="dataset2", source=dataset) + + test.analyzeModel("dataset2") + self.assertAlmostEqual( + (1.0**2.0) * 8.0 / 10.0, + test.performance["dataset2"]["error1"]["mse"], + places=6, + ) + self.assertAlmostEqual( + ((2.0**2) * 6.0 + (1.0**2) * 2.0) / 10.0, + test.performance["dataset2"]["error2"]["mse"], + places=6, + ) + self.assertAlmostEqual( + ((1.0**2) * 8.0 / 10.0 + ((2.0**2) * 6.0 + (1.0**2) * 2.0) / 10.0) / 2.0, + test.performance["dataset2"]["total"]["mean_error"], + places=6, + ) + + test.analyzeModel("dataset2", batch_size=5) + self.assertAlmostEqual( + (1.0**2.0) * 8.0 / 10.0, + test.performance["dataset2"]["error1"]["mse"], + places=6, + ) + self.assertAlmostEqual( + ((2.0**2) * 6.0 + (1.0**2) * 2.0) / 10.0, + test.performance["dataset2"]["error2"]["mse"], + places=6, + ) + self.assertAlmostEqual( + ((1.0**2) * 8.0 / 10.0 + ((2.0**2) * 6.0 + (1.0**2) * 2.0) / 10.0) / 2.0, + test.performance["dataset2"]["total"]["mean_error"], + places=6, + ) + + test.analyzeModel("dataset2", batch_size=6) + self.assertEqual( + { + "A": [[[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]], [[2.0]]], + "B": [[[1.0]], [[1.0]], [[1.0]], [[1.0]], [[1.0]], [[1.0]]], + }, + test.prediction["dataset2"]["error1"], + ) + self.assertEqual( + (1.0**2) * 6.0 / 6.0, test.performance["dataset2"]["error1"]["mse"] + ) + self.assertEqual( + (2.0**2) * 6.0 / 6.0, test.performance["dataset2"]["error2"]["mse"] + ) + self.assertEqual( + (1 + 4) / 2.0, test.performance["dataset2"]["total"]["mean_error"] + ) + + test.analyzeModel("dataset2", minimize_gain={"error1": 0.5, "error2": 0.0}) + self.assertAlmostEqual( + (1.0**2.0) * 8.0 / 10.0 * 0.5, + test.performance["dataset2"]["error1"]["mse"], + places=6, + ) + self.assertAlmostEqual( + 0.0, test.performance["dataset2"]["error2"]["mse"], places=6 + ) + self.assertAlmostEqual( + ((1.0**2) * 8.0 / 10.0 * 0.5 + 0.0) / 2.0, + test.performance["dataset2"]["total"]["mean_error"], + places=6, + ) def test_analysis_results_closed_loop_state(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[2]]) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[2]]) relation = Fir(W=a)(input1.last()) relation.closedLoop(input1) - output1 = Output('out', relation) + output1 = Output("out", relation) test = Modely(visualizer=None, seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - #Prediction samples = None - dataset = {'in1': [1,1,1,1,1,1,1,1,1,1], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [3,3,3,3,3,3,3,3,3,3]} - test.loadData(name='dataset', source=dataset) + # Prediction samples = None + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], + } + test.loadData(name="dataset", source=dataset) # Test prediction - test.analyzeModel('dataset',prediction_samples=-1) - self.assertEqual({'A': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]], - 'B': [[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]],[[2.0]]]}, - test.prediction['dataset']['error1']) - self.assertEqual((0.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error1']['mse']) - self.assertEqual((1.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error2']['mse']) - self.assertEqual((0+1)/2.0, test.performance['dataset']['total']['mean_error']) - - dataset = {'in1': [1,1,1,1,1,1,2,2,3,3], 'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [3,3,3,3,3,3,3,3,3,3]} - test.loadData(name='dataset2', source=dataset) - - test.analyzeModel('dataset2', batch_size=5) - self.assertEqual((0.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error1']['mse']) - self.assertEqual((1.0 ** 2) * 10.0 / 10.0, test.performance['dataset']['error2']['mse']) - self.assertEqual((0+1)/2.0, test.performance['dataset']['total']['mean_error']) + test.analyzeModel("dataset", prediction_samples=-1) + self.assertEqual( + { + "A": [ + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + ], + "B": [ + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + [[2.0]], + ], + }, + test.prediction["dataset"]["error1"], + ) + self.assertEqual( + (0.0**2) * 10.0 / 10.0, test.performance["dataset"]["error1"]["mse"] + ) + self.assertEqual( + (1.0**2) * 10.0 / 10.0, test.performance["dataset"]["error2"]["mse"] + ) + self.assertEqual( + (0 + 1) / 2.0, test.performance["dataset"]["total"]["mean_error"] + ) + + dataset = { + "in1": [1, 1, 1, 1, 1, 1, 2, 2, 3, 3], + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], + } + test.loadData(name="dataset2", source=dataset) + + test.analyzeModel("dataset2", batch_size=5) + self.assertEqual( + (0.0**2) * 10.0 / 10.0, test.performance["dataset"]["error1"]["mse"] + ) + self.assertEqual( + (1.0**2) * 10.0 / 10.0, test.performance["dataset"]["error2"]["mse"] + ) + self.assertEqual( + (0 + 1) / 2.0, test.performance["dataset"]["total"]["mean_error"] + ) # Prediction samples = 5 - dataset = {'in1': [1,2,3,4,5,6,7,8,9,10], 'out1': [11,12,13,14,15,16,17,18,19,20], 'out2': [10,20,30,40,50,60,70,80,90,100]} - test.loadData(name='dataset3', source=dataset) - - test.analyzeModel('dataset3', prediction_samples=5, batch_size=2) - A =[[[[11.0]], [[12.0]], [[13.0]], [[14.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[16.0]], [[17.0]], [[18.0]], [[19.0]]]] - B =[[[[2.0]], [[4.0]], [[6.0]], [[8.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], - [[[64.0]], [[128.0]], [[192.0]], [[256.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[60.0]], [[70.0]], [[80.0]], [[90.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset3']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset3']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/24.0, test.performance['dataset3']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/24.0, test.performance['dataset3']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/24.0+np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/24.0)/2.0, test.performance['dataset3']['total']['mean_error'], places=3) - test.analyzeModel(splits=[50,30,20], dataset='dataset3', prediction_samples=1, batch_size=1) - A =[[[[11.0]], [[12.0]], [[13.0]], [[14.0]]], [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], [[[16.0]], [[17.0]], [[18.0]], [[19.0]]]] - B =[[[[2.0]], [[4.0]], [[6.0]], [[8.0]]], [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], [[[64.0]], [[128.0]], [[192.0]], [[256.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]]], [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], [[[60.0]], [[70.0]], [[80.0]], [[90.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset3']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset3']['error2']) - - test.analyzeModel('dataset3', prediction_samples=5, batch_size=4) - A =[[[[11.0]], [[12.0]], [[13.0]], [[14.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[16.0]], [[17.0]], [[18.0]], [[19.0]]]] - B =[[[[2.0]], [[4.0]], [[6.0]], [[8.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], - [[[64.0]], [[128.0]], [[192.0]], [[256.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[60.0]], [[70.0]], [[80.0]], [[90.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset3']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset3']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/24.0, test.performance['dataset3']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/24.0, test.performance['dataset3']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/24.0+np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/24.0)/2.0, test.performance['dataset3']['total']['mean_error'], places=3) - - test.analyzeModel('dataset3', prediction_samples=4, batch_size=6) - A =[[[[11.0]], [[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]], [[20.0]]]] - B =[[[[2.0]], [[4.0]], [[6.0]], [[8.0]], [[10.0]], [[12.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]], [[20.0]], [[24.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]], [[40.0]], [[48.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]], [[80.0]], [[96.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]], [[160.0]], [[192.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]], [[100.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset3']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset3']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/30.0, test.performance['dataset3']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/30.0, test.performance['dataset3']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten()-np.array(B).flatten())**2)/30.0+np.sum((np.array(C).flatten()-np.array(B).flatten())**2)/30.0)/2.0, test.performance['dataset3']['total']['mean_error'], places=3) - - dataset = {'out1': [2,2,2,2,2,2,2,2,2,2], 'out2': [3,3,3,3,3,3,3,3,3,3]} - test.loadData(name='dataset4', source=dataset) - test.trainModel(dataset='dataset4', prediction_samples=-1) #TODO FIX - test.analyzeModel('dataset4', prediction_samples=-1) #TODO FIX - + dataset = { + "in1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "out1": [11, 12, 13, 14, 15, 16, 17, 18, 19, 20], + "out2": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100], + } + test.loadData(name="dataset3", source=dataset) + + test.analyzeModel("dataset3", prediction_samples=5, batch_size=2) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[16.0]], [[17.0]], [[18.0]], [[19.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], + [[[64.0]], [[128.0]], [[192.0]], [[256.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[60.0]], [[70.0]], [[80.0]], [[90.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset3"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset3"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset3"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset3"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0 + ) + / 2.0, + test.performance["dataset3"]["total"]["mean_error"], + places=3, + ) + test.analyzeModel( + splits=[50, 30, 20], dataset="dataset3", prediction_samples=1, batch_size=1 + ) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[16.0]], [[17.0]], [[18.0]], [[19.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], + [[[64.0]], [[128.0]], [[192.0]], [[256.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[60.0]], [[70.0]], [[80.0]], [[90.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset3"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset3"]["error2"]) + + test.analyzeModel("dataset3", prediction_samples=5, batch_size=4) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[16.0]], [[17.0]], [[18.0]], [[19.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], + [[[64.0]], [[128.0]], [[192.0]], [[256.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[60.0]], [[70.0]], [[80.0]], [[90.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset3"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset3"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset3"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset3"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0 + ) + / 2.0, + test.performance["dataset3"]["total"]["mean_error"], + places=3, + ) + + test.analyzeModel("dataset3", prediction_samples=4, batch_size=6) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]], [[20.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]], [[10.0]], [[12.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]], [[20.0]], [[24.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]], [[40.0]], [[48.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]], [[80.0]], [[96.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]], [[160.0]], [[192.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]], [[100.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset3"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset3"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0, + test.performance["dataset3"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0, + test.performance["dataset3"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0 + ) + / 2.0, + test.performance["dataset3"]["total"]["mean_error"], + places=3, + ) + + dataset = { + "out1": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], + "out2": [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], + } + test.loadData(name="dataset4", source=dataset) + test.trainModel(dataset="dataset4", prediction_samples=-1) # TODO FIX + test.analyzeModel("dataset4", prediction_samples=-1) # TODO FIX def test_analysis_results_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1') - target1 = Input('out1') - target2 = Input('out2') - a = Parameter('a', sw=1, values=[[2]]) - output1 = Output('out', Fir(W=a)(input1.last())) + input1 = Input("in1") + target1 = Input("out1") + target2 = Input("out2") + a = Parameter("a", sw=1, values=[[2]]) + output1 = Output("out", Fir(W=a)(input1.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', output1) - test.addMinimize('error1', target1.last(), output1) - test.addMinimize('error2', target2.last(), output1) + test.addModel("model", output1) + test.addMinimize("error1", target1.last(), output1) + test.addMinimize("error2", target2.last(), output1) test.neuralizeModel() - dataset = {'in1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'out1': [11, 12, 13, 14, 15, 16, 17, 18, 19, 20], - 'out2': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]} - test.loadData(name='dataset', source=dataset) - - test.analyzeModel('dataset', closed_loop={'in1': 'out'}, prediction_samples=5, batch_size=2) - A = [[[[11.0]], [[12.0]], [[13.0]], [[14.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[16.0]], [[17.0]], [[18.0]], [[19.0]]]] - B = [[[[2.0]], [[4.0]], [[6.0]], [[8.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], - [[[64.0]], [[128.0]], [[192.0]], [[256.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[60.0]], [[70.0]], [[80.0]], [[90.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, - test.performance['dataset']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, - test.performance['dataset']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + np.sum( - (np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0) / 2.0, - test.performance['dataset']['total']['mean_error'], places=3) - - test.analyzeModel('dataset', closed_loop={'in1': 'out'}, prediction_samples=5, batch_size=4) - A = [[[[11.0]], [[12.0]], [[13.0]], [[14.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[16.0]], [[17.0]], [[18.0]], [[19.0]]]] - B = [[[[2.0]], [[4.0]], [[6.0]], [[8.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], - [[[64.0]], [[128.0]], [[192.0]], [[256.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[60.0]], [[70.0]], [[80.0]], [[90.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, - test.performance['dataset']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, - test.performance['dataset']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + np.sum( - (np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0) / 2.0, - test.performance['dataset']['total']['mean_error'], places=3) - - test.analyzeModel('dataset', closed_loop={'in1': 'out'}, prediction_samples=4, batch_size=6) - A = [[[[11.0]], [[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]]], - [[[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]]], - [[[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]]], - [[[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]]], - [[[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]], [[20.0]]]] - B = [[[[2.0]], [[4.0]], [[6.0]], [[8.0]], [[10.0]], [[12.0]]], - [[[4.0]], [[8.0]], [[12.0]], [[16.0]], [[20.0]], [[24.0]]], - [[[8.0]], [[16.0]], [[24.0]], [[32.0]], [[40.0]], [[48.0]]], - [[[16.0]], [[32.0]], [[48.0]], [[64.0]], [[80.0]], [[96.0]]], - [[[32.0]], [[64.0]], [[96.0]], [[128.0]], [[160.0]], [[192.0]]]] - C = [[[[10.0]], [[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]]], - [[[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]]], - [[[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]]], - [[[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]]], - [[[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]], [[100.0]]]] - self.assertEqual({'A': A, 'B': B}, test.prediction['dataset']['error1']) - self.assertEqual({'A': C, 'B': B}, test.prediction['dataset']['error2']) - self.assertAlmostEqual(np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0, - test.performance['dataset']['error1']['mse'], places=3) - self.assertAlmostEqual(np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0, - test.performance['dataset']['error2']['mse'], places=3) - self.assertAlmostEqual((np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0 + np.sum( - (np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0) / 2.0, - test.performance['dataset']['total']['mean_error'], places=3) + dataset = { + "in1": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + "out1": [11, 12, 13, 14, 15, 16, 17, 18, 19, 20], + "out2": [10, 20, 30, 40, 50, 60, 70, 80, 90, 100], + } + test.loadData(name="dataset", source=dataset) + + test.analyzeModel( + "dataset", closed_loop={"in1": "out"}, prediction_samples=5, batch_size=2 + ) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[16.0]], [[17.0]], [[18.0]], [[19.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], + [[[64.0]], [[128.0]], [[192.0]], [[256.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[60.0]], [[70.0]], [[80.0]], [[90.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0 + ) + / 2.0, + test.performance["dataset"]["total"]["mean_error"], + places=3, + ) + + test.analyzeModel( + "dataset", closed_loop={"in1": "out"}, prediction_samples=5, batch_size=4 + ) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[16.0]], [[17.0]], [[18.0]], [[19.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]]], + [[[64.0]], [[128.0]], [[192.0]], [[256.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[60.0]], [[70.0]], [[80.0]], [[90.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0, + test.performance["dataset"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 24.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 24.0 + ) + / 2.0, + test.performance["dataset"]["total"]["mean_error"], + places=3, + ) + + test.analyzeModel( + "dataset", closed_loop={"in1": "out"}, prediction_samples=4, batch_size=6 + ) + A = [ + [[[11.0]], [[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]]], + [[[12.0]], [[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]]], + [[[13.0]], [[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]]], + [[[14.0]], [[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]]], + [[[15.0]], [[16.0]], [[17.0]], [[18.0]], [[19.0]], [[20.0]]], + ] + B = [ + [[[2.0]], [[4.0]], [[6.0]], [[8.0]], [[10.0]], [[12.0]]], + [[[4.0]], [[8.0]], [[12.0]], [[16.0]], [[20.0]], [[24.0]]], + [[[8.0]], [[16.0]], [[24.0]], [[32.0]], [[40.0]], [[48.0]]], + [[[16.0]], [[32.0]], [[48.0]], [[64.0]], [[80.0]], [[96.0]]], + [[[32.0]], [[64.0]], [[96.0]], [[128.0]], [[160.0]], [[192.0]]], + ] + C = [ + [[[10.0]], [[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]]], + [[[20.0]], [[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]]], + [[[30.0]], [[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]]], + [[[40.0]], [[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]]], + [[[50.0]], [[60.0]], [[70.0]], [[80.0]], [[90.0]], [[100.0]]], + ] + self.assertEqual({"A": A, "B": B}, test.prediction["dataset"]["error1"]) + self.assertEqual({"A": C, "B": B}, test.prediction["dataset"]["error2"]) + self.assertAlmostEqual( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0, + test.performance["dataset"]["error1"]["mse"], + places=3, + ) + self.assertAlmostEqual( + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0, + test.performance["dataset"]["error2"]["mse"], + places=3, + ) + self.assertAlmostEqual( + ( + np.sum((np.array(A).flatten() - np.array(B).flatten()) ** 2) / 30.0 + + np.sum((np.array(C).flatten() - np.array(B).flatten()) ** 2) / 30.0 + ) + / 2.0, + test.performance["dataset"]["total"]["mean_error"], + places=3, + ) diff --git a/tests/test_train.py b/tests/test_train.py index a9fe6fe4..90f7e370 100644 --- a/tests/test_train.py +++ b/tests/test_train.py @@ -1,4 +1,7 @@ -import unittest, os, sys, torch +import unittest +import os +import sys +import torch import numpy as np from nnodely import * @@ -14,283 +17,354 @@ # 5 Tests # This file tests the value of the training parameters -data_folder = os.path.join(os.path.dirname(__file__), '_data/') +data_folder = os.path.join(os.path.dirname(__file__), "_data/") + class ModelyTrainingTest(unittest.TestCase): def test_training_values_fir(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('out1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out', Fir(W=a)(input1.last())) - output2 = Output('out2', Fir(W_init='init_constant', W_init_params={'value':1})(input1.last())) - output3 = Output('out3', Fir(W_init='init_exp', b_init='init_exp')(input1.last())) - output4 = Output('out4', Fir(W_init='init_lin', b_init='init_lin')(input1.last())) - output5 = Output('out5', Fir(W_init='init_negexp', b_init='init_negexp')(input1.last())) - - test = Modely(visualizer=None,seed=42) - test.addModel('model', [output1,output2,output3,output4,output5]) - test.addMinimize('error', target.last(), output1) + input1 = Input("in1") + target = Input("out1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out", Fir(W=a)(input1.last())) + output2 = Output( + "out2", + Fir(W_init="init_constant", W_init_params={"value": 1})(input1.last()), + ) + output3 = Output( + "out3", Fir(W_init="init_exp", b_init="init_exp")(input1.last()) + ) + output4 = Output( + "out4", Fir(W_init="init_lin", b_init="init_lin")(input1.last()) + ) + output5 = Output( + "out5", Fir(W_init="init_negexp", b_init="init_negexp")(input1.last()) + ) + + test = Modely(visualizer=None, seed=42) + test.addModel("model", [output1, output2, output3, output4, output5]) + test.addMinimize("error", target.last(), output1) test.neuralizeModel() - dataset = {'in1': [1], 'in2':[[1,2,3]], 'out1': [2]} - test.loadData(name='dataset', source=dataset) + dataset = {"in1": [1], "in2": [[1, 2, 3]], "out1": [2]} + test.loadData(name="dataset", source=dataset) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=2) + self.assertListEqual([[1.0]], test.parameters["a"]) def test_training_values_linear(self): NeuObj.clearNames() - input1 = Input('in1') - input2 = Input('in2', dimensions=3) - target = Input('out1') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output1 = Output('out', Linear(W=W,b=b)(input1.last())) - output2 = Output('out2', Linear(W_init='init_constant', W_init_params={'value':1})(input1.last())) - output3 = Output('out3', Linear(W_init='init_exp', b_init='init_exp')(input2.last())) - output4 = Output('out4', Linear(W_init='init_negexp', b_init='init_negexp')(input2.last())) - output5 = Output('out5', Linear(W_init='init_lin', b_init='init_lin')(input2.last())) + input1 = Input("in1") + input2 = Input("in2", dimensions=3) + target = Input("out1") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output1 = Output("out", Linear(W=W, b=b)(input1.last())) + output2 = Output( + "out2", + Linear(W_init="init_constant", W_init_params={"value": 1})(input1.last()), + ) + output3 = Output( + "out3", Linear(W_init="init_exp", b_init="init_exp")(input2.last()) + ) + output4 = Output( + "out4", Linear(W_init="init_negexp", b_init="init_negexp")(input2.last()) + ) + output5 = Output( + "out5", Linear(W_init="init_lin", b_init="init_lin")(input2.last()) + ) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2,output3,output4,output5]) - test.addMinimize('error', target.last(), output1) + test.addModel("model", [output1, output2, output3, output4, output5]) + test.addMinimize("error", target.last(), output1) test.neuralizeModel() - dataset = {'in1': [1], 'in2':[[1,2,3]], 'out1': [3]} - test.loadData(name='dataset', source=dataset) + dataset = {"in1": [1], "in2": [[1, 2, 3]], "out1": [3]} + test.loadData(name="dataset", source=dataset) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) def test_training_clear_model(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('int1') - a = Parameter('a', sw=1, values=[[1]]) + input1 = Input("in1") + target = Input("int1") + a = Parameter("a", sw=1, values=[[1]]) fir_out = Fir(W=a)(input1.last()) - output1 = Output('out1', fir_out) + output1 = Output("out1", fir_out) - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output2 = Output('out2', Linear(W=W,b=b)(fir_out)) + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output2 = Output("out2", Linear(W=W, b=b)(fir_out)) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error', target.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]})) - - dataset = {'in1': [1], 'int1': [3]} - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertEqual({"out1": [1.0], "out2": [2.0]}, test({"in1": [1]})) + + dataset = {"in1": [1], "int1": [3]} + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) def test_network_linear_interpolation_train(self): NeuObj.clearNames() - x = Input('x') - param = Parameter(name='a', sw=1) - rel1 = Fir(W=param)(Interpolation([1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], mode='linear')(x.last())) - out = Output('out',rel1) + x = Input("x") + param = Parameter(name="a", sw=1) + rel1 = Fir(W=param)( + Interpolation([1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], mode="linear")( + x.last() + ) + ) + out = Output("out", rel1) test = Modely(visualizer=None, seed=1) - test.addModel('fun',[out]) - test.addMinimize('error', out, x.last()) + test.addModel("fun", [out]) + test.addMinimize("error", out, x.last()) test.neuralizeModel(0.01) - dataset = {'x':np.random.uniform(1,4,100)} - test.loadData(name='dataset', source=dataset) + dataset = {"x": np.random.uniform(1, 4, 100)} + test.loadData(name="dataset", source=dataset) test.trainModel(num_of_epochs=100, train_batch_size=10) - self.assertAlmostEqual(test.parameters['a'][0][0], 0.5, places=2) + self.assertAlmostEqual(test.parameters["a"][0][0], 0.5, places=2) def test_multimodel_with_loss_gain_and_lr_gain(self): NeuObj.clearNames() ## Model1 - input1 = Input('in1') - a1 = Parameter('a1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output11 = Output('out11', Fir(W=a1)(input1.tw(0.05))) - a2 = Parameter('a2', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) - output12 = Output('out12', Fir(W=a2)(input1.tw(0.05))) - a3 = Parameter('a3', dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) - output13 = Output('out13', Fir(W=a3)(input1.tw(0.05))) + input1 = Input("in1") + a1 = Parameter("a1", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output11 = Output("out11", Fir(W=a1)(input1.tw(0.05))) + a2 = Parameter("a2", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output12 = Output("out12", Fir(W=a2)(input1.tw(0.05))) + a3 = Parameter("a3", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output13 = Output("out13", Fir(W=a3)(input1.tw(0.05))) test = Modely(visualizer=None, seed=42) - test.addModel('model1', [output11, output12, output13]) - test.addMinimize('error11', input1.next(), output11) - test.addMinimize('error12', input1.next(), output12) - test.addMinimize('error13', input1.next(), output13) + test.addModel("model1", [output11, output12, output13]) + test.addMinimize("error11", input1.next(), output11) + test.addMinimize("error12", input1.next(), output12) + test.addMinimize("error13", input1.next(), output13) ## Model2 - input2 = Input('in2') - b1 = Parameter('b1', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output21 = Output('out21', Fir(W=b1)(input2.tw(0.05))) - b2 = Parameter('b2', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output22 = Output('out22', Fir(W=b2)(input2.tw(0.05))) - b3 = Parameter('b3', dimensions=1, tw=0.05, values=[[1],[1],[1],[1],[1]]) - output23 = Output('out23', Fir(W=b3)(input2.tw(0.05))) - - test.addModel('model2', [output21, output22, output23]) - test.addMinimize('error21', input2.next(), output21) - test.addMinimize('error22', input2.next(), output22) - test.addMinimize('error23', input2.next(), output23) + input2 = Input("in2") + b1 = Parameter("b1", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output21 = Output("out21", Fir(W=b1)(input2.tw(0.05))) + b2 = Parameter("b2", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output22 = Output("out22", Fir(W=b2)(input2.tw(0.05))) + b3 = Parameter("b3", dimensions=1, tw=0.05, values=[[1], [1], [1], [1], [1]]) + output23 = Output("out23", Fir(W=b3)(input2.tw(0.05))) + + test.addModel("model2", [output21, output22, output23]) + test.addMinimize("error21", input2.next(), output21) + test.addMinimize("error22", input2.next(), output22) + test.addMinimize("error23", input2.next(), output23) test.neuralizeModel(0.01) data_in1 = [1, 1, 1, 1, 1, 2] data_in2 = [1, 1, 1, 1, 1, 2] - dataset = {'in1': data_in1, 'in2': data_in2} + dataset = {"in1": data_in1, "in2": data_in2} - test.loadData(name='dataset', source=dataset) + test.loadData(name="dataset", source=dataset) ## Train only model1 - self.assertListEqual(test.parameters['a1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['a2'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b2'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['a3'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b3'], [[1], [1], [1], [1], [1]]) - test.trainModel(optimizer='SGD', models='model1', splits=[100,0,0], lr=1, num_of_epochs=1) - self.assertListEqual(test.parameters['a1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['a2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b2'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['a3'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b3'], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["a1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["a2"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b2"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["a3"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b3"], [[1], [1], [1], [1], [1]]) + test.trainModel( + optimizer="SGD", models="model1", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual(test.parameters["a1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["a2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b2"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["a3"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b3"], [[1], [1], [1], [1], [1]]) ## Train only model2 test.neuralizeModel(0.01, clear_model=True) - test.trainModel(optimizer='SGD', models='model2', splits=[100,0,0], lr=1, num_of_epochs=1) - self.assertListEqual(test.parameters['a1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a2'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a3'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b3'], [[-5], [-5], [-5], [-5], [-5]]) + test.trainModel( + optimizer="SGD", models="model2", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual(test.parameters["a1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a2"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a3"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b3"], [[-5], [-5], [-5], [-5], [-5]]) ## Train both models test.neuralizeModel(0.01, clear_model=True) - test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1) - self.assertListEqual(test.parameters['a1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a3'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b3'], [[-5], [-5], [-5], [-5], [-5]]) + test.trainModel( + optimizer="SGD", + models=["model1", "model2"], + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + ) + self.assertListEqual(test.parameters["a1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a3"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b3"], [[-5], [-5], [-5], [-5], [-5]]) ## Train both models but set the gain of a to zero and the gain of b to double test.neuralizeModel(0.01, clear_model=True) - test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, lr_param={'a1':0, 'b1':2}) - self.assertListEqual(test.parameters['a1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b1'], [[-11], [-11], [-11], [-11], [-11]]) - self.assertListEqual(test.parameters['a2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a3'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b3'], [[-5], [-5], [-5], [-5], [-5]]) + test.trainModel( + optimizer="SGD", + models=["model1", "model2"], + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + lr_param={"a1": 0, "b1": 2}, + ) + self.assertListEqual(test.parameters["a1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b1"], [[-11], [-11], [-11], [-11], [-11]]) + self.assertListEqual(test.parameters["a2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a3"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b3"], [[-5], [-5], [-5], [-5], [-5]]) ## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double test.neuralizeModel(0.01, clear_model=True) - test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':0}) - self.assertListEqual(test.parameters['a1'], [[1], [1], [1], [1], [1]]) - self.assertListEqual(test.parameters['b1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a3'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b3'], [[-5], [-5], [-5], [-5], [-5]]) + test.trainModel( + optimizer="SGD", + models=["model1", "model2"], + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + minimize_gain={"error11": 0}, + ) + self.assertListEqual(test.parameters["a1"], [[1], [1], [1], [1], [1]]) + self.assertListEqual(test.parameters["b1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a3"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b3"], [[-5], [-5], [-5], [-5], [-5]]) ## Train both models but set the minimize gain of error1 to zero and the minimize gain of error2 to double test.neuralizeModel(0.01, clear_model=True) - test.trainModel(optimizer='SGD', models=['model1','model2'], splits=[100,0,0], lr=1, num_of_epochs=1, minimize_gain={'error11':-1,'error22':2}) - self.assertListEqual(test.parameters['a1'], [[7], [7], [7], [7], [7]]) - self.assertListEqual(test.parameters['b1'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['a2'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b2'], [[-11], [-11], [-11], [-11], [-11]]) - self.assertListEqual(test.parameters['a3'], [[-5], [-5], [-5], [-5], [-5]]) - self.assertListEqual(test.parameters['b3'], [[-5], [-5], [-5], [-5], [-5]]) + test.trainModel( + optimizer="SGD", + models=["model1", "model2"], + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + minimize_gain={"error11": -1, "error22": 2}, + ) + self.assertListEqual(test.parameters["a1"], [[7], [7], [7], [7], [7]]) + self.assertListEqual(test.parameters["b1"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["a2"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b2"], [[-11], [-11], [-11], [-11], [-11]]) + self.assertListEqual(test.parameters["a3"], [[-5], [-5], [-5], [-5], [-5]]) + self.assertListEqual(test.parameters["b3"], [[-5], [-5], [-5], [-5], [-5]]) def test_train_equation_learner(self): # TODO aggiungi la verifica dei parametri NeuObj.clearNames() + def func(x): return np.cos(x) + np.sin(x) - - data_x = np.random.uniform(0, 2*np.pi, 200) + + data_x = np.random.uniform(0, 2 * np.pi, 200) data_y = func(data_x) - dataset = {'x': data_x, 'y': data_y} + dataset = {"x": data_x, "y": data_y} - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") linear_in = Linear(output_dimension=5) linear_in_2 = Linear(output_dimension=5) - linear_out = Linear(output_dimension=1, W_init=init_constant, W_init_params={'value':1}) + linear_out = Linear( + output_dimension=1, W_init=init_constant, W_init_params={"value": 1} + ) - equation_learner = EquationLearner(functions=[Sin, Identity, Add, Cos], linear_in=linear_in) ## W=1*5 , b=1, activation_out=4 - equation_learner2 = EquationLearner(functions=[Add, Identity, Mul],linear_in=linear_in_2, linear_out=linear_out) ## INGRESSO W=4*5, b=5, activation_out=3 USCITA W=3*1, b=1 + equation_learner = EquationLearner( + functions=[Sin, Identity, Add, Cos], linear_in=linear_in + ) ## W=1*5 , b=1, activation_out=4 + equation_learner2 = EquationLearner( + functions=[Add, Identity, Mul], linear_in=linear_in_2, linear_out=linear_out + ) ## INGRESSO W=4*5, b=5, activation_out=3 USCITA W=3*1, b=1 eq1 = equation_learner(x.last()) eq2 = equation_learner2(eq1) - out = Output('eq2', eq2) + out = Output("eq2", eq2) example = Modely(visualizer=None) - example.addModel('model',[out]) - example.addMinimize('error', out, y.last()) + example.addModel("model", [out]) + example.addMinimize("error", out, y.last()) example.neuralizeModel() - example.loadData(name='dataset', source=dataset) + example.loadData(name="dataset", source=dataset) ## Print the initial weights - optimizer_defaults = {'weight_decay': 0.3,} - example.trainModel(train_dataset='dataset', lr=0.01, num_of_epochs=2, optimizer_defaults=optimizer_defaults, early_stopping=select_best_model) + optimizer_defaults = { + "weight_decay": 0.3, + } + example.trainModel( + train_dataset="dataset", + lr=0.01, + num_of_epochs=2, + optimizer_defaults=optimizer_defaults, + early_stopping=select_best_model, + ) def test_train_derivate_wrt_input(self): NeuObj.clearNames() - x = Input('x') - dy_dx_target = Input('dy_dx') + x = Input("x") + dy_dx_target = Input("dy_dx") x_last = x.last() def parametric_fun(x, a, b, c, d): import torch - return x ** 3 * a + x ** 2 * b + torch.sin(x) * c + d + + return x**3 * a + x**2 * b + torch.sin(x) * c + d def dx_parametric_fun(x, a, b, c, d): import torch - return (3 * x ** 2 * a) + (2 * x * b) + c * torch.cos(x) - fun = ParamFun(parametric_fun,['a','b','c','d'])(x_last) - approx_dy_dx = Output('d_out', Differentiate(fun, x_last)) + return (3 * x**2 * a) + (2 * x * b) + c * torch.cos(x) + + fun = ParamFun(parametric_fun, ["a", "b", "c", "d"])(x_last) + approx_dy_dx = Output("d_out", Differentiate(fun, x_last)) test = Modely(visualizer=None, seed=12) @@ -300,45 +374,108 @@ def dx_parametric_fun(x, a, b, c, d): data_b = -0.03 data_c = 2.02 data_d = -1.05 - dataset = {'x': data_x, 'dy_dx': dx_parametric_fun(data_x, data_a, data_b, data_c, data_d)} + dataset = { + "x": data_x, + "dy_dx": dx_parametric_fun(data_x, data_a, data_b, data_c, data_d), + } # d y_approx / d x == dy_dx # Se x era una time window and dy_dx dovrà essere una time window - test.addModel('model', [approx_dy_dx]) - test.addMinimize('sob_err', 'd_out', dy_dx_target.last()) + test.addModel("model", [approx_dy_dx]) + test.addMinimize("sob_err", "d_out", dy_dx_target.last()) test.neuralizeModel() - test.loadData('data', dataset) - test.trainModel(num_of_epochs=1000, splits=[70,20,10], lr=0.3) - self.assertAlmostEqual(test.parameters['a'][0], data_a, places=4) - self.assertAlmostEqual(test.parameters['b'][0], data_b, places=4) - self.assertAlmostEqual(test.parameters['c'][0], data_c, places=4) - #The value data_d is not match because the derivative does not depend on it - + test.loadData("data", dataset) + test.trainModel(num_of_epochs=1000, splits=[70, 20, 10], lr=0.3) + self.assertAlmostEqual(test.parameters["a"][0], data_a, places=4) + self.assertAlmostEqual(test.parameters["b"][0], data_b, places=4) + self.assertAlmostEqual(test.parameters["c"][0], data_c, places=4) + # The value data_d is not match because the derivative does not depend on it + def test_step(self): NeuObj.clearNames() - x = Input('x') + x = Input("x") relation = Fir()(x.tw(0.05)) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, log_internal=True) - test.addModel('model', output) - test.addMinimize('error', output, x.next()) + test.addModel("model", output) + test.addMinimize("error", output, x.next()) test.neuralizeModel(0.01) - train_data_x = np.array(10*[10] + 20*[20] + 30*[30], dtype=np.float32) - train_dataset = {'x': train_data_x, 'time': np.array(range(60), dtype=np.float32)} - test.loadData(name='dataset', source=train_dataset, ) - self.assertListEqual(list(test._data['dataset']['x'].shape), [55, 6, 1]) ## 60 observations, time window of 6 so in total 54+1 samples - test.trainModel(step=10, train_batch_size=10, train_dataset='dataset', num_of_epochs=1, shuffle_data=False, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 20) ## chosed 10 sample at index = [0, 21] and for each sample the horizon is 10 so in total 4*10=40 - test.trainModel(step=10, train_batch_size=10, train_dataset='dataset', num_of_epochs=1, shuffle_data=True, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 20) ## shuffle data does not change the number of samples - test.trainModel(step=0, train_batch_size=10, train_dataset='dataset', num_of_epochs=1, shuffle_data=False, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 40) ## chosed 10 sample at index = [0, 11, 22, 33] and for each sample the horizon is 10 so in total 4*10=40 - test.trainModel(step=1000, train_batch_size=10, train_dataset='dataset', num_of_epochs=1, shuffle_data=False, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 10) ## clip step to max value = 36 so just 1 sample * 10 prediction samples - test.trainModel(step=10, train_batch_size=1, train_dataset='dataset', num_of_epochs=1, shuffle_data=False, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 50) ## chosed sample = [0, 11, 22, 33, 44] and for each sample the horizon is 10 so in total 5*10=50 - test.trainModel(step=0, train_batch_size=1, train_dataset='dataset', num_of_epochs=1, shuffle_data=False, prediction_samples=9) - self.assertEqual(len(test.internals.keys()), 460) ## 46 sample * 10 horizon \ No newline at end of file + train_data_x = np.array(10 * [10] + 20 * [20] + 30 * [30], dtype=np.float32) + train_dataset = { + "x": train_data_x, + "time": np.array(range(60), dtype=np.float32), + } + test.loadData( + name="dataset", + source=train_dataset, + ) + self.assertListEqual( + list(test._data["dataset"]["x"].shape), [55, 6, 1] + ) ## 60 observations, time window of 6 so in total 54+1 samples + test.trainModel( + step=10, + train_batch_size=10, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=False, + prediction_samples=9, + ) + self.assertEqual( + len(test.internals.keys()), 20 + ) ## chosed 10 sample at index = [0, 21] and for each sample the horizon is 10 so in total 4*10=40 + test.trainModel( + step=10, + train_batch_size=10, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=True, + prediction_samples=9, + ) + self.assertEqual( + len(test.internals.keys()), 20 + ) ## shuffle data does not change the number of samples + test.trainModel( + step=0, + train_batch_size=10, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=False, + prediction_samples=9, + ) + self.assertEqual( + len(test.internals.keys()), 40 + ) ## chosed 10 sample at index = [0, 11, 22, 33] and for each sample the horizon is 10 so in total 4*10=40 + test.trainModel( + step=1000, + train_batch_size=10, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=False, + prediction_samples=9, + ) + self.assertEqual( + len(test.internals.keys()), 10 + ) ## clip step to max value = 36 so just 1 sample * 10 prediction samples + test.trainModel( + step=10, + train_batch_size=1, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=False, + prediction_samples=9, + ) + self.assertEqual( + len(test.internals.keys()), 50 + ) ## chosed sample = [0, 11, 22, 33, 44] and for each sample the horizon is 10 so in total 5*10=50 + test.trainModel( + step=0, + train_batch_size=1, + train_dataset="dataset", + num_of_epochs=1, + shuffle_data=False, + prediction_samples=9, + ) + self.assertEqual(len(test.internals.keys()), 460) ## 46 sample * 10 horizon diff --git a/tests/test_train_recurrent.py b/tests/test_train_recurrent.py index da059a37..47f6dbf4 100644 --- a/tests/test_train_recurrent.py +++ b/tests/test_train_recurrent.py @@ -1,6 +1,7 @@ -import unittest, os, sys +import unittest +import os +import sys import numpy as np -from pygments.unistring import xid_start from nnodely import * from nnodely.basic.relation import NeuObj @@ -14,701 +15,1352 @@ # 15 Tests # Test the value of the weight after the recurrent training + # Linear function -def linear_fun(x,a,b): - return x*a+b +def linear_fun(x, a, b): + return x * a + b + -data_x = np.random.rand(500)*20-10 +data_x = np.random.rand(500) * 20 - 10 data_a = 2 data_b = -3 -dataset = {'in1': data_x, 'out': linear_fun(data_x,data_a,data_b)} -data_folder = '/tests/_data/' +dataset = {"in1": data_x, "out": linear_fun(data_x, data_a, data_b)} +data_folder = "/tests/_data/" + class ModelyTrainingTest(unittest.TestCase): def assertAlmostEqual(self, data1, data2, precision=3): if type(data1) == type(data2) == list: - assert np.asarray(data1, dtype=np.float32).ndim == np.asarray(data2,dtype=np.float32).ndim, f'Inputs must have the same dimension! Received {type(data1)} and {type(data2)}' + assert ( + np.asarray(data1, dtype=np.float32).ndim + == np.asarray(data2, dtype=np.float32).ndim + ), ( + f"Inputs must have the same dimension! Received {type(data1)} and {type(data2)}" + ) self.assertEqual(len(data1), len(data2)) for pred, label in zip(data1, data2): self.assertAlmostEqual(pred, label, precision=precision) elif type(data1) == type(data2) == dict: self.assertEqual(len(data1.items()), len(data2.items())) - for (pred_key,pred_value), (label_key,label_value) in zip(data1.items(), data2.items()): + for (pred_key, pred_value), (label_key, label_value) in zip( + data1.items(), data2.items() + ): self.assertAlmostEqual(pred_value, label_value, precision=precision) else: super().assertAlmostEqual(data1, data2, places=precision) def test_recurrent_shuffle(self): NeuObj.clearNames() - target = Input('target') - x = Input('x') + target = Input("target") + x = Input("x") relation = Fir(x.last()) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, seed=42, log_internal=True) - test.addModel('model', output) - test.addMinimize('out', target.next(), 'out') + test.addModel("model", output) + test.addMinimize("out", target.next(), "out") test.neuralizeModel(0.01) - dataset = {'x': [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], 'target': [21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]} - test.loadData(name='dataset', source=dataset) - - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=0.01, num_of_epochs=1, train_batch_size=4, prediction_samples=1, step=1, shuffle_data=True) - self.assertListEqual([[[4.0]], [[1.0]], [[9.0]], [[18.0]]], test.internals['inout_0_0']['XY']['x']) - self.assertListEqual([[[25.0]], [[22.0]], [[30.0]], [[39.0]]], test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[26.0]], [[23.0]], [[31.0]], [[40.0]]], test.internals['inout_0_1']['XY']['target']) - self.assertListEqual([[[5.0]], [[16.0]], [[3.0]], [[13.0]]], test.internals['inout_1_0']['XY']['x']) - self.assertListEqual([[[26.0]], [[37.0]], [[24.0]], [[34.0]]], test.internals['inout_1_0']['XY']['target']) - self.assertListEqual([[[27.0]], [[38.0]], [[25.0]], [[35.0]]], test.internals['inout_1_1']['XY']['target']) - self.assertListEqual([[[15.0]], [[2.0]], [[17.0]], [[14.0]]], test.internals['inout_2_0']['XY']['x']) - self.assertListEqual([[[36.0]], [[23.0]], [[38.0]], [[35.0]]], test.internals['inout_2_0']['XY']['target']) - self.assertListEqual([[[37.0]], [[24.0]], [[39.0]], [[36.0]]], test.internals['inout_2_1']['XY']['target']) - - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=0.01, num_of_epochs=1, train_batch_size=2, - prediction_samples=2, step=0, shuffle_data=True) + dataset = { + "x": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + ], + "target": [ + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + ], + } + test.loadData(name="dataset", source=dataset) + + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=0.01, + num_of_epochs=1, + train_batch_size=4, + prediction_samples=1, + step=1, + shuffle_data=True, + ) + self.assertListEqual( + [[[4.0]], [[1.0]], [[9.0]], [[18.0]]], + test.internals["inout_0_0"]["XY"]["x"], + ) + self.assertListEqual( + [[[25.0]], [[22.0]], [[30.0]], [[39.0]]], + test.internals["inout_0_0"]["XY"]["target"], + ) + self.assertListEqual( + [[[26.0]], [[23.0]], [[31.0]], [[40.0]]], + test.internals["inout_0_1"]["XY"]["target"], + ) + self.assertListEqual( + [[[5.0]], [[16.0]], [[3.0]], [[13.0]]], + test.internals["inout_1_0"]["XY"]["x"], + ) + self.assertListEqual( + [[[26.0]], [[37.0]], [[24.0]], [[34.0]]], + test.internals["inout_1_0"]["XY"]["target"], + ) + self.assertListEqual( + [[[27.0]], [[38.0]], [[25.0]], [[35.0]]], + test.internals["inout_1_1"]["XY"]["target"], + ) + self.assertListEqual( + [[[15.0]], [[2.0]], [[17.0]], [[14.0]]], + test.internals["inout_2_0"]["XY"]["x"], + ) + self.assertListEqual( + [[[36.0]], [[23.0]], [[38.0]], [[35.0]]], + test.internals["inout_2_0"]["XY"]["target"], + ) + self.assertListEqual( + [[[37.0]], [[24.0]], [[39.0]], [[36.0]]], + test.internals["inout_2_1"]["XY"]["target"], + ) + + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=0.01, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=2, + step=0, + shuffle_data=True, + ) # ( number_samples - window_size - prediction_samples )// (batch_size + step=0) * (predictoin_samples+1) - self.assertEqual((20-1-2)//2*3, len(test.internals.keys())) + self.assertEqual((20 - 1 - 2) // 2 * 3, len(test.internals.keys())) with self.assertRaises(ValueError): - test.trainModel(dataset='dataset', splits=[40,30,30], optimizer='SGD', lr=0.01, num_of_epochs=1, train_batch_size=2, - prediction_samples=50, step=0, shuffle_data=True) + test.trainModel( + dataset="dataset", + splits=[40, 30, 30], + optimizer="SGD", + lr=0.01, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=50, + step=0, + shuffle_data=True, + ) with self.assertRaises(ValueError): - test.trainModel(dataset='dataset', splits=[40,10,40], optimizer='SGD', lr=0.01, num_of_epochs=1, train_batch_size=2, - prediction_samples=50, step=0, shuffle_data=True) + test.trainModel( + dataset="dataset", + splits=[40, 10, 40], + optimizer="SGD", + lr=0.01, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=50, + step=0, + shuffle_data=True, + ) from nnodely.support.earlystopping import early_stop_patience, select_best_model - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=0.01, num_of_epochs=15, - train_batch_size=2, early_stopping=early_stop_patience, early_stopping_params={'patience':2}, select_model=select_best_model, - prediction_samples=2, step=0, shuffle_data=True) + + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=0.01, + num_of_epochs=15, + train_batch_size=2, + early_stopping=early_stop_patience, + early_stopping_params={"patience": 2}, + select_model=select_best_model, + prediction_samples=2, + step=0, + shuffle_data=True, + ) def test_train_multifiles(self): NeuObj.clearNames() - x = Input('x') - y = Input('y') - relation = Fir()(x.tw(0.05))+Fir(y.sw([-2,2])) + x = Input("x") + y = Input("y") + relation = Fir()(x.tw(0.05)) + Fir(y.sw([-2, 2])) relation.closedLoop(x) - output = Output('out', relation) + output = Output("out", relation) test = Modely(visualizer=None, log_internal=True) - test.addModel('model', output) - test.addMinimize('error', 'out', x.next()) + test.addModel("model", output) + test.addMinimize("error", "out", x.next()) test.neuralizeModel(0.01) ## The folder contains 3 files with 10, 20 and 30 samples respectively - data_struct = ['x', 'y'] - data_folder = os.path.join(os.path.dirname(__file__), 'multifile/') - test.loadData(name='dataset', source=data_folder, format=data_struct, skiplines=1) - self.assertEqual(len(test._data['dataset']['x']), 42) - self.assertEqual(len(test._data['dataset']['y']), 42) - - test.trainModel(splits=[70, 20, 10], train_batch_size = 3, num_of_epochs=1, prediction_samples=2) - self.assertEqual(len(list(test.internals.keys())), 3*7) - self.assertEqual(list(np.mean(np.array(test.internals['inout_0_0']['XY']['y']),axis=1)), - list(np.mean(np.array(test.internals['inout_0_1']['XY']['y']),axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_0_0']['XY']['y']), axis=1)), - list(np.mean(np.array(test.internals['inout_0_2']['XY']['y']), axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_1_0']['XY']['y']),axis=1)), - list(np.mean(np.array(test.internals['inout_1_1']['XY']['y']),axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_1_0']['XY']['y']), axis=1)), - list(np.mean(np.array(test.internals['inout_1_2']['XY']['y']), axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_2_0']['XY']['y']),axis=1)), - list(np.mean(np.array(test.internals['inout_2_1']['XY']['y']),axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_2_0']['XY']['y']), axis=1)), - list(np.mean(np.array(test.internals['inout_2_2']['XY']['y']), axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_6_0']['XY']['y']),axis=1)), - list(np.mean(np.array(test.internals['inout_6_1']['XY']['y']),axis=1))) - self.assertEqual(list(np.mean(np.array(test.internals['inout_6_0']['XY']['y']), axis=1)), - list(np.mean(np.array(test.internals['inout_6_2']['XY']['y']), axis=1))) + data_struct = ["x", "y"] + data_folder = os.path.join(os.path.dirname(__file__), "multifile/") + test.loadData( + name="dataset", source=data_folder, format=data_struct, skiplines=1 + ) + self.assertEqual(len(test._data["dataset"]["x"]), 42) + self.assertEqual(len(test._data["dataset"]["y"]), 42) + + test.trainModel( + splits=[70, 20, 10], + train_batch_size=3, + num_of_epochs=1, + prediction_samples=2, + ) + self.assertEqual(len(list(test.internals.keys())), 3 * 7) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_0_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_0_1"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_0_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_0_2"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_1_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_1_1"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_1_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_1_2"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_2_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_2_1"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_2_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_2_2"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_6_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_6_1"]["XY"]["y"]), axis=1)), + ) + self.assertEqual( + list(np.mean(np.array(test.internals["inout_6_0"]["XY"]["y"]), axis=1)), + list(np.mean(np.array(test.internals["inout_6_2"]["XY"]["y"]), axis=1)), + ) def test_training_values_fir_connect_linear(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) + input1 = Input("in1") + target = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) relation = Fir(W=a)(input1.last()) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) relation.connect(inout) - output1 = Output('out1', relation) - output2 = Output('out2', Linear(W=W,b=b)(inout.last())) + output1 = Output("out1", relation) + output2 = Output("out2", Linear(W=W, b=b)(inout.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error', target.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]})) - - dataset = {'in1': [1], 'target1': [3]} - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertEqual({"out1": [1.0], "out2": [2.0]}, test({"in1": [1]})) + + dataset = {"in1": [1], "target1": [3]} + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) - - dataset = {'in1': [1,1], 'target1': [3,3]} - test.loadData(name='dataset2', source=dataset) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=2) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) + + dataset = {"in1": [1, 1], "target1": [3, 3]} + test.loadData(name="dataset2", source=dataset) test.neuralizeModel(clear_model=True) # the out is 3.0 due the mean of the error is not the same of two epochs - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", optimizer="SGD", lr=1, num_of_epochs=1 + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=2) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", optimizer="SGD", lr=1, num_of_epochs=2 + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) def test_training_values_fir_train_connect_linear(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('out1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1-net',Fir(W=a)(input1.last())) + input1 = Input("in1") + target = Input("out1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1-net", Fir(W=a)(input1.last())) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=1) - output2 = Output('out2-net', Linear(W=W,b=b)(inout.last())) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=1) + output2 = Output("out2-net", Linear(W=W, b=b)(inout.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error', target.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1-net': [1.0], 'out2-net': [2.0]}, test({'in1': [1]}, connect={'inout': 'out1-net'})) - - dataset = {'in1': [1], 'out1': [3]} - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1-net'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1-net'}) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertEqual( + {"out1-net": [1.0], "out2-net": [2.0]}, + test({"in1": [1]}, connect={"inout": "out1-net"}), + ) + + dataset = {"in1": [1], "out1": [3]} + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1-net'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1-net'}) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2, connect={'inout': 'out1-net'}) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=2, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) with self.assertRaises(KeyError): - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=2) - dataset = {'in1': [1,1], 'out1': [3,3]} - test.loadData(name='dataset2', source=dataset) + dataset = {"in1": [1, 1], "out1": [3, 3]} + test.loadData(name="dataset2", source=dataset) test.neuralizeModel(clear_model=True) # the out is 3.0 due the mean of the error is not the same of two epochs - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, connect={'inout': 'out1-net'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=2, connect={'inout': 'out1-net'}) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=2, + connect={"inout": "out1-net"}, + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) def test_training_values_fir_connect_linear_only_model(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1',Fir(W=a)(input1.last())) + input1 = Input("in1") + target = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1", Fir(W=a)(input1.last())) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output2 = Output('out2', Linear(W=W,b=b)(inout.last())) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output2 = Output("out2", Linear(W=W, b=b)(inout.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model1', output1) - test.addModel('model2', output2) - test.addMinimize('error', target.last(), output2) + test.addModel("model1", output1) + test.addModel("model2", output2) + test.addMinimize("error", target.last(), output2) test.addConnect(output1, inout) test.neuralizeModel() - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]})) + self.assertEqual({"out1": [1.0], "out2": [2.0]}, test({"in1": [1]})) - dataset = {'in1': [1], 'target1': [3]} - test.loadData(name='dataset', source=dataset) + dataset = {"in1": [1], "target1": [3]} + test.loadData(name="dataset", source=dataset) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(models='model1', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(models='model1', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + models="model1", optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel( + models="model1", optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(models='model2', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(models='model2', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + models="model2", optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + models="model2", optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1 + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) def test_training_values_fir_train_connect_linear_only_model(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1',Fir(W=a)(input1.last())) + input1 = Input("in1") + target = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1", Fir(W=a)(input1.last())) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output2 = Output('out2', Linear(W=W,b=b)(inout.last())) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output2 = Output("out2", Linear(W=W, b=b)(inout.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model1', output1) - test.addModel('model2', output2) - test.addMinimize('error', target.last(), output2) + test.addModel("model1", output1) + test.addModel("model2", output2) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [1.0], 'out2': [1.0]}, test({'in1': [1]})) - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]}, connect={'inout': 'out1'})) - - dataset = {'in1': [1], 'target1': [3]} - test.loadData(name='dataset', source=dataset) - - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[-51.0]], test.parameters['W']) - self.assertListEqual([-15.0], test.parameters['b']) - self.assertListEqual([[-51.0]], test.parameters['a']) + self.assertEqual({"out1": [1.0], "out2": [1.0]}, test({"in1": [1]})) + self.assertEqual( + {"out1": [1.0], "out2": [2.0]}, + test({"in1": [1]}, connect={"inout": "out1"}), + ) + + dataset = {"in1": [1], "target1": [3]} + test.loadData(name="dataset", source=dataset) + + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-51.0]], test.parameters["W"]) + self.assertListEqual([-15.0], test.parameters["b"]) + self.assertListEqual([[-51.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(models='model1', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[3.0]], test.parameters['a']) - test.trainModel(models='model1', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + models="model1", + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[3.0]], test.parameters["a"]) + test.trainModel( + models="model1", + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(models='model2', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(models='model2', optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, connect={'inout': 'out1'}) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + models="model2", + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + models="model2", + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) def test_training_values_fir_connect_linear_more_prediction(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('out1') - a = Parameter('a', sw=1, values=[[1]]) - relation =Fir(W=a)(input1.last()) + input1 = Input("in1") + target = Input("out1") + a = Parameter("a", sw=1, values=[[1]]) + relation = Fir(W=a)(input1.last()) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=1) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=1) relation.connect(inout) - output1 = Output('out1-net', relation) - output2 = Output('out2-net', Linear(W=W,b=b)(inout.last())) + output1 = Output("out1-net", relation) + output2 = Output("out2-net", Linear(W=W, b=b)(inout.last())) - test = Modely(visualizer=None,seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error', target.last(), output2) + test = Modely(visualizer=None, seed=42) + test.addModel("model", [output1, output2]) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1-net': [1.0], 'out2-net': [2.0]}, test({'in1': [1]})) - - dataset = {'in1': [0,2,7,1], 'out1': [3,4,5,1], 'inout': [1,1,2,2]} - test.loadData(name='dataset2', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[-9.0]], test.parameters['W']) - self.assertEqual([0.5], test.parameters['b']) - self.assertListEqual([[-9.0]], test.parameters['a']) + self.assertEqual({"out1-net": [1.0], "out2-net": [2.0]}, test({"in1": [1]})) + + dataset = {"in1": [0, 2, 7, 1], "out1": [3, 4, 5, 1], "inout": [1, 1, 2, 2]} + test.loadData(name="dataset2", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[-9.0]], test.parameters["W"]) + self.assertEqual([0.5], test.parameters["b"]) + self.assertListEqual([[-9.0]], test.parameters["a"]) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + ) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[-9.0]], test.parameters['W']) - self.assertEqual([0.5], test.parameters['b']) - self.assertListEqual([[-9.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual([[-9.0]], test.parameters["W"]) + self.assertEqual([0.5], test.parameters["b"]) + self.assertListEqual([[-9.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - #TODO add this test for check prediction_Sample -1 for connect + # TODO add this test for check prediction_Sample -1 for connect # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=-1) # self.assertListEqual([[-9.0]], test.parameters['W']) ? # self.assertEqual([0.5], test.parameters['b']) ? # self.assertListEqual([[-9.0]], test.parameters['a']) ? - dataset = {'in1': [0, 2, 7, 1, 5, 0, 2], 'out1': [1, 4, 8, 2, 6, 1, 1]} - test.loadData(name='dataset3', source=dataset) + dataset = {"in1": [0, 2, 7, 1, 5, 0, 2], "out1": [1, 4, 8, 2, 6, 1, 1]} + test.loadData(name="dataset3", source=dataset) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset3', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, train_batch_size=2, prediction_samples=3) - self.assertListEqual([[-162.75]], test.parameters['W']) - self.assertEqual([-15.75], test.parameters['b']) - self.assertListEqual([[-162.75]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=3, + ) + self.assertListEqual([[-162.75]], test.parameters["W"]) + self.assertEqual([-15.75], test.parameters["b"]) + self.assertListEqual([[-162.75]], test.parameters["a"]) # Because is a connect and the window is 1 the initialization of the state is overwritten by the out1 - test.loadData(name='dataset4', source=dataset|{'inout': [0,0,0,0,0,0,0]}) + test.loadData( + name="dataset4", source=dataset | {"inout": [0, 0, 0, 0, 0, 0, 0]} + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset4', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, train_batch_size=2, prediction_samples=3) - self.assertListEqual([[-162.75]], test.parameters['W']) - self.assertEqual([-15.75], test.parameters['b']) - self.assertListEqual([[-162.75]], test.parameters['a']) + test.trainModel( + train_dataset="dataset4", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=3, + ) + self.assertListEqual([[-162.75]], test.parameters["W"]) + self.assertEqual([-15.75], test.parameters["b"]) + self.assertListEqual([[-162.75]], test.parameters["a"]) def test_training_values_fir_train_connect_linear_more_prediction(self): NeuObj.clearNames() - input1 = Input('in1') - target = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1',Fir(W=a)(input1.last())) + input1 = Input("in1") + target = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1", Fir(W=a)(input1.last())) - inout = Input('inout') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output2 = Output('out2', Linear(W=W,b=b)(inout.last())) + inout = Input("inout") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output2 = Output("out2", Linear(W=W, b=b)(inout.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error', target.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error", target.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1]},connect={'inout': 'out1'})) - - dataset = {'in1': [0,2,7,1], 'target1': [3,4,5,1]} - test.loadData(name='dataset2', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, connect={'inout': 'out1'}) - self.assertListEqual([[-9.0]], test.parameters['W']) - self.assertListEqual([0.5], test.parameters['b']) - self.assertListEqual([[-9.0]], test.parameters['a']) + self.assertEqual( + {"out1": [1.0], "out2": [2.0]}, + test({"in1": [1]}, connect={"inout": "out1"}), + ) + + dataset = {"in1": [0, 2, 7, 1], "target1": [3, 4, 5, 1]} + test.loadData(name="dataset2", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-9.0]], test.parameters["W"]) + self.assertListEqual([0.5], test.parameters["b"]) + self.assertListEqual([[-9.0]], test.parameters["a"]) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10, connect={'inout': 'out1'}) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + connect={"inout": "out1"}, + ) # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1, connect={'inout': 'out1'}) # TODO add this test test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3, connect={'inout': 'out1'}) - self.assertListEqual([[-9.0]], test.parameters['W']) - self.assertListEqual([0.5], test.parameters['b']) - self.assertListEqual([[-9.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-9.0]], test.parameters["W"]) + self.assertListEqual([0.5], test.parameters["b"]) + self.assertListEqual([[-9.0]], test.parameters["a"]) # Because is a connect and the window is 1 the initialization of the state is overwritten by the out1 - dataset = {'in1': [0,2,7,1], 'target1': [3,4,5,1], 'inout':[1,1,2,2]} - test.loadData(name='dataset3', source=dataset) + dataset = {"in1": [0, 2, 7, 1], "target1": [3, 4, 5, 1], "inout": [1, 1, 2, 2]} + test.loadData(name="dataset3", source=dataset) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3, connect={'inout': 'out1'}) - self.assertListEqual([[-9.0]], test.parameters['W']) - self.assertListEqual([0.5], test.parameters['b']) - self.assertListEqual([[-9.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-9.0]], test.parameters["W"]) + self.assertListEqual([0.5], test.parameters["b"]) + self.assertListEqual([[-9.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset3', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[-273.0]], test.parameters['W']) - self.assertListEqual([-137.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual([[-273.0]], test.parameters["W"]) + self.assertListEqual([-137.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset3', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=-1) - self.assertListEqual([[-273.0]], test.parameters['W']) - self.assertListEqual([-137.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=-1, + ) + self.assertListEqual([[-273.0]], test.parameters["W"]) + self.assertListEqual([-137.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset3', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, train_batch_size=1) - self.assertListEqual([[-273.0]], test.parameters['W']) - self.assertListEqual([-137.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - - dataset = {'in1': [0, 2, 7, 1, 5, 0, 2], 'target1': [1, 4, 8, 2, 6, 1, 1]} - test.loadData(name='dataset4', source=dataset) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=1, + ) + self.assertListEqual([[-273.0]], test.parameters["W"]) + self.assertListEqual([-137.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + + dataset = {"in1": [0, 2, 7, 1, 5, 0, 2], "target1": [1, 4, 8, 2, 6, 1, 1]} + test.loadData(name="dataset4", source=dataset) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset4', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, - train_batch_size=2, prediction_samples=3, connect={'inout': 'out1'}) - self.assertListEqual([[-162.75]], test.parameters['W']) - self.assertListEqual([-15.75], test.parameters['b']) - self.assertListEqual([[-162.75]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset4", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-162.75]], test.parameters["W"]) + self.assertListEqual([-15.75], test.parameters["b"]) + self.assertListEqual([[-162.75]], test.parameters["a"]) # Because is a connect and the window is 1 the initialization of the state is overwritten by the out1 - test.loadData(name='dataset5', source=dataset | {'inout': [0, 0, 0, 0, 0, 0, 0]}) + test.loadData( + name="dataset5", source=dataset | {"inout": [0, 0, 0, 0, 0, 0, 0]} + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset5', optimizer='SGD', shuffle_data=False, lr=1, num_of_epochs=1, - train_batch_size=2, prediction_samples=3, connect={'inout': 'out1'}) - self.assertListEqual([[-162.75]], test.parameters['W']) - self.assertListEqual([-15.75], test.parameters['b']) - self.assertListEqual([[-162.75]], test.parameters['a']) + test.trainModel( + train_dataset="dataset5", + optimizer="SGD", + shuffle_data=False, + lr=1, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual([[-162.75]], test.parameters["W"]) + self.assertListEqual([-15.75], test.parameters["b"]) + self.assertListEqual([[-162.75]], test.parameters["a"]) def test_training_values_fir_connect_linear_more_window(self): NeuObj.clearNames() - input1 = Input('in1', dimensions=2) - W = Parameter('W', values=[[-1], [-5]]) - b = Parameter('b', values=1) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=1) lin_out = Linear(W=W, b=b)(input1.sw(2)) - inout = Input('inout') - a = Parameter('a', sw=2, values=[[4], [5]]) - a_big = Parameter('ab', sw=5, values=[[1], [2], [3], [4], [5]]) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) + a_big = Parameter("ab", sw=5, values=[[1], [2], [3], [4], [5]]) lin_out.connect(inout) - output1 = Output('out1', lin_out) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - output3 = Output('out3', Fir(W=a_big)(inout.sw(5))) - output4 = Output('out4', Fir(W=a)(lin_out)) + output1 = Output("out1", lin_out) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + output3 = Output("out3", Fir(W=a_big)(inout.sw(5))) + output4 = Output("out4", Fir(W=a)(lin_out)) - target = Input('target') + target = Input("target") test = Modely(visualizer=None, seed=42, log_internal=True) - test.addModel('model', [output1, output2, output3, output4]) - test.addMinimize('error2', target.last(), output2) - #test.addMinimize('error3', target.last(), output3) - #test.addMinimize('error4', target.last(), output4) + test.addModel("model", [output1, output2, output3, output4]) + test.addMinimize("error2", target.last(), output2) + # test.addMinimize('error3', target.last(), output3) + # test.addMinimize('error4', target.last(), output4) test.neuralizeModel() # Dataset with only one sample - dataset = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2]], 'target': [3,4,5,1,3]} - self.assertEqual({'out1': [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0]], - 'out2': [-96.0, -194.0, -179.0, -125.0], - 'out3': [-96.0, -206.0, -235.0, -239.0], - 'out4': [-96.0, -194.0, -179.0, -125.0] - }, test(dataset)) - test.loadData(name='dataset', source=dataset) + dataset = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2]], + "target": [3, 4, 5, 1, 3], + } + self.assertEqual( + { + "out1": [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0]], + "out2": [-96.0, -194.0, -179.0, -125.0], + "out3": [-96.0, -206.0, -235.0, -239.0], + "out4": [-96.0, -194.0, -179.0, -125.0], + }, + test(dataset), + ) + test.loadData(name="dataset", source=dataset) # TODO add and error # dataset = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2]], 'target': [3,4,5,1]} # test.loadData(name='dataset2', source=dataset) - self.assertListEqual([[-1], [-5]], test.parameters['W']) - self.assertEqual([1 ], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[6143], [5627]], test.parameters['W']) - self.assertEqual([2305], test.parameters['b']) - self.assertListEqual([[-3836], [-3323]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertEqual([1], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[6143], [5627]], test.parameters["W"]) + self.assertEqual([2305], test.parameters["b"]) + self.assertListEqual([[-3836], [-3323]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=1, + ) # Data set with more samples test.neuralizeModel(clear_model=True) - dataset2 = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2],[6,5],[4,5],[0,0]], 'target': [3,4,5,1,3,0,1,0]} - test.loadData(name='dataset2', source=dataset2) + dataset2 = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2], [6, 5], [4, 5], [0, 0]], + "target": [3, 4, 5, 1, 3, 0, 1, 0], + } + test.loadData(name="dataset2", source=dataset2) self.maxDiff = None - self.assertEqual({'out1': [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0], [-13.0, -30.0], [-30.0, -28.0], [-28.0, 1.0]], - 'out2': [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], - 'out3': [-96.0, -206.0, -235.0, -239.0, -315.0, -355.0, -238.0], - 'out4': [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0] - }, test(dataset2)) + self.assertEqual( + { + "out1": [ + [-4.0, -16.0], + [-16.0, -26.0], + [-26.0, -15.0], + [-15.0, -13.0], + [-13.0, -30.0], + [-30.0, -28.0], + [-28.0, 1.0], + ], + "out2": [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], + "out3": [-96.0, -206.0, -235.0, -239.0, -315.0, -355.0, -238.0], + "out4": [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], + }, + test(dataset2), + ) # Use a train_batch_size of 4 # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1) # TODO add this test - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Use a small batch but with a prediction sample of 3 = to 4 samples test.neuralizeModel(clear_model=True) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=4) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=4, + ) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Different minimize - test.removeMinimize('error2') - test.addMinimize('error3', target.last(), output3) + test.removeMinimize("error2") + test.addMinimize("error3", target.last(), output3) test.neuralizeModel(clear_model=True) - self.assertListEqual([[-1], [-5]], test.parameters['W']) - self.assertEqual([1], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertEqual([1], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Use a train_batch_size of 4 - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertEqual([3142], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertEqual([3142], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertEqual([3142], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertEqual([3142], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, shuffle_data=False, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]]], test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]], test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]], test.internals['inout_0_2']['XY']['in1']) - self.assertListEqual([[[4.0, 5.0], [0.0, 0.0]]], test.internals['inout_0_3']['XY']['in1']) - self.assertListEqual([[[3.0]]], test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]]], test.internals['inout_0_1']['XY']['target']) - self.assertListEqual([[[1.0]]], test.internals['inout_0_2']['XY']['target']) - self.assertListEqual([[[0.0]]], test.internals['inout_0_3']['XY']['target']) - self.assertDictEqual({'out1': [[[-15.0], [-13.0]]], 'out2': [[[-125.0]]], 'out3': [[[-125.0]]], 'out4': [[[-125.0]]]}, test.internals['inout_0_0']['out']) - self.assertDictEqual({'out1': [[[-13.0], [-30.0]]], 'out2': [[[-202.0]]], 'out3': [[[-247.0]]], 'out4': [[[-202.0]]]}, test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[4*-1+2*-5+1.0], [6*-1+5*-5+1.0]]], - 'out2': [[[(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]], - 'out3': [[[(-15)*3.0+(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]], - 'out4': [[[(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]]}, test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[6*-1+5*-5+1.0], [4*-1+5*-5+1.0]]], - 'out2': [[[(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]], - 'out3': [[[(-15)*2.0+(4*-1+2*-5+1.0)*3.0+(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]], - 'out4': [[[(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]]}, test.internals['inout_0_2']['out']) - self.assertDictEqual({'out1': [[[4*-1+5*-5+1.0], [0*-1+0*-5+1.0]]], - 'out2': [[[(4*-1+5*-5+1.0)*4.0+(0*-1+0*-5+1.0)*5.0]]], - 'out3': [[[(-15)*1.0+(4*-1+2*-5+1.0)*2.0+(6*-1+5*-5+1.0)*3.0+(4*-1+5*-5+1.0)*4.0+(0*-1+0*-5+1.0)*5.0]]], - 'out4': [[[(4*-1+5*-5+1.0)*4.0+(0*-1+0*-5+1.0)*5.0]]]}, test.internals['inout_0_3']['out']) - self.assertDictEqual({'inout': [[[0.0],[0.0], [-15.0], [-13.0], [np.inf]]]}, test.internals['inout_0_0']['state']) - self.assertDictEqual({'inout': [[[0.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, test.internals['inout_0_1']['state']) - self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, test.internals['inout_0_2']['state']) - self.assertDictEqual({'inout': [[[-13.0], [-30.0], [-28.0], [1.0], [np.inf]]]}, test.internals['inout_0_3']['state']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]]], test.internals["inout_0_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_0_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_0_2"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 5.0], [0.0, 0.0]]], test.internals["inout_0_3"]["XY"]["in1"] + ) + self.assertListEqual([[[3.0]]], test.internals["inout_0_0"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_1"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_0_2"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_3"]["XY"]["target"]) + self.assertDictEqual( + { + "out1": [[[-15.0], [-13.0]]], + "out2": [[[-125.0]]], + "out3": [[[-125.0]]], + "out4": [[[-125.0]]], + }, + test.internals["inout_0_0"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[-13.0], [-30.0]]], + "out2": [[[-202.0]]], + "out3": [[[-247.0]]], + "out4": [[[-202.0]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], + "out2": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + "out3": [ + [ + [ + (-15) * 3.0 + + (4 * -1 + 2 * -5 + 1.0) * 4 + + (6 * -1 + 5 * -5 + 1.0) * 5 + ] + ] + ], + "out4": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], + "out2": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 2.0 + + (4 * -1 + 2 * -5 + 1.0) * 3.0 + + (6 * -1 + 5 * -5 + 1.0) * 4.0 + + (4 * -1 + 5 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_2"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[4 * -1 + 5 * -5 + 1.0], [0 * -1 + 0 * -5 + 1.0]]], + "out2": [ + [[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 1.0 + + (4 * -1 + 2 * -5 + 1.0) * 2.0 + + (6 * -1 + 5 * -5 + 1.0) * 3.0 + + (4 * -1 + 5 * -5 + 1.0) * 4.0 + + (0 * -1 + 0 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_3"]["out"], + ) + self.assertDictEqual( + {"inout": [[[0.0], [0.0], [-15.0], [-13.0], [np.inf]]]}, + test.internals["inout_0_0"]["state"], + ) + self.assertDictEqual( + {"inout": [[[0.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, + test.internals["inout_0_1"]["state"], + ) + self.assertDictEqual( + {"inout": [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, + test.internals["inout_0_2"]["state"], + ) + self.assertDictEqual( + {"inout": [[[-13.0], [-30.0], [-28.0], [1.0], [np.inf]]]}, + test.internals["inout_0_3"]["state"], + ) # Replace instead of roll # self.assertDictEqual({'inout': [[[0.0], [0.0], [-15.0], [-13.0], [0.0]]]}, test.internals['inout_0_0']['state']) # self.assertDictEqual({'inout': [[[0.0], [-15.0], [-13.0], [-30.0], [0.0]]]}, test.internals['inout_0_1']['state']) # self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [0.0]]]}, test.internals['inout_0_2']['state']) # self.assertDictEqual({'inout': [[[-13.0], [-30.0], [-28.0], [1.0], [-15.0]]]}, test.internals['inout_0_3']['state']) - self.assertListEqual([[22273.5], [20993.0]], test.parameters['W']) - self.assertEqual([6154.0], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[-1784.0], [-4020.0], [-7564.5], [-10843.5], [-9033.0]], test.parameters['ab']) + self.assertListEqual([[22273.5], [20993.0]], test.parameters["W"]) + self.assertEqual([6154.0], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual( + [[-1784.0], [-4020.0], [-7564.5], [-10843.5], [-9033.0]], + test.parameters["ab"], + ) with self.assertRaises(KeyError): - test.internals['inout_1_0'] + test.internals["inout_1_0"] test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, train_batch_size=1, - prediction_samples=2) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]]], test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]], test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]], test.internals['inout_0_2']['XY']['in1']) - self.assertListEqual([[[3.0]]], test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]]], test.internals['inout_0_1']['XY']['target']) - self.assertListEqual([[[1.0]]], test.internals['inout_0_2']['XY']['target']) - self.assertDictEqual({'out1': [[[-15.0], [-13.0]]], 'out2': [[[-125.0]]], 'out3': [[[-125.0]]], 'out4': [[[-125.0]]]}, test.internals['inout_0_0']['out']) - self.assertDictEqual({'out1': [[[-13.0], [-30.0]]], 'out2': [[[-202.0]]], 'out3': [[[-247.0]]], 'out4': [[[-202.0]]]}, test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[4*-1+2*-5+1.0], [6*-1+5*-5+1.0]]], - 'out2': [[[(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]], - 'out3': [[[(-15)*3.0+(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]], - 'out4': [[[(4*-1+2*-5+1.0)*4+(6*-1+5*-5+1.0)*5]]]}, test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[6*-1+5*-5+1.0], [4*-1+5*-5+1.0]]], - 'out2': [[[(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]], - 'out3': [[[(-15)*2.0+(4*-1+2*-5+1.0)*3.0+(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]], - 'out4': [[[(6*-1+5*-5+1.0)*4.0+(4*-1+5*-5+1.0)*5.0]]]}, test.internals['inout_0_2']['out']) - self.assertDictEqual({'inout': [[[0.0], [0.0], [-15.0], [-13.0], [np.inf]]]}, test.internals['inout_0_0']['state']) - self.assertDictEqual({'inout': [[[0.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, test.internals['inout_0_1']['state']) - self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, test.internals['inout_0_2']['state']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=2, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]]], test.internals["inout_0_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_0_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_0_2"]["XY"]["in1"] + ) + self.assertListEqual([[[3.0]]], test.internals["inout_0_0"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_1"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_0_2"]["XY"]["target"]) + self.assertDictEqual( + { + "out1": [[[-15.0], [-13.0]]], + "out2": [[[-125.0]]], + "out3": [[[-125.0]]], + "out4": [[[-125.0]]], + }, + test.internals["inout_0_0"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[-13.0], [-30.0]]], + "out2": [[[-202.0]]], + "out3": [[[-247.0]]], + "out4": [[[-202.0]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], + "out2": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + "out3": [ + [ + [ + (-15) * 3.0 + + (4 * -1 + 2 * -5 + 1.0) * 4 + + (6 * -1 + 5 * -5 + 1.0) * 5 + ] + ] + ], + "out4": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], + "out2": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 2.0 + + (4 * -1 + 2 * -5 + 1.0) * 3.0 + + (6 * -1 + 5 * -5 + 1.0) * 4.0 + + (4 * -1 + 5 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_2"]["out"], + ) + self.assertDictEqual( + {"inout": [[[0.0], [0.0], [-15.0], [-13.0], [np.inf]]]}, + test.internals["inout_0_0"]["state"], + ) + self.assertDictEqual( + {"inout": [[[0.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, + test.internals["inout_0_1"]["state"], + ) + self.assertDictEqual( + {"inout": [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, + test.internals["inout_0_2"]["state"], + ) # Replace instead of rolling # self.assertDictEqual({'inout': [[[0.0], [0.0], [-15.0], [-13.0], [0.0]]]}, test.internals['inout_0_0']['state']) # self.assertDictEqual({'inout': [[[0.0], [-15.0], [-13.0], [-30.0], [0.0]]]}, test.internals['inout_0_1']['state']) # self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [0.0]]]}, test.internals['inout_0_2']['state']) - W = test.internals['inout_1_0']['param']['W'] - b = test.internals['inout_1_0']['param']['b'] - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]], test.internals['inout_1_0']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]], test.internals['inout_1_1']['XY']['in1']) - self.assertListEqual([[[4.0, 5.0], [0.0, 0.0]]], test.internals['inout_1_2']['XY']['in1']) - self.assertListEqual([[[0.0]]], test.internals['inout_1_0']['XY']['target']) - self.assertListEqual([[[1.0]]], test.internals['inout_1_1']['XY']['target']) - self.assertListEqual([[[0.0]]], test.internals['inout_1_2']['XY']['target']) - self.assertAlmostEqual({'inout': [[[0.0], [0.0], [W[0][0]*4.0+W[1][0]*2.0+b[0]], [W[0][0]*6.0+W[1][0]*5.0+b[0]], [np.inf]]]}, test.internals['inout_1_0']['state']) - self.assertAlmostEqual({'inout': [[[0.0], [W[0][0]*4.0+W[1][0]*2.0+b[0]], [W[0][0]*6.0+W[1][0]*5.0+b[0]], [W[0][0]*4.0+W[1][0]*5.0+b[0]], [np.inf]]]}, test.internals['inout_1_1']['state']) - self.assertAlmostEqual({'inout': [[[W[0][0]*4.0+W[1][0]*2.0+b[0]], [W[0][0]*6.0+W[1][0]*5.0+b[0]], [W[0][0]*4.0+W[1][0]*5.0+b[0]], [W[0][0]*0.0+W[1][0]*0.0+b[0]], [np.inf]]]}, test.internals['inout_1_2']['state']) + W = test.internals["inout_1_0"]["param"]["W"] + b = test.internals["inout_1_0"]["param"]["b"] + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_1_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_1_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 5.0], [0.0, 0.0]]], test.internals["inout_1_2"]["XY"]["in1"] + ) + self.assertListEqual([[[0.0]]], test.internals["inout_1_0"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_1_1"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_1_2"]["XY"]["target"]) + self.assertAlmostEqual( + { + "inout": [ + [ + [0.0], + [0.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_0"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [0.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_1"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_2"]["state"], + ) # Replace instead of rolling # self.assertAlmostEqual({'inout': [[[0.0], [0.0], [W[0][0][0] * 4.0 + W[0][1][0] * 2.0 + b[0][0]], # [W[0][0][0] * 6.0 + W[0][1][0] * 5.0 + b[0][0]], [0.0]]]}, @@ -722,43 +1374,111 @@ def test_training_values_fir_connect_linear_more_window(self): # test.internals['inout_1_2']['state']) with self.assertRaises(KeyError): - test.internals['inout_2_0'] + test.internals["inout_2_0"] test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, train_batch_size=2, prediction_samples=1) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]], [[4.0, 2.0], [6.0, 5.0]]], test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]], [[6.0, 5.0], [4.0, 5.0]]], test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[3.0]],[[0.0]]], test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]],[[1.0]]], test.internals['inout_0_1']['XY']['target']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=1, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]], [[4.0, 2.0], [6.0, 5.0]]], + test.internals["inout_0_0"]["XY"]["in1"], + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]], [[6.0, 5.0], [4.0, 5.0]]], + test.internals["inout_0_1"]["XY"]["in1"], + ) + self.assertListEqual( + [[[3.0]], [[0.0]]], test.internals["inout_0_0"]["XY"]["target"] + ) + self.assertListEqual( + [[[0.0]], [[1.0]]], test.internals["inout_0_1"]["XY"]["target"] + ) with self.assertRaises(KeyError): - test.internals['inout_1_0'] + test.internals["inout_1_0"] test.neuralizeModel(clear_model=True) - dataset3 = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2],[6,5],[4,5],[0,0]], 'target': [3,4,5,1,3,0,1,0], 'inout':[9,8,7,6,5,4,3,2]} - test.loadData(name='dataset3', source=dataset3) - test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, - train_batch_size=1, - prediction_samples=2) - self.assertDictEqual({'inout': [[[8.0], [7.0], [-15.0], [-13.0], [np.inf]]]}, test.internals['inout_0_0']['state']) - self.assertDictEqual({'inout': [[[7.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, test.internals['inout_0_1']['state']) - self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, test.internals['inout_0_2']['state']) + dataset3 = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2], [6, 5], [4, 5], [0, 0]], + "target": [3, 4, 5, 1, 3, 0, 1, 0], + "inout": [9, 8, 7, 6, 5, 4, 3, 2], + } + test.loadData(name="dataset3", source=dataset3) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=2, + ) + self.assertDictEqual( + {"inout": [[[8.0], [7.0], [-15.0], [-13.0], [np.inf]]]}, + test.internals["inout_0_0"]["state"], + ) + self.assertDictEqual( + {"inout": [[[7.0], [-15.0], [-13.0], [-30.0], [np.inf]]]}, + test.internals["inout_0_1"]["state"], + ) + self.assertDictEqual( + {"inout": [[[-15.0], [-13.0], [-30.0], [-28.0], [np.inf]]]}, + test.internals["inout_0_2"]["state"], + ) # Replace insead of rolling # self.assertDictEqual({'inout': [[[8.0], [7.0], [-15.0], [-13.0], [9.0]]]}, test.internals['inout_0_0']['state']) # self.assertDictEqual({'inout': [[[7.0], [-15.0], [-13.0], [-30.0], [8.0]]]}, test.internals['inout_0_1']['state']) # self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [7.0]]]}, test.internals['inout_0_2']['state']) - W = test.internals['inout_1_0']['param']['W'] - b = test.internals['inout_1_0']['param']['b'] - self.assertAlmostEqual({'inout': [[[7.0], [6.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], [np.inf]]]}, - test.internals['inout_1_0']['state']) - self.assertAlmostEqual({'inout': [[[6.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [np.inf]]]}, - test.internals['inout_1_1']['state']) - self.assertAlmostEqual({'inout': [ - [[W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], [np.inf]]]}, - test.internals['inout_1_2']['state']) + W = test.internals["inout_1_0"]["param"]["W"] + b = test.internals["inout_1_0"]["param"]["b"] + self.assertAlmostEqual( + { + "inout": [ + [ + [7.0], + [6.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_0"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [6.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_1"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], + [np.inf], + ] + ] + }, + test.internals["inout_1_2"]["state"], + ) # replace insead of rolling # self.assertAlmostEqual({'inout': [[[7.0], [6.0], [W[0][0][0] * 4.0 + W[0][1][0] * 2.0 + b[0][0]], # [W[0][0][0] * 6.0 + W[0][1][0] * 5.0 + b[0][0]], [8.0]]]}, @@ -774,184 +1494,411 @@ def test_training_values_fir_connect_linear_more_window(self): def test_training_values_fir_connect_train_linear_more_window(self): NeuObj.clearNames() - input1 = Input('in1', dimensions=2) - W = Parameter('W', values=[[-1], [-5]]) - b = Parameter('b', values=[1]) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) lin_out = Linear(W=W, b=b)(input1.sw(2)) - output1 = Output('out1', lin_out) + output1 = Output("out1", lin_out) - inout = Input('inout') - a = Parameter('a', sw=2, values=[[4], [5]]) - a_big = Parameter('ab', sw=5, values=[[1], [2], [3], [4], [5]]) - output2 = Output('out2', Fir(W=a)(inout.sw(2))) - output3 = Output('out3', Fir(W=a_big)(inout.sw(5))) - output4 = Output('out4', Fir(W=a)(lin_out)) + inout = Input("inout") + a = Parameter("a", sw=2, values=[[4], [5]]) + a_big = Parameter("ab", sw=5, values=[[1], [2], [3], [4], [5]]) + output2 = Output("out2", Fir(W=a)(inout.sw(2))) + output3 = Output("out3", Fir(W=a_big)(inout.sw(5))) + output4 = Output("out4", Fir(W=a)(lin_out)) - target = Input('target') + target = Input("target") test = Modely(visualizer=None, seed=42, log_internal=True) - test.addModel('model', [output1, output2, output3, output4]) - test.addMinimize('error2', target.last(), output2) + test.addModel("model", [output1, output2, output3, output4]) + test.addMinimize("error2", target.last(), output2) test.neuralizeModel() # Dataset with only one sample - dataset = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2]], 'target': [3,4,5,1,3]} - self.assertEqual({'out1': [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0]], - 'out2': [-96.0, -194.0, -179.0, -125.0], - 'out3': [-96.0, -206.0, -235.0, -239.0], - 'out4': [-96.0, -194.0, -179.0, -125.0] - }, test(dataset, connect={'inout':'out1'})) - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[-1], [-5]], test.parameters['W']) - self.assertListEqual([1], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, connect={'inout':'out1'}) - self.assertListEqual([[6143], [5627]], test.parameters['W']) - self.assertListEqual([2305], test.parameters['b']) - self.assertListEqual([[-3836], [-3323]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + dataset = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2]], + "target": [3, 4, 5, 1, 3], + } + self.assertEqual( + { + "out1": [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0]], + "out2": [-96.0, -194.0, -179.0, -125.0], + "out3": [-96.0, -206.0, -235.0, -239.0], + "out4": [-96.0, -194.0, -179.0, -125.0], + }, + test(dataset, connect={"inout": "out1"}), + ) + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + connect={"inout": "out1"}, + ) + self.assertListEqual([[6143], [5627]], test.parameters["W"]) + self.assertListEqual([2305], test.parameters["b"]) + self.assertListEqual([[-3836], [-3323]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) with self.assertRaises(KeyError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10, connect={'inout':'out1'}) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + connect={"inout": "out1"}, + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1, connect={'inout':'out1'}) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=1, + connect={"inout": "out1"}, + ) # Data set with more samples test.neuralizeModel(clear_model=True) - dataset2 = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2],[6,5],[4,5],[0,0]], 'target': [3,4,5,1,3,0,1,0]} - test.loadData(name='dataset2', source=dataset2) + dataset2 = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2], [6, 5], [4, 5], [0, 0]], + "target": [3, 4, 5, 1, 3, 0, 1, 0], + } + test.loadData(name="dataset2", source=dataset2) self.maxDiff = None - self.assertEqual({'out1': [[-4.0, -16.0], [-16.0, -26.0], [-26.0, -15.0], [-15.0, -13.0], [-13.0, -30.0], [-30.0, -28.0], [-28.0, 1.0]], - 'out2': [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], - 'out3': [-96.0, -206.0, -235.0, -239.0, -315.0, -355.0, -238.0], - 'out4': [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0] - }, test(dataset2, connect={'inout':'out1'})) + self.assertEqual( + { + "out1": [ + [-4.0, -16.0], + [-16.0, -26.0], + [-26.0, -15.0], + [-15.0, -13.0], + [-13.0, -30.0], + [-30.0, -28.0], + [-28.0, 1.0], + ], + "out2": [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], + "out3": [-96.0, -206.0, -235.0, -239.0, -315.0, -355.0, -238.0], + "out4": [-96.0, -194.0, -179.0, -125.0, -202.0, -260.0, -107.0], + }, + test(dataset2, connect={"inout": "out1"}), + ) # Use a train_batch_size of 4 # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1, connect={'inout':'out1'}) TODO add this test - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, connect={'inout':'out1'}) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertListEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + connect={"inout": "out1"}, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertListEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4, connect={'inout':'out1'}) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertListEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + connect={"inout": "out1"}, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertListEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Use a small batch but with a prediction sample of 3 = to 4 samples test.neuralizeModel(clear_model=True) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=4, connect={'inout':'out1'}) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3, connect={'inout':'out1'}) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertListEqual([3142], test.parameters['b']) - self.assertListEqual([[-7682], [-7457.5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=4, + connect={"inout": "out1"}, + ) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertListEqual([3142], test.parameters["b"]) + self.assertListEqual([[-7682], [-7457.5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Different minimize - test.removeMinimize('error2') - test.addMinimize('error3', target.last(), output3) + test.removeMinimize("error2") + test.addMinimize("error3", target.last(), output3) test.neuralizeModel(clear_model=True) - self.assertListEqual([[-1], [-5]], test.parameters['W']) - self.assertListEqual([1], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters['ab']) + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [4], [5]], test.parameters["ab"]) # Use a train_batch_size of 4 - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, connect={'inout':'out1'}) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertListEqual([3142], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + connect={"inout": "out1"}, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertListEqual([3142], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4, connect={'inout':'out1'}) - self.assertListEqual([[12779], [11678.5]], test.parameters['W']) - self.assertListEqual([3142], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters['ab']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + connect={"inout": "out1"}, + ) + self.assertListEqual([[12779], [11678.5]], test.parameters["W"]) + self.assertListEqual([3142], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual([[1], [2], [3], [-7682], [-7457.5]], test.parameters["ab"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3, connect={'inout':'out1'}) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]]],test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]],test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]],test.internals['inout_0_2']['XY']['in1']) - self.assertListEqual([[[4.0, 5.0], [0.0, 0.0]]],test.internals['inout_0_3']['XY']['in1']) - self.assertListEqual([[[3.0]]],test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]]],test.internals['inout_0_1']['XY']['target']) - self.assertListEqual([[[1.0]]],test.internals['inout_0_2']['XY']['target']) - self.assertListEqual([[[0.0]]],test.internals['inout_0_3']['XY']['target']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + connect={"inout": "out1"}, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]]], test.internals["inout_0_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_0_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_0_2"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 5.0], [0.0, 0.0]]], test.internals["inout_0_3"]["XY"]["in1"] + ) + self.assertListEqual([[[3.0]]], test.internals["inout_0_0"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_1"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_0_2"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_3"]["XY"]["target"]) + self.assertDictEqual( + { + "out1": [[[-15.0], [-13.0]]], + "out2": [[[-125.0]]], + "out3": [[[-125.0]]], + "out4": [[[-125.0]]], + }, + test.internals["inout_0_0"]["out"], + ) self.assertDictEqual( - {'out1': [[[-15.0], [-13.0]]], 'out2': [[[-125.0]]], 'out3': [[[-125.0]]], 'out4': [[[-125.0]]]}, - test.internals['inout_0_0']['out']) + { + "out1": [[[-13.0], [-30.0]]], + "out2": [[[-202.0]]], + "out3": [[[-247.0]]], + "out4": [[[-202.0]]], + }, + test.internals["inout_0_1"]["out"], + ) self.assertDictEqual( - {'out1': [[[-13.0], [-30.0]]], 'out2': [[[-202.0]]], 'out3': [[[-247.0]]], 'out4': [[[-202.0]]]}, - test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], - 'out2': [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], - 'out3': [[[(-15) * 3.0 + (4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], - 'out4': [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]]}, - test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], - 'out2': [[[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]]], - 'out3': [[[(-15) * 2.0 + (4 * -1 + 2 * -5 + 1.0) * 3.0 + (6 * -1 + 5 * -5 + 1.0) * 4.0 + ( - 4 * -1 + 5 * -5 + 1.0) * 5.0]]], - 'out4': [[[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]]]}, - test.internals['inout_0_2']['out']) - self.assertDictEqual({'out1': [[[4 * -1 + 5 * -5 + 1.0], [0 * -1 + 0 * -5 + 1.0]]], - 'out2': [[[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]]], - 'out3': [[[(-15) * 1.0 + (4 * -1 + 2 * -5 + 1.0) * 2.0 + (6 * -1 + 5 * -5 + 1.0) * 3.0 + ( - 4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]]], - 'out4': [[[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]]]}, - test.internals['inout_0_3']['out']) - self.assertListEqual([[22273.5], [20993.0]], test.parameters['W']) - self.assertListEqual([6154.0], test.parameters['b']) - self.assertListEqual([[4], [5]], test.parameters['a']) - self.assertListEqual([[-1784.0], [-4020.0], [-7564.5], [-10843.5], [-9033.0]], - test.parameters['ab']) + { + "out1": [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], + "out2": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + "out3": [ + [ + [ + (-15) * 3.0 + + (4 * -1 + 2 * -5 + 1.0) * 4 + + (6 * -1 + 5 * -5 + 1.0) * 5 + ] + ] + ], + "out4": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], + "out2": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 2.0 + + (4 * -1 + 2 * -5 + 1.0) * 3.0 + + (6 * -1 + 5 * -5 + 1.0) * 4.0 + + (4 * -1 + 5 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_2"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[4 * -1 + 5 * -5 + 1.0], [0 * -1 + 0 * -5 + 1.0]]], + "out2": [ + [[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 1.0 + + (4 * -1 + 2 * -5 + 1.0) * 2.0 + + (6 * -1 + 5 * -5 + 1.0) * 3.0 + + (4 * -1 + 5 * -5 + 1.0) * 4.0 + + (0 * -1 + 0 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(4 * -1 + 5 * -5 + 1.0) * 4.0 + (0 * -1 + 0 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_3"]["out"], + ) + self.assertListEqual([[22273.5], [20993.0]], test.parameters["W"]) + self.assertListEqual([6154.0], test.parameters["b"]) + self.assertListEqual([[4], [5]], test.parameters["a"]) + self.assertListEqual( + [[-1784.0], [-4020.0], [-7564.5], [-10843.5], [-9033.0]], + test.parameters["ab"], + ) with self.assertRaises(KeyError): - test.internals['inout_1_0'] + test.internals["inout_1_0"] test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, - train_batch_size=1, - prediction_samples=2, connect={'inout':'out1'}) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]]],test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]],test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]],test.internals['inout_0_2']['XY']['in1']) - self.assertListEqual([[[3.0]]],test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]]],test.internals['inout_0_1']['XY']['target']) - self.assertListEqual([[[1.0]]],test.internals['inout_0_2']['XY']['target']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=2, + connect={"inout": "out1"}, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]]], test.internals["inout_0_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_0_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_0_2"]["XY"]["in1"] + ) + self.assertListEqual([[[3.0]]], test.internals["inout_0_0"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_0_1"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_0_2"]["XY"]["target"]) + self.assertDictEqual( + { + "out1": [[[-15.0], [-13.0]]], + "out2": [[[-125.0]]], + "out3": [[[-125.0]]], + "out4": [[[-125.0]]], + }, + test.internals["inout_0_0"]["out"], + ) self.assertDictEqual( - {'out1': [[[-15.0], [-13.0]]], 'out2': [[[-125.0]]], 'out3': [[[-125.0]]], 'out4': [[[-125.0]]]}, - test.internals['inout_0_0']['out']) + { + "out1": [[[-13.0], [-30.0]]], + "out2": [[[-202.0]]], + "out3": [[[-247.0]]], + "out4": [[[-202.0]]], + }, + test.internals["inout_0_1"]["out"], + ) self.assertDictEqual( - {'out1': [[[-13.0], [-30.0]]], 'out2': [[[-202.0]]], 'out3': [[[-247.0]]], 'out4': [[[-202.0]]]}, - test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], - 'out2': [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], - 'out3': [[[(-15) * 3.0 + (4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], - 'out4': [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]]}, - test.internals['inout_0_1']['out']) - self.assertDictEqual({'out1': [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], - 'out2': [[[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]]], - 'out3': [[[(-15) * 2.0 + (4 * -1 + 2 * -5 + 1.0) * 3.0 + (6 * -1 + 5 * -5 + 1.0) * 4.0 + ( - 4 * -1 + 5 * -5 + 1.0) * 5.0]]], - 'out4': [[[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]]]}, - test.internals['inout_0_2']['out']) - W = test.internals['inout_1_0']['param']['W'] - b = test.internals['inout_1_0']['param']['b'] - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]]],test.internals['inout_1_0']['XY']['in1']) - self.assertListEqual([[[6.0, 5.0], [4.0, 5.0]]],test.internals['inout_1_1']['XY']['in1']) - self.assertListEqual([[[4.0, 5.0], [0.0, 0.0]]],test.internals['inout_1_2']['XY']['in1']) - self.assertListEqual([[[0.0]]],test.internals['inout_1_0']['XY']['target']) - self.assertListEqual([[[1.0]]],test.internals['inout_1_1']['XY']['target']) - self.assertListEqual([[[0.0]]],test.internals['inout_1_2']['XY']['target']) + { + "out1": [[[4 * -1 + 2 * -5 + 1.0], [6 * -1 + 5 * -5 + 1.0]]], + "out2": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + "out3": [ + [ + [ + (-15) * 3.0 + + (4 * -1 + 2 * -5 + 1.0) * 4 + + (6 * -1 + 5 * -5 + 1.0) * 5 + ] + ] + ], + "out4": [[[(4 * -1 + 2 * -5 + 1.0) * 4 + (6 * -1 + 5 * -5 + 1.0) * 5]]], + }, + test.internals["inout_0_1"]["out"], + ) + self.assertDictEqual( + { + "out1": [[[6 * -1 + 5 * -5 + 1.0], [4 * -1 + 5 * -5 + 1.0]]], + "out2": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + "out3": [ + [ + [ + (-15) * 2.0 + + (4 * -1 + 2 * -5 + 1.0) * 3.0 + + (6 * -1 + 5 * -5 + 1.0) * 4.0 + + (4 * -1 + 5 * -5 + 1.0) * 5.0 + ] + ] + ], + "out4": [ + [[(6 * -1 + 5 * -5 + 1.0) * 4.0 + (4 * -1 + 5 * -5 + 1.0) * 5.0]] + ], + }, + test.internals["inout_0_2"]["out"], + ) + W = test.internals["inout_1_0"]["param"]["W"] + b = test.internals["inout_1_0"]["param"]["b"] + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]]], test.internals["inout_1_0"]["XY"]["in1"] + ) + self.assertListEqual( + [[[6.0, 5.0], [4.0, 5.0]]], test.internals["inout_1_1"]["XY"]["in1"] + ) + self.assertListEqual( + [[[4.0, 5.0], [0.0, 0.0]]], test.internals["inout_1_2"]["XY"]["in1"] + ) + self.assertListEqual([[[0.0]]], test.internals["inout_1_0"]["XY"]["target"]) + self.assertListEqual([[[1.0]]], test.internals["inout_1_1"]["XY"]["target"]) + self.assertListEqual([[[0.0]]], test.internals["inout_1_2"]["XY"]["target"]) # self.assertAlmostEqual({'inout': [[[0.0], [0.0], [0.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], # [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]]]]}, # test.internals['inout_1_0']['state']) @@ -963,48 +1910,117 @@ def test_training_values_fir_connect_train_linear_more_window(self): # [[0.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], # [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]]]]}, # test.internals['inout_1_2']['state']) - self.assertAlmostEqual({'inout': [[[0.0], [0.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_0']['state']) - self.assertAlmostEqual({'inout': [[[0.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_1']['state']) - self.assertAlmostEqual({'inout': [ - [[W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_2']['state']) + self.assertAlmostEqual( + { + "inout": [ + [ + [0.0], + [0.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_0"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [0.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_1"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_2"]["state"], + ) with self.assertRaises(KeyError): - test.internals['inout_2_0'] + test.internals["inout_2_0"] test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, - train_batch_size=2, prediction_samples=1, connect={'inout':'out1'}) - self.assertListEqual([[[1.0, 3.0], [4.0, 2.0]], [[4.0, 2.0], [6.0, 5.0]]],test.internals['inout_0_0']['XY']['in1']) - self.assertListEqual([[[4.0, 2.0], [6.0, 5.0]], [[6.0, 5.0], [4.0, 5.0]]],test.internals['inout_0_1']['XY']['in1']) - self.assertListEqual([[[3.0]], [[0.0]]],test.internals['inout_0_0']['XY']['target']) - self.assertListEqual([[[0.0]], [[1.0]]],test.internals['inout_0_1']['XY']['target']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=2, + prediction_samples=1, + connect={"inout": "out1"}, + ) + self.assertListEqual( + [[[1.0, 3.0], [4.0, 2.0]], [[4.0, 2.0], [6.0, 5.0]]], + test.internals["inout_0_0"]["XY"]["in1"], + ) + self.assertListEqual( + [[[4.0, 2.0], [6.0, 5.0]], [[6.0, 5.0], [4.0, 5.0]]], + test.internals["inout_0_1"]["XY"]["in1"], + ) + self.assertListEqual( + [[[3.0]], [[0.0]]], test.internals["inout_0_0"]["XY"]["target"] + ) + self.assertListEqual( + [[[0.0]], [[1.0]]], test.internals["inout_0_1"]["XY"]["target"] + ) with self.assertRaises(KeyError): - test.internals['inout_1_0'] + test.internals["inout_1_0"] test.neuralizeModel(clear_model=True) - dataset3 = {'in1': [[0,1],[2,3],[7,4],[1,3],[4,2],[6,5],[4,5],[0,0]], 'target': [3,4,5,1,3,0,1,0], 'inout':[9,8,7,6,5,4,3,2]} - test.loadData(name='dataset3', source=dataset3) - test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=0.01, shuffle_data=False, num_of_epochs=1, - train_batch_size=1, - prediction_samples=2, connect={'inout':'out1'}) + dataset3 = { + "in1": [[0, 1], [2, 3], [7, 4], [1, 3], [4, 2], [6, 5], [4, 5], [0, 0]], + "target": [3, 4, 5, 1, 3, 0, 1, 0], + "inout": [9, 8, 7, 6, 5, 4, 3, 2], + } + test.loadData(name="dataset3", source=dataset3) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + lr=0.01, + shuffle_data=False, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=2, + connect={"inout": "out1"}, + ) # self.assertDictEqual({'inout': [[[8.0], [7.0], [6.0], [-15.0], [-13.0]]]}, test.internals['inout_0_0']['state']) # self.assertDictEqual({'inout': [[[7.0], [6.0], [-15.0], [-13.0], [-30.0]]]}, test.internals['inout_0_1']['state']) # self.assertDictEqual({'inout': [[[6.0], [-15.0], [-13.0], [-30.0], [-28.0]]]}, test.internals['inout_0_2']['state']) - self.assertDictEqual({'inout': [[[8.0], [7.0], [-15.0], [-13.0], [float('inf')]]]}, test.internals['inout_0_0']['state']) - self.assertDictEqual({'inout': [[[7.0], [-15.0], [-13.0], [-30.0], [float('inf')]]]}, test.internals['inout_0_1']['state']) - self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [float('inf')]]]}, test.internals['inout_0_2']['state']) + self.assertDictEqual( + {"inout": [[[8.0], [7.0], [-15.0], [-13.0], [float("inf")]]]}, + test.internals["inout_0_0"]["state"], + ) + self.assertDictEqual( + {"inout": [[[7.0], [-15.0], [-13.0], [-30.0], [float("inf")]]]}, + test.internals["inout_0_1"]["state"], + ) + self.assertDictEqual( + {"inout": [[[-15.0], [-13.0], [-30.0], [-28.0], [float("inf")]]]}, + test.internals["inout_0_2"]["state"], + ) # Replace instead of rolling # self.assertDictEqual({'inout': [[[8.0], [7.0], [-15.0], [-13.0], [9.0]]]}, test.internals['inout_0_0']['connect']) # self.assertDictEqual({'inout': [[[7.0], [-15.0], [-13.0], [-30.0], [8.0]]]}, test.internals['inout_0_1']['connect']) # self.assertDictEqual({'inout': [[[-15.0], [-13.0], [-30.0], [-28.0], [7.0]]]}, test.internals['inout_0_2']['connect']) - W = test.internals['inout_1_0']['param']['W'] - b = test.internals['inout_1_0']['param']['b'] + W = test.internals["inout_1_0"]["param"]["W"] + b = test.internals["inout_1_0"]["param"]["b"] # self.assertAlmostEqual({'inout': [[[7.0], [6.0], [5.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], # [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]]]]}, # test.internals['inout_1_0']['state']) @@ -1017,249 +2033,396 @@ def test_training_values_fir_connect_train_linear_more_window(self): # [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]]]]}, # test.internals['inout_1_2']['state']) # Replace insead of rolling - self.assertAlmostEqual({'inout': [[[7.0], [6.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_0']['state']) - self.assertAlmostEqual({'inout': [[[6.0], [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], - [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_1']['state']) - self.assertAlmostEqual({'inout': [ - [[W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], - [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], [float('inf')]]]}, - test.internals['inout_1_2']['state']) + self.assertAlmostEqual( + { + "inout": [ + [ + [7.0], + [6.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_0"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [6.0], + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_1"]["state"], + ) + self.assertAlmostEqual( + { + "inout": [ + [ + [W[0][0] * 4.0 + W[1][0] * 2.0 + b[0]], + [W[0][0] * 6.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 4.0 + W[1][0] * 5.0 + b[0]], + [W[0][0] * 0.0 + W[1][0] * 0.0 + b[0]], + [float("inf")], + ] + ] + }, + test.internals["inout_1_2"]["state"], + ) def test_training_values_fir_and_liner_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1') - target_out1 = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) + input1 = Input("in1") + target_out1 = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) relation1 = Fir(W=a)(input1.last()) relation1.closedLoop(input1) - output1 = Output('out1', relation1) + output1 = Output("out1", relation1) - input2 = Input('in2') - target_out2 = Input('target2') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - relation2 = Linear(W=W,b=b)(input2.last()) + input2 = Input("in2") + target_out2 = Input("target2") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + relation2 = Linear(W=W, b=b)(input2.last()) relation2.closedLoop(input2) - output2 = Output('out2', relation2) + output2 = Output("out2", relation2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', target_out1.last(), output1) - test.addMinimize('error2', target_out2.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", target_out1.last(), output1) + test.addMinimize("error2", target_out2.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [0.0], 'out2': [1.0]}, test()) - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1.0],'in2': [1.0]})) - self.assertEqual({'out1': [1.0], 'out2': [3.0]}, test()) + self.assertEqual({"out1": [0.0], "out2": [1.0]}, test()) + self.assertEqual( + {"out1": [1.0], "out2": [2.0]}, test({"in1": [1.0], "in2": [1.0]}) + ) + self.assertEqual({"out1": [1.0], "out2": [3.0]}, test()) test.resetStates() - self.assertEqual({'out1': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'out2': [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, test(prediction_samples=5, num_of_samples=6)) - - dataset = {'in1': [1], 'in2': [1.0], 'target1': [3], 'target2': [3]} - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertEqual( + { + "out1": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + "out2": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0], + }, + test(prediction_samples=5, num_of_samples=6), + ) + + dataset = {"in1": [1], "in2": [1.0], "target1": [3], "target2": [3]} + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - - dataset = {'in1': [1.0,1.0], 'in2': [1.0,1.0], 'target1': [3.0,3.0], 'target2': [3.0,3.0]} - test.loadData(name='dataset2', source=dataset) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=2) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + + dataset = { + "in1": [1.0, 1.0], + "in2": [1.0, 1.0], + "target1": [3.0, 3.0], + "target2": [3.0, 3.0], + } + test.loadData(name="dataset2", source=dataset) test.neuralizeModel(clear_model=True) # the out is 3.0 due the mean of the error is not the same of two epochs - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertListEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", optimizer="SGD", lr=1, num_of_epochs=1 + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertListEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=2) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertListEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", optimizer="SGD", lr=1, num_of_epochs=2 + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertListEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) def test_training_values_fir_and_liner_train_closed_loop(self): NeuObj.clearNames() - input1 = Input('in1') - target_out1 = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1',Fir(W=a)(input1.last())) + input1 = Input("in1") + target_out1 = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1", Fir(W=a)(input1.last())) - input2 = Input('in2') - target_out2 = Input('target2') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=1) - output2 = Output('out2', Linear(W=W,b=b)(input2.last())) + input2 = Input("in2") + target_out2 = Input("target2") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=1) + output2 = Output("out2", Linear(W=W, b=b)(input2.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', target_out1.last(), output1) - test.addMinimize('error2', target_out2.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", target_out1.last(), output1) + test.addMinimize("error2", target_out2.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [0.0], 'out2': [1.0]}, test(closed_loop={'in1':'out1','in2':'out2'})) - self.assertEqual({'out1': [1.0], 'out2': [2.0]}, test({'in1': [1.0],'in2': [1.0]},closed_loop={'in1':'out1','in2':'out2'})) + self.assertEqual( + {"out1": [0.0], "out2": [1.0]}, + test(closed_loop={"in1": "out1", "in2": "out2"}), + ) + self.assertEqual( + {"out1": [1.0], "out2": [2.0]}, + test( + {"in1": [1.0], "in2": [1.0]}, closed_loop={"in1": "out1", "in2": "out2"} + ), + ) # # The memory is reset for each call - self.assertEqual({'out1': [0.0], 'out2': [1.0]}, test(closed_loop={'in1':'out1', 'in2':'out2'})) - - dataset = {'in1': [1], 'in2': [1.0], 'target1': [3], 'target2': [3]} - test.loadData(name='dataset', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertEqual( + {"out1": [0.0], "out2": [1.0]}, + test(closed_loop={"in1": "out1", "in2": "out2"}), + ) + + dataset = {"in1": [1], "in2": [1.0], "target1": [3], "target2": [3]} + test.loadData(name="dataset", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=1, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=1) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) + test.trainModel(optimizer="SGD", splits=[100, 0, 0], lr=1, num_of_epochs=1) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(optimizer='SGD', splits=[100, 0, 0], lr=1, num_of_epochs=2, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - - dataset = {'in1': [1.0,1.0], 'in2': [1.0,1.0], 'target1': [3.0,3.0], 'target2': [3.0,3.0]} - test.loadData(name='dataset2', source=dataset) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + optimizer="SGD", + splits=[100, 0, 0], + lr=1, + num_of_epochs=2, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + + dataset = { + "in1": [1.0, 1.0], + "in2": [1.0, 1.0], + "target1": [3.0, 3.0], + "target2": [3.0, 3.0], + } + test.loadData(name="dataset2", source=dataset) test.neuralizeModel(clear_model=True) # the out is 3.0 due the mean of the error is not the same of two epochs - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[3.0]], test.parameters['W']) - self.assertEqual([3.0], test.parameters['b']) - self.assertListEqual([[5.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[3.0]], test.parameters["W"]) + self.assertEqual([3.0], test.parameters["b"]) + self.assertListEqual([[5.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=2, closed_loop={'in1':'out1','in2':'out2'}) - self.assertListEqual([[-3.0]], test.parameters['W']) - self.assertEqual([-3.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=2, + closed_loop={"in1": "out1", "in2": "out2"}, + ) + self.assertListEqual([[-3.0]], test.parameters["W"]) + self.assertEqual([-3.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) def test_training_values_fir_and_linear_closed_loop_more_prediction(self): NeuObj.clearNames() - input1 = Input('in1') - target_out1 = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) + input1 = Input("in1") + target_out1 = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) relation1 = Fir(W=a)(input1.last()) relation1.closedLoop(input1) - output1 = Output('out1',relation1) + output1 = Output("out1", relation1) - input2 = Input('in2') - target_out2 = Input('target2') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - relation2=Linear(W=W,b=b)(input2.last()) + input2 = Input("in2") + target_out2 = Input("target2") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + relation2 = Linear(W=W, b=b)(input2.last()) relation2.closedLoop(input2) - output2 = Output('out2', relation2) + output2 = Output("out2", relation2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', target_out1.last(), output1) - test.addMinimize('error2', target_out2.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", target_out1.last(), output1) + test.addMinimize("error2", target_out2.last(), output2) test.neuralizeModel() - self.assertEqual({'out1': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'out2': [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, - test(prediction_samples=5, num_of_samples=6)) - #self.assertEqual({'out1': [1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0], 'out2': [7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0]}, + self.assertEqual( + { + "out1": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + "out2": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0], + }, + test(prediction_samples=5, num_of_samples=6), + ) + # self.assertEqual({'out1': [1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0], 'out2': [7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0]}, # test({'in1':[1.0,2.0]},prediction_samples=5)) - self.assertEqual({'out1': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0], 'out2': [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 1.0]}, - test({'in1': [1.0, 2.0]}, prediction_samples=5, num_of_samples=7)) - #self.assertEqual({'out1': [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0], 'out2': [0.0, -1.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0]}, + self.assertEqual( + { + "out1": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0], + "out2": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 1.0], + }, + test({"in1": [1.0, 2.0]}, prediction_samples=5, num_of_samples=7), + ) + # self.assertEqual({'out1': [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0], 'out2': [0.0, -1.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0]}, # test({'in2':[-1.0,-2.0,-3.0]},prediction_samples=5)) - self.assertEqual({'out1': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'out2': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0]}, - test({'in2':[-1.0,-2.0,-3.0]}, prediction_samples=5, num_of_samples=8)) - - dataset = {'in1': [0,2,7,1], 'in2': [-1,0,-3,7], 'target1': [3,4,5,1], 'target2': [-3,-4,-5,-1]} - test.loadData(name='dataset2', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[-24.5]], test.parameters['W']) - self.assertListEqual([-9.0], test.parameters['b']) - self.assertListEqual([[-4.0]], test.parameters['a']) + self.assertEqual( + { + "out1": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + "out2": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0], + }, + test({"in2": [-1.0, -2.0, -3.0]}, prediction_samples=5, num_of_samples=8), + ) + + dataset = { + "in1": [0, 2, 7, 1], + "in2": [-1, 0, -3, 7], + "target1": [3, 4, 5, 1], + "target2": [-3, -4, -5, -1], + } + test.loadData(name="dataset2", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[-24.5]], test.parameters["W"]) + self.assertListEqual([-9.0], test.parameters["b"]) + self.assertListEqual([[-4.0]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1) - self.assertListEqual([[-24.5]], test.parameters['W']) - self.assertListEqual([-9.0], test.parameters['b']) - self.assertListEqual([[-4.0]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", optimizer="SGD", lr=1, num_of_epochs=1 + ) + self.assertListEqual([[-24.5]], test.parameters["W"]) + self.assertListEqual([-9.0], test.parameters["b"]) + self.assertListEqual([[-4.0]], test.parameters["a"]) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + ) # test.neuralizeModel(clear_model=True) # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1) # self.assertListEqual([[[1.0]]], test.parameters['W']) # self.assertListEqual([[1.0]], test.parameters['b']) # self.assertListEqual([[1.0]], test.parameters['a']) test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([-24.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([-24.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) # test.neuralizeModel(clear_model=True) # self.assertListEqual([[[1.0]]],test.parameters['W']) @@ -1272,50 +2435,97 @@ def test_training_values_fir_and_linear_closed_loop_more_prediction(self): def test_training_values_fir_and_linear_train_closed_loop_more_prediction(self): NeuObj.clearNames() - input1 = Input('in1') - target_out1 = Input('target1') - a = Parameter('a', sw=1, values=[[1]]) - output1 = Output('out1',Fir(W=a)(input1.last())) + input1 = Input("in1") + target_out1 = Input("target1") + a = Parameter("a", sw=1, values=[[1]]) + output1 = Output("out1", Fir(W=a)(input1.last())) - input2 = Input('in2') - target_out2 = Input('target2') - W = Parameter('W', values=[[1]]) - b = Parameter('b', values=[1]) - output2 = Output('out2', Linear(W=W,b=b)(input2.last())) + input2 = Input("in2") + target_out2 = Input("target2") + W = Parameter("W", values=[[1]]) + b = Parameter("b", values=[1]) + output2 = Output("out2", Linear(W=W, b=b)(input2.last())) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', target_out1.last(), output1) - test.addMinimize('error2', target_out2.last(), output2) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", target_out1.last(), output1) + test.addMinimize("error2", target_out2.last(), output2) test.neuralizeModel() # self.assertEqual({'out1': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'out2': [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, # test(prediction_samples=5, closed_loop={'in2':'out2','in1':'out1'}, _num_of_samples=6)) - self.assertEqual({'out1': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0], 'out2': [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 1.0]}, - test({'in1':[1.0, 2.0]}, prediction_samples=5, closed_loop={'in2':'out2','in1':'out1'}, num_of_samples=7)) - self.assertEqual({'out1': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 'out2': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0]}, - test({'in2':[-1.0,-2.0,-3.0]}, prediction_samples=5, closed_loop={'in2':'out2','in1':'out1'}, num_of_samples=8)) - - dataset = {'in1': [0,2,7,1], 'in2': [-1,0,-3,7], 'target1': [3,4,5,1], 'target2': [-3,-4,-5,-1]} - test.loadData(name='dataset2', source=dataset) - - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, closed_loop={'in2':'out2','in1':'out1'}) - self.assertListEqual([[-24.5]], test.parameters['W']) - self.assertListEqual([-9.0], test.parameters['b']) - self.assertListEqual([[-4.0]], test.parameters['a']) + self.assertEqual( + { + "out1": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0], + "out2": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 1.0], + }, + test( + {"in1": [1.0, 2.0]}, + prediction_samples=5, + closed_loop={"in2": "out2", "in1": "out1"}, + num_of_samples=7, + ), + ) + self.assertEqual( + { + "out1": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + "out2": [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0], + }, + test( + {"in2": [-1.0, -2.0, -3.0]}, + prediction_samples=5, + closed_loop={"in2": "out2", "in1": "out1"}, + num_of_samples=8, + ), + ) + + dataset = { + "in1": [0, 2, 7, 1], + "in2": [-1, 0, -3, 7], + "target1": [3, 4, 5, 1], + "target2": [-3, -4, -5, -1], + } + test.loadData(name="dataset2", source=dataset) + + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + closed_loop={"in2": "out2", "in1": "out1"}, + ) + self.assertListEqual([[-24.5]], test.parameters["W"]) + self.assertListEqual([-9.0], test.parameters["b"]) + self.assertListEqual([[-4.0]], test.parameters["a"]) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10, closed_loop={'in2':'out2','in1':'out1'}) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + closed_loop={"in2": "out2", "in1": "out1"}, + ) # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1, closed_loop={'in2':'out2','in1':'out1'}) # TODO add this test test.neuralizeModel(clear_model=True) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3, closed_loop={'in2':'out2','in1':'out1'}) - self.assertListEqual([[1.0]], test.parameters['W']) - self.assertListEqual([-24.0], test.parameters['b']) - self.assertListEqual([[1.0]], test.parameters['a']) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + closed_loop={"in2": "out2", "in1": "out1"}, + ) + self.assertListEqual([[1.0]], test.parameters["W"]) + self.assertListEqual([-24.0], test.parameters["b"]) + self.assertListEqual([[1.0]], test.parameters["a"]) # test.neuralizeModel(clear_model=True) # TODO add this test # self.assertListEqual([[[1.0]]],test.parameters['W']) @@ -1328,96 +2538,242 @@ def test_training_values_fir_and_linear_train_closed_loop_more_prediction(self): def test_training_values_fir_and_liner_closed_loop_bigger_window(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=[1]) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) relation1 = Linear(W=W, b=b)(input1.sw(2)) - input2 = Input('in2') - a = Parameter('a', sw=4, values=[[1,3],[2,4],[3,5],[4,6]]) - relation2 = Fir(output_dimension=2,W=a)(input2.sw(4)) + input2 = Input("in2") + a = Parameter("a", sw=4, values=[[1, 3], [2, 4], [3, 5], [4, 6]]) + relation2 = Fir(output_dimension=2, W=a)(input2.sw(4)) relation2.closedLoop(input1) relation1.closedLoop(input2) - output1 = Output('out1', relation1) - output2 = Output('out2', relation2) + output1 = Output("out1", relation1) + output2 = Output("out2", relation2) - target1 = Input('target1') - target2 = Input('target2', dimensions=2) + target1 = Input("target1") + target2 = Input("target2", dimensions=2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', output1, target1.sw(2)) - test.addMinimize('error2', output2, target2.last()) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", output1, target1.sw(2)) + test.addMinimize("error2", output2, target2.last()) test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], 'out2': [[[-49.0, -107.0]], [[-12.0, -46.0]], [[13.0, 15.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], 'in2': [-10, -16, -5, 2, 2, 2]})) - - dataset = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], 'in2': [-10, -16, -5, 2], - 'target1': [-11, -17, -12, -20], - 'target2': [[-34.0, -86.0], [-31.0, -90.0], [-32.0, -86.0], [-33.0, -84.0]]} - test.loadData(name='dataset', source=dataset) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], - 'out2': [[[-49.0, -107.0]], [[-120.0, -214.0]], [[-205.0, -333.0]]]}, - test(dataset)) - - self.assertListEqual([[-1],[-5]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1,3],[2,4],[3,5],[4,6]], test.parameters['a']) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[83.0],[105.0]], test.parameters['W']) - self.assertListEqual([6.0], test.parameters['b']) - self.assertListEqual([[-159.0, -227.0], [-254., -364.], [-77., -110.], [36., 52.]], test.parameters['a']) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], + "out2": [[[-49.0, -107.0]], [[-12.0, -46.0]], [[13.0, 15.0]]], + }, + test( + { + "in1": [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], + "in2": [-10, -16, -5, 2, 2, 2], + } + ), + ) + + dataset = { + "in1": [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], + "in2": [-10, -16, -5, 2], + "target1": [-11, -17, -12, -20], + "target2": [[-34.0, -86.0], [-31.0, -90.0], [-32.0, -86.0], [-33.0, -84.0]], + } + test.loadData(name="dataset", source=dataset) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], + "out2": [[[-49.0, -107.0]], [[-120.0, -214.0]], [[-205.0, -333.0]]], + }, + test(dataset), + ) + + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1, 3], [2, 4], [3, 5], [4, 6]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[83.0], [105.0]], test.parameters["W"]) + self.assertListEqual([6.0], test.parameters["b"]) + self.assertListEqual( + [[-159.0, -227.0], [-254.0, -364.0], [-77.0, -110.0], [36.0, 52.0]], + test.parameters["a"], + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=1, + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, minimize_gain={'error1':0}) - self.assertListEqual([[-1],[-5]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[-159.0, -227.0], [-254., -364.], [-77., -110.], [36., 52.]], test.parameters['a']) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + minimize_gain={"error1": 0}, + ) + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual( + [[-159.0, -227.0], [-254.0, -364.0], [-77.0, -110.0], [36.0, 52.0]], + test.parameters["a"], + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, minimize_gain={'error2':0}) - self.assertListEqual([[83.0],[105.0]], test.parameters['W']) - self.assertListEqual([6.0], test.parameters['b']) - self.assertListEqual([[1,3],[2,4],[3,5],[4,6]], test.parameters['a']) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + minimize_gain={"error2": 0}, + ) + self.assertListEqual([[83.0], [105.0]], test.parameters["W"]) + self.assertListEqual([6.0], test.parameters["b"]) + self.assertListEqual([[1, 3], [2, 4], [3, 5], [4, 6]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - dataset2 = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0], [0.0, 0.0], [0.0, 1.0], [1.0, 0.0]], 'in2': [-10, -16, -5, 2, 3, -3, 5], - 'target1':[-11,-17,-12,-20,5,1,0], - 'target2':[[-34.0, -86.0],[-31.0, -90.0],[-32.0, -86.0],[-33.0, -84.0],[-31.0, -84.0],[0.0, -84.0],[-31.0, 0.0]]} - test.loadData(name='dataset2', source=dataset2) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0],[-4.0,1.0],[1.0,-4.0],[-4.0,0.0]], - 'out2': [[[-49, -107]], [[-8, -40]], [[-4, -10]], [[19, 33]], [[-11, -17]], [[-24, -44]]]}, - test(dataset2)) + dataset2 = { + "in1": [ + [1.0, 2.0], + [2.0, 3.0], + [4.0, 6.0], + [0.0, 1.0], + [0.0, 0.0], + [0.0, 1.0], + [1.0, 0.0], + ], + "in2": [-10, -16, -5, 2, 3, -3, 5], + "target1": [-11, -17, -12, -20, 5, 1, 0], + "target2": [ + [-34.0, -86.0], + [-31.0, -90.0], + [-32.0, -86.0], + [-33.0, -84.0], + [-31.0, -84.0], + [0.0, -84.0], + [-31.0, 0.0], + ], + } + test.loadData(name="dataset2", source=dataset2) + self.assertEqual( + { + "out1": [ + [-10.0, -16.0], + [-16.0, -33.0], + [-33.0, -4.0], + [-4.0, 1.0], + [1.0, -4.0], + [-4.0, 0.0], + ], + "out2": [ + [[-49, -107]], + [[-8, -40]], + [[-4, -10]], + [[19, 33]], + [[-11, -17]], + [[-24, -44]], + ], + }, + test(dataset2), + ) # Use a train_batch_size of 4 # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1) # TODO Add this test - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0) - self.assertListEqual([[20.0], [21.0]], test.parameters['W']) - self.assertListEqual([2.75], test.parameters['b']) - self.assertListEqual([[23., 197.5], [-68.75, -94.75], [12., -76.5], [-70.75, -1.25]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + ) + self.assertListEqual([[20.0], [21.0]], test.parameters["W"]) + self.assertListEqual([2.75], test.parameters["b"]) + self.assertListEqual( + [[23.0, 197.5], [-68.75, -94.75], [12.0, -76.5], [-70.75, -1.25]], + test.parameters["a"], + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4) - self.assertListEqual([[20.0], [21.0]], test.parameters['W']) - self.assertListEqual([2.75], test.parameters['b']) - self.assertListEqual([[23., 197.5], [-68.75, -94.75], [12., -76.5], [-70.75, -1.25]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + ) + self.assertListEqual([[20.0], [21.0]], test.parameters["W"]) + self.assertListEqual([2.75], test.parameters["b"]) + self.assertListEqual( + [[23.0, 197.5], [-68.75, -94.75], [12.0, -76.5], [-70.75, -1.25]], + test.parameters["a"], + ) # Use a small batch but with a prediction sample of 3 = to 4 samples - dataset3 = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0], [0.0, 0.0], [0.0, 1.0], [1.0, 0.0]], 'in2': [-10, -16, -5, 2, 3, -3, 5], - 'target1':[-11, -17, -30, -2, 582, 1421, -18975], - 'target2':[[-34.0, -86.0],[-31.0, -90.0],[-32.0, -86.0],[-48, -106], [-140, -256], [2254, 3341], [7420, 11374]]} - test.loadData(name='dataset3', source=dataset3) + dataset3 = { + "in1": [ + [1.0, 2.0], + [2.0, 3.0], + [4.0, 6.0], + [0.0, 1.0], + [0.0, 0.0], + [0.0, 1.0], + [1.0, 0.0], + ], + "in2": [-10, -16, -5, 2, 3, -3, 5], + "target1": [-11, -17, -30, -2, 582, 1421, -18975], + "target2": [ + [-34.0, -86.0], + [-31.0, -90.0], + [-32.0, -86.0], + [-48, -106], + [-140, -256], + [2254, 3341], + [7420, 11374], + ], + } + test.loadData(name="dataset3", source=dataset3) test.neuralizeModel(clear_model=True) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=4) - test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3) - self.assertListEqual([[-3010.5],[-5211.25]], test.parameters['W']) - self.assertListEqual([199.5], test.parameters['b']) - self.assertListEqual([[252.75, 1172.5], [420.5, 1998.25], [-228.5, 627.5], [-626.75, 3036.5]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=4, + ) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + ) + self.assertListEqual([[-3010.5], [-5211.25]], test.parameters["W"]) + self.assertListEqual([199.5], test.parameters["b"]) + self.assertListEqual( + [[252.75, 1172.5], [420.5, 1998.25], [-228.5, 627.5], [-626.75, 3036.5]], + test.parameters["a"], + ) # test.neuralizeModel(clear_model=True) # test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=0.01, num_of_epochs=2, train_batch_size=2, prediction_samples=2) @@ -1427,90 +2783,246 @@ def test_training_values_fir_and_liner_closed_loop_bigger_window(self): def test_training_values_fir_and_liner_train_closed_loop_bigger_window(self): NeuObj.clearNames() - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[-1],[-5]]) - b = Parameter('b', values=[1]) - output1 = Output('out1', Linear(W=W,b=b)(input1.sw(2))) + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[-1], [-5]]) + b = Parameter("b", values=[1]) + output1 = Output("out1", Linear(W=W, b=b)(input1.sw(2))) - input2 = Input('in2') - a = Parameter('a', sw=4, values=[[1,3],[2,4],[3,5],[4,6]]) - output2 = Output('out2', Fir(output_dimension=2,W=a)(input2.sw(4))) + input2 = Input("in2") + a = Parameter("a", sw=4, values=[[1, 3], [2, 4], [3, 5], [4, 6]]) + output2 = Output("out2", Fir(output_dimension=2, W=a)(input2.sw(4))) - target1 = Input('target1') - target2 = Input('target2', dimensions=2) + target1 = Input("target1") + target2 = Input("target2", dimensions=2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', output1, target1.sw(2)) - test.addMinimize('error2', output2, target2.last()) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", output1, target1.sw(2)) + test.addMinimize("error2", output2, target2.last()) test.neuralizeModel() - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], 'out2': [[[-49.0, -107.0]], [[-12.0, -46.0]], [[13.0, 15.0]]]}, - test({'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], 'in2': [-10, -16, -5, 2, 2, 2]},closed_loop={'in1':'out2','in2':'out1'})) - - dataset = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], 'in2': [-10, -16, -5, 2], - 'target1': [-11, -17, -12, -20], - 'target2': [[-34.0, -86.0], [-31.0, -90.0], [-32.0, -86.0], [-33.0, -84.0]]} - test.loadData(name='dataset', source=dataset) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], - 'out2': [[[-49.0, -107.0]], [[-120.0, -214.0]], [[-205.0, -333.0]]]}, - test(dataset,closed_loop={'in1':'out2','in2':'out1'})) - - self.assertListEqual([[-1],[-5]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[1,3],[2,4],[3,5],[4,6]], test.parameters['a']) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0,closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[83.0],[105.0]], test.parameters['W']) - self.assertListEqual([6.0], test.parameters['b']) - self.assertListEqual([[-159.0, -227.0], [-254., -364.], [-77., -110.], [36., 52.]], test.parameters['a']) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], + "out2": [[[-49.0, -107.0]], [[-12.0, -46.0]], [[13.0, 15.0]]], + }, + test( + { + "in1": [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], + "in2": [-10, -16, -5, 2, 2, 2], + }, + closed_loop={"in1": "out2", "in2": "out1"}, + ), + ) + + dataset = { + "in1": [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0]], + "in2": [-10, -16, -5, 2], + "target1": [-11, -17, -12, -20], + "target2": [[-34.0, -86.0], [-31.0, -90.0], [-32.0, -86.0], [-33.0, -84.0]], + } + test.loadData(name="dataset", source=dataset) + self.assertEqual( + { + "out1": [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0]], + "out2": [[[-49.0, -107.0]], [[-120.0, -214.0]], [[-205.0, -333.0]]], + }, + test(dataset, closed_loop={"in1": "out2", "in2": "out1"}), + ) + + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual([[1, 3], [2, 4], [3, 5], [4, 6]], test.parameters["a"]) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[83.0], [105.0]], test.parameters["W"]) + self.assertListEqual([6.0], test.parameters["b"]) + self.assertListEqual( + [[-159.0, -227.0], [-254.0, -364.0], [-77.0, -110.0], [36.0, 52.0]], + test.parameters["a"], + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=10,closed_loop={'in1':'out2','in2':'out1'}) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=10, + closed_loop={"in1": "out2", "in2": "out1"}, + ) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1,closed_loop={'in1':'out2','in2':'out1'}) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=1, + closed_loop={"in1": "out2", "in2": "out1"}, + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, minimize_gain={'error1':0},closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[-1],[-5]], test.parameters['W']) - self.assertListEqual([1.0], test.parameters['b']) - self.assertListEqual([[-159.0, -227.0], [-254., -364.], [-77., -110.], [36., 52.]], test.parameters['a']) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + minimize_gain={"error1": 0}, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[-1], [-5]], test.parameters["W"]) + self.assertListEqual([1.0], test.parameters["b"]) + self.assertListEqual( + [[-159.0, -227.0], [-254.0, -364.0], [-77.0, -110.0], [36.0, 52.0]], + test.parameters["a"], + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, minimize_gain={'error2':0},closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[83.0],[105.0]], test.parameters['W']) - self.assertListEqual([6.0], test.parameters['b']) - self.assertListEqual([[1,3],[2,4],[3,5],[4,6]], test.parameters['a']) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + minimize_gain={"error2": 0}, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[83.0], [105.0]], test.parameters["W"]) + self.assertListEqual([6.0], test.parameters["b"]) + self.assertListEqual([[1, 3], [2, 4], [3, 5], [4, 6]], test.parameters["a"]) test.neuralizeModel(clear_model=True) - dataset2 = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0], [0.0, 0.0], [0.0, 1.0], [1.0, 0.0]], 'in2': [-10, -16, -5, 2, 3, -3, 5], - 'target1':[-11,-17,-12,-20,5,1,0], - 'target2':[[-34.0, -86.0],[-31.0, -90.0],[-32.0, -86.0],[-33.0, -84.0],[-31.0, -84.0],[0.0, -84.0],[-31.0, 0.0]]} - test.loadData(name='dataset2', source=dataset2) - self.assertEqual({'out1': [[-10.0, -16.0], [-16.0, -33.0], [-33.0, -4.0],[-4.0,1.0],[1.0,-4.0],[-4.0,0.0]], - 'out2': [[[-49, -107]], [[-8, -40]], [[-4, -10]], [[19, 33]], [[-11, -17]], [[-24, -44]]]}, - test(dataset2,closed_loop={'in1':'out2','in2':'out1'})) + dataset2 = { + "in1": [ + [1.0, 2.0], + [2.0, 3.0], + [4.0, 6.0], + [0.0, 1.0], + [0.0, 0.0], + [0.0, 1.0], + [1.0, 0.0], + ], + "in2": [-10, -16, -5, 2, 3, -3, 5], + "target1": [-11, -17, -12, -20, 5, 1, 0], + "target2": [ + [-34.0, -86.0], + [-31.0, -90.0], + [-32.0, -86.0], + [-33.0, -84.0], + [-31.0, -84.0], + [0.0, -84.0], + [-31.0, 0.0], + ], + } + test.loadData(name="dataset2", source=dataset2) + self.assertEqual( + { + "out1": [ + [-10.0, -16.0], + [-16.0, -33.0], + [-33.0, -4.0], + [-4.0, 1.0], + [1.0, -4.0], + [-4.0, 0.0], + ], + "out2": [ + [[-49, -107]], + [[-8, -40]], + [[-4, -10]], + [[19, 33]], + [[-11, -17]], + [[-24, -44]], + ], + }, + test(dataset2, closed_loop={"in1": "out2", "in2": "out1"}), + ) # Use a train_batch_size of 4 # test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=1, closed_loop={'in1':'out2','in2':'out1'}) # TODO Add this test - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, prediction_samples=0, closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[20.0], [21.0]], test.parameters['W']) - self.assertListEqual([2.75], test.parameters['b']) - self.assertListEqual([[23., 197.5], [-68.75, -94.75], [12., -76.5], [-70.75, -1.25]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + prediction_samples=0, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[20.0], [21.0]], test.parameters["W"]) + self.assertListEqual([2.75], test.parameters["b"]) + self.assertListEqual( + [[23.0, 197.5], [-68.75, -94.75], [12.0, -76.5], [-70.75, -1.25]], + test.parameters["a"], + ) test.neuralizeModel(clear_model=True) - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=4,closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[20.0], [21.0]], test.parameters['W']) - self.assertListEqual([2.75], test.parameters['b']) - self.assertListEqual([[23., 197.5], [-68.75, -94.75], [12., -76.5], [-70.75, -1.25]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=4, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[20.0], [21.0]], test.parameters["W"]) + self.assertListEqual([2.75], test.parameters["b"]) + self.assertListEqual( + [[23.0, 197.5], [-68.75, -94.75], [12.0, -76.5], [-70.75, -1.25]], + test.parameters["a"], + ) # Use a small batch but with a prediction sample of 3 = to 4 samples - dataset3 = {'in1': [[1.0, 2.0], [2.0, 3.0], [4.0, 6.0], [0.0, 1.0], [0.0, 0.0], [0.0, 1.0], [1.0, 0.0]], 'in2': [-10, -16, -5, 2, 3, -3, 5], - 'target1':[-11, -17, -30, -2, 582, 1421, -18975], - 'target2':[[-34.0, -86.0],[-31.0, -90.0],[-32.0, -86.0],[-48, -106], [-140, -256], [2254, 3341], [7420, 11374]]} - test.loadData(name='dataset3', source=dataset3) + dataset3 = { + "in1": [ + [1.0, 2.0], + [2.0, 3.0], + [4.0, 6.0], + [0.0, 1.0], + [0.0, 0.0], + [0.0, 1.0], + [1.0, 0.0], + ], + "in2": [-10, -16, -5, 2, 3, -3, 5], + "target1": [-11, -17, -30, -2, 582, 1421, -18975], + "target2": [ + [-34.0, -86.0], + [-31.0, -90.0], + [-32.0, -86.0], + [-48, -106], + [-140, -256], + [2254, 3341], + [7420, 11374], + ], + } + test.loadData(name="dataset3", source=dataset3) test.neuralizeModel(clear_model=True) with self.assertRaises(ValueError): - test.trainModel(train_dataset='dataset2', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=4,closed_loop={'in1':'out2','in2':'out1'}) - test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=1, num_of_epochs=1, train_batch_size=1, prediction_samples=3,closed_loop={'in1':'out2','in2':'out1'}) - self.assertListEqual([[-3010.5],[-5211.25]], test.parameters['W']) - self.assertListEqual([199.5], test.parameters['b']) - self.assertListEqual([[252.75, 1172.5], [420.5, 1998.25], [-228.5, 627.5], [-626.75, 3036.5]], test.parameters['a']) + test.trainModel( + train_dataset="dataset2", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=4, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + test.trainModel( + train_dataset="dataset3", + optimizer="SGD", + lr=1, + num_of_epochs=1, + train_batch_size=1, + prediction_samples=3, + closed_loop={"in1": "out2", "in2": "out1"}, + ) + self.assertListEqual([[-3010.5], [-5211.25]], test.parameters["W"]) + self.assertListEqual([199.5], test.parameters["b"]) + self.assertListEqual( + [[252.75, 1172.5], [420.5, 1998.25], [-228.5, 627.5], [-626.75, 3036.5]], + test.parameters["a"], + ) # test.neuralizeModel(clear_model=True) # test.trainModel(train_dataset='dataset3', optimizer='SGD', lr=1, num_of_epochs=2, train_batch_size=2, prediction_samples=2,closed_loop={'in1':'out2','in2':'out1'}) @@ -1520,105 +3032,230 @@ def test_training_values_fir_and_liner_train_closed_loop_bigger_window(self): def test_train_compare_state_and_closed_loop(self): NeuObj.clearNames() - dataset = {'control': [-1, -1, -5, 2,-1, -1, -5, 2,-1, -1, -5, 2,-1, -1, -5, 2,-1, -1, -5, 2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2], - 'target1': [-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2,-1, -1, -1, -2], - 'target2': [[-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0], - [-1.0, -1.0], [-1.0, -2.0], [-1.0, -1.0], [-1.0, -2.0] - ]} - - feed = Input('control') - input1 = Input('in1', dimensions=2) - W = Parameter('W', values=[[0.1],[0.1]]) - b = Parameter('b', values=[0.1]) - output1 = Output('out1', feed.sw(2)+Linear(W=W, b=b)(input1.sw(2))) - - input2 = Input('in2') - a = Parameter('a', sw=4, values=[[0.1,0.3],[0.2,0.4],[0.3,0.5],[0.4,0.6]]) - output2 = Output('out2', Fir(output_dimension=2,W=a)(input2.sw(4))) - - target1 = Input('target1') - target2 = Input('target2', dimensions=2) + dataset = { + "control": [ + -1, + -1, + -5, + 2, + -1, + -1, + -5, + 2, + -1, + -1, + -5, + 2, + -1, + -1, + -5, + 2, + -1, + -1, + -5, + 2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + ], + "target1": [ + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + -1, + -1, + -1, + -2, + ], + "target2": [ + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + [-1.0, -1.0], + [-1.0, -2.0], + ], + } + + feed = Input("control") + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[0.1], [0.1]]) + b = Parameter("b", values=[0.1]) + output1 = Output("out1", feed.sw(2) + Linear(W=W, b=b)(input1.sw(2))) + + input2 = Input("in2") + a = Parameter( + "a", sw=4, values=[[0.1, 0.3], [0.2, 0.4], [0.3, 0.5], [0.4, 0.6]] + ) + output2 = Output("out2", Fir(output_dimension=2, W=a)(input2.sw(4))) + + target1 = Input("target1") + target2 = Input("target2", dimensions=2) test = Modely(visualizer=None, seed=42) - test.addModel('model', [output1,output2]) - test.addMinimize('error1', output1, target1.sw(2)) - test.addMinimize('error2', output2, target2.last()) + test.addModel("model", [output1, output2]) + test.addMinimize("error1", output1, target1.sw(2)) + test.addMinimize("error2", output2, target2.last()) test.neuralizeModel() - test.loadData(name='dataset', source=dataset) - test.trainModel(splits=[60,40,0], optimizer='SGD', lr=0.001, num_of_epochs=1, prediction_samples=10, - closed_loop={'in1': 'out2', 'in2': 'out1'}) + test.loadData(name="dataset", source=dataset) + test.trainModel( + splits=[60, 40, 0], + optimizer="SGD", + lr=0.001, + num_of_epochs=1, + prediction_samples=10, + closed_loop={"in1": "out2", "in2": "out1"}, + ) NeuObj.clearNames() - feed = Input('control') - input1 = Input('in1',dimensions=2) - W = Parameter('W', values=[[0.1],[0.1]]) - b = Parameter('b', values=[0.1]) + feed = Input("control") + input1 = Input("in1", dimensions=2) + W = Parameter("W", values=[[0.1], [0.1]]) + b = Parameter("b", values=[0.1]) relation1 = feed.sw(2) + Linear(W=W, b=b)(input1.sw(2)) - input2 = Input('in2') - a = Parameter('a', sw=4, values=[[0.1,0.3],[0.2,0.4],[0.3,0.5],[0.4,0.6]]) + input2 = Input("in2") + a = Parameter( + "a", sw=4, values=[[0.1, 0.3], [0.2, 0.4], [0.3, 0.5], [0.4, 0.6]] + ) relation2 = Fir(output_dimension=2, W=a)(input2.sw(4)) relation1.closedLoop(input2) relation2.closedLoop(input1) - output1 = Output('out1', relation1) - output2 = Output('out2', relation2) + output1 = Output("out1", relation1) + output2 = Output("out2", relation2) - target1 = Input('target1') - target2 = Input('target2', dimensions=2) + target1 = Input("target1") + target2 = Input("target2", dimensions=2) test2 = Modely(visualizer=None, seed=42) - test2.addModel('model', [output1, output2]) - test2.addMinimize('error1', output1, target1.sw(2)) - test2.addMinimize('error2', output2, target2.last()) + test2.addModel("model", [output1, output2]) + test2.addMinimize("error1", output1, target1.sw(2)) + test2.addMinimize("error2", output2, target2.last()) test2.neuralizeModel() - test2.loadData(name='dataset', source=dataset) - test2.trainModel(splits=[60,40,0], optimizer='SGD', lr=0.001, num_of_epochs=1, prediction_samples=10) - - self.assertListEqual(test2.parameters['W'], test.parameters['W']) - self.assertListEqual(test2.parameters['a'], test.parameters['a']) - self.assertListEqual(test2.parameters['b'], test.parameters['b']) - self.assertListEqual(test2._training['error1']['train'] , test._training['error1']['train']) - self.assertListEqual(test2._training['error1']['val'], test._training['error1']['val']) - self.assertListEqual(test2._training['error2']['train'] , test._training['error2']['train']) - self.assertListEqual(test2._training['error2']['val'], test._training['error2']['val']) + test2.loadData(name="dataset", source=dataset) + test2.trainModel( + splits=[60, 40, 0], + optimizer="SGD", + lr=0.001, + num_of_epochs=1, + prediction_samples=10, + ) + + self.assertListEqual(test2.parameters["W"], test.parameters["W"]) + self.assertListEqual(test2.parameters["a"], test.parameters["a"]) + self.assertListEqual(test2.parameters["b"], test.parameters["b"]) + self.assertListEqual( + test2._training["error1"]["train"], test._training["error1"]["train"] + ) + self.assertListEqual( + test2._training["error1"]["val"], test._training["error1"]["val"] + ) + self.assertListEqual( + test2._training["error2"]["train"], test._training["error2"]["train"] + ) + self.assertListEqual( + test2._training["error2"]["val"], test._training["error2"]["val"] + ) test2 = Modely(visualizer=None, seed=42, log_internal=True) - test2.addModel('model', [output1, output2]) - test2.addMinimize('error1', output1, target1.sw(2)) - test2.addMinimize('error2', output2, target2.last()) + test2.addModel("model", [output1, output2]) + test2.addMinimize("error1", output1, target1.sw(2)) + test2.addMinimize("error2", output2, target2.last()) test2.neuralizeModel() - test2.loadData(name='dataset', source=dataset) - test2.trainModel(splits=[100,0,0], train_batch_size=1, step=10, optimizer='SGD', lr=0.001, num_of_epochs=1, prediction_samples=3) - - self.assertEqual(len(test2.internals.keys()), (3+1)*((26+10)//(10+1))) - #self.assertEqual(test2.internals) + test2.loadData(name="dataset", source=dataset) + test2.trainModel( + splits=[100, 0, 0], + train_batch_size=1, + step=10, + optimizer="SGD", + lr=0.001, + num_of_epochs=1, + prediction_samples=3, + ) + + self.assertEqual(len(test2.internals.keys()), (3 + 1) * ((26 + 10) // (10 + 1))) + # self.assertEqual(test2.internals) def test_train_derivate_wrt_input_closed_loop(self): NeuObj.clearNames() - x = Input('x') - x_target = Input('x_target') - y = Input('y') + x = Input("x") + x_target = Input("x_target") + y = Input("y") x_last = x.last() y_last = y.last() - p=Parameter('fir',sw=1,values=[[-0.5]]) + p = Parameter("fir", sw=1, values=[[-0.5]]) fun = Sin(x_last) + Fir(W=p)(x_last) + Cos(y_last) out_der = Differentiate(fun, x_last) + Differentiate(fun, y_last) out_der.closedLoop(x) - out = Output('out', out_der) + out = Output("out", out_der) m = Modely(visualizer=None, seed=7) - m.addModel('model', [out]) - m.addMinimize('error', out, x_target.next()) + m.addModel("model", [out]) + m.addMinimize("error", out, x_target.next()) m.neuralizeModel() K = 0 @@ -1634,39 +3271,46 @@ def fun_data(x, y, K): x_data.append(x) y_data.append(y) - dataset = {'x': x_data, 'y': y_data, 'x_target': x_data} - m.loadData('dataset', dataset) - m.trainModel(lr=0.4, num_of_epochs=200, closed_loop={'y': 'out'}, prediction_samples=9) - result = m({'x': [-0.2], 'y': [0.5]}, closed_loop={'y':'out'}, num_of_samples=10, prediction_samples=10) - self.assertAlmostEqual([a.tolist() for a in x_data[0:10]],result['out']) + dataset = {"x": x_data, "y": y_data, "x_target": x_data} + m.loadData("dataset", dataset) + m.trainModel( + lr=0.4, num_of_epochs=200, closed_loop={"y": "out"}, prediction_samples=9 + ) + result = m( + {"x": [-0.2], "y": [0.5]}, + closed_loop={"y": "out"}, + num_of_samples=10, + prediction_samples=10, + ) + self.assertAlmostEqual([a.tolist() for a in x_data[0:10]], result["out"]) def test_train_derivate_wrt_input_connect(self): NeuObj.clearNames() - x = Input('x') - y = Input('y') + x = Input("x") + y = Input("y") x_last = x.last() y_last = y.last() - p1 = Parameter('p1', sw=1, values=[[0]]) + p1 = Parameter("p1", sw=1, values=[[0]]) fun = Sin(x_last) + Fir(W=p1)(x_last) + Cos(y_last) out_der = Differentiate(fun, x_last) + Differentiate(fun, y_last) - x2 = Input('x2') - y2 = Input('y2') + x2 = Input("x2") + y2 = Input("y2") x2_last = x2.last() y2_last = y2.last() - p2 = Parameter('p2', sw=1, values=[[0]]) + p2 = Parameter("p2", sw=1, values=[[0]]) fun2 = Sin(x2_last) + Fir(W=p2)(x2_last) + Cos(y2_last) out_der2 = Differentiate(fun2, x2_last) + Differentiate(fun2, y2_last) out_der.connect(x2) - out1 = Output('out1', out_der) - out2 = Output('out2', out_der2) + out1 = Output("out1", out_der) + out2 = Output("out2", out_der2) - target = Input('target') + target = Input("target") m = Modely(visualizer=None, seed=5) - m.addModel('model', [out1,out2]) - m.addMinimize('error', out_der2, target.last()) + m.addModel("model", [out1, out2]) + m.addMinimize("error", out_der2, target.last()) m.neuralizeModel() K1 = -0.5 @@ -1676,76 +3320,121 @@ def fun_data(x, y, K): return K + np.cos(x) - np.sin(y) def fun_data2(x, y, K1, K2): - return K2 + np.cos(fun_data(x,y,K1)) - np.sin(fun_data(x,y,K1)) + return K2 + np.cos(fun_data(x, y, K1)) - np.sin(fun_data(x, y, K1)) target = [] import numpy as np + x = np.random.rand(100) y = np.random.rand(100) - for (xi,yi) in zip(x,y): + for xi, yi in zip(x, y): r = fun_data2(xi, yi, K1, K2) target.append(r) - dataset = {'x': x.tolist(), 'y': y.tolist(), 'target': target} - m.loadData('dataset', dataset) - m.trainModel(lr=0.3, num_of_epochs=200, splits=[70,20,10], connect={'y2': 'out1'}, prediction_samples=9) - - result = m({'x': x.tolist(), 'y': y.tolist()}, connect={'y2':'out1'}, num_of_samples=10, prediction_samples=10) - self.assertAlmostEqual([a.tolist() for a in target[0:10]],result['out2']) + dataset = {"x": x.tolist(), "y": y.tolist(), "target": target} + m.loadData("dataset", dataset) + m.trainModel( + lr=0.3, + num_of_epochs=200, + splits=[70, 20, 10], + connect={"y2": "out1"}, + prediction_samples=9, + ) + + result = m( + {"x": x.tolist(), "y": y.tolist()}, + connect={"y2": "out1"}, + num_of_samples=10, + prediction_samples=10, + ) + self.assertAlmostEqual([a.tolist() for a in target[0:10]], result["out2"]) def test_training_values_fir_connect_linear_more_window_2(self): NeuObj.clearNames() - input1 = Input('in1') - W = Parameter('W', sw=4, values=[[1], [1], [1], [1]]) - b = Parameter('b', values=0) + input1 = Input("in1") + W = Parameter("W", sw=4, values=[[1], [1], [1], [1]]) + b = Parameter("b", values=0) lin_out = Fir(W=W, b=b)(input1.sw(4)) - inout = Input('inout') + inout = Input("inout") lin_out.connect(inout) - W1 = Parameter('W1', sw=4, values=[[1], [1], [1], [1]]) - b1 = Parameter('b1', values=0) + W1 = Parameter("W1", sw=4, values=[[1], [1], [1], [1]]) + b1 = Parameter("b1", values=0) fir_out = Fir(W=W1, b=b1)(inout.sw(4)) - output = Output('out', inout.sw(4)) - output1 = Output('out1', lin_out) - output2 = Output('out2', fir_out) + output = Output("out", inout.sw(4)) + output1 = Output("out1", lin_out) + output2 = Output("out2", fir_out) - target = Input('target') + target = Input("target") test = Modely(visualizer=None, seed=42, log_internal=True) - test.addModel('model', [output, output1, output2]) - test.addMinimize('error2', target.last(), output2) + test.addModel("model", [output, output1, output2]) + test.addMinimize("error2", target.last(), output2) test.neuralizeModel() # Dataset with only one sample - dataset = {'in1': [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0], - 'inout':[10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0], - 'target': [10.0, 22.0, 34.0, 46.0, 58.0, 70.0, 82.0, 94.0, 106.0]} - test.loadData(name='dataset', source=dataset) - + dataset = { + "in1": [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0], + "inout": [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0], + "target": [10.0, 22.0, 34.0, 46.0, 58.0, 70.0, 82.0, 94.0, 106.0], + } + test.loadData(name="dataset", source=dataset) # Use a small batch but with a prediction sample of 3 = to 4 samples - self.assertListEqual([[1.0], [1.0], [1.0], [1.0]], test.parameters['W']) - self.assertListEqual([[1.0], [1.0], [1.0], [1.0]], test.parameters['W1']) - self.assertListEqual([0.0], test.parameters['b']) - self.assertListEqual([0.0], test.parameters['b1']) + self.assertListEqual([[1.0], [1.0], [1.0], [1.0]], test.parameters["W"]) + self.assertListEqual([[1.0], [1.0], [1.0], [1.0]], test.parameters["W1"]) + self.assertListEqual([0.0], test.parameters["b"]) + self.assertListEqual([0.0], test.parameters["b1"]) inference = test(inputs=dataset, prediction_samples=3) - self.assertDictEqual({'out': [[10.0, 20.0, 30.0, 12.0], [20.0, 30.0, 12.0, 20.0], [30.0, 12.0, 20.0, 28.0], [12.0, 20.0, 28.0, 36.0], [50.0, 60.0, 70.0, 44.0], [60.0, 70.0, 44.0, 52.0]], - 'out1': [12.0, 20.0, 28.0, 36.0, 44.0, 52.0], - 'out2': [72.0, 82.0, 90.0, 96.0, 224.0, 226.0]}, - inference) - test.trainModel(train_dataset='dataset', optimizer='SGD', lr=0.0001, train_batch_size=1, num_of_epochs=1, shuffle_data=False, prediction_samples=3) - for i, (k,v) in enumerate(test.internals.items()): + self.assertDictEqual( + { + "out": [ + [10.0, 20.0, 30.0, 12.0], + [20.0, 30.0, 12.0, 20.0], + [30.0, 12.0, 20.0, 28.0], + [12.0, 20.0, 28.0, 36.0], + [50.0, 60.0, 70.0, 44.0], + [60.0, 70.0, 44.0, 52.0], + ], + "out1": [12.0, 20.0, 28.0, 36.0, 44.0, 52.0], + "out2": [72.0, 82.0, 90.0, 96.0, 224.0, 226.0], + }, + inference, + ) + test.trainModel( + train_dataset="dataset", + optimizer="SGD", + lr=0.0001, + train_batch_size=1, + num_of_epochs=1, + shuffle_data=False, + prediction_samples=3, + ) + for i, (k, v) in enumerate(test.internals.items()): if i > 3: break - self.assertEqual(v['out']['out'][0][-1][0], v['out']['out1'][0][0][0]) - self.assertEqual(sum([x[0] for x in v['out']['out'][0]]), v['out']['out2'][0][0][0]) - self.assertDictEqual({'inout': [[[20.0], [30.0], [12.0], [float('inf')]]]}, test.internals['inout_0_0']['state']) - self.assertDictEqual({'inout': [[[30.0], [12.0], [20.0], [float('inf')]]]}, test.internals['inout_0_1']['state']) - self.assertDictEqual({'inout': [[[12.0], [20.0], [28.0], [float('inf')]]]}, test.internals['inout_0_2']['state']) - self.assertDictEqual({'inout': [[[20.0], [28.0], [36.0], [float('inf')]]]}, test.internals['inout_0_3']['state']) - + self.assertEqual(v["out"]["out"][0][-1][0], v["out"]["out1"][0][0][0]) + self.assertEqual( + sum([x[0] for x in v["out"]["out"][0]]), v["out"]["out2"][0][0][0] + ) + self.assertDictEqual( + {"inout": [[[20.0], [30.0], [12.0], [float("inf")]]]}, + test.internals["inout_0_0"]["state"], + ) + self.assertDictEqual( + {"inout": [[[30.0], [12.0], [20.0], [float("inf")]]]}, + test.internals["inout_0_1"]["state"], + ) + self.assertDictEqual( + {"inout": [[[12.0], [20.0], [28.0], [float("inf")]]]}, + test.internals["inout_0_2"]["state"], + ) + self.assertDictEqual( + {"inout": [[[20.0], [28.0], [36.0], [float("inf")]]]}, + test.internals["inout_0_3"]["state"], + ) # def test_state_initialization(self): # NeuObj.clearNames() @@ -1782,4 +3471,4 @@ def test_training_values_fir_connect_linear_more_window_2(self): # self.assertEqual(model.internals['inout_0_3']['out']['out'], [[[42.0]]]) # self.assertEqual(model.internals['inout_0_4']['out']['out'], [[[89.0]]]) # self.assertEqual(model.internals['inout_0_5']['out']['out'], [[[184.0]]]) - # self.assertEqual(model.internals['inout_1_0']['out']['out'], [[[6.0]]]) \ No newline at end of file + # self.assertEqual(model.internals['inout_1_0']['out']['out'], [[[6.0]]]) diff --git a/tests/test_utils.py b/tests/test_utils.py index e3d6665e..bc7f9c8b 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,4 +1,7 @@ -import unittest, os, sys, torch +import unittest +import os +import sys +import torch from nnodely import * from nnodely.support.mathutils import linear_interp @@ -12,14 +15,21 @@ sys.path.append(os.getcwd()) + class ModelyTrainingTest(unittest.TestCase): # test the linear interpolation function with batches of input data with shape torch.Size([N, 1, 1]) def test_linear_interp_with_batched_input_1(self): # x is a tensor of query points, and is a tensor of shape torch.Size([N, 1, 1]) - x = torch.tensor([[[-1.0]],[[0.15]],[[0.25]],[[0.35]],[[1.3]]]) + x = torch.tensor([[[-1.0]], [[0.15]], [[0.25]], [[0.35]], [[1.3]]]) # x_data and y_data are tensors of shape torch.Size([Q, 1]) - x_data = torch.tensor([[0.0],[0.1],[0.2],[0.3],[0.4],[0.5],[0.6],[0.7],[0.8],[0.9]]) - y_data = torch.tensor([[0.5],[0.6],[0.7],[0.8],[0.9],[1.0],[1.1],[1.2],[1.3],[1.4]]) + x_data = torch.tensor( + [[0.0], [0.1], [0.2], [0.3], [0.4], [0.5], [0.6], [0.7], [0.8], [0.9]] + ) + y_data = torch.tensor( + [[0.5], [0.6], [0.7], [0.8], [0.9], [1.0], [1.1], [1.2], [1.3], [1.4]] + ) - y = linear_interp(x,x_data,y_data) - self.assertEqual(y.shape, x.shape) # check that the output has the same shape as the input + y = linear_interp(x, x_data, y_data) + self.assertEqual( + y.shape, x.shape + ) # check that the output has the same shape as the input diff --git a/tests/test_visualizer.py b/tests/test_visualizer.py index b7f50364..4a824d12 100644 --- a/tests/test_visualizer.py +++ b/tests/test_visualizer.py @@ -1,10 +1,9 @@ -import sys, io, os, unittest, torch -import numpy as np +import sys +import os +import unittest from nnodely import * -from nnodely.basic.relation import NeuObj from nnodely.support.logger import logging, nnLogger -from nnodely.support.jsonutils import plot_structure log = nnLogger(__name__, logging.ERROR) log.setAllLevel(logging.ERROR) @@ -14,258 +13,319 @@ # 3 Tests # Test of visualizers -class ModelyTestVisualizer(unittest.TestCase): - def __init__(self, *args, **kwargs): - NeuObj.clearNames() - super(ModelyTestVisualizer, self).__init__(*args, **kwargs) - - self.x = x = Input('x') - self.y = y = Input('y') - self.z = z = Input('z') - self.a = a = Input('a', dimensions=2) - self.b = b = Input('b', dimensions=2) - - ## create the relations - def myFun(K1, p1, p2): - return K1 * p1 * p2 - - P_time = Parameter('P_time', dimensions=2, sw=5, values=[[0,0],[-0.1,0.1],[-0.2,0.2],[-0.3,0.3],[-0.4,0.4]]) - K_x = Parameter('k_x', dimensions=1, tw=1, init='init_constant', init_params={'value': 1}) - K_y = Parameter('k_y', dimensions=1, tw=1) - w = Parameter('w', dimensions=1, tw=1, init='init_constant', init_params={'value': 1}) - t = Parameter('t', dimensions=1, tw=1) - c_v = Constant('c_v', tw=1, values=[[1], [2]]) - c = 5 - w_5 = Parameter('w_5', dimensions=1, tw=5) - t_5 = Parameter('t_5', dimensions=1, tw=5) - c_5 = [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] - c_5_2 = Constant('c_5_2', tw=5, values=c_5) - parfun_x = ParamFun(myFun, parameters_and_constants=[K_x,c_v]) - parfun_y = ParamFun(myFun, parameters_and_constants=[K_y]) - parfun_zz = ParamFun(myFun) - parfun_2d = ParamFun(myFun, parameters_and_constants=[K_x, K_x]) - parfun_3d = ParamFun(myFun, parameters_and_constants=[K_x]) - fir_w = Fir(W=w_5)(x.tw(5)) - fir_t = Fir(W=t_5)(y.tw(5)) - time_part = TimePart(x.tw(5), i=1, j=3) - sample_select = SampleSelect(x.sw(5), i=1) - - def fuzzyfun(x): - return torch.sin(x) - - def fuzzyfunth(x): - return torch.tanh(x) - - fuzzy = Fuzzify(output_dimension=4, range=[0, 4], functions=fuzzyfun)(x.tw(1)) - fuzzyTriang = Fuzzify(centers=[1, 2, 3, 7])(x.tw(1)) - fuzzyRect = Fuzzify(centers=[1, 2, 3, 7], functions='Rectangular')(x.tw(1)) - fuzzyList = Fuzzify(centers=[1, 3, 2, 7], functions=[fuzzyfun,fuzzyfunth])(x.tw(1)) - self.stream = fuzzyList - - self.out = Output('out', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v))) - self.out2 = Output('out2', Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) - self.out3 = Output('out3', Add(fir_w, fir_t)) - self.out4 = Output('out4', Linear(output_dimension=1)(fuzzy+fuzzyTriang+fuzzyRect+fuzzyList)) - self.out5 = Output('out5', Fir(time_part) + Fir(sample_select)) - self.out6 = Output('out6', LocalModel(output_function=Fir())(x.tw(1), fuzzy)) - self.out7 = Output('out7', parfun_zz(z.last())) - self.out8 = Output('out8', Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + Fir(parfun_zz(x.tw(5), t_5, c_5_2))) - self.out9 = Output('out9', Fir(parfun_2d(x.tw(1)) + parfun_3d(x.tw(1),x.tw(1)))) - self.out10 = Output('out10', a.sw(5)+P_time) - self.out11 = Output('out11', TimeConcatenate(TimeConcatenate( - TimeConcatenate(Integrate(a.last()),Integrate(a.last())), - TimeConcatenate(Integrate(a.last()),Integrate(a.last())) - ),Integrate(a.last()))+P_time) - - def setUp(self): - # Reindirizza stdout e stderr - self._original_stdout = sys.stdout - self._original_stderr = sys.stderr - sys.stdout = io.StringIO() - sys.stderr = io.StringIO() - - def tearDown(self): - # Ripristina stdout e stderr - sys.stdout = self._original_stdout - sys.stderr = self._original_stderr - - def test_rper_of_objects(self): - print(repr(self.x)) - print(repr(self.stream)) - print(repr(self.out9)) - - def test_export_textvisualizer(self): - t = TextVisualizer(5) - test = Modely(visualizer=t, seed=42, workspace='./results') - test.addModel('modelA', self.out) - test.addModel('modelB', [self.out2, self.out3, self.out4]) - test.addModel('modelC', [self.out4, self.out5, self.out6]) - test.addModel('modelD', self.out7) - test.addMinimize('error1', self.x.last(), self.out) - test.addMinimize('error2', self.y.last(), self.out3, loss_function='rmse') - test.addMinimize('error3', self.z.last(), self.out6, loss_function='rmse') - - test.neuralizeModel(0.5) - - data_x = np.arange(0.0, 5, 0.1) - data_y = np.arange(0.0, 5, 0.1) - a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 10, 'lr': 0.01} - test.loadData(name='dataset', source=dataset) # Create the datastest.trainModel(optimizer='SGD', training_params=params) # Train the traced model - t.showMinimize('error1') - t.showMinimize('error2') - t.showMinimize('error3') - test.trainModel(optimizer='SGD', training_params=params) - t.showWeights() - test.trainModel(optimizer='SGD', training_params=params, closed_loop={'x':'out'}, prediction_samples=1) - test.saveModel() - test.loadModel() - - test.neuralizeModel(0.5) - test.exportPythonModel() - test.importPythonModel() - test.exportReport() - - test = Modely(visualizer='Standard') - test.addModel('modelA', self.out) - test.neuralizeModel(0.5) - def test_export_mplvisualizer(self): - m = MPLVisualizer(5) - test = Modely(visualizer=m, seed=42) - test.addModel('modelA', self.out) - test.addModel('modelB', [self.out2, self.out3, self.out4]) - test.addModel('modelC', [self.out4, self.out5, self.out6]) - test.addModel('modelD', self.out7) - test.addModel('modelE', self.out9) - test.addMinimize('error1', self.x.last(), self.out) - test.addMinimize('error2', self.y.last(), self.out3, loss_function='rmse') - test.addMinimize('error3', self.z.last(), self.out6, loss_function='rmse') - - test.neuralizeModel(0.5) - - data_x = np.arange(0.0, 1000, 0.1) - data_y = np.arange(0.0, 1000, 0.1) - a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 10, 'lr': 0.01} - test.loadData(name='dataset', source=dataset) # Create the dataset - test.trainAndAnalyze(optimizer='SGD', training_params=params) # Train the traced model - test.trainAndAnalyze(optimizer='SGD', training_params=params) - m.closeResult() - m.closeTraining() - list_of_functions = list(test.json['Functions'].keys()) - try: - for f in list_of_functions: - m.showFunctions(f) - except ValueError: - pass - with self.assertRaises(ValueError): - m.showFunctions(list_of_functions[1]) - m.closeFunctions() - test.trainAndAnalyze(optimizer='SGD', splits=[70, 20, 10], training_params=params, closed_loop={'x': 'out2'}, - prediction_samples=5) - m.closeResult() - m.closeTraining() - - def test_export_mplvisualizer2(self): - clearNames(['x', 'F']) - x = Input('x') - F = Input('F') - def myFun(K1, K2, p1, p2): - import torch - return p1 * K1 + p2 * torch.sin(K2) - - parfun = ParamFun(myFun) - out = Output('fun', parfun(x.last(), F.last())) - m = MPLVisualizer() - example = Modely(visualizer=m) - example.addModel('out', out) - example.neuralizeModel() - m.showFunctions(list(example.json['Functions'].keys()), xlim=[[-5, 5], [-1, 1]]) - m.closeFunctions() - - # @unittest.skipIf( - # sys.platform.startswith("win"), - # reason="MPLNotebookVisualizer ask for backend GUI not available in Windows CI" - # ) - def test_export_mplnotebookvisualizer(self): - m = MPLNotebookVisualizer(5, test=True) - test = Modely(visualizer=m, seed=42) - test.addModel('modelB', [self.out2, self.out3, self.out4]) - test.addModel('modelC', [self.out4, self.out5, self.out6]) - test.addModel('modelD', [self.out9]) - test.addMinimize('error2', self.y.last(), self.out3, loss_function='rmse') - test.addMinimize('error3', self.z.last(), self.out6, loss_function='rmse') - - test.neuralizeModel(1) - - data_x = np.arange(0.0, 1000, 0.1) - data_y = np.arange(0.0, 1000, 0.1) - a, b = -1.0, 2.0 - dataset = {'x': data_x, 'y': data_y, 'z': a * data_x + b * data_y} - params = {'num_of_epochs': 1, 'lr': 0.01} - test.loadData(name='dataset', source=dataset) # Create the dataset - test.trainAndAnalyze(optimizer='SGD', splits=[70,20,10], training_params=params) # Train the traced mode - m.closePlots() - list_of_functions = list(test.json['Functions'].keys()) - try: - for f in list_of_functions: - m.showFunctions(f) - except ValueError: - pass - m.closePlots() - test.trainAndAnalyze(optimizer='SGD', splits=[70, 20, 10], training_params=params, closed_loop={'x':'out2'}, prediction_samples=5) - m.closePlots() - - - def test_structure_plot(self): - clearNames() - X = Input('X') - Y = Input('Y') - Z = Input('Z') - t_state = Input('t_state') - k_state = Input('k_state') - - func1 = Fir(X.last()) + Fir(Y.last()) - func1.closedLoop(t_state) - func2 = Fir(Z.last()) + t_state.last() - func2.connect(k_state) - func3 = Fir(k_state.last()) * Constant('g', sw=1, values=[[9.8]]) - - out = Output('out', func1 + func2 + func3) - - example = Modely(visualizer=None) - example.addModel('model', out) - example.neuralizeModel() - with self.assertRaises(ValueError): - plot_structure(example.json, filename='results/structure_plot', library='invalid_library') - plot_structure(example.json, filename='results/structure_plot', library='matplotlib', view=False) - #plot_structure(example.json, filename='results/structure_plot', library='graphviz', view=False) - - def test_window_vector_plot(self): - m = MPLNotebookVisualizer(5, test=True) - test = Modely(visualizer=m, seed=42) - test.addModel('modelA', self.out10) - test.addMinimize('error1', self.b.sw(5), self.out10, loss_function='rmse') - test.neuralizeModel() - data_x = np.sin(np.arange(0.0, 5, 0.01)) - data_y = np.cos(np.arange(0.0, 5, 0.01)) - data_a = np.transpose(np.array([data_x,data_y])) - dataset = {'a':data_a, 'b': data_a} - test.loadData(name='dataset', source=dataset) - test.analyzeModel() - - def test_window_vector_plot_recurrent(self): - m = MPLNotebookVisualizer(5, test=True) - test = Modely(visualizer=m, seed=42) - test.addModel('modelA', self.out10) - test.addMinimize('error1', self.b.sw(5), self.out11, loss_function='rmse') - test.neuralizeModel(0.1) - data_x = np.sin(np.arange(0.0, 5, 0.01)) - data_y = np.cos(np.arange(0.0, 5, 0.01)) - data_a = np.transpose(np.array([data_x,data_y])) - dataset = {'a':data_a, 'b': data_a} - test.loadData(name='dataset', source=dataset) - test.analyzeModel(prediction_samples=20) \ No newline at end of file +class ModelyTestVisualizer(unittest.TestCase): + pass + # def __init__(self, *args, **kwargs): + # NeuObj.clearNames() + # super(ModelyTestVisualizer, self).__init__(*args, **kwargs) + # + # self.x = x = Input("x") + # self.y = y = Input("y") + # self.z = z = Input("z") + # self.a = a = Input("a", dimensions=2) + # self.b = b = Input("b", dimensions=2) + # + # ## create the relations + # def myFun(K1, p1, p2): + # return K1 * p1 * p2 + # + # P_time = Parameter( + # "P_time", + # dimensions=2, + # sw=5, + # values=[[0, 0], [-0.1, 0.1], [-0.2, 0.2], [-0.3, 0.3], [-0.4, 0.4]], + # ) + # K_x = Parameter( + # "k_x", dimensions=1, tw=1, init="init_constant", init_params={"value": 1} + # ) + # K_y = Parameter("k_y", dimensions=1, tw=1) + # w = Parameter( + # "w", dimensions=1, tw=1, init="init_constant", init_params={"value": 1} + # ) + # t = Parameter("t", dimensions=1, tw=1) + # c_v = Constant("c_v", tw=1, values=[[1], [2]]) + # c = 5 + # w_5 = Parameter("w_5", dimensions=1, tw=5) + # t_5 = Parameter("t_5", dimensions=1, tw=5) + # c_5 = [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] + # c_5_2 = Constant("c_5_2", tw=5, values=c_5) + # parfun_x = ParamFun(myFun, parameters_and_constants=[K_x, c_v]) + # parfun_y = ParamFun(myFun, parameters_and_constants=[K_y]) + # parfun_zz = ParamFun(myFun) + # parfun_2d = ParamFun(myFun, parameters_and_constants=[K_x, K_x]) + # parfun_3d = ParamFun(myFun, parameters_and_constants=[K_x]) + # fir_w = Fir(W=w_5)(x.tw(5)) + # fir_t = Fir(W=t_5)(y.tw(5)) + # time_part = TimePart(x.tw(5), i=1, j=3) + # sample_select = SampleSelect(x.sw(5), i=1) + # + # def fuzzyfun(x): + # return torch.sin(x) + # + # def fuzzyfunth(x): + # return torch.tanh(x) + # + # fuzzy = Fuzzify(output_dimension=4, range=[0, 4], functions=fuzzyfun)(x.tw(1)) + # fuzzyTriang = Fuzzify(centers=[1, 2, 3, 7])(x.tw(1)) + # fuzzyRect = Fuzzify(centers=[1, 2, 3, 7], functions="Rectangular")(x.tw(1)) + # fuzzyList = Fuzzify(centers=[1, 3, 2, 7], functions=[fuzzyfun, fuzzyfunth])( + # x.tw(1) + # ) + # self.stream = fuzzyList + # + # self.out = Output("out", Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v))) + # self.out2 = Output("out2", Add(w, x.tw(1)) + Add(t, y.tw(1)) + Add(w, c)) + # self.out3 = Output("out3", Add(fir_w, fir_t)) + # self.out4 = Output( + # "out4", + # Linear(output_dimension=1)(fuzzy + fuzzyTriang + fuzzyRect + fuzzyList), + # ) + # self.out5 = Output("out5", Fir(time_part) + Fir(sample_select)) + # self.out6 = Output("out6", LocalModel(output_function=Fir())(x.tw(1), fuzzy)) + # self.out7 = Output("out7", parfun_zz(z.last())) + # self.out8 = Output( + # "out8", + # Fir(parfun_x(x.tw(1)) + parfun_y(y.tw(1), c_v)) + # + Fir(parfun_zz(x.tw(5), t_5, c_5_2)), + # ) + # self.out9 = Output( + # "out9", Fir(parfun_2d(x.tw(1)) + parfun_3d(x.tw(1), x.tw(1))) + # ) + # self.out10 = Output("out10", a.sw(5) + P_time) + # self.out11 = Output( + # "out11", + # TimeConcatenate( + # TimeConcatenate( + # TimeConcatenate(Integrate(a.last()), Integrate(a.last())), + # TimeConcatenate(Integrate(a.last()), Integrate(a.last())), + # ), + # Integrate(a.last()), + # ) + # + P_time, + # ) + # + # def setUp(self): + # # Reindirizza stdout e stderr + # self._original_stdout = sys.stdout + # self._original_stderr = sys.stderr + # sys.stdout = io.StringIO() + # sys.stderr = io.StringIO() + # + # def tearDown(self): + # # Ripristina stdout e stderr + # sys.stdout = self._original_stdout + # sys.stderr = self._original_stderr + # + # def test_rper_of_objects(self): + # print(repr(self.x)) + # print(repr(self.stream)) + # print(repr(self.out9)) + # + # def test_export_textvisualizer(self): + # t = TextVisualizer(5) + # test = Modely(visualizer=t, seed=42, workspace="./results") + # test.addModel("modelA", self.out) + # test.addModel("modelB", [self.out2, self.out3, self.out4]) + # test.addModel("modelC", [self.out4, self.out5, self.out6]) + # test.addModel("modelD", self.out7) + # test.addMinimize("error1", self.x.last(), self.out) + # test.addMinimize("error2", self.y.last(), self.out3, loss_function="rmse") + # test.addMinimize("error3", self.z.last(), self.out6, loss_function="rmse") + # + # test.neuralizeModel(0.5) + # + # data_x = np.arange(0.0, 5, 0.1) + # data_y = np.arange(0.0, 5, 0.1) + # a, b = -1.0, 2.0 + # dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + # params = {"num_of_epochs": 10, "lr": 0.01} + # test.loadData( + # name="dataset", source=dataset + # ) # Create the datastest.trainModel(optimizer='SGD', training_params=params) # Train the traced model + # t.showMinimize("error1") + # t.showMinimize("error2") + # t.showMinimize("error3") + # test.trainModel(optimizer="SGD", training_params=params) + # t.showWeights() + # test.trainModel( + # optimizer="SGD", + # training_params=params, + # closed_loop={"x": "out"}, + # prediction_samples=1, + # ) + # test.saveModel() + # test.loadModel() + # + # test.neuralizeModel(0.5) + # test.exportPythonModel() + # test.importPythonModel() + # test.exportReport() + # + # test = Modely(visualizer="Standard") + # test.addModel("modelA", self.out) + # test.neuralizeModel(0.5) + # + # def test_export_mplvisualizer(self): + # m = MPLVisualizer(5) + # test = Modely(visualizer=m, seed=42) + # test.addModel("modelA", self.out) + # test.addModel("modelB", [self.out2, self.out3, self.out4]) + # test.addModel("modelC", [self.out4, self.out5, self.out6]) + # test.addModel("modelD", self.out7) + # test.addModel("modelE", self.out9) + # test.addMinimize("error1", self.x.last(), self.out) + # test.addMinimize("error2", self.y.last(), self.out3, loss_function="rmse") + # test.addMinimize("error3", self.z.last(), self.out6, loss_function="rmse") + # + # test.neuralizeModel(0.5) + # + # data_x = np.arange(0.0, 1000, 0.1) + # data_y = np.arange(0.0, 1000, 0.1) + # a, b = -1.0, 2.0 + # dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + # params = {"num_of_epochs": 10, "lr": 0.01} + # test.loadData(name="dataset", source=dataset) # Create the dataset + # test.trainAndAnalyze( + # optimizer="SGD", training_params=params + # ) # Train the traced model + # test.trainAndAnalyze(optimizer="SGD", training_params=params) + # m.closeResult() + # m.closeTraining() + # list_of_functions = list(test.json["Functions"].keys()) + # try: + # for f in list_of_functions: + # m.showFunctions(f) + # except ValueError: + # pass + # with self.assertRaises(ValueError): + # m.showFunctions(list_of_functions[1]) + # m.closeFunctions() + # test.trainAndAnalyze( + # optimizer="SGD", + # splits=[70, 20, 10], + # training_params=params, + # closed_loop={"x": "out2"}, + # prediction_samples=5, + # ) + # m.closeResult() + # m.closeTraining() + # + # def test_export_mplvisualizer2(self): + # clearNames(["x", "F"]) + # x = Input("x") + # F = Input("F") + # + # def myFun(K1, K2, p1, p2): + # import torch + # + # return p1 * K1 + p2 * torch.sin(K2) + # + # parfun = ParamFun(myFun) + # out = Output("fun", parfun(x.last(), F.last())) + # m = MPLVisualizer() + # example = Modely(visualizer=m) + # example.addModel("out", out) + # example.neuralizeModel() + # m.showFunctions(list(example.json["Functions"].keys()), xlim=[[-5, 5], [-1, 1]]) + # m.closeFunctions() + # + # # @unittest.skipIf( + # # sys.platform.startswith("win"), + # # reason="MPLNotebookVisualizer ask for backend GUI not available in Windows CI" + # # ) + # def test_export_mplnotebookvisualizer(self): + # m = MPLNotebookVisualizer(5, test=True) + # test = Modely(visualizer=m, seed=42) + # test.addModel("modelB", [self.out2, self.out3, self.out4]) + # test.addModel("modelC", [self.out4, self.out5, self.out6]) + # test.addModel("modelD", [self.out9]) + # test.addMinimize("error2", self.y.last(), self.out3, loss_function="rmse") + # test.addMinimize("error3", self.z.last(), self.out6, loss_function="rmse") + # + # test.neuralizeModel(1) + # + # data_x = np.arange(0.0, 1000, 0.1) + # data_y = np.arange(0.0, 1000, 0.1) + # a, b = -1.0, 2.0 + # dataset = {"x": data_x, "y": data_y, "z": a * data_x + b * data_y} + # params = {"num_of_epochs": 1, "lr": 0.01} + # test.loadData(name="dataset", source=dataset) # Create the dataset + # test.trainAndAnalyze( + # optimizer="SGD", splits=[70, 20, 10], training_params=params + # ) # Train the traced mode + # m.closePlots() + # list_of_functions = list(test.json["Functions"].keys()) + # try: + # for f in list_of_functions: + # m.showFunctions(f) + # except ValueError: + # pass + # m.closePlots() + # test.trainAndAnalyze( + # optimizer="SGD", + # splits=[70, 20, 10], + # training_params=params, + # closed_loop={"x": "out2"}, + # prediction_samples=5, + # ) + # m.closePlots() + # + # def test_structure_plot(self): + # clearNames() + # X = Input("X") + # Y = Input("Y") + # Z = Input("Z") + # t_state = Input("t_state") + # k_state = Input("k_state") + # + # func1 = Fir(X.last()) + Fir(Y.last()) + # func1.closedLoop(t_state) + # func2 = Fir(Z.last()) + t_state.last() + # func2.connect(k_state) + # func3 = Fir(k_state.last()) * Constant("g", sw=1, values=[[9.8]]) + # + # out = Output("out", func1 + func2 + func3) + # + # example = Modely(visualizer=None) + # example.addModel("model", out) + # example.neuralizeModel() + # with self.assertRaises(ValueError): + # plot_structure( + # example.json, + # filename="results/structure_plot", + # library="invalid_library", + # ) + # plot_structure( + # example.json, + # filename="results/structure_plot", + # library="matplotlib", + # view=False, + # ) + # # plot_structure(example.json, filename='results/structure_plot', library='graphviz', view=False) + # + # def test_window_vector_plot(self): + # m = MPLNotebookVisualizer(5, test=True) + # test = Modely(visualizer=m, seed=42) + # test.addModel("modelA", self.out10) + # test.addMinimize("error1", self.b.sw(5), self.out10, loss_function="rmse") + # test.neuralizeModel() + # data_x = np.sin(np.arange(0.0, 5, 0.01)) + # data_y = np.cos(np.arange(0.0, 5, 0.01)) + # data_a = np.transpose(np.array([data_x, data_y])) + # dataset = {"a": data_a, "b": data_a} + # test.loadData(name="dataset", source=dataset) + # test.analyzeModel() + # + # def test_window_vector_plot_recurrent(self): + # m = MPLNotebookVisualizer(5, test=True) + # test = Modely(visualizer=m, seed=42) + # test.addModel("modelA", self.out10) + # test.addMinimize("error1", self.b.sw(5), self.out11, loss_function="rmse") + # test.neuralizeModel(0.1) + # data_x = np.sin(np.arange(0.0, 5, 0.01)) + # data_y = np.cos(np.arange(0.0, 5, 0.01)) + # data_a = np.transpose(np.array([data_x, data_y])) + # dataset = {"a": data_a, "b": data_a} + # test.loadData(name="dataset", source=dataset) + # test.analyzeModel(prediction_samples=20) diff --git a/tests/val_data/testdata.dta b/tests/val_data/testdata.dta index 3175afdc..24f246c3 100644 --- a/tests/val_data/testdata.dta +++ b/tests/val_data/testdata.dta @@ -13,4 +13,3 @@ x1 y1 x2 y2 A1x A1y B1x B1y A2x A2y 0.809 0.820 0.337 0.466 - 0.350 1.375 0.577 1.208 - 0.575 1.375 0.706 2.220 - 0.274 0.857 12.533 0.080 - 0.810 0.819 0.342 0.460 - 0.350 1.375 0.574 1.204 - 0.575 1.375 0.703 2.217 - 0.274 0.850 12.543 0.090 - 0.812 0.818 0.348 0.453 - 0.350 1.375 0.571 1.199 - 0.575 1.375 0.699 2.214 - 0.274 0.842 12.556 0.100 - - diff --git a/tests/vector_data/vector_2.dta b/tests/vector_data/vector_2.dta index bb9f5885..e5b91343 100644 --- a/tests/vector_data/vector_2.dta +++ b/tests/vector_data/vector_2.dta @@ -14,4 +14,3 @@ x1 x2 x3 x4 y1 y2 y3 NO NO NO NO k1 0.805 0.825 0.322 0.485 0.350 1.375 0.585 1.218 - 0.575 1.375 0.714 1.227 - 0.274 0.977 12.502 0.040 0.806 0.824 0.325 0.481 0.350 1.375 0.584 1.216 - 0.575 1.375 0.712 1.225 - 0.274 0.973 12.508 0.050 0.807 0.823 0.329 0.477 0.350 1.375 0.582 1.214 - 0.575 1.375 0.710 1.224 - 0.274 0.969 12.515 0.060 - diff --git a/tests/vehicle_data/vehicle.csv b/tests/vehicle_data/vehicle.csv index 5625a587..3d80578b 100644 --- a/tests/vehicle_data/vehicle.csv +++ b/tests/vehicle_data/vehicle.csv @@ -98,4 +98,4 @@ 13.473333333333336,12.779200000000001,0.,5,-0.7460835566787409,-0.6602761975976819,-0.5746327099489577,-0.48922828574131927,-0.4061226600199461,-0.3259584416340431,-0.2506976788511679,-0.18109245144700026,-0.11566989947226602,-0.05551166846061051,0.,0.04959411345004128,0.09326429982348827,0.12985450593151882,0.16023045483507303,0.1832476556463689,0.20626485645772163,0.22928205726901751,0.2522992580803134,0.2753164588916661,0.298333659702962,0.09911902783658734 13.474444444444448,13.0928,0.,5,-0.7485232229184362,-0.6627158638373771,-0.5770452306900893,-0.4916408064824509,-0.4081821510060877,-0.32801793262018464,-0.25204581648097246,-0.18244058907686167,-0.11638159820341798,-0.05622336719181931,0.,0.04959411345004128,0.09414036583672214,0.13073057194475268,0.162020926674586,0.1850381274858819,0.2080553282972346,0.2310725291085305,0.25408972991982637,0.2771069307311791,0.30012413154247497,0.11169376341230414 13.496111111111112,13.014400000000002,0.,5,-0.7509649513013414,-0.6651575922202255,-0.5794597906294712,-0.4940553664218328,-0.41024338278987216,-0.3300791644039691,-0.2533950936325482,-0.1837898662284374,-0.11709389850244634,-0.05693566749079082,0.,0.04959411345004128,0.09501717235025353,0.13160737845828407,0.16381291192163872,0.1868301127329346,0.20984731354423047,0.2328645143555832,0.2558817151668791,0.2788989159782318,0.3019161167895277,0.1517397792930878 -13.51277777777778,13.0928,0.,5,-0.7534101501202031,-0.667602791039144,-0.581877782390336,-0.49647335818269767,-0.41230754420877247,-0.3321433258228126,-0.2547462885158893,-0.18514106111177853,-0.11780721119600912,-0.05764898018441045,0.,0.04959411345004128,0.09589522507155834,0.13248543117953204,0.16560744412277018,0.18862464493406605,0.21164184574541878,0.23465904655671466,0.2576762473680674,0.28069344817936326,0.30371064899065914,0.19856692399271794 \ No newline at end of file +13.51277777777778,13.0928,0.,5,-0.7534101501202031,-0.667602791039144,-0.581877782390336,-0.49647335818269767,-0.41230754420877247,-0.3321433258228126,-0.2547462885158893,-0.18514106111177853,-0.11780721119600912,-0.05764898018441045,0.,0.04959411345004128,0.09589522507155834,0.13248543117953204,0.16560744412277018,0.18862464493406605,0.21164184574541878,0.23465904655671466,0.2576762473680674,0.28069344817936326,0.30371064899065914,0.19856692399271794 diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..20129039 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2168 @@ +version = 1 +revision = 3 +requires-python = ">=3.10, <3.14" +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/08/0f303cb0b529e456bb116f2d50565a482694fbb94340bf56d44677e7ed03/charset_normalizer-3.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cdd68a1fb318e290a2077696b7eb7a21a49163c455979c639bf5a5dcdc46617d", size = 315182, upload-time = "2026-04-02T09:25:40.673Z" }, + { url = "https://files.pythonhosted.org/packages/24/47/b192933e94b546f1b1fe4df9cc1f84fcdbf2359f8d1081d46dd029b50207/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e17b8d5d6a8c47c85e68ca8379def1303fd360c3e22093a807cd34a71cd082b8", size = 209329, upload-time = "2026-04-02T09:25:42.354Z" }, + { url = "https://files.pythonhosted.org/packages/c2/b4/01fa81c5ca6141024d89a8fc15968002b71da7f825dd14113207113fabbd/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:511ef87c8aec0783e08ac18565a16d435372bc1ac25a91e6ac7f5ef2b0bff790", size = 231230, upload-time = "2026-04-02T09:25:44.281Z" }, + { url = "https://files.pythonhosted.org/packages/20/f7/7b991776844dfa058017e600e6e55ff01984a063290ca5622c0b63162f68/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:007d05ec7321d12a40227aae9e2bc6dca73f3cb21058999a1df9e193555a9dcc", size = 225890, upload-time = "2026-04-02T09:25:45.475Z" }, + { url = "https://files.pythonhosted.org/packages/20/e7/bed0024a0f4ab0c8a9c64d4445f39b30c99bd1acd228291959e3de664247/charset_normalizer-3.4.7-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf29836da5119f3c8a8a70667b0ef5fdca3bb12f80fd06487cfa575b3909b393", size = 216930, upload-time = "2026-04-02T09:25:46.58Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ab/b18f0ab31cdd7b3ddb8bb76c4a414aeb8160c9810fdf1bc62f269a539d87/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:12d8baf840cc7889b37c7c770f478adea7adce3dcb3944d02ec87508e2dcf153", size = 202109, upload-time = "2026-04-02T09:25:48.031Z" }, + { url = "https://files.pythonhosted.org/packages/82/e5/7e9440768a06dfb3075936490cb82dbf0ee20a133bf0dd8551fa096914ec/charset_normalizer-3.4.7-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d560742f3c0d62afaccf9f41fe485ed69bd7661a241f86a3ef0f0fb8b1a397af", size = 214684, upload-time = "2026-04-02T09:25:49.245Z" }, + { url = "https://files.pythonhosted.org/packages/71/94/8c61d8da9f062fdf457c80acfa25060ec22bf1d34bbeaca4350f13bcfd07/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b14b2d9dac08e28bb8046a1a0434b1750eb221c8f5b87a68f4fa11a6f97b5e34", size = 212785, upload-time = "2026-04-02T09:25:50.671Z" }, + { url = "https://files.pythonhosted.org/packages/66/cd/6e9889c648e72c0ab2e5967528bb83508f354d706637bc7097190c874e13/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:bc17a677b21b3502a21f66a8cc64f5bfad4df8a0b8434d661666f8ce90ac3af1", size = 203055, upload-time = "2026-04-02T09:25:51.802Z" }, + { url = "https://files.pythonhosted.org/packages/92/2e/7a951d6a08aefb7eb8e1b54cdfb580b1365afdd9dd484dc4bee9e5d8f258/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:750e02e074872a3fad7f233b47734166440af3cdea0add3e95163110816d6752", size = 232502, upload-time = "2026-04-02T09:25:53.388Z" }, + { url = "https://files.pythonhosted.org/packages/58/d5/abcf2d83bf8e0a1286df55cd0dc1d49af0da4282aa77e986df343e7de124/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:4e5163c14bffd570ef2affbfdd77bba66383890797df43dc8b4cc7d6f500bf53", size = 214295, upload-time = "2026-04-02T09:25:54.765Z" }, + { url = "https://files.pythonhosted.org/packages/47/3a/7d4cd7ed54be99973a0dc176032cba5cb1f258082c31fa6df35cff46acfc/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6ed74185b2db44f41ef35fd1617c5888e59792da9bbc9190d6c7300617182616", size = 227145, upload-time = "2026-04-02T09:25:55.904Z" }, + { url = "https://files.pythonhosted.org/packages/1d/98/3a45bf8247889cf28262ebd3d0872edff11565b2a1e3064ccb132db3fbb0/charset_normalizer-3.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:94e1885b270625a9a828c9793b4d52a64445299baa1fea5a173bf1d3dd9a1a5a", size = 218884, upload-time = "2026-04-02T09:25:57.074Z" }, + { url = "https://files.pythonhosted.org/packages/ad/80/2e8b7f8915ed5c9ef13aa828d82738e33888c485b65ebf744d615040c7ea/charset_normalizer-3.4.7-cp310-cp310-win32.whl", hash = "sha256:6785f414ae0f3c733c437e0f3929197934f526d19dfaa75e18fdb4f94c6fb374", size = 148343, upload-time = "2026-04-02T09:25:58.199Z" }, + { url = "https://files.pythonhosted.org/packages/35/1b/3b8c8c77184af465ee9ad88b5aea46ea6b2e1f7b9dc9502891e37af21e30/charset_normalizer-3.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:6696b7688f54f5af4462118f0bfa7c1621eeb87154f77fa04b9295ce7a8f2943", size = 159174, upload-time = "2026-04-02T09:25:59.322Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/feb40dca40dbb21e0a908801782d9288c64fc8d8e562c2098e9994c8c21b/charset_normalizer-3.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:66671f93accb62ed07da56613636f3641f1a12c13046ce91ffc923721f23c008", size = 147805, upload-time = "2026-04-02T09:26:00.756Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" }, + { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" }, + { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" }, + { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" }, + { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" }, + { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" }, + { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" }, + { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" }, + { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" }, + { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" }, + { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" }, + { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" }, + { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" }, + { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" }, + { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" }, + { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" }, + { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" }, + { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" }, + { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +dependencies = [ + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" }, + { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" }, + { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" }, + { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" }, + { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" }, + { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" }, + { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" }, + { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" }, + { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" }, + { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" }, + { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" }, + { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" }, + { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" }, + { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "coverage" +version = "7.13.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/33/e8c48488c29a73fd089f9d71f9653c1be7478f2ad6b5bc870db11a55d23d/coverage-7.13.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e0723d2c96324561b9aa76fb982406e11d93cdb388a7a7da2b16e04719cf7ca5", size = 219255, upload-time = "2026-03-17T10:29:51.081Z" }, + { url = "https://files.pythonhosted.org/packages/da/bd/b0ebe9f677d7f4b74a3e115eec7ddd4bcf892074963a00d91e8b164a6386/coverage-7.13.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52f444e86475992506b32d4e5ca55c24fc88d73bcbda0e9745095b28ef4dc0cf", size = 219772, upload-time = "2026-03-17T10:29:52.867Z" }, + { url = "https://files.pythonhosted.org/packages/48/cc/5cb9502f4e01972f54eedd48218bb203fe81e294be606a2bc93970208013/coverage-7.13.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:704de6328e3d612a8f6c07000a878ff38181ec3263d5a11da1db294fa6a9bdf8", size = 246532, upload-time = "2026-03-17T10:29:54.688Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d8/3217636d86c7e7b12e126e4f30ef1581047da73140614523af7495ed5f2d/coverage-7.13.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a1a6d79a14e1ec1832cabc833898636ad5f3754a678ef8bb4908515208bf84f4", size = 248333, upload-time = "2026-03-17T10:29:56.221Z" }, + { url = "https://files.pythonhosted.org/packages/2b/30/2002ac6729ba2d4357438e2ed3c447ad8562866c8c63fc16f6dfc33afe56/coverage-7.13.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79060214983769c7ba3f0cee10b54c97609dca4d478fa1aa32b914480fd5738d", size = 250211, upload-time = "2026-03-17T10:29:57.938Z" }, + { url = "https://files.pythonhosted.org/packages/6c/85/552496626d6b9359eb0e2f86f920037c9cbfba09b24d914c6e1528155f7d/coverage-7.13.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:356e76b46783a98c2a2fe81ec79df4883a1e62895ea952968fb253c114e7f930", size = 252125, upload-time = "2026-03-17T10:29:59.388Z" }, + { url = "https://files.pythonhosted.org/packages/44/21/40256eabdcbccdb6acf6b381b3016a154399a75fe39d406f790ae84d1f3c/coverage-7.13.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0cef0cdec915d11254a7f549c1170afecce708d30610c6abdded1f74e581666d", size = 247219, upload-time = "2026-03-17T10:30:01.199Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e8/96e2a6c3f21a0ea77d7830b254a1542d0328acc8d7bdf6a284ba7e529f77/coverage-7.13.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dc022073d063b25a402454e5712ef9e007113e3a676b96c5f29b2bda29352f40", size = 248248, upload-time = "2026-03-17T10:30:03.317Z" }, + { url = "https://files.pythonhosted.org/packages/da/ba/8477f549e554827da390ec659f3c38e4b6d95470f4daafc2d8ff94eaa9c2/coverage-7.13.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9b74db26dfea4f4e50d48a4602207cd1e78be33182bc9cbf22da94f332f99878", size = 246254, upload-time = "2026-03-17T10:30:04.832Z" }, + { url = "https://files.pythonhosted.org/packages/55/59/bc22aef0e6aa179d5b1b001e8b3654785e9adf27ef24c93dc4228ebd5d68/coverage-7.13.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ad146744ca4fd09b50c482650e3c1b1f4dfa1d4792e0a04a369c7f23336f0400", size = 250067, upload-time = "2026-03-17T10:30:06.535Z" }, + { url = "https://files.pythonhosted.org/packages/de/1b/c6a023a160806a5137dca53468fd97530d6acad24a22003b1578a9c2e429/coverage-7.13.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:c555b48be1853fe3997c11c4bd521cdd9a9612352de01fa4508f16ec341e6fe0", size = 246521, upload-time = "2026-03-17T10:30:08.486Z" }, + { url = "https://files.pythonhosted.org/packages/2d/3f/3532c85a55aa2f899fa17c186f831cfa1aa434d88ff792a709636f64130e/coverage-7.13.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7034b5c56a58ae5e85f23949d52c14aca2cfc6848a31764995b7de88f13a1ea0", size = 247126, upload-time = "2026-03-17T10:30:09.966Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2e/b9d56af4a24ef45dfbcda88e06870cb7d57b2b0bfa3a888d79b4c8debd76/coverage-7.13.5-cp310-cp310-win32.whl", hash = "sha256:eb7fdf1ef130660e7415e0253a01a7d5a88c9c4d158bcf75cbbd922fd65a5b58", size = 221860, upload-time = "2026-03-17T10:30:11.393Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cc/d938417e7a4d7f0433ad4edee8bb2acdc60dc7ac5af19e2a07a048ecbee3/coverage-7.13.5-cp310-cp310-win_amd64.whl", hash = "sha256:3e1bb5f6c78feeb1be3475789b14a0f0a5b47d505bfc7267126ccbd50289999e", size = 222788, upload-time = "2026-03-17T10:30:12.886Z" }, + { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" }, + { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" }, + { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" }, + { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" }, + { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" }, + { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" }, + { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" }, + { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" }, + { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" }, + { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" }, + { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" }, + { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" }, + { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" }, + { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" }, + { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" }, + { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" }, + { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" }, + { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" }, + { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" }, + { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" }, + { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" }, + { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" }, + { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" }, + { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" }, + { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" }, + { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" }, + { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" }, + { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" }, + { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" }, + { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" }, + { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" }, + { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" }, + { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" }, + { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" }, + { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" }, + { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" }, + { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" }, + { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" }, + { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" }, + { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" }, + { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" }, + { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" }, + { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" }, + { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" }, + { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" }, + { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" }, + { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "filelock" +version = "3.25.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "fonttools" +version = "4.62.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/ff/532ed43808b469c807e8cb6b21358da3fe6fd51486b3a8c93db0bb5d957f/fonttools-4.62.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ad5cca75776cd453b1b035b530e943334957ae152a36a88a320e779d61fc980c", size = 2873740, upload-time = "2026-03-13T13:52:11.822Z" }, + { url = "https://files.pythonhosted.org/packages/85/e4/2318d2b430562da7227010fb2bb029d2fa54d7b46443ae8942bab224e2a0/fonttools-4.62.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b3ae47e8636156a9accff64c02c0924cbebad62854c4a6dbdc110cd5b4b341a", size = 2417649, upload-time = "2026-03-13T13:52:14.605Z" }, + { url = "https://files.pythonhosted.org/packages/4c/28/40f15523b5188598018e7956899fed94eb7debec89e2dd70cb4a8df90492/fonttools-4.62.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b9e288b4da2f64fd6180644221749de651703e8d0c16bd4b719533a3a7d6e3", size = 4935213, upload-time = "2026-03-13T13:52:17.399Z" }, + { url = "https://files.pythonhosted.org/packages/42/09/7dbe3d7023f57d9b580cfa832109d521988112fd59dddfda3fddda8218f9/fonttools-4.62.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7bca7a1c1faf235ffe25d4f2e555246b4750220b38de8261d94ebc5ce8a23c23", size = 4892374, upload-time = "2026-03-13T13:52:20.175Z" }, + { url = "https://files.pythonhosted.org/packages/d1/2d/84509a2e32cb925371560ef5431365d8da2183c11d98e5b4b8b4e42426a5/fonttools-4.62.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b4e0fcf265ad26e487c56cb12a42dffe7162de708762db951e1b3f755319507d", size = 4911856, upload-time = "2026-03-13T13:52:22.777Z" }, + { url = "https://files.pythonhosted.org/packages/a5/80/df28131379eed93d9e6e6fccd3bf6e3d077bebbfe98cc83f21bbcd83ed02/fonttools-4.62.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2d850f66830a27b0d498ee05adb13a3781637b1826982cd7e2b3789ef0cc71ae", size = 5031712, upload-time = "2026-03-13T13:52:25.14Z" }, + { url = "https://files.pythonhosted.org/packages/3d/03/3c8f09aad64230cd6d921ae7a19f9603c36f70930b00459f112706f6769a/fonttools-4.62.1-cp310-cp310-win32.whl", hash = "sha256:486f32c8047ccd05652aba17e4a8819a3a9d78570eb8a0e3b4503142947880ed", size = 1507878, upload-time = "2026-03-13T13:52:28.149Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ec/f53f626f8f3e89f4cadd8fc08f3452c8fd182c951ad5caa35efac22b29ab/fonttools-4.62.1-cp310-cp310-win_amd64.whl", hash = "sha256:5a648bde915fba9da05ae98856987ca91ba832949a9e2888b48c47ef8b96c5a9", size = 1556766, upload-time = "2026-03-13T13:52:30.814Z" }, + { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" }, + { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" }, + { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" }, + { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" }, + { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" }, + { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/47/d4/dbacced3953544b9a93088cc10ef2b596d348c983d5c67a404fa41ec51ba/fonttools-4.62.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:90365821debbd7db678809c7491ca4acd1e0779b9624cdc6ddaf1f31992bf974", size = 2870219, upload-time = "2026-03-13T13:52:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/66/9e/a769c8e99b81e5a87ab7e5e7236684de4e96246aae17274e5347d11ebd78/fonttools-4.62.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12859ff0b47dd20f110804c3e0d0970f7b832f561630cd879969011541a464a9", size = 2414891, upload-time = "2026-03-13T13:52:56.493Z" }, + { url = "https://files.pythonhosted.org/packages/69/64/f19a9e3911968c37e1e620e14dfc5778299e1474f72f4e57c5ec771d9489/fonttools-4.62.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c125ffa00c3d9003cdaaf7f2c79e6e535628093e14b5de1dccb08859b680936", size = 5033197, upload-time = "2026-03-13T13:52:59.179Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8a/99c8b3c3888c5c474c08dbfd7c8899786de9604b727fcefb055b42c84bba/fonttools-4.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:149f7d84afca659d1a97e39a4778794a2f83bf344c5ee5134e09995086cc2392", size = 4988768, upload-time = "2026-03-13T13:53:02.761Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c6/0f904540d3e6ab463c1243a0d803504826a11604c72dd58c2949796a1762/fonttools-4.62.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0aa72c43a601cfa9273bb1ae0518f1acadc01ee181a6fc60cd758d7fdadffc04", size = 4971512, upload-time = "2026-03-13T13:53:05.678Z" }, + { url = "https://files.pythonhosted.org/packages/29/0b/5cbef6588dc9bd6b5c9ad6a4d5a8ca384d0cea089da31711bbeb4f9654a6/fonttools-4.62.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:19177c8d96c7c36359266e571c5173bcee9157b59cfc8cb0153c5673dc5a3a7d", size = 5122723, upload-time = "2026-03-13T13:53:08.662Z" }, + { url = "https://files.pythonhosted.org/packages/4a/47/b3a5342d381595ef439adec67848bed561ab7fdb1019fa522e82101b7d9c/fonttools-4.62.1-cp312-cp312-win32.whl", hash = "sha256:a24decd24d60744ee8b4679d38e88b8303d86772053afc29b19d23bb8207803c", size = 2281278, upload-time = "2026-03-13T13:53:10.998Z" }, + { url = "https://files.pythonhosted.org/packages/28/b1/0c2ab56a16f409c6c8a68816e6af707827ad5d629634691ff60a52879792/fonttools-4.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e7863e10b3de72376280b515d35b14f5eeed639d1aa7824f4cf06779ec65e42", size = 2331414, upload-time = "2026-03-13T13:53:13.992Z" }, + { url = "https://files.pythonhosted.org/packages/3b/56/6f389de21c49555553d6a5aeed5ac9767631497ac836c4f076273d15bd72/fonttools-4.62.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c22b1014017111c401469e3acc5433e6acf6ebcc6aa9efb538a533c800971c79", size = 2865155, upload-time = "2026-03-13T13:53:16.132Z" }, + { url = "https://files.pythonhosted.org/packages/03/c5/0e3966edd5ec668d41dfe418787726752bc07e2f5fd8c8f208615e61fa89/fonttools-4.62.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68959f5fc58ed4599b44aad161c2837477d7f35f5f79402d97439974faebfebe", size = 2412802, upload-time = "2026-03-13T13:53:18.878Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/e6ac4b44026de7786fe46e3bfa0c87e51d5d70a841054065d49cd62bb909/fonttools-4.62.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef46db46c9447103b8f3ff91e8ba009d5fe181b1920a83757a5762551e32bb68", size = 5013926, upload-time = "2026-03-13T13:53:21.379Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/8b1e801939839d405f1f122e7d175cebe9aeb4e114f95bfc45e3152af9a7/fonttools-4.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6706d1cb1d5e6251a97ad3c1b9347505c5615c112e66047abbef0f8545fa30d1", size = 4964575, upload-time = "2026-03-13T13:53:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/46/76/7d051671e938b1881670528fec69cc4044315edd71a229c7fd712eaa5119/fonttools-4.62.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2e7abd2b1e11736f58c1de27819e1955a53267c21732e78243fa2fa2e5c1e069", size = 4953693, upload-time = "2026-03-13T13:53:26.569Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ae/b41f8628ec0be3c1b934fc12b84f4576a5c646119db4d3bdd76a217c90b5/fonttools-4.62.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:403d28ce06ebfc547fbcb0cb8b7f7cc2f7a2d3e1a67ba9a34b14632df9e080f9", size = 5094920, upload-time = "2026-03-13T13:53:29.329Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/53a1e9469331a23dcc400970a27a4caa3d9f6edbf5baab0260285238b884/fonttools-4.62.1-cp313-cp313-win32.whl", hash = "sha256:93c316e0f5301b2adbe6a5f658634307c096fd5aae60a5b3412e4f3e1728ab24", size = 2279928, upload-time = "2026-03-13T13:53:32.352Z" }, + { url = "https://files.pythonhosted.org/packages/38/60/35186529de1db3c01f5ad625bde07c1f576305eab6d86bbda4c58445f721/fonttools-4.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:7aa21ff53e28a9c2157acbc44e5b401149d3c9178107130e82d74ceb500e5056", size = 2330514, upload-time = "2026-03-13T13:53:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/cf/b50ddf667c15276a9ab15a70ef5f257564de271957933ffea49d2cdbcdfb/fsspec-2026.3.0.tar.gz", hash = "sha256:1ee6a0e28677557f8c2f994e3eea77db6392b4de9cd1f5d7a9e87a0ae9d01b41", size = 313547, upload-time = "2026-03-27T19:11:14.892Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/1f/5f4a3cd9e4440e9d9bc78ad0a91a1c8d46b4d429d5239ebe6793c9fe5c41/fsspec-2026.3.0-py3-none-any.whl", hash = "sha256:d2ceafaad1b3457968ed14efa28798162f1638dbb5d2a6868a2db002a5ee39a4", size = 202595, upload-time = "2026-03-27T19:11:13.595Z" }, +] + +[[package]] +name = "graphviz" +version = "0.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434, upload-time = "2025-06-15T09:35:05.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" }, +] + +[[package]] +name = "identify" +version = "2.6.18" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/c4/7fb4db12296cdb11893d61c92048fe617ee853f8523b9b296ac03b43757e/identify-2.6.18.tar.gz", hash = "sha256:873ac56a5e3fd63e7438a7ecbc4d91aca692eb3fefa4534db2b7913f3fc352fd", size = 99580, upload-time = "2026-03-15T18:39:50.319Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/33/92ef41c6fad0233e41d3d84ba8e8ad18d1780f1e5d99b3c683e6d7f98b63/identify-2.6.18-py2.py3-none-any.whl", hash = "sha256:8db9d3c8ea9079db92cafb0ebf97abdc09d52e97f4dcf773a2e694048b7cd737", size = 99394, upload-time = "2026-03-15T18:39:48.915Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/f8/06549565caa026e540b7e7bab5c5a90eb7ca986015f4c48dace243cd24d9/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374", size = 122802, upload-time = "2026-03-09T13:12:37.515Z" }, + { url = "https://files.pythonhosted.org/packages/84/eb/8476a0818850c563ff343ea7c9c05dcdcbd689a38e01aa31657df01f91fa/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd", size = 66216, upload-time = "2026-03-09T13:12:38.812Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c4/f9c8a6b4c21aed4198566e45923512986d6cef530e7263b3a5f823546561/kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476", size = 63917, upload-time = "2026-03-09T13:12:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/f1/0e/ba4ae25d03722f64de8b2c13e80d82ab537a06b30fc7065183c6439357e3/kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22", size = 1628776, upload-time = "2026-03-09T13:12:41.976Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e4/3f43a011bc8a0860d1c96f84d32fa87439d3feedf66e672fef03bf5e8bac/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b", size = 1228164, upload-time = "2026-03-09T13:12:44.002Z" }, + { url = "https://files.pythonhosted.org/packages/4b/34/3a901559a1e0c218404f9a61a93be82d45cb8f44453ba43088644980f033/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e", size = 1246656, upload-time = "2026-03-09T13:12:45.557Z" }, + { url = "https://files.pythonhosted.org/packages/87/9e/f78c466ea20527822b95ad38f141f2de1dcd7f23fb8716b002b0d91bbe59/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb", size = 1295562, upload-time = "2026-03-09T13:12:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/0a/66/fd0e4a612e3a286c24e6d6f3a5428d11258ed1909bc530ba3b59807fd980/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537", size = 2178473, upload-time = "2026-03-09T13:12:50.254Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8e/6cac929e0049539e5ee25c1ee937556f379ba5204840d03008363ced662d/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4", size = 2274035, upload-time = "2026-03-09T13:12:51.785Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d3/9d0c18f1b52ea8074b792452cf17f1f5a56bd0302a85191f405cfbf9da16/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c", size = 2443217, upload-time = "2026-03-09T13:12:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/45/2a/6e19368803a038b2a90857bf4ee9e3c7b667216d045866bf22d3439fd75e/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede", size = 2249196, upload-time = "2026-03-09T13:12:55.057Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/3f641dfcbe72e222175d626bacf2f72c3b34312afec949dd1c50afa400f5/kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2", size = 73389, upload-time = "2026-03-09T13:12:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/da/88/299b137b9e0025d8982e03d2d52c123b0a2b159e84b0ef1501ef446339cf/kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875", size = 64782, upload-time = "2026-03-09T13:12:57.609Z" }, + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/17/6f/6fd4f690a40c2582fa34b97d2678f718acf3706b91d270c65ecb455d0a06/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4", size = 59606, upload-time = "2026-03-09T13:15:40.81Z" }, + { url = "https://files.pythonhosted.org/packages/82/a0/2355d5e3b338f13ce63f361abb181e3b6ea5fffdb73f739b3e80efa76159/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca", size = 57537, upload-time = "2026-03-09T13:15:42.071Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b9/1d50e610ecadebe205b71d6728fd224ce0e0ca6aba7b9cbe1da049203ac5/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f", size = 79888, upload-time = "2026-03-09T13:15:43.317Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ee/b85ffcd75afed0357d74f0e6fc02a4507da441165de1ca4760b9f496390d/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed", size = 77584, upload-time = "2026-03-09T13:15:44.605Z" }, + { url = "https://files.pythonhosted.org/packages/6b/dd/644d0dde6010a8583b4cd66dd41c5f83f5325464d15c4f490b3340ab73b4/kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc", size = 73390, upload-time = "2026-03-09T13:15:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/be/a30bd917018ad220c400169fba298f2bb7003c8ccbc0c3e24ae2aacad1e8/matplotlib-3.10.8-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:00270d217d6b20d14b584c521f810d60c5c78406dc289859776550df837dcda7", size = 8239828, upload-time = "2025-12-10T22:55:02.313Z" }, + { url = "https://files.pythonhosted.org/packages/58/27/ca01e043c4841078e82cf6e80a6993dfecd315c3d79f5f3153afbb8e1ec6/matplotlib-3.10.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37b3c1cc42aa184b3f738cfa18c1c1d72fd496d85467a6cf7b807936d39aa656", size = 8128050, upload-time = "2025-12-10T22:55:04.997Z" }, + { url = "https://files.pythonhosted.org/packages/cb/aa/7ab67f2b729ae6a91bcf9dcac0affb95fb8c56f7fd2b2af894ae0b0cf6fa/matplotlib-3.10.8-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee40c27c795bda6a5292e9cff9890189d32f7e3a0bf04e0e3c9430c4a00c37df", size = 8700452, upload-time = "2025-12-10T22:55:07.47Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/2d5817b0acee3c49b7e7ccfbf5b273f284957cc8e270adf36375db353190/matplotlib-3.10.8-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a48f2b74020919552ea25d222d5cc6af9ca3f4eb43a93e14d068457f545c2a17", size = 9534928, upload-time = "2025-12-10T22:55:10.566Z" }, + { url = "https://files.pythonhosted.org/packages/c9/5b/8e66653e9f7c39cb2e5cab25fce4810daffa2bff02cbf5f3077cea9e942c/matplotlib-3.10.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f254d118d14a7f99d616271d6c3c27922c092dac11112670b157798b89bf4933", size = 9586377, upload-time = "2025-12-10T22:55:12.362Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/fd0bbadf837f81edb0d208ba8f8cb552874c3b16e27cb91a31977d90875d/matplotlib-3.10.8-cp310-cp310-win_amd64.whl", hash = "sha256:f9b587c9c7274c1613a30afabf65a272114cd6cdbe67b3406f818c79d7ab2e2a", size = 8128127, upload-time = "2025-12-10T22:55:14.436Z" }, + { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" }, + { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" }, + { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" }, + { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" }, + { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" }, + { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" }, + { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" }, + { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" }, + { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" }, + { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" }, + { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" }, + { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" }, + { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" }, + { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" }, + { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" }, + { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" }, + { url = "https://files.pythonhosted.org/packages/f5/43/31d59500bb950b0d188e149a2e552040528c13d6e3d6e84d0cccac593dcd/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f97aeb209c3d2511443f8797e3e5a569aebb040d4f8bc79aa3ee78a8fb9e3dd8", size = 8237252, upload-time = "2025-12-10T22:56:39.529Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2c/615c09984f3c5f907f51c886538ad785cf72e0e11a3225de2c0f9442aecc/matplotlib-3.10.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fb061f596dad3a0f52b60dc6a5dec4a0c300dec41e058a7efe09256188d170b7", size = 8124693, upload-time = "2025-12-10T22:56:41.758Z" }, + { url = "https://files.pythonhosted.org/packages/91/e1/2757277a1c56041e1fc104b51a0f7b9a4afc8eb737865d63cababe30bc61/matplotlib-3.10.8-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12d90df9183093fcd479f4172ac26b322b1248b15729cb57f42f71f24c7e37a3", size = 8702205, upload-time = "2025-12-10T22:56:43.415Z" }, + { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" }, + { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" }, +] + +[[package]] +name = "ml-dtypes" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/3a/c5b855752a70267ff729c349e650263adb3c206c29d28cc8ea7ace30a1d5/ml_dtypes-0.5.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b95e97e470fe60ed493fd9ae3911d8da4ebac16bd21f87ffa2b7c588bf22ea2c", size = 679735, upload-time = "2025-11-17T22:31:31.367Z" }, + { url = "https://files.pythonhosted.org/packages/41/79/7433f30ee04bd4faa303844048f55e1eb939131c8e5195a00a96a0939b64/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4b801ebe0b477be666696bda493a9be8356f1f0057a57f1e35cd26928823e5a", size = 5051883, upload-time = "2025-11-17T22:31:33.658Z" }, + { url = "https://files.pythonhosted.org/packages/10/b1/8938e8830b0ee2e167fc75a094dea766a1152bde46752cd9bfc57ee78a82/ml_dtypes-0.5.4-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:388d399a2152dd79a3f0456a952284a99ee5c93d3e2f8dfe25977511e0515270", size = 5030369, upload-time = "2025-11-17T22:31:35.595Z" }, + { url = "https://files.pythonhosted.org/packages/c7/a3/51886727bd16e2f47587997b802dd56398692ce8c6c03c2e5bb32ecafe26/ml_dtypes-0.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:4ff7f3e7ca2972e7de850e7b8fcbb355304271e2933dd90814c1cb847414d6e2", size = 210738, upload-time = "2025-11-17T22:31:37.43Z" }, + { url = "https://files.pythonhosted.org/packages/c6/5e/712092cfe7e5eb667b8ad9ca7c54442f21ed7ca8979745f1000e24cf8737/ml_dtypes-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90", size = 679734, upload-time = "2025-11-17T22:31:39.223Z" }, + { url = "https://files.pythonhosted.org/packages/4f/cf/912146dfd4b5c0eea956836c01dcd2fce6c9c844b2691f5152aca196ce4f/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040", size = 5056165, upload-time = "2025-11-17T22:31:41.071Z" }, + { url = "https://files.pythonhosted.org/packages/a9/80/19189ea605017473660e43762dc853d2797984b3c7bf30ce656099add30c/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483", size = 5034975, upload-time = "2025-11-17T22:31:42.758Z" }, + { url = "https://files.pythonhosted.org/packages/b4/24/70bd59276883fdd91600ca20040b41efd4902a923283c4d6edcb1de128d2/ml_dtypes-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb", size = 210742, upload-time = "2025-11-17T22:31:44.068Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c9/64230ef14e40aa3f1cb254ef623bf812735e6bec7772848d19131111ac0d/ml_dtypes-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de", size = 160709, upload-time = "2025-11-17T22:31:46.557Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" }, + { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" }, + { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" }, + { url = "https://files.pythonhosted.org/packages/d9/a1/4008f14bbc616cfb1ac5b39ea485f9c63031c4634ab3f4cf72e7541f816a/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48", size = 676888, upload-time = "2025-11-17T22:31:56.907Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b7/dff378afc2b0d5a7d6cd9d3209b60474d9819d1189d347521e1688a60a53/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b", size = 5036993, upload-time = "2025-11-17T22:31:58.497Z" }, + { url = "https://files.pythonhosted.org/packages/eb/33/40cd74219417e78b97c47802037cf2d87b91973e18bb968a7da48a96ea44/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d", size = 5010956, upload-time = "2025-11-17T22:31:59.931Z" }, + { url = "https://files.pythonhosted.org/packages/e1/8b/200088c6859d8221454825959df35b5244fa9bdf263fd0249ac5fb75e281/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328", size = 212224, upload-time = "2025-11-17T22:32:01.349Z" }, + { url = "https://files.pythonhosted.org/packages/8f/75/dfc3775cb36367816e678f69a7843f6f03bd4e2bcd79941e01ea960a068e/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175", size = 160798, upload-time = "2025-11-17T22:32:02.864Z" }, + { url = "https://files.pythonhosted.org/packages/4f/74/e9ddb35fd1dd43b1106c20ced3f53c2e8e7fc7598c15638e9f80677f81d4/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6", size = 702083, upload-time = "2025-11-17T22:32:04.08Z" }, + { url = "https://files.pythonhosted.org/packages/74/f5/667060b0aed1aa63166b22897fdf16dca9eb704e6b4bbf86848d5a181aa7/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d", size = 5354111, upload-time = "2025-11-17T22:32:05.546Z" }, + { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" }, + { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" }, + { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "networkx" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "nnodely" +version = "1.5.5.dev1" +source = { editable = "." } +dependencies = [ + { name = "graphviz" }, + { name = "matplotlib" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "onnx" }, + { name = "onnxruntime", version = "1.24.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "onnxruntime", version = "1.24.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "pandas", version = "3.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "reportlab" }, + { name = "torch", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "torch", version = "2.6.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pre-commit" }, + { name = "pytest-cov" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "graphviz" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "numpy", marker = "python_full_version == '3.10.*' and platform_machine == 'x86_64'", specifier = "==1.26.4" }, + { name = "onnx" }, + { name = "onnxruntime" }, + { name = "pandas" }, + { name = "reportlab" }, + { name = "torch", marker = "python_full_version != '3.10.*' or platform_machine != 'x86_64'", specifier = "==2.6.0" }, + { name = "torch", marker = "python_full_version == '3.10.*' and platform_machine == 'x86_64'", specifier = "==2.2.2" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "pre-commit", specifier = ">=4.5.1" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, + { name = "ruff", specifier = ">=0.15.10" }, +] + +[[package]] +name = "nodeenv" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, +] + +[[package]] +name = "numpy" +version = "1.26.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/94/ace0fdea5241a27d13543ee117cbc65868e82213fb31a8eb7fe9ff23f313/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0", size = 20631468, upload-time = "2024-02-05T23:48:01.194Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d7/ecf66c1cd12dc28b4040b15ab4d17b773b87fa9d29ca16125de01adb36cd/numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f", size = 18240889, upload-time = "2024-02-05T23:49:25.361Z" }, + { url = "https://files.pythonhosted.org/packages/39/fe/39ada9b094f01f5a35486577c848fe274e374bbf8d8f472e1423a0bbd26d/numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2", size = 18078620, upload-time = "2024-02-05T23:50:22.515Z" }, + { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" }, + { url = "https://files.pythonhosted.org/packages/11/57/baae43d14fe163fa0e4c47f307b6b2511ab8d7d30177c491960504252053/numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71", size = 20630554, upload-time = "2024-02-05T23:51:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/3a/d0/edc009c27b406c4f9cbc79274d6e46d634d139075492ad055e3d68445925/numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5", size = 18252005, upload-time = "2024-02-05T23:53:15.637Z" }, + { url = "https://files.pythonhosted.org/packages/df/a0/4e0f14d847cfc2a633a1c8621d00724f3206cfeddeb66d35698c4e2cf3d2/numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a", size = 18093567, upload-time = "2024-02-05T23:54:11.696Z" }, + { url = "https://files.pythonhosted.org/packages/3f/6b/5610004206cf7f8e7ad91c5a85a8c71b2f2f8051a0c0c4d5916b76d6cbb2/numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2", size = 15811913, upload-time = "2024-02-05T23:54:53.933Z" }, + { url = "https://files.pythonhosted.org/packages/95/12/8f2020a8e8b8383ac0177dc9570aad031a3beb12e38847f7129bacd96228/numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218", size = 20335901, upload-time = "2024-02-05T23:55:32.801Z" }, + { url = "https://files.pythonhosted.org/packages/0f/50/de23fde84e45f5c4fda2488c759b69990fd4512387a8632860f3ac9cd225/numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed", size = 17950613, upload-time = "2024-02-05T23:56:56.054Z" }, + { url = "https://files.pythonhosted.org/packages/76/8c/2ba3902e1a0fc1c74962ea9bb33a534bb05984ad7ff9515bf8d07527cadd/numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0", size = 17786643, upload-time = "2024-02-05T23:57:56.585Z" }, + { url = "https://files.pythonhosted.org/packages/16/2e/86f24451c2d530c88daf997cb8d6ac622c1d40d19f5a031ed68a4b73a374/numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818", size = 15517754, upload-time = "2024-02-05T23:58:36.364Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", hash = "sha256:2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0", size = 20731587, upload-time = "2026-03-29T13:22:01.298Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/c6/4218570d8c8ecc9704b5157a3348e486e84ef4be0ed3e38218ab473c83d2/numpy-2.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f983334aea213c99992053ede6168500e5f086ce74fbc4acc3f2b00f5762e9db", size = 16976799, upload-time = "2026-03-29T13:18:15.438Z" }, + { url = "https://files.pythonhosted.org/packages/dd/92/b4d922c4a5f5dab9ed44e6153908a5c665b71acf183a83b93b690996e39b/numpy-2.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:72944b19f2324114e9dc86a159787333b77874143efcf89a5167ef83cfee8af0", size = 14971552, upload-time = "2026-03-29T13:18:18.606Z" }, + { url = "https://files.pythonhosted.org/packages/8a/dc/df98c095978fa6ee7b9a9387d1d58cbb3d232d0e69ad169a4ce784bde4fd/numpy-2.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:86b6f55f5a352b48d7fbfd2dbc3d5b780b2d79f4d3c121f33eb6efb22e9a2015", size = 5476566, upload-time = "2026-03-29T13:18:21.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/34/b3fdcec6e725409223dd27356bdf5a3c2cc2282e428218ecc9cb7acc9763/numpy-2.4.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:ba1f4fc670ed79f876f70082eff4f9583c15fb9a4b89d6188412de4d18ae2f40", size = 6806482, upload-time = "2026-03-29T13:18:23.634Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/63417c13aa35d57bee1337c67446761dc25ea6543130cf868eace6e8157b/numpy-2.4.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a87ec22c87be071b6bdbd27920b129b94f2fc964358ce38f3822635a3e2e03d", size = 15973376, upload-time = "2026-03-29T13:18:26.677Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c5/9fcb7e0e69cef59cf10c746b84f7d58b08bc66a6b7d459783c5a4f6101a6/numpy-2.4.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df3775294accfdd75f32c74ae39fcba920c9a378a2fc18a12b6820aa8c1fb502", size = 16925137, upload-time = "2026-03-29T13:18:30.14Z" }, + { url = "https://files.pythonhosted.org/packages/7e/43/80020edacb3f84b9efdd1591120a4296462c23fd8db0dde1666f6ef66f13/numpy-2.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d4e437e295f18ec29bc79daf55e8a47a9113df44d66f702f02a293d93a2d6dd", size = 17329414, upload-time = "2026-03-29T13:18:33.733Z" }, + { url = "https://files.pythonhosted.org/packages/fd/06/af0658593b18a5f73532d377188b964f239eb0894e664a6c12f484472f97/numpy-2.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6aa3236c78803afbcb255045fbef97a9e25a1f6c9888357d205ddc42f4d6eba5", size = 18658397, upload-time = "2026-03-29T13:18:37.511Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ce/13a09ed65f5d0ce5c7dd0669250374c6e379910f97af2c08c57b0608eee4/numpy-2.4.4-cp311-cp311-win32.whl", hash = "sha256:30caa73029a225b2d40d9fae193e008e24b2026b7ee1a867b7ee8d96ca1a448e", size = 6239499, upload-time = "2026-03-29T13:18:40.372Z" }, + { url = "https://files.pythonhosted.org/packages/bd/63/05d193dbb4b5eec1eca73822d80da98b511f8328ad4ae3ca4caf0f4db91d/numpy-2.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:6bbe4eb67390b0a0265a2c25458f6b90a409d5d069f1041e6aff1e27e3d9a79e", size = 12614257, upload-time = "2026-03-29T13:18:42.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/c5/8168052f080c26fa984c413305012be54741c9d0d74abd7fbeeccae3889f/numpy-2.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:fcfe2045fd2e8f3cb0ce9d4ba6dba6333b8fa05bb8a4939c908cd43322d14c7e", size = 10486775, upload-time = "2026-03-29T13:18:45.835Z" }, + { url = "https://files.pythonhosted.org/packages/28/05/32396bec30fb2263770ee910142f49c1476d08e8ad41abf8403806b520ce/numpy-2.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15716cfef24d3a9762e3acdf87e27f58dc823d1348f765bbea6bef8c639bfa1b", size = 16689272, upload-time = "2026-03-29T13:18:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/c5/f3/a983d28637bfcd763a9c7aafdb6d5c0ebf3d487d1e1459ffdb57e2f01117/numpy-2.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23cbfd4c17357c81021f21540da84ee282b9c8fba38a03b7b9d09ba6b951421e", size = 14699573, upload-time = "2026-03-29T13:18:52.629Z" }, + { url = "https://files.pythonhosted.org/packages/9b/fd/e5ecca1e78c05106d98028114f5c00d3eddb41207686b2b7de3e477b0e22/numpy-2.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b3b60bb7cba2c8c81837661c488637eee696f59a877788a396d33150c35d842", size = 5204782, upload-time = "2026-03-29T13:18:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/de/2f/702a4594413c1a8632092beae8aba00f1d67947389369b3777aed783fdca/numpy-2.4.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e4a010c27ff6f210ff4c6ef34394cd61470d01014439b192ec22552ee867f2a8", size = 6552038, upload-time = "2026-03-29T13:18:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121", size = 15670666, upload-time = "2026-03-29T13:19:00.341Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e", size = 16645480, upload-time = "2026-03-29T13:19:03.63Z" }, + { url = "https://files.pythonhosted.org/packages/34/49/f2312c154b82a286758ee2f1743336d50651f8b5195db18cdb63675ff649/numpy-2.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62d6b0f03b694173f9fcb1fb317f7222fd0b0b103e784c6549f5e53a27718c44", size = 17020036, upload-time = "2026-03-29T13:19:07.428Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e9/736d17bd77f1b0ec4f9901aaec129c00d59f5d84d5e79bba540ef12c2330/numpy-2.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbc356aae7adf9e6336d336b9c8111d390a05df88f1805573ebb0807bd06fd1d", size = 18368643, upload-time = "2026-03-29T13:19:10.775Z" }, + { url = "https://files.pythonhosted.org/packages/63/f6/d417977c5f519b17c8a5c3bc9e8304b0908b0e21136fe43bf628a1343914/numpy-2.4.4-cp312-cp312-win32.whl", hash = "sha256:0d35aea54ad1d420c812bfa0385c71cd7cc5bcf7c65fed95fc2cd02fe8c79827", size = 5961117, upload-time = "2026-03-29T13:19:13.464Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5b/e1deebf88ff431b01b7406ca3583ab2bbb90972bbe1c568732e49c844f7e/numpy-2.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:b5f0362dc928a6ecd9db58868fca5e48485205e3855957bdedea308f8672ea4a", size = 12320584, upload-time = "2026-03-29T13:19:16.155Z" }, + { url = "https://files.pythonhosted.org/packages/58/89/e4e856ac82a68c3ed64486a544977d0e7bdd18b8da75b78a577ca31c4395/numpy-2.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:846300f379b5b12cc769334464656bc882e0735d27d9726568bc932fdc49d5ec", size = 10221450, upload-time = "2026-03-29T13:19:18.994Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d0a583ce4fefcc3308806a749a536c201ed6b5ad6e1322e227ee4848979d/numpy-2.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:08f2e31ed5e6f04b118e49821397f12767934cfdd12a1ce86a058f91e004ee50", size = 16684933, upload-time = "2026-03-29T13:19:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2b7a48fbb745d344742c0277f01286dead15f3f68e4f359fbfcf7b48f70f/numpy-2.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e823b8b6edc81e747526f70f71a9c0a07ac4e7ad13020aa736bb7c9d67196115", size = 14694532, upload-time = "2026-03-29T13:19:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/499737bfba066b4a3bebff24a8f1c5b2dee410b209bc6668c9be692580f0/numpy-2.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4a19d9dba1a76618dd86b164d608566f393f8ec6ac7c44f0cc879011c45e65af", size = 5199661, upload-time = "2026-03-29T13:19:28.31Z" }, + { url = "https://files.pythonhosted.org/packages/cd/da/464d551604320d1491bc345efed99b4b7034143a85787aab78d5691d5a0e/numpy-2.4.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d2a8490669bfe99a233298348acc2d824d496dee0e66e31b66a6022c2ad74a5c", size = 6547539, upload-time = "2026-03-29T13:19:30.97Z" }, + { url = "https://files.pythonhosted.org/packages/7d/90/8d23e3b0dafd024bf31bdec225b3bb5c2dbfa6912f8a53b8659f21216cbf/numpy-2.4.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45dbed2ab436a9e826e302fcdcbe9133f9b0006e5af7168afb8963a6520da103", size = 15668806, upload-time = "2026-03-29T13:19:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/a9d864e42a01896bb5974475438f16086be9ba1f0d19d0bb7a07427c4a8b/numpy-2.4.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c901b15172510173f5cb310eae652908340f8dede90fff9e3bf6c0d8dfd92f83", size = 16632682, upload-time = "2026-03-29T13:19:37.336Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/14570d65c3bde4e202a031210475ae9cde9b7686a2e7dc97ee67d2833b35/numpy-2.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:99d838547ace2c4aace6c4f76e879ddfe02bb58a80c1549928477862b7a6d6ed", size = 17019810, upload-time = "2026-03-29T13:19:40.963Z" }, + { url = "https://files.pythonhosted.org/packages/8a/77/2ba9d87081fd41f6d640c83f26fb7351e536b7ce6dd9061b6af5904e8e46/numpy-2.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0aec54fd785890ecca25a6003fd9a5aed47ad607bbac5cd64f836ad8666f4959", size = 18357394, upload-time = "2026-03-29T13:19:44.859Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/52666c9a41708b0853fa3b1a12c90da38c507a3074883823126d4e9d5b30/numpy-2.4.4-cp313-cp313-win32.whl", hash = "sha256:07077278157d02f65c43b1b26a3886bce886f95d20aabd11f87932750dfb14ed", size = 5959556, upload-time = "2026-03-29T13:19:47.661Z" }, + { url = "https://files.pythonhosted.org/packages/57/fb/48649b4971cde70d817cf97a2a2fdc0b4d8308569f1dd2f2611959d2e0cf/numpy-2.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:5c70f1cc1c4efbe316a572e2d8b9b9cc44e89b95f79ca3331553fbb63716e2bf", size = 12317311, upload-time = "2026-03-29T13:19:50.67Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/11490cddd564eb4de97b4579ef6bfe6a736cc07e94c1598590ae25415e01/numpy-2.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:ef4059d6e5152fa1a39f888e344c73fdc926e1b2dd58c771d67b0acfbf2aa67d", size = 10222060, upload-time = "2026-03-29T13:19:54.229Z" }, + { url = "https://files.pythonhosted.org/packages/99/5d/dab4339177a905aad3e2221c915b35202f1ec30d750dd2e5e9d9a72b804b/numpy-2.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4bbc7f303d125971f60ec0aaad5e12c62d0d2c925f0ab1273debd0e4ba37aba5", size = 14822302, upload-time = "2026-03-29T13:19:57.585Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e4/0564a65e7d3d97562ed6f9b0fd0fb0a6f559ee444092f105938b50043876/numpy-2.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:4d6d57903571f86180eb98f8f0c839fa9ebbfb031356d87f1361be91e433f5b7", size = 5327407, upload-time = "2026-03-29T13:20:00.601Z" }, + { url = "https://files.pythonhosted.org/packages/29/8d/35a3a6ce5ad371afa58b4700f1c820f8f279948cca32524e0a695b0ded83/numpy-2.4.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:4636de7fd195197b7535f231b5de9e4b36d2c440b6e566d2e4e4746e6af0ca93", size = 6647631, upload-time = "2026-03-29T13:20:02.855Z" }, + { url = "https://files.pythonhosted.org/packages/f4/da/477731acbd5a58a946c736edfdabb2ac5b34c3d08d1ba1a7b437fa0884df/numpy-2.4.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad2e2ef14e0b04e544ea2fa0a36463f847f113d314aa02e5b402fdf910ef309e", size = 15727691, upload-time = "2026-03-29T13:20:06.004Z" }, + { url = "https://files.pythonhosted.org/packages/e6/db/338535d9b152beabeb511579598418ba0212ce77cf9718edd70262cc4370/numpy-2.4.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a285b3b96f951841799528cd1f4f01cd70e7e0204b4abebac9463eecfcf2a40", size = 16681241, upload-time = "2026-03-29T13:20:09.417Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a9/ad248e8f58beb7a0219b413c9c7d8151c5d285f7f946c3e26695bdbbe2df/numpy-2.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8474c4241bc18b750be2abea9d7a9ec84f46ef861dbacf86a4f6e043401f79e", size = 17085767, upload-time = "2026-03-29T13:20:13.126Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1a/3b88ccd3694681356f70da841630e4725a7264d6a885c8d442a697e1146b/numpy-2.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4e874c976154687c1f71715b034739b45c7711bec81db01914770373d125e392", size = 18403169, upload-time = "2026-03-29T13:20:17.096Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c9/fcfd5d0639222c6eac7f304829b04892ef51c96a75d479214d77e3ce6e33/numpy-2.4.4-cp313-cp313t-win32.whl", hash = "sha256:9c585a1790d5436a5374bac930dad6ed244c046ed91b2b2a3634eb2971d21008", size = 6083477, upload-time = "2026-03-29T13:20:20.195Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e3/3938a61d1c538aaec8ed6fd6323f57b0c2d2d2219512434c5c878db76553/numpy-2.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:93e15038125dc1e5345d9b5b68aa7f996ec33b98118d18c6ca0d0b7d6198b7e8", size = 12457487, upload-time = "2026-03-29T13:20:22.946Z" }, + { url = "https://files.pythonhosted.org/packages/97/6a/7e345032cc60501721ef94e0e30b60f6b0bd601f9174ebd36389a2b86d40/numpy-2.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:0dfd3f9d3adbe2920b68b5cd3d51444e13a10792ec7154cd0a2f6e74d4ab3233", size = 10292002, upload-time = "2026-03-29T13:20:25.909Z" }, + { url = "https://files.pythonhosted.org/packages/6b/33/8fae8f964a4f63ed528264ddf25d2b683d0b663e3cba26961eb838a7c1bd/numpy-2.4.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:58c8b5929fcb8287cbd6f0a3fae19c6e03a5c48402ae792962ac465224a629a4", size = 16854491, upload-time = "2026-03-29T13:21:38.03Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d0/1aabee441380b981cf8cdda3ae7a46aa827d1b5a8cce84d14598bc94d6d9/numpy-2.4.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:eea7ac5d2dce4189771cedb559c738a71512768210dc4e4753b107a2048b3d0e", size = 14895830, upload-time = "2026-03-29T13:21:41.509Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b8/aafb0d1065416894fccf4df6b49ef22b8db045187949545bced89c034b8e/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:51fc224f7ca4d92656d5a5eb315f12eb5fe2c97a66249aa7b5f562528a3be38c", size = 5400927, upload-time = "2026-03-29T13:21:44.747Z" }, + { url = "https://files.pythonhosted.org/packages/d6/77/063baa20b08b431038c7f9ff5435540c7b7265c78cf56012a483019ca72d/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:28a650663f7314afc3e6ec620f44f333c386aad9f6fc472030865dc0ebb26ee3", size = 6715557, upload-time = "2026-03-29T13:21:47.406Z" }, + { url = "https://files.pythonhosted.org/packages/c7/a8/379542d45a14f149444c5c4c4e7714707239ce9cc1de8c2803958889da14/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19710a9ca9992d7174e9c52f643d4272dcd1558c5f7af7f6f8190f633bd651a7", size = 15804253, upload-time = "2026-03-29T13:21:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/a2/c8/f0a45426d6d21e7ea3310a15cf90c43a14d9232c31a837702dba437f3373/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b2aec6af35c113b05695ebb5749a787acd63cafc83086a05771d1e1cd1e555f", size = 16753552, upload-time = "2026-03-29T13:21:54.344Z" }, + { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.1.3.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/6d/121efd7382d5b0284239f4ab1fc1590d86d34ed4a4a2fdb13b30ca8e5740/nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl", hash = "sha256:ee53ccca76a6fc08fb9701aa95b6ceb242cdaab118c3bb152af4e579af792728", size = 410594774, upload-time = "2023-04-19T15:50:03.519Z" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.4.5.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/71/1c91302526c45ab494c23f61c7a84aa568b8c1f9d196efa5993957faf906/nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl", hash = "sha256:2fc8da60df463fdefa81e323eef2e36489e1c94335b5358bcb38360adf75ac9b", size = 363438805, upload-time = "2024-04-03T20:57:06.025Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.1.105" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/00/6b218edd739ecfc60524e585ba8e6b00554dd908de2c9c66c1af3e44e18d/nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:e54fde3983165c624cb79254ae9818a456eb6e87a7fd4d56a2352c24ee542d7e", size = 14109015, upload-time = "2023-04-19T15:47:32.502Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/42/f4f60238e8194a3106d06a058d494b18e006c10bb2b915655bd9f6ea4cb1/nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:9dec60f5ac126f7bb551c055072b69d85392b13311fcc1bcda2202d172df30fb", size = 13813957, upload-time = "2024-04-03T20:55:01.564Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.1.105" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/9f/c64c03f49d6fbc56196664d05dba14e3a561038a81a638eeb47f4d4cfd48/nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:339b385f50c309763ca65456ec75e17bbefcbbf2893f462cb8b90584cd27a1c2", size = 23671734, upload-time = "2023-04-19T15:48:32.42Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/14/91ae57cd4db3f9ef7aa99f4019cfa8d54cb4caa7e00975df6467e9725a9f/nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a178759ebb095827bd30ef56598ec182b85547f1508941a3d560eb7ea1fbf338", size = 24640306, upload-time = "2024-04-03T20:56:01.463Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.1.105" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/d5/c68b1d2cdfcc59e72e8a5949a37ddb22ae6cade80cd4a57a84d4c8b55472/nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:6e258468ddf5796e25f1dc591a31029fa317d97a0a94ed93468fc86301d61e40", size = 823596, upload-time = "2023-04-19T15:47:22.471Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/27/1795d86fe88ef397885f2e580ac37628ed058a92ed2c39dc8eac3adf0619/nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:64403288fa2136ee8e467cdc9c9427e0434110899d07c779f25b5c068934faa5", size = 883737, upload-time = "2024-04-03T20:54:51.355Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "8.9.2.26" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/74/a2e2be7fb83aaedec84f391f082cf765dfb635e7caa9b49065f73e4835d8/nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl", hash = "sha256:5ccb288774fdfb07a7e7025ffec286971c06d8d7b4fb162525334616d7629ff9", size = 731725872, upload-time = "2023-06-01T19:24:57.328Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.1.0.70" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.4.5.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/fd/713452cd72343f682b1c7b9321e23829f00b842ceaedcda96e742ea0b0b3/nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f", size = 664752741, upload-time = "2024-04-22T15:24:15.253Z" }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.0.2.54" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/94/eb540db023ce1d162e7bea9f8f5aa781d57c65aed513c33ee9a5123ead4d/nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl", hash = "sha256:794e3948a1aa71fd817c3775866943936774d1c14e7628c74f6f7417224cdf56", size = 121635161, upload-time = "2023-04-19T15:50:46Z" }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.2.1.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "nvidia-nvjitlink-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/94/3266821f65b92b3138631e9c8e7fe1fb513804ac934485a8d05776e1dd43/nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f083fc24912aa410be21fa16d157fed2055dab1cc4b6934a0e03cba69eb242b9", size = 211459117, upload-time = "2024-04-03T20:57:40.402Z" }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.2.106" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/31/4890b1c9abc496303412947fc7dcea3d14861720642b49e8ceed89636705/nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:9d264c5036dde4e64f1de8c50ae753237c12e0b1348738169cd0f8a536c0e1e0", size = 56467784, upload-time = "2023-04-19T15:51:04.804Z" }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.5.147" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/6d/44ad094874c6f1b9c654f8ed939590bdc408349f137f9b98a3a23ccec411/nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a88f583d4e0bb643c49743469964103aa59f7f708d862c3ddb0fc07f851e3b8b", size = 56305206, upload-time = "2024-04-03T20:58:08.722Z" }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.4.5.107" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "nvidia-cusparse-cu12", version = "12.1.0.106", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "nvidia-nvjitlink-cu12", version = "12.9.86", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/1d/8de1e5c67099015c834315e333911273a8c6aaba78923dd1d1e25fc5f217/nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl", hash = "sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd", size = 124161928, upload-time = "2023-04-19T15:51:25.781Z" }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.6.1.9" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "nvidia-cublas-cu12", version = "12.4.5.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cusparse-cu12", version = "12.3.1.170", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/e1/5b9089a4b2a4790dfdea8b3a006052cfecff58139d5a4e34cb1a51df8d6f/nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl", hash = "sha256:19e33fa442bcfd085b3086c4ebf7e8debc07cfe01e11513cc6d332fd918ac260", size = 127936057, upload-time = "2024-04-03T20:58:28.735Z" }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.1.0.106" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "nvidia-nvjitlink-cu12", version = "12.9.86", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/5b/cfaeebf25cd9fdec14338ccb16f6b2c4c7fa9163aefcf057d86b9cc248bb/nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c", size = 195958278, upload-time = "2023-04-19T15:51:49.939Z" }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.3.1.170" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "nvidia-nvjitlink-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/f7/97a9ea26ed4bbbfc2d470994b8b4f338ef663be97b8f677519ac195e113d/nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ea4f11a2904e2a8dc4b1833cc1b5181cde564edd0d5cd33e3c168eff2d1863f1", size = 207454763, upload-time = "2024-04-03T20:58:59.995Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu12" +version = "0.6.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/a8/bcbb63b53a4b1234feeafb65544ee55495e1bb37ec31b999b963cbccfd1d/nvidia_cusparselt_cu12-0.6.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:df2c24502fd76ebafe7457dbc4716b2fec071aabaed4fb7691a201cde03704d9", size = 150057751, upload-time = "2024-07-23T02:35:53.074Z" }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.19.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/00/d0d4e48aef772ad5aebcf70b73028f88db6e5640b36c38e90445b7a57c45/nvidia_nccl_cu12-2.19.3-py3-none-manylinux1_x86_64.whl", hash = "sha256:a9734707a2c96443331c1e48c717024aa6678a0e2a4cb66b2c364d18cee6b48d", size = 165987969, upload-time = "2023-10-24T16:16:24.789Z" }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.21.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/99/12cd266d6233f47d00daf3a72739872bdc10267d0383508b0b9c84a18bb6/nvidia_nccl_cu12-2.21.5-py3-none-manylinux2014_x86_64.whl", hash = "sha256:8579076d30a8c24988834445f8d633c697d42397e92ffc3f63fa26766d25e0a0", size = 188654414, upload-time = "2024-04-03T15:32:57.427Z" }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/ff/847841bacfbefc97a00036e0fce5a0f086b640756dc38caea5e1bb002655/nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:06b3b9b25bf3f8af351d664978ca26a16d2c5127dbd53c0497e28d1fb9611d57", size = 21066810, upload-time = "2024-04-03T20:59:46.957Z" }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.9.86" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/0c/c75bbfb967457a0b7670b8ad267bfc4fffdf341c074e0a80db06c24ccfd4/nvidia_nvjitlink_cu12-12.9.86-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:e3f1171dbdc83c5932a45f0f4c99180a70de9bd2718c1ab77d14104f6d7147f9", size = 39748338, upload-time = "2025-06-05T20:10:25.613Z" }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.1.105" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/d3/8057f0587683ed2fcd4dbfbdfdfa807b9160b809976099d36b8f60d08f03/nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl", hash = "sha256:dc21cf308ca5691e7c04d962e213f8a4aa9bbfa23d95412f452254c2caeb09e5", size = 99138, upload-time = "2023-04-19T15:48:43.556Z" }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.4.127" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/20/199b8713428322a2f22b722c62b8cc278cc53dffa9705d744484b5035ee9/nvidia_nvtx_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl", hash = "sha256:781e950d9b9f60d8241ccea575b32f5105a5baf4c2351cab5256a24869f12a1a", size = 99144, upload-time = "2024-04-03T20:56:12.406Z" }, +] + +[[package]] +name = "onnx" +version = "1.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ml-dtypes" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "protobuf" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/93/942d2a0f6a70538eea042ce0445c8aefd46559ad153469986f29a743c01c/onnx-1.21.0.tar.gz", hash = "sha256:4d8b67d0aaec5864c87633188b91cc520877477ec0254eda122bef8be43cd764", size = 12074608, upload-time = "2026-03-27T21:33:36.118Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/28/a14b1845bf9302c3a787221e8f37cde4e7f930e10d95a8e22dd910aeb41d/onnx-1.21.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:e0c21cc5c7a41d1a509828e2b14fe9c30e807c6df611ec0fd64a47b8d4b16abd", size = 17966899, upload-time = "2026-03-27T21:32:15.53Z" }, + { url = "https://files.pythonhosted.org/packages/41/7b/788881bf022a4cfb7b0843782f88415ea51c805cee4a909dcf2e49bb8129/onnx-1.21.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1931bfcc222a4c9da6475f2ffffb84b97ab3876041ec639171c11ce802bee6a", size = 17534297, upload-time = "2026-03-27T21:32:18.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/51/eb64d4f2ec6caa98909aab5fbcfa24be9c059081e804bbb0012cc549ef89/onnx-1.21.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9b56ad04039fac6b028c07e54afa1ec7f75dd340f65311f2c292e41ed7aa4d9", size = 17616697, upload-time = "2026-03-27T21:32:21Z" }, + { url = "https://files.pythonhosted.org/packages/d2/4e/6b1f7800dae3407dc850e7e59d591ed8c83e9b3401e4cd57a1f612e400c6/onnx-1.21.0-cp310-cp310-win32.whl", hash = "sha256:3abd09872523c7e0362d767e4e63bd7c6bac52a5e2c3edbf061061fe540e2027", size = 16288893, upload-time = "2026-03-27T21:32:23.864Z" }, + { url = "https://files.pythonhosted.org/packages/a2/a8/89273e581d3943e20314af19b1596ab4d763f9c2eb07d4eaf4fb0593219b/onnx-1.21.0-cp310-cp310-win_amd64.whl", hash = "sha256:f2c7c234c568402e10db74e33d787e4144e394ae2bcbbf11000fbfe2e017ad68", size = 16443416, upload-time = "2026-03-27T21:32:26.655Z" }, + { url = "https://files.pythonhosted.org/packages/45/48/32e383aa6bc40b72a9fd419937aaa647078190c9bfccdc97b316d2dee687/onnx-1.21.0-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:2aca19949260875c14866fc77ea0bc37e4e809b24976108762843d328c92d3ce", size = 17968053, upload-time = "2026-03-27T21:32:29.558Z" }, + { url = "https://files.pythonhosted.org/packages/e2/26/5726e8df7d36e96bb3c679912d1a86af42f393d77aa17d6b98a97d4289ce/onnx-1.21.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82aa6ab51144df07c58c4850cb78d4f1ae969d8c0bf657b28041796d49ba6974", size = 17534821, upload-time = "2026-03-27T21:32:32.351Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2b/021dcd2dd50c3c71b7959d7368526da384a295c162fb4863f36057973f78/onnx-1.21.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10c3185a232089335581fabb98fba4e86d3e8246b8140f2e406082438100ebda", size = 17616664, upload-time = "2026-03-27T21:32:34.921Z" }, + { url = "https://files.pythonhosted.org/packages/12/00/afa32a46fa122a7ed42df1cfe8796922156a3725ba8fc581c4779c96e2fc/onnx-1.21.0-cp311-cp311-win32.whl", hash = "sha256:f53b3c15a3b539c16b99655c43c365622046d68c49b680c48eba4da2a4fb6f27", size = 16289035, upload-time = "2026-03-27T21:32:37.783Z" }, + { url = "https://files.pythonhosted.org/packages/73/8d/483cc980a24d4c0131d0af06d0ff6a37fb08ae90a7848ece8cef645194f1/onnx-1.21.0-cp311-cp311-win_amd64.whl", hash = "sha256:5f78c411743db317a76e5d009f84f7e3d5380411a1567a868e82461a1e5c775d", size = 16443748, upload-time = "2026-03-27T21:32:40.337Z" }, + { url = "https://files.pythonhosted.org/packages/38/78/9d06fd5aaaed1ec9cb8a3b70fbbf00c1bdc18db610771e96379f0ed58112/onnx-1.21.0-cp311-cp311-win_arm64.whl", hash = "sha256:ab6a488dabbb172eebc9f3b3e7ac68763f32b0c571626d4a5004608f866cc83d", size = 16406123, upload-time = "2026-03-27T21:32:45.159Z" }, + { url = "https://files.pythonhosted.org/packages/7d/ae/cb644ec84c25e63575d9d8790fdcc5d1a11d67d3f62f872edb35fa38d158/onnx-1.21.0-cp312-abi3-macosx_12_0_universal2.whl", hash = "sha256:fc2635400fe39ff37ebc4e75342cc54450eadadf39c540ff132c319bf4960095", size = 17965930, upload-time = "2026-03-27T21:32:48.089Z" }, + { url = "https://files.pythonhosted.org/packages/6f/b6/eeb5903586645ef8a49b4b7892580438741acc3df91d7a5bd0f3a59ea9cb/onnx-1.21.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9003d5206c01fa2ff4b46311566865d8e493e1a6998d4009ec6de39843f1b59b", size = 17531344, upload-time = "2026-03-27T21:32:50.837Z" }, + { url = "https://files.pythonhosted.org/packages/a7/00/4823f06357892d1e60d6f34e7299d2ba4ed2108c487cc394f7ce85a3ff14/onnx-1.21.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9261bd580fb8548c9c37b3c6750387eb8f21ea43c63880d37b2c622e1684285", size = 17613697, upload-time = "2026-03-27T21:32:54.222Z" }, + { url = "https://files.pythonhosted.org/packages/23/1d/391f3c567ae068c8ac4f1d1316bae97c9eb45e702f05975fe0e17ad441f0/onnx-1.21.0-cp312-abi3-win32.whl", hash = "sha256:9ea4e824964082811938a9250451d89c4ec474fe42dd36c038bfa5df31993d1e", size = 16287200, upload-time = "2026-03-27T21:32:57.277Z" }, + { url = "https://files.pythonhosted.org/packages/9c/a6/5eefbe5b40ea96de95a766bd2e0e751f35bdea2d4b951991ec9afaa69531/onnx-1.21.0-cp312-abi3-win_amd64.whl", hash = "sha256:458d91948ad9a7729a347550553b49ab6939f9af2cddf334e2116e45467dc61f", size = 16441045, upload-time = "2026-03-27T21:33:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/63/c4/0ed8dc037a39113d2a4d66e0005e07751c299c46b993f1ad5c2c35664c20/onnx-1.21.0-cp312-abi3-win_arm64.whl", hash = "sha256:ca14bc4842fccc3187eb538f07eabeb25a779b39388b006db4356c07403a7bbb", size = 16403134, upload-time = "2026-03-27T21:33:03.987Z" }, + { url = "https://files.pythonhosted.org/packages/f8/89/0e1a9beb536401e2f45ac88735e123f2735e12fc7b56ff6c11727e097526/onnx-1.21.0-cp313-cp313t-macosx_12_0_universal2.whl", hash = "sha256:257d1d1deb6a652913698f1e3f33ef1ca0aa69174892fe38946d4572d89dd94f", size = 17975430, upload-time = "2026-03-27T21:33:07.005Z" }, + { url = "https://files.pythonhosted.org/packages/ec/46/e6dc71a7b3b317265591b20a5f71d0ff5c0d26c24e52283139dc90c66038/onnx-1.21.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7cd7cb8f6459311bdb557cbf6c0ccc6d8ace11c304d1bba0a30b4a4688e245f8", size = 17537435, upload-time = "2026-03-27T21:33:09.765Z" }, + { url = "https://files.pythonhosted.org/packages/49/2e/27affcac63eaf2ef183a44fd1a1354b11da64a6c72fe6f3fdcf5571bcee5/onnx-1.21.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b58a4cfec8d9311b73dc083e4c1fa362069267881144c05139b3eba5dc3a840", size = 17617687, upload-time = "2026-03-27T21:33:12.619Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5c/ac8ed15e941593a3672ce424280b764979026317811f2e8508432bfc3429/onnx-1.21.0-cp313-cp313t-win_amd64.whl", hash = "sha256:1a9baf882562c4cebf79589bebb7cd71a20e30b51158cac3e3bbaf27da6163bd", size = 16449402, upload-time = "2026-03-27T21:33:15.555Z" }, + { url = "https://files.pythonhosted.org/packages/0e/aa/d2231e0dcaad838217afc64c306c8152a080134d2034e247cc973d577674/onnx-1.21.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bba12181566acf49b35875838eba49536a327b2944664b17125577d230c637ad", size = 16408273, upload-time = "2026-03-27T21:33:18.599Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.24.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +dependencies = [ + { name = "flatbuffers", marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "packaging", marker = "python_full_version < '3.11'" }, + { name = "protobuf", marker = "python_full_version < '3.11'" }, + { name = "sympy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "sympy", version = "1.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/41/3253db975a90c3ce1d475e2a230773a21cd7998537f0657947df6fb79861/onnxruntime-1.24.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3e6456801c66b095c5cd68e690ca25db970ea5202bd0c5b84a2c3ef7731c5a3c", size = 17332766, upload-time = "2026-03-05T17:18:59.714Z" }, + { url = "https://files.pythonhosted.org/packages/7e/c5/3af6b325f1492d691b23844d88ed26844c1164620860c5efe95c0e22782d/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b2ebc54c6d8281dccff78d4b06e47d4cf07535937584ab759448390a70f4978", size = 15130330, upload-time = "2026-03-05T16:34:53.831Z" }, + { url = "https://files.pythonhosted.org/packages/03/4b/f96b46c1866a293ed23ca2cf5e5a63d413ad3a951da60dd877e3c56cbbca/onnxruntime-1.24.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb56575d7794bf0781156955610c9e651c9504c64d42ec880784b6106244882d", size = 17213247, upload-time = "2026-03-05T17:17:59.812Z" }, + { url = "https://files.pythonhosted.org/packages/36/13/27cf4d8df2578747584e8758aeb0b673b60274048510257f1f084b15e80e/onnxruntime-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:c958222ef9eff54018332beecd32d5d94a3ab079d8821937b333811bf4da0d39", size = 12595530, upload-time = "2026-03-05T17:18:49.356Z" }, + { url = "https://files.pythonhosted.org/packages/19/8c/6d9f31e6bae72a8079be12ed8ba36c4126a571fad38ded0a1b96f60f6896/onnxruntime-1.24.3-cp311-cp311-win_arm64.whl", hash = "sha256:a8f761857ebaf58a85b9e42422d03207f1d39e6bb8fecfdbf613bac5b9710723", size = 12261715, upload-time = "2026-03-05T17:18:39.699Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7f/dfdc4e52600fde4c02d59bfe98c4b057931c1114b701e175aee311a9bc11/onnxruntime-1.24.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:0d244227dc5e00a9ae15a7ac1eba4c4460d7876dfecafe73fb00db9f1d914d91", size = 17342578, upload-time = "2026-03-05T17:19:02.403Z" }, + { url = "https://files.pythonhosted.org/packages/1c/dc/1f5489f7b21817d4ad352bf7a92a252bd5b438bcbaa7ad20ea50814edc79/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a9847b870b6cb462652b547bc98c49e0efb67553410a082fde1918a38707452", size = 15150105, upload-time = "2026-03-05T16:34:56.897Z" }, + { url = "https://files.pythonhosted.org/packages/28/7c/fd253da53594ab8efbefdc85b3638620ab1a6aab6eb7028a513c853559ce/onnxruntime-1.24.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b354afce3333f2859c7e8706d84b6c552beac39233bcd3141ce7ab77b4cabb5d", size = 17237101, upload-time = "2026-03-05T17:18:02.561Z" }, + { url = "https://files.pythonhosted.org/packages/71/5f/eaabc5699eeed6a9188c5c055ac1948ae50138697a0428d562ac970d7db5/onnxruntime-1.24.3-cp312-cp312-win_amd64.whl", hash = "sha256:44ea708c34965439170d811267c51281d3897ecfc4aa0087fa25d4a4c3eb2e4a", size = 12597638, upload-time = "2026-03-05T17:18:52.141Z" }, + { url = "https://files.pythonhosted.org/packages/cc/5c/d8066c320b90610dbeb489a483b132c3b3879b2f93f949fb5d30cfa9b119/onnxruntime-1.24.3-cp312-cp312-win_arm64.whl", hash = "sha256:48d1092b44ca2ba6f9543892e7c422c15a568481403c10440945685faf27a8d8", size = 12270943, upload-time = "2026-03-05T17:18:42.006Z" }, + { url = "https://files.pythonhosted.org/packages/51/8d/487ece554119e2991242d4de55de7019ac6e47ee8dfafa69fcf41d37f8ed/onnxruntime-1.24.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:34a0ea5ff191d8420d9c1332355644148b1bf1a0d10c411af890a63a9f662aa7", size = 17342706, upload-time = "2026-03-05T16:35:10.813Z" }, + { url = "https://files.pythonhosted.org/packages/dd/25/8b444f463c1ac6106b889f6235c84f01eec001eaf689c3eff8c69cf48fae/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fd2ec7bb0fabe42f55e8337cfc9b1969d0d14622711aac73d69b4bd5abb5ed7", size = 15149956, upload-time = "2026-03-05T16:34:59.264Z" }, + { url = "https://files.pythonhosted.org/packages/34/fc/c9182a3e1ab46940dd4f30e61071f59eee8804c1f641f37ce6e173633fb6/onnxruntime-1.24.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df8e70e732fe26346faaeec9147fa38bef35d232d2495d27e93dd221a2d473a9", size = 17237370, upload-time = "2026-03-05T17:18:05.258Z" }, + { url = "https://files.pythonhosted.org/packages/05/7e/3b549e1f4538514118bff98a1bcd6481dd9a17067f8c9af77151621c9a5c/onnxruntime-1.24.3-cp313-cp313-win_amd64.whl", hash = "sha256:2d3706719be6ad41d38a2250998b1d87758a20f6ea4546962e21dc79f1f1fd2b", size = 12597939, upload-time = "2026-03-05T17:18:54.772Z" }, + { url = "https://files.pythonhosted.org/packages/80/41/9696a5c4631a0caa75cc8bc4efd30938fd483694aa614898d087c3ee6d29/onnxruntime-1.24.3-cp313-cp313-win_arm64.whl", hash = "sha256:b082f3ba9519f0a1a1e754556bc7e635c7526ef81b98b3f78da4455d25f0437b", size = 12270705, upload-time = "2026-03-05T17:18:44.774Z" }, + { url = "https://files.pythonhosted.org/packages/b7/65/a26c5e59e3b210852ee04248cf8843c81fe7d40d94cf95343b66efe7eec9/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72f956634bc2e4bd2e8b006bef111849bd42c42dea37bd0a4c728404fdaf4d34", size = 15161796, upload-time = "2026-03-05T16:35:02.871Z" }, + { url = "https://files.pythonhosted.org/packages/f3/25/2035b4aa2ccb5be6acf139397731ec507c5f09e199ab39d3262b22ffa1ac/onnxruntime-1.24.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78d1f25eed4ab9959db70a626ed50ee24cf497e60774f59f1207ac8556399c4d", size = 17240936, upload-time = "2026-03-05T17:18:09.534Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.24.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "flatbuffers", marker = "python_full_version >= '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging", marker = "python_full_version >= '3.11'" }, + { name = "protobuf", marker = "python_full_version >= '3.11'" }, + { name = "sympy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/69/6c40720201012c6af9aa7d4ecdd620e521bd806dc6269d636fdd5c5aeebe/onnxruntime-1.24.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0bdfce8e9a6497cec584aab407b71bf697dac5e1b7b7974adc50bf7533bdb3a2", size = 17332131, upload-time = "2026-03-17T22:05:49.005Z" }, + { url = "https://files.pythonhosted.org/packages/38/e9/8c901c150ce0c368da38638f44152fb411059c0c7364b497c9e5c957321a/onnxruntime-1.24.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:046ff290045a387676941a02a8ae5c3ebec6b4f551ae228711968c4a69d8f6b7", size = 15152472, upload-time = "2026-03-17T22:03:26.176Z" }, + { url = "https://files.pythonhosted.org/packages/d5/b6/7a4df417cdd01e8f067a509e123ac8b31af450a719fa7ed81787dd6057ec/onnxruntime-1.24.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e54ad52e61d2d4618dcff8fa1480ac66b24ee2eab73331322db1049f11ccf330", size = 17222993, upload-time = "2026-03-17T22:04:34.485Z" }, + { url = "https://files.pythonhosted.org/packages/dd/59/8febe015f391aa1757fa5ba82c759ea4b6c14ef970132efb5e316665ba61/onnxruntime-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b43b63eb24a2bc8fc77a09be67587a570967a412cccb837b6245ccb546691153", size = 12594863, upload-time = "2026-03-17T22:05:38.749Z" }, + { url = "https://files.pythonhosted.org/packages/32/84/4155fcd362e8873eb6ce305acfeeadacd9e0e59415adac474bea3d9281bb/onnxruntime-1.24.4-cp311-cp311-win_arm64.whl", hash = "sha256:e26478356dba25631fb3f20112e345f8e8bf62c499bb497e8a559f7d69cf7e7b", size = 12259895, upload-time = "2026-03-17T22:05:28.812Z" }, + { url = "https://files.pythonhosted.org/packages/d7/38/31db1b232b4ba960065a90c1506ad7a56995cd8482033184e97fadca17cc/onnxruntime-1.24.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cad1c2b3f455c55678ab2a8caa51fb420c25e6e3cf10f4c23653cdabedc8de78", size = 17341875, upload-time = "2026-03-17T22:05:51.669Z" }, + { url = "https://files.pythonhosted.org/packages/aa/60/c4d1c8043eb42f8a9aa9e931c8c293d289c48ff463267130eca97d13357f/onnxruntime-1.24.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1a5c5a544b22f90859c88617ecb30e161ee3349fcc73878854f43d77f00558b5", size = 15172485, upload-time = "2026-03-17T22:03:32.182Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ab/5b68110e0460d73fad814d5bd11c7b1ddcce5c37b10177eb264d6a36e331/onnxruntime-1.24.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d640eb9f3782689b55cfa715094474cd5662f2f137be6a6f847a594b6e9705c", size = 17244912, upload-time = "2026-03-17T22:04:37.251Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f4/6b89e297b93704345f0f3f8c62229bee323ef25682a3f9b4f89a39324950/onnxruntime-1.24.4-cp312-cp312-win_amd64.whl", hash = "sha256:535b29475ca42b593c45fbb2152fbf1cdf3f287315bf650e6a724a0a1d065cdb", size = 12596856, upload-time = "2026-03-17T22:05:41.224Z" }, + { url = "https://files.pythonhosted.org/packages/43/06/8b8ec6e9e6a474fcd5d772453f627ad4549dfe3ab8c0bf70af5afcde551b/onnxruntime-1.24.4-cp312-cp312-win_arm64.whl", hash = "sha256:e6214096e14b7b52e3bee1903dc12dc7ca09cb65e26664668a4620cc5e6f9a90", size = 12270275, upload-time = "2026-03-17T22:05:31.132Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f0/8a21ec0a97e40abb7d8da1e8b20fb9e1af509cc6d191f6faa75f73622fb2/onnxruntime-1.24.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e99a48078baaefa2b50fe5836c319499f71f13f76ed32d0211f39109147a49e0", size = 17341922, upload-time = "2026-03-17T22:03:56.364Z" }, + { url = "https://files.pythonhosted.org/packages/8b/25/d7908de8e08cee9abfa15b8aa82349b79733ae5865162a3609c11598805d/onnxruntime-1.24.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4aaed1e5e1aaacf2343c838a30a7c3ade78f13eeb16817411f929d04040a13", size = 15172290, upload-time = "2026-03-17T22:03:37.124Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/105ec27a78c5aa0154a7c0cd8c41c19a97799c3b12fc30392928997e3be3/onnxruntime-1.24.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e30c972bc02e072911aabb6891453ec73795386c0af2b761b65444b8a4c4745f", size = 17244738, upload-time = "2026-03-17T22:04:40.625Z" }, + { url = "https://files.pythonhosted.org/packages/05/fb/a592736d968c2f58e12de4d52088dda8e0e724b26ad5c0487263adb45875/onnxruntime-1.24.4-cp313-cp313-win_amd64.whl", hash = "sha256:3b6ba8b0181a3aa88edab00eb01424ffc06f42e71095a91186c2249415fcff93", size = 12597435, upload-time = "2026-03-17T22:05:43.826Z" }, + { url = "https://files.pythonhosted.org/packages/ad/04/ae2479e9841b64bd2eb44f8a64756c62593f896514369a11243b1b86ca5c/onnxruntime-1.24.4-cp313-cp313-win_arm64.whl", hash = "sha256:71d6a5c1821d6e8586a024000ece458db8f2fc0ecd050435d45794827ce81e19", size = 12269852, upload-time = "2026-03-17T22:05:33.353Z" }, + { url = "https://files.pythonhosted.org/packages/b4/af/a479a536c4398ffaf49fbbe755f45d5b8726bdb4335ab31b537f3d7149b8/onnxruntime-1.24.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1700f559c8086d06b2a4d5de51e62cb4ff5e2631822f71a36db8c72383db71ee", size = 15176861, upload-time = "2026-03-17T22:03:40.143Z" }, + { url = "https://files.pythonhosted.org/packages/be/13/19f5da70c346a76037da2c2851ecbf1266e61d7f0dcdb887c667210d4608/onnxruntime-1.24.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c74e268dc808e61e63784d43f9ddcdaf50a776c2819e8bd1d1b11ef64bf7e36", size = 17247454, upload-time = "2026-03-17T22:04:46.643Z" }, +] + +[[package]] +name = "packaging" +version = "26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +dependencies = [ + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "python-dateutil", marker = "python_full_version < '3.11'" }, + { name = "pytz", marker = "python_full_version < '3.11'" }, + { name = "tzdata", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" }, + { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" }, + { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" }, + { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" }, + { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" }, + { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" }, + { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, +] + +[[package]] +name = "pandas" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "python-dateutil", marker = "python_full_version >= '3.11'" }, + { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/99/b342345300f13440fe9fe385c3c481e2d9a595ee3bab4d3219247ac94e9a/pandas-3.0.2.tar.gz", hash = "sha256:f4753e73e34c8d83221ba58f232433fca2748be8b18dbca02d242ed153945043", size = 4645855, upload-time = "2026-03-31T06:48:30.816Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/35/6411db530c618e0e0005187e35aa02ce60ae4c4c4d206964a2f978217c27/pandas-3.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a727a73cbdba2f7458dc82449e2315899d5140b449015d822f515749a46cbbe0", size = 10326926, upload-time = "2026-03-31T06:46:08.29Z" }, + { url = "https://files.pythonhosted.org/packages/c4/d3/b7da1d5d7dbdc5ef52ed7debd2b484313b832982266905315dad5a0bf0b1/pandas-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dbbd4aa20ca51e63b53bbde6a0fa4254b1aaabb74d2f542df7a7959feb1d760c", size = 9926987, upload-time = "2026-03-31T06:46:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/52/77/9b1c2d6070b5dbe239a7bc889e21bfa58720793fb902d1e070695d87c6d0/pandas-3.0.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:339dda302bd8369dedeae979cb750e484d549b563c3f54f3922cb8ff4978c5eb", size = 10757067, upload-time = "2026-03-31T06:46:14.903Z" }, + { url = "https://files.pythonhosted.org/packages/20/17/ec40d981705654853726e7ac9aea9ddbb4a5d9cf54d8472222f4f3de06c2/pandas-3.0.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:61c2fd96d72b983a9891b2598f286befd4ad262161a609c92dc1652544b46b76", size = 11258787, upload-time = "2026-03-31T06:46:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/90/e3/3f1126d43d3702ca8773871a81c9f15122a1f412342cc56284ffda5b1f70/pandas-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c934008c733b8bbea273ea308b73b3156f0181e5b72960790b09c18a2794fe1e", size = 11771616, upload-time = "2026-03-31T06:46:20.532Z" }, + { url = "https://files.pythonhosted.org/packages/2e/cf/0f4e268e1f5062e44a6bda9f925806721cd4c95c2b808a4c82ebe914f96b/pandas-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:60a80bb4feacbef5e1447a3f82c33209c8b7e07f28d805cfd1fb951e5cb443aa", size = 12337623, upload-time = "2026-03-31T06:46:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/97a6339859d4acb2536efb24feb6708e82f7d33b2ed7e036f2983fcced82/pandas-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:ed72cb3f45190874eb579c64fa92d9df74e98fd63e2be7f62bce5ace0ade61df", size = 9897372, upload-time = "2026-03-31T06:46:26.703Z" }, + { url = "https://files.pythonhosted.org/packages/8f/eb/781516b808a99ddf288143cec46b342b3016c3414d137da1fdc3290d8860/pandas-3.0.2-cp311-cp311-win_arm64.whl", hash = "sha256:f12b1a9e332c01e09510586f8ca9b108fd631fd656af82e452d7315ef6df5f9f", size = 9154922, upload-time = "2026-03-31T06:46:30.284Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b0/c20bd4d6d3f736e6bd6b55794e9cd0a617b858eaad27c8f410ea05d953b7/pandas-3.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:232a70ebb568c0c4d2db4584f338c1577d81e3af63292208d615907b698a0f18", size = 10347921, upload-time = "2026-03-31T06:46:33.36Z" }, + { url = "https://files.pythonhosted.org/packages/35/d0/4831af68ce30cc2d03c697bea8450e3225a835ef497d0d70f31b8cdde965/pandas-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:970762605cff1ca0d3f71ed4f3a769ea8f85fc8e6348f6e110b8fea7e6eb5a14", size = 9888127, upload-time = "2026-03-31T06:46:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/61/a9/16ea9346e1fc4a96e2896242d9bc674764fb9049b0044c0132502f7a771e/pandas-3.0.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aff4e6f4d722e0652707d7bcb190c445fe58428500c6d16005b02401764b1b3d", size = 10399577, upload-time = "2026-03-31T06:46:39.224Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a8/3a61a721472959ab0ce865ef05d10b0d6bfe27ce8801c99f33d4fa996e65/pandas-3.0.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef8b27695c3d3dc78403c9a7d5e59a62d5464a7e1123b4e0042763f7104dc74f", size = 10880030, upload-time = "2026-03-31T06:46:42.412Z" }, + { url = "https://files.pythonhosted.org/packages/da/65/7225c0ea4d6ce9cb2160a7fb7f39804871049f016e74782e5dade4d14109/pandas-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f8d68083e49e16b84734eb1a4dcae4259a75c90fb6e2251ab9a00b61120c06ab", size = 11409468, upload-time = "2026-03-31T06:46:45.2Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/46e7c76032639f2132359b5cf4c785dd8cf9aea5ea64699eac752f02b9db/pandas-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:32cc41f310ebd4a296d93515fcac312216adfedb1894e879303987b8f1e2b97d", size = 11936381, upload-time = "2026-03-31T06:46:48.293Z" }, + { url = "https://files.pythonhosted.org/packages/7b/8b/721a9cff6fa6a91b162eb51019c6243b82b3226c71bb6c8ef4a9bd65cbc6/pandas-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:a4785e1d6547d8427c5208b748ae2efb64659a21bd82bf440d4262d02bfa02a4", size = 9744993, upload-time = "2026-03-31T06:46:51.488Z" }, + { url = "https://files.pythonhosted.org/packages/d5/18/7f0bd34ae27b28159aa80f2a6799f47fda34f7fb938a76e20c7b7fe3b200/pandas-3.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:08504503f7101300107ecdc8df73658e4347586db5cfdadabc1592e9d7e7a0fd", size = 9056118, upload-time = "2026-03-31T06:46:54.548Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ca/3e639a1ea6fcd0617ca4e8ca45f62a74de33a56ae6cd552735470b22c8d3/pandas-3.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b5918ba197c951dec132b0c5929a00c0bf05d5942f590d3c10a807f6e15a57d3", size = 10321105, upload-time = "2026-03-31T06:46:57.327Z" }, + { url = "https://files.pythonhosted.org/packages/0b/77/dbc82ff2fb0e63c6564356682bf201edff0ba16c98630d21a1fb312a8182/pandas-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d606a041c89c0a474a4702d532ab7e73a14fe35c8d427b972a625c8e46373668", size = 9864088, upload-time = "2026-03-31T06:46:59.935Z" }, + { url = "https://files.pythonhosted.org/packages/5c/2b/341f1b04bbca2e17e13cd3f08c215b70ef2c60c5356ef1e8c6857449edc7/pandas-3.0.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:710246ba0616e86891b58ab95f2495143bb2bc83ab6b06747c74216f583a6ac9", size = 10369066, upload-time = "2026-03-31T06:47:02.792Z" }, + { url = "https://files.pythonhosted.org/packages/12/c5/cbb1ffefb20a93d3f0e1fdcda699fb84976210d411b008f97f48bf6ce27e/pandas-3.0.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d3cfe227c725b1f3dff4278b43d8c784656a42a9325b63af6b1492a8232209e", size = 10876780, upload-time = "2026-03-31T06:47:06.205Z" }, + { url = "https://files.pythonhosted.org/packages/98/fe/2249ae5e0a69bd0ddf17353d0a5d26611d70970111f5b3600cdc8be883e7/pandas-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c3b723df9087a9a9a840e263ebd9f88b64a12075d1bf2ea401a5a42f254f084d", size = 11375181, upload-time = "2026-03-31T06:47:09.383Z" }, + { url = "https://files.pythonhosted.org/packages/de/64/77a38b09e70b6464883b8d7584ab543e748e42c1b5d337a2ee088e0df741/pandas-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a3096110bf9eac0070b7208465f2740e2d8a670d5cb6530b5bb884eca495fd39", size = 11928899, upload-time = "2026-03-31T06:47:12.686Z" }, + { url = "https://files.pythonhosted.org/packages/5e/52/42855bf626868413f761addd574acc6195880ae247a5346477a4361c3acb/pandas-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:07a10f5c36512eead51bc578eb3354ad17578b22c013d89a796ab5eee90cd991", size = 9746574, upload-time = "2026-03-31T06:47:15.64Z" }, + { url = "https://files.pythonhosted.org/packages/88/39/21304ae06a25e8bf9fc820d69b29b2c495b2ae580d1e143146c309941760/pandas-3.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:5fdbfa05931071aba28b408e59226186b01eb5e92bea2ab78b65863ca3228d84", size = 9047156, upload-time = "2026-03-31T06:47:18.595Z" }, + { url = "https://files.pythonhosted.org/packages/72/20/7defa8b27d4f330a903bb68eea33be07d839c5ea6bdda54174efcec0e1d2/pandas-3.0.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:dbc20dea3b9e27d0e66d74c42b2d0c1bed9c2ffe92adea33633e3bedeb5ac235", size = 10756238, upload-time = "2026-03-31T06:47:22.012Z" }, + { url = "https://files.pythonhosted.org/packages/e9/95/49433c14862c636afc0e9b2db83ff16b3ad92959364e52b2955e44c8e94c/pandas-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b75c347eff42497452116ce05ef461822d97ce5b9ff8df6edacb8076092c855d", size = 10408520, upload-time = "2026-03-31T06:47:25.197Z" }, + { url = "https://files.pythonhosted.org/packages/3b/f8/462ad2b5881d6b8ec8e5f7ed2ea1893faa02290d13870a1600fe72ad8efc/pandas-3.0.2-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1478075142e83a5571782ad007fb201ed074bdeac7ebcc8890c71442e96adf7", size = 10324154, upload-time = "2026-03-31T06:47:28.097Z" }, + { url = "https://files.pythonhosted.org/packages/0a/65/d1e69b649cbcddda23ad6e4c40ef935340f6f652a006e5cbc3555ac8adb3/pandas-3.0.2-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5880314e69e763d4c8b27937090de570f1fb8d027059a7ada3f7f8e98bdcb677", size = 10714449, upload-time = "2026-03-31T06:47:30.85Z" }, + { url = "https://files.pythonhosted.org/packages/47/a4/85b59bc65b8190ea3689882db6cdf32a5003c0ccd5a586c30fdcc3ffc4fc/pandas-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b5329e26898896f06035241a626d7c335daa479b9bbc82be7c2742d048e41172", size = 11338475, upload-time = "2026-03-31T06:47:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c4/bc6966c6e38e5d9478b935272d124d80a589511ed1612a5d21d36f664c68/pandas-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:81526c4afd31971f8b62671442a4b2b51e0aa9acc3819c9f0f12a28b6fcf85f1", size = 11786568, upload-time = "2026-03-31T06:47:36.941Z" }, + { url = "https://files.pythonhosted.org/packages/e8/74/09298ca9740beed1d3504e073d67e128aa07e5ca5ca2824b0c674c0b8676/pandas-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:7cadd7e9a44ec13b621aec60f9150e744cfc7a3dd32924a7e2f45edff31823b0", size = 10488652, upload-time = "2026-03-31T06:47:40.612Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/aa/d0b28e1c811cd4d5f5c2bfe2e022292bd255ae5744a3b9ac7d6c8f72dd75/pillow-12.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:a4e8f36e677d3336f35089648c8955c51c6d386a13cf6ee9c189c5f5bd713a9f", size = 5354355, upload-time = "2026-04-01T14:42:15.402Z" }, + { url = "https://files.pythonhosted.org/packages/27/8e/1d5b39b8ae2bd7650d0c7b6abb9602d16043ead9ebbfef4bc4047454da2a/pillow-12.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e589959f10d9824d39b350472b92f0ce3b443c0a3442ebf41c40cb8361c5b97", size = 4695871, upload-time = "2026-04-01T14:42:18.234Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c5/dcb7a6ca6b7d3be41a76958e90018d56c8462166b3ef223150360850c8da/pillow-12.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a52edc8bfff4429aaabdf4d9ee0daadbbf8562364f940937b941f87a4290f5ff", size = 6269734, upload-time = "2026-04-01T14:42:20.608Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f1/aa1bb13b2f4eba914e9637893c73f2af8e48d7d4023b9d3750d4c5eb2d0c/pillow-12.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975385f4776fafde056abb318f612ef6285b10a1f12b8570f3647ad0d74b48ec", size = 8076080, upload-time = "2026-04-01T14:42:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2a/8c79d6a53169937784604a8ae8d77e45888c41537f7f6f65ed1f407fe66d/pillow-12.2.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd9c0c7a0c681a347b3194c500cb1e6ca9cab053ea4d82a5cf45b6b754560136", size = 6382236, upload-time = "2026-04-01T14:42:25.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/42/bbcb6051030e1e421d103ce7a8ecadf837aa2f39b8f82ef1a8d37c3d4ebc/pillow-12.2.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88d387ff40b3ff7c274947ed3125dedf5262ec6919d83946753b5f3d7c67ea4c", size = 7070220, upload-time = "2026-04-01T14:42:28.68Z" }, + { url = "https://files.pythonhosted.org/packages/3f/e1/c2a7d6dd8cfa6b231227da096fd2d58754bab3603b9d73bf609d3c18b64f/pillow-12.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c4167c34b0d8ba05b547a3bb23578d0ba17b80a5593f93bd8ecb123dd336a3", size = 6493124, upload-time = "2026-04-01T14:42:31.579Z" }, + { url = "https://files.pythonhosted.org/packages/5f/41/7c8617da5d32e1d2f026e509484fdb6f3ad7efaef1749a0c1928adbb099e/pillow-12.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34c0d99ecccea270c04882cb3b86e7b57296079c9a4aff88cb3b33563d95afaa", size = 7194324, upload-time = "2026-04-01T14:42:34.615Z" }, + { url = "https://files.pythonhosted.org/packages/2d/de/a777627e19fd6d62f84070ee1521adde5eeda4855b5cf60fe0b149118bca/pillow-12.2.0-cp310-cp310-win32.whl", hash = "sha256:b85f66ae9eb53e860a873b858b789217ba505e5e405a24b85c0464822fe88032", size = 6376363, upload-time = "2026-04-01T14:42:37.19Z" }, + { url = "https://files.pythonhosted.org/packages/e7/34/fc4cb5204896465842767b96d250c08410f01f2f28afc43b257de842eed5/pillow-12.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:673aa32138f3e7531ccdbca7b3901dba9b70940a19ccecc6a37c77d5fdeb05b5", size = 7083523, upload-time = "2026-04-01T14:42:39.62Z" }, + { url = "https://files.pythonhosted.org/packages/2d/a0/32852d36bc7709f14dc3f64f929a275e958ad8c19a6deba9610d458e28b3/pillow-12.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:3e080565d8d7c671db5802eedfb438e5565ffa40115216eabb8cd52d0ecce024", size = 2463318, upload-time = "2026-04-01T14:42:42.063Z" }, + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" }, +] + +[[package]] +name = "protobuf" +version = "7.34.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" }, + { url = "https://files.pythonhosted.org/packages/eb/9d/aa69df2724ff63efa6f72307b483ce0827f4347cc6d6df24b59e26659fef/protobuf-7.34.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:5185e0e948d07abe94bb76ec9b8416b604cfe5da6f871d67aad30cbf24c3110b", size = 325753, upload-time = "2026-03-20T17:34:38.751Z" }, + { url = "https://files.pythonhosted.org/packages/92/e8/d174c91fd48e50101943f042b09af9029064810b734e4160bbe282fa1caa/protobuf-7.34.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:403b093a6e28a960372b44e5eb081775c9b056e816a8029c61231743d63f881a", size = 340198, upload-time = "2026-03-20T17:34:39.871Z" }, + { url = "https://files.pythonhosted.org/packages/53/1b/3b431694a4dc6d37b9f653f0c64b0a0d9ec074ee810710c0c3da21d67ba7/protobuf-7.34.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:8ff40ce8cd688f7265326b38d5a1bed9bfdf5e6723d49961432f83e21d5713e4", size = 324267, upload-time = "2026-03-20T17:34:41.1Z" }, + { url = "https://files.pythonhosted.org/packages/85/29/64de04a0ac142fb685fd09999bc3d337943fb386f3a0ec57f92fd8203f97/protobuf-7.34.1-cp310-abi3-win32.whl", hash = "sha256:34b84ce27680df7cca9f231043ada0daa55d0c44a2ddfaa58ec1d0d89d8bf60a", size = 426628, upload-time = "2026-03-20T17:34:42.536Z" }, + { url = "https://files.pythonhosted.org/packages/4d/87/cb5e585192a22b8bd457df5a2c16a75ea0db9674c3a0a39fc9347d84e075/protobuf-7.34.1-cp310-abi3-win_amd64.whl", hash = "sha256:e97b55646e6ce5cbb0954a8c28cd39a5869b59090dfaa7df4598a7fba869468c", size = 437901, upload-time = "2026-03-20T17:34:44.112Z" }, + { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "platformdirs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/ef/3bae0e537cfe91e8431efcba4434463d2c5a65f5a89edd47c6cf2f03c55f/python_discovery-1.2.2.tar.gz", hash = "sha256:876e9c57139eb757cb5878cbdd9ae5379e5d96266c99ef731119e04fffe533bb", size = 58872, upload-time = "2026-04-07T17:28:49.249Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/db/795879cc3ddfe338599bddea6388cc5100b088db0a4caf6e6c1af1c27e04/python_discovery-1.2.2-py3-none-any.whl", hash = "sha256:e1ae95d9af875e78f15e19aed0c6137ab1bb49c200f21f5061786490c9585c7a", size = 31894, upload-time = "2026-04-07T17:28:48.09Z" }, +] + +[[package]] +name = "pytz" +version = "2026.1.post1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", hash = "sha256:3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1", size = 321088, upload-time = "2026-03-03T07:47:50.683Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, +] + +[[package]] +name = "reportlab" +version = "4.4.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "charset-normalizer" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/57/28bfbf0a775b618b6e4d854ef8dd3f5c8988e5d614d8898703502a35f61c/reportlab-4.4.10.tar.gz", hash = "sha256:5cbbb34ac3546039d0086deb2938cdec06b12da3cdb836e813258eb33cd28487", size = 3714962, upload-time = "2026-02-12T10:45:21.325Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/2e/e1798b8b248e1517e74c6cdf10dd6edd485044e7edf46b5f11ffcc5a0add/reportlab-4.4.10-py3-none-any.whl", hash = "sha256:5abc815746ae2bc44e7ff25db96814f921349ca814c992c7eac3c26029bf7c24", size = 1955400, upload-time = "2026-02-12T10:45:18.828Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/d9/aa3f7d59a10ef6b14fe3431706f854dbf03c5976be614a9796d36326810c/ruff-0.15.10.tar.gz", hash = "sha256:d1f86e67ebfdef88e00faefa1552b5e510e1d35f3be7d423dc7e84e63788c94e", size = 4631728, upload-time = "2026-04-09T14:06:09.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/00/a1c2fdc9939b2c03691edbda290afcd297f1f389196172826b03d6b6a595/ruff-0.15.10-py3-none-linux_armv6l.whl", hash = "sha256:0744e31482f8f7d0d10a11fcbf897af272fefdfcb10f5af907b18c2813ff4d5f", size = 10563362, upload-time = "2026-04-09T14:06:21.189Z" }, + { url = "https://files.pythonhosted.org/packages/5c/15/006990029aea0bebe9d33c73c3e28c80c391ebdba408d1b08496f00d422d/ruff-0.15.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b1e7c16ea0ff5a53b7c2df52d947e685973049be1cdfe2b59a9c43601897b22e", size = 10951122, upload-time = "2026-04-09T14:06:02.236Z" }, + { url = "https://files.pythonhosted.org/packages/f2/c0/4ac978fe874d0618c7da647862afe697b281c2806f13ce904ad652fa87e4/ruff-0.15.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:93cc06a19e5155b4441dd72808fdf84290d84ad8a39ca3b0f994363ade4cebb1", size = 10314005, upload-time = "2026-04-09T14:06:00.026Z" }, + { url = "https://files.pythonhosted.org/packages/da/73/c209138a5c98c0d321266372fc4e33ad43d506d7e5dd817dd89b60a8548f/ruff-0.15.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83e1dd04312997c99ea6965df66a14fb4f03ba978564574ffc68b0d61fd3989e", size = 10643450, upload-time = "2026-04-09T14:05:42.137Z" }, + { url = "https://files.pythonhosted.org/packages/ec/76/0deec355d8ec10709653635b1f90856735302cb8e149acfdf6f82a5feb70/ruff-0.15.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8154d43684e4333360fedd11aaa40b1b08a4e37d8ffa9d95fee6fa5b37b6fab1", size = 10379597, upload-time = "2026-04-09T14:05:49.984Z" }, + { url = "https://files.pythonhosted.org/packages/dc/be/86bba8fc8798c081e28a4b3bb6d143ccad3fd5f6f024f02002b8f08a9fa3/ruff-0.15.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ab88715f3a6deb6bde6c227f3a123410bec7b855c3ae331b4c006189e895cef", size = 11146645, upload-time = "2026-04-09T14:06:12.246Z" }, + { url = "https://files.pythonhosted.org/packages/a8/89/140025e65911b281c57be1d385ba1d932c2366ca88ae6663685aed8d4881/ruff-0.15.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a768ff5969b4f44c349d48edf4ab4f91eddb27fd9d77799598e130fb628aa158", size = 12030289, upload-time = "2026-04-09T14:06:04.776Z" }, + { url = "https://files.pythonhosted.org/packages/88/de/ddacca9545a5e01332567db01d44bd8cf725f2db3b3d61a80550b48308ea/ruff-0.15.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ee3ef42dab7078bda5ff6a1bcba8539e9857deb447132ad5566a038674540d0", size = 11496266, upload-time = "2026-04-09T14:05:55.485Z" }, + { url = "https://files.pythonhosted.org/packages/bc/bb/7ddb00a83760ff4a83c4e2fc231fd63937cc7317c10c82f583302e0f6586/ruff-0.15.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51cb8cc943e891ba99989dd92d61e29b1d231e14811db9be6440ecf25d5c1609", size = 11256418, upload-time = "2026-04-09T14:05:57.69Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8d/55de0d35aacf6cd50b6ee91ee0f291672080021896543776f4170fc5c454/ruff-0.15.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:e59c9bdc056a320fb9ea1700a8d591718b8faf78af065484e801258d3a76bc3f", size = 11288416, upload-time = "2026-04-09T14:05:44.695Z" }, + { url = "https://files.pythonhosted.org/packages/68/cf/9438b1a27426ec46a80e0a718093c7f958ef72f43eb3111862949ead3cc1/ruff-0.15.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:136c00ca2f47b0018b073f28cb5c1506642a830ea941a60354b0e8bc8076b151", size = 10621053, upload-time = "2026-04-09T14:05:52.782Z" }, + { url = "https://files.pythonhosted.org/packages/4c/50/e29be6e2c135e9cd4cb15fbade49d6a2717e009dff3766dd080fcb82e251/ruff-0.15.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8b80a2f3c9c8a950d6237f2ca12b206bccff626139be9fa005f14feb881a1ae8", size = 10378302, upload-time = "2026-04-09T14:06:14.361Z" }, + { url = "https://files.pythonhosted.org/packages/18/2f/e0b36a6f99c51bb89f3a30239bc7bf97e87a37ae80aa2d6542d6e5150364/ruff-0.15.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:e3e53c588164dc025b671c9df2462429d60357ea91af7e92e9d56c565a9f1b07", size = 10850074, upload-time = "2026-04-09T14:06:16.581Z" }, + { url = "https://files.pythonhosted.org/packages/11/08/874da392558ce087a0f9b709dc6ec0d60cbc694c1c772dab8d5f31efe8cb/ruff-0.15.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b0c52744cf9f143a393e284125d2576140b68264a93c6716464e129a3e9adb48", size = 11358051, upload-time = "2026-04-09T14:06:18.948Z" }, + { url = "https://files.pythonhosted.org/packages/e4/46/602938f030adfa043e67112b73821024dc79f3ab4df5474c25fa4c1d2d14/ruff-0.15.10-py3-none-win32.whl", hash = "sha256:d4272e87e801e9a27a2e8df7b21011c909d9ddd82f4f3281d269b6ba19789ca5", size = 10588964, upload-time = "2026-04-09T14:06:07.14Z" }, + { url = "https://files.pythonhosted.org/packages/25/b6/261225b875d7a13b33a6d02508c39c28450b2041bb01d0f7f1a83d569512/ruff-0.15.10-py3-none-win_amd64.whl", hash = "sha256:28cb32d53203242d403d819fd6983152489b12e4a3ae44993543d6fe62ab42ed", size = 11745044, upload-time = "2026-04-09T14:05:39.473Z" }, + { url = "https://files.pythonhosted.org/packages/58/ed/dea90a65b7d9e69888890fb14c90d7f51bf0c1e82ad800aeb0160e4bacfd/ruff-0.15.10-py3-none-win_arm64.whl", hash = "sha256:601d1610a9e1f1c2165a4f561eeaa2e2ea1e97f3287c5aa258d3dab8b57c6188", size = 11035607, upload-time = "2026-04-09T14:05:47.593Z" }, +] + +[[package]] +name = "setuptools" +version = "81.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/1c/73e719955c59b8e424d015ab450f51c0af856ae46ea2da83eba51cc88de1/setuptools-81.0.0.tar.gz", hash = "sha256:487b53915f52501f0a79ccfd0c02c165ffe06631443a886740b91af4b7a5845a", size = 1198299, upload-time = "2026-02-06T21:10:39.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sympy" +version = "1.13.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +dependencies = [ + { name = "mpmath", marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/99/5a5b6f19ff9f083671ddf7b9632028436167cd3d33e11015754e41b249a4/sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f", size = 7533040, upload-time = "2024-07-19T09:26:51.238Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/fe/81695a1aa331a842b582453b605175f419fe8540355886031328089d840a/sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8", size = 6189177, upload-time = "2024-07-19T09:26:48.863Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "mpmath", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "torch" +version = "2.2.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "filelock", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "fsspec", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "jinja2", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-cupti-cu12", version = "12.1.105", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-nvrtc-cu12", version = "12.1.105", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-runtime-cu12", version = "12.1.105", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cudnn-cu12", version = "8.9.2.26", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufft-cu12", version = "11.0.2.54", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-curand-cu12", version = "10.3.2.106", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusolver-cu12", version = "11.4.5.107", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparse-cu12", version = "12.1.0.106", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu12", version = "2.19.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvtx-cu12", version = "12.1.105", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "sympy", version = "1.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, + { name = "triton", version = "2.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/b3/1fcc3bccfddadfd6845dcbfe26eb4b099f1dfea5aa0e5cfb92b3c98dba5b/torch-2.2.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:bc889d311a855dd2dfd164daf8cc903a6b7273a747189cebafdd89106e4ad585", size = 755526581, upload-time = "2024-03-27T21:06:46.5Z" }, + { url = "https://files.pythonhosted.org/packages/3a/81/684d99e536b20e869a7c1222cf1dd233311fb05d3628e9570992bfb65760/torch-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:11e8fe261233aeabd67696d6b993eeb0896faa175c6b41b9a6c9f0334bdad1c5", size = 198579616, upload-time = "2024-03-27T21:10:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/3b/55/7192974ab13e5e5577f45d14ce70d42f5a9a686b4f57bbe8c9ab45c4a61a/torch-2.2.2-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:b2e2200b245bd9f263a0d41b6a2dab69c4aca635a01b30cca78064b0ef5b109e", size = 150788930, upload-time = "2024-03-27T21:08:09.98Z" }, + { url = "https://files.pythonhosted.org/packages/c3/33/d7a6123231bd4d04c7005dde8507235772f3bc4622a25f3a88c016415d49/torch-2.2.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:ad4c03b786e074f46606f4151c0a1e3740268bcf29fbd2fdf6666d66341c1dcb", size = 755555407, upload-time = "2024-03-27T21:09:48.166Z" }, + { url = "https://files.pythonhosted.org/packages/5c/01/5ab75f138bf32d7a69df61e4997e24eccad87cc009f5fb7e2a31af8a4036/torch-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:f9ef0a648310435511e76905f9b89612e45ef2c8b023bee294f5e6f7e73a3e7c", size = 198584125, upload-time = "2024-03-27T21:10:06.958Z" }, + { url = "https://files.pythonhosted.org/packages/3f/14/e105b8ef6d324e789c1589e95cb0ab63f3e07c2216d68b1178b7c21b7d2a/torch-2.2.2-cp311-none-macosx_10_9_x86_64.whl", hash = "sha256:95b9b44f3bcebd8b6cd8d37ec802048c872d9c567ba52c894bba90863a439059", size = 150796474, upload-time = "2024-03-27T21:09:29.142Z" }, + { url = "https://files.pythonhosted.org/packages/4c/0c/d8f77363a7a3350c96e6c9db4ffb101d1c0487cc0b8cdaae1e4bfb2800ad/torch-2.2.2-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:cf12cdb66c9c940227ad647bc9cf5dba7e8640772ae10dfe7569a0c1e2a28aca", size = 755466713, upload-time = "2024-03-27T21:08:48.868Z" }, + { url = "https://files.pythonhosted.org/packages/72/ce/beca89dcdcf4323880d3b959ef457a4c61a95483af250e6892fec9174162/torch-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:451331406b760f4b1ab298ddd536486ab3cfb1312614cfe0532133535be60bea", size = 198528804, upload-time = "2024-03-27T21:09:14.691Z" }, + { url = "https://files.pythonhosted.org/packages/79/78/29dcab24a344ffd9ee9549ec0ab2c7885c13df61cde4c65836ee275efaeb/torch-2.2.2-cp312-none-macosx_10_9_x86_64.whl", hash = "sha256:eb4d6e9d3663e26cd27dc3ad266b34445a16b54908e74725adb241aa56987533", size = 150797270, upload-time = "2024-03-27T21:08:29.623Z" }, +] + +[[package]] +name = "torch" +version = "2.6.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'emscripten'", + "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.11' and platform_machine != 's390x' and platform_machine != 'x86_64'", + "python_full_version < '3.11' and platform_machine == 's390x'", +] +dependencies = [ + { name = "filelock", marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, + { name = "fsspec", marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, + { name = "jinja2", marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and platform_machine != 'x86_64'" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "nvidia-cublas-cu12", version = "12.4.5.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-cupti-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-nvrtc-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-runtime-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cudnn-cu12", version = "9.1.0.70", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufft-cu12", version = "11.2.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-curand-cu12", version = "10.3.5.147", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusolver-cu12", version = "11.6.1.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparse-cu12", version = "12.3.1.170", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu12", marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu12", version = "2.21.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvjitlink-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvtx-cu12", version = "12.4.127", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "setuptools", marker = "python_full_version >= '3.12'" }, + { name = "sympy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, + { name = "triton", version = "3.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "typing-extensions", marker = "python_full_version >= '3.11' or platform_machine != 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/81/aa9ab58ec10264c1abe62c8b73f5086c3c558885d6beecebf699f0dbeaeb/torch-2.6.0-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:6860df13d9911ac158f4c44031609700e1eba07916fff62e21e6ffa0a9e01961", size = 766685561, upload-time = "2025-01-29T16:19:12.12Z" }, + { url = "https://files.pythonhosted.org/packages/86/86/e661e229df2f5bfc6eab4c97deb1286d598bbeff31ab0cdb99b3c0d53c6f/torch-2.6.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c4f103a49830ce4c7561ef4434cc7926e5a5fe4e5eb100c19ab36ea1e2b634ab", size = 95751887, upload-time = "2025-01-29T16:27:50.77Z" }, + { url = "https://files.pythonhosted.org/packages/20/e0/5cb2f8493571f0a5a7273cd7078f191ac252a402b5fb9cb6091f14879109/torch-2.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:56eeaf2ecac90da5d9e35f7f35eb286da82673ec3c582e310a8d1631a1c02341", size = 204165139, upload-time = "2025-01-29T16:27:11.63Z" }, + { url = "https://files.pythonhosted.org/packages/e5/16/ea1b7842413a7b8a5aaa5e99e8eaf3da3183cc3ab345ad025a07ff636301/torch-2.6.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:09e06f9949e1a0518c5b09fe95295bc9661f219d9ecb6f9893e5123e10696628", size = 66520221, upload-time = "2025-01-29T16:22:18.862Z" }, + { url = "https://files.pythonhosted.org/packages/78/a9/97cbbc97002fff0de394a2da2cdfa859481fdca36996d7bd845d50aa9d8d/torch-2.6.0-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:7979834102cd5b7a43cc64e87f2f3b14bd0e1458f06e9f88ffa386d07c7446e1", size = 766715424, upload-time = "2025-01-29T16:25:15.874Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fa/134ce8f8a7ea07f09588c9cc2cea0d69249efab977707cf67669431dcf5c/torch-2.6.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:ccbd0320411fe1a3b3fec7b4d3185aa7d0c52adac94480ab024b5c8f74a0bf1d", size = 95759416, upload-time = "2025-01-29T16:27:38.429Z" }, + { url = "https://files.pythonhosted.org/packages/11/c5/2370d96b31eb1841c3a0883a492c15278a6718ccad61bb6a649c80d1d9eb/torch-2.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:46763dcb051180ce1ed23d1891d9b1598e07d051ce4c9d14307029809c4d64f7", size = 204164970, upload-time = "2025-01-29T16:26:16.182Z" }, + { url = "https://files.pythonhosted.org/packages/0b/fa/f33a4148c6fb46ca2a3f8de39c24d473822d5774d652b66ed9b1214da5f7/torch-2.6.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:94fc63b3b4bedd327af588696559f68c264440e2503cc9e6954019473d74ae21", size = 66530713, upload-time = "2025-01-29T16:26:38.881Z" }, + { url = "https://files.pythonhosted.org/packages/e5/35/0c52d708144c2deb595cd22819a609f78fdd699b95ff6f0ebcd456e3c7c1/torch-2.6.0-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:2bb8987f3bb1ef2675897034402373ddfc8f5ef0e156e2d8cfc47cacafdda4a9", size = 766624563, upload-time = "2025-01-29T16:23:19.084Z" }, + { url = "https://files.pythonhosted.org/packages/01/d6/455ab3fbb2c61c71c8842753b566012e1ed111e7a4c82e0e1c20d0c76b62/torch-2.6.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:b789069020c5588c70d5c2158ac0aa23fd24a028f34a8b4fcb8fcb4d7efcf5fb", size = 95607867, upload-time = "2025-01-29T16:25:55.649Z" }, + { url = "https://files.pythonhosted.org/packages/18/cf/ae99bd066571656185be0d88ee70abc58467b76f2f7c8bfeb48735a71fe6/torch-2.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:7e1448426d0ba3620408218b50aa6ada88aeae34f7a239ba5431f6c8774b1239", size = 204120469, upload-time = "2025-01-29T16:24:01.821Z" }, + { url = "https://files.pythonhosted.org/packages/81/b4/605ae4173aa37fb5aa14605d100ff31f4f5d49f617928c9f486bb3aaec08/torch-2.6.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:9a610afe216a85a8b9bc9f8365ed561535c93e804c2a317ef7fabcc5deda0989", size = 66532538, upload-time = "2025-01-29T16:24:18.976Z" }, + { url = "https://files.pythonhosted.org/packages/24/85/ead1349fc30fe5a32cadd947c91bda4a62fbfd7f8c34ee61f6398d38fb48/torch-2.6.0-cp313-cp313-manylinux1_x86_64.whl", hash = "sha256:4874a73507a300a5d089ceaff616a569e7bb7c613c56f37f63ec3ffac65259cf", size = 766626191, upload-time = "2025-01-29T16:17:26.26Z" }, + { url = "https://files.pythonhosted.org/packages/dd/b0/26f06f9428b250d856f6d512413e9e800b78625f63801cbba13957432036/torch-2.6.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a0d5e1b9874c1a6c25556840ab8920569a7a4137afa8a63a32cee0bc7d89bd4b", size = 95611439, upload-time = "2025-01-29T16:21:21.061Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9c/fc5224e9770c83faed3a087112d73147cd7c7bfb7557dcf9ad87e1dda163/torch-2.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:510c73251bee9ba02ae1cb6c9d4ee0907b3ce6020e62784e2d7598e0cfa4d6cc", size = 204126475, upload-time = "2025-01-29T16:21:55.394Z" }, + { url = "https://files.pythonhosted.org/packages/88/8b/d60c0491ab63634763be1537ad488694d316ddc4a20eaadd639cedc53971/torch-2.6.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:ff96f4038f8af9f7ec4231710ed4549da1bdebad95923953a25045dcf6fd87e2", size = 66536783, upload-time = "2025-01-29T16:22:08.559Z" }, +] + +[[package]] +name = "triton" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_machine == 'x86_64'", +] +dependencies = [ + { name = "filelock", marker = "python_full_version < '3.11' and platform_machine == 'x86_64'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/05/ed974ce87fe8c8843855daa2136b3409ee1c126707ab54a8b72815c08b49/triton-2.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2294514340cfe4e8f4f9e5c66c702744c4a117d25e618bd08469d0bfed1e2e5", size = 167900779, upload-time = "2024-01-10T03:11:56.576Z" }, + { url = "https://files.pythonhosted.org/packages/bd/ac/3974caaa459bf2c3a244a84be8d17561f631f7d42af370fc311defeca2fb/triton-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da58a152bddb62cafa9a857dd2bc1f886dbf9f9c90a2b5da82157cd2b34392b0", size = 167928356, upload-time = "2024-01-10T03:12:05.923Z" }, + { url = "https://files.pythonhosted.org/packages/0e/49/2e1bbae4542b8f624e409540b4197e37ab22a88e8685e99debe721cc2b50/triton-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af58716e721460a61886668b205963dc4d1e4ac20508cc3f623aef0d70283d5", size = 167933985, upload-time = "2024-01-10T03:12:14.556Z" }, +] + +[[package]] +name = "triton" +version = "3.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/65/3ffa90e158a2c82f0716eee8d26a725d241549b7d7aaf7e4f44ac03ebd89/triton-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3e54983cd51875855da7c68ec05c05cf8bb08df361b1d5b69e05e40b0c9bd62", size = 253090354, upload-time = "2025-01-22T19:12:21.872Z" }, + { url = "https://files.pythonhosted.org/packages/a7/2e/757d2280d4fefe7d33af7615124e7e298ae7b8e3bc4446cdb8e88b0f9bab/triton-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8009a1fb093ee8546495e96731336a33fb8856a38e45bb4ab6affd6dbc3ba220", size = 253157636, upload-time = "2025-01-22T19:12:51.322Z" }, + { url = "https://files.pythonhosted.org/packages/06/00/59500052cb1cf8cf5316be93598946bc451f14072c6ff256904428eaf03c/triton-3.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d9b215efc1c26fa7eefb9a157915c92d52e000d2bf83e5f69704047e63f125c", size = 253159365, upload-time = "2025-01-22T19:13:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/c7/30/37a3384d1e2e9320331baca41e835e90a3767303642c7a80d4510152cbcf/triton-3.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5dfa23ba84541d7c0a531dfce76d8bcd19159d50a4a8b14ad01e91734a5c1b0", size = 253154278, upload-time = "2025-01-22T19:13:54.221Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/f5/cd531b2d15a671a40c0f66cf06bc3570a12cd56eef98960068ebbad1bf5a/tzdata-2026.1.tar.gz", hash = "sha256:67658a1903c75917309e753fdc349ac0efd8c27db7a0cb406a25be4840f87f98", size = 197639, upload-time = "2026-04-03T11:25:22.002Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/70/d460bd685a170790ec89317e9bd33047988e4bce507b831f5db771e142de/tzdata-2026.1-py2.py3-none-any.whl", hash = "sha256:4b1d2be7ac37ceafd7327b961aa3a54e467efbdb563a23655fbfe0d39cfc42a9", size = 348952, upload-time = "2026-04-03T11:25:20.313Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "python-discovery" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/97/c5/aff062c66b42e2183201a7ace10c6b2e959a9a16525c8e8ca8e59410d27a/virtualenv-21.2.1.tar.gz", hash = "sha256:b66ffe81301766c0d5e2208fc3576652c59d44e7b731fc5f5ed701c9b537fa78", size = 5844770, upload-time = "2026-04-09T18:47:11.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/0e/f083a76cb590e60dff3868779558eefefb8dfb7c9ed020babc7aa014ccbf/virtualenv-21.2.1-py3-none-any.whl", hash = "sha256:bd16b49c53562b28cf1a3ad2f36edb805ad71301dee70ddc449e5c88a9f919a2", size = 5828326, upload-time = "2026-04-09T18:47:09.331Z" }, +]