diff --git a/.gitignore b/.gitignore index 00351e708..c9b8f51c1 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,265 @@ figures molecule applications experiments + +# Created by https://www.toptal.com/developers/gitignore/api/python,jupyternotebooks,macos,linux,windows +# Edit at https://www.toptal.com/developers/gitignore?templates=python,jupyternotebooks,macos,linux,windows + +### JupyterNotebooks ### +# gitignore template for Jupyter Notebooks +# website: http://jupyter.org/ + +.ipynb_checkpoints +*/.ipynb_checkpoints/* + +# IPython +profile_default/ +ipython_config.py + +# Remove previous ipynb_checkpoints +# git rm -r .ipynb_checkpoints/ + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + +### Python ### +# 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/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook + +# IPython + +# 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/#use-with-ide +.pdm.toml + +# 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 +.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/ + +### Python Patch ### +# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration +poetry.toml + +# ruff +.ruff_cache/ + +# LSP config files +pyrightconfig.json + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# End of https://www.toptal.com/developers/gitignore/api/python,jupyternotebooks,macos,linux,windows \ No newline at end of file diff --git a/.ipynb_checkpoints/LICENSE-checkpoint b/.ipynb_checkpoints/LICENSE-checkpoint deleted file mode 100644 index 2c83bbe21..000000000 --- a/.ipynb_checkpoints/LICENSE-checkpoint +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2024 Ziming Liu - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/.ipynb_checkpoints/README-checkpoint.md b/.ipynb_checkpoints/README-checkpoint.md deleted file mode 100644 index 8984965a4..000000000 --- a/.ipynb_checkpoints/README-checkpoint.md +++ /dev/null @@ -1,174 +0,0 @@ -kan_plot - -# !! Major Updates on July 14, 2024 - -* `model.train()` has been changed to `model.fit()` -* Some other small features are changed (e.g., create_dataset has been moved to kan.utils). I have updated and checked the notebooks in `./tutorials` are runnable on CPUs, so please refer to those tutorials for updated/new functionalities. Documentation hasn't been updated yet but will be updated soon. - -For pypi users, this is the most recent version 0.2.1. - -New functionalities include (documentation later): -* including multiplications in KANs. [Tutorial](https://github.com/KindXiaoming/pykan/blob/master/tutorials/Interp_1_Hello%2C%20MultKAN.ipynb) -* the speed mode. Speed up your KAN using `model = model.speed()` if you never use the symbolic functionalities. [Tutorial](https://github.com/KindXiaoming/pykan/blob/master/tutorials/Example_2_speed_up.ipynb) -* Compiling symbolic formulas into KANs. [Tutorial](https://github.com/KindXiaoming/pykan/blob/master/tutorials/Interp_3_KAN_Compiler.ipynb) -* Feature attribution and pruning inputs. [Tutorial](https://github.com/KindXiaoming/pykan/blob/master/tutorials/Interp_4_feature_attribution.ipynb) - -# Kolmogorov-Arnold Networks (KANs) - -This is the github repo for the paper ["KAN: Kolmogorov-Arnold Networks"](https://arxiv.org/abs/2404.19756). Find the documentation [here](https://kindxiaoming.github.io/pykan/). Here's [author's note](https://github.com/KindXiaoming/pykan?tab=readme-ov-file#authors-note) responding to current hype of KANs. - -Kolmogorov-Arnold Networks (KANs) are promising alternatives of Multi-Layer Perceptrons (MLPs). KANs have strong mathematical foundations just like MLPs: MLPs are based on the universal approximation theorem, while KANs are based on Kolmogorov-Arnold representation theorem. KANs and MLPs are dual: KANs have activation functions on edges, while MLPs have activation functions on nodes. This simple change makes KANs better (sometimes much better!) than MLPs in terms of both model **accuracy** and **interpretability**. A quick intro of KANs [here](https://kindxiaoming.github.io/pykan/intro.html). - -mlp_kan_compare - -## Accuracy -**KANs have faster scaling than MLPs. KANs have better accuracy than MLPs with fewer parameters.** - -Please set `torch.set_default_dtype(torch.float64)` if you want high precision. - -**Example 1: fitting symbolic formulas** -Screenshot 2024-04-30 at 10 55 30 - -**Example 2: fitting special functions** -Screenshot 2024-04-30 at 11 07 20 - -**Example 3: PDE solving** -Screenshot 2024-04-30 at 10 57 25 - -**Example 4: avoid catastrophic forgetting** -Screenshot 2024-04-30 at 11 04 36 - -## Interpretability -**KANs can be intuitively visualized. KANs offer interpretability and interactivity that MLPs cannot provide. We can use KANs to potentially discover new scientific laws.** - -**Example 1: Symbolic formulas** -Screenshot 2024-04-30 at 11 04 56 - -**Example 2: Discovering mathematical laws of knots** -Screenshot 2024-04-30 at 11 05 25 - -**Example 3: Discovering physical laws of Anderson localization** -Screenshot 2024-04-30 at 11 05 53 - -**Example 4: Training of a three-layer KAN** - -![kan_training_low_res](https://github.com/KindXiaoming/pykan/assets/23551623/e9f215c7-a393-46b9-8528-c906878f015e) - - - -## Installation -Pykan can be installed via PyPI or directly from GitHub. - -**Pre-requisites:** - -``` -Python 3.9.7 or higher -pip -``` - -**For developers** - -``` -git clone https://github.com/KindXiaoming/pykan.git -cd pykan -pip install -e . -``` - -**Installation via github** - -``` -pip install git+https://github.com/KindXiaoming/pykan.git -``` - -**Installation via PyPI:** -``` -pip install pykan -``` - -Requirements - -```python -# python==3.9.7 -matplotlib==3.6.2 -numpy==1.24.4 -scikit_learn==1.1.3 -setuptools==65.5.0 -sympy==1.11.1 -torch==2.2.2 -tqdm==4.66.2 -``` - -After activating the virtual environment, you can install specific package requirements as follows: -```python -pip install -r requirements.txt -``` - -**Optional: Conda Environment Setup** -For those who prefer using Conda: -``` -conda create --name pykan-env python=3.9.7 -conda activate pykan-env -pip install git+https://github.com/KindXiaoming/pykan.git # For GitHub installation -# or -pip install pykan # For PyPI installation -``` - -## Computation requirements - -Examples in [tutorials](tutorials) are runnable on a single CPU typically less than 10 minutes. All examples in the paper are runnable on a single CPU in less than one day. Training KANs for PDE is the most expensive and may take hours to days on a single CPU. We use CPUs to train our models because we carried out parameter sweeps (both for MLPs and KANs) to obtain Pareto Frontiers. There are thousands of small models which is why we use CPUs rather than GPUs. Admittedly, our problem scales are smaller than typical machine learning tasks, but are typical for science-related tasks. In case the scale of your task is large, it is advisable to use GPUs. - -## Documentation -The documentation can be found [here](https://kindxiaoming.github.io/pykan/). - -## Tutorials - -**Quickstart** - -Get started with [hellokan.ipynb](./hellokan.ipynb) notebook. - -**More demos** - -More Notebook tutorials can be found in [tutorials](tutorials). - -## Advice on hyperparameter tuning -Many intuition about MLPs and other networks may not directy transfer to KANs. So how can I tune the hyperparameters effectively? Here is my general advice based on my experience playing with the problems reported in the paper. Since these problems are relatively small-scale and science-oriented, it is likely that my advice is not suitable to your case. But I want to at least share my experience such that users can have better clues where to start and what to expect from tuning hyperparameters. - -* Start from a simple setup (small KAN shape, small grid size, small data, no reguralization `lamb=0`). This is very different from MLP literature, where people by default use widths of order `O(10^2)` or higher. For example, if you have a task with 5 inputs and 1 outputs, I would try something as simple as `KAN(width=[5,1,1], grid=3, k=3)`. If it doesn't work, I would gradually first increase width. If that still doesn't work, I would consider increasing depth. You don't need to be this extreme, if you have better understanding about the complexity of your task. - -* Once an acceptable performance is achieved, you could then try refining your KAN (more accurate or more interpretable). - -* If you care about accuracy, try grid extention technique. An example is [here](https://kindxiaoming.github.io/pykan/Examples/Example_1_function_fitting.html). But watch out for overfitting, see below. - -* If you care about interpretability, try sparsifying the network with, e.g., `model.train(lamb=0.01)`. It would also be advisable to try increasing lamb gradually. After training with sparsification, plot it, if you see some neurons that are obvious useless, you may call `pruned_model = model.prune()` to get the pruned model. You can then further train (either to encourage accuracy or encouarge sparsity), or do symbolic regression. - -* I also want to emphasize that accuracy and interpretability (and also parameter efficiency) are not necessarily contradictory, e.g., Figure 2.3 in [our paper](https://arxiv.org/pdf/2404.19756). They can be positively correlated in some cases but in other cases may dispaly some tradeoff. So it would be good not to be greedy and aim for one goal at a time. However, if you have a strong reason why you believe pruning (interpretability) can also help accuracy, you may want to plan ahead, such that even if your end goal is accuracy, you want to push interpretability first. - -* Once you get a quite good result, try increasing data size and have a final run, which should give you even better results! - -Disclaimer: Try the simplest thing first is the mindset of physicists, which could be personal/biased but I find this mindset quite effective and make things well-controlled for me. Also, The reason why I tend to choose a small dataset at first is to get faster feedback in the debugging stage (my initial implementation is slow, after all!). The hidden assumption is that a small dataset behaves qualitatively similar to a large dataset, which is not necessarily true in general, but usually true in small-scale problems that I have tried. To know if your data is sufficient, see the next paragraph. - -Another thing that would be good to keep in mind is that please constantly checking if your model is in underfitting or overfitting regime. If there is a large gap between train/test losses, you probably want to increase data or reduce model (`grid` is more important than `width`, so first try decreasing `grid`, then `width`). This is also the reason why I'd love to start from simple models to make sure that the model is first in underfitting regime and then gradually expands to the "Goldilocks zone". - -## Citation -```python -@article{liu2024kan, - title={KAN: Kolmogorov-Arnold Networks}, - author={Liu, Ziming and Wang, Yixuan and Vaidya, Sachin and Ruehle, Fabian and Halverson, James and Solja{\v{c}}i{\'c}, Marin and Hou, Thomas Y and Tegmark, Max}, - journal={arXiv preprint arXiv:2404.19756}, - year={2024} -} -``` - -## Contact -If you have any questions, please contact zmliu@mit.edu - -## Author's note -I would like to thank everyone who's interested in KANs. When I designed KANs and wrote codes, I have math & physics examples (which are quite small scale!) in mind, so did not consider much optimization in efficiency or reusability. It's so honored to receive this unwarranted attention, which is way beyond my expectation. So I accept any criticism from people complaning about the efficiency and resuability of the codes, my apology. My only hope is that you find `model.plot()` fun to play with :). - -For users who are interested in scientific discoveries and scientific computing (the orginal users intended for), I'm happy to hear your applications and collaborate. This repo will continue remaining mostly for this purpose, probably without signifiant updates for efficiency. In fact, there are already implmentations like [efficientkan](https://github.com/Blealtan/efficient-kan) or [fouierkan](https://github.com/GistNoesis/FourierKAN/) that look promising for improving efficiency. - -For users who are machine learning focus, I have to be honest that KANs are likely not a simple plug-in that can be used out-of-the box (yet). Hyperparameters need tuning, and more tricks special to your applications should be introduced. For example, [GraphKAN](https://github.com/WillHua127/GraphKAN-Graph-Kolmogorov-Arnold-Networks) suggests that KANs should better be used in latent space (need embedding and unembedding linear layers after inputs and before outputs). [KANRL](https://github.com/riiswa/kanrl) suggests that some trainable parameters should better be fixed in reinforcement learning to increase training stability. - -The most common question I've been asked lately is whether KANs will be next-gen LLMs. I don't have good intuition about this. KANs are designed for applications where one cares about high accuracy and/or interpretability. We do care about LLM interpretability for sure, but interpretability can mean wildly different things for LLM and for science. Do we care about high accuracy for LLMs? I don't know, scaling laws seem to imply so, but probably not too high precision. Also, accuracy can also mean different things for LLM and for science. This subtlety makes it hard to directly transfer conclusions in our paper to LLMs, or machine learning tasks in general. However, I would be very happy if you have enjoyed the high-level idea (learnable activation functions on edges, or interacting with AI for scientific discoveries), which is not necessariy *the future*, but can hopefully inspire and impact *many possible futures*. As a physicist, the message I want to convey is less of "KANs are great", but more of "try thinking of current architectures critically and seeking fundamentally different alternatives that can do fun and/or useful stuff". - -I would like to welcome people to be critical of KANs, but also to be critical of critiques as well. Practice is the only criterion for testing understanding (实践是检验真理的唯一标准). We don't know many things beforehand until they are really tried and shown to be succeeding or failing. As much as I'm willing to see success mode of KANs, I'm equally curious about failure modes of KANs, to better understand the boundaries. KANs and MLPs cannot replace each other (as far as I can tell); they each have advantages in some settings and limitations in others. I would be intrigued by a theoretical framework that encompasses both and could even suggest new alternatives (physicists love unified theories, sorry :). diff --git a/.ipynb_checkpoints/__init__-checkpoint.py b/.ipynb_checkpoints/__init__-checkpoint.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/.ipynb_checkpoints/hellokan-checkpoint.ipynb b/.ipynb_checkpoints/hellokan-checkpoint.ipynb deleted file mode 100644 index da1222058..000000000 --- a/.ipynb_checkpoints/hellokan-checkpoint.ipynb +++ /dev/null @@ -1,536 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Hello, KAN!" - ] - }, - { - "cell_type": "markdown", - "id": "59cf5cd0", - "metadata": {}, - "source": [ - "### Kolmogorov-Arnold representation theorem" - ] - }, - { - "cell_type": "markdown", - "id": "f88e5321", - "metadata": {}, - "source": [ - "Kolmogorov-Arnold representation theorem states that if $f$ is a multivariate continuous function\n", - "on a bounded domain, then it can be written as a finite composition of continuous functions of a\n", - "single variable and the binary operation of addition. More specifically, for a smooth $f : [0,1]^n \\to \\mathbb{R}$,\n", - "\n", - "\n", - "$$f(x) = f(x_1,...,x_n)=\\sum_{q=1}^{2n+1}\\Phi_q(\\sum_{p=1}^n \\phi_{q,p}(x_p))$$\n", - "\n", - "where $\\phi_{q,p}:[0,1]\\to\\mathbb{R}$ and $\\Phi_q:\\mathbb{R}\\to\\mathbb{R}$. In a sense, they showed that the only true multivariate function is addition, since every other function can be written using univariate functions and sum. However, this 2-Layer width-$(2n+1)$ Kolmogorov-Arnold representation may not be smooth due to its limited expressive power. We augment its expressive power by generalizing it to arbitrary depths and widths." - ] - }, - { - "cell_type": "markdown", - "id": "ebd8766a", - "metadata": {}, - "source": [ - "### Kolmogorov-Arnold Network (KAN)" - ] - }, - { - "cell_type": "markdown", - "id": "2cf3b1ee", - "metadata": {}, - "source": [ - "The Kolmogorov-Arnold representation can be written in matrix form\n", - "\n", - "$$f(x)={\\bf \\Phi}_{\\rm out}\\circ{\\bf \\Phi}_{\\rm in}\\circ {\\bf x}$$\n", - "\n", - "where \n", - "\n", - "$${\\bf \\Phi}_{\\rm in}= \\begin{pmatrix} \\phi_{1,1}(\\cdot) & \\cdots & \\phi_{1,n}(\\cdot) \\\\ \\vdots & & \\vdots \\\\ \\phi_{2n+1,1}(\\cdot) & \\cdots & \\phi_{2n+1,n}(\\cdot) \\end{pmatrix},\\quad {\\bf \\Phi}_{\\rm out}=\\begin{pmatrix} \\Phi_1(\\cdot) & \\cdots & \\Phi_{2n+1}(\\cdot)\\end{pmatrix}$$" - ] - }, - { - "cell_type": "markdown", - "id": "f6521452", - "metadata": {}, - "source": [ - "We notice that both ${\\bf \\Phi}_{\\rm in}$ and ${\\bf \\Phi}_{\\rm out}$ are special cases of the following function matrix ${\\bf \\Phi}$ (with $n_{\\rm in}$ inputs, and $n_{\\rm out}$ outputs), we call a Kolmogorov-Arnold layer:\n", - "\n", - "$${\\bf \\Phi}= \\begin{pmatrix} \\phi_{1,1}(\\cdot) & \\cdots & \\phi_{1,n_{\\rm in}}(\\cdot) \\\\ \\vdots & & \\vdots \\\\ \\phi_{n_{\\rm out},1}(\\cdot) & \\cdots & \\phi_{n_{\\rm out},n_{\\rm in}}(\\cdot) \\end{pmatrix}$$\n", - "\n", - "${\\bf \\Phi}_{\\rm in}$ corresponds to $n_{\\rm in}=n, n_{\\rm out}=2n+1$, and ${\\bf \\Phi}_{\\rm out}$ corresponds to $n_{\\rm in}=2n+1, n_{\\rm out}=1$." - ] - }, - { - "cell_type": "markdown", - "id": "1b410498", - "metadata": {}, - "source": [ - "After defining the layer, we can construct a Kolmogorov-Arnold network simply by stacking layers! Let's say we have $L$ layers, with the $l^{\\rm th}$ layer ${\\bf \\Phi}_l$ have shape $(n_{l+1}, n_{l})$. Then the whole network is\n", - "\n", - "$${\\rm KAN}({\\bf x})={\\bf \\Phi}_{L-1}\\circ\\cdots \\circ{\\bf \\Phi}_1\\circ{\\bf \\Phi}_0\\circ {\\bf x}$$" - ] - }, - { - "cell_type": "markdown", - "id": "54bbde9a", - "metadata": {}, - "source": [ - "In constrast, a Multi-Layer Perceptron is interleaved by linear layers ${\\bf W}_l$ and nonlinearities $\\sigma$:\n", - "\n", - "$${\\rm MLP}({\\bf x})={\\bf W}_{L-1}\\circ\\sigma\\circ\\cdots\\circ {\\bf W}_1\\circ\\sigma\\circ {\\bf W}_0\\circ {\\bf x}$$" - ] - }, - { - "cell_type": "markdown", - "id": "1c5f7795", - "metadata": {}, - "source": [ - "A KAN can be easily visualized. (1) A KAN is simply stack of KAN layers. (2) Each KAN layer can be visualized as a fully-connected layer, with a 1D function placed on each edge. Let's see an example below." - ] - }, - { - "cell_type": "markdown", - "id": "adcb5f75", - "metadata": {}, - "source": [ - "### Get started with KANs" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Initialize KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cpu\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import *\n", - "torch.set_default_dtype(torch.float64)\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device)" - ] - }, - { - "cell_type": "markdown", - "id": "3d72e076", - "metadata": {}, - "source": [ - "Create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "46717e8b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan.utils import create_dataset\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "8c6add1d", - "metadata": {}, - "source": [ - "Plot KAN at initialization" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ac76f858", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "ddf67e30", - "metadata": {}, - "source": [ - "Train KAN with sparsity regularization" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.85e-02 | test_loss: 1.77e-02 | reg: 6.93e+00 | : 100%|█| 50/50 [00:09<00:00, 5.13it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=50, lamb=0.001);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "Plot trained KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "92a4f67a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "576856cf", - "metadata": {}, - "source": [ - "Prune KAN and replot" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "7fe6fb12", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAuY0lEQVR4nO3deVRUV54H8O+tKrZikSW4oq2FuItRBFyjxoUoSTTi6U7bPYlZJo5Jq21yJuM45nR01HQnnWnN5kmbOROTaJsF0walJR0juAcE3FBxwQ0QEaEIUFBV1Lvzh1JHjFGUV7yq4vs5x398vFc/lMv33eW9K6SUEkRERCrSaV0AERF5H4YLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqM2hdAJEnkFLi2rVrqK2tRVBQECIiIiCE0LosIrfFngvRHZjNZqxZswYxMTGIjIxEr169EBkZiZiYGKxZswZms1nrEonckuBOlES3l5GRgZSUFFgsFgDXey9NmnotRqMRqampSEpK0qRGInfFcCG6jYyMDCQnJ0NKCUVRfvbrdDodhBDYtm0bA4boJgwXoluYzWZERUWhvr7+jsHSRKfTISAgAMXFxQgNDXV9gUQegHMuRLdYv349LBZLi4IFABRFgcViwSeffOLiyog8B3suRDeRUiImJgZFRUW4l6YhhIDJZMLp06e5iowIDBeiZioqKhAZGdmq8yMiIlSsiMgzcViM6Ca1tbWtOr+mpkalSog8G8OF6CZBQUGtOj84OFilSog8G8OF6CYRERGIjo6+53kTIQSio6MRHh7uosqIPAvDhegmQgjMnz//vs5dsGABJ/OJbuCEPtEt+JwLUeux50J0i9DQUKSmpkIIAZ3uzk2k6Qn9zZs3M1iIbsJwIbqNpKQkbNu2DQEBARBC/GS4q+nvAgICkJ6ejilTpmhUKZF7YrgQ/YykpCQUFxdj9erVMJlMzY6ZTCasXr0aJSUlDBai2+CcC1ELSCmxc+dOTJw4ETt27MCECRM4eU90B+y5ELWAEMI5pxIaGspgIboLhgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGC9Fd2O12lJSU4MSJEwCAs2fPorKyEoqiaFwZkfviNsdEP8NsNiM1NRUbNmxAQUEBampqYLPZ4O/vj8jISIwdOxbPPfccRo8eDYPBoHW5RG6F4UJ0G/v378eiRYtw5MgRxMfHIzk5GbGxsQgKCoLZbEZubi7S0tJw5swZ/OpXv8KKFSsQGRmpddlEboPhQnSLb7/9FnPmzEFQUBDeeOMNTJs2DTabDZs2bYLVakVISAiefPJJ2O12bNq0Ca+//joGDhyITz/9FJ06ddK6fCK3wHAhusmpU6fwyCOPIDAwEJs2bcKAAQMghEBRURGGDRuG6upq9OrVC7m5uQgLC4OUEnv27MHs2bMxfvx4fPTRR/Dz89P62yDSHCf0iW5wOBxYtWoVqqqq8N577zmD5U6EEBgzZgzefPNNbNmyBdu3b2+jaoncG8OF6IYzZ84gLS0NM2fOxJgxY+4aLE2EEJgxYwZGjBiBdevWobGx0cWVErk/LnEhumHfvn2ora1FSkoKzp8/j7q6Ouex4uJiOBwOAIDNZkNBQQFCQkKcx7t27YqZM2fi9ddfR1lZGaKiotq8fiJ3wnAhuuHkyZMwGo0wmUyYO3cu9u7d6zwmpYTVagUAlJaWYvLkyc5jQgi8/fbbGDx4MCwWC0pLSxku1O4xXIhuqK+vh8FggJ+fH6xWKxoaGm77dVLKnxxrbGxEQEBAsxAias8YLkQ3dOzYEfX19TCbzUhMTERgYKDzWH19Pfbt2+cMkVGjRjkfnBRCoEePHigvL4dOp0NYWJhW3wKR22C4EN0QFxcHu92O7Oxs/OlPf2p2rKioCPHx8aiurkanTp3w+eefIzQ01HlcCIElS5agc+fOHBIjAleLETklJCTAZDJh/fr1qKurg16vb/aniRACOp3O+fc6nQ6XL1/GV199heTkZHTo0EHD74LIPTBciG6IiIjA7373O+Tl5eGdd95p8ZJiq9WK//7v/0Z9fT3mzp3b4iXMRN6Mw2JEN5kzZw527dqFP/3pTzAajZg3bx78/f0BAAaDAQaDwdmLkVKipqYGK1euxKZNm/CXv/wFffv21bJ8IrfB178Q3eLq1at46aWXsHXrViQlJWHRokXo378/CgsLoSgKfH190bt3b2RnZ+PPf/4zDh06hOXLl2PevHnNhs+I2jOGC9Ft1NXVYd26dXjnnXdw5coVmEwmxMTEIDg4GFVVVSgsLERpaSni4uLwhz/8AePGjYNOx1FmoiYMF6I7KCsrw44dO5CVlYXDhw8jOzsbY8eOxejRozFlyhQkJibCaDRqXSaR22G4ELVQTk4OEhISkJOTg+HDh2tdDpFbYz+eqIX0er1zGTIR3RlbCRERqY7hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREquN+LkQtJKWEoijQ6XQQQmhdDpFbY8+F6B5wLxeiljFoXQCRGux2Oy5evAhFUbQupdWEEOjRowd8fX21LoXovjFcyCsUFxfjxRdfRFxcnDNgPLWXkZubiw8++ADR0dFal0J03xgu5BWklBg8eDASExOxceNGTJs2DU899ZTWZd2XxYsXg1Oh5OkYLuRVtmzZgq+++gpmsxm//vWvPW5oiaFC3sIzxw2IbkMIgccffxx6vR4HDx7EuXPntC6JqN1iuJBXGTVqFLp16waz2YyMjAz2BIg0wnAhr/LAAw9g4sSJAICvv/4aNptN44qI2ieGC3kVIQRSUlJgMBiQl5eHkydPal0SUbvEcCGvM2LECJhMJtTW1mLLli0cGiPSAMOFvE5oaCgee+wxANeHxmprazWuiKj9YbiQ1xFCYNasWTAajThx4gQOHDjA3gtRG2O4kFeKjY1FXFwc7HY7NmzY4BWvhSHyJAwX8kp+fn6YPXs2hBDIyMjApUuXtC6JqF1huJBXEkIgOTkZXbt2RXl5OTZv3syhMaI2xHAhr9WlSxdMnz4dAPDZZ5+hpqZG44qI2g+GC3ktIQSeeuopBAYGoqCgADt27GDvhaiNMFzIawkhMGTIEIwbNw6NjY1Yt24dn9gnaiMMF/JqPj4+eOGFF+Dj44Ndu3bhhx9+YO+FqA0wXMirCSHw8MMPIy4uDvX19fjggw/gcDi0LovI6zFcyOsZjUa8+OKL0Ov1+Mc//oHc3Fz2XohcjOFCXk8IgUcffRSxsbGora3FmjVr0NjYqHVZRF6N4ULtQkhICBYuXAi9Xo+tW7dy7oXIxRgu1C4IITBjxgwMHz4cdXV1ePPNN2G1WrUui8hrMVyo3QgKCsK///u/w9fXF//85z+Rnp7O3guRizBcqN0QQmDq1KmYPHkybDYbVq5cicrKSq3LIvJKDBdqV/z8/LB06VJ06NABhw8fxgcffMA3JhO5AMOF2hUhBOLi4vCv//qvkFLinXfeQV5eHofHiFTGcKF2R6/X4+WXX8agQYNQWVmJxYsX86WWRCpjuFC71LFjR6xatQpGoxFZWVlYvXo1n9wnUhHDhdolIQSSkpIwd+5cSCnxP//zP/jnP//J4TEilTBcqN0yGAxYsmQJRo0ahZqaGixYsACnT59mwBCpgOFC7VpYWBjeffdddOvWDWfPnsW8efNw7do1BgxRKzFcqF0TQiA2NharV69GUFAQMjMzsXDhQtTV1WldGpFHY7hQuyeEwPTp07Fs2TL4+vriiy++wH/8x3/AYrFoXRqRx2K4EOH68uQXX3wRixYtghAC69atw3/+53/CYrFwiIzoPjBciG7w9fXFa6+9hpdeegkAsHbtWrz88suoqalhwBDdI4YL0U0CAgKwcuVK/O53v4MQAv/7v/+L559/HuXl5QwYonvAcCG6hdFoxKpVq7B48WL4+PggNTUVM2fOxLFjxxgwRC3EcCG6DX9/fyxduhRvv/02OnTogAMHDuDRRx/Fl19+CbvdzpAhuguGC9HP8PHxwdy5c7Fx40ZER0ejuLgYzzzzDBYuXIjLly8zYIjugOFCdAc6nQ5JSUlIT0/Ho48+Crvdjg8//BCTJk3CF198gYaGBoYM0W0wXIjuQgiB6OhobNy4EW+99RY6duyIwsJCPP3000hJScHu3bs5VEZ0C4YLUQsIIRAYGIgFCxbgu+++Q0pKCnQ6HbZv345p06Zh9uzZyMrKYk+G6AaGC9E9EEJgwIAB+Oyzz/Dll19izJgxsNvt2Lx5M6ZNm4bk5GRs2LABV69ehZSSQUPtFsOF6B4JIeDr64tp06YhPT0dGzZswEMPPQQpJTIzM/HMM88gMTER8+fPR2ZmJqqrqxk01O4wXIjuU9NQWUpKCtLT07F161Y8+eSTCAsLw4ULF7B27VpMnToVI0eOxEsvvYRvvvkGxcXFnJ+hdsGgdQFEnk4IgYCAADz88MMYP348Lly4gLS0NKSmpuLQoUMoLCxEYWEh1q1bh/DwcAwYMACJiYlITEzEgAED0KVLFxiNRuj1eq2/FSLVMFyIVCKEgF6vh8lkwoIFC/Bv//ZvOHXqFL777jtkZGTg0KFDuHbtGnbt2oVdu3ZBCAGj0YhOnTrBZDIhJiYGEydOZK+GvALDhcgFhBDw8/PD4MGDMWjQIMyfPx9lZWU4dOgQ9u7di+zsbJw6dQrXrl1DUVERioqK8N1338Fut6NDhw5al0/UagwX8jrueOev1+vRrVs3dOvWDcnJyXA4HDCbzbhw4QIKCwtRUFCAwsJCPPTQQzhy5IjW5RK1GsOFvIIQAkePHsWyZcu0LuW++Pj4YODAgSgsLMThw4chhNC6JKJWEdIdb/OI7pHNZkNRUREcDofWpbSaTqdDdHQ0fH19tS6F6L4xXIiISHUcFiNqoZvvwzhsRXRnfIiSqIXy8/Oh1+uRn5+vdSlEbo/hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREqmO4EBGR6hguRESkOoYLUQtIKVFVVQUAqKqqAjdwJbozhgvRHZjNZqxZswYxMTGYNGkSpJSYNGkSYmJisGbNGpjNZq1LJHJLQvIWjOi2MjIykJKSAovFAuD22xwbjUakpqYiKSlJkxqJ3BXDheg2MjIykJycDCklFEX52a/T6XQQQmDbtm0MGKKbMFyIbmE2mxEVFYX6+vo7BksTnU6HgIAAFBcXIzQ01PUFEnkAzrkQ3WL9+vWwWCwtChYAUBQFFosFn3zyiYsrI/Ic7LkQ3URKiZiYGBQVFd3TijAhBEwmE06fPu2cjyFqzxguRDepqKhAZGRkq86PiIhQsSIiz8RhMaKb1NbWtur8mpoalSoh8mwMF6KbBAUFter84OBglSoh8mwMF6KbREREIDo6+p7nTYQQiI6ORnh4uIsqI/IsDBeimwghMH/+/Ps6d8GCBZzMJ7qBE/pEt+BzLkStx54L0S1CQ0ORmpoKIQR0ujs3kaYn9Ddv3sxgIboJw4XoNpKSkrBt2zYEBARACPGT4a6mvwsICEB6ejqmTJmiUaVE7onhQvQzkpKSUFxcjNWrV8NkMjU7ZjKZsHr1apSUlDBYiG6Dcy5ELSClxM6dOzFx4kTs2LEDEyZM4OQ90R2w50LUAkII55xKaGgog4XoLhguRESkOoYLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqY7gQEZHqGC5Ed2G321FSUoITJ04AAM6ePYvKykooiqJxZUTui9scE/0Ms9mM1NRUbNiwAQUFBaipqYHNZoO/vz8iIyMxduxYPPfccxg9ejQMBoPW5RK5FYYL0W3s378fixYtwpEjRxAfH4/k5GTExsYiKCgIZrMZubm5SEtLw5kzZ/CrX/0KK1asQGRkpNZlE7kNhgvRLb799lvMmTMHQUFBeOONNzBt2jTYbDZs2rQJVqsVISEhePLJJ2G327Fp0ya8/vrrGDhwID799FN06tRJ6/KJ3ALDhegmp06dwiOPPILAwEBs2rQJAwYMgBACRUVFGDZsGKqrq9GrVy/k5uYiLCwMUkrs2bMHs2fPxvjx4/HRRx/Bz89P62+DSHOc0Ce6weFwYNWqVaiqqsJ7773nDJY7EUJgzJgxePPNN7FlyxZs3769jaolcm8MF6Ibzpw5g7S0NMycORNjxoy5a7A0EUJgxowZGDFiBNatW4fGxkYXV0rk/rjEheiGffv2oba2FikpKTh//jzq6uqcx4qLi+FwOAAANpsNBQUFCAkJcR7v2rUrZs6ciddffx1lZWWIiopq8/qJ3AnDheiGkydPwmg0wmQyYe7cudi7d6/zmJQSVqsVAFBaWorJkyc7jwkh8Pbbb2Pw4MGwWCwoLS1luFC7x3AhuqG+vh4GgwF+fn6wWq1oaGi47ddJKX9yrLGxEQEBAc1CiKg9Y7hQu3fu3DlkZmZi9+7dsFgsMJvNSExMRGBgoPNr6uvrsW/fPmeIjBo1yvngpBACPXr0QHl5ORwOB0pKSmC1WrlqjNo1LkWmdufixYvIysrCzp07kZmZiQsXLkAIgV69euHcuXN4//338fzzzzc7p6ioCPHx8aiurkbPnj1x8OBBhIaGOo8LIbBkyRK88847MJlMCAgIQGxsLOLj4xEfH4/BgwfD19e3jb9TIu0wXMjrlZSUIDMz0/mnqKgIADBkyBCMGzcOEyZMwNixY6EoCsaMGYOwsDBs37692YT9zz3nAlwfJistLcW4cePw2GOPYe7cuTh48KDzT01NDfz8/PDggw9i+PDhSEhIwMCBA+Hj46PJvwdRW2C4kNcpKytrFianT58GAAwaNMgZJg899BAiIiJ+cu7777+PV155BUuXLsXixYudQ193CpeGhgb8/ve/R1paGr7//nv07dvXeT1FUVBYWIiDBw8iOzsbubm5qKurg7+/P4YOHers2QwYMIDvJyOvwnAhj1deXo6srCxnmJw8eRIA0L9//2Zh0rFjx7teq66uDs8++yzS09OxbNkyzJs3D/7+/jh37hwSEhKcw2LZ2dkIDQ1FTU0NVq5ciQ8//BB/+ctf8Mwzz9zx+g6HAydPnkR2djYOHjyIvLw8WCwWGI1GZ9gkJCSgX79+0Ov1qvz7EGmB4UIep6KiArt27XKGSUFBAQCgT58+zjAZN24cOnfufF/Xv3r1Kl566SVs3boVSUlJWLRoEfr374/CwkIoigJfX1/07t0b2dnZ+POf/4xDhw5h+fLlmDdv3j0HQmNjI44fP46cnBzk5OQgPz8fDQ0NCAwMxLBhw5CQkID4+Hj07dsXOh2feSbPwXAht1dVVYVdu3Zh586dyMrKwpEjRwAA0dHRzcKkW7duqn1mXV0d1q1bh3feeQdXrlyByWRCTEwMgoODUVVVhcLCQpSWliIuLg5/+MMfMG7cOFV++dvtdhQUFDjD5tChQ7BarQgODkZcXJxzGC0mJoZhQ26N4UJup7q6Grt373aGyaFDhyClRM+ePTF+/Hjnn+7du7u8lrKyMuzYsQNZWVkoKipCQ0MDwsLCMGjQIEyZMgWJiYkwGo0u+3ybzYajR48652yOHDkCm82GDh06IC4uztmziY6ObvHraojaAsOFNFdTU4M9e/Y4h7ny8vKgKAqioqIwfvx4TJgwAePHj0fPnj01rdPhcEBKCZ1Op1mvwWq14siRI86ezZEjR9DY2IiwsDAMHz7c2bPp1asXw4Y0xXChNldbW4t9+/Y5eyYHDx6Ew+FA165dm/VMTCYTf0HeRUNDAw4dOoSDBw8iJycHR48ehcPhQEREhHPZc3x8PHr06MF/S2pTDBdyOYvFgv379zvDJDs7G42NjejUqVOzMImJieEvwFayWCw4fPgwsrOzkZOTg4KCAiiKgsjISGevJj4+HlFRUfy3JpdiuJDqGhoacODAAWeYHDhwAHa7HZGRkRg3bpwzTPr168dfcC5WV1eH/Px85zDaiRMnoCgKOnfu7BxGS0hIQNeuXbUulbwMw4VazWq14ocffnDOmRw4cABWqxXh4eHNwmTgwIEME43V1NQgLy/PGTaFhYWQUqJr167Nejb3u4ybqAnDhe6ZzWZDTk4OMjMzsXPnTuzfvx8NDQ0IDQ3FQw895AyTwYMHc7msm6uurm4WNqdOnQIAREVFOYMmISEBkZGRGldKnobhQndlt9uRm5vrDJN9+/bBYrEgJCQEY8eOdT5nMmTIED5V7uHMZjNyc3ORk5OD7OxsnD17FgDQo0cP5+KA4cOH44EHHtC4UnJ3DBf6icbGRuTn5zvDZO/evaitrUVQUBDGjBnj7JkMHTqU78PycpWVlc6VaDk5OTh37hwAoFevXs2G0Zres0bUhOFCcDgcOHz4sDNM9uzZgx9//BFGoxGjR4929kzi4uL4Jt92rqKiwhk22dnZuHjxIoDrb0to6tnExcU1246A2ieGSzukKAqOHj3qDJPdu3fDbDbD398fo0aNcoZJfHw89yChOyovL3f2anJyclBcXAzg+nvemno1cXFxzbYvoPaB4dIOSClRUFDgDJNdu3ahsrISfn5+GDFihDNMEhMTuXsitcrly5eb9WwuX74MIQT69u3rXBwwbNgwBAUFaV0quRjDxQtJKXHy5MlmYXL16lX4+PhgxIgRzjmTESNGwN/fX+tyyYuVlJQ069lcuXIFOp0O/fv3d/Zshg4d2mxLafIODBcvIKXE6dOnnWGSlZWFK1euwGAwICEhwRkmI0eOdOlLFonuREqJ4uJiZ9BkZ2ejoqICOp0OAwcOdPZsHnzwQQQEBGhdLrUSw8UDSSlRVFTULExKS0uh1+sxfPhw58seR44cyeEHcltSSly8eNEZNAcPHsS1a9eg1+sxePBgZ89myJAh7GF7IIaLhzh//nyzMLl06RJ0Oh2GDRvmDJNRo0Zx4pQ8lpQS586dazaMZjab4ePj0yxsYmNjOTfoARguHmLAgAE4deoUHnzwQWeYjB49mks+yWspioKioiJnzyY3NxfV1dV48803kZSUpHV5dBcMFw/R9N/Ed3NReyWlhNVqhY+PD98E4QEYLkREpDq+u0MFdrsdFy9ehKIoWpfSakII9OjRgw9P0j2x2+0oKyvzmjbQpUsXvo2ilRguKiguLsaLL76IuLg4rUtptdzcXHzwwQeIjo7WuhTyIOXl5VixYgUGDBigdSmtdvz4cSxduhTdu3fXuhSPxnBRgZQSsbGxWLlyZYu+3uFwICcnB2lpabh69SqGDh2KmTNnolOnTi6u9O4WL14MjpTSvZJSok+fPliwYIHq1256eeaxY8dQXV2NkJAQDBo0CPHx8QgPD1f981avXs02oAKGi8ruNuFeV1eH5cuXY+3atairq3Oe88EHH2Dt2rUYM2aMZpP2bFCkBjV+fqWUsFgsSE1Nxd/+9refDLkJIdC5c2c8+eSTmDVrFgIDA1X7XFIHw6UNNTQ04NVXX8Vf//pXAEBcXBxMJhMyMzNx4sQJ/Pa3v8XXX3+NoUOHclUYtVtSSpSWlmLFihU4cOAAFEVBWFgY+vfvj8jISFRUVOD48eO4fPky1qxZg/3792Pp0qWIiopiu3EjDJc2oigKPvroI3z00UcQQmDhwoV47bXXEBQUhNzcXPzmN7/B2bNnsXDhQqSlpfH5FWqXpJS4cOECXn31VRQWFsLf3x8zZ87Eb37zG3Tp0gU6nQ6KoqCsrAwbN27EV199hQMHDmDRokX44x//iOjoaAaMm+AetG1ASoljx45hxYoVaGxsxOzZs7F8+XKEhIRAp9Nh+PDheP/99xEcHIz9+/dj3bp17J5TuyOlRHl5OZYsWYLCwkKEhYVh2bJleOWVVxAVFQW9Xg8hBPR6Pbp164aXX34ZK1asQFhYGE6fPo0lS5agtLSUbcdNMFzagN1ux4oVK3D16lX069cPq1atavauJCEEHn74YcyZMwdSSrz//vu4dOmShhUTtb36+nq88cYbKCgoQEhICJYtW4akpKSf3e1Ur9dj0qRJWLlyJUJDQ1FYWIiVK1c65zJJWwwXF5NSIjMzE9u2bYPBYMDSpUvRpUuXn3Td9Xo9Fi5ciK5du+LSpUv4+OOPeQdG7YaiKNiwYQOysrLg6+uLV155BWPHjr3rEJcQAqNGjcKrr74Kf39/7N+/Hx9//DEcDkcbVU4/h+HiYjabDWvWrEFDQwPGjBmD6dOn/2yD6dmzJ/7lX/4FAPDJJ5+gvLy8LUsl0oSUEkeOHMH69eshpcSsWbOQnJwMna5lv56EEEhKSsKvf/1rSCmxYcMG5Obm8uZMYwwXF5JS4ocffkBmZiZ8fHywcOHCO+5TIYTAnDlzEBERgfPnz2Pr1q1sIOT1LBYL3n33XdTU1KBfv3544YUX7vnpeIPBgGeffRZDhgyBxWLBmjVrUFNT46KKqSUYLi6kKArWrVuHhoYGxMXFYeLEiXft5kdHR+ORRx6BlBKffPIJrFZrG1VL1PaklEhPT0d+fj78/f2xYMGC+14pGRwcjIULFyIwMBDHjx/H5s2beXOmIYaLCxUVFSEjIwM6nQ7PPfdci3aB1Ol0ePrpp+Hr64vc3Fzk5+ezgZDXunr1KtavXw+Hw4GkpCQkJCTc91JiIQSGDBmCxx9/3DmHU1paqnLF1FIMFxeRUmLz5s24du0aunfvjuTk5BY1GiEEEhMTMXDgQNTX1+OLL75og2qJ2l5TG7l06RLCw8Px7LPPtvpV+nq9Hk899RQ6d+6M8vJybNy40StepumJGC4uUldXhy+//BIAMH36dHTs2LHF5wYGBiIlJQUAsG3bNlRWVrqkRiItXb58GampqQCAJ554Aj169FDlAcguXbrgl7/8JYQQ2LZtGy5cuMDevwYYLi4gpURubi4KCgrg7++PX/7yl/d0vhACjz/+OEJCQnD+/Hns3buXjYO8ipQSf//731FeXo6OHTti1qxZLV4ddjdCCMyYMQNRUVGoqqrCl19+yfajAYaLi6SmpsJmsyE2NhZDhgy55zuymJgYxMfHw+FwcGKSvM7Vq1fxzTffAAAee+wxdOnSRdXrh4eHIyUlBUIIbN++nXMvGmC4uEBVVRUyMjIAADNmzLjj8uOf4+PjgyeeeAIAsHPnTly9elXVGom0IqXEt99+i7KyMoSFheGJJ55Q/X1gQggkJyejc+fOuHbtGtLS0niD1sYYLiqTUiI7Oxvnz59HUFAQpk2bdl8NRwiByZMnIywsDKWlpdizZw8bB3mF2tpabNmyBVJKTJo0Cd26dXPJ50RGRmLatGkArs9dVlVVueRz6PYYLi6QlpaGxsZGPPjgg+jTp899X+cXv/gF4uPjoSiKszESebKmm6+zZ88iICDAJb2WJkIIPPbYYwgJCUFJSQl27drFNtSGGC4qq66uxvfffw8AmDZtWqv2ojcYDJg+fToAYNeuXaioqFClRiKtNDY24u9//zscDgeGDx+OPn36uPQV+T169MDo0aOhKAq++eYb2Gw2l30WNcdwUdmRI0dw/vx5GI1GTJkypVUNp+ltyaGhoSgtLcX+/ft550Ue7fz588jNzYVer8f06dN/9o3HatHpdJg+fTp8fHxw7NgxnDhxgm2ojTBcVJaRkQGbzYa+ffuib9++rb5ez549ERcXB4fDwUlJ8mhSSmRkZKCurg7du3dHYmKiyzf2anpqPyYmBlarFf/4xz/YhtoIw0VFDQ0NziGxiRMn3tcqsVv5+PggOTkZAJCVlQWz2dzqa95KSskGRy5XU1OD7777DgAwadIkBAcHt8nnBgQE4JFHHgFwvQ1xYr9tMFxUdO7cOZw4cQIGgwGTJ09W5a5MCIFJkyYhKCgIFy9eVP1V4lJKfP755/j973+P7777jq/KIJeQUuLQoUO4ePEijEajau2jJYQQmDBhAjp06IArV67gwIEDvJlqAwwXFe3Zswc1NTXo1q0bHnzwQdWuGx0djdjYWDQ2NmLr1q2qXRe4/ubmL774Au+99x4+++wzVa9N1KRpSMzhcGDQoEEwmUxt+vldu3ZFXFwcFEXB9u3buZlYG2C4qKRpx0kASExMRHh4uGrX9vPzc3brd+zYoeo+FZWVlcjLy3Pe3an1Cg6im1VUVOCHH36AEAJTpky55/1aWkuv1yMpKQk6nQ6HDh1CSUlJm35+e8TfJCoRQuC1117Du+++i+eee07VLn/TTnsBAQE4e/Ysjhw5otq1jx49isuXLyMoKAgjRoxQ7bpETZqebamoqEBoaChGjRrVZkNiTYQQiI+PR8eOHfHjjz/yfX1tgOGion79+mHevHkt2hTsXvXv3x/9+vWDzWZDenq6Kg1DSomdO3eisbERffr0wS9+8QsVKiVqzuFwYMeOHZBSYujQoejUqZMmdYSFhSExMREA8P3336OxsVGTOtoLhovKhBAuuSszGo1ISkoCcH25s8ViafU1rVYrdu7cCQAYN24c/P39W31NoluVl5cjPz/fuTiltXu23C8hBCZOnAi9Xo8TJ07g0qVLmtTRXjBcPIQQAtOmTYOfnx8KCwtx/PjxVl/zwoULKCgogMFgwKRJk1Sokqg5KSVycnJgNpsRHh6O4cOHt/mQWBMhBGJjY9G5c2fU1tZi3759HBpzIYaLB4mNjUXv3r1RX1/f6ofBpJTYtWsXfvzxR3Tp0gXDhg1TsVKi6xRFQWZmpnNI7IEHHtC0ng4dOiAhIQHA9WdeODTmOgwXDxIUFIQpU6YAANLT01FfX3/f13I4HEhPTwcAjBw5EhEREarUSHSziooKHD582G1WIwohMH78eOfQGPd5cR2Gi4d57LHH4Ovr63xP0v0qKyvDgQMHIITAo48+qtlQBXkvKSXy8/NRVVWF0NBQxMXFaf5zJoTA4MGD8cADD6C2thY5OTkcGnMRhosHEUJg6NChzqGxrVu33lfDaBoSu3r1Kh544AGMHTtW80ZP3qfp50xRFAwaNAiRkZFalwTg+qqxoUOHQkqJ3bt384FKF2G4eJjg4GBMnToVwPV9Y+5n1ZiiKPj6668hpcSoUaPQtWtXtcskQnV1NfLy8gAAY8eO1WyV2K2EEM4bqmPHjuHatWtal+SVGC4eRgiBGTNmwN/fH8ePH0d+fv49X6O4uBi7d++GEAJPPPGE2zR68h5SSpw4cQLl5eUIDAxEfHy82/SOm0YAOnTogMrKShw7doxDYy7AcPFAQ4YMwcCBA2G1WvHVV1/dU8OQUmL79u2oqKhA586d8fDDD7tNoyfvsm/fPjgcDkRHR7tsK+P71bFjR/Tt2xeKomDv3r1al+OVGC4eyGg0IiUlBQCwdevWe9qh0mq14m9/+xuklJg8eTK6dOniqjKpHWtoaEB2djYAYMSIEa3akdUVDAYDRo4cCQDIy8tDXV2dxhV5H4aLBxJCYPr06QgNDcWFCxecr9a4Gykl8vLycPDgQfj4+GD27NnstZBLXLx4ERcvXoSPjw9Gjhzpdj9nQggkJCTAz88PJSUlOHfunNYleR2Gi4fq3bs3JkyYAEVRsH79+hbtDa4oCj7++GPU19cjNjbWLRs9eT4pJXJzc1FfX49OnTqhd+/eWpd0Wz179kS3bt1gs9m4JNkFGC4eSq/X4+mnn4bBYMCePXuQl5d318Zx5swZbNmyBUIIzJkzB4GBgW1ULbUniqJg//79AK7PDwYFBWlc0e0ZjUbnmymys7P5tL7KGC4equlJ4yFDhsBiseDDDz+843p9RVHw17/+FRUVFejVqxdSUlLYayGXqKqqwokTJyCEcPvecWJiInQ6HQoLC1FZWal1OV6F4eLBgoKC8MILL0Cn02HLli04fPjwbXsvUkocP34cn376KYQQeP7559GxY0cNKqb2oOkXdWBgIGJjY902XIQQGDhwIIKDg2E2m1v1xgv6KYaLBxNCICUlBYMGDcKPP/6IP/7xj7ede7FarVi+fDmuXbuGPn36YM6cOW7b4Mnz5eTkwOFwoFevXujcubPW5dxRx44d0bt3byiK4lzdRupguHi40NBQvPrqq/Dx8UFaWho2btzYrPeiKAr+7//+D9988w18fHywZMkS9lrIZWw2G3JzcwEAw4cPd7slyLcyGAzOeZf8/HxYrVaNK/IeDBcP1/SU/fTp02G327F48WJs27YNDocDdrsdn3/+Of7rv/4Ldrsds2bNwqxZs9hrIZe5cuUKzp07B71ej/j4eK3Luaum7Y/1ej0uXryIsrIyrUvyGgatC6DW8/Pzw1tvvYXTp0/j8OHD+O1vf4spU6bAarVix44dqK+vx8iRI/HWW2/Bz89P63LJix0/fhy1tbWIiIhAnz59POJGpnfv3ggPD0dFRQWOHTumdTlegz0XLyCEQPfu3bFx40aMGTMGdXV1SE1NxdatW2Gz2TB16lRs2LABnTt39ojGTp6r6XmRmJgYhIWFaV1Oi3To0AF9+/aFlBIHDx7k8y4qYc9FZVr+YPbt2xdbtmzBN998g6ysLBgMBkyePBlTp06F0WjUvD7yblJKxMXFobKyEiNHjoRer/eInze9Xo8JEyYgICAAiYmJqmwhTgwXVQghcPToUSxbtkzrUpy6d+8OADh27Ng9dfWbdg0kuhdCCJw5cwZGoxHR0dEoLy/H2rVrtS6rxRRFQc+ePXHu3DmcPn2abUAFQnrCrYWbs9lsKCoq8opNh3Q6HaKjo91+lQ+5F7vdjuLiYq9pA927d4ePj4/WpXg0hgsREamOE/oeQkrp/EPUXimKgoaGBiiKonUpdBcMFw+Rn58Pg8FwXztPEnmLwsJCJCYmorCwUOtS6C4YLkREpDqGCxERqY7hQkREqmO4EBGR6hguRESkOoYLERGpjuFCRESqY7gQEZHqGC5ERKQ6hgsREamO4UJERKpjuBARkeoYLkREpDqGCxERqY7hQkREqmO4eAApJaqqqgAAVVVV3DCM2qWmdmCz2dgOPADDxY2ZzWasWbMGMTExmDRpEhRFwaRJkxATE4M1a9bAbDZrXSKRy93cDkaPHo2TJ09i9OjRbAduTkjGv1vKyMhASkoKLBYLADS7SxNCAACMRiNSU1ORlJSkSY1ErsZ24LkYLm4oIyMDycnJkFLeca9wnU4HIQS2bdvGhkVeh+3AszFc3IzZbEZUVBTq6+vv2KCa6HQ6BAQEoLi4GKGhoa4vkKgNsB14Ps65uJn169fDYrG0qEEBgKIosFgs+OSTT1xcGVHbYTvwfOy5uBEpJWJiYlBUVHRPK2GEEDCZTDh9+rRzHJrIU7EdeAeGixupqKhAZGRkq86PiIhQsSKitsd24B04LOZGamtrW3V+TU2NSpUQaYftwDswXNxIUFBQq84PDg5WqRIi7bAdeAeGixuJiIhAdHT0PY8XCyEQHR2N8PBwF1VG1HbYDrwDw8WNCCEwf/78+zp3wYIFnMQkr8B24B04oe9muL6fiO3AG7Dn4mZCQ0ORmpoKIQR0ujv/9zQ9mbx582Y2KPIqbAeej+HihpKSkrBt2zYEBARACPGTbn7T3wUEBCA9PR1TpkzRqFIi12E78GwMFzeVlJSE4uJirF69GiaTqdkxk8mE1atXo6SkhA2KvBrbgefinIsHkFKisrISNTU1CA4ORnh4OCctqd1hO/AsDBciIlIdh8WIiEh1DBciIlIdw4WIiFTHcCEiItUxXIiISHUMFyIiUh3DhYiIVMdwISIi1TFciIhIdQwXIiJSHcOFiIhUx3AhIiLVMVyIiEh1DBciIlLd/wO28WdCwCiQTwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "bd08ad99", - "metadata": {}, - "source": [ - "Continue training and replot" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "18a2db11", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.79e-02 | test_loss: 1.72e-02 | reg: 7.66e+00 | : 100%|█| 50/50 [00:06<00:00, 7.21it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8768d56c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.4\n" - ] - } - ], - "source": [ - "model = model.refine(10)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "46f73098", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.67e-04 | test_loss: 4.73e-04 | reg: 7.66e+00 | : 100%|█| 50/50 [00:06<00:00, 7.37it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "markdown", - "id": "cf35d505", - "metadata": {}, - "source": [ - "Automatically or manually set activation functions to be symbolic" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b3c0642b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.9999999188529035, c=2\n", - "fixing (0,1,0) with x^2, r2=0.9999999809840728, c=2\n", - "fixing (1,0,0) with exp, r2=0.9999999904907739, c=2\n", - "saving model version 0.6\n" - ] - } - ], - "source": [ - "mode = \"auto\" # \"manual\"\n", - "\n", - "if mode == \"manual\":\n", - " # manual mode\n", - " model.fix_symbolic(0,0,0,'sin');\n", - " model.fix_symbolic(0,1,0,'x^2');\n", - " model.fix_symbolic(1,0,0,'exp');\n", - "elif mode == \"auto\":\n", - " # automatic mode\n", - " lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", - " model.auto_symbolic(lib=lib)" - ] - }, - { - "cell_type": "markdown", - "id": "821ba616", - "metadata": {}, - "source": [ - "Continue training till machine precision" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c0800415", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.33e-10 | test_loss: 7.20e-11 | reg: 0.00e+00 | : 100%|█| 50/50 [00:02<00:00, 24.56it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.7\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "markdown", - "id": "e39da499", - "metadata": {}, - "source": [ - "Obtain the symbolic formula" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "bf44f7e0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 e^{1.0 x_{2}^{2} + 1.0 \\sin{\\left(3.1416 x_{1} \\right)}}$" - ], - "text/plain": [ - "1.0*exp(1.0*x_2**2 + 1.0*sin(3.1416*x_1))" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan.utils import ex_round\n", - "\n", - "ex_round(model.symbolic_formula()[0][0],4)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "16e635f0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/setup-checkpoint.py b/.ipynb_checkpoints/setup-checkpoint.py deleted file mode 100644 index bc175730c..000000000 --- a/.ipynb_checkpoints/setup-checkpoint.py +++ /dev/null @@ -1,31 +0,0 @@ -import setuptools - -# Load the long_description from README.md -with open("README.md", "r", encoding="utf8") as fh: - long_description = fh.read() - -setuptools.setup( - name="pykan", - version="0.2.7", - author="Ziming Liu", - author_email="zmliu@mit.edu", - description="Kolmogorov Arnold Networks", - long_description=long_description, - long_description_content_type="text/markdown", - # url="https://github.com/kindxiaoming/", - packages=setuptools.find_packages(), - include_package_data=True, - package_data={ - 'pykan': [ - 'figures/lock.png', - 'assets/img/sum_symbol.png', - 'assets/img/mult_symbol.png', - ], - }, - classifiers=[ - "Programming Language :: Python :: 3", - "License :: OSI Approved :: MIT License", - "Operating System :: OS Independent", - ], - python_requires='>=3.6', -) diff --git a/.python-version b/.python-version new file mode 100644 index 000000000..2c0733315 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.11 diff --git a/docs/.ipynb_checkpoints/API_1_indexing_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_1_indexing_-checkpoint.ipynb deleted file mode 100644 index e249a0fee..000000000 --- a/docs/.ipynb_checkpoints/API_1_indexing_-checkpoint.ipynb +++ /dev/null @@ -1,417 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 1: Indexing" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN\n", - "import torch\n", - "model = KAN(width=[2,3,2,1])\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x);\n", - "beta = 100\n", - "model.plot(beta=beta)\n", - "# [2,3,2,1] means 2 input nodes\n", - "# 3 neurons in the first hidden layer,\n", - "# 2 neurons in the second hidden layer,\n", - "# 1 output node" - ] - }, - { - "cell_type": "markdown", - "id": "c47ccd2b", - "metadata": {}, - "source": [ - "## Indexing of edges (activation functions)" - ] - }, - { - "cell_type": "markdown", - "id": "8c30add2", - "metadata": {}, - "source": [ - "### Each activation function is indexed by $(l,i,j)$ where $l$ is the layer index, $i$ is the input neuron index, $j$ is the output neuron index. All of them starts from 0. For example, the one in the bottom left corner is (0, 0, 0). Let's try to make it symbolic and see it turns red." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c95dbc78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9995602360489043\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "bf721202", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9992399109543574\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAHiCAYAAAAkiYF/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbGUlEQVR4nOzddVgc1/4G8Hdxt0CSphEixNO4CyHuTeNK3BPi7u5ClBB3d3d39xAB4kAIENx23t8f/OCmbdpGdpndnfN5nj733l7Y/c7hzLxzzsycUZEkBEEQBEGDjOQuQBAEQTA8IlwEQRAEjRPhIgiCIGicCBdBEARB40S4CIIgCBonwkUQBEHQOBEugiAIgsaJcBEEQRA0ToSLIAiCoHEiXARBEASNE+EiCIIgaJwIF0EQBEHjRLgIgiAIGifCRRAEQdA4ES6CIAiCxpnIXYAg6AOS+PTpE6Kjo2FjY4MMGTJApVLJXZYg6CwxchGEfxEREQFvb2+4ubnBxcUFOXPmhIuLC9zc3ODt7Y2IiAi5SxQEnaQSb6IUhK87duwYmjZtitjYWAApo5dUqaMWKysr7Nq1C7Vr15alRkHQVSJcBOErjh07hvr164MkJEn6x58zMjKCSqXCoUOHRMAIwhdEuAjCX0RERCBr1qyIi4v712BJZWRkBEtLS7x9+xYODg7aL1AQ9IC45iIIf7Fu3TrExsZ+U7AAgCRJiI2Nxfr167VcmSDoDzFyEYQvkISbmxv8/f3xPbuGSqVCrly58Pz5c3EXmSBAhIsg/EloaChcXFx+6vczZMigwYoEQT+JaTFB+EJ0dPRP/X5UVJSGKhEE/SbCRRC+YGNj81O/b2trq6FKBEG/iXARhC9kyJABWbJk+aHfzZ07N5ycnDRckSDoJxEugvD/zp8/jxo1auD9+/c/9Pv58uVDZGSkhqsSBP0kwkVQvLNnz8LDwwPu7u4ICwvDhg0bYGVlBSOjb9s9VCoVTExMcPr0abi6umLixIliWRhB8US4CIpEEmfOnIG7uzs8PDzw+fNn7N27F7dv30a7du2we/duqFSq/wwYIyMjGBkZ4dChQ/D390fHjh0xY8YMuLq6Yvz48QgPD0+nLRIEHUNBUBBJknjy5ElWrlyZAFiiRAnu37+fkiT97WePHj1Ka2trqlQqqlQqAkj7J/XfWVtb89ixY3/6vQ8fPnDgwIG0tLSknZ0dx44dy0+fPqXXJgqCThDhIiiCJEk8fvw4K1asSAAsVaoUDxw48NVQ+VJ4eDi9vb2ZO3fuP4VL7ty56e3tzYiIiH/83aCgIA4ePJiWlpa0tbXl6NGjGRoaqulNEwSdJB6iFAwaSZw4cQITJkzAlStXUKZMGYwfPx5169b9rifpSSIsLAxRUVGwtbWFk5PTN/9+SEgI5syZgyVLlsDIyAj9+vXDoEGD4Ozs/KObJQg6T4SLYJBI4tixY5g4cSKuXr2KsmXLYsKECahdu7Zsy7N8/PgxLWRUKhX69u2LwYMHi5ARDJK4oC8YFJI4fPgwypcvnzY6OXr0KK5cuYI6derIuu6Xi4sLZs6cicDAQPTt2xeLFy+Gq6srhg8fjo8fP8pWlyBogwgXwSCQxKFDh1C2bFnUr18fJiYmOH78OC5duiTraOVrnJ2dMX36dAQGBqJ///5YunQpXF1dMXToUISEhMhdniBohAgXQa+RxIEDB1CmTBk0aNAA5ubmOHnyJC5cuICaNWvqVKj8VYYMGTB16lQEBgZi4MCBWL58OXLmzIkhQ4YgODhY7vIE4aeIcBH0Ekns27cPpUqVQqNGjWBlZYVTp07h/PnzqF69uk6Hyl9lyJABU6ZMQWBgIAYPHowVK1YgZ86cGDRoEIKCguQuTxB+iAgXQa+QxN69e1GiRAk0btwYdnZ2OHPmDM6dO4dq1arpVaj8lZOTEyZNmoTAwEAMGzYMq1evRs6cOTFgwAB8+PBB7vIE4buIcBH0giRJ2L17N4oXL44//vgDjo6OOHv2LM6cOYOqVavKXZ5GOTo6YsKECQgMDMSIESOwbt065MqVC/379//hdc8EIb2JcBF0miRJ2LlzJ4oXL46mTZvC2dkZ58+fx+nTp+Hu7i53eVrl4OCA8ePHIzAwEKNGjcKGDRuQK1cu9OvXD+/evZO7PEH4VyJcBJ0kSRJ27NiBokWLonnz5siUKRMuXryIkydPonLlynKXl67s7e0xduxYBAYGYuzYsdi8eTNy5cqFPn364M2bN3KXJwhfJcJF0ClqtRrbtm3Db7/9hhYtWiBLliy4dOkSjh8/jooVK8pdnqzs7OwwevRoBAQEYPz48di6dSvy5MmD3r17i5ARdI4IF0EnqNVqbNmyBUWKFEGrVq2QLVs2XL58GceOHUOFChXkLk+n2NnZYdSoUQgMDMTEiROxfft25M6dGz179sSrV6/kLk8QAIhwEWSmVquxefNmFC5cGG3atIGrqyuuXr2KI0eOoHz58nKXp9NsbW0xYsQIBAYGYvLkydi1axfc3NzQo0cPBAYGyl2eoHAiXARZJCcnY+PGjShUqBDatm2L3Llz49q1azh8+DDKli0rd3l6xcbGBsOHD0dAQACmTp2KPXv2wM3NDd26dUNAQIDc5QkKJcJFSFfJyclYv349ChYsiPbt2yNv3ry4ceMGDh48iDJlyshdnl6zsbHB0KFDERAQgBkzZmD//v3ImzcvunTpAn9/f7nLExRGhIuQLpKTk7Fu3ToUKFAAHTp0QIECBXDz5k3s378fpUqVkrs8g2JtbY3BgwcjICAAM2fOxKFDh5A3b1507twZL1++lLs8QSFEuAhalZSUhDVr1iB//vzo2LEjChcujNu3b2Pfvn0oWbKk3OUZNCsrKwwaNAj+/v6YM2cOjhw5gnz58qFjx4548eKF3OUJBk6Ei6AVSUlJWLVqFfLnz4/OnTujaNGiuHPnDvbs2YPixYvLXZ6iWFlZYcCAAfD398e8efNw/Phx5MuXD56ennj27Jnc5QkGSoSLoFGJiYlYuXIl8ubNi65du6J48eK4d+8edu3ahWLFisldnqJZWlrCy8sL/v7+WLBgAU6dOoUCBQqgffv28PPzk7s8wcCIcBE0IjExEb6+vsibNy+6d++O0qVL4/79+9i5cyd+++03ucsTvmBhYYF+/frh5cuXWLhwIc6cOYOCBQuibdu2ePr0qdzlCQZChIvwUxISEuDj4wM3Nzf07NkT5cqVw4MHD7B9+3YUKVJE7vKEf2FhYYE+ffrg5cuXWLx4Mc6fP4+CBQuidevWePz4sdzlCXpOhIvwQxISErBs2TK4ubmhd+/eqFChAh4+fIitW7eiUKFCcpcnfAdzc3P06tULL168wNKlS3H58mUULlwYrVq1wqNHj+QuT9BTIlyE7xIfH48lS5YgT5486Nu3LypXroxHjx5hy5YtKFiwoNzlCT/B3NwcPXv2xPPnz+Hj44OrV6+iSJEiaNGiBR4+fCh3eYKeEeEifJP4+HgsXrwYefLkgZeXF6pWrYrHjx9j06ZNKFCggNzlCRpkZmaG7t2749mzZ/D19cWNGzdQpEgRNG/eHA8ePJC7PEFPiHAR/lVcXBwWLlyI3Llzo3///qhWrRqePHmCDRs2IF++fHKXJ2iRmZkZunbtimfPnmHlypW4desWfvvtNzRt2hT37t2TuzxBx4lwEb4qLi4OCxYsQK5cuTBo0CDUrFkTT58+xfr165E3b165yxPSkampKbp06QI/Pz+sXr0a9+7dQ7FixfDHH3/gzp07cpcn6CgRLsKfxMbGYv78+ciVKxeGDBmCunXr4unTp1i7di3c3NzkLk+QkampKTp16pTWHx48eIASJUqgcePGuH37ttzlCTpGhIsAAIiJicHcuXORK1cuDBs2DPXq1Us7U82TJ4/c5Qk6xMTEBB06dMDTp0+xbt06PH78GCVLlkSjRo1w69YtucsTdIQIF4WLiYnB7NmzkTNnTowYMQINGzbEs2fPsGrVKuTOnVvu8gQdZmJiAk9PTzx+/BgbNmyAn58fSpUqhQYNGuDGjRtylyfITISLQkVHR2PWrFnImTMnRo0ahT/++APPnz/HihUrkDNnTrnLE/SIiYkJ2rVrl3b34IsXL1CmTBnUr18f169fl7s8QSYiXBQmKioKM2bMQM6cOTFmzBg0adIEL168wPLly+Hq6ip3eYIeMzY2Rps2bfDo0SNs3rwZAQEBKFu2LOrWrYurV6/KXZ6QzkS4KERkZCSmTZsGV1dXjB8/Hs2bN8eLFy/g4+ODHDlyyF2eYECMjY3RunVrPHjwAFu3bsXr169Rvnx51K5dG5cvX5a7PCGdiHAxcJGRkZg6dSpy5syJiRMnolWrVmnLfGTPnl3u8gQDZmxsjJYtW6atNffu3TtUrFgRtWrVwqVLl+QuT9AyES4G6vPnz5g8eTJcXV0xefJktGnTBi9fvsSSJUuQLVs2ucsTFMTIyAjNmzfH/fv3sWPHDgQFBaFSpUqoUaMGLly4IHd5gpaIcDEwERERmDhxIlxdXTF16lS0b98e/v7+WLRoEbJmzSp3eYKCGRkZoVmzZrh79y527dqF0NBQVKlSBdWqVcO5c+fkLk/QMBEuBiIiIgITJkyAq6srZsyYgQ4dOsDf3x/e3t7IkiWL3OUJQhojIyM0adIEt2/fxp49exAeHo6qVavCw8MDZ8+elbs8QUNEuOi5sLAwjBs3Djly5MCsWbPQuXPntDcNilARdJmRkVHa0/179+7F58+f4eHhAXd3d5w+fRok5S5R+AkiXPRUWFgYxowZA1dXV8yZMwfdunVDQEAA5s2bh19++UXu8gThm6lUKvz++++4desW9u/fj5iYGFSvXh1VqlTBqVOnRMjoKREueubTp08YPXo0XF1dMX/+fPTo0QMBAQGYM2cOMmXKJHd5gvDDVCoVGjZsiBs3buDgwYOIj49HjRo1ULlyZZw4cUKEjJ4R4aInQkNDMXLkSLi6usLb2xu9evVCQEAAZs+eLUJFMCgqlSrt6f5Dhw4hKSkJtWrVQsWKFXHs2DERMnpCRfGX0nkkkS9fPnz48AF9+/bF4MGD4ezsLHdZgpAuSOLYsWOYOHEirl69ik2bNqFNmzZylyX8BxEuWqJvzapSqeQuQTAw2tgHUj9TG/1V7AOaZSJ3AYYqMDAQW7ZsgYmJbjcxSRQqVAj169cXO5egUWIfUDbd/qvrsTdv3iBz5syoWbOm3KV8VUhICPbu3YtGjRph//79qF+/vtwlCQZGH/aBffv2iX1AS0S4aJGzs7NOLrUSHx+PIUOGYNeuXQBSnjcQBG3Q9X1g9+7dAMQ+oA2iRRVGkiR4e3tj586dcHNzQ8uWLeUuSRDSlSRJmDt3Lnbt2oW8efOiRYsWcpdkkES4KEjqXTeTJk2CnZ0dVq1aJZ7iFxSFJPbt24dp06bB3t5e7ANaJMJFIUji5cuX6NmzJxITEzFz5kyUL19e7rIEId2QxP3799G7d2+o1WrMnTsXZcuWlbssgyXCRSGioqLQrVs3vH79Gl26dEGnTp3EnTGCYpBEcHAwOnbsiJCQEHh5eaFdu3ZiH9AiES4KkJycjLFjx+LcuXOoWLEiZsyYAVNTU7nLEoR0ExMTgx49euDevXto1KgRxo8fr/O3SOs7ES4GjiTWrVuHZcuWIUuWLFi5ciXs7e3lLksQ0k1SUhLGjBmDgwcPonjx4li2bBmsrKzkLsvgiXAxYCRx5coVDBkyBKampli2bBny5csnpgIExZAkCcuWLcPSpUuRJUsWrFu3DpkyZRL7QDoQ40IDRRKvX79Gx44dERkZialTp4onkAVFIYm9e/di1KhRsLS0xKpVq1CoUCGxD6QTES4GKioqCl26dMHz58/Rrl07DBw4UDwoJigGSVy+fBk9e/ZEcnIyvL29UbNmTREs6UgcbQxQUlIShg8fjtOnT6Ns2bJYsGABzM3N5S5LENIFSTx58gTt27dHWFgYRowYgY4dO4pgSWciXAyMJElYsmQJVqxYgWzZsmHdunVwcnKSuyxBSBck8fbtW7Rp0wavXr1Ct27dMHLkSBgbG8tdmuKIcDEgJHHo0CGMGTMG1tbWWL16NfLmzSvO2ARFIImwsDC0b98e9+/fxx9//IHZs2eLUbtMxDUXA0ESd+/eRffu3ZGYmIjFixejWrVqIlgExYiOjkaPHj1w/vx5VKlSBcuXL4e1tbXcZSmWGLkYAJJ48+YN2rVrh+DgYAwcOBCdO3cWwSIoRlxcHPr37489e/agSJEi2LBhA5ycnMQ+ICMRLnqOJMLDw+Hp6YnHjx+jefPmmDBhgnj6WFCMhIQEjBgxAuvXr0euXLmwbds2ZM2aVQSLzES46Lm4uDj07t0b586dQ6VKlbB06VJYWFjIXZYgpIukpCRMmTIl7SHJbdu2iQeFdYQIFz2WmJiI4cOHY/v27ShYsKCYChAUJTk5GbNmzcLMmTORIUMGbNmyBcWLFxf9X0eIcNFTarUaM2fOxLJly5A1a1Zs3boVOXLkEDuWoAhqtRrz58/HpEmTYG9vj40bN6JChQqi/+sQES56SJIk+Pr6YsqUKWk7VuHChcWOJSiCWq3GkiVLMHbsWFhbW2Pt2rWoXr266P86RoSLniGJLVu2YMiQITAzM8PKlStRuXJlsWMJiqBWq+Hj44Phw4fDwsICq1atQr169UT/10EiXPRI6kJ8vXr1AkksWrQIv//+u9ixBEVIDZahQ4fCzMwMK1asQOPGjUX/11HiflU9QRKHDx9G586dkZCQgLlz58LT01MsRikoglqtxrJlyzBs2DCYmprC19cXTZs2FcGiw8SRSQ+QxLFjx+Dp6YmYmBhMmTIFvXr1EsEiKIJarcaiRYswdOjQtGBp3ry56P86Tvx1dBxJHD16FO3atUNUVBQmTJiAgQMHioX4BEVITk7G/PnzMWLECJibm2PlypUiWPSE+AvpMJI4cOAA2rZti8jISIwfPx7Dhg0TT98LipCUlIQZM2Zg9OjRsLKywpo1a9CsWTMRLHpCHKV0lCRJ2LFjB3r06IG4uDhMmjQJQ4YMEcEiKEJCQgImTZqE2bNnw97eHmvXrhV3hekZcaTSQWq1GuvWrUP//v3Tzt769esngkVQhNjYWIwaNQpLliyBs7MzNmzYIJ5j0UPiaKVjkpKS4O3tjbFjx8LIyAgLFy5Ely5dxDUWweCRRFRUFLy8vLBx40ZkyZIFW7ZsEU/e6ykRLjokLi4O48aNw4IFC2BjY4Nly5ahRYsWYo5ZMHgkERoaim7duuHAgQPIkycPtm7dimLFiolg0VMiXHQASURERKBfv37YsmULMmbMiLVr16JWrVpixxIMHkm8evUKnp6euHjxIooXL47NmzeLt6jqOREuMiOJwMBAdO7cGWfPnkW+fPmwceNGlCxZUuxYgsEjiXv37qFdu3Z4/PgxqlWrhrVr1+LXX38V/V/PifkWGZHE5cuXUbt2bZw9exaVK1fGkSNHRLAIiiBJEo4ePYoGDRrgyZMnaNmyJbZv3y6CxUCIcJFJUlISVq9ejUaNGuHly5do37499u7dC1dXV7FjCQYvKSkJPj4+aNWqFUJCQjBw4ECsWrUKjo6Oov8bCDEtls5IIiwsDGPGjMGqVatgamqKSZMmYfDgweINkoLBS70jbNy4cVi2bBnMzc0xd+5c9OzZE6ampnKXJ2iQCJd0JEkSrly5Ai8vL9y+fRvZs2fH4sWLUb9+fXFHmGDwSCIgIAA9e/bEqVOn8Ouvv8LHxwd16tQR/d8AiXBJB6mjlfnz52PhwoWIiYlB3bp1sXDhQuTOnVtMAwgGT5IkHDt2DH379kVAQADKlSuHFStWoGDBgqL/GyhxuqBlcXFx2L59O9zd3TFt2jSYmZlh1qxZ2LlzpwgWQRGioqIwceJENG/eHG/evEGXLl1w4MABESwGToxctOjDhw+oW7cuLl68CCMjIzRo0ABTp04VryQWFCM4OBiNGzfG2bNnkSFDBsybNw8dO3aEmZmZ3KUJWibCRYvs7e0RExODEiVKYOTIkahXrx7MzMxEsAiKYWlpiZiYGJQrVw6LFi1C8eLFRf9XCBEuWvT48WN4enrCxcUFJiYmOH78uNwl/U10dDSSkpLkLkMwUM+fP0f79u3h4OCAd+/e4d27d3KX9DdiH9AOFUnKXYQhCg8Px61bt+Qu45tkzZoV+fLlE2eUgkaJfUDZRLgIgiAIGifuFhMEQRA0TlxzEQRBb3w50SKmsHSbGLnoidu3b0OlUuH27dtylyIIsrlz5w6MjIxw584duUsR/oMIF0EQBEHjRLgIgiAIGifCRRAEQdA4ES6CIAiCxolwEQRBEDROhIsgCIKgcSJcBEEQBI0T4SIIgiBonAgXQRAEQeNEuAiCIAgaJ8JFEARB0DgRLoIgCILGiXARBEEQNE6EiyAIgqBxIlwEQRAEjRPhIgiCIGicCBdBEARB40S4CIIgCBonwkUQBEHQOBEugiAIgsaJcBEEQRA0ToSLIAiCoHEiXARBEASNE+EiCIIgaJwIF0EQBEHjRLgIgiAIGifCRRAEQdA4ES6CIAiCxolwEQRBEDROhIsgCIKgcSJcBEEQBI0T4SIIgiBonAgXQRAEQeNEuAiCIAgaJ8JFEARB0DgRLoIgCILGiXARBEEQNE6EiyAIgqBxIlwEQRAEjRPhogdIIjw8HAAQHh4OkjJXJAjpT+wH+kWEiw6LiIiAt7c33NzcUKNGDQBAjRo14ObmBm9vb0RERMhboCCkA7Ef6CcVRfzrpGPHjqFp06aIjY0FgD+dpalUKgCAlZUVdu3ahdq1a8tSoyBom9gP9JcIFx107Ngx1K9fHyQhSdI//pyRkRFUKhUOHTokdizB4Ij9QL+JcNExERERyJo1K+Li4v51h0plZGQES0tLvH37Fg4ODtovUBDSgdgP9J+45qJj1q1bh9jY2G/aoQBAkiTExsZi/fr1Wq5MENKP2A/0nxi56BCScHNzg7+//3fdCaNSqZArVy48f/48bR5aEPSV2A8MgwgXHRIaGgoXF5ef+v0MGTJosCJBSH9iPzAMYlpMh0RHR//U70dFRWmoEkGQB0k8fvz4pz5D7Ae6wUTuAoT/sbGx+anfb926NWrUqAF3d3dUqFABVlZWGqpMELSDJF6+fImzZ8/i3LlzOHv2LN6+fftTn2lra6uh6oSfIabFdEjqXPPLly+/+3ednZ3h7u6Oc+fOITQ0FKampihdujSqVq2KqlWrokKFCrC2ttZC1YLw7Uji+fPnfwqT9+/fw8jICCVKlIC7uzvc3d3h5eWFwMDA7/pscc1Ft4iRiw5RqVRwd3f/oXAZO3YsvLy80qYVUnfcFStWYNq0aTAxMUHp0qXh7u6OqlWromLFij89UhKE/0ISz549w9mzZ9MC5cOHDzA2NkaJEiXQtm3btP5ob28PIOXOry1btnx3uJCEl5eXCBYdIcJFRyQkJGD48OFYvXo1jI2NIUnSd90pY2KS8qdUqVQoVKgQChUqhN69e4Mknj59mrZjr1mzBjNmzICxsTFKlSqFqlWrwt3dHZUqVRLTCcJP+2t/O3v2LIKDg9P6m6enJ9zd3VGxYkXY2dn97fc/ffqEqVOn4s2bNzAzM0NSUtI37wepfV/QDWJaTAf4+/ujRYsWePDgAebMmQM3Nzc0aNDgm55MBlLWWTp+/Dg8PT2xZMmSfx2R/NeZZOo0WqVKlb668wvCl/46Uj537hxCQkL+NlKuUKHCf5683Lx5E1OnToVKpcLYsWMREhLyzU/oA0DevHnx8uVLzJgxAwMHDhQjGLlRkNWOHTtoZ2fHXLly8ebNm2n//ujRo7S2tqZKpaJKpSKAtH9S/521tTWPHTtGkly/fj2tra2ZP39+3r9//5u/X5Ik+vn50dfXl23atGGWLFkIgEZGRixVqhQHDx7MAwcOMDw8XNObLughtVrNBw8ecNGiRWzatCldXFwIgKampqxQoQJHjRrF48ePMzo6+ps/Mzk5mStXrmTVqlU5ePBghoWFpf1/37MfJCQkcMiQIVSpVGzUqBE/ffqkjSYQvpEIF5nExcWxd+/eBMDmzZszIiLibz8THh5Ob29v5s6d+087Ve7cuent7f2333ny5AmLFClCCwsL+vr6UpKk765LkiQ+f/6cK1asYLt27Zg1a9a0sClRogQHDRrEffv2/ekAIBgutVrNe/fu0dvbm02aNGGGDBnSwqRSpUocM2YMT5w48V1h8qWPHz+yX79+9PDw4IYNG6hWq//2M9+7H+zfv58ZMmRg9uzZeenSpR+qS/h5Ilxk8OzZMxYrVozm5uZctmzZf4aAJEkMDQ1lQEAAQ0ND//XnY2Nj2aNHDwJg69atGRkZ+VO1SpLEly9fctWqVWzfvj2zZcuWdtZYrFgxDhgwgHv37hVniQZCrVbzzp07XLBgARs3bkwnJycCoJmZGatUqcKxY8fy1KlTjImJ+envunr1Khs1asSmTZvy3r17//nz37MfvH79mpUqVaKJiQlnzpz51dAStEuESzrbvHkzbWxs6Obmxjt37mjte7Zs2UJbW1vmyZOHt2/f1tjnSpJEf39/rlmzhh06dGCOHDnSwqZo0aL08vLi7t27GRoaqrHvFLQnOTmZt2/f5rx589ioUSM6OjoSAM3Nzenu7s7x48fzzJkzjI2N1dh3JiUl0cfHh+7u7hw+fPhXR+2akJiYyJEjR1KlUrFevXoMCQnRyvcIXyfCJZ3ExsayW7duBMA2bdr89IjiWzx79ozFixenubk5lyxZ8kPTZN8iICCAa9euZadOnZgzZ860aYsiRYqwX79+3Llzp9ixdURycjJv3rzJOXPmsGHDhrS3tycAWlhY0MPDgxMnTuTZs2cZFxenle8PCgpinz59WK1aNW7ZsiVdRhRHjhyhi4sLf/31V547d07r3yekEOGSDp48ecLChQvTwsKCK1eu1NpB/mvi4uLYp08fAmCzZs20dpb4pVevXnH9+vXs3Lnzn+bJCxUqxD59+nDHjh0MDg7Weh1Cyijh+vXrnD17NuvXr087OzsCoKWlJatXr85Jkybx/PnzjI+P13otly5dYoMGDdiiRQs+fPhQ69/3pbdv39Ld3Z3GxsacMmWKmCZLByJctGzdunW0srJigQIF+ODBA9nq2LlzJ+3t7ZkrVy7euHEjXb/7zZs33LhxI7t27Uo3N7e0sClYsCB79erFbdu2MSgoKF1rMlRJSUm8evUqZ86cybp169LW1pYAaGVlxZo1a3LKlCm8ePEiExIS0q2mxMRELlmyhO7u7hw1ahQ/f/6cbt/9paSkJI4bN45GRkasVauW6HNaJsJFS6Kjo9mxY0cCYIcOHX74bhpNevnyJUuXLk1TU1MuWLAgXUdQX3r79i03bdrE7t27M2/evGlhkz9/fvbs2ZNbtmzh+/fvZalN3yQmJvLKlSucPn0669SpQxsbGwKgtbU1a9WqxWnTpvHSpUvpGiZfev/+PXv27Mnq1atzx44dsvW5L504cYKZM2fmL7/8wlOnTsldjsES4aIFDx8+ZMGCBWllZcW1a9fKXc6fJCQkcMCAAQTAxo0b68Qtxe/fv+eWLVvYo0cP5s+fPy1s8uXLx+7du3Pz5s189+6d3GXqhISEBF66dInTpk1jrVq1aG1tTQC0sbFhnTp1OH36dF65coWJiYlyl8pz586xXr16bNWqFZ88eSJ3OX/y4cMHVq9enUZGRpwwYQKTk5PlLsngiHDRIEmSuHLlSlpaWrJw4cJ8/Pix3CX9o71799LBwYE5cuTg1atX5S7nTz58+MBt27axV69eLFCgQFrYuLm5sWvXrty4cSPfvHkjd5npIiEhgRcuXOCUKVNYo0YNWllZEQBtbW1Zr149zpw5k9euXWNSUpLcpaZJTEzkggUL6O7uzrFjxzIqKkrukr4qOTmZkyZNorGxMT08PMRoWcNEuGhIZGQk27ZtSwDs2rWrRp4D0LbAwECWK1eOJiYmnDNnjs5e5AwKCuL27dvZp08fFipU6E8P0XXp0oXr16/n69ev5S5TI+Lj43n+/HlOmjSJ1atXp6WlJQHQzs6O9evX5+zZs3n9+nWdCpMvvX37lt26dWONGjW4e/dunZgG+y9nzpxhlixZmDFjxrQVL4SfJ8JFA+7evcu8efPSxsaGmzZtkruc75KYmMihQ4cSAOvXr68Xz6eEhIRw586d7Nu3L4sUKZIWNrly5WKnTp24bt06BgYGyl3mN4mLi+PZs2c5ceJEenh40MLCggBob2/Phg0bcs6cObx586ZeTNucPn2adevWZevWrenn5yd3Od8lODiYtWvXppGREUePHq2z4a1PRLj8BEmSuGzZMpqbm7No0aJ6t0N96eDBg8yQIQOzZs3KCxcuyF3Od/n48SN3795NLy8v/vbbb2lh4+rqyg4dOnDNmjUMCAiQu0ySKc87nT59muPHj6e7uzvNzc0JgA4ODmzUqBHnzZvH27dv60WYpIqPj+fcuXPp7u7OiRMn6sTNKz9CrVZz+vTpNDExYeXKlRUz9aotIlx+0OfPn9miRQsCYO/evbX20Fl6evPmDStVqkRjY2NOmzZNZ6fJ/ktoaCj37NnDAQMGsFixYmkLHmbPnp2enp5ctWoVX758mS5TNjExMTx16hTHjh3LKlWq0MzMjADo6OjIxo0bc8GCBbxz545ehcmXXr9+zc6dO7NmzZrcv3+/XkyD/ZcLFy4wW7ZsdHZ25qFDh+QuR2+JcPkBN2/eZO7cuWlnZ8ft27fLXY5GJSUlcdSoUVSpVKxdu7ZBPOwYFhbGffv2ceDAgSxRokRa2GTNmpXt2rXjypUr+fz5c40cGGNiYnjixAmOGTOGlSpVoqmpKQEwQ4YMbNKkCb29vXnv3j29De4vHT9+nLVr12a7du344sULucvRqNDQUDZo0IAqlYrDhg3Tibvv9I0Il+8gSRIXLlxIMzMzlixZ0uB2qC8dO3aMLi4u/OWXX3j27Fm5y9Go8PBwHjhwgIMHD2bJkiVpZGREAPz111/Zpk0b+vr68tmzZ98UNtHR0Tx+/DhHjRrFChUqpIWJs7MzmzZtykWLFvHBgwcGESap4uLiOGvWLLq7u3Pq1KkaXXdMl6jVas6ZM4empqYsX7683lzH0xUiXL5ReHg4mzRpQgD08vJKl+Uy5Pb+/XtWrVqVRkZGnDhxot5O3fyXiIgIHjx4kEOHDmXp0qXTwuaXX35h69at6ePjw6dPn1KSJEZFRfHo0aMcMWIEy5cvTxMTEwJgxowZ2bx5cy5ZsoQPHz40iOmhrwkICGCHDh1Yq1YtHj582GC380tXrlyhq6srnZycuHfvXrnL0RsiXL7BtWvX6OrqSgcHB+7Zs0fuctJVcnIyx48fT5VKxerVq/PDhw9yl6R1nz9/5uHDhzls2DCWKlUqLWxMTU3TptQyZMjAFi1acOnSpXz8+LEiDrJHjhxh7dq12aFDB525QSK9hIWF8Y8//qBKpeLAgQNlW/FAn4hw+ReSJHHu3Lk0MTFh2bJlFbdDfenUqVPMnDkzM2XKxJMnT8pdjtZ8/vyZhw4dShvFGBsbEwCdnJxYoEAB5syZ86ujlUePHhlswMTGxnLatGl0d3fnzJkzDeLmlR8hSRK9vb1pZmbGMmXK0N/fX+6SdJoIl3/w6dMnNmzYkAA4ePBgcabClIcZa9SoQZVKxbFjxxrEswBfXn/5cpSSJUuWtOsvfn5+fwqOqKgoHjt2LO06S2rYuLi4sFmzZgZ1neXly5ds3749a9euLR4w/H83btxg7ty56eDgwJ07d8pdjs4S4fIVly5dYrZs2ejk5MQDBw7IXY5OUavVnDJlCo2MjFilShW9W/Mr9c6xQYMGffXOsRUrVnz3nWPR0dE8ceIER48e/dU7xBYuXKh3d4hJksQDBw6wZs2a7NSpE1+9eiV3STolIiKCzZs3p0qlYt++fRU7mvs3Ily+oFarOXPmTBobG7NixYoGs6SINpw7d45ZsmShs7Mzjxw5Inc5/+jTp0/cu3fv3555yZYtG9u3b6+VZ15iYmJ48uRJjh07lpUrV057tsXJySnt2Za7d+/qbNjExMRw0qRJdHd359y5cxVx88qPkCSJS5cupYWFBUuUKMHnz5/LXZJOEeHy/0JCQli3bl0C4IgRI8R97d8gJCSEderUSWszXZgmCw0NTXtav2jRomlh8uXT+v7+/ul6feSfnsp3dHTk77//rlNP5T979oxt2rRh3bp1xXL03+jOnTvMmzcv7ezsuGXLFrnL0RkiXKg/Z+G6SO7RXuo6Y/369fvTOmM5c+Zkp06duHbtWp27ESN1PbEJEyZ8dT2xuXPnpvt6YpIkcc+ePaxRowa7du0qlj75TpGRkWzTpg1VKhV79OhhsM/+fA9Fh8uX1w/c3d317vqBLkmv61TBwcHcsWPHV1dI7ty5M9evX6931we+XAm5WrVqaWHz5UrIN27c0NrIMDo6muPGjaO7uzsXLFggbl75QZIkccWKFbS0tGTRokX59OlTuUuSlWLDJSgoiDVr1jSoO5/kpo077IKCgtLe7VKwYEFFvNslPj7+T+9wSV12XxvvcHn69Clbt27NevXq8dy5cxqoXrh//z4LFChAGxsbbtiwQe5yZKPIcPnymY0TJ07IXY5BkSSJ8+bNo6mp6Q89G5T6VsqePXv+6a2UefPmZffu3blp0ya+fftWO8XrqNS3T06dOpW1atVKe2FY6tsnZ8yY8d1vn5QkiTt27GD16tXZo0cPMWrXsKioKHbo0IEqlYqdO3fWi/c7aZqiwkWJT5vL5VtXNXj37h03b97M7t27M2/evGlhkj9/fvbo0YNbtmwRbwj8i8TERF65coXTp09n7dq10151bG1tzVq1anHatGm8fPnyP4ZNZGQkR48eTXd3dy5atEjcvKJFa9asobW1NQsVKsSHDx/KXU66Uky4fLlO1qRJk3TizhxD97X12N68ecONGzeya9eudHNzSwuTAgUKsFevXty2bZsI/e+UmJjIq1evcubMmaxbty5tbGwIgFZWVqxZsyanTJnCixcvMiEhgY8fP2aLFi3YoEEDXrx4Ue7SFeHRo0csXLgwraysuHr1aoNdyeGvFBEuhrzCr6579eoV27dvTyMjo7RbcAGwUKFC7NOnD7dv386goCC5yzQoSUlJvH79OmfNmsX69evTzs6OAGhmZkZHR0eWKVOGe/fuFc+vpKOYmBh27dqVKpWKnp6ejIqKkrskrVORJAxUcnIyxo8fj+nTp6NWrVpYv349MmbMKHdZBu3Vq1c4e/Yszp07h7NnzyIgIAAAkCdPHnz8+BFJSUlYuHAhunTpInOlyhEeHo6BAwfiwoULsLGxwatXr/D582dYWFigfPnyqFq1Ktzd3VG2bFlYWFjIXa5B27RpE3r27ImsWbNi27Zt+O233+QuSXvkTjdtefPmDStXrkxjY2NOnz5dZ5+G1ncBAQFcs2YNO3ToQFdX17SRSdGiRenl5cXdu3fz48ePJP/89s5evXqJJTPSwYMHD9isWTM2bNiQV65cIZly7fHWrVucN28eGzVqRAcHBwKgubk5q1atyvHjx/PMmTPi76Mlfn5+LFasGC0tLbl8+XKDnSYzyHA5dOiQ3r4PXpdJksSXL19y1apV9PT0ZPbs2QmAKpWKxYoV44ABA7hnzx6Ghob+62f4+PjQ3NycRYsWpZ+fXzpugXKo1Wpu3LiRHh4e7Nu3L0NCQv7xZ5OTk3nnzh3Onz+fjRs3pqOjY1rYVKlShePGjeOpU6fEg4EaFBsby169elGlUrF169b8/Pmz3CVpnEGFS2JiIocOHUoArF+//r8e5IT/JkkSnz9/zhUrVrBdu3bMmjVrWpiUKFGCgwYN4r59+xgWFvbdn3337l3mzZuXNjY23LRpkxaqV66wsDAOGTKEVatW5YoVK7775hW1Ws179+7R29ubf/zxBzNkyJB2zaZSpUocM2YMT5w4ocjbazVt27ZttLOzo5ubG2/fvi13ORplMOESGBjIcuXK0cTEhHPmzBHTYD9AkiQ+e/aMvr6+bNOmDX/99VcCoJGREUuVKsXBgwfzwIEDDA8P18j3RUZGsm3btgTArl27ioOVBty9e5dNmjTh77//zuvXr2vkM9VqNe/fv89FixaxadOmdHZ2Tnt5WsWKFTlq1CgeP36c0dHRGvk+pXn+/DlLlixJc3NzLl682GCmyQwiXPbu3UtHR0fmyJEjbV5Z+G+SJPHp06f08fFh69at+csvv6SFSenSpTl06FAePHiQERERWq1h1apVtLS0ZOHChfn48WOtfZchU6vVXLt2LT08PDhgwACtjtrVajUfPnzIxYsXs3nz5nRxcSEAmpiYsHz58hw5ciSPHj2qiDuiNCU+Pp5eXl5UqVRs1qyZxk7g5KTX4ZKQkMABAwYQABs3bvxD0zNKIkkSHz9+zKVLl7Jly5bMnDkzAdDY2Jhly5blsGHDePjwYVnmfx8+fMgCBQrQysqKa9euTffv12efPn3iwIEDWbVqVa5ZsybdR+1f9qsWLVowU6ZMf+pXw4cP55EjRxgZGZmudemjXbt20cHBgbly5dLYyFMuehsu/v7+LF26NE1NTent7W0wQ0lNkiSJjx494pIlS9i8eXNmzJgx7QyzXLlyHDFiBI8ePaozO310dDQ7depEAOzQoYOYZvkGt27dYuPGjfnHH3/w1q1bcpdDMqXfPXnyhD4+PmzVqtWfTmLKlCnDoUOH8tChQwZ5EVsT/P39WbZsWZqZmXH+/Pl6e2zTy3DZuXMn7e3tmStXLt64cUPucnSGWq3mgwcPuGjRIjZr1uxP0xUVKlTgqFGjeOzYMZ2frli/fj2trKxYoEABPnjwQO5ydFJycjJXrVrFqlWrcvDgwTo9apckiX5+fly+fDnbtGnDLFmy/Ola3pAhQ3jgwAGtTr/qm4SEBA4ePJgqlYq///47P336JHdJ302vwiUuLo59+vQhADZr1kzxnTH1rp6FCxeySZMmaXf1mJqaslKlShw9ejRPnDihlyOAJ0+esEiRIrSwsODKlSv19uxNGz5+/EgvLy96eHhw/fr1enfzypd3IbZt2/ZPN46k3oW4f/9+g7ju8LP2799PJycn5siRg5cvX5a7nO+iN+Hy/PlzFi9enObm5ly6dKkiDzZqtZp37tzhggUL2LhxYzo5OaXdIlqlShWOHTuWp06dMpi7rmJjY9mtWzcCYNu2bXVm+k5O165dY6NGjdi0aVPevXtX7nI0QpIkvnjxgqtWrWL79u2ZLVu2tFveixcvzgEDBnDv3r16efauCa9evWLFihVpamrKWbNm6c3JhF6Ey/79+2lra0s3NzfeuXNH7nJk4enp+aeH29zd3Tl+/HiePn3a4B9u27x5M21sbJg3b15Fv6d8zZo1dHd357Bhwwz6rF6SJPr7+3P16tXs0KEDc+TIkRY2RYsW5enTp+UuMd0lJiZyxIgRVKlUrF+/vl7s81pZW0wLH6lVKpVK45+p6TaQJOlPdWq6Zk1/nqa3nyknQlCpVFr5e+lDHwgNDYVarUbGjBn1og00uf2pn6X0PpC6HxgZGWn0c1Npsg1MNPZJXwgMDMSWLVtgYqKVj9cYkihUqBDq16+v8Y6l9DZQ+vYDQFBQEE6dOgVjY2ONfq42uLq6oly5cqIPaOE4sHXrVr1og4IFC2q0DbSyxW/evEHmzJlRs2ZNbXz8TwsODsb+/fvRsGFD7N+/H/Xr19f4d+hDGxw4cAANGjTAgQMHNN4GSt9+AAgJCYGTkxNKlSql8c/WhLCwMFy5cgXly5fH5cuXUa5cOY1+vugD/2uDGjVqaPyzNSEoKAiHDx9GvXr1NN4GWotTZ2dnZMuWTVsf/8MSExMxfPhwbN++XavDS0C322DEiBFabwNd3f6EhAQMHz4cO3bs0HofsLe318nXPCQlJcHX1xdnzpxJm2rSBl3tA+m1DwBAhgwZdLINkpKSMHr0aGzduhVqtVrjbaC9FtVBJOHr64vt27cjd+7caNmypdwlpbu/tkGLFi3kLildpW7/jh07FLn9QEobHDt2DGfOnMEvv/wCDw8PuUtKVySxatUqbN++Hbly5VJsH9i2bRu2bdsGV1dXrbSBYsKFJK5cuYIxY8bA0tISPj4+yJIli9xlpavUNhg7diwsLS2xbNkyRbUBSVy9ehXjxo1TdB94+fIlVqxYAVNTU/Tv3x8ZMmSQu6x0QxI3btzA6NGjYWFhobh9AEhpg2fPnmH48OEwNjbG/PnztdIGigmX4OBgdOvWDVFRURg7dizc3d3lLildkURwcDC6d++OqKgojBkzRnFtEBIS8qftr1KlitwlpbuYmBgsWLAAUVFRaNGiBUqWLCl3SekqNDQU3bt3R2RkJEaMGIGqVavKXVK6i4uLg5eXF4KCgtCzZ0/UqVNHK9+jiHBJSEjAgAED8PjxYzRu3BheXl5anWPVRYmJiYpug8TERAwdOhSPHj1Co0aNFLf9AKBWq7Fx40Y8fvwYv/32G1q3bq2oNkjtA/fv30e9evUwaNAgRW0/kPJIw/z583Hq1CmUKlUK48aN09rdjAbfspIkYcmSJdixYwfy58+PRYsWwdzcXO6y0pUkSVi0aBF27tyJ/PnzY+HChYpqA5JYuXIltmzZgjx58ihu+4GUNrh+/Tr27NkDBwcHDBgwABYWFnKXlW5Sr7Vt2rQJuXPnxuLFixW1/UBKG5w7dw4zZ86Eg4MDlixZAnt7e619n27ffP2TSOL8+fOYMGECbGxs4Ovri19++UVrd8boIpI4e/YsJk2aBBsbG6xYsUJRbZB6nWXMmDFpc+y//vqrYrYfSGmDwMBAzJ8/H2q1Gj179kSOHDkU0wYkceHChbTrrcuXL0e2bNkUs/1AShsEBQWhT58+iI+Px4wZM1CyZEmttoHBhgtJvH37Ft27d0dsbCzmzp2LSpUqKa5DvXr1Ct27d0dcXBzmzZuHChUqKKoNUq8zRUZGYsqUKfDw8FDU9qdea5syZQpCQ0Px+++/o1q1aoppg9TjQLdu3RATE4MZM2agatWqitn+VImJiRg4cCD8/PzQokULdOnSRettYLDTYrGxsejVqxeeP3+OVq1aoVevXorrUNHR0ejevTv8/f3Rvn179OjRQ1FtEB8fj/79++PRo0f4448/MGDAAEXNsZNEWFgYpkyZAn9/f1SuXBndu3fX+afFNSkmJuZPx4G+ffsqqg8AKf3Ax8cHu3fvRv78+TFv3jyYmZlp/XsNspep1WpMmzYNhw8fRvHixTF//vx0aUxdkpycjDFjxuDUqVMoW7Ys5syZo6g2SL1wuWvXLhQoUEBx11lI4uPHj5g8eTIePXqEkiVLYvDgwYq6zpCcnIyJEyfiyJEjKFGiBObNm6eoPgD879LA+PHjYWVlhWXLliFz5szpcpJpcOFCEnv27MHcuXPh7OyMVatWwdnZWe6y0hVJrFmzJu05jtWrV8PR0VHustINSRw5cgRTp06FnZ0dVqxYkW47lC4giXfv3mHSpEl4/vw5ihcvjlGjRsHW1lZRbbBx40YsXLgQmTJlwpo1axR5HHj37h169OiB2NhYzJo1K10vDRhUuJDEw4cP0bdvX5DEggULUKxYMcXsUMD/Ll4OGzYMpqam8PHxQf78+RXTBiTh5+eHnj17IikpCfPnz0f58uUVtf0vX77E5MmT8ebNG1SoUAHDhg2DnZ2dotrg0qVLGDx4MExMTLB06VIULlxYMdufKi4uDn369MHz58/RunVr9OrVK12nBA0qXD59+oTOnTsjJCQEQ4YMQcuWLRXVoUjC398fnTt3RnR0NKZPn466desqqg0iIiLQtWtXvH//Hn379kWnTp0Us/2SJOHKlSuYP38+wsLCUL16dQwYMABWVlaKaYPUfaBjx46IjIzE5MmT0ahRI8Vsfyq1Wo2pU6fi0KFDKFasmCxTggYTLgkJCRg4cCBu3ryJ2rVra/XhIF1EEuHh4ejYsWNawPTr109RFy9TH5K7fPkyPDw8MHnyZEVcvCaJpKQk7Ny5Exs2bEBycjKaNWuGzp07K+oay1/3gU6dOmHgwIGK2geA/60bNn/+fLi4uGDlypVwcXFJ9zoMYs+TJAne3t7YsmUL3Nzc4OvrC2tra7nLSldxcXHo27cvLl26hKpVq2LOnDmKungpSRIWLFiAdevWIVeuXFixYgVsbW3lLkvrSCIiIgJLlizBmTNnYG1tjb59+6JOnTqKOrkCUu4O7NevHy5dugQPDw/MnTtXUfsA8L+10wYMGACVSoWFCxfKdmlA78OFJA4dOoSJEyfCxsYGq1evVtwDUklJSRg3bhy2bduG/PnzY82aNVp98lbXkMTu3bsxceJE2NraYvXq1ciZM6fB94HU60tz587FixcvkC1bNgwdOlSR1xdS94GtW7cif/78WL16taL2ASClP7x+/RodO3ZEeHg4xo4diyZNmsjWF/Q6XEji8ePHaRdvFyxYgIoVKypqx5IkCYsXL8bChQuROXNmbNq0CdmzZ1dMG5DEzZs30adPH6jVasyfPx+VK1c2+O1PTk7G0aNHsWLFCkRHR6N8+fLo37+/1l6BrMskScLSpUvh7e2NTJkyYePGjYraB1J9/vwZnTt3hp+fH1q1aoVhw4bJOnrV63D59OkTOnXqhA8fPsDLy0tRF2+BlAPrpk2bMGbMGFhbW2PNmjWKujsu9UzN09MTnz59wqhRo9CuXTuD3n6SiIqKgq+vL44ePQpTU1N4enqiZcuWMDc3N+ht/xqS2L59O0aNGgUrKyusXr0axYsXV1w7xMfHY8CAATh79iwqVqyIRYsWyX69TW/DJT4+Hn379sWNGzdQu3ZtTJkyRREXb1ORxP79+9G3b18AwKJFi1CzZk3F7FRfXrz18/ND69atMWrUKIO+zpC6nM+cOXPw6NEjZM6cGf3790eZMmUUd9EaSGmP48ePo3fv3iAJb29v1K5dWzH7QKrk5GRMmTIFmzZtQp48ebB27VqdeK5NL4/GarUaM2fOTFvpeMWKFYq6gE8Sp0+fRpcuXZCQkIA5c+agTZs2itqpUu/hP3fuHCpXrqwTZ2raJEkSbty4gblz5yI0NBQlSpTAoEGDkCVLFkX93VOlvviuY8eOiI6OxrRp0wx+1Po1kiTBx8cHc+bMgbOzM9avX68z1xv1LlxSh8HTp0+Ho6Mj1q1bh6xZs+pEY6aH1Ick27Zti8jISIwfPx49e/ZU1Jnrl+8/L1iwINavX68TZ2raolarcejQISxfvhyJiYlo3LgxunTpoqjnV75EEnfu3EHr1q0RGhqK4cOHo3///gY9av0akti6dStGjBgBCwsLrFy5EmXKlNGZPqFX4ZJ6tpI6FbR48WKULl1aZxpT20ji4sWLaNWqFT59+oThw4dj2LBhipoOTE5OxrRp07Bs2TJkzZoVmzdvNuiLt0lJSdi8eTM2bdoEExMT9OnTBw0aNFDU3/xLqatwNG/eHO/evUOfPn0wduxYmJqayl1aukqdFu/Tpw9IYtGiRahXr55O7Qd600NJIiAgAB06dEBERATGjx+P5s2b61RjalPqAnStW7fGx48fMXjwYIwbN05RO5VarcaiRYvSRq0bNmxAkSJFDLYPJCYmYuXKldi1axdsbGwwdOhQVKhQQVGj1C+l3h3arFkzBAYGokuXLpgxY4Yin2U5ceIEunbtivj4eMycORNt27bVuf1AL8KFJEJDQ9GuXTu8ePECHTp0wPDhwxUzDE69xtK2bVt8+vQJQ4YMwcSJExW3yvHKlSvT7gpas2aNQd9ynJCQAB8fH+zfvx+Ojo4YM2YMihYtarDb+19SRyzNmjXDixcv4Onpifnz58PS0lLu0tJV6rGgffv2iIyMxMSJE9G7d2+dPOHQvYq+IjY2Fj169MCVK1dQvXp1LFiwQDFnKyRx+PBhtG7dGmFhYRgxYoQig2Xt2rUYNGgQTE1NsXz5cp2bAtCkxMTEtGBxdnbG5MmTFR8sd+7cQZMmTfDixQu0b98eixcvVtRNPEBKO5w8eRJt27ZFREQERo0albY4py7S+XBJSEjA0KFDsXfvXvz2229Yt26dYp68lSQJO3bsQLt27fD582eMGTMG48aNU1SwqNVqrF69Gl5eXlCpVFiyZAmaNWtmsAfaxMRE+Pr6pgXLpEmTFLWq9V+RxOXLl/HHH38gICAAnTt3xpIlSxQZLAcPHkTbtm0RHh6OkSNHYtSoUTo9La7T4ZKUlITJkyfD19cX2bJlw+bNmxVz62XqQbVLly6Ij4/HtGnTdL4zaVpycjKWLl36p2Bp27atTk4BaEJycjLWrVuHPXv2wMnJCRMnTkTevHkV0d+/hiSOHj2Kpk2b4v379+jduzcWLlyouGCRJAlbt26Fp6dn2h2io0eP1vljgc7upcnJyZg7dy5mzpwJJycnbN68GQULFlTEjpb6HhIvLy8AgLe3NwYMGKCzw19tSEpKwqxZszB06NC099K0b9/eYINFrVZj27Zt2LZtG+zt7TFu3Djky5dPEf39a9RqNTZt2oQ2bdogPDwcw4cPx+zZsxV3jSX1BKt79+5ITEzEjBkz0t7VpOt08miVnJyMBQsWYPz48bC1tcWGDRtQoUIFRexo8fHxmDx5MmbPng0bGxssW7YMzZs3N9iD6l+RRFxcHMaOHYtFixbBzs4OK1euRKNGjQy2DSRJwoEDB7Bu3TpYW1tj9OjRilx8MlViYiLmz5+PiRMnQqVSYfr06ejXr59eHFA1hSTi4+MxadIkzJ8/HxYWFli8eDHatWunNzcy6Vy4JCUlYfbs2Zg4cSKsrKywbt061KpVy+B3NJKIiYnBkCFD0t6/sHbtWkVseyqS+PTpE/r27YsdO3YgS5YsWLduHTw8PAy2DVLv/vHx8YGpqSmGDh2KEiVKGOz2/pvUddNGjhwJX19f2NnZYeHChWjVqpXeHFA1IfXu2H79+mHXrl3ImDEjfH19UbduXb06wdKZcElN6okTJ2Lu3Lmws7PDmjVr0KBBA4Pf0UgiLCwMPXv2xO7du5EjRw5s2rQJ5cqVM/htT5W6fHyXLl1w5coVFCxYEBs2bDDohThJ4urVq1iwYAFIwsvLSzEj9L8iiTdv3qBHjx44fvw4smXLhjVr1qBq1aqKag+SePToEbp164br16+jYMGCWLNmDUqWLKl37aATMZh6cO3WrRtmz54NZ2dnbNu2DQ0bNtS7Bv1eqTtVs2bNsGvXLhQuXBgHDhxQVLBIkoQjR46gTp06uHr1KmrUqJH2elZDbYPU5zZmzZqFhIQEdOvWDTVr1tSrM1NNSb0jrE6dOjh27BhKly6Nw4cPKy5Y1Go1du/ejTp16qQtyHv48GG9DBZAB8IldSdr0KBB2qqe+/fvR/Xq1fWyQb8HSdy9exf169fHuXPnUKVKFRw4cEAxNy6kTgVOnToVLVq0wIcPH9CrVy/s2LHDoJd0IYmXL19iypQpiIyMROvWrfHHH38oMlhSb71u1KgRnj17htatW+PAgQMoUKCAwf79/4okPn/+jJEjR6a9PmLAgAHYtm2bXq+bKNu0WOp7vzdt2oSRI0ciJCQENWrUgK+vL1xdXfW2Qb+VJElpawMFBQWhefPmWLp0KZycnAx+24GUv/+zZ88wcOBAHD9+HA4ODpg3bx46depk0BduSeLdu3eYOHEiPn78iMaNG+vVRVpNSb2uMHLkSKxfvx7m5uaYPHkyBg4cqKj30qSeYA4YMACXLl1CxowZMWfOHLRo0ULv7w6VpfrU+fUxY8Zg3759MDU1xZAhQzBmzBjY2toadMdKvRtq3rx5mDFjBpKTkzFkyBCMHz8elpaWBr3tQMr2JyYmYtOmTRg7diw+fPiAUqVKYcmSJShVqpRBbz9JhISEYOLEiXj37h1q1qyJ7t27K+qhWCDlxOrKlSvo168f7t69i5w5c2Lx4sWoXbu2YkZvJBEbGwtfX19MmzYN4eHhqFKlChYuXIhChQoZxH6QruGSunP5+Phg8eLFCA0NRYECBTBnzhzUrl3b4M/eUqdDBg0ahMOHD8PBwQGzZs2Cp6en3p+lfAuSePLkCUaPHo2DBw/CzMwM/fv3x9ixY+Ho6GgQO9Q/Sb2uOGnSJLx48QIVK1aEl5eXYpYxAv53QF20aBFmzJiB6OhoNGzYEAsWLFDEbEUqSZJw+/ZtjBgxAufOnYO1tTXGjh2LQYMGwcbGxmDaIV2OaCTx4cMHbNy4ET4+PggICIC9vT2GDBmCoUOHwsXFxWAa9GtSRyubN29OO2stVqwYli5dirJlyxr0tgMp2x8REQEfHx/Mnz8foaGhKFSoEGbNmoVatWop4qQiIiICkydPxuPHj1GqVCkMGzZMUe9jSb22OnjwYJw+fRq2traYPn06+vTpo4gRO/C/qcAFCxZg2bJliIyMRJkyZTB79myUL1/e4EZtWg2X+Ph4PHjwABs2bMCuXbvw/v17WFlZoVWrVhgxYgSKFClicA36V/Hx8Thz5gxmzpyJS5cuwczMDH369MH48eORIUMGg9+p4uLisG/fPkybNg2PHj2Cra0thg8fjsGDByti+wGkBcu9e/fw22+/YdSoUQY//fulmJgY+Pr6Yvr06fj06RNKly6NBQsWKOr1zLGxsdi9ezemTp2KZ8+eIUOGDJg8eTJ69+4NOzs7g+wLWguX4OBg1KxZEzdv3kR8fDwcHR3h6emJvn37onjx4jA2NjbIBv1SUFAQ6tSpgytXrkCtVqN06dKYNGkSqlWrZvBn6wDw4cMH1K9fHxcuXICRkRHq1auHCRMmoHjx4oo5qERFRWHy5Mm4c+cOChcujHHjxsHBwcHg+36qoKAgNGrUKG36Z+TIkRgyZAjs7e0V1QYNGzbEhQsXYGxsjKZNm2L8+PEGf1eo1sLF3t4eMTExyJs3L1q0aIGWLVsiZ86cMDIyMugG/VJqGxQpUgR9+/ZFs2bNYG1trajtj46ORokSJTBy5EjUrVsXZmZmitl+IGV+PSEhAUWKFMG4ceMUczdgKmtra8TExKBMmTKYNWuWIl92Zmdnh5iYGJQsWRJjxoxBzZo1YWpqavD9QGvh8vDhQ3Tp0gXOzs6wsrLCkydP8OTJE2193Q+Jjo5GUlKS1j7/8ePH8PT0RMaMGWFlZYUzZ85o7bt+lDbb4MmTJ2jfvj1cXFxgbGyM48ePa+V7foa2+0BQUFDash3Pnj3T2vf8jLi4OCQnJ2vls589e4Z27drByckJ4eHhOHTokFa+52douw88efIE7dq1g7OzMyRJwrFjx7T2XT8qJiZG422gIkmNfiKA8PBw3Lp1S9MfqxVZs2bVyuqzSm8DpW8/kDIlpquB8lcuLi7Ili2b6APiOKCxNtBKuAiCIAjKpqzJT0EQBCFdiHDRE5IkQcmDTJKKb4PQ0FAEBwcrtg1EH9CvNtCLcDl9+nTaa26V6OTJkzA2NsbSpUvlLkU2AQEBsLOzQ58+feQuRRbv379Hu3btsGXLFoO/y+ifREdHI1euXPDw8IAkSXKXk+6ioqKQK1cu1KhRQy/CBdQTvXv3ppWVFV+8eCF3Kenq8+fPzJ49Oz08PKhWq+UuR1ZLliwhAJ44cULuUtKVWq1mv3792KpVK8bGxspdjqxOnTpFAFy4cKHcpaS7nj170sbGhv7+/nKX8k30JlyioqKYM2dOVq5cWVEH2W7dutHGxoYBAQFylyI7tVrNatWqMXv27Pz8+bPc5aSbHTt20N3dnXfv3pW7FJ3Qp08fWlpa8vnz53KXkm6OHTtGlUrFZcuWyV3KN9ObcCHJs2fPEgAXLFggdynp4ujRowRAHx8fuUvRGQEBAbSxsWG3bt3kLiVdvH79mrVq1VLkmfo/iYqKYq5cuVipUiVFnGhGREQwe/bsrFmzJiVJkrucb6ZX4UKS/fr1o6WlJZ89eyZ3KVoVERHBrFmzskaNGnrVodKDj48PAfDo0aNyl6JVarWaffr0YevWrRkXFyd3OTol9URz/vz5cpeidV27dqWdnR0DAwPlLuW76F24REdHM3fu3KxYsSKTk5PlLkdrOnfuTFtbW73rUOlBkiTWqFGDWbNmZUREhNzlaM22bdtYtWpV3rt3T+5SdJKXlxctLCzo5+cndylac+TIEapUKvr6+spdynfTu3AhyfPnz1OlUnHu3Llyl6IVhw4dIgCuWLFC7lJ01qtXr2hra8vOnTvLXYpWvHr1ijVr1uTixYvlLkVnRUdHM0+ePCxfvrxBnmiGh4cza9asrF27tl7OXuhluJDkwIEDaWFhwSdPnshdikaFhYUxS5Ysetuh0tPKlSsJgIcOHZK7FI1Sq9Xs2bMn27VrJ6bD/sOFCxeoUqk4e/ZsuUvRuE6dOtHe3p6vX7+Wu5QforfhEhMTw7x587JcuXIGddbSoUMH2tvb882bN3KXovMkSWKdOnWYJUsWhoWFyV2OxmzevJlVq1blgwcP5C5FLwwaNIjm5uYGdaJ58OBBqlQqrl69Wu5SfpjehgtJXrp0iSqVirNmzZK7FI3Yv38/Aeh1h0pvb968ob29PTt06CB3KRoREBDAGjVqcOnSpXKXojdiY2OZN29elilThklJSXKX89NSZy/q16+v17MXeh0uJDlkyBCam5vz0aNHcpfyUz59+sTMmTOzXr16et2h5LBmzRoC4P79++Uu5ackJyezR48ebN++PePj4+UuR69cvnyZRkZGnDFjhtyl/DRPT086ODjw7du3cpfyU/Q+XGJjY5k/f36WLl1ar89a2rZtaxAdSg6SJLF+/frMnDkzP336JHc5P2zjxo308PDg48eP5S5FLw0dOpRmZmZ8+PCh3KX8sL1791KlUnHdunVyl/LT9D5cSPLq1as0MjLitGnT5C7lh+zZs4cAuH79erlL0Vvv3r2jg4MD27ZtK3cpP8Tf35/Vq1fn8uXL5S5Fb8XFxTF//vwsVaqUXp5ohoaGMnPmzGzUqJFBzF4YRLiQ5PDhw2lmZqZ3F0E/fvzIjBkzsmHDhgbRoeS0fv16AuCePXvkLuW7JCUlsVu3buzQoQMTEhLkLkevXbt2jUZGRpw6darcpXy3tm3b0snJie/fv5e7FI0wmHCJi4tjwYIFWbJkSSYmJspdzjdr1aoVHR0dDaZDyUmSJDZq1IgZM2bkx48f5S7nm61fv54eHh4GdbeTnEaMGEFTU1Pev39f7lK+2a5du6hSqbhx40a5S9EYgwkXkrx+/TqNjY05efJkuUv5Jjt37iQAbtq0Se5SDMaHDx/o5OTEVq1ayV3KN3nx4gWrV6/OlStXyl2KwYiPj2ehQoVYvHhxvTjRDAkJYcaMGfnHH38Y1OyFQYULSY4ePZqmpqY6v4JsSEgIXVxcDK5D6YJNmzYRAHfs2CF3Kf8qMTGRXbp0YceOHfXiIKhPbty4QWNjY06aNEnuUv5Ty5Yt6ezszKCgILlL0SiDC5f4+HgWLlyYxYoV0+kdtnnz5syQIYPBdShdIEkS//jjD7q4uDAkJETucv7RmjVr6OHhYdBrY8lp9OjRNDEx4Z07d+Qu5R9t376dKpWKW7ZskbsUjTO4cCHJW7du0djYmBMmTJC7lK/atm0bAXDr1q1yl2KwgoKCmCFDBjZv3lzuUr7q2bNnrFatmnhgVovi4+NZpEgRFi1aVCdvlAgODqaLiwubNWtmkLMXBhkuJDlu3DiamJjw9u3bcpfyJ6kHPUPtULokNcS3bdsmdyl/kpiYyE6dOrFz5846Pbo2BLdu3aKJiQnHjRsndyl/IkkSmzVrRhcXFwYHB8tdjlYYbLgkJCSwaNGiLFKkiM6ctejLdI0hadasmc5NP65cuZLVqlVT1JsU5TR+/HiamJjw1q1bcpeSZsuWLVSpVNy+fbvcpWiNwYYLSd69e5cmJiYcM2aM3KWQTFmQEAB37twpdymKoWs3Tjx9+pQeHh5cu3at3KUoRkJCAosVK8YiRYroxLI6Hz58YIYMGfTmjsYfZdDhQpITJ06ksbExb968KWsd79+/p6OjI1u2bClrHUqUesv35s2bZa0jMTGRHTp0YNeuXfXyCXJ9lnqiOXr0aFnrkCSJjRs3ZqZMmfTqWawfYfDhkpiYyOLFi7NQoUKynbXo68N9hkQXHlb19fVl9erV+fLlS9lqULJJkybR2NiYN27ckK2GjRs3UqVScffu3bLVkF4MPlxI8v79+zQ1NeXIkSNl+f4NGzYQgCI6lK6Se5mdx48f08PDQ6wfJ6PExESWKFGCBQsWlOVE8927d3RyctLb9e++lyLChSSnTp1KIyMjXrt2LV2/V98XVDQku3fvlmWB0ISEBLZv357dunUzqBfb6aMHDx7Q1NSUI0aMSNfvlSSJDRs25C+//MLQ0NB0/W65KCZckpKSWKpUKRYoUCDdXh1rKEvBG5LUVxu8e/cu3b7Tx8eHNWrUYEBAQLp9p/DPUk80r169mm7fuW7dOqpUKu7bty/dvlNuigkXknz48CHNzMw4bNiwdPm+1JdYKalD6brUl7Kl11v+Hj58SA8PD7F+nA5JPdHMnz9/upxovn37lg4ODvT09NT6d+kSRYULSc6YMYNGRka8fPmyVr8n9fW7SutQ+iD1ddJr1qzR6vfEx8ezXbt27Nmzp5gO0zGPHj2imZkZhw4dqtXvkSSJ9erVY5YsWRgWFqbV79I1iguXpKQkli1blnnz5mVsbKxWvkOSJNapU0eRHUpfeHp60s7Ojm/evNHadyxZsoQ1atRgYGCg1r5D+HEzZ86kSqXipUuXtPYdq1atokql4sGDB7X2HbpKceFCkk+ePKG5uTkHDRqklc9fuXIlAfDQoUNa+Xzh54WFhTFLliysXbu2VqbH7t+/z6pVq4r143RYcnIyy5YtSzc3N8bExGj881+/fk17e3t26tRJ45+tDxQZLiQ5e/ZsqlQqXrx4UaOf++rVK9ra2iq2Q+mTQ4cOEYDG36USFxfHNm3asHfv3lSr1Rr9bEGzUk80Bw4cqNHPlSSJtWvXZtasWRkeHq7Rz9YXig2X5ORkli9fnnny5NHYWYskSaxZs6aiO5S+6dSpE21tbfnq1SuNfeaiRYtYs2ZNvn79WmOfKWjPnDlzqFKpeOHCBY19pq+vL1UqFY8cOaKxz9Q3ig0XkvTz86OFhQX79++vkc9bvnw5AfDo0aMa+TxB+8LDw5k1a1bWqFFDI9Njd+/epbu7u0EvSGhokpOTWaFCBebJk4fR0dE//XmBgYG0tbVlt27dNFCd/lJ0uJDk/PnzCYDnzp37qc8JCAigjY2N4juUPjp69CgB0MfH56c+Jy4ujq1bt2bfvn3FdJie8fPzo6WlJb28vH7qcyRJYo0aNZg9e3Z+/vxZQ9XpJ8WHi1qtZqVKlZgrV64fPmtRq9WsVq2a6FB6rFu3brSxsfmpBx0XLFjAWrVq8e3bt5orTEg3qSeaZ8+e/eHPWLZsGVUqFY8fP67ByvST4sOFJJ8/f05LS0v27dv3h35/6dKlBMATJ05ouDIhvXz+/JnZs2dntWrVfmjUcfv2bbq7u4vXKegxtVrNypUrM1euXIyKivru3/f396eNjQ179uypher0jwiX/7dw4UIC4OnTp7/r916+fElra2vRoQzAiRMnCIBLliz5rt+LiYlhy5Yt6eXlJabD9Nzz589pZWXFPn36fNfvqdVqenh40NXVlZGRkVqqTr+IcPl/arWa7u7udHV1/eazli9/R3Qow9CzZ09aWVl917L4c+fOZe3atdN1vTJBexYtWkQAPHXq1Hf9jkql+q7fMXQiXL6QOgrp1avXN/38j452BN0VGRlJV1dXuru7f9Mo5ObNm3R3d+eePXu0X5yQLtRqNatWrcocOXJ800njixcvaG1t/d2jHUMnwuUvlixZ8rfrJ5Ik8ePHjwwICODHjx8pSdIPD58F3Xf69GkC4MKFC9P+3df6QHR0NFu0aMEBAwaI6TAD87Xp7q/1AbVazSpVqvzwdRpDpiJJCGkkSULNmjXx4sULXLhwAXv27MGiRYvw8uXLtJ/JlStX2s8+ePAANjY2cpUraEnfvn2xevVqXLx4ERcuXPhbH8idOzcKFSqEmJgYbNy4EZkzZ5axWkEbli1bht69e2P37t14/fr1V/vAb7/9hr179+LMmTNwd3eXsVrdI8LlKwIDA1GwYEEkJSVBrVYDAL7WTBYWFti7dy9q166d3iUKWhYdHY28efMiODgYkiRBpVJ9tQ+Ym5tj3759og8YIEmSULJkSdy7dw8k/7EPmJiY4ODBg6IP/IWR3AXoIj8/P8THxyM5ORlMmTr86s8lJiaifv36OHbsWDpXKGjbpUuX0oIF+PrJBSD6gCE7ceIE7t+/n/a3/6c+oFarRR/4CjFy+YuIiAhkzZoVsbGx/9iZvmRkZARLS0u8ffsWDg4O2i9Q0LrUPhAXF5cWLv9G9AHDI/rAzxMjl79Yt27dNwcLkDJ0jo2Nxfr167VcmZBeUvvAtxxUANEHDJHoAz9PjFy+QBJubm7w9/f/5nABAJVKhVy5cuH58+dQqVRarFDQNtEHBNEHNEOEyxdCQ0Ph4uLyU7+fIUMGDVYkpLd/6gOmAJIAWACI/4/fF31Av4njgGaIabEvREdH/9TvR0VFaagSQS5/7QM2AEYAuIaUneXfggUQfcAQiOOAZohw+cLPPq8innfRf6l/Q1sAowAEABgP4BKATN/w+7a2tlqrTdC+yMhInD59+qc+Q/SBFCZyF6BLMmTIgNy5c3/3XGuqkiVLokGDBmjQoAE8PDxgYWGhhSoFbcpgYoJ5jo7wDA+HFYAVAGYBePcNv5s7d244OTlpt0BB416+fIkDBw7g4MGDOH/+PJKSkmBmZobExMTv+pzUay6iD6QQI5cvqFQq9OvX74d+t1evXvj9999x+PBh1KtXDxkyZEDjxo2xcuVKfPjwQcOVChoXEQFMmgRVrlzoFx2NTQDyAOiPbwsWIOV21AsXLmitREEzkpOTcf78eQwdOhQFChRAnjx5MHz4cJiYmGDevHkICAjArFmzfuiivJeXl7iYnyp9VpnRH+Hh4bS2tqZKpSKA//zHyMiI1tbWDA8PJ5my/tDDhw85Y8YMVqpUiUZGRgTAkiVLcsKECbx586ZGXqcraEh4ODlhAungQFpakgMGMOLxY1pbW6f97f7rH5VKRXNzcxYpUoQAWLVqVZ45c0buLRO+EBYWxs2bN7N169Z0cHAgAGbKlImdO3fm7t27/7YuWOpx4Fv7wF+PA4JYuPKrDh48+M0dytjYmMeOHfvHz/r48SM3bNjAli1b0t7engCYJUsWduvWjfv27dPIO7uFHxAWRo4bR9rbk1ZW5KBB5Pv3af/30aNHaWxs/J8Hly/7gCRJ3Lt3L4sXL04ArFKlCk+fPi1OJmQgSRKfPHnC2bNns0qVKjQ2NiYAFi9enGPHjuW1a9f+c7HRb+0DKpXqP48DSiTC5SsmTpxIIyMjWlhYUKVS/W0Uk/rvrK2tv6tDJSYm8vTp0xw0aBDd3NwIgBYWFqxXrx6XLl3KV69eaXGrBJLkp0/k2LH/C5XBg8kPH776o0ePHk0bxX5PH5Akifv372eJEiUIgJUrV+bJkydFyGhZQkICT548yQEDBjB37txp+1eDBg3o4+PDN2/efPdn/lsf+PKf7du3a2GL9JsIl7+4c+cOTUxMOGbMGIaHh9Pb2zuto6b+kzt3bnp7ezMiIuKnvsvPz49z586lh4dH2plV0aJFOXr0aF65ckUs465JoaHk6NGknR1pbU0OHUoGBf3nr/1MH5AkiQcOHGCpUqUIgBUrVuTx48dFyGhQSEgI161bx2bNmtHW1pYA+Ouvv7JHjx48cOAAY2Jifvo7/q0PTJ48mY6OjmzZsqUGtsawiHD5QkJCAosWLcrffvuNCQkJaf9ekiSGhoYyICCAoaGhWjk4hIeHc+vWrWzXrh2dnJwIgC4uLuzYsSN37tzJz58/a/w7FeHjR3LkSNLWlrSxIYcPJ4ODv/tjfqYPSJLEQ4cOsUyZMgTA8uXLp02jCd9HkiTev3+f06ZNY/ny5dNGE2XKlOGkSZN4+/ZtrbXrP/WBLVu2iNHLV4hw+cK4ceNoYmLC27dvy1pHUlISL1y4wOHDh7NQoUIEQFNTU9asWZPe3t7f9QpexQoJIUeMSAkUG5uU/x4SImtJkiTxyJEjLFu2LAGwXLlyPHLkiAiZ/xAXF8cjR46wT58+zJEjBwHQ2tqaf/zxB1etWsUP/zCtmV4kSWLTpk3p7OzM4B84cTFUIlz+361bt2hsbMwJEybIXcrfvHz5kgsXLmStWrVoampKACxYsCCHDRvG8+fPMykpSe4SdUdwMDlsWEqg2NqSo0aljF50iCRJPHr0KMuXL08ALFu2LA8dOiRC5gvv37/nypUr+fvvv9PKyooAmCNHDvbt25dHjx5lfHy83CX+SXBwMJ2dndm0aVPxd/x/IlxIxsfHs0iRIixWrBgTExPlLudfRUZGcteuXezUqRMzZsxIAHRycmLbtm25ZcsWhoWFyV2iPIKCyCFDUq6n2NmRY8akXGfRYZIk8fjx46xYsSIBsHTp0jx48KAiD06SJPHWrVucOHFi2jUqIyMjVqxYkdOnT+fDhw91vl22b99OANy6davcpegEES4kR48eTVNTU969e1fuUr6LWq3m1atXOWbMGBYrVowAaGxszKpVq3LOnDl8+vSp3CVq34cPKXd8WVml3AE2dmzKHWF6RJIknjx5kpUqVSIAlipVivv379f5g+nPiomJ4f79+9mtWzdmyZKFAGhnZ8cWLVpw/fr1/KhjI85v0aJFCzo5Ock+VacLFB8u169fp7GxMSdPnix3KT/t9evXXLZsGevXr08LCwsCoJubGwcOHMhTp07p/Kjsu7x/Tw4cmPLgo709OX58yrMrekySJJ46dYpVqlQhAJYoUYL79u0zqJBJ7aP16tVL66N58uQxmD768eNHZsyYkb///rtB/d1+hKLDJS4ujgULFmTJkiX1vlP/VepZYffu3Q3mrJAk+e4dOWBASqg4OKQ8Xa/nofI1Z86cobu7e9qDf3v27NHLg9WXo+uiRYv+bXTt5+cnd4kat3v3bgLgxo0b5S5FVooOl+HDh9PMzIwPHjyQuxSt+q/57AcPHuj+gevtW9LLi7SwIB0dyYkTU5ZuMXBnz56lh4dH2jNQu3bt0vnnn1KvC3bs2DHtuqCjo2PadUElLJHSunVrOjo68v0Xqz4ojWLD5erVqzQyMuK0adPkLiXdpd6J07hx47Q7cVxdXXXzTpw3b8i+fVNCxcmJnDyZ/MmHV/XR+fPnWb16dQLgb7/9xp07d+pUyPj7+3PhwoWsWbOmuKORZGhoKDNlysSGDRvq/ombligyXGJjY5k/f36WLl1acZ3+r758hiB79uy68wzB69dknz6kuTmZIQM5ZQopHiTlhQsXWKNGDQJg4cKFuX37dllC5stnsQoWLPi3Z7FevHiR7jXpmr179xIA161bJ3cpslBkuAwZMoTm5uZ89OiR3KXoFDmffk7z6hXZqxdpZkY6O5PTppGRkdr9Tj106dIl1qpViwBYqFAhbt26lcnJyVr9TrGKxPdr37497e3t+fbtW7lLSXeKC5dLly5RpVJx1qxZcpei81LXbWrevPlX122KjY3V3JcFBpI9e6aEiosLOWOGCJVvcPnyZdapU4cAWKBAAW7ZskWjIfPl+ncmJiZi/bvvFBYWxl9++YV169ZV3PSYosIlJiaGbm5uLFeunNbP8gzN11actbS0/KkVZ0mSAQFk9+4poZIxIzlzJvmXd2sI/+3q1ausW7cuATB//vzctGnTD/Xxr63cbW5uLlbu/gmpr/BYvXq13KWkK0WFy8CBA2lhYaGMhwu16Mt3Zbi7u//QuzL48iXZtStpakpmykTOnk2Kd9v8tGvXrrF+/foEwHz58nHDhg3/eV0xNDT0b+8c+uWXX8Q7hzSoY8eOtLOz4+vXr+UuJd0oJlzOnz9PlUrFuXPnyl2Kwfn06RM3b97MNm3a0NHR8d/f8vfyJdmlC2liQmbOTM6dS2pgWXThz27cuMGGDRumPUi7fv36tJD58m2pFStWTHsZVqlSpdLeliqmuzQrPDycv/76K2vVqqWY6TEVScLAxcTEoGjRosicOTPOnTsHY2NjuUsyWMnJybh8+TIOHjyIAwcO4OnTpzAzM4NH2bJokJiIBjdvwjVjRmDoUKBHD8DKSu6SDdqtW7cwadIk7N+/H1myZEHBggXx4sULBAYGwsrKCjVr1kSDBg1Qv359/PLLL3KXa9COHj2KunXrwtfXF926dZO7HO2TO93Sg5eXFy0tLfns2TO5S1Gc5ydOcEHp0qyhUtH0/1+yVLhQIY4YMYIXL14U1760KCgoiKtXr2aTJk1oaWmZ9pIrOzs7DhgwgJHihol016VLF9ra2jIwMFDuUrTO4MPl7NmzBMAFCxbIXYqy+PmRnp6ksTH566/kwoX8HBTEHTt2sEOHDnR2diYAZsiQge3bt+e2bdt++s2eSidJEu/cucPJkyenvZhMpVKxfPnynDp1Ku/du8fbt2+zSZMmBMBcuXJx1apVBrf0kS6LiIhgtmzZWL16dYOfHjPocImKimLOnDlZuXJlMYecXp48Idu1SwmVrFnJRYvIuLi//VhycjIvX77MUaNGsUiRIgRAExMTVqtWjfPmzROjzG8UGxvLgwcPsmfPnsyaNSsB0NbWls2aNePatWsZ8g8vSLt37x6bNm1KAMyZMydXrFjxp7evCtpz/PhxAuCyZcvkLkWrDDpcevfuTSsrK/G0cHp4/Jhs04Y0MiKzZSOXLCG/YxmZwMBALlmyhHXq1KGZmVna3U6DBw/mmTNnxNn1F96+fcvly5ezQYMGadNduXLlYv/+/XnixInvCon79++zefPmVKlUzJEjB5cvXy5CJh306NGD1tbW9Pf3l7sUrTHYcDl16hQBcNGiRXKXYtgePSJbt04JlezZyWXLvitUviYqKop79+5lly5dmDlzZgKgg4MDW7VqxY0bN/KTnr2v5Wep1Wpev36d48aNY4kSJdIWHq1SpQpnzZrFx48f//QUy8OHD9myZUuqVCpmz56dPj4+ImS0KDIykjly5GDVqlUNdlbFIMNFCX842T14QLZsmRIqOXKQPj4/HSpfo1areePGDY4fP/5PB9bKlStz5syZGjmw6qKoqCju2bPnbwHbunVrbtq0SWsB++jRI7Zq1YoqlYrZsmXj0qVLdWshUwNy8uRJAuDixYvlLkUrDDJclDDklM39+2Tz5qRKRebMSfr6kul4hvv27Vv6+vqyYcOGf5oS8vLy4vHjx/X6bDswMJCLFy9mnTp1aG5unva0/ZAhQ3j27Nl0nRp8/Pgx27RpQyMjI2bNmpWLFy9m3FeunQk/x5Cn7g0uXI4dO6aIi2Xp7t49slmz/4XKypWkzNdBYmNjeejQIfbq1etPF7ObNm3KNWvWMDg4WNb6/ktycjIvXbrEkSNH/ummhurVq3P+/Pl8/vy53CXy6dOnbNeuHY2MjPjrr79y0aJFImQ0yJBvOjKocEm9za9GjRoGOVUiizt3yCZNUkIld25y1SrZQ+VrJEni3bt3OWXKFJYtW5YqlYoqlYrlypXjlClTePfuXZ3oExEREdy+fTs9PT3Tbsd2dnamp6cnt2/frrO3Y/v5+bF9+/Y0MjJilixZ6O3trdmFSxXMUB+XMKhw6dq1q2IeUNK627fJxo1TQiVPHnLNGp0MlX8SFBTENWvWsGnTprSxsSEAZsuWjb169eKhQ4fS9ez7+fPnnD9/PqtXr562snCRIkU4cuRIXrp0Sa8eJH327Bk7dOhAY2NjZs6cmfPnzxchowH9+vUzuAe9DSZcjhw5QgD09fWVuxT9dvMm+fvvKaHi5kauW0fq+QvV4uPjefz4cXp5eTFnzpwEQCsrKzZq1Ii+vr589+6dRr8vKSmJZ8+e5ZAhQ5gvXz4CoJmZGevUqcPFixczICBAo98nh+fPn7NTp05pITNv3jzGiDXiflh0dDRz587NihUr6tXJxr8xiHBR4qJwGnfjBtmwYUqo5MtHrl+v96HyNZIk8dGjR5w5cyYrVaqUtmhjyZIlOX78eN64ceOH5r4/ffrETZs2sXXr1nRwcEhbvLNLly7cs2fPnxfvNCAvXrxg586daWxszEyZMnHOnDliFeUfZGiL6xpEuChxOWuNuXaNrF8/JVTy5yc3biQN5MzpW4SGhnLjxo1s1arVn5ab79q1K/fu3fuPB0pJkvj48WPOmjWLVapUSXvtQIkSJThu3Dhev37d4C7Q/ht/f3927dqVJiYmdHFx4axZs0TI/ABDei2I3odL6ot4Vq1aJXcp+uXqVbJevZRQKVCA3LxZUaHyNYmJiTxz5gwHDRrEvHnzpr0oq27dulyyZAmfP3/OEydOsH///syVK1faC9MaNmzI5cuXK/JVtn8VEBDA7t27p4XMzJkzDXbUpg2G9EJDvQ4XJb9C9IddvkzWqZMSKoUKkVu2KD5U/omfnx8nTZrEAgUKUKVSpa0qbGtryz/++IP79u0T1xn+QWBgIHv06EFTU1M6Oztz+vTpYhXmb2Qor2LX63Bp37497e3txRnjt7h4kaxVKyVUChcmt20jFTRt860kSeK9e/c4depUli9fPi1USpQowRYtWrB+/fp0cnIiALq4uLBDhw7cuXMnP3/+LHfpOunVq1fs1asXzczM6OTkxKlTp4q2+gZDhgyhubk5Hz16JHcpP0xvw2Xv3r0EwHXr1sldim67cIGsWTMlVIoUIXfsEKHyF3FxcTx8+DB79+7N7NmzEwBtbGzYpEkTrl69mkFBQX/6+eTkZF68eJHDhw9noUKFCICmpqasUaMGFyxYwJcvX8q0Jbrr9evX7N27d1rITJkyRYTMv4iNjWX+/PlZunTp/3xNta7Sy3AJDQ1lpkyZ2KBBAzEd9k/OnSOrV08JlaJFyZ07Rah84f3791yxYgV///13WllZEQBdXV3Zr18/Hjt27LvW0/L39+eiRYtYq1attBWdCxQowKFDh/L8+fN6e3DQhjdv3rBv3740Nzeno6MjJ02apLMPjsrt6tWrNDIy4rRp0+Qu5YfoZbikvqtd088nGIQzZ0gPj5RQKV6c3L1bhApTprtu3rzJCRMmsFSpUmkLYFaqVIkzZszgw4cPNXKiEhkZyd27d7NTp07MmDEjAdDR0ZFt2rTh5s2bGRYWpoGt0X9v376ll5cXzc3N6eDgwAkTJjA8PFzusnTO8OHDaWZmxgcPHshdynfTu3DZtWsXAXDjxo1yl6I7JIk8fZqsWjUlVEqUIPfuTfn3ChYdHc19+/axW7duzJIlCwHQ3t6eLVu25IYNG/jx40etfr9area1a9c4duxYFitWjABobGxMd3d3zp49m0+fPlX8yPvdu3fs378/LSwsaG9vz/Hjx4uQ+UJcXBwLFizIkiVL6t07jfQqXEJCQuji4sLGjRsrfqckmRIeJ0+SVaqkhErJkuS+fYoOlVevXnHp0qWsV68eLSwsCIBubm4cNGgQT58+LesO+ubNG/r4+LB+/fppteXJk4cDBgzgyZMn9XpF55/1/v17Dhw4kJaWlrSzs+PYsWMV996ef3L9+nUaGxtz8uTJcpfyXfQqXFq0aMEMGTL87QKr4kgSeeIEWalSSqiULk0eOKDIUFGr1bxy5QpHjx7NokWLpo0OPDw8OHfuXPr5+cld4lfFxMTwwIED7N69e9qoys7Ojs2bN+e6deu0PqrSVR8+fODgwYNpaWlJW1tbjh49WoQMydGjR9PU1JT37t2Tu5Rvpjfhsn37dgLgli1b5C5FPpJEHjtGVqyYEiplypCHDikuVD5//sydO3eyY8eOdHFxIQA6OTmxXbt23Lp1q95Nq0iSxNu3b3PSpEksXbo0AVClUrFChQqcNm0aHzx4oLiRelBQEIcMGUIrKyva2tpy1KhRDA0Nlbss2cTHx7Nw4cIsVqyY3kyP6UW4BAcH09nZmU2bNlXcTkYyJTyOHiXLl08JlXLlyMOHFRUqwcHB9Pb2Zs2aNWlqakoALFSoEIcPH84LFy4Y1B1ZHz584KpVq9i4cWNaW1sTAHPkyME+ffrwxIkTcpeXroKDgzls2DBaW1vTxsaGI0aMUOyo7tatWzQ2NuaECRPkLuWbqEgSGqaFj9QqlUql8c/UeBtIUsp/qlQp/2iYpttA09vPlBMhAP+rVZM160Uf0DJd7wPapg99IHU/UKlUWqlXk59porFP+kJgYCC2bNkCExOtfLzGkEShQoVQv359jf+hwgID4b9lC6DjbQASDoUKIY+G20D0AdEGSt9+QNltoJUtfvPmDTJnzoyaNWtq4+N/WmBgIC5fvowqVarg8OHDqF+/vsa/I+bNG5hnzoxsOtoGCAgArl5FbJUqeH3kCPJouA30qQ8cOXJEK31A19vg5cuXuHXrFsqVK4ejR49qvA2Uvv2A7rfBixcvcOfOHZQpUwbHjx/XaBtoLU6dnZ2RLVs2bX38DyOJGTNmwMfHB+PGjYORkZHWvsvS2RmOOtgGIIFZs4Bly2A6bhygpTbQ1T4gSRJmzpwJHx8fjB07Vqt9QFfbgCTmzJmDxYsXY+LEiVprA6VvP6DbbTBv3jwsWrRIK22gvRbVUQEBAdiyZQscHR3x+++/y12OPF69ArZsARwcgEaN5K4m3b18+RKbNm2Ck5MTGjduLHc5svj48SO2b98OW1tb1KtXT+5y0p3Stx8AwsPDsXPnTlhbW6N27doa/3xFhQtJLF68GOHh4ejQoYNOnk1oHQn4+gJhYUDbtoDC2kCSJHh7e+Pz58/o3LkzsmbNKndJ6Y4kdu/ejaCgINSrVw/Zs2eXu6R0RRK7du1CUFAQ6tevjxw5cshdUrojiSNHjuD9+/eoUaMGXF1dNf4digqX169fY/369XB0dESfPn20creFzgsKAtasAezsgD59tHLnmS578eIFNm3aBGdnZ/Tu3VuRfSAhIQG+vr4wMTFBr169tDolpIvi4+Ph6+sLU1NT9OrVS5F9IDk5GatWrYJKpUKXLl200gcU06tIYunSpfj06RPatGmDnDlzyl1S+iNTgiU4GGjSBMiTR+6K0pUkSViwYAE+f/6MLl26KHLkShKXLl3CgwcPUKJECZQpU0buktIVSVy8eDFt+0uXLi13SbJ4/Pgxrl69ijx58qBKlSpa+Q7FhMu7d++wZs0a2Nvbo3///oo8W0FYWMqUmJUV0L+/1i7k66rnz59j8+bNcHFxUeyoRZIkLFmyBGq1Gj169ICZmZncJaWr1O2XJAk9e/ZU3PYDKQG7bt06xMfHo23btrC2ttbK9yji6EISy5Ytw8ePH9GqVSvkzp1b7pLSHwls3gy8fg3UrQsULix3RelKkiTMnTsXkZGR6NatmyKvtQApAXv8+HFkzZoVjRs3VlzA+vn54eTJk8iWLRt+//13xW0/AISFhWHHjh2wtbVFmzZttNYGigiXDx8+YNWqVbC1tcWAAQMUN8cMAIiKApYuBczNgYEDFTdqefr0KbZt24ZMmTIpdp6dJFatWoWYmBi0a9cOjo6OcpeUrkhi5cqViImJgaenJxwcHOQuKd2RxMGDB/H+/XvUrFlTq5cHDP4IQxLLly9HcHAwWrRogbx588pdUvojgT17gGfPAA8PoHRpRV3IlyQJc+bMQVRUFHr06IEsWbLIXZIsQkNDsWnTJtjZ2aFz586KC9iQkBBs2bIF9vb26NSpk+K2HwCSkpKwYsUKGBkZoVu3blptA4MPlw8fPsDX1xe2trYYNGiQMkctcXGAtzdgbAwMGqT7S9Jo2IMHD7Bjxw5kyZIFPXv2VORBhSS2b9+ODx8+oH79+siVK5fcJaUrkti2bRuCgoLQsGFDrdx6qw9u376NmzdvomDBgqhcubIIlx+VOmoJCgpC8+bNkT9/frlLSn8kcPQocP8+UK4cULmyokYtarUaM2fORExMDHr37o1MmTLJXZIsYmNj4ePjA1NTU0Xehh8bG4vly5fDzMwMffr0UeRJpiRJ8PX1RWJiIjp37gxLS0utfp9Bt/CXo5bBgwcrskMhMRGYNy/lvw8aBCjo7hiSuH37Nvbt24fs2bNrfRpAV5HEiRMn8PjxY5QvXx6lS5dWVDuQxLFjx/D06VNUrFgRJUuWlLskWbx9+xb79u2Di4sLWrRoofU+YLBHW5Lw8fERo5YzZ4Dr14FixYDatRU3apk6dSri4uLQv39/ODs7y12SLJKTk7FgwQIAQP/+/WFqaipvQeksKSkJ3t7eAAAvLy+dX6FYG1JvPw4PD0fz5s2ROXNmrX+nwYbLu3fvsHz5ctja2mLIkCHKHLUkJwNz5wJqdcodYhYWcleUblIfljt69Cjy5MmDjh07KupsPRVJXL9+HVeuXEGBAgVQu3ZtRbXDl9tfsGBB1KxZU1HbnyoiIgJr1qyBlZUVevTokS5tYJBHXJJYtGgRQkJC0Lp1a+TLl0/uktIfCVy6BJw/DxQoAPz+u6JGLYmJiZgyZQqSkpIwbNgwRd52CvxvVYLExET07t0bVlZWcpeUrlLXkktKSlLk9gMpx8M9e/bg1atXqFGjBgoWLJgu32uQ4RIYGIiVK1fCwcFBuaMWtRqYPTtl9DJgAKClp3B1Ueoc+/nz51GkSBG0atVKkWerQMoyH4cPH0a2bNnQsmVLxbXDkydPcOTIEWTLli1drjPoori4OCxevBjGxsbw8vJKt+OhwR11U59pCAsLQ4cOHZBHYetnAUgZtVy5Apw6Bbi5Ac2bK2rUEhsbiylTpoAkRo8erbXlLXSdJElYuHAhYmNj0a1bNzg5OcldUroiiSVLliAmJgadO3dW3PYDKW1w+PBh3L9/H+XKlUPFihXTLWANLlweP36MDRs2wMXFBQMHDlTkmQqSk4GZM4GkpJRRi52d3BWlm9TnOW7fvo0KFSqgYcOGyuwDAPz9/bFjxw64uLgo8qHJV69eYdu2bciQIQO6dOmiuO0HUlaAnjNnDlQqFQYPHpyua6kZVLgkJydj8uTJiIqKQp8+fRT3ngoAKaOWixeBkyeBvHmB1q0VNWoJDw/H9OnTYWJigvHjx8Pc3FzukmSRet3x8+fP6NChg+JWJUh9xi08PBxt2rRR5FpyqUu93Lx5E6VKlUr3mzkMJlxI4vLly9i3bx9cXV0Vu+otkpKAKVNS/nPIEMWNWpYvX44XL16gXr16qFKlijL7AFLO2jdu3AhHR0dF7gtBQUFYs2YN7OzsFPnQKADExMRg+vTpUKlUGDlyZLqfaBlMuCQkJGDs2LFITEzEyJEjlflMQ+rT+BcuAL/9BrRsqahRy5s3b7Bw4ULY2Nhg3LhxMDY2lrskWZDEwoULERYWhvbt2ytuqROSWLFiBYKDg9G0aVO4ubnJXVK6I4mNGzfi3r17qFKliiy3oBtEuKTOs1+8eBGlSpVC27ZtFXmmguhoYMKElJAZPVpRd4hJkoRZs2YhODgYnp6e+O2335TZB5Byt+S6devg6OioyHcXhYSEYPny5bC2tlbseoLBwcGYMWMGzM3NMXHiRFneW2MQrR4SEoIJEybAxMQEU6ZMUeS97CCBtWuBe/cAd3egYUPFjFpI4s6dO1i3bh0yZcqEYcOGKfKAAqSE7Pz589PullTaG1dTRy3v379HkyZN0u2ZDl0iSRJmz56N169fo3nz5ihfvrwsJxh6vwdKkoTp06cjICAATZs2RbVq1RR3pgYAePUKmD495Sn8yZMVtYZYUlISxo0bh9jYWAwcOFCRry9O5efnh3Xr1sHZ2RkDBgxQ3L7w4cMHLF26FNbW1hg6dKjitp8kbty4AV9fX7i4uGDcuHGynWjpdbikXsRfsWIFMmbMiMmTJyty3SAkJwNjxwJBQUCnTkDZsooatezbtw8nTpxAwYIF0b17d8UdUFKlrqUWGRmJnj17Ku5uydRrTR8+fEDLli1RqFAhxfWF2NhYDBkyBLGxsRg+fDhy5colWxvo9ZE4KioKAwcORHx8PGbMmKG4d1QA+N+LwLZvB3LmTLnWoqApoU+fPmHs2LFQqVSYMmUK7O3t5S5JFqknWrt27UL27NnRt29fRR1YSeLZs2fw9fWFo6MjRowYobipUZJYvHgxLl++jAoVKqTbGmL/RG9bP/UC7q1bt+Dh4YGuXbsqamcCkBIsr16l3HKsUqUs95IOq53qitQ+8OzZMzRs2BD16tVTXh/4f/Hx8Rg9ejQSEhIwYsQIZMyYUe6S0pVarcb48eMRHh6OHj16KG5lDpK4desWZsyYAVtbW8ybN0/2a896GS4kcfbsWcyfPx9OTk5YsGABLBS04m+a+Higf3/gzRugQwegUSNFTYddvnwZy5Ytg7OzM6ZNm6bMKVGktMWmTZtw6dIllCpVCp6enooKWZI4fvw49uzZg5w5cypyZY7IyEj069cPkZGRGDp0KEqVKiV7G+jd3kgS79+/R69evZCQkIA5c+Yocm4VkpQyUjl0CChaFJg6VVGvLw4LC0O/fv0QFxeHadOmwc3NTXl9ACn7w5s3bzBhwgSYmZlhxowZsp+xprdPnz5hyJAhUKvVmDx5MlxcXOQuKV2p1WpMmTIF165dQ7Vq1XTmRg69G7nEx8ejb9++ePbsGVq0aKHMNYNIYPduYMYMwMEB8PUFMmSQu6p0k5SUhFGjRuHevXuoU6eOYt8wCaQseTRixAi8e/cOHTp0gLu7u6LaIjk5GaNHj8aTJ0/QqFEjNG/eXFHbTxL79+/H4sWLkSlTJixevFhnTi70KlxS74bZt28fChcujPnz58vycJCsSODaNaB375TRy/z5QKlSipkOkyQJy5Ytw5o1a5A9e3YsXLhQ0euHbd68GTt27ECePHkwYcIERa1KQBLr16/HmjVrkC1bNsydO1dRb9kkiadPn6Jfv36QJAlz585Fvnz5dCZc9SZcJEnC6tWrMXv2bDg7O2Pt2rWKu2gJEnj2DGjXDggLA4YPB9q0UVSwbN26FaNGjYKlpSV8fX2RM2dOndmZ0hNJ3L9/H8OGDYOJiQm8vb2RKVMmuctKNyRx8uRJDBo0CCYmJli6dClcXV0V0xdI4tOnT+jcuTM+fPiAXr166dz7avQiXEhi165dGDhwIExNTeHr64sSJUroVENqHQkEBgItWgABAUDHjsDIkYBCzlTVajXWr1+Pnj17pr1dsUaNGsrqA/+PJEJCQtCpUyd8/PgRAwYMUNTri1NfYd2+fXvExMRg0qRJirtTMDY2Fr169cK1a9dQvXp1nXzGT+fDRZIk7Ny5E127dkVycjLmzp2LRo0aKaojgQT8/YFmzYAHD4A//kiZDlPAHXIkERMTg8mTJ6N3795Qq9WYN28ePD09FfccA5DSHp8/f0bnzp1x584d1K1bF2PGjFHMdJgkSTh8+DCaNWuG0NBQDB48GP3791dUX0hdiWL37t0oXLgwVq1aBRsbG7nL+hud/oskJSVh6dKl6NSpExISEjBz5kx07dpVUR0JJHDrVspaYXfupNxuvGIFoIOdSdNI4vHjx2jatCmmTJkCGxsbrF69Gt27d1fMwfRLJBEWFoZOnTrh8OHDKFmyJFauXKkzF3C1iSTi4uIwd+5ctGrVCuHh4RgxYgQmTZqkmOssqScWffr0wapVq5AzZ05s2bIFWbNm1cmTbd0aR/0/kggODsaYMWOwbt06WFhYYNGiRejcubNyDiokkJgIbNqUMv316VPK9ZUlS1Le0aKDnUlTSCIyMhK+vr6YPXs2Pn36hJIlS2Lp0qUoWbKkTu5I2pZ68bZ79+64ePEiihYtiu3btyNz5swG3x6SJOHhw4cYMWIEjh07BltbW3h7e6Nbt246NxWkLV9evD9z5gzy5MmDbdu2oWDBgjr799fqXyYpKSntj/8tDZCazLt378aMGTPw/PlzuLq6YunSpahdu7Z+jlgk6X9B8C2dgEx50dfNmymvKj5yBDA1TQmYkSMBPTpLJYnAwEA4ODjA1tYWRkZG/9oPUs9Ojx49imnTpuHOnTuwsbHBsGHDMHToUDg6OursjvRPJEnCnj17kDFjRuTOnRtOTk5pZ9rfuk+EhoZi/fr1mD17NkJCQlC1alWsXbsW2bNn1/n2IIljx44hU6ZMcHV1/aZ+kPp7kiTh5cuXWL58OdasWYPw8HAUK1YMixYtStd3wf8skjh37hwyZsyIX3/9FTY2NlCpVN/UBkDKqu9r167FggULEBwcjPLly2PNmjU6/2yX1sIlMTERLVu2hImJCQoVKoSCBQsiZ86cyJgxI2xsbGBsbAyVSgVJkhAREYEXL17g5MmT2LNnD168eAFTU1O0atUK06ZN09+7QJKSgD59Uq6N5MsHuLkBWbIAjo6ApeX/wkaSUt7F8uYNcPUqsH9/yu3GCQlAwYIpz7PUqaN3F+/j4+PRoEEDxMTEoECBAihZsiSKFSuGvHnzImPGjDAzM4ORkREkScLbt29x5swZbNq0CXfu3AGAtAuVpUuX1s8TCwDR0dEYPnw4QkJC4OTkhFy5cqFAgQIoUKAA8uXLh5w5cyJDhgywtLSEsbExSCIhIQFhYWF4+vQpTp48iUOHDuHVq1ewsrLCoEGDMGbMGNjb2+vFPhEdHY2+ffvi48ePyJQpEwoUKIDChQsjf/78cHNzQ7Zs2WBvbw8TExOQRHx8PIKCgnDnzh0cOHAAZ86cQUREBJydnTF27FgMGDBA704yYmJi4OXlhU+fPuGXX35JawM3NzfkyZMHv/76a1obACkvPvz06ROePHmC48eP4/Dhw3j37l3a+2lGjx4NBwcHnW8DrYVLVFQUrl+/jg8fPmDHjh0AAFNTU1hZWcHa2homJiZp4fL582fExMRArVbD2toatWrVwsCBA+Hh4ZH2c3opKiplUcmQkJT/bWQEmJunjD6srP4XFmp1ys/GxKQEkokJkDcv0KVLyrIujo56OQ0WGxsLFxcXfPz4ESdPnsTRo0ehUqlgbm4OW1tbmJmZwdjYGGq1GmFhYYiLi4OpqSlKlSqFQYMGoUGDBjA3N9ffvz9SRiddunTBtWvX4Ofnh7t37+LatWsgmdYWVlZWsLS0hKmpKSRJQlxcHGJiYhAXFweSsLOzQ5MmTTBkyBCULl1ar6aGSaJZs2a4fv06Xrx4gVOnTuHYsWMAAGNj47Tjgbm5edq2R0VFISEhAUZGRsiSJQs6deqEXr16IU+ePHrZF9RqNerVq4ebN28iICAAR44cwcGDBwH8vQ1SAzYqKgrx8fEgCUdHR7Rs2RIDBw5EyZIl9eZES2vh4uDggLNnz8Lf3x+PHz/G48eP4e/vjw8fPiAyMhJJSUkgCSMjI2TLlg25c+dGpUqVULt2bRQoUEC/QyWVrS2wd2/Ksyl+fin/+fZtyvWTmJiUaypASuhkzgxkywaULAlUrw6ULp3y+3rcBhkyZMCxY8fw6dMnvHjxAnfv3sXdu3fx9OlTBAcHIzExEUlJSTAyMkLhwoVRvnx5/P777yhXrhwsLCz0/+8PwNbWFhMnToQkSYiKisKbN2/w4sUL+Pn54cmTJ3j58iU+fvyI2NhYxMfHQ6VSwdbWFq6ursibNy8qVaqEatWqIVeuXGmjfX1iZ2eHefPmITk5GZ8+fcLLly/h5+eHp0+fws/PD4GBgYiIiEgLEwcHB+TPnx9FihRBjRo1UKlSJbi4uOjddn/J3t4eS5cuRWJiIj5+/IgXL17g2bNnePbsGZ4/f45Xr17h8+fPSPz/44G1tTVy5MiB/Pnzp/39XV1dv2k6UZdoLVzu3LmTNszLnTs3cufODUmSkJiYiISEBKjV6rRwsbS0TDtDffXqFV69eqWtsv4kOjoaSUlJWvv80Pv3oTIzSxl5lCuX8p4VtTpluishIeX6CpASIJaWKaMaIyMgNhY4d05rdX0pITo6ZbSkBbdu3frTzuDq6gpXV1ckJycjPj4eycnJkCQJKpUK1tbWMDMzQ3R0NE6ePKmVer5G233g5s2bfzsgpE4VFypUCMnJyUhMTERiYiLUajVUKhXMzMxgbm6edoLl5+cHPz8/rdWozTb42va7uLjAxcUFlSpVSjseJCcn/23bAeDatWtaqetL2u4Df90PAOCXX37BL7/8gipVqvypDQCktUHqtbnUk3Nt0kYbqJh61UiDwsPDcevWLU1/rFZkzZpVK0smxISH4+OtW9B442qYCoBV1qxw0XAbiD4g2kDp2w8ouw20Ei6CIAiCsunHlSFBEARBryjjCSRD8OUAU48u6mlK6gBbny5oCoKm6dN+oBcjlwULFkClUmHkyJFavfCm0+7cSbl1+f+fAVGSjx8/on79+jAyMkp7BkaJGjduDDs7O2zdulXuUmRz+/ZtqFQq3L59W+5S0t2dO3eQN29eZMmSBXFxcXKX85/0Ily8vLwwa9YszJ49G1WrVsWbN2/kLklIJ+fPn0exYsVw8+ZNHD16FMWLF5e7JNls2LABDRs2ROvWrdGjRw+9OMAIP48kli5dinLlysHOzg4XLlyApaWl3GX9J70IFyMjIwwdOhQXLlzAmzdvUKxYsbSHkATDlPrqVg8PD7i5ueHu3buoXbu23GXJytbWFhs3bsSKFSuwfv16lC1bFk+fPpW7LEGLPn/+jBYtWqBPnz7o3r07Ll++jDx58shd1jfRi3BJVb58edy9exeVKlVCw4YNMXjw4LQHjwTDERwcjDp16mDcuHEYM2YMTp48iSxZsshdlk5QqVTo2rUrrl+/jqSkJJQqVQobNmyQuyxBC27cuIHixYvjxIkT2LlzJxYtWqRXb13Vq3ABACcnJ+zduxfz58/HokWLULlyZQQGBspdlqAhp0+fRtGiRfHgwQOcOHECEydOVMzKt9+jSJEiuHnzJpo1awZPT0907twZMTExcpclaABJeHt7o2LFinB2dsadO3fQtGlTucv6bnoXLkDK2duAAQNw6dIlhISEoHjx4tizZ4/cZQk/Qa1WY/z48ahRowYKFy6Mu3fvonr16nKXpdOsra2xdu1arF27Ftu2bUOZMmXw6NEjucsSfkJYWBj++OMPDBgwAH379sXFixeRM2dOucv6IXoZLqlKly6NO3fuoFq1amjSpAm8vLyQkJAgd1nCd3r//j1q1KiBKVOmYNKkSTh27BgyZ84sd1l6o0OHDrhx4waMjIxQunRprF69GuLZaP1z9epVFC9eHOfPn8e+ffswb948mJmZyV3WD9PrcAFSFsjcuXMnFi9ejOXLl6NixYp4+fKl3GUJ3+j48eMoVqwYnj17htOnTyvqlb2aVLBgQVy7dg1t27ZFly5d4OnpiejoaLnLEr6BJEmYM2cOKleujF9//RV3795Fo0aN5C7rp+l9uAAp02R9+vTBlStXEBERgRIlSqQt8y/opuTkZIwaNQq1a9dGyZIlcffuXbi7u8tdll6zsrLCihUrsGnTJuzduxclS5bE/fv35S5L+BehoaFo1KgRhg4dikGDBuHcuXPInj273GVphEGES6oSJUrg9u3bqFu3Lv6vvTuPqjH/4wD+fkq4sjTZxzo1HIeD59ZtUVGyFFkyKCSclCWnmKYRBtmnCaeYhpMlR2OZJmpkSiEylfbuY4xl7EZ2UxGKuM/vD1PHz9Jk3Hu/d/m8znGc0+3e5311Pt7d773P9/Hw8IC/vz+qqqpYxyJvKCkpwcCBAxEeHo6wsDAkJyejdevWrGPpjEmTJqGoqAgSiQTW1taIjo6mZTINlJWVBalUitzcXCQnJ+O7776r3QlZF+hUuQCvrh+xd+9eREdHIyYmBra2trhw4QLrWOQfKSkp4Hke165dw4kTJxASEqI1Fz/SJt27d0dubi58fHwwa9YsTJw4EY8ePWIdi+DVMti3334LJycnfPbZZxAEAcOHD2cdS+l0cqo5jsOMGTOQn5+PyspKWFpaYs+ePaxj6bXq6mrMnz8fbm5utecr2dvbs46l0xo3boxNmzYhLi4OKSkpsLS01MttUzTJvXv3MGzYMHzzzTdYsGABjh07ho4dO7KOpRI6WS41+vTpg6KiIri7u8PLywt+fn54+vQp61h65/r16xgwYAAiIiKwfv16JCUloWXLlqxj6Q0PDw/I5XK0aNEC/fr1Q1RUFC2TMZCRkQGe5yEIAtLS0rBq1SqdPodLp8sFAJo2bYrY2Fhs374du3fvho2NDc6dO8c6lt44cOAApFIpbt++jaysLAQFBWnFjq66xtzcHNnZ2Zg5cyYCAgIwfvx4lJeXs46lF16+fIkVK1Zg0KBB6NGjBwRBwJAhQ1jHUjmdLxfg1TKZj48PCgoKoFAoIJPJsHPnTtaxdNrz588xb948uLu7w9HREXK5HDY2Nqxj6bVGjRph48aNSEhIQHp6OqRSKfLz81nH0ml37tzB0KFDsWzZMixduhRHjhxB+/btWcdSC70olxq9evVCfn4+PD09MW3aNEydOpW2zFCBK1euwN7eHps2bcKGDRuQkJCATz75hHUs8o8xY8ZALpejTZs2cHBwQEREBC2TqcDRo0fRt29fnD17Funp6QgNDdWrc7j0qlyAV1tmxMTEIDY2Fvv374dMJsPp06dZx9IZ+/btg1QqRWlpKU6ePInAwEBaBtNAXbt2RWZmJgIDAxEUFAR3d3eUlpayjqUTXrx4gSVLlmDo0KHo27cvBEHAwIEDWcdSO70rlxre3t4oLCyEkZERrK2tsW3bNvrt7SNUVVVhzpw5GD9+PFxcXFBcXAyZTMY6FqlDw4YNsW7dOiQlJSErKws8zyMnJ4d1LK128+ZNDBo0CGvWrMGqVauQmpqKtm3bso7FhN6WCwD06NEDeXl5mDJlCvz8/DB58mRUVFSwjqV1Ll68CDs7O2zfvr32o68tWrRgHYvU08iRIyGXy9GpUyf0798f4eHhUCgUrGNpndTUVPA8j8uXLyMjIwOLFi3S63O49PeZ/0MikSA6Ohp79+5FUlJS7VYkpH5++uknWFhY4PHjx8jNzcXs2bNpGUwLde7cGRkZGQgODkZISAhGjBiBBw8esI6lFaqrq7FgwQIMGzYMVlZWEAQB/fv3Zx2LOb0vlxoTJkxAcXExjI2NYWtri82bN9MyWR0qKysxc+ZMTJw4EaNGjUJRURF4nmcdi3wEIyMjhIWF4dChQygoKADP88jMzGQdS6PduHEDTk5OWLduHcLDw/Hrr7+iVatWrGNpBCqX13Tr1g05OTnw9fWFv78/PD098fDhQ9axNM758+dhY2OD2NhYbN26Fbt27UKzZs1YxyJK4urqCkEQYG5uDicnJ6xevZqWyd7h4MGD4HkeN27cQGZmJr7++mu9XgZ7E/1LvKFx48aIiopCfHw80tLSYGFhgcLCQtaxNMaPP/4ImUyG6upq5Ofnw9fXl5bBdFCHDh2Qnp6ORYsWYcmSJXB1dcXdu3dZx9IIz58/x1dffYVRo0bBwcEBgiCgX79+rGNpHCqX9xg3bhzkcjlMTU1hZ2eHjRs36vUy2ZMnT+Dj44MpU6Zg3LhxKCwsRO/evVnHIirUoEEDrFy5EocPH8bvv/8Onudx/Phx1rGYunbtGvr374/vv/8eERER+OWXX2Bqaso6lkaicqmDmZkZsrOzMWfOHMydOxdjx45FWVkZ61hqd+bMGVhbWyMuLq72srrGxsasYxE1GTx4MARBQM+ePTF48GAsX74cL1++ZB1L7RITEyGVSnHv3j1kZ2dj3rx59Kq9DlQu/6Jhw4a1v6EcP34cUqkUeXl5rGOphSiKiImJgZWVFQwMDFBQUICpU6eyjkUYaNeuHQ4fPozQ0FCsWLECQ4YMwe3bt1nHUotnz54hMDAQX3zxBZydnSGXy2FlZcU6lsajcqmn0aNHQxAEtG/fHg4ODli/fr1OL5M9fvwY3t7emD59Ory8vJCXl4eePXuyjkUYMjQ0xNKlS5Geno7z58+D53kcOXKEdSyVunz5Muzt7REdHY2oqCjs27cPJiYmrGNpBSqXD9ClSxf89ttv+PLLLxEcHIxRo0bh77//Zh1L6U6dOgVLS0scOHAAu3fvxtatW9GkSRPWsYiGcHJygiAI4HkeLi4uWLx4MV68eME6ltL9/PPPkEqlKC8vR05ODubMmUPLYB+AyuUDGRkZ1X6ePScnBzzPIzs7m3UspRBFEdHR0bCxsYFEIkFRUREmTZrEOhbRQG3atMGhQ4ewevVqhIWFwdnZGSUlJaxjKUVVVRVmz54NT09PDB8+HMXFxbCwsGAdS+tQufxHbm5uEAQBXbt2haOjI8LCwrT6XIBHjx5h4sSJmDVrFnx8fJCbm4vu3buzjkU0mIGBARYuXIiMjAxcuXIFPM8jJSWFdayPcuHCBdja2mLHjh21O3c0b96cdSytROXyETp27Ijjx49j/vz5WLhwIdzc3HD//n3WsT5YzW9mKSkpiIuLw6ZNm9C4cWPWsYiWqDnXw9bWFm5ubpg/fz6qq6tZx/pgu3fvhoWFBSorK5Gfn48ZM2bQMthHoHL5SA0aNMCaNWuQmppauwXKiRMnWMeqF1EUERUVhX79+sHExARyuRweHh6sYxEt1KpVKyQlJWHt2rWIiIiAo6Mj/vrrL9ax6uXp06fw9fXF5MmTMWbMGBQVFaFPnz6sY2k9KhclcXFxgSAI6N69O5ydnbFy5UqNPhegvLwc48aNQ0BAAGbOnIns7GyYm5uzjkW0mIGBAYKDg5GZmYmbN2+C53kkJSWxjlWnc+fOwcbGBnv27MH27dsRGxuLpk2bso6lE6hclOjTTz/F0aNHsXjxYoSGhsLFxQV37txhHest+fn5kEqlOHbsGBISErBx40Y0atSIdSyiI2xtbSGXyzFgwACMHj0aQUFBeP78OetYb9m5cydkMhkUCgUKCgrg4+NDy2BKROWiZIaGhli+fDmOHj2KP/74AzzPIz09nXUsAK+WwSIiIuDg4IA2bdpALpdjzJgxrGMRHWRqaorExERERkYiKioKDg4OuHr1KutYAF5tZTR16lRMmzYNnp6eyM/PR69evVjH0jlULiri7OyMU6dOoXfv3hgyZAhCQ0OZLpOVlpbC3d0dQUFBCAwMRGZmJrp27cosD9F9HMdh7ty5yM7OxoMHDyCVSpGQkMA00+nTpyGTybB//37ExsYiJiaGtjJSESoXFWrbti1SU1OxYsUKrFq1CoMGDcKtW7fUnuPkyZPgeR5ZWVlISkrCunXr0LBhQ7XnIPrJysoKxcXFGDx4MMaOHYuAgABUVVWpNYMoiti2bRusra1hZGSEwsJCeHt7qzWDvqFyUTFDQ0MsXrwYx44dw8WLF9G3b1+kpaWp5dgKhQLh4eEYMGAAOnXqBLlcjpEjR6rl2IS8zsTEBPHx8fjhhx+wZcsW2NnZ4dKlS2o5dkVFBby8vODn54cpU6YgLy8PPXr0UMux9RmVi5o4OjpCEATIZDK4urpi4cKFKt0y4/79+xgxYgRCQkIQHByMjIwMdO7cWWXHI+TfcBwHf39/5ObmoqKiAhYWFoiLi1PpMQVBgKWlJQ4ePIi9e/ciOjoaEolEpcckr1C5qFHr1q2RnJyMsLAwrF27Fk5OTrhx44bSj5OZmQme51FQUIBDhw4hLCwMRkZGSj8OIf+FVCpFUVER3NzcMGHCBMyaNQuVlZVKPYYoiti8eTNsbW1hbGyM4uJiTJgwQanHIHWjclEzAwMDhISE4MSJE7h+/Tp4nkdycrJSHluhUGD16tVwcnLC559/DkEQ4OrqqpTHJkSZmjdvjj179mDLli3YuXMnbG1t8eeffyrlsR8+fAhPT0/4+/vD19cXOTk56Natm1Iem9QflQsj9vb2EAQBdnZ2GDFiBIKDg9+7ZYYoiigrK4MIvPr7HVv93717F66urliyZAkWLVqE9PR0dOjQQcXPgpD/juM4+Pn5IS8vD8+ePYOlpSV27dr13u+vmQPg/XNQWFgICwsLpKWlIT4+HlFRUbSVESsiYUqhUIjr168XGzRoINrY2IhXr16tva2srEyMjIwUzc3NRSkgvgREKSCam5uLkZGRYllZmSiKopieni62a9dObNu2rXjkyBE2T4SQj1BRUSF6e3uLAEQfHx/xyZMntbe9PgcAav+8PgcKhULcsGGDaGRkJMpkMvHy5csMnw0RRVGkctEQubm5YpcuXUQTExMxMTFRTE1NFY2NjUWO40SO4/6vXGq+1qRJE9HLy0vkOE50dnYWb9++zfppEPJRduzYIUokErFnz57imTNn3pqD18vl9Tmws7MTAYjz5s0Tnz17xvppEFEUOVHU4cspapmysjJMnz4diYmJtdtQ1Px4pAAKAcgAyN+4n7e3N3bs2AFDQ0N1xiVEJc6ePQsPDw9cunSpdtuY+vw3FRoaimXLlqk4HakvKhcNU1ZWhnbt2r21F9P7yoXjODRp0gQlJSV0+VWiM27duoUuXbrU++P6NAeah97Q1zCxsbHvfWP/BYA3z+8XRRFPnz5FbGysyrMRoi7x8fEftF0SzYHmoVcuGkQURXTr1g1Xrlx5axmgFwBTAJnvuB/HcTAzM8PFixdpV1ei9eqag7rQHGgWKhcN8uDBA7Ru3fqdtzUC0ApAEwAX67h/y5YtVZSOEPWoaw7qe3+aA/ZoWUyDPH78+L23dQZQDKCuyxhVVFQoOxIhalfXHNQHzYFmoHLRIHVdAa8EgCuA83Xcv1mzZsqORIjafeyVIGkONAOViwZp2bIlzM3N37leXIlXnxJ71w5MHMfB3Nwcpqamqo5IiMrVNQd1oTnQLFQuGoTjOAQEBPyn+wYGBtKbmEQn0BzoBnpDX8OUl5ejY8eOqKyshEKh+NfvNzAwgEQioc/3E51Cc6D96JWLhjExMcH+/fvBcRwMDOr+8RgYGIDjOCQkJNBAEZ1Cc6D9qFw0kIuLC5KTkyGRSMBx3Fsv82u+JpFIkJKSgqFDhzJKSojq0BxoNyoXDeXi4oKSkhJERkbCzMzs/24zMzNDZGQkbt68SQNFdBrNgfai91y0gCiKKC0tRUVFBZo1awZTU1N605LoHZoD7ULlQgghROloWYwQQojSUbkQQghROioXQgghSkflQgghROmoXAghhCgdlQshhBClo3IhhBCidFQuhBBClI7KhRBCiNJRuRBCCFE6KhdCCCFKR+VCCCFE6ahcCCGEKB2VCyGEEKX7Hx5MDC5Eou0oAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,0,1,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1e7cd4a8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9973507118333039\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,1,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "18e0baa2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999506177136502\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(1,0,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(1,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "50eb8f8c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999411308602921\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(2,1,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(2,1,0)" - ] - }, - { - "cell_type": "markdown", - "id": "960e5447", - "metadata": {}, - "source": [ - "## Indexing of nodes (neurons)" - ] - }, - { - "cell_type": "markdown", - "id": "f4a7880f", - "metadata": {}, - "source": [ - "### Each neuron (node) is indexed by $(l,i)$ where $l$ is the layer index along depth, $i$ is the neuron index along width. In the function remove_node, we use use $(l,i)$ to indicate which node we want to remove." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c9e70d77", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "model.remove_node(1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "a22c9e31", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "44553b6a", - "metadata": {}, - "outputs": [], - "source": [ - "model.remove_node(2,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "7c9b491a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "7b24fcdb", - "metadata": {}, - "outputs": [], - "source": [ - "model.remove_node(1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0a7e9373", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "markdown", - "id": "9ee64af1", - "metadata": {}, - "source": [ - "## Indexing of layers" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4c732dfc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2 3\n", - "2 3\n", - "3 2\n", - "3 2\n", - "2 1\n", - "2 1\n" - ] - } - ], - "source": [ - "# KAN spline layers are refererred to as act_fun\n", - "# KAN symbolic layers are referred to as symbolic_fun\n", - "\n", - "model = KAN(width=[2,3,2,1])\n", - "\n", - "i = 0\n", - "model.act_fun[i] # => KAN Layer (Spline)\n", - "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", - "\n", - "for i in range(3):\n", - " print(model.act_fun[i].in_dim, model.act_fun[i].out_dim)\n", - " print(model.symbolic_fun[i].in_dim, model.symbolic_fun[i].out_dim)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "1f0ccc8f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Parameter containing:\n", - "tensor([[0., 0.]])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# check model parameters\n", - "model.act_fun[i].grid\n", - "model.act_fun[i].coef\n", - "model.symbolic_fun[i].funs_name\n", - "model.symbolic_fun[i].mask" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "01a2cbe3", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_2_plotting_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_2_plotting_-checkpoint.ipynb deleted file mode 100644 index a578fcb11..000000000 --- a/docs/.ipynb_checkpoints/API_2_plotting_-checkpoint.ipynb +++ /dev/null @@ -1,551 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 2: Plotting" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### Initialize KAN and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "8c6add1d", - "metadata": {}, - "source": [ - "### Plot KAN at initialization" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ac76f858", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", - "model.plot(beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ee036e1e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# if you want to add variable names and title\n", - "model.plot(beta=100, in_vars=[r'$\\alpha$', 'x'], out_vars=['y'], title = 'My KAN')" - ] - }, - { - "cell_type": "markdown", - "id": "ddf67e30", - "metadata": {}, - "source": [ - "### Train KAN with sparsity regularization" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.57e-01 | test loss: 1.31e-01 | reg: 2.06e+01 : 100%|██| 20/20 [00:11<00:00, 1.80it/s]\n" - ] - } - ], - "source": [ - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "### $\\beta$ controls the transparency of activations. Larger $\\beta$ => more activation functions show up. We usually want to set a proper beta such that only important connections are visually significant. transparency is set to be ${\\rm tanh}(\\beta |\\phi|_1)$ where $|\\phi|_1$ is the l1 norm of the activation function. By default $\\beta=3$." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=3)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6383a22f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=100000)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9f6ff7e1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "61d537b7", - "metadata": {}, - "source": [ - "### After purning, \"mask=True\" will remove all connections that are connected to unsignificant neurons. The insignificant neurons themselves are still visualized. If you want those neurons to be removed as well, see below. Insignificant/Significant neurons are defined based on l1 norm of its incoming and outgoing functions." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1269a698", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "2249bb17", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(mask=True, beta=100000)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1e5b8732", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(mask=True, beta=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "9e788b91", - "metadata": {}, - "source": [ - "### Remove insignificant neurons" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "ed4800ea", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2 = model.prune()\n", - "model2(dataset['train_input']) # it's important to do a forward first to collect activations\n", - "model2.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "61c8eeb1", - "metadata": {}, - "source": [ - "### Resize the figure using the \"scale\" parameter. By default: 0.5" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "5cb8d57e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2.plot(scale=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "67305f39", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2.plot(scale=0.2)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "51c722ad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2.plot(scale=2.0)" - ] - }, - { - "cell_type": "markdown", - "id": "03d4bf1b", - "metadata": {}, - "source": [ - "### If you want to see sample distribution in addition to the line, set \"sample=True\"" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "c6d24148", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2(dataset['train_input'])\n", - "model2.plot(sample=True)" - ] - }, - { - "cell_type": "markdown", - "id": "a3fa482a", - "metadata": {}, - "source": [ - "### The samples are more visible if we use a smaller number of samples" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "3856bcb6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAy2ElEQVR4nO3de3RU9YEH8O+dmbzfTyAEQl4QQgB5BRJAKULiSlpEXbW6XV21WrdCT7VW9+Hx7NZdq+22KLXWU6vF5wELa3FBIogiQhKQlyQhISQQSCBAHhNmMq/M3N/+QeeagcwQyEzmzsz3cw5/zL13kl/C3Hzv7y0JIQSIiIi8SOPvAhARUfBhuBARkdcxXIiIyOsYLkRE5HUMFyIi8jqGCxEReR3DhYiIvI7hQkREXsdwISIir2O4EBGR1zFciIjI6xguRETkdQwXIiLyOoYLERF5HcOFiIi8TufvAhAFAiEEurq6YDQaERsbi5SUFEiS5O9iEakWay5EHuj1erz88svIz89HWloasrOzkZaWhvz8fLz88svQ6/X+LiKRKknciZJocJWVlbjjjjtgMpkAXKq9ODlrLdHR0diwYQPKy8v9UkYitWK4EA2isrISy5YtgxACsiy7vU6j0UCSJGzevJkBQzQAw4XoMnq9HpmZmTCbzR6DxUmj0SAqKgptbW1ITEz0fQGJAgD7XIgus3btWphMpiEFCwDIsgyTyYS3337bxyUjChysuRANIIRAfn4+WlpacC23hiRJyMnJQVNTE0eREYHhQuSis7MTaWlpw3p/SkqKF0tEFJjYLEY0gNFoHNb7DQaDl0pCFNgYLkQDxMbGDuv9cXFxXioJUWBjuBANkJKSgtzc3GvuN5EkCbm5uUhOTvZRyYgCC8OFaABJkrBy5crreu+qVavYmU/0N+zQJ7oM57kQDR9rLkSXSUxMxIYNGyBJEjQaz7eIc4b+xo0bGSxEAzBciAZRXl6OzZs3IyoqCpIkXdHc5TwWFRWFLVu2oKyszE8lJVInhguRG+Xl5Whra8Pq1auRk5Pjci4nJwerV69Ge3s7g4VoEOxzIRoCIQSOHDmCX/3qV3jqqacwdepUdt4TecCaC9EQSJKEpKQkxMXFISkpicFCdBUMFyIi8jqGCxEReR3DhYiIvI7hQkREXsdwISIir2O4EBGR1zFciIjI6xguRETkdQwXIiLyOoYLERF5HcOFiIi8juFCRERex3AhIiKvY7gQDVFSUhLuueceJCUl+bsoRKrH/VyIhsjhcMBsNiMqKgpardbfxSFSNYYLERF5HZvFiIjI63T+LgCRkyzLaGlpgcVi8XdRAt748eMRHx/v72JQCGO4kGrY7XZ8+OGH6O/vR2RkpL+Lo3q9vb3Q6/UuxyIiIgAADzzwAKZNm+aHUhFdwnAhVZEkCXfeeSfy8/P9XRRV0+v1+MMf/oDLu0xlWYZWq73iONFIY7iQ6mg0GoSFhfm7GKolhEBVVRXOnj17xTmbzeaHEhFdiR36RAHG4XDg+PHj/i4GkUcMF6IAxGYvUjuGC1GA0Wq1yM3N9XcxiDxinwtRAHKOCrtceHg4Vw8gVWC4EAUQIQQ6Ozvx1VdfKcc0Gg1iYmIwevRoLF68GNu2bfNjCYkuYbgQBRBZlvHZZ5+hp6dHOVZaWoply5YhOjoakiThs88+82MJiS5hnwtRgBBCoLW1Ffv27VOOJSYmYunSpYiPj+fwbVIVhgtRgOjv78fWrVthNpsBXJpwumjRIqSmpkKSJD+XjsgVw4UoAAghUFtbi6NHjyrHxo4di9LSUgYLqRLDhSgA9PX1obKyEg6HA8Cl4chlZWWIiYnxc8mIBsdwIVI5IQSqq6vR1tamHCsoKMC0adNYayHVYrgQqZgQAl1dXfj888+VWfmRkZEoLy9nBz6pGsOFSMWEENixY4fL0OPZs2cjOzubtRZSNYYLkUo5hx7X1NQoxxITE7FkyRJoNLx1Sd34CSVSKbvdjsrKSmXoMQDcdNNNHHpMAYHhQqRCzqHH9fX1yrGxY8di/vz5rLVQQOCnlEiFzGYzKisrYbfbAXDoMQUehguRyjiHHp8+fVo5NmnSJEyfPp3NYRQwGC5EKiKEQHd3t8vQ44iICA49poDDcCFSEefQ466uLuXY7NmzkZOTw1oLBRSGC5FKCCFw6tQpVFdXK8cSEhI49JgCEj+xRCox2NDjG2+8EWlpaay1UMDhZmFEfiSEgNVqRVtbG44dO4a6ujrlXEZGBhYsWMBaCwUkhguRnwgh0NHRgXXr1qG5uVlZ8Rj4duhxbGysH0tIdP0YLkR+Yjab8d5776GlpeWKc7GxsZg4cSKbwyhgsb5N5CfHjx/HyZMnBz1nMBgGDR2iQMFwIfIDIQTOnTsHWZYHPS/LMjo6OpS5LkSBhuFC5CdxcXHDOk+kZgwXohEmyzJaW1vR2trqdiRYQkICCgoK2OdCAYsd+kQjyOFw4LPPPsPWrVthsVgGvSY2NhYrVqxASkrKCJeOyHsYLkQjRAiBY8eOYcuWLbDZbFecj4iIwI033og5c+YgIyOD81sooDFciEaIEAL79u0bNFic5s6dizFjxrA5jAIeH42IRoAQAt988w0OHz7s9pr+/n709fUxWCgoMFyIRkBfXx82bdrksm7Y5SIjIxEfHz+CpSLyHYYL0Qhob2/H+fPnPV4zbdo0pKamjlCJiHyL4UI0Amw2m8cJkRMmTMD3vvc9duJT0OAnmciHhBAwm80wm83QarVur5s9ezYSEhLY30JBg6PFiHxECIHjx49jw4YNaG9vd1n1eKCxY8di5syZDBYKKgwXIh9wLqe/du1adHd3D3pNREQE8vLysGLFCiQkJIxwCYl8i+FC5AP9/f346KOP3AZLeHg4Hn74YUycOBE6nY61Fgo6DBciH2hra0NDQ4Pb83a7HRqNBmFhYSNYKqKRww59Ih/o7OxEf3+/2/NarRZRUVEjWCKikcVwIfIyIQRiYmI8DivOzMzEqFGjRrBURCOLzWJEXiKEQF9fH77++mvU1ta6vS4qKgrf+973EBkZOYKlIxpZDBciLxBCQK/X46233sLx48fdXhcZGYmKigrk5+ezE5+CGsOFyAuEEPj000/dBktiYiLmzJmDG264AVlZWZyJT0GP4ULkBWazGXV1dW7Px8TE4O/+7u8QERHBGguFBIYL0TAIIXDx4kXs3LkTvb29bq+zWCyQZZnBQiGD4UJ0nYQQ6OrqwhtvvIFTp055vDYtLQ3h4eEjVDIi/2PDL9F1EkJg69atVw2W8PBw3HTTTR4XriQKNqy5EF0nk8mExsZGj9ckJSXh1ltvRVFREZvEKKQwXIiuk91uh81mc3s+KSkJP/nJT5CWlsZgoZDDZjGi6yCEUNYHcycjIwMpKSkMFgpJDBeia+Scib9u3Tq3I8QiIyOxaNEizmehkMVmMaIhEELAYDCgo6MDdrsdu3fvdpnXotFolBpKamoqli1bhsmTJ7PWQiGL4UJ0FQ6HAzU1Nfjkk0/Q09MDIQSEEMr5iIgI3HHHHRgzZgw0Gg3S09MRHR3NYKGQxnAh8kAIgdraWqxfv37QzvuwsDAsX74cpaWlbAIjGoB3A5EHDocDO3fudDsqLC0tDfPmzWOwEF2GdwSRB1arFRcuXHB73mg0wmq1jmCJiAIDm8WIBhBCoL+/H3q9Hna7HbIsw263u70+PDwcOh1vI6LL8a4g+hshBFpaWrBp0yacPn0asixDp9PBZDK5fU9hYSG3KyYaBMOFCJeC5cyZM3jzzTfR09OjHPc0Az8nJwdlZWUcFUY0CIYLhTQhBKxWK6qrq7Fz506XYBlIp9OhpKQEFy9ehBAC+fn5KC4uRmxsLMOFaBAMFwppdrsdGzduxJ49eyDLstvrtFotFi1ahFGjRgEAJEliqBB5wHChkOScCHns2DFUV1d7DBbgUrjodDoOOSYaIoYLhRQhBGw2Gw4ePIhvvvkGbW1tHkeDOY0fPx6JiYm+LyBRkGC4UMiQZRkdHR3YsmULDh06dNXailNiYiIqKio45JjoGvBuoaDn3Od+79692LZtG4xG45DeFxYWhtmzZ2Px4sXIyMhgHwvRNWC4UNByTog8fPgwtmzZgnPnzg35vZIkYeHChVixYoXLisdENDQMF1IlIQRkWUZ/fz90Op3L/vNX+0MvhIDRaMT+/fvxzTffoKmpCQ6HY0jfNzw8HPHx8SgpKcF3vvMdBgvRdWK4kOo4HA4cPHgQu3fvRnd3N+Lj45GXlwdJkhAbG4uxY8di3LhxiIiIuOIPvxACXV1deOutt3DixIlr+r6JiYn44Q9/yCXzibyA4UKq88UXX6CxsVEZxXXu3Dk0NTUp57VaLXJycnD33Xdj1KhRcDgcsNlssFgsMJlMqKysvOZg0Wg0mD9/PrKysjjcmMgLGC6kKrIsu+zwOBiHw4Gmpib84Q9/QHJyMoxGI0wmE6xWK/r7+4c0tHig2NhYLFy4EEuWLGGwEHkJw4UCVmdnJzo7O6/7/RqNBjk5ObjrrruQkZHBYCHyIoYLhaS0tDRUVFSgqKgIkZGR7F8h8jKGCwW0xMREJCQkIC4uDgkJCUhISMDFixfdrhUWExODuXPnYsmSJUhISGCoEPkIw4VURZIkjBkzBmfPnr3qtSkpKXj88ceRnJwMrVarBEV/fz/i4+Oxc+dO9PX1QZIkJCUlYcmSJZgyZQpSUlK48CSRjzFcSHWmTJkCnU6H06dPu71GkiRMmjQJ586dG3Ry5Lhx43DLLbego6MDWq0WmZmZiIuLw9mzZ4cUXIHK4XCgr6/P38UgYriQejhrLc3NzdDpdJgwYYLH668lKDwFVbCJjIxEdHS0v4tBIU4SQgh/F4II+HZWPj+Sw6fRaDj6jfyK4UJERF7HRxsiIvI6hgsREXkdw4WIiLyO4UJERF7HcCEaIofDAaPROOS9YYhCGcOFaIjOnDmDn//85zhz5oy/i0KkegwXIiLyOoYLERF5HcOFiIi8juFCRERex3AhIiKvY7gQEZHXMVyIiMjrGC5EROR1DBciIvI6hgsREXkdw4WIiLyO4UJERF7HcCEiIq9juBARkdcxXIiGQAiB7u5uGAwGdHd3Qwjh7yIRqZokeJcQuaXX67F27VqsWbMGzc3NyvHc3FysXLkS999/PxITE/1XQCKVYrgQuVFZWYk77rgDJpMJAFxqK5IkAQCio6OxYcMGlJeX+6WMRGrFcCEaRGVlJZYtWwYhBGRZdnudRqOBJEnYvHkzA4ZoAIYL0WX0ej0yMzNhNps9BouTRqNBVFQU2tra2ERG9Dfs0Ce6zNq1a2EymYYULAAgyzJMJhPefvttH5eMKHCw5kI0gBAC+fn5aGlpuaYRYZIkIScnB01NTUp/DFEoY7gQDdDZ2Ym0tLRhvT8lJcWLJSIKTGwWIxqgp6dnWO83GAxeKglRYNP5uwBE/mSxWHDgwAHs2bMHVVVVqKmpGdbX++CDDzB37lwUFRUhLS2NTWQUstgsRiHl4sWL2Lt3L6qrq1FVVYWDBw/CZrMhISEBc+fORUlJCV588UW0t7df89dOTU3F3XffjdbWVuX1lClTUFRUhClTpiAzM5NhQyGDNRcKal1dXaiqqlL+1dbWQpZlpKeno7S0FCtWrEBJSQkmT54MjeZSK7Esy/jpT396zR36zz77LFatWgWDwYCjR4+itrYWdXV12LVrF2RZRnx8PKZMmaL8y87Ohlar9dWPTuRXrLlQUGlra0N1dbXSzNXU1AQAyMrKQklJifIvOzvbbS3C2/NcLBYLGhoaUFdXh7q6OjQ2NsJmsyEqKgqTJ09Wajf5+fkICwsb1s9PpBYMFwpYQgg0NzejqqoKe/bsQXV1NU6fPg0AmDRpEkpKSlBaWop58+YhIyPjmr72tc7Q37JlC8rKyob0tfv7+3H8+HHU1dWhtrYW9fX1MJvNCAsLw6RJk5SaTUFBAaKioq6p3ERqwXChgOFwOFBfX+/SzNXZ2QmNRoNp06YptZK5c+d6ZTjwUNcW27hx45CDZTCyLOPkyZNKM1pdXR16e3uh0WiQm5ur1GwKCwsRFxc3vB+KaIQwXEi1bDYbDh06pARJTU0NDAYDwsPDMXPmTJSWlqKkpARz5sxBbGysT8qg1+vx9ttv45VXXrliVeRVq1bh/vvvR0JCgle/pxAC7e3tSq2mtrYWFy5cAACMHz9eGSAwZcoUzqkh1WK4kGqYTCZ8/fXXSjPX119/DavVipiYGBQXFyvNXDNmzEBERMSIlm3gfi5xcXFITk4e0ZFf58+fV2o1tbW1ymi20aNHK0FTVFSE0aNHc0QaqQLDhfxGr9ejpqZGqZkcPnwYdrsdycnJmDdvHubNm4fS0lIUFRVBp+PAxoH0er1Sq6mrq8OJEycghEBycjIKCwuV2k1WVhbDhvyC4UIj5ty5c0qQVFdXo76+HkIIjBkzxqXzfeLEicqwYBqavr4+HD16VKndNDU1wW63IzY2FoWFhUrtJjc3l0FNI4LhQj4hhMCpU6eUMNmzZw9OnDgBAMjJyVGCpKSkBOPHj+fTtZdZrVYcO3ZMaUZraGiA1WpFREQECgoKlJrNpEmTEB4e7u/iUhBiuJBXyLKMY8eOuYzkOnv2LCRJQmFhoTKSa968eRg1apS/ixty7HY7mpubXZrS+vr6oNPpkJ+fr9RsJk+ejJiYGH8Xl4IAw4Wui91uR21trcuaXN3d3dDpdLjhhhuU/pLi4mJuoKVCQgi0trYqNZu6ujr09PRAkiRkZ2e7LFvj7dFwFBoYLjQkVqsVBw4cUGole/fuRV9fHyIiIjBnzhylZjJ79mxER0f7u7h0jYQQ6OjocJlr09HRAQAYO3asy/Dn9PR0P5eWAgHDhQZlNBqxd+9eJUwOHDgAm82G+Ph4FBcXK3NMpk+fzjb7INXZ2Yn6+nqldnPq1CkAQFpamjKps6ioCGPHjmWfGV2B4UIALi3wWF1drazLdeTIEciyjNTUVKXzvbS0FJMnT+ZiiyHKYDC49Nk0NzdDlmUkJCRcsSAnR/sRwyVEtbe3K0FSXV2NxsZGAMC4ceNcFnjMzc3lUykNymw2o6GhQVlJoLGxEf39/YiOjnZZkDMvL48LcoYghksIEEKgpaXFZSSXs4lj4sSJSq1k3rx5yMzM9HNpKVDZbDY0NTUpfTb19fWwWCwIDw/HxIkTlX6bgoICREZG+ru45GMMlyDkcDjQ0NCg1Er27NmDCxcuQKPRoKioSAmSefPmITU11d/FpSDlcDhw4sQJlxFpBoMBGo0GeXl5SjMaF+QMTgyXIGCz2XD48GElSGpqanDx4kWEh4djxowZShNXcXExb2LyGyEE2traXMKms7MTADBhwgSXZWuSk5P9XFoaLoZLADKbzcoCj1VVVdi3bx8sFguio6NRXFysNHPNnDmTzQ+kWkIIXLhwAbW1tUrYnDlzBgAwZswYl0ECXJAz8DBcAsT27duxe/duVFVV4dChQ7Db7UhMTFSWUCkpKcHUqVPZcUoBraenR+mzqaurw8mTJ5UFOZ0DBLy1Xw/5FsMlQPT29kKWZeh0OoSFhUGn00Gr1fJpjoKa3W6H0WiEwWCAwWBAX18f8vPzuepDAGC4BAhZliFJEsOEQprD4YAkSZxHEwAYLkRE5HWMfyIi8jruGvQ3DocD+/btg8Fg8HdRAt706dO5uGGAcs6RMpvN/i5KwMvNzUVSUpK/i+E3bBb7G7PZjGXLlsFisSA2NtbfxfEKh8MBs9kMrVaLyMhIpb+mra1NmV/glJiYOOwtcZ0rAbz66qu45ZZbhlV28g+r1Yqnn34aNpsNUVFR/i6O6nV3d6Orq8vlmPP39sQTT2Du3Ln+KJYqsObyN0IIaDQaPP/885g/f76/izMsQgjs27cPr732GmpraxEZGYmSkhI89thj6O3txT/+4z9ClmWX9zgcDjz00EO47bbbrjtg+vv7cc8994DPK4FLCAFJkvDwww9j6tSp/i6OqnV2duL555+/4kHN4XBAq9WG/H3AcLmMTqdDRESEv4tx3YQQ+Pzzz/HYY4+5PFG1tLRg//79iIuLUyaqDdTb24vnn38ec+bMQW5u7nV9b45mCx5arZZzpjwQQmD79u3KGn0DWa1W3gdguAQdk8mEX//611dU1QHg8OHDHt/b0dGBHTt2ICcnhzcHkQd2ux11dXX+LoaqMVyCzNmzZ3H06NFhvZ8IuPR0brVaYbFYEBER4dJvRwj5Zq+rYbgECYfDgdbWVnz22WewWq3X9TUkSbruJjEKLlarFZs3b8a2bdvQ3d2N+Ph43HTTTaioqEBUVFTIh4xOp8OUKVNQX1/v76KoFsMlCJjNZrzyyiv405/+hJ6eHo9PVEuXLkV9fT3a29uvOJecnIzS0tKQ/8MR6oQQ+Mtf/oJjx47B4XAAAPR6Pd599110dHTgRz/6Ebe2BnDLLbdgz549V9xLkZGRXEEAnEQZ8IQQeOedd/Db3/4W3d3dHoMlLy8P//Vf/4W33noLxcXF0Olcny16e3tRVVXF6n6IE0Lg6NGjSrAMPL5z504+reNSLT85ORlpaWnKMa1Wi6KiIjz55JPIysryY+nUgeES4IxGI9555x3Y7fZBz2s0GqSlpaGiogJvvvkmsrOzMWPGDKxbtw7vv/8+fvaznynj8u12O37/+9/jwoULI/kjUACx2Ww4evQoH0Bw6WGstbVVeV1YWIjnnnsOs2bNYs0FDJeAZrVa8ac//QnNzc1urxk3bhw2b96MP/7xj5g8ebIyXDguLg6LFy/GE088gfLycuX6xsZGvPfee1fMgyFyYrBc+h00Nzejt7dXOTZt2rSAnsbgbQyXAOVsF3/ppZdgs9ncXpeeno6MjAyEhYUN2pcSFhaGxx9/XFnCXAiBN998U9lHg2igsLAw5SEl1B05ckR5CNPpdCgqKuLvZQCGS4AymUz485//7DFYNBoNKioqPD5NSZKEqVOn4u///u+VY2fPnsUf//hH1l5ClCRJmDRp0qBNOzNnzsSUKVP8UCp1sVqtLn1PqampGDdunB9LpD4MlwCl1+tx+vRpt+c1Gg2WL1+OH/zgB1d9mtJqtXjkkUeQkZGhHPvwww9x5MgR1l5CkCRJuOuuu/DQQw8hKysLWq1WOcfZ55dcuHABbW1tyuu8vLygWZPQWxguAchoNGLNmjXQ6/VurykoKMBLL72EuLi4IX3NrKwsPPjgg8ofDr1ejzVr1nisGVHwioiIwHe/+1388pe/RFFRkXK8sbERra2tIf3QIYRAY2OjsnK0JEmYNm0aO/Evw99GgJFlGa+99hrefPNNtyPEJEnCsmXLkJiYOOSnTI1Gg/vuuw+TJk1Sjn366afYtWtXSP8hCWWSJCEmJgaLFi1SPkdmsxlr1qzBX/7yF+j1+pD8bAghXGr1ERERKCgoYI3uMgyXANPT04N169a57Q/RaDQoKyvDww8/fM0f9tTUVPz4xz9W5r84J2f29fUNu9wUuMaPH+8yabKlpQXvvPMOXnjhBXR3d/uxZP5hMpnQ2NiovM7IyMDo0aP9WCJ1YrgEmK6uLo/zUHJycvDyyy8jOTn5mr+2JEn47ne/i+LiYuXY3r178X//938h+YRKl2rKW7ZsuWJJISEE6uvrsWnTppAb+NHW1uZyDxYUFCAyMtKPJVInhkuAiY2NRUxMjNvzmZmZSEhIuO4qekxMDFatWqXcLHa7Ha+++uoVe1ZQaDAajThy5Ijb8/v377/utewCkTNUnX2Rzv4WuhLDJcCkp6fjxhtvHPScTqfD8uXLr1jW5VpIkoSFCxdi6dKlyrGGhga8//77rL2EILvd7jE8Lly4gPb29pD5bDgcDpewjY+PR15eHvtbBsFwCTCSJA26aGB4eDjuvfde3H777cP+oIeHh2PlypVISEgA8O3EylAfJRSKYmNjXYaoX85kMmHr1q0h87no7e1FS0uL8nr8+PHX1QQdChguAUKWZbS1teHDDz/EJ598ohxPT0/Hgw8+iLfeegv//d//jejo6GF/L0mSMH36dNx5553Ksfb2dk6sDEHh4eG49dZbXea6XK65uRn9/f0jWCr/EELgxIkTLku+TJ06dVgtBcGM4RIA7HY71q5di1tuuQUrV65ET08PgEsh8Oijj+LFF19EWVmZVzdz0mg0eOSRRzBmzBjl2Pr163Hw4EHYbLaQeVINdZIkoaCgwONDi16vd/mDG8xqa2uV1aKde7rQ4BguKieEwLZt2/Dcc8+ho6Pjij/qzidKb7f5SpKE7Oxs/NM//ZPytXt6evCDH/wAK1aswNq1a9HX18eQCQEpKSnIz893e76rqwvV1dVB/1mw2Wyora1VXicnJyMrK4v9LW4wXFTOWWsxmUxXnBNCYN26dTAajT753s6JlQP3prhw4QJqamrw9NNP4z/+4z9Cojkk1Ol0OreDSIBLn8OB/RDBiku+XBuGi8pZLBacOHHC7fmOjg6Py8AMl9FoHDS8HA4H3n//fdTU1AT9E2uoc26M5anfZajLDAUqIQSOHTvm8pDHJV88429G5cLCwpCUlOT2fExMjLLZly8cOnQIXV1dg56zWCz46quvfPa9ST1ycnIwduzYQc9FRERgzpw5I1yikSWEwDfffKM8SEVGRnLrgatguKhcREQEKioq3D4hLVmyxGP4DNfVOu9DaQJdKIuPj8cDDzyg7Psz0NKlS1FYWBjUf2jNZjOOHTumvB49ejSXfLkKhksAmDVrFsLCwlyOaTQaLFiwAE888YRPq+ZTpkxx266s0+kwe/Zsn31vUg9JkjBr1iz853/+J26++WaXIElMTPTYZBYM2tvbce7cOeX15MmTueTLVTBcVE4IgU2bNik1BOfClL/5zW/w5z//GWPGjPHpE+PkyZNxzz33DBpgmZmZKCkpCeonVvqWRqPBhAkT8A//8A8uNZja2lq3K3QHg8GWfJk6dSo/91fBcFG5c+fOuUyazMrKwurVq3Hfffdd05L610un0+Hf/u3f8OSTT16xOu7Zs2dx6NAhduiHEEmSkJiY6DKCsLW11aeDSvxNlmWXJV/i4uKQn5/PcLkKhouKCSHw6aefor29XTlWUVGBtLS0EftgS5KEuLg4PPXUU9i+fTteeuklpYnOarXijTfeYL9LiNFqtS4biPX29uLIkSPo7+8PygeNwZZ8SUlJ8WOJAgPDRcXMZjPWr1+v3LBxcXG4/fbb/VIWjUaD5ORk3HbbbZgxY4ZyfNeuXVi9ejX27t3LXStDSG5urtJU6tzA7n/+539w/vz5oAkYIQQcDgeOHj2qrIoBXOqH5JIvV8dwUSkhBA4cOIDDhw8rx0pLSzFp0iS/VsdjYmLw4IMPKh24FosFv/71r3H77bfjpz/9KS5evOi3stHIsFqt+OSTT1zWmbNYLNi9ezfWrFmjbP8byIQQ6O3txeuvv47f/e53ypIvGo3G42oF9C2Gi0rJsoz169fDYrEAuNT3cc8991wxaswfYmNjr+jgt1gs+N///V80NDT4qVQ0UhobG3HgwIFBz9XW1uLw4cMBX3ux2Wx4/fXX8cknn7hMIpZlGVu3blXuS3KP4aJSp0+fxvbt25XXeXl5WLhwod87EWVZxoYNG9wu+8JVk4Obc2Vgd6PDHA6Hy/pbgerYsWPYu3fvoOcOHjzocQM1uoThokJCCGzevNllK9UVK1Yo+6v4U39/P06ePOnvYpAfXW1FiJaWloBec865Vpq7PkSHw4Hm5uaAr535GsNFhYxGIzZs2KB8eFNSUrB8+XK/11qAS81znJkcuiRJQl5enscJhCdOnAj4bbGvNkGSEyivjuGiMkIIVFVV4ejRo8qxRYsWYcKECf4r1ABarRa33377oLthAt5f+p/UJzMzE+PGjXN7vr+/P6A79SVJQmFhIeLj4wc9Hx0dzUmUQ8BwURmHw4F169YpzQrh4eG4++67VbO8hiRJuPXWW/HYY4+5bCCl1WpRWlqKnJwcP5aORkJYWBhyc3Pdnk9MTAz4rX9Hjx496M8YFhaGFStWIDs72w+lCiwcrK0yzc3N+PLLL5XXU6ZMQXFxsaqeksLDw/HMM8+grKwMX3zxBfr6+jBr1iwsWLAADzzwgL+LRz4mSRLKy8tRVVV1xQ6UkiRh6dKlqugfHI6Ojg40Nzcrr+Pi4lBYWIjFixdjzpw5qnnYUzOGi4oIIfDRRx+5bGN85513IiYmxs8lcyVJEsLCwjB37lwUFxcrxwO5E5eGTpIk5OTk4Cc/+QnWrl2LtrY2l3kggb4UvRACX331lTJnS5Ik3HHHHbjtttug0WgC+mcbSWwWU5Genh589NFHyutRo0bh1ltvVfWHWZIk5R+FDo1Gg9mzZ+OXv/wlfvjDHypP8g6HA/v27fNz6YbHYDC4tB4kJiZi/vz50Gq1/JxfA4aLCgghIMsyPv/8c5c1jMrKypCRkeHHkhG5J0kSYmNjsWDBAqSlpSnHDxw4gL6+Pj+W7PoJIXDw4EGcOXNGOVZcXOzy89HQMFz8TJZlHDp0CD/+8Y/x7LPPKs0LUVFRuOuuu7iNKqleXFwcbrjhBuX12bNn0dTUFJDzQPr7+7F9+3ZlMnBERAQWL17M+/A68DfmR0IIfPnll7j33nvx4Ycf4vz588q51NRUZGdnsxpOqidJEkpKSpSmMbvdjurq6oALF+fkyYFLGBUUFCAvL4/34XVguPhRX18fXnjhBZeZ+E7t7e34+OOPA+4GpdAjSRLy8/NdJtcePHgQBoPBj6W6dkII7NixQ1k3TKPR4Oabb1bFen6BiOHiR6dOnXKZLDmQLMvYsWOH0kxGpGaxsbGYOXOm8vr8+fNobGwMqIejzs5O1NTUKK/HjBmDmTNnstZynRgufmSz2Twu9MiVVymQzJs3T3nKdzgcAdU05lwZY+C+LQsWLHA7S5+ujuHiJw6HAx0dHR47CmfOnMnJWhQQJElCbm6uy+jGw4cPXzHJUq3MZjM+//xzl435brzxRtZahoHh4gdCCGzatAn//M//DJPJNOg1OTk5uO+++0a4ZETXLzo6GrNnz1Zed3Z2or6+XvW1FyEEamtrXVb7njFjBsaOHeu/QgUBhosfdHV14cUXX3S7a+O0adPwxhtvYMKECXxyooAhSRKKi4uVRU1lWUZ1dbXq9/hxOBzYvn270r+p0+lw8803c/jxMPG3N8KEENi3b5/HPVEKCwu56ioFpOzsbIwfP155feTIEej1ev8VaAhOnz7tsp14Tk5OwC9howYMlxEmhMBf//pXtzv5AZf2KFd7UwLRYCIjIzFnzhzldXd3N44cOaLaz7Msy/jiiy+U5mlJkrB48WLu1+IFDJcRJITA6dOn3W6fClz6cM+aNYtPTRSQJEnCnDlzlD/OQghVN4319vZi9+7dyuvU1FTMmzeP958XMFxGkBACr776Kk6dOuX2mqSkJJSVlfHDTQFr3LhxyMrKUl7X1dWpcmdKIQT27t3rsjJGSUkJkpKS/Fiq4MFwGUEGgwE7d+70eM3NN9/scZc/IrWLiIjA3Llzlde9vb345ptvVNc0ZrVaXYYfR0VF4Tvf+Q4f7LyE4TKC+vv7PU6MTE1NxZNPPgmdjtvsUOCSJAmzZ89GVFQUgG8nKKpptQkhBBobG9HU1KQcKyoqQlZWFsPFSxguIyguLg55eXluzxcWFmLcuHH8cFPAGzt2rMs2wQ0NDS7NT/7mXF7JZrMBuLRN980338wHOy9iuIwQWZbR29vrtrM+JiYGjzzyiDJHgCiQOXcqdTIajTh06JBqmsbOnTuH/fv3K68zMzMxffp0Pth5EcNlBFitVrz++usoKyvDK6+84nKDhYeHY+LEifjNb36DpUuX8sNNQcE56tG5Rbdz1JinIfgjRQiBXbt2KUvTSJKERYsWqW478UDHOqCPCSHw3nvv4Re/+IVSBXcKCwvDCy+8gOXLlyMhIYHBQkFl9OjRyM/Px6FDhwAATU1N6Ojo8PuAFaPR6LKNcUJCAubPn8/7z8tYc/Gxixcv4o033rgiWIBLHfz79+9HfHw8P9gUdHQ6ncucEaPRiP379/u1aUwIgUOHDqG9vV05NmfOHKSnp/utTMGK4eJj58+fd9mP+3J1dXWwWq0jWCKikSFJEmbMmIHY2FjlWE1NDfr7+/1WJrvd7rKOWHh4ONcR8xH+Rn0sIiLCYyd9TEwMl9WnoJWeno6CggLldXNzs0utYSQ5tzGur69Xjk2aNInbGPsIw8XHRo8ejRtuuGHQc5Ikoby8nNuoUtDSarUoKSlR/nibzWbs2rULfX19I948JoTA559/rsw1c64jxhGavsFw8TGLxTLohkkajQZLly7Ffffdx6cmClqSJGHq1KkuOzpu3LgRTz/9NHbt2jWiEys7OztRXV2tvB4zZgxmz57N+89HOFrMR4QQsNvtWL9+vTJaBgAyMjIwefJkLFmyBHfddRe3UaWgJoTAuXPnXPoVHQ4HWltbsWbNGkRERKC4uNjnf+CdQ6G7u7uVY/Pnz0dCQoJPv28oY7h4mfNmevvtt/HVV1+hrq5OeTqLjo7GmjVrsGDBAmg0Gj4xUdBzOBzYtGnToMseWSwWfPTRR5gxY4ZPm6aEEDAajS7riMXGxuKmm27y2fckhotXCSHQ1taGhx9+2GX2r1NFRQVKS0vZgU8hw2KxeFwFvKmpCdu2bUN5ebnXl14RQsBgMOCTTz5BVVUVTpw4oZybPn06MjMz+YDnQwyXQQghIISAw+GAVquFJElD+hDabDb84he/GDRYgEv9LBzySKFEo9F4HLBitVrx5ptvIjExEaWlpV79Y9/X14ff/va3g86tmTx5Mu9FH+Nv9zKyLGP37t1YuXIlbrvtNjz66KP49NNPhzQ2v6GhAVu3bnV7vqqqatDOfaJgFRkZ6Xa0pJPNZsPHH38Ms9k8rBFkzodC578vv/zS7aTNHTt2KLtPkm+w5jKAEAIffPABKisrYTQaleNbt27FE088gZUrV3qsujc3N8NsNrs9b7FY/DqBjGikSZKE2267DQ0NDS7L21+uoaEBzz33HG699VYsWLDgmobnCyFgsVhw4MAB1NbWQqPRYOrUqdi7d6/bsGpra8PZs2c9rlJOw8NwGUCWZWzcuPGKD6TZbMYrr7yCBQsWuB26KIRAdHQ0JEly+4HOzc3l6BQKKZIkIS0tDT//+c/x7//+7zh37tyg1zkcDjQ0NOD48eNob2/H97//fbd9k86aidFoRHd3NxwOBz744APs27dP2U558+bNHssly7IqFtEMZgyXy7gLBoPBgKeeegr/8i//giVLlkCr1cJut+P48eOor6+HRqPB+vXr3e4VHhUVhUcffRQRERG+LD6R6kiShPT0dMybNw9//etfPV5rt9vx8ccfY+LEiXA4HLDZbJgwYQIyMzNht9vR1NSEo0eP4vTp0zh69KgytPjytfuuNn8mOTkZo0aNGt4PRh4xXK5BbW0tHn30UbzyyitYvHgxXnzxRbz33nu4ePGixxpLVFQUVq1ahbKyMo5OoZAkSRJWrFiBlpYW1NbWeuxbMZlMePHFF9Hf36+0CMyfPx89PT04fPjwsJuWdTqdshI5+Q7D5RoZjUY8++yzePfdd7Fz507lCWngzRIdHY2lS5fCZDIhPT0dy5cvx8KFC7nMC4UsSZKQnJyMZ555Bjt37sTHH3+Ms2fPur1+YE3EZDJh27Zt1/V9Y2NjkZeXh+bmZvT39yMtLQ0VFRVYunQpR4v5GMNlAGf78IULFzxe197e7nHxvZkzZ+L3v/89wsLClJoKaywU6iRJQnx8PCoqKiCEwBtvvOHz9cUmTJiAf/3Xf4XBYIDNZkNSUpLSN0q+xegeQKPR4Jlnnhn2RMeenh44HA5lFj4/yETfkiQJN910EwoLC336fXQ6HcrKyhAZGYn09HRkZmYiJiaG9+MIYbhcJjs7G++++y4eeught9dERUV5HJKcnJzs9dnGRMEkPj4eP/vZz3DLLbcgKSkJ4eHhSExM9Npae3Fxcbj33nuxYMEChomf8C/gIOLj4/H444+jpqYGhw8fdjmXkJCAX/3qV9i+fTvWr19/xXu1Wi2WL1/O/hUiDyRJQkpKCn70ox/h+9//PgwGA2JjY/H111/jtddeu+bVkiVJwqxZs1BSUgKdTof8/HxkZGRwqSU/YrgMIMsy9u3bp8zcvfvuu9HT06OsjRQdHY27774bkZGRmDVrFj799FPo9XqXr5GTk4O4uDhUVlaOdPH9zm63o6enx9/FoGESQqChoWHQxSZ9LSoqCpmZmWhtbXU5rtVqIcvyoH00kiShqKgICxcuRExMDADgzJkzHneA9SWHwwGDweCX760mkvDnhtYqYrFY8MQTT7gsbgd8O2ELwBX9JwPPObGPBXj22WdRWlrq72LQdbDZbPjd737ncSSXr7m7r5znLqfWe+7+++9HUVGRv4vhNwyXv3Huv8Jfx/DpdDoO8wxQzgVbeR8Mn1arDen7gOFCREReF7qxSkREPsNwISIir2O4EBGR1zFciIjI6xguAYKj2YguzSHp6+u75kmWNPIYLgHiyJEjGD16NI4cOeLvohD5zcmTJ3HPPffg5MmT/i4KXQXDhYiIvI7hQkREXsdwISIir2O4EBGR1zFciIjI6xguRETkdQwXIiLyOoYLERF5HcOFiIi8juFCRERex3AhIiKvY7gQEZHXMVyIiMjrGC5EROR1DJcAIIRAT08PZFlGT08P93ShkCSEQHd3N0wmE7q7u3kfqBzDRcX0ej1efvll5OfnY9GiRejp6cGiRYuQn5+Pl19+GXq93t9FJPK5gfdBcXExduzYgeLiYt4HKicJxr8qVVZW4o477oDJZAIAl6c0SZIAANHR0diwYQPKy8v9UkYiX+N9ELgYLipUWVmJZcuWQQgBWZbdXqfRaCBJEjZv3swbi4IO74PAxnBRGb1ej8zMTJjNZo83lJNGo0FUVBTa2tqQmJjo+wISjQDeB4GPfS4qs3btWphMpiHdUAAgyzJMJhPefvttH5eMaOTwPgh8rLmoiBAC+fn5aGlpuaaRMJIkIScnB01NTUo7NFGg4n0QHBguKtLZ2Ym0tLRhvT8lJcWLJSIaebwPggObxVTEaDQO6/0Gg8FLJSHyH94HwYHhoiKxsbHDen9cXJyXSkLkP7wPggPDRUVSUlKQm5t7ze3FkiQhNzcXycnJPioZ0cjhfRAcGC4qIkkSVq5ceV3vXbVqFTsxKSjwPggO7NBXGY7vJ+J9EAxYc1GZxMREbNiwAZIkQaPx/N/jnJm8ceNG3lAUVHgfBD6GiwqVl5dj8+bNiIqKgiRJV1TznceioqKwZcsWlJWV+amkRL7D+yCwMVxUqry8HG1tbVi9ejVycnJczuXk5GD16tVob2/nDUVBjfdB4GKfSwBw7mNhMBgQFxeH5ORkdlpSyOF9EFgYLkRE5HVsFiMiIq9juBARkdcxXIiIyOsYLkRE5HUMFyIi8jqGCxEReR3DhYiIvI7hQkREXsdwISIir2O4EBGR1zFciIjI6xguRETkdQwXIiLyOoYLERF53f8DRszR4/wP9gsAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2(dataset['train_input'][:20])\n", - "model2.plot(sample=True)" - ] - }, - { - "cell_type": "markdown", - "id": "4fa7ca2c", - "metadata": {}, - "source": [ - "### If a function is set to be symbolic, it becomes red" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "3d502880", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best value at boundary.\n", - "r2 is 0.9926980535347188\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9927)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model2.fix_symbolic(0,1,0,'x^2')" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "f8f93b9c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "e75a0760", - "metadata": {}, - "source": [ - "### If a function is set to be both symbolic and numeric (its output is the addition of symbolic and spline), then it shows up in purple" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "17df5fed", - "metadata": {}, - "outputs": [], - "source": [ - "model2.set_mode(0,1,0,mode='ns')" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "b5b13363", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model2.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_3_grid_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_3_grid_-checkpoint.ipynb deleted file mode 100644 index 7c452b3b1..000000000 --- a/docs/.ipynb_checkpoints/API_3_grid_-checkpoint.ipynb +++ /dev/null @@ -1,294 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 3: Grid" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### One important feature of KANs is that they embed splines to neural networks. However, splines are only valid for approximating functions in known bounded regions, while the range of activations in neural networks may be changing over training. So we have to update grids properly according to that. Let's first take a look at how we parametrize splines. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'B_i(x)')" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan.spline import B_batch\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# consider a 1D example.\n", - "# Suppose we have grid in [-1,1] with G intervals, spline order k\n", - "G = 5\n", - "k = 3\n", - "grid = torch.linspace(-1,1,steps=G+1)[None,:]\n", - "\n", - "# and we have sample range in [-1,1]\n", - "x = torch.linspace(-1,1,steps=1001)[None,:]\n", - "\n", - "basis = B_batch(x, grid, k=k)\n", - "\n", - "for i in range(G+k):\n", - " plt.plot(x[0].detach().numpy(), basis[0,i,:].detach().numpy())\n", - " \n", - "plt.legend(['B_{}(x)'.format(i) for i in np.arange(G+k)])\n", - "plt.xlabel('x')\n", - "plt.ylabel('B_i(x)')" - ] - }, - { - "cell_type": "markdown", - "id": "75af662c", - "metadata": {}, - "source": [ - "### There are $G+k$ B-spline basis. The function is a linear combination of these bases $${\\rm spline}(x)=\\sum_{i=0}^{G+k-1} c_i B_i(x).$$ We don't need worry about the implementation since it's already built in KAN. But let's check if KAN is indeed implementing this. We initialize a [1,1] KAN, which is simply a 1D spline." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4369a310", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.1382, grad_fn=)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import KAN\n", - "\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "# obtain coefficients c_i\n", - "model.act_fun[0].coef\n", - "assert(model.act_fun[0].coef[0].shape[0] == G+k)\n", - "\n", - "# the model forward\n", - "model_output = model(x[0][:,None])\n", - "\n", - "# spline output\n", - "spline_output = torch.einsum('i,ij->j',model.act_fun[0].coef[0], basis[0])[:,None]\n", - "\n", - "torch.mean((model_output - spline_output)**2)" - ] - }, - { - "cell_type": "markdown", - "id": "82150587", - "metadata": {}, - "source": [ - "### They are not the same, what's happening? We want to remind that we model the activation function to have two additive parts, a residual function $b$(x) plus the spline function, i.e., $$\\phi(x)={\\rm scale\\_base}*b(x)+{\\rm scale\\_sp}*{\\rm spline}(x),$$ and by default $b(x)={\\rm silu}(x)=x/(1+e^{-x})$." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7d76a3c4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0., grad_fn=)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# residual output\n", - "residual_output = torch.nn.SiLU()(x[0][:,None])\n", - "scale_base = model.act_fun[0].scale_base\n", - "scale_sp = model.act_fun[0].scale_sp\n", - "torch.mean((model_output - (scale_base * residual_output + scale_sp * spline_output))**2)" - ] - }, - { - "cell_type": "markdown", - "id": "3d72e076", - "metadata": {}, - "source": [ - "### What if my grid does not match my data? For example, my grid is in [-1,1], but my data is in [10,10] or [-0.5,0.5]. Use update_grid_from_sample to adjust grids to samples. This grid update applies to all splines in all layers." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "46717e8b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameter containing:\n", - "tensor([[-1.0000, -0.6000, -0.2000, 0.2000, 0.6000, 1.0000]])\n", - "Parameter containing:\n", - "tensor([[-10.0100, -6.0060, -2.0020, 2.0020, 6.0060, 10.0100]])\n" - ] - } - ], - "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-10,10,steps = 1001)[:,None]\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "de04db15", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameter containing:\n", - "tensor([[-1.0000, -0.6000, -0.2000, 0.2000, 0.6000, 1.0000]])\n", - "Parameter containing:\n", - "tensor([[-0.5100, -0.3060, -0.1020, 0.1020, 0.3060, 0.5100]])\n" - ] - } - ], - "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-0.5,0.5,steps = 1001)[:,None]\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "markdown", - "id": "e418ca2c", - "metadata": {}, - "source": [ - "### Uniform grid or non-uniform? We consider two options: (1) uniform grid; (2) adaptive grid (based on sample distribution) such that there are (rougly) same number of samples in each interval. We provide a parameter grid_eps to interpolate between these two regimes. grid_eps = 1 gives (1), and grid_eps = 0 gives (0). By default we set grid_eps = 1 (uniform grid). There could be other options but it is out of our scope here." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d2c4f636", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameter containing:\n", - "tensor([[-1.0000, -0.6000, -0.2000, 0.2000, 0.6000, 1.0000]])\n", - "Parameter containing:\n", - "tensor([[-3.4896, -2.1218, -0.7541, 0.6137, 1.9815, 3.3493]])\n" - ] - } - ], - "source": [ - "# uniform grid\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "b9b354c6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameter containing:\n", - "tensor([[-1.0000, -0.6000, -0.2000, 0.2000, 0.6000, 1.0000]])\n", - "Parameter containing:\n", - "tensor([[-3.4796, -0.8529, -0.2272, 0.2667, 0.8940, 3.3393]])\n" - ] - } - ], - "source": [ - "# adaptive grid based on sample distribution\n", - "model = KAN(width=[1,1], grid=G, k=k, grid_eps = 0.)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7b8f994", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_4_extract_activations_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_4_extract_activations_-checkpoint.ipynb deleted file mode 100644 index 88ff1fc72..000000000 --- a/docs/.ipynb_checkpoints/API_4_extract_activations_-checkpoint.ipynb +++ /dev/null @@ -1,140 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 4: Extracting activation functions\n", - "\n", - "### The KAN diagrams give intuitive illustration, but sometimes we may also want to extract the values of activation functions for more quantitative tasks. Using the indexing convention introduced in the indexing notebook, each edge is indexed as $(l,i,j)$, where $l$ is the layer index, $i$ is the input neuron index, and $j$ is output neuron index." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import matplotlib.pyplot as plt\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale_base = 1.0)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x)\n", - "model.plot(beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d3fe2e03", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8wUlEQVR4nO3df1zV9d3/8efh10FUjgIJqAik/ZCoTByGZq2WpHU5V61srbpq5pVdtS5z27Vc2wzXRrva1dpqWm21rWzNrdp32bhodLmrLHWUWEb0wxRD5RACekCRX+d8vn/gIZDD4QNyfj/ut9u5KZ/zPocXHPQ8ef+0GIZhCAAAIEREBboAAACAoSC8AACAkEJ4AQAAIYXwAgAAQgrhBQAAhBTCCwAACCmEFwAAEFIILwAAIKTEBLqAkeZyuVRbW6uxY8fKYrEEuhwAAGCCYRhqaWnRxIkTFRXlvW8l7MJLbW2tMjIyAl0GAAAYhn379mny5Mle24RdeBk7dqyk7i8+MTExwNUAAAAzmpublZGR0fM+7k3YhRf3UFFiYiLhBQCAEGNmygcTdgEAQEghvAAAgJBCeAEAACGF8AIAAEIK4QUAAIQUwgsAAAgphBcAABBSCC8AACCkhN0mdQAAwDecLkPl1U2qb2nThLHxys9OUnSU/88RJLwAAIBBlVbaVbSxSnZHW8+1dFu8Vi/K0YLcdL/WwrARAADwqrTSrtvXV/QJLpJU52jT7esrVFpp92s9hBcAADAgp8tQ0cYqGR7uc18r2lglp8tTC98gvAAAgAGVVzf163HpzZBkd7SpvLrJbzURXgAAwIDqWwYOLsNpNxIILwAAYEATxsaPaLuRQHgBAAADys9OUrotXgMtiLaoe9VRfnaS32oivAAAgAFFR1m0elGOx/vcgWb1ohy/7vdCeAEAAF4tyE3XT67K7Xc9zRavdTfM9Ps+L2xSBwAABpUQ1x0ZslISdPelp7PDLgAACG5v7e1eCn3JGalaPGNSQGshvAAAgAG5zzP636p6SdKszHGBLUiEFwAAMABP5xndt7FKUVEWv89z6Y0JuwAAoJ+BzjM62NIekPOMeiO8AACAPoLxPKPeCC8AAKCPYDzPqDe/hJe1a9cqOztb8fHxysvL0+bNm722f/bZZ3XuuecqISFB6enpuuWWW9TY2OiPUgEAiHjBeJ5Rbz4PLxs2bNCKFSt07733aseOHZo3b54WLlyompoaj+3feOMN3XTTTVq6dKnef/99/fnPf9Zbb72lW2+91delAgAASXsbjppq58/zjHrzeXh56KGHtHTpUt16662aPn26Hn74YWVkZGjdunUe22/btk1ZWVm66667lJ2drQsuuEC33Xab3n77bV+XCgBAxHO6DD1X7rmDoTd/n2fUm0/DS0dHh7Zv367CwsI+1wsLC7VlyxaPj5kzZ47279+vkpISGYahzz77TM8//7yuuOIKj+3b29vV3Nzc5wYAAIanvLpJdc3tg7a77gtTArK7ruTj8NLQ0CCn06nU1NQ+11NTU1VXV+fxMXPmzNGzzz6rJUuWKC4uTmlpaRo3bpweeeQRj+2Li4tls9l6bhkZGSP+dQAAECnMzmPJSknwcSUD88uEXYulbzIzDKPfNbeqqirddddd+uEPf6jt27ertLRU1dXVWr58ucf2q1atksPh6Lnt27dvxOsHACBSmJ3HEqj5LpKPd9hNSUlRdHR0v16W+vr6fr0xbsXFxZo7d66+853vSJLOOeccjR49WvPmzdP999+v9PS+O/pZrVZZrVbffAEAAESY/OwkpdviVedo87jPi0Xdp0kHar6L5OOel7i4OOXl5amsrKzP9bKyMs2ZM8fjY1pbWxUV1bes6OhoSd09NgAAwHeioyxavSjH433uMZPVi3ICNt9F8sOw0cqVK/Wb3/xGTz31lD744APdfffdqqmp6RkGWrVqlW666aae9osWLdKLL76odevWac+ePXrzzTd11113KT8/XxMnTvR1uQAARLwFuel69PrzdGI8SbPFa90NMwN6rpHkh4MZlyxZosbGRq1Zs0Z2u125ubkqKSlRZmamJMlut/fZ8+Xmm29WS0uLHn30UX3rW9/SuHHjdMkll+inP/2pr0sFAADHTUkaLUPSqNgo/eSqc5SW2D1UFMgeFzeLEWZjMc3NzbLZbHI4HEpMTAx0OQAAhKTfbN6j+//2gS45c4KeuvkLPv98Q3n/5mwjAADQj/vcotkBnJg7EMILAADow+Uy9Nbe7vASyFVFAyG8AACAPnbVH9Gh1k6Nio1W7iRboMvph/ACAAD6KK9ulCTlZY5XbHTwRYXgqwgAAATUP6uDd8hIIrwAAIBeDMPomaxLeAEAAEHv08ZW1be0Ky46SjMyxgW6HI8ILwAAoMc/j893mZExTvGx0QGuxjPCCwAA6BHs810kPxwPAAAAgp/T1T3X5f8+qpckzcocH+CKBkbPCwAAEa600q4LfrpJX/v1NjUd7ZQkfffFnSqttAe4Ms8ILwAARLDSSrtuX18hu6Otz/X65nbdvr4iKAMM4QUAgAjldBkq2lglTyc0u68VbayS0xVcZzgTXgAAiFDl1U39elx6MyTZHW09+74EC8ILAAARqr5l4OAynHb+QngBACBCTRgbP6Lt/IXwAgBAhMrPTlJa4sDBxCIp3RYfdHu+EF4AAIhQZVV1aut0erzPcvzP1YtyFB1l8dgmUNikDgCACFRaadfy9RUD3j8uIVbFV52tBbnpfqzKHHpeAACIME6XoXtefM9rG8MwND8nzU8VDQ3hBQCACLNtT6MOt3Z6bXP4WJe27Wn0U0VDQ3gBACDCbN1tLpSYbedvhBcAACKO2R1zg2tnXTfCCwAAEabg1JQRbedvhBcAACLM+VOTNS4h1mubcQmxOn9qsp8qGhrCCwAAESY6yqIHrjrba5sHrjo76PZ3cSO8AAAQgRbkpuu/rzm33/W0RKseu2FmUO7v4sYmdQAARKjEUd1DR+m2eN2z8ExNGNt9FECw9ri4EV4AAIhQ/zy+j8sXz5igxTMmBbga8xg2AgAgQm2r7g4v558aXAcvDobwAgBABHIc69T7tc2SpPNPDc5VRQMhvAAAEIHe3tskw5BOTRmt1MT4QJczJIQXAAAikPvcotkhNmQkMWEXAICI4nQZKq9uUmllnSQpP4vwAgAAglRppV1FG6tkd7T1XCv+nw81Ki46qPd1ORHDRgAARIDSSrtuX1/RJ7hI0sGWdt2+vkKllfYAVTZ0hBcAAMKc02WoaGOVxzOi3deKNlbJ6QrOU6RPRHgBACDMlVc39etx6c2QZHe0qby6yX9FnQTCCwAAYa6+ZeDgMpx2gUZ4AQAgzE0Ya24fF7PtAo3wAgBAmMvPTtK4hNgB77eo+3DG/OzQWDZNeAEAIMyVVdXpcGvngPcbklYvygn606TdCC8AAIQxp8vQt/70rtc24xJiNT8nzU8VnTzCCwAAYWzFHyt0tMPptc3h1s6QWWkkEV4AAAhbHV0uvbyzzlTbUFlpJBFeAAAIW89s3etxYzpPQmWlkUR4AQAgbO1tbDXVLiEuOmRWGkmEFwAAwpi5fpcvZI0PmZVGEuEFAICwZTaPfPmcib4tZIQRXgAACENOl6GNO82dFD1xfIKPqxlZhBcAAMJQeXWTmo4OvDGdW/LouJCa7yIRXgAACEuvVplbIr14xsSQmu8iEV4AAAg7Tpehv7xzwFTbUNpZ180v4WXt2rXKzs5WfHy88vLytHnzZq/t29vbde+99yozM1NWq1VTp07VU0895Y9SAQAIeeE8ZCRJMb7+BBs2bNCKFSu0du1azZ07V48//rgWLlyoqqoqTZkyxeNjrr32Wn322Wd68sknNW3aNNXX16urq8vXpQIAEBbM7pYbikNGkh/Cy0MPPaSlS5fq1ltvlSQ9/PDDeuWVV7Ru3ToVFxf3a19aWqrXXntNe/bsUVJSdxrMysrydZkAAIQNs7vlhuKQkeTjYaOOjg5t375dhYWFfa4XFhZqy5YtHh/z0ksvadasWfqv//ovTZo0Saeffrq+/e1v69ixYx7bt7e3q7m5uc8NAIBIlp+dpHRbvLz1qaTb4kNyyEjycXhpaGiQ0+lUampqn+upqamqq/M8C3rPnj164403VFlZqb/85S96+OGH9fzzz+uOO+7w2L64uFg2m63nlpGRMeJfBwAAoSQ6yqLVi3I83mc5flu9KCckh4wkP03YtVj6fnMMw+h3zc3lcslisejZZ59Vfn6+Lr/8cj300EP63e9+57H3ZdWqVXI4HD23ffv2+eRrAAAglCzITdcDV53d73qaLV7rbpipBbnpAahqZPh0zktKSoqio6P79bLU19f3641xS09P16RJk2Sz2XquTZ8+XYZhaP/+/TrttNP6tLdarbJarSNfPAAAIS4+LlqSlJmUoJWFp2vC2O6holDtcXHzac9LXFyc8vLyVFZW1ud6WVmZ5syZ4/Exc+fOVW1trY4cOdJz7eOPP1ZUVJQmT57sy3IBAAgr2/Y0SpLm56Rq8YxJKpiaHPLBRfLDsNHKlSv1m9/8Rk899ZQ++OAD3X333aqpqdHy5csldQ/73HTTTT3tr7/+eiUnJ+uWW25RVVWVXn/9dX3nO9/RN77xDY0aNcrX5QIAEDa27u4OLwVTkwNcycjy+VLpJUuWqLGxUWvWrJHdbldubq5KSkqUmZkpSbLb7aqpqelpP2bMGJWVlemb3/ymZs2apeTkZF177bW6//77fV0qAABho/bwMe1tbFWURfpCiK4qGojFMAwj0EWMpObmZtlsNjkcDiUmJga6HAAAAuKF7fv1rT+/q3Mn2/TXOy8IdDmDGsr7N2cbAQAQhrYen+9yfpgNGUmEFwAAwpJ7vsucqSkBrmTkEV4AAAgz+5padeDwMcVEWTQrc3ygyxlxhBcAAMKMu9fl3IxxGm31+docvwu/rwgAgAjldBkqr27Sn97uXsU7O8xWGbkRXgAACAOllXbd91KV6prbeq79sXyfzplsC+mjADxh2AgAgBBXWmnX8vUVfYKLJDW1dmj5+gqVVtoDVJlvEF4AAAhhTpehe158z2ubVS++J6crfLZ1I7wAABDCtu1p1OHWTq9tDrV29pxzFA4ILwAAhLAtuxtGtF0oILwAABDCDhw6NqLtQgHhBQCAEDZxXPyItgsFhBcAAEJYbLS5t/K5U0/xcSX+Q3gBACBEOV2GNry1b9B24xJiw+qARsILAAAhqry6SXXN7YO2u2VOtqKjLH6oyD8ILwAAhKj6lrbBG0nKSknwcSX+RXgBACBETRhrbhKu2XahgvACAECIys9OUrotXgMNCFkkpdvilR9mBzQSXgAACFHRURatXpQjTxv/uwPN6kU5YTXfRSK8AAAQ0hbkpuvL5/Q/NTrNFq91N8wMuxOlJSkm0AUAAICTU3+ke8XRN+Zm6dyMcZowtnuoKNx6XNwILwAAhLC2TqcqPj0sSbrh/EydesqYwBbkBwwbAQAQwrZ/ekgdTpfSEuOVnTI60OX4BT0vAACEIKfLUHl1k363pVqSVHBqkiyW8BwmOhHhBQCAEFNaaVfRxirZHZ9vUrfpo4MqrbSH5QTdEzFsBABACCmttOv29RV9goskOY516vb1FSqttAeoMv8hvAAAECKcLkNFG6s87uviVrSxSk6Xtxahj/ACAECIKK9u6tfj0pshye5oU3l1k/+KCgDCCwAAIcLsQYxm24UqwgsAACGi+uARU+1Sxlh9XElgEV4AAAgBTpeh32/da65xeE95IbwAABAKyqubdKi1y1TbhqPtPq4msAgvAACEgFer6ky3nTA23oeVBB7hBQCAIOd0Gfrj2/tMtU0eHaf87CQfVxRYhBcAAILctj2NOtruNNX2R4tzw/Y0aTfCCwAAQW7r7kZT7c7LGKfLz+F4AAAAEGCGyeVDc6Yl+7iS4EB4AQAgyI0bFTui7UId4QUAgCBXe/iYqXbhvjmdG+EFAIAg5nQZ+tP2/abaptlG+bia4EB4AQAgiD26aZeplUaRsETajfACAECQcroM/fbNvabaLp4xMeyXSLsRXgAACFLl1U06fKzTVNv5OWk+riZ4EF4AAAhS9S1tptqNS4iNmCEjifACAEDQMntG0S1zsiNmyEgivAAAELTys5OUbouXt1gyLiFWd14yzW81BQPCCwAAQSo6yqLVi3K8tnngqrMjqtdFIrwAABDU5uekacWlp/cLKOm2eD12w0wtyA3/s4xOFBPoAgAAgGellXYVbayS3fH5xN2x8TG69YJs3XnJaRHX4+JGzwsAAEGotNKu29dX9AkuknSkrUsPv7pLZVV1Aaos8AgvAAAEGafLUNHGKo9nSbuvFW2sktNl7rTpcEN4AQAgyJRXN/XrcenNkGR3tKm8usl/RQURwgsAAEHG7OZ0ZtuFG7+El7Vr1yo7O1vx8fHKy8vT5s2bTT3uzTffVExMjGbMmOHbAgEACCJmN6cz2y7c+Dy8bNiwQStWrNC9996rHTt2aN68eVq4cKFqamq8Ps7hcOimm27Sl770JV+XCABAUBlsczqLupdKR9KRAL35PLw89NBDWrp0qW699VZNnz5dDz/8sDIyMrRu3Tqvj7vtttt0/fXXq6CgwNclAgAQVLxtTucONKsX5bBU2hc6Ojq0fft2FRYW9rleWFioLVu2DPi43/72t9q9e7dWr17ty/IAAAhaC3LT9YN/6R9g0mzxWhehm9O5+XSTuoaGBjmdTqWmpva5npqaqro6z+vTd+3apXvuuUebN29WTMzg5bW3t6u9vb3n4+bm5pMrGgCAIOFeCH32pETdOu9UTRjbPVQUqT0ubn6ZsGux9P0mG4bR75okOZ1OXX/99SoqKtLpp59u6rmLi4tls9l6bhkZGSNSMwAAgfbmJw2SpH85Z6IWz5ikgqnJER9cJB+Hl5SUFEVHR/frZamvr+/XGyNJLS0tevvtt3XnnXcqJiZGMTExWrNmjd59913FxMRo06ZN/R6zatUqORyOntu+fft89vUAAOAvHV0ubdvTKEm64LSUAFcTXHw6bBQXF6e8vDyVlZXpyiuv7LleVlamxYsX92ufmJio9957r8+1tWvXatOmTXr++eeVnZ3d7zFWq1VWq3XkiwcAIIB21BxSa4dTyaPjND0tMdDlBBWfH8y4cuVK3XjjjZo1a5YKCgr0xBNPqKamRsuXL5fU3XNy4MABPf3004qKilJubm6fx0+YMEHx8fH9rgMAEI6cLkPl1U363ZvVkqSCqcmKYqioD5+HlyVLlqixsVFr1qyR3W5Xbm6uSkpKlJmZKUmy2+2D7vkCAEAk8HSK9OZdDSqttEf06qITWQzDCKtTnZqbm2Wz2eRwOJSYSDcbACA0uE+R9vSmbJHCfnn0UN6/OdsIAIAA83aKtFsknyJ9IsILAAABxinSQ0N4AQAgwDhFemgILwAABBinSA8N4QUAgADjFOmhIbwAABBgnCI9NIQXAACCwILcdP3ya+f1633hFOn+fL5JHQAAMOeUsVYZkhLjY7Rmca5SEzlF2hPCCwAAQeL1jw9Kki45c4K+ct6kAFcTvBg2AgAgSLy+qzu8XHj6KQGuJLgRXgAACAIHW9pVeaBZkjTvNMKLN4QXAACCwBufdPe6nDUxUaeMtQa4muBGeAEAIAi8/nGDJIaMzCC8AAAQYC6X0TNZ9yLCy6AILwAABFiVvVmNRzs0Oi5aM6eMD3Q5QY/wAgBAgL12vNelYGqK4mJ4ax4M3yEAAALstZ4ho5QAVxIaCC8AAARQS1unKj49JEm66PQJAa4mNBBeAAAIoK27G9XlMpSVnKApyQmBLickcDwAAAAB4HQZKq9u0u+37pUkXXAaQ0ZmEV4AAPCz0kq77nupSnXNbT3X/rbTrgumpXB6tAkMGwEA4EellXYtX1/RJ7hI0qHWTi1fX6HSSnuAKgsdhBcAAPzE6TJ0z4vveW2z6sX35HQZfqooNBFeAADwk217GnW4tdNrm0Otndq2p9FPFYUmwgsAAH6ydbe5UGK2XaQivAAA4Ddmh4MYNvKG8AIAgJ8UnGpuObTZdpGK8AIAgJ84jnXIMkibcQmxOn9qsl/qCVWEFwAA/KC00q47/rBj0AGhB646W9FRg0WcyEZ4AQDAx5wuQ0Ubq7wGF4uktdfPZJM6EwgvAAD4WHl1k+yONq9tDEnjR8f5p6AQR3gBAMDH6lu8B5ehtot0hBcAAHxswtj4EW0X6QgvAAD42KGj7YO2SbfFKz87yQ/VhD7CCwAAPuR0GfrR3z4YtN0PrshhlZFJhBcAAHzIzGRdicm6Q0F4AQDAh5isO/IILwAA+NDehqOm2jFZ17yYQBcAAEC4Kq206+ev7vLaxiIpjcm6Q0LPCwAAPuDeVdeM1YuYrDsUhBcAAHzA7ETdFZeezpEAQ0R4AQDAB8xOwM1KSfBxJeGH8AIAgA+wq67vEF4AAPCB/OwkpdviNdBMFovYVXe4CC8AAPhAdJRF37t8ugwP97kDDRN1h4el0gAA+EBxSZV+vbna431ptnitXpTDRN1hIrwAADDCikuq9PjrnoOLJP3LOWkEl5PAsBEAACOoo8s1YI+L25Nv7FVHl8tPFYUfwgsAACPoma175fI00aUXl9HdDsNDeAEAYAR92tQ6ou3QH+EFAIARlJlkbtM5s+3QH+EFAIARdGNBlgZb/Rxl6W6H4SG8AAAwguJiorRsXrbXNsvmZSsuhrfg4eI7BwDACLtn4XSNieu/G0mURbrtwmytujwnAFWFD7+El7Vr1yo7O1vx8fHKy8vT5s2bB2z74osvav78+TrllFOUmJiogoICvfLKK/4oEwCAEbFzv0NHOroUH2PRPQvP0E0FmfrBFdP14Y8WElxGgM/Dy4YNG7RixQrde++92rFjh+bNm6eFCxeqpqbGY/vXX39d8+fPV0lJibZv366LL75YixYt0o4dO3xdKgAAI6Kk0i5J+lJOmpZfNE1rFudq6bxTGSoaIRbDMAZZjX5yZs+erZkzZ2rdunU916ZPn66vfOUrKi4uNvUcZ511lpYsWaIf/vCHg7Ztbm6WzWaTw+FQYmLisOsGAGA4DMPQRQ/+n2qaWrX26zN1+dnspGvGUN6/fRoBOzo6tH37dhUWFva5XlhYqC1btph6DpfLpZaWFiUleT51s729Xc3NzX1uAAAEyvu1zappalV8bJS+eMYpgS4nLPk0vDQ0NMjpdCo1NbXP9dTUVNXV1Zl6jv/+7//W0aNHde2113q8v7i4WDabreeWkZFx0nUDADBUTpehrbsb9YtXP5YkffH0U5TgYdIuTp5fBt8slr4L3g3D6HfNk+eee0733XefNmzYoAkTJnhss2rVKjkcjp7bvn37RqRmAADMKq2064KfbtLXfr1NZR/US5K27WlS6fG5LxhZPg0vKSkpio6O7tfLUl9f36835kQbNmzQ0qVL9ac//UmXXnrpgO2sVqsSExP73AAA8JfSSrtuX18hu6Otz3XHsU7dvr6CAOMDPg0vcXFxysvLU1lZWZ/rZWVlmjNnzoCPe+6553TzzTfrD3/4g6644gpflggAwLA5XYaKNlbJ08oX97WijVVyDnZSI4bE54NxK1eu1I033qhZs2apoKBATzzxhGpqarR8+XJJ3cM+Bw4c0NNPPy2pO7jcdNNN+sUvfqHzzz+/p9dm1KhRstlsvi4XAADTyqub+vW49GZIsjvaVF7dpIKpyf4rLMz5PLwsWbJEjY2NWrNmjex2u3Jzc1VSUqLMzExJkt1u77Pny+OPP66uri7dcccduuOOO3qu/+u//qt+97vf+bpcAABMq28ZOLgMpx3M8fk+L/7GPi8AAH/5xasf6+ev7hq03XPLzqfnZRBBs88LAADhyuky9Fy5593ie0u3xSs/2/NeZRgewgsAAMNQXt2kuub2Qdtd94Upio4afHsQmEd4AQBgGMzOY8lKSfBxJZGH8AIAwDAkJcSZajdhbLyPK4k87FsMAMAQFZdU6YnXq722sUhKY76LTxBeAAAYguKSKj1uIrhI0upFOcx38QHCCwAAJnV0ufTrzd6Di9Td47J6UY4W5Kb7oarIw5wXAABMembrXpnZ6f8bc7MILj5EeAEAwKRPm1pNtdt36JiPK4lshBcAAEzKTDK37NlsOwwP4QUAAJNuLMjSYPNvoyzd7eA7hBcAAEyKi4nSsnnZXtssm5etuBjeXn2J7y4AAEOw6vIcXTtrcr/rURbptguzterynABUFVlYKg0AgElOl6Hy6iYdau2QJE07ZbTmTEtRZlKCbizIosfFTwgvAACYUFppV9HGKtkdn59p1HC0Q3OmJrMs2s+IiAAADKK00q7b11f0CS6S5Gjt1O3rK1RaaQ9QZZGJ8AIAgBdOl6GijVXytDed+1rRxio5zexehxFBeAEAwIvy6qZ+PS69GZLsjjaVVzf5r6gIR3gBAMCLV6vqTLWrbxk44GBkEV4AABiA02XoL+8cMNV2wth4H1cDN8ILAAADKK9uUtPRzkHbJY+OU352kh8qgkR4AQBgQD8uqTLVbvGMiYoe7NwAjBjCCwAAHhzrcKryQLOptvNz0nxcDXojvAAA4MFPTPa6JMRFM2TkZ4QXAAA82NvYaqpdZnICQ0Z+RngBAMCDrOQEU+1mZY73cSU4EeEFAAAPvmfydGiz7TByCC8AAHgwKi5al06f4LXN/JwJGhUX7aeK4EZ4AQBgADfPyR7wvvk5E/Trm77gx2rgFhPoAgAACFbPlddIkq7Ln6zYqCjtbWxVVnKCvnd5Dj0uAUR4AQDAg4Mt7Xrl/e5zjW46P1s5ExMDXBHcGDYCAMCD57fvV5fL0IyMcQSXIEPPCwAAxzldhsqrm/RZc5t+t6VaknR9/pQAV4UTEV4AAJBUWmlX0cYq2R1tPdcskqyxDFIEG8ILACDilVbadfv6ChknXDckrfjjO7LGRGlBbnogSoMHxEkAQERzugwVbazqF1zcDElFG6vkdA3UAv5GeAEARLTy6qY+Q0We2B1tKq9u8lNFGAzhBQAQ0eqavQeXobaD7xFeAAARrelI+4i2g+8RXgAAEW1cQpypdkmjzbWD7xFeAAARq7TSrh+XVJlqm2Yb5eNqYBZLpQEAEWmg5dGepNvilZ+d5POaYA49LwCAiDPY8ujeLJJWL8pRdJTF12XBJMILACDimFkeLUnJo+O07oaZbFAXZAgvAICI82pVnal2379iOsElCBFeAAARxeky9Jd3DphqyyTd4ER4AQBElPLqJjUd7Ry0XfLoOCbpBinCCwAgopgdMlo8YyKTdIMU4QUAEDGGMmQ0PyfNx9VguAgvAICIwZBReCC8AAAiRn2LucMVGTIKboQXAEDE2Ntw1FQ7hoyCG+EFABARSivt+vmruwZtx1EAwc8v4WXt2rXKzs5WfHy88vLytHnzZq/tX3vtNeXl5Sk+Pl6nnnqqHnvsMX+UCQAIU+7jAAbDUQChwefhZcOGDVqxYoXuvfde7dixQ/PmzdPChQtVU1PjsX11dbUuv/xyzZs3Tzt27ND3vvc93XXXXXrhhRd8XapXTpehrbsb9dd3Dmjr7kY5XWZOxAAABAOzxwGsuPR0dtQNARbDMHz6Ljx79mzNnDlT69at67k2ffp0feUrX1FxcXG/9t/97nf10ksv6YMPPui5tnz5cr377rvaunXroJ+vublZNptNDodDiYmJI/I1lFbaVbSxqs8PfrotXqsX5QTND7nTZai8ukn1LW2aMLa7y5PfHACg21/fOaD/+OM7g7b7xXUztHjGJN8XhH6G8v4d48tCOjo6tH37dt1zzz19rhcWFmrLli0eH7N161YVFhb2uXbZZZfpySefVGdnp2JjY31WrycDHZle52jT7esrguLArlAIVwAQSBPGxo9oOwSWT4eNGhoa5HQ6lZqa2ud6amqq6uo873BYV1fnsX1XV5caGhr6tW9vb1dzc3Of20jxdmS6+1rRxqqADiG5w9WJ3aHucFVaaQ9QZd2cLkNv7mrQz175UD975SO9+UkDQ24A/C4/O0lptoGDiUVM1A0lPu15cbNY+g5fGIbR79pg7T1dl6Ti4mIVFRWNQJX9DTZGakiyO9p0btErGmONlTU2SvEx0bLGRskaEyVrTHT3n7Gf/z0+9vi1mChZe/+99+N6rrsf0+u5erVzGfIarizqvn9+TlpAhpBKK+2658X3dLj18w2hHv3HJxqXEKsHrjqbXiEAfhMdZdE1eZP1yKZP+t3n/t+Ribqhw6fhJSUlRdHR0f16Werr6/v1rrilpaV5bB8TE6Pk5OR+7VetWqWVK1f2fNzc3KyMjIwRqN78ZkZH2p060u4ckc85FDFRFnV56cVwh6tv//kdTU9P1BhrrMbGx/S6xWqMtfvvo+NiFDWC/2hLK+1avr7C432HWzu1fH2FHguCITcAkcEwDL3xSXfv/ei4aB3t+Pz/7DSG2UOOT8NLXFyc8vLyVFZWpiuvvLLnellZmRYvXuzxMQUFBdq4cWOfa3//+981a9Ysj/NdrFarrFbryBZ+nNmxz5999RydmZ6o9i6n2jtdau9yqb3LqbbO7j/bu1zHrx//e5dL7Z0n3H/8Md4e39blVO/p1d6CS29/2VGrv+yo9drGYpHGxHUHmTHHg83Y+Jjj4eZ46LG67+/9cWyvx8TIGhMtp8vQfS+9P2hdvuwVYgIzgN4272rQjprDssZE6dVvXaS9Da38/xDCfD5stHLlSt14442aNWuWCgoK9MQTT6impkbLly+X1N1zcuDAAT399NOSulcWPfroo1q5cqWWLVumrVu36sknn9Rzzz3n61L7yc9OUrotXnWONo9DMxZ1J/YrZ072yw++YRjqchk94WfL7kZ987kdgz6uMCdVo60xamnrUktbp1raunSk/fO/d7kMGYbU0t6llvYuyTH8GuOiu4e5mtu6Bm1rd7Tp/z6q1yVnTvA6jDhUg01gJtgAkcUwDD386seSpK/PzlS6bZTSbaMCXBVOhs/Dy5IlS9TY2Kg1a9bIbrcrNzdXJSUlyszMlCTZ7fY+e75kZ2erpKREd999t371q19p4sSJ+uUvf6mrr77a16X2Ex1l0epFObp9fYUsUp8AE4gxUovFothoi2KjozTGGqPLz07XT0o+GDRcrbshb8AaDaM7DDW3depIW9fxgNOlI+2dam7r6nWt83jg6Q44PSHo+H3uLtgOp0sdTpfpr2np79+WNSZKp4y1dt/GWD//e6+PU47/GR8b7fX5Blsd9m8XZuuld+2szAIiyOZdDao43uuy/KJTA10ORoDP93nxt0jb58X9Zi15Dlf+WsrtdBk9vTlvftKg777wnk8+z9j4mAFDTvLoOP3nCzvVcKRjSM851O8VPTdA6DAMQ199bKu2f3pI35ibrR8uygl0SRjAUN6/CS8mBfMbVrCFK6fL0NwH/ld1ze1e26Xb4vXqyovUdLRDB4+062BLr5uHjzu6zPfoDJW7l+qN717i9XUNtu81AM/c/2dv3nVQa/9vt+KiLXrju5doQiL7uAQrwosPwkuwC7Zw5W21kdtQVhsZhqHmti6v4eaT+iOqPXzspOq+9/LpWnh2mtJto/p9/wYakvJ3LxcA7zz9kpEQF62Hrj2Xf6NBjPASgeElGHna50WSxifEqtgH+7xs3d2or/1624g8V1x0lCYnjVJW8mhlJicoY/woPbLpEx064WtxM9tzA8C3BvolQ+r+d8ovGcEraI4HQGRbkJuu+Tlp2ra7UVv3NEiyqGBqss4/Ndknb/CDrQ4zI90Wr4Yj7epwurTn4FHtOXjU1OPce+qUVzepYGr//YgA+F73Ng2eN+50C+TGnRg5hBf4VHSURXNPS9Hc01L88rkGWh02mN49J5JUe/iYappatbfxqD5tbNW2PQ3auX/woyd+8Nf3dOFpE3TWxETlTEzUtAljFBvt88PbAUh6dNMu1TUPvis6v2SEPsILwsqC3HStu2Gmx0m1Xz43XU+8Xi1p8GXvGUkJykhK0Nxp3aHL7JDUJ/VH9Ul9dc/HcdFROj1tjM5KtynneKDp3u14eP/0nC7Dbz1ZQCgprbTr56/uMtXW7O7pCF6EF4Qd93CVpwnM500Z3y/YmNka3MyGhclj4vTty87Qh/YWVdmb9UFts1rau1R5oFmVB/r22mQlJ+isiZ8HmrPSEwddBcFZUYBn7kN0zeLk6NDHhF1EnOGuzBrqnjoul6H9h47p/VqHquzNqqpt1vu1zQN2a6eMsXaHmfTEnmGnrOTRio6yjPjqLSCcDGWyfjoT64MWq40IL/CRkdjnpfFIe58wU2Vv1p6DR+TpqKqEuGidkTpGH9a16Fin931uvP2nHGxL6YGR9Nd3Dug//viOqbaE/ODFaiPAR7wNSZmVPMaqeaedonmnndJz7ViHUx/WdQeZ92u7g82Hdc1q7XBqxz5zh00NNBGRjfUQ7swOA9196en8zIcJwgswRNFRlhFfqTAqLlrnTRmv86aM77nmdBmqbjiip7d+qqe3fmrqeV7eWauMpFGaPD5B0uBnPbHnBUKd02XI5TJkGxUrxzHP+zBJUlqiVXdeMs2PlcGXCC9AkIqOsmjahLFamJtuOrw8+88aPfvPGk0aN0r52eO16cODHicYG+qeq9N7zwuGlhBqPPUqnsj9E3zfl8/i5zmMEF6AIJefnaS0ROugZ0WNtkZr2iljVFnbrAOHj+kvO7wfldB7zwvHsY7+q7ASrfpa/hRlpYwmzCDoeNtJtzczqwkReggvQJCLjrLovi+fNehqo/++pvvclqPtXdr+6SE9s22vyqrqB33+0kq7nt76af+hpeb2PvtmjBsVq1vmZunOS04jxCCg3EujvQWXcaNi9auvz2QfpDDF1p9ACFiQm67HbpipcQmx/e4bnxDbZwXFaGuMLjz9FH1j7qmmnvv3HoKLJ4ePdernr+7SOUWv6Ecb39fW3Y1yeloiBfhYeXWT16EiqfvnNcpiIbiEKXpegBAx1LOizJz1NNRjFCTpaLtTT765V0++uZdVSwgIszvkspNu+KLnBQgh7rOivn3Zmfr2ZWdo7rSUAX+zdJ/1JH0+adHNcvx2y9ysk6rHvWqptNJ+Us8DDIXZpdHspBu+CC9AGHOf9ZRm6/ufeJotXutumKn5OWkn9fzuXpuijVUMIcFv8rOTlBAXPeD9FnXvZZSfneS/ouBXDBsBYc7bxnpOlzHo0NJgvJ3Uy/Jr+EJpZZ1aO5we7/N00CrCD+EFiAADbaznHlq6fX3FsOa/9PbbN6tlGxWr6eljZbFY2NkXI6Z3CHa6DP3g/1VKkubnpKrygGPIB60i9HG2EQBTm32ZlZ0yWqenjtEr73/W776BDrEEBlKy067v/7VSTUc7+lyfdsoYla6YJ4vFQu9emOBgRsILMGS9f7vd29Cq375ZrcNetlt3s0iyJcTqC5nj9dquBnV0eT9A0qLu34452ReDKS6p0uOvVw94P4cshhcOZgQwZCcOLd15yTQ9uukTryHGHT0euOpsLchN15H2Lj3+2m49sumTAT+PtzkygNvL79R6DS5S3+MtEFlYbQTAo+goi/7j0tO0/Qfz9dyy8/WNuVlKGh3Xp4171ZL7t98x1hhNmzDG1POXvFer1o6uAe93ugxt3d2ov75zgA3xIkzJzlp98487Bm3nDsGIPPS8APDK3SNTMDVZ916RM+j8ArN7azyzrUYvVBzQgtw0XXXeZBVM/XyzPU9zcJJGx+r+xbm6/JyJI/fFIeiUVtr1738YPLi4sRFdZCK8ADBtoFVLvZnZ2XeMNUbjE2K179AxvVhxQC9WHFBaYrwWnzdRE8bG6/6X+59b03S0U//+hx1aVGnXpTlpTM4MQ+4zi4aCjegiE+EFwIjytvzaHTN+ds05uuysNFXUHNILFQf08ru1qmtu0+Ov7Rn0+TfurNPGnXWSWHodbsycWdRb8ug4NqKLUMx5ATDiBtvZd0FuuiwWi/Iyk/STK8/WW9+/VI/dMFN5meOH9Hk4niC8DHUI6EeLc+l5i1D0vADwCW87+57IGhOtBbnpau9yafunh0x/DkPdvTmsOgkPQxkCuu3CbF1+Dj1ukYrwAsBnzMyR6W048xdOXHrNkQSh48TXKml0nKIskreFZRZJj1x3nv5lBhO3IxnhBUDQyM9OUtLoWDUdHXxzvBPVt7QNuErpyhmTdGlOGkEmiHh6rQYLLpL0q+vPY8UZ2GEXQHAp2Vk7pKWybqljrfqspd1rGyb4BoeSnXb9+x8qBrz/xoJMvVr1GediRRiOByC8ACFtsG3hh8u9+unuS09TVspohpUCoGRnre58bseAPSzu4yNe+87F2v7pIYb/IgjHAwAIaasuz9G5k8d7PJCvN/db2W0XnqrHXh98mbX7/fLnr+7qucZv9P7hdBl65H936eH/3eW1nXsO0/ZPD3F8BAZEeAEQlC4/J12X5ab1OSzyufIa1TV/PpSQdjx4tA9yGKQ3dY42LV9foa/OnKQEa4wykxJ0Y0GW4mLYSWKklFba9d0XdspxbODjIE7EzrnwhvACIGh5OizS00qirbsbh/053L0xz1cc6Ln245IPtGxetlZdnjPs50W3wea3DISdc+EN4QVAyBho6bWZIwmGwmWoZ84NAWb4SnbW6o5hTL5Ot8Wzcy68ol8UQMhzH0kw0n69uVodx4ekOOV6aLp7XHYMK0yuXpTD5Fx4Rc8LgLDgPpLgxL1DTobLkJ7ZuleTxo/ilOshcK8oGqooi/To12YyeRqDYqk0gLDi3rW1rKpO/++dWq+rlcyYd1qy3tjVOGAPwm0XMjemt9JKu5avH/ocF0laywZ0EY19XggvANR3+/m9Da16+NWPJWlE5sX0dsucLBWeFdk7+DpdhrbtbtQdf6jQ4WND2yHZ3ePCWUWRjfBCeAHggact6UdSpO4Zc7LfV3pcIBFeCC8ABtS7N6as6jO9vNM+YNuLzzhF//jooOnndve5rLshcuZtlFbadfv6imH1Zo1PiFXxVWdHzPcK3rHDLgAMoPdy68UzJmnSuCr9enN1n+3qoyzSsnnZ+uIZqUMKL4a6A0zRxirNz0nrGUIK15OuO7pc+t5fKocVXFZ8aZq++aXTw+L7AP8jvACIaKsuz9G3Cs/UM1v36tOm1j477DpdxpBPuXZvb19e3aSCqckeh1RGx0XrwtNP0Q3nZ+r8U5ND8g28ZKdd331xp1razO+aKzG/BSODYSMA8GK4p1yfn52kOdNS9POyj732TIxLiNUDITZ0cjIHZzK/BQNhzgvhBcAI8tUp172tvf482UbFaeueBkndQ1vB2Csz3DAXqZOZYR7hhfACYISV7LQPesq11D3nJWl0nM6alKjXP24w/fwW9V/CHWy9Mk6XoS/8uGxIw2jjRsXqV1+fGZRBDMGFCbsAMMJ6n3JdVlWnp97c2y9wuN+af3xlrtq7XEMKL55+izzc2qnl6yv0WABXL/WebNzQ0j6k4GKR9MDVZ2vutBTfFYiIRHgBAJPcK5UKpiYrPzup30TctF5DIydz0vWJijZW6ZIzU7X900OqcxxTw5F2HT7WKYuPh5dOZv+W5NFx+vGVuUHTa4TwwrARAAyTtyXQTpehC366acQ2xEsaHTfgkJUvhpdOZv+WxPgYvf39+YqL4exfmDeU929+sgBgmNw9MYtnTFLB1L69HyN90rW3uTbu4aXSyoE33HMzczq202WoaGPVsI9ReOCqcwgu8CmGjQDARxbkpuuxG2bqnhff0+HWoZ33Mxwnbo53Ik/DQJ5WAZVXNw27x+i2C7PZwwU+x7ARAPiY02Xo0U2f6PHXd6u1w+nTz/XcsvN7dhDubaBhIHfM+dX1MzUlOUGbdzXoxYr92lV/ZEifN2l0rO5fnMseLhi2oFkqfejQId1111166aWXJElf/vKX9cgjj2jcuHEe23d2dur73/++SkpKtGfPHtlsNl166aV64IEHNHGiuX8QhBcAwcp98nLvvVwcrZ369z9UjNjnSEu0KneSTVOSRiszOUFTkhM0edwo3fhkueqaB+5NibJIHkaQvPrBFdOVMtYaVkceIHCCJrwsXLhQ+/fv1xNPPCFJ+rd/+zdlZWVp48aNHts7HA599atf1bJly3Tuuefq0KFDWrFihbq6uvT222+b+pyEFwChprTS7nFoaYw1WkfafdtT01t8TJQuOO0UXXBasn61abcajrR7nPdiUffKqje+ewmBBSMmKMLLBx98oJycHG3btk2zZ8+WJG3btk0FBQX68MMPdcYZZ5h6nrfeekv5+fn69NNPNWXKlEHbE14AhCJPvTJfyErSRQ/+w/T8k1PGWvVfV5+j/YdaVdPUqk8bu//cffCIOp2D/1f/0DXn6qq8yZI+H2aSPO9lE0knZ8M/gmKTuq1bt8pms/UEF0k6//zzZbPZtGXLFtPhxeFwyGKxDDjU1N7ervb29p6Pm5ubT6puAAiE6CiL5p6Wormn9d3QbfWiHNNLln+0+CxdfOaEfte37m7Q1379z0Efnz5uVM/fF+Sma90NM73uZQMEis/CS11dnSZM6P+PaMKECaqrqzP1HG1tbbrnnnt0/fXXD5jCiouLVVRUdFK1AkCwGihE9DY+IVbFXvZ5yc9OVrotXnWONq/DQPnZSf0+9/yctAH3sgECZcjh5b777hs0LLz11luSJIul/w+4YRger5+os7NT1113nVwul9auXTtgu1WrVmnlypU9Hzc3NysjI2PQ5weAUNE7RAxnh133njO3r68Y8EiD1YtyPD6Hey8bIJgMObzceeeduu6667y2ycrK0s6dO/XZZ5/1u+/gwYNKTU31+vjOzk5de+21qq6u1qZNm7yOfVmtVlmtVnPFA0CIOtkQwTAQwsmQw0tKSopSUgY/ZKugoEAOh0Pl5eXKz8+XJP3zn/+Uw+HQnDlzBnycO7js2rVL//jHP5ScTOIHgJHAMBDChc+XStfW1urxxx+X1L1UOjMzs89S6TPPPFPFxcW68sor1dXVpauvvloVFRV6+eWX+/TQJCUlKS4ubtDPyWojAABCT9CcbfTss8/q7LPPVmFhoQoLC3XOOefomWee6dPmo48+ksPhkCTt379fL730kvbv368ZM2YoPT2957ZlyxZflgoAAEIExwMAAICAC5qeFwAAgJFGeAEAACGF8AIAAEIK4QUAAIQUwgsAAAgphBcAABBSCC8AACCk+OxU6UBxb1vT3Nwc4EoAAIBZ7vdtM9vPhV14aWlpkSROlgYAIAS1tLTIZrN5bRN2O+y6XC7V1tZq7Nixslg4bGwgzc3NysjI0L59+9iJOIjxOoUGXqfQwOsU3AzDUEtLiyZOnKioKO+zWsKu5yUqKkqTJ08OdBkhIzExkX/EIYDXKTTwOoUGXqfgNViPixsTdgEAQEghvAAAgJBCeIlQVqtVq1evltVqDXQp8ILXKTTwOoUGXqfwEXYTdgEAQHij5wUAAIQUwgsAAAgphBcAABBSCC8AACCkEF4gSfrb3/6m2bNna9SoUUpJSdFVV10V6JIwgPb2ds2YMUMWi0XvvPNOoMtBL3v37tXSpUuVnZ2tUaNGaerUqVq9erU6OjoCXRokrV27VtnZ2YqPj1deXp42b94c6JIwTGG3wy6G7oUXXtCyZcv0k5/8RJdccokMw9B7770X6LIwgP/8z//UxIkT9e677wa6FJzgww8/lMvl0uOPP65p06apsrJSy5Yt09GjR/Wzn/0s0OVFtA0bNmjFihVau3at5s6dq8cff1wLFy5UVVWVpkyZEujyMEQslY5wXV1dysrKUlFRkZYuXRrocjCI//mf/9HKlSv1wgsv6KyzztKOHTs0Y8aMQJcFLx588EGtW7dOe/bsCXQpEW327NmaOXOm1q1b13Nt+vTp+spXvqLi4uIAVobhYNgowlVUVOjAgQOKiorSeeedp/T0dC1cuFDvv/9+oEvDCT777DMtW7ZMzzzzjBISEgJdDkxyOBxKSkoKdBkRraOjQ9u3b1dhYWGf64WFhdqyZUuAqsLJILxEOPdvg/fdd5++//3v6+WXX9b48eN10UUXqampKcDVwc0wDN18881avny5Zs2aFehyYNLu3bv1yCOPaPny5YEuJaI1NDTI6XQqNTW1z/XU1FTV1dUFqCqcDMJLmLrvvvtksVi83t5++225XC5J0r333qurr75aeXl5+u1vfyuLxaI///nPAf4qwp/Z1+mRRx5Rc3OzVq1aFeiSI5LZ16m32tpaLViwQNdcc41uvfXWAFWO3iwWS5+PDcPodw2hgQm7YerOO+/Udddd57VNVlaWWlpaJEk5OTk9161Wq0499VTV1NT4tEaYf53uv/9+bdu2rd+ZLLNmzdLXv/51/f73v/dlmRHP7OvkVltbq4svvlgFBQV64oknfFwdBpOSkqLo6Oh+vSz19fX9emMQGggvYSolJUUpKSmDtsvLy5PVatVHH32kCy64QJLU2dmpvXv3KjMz09dlRjyzr9Mvf/lL3X///T0f19bW6rLLLtOGDRs0e/ZsX5YImX+dJOnAgQO6+OKLe3oxo6Lo4A60uLg45eXlqaysTFdeeWXP9bKyMi1evDiAlWG4CC8RLjExUcuXL9fq1auVkZGhzMxMPfjgg5Kka665JsDVwe3EpZxjxoyRJE2dOlWTJ08OREnwoLa2Vl/84hc1ZcoU/exnP9PBgwd77ktLSwtgZVi5cqVuvPFGzZo1q6dHrKamhvlIIYrwAj344IOKiYnRjTfeqGPHjmn27NnatGmTxo8fH+jSgJDy97//XZ988ok++eSTfqGSXSkCa8mSJWpsbNSaNWtkt9uVm5urkpISephDFPu8AACAkMJgLAAACCmEFwAAEFIILwAAIKQQXgAAQEghvAAAgJBCeAEAACGF8AIAAEIK4QUAAIQUwgsAAAgphBcAABBSCC8AACCkEF4AAEBI+f8YJoULqfzzIwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "l = 1\n", - "i = 2\n", - "j = 0\n", - "\n", - "inputs = model.spline_preacts[l][:,j,i]\n", - "outputs = model.spline_postacts[l][:,j,i]\n", - "# they are not ordered yet\n", - "rank = np.argsort(inputs)\n", - "inputs = inputs[rank]\n", - "outputs = outputs[rank]\n", - "plt.plot(inputs, outputs, marker=\"o\")" - ] - }, - { - "cell_type": "markdown", - "id": "a9e62f17", - "metadata": {}, - "source": [ - "### If we are interested in the range of some activation function, we can use get_range." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1a978202", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x range: [-6.95 , 1.54 ]\n", - "y range: [-0.20 , 0.85 ]\n" - ] - }, - { - "data": { - "text/plain": [ - "(tensor(-6.9550), tensor(1.5376), tensor(-0.1954), tensor(0.8475))" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.get_range(l,i,j)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_5_initialization_hyperparameter_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_5_initialization_hyperparameter_-checkpoint.ipynb deleted file mode 100644 index 8ac8f866f..000000000 --- a/docs/.ipynb_checkpoints/API_5_initialization_hyperparameter_-checkpoint.ipynb +++ /dev/null @@ -1,235 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 5: Initialization Hyperparamters" - ] - }, - { - "cell_type": "markdown", - "id": "6581dacd", - "metadata": {}, - "source": [ - "### Initialization is the first step to gaurantee good training. Each activation function is initialized to be $\\phi(x)={\\rm scale\\_base}*b(x) + {\\rm scale\\_sp}*{\\rm spline}(x)$.\n", - "1. $b(x)$ is the base function, default: silu, can be set with ${\\rm base\\_fun}$\n", - "\n", - "2. ${\\rm scale\\_base}=1/\\sqrt{n_{\\rm in}}+e$ where $e$ is drawn from $U[-{\\rm noise\\_scale\\_base},{\\rm noise\\_scale\\_base}]$. Default: ${\\rm noise\\_scale\\_base}=0.1$.\n", - "\n", - "3. ${\\rm scale\\_sp}=1$\n", - "\n", - "4. ${\\rm spline}(x)$ is initialized by drawing coefficients independently from $N(0,({\\rm noise\\_scale}/G)^2)$ where $G$ is the grid number. Default: ${\\rm noise\\_scale}=0.1$.\n" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "### Default setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "c3e6d104", - "metadata": {}, - "source": [ - "### Case 1: Initialize all activation functions to be exactly linear. We need to set noise_scale_base = 0., base_fun = identity, noise_scale = 0." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "90d2d5de", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale_base = 0., base_fun = lambda x: x, noise_scale = 0.)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "1d834a51", - "metadata": {}, - "source": [ - "### Case 2: Noisy spline initialization (not recommended, just for illustration). Set noise_scale to be a large number." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a23d4e55", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=1.)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "37884df0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=10.)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "4641f36a", - "metadata": {}, - "source": [ - "### Case 3: Break Symmetry. When noise_scale_base is too small, nodes are almost degenerate. Sometimes we want to break such symmetry even at initialization. For an example, please see the PDE demo, where a non-zero noise_scale_base is important for achieving fast convergence." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "8d5348a7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale_base=0.0)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a65a5a4a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale_base=1.0)\n", - "x = torch.normal(0,1,size=(100,2))\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb2b1358", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_6_training_hyperparameter_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_6_training_hyperparameter_-checkpoint.ipynb deleted file mode 100644 index a5f2bc45c..000000000 --- a/docs/.ipynb_checkpoints/API_6_training_hyperparameter_-checkpoint.ipynb +++ /dev/null @@ -1,864 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 6: Training Hyperparamters\n", - "\n", - "### Regularization helps interpretability by making KANs sparser. This may require some hyperparamter tuning. Let's see how hyperparameters can affect training" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "### Load KAN and create_dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### Default setup" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.69e-01 | test loss: 1.50e-01 | reg: 5.01e+00 : 100%|██| 20/20 [00:12<00:00, 1.59it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo/klEQVR4nO3de1xUdd4H8M+ZYSBAEkFMDW8gBl3MW5uXVdPHBExNIgViZjXLe2Jt226r2/rsa2u322aQhagZMIMBcjGNgN3n5a2LtY+W17wUKIaliDDK1Rlmfs8fzwOP5Y3LmTlz+bxfL//BmeHDT46fOefM+R5JCCFAREQkI5XSAYiIyPWwXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikp2H0gGInIEQAhcvXkR9fT26deuGwMBASJKkdCwih8U9F6KbMBqNSE5ORlhYGIKCgjBo0CAEBQUhLCwMycnJMBqNSkckckgS70RJdH2lpaWIjY1FY2MjgP/de2nVutfi4+OD/Px8REZGKpKRyFGxXIiuo7S0FI888giEELBarTd8nEqlgiRJKCoqYsEQXYXlQvQLRqMRwcHBaGpqummxtFKpVPD29kZlZSX8/f1tH5DICfCcC9EvZGRkoLGxsV3FAgBWqxWNjY3IzMy0cTIi58E9F6KrCCEQFhaG8vJydGTTkCQJISEh+O677/gpMiKwXIh+prq6GkFBQV16fmBgoIyJiJwTD4sRXaW+vr5Lz6+rq5MpCZFzY7kQXaVbt25der6fn59MSYicG8uF6CqBgYEIDQ3t8HkTSZIQGhqKgIAAGyUjci4sF6KrSJKE5cuXd/h5QggkJSXxZD7R/2G5EP3C3Llz4ePjA5Wq/ZuHh4cHfvWrX9kwFZFzYbkQ/YK/vz/y8/MhSdItC0alUkGlUuHJJ5/Exo0bkZeXh5aWFjslJXJc/Cgy0Q20d7ZYQUEBHn74YZSWliI/Px/9+/fHokWL0KtXL0VyEzkClgvRTRiNRmRmZiIlJQVlZWVtXw8NDUVSUhLmzp2L7t27t3399OnTSEtLw6VLl6DVajFmzBiehyG3xHIhagchBGpqalBXVwc/Pz8EBATcsDSam5uRlZWFL774Ag8++CB0Oh28vb3tnJhIWSwXIhv56quvoNfr4evri0WLFiEkJETpSER2w3IhsqHq6mqkpaXh9OnTmDVrFqKjozv0KTQiZ8VyIbIxi8WCbdu2oaioCEOGDMGCBQvQo0cPpWMR2RTLhchOTpw4gQ0bNsBkMuHJJ5/E8OHDlY5EZDMsFyI7qq+vR3p6Or755htMmjQJc+bMgaenp9KxiGTHciGyMyEEdu/ejezsbAQFBWHRokUIDg5WOhaRrFguRAr58ccfkZaWhnPnziEuLg6TJk3iNTHkMlguRAoym83Izc3Fjh07cP/992P+/PldHvtP5AhYLkQO4ODBg9i0aRPUajUWLFiAiIgIpSMRdQnLhchBGI1GbNy4EcePH0d0dDRmzZoFtVqtdCyiTmG5EDkQIQRKSkpQUFCAAQMGYOHChRyASU6J5ULkgE6dOoX169fj8uXLbQMwiZwJy4XIQTU3N8NgMGDv3r0YPXo0tFotB2CS02C5EDm4L7/8Enq9Hn5+fli4cCEHYJJTYLkQOYELFy4gLS0NFRUViImJQVRUFAdgkkNjuRA5CYvFgq1bt6K4uBh33XUXnn76aQ7AJIfFciFyMseOHcPGjRvR0tKCJ598EsOGDVM6EtE1WC5ETujqAZiTJ0/G7NmzOQCTHArLhchJCSGwa9cu5OTkoFevXli0aBHuvPNOpWMRAWC5EDm9s2fPIi0tDVVVVYiLi8NDDz3EAZikOJYLkQswmUzYsmULduzYgeHDh2PevHkcgEmKYrkQuZADBw7ggw8+gIeHBxYsWIDw8HClI5GbYrkQuZja2lps3LgRJ06c4ABMUgzLhcgFWa1WlJSUoLCwEAMHDsTChQsRFBSkdCxyIywXIhd26tQppKWloa6uDjqdDqNHj1Y6ErkJlguRi2tqakJWVhb27t2LMWPGQKvV4rbbblM6Frk4lguRm9i7dy/0ej26d++OhQsXYtCgQUpHIhfGciFyI1VVVVi/fj0qKirw2GOPISoqitfEkE2wXIjczNUDMMPDw/H000/D399f6VjkYlguRG7q2LFj2LBhAywWC+bPn4/7779f6UjkQlguRG6svr4emzZtwsGDBzF58mTMmTMHGo1G6VjkAlguRG5OCIGdO3ciJycHvXv3xqJFi9C3b1+lY5GTY7kQEQCgsrISaWlpuHDhAuLj4zFx4kSe7KdOY7kQURuTyYTc3Fzs3LmTAzCpS1guRHSNb775Bh988AE8PT2xYMEC3HXXXUpHIifDciGi66qtrcWGDRtw8uRJPPLII5g5cyYHYFK7sVyI6IasViuKi4uxdetWDBw4EIsWLULPnj2VjkVOgOVCRLdUXl6OtLQ0NDQ0QKfT4cEHH1Q6Ejk4lgsRtUtTUxP0ej2++uorjB07FomJiRyASTfEciGidhNCYO/evTAYDOjevTsWLVqEgQMHKh2LHBDLhYg6rKqqCmlpaThz5gxiY2MRGRnJa2LoZ1guRNQpLS0tbQMw7777bjz99NPo3r270rHIQbBciKhLvv32W2zcuBEWiwVPPfUUhg4dqnQkcgAsFyLqsrq6OmzatAmHDh3Cf/zHf2D27NkcgOnmWC5EJAshBHbs2IHc3Fz07t0bixcvRp8+fZSORQphuRCRrCorK7Fu3TpcvHgR8fHxmDBhAk/2uyGWCxHJzmQyITs7G7t378aIESPw9NNPw8vLS+lYZEcsFyLqkI78l1FdXY0LFy4gIiKiw9+HezvOjeVCRB3y0UcfoV+/fjZ7fZPJhObmZjz00EM2+x5kex5KByAi5/LTTz9hxowZNnntM2fOICMjA0FBQSwXJ6dSOgARORdJkqBSqWT/I0kS1qxZg0mTJin9I5IMWC5E5BA+++wzCCEwfvx4paOQDFguRKQ4s9kMvV6P3/3udzyR7yJYLkSkKCEE1q1bhyFDhtj0gwJkXzyhT0SK+umnn3Do0CGsXbuWey0uhHsuRKQYIQRef/11JCQk8CJLF8NyISLF7NixA5Ik8RNiLojlQkSKMJvNyM7OxgsvvMDDYS6I5UJEdieEQGpqKsLDwzk52UXxhD4R2d2FCxdw6NAhvPvuu9xrcVHccyEiuxJC4LXXXkNsbCxP4rswlgsR2dWePXtgNpsRFRWldBSyIZYLEdlNU1MTDAYDT+K7AZYLEdmFEAJvvvkmHnzwQQQHBysdh2yM5UJENieEwCeffIKamho8+eST3GtxAywXIrIpIQQOHTqEbdu2YeXKlVCr1UpHIjtguRCRzQghcPToUaSmpiIpKQlBQUFKRyI74XUuRGQTQgh8/vnn2Lx5MxYsWIC7775b6UhkRywXIpJdU1MT8vLy8PXXX2PFihUYMmQIz7O4GZYLEcmmpaUFR44cQV5eHnr06IGXXnoJAQEBSsciBbBciKjDKioq4OfnB41GA4vFgrq6OpSVleHLL7+E0WhEdHQ0xo0bBw8P/hfjrvgvT0QdtmHDBlgsFqhUKgghAABBQUEYM2YMRo0aBR8fHx4Gc3MsFyLqEA8PD0yfPh2NjY0wm81Qq9Xw8fGBj48PVCoVysrKuvw9AgMDZUhKSpJE69sOIqJ2MJlMNv8eKpWKh9ScHMuFiGzGYrGgsbERPj4+vHjSzfAiSiKymcrKSjz77LOorKxUOgrZGcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdh5KB+gKIQQuXryI+vp6dOvWDYGBgZAkSelYDo1r1jlct44TQqCmpgb19fWoqalB//79uWbt4Cq/a06552I0GpGcnIywsDAEBQVh0KBBCAoKQlhYGJKTk2E0GpWO6HC4Zp3Ddeu4q9dsxIgRyM3NxYgRI7hmt+Byv2vCyZSUlAhfX18hSZKQJEkAaPvT+jVfX19RUlKidFSHwTXrHK5bx3HNOscV182pyqWkpESo1WqhUql+tvi//KNSqYRarXaqfwhb4Zp1Dtet47hmneOq6yYJIYTce0O2YDQaERwcjKamJlit1ls+XqVSwdvbG5WVlfD397d9QAfENescrlvHcc06x5XXzWnOuWRkZKCxsbFd/wAAYLVa0djYiMzMTBsnc1xcs87hunUc16xzXHndnGLPRQiBsLAwlJeXoyNxJUlCSEgIvvvuO6f8tEVXcM06h+vWcVyzznH1dXOKcqmurkZQUFCXnh8YGChjIsfHNescrlvHcc06x9XXzSkOi9XX13fp+XV1dTIlcR5cs87hunUc16xzXH3dnKJcunXr1qXn+/n5yZTEeXDNOofr1nFcs85x9XVzinIJDAxEaGhoh48vSpKE0NBQBAQE2CiZ4+KadQ7XrWNOnTqF1NRUeHp6dvi57rpmrVz9d80pykWSJCxfvrxTz01KSnLok162wjXrHK7brVksFpSWlkKn02Hy5MkoLCzE1KlTO/Va7rJm1+Pqv2tOcUIfcO3Pg9sK16xzuG7XV1VVhZycHGzevBnnzp3DiBEjoNPpEB0djaampg6tmSRJ8Pb2xtmzZ116zW7FlX/XnGLPBQD8/f2Rn58PSZKgUt08tkqlgiRJKCgocPh/AFvimnUO1+3/CSHw5ZdfYtmyZRg7dixSU1MxadIkFBUVIT8/H7NmzYKXl1eH1qz1HXdsbKw9fgSH5tK/a3aeCNBl7Z3BU1paqnRUh8E16xx3XrfLly+L9PR0MWXKFDFw4EAxZcoUkZ6eLi5fvnzT57V3zXJzc8Wf/vQn8dJLL4nq6mo7/VSOyxV/15yuXIQQora2ViQnJ4vQ0NCf/SOEhoaK5ORkYTQalY7ocLhmneNu63b06FHxxz/+UURERIjQ0FCxdOlSsXfvXmG1Wtv9Gu1ds4sXL4rVq1eLlStXivPnz9vqR3Iarva75jTnXK5H/N/9Iurq6uDn54eAgACHP8mlNK5Z57jyul25cgXFxcXQ6/X4+uuv0bt3bzzxxBOIi4tDr169Ov267VmzS5cu4Z133kF9fT2SkpLQt2/frv44Ts9VfteculyIqPPOnDmDzZs3Izc3F7W1tfj1r38NrVaLKVOmQK1W2y1HfX09UlJSYDQasXz5cvTr189u35tsh+VC5EYsFgt2794Ng8GAXbt2wc/PD7Nnz0ZiYiIGDRqkWK7GxkasXbsWVVVVeOaZZzBw4EDFspA8WC5EbuDixYvIzc1FVlYWzp49i/vuuw86nQ7Tp0+Ht7e30vEAAM3NzXjvvfdQWVmJpUuXYvDgwUpHoi5guRC5KCEE9u/fD4PBgKKiIqjVasycORNarRZDhw5VOt51mUwmrFu3DuXl5Vi8eDHCw8OVjkSdxHIhcjENDQ3YunUr9Ho9Tpw4gQEDBkCr1eLxxx93iusjzGYzNmzYgBMnTmDBggW49957lY5EncByIXIRJ0+eRFZWFvLz89HU1IQpU6ZAp9Nh7Nixt7xAz9G0tLRg06ZNOHLkCObPn49hw4YpHYk6iOVC5MTMZjNKS0uh1+vx73//G0FBQYiPj0dCQgL69OmjdLwusVgsyMzMxNdff43f/OY3eOCBB5SORB3goXQAIuq4H3/8ER9++CGys7NRXV2N0aNHY+3atZg6dSo0Go3S8WShVqsxd+5caDQaZGRkwGw2Y+zYsUrHonZiuRA5CavVis8++wx6vR47duyAj48PHnvsMWi1WoSFhSkdzyZUKhUSExPh4eGBrKwsmM1mTJw4UelY1A4sFyIHV1tbi7y8PGRlZaGiogIRERF4+eWX8eijj8LHx0fpeDYnSRLi4uLg6emJ3NxcmM1mTJkyRelYdAssFyIHJITAoUOHoNfrsX37dggh8Mgjj+Ctt97C8OHDnXIcSFdIkoSYmBhoNBoUFhbCZDIhOjra7dbBmbBciBxIU1MTtm3bBoPBgCNHjiA4OBjPPfcc5syZ4/B3HrQ1SZIwY8YMeHp6Ytu2bTCbzZg5cyYLxkGxXIgcQHl5OQwGA/Lz81FXV4dJkyZh06ZNmDBhgl3nfDmDyMhIeHp6Ii8vD2azGbGxsSwYB8RyIVKIxWLBv/71LxgMBnz++efo0aMHEhMTkZCQwOGNtzBp0iR4eHggOzsbZrMZ8fHxLBgHw3IhsrPz588jOzsbH374Ic6fP4+RI0dizZo1mDZtGjw9PZWO5zTGjx8PjUYDg8EAs9kMrVbrdBeLujKWC5EdCCGwd+9eGAwG/POf/4SXlxdmzZoFrVaLiIgIpeM5rdGjR0Oj0SA9PR1msxnz5s3jYUQHwSv0iWzo8uXLKCgogMFgQFlZGcLCwqDVahETEwM/Pz+l47mMgwcP4v3338c999yDp556Ch4efN+sNJYLkQ0cOXIEBoMB27Ztg8lkQlRUFHQ6HX71q1/x3ICNfPvtt1i/fj0GDx6MhQsX8hCjwlguRDK5cuUKioqKoNfrceDAAfTu3RuJiYmIi4tDUFCQ0vHcwokTJ7Bu3ToMGDAAS5YsgZeXl9KR3BbLhaiLKioqkJWVhby8PNTW1mL8+PHQ6XSYPHkyj/8roLy8HO+++y769OmDZcuWOczN0NwNy4WoEywWC3bt2gW9Xo/du3eje/fumDNnDp544gneotcBVFRUYO3atejZsyeeeeYZ+Pr6Kh3J7bBciDqguroaOTk52Lx5M3788UcMHTq07XbBt912m9Lx6Cpnz55FSkoKbr/9diQlJfEDFHbGciG6BSEE9u3bB71ej+LiYqjVajz66KPQarW47777lI5HN3Hu3DmkpKTgtttuQ1JSklPcidNVsFyIbqC+vh6FhYUwGAw4efIkBg4cCJ1Oh9jYWHTv3l3peNROFy5cQEpKClQqFVasWOH2M9rsheVC9AsnTpyAwWBAQUEBrly5gocffhharRZjxozhFeBOqqamBsnJybBYLFixYgU/vWcHLBciACaTCSUlJdDr9di3bx+CgoKQkJCAhIQE9O7dW+l4JAOj0YiUlBQ0Nzdj+fLlTn8baEfHciG3dvbs2bbbBV+8eBFjxoyBTqfDww8/zKu8XVBdXR1SUlJw+fJlJCUl4c4771Q6kstiuZDbsVqt+PTTT6HX67Fz5074+Pjg8ccfR2JiIgYPHqx0PLKxhoYGrF27FtXV1XjmmWcwYMAApSO5JJYLuY3a2lps2bIFWVlZOHPmDO6++27odDrMnDnTLW4XTP+vqakJ7733Hn788UcsXboUoaGhSkdyOSwXcmlCCBw4cAAGgwEff/wxhBCYPn06dDodhg0bxjlfbuzKlStITU1FRUUFFi9ejLvuukvpSC6F5UIuqbGxEdu3b4der8fRo0fRr18/aLVazJ49Gz169FA6HjkIs9mMtLQ0fP/991iwYAHuuecepSO5DJYLuZSysrK22wXX19dj8uTJ0Gq1mDBhAj9GTNfV0tKC999/H0ePHsVTTz2F+++/X+lILoHlQk6vpaWl7XbBX3zxBQICAhAfH4+EhAQEBwcrHY+cgMViQXp6Og4cOIB58+Zh5MiRSkdyeiwXclrnzp1ru11wVVUVRo0aBZ1Oh6ioKN7LgzrMarUiKysLX331FbRaLUaPHq10JKfGD/KTUxFC4IsvvoDBYMC//vUveHl54bHHHoNWq+UJWeoSlUoFrVYLDw8P6PV6mM1mjB8/XulYTovlQk7h0qVLyM/PR1ZWFsrLyzFkyBCsXr0aMTEx6Natm9LxyEVIkoT4+HhoNBpkZ2fDbDZj8uTJSsdySiwXcmiHDx9GVlYWPvroI7S0tCA6OhqvvvoqRo0axY8Rk01IkoTY2Fh4enoiPz+/7TbV1DEsF3I4zc3NbbcLPnjwIPr06YNnnnkGcXFx6Nmzp9LxyA1IkoSZM2fC09MT27dvh9lsxvTp0/mGpgNYLuQwWm8XvGXLFhiNRkycOBEbNmzApEmTeLtgUkRUVBQ8PDxQWFgIs9mMmJgYFkw7sVxIURaLBTt27IDBYMCePXvg7++P2bNnIzExkTOfyCFMmTIFGo0Gubm5MJlMiIuLY8G0A8uFFHHhwoW22wX/9NNPGDZsGP7xj39g2rRpvF0wOZyJEyfC09MTWVlZMJvNSExM5EW5t8ByIbsRQuC///u/224XrNFo2m4XfO+99yodj+imxowZAw8PD2RmZsJsNmPu3Lk8XHsTLBeyufr6ehQUFCArKwsnT55ESEgIVq1ahdjYWNx+++1KxyNqtwceeAAajQabNm1CS0sL5s+fz/v+3ACv0CebOX78OAwGAwoLC3HlyhVMnTq17XbBPGZNzuzIkSPYsGED7rrrLixYsAAajUbpSA6H5UKyMplMKC4uhsFgwL59+3DHHXcgISEBcXFxvF0wuZQTJ05g3bp1GDRoEBYvXsyRQ7/AciFZVFZWYvPmzcjJyUFNTQ3GjRuHxMRE3i6YXNr333+P1NRU9O3bF8uWLeOHUa7CcqEuuXDhAl588UXs3LkT3bp1a7tdMO/sR+7i9OnTWLt2LXr16oVly5bB19dX6UgOgeVC15WSktKuQZBCCFRXV8PHxwc+Pj7XnEtpamqCt7f3dZ9bU1ODhIQEWfISye2TTz5B37592/XYhoYGnDp1ChEREe3+BFlLSwuuXLmCcePGdSWmw+LxCrqukydPYsmSJV16jczMTOTl5WHkyJH485//fE3xrFixguVCDuunn37C6NGj0b1793Y9viMj+i9duoSNGzeiR48eLlsuvAqIrkuSJGg0mk7/+fe//43XX38dzz33HEpLS5Genn7NY4gcmSRJ+Mc//oHGxkao1WpZ/2RkZOCOO+5Q+ke0KZYLyU4IgYULF+Ktt97C1KlTsXnzZrz22muwWq1KRyPqkLvvvhvvvvuurK8phMD333+PuLg4WV/X0bBcSHaffvophBCYNm0aAGDw4MHw9/dHfn6+wsmIOiYuLg4//PCDrG+M6uvrAQBeXl6yvaYjYrmQ7JYvX45XX3217RyLJElYu3Yt/vznP4OfHyFn4uHhAT8/P3z11VeyvWZ+fj6GDBni8hcSs1xIViaTCZcvX8aMGTN+9vXRo0ejubkZjY2NCiUj6pyEhARZ97r379/vFh9kYbmQrFqvWP7luzJJkvDAAw9g9erVCiUj6pz77rsPTU1Nsux1CyFgtVoRFBQkQzLHxnIhWb377rt46623rvt3ycnJKCgo4KExciqto/UvXbrU5deqrKyEWq12+UNiAMuFZGS1WmEymXD//fdf9+979+4NSZJw9uxZOycj6prw8HAUFBR0+XWys7MxZswYGRI5PpYLyea//uu/4Ofnd8N3ZZIkQavVdvniTCJ7mz17Nr755psuv87p06evOR/pqniFPsnmpZdewosvvnjTx6xcuRLh4eFobm62UyqirrvjjjtgtVohhOj0Ia3WjzO7y+wx7rmQLIQQqKqqwuzZs2/6OC8vLzz44IN49tln7ROMSAaSJEGSJNTU1HT6NY4fPw4vLy+3ON8CsFzoJlpaWtr92Orq6raRMbeyYcMGDB48uCvRiOzunnvu6dJHknNychAVFSVjIsfGcqEbWrRoEUwmU7se+5e//AW//vWv2/VYPz8/PP/8812JRmR3jz/+OA4fPtyp57ZOD3/ooYfkDeXAWC50QzU1NXj22Wfb9dHh4uJi/O1vf2v3a7vLoQFyHT179mw779JRTU1NAOBWA1tZLnRDmZmZKCkpQWVl5U0f19LSAqvVijvvvNNOyYjsr/Ww76lTpzr83JycHLcY+XI1lgvdkJ+fH5YuXQqdTnfTd2s5OTno1auXW2045J4efvhhGAyGDj1HCIF9+/bhN7/5jY1SOSaWC93Uc889hx9++AEVFRU3fMzf//53vPbaa3ZMRaSMqVOn4vz58x06NFZZWQmVSgV/f3/bBXNALBe6KbVajWXLlmHu3LnX3aBaWlrQ0NCACRMmKJCOyL40Gg08PT1x7Nixdj1eCIHU1FTExMS43Z49y4VuacWKFaisrLzuseb169ejX79+bfOXiFydVqvFpk2b2rX3sn//fjQ1NbnVp8Ra8X8EuiW1Wo1nn332mnMvQgisWbMGaWlpCqYjsq8RI0bAbDbfdO9FCIHvvvsOmZmZWLJkiVu++XK/n5g6ZdmyZbh8+TK2bNkCIQSEEMjOzoavry/Cw8OVjkdkN5IkYf78+Vi/fj1qa2uvecNlNBrx8ccfIy0tDY8//jjCwsIUTKsczhajdlGpVMjMzERcXBy8vLzg6+uL1atXY8uWLW53LJlo6NChGD16NN58803MmDEDffv2RWNjI7799lt888036NmzJ5YsWYKQkBC33T5YLnRDvzymPGzYMKxZswYpKSmwWCz461//iqFDh/L+LOSybva7PWfOHNx555349NNP0djYCLVajeDgYCQkJCAsLAweHh63fA1XxnKh6woICMA///nPa77u4eGBhQsXwmq14vbbb7/uY9orIiKiKxGJbMrX1xcHDx686WP8/PwwadIkNDU1QaPR4LbbboPJZMLRo0fb9T2Cg4PliOqQJOGutUo31ZGhlZ0lSRLUarXNvw9RZ1gsFpt/D0mSXPZkP8uFusRqteLixYu4/fbb4eXlpXQcIkU0NDSgrKwM4eHh8PT0VDqOQ3DNyiS7+etf/4rx48ffcv4YkatqaWnBO++8g48++shtT95fD8uFOu2zzz5Deno6XnzxRYSGhiodh0gRxcXFOHv2LObOnetWU49vheVCnXLp0iW88MILGDdunNsN5CNqderUKZSWlmLatGno37+/0nEcCsuFOmX16tVoaGjAG2+84bInJIluxmQyISMjAwMGDEBkZKTScRwOP4pMHVZUVISPPvoIa9asQZ8+fZSOQ6SIgoICGI1GLF26lG+wroMrQh1y/vx5rFq1CtOmTcOjjz6qdBwiRXz77bf49NNP8dhjj6FXr15Kx3FILBdqNyEEfv/738PLywsvv/wyPxlDbqmhoQEGgwEREREYP3680nEcFg+LUbtlZWVhz549SE9PR48ePZSOQ2R3rQNbW1paoNPp+AbrJrjnQu1y6tQpvPLKK9BqtZg4caLScYgUsW/fPnz99deIj49H9+7dlY7j0HiFPt2SxWJBbGwsLl26hKKiIvj4+Cgdicjuamtr8corr+Dee+/FvHnzlI7j8HhYjG7pvffew+HDh5GXl8diIbckhIBer4eXlxfmzJmjdBynwMNidFOHDx9GcnIyli5diuHDhysdh0gRu3fvxokTJ6DT6fgGq514WIxuqLm5GdOnT4e3tzcKCwvb7k9B5E7OnTuHV199FePGjcPs2bOVjuM0+L8F3dDrr7+OyspKbN++ncVCbslisSAjIwMBAQG8rquDeFiMruvzzz/HBx98gD/84Q9uew9wopKSElRWVmLevHkcpd9BLBe6xuXLl/G73/0O48aNw9y5c5WOQ6SI06dPo6SkBNHR0RxK2QksF7oGh1KSu2sdStm/f39ERUUpHccp8UA6/cwnn3yCrVu3ciglubXCwkLU1tZiyZIlfIPVSVw1alNVVYVVq1YhOjqaJy/JbR07dgx79uxBTEwMh1J2AcuFAPzvRWJ/+MMfoNFo8Morr3BmErmlhoYG6PV6REREYMKECUrHcWo8LEYAgM2bN2PXrl344IMPOJSS3FZOTg7MZjO0Wi3fYHUR91wIp0+fxiuvvILExEQ89NBDSschUsS+ffuwf/9+xMfHw9/fX+k4To/l4uYsFguee+459OrVCytXrlQ6DpEijEYjsrOzMWrUKIwcOVLpOC6Bh8XcXGpqKg4dOsShlOS2rh5KGRcXp3Qcl8E9Fzd2+PBhvP322xxKSW5t9+7dOH78OIdSyoyDK91Uc3MzZsyYAS8vLxQWFkKj0Sgdicjuzp8/j7///e8YO3YsR+nLjIfF3NQbb7yBM2fO4OOPP2axkFuyWCxIT09HQEAAZs2apXQcl8PDYm7oiy++wKZNmziUktxa61DKuXPnciilDbBc3EzrUMqxY8fyVq3ktq4eSjlgwACl47gkloubWb16Nerq6jiUktxW61DKfv36ITIyUuk4LovnXNxIcXExtm7dirfeegt9+/ZVOg6RIrZu3Yra2losXrwYarVa6Tgui29d3URVVRVWrlyJ6Ohonrwkt3Xs2DHs3r0bMTExuOOOO5SO49JYLm6gdSilh4cHh1KS22odShkeHs6hlHbAw2Ju4MMPP8SuXbvw/vvvcyglua2cnByYTCbodDq+wbID7rm4uIqKCrz88st44oknMHnyZKXjECli//792L9/PxISEjiU0k5YLi7MYrHgt7/9LXr16oVVq1YpHYdIEUajER9++CFGjhzJoZR2xMNiLiw1NRUHDhzAli1bODOJ3FLrUEpPT08OpbQz7rm4qCNHjuDtt9/GkiVLMGLECKXjECliz549bUMpfX19lY7jVji40gVduXIFM2bMgKenJ4dSktviUEpl8bCYC3rjjTdQUVGB7du3s1jILVksFmRkZKBHjx68rkshPCzmYvbu3Yv3338fL7zwAoYMGaJ0HCJFlJaW4ocffuBQSgWxXFxIXV0dnn/+eYwZMwbz589XOg6RIioqKlBcXIyoqCgMHDhQ6Thui+XiQv7zP/8TdXV1ePPNNzmUktxS61DK4OBgREVFKR3HrfF/IBdRXFyMgoIC/OUvf+FQSnJbW7duRU1NDebNm8ehlApjubiAqqoqrFq1ClFRUYiJiVE6DpEijh8/jt27d2PWrFkcSukAWC5OTgiBF198EWq1Gn/72984M4ncUmNjY9tQyokTJyodh8CPIju97Oxs7Ny5k0Mpya3l5OTgypUrHErpQLjn4sRah1LGx8dzKCW5rf3792Pfvn2Ii4vjUEoHwj0XJyCEwMWLF1FfX49u3bohMDAQVqsVzz//PHr27ImXXnpJ6YhENne97eDSpUvIzs7GyJEjMWrUKKUj0lVYLg7MaDQiIyMD77zzDsrKytq+HhoaiuHDh2P//v3Iy8vjUEpyaTfaDkJCQjB8+HD0798fcXFxPBzmYFguDqq0tBSxsbFobGy85u/KyspQVlYGjUaD6upqBdIR2cfNtoPy8nKUl5fD29sbkZGRiIyMVCAh3QgHVzqg0tJSPPLIIxBCwGq13vBxkiRBpVKhqKiIGxa5nPZuByqVCpIkcTtwMCwXB2M0GhEcHIympqabblCtVCoVvL29UVlZyZOZ5DK4HTg/flrMwWRkZKCxsbFdGxQAWK1WNDY2IjMz08bJiOyH24Hz456LAxFCICwsDOXl5ejIP4skSQgJCcF3333Hk5rk9LgduAaWiwOprq5GUFBQl54fGBgoYyIi++N24Bp4WMyB1NfXd+n5dXV1MiUhUg63A9fAcnEg3bp169Lz/fz8ZEpCpBxuB66B5eJAAgMDERoa2uHjxZIkITQ0FAEBATZKRmQ/3A5cA8vFgUiShOXLl3fquUlJSTyJSS6B24Fr4Al9B8PP9xNxO3AF3HNxMP7+/sjPz2+7+v5mWq9MLigo4AZFLoXbgfNjuTigyMhIFBUVwdvbG5IkXbOb3/o1b29vfPLJJ5g6dapCSYlsh9uBc2O5OKjIyEhUVlbi7bffRkhIyM/+LiQkBG+//TbOnj3LDYpcGrcD58VzLk5ACIGamhrU1dXBz88PAQEBPGlJbofbgXNhuRARkex4WIyIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItn9D0HDRORUqKCOAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.1);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "07f400a8", - "metadata": {}, - "source": [ - "### Parameter 1: $\\lambda$, overall penalty strength. Previously $\\lambda=0.1$, now we try different $\\lambda$." - ] - }, - { - "cell_type": "markdown", - "id": "9916490a", - "metadata": {}, - "source": [ - "$\\lambda=0$" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "77e8cafd", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.16e-03 | test loss: 5.00e-03 | reg: 1.24e+01 : 100%|██| 20/20 [00:10<00:00, 1.86it/s]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1XklEQVR4nO2dd3xUZdr+rzNJJpn0CqQQSEJCCEnovahUpUhTV4qigm1XUURdfdd1V93f7lqwrm1FUaRZqAlIEVBCJ0AglUx679P7zDm/P3jPeQMkMDM5M3Nm8nw/n/knmTnnnmfOOddT7vt6KIZhGBAIBAKBwCMiVwdAIBAIBM+DiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4x9vVARAI7gDDMGhvb4darUZgYCAiIiJAUZSrwyIQBAsZuRAIt0Aul+Ojjz5CcnIyoqKikJCQgKioKCQnJ+Ojjz6CXC53dYgEgiChyE6UBELXHDx4EEuWLIFWqwVwbfTCwo5a/P39sWPHDsyePdslMRIIQoWIC4HQBQcPHsTcuXPBMAxomu72fSKRCBRFYd++fURgCIROEHEhEG5ALpcjLi4OOp3ulsLCIhKJIJFIUFdXh9DQUMcHSCC4AWTNhUC4ge+++w5ardYqYQEAmqah1WqxadMmB0dGILgPZORCIHSCYRgkJyejoqICttwaFEUhMTERUqmUZJERCCDiQiBcR1tbG6Kionr0+YiICB4jIhDcEzItRiB0Qq1W9+jzKpWKp0gIBPeGiAuB0AmJRNKjzwcFBfEUCYHg3hBxIfR6aJqGRqNBa2srTCYTBgwYYNdxoqKiUFRUhObmZp4jJBDcD2L/QuiVMAwDvV4PnU4HvV4PhmHg5+eH8PBwLF68GB988IHNx1yxYgWqq6tRVFSEkJAQJCcnY9CgQQgJCXHANyAQhA0RF0Kvwmg0QqvVcjUsPj4+CA4OhkQigdlsxvbt29HR0QGxWAyTyWR1xpi3tzcWLVqEyZMno6GhAaWlpbh8+TJyc3PRt29fJCcnIykpCX5+fg7+hgSCMCDZYgSPx2w2Q6vVQqvVwmKxwMvLC/7+/pBIJPDx8QEAVFdXY8OGDVAoFFi6dCkUCgXmzZtnVYU+ADz44IPQaDRYtGgRli9fDm9vb5jNZlRVVUEqlaK2thYURSE+Ph7JyckYMGAAvLy8nPL9CQRXQMSF4JGwhY06nQ5GoxEURUEikcDf3x++vr7c+xiGweHDh7F7927ExcVh9erV6NOnDwDrvcV27tyJmTNnYvfu3fj++++RkJCAF198EdHR0dz7dTodysvLUVpaitbWVojFYiQmJiIlJQX9+vUjtTEEj4OIC8FjYNdRtFot9Ho9AMDPzw/+/v7w8/O76QGuUCiwceNGFBcXY9asWViwYAG8va+fKZbL5di0aRM+/vhjlJeXc39PSkrCmjVrsHLlyuvWVMrKyvDee+9BJpPhqaeewp133nnTeeVyOaRSKaRSKVQqFQIDA5GcnIzk5GSEhYXx3SwEgksg4kJwewwGAzdKYRgGYrGYm/Zip61upKCgAN9++y0oisJjjz2GIUOG3PIcDMOgoqICv/zyC+655x4kJiZ2O9rQ6XT473//i6NHj2Lq1Kl4+umn4e/v3+Uxm5qaIJVKUV5eDqPRiMjISKSkpCApKanLzxAI7gIRF4JbYjKZOEGxWCzw9vbmpr1uHH3c+Lldu3bhyJEjyMjIwMqVK62uTZHJZDh06BBmzZpl1Qjj+PHj+PzzzxEUFIR169Zh8ODB3b7XYrGgpqYGUqkU1dXVYBgGcXFxSE5ORkJCwi2/E4EgRIi4ENwGi8UCnU4HrVYLk8nEuRH7+/tDLBbf9vONjY3YsGEDmpqasGTJEtx11102rXXYKi4A0NzcjPXr10MqlWLZsmVYsmRJt6MpFoPBgPLyckilUjQ1NcHb2xuJiYlITk5GbGwsWZ8huAVEXAiChmEYTlAMBgMoiuLWUXx9fa160DIMgxMnTuCHH35AZGQkVq9ejbi4OJtjsUdcgGuiuG3bNvz8888YOnQoXnjhBav9x5RKJcrKylBaWgqFQgF/f38MGjQIKSkpxMOMIGiIuBAECVvgyK6j+Pr6QiKR3HIdpSu0Wi2+//57XLx4EVOmTMEDDzxg1SinK+wVF5aCggK8//77MBgMWLNmDcaNG2fT51taWiCVSlFWVga9Xo/w8HAuESAgIMDmeAgER0LEhSAYjEYjN0qhaRre3t7w9/eHv7+/XTUhUqkUX3/9NQwGAx5++GGMGDGiR/H1VFyAa8aW//nPf3DmzBncc889eOyxx2wWO5qmUVdXh9LSUlRVVcFisSAmJgYpKSlISEiwWzwJBD4h4kJwKRaLhStwNJvNEIlEnKCwBY62QtM0srOzsX//fgwaNAirVq3iJcWXD3EBrk3THTx4EF9//TX69euHF1980W4/M6PRiMrKSkilUtTX18PLywsDBw5EcnIy+vfvb9Moj0DgEyIuBKdD0zQ3Qulc4CiRSHpsj9Le3o6vv/4alZWVmDdvHu655x7eHrB8iQtLTU0N3nvvPTQ0NOCxxx7DPffc06PFerVajbKyMkilUnR0dMDPzw+DBg1CcnIyVxhKIDgLIi4Ep8AwDFePwhpF+vr6cvUofGRA5ebmYvPmzfD398eqVauQlJTEQ+T/B9/iAlwbeXz77bfYt28fxowZgzVr1iA4OLjHx21vb0dpaSnKysqg1Wo5I83k5GRejk8g3A4iLgSH0pVRJCsofHlrGQwGbN++HadOncLo0aOxfPlyhxQgOkJcWM6fP4+PPvoI3t7eWLt2LYYNG8bLcRmGQX19PaRSKSoqKmA2m9GvXz/OSLOzFQ6BwCdEXAi8wxpF6nQ6mM3mLo0i+aKmpgYbNmyAXC7Hgw8+iAkTJjisDsSR4gIAHR0d+PDDD3HlyhUsXrwYy5cv59XckjXSLC0tRV1dHWekmZKSgvj4eGKkSeAVIi4EXuhuHeVGo0i+YBgGR44cwc6dOxEbG4vVq1ejb9++vJ+nM44WF+Da99q5cye2bNmCxMREvPjii+jXrx/v59FqtVyhJmukmZSUhOTkZGKkSeAFIi4Eu7HVKJIvlEolvv32WxQWFmLmzJlYuHChU+xRnCEuLFKpFO+99x4UCgVngOkoZDIZZ6SpVqsRFBTErc+EhoY67LwEz4aIC8Fm7DGK5IvOhpOPPPIIhg4d6tDzdcaZ4gJcM8D88ssvcezYMdxxxx146qmnHGpmyRpplpaWoqKiAkajEVFRUdyOmhKJxGHnJngeRFwIVmEymbhpL1uMIvnCbDZj586dOHLkCNLT0/HII49YbTjJF84WF5bff/8dn3/+OUJCQrBu3TqkpKQ4/JwWiwXV1dWQSqWoqanhjDRTUlIwcOBAYqRJuC1EXAjd0lOjSL5oamrChg0b0NjYiMWLF2PatGkuWRNwlbgA19rgvffeQ0VFBZYtW4bFixc7rUBSr9ejoqICpaWlaG5uho+PDxISEpCSkoKYmBiyPkPoEiIuhOvgwyiSz1hOnjyJH374AWFhYXj88cfRv39/p53/RlwpLsA1sd+6dSt27NiB9PR0rF271unmlUqlklufUSgUCAgI4Ao1iZEmoTNEXAgAbjaKdOY6SlfcaDh5//33u7wmw9XiwnLlyhV88MEHMJlMWLNmDcaOHeuSOFpaWlBaWory8nLOSDMlJQWDBg0iRpoEIi69ma423OqJUSRflJWV4euvv4Zer8dDDz2EkSNHuiyWzghFXIBrBpiffPIJzp49izlz5uDRRx91mWElTdOora2FVCrljDRjY2ORnJyMxMRE3mubCO4BEZdeRndGkRKJxOVuujRNY9++fdi3bx8GDRqExx57DOHh4S6NqTNCEhfg2rThL7/8go0bNyI6Ohrr1q2z2wCTL4xGIyoqKiCVStHQ0ABvb2/OSDMuLo4YafYiiLj0Amia5upRXL2O0h2s4WRFRQXmzZuHOXPmCO5BJDRxYamursb69evR2NiIRx99tMcGmHzBGmmWlpZCJpNxRpopKSmIiopydXgEB0PExUNxhlEkX1y4cAHff/89JBIJVq9ezbvhJF8IVVyAayOGjRs3Yv/+/Rg3bhyeffZZp6dq34q2tjZuozOtVovQ0FCuUFNIcRL4g4iLh+EMo0i+MBgM+OGHH3Dy5EmHGk7yhZDFheXcuXP4+OOP4ePjgxdeeAEZGRmuDuk6aJpGQ0MDSktLUVlZyRlppqSkIDEx0eVJGwT+IOLiAZjNZi59mDWKZOtRhLqYWltbi6+++goymQwPPvggJk6cKKjRVFe4g7gA16YYP/jgAxQUFGDJkiVYtmyZ4DoWwLWEkqqqKkilUs5Ic8CAAUhOTiZGmh4AERc3xdlGkXzBGk7u2rUL0dHRePzxxx1uOMkX7iIuwLXrY9euXdiyZQuSkpKwbt06hxhg8oVWq+U2Omtra4Ovr+91RpoE94OIixvhKqNIvuhsODljxgwsWrTIrWxE3ElcWDobYD799NO44447XB3SbZHJZNxGZ52NNFNSUhASEuLq8AhWQsTFDei8ME/TNMRiMTdKEVpGVXcUFhZi48aNAIBHH33UqYaTfOGO4gJcGxV8+eWX+O2333DXXXfhySefdAsTSoZh0NjYyG10ZjQa0adPH26jM3f4Dr0ZIi4Chd1wizWKZDfccpZRJF+YzWbs2rULv/76K4YOHYpHHnnEbbfZdVdxYfntt9/w+eefIzQ0FC+++CKSk5NdHZLVmM1m1NTUoLS0FLW1tWAYBv3790dycjIx0hQoRFwEhFCMIvmiubkZX331FRoaGrB48WJMnz5d8FN3t8LdxQW43gBz+fLlWLx4sdv9Jnq9ntvojDXSTExMRHJyMjHSFBBEXFwMaxSp0+mg1+u5AkeJROIW6yhdwTAMTp06he3btwvCcJIvPEFcgGudmC1btmDnzp3IzMzE888/LygnBFtQKBSckaZSqURAQABXP+Ou38lTIOLiIly54ZYj0Wq12LJlC3JzczFp0iT84Q9/EHT2mi14iriwXL58GR988AHMZjOee+45jBkzxtUh9Yjm5mbOSNNgMCAiIoLb6IwYaTofIi5OpDujSIlE4hFzxuXl5fj666+h1WqxYsUKjB492tUh8YqniQtwLYPv448/xvnz5zF37lw88sgjbjkF2xmaplFTUwOpVIrq6mrOSDMlJQUJCQmCrf3yNIi4OBjWKFKn03HrKEIxiuQLmqaxf/9+ZGdnIzExEatWrfLIvT08UVyA/zPA/OabbxATE4MXX3wR8fHxrg6LF1gjzdLSUjQ2NnJGmikpKYiNjXXrWQKhQ8TFAbiDUSRfdHR04Ouvv0Z5eTnmzp2LuXPneuwN66niwlJdXY333nsPTU1NWLVqFWbPnu1R16pKpeKMNOVyOSQSCbfRGTHS5B8iLjzhTkaRfHHx4kV8//338PX1xapVq9wqtdUePF1cgGs9/W+++Qa//PILxo8fj2eeecYjjSVbW1s5I02dTofQ0FBuozNP/L6ugIhLD3Eno0i+MBgM+Omnn5CTk4ORI0fioYceErThJF/0BnFhOXPmDD755BP4+vrihRdeQHp6uqtDcgg0TaO+vh5SqZQz0oyOjuYKNT1l6toVEHGxA3c0iuSL2tpabNiwAR0dHfjDH/6ASZMmeeSorCt6k7gA1www33//fRQWFuK+++7D0qVLPbbDBFxLuKmsrIRUKkV9fT0oiuI2OouPj/fY6V5HQcTFStzVKJIvGIbB0aNHsXPnTkRHR2P16tW9zlCwt4kLcO2637FjB7Zu3Yrk5GSsW7fObYxGe4JGo0F5eTlKS0vR3t7OGWmmpKT0iu/PB0RcbkFno0iDwQCGYbgCR09dR+kKlUqFb7/9FgUFBZg+fToWL17sEanTttIbxYXl6tWrWL9+PVQqFZ5++mlMnTrV1SE5jY6ODq5QU6PRIDg4mCvUJEaa3UPEpQsMBgNXNd95HcWdjCL5oqioCBs3bgTDMHjkkUc8du7dGnqzuADXCmQ///xzHD9+HNOmTcMTTzzRq8wjWSPN0tJSVFRUwGQyoU+fPkhJSUFSUhL8/PxcHaKgIOLyv3iKUSRfmM1m7N69G4cPH0ZaWhoeffRRtzWc5IveLi7AtQfsb7/9hi+++AJhYWF48cUXMWjQIFeH5XTMZjOqq6shlUpRW1sLAJyR5oABA3rlM+NGerW40DTNCUpno0iJRNIr1lG6o7m5GRs2bEB9fb1HGE7yBRGX/6OxsRHvvfceKisr8dBDD2HhwoW99hrR6/XcRmctLS0Qi8WckWZ0dHSvbZdeJy5dGUWy9SjuahTJFwzD4PTp09i+fTtCQ0OxevVqj6nU5gMiLtdjNps5A8zhw4fj+eef7/XtolAoUFpaCqlUCpVKhcDAQAwaNAgpKSm9rm16jbh4qlEkX2i1WmzduhXnz5/HxIkT8eCDD/bq0VtXEHHpGtYA02Kx4LnnnvM4Tzl7aWpqglQqvc5Iky3U7A11YR4tLp5uFMkXrOGkRqPBQw89RB4O3UDEpXsUCgU+/vhj5ObmYt68eVi5ciUpQPxfLBYLamtrUVpaiurqajAMwxlpDhw40GNr4zxOXDxtwy1HQtM0fvnlF2RnZyMhIcFjDSf5gojLrWEYBvv27cO3336L2NhYvPTSS4iLi3N1WILCYDCgoqICUqmUM9JMSEhAcnKyxxlpeoS4sOsovcEoki9kMhm+/vprlJWVebzhJF8QcbGOqqoqvPvuu2hpacHq1asxa9Yscg92gUql4upn5HI5/P39OSPNyMhIV4fXY9xaXBiGgUwmu8ko0s/Pjzwob0F+fj6++eabXmM4yRdEXKzHYDDg66+/xsGDBzFhwgQ8//zzpA7kFrS2tqK0tBRlZWXQ6/UICwvD2LFjMXDgQFeHZjeCFBdbQpLL5fDx8bFrYd6TelO2tllDQwOSk5Ntnu/1pDYDbGs3jUaDK1euIDMz0+adDT2p3Wxps46ODrS3t9vVgfGkNgOsaze2w9zS0oI+ffrYtVWzUNpNkOKiVCp5XeRiGOamBrdYLAgMDOTtHK4mKyvrtvPbBoOhRxlgKpXK42w/CgoKEBoaatV7WX85WzoyZrMZZrPZowoNt23b5tAetdFohE6nw9133+2wc7iC3Nxch65pms1mmEwmpKWlOewctiDIlCmz2czbngp6vR4qlQpisfi6h0hHR4dHiUtTUxPmzp3b7f/37t2LvLw8pKenY/HixXad46uvvvI4cVEqlQ67GWmaxqFDhxASEuJR4lJXV4cHHnjAIceWSqX44osv0K9fP48TF5lMhpEjRzrk2EajEXv37kVoaKhgxEWwCxMURfX4BVwTkZCQEK5wsvP/PAmKoiASibp8Xb58GUePHsWKFSvw22+/obS0tNv33urlqdjTFta8ZDIZNBqNq7+eQ/Dy8uL9RVEU/v73v2PRokWu/noO4Vb3aE9f58+fF1x5hec+MXAt997Hxwe+vr6IiIiATCazab7YE2AYBhs2bMAzzzyDQYMG4fHHH8dnn33W69rBFVRWVto1Z95b2b59OwIDAz1udOwMSkpKcMcdd7g6jOvwWHFhGAYajQYRERGgKIqrcaFp2sWROZfCwkJ4eXlxC6qZmZkwGo1QqVQujszzqa+vR1JSkqvDcAtUKhV+/PFH/Pvf//bImQVHwjAMaJoWXEfGY8WFFRF2Oofd3Kujo8OVYTmdDRs24NFHH+VuWIqiMHr0aHz99dcujszzMRqNiI6OdnUYgodhGPzlL3/BrFmzPKK+w9m0trZCJBIJTpQ9Vlw6Ojpu2tArNDQURqPRhVE5F4vFAr1ej+HDh1/39+XLl+Pq1atkaswJEFeI23Pq1Ck0NTXhySefdHUobsnRo0cxYsQIV4dxEx4rLkaj8aYUU1ZoestD9dixYwgLC7upR8MWs+n1eleE1StgrzGh9SaFhsFgwPr16/H3v/8dXl5erg7H7WAYBgqFgoiLs+juxmYzxXQ6nSvCcjp79uzBY489dtPfKYpCQkICduzY4YKoege9aYRsLwzD4M0338TIkSMxZMgQV4fjlrBrp0IUZo8UF5VKxaU23khwcDAUCoULonIuDMPAZDJ1W1+xcuVKnDp1yslR9R4qKyttruLvbZw4cQJSqRR//vOfyQjPTg4dOiTYrcc9Vly6834KCAjwWIvrzpSXl8PHx6fbm7Zv376gadpqSwqCbVy9ehWpqamuDkOwKBQKvP/++3jjjTd6xf3oCBiGQXt7O8aNG+fqULrE48SFfRDeaiG1N9jKb9y48ZYV+xRFwcvLCzU1Nbc8jkqlwnfffQeZTMZ3iB6NXq93a9NBR0LTNF555RXcfffdRIB7QGVlJXx8fARXPMniceJiNpsBdL+Q6qkV+p1hezQzZsy45fumTZuGTZs23fI97733HnQ6Hd5//30+Q/Ro2A6OEOfBXQ3DMPjiiy9AURQef/xxj78XHQXDMDh27Nht73FX4nHiIpPJesUWordCqVQCwG17NHPnzkV9fX23/zeZTGhubsYTTzyB+++/n9cYPRmVStUrOjH2cPz4cRw7dgxvv/22R1sKORq5XA6LxYL+/fu7OpRu8ahfl13EDgkJcXUoLmXjxo1WbVXMOiRbLJYu/793717ExsbCy8sLmZmZvMboyZw/f55MiXVBWVkZPvroI7z11lu8GdP2RhiGQVZWFiZMmCDoDozHiQvQu2sLGIZBSUkJli9fftv3UhSF4OBgnDx5ssv/HzlyBKtWreI7RI+GYRi0tbXdVLja22lubsZf/vIXPP300xg8eLCrw3FrysvLYTKZBJslxuJR4sIaVfZWcWEYBkVFRRCLxVbv+rds2TLs2rWry2PRNE3sS2yErW8hGVD/R0dHB1566SXce++9mDFjRq+9P/lAq9Xi6NGjmDt3ruDbUZhpBnbAMAy0Wi369u3r6lBcxpEjR7B3716bFkozMzOh0+lu2lCtrKysVwu1vZw+fRpxcXGk3f6X5uZmvPLKK7jjjjuwbNky0i49QK/XY9euXUhPT3eL55zHjFzYdYPenKFTUlKCiRMn2jRcZveDaGhouO7vmzZtwj333MN3iB4NTdNobm7G2LFjXR2Ky2EYBsXFxVi3bh2mTZuGxx57jAiLnTAMg9bWVuzcuRMxMTGCX2th8ZiRS3t7OwICAtyi0R3FH//4R7uylGbNmoWvvvoKf//73wH838U8c+ZMB0TpuVy5cgVBQUG9fkrMZDJh//792L59O1auXInZs2f36vvSXhiGgUqlQkFBAUpLSzFs2DAMHz7cbdrSbcSFYRhu6ubGxqVpGmazGX369HFRdMLA3tTOuXPn4sCBA1z7srsnCrU4yxHc6EJg6w2s1+tx9epV3HvvvXyG5VbQNA2pVIpNmzZBLpfj73//O1JSUtzmYehq2GecTqdDU1MTKioq0NzcjL59+2L+/PkIDw93q7YU7NPDZDJxDzez2QyFQgGLxQKxWIzg4GBu/wI2O8ff39+tGl5I+Pj4IDAwECdOnMCUKVOwceNGjBgxote0Z1lZGdra2mAymeDl5YWAgAAEBQUhMDAQEokEvr6+8Pb27nZUaDKZcOTIESQnJ0MikbjgG7gOhmFgNptRXl6OrKwsFBYWYtasWVi0aFGvawtbYBNmLBYLDAYDVCoVmpub0dDQAIVCAYlEgvj4eIwePRqhoaFueS8KVlxaW1sRHh4Os9kMpVKJwMBA+Pn5Qa1Wo6WlBSEhIfD19YVGo4HFYkFUVJSrQ3Zr1qxZg3//+98YOnQoCgsL8cEHH7g6JKdRW1uLfv36wdfXF2azGWq1GrW1tdDpdLBYLKAoCn5+fggJCUFkZCRCQ0Ph6+sLhmEgl8uRl5eH4OBgQdqeOwqFQoG2tjYUFhbi9OnTaG1txaRJk/D222+jT58+bvkwdAYajQbV1dVobGyESqWC0WiE2WyGj48PwsLCkJCQgOjo6Os60O6KYMUlNDQUCoUCFEUhPDwcvr6+oCgKYWFh0Ov1UCqVUCqVoCgKUVFRbv0jCIH+/ftj1KhReO+99zBhwoRe1eu84447rhuVsNMTNE3DZDJBp9NBrVajo6MD5eXl123ZIBKJkJCQ0Oumf1555RUAQGxsLKZPn47Ro0cjJCSkV7WBPezatQuhoaGIi4tDYmIi/P39IZFIIJFIuNGxpyBYcRGJRAgKCuIa22AwcP+jKApBQUGwWCzw9vaG2WzmPMWsxdPWE7y8vJCfn9+jY4wZMwbx8fHo27dvl8fyRMNPkUiEpqam277P29sbffr0QWRkJEwmE4xGIzei8fb2vuUxPM2OyNvbGzNnzkRYWBgCAgIgEolQVlbG6zk8cf1UJBIhJSXlupGdXq+HXq/nzRhWSM4HFCNAP3VnheRJvQRnbE4lEok8TpRt7ZTYA+tA7Sl07ug5CpFI5HFZd73tWhOkuNgCu6DoaUNKR2KxWKDVauHv7y+YC9EdoGmaazdiumgdFosFer0efn5+5FqzAYvFAp1OB4lE4rbt5vZ3iNlsRktLi1N6BZ5CfX09XnzxxVs6IhNuRqFQYN++fb1iJ1O+qKqqwrJly1BVVeXqUNwKmUyGLVu2uPU+Sm4vLgQCgUAQHkRcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7bi0uDMOgra0NtbW1aGtrA8Mwrg5J8DAMg46ODqhUKnR0dJA2sxKGYdDe3o7W1la0t7eTdrMC9lrTarXkWrMB9lpjX27bbowbIpPJmA8//JBJSkpiAHCvpKQk5sMPP2RkMpmrQxQcpM3sg7Sb7ZA2sw9Paze3E5cDBw4wAQEBDEVRDEVR1/0I7N8CAgKYAwcOuDpUwUDazD5Iu9kOaTP78MR2cytxOXDgAOPl5cWIRKLrGv/Gl0gkYry8vNzqh3AUpM3sg7Sb7ZA2sw9PbTeKYdxjQk8ulyMuLg46nQ40Td/2/SKRCBKJBHV1dQgNDXV8gAKEtJl9kHazHdJm9uHJ7eY2C/rfffcdtFqtVT8AANA0Da1Wi02bNjk4MuFC2sw+SLvZDmkz+/DkdnOLkQvDMEhOTkZFRYVNmRMURSExMRFSqRQURTkwQuFB2sw+SLvZDmkz+/D0dnMLcWlra0NUVFSPPh8REcFjRMKHtJl9kHazHdJm9uHp7eYW02JqtbpHn1epVDxF4j6QNrMP0m62Q9rMPjy93dxCXAIDA3v0+aCgIJ4icR9Im9kHaTfbIW1mOyqVCiUlJT06htDbzdvVAVhDREQEkpKSbJ6bBICBAwdCJBJBq9XCx8cHPj4+DopSWPSkzeLj4+Hl5QWGYQQ9p+sIIiIiMHDgQFRVVdn82aSkJISHh/MflICpq6tDdnY2AgICoNFobPosu3bQW9pMJpOhoKAA+fn5qK6uBgBERUWhtbXVpuO4S7u5hbhQFIVnn30Wa9eutflza9asgZ+fH4xGIwwGAyiKgo+PD8RiMby9vT324WlvmwHAI488gvr6ejQ3NyMsLAxhYWG9QpR1Oh0uX76MyZMn2yUuy5Yt89jrqTMWiwVnzpxBdnY2Ll68iODgYMyfPx/bt2+3+Vhr1qzx6DZraWnhBKW+vh5eXl5ISUnB/fffj7S0NMTExGDt2rU2dwDdod3cYkEf4Ccf3GKxwGg0wmQywWKxgKIoeHt7QywWw8fHR/A/lq3I5XLExsZCp9NZdfF2bjOJRAKZTAaZTAaaphEUFITw8PAeT4EIEZqmUVJSgoKCAlAUhYSEBNxxxx3Q6/VWXWsURUEsFuPNN99EcnIypk6dKuiFVnvp6OjAL7/8gv3796OtrQ1DhgzB/PnzMWXKFGi1WpvuT4qiIJFIUF9fL/h6DVtgGAYNDQ2coLS0tEAsFiM1NRUZGRkYPHgw/Pz8uPd7cp2L24gLABw8eBBz584FTdO3fFiKRCJQFIX9+/dj1qxZXb7HYrHAZDLBZDLBbDYDADdtJhaLPUJoNBoNsrKysHz5cgC45cXbXZvRNA2FQoGOjg7o9XqIxWJuNOPl5eXw7+Bo6uvrceHCBajVaqSkpCAzMxNisZi71hiGsbrdBg8ejBMnTkAul2Po0KEYP378dQ8Sd4RhGOTn5yMrKwsnT56Et7c3pk+fjnnz5iEpKem691rbZuy99fTTT+Nf//oXgoODHfodHA3DMKiuruYERSaTQSKRIC0tDRkZGUhOTr7lyN+ea62755qQcCtxAa79EIsWLYJOp7vpf+xF6+/vj507d1r9A9A0DZPJBKPRyAlN5xGNSOQWeQ/XoVarodFoEBAQgJMnT2LJkiXQarUAcJ0w29JmOp0OHR0dUCgUAICQkBCEh4dDIpE48Js4BoVCgQsXLqCxsRHR0dEYNWoUQkJCrnvPwYMHbW43mqaRn5+Ps2fPgqIojB07FhkZGW53DWk0Gvz666/Izs5GTU0N4uPjMW/ePMyYMQMBAQHdfs7aNvvuu+9QW1sLiqLw8MMPIywszLFfiGcsFgsqKiqQn5+PwsJCqFQqBAYGIj09HRkZGUhMTLSp83WrdgOutZ2tzzVX43biAgBfffUVfvjhB1RWVqKiooL7e1JSEtasWYOVK1fe9KCwFoZhuKkzk8kE4JrQsCMad3hIsMISGBjIPQjkcjk2bdqEjz/+GOXl5dx77Wkzi8XCTZkZjUb4+fkhPDwcISEhgm8fo9GIK1euoLS0FAEBARg1ahTi4uK6fb+97abT6XD27FkUFBQgLCwMU6ZMQXx8vEO+E5+Ul5cjOzsbR44cgdlsxqRJkzB//nxkZGRYPZq3ts0UCgW+++47mM1mrFy5UvBTiWazGaWlpcjPz0dRURF0Oh3CwsI4QYmPj+/R9d9du8XExGDdunVYtWqV3c81V+B24kLTNF566SVMmDABS5Ys4fYmYdcE+JzOYhjmuhENwzDw8vLihEaI00IqlQparRZBQUHw9/e/6f9Mp/1c+GgztVrNHc/LywuhoaEICwuDr69vT74G7zAMA6lUisuXL4NhGKSnpyM1NdXqh4G97dbW1oacnBzU19dj4MCBmDx5suDmyo1GI3JycpCVlYXi4mJERkZizpw5uOeee3qUkWRNm6lUKmzatAk6nQ4PP/ww+vTp09OvwysGg4FbjysuLobRaESfPn2QkZGB9PR0xMTE8D6F3rndJBIJpFIpEhMTERMTw+t5HI3biUtRURE+/PBDvPbaa07tCTIMA7PZzI1qGIaBSCTips68vV2feKdUKqHT6RAcHOz0qSqTyYSOjg7I5XKYzWYEBAQgPDwcQUFBLl+/ampqwoULFyCXy5GUlIRhw4Y5vX3Kyspw8uRJaDQaDBs2DGPGjIFYLHZqDDfS2NiI/fv348CBA1AqlRg5ciTmzZuH8ePHO7XjpNFo8P3330OpVOKhhx5CdHS0087dFVqtFkVFRcjPz4dUKoXZbEZsbCw3QnG2ABYVFcFsNiMzM9Op5+0pbicu3377LcrKyvDWW2+59KHFTpsZjUZOaDqnODsbhUIBvV6PkJAQly4iMwwDpVLJ7UDo7e3tsnRmtVqNixcvora2FlFRURg1apRLp17MZjMuXbqECxcuwMfHBxMmTMCQIUOceh3TNI3z588jOzsb58+fR0BAAGbNmoW5c+fecnrQ0eh0OmzevBnt7e1YsWKF02NRKpUoLCxEfn4+Vxs2YMAAboTiyjWh1tZWXL16FWPGjBHcjMCtcCtxMZvNeOGFFzBjxgzce++9rg6Ho/OIhqZpLjXVGUWbDMNAoVDAYDC4XFhuRK/XQyaTQS6Xg2EYbmrkVgvCfGA2m1FYWIiioiL4+flhxIgRGDhwoEPPaQtqtRqnT5/G1atXERUVhalTpzq8ty6Xy3Hw4EFkZ2ejpaUFKSkpmD9/Pu644w7BPLAMBgO2bNmCpqYmLF++HAMGDHDo+To6OrgMr5qaGlAUhaSkJGRkZCAtLU0wWWwWiwVnz55FfHy8SzsAtuJW4pKXl4fPPvsMb7zxhsuHzt1hNpu5EQ0rNKzI8F1LwwqL0WhESEiIYB4SN0LTNORyOTo6OmAwGODr64uwsDCEhobyOv3CMAwqKyuRl5cHo9GItLQ0pKWlCWLKsisaGxuRk5ODlpYWJCcnY+LEibxaejAMg6KiImRlZSEnJwcikQh33nkn5s+fj5SUFN7OwydGoxHbtm1DXV0dli5disTERN6OzTAMWlpakJ+fj4KCAjQ0NMDb2xspKSnIyMjAkCFDulynFAIlJSXQ6XQYMWKEq0OxGrcSl//+979oamrC66+/7upQrIKtpTEajbwXbTIMA7lcDpPJhNDQUJfP31uLVqtFR0cHlEolKIpCSEgIwsLCerwG0tbWhtzcXLS3t2PAgAEYMWKEw0dIfMAwDEpKSnD69GkYjUaMHDkSI0eO7JEg6nQ6HD16FFlZWaisrERMTAzmzZuHWbNmCd6PCrg25fzjjz+isrISDzzwQI+EkGEY1NfXc4LS2toKsViMIUOGICMjA6mpqW5x77S3t6O4uBijRo1ym9R/txEXg8GAF154AfPnz8fdd9/t6nBshqZpbursxqJNW2tp3FVYOmM2m7l0ZpPJBIlEgvDwcAQHB9vUFjqdDpcuXUJlZSXCwsIwevRowWUcWYPRaERubi4uX74MiUSCSZMmITk52aZjVFdXIzs7G4cPH4Zer8eECRMwf/58jBgxwuVJFbZiNpuxY8cOlJaWYsmSJUhLS7P6szRNX1fUKJfL4e/vf11Ro1BHs91B0zTOnj2L2NhYt0hpB9xIXM6dO4cNGzbgX//6l+Dz4W9HT4o2GYaBTCaD2Wz2CM8vhmG4dGa1Ws2lM4eHh99SNC0WC4qLi1FYWAgvLy8MHz4cSUlJbvcQvRGFQoETJ06gsrIS0dHRmDp16i33/DCbzTh58iSysrKQn5+PsLAwLo24J3uFCAGLxYLdu3ejsLAQCxcuvGW2lMViQXl5OVfUqFarERwcjKFDh3JFjUKvwbodpaWlUKlUGDVqlKtDsQq3EZdPP/0UKpUKr7zyiqtD4ZWuija9vLw4oem8JkHTNOf1FRoa6vbCciNGo5EbzVgsFgQGBnJ+Zp1Fo7a2FhcuXIBWq0VqairS09PdcvR2K2pra5GTk4OOjg6kpaVhwoQJ102HtLS0cGnEMpkMmZmZmD9/PiZOnOh2vfJbQdM0srKykJeXh/nz52PkyJHc/0wmE1fUWFxcDJ1Oh/DwcC7DKz4+3u07G52RyWQoLCzE8OHD3cLjzy3ERaPR4MUXX8T999+PadOmuToch8EWbbKvzkWb3t7eUCqVoGkaYWFhHvUAuRGaprl0Zp1OBx8fH4SFhYGiKFy+fBlNTU2IiYnBqFGjBJPR4whomkZBQQHOnj0LhmEwevRomEwm/PLLLzhz5gwkEglmzJiB+fPnu81UiT0wDIP9+/fj/PnzmD59OoKCgpCfn4+SkhKYTCb07duXE5To6GiPEpTOMAyDc+fOoW/fvoLKfuwOt3hCXbp0CTRNY/To0a4OxaGwKcxisfi6ok2tVguZTAaKotxyPcFWRCIRQkNDERoaCr1ej8bGRhw9ehTV1dVc6u6NpomeiEgkQmZmJvr164cvvvgCf/zjH6HRaJCZmYk1a9bgrrvucpvF3Z6g1WoRFRUFpVKJV199FQMGDMC4ceMwY8YMpKenu/30n7VQFIXIyEi0trYSceGLc+fOYfDgwR7dS70RNoVZJBJBp9MhICAAgYGBsFgsUKlULi/adAbswuyVK1fAMAymTJmCiIgI6PV6lJWVITw8HKGhoW4/l94VDMOgtLQUWVlZ+O2338AwDGbPno3IyEgA19Za9Hq9x4qLQqG4rqgRAAYNGoQBAwagoaEBw4YNw9SpUz12lNIdkZGRaGxshFKpFPzzUPBPJaVSiatXr+Khhx5ydShOhzWIBIA+ffpw6y+dizY9dQO0xsZGXLhwAQqFAoMGDcKwYcO4AlGNRoOOjg40NTWhubmZ8zMTUgGpvRgMBhw7dgxZWVkoKytD37598fDDD2P27NmcaWFFRQVOnDiBbdu2ISMjA2PHjhVsjZMttLe3X1fUKBKJMGjQICxevBhDhw7l1hlycnJw5MgRmEwmTJ8+3SOud2sJCQmBWCxGa2ur4MVF8GsuR48exU8//YT33nvPLeoW+IJN1RWJRAgLC+u2d97VBmiOKtp0BiqVChcuXEB9fT369OmD0aNHd2u9YTKZuAQAs9kMf39/Lp3Z3b43u13w4cOHodFoMGbMGMyfPx+jR4/u8re3WCzIy8tDbm4uvLy8MH78eAwdOtStvjfDMGhubuZqUBobG+Ht7Y3BgwdzRY3djczOnDmDAwcOYPz48Zg9e7Zbfe+eUllZiZaWFowdO1bQ31vw4vLvf/8bgYGBeOaZZ1wditOwVlhu5MaiTQDciEboQmMymVBQUICSkhJIJBKMHDnS6kVqhmGgUqnQ0dEBjUYDb29vLp1ZyBl17HbBWVlZuHTpEkJCQnD33Xdjzpw56Nevn1XH0Gg0OH36NEpKShAREYGpU6ciNjbWwZHbD8MwqKur4wSlra0Nvr6+SEtLQ3p6OgYPHmx15l9ubi6ys7MxatQozJs3T9DXN5+o1Wrk5eUhPT1dcA7bnRG0uLS3t+PVV1/F6tWrMXbsWFeH4xTY3jj7gLR3PYHPok1HwjAMKioqkJeXB5PJhKFDhyItLc1uWxiDwcD5mVksluv8zITy8Glvb+e2C25vb0daWhq3XbC9Ytjc3IycnBw0NTVh0KBBmDhxomCmTWiaRlVVFTflpVAo4O/vj/T0dKSnp2PQoEF2rxvm5eVhz549yMzMxIIFCwRzXTua3NxchISE2Fxo60wELS4HDhxAVlYW3n//fY+YU74dRqMRcrmccxLm62HYXdGmqzdAa21tRW5uLjo6OjBw4ECMGDGCN28noW3PzDAMLl++jKysLJw6dQpisZjbLpgv/yw2CeDUqVPQ6/WclYwrRm8WiwVlZWUoKChAQUEBNBoNQkJCuKLGhIQE3q67goIC7Ny5E0OGDMHixYsFuc8S31RXV6OxsRFjx44VrKAKWlzeeust9O3bF0888YSrQ3E4rLD4+PggNDTUYb3szhug3a5o01FotVpcunQJVVVVCA8Px+jRox2aTtrV9sxhYWFOMSlUq9XcdsG1tbWIj4/H/PnzMX36dIetIZpMJly4cAGXLl2Cn58fJk6ciMGDBzvkXJ0xGo3XFTXq9XpERERwNSj9+/d32HVdUlKCn376CYMGDcL999/vsRmULFqtFhcvXkRaWlqPNnRzJIIVF9ag8umnn3YrJ1B7MBgMUCgUEIvFCAkJcdr0za2KNh2x06bZbOYsW3x8fDB8+HAkJiY67fs6c3vmsrIyZGdn4+jRo3ZvF9xTlEolTp48ifLycvTr1w9Tp07lvU5Kp9OhpKQE+fn5uHr1KkwmE/r168cJSr9+/Zz2fcvKyrB9+3YMGDAADz74oKDX2/jg0qVL8Pf3d0rHwR4EKy579+7Fr7/+ivXr13v0RWIwGCCXy+Hr6+tUYbkRR++0WV1djUuXLkGn03GWLa78XTtvz8wWbYaHh/do+tVoNOL48ePIyspCSUkJIiMjMXfuXNxzzz0u3Wyqrq4OOTk5aG9vx5AhQzB+/PgejZrUajUKCwtRUFCAsrIyWCwW9O/fHxkZGRg6dKhLixorKyuxbds2xMTEYNmyZR5nC9SZuro61NTUYNy4cYKcChSkuDAMg9dffx2JiYl49NFHXR2Ow9Dr9VAoFPDz8+NqGIRC5xENTdNc0aatG6DJZDLk5uaipaUFcXFxGDlypKBs329MZ7Zne+bGxkZkZ2fj0KFDUCqVGDVqFObPn4+xY8cK5qanaRpFRUU4c+YMLBYLRo8ejeHDh1sdn1wu59ZPKisrAQAJCQmcoAgpa6mmpgZbtmxBnz59sHz5co+of+oKvV6P3NxcDB48WJAuBYIUl5qaGvzjH//Ac889h6FDh7o6HIeg0+mgVCohkUgEk9XTHd1tgHarok29Xo/Lly+jrKwMISEhGDVqlGA3eANs356ZpmmcO3cOWVlZyM3NRWBgIGbPno25c+cKOhXYYDDg3LlzyM/PR2BgICZPntxtQkFbWxuX4VVbWwsvLy8kJycjPT0daWlpgjZPrK+vx+bNmxEWFoYVK1YIdhOwnnL58mX4+PjYtCWBsxCkuOzYsQMnT57Ee++9J9hMiJ6g1WqhUqncQlhu5HZFmwzD4OrVq8jPzwdFUcjMzERycrJb/Y4GgwEdHR3Xbc8cFhaGwMBAyGQyHDhwAPv37xfsdsHWIJPJkJOTg5qaGsTFxWHKlCkIDw9HU1MTJyhNTU3w8fHhihpTU1Pdym6mqakJ33//PQIDA/HQQw8JWgztpaGhAZWVlRg3bpzgkhgEJy4Mw+DVV19FRkYGli9f7upweIcVFn9/f0FND9nDjUWbjY2NKCgogF6vR2pqKoYNG+ZWD9wb6bw9c0FBAXJycnDlyhX4+vpi2rRpmDdvnmC3C7aWyspK7NmzB1evXgVN05yHXeeiRnde82xtbcWmTZvg6+uLhx9+2O06c7fDaDTi3LlzSE5ORt++fV0dznUIS+oAlJeXo6OjwyOLJjUaDdRqNXcDuzteXl7w8vKC0WjExYsXUVNTg4iICIwdOxYhISEwGo0AIKiiTVvQ6/U4efIksrOzUV5ejoiICG7PlOjoaMGmgN4OmqZRWVnJbawlk8nAMAwoikJ4eDjmzZuHzMxMt/zNbiQqKgqPPvoovvvuO2zcuBErV64U1PpQT2EzTFtbWwUnLoIbuWzbtg15eXn497//LZiKaj5Qq9XQaDQIDAz0GI80o9HIpaAGBARg5MiR6N+/P1e02XkDNCEUbVpLZWUlsrOzceTIERgMBm674OHDh8NisXCjmZ5sz+xszGYzV9RYWFjIFTWyKcMDBw6EXq/HmTNnUFRUhPDwcEyZMgX9+/d3dei8IJfL8d1334GmaaxcudJtOwZd0dTUhLKyMowbN05Qo0xBiQtN03jppZcwfvx43H///a4OhzdUKhW0Wi2CgoI8YmGRYRiUl5cjLy8PFosF6enpSE1N7TLzSAhFm9ZgMplw4sQJZGdno6CggNsueM6cOZzNfWfs3Z7ZmRiNRm79q7i4GAaDAZGRkZygxMXFddmBa21txfHjx9HY2IiEhARMnjxZcNmM9qBUKrFp0yYYDAY8/PDDgsywsgez2YyzZ88iMTFRUEkzghKXoqIifPjhh/jLX/6CAQMGuDocXlAqldDpdAgODnarxdDuaGlpQW5uLmQyGRITEzF8+HCrv5ezizatgd0u+JdffoFcLsewYcMwf/58TJgwweoFUmu3Z3YGOp0OxcXF3IjSbDYjOjqaE5S+fftaHZNUKsXJkyeh0+kwbNgwjB49WjDCaS8ajQabNm2CWq3GQw89ZLVBqNApLCyExWJBZmamq0PhEJS4fPfdd5BKpXjrrbc8YkpMoVBAr9d7hLBoNBpuXSUyMhKjRo3qskdvLd0VbTpjAzSGYXDhwgVkZWXh7NmzkEgkmDVrFubOnduj7YIZhuH8zDpvz+zobanZosb8/HyUlZWBpmnEx8dzghIREWH3sc1mMy5evIiLFy9CLBZjwoQJSE1Ndev7U6vVYvPmzZDJZFixYoWgU8etpaWlBaWlpRgzZoxgkmgEIy5msxnr1q3DtGnTsGDBAleH02NYYQkJCXHrIi6z2YyioiIUFRVBLBZjxIgRGDhwIO8Pl85Cw9bSsFNnfM0jKxQKHDp0CPv27UNjYyOSkpIwf/583HXXXbz/Rnq9nvMzYxgGwcHBCAsL4229TSaTcUWNVVVVAICkpCSkp6dj6NChvE9jqVQqnDp1ClKpFH369MHUqVPdutev1+uxZcsWtLS0YPny5T3qVAgBi8WCs2fPIj4+HnFxca4OB4CAxCUvLw+fffYZ3njjDUHNG9oK23s1GAwIDQ0VTC/CHqqqqnDp0iXo9XqkpaVh6NChTsmlt6doszsYhkFJSQmys7Px+++/g2EY3HHHHZg/f75TeuAWi4UbzRgMBvj6+nJ+ZrZOA7a2tnI1KHV1dfDy8kJKSgpX1OiMRJGGhgbk5OSgtbUVgwcPxsSJE902QcVoNGLr1q2or6/HsmXLkJCQ4OqQekRJSQn0ej2GDx/u6lAACEhcvvrqKzQ2NuL11193dSh2wzAM5HI5TCYTQkJC3FZY2tvbceHCBbS2tqJ///4YOXKky1Kn7d1pU6/X49ixY8jOzkZZWRn69euHefPmYdasWS5bnGa3Z1apVKAoCiEhIQgPD+921MQwDFc7lJ+fj+bmZvj4+CA1NZUranTFqJhhGBQXF+P06dMwmUwYNWoURowYIbgiPmswmUz44YcfUFVVhT/84Q+C3h/ldrS3t6O4uBijRo0SxDS8IMTFYDBg3bp1nMmfO9JZWEJDQ91y4VOn0+Hy5csoLy9HaGgoRo0aJaipj+522mRHNRRFoba2ltsuWKvVYty4cZg3bx5Gjx4tmHUCdqfRjo6Om7ZnBq7ZH7E7NXZ0dEAikWDIkCHIyMhASkqKYNJNjUYjzp8/j8uXLyMgIACTJk3CoEGDXB2WzZjNZvz888+QSqW47777MGTIEFeHZBc0TePs2bOIjY0VxDSfIMTl3Llz2LBhA/75z3/2aJHYVTAMwxkfdudFJWRomuZs0728vDBs2DAMGjRIMA/jrui8AZper8f58+dx6NAhFBYWIjQ0lEsjFlphWWfY7ZlbW1tRWlqKsrIy1NfXcyNfdqfGpKQkwaRsd4VcLseJEydQVVWF2NhYTJkyxe3uY4vFgp07d6K4uBiLFy9Genq6q0Oyi9LSUqhUKowaNcrVoQhDXD799FMolUq8+uqrrg7FZliLEIvFgtDQULcTlrq6Oly4cAEajQYpKSnIzMx0m1FXW1sbfvnlF+zbtw/t7e1ITU3FzJkzMX78eEgkEkEXbZrNZkilUuTn56OoqAhKpRK+vr6Ij49HYmIiUlJSEBkZ6ZJ0ZnupqalBTk4O5HI5hg4dinHjxgliesZaaJrG3r17cfnyZSxYsEAwaxe2IJPJUFhYiBEjRrh8Lczlk6RarRYFBQW47777XB2KzdA0DZlMBpqmHZ5uyjcKhQK5ubloampCdHQ07rzzTrcolGMYBnl5ecjKysLp06fh6+vLbReckJBwXdGmXq+HTqcTTNGmwWBASUkJCgoKUFxcDKPRiKioKIwbNw4ZGRmIjY3lEkJkMhlqamrg4+OD8PBwhIaGCv76io+Px9KlS5Gfn4+zZ8+itLSU+25CFPgbEYlEWLBgAby9vbF7926YTCaMGTPG1WHZBHudtLa2ulxcXD5yOXnyJDZt2oR33nnHLR5uLO4qLEajEVeuXEFpaSkCAwMxatQot8jzV6vVOHz4MLKzs1FXV4cBAwZw2wV353rQVdEmnxugWYNWq+WKGktLS2E2mxEbG8tNefXp06fbkcmN2zMHBwcjPDzcLVwedDodzp49y01TTpkyRRDrANbAMAwOHjyIM2fOYPbs2ZgwYYKrQ7KJsrIyyGQylwujy8Xlgw8+AE3TWLdunSvDsAl2u1wACAsLE/R8OAvDMJBKpbh8+TIYhkFGRgYGDx4s+B6lVCpFdnY2jh07BovFgsmTJ2P+/PkYOnSozdNFrMgYjUaHFm2qVCquqLG8vBw0TWPAgAFcUaOtvlad/cwcvT0z37S1tSEnJwf19fUYOHAgJk+e7BbGkQzD4OjRo8jJycG0adMwdepUV4dkNQqFAvn5+cjMzHSpC7RLxUWpVOKll17CihUrMGXKFFeFYRPuKCxNTU24cOEC5HI5kpKSMHz4cEEXdhoMBm674KtXryIqKgpz587F3Xffzdt2wXwXbcpkMi7Dq7q6GhRFITExkdupka+b3BHbMzuD8vJynDhxAhqNBsOGDcOYMWPcYm3v+PHjOHr0KKZOnYq77rrLbda/zp07h8jIyG43gnMGLhWXY8eO4YcffsD69etdPj9oDWwKqUgkQlhYmOB7jWq1GhcvXkRtbS2ioqIwatSoHlmBOJqGhgZuu2CVSoXRo0dj3rx5GDdunEPb2t6izZaWFk5Q6uvr4e3tfV1RoyOnr7ranjksLAzBwcGCfQCazWbk5eUhNzcXPj4+mDBhAoYMGSLYeFlOnTqFQ4cOYcKECZg1a5bg4wWuOXu3tLRg7NixLovXpeLyzjvvQCKR4Nlnn3VVCFbjTsJiMplQWFiI4uJi+Pn5cZYtQsRiseDcuXPIzs5Gbm4ugoKCuO2CY2JiXBLPjUWb3t7enNA0NjZygtLS0gKxWIwhQ4ZwztDOHkGw2zPLZDJoNJrbbs8sBDQaDU6dOsWNSqdMmeKS39oWzp07h/3792PMmDGYM2eO4AVGrVYjLy8P6enpLpuGdJm4dHR04JVXXsFjjz2G8ePHuyIEqzGZTJDL5ZytulCFhWEYVFZWIi8vD0ajEWlpaUhLSxNksgG7XfC+ffvQ2tqK1NRUzJ8/H1OmTBHMFA8rNOXl5ZxtvVKpREBAADIyMrgtnIXyEO+8PTNN0wgKCuLcmYVIU1MTjh8/jpaWFiQnJ2PixImC3p310qVL2Lt3L4YNG4Z7771XsM8BltzcXISEhLjMdcBl4nLw4EHs3bsX69evF/T8Pzv9wPYIhdpjaWtrQ25uLtrb2zFgwABB5LnfCMMwKCgoQFZWFk6cOAFvb29uu2AhVXZbLBZUVFRwOzWqVCoEBARgyJAhSE5ORv/+/eHl5cWNaIS20yZN05yfmV6vh1gs5tKZhbZGyDAMrl69ilOnTsFgMGDUqFEYOXKkIDtEAJCfn49du3YhLS0NixYtElx7dqa6uhqNjY0YO3asS65Pl4nLP/7xD0RFReHJJ590xemtwmg0Qi6Xw8fHB6GhoYIUFq1Wi7y8PFRWViIsLAyjR49Gnz59XB3WdWi1Wvz666/Izs5GdXU14uLiMG/ePMycOVMwvWqTyXRdUaNOp0NYWBiX4TVgwADu92cYhps6E/pOm1qtFh0dHVAqlQDA+ZkJrbjRaDTiwoULyMvLg0QiwaRJkwTr81VUVIQdO3YgJSUFS5YsEawQarVaXLx4EWlpaS7ZedMl4tLU1ITXX38dTz31FEaOHOns01uFwWCAQqEQrLBYLBYUFxejsLAQXl5eGD58OJKSkgQVZ2VlJbKysnDkyBEYjUZMnDgR8+fPx7BhwwQRp8FgQHFxMQoKClBSUgKj0Yg+ffpwghITE3PbODsXbZrNZkFsgNYVZrP5pu2Zw8LCBJfOrFAocPLkSVRUVCA6OhpTpkwRXGcJuGaz8uOPPyIhIQEPPPCAYKZGb+TixYsICAjA4MGDnX5ul4hLVlYWDh8+jPXr1wvyRzEYDJDL5fD19UVISIggHoSdqampwcWLF6HVajmHXKG0I7tdcFZWFgoLCxEREYE5c+bg7rvvFoTflFarRVFREVfUaLFYEBcXd11Ro710twGaM4s2rYlR6NszA0BtbS1ycnLQ0dGBtLQ0jB8/XnDFoxUVFdi2bRvi4uKwdOlSQbUfS21tLWprazFu3Dind3ScLi4Mw+Bvf/sbEhIS8Oijjzrz1Fah1+uhUCjg5+cnOMcAuVyO3NxcNDc3IzY2FiNHjnRpkVRnmpubsW/fPhw4cAAKhQIjRozAvHnzMH78eJc/VJVKJVfUWFFRAYZhritq5Kt25kacVbRpLzduzxwQEIDw8HAEBQUJokNF0zQKCwtx5swZMAyDMWPGIDMzUzCjQeDausbWrVvRt29fLF++XDDJKCx6vR65ublITU11eufO6eJSW1uLt956C8899xyGDh3qzFPfFp1OB6VSKThhYRgG58+fR1lZGYKCgjBq1CjBpG7KZDJ88MEHOHfuHPz9/bntgvv37+/q0FBVVYV9+/ahuroaIpEISUlJXFGjs7OSuivaFEJvnE1n7ujogFarhY+PD6Kiohwmurai1+tx7tw55OfnIyQkBDNmzBDUVhB1dXXYvHkzIiIisGLFCsGtZ12+fJlLmXcmvIhLdna21f5USqUS1dXVSE9Pt7p3ZDKZYDAY7KriZ3P/rUGv18NkMt32wcMwzHWx0zRt1wWVn59vdQ56RUUF/Pz8EB0dfVO7mc3mbr+jwWCwKxNr8+bNVu3MxzAMysrKEBYWhvDw8Jvm79ndF7tCoVBgzpw5NsX166+/Wv1gUavVqKqqQmRkJCIiIripQ3b6qrupRI1Gg3HjxtkUF3Ctc0JR1G3XMMxmM7c+Y+t1wzCMXb3jlpYWq7Iy2bVGPz8/m0bFNE2Dpmm7Fo7PnTuH4ODg207tajQaVFRUICkpyWZR1uv1Nndmf//9d0RFRVn1nFKr1aioqLAp9Z/tcNhjj19TU2N1Nmh7ezv0er1NHoI0TcNisfRIxHkZmzc0NNi0ydfkyZOtfm9jYyO+//57hIeH2yUu7GZM1mDNnKlarYbRaISPjw9nh65UKu0SF4VCYfUF39WFwTAMCgsLUVdXh6CgIIwbN+6mC/vkyZN2iUt1dTUefPBBq97bXZ3Sjh07cOzYMYwYMQKrVq266f//+te/bBaX5uZm3HXXXVa//0bzPp1Ohx07dkAul2PkyJGYOHHiTZ/ZunWrXeJisVhgNpsRFBR0S4HpyfqYRqOxS1wMBgOioqJu+76goCCbp0/UajXa29u5lGdb6ejogFQqtep6s2e2o6ysDDU1NTZ/tqWlBY2Njbj//vuter8tyUl6vR5btmzhNuWzFa1Wi7i4OKvea+sI1GAwoLS0FL6+vj0SF17SRCiKgpeXF+8vkUiEjz/+uMcZZRRF8fLSaDQwGAwIDAzkzAR7ikgksutFURSuXLmC8vJyZGZmwmw249ixY1zPmX31pM28vb3tfl24cAGbN2/GypUrsX//fpw9e/am99hLT66nr776CiKRCNOmTcOhQ4eQl5d30/t6gq+vL1QqFdeGfL2Aa52JnsBnPOzLaDRy9kI9QS6Xc4XKfL5qa2vx+++/291epaWlUCqVvMf166+/9qiTQVEUWlpabrrf+XgVFxfzspYrnBzELqiuroZKpcLMmTNdHQoYhoFWq0VYWBh8fX259GQ+BMYeVCoViouLMXPmTMTFxWHq1KlQKBSora11STydYRgG//jHP/Daa69hwoQJeO211/D222/3+OHYUwoLC9HR0YFly5YhIyMDq1atwk8//cTVqvABO/VkMBh4OyYLK1pCwWw2o7KyEpGRkT1ewxo8eLDdInArfvvtN4wdO9buz2dkZGDv3r08RnSNy5cv49577+3RMSoqKrj6Jb4wm83Q6XQYMGBAj48lWHFhGAaffPIJHnzwQUHk4et0OohEIq5nS1EUQkNDXeIuwDAMjhw5gmHDhnFFiF5eXpg6dSpOnTrl8of40aNHIRaLuZt69OjRMBqNaG1tdVlMDMNg+/btWLFiBfcbDhgwAAkJCdi+fTtv56EoCoGBgdDpdLz+Dmxqs1CgaRpVVVUIDAy0el3iVkycOBENDQ08RXcNNu06IyPD7mPcfffdqKqq4rXtaZoGwzA9LmxMTk5GcXExr7GVlJQgIiKCl2eu65/a3VBbWwutViuYfRTUavVNGWQURblEXBQKBfR6PdLS0q77e9++feHt7Y3Kykqnx8TCMAw++ugj/PWvf+UeOBRFYdasWfjXv/7lsri0Wi1MJhNSUlK4v1EUhYcffhgFBQUwGo28ncvLywsURfE6IjIYDIKpZWIYBtXV1fDy8kJsbCwvacvsmiWfD0qLxQIAPXpQsve32WzmJSbg2ghaIpH0uN0iIyO5nUv5wGKxQKFQ8OaMIEhxYUct999/vyDy7dkLvqt1AlfE9/vvvyMzM/Omc1MUhalTp+LcuXMu6+UqFAoYDAYMGzbsur8/9dRTKCoqcllcP//8M1JTU29qM4lEgpSUFGzdupW3c1EUhYCAAGg0Gt6+r9lsFkQNBcMwqK2thcViuc4Sp6ewazh8TvMUFBT0uGaHoihERETg5MmTvMV14MABzJ49u8fHoSgKycnJKCkp4eU6Ky0t5dV/TpDiUl1dDbVajTvvvNPVoQC41utlF9Fdjdlshkaj6TZnPSoqCl5eXqiurnZyZNd49913MWnSpC4f4oBr1g0YhkFRURHuu+++Lv+/YsUKFBcXQ6/X83ZOtiPCp5i6uniQpmnU1tbCaDQiISGB9+nq+Ph4nD59mrfjnT9/HpMmTerxcRYsWMCbuLBrtz2ZqutMREQELBYLdDpdj45D0zQ6Ojp4tYkRnLgIba0FuJb+KZRK+NzcXERGRnbbNuzo5cyZM6Bp2qmxMQyD3NxcPP/8813GlZmZiS+//NKpMQH/Nz3SnUmmr68vhg4dik2bNvEmBmyRpFqt7vGxhLDWYrFYUFNTA5PJhISEBIcI3cSJE1FRUcHLsRiGgcFg4GUnxri4OK4uqad0dHRYVQtlLRRFIS4uDsXFxT06DlugzadzhDCe3p04c+YMzGazYNZa2AtKCPPdDMOgoqLitnVCffr0QVBQEM6dO+ekyK7R1tYGiqK6zRx6/vnncfToUafGBFwr0rudR9zSpUtRWVmJ0tJS3s7r7+8Pi8XCq2A5G/Yhza7jDRw40GEjqPDwcG6xu6ewHSs+2oxNy+cjE3PPnj0YPnx4j4/Tmfj4eOj1ers7kwzDoLW1lfcKfkGJi0ajwaZNm/Dss88KYgoK+L+FPEfFY8uNpFKpQFHUbQs2KYrC9OnTnT5H/+67795yn/GYmBiuktuZHDx48LZpnz4+Pli6dCkOHDjA23nZdYSepiXzuZhsC2y2VWVlJQICAhAfH+/QqTn2uuHj+5aWlvKyaM4yefJk7Nmzp0fHYNerZs2axUtMLGyGor2jvvr6eof43QlGXCwWC9avX4+xY8ciKSnJ1eFwqFQqh3oF5eXlWS0wOTk5XS5Kd4Wfn1+Pe0i2CB/DMLh8+TL++Mc/dvseiqLg7++P8+fP9yguW2AYpsvMuq7IyMjA448/zuv5+UhLZjf8ciY0TaO5uRn19fXo27cv+vXr55Rp6sDAQBQVFfX4OKdPn+Z1h9tJkyaho6Ojx78jAId0+lJTU9Hc3GxzfGzmX1paGu8daEGIi8ViwZdffgmRSISHH35YMKMW1oPKkTs6Xr16FR0dHVbFolAokJmZafWxe9qOO3bssPpiVSqVXA/qVqxcuRIff/xxj+KyBfaGtubByIofn7A9/Z6M1sxms9NS3hmGgU6nQ2VlJTQaDQYOHOjU/YzGjx+P3NzcHh2DXTRPTU3lKaprCRo9zWbbt28fEhISHNKWYrEYFEXZvMan0Wgcct0DAhAXi8WCDRs2oLm5GevWrXN5Rkxn2AerI2+sYcOG4fjx47d9X0tLCy/2JLbw1VdfQavVWvXejz/+GKNGjbptW82dOxdtbW1OW6Q+evSoSx10KYqCr69vjxf2nTFqoGka7e3tqK6uRkBAABISEuDn5+fUzl5ycjIvmU8A/202dOhQu6fGWB/AhQsX8hoTC0VRGDBgAEpKSmz6XElJCeLj4x3yG7tUXGiaxldffYWmpia8/PLLgrOqZh2VHXlzDR482Kppk5MnTzp91860tDT897//ve37GIbByZMn8cILL9z2vT4+PqAoymnV+qdOncKiRYuccq7ukEgkdi9UO0uETSYTampqIJPJ0L9/f/Tt29cl2ZrsOdkMP3soKytziCjOmTMHlZWVdv0mGo0GABy61UNMTAy3d5A10DQNg8Fgk1uyLbhMXBiGwaZNm1BfX48XX3zRoVNP9qLT6RyegiwSieDt7X1L6wt23cDZa1EvvvgiDh06dNv3abVam+wspk2bhnfffben4d0WdlozPj7e4ee6FWy2EfuAsQU+s566Q6/Xo6KiAt7e3khISEBAQIDLpqbZhBWpVGr3MU6dOsXregsLK1gymczmz+7atcsh6xqdYUfJ9fX1Vr2/uroa/v7+DovJJeLCMAwOHTqEK1eu4OWXXxaksLA3tTOmoUaNGoWzZ892+/+Kigr4+vo6vSfJZnfdrrjw008/7dIxoDv+9Kc/OWUNQS6X81pT0BMCAwO5jcJsQa/XO3TXSjbNOCwsDLGxsYLYIXPSpEl2Fy0yDHPLIuOeQFEUxo0bhx9//NHmmCoqKnpsVGkNqampqKmpue3ohWEYNDQ08LoudSMuueuKi4uxZ88erFu3zuk7AlqLSqXipnAcTUJCAvR6fbcXxIULFzBhwgSHx3EjFEUhKSkJGzdu7PY9DMPg6NGjePnll60+rr+/P/7+97/zEOGt2bNnj1VZYs6gc1GlLdMqRqPRYdPFNE2jsrISERERvJhP8kVKSordGXZs2rejOoXTp09Hc3OzTdN2V65cgUQicUrGX0BAABiGua1Xnlqtdrg3otPFpbm5GZ999hlWrVrlsLm+nsIWjjlrq2N2H4X29vab/sfuWhgdHe2UWG7kL3/5C/bu3dvtjd7W1gYANm0wRVGUU0aExcXFWLBggcPPYy3+/v7cSJBhGO7VHez/HNFWDMOgpqYGfn5+ghIWAJz7uD0uyTk5OQ59rnh7eyMqKgqHDx+26v0MwyA7OxsPPPCAU9qYoij07dv3lgv7DMOgpKQEAwcOdGhMThUXhUKBd999FzNnznT64rS1sIVjrLOtsxg6dChOnTp1098vXLiAiIgIl938MTExYBgGzc3NXf7/zTffxJw5c5wanzU9WtaRWCi2PQA49wKDwQC1Wg2dTgedTgeDwXDL7+SIttVoNNBqtQ7LFOopU6dOxYEDB2yutSotLcWMGTMcGBmwfPlynD171qpiz+LiYohEIl72R7GWxMREqNXqbqdgTSYTjEajwzusThEX9uH09ttvY9iwYbj33nud/jCyNluH3SzHmbn9wLXMrBunTBiGQXl5uV3bO/MFRVFYsGBBl9NYJpMJpaWleOqpp5wa06FDh257Yx84cADR0dGCe3B6eXndtF+8Xq/vcrpMp9M5dNQSFxcniPWorkhLSwNN07hw4QJkMhmqq6tRXFx8y0JG1nr+drVWPSU4OBhxcXHYvXv3LZ8pFosFO3fudNqohUUkEsHf3x9VVVU3/Y9hGBQXF6NPnz4Oj8nhV5bJZMKZM2fwzjvvYPjw4Vi+fLnTb3i9Xg+ZTAaFQtHtQ4mdp5TL5QgKCnJ6vY2Xlxe8vb2vy/Sora2Fj4+Py1O0V69ejcrKypsKyD755BOkpKQ4vXq8sLAQGzduRGtra5c3N5savWLFCqfGZS0ikQi+vr6QSCSQSCQICgriCv/Y78NOzfKd7MIu5Pr6+gp2vRO41qlZtGgRpFIpsrOzcerUKVy9ehW7du3ChQsXbvrd2emnkSNHOvz5QlEUli9fjuLiYpSXl3d7De7atQt9+/blxTzTVtLS0tDY2HjT6IXtyDgj89Qh4sJW+V64cAEffvgh9u3bhwcffBD333+/S3pKarUagYGB8PLygkwmu25XP3ZUo1aroVAoEBAQ4JINwABgwoQJOH36NBfT6dOnMXnyZJf3vn18fDB9+nS89tprXLs1Njbi0KFDeOutt5wez9NPP42wsDB88cUXOHToEGQy2XW/5/nz5+Hr64uIiAinx2YtnfehF4lECAwMhNFo5K5N9vvwfb9otVrI5XJe92JxFJGRkViyZAkWLFiAJUuWYP78+ZgzZw4KCgpw5MiR6zqK9fX1UCgUGDdunFNi8/Pzw3333YcffvgB1dXVN804nDx5EuXl5XjooYdc0s5isRjBwcG4evUqFxtN0ygoKEB8fLxTnsO85R1evHgRkZGR0Gg0uHr1Ki5fvgyapjFhwgRMmjQJgYGBLruYw8LC4OXlBbFYDJFIBLlcjsDAQHh7e8NkMnFbGIeGhjq8aPJWxMXFgWEYlJWVob29HQEBAS6tLu/M2rVrsXTpUnz//fcYOXIk/vnPf+LBBx9EaGio02ORSCRYvHgxKisrcezYMVy4cAEZGRnIyMiAWq3Grl278NRTTwn+4dkZVmDYjpBOp+MsPfhCo9GgurpaMCnH1iAWi68bGUdHR+P+++9HdnY29uzZg3HjxsFkMuHgwYOYMWOGUzuvqampmDVrFn744QeMHj0agwcPhtlsxsWLF1FZWYlHHnnEZR1ViqIwZMgQ5Obmora2FmFhYaiuroZYLEZcXJxTYuDtCvvll19gMBjg5eWFmJgYzJs3D6mpqdd51rhqX4rOU1z+/v7w8vLipiDY+cnOF4Ez47zxXNOmTcPp06chFou5hUlXtVvn83p7e2P9+vVYv349fv/9d0yfPh0PP/ywS2JjGAYURSExMREDBgxAdXU1zp49i59//hkikQiLFy9GfHy8y2KzF29vb/j7+3Ob0/n7+/P6Herq6tC3b1+EhIQIYo+YztgSj7+/PxYtWoRz587h999/B3BtL5iUlBTev9ftjjd69Gj069cPJ0+eRHFxMbe/yqpVqxzezrc7tpeXFzIyMlBeXo7W1lYEBQVx02HO+P15EZfAwEBkZmZy+3z7+vqCoihe98awV21FItFNOd+sURv7kKIoqkd7qNvbC/T19UVdXd1Nf09LS4OXlxcvFilhYWF2fS44OLjL7LWFCxdCr9cjJCSkx7sG2jPvGxAQgMLCwpv+npGRgUGDBsHLywu+vr5dvsdaYmJi7PqcSCTistTsha09oCiqy2PZuxbo7e2NiIgI+Pj4OGw3UHt76RKJxC67+OjoaISHh3M1RLc6hi2p8iz+/v5We3VlZmZCr9dzv19jYyMaGxtv+zl7Zya8vb2tMrwFrrWTxWKBj48P5HK51efo6XofxfAgYT3xAbIWeyutndVDs2f6wln7mtjTbs74TQHbH5bkWrPvWhNybEK9D4QaFyDs35P7LB/iYgsajQYVFRVITk522Xxkd+h0OlgsFoenMtoDu0+2RCIRlHM0TdMoLy9HdHS04NpNLpejuroa6enpgmoz4Frlvdls5nVDKz5gGAZtbW3w9fUVVI0Qi8VigVar5aa3hYJGo0FZWRlSU1Odvknf7Whra3OoQWV3OD11q6WlBVu2bMErr7yCixcvOvv0t0Wj0fR450BHoFAosGfPHi6XXyh8+eWXeOGFF+wy83MUNE3j0KFD+Ne//oXTp0/32MLdEbCp7yqVymmjRGtgp4jr6+t7PMXnCDo6OvDdd99ZPSXkDCwWCzZv3owTJ04Iqm7IbDajuLgYJSUlt7SXchROb4mEhAS8/vrrSE1NxRdffIHvv/++R+sdfCKRSODr6wulUun0rXjdkYsXL2L37t1YtWoV+vfv7+pwAAAymQyff/45jh49ipkzZ+KJJ54Q3IgKwHV1JkqlUlAdmn79+sHLy8tqd93ezu+//47m5mYsWrTouuJYV6JQKHDx4kUoFAoMGTIESUlJTh8huyQf0d/fH08++SROnjyJbdu2QSqV4oknnnBaitytCA4ORnt7O5RKpUvSbN0FtVqN9evXY8SIEYLx77p8+TJ27NgBiUSCp59+2qmWG/bg5eWFoKAg6HQ6aLVamEwml9rdd44rNjYWVVVVaG9vF3S9kKupq6tDTk4O7rzzTrsTQfiEdV+ora1FSEgIBg8e7PQiZxaXJbtTFIXJkycjKSkJX331Ff75z39iyZIlmDZtmktvLpFIhODgYMjlcm6Ng3Az//nPf6DT6bBu3TqXPwyNRiN2796N3NxcDBs2DIsXL3ab343NXPTx8YFGo4FSqURAQIDL61ACAgIQERGB5uZmBAYGCm4dQQgYjUbs3LkTsbGxLrVoYtHr9bh69SrUajUGDhyI2NhY1z5LXXbm/yU6Ohqvvvoq7rzzTvzwww/4z3/+47BUSWthrTmENh8uFI4fP45jx47hmWeeQVRUlEtjqa+vx0cffYQrV67ggQcewLJly9xGWDrj4+OD4OBgiEQiqFQqQawT9e3bF2KxGHV1dYKrixEChw8fhkqlwqJFi1y+1tLa2opLly7BZDIhMzMTcXFxLu/0uVxcgGs31gMPPIBnn30WVVVVeOONN1BUVOTSmIKCgiASiQS3gO5q2tvb8dFHH2Hq1Km46667XBYHwzA4fvw4/vOf/0AsFuO5557D6NGjXX5D9QSRSISgoCBIJBLo9XqoVCqXrv2xBYEGgwEtLS0ui0OIlJWV4fz585g1a5ZLpw0tFgtKS0tx9epVhIeHY8SIEYLxjBOEuLBkZGTgb3/7G+Li4vDhhx/i559/tsrW2hFQFIWQkBCYTCa7tqf1RBiGwfvvvw+xWIxnn33WZQ9ylUqFr7/+GtnZ2Zg0aZIgRlB84ufnh6CgINA0DaVS6dKEFz8/P/Tp0wdtbW3QarUui0NIaLVa7NmzB4MGDcLo0aNdFodarcalS5fQ3t6OlJQUDB48WFDp2YIzGAoODsZzzz2Hw4cPY9euXbh69Soef/xx9OnTx+mx+Pj4ICAgAGq1Gr6+vi6fB3c1+/btQ25uLv7f//t/LquBKCkp4baZXb16NVJSUlwSh6Px9vZGcHAwtFotNBoNTCaTQ/c7vxURERFQqVSor69HUlKSy6eAXAnDMNi3bx/MZjMWLFjgsg5WXV0dqqurERAQgPT0dMHVDAICG7mwUBSFWbNm4ZVXXoFOp8Nbb72FU6dOuWTel11cVSgUvXreua6uDv/9738xb948l/TWzGYzsrKy8M033yAuLg4vvPCCxwoLC0VRCAgIQEBAAEwmE5RKpUtG8hRFITY2FmazGU1NTU4/v5DIz89HYWEh5s2b55LpJ6PRiIKCAlRVVSE2NhbDhg0TpLAAAhy5dGbAgAH461//iu3bt+Pbb79FYWEhVqxY4dQFW3Z6rKOjA2q1WjDzmc7EYrHgnXfeQWRkJB5//HGnn7+lpQVbt25Fc3Mz7r33XkyaNMmt11ZsRSwWw9vbGxqNBiqVChKJxOkPFLFYjH79+qGhoQFBQUG98j5QKBTYv38/MjIyMHToUKefv6OjA1KpFBRFIT09XfClEoIcuXTG19cXK1euxOOPP478/Hy8+eabdpnc9QRvb28EBARAq9UKpuDTmWzfvh2lpaV46aWXnPpQYxgG586dw0cffQSTyYRnn31WEPvbuAJ2sd/Pzw86nc4li/1hYWEICgpCQ0ODy9ZCXQXDMNizZw/EYjHmzJnj1HPTNI2KigoUFRUhKCgII0aMELywAG4gLixjxozB3/72N4SEhOCdd97Bvn37nHpzBQQEQCwWQ6lU9qrpMalUii1btmDp0qUYMmSI086r0+mwefNm/Pzzzxg5ciSee+45QRSpuRp250p2sd/ZFi0xMTFgGMYqx19P4ty5c6ioqMDChQudOnOi1Wpx+fJlNDU1ISkpCWlpaYJxAbgdgp4Wu5GIiAi8/PLLyMrKwt69e1FcXIxVq1bZbStvK2z1vkqlEqSpH98YDAa8/fbbSEhIwPLly5123qqqKmzduhUGgwEPPfQQMjIynHZud4Bd7NdoNFyyibMMML29vRETE4Pa2lrI5XK36EH3lNbWVhw+fBjjxo1z6pbFTU1NqKiogJ+fH4YNG8b7lteOxq3EBbg2PbBgwQKkpaVhw4YNeOONN7By5UqMGDHC4edm7TqUSiV8fX09vmp548aNaG5uxqeffuqUTDmapnHkyBH8+uuvGDhwIJYuXdorHl72QFEUAgMDYTAYoNPpYDabERAQ4JRU1ODgYISGhqKxsREBAQFu05O2B4vFgl27diE0NJTbvM/RmM1mSKVStLe3o1+/fkhMTHTLDD33i/h/SU5O5gwwP//8c2zevNkp6yG9xdzy0qVL2LVrFx577DHEx8c7/HwymQxffPEFfv31V8ycORNPPvkkERYr6GyAqVKpnGaA2VvMLY8fP46mpiYsXrzYKSKqUChw6dIlznBy0KBBbiksgBuOXDoTEBCAJ598Ejk5Ofjhhx8glUrx+OOPO9wA09PNLdVqNd577z2MGDECCxcudPj5rly5gp9//hl+fn54+umnMXDgQIef05NwhQFmbzC3ZE0p77jjDoev991oOJmSkuL2MyPuKYmdoCgKU6dOxWuvvQYvLy/885//xNGjRx266M6aW7JTEp7Gp59+6hRTSqPRiJ9//hmbN2/G4MGDsXbtWiIsdsIaYAYGBsJsNjulJqazuaWQtgzgA6PRiF27diE6OtrhppR6vR5XrlxBXV0dBgwYgPT0dLcXFsADxIWFNcCcOnUqtm/fjk8//dShBpieam55/PhxHD16FH/6058caqnCGk5eunQJ999/v9saTgoNZxtgeqq55eHDh6FUKrF48WKHTkvdaDjZv39/j0m19xhxAa7dWA8++CCeffZZVFRU4M0330RxcbHDzudp5pYdHR34+OOPMWXKFEybNs0h52AYBjk5OZzh5PPPP48xY8Z4zA0lBJxpgNnZ3LK1tdUh53A2rCnlzJkzHTbdZ7FYIJVKOcPJ4cOHe1xhqkeJCwtrgBkTE4MPP/wQO3bscMgUAUVRCA4O9ghzS9aU0tvbG2vWrHHIw16tVuObb75BVlYWJk2a5PDRUW/HWQaYfn5+iIqKQmtrq9ubW+p0OuzZswdJSUkYM2aMQ86hVquRl5eHtrY2znDSE30LPe8b/S8hISF4/vnncejQIezatQslJSUOMcAUi8UICAiARqNxa3PL/fv34/z58/jHP/7hkBqe0tJSbN++HQCwatUqDB48mPdzEG7GWQaYkZGRUKvVbm9u6WhTyvr6elRVVSEgIADDhw/36Klg97wCrISiKMyePRuvvvoqZ4B5+vRp3ueG2foCdzW3rK+vx5dffom5c+fy3lszm83Izs7Ghg0bEBsbixdeeIEIi5NxhgGmJ5hb5ufno6CgAHPnzuW9g8UaTlZWVnKGk54sLIAHj1w6M2DAALz22mvYtm0bNm7cyBlg8uWT1dncUqPRIDAwkJfjOgPWlDIiIgJPPPEEr8dubW3F1q1b0dTUhPnz5/daXzCh4GgDTHc2t1Qqldi3bx8yMjKQnp7O67FlMhlKS0vdxnCSLzx65NIZPz8/PProo1i9ejWuXLnCuwEma26p0Wjcytzyhx9+wNWrV/Hyyy/z9qBhGAbnz5/Hhx9+CKPRiGeeeQZTpkwhwiIAHG2AGRYWhsDAQDQ0NLhNFiXDMNi9ezfvppSs4WRhYaFbGU7yRa8RF5axY8fi9ddfR3BwMN555x3s37+ft5vL3cwtpVIpNm/ejAcffJA3U0qdToetW7fip59+wogRI/Dcc88hNjaWl2MT+MORBpixsbFgGAYNDQ28HdORsKaUCxYs4G2qijWcbGxsRGJiolsZTvJFr5gWu5HIyEi89NJLyMrKwp49ezgDTD56Fe5ibmkwGPDOO+8gISEBK1as4OWYVVVV2LZtG3Q6HZYvX45hw4bxclyCY3CUAaY7mVu2tbXh8OHDGDt2LJKSkng5ZmfDyeHDh7ud4SRf9LqRC4uXlxcWLlyIF154Ac3NzXjjjTeQl5fHy3FZKw4hVy1v3LgRjY2N+POf/9zjDDeapvHrr7/i888/R0hICNauXUuExU1gDTD9/f1hMBh4KwrubG7p7G0BrMVisWDnzp0IDQ3FzJkze3w8s9mMkpISlJWVoU+fPr1aWIBeLC4sgwcPxt/+9jckJyfjs88+w5YtW3p8Mwjd3DIvLw+7du3CqlWremxKKZfL8eWXX+Lw4cOYMWMGnnrqKadtgUDgD19fX26kzZcBptDNLXNyctDU1IRFixb1eMpKqVTi0qVLkMvlbm84yRe9clrsRgICAvD000/j+PHj+PHHHzkDzJ6sFQjV3JI1pRw+fHiPTSnz8/Px888/w9fXF0899RQSEhL4CZLgEvg2wBSyuWV9fT2OHz+OqVOn9ug+90TDSb7o3dLaCYqicMcdd+Avf/kLKIrC//t//w/Hjh2ze2FeqOaWn332GTQaTY9MKY1GI3bs2IHvv/8egwYNwtq1a4mweAh8G2AK0dzSZDJh586dPTal1Ov1yM/P9zjDSb4g4nIDMTEx+J//+R9MmTIF27Ztw2effQa1Wm3XsYRmbpmTk4MjR47gmWeesdupoKGhAR9//DEuXryI++67DytWrPD4YrDeCJ8GmH369BGUuSVrSrlo0SK7N1dra2tDXl4eDAYDMjIyPMpwki+IuHSBj48Pli5dij/96U8oKyvDG2+8gZKSEruOxZpbKpVKnqO0jY6ODnz00UeYPHmyXaaUrOHkJ598Am9vbzz33HMYO3YsuaE8GL4MMEUikWDMLcvLy3Hu3DnMnDkTkZGRNn+eNZwsKSlBaGgoRowYIeisUFdCxOUWDBs2DH/7298QHR2NDz74ADt37rR5BMKaWxqNRpeZW/bUlFKtVmPjxo3IysrCxIkTezTyIbgffBhgCsHcUqfTYffu3XabUnY2nExOTkZqaqrbegk6A9IytyE0NBRr167FwYMHsXv3bs4A0xY3X7FYDH9/f5eZW7KmlG+99RZCQkJs+ixrOMkwDB577DGkpqY6KEqCkOHDADMyMhIqlcpl5pb79u2DyWSyy5SyNxlO8gUZuVgBRVG4++678ec//xkajQZvvvkmzpw5Y9MxAgMDXWJu2dDQwJlSjh071urPWSwWznAyJiYGL7zwAhGWXk5XBpi2jOTZvV/MZjOam5sdGOnNFBQUoKCgAPPmzbNpGquz4WRMTEyvMJzkCzJysYGEhAT89a9/xbZt2/DNN9+gsLAQy5cvt8qTizW3bG9vd5q5JWtKGR4ejscff9zqz3U2nJw3bx7xBSNcB2uAqVaroVQqbTLAFIvF6Nu3LxobGxEUFOSU+0CpVCI7Oxvp6ek2mVKyhpMAepXhJF8QcbER1gBz6NCh2Lx5MyoqKrB69WqrUnG9vb0RGBgItVoNsVgMsVjs0Fh//PFHlJSU4IMPPrCqt8UwDC5cuIDdu3cjJCQEzzzzDPEFI3QJm2qv0+mg0+lgNpvh7+9v1VRXeHg4Nz02aNAguzO2rIFhGOzZswc+Pj6YO3euVZ+haRpVVVVoaGhAWFgYUlJSep0vGB+QaTE7GTt2LP76178iMDAQb7/9Nn755RerMmkCAgLg4+PjcHPLsrIyfP/991abUup0Omzbtg0//vgjMjMzieEkwSokEgkCAwNhsVhsMsB0lrnl+fPnUV5ejoULF1rVwdLpdNcZTg4dOpQIi52QkUsPiIqKwssvv4y9e/di9+7dKCoqssoAk50ec5S5pdFoxNtvv221KWV1dTW2bt1KDCcJdsHWxNhigOkMc0tbTSlZw0lfX99e7wvGB2Tk0kO8vLywaNEirF27ljPAvHz58m0/40hzS9aU8uWXX75lZlpnw8ng4GBiOEmwG3sMMIODgxESEoKmpibezS0tFgt27dqF4ODg25pSEsNJx0DEhSdSU1M5A8xPP/0UW7duveUN4yhzy8uXL2Pnzp149NFHMWDAgG7fJ5fL8d///heHDx/GtGnT8PTTTxPDSUKPsdUAMzo6GiKRiHdzy5ycHDQ2NmLx4sW3nNbqbDiZmprq8DWg3gSZFuMR1gDz999/x08//QSpVIrVq1d3u3bBt7mlRqPBu+++i2HDhmHx4sXdvq+goAA//fQTxGIxnnzySSQmJvb43AQCiy0GmI4wt7TGlJJhGNTW1qKmpgbBwcEYPHgw8QXjGTJy4RmKonDnnXfif/7nfwAA//znP/Hbb791uXjPt7kla0r54osvdnkjm0wm7NixA5s2bUJSUhLWrl1LhIXgEGwxwOTT3NJkMmHXrl3o169ft6aUBoMB+fn5qKmpQXx8PDIyMoiwOAAiLg4iNjYW//M//4PJkydj69at+Pzzz7u0f+HL3PLEiRP49ddf8ac//alLa5bGxkZ89NFHuHjxIpYsWYKHHnoI/v7+dp+PQLAGaw0w+TK3PHz4MORyORYvXtzl9FZbWxsuXboEg8GAzMxMxMfHkxouB0HExYF0NsCUSqV44403cPXq1Zve11NzS9aUctKkSZg+ffp1/2MYBidOnMAnn3wCLy8vPPfccxg3bhy5oQhOwxoDTJFIhNjY2B6ZW97KlJIYTjofIi5OgDXA7Nu3L95//33s2rXrulFKZ3NLW039GIbBBx98wAlHZ9HQaDT49ttvsXfvXowfPx7PPvssMZwkuIzbGWBKJBLO3NLWaWKdToc9e/YgMTHxJpsj1nCytbWVGE46EdLCToI1wDx06BBngLl69WrOAJM1t2Sr9629+H/55RecO3fuJlNKqVSK7du3g6ZpPProo1YVUhIIjuZ2BpisuWVdXZ1N5pb79++H0WjEwoULr+tgdTacHDFiBPEFcyJk5OJERCIRZ4CpVqvx1ltv4ezZs9z/bTW3bGxsxJdffol77rmH661ZLBbs27cPX331Ffr164e1a9cSYSEIilsZYNpjbllQUID8/HzMnTuXm+oymUwoLCzkDCczMzOJsDgZIi4ugDXAHD58OL7++mt888030Ov1nLml2Wy+bvGfYRi0t7ejtbUV7e3tYBgGNE3jnXfeQVhYGJ588kkA1xYrP/30U5w4cQJz587F6tWrybwyQbCIxWIEBQWBoigolUro9Xru73379kVHR8d1u8Cy9wH7YhgGSqUS+/btu86UUiaT4eLFi1Cr1Rg6dCgSEhKcbu9PAChGCPuO9mLOnDmDLVu2IDg4GI8//jgGDhzI2WiIRCJs3boVn3zyCcrLy7nPJCUlYdKkSaivr8fHH3+MIUOG4OLFi1xF8rJlyxAXF+fCb0Ug2IZOp4Ner4ePjw9ngFldXQ29Xo/IyEhs3rz5pvsgMTEREyZMQGpqKtatWwdfX19UV1ejvr6eGE4KACIuAqC1tRUbNmxAdXU1Fi5ciNmzZ2PHjh1YuXIltFotKIrqcppMLBbj559/hkqlQl5eHkaPHo2FCxc63G2ZQHAEJpMJWq0WDMNwRZfffvst1qxZw41quroPJBIJtm/fjvj4eGg0GgwcOJCYrgoAIi4CwWKxYM+ePTh48CAYhsGGDRsAdH0zdYaiKCxduhQvvfQShg8f7oRICQTHwTAMt9B//PhxLF68GAzD3PI+oCgKFEXho48+wiOPPOKUPWIIt4eIi8A4d+4cJk+ebLWRH0VRkEgkqK+vJ5sZETyG5uZmJCYmQqfTWZXcQu4D4UFWuQTG6dOnbXKIZRgGOp0OmzZtcmBUBIJz2b59OzdFZg3kPhAeZOQiIBiGQXJyMioqKmyywKAoComJiZBKpaTynuD2kPvAMyDiIiDa2tq4okp7P8+HqyyB4ErIfeAZkGkxAdE5p98eVCoVT5EQCK6D3AeeAREXAdHTLJegoCCeIiEQXAe5DzwDIi4CIiIiAklJSTbPF1MUhaSkJISHhzsoMgLBeZD7wDMg4iIgKIrCs88+a9dn16xZQxYxCR4BuQ88A7KgLzDkcjni4uKg0+lu2vOiK0QiESQSCerq6kh+P8FjIPeB+0NGLgIjNDQUO3bsAEVRtzXbE4lEoCgKO3fuJDcUwaMg94H7Q8RFgMyePRv79u2DRCLhrC06w/5NIpFg//79mDVrlosiJRAcB7kP3BsiLgJl9uzZqKurw4cffojExMTr/peYmIgPP/wQ9fX15IYieDTkPnBfyJqLG8AwDDo6OqBSqRAUFITw8HCyaEnodZD7wL0g4kIgEAgE3iHTYgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOCd/w/+mxHOIc9MKAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1XklEQVR4nO2dd3xUZdr+rzNJJpn0CqQQSEJCCEnovahUpUhTV4qigm1XUURdfdd1V93f7lqwrm1FUaRZqAlIEVBCJ0AglUx679P7zDm/P3jPeQMkMDM5M3Nm8nw/n/knmTnnnmfOOddT7vt6KIZhGBAIBAKBwCMiVwdAIBAIBM+DiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4h4gLgUAgEHiHiAuBQCAQeIeIC4FAIBB4x9vVARAI7gDDMGhvb4darUZgYCAiIiJAUZSrwyIQBAsZuRAIt0Aul+Ojjz5CcnIyoqKikJCQgKioKCQnJ+Ojjz6CXC53dYgEgiChyE6UBELXHDx4EEuWLIFWqwVwbfTCwo5a/P39sWPHDsyePdslMRIIQoWIC4HQBQcPHsTcuXPBMAxomu72fSKRCBRFYd++fURgCIROEHEhEG5ALpcjLi4OOp3ulsLCIhKJIJFIUFdXh9DQUMcHSCC4AWTNhUC4ge+++w5ardYqYQEAmqah1WqxadMmB0dGILgPZORCIHSCYRgkJyejoqICttwaFEUhMTERUqmUZJERCCDiQiBcR1tbG6Kionr0+YiICB4jIhDcEzItRiB0Qq1W9+jzKpWKp0gIBPeGiAuB0AmJRNKjzwcFBfEUCYHg3hBxIfR6aJqGRqNBa2srTCYTBgwYYNdxoqKiUFRUhObmZp4jJBDcD2L/QuiVMAwDvV4PnU4HvV4PhmHg5+eH8PBwLF68GB988IHNx1yxYgWqq6tRVFSEkJAQJCcnY9CgQQgJCXHANyAQhA0RF0Kvwmg0QqvVcjUsPj4+CA4OhkQigdlsxvbt29HR0QGxWAyTyWR1xpi3tzcWLVqEyZMno6GhAaWlpbh8+TJyc3PRt29fJCcnIykpCX5+fg7+hgSCMCDZYgSPx2w2Q6vVQqvVwmKxwMvLC/7+/pBIJPDx8QEAVFdXY8OGDVAoFFi6dCkUCgXmzZtnVYU+ADz44IPQaDRYtGgRli9fDm9vb5jNZlRVVUEqlaK2thYURSE+Ph7JyckYMGAAvLy8nPL9CQRXQMSF4JGwhY06nQ5GoxEURUEikcDf3x++vr7c+xiGweHDh7F7927ExcVh9erV6NOnDwDrvcV27tyJmTNnYvfu3fj++++RkJCAF198EdHR0dz7dTodysvLUVpaitbWVojFYiQmJiIlJQX9+vUjtTEEj4OIC8FjYNdRtFot9Ho9AMDPzw/+/v7w8/O76QGuUCiwceNGFBcXY9asWViwYAG8va+fKZbL5di0aRM+/vhjlJeXc39PSkrCmjVrsHLlyuvWVMrKyvDee+9BJpPhqaeewp133nnTeeVyOaRSKaRSKVQqFQIDA5GcnIzk5GSEhYXx3SwEgksg4kJwewwGAzdKYRgGYrGYm/Zip61upKCgAN9++y0oisJjjz2GIUOG3PIcDMOgoqICv/zyC+655x4kJiZ2O9rQ6XT473//i6NHj2Lq1Kl4+umn4e/v3+Uxm5qaIJVKUV5eDqPRiMjISKSkpCApKanLzxAI7gIRF4JbYjKZOEGxWCzw9vbmpr1uHH3c+Lldu3bhyJEjyMjIwMqVK62uTZHJZDh06BBmzZpl1Qjj+PHj+PzzzxEUFIR169Zh8ODB3b7XYrGgpqYGUqkU1dXVYBgGcXFxSE5ORkJCwi2/E4EgRIi4ENwGi8UCnU4HrVYLk8nEuRH7+/tDLBbf9vONjY3YsGEDmpqasGTJEtx11102rXXYKi4A0NzcjPXr10MqlWLZsmVYsmRJt6MpFoPBgPLyckilUjQ1NcHb2xuJiYlITk5GbGwsWZ8huAVEXAiChmEYTlAMBgMoiuLWUXx9fa160DIMgxMnTuCHH35AZGQkVq9ejbi4OJtjsUdcgGuiuG3bNvz8888YOnQoXnjhBav9x5RKJcrKylBaWgqFQgF/f38MGjQIKSkpxMOMIGiIuBAECVvgyK6j+Pr6QiKR3HIdpSu0Wi2+//57XLx4EVOmTMEDDzxg1SinK+wVF5aCggK8//77MBgMWLNmDcaNG2fT51taWiCVSlFWVga9Xo/w8HAuESAgIMDmeAgER0LEhSAYjEYjN0qhaRre3t7w9/eHv7+/XTUhUqkUX3/9NQwGAx5++GGMGDGiR/H1VFyAa8aW//nPf3DmzBncc889eOyxx2wWO5qmUVdXh9LSUlRVVcFisSAmJgYpKSlISEiwWzwJBD4h4kJwKRaLhStwNJvNEIlEnKCwBY62QtM0srOzsX//fgwaNAirVq3iJcWXD3EBrk3THTx4EF9//TX69euHF1980W4/M6PRiMrKSkilUtTX18PLywsDBw5EcnIy+vfvb9Moj0DgEyIuBKdD0zQ3Qulc4CiRSHpsj9Le3o6vv/4alZWVmDdvHu655x7eHrB8iQtLTU0N3nvvPTQ0NOCxxx7DPffc06PFerVajbKyMkilUnR0dMDPzw+DBg1CcnIyVxhKIDgLIi4Ep8AwDFePwhpF+vr6cvUofGRA5ebmYvPmzfD398eqVauQlJTEQ+T/B9/iAlwbeXz77bfYt28fxowZgzVr1iA4OLjHx21vb0dpaSnKysqg1Wo5I83k5GRejk8g3A4iLgSH0pVRJCsofHlrGQwGbN++HadOncLo0aOxfPlyhxQgOkJcWM6fP4+PPvoI3t7eWLt2LYYNG8bLcRmGQX19PaRSKSoqKmA2m9GvXz/OSLOzFQ6BwCdEXAi8wxpF6nQ6mM3mLo0i+aKmpgYbNmyAXC7Hgw8+iAkTJjisDsSR4gIAHR0d+PDDD3HlyhUsXrwYy5cv59XckjXSLC0tRV1dHWekmZKSgvj4eGKkSeAVIi4EXuhuHeVGo0i+YBgGR44cwc6dOxEbG4vVq1ejb9++vJ+nM44WF+Da99q5cye2bNmCxMREvPjii+jXrx/v59FqtVyhJmukmZSUhOTkZGKkSeAFIi4Eu7HVKJIvlEolvv32WxQWFmLmzJlYuHChU+xRnCEuLFKpFO+99x4UCgVngOkoZDIZZ6SpVqsRFBTErc+EhoY67LwEz4aIC8Fm7DGK5IvOhpOPPPIIhg4d6tDzdcaZ4gJcM8D88ssvcezYMdxxxx146qmnHGpmyRpplpaWoqKiAkajEVFRUdyOmhKJxGHnJngeRFwIVmEymbhpL1uMIvnCbDZj586dOHLkCNLT0/HII49YbTjJF84WF5bff/8dn3/+OUJCQrBu3TqkpKQ4/JwWiwXV1dWQSqWoqanhjDRTUlIwcOBAYqRJuC1EXAjd0lOjSL5oamrChg0b0NjYiMWLF2PatGkuWRNwlbgA19rgvffeQ0VFBZYtW4bFixc7rUBSr9ejoqICpaWlaG5uho+PDxISEpCSkoKYmBiyPkPoEiIuhOvgwyiSz1hOnjyJH374AWFhYXj88cfRv39/p53/RlwpLsA1sd+6dSt27NiB9PR0rF271unmlUqlklufUSgUCAgI4Ao1iZEmoTNEXAgAbjaKdOY6SlfcaDh5//33u7wmw9XiwnLlyhV88MEHMJlMWLNmDcaOHeuSOFpaWlBaWory8nLOSDMlJQWDBg0iRpoEIi69ma423OqJUSRflJWV4euvv4Zer8dDDz2EkSNHuiyWzghFXIBrBpiffPIJzp49izlz5uDRRx91mWElTdOora2FVCrljDRjY2ORnJyMxMRE3mubCO4BEZdeRndGkRKJxOVuujRNY9++fdi3bx8GDRqExx57DOHh4S6NqTNCEhfg2rThL7/8go0bNyI6Ohrr1q2z2wCTL4xGIyoqKiCVStHQ0ABvb2/OSDMuLo4YafYiiLj0Amia5upRXL2O0h2s4WRFRQXmzZuHOXPmCO5BJDRxYamursb69evR2NiIRx99tMcGmHzBGmmWlpZCJpNxRpopKSmIiopydXgEB0PExUNxhlEkX1y4cAHff/89JBIJVq9ezbvhJF8IVVyAayOGjRs3Yv/+/Rg3bhyeffZZp6dq34q2tjZuozOtVovQ0FCuUFNIcRL4g4iLh+EMo0i+MBgM+OGHH3Dy5EmHGk7yhZDFheXcuXP4+OOP4ePjgxdeeAEZGRmuDuk6aJpGQ0MDSktLUVlZyRlppqSkIDEx0eVJGwT+IOLiAZjNZi59mDWKZOtRhLqYWltbi6+++goymQwPPvggJk6cKKjRVFe4g7gA16YYP/jgAxQUFGDJkiVYtmyZ4DoWwLWEkqqqKkilUs5Ic8CAAUhOTiZGmh4AERc3xdlGkXzBGk7u2rUL0dHRePzxxx1uOMkX7iIuwLXrY9euXdiyZQuSkpKwbt06hxhg8oVWq+U2Omtra4Ovr+91RpoE94OIixvhKqNIvuhsODljxgwsWrTIrWxE3ElcWDobYD799NO44447XB3SbZHJZNxGZ52NNFNSUhASEuLq8AhWQsTFDei8ME/TNMRiMTdKEVpGVXcUFhZi48aNAIBHH33UqYaTfOGO4gJcGxV8+eWX+O2333DXXXfhySefdAsTSoZh0NjYyG10ZjQa0adPH26jM3f4Dr0ZIi4Chd1wizWKZDfccpZRJF+YzWbs2rULv/76K4YOHYpHHnnEbbfZdVdxYfntt9/w+eefIzQ0FC+++CKSk5NdHZLVmM1m1NTUoLS0FLW1tWAYBv3790dycjIx0hQoRFwEhFCMIvmiubkZX331FRoaGrB48WJMnz5d8FN3t8LdxQW43gBz+fLlWLx4sdv9Jnq9ntvojDXSTExMRHJyMjHSFBBEXFwMaxSp0+mg1+u5AkeJROIW6yhdwTAMTp06he3btwvCcJIvPEFcgGudmC1btmDnzp3IzMzE888/LygnBFtQKBSckaZSqURAQABXP+Ou38lTIOLiIly54ZYj0Wq12LJlC3JzczFp0iT84Q9/EHT2mi14iriwXL58GR988AHMZjOee+45jBkzxtUh9Yjm5mbOSNNgMCAiIoLb6IwYaTofIi5OpDujSIlE4hFzxuXl5fj666+h1WqxYsUKjB492tUh8YqniQtwLYPv448/xvnz5zF37lw88sgjbjkF2xmaplFTUwOpVIrq6mrOSDMlJQUJCQmCrf3yNIi4OBjWKFKn03HrKEIxiuQLmqaxf/9+ZGdnIzExEatWrfLIvT08UVyA/zPA/OabbxATE4MXX3wR8fHxrg6LF1gjzdLSUjQ2NnJGmikpKYiNjXXrWQKhQ8TFAbiDUSRfdHR04Ouvv0Z5eTnmzp2LuXPneuwN66niwlJdXY333nsPTU1NWLVqFWbPnu1R16pKpeKMNOVyOSQSCbfRGTHS5B8iLjzhTkaRfHHx4kV8//338PX1xapVq9wqtdUePF1cgGs9/W+++Qa//PILxo8fj2eeecYjjSVbW1s5I02dTofQ0FBuozNP/L6ugIhLD3Eno0i+MBgM+Omnn5CTk4ORI0fioYceErThJF/0BnFhOXPmDD755BP4+vrihRdeQHp6uqtDcgg0TaO+vh5SqZQz0oyOjuYKNT1l6toVEHGxA3c0iuSL2tpabNiwAR0dHfjDH/6ASZMmeeSorCt6k7gA1www33//fRQWFuK+++7D0qVLPbbDBFxLuKmsrIRUKkV9fT0oiuI2OouPj/fY6V5HQcTFStzVKJIvGIbB0aNHsXPnTkRHR2P16tW9zlCwt4kLcO2637FjB7Zu3Yrk5GSsW7fObYxGe4JGo0F5eTlKS0vR3t7OGWmmpKT0iu/PB0RcbkFno0iDwQCGYbgCR09dR+kKlUqFb7/9FgUFBZg+fToWL17sEanTttIbxYXl6tWrWL9+PVQqFZ5++mlMnTrV1SE5jY6ODq5QU6PRIDg4mCvUJEaa3UPEpQsMBgNXNd95HcWdjCL5oqioCBs3bgTDMHjkkUc8du7dGnqzuADXCmQ///xzHD9+HNOmTcMTTzzRq8wjWSPN0tJSVFRUwGQyoU+fPkhJSUFSUhL8/PxcHaKgIOLyv3iKUSRfmM1m7N69G4cPH0ZaWhoeffRRtzWc5IveLi7AtQfsb7/9hi+++AJhYWF48cUXMWjQIFeH5XTMZjOqq6shlUpRW1sLAJyR5oABA3rlM+NGerW40DTNCUpno0iJRNIr1lG6o7m5GRs2bEB9fb1HGE7yBRGX/6OxsRHvvfceKisr8dBDD2HhwoW99hrR6/XcRmctLS0Qi8WckWZ0dHSvbZdeJy5dGUWy9SjuahTJFwzD4PTp09i+fTtCQ0OxevVqj6nU5gMiLtdjNps5A8zhw4fj+eef7/XtolAoUFpaCqlUCpVKhcDAQAwaNAgpKSm9rm16jbh4qlEkX2i1WmzduhXnz5/HxIkT8eCDD/bq0VtXEHHpGtYA02Kx4LnnnvM4Tzl7aWpqglQqvc5Iky3U7A11YR4tLp5uFMkXrOGkRqPBQw89RB4O3UDEpXsUCgU+/vhj5ObmYt68eVi5ciUpQPxfLBYLamtrUVpaiurqajAMwxlpDhw40GNr4zxOXDxtwy1HQtM0fvnlF2RnZyMhIcFjDSf5gojLrWEYBvv27cO3336L2NhYvPTSS4iLi3N1WILCYDCgoqICUqmUM9JMSEhAcnKyxxlpeoS4sOsovcEoki9kMhm+/vprlJWVebzhJF8QcbGOqqoqvPvuu2hpacHq1asxa9Yscg92gUql4upn5HI5/P39OSPNyMhIV4fXY9xaXBiGgUwmu8ko0s/Pjzwob0F+fj6++eabXmM4yRdEXKzHYDDg66+/xsGDBzFhwgQ8//zzpA7kFrS2tqK0tBRlZWXQ6/UICwvD2LFjMXDgQFeHZjeCFBdbQpLL5fDx8bFrYd6TelO2tllDQwOSk5Ntnu/1pDYDbGs3jUaDK1euIDMz0+adDT2p3Wxps46ODrS3t9vVgfGkNgOsaze2w9zS0oI+ffrYtVWzUNpNkOKiVCp5XeRiGOamBrdYLAgMDOTtHK4mKyvrtvPbBoOhRxlgKpXK42w/CgoKEBoaatV7WX85WzoyZrMZZrPZowoNt23b5tAetdFohE6nw9133+2wc7iC3Nxch65pms1mmEwmpKWlOewctiDIlCmz2czbngp6vR4qlQpisfi6h0hHR4dHiUtTUxPmzp3b7f/37t2LvLw8pKenY/HixXad46uvvvI4cVEqlQ67GWmaxqFDhxASEuJR4lJXV4cHHnjAIceWSqX44osv0K9fP48TF5lMhpEjRzrk2EajEXv37kVoaKhgxEWwCxMURfX4BVwTkZCQEK5wsvP/PAmKoiASibp8Xb58GUePHsWKFSvw22+/obS0tNv33urlqdjTFta8ZDIZNBqNq7+eQ/Dy8uL9RVEU/v73v2PRokWu/noO4Vb3aE9f58+fF1x5hec+MXAt997Hxwe+vr6IiIiATCazab7YE2AYBhs2bMAzzzyDQYMG4fHHH8dnn33W69rBFVRWVto1Z95b2b59OwIDAz1udOwMSkpKcMcdd7g6jOvwWHFhGAYajQYRERGgKIqrcaFp2sWROZfCwkJ4eXlxC6qZmZkwGo1QqVQujszzqa+vR1JSkqvDcAtUKhV+/PFH/Pvf//bImQVHwjAMaJoWXEfGY8WFFRF2Oofd3Kujo8OVYTmdDRs24NFHH+VuWIqiMHr0aHz99dcujszzMRqNiI6OdnUYgodhGPzlL3/BrFmzPKK+w9m0trZCJBIJTpQ9Vlw6Ojpu2tArNDQURqPRhVE5F4vFAr1ej+HDh1/39+XLl+Pq1atkaswJEFeI23Pq1Ck0NTXhySefdHUobsnRo0cxYsQIV4dxEx4rLkaj8aYUU1ZoestD9dixYwgLC7upR8MWs+n1eleE1StgrzGh9SaFhsFgwPr16/H3v/8dXl5erg7H7WAYBgqFgoiLs+juxmYzxXQ6nSvCcjp79uzBY489dtPfKYpCQkICduzY4YKoege9aYRsLwzD4M0338TIkSMxZMgQV4fjlrBrp0IUZo8UF5VKxaU23khwcDAUCoULonIuDMPAZDJ1W1+xcuVKnDp1yslR9R4qKyttruLvbZw4cQJSqRR//vOfyQjPTg4dOiTYrcc9Vly6834KCAjwWIvrzpSXl8PHx6fbm7Zv376gadpqSwqCbVy9ehWpqamuDkOwKBQKvP/++3jjjTd6xf3oCBiGQXt7O8aNG+fqULrE48SFfRDeaiG1N9jKb9y48ZYV+xRFwcvLCzU1Nbc8jkqlwnfffQeZTMZ3iB6NXq93a9NBR0LTNF555RXcfffdRIB7QGVlJXx8fARXPMniceJiNpsBdL+Q6qkV+p1hezQzZsy45fumTZuGTZs23fI97733HnQ6Hd5//30+Q/Ro2A6OEOfBXQ3DMPjiiy9AURQef/xxj78XHQXDMDh27Nht73FX4nHiIpPJesUWordCqVQCwG17NHPnzkV9fX23/zeZTGhubsYTTzyB+++/n9cYPRmVStUrOjH2cPz4cRw7dgxvv/22R1sKORq5XA6LxYL+/fu7OpRu8ahfl13EDgkJcXUoLmXjxo1WbVXMOiRbLJYu/793717ExsbCy8sLmZmZvMboyZw/f55MiXVBWVkZPvroI7z11lu8GdP2RhiGQVZWFiZMmCDoDozHiQvQu2sLGIZBSUkJli9fftv3UhSF4OBgnDx5ssv/HzlyBKtWreI7RI+GYRi0tbXdVLja22lubsZf/vIXPP300xg8eLCrw3FrysvLYTKZBJslxuJR4sIaVfZWcWEYBkVFRRCLxVbv+rds2TLs2rWry2PRNE3sS2yErW8hGVD/R0dHB1566SXce++9mDFjRq+9P/lAq9Xi6NGjmDt3ruDbUZhpBnbAMAy0Wi369u3r6lBcxpEjR7B3716bFkozMzOh0+lu2lCtrKysVwu1vZw+fRpxcXGk3f6X5uZmvPLKK7jjjjuwbNky0i49QK/XY9euXUhPT3eL55zHjFzYdYPenKFTUlKCiRMn2jRcZveDaGhouO7vmzZtwj333MN3iB4NTdNobm7G2LFjXR2Ky2EYBsXFxVi3bh2mTZuGxx57jAiLnTAMg9bWVuzcuRMxMTGCX2th8ZiRS3t7OwICAtyi0R3FH//4R7uylGbNmoWvvvoKf//73wH838U8c+ZMB0TpuVy5cgVBQUG9fkrMZDJh//792L59O1auXInZs2f36vvSXhiGgUqlQkFBAUpLSzFs2DAMHz7cbdrSbcSFYRhu6ubGxqVpGmazGX369HFRdMLA3tTOuXPn4sCBA1z7srsnCrU4yxHc6EJg6w2s1+tx9epV3HvvvXyG5VbQNA2pVIpNmzZBLpfj73//O1JSUtzmYehq2GecTqdDU1MTKioq0NzcjL59+2L+/PkIDw93q7YU7NPDZDJxDzez2QyFQgGLxQKxWIzg4GBu/wI2O8ff39+tGl5I+Pj4IDAwECdOnMCUKVOwceNGjBgxote0Z1lZGdra2mAymeDl5YWAgAAEBQUhMDAQEokEvr6+8Pb27nZUaDKZcOTIESQnJ0MikbjgG7gOhmFgNptRXl6OrKwsFBYWYtasWVi0aFGvawtbYBNmLBYLDAYDVCoVmpub0dDQAIVCAYlEgvj4eIwePRqhoaFueS8KVlxaW1sRHh4Os9kMpVKJwMBA+Pn5Qa1Wo6WlBSEhIfD19YVGo4HFYkFUVJSrQ3Zr1qxZg3//+98YOnQoCgsL8cEHH7g6JKdRW1uLfv36wdfXF2azGWq1GrW1tdDpdLBYLKAoCn5+fggJCUFkZCRCQ0Ph6+sLhmEgl8uRl5eH4OBgQdqeOwqFQoG2tjYUFhbi9OnTaG1txaRJk/D222+jT58+bvkwdAYajQbV1dVobGyESqWC0WiE2WyGj48PwsLCkJCQgOjo6Os60O6KYMUlNDQUCoUCFEUhPDwcvr6+oCgKYWFh0Ov1UCqVUCqVoCgKUVFRbv0jCIH+/ftj1KhReO+99zBhwoRe1eu84447rhuVsNMTNE3DZDJBp9NBrVajo6MD5eXl123ZIBKJkJCQ0Oumf1555RUAQGxsLKZPn47Ro0cjJCSkV7WBPezatQuhoaGIi4tDYmIi/P39IZFIIJFIuNGxpyBYcRGJRAgKCuIa22AwcP+jKApBQUGwWCzw9vaG2WzmPMWsxdPWE7y8vJCfn9+jY4wZMwbx8fHo27dvl8fyRMNPkUiEpqam277P29sbffr0QWRkJEwmE4xGIzei8fb2vuUxPM2OyNvbGzNnzkRYWBgCAgIgEolQVlbG6zk8cf1UJBIhJSXlupGdXq+HXq/nzRhWSM4HFCNAP3VnheRJvQRnbE4lEok8TpRt7ZTYA+tA7Sl07ug5CpFI5HFZd73tWhOkuNgCu6DoaUNKR2KxWKDVauHv7y+YC9EdoGmaazdiumgdFosFer0efn5+5FqzAYvFAp1OB4lE4rbt5vZ3iNlsRktLi1N6BZ5CfX09XnzxxVs6IhNuRqFQYN++fb1iJ1O+qKqqwrJly1BVVeXqUNwKmUyGLVu2uPU+Sm4vLgQCgUAQHkRcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7RFwIBAKBwDtEXAgEAoHAO0RcCAQCgcA7bi0uDMOgra0NtbW1aGtrA8Mwrg5J8DAMg46ODqhUKnR0dJA2sxKGYdDe3o7W1la0t7eTdrMC9lrTarXkWrMB9lpjX27bbowbIpPJmA8//JBJSkpiAHCvpKQk5sMPP2RkMpmrQxQcpM3sg7Sb7ZA2sw9Paze3E5cDBw4wAQEBDEVRDEVR1/0I7N8CAgKYAwcOuDpUwUDazD5Iu9kOaTP78MR2cytxOXDgAOPl5cWIRKLrGv/Gl0gkYry8vNzqh3AUpM3sg7Sb7ZA2sw9PbTeKYdxjQk8ulyMuLg46nQ40Td/2/SKRCBKJBHV1dQgNDXV8gAKEtJl9kHazHdJm9uHJ7eY2C/rfffcdtFqtVT8AANA0Da1Wi02bNjk4MuFC2sw+SLvZDmkz+/DkdnOLkQvDMEhOTkZFRYVNmRMURSExMRFSqRQURTkwQuFB2sw+SLvZDmkz+/D0dnMLcWlra0NUVFSPPh8REcFjRMKHtJl9kHazHdJm9uHp7eYW02JqtbpHn1epVDxF4j6QNrMP0m62Q9rMPjy93dxCXAIDA3v0+aCgIJ4icR9Im9kHaTfbIW1mOyqVCiUlJT06htDbzdvVAVhDREQEkpKSbJ6bBICBAwdCJBJBq9XCx8cHPj4+DopSWPSkzeLj4+Hl5QWGYQQ9p+sIIiIiMHDgQFRVVdn82aSkJISHh/MflICpq6tDdnY2AgICoNFobPosu3bQW9pMJpOhoKAA+fn5qK6uBgBERUWhtbXVpuO4S7u5hbhQFIVnn30Wa9eutflza9asgZ+fH4xGIwwGAyiKgo+PD8RiMby9vT324WlvmwHAI488gvr6ejQ3NyMsLAxhYWG9QpR1Oh0uX76MyZMn2yUuy5Yt89jrqTMWiwVnzpxBdnY2Ll68iODgYMyfPx/bt2+3+Vhr1qzx6DZraWnhBKW+vh5eXl5ISUnB/fffj7S0NMTExGDt2rU2dwDdod3cYkEf4Ccf3GKxwGg0wmQywWKxgKIoeHt7QywWw8fHR/A/lq3I5XLExsZCp9NZdfF2bjOJRAKZTAaZTAaaphEUFITw8PAeT4EIEZqmUVJSgoKCAlAUhYSEBNxxxx3Q6/VWXWsURUEsFuPNN99EcnIypk6dKuiFVnvp6OjAL7/8gv3796OtrQ1DhgzB/PnzMWXKFGi1WpvuT4qiIJFIUF9fL/h6DVtgGAYNDQ2coLS0tEAsFiM1NRUZGRkYPHgw/Pz8uPd7cp2L24gLABw8eBBz584FTdO3fFiKRCJQFIX9+/dj1qxZXb7HYrHAZDLBZDLBbDYDADdtJhaLPUJoNBoNsrKysHz5cgC45cXbXZvRNA2FQoGOjg7o9XqIxWJuNOPl5eXw7+Bo6uvrceHCBajVaqSkpCAzMxNisZi71hiGsbrdBg8ejBMnTkAul2Po0KEYP378dQ8Sd4RhGOTn5yMrKwsnT56Et7c3pk+fjnnz5iEpKem691rbZuy99fTTT+Nf//oXgoODHfodHA3DMKiuruYERSaTQSKRIC0tDRkZGUhOTr7lyN+ea62755qQcCtxAa79EIsWLYJOp7vpf+xF6+/vj507d1r9A9A0DZPJBKPRyAlN5xGNSOQWeQ/XoVarodFoEBAQgJMnT2LJkiXQarUAcJ0w29JmOp0OHR0dUCgUAICQkBCEh4dDIpE48Js4BoVCgQsXLqCxsRHR0dEYNWoUQkJCrnvPwYMHbW43mqaRn5+Ps2fPgqIojB07FhkZGW53DWk0Gvz666/Izs5GTU0N4uPjMW/ePMyYMQMBAQHdfs7aNvvuu+9QW1sLiqLw8MMPIywszLFfiGcsFgsqKiqQn5+PwsJCqFQqBAYGIj09HRkZGUhMTLSp83WrdgOutZ2tzzVX43biAgBfffUVfvjhB1RWVqKiooL7e1JSEtasWYOVK1fe9KCwFoZhuKkzk8kE4JrQsCMad3hIsMISGBjIPQjkcjk2bdqEjz/+GOXl5dx77Wkzi8XCTZkZjUb4+fkhPDwcISEhgm8fo9GIK1euoLS0FAEBARg1ahTi4uK6fb+97abT6XD27FkUFBQgLCwMU6ZMQXx8vEO+E5+Ul5cjOzsbR44cgdlsxqRJkzB//nxkZGRYPZq3ts0UCgW+++47mM1mrFy5UvBTiWazGaWlpcjPz0dRURF0Oh3CwsI4QYmPj+/R9d9du8XExGDdunVYtWqV3c81V+B24kLTNF566SVMmDABS5Ys4fYmYdcE+JzOYhjmuhENwzDw8vLihEaI00IqlQparRZBQUHw9/e/6f9Mp/1c+GgztVrNHc/LywuhoaEICwuDr69vT74G7zAMA6lUisuXL4NhGKSnpyM1NdXqh4G97dbW1oacnBzU19dj4MCBmDx5suDmyo1GI3JycpCVlYXi4mJERkZizpw5uOeee3qUkWRNm6lUKmzatAk6nQ4PP/ww+vTp09OvwysGg4FbjysuLobRaESfPn2QkZGB9PR0xMTE8D6F3rndJBIJpFIpEhMTERMTw+t5HI3biUtRURE+/PBDvPbaa07tCTIMA7PZzI1qGIaBSCTips68vV2feKdUKqHT6RAcHOz0qSqTyYSOjg7I5XKYzWYEBAQgPDwcQUFBLl+/ampqwoULFyCXy5GUlIRhw4Y5vX3Kyspw8uRJaDQaDBs2DGPGjIFYLHZqDDfS2NiI/fv348CBA1AqlRg5ciTmzZuH8ePHO7XjpNFo8P3330OpVOKhhx5CdHS0087dFVqtFkVFRcjPz4dUKoXZbEZsbCw3QnG2ABYVFcFsNiMzM9Op5+0pbicu3377LcrKyvDWW2+59KHFTpsZjUZOaDqnODsbhUIBvV6PkJAQly4iMwwDpVLJ7UDo7e3tsnRmtVqNixcvora2FlFRURg1apRLp17MZjMuXbqECxcuwMfHBxMmTMCQIUOceh3TNI3z588jOzsb58+fR0BAAGbNmoW5c+fecnrQ0eh0OmzevBnt7e1YsWKF02NRKpUoLCxEfn4+Vxs2YMAAboTiyjWh1tZWXL16FWPGjBHcjMCtcCtxMZvNeOGFFzBjxgzce++9rg6Ho/OIhqZpLjXVGUWbDMNAoVDAYDC4XFhuRK/XQyaTQS6Xg2EYbmrkVgvCfGA2m1FYWIiioiL4+flhxIgRGDhwoEPPaQtqtRqnT5/G1atXERUVhalTpzq8ty6Xy3Hw4EFkZ2ejpaUFKSkpmD9/Pu644w7BPLAMBgO2bNmCpqYmLF++HAMGDHDo+To6OrgMr5qaGlAUhaSkJGRkZCAtLU0wWWwWiwVnz55FfHy8SzsAtuJW4pKXl4fPPvsMb7zxhsuHzt1hNpu5EQ0rNKzI8F1LwwqL0WhESEiIYB4SN0LTNORyOTo6OmAwGODr64uwsDCEhobyOv3CMAwqKyuRl5cHo9GItLQ0pKWlCWLKsisaGxuRk5ODlpYWJCcnY+LEibxaejAMg6KiImRlZSEnJwcikQh33nkn5s+fj5SUFN7OwydGoxHbtm1DXV0dli5disTERN6OzTAMWlpakJ+fj4KCAjQ0NMDb2xspKSnIyMjAkCFDulynFAIlJSXQ6XQYMWKEq0OxGrcSl//+979oamrC66+/7upQrIKtpTEajbwXbTIMA7lcDpPJhNDQUJfP31uLVqtFR0cHlEolKIpCSEgIwsLCerwG0tbWhtzcXLS3t2PAgAEYMWKEw0dIfMAwDEpKSnD69GkYjUaMHDkSI0eO7JEg6nQ6HD16FFlZWaisrERMTAzmzZuHWbNmCd6PCrg25fzjjz+isrISDzzwQI+EkGEY1NfXc4LS2toKsViMIUOGICMjA6mpqW5x77S3t6O4uBijRo1ym9R/txEXg8GAF154AfPnz8fdd9/t6nBshqZpbursxqJNW2tp3FVYOmM2m7l0ZpPJBIlEgvDwcAQHB9vUFjqdDpcuXUJlZSXCwsIwevRowWUcWYPRaERubi4uX74MiUSCSZMmITk52aZjVFdXIzs7G4cPH4Zer8eECRMwf/58jBgxwuVJFbZiNpuxY8cOlJaWYsmSJUhLS7P6szRNX1fUKJfL4e/vf11Ro1BHs91B0zTOnj2L2NhYt0hpB9xIXM6dO4cNGzbgX//6l+Dz4W9HT4o2GYaBTCaD2Wz2CM8vhmG4dGa1Ws2lM4eHh99SNC0WC4qLi1FYWAgvLy8MHz4cSUlJbvcQvRGFQoETJ06gsrIS0dHRmDp16i33/DCbzTh58iSysrKQn5+PsLAwLo24J3uFCAGLxYLdu3ejsLAQCxcuvGW2lMViQXl5OVfUqFarERwcjKFDh3JFjUKvwbodpaWlUKlUGDVqlKtDsQq3EZdPP/0UKpUKr7zyiqtD4ZWuija9vLw4oem8JkHTNOf1FRoa6vbCciNGo5EbzVgsFgQGBnJ+Zp1Fo7a2FhcuXIBWq0VqairS09PdcvR2K2pra5GTk4OOjg6kpaVhwoQJ102HtLS0cGnEMpkMmZmZmD9/PiZOnOh2vfJbQdM0srKykJeXh/nz52PkyJHc/0wmE1fUWFxcDJ1Oh/DwcC7DKz4+3u07G52RyWQoLCzE8OHD3cLjzy3ERaPR4MUXX8T999+PadOmuToch8EWbbKvzkWb3t7eUCqVoGkaYWFhHvUAuRGaprl0Zp1OBx8fH4SFhYGiKFy+fBlNTU2IiYnBqFGjBJPR4whomkZBQQHOnj0LhmEwevRomEwm/PLLLzhz5gwkEglmzJiB+fPnu81UiT0wDIP9+/fj/PnzmD59OoKCgpCfn4+SkhKYTCb07duXE5To6GiPEpTOMAyDc+fOoW/fvoLKfuwOt3hCXbp0CTRNY/To0a4OxaGwKcxisfi6ok2tVguZTAaKotxyPcFWRCIRQkNDERoaCr1ej8bGRhw9ehTV1dVc6u6NpomeiEgkQmZmJvr164cvvvgCf/zjH6HRaJCZmYk1a9bgrrvucpvF3Z6g1WoRFRUFpVKJV199FQMGDMC4ceMwY8YMpKenu/30n7VQFIXIyEi0trYSceGLc+fOYfDgwR7dS70RNoVZJBJBp9MhICAAgYGBsFgsUKlULi/adAbswuyVK1fAMAymTJmCiIgI6PV6lJWVITw8HKGhoW4/l94VDMOgtLQUWVlZ+O2338AwDGbPno3IyEgA19Za9Hq9x4qLQqG4rqgRAAYNGoQBAwagoaEBw4YNw9SpUz12lNIdkZGRaGxshFKpFPzzUPBPJaVSiatXr+Khhx5ydShOhzWIBIA+ffpw6y+dizY9dQO0xsZGXLhwAQqFAoMGDcKwYcO4AlGNRoOOjg40NTWhubmZ8zMTUgGpvRgMBhw7dgxZWVkoKytD37598fDDD2P27NmcaWFFRQVOnDiBbdu2ISMjA2PHjhVsjZMttLe3X1fUKBKJMGjQICxevBhDhw7l1hlycnJw5MgRmEwmTJ8+3SOud2sJCQmBWCxGa2ur4MVF8GsuR48exU8//YT33nvPLeoW+IJN1RWJRAgLC+u2d97VBmiOKtp0BiqVChcuXEB9fT369OmD0aNHd2u9YTKZuAQAs9kMf39/Lp3Z3b43u13w4cOHodFoMGbMGMyfPx+jR4/u8re3WCzIy8tDbm4uvLy8MH78eAwdOtStvjfDMGhubuZqUBobG+Ht7Y3BgwdzRY3djczOnDmDAwcOYPz48Zg9e7Zbfe+eUllZiZaWFowdO1bQ31vw4vLvf/8bgYGBeOaZZ1wditOwVlhu5MaiTQDciEboQmMymVBQUICSkhJIJBKMHDnS6kVqhmGgUqnQ0dEBjUYDb29vLp1ZyBl17HbBWVlZuHTpEkJCQnD33Xdjzpw56Nevn1XH0Gg0OH36NEpKShAREYGpU6ciNjbWwZHbD8MwqKur4wSlra0Nvr6+SEtLQ3p6OgYPHmx15l9ubi6ys7MxatQozJs3T9DXN5+o1Wrk5eUhPT1dcA7bnRG0uLS3t+PVV1/F6tWrMXbsWFeH4xTY3jj7gLR3PYHPok1HwjAMKioqkJeXB5PJhKFDhyItLc1uWxiDwcD5mVksluv8zITy8Glvb+e2C25vb0daWhq3XbC9Ytjc3IycnBw0NTVh0KBBmDhxomCmTWiaRlVVFTflpVAo4O/vj/T0dKSnp2PQoEF2rxvm5eVhz549yMzMxIIFCwRzXTua3NxchISE2Fxo60wELS4HDhxAVlYW3n//fY+YU74dRqMRcrmccxLm62HYXdGmqzdAa21tRW5uLjo6OjBw4ECMGDGCN28noW3PzDAMLl++jKysLJw6dQpisZjbLpgv/yw2CeDUqVPQ6/WclYwrRm8WiwVlZWUoKChAQUEBNBoNQkJCuKLGhIQE3q67goIC7Ny5E0OGDMHixYsFuc8S31RXV6OxsRFjx44VrKAKWlzeeust9O3bF0888YSrQ3E4rLD4+PggNDTUYb3szhug3a5o01FotVpcunQJVVVVCA8Px+jRox2aTtrV9sxhYWFOMSlUq9XcdsG1tbWIj4/H/PnzMX36dIetIZpMJly4cAGXLl2Cn58fJk6ciMGDBzvkXJ0xGo3XFTXq9XpERERwNSj9+/d32HVdUlKCn376CYMGDcL999/vsRmULFqtFhcvXkRaWlqPNnRzJIIVF9ag8umnn3YrJ1B7MBgMUCgUEIvFCAkJcdr0za2KNh2x06bZbOYsW3x8fDB8+HAkJiY67fs6c3vmsrIyZGdn4+jRo3ZvF9xTlEolTp48ifLycvTr1w9Tp07lvU5Kp9OhpKQE+fn5uHr1KkwmE/r168cJSr9+/Zz2fcvKyrB9+3YMGDAADz74oKDX2/jg0qVL8Pf3d0rHwR4EKy579+7Fr7/+ivXr13v0RWIwGCCXy+Hr6+tUYbkRR++0WV1djUuXLkGn03GWLa78XTtvz8wWbYaHh/do+tVoNOL48ePIyspCSUkJIiMjMXfuXNxzzz0u3Wyqrq4OOTk5aG9vx5AhQzB+/PgejZrUajUKCwtRUFCAsrIyWCwW9O/fHxkZGRg6dKhLixorKyuxbds2xMTEYNmyZR5nC9SZuro61NTUYNy4cYKcChSkuDAMg9dffx2JiYl49NFHXR2Ow9Dr9VAoFPDz8+NqGIRC5xENTdNc0aatG6DJZDLk5uaipaUFcXFxGDlypKBs329MZ7Zne+bGxkZkZ2fj0KFDUCqVGDVqFObPn4+xY8cK5qanaRpFRUU4c+YMLBYLRo8ejeHDh1sdn1wu59ZPKisrAQAJCQmcoAgpa6mmpgZbtmxBnz59sHz5co+of+oKvV6P3NxcDB48WJAuBYIUl5qaGvzjH//Ac889h6FDh7o6HIeg0+mgVCohkUgEk9XTHd1tgHarok29Xo/Lly+jrKwMISEhGDVqlGA3eANs356ZpmmcO3cOWVlZyM3NRWBgIGbPno25c+cKOhXYYDDg3LlzyM/PR2BgICZPntxtQkFbWxuX4VVbWwsvLy8kJycjPT0daWlpgjZPrK+vx+bNmxEWFoYVK1YIdhOwnnL58mX4+PjYtCWBsxCkuOzYsQMnT57Ee++9J9hMiJ6g1WqhUqncQlhu5HZFmwzD4OrVq8jPzwdFUcjMzERycrJb/Y4GgwEdHR3Xbc8cFhaGwMBAyGQyHDhwAPv37xfsdsHWIJPJkJOTg5qaGsTFxWHKlCkIDw9HU1MTJyhNTU3w8fHhihpTU1Pdym6mqakJ33//PQIDA/HQQw8JWgztpaGhAZWVlRg3bpzgkhgEJy4Mw+DVV19FRkYGli9f7upweIcVFn9/f0FND9nDjUWbjY2NKCgogF6vR2pqKoYNG+ZWD9wb6bw9c0FBAXJycnDlyhX4+vpi2rRpmDdvnmC3C7aWyspK7NmzB1evXgVN05yHXeeiRnde82xtbcWmTZvg6+uLhx9+2O06c7fDaDTi3LlzSE5ORt++fV0dznUIS+oAlJeXo6OjwyOLJjUaDdRqNXcDuzteXl7w8vKC0WjExYsXUVNTg4iICIwdOxYhISEwGo0AIKiiTVvQ6/U4efIksrOzUV5ejoiICG7PlOjoaMGmgN4OmqZRWVnJbawlk8nAMAwoikJ4eDjmzZuHzMxMt/zNbiQqKgqPPvoovvvuO2zcuBErV64U1PpQT2EzTFtbWwUnLoIbuWzbtg15eXn497//LZiKaj5Qq9XQaDQIDAz0GI80o9HIpaAGBARg5MiR6N+/P1e02XkDNCEUbVpLZWUlsrOzceTIERgMBm674OHDh8NisXCjmZ5sz+xszGYzV9RYWFjIFTWyKcMDBw6EXq/HmTNnUFRUhPDwcEyZMgX9+/d3dei8IJfL8d1334GmaaxcudJtOwZd0dTUhLKyMowbN05Qo0xBiQtN03jppZcwfvx43H///a4OhzdUKhW0Wi2CgoI8YmGRYRiUl5cjLy8PFosF6enpSE1N7TLzSAhFm9ZgMplw4sQJZGdno6CggNsueM6cOZzNfWfs3Z7ZmRiNRm79q7i4GAaDAZGRkZygxMXFddmBa21txfHjx9HY2IiEhARMnjxZcNmM9qBUKrFp0yYYDAY8/PDDgsywsgez2YyzZ88iMTFRUEkzghKXoqIifPjhh/jLX/6CAQMGuDocXlAqldDpdAgODnarxdDuaGlpQW5uLmQyGRITEzF8+HCrv5ezizatgd0u+JdffoFcLsewYcMwf/58TJgwweoFUmu3Z3YGOp0OxcXF3IjSbDYjOjqaE5S+fftaHZNUKsXJkyeh0+kwbNgwjB49WjDCaS8ajQabNm2CWq3GQw89ZLVBqNApLCyExWJBZmamq0PhEJS4fPfdd5BKpXjrrbc8YkpMoVBAr9d7hLBoNBpuXSUyMhKjRo3qskdvLd0VbTpjAzSGYXDhwgVkZWXh7NmzkEgkmDVrFubOnduj7YIZhuH8zDpvz+zobanZosb8/HyUlZWBpmnEx8dzghIREWH3sc1mMy5evIiLFy9CLBZjwoQJSE1Ndev7U6vVYvPmzZDJZFixYoWgU8etpaWlBaWlpRgzZoxgkmgEIy5msxnr1q3DtGnTsGDBAleH02NYYQkJCXHrIi6z2YyioiIUFRVBLBZjxIgRGDhwIO8Pl85Cw9bSsFNnfM0jKxQKHDp0CPv27UNjYyOSkpIwf/583HXXXbz/Rnq9nvMzYxgGwcHBCAsL4229TSaTcUWNVVVVAICkpCSkp6dj6NChvE9jqVQqnDp1ClKpFH369MHUqVPdutev1+uxZcsWtLS0YPny5T3qVAgBi8WCs2fPIj4+HnFxca4OB4CAxCUvLw+fffYZ3njjDUHNG9oK23s1GAwIDQ0VTC/CHqqqqnDp0iXo9XqkpaVh6NChTsmlt6doszsYhkFJSQmys7Px+++/g2EY3HHHHZg/f75TeuAWi4UbzRgMBvj6+nJ+ZrZOA7a2tnI1KHV1dfDy8kJKSgpX1OiMRJGGhgbk5OSgtbUVgwcPxsSJE902QcVoNGLr1q2or6/HsmXLkJCQ4OqQekRJSQn0ej2GDx/u6lAACEhcvvrqKzQ2NuL11193dSh2wzAM5HI5TCYTQkJC3FZY2tvbceHCBbS2tqJ///4YOXKky1Kn7d1pU6/X49ixY8jOzkZZWRn69euHefPmYdasWS5bnGa3Z1apVKAoCiEhIQgPD+921MQwDFc7lJ+fj+bmZvj4+CA1NZUranTFqJhhGBQXF+P06dMwmUwYNWoURowYIbgiPmswmUz44YcfUFVVhT/84Q+C3h/ldrS3t6O4uBijRo0SxDS8IMTFYDBg3bp1nMmfO9JZWEJDQ91y4VOn0+Hy5csoLy9HaGgoRo0aJaipj+522mRHNRRFoba2ltsuWKvVYty4cZg3bx5Gjx4tmHUCdqfRjo6Om7ZnBq7ZH7E7NXZ0dEAikWDIkCHIyMhASkqKYNJNjUYjzp8/j8uXLyMgIACTJk3CoEGDXB2WzZjNZvz888+QSqW47777MGTIEFeHZBc0TePs2bOIjY0VxDSfIMTl3Llz2LBhA/75z3/2aJHYVTAMwxkfdudFJWRomuZs0728vDBs2DAMGjRIMA/jrui8AZper8f58+dx6NAhFBYWIjQ0lEsjFlphWWfY7ZlbW1tRWlqKsrIy1NfXcyNfdqfGpKQkwaRsd4VcLseJEydQVVWF2NhYTJkyxe3uY4vFgp07d6K4uBiLFy9Genq6q0Oyi9LSUqhUKowaNcrVoQhDXD799FMolUq8+uqrrg7FZliLEIvFgtDQULcTlrq6Oly4cAEajQYpKSnIzMx0m1FXW1sbfvnlF+zbtw/t7e1ITU3FzJkzMX78eEgkEkEXbZrNZkilUuTn56OoqAhKpRK+vr6Ij49HYmIiUlJSEBkZ6ZJ0ZnupqalBTk4O5HI5hg4dinHjxgliesZaaJrG3r17cfnyZSxYsEAwaxe2IJPJUFhYiBEjRrh8Lczlk6RarRYFBQW47777XB2KzdA0DZlMBpqmHZ5uyjcKhQK5ubloampCdHQ07rzzTrcolGMYBnl5ecjKysLp06fh6+vLbReckJBwXdGmXq+HTqcTTNGmwWBASUkJCgoKUFxcDKPRiKioKIwbNw4ZGRmIjY3lEkJkMhlqamrg4+OD8PBwhIaGCv76io+Px9KlS5Gfn4+zZ8+itLSU+25CFPgbEYlEWLBgAby9vbF7926YTCaMGTPG1WHZBHudtLa2ulxcXD5yOXnyJDZt2oR33nnHLR5uLO4qLEajEVeuXEFpaSkCAwMxatQot8jzV6vVOHz4MLKzs1FXV4cBAwZw2wV353rQVdEmnxugWYNWq+WKGktLS2E2mxEbG8tNefXp06fbkcmN2zMHBwcjPDzcLVwedDodzp49y01TTpkyRRDrANbAMAwOHjyIM2fOYPbs2ZgwYYKrQ7KJsrIyyGQylwujy8Xlgw8+AE3TWLdunSvDsAl2u1wACAsLE/R8OAvDMJBKpbh8+TIYhkFGRgYGDx4s+B6lVCpFdnY2jh07BovFgsmTJ2P+/PkYOnSozdNFrMgYjUaHFm2qVCquqLG8vBw0TWPAgAFcUaOtvlad/cwcvT0z37S1tSEnJwf19fUYOHAgJk+e7BbGkQzD4OjRo8jJycG0adMwdepUV4dkNQqFAvn5+cjMzHSpC7RLxUWpVOKll17CihUrMGXKFFeFYRPuKCxNTU24cOEC5HI5kpKSMHz4cEEXdhoMBm674KtXryIqKgpz587F3Xffzdt2wXwXbcpkMi7Dq7q6GhRFITExkdupka+b3BHbMzuD8vJynDhxAhqNBsOGDcOYMWPcYm3v+PHjOHr0KKZOnYq77rrLbda/zp07h8jIyG43gnMGLhWXY8eO4YcffsD69etdPj9oDWwKqUgkQlhYmOB7jWq1GhcvXkRtbS2ioqIwatSoHlmBOJqGhgZuu2CVSoXRo0dj3rx5GDdunEPb2t6izZaWFk5Q6uvr4e3tfV1RoyOnr7ranjksLAzBwcGCfQCazWbk5eUhNzcXPj4+mDBhAoYMGSLYeFlOnTqFQ4cOYcKECZg1a5bg4wWuOXu3tLRg7NixLovXpeLyzjvvQCKR4Nlnn3VVCFbjTsJiMplQWFiI4uJi+Pn5cZYtQsRiseDcuXPIzs5Gbm4ugoKCuO2CY2JiXBLPjUWb3t7enNA0NjZygtLS0gKxWIwhQ4ZwztDOHkGw2zPLZDJoNJrbbs8sBDQaDU6dOsWNSqdMmeKS39oWzp07h/3792PMmDGYM2eO4AVGrVYjLy8P6enpLpuGdJm4dHR04JVXXsFjjz2G8ePHuyIEqzGZTJDL5ZytulCFhWEYVFZWIi8vD0ajEWlpaUhLSxNksgG7XfC+ffvQ2tqK1NRUzJ8/H1OmTBHMFA8rNOXl5ZxtvVKpREBAADIyMrgtnIXyEO+8PTNN0wgKCuLcmYVIU1MTjh8/jpaWFiQnJ2PixImC3p310qVL2Lt3L4YNG4Z7771XsM8BltzcXISEhLjMdcBl4nLw4EHs3bsX69evF/T8Pzv9wPYIhdpjaWtrQ25uLtrb2zFgwABB5LnfCMMwKCgoQFZWFk6cOAFvb29uu2AhVXZbLBZUVFRwOzWqVCoEBARgyJAhSE5ORv/+/eHl5cWNaIS20yZN05yfmV6vh1gs5tKZhbZGyDAMrl69ilOnTsFgMGDUqFEYOXKkIDtEAJCfn49du3YhLS0NixYtElx7dqa6uhqNjY0YO3asS65Pl4nLP/7xD0RFReHJJ590xemtwmg0Qi6Xw8fHB6GhoYIUFq1Wi7y8PFRWViIsLAyjR49Gnz59XB3WdWi1Wvz666/Izs5GdXU14uLiMG/ePMycOVMwvWqTyXRdUaNOp0NYWBiX4TVgwADu92cYhps6E/pOm1qtFh0dHVAqlQDA+ZkJrbjRaDTiwoULyMvLg0QiwaRJkwTr81VUVIQdO3YgJSUFS5YsEawQarVaXLx4EWlpaS7ZedMl4tLU1ITXX38dTz31FEaOHOns01uFwWCAQqEQrLBYLBYUFxejsLAQXl5eGD58OJKSkgQVZ2VlJbKysnDkyBEYjUZMnDgR8+fPx7BhwwQRp8FgQHFxMQoKClBSUgKj0Yg+ffpwghITE3PbODsXbZrNZkFsgNYVZrP5pu2Zw8LCBJfOrFAocPLkSVRUVCA6OhpTpkwRXGcJuGaz8uOPPyIhIQEPPPCAYKZGb+TixYsICAjA4MGDnX5ul4hLVlYWDh8+jPXr1wvyRzEYDJDL5fD19UVISIggHoSdqampwcWLF6HVajmHXKG0I7tdcFZWFgoLCxEREYE5c+bg7rvvFoTflFarRVFREVfUaLFYEBcXd11Ro710twGaM4s2rYlR6NszA0BtbS1ycnLQ0dGBtLQ0jB8/XnDFoxUVFdi2bRvi4uKwdOlSQbUfS21tLWprazFu3Dind3ScLi4Mw+Bvf/sbEhIS8Oijjzrz1Fah1+uhUCjg5+cnOMcAuVyO3NxcNDc3IzY2FiNHjnRpkVRnmpubsW/fPhw4cAAKhQIjRozAvHnzMH78eJc/VJVKJVfUWFFRAYZhritq5Kt25kacVbRpLzduzxwQEIDw8HAEBQUJokNF0zQKCwtx5swZMAyDMWPGIDMzUzCjQeDausbWrVvRt29fLF++XDDJKCx6vR65ublITU11eufO6eJSW1uLt956C8899xyGDh3qzFPfFp1OB6VSKThhYRgG58+fR1lZGYKCgjBq1CjBpG7KZDJ88MEHOHfuHPz9/bntgvv37+/q0FBVVYV9+/ahuroaIpEISUlJXFGjs7OSuivaFEJvnE1n7ujogFarhY+PD6Kiohwmurai1+tx7tw55OfnIyQkBDNmzBDUVhB1dXXYvHkzIiIisGLFCsGtZ12+fJlLmXcmvIhLdna21f5USqUS1dXVSE9Pt7p3ZDKZYDAY7KriZ3P/rUGv18NkMt32wcMwzHWx0zRt1wWVn59vdQ56RUUF/Pz8EB0dfVO7mc3mbr+jwWCwKxNr8+bNVu3MxzAMysrKEBYWhvDw8Jvm79ndF7tCoVBgzpw5NsX166+/Wv1gUavVqKqqQmRkJCIiIripQ3b6qrupRI1Gg3HjxtkUF3Ctc0JR1G3XMMxmM7c+Y+t1wzCMXb3jlpYWq7Iy2bVGPz8/m0bFNE2Dpmm7Fo7PnTuH4ODg207tajQaVFRUICkpyWZR1uv1Nndmf//9d0RFRVn1nFKr1aioqLAp9Z/tcNhjj19TU2N1Nmh7ezv0er1NHoI0TcNisfRIxHkZmzc0NNi0ydfkyZOtfm9jYyO+//57hIeH2yUu7GZM1mDNnKlarYbRaISPjw9nh65UKu0SF4VCYfUF39WFwTAMCgsLUVdXh6CgIIwbN+6mC/vkyZN2iUt1dTUefPBBq97bXZ3Sjh07cOzYMYwYMQKrVq266f//+te/bBaX5uZm3HXXXVa//0bzPp1Ohx07dkAul2PkyJGYOHHiTZ/ZunWrXeJisVhgNpsRFBR0S4HpyfqYRqOxS1wMBgOioqJu+76goCCbp0/UajXa29u5lGdb6ejogFQqtep6s2e2o6ysDDU1NTZ/tqWlBY2Njbj//vuter8tyUl6vR5btmzhNuWzFa1Wi7i4OKvea+sI1GAwoLS0FL6+vj0SF17SRCiKgpeXF+8vkUiEjz/+uMcZZRRF8fLSaDQwGAwIDAzkzAR7ikgksutFURSuXLmC8vJyZGZmwmw249ixY1zPmX31pM28vb3tfl24cAGbN2/GypUrsX//fpw9e/am99hLT66nr776CiKRCNOmTcOhQ4eQl5d30/t6gq+vL1QqFdeGfL2Aa52JnsBnPOzLaDRy9kI9QS6Xc4XKfL5qa2vx+++/291epaWlUCqVvMf166+/9qiTQVEUWlpabrrf+XgVFxfzspYrnBzELqiuroZKpcLMmTNdHQoYhoFWq0VYWBh8fX259GQ+BMYeVCoViouLMXPmTMTFxWHq1KlQKBSora11STydYRgG//jHP/Daa69hwoQJeO211/D222/3+OHYUwoLC9HR0YFly5YhIyMDq1atwk8//cTVqvABO/VkMBh4OyYLK1pCwWw2o7KyEpGRkT1ewxo8eLDdInArfvvtN4wdO9buz2dkZGDv3r08RnSNy5cv49577+3RMSoqKrj6Jb4wm83Q6XQYMGBAj48lWHFhGAaffPIJHnzwQUHk4et0OohEIq5nS1EUQkNDXeIuwDAMjhw5gmHDhnFFiF5eXpg6dSpOnTrl8of40aNHIRaLuZt69OjRMBqNaG1tdVlMDMNg+/btWLFiBfcbDhgwAAkJCdi+fTtv56EoCoGBgdDpdLz+Dmxqs1CgaRpVVVUIDAy0el3iVkycOBENDQ08RXcNNu06IyPD7mPcfffdqKqq4rXtaZoGwzA9LmxMTk5GcXExr7GVlJQgIiKCl2eu65/a3VBbWwutViuYfRTUavVNGWQURblEXBQKBfR6PdLS0q77e9++feHt7Y3Kykqnx8TCMAw++ugj/PWvf+UeOBRFYdasWfjXv/7lsri0Wi1MJhNSUlK4v1EUhYcffhgFBQUwGo28ncvLywsURfE6IjIYDIKpZWIYBtXV1fDy8kJsbCwvacvsmiWfD0qLxQIAPXpQsve32WzmJSbg2ghaIpH0uN0iIyO5nUv5wGKxQKFQ8OaMIEhxYUct999/vyDy7dkLvqt1AlfE9/vvvyMzM/Omc1MUhalTp+LcuXMu6+UqFAoYDAYMGzbsur8/9dRTKCoqcllcP//8M1JTU29qM4lEgpSUFGzdupW3c1EUhYCAAGg0Gt6+r9lsFkQNBcMwqK2thcViuc4Sp6ewazh8TvMUFBT0uGaHoihERETg5MmTvMV14MABzJ49u8fHoSgKycnJKCkp4eU6Ky0t5dV/TpDiUl1dDbVajTvvvNPVoQC41utlF9Fdjdlshkaj6TZnPSoqCl5eXqiurnZyZNd49913MWnSpC4f4oBr1g0YhkFRURHuu+++Lv+/YsUKFBcXQ6/X83ZOtiPCp5i6uniQpmnU1tbCaDQiISGB9+nq+Ph4nD59mrfjnT9/HpMmTerxcRYsWMCbuLBrtz2ZqutMREQELBYLdDpdj45D0zQ6Ojp4tYkRnLgIba0FuJb+KZRK+NzcXERGRnbbNuzo5cyZM6Bp2qmxMQyD3NxcPP/8813GlZmZiS+//NKpMQH/Nz3SnUmmr68vhg4dik2bNvEmBmyRpFqt7vGxhLDWYrFYUFNTA5PJhISEBIcI3cSJE1FRUcHLsRiGgcFg4GUnxri4OK4uqad0dHRYVQtlLRRFIS4uDsXFxT06DlugzadzhDCe3p04c+YMzGazYNZa2AtKCPPdDMOgoqLitnVCffr0QVBQEM6dO+ekyK7R1tYGiqK6zRx6/vnncfToUafGBFwr0rudR9zSpUtRWVmJ0tJS3s7r7+8Pi8XCq2A5G/Yhza7jDRw40GEjqPDwcG6xu6ewHSs+2oxNy+cjE3PPnj0YPnx4j4/Tmfj4eOj1ers7kwzDoLW1lfcKfkGJi0ajwaZNm/Dss88KYgoK+L+FPEfFY8uNpFKpQFHUbQs2KYrC9OnTnT5H/+67795yn/GYmBiuktuZHDx48LZpnz4+Pli6dCkOHDjA23nZdYSepiXzuZhsC2y2VWVlJQICAhAfH+/QqTn2uuHj+5aWlvKyaM4yefJk7Nmzp0fHYNerZs2axUtMLGyGor2jvvr6eof43QlGXCwWC9avX4+xY8ciKSnJ1eFwqFQqh3oF5eXlWS0wOTk5XS5Kd4Wfn1+Pe0i2CB/DMLh8+TL++Mc/dvseiqLg7++P8+fP9yguW2AYpsvMuq7IyMjA448/zuv5+UhLZjf8ciY0TaO5uRn19fXo27cv+vXr55Rp6sDAQBQVFfX4OKdPn+Z1h9tJkyaho6Ojx78jAId0+lJTU9Hc3GxzfGzmX1paGu8daEGIi8ViwZdffgmRSISHH35YMKMW1oPKkTs6Xr16FR0dHVbFolAokJmZafWxe9qOO3bssPpiVSqVXA/qVqxcuRIff/xxj+KyBfaGtubByIofn7A9/Z6M1sxms9NS3hmGgU6nQ2VlJTQaDQYOHOjU/YzGjx+P3NzcHh2DXTRPTU3lKaprCRo9zWbbt28fEhISHNKWYrEYFEXZvMan0Wgcct0DAhAXi8WCDRs2oLm5GevWrXN5Rkxn2AerI2+sYcOG4fjx47d9X0tLCy/2JLbw1VdfQavVWvXejz/+GKNGjbptW82dOxdtbW1OW6Q+evSoSx10KYqCr69vjxf2nTFqoGka7e3tqK6uRkBAABISEuDn5+fUzl5ycjIvmU8A/202dOhQu6fGWB/AhQsX8hoTC0VRGDBgAEpKSmz6XElJCeLj4x3yG7tUXGiaxldffYWmpia8/PLLgrOqZh2VHXlzDR482Kppk5MnTzp91860tDT897//ve37GIbByZMn8cILL9z2vT4+PqAoymnV+qdOncKiRYuccq7ukEgkdi9UO0uETSYTampqIJPJ0L9/f/Tt29cl2ZrsOdkMP3soKytziCjOmTMHlZWVdv0mGo0GABy61UNMTAy3d5A10DQNg8Fgk1uyLbhMXBiGwaZNm1BfX48XX3zRoVNP9qLT6RyegiwSieDt7X1L6wt23cDZa1EvvvgiDh06dNv3abVam+wspk2bhnfffben4d0WdlozPj7e4ee6FWy2EfuAsQU+s566Q6/Xo6KiAt7e3khISEBAQIDLpqbZhBWpVGr3MU6dOsXregsLK1gymczmz+7atcsh6xqdYUfJ9fX1Vr2/uroa/v7+DovJJeLCMAwOHTqEK1eu4OWXXxaksLA3tTOmoUaNGoWzZ892+/+Kigr4+vo6vSfJZnfdrrjw008/7dIxoDv+9Kc/OWUNQS6X81pT0BMCAwO5jcJsQa/XO3TXSjbNOCwsDLGxsYLYIXPSpEl2Fy0yDHPLIuOeQFEUxo0bhx9//NHmmCoqKnpsVGkNqampqKmpue3ohWEYNDQ08LoudSMuueuKi4uxZ88erFu3zuk7AlqLSqXipnAcTUJCAvR6fbcXxIULFzBhwgSHx3EjFEUhKSkJGzdu7PY9DMPg6NGjePnll60+rr+/P/7+97/zEOGt2bNnj1VZYs6gc1GlLdMqRqPRYdPFNE2jsrISERERvJhP8kVKSordGXZs2rejOoXTp09Hc3OzTdN2V65cgUQicUrGX0BAABiGua1Xnlqtdrg3otPFpbm5GZ999hlWrVrlsLm+nsIWjjlrq2N2H4X29vab/sfuWhgdHe2UWG7kL3/5C/bu3dvtjd7W1gYANm0wRVGUU0aExcXFWLBggcPPYy3+/v7cSJBhGO7VHez/HNFWDMOgpqYGfn5+ghIWAJz7uD0uyTk5OQ59rnh7eyMqKgqHDx+26v0MwyA7OxsPPPCAU9qYoij07dv3lgv7DMOgpKQEAwcOdGhMThUXhUKBd999FzNnznT64rS1sIVjrLOtsxg6dChOnTp1098vXLiAiIgIl938MTExYBgGzc3NXf7/zTffxJw5c5wanzU9WtaRWCi2PQA49wKDwQC1Wg2dTgedTgeDwXDL7+SIttVoNNBqtQ7LFOopU6dOxYEDB2yutSotLcWMGTMcGBmwfPlynD171qpiz+LiYohEIl72R7GWxMREqNXqbqdgTSYTjEajwzusThEX9uH09ttvY9iwYbj33nud/jCyNluH3SzHmbn9wLXMrBunTBiGQXl5uV3bO/MFRVFYsGBBl9NYJpMJpaWleOqpp5wa06FDh257Yx84cADR0dGCe3B6eXndtF+8Xq/vcrpMp9M5dNQSFxcniPWorkhLSwNN07hw4QJkMhmqq6tRXFx8y0JG1nr+drVWPSU4OBhxcXHYvXv3LZ8pFosFO3fudNqohUUkEsHf3x9VVVU3/Y9hGBQXF6NPnz4Oj8nhV5bJZMKZM2fwzjvvYPjw4Vi+fLnTb3i9Xg+ZTAaFQtHtQ4mdp5TL5QgKCnJ6vY2Xlxe8vb2vy/Sora2Fj4+Py1O0V69ejcrKypsKyD755BOkpKQ4vXq8sLAQGzduRGtra5c3N5savWLFCqfGZS0ikQi+vr6QSCSQSCQICgriCv/Y78NOzfKd7MIu5Pr6+gp2vRO41qlZtGgRpFIpsrOzcerUKVy9ehW7du3ChQsXbvrd2emnkSNHOvz5QlEUli9fjuLiYpSXl3d7De7atQt9+/blxTzTVtLS0tDY2HjT6IXtyDgj89Qh4sJW+V64cAEffvgh9u3bhwcffBD333+/S3pKarUagYGB8PLygkwmu25XP3ZUo1aroVAoEBAQ4JINwABgwoQJOH36NBfT6dOnMXnyZJf3vn18fDB9+nS89tprXLs1Njbi0KFDeOutt5wez9NPP42wsDB88cUXOHToEGQy2XW/5/nz5+Hr64uIiAinx2YtnfehF4lECAwMhNFo5K5N9vvwfb9otVrI5XJe92JxFJGRkViyZAkWLFiAJUuWYP78+ZgzZw4KCgpw5MiR6zqK9fX1UCgUGDdunFNi8/Pzw3333YcffvgB1dXVN804nDx5EuXl5XjooYdc0s5isRjBwcG4evUqFxtN0ygoKEB8fLxTnsO85R1evHgRkZGR0Gg0uHr1Ki5fvgyapjFhwgRMmjQJgYGBLruYw8LC4OXlBbFYDJFIBLlcjsDAQHh7e8NkMnFbGIeGhjq8aPJWxMXFgWEYlJWVob29HQEBAS6tLu/M2rVrsXTpUnz//fcYOXIk/vnPf+LBBx9EaGio02ORSCRYvHgxKisrcezYMVy4cAEZGRnIyMiAWq3Grl278NRTTwn+4dkZVmDYjpBOp+MsPfhCo9GgurpaMCnH1iAWi68bGUdHR+P+++9HdnY29uzZg3HjxsFkMuHgwYOYMWOGUzuvqampmDVrFn744QeMHj0agwcPhtlsxsWLF1FZWYlHHnnEZR1ViqIwZMgQ5Obmora2FmFhYaiuroZYLEZcXJxTYuDtCvvll19gMBjg5eWFmJgYzJs3D6mpqdd51rhqX4rOU1z+/v7w8vLipiDY+cnOF4Ez47zxXNOmTcPp06chFou5hUlXtVvn83p7e2P9+vVYv349fv/9d0yfPh0PP/ywS2JjGAYURSExMREDBgxAdXU1zp49i59//hkikQiLFy9GfHy8y2KzF29vb/j7+3Ob0/n7+/P6Herq6tC3b1+EhIQIYo+YztgSj7+/PxYtWoRz587h999/B3BtL5iUlBTev9ftjjd69Gj069cPJ0+eRHFxMbe/yqpVqxzezrc7tpeXFzIyMlBeXo7W1lYEBQVx02HO+P15EZfAwEBkZmZy+3z7+vqCoihe98awV21FItFNOd+sURv7kKIoqkd7qNvbC/T19UVdXd1Nf09LS4OXlxcvFilhYWF2fS44OLjL7LWFCxdCr9cjJCSkx7sG2jPvGxAQgMLCwpv+npGRgUGDBsHLywu+vr5dvsdaYmJi7PqcSCTistTsha09oCiqy2PZuxbo7e2NiIgI+Pj4OGw3UHt76RKJxC67+OjoaISHh3M1RLc6hi2p8iz+/v5We3VlZmZCr9dzv19jYyMaGxtv+zl7Zya8vb2tMrwFrrWTxWKBj48P5HK51efo6XofxfAgYT3xAbIWeyutndVDs2f6wln7mtjTbs74TQHbH5bkWrPvWhNybEK9D4QaFyDs35P7LB/iYgsajQYVFRVITk522Xxkd+h0OlgsFoenMtoDu0+2RCIRlHM0TdMoLy9HdHS04NpNLpejuroa6enpgmoz4Frlvdls5nVDKz5gGAZtbW3w9fUVVI0Qi8VigVar5aa3hYJGo0FZWRlSU1Odvknf7Whra3OoQWV3OD11q6WlBVu2bMErr7yCixcvOvv0t0Wj0fR450BHoFAosGfPHi6XXyh8+eWXeOGFF+wy83MUNE3j0KFD+Ne//oXTp0/32MLdEbCp7yqVymmjRGtgp4jr6+t7PMXnCDo6OvDdd99ZPSXkDCwWCzZv3owTJ04Iqm7IbDajuLgYJSUlt7SXchROb4mEhAS8/vrrSE1NxRdffIHvv/++R+sdfCKRSODr6wulUun0rXjdkYsXL2L37t1YtWoV+vfv7+pwAAAymQyff/45jh49ipkzZ+KJJ54Q3IgKwHV1JkqlUlAdmn79+sHLy8tqd93ezu+//47m5mYsWrTouuJYV6JQKHDx4kUoFAoMGTIESUlJTh8huyQf0d/fH08++SROnjyJbdu2QSqV4oknnnBaitytCA4ORnt7O5RKpUvSbN0FtVqN9evXY8SIEYLx77p8+TJ27NgBiUSCp59+2qmWG/bg5eWFoKAg6HQ6aLVamEwml9rdd44rNjYWVVVVaG9vF3S9kKupq6tDTk4O7rzzTrsTQfiEdV+ora1FSEgIBg8e7PQiZxaXJbtTFIXJkycjKSkJX331Ff75z39iyZIlmDZtmktvLpFIhODgYMjlcm6Ng3Az//nPf6DT6bBu3TqXPwyNRiN2796N3NxcDBs2DIsXL3ab343NXPTx8YFGo4FSqURAQIDL61ACAgIQERGB5uZmBAYGCm4dQQgYjUbs3LkTsbGxLrVoYtHr9bh69SrUajUGDhyI2NhY1z5LXXbm/yU6Ohqvvvoq7rzzTvzwww/4z3/+47BUSWthrTmENh8uFI4fP45jx47hmWeeQVRUlEtjqa+vx0cffYQrV67ggQcewLJly9xGWDrj4+OD4OBgiEQiqFQqQawT9e3bF2KxGHV1dYKrixEChw8fhkqlwqJFi1y+1tLa2opLly7BZDIhMzMTcXFxLu/0uVxcgGs31gMPPIBnn30WVVVVeOONN1BUVOTSmIKCgiASiQS3gO5q2tvb8dFHH2Hq1Km46667XBYHwzA4fvw4/vOf/0AsFuO5557D6NGjXX5D9QSRSISgoCBIJBLo9XqoVCqXrv2xBYEGgwEtLS0ui0OIlJWV4fz585g1a5ZLpw0tFgtKS0tx9epVhIeHY8SIEYLxjBOEuLBkZGTgb3/7G+Li4vDhhx/i559/tsrW2hFQFIWQkBCYTCa7tqf1RBiGwfvvvw+xWIxnn33WZQ9ylUqFr7/+GtnZ2Zg0aZIgRlB84ufnh6CgINA0DaVS6dKEFz8/P/Tp0wdtbW3QarUui0NIaLVa7NmzB4MGDcLo0aNdFodarcalS5fQ3t6OlJQUDB48WFDp2YIzGAoODsZzzz2Hw4cPY9euXbh69Soef/xx9OnTx+mx+Pj4ICAgAGq1Gr6+vi6fB3c1+/btQ25uLv7f//t/LquBKCkp4baZXb16NVJSUlwSh6Px9vZGcHAwtFotNBoNTCaTQ/c7vxURERFQqVSor69HUlKSy6eAXAnDMNi3bx/MZjMWLFjgsg5WXV0dqqurERAQgPT0dMHVDAICG7mwUBSFWbNm4ZVXXoFOp8Nbb72FU6dOuWTel11cVSgUvXreua6uDv/9738xb948l/TWzGYzsrKy8M033yAuLg4vvPCCxwoLC0VRCAgIQEBAAEwmE5RKpUtG8hRFITY2FmazGU1NTU4/v5DIz89HYWEh5s2b55LpJ6PRiIKCAlRVVSE2NhbDhg0TpLAAAhy5dGbAgAH461//iu3bt+Pbb79FYWEhVqxY4dQFW3Z6rKOjA2q1WjDzmc7EYrHgnXfeQWRkJB5//HGnn7+lpQVbt25Fc3Mz7r33XkyaNMmt11ZsRSwWw9vbGxqNBiqVChKJxOkPFLFYjH79+qGhoQFBQUG98j5QKBTYv38/MjIyMHToUKefv6OjA1KpFBRFIT09XfClEoIcuXTG19cXK1euxOOPP478/Hy8+eabdpnc9QRvb28EBARAq9UKpuDTmWzfvh2lpaV46aWXnPpQYxgG586dw0cffQSTyYRnn31WEPvbuAJ2sd/Pzw86nc4li/1hYWEICgpCQ0ODy9ZCXQXDMNizZw/EYjHmzJnj1HPTNI2KigoUFRUhKCgII0aMELywAG4gLixjxozB3/72N4SEhOCdd97Bvn37nHpzBQQEQCwWQ6lU9qrpMalUii1btmDp0qUYMmSI086r0+mwefNm/Pzzzxg5ciSee+45QRSpuRp250p2sd/ZFi0xMTFgGMYqx19P4ty5c6ioqMDChQudOnOi1Wpx+fJlNDU1ISkpCWlpaYJxAbgdgp4Wu5GIiAi8/PLLyMrKwt69e1FcXIxVq1bZbStvK2z1vkqlEqSpH98YDAa8/fbbSEhIwPLly5123qqqKmzduhUGgwEPPfQQMjIynHZud4Bd7NdoNFyyibMMML29vRETE4Pa2lrI5XK36EH3lNbWVhw+fBjjxo1z6pbFTU1NqKiogJ+fH4YNG8b7lteOxq3EBbg2PbBgwQKkpaVhw4YNeOONN7By5UqMGDHC4edm7TqUSiV8fX09vmp548aNaG5uxqeffuqUTDmapnHkyBH8+uuvGDhwIJYuXdorHl72QFEUAgMDYTAYoNPpYDabERAQ4JRU1ODgYISGhqKxsREBAQFu05O2B4vFgl27diE0NJTbvM/RmM1mSKVStLe3o1+/fkhMTHTLDD33i/h/SU5O5gwwP//8c2zevNkp6yG9xdzy0qVL2LVrFx577DHEx8c7/HwymQxffPEFfv31V8ycORNPPvkkERYr6GyAqVKpnGaA2VvMLY8fP46mpiYsXrzYKSKqUChw6dIlznBy0KBBbiksgBuOXDoTEBCAJ598Ejk5Ofjhhx8glUrx+OOPO9wA09PNLdVqNd577z2MGDECCxcudPj5rly5gp9//hl+fn54+umnMXDgQIef05NwhQFmbzC3ZE0p77jjDoev991oOJmSkuL2MyPuKYmdoCgKU6dOxWuvvQYvLy/885//xNGjRx266M6aW7JTEp7Gp59+6hRTSqPRiJ9//hmbN2/G4MGDsXbtWiIsdsIaYAYGBsJsNjulJqazuaWQtgzgA6PRiF27diE6OtrhppR6vR5XrlxBXV0dBgwYgPT0dLcXFsADxIWFNcCcOnUqtm/fjk8//dShBpieam55/PhxHD16FH/6058caqnCGk5eunQJ999/v9saTgoNZxtgeqq55eHDh6FUKrF48WKHTkvdaDjZv39/j0m19xhxAa7dWA8++CCeffZZVFRU4M0330RxcbHDzudp5pYdHR34+OOPMWXKFEybNs0h52AYBjk5OZzh5PPPP48xY8Z4zA0lBJxpgNnZ3LK1tdUh53A2rCnlzJkzHTbdZ7FYIJVKOcPJ4cOHe1xhqkeJCwtrgBkTE4MPP/wQO3bscMgUAUVRCA4O9ghzS9aU0tvbG2vWrHHIw16tVuObb75BVlYWJk2a5PDRUW/HWQaYfn5+iIqKQmtrq9ubW+p0OuzZswdJSUkYM2aMQ86hVquRl5eHtrY2znDSE30LPe8b/S8hISF4/vnncejQIezatQslJSUOMcAUi8UICAiARqNxa3PL/fv34/z58/jHP/7hkBqe0tJSbN++HQCwatUqDB48mPdzEG7GWQaYkZGRUKvVbm9u6WhTyvr6elRVVSEgIADDhw/36Klg97wCrISiKMyePRuvvvoqZ4B5+vRp3ueG2foCdzW3rK+vx5dffom5c+fy3lszm83Izs7Ghg0bEBsbixdeeIEIi5NxhgGmJ5hb5ufno6CgAHPnzuW9g8UaTlZWVnKGk54sLIAHj1w6M2DAALz22mvYtm0bNm7cyBlg8uWT1dncUqPRIDAwkJfjOgPWlDIiIgJPPPEEr8dubW3F1q1b0dTUhPnz5/daXzCh4GgDTHc2t1Qqldi3bx8yMjKQnp7O67FlMhlKS0vdxnCSLzx65NIZPz8/PProo1i9ejWuXLnCuwEma26p0Wjcytzyhx9+wNWrV/Hyyy/z9qBhGAbnz5/Hhx9+CKPRiGeeeQZTpkwhwiIAHG2AGRYWhsDAQDQ0NLhNFiXDMNi9ezfvppSs4WRhYaFbGU7yRa8RF5axY8fi9ddfR3BwMN555x3s37+ft5vL3cwtpVIpNm/ejAcffJA3U0qdToetW7fip59+wogRI/Dcc88hNjaWl2MT+MORBpixsbFgGAYNDQ28HdORsKaUCxYs4G2qijWcbGxsRGJiolsZTvJFr5gWu5HIyEi89NJLyMrKwp49ezgDTD56Fe5ibmkwGPDOO+8gISEBK1as4OWYVVVV2LZtG3Q6HZYvX45hw4bxclyCY3CUAaY7mVu2tbXh8OHDGDt2LJKSkng5ZmfDyeHDh7ud4SRf9LqRC4uXlxcWLlyIF154Ac3NzXjjjTeQl5fHy3FZKw4hVy1v3LgRjY2N+POf/9zjDDeapvHrr7/i888/R0hICNauXUuExU1gDTD9/f1hMBh4KwrubG7p7G0BrMVisWDnzp0IDQ3FzJkze3w8s9mMkpISlJWVoU+fPr1aWIBeLC4sgwcPxt/+9jckJyfjs88+w5YtW3p8Mwjd3DIvLw+7du3CqlWremxKKZfL8eWXX+Lw4cOYMWMGnnrqKadtgUDgD19fX26kzZcBptDNLXNyctDU1IRFixb1eMpKqVTi0qVLkMvlbm84yRe9clrsRgICAvD000/j+PHj+PHHHzkDzJ6sFQjV3JI1pRw+fHiPTSnz8/Px888/w9fXF0899RQSEhL4CZLgEvg2wBSyuWV9fT2OHz+OqVOn9ug+90TDSb7o3dLaCYqicMcdd+Avf/kLKIrC//t//w/Hjh2ze2FeqOaWn332GTQaTY9MKY1GI3bs2IHvv/8egwYNwtq1a4mweAh8G2AK0dzSZDJh586dPTal1Ov1yM/P9zjDSb4g4nIDMTEx+J//+R9MmTIF27Ztw2effQa1Wm3XsYRmbpmTk4MjR47gmWeesdupoKGhAR9//DEuXryI++67DytWrPD4YrDeCJ8GmH369BGUuSVrSrlo0SK7N1dra2tDXl4eDAYDMjIyPMpwki+IuHSBj48Pli5dij/96U8oKyvDG2+8gZKSEruOxZpbKpVKnqO0jY6ODnz00UeYPHmyXaaUrOHkJ598Am9vbzz33HMYO3YsuaE8GL4MMEUikWDMLcvLy3Hu3DnMnDkTkZGRNn+eNZwsKSlBaGgoRowYIeisUFdCxOUWDBs2DH/7298QHR2NDz74ADt37rR5BMKaWxqNRpeZW/bUlFKtVmPjxo3IysrCxIkTezTyIbgffBhgCsHcUqfTYffu3XabUnY2nExOTkZqaqrbegk6A9IytyE0NBRr167FwYMHsXv3bs4A0xY3X7FYDH9/f5eZW7KmlG+99RZCQkJs+ixrOMkwDB577DGkpqY6KEqCkOHDADMyMhIqlcpl5pb79u2DyWSyy5SyNxlO8gUZuVgBRVG4++678ec//xkajQZvvvkmzpw5Y9MxAgMDXWJu2dDQwJlSjh071urPWSwWznAyJiYGL7zwAhGWXk5XBpi2jOTZvV/MZjOam5sdGOnNFBQUoKCgAPPmzbNpGquz4WRMTEyvMJzkCzJysYGEhAT89a9/xbZt2/DNN9+gsLAQy5cvt8qTizW3bG9vd5q5JWtKGR4ejscff9zqz3U2nJw3bx7xBSNcB2uAqVaroVQqbTLAFIvF6Nu3LxobGxEUFOSU+0CpVCI7Oxvp6ek2mVKyhpMAepXhJF8QcbER1gBz6NCh2Lx5MyoqKrB69WqrUnG9vb0RGBgItVoNsVgMsVjs0Fh//PFHlJSU4IMPPrCqt8UwDC5cuIDdu3cjJCQEzzzzDPEFI3QJm2qv0+mg0+lgNpvh7+9v1VRXeHg4Nz02aNAguzO2rIFhGOzZswc+Pj6YO3euVZ+haRpVVVVoaGhAWFgYUlJSep0vGB+QaTE7GTt2LP76178iMDAQb7/9Nn755RerMmkCAgLg4+PjcHPLsrIyfP/991abUup0Omzbtg0//vgjMjMzieEkwSokEgkCAwNhsVhsMsB0lrnl+fPnUV5ejoULF1rVwdLpdNcZTg4dOpQIi52QkUsPiIqKwssvv4y9e/di9+7dKCoqssoAk50ec5S5pdFoxNtvv221KWV1dTW2bt1KDCcJdsHWxNhigOkMc0tbTSlZw0lfX99e7wvGB2Tk0kO8vLywaNEirF27ljPAvHz58m0/40hzS9aU8uWXX75lZlpnw8ng4GBiOEmwG3sMMIODgxESEoKmpibezS0tFgt27dqF4ODg25pSEsNJx0DEhSdSU1M5A8xPP/0UW7duveUN4yhzy8uXL2Pnzp149NFHMWDAgG7fJ5fL8d///heHDx/GtGnT8PTTTxPDSUKPsdUAMzo6GiKRiHdzy5ycHDQ2NmLx4sW3nNbqbDiZmprq8DWg3gSZFuMR1gDz999/x08//QSpVIrVq1d3u3bBt7mlRqPBu+++i2HDhmHx4sXdvq+goAA//fQTxGIxnnzySSQmJvb43AQCiy0GmI4wt7TGlJJhGNTW1qKmpgbBwcEYPHgw8QXjGTJy4RmKonDnnXfif/7nfwAA//znP/Hbb791uXjPt7kla0r54osvdnkjm0wm7NixA5s2bUJSUhLWrl1LhIXgEGwxwOTT3NJkMmHXrl3o169ft6aUBoMB+fn5qKmpQXx8PDIyMoiwOAAiLg4iNjYW//M//4PJkydj69at+Pzzz7u0f+HL3PLEiRP49ddf8ac//alLa5bGxkZ89NFHuHjxIpYsWYKHHnoI/v7+dp+PQLAGaw0w+TK3PHz4MORyORYvXtzl9FZbWxsuXboEg8GAzMxMxMfHkxouB0HExYF0NsCUSqV44403cPXq1Zve11NzS9aUctKkSZg+ffp1/2MYBidOnMAnn3wCLy8vPPfccxg3bhy5oQhOwxoDTJFIhNjY2B6ZW97KlJIYTjofIi5OgDXA7Nu3L95//33s2rXrulFKZ3NLW039GIbBBx98wAlHZ9HQaDT49ttvsXfvXowfPx7PPvssMZwkuIzbGWBKJBLO3NLWaWKdToc9e/YgMTHxJpsj1nCytbWVGE46EdLCToI1wDx06BBngLl69WrOAJM1t2Sr9629+H/55RecO3fuJlNKqVSK7du3g6ZpPProo1YVUhIIjuZ2BpisuWVdXZ1N5pb79++H0WjEwoULr+tgdTacHDFiBPEFcyJk5OJERCIRZ4CpVqvx1ltv4ezZs9z/bTW3bGxsxJdffol77rmH661ZLBbs27cPX331Ffr164e1a9cSYSEIilsZYNpjbllQUID8/HzMnTuXm+oymUwoLCzkDCczMzOJsDgZIi4ugDXAHD58OL7++mt888030Ov1nLml2Wy+bvGfYRi0t7ejtbUV7e3tYBgGNE3jnXfeQVhYGJ588kkA1xYrP/30U5w4cQJz587F6tWrybwyQbCIxWIEBQWBoigolUro9Xru73379kVHR8d1u8Cy9wH7YhgGSqUS+/btu86UUiaT4eLFi1Cr1Rg6dCgSEhKcbu9PAChGCPuO9mLOnDmDLVu2IDg4GI8//jgGDhzI2WiIRCJs3boVn3zyCcrLy7nPJCUlYdKkSaivr8fHH3+MIUOG4OLFi1xF8rJlyxAXF+fCb0Ug2IZOp4Ner4ePjw9ngFldXQ29Xo/IyEhs3rz5pvsgMTEREyZMQGpqKtatWwdfX19UV1ejvr6eGE4KACIuAqC1tRUbNmxAdXU1Fi5ciNmzZ2PHjh1YuXIltFotKIrqcppMLBbj559/hkqlQl5eHkaPHo2FCxc63G2ZQHAEJpMJWq0WDMNwRZfffvst1qxZw41quroPJBIJtm/fjvj4eGg0GgwcOJCYrgoAIi4CwWKxYM+ePTh48CAYhsGGDRsAdH0zdYaiKCxduhQvvfQShg8f7oRICQTHwTAMt9B//PhxLF68GAzD3PI+oCgKFEXho48+wiOPPOKUPWIIt4eIi8A4d+4cJk+ebLWRH0VRkEgkqK+vJ5sZETyG5uZmJCYmQqfTWZXcQu4D4UFWuQTG6dOnbXKIZRgGOp0OmzZtcmBUBIJz2b59OzdFZg3kPhAeZOQiIBiGQXJyMioqKmyywKAoComJiZBKpaTynuD2kPvAMyDiIiDa2tq4okp7P8+HqyyB4ErIfeAZkGkxAdE5p98eVCoVT5EQCK6D3AeeAREXAdHTLJegoCCeIiEQXAe5DzwDIi4CIiIiAklJSTbPF1MUhaSkJISHhzsoMgLBeZD7wDMg4iIgKIrCs88+a9dn16xZQxYxCR4BuQ88A7KgLzDkcjni4uKg0+lu2vOiK0QiESQSCerq6kh+P8FjIPeB+0NGLgIjNDQUO3bsAEVRtzXbE4lEoCgKO3fuJDcUwaMg94H7Q8RFgMyePRv79u2DRCLhrC06w/5NIpFg//79mDVrlosiJRAcB7kP3BsiLgJl9uzZqKurw4cffojExMTr/peYmIgPP/wQ9fX15IYieDTkPnBfyJqLG8AwDDo6OqBSqRAUFITw8HCyaEnodZD7wL0g4kIgEAgE3iHTYgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOAdIi4EAoFA4B0iLgQCgUDgHSIuBAKBQOCd/w/+mxHOIc9MKAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.00);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "d92f84a5", - "metadata": {}, - "source": [ - "$\\lambda=10^{-2}$" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f1a96caf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.01e-01 | test loss: 5.65e-01 | reg: 1.78e+01 : 100%|██| 20/20 [00:13<00:00, 1.51it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.1, lamb_entropy=10.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "ae826b35", - "metadata": {}, - "source": [ - "$\\lambda=1$" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0da2ead7", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.09e+00 | test loss: 1.02e+00 | reg: 5.18e+00 : 100%|██| 20/20 [00:11<00:00, 1.67it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "650e7432", - "metadata": {}, - "source": [ - "### Parameter 2: (relative) penalty strength of entropy $\\lambda_{\\rm ent}$. The absolute magnitude is $\\lambda\\lambda_{\\rm ent}$. Previously we set $\\lambda=0.1$ and $\\lambda_{\\rm ent}=10.0$. Below we fix $\\lambda=0.1$ and vary $\\lambda_{\\rm ent}$." - ] - }, - { - "cell_type": "markdown", - "id": "c0d92d91", - "metadata": {}, - "source": [ - "$\\lambda_{\\rm ent}=0.0$" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d57d3cee", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.90e-02 | test loss: 8.40e-02 | reg: 1.68e+00 : 100%|██| 20/20 [00:12<00:00, 1.65it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.1, lamb_entropy=0.0);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "25d3f9f1", - "metadata": {}, - "source": [ - "$\\lambda_{\\rm ent}=10.$" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "94450fdf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.03e-01 | test loss: 5.67e-01 | reg: 1.77e+01 : 100%|██| 20/20 [00:10<00:00, 1.89it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.1, lamb_entropy=10.0);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "1cb475c3", - "metadata": {}, - "source": [ - "$\\lambda_{\\rm ent}=100.$" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "5370c135", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.60e+00 | test loss: 1.54e+00 | reg: 2.69e+02 : 100%|██| 20/20 [00:11<00:00, 1.67it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.1, lamb_entropy=100.0);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "409bfc64", - "metadata": {}, - "source": [ - "### Parameter 3: Grid size $G$. Previously we set $G=5$, we vary $G$ below." - ] - }, - { - "cell_type": "markdown", - "id": "6c841825", - "metadata": {}, - "source": [ - "$G=1$" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c78702b1", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.41e-01 | test loss: 1.33e-01 | reg: 1.01e+01 : 100%|██| 20/20 [00:06<00:00, 2.95it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=1, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=2.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "5e678b38", - "metadata": {}, - "source": [ - "$G=3$" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9b649166", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.18e-02 | test loss: 5.66e-02 | reg: 5.93e+00 : 100%|██| 20/20 [00:11<00:00, 1.76it/s]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKVklEQVR4nO3deXRU9d0/8PedmSyTzGSWTAISREjYF1lUWnDXKvq4gQgITMQFztNWa/W4to+1PW0f255WIe3T1hbqI2QUraKgyOKCiNXiCvjITkJWlmQye2af+/394e+Ok5CQWe7MvXfyeZ3j6TklM/PNzb33Pfe7fL4cY4yBEEIIEZFK6gYQQgjJPxQuhBBCREfhQgghRHQULoQQQkRH4UIIIUR0FC6EEEJER+FCCCFEdBQuhBBCREfhQgghRHQULoQQQkRH4UIIIUR0FC6EEEJER+FCCCFEdBQuhBBCREfhQgghRHQaqRtAiBIwxtDV1QWfzwedTofy8nJwHCd1swiRLXpyIeQsXC4X6urqMGbMGFRUVGDUqFGoqKjAmDFjUFdXB5fLJXUTCZEljnaiJKRv27dvx/z58+H3+wF88/QiEJ5aSkpKsGHDBsyZM0eSNhIiVxQuhPRh+/btuOGGG8AYA8/z/f6cSqUCx3F46623KGAISUDhQkgvLpcLw4cPRyAQOGuwCFQqFbRaLdra2mA0GrPfQEIUgMZcCOll7dq18Pv9SQULAPA8D7/fj3Xr1mW5ZYQoBz25EJKAMYYxY8agsbERqVwaHMehuroaR48epVlkhIDChZAe7HY7KioqMnp9eXm5iC0iRJmoW4yQBD6fL6PXe71ekVpCiLJRuBCSoKCgIKPX6/V6kVpCiLJRuJBBLxqNoqOjAwcOHEBrayuqqqrSeh+VSoWf/exn2L17d0rjNYTkIxpzIYMSz/Nwu93o7OyEy+UCYwwGgwEWiwX19fV46KGHUg6Iq666CocOHcKJEycwevRoWK1WLF26FKNHj87Sb0GIfFG4kEHF6/XCbrfD4XAgGo2itLQUFosF5eXl8S6xTNa56PV67Ny5E/X19diwYQN8Ph9mzZoFq9WKRYsW0WA/GTQoXEjeCwaDsNvtsNvtCIVCKCwshMVigcVigVar7fM1qa7Q37JlC6699toe/+b3+7Fp0ybYbDZs374dKpUK119/PWpra3HjjTeiuLhY1N+TEDmhcCF5KRKJoKurC3a7Hd3d3VCr1TCbzbBYLCgrK0vqPZKtLfbaa6+dESy9nT59Gi+//DLq6+vx+eefw2AwYMGCBbBarbj00kuhUtHwJ8kvFC4kb/A8D6fTCbvdDrfbDQAwGo2wWCwwGo1p3cBdLhfWrVuHP/7xj2hoaIj//zU1Nbj//vuxbNkyGAyGlN7z0KFDsNlssNlsaG5uxogRI7B06VLU1tZiwoQJKbeREDmicCGKxhjrMY4Si8Wg0+ni4ygajThbFgn7ubjdbhgMBlH2c+F5Hh999BFsNhv++c9/wuVyYcaMGaitrcXtt9+OoUOHitJ2QqRA4UIUye/3w263o6urC+FwGMXFxSgvL4fFYsnaWIYw/iKMs4gpGAxiy5YtsNls2Lx5M2KxGK699lpYrVbMnTsXpaWlon4eIdlG4UIUIxwOx8dR/H4/NBpNPFB0Ol3WPz+b4ZLI4XDglVdeQX19PT766COUlpbi1ltvRW1tLa666iqo1eqsfTYhYqFwIbIWi8V6jKOoVKoe4yi5LBKZq3BJ1NjYiBdeeAH19fU4evQozjnnHCxZsgRWqxVTp06lIplEtihciOwwxuB2u2G32+F0OsHzPMrKylBeXo7y8nLJvrlLES6Jn/3ZZ5/BZrNh/fr1sNvtmDx5cnyh5vDhw3PaHkIGQuFCZKO7uzs+jhKJRKDVauMD80VFRVI3T9JwSRSJRPD222+jvr4emzZtQigUwhVXXIHa2lrMnz8/6anWhGQThQuRVCgUigdKIBBAQUFBfBxFboPYcgmXRB6PBxs2bIDNZsP777+PoqIi3HzzzaitrcWcOXMyLsRJSLooXEjORaNROBwO2O12eL1eqFQqmM1mlJeXw2AwyObG3ZscwyVRa2sr1q9fj/r6enz99dewWCy4/fbbYbVaMXPmTFm2meQvCheSE4wxuFyu+DhKYqFIk8mkiBlQcg8XAWMMX331Ferr6/Hiiy/i5MmTGDNmDKxWK6xWK6qrq6VuIhkEKFxIVvUuFFlSUhIfRyksLJS6eSlRSrgkisVi2LFjB2w2GzZs2IDu7m5cfPHFsFqtWLhwIcxms9RNJHmKwoWILp1CkUqgxHBJ1N3djU2bNqG+vh5vv/021Go1brjhBtTW1uKGG26QxaQJkj8oXIgoIpFIfBzF5/OlVShS7pQeLolOnTqFl156CTabDV988QWMRiMWLlwIq9WKiy++mAppkoxRuJC09VUoMnEcJd9uUPkULokOHjwYL6TZ0tKCkSNHYunSpbBarRg/frzUzSMKReFCUubxePosFGk2m/N66mu+houA53n861//Qn19PV555RW43W5ceOGFsFqtWLx4MSorK6VuIlEQCheSlEAgEB9HCYfDKCoqio+jDJZNr/I9XBIFg0G89dZbqK+vx5YtW8DzPK699lrU1tbilltuQUlJidRNJDJH4UL6FYlE4oEiFIoUxlH0er3Uzcu5wRQuibq6uvDPf/4T9fX1+Pe//w2dTof58+fDarXiyiuvVMQ0cpJ7FC6kh96FIjmOg8lkgsVigcFgyLtxlFQM1nBJ1NDQEC+keezYMQwbNgxLlixBbW0tzj//fKmbR2SEwoWAMdZjHIXneej1+vg4ilgbbikdhcu3GGP49NNPUV9fj5deegldXV2YMmUKamtrsWTJElRVVUndRCIxCpdBrHehyOLi4vg4Cq15OBOFS9/C4TC2b98Om82GTZs2IRwO46qrroLVasX8+fMHZRcqoXAZdEKhUHzDLbkXipQbCpeBud1ubNiwAfX19di5cye0Wi1uueUW1NbW4pprrsnr2YSkJwqXQSAWi8UXOHo8HqhUqh7jKHSjTA6FS2paWlrw4osvor6+HgcOHEBFRQUWL14Mq9WKCy+8kI5hnqNwyVOJhSJdLhd4nldcoUi5oXBJD2MMe/fuhc1mw4svvohTp05h3Lhx8Y3ORo0aJXUTSRZQuOQZn88XH0dReqFIuaFwyVw0GsWOHTtQX1+P1157DX6/H5dccglqa2uxYMECmEwmqZtIRELhkgeCwWB8HCUYDKKwsDA+jkKL3cRD4SIun8+HjRs3wmaz4Z133oFGo8GNN94Iq9WK//iP/6BJJQpH4aJQ0Wg0Hii9C0Xq9Xq6+WUBhUv2nDx5Ei+99BLq6+uxZ88emEwmLFy4ELW1tZg9ezYdbwWicFEQnud7jKMA+V0oUm4oXHJj//79sNlseOGFF9Da2opRo0bFNzobO3as1M0jSaJwUYDehSJLS0vj4yg0tTN3KFxyi+d57Nq1CzabDa+88go8Hg9mzpwJq9WKRYsWUSFNmaNwkan+CkWWl5cresMtJaNwkU4gEMDmzZtRX1+PrVu3gjGG6667DlarFbfccgtdEzJE4SIjkUgkPo7S3d0NtVodH5inVc7So3CRB7vdjpdffhk2mw27d++GXq/H/PnzUVtbi8svv5ym2csEhYvEeJ6PL3AUCkUajUZYLBYYjUYaR5ERChf5OXr0KF544QXYbDY0NDSgqqoqvtHZlClTpG7eoEbhIgEqFKlMFC7yxRjD7t27UV9fj5dffhkOhwNTp06F1WrFkiVLMGzYMKmbOOhQuOSQ3++Pj6NQoUjloXBRhnA4jK1bt8Jms+HNN99EOBzG1VdfjdraWsybN4+6mHOEwiXLwuFwPFASC0WWl5dDp9NJ3TySAgoX5XG5XHj11VdRX1+PXbt2oaSkBHPnzoXVasU111xDvQRZROGSBVQoMj9RuChbc3NzfKOzQ4cOobKyEosXL0ZtbS1mzJhBf1ORUbiIhDEGt9sNu90Op9MJnudRVlYWH0ehGSzKR+GSHxhj+PLLL2Gz2bB+/XqcPn0a48ePR21tLZYuXYrzzjtP6ibmBQqXDPUuFKnValFRUUGFIvMQhUv+iUajePfdd2Gz2fD666/D7/fjsssug9VqxYIFC2A0GqVuomJRuKQhFArFx1GCwSAKCgriA/NUKDJ/UbjkN6/Xi40bN6K+vh7vvfceNBoNbrrpJtTW1uL666+nL4sponBJUjQajY+jeL1eqFSqeKHIsrIyutkMAhQug8eJEyewfv162Gw27N27F2azGYsWLYLVasWsWbPo758ECpezoEKRJBGFy+D09ddfxwtptrW1obq6Ol5Ic8yYMVI3T7YoXPrg9Xrj4yhUKJIIKFwGt1gshl27dqG+vh6vvvoqvF4vvvOd76C2thaLFi2CxWKRuomyQuHy/wmFIru6uhAKhVBYWBgfR6GieASgcCHfCgQCeOONN2Cz2bBt2zYAwPXXXw+r1YqbbrqJ7hkY5OFChSJJKihcSF86Ozvx8ssvo76+Hp9++inKyspw2223oba2Fpdddtmg7T4fdOHC8zycTme8UCQAKhRJkkLhQgZy5MgR2Gw22Gw2HD9+HOeee268kOakSZOkbl5ODYpwSSwU6XQ6EYvFoNfr42VYqAQESQaFC0kWYwwff/wxbDYbXn75ZTidTkybNg21tbVYvHgxzjnnHKmbmHV5HS5Cociuri6Ew+F4ocjy8nIUFxdL3TyiMBQuJB2hUAhbt25FfX09Nm/ejGg0iu9973uora3F3Llz87bGYN6FSzgcjo+j+P1+aDSa+DhKvv4RSW5QuJBMOZ1OvPLKK7DZbPjwww9RUlKCefPmoba2FldffXVe9aLkRbj0VyiyvLwcRqORbgREFBQuREzHjx/Hiy++iPr6ehw+fBhDhw7F4sWLYbVaMX36dMWfY4oOF57n0djYSIUiSU5QuJBsYIzhiy++QH19PdavX4/Ozk5MnDgR//3f/425c+dK3by0yTJcUmlSW1sbiouLYTQaU36kpBsESfX0F8IlVXSukWTONeFnGGPgOC6t80Yu55osw6WtrS2jApDJ3AAikQiGDBmS9meQ/MDzfEoXo3DRp0ouFzyRzi9+8QtMnTo1a+8fCATg8Xjw/e9/P2ufkQpZjh4FAgFUVVWl9drOzk6cOnUKhYWFGD16dL/dY0ePHqVwISlLNSSE724ULuTQoUP42c9+lpX3Pnz4MJYsWYLRo0fLJlxku2JQeCRM5T+fz4fjx49jxIgRUKlUOHToUL/vRYggnXMtmf8IScRxHNRqtej/qVQqXHfddVi6dKnUv2IPsg2XVDHGcOjQIdTU1MBoNGLMmDHw+/3wer1SN40MUul2oRGSira2NrS3t+Ohhx6Suik95E24OBwOcByH8vJyAN98S6ipqcGRI0dSHrQlhBCluOaaa/DYY4/JrnSVvFqTJsYYGhoaMHbs2B7fFM1mM2KxGCKRiIStI4MRfaEhudDR0YEjR47gV7/6ldRNOUNehEs4HAZj7IxKxhzHwWKx4OjRoxK1jAx21C1GsmnOnDn44Q9/KMt1fbKcLZYqYXVrXxfyqFGj8Nlnn1H/N8kpenIh2dbZ2Yl9+/bhs88+k7opfVL8kwtjDIFAAOeee26f/y70QwYCgVw2ixD6MkOyas6cOfj+978v23pk8mxVCpxOZ3w6Xn+GDRuGo0ePZnUBE8lfvZ9CBgoNemoh2dbW1oZ9+/bh008/lbop/VL8k0tjYyOqq6vP+jNVVVUIBoN00ZOUMcb6/C8Z9ORCsoExhiuvvBI/+clPZPvUAig8XBhjiMViMJlMZ/054amGZo2RVCWusBfCYqCAoS8xJJt2796N5uZm/PKXv5S6KWel6HA5efIkCgsLk/qGaDKZ0NjYmINWkXzRO1iSWXlP5V5INvE8j+uuuw5r166V3bqW3uTdurNgjKGtrQ1jx45N6udHjRoFt9ud5VaRfCcETCrdY4SI5ec//znMZjNuv/12qZsyIPl22A2A53kwxpKuniz0TaZbMp0MPgOVPe/9lCIEDtUWI9nQ0NCAp556Cs3NzYo4vxR7l21sbERZWVnSB5njOBQWFqKjoyPLLSNK09cTyNmeSnqHBz3FkGwLBoOYPXs2fvOb32D48OFSNycpigwXxhgcDgdGjx6d0uuqq6vR2tqapVYRpTpbOPT35aWv7jF6aiHZEI1GMWfOHEyfPh2PPPKI1M1JmiK7xTweDziOS3kaXllZWbw7jZCzSaaiQ1/dYYSIKRQKYeHChfD5fHjnnXcUdY4p7smFMYajR49i9OjRKR9o4edptT45m1S+fNA+LiQbGGNoaWnBVVddBYfDgV27dqGwsFDqZqVEtuHS3wXe3d2d1NqW/gwdOhQNDQ2ZNI3kob7Ot1TG8yhUiBgYY/D7/VizZg2+853vYMqUKXj33XdRWloqddNSJttusc7OTlRUVJwxcHro0CFUV1enfTEPHz4cx44dE6uZJA8IYycC6uIiucYYQ0dHB9544w389a9/RSwWw+rVq3HDDTco9lyUbbg0NzdDrVbHN/9ijKG1tRVqtRoWiyXt91WpVBg7diyV4SdnoLE4kitCdZFTp07hk08+wRtvvIEPP/wQVVVVePDBB3Hrrbcq8mklkWzDZfz48Th48CBUKhV0Oh3sdjtOnz6NqVOnZpTkSv0WQLKnr0WRdJ6QbOjo6MDXX3+NDz/8EB9++CEaGxtRUVGBOXPm4Ec/+hHOP/98xY2t9Ee24aLT6VBTUxNfMKRSqTBx4sS8OfBEXhK7xihYSLZcfPHF0Gq1uOCCC2C1WvHd734XI0eORFFRUd6dd7IMF5VKBZfLBZVKhaqqKkSjURQWFiIcDiMcDovyGUVFRaK8D1G+vkKFusiI2AoLC3H33XejuroapaWl4DgODQ0Nok4wGjlypGjvlSmOyfAq4nk+J59DZWBIrk7/fPtWSlKXiyUQarVaNr07sgyXVPA8j1AohKKiIgoLknU0k4zkQj6M/yn+bhwIBPDVV1/RwkiSdYwxqvBAcmLPnj1QqVTYs2eP1E1Jm+LDhRBCiPxQuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0VG4EEIIER2FCyGEENFRuBBCCBEdhQshhBDRUbgQQggRHYULIYQQ0WmkbkAmGGOw2+04ceIEhg4dipKSEnAcJ3WzZI0xhq6uLvh8Puh0OpSXl9MxS4Jwrnk8HpSVlcFisdBxGwCda+lhjMHpdAIAnE4nGGPKPG5MgZxOJ1u1ahWrqalhAOL/1dTUsFWrVjGn0yl1E2WHjll66Liljo5ZevLtuCkuXLZt28ZKS0sZx3GM47gefwTh/ystLWXbtm2TuqmyQccsPXTcUkfHLD35eNwUFS7btm1jarWaqVSqHge/938qlYqp1WpF/SGyhY5Zeui4pY6OWXry9bhxjDGWcd9aDrhcLgwfPhyBQAA8zw/48yqVClqtFm1tbTAajdlvoAzRMUsPHbfU0TFLTz4fN8XMFlu7di38fn9SfwAA4Hkefr8f69aty3LL5IuOWXrouKWOjll68vm4KeLJhTGGMWPGoLGxEak0l+M4VFdX4+jRo8qcbZEBOmbpoeOWOjpm6cn346aIcLHb7aioqMjo9eXl5SK2SP7omKWHjlvq6JilJ9+PmyK6xXw+X0av93q9IrVEOeiYpYeOW+romKUn34+bIsJFp9Nl9Hq9Xi9SS5SDjll66Liljo5Z6iKRCAKBQEbvIffjpohwKS8vR01NTcr9ixzHoaamBmazOUstky86ZukpLy9HdXV1Wq8djMeNMQaTyZTWMRts51ooFMLp06dx8OBB7N27Fz6fD+eee27K76OU46aIcOE4Dj/60Y/Seu39998v60GvbKFjlh6e53Hvvfem9drLLrtM5NbIF2MMsVgMsVgMjDHcd999ab1Pvp9rwWAQJ0+exP79+/HVV1+htbUVGo0Go0aNwvTp0/HQQw+l9fsr4bgpYkAfyO/54NnicrlQVVWFQCCQ1GyUwXzMeJ5HLBYD8E1f9ogRI5I+1ziOg0qlQiwWwxVXXIG6ujqcf/752W6yJHiejx8T4ffmOC7l65PjOGi1WrS3t+fdueb3++F0OuF0OhEIBKBSqWA0GmEymWAwGKBWq+M/m8/3NUU8uQCA0WjEhg0bwHHcgIktnPCvvfaa7P8A2WQwGPDqq6/GbwJnM1iPGc/ziEajiMViUKlUKCgogNlsjp9ryRw3lUqFLVu2YMuWLTh58iSmT5+OH/zgB7Db7Tn6LbJLeEqJRqPgeR4qlQpqtRpqtTp+LSZenwMdM+Eafv7552U/bpAsn8+H1tZWfPXVV9i/fz86OjpQWlqKMWPGYPr06fFurMRgAVI7boq7RnNYDUAU27ZtY1qtts/yCIk1eLZv3y51UyXF8zyLxWKM5/mk6xYNpmPG8zyLRCIsHA6zSCTCeJ4/42fSOW7hcJitXLmSGQwGZjQa2apVq1g4HM7lryaaWCzGotEoi0QiLBqNslgsNuBrkj1mW7ZsYZ2dnayzs5NFo9Ec/Dbi4nmeud1u1tTUxPbs2cM+/fRTtmfPHtbU1MTcbnef59PZnO24CcdOadeo4sKFMcZeeeUVNn/+fFZdXX1G9dC6ujrmcrmkbqKkEoNF4HQ6WV1dXZ8VVwfbMYtGo/FQGeiGme5x6+joYP/5n//JOI5j48ePV0w9KOHciUQi8VBJ9UaZ7DGLRqOKCphYLMacTidrbGxkX375Jfv000/Z3r17WXNzM/N6vSkfp976O27nnXceW7lypeKuUcWMuQh4no/3aV911VVwOBzwer3Q6/Uwm82yH+TKNvbNF4Z+uw8ZY4P2mCWOq6jV6gG7IRKle9z27t2LBx54AB988AFuvPFGPP300xg7dmzav0O2MMbA83x8bE7o7sv0PQc6ZjzPw+l0gud5mEwmaDTy2mIqFovB7XbD6XTC5XKB53lotVqYTCaYTCaUlJSI/pmJx620tBSRSAQGgwGlpaWif1Y2KS5cGhsbsX79etxzzz0YOnSo1M2RlYGCZbBi/3/MgDEWHy/I9edv2LABDz/8ME6cOIEf//jHeOKJJ2AwGHLajr7aJYQK0HOAPpfkFjDRaBQulwtOpxNutxuMMZSUlMQDRavV5rQ9DocDPM/DYrHk9HMzpbhwefPNN9HW1oYf/OAHUjdFVihYziTcOHmeB8dxPQagpRAIBPD000/jN7/5DXQ6HZ566inceeedkoRd76cUqc8bnufhcrkQjUZhMplQUFCQ08+PRCLxGV5erxeMMeh0OpjNZhiNRhQVFeW0PYkCgQCcTieGDBmS83MlE4oKl1gshpUrV2LmzJmDak3BQChYzhSLxeKhIkYXj5ja2trw+OOP44UXXsCMGTNQV1eHSy65JOuf23sacTIzlHKJ/f/tfaPRKIxGIwoLC7P6eaFQKB4oPp8PHMdBr9fHn1ByHXD9YYzh1KlT0Ov1GVdDyCX5nFlJOHbsGEKhECZOnCh1U2SDgqUnnucRiUTiU2Y1Go2sbqAAMHz4cNhsNnz00UdQqVS49NJLsXjxYrS0tIj+WUKXYF/TiOV2XDiOi9/UXS4XwuGw6J8RCARw4sSJ+KLGtra2+KLGadOmYdy4caisrJRNsADfHJfi4uKMy8XkmqKeXF577TU4HA4sX75c6qbIAgXLt3qPq0gxdpAOnuexbt06PP744/B4PHjsscfwyCOPZDxQLHR7JZ4fcguT/jDG4Ha7EQ6HYTAYMu6S6u7ujj+hBIPBHosajUajIo5LMBiEw+FAZWWl5GNSyVJMuITDYaxcuRKXXnopZs+eLXVzJNe7e2Owktu4Sro8Hg+eeuoprFy5EkOGDMHvf/97LFy4MKXfRS4D9GIQAiYUCqU85sEYg8/niwdKOByGRqOJB0pZWZkiAiWR0DWm0+kUs/BUMeGyf/9+bNy4Effdd5/ks2ykJtw8lHaBiC2TqcVydezYMTz88MPYtGkTLrnkEtTV1WHGjBlnfU02phHLhdvtRjAYhMFgQHFxcb8/xxiDx+OJTxmORCIoKCiIj5/o9XpFhmwioauwsrJS6qYkRTFn4P79+1FVVUXBQsHSZ8mWfDkeo0ePxsaNG/H222/D4XDgwgsvxIoVK9DR0XHGzyYeB+CbgJXjGFMmDAYDtFot3G73GWMOwhTmxsZG7NmzB0eOHIHH40F5eTkmTJiAadOm4bzzzkNZWZnigwUAtFototEoIpGI1E1JiiKeXAKBAFatWoXvfe97uOiii6RujmQGe7AkjqsouQssWdFoFM8++yyefPJJxGIxPPnkk7jvvvug0WhkNY04FzweDwKBAEpKShCJROBwOOB2u3OyqFEuGGM4ffo0SkpKUFZWJnVzBqSIu9Thw4fBGMOECROkbopkBnuwCDOeAECj0UCj0eT9DVWj0eC+++7D0aNHYbVa8eijj2LKlCl46623wHFc/Ckl349DNBpFOBxGe3s7Pv74Y+zfvx/hcBjDhg3DlClTMHnyZFRVVeV1sADfVpJWyqwxRTy5vPDCCwCApUuXStwSaQzmYMnHcZVk9R5L+frrr/HQQw9hx44duO666/DMM8/k7ReucDgcXyXv8XgAfLPzYmFhYbxytdLKoYghHA7DbrfDYrFkfR1QpmR/pfp8PjQ3N2PSpElSN0USgzVYGGN5O64yECFQhVAV1utMmzYN7777Ll5//XUcOXIE559/Ph588EE4nU6JWyyOUCiEU6dO4eDBg9i3bx9aWlrAcRxGjhyJadOmYfz48aiurobZbIbP58t4D3olKiwshFqtVsTTi+yfXD777DO8++67eOCBB3Je00dqgzFY8mVqcapSnUYcDAaxatUq/PrXv4ZWq8Wvf/1rLF++XFHlQYBvS5s4nU74/X6oVCoYDIb4xlr9renw+/3wer0oKSlRzNRcsXg8Hvj9ftnXVpR9uDz//PMoKSnBwoULpW5KTg3GYJFzyZZsybTO14kTJ/DTn/4Ua9euxfnnn4+6ujpcccUVWWxx5novalSr1T12akz27x4IBODxeKDVahUxwC2WSCSCzs5OlJeXS1rzbCCyvnrdbjfa29sHXZfYYAuWxJIt+Tidti9nm0acypPasGHD8Pzzz+OTTz5BSUkJrrzySixYsABNTU1ZannqGGPwer1oaWnBvn37cODAAXR2dkKv12Ps2LGYPn06qqurYTKZUvq7C6ESCATgdruz+BvIS0FBATQajey7xmRdR+DAgQPQaDQYM2aM1E3JmcEULEot2ZKubFYjnjlzJj766COsX78ejz76KMaPH49HHnkEjz/+uCQD34mLGoVilIWFhTAajTCbzdDpdKL83lqtFhzHxcNlsKyD02q16O7ujk/LlyNZd4utWbMGZrMZt956q9RNybrBVCdssI2r5LrOl8/nw29/+1v84Q9/gMViwe9+9zssWbIk68eY5/keG2vFYjEUFRXBbDbDZDJlNeRCoRBcLheKiopgMBjy+nwCvpme3dHRAbPZfNbKBVKSbbh0dXXh2WefxW233YZx48ZJ3ZysGkzBMlimFsuhztfx48fxyCOPYMOGDZg1axbq6upEX4Qci8V6bKwl5aJGYfpyQUEBjEZj3l9LnZ2d0Gg0MJlMUjelT7K9svfv34+ioiLU1NRI3ZSsGizBks8lWxIJXX3C5ARhGrEUT2ejRo3Cq6++ih07dqC7uxszZ87EXXfdhZMnT2b0vsKA8pEjR7Bnzx40NjbKYlGj0O0WiUTgcrkg0+/NotFqtQgGg7L9PWX75PLXv/4Vw4cPx0033SR1U7JmMATLYBhXkcNTykCi0SjWrFmDJ554AqFQCP/1X/+FBx54IOkulXA43GOnRgA9NtaS04I+YVdJ4Vu9nP4OYorFYjh9+rQkWy8nQ5bhcurUKfzjH//A4sWLUV1dLXVzsmIwBEvi1OJ8HFeR43bBA3E6nfjlL3+J//mf/8GIESPw9NNP45ZbbumzzcFgMB4o3d3d4DgOZWVl8X1Q5LShVm/C04swzTkfn5IBwG63Q6VSwWw2S92UM8gyXN577z189dVX+PGPf5yXJ0W+B0u+j6vIfbvgZBw8eBAPPvggtm/fjquvvhqrVq3C5MmT4ff744ESCAR6LGo0Go2KWqQZjUbhdDqhUqlSnuasFN3d3fB4PBgyZIjsfj95tQbf3HgPHDiACRMmyO5giSGfgyWfS7YoabvgZEyYMAFbt27F5s2b0dTUhGnTpmHx4sX4+OOP45V3R48ejenTp2P06NEoLy9XVLAAiHeLCaX5hS8E+aS4uBiMMQSDQambcgbZXRXt7e3weDx5uXAyX4NFCJXEqsVKuxH1p786X3IbU0mFsAalpaUFw4cPx7p163D//fdj8+bNWLhwIT7++GOMGDEiL77tazQamM1mMMbgcDjif8d8oVarUVRUJMsFlbI7c/bv34+ysjIMHz5c6qaIKl+DJbEUvrDKXOm/nzCWIjylAFD0Uwrw7bbBTU1N2Lt3Lw4fPgyXywWTyYQpU6bg6aefxrFjx3Drrbfi/vvvjxfJzAdqtTo+XdfpdOZdwGi1WoRCIdk9mcnqSuF5HgcPHsSECRMUf4NKlI/Bko8lW+Q0jVgMQndQQ0NDfKdGr9eLiooKTJw4EVOnTsWIESPiWwAPGTIEa9asweeffw6TyYRrrrkGc+fORUNDg9S/SsbUajXMZjM4joPD4Yh/IcoHwow/uT29yOpu0NzcjO7u7rzqEsu3YOk9rpIPoZJP2wVHo1F0dXXh2LFj2LNnD44dO4ZgMIihQ4di8uTJmDJlCoYPH37W1fIzZszArl278NJLL+HLL7/ExIkT8fjjj8enICtV4sC+UJImH6hUKhQXF8suXGQ1W2zz5s1oaWnBD3/4Q6mbIop8CpZ8K9mixGnE/RGm3QobazHGoNPp4mtQMqmc6/f78fvf/x6/+93vYDAY8Jvf/AZ33HGHIoNXwPN8vDyN3KdUJ0vYumDIkCGyGe+UTbjEYjGsXLkSF110ES6//HKpm5OxfAoWoZsIUP7U4lzX+cqWvhY1Jq5BEXtRY0tLCx577DG89NJLuPDCC/HHP/4Rs2bNEvUzcokxFn96MZlMig8YxhhOnToFvV4PnU4ndXMAyKhbrKGhAaFQKC+6xPIlWBIHtZU8tbj3NGJAmQP0wWAQJ0+exIEDB7Bv3z60trZCrVZj1KhRmD59OsaNG4fKysqsrJYfMWIE1q9fj127diEWi2H27Nmora1Fe3u76J+VCxzHxUPF6XQiHA5L3aSMcBwnu64x2Ty5vP7667Db7VixYoXUTclIPgRLvpRsyYenlP4WNZrNZhgMBkm6QGKxGJ5//nn89Kc/hc/nw09+8hM89NBDsixBMhDGGFwuFyKRCAwGg6w33xpIMBiEw+FAZWVlvzt45pIswiUSiWDlypW45JJLMHv2bKmbk7Z8CBall2xRQp2vgfh8vnighEKheAkTs9mMsrIy2QSk2+3Gr3/9a9TV1WHYsGH4wx/+gPnz5yvqWAPfTtMOhUIwGo2KDRiha0yn08li62dZhMv+/fuxceNG3HvvvTAajVI3Jy1K3+RL6SVblDxAL+zUKARKJBKJl403mUwoKyuT9e9x5MgRPPTQQ9i8eTMuv/xy1NXVYerUqVI3K2VutxvBYBAGg0G2e6QMxOVyIRwOo7KyUuqmyGMnygMHDqCqqoqCRQLCDDChC0wuM02S1bvOl1Ketniej+/U6HK54js1ChtribVTYy6MHTsWb775JrZt24YHH3wQM2bMwIoVK/CrX/0KFRUVUjcvacImY263G4wxRXbzabVa+P3++BcUKUn+5BIMBrFy5UpcffXVmDlzppRNSYtSgyVxXEVJN2VAuU8psVisx06NPM+juLg4PmVYiu2IxRaJRPCXv/wFP//5zwEAv/jFL3DvvfdKfqNLhcfjQSAQQFlZmeIChjEWrw1XVlYmaVskD5d9+/Zh8+bN+PGPfyybKXTJUmqwKHVcRYkD9NFotMdOjYwxlJSUxANFaTevZHV2duLJJ5/E3//+d4wdOxYrV67EddddJ3Wzkub1euH3+6HX63O+6VmmhO69IUOGSNoOycPlxRdfBM/zsFqtUjYjZUoMFiWOqyhxgF7YrEpYgyLmokal2bdvHx544AHs3LkTN9xwA5555hmMHTtW6mYlxefzobu7GzqdTlFPleFwGHa7HRaLRdJN3CS9u3R3d6OpqUlxa1uUFixKLIWvtDpfoVAIp06dwsGDB7F37160tLQA+GZ9yLRp0zBhwgQMHTp0UAULAEydOhU7duzAq6++iq+//hqTJ0/Gww8/DLfbLXXTBqTT6aDT6eDz+eDz+aRuTtIKCwuhVqslX/Mi6ZPL559/jnfeeQcPPPCAYroHlBQsSivZorSnFKHkhtPphN/vB8dxPTbWksNaAzkJBAJ45pln8NRTT6G0tBRPPfUU7rrrLtlPIvH7/fB6vSgpKZHFFN9keDwe+P1+DB06VLI2SBoua9euRXFxMRYtWiRVE1KipGBJHFcRFkLKlZIG6P1+PxwOB5xOJ4LBIFQqVXzKsFSLGpWmvb0djz/+OGw2G6ZPn466ujpceumlUjfrrISA0Wq1kg+UJyMSiaCzsxPl5eWSPS1LdsfxeDxoa2tTTJeYUoIlsRS+3KsWn60asZyCxefzoaWlBfv27cP+/fvR2dkJnU6HMWPGYPr06aipqYHZbKZgSVJVVRXq6+vx8ccfQ6PR4LLLLsPtt98e70qUI2H2VSAQgMfjkbo5AyooKIBGo5G0a0yy5/b9+/dDo9EoYnBPCcGilJItSnhK6W9RozAgL+x/QjIza9Ys7N69G/X19Xj88ccxbtw4PPbYY3j00UdlOUNLq9X2WAdjMBikbtJZabVadHd3x2dX5ppk3WL/+Mc/YDKZcOutt0rx8UlRQjkXpYyryH0acV+LGouKiuKBorRp8krj9Xrx1FNP4ZlnnkFlZSV+//vfY9GiRbI8l0OhEFwuF4qKiuILL+UoGo2io6MDZrNZkooDkoRLV1cXnn32WcyfPx/jx4/P9ccnRQnBIvepxXIfoO9rUaNWq40Hihy/Pee7hoYGPPzww9i4cSMuvvhi1NXV4YILLpC6WWcIhUJwu90oLCyUdcB0dHTEn7pzTZK70YEDB1BYWIjRo0dL8fEDknuwJI5VyHFqsZynEUejUdjtdhw9ehR79uyJb/UwbNgwTJ48GZMnT0ZVVRUFi0Rqamrw+uuv45133oHL5cJFF12E5cuX4/Tp01I3rYeioiIYjUaEw2G4XC5IOC/qrEpKShAMBiVpnyRPLs8++yyGDRuGm2++OdcfPSA5B4ucS7bI+Smlv0WNZrNZ0VVw8100GsXf/vY3/OxnP0M0GsWTTz6J+++/X9KFgb0J4aLRaGAymWRxvicSusakqAaR83A5ffo01qxZg9tvvx01NTW5/OgByTlY5FyyRQg8QF4D9D6fD62trfD5fOA4Dnq9Ph4oSqp1Ndh1dXXhF7/4Bf7617+iuroaa9euldUumMKXF41GA6PRKKteBACw2+1QqVQwm805/VxRwuXDDz9MusSz2+1Gc3MzpkyZkvQNKBqNIhwOY/r06Sm3LZVfT/jZdG6M6bxG+JafjFgslvYgeDqvEYIsGem0LTGMUtHe3p50l1UwGERHRwfKysqg1+vjU4WFLxH9fXY0GlVUNV+l++Uvf4nKysqkamGlO/MpnY0IfT5f0l/kYrEYfD5fytsj8DyfVhes1+tN+gtSIBBAJBJJaX2OcI1k0j0sylRku92e0iZfqQzQnTx5Eu+++y70en3a4XK2P3ZioKT7bTvdE76vG1xi11Jit1K6q71TCbB0pbO+I93vNIFAAOecc05SP2swGPq8YTU1NcHv98NoNGLYsGFn/HtjYyOFSw4dOHAAf//737F79+6sFVtcsmRJyuESjUYRDAZRXl6e1M+neiNmjMHj8aR1Axe27E4mMFLt9mWMoaurCxqNRvpwAdK7wQyE53m8/PLLuPrqq9HQ0JD2+/R14xeSWfj3TLrDMnn4Ez4vcf2HEDg8z0vaBZatz80k8DKdwtzQ0IBgMIjhw4ejubkZPM/j3HPPlUU33mDFcRzmzZuH733vezh48KCs/hYcx8Hr9Yq+Kp/neTidzozum36/PysbyQlrYzIlr87BBIwxbN++HXq9Pqu72gl/GCFgpJhVkRgsQpgI/yWOZ+SDgbqksikSicDhcGDcuHEwGo0YP348Tp8+jVAolPO2kJ5WrVqF06dPw2azSd2UHoxGIwKBgOjXoN/vz/g9VSoV/H6/SC36ls/nE6WGmmzDpaurC3v37sXSpUuz8k1GjO4wsdrRX7DIbWBQ6Y4dO4by8vJ4F2NRURGGDRuGw4cP51WAK5FarcbmzZuxfPnynHTlJku4BiORiKjv293dnfENvKysDF6vV6QWfUP48ifGoktZ3r0YY3jhhRdw5ZVXZmUfhb4G7oUbeq6fXnoHS6LEp5d8kcmkiUw/1+fzYeTIkT3+/2HDhiEcDot+8yCpmz17Ns455xz89re/lbopccIsQzG3CBCugUynVBcXF0vW25IM2YULYww7d+6ERqPBd77znax+llz6ds82riJ8c5LrCZQqqbrEXC5Xn9WhOY5DRUUFjh49mvM2kZ44jsO2bdvw5JNPyurpRavV9qiHl6nEtWCZSByvFUt3d7do47yyCxeHw4Hdu3fDarVm7ebf3+yuxKeXXBlooaFcAlAMUgZkU1MTzjvvvD7/bcSIEaL0gZPMjRs3DpWVlfjzn/8sdVPihPtCOBwW5f08Ho9oC3c1Go2oG5kJ06nFIKtw4XkeNpsNl112WdYqjiZ7A8nVjSaZ8Mi3rjEpusSi0Wi/U0qF8jSdnZ05bRc5E8dxePPNN/Hwww/LKux1Op0opfYZYwiHw6LdwA0GA7q7u0V5L6GLTazgk024MMbw5ptvQqfTpbRmJl393eCy8aiZqXzpGktlYaaYuru7B5y4UVNTI+v9RAaTGTNmoKCgANu3b5e6KXFidY2J1SUmEBZSinFvEL7AitU2WYQLYwx79+7FkSNHsGTJkqzegJJZ8CjHgFE6qQbyAeD48eMDLrzU6/U9FrAS6XAch+effx633367bK5B4byNRqMZvY/QJSbWdSC8jxhddi6XS9T6Y5KHC2MMjY2N2L59O5YsWZLV4mpyOVFTJXzrzocbnxgXVaolfYLB4IDhwnEcioqKcPLkyUybR0Qwf/58+Hw+WU20KC0tzWjWmNhdYgIxZrMxxlIuETMQScOFMYZDhw5hw4YNuPnmm/ssxSEFqaYln41KpZJNW9IhZpdYR0dH0scilUf9mpoa2ZV2H6w4jsMTTzyBG2+8UeqmxJWWlma0qDkYDGZlXV2m7QLE764DJAyXcDiMDz74AFu2bMHNN9+MCRMm5KzLRMkzsOQQMELoJhu+YneJtba2Jj2I2draCp1Ol9Rnl5SUyHbzusHoiSeewLFjx+BwOKRuSg/p9CAIdcSMRqPo9x8xusacTmd8G2ex5DxcGGNoamqCzWZDY2MjrFYrxo0bl5MbfioFJhPHXeRwQ091HChb4wfC+wr/SXF8RowYgaNHjyb1uXa7/YyFk/3hOI42CZMRjUaDhQsXYv78+VI3BcA350dxcXFaXVChUAgcx2Vtq4eysjK4XK60XpuNLjFAxMKVA2GMwev14oMPPkBjYyMuuOACzJw5M2cb/6RzA0xmzUuu18QIOzuejbCpGCDuU5oQLImP9okB1t9n9X5NpioqKtDc3IxIJHLW80f420ixfzgRx3PPPQedTofu7u60q3WIeY3q9Xp0dnam9EWVMQa3252VpxZBSUkJPB5PWhXaheATe3FzTp5cGGM4cOAAnn/+eUQiEVitVlx88cWS7CiXyoE/29hLKt1CYknm6UUIFpVKJXql6t712IQTcqD2CK8RS7Kr6h0Oh+w2ViOpKSkpwXXXXYfFixen9fpwOIx//vOforWnry9VZyOUHVKr1Vm933EcB41Gk3KtMcYYXC4XjEaj6G3K+pMLz/PYuXMn9u3bh2uvvRYTJkxQZEHGvsIl15K5SSYOzIn91CKUbumrJpvwRNX7M7M1BXnEiBH44osvzvok19zc3O+qfKIcL7/8MgwGA7q6upLeWwX45ty7/fbb0dHRkfQeQAMRZhV6PB6YTKYBfz4Wi8Hv98NisWT9S47JZEJnZyf0en3SnxWNRkVdOJkoq3d5nufx1ltv4eDBg6itrcXEiRMlC5Z0N/RK/Jae+LSS+P/n0tlW6wttE/vbel/dYb3blPj5vduTjb+5SqVCaWkpmpub+21zLBbL+dauRHx6vR7Lli3D9ddfn9KYY11dHT744ANs3bpV1PaUlZUhHA4n1WXucDig0+myst9Vb2q1OqUy/EL7UgmjVGTtTs8Yw1tvvYXW1lYsW7YsJ8mdLYl7viTeYKUIl7Ot1s/2OpizVTVI7B7r/b/ZMnr0aNjt9j4/x+12D1i3jSjH3/72N+zbtw87d+5M6uc/+eQTPProo9ixY4coe5MkEs6ps1XSFrqbMt3NMdV2mUym+NjLQMLhMHiez0rleSBL4cIYw5YtW9DS0oJly5ZBp9Nl42NSak+mEoNFilAZiFRPLQIhYISA668bTUwFBQUoLCzsc+FjY2Nj0rPEiPwVFhaivr4eN99884DT0Nvb23HttdfiL3/5S1Y2GuS4b8vw93VvYYzF963P5iB+XwoKCqDRaAYMGOGpxWQyZa19oocLz/PYunUrjh8/jmXLlmUtFdMht0BIh3ATT+waSzYAMv3cZH9OmKac7ePNcRzGjh2L9vb2Hk9t0WiUusTy0IIFC3DppZfihhtu6LdruKurC5dccgmWLVuGe+65J2ttEWqN9dWOaDQKr9cLk8mU82EAjuNgNpvh9/v7fbISgqWwsDArYy0CUX/zcDiMTZs2obm5WRZPLAI5rFMRU1+zxrIxtiGEVrJPH4kzyITXZDtgiouLUVpaiuPHj8eflhoaGnL+jZFkH8dxeO2113Dq1CnceeedCAQC8X8T/u6XXHIJZs2ahbq6uqz+/TmOQ2lpKZxOZ49u4Gg0CqfTCb1eH9/xNNfUajUMBgMcDgcikcgZ9wmPx4NoNAqz2ZzVYyTa3ai1tRU2mw1erxd33HGH6P2cmcqnG41w0xZKPghTj8X+HdNdG5TLrkPh6cXlcuH06dNwOBzwer2orq7O+meT3CsuLsaHH36IgwcP4pprrsGmTZvwxRdfoK6uDpdeeimuvPJKrFu3LidPDKWlpeA4Dm63G5FIBIFAAA6HAyUlJaKvdk+VVqtFaWkpurq60N3djXA4jGAwCIfDgXA4nJMxcNGi9fXXX8f555+Piy++GBqNRpZPC/nUJmF8IxaL9ZjNJnbb5Fjuv3db1Go1xo0bh6amJjDGMHr0aMXXYhtsUvlbWSwWvP/++3j66afx85//PF6Y9E9/+hPmzZsn6rUw0PuYzWZ4PB643W5wHIeysrJ4V1O2z7+B3l+n06GgoADd3d3w+/3xadRCOaRst0+UcCkpKcHMmTNhMpnQ2NgoxlueYciQIWm/Nhd9/+nK5A+c+HTQ3/tk0jY5HjeNRtNvmYuhQ4fGu8bSLYUBgErA5JjFYsHGjRtTft3UqVNRU1MDv98Po9EIlUqFTZs29fuzqVKpVAiFQgP+XHFxcY8xxmReI0i36yzZtgHfnM/C/UGlUiVdgyzTbj2OiRBfuSoFn86jbq6+vaZzo6S2pd42ubaLpC/TPVKSwXFcymtN5Hyuyblt8deKES6p6O7uxrFjxzBu3DjZ1XzK1mpysaS7EDTbsjXmk6nu7m7Y7Xace+65iqwKQc6UeLuS0/kWjUbj+8/L7Vzz+/2IRqOiF6YcSM6Pgsvlwq5du/DnP/8Zhw4dyvXHD0guVZB7E2aiyK1tYmz9KjbGGNrb23HgwAEEAoF+p60S5dmzZw9UKhX27NkjdVPihBlYwvinXPA8D4fDAZfLJck1mvNwqaqqwooVKzBy5Ehs2LABW7ZsOetK11zK1sB4vkp1qnIuhEIhHDp0CCdPnkRVVRXGjRuXtTLnhADfPCELJevldB10dnYiHA7DbDbDYDDkvA2STMQuLi7G/PnzsXfvXmzfvh0tLS2YN29eRoP2YkmsISaXE0WuhG9qcukGcDgcaGpqglqtxvjx42Wzzorkr0gkgu7u7vjMLKkJW5v4fD4UFRXBaDTmpK5ZXyS9K0ybNg333HMPNBoN/vd//xeffvqplM2J66/MPvmW0NUk1YmbiOd5HD9+HA0NDTAYDJg8eTIFC8k6YZ+WgoICWVQiicVi6Orqio/9lJeXS3p9SrOENIHFYsGdd96J999/H++88w6OHz+OG2+8UdI/VuL0Xnp6OVNiHTOp+f1+NDQ0IBwOY9SoUbBYLFI3iQwSXq8XPM8nVXo/2wKBAFwuF1QqFSwWiyR7ZfUmi/4MjUaDa665BosWLcKJEyewZs0aHD9+XNI2pbop0GCSuHBTSqdOncKBAwegUqkwadIkChaSM+FwGIFAIGfl9PsjrOlyOp0oLi5GZWWlLIIFkEm4CEaPHo0VK1agoqICL774It577z1JZ/rIcXW61OTQHRaJRHDkyBG0trZiyJAhmDhxouymtZP8xfM83G43CgsLJV1wG4lE0NnZiUAgAJPJlNUKx+mQvFusN51Oh8WLF+OTTz7B+++/j+bmZsydO1eyCrfC+Iuc/mhSEaYdSxksbrc7/lQ7duxYSWbBkMFN2EpYynPP5/PB4/GgoKAAFRUVkhXJPBtZPbkIOI7Dd7/7Xdx5550IhUJYs2YNvvrqK8naAlD3mNTTjhljaGlpwZEjR1BSUoJJkyZRsJCcCwaDCAaD0Ov1ksySFAbtPR4PdDodLBaLLIMFkGm4CM455xzcc889mDhxIt588028/vrrKdXtEQt1jyFeO0mKCyoYDOLAgQPo6OjAiBEjMHbsWFlM+ySDSywWg8fjQXFxsSTdsMFgEJ2dnYhGoygvL5fVupq+yDpcgG92oLvxxhsxb948NDQ0YPXq1Whvb895Owbz4kqhO0yKYOns7MT+/fvB8zwmTpwoi7VQZHDyeDzxXShzSZjyLGzwVVFRkdVNvsQi+3ARTJw4EStWrIBOp8PatWvxr3/9K6c3+8HaPSZVd1g0GsWxY8fQ1NSE8vJyTJo0iaoVE8n4/X6Ew2EYDIacfsmKRqOw2+3w+/0wGAwwm82yWbQ8EHl21vXDYDDgjjvuwIcffohdu3bh+PHjuOWWW3JWkE3YQ2UwDfBL0R3m8/nQ0NCAWCyG0aNHy2IdARm8hKKUJSUlOZ3m293dDY/HA7VaDYvForiuYGVEYAKVSoXLL78cVqsVLpcLq1evxuHDh3P2+YNp9X6uu8OEgpMHDx5EUVERJk+eTMFCJCfc4HNV9UEoOOl2u1FSUoKKigrFBQugwHARjBgxAsuXL8fIkSPx6quvYuvWrTkpgDlYilvmujssHA7j0KFDOHHiRLzgpFwWg5HBy+fz5bQoZTgcPqPgpFJ7SRTVLdabVqvF/PnzsWfPHrz99tvxApiVlZVZ/dzBUNwyl0UpEwtOTpgwgeqCEVnIdVFKr9cLr9eLwsJCmEwmWZRXyoRin1wSTZ8+Hffccw9UKhWee+45fPbZZ1n/zHzuHsvVKnye59HU1EQFJ4ns5LIoZSwWg91uh9frhV6vh8ViUXywAAp/cklksVhw1113YceOHXj77bfjBTCzNcMoX4tb5qooJRWcJHLm8/lyUpRSjgUnxZIXTy4CjUaDa6+9FosWLUJ7eztWr16d1QKY+Tg9ORdFKU+fPk0FJ4lshcNh+P3+rBal7F1wsqKiIq+CBcizcBH0LoC5Y8eOrBXAzKfV+9nuDhMKTra0tFDBSSJLuShKmVhw0mg0wmQyKWbtSiryplust94FMJuamjBv3rysPObmQ3HLbBelpIKTRAmyXZTS5/PB6/VCo9HItuCkWPIvLhMkFsAMBoNYs2YN/u///i8rnwMot3ssm9OOGWNobW2lgpNE9rJZlDKx4GRpaamsC06KJa/DRXDOOedg+fLlGD9+PN544w1s3LhR9AKYSu4ey9YqfKHg5OnTp6ngJJG1bBalFApORiIRRRScFMugCBfgmwKYN910E+bOnYtjx45hzZo1ohfAVOLiymytwrfb7VRwkihGNopS9i44WVlZqYiCk2IZNOEimDRpEpYvX47S0lKsXbsWH330kWiBoLTusWx0h8ViMTQ0NOD48eNUcJIoQjaKUiq54KRY8rvTrx9GoxF33HEHdu3ahZ07d8YLYIrxrUVJxS3F7g5LLDhZU1Mj2e6hhCQrG0Up/X4/3G63YgtOimVwRWkClUqFK664AlarFQ6HA6tXr8aRI0dEeW8lrN4XszuMMYYTJ07g4MGDKCwsxOTJkylYiCKIWZRSKDjpcrmg1WoVW3BSLIM2XATnnXceVqxYgREjRuCVV17Btm3bEI1GM3pPuRe3FLM7LBwO4/Dhw2hvb8ewYcMwfvz4vFsMRvKTmEUpexecNBqNsu+5yLZB2S3Wm1arxW233YYvv/wS77zzDlpaWjB37tyMCmDKubilWEUpnU4njh8/DrVajfHjx+d8hz5C0iVmUcp8KzgplkH/5JJoxowZuPvuu8FxHJ577jl8/vnnGb2fHLvHxFiFLxScPHbsGMrKyjBp0iQKFqIYYhWlzNeCk2KhJ5deKioqcNddd+G9997D9u3b0djYmHYBTLkVtxSjKGViwcmRI0eioqJCxBYSkn1CUUqj0Zj2ewQCAbjdbnAcl3cFJ8VCTy590Gg0mDNnDhYuXIi2tjasXr0aTU1Nab2XnKYnZ1qUsnfBSQoWojSJRSnTWSGfWHCyqKgoLwtOioXC5SzGjBmDFStWwGKx4IUXXsD777+fVkjIYfV+Jt1hiQUnKysrqeAkUaRMi1IOloKTYqFusQHo9XosWbIEu3fvxs6dO9HU1IS5c+emXABTyuKWmRSlFApOMsao4CRRNK/XC8ZYWufwYCo4KRaK3SRwHIdZs2Zh2bJlCAQCaRXAlKp7LN1px70LTk6ePJmChSiWUJSyrKwspacNnucHXcFJsVC4pGDYsGFYvnw5xo0bhzfeeAObNm1KqQCmFN1j6azCTyw4ee6551LBSaJoPM+nVZQyFAqho6Nj0BWcFAtFcIoKCwtx8803o6amBlu2bEFbWxvmzp2LqqqqpF6fy+6xdLrD7HY7mpubUVhYiIkTJ1JdMKJ4wqyuZKfLM8bg8XjQ3d2N4uJiGI1GGltJAx2xNE2aNAkrVqxASUkJ1q1bh48//jipJ5JcdY+l2h2WWHDSbDZTwUmSF1ItSkkFJ8VDTy4ZMBqNWLZsGT744AO8//77aGxsTKoAZi6KW6bSHUYFJ0k+SrUoJRWcFBdFcoZUKhWuvPJKLF26NKUCmNlcvZ9sUUqh4OShQ4dQWFiISZMmUbCQvOHxeKBSqQYsSsnzPJxOJxWcFBmFi0hGjhyJFStW4Nxzz02qAGa2ilsm2x2WWHDynHPOwfjx4wfVRkYkv3V3dyMSicBgMAx4HXR2diIUCsFkMlHBSRFRt5iItFotFixYgC+++ALvvvsuWlpaMG/evH5XsmejuGUyRSmdTieampqgUqmo4CTJO5FIBD6fD6WlpWd9AqGCk9lFTy5ZcMEFF+Duu+8GADz33HP44osv+v1ZMbvHBlqFn1hwUq/XU8FJkneEmV4FBQX9dodRwcncoCeXLKmoqMDdd9+N9957D9u2bYsXwNRqtT1+TqzilgMVpfT7/WhsbEQoFKKCkyRv+Xw+xGKxfscOqeBk7tCTSxYJBTAXLFiA1tZWrF69Gs3NzWf8nBjTk89WlFIoOMlxHCZOnEjBQvLS2YpSUsHJ3KNwyYGxY8dixYoVMJvNsNlsfRbAzGT1fn/dYdFoFEePHo0XnJwwYcIZT06E5IOzFaWkgpPSoG6xHNHr9Vi6dCn+/e9/44MPPkBzczPmzp3bY0+JdFbv97cK3+PxoLGxEYwxjBkzJqO9KwiRO6EoZVlZWY//nwpOSofiO4c4jsPs2bOxbNkydHd3Y/Xq1fj66697/DuQfPdYX9OOhYKThw8fhlarxeTJkylYSF5LLEopfMmigpPSo3CRgFAAc+zYsdi0aRPeeOMNhMNhAH13jzHGYLfb0dTUBLvdHv+33qvwg8EgDh48GC84OW7cOFoMRvIGYwxOpxPAN9PphS9XXq+3R1FKKjgpDxyT0wbvg9DXX3+NrVu3orS0FHPnzsWwYcPiM788Hg/Wrl2LP/3pT2hoaIi/pqamBvfeey9qa2tRXl4OjuN6FJysrq7OaG9wQuTE5XL1ex3cc889WLBgAaqrq8FxHLxeL3w+H4qKimhsRWIULjLgdDqxceNGnDp1CldccQW++93vYtu2bbjtttsQCAQA9D3QX1JSgldeeQXjxo2Dw+GAxWLBeeedRxcUyRvbt2/H/Pnz4ff7AZz9OrjooosQjUah1+sHLPlCso/CRSZ4nscHH3yAjz/+GB6PB3/4wx8GXFwpTD2uq6vDkiVLqC4YySvbt2/HDTfcEO/+6o9wHbz44ou49dZbqStYJihcZOarr77CRRddhEgkknQJf61Wi/b2dhq4J3nD5XJh+PDhCAQCSU1woetAfqj/RGbef/99hMPhpNe7MMYQCASwbt26LLeMkNxZu3Yt/H5/SjMn6TqQF3pykRFhTYqwPiVZHMehuroaR48epVkxRPHoOsgPFC4yYrfbMyrNYrfbUV5eLmKLCMk9ug7yA3WLyYjP58vo9V6vV6SWECIdug7yA4WLjGQ6fZLK55N8QNdBfqBwkZHy8nLU1NSk3F/McRxqampoKjLJC3Qd5AcKFxnhOA4/+tGP0nrt/fffT4OYJC/QdZAfaEBfZlKd369SqaDVatHW1kbz+0neoOtA+ejJRWaMRiM2bNjQoyBlf4RqyK+99hpdUCSv0HWgfBQuMjRnzhy89dZb0Gq1fe4uKfx/Wq0WW7ZswbXXXitRSwnJHroOlI3CRabmzJmDtrY2rFq1CtXV1T3+rbq6GqtWrUJ7eztdUCSv0XWgXDTmogCMMTgcDni9Xuj1epjNZhq0JIMOXQfKQuFCCCFEdNQtRgghRHQULoQQQkRH4UIIIUR0FC6EEEJER+FCCCFEdBQuhBBCREfhQgghRHQULoQQQkRH4UIIIUR0FC6EEEJER+FCCCFEdBQuhBBCREfhQgghRHQULoQQQkT3/wD6VRnKd2uv8wAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=3, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=2.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "b17e4ed5", - "metadata": {}, - "source": [ - "$G=5$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "1209c59c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.47e-02 | test loss: 6.52e-02 | reg: 6.12e+00 : 100%|██| 20/20 [00:12<00:00, 1.58it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=2.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "0de00173", - "metadata": {}, - "source": [ - "$G=10$" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "9d67a57a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.08e-02 | test loss: 7.24e-02 | reg: 5.89e+00 : 100%|██| 20/20 [00:13<00:00, 1.44it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=10, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=2.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "7626a0bf", - "metadata": {}, - "source": [ - "$G=20$" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "0887f18d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.14e-02 | test loss: 5.50e-02 | reg: 7.70e+00 : 100%|██| 20/20 [00:16<00:00, 1.23it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=20, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=2.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "c14919f1", - "metadata": {}, - "source": [ - "### Parameter 4: seed. Previously we use seed = 0. Below we vary seed." - ] - }, - { - "cell_type": "markdown", - "id": "c8debdf5", - "metadata": {}, - "source": [ - "${\\rm seed} = 1$" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "8fe1c782", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.58e-02 | test loss: 5.50e-02 | reg: 8.48e+00 : 100%|██| 20/20 [00:13<00:00, 1.50it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, noise_scale_base=0.0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "fd5156bf", - "metadata": {}, - "source": [ - "${\\rm seed} = 42$" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e7d3ca9f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.43e-01 | test loss: 1.25e-01 | reg: 1.85e+01 : 100%|██| 20/20 [00:12<00:00, 1.65it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=42, noise_scale_base=0.0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "3bbddc95", - "metadata": {}, - "source": [ - "${\\rm seed} = 2024$" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "01dd251f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.50e-01 | test loss: 1.39e-01 | reg: 2.37e+01 : 100%|██| 20/20 [00:12<00:00, 1.57it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAr80lEQVR4nO3deVhU97kH8O8ZkB1FEBfABRBFsWqIRiUMxsTKk1hMGqPSm9zU1iy3jSH3SQzeuMSqiUSSNqHV6L1tU7XpDS6QkBu3qFEZVNS4VUFQQFBERJZhX2d+9w/LeUIWw3KYc2bm+3ke/5FZXn96/J4zv/O+IwkhBIiIiBSkU7sAIiKyPQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgU56h2AUTWQAiBiooK1NXVwcPDAz4+PpAkSe2yiDSLVy5E92A0GpGUlISQkBD4+voiMDAQvr6+CAkJQVJSEoxGo9olEmmSxG+iJPp++/fvx9y5c9HQ0ADg7tVLu/arFjc3N6SkpCA6OlqVGom0iuFC9D3279+P2bNnQwgBs9n8g4/T6XSQJAm7d+9mwBB9A8OF6FuMRiMCAgLQ2Nh4z2Bpp9Pp4OrqiuLiYnh5efV+gURWgHsuRN+ydetWNDQ0dCpYAMBsNqOhoQHbtm3r5cqIrAevXIi+QQiBkJAQFBQUoCuHhiRJCAoKwtWrV3kXGREYLkQdlJeXw9fXt0fP9/HxUbAiIuvEj8WIvqGurq5Hz6+trVWoEiLrxnAh+obGxsYePd/T01OhSoisGzv0ye7V19fjxIkTyMjIQE5ODjw8PLp8BdO+5+Lt7d1LVRJZF4YL2aXW1lacP38e6enpOHfuHEwmE8aPH4/Fixdj0qRJiI+P79KGPgDExcVxM5/oX7ihT3ZDCIHc3FxkZGTgxIkTqK+vx4gRIxAVFYWIiAi5R4V9LkQ9xysXsnklJSXIyMhARkYGysrK4OPjg5/+9KeIjIxEQEDAdx7v5eWFlJQUzJ49GzqdrlMd+qmpqQwWom/glQvZpJqaGhw/fhwGgwH5+flwdXXF1KlTodfrMWbMmE59fNXZ2WKpqamYNWtW7/xBiKwUw4VsRnNzM86cOQODwYALFy5AkiRMnDgRer0e4eHhcHJy6vJrGo1GbNu2DX/84x+Rn58v/35wcDDi4uLwy1/+Ev369VPyj0FkExguZNXMZjMuX76M9PR0nDp1Co2NjQgJCYFer8e0adMUuzVYCIHKykrU1tbC09MT3t7e3LwnugeGC1ml69evy/solZWVGDRoEPR6PSIjIzF48GC1yyOye9zQJ6tRVVWFY8eOwWAwoKioCB4eHoiIiEBkZCRCQkJ4JUGkIbxyIU1rbGzE6dOnYTAYcOnSJTg6OiI8PBxRUVGYMGECHB15fkSkRQwX0hyTyYSLFy/CYDDg9OnTaGlpwdixYxEZGYkpU6bA3d1d7RKJ6EcwXEgThBC4du0aDAYDjh07hpqaGvj7+8v7KAMGDFC7RCLqAn6mQKq6c+cOMjIyYDAYUFJSgn79+iEyMhJ6vR4jRozgPgqRleKVC1lcfX09MjMzYTAYkJOTA2dnZ0yePBl6vR7jxo2Dg4OD2iUSUQ8xXMgi2tracO7cOWRkZODMmTMwmUwYN24coqKiMHnyZLi4uKhdIhEpiOFCvUYIgatXr8JgMODEiROoq6vDiBEjEBkZiQcffBD9+/dXu0Qi6iUMF1JcaWkpDAYDDAYDysrK4O3tLe+jDB06VO3yiMgCGC6kiJqaGpw4cQIGgwF5eXlwdXXFlClToNfrMXbsWG7ME9kZhgt1W0tLS4dBkQAwYcIE6PV63H///d0aFElEtoHhQl0ihEB2djYyMjKQmZmJxsZGjBw5Uh4U2bdvX7VLJCINYLhQpxQXFyM9PV0eFDlw4EC5wXHIkCFql0dEGsMmSvpBRqNRHhRZWFgId3d3REREQK/Xc1AkEd0Tr1yog6amJnlQ5MWLF+Hg4ID7778fkZGRmDhxIvr06aN2iURkBRguBJPJhEuXLsmDIpubmxEaGgq9Xo+pU6dyUCQRdRnDxU4JIVBYWAiDwYDjx4/DaDTCz89P3kfx9fVVu0QismLcc7Ez5eXl8jc4FhcXo2/fvnjwwQeh1+sRGBjIfRQiUgSvXOxAfX09Tp06BYPBgOzsbDg5OcmDIn/yk59wUCQRKY7hYqPa2tpw4cIFGAwGnDlzBm1tbRg3bhwiIyPxwAMPwNXVVe0SiciGMVxsiBACeXl58qDI2tpaDBs2DFFRUYiIiIC3t7faJRKRnWC42IDS0lJ5H6W0tBT9+/eXB0UOGzZM7fKIyA4xXKxUbW2tPCjy6tWrcHFx6TAoUqfTqV0iEdkxhosVaW1txdmzZ5Geno7z589DCNFhUKSzs7PaJRIRAWC4aJ4QApcvX4bBYMDJkyfR0NCA4OBg6PV6REREcFAkEWkSw0WjiouL5X2U8vJy+Pr6yg2Ofn5+apdHRHRPbKLUEKPRiOPHj8NgMODatWtwd3fHtGnTEBkZidGjR7PBkYisBq9cVNbc3CwPivznP/8JnU6H8PBw6PV63HfffRwUSURWieGiArPZLA+KPHXqlDwoMjIyElOnToWHh4faJRIR9QjDxUKEECgqKoLBYMCxY8dgNBoxZMgQeR9l4MCBapdIRKQY7rn0soqKChw7dgzp6enyoMiIiAhERkYiODiY+yhEZJN45dILGhoacPLkSWRkZCA7OxuOjo6YNGkSoqKiMH78eA6KJCKbx3BRiMlkkgdFfv3112hra8PYsWMRFRXFQZFEZHcYLj0ghEB+fr78hVu1tbUYOnSovI/CQZFEZK8YLt1QVlYGg8EAg8GA0tJSeHl5yYMihw8frnZ5RESqY7h0Um1tLTIzM2EwGHDlyhU4OzvLgyLDwsI4KJKI6BsYLvfQPigyIyMDZ8+ehRAC48ePh16vx6RJkzgokojoBzBcvkUIgZycHGRkZCAzMxP19fUICgqSB0X269dP7RKJiDSP4fIvJSUlSE9PlwdFDhgwQN5H8ff3V7s8IiKrYtdNlNXV1fKgyIKCAri5ucmDIkNDQ9ngSETUTXZ35dLc3Iyvv/5aHhQpSRLuu+8+6PV6hIeHc1AkEZEC7CJczGYzsrKy5EGRTU1NGDVqFPR6PaZOnQpPT0+1SyQisik2HS7fHBRZVVWFwYMHyw2OgwYNUrs8IiKbZXN7LpWVlfI3OF6/fh2enp6YNm0aoqKiOCiSiMhCbOLKpbGxEadOnUJ6enqHQZGRkZGYOHEiB0USEVmYVYdLS0sLNm/ejK+//hotLS0YO3Ys9Ho9pkyZAjc3N7XLIyKyW5oMl66UlJubC3d3d/j6+na5Y54fkRER9Q5NhsuuXbt6dQBkc3MzmpqaMHPmzF57DyIie6bJDf2bN2/iySef7JXXLiwsxP/8z/9g4MCBDBciol6iyVG+kiRBp9Mp/kuSJKxbtw7R0dFq/xGJiGyaJsOltxw/fhxmsxkPPfSQ2qUQEdk0uwkXs9mMTZs24Y033uBGPhFRL7ObcPnkk0/g6+uLkSNHql0KEZHN0+SGvtKam5vxxRdf4MMPP+RVCxGRBdj8lYsQAu+99x4mTZqE/v37q10OEZFdsPkrl7KyMmRlZWHLli1ql0JEZDds+spFCIHVq1cjNjYWTk5OapdDRGQ3bDpcjh8/jsbGRsTExKhdChGRXbHZcGlra8OmTZuwbNkybuITEVmYTYaLEAIbNmxAcHAwbz0mIlKBTW7oFxUV4dSpU/joo4941UJEpAKbu3IxmUxYu3Ytnn/+ebi4uKhdDhGRXbKpcBFCYOPGjRg8eDDnhxERqcimPhbLzMzEmTNnsHnzZn4cRkSkIpu5crlx4wY2btyIN954A66urmqXQ0Rk12wiXO7cuYNVq1bhmWeewejRo9Uuh4jI7ll9uJSUlGDFihWYNWsWoqOj+XEYEZEGWO2eixACFy5cwIYNG/Doo4/iySefZLAQEWmE1YWLEALV1dVIS0tDRkYGfvWrXyEiIoLBQkSkIZoNl5s3b8LFxQWOjo6QJAnNzc24c+cOzp49i8zMTAwbNgxr1qzB4MGDGSxERBqj2XB57733IISQg0MIAScnJwQHB+Oll17C6NGjodNZ/ZYREZFN0mS4ODo64oknnkBLSwtaWloghICzszM8PDzg7OyMpqYmXLhwoUfv4evrq1C1RET0bZIQQqhdxLe1tLT0+nvodDo4OmoyW4mIrJ4mw6UrTCYTGhsb4erqCgcHB7XLISIi2ECfy/Xr1/Hcc8/h+vXrapdCRET/YvXhQkRE2sNwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHGOahfQE0IIVFZWor6+HpWVlRgxYgQkSVK7LE0TQqCiogJ1dXXw8PCAj48P16wTuG5dxzXrHltZN6u8cjEajUhKSkJISAgmTZqEL774ApMmTUJISAiSkpJgNBrVLlFzvrlmvr6+CAwMhK+vL9fsR3Dduo5r1j02t27Cyuzbt0+4u7sLSZKEJEkCgPyr/ffc3d3Fvn371C5VM7hm3cN16zquWffY4rpZVbjs27dPODg4CJ1O12Hxv/1Lp9MJBwcHq/qL6C1cs+7hunUd16x7bHXdJCGEUPpqqDcYjUYEBASgsbERZrP5Rx+v0+ng6uqK4uJieHl59X6BGsQ16x6uW9dxzbrHltfNavZctm7dioaGhk79BQCA2WxGQ0MDtm3b1suVaRfXrHu4bl3HNeseW143q7hyEUIgJCQEBQUF6Eq5kiQhKCgIV69etcq7LXqCa9Y9XLeu45p1j62vm1WES3l5OXx9fXv0fB8fHwUr0j6uWfdw3bqOa9Y9tr5uVvGxWF1dXY+eX1tbq1Al1oNr1j1ct67jmnWPra+bVYSLh4dHj57v7u6uUCXWo6dr5unpqVAl1oXr1nVcs+6x9XWzinDx8fFBcHBwtz5f9PLywn//93/j008/xZUrV2AymXqhQu3p7ppJkoTg4GB4e3v3UmXaxnXrOq5Z99j6ullFuEiShJdffrlbz/3P//xP3H///cjPz8eWLVvw9ttvY8eOHcjKykJra6vClWpHT9YsLi5O0xuFvYnr1nVcs+6x9XWzig19oOf3gwshUFpaiqysLGRlZeH27dvo06cPRo0ahbCwMISGhsLFxcUCfxLLseV76HsT163ruGbdY8vrZjXhAgD79+/H7NmzYTab73nrnk6ngyRJ2LNnD2bNmvW9jykvL5eDpri4GA4ODggODkZYWBjGjh1rM/s07WsmhLjnP97OrJk94bp1Hdese2x13awqXIC7fxFPPPEEmpqavvOz9stENzc3pKamdvovwGg0Ijs7G1lZWSgsLAQABAYGykHTr18/xepXw/79+zF37lw0NDQAQIdg7u6a2QOuW9dxzbrHJtet9yfMKG/58uVi1KhRIigoqMPsneDgYJGUlCSMRmO3X7u2tlacOnVK/O1vfxMrVqwQb7zxhti4caM4evSoKC8vV/BPYVlVVVUiKSlJBAcHK75mtozr1nVcs+6xtXWzuisXk8mEGTNm4PHHH8err76KyspK1NbWwtPTE97e3opucjU1NSEnJwdZWVm4cuUKWltbMXjwYISFhSEsLAyDBg3S/Kbat4l/fQdOb62ZreK6dR3XrHtsZd2sLlyOHz+OF198ETt27MCYMWMs9r4tLS24evUqsrKycPnyZTQ3N8PHx0cOmoCAAKv8B0BE1BusLlxWrFiB8+fP4//+7/9U+8/cZDIhPz8fWVlZyM7ORn19Pfr27SsHzYgRI6DTWcVd3kREvcKqwqWlpQXTp0/HM888g5deekntcgDcnVJaVFQk33lWXV0Nd3d3jBkzBmFhYQgODoajo1V/mzQRUZdZVbh89dVXeOWVV5CWloagoCC1y/kOIQRu3ryJrKwsXLp0CRUVFXB2dkZoaCjCwsIwatQoODk5qV0mEVGvs6pwWbJkCQoLC7Fr1y61S/lRQgjcvn1bvqIpLS2Fo6MjRo0ahXHjxtlk0yYRUTurCZeGhgZERUXhN7/5DRYtWqR2OV1WUVGB7OxsXLp0CTdu3IBOp+vQtNnTIXZERFpiNeGyZ88eLF26FPv374efn5/a5fRIdXW13LR57do1AMCIESPkoNH6WAcioh9jNeHy8ssvo6qqCh9//LHapSiqvr4ely9fRlZWFvLy8mAymeDv749x48YhLCwMAwYMULtEIqIus4pwqa6uxkMPPYQlS5bg6aefVrucXtPU1ITc3FxkZWUhNzcXra2tGDRokHyL8+DBg9lLQ0RWwSrCJTU1FatXr8ahQ4fs5ky+tbW1Q9NmU1MTvL295aAZOnQog4aINMsqwuW5554DAPzlL39RuRJ1mEwmFBQUyE2bdXV18PT0lIMmMDCQTZtEpCmaD5fy8nI88sgjePPNNzF37ly1y1Gd2WzG9evXcenSJblp09XVFWPHjkVYWBhGjhzJpk0iUp3mw+V///d/8e677+LIkSNWP/peaUIIlJSUyE2b5eXlcHZ2xujRoxEWFobRo0ezaZOIVKH5cHnmmWfg5eWFDRs2qF2KpgkhUFZWJjdt3rp1C46OjggJCZGbNl1dXdUuk4jshKbDpaSkBNHR0Vi/fj0ee+wxtcuxKpWVlXLT5vXr16HT6RAUFCT30nh6eqpdIhHZME2Hy0cffYQPP/wQ6enpcHNzU7scq1VTU9OhaVMIgeHDh8tB079/f7VLJCIbo+lwmTdvHoYPH4733ntP7VJsRkNDg9y0efXqVZhMJvj5+clNm76+vmqXSEQ2QLPhcu3aNcyZMwcffPABHnnkEbXLsUnNzc0dmjZbWlowcOBA+RbnIUOGsJeGiLpFs+GyceNGfPzxxzhy5AicnZ3VLsfmtba2Ii8vT27abGxsRP/+/eWgGTZsGIOGiDpNk+EihEBMTAwmTpyIt956S+1y7I7JZMK1a9fkO8/amzbbe2kCAwPh4OCgdplEpGGaDJfLly9j/vz52Lx5Mx588EG1y7FrZrMZN27ckJs2jUYjXF1d5W/aDAkJYdMmEX2HJsPlD3/4Az777DMcPnyYZ8gaIoTArVu35CuasrIyODk5dWja5EeYRARoMFzMZjOio6Mxffp0rFixQu1y6B6+2bRZUlICR0dHjBw5Um7a5O3jRPZLc+Fy7tw5PPvss9i6dSvCw8PVLoc6qaqqqkPTpiRJCAwMlG8IYNMmkX3RXLisW7cOX331Fb788ktO+rVStbW1ctNmQUEBhBAYOnQoxo0bh7Fjx8Lb21vtEomol2kqXEwmEx5++GHExMRgyZIlapdDCmhsbOzQtNnW1oYhQ4YgLCwM48aNg6+vL29xJrJBmgqXEydO4IUXXkBycjLCwsLULocU1tLSIjdt5uTkoKWlBQMGDJCnA/j5+TFoiGyEpsJl5cqVOHv2LL744gv+J2Pj2tra5KbN7OxsNDY2wsvLq0PTJj8WJbJemgmXlpYWTJ8+HU8//TQWL16sdjlkQWazuUPTZm1tLTw8POSmzaCgIN6STmRlNBMuhw8fRlxcHD777DMEBwerXQ6pRAiBGzduyF+AVlVVBRcXlw5Nm3369FG7TCL6EZoJl/j4eOTn5yMlJUXtUkgjhBAoLS2Vr2hu376NPn36yE2boaGhbNok0ihNhEtjYyOioqLw4osv4rnnnlO7HNKo8vJyeQzNzZs34eDg0KFp093dXe0SiehfNBEue/bswdKlS7Fv3z74+/urXQ5ZAaPRKDdtFhUVAUCHps2+ffuqXCGRfdNEuMTFxaGiogL/+Mc/1C6FrFBdXZ3ctJmfnw+z2Sw3bYaFhbFpk0gFqodLTU0Npk+fjtdeew3PPPOMmqWQDWhsbEROTg6ysrJw5coVtLW1YfDgwXLT5sCBA3mbO5EFqB4un376KVatWoVDhw7xK3ZJUS0tLbhy5YrctNnc3AwfHx/5isbf359BQ9RLVA+X559/HmazGX/961/VLINsXFtbG/Lz8+WmzYaGBvTr10/eoxk+fDibNokUpGq4VFRU4OGHH8bKlSvx1FNPqVUG2Rmz2YzCwkL5Fueamhq4u7vLTZvBwcFs2iTqIVXD5ZNPPsH69etx5MgReHl5qVUG2TEhBIqLi+WmzcrKSri4uCA0NFRu2nRyclK7TCKro2q4PPvss/D09MTGjRvVKoFIJoTA7du35Sua0tJS9OnTB6NGjZKbNl1cXNQuk8gqqBYut27dwqxZs5CQkICf/exnapRAdE/l5eVy0BQXF8PBwQHBwcEICwvDmDFj4OHhoXaJRJqlWrh89NFH+PDDD3H06FF2VpPmVVdXy02bhYWFAIARI0bINwT069dP3QKJNEa1cJk/fz6GDh2K3//+92q8PVG31dXVyV+Alp+fD5PJhICAALmXxsfHR+0SiVSnSrgUFhYiJiYG77//PmbOnGnptydSTFNTU4emzdbWVgwaNEjupRk0aBB7acguqRIumzZtwtatW3H06FFOtSWb0dra2qFps6mpCd7e3vIVTUBAAIOG7IbFw0UIgTlz5mD8+PF4++23LfnWRBZjMpk6NG3W19ejb9++8h7NiBEj2LRJNs3i4ZKTk4N58+Zh06ZNiIyMtORbE6nCbDajqKhIvvOsuroabm5uGD9+PObMmaN2eUS9QpFw2bx5M0JCQjr12MbGRlRWVsLPz+87HxE0NTXB2dn5ez86qKqqYhc/adqhQ4cwePDgH31cbW0t7ty5A5PJ1OnjBrg7wqalpQWTJ0/uSZlEFuGoxIvk5eVh0aJFPXqNL7/8Elu2bMGwYcPw9ttvf2f8xtKlSxkupGllZWXQ6/W9Mjqmrq4OH3/8Mby8vBguZBUU+dBXkiT06dOn27+uX7+OFStW4Je//CWKioqwdu3a7zyGyBps27YNAODg4KDor08//ZS9NGRVVN9RFEJg0aJFiIuLw+zZs/GXv/wFn3/+OZqbm9UujajL6urqsG/fPkVfUwiBK1eu4IknnlD0dYl6k+rhcv78edTU1GDhwoWQJAleXl4YP348EhIS1C6NqMsWLlyIY8eOQcn7ZEwmEwBwkgVZFVXDRQiBV155BcuXL++wif/+++8jNTVV0QOUyBL69esHSZJQXV2t2GuePHlSfl0ia6FquNTX16Oqqgo///nPO/y+r68vdDodioqKVKqMqHskScJPfvITpKSkKPaahw4d4nBXsjqqhsvq1asxZcqU7zSTSZKEf/u3f8OSJUtUqoyo+372s58hPz9fkdcSQqCpqQljxoxR5PWILEWRW5G7QwiB/fv34/Dhw9/787i4OEyePBlCCH4cQFalfW/EbDb3uAu/tbUVANjNT1ZHtX+xxcXFkCQJ3t7e3/tzFxcXODs74+zZsxaujKhnJEmCi4sLcnJyevxamZmZP3iMEGmZauHS3hR5r6uSV199FfHx8RasikgZM2bMwO7du3v8OkeOHMFjjz2mQEVElqVYuNy6davTjxVC4OLFi3jttdfu+bgFCxagrKyMPS9kdaZMmYKqqqoevUb7fsvo0aMVqorIchQLl1/84hdoaGjo1GMLCgrg4OAAV1fXez7OwcEBEyZMwOrVq5Uokchi2qdKtPeodEf7fktvjJMh6m2KhcuYMWOwdOnSTj12yZIl+Pd///dObdT/6U9/6tEBSqQGSZLg6uqK7Ozsbr9GZmYm+vfvr2BVRJajWLi8++67OHLkyI82PgohkJeXh8WLF3fqdfv3789ufbJKM2fO7NG+y+HDhxETE6NgRUSWo1i4eHh4wMPD4wdvLW536dIl9OnTp0vfQMnbMMkaTZ48GTU1Nd2aNCGEQHNzM0aNGtULlRH1PkX/1161ahVWrlx5z8e8/vrreOmll5R8WyJNat8raWlp6fJzq6qqIEkST6zIain6L3fWrFmoqalBW1vb9/7cbDbj5s2bePbZZ5V8WyJNkiQJ/v7+2L9/f5efu2vXLtx33329UBWRZSgaLjqdDoMGDUJycvL3/jwtLQ3e3t78fhayG/Pnz8fJkye79NGYEAKFhYWcJ0ZWTfFr7vXr1+ODDz74zu8LIbBu3TokJiYq/ZZEmjVgwAAIIVBXV9fp5+Tm5sLJyalL+5JEWqN4uISHh6O5ufk7B1NxcTFaWlrwwAMPKP2WRJolSRImTZqEv//97526ejGbzUhOTsb8+fM5U4+smuLhIkkSIiIiOmzsCyHwm9/8BosWLeIBQ3Znzpw5KC4uRkVFxT0fJ4TAl19+CVdXV05BJqvXK7eiJCYm4uDBg2hsbAQAnD17FsXFxbxLjOySo6MjZs6ciT//+c+or6//zhWM2WxGdXU19u3bh1OnTuGFF17gSRhZvV4Zud+3b19MmzYNr7zyCl588UX89re/xVtvvcUxFmS3ZsyYgVu3bmHz5s2YPn06Bg8eDCEEysvLkZeXh8LCQnh5eeGFF15gVz7ZBMXC5dtnY0lJSXj55ZexatUqLFy4ELNnz+bXFpPNu9e/8djYWJw+fRpnzpxBfX09JEmCm5sbhg0bhnnz5iEgIAAODg48TsgmKBIuXl5e+Oqrr77z+/PmzUNtbS369+//vT/vCk6GJa1zd3f/0Vlinp6emDp1qtxY6eTkBEdHR9TX1yM3N/dH32PIkCGK1ErU2yShwGnSDzVNKkmSJH6sRppmiQGr7Nona6FIuHRFc3MzysvLMXDgQDZTkt0qLS1FTU0NgoODedJENsnip0C5ublYuHAhpk+fjgMHDlj67Yk04ebNm/j444+xYcMGlJaWql0OkeIsfuUCADU1Nfjd736HAwcO4KmnnsLSpUvh4uJi6TKIVHX79m1s374d5eXleOyxxzBlyhTegkw2Q5VwAe7eVZOamoqEhAT4+fnh3Xff5aY92Z22tjbs3bsXJ06cQGhoKObOnQt3d3e1yyLqMdXCpV1BQQHi4+NRUFCAV199FU8//TTP3sju5OTkYNeuXXBwcMD8+fMRHBysdklEPaJ6uAB3N/mTkpLw97//HXq9Hm+99Ra8vb3VLovIompqarBz504UFBQgKioKM2fO5GY/WS1NhEs7g8GA5cuXw8HBAevWrcO0adPULonIooQQSE9Px4EDB+Dn54fY2FieaJFV0lS4AEB5eTmWLVuGEydOYOHChYiLi+Mty2R3iouLkZycjPr6ejz++OOYOHGi2iURdYnmwgW4O8hv27ZtSEpKwqhRo5CYmIjhw4erXRaRRTU3N+Pzzz/HuXPnMHHiRDz++OP8jheyGpoMl3bZ2dmIj49HWVkZli9fjjlz5nCzn+zO+fPnkZaWBnd3dyxYsABDhw5VuySiH6XpcAGAhoYGJCQk4LPPPsOjjz6KN998Ex4eHmqXRWRRlZWVSE5ORklJCWbOnImoqCiOgSFN03y4tNu7dy/WrFmDvn37IjExERMmTFC7JCKLMplMOHToEI4ePYrAwEDMnz8fffv2Vbssou9lNeECACUlJYiPj8fFixfx29/+Fs8//zzP3sju5OfnY+fOnWhra8PcuXP5rZWkSVYVLsDds7dNmzbhz3/+M8LDw/HOO+9g0KBBapdFZFENDQ1ITU1FdnY2pk6dikcffZR3VZKmWF24tDtz5gyWLl2KxsZGrFmzBo888ojaJRFZlBACJ0+exJ49e+Dj44PY2FieaJFmWG24AEB1dTV+97vf4eDBg5g3bx7i4+M5AJPszu3bt5GcnIyKigoOwCTNsOpwAe6evaWkpOCdd95BQEAAEhMTMWrUKLXLIrKo1tZW7N27F5mZmRg7diyefPJJuLm5qV0W2TGrD5d2+fn5iI+PR2FhIV577TX84he/4Nkb2Z3Lly8jJSUFjo6OmD9/PoKCgtQuieyUzYQLcLej+f3338c//vEPTJ8+HWvXrkX//v3VLovIompqarBjxw5cu3YN06dPxyOPPMIBmGRxNhUu7dLT07FixQo4Ojpi3bp1mDp1qtolEVmU2WyGwWDAgQMH4O/vjwULFnAAJlmUTYYLANy5cwfLli3DyZMn8atf/QqLFy/mrZpkdzgAk9Ris+EC3D1727p1K5KSkhAaGorExEQMGzZM7bKILKq5uRlpaWk4f/487rvvPsyZM4cDMKnX2XS4tMvKykJ8fDzKy8uxfPlyxMTEcLOf7M65c+eQlpYGDw8PxMbGIiAgQO2SyIbZRbgAQH19PRISEpCWlobHHnsMK1eu5ABMsjvfHID505/+FFFRUTzRol5hN+HSbs+ePVi7di369euHxMREjB8/Xu2SiCzKZDLh4MGDSE9PR1BQEObNm8cBmKQ4uwsXALh58ybi4+Nx6dIlLF68GIsWLeIATLI7+fn52LFjB0wmE5566imEhoaqXRLZELsMFwBoa2uTB2BOmjQJ77zzDgYOHKh2WUQWVV9fj5SUFOTk5GDatGl49NFH4ejoqHZZZAPsNlzanT59Gv/1X/+F5uZmrF27FjNmzFC7JCKL+uYAzAEDBiA2NpYnWtRjdh8uAGA0GrFq1Sp89dVXWLBgAV5//XXeqkl2p7S0FNu3b0dFRQVmz56NBx54gJv91G0Ml38RQmDnzp1ITEzE0KFDkZiYiJCQELXLIrKo1tZW7NmzBydPnuQATOoRhsu35OXlIT4+HkVFRViyZAliY2N59kZ2Jzs7GykpKejTpw8HYFK3MFy+R3NzM37/+9/jk08+wUMPPYQ1a9ZwACbZnerqauzcuRPXrl3DQw89hIcffpgDMKnTGC73cOTIEaxcuRJ9+vRBQkICpkyZonZJRBZlNpuRnp6OgwcPwt/fH7GxsTzRok5huPyIsrIyLFu2DKdOncKvf/1rLF68mLdqkt25ceMGkpOT0dDQgCeeeAITJkxQuyTSOIZLJ5jNZmzZsgV//OMfMWbMGHnTn8ieNDU1IS0tDRcuXEB4eDhiYmJ4VyX9IIZLF1y8eBFLly5FRUUFVqxYgZiYGLVLIrIoIQTOnz+PtLQ0eHp6IjY2Fv7+/mqXRRrEcOmi+vp6rFu3Dp9//jlmz56NFStWcAAm2Z2KigokJyfj1q1biI6ORmRkJO+qpA4YLt20Z88e+S6y9evXcwAm2R2TyYQDBw4gPT0dI0eOxLx58+Dp6al2WaQRDJceKC4uRnx8PLKzs7F48WL8+te/5gBMsjt5eXnYuXMnzGYznnrqKYwePVrtkkgDGC491NbWho0bN+Kvf/0rJk+ejISEBM5lIrtTX1+PXbt2ITc3lwMwCQDDRTEnT57EsmXL0NLSgjVr1nAAJtkdIQQyMzOxd+9eDsAkhouSjEYj3nzzTRw+fBixsbFYsmQJb9Uku1NaWork5GRUVVVh9uzZmDx5Mjf77RDDRWFCCGzfvh3vvfcehg4dinfffRcjR45Uuywii2ptbcXu3btx6tQphIWF4cknn4Srq6vaZZEFMVx6SV5eHl5//XXcuHEDS5YswYIFC3j2RnYnKysLqampcHJywvz58xEYGKh2SWQhDJde9M0BmDNmzMCaNWvg5eWldllEFlVdXY0dO3agsLAQM2bMwMMPP8y7Ku0Aw8UCDh8+jDfffBNOTk5ISEjAAw88oHZJRBZlNptx9OhRHDp0CAEBAViwYAEHYNo4houFlJWV4Y033sDp06exaNEivPTSS7xVk+zO9evXsX37djQ0NODnP/85m49tGMPFgsxmM/72t7/hT3/6E8LCwrB+/XoEBASoXRaRRTU1NeGzzz7DP//5T4SHh2POnDlwcnJSuyxSGMNFBRcvXkR8fDyqqqqwcuVKzJ49W+2SiCxKCIFz587h888/5wBMG8VwUUldXR3efvttfPHFF4iJicHy5cvh7u7+vY8VQqCiogJ1dXXw8PCAj48P7zwjm1BeXo7t27ejtLQUs2bNuucATB4H1oW3bKjEw8MDCQkJSEhIwKFDhzBv3jxcunSpw2OMRiOSkpIQEhICX19fBAYGwtfXFyEhIUhKSoLRaFSneCKFDBgwAP/xH/+BiIgI7N27F1u2bEFtbW2Hx/A4sE68ctGAGzduYOnSpcjOzkZcXBwWLlyIAwcOYO7cuWhoaABw96ytXfvZmpubG1JSUhAdHa1K3URK+r4BmPv37+dxYKUYLhrR1taGDRs24KOPPoKfnx8OHDgA4O5NAD9Ep9NBkiTs3r2bBxbZhLq6OqSkpCA3NxcuLi5YvXo1AB4H1ojhojEHDx5EdHT0PQ+mb9LpdHB1dUVxcTEbNMkmCCHw5ZdfIiYmBm1tbejMf1E8DrSHey4ak5WV1elgAe6e0TU0NGDbtm29WBWR5UiShJycHLS2tnYqWAAeB1rEKxcNEUIgJCQEBQUFnT6ogLsHY1BQEK5evcq7Z8jq8TiwDQwXDSkvL4evr2+Pnu/j46NgRUSWx+PANvBjMQ2pq6vr0fO/fQsnkTXicWAbGC4a4uHh0aPne3p6KlQJkXp4HNgGhouG+Pj4IDg4uMufF0uShODgYHh7e/dSZUSWw+PANjBcNESSJLz88svdem5cXBw3Mckm8DiwDdzQ1xij0YiAgAA0NjZ26pZk3t9PtojHgfXjlYvGeHl5ISUlBZIk/ei39bV3JqempvKAIpvC48D6MVw0KDo6Grt374arqyskSfrOZX7777m6umLPnj2YNWuWSpUS9R4eB9aN4aJR0dHRKC4uxgcffICgoKAOPwsKCsIHH3yAmzdv8oAim8bjwHpxz8UKCCFQWVmJ2tpaeHp6wtvbm5uWZHd4HFgXhgsRESmOH4sREZHiGC5ERKQ4hgsRESmO4UJERIpjuBARkeIYLkREpDiGCxERKY7hQkREimO4EBGR4hguRESkOIYLEREpjuFCRESKY7gQEZHiGC5ERKS4/wfFlDByRo8OMQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=2024, noise_scale_base=0.0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model.plot()\n", - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1692e33b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_7_pruning_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_7_pruning_-checkpoint.ipynb deleted file mode 100644 index 9c37c8020..000000000 --- a/docs/.ipynb_checkpoints/API_7_pruning_-checkpoint.ipynb +++ /dev/null @@ -1,263 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 7: Pruning\n", - "\n", - "### We usually use pruning to make neural networks sparser hence more efficient and more interpretable. KANs provide two ways of pruning: automatic pruning, and manual pruning." - ] - }, - { - "cell_type": "markdown", - "id": "7fd6a742", - "metadata": {}, - "source": [ - "## Automatic pruning\n", - "\n", - "### For each node, we consider it active if both of its max incoming l1 and outgoing l1 are above some threshold (see paper for details). Only active neurons will be kept, while inactive neurons are pruned away. Note that there is no automatic edge pruning, just to be safe (there are cases where important edges have small l1 norm). However, one can manually prune away nodes and edges." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.54e-01 | test loss: 1.30e-01 | reg: 2.02e+01 : 100%|██| 20/20 [00:11<00:00, 1.68it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "a4c70847", - "metadata": {}, - "source": [ - "### Let's try to use different threshold, by default, threshold = 1e-2" - ] - }, - { - "cell_type": "markdown", - "id": "d5ee3ecf", - "metadata": {}, - "source": [ - "threshold = 1e-4 leaves more hidden nodes." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "76adf576", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.54e-01 | test loss: 1.30e-01 | reg: 2.02e+01 : 100%|██| 20/20 [00:11<00:00, 1.70it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model = model.prune(threshold=1e-4)\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "13cfb2b4", - "metadata": {}, - "source": [ - "### We can manually prune away nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "81d103d2", - "metadata": {}, - "outputs": [], - "source": [ - "model.remove_node(1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "559c06e1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "fa3e5da5", - "metadata": {}, - "source": [ - "### We can also manually remove edges" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f4963f0e", - "metadata": {}, - "outputs": [], - "source": [ - "model.remove_edge(0,0,1)\n", - "model.remove_edge(0,0,3)\n", - "model.remove_edge(0,1,1)\n", - "model.remove_edge(0,1,3)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6bda6008", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "9397d2fe", - "metadata": {}, - "source": [ - "### Use prune() if you don't want to see these inactive nodes in the hiddenl layer" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2343614d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAyAElEQVR4nO3deXBVVYIG8O+897K87GRlCQSyhzUGAgFpZJPQICqiNSo6MtPWjF0u0zpVU1bZXXbN0lMz9vRg93S3zuj0gNu0GERskGCCoCJEAgoJSUggBLINZHvZXrb37pk/0u80j81AbnLf8v2q/OMe8sIh3pPvnuWeI6SUEkRERDoyGV0BIiLyPQwXIiLSHcOFiIh0x3AhIiLdMVyIiEh3DBciItIdw4WIiHTHcCEiIt0xXIiISHcMFyIi0h3DhYiIdMdwISIi3TFciIhIdwwXIiLSHcOFiIh0ZzG6AkTeQEqJtrY29PT0ICwsDDExMRBCGF0tIo/FngvRTdhsNrz66qtIS0tDXFwcZsyYgbi4OKSlpeHVV1+FzWYzuopEHknwJEqi6yssLMSmTZtgt9sBDPdeXFy9lpCQEBQUFCA/P9+QOhJ5KoYL0XUUFhZi/fr1kFJC07Qbfp3JZIIQAnv27GHAEF2B4UJ0FZvNhsTERPT19d00WFxMJhOsVisaGhoQFRU19hUk8gKccyG6yrZt22C320cULACgaRrsdju2b98+xjUj8h7suRBdQUqJtLQ01NbW4laahhACycnJqKmp4SoyIjBciNy0trYiLi5uVJ+PiYnRsUZE3onDYkRX6OnpGdXnu7u7daoJkXdjuBBdISwsbFSfDw8P16kmRN6N4UJ0hZiYGKSkpNzyvIkQAikpKYiOjh6jmhF5F4YL0RWEEHj22Wdv67PPPfccJ/OJ/ogT+kRX4XsuRKPHngvRVaKiolBQUAAhBEymmzcR1xv6O3fuZLAQXYHhQnQd+fn52LNnD6xWK4QQ1wx3ucqsViv27t2LNWvWGFRTIs/EcCG6gfz8fDQ0NGDr1q1ITk52+7Pk5GRs3boVjY2NDBai6+CcC9EISClRXl6OX/ziF3jhhRcwe/ZsTt4T3QR7LkQjIITAhAkTEBERgQkTJjBYiL4Dw4WIiHTHcCEiIt0xXIiISHcMFyIi0h3DhYiIdMdwISIi3TFciIhIdwwXIiLSHcOFiIh0x3AhIiLdMVyIiEh3DBciItIdw4WIiHTHcCEaocjISGzcuBGRkZFGV4XI4/E8F6IRcjqdsNvtCAkJgdlsNro6RB6N4UJERLrjsBgREenOYnQFiFw0TUNdXR36+/uNrorXmzp1KsLDw42uBvkxhgt5DIfDgZ07d2JoaAhBQUFGV8drtbS0YPPmzZg9e7bRVSE/xnAhjyKEwP3334+0tDSjq+IVNE3DqVOnkJiYiNjYWDidTrz++uvgVCoZjeFCHsdsNsNi4a35XaSUqK+vR0FBAYKCgrBq1Srk5OQYXS0iAAwXIq81ODiIwsJC9PX1oa+vD7t27eISafIYXC1G5IWklDhx4gSqq6tV2cSJEzFr1iwDa0X0JwwXIi8jpYTNZkNxcTE0TQMAWCwWrF27FqGhoQbXjmgYw4XIy2iahgMHDqC1tVWVzZs3D1lZWQbWisgdw4XIi0gpUVdXh2PHjqmyiIgI3H333ZxvIY/CcCHyIoODg9i/f7960VQIgWXLliE+Ph5CCINrR/QnDBciLyGlxDfffIOamhpVlpiYiMWLF8NkYlMmz8I7ksgLSCnR2dl5zSR+fn4+QkJCDK4d0bUYLkReQEqJzz//HC0tLapszpw5yMzM5HAYeSSGC5GHk1KioaEBR48eVWVhYWGcxCePxnAh8nAOhwOffvop7Ha7KrvzzjsxceJE9lrIYzFciDyYlBIVFRWorKxUZRMnTsTSpUs5iU8ejXcnkQez2+0oKiqCw+EAMLyp5+rVqxEWFmZwzYhujuFC5KGklCgpKUFDQ4MqS0tLw9y5czkcRh6P4ULkgaSUaG1txeeff67OZgkODsaaNWsQEBBgcO2IvhvDhcgDaZqGzz77DDabTZXNnz8fSUlJ7LWQV2C4EHkYKSUuXryIEydOqLKoqCgsX76ck/jkNXinEnmYoaEhFBUVXbN/WGxsLHst5DUYLkQexLX0uKqqSpVNnjwZixYtYrCQV2G4EHkQu92O4uJiOJ1OAMNLj1etWsX9w8jrMFyIPISUEseOHXNbepyeno7Zs2ez10Jeh+FC5AGklGhvb8ehQ4fU0uOgoCCsXr2aS4/JKzFciDyAlBKHDh1CR0eHKsvJycH06dPZayGvxHAhMphr1+Orjy5esWIFlx6T1+KdS2Qwp9OJ4uJi9PX1qbKlS5dy6TF5NYYLkYGklKiqqsLp06dV2aRJk3h0MXk93r1EBurv73fb9dhkMmHlypXc9Zi8HsOFyCBSShw/fhwXL15UZampqdz1mHwCw4XIAFJK2Gw2HDx4EJqmAQACAwOxevVqBAYGGlw7otFjuBAZQEqJL774Aq2traps3rx5SElJYa+FfALDhWicSSnR1NSEkpISVRYWFoaVK1dyEp98Bu9konHmWnrc29urypYsWYKEhAT2WshnMFyIxpGUEtXV1SgvL1dl8fHxuPPOO9lrIZ/Cu5loHPX392P//v0YGhoC8KelxxEREQbXjEhfDBeicXK9pcfJycnIzs7mcBj5HIYL0Thw7Xp84MABt6XHa9asQVBQkMG1I9Ifw4VoHGiahoMHD6K9vV2VZWdnc+kx+SyGC9EYk1Li4sWL1+x6vGrVKk7ik8/inU00xgYHB7Fv3z709/cDAIQQWLZsGeLi4thrIZ/FcCEaQ1JKfPPNN6ipqVFlU6ZM4a7H5PN4dxONESklOjo6UFRUpCbxLRYL1qxZg5CQEINrRzS2GC5EY0TTNBQXF7vtHzZ37lzMnDmTw2Hk8xguRGPA9Sb+1ZP4a9asgdlsNrBmROOD4UI0Bnp7e7F3714MDg4CGH4Tf8WKFYiPj2evhfwCw4VIZ5qm4dChQ6ivr1dlM2bMQF5eHifxyW/wTifSkZQStbW1+OKLL1SZ1WrF+vXrERwcbGDNiMYXw4VIR729vdi9e7d6pwUAli5diunTp3M4jPwKw4VIJ06nE0VFRW4bUyYlJeGuu+7icBj5Hd7xRDqQUqK8vByHDx9WZVarFRs2bEBoaKiBNSMyBsOFaJSklLh8+TJ2796tzmkRQmDFihVITk7mcBj5JYYL0ShIKdHX14edO3eira1NlWdkZGDZsmUcDiO/xTufaBScTif27duH6upqVRYdHY3777+f57SQX2O4EN0mTdNw5MgRfPXVV5BSAgCCgoJw3333ISEhgcNh5NcYLkS3QUqJsrIy7NmzBw6HA8DwW/grV67E7NmzGSzk9xguRLdISomzZ8/igw8+cHufJScnB8uXL+feYURguBDdEtepku+99x66u7tVeWpqKu677z4EBgYaWDsiz8FwIRohKSUaGhrw9ttvo729XZVPnjwZDz/8MMLCwjgcRvRHFqMrQOQNpJSor6/HW2+9hZaWFlUeFxeHRx99FDExMQwWoiswXIi+g2szynfeecetxxIdHY3NmzdjypQpDBaiqzBciG5C0zRUVFTg/fffR1dXlyqPjo7GY489hqSkJAYL0XUwXIhuwOl04uuvv8bu3bvR19enymNjY7F582budEx0EwwXoqtIKTE4OIji4mIcOHBAvccCAJMmTeJQGNEIMFyIriClRFdXFz766CN8++230DRN/VlycjIeeeQRxMbGMliIvgPDheiPpJRoamrC+++/jwsXLqhyIQTmzp2LBx54ABEREQwWohFguBBheH6lvLwcH374IWw2myq3WCxYunQp1q5di6CgIAYL0QgxXMivueZXDh48iAMHDmBgYED9mdVqxfr165GXlweLhU2F6FawxZDfklKira0Nu3btQkVFhdv8SlxcHB588EGkpaXxTBai28BwIb8jpYSmaTh9+jR2796N1tZWtz/PyMjApk2bEBcXx2EwotvEcCG/IqVEZ2cnioqKUFJSoo4lBobnV+68807k5+fDarUyWIhGgeFCfsE1t3Lq1Cns37/fbX8wAIiMjMSGDRtwxx13wGQyMViIRonhQj7NFSo1NTU4ePAgamtr3eZWhBBIT0/Hfffdh0mTJjFUiHTCcCGP1NPTg9raWoSHhyM8PBxWqxWBgYEwm80qAK4XBK7jhh0OBzo6OlBVVYXjx4+joaEBTqfT7WvDwsKwYsUK3HnnnVxmTKQzhgt5pIaGBmzbtg0AEBAQgODgYISGhiIyMhKRkZGIiIhAWFgYrFarWiY8MDCA7u5utLa2oqmpCZcvX3Y7KdLFYrEgKysLa9euxaRJk7gajGgMMFzII3V2dqqehtPpRH9/P2w2GxobG2/7e5rNZiQlJWHlypXIzMx06wURkb4YLuSRrnxLfrSCg4ORkpKCxYsXIy0tDYGBgQwVojHGcCGPlJ2djZiYGHR0dKC9vR02mw1dXV3o7e1Ff38/HA4HNE1zm5wHhnsnFosF4eHhmDhxItLT05GRkYHY2FiuAiMaRwwX8kgJCQlISEhQE/RSSjgcDgwNDaGvr0/9NzAwAIfDASEEAgICYLVaER4ejtDQUAQHB0MIwUAhMgDDhTyKlBJ1dXUYHBwc0de7QsX1WbvdDrvdPpZV9GhOp9Ov//3kORgu5DGEEJg4cSIqKipQUVFhdHW8VnBwMEJCQoyuBvk5IV3jDkQGc+35xVty9EwmE5dYk6EYLkREpDs+2hARke4YLkREpDuGCxER6Y7hQkREumO4EI2Q0+lEd3f3NbsrE9G1GC5EI9Tc3Iwf//jHaG5uNroqRB6P4UJERLpjuBARke4YLkREpDuGCxER6Y7hQkREumO4EBGR7hguRESkO4YLERHpjuFCRES6Y7gQEZHuGC5ERKQ7hgsREemO4UJERLpjuBARke4YLkQjIKVEe3s7urq60N7eDiml0VUi8mhCspUQ3ZDNZsO2bdvwq1/9CufOnVPlKSkpePbZZ/HEE08gKirKuAoSeSiGC9ENFBYWYtOmTbDb7QDg1lsRQgAAQkJCUFBQgPz8fEPqSOSpGC5E11FYWIj169dDSglN0274dSaTCUII7NmzhwFDdAWGC9FVbDYbEhMT0dfXd9NgcTGZTLBarWhoaOAQGdEfcUKf6Crbtm2D3W4fUbAAgKZpsNvt2L59+xjXjMh7sOdCdAUpJdLS0lBbW3tLK8KEEEhOTkZNTY2ajyHyZwwXoiu0trYiLi5uVJ+PiYnRsUZE3onDYkRX6OjoGNXnu7u7daoJkXezGF0BIiP19/fjxIkTOHLkCI4cOYKvv/56VN9vx44dWLhwIbKyshAXF8chMvJbHBYjv9LV1YVjx47h6NGjOHLkCL799lsMDg4iMjISixYtQl5eHv7lX/4FDQ0Nt/y94+LisHnzZtTX1wMAYmJiMHPmTMycORNZWVmYMmUKw4b8Bnsu5NPa2tpUkBw9ehTl5eXQNA3x8fFYvHgxNm7ciMWLFyMzMxMm0/AosdPpxPPPP3/LE/o//vGP8dxzz6GnpwdVVVWoqKhARUUFDh8+DE3TEB4eroJm5syZSEpKgtlsHqt/OpGh2HMhn9LQ0ICjR4+qQKmpqQEATJs2DYsXL8bixYuRl5eHGTNm3LAXofd7Lv39/aiurkZFRQUqKytRXV2NoaEhWK1WZGRkqN5NSkoKAgICRvXvJ/IUDBfyWlJKnDt3Ts2XHD16VA1nZWRkIC8vT4XJ5MmTb+l73+ob+nv37sWaNWtG9L2HhoZw7tw5VFZWoqKiAlVVVejr60NAQADS0tJU7yY9PR1Wq/WW6k3kKRgu5DWcTicqKirchrlaW1thMpkwd+5cFSaLFi1CdHT0qP++ke4ttnPnzhEHy/VomoYLFy6oYbTKykp0dXXBZDIhOTlZDaNlZmYiPDx8dP8oonHCcCGPNTg4iJMnT6ogKSkpQXd3NwIDA5GTk6OGuRYsWICwsLAxqYPNZsP27dvxy1/+8ppdkZ977jk88cQTiIyM1PXvlFKiqalJBU1FRQVaW1sBAFOnTnWbt9EjRInGAsOFPIbdbsfx48fVMFdpaSkGBgYQGhqK3NxcFSZ33HEHgoKCxrVurvNcuru7ER4ejujo6HFd+dXS0qKCpqKiAk1NTQCAhIQEt7BJSEjgijTyCAwXMozNZkNJSYka5jp16hQcDgcmTJiAvLw8Ncw1e/ZsWCxc2Hglm82mVqRVVlairq4OUkpMmDBBBc3MmTMxdepUhg0ZguFC4+bSpUtu8yWVlZWQUmLSpEluK7nS0tLUsmAamd7eXpw5c0b1bs6ePQun04nQ0FBkZWWpwElOTubyZxoXDBcaE1JKXLx4UYXJkSNHcP78eQBAcnKyCpLFixfz6XoMDAwM4OzZs2oYrbq6GgMDAwgKCkJ6errq2aSlpSEwMNDo6pIPYriQLjRNQ01NjeqVHDlyBM3NzRBCICsrS/VMFi1ahISEBKOr63ecTidqa2tVz6ayshK9vb0wm81ITU1V8zaZmZkICQkxurrkAxgudFscDgfKy8tVr6SkpAQdHR2wWCyYN2+e6pUsXLiQB2h5ICkl6uvrVc+moqICNpsNQghMnz5dDaNlZWXpvhqO/APDhUZkYGAAJ06cUL2SY8eOobe3F0FBQcjNzVVhMn/+fD75eiEpJS5duuT2rs2lS5cAAJMnT3bbI200RxKQ/2C40HX19PTg2LFjqmfyzTffYHBwEBEREVi4cKEa5po7dy7H7H1UW1sbKisr1VCaa0PO2NhYt+XPkydP5pwZXYPhQgCA9vZ2tz25ysrKoGkaYmNj3Sbfs7KyuNrIT3V3d7stf66trYWmaYiIiHAbRps+fTpX+xHDxV81NjaqMDl69CjOnDkDAEhMTHRbFpySksKnUrquvr4+tw05a2pq1IacmZmZKnC4Iad/Yrj4ASklamtr3ZYFu4Y40tPT1QuLeXl5SExMNLi25K2GhoZw9uxZtw05+/v73TbknDlzJtLT0xEcHGx0dWmMMVx8kNPpRFVVlduy4JaWFphMJsyePVv1ShYtWoTY2Fijq0s+yul0XrMhZ3d3t9qQ0zWMlpWVNWZ7w5FxGC4+YHBwEKdOnVJBUlJSgq6uLgQGBiI7O1sNc+Xm5nJXXTKMlBKNjY1ue6S1tbUBGD5v58p5G27I6f0YLl6or68PpaWlar7k2LFj6O/vR0hIiNuy4JycHA4/kMeSUl6zIWdzczMAYOLEiW5hww05vQ/DxUsUFxfj8OHDOHLkCE6ePAmHw4GoqCi3+ZI5c+Zw4pS8ms1mc9tF4MKFC5BSIjo6WoVNbm4uezZegOHiJTo6OqBpGgICAtR/ZrOZT3Pk0xwOB7q7u9HV1YXu7m709PQgIyMDEyZMMLpq9B0YLl5C0zQIIRgm5NecTieEEHyPxgswXIiISHeMfyIi0h2P9/sjp9OJ0tJSdHd3G10Vrzd37lzEx8cbXQ26DU6nE9XV1ejr6zO6Kl4vOTnZr3cE57DYH/X19WHDhg3o7+/nC123ybUTwK9+9SusXbvW6OrQbRgYGMBPfvITDA4Ochn7KDQ3N+OZZ55Bbm6u0VUxDHsufySlhMlkwj/8wz9gyZIlRldnTGmahv7+fkgpERwcrNtGlA6HAw8//DD4vOLdhBDYsmULZs2aZXRVvIJrj7WUlBSEhYXB4XDgn/7pn/y+HTBcrmI2mxEUFGR0NXQnpYTD4cCRI0fw7rvvoqysDE6nE6mpqXj44Ydx9913IzAwcFSr0biazXeYTCa+MzUCUkpUVVXh3//93xEbG4uFCxdi1apVbAdguPgFKSV6enrw85//HP/zP//jNp5eW1uLgwcP4qGHHsLLL7+MyMhINgyiEdI0DYcPH8bQ0BCam5uxd+9ezJ071+hqeQSGi4+TUqK3txcvvvgiCgoKoGnaNV8zODiId999FwMDA3jllVcQGhpqQE3JU7mGd/jQca3W1laUl5er66SkJCQnJxtYI8/Bpcg+zuFw4Oc//7lbsJhMJmRlZSE7OxsWy/DzhZQSH374IX73u99dN4DIPzkcDlRVVWFwcNDoqngcKSVOnjyJrq4uVZaXl8eFEH/EcPFhUkrs2bPHLTCCgoLwox/9CLt378aHH36IF198Uc0xOZ1O/PrXv0Z5ebnfT0bS8MqxgoIC/OxnP8Pu3bvhdDqNrpJHcTgcKCkpUW0lJCQE8+fPN7hWnoPh4qOklGhoaMA///M/qzkWs9mMH/7wh3jhhRcQGRmJ0NBQPPXUU3jsscfUkEdbWxu2bt3KJ1U/Nzg4iDfffBMFBQXo6+vDrl278PXXX/Oh4wotLS04d+6cuk5NTcXEiRMNrJFnYbj4KKfTid/85jc4f/68Klu9ejWee+45BAYGqrKAgAD86Ec/Qnp6uiorLi7G0aNH+YvEj5nNZgQHB6t7YGBgAO+99x46OjoMrplnkFLi9OnT6O3tBTA8H7VgwQI1zEwMF58kpcS3336LHTt2qLKEhAS89NJL10zWCyEQHx+PZ555RjWMvr4+vPHGG+y9+DGz2Yw/+7M/Q3Z2tiprbm7G/v37OSeH4VVix48fV+FrtVoxZ84cLnq4AsPFBw0NDeG3v/2tmmg0mUz467/+a6Snp1/35hdCYN26dW6/SD7//HN8++237L34sZCQEGzevBkREREAhh9aPvvsM3V6pD/r6OhwGxKbPn06EhISDKyR52G4+BgpJUpLS1FcXKzKMjMz8cgjj9x0m/KwsDBs2bJFva3f19eHt99+m0+pfkwIgWnTpuGuu+5SZe3t7fjqq6/8+qFDSomzZ8+is7NTlc2bN48vnV6F4eJjHA4H/vu//xt2ux3A8PDGX/3VX33nyX1CCNx9991IS0tTZcXFxairqxvL6pKHE0Jg1apVCA8PBzD8i/WLL75Q95c/ci1Bdj14BQQEYM6cOQbXyvMwXHyIlBIVFRX47LPPVNnMmTOxbt26EY0FR0VF4cEHH1Rf29raio8//tivn1L9nRACkyZNwh133KHKGhoaUF1d7bf3RV9fH6qqqtR1QkICpkyZwvmWqzBcfIiUEu+88446NsBkMuHxxx9HZGTkiD4vhMCGDRsQExOjyj766CMeQ+DnTCYTvve976kFHw6HA1999ZXfDpk2Nzfj8uXL6jozMxNWq9XAGnkmhosPqa+vxyeffKKup0+fPuJei8u0adOwcuVKdV1dXY1jx4757VMqDT90pKenY8qUKaqsrKzM7c10fyGlRGVlJQYGBgAM/2y4Suz6GC4+QkqJP/zhD25PVA888ADi4uJu6fuYTCZs2rRJvQszNDSEDz/80G+fUmnY1W+ft7e3o7Ky0u8eOjRNc9tLLCwsDKmpqQyX62C4+Iienh58+OGHqrFHR0dj48aNt3zTu14Gu3Ji/9ChQ2hqatK1vuRdXPeF66FD0zSUlpb63UNHV1eX2yKXqVOnfudiGX/FcPEBUkocO3bMbZJx+fLlmDFjxm19v7CwMNxzzz3q+vLly/jss8/87imV3E2dOtVtaKyystKv5uOklKivr4fNZlNlWVlZfCv/BhguPkDTNBQUFKg36gMDA/HQQw/d9gmTQgisXbvW7eW5jz/+mG/s+7ng4GDMmzdPXbe3t+PcuXN+9dBRUVGhNvA0m83IysoyuEaei+HiAxobG3Ho0CF1nZ6ejoULF45qHDg1NRU5OTnq+sSJEzh79uyo6kneTQjhdkyD0+nEyZMnDa7V+HEdP+ASGRmJpKQkzrfcAMPFy0kpUVxcjJaWFlW2YcMGhIWFjer7BgYGYsOGDarhdHd3Y//+/X71lErXSkpKclskcvr0afT39xtYo/HT2dmJhoYGdT1t2jT1cildi+Hi5QYGBtxedIyMjMT3v//9UT9NCSGwfPlyxMfHq7K9e/f69ZvZBISGhiIzM1Nd/9///Z9fLPaQUuLixYtuc0xZWVm3PfTsDxguXsy1x9G3336rynJzc3U7ZnXy5MlYunSpuj5z5gxOnTrF3osfE0Jg3rx56uFlYGAAFRUVfnFPnDlzxm2+JSMjg0NiN8Fw8XL79u1DT08PgOF3VDZs2KDbBnqu7+caY+/v78cf/vAHv/hFQtcnhEBqaqrbsGt5ebnPL0l2OBw4c+aMuo6KinJbOUfXYrh4sd7eXuzbt09dx8fHY9myZbo9TQkhsGjRIkydOlWVFRUVob29XZfvT94pJibG7Z44f/682w7BvqizsxP19fXqmvMt343h4qVcJ+FVV1ersqVLl+p+zOqECROwevVqdV1fX+92bjj5H4vFglmzZqnrzs5O1NXV+fQ9cfHiRTVCAAzvJ8b5lptjuHixTz75RK3UMZvNWL9+/U3PbLkdQgjcc889CA4OBjA8PPDxxx/7/DAI3ZgQAjNnznRbknz69GmDazV2pJRu8y0Wi4XzLSPAcPFSXV1dOHDggLpOTEwc9bst1yOEwNy5c5GRkaHKvvzyS79YIUQ3Nm3aNEyYMEFdV1VVYWhoyMAajZ2r51siIyORmJhoYI28A8PFC0kpcerUKdTW1qqyZcuWuW2Vr6eQkBB8//vfV9ctLS3cDsbPhYWFuW0v1NjY6LNzcVfPtyQlJXG+ZQQYLl6qsLBQbcdisViwdu3aMeumu7aDufI0wl27dqltx8n/mEwmt3mX3t5e1NbW+twDh+v9livnWzIyMnQffvZF/Al5oc7OTrfTJqdOnYqcnJwxHQNOTU1Fbm6uuj5x4oTfvN9A1xJCICMjQ+2S7Fpg4ouqqqo433IbGC5exjUkduHCBVW2bNkyt/HvsRAQEIAHHnhAPbHZ7Xbs2rWL4eLHJk2ahNjYWHVdU1Pjc71ZzrfcPoaLF9q/f78aEgsICNBlu5fv4toO5sr3G/bu3eu2pxn5F6vVitTUVHXd3Nzsc/fD1fuJcb5l5BguXqarq8ttB+TExES37TjGUmxsLNatW6euGxoasG/fPvZe/JRrSbLr3uvv7/epLfg53zI6/Cl5ESklysrK3E7C+973vjfmQ2IuQgg8+OCD6slN0zS89957bo2P/IcQAmlpaQgKCgLwp3kXXwkXYPhANM633B6Gi5f59NNP1bi2xWJBfn7+uN3sQghkZmZi2bJlqqysrIzLkv1YfHy8287ZZ8+e9Zkt+DnfMjoMFy/S3d2NgwcPquspU6bgjjvuGNcnKYvFgj//8z9Xb+wPDQ3hv/7rv9Db2ztudSDPERQUhLS0NHV9+fJlXLp0ycAa6cdms6GxsVFdc77l1jBcvMjp06fdXpxcunQpoqOjx7UOQgjk5eVh0aJFquz48ePcLdlPXT3vMjAwgJqaGp+4Fy5cuHDN+S2cbxk5/qS8hJTS0CGxKwUHB+OHP/whrFYrgOHhg1/+8pdobm4e97qQsYQQSElJUfcCMPwQ5O17z0kpUVVVpf4dnG+5dQwXL9HT0+P24uTkyZMxf/58Q252IQTuvPNOrFmzRpU1NDTgyy+/HPe6kPHi4uLcduOura1FX1+fgTUaPZ7fMnoMFy8gpURlZSXOnTunypYsWTJme4mNRGBgIJ5//nnEx8cjKysLv/nNb7Bx40bD6kPGCQwMdNvYtLW11es3Nm1vb3d7v2X69OluB6TRd2O4eIlPP/3UbXt9o4bEXFwrx15//XXs2LED69ev1+0ETPI+V867DA0Nobq62mvnXaSUqKurc1ukwvmWW8ef1g1IKXH58mWPWAVlt9vdttefNGkScnNzDR//NZlMWLJkCeLi4gyvCxlHCIHk5GS3J3tvn3epqKhQ9Q8ICOB8y21guFzHwMAAdu/ejY0bN+KNN94wvJFUVFTg7Nmz6jovL8/QIbErCSHY6AgTJkxwm5M4f/6820orbzI4OIiqqip1HR0dzfmW28BwucrAwABeeuklPPPMM6ipqcFrr72GsrIyw7r4UkocOHBATZCazWasXbuWXXTyKAEBAcjKylLXHR0duHjxooE1un0tLS1uKx9TU1MREhJiYI28E39DXcViscBqtaqNIdva2vCv//qvhq1+sdvtKCoqUtcJCQljcuIk0WjNmjVLnSvvdDq98kgGKSVqampUexdCYPbs2XyYuw38iV3FbDbj6aefRmZmpio7ePAg9u/fP+4NxbXWvrq6WpUtXrwYcXFx41oPou8ihEBSUhIiIyNVWUVFBRwOh4G1unVSSpSXl6u2HhwcjPT0dD7M3QaGy3UkJCTgb//2b9VBSENDQ/j1r3+Nzs7Oca9LUVERh8TIK0RERCA5OVld19fXo62tzcAa3bre3l63h7mJEye67Z1GI8ffUtchhMDdd9+N5cuXq7Ly8vJx3+LkekNiixYt4lMUeSSTyYTZs2er656eHq/bCqa+vh6tra3qOisrS+2jR7eG4XIDwcHBePrpp9VEntPpxO9+9zt0dXWNy9/v2r6cQ2LkLVz7jF25Bf+pU6e8JlxcR1oMDQ0BGA7LuXPnGlwr78VwuQEhBObPn4+VK1eqsoqKChQWFo5bYyksLHQbElu3bh2HxMijTZo0CZMmTVLXVVVVHvGu2EgMDQ2hrKxMXUdFRSE5OZkjBbeJv6luIiAgAE8++aTalM/pdGLbtm2w2+1j/nd3d3e7DYlNnjyZQ2Lk8YKDgzFz5kx13dLSggsXLnhF7+XSpUtuy6dTU1PdFijQrWG43ISr97J06VJVdvLkSRw+fHhMG4uUEidPnrxme/3Y2Ngx+zuJ9JKdna2WJDscDnzzzTcG1+i7uYahr1yCfMcdd3CkYBT4k/sOgYGB2LJli1o5Njg4iLfffluNy44FKSX27t2rttcPCAjA+vXr2Wshj+fagv/Kc4ZOnTrl8adTOp1OHD9+XD00hoSEuO2XRreO4fIdhBBYsmSJ28Tel19+OaZnhbe3t7vtJTZt2jQsWLCANzp5hbCwMLe39ZuamlBfX+/RQ2MtLS1uWywlJydzCfIoMVxGICQkBI8++qjqIvf09OB///d/x6SxSClRUlLiNva7evVqREVF6f53EY0Fk8mEBQsWqPYyMDCA0tJSg2t1Y65h6J6eHlW2YMECWCwWA2vl/RguIyCEwJo1a5CUlKTKPvnkE7fzHvTidDqxa9cuOJ1OAMMTpPfccw97LeQ1hBDIysrChAkTVNmJEyc89gCxoaEhHD16VD0shoaGIjs7m21ulBguIxQXF4cHHnhAXV+6dAkff/yx7r2X+vp6HD58WF1nZWVh9uzZvNHJq0RERGDOnDnqurGxEbW1tR45NFZfX+82JJaens4hMR0wXG7BAw88oCYqpZTYsWOHrlvCSClRWFjotmXGPffcwx1ZyeuYTCbk5eWpVWNDQ0P46quvPC5cNE3D4cOH1YID1xHeHBIbPYbLCAkhMGPGDKxatUqVVVdX49ChQ7o1GLvdjo8++kh9v+joaKxdu5a9FvI6QghkZGRg4sSJquz48ePo6OgwsFbX6uzsxNGjR9V1bGws5s2bxzanA4bLLTCbzXj00UfVS5UOhwPvvvuu2p5/NKSUOHHiBMrLy1XZkiVLMH369FF/byIjhIWFYeHCheq6vb3dbbmv0aSUOHbsGFpaWlTZwoUL+eKkThgut0AIgZycHOTk5KiykpISnDx5ctQNRtM0vP/+++rdFovFgoceeojdc/JqS5YsUcO6UkocPHjQY955cW0M62q7VqsVd911F3stOmG43KLg4GA88sgjaizZbrfj97///aiPQq6rq0NxcbG6TktLw5IlS3ijk9cSQiAxMRGzZs1SZbW1tR5xiJiUEl9//TXq6upU2bx58zBt2jS2OZ0wXG6REAKrVq1yO7di3759ozrSVUqJgoICtdW3EAKbNm1CRETEqOtLZCSLxYJVq1apHrjD4cC+ffvGdIeLkeju7saePXvUQ2FQUBDWrl2rHhpp9BgutyE6OhqbNm1S1y0tLSgoKLjtp7GWlhZ88MEH6jo+Ph733nsvn6DI6wkhMGvWLKSmpqqy8vJyQ3svmqahuLgYFy5cUGXZ2dnIyMhgm9MRw+U2CCGwceNGt7NVduzY4TYxOFJSSnz00UduN/q6deswbdo0XepKZLTg4GC3XsHQ0BB2796t5hfHk5QSFy5ccDv4LyQkBPfeey/nN3XGcLlN06ZNw/r169V1XV0ddu3adctPY21tbdi+fbv6XGRkJB577DE+QZHPcO0unpaWpspOnz6NkpKSce29SCnR29uLt956y+39tOXLlyM1NZVtTmcMl9tkMpnw+OOPq2WLUkps3779ls4Ml1Ligw8+QE1NjSpbs2YNsrKyeKOTTwkODsa9996LgIAAAMPbHLnmGccrYBwOB3bs2OF2IFhiYiLuu+8+bq0/BvgTvU2u/ZPy8/NV2dmzZ7Fz584RNRYpJRobG/Hmm2+qScWIiAg8+eSTnFQknyOEQHZ2NubPn6/Kmpqa8P7778PhcIzp3y2lxNDQEHbt2oV9+/ap9hkcHIzNmzcjOjqaD3NjgOEyCmazGT/4wQ8QHh4OYHii8M0330Rzc/N3flbTNPznf/6n21zLhg0bMGfOHN7o5JMCAgLw0EMPue3w/cUXX6C4uHjUS/lvREoJu92Od955BwUFBWpDWLPZjPvuuw85OTlsb2OE4TIKQgjMmTMH99xzjyqrq6vDG2+8oW7i65FS4siRI3jnnXdUWXx8PJ566in2WshnCSEwdepUPPjgg24nVb733nsoLS3VNWCklHA6naiursYrr7yCPXv2qB6SEALLly/Hvffey/Y2hhguo2Q2m/HUU0+pI4illHjrrbdQWlp63eExKSUuXbqEn/70p+ju7gYwPH/zgx/8AGlpaXyKIp9mMpmwYsUKt6PDe3t78dprr+Ho0aM3fSgbCdcQWE1NDV577TX84z/+I8rLy1VbNJlMWLlyJZ544gl1uiyNDa69GyXXBn1btmzBv/3bv0FKic7OTrz88svYtm0b4uPjVWC4Vqu8/PLLOHXqlPoeOTk52LJlCycVyS8EBgbisccew+XLl1FZWQkA6Orqwm9/+1s0NjZi3bp1CAkJGfGDlpQSmqbBZrPh1KlT+OKLL3DmzJlrljoHBQVhw4YNuP/++xEUFMQHuTHGcNGByWTCX/7lX6K4uBjffPMNgOHDkf7u7/4Or7zyinofpr29HX//93+Pjz76SH02JiYGP/3pT3nSJPkNIQSioqLw9NNPY+vWreoslb6+Prz//vsoLS3FunXrkJ2djfDwcAgh3ILA1QtxOBzo6OhAdXU1SktLcfr0adhstmtGDIQQSEpKwiOPPILs7GyYTCYGyzhguOgkJiYGL7/8Mv7iL/5CbSu+b98+NDU14dFHH4Wmafj973/vtsllUFAQXnzxRSxYsIA3O/kVIQQSEhLw/PPP4/XXX0dZWRmklJBS4ty5c/iP//gPxMTEIDU1FTNmzEBsbCwCAwMxNDQEm82GpqYmXLx4EU1NTejt7b3uELQQAhMnTsTq1auxYsUKFVQ0PhguOhFCIC8vDy+99BJ+8pOfoK+vT53NffLkyWu+PjAwEM8++yweeeQRDoeRXxJCID4+Hs8//zwKCgpQVFSkdkyWUqK1tRWtra3qvBUhxIiW+QcFBSE1NRV33XUX5s+fj4iICIaKARguOjKZTHj00UfhdDrxs5/97IanVIaHh+OFF17Ak08+yUlF8mtCCISFheHxxx/HggULsGvXLlRUVFz3jKSbBUtAQACmTJmC+fPnY+HChZg2bRosFgtDxUAMF51ZLBY88cQTyMzMxC9+8QuUlpbCbrcDAEJDQ5Gbm4u/+Zu/waJFi7gMkgjDAWM2mzFr1ixkZGTg3LlzKCkpwenTp3Hp0iX09/e7LVM2mUwICAhAZGQkEhMTkZWVhdmzZ2PKlCkIDg5moHgIhssYcJ0f/tZbb+H8+fOoq6tTxyRPnz4dgYGBbABEVxFCICAgABkZGcjIyMDg4CBsNhs6OjrQ1dUFh8MBi8WC0NBQREVFISoqCsHBwZyg91AMlytomubW09CL68Y/f/48zp8/r+v39iROpxM2m83oatAoSSlRXV1tyK7FN+IKHmD4gD673Y6mpiaDa3V9TqcTPT09RlfDcAyXPzKZTMjIyEBRURGKioqMro7XCgsL47JqL+Z6i/7EiRM4ceKE0dXxWlarFWFhYUZXw1BCGn3eqIeQUsLhcBh+/KovsFgsXAHnpVzbprAdjJ7ZbPbrdsBwISIi3flvrBIR0ZhhuBARke4YLkREpDuGCxER6Y7h4iW4mo3oT++QjPbcFxp7DBcvUVZWhsmTJ6OsrMzoqhAZ5sKFC9iyZYvb8eDkmRguRESkO4YLERHpjuFCRES6Y7gQEZHuGC5ERKQ7hgsREemO4UJERLpjuBARke4YLkREpDuGCxER6Y7hQkREumO4EBGR7hguRESkO4YLERHpjuHiBaSU6OjogKZp6Ojo4Jku5JeklGhvb0dvby/a29vZDjwcw8WD2Ww2vPrqq0hLS8Py5cvR1taG5cuXIy0tDa+++ipsNpvRVSQac1e2g9zcXOzbtw+5ublsBx5OSMa/RyosLMSmTZtgt9sBwO0pTQgBAAgJCUFBQQHy8/MNqSPRWGM78F4MFw9UWFiI9evXQ0oJTdNu+HUmkwlCCOzZs4cNi3wO24F3Y7h4GJvNhsTERPT19d20QbmYTCZYrVY0NDQgKipq7CtINA7YDrwf51w8zLZt22C320fUoABA0zTY7XZs3759jGtGNH7YDrwfey4eREqJtLQ01NbW3tJKGCEEkpOTUVNTo8ahibwV24FvYLh4kNbWVsTFxY3q8zExMTrWiGj8sR34Bg6LeZCenp5Rfb67u1unmhAZh+3ANzBcPEhYWNioPh8eHq5TTYiMw3bgGxguHiQmJgYpKSm3PF4shEBKSgqio6PHqGZE44ftwDcwXDyIEALPPvvsbX32ueee4yQm+QS2A9/ACX0Pw/X9RGwHvoA9Fw8TFRWFgoICCCFgMt38f4/rzeSdO3eyQZFPYTvwfgwXD5Sfn489e/bAarVCCHFNN99VZrVasXfvXqxZs8agmhKNHbYD78Zw8VD5+floaGjA1q1bkZyc7PZnycnJ2Lp1KxobG9mgyKexHXgvzrl4Adc5Ft3d3QgPD0d0dDQnLcnvsB14F4YLERHpjsNiRESkO4YLERHpjuFCRES6Y7gQEZHuGC5ERKQ7hgsREemO4UJERLpjuBARke4YLkREpDuGCxER6Y7hQkREumO4EBGR7hguRESkO4YLERHp7v8BvbEO7v4lPHAAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune(mode='manual', active_neurons_id=[[0,1],[2],[0]]);\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b58417be", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_8_checkpoint_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_8_checkpoint_-checkpoint.ipynb deleted file mode 100644 index 9b1c96a5b..000000000 --- a/docs/.ipynb_checkpoints/API_8_checkpoint_-checkpoint.ipynb +++ /dev/null @@ -1,220 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 8: Checkpoint\n", - "\n", - "### It is fun to play with KANs, just the same it is fun to play computer games. A common frustration in both games is that one did something wrong but cannot restore to the lastest checkpoint. We provide a quick way to save and load your checkpoint, so that you won't be frustrated and think that you need to start all over again." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "save this model to ./model_ckpt/ckpt1\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXiklEQVR4nO2dWYxb15nn/9yLe3GrjdRWpVJt2mxZVjoddxbH8nRnkgGmgRk0phsB+qmBoNNAv8zjvM9TOgMM5rUNTDAP08Eg6bidOMvEiDuxZUu2rCrVvpK1kcV9ves8aM51VblKIlmXvOeyvh8gGJBF8vDw3vs/53zf9/8sqqqqIAiCIAgdsRo9AIIgCKL3IHEhCIIgdIfEhSAIgtAdEheCIAhCd0hcCIIgCN0hcSEIgiB0h8SFIAiC0B0SF4IgCEJ3SFwIgiAI3SFxIQiCIHSHxIUgCILQHRIXgiAIQndIXAiCIAjdIXEhCIIgdIfEhSAIgtAdu9EDIAgzoKoqDg4OUC6X4fP5EIlEYLFYjB4WQXAL7VwI4jnk83n8wz/8A8bHxxGLxXDlyhXEYjGMj4/jH/7hH5DP540eIkFwiYU6URLEyfz85z/Hn//5n6NarQJ4tnthsF2Lx+PBP/3TP+HNN980ZIwEwSskLgRxAj//+c/xrW99C6qqQlGUU/+d1WqFxWLBz372MxIYgjgEiQtBHCOfzyORSKBWqz1XWBhWqxVutxvJZBL9/f2dHyBBmACKuRDEMf7xH/8R1Wq1KWEBAEVRUK1W8dZbb3V4ZARhHmjnQhCHUFUV4+PjWF1dRSu3hsViwejoKJaWliiLjCBA4kIQR8hkMojFYmd6fSQS0XFEBGFO6FiMIA5RLpfP9PpSqaTTSAjC3JC4EMQh3G73mV7v9/t1GglBmBsSF+Lco6oq6vU68vk8LBYLLl++3Nb7XL58GW63G5Ik6TtAgjAhJC7EuURVVTQaDRSLRWQyGZRKJVgsFgSDQXzve99r6z2/973vQZIklMtlFItF1Ov1pjPOCKLXoIA+ca4QRRH1eh2NRgOqqsJut6Ovrw8ulwsWiwWVSgV7e3u4efMmarVaUxljFosFfX19WF1dxdDQECRJgiAIEEVR+wyHwwGn00mZZMS5gcSF6HlkWdYERZZlWK1WTVDs9mferZIkoVQqQVEU+Hw+/N//+3+brtAHgB/96Ef40pe+hEAggP7+flgsFqiqClEUtT8ANJGx2+0kNERPQ+JC9CSKoqDRaKBer0OSJFgsFrhcLvT19cHhcBz5t7VaDZVKBXa7HX6/HzabDUDz3mI//vGPcf/+fRSLReRyOTidTsRiMU242GsFQYAgCJBlGRaL5YjQEESvQeJC9AzsAV6v1yEIAgDA6XSir6/vxCMpRVFQKpUgiiLcbje8Xu8X3jOfz+Ott97CD3/4Q6ysrGh/PzY2hu9///v47ne/i2AwqP29IAhIp9OQZRmRSOTE95RlGaIoQhAEKIoCq9UKp9MJh8OhCRtBmB0SF8L0HI+jOBwOuFwuuFwu7djqOIIgaDUtfr//C7uZ46iqikwmg/39fQwMDCAajZ56rKUoCnK5HMrlMrxeL8Lh8KnjOB6fsdlsmtCc9hqCMAMkLoQpkSRJO/ZSFAU2m0079nre6l9VVVSrVdRqNTidTvh8vqYf4sxDzOPxNPWaSqWCbDYLq9WKaDQKl8v13HEdFhrgWXyG/aH4DGE2SFwI06AoirZDYXEUFph/0c4DeHYcVSqVIEkSvF5vywWTrYoL8EwEM5kMGo0G+vv7jxyhnQZLBBAEQfueFJ8hzAaJC8E1rB6l0WhAEARYLJYjcZRmqdfrqFQqsFqt8Pv9bT2k2xEX9h0KhQIKhQL6+voQjUabjq0oiqIlArD4DBMais8QPEPiQnDJ4cA8i6McrkdpFlVVUS6X0Wg00NfXB6/X2/YRU7viwqjX68hkMlBVFZFIBB6Pp6XXy7KsCQ3FZwjeIXEhuEGSJO3Yi8VRmKC0s0oXRRGlUgmqqsLv97e00zmJs4oLe4+DgwNUq1X4/X6EQqG2xO7wsRkr1GRCQ/EZggdIXAhDkWVZC8yzAkcWmD9LfKFaraJarcLhcMDv9+uystdDXBilUgm5XA52ux2xWKypmNFJnBSfOSw0BGEUJC5E12FxlHq9DlEU246jnIQsyyiXyxBFER6Pp+Wjp+ehp7gAz3Yf6XQakiQhFAqd2VFZURRNaFihptPppPgMYQgkLkTXYIH5RqMB4FmBI6tH0eMop9FooFwuw2KxNFW70ip6iwvwTGhzuRxKpRLcbjei0agu783iM6IoHinUdDqdFJ8hugKJC9FRRFHUdinHjSL1fEBXKhXU63W4XC74fL6OxB06IS6MWq2GTCYDi8WCaDSKvr4+3d6bjDQJIyBxIXSnGaNIvThsOOn1enV9KB+nk+ICPJu3TCaDer2OYDCIYDCo68P/eUaaFJ8h9IbEhdAFZhTZaDS0OMppRpF6cZrhZKfotLgwmAGmy+VCNBrtSOHkSfEZKtQk9ITEhWibVo0i9UJRFJTLZQiCcKrhZKc+txviAjyLH2UyGSiKgnA43NHvSEaaRCcgcSFaph2jSL04bDjp8/nOnF3WCt0UF/Z52WwWlUrlhQaYenGakSbFZ4hWIXEhmqJdo0i9OIvhpF50W1wYrRhg6gUZaRJnhcSFOJWTGm61YhSpF2c1nNQLo8QFaM8AUy/Y8acoimSkSTQNiQtxhONGkQC0Iy8jjkb0MJzUCyPFBTibAaZekJEm0SwkLgQA/Ywi9UJPw0m9MFpcGIcNMKPRqGE7OTLSJJ4Hics5Rm+jSL04bDjp8/m6EmNoBl7EhY1FDwNMvWDZZiw+Q0aaBInLOaNTRpF60QnDSb3gSVwYehlg6sVpjc7YH+L8QOJyDuikUaReKIqCUqnUEcNJveBRXAD9DTD1gsVnRFEkI81zCIlLD3M8jqK3UaRedNpwUi94FRfgqAGmx+NBJBLhaoxkpHn+IHHpMZhRJIuj2O127diLt5u4W4aTesGzuDA6aYCpFycZaVJ8pvcgcekBToqjdMooUi+6aTipF2YQF6DzBph6cTw+A5CRZi9B4mJSTjOKZPUoPNNtw0m9MIu4MAqFAvL5fEcNMPWCjDR7DxIXE2GUUaReHDec9Hg83I/5MGYTF6C7Bph6cZqRJsVnzAWJiwk4bhTZiYZbncZIw0m9MKO4AMYYYOoFGWmaFxIXTmENt4wyitQLHgwn9cKs4sKoVCo4ODiAzWZDLBYzlcCTkab5IHHhiJOMIjvdcKuT8GI4qRdmFxfgqAFmKBRCIBAwekgtQ0aa5oDExWBOiqMYaRSpFzwZTupFL4gLwIcBpl6QkSa/kLgYhCAIWrYXD0aResGj4aRe9Iq4MHgxwNQLSZK0RAAy0jQeEpcuwqtRpF7wajipF70mLsCz75TJZFCr1bgwwNQLMtI0HhKXDqMoiiYokiRxZxSpFzwbTupFL4oLgzcDTL0gI03jIHHpAGYwitQLMxhO6kUviwvArwGmXpCRZnchcdER3hpudRqzGE7qRa+LC8C/AaZenNTojCUC9OL3NQISlzNiJqNIvTCb4aRenAdxYVSrVRwcHHBtgKkXoihqf8hIUz9IXNrAjEaRemFGw0m9OE/iApjHAFMvyEhTX0hcmsTMRpF6YVbDSb04b+LCMJMBpl6cZKTJROY8fH89IHF5DqzAkYkKYC6jSL0wu+GkXpxXcQHMaYCpF9TorD1IXE6gF4wi9YLVrgDmNZzUi/MsLsBRA0yfz4dQKHTu5oGMNJuHxOX/w4wiG43GkTiK2Ywi9aRSqaBWq/V07UornHdxYZjZAFMvTjPSZP5mJDTnXFx6zShSL3rNcFIvSFw+R5IkpNNpCIJgWgNMvWDH59To7CjnTlx61ShSL3rRcFIvSFyOoqoq8vk8isWi6Q0w9eIkI02WCHDe5ubciMtJRpFMVOhB0duGk3pB4nIyvWaAqRfn3Uizp8VFkiTt2KsXjSL1otcNJ/WCxOV0ZFnGwcFBzxlg6sV5NNLsOXE5zSjS5XKd6zjKaRw2nPT5fCS6z4HE5cUwA0yHw4FoNEr33DFOM9LsxfhMT4jLeTKK1IvzZDipFyQuzSEIAjKZDCRJQjgchs/nM3pIXNLrjc5MLS6qqqJUKp0bo0i9EAQBpVLp3BhO6gWJS/McN8CMRqN0Tz6Hk4w0zZ61yuU+rBW9s1gs8Hg86OvrO3LxNvMevXSxtzpnTqdTW1G2+tpeot21Vauv66V5a/a7h0IhuN1uVKvVll7H6KU5A57//Q/X1bFEgBe95jR4mTcudy7Mv6pTqKoKVVV7KqulWq12fCutqmrPGVU2Go2W5o0dXzQLu73MvAI9Tj6f7+hxs6IoUFW15/rJ1Gq1rtyjvCTkcLlzkWW5YzEAURS1B3EviYssyx37PofnrNfEhR1BNEsr/1aWZS0G2EviIooigsFgR967Xq+jWCxq5qi9hKIoHbt/JEnSxIvE5QV0YmunKAqKxSICgQDq9bru7280nZgzVq3v9/s1885eo1PXWr1eR19fn3bE0Ut0as729/cRi8VQLpd1f38e6MS8sf5KXq9XKwzngXMTlVRVFYVCgVKSW4DNmdvtpjlrAVVVUa1Weybrpxuoqord3V2yG2oRVvxst9u5S2U+F+LClJ0VCfIS8OIZVVW14wm3201z1iSqqqJWq8Fut/d0gZyeMBsZRVEQiURozpqElWCwxn28zdu5EBdmod/f38/dD8AjTIwVRYHf76c5axJVVbXjVkqHbx4WZxkaGqI5awHm5M7rgrnnxUWWZS3OQrUJL4athhqNRs+3tdUTZoiqKArt9FpAlmUtzsLbsQ7PsAZ+Ho+H26PXnn7aUsygdSRJQqVSQTAYJDFuEmbpIYoiCUsLqKqKnZ0d+P1+irO0ACse5z1+3LNPDxYzsFqt57Ytb6uwXZ7P56NVZJMcbhpFlfvNo6oq0uk07HY7mVy2wOEA/vHCcd7oyTuBZevIskxHO02iKAoKhQI8Hg/5sbWALMtoNBpwu90kLE3CAviCIGBgYIDuzyZhsVAAplgw99zdwGIGtVqNhKVJ2PEhM/ukOWsOSZK0WhZez715gz0gS6UShoaGSJCbxIwZrz33y4qiiHK5jGAwSDd8EzBhsdvtXKYz8grL1KHeQK3RaDRwcHCAwcFBOnptEjMKC9Bj4iKKIorFIjn9NgmLS1ksFlNdtEYjyzJqtRpcLhfsdjvNW5MIgoC9vT1Eo1FuLEp4h2WFATDdPdoz4iJJEgqFAnw+H8UMmoBlnABAIBAw1UVrJCQs7SGKInZ3dxEKhah3UJMwYbFaraY8VeiJfSkTFq/XS8VrTcCERVVVEpYWIGFpDyYsgUCAinKbQFVVyLKMSqUCh8Nh2vR204sLE5aTeroQX4QdhQG0Y2kWdrOzGAsJS/OwozC/308JNk3AUtsrlYrpGx+aVlzYj8B2LCQsL4a1NgZIWJqFhKU9mBVOOp1Gf38/7ViagLk81Go1eDwe03vTmVJc2I9QKpXg8/lMre7dghVI2u120wUGjYItYBqNhpZuTPP2YtjuuFAoIBKJmKImw2iY4akoivD5fD1xrZlOXNiPUK1WEQgETK/unYY9IJldBN3ozcEWMMzShdKNm0OSJGSzWYiiiKGhIbo/m0BRFFSrVa37Zq/U/phKXJj1gSiK6O/v7wl17ySsoJQ1EqIdXnOwIx1FUcjSpUmYK0Yul0NfXx+Gh4dp3l7A4cB9L9aZmUJc2I9QKpVgtVrR399PF+4LUBQFlUoFoigiEAhQrKAJVFXVdsbkSdcc7N7M5XJoNBpaqjHN2/NhZqfVatX0gfvT4FpcDt/s9XodbrfbtGl53YJdtJVKBTabjYS4SQ7HVxwOB5xOJ11nL4BVjufzeW23QseHL+ZwfMXr9fbswo9bcVEURfMIs9lsmp1LL/4IesHqMJhDby+uhjoBu9YURaHAfZOw2IogCAiHw7ToaxJZllGtVgGgp+IrJ8GtuOTzedhsNvh8PgoKNkmhUIDD4dB6sdCcNQdbwNBxTvPs7OzA7XbTbqVFyuXyuTGI5VJcLBaLVlMAPKvw1ZteXDGw5kGyLEOWZd3fvxfnDADsdjtsNltH5gzovXljXnQulwuNRqMjn9GrppZOpxN2ux2SJHXk/Xm61iyqqqpGD+I43RpSL60caM7ag+atdRRF6fhnWCyWnpoz4Pxda1yKSyuwbBU6J28emrP2URSFq9Uh77AEEzrabg1VVbVrzazzZvq7hKVBdupIoxeRZRn5fJ7mrEVYsVs3Vu69giiK2NnZ6cjRdi/DrJrMfK2ZXlwIgiAI/iBxIQiCIHSHxIUgCILQHRIXgiAIQndIXAiCIAjdIXEhCIIgdIfEhSAIgtAdEheCIAhCd0hcCIIgCN0hcSEIgiB0h8SFIAiC0B0SF4IgCEJ3SFwIgiAI3SFxIQiCIHSHxIUgCILQHRIXgiAIQndIXAiCIAjdIXEhCIIgdIfEhSAIgtAdEheCIAhCd0hcCIIgCN0hcSEIgiB0h8SFIAiC0B0SF4IgCEJ3SFwIgiAI3SFxIQiCIHSHxIUgCILQHRIXgiAIQndIXAiCIAjdIXEhCIIgdIfEhSAIgtAdEheCIAhCd0hcCIIgCN0hcSEIgiB0h8SFIAiC0B0SF4IgCEJ3SFwIgiAI3SFxIQiCIHSHxIUgCILQHRIXgiAIQndIXAiCIAjdIXEhCIIgdIfEhSAIgtAdEheCIAhCd0hcCIIgCN0hcSEIgiB0h8SFIAiC0B1Ti4uqqshkMtjc3EQmk4GqqkYPiXtoztqDzdvGxgbNW5OwOdva2qI5a4GeuUdVE5LL5dQf/OAH6tjYmApA+zM2Nqb+4Ac/UHO5nNFD5A6as/ageWsdmrP26LV5M524vPPOO6rX61UtFotqsViO/Ajs77xer/rOO+8YPVRuoDlrD5q31qE5a49enDdTics777yj2mw21Wq1Hpn843+sVqtqs9lM9UN0Cpqz9qB5ax2as/bo1XmzqKo5DvTy+TwSiQRqtRoURXnhv7darXC73Ugmk+jv7+/8ADmE5qw9aN5ah+asPXp53kwT0P/Hf/xHVKvVpn4AAFAUBdVqFW+99VaHR8YvNGftQfPWOjRn7dHL82aKnYuqqhgfH8fq6mpLmRMWiwWjo6NYWlqCxWLp4Aj5g+asPWjeWofmrD16fd5MIS6ZTAaxWOxMr49EIjqOiH9oztqD5q11aM7ao9fnzRTHYuVy+UyvL5VKOo3EPNCctQfNW+vQnLVHr8+bKcTF5/MZ+nozctbv7Pf7dRqJuaB5ax2as9aRJAmiKJ7pPXifN1OISyQSwdjYWFvni/F4HJubm1hfX0ehUDBvtWuLnHXOBEFoOsjYS0QiEYyOjrb12rGxMYTDYZ1HxDfVahW5XA4jIyMtv9ZisZyrORNFEQcHB1hbW8PCwgIEQcDFixdbfh+zzJspxMViseBv//Zv23rd3/3d3yEWi6FYLGJxcRGPHj3C6uoqcrlcTz88250zAPiLv/gLzM7O4ne/+x1WVlZQr9d1Hh2fyLKM/f19/MVf/EVbr/+bv/kbrgOseqGqKtLpND799FN88MEH2Nvbw1//9V+39V7f//73e3rOGo0G0uk0VlZWsLi4iL29PdhsNsTjcUxOTuLv//7v2/r+Zpg3UwT0AX3ywdkqK5fLoVarwWq1IhgMIhQKob+/HzabrcPforvk83nE43HUarWmdmyH58zhcCCZTGJnZweyLCMajSKRSCAcDnN/UbeKqqrI5/PIZrOwWCyw2WyYnp5GvV5v6lqzWCxwu934/e9/j4GBAYTDYTidzi6MvLsIgoDt7W1sb2+j0WggGAwiHo9ri7dW7k82Z6lUivt6jVap1+soFosoFotoNBqwWq3w+XwIBALw+/2wWj9f0/dynYtpxAUAfv7zn+Nb3/oWFEV57sPSarXCYrHg7bffxv3790/8N/V6XROaSqUCi8WCQCCAUCiEUCgEu93eqa/RNer1Ov75n/8Z//E//kcAeO7Fe9qcybKM3d1dJJNJlEoluN1uJBIJjIyMwOFwdPw7dJpKpYJ0Og1RFNHf349wOAybzaZda6qqNj1vr732GrLZLERRhN/v75kFSz6fRyqVQjqdhtVqxeDgIOLx+BdiLc3OmcVigcViwX/9r/8V3/ve99DX19fpr9BxqtWqJiiiKMJms8Hv9yMQCMDr9R4RlOO0c62d9lzjCVOJC/Dsh/j3//7fo1qtfuH/sRW1x+PBj3/846Z/AEEQNKFhGRh+v18TGjOuQmu1Gur1Ovr6+vDee+/hz//8z7U5O/yTtzJnhUIByWQSe3t7AIDBwUEkEgkEg8EOfpPOIAgC0uk0qtUqPB4PYrHYF37nn//85y3Pm6qqKJVKyOfzAID+/n74/X7T7fYkScLu7i5SqZQ2R/F4HENDQ89deDU7Zz/60Y+06+bVV1+F2+3u4LfRH1VVjwiKJEmw2+3a7sTr9bb0mz9v3oBnc9fqc81oTCcuAPDb3/4WP/rRj/DLX/4Sq6ur2t+PjY3h+9//Pr773e+2/cATRRH5fB65XA7FYhGqqsLr9SIUCiEcDsPlcun1NToGExa3262tCvP5PN566y388Ic/xMrKivZv25kzURSxvb2NZDKJWq0Gv9+PRCKBoaEh7lfqsiwjm80in8/D4XAgFovB6/We+u/bnTdZlpHP51EqleBwOBAOh03xAC2Xy0ilUtjb24OiKIjFYojH4y0dwTQ7Z/V6HR9++CEURcHdu3ef+zvwgKqqKJfLKBaLKJVKkGUZDocDgUAAgUAAbrf7TIuI0+YtkUjg7//+7/HXf/3XplrImU5cVFXFT3/6U1y+fBk3btxANptFqVSC3+/XPR7AHhC5XA6FQgGKosDtdms7Go/Ho9tn6UW1WkWj0YDH4zlRCFVV1W3O2Hslk0mk02nY7XYMDw8jkUhw96BQVRXFYhEHBwdQVRXhcBj9/f1Nf/d2500QBGSzWdTrdXg8HoRCIe6OExVFQTqdRiqVQqFQgMvlwsjICEZGRs60a29mzhqNBh48eABBEPDqq69yVzagKApKpZL2R1EUuFwuTVA6caR3eN5YfOXChQsYGBjQ/bM6ienEZW9vD++99x6++c1vIhQKde1zFUVBoVBALpdDPp+HLMtwuVwIh8MIhUJcPExfJCydpFarIZVKYXt7G4IgIBwOI5FIIBaLGX4kVK1WkU6nIQgCAoEAotFo13dYlUoFuVwOsiwjEAggGAw+9xy+G9RqNWxvb2NnZweiKCIcDmNkZATRaLSrv5kgCHjw4AHq9Tru3r2LQCDQtc8+CVmWUSqVUCwWUS6Xoaoq+vr6NEHp9r21vLwMWZYxMTHR1c89K6YTlwcPHiCTyeBP//RPDRsDWwWzOI0kSXA6ndqOxufzdf2BWqlUIAgCvF6voTEiRVGwv7+PZDKJfD4Pl8uFeDyOeDze9ZtSFEVkMhmUy2X09fUhFosZGjxWVRWFQgGFQgFWq1W7Vro9hmw2i1QqhYODA223OTIyYuhOXBRFfPTRR6hWq7hz507XM6EkSdLiJ9VqFaqqwuPxaIJi5G4zm81ibW0NN27cMFX811TioigKfvKTn2B8fBwzMzNGDwfA5+ewTGgEQYDdbteEJhAIdFxoeBGW45TLZS2dmZ3fs3TmTqIoivZ72Gw2RKNRrqqZJUnSshSdTifC4XDHRU8QBOzs7GB7exv1eh1+vx/xeBwDAwPcxMkkScLHH3+MYrGIO3fudPw6EQRB26FUq1VYLBZ4vV4ty4uXjFFFUfDpp59ieHgYQ0NDRg+naUwlLqlUCv/6r/+KN9980/Ct82mw449sNotGowGbzYb+/n6EQiHdj0JUVUWlUoEoivD5fNyd5TNY5tHW1hYqlQo8Hg8SiQSGh4d1HzOLq8iyrAm80cdPp9FoNLTrhCWN6P1AKxQKSKVS2N/fh8ViweDgIEZGRri9f2RZxsOHD5HP5/Hyyy/rbszYaDS0HUq9XofFYjlSg8KL0B5ndXUVjUYDU1NTRg+laUwlLn/4wx9QKpXwxhtvGD2UpqjVatoKulqt6lq0yYRFkiR4vV5uheU4+XweW1tb2sNuaGgIiUTizA+7er2OdDqNer0On8+HWCzGzcrzRbCdr6IoCAaDCAaDZ9rtstqkVCqFSqUCt9utpRGb4TqRZRmffPIJDg4O8NJLL53JORh4dh+yDC9W1Mh2Jz6fj9vFx2Hy+TxWVlYwMzNjmrog04iLJEn4yU9+gunpaUxOTho9nJZpNBrajuZ40WZ/f39LNz07ipNlGT6fzzQP0cMIgoBUKoVUKoV6vY5AIIALFy5gcHCwpZtdkiRkMhmUSiW4XC7EYjFTpPwehyWMFItF2Gy2tpJEKpUKUqkUdnd3oSgKIpEI4vE4QqGQ4UkVrcKOgvb393H79m0MDg42/VpVVTVBOamo0YiY6FlRFAWPHz/GwMBAWz5uRmAacdnc3MQHH3yAP/uzP+MiM+ssCIJwpJYGaL5osxeE5TCqqiKTySCZTOLg4AAOhwMjIyOIx+PPDTCrqqrtCi0WCyKRiKlqAE5DFEVtp9vX1/dCKxlFUZDJZJBKpZDP5+F0OrU0YjPUZD0PVVXx+PFj7O7u4saNG899qLKdPNuhHC5qDAQC8Hg8phOU46yvr6NSqXATb34RphGX999/H41GA9/4xjeMHoqusODuSUWboVDoyBaYVX8risL1+XC7VKtVLZ1ZFEVEIhEkEokvpMaWy2VkMhlIkqRZtpjhaKMVarXac61k6vW6lkYsCAL6+/sRj8cRjUZ7ai5UVcWTJ0+QSqVw/fp1JBIJ7f8pinJEUGRZhtPp1OInPNahnYVisYilpSVMTU2Z4ruZQlwEQcBPf/pT3Lx5E+Pj40YPp2PIsoxCoYBsNvuFos1gMAhFUXpWWA6jKAr29vaQTCZRKBTQ19enPThZZo/X60U0GuUqO05vjlvJBINBSJKE7e1tHBwcwGazYWhoCCMjI6bfzT8PVVXx9OlTbG5uYnJyEqFQSKtB6UZRIy+wnRxbdPGOKcRlbW0NH3/8Mf7tv/23PX3xHOZw0Sar1nU6ndpDlrdK5k5RKpWwsbGBhYUFlMtlDA0NYWZmxhQ3l140Gg0sLCxgZWUFoihieHgYY2NjGBwc7OlFBkOWZRSLRTx8+BDLy8u4fPkyxsfHtR2K2Y//WmFzcxOFQgE3btwweigvxBQH9pubm4YXwHUbVmQXDAYRDoc1c7x8Po90Og2Hw6EdnZnRGLEZVFWFLMtwu924fv06BEFAsVjE/Pw8tra2tHRms8edTqNYLGppxABw5coVeDweOJ1O2Gw2KIrSs+IiiqJWg1KpVAAAo6Oj8Pv92N/fh6IoiEajBo+y+4TDYaTTaZTLZe4XmNzflSzF9M6dO0YPpevIsoxyuQyLxYJEIgGr1fqFos39/X3Y7XatliYQCPTEmfthy5ZgMIhIJKI9SJmf2eLiIpaXlzU/M95vtmZgDctSqRRKpRL6+vpw5cqVIzVB1WoV2WwW29vbWjymF35ztngoFouo1WpaUePIyAj8fj/sdjuuXLmC1dVVLC4uQlEUXLt2zehhdxVWz5bNZrm/3rk/FlteXsann36Kb3/72z19vn6cw8LyvFx8VrSZy+VQr9dhs9mO1NKY7aEjiiLS6bRWnxGLxU499mg0Glo6c6PRQH9/PxKJBAYGBkz3vVkyw+7uLiRJ0tKITzPIZBZE+XweVqtVs/Y3G+0WNa6vr2N+fh6XLl0yVWGhHrDMyps3b3J9YsG9uPz617+G0+nEV77yFaOH0jWYcR4r9mr2AjpetGmxWI4IDc/HR4qiaFb4NpsNsVis6ZUZa7ubTCaRzWa1dNx4PM51zQtLw06lUsjlcloa9sjISNNHwLIsI5fLoVwud81K5qwcrkERBKHtosatrS3Mzs7iwoULmJ6e5vpBqyfVahVPnz7V4k68wrW4VCoVvP3227h37x4uXrxo9HC6giRJKJfLsNlsZyr2YkWb7MFjsViO1NLwVKldLBaRyWSgKIrmMt3u92aFhNvb25AkSWvPHIlEuHn4NBoNzefreLvgdndc3bCSaRfWWIvFUFhRI8vwarWx1mFSqRSePHmCkZERXL9+nZvfuNM8efIEfr8fly5dMnoop8K1uMzPz2Nubg7f+c53uLlROolewnIcVpjHOm2qqgqfz6f1NDEq26ZWqyGdTqPRaMDv9yMajer2O/PYnjmXyyGVSiGTyTy3XfBZqFQqyGazulnJtMtJRY0Oh0PboehZ1Lizs4PHjx9jcHAQt27dOhcCs729jf39fa6/L9fi8u6778Lv9+NLX/qS0UPpOKIoolKp6C4sx2EZZ6wBGrMWZzuGbhypdNuyxcj2zMfbBXu9XsTjcQwODnZswXTYSsZqtSIcDnelDkZRFK1TI3ORYEWNrFNjp9jb28Mnn3yCWCyG27dvmy7m1ir1eh2zs7MYGxvrenuCZuFWXEqlEt555x18+ctfRjweN3o4HUUURZTLZTgcjjMdEbQKK9pkDdA63WmTWbZks1lYrVZEo9Gunhl3sz1zqVTS0ojbbRd8ViRJQjabRbVa1Rrb6b1LZYknh4sa+/r6tB1KN+M/mUwGDx8+RDgcxksvvdSzadqMubk5uN1uXLlyxeihnAi34jI7O4ulpSV8+9vf7umL5LCwGJlaqCiK1gAtn89DkiS4XK4jDdDOQrlcRjqdhizLhlu2HG7PnMlkYLPZdGnPzBqlpVIpFItF3doFn5V6vY5sNgtBEODz+RAKhc50T0mSdKQGRVVVuN1ubYdi5Hc9ODjAw4cPEQwGcefOnZ5+duzu7mJnZwe3bt3icqfGrbi88847iEQiuHv3rtFD6RiCIGgNo3iy72C2IyxOI4pi20WbjUYD6XQatVoNXq8XsViMq2SCer2upTMLgoBQKKSlM7eSpXe8XXA8HucqieBwfRTwzEqmlUZ2oihq8RNW1Oj1erWUYZ5+01wuh48//hg+nw+vvPJKz8ZrG40Gnjx5gitXrnS8sVo7cCkuuVwOv/zlL/Haa6+ZqvNaKzQaDVSrVe6E5TgsMJvNZo902nxR0aYsyzg4OEChUIDT6UQsFuPabE9RFKTTaWxtbWnuwvF4HIlE4sSjJFVVcXBwgFQqhWw2q7UL5j39WVEU5PN5lEol2Gw2hMPhU3+X04oamaDw/NAuFAr46KOP4Ha7cffuXa7ET0/m5+fhcDgwNjZm9FC+AJfi8vjxY6yvr+Pb3/42Nys/PWHC4nK5uH7gnkS1WtV2NLVaTSvgO9xpM5/PI5vNAoBmhW+m3/G09syhUAiiKB5pFxwIBLR2wTweTZyGKIrIZrOo1WpHrP3r9bomKKyxFitq9Pl8pjpmKpVKePDgAVwuF+7evduTRdj7+/tIJpO4desWd78Nd+KiqirefvttDA8P4+WXXzZ6OLpTr9e1G5rnFW4zHC/arNfrmhcYa/zF2wXfCrIsY2dnB8lkEru7u1psLBqNIh6PIx6Pm7Iq/jC1Wk0r4gSAvr4+LWXY7/ebplPjaZTLZTx48AB2ux13797lvsC0VURRxOPHj3Hp0iXuvNa4u2oODg5QrVZ7smiyl4QFANxuN0ZGRjA+Pq7VqKiqqtnCLy8vY39/H6IoGj3UtlBVFRaLBVarFTabDRaLRWt7oCgKOFuXNQ076tzZ2cHW1hbq9bomIHa7XUtC6AWfOp/Ph3v37kGWZXz44Yeo1WpGD0lX2EKALQ54grudy6NHj5BKpfCtb33LVEcpL6JWq6Fer8PtdvfM6klRFC2uYrfbtVYApxVtsoQA3i3Sj7cLZjuV/v7+I+nM7FgskUhwv0s7XNRYLBYhyzIcDseRxlqKomiODg6HA+FwuCcWQcCz++/BgwdQFAWvvvqq6Y6jn0cmk8HGxgZu3rzJVWyJK3FRVRU//elPcenSJdy6dcvo4ehGtVpFo9HoKWEpFAo4ODiAqqqaaJy0GDitaJO9hpeHFwvop1IpLQnhee2CWUB/a2tLa8/M0pl5eXAdLmpkHUybKWoUBAHZbBb1el0rsOU5eN8s9XodDx48gCRJuHv3Lveuws0iSRIeP36sZTnyAlfisre3h/feew/f/OY3EQqFjB6OLjBh8Xg83K/Ym+GwZUsgEEAkEmn6wcMylQ4Xbfb19WlCY0TW3PF2waFQSGvI1koqcjKZ1Nozh8NhXLhwoaX30AtmesqKGlVVRV9fnyYorVyDzHFblmUEAgEtYcPMCIKABw8eoNFo4O7du6aPmTGWl5chyzImJiaMHooGV+Ly4MEDZDIZ/Omf/qnRQ9GFSqUCQRDg9XpNn6kiiiIymQzK5TL6+vrO3LztpKJNp9N5pGizUw9m5hSQSqWOtAuOx+Nn2nUcb8/scrk0P7NOLiw6WdSoqioKhQIKhYLWwM7sK35RFPHgwQPUajW88sorXbEB6jTZbBZra2u4ceMGN88absRFURT85Cc/wfj4OGZmZowezpnpFWFh5/C5XA42mw3RaFT31d5pRZuHa2n0EJrDacS1Wg0+n0/z+eqE/QvLMlMUBQMDA1o6sx6wosZisYhqtQqgs0WNkiQhl8uhUql0zEqmm0iShI8++gjlchl37twx/UmJLMt4/PgxRkZGMDg4aPRwAHAkLtvb23j//ffx5ptvct2joBnK5TJEUdS6xpmVUqmETCYDWZa1HUU3jkUOd9psNBqw2WxfqKVphePtggcGBhCPx7tynUmSpKUzVyoVeL3ettszNxoNbYfCihp9Pp/m49WNhAK9rWSMRJZlfPzxxygUCnj55ZcRiUSMHtKZWF1dRaPR4KZ5Gjfi8oc//AHFYhH37983eihtwzJyJEmC1+s1rbCw1tL1eh0+nw/RaNSw73JS0WYwGEQ4HEYwGDz1wcbaBSeTSe0oLx6PH2kX3G1yuRy2traQTqdhtVoxNDSERCLx3J3g84oa/X6/YTEQtgAw2tr/rMiyjEePHiGbzeKll15CLBYzekhtk8/nsbKygpmZGS4Sh7gQF0mS8JOf/ATT09OYnJw0ejhtwbybZFmGz+czZXaNLMvIZDKa6WI0GuUm8wl49qBlQlOpVGCxWBAIBLS+NHa7/QvtgqPRKEZGRk5tF2wEx9szB4NBXLhwQavyr1arWoaXIAiw2Wza7sTr9XITVD9s7W+z2QxLyjgriqLgk08+QTqdxu3bt7k5VmoVRVG0vjbDw8NGD4cPcdnc3MQHH3yAP/uzPzPlxWl2YVFVVbNssVgsiEQiusU5OoUgCJrQsF7y1WoViqIgFArh0qVLLbULNgLWnnlra0vLVvP5fIhEIkeOu7rZhqEdWF1TtVo9YiVjJlRVxaeffoq9vT3cvHmTi4dzO6yvr6NSqXARt+ZiCbS1tdW1hkZ6w4LRZhWWSqWCjY0NZDIZBAIBXLp0yRRHHE6nU+uiWavVtCwpr9cLj8eDRqOBfD6PRqNh9FBPhC1IRFGE1+vF0NAQvF4vyuUydnZ2jpia8v5bOBwODAwMYHBwELIsY3t7GwcHB5Bl2eihNY3FYsGtW7cwMjKCTz/9FKlUyughtUUoFEK9XteSPIzE8J2LIAj46U9/ips3b2J8fNzIobQMExZFUeD3+00V2BQEAel0GtVqFR6PB7FYzDSrzePtglkasdfrhSRJWgO0QqEARVG4KdpUFAWlUkn7c1JRoyzLWjpzsViE2+1GPB43vCdMs7B7Ip/PAwD6+/tbatFgNKqqYm5uDltbW5ienjadDZWqqnj8+LHmKmEkhovL2toaPvroI3z729/m+gjjOKz6mVmbmEVYZFlGNptFPp+Hw+FALBYzxY6RZV1tb2833S6YxQRYLY0sy10v2jxLUWOxWNTSmYFnWW4XLlwwRV2GLMuatb8ZrWSePn2KjY0NTE5O4vLly0YPpyU2NzdRKBRw48YNQ8dhuLi89957UFUVX/3qV40cRkuwFSgAQzN2WoEVw2WzWaiqqgXBeV9RsnbBe3t7UFW17XbBqqpqRZu5XK6jRZuSJB2pQWGWNyzDq9UdCKvPSSaTqFar8Pl8uHDhQkfaM+vNYSsZt9uNcDhsmizKxcVFrK6uYnx8nMt+KadRKpWwuLiIiYkJQwteDRWXer2Of/7nf8bLL7+M0dFRo4bREmYUlmq1inQ6DUEQEAgEEI1GuX4ondQumKUR63E0xOIdbAfHGqAxoWknmeF4UaPFYtEEJRAI6BKLO96e2Wq1YmRk5MztmbtBtVpFNpuFLMvw+/3o7+83xb2zsrKCpaUljI2NmerY/vHjxwiFQrhw4YJhYzBUXJaXl/HJJ5/gO9/5jinOk2VZRrlc1orXeL859LZs6TSst8ju7m5X2wUzD61sNttS0Waj0dAEpV6va9cF26F0UsBPa88ci8W4vS7Z7jGfz2tN5szg7bW2toaFhQVcvnzZNKUSyWQS2WwWN27cMOx0wlBx+c1vfgOHw4GvfOUrRg2hadjZOSti4/UGBp6t/NmqvFOWLXpxvF0wcxceGRkx5Iz+tKLNUCikWe4fL2pkjbWM2MkyN+dkMolcLqe1Z47H49wuJGRZ1qz9nU4nwuEwt2NlbG5uYm5uDhcvXsTU1BT3x8mVSgXz8/O4du2aYfe+YeJSrVbxs5/9DK+++iouXbpkxBCaRpIklMtl7UHC84VVLBaRyWS0eo9uWba0iiAI2NnZ0QoJeWwXzIo2t7e3kU6nUalUtISAkZERRCIRrooaK5WK5s7M+tAkEgmuCkgP02g0tN2i1+tFKBTiOpU/mUziyZMniMfjuH79OpdzepgnT57A7/cb9nw1TFwWFhYwOzuL73znO1xfUExYbDZbR516z8phyxa/3691huSNfD6PVCqFdDoNi8WCwcFB7toFMxsfluUlSZLWeVKSJEiSBIvFAr/frwk4T8e6sixjd3cXW1tbKJfL8Hg8Wjozj8F0M1nJ7Ozs4PHjxxgaGsLNmze5HSfwzK9xf38ft27dMmSchonLu+++C5/Phz/6oz8y4uObwgzCIkkSMpkMSqUSXC4XYrEYdymfkiRhb28PqVQKlUpFe9gNDQ1xI4CKomidGllRLOvUGAgEjtjgiKKo9aUpFota8SYTGp6OeAqFAra2tjTTTuZnxps5rJmsZPb29vDJJ59gYGAAt27d4mbnepxarYa5uTlcvXrVkPR1Q8SlVCrhnXfewZe//GXDC31OQxRFVCoV2O12LqukWU+SbDYLq9WKSCTCXf1DuVzG9vb2F9oF82JvzjL/WA2KoihwuVyaoDQjEqye43DRptvt1oSGF282QRCwvb2NVCqFWq3GbXtmSZKQzWZRrVbhcrkQiUS42hUy0uk0Hj16hEgkgtu3b3M1h4eZm5uD2+3GlStXuv7ZhojL3NwcFhYW8J3vfIfLH0UURa2POI+NkcrlMjKZDCRJQn9/P8LhMDerp+Ptgl0uF0ZGRjA8PMxF/4+Tihrdbrfm43WWMZ5UtOlyuY7U0hgNS6Bg6cx2u11LZ+ZFCIFnq+5sNqu1ruDR2v/g4AAPHz5Ef38/Xn75Ze7GBwC7u7vY2dkxZIdliLi88847CIfDePXVV7v90S9EEARUKhXN14knGo0G0uk0arUavF4votEoN6s61i6Ytfptp11wp3heUWMgEOhIHOK0ok2W4sxDYghL/U6lUlrqN0tnNnpswOf1SLlcDgAQDAa5M1TN5XL4+OOP4ff7cefOHW6OeRmNRgNPnjzB6Oho108Mui4u+Xwe7777Ll577TUMDQ1186NfCM/Csr+/j0KhAKfTiWg0ys34BEHA/Pw8Dg4OYLfbdWkXrBfVahV7e3taUePhTo3dfAgcfkjmcjmtaDMcDnORKcmKVre2trTd5ujoKDdH1oqiIJ/Po1gswuFwIBqNcrELZuTzeXz88cfweDx45ZVXuEuamJ+fh8Ph6LrLgC7iMjc31/R5P+sKODk52fQKRJZlSJLUVhV/rVZrersqiiIkSWo5IK6qalsXezabbXrncXBwAIfD0dKKV1VVLQOnVdbX15sSMFVVsbq6qq3Im916K4oCWZYxMjLS0rj29/ebDpizVFefzwePx9PUdaCqKmRZRjgcbmlcwLPsnGaunVqtpiUNtGLtrigKFEVpq6HV6upqU8dytVoN6XQaXq+3pc6M7PdsR5CYz92LEEURhUJB693TLKqqQlXVljMSl5eXm35NtVpFMpnE2NhY088bWZYhy3JbVfTNXmsANHfwVvrUsPvgLM3TdFm+FYvFpitXh4eHMTEx0dJ7s1VBO+LCzAqbodUVhyzLqFarsFqtbYkLq6xuhlZ3KoIgYH9/H3a7vS1xqVQqTTvCRqPRlt67Wq1iYWFBi8e0QqPRaPqCZynZrbz39va2ZrTYKrVarandeDAYbHnX3mg0sL6+rpmNtkqlUmnagLHVh121WsXTp081m55WEQSh6Wu01WtZEARtV92quJTL5ZaeOa3sQsvlMmZnZ9HX19eWuNTr9aYXJq368NXrdayvr8PpdBovLgA6EixSVRW/+93vMD4+jmw22/b7dOKMlh119PX1QZKktt+nU2Pb3t5GKBRCrVZr+3069Zs+fvwYiUQCxWKxrffo1JxtbGwgHA6jXq+3/T6dmrPFxUUMDAygUqm0/T6dGtsnn3xypt8T6Nxvur+/j0Ag0HZfn07N2ccff4zLly9rrQnaoVNztry8jGg0euaeMHykGJ3C7u4uBEHAtWvXjB7KFxAEoe3jsE7Dai94S00GoGW5GWmodxLVahWyLLe8C+sGlUoFkiRxF6MEoBl/8hA7Ok6lUoGiKNzV9KTTaYiiyKWVf71ehyAIulxr3IqLqqr4wx/+gC996UtcZYcAz8bGrM95GxtLBR4ZGeFybHNzc9xZZ6iqis3NTS7nTFVVLC0t4eLFi1yO7dNPP8X09DSXY8tkMhgcHORqbGyn99JLL3E1LuDzay2RSOgyNm7F5enTp3A6nVz2sq5Wq7DZbNylHaqqip2dHXg8Hi53VMvLy1qBIU+w4xwed3r5fB6qqnK5o0omk7BarS0FirsBExan08ndfbC0tASXy8Xl78l2yAMDA7q8H5fiIooi5ubm8NWvfpU7dVcUBYIgcLlrqdVqWlCZt7GxOhijfI5OQ1VVpFIpXLhwgatxAZ9n4o2NjXE3NlmWsbi4yOUKXJIkVCoV7nYtoihidXUVd+/e5WpcwOexFj13yNyJi6qqeP/997We6DzB+oO7XC5uKuIZbNcyODjI5dg+/fRTJBIJ7laSmUwGNpuNu2sNAFKplOZvxhOqqmJ2dhb9/f1cuA4cRlVV7O7uIhgMclUxz4L4Q0ND3Hn/AdA61LaSfv4i+HoK4Vmw6+DgAK+++ip36t5oNDS7EJ5gWTG82tXs7OxAFEXuWsWy4sHLly9zd61JkoTd3V1MTExwN7ZKpYJ0Os3dLhSAZunTavptp8lmsygUClw6KbNMyatXr+o6Nq7ERVEUvP/++3j11Ve5WnUAz8ZWq9W4PA4TBAGlUgnxeJy7sYmiiMXFRe5uKlVVsbW1Ba/Xy42FDkNVVSwsLCASiXC301NVFQ8fPsT4+Dh3MUdFUXBwcMDdcZiiKHj48CFu3rzJ5anC+vo63G637gtTbr6pqqr48MMPNbdWnjh8HMab6LGYQSQS4XJsjx8/xsDAAFf9WoBnMaByucxlFlYmk+EyvZdlE9ntdu5Sydnu3e12c7VYYEeIHo+Hy1TySqWCbDaL8fFx3e8DbsSF9fv4kz/5E65udpZ2DABut5ursQHPbGFYP3Le2NnZQbVabcnqpxuw1drw8DB3K8l6vY6NjQ1cu3aNu7GVy2VsbW3h5Zdf5ur3BJ7NW71e58Z0k1EoFJBKpbgM4kuShKWlJVy6dKkju1Aurl5BEPD73/8e9+7d4870TRAECILAhYvtcVjTKh6PwxqNBhYXF7lrpsR2ek6nk7uUaFmWsbCwgOHhYS6MPw8jyzIePnyIa9eucdUMDfg8dhaLxbi61mRZxkcffYSZmRmudlPA564PwWBQ1yD+YQz/JVRVxXvvvYeRkRFuXFgZzDvM5/NxddECz+YtmUwiHA5zJ8iKouDRo0fctS8GoFnv8xbEZ0dOfX193BVzsmw/v9/P5ZH1/v4+XC4XV4KsqioePXrE7TH/2toaAODKlSsdu9YMfWKyi1YQBO62jSzO4na7uQtcqqqKdDoNq9XK3eqbBaNtNpvu2SdnpV6vI5lM4uLFi1zFp9gxnSiKHTn7Pgus1qZSqXCXHcZ65giCgIGBAW7Gxn7PQqGAO3fucDMu4PNFablcxrVr1zo6NsPEhVlurK2t4etf/zpXOwMmLHa7HS6Xi6uLA3gWhOMxO4xduJlMBrdv3+ZqbKIoYn19HQMDA1zVtDCT0UKhgMnJSe7ug93dXWxubuKVV17hTpCr1SpyuRyGhoa4mTfmDrC4uMhd1ivb5R0cHGBycrLji2bDfpFMJoOPPvoIX/nKV7iqG1FVFbVaDYqiwOv1cvWABJ7FMnZ3dzE0NMTVjkpVVezt7WFtbQ0vvfQSV0d1rDI6EAhw0RmTweZsb28Pk5OTXM0Za4f89OlT3L59m7t7tFqtIpPJYGBggKt4RqFQwKNHj3Dr1i2ujoRVVUU+n0cqlcK1a9e6MmeGPJ1yuRx+97vf4c6dO1x57KiqClEU0Wg0uGunCjxLLmBpx7ydL+/v72NxcRHXr1/nppBTVVU0Gg1sbGzA7/djeHiYm9+UrXC3t7cxMTHBVZBcVVVks1l89tlnmJmZ4SoTUVVVFAoFFAoFxGIxbkSPPbw/+ugjTExMcOe3VqlUsLa2hrGxsa49O7oqLuwH+O1vf4vp6WlcunSJq5udeRL5fD7utrOskVUwGER/fz9X87azs4Pl5WXMzMxwEwNi5/Hb29uIRCJcpaiymFkymcT4+Dh3x3TpdBqzs7OYmpriKpahKIpWAzQ0NASn08nF2Njx4ZMnT3Dt2jXuaqdqtRqWlpZw4cKFrloJdU1c2Or297//PaampjoeTGoFtmOpVCrweDzcHTcVi0UcHBwgFApxJyxbW1vY2NjAjRs3uBgba8+6t7eHUqmEkZERrnah7EG0s7OD8fFxbnZ5wOdp2ktLS5iZmeFKkCVJwt7eHmw2G4aHh7lZ/EmShJWVFWxtbeHGjRvcuQPUajUsLCxgaGio60fCXXmKKoqClZUVzM7O4tatW1ykgbK+2rIso9FoQJIkeL1eOBwOw8fGxsd6wAuCgMHBQXg8Hi7GBjwb38rKCvb29nD79m0ubHEURUGpVMLe3h6cTieuXLnCzeoWeDa+ra0t5HI5TExMcLVjURQFq6urSKVSuH37NhcLBeDzhd/e3h48Hg/C4TA348pms1hYWAAA3Lt3j4t7gME65a6srGBgYMAQp/SOigv7gp999hlyuRy+/OUvG74aYoIiCAJEUQQAOBwO+P1+WK1Wwy8OVVVRr9dRKBQ0L7OBgQHYbDbDx8aQJAkLCwsolUp46aWXDI//sABvOp2GIAiIxWLcPByBz3/T9fV1qKqKqakpbjzD2CJmfn4etVoNr7zyCjeix+YtnU4jEAggGAwa/puyTNLV1VVks1lcvHgRly9f5uq0gzUM3N7eRjweN+yZq/uMsB1BuVzG+vo6Njc3MTg4iNdff93QoKWqqlAUBfV6HaIowuFwwOPxaA9towWPZakVCgU0Gg14vV6MjIxws/JWVRXAsyLExcVF2O12vPzyy4Zl6hyes4ODA9RqNfT39yORSHAhxGy+BEFAOp1GJpNBOBxGPB7n4kiHxRj39vawvr6OYDCIV155hYuMNfbbFotFFAoFhMNhQ3cFbDyFQgGbm5vIZrOIxWK4d+8eN6cJ7PlWLpexu7uruZAb6Syim7jkcjnUajXk83lkMhmUSiWEQiHcu3fP8PRPSZI0GxeedinAs8K+Wq2GcrkMRVHg8/kQi8Vgt9sNH1+pVIKiKJBlGbVaDdlsFqVSCcPDw4YWItZqNVSrVa2ALhAIYGhoiIsjzWq1ClEUtd+0UqnA7XZjbGzM8GOTUqkEURRRr9dRLBaRy+VgtVoxPj5ueOC+0WgAgHaqUKlUAACDg4OG1poVCgXk83ns7e2hWq0iFovhlVdeMfy3BJ5da+zZVq1WUS6XIcsyIpEIBgYGDN9N6fbpH3zwAex2O/x+P0ZGRjAwMHDkB2ArOSOoVCqw2WxfyAIzckyM3d1dOJ1OBINBeL3eI8VgRo9vbm4OFosFVqsVDocDwWAQY2NjWvqnUePb2tqC0+lEIBCA3+8/sto2es5WVlZgtVrhdDrh8/kwPDx8xPDUyPF99tlnsNlsWt+f8fFx9Pf3a/eEkWNLp9PaCYLdbkcwGDyyKzBqbJ988gk8Hg8GBgYwMDBwJPXZ6GttdXUVVqsVdrsdfX19GBoagt/v10TF6PHpIi4ulwvj4+NwOBzahVoqlVAqlfR4ewBoO9eeTb7VaoWiKFAURbcxMdpdwdtsNvT392sXQ61W03NYAND22b7D4UAikdB2eOy/lUpFW1WelXYypex2O6LRqHb0xdxw9aTd41u73Y7BwcEjR61sx6wX7ca3nE6ntttkv6WiKMhms7qNrd2iQZvNpmX0HT6i1vN+aOf4liWFOBwOWK1W3Z9pANpODWbXGvst2ZyVy2XdxnbWWKpF1UHeOvHAPk67cZFuqXevjY3X35TnOeN5bLz+ngC/80Zz1t61pr1WD3FphWq1io2NDYyOjnKTMcNoNBqQZdnw7KeTUFUVgiBwE+BnsBTW4eFhbrKMGLVajTvvKUY+n0etVtNWn7xwuENnp6zYzwJLTeYhvnaYWq2Gra0tbafDE7lcDvV6HcPDw1393K5f1fV6Haurq/iXf/kXJJPJbn/8c7FYLGg0GlqKMk8IgoDNzU1dj1j0YGVlBalUiqsbnRXsrq6uotFodGUF2iqSJGF7extzc3MdOQ5tF4vFglKphMePH3M1LoYoitje3ubqHmUtJvb397laKLACz9XVVYii2PUYTNdnIhwO44033sDg4CB+//vf4+OPP4Ysy90exok4nU44HA5UKhUuH0i8kc1mkUwmu+pX9CKY+zEzNeStBoERjUYxPT0NAJidncX+/r7BI/qciYkJOBwOzM3NGR4UNgMrKysolUq4efMmF2nmwLOY99zcHMrlMsbGxgyxpDFEZp1OJ/7oj/4Ir7zyCjY2NvDuu+8in88bMZQvwI52WGtj4mQkScL8/DxCoRA3Td4KhQJWVlYgiiIuX75seMHui3C73ZienkYsFsPGxgaWlpYgSZLRw4LdbsfMzAxyuRw2NzeNHg7X5PN5rK6u4urVq1317ToNZuGzuLiIvr4+TE9PG2Y8auge7sqVK/jmN78Jm82GX/3qV1haWjJyOACeHQt4vV7NHZk4mcXFRciyjKmpKcMf4IqiIJVKIZlMwufzcbWTehFWqxWXLl3C+Pg4yuUynjx5gmKxaPSwEAqFcPHiRaysrOiagdRLyLKMx48fIxgMYnR01OjhoNFoYGFhAXt7e4jH41oGr1EYfkAYCATwjW98A2NjY/jkk0/wu9/9zvCHusPhgMvl0vq6EEfZ39/H3t4erl27ZnhSRr1ex8rKCorFIuLxuFahbzb6+/tx/fp1uN1uLCwsIJlMGn4kdfXqVbjdbszOztJ9cAILCwtoNBq4ceOG4QusbDaLp0+fQpIkTExMGOIldhzDxQV4lud++/ZtfOUrX0E2m8UvfvEL7O3tGTomVvimV01Hr8BWRwMDA4b3rDg4ONAKycbGxrjqO9IODocDExMTSCQS2N3dxdOnTw1daFmtVly/fh3lchmrq6uGjYNHMpkMNjc3DTcglWUZ6+vrWFtbQzAYxNTUFDdZm1yIC2N4eBj3799HMBjEe++9h8ePHxu2YmLHY5Ik6V6kZ2bm5+dhtVpx7do1w8YgSRI2Njawu7uLcDiM0dFRrroRnpXh4WFMTU1BkiTMzs7i4ODAsLH4/X6MjY1hY2MDhULBsHHwhCiK+OyzzxCNRnHx4kXDxlGpVPD06VPkcjlcvnwZV65c4WrXzpW4AM+qo1977TXcvHkTS0tL+PWvf23YmS+zVajVatxktBlJKpVCNpvF1NSUYWe5zEa8Xq/j0qVLXGz/O4HX69W6QK6urmJ1ddWwa/DSpUsIBAJ48uQJ3QeAdkx448YNw8awu7uLhYUF2O12TE9Pc1mTxJ24AM92DRMTE/jGN74BURTx7rvvYn193ZCxuN1u2Gw2VCoVw8/AjaRarWJ5eRnxeBzhcLjrn8+abG1sbKCvr08zguxlbDYbRkdHMTo6inw+j9nZWUOOaS0WC65fvw5BELC4uNj1z+eJ7e1t7O7uYmZmxpB4oyiKWFpaQiqVwuDgICYmJgyPe54Gl+LCCIVCeOONN5BIJPDgwQP84Q9/MKR4yuv1Qpblc3s8pqoqnj59CpfLhbGxsa5/fqPR0PpnDA0N4dKlS1zWrnSKSCSCmZkZ2O12PH36FDs7O11f6Ljdbly7dg2pVAqZTKarn80L9Xodc3NzGB4extDQUNc/v1AoaEW3165dQzwe53rXzrW4AM+Opu7evYsvfelL2N3dxbvvvtv1M2ibzQa32416vc5FHUK32djYQKlUwvT0dNfPdHO5HFZXV6GqKkZHR7nc/ncDl8uFqakpDA0NIZlMYnFxsetuDfF4HNFoFHNzc9w5RXQaVVXx2WefacdQ3YR1MF1eXobX68X09HTbJqHdhHtxYVy4cAFvvPEG+vr68Jvf/AZPnz7t6uqtr68Pdrv93B2PlUolrK+va+fu3UKWZWxtbWF7e1urIzCy2RwPWCwWJBIJTExMoFarYXZ2tuvFx9PT01BVFfPz8139XKPZ3NzEwcEBbty40dV4Y71ex/z8PNLpNC5cuICrV6+aZtduGnEBnh1Pff3rX8fU1BRmZ2fx29/+tqv+R16vV2upex5QFAVzc3Pw+Xy4fPly1z63Wq1iZWUFlUoFFy5cwMjICFeeTUYTCARw/fp1+Hw+LC0tYWNjo2tZlU6nE1NTU9jf38fOzk5XPtNoyuUyFhYWcOnSpa7unNPptLaInpqawsDAQNc+Ww9Md8daLBbMzMzgq1/9KsrlMn7xi18glUp15bOtVis8Hg8EQeDKOK9TsKysblXhM8PJtbU1OBwOjI2NcWGpwSN2ux3j4+O4dOkSMplMVw0wBwYGMDw8jIWFhZ6PQ6qqisePH2sxp27ADCc3NzcRiUQwNTV1pEmZWTCduDBisRju37+PWCyGf/3Xf+2aAeZ5MbfM5XKaKWU3irKY4WQ6ndYMJ3mzLueRgYEBLQYwNzfXNQPMiYkJ2O12zM7O9vQxcbdNKUulEp4+fYpSqaQZTpp1127OUf9/nE4nvvzlL+POnTvY2NjAL3/5y64UevW6uaUkSXj69GnXTCmLxaJmOHnlyhXuDSd5gxlgRqPRrhlgHja33Nra6uhnGUU+n8fKygrGxsYQDAY7+lmqqmJ7exuLi4twuVyGGk7qhanFhTE6OopvfvObsFgs+OUvf4nl5eWOfl6vm1t2y5RSURRsb29ja2vLdIaTvGGEASYzt1xeXu45myRmShkIBDqefs8slXZ3dzEyMoLx8fGecJzoCXEBngU5X3/9dYyNjeHRo0cdN8DsVXPLbplSsqZxhUIBIyMjpjWc5I3+/n7MzMx0zQCTmVs+efKkp+4DZkp58+bNji6wmOGkKIqYmJjA8PBwz+zae0ZcgO4bYPaauSWrwI7FYh01pWSGkxaLBaOjowiFQh37rPOI0+nEtWvXumKAedjccm1trSOf0W26YUqpKMoRw8np6WluDCf1oqfEhdEtA8xeM7ecn5/XrHc6wUmGk7xaV5gdi8XSNQNMv9+P0dFRrK+vm97cshumlNVqFXNzc9waTupFT4oLcNQAc3FxsWMGmL1ibplKpXBwcIDJycmOZGmdF8NJ3uiWAebly5d7wtxybm4OiqLg+vXrHXn/vb09zM/Pw2azcWs4qRc9Ky7A5waYr7/+umaAubGxofvnHDa3NCO1Wg0rKyuIx+O6X+zn0XCSNw4bYOZyuY4YYLL6MzObW+7s7GBnZwfT09O6u0Eww8lkMomBgQFMTk72/K69p8WFcdgA88MPP8QHH3ygexEkM7fspmOAHqiqirm5OTidTt2zYs674SRvRCIRXL9+/YgBpp54PB7TmlseNqUcHh7W9b0PG06Oj48jkUici137uRAX4HMDzHv37mFnZ0d3A0yzmlt2ypSSDCf55LgB5sLCgq4LrcPmlmZxsWCmlOyoSi9OMpw8T44T50ZcGBcvXuyYAabZzC2ZKeXFixd1u+hlWUYymSTDSY45boD55MkTXQ0wp6amtDYNZqATppRmNpzUi3MnLsCzI6yvfe1rmJycxJMnT3Q1wGTmlrwfjzFTSq/Xq5spJTOcLJfLSCQSZDjJOZ0ywGS7IzOYW1YqFSwsLODixYu67a4zmYypDSf14tze+Sw//2tf+5pmgLm9va3L+7rdbjQaDa6PBVZXV1Gv1zE9PX1mAVBVFel0+ojhZKftMgh9OGyAmU6ndTPANIO55WFTSj3S72VZxurqKjY2NhAOh01rOKkX51ZcGIcNMN9//308fPjwzKmULpdLM7fk8XiM+UGNjo6euXCLGU7u7+8jFouR4aRJGRgYwMzMDAD9DDB5N7dcWVlBsVjUxZSyXC5jbm4OxWIRY2NjuHTp0rnftZ/vb///YQaYL7/8MtbX13UxwGQPbd7Skw+bUiYSiTO913HDyYGBgXORBdOrHDfAXF5ePlNyCuvayKO5ZaFQ0MWUkhlOLiwswOl09oThpF6QuBxibGxMNwNMXs0tmSnl5ORk20Jw2HDS6/WS4WQPwQwwr169ilKphNnZWZRKpbbfLxwOc2duqZcpJavpYYaT165d6wnDSb0gcTkGM8AcHR3Fo0eP8P7777ctDg6HA06nkxtzy3Q6jb29PYyPj7edwXXccPLChQs9aV1x3gmFQpiZmYHL5cL8/DxSqVTbR1u8mVuyONBZTClzuRzm5uYgCAKuXbvWU4aTekHicgI2mw0vvfQS/viP/xiZTAa/+MUv2j6D9ng8XJhbCoKAhYUFxGIxDA0NtfUeZDh5vnA6nZiYmEAikcDOzg7m5+fbWmjxZG55VlNKZji5urqKQCCA6elpcpw4BRKX5zAyMoL79+8jEAjgt7/9LT777LOWV168mFuexZSSDCfPL8wAc3JyEqIoYnZ2FtlstuX34cHckplSRiIRXLhwoeXXV6tVPH36VDOcHB0dpV37cyBxeQFutxt/8id/ghs3bmBhYQG/+c1vWjbANNrccnt7u21TSjKcJADA5/NpBpgrKytYW1tr+Vpm5pazs7OG3AfMlPLGjRstX8PMcNJqtWJqaoocJ5qAxKUJLBYLJicn8Y1vfAOCILRlgGmUuWWtVsPy8jJGRkZauiHIcJI4DjPAvHLlCrLZbMsGmMzcstFoYGlpqYMj/SLtmlKeZDhJjhPNQeLSAuFwGG+88Qbi8XhbBpjdNrdkFhxOpxNXr15t+nWCIJDhJHEq0Wj0iAHm7u5u06/1eDwYHx9HMpnsWH+Z47RrSnleDSf1gsSlRex2O1599VXcu3cP29vbePfdd5s+g+62ueXm5iaKxSKmpqaaPhvO5/NYWVmBoihkOEmcymEDzK2trZYMMBOJBCKRCGZnZzvuYsFMKa1Wa9OmlKqqnmvDSb0gcWmTixcv4v79+3C5XPj1r3+N+fn5plI1u2VuWSqVsLa2hosXLzZVJMYMJ1OplJb/T9t/4nmcxQBzenq6K+aWW1tbLZlSkuGkfpC4nAGv14uvf/3rmJiYwGeffYb33nuvqSOvTptbKoqCp0+fNm1KyQwnS6USEokE4vH4ubeuIJrnuAHm5ubmC7MqXS4XJicnO2puediUMhqNvvDfM8NJRVEwOTl5bg0n9YKeIGfEarXixo0b+OpXv4pSqdSUAWanzS1XV1dRq9VeaErJDCfX19fhcDhw9epVMpwk2oIZYF68eBH7+/t4+vTpCxdPg4ODGBoa6oi5JTOl7Ovre2H6/UmGk+Q4cXZIXHRiYGAA9+/fRzQabcoAs1Pmls2aUh42nIxGo2Q4SejC4OCgduQ1NzeHdDr93H8/OTkJm82Gubk5Xe+DZk0pDxtOjo6OkuGkjtAs6ojT6cQf//EfawaYv/rVr55bMMZWR3qlJzdrSkmGk0Qn8Xg8mJ6eRiQSwfr6+nMNMO12O2ZmZpDNZnUzt2zGlPIkw0lynNAXEpcOMDY2htdffx0A8Ktf/QorKysn/jur1aqZWwqCcObPXVpaeq4pJRlOEt3CarXi8uXLTRlg6mlu2YwpJTOc3NnZIcPJDkLi0iGCwSBef/11XLlyBQ8fPsT7779/ooAwc8tqtXomU790Oo3d3d1TTSnJcJIwgmYNMPUyt1xYWECtVjvVlPKw4eTExAQZTnYQEpcO0qwB5lnNLV9kSkmGk4SRMAPMeDx+qgGm1WrFzMzMmcwtDw4OTjWlVBQFGxsbZDjZRUhcugAzwPT7/ScaYJ7V3PI0U0pJkrC5uUmGk4ThWCwWjIyMPNcAMxAItG1uediU8uLFi0f+HzOczGazuHTpEhlOdgkSly5xkgHm4Z1Ku+aWp5lSMsPJWq2GixcvkuEkwQXMADMYDGoGmIcXWu2aW87NzUGW5S+YUh43nGym3oXQBxKXLnLYALPRaOAXv/gFNjc3tf/f19fXkrnlSaaUqqpib2/viOGk3+/vyPchiHaw2WwYGxs70QCTmVvW6/WmzS1PMqUkw0njIXExgMMGmB988AE+/PBDSJKkHY8dN7dUVRWZTAbJZBKZTAaqqp5oSikIAtbW1nBwcIDBwUEynCS4JhqNYmZmBjab7YgBpsfjwbVr175gbnnSfXCSKWWxWMTc3Byq1SoZThqIRe2kwRXxQjY2NvDw4UP09fXh3r17CIfDqNfr2vHY//yf/xP/7b/9tyPpzGNjY/hP/+k/4e7du3jttdcQDAaRz+exs7MDu92ORCIBt9tt4LciiOZRVRXJZBK7u7sIBoO4cuUKHA4HHj16hHK5jMnJSfzoRz868T74d//u3+FrX/sa/s2/+Tew2+1IpVLY29tDIBCgwmCDIXHhgHK5jA8++AC5XA7Xr1/HxMQE/s//+T/4y7/8S1SrVVgslhPTN91uN/73//7fuHnzJgqFAvr7+zE8PEwVxoQpKRaLWF1dhaqqGB0dRV9fH374wx/iv/yX/6Ilupx0H3g8Hvyv//W/cPXqVdRqNcTjcQwODnZ7+MQxSFw4QVEUzM7OYn5+Huvr6/jP//k/Azj5ZjqM1WrF//gf/wP/4T/8B/IFI0yPKIpYW1tDoVDA/Pw8vvvd7wJ4/n1gsVhgsVjw3//7f8df/dVfUWEwJ5C4cMbS0hJu3LgBQRCa8lqyWCxwu91IpVLo7+/v/AAJogssLi7i1q1baDQadB+YFDo/4Yy333676RsKgGbd/9Zbb3V4ZATRPf7lX/4F9Xqd7gMTQzsXjlBVFePj49q5c7OwyvulpSXKiiFMD90HvQGJC0dkMhnEYrEzvZ7aEhNmh+6D3oCOxTiiXC6f6fWnuc4ShJmg+6A3IHHhiLMa6VElPtEL0H3QG5C4cEQkEsHY2FjL58UWiwVjY2MIh8MdGhlBdA+6D3oDEheOsFgs+Nu//du2Xvv973+fgphET0D3QW9AAX3OyOfzSCQSqNVqTTVNslqtcLvdSCaTlN9P9Ax0H5gf2rlwRn9/P/7pn/4JFovlhTYuVqsVFosFP/7xj+mGInoKug/MD4kLh7z55pv42c9+BrfbrVlbHIb9ndvtxttvv4379+8bNFKC6Bx0H5gbEhdOefPNN5FMJvGDH/wAo6OjR/7f6OgofvCDHyCVStENRfQ0dB+YF4q5mABVVZHNZlEqleD3+xEOhyloSZw76D4wFyQuBEEQhO7QsRhBEAShOyQuBEEQhO6QuBAEQRC6Q+JCEARB6A6JC0EQBKE7JC4EQRCE7pC4EARBELpD4kIQBEHoDokLQRAEoTskLgRBEITukLgQBEEQukPiQhAEQegOiQtBEAShOyQuBEEQhO78Pw3EQAwOHcfRAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "import torch.nn\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, base_fun=torch.nn.SiLU())\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "model(dataset['train_input'])\n", - "model.plot()\n", - "model.save_ckpt('ckpt1')\n", - "#model.clear_ckpts()\n", - "# save intialized model as ckpt1" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ab90723b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.55e-01 | test loss: 1.30e-01 | reg: 2.03e+01 : 100%|██| 20/20 [00:12<00:00, 1.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "save this model to ./model_ckpt/ckpt2\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);\n", - "model.plot()\n", - "model.save_ckpt('ckpt2')\n", - "# save the trained model as ckpt2" - ] - }, - { - "cell_type": "markdown", - "id": "6b339ba4", - "metadata": {}, - "source": [ - "### The above results look promising! You probably want to further simplify it down by further training it or pruning it. Suppose you want to pump up regularization strengh to make the graph cleaner, but you set the strength to be too large and training messes the whole thing up." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0b580553", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.59e+00 | test loss: 8.56e+00 | reg: 3.16e+01 : 100%|██| 20/20 [00:01<00:00, 19.61it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "save this model to ./model_ckpt/ckpt3\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.train(dataset, opt=\"Adam\", steps=20, lamb=100., lamb_entropy=10.);\n", - "model.plot()\n", - "model.save_ckpt('ckpt3')" - ] - }, - { - "cell_type": "markdown", - "id": "4300604e", - "metadata": {}, - "source": [ - "### We want to recover to ckpt2" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "705661e5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.load_ckpt('ckpt2')\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "686b8fb4", - "metadata": {}, - "source": [ - "### Now we realize that pruning it seems a better choice." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0598e1f0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/API_9_video_-checkpoint.ipynb b/docs/.ipynb_checkpoints/API_9_video_-checkpoint.ipynb deleted file mode 100644 index f48a110f2..000000000 --- a/docs/.ipynb_checkpoints/API_9_video_-checkpoint.ipynb +++ /dev/null @@ -1,90 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API Demo 9: Videos of KAN training\n", - "\n", - "### We have shown one can visualize KAN with the plot() method. If one wants to save the training dynamics of KAN plots, one only needs to pass argument save_video = True to train() method (and set some video related parameters)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.39e-03 | test loss: 6.40e-03 | reg: 7.91e+00 : 100%|██| 50/50 [01:30<00:00, 1.81s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Moviepy - Building video video.mp4.\n", - "Moviepy - Writing video video.mp4\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " \r" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Moviepy - Done !\n", - "Moviepy - video ready video.mp4\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000)\n", - "\n", - "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.train(dataset, opt=\"LBFGS\", steps=50, lamb=5e-5, lamb_entropy=2., save_video=True, beta=10, \n", - " in_vars=[r'$x_1$', r'$x_2$', r'$x_3$', r'$x_4$'],\n", - " out_vars=[r'${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$'],\n", - " video_name='video', fps=5);" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_10_relativity-addition_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_10_relativity-addition_-checkpoint.ipynb deleted file mode 100644 index 104555cca..000000000 --- a/docs/.ipynb_checkpoints/Example_10_relativity-addition_-checkpoint.ipynb +++ /dev/null @@ -1,432 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 10: Use of lock for Relativity Addition" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "### In this example, we will symbolically regress $f(u,v)=\\frac{u+v}{1+uv}$. In relavitity, we know the rapidity trick $f(u,v)={\\rm tanh}({\\rm arctanh}\\ u+{\\rm arctanh}\\ v)$. Can we rediscover rapidity trick with KAN?" - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "### Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [], - "source": [ - "from kan import KAN, create_dataset\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=10, k=3)\n", - "\n", - "# create dataset\n", - "f = lambda x: (x[:,[0]]+x[:,[1]])/(1+x[:,[0]]*x[:,[1]])\n", - "dataset = create_dataset(f, n_var=2, ranges=[-0.9,0.9])" - ] - }, - { - "cell_type": "markdown", - "id": "cb1f817e", - "metadata": {}, - "source": [ - "### Train KAN and plot" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a87b97b0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.28e-04 | test loss: 6.37e-04 | reg: 2.73e+00 : 100%|██| 20/20 [00:03<00:00, 5.41it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f1cfc9d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "2795dfc8", - "metadata": {}, - "source": [ - "### We notice that the two functions in the first layer look the same. Let's try to lock them!" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "17b6b983", - "metadata": {}, - "outputs": [], - "source": [ - "model.lock(0,[[0,0],[1,0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "eb976f5a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "8214259e", - "metadata": {}, - "source": [ - "### Now there are lock symbols in their top left corners!" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0298d20a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.13e-04 | test loss: 6.00e-04 | reg: 2.73e+00 : 100%|██| 20/20 [00:03<00:00, 5.68it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "5ca6421a", - "metadata": {}, - "source": [ - "### Retrain the model, the loss remains similar, meaning that the locking does not degrade model behavior, justifying our hypothesis that these two activation functions are the same. Let's now determine what this function is using $\\texttt{suggest_symbolic}$" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2ccb7048", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "arctanh , 0.9999993678015309\n", - "tan , 0.9998485210873531\n", - "arcsin , 0.998865199664262\n", - "sqrt , 0.9830640000050016\n", - "x^2 , 0.9830517375289431\n" - ] - }, - { - "data": { - "text/plain": [ - "('arctanh',\n", - " ((x)>, (x)>),\n", - " 0.9999993678015309)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,1,0)" - ] - }, - { - "cell_type": "markdown", - "id": "0092be41", - "metadata": {}, - "source": [ - "### we can see that ${\\rm arctanh}$ is at the top of the suggestion list! So we can set both to arctanh, retrain the model, and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "1bb96fe1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999992221865773\n", - "r2 is 0.9999993678015309\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'arctanh')\n", - "model.fix_symbolic(0,1,0,'arctanh')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "83b852a3", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.39e-04 | test loss: 2.54e-03 | reg: 2.73e+00 : 100%|██| 20/20 [00:03<00:00, 6.33it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20, update_grid=False);" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9ccd0923", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "4b98a727", - "metadata": {}, - "source": [ - "### we will see that ${\\rm tanh}$ is at the top of the suggestion list (${\\rm sigmoid}$ is equivalent to tanh given input/ouput affine transformations)! So we can set it to ${\\rm tanh}$, retrain the model to machine precision, plot it and finally get the symbolic formula." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "99ad38b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "tanh , 0.9999837308133379\n", - "sigmoid , 0.9999837287987492\n", - "arctan , 0.9995498634842791\n", - "sin , 0.996256989539414\n", - "gaussian , 0.9938095927784649\n" - ] - }, - { - "data": { - "text/plain": [ - "('tanh',\n", - " ((x)>, (x)>),\n", - " 0.9999837308133379)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(1,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "af24c80d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999837308133379\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000, grad_fn=)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(1,0,0,'tanh')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "01936f17", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.69e-11 | test loss: 5.76e-12 | reg: 2.69e+00 : 100%|██| 20/20 [00:00<00:00, 21.70it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "76bcc188", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "b62b0246", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 \\tanh{\\left(1.0 \\operatorname{atanh}{\\left(1.0 x_{1} \\right)} + 1.0 \\operatorname{atanh}{\\left(1.0 x_{2} \\right)} \\right)}$" - ], - "text/plain": [ - "1.0*tanh(1.0*atanh(1.0*x_1) + 1.0*atanh(1.0*x_2))" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.symbolic_formula()[0][0]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_11_encouraing_linear_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_11_encouraing_linear_-checkpoint.ipynb deleted file mode 100644 index 71fe56cb5..000000000 --- a/docs/.ipynb_checkpoints/Example_11_encouraing_linear_-checkpoint.ipynb +++ /dev/null @@ -1,327 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "095b0666", - "metadata": {}, - "source": [ - "# Example 11: Encouraging linearity\n", - "\n", - "### In cases where we don't know how deep we should set KANs to be, one strategy is to try from small models, grudually making models wider/deeper until we find the minimal model that performs the task quite well. Another strategy is to start from a big enough model and prune it down. This jupyter notebook demonstrates cases where we go for the second strategy. Besides sparsity along width, we also want activation functions to be linear ('shortcut' along depth)." - ] - }, - { - "cell_type": "markdown", - "id": "ef047a0f", - "metadata": {}, - "source": [ - "### Tricks\n", - "\n", - "There are two relevant tricks: \n", - "\n", - "(1) set the base function 'base_fun' to be linear; \n", - "\n", - "(2) penalize spline coefficients. When spline coefficients are zero, the activation function is linear." - ] - }, - { - "cell_type": "markdown", - "id": "91301ca0", - "metadata": {}, - "source": [ - "### Case 1: 1D function $f(x)={\\rm sin}(\\pi x)$. Although we know a [1,1] KAN suffices, we suppose we don't know that and use a [1,1,1,1] KAN instead." - ] - }, - { - "cell_type": "markdown", - "id": "77f9e16d", - "metadata": {}, - "source": [ - "### without trick" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c881665b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.78e-04 | test loss: 7.09e-04 | reg: 1.29e+00 : 100%|██| 20/20 [00:03<00:00, 5.28it/s]\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", - "dataset = create_dataset(f, n_var=1)\n", - "\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0)\n", - "\n", - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "201ceacf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "13c725a5", - "metadata": {}, - "source": [ - "### with tricks" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a22ffff3", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.40e-03 | test loss: 4.22e-03 | reg: 3.35e+00 : 100%|██| 20/20 [00:03<00:00, 5.78it/s]\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", - "dataset = create_dataset(f, n_var=1)\n", - "\n", - "# set base_fun to be linear\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, base_fun=lambda x: x)\n", - "\n", - "# penality spline coefficients\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-4, lamb_coef=10.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c82c8db5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "af370a4c", - "metadata": {}, - "source": [ - "### Case 2: 2D function $f(x,y)={\\rm exp}({\\rm sin}(\\pi x)+y^2)$. We know a [2,1,1] KAN represents it. Let's suppose we don't know about that and use a [2,3,3,3,1] KAN instead." - ] - }, - { - "cell_type": "markdown", - "id": "fdba8357", - "metadata": {}, - "source": [ - "### without tricks" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5920bdaf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.02e-02 | test loss: 8.01e-02 | reg: 1.24e+01 : 100%|██| 20/20 [00:33<00:00, 1.70s/it]\n" - ] - } - ], - "source": [ - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "model = KAN(width=[2,3,3,3,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "26af5d19", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "b0316bee", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "ca1c5e86", - "metadata": {}, - "source": [ - "### with tricks" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "1f82e8c0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.19e-02 | test loss: 7.77e-02 | reg: 1.37e+01 : 100%|██| 20/20 [00:29<00:00, 1.47s/it]\n" - ] - } - ], - "source": [ - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "model = KAN(width=[2,3,3,3,1], grid=5, k=3, seed=0)\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_coef=1.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e09861b6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "31ee6172", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAJ8CAYAAAAyDezRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABO0klEQVR4nO3deXxU5b0/8M+ZTGYyk4XsO1tCgABhlX1RFIgVxVrca92q997+Krxcaq1trctLrRUXsNfbXmu1QN2FqjRAkH0XkCUJe9hCCNkzySSTZWbO8/tD59wcNgM5yTkz83m/Xv5xniHwgHPmM89yvo8khBAgIiLSkEnvDhARUeBhuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERac6sdweI/IEQAjU1NWhsbERERATi4uIgSZLe3SIyLI5ciC7B4XBgwYIFyMrKQkJCAvr27YuEhARkZWVhwYIFcDgceneRyJAkHnNMdGH5+fmYPXs2XC4XgO9GLz6+UYvdbseSJUuQm5urSx+JjIrhQnQB+fn5mDlzJoQQkGX5or/OZDJBkiTk5eUxYIjaYbgQncPhcCA9PR3Nzc2XDBYfk8kEm82G0tJSREdHd30HifwA11yIzrFw4UK4XK4OBQsAyLIMl8uFRYsWdXHPiPwHRy5E7QghkJWVhePHj+Nybg1JkpCRkYGjR49yFxkRGC5EKtXV1UhISOjUz8fFxWnYIyL/xGkxonYaGxs79fNOp1OjnhD5N4YLUTsRERGd+vnIyEiNekLk3xguRO3ExcUhMzPzstdNJElCZmYmYmNju6hnRP6F4ULUjiRJmDNnzhX97Ny5c7mYT/Q9LugTnYPPuRB1HkcuROeIjo7GkiVLIEkSTKZL3yK+J/SXLl3KYCFqh+FCdAG5ubnIy8uDzWaDJEnnTXf52mw2G5YvX44ZM2bo1FMiY2K4EF1Ebm4uSktLMX/+fGRkZKhey8jIwPz583HmzBkGC9EFcM2FqAOEENiyZQvuuOMOfPLJJ5g4cSIX74kugSMXog6QJAnR0dEwm82Ijo5msBD9AIYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESa43kuRB3U1taGyspKJCYmwmKx6N0dIkNjuBB1kCzL8Hg8MJvNMJk46Ce6FIYLERFpjl+/iIhIc2a9O0AkhEB9fT1qa2v17krACQkJQWpqKkJDQ/XuCgUZhgsZwtKlS/HWW2/BbrfzfHqNeL1emEwmfPrpp0hPT9e7OxRkGC5kCG63G8OGDcOLL77IxfIrJMsyDh8+jPT0dERGRuL06dN47LHHwGVV0gPDhQzDarUiLS2N4XIFvF4vVq1ahWeeeQbXXnstnnvuObS2tnIUSLphuBD5OY/Hg88//xwvvvginE4nPv/8c0RFReHWW2/Vu2sUxPgVkciPtba24t1338Vzzz0Hp9MJ4LtRTF5eHkpLS3XuHQUzjlyI/JAQAi0tLXjrrbfw7rvvoq2tTXktPT0d8+bNQ1JSko49pGDHkQuRnxFCwOl04oUXXsA777yjCpb+/fvjL3/5C8aPH8/1FtIVRy5EfkQIgZqaGvzhD3/AihUrIMuy8trIkSMxb948ZGZmMlhIdwwXIj8hhEBZWRmeeuopbN68WdliLEkSJk+ejFdeeQWpqakMFjIETosR+QEhBI4dO4Zf/vKX2LRpkxIsJpMJM2fOxJtvvslgIUPhyIXI4IQQKCwsxBNPPIEjR44o7WazGXfccQd+85vfIDIyksFChsJwITIwIQS2bduGJ598UrW12GKx4KGHHsLcuXMRFhbGYCHDYbgQGZQsy/j666/xu9/9DlVVVUq7zWbDY489hgceeICHlpFhMVyIDMjr9eJf//oXXnjhBdTX1yvtUVFR+N3vfodbb70VZjNvXzIuvjuJDMbtduOf//wn5s2bh6amJqU9Pj4eL774ImbMmIGQkBAde0j0wxguRAYhhEBrayveeecd/Pd//zdaW1uV19LS0vCnP/0JEydOZGFP8gsMFyIDEEKgubkZb775Jt5//3243W7ltczMTLz22msYMWIEF+7JbzBciHQmhEBjYyP++Mc/4uOPP4bX61VeGzx4MN544w0MGDCAwUJ+heFCpCMhBBwOB5599lksW7ZMVc5lzJgxeO2119CrVy8GC/kdhguRToQQqK6uxm9/+1t8/fXXqnIuU6ZMwZ/+9CckJyczWMgvcWWQSAdCCJSXl+Pxxx8/L1iuv/56vPHGGwwW8mscuRB1MyEESkpK8MQTT2Dnzp1Ku8lkwuzZs/HMM88gKiqKwUJ+jeFC1I2EECguLsbjjz+OgoICpd1sNuPuu+/GU089hfDwcAYL+T2GC1E3EUJg//79ePzxx3H48GGlPTQ0FD//+c/x6KOPsk4YBQyGC1E3EEJg9+7dePzxx3Hy5Eml3WKxYM6cOfjP//xPWK1W/TpIpDGGC1EXu1hlY5vNhscffxz3338/C1BSwGG4EHUhWZaxfv16PPXUU6isrFTaIyIi8PTTT+POO+9kAUoKSHxXE3URr9eLFStW4JlnnkFtba3S3qNHDzz33HO4+eabWYCSAhbDhagLeDweLF26FC+88AKcTqfSHhcXh5deegm5ubksQEkBjeFCpDFfyfxXX30VLpdLaU9KSsKrr76KKVOmMFgo4DFciDQihEBbWxv+9re/4a233lKVzE9PT8frr7+OsWPHcqsxBQWGC5EGfGexvPXWW/jb3/6GtrY25bXMzEy88cYbGDZsGIOFggbDhaiThBBoamrCq6++ig8++AAej0d5bdCgQZg/fz769+/PYKGgwnAh6gQhBBoaGvDCCy9g6dKlqpL5o0aNwuuvv44+ffowWCjoMFyIrpAQArW1tfj973+PFStWKJWNAWDixImYN28eUlNTGSwUlBguRFdACIGKigo89dRT2LBhg6pk/rRp0/Dyyy8jISGBwUJBi/shiS6TEAKnT5/G3LlzsX79eiVYTCYTZs2ahXnz5jFYKOhx5EJ0GXwl85944gns27dPaQ8JCcEdd9yB3/72t4iIiGCwUNBjuBB1kK9k/mOPPYYjR44o7aGhobj//vvx+OOPw2azMViIwHAh6hAhBL799ls88cQT55XM/3//7//hF7/4BaxWK4OF6HsMF6IfIITAli1b8OSTT6KsrExpZ8l8ootjuBBdgizLWLNmDX7zm9+gurpaaY+IiMBvf/tb3HHHHSyZT3QBvCuILsLr9eLf//43/vCHP8DhcCjt0dHReO655zBr1iyWzCe6CIYL0QV4PB58/vnnePHFF1Ul8+Pj4/Hyyy9j+vTprGxMdAkMF6JzuN1ufPjhh3jllVdUJfNTUlLw6quvYtKkSQwWoh/AcCFqp62tDe+//z7eeOMNtLS0KO29evXCG2+8gauuuoo7wog6gOFChP8rmf/Xv/4Vb7/99nkl8+fPn4+cnBwGC1EHMVwo6PmCZf78+Xj33XfhdruV17KzszF//nwMGDCAwUJ0GRguFNSEEHC5XJg3bx4WL16sOotl2LBhePPNN5GRkcFgIbpMDBcKWkIIOJ1OvPTSS/jss8/g9XqV10aPHo033ngDPXv2ZLAQXQGGCwUlIQTq6+vx7LPP4quvvlId8jVp0iTMmzcPKSkpDBaiK8RwoaAjhEBNTQ1+97vfIT8/X3UWy9SpU/GnP/2JJfOJOomb9SmoCCFQXl6Oxx577LxgueGGG/D6668zWIg0wJELBQ0hBE6dOoUnnngCu3btUtpNJhNuueUWPPvss4iKimKwEGmA4UJBQQiBgwcP4oknnsCBAweU9pCQENx11134zW9+w0O+iDTEcKGAJ4TAN998g1//+tc4deqU0h4aGooHH3wQjz32GMLCwhgsRBpiuFBA83q9WLVqFZ555hlUVVUp7WFhYXjkkUfw8MMPIywsTMceEgUmhgsFJCGEUoDytddeU1U2joyMxK9//WvcddddCA0N1bGXRIGL4UIBRwiBxsZGLFiwAAsXLlTVCYuLi8Pzzz+PG264gWexEHUhhgsFFCEESktL8fzzz2PNmjWqhyN79uyJV155BRMmTGDJfKIuxnChgCHLMr799lv8/ve/x6FDh1SvDRs2DK+88gqys7O5cE/UDRguFBDcbje++OILvPLKK6qz7k0mE6ZPn47nn38eycnJDBaibsJwIb8mhEBTUxPefvtt/P3vf0dra6vymtVqxQMPPIBHHnmEz7AQdTOGC/ktIQSqq6vx/PPPY/ny5aqqxvHx8Xj66adx8803c0cYkQ4YLuSXfAv3v/71r7Ft2zalRhgADBw4EC+99BJGjhzJhXsinTBcyO8IIVBSUoJHH30Uu3fvVtpNJhOuueYavPDCC0hPT+c0GJGOGC7kV4QQOHPmzHnBYjabcdddd+HJJ59k8UkiA2C4kN8QQqC2thZPPfWUKlgsFgv+4z/+A3PmzIHVamWwEBkAw4X8RktLC15++WVs2bJFabNYLHjkkUfwX//1X7BarTr2joja42on+QWv14t//OMf+OKLL5TFe7PZjIcffpjBQmRADBcyPCEEtm3bhrfffhsejwfAdydH/uQnP1GmwojIWBguZHhVVVV46aWXVJWNx44di6effprl8okMiuFChubxePC///u/OHjwoNKWkpKC5557DjExMVy8JzIohgsZlhACu3btwscff6yss1gsFjz++OMYOHAgg4XIwBguZFgulwsLFixAY2Oj0jZ9+nTMmjWLwUJkcAwXMiQhBFatWoUdO3YobQkJCXj00Ue5gE/kBxguZEj19fV45513VLvD7r33XvTr14+jFiI/wHAhwxFCIC8vT3XgV79+/XD33XezECWRn+CdSobT0NCAf/7zn8oRxSEhIXjggQcQFxenc8+IqKMYLmQ4q1evxuHDh5Xr/v37Y+bMmZwOI/IjDBcyFJfLhQ8++EA5+MtkMuGee+5Bjx49dO4ZEV0OhgsZyp49e1BUVKRc9+nTB9dffz1HLUR+huFChjJkyBA8++yzyMnJQWhoKG699VautRD5IZbcJ0OJiorCXXfdhZtuugk7duzA0KFDIYRQHWNMHcN/M9ITw4UMY9++fZg7d65qCuyLL77Qr0N+rrGxES0tLXp3g4IUw4UMYfTo0XC73Xp3I+BMnDgRUVFReneDgpAkOHYmA+DbsGtxQwR1N45cyBD44UcUWLhbjIiINMdwISIizTFciIhIcwwXIiLSHMOFqINkWUZbW5tSrZmILo7hQtRBBw4cQFZWFg4cOKB3V4gMj+FCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgtRBwghUFdXB4/Hg7q6Oggh9O4SkaExXIguweFwYMGCBcjKysKUKVNQVlaGKVOmICsrCwsWLIDD4dC7i0SGJAl+BSO6oPz8fMyePRsulwsAVKMVSZIAAHa7HUuWLEFubq4ufSQyKoYL0QXk5+dj5syZEEJAluWL/jqTyQRJkpCXl8eAIWqH4UJ0DofDgfT0dDQ3N18yWHxMJhNsNhtKS0sRHR3d9R0k8gNccyE6x8KFC+FyuToULAAgyzJcLhcWLVrUxT0j8h8cuRC1I4RAVlYWjh8/flk7wiRJQkZGBo4ePaqsxxAFM4YLUTvV1dVISEjo1M/HxcVp2CMi/8RpMaJ2GhsbO/XzTqdTo54Q+TeGC1E7ERERnfr5yMhIjXpC5N8YLkTtxMXFITMz87LXTSRJQmZmJmJjY7uoZ0T+heFC1I4kSZgzZ84V/ezcuXO5mE/0PS7oE52Dz7kQdR5HLkTniI6OxpIlSyBJEkymS98ivif0ly5dymAhaofhQnQBubm5yMvLg81mgyRJ5013+dpsNhuWL1+OGTNm6NRTImNiuBBdRG5uLkpLSzF//nxkZGSoXsvIyMD8+fNx5swZBgvRBXDNhagDhBDYt28f/vjHP+Lpp5/GsGHDuHhPdAkcuRB1gCRJiImJQUREBGJiYhgsRD+A4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDkeFkbUQU6nE3v27MGIESMQGRmpd3eIDI3hQtRBXq8XLpcLdrsdISEheneHyNAYLkREpDmuuRARkebMeneASAgBl8sFp9Opd1cCjslkQmxsLMxm3urUvfiOI0PYtm0bli1bBqvVCkmS9O5OQJBlGZIk4amnnkJcXJze3aEgw3AhQ/B4POjbty/uuecehssVkmUZJSUlSE9Ph9lsRnV1Nf7+97+Dy6qkB4YLGUZoaChiY2NhMnEp8HLJsozt27fjk08+wcSJEzFr1iy43W69u0VBjOFC5OeEECgsLMQnn3yCpqYmrF69Go2NjZg6dareXaMgxq+IRH5MCIHi4mIsXrwYTU1NAL4bxZw4cQIul0vn3lEw48iFyE8JIVBeXo6FCxfC4XAo7TExMbj//vsRHh6uX+co6HHkQuSHhBBoaGjA4sWLUV5errSHh4fj3nvvRUZGho69I2K4EPmltrY2fPbZZzhy5IjSZrVaceedd2Lw4MHccUe6Y7gQ+Rmv14tVq1Zhx44dSltISAhmzpyJMWPGcLcdGQLfhUR+RAiBPXv2YOXKlZBlWWmfOHEipk2bxoKaZBgMFyI/IYTA6dOn8emnn6K1tVVpz87Oxk9+8hOEhobq2DsiNYYLkR8QQsDpdOKDDz5AbW2t0p6YmIif/vSnCA8P5zoLGQrDhcgPeDwe/Otf/8KxY8eUNrvdjrvvvhtJSUkMFjIchguRwcmyjM2bN2Pbtm1KW0hICG688UYMGjSIwUKGxHAhMjDfE/hffPEFPB6P0j527Fhcc8013BlGhsV3JpFBCSFQW1uLDz/8UCntAgB9+/bF7NmzuYBPhsZwITIo34OSpaWlSluPHj1w9913IyoqitNhZGgMFyIDkmUZa9aswe7du5U2s9mMW265Bb1792awkOExXIgMRgiBoqIiLF++XPWg5JQpUzBu3Dius5Bf4LuUyECEEKioqMDHH3+MlpYWpX3gwIGYNWsWzGYWMif/wHAhMgghBFwuFz766CNUVlYq7XFxcbjrrrtYQp/8CsOFyCC8Xi+++uorHDhwQGmzWq24/fbbkZqaynUW8isMFyID8D0ouWHDBgghAAAmkwm5ubkYPnw4g4X8DsOFSGdCCBw6dAj/+te/VA9Kjhw5EjNmzGClY/JLDBciHQkhUFZWhsWLF6selOzVqxduv/12WK1WHXtHdOUYLkQ6EUKgvr4eixYtQlVVldIeHR2Nn/3sZ4iJieF0GPkthguRTlpaWvDxxx+rKh37jiru06cPg4X8GsOFSAdutxtffvklvv32W6UtJCQEs2bNwsiRIxks5PcYLkTdzOv1YvXq1Vi/fr2yM0ySJEyZMgXXXnstn8CngMB3MVE3kmUZ27dvx7Jly1Q7w4YPH45bbrmFlY4pYDBciLqJEAIFBQX45JNP0NbWprRnZmbi7rvvhs1m07F3RNpiuBB1AyEEjh49isWLF8PlcintKSkpuP/++xEdHc11FgooDBeiLiaEwKlTp/D++++jvr5eaY+NjcX999+P5ORkBgsFHIYLURcSQuDs2bN47733VM+yRERE4N5770VGRgaDhQISw4WoiwghUFVVhffeew9lZWVKe1hYGO6++24MGjSIwUIBi+FC1AWEEKirq8N7772HkydPKu0WiwW33347rrrqKm45poDGdzeRxoQQaGhowPvvv4/i4mKl3Ww248c//jEmTpzIYKGAx3c4kYaEEGhsbMTChQtx8OBBpT0kJAQzZ87EtddeyyrHFBQYLkQa8Z0kuXjxYhQUFCjtJpMJ06dPx/XXX89jiiloMFyINCCEQHNzMz744APs3r1baTeZTLjmmmtw00038el7CioMF6JO8gXLRx99hJ07dyrtkiRh8uTJmD17NiwWi449JOp+DBeiThBCoLW1FZ9++im2b9+uKkQ5fvx43HbbbbBYLNxyTEGH4UJ0hYQQaGtrw2effYYtW7YowQIAo0ePxp133gmr1cpgoaDEcCG6Qm1tbViyZAk2bdqkCpZRo0bhpz/9KWw2G4OFghbDhegKtLW14YsvvsD69eshy7LSPnz4cNxzzz2w2+0MFgpqDBeiy+Q7RXLNmjWqYMnJycG9996LiIgIBgsFPYYL0WVwu9346quv8PXXX6uCZfDgwbj//vsRGRnJYCECw4Wow9xuN/Ly8rBq1SpVsAwcOBAPPPAAoqKiGCxE32O4EHWA2+3G8uXLsXLlSni9XqV9wIABePDBB9GjRw8GC1E7DBeiH+DxeLBy5UqsWLFCde59VlYWHnzwQcTExDBYiM7BcCG6BI/Hg/z8fOTl5amCpV+/fnjooYcQGxvLYCG6AIYL0UV4PB58/fXXWLZsmSpYMjIy8POf/5zBQnQJDBeiC/B4PFizZg2++uorVbD07dsXDz30EOLj4xksRJfAcCE6h9frxfr16/HFF1/A7XYr7b1798ZDDz2EhIQEBgvRD2C4ELXj9XqxYcMGLF26VBUsvXr1wsMPP4zExEQGC1EHMFyIvuf1erFx40Z8/vnnaGtrU9p79uyJhx56CElJSQwWog5iuBABkGUZmzdvPi9Y0tLS8NBDDyElJYXBQnQZGC4U9HzB8umnn6K1tVVpT01NxcMPP4zU1FQGC9FlYrhQUJNlGVu2bMEnn3yiCpaUlBQ8/PDDSEtLY7AQXQGGCwWtiwVLcnIyHn74YaSnpzNYiK6QWe8OEOnB6/VecCosKSkJDz/8MHr27MlgIeoEhgsFnfa7wi4ULL169WKwEHUSw4WCiu/J+y+//FK1K8wXLL1792awEGmA4UJBQQgBj8eDFStWYPny5aqSLr41Fo5YiLTDcKGAJ4RAa2srvvjiC6xbt051HovvORYu3hNpi+FCAU0IAafTiY8//hg7d+6EEEJ5rXfv3vj5z3/OBySJugDDhQKWEALl5eVYvHgxjhw5onqtf//+eOCBB1jdmKiLMFwoIMmyjAMHDuDDDz9EZWWl6rXhw4fjnnvu4dHERF2I4UIBxbe+snbtWqxYsQLNzc3KayaTCZMmTcLs2bNht9sZLERdiOFCAUOWZZw5cwZLlizBgQMHIMuy8prVasXMmTMxbdo0hIaGMliIuhjDhfyeEAIulwsbNmzA6tWr0dDQoHo9NjYWd9xxB4YPH46QkBCdekkUXBgu5LeEEHC73SgsLMTy5ctRUlKi2g0mSRIGDhyIO++8k5WNiboZw4X8jhACsizjxIkTWL58OQ4cOKB6KBIA7HY7rrvuOkyfPh02m43BQtTNGC7kV4QQqKiowKpVq7Bjxw60tLSoXjeZTOjfvz9+/OMfIyMjAyYTC38T6YHhQn7Bt66yadMmrF69Gg6H47xfk5iYiOuvvx5jxoyB1WrlaIVIRwwXMjxZllFcXIwlS5bg+PHjqnUVAIiMjMSUKVMwdepUPrtCZBAMFzIs3zMrq1evxqpVq+ByuVSvW61WjBo1Crm5uUoJFwYLkTEwXMiQhBCoqanBRx99hMLCQtUzKyaTCVlZWbjpppvQr18/hISEMFSIDIbhQoYjhMCpU6ewcOFCnD59WvVajx49cMMNN2DixIlcVyEyMIYLGc7hw4fx/vvvo6amRmmTJAmDBg3CbbfdhrS0NIYKkcExXMhQDh8+jHfffRf19fVKW2hoKK677jrccMMNfGaFyE8wXMhQLBaLqkSLzWbDrbfeiokTJ8Js5tuVyF/wCTMylL59++KBBx5Ajx49EBkZifvuuw+TJ09msBD5Gd6xZDgDBgzAgw8+CADIzs4GANVuMSIyPoYLGcaJEyfwzjvvqNZUNm/erGOP/FtLSwvcbrfe3aAgxXAhQ8jKyoLX69W7GwEnOzsbdrtd725QEJLEubU0iHTAt2HX4g476m4cuZAh8MOPKLBwtxgREWmO4UJERJpjuBARkeYYLkREpDmGC1EHeb1eOJ1Obpkm6gCGC1EHlZaW4tFHH0VpaaneXSEyPIYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5EHSCEQG1tLRobG1FbWwshhN5dIjI0SfAuIbooh8OBhQsX4s9//jOOHTumtGdmZmLOnDm47777EB0drV8HiQyK4UJ0Efn5+Zg9ezZcLhcAqEYrkiQBAOx2O5YsWYLc3Fxd+khkVAwXogvIz8/HzJkzIYSALMsX/XUmkwmSJCEvL48BQ9QOw4XoHA6HA+np6Whubr5ksPiYTCbYbDaUlpZyiozoe1zQJzrHwoUL4XK5OhQsACDLMlwuFxYtWtTFPSPyHxy5ELUjhEBWVhaOHz9+WTvCJElCRkYGjh49qqzHEAUzhgtRO9XV1UhISOjUz8fFxWnYIyL/xGkxonYaGxs79fNOp1OjnhD5N4YLUTsRERGd+vnIyEiNekLk3xguRO3ExcUhMzPzstdNJElCZmYmYmNju6hnRP6F4ULUjiRJmDNnzhX97Ny5c7mYT/Q9LugTnYPPuRB1HkcuROeIjo7GkiVLIEkSTKZL3yK+J/SXLl3KYCFqh+FCdAG5ubnIy8uDzWaDJEnnTXf52mw2G5YvX44ZM2bo1FMiY2K4EF1Ebm4uSktLMX/+fGRkZKhey8jIwPz583HmzBkGC9EFcM2FqAOEEDh06BAWLlyI++67DwMHDuTiPdElcORC1AGSJCE2NhYxMTGIjY1lsBD9AIYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQdZDdbseYMWNgt9v17gqR4fGwMKIO8nq9cLlcsNvtCAkJ0bs7RIbGcCEiIs1xWoyIiDRn1rsDREIItLS0oLm5We+uBBxJkhAVFcVpPOp2DBcyhP3792Pr1q2wWCx6dyVgCCEgSRLuuusu9OjRQ+/uUJBhuJAheL1epKSkYMaMGZAkSe/u+CWPx4OamhokJCTAZDLB4XAgLy9P725RkGK4kGGYzWZERUUxXK6AEAJ79+7Fpk2bMGLECIwZMwYRERH8tyTdMFyI/JwQAqdPn8amTZvQ0tKC7du3o6qqCmPGjNG7axTEuFuMyI8JIdDY2IjVq1ejpaVF1UakJ45ciPyYLMvYsmULqqurlbbw8HBMnz4dVqtVx55RsOPIhchPCSFw/PhxHDhwQGkLCQnBlClTkJycrGPPiBguRH6rubkZW7ZsgcfjUdoGDRqE7OxsLuST7hguRH5ICIF9+/ahsrJSaYuOjsaECRP4wCQZAsOFyM8IIVBXV4c9e/YobSaTCePGjeNWbjIMhguRnxFC4Ntvv1XtCEtPT8fAgQMZLGQYDBciPyKEQFVVFQ4ePKi0mc1mjB8/HqGhoTr2jEiN4ULkR4QQ2LVrl/JMCwD069cP6enpHLWQoTBciPyEEAIVFRU4evSo0ma1WjF69GiYTLyVyVj4jiTyE0II7N69G21tbUpb//79kZSUxFELGQ7DhcgPCCFQWVmJ4uJipc1qtWLEiBEMFjIkhguRHxBCYM+ePWhtbVXa+vfvj8TERIYLGRLDhcgP1NTUqNZaLBYLhg8fzmAhw2K4EBmcEAIFBQXn7RDjWgsZGcOFyOAcDgcOHTqkXIeGhnKthQyP4UJkYEIIFBUVoampSWnr3bs3kpOTGS5kaAwXIgNzOp3Yv3+/ch0SEoKRI0fyuRYyPL5DiQxKCIGDBw+ioaFBaUtPT0daWhpHLWR4DBcig3K5XCgoKFCuTSYTRowYAbOZB8iS8TFciAxICIEjR47A4XAobcnJyejTpw9HLeQXGC5EBtTa2oq9e/dCCAEAkCQJw4cPZ+Vj8hsMFyKDEULg2LFjqK6uVtri4+PRr18/jlrIbzBciAymra0Ne/bsUY1ahg0bBqvVqnPPiDqO4UJkIEIInDhxAuXl5UpbTEwMBgwYwFEL+RWGC5GBuN1ufPvtt5BlWWkbOnQo7Ha7jr0iunwMFyKDEELg+PHjOHv2rNIWHR2N7OxsjlrI7zBciAyira3tgqOWiIgIHXtFdGUYLkQGIIRAcXHxeaOWwYMHc9RCfonhQmQALS0t2Llzp2rUMnz4cI5ayG8xXIh0JoTA/v37UVVVpbTFxcVx1EJ+jeFCpCMhBBoaGrBr1y7Vcy2jRo3iDjHyawwXIh0JIbBr1y5V5eOUlBTuECO/x3Ah0okQAmVlZSgqKlLaQkJCMG7cOFgsFh17RtR5DBcinbS1tWHLli1obW1V2vr168fKxxQQGC5EOvAdX1xSUqK02e12TJgwASEhITr2jEgbDBeibiaEQHV1NbZv365axL/qqqsQHx/PUQsFBIYLUTdzu93YuHEjmpqalLbU1FQMHz6cwUIBg+FC1I2EECgoKMCJEyeUNqvVismTJ7OkPgUUhgtRNxFC4OzZs9i2bZvqSfwRI0YgPT2doxYKKAwXom7S3NyMtWvXorm5WWlLS0vD6NGjGSwUcBguRN3A6/Vi69atKCsrU9psNhuuueYahIWFMVwo4DBciLqYEAIHDhzAvn37lDaTyYTx48cjNTWVwUIBieFC1IV86ywbN26E1+tV2vv3749hw4YxWChgMVyIuogQAo2Njfj6669V244TEhJwzTXXwGw269g7oq7FcCHqIm63G2vXrkVFRYXSZrPZMG3aNERGRnLUQgGN4ULUBbxeL7755hscOXJEaTOZTJg8eTK3HVNQYLgQaUwIgUOHDmHnzp1KeRfgu5MlhwwZwmChoMBwIdKQEAJnzpzBunXr4PF4lPa+ffti0qRJLEpJQYPhQqQRIQTq6+uxatUquFwupT0+Ph7Tpk2D1WrlqIWCBsOFSCOtra1YvXo1qqurlTabzYbp06cjOjqawUJBheFCpAGPx4MtW7aoClKazWZMnTqVC/gUlBguRJ0khEBhYSH27t173vks2dnZDBYKSgwXok4QQuDkyZPYtGnTeU/gjx07lgv4FLQYLkRXSAiB2tpafP3112hpaVHak5KScO2118JisejYOyJ9MVyIroAQAi6XC6tWrYLD4VDaIyIiMGPGDERERHA6jIIaw4XoCng8HmzYsAGnT59W2kJDQ3HdddchOTmZwUJBj+FCdJlkWcaOHTtw4MABpc1XQj8rK4vBQgSGC9Fl8Z3N8s0336iOKh48eDBGjRoFk4m3FBHAcCHqMCEETp06dV5pl169euHqq69mCX2idhguRB0ghEBFRQXy8/PR3NystMfFxWHGjBmw2WycDiNqh+FC9AOEEKirq8OKFStQX1+vtIeHhyM3NxcxMTEMFqJzMFyILkEIAafTieXLl6Oqqkppt1qtmD59OtLS0hgsRBfAcCG6CN8xxXl5eSgrK1PazWYzpkyZgn79+jFYiC6CK5BEF+AbseTl5ameZfFtOR46dCh3hhFdAsOF6By+si4rVqxQjVhMJhPGjBmD0aNHs2YY0Q9guBC14ztJMj8/HzU1NUq7yWTCVVddhfHjx3PLMVEH8C4hwneh4vV6UVRUhE2bNqm2G/tGLAwWoo7jnUJBz7fVeOvWrTh06JDqyfvQ0FBMmDABo0aNQkhICBfwiTqI4UJBSwiB5uZm7N+/H7t27YLT6VS9brfbMXXqVGRnZ3PxnugyMVwoqPhOinQ6nTh8+DAKCgpQW1urtPskJSVh2rRpSE1N5WiF6AowXCjg+YKjubkZ5eXlOHz4ME6cOIHGxsbzfm1oaChycnIwbtw4hIeHM1iIrhDDhQKOL0zcbjcaGhpw9uxZlJSUoLS0FE6nU7Wm4mMymZCamooJEyagV69ekCSJwULUCQwXMhxfOHT0w10IASEEWltb4XA4UFFRgbKyMpSXl6OhoQFtbW0X/VmTyYSkpCSMHDkS/fr1g8ViYagQaYDhQoZz6NAhVFZWIikpCbGxsbDb7TCbzcqHvtfrRWtrK1wuFxwOB6qrq1FZWYmamhq4XC5VOfyLCQsLQ8+ePTFkyBD06tWLoUKkMYYLGYoQAocPH8aRI0cAfFfHy2KxIDQ0FCaTCUIIeDweuN1uuN3uC05xXYgkSQgLC0NSUhIyMzPRt29f9OjRAyaTiaFC1AUYLmQobW1tqK6uVq49Hk+HRiLnkiQJVqsVsbGxSElJQc+ePZGUlISIiAgGClE3YLiQobhcLrS0tFz2z5nNZtjtdiVMUlJSEB8fj4iICKUOGAOFqPswXMhQoqKicNttt6G6uhoVFRWoq6tDU1OTMgUmSRLMZjPCwsIQERGB6OhoxMXFITY2FlFRUbBarUqIMEyI9MNwIUMxmUxITExEYmIiBg0apNT8ar+2YjKZlKmtSwXIuQ9GBptg//uTvhguZBhnz57FsmXLOOLQSFtbG9xut97doCDFcCFD6NmzZ4d3flHH9e7dG1arVe9uUBCSBMfOZAB8G3Ytjgapu3HkQobADz+iwMI64kREpDmGCxERaY7hQkREmmO4EBGR5hguRB3k9XrhdDrh9Xr17gqR4TFciDqouroa//M//6MqrElEF8ZwISIizTFciIhIcwwXIiLSHMOFiIg0x3AhIiLNMVyIiEhzDBciItIcw4WIiDTHcCEiIs0xXIiISHMMFyIi0hzDhYiINMdwISIizTFciIhIcwwXIiLSHMOFiIg0x3Ah6gAhBGpqalBXV4eamhoIIfTuEpGhSYJ3CdFFORwOLFy4EH/+859x7NgxpT0zMxNz5szBfffdh+joaP06SGRQDBeii8jPz8fs2bPhcrkAQDVakSQJAGC327FkyRLk5ubq0kcio2K4EF1Afn4+Zs6cCSEEZFm+6K8zmUyQJAl5eXkMGKJ2GC5E53A4HEhPT0dzc/Mlg8XHZDLBZrOhtLSUU2RE3+OCPtE5Fi5cCJfL1aFgAQBZluFyubBo0aIu7hmR/+DIhagdIQSysrJw/Pjxy9oRJkkSMjIycPToUWU9hiiYMVyI2qmurkZCQkKnfj4uLk7DHhH5J06LEX3P4/Fg3759nfo9nE6nRr0h8m9mvTtApBev14vi4mIUFhZi3759OHDgABoaGjr1e65ZswYDBgxAamoqUlJSYLPZNOotkX/htBgFDVmWcezYMRQUFKCwsBBFRUVobm5GWFgYBg0ahGHDhmHIkCGYOXMmTpw4cdlP4ffq1Qv//Oc/cfbsWdTX1wMAYmJikJKSooRNWFhYV/zViAyH4UIBS5ZlnDhxAgUFBSgoKEBRURFcLhesVisGDRqEoUOHYujQoejXrx/M5v8bxC9YsACPPfbYZS/oz58/H3PnzgUAuFwunD17FmVlZeeFTWpqKlJTU5GcnMywoYDFcKGAIYTAyZMnUVBQgH379qGoqAhNTU2wWCwYNGgQcnJyMHToUPTv318VJufqiudcmpqalLApKytT1mZiY2NVYWO1Wq/o705kNAwX8ltCCJw6dUo1MnE6nQgNDcXAgQMxbNgw5OTkYMCAAQgNDb2s3/tyn9Bfvnw5ZsyY0eHfv7GxUTWy8YVNXFycKmwsFstl9ZvIKBgu5DeEECgpKUFhYaGybtLQ0ACz2YyBAwcq01wDBgzQ5EO5o7XFli5delnBciFOp1M1smlqaoIkSUrYpKSkMGzIrzBcyLCEEDhz5gz27duHwsJCFBYWwuFwwGw2Y8CAAco0V3Z2dpd96DocDixatAhvvfXWeVWR586di/vuuw89evTQ/M91Op1K0Jw9e1YJm/j4eFXYXO6IjKi7MFzIMIQQKCsrU7YGFxYWoq6uDiEhIcjKysKwYcMwdOhQDBw4sNsXwoUQqK2thdPpRGRkJGJjY7v1SfyGhgZV2LhcLkiShISEBFXYXGotiag7MVxIN0IInD17VpnmKigoQG1tLUwmE7KyspRpruzsbD4vco76+npV2DQ3N8NkMqnCJikpiWFDumG4ULeqqKhQRiUFBQWorq6GJEnIyspSprkGDRoEu92ud1f9isPhUIKmrKwMLS0tMJlMSExMVMImMTGRYUPdhuFCXaqyslI1zVVZWakUefTt5ho8eDDCw8P17mpAqaurU0Y25eXlaGlpQUhIyHlhExISondXKUAxXEhT1dXVyhRXQUEBKioqIEkS+vbti5ycHOUpeIZJ9xFCKGFz9uxZnD17Fq2trQgJCUFSUpJSQSAxMREmE8sNkjYYLtQptbW1qmmus2fPAoASJkOHDsWQIUMQGRmpc0/Jx7c5oX3YtLW1wWw2q8ImISGBYUNXjOFCl6Wurk41zXXmzBkAQO/evTF06FDk5OQgJycHUVFROveUOkoIgZqaGlXYuN1umM1mJCcnK2ETHx/PsKEOY7jQJTkcDuUZk3379qG0tBQA0LNnT2U315AhQ3i8bwCRZVkVNuXl5XC73QgNDVWFTVxcHMOGLorhQioNDQ2qrcElJSUAgPT0dGWaKycnBzExMTr3lLqLLMuorq5WhY3H44HFYjkvbHgKJ/kwXIKc0+lEUVGRMs118uRJAEBqaqoSJEOHDkVsbKy+HSXDkGUZVVVVyrbniooKVdj4aqN194OmZCwMlyDT2NiIoqIiZWRy8uRJCCGQnJysTHPl5OQgPj5e766Sn5BlGZWVlcrIpqKiAl6vF1arFSkpKcrIJiYmhmETRBguAa6pqQn79+9XwuT48eMQQiAxMVEJk6FDh3bq3Hii9rxeLyorK5WRTWVlJbxeL8LCwlQjG06tBjaGS4Bpbm5GUVGRsm5SXFwMIQQSEhJU01xJSUl6d5WChMfjOS9sZFlGWFiY8kBnamoqN4UEGIaLn2tubsbBgwexb98+JUxkWUZsbKxS6DEnJwfJycmckiBD8Hg8qKioUMKmqqoKsizDZrMpQZOamtol1aap+zBc/ExraysOHDigTHMdPXoUXq8XMTExqmmulJQUhgn5BV/Y+MrVVFVVQQgBu92uChs+O+VfGC5+4pNPPsGuXbtw5MgReDweREdHq6a50tLSGCYUENxuN8rLy5WRTXV1NYQQCA8PR0pKCjec+AmGi58oLi4GAERFRSEyMhJhYWEMEwoKHo8HDQ0NcDgcqK+vR0ZGBqfM/ADDhYiINMfaDUREpDmGCxERaS7oj6UTQqCxsRENDQ16dyXg+I7d5emHxiaEQGtrK1paWvTuSsAxmUyIiIgIygKfvOsBrF27Fh999BEXyTUkyzIkScKrr76KxMREvbtDP6C4uBi7d+9GaGio3l0JGEIISJKEG2+8MSjPM2K44LvdKP3798cvf/lLhotGKioq8Prrr4P7RfyD1+tFQkICJk2axHvgCgghlKOkQ0NDIUkSnE4n1q1bp3fXdMNw+Z7FYgmKk/eEEHC73Th8+DD27t2Lqqoq2Gw2DBo0CMOHD0dUVJQmHy5ut1uD3lJ3MpvNiIiIYLhcAVmWsWPHDmWrdN++fWGz2YL635LhEkSEEDh58iQWL16MPXv2oK2tTXktLy8PvXv3xs9+9jOMHj0aISEhOvaU9OZbh7FarUH9AdlR9fX1KC0tRVtbG2pqalBcXIzJkyfr3S1dBfbXdFLIsoxdu3bh+eefxzfffKMKFuD/gue1117DypUr4fV6deop6a2trQ179+5FXl4e6uvrObX5A4QQOHHihOqeSkhIgNVq1bFX+mO4BAEhBPbs2YM333wTVVVVqtfMZrPqm2lzczPee+89bN26lR8qQai2tharVq3Crl27UFtbi507d/KLxg9wu904ceKEcm0ymZCVlaVjj4yB4RLghBA4deoU3n77bdTX1yvt4eHhuPXWW/Hyyy9jzpw5qhL8LS0t+Pvf/47Tp08zYIJMS0sLqqurleuSkhKcOHGC74OLEEKgqqoKDodDaYuNjeX5SGC4BLzGxkb89a9/RUVFhdIWExODX/3qV7j33nsxePBgzJgxA7///e+RkpKi/JqqqiosWrTovOkzCmwpKSnIzs5WrmVZRkFBAVpbW3XslbGdPHkSsiwr13369OGzXWC4BDSv14svv/wSRUVFSlt4eDgeeeQR1aK9JEno27cvfvGLX8Butyu/dufOndi2bRu/tQYRSZKQk5OjOrirtrZWOQ6b1FpbW1FaWqpch4aGonfv3twEAYZLwBJCoLi4GMuWLVM+FEwmE2677TaMHj36vDe/JEkYPnw4brjhBuU1j8eDzz//HE6ns9v7T/qx2WwYMmSIqu3w4cPweDw69ciYfFNijY2NSlt8fDwrNn+P4RKg2tra8OGHH6re+CNHjsSNN9540W3GISEh+PGPf4z09HSl7eTJk1i/fj2/tQYR30i2/eiluroaFRUVfB+co6SkRDUl1rt374B/Vq6j+K8QgIQQ2LFjB/bu3au0RUVF4Wc/+xnCwsIu+bPR0dG45ZZblBtECKFsSaXgYbVakZmZqVzLsoxjx44xXNppa2tDWVmZch0aGspD+9phuAQgl8uFpUuXKtMYkiThRz/6ETIyMn7wjS9JEiZNmqT6YDlz5gw2b97MD5YgIkkSMjIyVM9qlJaWwuVy6dgr4xBCoLa2VlXwNjY2lkcxt8NwCTBCCGzbtk05uRIAkpOTMXPmzA4P1+12O2688UbV6GXlypVoamrqkj6TMUVFRSE5OVm5drlcOHv2LL9kfO/MmTOqKbH09HRWtmiH4RJgXC4Xli1bprzpJUnCTTfdhNjY2A7/HpIkYezYsejdu7fSVlJSgt27d/ODJYj41l7a466x73i9Xpw5c0a5DgkJQXp6OqfE2mG4BBDfWkv7p4V79uyJa6655rLf9BEREcjNzVV+zuv1YuXKlSxIGUQkSUJKSopqe3pFRQWnxgA4nU7U1dUp11FRUaoNEMRwCSitra1Yvny5Uq7Dt9ZyJfPAkiRhwoQJqrNYDh48iCNHjvCbaxCx2+2qqbHm5maUl5cH9XtACIHy8nLVF62UlBSehXMOhkuAEEKgqKgIR44cUdqSk5MxefLkKx6qx8TEqCq7trW1YfXq1ap5ZgpskiShV69eqraSkpKgD5f2U2KSJCEtLU3HHhkTwyVAeL1e5Ofnqx50mzZtWqeG6pIkYerUqYiIiFDadu7cicrKys50lfyIJElITk5WbWGvqKgI6nIwra2tqgKwYWFhiI+P53rLORguAeLUqVOq51piYmJw9dVXd+oNL0kS0tPTMXz4cKXN4XBgy5YtQf3NNdiEh4cjPj5euXa5XKipqdGxR/qqqalRrTvFx8er1qXoOwyXACDLMtatW6d6w48bN06Ts+tDQkIwbdo0VSG+DRs2cFE3iPi+ZPjIsowzZ84E5RcMIQTOnj2rmhpOTU3lqOUCGC4BwOFwYOvWrcq11WrFtGnTNClDIUkSBg8efN625KKioqD8cAlGvl1j7b9glJWVBeU5L16vF2fPnlWuQ0JCkJKSwnC5AIaLnxNCYNeuXap1kOzsbGRmZmr2hrfZbJg6daqqoOWaNWuC8sMlWPXo0UO167C+vl71dHqwaGpqUm1BjoiIYKHKi2C4+Dm3241169YpowhJknDddddpep6EJEkYP3686ibat2+fascMBTaz2azakux2u1FZWRlUo1dfFeT2ZxwlJSVxC/JFMFz8mO/s7nO3H48cOVLzYXpCQgJGjx6tXDc2NmLjxo1B9eES7M4tyhiM6y7tC1UC36230IUxXPzcpk2b0NLSolyPGzeuS4rnmUwmXHvttbBYLErb5s2bedZLkJAkCfHx8apClud+iw90vtGaj8ViQUJCAtdbLoLh4scaGhqwfft25TosLAxTpkzpkje7JEno378/+vXrp7SVlZVh7969QfftNVjZbDZVjbqmpibV2fGBzul0qr5M9ejRQ/UMGKkxXPyUEAIFBQWoqKhQ2vr3748+ffp02Tcpq9WKa6+9Vvn9ZVnGmjVreEJhkDCZTEhJSVGuZVkOmlIwQghUVFSo3uvJycmsgnwJDBc/JcsyNm7cqKp+PGXKlC5dXJQkCaNHj1Y9UFdUVITjx48HxQdMsPM9rd9+i3swhUv7Lci+7dl0cQwXP1VeXo7CwkLlOiYmBqNGjery+d/Y2FhMmDBBuW5pacGaNWuC4gOGvnuftX8avaamRrXmF6ja2tpUJV+sVivi4uK43nIJDBc/JITAzp07VfO/I0aMQFxcXJf/2b6FfZvNprRt27aN9caChO9D1ae5uRm1tbUB/+Wivr5edVhebGys6h6g8zFc/FBbWxu2bNmiXJvNZkyaNEmTJ/I7onfv3hg2bJhyXVdXx23JQcI3NebjKz8fyHx/x/YlX86dHqTz8V/HzwghcOrUKRw/flxpS0lJQXZ2drcN0c1mM3Jzc5UHNYUQWL16Nerr67vlzyf9+MKl/UL2uR+8gebc9RbfxgZOiV0aw8UPbdu2TTXPPWbMmG7dEilJEnJycpCVlaW0lZWVYfPmzRy9BIEePXogPDxcua6rq0Nzc7OOPepaLS0tqirQdrsdMTExOvbIPzBc/IzL5cI333yjXFssFtUCe3cJCwvDj370I2VqQAiB5cuXB2W9qWATGhqq2jHY2toa0CX4a2pqVOEZFxenepiULozh4keEEDhy5Iiqplffvn279NmWi5EkCWPHjkWfPn2UtpKSEmzYsIGjlwB37jZc37RRIP5/9623tP+7cUqsYxgufkQIgW3btqke5Bo/frxu36LCw8Nx0003qUYvX375Jaqrq3XpD3UPSZKQmJioKo5aUVERkFWyZVk+r8R+cnIyw6UDGC5+xOl0Yvfu3cq13W7H6NGjdXujS5KECRMmqErClJeX48svvwzoBV4CoqKiVOt89fX1AXmA3LklbiIiIrqkdl8gYrj4CSEEDh48qHqeJCsrC2lpaTr26rvRy2233aaqDLB582aOXgJcaGgoEhISlOvW1lZUV1cH1NSYEALV1dVobW1V2hITE1XFW+niGC4XIIRQ/jMKWZaxZcsWZerBN2rQ8tyWKyFJEq666iqMGTMGZrMZI0aMwK9+9atueaCT9HVu+ZP200eB4ty/E0vsd5y+n0wGJMsySktLsW7dOtx4442IjY01xPxqXV0d9u3bp1xHRkZ2ybktVyI0NBT33HMPJk2ahDFjxsBqtZ537gUFFkmSkJCQgNDQULjdbgBAZWUlvF6v7l94tOLxeFQPiPpGa0a45/xBYLwLNOJwOPDvf/8b+fn5qK+vhyRJuOeee3R/MwkhUFhYiNraWqUtOzsbiYmJOvbq/0iShJ49e6Jnz566/1tR94mMjERUVJSyDbmhoQGNjY2Ijo7Wt2MaaWhoUG2t79GjByIjI3XskX/htFg7xcXFWLp0KRwOB4QQyM/PR2lpqe7TY74psfZHGU+cONFQ5b4lSWKwBBmz2az6guMr7qj3/aIFltjvPIZLO0OHDlXVzHI4HFi2bJnuO58qKytx4MAB5TomJgbDhg3jhznpLlDXXYQQqqldSZK43nKZGC7tWCwW3HbbbQgLC1PaNm3apHposbsJIbB7927V8Hzo0KEsP0G68x193H73VGVlpbIG489aW1tVJfbDwsJYYv8yMVzOMXDgQIwePVq5djqdWLVqlW6jF4/Hg61btypTDSaTCRMnTmRFVjKE8PBw9OjRQ7k+9yhgf1VbW6t6bicuLk51jg39MH5CnSMkJAQ33nij6qn3zZs3qxbTu1NZWRmOHj2qXCcmJmLw4MH8BkWGEBISgqSkJOXa4/H4/bqLb0qs/RfK1NRU3nOXieFyDkmSMGDAAAwZMkRpq66uxrZt27r9hvEdCtb+kKKRI0dyxwoZyrnrLv6+Dd3r9Z5X8oX1xC4fw+UCzGYzZsyYoewMEUJg3bp1qid1u0Nrayu2bdum6teECRP4JifDkCQJcXFxqnXKysrKbr9XtOR0OlFXV6dcR0ZGBsz26u7EcLkASZIwbNgwVWmV48eP4/Dhw902evEdCnbixAmlLTU1Ff3792e4kKHY7XbExsYq1+fW4/Invi3IbW1tSltKSoqqvBF1DMPlIiIiIjB58mTl2u12d3s5+e3bt6u+AY4ZM4aLimQ4vpMZfWRZRllZmV+uuwghcPr0aeVakiTd6/f5K4bLRfgeVGx/4t6uXbu6bWHf5XJhx44dyrXFYsG4ceM4aiFDSklJUe1gPHdB3F80NzerisPabDYkJibyvrsCDJdLSEtLUy3s19bWYu/evV3+jcx3KFhpaanS1qdPH/Tt27dL/1yiKyFJEmJjY1Ul+Gtra1UbUfyBEAKVlZWqUycTExNhs9l07JX/YrhcQkhICKZMmaJ8axFCYOPGjaqSEF1BCIEtW7ao/pwJEybwaFUyLIvFotqS3NraioqKCr+bGispKVH1mfXyrhzD5RJ8C/vtz604dOhQl5e4qK+vVx0KFh4ejjFjxvBNToaWnp6uuj59+rRfhUtLS4vq3rZardyC3AkMlx/Qo0cPjBo1SrluamrCjh07uuymEUKgqKhIVXpiwIABrGtEhiZJEpKSklRbkisqKtDS0qJjrzrONyXW2NiotMXHx6um+ujyMFx+gG9hv/0ZFVu3bu2yffyyLGPjxo3KYqgkSZg0aVLAnJFBgSs8PFw1ym9qavKbp/WFEDhx4oSqr3369GGZpU7gv9wPkCQJ/fv3V21HPHHiBE6ePNklN015eTkKCwuV65iYGIwYMYJDczI8SZLQq1cv5VoIgZKSEh171HHNzc2qygJWqxVpaWm87zqB4dIBdrsdY8eOVa7b2tpUT85rRQiBHTt2qIbmw4cP55HB5Bd8ZenbV0k+c+aM4afGhBA4c+aMandbUlISyyx1EsOlg8aNG6farbVjxw7Nt1q2trZi06ZNyojIbDZj8uTJHJqT34iMjFRNjTU2NqK8vNzQU2OyLOPYsWOqtoyMDI5aOomfWh0gSRJ69+6NjIwMpa2srAxHjhzR7KYRQqC4uFhV7iUtLQ2DBg3im5z8hslkQp8+fZTrC61lGIkQAnV1daioqFDaIiIiOCWmAYZLB1mtVowfP1659ng82Lx5s6bhsmHDBlVNowkTJqgqBBAZnSRJSE9PV+0aKysrU031Gk1xcbHqgLNevXrxwUkNMFw6SJIkjB49WvVhv2fPHtTX12vy+9fW1mLnzp3Ktd1ux8SJE/ntifxORESEaut8c3PzeQ8nGoXL5VLNFpjNZvTr10/HHgUOhstlSElJwYABA5Tr6upqFBUVdfqm8Z3bUl1drbQNHjz4vIfSiPyBJEnIzMxUfTEqLi7u8soWl0sIgePHj6tGVUlJSYiPj+eXOg0wXC6D2WzGpEmTlDeeLMvYvHlzpwv0tba2Yu3ataqjjKdOncpnW8gvSZKElJQU1RkoNTU1hlvYb21txeHDh5VrSZIwcOBAbqDRCP8VL4MkSRgxYoTqzPCioiJVFdXL5StSWVxcrLSlpKRg+PDh/PZEfstisSAzM1O5lmUZhw4dMkylZN+opf2hYHFxcUhPT+d9pxGGy2WKi4vD0KFDlev6+nrs2rXrir+RybKM1atXqxbyJ0+ejKioqE73lUgvvqmx9gvjpaWlqK6uNsTopbm5GUVFRcq1JEkYNGgQDwXTEMPlMplMJkyZMkV1BPKmTZtU4dBRQgicPXtWtZAfGRmJq6++mt+eyO9FRESojonweDzYv3+/7uEihMChQ4dUm3Hi4uLQp08f3ncaYrhcJkmSMHjwYCQnJyttxcXFOH78+BXdNGvXrkVDQ4NyPXLkSJ58RwHBt4bR/on9U6dO6VqKXwiB2tpa7N+/X2kzmUzIyclR9ZM6j+FyBSIjI1XPvLS2tl7REcg1NTVYv369cm2xWJCbm8sFRQoIkiQhJiZG9fCxx+PB3r174fV6demTx+PBrl27VCVpUlJS0Lt3b45aNMZPsSs0efJk1Xzy9u3bL+sIZCEE1q9fr9oMkJ2djYEDB/JNTgFDkiQMGTLkvIcqr3Sk3xlCCBw8eBCnT59W2iwWC0aOHMmdmV2A4XIFfOVgBg0apLRVV1dj+/btHb5h6urqsHLlSlUdsZkzZ3JoTgFFkiRER0cjOztbaZNlGbt370ZDQ0O3BYyvOOWePXtUf+agQYOQmJjIL3RdgOFyhcxmM6ZNm6ZMYQkhsHr1atX52xcjhMDXX3+N8vJypS0rK4ul9SlgDR48GLGxscq10+nEN998oyq70lWEEKipqcHmzZtVG2+SkpKQk5PDaeguwn/VK+R75qVnz55K2/Hjx7F79+5LfhsTQqC8vBzLly9XjVpuvvlm1jOigCRJEsLCwjB69GjV9FNJSUmXr7/4gmXdunVwOp1Ku91ux4QJE1SVzklbDJdOiIiIwPTp05XRhtfrxVdffXXJ8yu8Xi8+//xzVamXQYMGYfTo0Ry1UMDyFbQcPHiw0iaEQGFhIQoLC7skYGRZRmlpKVavXg2Hw6G0WywWTJgwAXFxcbznuhDDpRMkScLkyZORmJiotB0+fPiiay9CCOzevVu1Q8xqteK2227jNygKeCaTCcOGDVON9mVZxrfffovdu3fD7XZrsgYjhEBLSwv27t2LtWvXqkYsZrMZY8aM4e6wbsBw6aS4uDhcf/31yhvV4/Hgs88+Q11dnepGEUKgsrIS77//vmpkM2nSJOTk5PCNTkHBYrFg4sSJqgPFZFnGvn37sHbtWuW+uZKQEULA7XbjxIkTWLlyJb799lvVGktoaCjGjRuHAQMGcJ2lG/BfuJMkScL06dNVFYxLSkrwwQcfKIuVQgg0NDTgL3/5i+pM8aSkJNx5553cBklBQ5IkRERE4JprrkF8fLzSLoRASUkJ8vLy8M0336Curg6yLP9gyAghIMsympqacPjwYSxfvhzr1q1DVVWV6tdFRETg6quvZrB0I36qaSA6Ohq33347FixYAI/Ho+wci4yMxM0334y6ujr84x//wO7du5WfsVgsuPfee5GSksJRCwUVSZLQo0cPTJs2DZs3b0ZpaanyWktLCwoLC3H48GEkJSUhPT0dCQkJCA8PR2hoKCRJUkYoLpcLNTU1KCsrQ3l5OVwu1wX/rLS0NIwdOxYxMTG817oRw0UDkiRh0qRJ2LNnD9auXQvgu+mxzz//HOvWrUNzczOampqUX28ymTBr1ixV+X6iYOIbwVx77bUoKCjAgQMHVFNYbW1tOH36NE6fPg2TyQSLxYLQ0FCYTCbIsgy32422trZLVlmOiorC0KFD0a9fP5jNZt5r3YzhopHQ0FDcf//9KC8vx4EDBwB8N2RvvysM+C5Ypk+fjjvvvFMpfkkUjCRJgtVqxahRo9CrVy/s27cPZ86cOe9QMVmW0dLScsldmO1/z6ioKAwYMABZWVmw2WwMFZ0wXDQiSRJiY2Px5JNP4u2338bu3bvP+1Zlt9sxa9Ys3HrrrQgLC+ObngjffeFKTEzEddddh6qqKhw9ehSlpaVoamrq0MK+7zmapKQkZGRkIC0tDVarlfeXzhguGpIkCQkJCXjqqaewdetWbNy4ERUVFbBYLOjfvz+mT5+OrKwsjliIziFJEkJCQpCUlISkpCS0tLSgtrYWFRUVqK2tRVNTkzINZjKZEBoaivDwcMTExCAhIQFxcXGw2+2QJImhYhAMl3Z8O086KywsDNdeey2uvvpquN1u5WZofzxyoNP7zA66Mkb5/xYWFobU1FSkpqYq92X7+8ZkMsFkMl0wSIzydwh2DJfvHTlyBPPmzeO3Ho24XK4rOkCN9FNZWYl169bp3Y2A4Xa7z1s/CiYMF3xXVC+Y3wRdZfjw4QgPD9e7G9QBycnJQTGi7m6pqalBW+lcEhxDchjdxTgaND7eA10rGO8BhgsREWmOdRCIiEhzDBciItIcw4WIiDTHcCEiIs0xXPyE1+tFU1NTlx4JS2R0Xq8XTqeT94EfYLj4iZMnT+L222/HyZMn9e4KkW7q6urw8ccfo66uTu+u0A9guBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7h4geEEKitrUVzczNqa2shhNC7S0TdTgiBmpoaVFdXo6amhveBwUmC/4cMy+FwYOHChfjzn/+MY8eOKe2ZmZmYM2cO7rvvPkRHR+vXQaJuwPvAPzFcDCo/Px+zZ8+Gy+UCANW3NEmSAAB2ux1LlixBbm6uLn0k6mq8D/wXw8WA8vPzMXPmTAghIMvyRX+dyWSCJEnIy8vjjUUBh/eBf2O4GIzD4UB6ejqam5sveUP5mEwm2Gw2lJaWcmqAAgbvA//HBX2DWbhwIVwuV4duKACQZRkulwuLFi3q4p4RdR/eB/6PIxcDEUIgKysLx48fv6ydMJIkISMjA0ePHlXmoYn8Fe+DwMBwMZDq6mokJCR06ufj4uI07BFR9+N9EBg4LWYgjY2Nnfp5p9OpUU+I9MP7IDAwXAwkIiKiUz8fGRmpUU+I9MP7IDAwXAwkLi4OmZmZlz1fLEkSMjMzERsb20U9I+o+vA8CA8PFQCRJwpw5c67oZ+fOnctFTAoIvA8CAxf0DYb7+4l4HwQCjlwMJjo6GkuWLIEkSTCZLv2/x/dk8tKlS3lDUUDhfeD/GC4GlJubi7y8PNhsNkiSdN4w39dms9mwfPlyzJgxQ6eeEnUd3gf+jeFiULm5uSgtLcX8+fORkZGhei0jIwPz58/HmTNneENRQON94L+45uIHfOe5OJ1OREZGIjY2louWFHR4H/gXhgsREWmO02JERKQ5hgsREWmO4UJERJpjuBARkeYYLkREpDmGCxERaY7hQkREmmO4EBGR5hguRESkOYYLERFpjuFCRESaY7gQEZHmGC5ERKQ5hgsREWmO4UJERJr7/0EAd3LFuAP9AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb deleted file mode 100644 index 541090443..000000000 --- a/docs/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb +++ /dev/null @@ -1,324 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 11: Unsupervised learning" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "### In this example, we will use KAN for unsupervised learning. Instead of trying to figure out how a target variable $y$ depends on input variables, we treat all variables on the equal footing (as input variables). Below we contruct a synthetic dataset where we have six variables $x_1, x_2, x_3, x_4, x_5, x_6$. $(x_1, x_2, x_3)$ are dependent such that $x_3={\\rm exp}({\\rm sin}(\\pi x_1)+x_2^2)$; $(x_4,x_5)$ are dependent such that $x_5=x_4^3$. And $x_6$ is independent of all other variables. Can we use KANs to discover these dependent groups?\n", - "\n", - "### The idea is that we treat the problem as a classification problem. The dataset that satisfies these interdependent relations are 'positive' samples, while corrupted samples (by random permutation of features across samples) are 'negative' samples. We want to train a KAN to output 1 when it is a positive sample, and output 0 when it is a negative sample. We set the last layer activation to be Gaussian, so positive samples will have zero activation in the second to last layer, while negtive samples will have non-zero activation in the second to last layer. We can then define the relation implicitly as $g=0$ where $g$ is the activation in the second to last layer." - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "### Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [], - "source": [ - "from kan import KAN\n", - "import torch\n", - "import copy\n", - "\n", - "\n", - "seed = 1\n", - "\n", - "model = KAN(width=[6,1,1], grid=3, k=3, seed=seed)\n", - "\n", - "# create dataset\n", - "\n", - "\n", - "def create_dataset(train_num=500, test_num=500):\n", - " \n", - " def generate_contrastive(x):\n", - " # positive samples\n", - " batch = x.shape[0]\n", - " x[:,2] = torch.exp(torch.sin(torch.pi*x[:,0])+x[:,1]**2)\n", - " x[:,3] = x[:,4]**3\n", - "\n", - " # negative samples\n", - " def corrupt(tensor):\n", - " y = copy.deepcopy(tensor)\n", - " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", - " return y\n", - "\n", - " x_cor = corrupt(x)\n", - " x = torch.cat([x, x_cor], dim=0)\n", - " y = torch.cat([torch.ones(batch,), torch.zeros(batch,)], dim=0)[:,None]\n", - " return x, y\n", - " \n", - " x = torch.rand(train_num, 6) * 2 - 1\n", - " x_train, y_train = generate_contrastive(x)\n", - " \n", - " x = torch.rand(test_num, 6) * 2 - 1\n", - " x_test, y_test = generate_contrastive(x)\n", - " \n", - " dataset = {}\n", - " dataset['train_input'] = x_train\n", - " dataset['test_input'] = x_test\n", - " dataset['train_label'] = y_train\n", - " dataset['test_label'] = y_test\n", - " return dataset\n", - "\n", - "dataset = create_dataset()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "79665292", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "45760ca2", - "metadata": {}, - "outputs": [], - "source": [ - "# set the (1,0,0) activation to be gausssian\n", - "#model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d951ae17", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "aa26622b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.66e-01 | test loss: 1.49e-01 | reg: 7.61e+00 : 100%|██| 50/50 [00:16<00:00, 3.12it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=50, lamb=0.002, lamb_entropy=10.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9d162e40", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "b828d97a", - "metadata": {}, - "source": [ - "### This gives the dependence among $(x_1,x_2,x_3)$. Another random seed can give dependence among $(x_4,x_5)$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "abf1936d", - "metadata": {}, - "outputs": [], - "source": [ - "seed = 42\n", - "model = KAN(width=[6,1,1], grid=3, k=3, seed=seed, noise_scale_base=1.0)\n", - "dataset = create_dataset()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "23b9c0d3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7992b551", - "metadata": {}, - "outputs": [], - "source": [ - "# set the (1,0,0) activation to be gausssian\n", - "#model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d9b19eba", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c6a28a6c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.83e-02 | test loss: 1.19e-01 | reg: 1.28e+01 : 100%|█| 100/100 [00:26<00:00, 3.73it/s\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=100, lamb=0.001, lamb_entropy=10.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "150e592b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ce90a441", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb deleted file mode 100644 index 4438cc308..000000000 --- a/docs/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb +++ /dev/null @@ -1,192 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 13: Phase transition" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "### In this example, we will use KAN to learn phase transitions in data. Phase transition is an important concept in science. We consider a toy example $f(x_1,x_2,x_3)$ is 1 if $g(x_1,x_2,x_3)>0$, and is 0 if $g(x_1,x_2,x_3)<0$. $g(x_1,x_2,x_3)={\\rm sin}(\\pi x_1)+{\\rm cos}(\\pi x_2)+{\\rm tan}(\\frac{\\pi}{2}x_3)$." - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "### Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "\n", - "model = KAN(width=[3,1,1], grid=3, k=3)\n", - "\n", - "# create dataset\n", - "f = lambda x: (torch.sin(torch.pi*x[:,[0]]) + torch.cos(torch.pi*x[:,[1]]) + torch.tan(torch.pi/2*x[:,[2]]) > 0).float()\n", - "dataset = create_dataset(f, n_var=3)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3837440b", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.4870, dtype=torch.float32)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "torch.mean(dataset['train_label'])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fe38f7c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8627b850", - "metadata": {}, - "outputs": [], - "source": [ - "# set the last activation to be sigmoid\n", - "model.fix_symbolic(1,0,0,'sigmoid',fit_params_bool=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3957140b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "be0b0daf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.71e-02 | test loss: 8.77e-02 | reg: 8.55e+00 : 100%|██| 50/50 [00:07<00:00, 6.54it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=50, lamb=0.001, lamb_entropy=10.);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2f9b37a8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d6d85bda", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_1_function_fitting_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_1_function_fitting_-checkpoint.ipynb deleted file mode 100644 index 29c4ca2df..000000000 --- a/docs/.ipynb_checkpoints/Example_1_function_fitting_-checkpoint.ipynb +++ /dev/null @@ -1,261 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 1: Function Fitting\n", - "\n", - "### In this example, we will cover how to leverage grid refinement to maximimze KANs' ability to fit functions" - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "### intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [], - "source": [ - "from kan import *\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3)\n", - "\n", - "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)" - ] - }, - { - "cell_type": "markdown", - "id": "cb1f817e", - "metadata": {}, - "source": [ - "### Train KAN (grid=3)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a87b97b0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.54e-02 | test loss: 1.50e-02 | reg: 3.01e+00 : 100%|██| 20/20 [00:03<00:00, 6.45it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "52294efd", - "metadata": {}, - "source": [ - "### The loss plateaus - we want a more fine-grained KAN!" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f1cfc9d", - "metadata": {}, - "outputs": [], - "source": [ - "# initialize a more fine-grained KAN with G=10\n", - "model2 = KAN(width=[2,1,1], grid=10, k=3)\n", - "# initialize model2 from model\n", - "model2.initialize_from_another_model(model, dataset['train_input']);" - ] - }, - { - "cell_type": "markdown", - "id": "f3cc5079", - "metadata": {}, - "source": [ - "### Train KAN (grid=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "898b1794", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.18e-04 | test loss: 3.29e-04 | reg: 3.00e+00 : 100%|██| 20/20 [00:02<00:00, 6.87it/s]\n" - ] - } - ], - "source": [ - "model2.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "bcdc0d3d", - "metadata": {}, - "source": [ - "### The loss becomes lower, which is good! Now we can even iteratively making grids finer." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "a1c25e8a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.73e-03 | test loss: 6.62e-03 | reg: 2.86e+00 : 100%|██| 50/50 [00:06<00:00, 7.28it/s]\n", - "train loss: 4.32e-04 | test loss: 4.15e-04 | reg: 2.89e+00 : 100%|██| 50/50 [00:07<00:00, 6.93it/s]\n", - "train loss: 4.59e-05 | test loss: 4.51e-05 | reg: 2.88e+00 : 100%|██| 50/50 [00:12<00:00, 4.01it/s]\n", - "train loss: 4.19e-06 | test loss: 1.04e-05 | reg: 2.88e+00 : 100%|██| 50/50 [00:30<00:00, 1.63it/s]\n", - "train loss: 1.62e-06 | test loss: 8.17e-06 | reg: 2.88e+00 : 100%|██| 50/50 [00:40<00:00, 1.24it/s]\n" - ] - } - ], - "source": [ - "grids = np.array([5,10,20,50,100])\n", - "\n", - "train_losses = []\n", - "test_losses = []\n", - "steps = 50\n", - "k = 3\n", - "\n", - "for i in range(grids.shape[0]):\n", - " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k)\n", - " if i != 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k).initialize_from_another_model(model, dataset['train_input'])\n", - " results = model.train(dataset, opt=\"LBFGS\", steps=steps, stop_grid_update_step=30)\n", - " train_losses += results['train_loss']\n", - " test_losses += results['test_loss']\n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "6be8ba55", - "metadata": {}, - "source": [ - "### Training dynamics of losses display staircase structures (loss suddenly drops after grid refinement)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "156f68a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(train_losses)\n", - "plt.plot(test_losses)\n", - "plt.legend(['train', 'test'])\n", - "plt.ylabel('RMSE')\n", - "plt.xlabel('step')\n", - "plt.yscale('log')" - ] - }, - { - "cell_type": "markdown", - "id": "6ed8d26b", - "metadata": {}, - "source": [ - "### neural scaling laws" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "8301085c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'RMSE')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAG2CAYAAACTTOmSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB3JElEQVR4nO3dd3xN9x/H8dfNzd4ihBBJrBIxI0ZsVauluocSo2rVqFmjVWq0aNEKake1RVuj7a9WB0HMEBWxhRghRmTPe8/vj9QljRDc5Nwkn+fjcR/cc88953NTdd++U6MoioIQQgghRAlkpnYBQgghhBBqkSAkhBBCiBJLgpAQQgghSiwJQkIIIYQosSQICSGEEKLEkiAkhBBCiBJLgpAQQgghSiwJQkIIIYQosSQICSGEEKLEMle7AFOn1+u5evUqDg4OaDQatcsRQgghRD4oikJiYiLu7u6YmeXd7iNB6BGuXr2Kh4eH2mUIIYQQ4glcunSJihUr5vl6sQ9Cly5dokePHsTGxmJubs5HH33Ea6+9lu/3Ozg4GK7j6OhYUGUKIYQQwogSEhLw8PAwfI/nRVPcN12NiYnh+vXr1KtXj9jYWBo0aMCpU6ews7PL1/sTEhJwcnIiPj5egpAQQghRROT3+7vYtwiVL1+e8uXLA1C2bFlcXFy4fft2voOQEEIIIYov1WeNhYSE0KVLF9zd3dFoNGzcuDHXOQsWLMDb2xtra2v8/PzYtWvXE93r0KFD6PV6GfMjhBBCCMAEWoSSk5OpW7cuvXv35pVXXsn1+tq1axk+fDgLFiygWbNmfPPNN3Tq1InIyEgqVaoEgJ+fH+np6bneu23bNtzd3QG4desWPXv2ZOnSpQ+tJz09Pce1EhISnubjCSGEEHnS6XRkZmaqXUaRZGFhgVarferrmNQYIY1Gw4YNG+jWrZvhWOPGjWnQoAELFy40HKtZsybdunVjxowZ+bpueno6zz33HP369aNHjx4PPfeTTz5h8uTJuY7LGCEhhBDGoigK165d486dO2qXUqQ5OztTrly5By5vUyzGCGVkZBAWFsaHH36Y43j79u0JDQ3N1zUURaFXr160bdv2kSEIYNy4cYwYMcLw/O6ocyGEEMJY7oagsmXLYmtrK+vUPSZFUUhJSSE2NhbAMBb4SZh0ELp58yY6nQ43N7ccx93c3Lh27Vq+rrFnzx7Wrl1LnTp1DOOPvv32W2rXrv3A862srLCysnqquoUQQoi86HQ6QwgqXbq02uUUWTY2NgDExsZStmzZJ+4mM+kgdNd/k7KiKPlOz82bN0ev1z/2PYOCgggKCkKn0z32e4UQQoi83B0TZGtrq3IlRd/dn2FmZuYTByHVZ409jKurK1qtNlfrT2xsbK5WImMbPHgwkZGRHDx4sEDvI4QQomSS7rCnZ4yfoUkHIUtLS/z8/Ni+fXuO49u3bycgIEClqp6eTq+w99wtNoVfYe+5W+j0JjNeXQghhChRVO8aS0pK4uzZs4bnUVFRhIeH4+LiQqVKlRgxYgQ9evSgYcOGNG3alMWLFxMdHc2AAQMKtK6C6hrbEhHDp78cwyPpKGW5QyzOXLKvy0dda9PR98kHewkhhBDi8akehA4dOkSbNm0Mz+/O2AoMDGTlypW88cYb3Lp1iylTphATE4Ovry+///47np6eBVrX4MGDGTx4sGH6nTFsiYhh4/eL+NFiFe6Wtw3Hr6a7MOX7nvD2AAlDQggh8k2nVzgQdZvYxDTKOljTyNsFrVnR6HLz8vJi+PDhDB8+XNU6VA9CrVu35lFLGQ0aNIhBgwYVUkUFQ6dX2LFxOQss5uZ6rRy3WWAxl/EbLXnOZ3yR+UMshBBCPVsiYpj8ayQx8WmGY+WdrJnUxafA/lHdunVr6tWrx9y5c5/6WgcPHjSJ7a5MeoyQmoKCgvDx8cHf398o1ztw7gZDM7NXtf5vzrn7fGjmMg6cu2GU+wkhhCi+tkTEMHD14RwhCOBafBoDVx9mS0SMKnUpikJWVla+zi1TpoxJzJyTIJQHY88a013Yg7vmdq4QdJeZBtw1t9Bd2GOU+wkhhCg6FEUhJSMrX4/EtEwm/XKcB/Wl3D32yS+RJKZl5ut6+d1golevXuzcuZN58+ah0WjQaDSsXLkSjUbD1q1badiwIVZWVuzatYtz587x4osv4ubmhr29Pf7+/vzxxx85rufl5ZWjZUmj0bB06VJeeuklbG1tqVatGr/88suT/UAfg+pdYyVFWc0do54nhBCi+EjN1OHz8VajXEsBriWkUfuTbfk6P3JKB2wtHx0H5s2bx+nTp/H19WXKlCkAHD9+HIAxY8Ywe/ZsKleujLOzM5cvX6Zz585MnToVa2trgoOD6dKlC6dOnTLsE/ogkydPZubMmcyaNYuvv/6a7t27c/HiRVxcXPL1WZ6EtAgVkiqVq+TrvDO30snSPf4CkEIIIURBcnJywtLSEltbW8qVK0e5cuUMixhOmTKF5557jipVqlC6dGnq1q1L//79qV27NtWqVWPq1KlUrlz5kS08vXr14q233qJq1apMnz6d5ORkDhw4UKCfS1qE8mDs6fNar2ak2pTDKuXaA7vHFAU0GmgaOYUv596m2ztDqO7mYJR7CyGEMG02Floip3TI17kHom7Ta8Wjh22s7O1PI+9Ht6TYWDz9Du4NGzbM8Tw5OZnJkyfz22+/cfXqVbKyskhNTSU6Ovqh16lTp47h93Z2djg4OBj2Eyso0iKUB6OvLG2mxabLLDQaDf9t79EDaCDZtgIummTGJH7O2aBXWbb1oLQOCSFECaDRaLC1NM/Xo0W1MpR3siav+cUasmePtahWJl/XM8bqzP+d/TV69Gh+/vlnpk2bxq5duwgPD6d27dpkZGQ89DoWFhY5P4tG80TbZD0OCUKFyacrmtdXoXF0z3FY41gBzevfYjfyKElNRpGFls5m++ga+jKz5s7mzPVElQoWQghharRmGiZ18QHIFYbuPp/UxadAlmKxtLTMV0/Jrl276NWrFy+99BK1a9emXLlyXLhwwej1GIMEocLm0xXN8AgI/A1eWQaBv6EZfgx8uoLWAvuOH6F970/iHapSRpPAuMRpRAa9ybLtR6R1SAghBAAdfcuz8J0GlHOyznG8nJM1C99pUGDrCHl5ebF//34uXLjAzZs382ytqVq1KuvXryc8PJyjR4/y9ttvF3jLzpOSMUJqMNOCd4s8X9a418dpWChJW6die3A+L5rt5vrubsw49gFvvfMuVcvaF2KxQgghTFFH3/I851OuUFeWHjVqFIGBgfj4+JCamsqKFSseeN6cOXPo06cPAQEBuLq6MnbsWBISEgqsrqehUfK7gEAJc/9g6dOnTxMfH4+jo2Oh16FcOkjimn44JkcB8KO+NUmtJ9OzdV1ZgVoIIYqgtLQ0oqKi8Pb2xtra+tFvEHl62M/y7hZZj/r+lq6xPBh9sPQT0nj44zh8L0kN+qNHw2tmO2i/82WmfjWfczeSVK1NCCGEKOokCBUFFjbYd52Jptf/SLT1oILmFpPuTOTA14Gs/DsCnV4a9YQQQognIUGoCNF4NcNh+H6S6vYB4C2zP2j7dzcmf/0NUTeTVa5OCCGEKHokCBU1lnbYvzQHpecmkmzcqWR2gylxYwn5qi8rd0ail9YhIYQQIt8kCBVRmsqtsR+2nyTf7gAEmm2m5Z8v8fH85VyQ1iEhhBAiXyQI5SEoKAgfHx/8/f3VLiVv1o7Yv7oApftPJFuVpbLZNSbfGskfX/Xn25CT0jokhBBCPIIEoTyYyqyx/NBUew674QdJrvEaWo3Cu2a/0viPl5kQtIroWylqlyeEEEKYLAlCxYWNM3ZvLkX/xvekWpamutkVPr05nP/NG8zqPWekdUgIIYR4AAlCxYxZzeexGX6I5GrdMNfoGWi2ngZbX+HDhd9z6ba0DgkhhBD3kyBUHNm6YNc9GP2rwaRZlMLH7CLTYoewYe4wVoeeldYhIYQoLvQ6iNoFx37K/lX/6A1RRU4ShIoxM99uWA87SErlTlhodAw1W0edLa8ydtFaaR0SQoiiLvIXmOsLwS/Az32zf53rm328gLRu3Zrhw4cb7Xq9evWiW7duRrvek5AgVNzZl8G2xw/oX1pCurkjdcyimHp9MOvmjuT7feeRreaEEKIIivwF1vWEhKs5jyfEZB8vwDBU3EgQykORmD6fXxoNZnVfx2roAVI822GlyWKk2ffU+P01Ri9az+U4aR0SQghVKQpkJOfvkZYAm8cAD/qH7L/HtozNPi8/18vnP4h79erFzp07mTdvHhqNBo1Gw4ULF4iMjKRz587Y29vj5uZGjx49uHnzpuF9P/30E7Vr18bGxobSpUvTrl07kpOT+eSTTwgODmbTpk2G6+3YseOpf5SPS3aff4T87l5bZCgK+iOryfrfh1jqkkhTLJjL23h2HsGbjTzRaGRHeyGEKEgP3DE9Ixmmu6tT0PirYGn3yNPi4+Pp1KkTvr6+TJkyBQCdTke9evXo168fPXv2JDU1lbFjx5KVlcVff/1FTEwMlSpVYubMmbz00kskJiaya9cuevbsCUDfvn1JSEhgxYoVALi4uGBpaZnv0o2x+7x5vu8migeNBrMGPbCs0oaUnwZieymEDwlm///2M+roeEa+3h53Zxu1qxRCCGFinJycsLS0xNbWlnLlygHw8ccf06BBA6ZPn244b/ny5Xh4eHD69GmSkpLIysri5ZdfxtPTE4DatWsbzrWxsSE9Pd1wPTVIECqpnCpi2+cX9IdWoNsynsacxPdKP+bMeYdqzw/ldX9pHRJCiEJjYZvdMpMfF0Phu1cffV73n8AzIH/3fkJhYWH8/fff2Nvb53rt3LlztG/fnmeffZbatWvToUMH2rdvz6uvvkqpUqWe+J7GJmOESjKNBjP/Pli8v4/UCk2x06QzUbOMCr++zYgl/yMmPlXtCoUQomTQaLK7p/LzqNIWHN2BvP6xqgHHCtnn5ed6T/GPXr1eT5cuXQgPD8/xOHPmDC1btkSr1bJ9+3Y2b96Mj48PX3/9Nc888wxRUVFPfE9jkyAkoJQXNn1/R9/xc7LMrGmuPc6UK++ycM4nrDsYLTPLhBDClJhpoePn/z75b4j593nHz7LPMzJLS0t0untrFTVo0IDjx4/j5eVF1apVczzs7LLHHWk0Gpo1a8bkyZM5cuQIlpaWbNiw4YHXU4MEIZHNzAyzJgMwHxxKarmGOGhSmcIiXH/pwYilm7kWn6Z2hUIIIe7y6QqvrwLH8jmPO7pnH/fpWiC39fLyYv/+/Vy4cIGbN28yePBgbt++zVtvvcWBAwc4f/4827Zto0+fPuh0Ovbv38/06dM5dOgQ0dHRrF+/nhs3blCzZk3D9f755x9OnTrFzZs3yczMLJC6H0aCkMipdBVs3tuGrt0UsjSWtNWG88nlvsyb8yk/H7okrUNCCGEqfLrC8AgI/A1eWZb96/BjBRaCAEaNGoVWq8XHx4cyZcqQkZHBnj170Ol0dOjQAV9fX4YNG4aTkxNmZmY4OjoSEhJC586dqV69OhMnTuSLL76gU6dOAPTr149nnnmGhg0bUqZMGfbs2VNgtedFps8/QrGbPv84Yk+S9tN7WMceBWCbzo/NXh/y4WstcXO0fsSbhRBCPMjDpnyLx2OM6fPSIqSiuLg44uLi1C4jb2VrYN3/L3RtJqLTmNNeG8ZH0b2Z/eVnbDhyWVqHhBBCFHkShPJQGCtLv//++/j6+rJ58+YCu8dT05qjbTUabf+dpJWuhYsmiVnMwWJ9X0as/IvYRBk7JIQQouiSIJSHwYMHExkZycGDBwvk+nfu3CEsLIyrV6/SuXNn3n33XRISEgrkXkZRzhfrgTvQtRiDHi0vaPcx/kIvpn/5BZvCr0jrkBBCiCJJgpBKnJ2dOXLkCB988AEajYZly5ZRu3Zt/vzzT7VLy5u5JdpnJ2D23p+klapOGU0Cc5WZZP38HiOCd3AjMV3tCoUQQojHIkFIRTY2Nnz55Zfs2LEDb29voqOjadeuHe+//z7Jyclql5c39/pYD96NLmAYesx4RbubsVG9mfzlXH49elVah4QQQhQZEoRMQMuWLfnnn38YOHAgABs2bCAjI0Plqh7B3Apt+ymY9d1GulMVymnimK9MJ/nHgYz4dhc3k6R1SAghhOmTIGQi7O3tWbBgAdu3b2fVqlWGfVgURSE93YRDhYc/Vu/vQdd4EAoa3jTfwchzvZn45Xz+90+M2tUJIYQQDyVByMS0a9eOZ5991vA8ODiYevXqsX//fhWregQLG7SdZqDp/TsZDpWoqLnJIv0Ubq97nxHf7uGWtA4JIYQwURKETJhOp2PmzJmcPHmSgIAAxo8fb9qtQ54BWL6/F51fXwB6mP/BsDO9GPvlIjYfk9YhIYQQpkeCkAnTarXs3r2bd955B71ez4wZM/D39+fIkSNql5Y3K3u0Xb6EnpvIsK+Ap1ksi3WTuLr2Az5YHcrtZBMf+ySEEKJEkSBk4lxcXPj2229Zv349ZcqU4dixYzRq1IjJkyersjldvlVujeX7+9DV64GZRqGv+WbeP92HkV8uZkvENbWrE0IIYSJSUlLw9PRk1KhRqtxfglAR8dJLL3H8+HFeeeUVsrKymDx5smm3DAFYO6LtNh+6/0SmrRtVzGJYmjWRC2tGMeK7fcRJ65AQQpR406ZNo3HjxqrdX4JQEVKmTBl+/PFHfvjhByZNmkSjRo3ULil/qj2HxZD96Gq/iVajMMD8Vwac6sOQL1ew7bi0DgkhREl15swZTp48SefOnVWrodgHocTERPz9/alXrx61a9dmyZIlapf0VDQaDW+++SaTJk0yHDtz5gzPPvssp06dUrGyR7AphfaVb+DN78m0KUN1syuszPqQEz98yKg1B7mTIq1DQghRVLRs2RKNRsMPP/yQ4/iCBQsoW7Zsvq8zatQoZsyYYezyHkuxD0K2trbs3LmT8PBw9u/fz4wZM7h165baZRnVsGHD+Ouvv6hXrx5z585Fr9erXVLeajyPxfv70fm8jLlGzzDzDfSJ7MugL1fxR+R1tasTQgjxCIqiEB4eTvny5fn5559zvHb48GEaNGhgeO7n54evr2+ux9WrV9m0aRPVq1enevXqhf0Rcij2QUir1WJrawtAWloaOp2u2G0BsXjxYtq3b09aWhoffPABrVu35ty5c2qXlTe70mhfXwGvrSTT2gUfs4uszBxD+HcTGLX2EPEpJjwIXAghSrgzZ86QmJjIxIkT2bx5MykpKYbXwsLC8PPzy/E8IiIi18Pd3Z19+/axZs0avLy8GDVqFEuWLGHKlCmF/nlUD0IhISF06dIFd3d3NBoNGzduzHXOggUL8Pb2xtraGj8/P3bt2vVY97hz5w5169alYsWKjBkzBldXVyNVbxoqVqzIli1bWLRoEXZ2duzatYu6deuyYMEC024dqvVSduvQMy9gqdExyuJHehzvR/85q/nrpLQOCSGEKQoLC8Pa2pp3330XR0dHNm/eDEB6ejrHjx/P0SL0MDNmzODSpUtcuHCB2bNn069fPz7++OOCLP2BVA9CycnJ1K1bl/nz5z/w9bVr1zJ8+HAmTJjAkSNHaNGiBZ06dSI6OtpwzsOa3iB7p/ejR48SFRXF999/z/Xrxe9LVqPR0L9/f44dO0arVq1ITk5m8ODBBAcHq13aw9mXRfvmanh5CVmWjtQ1O09wxmj2fTuJ0esOE58qrUNCiJIjOTk5z0daWlq+z01NTc3XuU/i8OHD1KlTB0tLS1566SV++uknAP755x8yMzNztAgVCYoJAZQNGzbkONaoUSNlwIABOY7VqFFD+fDDD5/oHgMGDFDWrVuX5+tpaWlKfHy84XHp0iUFUOLj45/ofmrQ6XTKvHnzlGbNmikZGRlql5N/8VeVrFWvKMokR0WZ5Kgc+shPeXXqKuXvk9fVrkwIIYwmNTVViYyMVFJTU3O9BuT56Ny5c45zbW1t8zy3VatWOc51dXV94HlPok2bNobv5e3btysODg5KWlqasnDhQsXFxeWJrvmkHvazjI+Pz9f3t+otQg+TkZFBWFgY7du3z3G8ffv2hIaG5usa169fJyEhAYCEhARCQkJ45pln8jx/xowZODk5GR4eHh5P/gFUYmZmxtChQwkJCcHCwgLI/lkOHz7c0EpmkhzLo33nR3gxiCwLB/zMzrAqYwQ7V01h7I9HSEiT1iEhhFDbkSNHDK0+rVu3xtLSkq1bt3L48GHq16+vcnWPz1ztAh7m5s2b6HQ63Nzcchx3c3Pj2rX8rT9z+fJl+vbti6IoKIrC+++/T506dfI8f9y4cYwYMcLwPCEhoUiGIcgORHdNmzaNefPmsWrVKr7++mvefvttNBqNitXlQaOB+u9g7t0K3ab3sYnawSSLb9l37BC9zwxh2KvtaVm9jNpVCiFEgUhKSsrzNa1Wm+N5bGxsnufe//c/wIULF56qrrvOnz/PnTt3DOOAzM3N6dKlCz///DMRERG0a9fOKPcpTCYdhO767xe2oij5/hL38/MjPDw83/eysrLCysrqccorEt544w1+//13Dh06xDvvvMPPP//MokWLHmu9h0Ll7IG250Y4tBzd1ok0yTrBqvQPmB7cnc0NejH+eR8crC3UrlIIIYzKzs5O9XMfJiwsDEtLS3x9fQ3HXnnlFXr06EFKSgpjxowxyn0Kk0l3jbm6uqLVanO1/sTGxuZqJTK2oKAgfHx88Pf3L9D7FBYfHx/27t3Lp59+ioWFBRs2bKBWrVqGQW4mSaMB/75oB4Wiq9QMO0060yyW0zl8EIFz1rPrzA21KxRCiBLl8OHD+Pr6YmlpaTj23HPPodPpyMjIyPeMMVNi0kHI0tISPz8/tm/fnuP49u3bCQgIKNB7Dx48mMjISA4ePFig9ylM5ubmTJw4kQMHDlCnTh1u3rzJa6+9xrRp09Qu7eFcvNH2+g06foZOa00LbQQr04bxy8qZjF//D0npWWpXKIQQJcKMGTMICwvLcczKyoqEhAQURaFatWoqVfbkVA9CSUlJhIeHG7qvoqKiCA8PN0yPHzFiBEuXLmX58uWcOHGCDz74gOjoaAYMGKBi1UVbvXr1OHjwIBMmTMDR0ZE33nhD7ZIezcwMmgxEO3APugr+OGpSmWWxmHZHhtD9y43sOXtT7QqFEEIUQRpFUXeZ5R07dtCmTZtcxwMDA1m5ciWQvaDizJkziYmJwdfXlzlz5tCyZcsCrSsoKIigoCB0Oh2nT58mPj4eR0fHAr2nGm7fvo2Li4vh+Zo1a+jYsSPOzs7qFfUoeh3snY/+z6mY6TO4o9gxKTMQB/+3GNfZBzurIjH0TQhRQqWlpREVFWVYKFg8uYf9LBMSEnBycnrk97fqQcjU5fcHWRyEhITQunVrKlSowNKlS+nQoYPaJT1c7El06/ujvRYOwBadP0F2gxj3WksCqhSv1cOFEMWHBCHjMUYQUr1rTJgOKysrqlSpwuXLl+nYsSP9+/cnMTFR7bLyVrYG2n5/QpuJ6M0s6Kg9yMrUoaxeNo+PN0WQLGOHhBBCPIIEoTwUt1lj+dG4cWPCw8MZMmQIkL2Za506dfj7779VruwhtObQajRm7/2NrqwvpTWJLLD8Cv9DI3lj7m/sO39L7QqFEEKYMOkae4SS1DV2v7///pvevXtz8eJFACZMmMDUqVNVruoRsjIgZBbKri/QKDpuKE6Mz+xLhSavMqbjM9haytghIYT67nbneHl5YWNjo3Y5RVpqaioXLlyQrjFhfG3atOHYsWO89957AEVjSqS5JbSdgObdP9C5PkMZTTxLLL+k9sExvDZ3MweibqtdoRBCGLY+SklJUbmSou/uz/Duz/RJSIvQI5TUFqH7HTp0CD8/P8Nq3sePH6dKlSqmPcgvMw12zEAJ/QqNoueaUoqxme9RpWk3Rnd4BhtL7aOvIYQQBSQmJoY7d+5QtmxZbG1tTXPLIxOmKAopKSnExsbi7OxM+fLlc50js8aeUkmZPv+44uLi8PX1xcnJieDgYNMfQ3XpALoNA9DePgfAD1ltWO30HpNfa0JDL5dHvFkIIQqGoihcu3aNO3fuqF1Kkebs7Ey5cuUeGCQlCBmJtAjldPDgQbp06cL169fRarWMGzeOjz76KMdy6yYnIwX++hRl30I0KFxWXBmb+R41A7owqsMzWFtI65AQQh06nY7MzEy1yyiSLCwscm1Eez8JQkYiQSi3W7du8f7777NmzRoA6tatS3BwMHXr1lW5ske4sAfdxkFo71wAYFXWc6xx6sunrzfBz7OUurUJIYQwKhksLQpM6dKl+eGHH1i3bh2urq4cPXoUf39/pk6diknnaq9maAfuAf93Aehpvp2FiUOZ+c1ypv9+grRMneFUnV5h77lbbAq/wt5zt9DpTfhzCSGEeGLSIpQHGSOUP9evX2fgwIFs2LCB7t27s3r1arVLyp9zf6Pf9D5mCZfRKxqW6zrys3Nvpr3eiNiEND795RgeSUcpyx1iceaSfV0+6lqbjr65B+QJIYQwPdI1ZiTSNfZoiqKwdu1a2rdvb9i3LCEhATs7u4f236ouLQG2jocj3wJwTl+eUZkDKKuJY5LFKtw196bbX1VcmJLZk25vD5AwJIQQRYAEISORIPT4FEWhW7du3Lx5k5UrV5r+GkRntme3DiVdQ6dk9xcrgNl9kxDu9oyNtxjDtPHj0ZrJVFchhDBlMkZIqOb8+fP8/fffhIaGUrduXb766iv0er3aZeWt2nOYDd7HDe9uaDWg0eQMQXDv+dDMZRw4d6PwaxRCCFEgJAgJo6tSpQoRERG0a9eO1NRUhg0bxrPPPktUVJTapeXNphSn3Ls99BQzDbhrbqG7sKdwahJCCFHgJAiJAlGpUiW2bdvGggULsLW1ZceOHdSpU4fFixeb7Myyspo7+TqvDHEFW4gQQohCI0EoDyVx93lj02g0DBw4kH/++YcWLVqQlJTEZ599ZrL761SpXCVf5y07ksSOU7EmG+iEEELknwyWfgQZLG0cer2er776ivr169OqVSsAQ5AwmT129DpSZ/lglXIt1xih+53SV+DzrLdI927HuM4++FZwKrwahRBC5IvMGjMSCUIFJygoiK1bt7J48WLKlSundjnZIn9BWdcTBSVHc6ke0ACKhS1mmdktWvv1Nfgs8y0867ZiZPtn8HCxVaNiIYQQDyBByEgkCBWMpKQkKlWqRFxcHC4uLgQFBfHGG2+YRutQ5C8oW8aiSbhqOKQ4VkDT8TPwbgG756LftwgzXRoAv+saMU//Ji0DmjK4TVWcbU143zUhhCghJAgZiQShghMREUHPnj05cuQIAK+++ioLFiygTJkyKlcG6HVwMRSSroO9G3gGgNl9i0PGX4YdM1DCv0ej6MlSzFira8My89d5s60/PZt6yWauQgihIglCRiJBqGBlZmYyffp0pk6dSlZWFmXKlOGbb77hpZdeUru0/LkeifLnZDSntwCQolixVNeJX+1eY1DHerxYtwJmsviiEEIUOglCRiJBqHAcPnyYwMBAIiIi0Gq1nD59msqVK6tdVv5d2IOyfRKaKwcBuKU48HXWSxwp+xKjO9eheTVXlQsUQoiSRYLQU5JNVwtfeno6kydPxsrKikmTJqldzuNTFDjxK/o/JmN2+ywAF/VlmZ31OglVujC2kw8+7vJnSAghCoMEISORFiF1HTt2jK+//ppZs2bh5FREpqnrsuDIKvR/z8AsORaAY3ovPs96C7d6nRjZvjruzjYqFymEEMWbBCEjkSCkHkVR8Pf3JywsDA8PD5YvX067du3ULiv/MpJh7wL0u+dilpkEQIiuNl8ob9OkWRsGta6Kk42FykUKIUTxJJuuiiJPo9EwZ84cKleuzKVLl3juuecYNGgQSUlJapeWP5Z20Go0ZsOPQuMB6M0saKk9xibzcdQIHclbM9ewdNd50rN0alcqhBAllrQIPYK0CKkvKSmJsWPHsmDBAgAqV67MihUraNmypcqVPabbUSh/TUUT8RMA6Yo5q3XPsd7+Td7r6E+XOu4yw0wIIYxEusaMRIKQ6fjjjz/o27cv0dHRaDQa/vjjD9q2bat2WY/vajj67ZMwi9oBQIJiw6KsLhxwe4MRz9cjoIrMMBNCiKclQchIJAiZloSEBEaMGMGJEycICQlBqy3Cixae+wv9tkmYXf8HgOuKM3OyXuVGlVcZ09mXZ8o5qFygEEIUXRKEjESCkGlKS0vD2toagNTUVObPn8/QoUOxsrJSubLHpNdDxM/o/piCNiEagLN6d2bp3sCpXjdGtK9BOSdrlYsUQoiiRwZLi2LtbggCmDhxImPGjMHPz4+wsDAVq3oCZmZQ5zW0Qw9Bx8/QWZeiqtlVvrGYw+vH+vHB7EXM2nqShLRMtSsVQohiSYKQKPJatGhB2bJlOX78OI0bN2bSpElkZGSoXdbjMbeCJgPRDj8KLUah11rT0Ow0P2gnUW/3IHrP/JaVe6LIyNKrXakQQhQr0jX2CNI1VjTcuHGDwYMH8+OPPwJQr149Vq1aRe3atVWu7AklxKDs+AzlyLeYKTp0ioYfda340aEHfTo1o3Ptcmg0MsNMCCHyIl1jTykoKAgfHx/8/f3VLkXkQ5kyZVi3bh1r1qzBxcWF8PBw/Pz8WLdundqlPRnH8mi6zsNs0D70z7yAVqPwpvkOvksZwMV1Y+g+fxv7z99Su0ohhCjypEXoEaRFqOi5du0a/fv3Z8eOHURERODh4aF2SU8vej+6bR+hvbwfgDjFnvlZL3Kl2juM6lybqmVlhpkQQtxPZo0ZiQShoklRFKKionLsYL9t2zaeffbZojvlXlHg1Gaytk3C/PZpAC4rrnyZ9RrWDd5i+HPPUNZRZpgJIQRIEDIaCULFw5YtW+jUqRPNmzdnxYoVVK1aVe2SnpwuC47+QNafUzFPvgZApN6TOcrb1GzejfdaV8XeylzlIoUQQl0yRkiI+8TFxWFvb8/u3bupW7cuQUFB6PVFdAaW1hwa9MB82BFo9wlZFg74mF1kiXYGjXf3YeDMJXy79wKZuiL6+YQQohBJi9AjSItQ8XHhwgV69+7Njh07AGjbti3Lly/H09NT3cKeVsptlF1foOz/BjN99npDv+masMahF+90bkOHWm4yw0wIUeJIi5AQ/+Hl5cWff/7JV199hY2NDX/99Re1a9fm+++/V7u0p2PrgqbDNMyGHkZf+w0UNLyg3ceK5MFcWzOEPgs2c+jCbbWrFEIIkyRBSJQoZmZmDBkyhKNHjxIQEEBiYmLR25YjL86VMHtlMZoBu8iq3A4LjY5e5tv4OrY3IUtGMzR4F+duJKldpRBCmBTpGnsE6RorvnQ6Hb///jtdunQxHIuOjsbDw6N4dCVFhZC55SMsrocDcENx4ivdK2j8ejKknQ9lHIpJABRCiAeQWWNGIkGo5Lh+/Tq1atWiefPmfPPNN7i5uald0tNTFDi+gYxtn2CZcBGAKL0bX/EWXi26827LytjJDDMhRDEkY4SEeEx79uwhISGBTZs2UatWLcN2HUWaRgO+L2M59BB0nk2mdWm8za4zx2wurXa9yYiZ8/l+fzRZMsNMCFFCSYvQI0iLUMly9OhRAgMDOXr0KACvv/46QUFBuLq6qlyZkaQnooR+jW7315jrUgD4S1eP7x1688YLnWhXs2zx6BYUQpR40iL0HykpKXh6ejJq1Ci1SxEmrG7duhw4cICPPvoIrVbLunXr8PX1ZdOmTWqXZhxWDmjajMf8g6Po/Pqi15jTVhvO4uThxP/wLoMW/MKR6Di1qxRCiEJTYoLQtGnTaNy4sdpliCLA0tKSKVOmsG/fPnx8fLh+/TqbN29Wuyzjsi+LtsuXmL1/gMwaL2KmUXhVG8Lc2L4cWDyY0at2cOFmstpVCiFEgSsRQejMmTOcPHmSzp07q12KKEIaNmxIWFgYU6dOZdasWYbjGRkZKlZlZKWrYPHmKnj3L9IrBmClyaS/+f+YeO4t1s4dyacbwriVlK52lUIIUWBUD0IhISF06dIFd3d3NBoNGzduzHXOggUL8Pb2xtraGj8/P3bt2vVY9xg1ahQzZswwUsWiJLG2tmbChAk4OGTv7q4oCs8//zzvvfceiYmJKldnRBX9sOr7O3T/iTSXGjhpUhhr/gN9w19lzqxJLPjrFKkZOrWrFEIIo1M9CCUnJ1O3bl3mz5//wNfXrl3L8OHDmTBhAkeOHKFFixZ06tSJ6Ohowzl+fn74+vrmely9epVNmzZRvXp1qlevnq960tPTSUhIyPEQ4q7Q0FD++OMPlixZQu3atfn777/VLsl4NBqo9hzW74dCt0Wk25bHXXObqZqFPLvjZSbMnMW6A9Ho9DK/QghRfJjUrDGNRsOGDRvo1q2b4Vjjxo1p0KABCxcuNByrWbMm3bp1y1crz7hx41i9ejVarZakpCQyMzMZOXIkH3/88QPP/+STT5g8eXKu4zJrTNy1c+dOevfuTVRUFADvv/8+n332GXZ2dipXZmSZaegPLCZrxywsM7P/QbBfX4PvHPrQrUs32jwjM8yEEKarSC6o+N8glJGRga2tLT/++CMvvfSS4bxhw4YRHh7Ozp07H+v6K1euJCIigtmzZ+d5Tnp6Ounp98ZEJCQk4OHhIUFI5JCUlMTo0aNZtGgRAFWrVmXlypU0a9ZM5coKQGocWbvmwL5FmOuz/9/4XdeI7eX70btre+pUdFa3PiGEeIBiMX3+5s2b6HS6XCv8urm5ce3atQK5p5WVFY6OjjkeQvyXvb09CxcuZNu2bVSsWJGzZ8/Sv39/dLpiOI7GphTm7adgPuwwGbW7o8eMztoDzLren2OL+jDh2z+IvpWidpVCCPFEisTa+v9tflcU5Yma5Hv16pXvc4OCgggKCiqeX2zCaJ577jkiIiIYMWIEAwYMQKvVql1SwXGqiOUrC6D5+6RunYTN+W10N/+TlLO7WTG3M4l+g+n/XF1K2VmqXakQQuSbSbcIubq6otVqc7X+xMbGFvg+UIMHDyYyMpKDBw8W6H1E0efk5MSyZcvw9/c3HPviiy+YMGFCjm7WYsPNB5ueP0Kv30kp2wBbTTqDtRvod+QlFs0azTd/nSQtU/4BIYQoGkw6CFlaWuLn58f27dtzHN++fTsBAQEqVSXEw126dInx48czffp0/P39CQ8PV7ukguHVDNuBf8Hr35Li4E1pTSLjWEnHHV2Y9vlUfjokM8yEEKZP9SCUlJREeHi44csiKiqK8PBww/T4ESNGsHTpUpYvX86JEyf44IMPiI6OZsCAAQVaV1BQED4+Pjn+lS9Efnh4ePD999/j6urKsWPH8Pf3Z8qUKWRmZqpdmvFpNODTFdvhh9A/P4c0K1c8zWL5NOtLnvmlCxO/+Jqdp29gQnMyhBAiB9Vnje3YsYM2bdrkOh4YGMjKlSuB7AUVZ86cSUxMDL6+vsyZM4eWLVsWSn2y6ap4UrGxsQwcOJD169cD2etdBQcHU6tWLZUrK0AZyWTumY+yex6WuuwtOkJ0tdlafiBvvfgCvhWcVC5QCFFSFMnp86ZIgpB4Goqi8MMPP/D+++8TFxeHo6MjFy9exNnZWe3SClbyTdL/+gzzwyvQKlkAbNA141i19+nTpTUVS9mqXKAQoriTIPSU7p81dvr0aQlC4qlcvXqV9957j5YtWzJmzBi1yyk8t6NI3joZu1MbAEhXzPle/xx3Gg6jz3MNcbK1ULlAIURxJUHISKRFSBiLoigoioKZWfbQvIMHDxIaGsqQIUMMx4qtq+Ek/jYBh6u7AUhQbFip6YZDqyG81bwG1hbFeNkBIYQqJAgZiQQhURDS0tJo0KABJ06coFWrVixfvpzKlSurXVaBU87+RdL/JuAQFwnAdcWZFRZvUaPTALrW98TMTLbsEEIYR7FYWVqI4srKyoohQ4ZgZ2fHzp07qVOnDosWLSr2s6s0VdviMGQP+peWkGxTATfNHT7MWojvpk5M+3IWu0/fULtEIUQJIy1CeZAxQqIwnD9/nt69exMSEgJkr1S9bNkyPDw8VK6sEGSlk7l/KVl/f45NVjwAh/TV2Vx+IK+8+Co+7vL/mxDiyUnXmJFI15goaHq9nq+//poPP/yQtLQ0HB0d2b9/PzVq1FC7tMKRFk/qjjmY71+AhZK9Evd2nR9Hqg/jnS7tcXe2UblAIURRJEHISCQIicJy6tQpevXqhb29Pdu2bXui/fSKtIQYErdOxfb492jRo1M0rFdac91vBD3aN8XJ5t4MM51e4UDUbWIT0yjrYE0jbxe0Mr5ICHEfCUJGIkFIFCadTkd8fDwuLi4AJCYmsnXrVl555ZWSE4xunObObxNxvrgVgDTFgu80z2PZagSvt/Dl75OxfPrLMTySjlKWO8TizCX7unzUtTYdfcurXLwQwlRIEDISCUJCTf3792fx4sW8/PLLLFy4kLJly6pdUqFRovcR/8s4nG8eBiBOsWeF9hXOpzky3uI73DW3DedeVVyYktmTbm8PkDAkhABk1thTk73GhNoURaFixYqYm5uzfv16atWqxc8//6x2WYVGU6kJzoP/QvfG98TbV6GUJokR+mC+tvia8tzOcW45brPAYi47Ni6XjV6FEI9FWoQeQVqEhNqOHDlCYGAgx44dA+Ctt95i/vz5hu6zEkGXxcktC6l24CO0mgf/laVX4BqlufjOPppWKzktZ0KIB5MWISGKifr163Pw4EHGjx+PmZkZP/zwA7Vq1WLfvn1ql1Z4tObctKyYZwgCMNOAu+YW+qiQQixMCFHUSRASogiwsrJi2rRp7N27lxo1apCZmYm3t7faZRWqspo7+TrPf+8g0le/BQeXwu3zBVuUEKLIM1e7ACFE/jVq1IjDhw9z8uRJ3NzcDMf/+ecf6tSpo2JlBa9K5Sqw+9HnWSrpcPb37AeAsydUaQNV2oJ3S7ApVbCFCiGKFGkREqKIsbGxoX79+obnP//8M3Xr1mXAgAEkJiaqWFnB0no1I9WmHHmNhdYrEG9RljHOXzIr83X26WuSoWjhzkUIWwnresLMyrDkWfhrKlwMBV1moX4GIYTpkcHSeZAtNkRR8fHHH/Ppp58C4O3tzYoVK2jVqpXKVRWQyF9Q1vVEQcnxrzg9oEGD5vVV4NOVw9FxLNsdRUjEBRoSSUuzf2hjcRwv5XLO61nag1eL7Bajym3AtRqUlPWahCjmZB0hI5FZY6Io+Ouvv+jTpw8XL14EYNiwYUyfPh1bW1uVKysAkb+gbBmLJuGq4ZDiWAFNx8/Ap2uOU6/cSSU49AI/HIgmMS2LctyivfUJ3ix9hmdSwtCm5pyGj2NFqNL632601mBXusA/jhCiYEgQMhIJQqKoSEhIYNSoUSxZsgSAatWq8e2339K4cWOVKysAel1211bSdbB3A88AMNPmeXpyehY/HrrEitALXLyVAoCFmUK/aim8U+Yc7rf2QvRe0GXc9y4NlK97b3yRR2MwtyrgDyaEMBYJQkYiQUgUNVu2bOHdd9/lypUrbN68mY4dO6pdksnQ6RX+PHGdZbuj2B91rzXI36sU/ZqU41nb82ij/oZzf0Ps8ZxvtrAFz2b3glGZGtKNJoQJkyBkJBKERFEUFxfHpk2b6NWrl+FYQkKC/Bm+T8SVeJbvjuLXf66Sqcv+a9DDxYZeAd683rAiDpm34PwOOPdXdjBKjs15AYfy2eOKqrSByq3BXhZxFMKUSBAyEglCoji4dOkS9evXZ9CgQUycOBFLS0u1SzIZ1xPS+HbvRb7bf5G4lOxZZPZW5rzh70GvAC88XGxBUeD6cTj/b2vRxT2QlZbzQm61740vqtQULGwK/8MIIQwkCBmJBCFRHMycOZOxY8cCUK9ePYKDg4v9ukOPKzVDx4YjV1i+J4qzsUlA9mrVHWqVo29zb/w8S6G52xWWmQaX9t1rLbr2T86LmVtnh6G73Whla4GZrFYiRGGSIPSUZPq8KG7WrVvHoEGDuHXrFhYWFkyaNImxY8dibi7rqt5Pr1cIOXODZbuj2HXmpuF43YpO9GnuTefa5bHQ/ifUJN2AqJ33glHi1Zyv25W5rxutDTiWL4RPIkTJJkHISKRFSBQn169fp3///mzatAkAf39/goODqVmzpsqVmabT1xNZvjuK9UeukJGlB6C8kzU9m3rxdqNKONla5H6TosCNU/92o/0FF3ZDZkrOc8rUzG4pqtIme8abpV0hfBohShYJQkYiQUgUN4qi8N133zFkyBDu3LnDqFGjmDVrltplmbRbSel8tz+aVXsvcjMpHQAbCy2v+lWkdzMvKpexz/vNWelw6cC9YHQ1HLjvr12tZfbU/LvdaOXqSjeaEEYgQchIJAiJ4urKlStMmzaNL774Ahub7IG9iqLcGwcjcknP0vHr0RiW7Y7iREyC4fizNcrSt7k3TauUfvTPL+V2zm60+Es5X7dxyZ6FdrcbzdnD+B9EiBJAgpCRSBASJYVOp6NTp0507dqVQYMGYSatEnlSFIW952+xfHcUf56M5e7fojXLO9KnmRdd67ljZZ73Ao/3XQhunbvXWhS1CzL+s19c6Wr3utG8moOVg/E/kBDFkAQhI5EgJEqKH374gbfffhuANm3asHz5cry8vNQtqgiIupnMij1R/HjoMqmZOgBc7a3o0cSTd5pUorT9Y6xGrcuEy4fuBaMrYaDo771uZg4VG90LRu71H7qithAlmQQhI5EgJEoKvV7PwoULGTNmDCkpKdjb2/PFF1/Qr18/6S7Lh/iUTH44GE1w6AVi4rPXGLI0N+OlehXo09ybZ8o9QUtO6h24sOteN1pcVM7XrZ3Au9W98UWlvJ76cwhRXEgQMhIJQqKkOXv2LL1792b37t0AdOjQgaVLl1KxYkWVKysaMnV6NkdcY9nuKI5eumM43qKaK32ae9OqWhnMzJ4wWN6Ouq8bLQTS4nO+Xsr7vm60FmDj/MSfQ4iiToKQkUgQEiWRTqdj3rx5jB8/nvT0dNq2bcuff/6pdllFiqIoHI6OY9nuKLZEXEP/79+0VcrY0ae5Ny/Xr4iN5VN0a+my4OqRe8Ho8kHQZ917XaOFCn73glEFP9A+YLq/EMWUBCEjkSAkSrITJ07Qv39/FixYgK+vr9rlFFmXbqcQHHqBNQcvkZSeHVZK2VrwduNK9GzqhZuj9dPfJC0he82iu9uA3DqT83Urx+xWorvdaC6VZdNYUaxJEHpKsrK0ENn+O6V+9uzZeHh48MYbb6hYVdGUmJbJukOXWRkaxaXbqQBYaDW8UMedvs298a3gZLyb3bl0r7Xo/A5Ijcv5ulOlf0NRm+xxRrYuxru3ECZAgpCRSIuQEPeEh4fTsGFDdDodr732GgsWLMDV1VXtsoocnV5he2T2OKKDF+4FlEbeLvRt7k27mm5on3Qc0YPodRBz9F5rUfQ+0Gfed4Imewba3W60io3AXDbmFUWbBCEjkSAkxD0ZGRlMmzaNadOmodPpKFu2LN988w3dunVTu7Qi65/Ld1i2O4r//RND1r8DiTxL29IrwIvXGnpgb1UAe8FlJMOFPfdajG6czPm6hV32mkV3g5FrdelGE0WOBCEjkSAkRG5hYWEEBgZy/PhxAN555x2++uorSpUqpXJlRde1+DSC917g+/3RxKdmt9Y4WJvzpr8HgQFeVCxlW3A3T7ia3VJ0t8Uo5WbO1x0r3LdpbGuwk1ZAYfoKJAgdOHAAPz8/tNrsmQ7/HTuQnp7Opk2beP3115+idNMiQUiIB0tPT2fSpEnMmjULvV5PtWrViIyMlN3sn1JKRhY/H77Cit1RnL+ZDIDWTEPHWuXo09wbP88CDpt6PVyPuNdadHEv6NJznlOuzr3WIo8mYGGEwd5CGFmBBCGtVktMTAxly5YFwNHRkfDwcCpXrgxk72zt7u6OTqd7yvJNhwQhIR5u3759BAYGMnToUAYPHqx2OcWGXq+w43Qsy3ZHsefsLcPxeh7O9G3uTSffcphrC2EblMxUuBh6r7XoekTO181twDPgXjAq6yPdaMIkFEgQMjMz49q1a4Yg5ODgwNGjR3MEofLly6PX6x92mSJFgpAQj5aamoqVlZVhf7I9e/aQlpbGs88+q3JlxcOJmASW745iU/hVMnTZf7+6O1kTGODFm40q4WRTiOsDJV7PnoV2t8Uo6XrO1+3L/btpbNvsXx3cCq82Ie6jWhCSFiEhSrakpCTq1KlDVFQUgwYN4vPPP8fe3l7tsoqFG4nprN53kdX7LnIrOQMAW0strzf0oHczLzxL2xVuQYoCsSfuhaILeyArNec5ZWvdm6ZfKQAsC3CskxD3kSBkJBKEhHg8ycnJjB49moULFwJQuXJlVq5cSYsWLVSurPhIy9TxS/hVlu2O4tT17N3qNRpoV9ONvs29aeztos7+cJlpcGn/vWAUczTn61orqNTkXjeaW20wK4TuPVEiFVgQ+uuvv3BxyV54KyAggHXr1hn2ILp58ybPPfecBCEhBH/88Qd9+vTh0qVLaDQahg8fzrRp07CxsVG7tGJDURT2nL3Fst3n+fvUDcPxWu6O9G3uzQt13LE0VzFoJN+8rxvtb0i4kvN1W9d73WhV2oCjuxpVimKqwIKQRqPhQW+5e1yj0UgQEkIAEB8fz4gRI1i+fDkAzzzzDLt375ZFGAvA2dgkVuyJ4ufDl0nLzB5HVNbBip5NPXm7sScudiovkKgocPPMvytd/529HUhGUs5zytS4N03fsxlYSZeqeHIFEoQuXryYr/M8PT3ze0mTJ0FIiKf3v//9j379+uHv78/GjRvV6bYpIeKSM/j+QDSr9l7gekL2tHcrczNeblCRvs29qFrWQeUK/5WVkb1R7N1utKtHQLlvoo2ZBXg0vje+qHw9MHuKTWpFiSMLKt7H3NzcsGFkw4YNWbp0ab7fK0FICOO4ffs2Op2OMmXKGJ5fvHiR+vXrq1xZ8ZSRpef3YzEs2x3FsSvxhuOtqpehb3NvWlRzNa1AmnIbokLuBaM70TlftymVvSfa3W4050qPvqZelz31P+k62LtlT/OXMFViFEgQun37NikpKYYxQQDHjx9n9uzZJCcn061bN95+++2nq7wAuLq6cvPmzUef+AAShIQoGO+88w5r165l4sSJjB8/HguLQpwCXoIoisLBC3Es232ebZHXufs3fnU3e/o086Zb/QpYW5hYOFAUuH3+3oaxUSGQnpDznNJV/+1Ga5u9HYj1f/5+jvwFtozNXjX7Lkd36Pg5+HQt8I8g1FcgQeitt96ifPnyfPnllwDExsZSo0YN3N3dqVKlCps3b2bZsmX06NHj6T+BEUkQEsK0ZGRk0L17d3766ScAGjRoQHBwsKHlVhSM6FsprAiNYt3BSyRnZI/ldLGz5J3GlXinqSdlHUx0hWhdFlwJuze+6PIhUO4bi6rRgkeje8Eo/jL81Bv479fbvy1gr6+SMFQC5Pf7+7GmE+zbt4+uXe/94Vm1ahUuLi6Eh4ezadMmpk+fTlBQ0GMVGhISQpcuXXB3d0ej0bBx48Zc5yxYsABvb2+sra3x8/Nj165dj3WPhIQE/Pz8aN68OTt37nys9wohjM/S0pJ169bxww8/4OLiwuHDh/Hz82PGjBlkZWWpXV6xVam0LZO61GLv+GeZ+HxNKjjbcDs5g6/+Okvzz/5m5LqjRF5NePSFCpvWHCo1hjbjoO82GBsFb3wH/u+CS+XsUBS9F3ZMh2Xt8ghB3Du25cPsbjMheMwWIRsbG06ePGkYDN25c2dq1arFrFmzADh9+jRNmzbl1q1bD7tMDps3b2bPnj00aNCAV155hQ0bNuTYyXrt2rX06NGDBQsW0KxZM7755huWLl1KZGQklSpl9xH7+fmRnp6e69rbtm3D3d2dq1ev4u7uTkREBM8//zzHjh3Ld+uOtAgJUbBiYmLo378/v/76KwCNGzdmzZo1eHl5qVtYCZCl07Mt8jrLdkcRdjHOcLxp5dL0be5N2xplMTMzoXFEeYm7cG/T2DN/QGbyo9/j1Tw7RFk5grXTv7863verQ87XzFWedSceW4F0jbm5ubFt2zbq1q0LZHc5ffPNN7zyyisAnDlzhvr165OUlPSwy+RdjEaTKwg1btyYBg0aGBZnA6hZsybdunVjxowZj32PTp068emnn9KwYcMHvp6enp4jVCUkJODh4SFBSIgCpCgKq1atYujQodjZ2XH8+HHZyb6QhV+6w7LdUfx+LAadPvtrwdvVjt7NvHjVryK2lkVkM91/1sH6fsa/rrl1zrBk5fDv753+E6Ae8pq5tezDVojyG4Qe6092o0aN+Oqrr1iyZAnr168nMTGRtm3bGl4/ffo0Hh4eT171f2RkZBAWFsaHH36Y43j79u0JDQ3N1zXi4uKwtbXFysqKy5cvExkZaVgJ+0FmzJjB5MmTn6puIcTj0Wg0BAYG0rZtWy5fvmwIQYqiEBMTg7u7LLRX0Op5OPP1W/UZ16kGwXsv8P3+aKJuJvPxpuPM3nqKtxpXIrCpF+7OJr4gpkP5/J3n/x7Yl8kehJ2WkPevd1uXstKyH8mxT16bmcWDW5se2BKVR8iytCs+YcpEZvU9VhD69NNPadeuHatXryYrK4vx48fn+FfbmjVraNWqldGKu3nzJjqdDje3nJv2ubm5ce3atXxd48SJE/Tv39+wGOS8efMMK2M/yLhx4xgxYoTh+d0WISFEwfPw8Mjx/9u3337LwIEDmTVrFgMGDDBs6ioKjruzDeM61WRo22r8FHaZFXuiuHArhW92nmfprig61y5P3+be1PNwVrvUB/MMyJ4dlhDDg8cJabJf7/RZ/r509bqHh6U8X0vMeQwF9JmQciv78aQ0Zv+GpQeEpEcGqX9fs3JUf2sTE5rV91hBqF69epw4cYLQ0FDKlStH48aNc7z+5ptv4uPjY9QCgVxrXdxdwTo/AgICOHbsWL7vZWVlhZWV1WPVJ4QoGBs2bCAlJYXBgwezfv16li9fbhgbKAqWnZU5gQFe9GjiyZ8nY1m2+zz7zt/m16NX+fXoVfw8S9G3uTftfdww15pQQDXTZn+ZrutJ9iyx+8PQv98bHfMZgu5ez6ZU9uNJ6fXZq2jnCknxjwhQ8TlfU3TZi06mxWc/4h996zxZOjykS+8BQSrHa/+2ZGmfsLs08pd///v8J6gmxGQfL+RZfSa1oOJ/xwhlZGRga2vLjz/+yEsvvWQ4b9iwYYSHhxfoDLCgoCCCgoLQ6XScPn1axggJoQK9Xs/8+fP58MMPSU1NxcHBgTlz5tCnTx/TWgywhDh+NZ5lu6P49ehVMnXZXx0VnG3o3cyL1/09cLQ2obWgHtjiUCE7BBXFqfOKApmp/wlO/wlS6YmPfk2Xe2LRE7OwzSNA/bfb775WKgs7WPs2JOXVxfhvi93wY0/dTVYgg6VXrVqVr/N69uyZ30vmLCaPwdJ+fn4sWLDAcMzHx4cXX3zxiQZLPy6ZNSaE+k6fPk2vXr3Yu3cvkD1jdcmSJTJ2SCWxCWl8u+8i3+2P5nZyBgD2Vua81rAivQO8qVTaVuUK/2UiY1BMSlZ67rCUI0A9KEj9p5svM6Xg6wz8DbxbPNUlCmzTVXt7e8zNzR+48Spkh5nbt2/nu9CkpCTOnj0LQP369fnyyy9p06YNLi4uVKpUyTB9ftGiRTRt2pTFixezZMkSjh8/Xih7mkkQEsI06HQ6vvzySz766CMyMjLYsWMHLVu2VLusEi0tU8eGI1dYvjuKM7HZs4XNNPCcjxt9m1fG36uUtNwVR7rMf8NTfO6QlKNL7wGvJV2D1LhH3+OVZVD71acqs0CCUK1atbh+/TrvvPMOffr0oU6dOk9VJMCOHTto06ZNruOBgYGsXLkSyF5QcebMmcTExODr68ucOXMK/C9A6RoTwjRFRkby559/MmTIEMOxrKwszM2LyPTuYkhRFELO3GTZ7ihCTt8wHK9T0Yk+zbx5vk55LExpHJFQT9QuCH7h0eeZaosQwP79+1m+fDlr166latWq9O3bl+7duxfbkCAtQkKYtrNnz9KuXTtmz57Nq68+3b8gxdM7cz2R5XuiWH/4CulZ2bvJuzla0bOpF90bV8LZVhYmLNH0Opjr++hZfaY6Ruh+qamp/Pjjj6xYsYIDBw7QrVs3li9fXuxmXEkQEsK09evXj6VLlwLZM1fnz59P6dKlVa5K3EpK5/v90azad5EbidkDdK0tzHilQUX6NPemShl7lSsUqjHMGoMHzuoz0qyxAg9Cd4WEhDBp0iRCQkK4efNmsVkNVrrGhCgaMjIy+PTTT5kxYwY6nY5y5cqxePFiunTponZpAkjP0vHb0RiW7Y4iMubePmZtnilD3+aVaVa1tIwjKokKYVZfgQahK1euEBwczIoVK0hOTjaMGapRo8ZTFW2KpEVIiKLh4MGDBAYGcuLECSB7nOHcuXNxdnZWtzABZI8j2nf+Nst2R/Hnyevc/eapUc6BPs296VrXHWuLEj6jq6Qp4Fl9BRKE1q1bx4oVK9i5cycdOnSgd+/ePP/882i1xfcPrwQhIYqOtLQ0Pv74Y2bPno2iKHz22WeMHTtW7bLEf0TdTGblnih+DLtMSkb2LvCu9pa808STd5p44mpfvIZYCHUU2PT5SpUq0b1791zbXtxv6NChj1etCZMgJETRs2fPHubOnct3332HpaUMzjVV8SmZrDkYTXDoBa7GpwFgaW5Gt3ru9GnuTY1y8neueHIFEoS8vLwe2Zer0Wg4f/58/is1UTJGSIjiIyMjgzfffJMhQ4Y8cLkOoa5MnZ4tEddYtjuK8Et3DMebV3Wlb3NvWlUvg5mZjCMSj6fQBkv/15UrV6hQoYIxL6kqaRESouibNWsWY8aMAWDIkCF89tln2NqayOrHIoewi3Es3x3F5ogY9P9+O1UuY0efZt680qAiNpbFdyiGMK5CD0LXrl1j+vTpLFmyhNTUVGNc0iRIEBKi6EtMTGTUqFEsXrwYgKpVqxIcHExAQIDKlYm8XI5LITj0AmsOXCIxPQsAZ1sL3m5UiZ5NvSjnZK1yhcLU5ff7+7GW+rxz5w7du3enTJkyuLu789VXX6HX6/n444+pXLkye/fuZfny5U9dvBBCGJODgwPffPMNW7ZsoUKFCpw9e5bmzZszevRo0tLS1C5PPEDFUrZMeN6HveOfZVIXHyq52HInJZMFO87R/PO/GL7mCMcuP83260Jke6wWoUGDBvHrr7/yxhtvsGXLFk6cOEGHDh1IS0tj0qRJtGrVqiBrVYW0CAlRvNy5c4fhw4cTHBwM5NzOR5gunV7hjxPXWbY7igNR9/azbOTlQp/m3jzn44b2P+OIdHqFA1G3iU1Mo6yDNY28XXKdI4qvAuka8/T0ZNmyZbRr147z589TtWpVhg4dyty5c41Rs0mRwdJCFG+//PILH3zwAVu2bKFatWpqlyMew7HL8SzfE8WvR6+S9e9AokoutvQK8OJ1fw/srczZEhHD5F8jiYm/1+JX3smaSV186OhbXq3SRSEqkCBkYWHBxYsXcXd3B8DW1pYDBw7g6+v79BWbKGkREqL4+u9mrfPmzaN169bUrVtXxapEfl2LT2PV3gt8fyCaOymZADhYmdPI24U/T8bmOv9uW9DCdxpIGCoBCmSMkF6vx8LCwvBcq9ViZ2f35FUKIYSK7g9Bu3bt4oMPPqBhw4Z8+umnZGZmqliZyI9yTtaM6ViDvR8+y9RuvlQuY0dietYDQxDc29Vq8q+R6PRGnTAtirDHXlCxU6dOho1Vf/31V9q2bZsrDK1fv964VapIWoSEKBmuX7/OwIED2bBhAwB+fn4EBwdTq1YtlSsT+aXXK3yz8xyfbz31yHN/6NeEplVkc97irEBahAIDAylbtixOTk44OTnxzjvv4O7ubnh+9yGEEEWNm5sbP//8M6tXr8bZ2ZmwsDAaNGjArFmz0Ol0apcn8sHMTIN7KZt8nTtjcyRLQs5zJDqOjCx9AVcmTJnRF1QsLmSwtBAl15UrV+jXrx+bN28GoFOnTvzvf/+TXdKLgL3nbvHWkn2P9R4rczPqejjj71WKhp4uNKhUCidbi0e/UZg01VaWLm6ka0yIkklRFJYvX84HH3zAV199Ra9evdQuSeSDTq/Q/PO/uBafxoO+3DSAi50lfZp7cyQ6jrCLccSl5B4PVt3NnoZeLjT0zA5HHi42EoSLGAlCRiJBSIiS7fr165QtW9bwJRgaGkr58uXx9vZWuTKRly0RMQxcfRggRxh60KwxRVE4dyOZQxduc+hidjCKupmc65plHaxo6FUKP8/scOTj7oiF9rFGl4hCJkHISCQICSHuiouLw9fXl/j4eL744gvee+89aSUwUU+zjtCNxHTCLsYRdjE7HEVciSdTl/Or0sZCSz0PZxp6laKhlwv1KznjaC3daaZEgpCRSBASQtx1+fJl3n77bXbt2gVA+/btWbp0KR4eHipXJh7EWCtLp2XqOHrpjqHF6NCF2ySkZeU4R6OBZ9wcaOhVCn8vF/w8S1HBWbrT1CRByEgkCAkh7qfX65k3bx7jx48nLS0NR0dH5s2bR2BgoHzplRB6vcLZG0kcuhBn6FKLvp2S67xyjtb4eZXC3zO71ahGOQfMpTut0EgQMhIJQkKIBzl16hSBgYHs378fgBdeeIGffvrJsM6aKFliE9IIuxjHwQvZXWrHryYYtv+4y85SS/1KpfDzLEVDr1LUr1QKeyvzPK4onpYEISORICSEyEtWVhazZ89m0qRJvPrqq3z33XdqlyRMREpGFkcvxRtajA5fjCMxPWd3mpkGapZ3pKFnKfy8XPD3KkV5p/ytgyQeTYLQU5J1hIQQ+RUREYG7uzsuLi4A3LhxA4AyZcqoWZYwITq9wunridnjjP4NR5fjUnOdV8HZxtBi1NDThWfKOTzRuCYhQchopEVICPE4FEXh5ZdfZs+ePSxatIiXX35Z7ZKEiboWn8ahi7ezxxpdvE3k1QT+uwWag5U59So54//vmkb1KjljayndafkhQchIJAgJIR7H7du3adWqFREREQB0796dr776ytBaJERektOzCL90xxCMjkTfIek/3WlaMw0+5R0NLUYNvUrh5mitUsWmTYKQkUgQEkI8rvT0dCZPnsznn3+OXq+nfPnyLFmyhOeff17t0kQRotMrnLyW8G8wyu5Su3rfukh3VSxlY5iy39CrFNXLOmAm3WkShIxFgpAQ4knt37+fwMBATp3K3g29d+/ezJs3DwcHB5UrE0XVlTupHLpw+9/1jOI4ee0B3WnW5tmhyDN7Jex6Hs7YWGrVKVhFEoSMRIKQEOJppKamMnHiRObMmYOnpyfHjh3D3t5e7bJEMZGYlsmR6LuLPWZ3p6Vk6HKcY26moVYFp3/3TSuFn1cpyjoU/+40CUJGIkFICGEMu3btwszMjGbNmgHZCzOmpqZiZ2encmWiOMnS6TkRk5hjEPb1hPRc53mWtsXPs5RhEHaVMvbFrjtNgpCRSBASQhSEBQsW8MUXX7BixQpatmypdjmimFIUhctxqf8u9pjdpXbqeiL//eZ3srHIMW2/TkUnrC2KdneaBCEjkSAkhDA2nU5HnTp1iIyMRKPRMGzYMKZPn46NjSymJwpefGomh6PjCPu3xSj80h3SMvU5zrHQaqhdwYmGdwdhe5aitH3RWjVdgpCRSBASQhSEhIQERo4cydKlSwGoXr06wcHBNGnSROXKREmTqdNz/GrCvUHYF+O4kZi7O62yq52h1cjP04UqZexMen89CUJPSVaWFkIUhs2bN/Puu+9y9epVzMzMGD16NJMnT5Y9y4RqFEUh+naKYdr+oQu3OROblOs8FztLGlS6251WitoVnbAyz393mk6vcCDqNrGJaZR1sKaRt4tRV9GWIGQk0iIkhChocXFxDBs2jG+//RatVsvBgwepX7++2mUJYXAnJYPD0dlT9g9diOPo5TukZ+XsTrM0N6NOBSf8vErh75ndpVbKzvKB19sSEcPkXyOJuW9dpPJO1kzq4kNH3/JGqVmCkJFIEBJCFJaNGzdy7tw5Ro4caTimKIpJdz+IkikjS0/E1XjCLtwbhH0rOSPXeVXK2N232KMLXqVt2Xr8GgNXH+a/4ePun/KF7zQwShiSIGQkEoSEEGqJiIigX79+LF68mNq1a6tdjhB5UhSFC7dSskPRv4Owz91IznVeaTsLktJ1uVqT7tIA5Zys2T227VN3k0kQMhIJQkIItXTo0IFt27ZhYWHB5MmTGT16NObmsuGmKBpuJ2f8O/g6Oxz9czmeDN2DA9B//dCvCU2rlH6q++f3+9vsqe4ihBCiwAQHB9O1a1cyMzMZP348zZo14+TJk2qXJUS+uNhZ8pyPG+M61eSngQH880l7hj9bLV/vjU3MvadaQZEgJIQQJqpcuXJs3LiR4OBgnJycOHDgAPXr1+fLL79Ep9M9+gJCmBBrCy2NK+evlacwtwCRICSEECZMo9HQs2dPIiIi6NChA2lpaYwcOZLvvvtO7dKEeGyNvF0o72RNXqN/NGTPHmvk7VJoNUkQEkKIIqBixYps3ryZxYsX06FDB7p37652SUI8Nq2ZhkldfAByhaG7zyd18THqekKPIkFICCGKCI1GQ79+/di8eTNabfbCdampqfTr14+LFy+qXJ0Q+dPRtzwL32lAOaec3V/lnKyNNnX+ccissUeQWWNCCFM2duxYZs6ciYODA19++SV9+/aVdYdEkWAqK0tLi5AQQhRh7777LgEBASQmJtKvXz+ef/55rly5onZZQjyS1kxD0yqlebFeBZpWKV2o3WH3KxFBKCoqijZt2uDj40Pt2rVJTs69yJMQQhRF1apVIyQkhNmzZ2NlZcXmzZvx9fXl22+/RRr8hXi0EhGEevXqxZQpU4iMjGTnzp2ymaEQoljRarWMHDmSI0eO4O/vz507d+jZsyfTpk1TuzQhTF6xD0LHjx/HwsKCFi1aAODi4iIrswohiqWaNWsSGhrK1KlTcXV1pWfPnmqXJITJUz0IhYSE0KVLF9zd3dFoNGzcuDHXOQsWLMDb2xtra2v8/PzYtWtXvq9/5swZ7O3t6dq1Kw0aNGD69OlGrF4IIUyLubk5EyZMICoqikqVKhmOL1u2jJs3b6pYmRCmSfUglJycTN26dZk/f/4DX1+7di3Dhw9nwoQJHDlyhBYtWtCpUyeio6MN5/j5+eHr65vrcfXqVTIzM9m1axdBQUHs3buX7du3s3379sL6eEIIoQp7e3vD77du3cq7775LrVq12LRpk4pVCWF6VO8j6tSpE506dcrz9bvTQd99910A5s6dy9atW1m4cCEzZswAICwsLM/3V6xYEX9/fzw8PADo3Lkz4eHhPPfccw88Pz09nfT0dMPzhISEx/5MQghhSsqUKYOPjw+RkZF069aNHj16MG/ePEqVKqV2aUKoTvUWoYfJyMggLCyM9u3b5zjevn17QkND83UNf39/rl+/TlxcHHq9npCQEGrWrJnn+TNmzMDJycnwuBughBCiqGrQoAFhYWGMGTMGMzMzvv32W3x9fdmyZYvapQmhOpMOQjdv3kSn0+Hm5pbjuJubG9euXcvXNczNzZk+fTotW7akTp06VKtWjRdeeCHP88eNG0d8fLzhcenSpaf6DEIIYQqsra35/PPP2b17N9WqVePq1at06tSJsWPHql2aEKpSvWssP/67SqqiKI+1cuqjut/uZ2VlhZWVFUFBQQQFBckOz0KIYqVp06aEh4czfvx45s2bh7+/v9olCaEqk24RcnV1RavV5mr9iY2NzdVKZGyDBw8mMjKSgwcPFuh9hBCisNna2jJ37lyOHz/Oq6++ajgeFhYmC86KEsekg5ClpSV+fn65Znlt376dgIAAlaoSQojiwcfHx/D72NhYOnbsSN26ddm9e7eKVQlRuFQPQklJSYSHhxMeHg5kb4cRHh5umB4/YsQIli5dyvLlyzlx4gQffPAB0dHRDBgwoEDrCgoKwsfHR5qNhRAlwqVLl7C2tubcuXO0bNmSkSNHkpqaqnZZQhQ41Xef37FjB23atMl1PDAwkJUrVwLZCyrOnDmTmJgYfH19mTNnDi1btiyU+mT3eSFESREfH88HH3zAihUrAKhRowbBwcE0atRI5cqEeHz5/f5WPQiZOglCQoiS5rfffqNfv35cu3YNMzMzPvzwQ6ZOnfpYk1SEUFt+v79V7xoTQghhWl544QUiIiJ4++230ev13LhxQ0KQKLaKxPR5Ncj0eSFESVa6dGm+++473njjjRzDF27duoWjoyMWFhYqVieE8UjX2CNI15gQQmRTFIX27dsTFxdHcHAwtWrVUrskIfIkXWNCCCGM6ty5c4SFhREWFkaDBg2YOXOmtJqLIk+CkBBCiHypWrUqERERPP/882RkZDB27FiaN2/O6dOn1S5NiCcmQSgPso6QEELk5u7uzq+//sry5ctxdHRk37591K1bl7lz56LX69UuT4jHJmOEHkHGCAkhxINdunSJvn37sn37dmrUqMGRI0ewtrZWuywhgPx/f8usMSGEEE/Ew8ODrVu3snjxYurXr28IQTqdDjMzM5lyL4oE6RoTQgjxxDQaDf3798+x+vQXX3xBhw4duHTpkoqVCZE/EoTyIGOEhBDi8SUmJjJjxgy2b9+Or68vy5cvR0ZgCFMmY4QeQcYICSHE4zl9+jSBgYHs27cPgOeff54lS5ZQvnx5lSsTJYmsIySEEEIV1atXZ/fu3Xz++edYWlryv//9j1q1avH9999L65AwORKEhBBCGJ1Wq2XMmDEcPnwYPz8/4uLi6N27N9HR0WqXJkQOMmtMCCFEgalVqxZ79+7ls88+w9bWFk9PT7VLEiIHaRESQghRoCwsLPjoo48YOXKk4djBgwfp0aMHt2/fVrEyISQI5UlmjQkhRMHQ6/X07duX1atXU6tWLX777Te1SxIlmMwaewSZNSaEEMZ34MABAgMDOXnyJAC9evVi7ty5ODk5qVyZKC5k1pgQQgiT1ahRIw4fPszIkSPRaDSsXLkSX19ftm3bpnZpooSRICSEEEIVNjY2zJ49m5CQEKpUqcLly5fp0KEDO3bsULs0UYLIrDEhhBCqat68OUePHuXDDz/k1KlTtGzZUu2SRAkiLUJCCCFUZ2dnx9dff83//vc/zMyyv5oSExP55JNPSElJUbk6UZxJEBJCCGEyLCwsDL8fPXo0kydPpl69eoSGhqpYlSjOJAjlQabPCyGEul588UXc3d05c+YMLVq0YOzYsaSlpaldlihmZPr8I8j0eSGEUE9cXBzDhw9n1apVAPj4+BAcHEzDhg1VrkyYOpk+L4QQosgrVaoUwcHBbNy4ETc3NyIjI2nSpAlr1qxRuzRRTEgQEkIIYfJefPFFIiIieOONN3B2dqZNmzZqlySKCQlCQgghigRXV1fWrFnD0aNHcXNzMxzfsGEDWVlZKlYmijIJQkIIIYqUChUqGH6/fv16Xn75ZQICAjhx4oSKVYmiSoKQEEKIIkuv1+Ps7MzBgwepX78+s2fPRqfTqV2WKEIkCAkhhCiyXn31VSIiIujYsSPp6emMHj2ali1bcubMGbVLE0WEBCEhhBBFWoUKFfj9999ZsmQJDg4OhIaGUrduXYKDg9UuTRQBEoSEEEIUeRqNhnfffZdjx47Rtm1bUlNTKVu2rNpliSJAglAeZGVpIYQoejw9Pdm+fTt//vknnTp1Mhw/c+YMsn6weBBZWfoRZGVpIYQo2i5fvoyvry9NmjRh6dKlVKxYUe2SRCGQlaWFEEII4ODBg6SlpbF161Z8fX0JDg6W1iFhIEFICCFEsfbSSy8RHh5Oo0aNiI+Pp1evXrz44otcu3ZN7dKECZAgJIQQotirUaMGe/bsYfr06VhYWPDrr79Sq1Yt1q1bp3ZpQmUShIQQQpQI5ubmjBs3jrCwMOrXr8/t27fZt2+f2mUJlZmrXYAQQghRmGrXrs3+/fsJCgqif//+huMpKSnY2tqqWJlQg7QICSGEKHEsLCwYPnw4NjY2AOh0Otq3b0+PHj2Ii4tTuTpRmCQICSGEKPFCQ0PZu3cvq1evxtfXl82bN6tdkigkEoSEEEKUeC1atGDPnj1Ur16dq1ev0rlzZ959910SEhLULk0UMAlCQgghBNCkSROOHDnCBx98gEajYdmyZdSuXZs///xT7dJEAZIgJIQQQvzL1taWL7/8kh07dlC5cmWio6MZPXo0er1e7dJEASn2QejUqVPUq1fP8LCxsWHjxo1qlyWEEMKEtWzZkqNHj/L++++zcuVKzMyK/ddliVWi9hpLSkrCy8uLixcvYmdnl6/3yF5jQggh7po8eTLx8fFMmzbNMONMmCbZa+wBfvnlF5599tl8hyAhhBDirujoaKZOncqcOXOoX78++/fvV7skYQSqB6GQkBC6dOmCu7s7Go3mgd1WCxYswNvbG2tra/z8/Ni1a9cT3WvdunW88cYbT1mxEEKIkqhSpUps3LiR8uXLc+rUKQICAhg3bhzp6elqlyaegupBKDk5mbp16zJ//vwHvr527VqGDx/OhAkTOHLkCC1atKBTp05ER0cbzvHz88PX1zfX4+rVq4ZzEhIS2LNnD507dy7wzySEEKJ4ev7554mIiKB79+7o9Xo+++wzGjZsyOHDh9UuTTwhkxojpNFo2LBhA926dTMca9y4MQ0aNGDhwoWGYzVr1qRbt27MmDEj39f+9ttv2bp1K6tXr37oeenp6TnSfUJCAh4eHjJGSAghRA4bNmygf//+3LhxAycnJ6Kjo+V7woQUizFCGRkZhIWF0b59+xzH27dvT2ho6GNdK7/dYjNmzMDJycnw8PDweKz7CCGEKBleeukljh8/ziuvvMLUqVMlBBVRJh2Ebt68iU6nw83NLcdxNzc3rl27lu/rxMfHc+DAATp06PDIc8eNG0d8fLzhcenSpceuWwghRMlQpkwZfvzxRwYPHmw4FhISwowZM8jKylKxMpFfRWL3eY1Gk+O5oii5jj2Mk5MT169fz9e5VlZWWFlZPVZ9QgghSq77v49SUlLo3bs358+fZ9OmTaxcuZIaNWqoWJ14FJNuEXJ1dUWr1eZq/YmNjc3VSmRsQUFB+Pj44O/vX6D3EUIIUXzY2Njw8ccf4+joyP79+6lfvz5z5syRlalNmEkHIUtLS/z8/Ni+fXuO49u3bycgIKBA7z148GAiIyM5ePBggd5HCCFE8aHRaAgMDCQiIoL27duTlpbGiBEjaN26NefOnVO7PPEAqgehpKQkwsPDCQ8PByAqKorw8HDD9PgRI0awdOlSli9fzokTJ/jggw+Ijo5mwIABKlYthBBC5M3Dw4MtW7awaNEi7Ozs2LVrF3Xq1OH06dNqlyb+Q/Xp8zt27KBNmza5jgcGBrJy5Uoge0HFmTNnEhMTg6+vL3PmzKFly5YFWldQUBBBQUHodDpOnz4t0+eFEEI8kaioKPr06YODgwObNm16rDGu4snld/q86kHI1MleY0IIIZ6WXq8nOTkZBwcHAOLi4vj111/p0aOHBKMCUizWERJCCCGKAzMzM0MIAhg6dCiBgYG88MILOXZBEIVPglAeZNaYEEKIgqAoCnXq1MHKyorff/+dWrVqsXr1aqSDRh3SNfYI0jUmhBCiIERGRhIYGMihQ4cA6NatG4sWLSrw5WFKCukaE0IIIUyYj48Pe/fu5dNPP8XCwoKNGzdSq1Yt9u7dq3ZpJYoEISGEEEIl5ubmTJw4kYMHD1KnTh0sLS155pln1C6rRJEglAcZIySEEKKw1K1bl4MHD/Lnn3/i4uICZI8l2rdvn8qVFX8ShPIgK0sLIYQoTJaWltSsWdPwfPXq1TRt2pTAwEDu3LmjXmHFnAQhIYQQwgRduHABjUbDqlWr8PX1ZevWrWqXVCxJEBJCCCFM0EcffcTu3bupWrUqV65coWPHjrz33nskJiaqXVqxIkFICCGEMFEBAQEcPXqUoUOHArBkyRJq167N7t27Va6s+JAglAcZLC2EEMIU2NraMm/ePP7++2+8vLy4ePEiOp1O7bKKDVlQ8RFkQUUhhBCmIjExkS1btvDaa68Zjt28eRNXV1cVqzJNsqCiEEIIUcw4ODjkCEFnz56lcuXKjB49mrS0NBUrK7okCAkhhBBF1MaNG0lMTGT27Nk0aNBAlnx5AhKEhBBCiCJq1KhR/PLLL7i5uXHixAmaNm3KxIkTycjIULu0IkOCUB5ksLQQQoiioEuXLhw/fpw333wTnU7HtGnTaNSoEUePHlW7tCJBglAeZGVpIYQQRUXp0qX54Ycf+PHHH3F1deXo0aP8/PPPapdVJEgQEkIIIYqJV199lePHjzNy5EgmTpxoOK7X61WsyrRJEBJCCCGKkbJlyzJ79mwsLS0ByMzMpHnz5syaNUvWH3oACUJCCCFEMbZ27Vr27t3LmDFjaNmyJWfOnFG7JJMiQUgIIYQoxrp3786yZctwcHAgNDSUunXr8tVXX0l32b8kCAkhhBDFmEajoU+fPkRERNCuXTtSU1MZNmwYbdu2JSoqSu3yVCdBSAghhCgBKlWqxLZt21iwYAF2dnbs3LmTAQMGqF2W6iQI5UHWERJCCFHcaDQaBg4cyD///EOHDh2YP3++2iWpTjZdfQTZdFUIIURJ8Mknn+Dl5UVgYCAajUbtcp6abLoqhBBCiHw5dOgQU6ZMoXfv3nTt2pWYmBi1Syo0EoSEEEKIEq5evXpMnz4dS0tLfvvtN2rVqsUPP/xASeg0kiAkhBBClHDm5uZ8+OGHhIWFUb9+feLi4nj77bd57bXXuHHjhtrlFSgJQkIIIYQAwNfXl/379/PJJ59gbm7Ozz//TEBAAFlZWWqXVmAkCAkhhBDCwMLCgkmTJrF//358fX0ZP3485ubmapdVYIrvJxNCCCHEE2vQoAFhYWFYWFgYjv3555+kpaXx/PPPq1iZcUmLkBBCCCEeyNLS0jCV/s6dOwQGBvLCCy/Qp08f4uPjVa7OOCQICSGEEOKRrKyseOONN9BoNKxYsYLatWuzfft2tct6ahKE8iArSwshhBD32NjY8MUXX7Bz506qVKnCpUuXaN++PQMHDiQpKUnt8p6YrCz9CLKytBBCCJFTcnIyY8eOJSgoCABvb28OHjxI6dKlVa7sHllZWgghhBAFws7Ojvnz5/PHH39QqVIlmjRpYlIh6HHIrDEhhBBCPJFnn32WY8eOodPpDMdiY2M5f/48TZo0UbGy/JMWISGEEEI8MUdHR0qVKgWAoij079+fZs2aMXbsWNLS0lSu7tEkCAkhhBDCKDIyMnBwcECv1zNz5kz8/PwICwtTu6yHkiAkhBBCCKOwsrJi1apVbNiwgbJlyxIZGUnjxo2ZNGkSGRkZapf3QBKEhBBCCGFU3bp14/jx47z22mvodDqmTJlC48aNiYqKUru0XCQICSGEEMLoXF1dWbduHWvXrqV06dLcuXMHV1dXtcvKRWaNCSGEEKLAvP7667Rs2ZKYmBgcHByA7EHVFy5cwNvbW+XqpEVICCGEEAWsXLly1K9f3/B80aJF1KxZky+//DLH1Hs1SBASQgghRKH666+/SE9PZ+TIkQwdOlTVWkpEEJozZw61atXCx8eHoUOHIruKCCGEEOpZt24dixcvxtXVlcGDB6taS7Hfa+zGjRs0adKE48ePY2FhQcuWLZk9ezZNmzbN1/tlrzEhhBCiYKSkpGBra1sg187v93eJGCydlZVlWN0yMzOTsmXLqlyREEIIIQoqBD0O1bvGQkJC6NKlC+7u7mg0GjZu3JjrnAULFuDt7Y21tTV+fn7s2rUr39cvU6YMo0aNolKlSri7u9OuXTuqVKlixE8ghBBCiKJK9SCUnJxM3bp1mT9//gNfX7t2LcOHD2fChAkcOXKEFi1a0KlTJ6Kjow3n+Pn54evrm+tx9epV4uLi+O2337hw4QJXrlwhNDSUkJCQwvp4QgghhDBhJjVGSKPRsGHDBrp162Y41rhxYxo0aMDChQsNx2rWrEm3bt2YMWPGI6/5448/smPHDoKCggCYNWsWiqIwZsyYB56fnp5Oenq64XlCQgIeHh4yRkgIIYQoQvI7Rkj1FqGHycjIICwsjPbt2+c43r59e0JDQ/N1DQ8PD0JDQ0lLS0On07Fjxw6eeeaZPM+fMWMGTk5OhoeHh8dTfQYhhBBCmC6TDkI3b95Ep9Ph5uaW47ibmxvXrl3L1zWaNGlC586dqV+/PnXq1KFKlSp07do1z/PHjRtHfHy84XHp0qWn+gxCCCGEMF1FYtaYRqPJ8VxRlFzHHmbatGlMmzYtX+daWVlhZWVFUFAQQUFBqq94KYQQQoiCY9ItQq6urmi12lytP7GxsblaiYxt8ODBREZGcvDgwQK9jxBCCCHUY9JByNLSEj8/P7Zv357j+Pbt2wkICFCpKiGEEEIUF6p3jSUlJXH27FnD86ioKMLDw3FxcaFSpUqMGDGCHj160LBhQ5o2bcrixYuJjo5mwIABBVqXdI0JIYQQxZ/q0+d37NhBmzZtch0PDAxk5cqVQPaCijNnziQmJgZfX1/mzJlDy5YtC6U+2WJDCCGEKHry+/2tehAydRKEhBBCiKKnWKwjJIQQQghRkCQI5SEoKAgfHx/8/f3VLkUIIYQQBUS6xh4hPj4eZ2dnLl26JF1jQgghRBFxd4usO3fu4OTklOd5qs8aM3WJiYkAstWGEEIIUQQlJiY+NAhJi9Aj6PV6rl69ioODw2OtZl0c+fv7l7gFJovSZzaVWguzjoK8l7GvbazrPc117v4LWVq4TZep/H9cmArqMyuKQmJiIu7u7piZ5T0SSFqEHsHMzIyKFSuqXYZJ0Gq1Je4vz6L0mU2l1sKsoyDvZexrG+t6xriOo6OjSfxZEbmZyv/HhakgP/PDWoLuksHSIt8GDx6sdgmFrih9ZlOptTDrKMh7Gfvaxrqeqfx3FgWjJP73VfszS9eYEEKUELIumhC5SYuQEEKUEFZWVkyaNAkrKyu1SxHCZEiLkBBCCCFKLGkREkIIIUSJJUFICCGEECWWBCEhhBBClFgShIQQQghRYkkQEkIIIUSJJUFICCFKuEuXLtG6dWt8fHyoU6cOP/74o9olCVFoZPq8EEKUcDExMVy/fp169eoRGxtLgwYNOHXqFHZ2dmqXJkSBk73GhBCihCtfvjzly5cHoGzZsri4uHD79m0JQqJEkK4xIYQo4kJCQujSpQvu7u5oNBo2btyY65wFCxbg7e2NtbU1fn5+7Nq164HXOnToEHq9Hg8PjwKuWgjTIEFICCGKuOTkZOrWrcv8+fMf+PratWsZPnw4EyZM4MiRI7Ro0YJOnToRHR2d47xbt27Rs2dPFi9eXBhlC2ESZIyQEEIUIxqNhg0bNtCtWzfDscaNG9OgQQMWLlxoOFazZk26devGjBkzAEhPT+e5556jX79+9OjRo7DLFkI10iIkhBDFWEZGBmFhYbRv3z7H8fbt2xMaGgqAoij06tWLtm3bSggSJY4EISGEKMZu3ryJTqfDzc0tx3E3NzeuXbsGwJ49e1i7di0bN26kXr161KtXj2PHjqlRrhCFTmaNCSFECaDRaHI8VxTFcKx58+bo9Xo1yhJCddIiJIQQxZirqytardbQ+nNXbGxsrlYiIUoiCUJCCFGMWVpa4ufnx/bt23Mc3759OwEBASpVJYTpkK4xIYQo4pKSkjh79qzheVRUFOHh4bi4uFCpUiVGjBhBjx49aNiwIU2bNmXx4sVER0czYMAAFasWwjTI9HkhhCjiduzYQZs2bXIdDwwMZOXKlUD2goozZ84kJiYGX19f5syZQ8uWLQu5UiFMjwQhIYQQQpRYMkZICCGEECWWBCEhhBBClFgShIQQQghRYkkQEkIIIUSJJUFICCGEECWWBCEhhBBClFgShIQQQghRYkkQEkIIIUSJJUFICCGEECWWBCEhhGpat27N8OHD1S7DQFEU3nvvPVxcXNBoNISHh6tdkhCigMmmq0II8a8tW7awcuVKduzYQeXKlXF1dVW7JCFEAZMgJIQoVnQ6HRqNBjOzx2/wPnfuHOXLlycgIKAAKnu4jIwMLC0tC/2+QpR00jUmRAnXunVrhg4dypgxY3BxcaFcuXJ88sknhtcvXLiQq5vozp07aDQaduzYAWTvfq7RaNi6dSv169fHxsaGtm3bEhsby+bNm6lZsyaOjo689dZbpKSk5Lh/VlYW77//Ps7OzpQuXZqJEydy/17QGRkZjBkzhgoVKmBnZ0fjxo0N9wVYuXIlzs7O/Pbbb/j4+GBlZcXFixcf+Fl37txJo0aNsLKyonz58nz44YdkZWUB0KtXL4YMGUJ0dDQajQYvL68HXuPu/TZu3Ej16tWxtrbmueee49KlS4Zzzp07x4svvoibmxv29vb4+/vzxx9/5LiOl5cXU6dOpVevXjg5OdGvXz8Axo4dS/Xq1bG1taVy5cp89NFHZGZmGt73ySefUK9ePZYvX06lSpWwt7dn4MCB6HQ6Zs6cSbly5ShbtizTpk3Lcb9PPvmESpUqYWVlhbu7O0OHDn3g5xOixFGEECVaq1atFEdHR+WTTz5RTp8+rQQHBysajUbZtm2boiiKEhUVpQDKkSNHDO+Ji4tTAOXvv/9WFEVR/v77bwVQmjRpouzevVs5fPiwUrVqVaVVq1ZK+/btlcOHDyshISFK6dKllc8++yzHve3t7ZVhw4YpJ0+eVFavXq3Y2toqixcvNpzz9ttvKwEBAUpISIhy9uxZZdasWYqVlZVy+vRpRVEUZcWKFYqFhYUSEBCg7NmzRzl58qSSlJSU63NevnxZsbW1VQYNGqScOHFC2bBhg+Lq6qpMmjRJURRFuXPnjjJlyhSlYsWKSkxMjBIbG/vAn9fd+zVs2FAJDQ1VDh06pDRq1EgJCAgwnBMeHq4sWrRI+eeff5TTp08rEyZMUKytrZWLFy8azvH09FQcHR2VWbNmKWfOnFHOnDmjKIqifPrpp8qePXuUqKgo5ZdfflHc3NyUzz//3PC+SZMmKfb29sqrr76qHD9+XPnll18US0tLpUOHDsqQIUOUkydPKsuXL1cAZe/evYqiKMqPP/6oODo6Kr///rty8eJFZf/+/Tl+xkKUZBKEhCjhWrVqpTRv3jzHMX9/f2Xs2LGKojxeEPrjjz8M58yYMUMBlHPnzhmO9e/fX+nQoUOOe9esWVPR6/WGY2PHjlVq1qypKIqinD17VtFoNMqVK1dy1Pfss88q48aNUxQlO5gASnh4+EM/5/jx45Vnnnkmx72CgoIUe3t7RafTKYqiKHPmzFE8PT0fep2799u3b5/h2IkTJxRA2b9/f57v8/HxUb7++mvDc09PT6Vbt24PvZeiKMrMmTMVPz8/w/NJkyYptra2SkJCguFYhw4dFC8vL8PnUBRFeeaZZ5QZM2YoiqIoX3zxhVK9enUlIyPjkfcToqSRrjEhBHXq1MnxvHz58sTGxj7Vddzc3AzdO/cf++91mzRpgkajMTxv2rQpZ86cQafTcfjwYRRFoXr16tjb2xseO3fu5Ny5c4b3WFpa5voM/3XixAmaNm2a417NmjUjKSmJy5cvP9bnNDc3p2HDhobnNWrUwNnZmRMnTgCQnJzMmDFj8PHxwdnZGXt7e06ePEl0dHSO69x/jbt++uknmjdvTrly5bC3t+ejjz7K9T4vLy8cHBwMz93c3PDx8ckxLur+n/Vrr71GamoqlStXpl+/fmzYsMHQJShESSeDpYUQWFhY5Hiu0WjQ6/UAhi9X5b5xO/ePWcnrOhqN5qHXzQ+9Xo9WqyUsLAytVpvjNXt7e8PvbWxscgScB1EUJdc5dz/To977IA96z91jo0ePZuvWrcyePZuqVatiY2PDq6++SkZGRo7z7ezscjzft28fb775JpMnT6ZDhw44OTmxZs0avvjiixznPejn+rCftYeHB6dOnWL79u388ccfDBo0iFmzZrFz585c7xOipJEgJIR4qDJlygAQExND/fr1AYy6vs6+fftyPa9WrRparZb69euj0+mIjY2lRYsWT3UfHx8ffv755xyBKDQ0FAcHBypUqPBY18rKyuLQoUM0atQIgFOnTnHnzh1q1KgBwK5du+jVqxcvvfQSAElJSVy4cOGR192zZw+enp5MmDDBcCyvgd+Py8bGhq5du9K1a1cGDx5MjRo1OHbsGA0aNDDK9YUoqqRrTAjxUDY2NjRp0oTPPvuMyMhIQkJCmDhxotGuf+nSJUaMGMGpU6f44Ycf+Prrrxk2bBgA1atXp3v37vTs2ZP169cTFRXFwYMH+fzzz/n9998f6z6DBg3i0qVLDBkyhJMnT7Jp0yYmTZrEiBEjHnuqvYWFBUOGDGH//v0cPnyY3r1706RJE0Mwqlq1KuvXryc8PJyjR4/y9ttv56slrGrVqkRHR7NmzRrOnTvHV199xYYNGx6rtgdZuXIly5YtIyIigvPnz/Ptt99iY2ODp6fnU19biKJOgpAQ4pGWL19OZmYmDRs2ZNiwYUydOtVo1+7Zsyepqak0atSIwYMHM2TIEN577z3D6ytWrKBnz56MHDmSZ555hq5du7J//348PDwe6z4VKlTg999/58CBA9StW5cBAwbQt2/fJwp1tra2jB07lrfffpumTZtiY2PDmjVrDK/PmTOHUqVKERAQQJcuXejQoUO+Wl5efPFFPvjgA95//33q1atHaGgoH3300WPX91/Ozs4sWbKEZs2aUadOHf78809+/fVXSpcu/dTXFqKo0yj3d/wLIYR4qJUrVzJ8+HDu3LmjdilCCCOQFiEhhBBClFgShIQQQghRYknXmBBCCCFKLGkREkIIIUSJJUFICCGEECWWBCEhhBBClFgShIQQQghRYkkQEkIIIUSJJUFICCGEECWWBCEhhBBClFgShIQQQghRYv0fL/17NZbdbq0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_params = 3 * grids\n", - "train_vs_G = train_losses[(steps-1)::steps]\n", - "test_vs_G = test_losses[(steps-1)::steps]\n", - "plt.plot(n_params, train_vs_G, marker=\"o\")\n", - "plt.plot(n_params, test_vs_G, marker=\"o\")\n", - "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.legend(['train', 'test', r'$N^{-4}$'])\n", - "plt.xlabel('number of params')\n", - "plt.ylabel('RMSE')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_2_deep_formula_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_2_deep_formula_-checkpoint.ipynb deleted file mode 100644 index f43dc0569..000000000 --- a/docs/.ipynb_checkpoints/Example_2_deep_formula_-checkpoint.ipynb +++ /dev/null @@ -1,289 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 2: Deep Formulas\n", - "\n", - "### The orignal Kolmogorov-Arnold theorem says that it suffices to have 2-Layer function composition (inner and outer functions), but the functions might be non-smooth or even fractal. We generalize KA representation to arbitrary depths. An example a 2-Layer KAN (with smooth activations) is unable to do is: $f(x_1,x_2,x_3,x_4)={\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$, which requires at least 3-Layer KANs." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.26e-02 | test loss: 1.20e-02 | reg: 6.73e+00 : 100%|██| 20/20 [00:32<00:00, 1.63s/it]\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000)\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.001, lamb_entropy=2.);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d81e80f7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "4cd7456f", - "metadata": {}, - "outputs": [], - "source": [ - "# it seems that removing edge manually does not change results too much. We include both for completeness.\n", - "remove_edge = True\n", - "\n", - "if remove_edge == True:\n", - " model.remove_edge(0,0,1)\n", - " model.remove_edge(0,1,1)\n", - " model.remove_edge(0,2,0)\n", - " model.remove_edge(0,3,0)\n", - "else:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ee39c97b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.77e-03 | test loss: 4.57e-03 | reg: 7.07e+00 : 100%|██| 50/50 [00:42<00:00, 1.19it/s]\n", - "train loss: 1.78e-03 | test loss: 1.84e-03 | reg: 7.15e+00 : 100%|██| 50/50 [00:46<00:00, 1.07it/s]\n", - "train loss: 1.56e-04 | test loss: 1.47e-04 | reg: 7.04e+00 : 100%|██| 50/50 [01:10<00:00, 1.41s/it]\n", - "train loss: 1.13e-05 | test loss: 1.05e-05 | reg: 7.05e+00 : 100%|██| 50/50 [01:27<00:00, 1.74s/it]\n", - "train loss: 6.00e-07 | test loss: 5.07e-07 | reg: 7.05e+00 : 100%|██| 50/50 [01:50<00:00, 2.21s/it]\n" - ] - } - ], - "source": [ - "grids = [3,5,10,20,50]\n", - "#grids = [5]\n", - "\n", - "train_rmse = []\n", - "test_rmse = []\n", - "\n", - "for i in range(len(grids)):\n", - " model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", - " results = model.train(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "94f3930a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.004774762578012783, 0.0017847731212278354, 0.00015569770964015761, 1.1261090479694874e-05, 5.997260680598509e-07]\n", - "[0.004566344580739028, 0.0018364543204432066, 0.00014685209697567987, 1.0454170453671914e-05, 5.074556425958742e-07]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "n_params = np.array(grids) * (4*2+2*1+1*1)\n", - "plt.plot(n_params, train_rmse, marker=\"o\")\n", - "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 10000*n_params**(-4.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "print(train_rmse)\n", - "print(test_rmse)" - ] - }, - { - "cell_type": "markdown", - "id": "f53644fe", - "metadata": {}, - "source": [ - "### Now we show that a 2 two-layer KAN performs much worse for this task" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "58c4ae70", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.41e-02 | test loss: 7.32e-02 | reg: 1.36e+01 : 100%|██| 20/20 [00:34<00:00, 1.74s/it]\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,9,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000)\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.001, lamb_entropy=2.);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "869828f2", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.75e-02 | test loss: 2.97e-02 | reg: 1.81e+01 : 100%|██| 50/50 [01:24<00:00, 1.69s/it]\n", - "train loss: 1.76e-02 | test loss: 2.01e-02 | reg: 1.76e+01 : 100%|██| 50/50 [01:38<00:00, 1.97s/it]\n", - "train loss: 3.79e-03 | test loss: 4.85e-03 | reg: 1.78e+01 : 100%|██| 50/50 [01:48<00:00, 2.16s/it]\n", - "train loss: 1.77e-03 | test loss: 2.95e-03 | reg: 1.77e+01 : 100%|██| 50/50 [02:07<00:00, 2.55s/it]\n", - "train loss: 7.62e-03 | test loss: 1.18e-02 | reg: 1.74e+01 : 100%|██| 50/50 [03:06<00:00, 3.73s/it]\n" - ] - } - ], - "source": [ - "grids = [3,5,10,20,50]\n", - "#grids = [5]\n", - "\n", - "train_rmse = []\n", - "test_rmse = []\n", - "\n", - "for i in range(len(grids)):\n", - " model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", - " results = model.train(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4f0a99fd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.027514415570597788, 0.0175788804953916, 0.0037939843087960545, 0.001766220055347071, 0.007622899974849284]\n", - "[0.029668332328004216, 0.020098020933420547, 0.00485182714170569, 0.00294601553725477, 0.01183480890790476]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "n_params = np.array(grids) * (4*9+9*1)\n", - "plt.plot(n_params, train_rmse, marker=\"o\")\n", - "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 300*n_params**(-2.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "print(train_rmse)\n", - "print(test_rmse)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5776b6e1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_3_classfication_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_3_classfication_-checkpoint.ipynb deleted file mode 100644 index b1bd2bc49..000000000 --- a/docs/.ipynb_checkpoints/Example_3_classfication_-checkpoint.ipynb +++ /dev/null @@ -1,436 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 3: Classification" - ] - }, - { - "cell_type": "markdown", - "id": "31bcb9ac", - "metadata": {}, - "source": [ - "### Let's first treat the problem as a regression problem (output dimension = 1, MSE loss). " - ] - }, - { - "cell_type": "markdown", - "id": "908489de", - "metadata": {}, - "source": [ - "### create the two moon dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "763d1fb4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.datasets import make_moons\n", - "import torch\n", - "import numpy as np\n", - "\n", - "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "\n", - "dataset['train_input'] = torch.from_numpy(train_input)\n", - "dataset['test_input'] = torch.from_numpy(test_input)\n", - "dataset['train_label'] = torch.from_numpy(train_label[:,None])\n", - "dataset['test_label'] = torch.from_numpy(test_label[:,None])\n", - "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0], X[:,1], c=y[:,0])" - ] - }, - { - "cell_type": "markdown", - "id": "06649143", - "metadata": {}, - "source": [ - "### Train KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.55e-01 | test loss: 1.63e-01 | reg: 5.98e+00 : 100%|██| 20/20 [00:02<00:00, 7.58it/s]\n" - ] - }, - { - "data": { - "text/plain": [ - "(1.0, 0.9980000257492065)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model = KAN(width=[2,1], grid=3, k=3)\n", - "\n", - "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).float())\n", - "\n", - "results = model.train(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" - ] - }, - { - "cell_type": "markdown", - "id": "2d92afc4", - "metadata": {}, - "source": [ - "### Automatic symbolic regression" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ec64a6b4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.9737825480476489\n", - "fixing (0,1,0) with tan, r2=0.9779941633696527\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\displaystyle 0.39 \\sin{\\left(3.1 x_{1} + 7.85 \\right)} - 0.77 \\tan{\\left(0.95 x_{2} - 3.4 \\right)} + 0.49$" - ], - "text/plain": [ - "0.39*sin(3.1*x_1 + 7.85) - 0.77*tan(0.95*x_2 - 3.4) + 0.49" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','tan','abs']\n", - "model.auto_symbolic(lib=lib)\n", - "formula = model.symbolic_formula()[0][0]\n", - "formula" - ] - }, - { - "cell_type": "markdown", - "id": "cee6c7c8", - "metadata": {}, - "source": [ - "### How accurate is this formula?" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "dd5226ea", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train acc of the formula: tensor(0.9990)\n", - "test acc of the formula: tensor(0.9990)\n" - ] - } - ], - "source": [ - "# how accurate is this formula?\n", - "def acc(formula, X, y):\n", - " batch = X.shape[0]\n", - " correct = 0\n", - " for i in range(batch):\n", - " correct += np.round(np.array(formula.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)) == y[i,0]\n", - " return correct/batch\n", - "\n", - "print('train acc of the formula:', acc(formula, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula, dataset['test_input'], dataset['test_label']))" - ] - }, - { - "cell_type": "markdown", - "id": "8a77c90a", - "metadata": {}, - "source": [ - "## Let's then treat the problem as a classification problem (output dimension = 2, crossentropy loss)." - ] - }, - { - "cell_type": "markdown", - "id": "b03f2dd0", - "metadata": {}, - "source": [ - "### Create the two moon datatset" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "71c1d738", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.datasets import make_moons\n", - "import torch\n", - "import numpy as np\n", - "\n", - "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "\n", - "dataset['train_input'] = torch.from_numpy(train_input)\n", - "dataset['test_input'] = torch.from_numpy(test_input)\n", - "dataset['train_label'] = torch.from_numpy(train_label)\n", - "dataset['test_label'] = torch.from_numpy(test_label)\n", - "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0], X[:,1], c=y[:])" - ] - }, - { - "cell_type": "markdown", - "id": "494fe1d3", - "metadata": {}, - "source": [ - "### Train KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "13ec74e5", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 0.00e+00 | test loss: 7.12e-01 | reg: 1.14e+03 : 100%|██| 20/20 [00:03<00:00, 6.13it/s]\n" - ] - } - ], - "source": [ - "model = KAN(width=[2,2], grid=3, k=3)\n", - "\n", - "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n", - "\n", - "results = model.train(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc), loss_fn=torch.nn.CrossEntropyLoss());" - ] - }, - { - "cell_type": "markdown", - "id": "5e36b0f3", - "metadata": {}, - "source": [ - "### Automatic symbolic regression" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "91b4c228", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.8302683276572508\n", - "fixing (0,0,1) with sin, r2=0.7800130680092008\n", - "fixing (0,1,0) with x^3, r2=0.9535750788608285\n", - "fixing (0,1,1) with x^3, r2=0.9533527864007133\n" - ] - } - ], - "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", - "model.auto_symbolic(lib=lib)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "83606957", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle - 3227.26 \\left(0.21 - x_{2}\\right)^{3} - 837.31 \\sin{\\left(3.13 x_{1} + 1.42 \\right)} - 124.65$" - ], - "text/plain": [ - "-3227.26*(0.21 - x_2)**3 - 837.31*sin(3.13*x_1 + 1.42) - 124.65" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula1, formula2 = model.symbolic_formula()[0]\n", - "formula1" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "9fa988e3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 3138.94 \\left(0.21 - x_{2}\\right)^{3} + 942.35 \\sin{\\left(3.19 x_{1} + 1.4 \\right)} + 178.4$" - ], - "text/plain": [ - "3138.94*(0.21 - x_2)**3 + 942.35*sin(3.19*x_1 + 1.4) + 178.4" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula2" - ] - }, - { - "cell_type": "markdown", - "id": "0cfce819", - "metadata": {}, - "source": [ - "### How accurate is this formula?" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "ecd368f8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train acc of the formula: tensor(0.9700)\n", - "test acc of the formula: tensor(0.9660)\n" - ] - } - ], - "source": [ - "# how accurate is this formula?\n", - "def acc(formula1, formula2, X, y):\n", - " batch = X.shape[0]\n", - " correct = 0\n", - " for i in range(batch):\n", - " logit1 = np.array(formula1.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " logit2 = np.array(formula2.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " correct += (logit2 > logit1) == y[i]\n", - " return correct/batch\n", - "\n", - "print('train acc of the formula:', acc(formula1, formula2, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula1, formula2, dataset['test_input'], dataset['test_label']))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_4_symbolic_regression_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_4_symbolic_regression_-checkpoint.ipynb deleted file mode 100644 index ce15ca9b7..000000000 --- a/docs/.ipynb_checkpoints/Example_4_symbolic_regression_-checkpoint.ipynb +++ /dev/null @@ -1,5420 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 4: Symbolic Regression" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### The symbolic space is very dense, which means getting the correct symbolic formula (if existing at all) is a hard task. We will show how sentitive symbolic regression is, especially in the presence of noise. This is good or bad:\n", - "\n", - "**Good**: One can easily find symbolic formulas that match with data quite well (within some tolerable epsilon). When one does not care about the exact symbolic formula, they might be happy with these approximate symbolic formulas that fit their data well. These approximate symbolic formulas provide some level of insight, have predictive power and are easy to compute.\n", - "\n", - "**Bad**: It's hard to find the exact formula. When one does care about the exact formula, we either care about (i) its generalizability in future cases (like Newton's gravity), or (ii) fitting the clean data or solving a PDE as precise as machine precision. For case (i), it is open-ended and requires case-by-case analysis. For case (ii), we can get a (hopefully) clear signal of the correctness of a symbolic formula by noticing the loss to go down to near machine precision. We will use an example to demonstrate this below." - ] - }, - { - "cell_type": "markdown", - "id": "7c308c65", - "metadata": {}, - "source": [ - "## Part I: Automated vs manual symbolic regression (How can we know that we get the exact formula?)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8aa1966d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.54e-01 | test loss: 1.30e-01 | reg: 2.02e+01 : 100%|██| 20/20 [00:15<00:00, 1.26it/s]\n" - ] - } - ], - "source": [ - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "943d9182", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4942984c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9981093780355159\n", - "gaussian , 0.9360582190339871\n", - "tanh , 0.8616859029524302\n", - "sigmoid , 0.8585390273680941\n", - "arctan , 0.8428622193038047\n" - ] - }, - { - "data": { - "text/plain": [ - "('sin',\n", - " ((x)>, (x)>),\n", - " 0.9981093780355159)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# sin appears at the top of the suggestion list, which is good!\n", - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3f1c41a6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9910665391502297\n", - "x^2 , 0.9885210310683376\n", - "gaussian , 0.9883627975330689\n", - "sin , 0.9843196558672351\n", - "x^4 , 0.9403353142717915\n" - ] - }, - { - "data": { - "text/plain": [ - "('cosh',\n", - " ((x)>, (x)>),\n", - " 0.9910665391502297)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# x^2 appears in the suggestion list (usually not top 1), but it is fine!\n", - "model.suggest_symbolic(0,1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "01ff562d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9995702405196035\n", - "x^2 , 0.9992413667649066\n", - "cosh , 0.9990483455142343\n", - "gaussian , 0.9989441353410312\n", - "tanh , 0.9986571504172722\n" - ] - }, - { - "data": { - "text/plain": [ - "('sin',\n", - " ((x)>, (x)>),\n", - " 0.9995702405196035)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# exp not even appears in the list (but note how high correlation of all these functions), which is sad!\n", - "model.suggest_symbolic(1,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "232b710b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9995702405196035\n", - "x^2 , 0.9992413667649066\n", - "cosh , 0.9990483455142343\n", - "gaussian , 0.9989441353410312\n", - "tanh , 0.9986571504172722\n", - "sigmoid , 0.998657149375774\n", - "arctan , 0.9970617106973462\n", - "x^3 , 0.9962099497478061\n", - "x^4 , 0.9947572943342223\n", - "exp , 0.9913715887470934\n", - "1/x^4 , 0.9890801101893518\n", - "1/x^3 , 0.9884748093165208\n", - "1/x^2 , 0.9874565358732027\n", - "1/x , 0.9853279073610555\n", - "1/sqrt(x) , 0.9830898307444438\n" - ] - }, - { - "data": { - "text/plain": [ - "('sin',\n", - " ((x)>, (x)>),\n", - " 0.9995702405196035)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# let's try suggesting more by changing topk. Exp should appear in the list\n", - "# But it's very unclear why should we prefer exp over others. All of them have quite high correlation with the learned spline.\n", - "model.suggest_symbolic(1,0,0,topk=15)" - ] - }, - { - "cell_type": "markdown", - "id": "51844d0f", - "metadata": {}, - "source": [ - "### Let's train more! The loss goes down and the splines should be more exact" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "324937fe", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.74e-03 | test loss: 4.80e-03 | reg: 2.93e+00 : 100%|██| 20/20 [00:03<00:00, 6.47it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "fb0f6758", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.999987075018884\n", - "gaussian , 0.921655835107275\n", - "tanh , 0.8631397517896181\n", - "sigmoid , 0.8594117556407576\n", - "arctan , 0.8440367634049246\n" - ] - }, - { - "data": { - "text/plain": [ - "('sin',\n", - " ((x)>, (x)>),\n", - " 0.999987075018884)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# sin appears at the top of the suggestion list, which is good!\n", - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9a2406e8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999996930603142\n", - "cosh , 0.9999917592117541\n", - "gaussian , 0.9999827145861027\n", - "sin , 0.9980876045759569\n", - "abs , 0.9377603078924529\n" - ] - }, - { - "data": { - "text/plain": [ - "('x^2',\n", - " ((x)>, (x)>),\n", - " 0.9999996930603142)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# x^2 appears at the top of the suggestion list, which is good!\n", - "# But note how competitive cosh and gaussian are. They are also locally quadratic.\n", - "model.suggest_symbolic(0,1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "26dfe636", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999987580912774\n", - "tanh , 0.9999187437583558\n", - "cosh , 0.9999121147442106\n", - "sigmoid , 0.9998776769631791\n", - "gaussian , 0.9998535744392626\n" - ] - }, - { - "data": { - "text/plain": [ - "('exp',\n", - " ((x)>, (x)>),\n", - " 0.9999987580912774)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# exp appears at the top of the suggestion list, which is good!\n", - "model.suggest_symbolic(1,0,0)" - ] - }, - { - "cell_type": "markdown", - "id": "a880bac4", - "metadata": {}, - "source": [ - "### The takeaway is that symbolic regression is very sensitive to noise, so if we want to extract exact symbolic formulas from trained networks, the networks need to be trained to quite high accuracy!" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0fd2e8b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.999987075018884\n", - "fixing (0,1,0) with x^2, r2=0.9999996930603142\n", - "fixing (1,0,0) with exp, r2=0.9999987580912774\n" - ] - } - ], - "source": [ - "# now let's replace every activation function with its top 1 symbolic suggestion. This is implmented in auto_symbolic()\n", - "model.auto_symbolic()\n", - "\n", - "# if the user wants to constrain the symbolic space, they can pass in their symbolic libarary\n", - "# lib = ['sin', 'x^2', 'exp']\n", - "# model.auto_symbolic(lib=lib)" - ] - }, - { - "cell_type": "markdown", - "id": "a3d634fe", - "metadata": {}, - "source": [ - "### After retraining, we get (almost) machine precision! This is the winning signal that this formula is (very likely to be) exact!" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9fcecc80", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.13e-10 | test loss: 2.78e-11 | reg: 2.93e+00 : 100%|██| 20/20 [00:01<00:00, 11.85it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "4eb022df", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 e^{1.0 x_{2}^{2} + 1.0 \\sin{\\left(3.14 x_{1} \\right)}}$" - ], - "text/plain": [ - "1.0*exp(1.0*x_2**2 + 1.0*sin(3.14*x_1))" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# obtaining symbolic formula\n", - "formula, variables = model.symbolic_formula()\n", - "formula[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "a8e794ba", - "metadata": { - "code_folding": [] - }, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 e^{1.0 y^{2} + 1.0 \\sin{\\left(3.14 \\alpha \\right)}}$" - ], - "text/plain": [ - "1.0*exp(1.0*y**2 + 1.0*sin(3.14*\\alpha))" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# if you want to rename your variables, you could use the \"var\" argument\n", - "formula, variables = model.symbolic_formula(var=['\\\\alpha','y'])\n", - "formula[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "a1349079", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 3.14013671875 e^{1.0 y^{2} + 1.0 \\sin{\\left(3.14 \\alpha \\right)}} \\cos{\\left(3.14 \\alpha \\right)}$" - ], - "text/plain": [ - "3.14013671875*exp(1.0*y**2 + 1.0*sin(3.14*\\alpha))*cos(3.14*\\alpha)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# one can even postprocess the formula (e.g., taking derivatives)\n", - "from sympy import *\n", - "diff(formula[0], variables[0])" - ] - }, - { - "cell_type": "markdown", - "id": "4474d38d", - "metadata": {}, - "source": [ - "### When do we know the formula we guessed is wrong (not exact)? If the data is clean (no noise), we should see the training loss does not reach machine precision" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "22529272", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.999993562134913\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# let's replace (0,1,0) with cosh\n", - "model.fix_symbolic(0,1,0,'cosh')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "404dbd96", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.26e-03 | test loss: 1.28e-03 | reg: 2.93e+00 : 100%|██| 20/20 [00:03<00:00, 6.54it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# this loss is stuck at around 1e-3 RMSE, which is good, but not machine precision.\n", - "model.train(dataset, opt=\"LBFGS\", steps=20);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "2318c655", - "metadata": {}, - "source": [ - "## Part II: How hard (ill-defined) is symbolic regression, really?\n", - "\n", - "In part I, we show how people can use KANs for symbolic regression, but caveat that we need to train KANs to quite high precision. This is not a problem specific to KANs though; this issue originates from symbolic regression. The space of symbolic formulas is actually quite dense, so tiny noise can make one symbolic formula transit to another. " - ] - }, - { - "cell_type": "markdown", - "id": "a4d76348", - "metadata": {}, - "source": [ - "### 1D example: Adding noise to a bounded region sine" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "73dd7978", - "metadata": {}, - "outputs": [], - "source": [ - "def toy(bound=1., noise=0., fun=lambda x: torch.sin(torch.pi*x)):\n", - "\n", - " num_pts = 101\n", - " x = torch.linspace(-bound,bound,steps=num_pts)\n", - " x = x[:,None]\n", - " y = fun(x) + torch.normal(0,1,size=(num_pts,)) * noise\n", - " dataset = {}\n", - " dataset['train_input'] = dataset['test_input'] = x\n", - " dataset['train_label'] = dataset['test_label'] = y\n", - " model = KAN(width=[1,1], grid=5, k=3, seed=0, grid_range=(-bound,bound))\n", - " model.train(dataset, opt=\"LBFGS\", steps=20)\n", - " model.suggest_symbolic(0,0,0)\n", - " model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "2e129909", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.79e-03 | test loss: 2.79e-03 | reg: 3.12e-01 : 100%|██| 20/20 [00:01<00:00, 13.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999842278946689\n", - "gaussian , 0.9184406012010798\n", - "tanh , 0.8635381099424172\n", - "sigmoid , 0.8601324746874981\n", - "arctan , 0.845004037750832\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# when the function is whole range \"bound=1.\"\" (captures a whole period of sine) and has zero noise \"noise=0.\"\n", - "# it is quite clear the function is clear\n", - "toy()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "b260de36", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.30e-01 | test loss: 9.30e-01 | reg: 3.12e-01 : 100%|██| 20/20 [00:00<00:00, 40.68it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999842278898873\n", - "gaussian , 0.9184406080128915\n", - "tanh , 0.8635381682633535\n", - "sigmoid , 0.8601325311561702\n", - "arctan , 0.8450040982073312\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# even with large noise, sine can be revealed, yeah!\n", - "toy(noise=1.)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "b429397b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.30e-02 | test loss: 9.30e-02 | reg: 7.15e-01 : 100%|██| 20/20 [00:00<00:00, 43.08it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999916591202906\n", - "arctan , 0.9999847147948822\n", - "tanh , 0.999984517365484\n", - "x , 0.9999796669306419\n", - "abs , 0.9999796669306419\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# but when bound is small and there is noise, it starts to screw up (at least becomes less clear why we should prefer sine)\n", - "toy(bound = 0.1, noise=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "c2ec089e", - "metadata": {}, - "source": [ - "### Phase diagram of symbolic regression (how fratcal/chaotic is my phase diagram?)" - ] - }, - { - "cell_type": "markdown", - "id": "29f51b09", - "metadata": {}, - "source": [ - "#### mix three functions $f_1(x)={\\rm sin}(x)$, $f_2(x)=x^2$, and $f_3(x)={\\rm exp}(x)$ such that $f(x)=af_1(x)+bf_2(x)+(1-a-b)f_3(x)$. Symbolically regress $f(x)$." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "b76dfc4a", - "metadata": { - "code_folding": [] - }, - "outputs": [], - "source": [ - "def mix(a, b, bound=1):\n", - " num_pts = 101\n", - " x = torch.linspace(-bound,bound,steps=num_pts)\n", - " x = x[:,None]\n", - " y = a * torch.sin(x) + b * x**2 + (1-a-b) * torch.exp(x)\n", - " dataset = {}\n", - " dataset['train_input'] = dataset['test_input'] = x\n", - " dataset['train_label'] = dataset['test_label'] = y\n", - " model = KAN(width=[1,1], grid=10, k=3, seed=0, grid_range=(-bound,bound))\n", - " model.train(dataset, opt=\"LBFGS\", steps=20)\n", - " return model.suggest_symbolic(0,0,0)[0]\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "372aabd8", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.40e-06 | test loss: 2.40e-06 | reg: 2.64e-01 : 100%|██| 20/20 [00:00<00:00, 29.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.999997477547859\n", - "exp , 0.9999670134850122\n", - "sigmoid , 0.9999606621996252\n", - "tanh , 0.9999524925435431\n", - "1/x^4 , 0.9999517925552405\n" - ] - }, - { - "data": { - "text/plain": [ - "'cosh'" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mix(a=0.2, b=0.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "9166ca69", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.77e-06 | test loss: 2.77e-06 | reg: 2.72e-01 : 100%|██| 20/20 [00:00<00:00, 43.39it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999999999827021\n", - "cosh , 0.9999999999827017\n", - "tanh , 0.999973163748351\n", - "sigmoid , 0.9999497922899572\n", - "1/x^4 , 0.9999369992759012\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.52e-06 | test loss: 2.52e-06 | reg: 2.45e-01 : 100%|██| 20/20 [00:01<00:00, 17.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999988787247418\n", - "x^4 , 0.9999910879853997\n", - "gaussian , 0.999967486241568\n", - "tanh , 0.9999518786252838\n", - "sigmoid , 0.999948450438625\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.28e-06 | test loss: 2.28e-06 | reg: 2.18e-01 : 100%|██| 20/20 [00:00<00:00, 43.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999946575638085\n", - "x^3 , 0.9999164116905525\n", - "gaussian , 0.9997468080512466\n", - "x^4 , 0.9996076211798797\n", - "tanh , 0.9995835694860234\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.04e-06 | test loss: 2.04e-06 | reg: 1.94e-01 : 100%|██| 20/20 [00:00<00:00, 39.90it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999854846669585\n", - "x^3 , 0.9988138920172807\n", - "gaussian , 0.9985227715662934\n", - "x^2 , 0.998477650070286\n", - "sin , 0.9981948138629363\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.80e-06 | test loss: 1.80e-06 | reg: 1.71e-01 : 100%|██| 20/20 [00:00<00:00, 39.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999662581221136\n", - "x^2 , 0.9986097449347123\n", - "sin , 0.998284128651733\n", - "x^3 , 0.9936582971043266\n", - "gaussian , 0.9936463187510403\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.55e-06 | test loss: 1.55e-06 | reg: 1.51e-01 : 100%|██| 20/20 [00:00<00:00, 44.84it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999418178114038\n", - "x^2 , 0.9987944480619438\n", - "sin , 0.9984323316332249\n", - "gaussian , 0.9949686832586251\n", - "tanh , 0.9764364382302457\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.31e-06 | test loss: 1.31e-06 | reg: 1.36e-01 : 100%|██| 20/20 [00:00<00:00, 39.78it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999041816268858\n", - "x^2 , 0.9990436001283093\n", - "sin , 0.9986633245000535\n", - "gaussian , 0.9958810456319825\n", - "tanh , 0.9380270364085883\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.07e-06 | test loss: 1.07e-06 | reg: 1.29e-01 : 100%|██| 20/20 [00:00<00:00, 40.74it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9998655818685623\n", - "x^2 , 0.9993505000566273\n", - "sin , 0.9989811585960545\n", - "gaussian , 0.9916259900602326\n", - "x^4 , 0.9172564495092251\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.32e-07 | test loss: 8.32e-07 | reg: 1.27e-01 : 100%|██| 20/20 [00:00<00:00, 44.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9996700824962792\n", - "sin , 0.9993888581205067\n", - "cosh , 0.998561267814873\n", - "gaussian , 0.9707186857583728\n", - "abs , 0.9254006963892939\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.00e-07 | test loss: 6.00e-07 | reg: 1.30e-01 : 100%|██| 20/20 [00:00<00:00, 44.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999132817985119\n", - "sin , 0.9994936051757877\n", - "gaussian , 0.9994851357951505\n", - "cosh , 0.987913942212583\n", - "abs , 0.933975094122013\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.79e-07 | test loss: 3.79e-07 | reg: 1.38e-01 : 100%|██| 20/20 [00:00<00:00, 43.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999999998837575\n", - "cosh , 0.9999099009608192\n", - "gaussian , 0.9997105669072212\n", - "sin , 0.9989290599804755\n", - "abs , 0.93740817498461\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.58e-06 | test loss: 2.58e-06 | reg: 2.68e-01 : 100%|██| 20/20 [00:00<00:00, 27.79it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "arctan , 0.9999798378098914\n", - "cosh , 0.9999771001456361\n", - "tanh , 0.9999633902076488\n", - "sigmoid , 0.9999541433147963\n", - "1/x^4 , 0.9999236487568766\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.34e-06 | test loss: 2.34e-06 | reg: 2.40e-01 : 100%|██| 20/20 [00:00<00:00, 20.99it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999937207935639\n", - "x^4 , 0.9999862674170232\n", - "gaussian , 0.9999638602636551\n", - "sigmoid , 0.9999448387268524\n", - "x^3 , 0.9999438604212395\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.10e-06 | test loss: 2.10e-06 | reg: 2.14e-01 : 100%|██| 20/20 [00:00<00:00, 40.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999949634057903\n", - "x^3 , 0.9998843971854673\n", - "gaussian , 0.9997599295163522\n", - "tanh , 0.9996162757398458\n", - "sigmoid , 0.9996147714224425\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.86e-06 | test loss: 1.86e-06 | reg: 1.89e-01 : 100%|██| 20/20 [00:00<00:00, 50.75it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.999982696239627\n", - "x^2 , 0.9991234483879446\n", - "sin , 0.9988859253126088\n", - "x^3 , 0.9987772391387374\n", - "gaussian , 0.998656639925584\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.61e-06 | test loss: 1.61e-06 | reg: 1.66e-01 : 100%|██| 20/20 [00:00<00:00, 43.78it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999905018303474\n", - "x^2 , 0.9992854342507987\n", - "sin , 0.998871759377929\n", - "gaussian , 0.9985721495291437\n", - "x^3 , 0.9939912670589373\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.37e-06 | test loss: 1.37e-06 | reg: 1.45e-01 : 100%|██| 20/20 [00:00<00:00, 36.50it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999796806444573\n", - "x^2 , 0.999480532354729\n", - "sin , 0.9991909206588246\n", - "gaussian , 0.9964682981271429\n", - "tanh , 0.9772535252536733\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.13e-06 | test loss: 1.13e-06 | reg: 1.29e-01 : 100%|██| 20/20 [00:00<00:00, 46.90it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999738670223917\n", - "x^2 , 0.9996973599778907\n", - "sin , 0.9994116683309964\n", - "gaussian , 0.9973545677199919\n", - "tanh , 0.9376915470857489\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.85e-07 | test loss: 8.85e-07 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 43.78it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9998957469235318\n", - "cosh , 0.9998722722380837\n", - "sin , 0.9996590283030754\n", - "gaussian , 0.9939866829832639\n", - "abs , 0.9232648879118915\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.46e-07 | test loss: 6.46e-07 | reg: 1.20e-01 : 100%|██| 20/20 [00:00<00:00, 36.61it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999974059407801\n", - "sin , 0.999834148899939\n", - "cosh , 0.9962063866033833\n", - "gaussian , 0.9754127817001195\n", - "abs , 0.9311623016073874\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.18e-07 | test loss: 4.18e-07 | reg: 1.24e-01 : 100%|██| 20/20 [00:00<00:00, 41.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999226429006036\n", - "sin , 0.9998636426802294\n", - "cosh , 0.9997752175292851\n", - "gaussian , 0.999679958882009\n", - "abs , 0.9372397600766894\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.23e-07 | test loss: 2.23e-07 | reg: 1.33e-01 : 100%|██| 20/20 [00:00<00:00, 40.07it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9995568150249838\n", - "gaussian , 0.9993467471612426\n", - "sin , 0.9985870166410652\n", - "x^2 , 0.9984339446779963\n", - "abs , 0.9362895855226272\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.41e-06 | test loss: 2.41e-06 | reg: 2.64e-01 : 100%|██| 20/20 [00:00<00:00, 50.70it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999974775415001\n", - "exp , 0.9999951134484997\n", - "sigmoid , 0.9999606621811076\n", - "tanh , 0.9999524925186463\n", - "1/x^4 , 0.9999517925693375\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.16e-06 | test loss: 2.16e-06 | reg: 2.36e-01 : 100%|██| 20/20 [00:00<00:00, 38.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999987855303939\n", - "x^3 , 0.9999772484086487\n", - "x^4 , 0.9999697464110736\n", - "gaussian , 0.9999593591292381\n", - "sigmoid , 0.9999388880060787\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.92e-06 | test loss: 1.92e-06 | reg: 2.09e-01 : 100%|██| 20/20 [00:00<00:00, 43.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.99999935535384\n", - "x^3 , 0.9998219698585193\n", - "gaussian , 0.9997659958370352\n", - "tanh , 0.9996382852712733\n", - "sigmoid , 0.999636745445751\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.66e-06 | test loss: 1.66e-06 | reg: 1.84e-01 : 100%|██| 20/20 [00:01<00:00, 17.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999988957805453\n", - "x^2 , 0.9996199310076759\n", - "sin , 0.9994371092496096\n", - "gaussian , 0.9987635279928482\n", - "x^3 , 0.9986602848898886\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.43e-06 | test loss: 1.43e-06 | reg: 1.60e-01 : 100%|██| 20/20 [00:00<00:00, 40.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999954784528895\n", - "x^2 , 0.9997669036986749\n", - "sin , 0.9994959364448105\n", - "gaussian , 0.9992839638818944\n", - "x^3 , 0.9941048878141949\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.19e-06 | test loss: 1.19e-06 | reg: 1.39e-01 : 100%|██| 20/20 [00:00<00:00, 40.14it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999057877413986\n", - "cosh , 0.9997878856454342\n", - "sin , 0.9997010374773055\n", - "gaussian , 0.9978271729275431\n", - "sigmoid , 0.9780411748220801\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.43e-07 | test loss: 9.43e-07 | reg: 1.23e-01 : 100%|██| 20/20 [00:00<00:00, 42.49it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999916810769826\n", - "sin , 0.9998540286212848\n", - "gaussian , 0.9985646631915182\n", - "cosh , 0.9978692658702253\n", - "tanh , 0.9372183456949574\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.05e-07 | test loss: 7.05e-07 | reg: 1.15e-01 : 100%|██| 20/20 [00:00<00:00, 46.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999411945915794\n", - "sin , 0.999917846530661\n", - "cosh , 0.9993168732975628\n", - "gaussian , 0.9961111289682559\n", - "abs , 0.9302392302167873\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.75e-07 | test loss: 4.75e-07 | reg: 1.13e-01 : 100%|██| 20/20 [00:00<00:00, 48.74it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9997864168657743\n", - "x^2 , 0.9996579498087828\n", - "cosh , 0.9942754283755333\n", - "gaussian , 0.9798855202432393\n", - "abs , 0.9369096690204137\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.64e-07 | test loss: 2.64e-07 | reg: 1.18e-01 : 100%|██| 20/20 [00:00<00:00, 43.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9992177278915768\n", - "x^2 , 0.999137470112453\n", - "gaussian , 0.999088490162276\n", - "cosh , 0.9988973034727238\n", - "abs , 0.9396624038444488\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.78e-07 | test loss: 1.78e-07 | reg: 1.27e-01 : 100%|██| 20/20 [00:00<00:00, 45.43it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.998540782190707\n", - "cosh , 0.998497783054037\n", - "sin , 0.9981679237204564\n", - "gaussian , 0.9980799911419045\n", - "abs , 0.9348151361956722\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.22e-06 | test loss: 2.22e-06 | reg: 2.60e-01 : 100%|██| 20/20 [00:00<00:00, 47.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999930298639131\n", - "exp , 0.9999836112405796\n", - "tanh , 0.9999821515315185\n", - "x^4 , 0.9999746028947676\n", - "arctan , 0.9999713956244152\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.98e-06 | test loss: 1.98e-06 | reg: 2.32e-01 : 100%|██| 20/20 [00:00<00:00, 47.28it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999962889824672\n", - "x^3 , 0.9999811150224204\n", - "gaussian , 0.9999534848375812\n", - "tanh , 0.9999336923279952\n", - "sigmoid , 0.9999305175966535\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.74e-06 | test loss: 1.74e-06 | reg: 2.05e-01 : 100%|██| 20/20 [00:00<00:00, 40.82it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999962156472607\n", - "x^2 , 0.9998260034206992\n", - "gaussian , 0.9997664875004227\n", - "x^3 , 0.9997117036934391\n", - "sin , 0.9997113407524149\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.49e-06 | test loss: 1.49e-06 | reg: 1.79e-01 : 100%|██| 20/20 [00:00<00:00, 47.64it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999544661515833\n", - "x^2 , 0.9999233768388777\n", - "sin , 0.9998096068574465\n", - "gaussian , 0.998846633386868\n", - "x^3 , 0.9984457355669536\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.25e-06 | test loss: 1.25e-06 | reg: 1.55e-01 : 100%|██| 20/20 [00:00<00:00, 39.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999875880501998\n", - "cosh , 0.9999623957580879\n", - "sin , 0.9998842247678139\n", - "gaussian , 0.9997446918456595\n", - "x^3 , 0.9939812278070211\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.01e-06 | test loss: 1.01e-06 | reg: 1.33e-01 : 100%|██| 20/20 [00:00<00:00, 47.68it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999658213074126\n", - "sin , 0.9998830954293118\n", - "cosh , 0.9991428566544741\n", - "gaussian , 0.9988921913945791\n", - "tanh , 0.9787975107817283\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.68e-07 | test loss: 7.68e-07 | reg: 1.16e-01 : 100%|██| 20/20 [00:00<00:00, 44.81it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999324078991241\n", - "x^2 , 0.9997596795941941\n", - "cosh , 0.9994865919109623\n", - "gaussian , 0.9994862477413593\n", - "tanh , 0.9365762760176262\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.36e-07 | test loss: 5.36e-07 | reg: 1.08e-01 : 100%|██| 20/20 [00:00<00:00, 43.66it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9997548044475728\n", - "x^2 , 0.9992301995166885\n", - "cosh , 0.9979137733537407\n", - "gaussian , 0.9977997203751177\n", - "abs , 0.9377138311216435\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.19e-07 | test loss: 3.19e-07 | reg: 1.07e-01 : 100%|██| 20/20 [00:00<00:00, 41.27it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9990790086224685\n", - "x^2 , 0.998306797086686\n", - "cosh , 0.9912197954445299\n", - "gaussian , 0.983836484418377\n", - "abs , 0.9422994090520702\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.88e-07 | test loss: 1.88e-07 | reg: 1.12e-01 : 100%|██| 20/20 [00:00<00:00, 38.48it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9974240586295893\n", - "gaussian , 0.9973311148206122\n", - "x^2 , 0.9971996559803431\n", - "cosh , 0.9968911992725868\n", - "abs , 0.9402041148610969\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.92e-07 | test loss: 2.92e-07 | reg: 1.21e-01 : 100%|██| 20/20 [00:00<00:00, 40.66it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9964799073278351\n", - "x^2 , 0.9963340407057836\n", - "sin , 0.9959863127871974\n", - "gaussian , 0.9956440035977147\n", - "abs , 0.9297638765888608\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.04e-06 | test loss: 2.04e-06 | reg: 2.57e-01 : 100%|██| 20/20 [00:01<00:00, 19.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^4 , 0.9999894819511871\n", - "x^3 , 0.9999835048772354\n", - "tanh , 0.9999809889835496\n", - "cosh , 0.9999804113519436\n", - "sigmoid , 0.9999728460390712\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.80e-06 | test loss: 1.80e-06 | reg: 2.28e-01 : 100%|██| 20/20 [00:00<00:00, 36.75it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999673825431549\n", - "gaussian , 0.9999462038064604\n", - "x^2 , 0.9999377574579958\n", - "x^3 , 0.999934739879401\n", - "tanh , 0.9999253640056137\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.56e-06 | test loss: 1.56e-06 | reg: 2.00e-01 : 100%|██| 20/20 [00:00<00:00, 40.62it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999856957320528\n", - "cosh , 0.9999806264360336\n", - "sin , 0.9999333905161271\n", - "gaussian , 0.9997629877627796\n", - "tanh , 0.9996615330714775\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.31e-06 | test loss: 1.31e-06 | reg: 1.74e-01 : 100%|██| 20/20 [00:00<00:00, 42.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999803474424048\n", - "sin , 0.9999690179361935\n", - "cosh , 0.9996537442008128\n", - "gaussian , 0.9989097397461996\n", - "tanh , 0.9985534483580678\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.07e-06 | test loss: 1.07e-06 | reg: 1.50e-01 : 100%|██| 20/20 [00:00<00:00, 52.19it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999726154715255\n", - "gaussian , 0.9999250404431426\n", - "x^2 , 0.9998623405070776\n", - "cosh , 0.9996561770567938\n", - "tanh , 0.9942785952521871\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.35e-07 | test loss: 8.35e-07 | reg: 1.28e-01 : 100%|██| 20/20 [00:00<00:00, 48.08it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999424641676066\n", - "gaussian , 0.9999091837427161\n", - "x^2 , 0.9995191008698547\n", - "cosh , 0.9978922471122651\n", - "tanh , 0.9795181094994256\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.03e-07 | test loss: 6.03e-07 | reg: 1.10e-01 : 100%|██| 20/20 [00:00<00:00, 42.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9998135112170027\n", - "gaussian , 0.999787323738521\n", - "x^2 , 0.9987606438444635\n", - "cosh , 0.9982635098451202\n", - "abs , 0.9422869570493372\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.87e-07 | test loss: 3.87e-07 | reg: 1.01e-01 : 100%|██| 20/20 [00:00<00:00, 40.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9992995819998103\n", - "gaussian , 0.9987377926584199\n", - "x^2 , 0.9973752641583749\n", - "cosh , 0.995255140131929\n", - "abs , 0.9455257642420224\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.37e-07 | test loss: 2.37e-07 | reg: 1.00e-01 : 100%|██| 20/20 [00:00<00:00, 39.05it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9974728070753829\n", - "x^2 , 0.995416161237695\n", - "gaussian , 0.9867522256462564\n", - "cosh , 0.986582711416683\n", - "abs , 0.9468472932133176\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.80e-07 | test loss: 2.80e-07 | reg: 1.05e-01 : 100%|██| 20/20 [00:00<00:00, 43.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9938672203947038\n", - "gaussian , 0.9937913539713064\n", - "x^2 , 0.9936057905336317\n", - "cosh , 0.9932430068628105\n", - "abs , 0.9381962721720656\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.63e-07 | test loss: 4.63e-07 | reg: 1.16e-01 : 100%|██| 20/20 [00:00<00:00, 40.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.992730560931046\n", - "sin , 0.9922829131306503\n", - "gaussian , 0.9916990159565282\n", - "cosh , 0.98563942691924\n", - "abs , 0.9212244844946261\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.86e-06 | test loss: 1.86e-06 | reg: 2.53e-01 : 100%|██| 20/20 [00:00<00:00, 41.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9999888112900659\n", - "x^2 , 0.9999849501568968\n", - "tanh , 0.9999760956345113\n", - "x^3 , 0.9999758615432004\n", - "sigmoid , 0.9999716645393338\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.62e-06 | test loss: 1.62e-06 | reg: 2.24e-01 : 100%|██| 20/20 [00:00<00:00, 40.52it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999870715347138\n", - "sin , 0.9999811871919927\n", - "cosh , 0.9999553343368358\n", - "gaussian , 0.9999383081018585\n", - "tanh , 0.9999177958840636\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.38e-06 | test loss: 1.38e-06 | reg: 1.96e-01 : 100%|██| 20/20 [00:00<00:00, 44.48it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999859303543726\n", - "gaussian , 0.9999644813363999\n", - "x^2 , 0.9999214589741492\n", - "tanh , 0.9996703332150525\n", - "sigmoid , 0.9996690041252987\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.14e-06 | test loss: 1.14e-06 | reg: 1.69e-01 : 100%|██| 20/20 [00:00<00:00, 41.08it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999802936975296\n", - "x^2 , 0.9997259928372615\n", - "cosh , 0.9993475620341137\n", - "gaussian , 0.9989573036832605\n", - "tanh , 0.9986543793643053\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.05e-07 | test loss: 9.05e-07 | reg: 1.44e-01 : 100%|██| 20/20 [00:00<00:00, 44.49it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999585866499787\n", - "gaussian , 0.9999486876810368\n", - "x^2 , 0.9992827278167005\n", - "cosh , 0.9988740875766842\n", - "tanh , 0.9946613426702609\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.75e-07 | test loss: 6.75e-07 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 42.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9998822169169899\n", - "gaussian , 0.999878040103399\n", - "x^2 , 0.99837407546255\n", - "cosh , 0.9979460330489591\n", - "tanh , 0.9802089053769921\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.60e-07 | test loss: 4.60e-07 | reg: 1.04e-01 : 100%|██| 20/20 [00:00<00:00, 42.62it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.999597666676653\n", - "sin , 0.9995937068570286\n", - "x^2 , 0.99664915970953\n", - "cosh , 0.9958802001000374\n", - "abs , 0.9512847855771679\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.98e-07 | test loss: 2.98e-07 | reg: 9.48e-02 : 100%|██| 20/20 [00:00<00:00, 46.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9984509165908535\n", - "gaussian , 0.9959578952120252\n", - "x^2 , 0.9937818028920754\n", - "cosh , 0.9907205081520056\n", - "abs , 0.9534651069741744\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.89e-07 | test loss: 2.89e-07 | reg: 9.37e-02 : 100%|██| 20/20 [00:00<00:00, 40.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9943901136276602\n", - "x^2 , 0.990205343640921\n", - "gaussian , 0.987762675373181\n", - "cosh , 0.9761222166037805\n", - "abs , 0.9497419182649224\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.40e-07 | test loss: 4.40e-07 | reg: 9.91e-02 : 100%|██| 20/20 [00:00<00:00, 43.16it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9876449536124641\n", - "sin , 0.9874566180838149\n", - "cosh , 0.9873751146532993\n", - "x^2 , 0.9871135812467379\n", - "abs , 0.9320312251409515\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.40e-07 | test loss: 6.40e-07 | reg: 1.10e-01 : 100%|██| 20/20 [00:00<00:00, 47.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9873681256920457\n", - "sin , 0.9867104677131169\n", - "cosh , 0.9863604874844045\n", - "gaussian , 0.9859360750741196\n", - "x^4 , 0.9239128488596182\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.69e-06 | test loss: 1.69e-06 | reg: 2.50e-01 : 100%|██| 20/20 [00:00<00:00, 38.33it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.999990707616756\n", - "tanh , 0.9999723043366056\n", - "sigmoid , 0.9999701323519831\n", - "gaussian , 0.9999551813924956\n", - "x^2 , 0.9999522532756852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.44e-06 | test loss: 1.44e-06 | reg: 2.20e-01 : 100%|██| 20/20 [00:00<00:00, 20.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999900693982379\n", - "gaussian , 0.9999311426065755\n", - "tanh , 0.9999145249443635\n", - "sigmoid , 0.9999130489202535\n", - "x^2 , 0.9998377031202675\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.21e-06 | test loss: 1.21e-06 | reg: 1.92e-01 : 100%|██| 20/20 [00:00<00:00, 45.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999862820440971\n", - "gaussian , 0.9997517753887365\n", - "tanh , 0.9996841983206314\n", - "sigmoid , 0.9996830107874256\n", - "x^2 , 0.999585767134396\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.77e-07 | test loss: 9.77e-07 | reg: 1.65e-01 : 100%|██| 20/20 [00:00<00:00, 55.67it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999745726295028\n", - "x^2 , 0.9990823277390866\n", - "gaussian , 0.9989945842715465\n", - "cosh , 0.9988728127858241\n", - "tanh , 0.9987539221752944\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.49e-07 | test loss: 7.49e-07 | reg: 1.39e-01 : 100%|██| 20/20 [00:00<00:00, 40.60it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999370198218576\n", - "x^2 , 0.9981115478889542\n", - "cosh , 0.9974772652014616\n", - "gaussian , 0.995731717057559\n", - "tanh , 0.9950291700743682\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.36e-07 | test loss: 5.36e-07 | reg: 1.16e-01 : 100%|██| 20/20 [00:00<00:00, 44.68it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9998221482804251\n", - "sin , 0.9998030639266311\n", - "x^2 , 0.9962716348456105\n", - "cosh , 0.9957027344640318\n", - "tanh , 0.9808861574166389\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.67e-07 | test loss: 3.67e-07 | reg: 9.76e-02 : 100%|██| 20/20 [00:00<00:00, 40.80it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9993158902101864\n", - "sin , 0.9992737234348714\n", - "x^2 , 0.9929134959392898\n", - "cosh , 0.9918352264630244\n", - "abs , 0.9605168885411256\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.18e-07 | test loss: 3.18e-07 | reg: 8.81e-02 : 100%|██| 20/20 [00:00<00:00, 37.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9970616380122096\n", - "gaussian , 0.9966420291540972\n", - "x^2 , 0.9875208727310729\n", - "cosh , 0.983348154979657\n", - "abs , 0.9611248513995477\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.31e-07 | test loss: 4.31e-07 | reg: 8.70e-02 : 100%|██| 20/20 [00:00<00:00, 43.04it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9888254509108924\n", - "x^2 , 0.981424420858435\n", - "gaussian , 0.9756945249179574\n", - "cosh , 0.9653653219988936\n", - "abs , 0.949892059404306\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.17e-07 | test loss: 6.17e-07 | reg: 9.30e-02 : 100%|██| 20/20 [00:00<00:00, 42.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9783739534751957\n", - "gaussian , 0.9779770648401149\n", - "sin , 0.9773944419005031\n", - "x^2 , 0.9772100499611249\n", - "abs , 0.9197221129892613\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.36e-07 | test loss: 8.36e-07 | reg: 1.06e-01 : 100%|██| 20/20 [00:00<00:00, 45.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9847797381605126\n", - "x^2 , 0.979881475095261\n", - "sin , 0.9789559646121901\n", - "gaussian , 0.9779176281844336\n", - "x^4 , 0.9285991153021671\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.52e-06 | test loss: 1.52e-06 | reg: 2.46e-01 : 100%|██| 20/20 [00:00<00:00, 43.84it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999930938197495\n", - "gaussian , 0.9999927495837864\n", - "tanh , 0.9999730056399402\n", - "sigmoid , 0.9999716131493217\n", - "arctan , 0.9999521920308199\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.28e-06 | test loss: 1.28e-06 | reg: 2.17e-01 : 100%|██| 20/20 [00:00<00:00, 47.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999916138797103\n", - "gaussian , 0.999926218584326\n", - "tanh , 0.9999191528924947\n", - "sigmoid , 0.9999179925256542\n", - "arctan , 0.9998352652530494\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.05e-06 | test loss: 1.05e-06 | reg: 1.88e-01 : 100%|██| 20/20 [00:00<00:00, 49.52it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999899760530466\n", - "sin , 0.9999866880205311\n", - "tanh , 0.9997096545485408\n", - "sigmoid , 0.9997086093190996\n", - "arctan , 0.9993950375881484\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.25e-07 | test loss: 8.25e-07 | reg: 1.60e-01 : 100%|██| 20/20 [00:00<00:00, 50.16it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999712618941392\n", - "gaussian , 0.9990277391373628\n", - "tanh , 0.9988653756689869\n", - "sigmoid , 0.9988643627333774\n", - "x^2 , 0.9979566871598838\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.15e-07 | test loss: 6.15e-07 | reg: 1.34e-01 : 100%|██| 20/20 [00:00<00:00, 44.33it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999414756950388\n", - "sin , 0.9999185788926284\n", - "x^2 , 0.9961768265523611\n", - "tanh , 0.9954056127804757\n", - "sigmoid , 0.9954045447762155\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.42e-07 | test loss: 4.42e-07 | reg: 1.11e-01 : 100%|██| 20/20 [00:00<00:00, 36.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9997728550720852\n", - "sin , 0.9997168387512211\n", - "x^2 , 0.9928623326890238\n", - "cosh , 0.9921522541074415\n", - "tanh , 0.9815839509974684\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.64e-07 | test loss: 3.64e-07 | reg: 9.13e-02 : 100%|██| 20/20 [00:00<00:00, 51.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9989709402248369\n", - "sin , 0.9988544685797407\n", - "x^2 , 0.9868026386831295\n", - "cosh , 0.985345236582632\n", - "abs , 0.9698770230380636\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.35e-07 | test loss: 4.35e-07 | reg: 8.13e-02 : 100%|██| 20/20 [00:00<00:00, 40.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9949371389273981\n", - "sin , 0.9949107782356766\n", - "x^2 , 0.977112955292746\n", - "cosh , 0.9716178500832297\n", - "abs , 0.967722640360993\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.03e-07 | test loss: 6.03e-07 | reg: 8.00e-02 : 100%|██| 20/20 [00:00<00:00, 43.30it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9790424824765466\n", - "gaussian , 0.9715243025795919\n", - "x^2 , 0.9671692490974791\n", - "cosh , 0.9450165956953308\n", - "abs , 0.9448625902159359\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.07e-07 | test loss: 8.07e-07 | reg: 8.69e-02 : 100%|██| 20/20 [00:00<00:00, 43.17it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.965461717507565\n", - "x^2 , 0.9648932341203752\n", - "sin , 0.963856710506799\n", - "gaussian , 0.9636801162210671\n", - "x^4 , 0.9002751610118467\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.03e-06 | test loss: 1.03e-06 | reg: 1.03e-01 : 100%|██| 20/20 [00:00<00:00, 41.77it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9807409640082864\n", - "x^2 , 0.9699721931104404\n", - "sin , 0.9677166767908957\n", - "gaussian , 0.9394860427747876\n", - "x^4 , 0.9351858394996657\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.36e-06 | test loss: 1.36e-06 | reg: 2.43e-01 : 100%|██| 20/20 [00:00<00:00, 44.90it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999978669498215\n", - "sin , 0.9999956722754607\n", - "tanh , 0.9999799263714397\n", - "sigmoid , 0.9999789216022107\n", - "arctan , 0.9999642054598574\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.13e-06 | test loss: 1.13e-06 | reg: 2.13e-01 : 100%|██| 20/20 [00:00<00:00, 44.99it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999943906884494\n", - "tanh , 0.9999343640823076\n", - "sigmoid , 0.9999334248881454\n", - "gaussian , 0.9999249439932951\n", - "arctan , 0.9998684985487326\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.03e-07 | test loss: 9.03e-07 | reg: 1.84e-01 : 100%|██| 20/20 [00:00<00:00, 45.74it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999896507243767\n", - "tanh , 0.9997526274283742\n", - "sigmoid , 0.9997517092998544\n", - "gaussian , 0.9997514568009086\n", - "arctan , 0.9994994651669644\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.94e-07 | test loss: 6.94e-07 | reg: 1.56e-01 : 100%|██| 20/20 [00:00<00:00, 45.29it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999899485873852\n", - "sin , 0.9999314322918655\n", - "tanh , 0.9990030069449396\n", - "sigmoid , 0.9990020609332764\n", - "arctan , 0.9981096381936067\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.19e-07 | test loss: 5.19e-07 | reg: 1.30e-01 : 100%|██| 20/20 [00:00<00:00, 36.49it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999536171672674\n", - "sin , 0.9999094157336442\n", - "tanh , 0.9958217326666846\n", - "sigmoid , 0.9958206863529286\n", - "x^2 , 0.9932659752647721\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.21e-07 | test loss: 4.21e-07 | reg: 1.06e-01 : 100%|██| 20/20 [00:00<00:00, 49.72it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9997544064398111\n", - "sin , 0.9996390145601096\n", - "x^2 , 0.9876782817075724\n", - "cosh , 0.986829120472927\n", - "tanh , 0.9823615338330297\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.54e-07 | test loss: 4.54e-07 | reg: 8.52e-02 : 100%|██| 20/20 [00:00<00:00, 42.86it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9985268503112813\n", - "sin , 0.9983499410484818\n", - "abs , 0.9785902377362155\n", - "x^2 , 0.9771995020822951\n", - "cosh , 0.9752846715582264\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.93e-07 | test loss: 5.93e-07 | reg: 7.45e-02 : 100%|██| 20/20 [00:00<00:00, 40.78it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.991738617202277\n", - "sin , 0.9916999095855713\n", - "abs , 0.9717770596320756\n", - "x^2 , 0.9601566417330277\n", - "cosh , 0.9530802418693475\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.85e-07 | test loss: 7.85e-07 | reg: 7.31e-02 : 100%|██| 20/20 [00:00<00:00, 44.58it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9620464258065169\n", - "gaussian , 0.9582876791641027\n", - "x^2 , 0.9445008625317239\n", - "cosh , 0.9430687242552336\n", - "abs , 0.9308710215935037\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.96e-07 | test loss: 9.96e-07 | reg: 8.13e-02 : 100%|██| 20/20 [00:00<00:00, 43.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9480750122921905\n", - "x^2 , 0.9456250628531494\n", - "sin , 0.9445956284973298\n", - "gaussian , 0.9434289429080119\n", - "x^4 , 0.9009688699792165\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.22e-06 | test loss: 1.22e-06 | reg: 1.02e-01 : 100%|██| 20/20 [00:00<00:00, 37.36it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9766929896410047\n", - "x^2 , 0.957514493788183\n", - "sin , 0.9559851348570871\n", - "x^4 , 0.9438827362855521\n", - "gaussian , 0.9167827938895323\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.20e-06 | test loss: 1.20e-06 | reg: 2.39e-01 : 100%|██| 20/20 [00:00<00:00, 46.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999984333249491\n", - "sigmoid , 0.9999901865767792\n", - "arctan , 0.9999829580110535\n", - "gaussian , 0.9999746546393077\n", - "tanh , 0.9999393123160958\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.82e-07 | test loss: 9.82e-07 | reg: 2.10e-01 : 100%|██| 20/20 [00:00<00:00, 43.17it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999977984107461\n", - "gaussian , 0.999996383890805\n", - "tanh , 0.9999585593099201\n", - "sigmoid , 0.9999577735635269\n", - "arctan , 0.9999150645734015\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.75e-07 | test loss: 7.75e-07 | reg: 1.80e-01 : 100%|██| 20/20 [00:00<00:00, 43.96it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999953796079631\n", - "sin , 0.9999944856461577\n", - "tanh , 0.9998140271258696\n", - "sigmoid , 0.9998132139651115\n", - "arctan , 0.9996263187286749\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.99e-07 | test loss: 5.99e-07 | reg: 1.52e-01 : 100%|██| 20/20 [00:00<00:00, 39.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999799131978417\n", - "tanh , 0.9991760870939851\n", - "sigmoid , 0.999175206451367\n", - "gaussian , 0.9991099365080184\n", - "arctan , 0.9984657428834645\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.86e-07 | test loss: 4.86e-07 | reg: 1.25e-01 : 100%|██| 20/20 [00:00<00:00, 56.80it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999683931970753\n", - "sin , 0.9999135788767782\n", - "tanh , 0.996308913203486\n", - "sigmoid , 0.9963078955424317\n", - "arctan , 0.9939227717854873\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.85e-07 | test loss: 4.85e-07 | reg: 1.00e-01 : 100%|██| 20/20 [00:00<00:00, 44.41it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9997689201745247\n", - "sin , 0.9995873145216307\n", - "abs , 0.9849023647718247\n", - "tanh , 0.9833009867719864\n", - "sigmoid , 0.9832997013656896\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.93e-07 | test loss: 5.93e-07 | reg: 7.91e-02 : 100%|██| 20/20 [00:00<00:00, 47.72it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9982643783383393\n", - "sin , 0.9977962501289016\n", - "abs , 0.9854353082947718\n", - "x^2 , 0.9624423927207054\n", - "cosh , 0.9600011409875004\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.70e-07 | test loss: 7.70e-07 | reg: 6.75e-02 : 100%|██| 20/20 [00:00<00:00, 39.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9870493767685123\n", - "gaussian , 0.9870320319171259\n", - "abs , 0.9705633369555351\n", - "x^2 , 0.932694450295423\n", - "cosh , 0.9237291936352401\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.74e-07 | test loss: 9.74e-07 | reg: 6.60e-02 : 100%|██| 20/20 [00:00<00:00, 42.96it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9329023836770476\n", - "gaussian , 0.9251125534459796\n", - "x^2 , 0.9090404451604721\n", - "cosh , 0.9075530370365199\n", - "abs , 0.902215514501183\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.19e-06 | test loss: 1.19e-06 | reg: 7.68e-02 : 100%|██| 20/20 [00:00<00:00, 45.43it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.936942764457975\n", - "x^2 , 0.9195925986987522\n", - "sin , 0.9179859981970137\n", - "gaussian , 0.916197691863038\n", - "x^4 , 0.9043637756591075\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.42e-06 | test loss: 1.42e-06 | reg: 1.03e-01 : 100%|██| 20/20 [00:00<00:00, 42.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9746783379118565\n", - "x^4 , 0.9547067294869719\n", - "x^2 , 0.9426800819283715\n", - "sin , 0.9405877648417602\n", - "gaussian , 0.9047220443136558\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.06e-06 | test loss: 1.06e-06 | reg: 2.36e-01 : 100%|██| 20/20 [00:00<00:00, 44.17it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999998722503725\n", - "tanh , 0.9999959867450359\n", - "sigmoid , 0.9999953377679788\n", - "arctan , 0.9999901647899601\n", - "gaussian , 0.9999791487269069\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.56e-07 | test loss: 8.56e-07 | reg: 2.06e-01 : 100%|██| 20/20 [00:00<00:00, 50.53it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999997233652407\n", - "tanh , 0.9999795491992056\n", - "sigmoid , 0.9999788713253935\n", - "arctan , 0.9999539297010896\n", - "gaussian , 0.9999367314200862\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.79e-07 | test loss: 6.79e-07 | reg: 1.77e-01 : 100%|██| 20/20 [00:00<00:00, 47.96it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999983352488726\n", - "gaussian , 0.9999608456659727\n", - "tanh , 0.9998803010371731\n", - "sigmoid , 0.9998795700743581\n", - "arctan , 0.9997532798065882\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.56e-07 | test loss: 5.56e-07 | reg: 1.48e-01 : 100%|██| 20/20 [00:00<00:00, 47.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999886905327071\n", - "gaussian , 0.9999526296594224\n", - "tanh , 0.9993739474035951\n", - "sigmoid , 0.9993731243691055\n", - "arctan , 0.998837883424404\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.28e-07 | test loss: 5.28e-07 | reg: 1.20e-01 : 100%|██| 20/20 [00:00<00:00, 47.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9999347944113626\n", - "sin , 0.9999299845850768\n", - "tanh , 0.9968744391727294\n", - "sigmoid , 0.9968734504088798\n", - "arctan , 0.9949201894762312\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.08e-07 | test loss: 6.08e-07 | reg: 9.51e-02 : 100%|██| 20/20 [00:00<00:00, 34.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9997595833681479\n", - "sin , 0.9993617636896577\n", - "abs , 0.9889704797728257\n", - "sigmoid , 0.9844737269360767\n", - "tanh , 0.9844552121850878\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.61e-07 | test loss: 7.61e-07 | reg: 7.30e-02 : 100%|██| 20/20 [00:00<00:00, 39.79it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.9979451890061467\n", - "sin , 0.9972568796736283\n", - "abs , 0.9882338451079785\n", - "x^2 , 0.9400830044171552\n", - "cosh , 0.9380462665721708\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.51e-07 | test loss: 9.51e-07 | reg: 6.06e-02 : 100%|██| 20/20 [00:00<00:00, 42.43it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9805383456413282\n", - "gaussian , 0.9793534545721814\n", - "abs , 0.9588682058685749\n", - "x^2 , 0.8881789600114199\n", - "cosh , 0.8769912910873774\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.16e-06 | test loss: 1.16e-06 | reg: 5.94e-02 : 100%|██| 20/20 [00:00<00:00, 42.80it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.8848700744056857\n", - "gaussian , 0.8765425797595888\n", - "x^2 , 0.854821484894479\n", - "cosh , 0.8535224650797281\n", - "abs , 0.8493986649063162\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.38e-06 | test loss: 1.38e-06 | reg: 7.70e-02 : 100%|██| 20/20 [00:00<00:00, 48.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9268644000446836\n", - "x^4 , 0.9112716246650874\n", - "x^2 , 0.8865324039130013\n", - "sin , 0.8842948895377678\n", - "gaussian , 0.8094804211038418\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.60e-06 | test loss: 1.60e-06 | reg: 1.05e-01 : 100%|██| 20/20 [00:00<00:00, 44.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "cosh , 0.9740201843349593\n", - "x^4 , 0.9673225582521513\n", - "gaussian , 0.952288197814531\n", - "tanh , 0.9497276520343576\n", - "sigmoid , 0.9497237037538462\n" - ] - } - ], - "source": [ - "# let's do a phase diagram, which looks quite \"fractal\"\n", - "num = 11\n", - "a_arr = np.linspace(0,1,num=num)\n", - "b_arr = np.linspace(0,1,num=num)\n", - "sf_mat = np.empty((num,num), dtype='U8')\n", - "\n", - "for i in range(num):\n", - " for j in range(num):\n", - " a = a_arr[i]; b = b_arr[j]\n", - " sf_mat[i,j] = mix(a, b)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "7c60506b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "classes = list(set(sf_mat.reshape(-1,)))\n", - "n_class = len(classes)\n", - "\n", - "colors = np.random.rand(n_class,4)\n", - "dic = {}\n", - "for i in range(n_class):\n", - " dic[classes[i]] = colors[i]\n", - " \n", - "\n", - "img = np.zeros((num,num,4))\n", - "for i in range(num):\n", - " for j in range(num):\n", - " img[i][j] = dic[sf_mat[i][j]]\n", - "plt.imshow(img)" - ] - }, - { - "cell_type": "markdown", - "id": "16bfe1f1", - "metadata": {}, - "source": [ - "### Does this mean symbolic regression is screwed? The hope is that by incorporating reasonable inductive biases (hence reducing the symbolic search space), SR will become more robust." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "39598bda", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['x', 'x^2', 'x^3', 'x^4', '1/x', '1/x^2', '1/x^3', '1/x^4', 'sqrt', '1/sqrt(x)', 'exp', 'log', 'abs', 'sin', 'tan', 'tanh', 'sigmoid', 'sgn', 'arcsin', 'arctan', 'arctanh', '0', 'gaussian', 'cosh'])" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# we have used the default symbolic library whch contains the following functions\n", - "SYMBOLIC_LIB.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "61234166", - "metadata": {}, - "outputs": [], - "source": [ - "# we may constrain to a smaller library (pass as parameter \"lib=lib\" in suggest_symbolic)\n", - "lib = ['exp', 'x^2', 'sin']\n", - "def mix(a, b, bound=1):\n", - " num_pts = 101\n", - " x = torch.linspace(-bound,bound,steps=num_pts)\n", - " x = x[:,None]\n", - " y = a * torch.sin(x) + b * x**2 + (1-a-b) * torch.exp(x)\n", - " dataset = {}\n", - " dataset['train_input'] = dataset['test_input'] = x\n", - " dataset['train_label'] = dataset['test_label'] = y\n", - " model = KAN(width=[1,1], grid=10, k=3, seed=0, grid_range=(-bound,bound))\n", - " model.train(dataset, opt=\"LBFGS\", steps=20)\n", - " return model.suggest_symbolic(0,0,0,lib=lib)[0]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "908b77ea", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.17e-08 | test loss: 2.17e-08 | reg: 2.58e-01 : 100%|██| 20/20 [00:00<00:00, 45.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999999999999639\n", - "x^2 , 0.9999841274399789\n", - "sin , 0.9999195962429422\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.02e-08 | test loss: 2.02e-08 | reg: 2.30e-01 : 100%|██| 20/20 [00:00<00:00, 43.80it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999940363902637\n", - "x^2 , 0.9999842116986534\n", - "sin , 0.9999055408903353\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.87e-08 | test loss: 1.87e-08 | reg: 2.03e-01 : 100%|██| 20/20 [00:00<00:00, 30.85it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999842858440444\n", - "exp , 0.9999260405306123\n", - "sin , 0.999886385951903\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.71e-08 | test loss: 1.71e-08 | reg: 1.76e-01 : 100%|██| 20/20 [00:00<00:00, 40.10it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999843962720248\n", - "exp , 0.9999007440044174\n", - "sin , 0.9998593570241779\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.56e-08 | test loss: 1.56e-08 | reg: 1.50e-01 : 100%|██| 20/20 [00:00<00:00, 40.88it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999845742894306\n", - "sin , 0.9998195334563984\n", - "exp , 0.9996560303116143\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.41e-08 | test loss: 1.41e-08 | reg: 1.24e-01 : 100%|██| 20/20 [00:00<00:00, 37.10it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999848839841157\n", - "sin , 0.9997576089235269\n", - "exp , 0.9990747506002051\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.26e-08 | test loss: 1.26e-08 | reg: 9.83e-02 : 100%|██| 20/20 [00:00<00:00, 38.95it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999854490365007\n", - "sin , 0.9996549423479186\n", - "exp , 0.9970989669443501\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.11e-08 | test loss: 1.11e-08 | reg: 7.39e-02 : 100%|██| 20/20 [00:00<00:00, 42.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999865646301423\n", - "sin , 0.9994730789192812\n", - "exp , 0.9895624276437505\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.54e-09 | test loss: 9.54e-09 | reg: 5.21e-02 : 100%|██| 20/20 [00:00<00:00, 46.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999889651827465\n", - "sin , 0.999120594481087\n", - "exp , 0.9559414617900991\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.03e-09 | test loss: 8.03e-09 | reg: 4.00e-02 : 100%|██| 20/20 [00:00<00:00, 48.92it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999924793158511\n", - "sin , 0.9987167102775933\n", - "exp , 0.7906888762229085\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.57e-09 | test loss: 6.57e-09 | reg: 3.95e-02 : 100%|██| 20/20 [00:00<00:00, 34.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999982519802602\n", - "sin , 0.9975488884124427\n", - "exp , 0.2695851370154267\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.04e-08 | test loss: 2.04e-08 | reg: 2.55e-01 : 100%|██| 20/20 [00:00<00:00, 35.39it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999897864586992\n", - "exp , 0.999941148365934\n", - "sin , 0.999933060918167\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.88e-08 | test loss: 1.88e-08 | reg: 2.28e-01 : 100%|██| 20/20 [00:00<00:00, 36.69it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999903651856844\n", - "exp , 0.9999481583538449\n", - "sin , 0.9999215913152464\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.73e-08 | test loss: 1.73e-08 | reg: 2.01e-01 : 100%|██| 20/20 [00:00<00:00, 42.49it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999910667256126\n", - "exp , 0.9999745307384252\n", - "sin , 0.9999059037181064\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.58e-08 | test loss: 1.58e-08 | reg: 1.75e-01 : 100%|██| 20/20 [00:00<00:00, 40.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999919340015667\n", - "sin , 0.9998836753524568\n", - "exp , 0.9998682812651544\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.43e-08 | test loss: 1.43e-08 | reg: 1.49e-01 : 100%|██| 20/20 [00:00<00:00, 44.22it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999930282260644\n", - "sin , 0.9998507984084428\n", - "exp , 0.9997376724009996\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.28e-08 | test loss: 1.28e-08 | reg: 1.23e-01 : 100%|██| 20/20 [00:00<00:00, 42.51it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999944249680105\n", - "sin , 0.9997993496969405\n", - "exp , 0.9992295248908697\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.12e-08 | test loss: 1.12e-08 | reg: 9.78e-02 : 100%|██| 20/20 [00:00<00:00, 34.00it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999962146964306\n", - "sin , 0.9997131766871225\n", - "exp , 0.9975441981216764\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.73e-09 | test loss: 9.73e-09 | reg: 7.42e-02 : 100%|██| 20/20 [00:00<00:00, 48.14it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999983708153872\n", - "sin , 0.9995575032145757\n", - "exp , 0.9909835169112797\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.22e-09 | test loss: 8.22e-09 | reg: 5.33e-02 : 100%|██| 20/20 [00:00<00:00, 37.91it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999990354001381\n", - "sin , 0.9992662822226276\n", - "exp , 0.960527319751894\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.73e-09 | test loss: 6.73e-09 | reg: 4.04e-02 : 100%|██| 20/20 [00:00<00:00, 40.84it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999913264861179\n", - "sin , 0.9988721445986375\n", - "exp , 0.80011712829603\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.20e-09 | test loss: 5.20e-09 | reg: 4.08e-02 : 100%|██| 20/20 [00:00<00:00, 40.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9998163363479399\n", - "sin , 0.9978431561059808\n", - "exp , 0.2814546223704926\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.90e-08 | test loss: 1.90e-08 | reg: 2.53e-01 : 100%|██| 20/20 [00:00<00:00, 43.20it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999999483032596\n", - "x^2 , 0.9999941967836338\n", - "sin , 0.9999450777771645\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.75e-08 | test loss: 1.75e-08 | reg: 2.26e-01 : 100%|██| 20/20 [00:00<00:00, 36.22it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999968986658919\n", - "x^2 , 0.9999950270576494\n", - "sin , 0.9999359202086953\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.60e-08 | test loss: 1.60e-08 | reg: 2.00e-01 : 100%|██| 20/20 [00:00<00:00, 46.59it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999959671234449\n", - "exp , 0.9999689579268118\n", - "sin , 0.9999233338974699\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.45e-08 | test loss: 1.45e-08 | reg: 1.73e-01 : 100%|██| 20/20 [00:00<00:00, 39.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999970388609115\n", - "exp , 0.9999277672142578\n", - "sin , 0.9999054264402666\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.30e-08 | test loss: 1.30e-08 | reg: 1.48e-01 : 100%|██| 20/20 [00:00<00:00, 43.91it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999981866112407\n", - "sin , 0.9998787853748133\n", - "exp , 0.9997940227934969\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.14e-08 | test loss: 1.14e-08 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 43.28it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999993305928151\n", - "sin , 0.999836805899482\n", - "exp , 0.9993569516643317\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.92e-09 | test loss: 9.92e-09 | reg: 9.77e-02 : 100%|██| 20/20 [00:00<00:00, 43.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999999767252477\n", - "sin , 0.9997657565532695\n", - "exp , 0.9979264009346674\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.41e-09 | test loss: 8.41e-09 | reg: 7.48e-02 : 100%|██| 20/20 [00:00<00:00, 48.04it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999970458743549\n", - "sin , 0.9996348080941417\n", - "exp , 0.9922256134147542\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.90e-09 | test loss: 6.90e-09 | reg: 5.51e-02 : 100%|██| 20/20 [00:00<00:00, 44.51it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999882011585163\n", - "sin , 0.9993792035049228\n", - "exp , 0.9648688511956083\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.37e-09 | test loss: 5.37e-09 | reg: 4.22e-02 : 100%|██| 20/20 [00:00<00:00, 40.25it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999431478128625\n", - "sin , 0.9989853642931659\n", - "exp , 0.8099064637358544\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.88e-09 | test loss: 3.88e-09 | reg: 4.35e-02 : 100%|██| 20/20 [00:00<00:00, 44.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9991878132353741\n", - "sin , 0.9979687146035487\n", - "exp , 0.2948244018433414\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.77e-08 | test loss: 1.77e-08 | reg: 2.51e-01 : 100%|██| 20/20 [00:00<00:00, 40.99it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999973837949323\n", - "sin , 0.9999556108208976\n", - "exp , 0.9999423526826876\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.62e-08 | test loss: 1.62e-08 | reg: 2.25e-01 : 100%|██| 20/20 [00:00<00:00, 36.59it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999981726743682\n", - "sin , 0.9999484842856431\n", - "exp , 0.9999473753358622\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.47e-08 | test loss: 1.47e-08 | reg: 1.98e-01 : 100%|██| 20/20 [00:00<00:00, 44.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999989595646115\n", - "exp , 0.9999492978808466\n", - "sin , 0.9999386215876175\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.32e-08 | test loss: 1.32e-08 | reg: 1.72e-01 : 100%|██| 20/20 [00:00<00:00, 44.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999996254779309\n", - "exp , 0.9999403199854738\n", - "sin , 0.9999245063324657\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.16e-08 | test loss: 1.16e-08 | reg: 1.47e-01 : 100%|██| 20/20 [00:00<00:00, 53.99it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999999902142925\n", - "sin , 0.9999033788427966\n", - "exp , 0.9998233862273559\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.01e-08 | test loss: 1.01e-08 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 43.09it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999993945260922\n", - "sin , 0.9998698461072781\n", - "exp , 0.9994604176643853\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.60e-09 | test loss: 8.60e-09 | reg: 9.78e-02 : 100%|██| 20/20 [00:00<00:00, 40.29it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999962624913747\n", - "sin , 0.999812394838402\n", - "exp , 0.9982470612489773\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.09e-09 | test loss: 7.09e-09 | reg: 7.58e-02 : 100%|██| 20/20 [00:00<00:00, 39.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999855256919693\n", - "sin , 0.9997042323555781\n", - "exp , 0.9934084524703305\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.56e-09 | test loss: 5.56e-09 | reg: 5.74e-02 : 100%|██| 20/20 [00:00<00:00, 48.21it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999509121969333\n", - "sin , 0.9994826743156423\n", - "exp , 0.9690407199009088\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.05e-09 | test loss: 4.05e-09 | reg: 4.54e-02 : 100%|██| 20/20 [00:00<00:00, 39.78it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9998306455096987\n", - "sin , 0.9990671369324535\n", - "exp , 0.8200102819209695\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.55e-09 | test loss: 2.55e-09 | reg: 4.76e-02 : 100%|██| 20/20 [00:00<00:00, 36.39it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9979550584268881\n", - "sin , 0.9978931765377275\n", - "exp , 0.30997176980589874\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.64e-08 | test loss: 1.64e-08 | reg: 2.50e-01 : 100%|██| 20/20 [00:00<00:00, 40.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999995435772306\n", - "x^2 , 0.9999993202720766\n", - "sin , 0.9999646329733246\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.49e-08 | test loss: 1.49e-08 | reg: 2.23e-01 : 100%|██| 20/20 [00:00<00:00, 41.62it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.999999776416721\n", - "exp , 0.9999936654595362\n", - "sin , 0.9999592519777621\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.34e-08 | test loss: 1.34e-08 | reg: 1.97e-01 : 100%|██| 20/20 [00:00<00:00, 44.66it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999999292547446\n", - "exp , 0.9999841395212624\n", - "sin , 0.999951727445816\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.19e-08 | test loss: 1.19e-08 | reg: 1.71e-01 : 100%|██| 20/20 [00:00<00:00, 44.92it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999996917196639\n", - "sin , 0.9999408710455521\n", - "exp , 0.9999069779386928\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.03e-08 | test loss: 1.03e-08 | reg: 1.46e-01 : 100%|██| 20/20 [00:00<00:00, 47.71it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999982862472424\n", - "sin , 0.999924500202756\n", - "exp , 0.9998279543178681\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.80e-09 | test loss: 8.80e-09 | reg: 1.21e-01 : 100%|██| 20/20 [00:00<00:00, 42.92it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.999994399261074\n", - "sin , 0.9998982872842133\n", - "exp , 0.9995430618744594\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.28e-09 | test loss: 7.28e-09 | reg: 9.82e-02 : 100%|██| 20/20 [00:00<00:00, 44.87it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999846769079466\n", - "sin , 0.9998527941960059\n", - "exp , 0.998507365877467\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.76e-09 | test loss: 5.76e-09 | reg: 7.72e-02 : 100%|██| 20/20 [00:00<00:00, 40.42it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999591064202273\n", - "sin , 0.9997651030691422\n", - "exp , 0.994405837621339\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.24e-09 | test loss: 4.24e-09 | reg: 6.02e-02 : 100%|██| 20/20 [00:00<00:00, 42.98it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9998837805081656\n", - "sin , 0.9995754338853143\n", - "exp , 0.972913947729953\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.73e-09 | test loss: 2.73e-09 | reg: 5.00e-02 : 100%|██| 20/20 [00:00<00:00, 41.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9996498645481074\n", - "sin , 0.9991201921166716\n", - "exp , 0.8303506225546471\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.24e-09 | test loss: 1.24e-09 | reg: 5.35e-02 : 100%|██| 20/20 [00:00<00:00, 33.88it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9975671382600958\n", - "x^2 , 0.9959025139156165\n", - "exp , 0.3272398323990947\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.51e-08 | test loss: 1.51e-08 | reg: 2.48e-01 : 100%|██| 20/20 [00:00<00:00, 33.97it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999999273977364\n", - "sin , 0.999972137087767\n", - "exp , 0.9999416230314031\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.36e-08 | test loss: 1.36e-08 | reg: 2.22e-01 : 100%|██| 20/20 [00:00<00:00, 40.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999998145393945\n", - "sin , 0.9999682142467496\n", - "exp , 0.9999659993562859\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.21e-08 | test loss: 1.21e-08 | reg: 1.96e-01 : 100%|██| 20/20 [00:00<00:00, 44.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999990327979635\n", - "sin , 0.9999626403806093\n", - "exp , 0.9999479302673148\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.05e-08 | test loss: 1.05e-08 | reg: 1.71e-01 : 100%|██| 20/20 [00:00<00:00, 41.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999971222660284\n", - "sin , 0.9999545031184953\n", - "exp , 0.9999322662928528\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.01e-09 | test loss: 9.01e-09 | reg: 1.46e-01 : 100%|██| 20/20 [00:00<00:00, 43.63it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999928506457437\n", - "sin , 0.9999421177337516\n", - "exp , 0.9998097288010696\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.49e-09 | test loss: 7.49e-09 | reg: 1.21e-01 : 100%|██| 20/20 [00:00<00:00, 44.46it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999822360404783\n", - "sin , 0.9999220769608526\n", - "exp , 0.9996077177342251\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.96e-09 | test loss: 5.96e-09 | reg: 9.89e-02 : 100%|██| 20/20 [00:00<00:00, 53.97it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.999964802453253\n", - "sin , 0.9998867957502443\n", - "exp , 0.9987081345779585\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.44e-09 | test loss: 4.44e-09 | reg: 7.88e-02 : 100%|██| 20/20 [00:00<00:00, 43.92it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999175944145272\n", - "sin , 0.9998169466724585\n", - "exp , 0.9952629708219127\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.92e-09 | test loss: 2.92e-09 | reg: 6.33e-02 : 100%|██| 20/20 [00:00<00:00, 40.19it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9997839395304963\n", - "sin , 0.9996559816500792\n", - "exp , 0.9765461190280487\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.43e-09 | test loss: 1.43e-09 | reg: 5.57e-02 : 100%|██| 20/20 [00:00<00:00, 31.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9993615297170999\n", - "sin , 0.9992162433614376\n", - "exp , 0.8408048845759444\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.44e-10 | test loss: 3.44e-10 | reg: 6.15e-02 : 100%|██| 20/20 [00:00<00:00, 23.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9969431394468133\n", - "x^2 , 0.9927325368990941\n", - "exp , 0.34705555016523576\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.38e-08 | test loss: 1.38e-08 | reg: 2.47e-01 : 100%|██| 20/20 [00:00<00:00, 27.06it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999993835845823\n", - "exp , 0.9999979009384041\n", - "sin , 0.9999781529177164\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.23e-08 | test loss: 1.23e-08 | reg: 2.21e-01 : 100%|██| 20/20 [00:00<00:00, 28.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999982596377558\n", - "exp , 0.9999826642402296\n", - "sin , 0.999975403004672\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.07e-08 | test loss: 1.07e-08 | reg: 1.95e-01 : 100%|██| 20/20 [00:00<00:00, 28.02it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999960480978767\n", - "sin , 0.9999713985665561\n", - "exp , 0.9999678693890908\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.22e-09 | test loss: 9.22e-09 | reg: 1.70e-01 : 100%|██| 20/20 [00:00<00:00, 35.18it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.999991537192374\n", - "sin , 0.999965455283627\n", - "exp , 0.9999527752253392\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.70e-09 | test loss: 7.70e-09 | reg: 1.45e-01 : 100%|██| 20/20 [00:00<00:00, 30.27it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999840061625307\n", - "sin , 0.9999562904170857\n", - "exp , 0.999848705695026\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.17e-09 | test loss: 6.17e-09 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 24.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999686012309674\n", - "sin , 0.9999412814570412\n", - "exp , 0.9996568552973389\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.65e-09 | test loss: 4.65e-09 | reg: 9.98e-02 : 100%|██| 20/20 [00:00<00:00, 28.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.999936210582381\n", - "sin , 0.999914407864863\n", - "exp , 0.998905881229885\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.14e-09 | test loss: 3.13e-09 | reg: 8.08e-02 : 100%|██| 20/20 [00:00<00:00, 37.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9998600127039595\n", - "sin , 0.9998596147774699\n", - "exp , 0.9960274461980388\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.63e-09 | test loss: 1.63e-09 | reg: 6.69e-02 : 100%|██| 20/20 [00:00<00:00, 39.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9997236129916397\n", - "x^2 , 0.9996456211560416\n", - "exp , 0.9798815731174731\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.91e-10 | test loss: 3.91e-10 | reg: 6.21e-02 : 100%|██| 20/20 [00:00<00:00, 37.63it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9992448590848789\n", - "x^2 , 0.9989434205375304\n", - "exp , 0.851363652171008\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.48e-09 | test loss: 1.48e-09 | reg: 6.99e-02 : 100%|██| 20/20 [00:00<00:00, 41.08it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9959631103992738\n", - "x^2 , 0.9880298934280559\n", - "exp , 0.3699525677002401\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.25e-08 | test loss: 1.25e-08 | reg: 2.46e-01 : 100%|██| 20/20 [00:00<00:00, 37.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999974755376599\n", - "sin , 0.999982771618615\n", - "exp , 0.9999378510072501\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.10e-08 | test loss: 1.10e-08 | reg: 2.20e-01 : 100%|██| 20/20 [00:00<00:00, 46.47it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999950949412941\n", - "sin , 0.9999809179819591\n", - "exp , 0.9999775858852623\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.43e-09 | test loss: 9.43e-09 | reg: 1.94e-01 : 100%|██| 20/20 [00:00<00:00, 48.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999909995161567\n", - "sin , 0.99997811973606\n", - "exp , 0.9999745650796973\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.91e-09 | test loss: 7.91e-09 | reg: 1.69e-01 : 100%|██| 20/20 [00:00<00:00, 40.15it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999839054191747\n", - "sin , 0.9999738708591638\n", - "exp , 0.9999301819009739\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.39e-09 | test loss: 6.39e-09 | reg: 1.45e-01 : 100%|██| 20/20 [00:00<00:00, 49.67it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999712511423499\n", - "sin , 0.9999672116732772\n", - "exp , 0.9998759476535651\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.87e-09 | test loss: 4.87e-09 | reg: 1.22e-01 : 100%|██| 20/20 [00:00<00:00, 41.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999561449575607\n", - "x^2 , 0.9999474340188654\n", - "exp , 0.9996925240661405\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.36e-09 | test loss: 3.36e-09 | reg: 1.01e-01 : 100%|██| 20/20 [00:00<00:00, 37.69it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999359791634311\n", - "x^2 , 0.9998987103013962\n", - "exp , 0.9990779156635234\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.86e-09 | test loss: 1.86e-09 | reg: 8.32e-02 : 100%|██| 20/20 [00:00<00:00, 41.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.999893422872044\n", - "x^2 , 0.9997851521886209\n", - "exp , 0.9966235714622826\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.79e-10 | test loss: 5.79e-10 | reg: 7.13e-02 : 100%|██| 20/20 [00:00<00:00, 39.52it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9997784124877638\n", - "x^2 , 0.9994637170628504\n", - "exp , 0.9828804558908593\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.33e-09 | test loss: 1.33e-09 | reg: 6.87e-02 : 100%|██| 20/20 [00:00<00:00, 37.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9992376323441506\n", - "x^2 , 0.9983591814967973\n", - "exp , 0.862391351818434\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.79e-09 | test loss: 2.79e-09 | reg: 7.94e-02 : 100%|██| 20/20 [00:00<00:00, 39.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9944110485646586\n", - "x^2 , 0.9816962474224649\n", - "exp , 0.3965991904252684\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.12e-08 | test loss: 1.12e-08 | reg: 2.45e-01 : 100%|██| 20/20 [00:00<00:00, 30.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999942564460803\n", - "exp , 0.9999934337977243\n", - "sin , 0.9999861648364792\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.65e-09 | test loss: 9.65e-09 | reg: 2.19e-01 : 100%|██| 20/20 [00:00<00:00, 35.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999902923652078\n", - "sin , 0.9999849518514359\n", - "exp , 0.9999613659020306\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.13e-09 | test loss: 8.13e-09 | reg: 1.94e-01 : 100%|██| 20/20 [00:00<00:00, 31.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999837274020729\n", - "sin , 0.9999830308299852\n", - "exp , 0.9999154398628454\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.61e-09 | test loss: 6.61e-09 | reg: 1.69e-01 : 100%|██| 20/20 [00:00<00:00, 28.46it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999800294497047\n", - "x^2 , 0.9999731551293094\n", - "exp , 0.9999043625986571\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.09e-09 | test loss: 5.09e-09 | reg: 1.45e-01 : 100%|██| 20/20 [00:00<00:00, 36.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999752362233539\n", - "x^2 , 0.9999543237918428\n", - "exp , 0.9998837024119729\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.59e-09 | test loss: 3.59e-09 | reg: 1.23e-01 : 100%|██| 20/20 [00:00<00:00, 33.71it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999671472397126\n", - "x^2 , 0.999920520242572\n", - "exp , 0.9997162974965994\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.11e-09 | test loss: 2.11e-09 | reg: 1.02e-01 : 100%|██| 20/20 [00:00<00:00, 29.70it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999521118045746\n", - "x^2 , 0.9998517198959569\n", - "exp , 0.9991994724291818\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.18e-10 | test loss: 8.18e-10 | reg: 8.60e-02 : 100%|██| 20/20 [00:00<00:00, 27.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999191931580688\n", - "x^2 , 0.9996922419099825\n", - "exp , 0.9971630293162339\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.23e-09 | test loss: 1.23e-09 | reg: 7.58e-02 : 100%|██| 20/20 [00:00<00:00, 27.04it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9998214259046335\n", - "x^2 , 0.9992365904461334\n", - "exp , 0.9855351478460005\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.62e-09 | test loss: 2.62e-09 | reg: 7.77e-02 : 100%|██| 20/20 [00:00<00:00, 24.95it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9992094653374828\n", - "x^2 , 0.997561488327335\n", - "exp , 0.8738196605080718\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.10e-09 | test loss: 4.10e-09 | reg: 9.07e-02 : 100%|██| 20/20 [00:00<00:00, 34.69it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9922364482738998\n", - "x^2 , 0.9865738449440605\n", - "exp , 0.42783037973898724\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 9.87e-09 | test loss: 9.87e-09 | reg: 2.44e-01 : 100%|██| 20/20 [00:00<00:00, 48.50it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9999896926875822\n", - "sin , 0.9999885782292838\n", - "exp , 0.9999292279786546\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.35e-09 | test loss: 8.35e-09 | reg: 2.18e-01 : 100%|██| 20/20 [00:00<00:00, 33.16it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999877872886065\n", - "x^2 , 0.9999838323248553\n", - "exp , 0.9999789165976448\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.84e-09 | test loss: 6.84e-09 | reg: 1.93e-01 : 100%|██| 20/20 [00:00<00:00, 46.33it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999864664396515\n", - "x^2 , 0.9999745891023756\n", - "exp , 0.9999649555496989\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.32e-09 | test loss: 5.32e-09 | reg: 1.69e-01 : 100%|██| 20/20 [00:00<00:00, 40.58it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999843410323541\n", - "x^2 , 0.9999595824867687\n", - "exp , 0.9999363993653761\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.83e-09 | test loss: 3.83e-09 | reg: 1.46e-01 : 100%|██| 20/20 [00:00<00:00, 41.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999808836617524\n", - "x^2 , 0.9999340658950667\n", - "exp , 0.9998727806292239\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.36e-09 | test loss: 2.36e-09 | reg: 1.24e-01 : 100%|██| 20/20 [00:00<00:00, 45.26it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999749630672443\n", - "x^2 , 0.9998877158288519\n", - "exp , 0.9997292201760375\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.08e-09 | test loss: 1.08e-09 | reg: 1.04e-01 : 100%|██| 20/20 [00:00<00:00, 40.71it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999637514193707\n", - "x^2 , 0.9997949968711753\n", - "exp , 0.9992688918286982\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.18e-09 | test loss: 1.18e-09 | reg: 8.91e-02 : 100%|██| 20/20 [00:00<00:00, 40.07it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999382587554829\n", - "x^2 , 0.9995804083543193\n", - "exp , 0.997562547933165\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.49e-09 | test loss: 2.49e-09 | reg: 8.13e-02 : 100%|██| 20/20 [00:00<00:00, 39.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9998545572827711\n", - "x^2 , 0.9989551972006018\n", - "exp , 0.9878365883665239\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.94e-09 | test loss: 3.94e-09 | reg: 8.77e-02 : 100%|██| 20/20 [00:00<00:00, 41.76it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.999179162081282\n", - "x^2 , 0.9964947779569694\n", - "exp , 0.8855949580343588\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.41e-09 | test loss: 5.41e-09 | reg: 1.03e-01 : 100%|██| 20/20 [00:00<00:00, 44.07it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9896743802302694\n", - "sin , 0.9893409020756886\n", - "exp , 0.4646785423849215\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.57e-09 | test loss: 8.57e-09 | reg: 2.43e-01 : 100%|██| 20/20 [00:00<00:00, 37.81it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999902713620692\n", - "x^2 , 0.9999807202372036\n", - "exp , 0.9997379079627818\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.06e-09 | test loss: 7.06e-09 | reg: 2.18e-01 : 100%|██| 20/20 [00:00<00:00, 47.32it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.999989739250175\n", - "x^2 , 0.9999756704785013\n", - "exp , 0.999926363885015\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.56e-09 | test loss: 5.56e-09 | reg: 1.93e-01 : 100%|██| 20/20 [00:00<00:00, 52.19it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999888074224221\n", - "x^2 , 0.9999631678786869\n", - "exp , 0.9999447765899155\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.07e-09 | test loss: 4.07e-09 | reg: 1.69e-01 : 100%|██| 20/20 [00:00<00:00, 37.65it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999872737863882\n", - "x^2 , 0.9999431335080622\n", - "exp , 0.9999263142234696\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.62e-09 | test loss: 2.62e-09 | reg: 1.46e-01 : 100%|██| 20/20 [00:00<00:00, 30.64it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999847406083843\n", - "x^2 , 0.999909483042181\n", - "exp , 0.9998436631999283\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.34e-09 | test loss: 1.34e-09 | reg: 1.25e-01 : 100%|██| 20/20 [00:00<00:00, 28.07it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999803638564161\n", - "x^2 , 0.999848886198266\n", - "exp , 0.9997317587005629\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.19e-09 | test loss: 1.19e-09 | reg: 1.06e-01 : 100%|██| 20/20 [00:00<00:00, 27.57it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999719462457353\n", - "x^2 , 0.9997282247718177\n", - "exp , 0.9992837377086745\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.37e-09 | test loss: 2.37e-09 | reg: 9.29e-02 : 100%|██| 20/20 [00:00<00:00, 29.79it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9999521133602743\n", - "x^2 , 0.999448434641883\n", - "exp , 0.9978756985305871\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.79e-09 | test loss: 3.79e-09 | reg: 8.83e-02 : 100%|██| 20/20 [00:00<00:00, 43.22it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.99988019998444\n", - "x^2 , 0.998618508248868\n", - "exp , 0.9897729427792255\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.25e-09 | test loss: 5.25e-09 | reg: 9.97e-02 : 100%|██| 20/20 [00:00<00:00, 39.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "sin , 0.9991252607520362\n", - "x^2 , 0.995078459413144\n", - "exp , 0.8974993831807665\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.71e-09 | test loss: 6.71e-09 | reg: 1.16e-01 : 100%|██| 20/20 [00:00<00:00, 42.40it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "x^2 , 0.9896966425177599\n", - "sin , 0.985121456003004\n", - "exp , 0.508387788052642\n" - ] - } - ], - "source": [ - "# we can redo the analysis for a more contrained (bound) region. The phase diagram becomes even more \"fractal\"\n", - "num = 11\n", - "a_arr = np.linspace(0,1,num=num)\n", - "b_arr = np.linspace(0,1,num=num)\n", - "sf_mat = np.empty((num,num), dtype='U8')\n", - "\n", - "for i in range(num):\n", - " for j in range(num):\n", - " a = a_arr[i]; b = b_arr[j]\n", - " sf_mat[i,j] = mix(a, b, bound=0.3)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "759c31f7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "classes = list(set(sf_mat.reshape(-1,)))\n", - "n_class = len(classes)\n", - "\n", - "colors = np.random.rand(n_class,4)\n", - "dic = {}\n", - "for i in range(n_class):\n", - " dic[classes[i]] = colors[i]\n", - " \n", - "\n", - "img = np.zeros((num,num,4))\n", - "for i in range(num):\n", - " for j in range(num):\n", - " img[i][j] = dic[sf_mat[i][j]]\n", - "plt.imshow(img)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_5_special_functions_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_5_special_functions_-checkpoint.ipynb deleted file mode 100644 index 1bc5e4071..000000000 --- a/docs/.ipynb_checkpoints/Example_5_special_functions_-checkpoint.ipynb +++ /dev/null @@ -1,546 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 5: Special functions" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### Let's construct a dataset which contains special functions $f(x,y)={\\rm exp}(J_0(20x)+y^2)$, where $J_0(x)$ is the Bessel function." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.40e-01 | test loss: 1.38e-01 | reg: 2.88e+01 : 100%|██| 20/20 [00:30<00:00, 1.50s/it]\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset, SYMBOLIC_LIB, add_symbolic\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=20, k=3, seed=0)\n", - "f = lambda x: torch.exp(torch.special.bessel_j0(20*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "### Plot trained KAN, the bessel function shows up in the bettom left" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "733a2a41", - "metadata": {}, - "source": [ - "### suggest_symbolic does not return anything that matches with it, since Bessel function isn't included in the default SYMBOLIC_LIB. We want to add Bessel to it." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "031db28f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.7090268761989152\n", - "1/x^2 , 0.21051195154680438\n", - "sin , 0.1822506022370818\n", - "abs , 0.12418544555819415\n", - "tan , 0.10407480103502795\n" - ] - }, - { - "data": { - "text/plain": [ - "('gaussian',\n", - " ((x)>, (x)>),\n", - " 0.7090268761989152)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4b8549a2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['x', 'x^2', 'x^3', 'x^4', '1/x', '1/x^2', '1/x^3', '1/x^4', 'sqrt', '1/sqrt(x)', 'exp', 'log', 'abs', 'sin', 'tan', 'tanh', 'sigmoid', 'sgn', 'arcsin', 'arctan', 'arctanh', '0', 'gaussian', 'cosh'])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "SYMBOLIC_LIB.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "cbde1924", - "metadata": {}, - "outputs": [], - "source": [ - "# add bessel function J0 to the symbolic library\n", - "# we should include a name and a pytorch implementation\n", - "add_symbolic('J0', torch.special.bessel_j0)" - ] - }, - { - "cell_type": "markdown", - "id": "bda24c6d", - "metadata": {}, - "source": [ - "### After adding Bessel, we check suggest_symbolic again" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "83e5cfdd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "gaussian , 0.7090268761989152\n", - "J0 , 0.2681378679614782\n", - "1/x^2 , 0.21051195154680438\n", - "sin , 0.1822506022370818\n", - "abs , 0.12418544555819415\n" - ] - }, - { - "data": { - "text/plain": [ - "('gaussian',\n", - " ((x)>, (x)>),\n", - " 0.7090268761989152)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# J0 shows up but not top 1, why?\n", - "\n", - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e78f4674", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "J0 , 0.9717763100936939\n", - "gaussian , 0.7494106253678943\n", - "sin , 0.49679878395526067\n", - "1/x^2 , 0.21051195158162733\n", - "abs , 0.12435207425739554\n" - ] - }, - { - "data": { - "text/plain": [ - "('J0',\n", - " (, J0),\n", - " 0.9717763100936939)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# This is because the ground truth is J0(20x) which involves 20 which is too large.\n", - "# our default search is in (-10,10)\n", - "# so we need to set the search range bigger in order to include 20\n", - "# now J0 appears at the top of the list\n", - "\n", - "model.suggest_symbolic(0,0,0,a_range=(-40,40))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "47fb0d09", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.67e-02 | test loss: 1.80e-02 | reg: 2.87e+00 : 100%|██| 20/20 [00:08<00:00, 2.25it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "4773e989", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "104199f4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "J0 , 0.9985560043309399\n", - "gaussian , 0.6101756259771707\n", - "sin , 0.5737221152646913\n", - "tan , 0.08366297315238909\n", - "1/x , 0.08315973336762218\n" - ] - }, - { - "data": { - "text/plain": [ - "('J0',\n", - " (, J0),\n", - " 0.9985560043309399)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,0,0,a_range=(-40,40))" - ] - }, - { - "cell_type": "markdown", - "id": "fe1f857d", - "metadata": {}, - "source": [ - "### Finish the rest of symbolic regression" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "eb6c0f43", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9985560043309399\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9986)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'J0',a_range=(-40,40))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "11a27268", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "skipping (0,0,0) since already symbolic\n", - "fixing (0,1,0) with x^2, r2=0.9999802186534139\n", - "fixing (1,0,0) with sigmoid, r2=0.9999663092809886\n" - ] - } - ], - "source": [ - "model.auto_symbolic()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "5076005f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "79816b25", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.12e-03 | test loss: 1.17e-03 | reg: 4.76e+01 : 100%|██| 20/20 [00:08<00:00, 2.38it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "ba171cc4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e26b771f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "function , r2\n", - "exp , 0.9999988610586863\n", - "cosh , 0.9999699077016541\n", - "sigmoid , 0.9999693609882967\n", - "arctan , 0.9999174139339265\n", - "gaussian , 0.9999096961395885\n" - ] - }, - { - "data": { - "text/plain": [ - "('exp',\n", - " ((x)>, (x)>),\n", - " 0.9999988610586863)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(1,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "b939a769", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999988610586863\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000, grad_fn=)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(1,0,0,'exp')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "a0e2813a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 8.09e-04 | test loss: 8.51e-04 | reg: 4.68e+01 : 100%|██| 20/20 [00:05<00:00, 3.96it/s]\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 e^{1.0 x_{2}^{2} + 1.0 J_{0}{\\left(- 20.0 x_{1} \\right)}}$" - ], - "text/plain": [ - "1.0*exp(1.0*x_2**2 + 1.0*J0(-20.0*x_1))" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# why can't we reach machine precision (because LBFGS early stops?)? The symbolic formula is correct though.\n", - "model.train(dataset, opt=\"LBFGS\", steps=20);\n", - "model.symbolic_formula()[0][0]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_6_PDE_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_6_PDE_-checkpoint.ipynb deleted file mode 100644 index 4cc20ade0..000000000 --- a/docs/.ipynb_checkpoints/Example_6_PDE_-checkpoint.ipynb +++ /dev/null @@ -1,270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 6: Solving Partial Differential Equation (PDE)" - ] - }, - { - "cell_type": "markdown", - "id": "7d568912", - "metadata": {}, - "source": [ - "### We aim to solve a 2D poisson equation $\\nabla^2 f(x,y) = -2\\pi^2{\\rm sin}(\\pi x){\\rm sin}(\\pi y)$, with boundary condition $f(-1,y)=f(1,y)=f(x,-1)=f(x,1)=0$. The ground truth solution is $f(x,y)={\\rm sin}(\\pi x){\\rm sin}(\\pi y)$." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0e2bc449", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "pde loss: 5.26e+00 | bc loss: 7.96e-02 | l2: 2.62e-02 : 100%|█| 20/20 [00:19<00:\n" - ] - } - ], - "source": [ - "from kan import KAN, LBFGS\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "from torch import autograd\n", - "from tqdm import tqdm\n", - "\n", - "dim = 2\n", - "np_i = 21 # number of interior points (along each dimension)\n", - "np_b = 21 # number of boundary points (along each dimension)\n", - "ranges = [-1, 1]\n", - "\n", - "model = KAN(width=[2,2,1], grid=5, k=3, grid_eps=1.0, noise_scale_base=0.25)\n", - "\n", - "def batch_jacobian(func, x, create_graph=False):\n", - " # x in shape (Batch, Length)\n", - " def _func_sum(x):\n", - " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", - "\n", - "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "\n", - "# interior\n", - "sampling_mode = 'random' # 'radnom' or 'mesh'\n", - "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - "\n", - "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "xb1 = helper(X[0], Y[0])\n", - "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", - "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", - "\n", - "steps = 20\n", - "alpha = 0.1\n", - "log = 1\n", - "\n", - "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "\n", - " pbar = tqdm(range(steps), desc='description')\n", - "\n", - " for _ in pbar:\n", - " def closure():\n", - " global pde_loss, bc_loss\n", - " optimizer.zero_grad()\n", - " # interior loss\n", - " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", - " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", - " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", - " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", - "\n", - " # boundary loss\n", - " bc_true = sol_fun(x_b)\n", - " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", - "\n", - " loss = alpha * pde_loss + bc_loss\n", - " loss.backward()\n", - " return loss\n", - "\n", - " if _ % 5 == 0 and _ < 50:\n", - " model.update_grid_from_samples(x_i)\n", - "\n", - " optimizer.step(closure)\n", - " sol = sol_fun(x_i)\n", - " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", - "\n", - " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.detach().numpy()))\n", - "\n", - "train()" - ] - }, - { - "cell_type": "markdown", - "id": "e2246bab", - "metadata": {}, - "source": [ - "### Plot the trained KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "02e2a0ba", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "64d2573b", - "metadata": {}, - "source": [ - "### Fix the first layer activation to be linear function, and the second layer to be sine functions (caveat: this is quite sensitive to hypreparams)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e2e78752", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best value at boundary.\n", - "r2 is 0.9982730203177389\n", - "Best value at boundary.\n", - "r2 is 0.9978885507047336\n", - "Best value at boundary.\n", - "r2 is 0.9967572093934152\n", - "Best value at boundary.\n", - "r2 is 0.9977250982977139\n", - "r2 is 0.9737003463841577\n", - "r2 is 0.9826072748927763\n" - ] - } - ], - "source": [ - "for i in range(2):\n", - " for j in range(2):\n", - " model.fix_symbolic(0,i,j,'x')\n", - " \n", - "for i in range(2):\n", - " model.fix_symbolic(1,i,0,'sin')" - ] - }, - { - "cell_type": "markdown", - "id": "3fae3f32", - "metadata": {}, - "source": [ - "### After setting all to be symbolic, we further train the model (affine parameters are still trainable). The model can now reach machine precision!" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "308b72af", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "pde loss: 4.38e-15 | bc loss: 5.92e-16 | l2: 4.99e-16 : 100%|█| 20/20 [00:09<00:\n" - ] - } - ], - "source": [ - "train()" - ] - }, - { - "cell_type": "markdown", - "id": "35985ae9", - "metadata": {}, - "source": [ - "### Print out the symbolic formula" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f0ec310e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.5*sin(-3.14159*x_1 + 3.14159*x_2 + 7.85398) + 0.5*sin(3.14159*x_1 + 3.14159*x_2 + 4.71239)]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula, var = model.symbolic_formula(floating_digit=5)\n", - "formula" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_7_continual_learning_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_7_continual_learning_-checkpoint.ipynb deleted file mode 100644 index 0d0847e5d..000000000 --- a/docs/.ipynb_checkpoints/Example_7_continual_learning_-checkpoint.ipynb +++ /dev/null @@ -1,232 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 7: Continual Learning" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### Setup: Our goal is to learn a 1D function from samples. The 1D function has 5 Gaussian peaks. Instead of presenting all samples to NN all at once, we have five phases of learning. In each phase only samples around one peak is presented to KAN. We find that KANs can do continual learning thanks to locality of splines." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1yElEQVR4nO2deXwU9f3/X7ubY3MuCUcSIEBEQEK8CIZL8EY8UFu/VascWrQibT1Qq1RtiK1FW0vpIXgi9ahFq1j5qVGschSwyClLQBCCIGwISch973x+f2xms5vsMbM785nP7r6fjwePh04+O/P5PPezn3nPZ2Y+bxNjjIEgCIIgCMIgzEZXgCAIgiCI2IaCEYIgCIIgDIWCEYIgCIIgDIWCEYIgCIIgDIWCEYIgCIIgDIWCEYIgCIIgDIWCEYIgCIIgDIWCEYIgCIIgDCXO6AooQZIknDhxAmlpaTCZTEZXhyAIgiAIBTDG0NDQgIEDB8Js9j//ERHByIkTJ5Cbm2t0NQiCIAiCCIFjx45h8ODBfv8eEcFIWloaAFdj0tPTDa4NQRAEQRBKqK+vR25urvs87o+ICEbkWzPp6ekUjBAEQRBEhBHsEQt6gJUgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCEOhYIQgCIIgCENRHYxs2LABM2bMwMCBA2EymfD+++8H/cz69etRWFgIq9WKM844A88//3wodY15nBLDpoNVePaT/Xj2k2+w6dsqOCVmdLWiDvLMB/LMj/ZOCa9sPIxf/9uOVzYeRnunZHSVohLq06FjYoypMvXxxx9j06ZNGDt2LG688UasXr0aN9xwg9/y5eXlKCgowF133YW7774bmzZtwvz58/HWW2/hxhtvVHTM+vp62Gw21NXVxexy8KV2Bx59bw9qmzu8tvdJjsfTPzwb0wtyDKpZdEGe+UCe+bH4ozK8tLEcnudEswm4a0oeFl6db1zFogzq075Rev5WHYx4fdhkChqMPPLII/jggw+wb98+97Z58+Zh9+7d2LJli6LjxHowUmp3YN4bOwKWeX7m2Jjt7FpBnvlAnvmx+KMyvLCh3O/f755KAYkWUJ/2j9Lzt+7PjGzZsgXTpk3z2nbllVdi27Zt6Ojo8PmZtrY21NfXe/2LVZwSw6IP9gYtV7KmjKYDw4A884E886O9U8JLG/0HIgDw0sZyumUTJtSntUH3YKSiogJZWVle27KystDZ2Ymqqiqfn1m8eDFsNpv7X25urt7VFJat5TWoqG8LWs5R14qt5TUcahSdkGc+kGd+vL7lCIKd+yTmKkeEDvVpbeDyNk3P1MHynSF/KYUXLlyIuro6979jx47pXkdR+aysQnHZtSrKEt6QZz6QZ35sPHhKUbkNB31fFBLKoD6tDboHI9nZ2aio8P4CKisrERcXh759+/r8TGJiItLT073+xSJOiWH1ruOKy/971wmaBgwB8swH8swPp8Sw/ehpRWV3Hj1NnkOE+rR26B6MTJw4EWvXrvXa9umnn2LcuHGIj4/X+/ARzdbyGtQ0+X6uxhfVTe00DRgC5JkP5JkfW8tr0NDqVFS2vrWTPIcI9WntUB2MNDY2YteuXdi1axcA16u7u3btwtGjRwG4brHMnj3bXX7evHn47rvvsGDBAuzbtw8rVqzAK6+8goceekibFkQxlQ2tXD4T65BnPpBnfqj1Rp5Dg/q0dsSp/cC2bdtwySWXuP9/wYIFAIA5c+Zg5cqVcDgc7sAEAPLy8vDRRx/hgQcewHPPPYeBAwfiL3/5i+I1RmKZAWlWLp+JdcgzH8gzP9R6I8+hQX1aO1QHIxdffDECLU2ycuXKXtsuuugi7NgR+B1sojdFeZnIsVlRUdcKJXcZc2xWFOVl6l6vaIM884E880N27agLfhVOnkNHTZ82Acgm136h3DQCYzGbcN25OYoGbgC47twcWMy+31Ai/EOe+WAxm1A8I588c0Du00ogz6GjZuxgAIpn5JNrP1AwIjCldgdeDLB6Yk9e3FCOUrtDxxpFJ+RZTMhz6Kjp0+Q5dNSOHYR/KBgRFKfEULKmTPFVpAyt8qcO8swP2bUayLN6QunT5Fk9aj2bQJ4DQcGIoGwtr1F0v9cTBlrlTy3kmR9qXZPn0CDPfCDP2kLBiKCE8/oXvTqmHPLMj1B9kWd1kGc+kGdtoWBEUMJ5/YteHVMOeeZHqL7IszrIMx/Is7ZQMCIo8itjap67NoFe01MLeeaHWtfkOTTIMx/Is7ZQMCIo8muQSpF/EPTqmDrIMz/UuCbPoUOe+UCetYWCEYGZXpCD524di9RE77Xp+iTHo0+yd16fjJR4PHfr+ZheoGxtAaIb2bMtydspedYe2XVPeo7P5Dk8ZM89T3zkWVtkzwlx3qfSnp77JMeR5yBQMCIwpXYHfvNhGRrbOt3bMlPi8bsbCvC7G85GvKW7x9c0deA3H+6j9QJCQPZc19Kd8MrTszW++2dCnsOj1O5Ayf/b67UtMyUeP5k0DCmJFvc28hwecp/2fI1U9pye1H1xQ57DQ/bc3im5t8meMzwuZE43d5LnIJhYoLXdBaG+vh42mw11dXVIT083ujpcKLU7cM8bO3q9w24C/L7XLocmy2eOpQhcIeSZH/5c+4M8hwZ55gN5VobS8zfNjAhIoMV0AnV8+W+0sI4yyDM/QlmIizyrhzzzgTxrDwUjAhLKQlwytLCOcsgzP0J1TZ7VQZ75QJ61h4IRAdFiURxaWCc45Jkf4Xoiz8ogz3wgz9pDwYiAaLEoDi2sExzyzI9wPZFnZZBnPpBn7aFgREBCWYhLhhbWUQ555keorsmzOsgzH8iz9lAwIiCBFtMJ1PlpYR11eHruacvk5789/588K0ft4nIAeQ4F8swH8qw9FIwIyvSCHCyfORYD0hK9tmfbrHh+5lg8P3MsstN7/y3WXhsLF9lzts172tTLs4+/kWf1yK57LhCVY7Pi7ql5yCHPmiB7TkmweG0nz9oie+65WCJ5Dg1aZ0Rwyk7U4eq//BepiXF4afY4FOVluqNqp8SQ/+tStHVK+NNN5+G68wZSxB0inU4Jox4vhZMxPHfrWEwvyPbyfOXSDfi2shEPXjES8y85kzyHwbV/3Qj78Xr8dGoeLhmV5e7TTonhrte24fP9lfhR4WA8feM55DkMHnpnN/61/Xtce04Obhs/1Mvzbz8sw6ubjqBoWCbe+ukE8hwGL6w/hMUf70fh0Aw8NG2Ul+c3vvwOxR/sxYC0RGxZeFlMeqZ1RqKE+lbX6qtZ6YmYOLyvV2e2mE3o3zVzMqRvckx2dK1o7nDC2RWXXzZ6QC/PQzKTAQAD0hPJc5icbnKtdDu9IMerT1vMJozKTgMApCTGkecwOd3UDgCYfGa/Xp7HDskAAJhMIM9hcrrZ1Z/PHdynl+cLR/QDALR0OMlzECgYERinxLD1sOt9dDnS7ok8RfjJXge2HKqmxXRCpKbRNXDHW0zYebS2l0c5R83Gg1XkOQycEkN1UxsA4Luq5t6eu/rznuN15DkMnBLD0ZpmAMCp+rZeHtOtriXhj9Y0k+cwcEoMB042AAAaWjt6eUzryivW0NqJ/x6sIs8BoNs0glJqd6BkTZnXwjo5NiuKZ+S77zmW2h24961daHdKfssQwSm1O/DYajuqu64kAW+PpXYHHnx7N5ranT7/Tiij1O7Aog/2oqK+zb2tp+dH3v0adS2dPv9OKCPY2FFqd+Dx9+2oavTd3wllKPEcqL/HCkrP3xSMCEigfCmAK7cBgKBlYqnDh0ow1z+dmocXN5ST5zAhz3wgz3wgz8qhYCRCcUoMFz7zud+lhk1wPT8CmFBR779Mts2K/z5yKd2nDEAw14ArFbi/mVXyrAzyzAfyzAfyrA56gDVCCZbzgAGoqG/zG4jIZSj/QXCU5JcIdIuXPCuDPPOBPPOBPOsDBSOCoWXOAsp/EBit/JDnwJBnPpBnPpBnfaBgRDC0zFlA+Q8Co5Uf8hwY8swH8swH8qwPFIwIRrCcByYA2emJyE4PXIbyHwRHSX4Js8n/EvzkWRnkmQ/kmQ/kWR8oGBEMJflSFl03BouuC5y7hvIfBCdYDiATgLum5Pn9O0CelaDGM+UBCh3yzAfyrA8UjAhIoHwp8ithcpl+qQl+yxDBcedLsXgPDLLHhVfnu74LygMUFv7ypfTyTPk8wqI7X0qc13byrC2y574pvsdf8qweerVXYNo7JYx8/GMAwAszC3F5flavaPpIVRMufnYd4i0mvPaT8V65awjlTF+6AfsrGnDPxcMxdUT/Xh6dEsOY4lK0dlAeoHD45b924+1t3+Pqs7Mxa8Iwn56v/vNGfHOyAQ9cPhI/v5TyAIWCv3wpMk6J4Z43tuPTspP44fmD8IcfnUueQ2DdN5W4/dWvMLCPFX/80Xk+PT/98X68tPEwzs/tg3/dMynmPNOrvVFAi8eKn5ecNcBnJ87oisw7nAznD+kTcx1dKxq6cgBNH5PdKwcQ4JqazUh2uT6jfwp5DpHGNpfnomGZfj0PykgC4LqvTp5DQ+7PYwam+/U8IisVAJCeFE+eQ0T2nJuR7Nfzubk2AEC8xUyeA0DBiMA0tLkSMCXGmXulXZdJS4yD3L/rWjp4VS3qqO9yl2aN81tGzgNU30qeQ0UevNN7pF33RM6bQp5DR3bXM729J+nWrv5M40bI1Ha5k3NX+SKty3NDW6ffMgQFI0IjX0UGOkGazabuzk6Dd0g4JeYeKAKfJF1/o6AvdOQs1HKf9YX8HdBJMnTkPpquxHMrnSRDRR5zA/Xn1K5keY1t1J8DQcGIwMhXkXJn9keqR2ZIQj2NHlcsgQI/efCmYCR0ugfvAJ6tdJIMF7mPBpoZSaMZqLBpbA1+wSjP9NH4HBgKRgTFKTF81bVcsMlk8pt62ikxmLvu02wtr6EU1SFQ2+zKXhpvMWHHd7V+HaZ3vaGw5VA1pV0PAafEUNOVKba8qsmvv9SuwXvviTryHAJOieH46RYAQEVdq3/PXRcxx083k+cQcEoM31Y2AgDqmjv8+kvqeoOsvqUDm7+tIs9+oLdpBCRYamq15Qj/KE2nXmp3YMHbu9Hs8VAxuVaOmj79yLtfo66lM2A5wjdqPD+22o7qpsD9nvCNGs/FH+zFyfq2gOWiGcraG6EES00tv6OutBzhH3LNB/LMB/LMB/KsDnq1NwJxSgwla8p6dV4A7m0la8rQ3ikpKkfTgf4h13wgz3wgz3wgz/pBwYhABEtNLaeefn3LEUXlKEW1f8g1H8gzH8gzH8izflAwIhBKU0p/V9Os6f5iEXLNB/LMB/LMB/KsHxSMCITSlNJDM5M13V8sQq75QJ75QJ75QJ71g4IRgQiWmlpOPT1r4jBF5ShFtX/INR/IMx/IMx/Is35QMCIQnqmpA6WeTogzKypHeRD8EywNONDbdaBy5No35JkPoXimsUM95Fk/KBgRDDk1dbDU00rLEf6RHVrjvX8G/lz3T/OdLpxcB0b2l271nda+p+cc6tMhIfvL6JEnhcYObZH9ZaUlem0nz+FB64wIilNimPz056iob0XxtfmYPWmYzyjaKTG8vPEwFn+8H7mZyVj30MUUbavkzr9/hc/2VeLmcYNxw/mDe6UBlznV0IYLnvoMAPDm3PGY4CNLJ+GfpWsPYOl/DmLS8L74xaUj/Hp2SgwXPPUZapra8dQNBbilaAh5VsH7O4/j/lW7cOaAVPzm+oKAnm96YQu2f3cad07Jw8KrRpNnFRypasLFz65DgsWMv/+kKKDne9/aiQ/3OHDtOTn48y3nx5RnWmckwrGYTejsegc90EnPYja57ztKEoupTq4V8qqqk87s5zMNuIy8HDwAFAy2kWuVyDmAzh5kC+jZYjYhM8U1C3VG/1TyrJKmdpfnvH4pQT3nZiQBALLTreRZJfK4YUuOD+p5ZFYaAFdCPfLsGwpGBEZOKhYsUZ6cpKmRUlSHRFPXoJKSENhzYpwFCRbXT4Zcq6dBQVIxme5Mp+RZLUqSt8mkUJLNkHFnVQ8yPgM0RiuBghFBae+U0NYpAQicBhwAUhNdf29s60QE3HUTjqauASI50RK0rJzErYkGFdU0tAVPty5DaddDR81JUvZM/Vk9ct9MVRJcuzP3Un/2BwUjguIZQacEOUnKHd0pMbR2SLrWKxpp7nIdbGYE6B686UpSPaHNjDiDlCR60u1ZedAn39ohlCN7DjZzDcD98HYjjRt+oWBEUOROmxRvQZwl8NeUHG+Bqes2ZANdSarGfZtGycwI3T4ImXo1J0kavEPGfZJUcZuGgj71yGOAkmDEc/aa8A0FI4JS1+IKKuItJmw5VB0woRIDYI1znUj/e6CKki+pwCkx9wCx39EQ1J0csHyxvzLo90J045QYTtW7lr4+WtMc1FtygsvzzqOnybMKnBLDd9VNAFxvfyn1fKiykTyrwCkx7D1eDwBo6XAq9nyyvpU8+4Fe7RWQUrsDv1ptR01Tu3tbjs2K4hn5vd5NL7U7ULKmzCspk7+yhDeldgcWfbAXFfVt7m2B3JXaHbjvn7vcz/IEK0+4UNtHS+0OPPTObq+rdfIcnFA8P/reHtQ2dygqT7gIxfMT79txqjH4eB6NKD1/UzAiGKV2B+55Y0ev1NPyy2Cei+WoKUt4o9YduQ4N8swH8swH8qweWmckAnFKDCVrynp1XADubSVryuCUmKqyhDdq3ZHr0CDPfCDPfCDP+kLBiEBsLa/xmvrrCQPgqGvF1vIaVWUJb9S6I9ehQZ75QJ75QJ71JaRgZNmyZcjLy4PVakVhYSE2btwYsPybb76Jc889F8nJycjJycEdd9yB6urqkCoczVQ2+O+4PcupKUt4o9YduQ4N8swH8swH8qwvqoORVatW4f7778djjz2GnTt3YsqUKbjqqqtw9OhRn+X/+9//Yvbs2Zg7dy727t2Ld955B1999RXuvPPOsCsfbQxIswYv1FVOTVnCG7XuyHVokGc+kGc+kGd9UR2MLFmyBHPnzsWdd96J0aNHY+nSpcjNzcXy5ct9lv/yyy8xbNgw3HvvvcjLy8OFF16Iu+++G9u2bQu78tFGUV4mcmzWXimnZUxwPYVdlJepqizhjVp35Do0yDMfyDMfyLO+qApG2tvbsX37dkybNs1r+7Rp07B582afn5k0aRK+//57fPTRR2CM4eTJk/jXv/6Fa665JvRaRykWswnFM/J9/k3u0MUz8mExm7zK9uzsPcsS3qjxHEp5wgV55kM4nmnsUI5ab+RZHaqCkaqqKjidTmRlZXltz8rKQkVFhc/PTJo0CW+++SZuvvlmJCQkIDs7G3369MFf//pXv8dpa2tDfX29179YYXpBDpbPHIvEOO+vJttm7fUamFw222YNWpbwRnaX3mOVSn/u5PKZyfGKyhMuZG8ZCr3J5QekJSoqT7hQ643GjtBQ6408K0fVOiMnTpzAoEGDsHnzZkycONG9/amnnsLrr7+O/fv39/pMWVkZLr/8cjzwwAO48sor4XA48PDDD+OCCy7AK6+84vM4ixYtQklJSa/tsbDOiMzNL2zB/8prMGfSUEwfk4OivEy/EbRTYnj64/14aeNhjB3SB+/Mm0TRtkKeX38IT3+8H+OGZuDBaaMCegaAbUdq8H/Pb0HflAT87daxQcsTLt7d/j0efGc3RmalouS6gqDeGlo7cPaiTwEAr95+AaaO7E+eFXCgogHTlm5AcoIFr8y5IKhnp8QwcfF/UNnQhpLrxmDmhKHkWQHtnRJGPv4xAOCFmYW4PD8rqOdZr/wPmw9VY9aEoVh03ZiY8azLOiP9+vWDxWLpNQtSWVnZa7ZEZvHixZg8eTIefvhhnHPOObjyyiuxbNkyrFixAg6Hw+dnFi5ciLq6Ove/Y8eOqalmVCAvUX7xqAGYOLxvwI5rMZtwbq4NABBnMcdMJ9eClq68NGflpAX1DAC2JNcVvsSYovKEi5YOl+dhfVMUeUtNjINcZMzAdPKskNZOl+eM5ARFni1mE/qmumZThvVLIc8KkfszAFx8VvBA2WI2YVi/FABA39QE8uwDVcFIQkICCgsLsXbtWq/ta9euxaRJk3x+prm5GWaz92EsFtc6/f4mZRITE5Genu71L9ZolpO3KcgkC3gkcKPEYqpobleesRfwSODW1um3/xK9cXtWkFQMAEwmU3eGZEouppimriX05VwoSkiTM/eSZ8XIF4sJcWYkxilzLfdn+QKI8Eb12zQLFizAyy+/jBUrVmDfvn144IEHcPToUcybNw+Aa1Zj9uzZ7vIzZszAe++9h+XLl+Pw4cPYtGkT7r33XhQVFWHgwIHatSTKkAcGpYNKmpWyyYaCnLE3WWXQ1+FkXjlqiMCEcpJMpZOkauSgL1lh0Ad0J3+kCxnlyK7SVHiW+z6N0b5RbrKLm2++GdXV1XjyySfhcDhQUFCAjz76CEOHDgUAOBwOrzVHbr/9djQ0NOBvf/sbHnzwQfTp0weXXnopnnnmGe1aEYW4Z0YUdnY5LXtDa0eQkoQn8olOHpCD4TmD0tTWCWu88pNrLKN2ZgTomoWqo5OkGprcM6rK+6X8ndBJUjmNba5xVk1/lseOZpoZ8YnqYAQA5s+fj/nz5/v828qVK3tt+8UvfoFf/OIXoRwqJmGMedw+UHiSlK8iqaOrovuKXdlPwWw2ISXBgqZ2JxrbOt3324nAdM9A0UlST5rdM6oqgj6agVKNnFFaVTBCngNCuWkEpK1Tgpw7Sel0qxy0tHdK6HDS7QOldF+xq7h90HVLrIGu2BUjnySVPpsDeDwHRYO3YtwzI2r6M3lWTXd/VhNcu8rSzIhvKBgREM/IOUnhbQDPKyHq7MppUvmgMECDdyi4Z0ZCOEnSlaRyQpkZoRko9XT3ZzXPjJDnQFAwIiDyFXeCxYyt5TWKUkxbzCZYTK7XxTYeOEVpqRXglBiqGtoAAEeqmxQ58yyz7chp8qwAp8TgqG0BAJyobVXsTD5J/q+8BlsOVZPrIDglhoOVjQCAupYOxb7kW2f7KxrIswKcEsPeE3UAgNYOp2Jf1njX6baivpU8+0DVomdGoXTRlGig1O7A4+/bUdXY7t6WY7OieEa+39X6Su0OlKwp80pXHewzsU4ozsizekJ1Vmp3YMHbu71m+ci1f8Lx/Mi7X6OupVPV52KVcDw/ttqO6ibl43q0oPT8TcGIQJTaHbjnjR3o+YXIy+P4Wj44lM/EOuSZD6E6I9fqIM98IM+hocsKrIR+OCWGkjVlvTosAPe2kjVlXlN7oXwm1iHPfAjVGblWB3nmA3nWHwpGBGFreY3X1F9PGABHXSu2lteE9ZlYhzzzIVRn5Fod5JkP5Fl/KBgRhMoG/x3WX7lQPhPrkGc+hOqMXKuDPPOBPOsPBSOCMCDNGrxQj3KhfCbWIc98CNUZuVYHeeYDedYfCkYEoSgvEzk2K/zlcjTB9fR1UV5mWJ+JdcgzH0J1Rq7VQZ75QJ71h4IRQbCYTSieke/zb3JHLp6R75V62vMzPTu7v8/EOuSZD6F4DudzsUqofZM8q0MLzzR2BIaCEYGYXpCD5TPH9lpiONtm9fv6l/yZbJtV8WdiHdlZZkq813byrC2ys/6pCV7bgzmTP9dP5edilVD7pvtz6YmqPherhO2Zxo6A0DojArLwva/x1tZjuKogG7MnDkNRXmbQyNkpMTz0zm6s3nkc0/KzsHxmIUXbQSi1V2DeG9sxrG8yFv/wHMWe//b5t/jTZwcwKisNH903hTwHYdexWtzw3Cb0SYrH8pmFijwDwJGqJlz87DokxJnx9zuKFH8uVunolDDi8Y8BAC/MLMTl+VmKfDklhoLiT9DS4cSSH52L688fRJ4D4JQYxv/uM1Q1tuO3NxTgx0VDFHuevnQDDlY24sErRmL+JWfGhGdaZySCaeladbJwaAYmDu+rqMNazCaMzEoDAKQnxcdEJw+X1g6X58EZyao8nz+kj/u/yXNwZM99UxMUewa6ExK2d0oYT4FIUNo9EmReNKq/Yl8WswnpSS7XI7PTyHMQLGYTOrvWBVHTLy1mE7LSXbMjuZnJ5LkHFIwIiJyEKUlFRkjAMyskJWJSQqM7qRh51pPuzMjKk4oB3skLWzoo+WMwmro8m01AYpy6oZ3S26ujuU19ojyge6xporGjFxSMCIh78FaReRPozgrZ1EYDtxJCPUm6PVN2ZEXI/VFt0GeNN6Mr9yMN3gqQT5ApCXEwmdRddctjDWX8Dk6HU3LPQvV8vi8Y8ljTTGN0LygYERB5QFB9xZ5AV+xqCPUkKZdvpqtIRYQaXJtMJvdnWugkGRQ5YEtOVNefAbpiV4NnwJassk/Ls6qNNHb0goIRAXFf4ai9Yk+kmRE1yCfJ1BBnRpo7nJAop0RQmkKc0gY8TpLUp4MinyTVBn0AXbGrQR434i0mJKi9HeaegaJgpCcUjAiI+wqHZkZ0pck9AxXa1Q1jQGsnDd7B6J4ZCf2Knfp0cOTnPWhmRF+6Z1RDCa7pFq8/KBgREPcVDj3LoCvy4J2icvC2xlnczzLQPfbghBr0eX6G+nRwmsPwTM+MKCec4Foea+hB4d5QMCIgTeG+5UEdXRGhXuGYzSYkx8uuafAORnOIQZ/nZ6hPB8cdXIcyA0UnScXI44batx0Bz7eWaNzoCQUjgtHplNDWKT+pTc8y6En32zShDN7yFTsN3sHQYmaErtiD454ZCeHZnBT3m3jUn4PR0hHaW3gA3XYMBAUjguH5lPWe43VwqggqrPGur5MxYP2BU6o+G2s4JYaT9a603cdqWlS5ckoMlq77NFvLa8hzAJwSw7GaZgBAZX2ralfy4L3lcDW2HKom135wSgz7HPUAgKbWTtWe5Kv8fRUN5DkATolh19FaAECnk6n33DWjevx0C3nuAS0HLxCldgd+/e+9qGxoc2/LsVlRPCM/aP6CUrsDiz7Yi4p69Z+NNUrtDpSsKYOjrtW9TY3nUD8ba4TrqtTuwAOrdqGlo3tlUXLdGy08//JfX6O+tftCiDz3RgvPv1q9BzVNHSF9PlJRev6mYEQQSu0O3PPGDvT8MuSliwIlVArns7EGeeZDuK7ItTLIMx/Ic+hQbpoIwikxlKwp69VRAbi3lawp8zmlF85nYw3yzIdwXZFrZZBnPpBnPlAwIgBby2u8pv56wgA46lqxtbxG08/GGuSZD+G6ItfKIM98IM98oGBEACob/HfUYOXC+WysQZ75EK4rcq0M8swH8swHCkYEYECaNeRy4Xw21iDPfAjXFblWBnnmA3nmAwUjAlCUl4kcmxX+8mya4HrquigvU9PPxhrkmQ/huiLXyiDPfCDPfKBgRAAsZhOKZ+T7/JvcgYtn5MNi7t2dPT/b86/BPhtrkGc+hONZi8/HCuH2SfKsDC0909jhHwpGBGF6QQ6WzxyLtB6r+mXbrEFf+5I/m23znuZT8tlYQ3bVNyXBazt51hbZ1YC0RK/tSl3Jn89MiQ/p87FCuH1S/nxWemjfU6yglWcaO/xD64wIxjOl+7F83SFMHdkP91x0JoryMhVHzE6J4Z43tuPTspP4wfmD8OyPzo35aNsfGw6cwuwVW5Fts+JPN52n2vPTH+/HSxsPo3BoBt6+eyJ59sPhU4249I/rkRhnxso7ilR5BoCdR0/jB8s2IyM5HstuK1T9+VjBKTEUFH+Clg4nltx0Lq4/b5AqTx2dEkY+/jEYgOW3jcW0Mdnk2QdOieGyP67DkepmPDL9LPx06hmqPDklhoufXYdjNc341dWjMffCvKj3TOuMRCgtXfklzh5kw8ThfVV1VIvZhDP6pwIAMpITor6Th0Nrh8tzjs0akueCQa4fVWKcmTwHoLVr9dT0pHjVngEg1WOmMJTPxwpmE9DW6erTF57ZT7Wn+Dize+n90Tnp5NkPFrMJpq5UEOOGZaj2ZDGb0D/VNSs7JDOZPHtAwYhgyAmUQkkqBnRn7JSTORG+kZOKqU1GKJNCqe0VEU66dcAzISF5DkRbpwR5zaxQEuUBHhllKYlbQOQ+LeeZUYvsmcZobygYEYwm90kyzMGbUlQHpMkd9IXqmVLbK0Huz0lhBtftnRI6nFKQ0rGLZ7bd5DBPkpQhOTDNXWNrKFl7ge4xh8ZobygYEQz55Bby1Q2lqFaEPHiHOqCkUGp7Rcj9OeTg2iOIIdf+kd0kJ1hgDnHqv/skSWOHPxhj7guZUPt099hBnj2hYEQwmsK8fUAzI8qQ/YQ6M5KSSEGfEuT+HGpwnRBnRrzFdXIl1/5pCvP2LkABthK0uB0mz6rSGO0NBSOC4X5mJDHUqJtOkkqQ/aSGPNVKzzIoIdxnRoDue/N0kvRPk/vWQeieu0+SNHb4w9NNqM+MJNPMiE8oGBEM9/3IUGdG6CSpCPcVe5gPsNKzDIHpnoEK44pdfpaBriT9Eu6D7wDNjChBdpMUbwn5TRj37TDy7AUFI4Lhee83FFLowUpFuJ9lCPFKMsnj+6HB2z/umZFwrtjdgzf1aX+4Z0bCmIEiz8EJd3wGPII+GqO9oGBEMNwPR9HtA11pDPOKPSHOjASL6+dD063+0XRmhDz7pfv2Ls1A6UlTmLfRPT9LFzHeUDAiEJ1OyX1PsuxEPZyS+sVxrfGur7SxrRNbDlWHtI9oxykxOOpaAAAnaltCcuSUGOLjXNO0m74lz75wSgzlVU0AgOrGtpAdyffm1x84RX3aB06JwX68DoBrMb9wPe85Xkue/dDY6hqfO50sZEey5yPVTeTZA1oOXhBK7Q4s+mAvKurb3NtybFYUz8hXnLeg1O5A8Qd7cTKMfUQ7pXYHStaUwVHX6t4Wiudw9xHtaOWo1O7Aff/chbbO7udyyHU3Wnp++J2v0eBx64A8e1Nqd2Dhe3twurnDvS2UsSPcfUQaSs/fFIwIQKndgXve2IGeX4T8eJSSREpa7CPaIc980MoRuQ4MeeYHjR2hQ7lpIgSnxFCypqxXBwXg3laypizgVJ4W+4h2yDMftHJErgNDnvlBYwcfKBgxmK3lNV5TrD1hABx1rdhaXqPrPqId8swHrRyR68CQZ37Q2MEHCkYMprLBfwdVWk6LfUQ75JkPWjki14Ehz/ygsYMPFIwYzIA0a9jltNhHtEOe+aCVI3IdGPLMDxo7+EDBiMEU5WUix2aFv7X8THA9bV2Ul6nrPqId8swHrRyR68CQZ37Q2MEHCkYMxmI2oXhGvs+/yR23eEZ+wKWHPffRs5TSfUQ75JkPWjnS4vuKZsgzP7QeO0LdR7RDwYgATC/IwfKZY5Fu9V49MdtmVfy6l7yPbJv3NJ+afUQ7sqN+qQle28mztsiOstITvbardSTvp09yfFj7iVa06ovyfgakhfd9RTOyo8Q471NmKGNHDo0dPqF1RgTihfWHsPjj/Rg3NAMPThuForxM1ZGyU2KYvWIrNn1bhZnjh6Lk+jExHW37Yvt3p3Hj8s3ITI7Hc7cVhuz58dV78NZXx3DRyP5YcfsF5LkH1Y1tKPztZwCA1+cWYdLwfiE5+s++k5j7920YnJGEP/zfuSF9X9GMU2IY/7vPUNXYjt/eUIAfFw0JyU9dSwfOLfkUAPD3O4pw4YjQvq9o5raXv8Smb6sxa8IQXH32wJDHjgue+gw1Te146oYC3BLi9xUp0DojEUhLhytXwajsNEwc3jekDmoxmzC0bzIAoH9aYlR38lBp7fLcLy0xLM+jB7p+WKmJceTZB61dq6YmxJkxZUT/kB2lWV0zIwkWc8jfVzRjMZvQ2bU+xYQzQveT6pHXpmBQOnn2QUtXPpkpI/qHNXbIs33DB6SS5y4oGBEIOXFSqEnyZJLj5URMlFjMF3L+n3CSt3l+nrKc+sadGTmMDKcAZZNVgpzcLpzsyBazyZ03pYmS5fmkO2tveGOHO3Mv9Wk3FIwIRPdJMszBO5FOkoGQB5TUMIM++SRLWU5906TRwC3/HijLqW/aOyW0O12zUGGfJGnsCIgWWXsBjwCbxg43FIwIhHtmJOyomzp6INwDCgV9uuKeGQlz4Hantm93IgIeceNOi0eQFm6fTkmkWdVAuGegNAr6WijAdhNSMLJs2TLk5eXBarWisLAQGzduDFi+ra0Njz32GIYOHYrExEQMHz4cK1asCKnC0UyzVlF3Ik0BBqLJfZLUaGaEBhSfaD0z4pSYV/ZewoUcDCfEmRFvCe/60n3rkS5kfKLZhQzdeuyF6lFi1apVuP/++7Fs2TJMnjwZL7zwAq666iqUlZVhyJAhPj9z00034eTJk3jllVdw5plnorKyEp2d9CX0ROuZETpJ+kYeaMMfUOSBm/qyL+RgONyZEc9gprndCWt8ePuLNtyew+zPnvugC5neOCWG1g5XMBz+hUz3bB/hQrXRJUuWYO7cubjzzjsBAEuXLsUnn3yC5cuXY/Hixb3Kl5aWYv369Th8+DAyM12ryw0bNiy8Wkcpmj0zQh09IN0nyXCnWinoC0R30BeeZ4vZhMQ4M9o6JTS1dSIzJSH4h2IIrTwDHrceaWakF/LbjoAWt3jlW+kU9MmomtNrb2/H9u3bMW3aNK/t06ZNw+bNm31+5oMPPsC4cePw+9//HoMGDcLIkSPx0EMPoaWlxe9x2traUF9f7/UvFtDsSW3q6AFp0mgGKsljqpWeZeiNplfs8j32DjpJ9qRJoxkogGZGAiE/AyUHx+FAMyO9UTUaV1VVwel0Iisry2t7VlYWKioqfH7m8OHD+O9//wur1YrVq1ejqqoK8+fPR01Njd/nRhYvXoySkhI1VYsKtHtSmzp6IDR7sLLLM2NAa4fkDk4IF+4r9jBnoADXlWhNEwXYvmjWcmbE/bo6jR09cT8DFW+ByRTe2iA0M9KbkMK7nl8EY8zvlyNJEkwmE958800UFRXh6quvxpIlS7By5Uq/syMLFy5EXV2d+9+xY8dCqWZE4ZQY6po7AADfnmyEUwr9Sjsp3vW11jS1Y8uh6rD2FW04JYbvT7v6XUVda1huEjweFtxw4BR59sApMRysbAAA1DV3hOXGKTF3/o5tR06TZw+cEsOuY7UAgE6nFLYb+fbDzqOnaezoQUOra3w2m01hu5HXczlY2Uieu1C1HHx7ezuSk5Pxzjvv4Ac/+IF7+3333Yddu3Zh/fr1vT4zZ84cbNq0Cd9++6172759+5Cfn48DBw5gxIgRQY8b7cvBl9odKFlTBkddq3tbjs2K4hn5qvMVlNodeOLfdpxqaA97X9GG1p612le0QZ75oLWbUrsDD76z2+t5EXLtotTuwGOr7ahuCn9cLbU78Mi7X6OupXtWJJo967IcfEJCAgoLC7F27Vqv7WvXrsWkSZN8fmby5Mk4ceIEGhsb3dsOHDgAs9mMwYMHqzl8VFJqd+CeN3Z4DSiA66r9njd2oNTuUL0vz0Ak1H1FG3p41mJf0QZ55oPWbuT99XxwlVx3u/EMRIDw+rRnIBLqvqIN1bdpFixYgJdffhkrVqzAvn378MADD+Do0aOYN28eANctltmzZ7vL33rrrejbty/uuOMOlJWVYcOGDXj44Yfxk5/8BElJSdq1JAJxSgwla8rga2pK3laypkzRFJ6W+4o2yDMfyDMftHZDrv1DfZofqoORm2++GUuXLsWTTz6J8847Dxs2bMBHH32EoUOHAgAcDgeOHj3qLp+amoq1a9eitrYW48aNw2233YYZM2bgL3/5i3atiFC2ltf0urLxhAFw1LVia3kN131FG+SZD+SZD1q7Idf+oT7Nj5Aev54/fz7mz5/v828rV67ste2ss87qdWuHACob/HdMteW03Fe0QZ75QJ75oLUbcu0f6tP8oNw0BjIgzapZOS33FW2QZz6QZz5o7YZc+4f6ND8oGDGQorxM5Nis8PfGugmup6yL8jK57ivaIM98IM980NoNufYP9Wl+UDBiIBazCcUz8n3+Te6wxTPyYTEHX2DHc189S6vdV7RBnvmgpRvy7B+t3Wj5+4g29Bo7wt1XNELBiMFML8jB8plj0Sc53mt7ts2K5TPHqnrvXN5Xts17mi+UfUUbspsBaYle28mztmjphjz7R2s38v76p3rn/SHX3W6SeiRoDKtPp4c/DkUbqhY9M4poX/QMAFZ9dRSPvLsH+TnpeOLafBTlZYYcITslhh8u24Td39dh3kXD8fCVo2I22u7Jfkc9pv95I1ISLHh5zgVhe77/nzux5msHrj47B3/98fnkuYv2TgkjH/8YAPDCrEJcPjorLM9//PQbLFt3CGcPsuH9n00mz104JYaLn12HYzXN+NXVozH3wryw3Bw/3YLJz3wOswl4Y+54jD+jL7nu4uf/2IH/97UDPxw7CD8qzA177Mj/dSnaOiX8+ebzcO25A6PWsy6LnhH6IaemzuufgonDwxsALGYTBmW41nAZ2McatZ08FFo7XZ77JCdo4nlEVhoAwJYUT549aOvsXjzropH9w/Z8bm4fAEC8xUSePXC5cF1PjhuWEbabtCTXC5YSAwo12F800dKVm2ZCXl9Nxo40q8v1qJw08gwKRoShScMMp4BHwitKBe5Fk0ZJ8mTkXB4tlOXUCzlJoxYZTgHKchoIOVFeuFmoAVcSuJ77JVzIY7RWCTFpjPaGghFB0DLzJkCpwP0hByOaeU6kLKe+6PYcfoZTwCPLKfXnXrizfWtwkoyzmGHtSrRJrr2RA2GtL2RojHZBwYgguGdGNOroSRR1+0QeUFI1SGsP0IDiD/fArVlw3TUzQv3ZC6fE3Ld4UzTq0yk0dvhEtwsZ8gyAghFhoJkRPmh5FQnQwO0P98Ct8VUkXa174/n71uyKnWahfKJ1gE0XMt5QMCIIWp8kkxPpHrsv3PfXtZoZSaQBxReaz4x0fV+tHVLMJhLzhew5zmxCgkWb4ZxmoXwju9YqwHZfyNAYDYCCEWHQflqbTpK+aGyjmREeaB5ce+yH+nQ3Wj+bI+8LoJmRnjS7XzLQ+EKmjTwDFIwIg+bT2nQ/0ifuAUWr++s0M+ITrWegEuPM7tcfabavm+6HKrXx7Lkv6tPdtHdK6HC6ZuRoZkQfKBgRBJoZ4YP8w9fuip0GFF9oPTNiMpm6r9jpStJNk8YzfZ77oguZbjzH0eR4bZ/NoZkRFxSMCIBTYqhuagMAlFc1aXJP3Nr1g6mob8WWQ9V0nx0uz99VNwMAqhraNXEir6HR3ilh48FT5Bkuz/sdDQBcJ0stnDglhviuZyK+PFxDnrto6DqRtTslzX7n8pt4Xx2pobGji4ZWl+c4swlfHTmtjec41xhd5qgnz6Dl4A2n1O5AyZoyOOpa3dtybFYUz8gPOU9Bqd2Bx1bbUd3Urtk+Ix29PC/6YC8q6ts022eko5dnrfcZDZTaHXj03T2obelwb9PC9YK3d3vdCot116V2Bx5/346qRu3G01K7Aw//62t3kKPFPkVF6fmbghEDKbU7cM8bO9DzC5AfQwslcZIe+4x0yDMfyDM/yDUfyHP4UG4awXFKDCVrynp1SADubSVrylRN3emxz0iHPPOBPPODXPOBPPOFghGD2Fpe4zXt3BMGwFHXiq3lNYbuM9Ihz3wgz/wg13wgz3yhYMQgKhv8d8hQyum1z0iHPPOBPPODXPOBPPOFghGDGJBm1bScXvuMdMgzH8gzP8g1H8gzXygYMYiivEzk2Kzwt2aiCa6nq4vyMg3dZ6RDnvlAnvlBrvlAnvlCwYhBWMwmFM/I9/k3uaMWz8h3rzqpdp89PxXqPiMd8swHPZyQZ9/o3ae12mekQ575QsGIgUwvyMHymWORmRLvtT3bZg359S55n9k272m+cPYZ6chOstISvbaTZ23Rwwl59o3sRV50T0YL131TEjTbZ6QjO+mZEVkLz1qOR9EArTMiAJ/srcDdr2/H0L7JePqH56AoLzPsyNgpMUz703ocOtWEh6eNwryLh8dktO3JsZpmTPn9F4gzm/D63PGaeb7rtW34fH8lbhqXi8U/PDvmPTslhoLiT9DS4cSSm87F9ecN0sTzb/5fGVZuPoLxeZn4x10TYt4zAPzo+c346shp3DF5GKblZ2vSp7+paMCVSzcgOcGCV+ZcoMk+I50n3rfj9S+/w5VjsnD7pDxNnLS0OzH616UAgJdnj8MlZw2ISs+0zkgE0dK12mFuRjImDu+rSYe0mE3uh6By+yZHZSdXS2uHy3OaNU5Tz8P6pgAA+qYmkGcAZhPQ2ulyfeGZ/TTzPGagayBLSrCQ5y7klVIvHjVAsz6dZnUtB9/pZJrtM9KRPY8dkqGZk6QEC+Itrv2MGZQe854pGBEArZOKyaRQIiYvupPkaZfhFCDPPWntkCDPtybrkU2WEri56U6wqd3YISfrbHdKaO+UNNtvJCMnytOyPwMeiTapT1MwIgLy4JqqV0enjLIAujOc9rz/Gy7k2RvPDKdJGmU4BTyyyVImajfdWXu1GzuSPX4fLdSnAXhcyGjYnwHKru4JBSMC0CgPKJqfJOmK3RM9Bm7AY2aEBhQA3VfrSfHa3k5xz4zQCdKNe2ZEw7Ej3mJGQteDsRT4uWjW6UImSQ6waWaEghERkE9iKRqfJOmK3Rs9Bm6g2zOdJF3IJzDtPcsDN50gAYAx5nGLV+MAm67YvWhyjx1aX8jIYwd5pmBEABrb9OrorgGlhTo6AI+TpF4DN13dAOi+ytP+BElBnyeez+boFWA3Up8GoN+savetR/JMwYgANOv0ACvNjHjTrFPQJz/URlPaLnTrz4ndz4xEwIoEuiP3N5MJsMbRw+960qzTbJ87wCbPFIyIQJNOD7DSswze6PbWkntKm4I+oLs/az7T1zVwM+aaFYh15Kv1pHgLzBq/FkoXMt7Iz/Vpfis9kTzLUDBiME6J4URtCwDgeG0LnJJ2V3zWrie/y6uasOVQtab7jjScEsPBk40AgLqWDl08Vze2kWeJ4evvawEAHZ2Spi4SLN3D1foDp2LaMwA0tLpOkHFmk6b9zikxdDpdwd7uY7Ux77m9U3IHv2WOek19yG+b7fiuJubHDlqB1UBK7Q6UrCmDo647XXSOzYriGflhLwlcanfg0ff2oLa5Q/N9Rxp6e37ifTtONbZrvu9IQ2/Peu07Eim1O/DYajuqm7Ttd+TZm1K7A8Uf7MXJ+jb3Ni379INv7/aaFYlG10rP3xSMGESp3YF73tiBnvLlydZwchToue9IgzzzgTzzQy8f5Nkb6tPaQMvBC4xTYihZU9arIwJwbytZUxbSlJ2e+440yDMfyDM/9PJBnr2hPs0fCkYMYGt5jdc0aE8YAEddK7aW1wi170iDPPOBPPNDLx/k2Rvq0/yhYMQAKhv8d8RQyvHad6RBnvlAnvmhlw/y7A31af5QMGIAcjZdrcrx2nekQZ75QJ75oZcP8uwN9Wn+UDBiAEV5mcixWeFvZQATXE9VF+VlCrXvSIM884E880MvH+TZG+rT/KFgxAAsZhOKZ+T7/JvcQYtn5IeUZEzPfUcani56tlZLz1rvO9Igz/zQ6/dNnr2hMZo/FIwYxPSCHCyfORb9UhO8tmfbrGG/1iXvO8fmPc2nxb4jDdlFVnqi13YtPWeTZ11dkGdvZB9J8d7Dd7g+yLM3so80q/eqq1r2aT3G/0iF1hkxmK3lNbjphS3om5KAv906FkV5mZpFxE6J4fzfrEV9SweeufEc/F/h4JiLtmWa2zqRX/wJAOCVOeNw8agBmnr+wbJN+Pr7Osy/eDgenDYqZj07JYbJT3+OivpWFM/Ix+yJwzT1/MCqXfhg9wlcXZCNv946NmY9A8BPX9uGT8tO4keFg/HDsYM1GzucEsOK/5bjqY/2ITcjCeseviSmPf9p7QH8+T8HMfnMvvj5JSM0HaMPnWrEZX9cj8Q4M1beUaTpvkWB1hmJEFo7XKvvDUi3YuLwvpp2RIvZhD5J8QCAMwekRl0nV0NLR/cqh1oGIoDL86A+SQCAnD5JMe3ZYjahs2t9hPF52vfnEQNSAQC25PiY9gx09+lJZ/bVdOywmE0YNywDgOs101j3LOf2Khho03yMlmdd2p0SxkdhIKIGCkYMxp0NUuPkbTLJCZQsD+hO3pYUb9HlB59M2TfdyAnctE78CHgkFqPU9rolbwO6kxxS8sfuJHbJenj2TP7YGduuKRgxmEadMpzKpNDgDcBj4NbNs5zePrY9OyXmvmLXOt064JkhmYK+Jh37tHwR00TBtYdn7fuznCjPdZzYHjsoGDEY98yIDh0doEFFpqldvlrXyzPNjADeQYIuJ0kKrt006XghI1+xt3VK7gy+sYqens1mE81ed0HBiMHIHV2PKUCge1CJ9Y6u98yIO+iL8ZkRuT9bzCYkxmk/vNDMSDdNOt7i9fydNHfEep/We+ygW2IABSOGo+f9dQBI7XpAqiHGr9j1H1DoJAl4Psdggcmk37M5sR70AUCzjlfsCXFmxFtMXseJVfR+rk+eFY/1sYOCEYORr26Sderoqe5p7dju6HoHffRsjgv9PXcN3DHen9s7JbR33T7R+4q9KcZPknKArdfstdtzjI8dFIwYjN5X7O4HK2O8o3ffDqNnc/TEHVzT7TBd8exnul2xy7N9MT52yLdPdAuwaVYVAAUjhuKUGI7WNAMAKuvb4JS0X39OjrrLHPXYcqhal2OIjlNi2OeoB+AKSvRwID+b831tc8x6BoCGVteA2tEp6eIhMc41cDe2dZJnAPEWE746clpzD06JuW+zbS2PXc9OiaGupQMAcOBkgy4ekrqCkY0Hq2K6T9MKrAZRanegZE0ZHHXdaaJzbFYUz8jXbCngUrsDv/zX16hv7Y64tT6G6PDy/KvVdtQ0tet2jEig1O7Ao+/uQW3X4A1o66HU7kDxB3txsr5Nl/1HCqV2Bx5/346qRn36G4/fTCRQandg0Qd7UaFjfyu1O3D/P3ehtbP7jaVoc630/E3BiAGU2h24540d6CleftxPi9wEPI4hOuSZH3p7IM8uyDMfaOzQDloOXlCcEkPJmrJeHRCAe1vJmrKwpup4HEN0yDM/9PZAnl2QZz7Q2GEMIQUjy5YtQ15eHqxWKwoLC7Fx40ZFn9u0aRPi4uJw3nnnhXLYqGBreY3X9GdPGABHXSu2ltcIfQzRIc/80NsDeXZBnvlAY4cxqA5GVq1ahfvvvx+PPfYYdu7ciSlTpuCqq67C0aNHA36urq4Os2fPxmWXXRZyZaOBygb/HTCUckYdQ3TIMz/09kCeXZBnPtDYYQyqg5ElS5Zg7ty5uPPOOzF69GgsXboUubm5WL58ecDP3X333bj11lsxceLEkCsbDQxIs2pazqhjiA555ofeHsizC/LMBxo7jEFVMNLe3o7t27dj2rRpXtunTZuGzZs3+/3cq6++ikOHDqG4uFjRcdra2lBfX+/1L1ooystEjs0Kf2tTmuB6mrooL1PoY4gOeeaH3h7IswvyzAcaO4xBVTBSVVUFp9OJrKwsr+1ZWVmoqKjw+ZmDBw/i0UcfxZtvvom4OGWLxixevBg2m839Lzc3V001hcZiNqF4Rr7Pv8kds3hGflhp7nkcQ3Q8HfRspR6e9TpGJKB3fyPPLsgzH2iMNoaQHmDtmXOCMeYzD4XT6cStt96KkpISjBw5UvH+Fy5ciLq6Ove/Y8eOhVJNYZlekIPlM8diQFqi1/Zsm1Wz17nkY2Sn63cM0XE7sHlPderiWcdjRAKyhwSL9ziglQfy7EL20HMlYfKsLbIHW5L3BbQeY0dGcrxux4gkVK0z0t7ejuTkZLzzzjv4wQ9+4N5+3333YdeuXVi/fr1X+draWmRkZMBi6f7hSJIExhgsFgs+/fRTXHrppUGPG23rjMh8W9mAy5dsQGKcGSvvKEJRXqbmkbBTYhhTXIrWDglLbz4PM84dGFPRNgB0OiWMePxjMAYsu20srhyTrYvn6Us34GBlIxZcPhI/u/TMmPMMANf8ZSP2nqjH3VPPwMWjBmjep50Sw09f24b/7K/E/xUOxjM3nhOTnh96Zzf+tf17XHtODm4bP1QXz3/89BssW3cI5wy2YfX8yTHpecV/y/Hk/yvDebl98Mj0s3QZozd9W4XbXv4fstITsfTm83U5hpHoss5IQkICCgsLsXbtWq/ta9euxaRJk3qVT09Px549e7Br1y73v3nz5mHUqFHYtWsXxo8fr+bwUYec8yAzJQETh/fVpQNazCakW12R95kDUqOqkyulw8kgh9xTR/bXzXNOnyQAwKCMpJj0DHTnTLk8P0uXPm0xmzB8QCoAICM5PmY9t3SNHeOGZujm+ZzBfQAA8RZz7HrucHkemZWq2xhtS3KNzyaYdDtGJKA688+CBQswa9YsjBs3DhMnTsSLL76Io0ePYt68eQBct1iOHz+O1157DWazGQUFBV6fHzBgAKxWa6/tsUhjq74ZTmVSE+NQ2dAWs0ncGj3anRyvT1IxAEhN7M6bEqs06pyQEOj+vTTGcAK3Rp0TbLr2Tckfm3TO2At49ufY9QyEEIzcfPPNqK6uxpNPPgmHw4GCggJ89NFHGDp0KADA4XAEXXOEcNEgp1u36huMuNPbx2hWSHdm5AQLzDpeddCg0p15VM8AO4U8u/u0np7lE3BzDGdI7s6qrmNwbe3uz5LEdB2jRCaknjx//nzMnz/f599WrlwZ8LOLFi3CokWLQjls1MFzZgSI3StJHleRnvuP1ZOkJDH3iUtP12my59aOICWjl6Yuz8kcZkZiObW9fMGYZo0PUjJ0PMf/pvZOXY8lMpSbxkAa3R2d08xIjJ4keVxFeu4/Zj17nLR4zIw0xWhwDXj2af2u2FMSyDOPC8bEODPiu95Ci9ULGYCCEUNp5HaS7HqWoTU2O7p8ktR7ZiTWb9PIJy2zyTXA6oU8rd0Qo56B7tkKPZ9lkH8vLR3OmErY5gmPC0aTydQ9dsToGA1QMGIYTonhm4oGAEBDa6euP3Z5wNr+XQ22HKqOqYHFKTHsOlrr/m99PbuCvoMnG2POMwA0dN02SYwz48vDNbq1X/ZcWd8ak56dEkNdi8v1gYoG3dpv9Qgo139zKiY9V3Qls/u+pkW39jslhniLy3Us9mcZVeuMGEW0rTNSanegZE2ZV9bGHJsVxTPyNV/optTuwINv73bfY9bzWKLB2/Oj7+5BbUv3cwyx4hlwtf+x1XZUN7W7t+nR/lK7A4+/b0dVo77HEZVSuwOLPtiLivo29za9PPM4jqjwGjt4jlFGofT8TcEIZ0rtDtzzxg70lC4/P63lyns8jyUa5JkfvNpPnskzD8iztuiy6BkRHk6JoWRNWa/OB8C9rWRNmSbTdDyPJRrkmR+82k+eyTMPyLNxUDDCka3lNV7TcT1hABx1rdhaXhNRxxIN8swPXu0nz+SZB+TZOCgY4Uhlg//OF0o5UY4lGuSZH7zaT57JMw/Is3FQMMKRAWnW4IVUlBPlWKJBnvnBq/3kmTzzgDwbBwUjHCnKy0SOzQp/i/2a4HqSuigvM6KOJRrkmR+82k+eyTMPyLNxUDDCEYvZhOIZ+QDQqxPK/188I1+TrI2ex+qJ1scSDfLMD17t5/mdigh55gN5Ng4KRjgzvSAHy2eORVZ6otf2bJtV81e55GP1T0vQ/ViiIbc92+Y9zamn5xwOxxIRuf3WeO/hROv28/xORURuf1qPlYTJs7bI7c9I9s4RQ571hdYZMYhTDW244KnPAABvzB2PicP76hYFVze2ofC3fI4lGk6JYfzvPkNVYzt+c/0Y3Dp+qG5td0oMRU99huqmdvz2hgL8uGhIzHgGgDte3YovvjmFWy7IxfXnDUJRXqYu7XdKDD96fgt2HD2NO6fkYeFVo2PK89Mf78Pz6w/jopH9MO+iM3X1vODtXfj3rhOYPiYbz902NqY8r955HA+s2oURA1Lx5PUFunr+2+ff4k+fHcCorDR8dN+UqPJM64wITkvXiqhJ8RZcOKKfrp0vPak7wj97kC2qOnowLGYT2jslAMDE4fp6tphNyExxzUKd0S8lpjwD3Xk8po7sr2vAazGbMCQzCQCQlWaNWc/n5mbo7vmsbNfJIyUxLuY8y8kI8/ql6O65cGgGAMBkQsx5lqFgxCAa2lzLhqfqnLEXAOItZiR05ZlojLF04Iwx9+CdzsF1LCdxa2jlk4UaiG3PcjK1nrdr9ED+LuW8Q7GEO5Epz/5MifII3vAcUDyPE2tZIZvanZAXMUyzxgcurAGp7vT2seUZ6B5I9c5CDXRnlI1FzzwyycqkxfBJkucYHesZvwEKRgyDZ9QNxO4VjtzeOLOp1wOWehDLg4rsmkfQF6vBNQDUt/IbO9K7vkt5JjeW4DlGy+NzY1snIuAxTl2gYMQg3B2d18xI16BSH3PBSPdVpMmk/73YlBgNRnjfDotVz4DHFTuPoC+GZ0bqOQbX8nnAKTG0dki6H09EKBgxCJ5T2gCQnhSbgwrPq3XAY2Ykxjw3e9wO43KPPYaDEffzZlyeGemaGYmx/gx0/4Z5eE5OsEC+VorFWSiAghFDcEoMe0/UAwBaOpxcMjPKP6iNB6uw5VB1zGSDrG12/bAlxri0W/b89fd1MenZbAJ2Ha3Vvd0pCS7PR2uaY8qzU2I43eRyfaiyUfd2JydYAAB1LR3Y/G1VTHk+XtsCAKioa9W93RJzvVkJAP89EDuePaF1RjhTanegZE2ZV8bGHJsVxTPydVvkptTuwAOrdqOlw8ntmCJQanfg0Xf3oLal+0pDz3aX2h14+F9fe11Fxornx9+3o6qx3b1Nb8+/em8Papr5fK+iUGp3YNEHe1FR3+beprfn4g/24iSn44kC7zHaiHMCT5SevykY4Uip3YF73tiBnsLlJxn0WHXPiGOKAO92k2dvyLO2kGc+kGftoUXPBMMpMZSsKevV6QC4t5WsKdN0es6IY4oA73aT596QZ+0gz3wgz8ZCwQgntpbXeE3D9YQBcNS1Ymt5TUQfUwR4t5s8+4Y8awN55gN5NhYKRjhR2eC/04VSTtRjigDvdpNnbcqJdjxRIM98IM/GQsEIJwakWYMXUlFO1GOKAO92k2dtyol2PFEgz3wgz8ZCwQgnivIykWOzwt+yWya4nqAuysuM6GOKAO92k2ffkGdtIM98IM/GQsEIJyxmE4pn5ANAr84n/3/xjHxNMzZ6HrMneh1TBHi3mzz3Rm/PvH5DIkCe+UCejYWCEY5ML8jB8pljkW3znnbLtll1e4VLPmb/tARuxxQBud1xPX7IerVbPl4Ox+9WBOR2yws2yejtmedvSATkdvdcap88a4vc7r4pfMbLWPXsC1pnxABa2p0Y/etSAMBLs8bh0tEDdI9+qxvbUPjbzwAAr88twqTh/WIi4p7yzOc4droF918+AuPz+qIoL1PXdjslhnG/XYvTzR343Q/Oxs0X5MaE55++tg2flp3EjwoH44djB3Px/MNlm7D7+zrMu2g4Hr5yVEx4/vNnB/Gnzw5g4hl9ce9lI7h4fmDVLnyw+wSuKsjG324dGxOePys7iTtf24bcjCT8/v/O5eL596X78cKGwzgvtw/evWdS1HimdUYExjOfBo9ABABsSd25WcYMtEVNRw9GQ5fra87OwcThfXVvt8VsQr/URADAsL7JMeO5qd3l+cIR/bh5HtI3BQDQPy0x5jwXDErn5nlUdhoAV6qDWPOcm5nMzfPYoRkAAJMJMePZEwpGDKCuRU7exu/HHWcxI6Urz0R9S2wkYmKMeWTt5ZMoDwDSk2IvQzLvxI9Ad3bgWOnPAIzpzzGYubfegP4sXzDWxVB/9oSCEQOQT1KesxU8iLUMnJ5JCNM4ZJKV6T5JxoZnwKCTZEwGffwy9sq4x40YyiYrB7g8x2j5WLE0bnhCwYgByJFvOseBGwDSk7pOkjEyeMsnSIvZ5M4+yoPYPEnKwQjPoC/2Bm/5Fi9Pz2kxODNS2+xK+sgzGHGPGy0diIBHOTWHghHOOCWG7UdOe/0/L1ITXZ39P/tOxkTadTmtfWKcGV8eruHWXvmq9asjNTHh2Skx1LW4Bu+DJxu4ez5wsj5mPB8/7Upr76jVP629TEqCy7OjrjVmPB882QjAdbuGd39ud0pYf+BU1HvuCb1NwxEjU0WX2h2475+70NYpcT+2EZTaHXhstR3VTXzS2nse98F3dqOpzcn1uEbBO62953EffXcPaj3ur0e7ZyPGjlK7A4+/b0dVI9/fkVEY6dmI3xEPlJ6/KRjhhJGpomMhTbUnRrWXPLsgz9pCnvlAnvWBXu0VCCNTRcdammqj2kueuyHP2kGe+UCejYeCEQ4YmSo61tJUG9Ve8uwNedYG8swH8mw8FIxwwMhU0bGWptqo9pLn8MqJflyjIM98IM/GQ8EIB4xMFR1raaqNai95Dq+c6Mc1CvLMB/JsPBSMcMDIVNGxlqbaqPaSZ2/IszaQZz6QZ+OhYIQDRqaKjrX09ka1lzx3w8tzLKRdJ898IM/GQ8EIJ4xMFc07LbbRyO1NiPPu3nq31/0dpydyPa5RyO3tubotN88xknZdbq8tyXvVVfKsLUaNk7Hm2R+0zghn2jsljHz8YwDA8zMLcUV+Freod7+jHtP/vBHJCRa8MucC3dNiG801f9mIvSfqcffUM3DxqAHc2uuUGM564mN0OBn+csv5uOacnKj2fP+qXXh/53Fcd+5A/LhoCFfP05duwMHKRiy4YiR+dsmZUe15+bpDeKZ0Py4YloEFV4zi6vmnr23Df/ZX4saxg/H7/zsnqj1/sb8Sd6z8CoP6WPHsj87j6nnxx/vw8sZyjB2SgXfmTYwKz7TOiKA0t3fnd7j0rAFcO1tGV8Tf2uHE+CgPRIDu5eCnF2RzSQMuYzGbYEtyuR6RlRr1nuWkYpPP7Mvd86CMJACuq8ho9ywnyRsz0Mbd86jsNAB8M40bhZxTKjczmbvn83MzAABxZlPUe+4JBSOckZN6JcVbet1G0Bs56ZPEYiPplZyQMCM5IUhJ7XEnJYyBdODdScUM8GztTi4W7chL3/dJ5ptg0/OYsZDe3oiMvTLyMWPBc08oGOFMTdfAnRBn5p50Kt5iRmJXAPT5/sqoXtWvtcPpznB68GQj97bKJ8m1ZdGdlNApMVTUu9ZAOF7bwr2dckbZaE9K6JQYDp9yJW873dTOvZ3ySfKbioao97zneD0AoK1D4t7O1K7+XFEfG0kJPaFnRjhSanfgV6v3oKaJf3IvI5P08abU7sCv/70XlQ3GJJ2KlaSERvepWElKKILnhe/twenm6E5KKILnJ/5tx6mG6EpKSInyBIMS5fHB6LYafXxeGN1Oo4/PC6PbafTxeWF0O40+vp7QA6wCQYny+GB0W40+Pi+MbqfRx+eF0e00+vi8MLqdRh9fFCgY4QAlyuOD0W01+vi8MLqdRh+fF0a30+jj88Lodhp9fFGgYIQDlCiPD0a31ejj88Lodhp9fF4Y3U6jj88Lo9tp9PFFgYIRDlCiPD4Y3Vajj88Lo9tp9PF5YXQ7jT4+L4xup9HHFwUKRjhAifL4YHRbjT4+L4xup9HH54XR7TT6+Lwwup1GH18UKBjhgJFJ1GIpEZPRyeqMPj4vjG6n0cfnhdHtjJWxgzyLQUjByLJly5CXlwer1YrCwkJs3LjRb9n33nsPV1xxBfr374/09HRMnDgRn3zyScgVjlTkZEjxFu8OxTNRXiwkYpLbao3nmySv5/EHpEV3sjy5nWmJfJO39Tx+TpT3abmdmT1WXeXtOdrHDrmdWQb9bmPFcyBUrzOyatUqzJo1C8uWLcPkyZPxwgsv4OWXX0ZZWRmGDBnSq/z999+PgQMH4pJLLkGfPn3w6quv4tlnn8X//vc/nH/++YqOGQ3rjMhMfvpzHK9twQNXjEDRsL5ck9U5JYa3th7F4+/bkZmSgK8euzxqo+3bXv4Sm76txqwJQ3D12QO5JwVsbutEfrEr6H559jhcwjkPES+e+nAfXtp4GBeP6o+7pw7n7tkpMUx++nNU1Lei+Np8zJ40LCo9v7/zOO5ftQtnDkjFb64vMMTzrS99if+V1+D2ScPwxLXReaX+bWUjLl+yHolxZqy8o8gQzw++vRvv7zqOaflZWD6zMOI967bOyJIlSzB37lzceeedGD16NJYuXYrc3FwsX77cZ/mlS5fil7/8JS644AKMGDECv/vd7zBixAisWbNG7aGjgtNdy8HfcN4grkmYANd04NQR/QG4EvZFeicPhJzb4dLRWdw9A0ByYhxSEiwAgDMHRG+yPDmPx7ihGYZ4tphNGNjHdTWZ0ycpaj3LSfLO7J9qmOcz+qcCcOV6ilbPcpK8fqmJhnk+Z7ANABAfZ45az75QFYy0t7dj+/btmDZtmtf2adOmYfPmzYr2IUkSGhoakJnp/2GctrY21NfXe/2LBlo7nGhudy1dLWfQ5U2flPiuukho7XAGKR25yBl7+xiQ7EqmT1eCPjkfUTRS29KVJM+AZIQymV2/pdNR7LnOwORtMnKyPPk7j0ZON7nalmnQ+AwAfVO7xo3G6PXsC1XBSFVVFZxOJ7Kysry2Z2VloaKiQtE+/vjHP6KpqQk33XST3zKLFy+GzWZz/8vNzVVTTWGp7upcZhNg/77OkBX1kuMtsJhc0fZnZSejclU/p8TcrsurmgxrY0ZX4Fdqd0Rl0iunxHC0phkAcKq+1bD2yUHfpm+rotZzmaMBANDU3mlY++RAaM/3dVHr+asjroXFzCYY15+7PB+pbopKz/5Q9czIiRMnMGjQIGzevBkTJ050b3/qqafw+uuvY//+/QE//9Zbb+HOO+/Ev//9b1x++eV+y7W1taGtrTvJWX19PXJzcyP6mZFSuwOPv29HVaNxSZCMTgTFg1K7A4s+2IuKemOS5HnW495/7kJ7lCbLE6UvldodePDt3Whqj85keSJ5fuTdr1HX0mloPfRCJM9Gnye0RpdnRvr16weLxdJrFqSysrLXbElPVq1ahblz5+Ltt98OGIgAQGJiItLT073+RTJyEqSqHtNuFXWtuOeNHSi1O7jVoeeywzzroDdyGz0DEYB/G+V6eAYiRtRDL0TpS3I9PAMRI+qhF6J59gxEjKiHXojm2cjzhJGoCkYSEhJQWFiItWvXem1fu3YtJk2a5Pdzb731Fm6//Xb84x//wDXXXBNaTSMUEZIgiVAHvRGljaLUQy9EaZ8o9dALUdonSj30QpT2iVIPI1H9Ns2CBQvw8ssvY8WKFdi3bx8eeOABHD16FPPmzQMALFy4ELNnz3aXf+uttzB79mz88Y9/xIQJE1BRUYGKigrU1dVp1wqBESEJkgh10BtR2ihKPfRClPaJUg+9EKV9otRDL0Rpnyj1MJK44EW8ufnmm1FdXY0nn3wSDocDBQUF+OijjzB06FAAgMPhwNGjR93lX3jhBXR2duJnP/sZfvazn7m3z5kzBytXrgy/BYIjQhIkEeqgN6K0UZR66IUo7ROlHnohSvtEqYdeiNI+UephJKqDEQCYP38+5s+f7/NvPQOMdevWhXKIqEGEJEgi1EFvRGmjKPXQC1HaJ0o99EKU9olSD70QpX2i1MNIKDeNzoiQBEmEOuiNKG0UpR56IUr7RKmHXojSPlHqoReitE+UehgJBSM6Y3QSpp51iNZETCJ4FqkeeiFK+0Sph16I0r5oHzvIszhQMMIBOQlSXI+OxDMJUiwkYjI6SV7PekRrsjyjk+T1rEe0JsuT25dhUJK8nvWI1rFDlN9rtHsOhupEeUYQDYnynBLDeU9+iobWTtxyQS5mnDsQE87gn/vAKTG8vvkIFv2/MqRZ4/D8zEJD6qEXTonhur/9F3tP1OOK0Vm4ffIww9pX39KBc0o+BQA8PG0k7po6HAlx0RH/OyWGn7+5Ax/vrcD5uX3w0JWjDPPslBim/v4LHK9twQ3nDcSPxuVGTZ92Sgx/KN2P5zccRm5GEp6+8RxDPcvJ8qaM6Id5Fw2PKs+rth7Fr963IynegpfnjDPU86/ft+PNrUcxYkAqFl03JqI9Kz1/UzDCAVFWBZXr8sS/7TjVED0r/MmIsoqiaHXRGtHaVmp34N63dqLd2T2URYNrET0veHu3O7+W0fXRChE9P/LuHnc+IqPrEy4UjAiCvKpeT8lyjMtz+k2kumiNSG0TqS5aI1rbRKuPVojWLtHqoxWitUu0+miBLsvBE+oQaVU9keqiNSK1TaS6aI1obROtPlohWrtEq49WiNYu0erDGwpGdESkVfVEqovWiNQ2keqiNaK1TbT6aIVo7RKtPlohWrtEqw9vKBjREZFW1ROpLlojUttEqovWiNY20eqjFaK1S7T6aIVo7RKtPryhYERHRFpVT6S6aI1IbROpLlojWttEq49WiNYu0eqjFaK1S7T68IaCER0RaVU9keqiNSK1TaS6aI1obROtPlohWrtEq49WiNYu0erDGwpGdESU1f161iXaVvgjz3wQybOI9dEK0doVrX1atHaJVh/eUDCiM/KqegkWY1cF9axLNK7wJ7ctJcHitZ08a4vcNluSsauv9qxPdnp0rXYrt6tfaoLXdsM9R1mfltuVJUj/iVbPSqB1RjjglBim/P5znKhtFWKFSKfE8Nzn32LJZwfQPy0RS28+L6JX+JNxSgy3vfQlviyvwYVn9sM9Fxu7QqRTYliz6wTuf3sXzCbgtZ8UYeLwflHheeG7X+Pt7d/jrOw0PHFtvuH9xykxnLPoEzS1O3Fr0RBcc06O4XUKF6fE8ML6Q/j9J9+gX2oC/nzL+Ya3ySkxXPvXjdjnaMC0/CzMmWTcCsdacrSmGVN//wVMAH519VmYMynP0NWSnRLD/De245Oykxg7pA8enGbcCsfhQoueCYJoq/vJdXr8fTuqGqNnFVZRPYuy8q5WiOhZrtfP/7ETnR5rMIhQr1AR2fP9q3ahtUMSql7hUGp34LHVdlQ3iTMeltodePhfX6OhtVOYOoUKBSMCIOJqeiLWKVxEbJOIdQoXUdskar1CRdT2iFqvcBCxTSLWKRxoBVaDEXE1PRHrFC4itknEOoWLqG0StV6hImp7RK1XOIjYJhHrxAsKRnRCxNX0RKxTuIjYJhHrFC6itknUeoWKqO0RtV7hIGKbRKwTLygY0QkRV9MTsU7hImKbRKxTuIjaJlHrFSqitkfUeoWDiG0SsU68oGBEJ0RcTU/EOoWLiG0SsU7hImqbRK1XqIjaHlHrFQ4itknEOvGCghGdEHE1PRHrFC4itknEOoWLqG0StV6hImp7RK1XOIjYJhHrxAsKRnRCtFUUe9bJ11GZAXUKF/LMBxE9A4HrJRNJriPBc7T1aV+PgtLYwR8KRnTGlhzfa1uf5HjDXs9yr6Dpp16RCnnmg2ieAZfrn07N6zV4m03AT6fmRdRrkDKieo7GPp3eYzVhgMYOI6BgRCfkd8Vrmzt6/e20j228qfNRh7rmDtzzxg6U2h0G1Cg0yDMfRPZcanfgxQ3lva5wGQNe3FBOnjUm2vp0fUtnr7+J4DpaPCuFghEdCPSuOOCafjPqXfFoeo+dPPOBPPNBZM8AueZFNHlWAwUjOiDyu+Ii100tIrdF5LqpReS2iFw3tYjeFtHrpwaR2yJy3fSEghEdEPldcZHrphaR2yJy3dQicltErptaRG+L6PVTg8htEbluekLBiA6I/K64yHVTi8htEbluahG5LSLXTS2it0X0+qlB5LaIXDc9oWBEB4ryMgM+9Wzku+LB3mMHXE9sR8J77OSZD+SZD3JbAmHkGhPR5pr6tFhQMKIDa8sqfD4NL2Pku+KB3q2XqW3uwNqyCm51ChXyzAfyzAeL2YTrzg38Kul15+YYtsZENLmmPi0eFIxojPwkdCD6JMfjivxsTjXqzRX52UGvCkR/Wps884E888MpMXywO/Armx/sdhjajmhwTX1aTCgY0ZhgT0IDrqjWyCeht5bXBL0qEP1pbfLMB/LMDyWujW5HNLimPi0mFIxoTCQ8CR0JdQxGJLQhEuoYjEhoQyTUUQmR0I5IqGMwIqENkVBHraFgRGMi4UnoSKhjMCKhDZFQx2BEQhsioY5KiIR2REIdgxEJbYiEOmoNBSMaI/JT2jLR8LQ2eeYDeeZHJLkOhNF1DEYkeY70Pq0GCkY0RuSntGWi4Wlt8swH8syPSHEt8hs/SogUz9HQp9VAwYiGRMJT2jKR/LQ2eeYDeeZHpLiOhDd+AhEpnoHI79NqoWBEQyLhKW2ZSH5amzzzgTzzI1JcR8IbP4GIFM9A5PdptVAwoiGR9AR0JNW1J5FU90iqa08iqe6RVFdfREr9I6We/oik+kdSXbWAghENiaQnoCOprj2JpLpHUl17Ekl1j6S6+iJS6h8p9fRHJNU/kuqqBRSMaMjppragZYx+SltGyVPxAHC6qZ1DbdRBnvkQ7K0DAMgQ5In+SPYMRE6fJs/8iHTXaqFgRCOcEsNvPtwXtNwT1xj7lLaMxWzCE9eMDlruNx+K9YAUeRYLUWocyZ4jqU+TZ35EsutQoGBEI5Q8GAUAGSkJHGqjjIyUxKBlRHtAijzzI9gDdIA4D/sBke05kvo0eeZHpLoOBQpGNCISHzaiOvMhEusMRF69I62+MpFW70irr0wk1jsS6xwqFIxoxJGqJkXlRHrYSGldjlQ161wT5ZBnfkSaa/LMB/LMj1h6iJWCEQ1wSgxvbT0atJwoD0bJFOVlIjs9+DTgP786KsQ9SfLMj0h0TZ75QJ75UTg0A8EeXzGbXOUiHQpGNGBreQ0q6oM/pX3LBUOEeDBKxmI24cdFQ4KWE+WeJHnmRyS6Js98IM/82P7daQSL5yTmKhfpUDCiAZ8pzA8wrF+yzjVRz7B+KYrKiZADQel9UfIcPpHap8kzH8gzH5SOeaJ4DgcKRsLEKTH8c9sxRWVFvK+ntE5vb/ve8CnXfqnBp4bVlONJJHmO5D5NnvlAnvkQSZ7DhYKRMPnb5wfR1OYMWq5vSoJQ9yJlivIykZkSeGErAGhs68TfPv+WQ438s7W8WllBAX+TkeQ5kvs0eeYDeeZDJHkOFwpGwsApMby66YiistefN1Coe5EyFrMJPzhvkKKyr24uNyz6dkoML20sV1S2SsEqi7xR4/mFDYcM9fzChsOKyorYp8kzH8gzHyLFsxZQMBIGW8trUNsSeFEoGRFSUvvjcoV1M3KBq799fhDN7cGvbgDxplpllHpubncadpWjxrOofZo884E88yESPGsBBSNhUFGv7OGiPkli5O/wR1FeJmzWOEVlK+padK5Nb9Rc3fQRJFeKL4ryMtEnKfiUK2DMVU4sen5+/bfkOUTIMx9E96wVFIyEwaqt3ykqd/noAcJN/3liMZtwRX6WorKrFLyrrzX3vrVD8dXNHZPyhHVtMZtwx+RhisoacZUTi55bOiTc+9YOfSvUA/LMh/v/SZ4jCQpGVOKUGDYdrML1f9uIL8uVvds9+cx+OtcqfCaP6K+o3JdHTuOGv23Epm+rdI3APT1/uEfZa2vJCRb8/NIzdauTFvz80hFITrAoKrv0Pwew8cAp8hwCajx/uKcC89/YpvsVpVNiuOf1bTHt+ebnN6O9U9K1Tk6JYcmn32DN17HrmccYrTXK5uajEKfE8OWhamw6dArHT/u/9cAYQ1VjO1o7nWhqc+JwVRM6nOq+4GxbUrjV1Z3sdOXPWez6vh63vfw/WAAMH5CCVGscrHEW9EtNhMnHxYUkSThc1YzG9k6kJsQhr38KLL4KwuX7m5ON+PZUI5wqx6y7pw4X9upGxmI24e6pZ+BPnx0MWpYxYNaKrYgzAecN6YOBNqu7L/ryLffVlo5OtHcyJMaZYY33/72cqG3Bru/rVPfnaPMMAB/ZT6L0Vx9h7NA+GNTH9Xv1/O17+u65vW9KAqqb/H8vgMv1tu9qVb3oFY2e/3fkNEY+/jHO6JeEswf18fqbUq/+vhfA5XnnsVqoiXei0bM8RptNwNhcGwZl9F4/xdNjUnwczh3cB5NH9MOEM/oa4sPEGFMdOi1btgx/+MMf4HA4MGbMGCxduhRTpkzxW379+vVYsGAB9u7di4EDB+KXv/wl5s2bp/h49fX1sNlsqKurQ3p6utrq9qLU7sCj7+0JmpFUC/okx2P741cI39mdEkPhb9YqfiBXNJITLNiz6ErhPQMu1/m/LkWbzleIehBpns9e9IniqXqRIM98IM+96ZMcj6d/eDamF+Rosj+l52/Vt2lWrVqF+++/H4899hh27tyJKVOm4KqrrsLRo76fJSgvL8fVV1+NKVOmYOfOnfjVr36Fe++9F++++67aQ2tCqd2BeW/s4BKIAGLfi/REzX1JEYmEqxsZi9mES88aYHQ1QiLSPN899QyjqxES5JkP5Lk3tc0dmPfGDpTaHbofyxPVwciSJUswd+5c3HnnnRg9ejSWLl2K3NxcLF++3Gf5559/HkOGDMHSpUsxevRo3HnnnfjJT36CZ599NuzKq8UpMSz6YC+346Umxgl/L9KTn186AimJyu5LikSkeQaAmROGGl0F1USi50js0+SZD9Y4M3kOQMmaMq7PnKgKRtrb27F9+3ZMmzbNa/u0adOwefNmn5/ZsmVLr/JXXnkltm3bho4O37MTbW1tqK+v9/qnBUqTJWnF7288J2KibsAVef/hxnOMroZqIs0zAEw4o2/EDd6R6DkS+zR55sO8iyJnVkSGp2feiQ5VBSNVVVVwOp3IyvJ+DTQrKwsVFb6fXK6oqPBZvrOzE1VVVT4/s3jxYthsNve/3NxcNdX0i9KkQ1pw15Q8XH2ONvfceHL1OQNx15RhRldDMZHqOdIG70j1DLj69DVnK3t13Wgi3XOkjB3WODN+cdkIo6sREjw98zxnhvRqr6nHo+KMsV7bgpX3tV1m4cKFqKurc/87dkxZkqNg8FqZc+6Fw/DYNflcjqUHj10zBnMvHGZ0NYIS6Z4jZfCOdM8A8JcfFyI5XuyVDO6YHPmeI2XsWHLTeRE3K+IJL888V7NW9evs168fLBZLr1mQysrKXrMfMtnZ2T7Lx8XFoW/fvj4/k5iYiPT0dK9/WlCUl4nsdH0zut41ZRieuHaMrsfgwRPXjsFdU/KMroZfosXzY9eQZx5YzCYsufk8o6vhl8tH90fxjMj3DIg/dtw9NXJnnzzR23OOzcp1VVpVwUhCQgIKCwuxdu1ar+1r167FpEmTfH5m4sSJvcp/+umnGDduHOLjlS1xqxUWswmLrtPnB5+aaMGyW8/HY9dEx4ACAI9dk49lt45FaqI4y9GQZz5Y481R53l6QQ6enzlW8dLavLhryjC8PKfI6Gpoityn4wWafZDHjoVXR/bskyd6jh3FM/K5zh6pXmdk1apVmDVrFp5//nlMnDgRL774Il566SXs3bsXQ4cOxcKFC3H8+HG89tprAFyv9hYUFODuu+/GXXfdhS1btmDevHl46623cOONNyo6pqjrjMSbgctGZ2HWxGGGLRTDA3mBuNe+PILP91eqXiQrXCxm4AryzIVEiwn3XDwcv7hsJHnWkTizK0vs4h+ei4Q4sW8fhYNTYvjz2gNYvuGQIZ5jbYz+w6f7setYXVj7ykiOx2ID1hkJedGz3//+93A4HCgoKMCf/vQnTJ06FQBw++2348iRI1i3bp27/Pr16/HAAw+4Fz175JFHDF30DAhtBVZrnAX906wYnJmEScONW6nOSDy9fV/THHBFUBm1K7BWNbajzSkhNyMZN44djEln9otpz3L/DLTypOffla7AKmMymTAoIzb7dKBxQMsVWAHyHGy81WIFViC2PQNAe6eEv28ux9byGjS3daKvn/7IawVWXYMR3ugRjBAEQRAEoS+6rcBKEARBEAShJRSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKOJk5gqAvEhsfX29wTUhCIIgCEIp8nk72GLvERGMNDQ0AAByc3MNrglBEARBEGppaGiAzWbz+/eIyE0jSRJOnDiBtLQ0mAJl/FJJfX09cnNzcezYsajNeRPtbaT2RT7R3sZobx8Q/W2k9oUOYwwNDQ0YOHAgzGb/T4ZExMyI2WzG4MGDddt/enp6VHYwT6K9jdS+yCfa2xjt7QOiv43UvtAINCMiQw+wEgRBEARhKBSMEARBEARhKDEdjCQmJqK4uBiJiYlGV0U3or2N1L7IJ9rbGO3tA6K/jdQ+/YmIB1gJgiAIgoheYnpmhCAIgiAI46FghCAIgiAIQ6FghCAIgiAIQ6FghCAIgiAIQ4n6YOSpp57CpEmTkJycjD59+ij6DGMMixYtwsCBA5GUlISLL74Ye/fu9SrT1taGX/ziF+jXrx9SUlJw3XXX4fvvv9ehBYE5ffo0Zs2aBZvNBpvNhlmzZqG2tjbgZ0wmk89/f/jDH9xlLr744l5/v+WWW3RuTW9Cad/tt9/eq+4TJkzwKiPK9weob2NHRwceeeQRnH322UhJScHAgQMxe/ZsnDhxwqucUd/hsmXLkJeXB6vVisLCQmzcuDFg+fXr16OwsBBWqxVnnHEGnn/++V5l3n33XeTn5yMxMRH5+flYvXq1XtVXhJo2vvfee7jiiivQv39/pKenY+LEifjkk0+8yqxcudLnb7K1tVXvpvhETfvWrVvns+779+/3KifSd6imfb7GE5PJhDFjxrjLiPT9bdiwATNmzMDAgQNhMpnw/vvvB/2MEL9BFuX8+te/ZkuWLGELFixgNptN0WeefvpplpaWxt599122Z88edvPNN7OcnBxWX1/vLjNv3jw2aNAgtnbtWrZjxw52ySWXsHPPPZd1dnbq1BLfTJ8+nRUUFLDNmzezzZs3s4KCAnbttdcG/IzD4fD6t2LFCmYymdihQ4fcZS666CJ21113eZWrra3Vuzm9CKV9c+bMYdOnT/eqe3V1tVcZUb4/xtS3sba2ll1++eVs1apVbP/+/WzLli1s/PjxrLCw0KucEd/hP//5TxYfH89eeuklVlZWxu677z6WkpLCvvvuO5/lDx8+zJKTk9l9993HysrK2EsvvcTi4+PZv/71L3eZzZs3M4vFwn73u9+xffv2sd/97ncsLi6Offnll7q2xR9q23jfffexZ555hm3dupUdOHCALVy4kMXHx7MdO3a4y7z66qssPT2912/TCNS274svvmAA2DfffONVd8/fkkjfodr21dbWerXr2LFjLDMzkxUXF7vLiPT9ffTRR+yxxx5j7777LgPAVq9eHbC8KL/BqA9GZF599VVFwYgkSSw7O5s9/fTT7m2tra3MZrOx559/njHm6pzx8fHsn//8p7vM8ePHmdlsZqWlpZrX3R9lZWUMgFeH2LJlCwPA9u/fr3g/119/Pbv00ku9tl100UXsvvvu06qqIRFq++bMmcOuv/56v38X5ftjTLvvcOvWrQyA14BqxHdYVFTE5s2b57XtrLPOYo8++qjP8r/85S/ZWWed5bXt7rvvZhMmTHD//0033cSmT5/uVebKK69kt9xyi0a1VofaNvoiPz+flZSUuP9f6fjEA7Xtk4OR06dP+92nSN9huN/f6tWrmclkYkeOHHFvE+n780RJMCLKbzDqb9Oopby8HBUVFZg2bZp7W2JiIi666CJs3rwZALB9+3Z0dHR4lRk4cCAKCgrcZXiwZcsW2Gw2jB8/3r1twoQJsNlsiutx8uRJfPjhh5g7d26vv7355pvo168fxowZg4ceesidPZkX4bRv3bp1GDBgAEaOHIm77roLlZWV7r+J8v0B2nyHAFBXVweTydTrViTP77C9vR3bt2/38goA06ZN89uWLVu29Cp/5ZVXYtu2bejo6AhYhvd3BYTWxp5IkoSGhgZkZmZ6bW9sbMTQoUMxePBgXHvttdi5c6dm9VZKOO07//zzkZOTg8suuwxffPGF199E+Q61+P5eeeUVXH755Rg6dKjXdhG+v1AQ5TcYEYnyeFJRUQEAyMrK8tqelZWF7777zl0mISEBGRkZvcrIn+dBRUUFBgwY0Gv7gAEDFNfj73//O9LS0vDDH/7Qa/ttt92GvLw8ZGdnw263Y+HChdi9ezfWrl2rSd2VEGr7rrrqKvzoRz/C0KFDUV5ejieeeAKXXnoptm/fjsTERGG+P0Cb77C1tRWPPvoobr31Vq8kV7y/w6qqKjidTp+/HX9tqaio8Fm+s7MTVVVVyMnJ8VuG93cFhNbGnvzxj39EU1MTbrrpJve2s846CytXrsTZZ5+N+vp6/PnPf8bkyZOxe/dujBgxQtM2BCKU9uXk5ODFF19EYWEh2tra8Prrr+Oyyy7DunXrMHXqVAD+v2fe32G435/D4cDHH3+Mf/zjH17bRfn+QkGU32BEBiOLFi1CSUlJwDJfffUVxo0bF/IxTCaT1/8zxnpt64mSMkpQ2j6gdz3V1mPFihW47bbbYLVavbbfdddd7v8uKCjAiBEjMG7cOOzYsQNjx45VtG9/6N2+m2++2f3fBQUFGDduHIYOHYoPP/ywV9ClZr9q4PUddnR04JZbboEkSVi2bJnX3/T8DgOh9rfjq3zP7aH8HvUk1Pq89dZbWLRoEf797397BaETJkzwesh68uTJGDt2LP7617/iL3/5i3YVV4ia9o0aNQqjRo1y///EiRNx7NgxPPvss+5gRO0+9SbUuqxcuRJ9+vTBDTfc4LVdtO9PLSL8BiMyGPn5z38e9K2AYcOGhbTv7OxsAK5oMScnx729srLSHRlmZ2ejvb0dp0+f9rq6rqysxKRJk0I6ridK2/f111/j5MmTvf526tSpXlGsLzZu3IhvvvkGq1atClp27NixiI+Px8GDB8M+kfFqn0xOTg6GDh2KgwcPAtD/+wP4tLGjowM33XQTysvL8fnnnwdN/a3ld+iLfv36wWKx9Lpa8vzt9CQ7O9tn+bi4OPTt2zdgGTV9QCtCaaPMqlWrMHfuXLzzzju4/PLLA5Y1m8244IIL3H2WF+G0z5MJEybgjTfecP+/KN9hOO1jjGHFihWYNWsWEhISApY16vsLBWF+g5o9fSI4ah9gfeaZZ9zb2trafD7AumrVKneZEydOGPYA6//+9z/3ti+//FLxw49z5szp9QaGP/bs2cMAsPXr14dcX7WE2z6ZqqoqlpiYyP7+978zxsT5/hgLvY3t7e3shhtuYGPGjGGVlZWKjsXjOywqKmL33HOP17bRo0cHfIB19OjRXtvmzZvX6+G5q666yqvM9OnTDX2AVU0bGWPsH//4B7NarUEfJpSRJImNGzeO3XHHHeFUNSRCaV9PbrzxRnbJJZe4/1+k7zDU9skP6u7ZsyfoMYz8/jyBwgdYRfgNRn0w8t1337GdO3eykpISlpqaynbu3Ml27tzJGhoa3GVGjRrF3nvvPff/P/3008xms7H33nuP7dmzh/34xz/2+Wrv4MGD2WeffcZ27NjBLr30UsNe7T3nnHPYli1b2JYtW9jZZ5/d67XQnu1jjLG6ujqWnJzMli9f3muf3377LSspKWFfffUVKy8vZx9++CE766yz2Pnnny98+xoaGtiDDz7INm/ezMrLy9kXX3zBJk6cyAYNGiTk98eY+jZ2dHSw6667jg0ePJjt2rXL61XCtrY2xphx36H82uQrr7zCysrK2P33389SUlLcbx48+uijbNasWe7y8muFDzzwACsrK2OvvPJKr9cKN23axCwWC3v66afZvn372NNPPy3Eq71K2/iPf/yDxcXFseeee87va9aLFi1ipaWl7NChQ2znzp3sjjvuYHFxcV5Bqqjt+9Of/sRWr17NDhw4wOx2O3v00UcZAPbuu++6y4j0Haptn8zMmTPZ+PHjfe5TpO+voaHBfZ4DwJYsWcJ27tzpftNO1N9g1Acjc+bMYQB6/fviiy/cZQCwV1991f3/kiSx4uJilp2dzRITE9nUqVN7RcMtLS3s5z//OcvMzGRJSUns2muvZUePHuXUqm6qq6vZbbfdxtLS0lhaWhq77bbber1i17N9jDH2wgsvsKSkJJ/rThw9epRNnTqVZWZmsoSEBDZ8+HB277339lqrgwdq29fc3MymTZvG+vfvz+Lj49mQIUPYnDlzen03onx/jKlvY3l5uc8+7dmvjfwOn3vuOTZ06FCWkJDAxo4d6zUTM2fOHHbRRRd5lV+3bh07//zzWUJCAhs2bJjPAPmdd95ho0aNYvHx8eyss87yOtEZgZo2XnTRRT6/qzlz5rjL3H///WzIkCEsISGB9e/fn02bNo1t3ryZY4u8UdO+Z555hg0fPpxZrVaWkZHBLrzwQvbhhx/22qdI36HaPlpbW8uSkpLYiy++6HN/In1/8gyOv/4m6m/QxFjXkyoEQRAEQRAGQOuMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKBSMEARBEARhKP8fjHlHI9cQ4+AAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import numpy as np\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "datasets = []\n", - "\n", - "n_peak = 5\n", - "n_num_per_peak = 100\n", - "n_sample = n_peak * n_num_per_peak\n", - "\n", - "x_grid = torch.linspace(-1,1,steps=n_sample)\n", - "\n", - "x_centers = 2/n_peak * (np.arange(n_peak) - n_peak/2+0.5)\n", - "\n", - "x_sample = torch.stack([torch.linspace(-1/n_peak,1/n_peak,steps=n_num_per_peak)+center for center in x_centers]).reshape(-1,)\n", - "\n", - "\n", - "y = 0.\n", - "for center in x_centers:\n", - " y += torch.exp(-(x_grid-center)**2*300)\n", - " \n", - "y_sample = 0.\n", - "for center in x_centers:\n", - " y_sample += torch.exp(-(x_sample-center)**2*300)\n", - " \n", - "\n", - "plt.plot(x_grid.detach().numpy(), y.detach().numpy())\n", - "plt.scatter(x_sample.detach().numpy(), y_sample.detach().numpy())" - ] - }, - { - "cell_type": "markdown", - "id": "19477c89", - "metadata": {}, - "source": [ - "### Sequentially prensenting different peaks to KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "831a9456", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.subplots(1, 5, figsize=(15, 2))\n", - "plt.subplots_adjust(wspace=0, hspace=0)\n", - "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", - " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.scatter(x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), color=\"black\", s=2)\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" - ] - }, - { - "cell_type": "markdown", - "id": "3e487a84", - "metadata": {}, - "source": [ - "### Training KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "11a1d129", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.99e-06 | test loss: 3.99e-06 | reg: 1.26e-01 : 100%|█| 100/100 [00:01<00:00, 59.94it/s\n", - "train loss: 3.99e-06 | test loss: 3.99e-06 | reg: 1.26e-01 : 100%|█| 100/100 [00:01<00:00, 70.47it/s\n", - "train loss: 3.99e-06 | test loss: 3.99e-06 | reg: 1.26e-01 : 100%|█| 100/100 [00:01<00:00, 74.04it/s\n", - "train loss: 3.99e-06 | test loss: 3.99e-06 | reg: 1.26e-01 : 100%|█| 100/100 [00:01<00:00, 76.05it/s\n", - "train loss: 3.99e-06 | test loss: 3.99e-06 | reg: 1.26e-01 : 100%|█| 100/100 [00:01<00:00, 81.69it/s\n" - ] - } - ], - "source": [ - "ys = []\n", - "\n", - "# setting bias_trainable=False, sp_trainable=False, sb_trainable=False is important.\n", - "# otherwise KAN will have random scaling and shift for samples in previous stages\n", - "\n", - "model = KAN(width=[1,1], grid=200, k=3, noise_scale=0.1, bias_trainable=False, sp_trainable=False, sb_trainable=False)\n", - "\n", - "for group_id in range(n_peak):\n", - " dataset = {}\n", - " dataset['train_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['train_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " model.train(dataset, opt = 'LBFGS', steps=100, update_grid=False);\n", - " y_pred = model(x_grid[:,None])\n", - " ys.append(y_pred.detach().numpy()[:,0])" - ] - }, - { - "cell_type": "markdown", - "id": "dbb9a1b7", - "metadata": {}, - "source": [ - "### Prediction of KAN after each stage" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "12379f4a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.subplots(1, 5, figsize=(15, 2))\n", - "plt.subplots_adjust(wspace=0, hspace=0)\n", - "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", - " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.plot(x_grid.detach().numpy(), ys[i-1], color='black')\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d2002726", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_8_scaling_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_8_scaling_-checkpoint.ipynb deleted file mode 100644 index e93b60170..000000000 --- a/docs/.ipynb_checkpoints/Example_8_scaling_-checkpoint.ipynb +++ /dev/null @@ -1,532 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 8: KANs' Scaling Laws" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "### In this example, we show KAN's scaling laws (wrt model params and data size)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a1c25e8a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "data_size=100\n", - "grid_size=5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.22e-03 | test loss: 7.32e-03 | reg: 2.91e+00 : 100%|██| 50/50 [00:07<00:00, 7.10it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.20e-04 | test loss: 8.06e-04 | reg: 2.90e+00 : 100%|██| 50/50 [00:06<00:00, 7.48it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 7.01e-06 | test loss: 3.07e-04 | reg: 2.90e+00 : 100%|██| 50/50 [00:07<00:00, 6.73it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.97e-04 | test loss: 3.15e-02 | reg: 2.90e+00 : 100%|██| 50/50 [00:07<00:00, 6.45it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.00e-03 | test loss: 1.65e+00 | reg: 3.05e+00 : 100%|██| 50/50 [00:07<00:00, 6.35it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "data_size=300\n", - "grid_size=5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.80e-03 | test loss: 6.71e-03 | reg: 2.88e+00 : 100%|██| 50/50 [00:06<00:00, 7.23it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.19e-04 | test loss: 3.15e-04 | reg: 2.89e+00 : 100%|██| 50/50 [00:06<00:00, 7.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.96e-05 | test loss: 2.34e-05 | reg: 2.89e+00 : 100%|██| 50/50 [00:07<00:00, 6.67it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.08e-06 | test loss: 5.00e-06 | reg: 2.89e+00 : 100%|██| 50/50 [00:11<00:00, 4.37it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.81e-07 | test loss: 3.41e-02 | reg: 2.89e+00 : 100%|██| 50/50 [00:17<00:00, 2.83it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "data_size=1000\n", - "grid_size=5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.45e-03 | test loss: 6.44e-03 | reg: 2.91e+00 : 100%|██| 50/50 [00:07<00:00, 6.72it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.14e-04 | test loss: 3.76e-04 | reg: 2.94e+00 : 100%|██| 50/50 [00:07<00:00, 6.54it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.94e-05 | test loss: 4.69e-05 | reg: 2.93e+00 : 100%|██| 50/50 [00:14<00:00, 3.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.21e-06 | test loss: 1.30e-05 | reg: 2.93e+00 : 100%|██| 50/50 [00:49<00:00, 1.01it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.12e-06 | test loss: 1.05e-05 | reg: 2.93e+00 : 100%|██| 50/50 [01:15<00:00, 1.51s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "data_size=3000\n", - "grid_size=5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 6.12e-03 | test loss: 6.77e-03 | reg: 2.79e+00 : 100%|██| 50/50 [00:16<00:00, 2.99it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.98e-04 | test loss: 3.35e-04 | reg: 2.78e+00 : 100%|██| 50/50 [00:34<00:00, 1.44it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=20\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.72e-05 | test loss: 1.86e-05 | reg: 2.78e+00 : 100%|██| 50/50 [00:38<00:00, 1.31it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=50\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.97e-07 | test loss: 4.93e-07 | reg: 2.78e+00 : 100%|██| 50/50 [00:51<00:00, 1.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid_size=100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.61e-08 | test loss: 3.27e-08 | reg: 2.78e+00 : 100%|██| 50/50 [00:26<00:00, 1.85it/s]\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3)\n", - "\n", - "data_sizes = np.array([100,300,1000,3000])\n", - "grids = np.array([5,10,20,50,100])\n", - "\n", - "train_losses = np.zeros((data_sizes.shape[0], grids.shape[0]))\n", - "test_losses = np.zeros((data_sizes.shape[0], grids.shape[0]))\n", - "steps = 50\n", - "k = 3\n", - "\n", - "for j in range(data_sizes.shape[0]):\n", - " data_size = data_sizes[j]\n", - " print(f'data_size={data_size}')\n", - " # create dataset\n", - " f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - " dataset = create_dataset(f, n_var=2, train_num=data_size)\n", - " \n", - " for i in range(grids.shape[0]):\n", - " print(f'grid_size={grids[i]}')\n", - " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k)\n", - " if i != 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k).initialize_from_another_model(model, dataset['train_input'])\n", - " results = model.train(dataset, opt=\"LBFGS\", steps=steps, stop_grid_update_step = 30)\n", - " train_losses[j][i] = results['train_loss'][-1]\n", - " test_losses[j][i] = results['test_loss'][-1]\n" - ] - }, - { - "cell_type": "markdown", - "id": "6be8ba55", - "metadata": {}, - "source": [ - "### Fix data size, study model (grid) size scaling. Roughly display $N^{-4}$ scaling." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e05289dd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'grid size')" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i in range(data_sizes.shape[0]):\n", - " plt.plot(grids, train_losses[i,:], marker=\"o\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.plot(np.array([5,100]), 0.1*np.array([3,100])**(-4.), ls=\"--\", color=\"black\")\n", - "plt.legend([f'data={data_sizes[i]}' for i in range(data_sizes.shape[0])]+[r'$N^{-4}$'])\n", - "plt.ylabel('train RMSE')\n", - "plt.xlabel('grid size')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6d15cc9e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'grid size')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i in range(data_sizes.shape[0]):\n", - " plt.plot(grids, test_losses[i,:], marker=\"o\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.plot(np.array([5,100]), 0.1*np.array([3,100])**(-4.), ls=\"--\", color=\"black\")\n", - "plt.legend([f'data={data_sizes[i]}' for i in range(data_sizes.shape[0])]+[r'$N^{-4}$'])\n", - "plt.ylabel('test RMSE')\n", - "plt.xlabel('grid size')" - ] - }, - { - "cell_type": "markdown", - "id": "18bcedfe", - "metadata": {}, - "source": [ - "### Fix model (grid) size, study data size scaling. No clear power law scaling. But we observe that: (1) increasing data size has no harm to performance. (2) powerful model (larger grid size) can benefit more from data size increase. Ideally one would want to increase data size and model size together so that their complexity always match." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "0dd85c41", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'data size')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i in range(grids.shape[0]):\n", - " plt.plot(data_sizes, train_losses[:,i], marker=\"o\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.plot(np.array([100,3000]), 1e8*np.array([100,3000])**(-4.), ls=\"--\", color=\"black\")\n", - "plt.legend([f'grid={grids[i]}' for i in range(grids.shape[0])]+[r'$N^{-4}$'])\n", - "plt.ylabel('train RMSE')\n", - "plt.xlabel('data size')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "107801f6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'data size')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i in range(grids.shape[0]):\n", - " plt.plot(data_sizes, test_losses[:,i], marker=\"o\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.plot(np.array([100,3000]), 1e5*np.array([100,3000])**(-4.), ls=\"--\", color=\"black\")\n", - "plt.legend([f'grid={grids[i]}' for i in range(grids.shape[0])]+[r'$N^{-4}$'])\n", - "plt.ylabel('test RMSE')\n", - "plt.xlabel('data size')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Example_9_singularity_-checkpoint.ipynb b/docs/.ipynb_checkpoints/Example_9_singularity_-checkpoint.ipynb deleted file mode 100644 index 69005b5f6..000000000 --- a/docs/.ipynb_checkpoints/Example_9_singularity_-checkpoint.ipynb +++ /dev/null @@ -1,346 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 9: Singularity" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "### Let's construct a dataset which contains singularity $f(x,y)={\\rm sin}({\\rm log}(x)+{\\rm log}(y))\\\n", - " (x>0,y>0)$" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.00e-03 | test loss: 3.94e-02 | reg: 2.72e+00 : 100%|██| 20/20 [00:11<00:00, 1.78it/s]\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset, SYMBOLIC_LIB, add_symbolic\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=20, k=3, seed=0)\n", - "f = lambda x: torch.sin(2*(torch.log(x[:,[0]])+torch.log(x[:,[1]])))\n", - "dataset = create_dataset(f, n_var=2, ranges=[0.2,5])\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ccb7ec43", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.999988712412588\n", - "r2 is 0.9999928603717329\n", - "r2 is 0.9968394556850537\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9968, grad_fn=)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'log')\n", - "model.fix_symbolic(0,1,0,'log')\n", - "model.fix_symbolic(1,0,0,'sin')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "0937db67", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.46e-15 | test loss: 6.78e-16 | reg: 2.72e+00 : 100%|██| 20/20 [00:02<00:00, 8.21it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e959cda3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 \\sin{\\left(2.0 \\log{\\left(2.01 x_{1} \\right)} + 2.0 \\log{\\left(0.62 x_{2} \\right)} + 5.85 \\right)}$" - ], - "text/plain": [ - "1.0*sin(2.0*log(2.01*x_1) + 2.0*log(0.62*x_2) + 5.85)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.symbolic_formula()[0][0]" - ] - }, - { - "cell_type": "markdown", - "id": "16e4da06", - "metadata": {}, - "source": [ - "### We were lucky -- singularity does not seem to be a problem in this case. But let's instead consider $f(x,y)=\\sqrt{x^2+y^2}$. $x=y=0$ is a singularity point." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1ce52cec", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.08e-01 | test loss: 2.18e-01 | reg: 2.75e+01 : 100%|██| 20/20 [00:38<00:00, 1.92s/it]\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset, SYMBOLIC_LIB, add_symbolic\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1)\n", - "f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3a69ec41", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ad2e8d6f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f2dc6ceb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 3.72e-03 | test loss: 3.45e-03 | reg: 3.42e+00 : 100%|██| 20/20 [00:03<00:00, 5.13it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2a302028", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "7cbec774", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with x^2, r2=0.9999921393183026\n", - "fixing (0,1,0) with x^2, r2=0.9999940727994734\n", - "fixing (1,0,0) with sqrt, r2=0.9998914314178492\n" - ] - } - ], - "source": [ - "model.auto_symbolic()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "e14000d8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.01 \\sqrt{x_{1}^{2} + 1.0 x_{2}^{2}} - 0.01$" - ], - "text/plain": [ - "1.01*sqrt(x_1**2 + 1.0*x_2**2) - 0.e-2" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.symbolic_formula()[0][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "031fabd6", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: nan | test loss: nan | reg: nan : 100%|█████████████████| 20/20 [00:03<00:00, 5.70it/s]\n" - ] - } - ], - "source": [ - "# will give nan, it's a bug that should be resolved later. \n", - "# But happy to see the above already give a formula that is close enough to ground truth\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lr=1e-3, update_grid=False);" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/Makefile-checkpoint b/docs/.ipynb_checkpoints/Makefile-checkpoint deleted file mode 100644 index d4bb2cbb9..000000000 --- a/docs/.ipynb_checkpoints/Makefile-checkpoint +++ /dev/null @@ -1,20 +0,0 @@ -# Minimal makefile for Sphinx documentation -# - -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build -SOURCEDIR = . -BUILDDIR = _build - -# Put it first so that "make" without argument is like "make help". -help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - -.PHONY: help Makefile - -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/.ipynb_checkpoints/community-checkpoint.rst b/docs/.ipynb_checkpoints/community-checkpoint.rst deleted file mode 100644 index 7e21e6fec..000000000 --- a/docs/.ipynb_checkpoints/community-checkpoint.rst +++ /dev/null @@ -1,12 +0,0 @@ -.. _community: - -Community ---------- - -.. toctree:: - :maxdepth: 1 - - Community/Community_1_physics_informed_kan.rst - Community/Community_2_protein_sequence_classification.rst - - \ No newline at end of file diff --git a/docs/.ipynb_checkpoints/conf-checkpoint.py b/docs/.ipynb_checkpoints/conf-checkpoint.py deleted file mode 100644 index 464f04ccd..000000000 --- a/docs/.ipynb_checkpoints/conf-checkpoint.py +++ /dev/null @@ -1,64 +0,0 @@ -import sphinx_rtd_theme - -# Configuration file for the Sphinx documentation builder. -# -# For the full list of built-in configuration values, see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html - -# -- Project information ----------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information - -project = 'Kolmogorov Arnold Network' -copyright = '2024, Ziming Liu' -author = 'Ziming Liu' - -# -- General configuration --------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration - -extensions = ["sphinx_rtd_theme", - "sphinx.ext.autodoc", - "sphinx.ext.autosectionlabel" - ] - -templates_path = ['_templates'] -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] - - - -# -- Options for HTML output ------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output - -#html_theme = 'alabaster' -html_theme = "sphinx_rtd_theme" -html_static_path = ['_static'] - -def skip(app, what, name, obj, would_skip, options): - if name == "__init__": - return False - return would_skip - -def setup(app): - app.connect("autodoc-skip-member", skip) - -autodoc_mock_imports = ["numpy", - "torch", - "torch.nn", - "matplotlib", - "matplotlib.pyplot", - "tqdm", - "sympy", - "scipy", - "sklearn", - "torch.optim", - "re", - "yaml", - "pandas"] - - -source_suffix = [".rst", ".md"] -#source_suffix = [".rst", ".md", ".ipynb"] -#source_suffix = { -# '.rst': 'restructuredtext', -# '.ipynb': 'myst-nb', -# '.myst': 'myst-nb', -#} diff --git a/docs/.ipynb_checkpoints/demos-checkpoint.rst b/docs/.ipynb_checkpoints/demos-checkpoint.rst deleted file mode 100644 index ad06bc8c6..000000000 --- a/docs/.ipynb_checkpoints/demos-checkpoint.rst +++ /dev/null @@ -1,20 +0,0 @@ -.. _api-demo: - -API Demos ---------- - -.. toctree:: - :maxdepth: 1 - - API_demo/API_1_indexing.rst - API_demo/API_2_plotting.rst - API_demo/API_3_extract_activations.rst - API_demo/API_4_initialization.rst - API_demo/API_5_grid.rst - API_demo/API_6_training_hyperparameter.rst - API_demo/API_7_pruning.rst - API_demo/API_8_regularization.rst - API_demo/API_9_video.rst - API_demo/API_10_device.rst - API_demo/API_11_create_dataset.rst - API_demo/API_12_checkpoint_save_load_model.rst \ No newline at end of file diff --git a/docs/.ipynb_checkpoints/examples-checkpoint.rst b/docs/.ipynb_checkpoints/examples-checkpoint.rst deleted file mode 100644 index b9b4605be..000000000 --- a/docs/.ipynb_checkpoints/examples-checkpoint.rst +++ /dev/null @@ -1,24 +0,0 @@ -.. _examples: - -Examples --------- - -.. toctree:: - :maxdepth: 1 - - Example/Example_1_function_fitting.rst - Example/Example_3_deep_formula.rst - Example/Example_4_classfication.rst - Example/Example_5_special_functions.rst - Example/Example_6_PDE_interpretation.rst - Example/Example_7_PDE_accuracy.rst - Example/Example_8_continual_learning.rst - Example/Example_9_singularity.rst - Example/Example_10_relativity-addition.rst - Example/Example_11_encouraing_linear.rst - Example/Example_12_unsupervised_learning.rst - Example/Example_13_phase_transition.rst - Example/Example_14_knot_supervised.rst - Example/Example_15_knot_unsupervised.rst - - \ No newline at end of file diff --git a/docs/.ipynb_checkpoints/index-checkpoint.rst b/docs/.ipynb_checkpoints/index-checkpoint.rst deleted file mode 100644 index 66cbee310..000000000 --- a/docs/.ipynb_checkpoints/index-checkpoint.rst +++ /dev/null @@ -1,78 +0,0 @@ -.. kolmogorov-arnold-network documentation master file, created by - sphinx-quickstart on Sun Apr 21 12:57:28 2024. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -Welcome to Kolmogorov Arnold Network (KAN) documentation! -========================================================== - -.. image:: kan_plot.png - -This documentation is for the `paper`_ "KAN: Kolmogorov-Arnold Networks" and the `github repo`_. -Kolmogorov-Arnold Networks, inspired by the Kolmogorov-Arnold representation theorem, are promising alternatives -of Multi-Layer Preceptrons (MLPs). KANs have activation functions on edges, whereas MLPs have activation functions on nodes. -This simple change makes KAN better than MLPs in terms of both accuracy and interpretability. - -.. _github repo: https://github.com/KindXiaoming/pykan -.. _paper: https://arxiv.org/abs/2404.19756 - -Installation ------------- - -Installation via github -~~~~~~~~~~~~~~~~~~~~~~~~ - -.. code-block:: python - - git clone https://github.com/KindXiaoming/pykan.git - cd pykan - pip install -e . - # pip install -r requirements.txt # install requirements - - -Installation via PyPI -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. code-block:: python - - pip install pykan - - -Requirements -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. code-block:: python - # python==3.9.7 - matplotlib==3.6.2 - numpy==1.24.4 - scikit_learn==1.1.3 - setuptools==65.5.0 - sympy==1.11.1 - torch==2.2.2 - tqdm==4.66.2 - -Get started ------------ - -* Quickstart: :ref:`hello-kan` -* KANs in Action: :ref:`api-demo`, :ref:`examples` -* API (advanced): :ref:`api`. - -.. toctree:: - :maxdepth: 1 - :caption: Contents: - - intro.rst - modules.rst - demos.rst - examples.rst - interp.rst - physics.rst - community.rst - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` diff --git a/docs/.ipynb_checkpoints/interp-checkpoint.rst b/docs/.ipynb_checkpoints/interp-checkpoint.rst deleted file mode 100644 index a542f0315..000000000 --- a/docs/.ipynb_checkpoints/interp-checkpoint.rst +++ /dev/null @@ -1,23 +0,0 @@ -.. _interp: - -Interpretability ----------------- - -.. toctree:: - :maxdepth: 1 - - Interp/Interp_1_Hello, MultKAN.rst - Interp/Interp_2_Advanced MultKAN.rst - Interp/Interp_3_KAN_Compiler.rst - Interp/Interp_4_feature_attribution.rst - Interp/Interp_5_test_symmetry.rst - Interp/Interp_6_test_symmetry_NN.rst - Interp/Interp_8_adding_auxillary_variables.rst - Interp/Interp_9_different_plotting_metrics.rst - Interp/Interp_10_hessian.rst - Interp/Interp_10A_swap.rst - Interp/Interp_10B_swap.rst - Interp/Interp_11_sparse_init.rst - - - \ No newline at end of file diff --git a/docs/.ipynb_checkpoints/intro-checkpoint.ipynb b/docs/.ipynb_checkpoints/intro-checkpoint.ipynb deleted file mode 100644 index 0d7e1de13..000000000 --- a/docs/.ipynb_checkpoints/intro-checkpoint.ipynb +++ /dev/null @@ -1,469 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Hello, KAN!" - ] - }, - { - "cell_type": "markdown", - "id": "59cf5cd0", - "metadata": {}, - "source": [ - "### Kolmogorov-Arnold representation theorem" - ] - }, - { - "cell_type": "markdown", - "id": "f88e5321", - "metadata": {}, - "source": [ - "Kolmogorov-Arnold representation theorem states that if $f$ is a multivariate continuous function\n", - "on a bounded domain, then it can be written as a finite composition of continuous functions of a\n", - "single variable and the binary operation of addition. More specifically, for a smooth $f : [0,1]^n \\to \\mathbb{R}$,\n", - "\n", - "\n", - "$$f(x) = f(x_1,...,x_n)=\\sum_{q=1}^{2n+1}\\Phi_q(\\sum_{p=1}^n \\phi_{q,p}(x_p))$$\n", - "\n", - "where $\\phi_{q,p}:[0,1]\\to\\mathbb{R}$ and $\\Phi_q:\\mathbb{R}\\to\\mathbb{R}$. In a sense, they showed that the only true multivariate function is addition, since every other function can be written using univariate functions and sum. However, this 2-Layer width-$(2n+1)$ Kolmogorov-Arnold representation may not be smooth due to its limited expressive power. We augment its expressive power by generalizing it to arbitrary depths and widths." - ] - }, - { - "cell_type": "markdown", - "id": "ebd8766a", - "metadata": {}, - "source": [ - "### Kolmogorov-Arnold Network (KAN)" - ] - }, - { - "cell_type": "markdown", - "id": "2cf3b1ee", - "metadata": {}, - "source": [ - "The Kolmogorov-Arnold representation can be written in matrix form\n", - "\n", - "$$f(x)={\\bf \\Phi}_{\\rm out}\\circ{\\bf \\Phi}_{\\rm in}\\circ {\\bf x}$$\n", - "\n", - "where \n", - "\n", - "$${\\bf \\Phi}_{\\rm in}= \\begin{pmatrix} \\phi_{1,1}(\\cdot) & \\cdots & \\phi_{1,n}(\\cdot) \\\\ \\vdots & & \\vdots \\\\ \\phi_{2n+1,1}(\\cdot) & \\cdots & \\phi_{2n+1,n}(\\cdot) \\end{pmatrix},\\quad {\\bf \\Phi}_{\\rm out}=\\begin{pmatrix} \\Phi_1(\\cdot) & \\cdots & \\Phi_{2n+1}(\\cdot)\\end{pmatrix}$$" - ] - }, - { - "cell_type": "markdown", - "id": "f6521452", - "metadata": {}, - "source": [ - "We notice that both ${\\bf \\Phi}_{\\rm in}$ and ${\\bf \\Phi}_{\\rm out}$ are special cases of the following function matrix ${\\bf \\Phi}$ (with $n_{\\rm in}$ inputs, and $n_{\\rm out}$ outputs), we call a Kolmogorov-Arnold layer:\n", - "\n", - "$${\\bf \\Phi}= \\begin{pmatrix} \\phi_{1,1}(\\cdot) & \\cdots & \\phi_{1,n_{\\rm in}}(\\cdot) \\\\ \\vdots & & \\vdots \\\\ \\phi_{n_{\\rm out},1}(\\cdot) & \\cdots & \\phi_{n_{\\rm out},n_{\\rm in}}(\\cdot) \\end{pmatrix}$$\n", - "\n", - "${\\bf \\Phi}_{\\rm in}$ corresponds to $n_{\\rm in}=n, n_{\\rm out}=2n+1$, and ${\\bf \\Phi}_{\\rm out}$ corresponds to $n_{\\rm in}=2n+1, n_{\\rm out}=1$." - ] - }, - { - "cell_type": "markdown", - "id": "1b410498", - "metadata": {}, - "source": [ - "After defining the layer, we can construct a Kolmogorov-Arnold network simply by stacking layers! Let's say we have $L$ layers, with the $l^{\\rm th}$ layer ${\\bf \\Phi}_l$ have shape $(n_{l+1}, n_{l})$. Then the whole network is\n", - "\n", - "$${\\rm KAN}({\\bf x})={\\bf \\Phi}_{L-1}\\circ\\cdots \\circ{\\bf \\Phi}_1\\circ{\\bf \\Phi}_0\\circ {\\bf x}$$" - ] - }, - { - "cell_type": "markdown", - "id": "54bbde9a", - "metadata": {}, - "source": [ - "In constrast, a Multi-Layer Perceptron is interleaved by linear layers ${\\bf W}_l$ and nonlinearities $\\sigma$:\n", - "\n", - "$${\\rm MLP}({\\bf x})={\\bf W}_{L-1}\\circ\\sigma\\circ\\cdots\\circ {\\bf W}_1\\circ\\sigma\\circ {\\bf W}_0\\circ {\\bf x}$$" - ] - }, - { - "cell_type": "markdown", - "id": "1c5f7795", - "metadata": {}, - "source": [ - "A KAN can be easily visualized. (1) A KAN is simply stack of KAN layers. (2) Each KAN layer can be visualized as a fully-connected layer, with a 1D function placed on each edge. Let's see an example below." - ] - }, - { - "cell_type": "markdown", - "id": "adcb5f75", - "metadata": {}, - "source": [ - "### Get started with KANs" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Initialize KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)" - ] - }, - { - "cell_type": "markdown", - "id": "3d72e076", - "metadata": {}, - "source": [ - "Create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "46717e8b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "8c6add1d", - "metadata": {}, - "source": [ - "Plot KAN at initialization" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ac76f858", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", - "model.plot(beta=100)" - ] - }, - { - "cell_type": "markdown", - "id": "ddf67e30", - "metadata": {}, - "source": [ - "Train KAN with sparsity regularization" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.57e-01 | test loss: 1.31e-01 | reg: 2.05e+01 : 100%|██| 20/20 [00:18<00:00, 1.06it/s]\n" - ] - } - ], - "source": [ - "# train the model\n", - "model.train(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "Plot trained KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "61d537b7", - "metadata": {}, - "source": [ - "Prune KAN and replot (keep the original shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1269a698", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.prune()\n", - "model.plot(mask=True)" - ] - }, - { - "cell_type": "markdown", - "id": "576856cf", - "metadata": {}, - "source": [ - "Prune KAN and replot (get a smaller shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7fe6fb12", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "bd08ad99", - "metadata": {}, - "source": [ - "Continue training and replot" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "18a2db11", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.74e-03 | test loss: 4.80e-03 | reg: 2.98e+00 : 100%|██| 50/50 [00:07<00:00, 7.03it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "af27aba7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "cf35d505", - "metadata": {}, - "source": [ - "Automatically or manually set activation functions to be symbolic" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b3c0642b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.999987252534279\n", - "fixing (0,1,0) with x^2, r2=0.9999996536741071\n", - "fixing (1,0,0) with exp, r2=0.9999988529417926\n" - ] - } - ], - "source": [ - "mode = \"auto\" # \"manual\"\n", - "\n", - "if mode == \"manual\":\n", - " # manual mode\n", - " model.fix_symbolic(0,0,0,'sin');\n", - " model.fix_symbolic(0,1,0,'x^2');\n", - " model.fix_symbolic(1,0,0,'exp');\n", - "elif mode == \"auto\":\n", - " # automatic mode\n", - " lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", - " model.auto_symbolic(lib=lib)" - ] - }, - { - "cell_type": "markdown", - "id": "821ba616", - "metadata": {}, - "source": [ - "Continue training to almost machine precision" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c0800415", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.02e-10 | test loss: 1.13e-10 | reg: 2.98e+00 : 100%|██| 50/50 [00:02<00:00, 22.59it/s]\n" - ] - } - ], - "source": [ - "model.train(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "markdown", - "id": "e39da499", - "metadata": {}, - "source": [ - "Obtain the symbolic formula" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "bf44f7e0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 e^{1.0 x_{2}^{2} + 1.0 \\sin{\\left(3.14 x_{1} \\right)}}$" - ], - "text/plain": [ - "1.0*exp(1.0*x_2**2 + 1.0*sin(3.14*x_1))" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.symbolic_formula()[0][0]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/.ipynb_checkpoints/intro-checkpoint.rst b/docs/.ipynb_checkpoints/intro-checkpoint.rst deleted file mode 100644 index cafbe96ff..000000000 --- a/docs/.ipynb_checkpoints/intro-checkpoint.rst +++ /dev/null @@ -1,224 +0,0 @@ -.. _hello-kan: - -Hello, KAN! -=========== - -Kolmogorov-Arnold representation theorem -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Kolmogorov-Arnold representation theorem states that if :math:`f` is a -multivariate continuous function on a bounded domain, then it can be -written as a finite composition of continuous functions of a single -variable and the binary operation of addition. More specifically, for a -smooth :math:`f : [0,1]^n \to \mathbb{R}`, - -.. math:: f(x) = f(x_1,...,x_n)=\sum_{q=1}^{2n+1}\Phi_q(\sum_{p=1}^n \phi_{q,p}(x_p)) - -where :math:`\phi_{q,p}:[0,1]\to\mathbb{R}` and -:math:`\Phi_q:\mathbb{R}\to\mathbb{R}`. In a sense, they showed that the -only true multivariate function is addition, since every other function -can be written using univariate functions and sum. However, this 2-Layer -width-:math:`(2n+1)` Kolmogorov-Arnold representation may not be smooth -due to its limited expressive power. We augment its expressive power by -generalizing it to arbitrary depths and widths. - -Kolmogorov-Arnold Network (KAN) -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The Kolmogorov-Arnold representation can be written in matrix form - -.. math:: f(x)={\bf \Phi}_{\rm out}\circ{\bf \Phi}_{\rm in}\circ {\bf x} - -where - -.. math:: {\bf \Phi}_{\rm in}= \begin{pmatrix} \phi_{1,1}(\cdot) & \cdots & \phi_{1,n}(\cdot) \\ \vdots & & \vdots \\ \phi_{2n+1,1}(\cdot) & \cdots & \phi_{2n+1,n}(\cdot) \end{pmatrix},\quad {\bf \Phi}_{\rm out}=\begin{pmatrix} \Phi_1(\cdot) & \cdots & \Phi_{2n+1}(\cdot)\end{pmatrix} - -We notice that both :math:`{\bf \Phi}_{\rm in}` and -:math:`{\bf \Phi}_{\rm out}` are special cases of the following function -matrix :math:`{\bf \Phi}` (with :math:`n_{\rm in}` inputs, and -:math:`n_{\rm out}` outputs), we call a Kolmogorov-Arnold layer: - -.. math:: {\bf \Phi}= \begin{pmatrix} \phi_{1,1}(\cdot) & \cdots & \phi_{1,n_{\rm in}}(\cdot) \\ \vdots & & \vdots \\ \phi_{n_{\rm out},1}(\cdot) & \cdots & \phi_{n_{\rm out},n_{\rm in}}(\cdot) \end{pmatrix} - -:math:`{\bf \Phi}_{\rm in}` corresponds to -:math:`n_{\rm in}=n, n_{\rm out}=2n+1`, and :math:`{\bf \Phi}_{\rm out}` -corresponds to :math:`n_{\rm in}=2n+1, n_{\rm out}=1`. - -After defining the layer, we can construct a Kolmogorov-Arnold network -simply by stacking layers! Let’s say we have :math:`L` layers, with the -:math:`l^{\rm th}` layer :math:`{\bf \Phi}_l` have shape -:math:`(n_{l+1}, n_{l})`. Then the whole network is - -.. math:: {\rm KAN}({\bf x})={\bf \Phi}_{L-1}\circ\cdots \circ{\bf \Phi}_1\circ{\bf \Phi}_0\circ {\bf x} - -In constrast, a Multi-Layer Perceptron is interleaved by linear layers -:math:`{\bf W}_l` and nonlinearities :math:`\sigma`: - -.. math:: {\rm MLP}({\bf x})={\bf W}_{L-1}\circ\sigma\circ\cdots\circ {\bf W}_1\circ\sigma\circ {\bf W}_0\circ {\bf x} - -A KAN can be easily visualized. (1) A KAN is simply stack of KAN layers. -(2) Each KAN layer can be visualized as a fully-connected layer, with a -1D function placed on each edge. Let’s see an example below. - -Get started with KANs -~~~~~~~~~~~~~~~~~~~~~ - -Initialize KAN - -.. code:: ipython3 - - from kan import * - # create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5). - model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - -Create dataset - -.. code:: ipython3 - - # create dataset f(x,y) = exp(sin(pi*x)+y^2) - f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - dataset = create_dataset(f, n_var=2) - dataset['train_input'].shape, dataset['train_label'].shape - - - - -.. parsed-literal:: - - (torch.Size([1000, 2]), torch.Size([1000, 1])) - - - -Plot KAN at initialization - -.. code:: ipython3 - - # plot KAN at initialization - model(dataset['train_input']); - model.plot(beta=100) - - - -.. image:: intro_files/intro_15_0.png - - -Train KAN with sparsity regularization - -.. code:: ipython3 - - # train the model - model.train(dataset, opt="LBFGS", steps=20, lamb=0.01, lamb_entropy=10.); - - -.. parsed-literal:: - - train loss: 1.57e-01 | test loss: 1.31e-01 | reg: 2.05e+01 : 100%|██| 20/20 [00:18<00:00, 1.06it/s] - - -Plot trained KAN - -.. code:: ipython3 - - model.plot() - - - -.. image:: intro_files/intro_19_0.png - - -Prune KAN and replot (keep the original shape) - -.. code:: ipython3 - - model.prune() - model.plot(mask=True) - - - -.. image:: intro_files/intro_21_0.png - - -Prune KAN and replot (get a smaller shape) - -.. code:: ipython3 - - model = model.prune() - model(dataset['train_input']) - model.plot() - - - -.. image:: intro_files/intro_23_0.png - - -Continue training and replot - -.. code:: ipython3 - - model.train(dataset, opt="LBFGS", steps=50); - - -.. parsed-literal:: - - train loss: 4.74e-03 | test loss: 4.80e-03 | reg: 2.98e+00 : 100%|██| 50/50 [00:07<00:00, 7.03it/s] - - -.. code:: ipython3 - - model.plot() - - - -.. image:: intro_files/intro_26_0.png - - -Automatically or manually set activation functions to be symbolic - -.. code:: ipython3 - - mode = "auto" # "manual" - - if mode == "manual": - # manual mode - model.fix_symbolic(0,0,0,'sin'); - model.fix_symbolic(0,1,0,'x^2'); - model.fix_symbolic(1,0,0,'exp'); - elif mode == "auto": - # automatic mode - lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs'] - model.auto_symbolic(lib=lib) - - -.. parsed-literal:: - - fixing (0,0,0) with sin, r2=0.999987252534279 - fixing (0,1,0) with x^2, r2=0.9999996536741071 - fixing (1,0,0) with exp, r2=0.9999988529417926 - - -Continue training to almost machine precision - -.. code:: ipython3 - - model.train(dataset, opt="LBFGS", steps=50); - - -.. parsed-literal:: - - train loss: 2.02e-10 | test loss: 1.13e-10 | reg: 2.98e+00 : 100%|██| 50/50 [00:02<00:00, 22.59it/s] - - -Obtain the symbolic formula - -.. code:: ipython3 - - model.symbolic_formula()[0][0] - - - - -.. math:: - - \displaystyle 1.0 e^{1.0 x_{2}^{2} + 1.0 \sin{\left(3.14 x_{1} \right)}} - - diff --git a/docs/.ipynb_checkpoints/kan-checkpoint.rst b/docs/.ipynb_checkpoints/kan-checkpoint.rst deleted file mode 100644 index 9aeff0e2e..000000000 --- a/docs/.ipynb_checkpoints/kan-checkpoint.rst +++ /dev/null @@ -1,66 +0,0 @@ -kan package -=========== - -kan.KAN module --------------- - -.. automodule:: kan.MultKAN - :members: - :undoc-members: - :show-inheritance: - -kan.KANLayer module -------------------- - -.. automodule:: kan.KANLayer - :members: - :undoc-members: - :show-inheritance: - -kan.LBFGS module ----------------- - -.. automodule:: kan.LBFGS - :members: - :undoc-members: - :show-inheritance: - -kan.Symbolic\_KANLayer module ------------------------------ - -.. automodule:: kan.Symbolic_KANLayer - :members: - :undoc-members: - :show-inheritance: - -kan.spline module ------------------ - -.. automodule:: kan.spline - :members: - :undoc-members: - :show-inheritance: - -kan.utils module ----------------- - -.. automodule:: kan.utils - :members: - :undoc-members: - :show-inheritance: - -kan.compiler module -------------------- - -.. automodule:: kan.compiler - :members: - :undoc-members: - :show-inheritance: - -kan.hypothesis module ---------------------- - -.. automodule:: kan.hypothesis - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/.ipynb_checkpoints/kan_plot-checkpoint.png b/docs/.ipynb_checkpoints/kan_plot-checkpoint.png deleted file mode 100644 index a630bba26..000000000 Binary files a/docs/.ipynb_checkpoints/kan_plot-checkpoint.png and /dev/null differ diff --git a/docs/.ipynb_checkpoints/make-checkpoint.bat b/docs/.ipynb_checkpoints/make-checkpoint.bat deleted file mode 100644 index 32bb24529..000000000 --- a/docs/.ipynb_checkpoints/make-checkpoint.bat +++ /dev/null @@ -1,35 +0,0 @@ -@ECHO OFF - -pushd %~dp0 - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set SOURCEDIR=. -set BUILDDIR=_build - -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.https://www.sphinx-doc.org/ - exit /b 1 -) - -if "%1" == "" goto help - -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% -goto end - -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% - -:end -popd diff --git a/docs/.ipynb_checkpoints/modules-checkpoint.rst b/docs/.ipynb_checkpoints/modules-checkpoint.rst deleted file mode 100644 index 7c3ced85d..000000000 --- a/docs/.ipynb_checkpoints/modules-checkpoint.rst +++ /dev/null @@ -1,9 +0,0 @@ -.. _api: - -API -=== - -.. toctree:: - :maxdepth: 4 - - kan diff --git a/docs/.ipynb_checkpoints/physics-checkpoint.rst b/docs/.ipynb_checkpoints/physics-checkpoint.rst deleted file mode 100644 index 5cf28dbbe..000000000 --- a/docs/.ipynb_checkpoints/physics-checkpoint.rst +++ /dev/null @@ -1,18 +0,0 @@ -.. _physics: - -Physics -------- - -.. toctree:: - :maxdepth: 1 - - Physics/Physics_1_Lagrangian.rst - Physics/Physics_2A_conservation_law.rst - Physics/Physics_2B_conservation_law_2D.rst - Physics/Physics_3_blackhole.rst - Physics/Physics_4A_constitutive_laws_P11.rst - Physics/Physics_4B_constitutive_laws_P12_with_prior.rst - Physics/Physics_4C_constitutive_laws_P12_without_prior.rst - - - \ No newline at end of file diff --git a/docs/API_demo/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.rst b/docs/API_demo/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.rst deleted file mode 100644 index 16db62889..000000000 --- a/docs/API_demo/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.rst +++ /dev/null @@ -1,231 +0,0 @@ -API 6: Training Hyperparamters -============================== - -Regularization helps interpretability by making KANs sparser. This may -require some hyperparamter tuning. Let’s see how hyperparameters can -affect training - -Load KAN and create_dataset - -.. code:: ipython3 - - from kan import * - import torch - - device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - print(device) - - f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - dataset = create_dataset(f, n_var=2, device=device) - dataset['train_input'].shape, dataset['train_label'].shape - - -.. parsed-literal:: - - cuda - - - - -.. parsed-literal:: - - (torch.Size([1000, 2]), torch.Size([1000, 1])) - - - -Default setup - -.. code:: ipython3 - - # train the model - model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=0.01); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 3.34e-02 | test_loss: 3.29e-02 | reg: 4.93e+00 | : 100%|█| 20/20 [00:05<00:00, 3.73it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_4_3.png - - -Parameter 1: :math:`\lambda`, overall penalty strength. -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Previously :math:`\lambda=0.01`, now we try different :math:`\lambda`. - -:math:`\lambda=0` - -.. code:: ipython3 - - # train the model - model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=0.00); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 5.51e-03 | test_loss: 6.14e-03 | reg: 1.52e+01 | : 100%|█| 20/20 [00:03<00:00, 5.84it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_7_3.png - - -:math:`\lambda=1` - -.. code:: ipython3 - - # train the model - model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=1.0); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 1.70e+00 | test_loss: 1.73e+00 | reg: 1.08e+01 | : 100%|█| 20/20 [00:04<00:00, 4.59it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_9_3.png - - -Parameter 2: (relative) penalty strength of entropy :math:`\lambda_{\rm ent}`. -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The absolute magnitude is :math:`\lambda\lambda_{\rm ent}`. Previously -we set :math:`\lambda=0.1` and :math:`\lambda_{\rm ent}=2.0` (default). -Below we fix :math:`\lambda=0.1` and vary :math:`\lambda_{\rm ent}`. - -:math:`\lambda_{\rm ent}=0.0` - -.. code:: ipython3 - - # train the model - model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=0.01, lamb_entropy=0.0); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 4.20e-02 | test_loss: 4.50e-02 | reg: 2.57e+00 | : 100%|█| 20/20 [00:04<00:00, 4.68it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_12_3.png - - -:math:`\lambda_{\rm ent}=10.` - -.. code:: ipython3 - - # train the model - model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=0.01, lamb_entropy=10.0); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 7.83e-02 | test_loss: 7.74e-02 | reg: 1.54e+01 | : 100%|█| 20/20 [00:05<00:00, 3.77it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_14_3.png - - -Parameter 3: seed. -~~~~~~~~~~~~~~~~~~ - -Previously we use seed = 1. Below we vary seed. - -:math:`{\rm seed} = 42` - -.. code:: ipython3 - - model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device) - model.fit(dataset, opt="LBFGS", steps=20, lamb=0.01); - model.plot() - - -.. parsed-literal:: - - checkpoint directory created: ./model - saving model version 0.0 - - -.. parsed-literal:: - - | train_loss: 5.67e-02 | test_loss: 5.72e-02 | reg: 5.81e+00 | : 100%|█| 20/20 [00:04<00:00, 4.81it - - -.. parsed-literal:: - - saving model version 0.1 - - - -.. image:: API_6_training_hyperparameter_files/API_6_training_hyperparameter_17_3.png - - diff --git a/docs/API_demo/API_10_device.ipynb b/docs/API_demo/API_10_device.ipynb index 37be025c3..d34034c97 100644 --- a/docs/API_demo/API_10_device.ipynb +++ b/docs/API_demo/API_10_device.ipynb @@ -29,11 +29,11 @@ "import torch\n", "\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "#device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "device = 'cpu'\n", + "# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = \"cpu\"\n", "print(device)" ] }, @@ -67,13 +67,27 @@ } ], "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 100, 100, 100, 1], grid=3, k=3, seed=0).to(device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=50,\n", + " lamb=1e-3,\n", + " lamb_entropy=5.0,\n", + " update_grid=False,\n", + ");" ] }, { @@ -99,7 +113,7 @@ } ], "source": [ - "device = 'cuda'\n", + "device = \"cuda\"\n", "print(device)" ] }, @@ -133,13 +147,27 @@ } ], "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 100, 100, 100, 1], grid=3, k=3, seed=0).to(device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=50,\n", + " lamb=1e-3,\n", + " lamb_entropy=5.0,\n", + " update_grid=False,\n", + ");" ] }, { diff --git a/docs/API_demo/API_11_create_dataset.ipynb b/docs/API_demo/API_11_create_dataset.ipynb index af8190ef6..8468c44b6 100644 --- a/docs/API_demo/API_11_create_dataset.ipynb +++ b/docs/API_demo/API_11_create_dataset.ipynb @@ -52,12 +52,12 @@ "from kan.utils import create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: x[:,[0]] * x[:,[1]]\n", + "f = lambda x: x[:, [0]] * x[:, [1]]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" + "dataset[\"train_label\"].shape" ] }, { @@ -86,9 +86,9 @@ } ], "source": [ - "f = lambda x: x[:,0] * x[:,1]\n", + "f = lambda x: x[:, 0] * x[:, 1]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" + "dataset[\"train_label\"].shape" ] }, { @@ -118,8 +118,8 @@ ], "source": [ "f = lambda x: x[0] * x[1]\n", - "dataset = create_dataset(f, n_var=2, f_mode='row', device=device)\n", - "dataset['train_label'].shape" + "dataset = create_dataset(f, n_var=2, f_mode=\"row\", device=device)\n", + "dataset[\"train_label\"].shape" ] }, { @@ -140,8 +140,8 @@ "import torch\n", "from kan.utils import create_dataset_from_data\n", "\n", - "x = torch.rand(100,2)\n", - "y = torch.rand(100,1)\n", + "x = torch.rand(100, 2)\n", + "y = torch.rand(100, 1)\n", "dataset = create_dataset_from_data(x, y, device=device)" ] }, diff --git a/docs/API_demo/API_12_checkpoint_save_load_model.ipynb b/docs/API_demo/API_12_checkpoint_save_load_model.ipynb index 476f6f054..62ec0c3cc 100644 --- a/docs/API_demo/API_12_checkpoint_save_load_model.ipynb +++ b/docs/API_demo/API_12_checkpoint_save_load_model.ipynb @@ -54,12 +54,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, auto_save=True, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, auto_save=True, device=device)\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -133,7 +133,7 @@ } ], "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, @@ -208,11 +208,11 @@ ], "source": [ "# revert to version 0.1 (if continuing)\n", - "model = model.rewind('0.1')\n", + "model = model.rewind(\"0.1\")\n", "\n", "# revert to version 0.1 (if starting from scratch)\n", - "#model = KAN.loadckpt('./model' + '0.1')\n", - "#model.get_act(dataset)\n", + "# model = KAN.loadckpt('./model' + '0.1')\n", + "# model.get_act(dataset)\n", "\n", "model.plot()" ] @@ -257,7 +257,7 @@ } ], "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=2);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=2)\n", "model.plot()" ] } diff --git a/docs/API_demo/API_1_indexing.ipynb b/docs/API_demo/API_1_indexing.ipynb index f27b7389d..c5b9b0d1f 100644 --- a/docs/API_demo/API_1_indexing.ipynb +++ b/docs/API_demo/API_1_indexing.ipynb @@ -37,12 +37,12 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,3,2,1], noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x);\n", + "model = KAN(width=[2, 3, 2, 1], noise_scale=0.3, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x)\n", "beta = 100\n", "model.plot(beta=beta)\n", "# [2,3,2,1] means 2 input nodes\n", @@ -94,9 +94,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'sin')\n", + "model.fix_symbolic(0, 0, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,0)" + "model.unfix_symbolic(0, 0, 0)" ] }, { @@ -126,9 +126,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,1,'sin')\n", + "model.fix_symbolic(0, 0, 1, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,1)" + "model.unfix_symbolic(0, 0, 1)" ] }, { @@ -158,9 +158,9 @@ } ], "source": [ - "model.fix_symbolic(0,1,0,'sin')\n", + "model.fix_symbolic(0, 1, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,1,0)" + "model.unfix_symbolic(0, 1, 0)" ] }, { @@ -190,9 +190,9 @@ } ], "source": [ - "model.fix_symbolic(1,0,0,'sin')\n", + "model.fix_symbolic(1, 0, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(1,0,0)" + "model.unfix_symbolic(1, 0, 0)" ] }, { @@ -222,9 +222,9 @@ } ], "source": [ - "model.fix_symbolic(2,1,0,'sin')\n", + "model.fix_symbolic(2, 1, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(2,1,0)" + "model.unfix_symbolic(2, 1, 0)" ] }, { @@ -262,7 +262,7 @@ } ], "source": [ - "model.remove_node(1,0)" + "model.remove_node(1, 0)" ] }, { @@ -303,7 +303,7 @@ } ], "source": [ - "model.remove_node(2,1)" + "model.remove_node(2, 1)" ] }, { @@ -344,7 +344,7 @@ } ], "source": [ - "model.remove_node(1,2)" + "model.remove_node(1, 2)" ] }, { @@ -401,11 +401,11 @@ "# KAN spline layers are refererred to as act_fun\n", "# KAN symbolic layers are referred to as symbolic_fun\n", "\n", - "model = KAN(width=[2,3,5,1])\n", + "model = KAN(width=[2, 3, 5, 1])\n", "\n", "i = 0\n", - "model.act_fun[i] # => KAN Layer (Spline)\n", - "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", + "model.act_fun[i] # => KAN Layer (Spline)\n", + "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", "\n", "for i in range(3):\n", " print(model.act_fun[i].in_dim, model.act_fun[i].out_dim)\n", diff --git a/docs/API_demo/API_2_plotting.ipynb b/docs/API_demo/API_2_plotting.ipynb index f9fd074b6..71bb2088a 100644 --- a/docs/API_demo/API_2_plotting.ipynb +++ b/docs/API_demo/API_2_plotting.ipynb @@ -45,16 +45,16 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -84,7 +84,7 @@ ], "source": [ "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=100)" ] }, @@ -107,7 +107,7 @@ ], "source": [ "# if you want to add variable names and title\n", - "model.plot(beta=100, in_vars=[r'$\\alpha$', 'x'], out_vars=['y'], title = 'My KAN')" + "model.plot(beta=100, in_vars=[r\"$\\alpha$\", \"x\"], out_vars=[\"y\"], title=\"My KAN\")" ] }, { @@ -248,7 +248,7 @@ } ], "source": [ - "model.plot(metric='forward_n', beta=100)" + "model.plot(metric=\"forward_n\", beta=100)" ] }, { @@ -269,7 +269,7 @@ } ], "source": [ - "model.plot(metric='forward_u', beta=100)" + "model.plot(metric=\"forward_u\", beta=100)" ] }, { @@ -290,7 +290,7 @@ } ], "source": [ - "model.plot(metric='backward', beta=100)" + "model.plot(metric=\"backward\", beta=100)" ] }, { @@ -456,7 +456,7 @@ } ], "source": [ - "model.get_act(dataset['train_input'][:20])\n", + "model.get_act(dataset[\"train_input\"][:20])\n", "model.plot(sample=True)" ] }, @@ -494,7 +494,7 @@ } ], "source": [ - "model.fix_symbolic(0,1,0,'x^2')" + "model.fix_symbolic(0, 1, 0, \"x^2\")" ] }, { @@ -533,7 +533,7 @@ "metadata": {}, "outputs": [], "source": [ - "model.set_mode(0,1,0,mode='ns')\n" + "model.set_mode(0, 1, 0, mode=\"ns\")" ] }, { diff --git a/docs/API_demo/API_3_extract_activations.ipynb b/docs/API_demo/API_3_extract_activations.ipynb index 8933c83ad..b63249265 100644 --- a/docs/API_demo/API_3_extract_activations.ipynb +++ b/docs/API_demo/API_3_extract_activations.ipynb @@ -38,14 +38,13 @@ ], "source": [ "from kan import *\n", - "import matplotlib.pyplot as plt\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", "model(x)\n", "model.plot(beta=100)" ] @@ -71,7 +70,7 @@ "l = 0\n", "i = 0\n", "j = 3\n", - "x, y = model.get_fun(l,i,j)" + "x, y = model.get_fun(l, i, j)" ] }, { @@ -111,7 +110,7 @@ } ], "source": [ - "model.get_range(l,i,j)" + "model.get_range(l, i, j)" ] }, { diff --git a/docs/API_demo/API_4_initialization.ipynb b/docs/API_demo/API_4_initialization.ipynb index 77c0825e1..7973d353d 100644 --- a/docs/API_demo/API_4_initialization.ipynb +++ b/docs/API_demo/API_4_initialization.ipynb @@ -58,15 +58,15 @@ } ], "source": [ - "from kan import KAN, create_dataset\n", + "from kan import KAN\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -104,9 +104,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, base_fun = 'identity', device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, base_fun=\"identity\", device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -144,9 +144,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, noise_scale=0.3, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -176,9 +176,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=10., device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, noise_scale=10.0, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -216,9 +216,17 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, scale_base_mu=5, scale_base_sigma=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(\n", + " width=[2, 5, 1],\n", + " grid=5,\n", + " k=3,\n", + " seed=0,\n", + " scale_base_mu=5,\n", + " scale_base_sigma=0,\n", + " device=device,\n", + ")\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -248,9 +256,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, sparse_init=True, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, sparse_init=True, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, diff --git a/docs/API_demo/API_5_grid.ipynb b/docs/API_demo/API_5_grid.ipynb index 655b1059d..b783a4eed 100644 --- a/docs/API_demo/API_5_grid.ipynb +++ b/docs/API_demo/API_5_grid.ipynb @@ -54,20 +54,20 @@ "# Suppose we have grid in [-1,1] with G intervals, spline order k\n", "G = 5\n", "k = 3\n", - "grid = torch.linspace(-1,1,steps=G+1)[None,:]\n", + "grid = torch.linspace(-1, 1, steps=G + 1)[None, :]\n", "grid = extend_grid(grid, k_extend=k)\n", "\n", "# and we have sample range in [-1,1]\n", - "x = torch.linspace(-1,1,steps=1001)[None,:]\n", + "x = torch.linspace(-1, 1, steps=1001)[None, :]\n", "\n", "basis = B_batch(x, grid, k=k)\n", "\n", - "for i in range(G+k):\n", - " plt.plot(x[0].detach().numpy(), basis[0,:,i].detach().numpy())\n", - " \n", - "plt.legend(['B_{}(x)'.format(i) for i in np.arange(G+k)])\n", - "plt.xlabel('x')\n", - "plt.ylabel('B_i(x)')" + "for i in range(G + k):\n", + " plt.plot(x[0].detach().numpy(), basis[0, :, i].detach().numpy())\n", + "\n", + "plt.legend([\"B_{}(x)\".format(i) for i in np.arange(G + k)])\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"B_i(x)\")" ] }, { @@ -106,18 +106,18 @@ "source": [ "from kan import KAN\n", "\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", "# obtain coefficients c_i\n", "model.act_fun[0].coef\n", - "assert(model.act_fun[0].coef[0].shape[1] == G+k)\n", + "assert model.act_fun[0].coef[0].shape[1] == G + k\n", "\n", "# the model forward\n", - "model_output = model(x[0][:,None])\n", + "model_output = model(x[0][:, None])\n", "\n", "# spline output\n", - "spline_output = torch.einsum('j,ij->i',model.act_fun[0].coef[0][0], basis[0])[:,None]\n", + "spline_output = torch.einsum(\"j,ij->i\", model.act_fun[0].coef[0][0], basis[0])[:, None]\n", "\n", - "torch.mean((model_output - spline_output)**2)" + "torch.mean((model_output - spline_output) ** 2)" ] }, { @@ -147,10 +147,12 @@ ], "source": [ "# residual output\n", - "residual_output = torch.nn.SiLU()(x[0][:,None])\n", + "residual_output = torch.nn.SiLU()(x[0][:, None])\n", "scale_base = model.act_fun[0].scale_base\n", "scale_sp = model.act_fun[0].scale_sp\n", - "torch.mean((model_output - (scale_base * residual_output + scale_sp * spline_output))**2)" + "torch.mean(\n", + " (model_output - (scale_base * residual_output + scale_sp * spline_output)) ** 2\n", + ")" ] }, { @@ -182,11 +184,13 @@ } ], "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-10,10,steps = 1001)[:,None]\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.linspace(-10, 10, steps=1001)[:, None]\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -211,11 +215,13 @@ } ], "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-0.5,0.5,steps = 1001)[:,None]\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.linspace(-0.5, 0.5, steps=1001)[:, None]\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -249,11 +255,13 @@ ], "source": [ "# uniform grid\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.normal(0, 1, size=(1000, 1))\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -279,11 +287,13 @@ ], "source": [ "# adaptive grid based on sample distribution\n", - "model = KAN(width=[1,1], grid=G, k=k, grid_eps = 0.)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", + "model = KAN(width=[1, 1], grid=G, k=k, grid_eps=0.0)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.normal(0, 1, size=(1000, 1))\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { diff --git a/docs/API_demo/API_6_training_hyperparameter.ipynb b/docs/API_demo/API_6_training_hyperparameter.ipynb index 11c12484f..5d22f26b8 100644 --- a/docs/API_demo/API_6_training_hyperparameter.ipynb +++ b/docs/API_demo/API_6_training_hyperparameter.ipynb @@ -46,12 +46,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -103,8 +103,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, @@ -167,8 +167,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.00);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.00)\n", "model.plot()" ] }, @@ -221,8 +221,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1.0)\n", "model.plot()" ] }, @@ -285,8 +285,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=0.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=0.0)\n", "model.plot()" ] }, @@ -339,8 +339,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0)\n", "model.plot()" ] }, @@ -402,8 +402,8 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=42, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, diff --git a/docs/API_demo/API_7_pruning.ipynb b/docs/API_demo/API_7_pruning.ipynb index 2b175b1a5..1b0961768 100644 --- a/docs/API_demo/API_7_pruning.ipynb +++ b/docs/API_demo/API_7_pruning.ipynb @@ -61,20 +61,20 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -103,13 +103,13 @@ } ], "source": [ - "mode = 'auto'\n", + "mode = \"auto\"\n", "\n", - "if mode == 'auto':\n", + "if mode == \"auto\":\n", " # automatic\n", - " model = model.prune_node(threshold=1e-2) # by default the threshold is 1e-2\n", + " model = model.prune_node(threshold=1e-2) # by default the threshold is 1e-2\n", " model.plot()\n", - "elif mode == 'manual':\n", + "elif mode == \"manual\":\n", " # manual\n", " model = model.prune_node(active_neurons_id=[[0]])" ] @@ -163,17 +163,18 @@ ], "source": [ "from kan import *\n", + "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=6, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=6, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -273,17 +274,18 @@ ], "source": [ "from kan import *\n", + "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, diff --git a/docs/API_demo/API_8_regularization.ipynb b/docs/API_demo/API_8_regularization.ipynb index 3e8faa423..170dc0d76 100644 --- a/docs/API_demo/API_8_regularization.ipynb +++ b/docs/API_demo/API_8_regularization.ipynb @@ -46,12 +46,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -108,12 +108,14 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_n'); # default\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_sum');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_u'); \n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_backward');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='node_backward');\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", + "model.fit(\n", + " dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric=\"edge_forward_spline_n\"\n", + ") # default\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_sum');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_u');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_backward');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='node_backward');\n", "model.plot()" ] }, @@ -146,9 +148,9 @@ } ], "source": [ - "model.plot(metric='forward_u')\n", - "#model.plot(metric='forward_n')\n", - "#model.plot(metric='backward') # default" + "model.plot(metric=\"forward_u\")\n", + "# model.plot(metric='forward_n')\n", + "# model.plot(metric='backward') # default" ] }, { diff --git a/docs/API_demo/API_9_video.ipynb b/docs/API_demo/API_9_video.ipynb index c5a723c9b..e414de35c 100644 --- a/docs/API_demo/API_9_video.ipynb +++ b/docs/API_demo/API_9_video.ipynb @@ -53,22 +53,36 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 2, 1, 1], grid=3, k=3, seed=1, device=device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", "\n", - "image_folder = 'video_img'\n", + "image_folder = \"video_img\"\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"LBFGS\", steps=5, lamb=0.001, lamb_entropy=2., save_fig=True, beta=10, \n", - " in_vars=[r'$x_1$', r'$x_2$', r'$x_3$', r'$x_4$'],\n", - " out_vars=[r'${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$'],\n", - " img_folder=image_folder);\n" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"LBFGS\",\n", + " steps=5,\n", + " lamb=0.001,\n", + " lamb_entropy=2.0,\n", + " save_fig=True,\n", + " beta=10,\n", + " in_vars=[r\"$x_1$\", r\"$x_2$\", r\"$x_3$\", r\"$x_4$\"],\n", + " out_vars=[r\"${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$\"],\n", + " img_folder=image_folder,\n", + ");" ] }, { @@ -105,24 +119,26 @@ "source": [ "import os\n", "import numpy as np\n", - "import moviepy.video.io.ImageSequenceClip # moviepy == 1.0.3\n", + "import moviepy.video.io.ImageSequenceClip # moviepy == 1.0.3\n", "\n", - "video_name='video'\n", - "fps=5\n", + "video_name = \"video\"\n", + "fps = 5\n", "\n", "fps = fps\n", "files = os.listdir(image_folder)\n", "train_index = []\n", "for file in files:\n", - " if file[0].isdigit() and file.endswith('.jpg'):\n", + " if file[0].isdigit() and file.endswith(\".jpg\"):\n", " train_index.append(int(file[:-4]))\n", "\n", "train_index = np.sort(train_index)\n", "\n", - "image_files = [image_folder+'/'+str(train_index[index])+'.jpg' for index in train_index]\n", + "image_files = [\n", + " image_folder + \"/\" + str(train_index[index]) + \".jpg\" for index in train_index\n", + "]\n", "\n", "clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps=fps)\n", - "clip.write_videofile(video_name+'.mp4')" + "clip.write_videofile(video_name + \".mp4\")" ] }, { diff --git a/docs/Community/Community_1_physics_informed_kan.ipynb b/docs/Community/Community_1_physics_informed_kan.ipynb index a100250a0..68139f066 100644 --- a/docs/Community/Community_1_physics_informed_kan.ipynb +++ b/docs/Community/Community_1_physics_informed_kan.ipynb @@ -54,26 +54,35 @@ "\n", "x = torch.linspace(0, width, num_points_x, device=device, requires_grad=False)\n", "y = torch.linspace(0, height, num_points_y, device=device, requires_grad=False)\n", - "X, Y = torch.meshgrid(x, y, indexing='ij')\n", + "X, Y = torch.meshgrid(x, y, indexing=\"ij\")\n", "coordinates = torch.stack([X.flatten(), Y.flatten()], dim=1).to(device)\n", "coordinates.requires_grad = True # Ensure coordinates require grad\n", "\n", - "model = KAN(width=[2,3,3, 3], grid=5, k=10, grid_eps=1.0,\n", - " noise_scale_base=0.25).to(device)\n", + "model = KAN(width=[2, 3, 3, 3], grid=5, k=10, grid_eps=1.0, noise_scale_base=0.25).to(\n", + " device\n", + ")\n", + "\n", "\n", "def batch_jacobian(func, x, create_graph=False):\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1, 0, 2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "def batch_hessian(func, x):\n", " jacobian = batch_jacobian(func, x, create_graph=True)\n", " hessians = []\n", " for i in range(jacobian.size(1)):\n", - " grad = autograd.grad(jacobian[:, i].sum(), x, create_graph=True, retain_graph=True)[0]\n", + " grad = autograd.grad(\n", + " jacobian[:, i].sum(), x, create_graph=True, retain_graph=True\n", + " )[0]\n", " hessians.append(grad.unsqueeze(1))\n", " return torch.cat(hessians, dim=1)\n", "\n", + "\n", "def navier_stokes_residuals(coords):\n", " coords = coords.clone().detach().requires_grad_(True) # Ensure coords require grad\n", " y_pred = model(coords)\n", @@ -93,27 +102,37 @@ " y_momentum = u * v_x + v * v_y + (1 / rho) * p_y - nu * (v_xx + v_yy)\n", "\n", " no_slip_mask = (coords[:, 1] == 0) | (coords[:, 1] == height)\n", - " inlet_mask = (coords[:, 0] == 0)\n", - " outlet_mask = (coords[:, 0] == width)\n", + " inlet_mask = coords[:, 0] == 0\n", + " outlet_mask = coords[:, 0] == width\n", "\n", " no_slip_loss = torch.mean(u[no_slip_mask] ** 2 + v[no_slip_mask] ** 2)\n", " inlet_loss = torch.mean((u[inlet_mask] - 1) ** 2)\n", " outlet_pressure_loss = torch.mean(p[outlet_mask] ** 2)\n", "\n", " bc_loss = no_slip_loss + inlet_loss + outlet_pressure_loss\n", - " total_loss = torch.mean(continuity ** 2 + x_momentum ** 2 + y_momentum ** 2) + bc_loss\n", + " total_loss = torch.mean(continuity**2 + x_momentum**2 + y_momentum**2) + bc_loss\n", " return total_loss\n", "\n", + "\n", "writer = SummaryWriter()\n", "\n", + "\n", "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1,\n", - " history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - " \n", - " steps = 200 # 20 steps are enough\n", - " pbar = tqdm(range(steps), desc='Training Progress')\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", + "\n", + " steps = 200 # 20 steps are enough\n", + " pbar = tqdm(range(steps), desc=\"Training Progress\")\n", "\n", " for step in pbar:\n", + "\n", " def closure():\n", " optimizer.zero_grad()\n", " loss = navier_stokes_residuals(coordinates)\n", @@ -123,13 +142,13 @@ " optimizer.step(closure)\n", " if step % 5 == 0:\n", " current_loss = closure().item()\n", - " pbar.set_description(\"Step: %d | Loss: %.3f\" %\n", - " (step, current_loss))\n", - " writer.add_scalar('Loss/train', current_loss, step)\n", + " pbar.set_description(\"Step: %d | Loss: %.3f\" % (step, current_loss))\n", + " writer.add_scalar(\"Loss/train\", current_loss, step)\n", + "\n", "\n", "train()\n", "\n", - "writer.close()\n" + "writer.close()" ] }, { @@ -149,22 +168,20 @@ } ], "source": [ - "u_pred = model(coordinates)[:, 0].detach().reshape(\n", - " num_points_x, num_points_y).T\n", + "u_pred = model(coordinates)[:, 0].detach().reshape(num_points_x, num_points_y).T\n", "\n", - "v_pred = model(coordinates)[:, 1].detach().reshape(\n", - " num_points_x, num_points_y).T\n", + "v_pred = model(coordinates)[:, 1].detach().reshape(num_points_x, num_points_y).T\n", "\n", "\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", + "magnitude = torch.sqrt(u_pred**2 + v_pred**2)\n", "\n", "plt.figure(figsize=(10, 5)) # Set the figure size as needed\n", - "plt.imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", + "plt.imshow(magnitude, extent=(0, width, 0, height), origin=\"lower\", cmap=\"viridis\")\n", "plt.colorbar() # Add a colorbar to show the magnitude scale\n", - "plt.title('Velocity Magnitude Contour')\n", - "plt.xlabel('Width')\n", - "plt.ylabel('Height')\n", - "plt.axis('equal') # Ensure the plot has equal scaling\n", + "plt.title(\"Velocity Magnitude Contour\")\n", + "plt.xlabel(\"Width\")\n", + "plt.ylabel(\"Height\")\n", + "plt.axis(\"equal\") # Ensure the plot has equal scaling\n", "plt.tight_layout() # Adjust layout to prevent overlap\n", "plt.show()" ] @@ -192,42 +209,50 @@ "p_pred = model(coordinates)[:, 2].detach().reshape(num_points_x, num_points_y).T\n", "\n", "# Velocity Magnitude\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", + "magnitude = torch.sqrt(u_pred**2 + v_pred**2)\n", "\n", "# Plotting all subplots\n", "fig, axs = plt.subplots(2, 2, figsize=(15, 10))\n", "\n", "# Velocity Magnitude\n", - "im0 = axs[0, 0].imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", + "im0 = axs[0, 0].imshow(\n", + " magnitude, extent=(0, width, 0, height), origin=\"lower\", cmap=\"viridis\"\n", + ")\n", "fig.colorbar(im0, ax=axs[0, 0])\n", - "axs[0, 0].set_title('Velocity Magnitude Contour')\n", - "axs[0, 0].set_xlabel('Width')\n", - "axs[0, 0].set_ylabel('Height')\n", - "axs[0, 0].axis('equal')\n", + "axs[0, 0].set_title(\"Velocity Magnitude Contour\")\n", + "axs[0, 0].set_xlabel(\"Width\")\n", + "axs[0, 0].set_ylabel(\"Height\")\n", + "axs[0, 0].axis(\"equal\")\n", "\n", "# u Component\n", - "im1 = axs[0, 1].imshow(u_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im1 = axs[0, 1].imshow(\n", + " u_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im1, ax=axs[0, 1])\n", - "axs[0, 1].set_title('u Component')\n", - "axs[0, 1].set_xlabel('Width')\n", - "axs[0, 1].set_ylabel('Height')\n", - "axs[0, 1].axis('equal')\n", + "axs[0, 1].set_title(\"u Component\")\n", + "axs[0, 1].set_xlabel(\"Width\")\n", + "axs[0, 1].set_ylabel(\"Height\")\n", + "axs[0, 1].axis(\"equal\")\n", "\n", "# v Component\n", - "im2 = axs[1, 0].imshow(v_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im2 = axs[1, 0].imshow(\n", + " v_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im2, ax=axs[1, 0])\n", - "axs[1, 0].set_title('v Component')\n", - "axs[1, 0].set_xlabel('Width')\n", - "axs[1, 0].set_ylabel('Height')\n", - "axs[1, 0].axis('equal')\n", + "axs[1, 0].set_title(\"v Component\")\n", + "axs[1, 0].set_xlabel(\"Width\")\n", + "axs[1, 0].set_ylabel(\"Height\")\n", + "axs[1, 0].axis(\"equal\")\n", "\n", "# Pressure\n", - "im3 = axs[1, 1].imshow(p_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im3 = axs[1, 1].imshow(\n", + " p_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im3, ax=axs[1, 1])\n", - "axs[1, 1].set_title('Pressure')\n", - "axs[1, 1].set_xlabel('Width')\n", - "axs[1, 1].set_ylabel('Height')\n", - "axs[1, 1].axis('equal')\n", + "axs[1, 1].set_title(\"Pressure\")\n", + "axs[1, 1].set_xlabel(\"Width\")\n", + "axs[1, 1].set_ylabel(\"Height\")\n", + "axs[1, 1].axis(\"equal\")\n", "\n", "plt.tight_layout() # Adjust layout to prevent overlap\n", "plt.show()" diff --git a/docs/Community/Community_2_protein_sequence_classification.ipynb b/docs/Community/Community_2_protein_sequence_classification.ipynb index 99c734517..f16cad513 100644 --- a/docs/Community/Community_2_protein_sequence_classification.ipynb +++ b/docs/Community/Community_2_protein_sequence_classification.ipynb @@ -53,10 +53,10 @@ "outputs": [], "source": [ "# Hyperparameters\n", - "PROTEIN_WINDOW_SIZE = 5 \n", + "PROTEIN_WINDOW_SIZE = 5\n", "\n", "# define the universe of possible input amino acids, ie. vocab list\n", - "aa_list = 'ARNDCQEGHILKMFPSTWYVX'" + "aa_list = \"ARNDCQEGHILKMFPSTWYVX\"" ] }, { @@ -78,10 +78,10 @@ " \"\"\"\n", " # Create a dictionary mapping amino acids to indices\n", " aa_to_index = {aa: i for i, aa in enumerate(aa_list)}\n", - " \n", + "\n", " # Initialize an array of zeros with shape (sequence_length, alphabet_length)\n", " encoding = np.zeros((len(protein_sequence), len(aa_list)))\n", - " \n", + "\n", " # Iterate over the protein sequence and set the corresponding index to 1\n", " for i, aa in enumerate(protein_sequence):\n", " if aa in aa_to_index:\n", @@ -89,7 +89,7 @@ " else:\n", " # If the amino acid is not in the alphabet, set the last index to 1 (unknown)\n", " encoding[i, -1] = 1\n", - " \n", + "\n", " return encoding" ] }, @@ -149,7 +149,7 @@ "source": [ "def generate_sample_protein_dataset(num_samples=20, protein_window_size=5):\n", " \"\"\"\n", - " Generate a dataset of protein sequences of length 11, keeping Lysine(K) in the center for label 1 and Serine(S) for label 0. \n", + " Generate a dataset of protein sequences of length 11, keeping Lysine(K) in the center for label 1 and Serine(S) for label 0.\n", "\n", " Args:\n", " num_samples (int): Number of samples to generate.\n", @@ -158,9 +158,9 @@ " Returns:\n", " dict: A dictionary containing train_input, test_input, train_label, and test_label.\n", " \"\"\"\n", - " \n", - " dataset = {'train_input': [], 'test_input': [], 'train_label': [], 'test_label': []}\n", - " alphabet = 'ARNDCQEGHILKMFPSTWYVX'\n", + "\n", + " dataset = {\"train_input\": [], \"test_input\": [], \"train_label\": [], \"test_label\": []}\n", + " alphabet = \"ARNDCQEGHILKMFPSTWYVX\"\n", "\n", " # Generate half of the samples with label 1 and half with label 0\n", " label_sequence = [1] * (num_samples // 2) + [0] * (num_samples // 2)\n", @@ -169,29 +169,42 @@ " for label in label_sequence:\n", " # Generate a protein sequence with 'K' in the middle for label 1 and 'S' for label 0\n", " if label == 1:\n", - " center_aa = 'K'\n", + " center_aa = \"K\"\n", " else:\n", - " center_aa = 'S'\n", - " sequence = ''.join(random.choices(alphabet.replace(center_aa, ''), k=protein_window_size//2)) + center_aa + ''.join(random.choices(alphabet.replace(center_aa, ''), k=protein_window_size//2))\n", + " center_aa = \"S\"\n", + " sequence = (\n", + " \"\".join(\n", + " random.choices(\n", + " alphabet.replace(center_aa, \"\"), k=protein_window_size // 2\n", + " )\n", + " )\n", + " + center_aa\n", + " + \"\".join(\n", + " random.choices(\n", + " alphabet.replace(center_aa, \"\"), k=protein_window_size // 2\n", + " )\n", + " )\n", + " )\n", " print(sequence, label)\n", " encoded_sequence = one_hot_encode(sequence).flatten()\n", "\n", " # Split the dataset into train and test (50% each)\n", - " if len(dataset['train_input']) < num_samples // 2:\n", - " dataset['train_input'].append(encoded_sequence)\n", - " dataset['train_label'].append(label)\n", + " if len(dataset[\"train_input\"]) < num_samples // 2:\n", + " dataset[\"train_input\"].append(encoded_sequence)\n", + " dataset[\"train_label\"].append(label)\n", " else:\n", - " dataset['test_input'].append(encoded_sequence)\n", - " dataset['test_label'].append(label)\n", + " dataset[\"test_input\"].append(encoded_sequence)\n", + " dataset[\"test_label\"].append(label)\n", "\n", " # Convert lists to tensors\n", - " dataset['train_input'] = torch.tensor(dataset['train_input'])\n", - " dataset['test_input'] = torch.tensor(dataset['test_input'])\n", - " dataset['train_label'] = torch.tensor(dataset['train_label']).view(-1, 1)\n", - " dataset['test_label'] = torch.tensor(dataset['test_label']).view(-1, 1)\n", + " dataset[\"train_input\"] = torch.tensor(dataset[\"train_input\"])\n", + " dataset[\"test_input\"] = torch.tensor(dataset[\"test_input\"])\n", + " dataset[\"train_label\"] = torch.tensor(dataset[\"train_label\"]).view(-1, 1)\n", + " dataset[\"test_label\"] = torch.tensor(dataset[\"test_label\"]).view(-1, 1)\n", "\n", " return dataset\n", "\n", + "\n", "# Generate dataset with 10 samples\n", "dataset = generate_sample_protein_dataset(40)" ] @@ -275,7 +288,7 @@ "# create a KAN: 105 inputs, 2D output, and 3 hidden neurons. k=2, 3 grid intervals (grid=3).\n", "# considering window size: 5, 5 times 21(vocab size), input-> 21 * 5\n", "\n", - "model = KAN(width=[105,3,2], grid=3, k=2)" + "model = KAN(width=[105, 3, 2], grid=3, k=2)" ] }, { @@ -304,13 +317,25 @@ ], "source": [ "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).float())\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"train_input\"])[:, 0])\n", + " == dataset[\"train_label\"][:, 0]\n", + " ).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).float())\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"test_input\"])[:, 0])\n", + " == dataset[\"test_label\"][:, 0]\n", + " ).float()\n", + " )\n", + "\n", "\n", - "results = model.train(dataset, opt=\"LBFGS\", steps=5, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" + "results = model.train(dataset, opt=\"LBFGS\", steps=5, metrics=(train_acc, test_acc))\n", + "results[\"train_acc\"][-1], results[\"test_acc\"][-1]" ] }, { @@ -648,7 +673,7 @@ } ], "source": [ - "lib = ['x','x^2']\n", + "lib = [\"x\", \"x^2\"]\n", "\n", "model.auto_symbolic(lib=lib)" ] diff --git a/docs/Example/Example_10_relativity-addition.ipynb b/docs/Example/Example_10_relativity-addition.ipynb index 50d49d0eb..ae165ee94 100644 --- a/docs/Example/Example_10_relativity-addition.ipynb +++ b/docs/Example/Example_10_relativity-addition.ipynb @@ -43,15 +43,15 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=10, k=3, device=device)\n", + "model = KAN(width=[2, 1, 1], grid=10, k=3, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: (x[:,[0]]+x[:,[1]])/(1+x[:,[0]]*x[:,[1]])\n", - "dataset = create_dataset(f, n_var=2, ranges=[-0.9,0.9], device=device)" + "f = lambda x: (x[:, [0]] + x[:, [1]]) / (1 + x[:, [0]] * x[:, [1]])\n", + "dataset = create_dataset(f, n_var=2, ranges=[-0.9, 0.9], device=device)" ] }, { @@ -159,7 +159,7 @@ } ], "source": [ - "model.suggest_symbolic(0,1,0,weight_simple=0.0)" + "model.suggest_symbolic(0, 1, 0, weight_simple=0.0)" ] }, { @@ -198,8 +198,8 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'arctanh')\n", - "model.fix_symbolic(0,1,0,'arctanh')" + "model.fix_symbolic(0, 0, 0, \"arctanh\")\n", + "model.fix_symbolic(0, 1, 0, \"arctanh\")" ] }, { @@ -299,7 +299,7 @@ } ], "source": [ - "model.suggest_symbolic(1,0,0,weight_simple=0.)" + "model.suggest_symbolic(1, 0, 0, weight_simple=0.0)" ] }, { @@ -328,7 +328,7 @@ } ], "source": [ - "model.fix_symbolic(1,0,0,'tanh')" + "model.fix_symbolic(1, 0, 0, \"tanh\")" ] }, { @@ -353,7 +353,14 @@ } ], "source": [ - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=2000, update_grid=False, singularity_avoiding=True);" + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=2000,\n", + " update_grid=False,\n", + " singularity_avoiding=True,\n", + ");" ] }, { diff --git a/docs/Example/Example_11_encouraing_linear.ipynb b/docs/Example/Example_11_encouraing_linear.ipynb index ee2126327..0c885326d 100644 --- a/docs/Example/Example_11_encouraing_linear.ipynb +++ b/docs/Example/Example_11_encouraing_linear.ipynb @@ -78,14 +78,14 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", + "f = lambda x: torch.sin(torch.pi * x[:, [0]])\n", "dataset = create_dataset(f, n_var=1, device=device)\n", "\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, noise_scale=0.1, device=device)\n", + "model = KAN(width=[1, 1, 1, 1], grid=5, k=3, seed=0, noise_scale=0.1, device=device)\n", "\n", "model.fit(dataset, opt=\"LBFGS\", steps=20);" ] @@ -159,11 +159,19 @@ "from kan import *\n", "\n", "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", + "f = lambda x: torch.sin(torch.pi * x[:, [0]])\n", "dataset = create_dataset(f, n_var=1, device=device)\n", "\n", "# set base_fun to be linear\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, base_fun='identity', noise_scale=0.1, device=device)\n", + "model = KAN(\n", + " width=[1, 1, 1, 1],\n", + " grid=5,\n", + " k=3,\n", + " seed=0,\n", + " base_fun=\"identity\",\n", + " noise_scale=0.1,\n", + " device=device,\n", + ")\n", "\n", "# penality spline coefficients\n", "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1e-4, lamb_coef=10.0);" diff --git a/docs/Example/Example_12_unsupervised_learning.ipynb b/docs/Example/Example_12_unsupervised_learning.ipynb index 943ae09b2..9656933c7 100644 --- a/docs/Example/Example_12_unsupervised_learning.ipynb +++ b/docs/Example/Example_12_unsupervised_learning.ipynb @@ -47,49 +47,59 @@ "import torch\n", "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 1\n", "\n", - "model = KAN(width=[6,1,1], grid=3, k=3, seed=seed, device=device)\n", + "model = KAN(width=[6, 1, 1], grid=3, k=3, seed=seed, device=device)\n", "\n", "# create dataset\n", "\n", "\n", "def create_dataset(train_num=500, test_num=500):\n", - " \n", " def generate_contrastive(x):\n", " # positive samples\n", " batch = x.shape[0]\n", - " x[:,2] = torch.exp(torch.sin(torch.pi*x[:,0])+x[:,1]**2)\n", - " x[:,3] = x[:,4]**3\n", + " x[:, 2] = torch.exp(torch.sin(torch.pi * x[:, 0]) + x[:, 1] ** 2)\n", + " x[:, 3] = x[:, 4] ** 3\n", "\n", " # negative samples\n", " def corrupt(tensor):\n", " y = copy.deepcopy(tensor)\n", " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", + " y[:, i] = y[:, i][torch.randperm(y.shape[0])]\n", " return y\n", "\n", " x_cor = corrupt(x)\n", " x = torch.cat([x, x_cor], dim=0)\n", - " y = torch.cat([torch.ones(batch,), torch.zeros(batch,)], dim=0)[:,None]\n", + " y = torch.cat(\n", + " [\n", + " torch.ones(\n", + " batch,\n", + " ),\n", + " torch.zeros(\n", + " batch,\n", + " ),\n", + " ],\n", + " dim=0,\n", + " )[:, None]\n", " return x, y\n", - " \n", + "\n", " x = torch.rand(train_num, 6) * 2 - 1\n", " x_train, y_train = generate_contrastive(x)\n", - " \n", + "\n", " x = torch.rand(test_num, 6) * 2 - 1\n", " x_test, y_test = generate_contrastive(x)\n", - " \n", + "\n", " dataset = {}\n", - " dataset['train_input'] = x_train.to(device)\n", - " dataset['test_input'] = x_test.to(device)\n", - " dataset['train_label'] = y_train.to(device)\n", - " dataset['test_label'] = y_test.to(device)\n", + " dataset[\"train_input\"] = x_train.to(device)\n", + " dataset[\"test_input\"] = x_test.to(device)\n", + " dataset[\"train_label\"] = y_train.to(device)\n", + " dataset[\"test_label\"] = y_test.to(device)\n", " return dataset\n", "\n", + "\n", "dataset = create_dataset()" ] }, @@ -111,7 +121,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -131,8 +141,8 @@ ], "source": [ "# set the (1,0,0) activation to be gausssian\n", - "#model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)" + "# model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", + "model.fix_symbolic(1, 0, 0, \"gaussian\", fit_params_bool=False)" ] }, { @@ -153,7 +163,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -207,7 +217,7 @@ } ], "source": [ - "model.plot(in_vars=[r'$x_{}$'.format(i) for i in range(1,7)])" + "model.plot(in_vars=[r\"$x_{}$\".format(i) for i in range(1, 7)])" ] }, { diff --git a/docs/Example/Example_13_phase_transition.ipynb b/docs/Example/Example_13_phase_transition.ipynb index ae7a4241a..be688b9d8 100644 --- a/docs/Example/Example_13_phase_transition.ipynb +++ b/docs/Example/Example_13_phase_transition.ipynb @@ -44,14 +44,19 @@ "from kan import KAN, create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[3,1,1], grid=3, k=3, device=device)\n", + "model = KAN(width=[3, 1, 1], grid=3, k=3, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: (torch.sin(torch.pi*x[:,[0]]) + torch.cos(torch.pi*x[:,[1]]) + torch.tan(torch.pi/2*x[:,[2]]) > 0).float()\n", - "dataset = create_dataset(f, n_var=3, device=device)\n" + "f = lambda x: (\n", + " torch.sin(torch.pi * x[:, [0]])\n", + " + torch.cos(torch.pi * x[:, [1]])\n", + " + torch.tan(torch.pi / 2 * x[:, [2]])\n", + " > 0\n", + ").float()\n", + "dataset = create_dataset(f, n_var=3, device=device)" ] }, { @@ -74,7 +79,7 @@ } ], "source": [ - "torch.mean(dataset['train_label'])" + "torch.mean(dataset[\"train_label\"])" ] }, { @@ -95,7 +100,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -115,7 +120,7 @@ ], "source": [ "# set the last activation to be tanh\n", - "model.fix_symbolic(1,0,0,'tanh',fit_params_bool=False)" + "model.fix_symbolic(1, 0, 0, \"tanh\", fit_params_bool=False)" ] }, { @@ -136,7 +141,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, diff --git a/docs/Example/Example_14_knot_supervised.ipynb b/docs/Example/Example_14_knot_supervised.ipynb index 11bbfbef6..45a868f71 100644 --- a/docs/Example/Example_14_knot_supervised.ipynb +++ b/docs/Example/Example_14_knot_supervised.ipynb @@ -37,9 +37,8 @@ "import numpy as np\n", "import torch\n", "from kan import *\n", - "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 42\n", @@ -51,33 +50,35 @@ "df.keys()\n", "\n", "X = df[df.keys()[1:-1]].to_numpy()\n", - "Y = df[['signature']].to_numpy()\n", + "Y = df[[\"signature\"]].to_numpy()\n", "\n", "# normalize X\n", "X_mean = np.mean(X, axis=0)\n", "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", + "X = (X - X_mean[np.newaxis, :]) / X_std[np.newaxis, :]\n", "input_normalier = [X_mean, X_std]\n", "\n", "# normalize Y\n", "max_signature = np.max(Y)\n", "min_signature = np.min(Y)\n", - "Y = ((Y-min_signature)/2).astype(int)\n", - "n_class = int((max_signature-min_signature)/2+1)\n", + "Y = ((Y - min_signature) / 2).astype(int)\n", + "n_class = int((max_signature - min_signature) / 2 + 1)\n", "output_normalier = [min_signature, 2]\n", "\n", "dataset = {}\n", "num = X.shape[0]\n", "n_feature = X.shape[1]\n", "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", + "train_id_ = np.random.choice(num, int(num * train_ratio), replace=False)\n", + "test_id_ = np.array(list(set(range(num)) - set(train_id_)))\n", "\n", "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(Y[train_id_][:,0]).type(torch.long).to(device)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(Y[test_id_][:,0]).type(torch.long).to(device)\n" + "dataset[\"train_input\"] = torch.from_numpy(X[train_id_]).type(dtype).to(device)\n", + "dataset[\"train_label\"] = (\n", + " torch.from_numpy(Y[train_id_][:, 0]).type(torch.long).to(device)\n", + ")\n", + "dataset[\"test_input\"] = torch.from_numpy(X[test_id_]).type(dtype).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(Y[test_id_][:, 0]).type(torch.long).to(device)" ] }, { @@ -90,13 +91,30 @@ "outputs": [], "source": [ "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"train_input\"]), dim=1) == dataset[\"train_label\"]\n", + " ).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"test_input\"]), dim=1) == dataset[\"test_label\"]\n", + " ).float()\n", + " )\n", + "\n", "\n", - "model = KAN(width=[n_feature,1,n_class], grid=5, k=3, seed=seed, device=device)\n", - "model.fit(dataset, lamb=0.005, batch=1024, loss_fn = nn.CrossEntropyLoss(), metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" + "model = KAN(width=[n_feature, 1, n_class], grid=5, k=3, seed=seed, device=device)\n", + "model.fit(\n", + " dataset,\n", + " lamb=0.005,\n", + " batch=1024,\n", + " loss_fn=nn.CrossEntropyLoss(),\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"reg\", \"train_acc\", \"test_acc\"],\n", + ");" ] }, { @@ -110,7 +128,13 @@ "\n", "n = 17\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:-1][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:-1][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] }, { @@ -125,8 +149,8 @@ "\n", "y_pos = range(len(features))\n", "plt.bar(y_pos, scores)\n", - "plt.xticks(y_pos, features, rotation=90);\n", - "plt.ylabel('feature importance')" + "plt.xticks(y_pos, features, rotation=90)\n", + "plt.ylabel(\"feature importance\")" ] } ], diff --git a/docs/Example/Example_15_knot_unsupervised.ipynb b/docs/Example/Example_15_knot_unsupervised.ipynb index 95ecd68b5..b278ac0ca 100644 --- a/docs/Example/Example_15_knot_unsupervised.ipynb +++ b/docs/Example/Example_15_knot_unsupervised.ipynb @@ -39,7 +39,7 @@ "from kan import *\n", "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 2024\n", @@ -55,37 +55,57 @@ "X = df[df.keys()[1:]].to_numpy()\n", "mean = np.mean(X, axis=0)\n", "std = np.std(X, axis=0)\n", - "X = (X - mean[np.newaxis,:])/std[np.newaxis,:]\n", + "X = (X - mean[np.newaxis, :]) / std[np.newaxis, :]\n", "\n", "# normalize X\n", "X_mean = np.mean(X, axis=0)\n", "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", + "X = (X - X_mean[np.newaxis, :]) / X_std[np.newaxis, :]\n", "input_normalier = [X_mean, X_std]\n", "\n", "dataset = {}\n", "num = X.shape[0]\n", "n_feature = X.shape[1]\n", "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n", + "train_id_ = np.random.choice(num, int(num * train_ratio), replace=False)\n", + "test_id_ = np.array(list(set(range(num)) - set(train_id_)))\n", + "dataset[\"train_input\"] = torch.from_numpy(X[train_id_]).type(dtype)\n", + "dataset[\"test_input\"] = torch.from_numpy(X[test_id_]).type(dtype)\n", + "\n", "\n", "def construct_contrastive_dataset(tensor):\n", " y = copy.deepcopy(tensor)\n", " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", + " y[:, i] = y[:, i][torch.randperm(y.shape[0])]\n", " return y\n", "\n", - "dataset['contrastive_train_input'] = construct_contrastive_dataset(dataset['train_input'])\n", - "dataset['contrastive_test_input'] = construct_contrastive_dataset(dataset['test_input'])\n", "\n", - "dataset['train_label'] = torch.cat([torch.ones(dataset['train_input'].shape[0],1), torch.zeros(dataset['contrastive_train_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['train_input'] = torch.cat([dataset['train_input'], dataset['contrastive_train_input']], dim=0).to(device)\n", + "dataset[\"contrastive_train_input\"] = construct_contrastive_dataset(\n", + " dataset[\"train_input\"]\n", + ")\n", + "dataset[\"contrastive_test_input\"] = construct_contrastive_dataset(dataset[\"test_input\"])\n", + "\n", + "dataset[\"train_label\"] = torch.cat(\n", + " [\n", + " torch.ones(dataset[\"train_input\"].shape[0], 1),\n", + " torch.zeros(dataset[\"contrastive_train_input\"].shape[0], 1),\n", + " ],\n", + " dim=0,\n", + ").to(device)\n", + "dataset[\"train_input\"] = torch.cat(\n", + " [dataset[\"train_input\"], dataset[\"contrastive_train_input\"]], dim=0\n", + ").to(device)\n", "\n", - "dataset['test_label'] = torch.cat([torch.ones(dataset['test_input'].shape[0],1), torch.zeros(dataset['contrastive_test_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['test_input'] = torch.cat([dataset['test_input'], dataset['contrastive_test_input']], dim=0).to(device)\n" + "dataset[\"test_label\"] = torch.cat(\n", + " [\n", + " torch.ones(dataset[\"test_input\"].shape[0], 1),\n", + " torch.zeros(dataset[\"contrastive_test_input\"].shape[0], 1),\n", + " ],\n", + " dim=0,\n", + ").to(device)\n", + "dataset[\"test_input\"] = torch.cat(\n", + " [dataset[\"test_input\"], dataset[\"contrastive_test_input\"]], dim=0\n", + ").to(device)" ] }, { @@ -98,14 +118,26 @@ "outputs": [], "source": [ "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", + "\n", "\n", - "model = KAN(width=[n_feature,1,1], grid=5, k=3, seed=seed, device=device)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)\n", - "model.fit(dataset, lamb=0.001, batch=1024, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" + "model = KAN(width=[n_feature, 1, 1], grid=5, k=3, seed=seed, device=device)\n", + "model.fix_symbolic(1, 0, 0, \"gaussian\", fit_params_bool=False)\n", + "model.fit(\n", + " dataset,\n", + " lamb=0.001,\n", + " batch=1024,\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"reg\", \"train_acc\", \"test_acc\"],\n", + ");" ] }, { @@ -120,7 +152,13 @@ "\n", "n = 18\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] }, { @@ -135,7 +173,13 @@ "\n", "n = 18\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] } ], diff --git a/docs/Example/Example_1_function_fitting.ipynb b/docs/Example/Example_1_function_fitting.ipynb index ba369ab89..5f5898b0a 100644 --- a/docs/Example/Example_1_function_fitting.ipynb +++ b/docs/Example/Example_1_function_fitting.ipynb @@ -38,14 +38,14 @@ "from kan import *\n", "\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 1, 1], grid=3, k=3, seed=1, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)" ] }, @@ -261,7 +261,7 @@ } ], "source": [ - "grids = np.array([3,10,20,50,100])\n", + "grids = np.array([3, 10, 20, 50, 100])\n", "\n", "\n", "train_losses = []\n", @@ -271,13 +271,12 @@ "\n", "for i in range(grids.shape[0]):\n", " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k, seed=1, device=device)\n", + " model = KAN(width=[2, 1, 1], grid=grids[i], k=k, seed=1, device=device)\n", " if i != 0:\n", " model = model.refine(grids[i])\n", " results = model.fit(dataset, opt=\"LBFGS\", steps=steps)\n", - " train_losses += results['train_loss']\n", - " test_losses += results['test_loss']\n", - " " + " train_losses += results[\"train_loss\"]\n", + " test_losses += results[\"test_loss\"]" ] }, { @@ -308,10 +307,10 @@ "source": [ "plt.plot(train_losses)\n", "plt.plot(test_losses)\n", - "plt.legend(['train', 'test'])\n", - "plt.ylabel('RMSE')\n", - "plt.xlabel('step')\n", - "plt.yscale('log')" + "plt.legend([\"train\", \"test\"])\n", + "plt.ylabel(\"RMSE\")\n", + "plt.xlabel(\"step\")\n", + "plt.yscale(\"log\")" ] }, { @@ -351,16 +350,16 @@ ], "source": [ "n_params = 3 * grids\n", - "train_vs_G = train_losses[(steps-1)::steps]\n", - "test_vs_G = test_losses[(steps-1)::steps]\n", + "train_vs_G = train_losses[(steps - 1) :: steps]\n", + "test_vs_G = test_losses[(steps - 1) :: steps]\n", "plt.plot(n_params, train_vs_G, marker=\"o\")\n", "plt.plot(n_params, test_vs_G, marker=\"o\")\n", - "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.legend(['train', 'test', r'$N^{-4}$'])\n", - "plt.xlabel('number of params')\n", - "plt.ylabel('RMSE')" + "plt.plot(n_params, 100 * n_params ** (-4.0), ls=\"--\", color=\"black\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"])\n", + "plt.xlabel(\"number of params\")\n", + "plt.ylabel(\"RMSE\")" ] }, { diff --git a/docs/Example/Example_3_deep_formula.ipynb b/docs/Example/Example_3_deep_formula.ipynb index 93346074e..3b839f220 100644 --- a/docs/Example/Example_3_deep_formula.ipynb +++ b/docs/Example/Example_3_deep_formula.ipynb @@ -58,16 +58,22 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 2, 1, 1], grid=3, k=3, seed=1, device=device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);" + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.0);" ] }, { @@ -210,18 +216,18 @@ } ], "source": [ - "grids = [3,5,10,20,50]\n", - "#grids = [5]\n", + "grids = [3, 5, 10, 20, 50]\n", + "# grids = [5]\n", "\n", "train_rmse = []\n", "test_rmse = []\n", "\n", "for i in range(len(grids)):\n", - " #model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0, device=device).initialize_from_another_model(model, dataset['train_input'])\n", + " # model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0, device=device).initialize_from_another_model(model, dataset['train_input'])\n", " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=20);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" + " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=20)\n", + " train_rmse.append(results[\"train_loss\"][-1].item())\n", + " test_rmse.append(results[\"test_loss\"][-1].item())" ] }, { @@ -261,13 +267,13 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "n_params = np.array(grids) * (4*2+2*1+1*1)\n", + "n_params = np.array(grids) * (4 * 2 + 2 * 1 + 1 * 1)\n", "plt.plot(n_params, train_rmse, marker=\"o\")\n", "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 10000*n_params**(-4.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", + "plt.plot(n_params, 10000 * n_params ** (-4.0), color=\"black\", ls=\"--\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"], loc=\"lower left\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", "print(train_rmse)\n", "print(test_rmse)" ] @@ -326,12 +332,18 @@ "import torch\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,9,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 9, 1], grid=3, k=3, seed=0)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000)\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.0)\n", "model.plot(beta=10)" ] }, @@ -436,17 +448,17 @@ } ], "source": [ - "grids = [3,5,10,20,50]\n", + "grids = [3, 5, 10, 20, 50]\n", "\n", "train_rmse = []\n", "test_rmse = []\n", "\n", "for i in range(len(grids)):\n", - " #model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", + " # model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" + " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30)\n", + " train_rmse.append(results[\"train_loss\"][-1].item())\n", + " test_rmse.append(results[\"test_loss\"][-1].item())" ] }, { @@ -478,13 +490,13 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "n_params = np.array(grids) * (4*9+9*1)\n", + "n_params = np.array(grids) * (4 * 9 + 9 * 1)\n", "plt.plot(n_params, train_rmse, marker=\"o\")\n", "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 300*n_params**(-2.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", + "plt.plot(n_params, 300 * n_params ** (-2.0), color=\"black\", ls=\"--\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"], loc=\"lower left\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", "print(train_rmse)\n", "print(test_rmse)" ] diff --git a/docs/Example/Example_4_classfication.ipynb b/docs/Example/Example_4_classfication.ipynb index 2887838d6..bf032db51 100644 --- a/docs/Example/Example_4_classfication.ipynb +++ b/docs/Example/Example_4_classfication.ipynb @@ -66,22 +66,30 @@ "from sklearn.datasets import make_moons\n", "import numpy as np\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", + "train_input, train_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", + "test_input, test_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", "\n", "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label[:,None]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label[:,None]).type(dtype).to(device)\n", + "dataset[\"train_input\"] = torch.from_numpy(train_input).type(dtype).to(device)\n", + "dataset[\"test_input\"] = torch.from_numpy(test_input).type(dtype).to(device)\n", + "dataset[\"train_label\"] = torch.from_numpy(train_label[:, None]).type(dtype).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(test_label[:, None]).type(dtype).to(device)\n", "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:,0].cpu().detach().numpy())" + "X = dataset[\"train_input\"]\n", + "y = dataset[\"train_label\"]\n", + "plt.scatter(\n", + " X[:, 0].cpu().detach().numpy(),\n", + " X[:, 1].cpu().detach().numpy(),\n", + " c=y[:, 0].cpu().detach().numpy(),\n", + ")" ] }, { @@ -139,16 +147,29 @@ } ], "source": [ - "model = KAN(width=[2,1], grid=3, k=3, device=device)\n", + "model = KAN(width=[2, 1], grid=3, k=3, device=device)\n", + "\n", "\n", "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"train_input\"])[:, 0])\n", + " == dataset[\"train_label\"][:, 0]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"test_input\"])[:, 0])\n", + " == dataset[\"test_label\"][:, 0]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" + "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc))\n", + "results[\"train_acc\"][-1], results[\"test_acc\"][-1]" ] }, { @@ -189,7 +210,7 @@ } ], "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','tan','abs']\n", + "lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"tan\", \"abs\"]\n", "model.auto_symbolic(lib=lib)\n", "formula = model.symbolic_formula()[0][0]\n", "ex_round(formula, 4)" @@ -224,11 +245,25 @@ " batch = X.shape[0]\n", " correct = 0\n", " for i in range(batch):\n", - " correct += np.round(np.array(formula.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)) == y[i,0]\n", - " return correct/batch\n", + " correct += (\n", + " np.round(\n", + " np.array(formula.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", + " )\n", + " == y[i, 0]\n", + " )\n", + " return correct / batch\n", "\n", - "print('train acc of the formula:', acc(formula, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula, dataset['test_input'], dataset['test_label']))" + "\n", + "print(\n", + " \"train acc of the formula:\",\n", + " acc(formula, dataset[\"train_input\"], dataset[\"train_label\"]),\n", + ")\n", + "print(\n", + " \"test acc of the formula:\",\n", + " acc(formula, dataset[\"test_input\"], dataset[\"test_label\"]),\n", + ")" ] }, { @@ -281,20 +316,27 @@ "import matplotlib.pyplot as plt\n", "from sklearn.datasets import make_moons\n", "import torch\n", - "import numpy as np\n", "\n", "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", + "train_input, train_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", + "test_input, test_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", "\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label).type(torch.long).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label).type(torch.long).to(device)\n", + "dataset[\"train_input\"] = torch.from_numpy(train_input).type(dtype).to(device)\n", + "dataset[\"test_input\"] = torch.from_numpy(test_input).type(dtype).to(device)\n", + "dataset[\"train_label\"] = torch.from_numpy(train_label).type(torch.long).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(test_label).type(torch.long).to(device)\n", "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:].cpu().detach().numpy())" + "X = dataset[\"train_input\"]\n", + "y = dataset[\"train_label\"]\n", + "plt.scatter(\n", + " X[:, 0].cpu().detach().numpy(),\n", + " X[:, 1].cpu().detach().numpy(),\n", + " c=y[:].cpu().detach().numpy(),\n", + ")" ] }, { @@ -342,15 +384,32 @@ } ], "source": [ - "model = KAN(width=[2,2], grid=3, k=3, seed=2024, device=device)\n", + "model = KAN(width=[2, 2], grid=3, k=3, seed=2024, device=device)\n", + "\n", "\n", "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"train_input\"]), dim=1) == dataset[\"train_label\"]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"test_input\"]), dim=1) == dataset[\"test_label\"]\n", + " ).type(dtype)\n", + " )\n", "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc), loss_fn=torch.nn.CrossEntropyLoss());" + "\n", + "results = model.fit(\n", + " dataset,\n", + " opt=\"LBFGS\",\n", + " steps=20,\n", + " metrics=(train_acc, test_acc),\n", + " loss_fn=torch.nn.CrossEntropyLoss(),\n", + ");" ] }, { @@ -380,7 +439,7 @@ } ], "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", + "lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"abs\"]\n", "model.auto_symbolic(lib=lib)" ] }, @@ -462,13 +521,24 @@ " batch = X.shape[0]\n", " correct = 0\n", " for i in range(batch):\n", - " logit1 = np.array(formula1.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " logit2 = np.array(formula2.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", + " logit1 = np.array(formula1.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", + " logit2 = np.array(formula2.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", " correct += (logit2 > logit1) == y[i]\n", - " return correct/batch\n", + " return correct / batch\n", + "\n", "\n", - "print('train acc of the formula:', acc(formula1, formula2, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula1, formula2, dataset['test_input'], dataset['test_label']))" + "print(\n", + " \"train acc of the formula:\",\n", + " acc(formula1, formula2, dataset[\"train_input\"], dataset[\"train_label\"]),\n", + ")\n", + "print(\n", + " \"test acc of the formula:\",\n", + " acc(formula1, formula2, dataset[\"test_input\"], dataset[\"test_label\"]),\n", + ")" ] }, { diff --git a/docs/Example/Example_5_special_functions.ipynb b/docs/Example/Example_5_special_functions.ipynb index 9894cbf46..25a2f586e 100644 --- a/docs/Example/Example_5_special_functions.ipynb +++ b/docs/Example/Example_5_special_functions.ipynb @@ -49,12 +49,12 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=2, device=device)\n", - "f = lambda x: torch.exp(torch.special.bessel_j0(20*x[:,[0]]) + x[:,[1]]**2)\n", + "model = KAN(width=[2, 1, 1], grid=3, k=3, seed=2, device=device)\n", + "f = lambda x: torch.exp(torch.special.bessel_j0(20 * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "\n", "# train the model\n", @@ -195,7 +195,7 @@ } ], "source": [ - "model.suggest_symbolic(0,0,0)" + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -234,7 +234,7 @@ "metadata": {}, "outputs": [], "source": [ - "add_symbolic('J0', torch.special.bessel_j0, c=1)" + "add_symbolic(\"J0\", torch.special.bessel_j0, c=1)" ] }, { @@ -282,7 +282,7 @@ ], "source": [ "# J0 fitting is not very good\n", - "model.suggest_symbolic(0,0,0)" + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -329,7 +329,7 @@ } ], "source": [ - "model.suggest_symbolic(0,0,0,a_range=(-40,40))" + "model.suggest_symbolic(0, 0, 0, a_range=(-40, 40))" ] } ], diff --git a/docs/Example/Example_6_PDE_interpretation.ipynb b/docs/Example/Example_6_PDE_interpretation.ipynb index a85aa1188..b79e2b631 100644 --- a/docs/Example/Example_6_PDE_interpretation.ipynb +++ b/docs/Example/Example_6_PDE_interpretation.ipynb @@ -41,51 +41,78 @@ ], "source": [ "from kan import *\n", - "import matplotlib.pyplot as plt\n", "from torch import autograd\n", "from tqdm import tqdm\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dim = 2\n", - "np_i = 21 # number of interior points (along each dimension)\n", - "np_b = 21 # number of boundary points (along each dimension)\n", + "np_i = 21 # number of interior points (along each dimension)\n", + "np_b = 21 # number of boundary points (along each dimension)\n", "ranges = [-1, 1]\n", "\n", - "model = KAN(width=[2,2,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 2, 1], grid=5, k=3, seed=1, device=device)\n", + "\n", "\n", "def batch_jacobian(func, x, create_graph=False):\n", " # x in shape (Batch, Length)\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", + "sol_fun = lambda x: torch.sin(torch.pi * x[:, [0]]) * torch.sin(torch.pi * x[:, [1]])\n", + "source_fun = (\n", + " lambda x: -2\n", + " * torch.pi**2\n", + " * torch.sin(torch.pi * x[:, [0]])\n", + " * torch.sin(torch.pi * x[:, [1]])\n", + ")\n", "\n", "# interior\n", - "sampling_mode = 'random' # 'radnom' or 'mesh'\n", + "sampling_mode = \"random\" # 'radnom' or 'mesh'\n", "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", + "x_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", + "y_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "if sampling_mode == \"mesh\":\n", + " # mesh\n", + " x_i = torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + " ).permute(1, 0)\n", "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", + " # random\n", + " x_i = torch.rand((np_i**2, 2)) * 2 - 1\n", + "\n", "x_i = x_i.to(device)\n", "\n", "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "helper = lambda X, Y: torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + ").permute(1, 0)\n", "xb1 = helper(X[0], Y[0])\n", "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", + "xb3 = helper(X[:, 0], Y[:, 0])\n", + "xb4 = helper(X[:, 0], Y[:, -1])\n", "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", "\n", "x_b = x_b.to(device)\n", @@ -94,28 +121,38 @@ "alpha = 0.01\n", "log = 1\n", "\n", + "\n", "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", + " pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", " for _ in pbar:\n", + "\n", " def closure():\n", " global pde_loss, bc_loss\n", " optimizer.zero_grad()\n", " # interior loss\n", " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", + " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:, 0, :]\n", " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", + " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:, :, :]\n", " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", + " pde_loss = torch.mean((lap - source) ** 2)\n", "\n", " # boundary loss\n", " bc_true = sol_fun(x_b)\n", " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", + " bc_loss = torch.mean((bc_pred - bc_true) ** 2)\n", "\n", " loss = alpha * pde_loss + bc_loss\n", " loss.backward()\n", @@ -127,10 +164,18 @@ " optimizer.step(closure)\n", " sol = sol_fun(x_i)\n", " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", + " l2 = torch.mean((model(x_i) - sol) ** 2)\n", "\n", " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", + " pbar.set_description(\n", + " \"pde loss: %.2e | bc loss: %.2e | l2: %.2e \"\n", + " % (\n", + " pde_loss.cpu().detach().numpy(),\n", + " bc_loss.cpu().detach().numpy(),\n", + " l2.cpu().detach().numpy(),\n", + " )\n", + " )\n", + "\n", "\n", "train()" ] @@ -208,10 +253,10 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'x')\n", - "model.fix_symbolic(0,0,1,'x')\n", - "model.fix_symbolic(0,1,0,'x')\n", - "model.fix_symbolic(0,1,1,'x')" + "model.fix_symbolic(0, 0, 0, \"x\")\n", + "model.fix_symbolic(0, 0, 1, \"x\")\n", + "model.fix_symbolic(0, 1, 0, \"x\")\n", + "model.fix_symbolic(0, 1, 1, \"x\")" ] }, { @@ -292,7 +337,7 @@ ], "source": [ "formula = model.symbolic_formula()[0][0]\n", - "ex_round(formula,6)" + "ex_round(formula, 6)" ] }, { diff --git a/docs/Example/Example_7_PDE_accuracy.ipynb b/docs/Example/Example_7_PDE_accuracy.ipynb index 0d7f03913..52884844a 100644 --- a/docs/Example/Example_7_PDE_accuracy.ipynb +++ b/docs/Example/Example_7_PDE_accuracy.ipynb @@ -48,13 +48,13 @@ "from torch import autograd\n", "from tqdm import tqdm\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "\n", "dim = 2\n", - "np_i = 51 # number of interior points (along each dimension)\n", - "np_b = 51 # number of boundary points (along each dimension)\n", + "np_i = 51 # number of interior points (along each dimension)\n", + "np_b = 51 # number of boundary points (along each dimension)\n", "ranges = [-1, 1]\n", "\n", "\n", @@ -62,33 +62,60 @@ " # x in shape (Batch, Length)\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", + "sol_fun = lambda x: torch.sin(torch.pi * x[:, [0]]) * torch.sin(torch.pi * x[:, [1]])\n", + "source_fun = (\n", + " lambda x: -2\n", + " * torch.pi**2\n", + " * torch.sin(torch.pi * x[:, [0]])\n", + " * torch.sin(torch.pi * x[:, [1]])\n", + ")\n", "\n", "# interior\n", - "sampling_mode = 'mesh' # 'radnom' or 'mesh'\n", + "sampling_mode = \"mesh\" # 'radnom' or 'mesh'\n", "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", + "x_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", + "y_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "if sampling_mode == \"mesh\":\n", + " # mesh\n", + " x_i = torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + " ).permute(1, 0)\n", "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", + " # random\n", + " x_i = torch.rand((np_i**2, 2)) * 2 - 1\n", + "\n", "x_i = x_i.to(device)\n", "\n", "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "helper = lambda X, Y: torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + ").permute(1, 0)\n", "xb1 = helper(X[0], Y[0])\n", "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", + "xb3 = helper(X[:, 0], Y[:, 0])\n", + "xb4 = helper(X[:, 0], Y[:, -1])\n", "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", "\n", "x_b = x_b.to(device)\n", @@ -97,7 +124,7 @@ "log = 1\n", "\n", "\n", - "grids = [5,10,20]\n", + "grids = [5, 10, 20]\n", "steps = 50\n", "\n", "pde_losses = []\n", @@ -106,7 +133,7 @@ "\n", "for grid in grids:\n", " if grid == grids[0]:\n", - " model = KAN(width=[2,2,1], grid=grid, k=3, seed=1, device=device)\n", + " model = KAN(width=[2, 2, 1], grid=grid, k=3, seed=1, device=device)\n", " model = model.speed()\n", " else:\n", " model.save_act = True\n", @@ -115,27 +142,40 @@ " model = model.speed()\n", "\n", " def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", + " pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", " for _ in pbar:\n", + "\n", " def closure():\n", " global pde_loss, bc_loss\n", " optimizer.zero_grad()\n", " # interior loss\n", " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", + " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[\n", + " :, 0, :\n", + " ]\n", " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", - " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", + " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:, :, :]\n", + " lap = torch.sum(\n", + " torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True\n", + " )\n", " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", + " pde_loss = torch.mean((lap - source) ** 2)\n", "\n", " # boundary loss\n", " bc_true = sol_fun(x_b)\n", " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", + " bc_loss = torch.mean((bc_pred - bc_true) ** 2)\n", "\n", " loss = alpha * pde_loss + bc_loss\n", " loss.backward()\n", @@ -147,16 +187,22 @@ " optimizer.step(closure)\n", " sol = sol_fun(x_i)\n", " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", + " l2 = torch.mean((model(x_i) - sol) ** 2)\n", "\n", " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", + " pbar.set_description(\n", + " \"pde loss: %.2e | bc loss: %.2e | l2: %.2e \"\n", + " % (\n", + " pde_loss.cpu().detach().numpy(),\n", + " bc_loss.cpu().detach().numpy(),\n", + " l2.cpu().detach().numpy(),\n", + " )\n", + " )\n", "\n", " pde_losses.append(pde_loss.cpu().detach().numpy())\n", " bc_losses.append(bc_loss.cpu().detach().numpy())\n", " l2_losses.append(l2.cpu().detach().numpy())\n", - " \n", - " \n", + "\n", " train()" ] }, @@ -188,12 +234,12 @@ } ], "source": [ - "plt.plot(pde_losses, marker='o')\n", - "plt.plot(bc_losses, marker='o')\n", - "plt.plot(l2_losses, marker='o')\n", - "plt.yscale('log')\n", - "plt.xlabel('steps')\n", - "plt.legend(['PDE loss', 'BC loss', 'L2 squared'])" + "plt.plot(pde_losses, marker=\"o\")\n", + "plt.plot(bc_losses, marker=\"o\")\n", + "plt.plot(l2_losses, marker=\"o\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"steps\")\n", + "plt.legend([\"PDE loss\", \"BC loss\", \"L2 squared\"])" ] }, { diff --git a/docs/Example/Example_8_continual_learning.ipynb b/docs/Example/Example_8_continual_learning.ipynb index 6df4a2618..21b121ca9 100644 --- a/docs/Example/Example_8_continual_learning.ipynb +++ b/docs/Example/Example_8_continual_learning.ipynb @@ -56,21 +56,28 @@ "n_num_per_peak = 100\n", "n_sample = n_peak * n_num_per_peak\n", "\n", - "x_grid = torch.linspace(-1,1,steps=n_sample)\n", + "x_grid = torch.linspace(-1, 1, steps=n_sample)\n", "\n", - "x_centers = 2/n_peak * (np.arange(n_peak) - n_peak/2+0.5)\n", + "x_centers = 2 / n_peak * (np.arange(n_peak) - n_peak / 2 + 0.5)\n", "\n", - "x_sample = torch.stack([torch.linspace(-1/n_peak,1/n_peak,steps=n_num_per_peak)+center for center in x_centers]).reshape(-1,)\n", + "x_sample = torch.stack(\n", + " [\n", + " torch.linspace(-1 / n_peak, 1 / n_peak, steps=n_num_per_peak) + center\n", + " for center in x_centers\n", + " ]\n", + ").reshape(\n", + " -1,\n", + ")\n", "\n", "\n", - "y = 0.\n", + "y = 0.0\n", "for center in x_centers:\n", - " y += torch.exp(-(x_grid-center)**2*300)\n", - " \n", - "y_sample = 0.\n", + " y += torch.exp(-((x_grid - center) ** 2) * 300)\n", + "\n", + "y_sample = 0.0\n", "for center in x_centers:\n", - " y_sample += torch.exp(-(x_sample-center)**2*300)\n", - " \n", + " y_sample += torch.exp(-((x_sample - center) ** 2) * 300)\n", + "\n", "\n", "plt.plot(x_grid.detach().numpy(), y.detach().numpy())\n", "plt.scatter(x_sample.detach().numpy(), y_sample.detach().numpy())" @@ -105,13 +112,22 @@ "plt.subplots(1, 5, figsize=(15, 2))\n", "plt.subplots_adjust(wspace=0, hspace=0)\n", "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", + "for i in range(1, 6):\n", + " plt.subplot(1, 5, i)\n", " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.scatter(x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), color=\"black\", s=2)\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" + " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color=\"black\", alpha=0.1)\n", + " plt.scatter(\n", + " x_sample[group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak]\n", + " .detach()\n", + " .numpy(),\n", + " y_sample[group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak]\n", + " .detach()\n", + " .numpy(),\n", + " color=\"black\",\n", + " s=2,\n", + " )\n", + " plt.xlim(-1, 1)\n", + " plt.ylim(-1, 2)" ] }, { @@ -213,17 +229,33 @@ "# setting bias_trainable=False, sp_trainable=False, sb_trainable=False is important.\n", "# otherwise KAN will have random scaling and shift for samples in previous stages\n", "\n", - "model = KAN(width=[1,1], grid=200, k=3, noise_scale=0.1, sp_trainable=False, sb_trainable=False, base_fun='zero')\n", + "model = KAN(\n", + " width=[1, 1],\n", + " grid=200,\n", + " k=3,\n", + " noise_scale=0.1,\n", + " sp_trainable=False,\n", + " sb_trainable=False,\n", + " base_fun=\"zero\",\n", + ")\n", "\n", "for group_id in range(n_peak):\n", " dataset = {}\n", - " dataset['train_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['train_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " model.fit(dataset, opt = 'LBFGS', steps=100, update_grid=False);\n", - " y_pred = model(x_grid[:,None])\n", - " ys.append(y_pred.detach().numpy()[:,0])" + " dataset[\"train_input\"] = x_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"train_label\"] = y_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"test_input\"] = x_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"test_label\"] = y_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " model.fit(dataset, opt=\"LBFGS\", steps=100, update_grid=False)\n", + " y_pred = model(x_grid[:, None])\n", + " ys.append(y_pred.detach().numpy()[:, 0])" ] }, { @@ -255,13 +287,13 @@ "plt.subplots(1, 5, figsize=(15, 2))\n", "plt.subplots_adjust(wspace=0, hspace=0)\n", "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", + "for i in range(1, 6):\n", + " plt.subplot(1, 5, i)\n", " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.plot(x_grid.detach().numpy(), ys[i-1], color='black')\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" + " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color=\"black\", alpha=0.1)\n", + " plt.plot(x_grid.detach().numpy(), ys[i - 1], color=\"black\")\n", + " plt.xlim(-1, 1)\n", + " plt.ylim(-1, 2)" ] }, { diff --git a/docs/Example/Example_9_singularity.ipynb b/docs/Example/Example_9_singularity.ipynb index 5fd011664..af0cfa0f2 100644 --- a/docs/Example/Example_9_singularity.ipynb +++ b/docs/Example/Example_9_singularity.ipynb @@ -58,13 +58,13 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=2, device=device)\n", - "f = lambda x: torch.sin(2*(torch.log(x[:,[0]])+torch.log(x[:,[1]])))\n", - "dataset = create_dataset(f, n_var=2, ranges=[0.2,5], device=device)\n", + "model = KAN(width=[2, 1, 1], grid=5, k=3, seed=2, device=device)\n", + "f = lambda x: torch.sin(2 * (torch.log(x[:, [0]]) + torch.log(x[:, [1]])))\n", + "dataset = create_dataset(f, n_var=2, ranges=[0.2, 5], device=device)\n", "\n", "# train the model\n", "model.fit(dataset, opt=\"LBFGS\", steps=20);" @@ -121,9 +121,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'log')\n", - "model.fix_symbolic(0,1,0,'log')\n", - "model.fix_symbolic(1,0,0,'sin')" + "model.fix_symbolic(0, 0, 0, \"log\")\n", + "model.fix_symbolic(0, 1, 0, \"log\")\n", + "model.fix_symbolic(1, 0, 0, \"sin\")" ] }, { @@ -224,8 +224,8 @@ "import torch\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=0)\n", - "f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2)\n", + "model = KAN(width=[2, 1, 1], grid=5, k=3, seed=0)\n", + "f = lambda x: torch.sqrt(x[:, [0]] ** 2 + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2)\n", "\n", "# train the model\n", @@ -283,9 +283,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'x^2')\n", - "model.fix_symbolic(0,1,0,'x^2')\n", - "model.fix_symbolic(1,0,0,'sqrt')" + "model.fix_symbolic(0, 0, 0, \"x^2\")\n", + "model.fix_symbolic(0, 1, 0, \"x^2\")\n", + "model.fix_symbolic(1, 0, 0, \"sqrt\")" ] }, { @@ -303,7 +303,7 @@ } ], "source": [ - "model = model.rewind('0.4')\n", + "model = model.rewind(\"0.4\")\n", "model.get_act(dataset)" ] }, @@ -388,7 +388,14 @@ } ], "source": [ - "model.fit(dataset, opt=\"Adam\", steps=1000, lr=1e-3, update_grid=False, singularity_avoiding=True);" + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " steps=1000,\n", + " lr=1e-3,\n", + " update_grid=False,\n", + " singularity_avoiding=True,\n", + ");" ] }, { diff --git a/docs/Interp/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.rst b/docs/Interp/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.rst deleted file mode 100644 index 178fe9018..000000000 --- a/docs/Interp/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.rst +++ /dev/null @@ -1,51 +0,0 @@ -Interpretability 11: sparse initialization -========================================== - -.. code:: ipython3 - - from kan import * - - device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - print(device) - - model = KAN([5,5,5,1], sparse_init=False, device=device) - x = torch.rand(100,5).to(device) - model.get_act(x) - model.plot() - - -.. parsed-literal:: - - cuda - checkpoint directory created: ./model - saving model version 0.0 - - - -.. image:: Interp_11_sparse_init_files/Interp_11_sparse_init_1_1.png - - -.. code:: ipython3 - - from kan import * - - device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - print(device) - - model = KAN([5,5,5,1], sparse_init=True, device=device) - x = torch.rand(100,5).to(device) - model.get_act(x) - model.plot() - - -.. parsed-literal:: - - cuda - checkpoint directory created: ./model - saving model version 0.0 - - - -.. image:: Interp_11_sparse_init_files/Interp_11_sparse_init_2_1.png - - diff --git a/docs/Interp/Interp_10A_swap.ipynb b/docs/Interp/Interp_10A_swap.ipynb index fe87fbfd5..1290edd41 100644 --- a/docs/Interp/Interp_10A_swap.ipynb +++ b/docs/Interp/Interp_10A_swap.ipynb @@ -74,7 +74,7 @@ "torch.manual_seed(seed)\n", "np.random.seed(seed)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "\n", @@ -84,10 +84,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (9 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", + "middle = np.array(\n", + " [\n", + " np.sum(inputs[:, :3], axis=1) > 1.5,\n", + " np.sum(inputs[:, 3:6], axis=1) > 1.5,\n", + " np.sum(inputs[:, 6:9], axis=1) > 1.5,\n", + " ]\n", + ").astype(np.float32)\n", + "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:, None]\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", @@ -98,14 +104,28 @@ "model = KAN(width=width, seed=seed, noise_scale=1.0, device=device)\n", "depth = len(width) - 1\n", "\n", + "\n", "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", "\n", "\n", - "model.fit(dataset, lamb=0.001, lamb_entropy=5., steps=20, stop_grid_update_step=1000, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" + "model.fit(\n", + " dataset,\n", + " lamb=0.001,\n", + " lamb_entropy=5.0,\n", + " steps=20,\n", + " stop_grid_update_step=1000,\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"train_acc\", \"test_acc\", \"reg\"],\n", + ");" ] }, { @@ -115,7 +135,7 @@ "metadata": {}, "outputs": [], "source": [ - "#model.plot()" + "# model.plot()" ] }, { @@ -235,7 +255,7 @@ "torch.manual_seed(seed)\n", "np.random.seed(seed)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "inputs = []\n", @@ -244,10 +264,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (9 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", + "middle = np.array(\n", + " [\n", + " np.sum(inputs[:, :3], axis=1) > 1.5,\n", + " np.sum(inputs[:, 3:6], axis=1) > 1.5,\n", + " np.sum(inputs[:, 6:9], axis=1) > 1.5,\n", + " ]\n", + ").astype(np.float32)\n", + "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:, None]\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", @@ -258,14 +284,28 @@ "model = MLP(width=width, seed=seed, device=device)\n", "depth = len(width) - 1\n", "\n", + "\n", "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", "\n", "\n", - "model.fit(dataset, lamb=0.0001, lamb_entropy=2., steps=1000, reg_metric='w', metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" + "model.fit(\n", + " dataset,\n", + " lamb=0.0001,\n", + " lamb_entropy=2.0,\n", + " steps=1000,\n", + " reg_metric=\"w\",\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"train_acc\", \"test_acc\", \"reg\"],\n", + ");" ] }, { diff --git a/docs/Interp/Interp_10B_swap.ipynb b/docs/Interp/Interp_10B_swap.ipynb index f54b5b294..d9354682c 100644 --- a/docs/Interp/Interp_10B_swap.ipynb +++ b/docs/Interp/Interp_10B_swap.ipynb @@ -58,16 +58,25 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[10,10,5], seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2), device=device)\n", + "model = KAN(width=[10, 10, 5], seed=1, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2), device=device)\n", "\n", - "#f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2)\n", - "f = lambda x: torch.cat([x[:,[0]] + x[:,[1]], x[:,[2]] + x[:,[3]], x[:,[4]] + x[:,[5]], x[:,[6]] + x[:,[7]], x[:,[8]] + x[:,[9]]], dim=1)\n", + "# f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2)\n", + "f = lambda x: torch.cat(\n", + " [\n", + " x[:, [0]] + x[:, [1]],\n", + " x[:, [2]] + x[:, [3]],\n", + " x[:, [4]] + x[:, [5]],\n", + " x[:, [6]] + x[:, [7]],\n", + " x[:, [8]] + x[:, [9]],\n", + " ],\n", + " dim=1,\n", + ")\n", "dataset = create_dataset(f, n_var=10, device=device)\n", - "model.fit(dataset, steps=20, lamb=1e-2);\n" + "model.fit(dataset, steps=20, lamb=1e-2);" ] }, { @@ -156,7 +165,7 @@ "from kan import *\n", "from kan.MLP import MLP\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "inputs = []\n", @@ -165,16 +174,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (10 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "labels = np.sum(inputs.reshape(2**10,5,2), axis=2) % 2\n", + "labels = np.sum(inputs.reshape(2**10, 5, 2), axis=2) % 2\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", "dataset = create_dataset_from_data(inputs, labels, device=device)\n", "\n", - "model = MLP(width=[10,20,5], seed=5, device=device)\n", - "model.fit(dataset, steps=100, lamb=2e-4, reg_metric='w');" + "model = MLP(width=[10, 20, 5], seed=5, device=device)\n", + "model.fit(dataset, steps=100, lamb=2e-4, reg_metric=\"w\");" ] }, { diff --git a/docs/Interp/Interp_10_hessian.ipynb b/docs/Interp/Interp_10_hessian.ipynb index c889a6902..02306cc4b 100644 --- a/docs/Interp/Interp_10_hessian.ipynb +++ b/docs/Interp/Interp_10_hessian.ipynb @@ -57,23 +57,21 @@ "source": [ "from kan.utils import get_derivative\n", "import torch\n", - "from kan.MLP import MLP\n", "from kan.MultKAN import KAN\n", - "from kan.utils import create_dataset, model2param\n", - "import copy\n", + "from kan.utils import create_dataset\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: x[:,[0]]**2\n", + "f = lambda x: x[:, [0]] ** 2\n", "dataset = create_dataset(f, n_var=1, train_num=1000, device=device)\n", "\n", - "inputs = dataset['train_input']\n", - "labels = dataset['train_label']\n", + "inputs = dataset[\"train_input\"]\n", + "labels = dataset[\"train_label\"]\n", "\n", - "#model = MLP(width = [1,30,1])\n", - "model = KAN(width=[1,5,1], device=device)\n", - "model.fit(dataset, opt='Adam', lr=1e-2, lamb=0.000, steps=1000);" + "# model = MLP(width = [1,30,1])\n", + "model = KAN(width=[1, 5, 1], device=device)\n", + "model.fit(dataset, opt=\"Adam\", lr=1e-2, lamb=0.000, steps=1000);" ] }, { @@ -104,7 +102,7 @@ "metadata": {}, "outputs": [], "source": [ - "hess = get_derivative(model, inputs, labels, derivative='hessian')\n", + "hess = get_derivative(model, inputs, labels, derivative=\"hessian\")\n", "values, vectors = torch.linalg.eigh(hess)" ] }, @@ -127,8 +125,9 @@ ], "source": [ "import matplotlib.pyplot as plt\n", - "plt.plot(values.cpu().numpy()[0], marker='o');\n", - "plt.yscale('log')" + "\n", + "plt.plot(values.cpu().numpy()[0], marker=\"o\")\n", + "plt.yscale(\"log\")" ] }, { diff --git a/docs/Interp/Interp_11_sparse_init.ipynb b/docs/Interp/Interp_11_sparse_init.ipynb index dfe4cef31..5b6945a86 100644 --- a/docs/Interp/Interp_11_sparse_init.ipynb +++ b/docs/Interp/Interp_11_sparse_init.ipynb @@ -37,11 +37,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN([5,5,5,1], sparse_init=False, device=device)\n", - "x = torch.rand(100,5).to(device)\n", + "model = KAN([5, 5, 5, 1], sparse_init=False, device=device)\n", + "x = torch.rand(100, 5).to(device)\n", "model.get_act(x)\n", "model.plot()" ] @@ -75,11 +75,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN([5,5,5,1], sparse_init=True, device=device)\n", - "x = torch.rand(100,5).to(device)\n", + "model = KAN([5, 5, 5, 1], sparse_init=True, device=device)\n", + "x = torch.rand(100, 5).to(device)\n", "model.get_act(x)\n", "model.plot()" ] diff --git a/docs/Interp/Interp_1_Hello, MultKAN.ipynb b/docs/Interp/Interp_1_Hello, MultKAN.ipynb index a226b496b..1291a896a 100644 --- a/docs/Interp/Interp_1_Hello, MultKAN.ipynb +++ b/docs/Interp/Interp_1_Hello, MultKAN.ipynb @@ -63,14 +63,15 @@ ], "source": [ "from kan import *\n", + "\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], device=device)\n", + "model = KAN(width=[2, 5, 1], device=device)\n", "\n", - "f = lambda x: x[:,0] * x[:,1]\n", + "f = lambda x: x[:, 0] * x[:, 1]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "model.fit(dataset, steps=20, lamb=0.001);" ] @@ -138,7 +139,7 @@ } ], "source": [ - "model = KAN(width=[2,[5,2],1], base_fun='identity', device=device)\n", + "model = KAN(width=[2, [5, 2], 1], base_fun=\"identity\", device=device)\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -330,7 +331,7 @@ ], "source": [ "sf = model.symbolic_formula()[0][0]\n", - "nsimplify(ex_round(ex_round(sf, 3),3))" + "nsimplify(ex_round(ex_round(sf, 3), 3))" ] }, { diff --git a/docs/Interp/Interp_2_Advanced MultKAN.ipynb b/docs/Interp/Interp_2_Advanced MultKAN.ipynb index 902191af8..aa7b7eb86 100644 --- a/docs/Interp/Interp_2_Advanced MultKAN.ipynb +++ b/docs/Interp/Interp_2_Advanced MultKAN.ipynb @@ -45,11 +45,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,[3,2],1], device=device)\n", - "x = torch.randn(100,2).to(device)\n", + "model = KAN(width=[2, [3, 2], 1], device=device)\n", + "x = torch.randn(100, 2).to(device)\n", "model(x)\n", "model.plot()" ] @@ -88,7 +88,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=3, device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=3, device=device)\n", "model(x)\n", "model.plot()" ] @@ -127,7 +127,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=4, device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=4, device=device)\n", "model(x)\n", "model.plot()" ] @@ -174,7 +174,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=[[],[2,3],[]], device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=[[], [2, 3], []], device=device)\n", "model(x)\n", "model.plot()" ] @@ -213,7 +213,7 @@ } ], "source": [ - "model = KAN(width=[2,[2,2],[1,3],[3,2],[1,1]], mult_arity=2, device=device)\n", + "model = KAN(width=[2, [2, 2], [1, 3], [3, 2], [1, 1]], mult_arity=2, device=device)\n", "model(x)\n", "model.plot()" ] diff --git a/docs/Interp/Interp_3_KAN_Compiler.ipynb b/docs/Interp/Interp_3_KAN_Compiler.ipynb index a328a235f..3ed847eec 100644 --- a/docs/Interp/Interp_3_KAN_Compiler.ipynb +++ b/docs/Interp/Interp_3_KAN_Compiler.ipynb @@ -46,15 +46,15 @@ "from kan.utils import create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "input_variables = x,y = symbols('x y')\n", - "expr = exp(sin(pi*x)+y**2)\n", + "input_variables = x, y = symbols(\"x y\")\n", + "expr = exp(sin(pi * x) + y**2)\n", "\n", "model = kanpiler(input_variables, expr).to(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,0]) + x[:,1]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, 0]) + x[:, 1] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "model.get_act(dataset)\n", "\n", @@ -88,18 +88,17 @@ ], "source": [ "from kan.feynman import get_feynman_dataset\n", - "import matplotlib.pyplot as plt\n", "\n", - "problem_id = 36 # problem_id in 1-120\n", + "problem_id = 36 # problem_id in 1-120\n", "input_variables, expr, f, ranges = get_feynman_dataset(problem_id)\n", "n_var = len(input_variables)\n", "model = kanpiler(input_variables, expr)\n", "\n", "dataset = create_dataset(f, n_var=n_var, ranges=ranges)\n", "model.get_act(dataset)\n", - "#model.plot(in_vars=input_variables, out_vars=[expr], beta=10000, title='P{}'.format(problem_id))\n", - "model.plot(in_vars=input_variables, out_vars=[symbols('omega')], beta=10000)\n", - "#plt.savefig('./fig1.pdf', bbox_inches='tight', dpi=200)" + "# model.plot(in_vars=input_variables, out_vars=[expr], beta=10000, title='P{}'.format(problem_id))\n", + "model.plot(in_vars=input_variables, out_vars=[symbols(\"omega\")], beta=10000)\n", + "# plt.savefig('./fig1.pdf', bbox_inches='tight', dpi=200)" ] }, { @@ -128,7 +127,7 @@ } ], "source": [ - "torch.mean((model(dataset['train_input'])-dataset['train_label'])**2)" + "torch.mean((model(dataset[\"train_input\"]) - dataset[\"train_label\"]) ** 2)" ] }, { @@ -233,7 +232,7 @@ } ], "source": [ - "model.expand_width(2, 2, sum_bool=False, mult_arity=[2,3])\n", + "model.expand_width(2, 2, sum_bool=False, mult_arity=[2, 3])\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -264,9 +263,9 @@ } ], "source": [ - "model.perturb(mag=0.1, mode='all')\n", + "model.perturb(mag=0.1, mode=\"all\")\n", "model.get_act(dataset)\n", - "model.plot(metric='forward_n')\n", + "model.plot(metric=\"forward_n\")\n", "# purple means both symbolic front (red) and spline front (black) are active" ] }, diff --git a/docs/Interp/Interp_4_feature_attribution.ipynb b/docs/Interp/Interp_4_feature_attribution.ipynb index 5f0d764bc..d138fffed 100644 --- a/docs/Interp/Interp_4_feature_attribution.ipynb +++ b/docs/Interp/Interp_4_feature_attribution.ipynb @@ -57,16 +57,16 @@ "from kan import *\n", "from sympy import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# let's construct a dataset\n", - "f = lambda x: x[:,0]**2 + 0.3*x[:,1] + 0.1*x[:,2]**3 + 0.0*x[:,3]\n", + "f = lambda x: x[:, 0] ** 2 + 0.3 * x[:, 1] + 0.1 * x[:, 2] ** 3 + 0.0 * x[:, 3]\n", "dataset = create_dataset(f, n_var=4, device=device)\n", "\n", - "input_vars = [r'$x_'+str(i)+'$' for i in range(4)]\n", + "input_vars = [r\"$x_\" + str(i) + \"$\" for i in range(4)]\n", "\n", - "model = KAN(width=[4,5,1], device=device)\n", + "model = KAN(width=[4, 5, 1], device=device)\n", "model.fit(dataset, steps=40, lamb=0.001);" ] }, @@ -159,7 +159,7 @@ ], "source": [ "# the 2nd neuron (index start from 0) in the 1st layer\n", - "model.attribute(1,2)" + "model.attribute(1, 2)" ] }, { @@ -193,7 +193,7 @@ "source": [ "# the 3nd neuron (index start from 0) in the 1st layer\n", "# note the y axis scale is really small\n", - "model.attribute(1,3)" + "model.attribute(1, 3)" ] }, { @@ -284,18 +284,20 @@ "# let's construct a dataset\n", "n_var = 100\n", "\n", + "\n", "def f(x):\n", " y = 0\n", " for i in range(n_var):\n", " # exponential decay\n", - " y += x[:,[i]]**2*0.5**i\n", + " y += x[:, [i]] ** 2 * 0.5**i\n", " return y\n", - " \n", + "\n", + "\n", "dataset = create_dataset(f, n_var=n_var, device=device)\n", "\n", - "input_vars = [r'$x_{'+str(i)+'}$' for i in range(n_var)]\n", + "input_vars = [r\"$x_{\" + str(i) + \"}$\" for i in range(n_var)]\n", "\n", - "model = KAN(width=[n_var,10,10,1], seed=2, device=device)\n", + "model = KAN(width=[n_var, 10, 10, 1], seed=2, device=device)\n", "model.fit(dataset, steps=50, lamb=1e-3);" ] }, @@ -335,7 +337,7 @@ } ], "source": [ - "model = model.rewind('0.1')" + "model = model.rewind(\"0.1\")" ] }, { @@ -366,11 +368,11 @@ } ], "source": [ - "plt.scatter(np.arange(n_var)+1, model.feature_score.cpu().detach().numpy())\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.xlabel('rank of input features', fontsize=15)\n", - "plt.ylabel('feature attribution score', fontsize=15)" + "plt.scatter(np.arange(n_var) + 1, model.feature_score.cpu().detach().numpy())\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"rank of input features\", fontsize=15)\n", + "plt.ylabel(\"feature attribution score\", fontsize=15)" ] }, { diff --git a/docs/Interp/Interp_5_test_symmetry.ipynb b/docs/Interp/Interp_5_test_symmetry.ipynb index 6f4c0bde8..15fbb8873 100644 --- a/docs/Interp/Interp_5_test_symmetry.ipynb +++ b/docs/Interp/Interp_5_test_symmetry.ipynb @@ -71,9 +71,9 @@ } ], "source": [ - "f = lambda x: x[:,[0]] * x[:,[1]] + x[:,[2]] * x[:,[3]] + x[:,[4]] * x[:,[5]]\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'add')" + "f = lambda x: x[:, [0]] * x[:, [1]] + x[:, [2]] * x[:, [3]] + x[:, [4]] * x[:, [5]]\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "detect_separability(f, x, \"add\")" ] }, { @@ -91,9 +91,13 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'mul');" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "detect_separability(f, x, \"mul\");" ] }, { @@ -122,10 +126,14 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "groups = [[0,1],[2,3],[4,5]]\n", - "test_separability(f, x, groups, 'mul')" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "groups = [[0, 1], [2, 3], [4, 5]]\n", + "test_separability(f, x, groups, \"mul\")" ] }, { @@ -146,7 +154,7 @@ } ], "source": [ - "test_separability(f, x, [[0,1],[2,4],[3,5]], 'mul')" + "test_separability(f, x, [[0, 1], [2, 4], [3, 5]], \"mul\")" ] }, { @@ -167,9 +175,11 @@ } ], "source": [ - "f = lambda x: torch.sin((x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]]))\n", - "x = torch.rand(100,6) * 2 - 1\n", - "test_separability(f, x, [[0,1],[2,3],[4,5]], 'mul')" + "f = lambda x: torch.sin(\n", + " (x[:, [0]] + x[:, [1]]) * (x[:, [2]] + x[:, [3]]) * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "test_separability(f, x, [[0, 1], [2, 3], [4, 5]], \"mul\")" ] }, { @@ -190,7 +200,7 @@ } ], "source": [ - "test_general_separability(f, x, [[0,1],[2,3],[4,5]])" + "test_general_separability(f, x, [[0, 1], [2, 3], [4, 5]])" ] }, { @@ -221,11 +231,15 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "print('[0,1]:', test_symmetry(f, x, [0,1]))\n", - "print('[0,2]:', test_symmetry(f, x, [0,2]))\n", - "print('[2,3]:', test_symmetry(f, x, [2,3]))" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "print(\"[0,1]:\", test_symmetry(f, x, [0, 1]))\n", + "print(\"[0,2]:\", test_symmetry(f, x, [0, 2]))\n", + "print(\"[2,3]:\", test_symmetry(f, x, [2, 3]))" ] }, { @@ -247,10 +261,10 @@ "from sympy import *\n", "\n", "# the function is only dependent on b/c, but not on the individual values of b and c.\n", - "f = lambda x: x[:,[0]] * torch.sqrt(1 + (x[:,[1]]/x[:,[2]])**2)\n", - "input_vars = a, b, c = symbols('a b c')\n", - "symmetry_var = b/c\n", - "x = torch.rand(100,3) * 2 - 1\n", + "f = lambda x: x[:, [0]] * torch.sqrt(1 + (x[:, [1]] / x[:, [2]]) ** 2)\n", + "input_vars = a, b, c = symbols(\"a b c\")\n", + "symmetry_var = b / c\n", + "x = torch.rand(100, 3) * 2 - 1\n", "test_symmetry_var(f, x, input_vars, symmetry_var);" ] }, @@ -300,9 +314,16 @@ } ], "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + ((x[:,[4]]**2 + x[:,[5]]**2) ** 2 + (x[:,[6]]**2 + x[:,[7]]**2) ** 2) ** 2\n", - "x = torch.rand(100,8) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" + "f = (\n", + " lambda x: (\n", + " (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2 + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + " )\n", + " ** 2\n", + " + ((x[:, [4]] ** 2 + x[:, [5]] ** 2) ** 2 + (x[:, [6]] ** 2 + x[:, [7]] ** 2) ** 2)\n", + " ** 2\n", + ")\n", + "x = torch.rand(100, 8) * 2 - 1\n", + "plot_tree(f, x, style=\"tree\") # by default, style = 'tree'" ] }, { @@ -323,7 +344,7 @@ } ], "source": [ - "plot_tree(f, x, style='box')" + "plot_tree(f, x, style=\"box\")" ] }, { @@ -344,9 +365,15 @@ } ], "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + x[:,[4]]**2\n", - "x = torch.rand(100,5) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" + "f = (\n", + " lambda x: (\n", + " (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2 + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + " )\n", + " ** 2\n", + " + x[:, [4]] ** 2\n", + ")\n", + "x = torch.rand(100, 5) * 2 - 1\n", + "plot_tree(f, x, style=\"tree\") # by default, style = 'tree'" ] }, { @@ -367,7 +394,7 @@ } ], "source": [ - "plot_tree(f, x, style='box')" + "plot_tree(f, x, style=\"box\")" ] }, { diff --git a/docs/Interp/Interp_6_test_symmetry_NN.ipynb b/docs/Interp/Interp_6_test_symmetry_NN.ipynb index 64edab6a5..ea7d8d6a7 100644 --- a/docs/Interp/Interp_6_test_symmetry_NN.ipynb +++ b/docs/Interp/Interp_6_test_symmetry_NN.ipynb @@ -29,8 +29,11 @@ "from kan import *\n", "from kan.hypothesis import plot_tree\n", "\n", - "f = lambda x: (x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2\n", - "x = torch.rand(100,4) * 2 - 1\n", + "f = (\n", + " lambda x: (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2\n", + " + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + ")\n", + "x = torch.rand(100, 4) * 2 - 1\n", "plot_tree(f, x)" ] }, @@ -72,11 +75,11 @@ } ], "source": [ - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dataset = create_dataset(f, n_var=4, device=device)\n", - "model = KAN(width=[4,5,5,1], seed=0, device=device)\n", + "model = KAN(width=[4, 5, 5, 1], seed=0, device=device)\n", "model.fit(dataset, steps=100);" ] }, diff --git a/docs/Interp/Interp_8_adding_auxillary_variables.ipynb b/docs/Interp/Interp_8_adding_auxillary_variables.ipynb index f8dc95b2e..c9d8eeeb6 100644 --- a/docs/Interp/Interp_8_adding_auxillary_variables.ipynb +++ b/docs/Interp/Interp_8_adding_auxillary_variables.ipynb @@ -32,16 +32,16 @@ "torch.manual_seed(seed)\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "input_variables = m0, v, c = symbols('m0 v c')\n", + "input_variables = m0, v, c = symbols(\"m0 v c\")\n", "\n", "# define auxillary variables\n", - "beta = v/c\n", - "gamma = 1/sqrt(1-beta**2)\n", + "beta = v / c\n", + "gamma = 1 / sqrt(1 - beta**2)\n", "\n", "aux_vars = (beta, gamma)\n", "\n", - "f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2)\n", - "dataset = create_dataset(f, n_var=3, ranges=[[0,1],[0,0.9],[1.1,2]])\n", + "f = lambda x: x[:, [0]] / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2)\n", + "dataset = create_dataset(f, n_var=3, ranges=[[0, 1], [0, 0.9], [1.1, 2]])\n", "\n", "# add auxillary variables\n", "dataset = augment_input(input_variables, aux_vars, dataset)\n", @@ -64,7 +64,7 @@ } ], "source": [ - "model = MultKAN(width=[5,[0,1]], mult_arity=2, grid=3, k=3, seed=seed)" + "model = MultKAN(width=[5, [0, 1]], mult_arity=2, grid=3, k=3, seed=seed)" ] }, { @@ -85,8 +85,13 @@ } ], "source": [ - "model(dataset['train_input'])\n", - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model(dataset[\"train_input\"])\n", + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -139,7 +144,12 @@ } ], "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -178,7 +188,12 @@ } ], "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -289,7 +304,7 @@ "source": [ "from kan.utils import ex_round\n", "\n", - "nsimplify(ex_round(ex_round(ex_round(sf,6),3),3))" + "nsimplify(ex_round(ex_round(ex_round(sf, 6), 3), 3))" ] }, { diff --git a/docs/Interp/Interp_9_different_plotting_metrics.ipynb b/docs/Interp/Interp_9_different_plotting_metrics.ipynb index 2cfaccaba..3a4bb7876 100644 --- a/docs/Interp/Interp_9_different_plotting_metrics.ipynb +++ b/docs/Interp/Interp_9_different_plotting_metrics.ipynb @@ -41,13 +41,13 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], device=device)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "model = KAN(width=[2, 5, 1], device=device)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.fit(dataset, steps = 20, lamb=1e-3);" + "model.fit(dataset, steps=20, lamb=1e-3);" ] }, { @@ -79,7 +79,7 @@ } ], "source": [ - "model.plot(metric='forward_u')" + "model.plot(metric=\"forward_u\")" ] }, { @@ -102,7 +102,7 @@ } ], "source": [ - "model.plot(metric='forward_n')" + "model.plot(metric=\"forward_n\")" ] }, { @@ -123,7 +123,7 @@ } ], "source": [ - "model.plot(metric='backward')" + "model.plot(metric=\"backward\")" ] } ], diff --git a/docs/Physics/Physics_1_Lagrangian.ipynb b/docs/Physics/Physics_1_Lagrangian.ipynb index f847e427f..d8dfb54fe 100644 --- a/docs/Physics/Physics_1_Lagrangian.ipynb +++ b/docs/Physics/Physics_1_Lagrangian.ipynb @@ -24,44 +24,43 @@ "seed = 0\n", "torch.manual_seed(seed)\n", "\n", - "#example = 'harmonic_oscillator'\n", - "#example = 'single_pendulum'\n", - "example = 'relativistic_mass'\n", + "# example = 'harmonic_oscillator'\n", + "# example = 'single_pendulum'\n", + "example = \"relativistic_mass\"\n", "\n", "# three examples: harmonic oscillator, single pendulum, double pendulum\n", "\n", "# dimension of q\n", "# Lagrangian: (q, qd) -> (qdd)\n", "\n", - "if example == 'harmonic_oscillator':\n", + "if example == \"harmonic_oscillator\":\n", " n_sample = 1000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qd = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qdd = - q\n", + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qd = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qdd = -q\n", " x = torch.cat([q, qd], dim=1)\n", - " \n", - "if example == 'single_pendulum':\n", + "\n", + "if example == \"single_pendulum\":\n", " n_sample = 1000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qd = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qdd = - torch.sin(q)\n", + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qd = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qdd = -torch.sin(q)\n", " x = torch.cat([q, qd], dim=1)\n", - " \n", - "if example == 'relativistic_mass':\n", + "\n", + "if example == \"relativistic_mass\":\n", " n_sample = 10000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " #qd = torch.rand(size=(n_sample,1)) * 1.998 - 0.999\n", - " #qd = 0.95 + torch.rand(size=(n_sample,1)) * 0.05\n", - " qd = torch.rand(size=(n_sample,1)) * 2 - 1\n", - " qdd = (1 - qd**2)**(3/2)\n", - " x = torch.cat([q, qd], dim=1)\n", - "\n" + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " # qd = torch.rand(size=(n_sample,1)) * 1.998 - 0.999\n", + " # qd = 0.95 + torch.rand(size=(n_sample,1)) * 0.05\n", + " qd = torch.rand(size=(n_sample, 1)) * 2 - 1\n", + " qdd = (1 - qd**2) ** (3 / 2)\n", + " x = torch.cat([q, qd], dim=1)" ] }, { @@ -82,8 +81,8 @@ "from kan.compiler import kanpiler\n", "from sympy import *\n", "\n", - "input_variables = symbol_x, symbol_vx = symbols('x v_x')\n", - "expr = symbol_vx ** 2\n", + "input_variables = symbol_x, symbol_vx = symbols(\"x v_x\")\n", + "expr = symbol_vx**2\n", "model = kanpiler(input_variables, expr, grid=20)" ] }, @@ -134,7 +133,7 @@ } ], "source": [ - "model.perturb(mode='best', mag=0.1)\n", + "model.perturb(mode=\"best\", mag=0.1)\n", "model.get_act(x)\n", "model.plot()" ] @@ -157,49 +156,54 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", + "from kan.utils import create_dataset_from_data\n", "\n", "torch.use_deterministic_algorithms(True)\n", "\n", + "\n", "def closure():\n", - " \n", " global loss\n", " optimizer.zero_grad()\n", - " \n", + "\n", " jacobian = batch_jacobian(model, x, create_graph=True)\n", " hessian = batch_hessian(model, x, create_graph=True)\n", - " Lqdqd = hessian[:,d:,d:]\n", - " Lq = jacobian[:,:d]\n", - " Lqqd = hessian[:,d:,:d]\n", + " Lqdqd = hessian[:, d:, d:]\n", + " Lq = jacobian[:, :d]\n", + " Lqqd = hessian[:, d:, :d]\n", "\n", - " Lqqd_qd_prod = torch.einsum('ijk,ik->ij', Lqqd, qd)\n", + " Lqqd_qd_prod = torch.einsum(\"ijk,ik->ij\", Lqqd, qd)\n", "\n", - " qdd_pred = torch.einsum('ijk,ik->ij', torch.linalg.inv(Lqdqd), Lq - Lqqd_qd_prod)\n", - " loss = torch.mean((qdd - qdd_pred)**2)\n", + " qdd_pred = torch.einsum(\"ijk,ik->ij\", torch.linalg.inv(Lqdqd), Lq - Lqqd_qd_prod)\n", + " loss = torch.mean((qdd - qdd_pred) ** 2)\n", "\n", " loss.backward()\n", " return loss\n", "\n", + "\n", "steps = 20\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(params, lr=1e-2)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(params, lr=1e-2)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "\n", "for _ in pbar:\n", - " \n", " # update grid\n", " if _ < 5 and _ % 20 == 0:\n", " model.update_grid(x)\n", - " \n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())\n", - " \n", - " " + " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())" ] }, { @@ -287,8 +291,8 @@ } ], "source": [ - "model.unfix_symbolic(0,0,0)\n", - "model.suggest_symbolic(0,0,0)" + "model.unfix_symbolic(0, 0, 0)\n", + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -328,8 +332,8 @@ } ], "source": [ - "model.unfix_symbolic(0,1,0)\n", - "model.suggest_symbolic(0,1,0)" + "model.unfix_symbolic(0, 1, 0)\n", + "model.suggest_symbolic(0, 1, 0)" ] }, { @@ -350,7 +354,7 @@ } ], "source": [ - "x, y = model.get_fun(0,1,0)" + "x, y = model.get_fun(0, 1, 0)" ] }, { @@ -370,11 +374,9 @@ } ], "source": [ - "from kan.utils import create_dataset_from_data\n", - "\n", - "dataset2 = create_dataset_from_data(x[:,None], y[:,None])\n", - "model2 = KAN(width=[1,1,1])\n", - "model2.fix_symbolic(0,0,0,'x^2',fit_params_bool=False)" + "dataset2 = create_dataset_from_data(x[:, None], y[:, None])\n", + "model2 = KAN(width=[1, 1, 1])\n", + "model2.fix_symbolic(0, 0, 0, \"x^2\", fit_params_bool=False)" ] }, { @@ -520,7 +522,7 @@ } ], "source": [ - "model2.suggest_symbolic(1,0,0)" + "model2.suggest_symbolic(1, 0, 0)" ] }, { @@ -550,7 +552,8 @@ ], "source": [ "from kan.utils import fit_params\n", - "fit_params(x**2, y, lambda x: x**(1/2))" + "\n", + "fit_params(x**2, y, lambda x: x ** (1 / 2))" ] }, { @@ -595,6 +598,7 @@ ], "source": [ "from kan.utils import ex_round\n", + "\n", "ex_round(model2.symbolic_formula()[0][0], 2)" ] }, diff --git a/docs/Physics/Physics_2A_conservation_law.ipynb b/docs/Physics/Physics_2A_conservation_law.ipynb index 25838b472..49d4e34f6 100644 --- a/docs/Physics/Physics_2A_conservation_law.ipynb +++ b/docs/Physics/Physics_2A_conservation_law.ipynb @@ -47,20 +47,23 @@ "source": [ "from kan import *\n", "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", "\n", - "model = KAN(width=[2,1], seed=42)\n", + "model = KAN(width=[2, 1], seed=42)\n", "\n", "# the model learns the Hamiltonian H = 1/2 * (x**2 + p**2)\n", - "x = torch.rand(1000,2) * 2 - 1\n", - "flow = torch.cat([x[:,[1]], -x[:,[0]]], dim=1)\n", + "x = torch.rand(1000, 2) * 2 - 1\n", + "flow = torch.cat([x[:, [1]], -x[:, [0]]], dim=1)\n", + "\n", "\n", "def pred_fn(model, x):\n", " grad = batch_jacobian(model, x, create_graph=True)\n", - " grad_normalized = grad/torch.linalg.norm(grad, dim=1, keepdim=True)\n", + " grad_normalized = grad / torch.linalg.norm(grad, dim=1, keepdim=True)\n", " return grad_normalized\n", "\n", - "loss_fn = lambda grad_normalized, flow: torch.mean(torch.sum(flow * grad_normalized, dim=1)**2)\n", + "\n", + "loss_fn = lambda grad_normalized, flow: torch.mean(\n", + " torch.sum(flow * grad_normalized, dim=1) ** 2\n", + ")\n", "\n", "\n", "dataset = create_dataset_from_data(x, flow)\n", @@ -130,6 +133,7 @@ ], "source": [ "from kan.utils import ex_round\n", + "\n", "ex_round(model.symbolic_formula()[0][0], 3)" ] }, diff --git a/docs/Physics/Physics_2B_conservation_law_2D.ipynb b/docs/Physics/Physics_2B_conservation_law_2D.ipynb index 33189decb..751163190 100644 --- a/docs/Physics/Physics_2B_conservation_law_2D.ipynb +++ b/docs/Physics/Physics_2B_conservation_law_2D.ipynb @@ -34,63 +34,71 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", + "from kan.utils import batch_jacobian\n", "\n", "torch.use_deterministic_algorithms(True)\n", "\n", "\n", - "#model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", - "#model = KAN(width=[4,[0,2],1], seed=2, base_fun='identity')\n", - "model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=2, base_fun='identity')\n", + "model = KAN(width=[4, [0, 2], 1], seed=12, base_fun=\"identity\")\n", "\n", "# the model learns the Hamiltonian H = 1/2 * (x**2 + p**2)\n", - "x = torch.rand(1000,4) * 2 - 1\n", - "flow = torch.cat([x[:,[1]], -x[:,[0]], x[:,[3]], -x[:,[2]]], dim=1)\n", - "flow = flow/torch.linalg.norm(flow, dim=1, keepdim=True)\n", + "x = torch.rand(1000, 4) * 2 - 1\n", + "flow = torch.cat([x[:, [1]], -x[:, [0]], x[:, [3]], -x[:, [2]]], dim=1)\n", + "flow = flow / torch.linalg.norm(flow, dim=1, keepdim=True)\n", "\n", - "loss_fn = lambda v1, v2: torch.mean(torch.sum(v1 * v2, dim=1)**2)\n", + "loss_fn = lambda v1, v2: torch.mean(torch.sum(v1 * v2, dim=1) ** 2)\n", "\n", "\n", "def get_grad_normalized(model, x):\n", " grad = batch_jacobian(model, x, create_graph=True)\n", - " grad_normalized = grad/torch.linalg.norm(grad, dim=1, keepdim=True)\n", + " grad_normalized = grad / torch.linalg.norm(grad, dim=1, keepdim=True)\n", " return grad_normalized\n", "\n", + "\n", "def closure():\n", - " \n", " global cq_loss, reg_loss\n", " optimizer.zero_grad()\n", "\n", " grads = []\n", " grad = get_grad_normalized(model, x)\n", " cq_loss = loss_fn(grad, flow)\n", - " reg_loss = model.reg(lamb_l1=1., entropy_offset=1e-4, lamb_coef=1.)\n", - " \n", + " reg_loss = model.reg(lamb_l1=1.0, entropy_offset=1e-4, lamb_coef=1.0)\n", + "\n", " lamb = 1e-2\n", " objective = cq_loss + lamb * reg_loss\n", " objective.backward()\n", " return objective\n", "\n", + "\n", "steps = 50\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(params, lr=1e-2)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(params, lr=1e-2)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "\n", "for _ in pbar:\n", - " \n", " # update grid\n", " if _ < 5 and _ % 20 == 0:\n", " model.update_grid_from_samples(x)\n", - " \n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| cq_loss: %.2e | reg_loss: %.2e |\" % (cq_loss.cpu().detach().numpy(), reg_loss.cpu().detach().numpy()))\n", - " \n", - " " + " pbar.set_description(\n", + " \"| cq_loss: %.2e | reg_loss: %.2e |\"\n", + " % (cq_loss.cpu().detach().numpy(), reg_loss.cpu().detach().numpy())\n", + " )" ] }, { @@ -111,7 +119,7 @@ } ], "source": [ - "#model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", "model.plot()" ] }, @@ -176,7 +184,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),3)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 3)" ] }, { @@ -205,7 +214,7 @@ } ], "source": [ - "#model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", "model.plot()" ] }, @@ -275,8 +284,8 @@ } ], "source": [ - "model.unfix_symbolic(1,0,0)\n", - "model.fix_symbolic(1,0,0,'x')" + "model.unfix_symbolic(1, 0, 0)\n", + "model.fix_symbolic(1, 0, 0, \"x\")" ] }, { @@ -302,7 +311,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),3)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 3)" ] }, { @@ -409,8 +419,8 @@ } ], "source": [ - "model.unfix_symbolic(1,1,0)\n", - "model.fix_symbolic(1,1,0,'x')" + "model.unfix_symbolic(1, 1, 0)\n", + "model.fix_symbolic(1, 1, 0, \"x\")" ] }, { @@ -436,7 +446,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),4)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 4)" ] }, { diff --git a/docs/Physics/Physics_3_blackhole.ipynb b/docs/Physics/Physics_3_blackhole.ipynb index 8decd1c05..321221fa4 100644 --- a/docs/Physics/Physics_3_blackhole.ipynb +++ b/docs/Physics/Physics_3_blackhole.ipynb @@ -23,41 +23,87 @@ "torch.use_deterministic_algorithms(True)\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "#model = KAN(width=[1,5,5,1], grid=5, grid_range=[1.2,3], grid_eps=0.)\n", - "#model = KAN(width=[1,1], grid=1, grid_range=[1.2,3], grid_eps=0., base_fun='zero')\n", - "#model.speed()\n", - "model = MLP(width=[1,20,20,1])\n", + "# model = KAN(width=[1,5,5,1], grid=5, grid_range=[1.2,3], grid_eps=0.)\n", + "# model = KAN(width=[1,1], grid=1, grid_range=[1.2,3], grid_eps=0., base_fun='zero')\n", + "# model.speed()\n", + "model = MLP(width=[1, 20, 20, 1])\n", + "\n", + "# model = lambda x: 2 * torch.sqrt(x) + torch.log((torch.sqrt(x)-1)/(torch.sqrt(x)+1))\n", "\n", - "#model = lambda x: 2 * torch.sqrt(x) + torch.log((torch.sqrt(x)-1)/(torch.sqrt(x)+1))\n", "\n", "# Schwarzschild 2M = 1\n", "def g(x_):\n", " bs = x_.shape[0]\n", - " t = x_[:,0]\n", + " t = x_[:, 0]\n", " a = torch.ones_like(t)\n", - " x = x_[:,1]\n", - " y = x_[:,2]\n", - " z = x_[:,3]\n", - " r = torch.sqrt(x**2+y**2+z**2)\n", - " stack1 = torch.stack([torch.ones(bs,)-1/r, torch.zeros(bs,), torch.zeros(bs,), torch.zeros(bs,)])\n", - " stack2 = torch.stack([torch.zeros(bs,), -(1+x**2/((r-1)*r**2)), -x*y/((r-1)*r**2), -x*z/((r-1)*r**2)])\n", - " stack3 = torch.stack([torch.zeros(bs,), -x*y/((r-1)*r**2), -(1+y**2/((r-1)*r**2)), -y*z/((r-1)*r**2)])\n", - " stack4 = torch.stack([torch.zeros(bs,), -x*z/((r-1)*r**2), -y*z/((r-1)*r**2), -(1+z**2/((r-1)*r**2))])\n", - " gs = torch.stack([stack1, stack2, stack3, stack4]).permute(2,0,1)\n", + " x = x_[:, 1]\n", + " y = x_[:, 2]\n", + " z = x_[:, 3]\n", + " r = torch.sqrt(x**2 + y**2 + z**2)\n", + " stack1 = torch.stack(\n", + " [\n", + " torch.ones(\n", + " bs,\n", + " )\n", + " - 1 / r,\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " ]\n", + " )\n", + " stack2 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -(1 + x**2 / ((r - 1) * r**2)),\n", + " -x * y / ((r - 1) * r**2),\n", + " -x * z / ((r - 1) * r**2),\n", + " ]\n", + " )\n", + " stack3 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -x * y / ((r - 1) * r**2),\n", + " -(1 + y**2 / ((r - 1) * r**2)),\n", + " -y * z / ((r - 1) * r**2),\n", + " ]\n", + " )\n", + " stack4 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -x * z / ((r - 1) * r**2),\n", + " -y * z / ((r - 1) * r**2),\n", + " -(1 + z**2 / ((r - 1) * r**2)),\n", + " ]\n", + " )\n", + " gs = torch.stack([stack1, stack2, stack3, stack4]).permute(2, 0, 1)\n", " return gs\n", "\n", + "\n", "def transform_g(transform, g, x):\n", - " jac = batch_jacobian(transform, x, create_graph=True, mode='vector')\n", + " jac = batch_jacobian(transform, x, create_graph=True, mode=\"vector\")\n", " jac_inv = torch.inverse(jac)\n", - " return torch.matmul(torch.matmul(jac_inv.permute(0,2,1), g(x)),jac_inv)\n", + " return torch.matmul(torch.matmul(jac_inv.permute(0, 2, 1), g(x)), jac_inv)\n", + "\n", "\n", "def transform(x):\n", - " t = x[:,[0]]\n", - " r = torch.linalg.norm(x[:,1:], dim=1, keepdim=True)\n", + " t = x[:, [0]]\n", + " r = torch.linalg.norm(x[:, 1:], dim=1, keepdim=True)\n", " tp = t + model(r)\n", - " #u = torch.sqrt(r)\n", - " #tp = t - (2*u+torch.log((u-1)/(u+1)))\n", - " return torch.cat([tp, x[:,1:]], dim=1)\n" + " # u = torch.sqrt(r)\n", + " # tp = t - (2*u+torch.log((u-1)/(u+1)))\n", + " return torch.cat([tp, x[:, 1:]], dim=1)" ] }, { @@ -76,50 +122,58 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", "\n", "\n", "steps = 5\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)\n", - "#optimizer = torch.optim.Adam([], lr=1e-3)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)\n", + "# optimizer = torch.optim.Adam([], lr=1e-3)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "n_train = 10000\n", - "W = torch.normal(0,1,size=(n_train,4))\n", - "input_ = torch.empty(n_train,4, requires_grad=False)\n", - "input_[:,0] = torch.rand(n_train, requires_grad=True)\n", - "#rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", - "rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", - "input_[:,1:] = W[:,1:]/torch.norm(W[:,1:], dim=1, keepdim=True)*torch.unsqueeze(rs, dim=1)\n", + "W = torch.normal(0, 1, size=(n_train, 4))\n", + "input_ = torch.empty(n_train, 4, requires_grad=False)\n", + "input_[:, 0] = torch.rand(n_train, requires_grad=True)\n", + "# rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", + "rs = 1.2 + 1.8 * torch.linspace(0, 1, n_train)\n", + "input_[:, 1:] = (\n", + " W[:, 1:] / torch.norm(W[:, 1:], dim=1, keepdim=True) * torch.unsqueeze(rs, dim=1)\n", + ")\n", "x = input_.detach().requires_grad_(True)\n", "\n", + "\n", "def closure():\n", - " \n", " global loss\n", " global x\n", " optimizer.zero_grad()\n", - " \n", + "\n", " g_GP = transform_g(transform, g, x)\n", " num = x.shape[0]\n", - " loss = torch.mean((g_GP[:,1:,1:] + torch.eye(3,3)[None,:,:].expand(num,3,3))**2)\n", + " loss = torch.mean(\n", + " (g_GP[:, 1:, 1:] + torch.eye(3, 3)[None, :, :].expand(num, 3, 3)) ** 2\n", + " )\n", "\n", " loss.backward()\n", " return loss\n", "\n", + "\n", "for _ in pbar:\n", - " \n", - " '''if _ < 50 and _ % 5 == 0:\n", - " model.update_grid(x)'''\n", - " \n", + " \"\"\"if _ < 50 and _ % 5 == 0:\n", + " model.update_grid(x)\"\"\"\n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())\n", - " \n", - " " + " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())" ] }, { @@ -176,15 +230,21 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())\n", + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())\n", "u = torch.sqrt(rs)\n", - "dt = 2*u + torch.log((u-1)/(u+1))\n", - "#plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", - "plt.plot(rs, -dt-23.85, color='orange', ls='--', lw=2)\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel(r'$\\Delta t$', fontsize=20)\n", - "#plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", - "plt.text(1.5,-23.3,r'$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C$',color='orange',fontsize=20)" + "dt = 2 * u + torch.log((u - 1) / (u + 1))\n", + "# plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", + "plt.plot(rs, -dt - 23.85, color=\"orange\", ls=\"--\", lw=2)\n", + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(r\"$\\Delta t$\", fontsize=20)\n", + "# plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", + "plt.text(\n", + " 1.5,\n", + " -23.3,\n", + " r\"$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C$\",\n", + " color=\"orange\",\n", + " fontsize=20,\n", + ")" ] }, { @@ -215,15 +275,27 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())\n", + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())\n", "u = torch.sqrt(rs)\n", - "dt = 2*u + torch.log((u-1)/(u+1))\n", - "plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", - "plt.plot(rs, -dt+6.5, color='orange', ls='--', lw=2)\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel(r'$\\Delta t$', fontsize=20)\n", - "plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", - "plt.text(1.5,7,r'$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C_2$',color='orange',fontsize=20)" + "dt = 2 * u + torch.log((u - 1) / (u + 1))\n", + "plt.plot(rs, dt + 3.65, color=\"red\", ls=\"--\", lw=2)\n", + "plt.plot(rs, -dt + 6.5, color=\"orange\", ls=\"--\", lw=2)\n", + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(r\"$\\Delta t$\", fontsize=20)\n", + "plt.text(\n", + " 1.5,\n", + " 3,\n", + " r\"$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$\",\n", + " color=\"red\",\n", + " fontsize=20,\n", + ")\n", + "plt.text(\n", + " 1.5,\n", + " 7,\n", + " r\"$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C_2$\",\n", + " color=\"orange\",\n", + " fontsize=20,\n", + ")" ] }, { @@ -254,7 +326,7 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())" + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())" ] }, { @@ -266,7 +338,9 @@ "source": [ "g_GP = transform_g(transform, g, x)\n", "num = x.shape[0]\n", - "loss = torch.mean((g_GP[:,1:,1:] + torch.eye(3,3)[None,:,:].expand(num,3,3))**2, dim=[1,2])" + "loss = torch.mean(\n", + " (g_GP[:, 1:, 1:] + torch.eye(3, 3)[None, :, :].expand(num, 3, 3)) ** 2, dim=[1, 2]\n", + ")" ] }, { @@ -320,9 +394,9 @@ ], "source": [ "plt.plot(rs.detach().numpy(), loss.detach().numpy())\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel('Minkowski Loss', fontsize=20)\n", - "plt.plot([2.282,2.282],[0,0.08], ls='--', color='black')" + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(\"Minkowski Loss\", fontsize=20)\n", + "plt.plot([2.282, 2.282], [0, 0.08], ls=\"--\", color=\"black\")" ] }, { diff --git a/docs/Physics/Physics_4A_constitutive_laws_P11.ipynb b/docs/Physics/Physics_4A_constitutive_laws_P11.ipynb index a8ada9edb..db089d05f 100644 --- a/docs/Physics/Physics_4A_constitutive_laws_P11.ipynb +++ b/docs/Physics/Physics_4A_constitutive_laws_P11.ipynb @@ -15,9 +15,11 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", @@ -33,19 +35,19 @@ "N = 1000\n", "sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -53,8 +55,7 @@ "\n", "# P12\n", "# linear: P12 = mu * (F12 + F21)\n", - "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)\n", - "\n" + "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)" ] }, { @@ -83,14 +84,22 @@ ], "source": [ "mu, lambda_ = linear.get_lame_parameters()\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "P11_l_expr = 2 * mu * (F11 - 1) + lambda_ * (F11 + F22 + F33 - 3)\n", "model = kanpiler(input_vars, P11_l_expr)\n", "\n", "F_flatten = F.reshape(N, -1)\n", "\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -120,7 +129,13 @@ "source": [ "model.perturb()\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -176,7 +191,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -186,8 +207,15 @@ "metadata": {}, "outputs": [], "source": [ - "detF = F11 * F22 * F33 + F12 * F23 * F31 + F13 * F21 * F32 - F11 * F23 * F32 - F12 * F21 * F33 - F13 * F22 * F31\n", - "D = symbols('|F|')\n", + "detF = (\n", + " F11 * F22 * F33\n", + " + F12 * F23 * F31\n", + " + F13 * F21 * F32\n", + " - F11 * F23 * F32\n", + " - F12 * F21 * F33\n", + " - F13 * F22 * F31\n", + ")\n", + "D = symbols(\"|F|\")\n", "\n", "dataset = augment_input(input_vars, [detF], dataset)" ] @@ -207,7 +235,7 @@ } ], "source": [ - "model.expand_width(0,1,perturb=True)" + "model.expand_width(0, 1, perturb=True)" ] }, { @@ -231,7 +259,13 @@ ], "source": [ "model.get_act(dataset)\n", - "model.plot(in_vars=[D] + list(input_vars), out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -263,7 +297,7 @@ } ], "source": [ - "model.fit(dataset, opt='LBFGS', steps=20);" + "model.fit(dataset, opt=\"LBFGS\", steps=20);" ] }, { @@ -285,7 +319,13 @@ ], "source": [ "model.get_act(dataset)\n", - "model.plot(in_vars=[D] + list(input_vars), out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -375,7 +415,7 @@ } ], "source": [ - "model.fit(dataset, opt='LBFGS', steps=100);" + "model.fit(dataset, opt=\"LBFGS\", steps=100);" ] }, { @@ -396,7 +436,13 @@ } ], "source": [ - "model.plot(in_vars=[D] + list(input_vars),out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -422,7 +468,7 @@ "source": [ "from kan.utils import ex_round\n", "\n", - "ex_round(ex_round(model.symbolic_formula(var= [D] + list(input_vars))[0][0],5),2)" + "ex_round(ex_round(model.symbolic_formula(var=[D] + list(input_vars))[0][0], 5), 2)" ] }, { @@ -443,7 +489,7 @@ } ], "source": [ - "0.28*np.log(2.5) - 0.67" + "0.28 * np.log(2.5) - 0.67" ] }, { diff --git a/docs/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb b/docs/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb index 1358cd1c9..91df35782 100644 --- a/docs/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb +++ b/docs/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb @@ -15,9 +15,11 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", @@ -31,21 +33,21 @@ "torch.set_default_dtype(torch.float64)\n", "\n", "N = 1000\n", - "sigma = 0.2 # previously sigma = 0.2\n", + "sigma = 0.2 # previously sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -82,17 +84,25 @@ ], "source": [ "mu, lambda_ = linear.get_lame_parameters()\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "\n", "# compile more terms in ground truth\n", "# or make the network bigger\n", "P12_l_expr = mu * (F12 + F21)\n", - "model = kanpiler(input_vars, P12_l_expr, base_fun='identity')\n", + "model = kanpiler(input_vars, P12_l_expr, base_fun=\"identity\")\n", "\n", "F_flatten = F.reshape(N, -1)\n", "\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -121,7 +131,13 @@ ], "source": [ "model.expand_depth()\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -150,9 +166,15 @@ } ], "source": [ - "model.expand_width(1,5,sum_bool=False,mult_arity=2)\n", - "model.expand_width(1,4)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.expand_width(1, 5, sum_bool=False, mult_arity=2)\n", + "model.expand_width(1, 4)\n", + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -170,7 +192,7 @@ } ], "source": [ - "model.perturb(mode='all')" + "model.perturb(mode=\"all\")" ] }, { @@ -191,7 +213,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -213,7 +241,7 @@ ], "source": [ "dataset = create_dataset_from_data(F_flatten, P12_n)\n", - "torch.sqrt(torch.mean((model(dataset['train_input']) - dataset['train_label'])**2))" + "torch.sqrt(torch.mean((model(dataset[\"train_input\"]) - dataset[\"train_label\"]) ** 2))" ] }, { @@ -245,9 +273,7 @@ } ], "source": [ - "from kan.utils import create_dataset_from_data\n", - "\n", - "#dataset = create_dataset_from_data(F_flatten, P12_n)\n", + "# dataset = create_dataset_from_data(F_flatten, P12_n)\n", "model.fit(dataset, steps=100, lamb=1e-5);" ] }, @@ -269,7 +295,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -298,7 +330,13 @@ ], "source": [ "model = model.prune()\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -316,7 +354,7 @@ } ], "source": [ - "model = model.rewind('0.7')" + "model = model.rewind(\"0.7\")" ] }, { @@ -369,7 +407,7 @@ } ], "source": [ - "model.plot()\n" + "model.plot()" ] }, { @@ -504,7 +542,8 @@ ], "source": [ "from kan.utils import ex_round\n", - "ex_round(expand(ex_round(model.symbolic_formula(var=input_vars)[0][0],4)),2)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula(var=input_vars)[0][0], 4)), 2)" ] }, { diff --git a/docs/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb b/docs/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb index d3d5b7423..013016c25 100644 --- a/docs/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb +++ b/docs/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb @@ -15,14 +15,15 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", "from kan import *\n", - "from kan.compiler import kanpiler\n", "\n", "random.seed(0)\n", "np.random.seed(0)\n", @@ -31,22 +32,22 @@ "torch.set_default_dtype(torch.float64)\n", "\n", "N = 1000\n", - "sigma = 0.5 # previously sigma = 0.2\n", + "sigma = 0.5 # previously sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "F_flatten = F.reshape(N, -1)\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -55,7 +56,9 @@ "# P12\n", "# linear: P12 = mu * (F12 + F21)\n", "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "dataset = create_dataset_from_data(F_flatten, P12_n)" ] }, @@ -97,7 +100,7 @@ ], "source": [ "# train from scratch without prior knowledge\n", - "model2 = KAN(width=[9,[5,5],1], base_fun='identity', sparse_init=True, seed=2)\n", + "model2 = KAN(width=[9, [5, 5], 1], base_fun=\"identity\", sparse_init=True, seed=2)\n", "model2.fit(dataset, steps=100, lamb=1e-5, lamb_coef=1.0);" ] }, @@ -127,9 +130,15 @@ } ], "source": [ - "model = KAN(width=[9,[5,5],1], base_fun='identity', sparse_init=True, seed=2)\n", + "model = KAN(width=[9, [5, 5], 1], base_fun=\"identity\", sparse_init=True, seed=2)\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -152,7 +161,13 @@ } ], "source": [ - "model2.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model2.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -191,7 +206,13 @@ } ], "source": [ - "model2.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model2.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -333,10 +354,10 @@ } ], "source": [ - "model2.unfix_symbolic(1,1,0)\n", - "model2.fix_symbolic(1,1,0,'x')\n", - "model2.unfix_symbolic(1,2,0)\n", - "model2.fix_symbolic(1,2,0,'x')" + "model2.unfix_symbolic(1, 1, 0)\n", + "model2.fix_symbolic(1, 1, 0, \"x\")\n", + "model2.unfix_symbolic(1, 2, 0)\n", + "model2.fix_symbolic(1, 2, 0, \"x\")" ] }, { @@ -393,7 +414,10 @@ ], "source": [ "from kan.utils import ex_round\n", - "ex_round(expand(ex_round(ex_round(model2.symbolic_formula(var=input_vars)[0][0], 8), 5)), 2)" + "\n", + "ex_round(\n", + " expand(ex_round(ex_round(model2.symbolic_formula(var=input_vars)[0][0], 8), 5)), 2\n", + ")" ] }, { diff --git a/docs/conf.py b/docs/conf.py index 464f04ccd..93143a954 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,5 +1,3 @@ -import sphinx_rtd_theme - # Configuration file for the Sphinx documentation builder. # # For the full list of built-in configuration values, see the documentation: @@ -8,57 +6,58 @@ # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -project = 'Kolmogorov Arnold Network' -copyright = '2024, Ziming Liu' -author = 'Ziming Liu' +project = "Kolmogorov Arnold Network" +copyright = "2024, Ziming Liu" +author = "Ziming Liu" # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration -extensions = ["sphinx_rtd_theme", - "sphinx.ext.autodoc", - "sphinx.ext.autosectionlabel" - ] - -templates_path = ['_templates'] -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +extensions = ["sphinx_rtd_theme", "sphinx.ext.autodoc", "sphinx.ext.autosectionlabel"] +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output -#html_theme = 'alabaster' +# html_theme = 'alabaster' html_theme = "sphinx_rtd_theme" -html_static_path = ['_static'] +html_static_path = ["_static"] + def skip(app, what, name, obj, would_skip, options): if name == "__init__": return False return would_skip + def setup(app): app.connect("autodoc-skip-member", skip) - -autodoc_mock_imports = ["numpy", - "torch", - "torch.nn", - "matplotlib", - "matplotlib.pyplot", - "tqdm", - "sympy", - "scipy", - "sklearn", - "torch.optim", - "re", - "yaml", - "pandas"] - + + +autodoc_mock_imports = [ + "numpy", + "torch", + "torch.nn", + "matplotlib", + "matplotlib.pyplot", + "tqdm", + "sympy", + "scipy", + "sklearn", + "torch.optim", + "re", + "yaml", + "pandas", +] + source_suffix = [".rst", ".md"] -#source_suffix = [".rst", ".md", ".ipynb"] -#source_suffix = { +# source_suffix = [".rst", ".md", ".ipynb"] +# source_suffix = { # '.rst': 'restructuredtext', # '.ipynb': 'myst-nb', # '.myst': 'myst-nb', -#} +# } diff --git a/docs/intro.ipynb b/docs/intro.ipynb index c9a10ddc8..8fbe1e308 100644 --- a/docs/intro.ipynb +++ b/docs/intro.ipynb @@ -117,8 +117,9 @@ "outputs": [], "source": [ "from kan import *\n", + "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0)" + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0)" ] }, { @@ -148,9 +149,9 @@ ], "source": [ "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -180,7 +181,7 @@ ], "source": [ "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=100)" ] }, @@ -208,7 +209,7 @@ ], "source": [ "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.);" + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0);" ] }, { @@ -297,7 +298,7 @@ ], "source": [ "model = model.prune()\n", - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -373,16 +374,16 @@ } ], "source": [ - "mode = \"auto\" # \"manual\"\n", + "mode = \"auto\" # \"manual\"\n", "\n", "if mode == \"manual\":\n", " # manual mode\n", - " model.fix_symbolic(0,0,0,'sin');\n", - " model.fix_symbolic(0,1,0,'x^2');\n", - " model.fix_symbolic(1,0,0,'exp');\n", + " model.fix_symbolic(0, 0, 0, \"sin\")\n", + " model.fix_symbolic(0, 1, 0, \"x^2\")\n", + " model.fix_symbolic(1, 0, 0, \"exp\")\n", "elif mode == \"auto\":\n", " # automatic mode\n", - " lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", + " lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"abs\"]\n", " model.auto_symbolic(lib=lib)" ] }, diff --git a/hellokan.ipynb b/hellokan.ipynb index da1222058..b9f6babfe 100644 --- a/hellokan.ipynb +++ b/hellokan.ipynb @@ -127,13 +127,14 @@ ], "source": [ "from kan import *\n", + "\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device)" + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=42, device=device)" ] }, { @@ -163,10 +164,11 @@ ], "source": [ "from kan.utils import create_dataset\n", + "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -196,7 +198,7 @@ ], "source": [ "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -423,16 +425,16 @@ } ], "source": [ - "mode = \"auto\" # \"manual\"\n", + "mode = \"auto\" # \"manual\"\n", "\n", "if mode == \"manual\":\n", " # manual mode\n", - " model.fix_symbolic(0,0,0,'sin');\n", - " model.fix_symbolic(0,1,0,'x^2');\n", - " model.fix_symbolic(1,0,0,'exp');\n", + " model.fix_symbolic(0, 0, 0, \"sin\")\n", + " model.fix_symbolic(0, 1, 0, \"x^2\")\n", + " model.fix_symbolic(1, 0, 0, \"exp\")\n", "elif mode == \"auto\":\n", " # automatic mode\n", - " lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", + " lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"abs\"]\n", " model.auto_symbolic(lib=lib)" ] }, @@ -500,7 +502,7 @@ "source": [ "from kan.utils import ex_round\n", "\n", - "ex_round(model.symbolic_formula()[0][0],4)" + "ex_round(model.symbolic_formula()[0][0], 4)" ] }, { diff --git a/kan/.ipynb_checkpoints/KANLayer-checkpoint.py b/kan/.ipynb_checkpoints/KANLayer-checkpoint.py deleted file mode 100644 index b880bfe8b..000000000 --- a/kan/.ipynb_checkpoints/KANLayer-checkpoint.py +++ /dev/null @@ -1,364 +0,0 @@ -import torch -import torch.nn as nn -import numpy as np -from .spline import * -from .utils import sparse_mask - - -class KANLayer(nn.Module): - """ - KANLayer class - - - Attributes: - ----------- - in_dim: int - input dimension - out_dim: int - output dimension - num: int - the number of grid intervals - k: int - the piecewise polynomial order of splines - noise_scale: float - spline scale at initialization - coef: 2D torch.tensor - coefficients of B-spline bases - scale_base_mu: float - magnitude of the residual function b(x) is drawn from N(mu, sigma^2), mu = sigma_base_mu - scale_base_sigma: float - magnitude of the residual function b(x) is drawn from N(mu, sigma^2), mu = sigma_base_sigma - scale_sp: float - mangitude of the spline function spline(x) - base_fun: fun - residual function b(x) - mask: 1D torch.float - mask of spline functions. setting some element of the mask to zero means setting the corresponding activation to zero function. - grid_eps: float in [0,1] - a hyperparameter used in update_grid_from_samples. When grid_eps = 1, the grid is uniform; when grid_eps = 0, the grid is partitioned using percentiles of samples. 0 < grid_eps < 1 interpolates between the two extremes. - the id of activation functions that are locked - device: str - device - """ - - def __init__(self, in_dim=3, out_dim=2, num=5, k=3, noise_scale=0.5, scale_base_mu=0.0, scale_base_sigma=1.0, scale_sp=1.0, base_fun=torch.nn.SiLU(), grid_eps=0.02, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, save_plot_data = True, device='cpu', sparse_init=False): - '''' - initialize a KANLayer - - Args: - ----- - in_dim : int - input dimension. Default: 2. - out_dim : int - output dimension. Default: 3. - num : int - the number of grid intervals = G. Default: 5. - k : int - the order of piecewise polynomial. Default: 3. - noise_scale : float - the scale of noise injected at initialization. Default: 0.1. - scale_base_mu : float - the scale of the residual function b(x) is intialized to be N(scale_base_mu, scale_base_sigma^2). - scale_base_sigma : float - the scale of the residual function b(x) is intialized to be N(scale_base_mu, scale_base_sigma^2). - scale_sp : float - the scale of the base function spline(x). - base_fun : function - residual function b(x). Default: torch.nn.SiLU() - grid_eps : float - When grid_eps = 1, the grid is uniform; when grid_eps = 0, the grid is partitioned using percentiles of samples. 0 < grid_eps < 1 interpolates between the two extremes. - grid_range : list/np.array of shape (2,) - setting the range of grids. Default: [-1,1]. - sp_trainable : bool - If true, scale_sp is trainable - sb_trainable : bool - If true, scale_base is trainable - device : str - device - sparse_init : bool - if sparse_init = True, sparse initialization is applied. - - Returns: - -------- - self - - Example - ------- - >>> from kan.KANLayer import * - >>> model = KANLayer(in_dim=3, out_dim=5) - >>> (model.in_dim, model.out_dim) - ''' - super(KANLayer, self).__init__() - # size - self.out_dim = out_dim - self.in_dim = in_dim - self.num = num - self.k = k - - grid = torch.linspace(grid_range[0], grid_range[1], steps=num + 1)[None,:].expand(self.in_dim, num+1) - grid = extend_grid(grid, k_extend=k) - self.grid = torch.nn.Parameter(grid).requires_grad_(False) - noises = (torch.rand(self.num+1, self.in_dim, self.out_dim) - 1/2) * noise_scale / num - - self.coef = torch.nn.Parameter(curve2coef(self.grid[:,k:-k].permute(1,0), noises, self.grid, k)) - - if sparse_init: - self.mask = torch.nn.Parameter(sparse_mask(in_dim, out_dim)).requires_grad_(False) - else: - self.mask = torch.nn.Parameter(torch.ones(in_dim, out_dim)).requires_grad_(False) - - self.scale_base = torch.nn.Parameter(scale_base_mu * 1 / np.sqrt(in_dim) + \ - scale_base_sigma * (torch.rand(in_dim, out_dim)*2-1) * 1/np.sqrt(in_dim)).requires_grad_(sb_trainable) - self.scale_sp = torch.nn.Parameter(torch.ones(in_dim, out_dim) * scale_sp * 1 / np.sqrt(in_dim) * self.mask).requires_grad_(sp_trainable) # make scale trainable - self.base_fun = base_fun - - - self.grid_eps = grid_eps - - self.to(device) - - def to(self, device): - super(KANLayer, self).to(device) - self.device = device - return self - - def forward(self, x): - ''' - KANLayer forward given input x - - Args: - ----- - x : 2D torch.float - inputs, shape (number of samples, input dimension) - - Returns: - -------- - y : 2D torch.float - outputs, shape (number of samples, output dimension) - preacts : 3D torch.float - fan out x into activations, shape (number of sampels, output dimension, input dimension) - postacts : 3D torch.float - the outputs of activation functions with preacts as inputs - postspline : 3D torch.float - the outputs of spline functions with preacts as inputs - - Example - ------- - >>> from kan.KANLayer import * - >>> model = KANLayer(in_dim=3, out_dim=5) - >>> x = torch.normal(0,1,size=(100,3)) - >>> y, preacts, postacts, postspline = model(x) - >>> y.shape, preacts.shape, postacts.shape, postspline.shape - ''' - batch = x.shape[0] - preacts = x[:,None,:].clone().expand(batch, self.out_dim, self.in_dim) - - base = self.base_fun(x) # (batch, in_dim) - y = coef2curve(x_eval=x, grid=self.grid, coef=self.coef, k=self.k) - - postspline = y.clone().permute(0,2,1) - - y = self.scale_base[None,:,:] * base[:,:,None] + self.scale_sp[None,:,:] * y - y = self.mask[None,:,:] * y - - postacts = y.clone().permute(0,2,1) - - y = torch.sum(y, dim=1) - return y, preacts, postacts, postspline - - def update_grid_from_samples(self, x, mode='sample'): - ''' - update grid from samples - - Args: - ----- - x : 2D torch.float - inputs, shape (number of samples, input dimension) - - Returns: - -------- - None - - Example - ------- - >>> model = KANLayer(in_dim=1, out_dim=1, num=5, k=3) - >>> print(model.grid.data) - >>> x = torch.linspace(-3,3,steps=100)[:,None] - >>> model.update_grid_from_samples(x) - >>> print(model.grid.data) - ''' - - batch = x.shape[0] - #x = torch.einsum('ij,k->ikj', x, torch.ones(self.out_dim, ).to(self.device)).reshape(batch, self.size).permute(1, 0) - x_pos = torch.sort(x, dim=0)[0] - y_eval = coef2curve(x_pos, self.grid, self.coef, self.k) - num_interval = self.grid.shape[1] - 1 - 2*self.k - - def get_grid(num_interval): - ids = [int(batch / num_interval * i) for i in range(num_interval)] + [-1] - grid_adaptive = x_pos[ids, :].permute(1,0) - margin = 0.00 - h = (grid_adaptive[:,[-1]] - grid_adaptive[:,[0]] + 2 * margin)/num_interval - grid_uniform = grid_adaptive[:,[0]] - margin + h * torch.arange(num_interval+1,)[None, :].to(x.device) - grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive - return grid - - - grid = get_grid(num_interval) - - if mode == 'grid': - sample_grid = get_grid(2*num_interval) - x_pos = sample_grid.permute(1,0) - y_eval = coef2curve(x_pos, self.grid, self.coef, self.k) - - self.grid.data = extend_grid(grid, k_extend=self.k) - #print('x_pos 2', x_pos.shape) - #print('y_eval 2', y_eval.shape) - self.coef.data = curve2coef(x_pos, y_eval, self.grid, self.k) - - def initialize_grid_from_parent(self, parent, x, mode='sample'): - ''' - update grid from a parent KANLayer & samples - - Args: - ----- - parent : KANLayer - a parent KANLayer (whose grid is usually coarser than the current model) - x : 2D torch.float - inputs, shape (number of samples, input dimension) - - Returns: - -------- - None - - Example - ------- - >>> batch = 100 - >>> parent_model = KANLayer(in_dim=1, out_dim=1, num=5, k=3) - >>> print(parent_model.grid.data) - >>> model = KANLayer(in_dim=1, out_dim=1, num=10, k=3) - >>> x = torch.normal(0,1,size=(batch, 1)) - >>> model.initialize_grid_from_parent(parent_model, x) - >>> print(model.grid.data) - ''' - - batch = x.shape[0] - - # shrink grid - x_pos = torch.sort(x, dim=0)[0] - y_eval = coef2curve(x_pos, parent.grid, parent.coef, parent.k) - num_interval = self.grid.shape[1] - 1 - 2*self.k - - - ''' - # based on samples - def get_grid(num_interval): - ids = [int(batch / num_interval * i) for i in range(num_interval)] + [-1] - grid_adaptive = x_pos[ids, :].permute(1,0) - h = (grid_adaptive[:,[-1]] - grid_adaptive[:,[0]])/num_interval - grid_uniform = grid_adaptive[:,[0]] + h * torch.arange(num_interval+1,)[None, :].to(x.device) - grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive - return grid''' - - #print('p', parent.grid) - # based on interpolating parent grid - def get_grid(num_interval): - x_pos = parent.grid[:,parent.k:-parent.k] - #print('x_pos', x_pos) - sp2 = KANLayer(in_dim=1, out_dim=self.in_dim,k=1,num=x_pos.shape[1]-1,scale_base_mu=0.0, scale_base_sigma=0.0).to(x.device) - - #print('sp2_grid', sp2.grid[:,sp2.k:-sp2.k].permute(1,0).expand(-1,self.in_dim)) - #print('sp2_coef_shape', sp2.coef.shape) - sp2_coef = curve2coef(sp2.grid[:,sp2.k:-sp2.k].permute(1,0).expand(-1,self.in_dim), x_pos.permute(1,0).unsqueeze(dim=2), sp2.grid[:,:], k=1).permute(1,0,2) - shp = sp2_coef.shape - #sp2_coef = torch.cat([torch.zeros(shp[0], shp[1], 1), sp2_coef, torch.zeros(shp[0], shp[1], 1)], dim=2) - #print('sp2_coef',sp2_coef) - #print(sp2.coef.shape) - sp2.coef.data = sp2_coef - percentile = torch.linspace(-1,1,self.num+1).to(self.device) - grid = sp2(percentile.unsqueeze(dim=1))[0].permute(1,0) - #print('c', grid) - return grid - - grid = get_grid(num_interval) - - if mode == 'grid': - sample_grid = get_grid(2*num_interval) - x_pos = sample_grid.permute(1,0) - y_eval = coef2curve(x_pos, parent.grid, parent.coef, parent.k) - - grid = extend_grid(grid, k_extend=self.k) - self.grid.data = grid - self.coef.data = curve2coef(x_pos, y_eval, self.grid, self.k) - - def get_subset(self, in_id, out_id): - ''' - get a smaller KANLayer from a larger KANLayer (used for pruning) - - Args: - ----- - in_id : list - id of selected input neurons - out_id : list - id of selected output neurons - - Returns: - -------- - spb : KANLayer - - Example - ------- - >>> kanlayer_large = KANLayer(in_dim=10, out_dim=10, num=5, k=3) - >>> kanlayer_small = kanlayer_large.get_subset([0,9],[1,2,3]) - >>> kanlayer_small.in_dim, kanlayer_small.out_dim - (2, 3) - ''' - spb = KANLayer(len(in_id), len(out_id), self.num, self.k, base_fun=self.base_fun) - spb.grid.data = self.grid[in_id] - spb.coef.data = self.coef[in_id][:,out_id] - spb.scale_base.data = self.scale_base[in_id][:,out_id] - spb.scale_sp.data = self.scale_sp[in_id][:,out_id] - spb.mask.data = self.mask[in_id][:,out_id] - - spb.in_dim = len(in_id) - spb.out_dim = len(out_id) - return spb - - - def swap(self, i1, i2, mode='in'): - ''' - swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') - - Args: - ----- - i1 : int - i2 : int - mode : str - mode = 'in' or 'out' - - Returns: - -------- - None - - Example - ------- - >>> from kan.KANLayer import * - >>> model = KANLayer(in_dim=2, out_dim=2, num=5, k=3) - >>> print(model.coef) - >>> model.swap(0,1,mode='in') - >>> print(model.coef) - ''' - with torch.no_grad(): - def swap_(data, i1, i2, mode='in'): - if mode == 'in': - data[i1], data[i2] = data[i2].clone(), data[i1].clone() - elif mode == 'out': - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() - - if mode == 'in': - swap_(self.grid.data, i1, i2, mode='in') - swap_(self.coef.data, i1, i2, mode=mode) - swap_(self.scale_base.data, i1, i2, mode=mode) - swap_(self.scale_sp.data, i1, i2, mode=mode) - swap_(self.mask.data, i1, i2, mode=mode) - diff --git a/kan/.ipynb_checkpoints/LBFGS-checkpoint.py b/kan/.ipynb_checkpoints/LBFGS-checkpoint.py deleted file mode 100644 index 212477f23..000000000 --- a/kan/.ipynb_checkpoints/LBFGS-checkpoint.py +++ /dev/null @@ -1,493 +0,0 @@ -import torch -from functools import reduce -from torch.optim import Optimizer - -__all__ = ['LBFGS'] - -def _cubic_interpolate(x1, f1, g1, x2, f2, g2, bounds=None): - # ported from https://github.com/torch/optim/blob/master/polyinterp.lua - # Compute bounds of interpolation area - if bounds is not None: - xmin_bound, xmax_bound = bounds - else: - xmin_bound, xmax_bound = (x1, x2) if x1 <= x2 else (x2, x1) - - # Code for most common case: cubic interpolation of 2 points - # w/ function and derivative values for both - # Solution in this case (where x2 is the farthest point): - # d1 = g1 + g2 - 3*(f1-f2)/(x1-x2); - # d2 = sqrt(d1^2 - g1*g2); - # min_pos = x2 - (x2 - x1)*((g2 + d2 - d1)/(g2 - g1 + 2*d2)); - # t_new = min(max(min_pos,xmin_bound),xmax_bound); - d1 = g1 + g2 - 3 * (f1 - f2) / (x1 - x2) - d2_square = d1**2 - g1 * g2 - if d2_square >= 0: - d2 = d2_square.sqrt() - if x1 <= x2: - min_pos = x2 - (x2 - x1) * ((g2 + d2 - d1) / (g2 - g1 + 2 * d2)) - else: - min_pos = x1 - (x1 - x2) * ((g1 + d2 - d1) / (g1 - g2 + 2 * d2)) - return min(max(min_pos, xmin_bound), xmax_bound) - else: - return (xmin_bound + xmax_bound) / 2. - - -def _strong_wolfe(obj_func, - x, - t, - d, - f, - g, - gtd, - c1=1e-4, - c2=0.9, - tolerance_change=1e-9, - max_ls=25): - # ported from https://github.com/torch/optim/blob/master/lswolfe.lua - d_norm = d.abs().max() - g = g.clone(memory_format=torch.contiguous_format) - # evaluate objective and gradient using initial step - f_new, g_new = obj_func(x, t, d) - ls_func_evals = 1 - gtd_new = g_new.dot(d) - - # bracket an interval containing a point satisfying the Wolfe criteria - t_prev, f_prev, g_prev, gtd_prev = 0, f, g, gtd - done = False - ls_iter = 0 - while ls_iter < max_ls: - # check conditions - #print(f_prev, f_new, g_new) - if f_new > (f + c1 * t * gtd) or (ls_iter > 1 and f_new >= f_prev): - bracket = [t_prev, t] - bracket_f = [f_prev, f_new] - bracket_g = [g_prev, g_new.clone(memory_format=torch.contiguous_format)] - bracket_gtd = [gtd_prev, gtd_new] - break - - if abs(gtd_new) <= -c2 * gtd: - bracket = [t] - bracket_f = [f_new] - bracket_g = [g_new] - done = True - break - - if gtd_new >= 0: - bracket = [t_prev, t] - bracket_f = [f_prev, f_new] - bracket_g = [g_prev, g_new.clone(memory_format=torch.contiguous_format)] - bracket_gtd = [gtd_prev, gtd_new] - break - - # interpolate - min_step = t + 0.01 * (t - t_prev) - max_step = t * 10 - tmp = t - t = _cubic_interpolate( - t_prev, - f_prev, - gtd_prev, - t, - f_new, - gtd_new, - bounds=(min_step, max_step)) - - # next step - t_prev = tmp - f_prev = f_new - g_prev = g_new.clone(memory_format=torch.contiguous_format) - gtd_prev = gtd_new - f_new, g_new = obj_func(x, t, d) - ls_func_evals += 1 - gtd_new = g_new.dot(d) - ls_iter += 1 - - - # reached max number of iterations? - if ls_iter == max_ls: - bracket = [0, t] - bracket_f = [f, f_new] - bracket_g = [g, g_new] - - # zoom phase: we now have a point satisfying the criteria, or - # a bracket around it. We refine the bracket until we find the - # exact point satisfying the criteria - insuf_progress = False - # find high and low points in bracket - low_pos, high_pos = (0, 1) if bracket_f[0] <= bracket_f[-1] else (1, 0) - while not done and ls_iter < max_ls: - # line-search bracket is so small - if abs(bracket[1] - bracket[0]) * d_norm < tolerance_change: - break - - # compute new trial value - t = _cubic_interpolate(bracket[0], bracket_f[0], bracket_gtd[0], - bracket[1], bracket_f[1], bracket_gtd[1]) - - # test that we are making sufficient progress: - # in case `t` is so close to boundary, we mark that we are making - # insufficient progress, and if - # + we have made insufficient progress in the last step, or - # + `t` is at one of the boundary, - # we will move `t` to a position which is `0.1 * len(bracket)` - # away from the nearest boundary point. - eps = 0.1 * (max(bracket) - min(bracket)) - if min(max(bracket) - t, t - min(bracket)) < eps: - # interpolation close to boundary - if insuf_progress or t >= max(bracket) or t <= min(bracket): - # evaluate at 0.1 away from boundary - if abs(t - max(bracket)) < abs(t - min(bracket)): - t = max(bracket) - eps - else: - t = min(bracket) + eps - insuf_progress = False - else: - insuf_progress = True - else: - insuf_progress = False - - # Evaluate new point - f_new, g_new = obj_func(x, t, d) - ls_func_evals += 1 - gtd_new = g_new.dot(d) - ls_iter += 1 - - if f_new > (f + c1 * t * gtd) or f_new >= bracket_f[low_pos]: - # Armijo condition not satisfied or not lower than lowest point - bracket[high_pos] = t - bracket_f[high_pos] = f_new - bracket_g[high_pos] = g_new.clone(memory_format=torch.contiguous_format) - bracket_gtd[high_pos] = gtd_new - low_pos, high_pos = (0, 1) if bracket_f[0] <= bracket_f[1] else (1, 0) - else: - if abs(gtd_new) <= -c2 * gtd: - # Wolfe conditions satisfied - done = True - elif gtd_new * (bracket[high_pos] - bracket[low_pos]) >= 0: - # old low becomes new high - bracket[high_pos] = bracket[low_pos] - bracket_f[high_pos] = bracket_f[low_pos] - bracket_g[high_pos] = bracket_g[low_pos] - bracket_gtd[high_pos] = bracket_gtd[low_pos] - - # new point becomes new low - bracket[low_pos] = t - bracket_f[low_pos] = f_new - bracket_g[low_pos] = g_new.clone(memory_format=torch.contiguous_format) - bracket_gtd[low_pos] = gtd_new - - #print(bracket) - if len(bracket) == 1: - t = bracket[0] - f_new = bracket_f[0] - g_new = bracket_g[0] - else: - t = bracket[low_pos] - f_new = bracket_f[low_pos] - g_new = bracket_g[low_pos] - return f_new, g_new, t, ls_func_evals - - - -class LBFGS(Optimizer): - """Implements L-BFGS algorithm. - - Heavily inspired by `minFunc - `_. - - .. warning:: - This optimizer doesn't support per-parameter options and parameter - groups (there can be only one). - - .. warning:: - Right now all parameters have to be on a single device. This will be - improved in the future. - - .. note:: - This is a very memory intensive optimizer (it requires additional - ``param_bytes * (history_size + 1)`` bytes). If it doesn't fit in memory - try reducing the history size, or use a different algorithm. - - Args: - lr (float): learning rate (default: 1) - max_iter (int): maximal number of iterations per optimization step - (default: 20) - max_eval (int): maximal number of function evaluations per optimization - step (default: max_iter * 1.25). - tolerance_grad (float): termination tolerance on first order optimality - (default: 1e-7). - tolerance_change (float): termination tolerance on function - value/parameter changes (default: 1e-9). - history_size (int): update history size (default: 100). - line_search_fn (str): either 'strong_wolfe' or None (default: None). - """ - - def __init__(self, - params, - lr=1, - max_iter=20, - max_eval=None, - tolerance_grad=1e-7, - tolerance_change=1e-9, - tolerance_ys=1e-32, - history_size=100, - line_search_fn=None): - if max_eval is None: - max_eval = max_iter * 5 // 4 - defaults = dict( - lr=lr, - max_iter=max_iter, - max_eval=max_eval, - tolerance_grad=tolerance_grad, - tolerance_change=tolerance_change, - tolerance_ys=tolerance_ys, - history_size=history_size, - line_search_fn=line_search_fn) - super().__init__(params, defaults) - - if len(self.param_groups) != 1: - raise ValueError("LBFGS doesn't support per-parameter options " - "(parameter groups)") - - self._params = self.param_groups[0]['params'] - self._numel_cache = None - - def _numel(self): - if self._numel_cache is None: - self._numel_cache = reduce(lambda total, p: total + p.numel(), self._params, 0) - return self._numel_cache - - def _gather_flat_grad(self): - views = [] - for p in self._params: - if p.grad is None: - view = p.new(p.numel()).zero_() - elif p.grad.is_sparse: - view = p.grad.to_dense().view(-1) - else: - view = p.grad.view(-1) - views.append(view) - device = views[0].device - return torch.cat(views, dim=0) - - def _add_grad(self, step_size, update): - offset = 0 - for p in self._params: - numel = p.numel() - # view as to avoid deprecated pointwise semantics - p.add_(update[offset:offset + numel].view_as(p), alpha=step_size) - offset += numel - assert offset == self._numel() - - def _clone_param(self): - return [p.clone(memory_format=torch.contiguous_format) for p in self._params] - - def _set_param(self, params_data): - for p, pdata in zip(self._params, params_data): - p.copy_(pdata) - - def _directional_evaluate(self, closure, x, t, d): - self._add_grad(t, d) - loss = float(closure()) - flat_grad = self._gather_flat_grad() - self._set_param(x) - return loss, flat_grad - - - @torch.no_grad() - def step(self, closure): - """Perform a single optimization step. - - Args: - closure (Callable): A closure that reevaluates the model - and returns the loss. - """ - - torch.manual_seed(0) - - assert len(self.param_groups) == 1 - - # Make sure the closure is always called with grad enabled - closure = torch.enable_grad()(closure) - - group = self.param_groups[0] - lr = group['lr'] - max_iter = group['max_iter'] - max_eval = group['max_eval'] - tolerance_grad = group['tolerance_grad'] - tolerance_change = group['tolerance_change'] - tolerance_ys = group['tolerance_ys'] - line_search_fn = group['line_search_fn'] - history_size = group['history_size'] - - # NOTE: LBFGS has only global state, but we register it as state for - # the first param, because this helps with casting in load_state_dict - state = self.state[self._params[0]] - state.setdefault('func_evals', 0) - state.setdefault('n_iter', 0) - - # evaluate initial f(x) and df/dx - orig_loss = closure() - loss = float(orig_loss) - current_evals = 1 - state['func_evals'] += 1 - - flat_grad = self._gather_flat_grad() - opt_cond = flat_grad.abs().max() <= tolerance_grad - - # optimal condition - if opt_cond: - return orig_loss - - # tensors cached in state (for tracing) - d = state.get('d') - t = state.get('t') - old_dirs = state.get('old_dirs') - old_stps = state.get('old_stps') - ro = state.get('ro') - H_diag = state.get('H_diag') - prev_flat_grad = state.get('prev_flat_grad') - prev_loss = state.get('prev_loss') - - n_iter = 0 - # optimize for a max of max_iter iterations - while n_iter < max_iter: - # keep track of nb of iterations - n_iter += 1 - state['n_iter'] += 1 - - ############################################################ - # compute gradient descent direction - ############################################################ - if state['n_iter'] == 1: - d = flat_grad.neg() - old_dirs = [] - old_stps = [] - ro = [] - H_diag = 1 - else: - # do lbfgs update (update memory) - y = flat_grad.sub(prev_flat_grad) - s = d.mul(t) - ys = y.dot(s) # y*s - if ys > tolerance_ys: - # updating memory - if len(old_dirs) == history_size: - # shift history by one (limited-memory) - old_dirs.pop(0) - old_stps.pop(0) - ro.pop(0) - - # store new direction/step - old_dirs.append(y) - old_stps.append(s) - ro.append(1. / ys) - - # update scale of initial Hessian approximation - H_diag = ys / y.dot(y) # (y*y) - - # compute the approximate (L-BFGS) inverse Hessian - # multiplied by the gradient - num_old = len(old_dirs) - - if 'al' not in state: - state['al'] = [None] * history_size - al = state['al'] - - # iteration in L-BFGS loop collapsed to use just one buffer - q = flat_grad.neg() - for i in range(num_old - 1, -1, -1): - al[i] = old_stps[i].dot(q) * ro[i] - q.add_(old_dirs[i], alpha=-al[i]) - - # multiply by initial Hessian - # r/d is the final direction - d = r = torch.mul(q, H_diag) - for i in range(num_old): - be_i = old_dirs[i].dot(r) * ro[i] - r.add_(old_stps[i], alpha=al[i] - be_i) - - if prev_flat_grad is None: - prev_flat_grad = flat_grad.clone(memory_format=torch.contiguous_format) - else: - prev_flat_grad.copy_(flat_grad) - prev_loss = loss - - ############################################################ - # compute step length - ############################################################ - # reset initial guess for step size - if state['n_iter'] == 1: - t = min(1., 1. / flat_grad.abs().sum()) * lr - else: - t = lr - - # directional derivative - gtd = flat_grad.dot(d) # g * d - - # directional derivative is below tolerance - if gtd > -tolerance_change: - break - - # optional line search: user function - ls_func_evals = 0 - if line_search_fn is not None: - # perform line search, using user function - if line_search_fn != "strong_wolfe": - raise RuntimeError("only 'strong_wolfe' is supported") - else: - x_init = self._clone_param() - - def obj_func(x, t, d): - return self._directional_evaluate(closure, x, t, d) - loss, flat_grad, t, ls_func_evals = _strong_wolfe( - obj_func, x_init, t, d, loss, flat_grad, gtd) - self._add_grad(t, d) - opt_cond = flat_grad.abs().max() <= tolerance_grad - else: - # no line search, simply move with fixed-step - self._add_grad(t, d) - if n_iter != max_iter: - # re-evaluate function only if not in last iteration - # the reason we do this: in a stochastic setting, - # no use to re-evaluate that function here - with torch.enable_grad(): - loss = float(closure()) - flat_grad = self._gather_flat_grad() - opt_cond = flat_grad.abs().max() <= tolerance_grad - ls_func_evals = 1 - - # update func eval - current_evals += ls_func_evals - state['func_evals'] += ls_func_evals - - ############################################################ - # check conditions - ############################################################ - if n_iter == max_iter: - break - - if current_evals >= max_eval: - break - - # optimal condition - if opt_cond: - break - - # lack of progress - if d.mul(t).abs().max() <= tolerance_change: - break - - if abs(loss - prev_loss) < tolerance_change: - break - - state['d'] = d - state['t'] = t - state['old_dirs'] = old_dirs - state['old_stps'] = old_stps - state['ro'] = ro - state['H_diag'] = H_diag - state['prev_flat_grad'] = prev_flat_grad - state['prev_loss'] = prev_loss - - return orig_loss diff --git a/kan/.ipynb_checkpoints/MLP-checkpoint.py b/kan/.ipynb_checkpoints/MLP-checkpoint.py deleted file mode 100644 index 1066c3b3d..000000000 --- a/kan/.ipynb_checkpoints/MLP-checkpoint.py +++ /dev/null @@ -1,361 +0,0 @@ -import torch -import torch.nn as nn -import matplotlib.pyplot as plt -import numpy as np -from tqdm import tqdm -from .LBFGS import LBFGS - -seed = 0 -torch.manual_seed(seed) - -class MLP(nn.Module): - - def __init__(self, width, act='silu', save_act=True, seed=0, device='cpu'): - super(MLP, self).__init__() - - torch.manual_seed(seed) - - linears = [] - self.width = width - self.depth = depth = len(width) - 1 - for i in range(depth): - linears.append(nn.Linear(width[i], width[i+1])) - self.linears = nn.ModuleList(linears) - - #if activation == 'silu': - self.act_fun = torch.nn.SiLU() - self.save_act = save_act - self.acts = None - - self.cache_data = None - - self.device = device - self.to(device) - - - def to(self, device): - super(MLP, self).to(device) - self.device = device - - return self - - - def get_act(self, x=None): - if isinstance(x, dict): - x = x['train_input'] - if x == None: - if self.cache_data != None: - x = self.cache_data - else: - raise Exception("missing input data x") - save_act = self.save_act - self.save_act = True - self.forward(x) - self.save_act = save_act - - @property - def w(self): - return [self.linears[l].weight for l in range(self.depth)] - - def forward(self, x): - - # cache data - self.cache_data = x - - self.acts = [] - self.acts_scale = [] - self.wa_forward = [] - self.a_forward = [] - - for i in range(self.depth): - - if self.save_act: - act = x.clone() - act_scale = torch.std(x, dim=0) - wa_forward = act_scale[None, :] * self.linears[i].weight - self.acts.append(act) - if i > 0: - self.acts_scale.append(act_scale) - self.wa_forward.append(wa_forward) - - x = self.linears[i](x) - if i < self.depth - 1: - x = self.act_fun(x) - else: - if self.save_act: - act_scale = torch.std(x, dim=0) - self.acts_scale.append(act_scale) - - return x - - def attribute(self): - if self.acts == None: - self.get_act() - - node_scores = [] - edge_scores = [] - - # back propagate from the last layer - node_score = torch.ones(self.width[-1]).requires_grad_(True).to(self.device) - node_scores.append(node_score) - - for l in range(self.depth,0,-1): - - edge_score = torch.einsum('ij,i->ij', torch.abs(self.wa_forward[l-1]), node_score/(self.acts_scale[l-1]+1e-4)) - edge_scores.append(edge_score) - - # this might be improper for MLPs (although reasonable for KANs) - node_score = torch.sum(edge_score, dim=0)/torch.sqrt(torch.tensor(self.width[l-1], device=self.device)) - #print(self.width[l]) - node_scores.append(node_score) - - self.node_scores = list(reversed(node_scores)) - self.edge_scores = list(reversed(edge_scores)) - self.wa_backward = self.edge_scores - - def plot(self, beta=3, scale=1., metric='w'): - # metric = 'w', 'act' or 'fa' - - if metric == 'fa': - self.attribute() - - depth = self.depth - y0 = 0.5 - fig, ax = plt.subplots(figsize=(3*scale,3*y0*depth*scale)) - shp = self.width - - min_spacing = 1/max(self.width) - for j in range(len(shp)): - N = shp[j] - for i in range(N): - plt.scatter(1 / (2 * N) + i / N, j * y0, s=min_spacing ** 2 * 5000 * scale ** 2, color='black') - - plt.ylim(-0.1*y0,y0*depth+0.1*y0) - plt.xlim(-0.02,1.02) - - linears = self.linears - - for ii in range(len(linears)): - linear = linears[ii] - p = linear.weight - p_shp = p.shape - - if metric == 'w': - pass - elif metric == 'act': - p = self.wa_forward[ii] - elif metric == 'fa': - p = self.wa_backward[ii] - else: - raise Exception('metric = \'{}\' not recognized. Choices are \'w\', \'act\', \'fa\'.'.format(metric)) - for i in range(p_shp[0]): - for j in range(p_shp[1]): - plt.plot([1/(2*p_shp[0])+i/p_shp[0], 1/(2*p_shp[1])+j/p_shp[1]], [y0*(ii+1),y0*ii], lw=0.5*scale, alpha=np.tanh(beta*np.abs(p[i,j].cpu().detach().numpy())), color="blue" if p[i,j]>0 else "red") - - ax.axis('off') - - def reg(self, reg_metric, lamb_l1, lamb_entropy): - - if reg_metric == 'w': - acts_scale = self.w - if reg_metric == 'act': - acts_scale = self.wa_forward - if reg_metric == 'fa': - acts_scale = self.wa_backward - if reg_metric == 'a': - acts_scale = self.acts_scale - - if len(acts_scale[0].shape) == 2: - reg_ = 0. - - for i in range(len(acts_scale)): - vec = acts_scale[i] - vec = torch.abs(vec) - - l1 = torch.sum(vec) - p_row = vec / (torch.sum(vec, dim=1, keepdim=True) + 1) - p_col = vec / (torch.sum(vec, dim=0, keepdim=True) + 1) - entropy_row = - torch.mean(torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1)) - entropy_col = - torch.mean(torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0)) - reg_ += lamb_l1 * l1 + lamb_entropy * (entropy_row + entropy_col) - - elif len(acts_scale[0].shape) == 1: - - reg_ = 0. - - for i in range(len(acts_scale)): - vec = acts_scale[i] - vec = torch.abs(vec) - - l1 = torch.sum(vec) - p = vec / (torch.sum(vec) + 1) - entropy = - torch.sum(p * torch.log2(p + 1e-4)) - reg_ += lamb_l1 * l1 + lamb_entropy * entropy - - return reg_ - - def get_reg(self, reg_metric, lamb_l1, lamb_entropy): - return self.reg(reg_metric, lamb_l1, lamb_entropy) - - def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., loss_fn=None, lr=1., batch=-1, - metrics=None, in_vars=None, out_vars=None, beta=3, device='cpu', reg_metric='w', display_metrics=None): - - if lamb > 0. and not self.save_act: - print('setting lamb=0. If you want to set lamb > 0, set =True') - - old_save_act = self.save_act - if lamb == 0.: - self.save_act = False - - pbar = tqdm(range(steps), desc='description', ncols=100) - - if loss_fn == None: - loss_fn = loss_fn_eval = lambda x, y: torch.mean((x - y) ** 2) - else: - loss_fn = loss_fn_eval = loss_fn - - if opt == "Adam": - optimizer = torch.optim.Adam(self.parameters(), lr=lr) - elif opt == "LBFGS": - optimizer = LBFGS(self.parameters(), lr=lr, history_size=10, line_search_fn="strong_wolfe", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32) - - results = {} - results['train_loss'] = [] - results['test_loss'] = [] - results['reg'] = [] - if metrics != None: - for i in range(len(metrics)): - results[metrics[i].__name__] = [] - - if batch == -1 or batch > dataset['train_input'].shape[0]: - batch_size = dataset['train_input'].shape[0] - batch_size_test = dataset['test_input'].shape[0] - else: - batch_size = batch - batch_size_test = batch - - global train_loss, reg_ - - def closure(): - global train_loss, reg_ - optimizer.zero_grad() - pred = self.forward(dataset['train_input'][train_id].to(self.device)) - train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device)) - if self.save_act: - if reg_metric == 'fa': - self.attribute() - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy) - else: - reg_ = torch.tensor(0.) - objective = train_loss + lamb * reg_ - objective.backward() - return objective - - for _ in pbar: - - if _ == steps-1 and old_save_act: - self.save_act = True - - train_id = np.random.choice(dataset['train_input'].shape[0], batch_size, replace=False) - test_id = np.random.choice(dataset['test_input'].shape[0], batch_size_test, replace=False) - - if opt == "LBFGS": - optimizer.step(closure) - - if opt == "Adam": - pred = self.forward(dataset['train_input'][train_id].to(self.device)) - train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device)) - if self.save_act: - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy) - else: - reg_ = torch.tensor(0.) - loss = train_loss + lamb * reg_ - optimizer.zero_grad() - loss.backward() - optimizer.step() - - test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id].to(self.device)), dataset['test_label'][test_id].to(self.device)) - - - if metrics != None: - for i in range(len(metrics)): - results[metrics[i].__name__].append(metrics[i]().item()) - - results['train_loss'].append(torch.sqrt(train_loss).cpu().detach().numpy()) - results['test_loss'].append(torch.sqrt(test_loss).cpu().detach().numpy()) - results['reg'].append(reg_.cpu().detach().numpy()) - - if _ % log == 0: - if display_metrics == None: - pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(), reg_.cpu().detach().numpy())) - else: - string = '' - data = () - for metric in display_metrics: - string += f' {metric}: %.2e |' - try: - results[metric] - except: - raise Exception(f'{metric} not recognized') - data += (results[metric][-1],) - pbar.set_description(string % data) - - return results - - @property - def connection_cost(self): - - with torch.no_grad(): - cc = 0. - for linear in self.linears: - t = torch.abs(linear.weight) - def get_coordinate(n): - return torch.linspace(0,1,steps=n+1, device=self.device)[:n] + 1/(2*n) - - in_dim = t.shape[0] - x_in = get_coordinate(in_dim) - - out_dim = t.shape[1] - x_out = get_coordinate(out_dim) - - dist = torch.abs(x_in[:,None] - x_out[None,:]) - cc += torch.sum(dist * t) - - return cc - - def swap(self, l, i1, i2): - - def swap_row(data, i1, i2): - data[i1], data[i2] = data[i2].clone(), data[i1].clone() - - def swap_col(data, i1, i2): - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() - - swap_row(self.linears[l-1].weight.data, i1, i2) - swap_row(self.linears[l-1].bias.data, i1, i2) - swap_col(self.linears[l].weight.data, i1, i2) - - def auto_swap_l(self, l): - - num = self.width[l] - for i in range(num): - ccs = [] - for j in range(num): - self.swap(l,i,j) - self.get_act() - self.attribute() - cc = self.connection_cost.detach().clone() - ccs.append(cc) - self.swap(l,i,j) - j = torch.argmin(torch.tensor(ccs)) - self.swap(l,i,j) - - def auto_swap(self): - depth = self.depth - for l in range(1, depth): - self.auto_swap_l(l) - - def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): - if x == None: - x = self.cache_data - plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test, verbose=verbose) \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/MultKAN-checkpoint.py b/kan/.ipynb_checkpoints/MultKAN-checkpoint.py deleted file mode 100644 index 37f3e5820..000000000 --- a/kan/.ipynb_checkpoints/MultKAN-checkpoint.py +++ /dev/null @@ -1,2805 +0,0 @@ -import torch -import torch.nn as nn -import numpy as np -from .KANLayer import KANLayer -#from .Symbolic_MultKANLayer import * -from .Symbolic_KANLayer import Symbolic_KANLayer -from .LBFGS import * -import os -import glob -import matplotlib.pyplot as plt -from tqdm import tqdm -import random -import copy -#from .MultKANLayer import MultKANLayer -import pandas as pd -from sympy.printing import latex -from sympy import * -import sympy -import yaml -from .spline import curve2coef -from .utils import SYMBOLIC_LIB -from .hypothesis import plot_tree - -class MultKAN(nn.Module): - ''' - KAN class - - Attributes: - ----------- - grid : int - the number of grid intervals - k : int - spline order - act_fun : a list of KANLayers - symbolic_fun: a list of Symbolic_KANLayer - depth : int - depth of KAN - width : list - number of neurons in each layer. - Without multiplication nodes, [2,5,5,3] means 2D inputs, 3D outputs, with 2 layers of 5 hidden neurons. - With multiplication nodes, [2,[5,3],[5,1],3] means besides the [2,5,53] KAN, there are 3 (1) mul nodes in layer 1 (2). - mult_arity : int, or list of int lists - multiplication arity for each multiplication node (the number of numbers to be multiplied) - grid : int - the number of grid intervals - k : int - the order of piecewise polynomial - base_fun : fun - residual function b(x). an activation function phi(x) = sb_scale * b(x) + sp_scale * spline(x) - symbolic_fun : a list of Symbolic_KANLayer - Symbolic_KANLayers - symbolic_enabled : bool - If False, the symbolic front is not computed (to save time). Default: True. - width_in : list - The number of input neurons for each layer - width_out : list - The number of output neurons for each layer - base_fun_name : str - The base function b(x) - grip_eps : float - The parameter that interpolates between uniform grid and adaptive grid (based on sample quantile) - node_bias : a list of 1D torch.float - node_scale : a list of 1D torch.float - subnode_bias : a list of 1D torch.float - subnode_scale : a list of 1D torch.float - symbolic_enabled : bool - when symbolic_enabled = False, the symbolic branch (symbolic_fun) will be ignored in computation (set to zero) - affine_trainable : bool - indicate whether affine parameters are trainable (node_bias, node_scale, subnode_bias, subnode_scale) - sp_trainable : bool - indicate whether the overall magnitude of splines is trainable - sb_trainable : bool - indicate whether the overall magnitude of base function is trainable - save_act : bool - indicate whether intermediate activations are saved in forward pass - node_scores : None or list of 1D torch.float - node attribution score - edge_scores : None or list of 2D torch.float - edge attribution score - subnode_scores : None or list of 1D torch.float - subnode attribution score - cache_data : None or 2D torch.float - cached input data - acts : None or a list of 2D torch.float - activations on nodes - auto_save : bool - indicate whether to automatically save a checkpoint once the model is modified - state_id : int - the state of the model (used to save checkpoint) - ckpt_path : str - the folder to store checkpoints - round : int - the number of times rewind() has been called - device : str - ''' - def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, scale_base_mu=0.0, scale_base_sigma=1.0, base_fun='silu', symbolic_enabled=True, affine_trainable=False, grid_eps=0.02, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, seed=1, save_act=True, sparse_init=False, auto_save=True, first_init=True, ckpt_path='./model', state_id=0, round=0, device='cpu'): - ''' - initalize a KAN model - - Args: - ----- - width : list of int - Without multiplication nodes: :math:`[n_0, n_1, .., n_{L-1}]` specify the number of neurons in each layer (including inputs/outputs) - With multiplication nodes: :math:`[[n_0,m_0=0], [n_1,m_1], .., [n_{L-1},m_{L-1}]]` specify the number of addition/multiplication nodes in each layer (including inputs/outputs) - grid : int - number of grid intervals. Default: 3. - k : int - order of piecewise polynomial. Default: 3. - mult_arity : int, or list of int lists - multiplication arity for each multiplication node (the number of numbers to be multiplied) - noise_scale : float - initial injected noise to spline. - base_fun : str - the residual function b(x). Default: 'silu' - symbolic_enabled : bool - compute (True) or skip (False) symbolic computations (for efficiency). By default: True. - affine_trainable : bool - affine parameters are updated or not. Affine parameters include node_scale, node_bias, subnode_scale, subnode_bias - grid_eps : float - When grid_eps = 1, the grid is uniform; when grid_eps = 0, the grid is partitioned using percentiles of samples. 0 < grid_eps < 1 interpolates between the two extremes. - grid_range : list/np.array of shape (2,)) - setting the range of grids. Default: [-1,1]. This argument is not important if fit(update_grid=True) (by default updata_grid=True) - sp_trainable : bool - If true, scale_sp is trainable. Default: True. - sb_trainable : bool - If true, scale_base is trainable. Default: True. - device : str - device - seed : int - random seed - save_act : bool - indicate whether intermediate activations are saved in forward pass - sparse_init : bool - sparse initialization (True) or normal dense initialization. Default: False. - auto_save : bool - indicate whether to automatically save a checkpoint once the model is modified - state_id : int - the state of the model (used to save checkpoint) - ckpt_path : str - the folder to store checkpoints. Default: './model' - round : int - the number of times rewind() has been called - device : str - - Returns: - -------- - self - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - checkpoint directory created: ./model - saving model version 0.0 - ''' - super(MultKAN, self).__init__() - - torch.manual_seed(seed) - np.random.seed(seed) - random.seed(seed) - - ### initializeing the numerical front ### - - self.act_fun = [] - self.depth = len(width) - 1 - - #print('haha1', width) - for i in range(len(width)): - #print(type(width[i]), type(width[i]) == int) - if type(width[i]) == int or type(width[i]) == np.int64: - width[i] = [width[i],0] - - #print('haha2', width) - - self.width = width - - # if mult_arity is just a scalar, we extend it to a list of lists - # e.g, mult_arity = [[2,3],[4]] means that in the first hidden layer, 2 mult ops have arity 2 and 3, respectively; - # in the second hidden layer, 1 mult op has arity 4. - if isinstance(mult_arity, int): - self.mult_homo = True # when homo is True, parallelization is possible - else: - self.mult_homo = False # when home if False, for loop is required. - self.mult_arity = mult_arity - - width_in = self.width_in - width_out = self.width_out - - self.base_fun_name = base_fun - if base_fun == 'silu': - base_fun = torch.nn.SiLU() - elif base_fun == 'identity': - base_fun = torch.nn.Identity() - elif base_fun == 'zero': - base_fun = lambda x: x*0. - - self.grid_eps = grid_eps - self.grid_range = grid_range - - - for l in range(self.depth): - # splines - if isinstance(grid, list): - grid_l = grid[l] - else: - grid_l = grid - - if isinstance(k, list): - k_l = k[l] - else: - k_l = k - - - sp_batch = KANLayer(in_dim=width_in[l], out_dim=width_out[l+1], num=grid_l, k=k_l, noise_scale=noise_scale, scale_base_mu=scale_base_mu, scale_base_sigma=scale_base_sigma, scale_sp=1., base_fun=base_fun, grid_eps=grid_eps, grid_range=grid_range, sp_trainable=sp_trainable, sb_trainable=sb_trainable, sparse_init=sparse_init) - self.act_fun.append(sp_batch) - - self.node_bias = [] - self.node_scale = [] - self.subnode_bias = [] - self.subnode_scale = [] - - globals()['self.node_bias_0'] = torch.nn.Parameter(torch.zeros(3,1)).requires_grad_(False) - exec('self.node_bias_0' + " = torch.nn.Parameter(torch.zeros(3,1)).requires_grad_(False)") - - for l in range(self.depth): - exec(f'self.node_bias_{l} = torch.nn.Parameter(torch.zeros(width_in[l+1])).requires_grad_(affine_trainable)') - exec(f'self.node_scale_{l} = torch.nn.Parameter(torch.ones(width_in[l+1])).requires_grad_(affine_trainable)') - exec(f'self.subnode_bias_{l} = torch.nn.Parameter(torch.zeros(width_out[l+1])).requires_grad_(affine_trainable)') - exec(f'self.subnode_scale_{l} = torch.nn.Parameter(torch.ones(width_out[l+1])).requires_grad_(affine_trainable)') - exec(f'self.node_bias.append(self.node_bias_{l})') - exec(f'self.node_scale.append(self.node_scale_{l})') - exec(f'self.subnode_bias.append(self.subnode_bias_{l})') - exec(f'self.subnode_scale.append(self.subnode_scale_{l})') - - - self.act_fun = nn.ModuleList(self.act_fun) - - self.grid = grid - self.k = k - self.base_fun = base_fun - - ### initializing the symbolic front ### - self.symbolic_fun = [] - for l in range(self.depth): - sb_batch = Symbolic_KANLayer(in_dim=width_in[l], out_dim=width_out[l+1]) - self.symbolic_fun.append(sb_batch) - - self.symbolic_fun = nn.ModuleList(self.symbolic_fun) - self.symbolic_enabled = symbolic_enabled - self.affine_trainable = affine_trainable - self.sp_trainable = sp_trainable - self.sb_trainable = sb_trainable - - self.save_act = save_act - - self.node_scores = None - self.edge_scores = None - self.subnode_scores = None - - self.cache_data = None - self.acts = None - - self.auto_save = auto_save - self.state_id = 0 - self.ckpt_path = ckpt_path - self.round = round - - self.device = device - self.to(device) - - if auto_save: - if first_init: - if not os.path.exists(ckpt_path): - # Create the directory - os.makedirs(ckpt_path) - print(f"checkpoint directory created: {ckpt_path}") - print('saving model version 0.0') - - history_path = self.ckpt_path+'/history.txt' - with open(history_path, 'w') as file: - file.write(f'### Round {self.round} ###' + '\n') - file.write('init => 0.0' + '\n') - self.saveckpt(path=self.ckpt_path+'/'+'0.0') - else: - self.state_id = state_id - - self.input_id = torch.arange(self.width_in[0],) - - def to(self, device): - ''' - move the model to device - - Args: - ----- - device : str or device - - Returns: - -------- - self - - Example - ------- - >>> from kan import * - >>> device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - >>> model.to(device) - ''' - super(MultKAN, self).to(device) - self.device = device - - for kanlayer in self.act_fun: - kanlayer.to(device) - - for symbolic_kanlayer in self.symbolic_fun: - symbolic_kanlayer.to(device) - - return self - - @property - def width_in(self): - ''' - The number of input nodes for each layer - ''' - width = self.width - width_in = [width[l][0]+width[l][1] for l in range(len(width))] - return width_in - - @property - def width_out(self): - ''' - The number of output subnodes for each layer - ''' - width = self.width - if self.mult_homo == True: - width_out = [width[l][0]+self.mult_arity*width[l][1] for l in range(len(width))] - else: - width_out = [width[l][0]+int(np.sum(self.mult_arity[l])) for l in range(len(width))] - return width_out - - @property - def n_sum(self): - ''' - The number of addition nodes for each layer - ''' - width = self.width - n_sum = [width[l][0] for l in range(1,len(width)-1)] - return n_sum - - @property - def n_mult(self): - ''' - The number of multiplication nodes for each layer - ''' - width = self.width - n_mult = [width[l][1] for l in range(1,len(width)-1)] - return n_mult - - @property - def feature_score(self): - ''' - attribution scores for inputs - ''' - self.attribute() - if self.node_scores == None: - return None - else: - return self.node_scores[0] - - def initialize_from_another_model(self, another_model, x): - ''' - initialize from another model of the same width, but their 'grid' parameter can be different. - Note this is equivalent to refine() when we don't want to keep another_model - - Args: - ----- - another_model : MultKAN - x : 2D torch.float - - Returns: - -------- - self - - Example - ------- - >>> from kan import * - >>> model1 = KAN(width=[2,5,1], grid=3) - >>> model2 = KAN(width=[2,5,1], grid=10) - >>> x = torch.rand(100,2) - >>> model2.initialize_from_another_model(model1, x) - ''' - another_model(x) # get activations - batch = x.shape[0] - - self.initialize_grid_from_another_model(another_model, x) - - for l in range(self.depth): - spb = self.act_fun[l] - #spb_parent = another_model.act_fun[l] - - # spb = spb_parent - preacts = another_model.spline_preacts[l] - postsplines = another_model.spline_postsplines[l] - self.act_fun[l].coef.data = curve2coef(preacts[:,0,:], postsplines.permute(0,2,1), spb.grid, k=spb.k) - self.act_fun[l].scale_base.data = another_model.act_fun[l].scale_base.data - self.act_fun[l].scale_sp.data = another_model.act_fun[l].scale_sp.data - self.act_fun[l].mask.data = another_model.act_fun[l].mask.data - - for l in range(self.depth): - self.node_bias[l].data = another_model.node_bias[l].data - self.node_scale[l].data = another_model.node_scale[l].data - - self.subnode_bias[l].data = another_model.subnode_bias[l].data - self.subnode_scale[l].data = another_model.subnode_scale[l].data - - for l in range(self.depth): - self.symbolic_fun[l] = another_model.symbolic_fun[l] - - return self.to(self.device) - - def log_history(self, method_name): - - if self.auto_save: - - # save to log file - #print(func.__name__) - with open(self.ckpt_path+'/history.txt', 'a') as file: - file.write(str(self.round)+'.'+str(self.state_id)+' => '+ method_name + ' => ' + str(self.round)+'.'+str(self.state_id+1) + '\n') - - # update state_id - self.state_id += 1 - - # save to ckpt - self.saveckpt(path=self.ckpt_path+'/'+str(self.round)+'.'+str(self.state_id)) - print('saving model version '+str(self.round)+'.'+str(self.state_id)) - - - def refine(self, new_grid): - ''' - grid refinement - - Args: - ----- - new_grid : init - the number of grid intervals after refinement - - Returns: - -------- - a refined model : MultKAN - - Example - ------- - >>> from kan import * - >>> device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - >>> print(model.grid) - >>> x = torch.rand(100,2) - >>> model.get_act(x) - >>> model = model.refine(10) - >>> print(model.grid) - checkpoint directory created: ./model - saving model version 0.0 - 5 - saving model version 0.1 - 10 - ''' - - model_new = MultKAN(width=self.width, - grid=new_grid, - k=self.k, - mult_arity=self.mult_arity, - base_fun=self.base_fun_name, - symbolic_enabled=self.symbolic_enabled, - affine_trainable=self.affine_trainable, - grid_eps=self.grid_eps, - grid_range=self.grid_range, - sp_trainable=self.sp_trainable, - sb_trainable=self.sb_trainable, - ckpt_path=self.ckpt_path, - auto_save=True, - first_init=False, - state_id=self.state_id, - round=self.round, - device=self.device) - - model_new.initialize_from_another_model(self, self.cache_data) - model_new.cache_data = self.cache_data - model_new.grid = new_grid - - self.log_history('refine') - model_new.state_id += 1 - - return model_new.to(self.device) - - - def saveckpt(self, path='model'): - ''' - save the current model to files (configuration file and state file) - - Args: - ----- - path : str - the path where checkpoints are saved - - Returns: - -------- - None - - Example - ------- - >>> from kan import * - >>> device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - >>> model.saveckpt('./mark') - # There will be three files appearing in the current folder: mark_cache_data, mark_config.yml, mark_state - ''' - - model = self - - dic = dict( - width = model.width, - grid = model.grid, - k = model.k, - mult_arity = model.mult_arity, - base_fun_name = model.base_fun_name, - symbolic_enabled = model.symbolic_enabled, - affine_trainable = model.affine_trainable, - grid_eps = model.grid_eps, - grid_range = model.grid_range, - sp_trainable = model.sp_trainable, - sb_trainable = model.sb_trainable, - state_id = model.state_id, - auto_save = model.auto_save, - ckpt_path = model.ckpt_path, - round = model.round, - device = str(model.device) - ) - - for i in range (model.depth): - dic[f'symbolic.funs_name.{i}'] = model.symbolic_fun[i].funs_name - - with open(f'{path}_config.yml', 'w') as outfile: - yaml.dump(dic, outfile, default_flow_style=False) - - torch.save(model.state_dict(), f'{path}_state') - torch.save(model.cache_data, f'{path}_cache_data') - - @staticmethod - def loadckpt(path='model'): - ''' - load checkpoint from path - - Args: - ----- - path : str - the path where checkpoints are saved - - Returns: - -------- - MultKAN - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - >>> model.saveckpt('./mark') - >>> KAN.loadckpt('./mark') - ''' - with open(f'{path}_config.yml', 'r') as stream: - config = yaml.safe_load(stream) - - state = torch.load(f'{path}_state') - - model_load = MultKAN(width=config['width'], - grid=config['grid'], - k=config['k'], - mult_arity = config['mult_arity'], - base_fun=config['base_fun_name'], - symbolic_enabled=config['symbolic_enabled'], - affine_trainable=config['affine_trainable'], - grid_eps=config['grid_eps'], - grid_range=config['grid_range'], - sp_trainable=config['sp_trainable'], - sb_trainable=config['sb_trainable'], - state_id=config['state_id'], - auto_save=config['auto_save'], - first_init=False, - ckpt_path=config['ckpt_path'], - round = config['round']+1, - device = config['device']) - - model_load.load_state_dict(state) - model_load.cache_data = torch.load(f'{path}_cache_data') - - depth = len(model_load.width) - 1 - for l in range(depth): - out_dim = model_load.symbolic_fun[l].out_dim - in_dim = model_load.symbolic_fun[l].in_dim - funs_name = config[f'symbolic.funs_name.{l}'] - for j in range(out_dim): - for i in range(in_dim): - fun_name = funs_name[j][i] - model_load.symbolic_fun[l].funs_name[j][i] = fun_name - model_load.symbolic_fun[l].funs[j][i] = SYMBOLIC_LIB[fun_name][0] - model_load.symbolic_fun[l].funs_sympy[j][i] = SYMBOLIC_LIB[fun_name][1] - model_load.symbolic_fun[l].funs_avoid_singularity[j][i] = SYMBOLIC_LIB[fun_name][3] - return model_load - - def copy(self): - ''' - deepcopy - - Args: - ----- - path : str - the path where checkpoints are saved - - Returns: - -------- - MultKAN - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[1,1], grid=5, k=3, seed=0) - >>> model2 = model.copy() - >>> model2.act_fun[0].coef.data *= 2 - >>> print(model2.act_fun[0].coef.data) - >>> print(model.act_fun[0].coef.data) - ''' - path='copy_temp' - self.saveckpt(path) - return KAN.loadckpt(path) - - def rewind(self, model_id): - ''' - rewind to an old version - - Args: - ----- - model_id : str - in format '{a}.{b}' where a is the round number, b is the version number in that round - - Returns: - -------- - MultKAN - - Example - ------- - Please refer to tutorials. API 12: Checkpoint, save & load model - ''' - self.round += 1 - self.state_id = model_id.split('.')[-1] - - history_path = self.ckpt_path+'/history.txt' - with open(history_path, 'a') as file: - file.write(f'### Round {self.round} ###' + '\n') - - self.saveckpt(path=self.ckpt_path+'/'+f'{self.round}.{self.state_id}') - - print('rewind to model version '+f'{self.round-1}.{self.state_id}'+', renamed as '+f'{self.round}.{self.state_id}') - - return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id)) - - - def checkout(self, model_id): - ''' - check out an old version - - Args: - ----- - model_id : str - in format '{a}.{b}' where a is the round number, b is the version number in that round - - Returns: - -------- - MultKAN - - Example - ------- - Same use as rewind, although checkout doesn't change states - ''' - return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id)) - - def update_grid_from_samples(self, x): - ''' - update grid from samples - - Args: - ----- - x : 2D torch.tensor - inputs - - Returns: - -------- - None - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[1,1], grid=5, k=3, seed=0) - >>> print(model.act_fun[0].grid) - >>> x = torch.linspace(-10,10,steps=101)[:,None] - >>> model.update_grid_from_samples(x) - >>> print(model.act_fun[0].grid) - ''' - for l in range(self.depth): - self.get_act(x) - self.act_fun[l].update_grid_from_samples(self.acts[l]) - - def update_grid(self, x): - ''' - call update_grid_from_samples. This seems unnecessary but we retain it for the sake of classes that might inherit from MultKAN - ''' - self.update_grid_from_samples(x) - - def initialize_grid_from_another_model(self, model, x): - ''' - initialize grid from another model - - Args: - ----- - model : MultKAN - parent model - x : 2D torch.tensor - inputs - - Returns: - -------- - None - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[1,1], grid=5, k=3, seed=0) - >>> print(model.act_fun[0].grid) - >>> x = torch.linspace(-10,10,steps=101)[:,None] - >>> model2 = KAN(width=[1,1], grid=10, k=3, seed=0) - >>> model2.initialize_grid_from_another_model(model, x) - >>> print(model2.act_fun[0].grid) - ''' - model(x) - for l in range(self.depth): - self.act_fun[l].initialize_grid_from_parent(model.act_fun[l], model.acts[l]) - - def forward(self, x, singularity_avoiding=False, y_th=10.): - ''' - forward pass - - Args: - ----- - x : 2D torch.tensor - inputs - singularity_avoiding : bool - whether to avoid singularity for the symbolic branch - y_th : float - the threshold for singularity - - Returns: - -------- - None - - Example1 - -------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) - >>> x = torch.rand(100,2) - >>> model(x).shape - - Example2 - -------- - >>> from kan import * - >>> model = KAN(width=[1,1], grid=5, k=3, seed=0) - >>> x = torch.tensor([[1],[-0.01]]) - >>> model.fix_symbolic(0,0,0,'log',fit_params_bool=False) - >>> print(model(x)) - >>> print(model(x, singularity_avoiding=True)) - >>> print(model(x, singularity_avoiding=True, y_th=1.)) - ''' - x = x[:,self.input_id.long()] - assert x.shape[1] == self.width_in[0] - - # cache data - self.cache_data = x - - self.acts = [] # shape ([batch, n0], [batch, n1], ..., [batch, n_L]) - self.acts_premult = [] - self.spline_preacts = [] - self.spline_postsplines = [] - self.spline_postacts = [] - self.acts_scale = [] - self.acts_scale_spline = [] - self.subnode_actscale = [] - self.edge_actscale = [] - # self.neurons_scale = [] - - self.acts.append(x) # acts shape: (batch, width[l]) - - for l in range(self.depth): - - x_numerical, preacts, postacts_numerical, postspline = self.act_fun[l](x) - #print(preacts, postacts_numerical, postspline) - - if self.symbolic_enabled == True: - x_symbolic, postacts_symbolic = self.symbolic_fun[l](x, singularity_avoiding=singularity_avoiding, y_th=y_th) - else: - x_symbolic = 0. - postacts_symbolic = 0. - - x = x_numerical + x_symbolic - - if self.save_act: - # save subnode_scale - self.subnode_actscale.append(torch.std(x, dim=0).detach()) - - # subnode affine transform - x = self.subnode_scale[l][None,:] * x + self.subnode_bias[l][None,:] - - if self.save_act: - postacts = postacts_numerical + postacts_symbolic - - # self.neurons_scale.append(torch.mean(torch.abs(x), dim=0)) - #grid_reshape = self.act_fun[l].grid.reshape(self.width_out[l + 1], self.width_in[l], -1) - input_range = torch.std(preacts, dim=0) + 0.1 - output_range_spline = torch.std(postacts_numerical, dim=0) # for training, only penalize the spline part - output_range = torch.std(postacts, dim=0) # for visualization, include the contribution from both spline + symbolic - # save edge_scale - self.edge_actscale.append(output_range) - - self.acts_scale.append((output_range / input_range).detach()) - self.acts_scale_spline.append(output_range_spline / input_range) - self.spline_preacts.append(preacts.detach()) - self.spline_postacts.append(postacts.detach()) - self.spline_postsplines.append(postspline.detach()) - - self.acts_premult.append(x.detach()) - - # multiplication - dim_sum = self.width[l+1][0] - dim_mult = self.width[l+1][1] - - if self.mult_homo == True: - for i in range(self.mult_arity-1): - if i == 0: - x_mult = x[:,dim_sum::self.mult_arity] * x[:,dim_sum+1::self.mult_arity] - else: - x_mult = x_mult * x[:,dim_sum+i+1::self.mult_arity] - - else: - for j in range(dim_mult): - acml_id = dim_sum + np.sum(self.mult_arity[l+1][:j]) - for i in range(self.mult_arity[l+1][j]-1): - if i == 0: - x_mult_j = x[:,[acml_id]] * x[:,[acml_id+1]] - else: - x_mult_j = x_mult_j * x[:,[acml_id+i+1]] - - if j == 0: - x_mult = x_mult_j - else: - x_mult = torch.cat([x_mult, x_mult_j], dim=1) - - if self.width[l+1][1] > 0: - x = torch.cat([x[:,:dim_sum], x_mult], dim=1) - - # x = x + self.biases[l].weight - # node affine transform - x = self.node_scale[l][None,:] * x + self.node_bias[l][None,:] - - self.acts.append(x.detach()) - - - return x - - def set_mode(self, l, i, j, mode, mask_n=None): - if mode == "s": - mask_n = 0.; - mask_s = 1. - elif mode == "n": - mask_n = 1.; - mask_s = 0. - elif mode == "sn" or mode == "ns": - if mask_n == None: - mask_n = 1. - else: - mask_n = mask_n - mask_s = 1. - else: - mask_n = 0.; - mask_s = 0. - - self.act_fun[l].mask.data[i][j] = mask_n - self.symbolic_fun[l].mask.data[j,i] = mask_s - - def fix_symbolic(self, l, i, j, fun_name, fit_params_bool=True, a_range=(-10, 10), b_range=(-10, 10), verbose=True, random=False, log_history=True): - ''' - set (l,i,j) activation to be symbolic (specified by fun_name) - - Args: - ----- - l : int - layer index - i : int - input neuron index - j : int - output neuron index - fun_name : str - function name - fit_params_bool : bool - obtaining affine parameters through fitting (True) or setting default values (False) - a_range : tuple - sweeping range of a - b_range : tuple - sweeping range of b - verbose : bool - If True, more information is printed. - random : bool - initialize affine parameteres randomly or as [1,0,1,0] - log_history : bool - indicate whether to log history when the function is called - - Returns: - -------- - None or r2 (coefficient of determination) - - Example 1 - --------- - >>> # when fit_params_bool = False - >>> model = KAN(width=[2,5,1], grid=5, k=3) - >>> model.fix_symbolic(0,1,3,'sin',fit_params_bool=False) - >>> print(model.act_fun[0].mask.reshape(2,5)) - >>> print(model.symbolic_fun[0].mask.reshape(2,5)) - - Example 2 - --------- - >>> # when fit_params_bool = True - >>> model = KAN(width=[2,5,1], grid=5, k=3, noise_scale=1.) - >>> x = torch.normal(0,1,size=(100,2)) - >>> model(x) # obtain activations (otherwise model does not have attributes acts) - >>> model.fix_symbolic(0,1,3,'sin',fit_params_bool=True) - >>> print(model.act_fun[0].mask.reshape(2,5)) - >>> print(model.symbolic_fun[0].mask.reshape(2,5)) - ''' - if not fit_params_bool: - self.symbolic_fun[l].fix_symbolic(i, j, fun_name, verbose=verbose, random=random) - r2 = None - else: - x = self.acts[l][:, i] - mask = self.act_fun[l].mask - y = self.spline_postacts[l][:, j, i] - #y = self.postacts[l][:, j, i] - r2 = self.symbolic_fun[l].fix_symbolic(i, j, fun_name, x, y, a_range=a_range, b_range=b_range, verbose=verbose) - if mask[i,j] == 0: - r2 = - 1e8 - self.set_mode(l, i, j, mode="s") - - if log_history: - self.log_history('fix_symbolic') - return r2 - - def unfix_symbolic(self, l, i, j, log_history=True): - ''' - unfix the (l,i,j) activation function. - ''' - self.set_mode(l, i, j, mode="n") - self.symbolic_fun[l].funs_name[j][i] = "0" - if log_history: - self.log_history('unfix_symbolic') - - def unfix_symbolic_all(self, log_history=True): - ''' - unfix all activation functions. - ''' - for l in range(len(self.width) - 1): - for i in range(self.width_in[l]): - for j in range(self.width_out[l + 1]): - self.unfix_symbolic(l, i, j, log_history) - - def get_range(self, l, i, j, verbose=True): - ''' - Get the input range and output range of the (l,i,j) activation - - Args: - ----- - l : int - layer index - i : int - input neuron index - j : int - output neuron index - - Returns: - -------- - x_min : float - minimum of input - x_max : float - maximum of input - y_min : float - minimum of output - y_max : float - maximum of output - - Example - ------- - >>> model = KAN(width=[2,3,1], grid=5, k=3, noise_scale=1.) - >>> x = torch.normal(0,1,size=(100,2)) - >>> model(x) # do a forward pass to obtain model.acts - >>> model.get_range(0,0,0) - ''' - x = self.spline_preacts[l][:, j, i] - y = self.spline_postacts[l][:, j, i] - x_min = torch.min(x).cpu().detach().numpy() - x_max = torch.max(x).cpu().detach().numpy() - y_min = torch.min(y).cpu().detach().numpy() - y_max = torch.max(y).cpu().detach().numpy() - if verbose: - print('x range: [' + '%.2f' % x_min, ',', '%.2f' % x_max, ']') - print('y range: [' + '%.2f' % y_min, ',', '%.2f' % y_max, ']') - return x_min, x_max, y_min, y_max - - def plot(self, folder="./figures", beta=3, metric='backward', scale=0.5, tick=False, sample=False, in_vars=None, out_vars=None, title=None, varscale=1.0): - ''' - plot KAN - - Args: - ----- - folder : str - the folder to store pngs - beta : float - positive number. control the transparency of each activation. transparency = tanh(beta*l1). - mask : bool - If True, plot with mask (need to run prune() first to obtain mask). If False (by default), plot all activation functions. - mode : bool - "supervised" or "unsupervised". If "supervised", l1 is measured by absolution value (not subtracting mean); if "unsupervised", l1 is measured by standard deviation (subtracting mean). - scale : float - control the size of the diagram - in_vars: None or list of str - the name(s) of input variables - out_vars: None or list of str - the name(s) of output variables - title: None or str - title - varscale : float - the size of input variables - - Returns: - -------- - Figure - - Example - ------- - >>> # see more interactive examples in demos - >>> model = KAN(width=[2,3,1], grid=3, k=3, noise_scale=1.0) - >>> x = torch.normal(0,1,size=(100,2)) - >>> model(x) # do a forward pass to obtain model.acts - >>> model.plot() - ''' - global Symbol - - if not self.save_act: - print('cannot plot since data are not saved. Set save_act=True first.') - - # forward to obtain activations - if self.acts == None: - if self.cache_data == None: - raise Exception('model hasn\'t seen any data yet.') - self.forward(self.cache_data) - - if metric == 'backward': - self.attribute() - - - if not os.path.exists(folder): - os.makedirs(folder) - # matplotlib.use('Agg') - depth = len(self.width) - 1 - for l in range(depth): - w_large = 2.0 - for i in range(self.width_in[l]): - for j in range(self.width_out[l+1]): - rank = torch.argsort(self.acts[l][:, i]) - fig, ax = plt.subplots(figsize=(w_large, w_large)) - - num = rank.shape[0] - - #print(self.width_in[l]) - #print(self.width_out[l+1]) - symbolic_mask = self.symbolic_fun[l].mask[j][i] - numeric_mask = self.act_fun[l].mask[i][j] - if symbolic_mask > 0. and numeric_mask > 0.: - color = 'purple' - alpha_mask = 1 - if symbolic_mask > 0. and numeric_mask == 0.: - color = "red" - alpha_mask = 1 - if symbolic_mask == 0. and numeric_mask > 0.: - color = "black" - alpha_mask = 1 - if symbolic_mask == 0. and numeric_mask == 0.: - color = "white" - alpha_mask = 0 - - - if tick == True: - ax.tick_params(axis="y", direction="in", pad=-22, labelsize=50) - ax.tick_params(axis="x", direction="in", pad=-15, labelsize=50) - x_min, x_max, y_min, y_max = self.get_range(l, i, j, verbose=False) - plt.xticks([x_min, x_max], ['%2.f' % x_min, '%2.f' % x_max]) - plt.yticks([y_min, y_max], ['%2.f' % y_min, '%2.f' % y_max]) - else: - plt.xticks([]) - plt.yticks([]) - if alpha_mask == 1: - plt.gca().patch.set_edgecolor('black') - else: - plt.gca().patch.set_edgecolor('white') - plt.gca().patch.set_linewidth(1.5) - # plt.axis('off') - - plt.plot(self.acts[l][:, i][rank].cpu().detach().numpy(), self.spline_postacts[l][:, j, i][rank].cpu().detach().numpy(), color=color, lw=5) - if sample == True: - plt.scatter(self.acts[l][:, i][rank].cpu().detach().numpy(), self.spline_postacts[l][:, j, i][rank].cpu().detach().numpy(), color=color, s=400 * scale ** 2) - plt.gca().spines[:].set_color(color) - - plt.savefig(f'{folder}/sp_{l}_{i}_{j}.png', bbox_inches="tight", dpi=400) - plt.close() - - def score2alpha(score): - return np.tanh(beta * score) - - - if metric == 'forward_n': - scores = self.acts_scale - elif metric == 'forward_u': - scores = self.edge_actscale - elif metric == 'backward': - scores = self.edge_scores - else: - raise Exception(f'metric = \'{metric}\' not recognized') - - alpha = [score2alpha(score.cpu().detach().numpy()) for score in scores] - - # draw skeleton - width = np.array(self.width) - width_in = np.array(self.width_in) - width_out = np.array(self.width_out) - A = 1 - y0 = 0.3 # height: from input to pre-mult - z0 = 0.1 # height: from pre-mult to post-mult (input of next layer) - - neuron_depth = len(width) - min_spacing = A / np.maximum(np.max(width_out), 5) - - max_neuron = np.max(width_out) - max_num_weights = np.max(width_in[:-1] * width_out[1:]) - y1 = 0.4 / np.maximum(max_num_weights, 5) # size (height/width) of 1D function diagrams - y2 = 0.15 / np.maximum(max_neuron, 5) # size (height/width) of operations (sum and mult) - - fig, ax = plt.subplots(figsize=(10 * scale, 10 * scale * (neuron_depth - 1) * (y0+z0))) - # fig, ax = plt.subplots(figsize=(5,5*(neuron_depth-1)*y0)) - - # -- Transformation functions - DC_to_FC = ax.transData.transform - FC_to_NFC = fig.transFigure.inverted().transform - # -- Take data coordinates and transform them to normalized figure coordinates - DC_to_NFC = lambda x: FC_to_NFC(DC_to_FC(x)) - - # plot scatters and lines - for l in range(neuron_depth): - - n = width_in[l] - - # scatters - for i in range(n): - plt.scatter(1 / (2 * n) + i / n, l * (y0+z0), s=min_spacing ** 2 * 10000 * scale ** 2, color='black') - - # plot connections (input to pre-mult) - for i in range(n): - if l < neuron_depth - 1: - n_next = width_out[l+1] - N = n * n_next - for j in range(n_next): - id_ = i * n_next + j - - symbol_mask = self.symbolic_fun[l].mask[j][i] - numerical_mask = self.act_fun[l].mask[i][j] - if symbol_mask == 1. and numerical_mask > 0.: - color = 'purple' - alpha_mask = 1. - if symbol_mask == 1. and numerical_mask == 0.: - color = "red" - alpha_mask = 1. - if symbol_mask == 0. and numerical_mask == 1.: - color = "black" - alpha_mask = 1. - if symbol_mask == 0. and numerical_mask == 0.: - color = "white" - alpha_mask = 0. - - plt.plot([1 / (2 * n) + i / n, 1 / (2 * N) + id_ / N], [l * (y0+z0), l * (y0+z0) + y0/2 - y1], color=color, lw=2 * scale, alpha=alpha[l][j][i] * alpha_mask) - plt.plot([1 / (2 * N) + id_ / N, 1 / (2 * n_next) + j / n_next], [l * (y0+z0) + y0/2 + y1, l * (y0+z0)+y0], color=color, lw=2 * scale, alpha=alpha[l][j][i] * alpha_mask) - - - # plot connections (pre-mult to post-mult, post-mult = next-layer input) - if l < neuron_depth - 1: - n_in = width_out[l+1] - n_out = width_in[l+1] - mult_id = 0 - for i in range(n_in): - if i < width[l+1][0]: - j = i - else: - if i == width[l+1][0]: - if isinstance(self.mult_arity,int): - ma = self.mult_arity - else: - ma = self.mult_arity[l+1][mult_id] - current_mult_arity = ma - if current_mult_arity == 0: - mult_id += 1 - if isinstance(self.mult_arity,int): - ma = self.mult_arity - else: - ma = self.mult_arity[l+1][mult_id] - current_mult_arity = ma - j = width[l+1][0] + mult_id - current_mult_arity -= 1 - #j = (i-width[l+1][0])//self.mult_arity + width[l+1][0] - plt.plot([1 / (2 * n_in) + i / n_in, 1 / (2 * n_out) + j / n_out], [l * (y0+z0) + y0, (l+1) * (y0+z0)], color='black', lw=2 * scale) - - - - plt.xlim(0, 1) - plt.ylim(-0.1 * (y0+z0), (neuron_depth - 1 + 0.1) * (y0+z0)) - - - plt.axis('off') - - for l in range(neuron_depth - 1): - # plot splines - n = width_in[l] - for i in range(n): - n_next = width_out[l + 1] - N = n * n_next - for j in range(n_next): - id_ = i * n_next + j - im = plt.imread(f'{folder}/sp_{l}_{i}_{j}.png') - left = DC_to_NFC([1 / (2 * N) + id_ / N - y1, 0])[0] - right = DC_to_NFC([1 / (2 * N) + id_ / N + y1, 0])[0] - bottom = DC_to_NFC([0, l * (y0+z0) + y0/2 - y1])[1] - up = DC_to_NFC([0, l * (y0+z0) + y0/2 + y1])[1] - newax = fig.add_axes([left, bottom, right - left, up - bottom]) - # newax = fig.add_axes([1/(2*N)+id_/N-y1, (l+1/2)*y0-y1, y1, y1], anchor='NE') - newax.imshow(im, alpha=alpha[l][j][i]) - newax.axis('off') - - - # plot sum symbols - N = n = width_out[l+1] - for j in range(n): - id_ = j - path = os.path.dirname(os.path.abspath(__file__)) + "/assets/img/sum_symbol.png" - im = plt.imread(path) - left = DC_to_NFC([1 / (2 * N) + id_ / N - y2, 0])[0] - right = DC_to_NFC([1 / (2 * N) + id_ / N + y2, 0])[0] - bottom = DC_to_NFC([0, l * (y0+z0) + y0 - y2])[1] - up = DC_to_NFC([0, l * (y0+z0) + y0 + y2])[1] - newax = fig.add_axes([left, bottom, right - left, up - bottom]) - newax.imshow(im) - newax.axis('off') - - # plot mult symbols - N = n = width_in[l+1] - n_sum = width[l+1][0] - n_mult = width[l+1][1] - for j in range(n_mult): - id_ = j + n_sum - path = os.path.dirname(os.path.abspath(__file__)) + "/assets/img/mult_symbol.png" - im = plt.imread(path) - left = DC_to_NFC([1 / (2 * N) + id_ / N - y2, 0])[0] - right = DC_to_NFC([1 / (2 * N) + id_ / N + y2, 0])[0] - bottom = DC_to_NFC([0, (l+1) * (y0+z0) - y2])[1] - up = DC_to_NFC([0, (l+1) * (y0+z0) + y2])[1] - newax = fig.add_axes([left, bottom, right - left, up - bottom]) - newax.imshow(im) - newax.axis('off') - - if in_vars != None: - n = self.width_in[0] - for i in range(n): - if isinstance(in_vars[i], sympy.Expr): - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), -0.1, f'${latex(in_vars[i])}$', fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') - else: - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), -0.1, in_vars[i], fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') - - - - if out_vars != None: - n = self.width_in[-1] - for i in range(n): - if isinstance(out_vars[i], sympy.Expr): - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), (y0+z0) * (len(self.width) - 1) + 0.15, f'${latex(out_vars[i])}$', fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') - else: - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), (y0+z0) * (len(self.width) - 1) + 0.15, out_vars[i], fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') - - if title != None: - plt.gcf().get_axes()[0].text(0.5, (y0+z0) * (len(self.width) - 1) + 0.3, title, fontsize=40 * scale, horizontalalignment='center', verticalalignment='center') - - - def reg(self, reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff): - ''' - Get regularization - - Args: - ----- - reg_metric : the regularization metric - 'edge_forward_spline_n', 'edge_forward_spline_u', 'edge_forward_sum', 'edge_backward', 'node_backward' - lamb_l1 : float - l1 penalty strength - lamb_entropy : float - entropy penalty strength - lamb_coef : float - coefficient penalty strength - lamb_coefdiff : float - coefficient smoothness strength - - Returns: - -------- - reg_ : torch.float - - Example - ------- - >>> model = KAN(width=[2,3,1], grid=5, k=3, noise_scale=1.) - >>> x = torch.rand(100,2) - >>> model.get_act(x) - >>> model.reg('edge_forward_spline_n', 1.0, 2.0, 1.0, 1.0) - ''' - if reg_metric == 'edge_forward_spline_n': - acts_scale = self.acts_scale_spline - - elif reg_metric == 'edge_forward_sum': - acts_scale = self.acts_scale - - elif reg_metric == 'edge_forward_spline_u': - acts_scale = self.edge_actscale - - elif reg_metric == 'edge_backward': - acts_scale = self.edge_scores - - elif reg_metric == 'node_backward': - acts_scale = self.node_attribute_scores - - else: - raise Exception(f'reg_metric = {reg_metric} not recognized!') - - reg_ = 0. - for i in range(len(acts_scale)): - vec = acts_scale[i] - - l1 = torch.sum(vec) - p_row = vec / (torch.sum(vec, dim=1, keepdim=True) + 1) - p_col = vec / (torch.sum(vec, dim=0, keepdim=True) + 1) - entropy_row = - torch.mean(torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1)) - entropy_col = - torch.mean(torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0)) - reg_ += lamb_l1 * l1 + lamb_entropy * (entropy_row + entropy_col) # both l1 and entropy - - # regularize coefficient to encourage spline to be zero - for i in range(len(self.act_fun)): - coeff_l1 = torch.sum(torch.mean(torch.abs(self.act_fun[i].coef), dim=1)) - coeff_diff_l1 = torch.sum(torch.mean(torch.abs(torch.diff(self.act_fun[i].coef)), dim=1)) - reg_ += lamb_coef * coeff_l1 + lamb_coefdiff * coeff_diff_l1 - - return reg_ - - def get_reg(self, reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff): - ''' - Get regularization. This seems unnecessary but in case a class wants to inherit this, it may want to rewrite get_reg, but not reg. - ''' - return self.reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) - - def disable_symbolic_in_fit(self, lamb): - ''' - during fitting, disable symbolic if either is true (lamb = 0, none of symbolic functions is active) - ''' - old_save_act = self.save_act - if lamb == 0.: - self.save_act = False - - # skip symbolic if no symbolic is turned on - depth = len(self.symbolic_fun) - no_symbolic = True - for l in range(depth): - no_symbolic *= torch.sum(torch.abs(self.symbolic_fun[l].mask)) == 0 - - old_symbolic_enabled = self.symbolic_enabled - - if no_symbolic: - self.symbolic_enabled = False - - return old_save_act, old_symbolic_enabled - - def get_params(self): - ''' - Get parameters - ''' - return self.parameters() - - - def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., lamb_coef=0., lamb_coefdiff=0., update_grid=True, grid_update_num=10, loss_fn=None, lr=1.,start_grid_update_step=-1, stop_grid_update_step=50, batch=-1, - metrics=None, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', singularity_avoiding=False, y_th=1000., reg_metric='edge_forward_spline_n', display_metrics=None): - ''' - training - - Args: - ----- - dataset : dic - contains dataset['train_input'], dataset['train_label'], dataset['test_input'], dataset['test_label'] - opt : str - "LBFGS" or "Adam" - steps : int - training steps - log : int - logging frequency - lamb : float - overall penalty strength - lamb_l1 : float - l1 penalty strength - lamb_entropy : float - entropy penalty strength - lamb_coef : float - coefficient magnitude penalty strength - lamb_coefdiff : float - difference of nearby coefficits (smoothness) penalty strength - update_grid : bool - If True, update grid regularly before stop_grid_update_step - grid_update_num : int - the number of grid updates before stop_grid_update_step - start_grid_update_step : int - no grid updates before this training step - stop_grid_update_step : int - no grid updates after this training step - loss_fn : function - loss function - lr : float - learning rate - batch : int - batch size, if -1 then full. - save_fig_freq : int - save figure every (save_fig_freq) steps - singularity_avoiding : bool - indicate whether to avoid singularity for the symbolic part - y_th : float - singularity threshold (anything above the threshold is considered singular and is softened in some ways) - reg_metric : str - regularization metric. Choose from {'edge_forward_spline_n', 'edge_forward_spline_u', 'edge_forward_sum', 'edge_backward', 'node_backward'} - metrics : a list of metrics (as functions) - the metrics to be computed in training - display_metrics : a list of functions - the metric to be displayed in tqdm progress bar - - Returns: - -------- - results : dic - results['train_loss'], 1D array of training losses (RMSE) - results['test_loss'], 1D array of test losses (RMSE) - results['reg'], 1D array of regularization - other metrics specified in metrics - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=2) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.plot() - # Most examples in toturals involve the fit() method. Please check them for useness. - ''' - - if lamb > 0. and not self.save_act: - print('setting lamb=0. If you want to set lamb > 0, set self.save_act=True') - - old_save_act, old_symbolic_enabled = self.disable_symbolic_in_fit(lamb) - - pbar = tqdm(range(steps), desc='description', ncols=100) - - if loss_fn == None: - loss_fn = loss_fn_eval = lambda x, y: torch.mean((x - y) ** 2) - else: - loss_fn = loss_fn_eval = loss_fn - - grid_update_freq = int(stop_grid_update_step / grid_update_num) - - if opt == "Adam": - optimizer = torch.optim.Adam(self.get_params(), lr=lr) - elif opt == "LBFGS": - optimizer = LBFGS(self.get_params(), lr=lr, history_size=10, line_search_fn="strong_wolfe", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32) - - results = {} - results['train_loss'] = [] - results['test_loss'] = [] - results['reg'] = [] - if metrics != None: - for i in range(len(metrics)): - results[metrics[i].__name__] = [] - - if batch == -1 or batch > dataset['train_input'].shape[0]: - batch_size = dataset['train_input'].shape[0] - batch_size_test = dataset['test_input'].shape[0] - else: - batch_size = batch - batch_size_test = batch - - global train_loss, reg_ - - def closure(): - global train_loss, reg_ - optimizer.zero_grad() - pred = self.forward(dataset['train_input'][train_id], singularity_avoiding=singularity_avoiding, y_th=y_th) - train_loss = loss_fn(pred, dataset['train_label'][train_id]) - if self.save_act: - if reg_metric == 'edge_backward': - self.attribute() - if reg_metric == 'node_backward': - self.node_attribute() - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) - else: - reg_ = torch.tensor(0.) - objective = train_loss + lamb * reg_ - objective.backward() - return objective - - if save_fig: - if not os.path.exists(img_folder): - os.makedirs(img_folder) - - for _ in pbar: - - if _ == steps-1 and old_save_act: - self.save_act = True - - if save_fig and _ % save_fig_freq == 0: - save_act = self.save_act - self.save_act = True - - train_id = np.random.choice(dataset['train_input'].shape[0], batch_size, replace=False) - test_id = np.random.choice(dataset['test_input'].shape[0], batch_size_test, replace=False) - - if _ % grid_update_freq == 0 and _ < stop_grid_update_step and update_grid and _ >= start_grid_update_step: - self.update_grid(dataset['train_input'][train_id]) - - if opt == "LBFGS": - optimizer.step(closure) - - if opt == "Adam": - pred = self.forward(dataset['train_input'][train_id], singularity_avoiding=singularity_avoiding, y_th=y_th) - train_loss = loss_fn(pred, dataset['train_label'][train_id]) - if self.save_act: - if reg_metric == 'edge_backward': - self.attribute() - if reg_metric == 'node_backward': - self.node_attribute() - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) - else: - reg_ = torch.tensor(0.) - loss = train_loss + lamb * reg_ - optimizer.zero_grad() - loss.backward() - optimizer.step() - - test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id]), dataset['test_label'][test_id]) - - - if metrics != None: - for i in range(len(metrics)): - results[metrics[i].__name__].append(metrics[i]().item()) - - results['train_loss'].append(torch.sqrt(train_loss).cpu().detach().numpy()) - results['test_loss'].append(torch.sqrt(test_loss).cpu().detach().numpy()) - results['reg'].append(reg_.cpu().detach().numpy()) - - if _ % log == 0: - if display_metrics == None: - pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(), reg_.cpu().detach().numpy())) - else: - string = '' - data = () - for metric in display_metrics: - string += f' {metric}: %.2e |' - try: - results[metric] - except: - raise Exception(f'{metric} not recognized') - data += (results[metric][-1],) - pbar.set_description(string % data) - - - if save_fig and _ % save_fig_freq == 0: - self.plot(folder=img_folder, in_vars=in_vars, out_vars=out_vars, title="Step {}".format(_), beta=beta) - plt.savefig(img_folder + '/' + str(_) + '.jpg', bbox_inches='tight', dpi=200) - plt.close() - self.save_act = save_act - - self.log_history('fit') - # revert back to original state - self.symbolic_enabled = old_symbolic_enabled - return results - - def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_history=True): - ''' - pruning nodes - - Args: - ----- - threshold : float - if the attribution score of a neuron is below the threshold, it is considered dead and will be removed - mode : str - 'auto' or 'manual'. with 'auto', nodes are automatically pruned using threshold. with 'manual', active_neurons_id should be passed in. - - Returns: - -------- - pruned network : MultKAN - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=2) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model = model.prune_node() - >>> model.plot() - ''' - if self.acts == None: - self.get_act() - - mask_up = [torch.ones(self.width_in[0], device=self.device)] - mask_down = [] - active_neurons_up = [list(range(self.width_in[0]))] - active_neurons_down = [] - num_sums = [] - num_mults = [] - mult_arities = [[]] - - if active_neurons_id != None: - mode = "manual" - - for i in range(len(self.acts_scale) - 1): - - mult_arity = [] - - if mode == "auto": - self.attribute() - overall_important_up = self.node_scores[i+1] > threshold - - elif mode == "manual": - overall_important_up = torch.zeros(self.width_in[i + 1], dtype=torch.bool, device=self.device) - overall_important_up[active_neurons_id[i]] = True - - - num_sum = torch.sum(overall_important_up[:self.width[i+1][0]]) - num_mult = torch.sum(overall_important_up[self.width[i+1][0]:]) - if self.mult_homo == True: - overall_important_down = torch.cat([overall_important_up[:self.width[i+1][0]], (overall_important_up[self.width[i+1][0]:][None,:].expand(self.mult_arity,-1)).T.reshape(-1,)], dim=0) - else: - overall_important_down = overall_important_up[:self.width[i+1][0]] - for j in range(overall_important_up[self.width[i+1][0]:].shape[0]): - active_bool = overall_important_up[self.width[i+1][0]+j] - arity = self.mult_arity[i+1][j] - overall_important_down = torch.cat([overall_important_down, torch.tensor([active_bool]*arity).to(self.device)]) - if active_bool: - mult_arity.append(arity) - - num_sums.append(num_sum.item()) - num_mults.append(num_mult.item()) - - mask_up.append(overall_important_up.float()) - mask_down.append(overall_important_down.float()) - - active_neurons_up.append(torch.where(overall_important_up == True)[0]) - active_neurons_down.append(torch.where(overall_important_down == True)[0]) - - mult_arities.append(mult_arity) - - active_neurons_down.append(list(range(self.width_out[-1]))) - mask_down.append(torch.ones(self.width_out[-1], device=self.device)) - - if self.mult_homo == False: - mult_arities.append(self.mult_arity[-1]) - - self.mask_up = mask_up - self.mask_down = mask_down - - # update act_fun[l].mask up - for l in range(len(self.acts_scale) - 1): - for i in range(self.width_in[l + 1]): - if i not in active_neurons_up[l + 1]: - self.remove_node(l + 1, i, mode='up',log_history=False) - - for i in range(self.width_out[l + 1]): - if i not in active_neurons_down[l]: - self.remove_node(l + 1, i, mode='down',log_history=False) - - model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun_name, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round).to(self.device) - model2.load_state_dict(self.state_dict()) - - width_new = [self.width[0]] - - for i in range(len(self.acts_scale)): - - if i < len(self.acts_scale) - 1: - num_sum = num_sums[i] - num_mult = num_mults[i] - model2.node_bias[i].data = model2.node_bias[i].data[active_neurons_up[i+1]] - model2.node_scale[i].data = model2.node_scale[i].data[active_neurons_up[i+1]] - model2.subnode_bias[i].data = model2.subnode_bias[i].data[active_neurons_down[i]] - model2.subnode_scale[i].data = model2.subnode_scale[i].data[active_neurons_down[i]] - model2.width[i+1] = [num_sum, num_mult] - - model2.act_fun[i].out_dim_sum = num_sum - model2.act_fun[i].out_dim_mult = num_mult - - model2.symbolic_fun[i].out_dim_sum = num_sum - model2.symbolic_fun[i].out_dim_mult = num_mult - - width_new.append([num_sum, num_mult]) - - model2.act_fun[i] = model2.act_fun[i].get_subset(active_neurons_up[i], active_neurons_down[i]) - model2.symbolic_fun[i] = self.symbolic_fun[i].get_subset(active_neurons_up[i], active_neurons_down[i]) - - model2.cache_data = self.cache_data - model2.acts = None - - width_new.append(self.width[-1]) - model2.width = width_new - - if self.mult_homo == False: - model2.mult_arity = mult_arities - - if log_history: - self.log_history('prune_node') - model2.state_id += 1 - - return model2 - - def prune_edge(self, threshold=3e-2, log_history=True): - ''' - pruning edges - - Args: - ----- - threshold : float - if the attribution score of an edge is below the threshold, it is considered dead and will be set to zero. - - Returns: - -------- - pruned network : MultKAN - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=2) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model = model.prune_edge() - >>> model.plot() - ''' - if self.acts == None: - self.get_act() - - for i in range(len(self.width)-1): - #self.act_fun[i].mask.data = ((self.acts_scale[i] > threshold).permute(1,0)).float() - old_mask = self.act_fun[i].mask.data - self.act_fun[i].mask.data = ((self.edge_scores[i] > threshold).permute(1,0)*old_mask).float() - - if log_history: - self.log_history('fix_symbolic') - - def prune(self, node_th=1e-2, edge_th=3e-2): - ''' - prune (both nodes and edges) - - Args: - ----- - node_th : float - if the attribution score of a node is below node_th, it is considered dead and will be set to zero. - edge_th : float - if the attribution score of an edge is below node_th, it is considered dead and will be set to zero. - - Returns: - -------- - pruned network : MultKAN - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=2) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model = model.prune() - >>> model.plot() - ''' - if self.acts == None: - self.get_act() - - self = self.prune_node(node_th, log_history=False) - #self.prune_node(node_th, log_history=False) - self.forward(self.cache_data) - self.attribute() - self.prune_edge(edge_th, log_history=False) - self.log_history('prune') - return self - - def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True): - ''' - prune inputs - - Args: - ----- - threshold : float - if the attribution score of the input feature is below threshold, it is considered irrelevant. - active_inputs : None or list - if a list is passed, the manual mode will disregard attribution score and prune as instructed. - - Returns: - -------- - pruned network : MultKAN - - Example1 - -------- - >>> # automatic - >>> from kan import * - >>> model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: 1 * x[:,[0]]**2 + 0.3 * x[:,[1]]**2 + 0.0 * x[:,[2]]**2 - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.plot() - >>> model = model.prune_input() - >>> model.plot() - - Example2 - -------- - >>> # automatic - >>> from kan import * - >>> model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: 1 * x[:,[0]]**2 + 0.3 * x[:,[1]]**2 + 0.0 * x[:,[2]]**2 - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.plot() - >>> model = model.prune_input(active_inputs=[0,1]) - >>> model.plot() - ''' - if active_inputs == None: - self.attribute() - input_score = self.node_scores[0] - input_mask = input_score > threshold - print('keep:', input_mask.tolist()) - input_id = torch.where(input_mask==True)[0] - - else: - input_id = torch.tensor(active_inputs, dtype=torch.long).to(self.device) - - model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round).to(self.device) - model2.load_state_dict(self.state_dict()) - - model2.act_fun[0] = model2.act_fun[0].get_subset(input_id, torch.arange(self.width_out[1])) - model2.symbolic_fun[0] = self.symbolic_fun[0].get_subset(input_id, torch.arange(self.width_out[1])) - - model2.cache_data = self.cache_data - model2.acts = None - - model2.width[0] = [len(input_id), 0] - model2.input_id = input_id - - if log_history: - self.log_history('prune_input') - model2.state_id += 1 - - return model2 - - def remove_edge(self, l, i, j, log_history=True): - ''' - remove activtion phi(l,i,j) (set its mask to zero) - ''' - self.act_fun[l].mask[i][j] = 0. - if log_history: - self.log_history('remove_edge') - - def remove_node(self, l ,i, mode='all', log_history=True): - ''' - remove neuron (l,i) (set the masks of all incoming and outgoing activation functions to zero) - ''' - if mode == 'down': - self.act_fun[l - 1].mask[:, i] = 0. - self.symbolic_fun[l - 1].mask[i, :] *= 0. - - elif mode == 'up': - self.act_fun[l].mask[i, :] = 0. - self.symbolic_fun[l].mask[:, i] *= 0. - - else: - self.remove_node(l, i, mode='up') - self.remove_node(l, i, mode='down') - - if log_history: - self.log_history('remove_node') - - - def attribute(self, l=None, i=None, out_score=None, plot=True): - ''' - get attribution scores - - Args: - ----- - l : None or int - layer index - i : None or int - neuron index - out_score : None or 1D torch.float - specify output scores - plot : bool - when plot = True, display the bar show - - Returns: - -------- - attribution scores - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: 1 * x[:,[0]]**2 + 0.3 * x[:,[1]]**2 + 0.0 * x[:,[2]]**2 - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.attribute() - >>> model.feature_score - ''' - # output (out_dim, in_dim) - - if l != None: - self.attribute() - out_score = self.node_scores[l] - - if self.acts == None: - self.get_act() - - def score_node2subnode(node_score, width, mult_arity, out_dim): - - assert np.sum(width) == node_score.shape[1] - if isinstance(mult_arity, int): - n_subnode = width[0] + mult_arity * width[1] - else: - n_subnode = width[0] + int(np.sum(mult_arity)) - - #subnode_score_leaf = torch.zeros(out_dim, n_subnode).requires_grad_(True) - #subnode_score = subnode_score_leaf.clone() - #subnode_score[:,:width[0]] = node_score[:,:width[0]] - subnode_score = node_score[:,:width[0]] - if isinstance(mult_arity, int): - #subnode_score[:,width[0]:] = node_score[:,width[0]:][:,:,None].expand(out_dim, node_score[width[0]:].shape[0], mult_arity).reshape(out_dim,-1) - subnode_score = torch.cat([subnode_score, node_score[:,width[0]:][:,:,None].expand(out_dim, node_score[:,width[0]:].shape[1], mult_arity).reshape(out_dim,-1)], dim=1) - else: - acml = width[0] - for i in range(len(mult_arity)): - #subnode_score[:, acml:acml+mult_arity[i]] = node_score[:, width[0]+i] - subnode_score = torch.cat([subnode_score, node_score[:, width[0]+i].expand(out_dim, mult_arity[i])], dim=1) - acml += mult_arity[i] - return subnode_score - - - node_scores = [] - subnode_scores = [] - edge_scores = [] - - l_query = l - if l == None: - l_end = self.depth - else: - l_end = l - - # back propagate from the queried layer - out_dim = self.width_in[l_end] - if out_score == None: - node_score = torch.eye(out_dim).requires_grad_(True) - else: - node_score = torch.diag(out_score).requires_grad_(True) - node_scores.append(node_score) - - device = self.act_fun[0].grid.device - - for l in range(l_end,0,-1): - - # node to subnode - if isinstance(self.mult_arity, int): - subnode_score = score_node2subnode(node_score, self.width[l], self.mult_arity, out_dim=out_dim) - else: - mult_arity = self.mult_arity[l] - #subnode_score = score_node2subnode(node_score, self.width[l], mult_arity) - subnode_score = score_node2subnode(node_score, self.width[l], mult_arity, out_dim=out_dim) - - subnode_scores.append(subnode_score) - # subnode to edge - #print(self.edge_actscale[l-1].device, subnode_score.device, self.subnode_actscale[l-1].device) - edge_score = torch.einsum('ij,ki,i->kij', self.edge_actscale[l-1], subnode_score.to(device), 1/(self.subnode_actscale[l-1]+1e-4)) - edge_scores.append(edge_score) - - # edge to node - node_score = torch.sum(edge_score, dim=1) - node_scores.append(node_score) - - self.node_scores_all = list(reversed(node_scores)) - self.edge_scores_all = list(reversed(edge_scores)) - self.subnode_scores_all = list(reversed(subnode_scores)) - - self.node_scores = [torch.mean(l, dim=0) for l in self.node_scores_all] - self.edge_scores = [torch.mean(l, dim=0) for l in self.edge_scores_all] - self.subnode_scores = [torch.mean(l, dim=0) for l in self.subnode_scores_all] - - # return - if l_query != None: - if i == None: - return self.node_scores_all[0] - else: - - # plot - if plot: - in_dim = self.width_in[0] - plt.figure(figsize=(1*in_dim, 3)) - plt.bar(range(in_dim),self.node_scores_all[0][i].cpu().detach().numpy()) - plt.xticks(range(in_dim)); - - return self.node_scores_all[0][i] - - def node_attribute(self): - self.node_attribute_scores = [] - for l in range(1, self.depth+1): - node_attr = self.attribute(l) - self.node_attribute_scores.append(node_attr) - - def feature_interaction(self, l, neuron_th = 1e-2, feature_th = 1e-2): - ''' - get feature interaction - - Args: - ----- - l : int - layer index - neuron_th : float - threshold to determine whether a neuron is active - feature_th : float - threshold to determine whether a feature is active - - Returns: - -------- - dictionary - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.3, seed=2) - >>> f = lambda x: 1 * x[:,[0]]**2 + 0.3 * x[:,[1]]**2 + 0.0 * x[:,[2]]**2 - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.attribute() - >>> model.feature_interaction(1) - ''' - dic = {} - width = self.width_in[l] - - for i in range(width): - score = self.attribute(l,i,plot=False) - - if torch.max(score) > neuron_th: - features = tuple(torch.where(score > torch.max(score) * feature_th)[0].detach().numpy()) - if features in dic.keys(): - dic[features] += 1 - else: - dic[features] = 1 - - return dic - - def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=None, topk=5, verbose=True, r2_loss_fun=lambda x: np.log2(1+1e-5-x), c_loss_fun=lambda x: x, weight_simple = 0.8): - ''' - suggest symbolic function - - Args: - ----- - l : int - layer index - i : int - neuron index in layer l - j : int - neuron index in layer j - a_range : tuple - search range of a - b_range : tuple - search range of b - lib : list of str - library of candidate symbolic functions - topk : int - the number of top functions displayed - verbose : bool - if verbose = True, print more information - r2_loss_fun : functoon - function : r2 -> "bits" - c_loss_fun : fun - function : c -> 'bits' - weight_simple : float - the simplifty weight: the higher, more prefer simplicity over performance - - - Returns: - -------- - best_name (str), best_fun (function), best_r2 (float), best_c (float) - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,1,1], grid=5, k=3, noise_scale=0.0, seed=0) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.suggest_symbolic(0,1,0) - ''' - r2s = [] - cs = [] - - if lib == None: - symbolic_lib = SYMBOLIC_LIB - else: - symbolic_lib = {} - for item in lib: - symbolic_lib[item] = SYMBOLIC_LIB[item] - - # getting r2 and complexities - for (name, content) in symbolic_lib.items(): - r2 = self.fix_symbolic(l, i, j, name, a_range=a_range, b_range=b_range, verbose=False, log_history=False) - if r2 == -1e8: # zero function - r2s.append(-1e8) - else: - r2s.append(r2.item()) - self.unfix_symbolic(l, i, j, log_history=False) - c = content[2] - cs.append(c) - - r2s = np.array(r2s) - cs = np.array(cs) - r2_loss = r2_loss_fun(r2s).astype('float') - cs_loss = c_loss_fun(cs) - - loss = weight_simple * cs_loss + (1-weight_simple) * r2_loss - - sorted_ids = np.argsort(loss)[:topk] - r2s = r2s[sorted_ids][:topk] - cs = cs[sorted_ids][:topk] - r2_loss = r2_loss[sorted_ids][:topk] - cs_loss = cs_loss[sorted_ids][:topk] - loss = loss[sorted_ids][:topk] - - topk = np.minimum(topk, len(symbolic_lib)) - - if verbose == True: - # print results in a dataframe - results = {} - results['function'] = [list(symbolic_lib.items())[sorted_ids[i]][0] for i in range(topk)] - results['fitting r2'] = r2s[:topk] - results['r2 loss'] = r2_loss[:topk] - results['complexity'] = cs[:topk] - results['complexity loss'] = cs_loss[:topk] - results['total loss'] = loss[:topk] - - df = pd.DataFrame(results) - print(df) - - best_name = list(symbolic_lib.items())[sorted_ids[0]][0] - best_fun = list(symbolic_lib.items())[sorted_ids[0]][1] - best_r2 = r2s[0] - best_c = cs[0] - - return best_name, best_fun, best_r2, best_c; - - def auto_symbolic(self, a_range=(-10, 10), b_range=(-10, 10), lib=None, verbose=1, weight_simple = 0.8, r2_threshold=0.0): - ''' - automatic symbolic regression for all edges - - Args: - ----- - a_range : tuple - search range of a - b_range : tuple - search range of b - lib : list of str - library of candidate symbolic functions - verbose : int - larger verbosity => more verbosity - weight_simple : float - a weight that prioritizies simplicity (low complexity) over performance (high r2) - set to 0.0 to ignore complexity - r2_threshold : float - If r2 is below this threshold, the edge will not be fixed with any symbolic function - set to 0.0 to ignore this threshold - Returns: - -------- - None - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,1,1], grid=5, k=3, noise_scale=0.0, seed=0) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.auto_symbolic() - ''' - for l in range(len(self.width_in) - 1): - for i in range(self.width_in[l]): - for j in range(self.width_out[l + 1]): - if self.symbolic_fun[l].mask[j, i] > 0. and self.act_fun[l].mask[i][j] == 0.: - print(f'skipping ({l},{i},{j}) since already symbolic') - elif self.symbolic_fun[l].mask[j, i] == 0. and self.act_fun[l].mask[i][j] == 0.: - self.fix_symbolic(l, i, j, '0', verbose=verbose > 1, log_history=False) - print(f'fixing ({l},{i},{j}) with 0') - else: - name, fun, r2, c = self.suggest_symbolic(l, i, j, a_range=a_range, b_range=b_range, lib=lib, verbose=False, weight_simple=weight_simple) - if r2 >= r2_threshold: - self.fix_symbolic(l, i, j, name, verbose=verbose > 1, log_history=False) - if verbose >= 1: - print(f'fixing ({l},{i},{j}) with {name}, r2={r2}, c={c}') - else: - print(f'For ({l},{i},{j}) the best fit was {name}, but r^2 = {r2} and this is lower than {r2_threshold}. This edge was omitted, keep training or try a different threshold.') - - self.log_history('auto_symbolic') - - def symbolic_formula(self, var=None, normalizer=None, output_normalizer = None): - ''' - get symbolic formula - - Args: - ----- - var : None or a list of sympy expression - input variables - normalizer : [mean, std] - output_normalizer : [mean, std] - - Returns: - -------- - None - - Example - ------- - >>> from kan import * - >>> model = KAN(width=[2,1,1], grid=5, k=3, noise_scale=0.0, seed=0) - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=3) - >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); - >>> model.auto_symbolic() - >>> model.symbolic_formula()[0][0] - ''' - - symbolic_acts = [] - symbolic_acts_premult = [] - x = [] - - def ex_round(ex1, n_digit): - ex2 = ex1 - for a in sympy.preorder_traversal(ex1): - if isinstance(a, sympy.Float): - ex2 = ex2.subs(a, round(a, n_digit)) - return ex2 - - # define variables - if var == None: - for ii in range(1, self.width[0][0] + 1): - exec(f"x{ii} = sympy.Symbol('x_{ii}')") - exec(f"x.append(x{ii})") - elif isinstance(var[0], sympy.Expr): - x = var - else: - x = [sympy.symbols(var_) for var_ in var] - - x0 = x - - if normalizer != None: - mean = normalizer[0] - std = normalizer[1] - x = [(x[i] - mean[i]) / std[i] for i in range(len(x))] - - symbolic_acts.append(x) - - for l in range(len(self.width_in) - 1): - num_sum = self.width[l + 1][0] - num_mult = self.width[l + 1][1] - y = [] - for j in range(self.width_out[l + 1]): - yj = 0. - for i in range(self.width_in[l]): - a, b, c, d = self.symbolic_fun[l].affine[j, i] - sympy_fun = self.symbolic_fun[l].funs_sympy[j][i] - try: - yj += c * sympy_fun(a * x[i] + b) + d - except: - print('make sure all activations need to be converted to symbolic formulas first!') - return - yj = self.subnode_scale[l][j] * yj + self.subnode_bias[l][j] - if simplify == True: - y.append(sympy.simplify(yj)) - else: - y.append(yj) - - symbolic_acts_premult.append(y) - - mult = [] - for k in range(num_mult): - if isinstance(self.mult_arity, int): - mult_arity = self.mult_arity - else: - mult_arity = self.mult_arity[l+1][k] - for i in range(mult_arity-1): - if i == 0: - mult_k = y[num_sum+2*k] * y[num_sum+2*k+1] - else: - mult_k = mult_k * y[num_sum+2*k+i+1] - mult.append(mult_k) - - y = y[:num_sum] + mult - - for j in range(self.width_in[l+1]): - y[j] = self.node_scale[l][j] * y[j] + self.node_bias[l][j] - - x = y - symbolic_acts.append(x) - - if output_normalizer != None: - output_layer = symbolic_acts[-1] - means = output_normalizer[0] - stds = output_normalizer[1] - - assert len(output_layer) == len(means), 'output_normalizer does not match the output layer' - assert len(output_layer) == len(stds), 'output_normalizer does not match the output layer' - - output_layer = [(output_layer[i] * stds[i] + means[i]) for i in range(len(output_layer))] - symbolic_acts[-1] = output_layer - - - self.symbolic_acts = [[symbolic_acts[l][i] for i in range(len(symbolic_acts[l]))] for l in range(len(symbolic_acts))] - self.symbolic_acts_premult = [[symbolic_acts_premult[l][i] for i in range(len(symbolic_acts_premult[l]))] for l in range(len(symbolic_acts_premult))] - - out_dim = len(symbolic_acts[-1]) - #return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 - - if simplify: - return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 - else: - return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 - - - def expand_depth(self): - ''' - expand network depth, add an indentity layer to the end. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - - Args: - ----- - var : None or a list of sympy expression - input variables - normalizer : [mean, std] - output_normalizer : [mean, std] - - Returns: - -------- - None - ''' - self.depth += 1 - - # add kanlayer, set mask to zero - dim_out = self.width_in[-1] - layer = KANLayer(dim_out, dim_out, num=self.grid, k=self.k) - layer.mask *= 0. - self.act_fun.append(layer) - - self.width.append([dim_out, 0]) - self.mult_arity.append([]) - - # add symbolic_kanlayer set mask to one. fun = identity on diagonal and zero for off-diagonal - layer = Symbolic_KANLayer(dim_out, dim_out) - layer.mask += 1. - - for j in range(dim_out): - for i in range(dim_out): - if i == j: - layer.fix_symbolic(i,j,'x') - else: - layer.fix_symbolic(i,j,'0') - - self.symbolic_fun.append(layer) - - self.node_bias.append(torch.nn.Parameter(torch.zeros(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.node_scale.append(torch.nn.Parameter(torch.ones(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.subnode_bias.append(torch.nn.Parameter(torch.zeros(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.subnode_scale.append(torch.nn.Parameter(torch.ones(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - - def expand_width(self, layer_id, n_added_nodes, sum_bool=True, mult_arity=2): - ''' - expand network width. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - - Args: - ----- - layer_id : int - layer index - n_added_nodes : init - the number of added nodes - sum_bool : bool - if sum_bool == True, added nodes are addition nodes; otherwise multiplication nodes - mult_arity : init - multiplication arity (the number of numbers to be multiplied) - - Returns: - -------- - None - ''' - def _expand(layer_id, n_added_nodes, sum_bool=True, mult_arity=2, added_dim='out'): - l = layer_id - in_dim = self.symbolic_fun[l].in_dim - out_dim = self.symbolic_fun[l].out_dim - if sum_bool: - - if added_dim == 'out': - new = Symbolic_KANLayer(in_dim, out_dim + n_added_nodes) - old = self.symbolic_fun[l] - in_id = np.arange(in_dim) - out_id = np.arange(out_dim + n_added_nodes) - - for j in out_id: - for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. - - for j in out_id: - for i in in_id: - if j > n_added_nodes-1: - new.funs[j][i] = old.funs[j-n_added_nodes][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j-n_added_nodes][i] - new.funs_sympy[j][i] = old.funs_sympy[j-n_added_nodes][i] - new.funs_name[j][i] = old.funs_name[j-n_added_nodes][i] - new.affine.data[j][i] = old.affine.data[j-n_added_nodes][i] - - self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim, out_dim + n_added_nodes, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - self.node_scale[l].data = torch.cat([torch.ones(n_added_nodes, device=self.device), self.node_scale[l].data]) - self.node_bias[l].data = torch.cat([torch.zeros(n_added_nodes, device=self.device), self.node_bias[l].data]) - self.subnode_scale[l].data = torch.cat([torch.ones(n_added_nodes, device=self.device), self.subnode_scale[l].data]) - self.subnode_bias[l].data = torch.cat([torch.zeros(n_added_nodes, device=self.device), self.subnode_bias[l].data]) - - - - if added_dim == 'in': - new = Symbolic_KANLayer(in_dim + n_added_nodes, out_dim) - old = self.symbolic_fun[l] - in_id = np.arange(in_dim + n_added_nodes) - out_id = np.arange(out_dim) - - for j in out_id: - for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. - - for j in out_id: - for i in in_id: - if i > n_added_nodes-1: - new.funs[j][i] = old.funs[j][i-n_added_nodes] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i-n_added_nodes] - new.funs_sympy[j][i] = old.funs_sympy[j][i-n_added_nodes] - new.funs_name[j][i] = old.funs_name[j][i-n_added_nodes] - new.affine.data[j][i] = old.affine.data[j][i-n_added_nodes] - - self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - - else: - - if isinstance(mult_arity, int): - mult_arity = [mult_arity] * n_added_nodes - - if added_dim == 'out': - n_added_subnodes = np.sum(mult_arity) - new = Symbolic_KANLayer(in_dim, out_dim + n_added_subnodes) - old = self.symbolic_fun[l] - in_id = np.arange(in_dim) - out_id = np.arange(out_dim + n_added_nodes) - - for j in out_id: - for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. - - for j in out_id: - for i in in_id: - if j < out_dim: - new.funs[j][i] = old.funs[j][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i] - new.funs_sympy[j][i] = old.funs_sympy[j][i] - new.funs_name[j][i] = old.funs_name[j][i] - new.affine.data[j][i] = old.affine.data[j][i] - - self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim, out_dim + n_added_subnodes, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - self.node_scale[l].data = torch.cat([self.node_scale[l].data, torch.ones(n_added_nodes, device=self.device)]) - self.node_bias[l].data = torch.cat([self.node_bias[l].data, torch.zeros(n_added_nodes, device=self.device)]) - self.subnode_scale[l].data = torch.cat([self.subnode_scale[l].data, torch.ones(n_added_subnodes, device=self.device)]) - self.subnode_bias[l].data = torch.cat([self.subnode_bias[l].data, torch.zeros(n_added_subnodes, device=self.device)]) - - if added_dim == 'in': - new = Symbolic_KANLayer(in_dim + n_added_nodes, out_dim) - old = self.symbolic_fun[l] - in_id = np.arange(in_dim + n_added_nodes) - out_id = np.arange(out_dim) - - for j in out_id: - for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. - - for j in out_id: - for i in in_id: - if i < in_dim: - new.funs[j][i] = old.funs[j][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i] - new.funs_sympy[j][i] = old.funs_sympy[j][i] - new.funs_name[j][i] = old.funs_name[j][i] - new.affine.data[j][i] = old.affine.data[j][i] - - self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - _expand(layer_id-1, n_added_nodes, sum_bool, mult_arity, added_dim='out') - _expand(layer_id, n_added_nodes, sum_bool, mult_arity, added_dim='in') - if sum_bool: - self.width[layer_id][0] += n_added_nodes - else: - if isinstance(mult_arity, int): - mult_arity = [mult_arity] * n_added_nodes - - self.width[layer_id][1] += n_added_nodes - self.mult_arity[layer_id] += mult_arity - - def perturb(self, mag=1.0, mode='non-intrusive'): - ''' - preturb a network. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - - Args: - ----- - mag : float - perturbation magnitude - mode : str - pertubatation mode, choices = {'non-intrusive', 'all', 'minimal'} - - Returns: - -------- - None - ''' - perturb_bool = {} - - if mode == 'all': - perturb_bool['aa_a'] = True - perturb_bool['aa_i'] = True - perturb_bool['ai'] = True - perturb_bool['ia'] = True - perturb_bool['ii'] = True - elif mode == 'non-intrusive': - perturb_bool['aa_a'] = False - perturb_bool['aa_i'] = False - perturb_bool['ai'] = True - perturb_bool['ia'] = False - perturb_bool['ii'] = True - elif mode == 'minimal': - perturb_bool['aa_a'] = True - perturb_bool['aa_i'] = False - perturb_bool['ai'] = False - perturb_bool['ia'] = False - perturb_bool['ii'] = False - else: - raise Exception('mode not recognized, valid modes are \'all\', \'non-intrusive\', \'minimal\'.') - - for l in range(self.depth): - funs_name = self.symbolic_fun[l].funs_name - for j in range(self.width_out[l+1]): - for i in range(self.width_in[l]): - out_array = list(np.array(self.symbolic_fun[l].funs_name)[j]) - in_array = list(np.array(self.symbolic_fun[l].funs_name)[:,i]) - out_active = len([i for i, x in enumerate(out_array) if x != "0"]) > 0 - in_active = len([i for i, x in enumerate(in_array) if x != "0"]) > 0 - dic = {True: 'a', False: 'i'} - edge_type = dic[in_active] + dic[out_active] - - if l < self.depth - 1 or mode != 'non-intrusive': - - if edge_type == 'aa': - if self.symbolic_fun[l].funs_name[j][i] == '0': - edge_type += '_i' - else: - edge_type += '_a' - - if perturb_bool[edge_type]: - self.act_fun[l].mask.data[i][j] = mag - - if l == self.depth - 1 and mode == 'non-intrusive': - - self.act_fun[l].mask.data[i][j] = torch.tensor(1.) - self.act_fun[l].scale_base.data[i][j] = torch.tensor(0.) - self.act_fun[l].scale_sp.data[i][j] = torch.tensor(0.) - - self.get_act(self.cache_data) - - self.log_history('perturb') - - - def module(self, start_layer, chain): - ''' - specify network modules - - Args: - ----- - start_layer : int - the earliest layer of the module - chain : str - specify neurons in the module - - Returns: - -------- - None - ''' - #chain = '[-1]->[-1,-2]->[-1]->[-1]' - groups = chain.split('->') - n_total_layers = len(groups)//2 - #start_layer = 0 - - for l in range(n_total_layers): - current_layer = cl = start_layer + l - id_in = [int(i) for i in groups[2*l][1:-1].split(',')] - id_out = [int(i) for i in groups[2*l+1][1:-1].split(',')] - - in_dim = self.width_in[cl] - out_dim = self.width_out[cl+1] - id_in_other = list(set(range(in_dim)) - set(id_in)) - id_out_other = list(set(range(out_dim)) - set(id_out)) - self.act_fun[cl].mask.data[np.ix_(id_in_other,id_out)] = 0. - self.act_fun[cl].mask.data[np.ix_(id_in,id_out_other)] = 0. - self.symbolic_fun[cl].mask.data[np.ix_(id_out,id_in_other)] = 0. - self.symbolic_fun[cl].mask.data[np.ix_(id_out_other,id_in)] = 0. - - self.log_history('module') - - def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): - ''' - turn KAN into a tree - ''' - if x == None: - x = self.cache_data - plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test, verbose=verbose) - - - def speed(self, compile=False): - ''' - turn on KAN's speed mode - ''' - self.symbolic_enabled=False - self.save_act=False - self.auto_save=False - if compile == True: - return torch.compile(self) - else: - return self - - def get_act(self, x=None): - ''' - collect intermidate activations - ''' - if isinstance(x, dict): - x = x['train_input'] - if x == None: - if self.cache_data != None: - x = self.cache_data - else: - raise Exception("missing input data x") - save_act = self.save_act - self.save_act = True - self.forward(x) - self.save_act = save_act - - def get_fun(self, l, i, j): - ''' - get function (l,i,j) - ''' - inputs = self.spline_preacts[l][:,j,i].cpu().detach().numpy() - outputs = self.spline_postacts[l][:,j,i].cpu().detach().numpy() - # they are not ordered yet - rank = np.argsort(inputs) - inputs = inputs[rank] - outputs = outputs[rank] - plt.figure(figsize=(3,3)) - plt.plot(inputs, outputs, marker="o") - return inputs, outputs - - - def history(self, k='all'): - ''' - get history - ''' - with open(self.ckpt_path+'/history.txt', 'r') as f: - data = f.readlines() - n_line = len(data) - if k == 'all': - k = n_line - - data = data[-k:] - for line in data: - print(line[:-1]) - @property - def n_edge(self): - ''' - the number of active edges - ''' - depth = len(self.act_fun) - complexity = 0 - for l in range(depth): - complexity += torch.sum(self.act_fun[l].mask > 0.) - return complexity.item() - - def evaluate(self, dataset): - evaluation = {} - evaluation['test_loss'] = torch.sqrt(torch.mean((self.forward(dataset['test_input']) - dataset['test_label'])**2)).item() - evaluation['n_edge'] = self.n_edge - evaluation['n_grid'] = self.grid - # add other metrics (maybe accuracy) - return evaluation - - def swap(self, l, i1, i2, log_history=True): - - self.act_fun[l-1].swap(i1,i2,mode='out') - self.symbolic_fun[l-1].swap(i1,i2,mode='out') - self.act_fun[l].swap(i1,i2,mode='in') - self.symbolic_fun[l].swap(i1,i2,mode='in') - - def swap_(data, i1, i2): - data[i1], data[i2] = data[i2], data[i1] - - swap_(self.node_scale[l-1].data, i1, i2) - swap_(self.node_bias[l-1].data, i1, i2) - swap_(self.subnode_scale[l-1].data, i1, i2) - swap_(self.subnode_bias[l-1].data, i1, i2) - - if log_history: - self.log_history('swap') - - @property - def connection_cost(self): - - cc = 0. - for t in self.edge_scores: - - def get_coordinate(n): - return torch.linspace(0,1,steps=n+1, device=self.device)[:n] + 1/(2*n) - - in_dim = t.shape[0] - x_in = get_coordinate(in_dim) - - out_dim = t.shape[1] - x_out = get_coordinate(out_dim) - - dist = torch.abs(x_in[:,None] - x_out[None,:]) - cc += torch.sum(dist * t) - - return cc - - def auto_swap_l(self, l): - - num = self.width_in[1] - for i in range(num): - ccs = [] - for j in range(num): - self.swap(l,i,j,log_history=False) - self.get_act() - self.attribute() - cc = self.connection_cost.detach().clone() - ccs.append(cc) - self.swap(l,i,j,log_history=False) - j = torch.argmin(torch.tensor(ccs)) - self.swap(l,i,j,log_history=False) - - def auto_swap(self): - ''' - automatically swap neurons such as connection costs are minimized - ''' - depth = self.depth - for l in range(1, depth): - self.auto_swap_l(l) - - self.log_history('auto_swap') - -KAN = MultKAN diff --git a/kan/.ipynb_checkpoints/Symbolic_KANLayer-checkpoint.py b/kan/.ipynb_checkpoints/Symbolic_KANLayer-checkpoint.py deleted file mode 100644 index 51baf0af5..000000000 --- a/kan/.ipynb_checkpoints/Symbolic_KANLayer-checkpoint.py +++ /dev/null @@ -1,270 +0,0 @@ -import torch -import torch.nn as nn -import numpy as np -import sympy -from .utils import * - - - -class Symbolic_KANLayer(nn.Module): - ''' - KANLayer class - - Attributes: - ----------- - in_dim : int - input dimension - out_dim : int - output dimension - funs : 2D array of torch functions (or lambda functions) - symbolic functions (torch) - funs_avoid_singularity : 2D array of torch functions (or lambda functions) with singularity avoiding - funs_name : 2D arry of str - names of symbolic functions - funs_sympy : 2D array of sympy functions (or lambda functions) - symbolic functions (sympy) - affine : 3D array of floats - affine transformations of inputs and outputs - ''' - def __init__(self, in_dim=3, out_dim=2, device='cpu'): - ''' - initialize a Symbolic_KANLayer (activation functions are initialized to be identity functions) - - Args: - ----- - in_dim : int - input dimension - out_dim : int - output dimension - device : str - device - - Returns: - -------- - self - - Example - ------- - >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=3) - >>> len(sb.funs), len(sb.funs[0]) - ''' - super(Symbolic_KANLayer, self).__init__() - self.out_dim = out_dim - self.in_dim = in_dim - self.mask = torch.nn.Parameter(torch.zeros(out_dim, in_dim, device=device)).requires_grad_(False) - # torch - self.funs = [[lambda x: x*0. for i in range(self.in_dim)] for j in range(self.out_dim)] - self.funs_avoid_singularity = [[lambda x, y_th: ((), x*0.) for i in range(self.in_dim)] for j in range(self.out_dim)] - # name - self.funs_name = [['0' for i in range(self.in_dim)] for j in range(self.out_dim)] - # sympy - self.funs_sympy = [[lambda x: x*0. for i in range(self.in_dim)] for j in range(self.out_dim)] - ### make funs_name the only parameter, and make others as the properties of funs_name? - - self.affine = torch.nn.Parameter(torch.zeros(out_dim, in_dim, 4, device=device)) - # c*f(a*x+b)+d - - self.device = device - self.to(device) - - def to(self, device): - ''' - move to device - ''' - super(Symbolic_KANLayer, self).to(device) - self.device = device - return self - - def forward(self, x, singularity_avoiding=False, y_th=10.): - ''' - forward - - Args: - ----- - x : 2D array - inputs, shape (batch, input dimension) - singularity_avoiding : bool - if True, funs_avoid_singularity is used; if False, funs is used. - y_th : float - the singularity threshold - - Returns: - -------- - y : 2D array - outputs, shape (batch, output dimension) - postacts : 3D array - activations after activation functions but before being summed on nodes - - Example - ------- - >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=5) - >>> x = torch.normal(0,1,size=(100,3)) - >>> y, postacts = sb(x) - >>> y.shape, postacts.shape - (torch.Size([100, 5]), torch.Size([100, 5, 3])) - ''' - - batch = x.shape[0] - postacts = [] - - for i in range(self.in_dim): - postacts_ = [] - for j in range(self.out_dim): - if singularity_avoiding: - xij = self.affine[j,i,2]*self.funs_avoid_singularity[j][i](self.affine[j,i,0]*x[:,[i]]+self.affine[j,i,1], torch.tensor(y_th))[1]+self.affine[j,i,3] - else: - xij = self.affine[j,i,2]*self.funs[j][i](self.affine[j,i,0]*x[:,[i]]+self.affine[j,i,1])+self.affine[j,i,3] - postacts_.append(self.mask[j][i]*xij) - postacts.append(torch.stack(postacts_)) - - postacts = torch.stack(postacts) - postacts = postacts.permute(2,1,0,3)[:,:,:,0] - y = torch.sum(postacts, dim=2) - - return y, postacts - - - def get_subset(self, in_id, out_id): - ''' - get a smaller Symbolic_KANLayer from a larger Symbolic_KANLayer (used for pruning) - - Args: - ----- - in_id : list - id of selected input neurons - out_id : list - id of selected output neurons - - Returns: - -------- - spb : Symbolic_KANLayer - - Example - ------- - >>> sb_large = Symbolic_KANLayer(in_dim=10, out_dim=10) - >>> sb_small = sb_large.get_subset([0,9],[1,2,3]) - >>> sb_small.in_dim, sb_small.out_dim - ''' - sbb = Symbolic_KANLayer(self.in_dim, self.out_dim, device=self.device) - sbb.in_dim = len(in_id) - sbb.out_dim = len(out_id) - sbb.mask.data = self.mask.data[out_id][:,in_id] - sbb.funs = [[self.funs[j][i] for i in in_id] for j in out_id] - sbb.funs_avoid_singularity = [[self.funs_avoid_singularity[j][i] for i in in_id] for j in out_id] - sbb.funs_sympy = [[self.funs_sympy[j][i] for i in in_id] for j in out_id] - sbb.funs_name = [[self.funs_name[j][i] for i in in_id] for j in out_id] - sbb.affine.data = self.affine.data[out_id][:,in_id] - return sbb - - - def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-10,10), b_range=(-10,10), verbose=True): - ''' - fix an activation function to be symbolic - - Args: - ----- - i : int - the id of input neuron - j : int - the id of output neuron - fun_name : str - the name of the symbolic functions - x : 1D array - preactivations - y : 1D array - postactivations - a_range : tuple - sweeping range of a - b_range : tuple - sweeping range of a - verbose : bool - print more information if True - - Returns: - -------- - r2 (coefficient of determination) - - Example 1 - --------- - >>> # when x & y are not provided. Affine parameters are set to a = 1, b = 0, c = 1, d = 0 - >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=2) - >>> sb.fix_symbolic(2,1,'sin') - >>> print(sb.funs_name) - >>> print(sb.affine) - - Example 2 - --------- - >>> # when x & y are provided, fit_params() is called to find the best fit coefficients - >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=2) - >>> batch = 100 - >>> x = torch.linspace(-1,1,steps=batch) - >>> noises = torch.normal(0,1,(batch,)) * 0.02 - >>> y = 5.0*torch.sin(3.0*x + 2.0) + 0.7 + noises - >>> sb.fix_symbolic(2,1,'sin',x,y) - >>> print(sb.funs_name) - >>> print(sb.affine[1,2,:].data) - ''' - if isinstance(fun_name,str): - fun = SYMBOLIC_LIB[fun_name][0] - fun_sympy = SYMBOLIC_LIB[fun_name][1] - fun_avoid_singularity = SYMBOLIC_LIB[fun_name][3] - self.funs_sympy[j][i] = fun_sympy - self.funs_name[j][i] = fun_name - - if x == None or y == None: - #initialzie from just fun - self.funs[j][i] = fun - self.funs_avoid_singularity[j][i] = fun_avoid_singularity - if random == False: - self.affine.data[j][i] = torch.tensor([1.,0.,1.,0.]) - else: - self.affine.data[j][i] = torch.rand(4,) * 2 - 1 - return None - else: - #initialize from x & y and fun - params, r2 = fit_params(x,y,fun, a_range=a_range, b_range=b_range, verbose=verbose, device=self.device) - self.funs[j][i] = fun - self.funs_avoid_singularity[j][i] = fun_avoid_singularity - self.affine.data[j][i] = params - return r2 - else: - # if fun_name itself is a function - fun = fun_name - fun_sympy = fun_name - self.funs_sympy[j][i] = fun_sympy - self.funs_name[j][i] = "anonymous" - - self.funs[j][i] = fun - self.funs_avoid_singularity[j][i] = fun - if random == False: - self.affine.data[j][i] = torch.tensor([1.,0.,1.,0.]) - else: - self.affine.data[j][i] = torch.rand(4,) * 2 - 1 - return None - - def swap(self, i1, i2, mode='in'): - ''' - swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') - ''' - with torch.no_grad(): - def swap_list_(data, i1, i2, mode='in'): - - if mode == 'in': - for j in range(self.out_dim): - data[j][i1], data[j][i2] = data[j][i2], data[j][i1] - - elif mode == 'out': - data[i1], data[i2] = data[i2], data[i1] - - def swap_(data, i1, i2, mode='in'): - if mode == 'in': - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() - - elif mode == 'out': - data[i1], data[i2] = data[i2].clone(), data[i1].clone() - - swap_list_(self.funs_name,i1,i2,mode) - swap_list_(self.funs_sympy,i1,i2,mode) - swap_list_(self.funs_avoid_singularity,i1,i2,mode) - swap_(self.affine.data,i1,i2,mode) - swap_(self.mask.data,i1,i2,mode) diff --git a/kan/.ipynb_checkpoints/__init__-checkpoint.py b/kan/.ipynb_checkpoints/__init__-checkpoint.py deleted file mode 100644 index 1ce0e47b2..000000000 --- a/kan/.ipynb_checkpoints/__init__-checkpoint.py +++ /dev/null @@ -1,3 +0,0 @@ -from .MultKAN import * -from .utils import * -#torch.use_deterministic_algorithms(True) \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/compiler-checkpoint.py b/kan/.ipynb_checkpoints/compiler-checkpoint.py deleted file mode 100644 index c8014829e..000000000 --- a/kan/.ipynb_checkpoints/compiler-checkpoint.py +++ /dev/null @@ -1,498 +0,0 @@ -from sympy import * -import sympy -import numpy as np -from kan.MultKAN import MultKAN -import torch - -def next_nontrivial_operation(expr, scale=1, bias=0): - ''' - remove the affine part of an expression - - Args: - ----- - expr : sympy expression - scale : float - bias : float - - Returns: - -------- - expr : sympy expression - scale : float - bias : float - - Example - ------- - >>> from kan.compiler import * - >>> from sympy import * - >>> input_vars = a, b = symbols('a b') - >>> expression = 3.14534242 * exp(sin(pi*a) + b**2) - 2.32345402 - >>> next_nontrivial_operation(expression) - ''' - if expr.func == Add or expr.func == Mul: - n_arg = len(expr.args) - n_num = 0 - n_var_id = [] - n_num_id = [] - var_args = [] - for i in range(n_arg): - is_number = expr.args[i].is_number - n_num += is_number - if not is_number: - n_var_id.append(i) - var_args.append(expr.args[i]) - else: - n_num_id.append(i) - if n_num > 0: - # trivial - if expr.func == Add: - for i in range(n_num): - if i == 0: - bias = expr.args[n_num_id[i]] - else: - bias += expr.args[n_num_id[i]] - if expr.func == Mul: - for i in range(n_num): - if i == 0: - scale = expr.args[n_num_id[i]] - else: - scale *= expr.args[n_num_id[i]] - - return next_nontrivial_operation(expr.func(*var_args), scale, bias) - else: - return expr, scale, bias - else: - return expr, scale, bias - - -def expr2kan(input_variables, expr, grid=5, k=3, auto_save=False): - ''' - compile a symbolic formula to a MultKAN - - Args: - ----- - input_variables : a list of sympy symbols - expr : sympy expression - grid : int - the number of grid intervals - k : int - spline order - auto_save : bool - if auto_save = True, models are automatically saved - - Returns: - -------- - MultKAN - - Example - ------- - >>> from kan.compiler import * - >>> from sympy import * - >>> input_vars = a, b = symbols('a b') - >>> expression = exp(sin(pi*a) + b**2) - >>> model = kanpiler(input_vars, expression) - >>> x = torch.rand(100,2) * 2 - 1 - >>> model(x) - >>> model.plot() - ''' - class Node: - def __init__(self, expr, mult_bool, depth, scale, bias, parent=None, mult_arity=None): - self.expr = expr - self.mult_bool = mult_bool - if self.mult_bool: - self.mult_arity = mult_arity - self.depth = depth - - if len(Nodes) <= depth: - Nodes.append([]) - index = 0 - else: - index = len(Nodes[depth]) - - Nodes[depth].append(self) - - self.index = index - if parent == None: - self.parent_index = None - else: - self.parent_index = parent.index - self.child_index = [] - - # update parent's child_index - if parent != None: - parent.child_index.append(self.index) - - - self.scale = scale - self.bias = bias - - - class SubNode: - def __init__(self, expr, depth, scale, bias, parent=None): - self.expr = expr - self.depth = depth - - if len(SubNodes) <= depth: - SubNodes.append([]) - index = 0 - else: - index = len(SubNodes[depth]) - - SubNodes[depth].append(self) - - self.index = index - self.parent_index = None # shape: (2,) - self.child_index = [] # shape: (n, 2) - - # update parent's child_index - parent.child_index.append(self.index) - - self.scale = scale - self.bias = bias - - - class Connection: - def __init__(self, affine, fun, fun_name, parent=None, child=None, power_exponent=None): - # connection = activation function that connects a subnode to a node in the next layer node - self.affine = affine #[1,0,1,0] # (a,b,c,d) - self.fun = fun # y = c*fun(a*x+b)+d - self.fun_name = fun_name - self.parent_index = parent.index - self.depth = parent.depth - self.child_index = child.index - self.power_exponent = power_exponent # if fun == Pow - Connections[(self.depth,self.parent_index,self.child_index)] = self - - def create_node(expr, parent=None, n_layer=None): - #print('before', expr) - expr, scale, bias = next_nontrivial_operation(expr) - #print('after', expr) - if parent == None: - depth = 0 - else: - depth = parent.depth - - - if expr.func == Mul: - mult_arity = len(expr.args) - node = Node(expr, True, depth, scale, bias, parent=parent, mult_arity=mult_arity) - # create mult_arity SubNodes, + 1 - for i in range(mult_arity): - # create SubNode - expr_i, scale, bias = next_nontrivial_operation(expr.args[i]) - subnode = SubNode(expr_i, node.depth+1, scale, bias, parent=node) - if expr_i.func == Add: - for j in range(len(expr_i.args)): - expr_ij, scale, bias = next_nontrivial_operation(expr_i.args[j]) - # expr_ij is impossible to be Add, should be Mul or 1D - if expr_ij.func == Mul: - #print(expr_ij) - # create a node with expr_ij - new_node = create_node(expr_ij, parent=subnode, n_layer=n_layer) - # create a connection which is a linear function - c = Connection([1,0,float(scale),float(bias)], lambda x: x, 'x', parent=subnode, child=new_node) - - elif expr_ij.func == Symbol: - #print(expr_ij) - new_node = create_node(expr_ij, parent=subnode, n_layer=n_layer) - c = Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) - - else: - # 1D function case - # create a node with expr_ij.args[0] - new_node = create_node(expr_ij.args[0], parent=subnode, n_layer=n_layer) - # create 1D function expr_ij.func - if expr_ij.func == Pow: - power_exponent = expr_ij.args[1] - else: - power_exponent = None - Connection([1,0,float(scale),float(bias)], expr_ij.func, fun_name = expr_ij.func, parent=subnode, child=new_node, power_exponent=power_exponent) - - - elif expr_i.func == Mul: - # create a node with expr_i - new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - # create 1D function, linear - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) - - elif expr_i.func == Symbol: - new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) - - else: - # 1D functions - # create a node with expr_i.args[0] - new_node = create_node(expr_i.args[0], parent=subnode, n_layer=n_layer) - # create 1D function expr_i.func - if expr_i.func == Pow: - power_exponent = expr_i.args[1] - else: - power_exponent = None - Connection([1,0,1,0], expr_i.func, fun_name = expr_i.func, parent=subnode, child=new_node, power_exponent=power_exponent) - - elif expr.func == Add: - - node = Node(expr, False, depth, scale, bias, parent=parent) - subnode = SubNode(expr, node.depth+1, 1, 0, parent=node) - - for i in range(len(expr.args)): - expr_i, scale, bias = next_nontrivial_operation(expr.args[i]) - if expr_i.func == Mul: - # create a node with expr_i - new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - # create a connection which is a linear function - Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) - - elif expr_i.func == Symbol: - new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) - - else: - # 1D function case - # create a node with expr_ij.args[0] - new_node = create_node(expr_i.args[0], parent=subnode, n_layer=n_layer) - # create 1D function expr_i.func - if expr_i.func == Pow: - power_exponent = expr_i.args[1] - else: - power_exponent = None - Connection([1,0,float(scale),float(bias)], expr_i.func, fun_name = expr_i.func, parent=subnode, child=new_node, power_exponent=power_exponent) - - elif expr.func == Symbol: - # expr.func is a symbol (one of input variables) - if n_layer == None: - node = Node(expr, False, depth, scale, bias, parent=parent) - else: - node = Node(expr, False, depth, scale, bias, parent=parent) - return_node = node - for i in range(n_layer - depth): - subnode = SubNode(expr, node.depth+1, 1, 0, parent=node) - node = Node(expr, False, subnode.depth, 1, 0, parent=subnode) - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=node) - node = return_node - - Start_Nodes.append(node) - - else: - # expr.func is 1D function - #print(expr, scale, bias) - node = Node(expr, False, depth, scale, bias, parent=parent) - expr_i, scale, bias = next_nontrivial_operation(expr.args[0]) - subnode = SubNode(expr_i, node.depth+1, 1, 0, parent=node) - # create a node with expr_i.args[0] - new_node = create_node(expr.args[0], parent=subnode, n_layer=n_layer) - # create 1D function expr_i.func - if expr.func == Pow: - power_exponent = expr.args[1] - else: - power_exponent = None - Connection([1,0,1,0], expr.func, fun_name = expr.func, parent=subnode, child=new_node, power_exponent=power_exponent) - - return node - - Nodes = [[]] - SubNodes = [[]] - Connections = {} - Start_Nodes = [] - - create_node(expr, n_layer=None) - - n_layer = len(Nodes) - 1 - - Nodes = [[]] - SubNodes = [[]] - Connections = {} - Start_Nodes = [] - - create_node(expr, n_layer=n_layer) - - # move affine parameters in leaf nodes to connections - for node in Start_Nodes: - c = Connections[(node.depth,node.parent_index,node.index)] - c.affine[0] = float(node.scale) - c.affine[1] = float(node.bias) - node.scale = 1. - node.bias = 0. - - #input_variables = symbol - node2var = [] - for node in Start_Nodes: - for i in range(len(input_variables)): - if node.expr == input_variables[i]: - node2var.append(i) - - # Nodes - n_mult = [] - n_sum = [] - for layer in Nodes: - n_mult.append(0) - n_sum.append(0) - for node in layer: - if node.mult_bool == True: - n_mult[-1] += 1 - else: - n_sum[-1] += 1 - - # depth - n_layer = len(Nodes) - 1 - - # converter - # input tree node id, output kan node id (distinguish sum and mult node) - # input tree subnode id, output tree subnode id - # node id - subnode_index_convert = {} - node_index_convert = {} - connection_index_convert = {} - mult_arities = [] - for layer_id in range(n_layer+1): - mult_arity = [] - i_sum = 0 - i_mult = 0 - for i in range(len(Nodes[layer_id])): - node = Nodes[layer_id][i] - if node.mult_bool == True: - kan_node_id = n_sum[layer_id] + i_mult - arity = len(node.child_index) - for i in range(arity): - subnode = SubNodes[node.depth+1][node.child_index[i]] - kan_subnode_id = n_sum[layer_id] + np.sum(mult_arity) + i - subnode_index_convert[(subnode.depth,subnode.index)] = (int(n_layer-subnode.depth),int(kan_subnode_id)) - i_mult += 1 - mult_arity.append(arity) - else: - kan_node_id = i_sum - if len(node.child_index) > 0: - subnode = SubNodes[node.depth+1][node.child_index[0]] - kan_subnode_id = i_sum - subnode_index_convert[(subnode.depth,subnode.index)] = (int(n_layer-subnode.depth),int(kan_subnode_id)) - i_sum += 1 - - if layer_id == n_layer: - # input layer - node_index_convert[(node.depth,node.index)] = (int(n_layer-node.depth),int(node2var[kan_node_id])) - else: - node_index_convert[(node.depth,node.index)] = (int(n_layer-node.depth),int(kan_node_id)) - - # node: depth (node.depth -> n_layer - node.depth) - # width (node.index -> kan_node_id) - # subnode: depth (subnode.depth -> n_layer - subnode.depth) - # width (subnote.index -> kan_subnode_id) - mult_arities.append(mult_arity) - - for index in list(Connections.keys()): - depth, subnode_id, node_id = index - # to int(n_layer-depth), - _, kan_subnode_id = subnode_index_convert[(depth, subnode_id)] - _, kan_node_id = node_index_convert[(depth, node_id)] - connection_index_convert[(depth, subnode_id, node_id)] = (n_layer-depth, kan_subnode_id, kan_node_id) - - - n_sum.reverse() - n_mult.reverse() - mult_arities.reverse() - - width = [[n_sum[i], n_mult[i]] for i in range(len(n_sum))] - width[0][0] = len(input_variables) - - # allow pass in other parameters (probably as a dictionary) in sf2kan, including grid k etc. - model = MultKAN(width=width, mult_arity=mult_arities, grid=grid, k=k, auto_save=auto_save) - - # clean the graph - for l in range(model.depth): - for i in range(model.width_in[l]): - for j in range(model.width_out[l+1]): - model.fix_symbolic(l,i,j,'0',fit_params_bool=False) - - # Nodes - Nodes_flat = [x for xs in Nodes for x in xs] - - self = model - - for node in Nodes_flat: - node_depth = node.depth - node_index = node.index - kan_node_depth, kan_node_index = node_index_convert[(node_depth,node_index)] - #print(kan_node_depth, kan_node_index) - if kan_node_depth > 0: - self.node_scale[kan_node_depth-1].data[kan_node_index] = float(node.scale) - self.node_bias[kan_node_depth-1].data[kan_node_index] = float(node.bias) - - - # SubNodes - SubNodes_flat = [x for xs in SubNodes for x in xs] - - for subnode in SubNodes_flat: - subnode_depth = subnode.depth - subnode_index = subnode.index - kan_subnode_depth, kan_subnode_index = subnode_index_convert[(subnode_depth,subnode_index)] - #print(kan_subnode_depth, kan_subnode_index) - self.subnode_scale[kan_subnode_depth].data[kan_subnode_index] = float(subnode.scale) - self.subnode_bias[kan_subnode_depth].data[kan_subnode_index] = float(subnode.bias) - - # Connections - Connections_flat = list(Connections.values()) - - for connection in Connections_flat: - c_depth = connection.depth - c_j = connection.parent_index - c_i = connection.child_index - kc_depth, kc_j, kc_i = connection_index_convert[(c_depth, c_j, c_i)] - - # get symbolic fun_name - fun_name = connection.fun_name - #if fun_name == Pow: - # print(connection.power_exponent) - - if fun_name == 'x': - kfun_name = 'x' - elif fun_name == exp: - kfun_name = 'exp' - elif fun_name == sin: - kfun_name = 'sin' - elif fun_name == cos: - kfun_name = 'cos' - elif fun_name == tan: - kfun_name = 'tan' - elif fun_name == sqrt: - kfun_name = 'sqrt' - elif fun_name == log: - kfun_name = 'log' - elif fun_name == tanh: - kfun_name = 'tanh' - elif fun_name == asin: - kfun_name = 'arcsin' - elif fun_name == acos: - kfun_name = 'arccos' - elif fun_name == atan: - kfun_name = 'arctan' - elif fun_name == atanh: - kfun_name = 'arctanh' - elif fun_name == sign: - kfun_name = 'sgn' - elif fun_name == Pow: - alpha = connection.power_exponent - if alpha == Rational(1,2): - kfun_name = 'x^0.5' - elif alpha == - Rational(1,2): - kfun_name = '1/x^0.5' - elif alpha == Rational(3,2): - kfun_name = 'x^1.5' - else: - alpha = int(connection.power_exponent) - if alpha > 0: - if alpha == 1: - kfun_name = 'x' - else: - kfun_name = f'x^{alpha}' - else: - if alpha == -1: - kfun_name = '1/x' - else: - kfun_name = f'1/x^{-alpha}' - - model.fix_symbolic(kc_depth, kc_i, kc_j, kfun_name, fit_params_bool=False) - model.symbolic_fun[kc_depth].affine.data.reshape(self.width_out[kc_depth+1], self.width_in[kc_depth], 4)[kc_j][kc_i] = torch.tensor(connection.affine) - - return model - - -sf2kan = kanpiler = expr2kan \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/experiment-checkpoint.py b/kan/.ipynb_checkpoints/experiment-checkpoint.py deleted file mode 100644 index 9ab9e9de3..000000000 --- a/kan/.ipynb_checkpoints/experiment-checkpoint.py +++ /dev/null @@ -1,55 +0,0 @@ -import torch -from .MultKAN import * - - -def runner1(width, dataset, grids=[5,10,20], steps=20, lamb=0.001, prune_round=3, refine_round=3, edge_th=1e-2, node_th=1e-2, metrics=None, seed=1): - - result = {} - result['test_loss'] = [] - result['c'] = [] - result['G'] = [] - result['id'] = [] - if metrics != None: - for i in range(len(metrics)): - result[metrics[i].__name__] = [] - - def collect(evaluation): - result['test_loss'].append(evaluation['test_loss']) - result['c'].append(evaluation['n_edge']) - result['G'].append(evaluation['n_grid']) - result['id'].append(f'{model.round}.{model.state_id}') - if metrics != None: - for i in range(len(metrics)): - result[metrics[i].__name__].append(metrics[i](model, dataset).item()) - - for i in range(prune_round): - # train and prune - if i == 0: - model = KAN(width=width, grid=grids[0], seed=seed) - else: - model = model.rewind(f'{i-1}.{2*i}') - - model.fit(dataset, steps=steps, lamb=lamb) - model = model.prune(edge_th=edge_th, node_th=node_th) - evaluation = model.evaluate(dataset) - collect(evaluation) - - for j in range(refine_round): - model = model.refine(grids[j]) - model.fit(dataset, steps=steps) - evaluation = model.evaluate(dataset) - collect(evaluation) - - for key in list(result.keys()): - result[key] = np.array(result[key]) - - return result - - -def pareto_frontier(x,y): - - pf_id = np.where(np.sum((x[:,None] <= x[None,:]) * (y[:,None] <= y[None,:]), axis=0) == 1)[0] - x_pf = x[pf_id] - y_pf = y[pf_id] - - return x_pf, y_pf, pf_id \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/feynman-checkpoint.py b/kan/.ipynb_checkpoints/feynman-checkpoint.py deleted file mode 100644 index 6cc55e96f..000000000 --- a/kan/.ipynb_checkpoints/feynman-checkpoint.py +++ /dev/null @@ -1,739 +0,0 @@ -from sympy import * -import torch - - -def get_feynman_dataset(name): - - global symbols - - tpi = torch.tensor(torch.pi) - - if name == 'test': - symbol = x, y = symbols('x, y') - expr = (x+y) * sin(exp(2*y)) - f = lambda x: (x[:,[0]] + x[:,[1]])*torch.sin(torch.exp(2*x[:,[1]])) - ranges = [-1,1] - - if name == 'I.6.20a' or name == 1: - symbol = theta = symbols('theta') - symbol = [symbol] - expr = exp(-theta**2/2)/sqrt(2*pi) - f = lambda x: torch.exp(-x[:,[0]]**2/2)/torch.sqrt(2*tpi) - ranges = [[-3,3]] - - if name == 'I.6.20' or name == 2: - symbol = theta, sigma = symbols('theta sigma') - expr = exp(-theta**2/(2*sigma**2))/sqrt(2*pi*sigma**2) - f = lambda x: torch.exp(-x[:,[0]]**2/(2*x[:,[1]]**2))/torch.sqrt(2*tpi*x[:,[1]]**2) - ranges = [[-1,1],[0.5,2]] - - if name == 'I.6.20b' or name == 3: - symbol = theta, theta1, sigma = symbols('theta theta1 sigma') - expr = exp(-(theta-theta1)**2/(2*sigma**2))/sqrt(2*pi*sigma**2) - f = lambda x: torch.exp(-(x[:,[0]]-x[:,[1]])**2/(2*x[:,[2]]**2))/torch.sqrt(2*tpi*x[:,[2]]**2) - ranges = [[-1.5,1.5],[-1.5,1.5],[0.5,2]] - - if name == 'I.8.4' or name == 4: - symbol = x1, x2, y1, y2 = symbols('x1 x2 y1 y2') - expr = sqrt((x2-x1)**2+(y2-y1)**2) - f = lambda x: torch.sqrt((x[:,[1]]-x[:,[0]])**2+(x[:,[3]]-x[:,[2]])**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.9.18' or name == 5: - symbol = G, m1, m2, x1, x2, y1, y2, z1, z2 = symbols('G m1 m2 x1 x2 y1 y2 z1 z2') - expr = G*m1*m2/((x2-x1)**2+(y2-y1)**2+(z2-z1)**2) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/((x[:,[3]]-x[:,[4]])**2+(x[:,[5]]-x[:,[6]])**2+(x[:,[7]]-x[:,[8]])**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,-0.5],[0.5,1],[-1,-0.5],[0.5,1],[-1,-0.5],[0.5,1]] - - if name == 'I.10.7' or name == 6: - symbol = m0, v, c = symbols('m0 v c') - expr = m0/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'I.11.19' or name == 7: - symbol = x1, y1, x2, y2, x3, y3 = symbols('x1 y1 x2 y2 x3 y3') - expr = x1*y1 + x2*y2 + x3*y3 - f = lambda x: x[:,[0]]*x[:,[1]] + x[:,[2]]*x[:,[3]] + x[:,[4]]*x[:,[5]] - ranges = [-1,1] - - if name == 'I.12.1' or name == 8: - symbol = mu, Nn = symbols('mu N_n') - expr = mu * Nn - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [-1,1] - - if name == 'I.12.2' or name == 9: - symbol = q1, q2, eps, r = symbols('q1 q2 epsilon r') - expr = q1*q2/(4*pi*eps*r**2) - f = lambda x: x[:,[0]]*x[:,[1]]/(4*tpi*x[:,[2]]*x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.12.4' or name == 10: - symbol = q1, eps, r = symbols('q1 epsilon r') - expr = q1/(4*pi*eps*r**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]**2) - ranges = [[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.12.5' or name == 11: - symbol = q2, Ef = symbols('q2, E_f') - expr = q2*Ef - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [-1,1] - - if name == 'I.12.11' or name == 12: - symbol = q, Ef, B, v, theta = symbols('q E_f B v theta') - expr = q*(Ef + B*v*sin(theta)) - f = lambda x: x[:,[0]]*(x[:,[1]]+x[:,[2]]*x[:,[3]]*torch.sin(x[:,[4]])) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.13.4' or name == 13: - symbol = m, v, u, w = symbols('m u v w') - expr = 1/2*m*(v**2+u**2+w**2) - f = lambda x: 1/2*x[:,[0]]*(x[:,[1]]**2+x[:,[2]]**2+x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.13.12' or name == 14: - symbol = G, m1, m2, r1, r2 = symbols('G m1 m2 r1 r2') - expr = G*m1*m2*(1/r2-1/r1) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*(1/x[:,[4]]-1/x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.14.3' or name == 15: - symbol = m, g, z = symbols('m g z') - expr = m*g*z - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]] - ranges = [[0,1],[0,1],[-1,1]] - - if name == 'I.14.4' or name == 16: - symbol = ks, x = symbols('k_s x') - expr = 1/2*ks*x**2 - f = lambda x: 1/2*x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[-1,1]] - - if name == 'I.15.3x' or name == 17: - symbol = x, u, t, c = symbols('x u t c') - expr = (x-u*t)/sqrt(1-u**2/c**2) - f = lambda x: (x[:,[0]] - x[:,[1]]*x[:,[2]])/torch.sqrt(1-x[:,[1]]**2/x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[1,2]] - - if name == 'I.15.3t' or name == 18: - symbol = t, u, x, c = symbols('t u x c') - expr = (t-u*x/c**2)/sqrt(1-u**2/c**2) - f = lambda x: (x[:,[0]] - x[:,[1]]*x[:,[2]]/x[:,[3]]**2)/torch.sqrt(1-x[:,[1]]**2/x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[1,2]] - - if name == 'I.15.10' or name == 19: - symbol = m0, v, c = symbols('m0 v c') - expr = m0*v/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[-1,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.16.6' or name == 20: - symbol = u, v, c = symbols('u v c') - expr = (u+v)/(1+u*v/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/(1+x[:,[0]]*x[:,[1]]/x[:,[2]]**2) - ranges = [[-0.8,0.8],[-0.8,0.8],[1,2]] - - if name == 'I.18.4' or name == 21: - symbol = m1, r1, m2, r2 = symbols('m1 r1 m2 r2') - expr = (m1*r1+m2*r2)/(m1+m2) - f = lambda x: (x[:,[0]]*x[:,[1]]+x[:,[2]]*x[:,[3]])/(x[:,[0]]+x[:,[2]]) - ranges = [[0.5,1],[-1,1],[0.5,1],[-1,1]] - - if name == 'I.18.4' or name == 22: - symbol = r, F, theta = symbols('r F theta') - expr = r*F*sin(theta) - f = lambda x: x[:,[0]]*x[:,[1]]*torch.sin(x[:,[2]]) - ranges = [[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.18.16' or name == 23: - symbol = m, r, v, theta = symbols('m r v theta') - expr = m*r*v*sin(theta) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*torch.sin(x[:,[3]]) - ranges = [[-1,1],[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.24.6' or name == 24: - symbol = m, omega, omega0, x = symbols('m omega omega_0 x') - expr = 1/4*m*(omega**2+omega0**2)*x**2 - f = lambda x: 1/4*x[:,[0]]*(x[:,[1]]**2+x[:,[2]]**2)*x[:,[3]]**2 - ranges = [[0,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.25.13' or name == 25: - symbol = q, C = symbols('q C') - expr = q/C - f = lambda x: x[:,[0]]/x[:,[1]] - ranges = [[-1,1],[0.5,2]] - - if name == 'I.26.2' or name == 26: - symbol = n, theta2 = symbols('n theta2') - expr = asin(n*sin(theta2)) - f = lambda x: torch.arcsin(x[:,[0]]*torch.sin(x[:,[1]])) - ranges = [[0,0.99],[0,2*tpi]] - - if name == 'I.27.6' or name == 27: - symbol = d1, d2, n = symbols('d1 d2 n') - expr = 1/(1/d1+n/d2) - f = lambda x: 1/(1/x[:,[0]]+x[:,[2]]/x[:,[1]]) - ranges = [[0.5,2],[1,2],[0.5,2]] - - if name == 'I.29.4' or name == 28: - symbol = omega, c = symbols('omega c') - expr = omega/c - f = lambda x: x[:,[0]]/x[:,[1]] - ranges = [[0,1],[0.5,2]] - - if name == 'I.29.16' or name == 29: - symbol = x1, x2, theta1, theta2 = symbols('x1 x2 theta1 theta2') - expr = sqrt(x1**2+x2**2-2*x1*x2*cos(theta1-theta2)) - f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2-2*x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]-x[:,[3]])) - ranges = [[-1,1],[-1,1],[0,2*tpi],[0,2*tpi]] - - if name == 'I.30.3' or name == 30: - symbol = I0, n, theta = symbols('I_0 n theta') - expr = I0 * sin(n*theta/2)**2 / sin(theta/2) ** 2 - f = lambda x: x[:,[0]] * torch.sin(x[:,[1]]*x[:,[2]]/2)**2 / torch.sin(x[:,[2]]/2)**2 - ranges = [[0,1],[0,4],[0.4*tpi,1.6*tpi]] - - if name == 'I.30.5' or name == 31: - symbol = lamb, n, d = symbols('lambda n d') - expr = asin(lamb/(n*d)) - f = lambda x: torch.arcsin(x[:,[0]]/(x[:,[1]]*x[:,[2]])) - ranges = [[-1,1],[1,1.5],[1,1.5]] - - if name == 'I.32.5' or name == 32: - symbol = q, a, eps, c = symbols('q a epsilon c') - expr = q**2*a**2/(eps*c**3) - f = lambda x: x[:,[0]]**2*x[:,[1]]**2/(x[:,[2]]*x[:,[3]]**3) - ranges = [[-1,1],[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.32.17' or name == 33: - symbol = eps, c, Ef, r, omega, omega0 = symbols('epsilon c E_f r omega omega_0') - expr = nsimplify((1/2*eps*c*Ef**2)*(8*pi*r**2/3)*(omega**4/(omega**2-omega0**2)**2)) - f = lambda x: (1/2*x[:,[0]]*x[:,[1]]*x[:,[2]]**2)*(8*tpi*x[:,[3]]**2/3)*(x[:,[4]]**4/(x[:,[4]]**2-x[:,[5]]**2)**2) - ranges = [[0,1],[0,1],[-1,1],[0,1],[0,1],[1,2]] - - if name == 'I.34.8' or name == 34: - symbol = q, V, B, p = symbols('q V B p') - expr = q*V*B/p - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[-1,1],[-1,1],[-1,1],[0.5,2]] - - if name == 'I.34.10' or name == 35: - symbol = omega0, v, c = symbols('omega_0 v c') - expr = omega0/(1-v/c) - f = lambda x: x[:,[0]]/(1-x[:,[1]]/x[:,[2]]) - ranges = [[0,1],[0,0.9],[1.1,2]] - - if name == 'I.34.14' or name == 36: - symbol = omega0, v, c = symbols('omega_0 v c') - expr = omega0 * (1+v/c)/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*(1+x[:,[1]]/x[:,[2]])/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.34.27' or name == 37: - symbol = hbar, omega = symbols('hbar omega') - expr = hbar * omega - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [[-1,1],[-1,1]] - - if name == 'I.37.4' or name == 38: - symbol = I1, I2, delta = symbols('I_1 I_2 delta') - expr = I1 + I2 + 2*sqrt(I1*I2)*cos(delta) - f = lambda x: x[:,[0]] + x[:,[1]] + 2*torch.sqrt(x[:,[0]]*x[:,[1]])*torch.cos(x[:,[2]]) - ranges = [[0.1,1],[0.1,1],[0,2*tpi]] - - if name == 'I.38.12' or name == 39: - symbol = eps, hbar, m, q = symbols('epsilon hbar m q') - expr = 4*pi*eps*hbar**2/(m*q**2) - f = lambda x: 4*tpi*x[:,[0]]*x[:,[1]]**2/(x[:,[2]]*x[:,[3]]**2) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.39.10' or name == 40: - symbol = pF, V = symbols('p_F V') - expr = 3/2 * pF * V - f = lambda x: 3/2 * x[:,[0]] * x[:,[1]] - ranges = [[0,1],[0,1]] - - if name == 'I.39.11' or name == 41: - symbol = gamma, pF, V = symbols('gamma p_F V') - expr = pF * V/(gamma - 1) - f = lambda x: 1/(x[:,[0]]-1) * x[:,[1]] * x[:,[2]] - ranges = [[1.5,3],[0,1],[0,1]] - - if name == 'I.39.22' or name == 42: - symbol = n, kb, T, V = symbols('n k_b T V') - expr = n*kb*T/V - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'I.40.1' or name == 43: - symbol = n0, m, g, x, kb, T = symbols('n_0 m g x k_b T') - expr = n0 * exp(-m*g*x/(kb*T)) - f = lambda x: x[:,[0]] * torch.exp(-x[:,[1]]*x[:,[2]]*x[:,[3]]/(x[:,[4]]*x[:,[5]])) - ranges = [[0,1],[-1,1],[-1,1],[-1,1],[1,2],[1,2]] - - if name == 'I.41.16' or name == 44: - symbol = hbar, omega, c, kb, T = symbols('hbar omega c k_b T') - expr = hbar * omega**3/(pi**2*c**2*(exp(hbar*omega/(kb*T))-1)) - f = lambda x: x[:,[0]]*x[:,[1]]**3/(tpi**2*x[:,[2]]**2*(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[3]]*x[:,[4]]))-1)) - ranges = [[0.5,1],[0.5,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'I.43.16' or name == 45: - symbol = mu, q, Ve, d = symbols('mu q V_e d') - expr = mu*q*Ve/d - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'I.43.31' or name == 46: - symbol = mu, kb, T = symbols('mu k_b T') - expr = mu*kb*T - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]] - ranges = [[0,1],[0,1],[0,1]] - - if name == 'I.43.43' or name == 47: - symbol = gamma, kb, v, A = symbols('gamma k_b v A') - expr = kb*v/A/(gamma-1) - f = lambda x: 1/(x[:,[0]]-1)*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[1.5,3],[0,1],[0,1],[0.5,2]] - - if name == 'I.44.4' or name == 48: - symbol = n, kb, T, V1, V2 = symbols('n k_b T V_1 V_2') - expr = n*kb*T*log(V2/V1) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*torch.log(x[:,[4]]/x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.47.23' or name == 49: - symbol = gamma, p, rho = symbols('gamma p rho') - expr = sqrt(gamma*p/rho) - f = lambda x: torch.sqrt(x[:,[0]]*x[:,[1]]/x[:,[2]]) - ranges = [[0.1,1],[0.1,1],[0.5,2]] - - if name == 'I.48.20' or name == 50: - symbol = m, v, c = symbols('m v c') - expr = m*c**2/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[2]]**2/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.50.26' or name == 51: - symbol = x1, alpha, omega, t = symbols('x_1 alpha omega t') - expr = x1*(cos(omega*t)+alpha*cos(omega*t)**2) - f = lambda x: x[:,[0]]*(torch.cos(x[:,[2]]*x[:,[3]])+x[:,[1]]*torch.cos(x[:,[2]]*x[:,[3]])**2) - ranges = [[0,1],[0,1],[0,2*tpi],[0,1]] - - if name == 'II.2.42' or name == 52: - symbol = kappa, T1, T2, A, d = symbols('kappa T_1 T_2 A d') - expr = kappa*(T2-T1)*A/d - f = lambda x: x[:,[0]]*(x[:,[2]]-x[:,[1]])*x[:,[3]]/x[:,[4]] - ranges = [[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.3.24' or name == 53: - symbol = P, r = symbols('P r') - expr = P/(4*pi*r**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]**2) - ranges = [[0,1],[0.5,2]] - - if name == 'II.4.23' or name == 54: - symbol = q, eps, r = symbols('q epsilon r') - expr = q/(4*pi*eps*r) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'II.6.11' or name == 55: - symbol = eps, pd, theta, r = symbols('epsilon p_d theta r') - expr = 1/(4*pi*eps)*pd*cos(theta)/r**2 - f = lambda x: 1/(4*tpi*x[:,[0]])*x[:,[1]]*torch.cos(x[:,[2]])/x[:,[3]]**2 - ranges = [[0.5,2],[0,1],[0,2*tpi],[0.5,2]] - - if name == 'II.6.15a' or name == 56: - symbol = eps, pd, z, x, y, r = symbols('epsilon p_d z x y r') - expr = 3/(4*pi*eps)*pd*z/r**5*sqrt(x**2+y**2) - f = lambda x: 3/(4*tpi*x[:,[0]])*x[:,[1]]*x[:,[2]]/x[:,[5]]**5*torch.sqrt(x[:,[3]]**2+x[:,[4]]**2) - ranges = [[0.5,2],[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.6.15b' or name == 57: - symbol = eps, pd, r, theta = symbols('epsilon p_d r theta') - expr = 3/(4*pi*eps)*pd/r**3*cos(theta)*sin(theta) - f = lambda x: 3/(4*tpi*x[:,[0]])*x[:,[1]]/x[:,[2]]**3*torch.cos(x[:,[3]])*torch.sin(x[:,[3]]) - ranges = [[0.5,2],[0,1],[0.5,2],[0,2*tpi]] - - if name == 'II.8.7' or name == 58: - symbol = q, eps, d = symbols('q epsilon d') - expr = 3/5*q**2/(4*pi*eps*d) - f = lambda x: 3/5*x[:,[0]]**2/(4*tpi*x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'II.8.31' or name == 59: - symbol = eps, Ef = symbols('epsilon E_f') - expr = 1/2*eps*Ef**2 - f = lambda x: 1/2*x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[0,1]] - - if name == 'I.10.9' or name == 60: - symbol = sigma, eps, chi = symbols('sigma epsilon chi') - expr = sigma/eps/(1+chi) - f = lambda x: x[:,[0]]/x[:,[1]]/(1+x[:,[2]]) - ranges = [[0,1],[0.5,2],[0,1]] - - if name == 'II.11.3' or name == 61: - symbol = q, Ef, m, omega0, omega = symbols('q E_f m omega_o omega') - expr = q*Ef/(m*(omega0**2-omega**2)) - f = lambda x: x[:,[0]]*x[:,[1]]/(x[:,[2]]*(x[:,[3]]**2-x[:,[4]]**2)) - ranges = [[0,1],[0,1],[0.5,2],[1.5,3],[0,1]] - - if name == 'II.11.17' or name == 62: - symbol = n0, pd, Ef, theta, kb, T = symbols('n_0 p_d E_f theta k_b T') - expr = n0*(1+pd*Ef*cos(theta)/(kb*T)) - f = lambda x: x[:,[0]]*(1+x[:,[1]]*x[:,[2]]*torch.cos(x[:,[3]])/(x[:,[4]]*x[:,[5]])) - ranges = [[0,1],[-1,1],[-1,1],[0,2*tpi],[0.5,2],[0.5,2]] - - - if name == 'II.11.20' or name == 63: - symbol = n, pd, Ef, kb, T = symbols('n p_d E_f k_b T') - expr = n*pd**2*Ef/(3*kb*T) - f = lambda x: x[:,[0]]*x[:,[1]]**2*x[:,[2]]/(3*x[:,[3]]*x[:,[4]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.11.27' or name == 64: - symbol = n, alpha, eps, Ef = symbols('n alpha epsilon E_f') - expr = n*alpha/(1-n*alpha/3)*eps*Ef - f = lambda x: x[:,[0]]*x[:,[1]]/(1-x[:,[0]]*x[:,[1]]/3)*x[:,[2]]*x[:,[3]] - ranges = [[0,1],[0,2],[0,1],[0,1]] - - if name == 'II.11.28' or name == 65: - symbol = n, alpha = symbols('n alpha') - expr = 1 + n*alpha/(1-n*alpha/3) - f = lambda x: 1 + x[:,[0]]*x[:,[1]]/(1-x[:,[0]]*x[:,[1]]/3) - ranges = [[0,1],[0,2]] - - if name == 'II.13.17' or name == 66: - symbol = eps, c, l, r = symbols('epsilon c l r') - expr = 1/(4*pi*eps*c**2)*(2*l/r) - f = lambda x: 1/(4*tpi*x[:,[0]]*x[:,[1]]**2)*(2*x[:,[2]]/x[:,[3]]) - ranges = [[0.5,2],[0.5,2],[0,1],[0.5,2]] - - if name == 'II.13.23' or name == 67: - symbol = rho, v, c = symbols('rho v c') - expr = rho/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'II.13.34' or name == 68: - symbol = rho, v, c = symbols('rho v c') - expr = rho*v/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'II.15.4' or name == 69: - symbol = muM, B, theta = symbols('mu_M B theta') - expr = - muM * B * cos(theta) - f = lambda x: - x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'II.15.5' or name == 70: - symbol = pd, Ef, theta = symbols('p_d E_f theta') - expr = - pd * Ef * cos(theta) - f = lambda x: - x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'II.21.32' or name == 71: - symbol = q, eps, r, v, c = symbols('q epsilon r v c') - expr = q/(4*pi*eps*r*(1-v/c)) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]*(1-x[:,[3]]/x[:,[4]])) - ranges = [[0,1],[0.5,2],[0.5,2],[0,1],[1,2]] - - if name == 'II.24.17' or name == 72: - symbol = omega, c, d = symbols('omega c d') - expr = sqrt(omega**2/c**2-pi**2/d**2) - f = lambda x: torch.sqrt(x[:,[0]]**2/x[:,[1]]**2-tpi**2/x[:,[2]]**2) - ranges = [[1,1.5],[0.75,1],[1*tpi,1.5*tpi]] - - if name == 'II.27.16' or name == 73: - symbol = eps, c, Ef = symbols('epsilon c E_f') - expr = eps * c * Ef**2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]**2 - ranges = [[0,1],[0,1],[-1,1]] - - if name == 'II.27.18' or name == 74: - symbol = eps, Ef = symbols('epsilon E_f') - expr = eps * Ef**2 - f = lambda x: x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[-1,1]] - - if name == 'II.34.2a' or name == 75: - symbol = q, v, r = symbols('q v r') - expr = q*v/(2*pi*r) - f = lambda x: x[:,[0]]*x[:,[1]]/(2*tpi*x[:,[2]]) - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'II.34.2' or name == 76: - symbol = q, v, r = symbols('q v r') - expr = q*v*r/2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/2 - ranges = [[0,1],[0,1],[0,1]] - - if name == 'II.34.11' or name == 77: - symbol = g, q, B, m = symbols('g q B m') - expr = g*q*B/(2*m) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/(2*x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.34.29a' or name == 78: - symbol = q, h, m = symbols('q h m') - expr = q*h/(4*pi*m) - f = lambda x: x[:,[0]]*x[:,[1]]/(4*tpi*x[:,[2]]) - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'II.34.29b' or name == 79: - symbol = g, mu, B, J, hbar = symbols('g mu B J hbar') - expr = g*mu*B*J/hbar - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*x[:,[3]]/x[:,[4]] - ranges = [[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.35.18' or name == 80: - symbol = n0, mu, B, kb, T = symbols('n0 mu B k_b T') - expr = n0/(exp(mu*B/(kb*T))+exp(-mu*B/(kb*T))) - f = lambda x: x[:,[0]]/(torch.exp(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))+torch.exp(-x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.35.21' or name == 81: - symbol = n, mu, B, kb, T = symbols('n mu B k_b T') - expr = n*mu*tanh(mu*B/(kb*T)) - f = lambda x: x[:,[0]]*x[:,[1]]*torch.tanh(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]])) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.36.38' or name == 82: - symbol = mu, B, kb, T, alpha, M, eps, c = symbols('mu B k_b T alpha M epsilon c') - expr = mu*B/(kb*T) + mu*alpha*M/(eps*c**2*kb*T) - f = lambda x: x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]) + x[:,[0]]*x[:,[4]]*x[:,[5]]/(x[:,[6]]*x[:,[7]]**2*x[:,[2]]*x[:,[3]]) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.37.1' or name == 83: - symbol = mu, chi, B = symbols('mu chi B') - expr = mu*(1+chi)*B - f = lambda x: x[:,[0]]*(1+x[:,[1]])*x[:,[2]] - ranges = [[0,1],[0,1],[0,1]] - - if name == 'II.38.3' or name == 84: - symbol = Y, A, x, d = symbols('Y A x d') - expr = Y*A*x/d - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.38.14' or name == 85: - symbol = Y, sigma = symbols('Y sigma') - expr = Y/(2*(1+sigma)) - f = lambda x: x[:,[0]]/(2*(1+x[:,[1]])) - ranges = [[0,1],[0,1]] - - if name == 'III.4.32' or name == 86: - symbol = hbar, omega, kb, T = symbols('hbar omega k_b T') - expr = 1/(exp(hbar*omega/(kb*T))-1) - f = lambda x: 1/(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]))-1) - ranges = [[0.5,1],[0.5,1],[0.5,2],[0.5,2]] - - if name == 'III.4.33' or name == 87: - symbol = hbar, omega, kb, T = symbols('hbar omega k_b T') - expr = hbar*omega/(exp(hbar*omega/(kb*T))-1) - f = lambda x: x[:,[0]]*x[:,[1]]/(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]))-1) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'III.7.38' or name == 88: - symbol = mu, B, hbar = symbols('mu B hbar') - expr = 2*mu*B/hbar - f = lambda x: 2*x[:,[0]]*x[:,[1]]/x[:,[2]] - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'III.8.54' or name == 89: - symbol = E, t, hbar = symbols('E t hbar') - expr = sin(E*t/hbar)**2 - f = lambda x: torch.sin(x[:,[0]]*x[:,[1]]/x[:,[2]])**2 - ranges = [[0,2*tpi],[0,1],[0.5,2]] - - if name == 'III.9.52' or name == 90: - symbol = pd, Ef, t, hbar, omega, omega0 = symbols('p_d E_f t hbar omega omega_0') - expr = pd*Ef*t/hbar*sin((omega-omega0)*t/2)**2/((omega-omega0)*t/2)**2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]]*torch.sin((x[:,[4]]-x[:,[5]])*x[:,[2]]/2)**2/((x[:,[4]]-x[:,[5]])*x[:,[2]]/2)**2 - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0,tpi],[0,tpi]] - - if name == 'III.10.19' or name == 91: - symbol = mu, Bx, By, Bz = symbols('mu B_x B_y B_z') - expr = mu*sqrt(Bx**2+By**2+Bz**2) - f = lambda x: x[:,[0]]*torch.sqrt(x[:,[1]]**2+x[:,[2]]**2+x[:,[3]]**2) - ranges = [[0,1],[0,1],[0,1],[0,1]] - - if name == 'III.12.43' or name == 92: - symbol = n, hbar = symbols('n hbar') - expr = n * hbar - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [[0,1],[0,1]] - - if name == 'III.13.18' or name == 93: - symbol = E, d, k, hbar = symbols('E d k hbar') - expr = 2*E*d**2*k/hbar - f = lambda x: 2*x[:,[0]]*x[:,[1]]**2*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'III.14.14' or name == 94: - symbol = I0, q, Ve, kb, T = symbols('I_0 q V_e k_b T') - expr = I0 * (exp(q*Ve/(kb*T))-1) - f = lambda x: x[:,[0]]*(torch.exp(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))-1) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'III.15.12' or name == 95: - symbol = U, k, d = symbols('U k d') - expr = 2*U*(1-cos(k*d)) - f = lambda x: 2*x[:,[0]]*(1-torch.cos(x[:,[1]]*x[:,[2]])) - ranges = [[0,1],[0,2*tpi],[0,1]] - - if name == 'III.15.14' or name == 96: - symbol = hbar, E, d = symbols('hbar E d') - expr = hbar**2/(2*E*d**2) - f = lambda x: x[:,[0]]**2/(2*x[:,[1]]*x[:,[2]]**2) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'III.15.27' or name == 97: - symbol = alpha, n, d = symbols('alpha n d') - expr = 2*pi*alpha/(n*d) - f = lambda x: 2*tpi*x[:,[0]]/(x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'III.17.37' or name == 98: - symbol = beta, alpha, theta = symbols('beta alpha theta') - expr = beta * (1+alpha*cos(theta)) - f = lambda x: x[:,[0]]*(1+x[:,[1]]*torch.cos(x[:,[2]])) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'III.19.51' or name == 99: - symbol = m, q, eps, hbar, n = symbols('m q epsilon hbar n') - expr = - m * q**4/(2*(4*pi*eps)**2*hbar**2)*1/n**2 - f = lambda x: - x[:,[0]]*x[:,[1]]**4/(2*(4*tpi*x[:,[2]])**2*x[:,[3]]**2)*1/x[:,[4]]**2 - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'III.21.20' or name == 100: - symbol = rho, q, A, m = symbols('rho q A m') - expr = - rho*q*A/m - f = lambda x: - x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'Rutherforld scattering' or name == 101: - symbol = Z1, Z2, alpha, hbar, c, E, theta = symbols('Z_1 Z_2 alpha hbar c E theta') - expr = (Z1*Z2*alpha*hbar*c/(4*E*sin(theta/2)**2))**2 - f = lambda x: (x[:,[0]]*x[:,[1]]*x[:,[2]]*x[:,[3]]*x[:,[4]]/(4*x[:,[5]]*torch.sin(x[:,[6]]/2)**2))**2 - ranges = [[0,1],[0,1],[0,1],[0,1],[0,1],[0.5,2],[0.1*tpi,0.9*tpi]] - - if name == 'Friedman equation' or name == 102: - symbol = G, rho, kf, c, af = symbols('G rho k_f c a_f') - expr = sqrt(8*pi*G/3*rho-kf*c**2/af**2) - f = lambda x: torch.sqrt(8*tpi*x[:,[0]]/3*x[:,[1]] - x[:,[2]]*x[:,[3]]**2/x[:,[4]]**2) - ranges = [[1,2],[1,2],[0,1],[0,1],[1,2]] - - if name == 'Compton scattering' or name == 103: - symbol = E, m, c, theta = symbols('E m c theta') - expr = E/(1+E/(m*c**2)*(1-cos(theta))) - f = lambda x: x[:,[0]]/(1+x[:,[0]]/(x[:,[1]]*x[:,[2]]**2)*(1-torch.cos(x[:,[3]]))) - ranges = [[0,1],[0.5,2],[0.5,2],[0,2*tpi]] - - if name == 'Radiated gravitational wave power' or name == 104: - symbol = G, c, m1, m2, r = symbols('G c m_1 m_2 r') - expr = -32/5*G**4/c**5*(m1*m2)**2*(m1+m2)/r**5 - f = lambda x: -32/5*x[:,[0]]**4/x[:,[1]]**5*(x[:,[2]]*x[:,[3]])**2*(x[:,[2]]+x[:,[3]])/x[:,[4]]**5 - ranges = [[0,1],[0.5,2],[0,1],[0,1],[0.5,2]] - - if name == 'Relativistic aberration' or name == 105: - symbol = theta2, v, c = symbols('theta_2 v c') - expr = acos((cos(theta2)-v/c)/(1-v/c*cos(theta2))) - f = lambda x: torch.arccos((torch.cos(x[:,[0]])-x[:,[1]]/x[:,[2]])/(1-x[:,[1]]/x[:,[2]]*torch.cos(x[:,[0]]))) - ranges = [[0,tpi],[0,1],[1,2]] - - if name == 'N-slit diffraction' or name == 106: - symbol = I0, alpha, delta, N = symbols('I_0 alpha delta N') - expr = I0 * (sin(alpha/2)/(alpha/2)*sin(N*delta/2)/sin(delta/2))**2 - f = lambda x: x[:,[0]] * (torch.sin(x[:,[1]]/2)/(x[:,[1]]/2)*torch.sin(x[:,[3]]*x[:,[2]]/2)/torch.sin(x[:,[2]]/2))**2 - ranges = [[0,1],[0.1*tpi,0.9*tpi],[0.1*tpi,0.9*tpi],[0.5,1]] - - if name == 'Goldstein 3.16' or name == 107: - symbol = m, E, U, L, r = symbols('m E U L r') - expr = sqrt(2/m*(E-U-L**2/(2*m*r**2))) - f = lambda x: torch.sqrt(2/x[:,[0]]*(x[:,[1]]-x[:,[2]]-x[:,[3]]**2/(2*x[:,[0]]*x[:,[4]]**2))) - ranges = [[1,2],[2,3],[0,1],[0,1],[1,2]] - - if name == 'Goldstein 3.55' or name == 108: - symbol = m, kG, L, E, theta1, theta2 = symbols('m k_G L E theta_1 theta_2') - expr = m*kG/L**2*(1+sqrt(1+2*E*L**2/(m*kG**2))*cos(theta1-theta2)) - f = lambda x: x[:,[0]]*x[:,[1]]/x[:,[2]]**2*(1+torch.sqrt(1+2*x[:,[3]]*x[:,[2]]**2/(x[:,[0]]*x[:,[1]]**2))*torch.cos(x[:,[4]]-x[:,[5]])) - ranges = [[0.5,2],[0.5,2],[0.5,2],[0,1],[0,2*tpi],[0,2*tpi]] - - if name == 'Goldstein 3.64 (ellipse)' or name == 109: - symbol = d, alpha, theta1, theta2 = symbols('d alpha theta_1 theta_2') - expr = d*(1-alpha**2)/(1+alpha*cos(theta2-theta1)) - f = lambda x: x[:,[0]]*(1-x[:,[1]]**2)/(1+x[:,[1]]*torch.cos(x[:,[2]]-x[:,[3]])) - ranges = [[0,1],[0,0.9],[0,2*tpi],[0,2*tpi]] - - if name == 'Goldstein 3.74 (Kepler)' or name == 110: - symbol = d, G, m1, m2 = symbols('d G m_1 m_2') - expr = 2*pi*d**(3/2)/sqrt(G*(m1+m2)) - f = lambda x: 2*tpi*x[:,[0]]**(3/2)/torch.sqrt(x[:,[1]]*(x[:,[2]]+x[:,[3]])) - ranges = [[0,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'Goldstein 3.99' or name == 111: - symbol = eps, E, L, m, Z1, Z2, q = symbols('epsilon E L m Z_1 Z_2 q') - expr = sqrt(1+2*eps**2*E*L**2/(m*(Z1*Z2*q**2)**2)) - f = lambda x: torch.sqrt(1+2*x[:,[0]]**2*x[:,[1]]*x[:,[2]]**2/(x[:,[3]]*(x[:,[4]]*x[:,[5]]*x[:,[6]]**2)**2)) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'Goldstein 8.56' or name == 112: - symbol = p, q, A, c, m, Ve = symbols('p q A c m V_e') - expr = sqrt((p-q*A)**2*c**2+m**2*c**4) + q*Ve - f = lambda x: torch.sqrt((x[:,[0]]-x[:,[1]]*x[:,[2]])**2*x[:,[3]]**2+x[:,[4]]**2*x[:,[3]]**4) + x[:,[1]]*x[:,[5]] - ranges = [0,1] - - if name == 'Goldstein 12.80' or name == 113: - symbol = m, p, omega, x, alpha, y = symbols('m p omega x alpha y') - expr = 1/(2*m)*(p**2+m**2*omega**2*x**2*(1+alpha*y/x)) - f = lambda x: 1/(2*x[:,[0]]) * (x[:,[1]]**2+x[:,[0]]**2*x[:,[2]]**2*x[:,[3]]**2*(1+x[:,[4]]*x[:,[3]]/x[:,[5]])) - ranges = [[0.5,2],[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'Jackson 2.11' or name == 114: - symbol = q, eps, y, Ve, d = symbols('q epsilon y V_e d') - expr = q/(4*pi*eps*y**2)*(4*pi*eps*Ve*d-q*d*y**3/(y**2-d**2)**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,x[:,[2]]]**2)*(4*tpi*x[:,[1]]*x[:,[3]]*x[:,[4]]-x[:,[0]]*x[:,[4]]*x[:,[2]]**3/(x[:,[2]]**2-x[:,[4]]**2)**2) - ranges = [[0,1],[0.5,2],[1,2],[0,1],[0,1]] - - if name == 'Jackson 3.45' or name == 115: - symbol = q, r, d, alpha = symbols('q r d alpha') - expr = q/sqrt(r**2+d**2-2*d*r*cos(alpha)) - f = lambda x: x[:,[0]]/torch.sqrt(x[:,[1]]**2+x[:,[2]]**2-2*x[:,[1]]*x[:,[2]]*torch.cos(x[:,[3]])) - ranges = [[0,1],[0,1],[0,1],[0,2*tpi]] - - if name == 'Jackson 4.60' or name == 116: - symbol = Ef, theta, alpha, d, r = symbols('E_f theta alpha d r') - expr = Ef * cos(theta) * ((alpha-1)/(alpha+2) * d**3/r**2 - r) - f = lambda x: x[:,[0]] * torch.cos(x[:,[1]]) * ((x[:,[2]]-1)/(x[:,[2]]+2) * x[:,[3]]**3/x[:,[4]]**2 - x[:,[4]]) - ranges = [[0,1],[0,2*tpi],[0,2],[0,1],[0.5,2]] - - if name == 'Jackson 11.38 (Doppler)' or name == 117: - symbol = omega, v, c, theta = symbols('omega v c theta') - expr = sqrt(1-v**2/c**2)/(1+v/c*cos(theta))*omega - f = lambda x: torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2)/(1+x[:,[1]]/x[:,[2]]*torch.cos(x[:,[3]]))*x[:,[0]] - ranges = [[0,1],[0,1],[1,2],[0,2*tpi]] - - if name == 'Weinberg 15.2.1' or name == 118: - symbol = G, c, kf, af, H = symbols('G c k_f a_f H') - expr = 3/(8*pi*G)*(c**2*kf/af**2+H**2) - f = lambda x: 3/(8*tpi*x[:,[0]])*(x[:,[1]]**2*x[:,[2]]/x[:,[3]]**2+x[:,[4]]**2) - ranges = [[0.5,2],[0,1],[0,1],[0.5,2],[0,1]] - - if name == 'Weinberg 15.2.2' or name == 119: - symbol = G, c, kf, af, H, alpha = symbols('G c k_f a_f H alpha') - expr = -1/(8*pi*G)*(c**4*kf/af**2+c**2*H**2*(1-2*alpha)) - f = lambda x: -1/(8*tpi*x[:,[0]])*(x[:,[1]]**4*x[:,[2]]/x[:,[3]]**2 + x[:,[1]]**2*x[:,[4]]**2*(1-2*x[:,[5]])) - ranges = [[0.5,2],[0,1],[0,1],[0.5,2],[0,1],[0,1]] - - if name == 'Schwarz 13.132 (Klein-Nishina)' or name == 120: - symbol = alpha, hbar, m, c, omega0, omega, theta = symbols('alpha hbar m c omega_0 omega theta') - expr = pi*alpha**2*hbar**2/m**2/c**2*(omega0/omega)**2*(omega0/omega+omega/omega0-sin(theta)**2) - f = lambda x: tpi*x[:,[0]]**2*x[:,[1]]**2/x[:,[2]]**2/x[:,[3]]**2*(x[:,[4]]/x[:,[5]])**2*(x[:,[4]]/x[:,[5]]+x[:,[5]]/x[:,[4]]-torch.sin(x[:,[6]])**2) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2],[0.5,2],[0,2*tpi]] - - return symbol, expr, f, ranges \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/hypothesis-checkpoint.py b/kan/.ipynb_checkpoints/hypothesis-checkpoint.py deleted file mode 100644 index 4850f5098..000000000 --- a/kan/.ipynb_checkpoints/hypothesis-checkpoint.py +++ /dev/null @@ -1,695 +0,0 @@ -import numpy as np -import torch -from sklearn.linear_model import LinearRegression -from sympy.utilities.lambdify import lambdify -from sklearn.cluster import AgglomerativeClustering -from .utils import batch_jacobian, batch_hessian -from functools import reduce -from kan.utils import batch_jacobian, batch_hessian -import copy -import matplotlib.pyplot as plt -import sympy -from sympy.printing import latex - - -def detect_separability(model, x, mode='add', score_th=1e-2, res_th=1e-2, n_clusters=None, bias=0., verbose=False): - ''' - detect function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - n_clusters : None or int - the number of clusters - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - results (dictionary) - - Example1 - -------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 + torch.exp(x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> detect_separability(model, x, mode='add') - - Example2 - -------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> detect_separability(model, x, mode='mul') - ''' - results = {} - - if mode == 'add': - hessian = batch_hessian(model, x) - elif mode == 'mul': - compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F) - hessian = batch_hessian(compose(torch.log, torch.abs, lambda x: x+bias, model), x) - - std = torch.std(x, dim=0) - hessian_normalized = hessian * std[None,:] * std[:,None] - score_mat = torch.median(torch.abs(hessian_normalized), dim=0)[0] - results['hessian'] = score_mat - - dist_hard = (score_mat < score_th).float() - - if isinstance(n_clusters, int): - n_cluster_try = [n_clusters, n_clusters] - elif isinstance(n_clusters, list): - n_cluster_try = n_clusters - else: - n_cluster_try = [1,x.shape[1]] - - n_cluster_try = list(range(n_cluster_try[0], n_cluster_try[1]+1)) - - for n_cluster in n_cluster_try: - - clustering = AgglomerativeClustering( - metric='precomputed', - n_clusters=n_cluster, - linkage='complete', - ).fit(dist_hard) - - labels = clustering.labels_ - - groups = [list(np.where(labels == i)[0]) for i in range(n_cluster)] - blocks = [torch.sum(score_mat[groups[i]][:,groups[i]]) for i in range(n_cluster)] - block_sum = torch.sum(torch.stack(blocks)) - total_sum = torch.sum(score_mat) - residual_sum = total_sum - block_sum - residual_ratio = residual_sum / total_sum - - if verbose == True: - print(f'n_group={n_cluster}, residual_ratio={residual_ratio}') - - if residual_ratio < res_th: - results['n_groups'] = n_cluster - results['labels'] = list(labels) - results['groups'] = groups - - if results['n_groups'] > 1: - print(f'{mode} separability detected') - else: - print(f'{mode} separability not detected') - - return results - - -def batch_grad_normgrad(model, x, group, create_graph=False): - # x in shape (Batch, Length) - group_A = group - group_B = list(set(range(x.shape[1])) - set(group)) - - def jac(x): - input_grad = batch_jacobian(model, x, create_graph=True) - input_grad_A = input_grad[:,group_A] - norm = torch.norm(input_grad_A, dim=1, keepdim=True) + 1e-6 - input_grad_A_normalized = input_grad_A/norm - return input_grad_A_normalized - - def _jac_sum(x): - return jac(x).sum(dim=0) - - return torch.autograd.functional.jacobian(_jac_sum, x, create_graph=create_graph).permute(1,0,2)[:,:,group_B] - - -def get_dependence(model, x, group): - group_A = group - group_B = list(set(range(x.shape[1])) - set(group)) - grad_normgrad = batch_grad_normgrad(model, x, group=group) - std = torch.std(x, dim=0) - dependence = grad_normgrad * std[None,group_A,None] * std[None,None,group_B] - dependence = torch.median(torch.abs(dependence), dim=0)[0] - return dependence - -def test_symmetry(model, x, group, dependence_th=1e-3): - ''' - detect function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - group : a list of indices - dependence_th : float - threshold of dependence - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_symmetry(model, x, [1,2])) # True - >>> print(test_symmetry(model, x, [0,2])) # False - ''' - if len(group) == x.shape[1] or len(group) == 0: - return True - - dependence = get_dependence(model, x, group) - max_dependence = torch.max(dependence) - return max_dependence < dependence_th - - -def test_separability(model, x, groups, mode='add', threshold=1e-2, bias=0): - ''' - test function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_separability(model, x, [[0],[1,2]], mode='mul')) # True - >>> print(test_separability(model, x, [[0],[1,2]], mode='add')) # False - ''' - if mode == 'add': - hessian = batch_hessian(model, x) - elif mode == 'mul': - compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F) - hessian = batch_hessian(compose(torch.log, torch.abs, lambda x: x+bias, model), x) - - std = torch.std(x, dim=0) - hessian_normalized = hessian * std[None,:] * std[:,None] - score_mat = torch.median(torch.abs(hessian_normalized), dim=0)[0] - - sep_bool = True - - # internal test - n_groups = len(groups) - for i in range(n_groups): - for j in range(i+1, n_groups): - sep_bool *= torch.max(score_mat[groups[i]][:,groups[j]]) < threshold - - # external test - group_id = [x for xs in groups for x in xs] - nongroup_id = list(set(range(x.shape[1])) - set(group_id)) - if len(nongroup_id) > 0 and len(group_id) > 0: - sep_bool *= torch.max(score_mat[group_id][:,nongroup_id]) < threshold - - return sep_bool - -def test_general_separability(model, x, groups, threshold=1e-2): - ''' - test function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]**2+x[:,[2]]**2)**2 - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_general_separability(model, x, [[1],[0,2]])) # False - >>> print(test_general_separability(model, x, [[0],[1,2]])) # True - ''' - grad = batch_jacobian(model, x) - - gensep_bool = True - - n_groups = len(groups) - for i in range(n_groups): - for j in range(i+1,n_groups): - group_A = groups[i] - group_B = groups[j] - for member_A in group_A: - for member_B in group_B: - def func(x): - grad = batch_jacobian(model, x, create_graph=True) - return grad[:,[member_B]]/grad[:,[member_A]] - # test if func is multiplicative separable - gensep_bool *= test_separability(func, x, groups, mode='mul', threshold=threshold) - return gensep_bool - - -def get_molecule(model, x, sym_th=1e-3, verbose=True): - ''' - how variables are combined hierarchically - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - sym_th : float - threshold of symmetry - verbose : bool - - Returns: - -------- - list - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> get_molecule(model, x, verbose=False) - [[[0], [1], [2], [3], [4], [5], [6], [7]], - [[0, 1], [2, 3], [4, 5], [6, 7]], - [[0, 1, 2, 3], [4, 5, 6, 7]], - [[0, 1, 2, 3, 4, 5, 6, 7]]] - ''' - n = x.shape[1] - atoms = [[i] for i in range(n)] - molecules = [] - moleculess = [copy.deepcopy(atoms)] - already_full = False - n_layer = 0 - last_n_molecule = n - - while True: - - - pointer = 0 - current_molecule = [] - remove_atoms = [] - n_atom = 0 - - while len(atoms) > 0: - - # assemble molecule - atom = atoms[pointer] - if verbose: - print(current_molecule) - print(atom) - - if len(current_molecule) == 0: - full = False - current_molecule += atom - remove_atoms.append(atom) - n_atom += 1 - else: - # try assemble the atom to the molecule - if len(current_molecule+atom) == x.shape[1] and already_full == False and n_atom > 1 and n_layer > 0: - full = True - already_full = True - else: - full = False - if test_symmetry(model, x, current_molecule+atom, dependence_th=sym_th): - current_molecule += atom - remove_atoms.append(atom) - n_atom += 1 - - pointer += 1 - - if pointer == len(atoms) or full: - molecules.append(current_molecule) - if full: - molecules.append(atom) - remove_atoms.append(atom) - # remove molecules from atoms - for atom in remove_atoms: - atoms.remove(atom) - current_molecule = [] - remove_atoms = [] - pointer = 0 - - # if not making progress, terminate - if len(molecules) == last_n_molecule: - def flatten(xss): - return [x for xs in xss for x in xs] - moleculess.append([flatten(molecules)]) - break - else: - moleculess.append(copy.deepcopy(molecules)) - - last_n_molecule = len(molecules) - - if len(molecules) == 1: - break - - atoms = molecules - molecules = [] - - n_layer += 1 - - #print(n_layer, atoms) - - - # sort - depth = len(moleculess) - 1 - - for l in list(range(depth,0,-1)): - - molecules_sorted = [] - molecules_l = moleculess[l] - molecules_lm1 = moleculess[l-1] - - - for molecule_l in molecules_l: - start = 0 - for i in range(1,len(molecule_l)+1): - if molecule_l[start:i] in molecules_lm1: - - molecules_sorted.append(molecule_l[start:i]) - start = i - - moleculess[l-1] = molecules_sorted - - return moleculess - - -def get_tree_node(model, x, moleculess, sep_th=1e-2, skip_test=True): - ''' - get tree nodes - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - sep_th : float - threshold of separability - skip_test : bool - if True, don't test the property of each module (to save time) - - Returns: - -------- - arities : list of numbers - properties : list of strings - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> moleculess = get_molecule(model, x, verbose=False) - >>> get_tree_node(model, x, moleculess, skip_test=False) - ''' - arities = [] - properties = [] - - depth = len(moleculess) - 1 - - for l in range(depth): - molecules_l = copy.deepcopy(moleculess[l]) - molecules_lp1 = copy.deepcopy(moleculess[l+1]) - arity_l = [] - property_l = [] - - for molecule in molecules_lp1: - start = 0 - arity = 0 - groups = [] - for i in range(1,len(molecule)+1): - if molecule[start:i] in molecules_l: - groups.append(molecule[start:i]) - start = i - arity += 1 - arity_l.append(arity) - - if arity == 1: - property = 'Id' - else: - property = '' - # test property - if skip_test: - gensep_bool = False - else: - gensep_bool = test_general_separability(model, x, groups, threshold=sep_th) - - if gensep_bool: - property = 'GS' - if l == depth - 1: - if skip_test: - add_bool = False - mul_bool = False - else: - add_bool = test_separability(model, x, groups, mode='add', threshold=sep_th) - mul_bool = test_separability(model, x, groups, mode='mul', threshold=sep_th) - if add_bool: - property = 'Add' - if mul_bool: - property = 'Mul' - - - property_l.append(property) - - - arities.append(arity_l) - properties.append(property_l) - - return arities, properties - - -def plot_tree(model, x, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): - ''' - get tree graph - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - in_var : list of symbols - input variables - style : str - 'tree' or 'box' - sym_th : float - threshold of symmetry - sep_th : float - threshold of separability - skip_sep_test : bool - if True, don't test the property of each module (to save time) - verbose : bool - - Returns: - -------- - a tree graph - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> plot_tree(model, x) - ''' - moleculess = get_molecule(model, x, sym_th=sym_th, verbose=verbose) - arities, properties = get_tree_node(model, x, moleculess, sep_th=sep_th, skip_test=skip_sep_test) - - n = x.shape[1] - var = None - - in_vars = [] - - if in_var == None: - for ii in range(1, n + 1): - exec(f"x{ii} = sympy.Symbol('x_{ii}')") - exec(f"in_vars.append(x{ii})") - elif type(var[0]) == Symbol: - in_vars = var - else: - in_vars = [sympy.symbols(var_) for var_ in var] - - - def flatten(xss): - return [x for xs in xss for x in xs] - - def myrectangle(center_x, center_y, width_x, width_y): - plt.plot([center_x - width_x/2, center_x + width_x/2], [center_y + width_y/2, center_y + width_y/2], color='k') # up - plt.plot([center_x - width_x/2, center_x + width_x/2], [center_y - width_y/2, center_y - width_y/2], color='k') # down - plt.plot([center_x - width_x/2, center_x - width_x/2], [center_y - width_y/2, center_y + width_y/2], color='k') # left - plt.plot([center_x + width_x/2, center_x + width_x/2], [center_y - width_y/2, center_y + width_y/2], color='k') # left - - depth = len(moleculess) - - delta = 1/n - a = 0.3 - b = 0.15 - y0 = 0.5 - - - # draw rectangles - for l in range(depth-1): - molecules = moleculess[l+1] - n_molecule = len(molecules) - - centers = [] - - acc_arity = 0 - - for i in range(n_molecule): - start_id = len(flatten(molecules[:i])) - end_id = len(flatten(molecules[:i+1])) - - center_x = (start_id + (end_id - 1 - start_id)/2) * delta + delta/2 - center_y = (l+1/2)*y0 - width_x = (end_id - start_id - 1 + 2*a)*delta - width_y = 2*b - - # add text (numbers) on rectangles - if style == 'box': - myrectangle(center_x, center_y, width_x, width_y) - plt.text(center_x, center_y, properties[l][i], fontsize=15, horizontalalignment='center', - verticalalignment='center') - elif style == 'tree': - # if 'GS', no rectangle, n=arity tilted lines - # if 'Id', no rectangle, n=arity vertical lines - # if 'Add' or 'Mul'. rectangle, "+" or "x" - # if '', rectangle - property = properties[l][i] - if property == 'GS' or property == 'Add' or property == 'Mul': - color = 'blue' - arity = arities[l][i] - for j in range(arity): - - if l == 0: - # x = (start_id + j) * delta + delta/2, center_x - # y = center_y - b, center_y + b - plt.plot([(start_id + j) * delta + delta/2, center_x], [center_y - b, center_y + b], color=color) - else: - # x = last_centers[acc_arity:acc_arity+arity], center_x - # y = center_y - b, center_y + b - plt.plot([last_centers[acc_arity+j], center_x], [center_y - b, center_y + b], color=color) - - acc_arity += arity - - if property == 'Add' or property == 'Mul': - if property == 'Add': - symbol = '+' - else: - symbol = '*' - - plt.text(center_x, center_y + b, symbol, horizontalalignment='center', - verticalalignment='center', color='red', fontsize=40) - if property == 'Id': - plt.plot([center_x, center_x], [center_y-width_y/2, center_y+width_y/2], color='black') - - if property == '': - myrectangle(center_x, center_y, width_x, width_y) - - - - # connections to the next layer - plt.plot([center_x, center_x], [center_y+width_y/2, center_y+y0-width_y/2], color='k') - centers.append(center_x) - last_centers = copy.deepcopy(centers) - - # connections from input variables to the first layer - for i in range(n): - x_ = (i + 1/2) * delta - # connections to the next layer - plt.plot([x_, x_], [0, y0/2-width_y/2], color='k') - plt.text(x_, -0.05*(depth-1), f'${latex(in_vars[moleculess[0][i][0]])}$', fontsize=20, horizontalalignment='center') - plt.xlim(0,1) - #plt.ylim(0,1); - plt.axis('off'); - plt.show() - - -def test_symmetry_var(model, x, input_vars, symmetry_var): - ''' - test symmetry - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - input_vars : list of sympy symbols - symmetry_var : sympy expression - - Returns: - -------- - cosine similarity - - Example - ------- - >>> from kan.hypothesis import * - >>> from sympy import * - >>> model = lambda x: x[:,[0]] * (x[:,[1]] + x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,8)) - >>> input_vars = a, b, c = symbols('a b c') - >>> symmetry_var = b + c - >>> test_symmetry_var(model, x, input_vars, symmetry_var); - >>> symmetry_var = b * c - >>> test_symmetry_var(model, x, input_vars, symmetry_var); - ''' - orig_vars = input_vars - sym_var = symmetry_var - - # gradients wrt to input (model) - input_grad = batch_jacobian(model, x) - - # gradients wrt to input (symmetry var) - func = lambdify(orig_vars, sym_var,'numpy') # returns a numpy-ready function - - func2 = lambda x: func(*[x[:,[i]] for i in range(len(orig_vars))]) - sym_grad = batch_jacobian(func2, x) - - # get id - idx = [] - sym_symbols = list(sym_var.free_symbols) - for sym_symbol in sym_symbols: - for j in range(len(orig_vars)): - if sym_symbol == orig_vars[j]: - idx.append(j) - - input_grad_part = input_grad[:,idx] - sym_grad_part = sym_grad[:,idx] - - cossim = torch.abs(torch.sum(input_grad_part * sym_grad_part, dim=1)/(torch.norm(input_grad_part, dim=1)*torch.norm(sym_grad_part, dim=1))) - - ratio = torch.sum(cossim > 0.9)/len(cossim) - - print(f'{100*ratio}% data have more than 0.9 cosine similarity') - if ratio > 0.9: - print('suggesting symmetry') - else: - print('not suggesting symmetry') - - return cossim \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/spline-checkpoint.py b/kan/.ipynb_checkpoints/spline-checkpoint.py deleted file mode 100644 index 6953bf081..000000000 --- a/kan/.ipynb_checkpoints/spline-checkpoint.py +++ /dev/null @@ -1,144 +0,0 @@ -import torch - - -def B_batch(x, grid, k=0, extend=True, device='cpu'): - ''' - evaludate x on B-spline bases - - Args: - ----- - x : 2D torch.tensor - inputs, shape (number of splines, number of samples) - grid : 2D torch.tensor - grids, shape (number of splines, number of grid points) - k : int - the piecewise polynomial order of splines. - extend : bool - If True, k points are extended on both ends. If False, no extension (zero boundary condition). Default: True - device : str - devicde - - Returns: - -------- - spline values : 3D torch.tensor - shape (batch, in_dim, G+k). G: the number of grid intervals, k: spline order. - - Example - ------- - >>> from kan.spline import B_batch - >>> x = torch.rand(100,2) - >>> grid = torch.linspace(-1,1,steps=11)[None, :].expand(2, 11) - >>> B_batch(x, grid, k=3).shape - ''' - - x = x.unsqueeze(dim=2) - grid = grid.unsqueeze(dim=0) - - if k == 0: - value = (x >= grid[:, :, :-1]) * (x < grid[:, :, 1:]) - else: - B_km1 = B_batch(x[:,:,0], grid=grid[0], k=k - 1) - - value = (x - grid[:, :, :-(k + 1)]) / (grid[:, :, k:-1] - grid[:, :, :-(k + 1)]) * B_km1[:, :, :-1] + ( - grid[:, :, k + 1:] - x) / (grid[:, :, k + 1:] - grid[:, :, 1:(-k)]) * B_km1[:, :, 1:] - - # in case grid is degenerate - value = torch.nan_to_num(value) - return value - - - -def coef2curve(x_eval, grid, coef, k, device="cpu"): - ''' - converting B-spline coefficients to B-spline curves. Evaluate x on B-spline curves (summing up B_batch results over B-spline basis). - - Args: - ----- - x_eval : 2D torch.tensor - shape (batch, in_dim) - grid : 2D torch.tensor - shape (in_dim, G+2k). G: the number of grid intervals; k: spline order. - coef : 3D torch.tensor - shape (in_dim, out_dim, G+k) - k : int - the piecewise polynomial order of splines. - device : str - devicde - - Returns: - -------- - y_eval : 3D torch.tensor - shape (batch, in_dim, out_dim) - - ''' - - b_splines = B_batch(x_eval, grid, k=k) - y_eval = torch.einsum('ijk,jlk->ijl', b_splines, coef.to(b_splines.device)) - - return y_eval - - -def curve2coef(x_eval, y_eval, grid, k): - ''' - converting B-spline curves to B-spline coefficients using least squares. - - Args: - ----- - x_eval : 2D torch.tensor - shape (batch, in_dim) - y_eval : 3D torch.tensor - shape (batch, in_dim, out_dim) - grid : 2D torch.tensor - shape (in_dim, grid+2*k) - k : int - spline order - lamb : float - regularized least square lambda - - Returns: - -------- - coef : 3D torch.tensor - shape (in_dim, out_dim, G+k) - ''' - #print('haha', x_eval.shape, y_eval.shape, grid.shape) - batch = x_eval.shape[0] - in_dim = x_eval.shape[1] - out_dim = y_eval.shape[2] - n_coef = grid.shape[1] - k - 1 - mat = B_batch(x_eval, grid, k) - mat = mat.permute(1,0,2)[:,None,:,:].expand(in_dim, out_dim, batch, n_coef) - #print('mat', mat.shape) - y_eval = y_eval.permute(1,2,0).unsqueeze(dim=3) - #print('y_eval', y_eval.shape) - device = mat.device - - #coef = torch.linalg.lstsq(mat, y_eval, driver='gelsy' if device == 'cpu' else 'gels').solution[:,:,:,0] - try: - coef = torch.linalg.lstsq(mat, y_eval).solution[:,:,:,0] - except: - print('lstsq failed') - - # manual psuedo-inverse - '''lamb=1e-8 - XtX = torch.einsum('ijmn,ijnp->ijmp', mat.permute(0,1,3,2), mat) - Xty = torch.einsum('ijmn,ijnp->ijmp', mat.permute(0,1,3,2), y_eval) - n1, n2, n = XtX.shape[0], XtX.shape[1], XtX.shape[2] - identity = torch.eye(n,n)[None, None, :, :].expand(n1, n2, n, n).to(device) - A = XtX + lamb * identity - B = Xty - coef = (A.pinverse() @ B)[:,:,:,0]''' - - return coef - - -def extend_grid(grid, k_extend=0): - ''' - extend grid - ''' - h = (grid[:, [-1]] - grid[:, [0]]) / (grid.shape[1] - 1) - - for i in range(k_extend): - grid = torch.cat([grid[:, [0]] - h, grid], dim=1) - grid = torch.cat([grid, grid[:, [-1]] + h], dim=1) - - return grid \ No newline at end of file diff --git a/kan/.ipynb_checkpoints/utils-checkpoint.py b/kan/.ipynb_checkpoints/utils-checkpoint.py deleted file mode 100644 index abb4d558b..000000000 --- a/kan/.ipynb_checkpoints/utils-checkpoint.py +++ /dev/null @@ -1,594 +0,0 @@ -import numpy as np -import torch -from sklearn.linear_model import LinearRegression -import sympy -import yaml -from sympy.utilities.lambdify import lambdify -import re - -# sigmoid = sympy.Function('sigmoid') -# name: (torch implementation, sympy implementation) - -# singularity protection functions -f_inv = lambda x, y_th: ((x_th := 1/y_th), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x) * (torch.abs(x) >= x_th)) -f_inv2 = lambda x, y_th: ((x_th := 1/y_th**(1/2)), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**2) * (torch.abs(x) >= x_th)) -f_inv3 = lambda x, y_th: ((x_th := 1/y_th**(1/3)), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**3) * (torch.abs(x) >= x_th)) -f_inv4 = lambda x, y_th: ((x_th := 1/y_th**(1/4)), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**4) * (torch.abs(x) >= x_th)) -f_inv5 = lambda x, y_th: ((x_th := 1/y_th**(1/5)), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**5) * (torch.abs(x) >= x_th)) -f_sqrt = lambda x, y_th: ((x_th := 1/y_th**2), x_th/y_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(torch.sqrt(torch.abs(x))*torch.sign(x)) * (torch.abs(x) >= x_th)) -f_power1d5 = lambda x, y_th: torch.abs(x)**1.5 -f_invsqrt = lambda x, y_th: ((x_th := 1/y_th**2), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/torch.sqrt(torch.abs(x))) * (torch.abs(x) >= x_th)) -f_log = lambda x, y_th: ((x_th := torch.e**(-y_th)), - y_th * (torch.abs(x) < x_th) + torch.nan_to_num(torch.log(torch.abs(x))) * (torch.abs(x) >= x_th)) -f_tan = lambda x, y_th: ((clip := x % torch.pi), (delta := torch.pi/2-torch.arctan(y_th)), - y_th/delta * (clip - torch.pi/2) * (torch.abs(clip - torch.pi/2) < delta) + torch.nan_to_num(torch.tan(clip)) * (torch.abs(clip - torch.pi/2) >= delta)) -f_arctanh = lambda x, y_th: ((delta := 1-torch.tanh(y_th) + 1e-4), y_th * torch.sign(x) * (torch.abs(x) > 1 - delta) + torch.nan_to_num(torch.arctanh(x)) * (torch.abs(x) <= 1 - delta)) -f_arcsin = lambda x, y_th: ((), torch.pi/2 * torch.sign(x) * (torch.abs(x) > 1) + torch.nan_to_num(torch.arcsin(x)) * (torch.abs(x) <= 1)) -f_arccos = lambda x, y_th: ((), torch.pi/2 * (1-torch.sign(x)) * (torch.abs(x) > 1) + torch.nan_to_num(torch.arccos(x)) * (torch.abs(x) <= 1)) -f_exp = lambda x, y_th: ((x_th := torch.log(y_th)), y_th * (x > x_th) + torch.exp(x) * (x <= x_th)) - -SYMBOLIC_LIB = {'x': (lambda x: x, lambda x: x, 1, lambda x, y_th: ((), x)), - 'x^2': (lambda x: x**2, lambda x: x**2, 2, lambda x, y_th: ((), x**2)), - 'x^3': (lambda x: x**3, lambda x: x**3, 3, lambda x, y_th: ((), x**3)), - 'x^4': (lambda x: x**4, lambda x: x**4, 3, lambda x, y_th: ((), x**4)), - 'x^5': (lambda x: x**5, lambda x: x**5, 3, lambda x, y_th: ((), x**5)), - '1/x': (lambda x: 1/x, lambda x: 1/x, 2, f_inv), - '1/x^2': (lambda x: 1/x**2, lambda x: 1/x**2, 2, f_inv2), - '1/x^3': (lambda x: 1/x**3, lambda x: 1/x**3, 3, f_inv3), - '1/x^4': (lambda x: 1/x**4, lambda x: 1/x**4, 4, f_inv4), - '1/x^5': (lambda x: 1/x**5, lambda x: 1/x**5, 5, f_inv5), - 'sqrt': (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), - 'x^0.5': (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), - 'x^1.5': (lambda x: torch.sqrt(x)**3, lambda x: sympy.sqrt(x)**3, 4, f_power1d5), - '1/sqrt(x)': (lambda x: 1/torch.sqrt(x), lambda x: 1/sympy.sqrt(x), 2, f_invsqrt), - '1/x^0.5': (lambda x: 1/torch.sqrt(x), lambda x: 1/sympy.sqrt(x), 2, f_invsqrt), - 'exp': (lambda x: torch.exp(x), lambda x: sympy.exp(x), 2, f_exp), - 'log': (lambda x: torch.log(x), lambda x: sympy.log(x), 2, f_log), - 'abs': (lambda x: torch.abs(x), lambda x: sympy.Abs(x), 3, lambda x, y_th: ((), torch.abs(x))), - 'sin': (lambda x: torch.sin(x), lambda x: sympy.sin(x), 2, lambda x, y_th: ((), torch.sin(x))), - 'cos': (lambda x: torch.cos(x), lambda x: sympy.cos(x), 2, lambda x, y_th: ((), torch.cos(x))), - 'tan': (lambda x: torch.tan(x), lambda x: sympy.tan(x), 3, f_tan), - 'tanh': (lambda x: torch.tanh(x), lambda x: sympy.tanh(x), 3, lambda x, y_th: ((), torch.tanh(x))), - 'sgn': (lambda x: torch.sign(x), lambda x: sympy.sign(x), 3, lambda x, y_th: ((), torch.sign(x))), - 'arcsin': (lambda x: torch.arcsin(x), lambda x: sympy.asin(x), 4, f_arcsin), - 'arccos': (lambda x: torch.arccos(x), lambda x: sympy.acos(x), 4, f_arccos), - 'arctan': (lambda x: torch.arctan(x), lambda x: sympy.atan(x), 4, lambda x, y_th: ((), torch.arctan(x))), - 'arctanh': (lambda x: torch.arctanh(x), lambda x: sympy.atanh(x), 4, f_arctanh), - '0': (lambda x: x*0, lambda x: x*0, 0, lambda x, y_th: ((), x*0)), - 'gaussian': (lambda x: torch.exp(-x**2), lambda x: sympy.exp(-x**2), 3, lambda x, y_th: ((), torch.exp(-x**2))), - #'cosh': (lambda x: torch.cosh(x), lambda x: sympy.cosh(x), 5), - #'sigmoid': (lambda x: torch.sigmoid(x), sympy.Function('sigmoid'), 4), - #'relu': (lambda x: torch.relu(x), relu), -} - -def create_dataset(f, - n_var=2, - f_mode = 'col', - ranges = [-1,1], - train_num=1000, - test_num=1000, - normalize_input=False, - normalize_label=False, - device='cpu', - seed=0): - ''' - create dataset - - Args: - ----- - f : function - the symbolic formula used to create the synthetic dataset - ranges : list or np.array; shape (2,) or (n_var, 2) - the range of input variables. Default: [-1,1]. - train_num : int - the number of training samples. Default: 1000. - test_num : int - the number of test samples. Default: 1000. - normalize_input : bool - If True, apply normalization to inputs. Default: False. - normalize_label : bool - If True, apply normalization to labels. Default: False. - device : str - device. Default: 'cpu'. - seed : int - random seed. Default: 0. - - Returns: - -------- - dataset : dic - Train/test inputs/labels are dataset['train_input'], dataset['train_label'], - dataset['test_input'], dataset['test_label'] - - Example - ------- - >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) - >>> dataset = create_dataset(f, n_var=2, train_num=100) - >>> dataset['train_input'].shape - torch.Size([100, 2]) - ''' - - np.random.seed(seed) - torch.manual_seed(seed) - - if len(np.array(ranges).shape) == 1: - ranges = np.array(ranges * n_var).reshape(n_var,2) - else: - ranges = np.array(ranges) - - - train_input = torch.zeros(train_num, n_var) - test_input = torch.zeros(test_num, n_var) - for i in range(n_var): - train_input[:,i] = torch.rand(train_num,)*(ranges[i,1]-ranges[i,0])+ranges[i,0] - test_input[:,i] = torch.rand(test_num,)*(ranges[i,1]-ranges[i,0])+ranges[i,0] - - if f_mode == 'col': - train_label = f(train_input) - test_label = f(test_input) - elif f_mode == 'row': - train_label = f(train_input.T) - test_label = f(test_input.T) - else: - print(f'f_mode {f_mode} not recognized') - - # if has only 1 dimension - if len(train_label.shape) == 1: - train_label = train_label.unsqueeze(dim=1) - test_label = test_label.unsqueeze(dim=1) - - def normalize(data, mean, std): - return (data-mean)/std - - if normalize_input == True: - mean_input = torch.mean(train_input, dim=0, keepdim=True) - std_input = torch.std(train_input, dim=0, keepdim=True) - train_input = normalize(train_input, mean_input, std_input) - test_input = normalize(test_input, mean_input, std_input) - - if normalize_label == True: - mean_label = torch.mean(train_label, dim=0, keepdim=True) - std_label = torch.std(train_label, dim=0, keepdim=True) - train_label = normalize(train_label, mean_label, std_label) - test_label = normalize(test_label, mean_label, std_label) - - dataset = {} - dataset['train_input'] = train_input.to(device) - dataset['test_input'] = test_input.to(device) - - dataset['train_label'] = train_label.to(device) - dataset['test_label'] = test_label.to(device) - - return dataset - - - -def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, iteration=3, verbose=True, device='cpu'): - ''' - fit a, b, c, d such that - - .. math:: - |y-(cf(ax+b)+d)|^2 - - is minimized. Both x and y are 1D array. Sweep a and b, find the best fitted model. - - Args: - ----- - x : 1D array - x values - y : 1D array - y values - fun : function - symbolic function - a_range : tuple - sweeping range of a - b_range : tuple - sweeping range of b - grid_num : int - number of steps along a and b - iteration : int - number of zooming in - verbose : bool - print extra information if True - device : str - device - - Returns: - -------- - a_best : float - best fitted a - b_best : float - best fitted b - c_best : float - best fitted c - d_best : float - best fitted d - r2_best : float - best r2 (coefficient of determination) - - Example - ------- - >>> num = 100 - >>> x = torch.linspace(-1,1,steps=num) - >>> noises = torch.normal(0,1,(num,)) * 0.02 - >>> y = 5.0*torch.sin(3.0*x + 2.0) + 0.7 + noises - >>> fit_params(x, y, torch.sin) - r2 is 0.9999727010726929 - (tensor([2.9982, 1.9996, 5.0053, 0.7011]), tensor(1.0000)) - ''' - # fit a, b, c, d such that y=c*fun(a*x+b)+d; both x and y are 1D array. - # sweep a and b, choose the best fitted model - for _ in range(iteration): - a_ = torch.linspace(a_range[0], a_range[1], steps=grid_number, device=device) - b_ = torch.linspace(b_range[0], b_range[1], steps=grid_number, device=device) - a_grid, b_grid = torch.meshgrid(a_, b_, indexing='ij') - post_fun = fun(a_grid[None,:,:] * x[:,None,None] + b_grid[None,:,:]) - x_mean = torch.mean(post_fun, dim=[0], keepdim=True) - y_mean = torch.mean(y, dim=[0], keepdim=True) - numerator = torch.sum((post_fun - x_mean)*(y-y_mean)[:,None,None], dim=0)**2 - denominator = torch.sum((post_fun - x_mean)**2, dim=0)*torch.sum((y - y_mean)[:,None,None]**2, dim=0) - r2 = numerator/(denominator+1e-4) - r2 = torch.nan_to_num(r2) - - - best_id = torch.argmax(r2) - a_id, b_id = torch.div(best_id, grid_number, rounding_mode='floor'), best_id % grid_number - - - if a_id == 0 or a_id == grid_number - 1 or b_id == 0 or b_id == grid_number - 1: - if _ == 0 and verbose==True: - print('Best value at boundary.') - if a_id == 0: - a_range = [a_[0], a_[1]] - if a_id == grid_number - 1: - a_range = [a_[-2], a_[-1]] - if b_id == 0: - b_range = [b_[0], b_[1]] - if b_id == grid_number - 1: - b_range = [b_[-2], b_[-1]] - - else: - a_range = [a_[a_id-1], a_[a_id+1]] - b_range = [b_[b_id-1], b_[b_id+1]] - - a_best = a_[a_id] - b_best = b_[b_id] - post_fun = fun(a_best * x + b_best) - r2_best = r2[a_id, b_id] - - if verbose == True: - print(f"r2 is {r2_best}") - if r2_best < 0.9: - print(f'r2 is not very high, please double check if you are choosing the correct symbolic function.') - - post_fun = torch.nan_to_num(post_fun) - reg = LinearRegression().fit(post_fun[:,None].detach().cpu().numpy(), y.detach().cpu().numpy()) - c_best = torch.from_numpy(reg.coef_)[0].to(device) - d_best = torch.from_numpy(np.array(reg.intercept_)).to(device) - return torch.stack([a_best, b_best, c_best, d_best]), r2_best - - -def sparse_mask(in_dim, out_dim): - ''' - get sparse mask - ''' - in_coord = torch.arange(in_dim) * 1/in_dim + 1/(2*in_dim) - out_coord = torch.arange(out_dim) * 1/out_dim + 1/(2*out_dim) - - dist_mat = torch.abs(out_coord[:,None] - in_coord[None,:]) - in_nearest = torch.argmin(dist_mat, dim=0) - in_connection = torch.stack([torch.arange(in_dim), in_nearest]).permute(1,0) - out_nearest = torch.argmin(dist_mat, dim=1) - out_connection = torch.stack([out_nearest, torch.arange(out_dim)]).permute(1,0) - all_connection = torch.cat([in_connection, out_connection], dim=0) - mask = torch.zeros(in_dim, out_dim) - mask[all_connection[:,0], all_connection[:,1]] = 1. - - return mask - - -def add_symbolic(name, fun, c=1, fun_singularity=None): - ''' - add a symbolic function to library - - Args: - ----- - name : str - name of the function - fun : fun - torch function or lambda function - - Returns: - -------- - None - - Example - ------- - >>> print(SYMBOLIC_LIB['Bessel']) - KeyError: 'Bessel' - >>> add_symbolic('Bessel', torch.special.bessel_j0) - >>> print(SYMBOLIC_LIB['Bessel']) - (, Bessel) - ''' - exec(f"globals()['{name}'] = sympy.Function('{name}')") - if fun_singularity==None: - fun_singularity = fun - SYMBOLIC_LIB[name] = (fun, globals()[name], c, fun_singularity) - - -def ex_round(ex1, n_digit): - ''' - rounding the numbers in an expression to certain floating points - - Args: - ----- - ex1 : sympy expression - n_digit : int - - Returns: - -------- - ex2 : sympy expression - - Example - ------- - >>> from kan.utils import * - >>> from sympy import * - >>> input_vars = a, b = symbols('a b') - >>> expression = 3.14534242 * exp(sin(pi*a) + b**2) - 2.32345402 - >>> ex_round(expression, 2) - ''' - ex2 = ex1 - for a in sympy.preorder_traversal(ex1): - if isinstance(a, sympy.Float): - ex2 = ex2.subs(a, round(a, n_digit)) - return ex2 - - -def augment_input(orig_vars, aux_vars, x): - ''' - augment inputs - - Args: - ----- - orig_vars : list of sympy symbols - aux_vars : list of auxiliary symbols - x : inputs - - Returns: - -------- - augmented inputs - - Example - ------- - >>> from kan.utils import * - >>> from sympy import * - >>> orig_vars = a, b = symbols('a b') - >>> aux_vars = [a + b, a * b] - >>> x = torch.rand(100, 2) - >>> augment_input(orig_vars, aux_vars, x).shape - ''' - # if x is a tensor - if isinstance(x, torch.Tensor): - - aux_values = torch.tensor([]).to(x.device) - - for aux_var in aux_vars: - func = lambdify(orig_vars, aux_var,'numpy') # returns a numpy-ready function - aux_value = torch.from_numpy(func(*[x[:,[i]].numpy() for i in range(len(orig_vars))])) - aux_values = torch.cat([aux_values, aux_value], dim=1) - - x = torch.cat([aux_values, x], dim=1) - - # if x is a dataset - elif isinstance(x, dict): - x['train_input'] = augment_input(orig_vars, aux_vars, x['train_input']) - x['test_input'] = augment_input(orig_vars, aux_vars, x['test_input']) - - return x - - -def batch_jacobian(func, x, create_graph=False, mode='scalar'): - ''' - jacobian - - Args: - ----- - func : function or model - x : inputs - create_graph : bool - - Returns: - -------- - jacobian - - Example - ------- - >>> from kan.utils import batch_jacobian - >>> x = torch.normal(0,1,size=(100,2)) - >>> model = lambda x: x[:,[0]] + x[:,[1]] - >>> batch_jacobian(model, x) - ''' - # x in shape (Batch, Length) - def _func_sum(x): - return func(x).sum(dim=0) - if mode == 'scalar': - return torch.autograd.functional.jacobian(_func_sum, x, create_graph=create_graph)[0] - elif mode == 'vector': - return torch.autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2) - -def batch_hessian(model, x, create_graph=False): - ''' - hessian - - Args: - ----- - func : function or model - x : inputs - create_graph : bool - - Returns: - -------- - jacobian - - Example - ------- - >>> from kan.utils import batch_hessian - >>> x = torch.normal(0,1,size=(100,2)) - >>> model = lambda x: x[:,[0]]**2 + x[:,[1]]**2 - >>> batch_hessian(model, x) - ''' - # x in shape (Batch, Length) - jac = lambda x: batch_jacobian(model, x, create_graph=True) - def _jac_sum(x): - return jac(x).sum(dim=0) - return torch.autograd.functional.jacobian(_jac_sum, x, create_graph=create_graph).permute(1,0,2) - - -def create_dataset_from_data(inputs, labels, train_ratio=0.8, device='cpu'): - ''' - create dataset from data - - Args: - ----- - inputs : 2D torch.float - labels : 2D torch.float - train_ratio : float - the ratio of training fraction - device : str - - Returns: - -------- - dataset (dictionary) - - Example - ------- - >>> from kan.utils import create_dataset_from_data - >>> x = torch.normal(0,1,size=(100,2)) - >>> y = torch.normal(0,1,size=(100,1)) - >>> dataset = create_dataset_from_data(x, y) - >>> dataset['train_input'].shape - ''' - num = inputs.shape[0] - train_id = np.random.choice(num, int(num*train_ratio), replace=False) - test_id = list(set(np.arange(num)) - set(train_id)) - dataset = {} - dataset['train_input'] = inputs[train_id].detach().to(device) - dataset['test_input'] = inputs[test_id].detach().to(device) - dataset['train_label'] = labels[train_id].detach().to(device) - dataset['test_label'] = labels[test_id].detach().to(device) - - return dataset - - -def get_derivative(model, inputs, labels, derivative='hessian', loss_mode='pred', reg_metric='w', lamb=0., lamb_l1=1., lamb_entropy=0.): - ''' - compute the jacobian/hessian of loss wrt to model parameters - - Args: - ----- - inputs : 2D torch.float - labels : 2D torch.float - derivative : str - 'jacobian' or 'hessian' - device : str - - Returns: - -------- - jacobian or hessian - ''' - def get_mapping(model): - - mapping = {} - name = 'model1' - - keys = list(model.state_dict().keys()) - for key in keys: - - y = re.findall(".[0-9]+", key) - if len(y) > 0: - y = y[0][1:] - x = re.split(".[0-9]+", key) - mapping[key] = name + '.' + x[0] + '[' + y + ']' + x[1] - - - y = re.findall("_[0-9]+", key) - if len(y) > 0: - y = y[0][1:] - x = re.split(".[0-9]+", key) - mapping[key] = name + '.' + x[0] + '[' + y + ']' - - return mapping - - - #model1 = copy.deepcopy(model) - model1 = model.copy() - mapping = get_mapping(model) - - # collect keys and shapes - keys = list(model.state_dict().keys()) - shapes = [] - - for params in model.parameters(): - shapes.append(params.shape) - - - # turn a flattened vector to model params - def param2statedict(p, keys, shapes): - - new_state_dict = {} - - start = 0 - n_group = len(keys) - for i in range(n_group): - shape = shapes[i] - n_params = torch.prod(torch.tensor(shape)) - new_state_dict[keys[i]] = p[start:start+n_params].reshape(shape) - start += n_params - - return new_state_dict - - def differentiable_load_state_dict(mapping, state_dict, model1): - - for key in keys: - if mapping[key][-1] != ']': - exec(f"del {mapping[key]}") - exec(f"{mapping[key]} = state_dict[key]") - - - # input: p, output: output - def get_param2loss_fun(inputs, labels): - - def param2loss_fun(p): - - p = p[0] - state_dict = param2statedict(p, keys, shapes) - # this step is non-differentiable - #model.load_state_dict(state_dict) - differentiable_load_state_dict(mapping, state_dict, model1) - if loss_mode == 'pred': - pred_loss = torch.mean((model1(inputs) - labels)**2, dim=(0,1), keepdim=True) - loss = pred_loss - elif loss_mode == 'reg': - reg_loss = model1.get_reg(reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy) * torch.ones(1,1) - loss = reg_loss - elif loss_mode == 'all': - pred_loss = torch.mean((model1(inputs) - labels)**2, dim=(0,1), keepdim=True) - reg_loss = model1.get_reg(reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy) * torch.ones(1,1) - loss = pred_loss + lamb * reg_loss - return loss - - return param2loss_fun - - fun = get_param2loss_fun(inputs, labels) - p = model2param(model)[None,:] - if derivative == 'hessian': - result = batch_hessian(fun, p) - elif derivative == 'jacobian': - result = batch_jacobian(fun, p) - return result - -def model2param(model): - ''' - turn model parameters into a flattened vector - ''' - p = torch.tensor([]).to(model.device) - for params in model.parameters(): - p = torch.cat([p, params.reshape(-1,)], dim=0) - return p diff --git a/kan/KANLayer.py b/kan/KANLayer.py index b880bfe8b..b0b445d0e 100644 --- a/kan/KANLayer.py +++ b/kan/KANLayer.py @@ -8,7 +8,7 @@ class KANLayer(nn.Module): """ KANLayer class - + Attributes: ----------- @@ -41,10 +41,28 @@ class KANLayer(nn.Module): device """ - def __init__(self, in_dim=3, out_dim=2, num=5, k=3, noise_scale=0.5, scale_base_mu=0.0, scale_base_sigma=1.0, scale_sp=1.0, base_fun=torch.nn.SiLU(), grid_eps=0.02, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, save_plot_data = True, device='cpu', sparse_init=False): - '''' + def __init__( + self, + in_dim=3, + out_dim=2, + num=5, + k=3, + noise_scale=0.5, + scale_base_mu=0.0, + scale_base_sigma=1.0, + scale_sp=1.0, + base_fun=torch.nn.SiLU(), + grid_eps=0.02, + grid_range=[-1, 1], + sp_trainable=True, + sb_trainable=True, + save_plot_data=True, + device="cpu", + sparse_init=False, + ): + """' initialize a KANLayer - + Args: ----- in_dim : int @@ -77,60 +95,78 @@ def __init__(self, in_dim=3, out_dim=2, num=5, k=3, noise_scale=0.5, scale_base_ device sparse_init : bool if sparse_init = True, sparse initialization is applied. - + Returns: -------- self - + Example ------- >>> from kan.KANLayer import * >>> model = KANLayer(in_dim=3, out_dim=5) >>> (model.in_dim, model.out_dim) - ''' + """ super(KANLayer, self).__init__() - # size + # size self.out_dim = out_dim self.in_dim = in_dim self.num = num self.k = k - grid = torch.linspace(grid_range[0], grid_range[1], steps=num + 1)[None,:].expand(self.in_dim, num+1) + grid = torch.linspace(grid_range[0], grid_range[1], steps=num + 1)[ + None, : + ].expand(self.in_dim, num + 1) grid = extend_grid(grid, k_extend=k) self.grid = torch.nn.Parameter(grid).requires_grad_(False) - noises = (torch.rand(self.num+1, self.in_dim, self.out_dim) - 1/2) * noise_scale / num + noises = ( + (torch.rand(self.num + 1, self.in_dim, self.out_dim) - 1 / 2) + * noise_scale + / num + ) + + self.coef = torch.nn.Parameter( + curve2coef(self.grid[:, k:-k].permute(1, 0), noises, self.grid, k) + ) - self.coef = torch.nn.Parameter(curve2coef(self.grid[:,k:-k].permute(1,0), noises, self.grid, k)) - if sparse_init: - self.mask = torch.nn.Parameter(sparse_mask(in_dim, out_dim)).requires_grad_(False) + self.mask = torch.nn.Parameter(sparse_mask(in_dim, out_dim)).requires_grad_( + False + ) else: - self.mask = torch.nn.Parameter(torch.ones(in_dim, out_dim)).requires_grad_(False) - - self.scale_base = torch.nn.Parameter(scale_base_mu * 1 / np.sqrt(in_dim) + \ - scale_base_sigma * (torch.rand(in_dim, out_dim)*2-1) * 1/np.sqrt(in_dim)).requires_grad_(sb_trainable) - self.scale_sp = torch.nn.Parameter(torch.ones(in_dim, out_dim) * scale_sp * 1 / np.sqrt(in_dim) * self.mask).requires_grad_(sp_trainable) # make scale trainable + self.mask = torch.nn.Parameter(torch.ones(in_dim, out_dim)).requires_grad_( + False + ) + + self.scale_base = torch.nn.Parameter( + scale_base_mu * 1 / np.sqrt(in_dim) + + scale_base_sigma + * (torch.rand(in_dim, out_dim) * 2 - 1) + * 1 + / np.sqrt(in_dim) + ).requires_grad_(sb_trainable) + self.scale_sp = torch.nn.Parameter( + torch.ones(in_dim, out_dim) * scale_sp * 1 / np.sqrt(in_dim) * self.mask + ).requires_grad_(sp_trainable) # make scale trainable self.base_fun = base_fun - self.grid_eps = grid_eps - + self.to(device) - + def to(self, device): super(KANLayer, self).to(device) - self.device = device + self.device = device return self def forward(self, x): - ''' + """ KANLayer forward given input x - + Args: ----- x : 2D torch.float inputs, shape (number of samples, input dimension) - + Returns: -------- y : 2D torch.float @@ -141,7 +177,7 @@ def forward(self, x): the outputs of activation functions with preacts as inputs postspline : 3D torch.float the outputs of spline functions with preacts as inputs - + Example ------- >>> from kan.KANLayer import * @@ -149,36 +185,39 @@ def forward(self, x): >>> x = torch.normal(0,1,size=(100,3)) >>> y, preacts, postacts, postspline = model(x) >>> y.shape, preacts.shape, postacts.shape, postspline.shape - ''' + """ batch = x.shape[0] - preacts = x[:,None,:].clone().expand(batch, self.out_dim, self.in_dim) - - base = self.base_fun(x) # (batch, in_dim) + preacts = x[:, None, :].clone().expand(batch, self.out_dim, self.in_dim) + + base = self.base_fun(x) # (batch, in_dim) y = coef2curve(x_eval=x, grid=self.grid, coef=self.coef, k=self.k) - - postspline = y.clone().permute(0,2,1) - - y = self.scale_base[None,:,:] * base[:,:,None] + self.scale_sp[None,:,:] * y - y = self.mask[None,:,:] * y - - postacts = y.clone().permute(0,2,1) - + + postspline = y.clone().permute(0, 2, 1) + + y = ( + self.scale_base[None, :, :] * base[:, :, None] + + self.scale_sp[None, :, :] * y + ) + y = self.mask[None, :, :] * y + + postacts = y.clone().permute(0, 2, 1) + y = torch.sum(y, dim=1) return y, preacts, postacts, postspline - def update_grid_from_samples(self, x, mode='sample'): - ''' + def update_grid_from_samples(self, x, mode="sample"): + """ update grid from samples - + Args: ----- x : 2D torch.float inputs, shape (number of samples, input dimension) - + Returns: -------- None - + Example ------- >>> model = KANLayer(in_dim=1, out_dim=1, num=5, k=3) @@ -186,51 +225,59 @@ def update_grid_from_samples(self, x, mode='sample'): >>> x = torch.linspace(-3,3,steps=100)[:,None] >>> model.update_grid_from_samples(x) >>> print(model.grid.data) - ''' - + """ + batch = x.shape[0] - #x = torch.einsum('ij,k->ikj', x, torch.ones(self.out_dim, ).to(self.device)).reshape(batch, self.size).permute(1, 0) + # x = torch.einsum('ij,k->ikj', x, torch.ones(self.out_dim, ).to(self.device)).reshape(batch, self.size).permute(1, 0) x_pos = torch.sort(x, dim=0)[0] y_eval = coef2curve(x_pos, self.grid, self.coef, self.k) - num_interval = self.grid.shape[1] - 1 - 2*self.k - + num_interval = self.grid.shape[1] - 1 - 2 * self.k + def get_grid(num_interval): ids = [int(batch / num_interval * i) for i in range(num_interval)] + [-1] - grid_adaptive = x_pos[ids, :].permute(1,0) + grid_adaptive = x_pos[ids, :].permute(1, 0) margin = 0.00 - h = (grid_adaptive[:,[-1]] - grid_adaptive[:,[0]] + 2 * margin)/num_interval - grid_uniform = grid_adaptive[:,[0]] - margin + h * torch.arange(num_interval+1,)[None, :].to(x.device) + h = ( + grid_adaptive[:, [-1]] - grid_adaptive[:, [0]] + 2 * margin + ) / num_interval + grid_uniform = ( + grid_adaptive[:, [0]] + - margin + + h + * torch.arange( + num_interval + 1, + )[None, :].to(x.device) + ) grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive return grid - - + grid = get_grid(num_interval) - - if mode == 'grid': - sample_grid = get_grid(2*num_interval) - x_pos = sample_grid.permute(1,0) + + if mode == "grid": + sample_grid = get_grid(2 * num_interval) + x_pos = sample_grid.permute(1, 0) y_eval = coef2curve(x_pos, self.grid, self.coef, self.k) - + self.grid.data = extend_grid(grid, k_extend=self.k) - #print('x_pos 2', x_pos.shape) - #print('y_eval 2', y_eval.shape) + # print('x_pos 2', x_pos.shape) + # print('y_eval 2', y_eval.shape) self.coef.data = curve2coef(x_pos, y_eval, self.grid, self.k) - def initialize_grid_from_parent(self, parent, x, mode='sample'): - ''' + def initialize_grid_from_parent(self, parent, x, mode="sample"): + """ update grid from a parent KANLayer & samples - + Args: ----- parent : KANLayer a parent KANLayer (whose grid is usually coarser than the current model) x : 2D torch.float inputs, shape (number of samples, input dimension) - + Returns: -------- None - + Example ------- >>> batch = 100 @@ -240,17 +287,16 @@ def initialize_grid_from_parent(self, parent, x, mode='sample'): >>> x = torch.normal(0,1,size=(batch, 1)) >>> model.initialize_grid_from_parent(parent_model, x) >>> print(model.grid.data) - ''' - + """ + batch = x.shape[0] - + # shrink grid x_pos = torch.sort(x, dim=0)[0] y_eval = coef2curve(x_pos, parent.grid, parent.coef, parent.k) - num_interval = self.grid.shape[1] - 1 - 2*self.k - - - ''' + num_interval = self.grid.shape[1] - 1 - 2 * self.k + + """ # based on samples def get_grid(num_interval): ids = [int(batch / num_interval * i) for i in range(num_interval)] + [-1] @@ -258,88 +304,101 @@ def get_grid(num_interval): h = (grid_adaptive[:,[-1]] - grid_adaptive[:,[0]])/num_interval grid_uniform = grid_adaptive[:,[0]] + h * torch.arange(num_interval+1,)[None, :].to(x.device) grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive - return grid''' - - #print('p', parent.grid) + return grid""" + + # print('p', parent.grid) # based on interpolating parent grid def get_grid(num_interval): - x_pos = parent.grid[:,parent.k:-parent.k] - #print('x_pos', x_pos) - sp2 = KANLayer(in_dim=1, out_dim=self.in_dim,k=1,num=x_pos.shape[1]-1,scale_base_mu=0.0, scale_base_sigma=0.0).to(x.device) + x_pos = parent.grid[:, parent.k : -parent.k] + # print('x_pos', x_pos) + sp2 = KANLayer( + in_dim=1, + out_dim=self.in_dim, + k=1, + num=x_pos.shape[1] - 1, + scale_base_mu=0.0, + scale_base_sigma=0.0, + ).to(x.device) - #print('sp2_grid', sp2.grid[:,sp2.k:-sp2.k].permute(1,0).expand(-1,self.in_dim)) - #print('sp2_coef_shape', sp2.coef.shape) - sp2_coef = curve2coef(sp2.grid[:,sp2.k:-sp2.k].permute(1,0).expand(-1,self.in_dim), x_pos.permute(1,0).unsqueeze(dim=2), sp2.grid[:,:], k=1).permute(1,0,2) + # print('sp2_grid', sp2.grid[:,sp2.k:-sp2.k].permute(1,0).expand(-1,self.in_dim)) + # print('sp2_coef_shape', sp2.coef.shape) + sp2_coef = curve2coef( + sp2.grid[:, sp2.k : -sp2.k].permute(1, 0).expand(-1, self.in_dim), + x_pos.permute(1, 0).unsqueeze(dim=2), + sp2.grid[:, :], + k=1, + ).permute(1, 0, 2) shp = sp2_coef.shape - #sp2_coef = torch.cat([torch.zeros(shp[0], shp[1], 1), sp2_coef, torch.zeros(shp[0], shp[1], 1)], dim=2) - #print('sp2_coef',sp2_coef) - #print(sp2.coef.shape) + # sp2_coef = torch.cat([torch.zeros(shp[0], shp[1], 1), sp2_coef, torch.zeros(shp[0], shp[1], 1)], dim=2) + # print('sp2_coef',sp2_coef) + # print(sp2.coef.shape) sp2.coef.data = sp2_coef - percentile = torch.linspace(-1,1,self.num+1).to(self.device) - grid = sp2(percentile.unsqueeze(dim=1))[0].permute(1,0) - #print('c', grid) + percentile = torch.linspace(-1, 1, self.num + 1).to(self.device) + grid = sp2(percentile.unsqueeze(dim=1))[0].permute(1, 0) + # print('c', grid) return grid - + grid = get_grid(num_interval) - - if mode == 'grid': - sample_grid = get_grid(2*num_interval) - x_pos = sample_grid.permute(1,0) + + if mode == "grid": + sample_grid = get_grid(2 * num_interval) + x_pos = sample_grid.permute(1, 0) y_eval = coef2curve(x_pos, parent.grid, parent.coef, parent.k) - + grid = extend_grid(grid, k_extend=self.k) self.grid.data = grid self.coef.data = curve2coef(x_pos, y_eval, self.grid, self.k) def get_subset(self, in_id, out_id): - ''' + """ get a smaller KANLayer from a larger KANLayer (used for pruning) - + Args: ----- in_id : list id of selected input neurons out_id : list id of selected output neurons - + Returns: -------- spb : KANLayer - + Example ------- >>> kanlayer_large = KANLayer(in_dim=10, out_dim=10, num=5, k=3) >>> kanlayer_small = kanlayer_large.get_subset([0,9],[1,2,3]) >>> kanlayer_small.in_dim, kanlayer_small.out_dim (2, 3) - ''' - spb = KANLayer(len(in_id), len(out_id), self.num, self.k, base_fun=self.base_fun) + """ + spb = KANLayer( + len(in_id), len(out_id), self.num, self.k, base_fun=self.base_fun + ) spb.grid.data = self.grid[in_id] - spb.coef.data = self.coef[in_id][:,out_id] - spb.scale_base.data = self.scale_base[in_id][:,out_id] - spb.scale_sp.data = self.scale_sp[in_id][:,out_id] - spb.mask.data = self.mask[in_id][:,out_id] + spb.coef.data = self.coef[in_id][:, out_id] + spb.scale_base.data = self.scale_base[in_id][:, out_id] + spb.scale_sp.data = self.scale_sp[in_id][:, out_id] + spb.mask.data = self.mask[in_id][:, out_id] spb.in_dim = len(in_id) spb.out_dim = len(out_id) return spb - - - def swap(self, i1, i2, mode='in'): - ''' - swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') - + + def swap(self, i1, i2, mode="in"): + """ + swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') + Args: ----- i1 : int i2 : int mode : str mode = 'in' or 'out' - + Returns: -------- None - + Example ------- >>> from kan.KANLayer import * @@ -347,18 +406,18 @@ def swap(self, i1, i2, mode='in'): >>> print(model.coef) >>> model.swap(0,1,mode='in') >>> print(model.coef) - ''' + """ with torch.no_grad(): - def swap_(data, i1, i2, mode='in'): - if mode == 'in': + + def swap_(data, i1, i2, mode="in"): + if mode == "in": data[i1], data[i2] = data[i2].clone(), data[i1].clone() - elif mode == 'out': - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() + elif mode == "out": + data[:, i1], data[:, i2] = data[:, i2].clone(), data[:, i1].clone() - if mode == 'in': - swap_(self.grid.data, i1, i2, mode='in') + if mode == "in": + swap_(self.grid.data, i1, i2, mode="in") swap_(self.coef.data, i1, i2, mode=mode) swap_(self.scale_base.data, i1, i2, mode=mode) swap_(self.scale_sp.data, i1, i2, mode=mode) swap_(self.mask.data, i1, i2, mode=mode) - diff --git a/kan/LBFGS.py b/kan/LBFGS.py index 212477f23..2fc3f00f1 100644 --- a/kan/LBFGS.py +++ b/kan/LBFGS.py @@ -2,7 +2,8 @@ from functools import reduce from torch.optim import Optimizer -__all__ = ['LBFGS'] +__all__ = ["LBFGS"] + def _cubic_interpolate(x1, f1, g1, x2, f2, g2, bounds=None): # ported from https://github.com/torch/optim/blob/master/polyinterp.lua @@ -29,20 +30,12 @@ def _cubic_interpolate(x1, f1, g1, x2, f2, g2, bounds=None): min_pos = x1 - (x1 - x2) * ((g1 + d2 - d1) / (g1 - g2 + 2 * d2)) return min(max(min_pos, xmin_bound), xmax_bound) else: - return (xmin_bound + xmax_bound) / 2. - - -def _strong_wolfe(obj_func, - x, - t, - d, - f, - g, - gtd, - c1=1e-4, - c2=0.9, - tolerance_change=1e-9, - max_ls=25): + return (xmin_bound + xmax_bound) / 2.0 + + +def _strong_wolfe( + obj_func, x, t, d, f, g, gtd, c1=1e-4, c2=0.9, tolerance_change=1e-9, max_ls=25 +): # ported from https://github.com/torch/optim/blob/master/lswolfe.lua d_norm = d.abs().max() g = g.clone(memory_format=torch.contiguous_format) @@ -57,7 +50,7 @@ def _strong_wolfe(obj_func, ls_iter = 0 while ls_iter < max_ls: # check conditions - #print(f_prev, f_new, g_new) + # print(f_prev, f_new, g_new) if f_new > (f + c1 * t * gtd) or (ls_iter > 1 and f_new >= f_prev): bracket = [t_prev, t] bracket_f = [f_prev, f_new] @@ -84,13 +77,8 @@ def _strong_wolfe(obj_func, max_step = t * 10 tmp = t t = _cubic_interpolate( - t_prev, - f_prev, - gtd_prev, - t, - f_new, - gtd_new, - bounds=(min_step, max_step)) + t_prev, f_prev, gtd_prev, t, f_new, gtd_new, bounds=(min_step, max_step) + ) # next step t_prev = tmp @@ -101,7 +89,6 @@ def _strong_wolfe(obj_func, ls_func_evals += 1 gtd_new = g_new.dot(d) ls_iter += 1 - # reached max number of iterations? if ls_iter == max_ls: @@ -121,8 +108,14 @@ def _strong_wolfe(obj_func, break # compute new trial value - t = _cubic_interpolate(bracket[0], bracket_f[0], bracket_gtd[0], - bracket[1], bracket_f[1], bracket_gtd[1]) + t = _cubic_interpolate( + bracket[0], + bracket_f[0], + bracket_gtd[0], + bracket[1], + bracket_f[1], + bracket_gtd[1], + ) # test that we are making sufficient progress: # in case `t` is so close to boundary, we mark that we are making @@ -176,7 +169,7 @@ def _strong_wolfe(obj_func, bracket_g[low_pos] = g_new.clone(memory_format=torch.contiguous_format) bracket_gtd[low_pos] = gtd_new - #print(bracket) + # print(bracket) if len(bracket) == 1: t = bracket[0] f_new = bracket_f[0] @@ -188,7 +181,6 @@ def _strong_wolfe(obj_func, return f_new, g_new, t, ls_func_evals - class LBFGS(Optimizer): """Implements L-BFGS algorithm. @@ -222,16 +214,18 @@ class LBFGS(Optimizer): line_search_fn (str): either 'strong_wolfe' or None (default: None). """ - def __init__(self, - params, - lr=1, - max_iter=20, - max_eval=None, - tolerance_grad=1e-7, - tolerance_change=1e-9, - tolerance_ys=1e-32, - history_size=100, - line_search_fn=None): + def __init__( + self, + params, + lr=1, + max_iter=20, + max_eval=None, + tolerance_grad=1e-7, + tolerance_change=1e-9, + tolerance_ys=1e-32, + history_size=100, + line_search_fn=None, + ): if max_eval is None: max_eval = max_iter * 5 // 4 defaults = dict( @@ -242,19 +236,23 @@ def __init__(self, tolerance_change=tolerance_change, tolerance_ys=tolerance_ys, history_size=history_size, - line_search_fn=line_search_fn) + line_search_fn=line_search_fn, + ) super().__init__(params, defaults) if len(self.param_groups) != 1: - raise ValueError("LBFGS doesn't support per-parameter options " - "(parameter groups)") + raise ValueError( + "LBFGS doesn't support per-parameter options (parameter groups)" + ) - self._params = self.param_groups[0]['params'] + self._params = self.param_groups[0]["params"] self._numel_cache = None def _numel(self): if self._numel_cache is None: - self._numel_cache = reduce(lambda total, p: total + p.numel(), self._params, 0) + self._numel_cache = reduce( + lambda total, p: total + p.numel(), self._params, 0 + ) return self._numel_cache def _gather_flat_grad(self): @@ -275,7 +273,7 @@ def _add_grad(self, step_size, update): for p in self._params: numel = p.numel() # view as to avoid deprecated pointwise semantics - p.add_(update[offset:offset + numel].view_as(p), alpha=step_size) + p.add_(update[offset : offset + numel].view_as(p), alpha=step_size) offset += numel assert offset == self._numel() @@ -293,7 +291,6 @@ def _directional_evaluate(self, closure, x, t, d): self._set_param(x) return loss, flat_grad - @torch.no_grad() def step(self, closure): """Perform a single optimization step. @@ -302,35 +299,35 @@ def step(self, closure): closure (Callable): A closure that reevaluates the model and returns the loss. """ - + torch.manual_seed(0) - + assert len(self.param_groups) == 1 # Make sure the closure is always called with grad enabled closure = torch.enable_grad()(closure) group = self.param_groups[0] - lr = group['lr'] - max_iter = group['max_iter'] - max_eval = group['max_eval'] - tolerance_grad = group['tolerance_grad'] - tolerance_change = group['tolerance_change'] - tolerance_ys = group['tolerance_ys'] - line_search_fn = group['line_search_fn'] - history_size = group['history_size'] + lr = group["lr"] + max_iter = group["max_iter"] + max_eval = group["max_eval"] + tolerance_grad = group["tolerance_grad"] + tolerance_change = group["tolerance_change"] + tolerance_ys = group["tolerance_ys"] + line_search_fn = group["line_search_fn"] + history_size = group["history_size"] # NOTE: LBFGS has only global state, but we register it as state for # the first param, because this helps with casting in load_state_dict state = self.state[self._params[0]] - state.setdefault('func_evals', 0) - state.setdefault('n_iter', 0) + state.setdefault("func_evals", 0) + state.setdefault("n_iter", 0) # evaluate initial f(x) and df/dx orig_loss = closure() loss = float(orig_loss) current_evals = 1 - state['func_evals'] += 1 + state["func_evals"] += 1 flat_grad = self._gather_flat_grad() opt_cond = flat_grad.abs().max() <= tolerance_grad @@ -340,26 +337,26 @@ def step(self, closure): return orig_loss # tensors cached in state (for tracing) - d = state.get('d') - t = state.get('t') - old_dirs = state.get('old_dirs') - old_stps = state.get('old_stps') - ro = state.get('ro') - H_diag = state.get('H_diag') - prev_flat_grad = state.get('prev_flat_grad') - prev_loss = state.get('prev_loss') + d = state.get("d") + t = state.get("t") + old_dirs = state.get("old_dirs") + old_stps = state.get("old_stps") + ro = state.get("ro") + H_diag = state.get("H_diag") + prev_flat_grad = state.get("prev_flat_grad") + prev_loss = state.get("prev_loss") n_iter = 0 # optimize for a max of max_iter iterations while n_iter < max_iter: # keep track of nb of iterations n_iter += 1 - state['n_iter'] += 1 + state["n_iter"] += 1 ############################################################ # compute gradient descent direction ############################################################ - if state['n_iter'] == 1: + if state["n_iter"] == 1: d = flat_grad.neg() old_dirs = [] old_stps = [] @@ -381,7 +378,7 @@ def step(self, closure): # store new direction/step old_dirs.append(y) old_stps.append(s) - ro.append(1. / ys) + ro.append(1.0 / ys) # update scale of initial Hessian approximation H_diag = ys / y.dot(y) # (y*y) @@ -390,9 +387,9 @@ def step(self, closure): # multiplied by the gradient num_old = len(old_dirs) - if 'al' not in state: - state['al'] = [None] * history_size - al = state['al'] + if "al" not in state: + state["al"] = [None] * history_size + al = state["al"] # iteration in L-BFGS loop collapsed to use just one buffer q = flat_grad.neg() @@ -417,8 +414,8 @@ def step(self, closure): # compute step length ############################################################ # reset initial guess for step size - if state['n_iter'] == 1: - t = min(1., 1. / flat_grad.abs().sum()) * lr + if state["n_iter"] == 1: + t = min(1.0, 1.0 / flat_grad.abs().sum()) * lr else: t = lr @@ -440,8 +437,10 @@ def step(self, closure): def obj_func(x, t, d): return self._directional_evaluate(closure, x, t, d) + loss, flat_grad, t, ls_func_evals = _strong_wolfe( - obj_func, x_init, t, d, loss, flat_grad, gtd) + obj_func, x_init, t, d, loss, flat_grad, gtd + ) self._add_grad(t, d) opt_cond = flat_grad.abs().max() <= tolerance_grad else: @@ -459,7 +458,7 @@ def obj_func(x, t, d): # update func eval current_evals += ls_func_evals - state['func_evals'] += ls_func_evals + state["func_evals"] += ls_func_evals ############################################################ # check conditions @@ -481,13 +480,13 @@ def obj_func(x, t, d): if abs(loss - prev_loss) < tolerance_change: break - state['d'] = d - state['t'] = t - state['old_dirs'] = old_dirs - state['old_stps'] = old_stps - state['ro'] = ro - state['H_diag'] = H_diag - state['prev_flat_grad'] = prev_flat_grad - state['prev_loss'] = prev_loss + state["d"] = d + state["t"] = t + state["old_dirs"] = old_dirs + state["old_stps"] = old_stps + state["ro"] = ro + state["H_diag"] = H_diag + state["prev_flat_grad"] = prev_flat_grad + state["prev_loss"] = prev_loss return orig_loss diff --git a/kan/MLP.py b/kan/MLP.py index 1066c3b3d..726e30fe6 100644 --- a/kan/MLP.py +++ b/kan/MLP.py @@ -8,41 +8,39 @@ seed = 0 torch.manual_seed(seed) + class MLP(nn.Module): - - def __init__(self, width, act='silu', save_act=True, seed=0, device='cpu'): + def __init__(self, width, act="silu", save_act=True, seed=0, device="cpu"): super(MLP, self).__init__() - + torch.manual_seed(seed) - + linears = [] self.width = width self.depth = depth = len(width) - 1 for i in range(depth): - linears.append(nn.Linear(width[i], width[i+1])) + linears.append(nn.Linear(width[i], width[i + 1])) self.linears = nn.ModuleList(linears) - - #if activation == 'silu': + + # if activation == 'silu': self.act_fun = torch.nn.SiLU() self.save_act = save_act self.acts = None - + self.cache_data = None - + self.device = device self.to(device) - - + def to(self, device): super(MLP, self).to(device) self.device = device - + return self - - + def get_act(self, x=None): if isinstance(x, dict): - x = x['train_input'] + x = x["train_input"] if x == None: if self.cache_data != None: x = self.cache_data @@ -52,23 +50,21 @@ def get_act(self, x=None): self.save_act = True self.forward(x) self.save_act = save_act - + @property def w(self): return [self.linears[l].weight for l in range(self.depth)] - + def forward(self, x): - # cache data self.cache_data = x - + self.acts = [] self.acts_scale = [] self.wa_forward = [] self.a_forward = [] - + for i in range(self.depth): - if self.save_act: act = x.clone() act_scale = torch.std(x, dim=0) @@ -77,7 +73,7 @@ def forward(self, x): if i > 0: self.acts_scale.append(act_scale) self.wa_forward.append(wa_forward) - + x = self.linears[i](x) if i < self.depth - 1: x = self.act_fun(x) @@ -85,9 +81,9 @@ def forward(self, x): if self.save_act: act_scale = torch.std(x, dim=0) self.acts_scale.append(act_scale) - + return x - + def attribute(self): if self.acts == None: self.get_act() @@ -99,74 +95,96 @@ def attribute(self): node_score = torch.ones(self.width[-1]).requires_grad_(True).to(self.device) node_scores.append(node_score) - for l in range(self.depth,0,-1): - - edge_score = torch.einsum('ij,i->ij', torch.abs(self.wa_forward[l-1]), node_score/(self.acts_scale[l-1]+1e-4)) + for l in range(self.depth, 0, -1): + edge_score = torch.einsum( + "ij,i->ij", + torch.abs(self.wa_forward[l - 1]), + node_score / (self.acts_scale[l - 1] + 1e-4), + ) edge_scores.append(edge_score) # this might be improper for MLPs (although reasonable for KANs) - node_score = torch.sum(edge_score, dim=0)/torch.sqrt(torch.tensor(self.width[l-1], device=self.device)) - #print(self.width[l]) + node_score = torch.sum(edge_score, dim=0) / torch.sqrt( + torch.tensor(self.width[l - 1], device=self.device) + ) + # print(self.width[l]) node_scores.append(node_score) self.node_scores = list(reversed(node_scores)) self.edge_scores = list(reversed(edge_scores)) self.wa_backward = self.edge_scores - - def plot(self, beta=3, scale=1., metric='w'): + + def plot(self, beta=3, scale=1.0, metric="w"): # metric = 'w', 'act' or 'fa' - - if metric == 'fa': + + if metric == "fa": self.attribute() - + depth = self.depth y0 = 0.5 - fig, ax = plt.subplots(figsize=(3*scale,3*y0*depth*scale)) + fig, ax = plt.subplots(figsize=(3 * scale, 3 * y0 * depth * scale)) shp = self.width - - min_spacing = 1/max(self.width) + + min_spacing = 1 / max(self.width) for j in range(len(shp)): N = shp[j] for i in range(N): - plt.scatter(1 / (2 * N) + i / N, j * y0, s=min_spacing ** 2 * 5000 * scale ** 2, color='black') - - plt.ylim(-0.1*y0,y0*depth+0.1*y0) - plt.xlim(-0.02,1.02) + plt.scatter( + 1 / (2 * N) + i / N, + j * y0, + s=min_spacing**2 * 5000 * scale**2, + color="black", + ) + + plt.ylim(-0.1 * y0, y0 * depth + 0.1 * y0) + plt.xlim(-0.02, 1.02) linears = self.linears - + for ii in range(len(linears)): linear = linears[ii] p = linear.weight p_shp = p.shape - - if metric == 'w': + + if metric == "w": pass - elif metric == 'act': + elif metric == "act": p = self.wa_forward[ii] - elif metric == 'fa': + elif metric == "fa": p = self.wa_backward[ii] else: - raise Exception('metric = \'{}\' not recognized. Choices are \'w\', \'act\', \'fa\'.'.format(metric)) + raise Exception( + "metric = '{}' not recognized. Choices are 'w', 'act', 'fa'.".format( + metric + ) + ) for i in range(p_shp[0]): for j in range(p_shp[1]): - plt.plot([1/(2*p_shp[0])+i/p_shp[0], 1/(2*p_shp[1])+j/p_shp[1]], [y0*(ii+1),y0*ii], lw=0.5*scale, alpha=np.tanh(beta*np.abs(p[i,j].cpu().detach().numpy())), color="blue" if p[i,j]>0 else "red") - - ax.axis('off') - + plt.plot( + [ + 1 / (2 * p_shp[0]) + i / p_shp[0], + 1 / (2 * p_shp[1]) + j / p_shp[1], + ], + [y0 * (ii + 1), y0 * ii], + lw=0.5 * scale, + alpha=np.tanh(beta * np.abs(p[i, j].cpu().detach().numpy())), + color="blue" if p[i, j] > 0 else "red", + ) + + ax.axis("off") + def reg(self, reg_metric, lamb_l1, lamb_entropy): - - if reg_metric == 'w': + if reg_metric == "w": acts_scale = self.w - if reg_metric == 'act': + if reg_metric == "act": acts_scale = self.wa_forward - if reg_metric == 'fa': + if reg_metric == "fa": acts_scale = self.wa_backward - if reg_metric == 'a': + if reg_metric == "a": acts_scale = self.acts_scale - + if len(acts_scale[0].shape) == 2: - reg_ = 0. + reg_ = 0.0 for i in range(len(acts_scale)): vec = acts_scale[i] @@ -175,13 +193,16 @@ def reg(self, reg_metric, lamb_l1, lamb_entropy): l1 = torch.sum(vec) p_row = vec / (torch.sum(vec, dim=1, keepdim=True) + 1) p_col = vec / (torch.sum(vec, dim=0, keepdim=True) + 1) - entropy_row = - torch.mean(torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1)) - entropy_col = - torch.mean(torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0)) + entropy_row = -torch.mean( + torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1) + ) + entropy_col = -torch.mean( + torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0) + ) reg_ += lamb_l1 * l1 + lamb_entropy * (entropy_row + entropy_col) - + elif len(acts_scale[0].shape) == 1: - - reg_ = 0. + reg_ = 0.0 for i in range(len(acts_scale)): vec = acts_scale[i] @@ -189,25 +210,42 @@ def reg(self, reg_metric, lamb_l1, lamb_entropy): l1 = torch.sum(vec) p = vec / (torch.sum(vec) + 1) - entropy = - torch.sum(p * torch.log2(p + 1e-4)) + entropy = -torch.sum(p * torch.log2(p + 1e-4)) reg_ += lamb_l1 * l1 + lamb_entropy * entropy return reg_ - + def get_reg(self, reg_metric, lamb_l1, lamb_entropy): return self.reg(reg_metric, lamb_l1, lamb_entropy) - - def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., loss_fn=None, lr=1., batch=-1, - metrics=None, in_vars=None, out_vars=None, beta=3, device='cpu', reg_metric='w', display_metrics=None): - if lamb > 0. and not self.save_act: - print('setting lamb=0. If you want to set lamb > 0, set =True') - + def fit( + self, + dataset, + opt="LBFGS", + steps=100, + log=1, + lamb=0.0, + lamb_l1=1.0, + lamb_entropy=2.0, + loss_fn=None, + lr=1.0, + batch=-1, + metrics=None, + in_vars=None, + out_vars=None, + beta=3, + device="cpu", + reg_metric="w", + display_metrics=None, + ): + if lamb > 0.0 and not self.save_act: + print("setting lamb=0. If you want to set lamb > 0, set =True") + old_save_act = self.save_act - if lamb == 0.: + if lamb == 0.0: self.save_act = False - - pbar = tqdm(range(steps), desc='description', ncols=100) + + pbar = tqdm(range(steps), desc="description", ncols=100) if loss_fn == None: loss_fn = loss_fn_eval = lambda x, y: torch.mean((x - y) ** 2) @@ -217,19 +255,27 @@ def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_ if opt == "Adam": optimizer = torch.optim.Adam(self.parameters(), lr=lr) elif opt == "LBFGS": - optimizer = LBFGS(self.parameters(), lr=lr, history_size=10, line_search_fn="strong_wolfe", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32) + optimizer = LBFGS( + self.parameters(), + lr=lr, + history_size=10, + line_search_fn="strong_wolfe", + tolerance_grad=1e-32, + tolerance_change=1e-32, + tolerance_ys=1e-32, + ) results = {} - results['train_loss'] = [] - results['test_loss'] = [] - results['reg'] = [] + results["train_loss"] = [] + results["test_loss"] = [] + results["reg"] = [] if metrics != None: for i in range(len(metrics)): results[metrics[i].__name__] = [] - if batch == -1 or batch > dataset['train_input'].shape[0]: - batch_size = dataset['train_input'].shape[0] - batch_size_test = dataset['test_input'].shape[0] + if batch == -1 or batch > dataset["train_input"].shape[0]: + batch_size = dataset["train_input"].shape[0] + batch_size_test = dataset["test_input"].shape[0] else: batch_size = batch batch_size_test = batch @@ -239,78 +285,94 @@ def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_ def closure(): global train_loss, reg_ optimizer.zero_grad() - pred = self.forward(dataset['train_input'][train_id].to(self.device)) - train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device)) + pred = self.forward(dataset["train_input"][train_id].to(self.device)) + train_loss = loss_fn(pred, dataset["train_label"][train_id].to(self.device)) if self.save_act: - if reg_metric == 'fa': + if reg_metric == "fa": self.attribute() reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy) else: - reg_ = torch.tensor(0.) + reg_ = torch.tensor(0.0) objective = train_loss + lamb * reg_ objective.backward() return objective for _ in pbar: - - if _ == steps-1 and old_save_act: + if _ == steps - 1 and old_save_act: self.save_act = True - - train_id = np.random.choice(dataset['train_input'].shape[0], batch_size, replace=False) - test_id = np.random.choice(dataset['test_input'].shape[0], batch_size_test, replace=False) + + train_id = np.random.choice( + dataset["train_input"].shape[0], batch_size, replace=False + ) + test_id = np.random.choice( + dataset["test_input"].shape[0], batch_size_test, replace=False + ) if opt == "LBFGS": optimizer.step(closure) if opt == "Adam": - pred = self.forward(dataset['train_input'][train_id].to(self.device)) - train_loss = loss_fn(pred, dataset['train_label'][train_id].to(self.device)) + pred = self.forward(dataset["train_input"][train_id].to(self.device)) + train_loss = loss_fn( + pred, dataset["train_label"][train_id].to(self.device) + ) if self.save_act: reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy) else: - reg_ = torch.tensor(0.) + reg_ = torch.tensor(0.0) loss = train_loss + lamb * reg_ optimizer.zero_grad() loss.backward() optimizer.step() - test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id].to(self.device)), dataset['test_label'][test_id].to(self.device)) - - + test_loss = loss_fn_eval( + self.forward(dataset["test_input"][test_id].to(self.device)), + dataset["test_label"][test_id].to(self.device), + ) + if metrics != None: for i in range(len(metrics)): results[metrics[i].__name__].append(metrics[i]().item()) - results['train_loss'].append(torch.sqrt(train_loss).cpu().detach().numpy()) - results['test_loss'].append(torch.sqrt(test_loss).cpu().detach().numpy()) - results['reg'].append(reg_.cpu().detach().numpy()) + results["train_loss"].append(torch.sqrt(train_loss).cpu().detach().numpy()) + results["test_loss"].append(torch.sqrt(test_loss).cpu().detach().numpy()) + results["reg"].append(reg_.cpu().detach().numpy()) if _ % log == 0: if display_metrics == None: - pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(), reg_.cpu().detach().numpy())) + pbar.set_description( + "| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " + % ( + torch.sqrt(train_loss).cpu().detach().numpy(), + torch.sqrt(test_loss).cpu().detach().numpy(), + reg_.cpu().detach().numpy(), + ) + ) else: - string = '' + string = "" data = () for metric in display_metrics: - string += f' {metric}: %.2e |' + string += f" {metric}: %.2e |" try: results[metric] except: - raise Exception(f'{metric} not recognized') + raise Exception(f"{metric} not recognized") data += (results[metric][-1],) pbar.set_description(string % data) - + return results - + @property def connection_cost(self): - with torch.no_grad(): - cc = 0. + cc = 0.0 for linear in self.linears: t = torch.abs(linear.weight) + def get_coordinate(n): - return torch.linspace(0,1,steps=n+1, device=self.device)[:n] + 1/(2*n) + return torch.linspace(0, 1, steps=n + 1, device=self.device)[ + :n + ] + 1 / (2 * n) in_dim = t.shape[0] x_in = get_coordinate(in_dim) @@ -318,44 +380,60 @@ def get_coordinate(n): out_dim = t.shape[1] x_out = get_coordinate(out_dim) - dist = torch.abs(x_in[:,None] - x_out[None,:]) + dist = torch.abs(x_in[:, None] - x_out[None, :]) cc += torch.sum(dist * t) return cc - - def swap(self, l, i1, i2): + def swap(self, l, i1, i2): def swap_row(data, i1, i2): data[i1], data[i2] = data[i2].clone(), data[i1].clone() def swap_col(data, i1, i2): - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() + data[:, i1], data[:, i2] = data[:, i2].clone(), data[:, i1].clone() - swap_row(self.linears[l-1].weight.data, i1, i2) - swap_row(self.linears[l-1].bias.data, i1, i2) + swap_row(self.linears[l - 1].weight.data, i1, i2) + swap_row(self.linears[l - 1].bias.data, i1, i2) swap_col(self.linears[l].weight.data, i1, i2) - - def auto_swap_l(self, l): + def auto_swap_l(self, l): num = self.width[l] for i in range(num): ccs = [] for j in range(num): - self.swap(l,i,j) + self.swap(l, i, j) self.get_act() self.attribute() cc = self.connection_cost.detach().clone() ccs.append(cc) - self.swap(l,i,j) + self.swap(l, i, j) j = torch.argmin(torch.tensor(ccs)) - self.swap(l,i,j) + self.swap(l, i, j) def auto_swap(self): depth = self.depth for l in range(1, depth): self.auto_swap_l(l) - - def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): + + def tree( + self, + x=None, + in_var=None, + style="tree", + sym_th=1e-3, + sep_th=1e-1, + skip_sep_test=False, + verbose=False, + ): if x == None: x = self.cache_data - plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test, verbose=verbose) \ No newline at end of file + plot_tree( + self, + x, + in_var=in_var, + style=style, + sym_th=sym_th, + sep_th=sep_th, + skip_sep_test=skip_sep_test, + verbose=verbose, + ) diff --git a/kan/MultKAN.py b/kan/MultKAN.py index 5ee6b93ea..55323dbde 100644 --- a/kan/MultKAN.py +++ b/kan/MultKAN.py @@ -2,16 +2,17 @@ import torch.nn as nn import numpy as np from .KANLayer import KANLayer -#from .Symbolic_MultKANLayer import * + +# from .Symbolic_MultKANLayer import * from .Symbolic_KANLayer import Symbolic_KANLayer from .LBFGS import * import os -import glob import matplotlib.pyplot as plt from tqdm import tqdm import random import copy -#from .MultKANLayer import MultKANLayer + +# from .MultKANLayer import MultKANLayer import pandas as pd from sympy.printing import latex from sympy import * @@ -21,10 +22,11 @@ from .utils import SYMBOLIC_LIB from .hypothesis import plot_tree + class MultKAN(nn.Module): - ''' + """ KAN class - + Attributes: ----------- grid : int @@ -38,7 +40,7 @@ class MultKAN(nn.Module): width : list number of neurons in each layer. Without multiplication nodes, [2,5,5,3] means 2D inputs, 3D outputs, with 2 layers of 5 hidden neurons. - With multiplication nodes, [2,[5,3],[5,1],3] means besides the [2,5,53] KAN, there are 3 (1) mul nodes in layer 1 (2). + With multiplication nodes, [2,[5,3],[5,1],3] means besides the [2,5,53] KAN, there are 3 (1) mul nodes in layer 1 (2). mult_arity : int, or list of int lists multiplication arity for each multiplication node (the number of numbers to be multiplied) grid : int @@ -92,11 +94,37 @@ class MultKAN(nn.Module): round : int the number of times rewind() has been called device : str - ''' - def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, scale_base_mu=0.0, scale_base_sigma=1.0, base_fun='silu', symbolic_enabled=True, affine_trainable=False, grid_eps=0.02, grid_range=[-1, 1], sp_trainable=True, sb_trainable=True, seed=1, save_act=True, sparse_init=False, auto_save=True, first_init=True, ckpt_path='./model', state_id=0, round=0, device='cpu'): - ''' + """ + + def __init__( + self, + width=None, + grid=3, + k=3, + mult_arity=2, + noise_scale=0.3, + scale_base_mu=0.0, + scale_base_sigma=1.0, + base_fun="silu", + symbolic_enabled=True, + affine_trainable=False, + grid_eps=0.02, + grid_range=[-1, 1], + sp_trainable=True, + sb_trainable=True, + seed=1, + save_act=True, + sparse_init=False, + auto_save=True, + first_init=True, + ckpt_path="./model", + state_id=0, + round=0, + device="cpu", + ): + """ initalize a KAN model - + Args: ----- width : list of int @@ -113,7 +141,7 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, sca base_fun : str the residual function b(x). Default: 'silu' symbolic_enabled : bool - compute (True) or skip (False) symbolic computations (for efficiency). By default: True. + compute (True) or skip (False) symbolic computations (for efficiency). By default: True. affine_trainable : bool affine parameters are updated or not. Affine parameters include node_scale, node_bias, subnode_scale, subnode_bias grid_eps : float @@ -141,18 +169,18 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, sca round : int the number of times rewind() has been called device : str - + Returns: -------- self - + Example ------- >>> from kan import * >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) checkpoint directory created: ./model saving model version 0.0 - ''' + """ super(MultKAN, self).__init__() torch.manual_seed(seed) @@ -163,76 +191,101 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, sca self.act_fun = [] self.depth = len(width) - 1 - - #print('haha1', width) + + # print('haha1', width) for i in range(len(width)): - #print(type(width[i]), type(width[i]) == int) + # print(type(width[i]), type(width[i]) == int) if type(width[i]) == int or type(width[i]) == np.int64: - width[i] = [width[i],0] - - #print('haha2', width) - + width[i] = [width[i], 0] + + # print('haha2', width) + self.width = width - + # if mult_arity is just a scalar, we extend it to a list of lists # e.g, mult_arity = [[2,3],[4]] means that in the first hidden layer, 2 mult ops have arity 2 and 3, respectively; # in the second hidden layer, 1 mult op has arity 4. if isinstance(mult_arity, int): - self.mult_homo = True # when homo is True, parallelization is possible + self.mult_homo = True # when homo is True, parallelization is possible else: - self.mult_homo = False # when home if False, for loop is required. + self.mult_homo = False # when home if False, for loop is required. self.mult_arity = mult_arity width_in = self.width_in width_out = self.width_out - + self.base_fun_name = base_fun - if base_fun == 'silu': + if base_fun == "silu": base_fun = torch.nn.SiLU() - elif base_fun == 'identity': + elif base_fun == "identity": base_fun = torch.nn.Identity() - elif base_fun == 'zero': - base_fun = lambda x: x*0. - + elif base_fun == "zero": + base_fun = lambda x: x * 0.0 + self.grid_eps = grid_eps self.grid_range = grid_range - - + for l in range(self.depth): # splines if isinstance(grid, list): grid_l = grid[l] else: grid_l = grid - + if isinstance(k, list): k_l = k[l] else: k_l = k - - - sp_batch = KANLayer(in_dim=width_in[l], out_dim=width_out[l+1], num=grid_l, k=k_l, noise_scale=noise_scale, scale_base_mu=scale_base_mu, scale_base_sigma=scale_base_sigma, scale_sp=1., base_fun=base_fun, grid_eps=grid_eps, grid_range=grid_range, sp_trainable=sp_trainable, sb_trainable=sb_trainable, sparse_init=sparse_init) + + sp_batch = KANLayer( + in_dim=width_in[l], + out_dim=width_out[l + 1], + num=grid_l, + k=k_l, + noise_scale=noise_scale, + scale_base_mu=scale_base_mu, + scale_base_sigma=scale_base_sigma, + scale_sp=1.0, + base_fun=base_fun, + grid_eps=grid_eps, + grid_range=grid_range, + sp_trainable=sp_trainable, + sb_trainable=sb_trainable, + sparse_init=sparse_init, + ) self.act_fun.append(sp_batch) self.node_bias = [] self.node_scale = [] self.subnode_bias = [] self.subnode_scale = [] - - globals()['self.node_bias_0'] = torch.nn.Parameter(torch.zeros(3,1)).requires_grad_(False) - exec('self.node_bias_0' + " = torch.nn.Parameter(torch.zeros(3,1)).requires_grad_(False)") - + + globals()["self.node_bias_0"] = torch.nn.Parameter( + torch.zeros(3, 1) + ).requires_grad_(False) + exec( + "self.node_bias_0" + + " = torch.nn.Parameter(torch.zeros(3,1)).requires_grad_(False)" + ) + for l in range(self.depth): - exec(f'self.node_bias_{l} = torch.nn.Parameter(torch.zeros(width_in[l+1])).requires_grad_(affine_trainable)') - exec(f'self.node_scale_{l} = torch.nn.Parameter(torch.ones(width_in[l+1])).requires_grad_(affine_trainable)') - exec(f'self.subnode_bias_{l} = torch.nn.Parameter(torch.zeros(width_out[l+1])).requires_grad_(affine_trainable)') - exec(f'self.subnode_scale_{l} = torch.nn.Parameter(torch.ones(width_out[l+1])).requires_grad_(affine_trainable)') - exec(f'self.node_bias.append(self.node_bias_{l})') - exec(f'self.node_scale.append(self.node_scale_{l})') - exec(f'self.subnode_bias.append(self.subnode_bias_{l})') - exec(f'self.subnode_scale.append(self.subnode_scale_{l})') - - + exec( + f"self.node_bias_{l} = torch.nn.Parameter(torch.zeros(width_in[l+1])).requires_grad_(affine_trainable)" + ) + exec( + f"self.node_scale_{l} = torch.nn.Parameter(torch.ones(width_in[l+1])).requires_grad_(affine_trainable)" + ) + exec( + f"self.subnode_bias_{l} = torch.nn.Parameter(torch.zeros(width_out[l+1])).requires_grad_(affine_trainable)" + ) + exec( + f"self.subnode_scale_{l} = torch.nn.Parameter(torch.ones(width_out[l+1])).requires_grad_(affine_trainable)" + ) + exec(f"self.node_bias.append(self.node_bias_{l})") + exec(f"self.node_scale.append(self.node_scale_{l})") + exec(f"self.subnode_bias.append(self.subnode_bias_{l})") + exec(f"self.subnode_scale.append(self.subnode_scale_{l})") + self.act_fun = nn.ModuleList(self.act_fun) self.grid = grid @@ -242,7 +295,7 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, sca ### initializing the symbolic front ### self.symbolic_fun = [] for l in range(self.depth): - sb_batch = Symbolic_KANLayer(in_dim=width_in[l], out_dim=width_out[l+1]) + sb_batch = Symbolic_KANLayer(in_dim=width_in[l], out_dim=width_out[l + 1]) self.symbolic_fun.append(sb_batch) self.symbolic_fun = nn.ModuleList(self.symbolic_fun) @@ -250,46 +303,48 @@ def __init__(self, width=None, grid=3, k=3, mult_arity = 2, noise_scale=0.3, sca self.affine_trainable = affine_trainable self.sp_trainable = sp_trainable self.sb_trainable = sb_trainable - + self.save_act = save_act - + self.node_scores = None self.edge_scores = None self.subnode_scores = None - + self.cache_data = None self.acts = None - + self.auto_save = auto_save self.state_id = 0 self.ckpt_path = ckpt_path self.round = round - + self.device = device self.to(device) - + if auto_save: if first_init: if not os.path.exists(ckpt_path): # Create the directory os.makedirs(ckpt_path) print(f"checkpoint directory created: {ckpt_path}") - print('saving model version 0.0') + print("saving model version 0.0") - history_path = self.ckpt_path+'/history.txt' - with open(history_path, 'w') as file: - file.write(f'### Round {self.round} ###' + '\n') - file.write('init => 0.0' + '\n') - self.saveckpt(path=self.ckpt_path+'/'+'0.0') + history_path = self.ckpt_path + "/history.txt" + with open(history_path, "w") as file: + file.write(f"### Round {self.round} ###" + "\n") + file.write("init => 0.0" + "\n") + self.saveckpt(path=self.ckpt_path + "/" + "0.0") else: self.state_id = state_id - - self.input_id = torch.arange(self.width_in[0],) - + + self.input_id = torch.arange( + self.width_in[0], + ) + def to(self, device): - ''' + """ move the model to device - + Args: ----- device : str or device @@ -297,69 +352,73 @@ def to(self, device): Returns: -------- self - + Example ------- >>> from kan import * >>> device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) >>> model.to(device) - ''' + """ super(MultKAN, self).to(device) self.device = device - + for kanlayer in self.act_fun: kanlayer.to(device) - + for symbolic_kanlayer in self.symbolic_fun: symbolic_kanlayer.to(device) - + return self - + @property def width_in(self): - ''' + """ The number of input nodes for each layer - ''' + """ width = self.width - width_in = [width[l][0]+width[l][1] for l in range(len(width))] + width_in = [width[l][0] + width[l][1] for l in range(len(width))] return width_in - + @property def width_out(self): - ''' + """ The number of output subnodes for each layer - ''' + """ width = self.width if self.mult_homo == True: - width_out = [width[l][0]+self.mult_arity*width[l][1] for l in range(len(width))] + width_out = [ + width[l][0] + self.mult_arity * width[l][1] for l in range(len(width)) + ] else: - width_out = [width[l][0]+int(np.sum(self.mult_arity[l])) for l in range(len(width))] + width_out = [ + width[l][0] + int(np.sum(self.mult_arity[l])) for l in range(len(width)) + ] return width_out - + @property def n_sum(self): - ''' + """ The number of addition nodes for each layer - ''' + """ width = self.width - n_sum = [width[l][0] for l in range(1,len(width)-1)] + n_sum = [width[l][0] for l in range(1, len(width) - 1)] return n_sum - + @property def n_mult(self): - ''' + """ The number of multiplication nodes for each layer - ''' + """ width = self.width - n_mult = [width[l][1] for l in range(1,len(width)-1)] + n_mult = [width[l][1] for l in range(1, len(width) - 1)] return n_mult - + @property def feature_score(self): - ''' + """ attribution scores for inputs - ''' + """ self.attribute() if self.node_scores == None: return None @@ -367,10 +426,10 @@ def feature_score(self): return self.node_scores[0] def initialize_from_another_model(self, another_model, x): - ''' - initialize from another model of the same width, but their 'grid' parameter can be different. + """ + initialize from another model of the same width, but their 'grid' parameter can be different. Note this is equivalent to refine() when we don't want to keep another_model - + Args: ----- another_model : MultKAN @@ -379,7 +438,7 @@ def initialize_from_another_model(self, another_model, x): Returns: -------- self - + Example ------- >>> from kan import * @@ -387,7 +446,7 @@ def initialize_from_another_model(self, another_model, x): >>> model2 = KAN(width=[2,5,1], grid=10) >>> x = torch.rand(100,2) >>> model2.initialize_from_another_model(model1, x) - ''' + """ another_model(x) # get activations batch = x.shape[0] @@ -395,12 +454,14 @@ def initialize_from_another_model(self, another_model, x): for l in range(self.depth): spb = self.act_fun[l] - #spb_parent = another_model.act_fun[l] + # spb_parent = another_model.act_fun[l] # spb = spb_parent preacts = another_model.spline_preacts[l] postsplines = another_model.spline_postsplines[l] - self.act_fun[l].coef.data = curve2coef(preacts[:,0,:], postsplines.permute(0,2,1), spb.grid, k=spb.k) + self.act_fun[l].coef.data = curve2coef( + preacts[:, 0, :], postsplines.permute(0, 2, 1), spb.grid, k=spb.k + ) self.act_fun[l].scale_base.data = another_model.act_fun[l].scale_base.data self.act_fun[l].scale_sp.data = another_model.act_fun[l].scale_sp.data self.act_fun[l].mask.data = another_model.act_fun[l].mask.data @@ -408,7 +469,7 @@ def initialize_from_another_model(self, another_model, x): for l in range(self.depth): self.node_bias[l].data = another_model.node_bias[l].data self.node_scale[l].data = another_model.node_scale[l].data - + self.subnode_bias[l].data = another_model.subnode_bias[l].data self.subnode_scale[l].data = another_model.subnode_scale[l].data @@ -416,28 +477,38 @@ def initialize_from_another_model(self, another_model, x): self.symbolic_fun[l] = another_model.symbolic_fun[l] return self.to(self.device) - - def log_history(self, method_name): + def log_history(self, method_name): if self.auto_save: - # save to log file - #print(func.__name__) - with open(self.ckpt_path+'/history.txt', 'a') as file: - file.write(str(self.round)+'.'+str(self.state_id)+' => '+ method_name + ' => ' + str(self.round)+'.'+str(self.state_id+1) + '\n') + # print(func.__name__) + with open(self.ckpt_path + "/history.txt", "a") as file: + file.write( + str(self.round) + + "." + + str(self.state_id) + + " => " + + method_name + + " => " + + str(self.round) + + "." + + str(self.state_id + 1) + + "\n" + ) # update state_id self.state_id += 1 # save to ckpt - self.saveckpt(path=self.ckpt_path+'/'+str(self.round)+'.'+str(self.state_id)) - print('saving model version '+str(self.round)+'.'+str(self.state_id)) + self.saveckpt( + path=self.ckpt_path + "/" + str(self.round) + "." + str(self.state_id) + ) + print("saving model version " + str(self.round) + "." + str(self.state_id)) - def refine(self, new_grid): - ''' + """ grid refinement - + Args: ----- new_grid : init @@ -446,7 +517,7 @@ def refine(self, new_grid): Returns: -------- a refined model : MultKAN - + Example ------- >>> from kan import * @@ -462,40 +533,41 @@ def refine(self, new_grid): 5 saving model version 0.1 10 - ''' - - model_new = MultKAN(width=self.width, - grid=new_grid, - k=self.k, - mult_arity=self.mult_arity, - base_fun=self.base_fun_name, - symbolic_enabled=self.symbolic_enabled, - affine_trainable=self.affine_trainable, - grid_eps=self.grid_eps, - grid_range=self.grid_range, - sp_trainable=self.sp_trainable, - sb_trainable=self.sb_trainable, - ckpt_path=self.ckpt_path, - auto_save=True, - first_init=False, - state_id=self.state_id, - round=self.round, - device=self.device) - + """ + + model_new = MultKAN( + width=self.width, + grid=new_grid, + k=self.k, + mult_arity=self.mult_arity, + base_fun=self.base_fun_name, + symbolic_enabled=self.symbolic_enabled, + affine_trainable=self.affine_trainable, + grid_eps=self.grid_eps, + grid_range=self.grid_range, + sp_trainable=self.sp_trainable, + sb_trainable=self.sb_trainable, + ckpt_path=self.ckpt_path, + auto_save=True, + first_init=False, + state_id=self.state_id, + round=self.round, + device=self.device, + ) + model_new.initialize_from_another_model(self, self.cache_data) model_new.cache_data = self.cache_data model_new.grid = new_grid - - self.log_history('refine') + + self.log_history("refine") model_new.state_id += 1 - + return model_new.to(self.device) - - - def saveckpt(self, path='model'): - ''' + + def saveckpt(self, path="model"): + """ save the current model to files (configuration file and state file) - + Args: ----- path : str @@ -504,7 +576,7 @@ def saveckpt(self, path='model'): Returns: -------- None - + Example ------- >>> from kan import * @@ -512,46 +584,46 @@ def saveckpt(self, path='model'): >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) >>> model.saveckpt('./mark') # There will be three files appearing in the current folder: mark_cache_data, mark_config.yml, mark_state - ''' - + """ + model = self - + dic = dict( - width = model.width, - grid = model.grid, - k = model.k, - mult_arity = model.mult_arity, - base_fun_name = model.base_fun_name, - symbolic_enabled = model.symbolic_enabled, - affine_trainable = model.affine_trainable, - grid_eps = model.grid_eps, - grid_range = model.grid_range, - sp_trainable = model.sp_trainable, - sb_trainable = model.sb_trainable, - state_id = model.state_id, - auto_save = model.auto_save, - ckpt_path = model.ckpt_path, - round = model.round, - device = str(model.device) + width=model.width, + grid=model.grid, + k=model.k, + mult_arity=model.mult_arity, + base_fun_name=model.base_fun_name, + symbolic_enabled=model.symbolic_enabled, + affine_trainable=model.affine_trainable, + grid_eps=model.grid_eps, + grid_range=model.grid_range, + sp_trainable=model.sp_trainable, + sb_trainable=model.sb_trainable, + state_id=model.state_id, + auto_save=model.auto_save, + ckpt_path=model.ckpt_path, + round=model.round, + device=str(model.device), ) - + if dic["device"].isdigit(): dic["device"] = int(model.device) - for i in range (model.depth): - dic[f'symbolic.funs_name.{i}'] = model.symbolic_fun[i].funs_name + for i in range(model.depth): + dic[f"symbolic.funs_name.{i}"] = model.symbolic_fun[i].funs_name - with open(f'{path}_config.yml', 'w') as outfile: + with open(f"{path}_config.yml", "w") as outfile: yaml.dump(dic, outfile, default_flow_style=False) - torch.save(model.state_dict(), f'{path}_state') - torch.save(model.cache_data, f'{path}_cache_data') - + torch.save(model.state_dict(), f"{path}_state") + torch.save(model.cache_data, f"{path}_cache_data") + @staticmethod - def loadckpt(path='model'): - ''' + def loadckpt(path="model"): + """ load checkpoint from path - + Args: ----- path : str @@ -560,58 +632,64 @@ def loadckpt(path='model'): Returns: -------- MultKAN - + Example ------- >>> from kan import * >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) >>> model.saveckpt('./mark') >>> KAN.loadckpt('./mark') - ''' - with open(f'{path}_config.yml', 'r') as stream: + """ + with open(f"{path}_config.yml", "r") as stream: config = yaml.safe_load(stream) - state = torch.load(f'{path}_state') - - model_load = MultKAN(width=config['width'], - grid=config['grid'], - k=config['k'], - mult_arity = config['mult_arity'], - base_fun=config['base_fun_name'], - symbolic_enabled=config['symbolic_enabled'], - affine_trainable=config['affine_trainable'], - grid_eps=config['grid_eps'], - grid_range=config['grid_range'], - sp_trainable=config['sp_trainable'], - sb_trainable=config['sb_trainable'], - state_id=config['state_id'], - auto_save=config['auto_save'], - first_init=False, - ckpt_path=config['ckpt_path'], - round = config['round']+1, - device = config['device']) + state = torch.load(f"{path}_state") + + model_load = MultKAN( + width=config["width"], + grid=config["grid"], + k=config["k"], + mult_arity=config["mult_arity"], + base_fun=config["base_fun_name"], + symbolic_enabled=config["symbolic_enabled"], + affine_trainable=config["affine_trainable"], + grid_eps=config["grid_eps"], + grid_range=config["grid_range"], + sp_trainable=config["sp_trainable"], + sb_trainable=config["sb_trainable"], + state_id=config["state_id"], + auto_save=config["auto_save"], + first_init=False, + ckpt_path=config["ckpt_path"], + round=config["round"] + 1, + device=config["device"], + ) model_load.load_state_dict(state) - model_load.cache_data = torch.load(f'{path}_cache_data') - + model_load.cache_data = torch.load(f"{path}_cache_data") + depth = len(model_load.width) - 1 for l in range(depth): out_dim = model_load.symbolic_fun[l].out_dim in_dim = model_load.symbolic_fun[l].in_dim - funs_name = config[f'symbolic.funs_name.{l}'] + funs_name = config[f"symbolic.funs_name.{l}"] for j in range(out_dim): for i in range(in_dim): fun_name = funs_name[j][i] model_load.symbolic_fun[l].funs_name[j][i] = fun_name model_load.symbolic_fun[l].funs[j][i] = SYMBOLIC_LIB[fun_name][0] - model_load.symbolic_fun[l].funs_sympy[j][i] = SYMBOLIC_LIB[fun_name][1] - model_load.symbolic_fun[l].funs_avoid_singularity[j][i] = SYMBOLIC_LIB[fun_name][3] + model_load.symbolic_fun[l].funs_sympy[j][i] = SYMBOLIC_LIB[ + fun_name + ][1] + model_load.symbolic_fun[l].funs_avoid_singularity[j][i] = ( + SYMBOLIC_LIB[fun_name][3] + ) return model_load - + def copy(self): - ''' + """ deepcopy - + Args: ----- path : str @@ -620,7 +698,7 @@ def copy(self): Returns: -------- MultKAN - + Example ------- >>> from kan import * @@ -629,65 +707,69 @@ def copy(self): >>> model2.act_fun[0].coef.data *= 2 >>> print(model2.act_fun[0].coef.data) >>> print(model.act_fun[0].coef.data) - ''' - path='copy_temp' + """ + path = "copy_temp" self.saveckpt(path) return KAN.loadckpt(path) - + def rewind(self, model_id): - ''' + """ rewind to an old version - + Args: ----- model_id : str - in format '{a}.{b}' where a is the round number, b is the version number in that round + in format '{a}.{b}' where a is the round number, b is the version number in that round Returns: -------- MultKAN - + Example ------- Please refer to tutorials. API 12: Checkpoint, save & load model - ''' + """ self.round += 1 - self.state_id = model_id.split('.')[-1] - - history_path = self.ckpt_path+'/history.txt' - with open(history_path, 'a') as file: - file.write(f'### Round {self.round} ###' + '\n') - - self.saveckpt(path=self.ckpt_path+'/'+f'{self.round}.{self.state_id}') - - print('rewind to model version '+f'{self.round-1}.{self.state_id}'+', renamed as '+f'{self.round}.{self.state_id}') - - return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id)) - - + self.state_id = model_id.split(".")[-1] + + history_path = self.ckpt_path + "/history.txt" + with open(history_path, "a") as file: + file.write(f"### Round {self.round} ###" + "\n") + + self.saveckpt(path=self.ckpt_path + "/" + f"{self.round}.{self.state_id}") + + print( + "rewind to model version " + + f"{self.round - 1}.{self.state_id}" + + ", renamed as " + + f"{self.round}.{self.state_id}" + ) + + return MultKAN.loadckpt(path=self.ckpt_path + "/" + str(model_id)) + def checkout(self, model_id): - ''' + """ check out an old version - + Args: ----- model_id : str - in format '{a}.{b}' where a is the round number, b is the version number in that round + in format '{a}.{b}' where a is the round number, b is the version number in that round Returns: -------- MultKAN - + Example ------- Same use as rewind, although checkout doesn't change states - ''' - return MultKAN.loadckpt(path=self.ckpt_path+'/'+str(model_id)) - + """ + return MultKAN.loadckpt(path=self.ckpt_path + "/" + str(model_id)) + def update_grid_from_samples(self, x): - ''' + """ update grid from samples - + Args: ----- x : 2D torch.tensor @@ -696,7 +778,7 @@ def update_grid_from_samples(self, x): Returns: -------- None - + Example ------- >>> from kan import * @@ -705,21 +787,21 @@ def update_grid_from_samples(self, x): >>> x = torch.linspace(-10,10,steps=101)[:,None] >>> model.update_grid_from_samples(x) >>> print(model.act_fun[0].grid) - ''' + """ for l in range(self.depth): self.get_act(x) self.act_fun[l].update_grid_from_samples(self.acts[l]) - + def update_grid(self, x): - ''' + """ call update_grid_from_samples. This seems unnecessary but we retain it for the sake of classes that might inherit from MultKAN - ''' + """ self.update_grid_from_samples(x) def initialize_grid_from_another_model(self, model, x): - ''' + """ initialize grid from another model - + Args: ----- model : MultKAN @@ -730,7 +812,7 @@ def initialize_grid_from_another_model(self, model, x): Returns: -------- None - + Example ------- >>> from kan import * @@ -740,15 +822,15 @@ def initialize_grid_from_another_model(self, model, x): >>> model2 = KAN(width=[1,1], grid=10, k=3, seed=0) >>> model2.initialize_grid_from_another_model(model, x) >>> print(model2.act_fun[0].grid) - ''' + """ model(x) for l in range(self.depth): self.act_fun[l].initialize_grid_from_parent(model.act_fun[l], model.acts[l]) - def forward(self, x, singularity_avoiding=False, y_th=10.): - ''' + def forward(self, x, singularity_avoiding=False, y_th=10.0): + """ forward pass - + Args: ----- x : 2D torch.tensor @@ -761,14 +843,14 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): Returns: -------- None - + Example1 -------- >>> from kan import * >>> model = KAN(width=[2,5,1], grid=5, k=3, seed=0) >>> x = torch.rand(100,2) >>> model(x).shape - + Example2 -------- >>> from kan import * @@ -778,13 +860,13 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): >>> print(model(x)) >>> print(model(x, singularity_avoiding=True)) >>> print(model(x, singularity_avoiding=True, y_th=1.)) - ''' - x = x[:,self.input_id.long()] + """ + x = x[:, self.input_id.long()] assert x.shape[1] == self.width_in[0] - + # cache data self.cache_data = x - + self.acts = [] # shape ([batch, n0], [batch, n1], ..., [batch, n_L]) self.acts_premult = [] self.spline_preacts = [] @@ -799,36 +881,41 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): self.acts.append(x) # acts shape: (batch, width[l]) for l in range(self.depth): - x_numerical, preacts, postacts_numerical, postspline = self.act_fun[l](x) - #print(preacts, postacts_numerical, postspline) - + # print(preacts, postacts_numerical, postspline) + if self.symbolic_enabled == True: - x_symbolic, postacts_symbolic = self.symbolic_fun[l](x, singularity_avoiding=singularity_avoiding, y_th=y_th) + x_symbolic, postacts_symbolic = self.symbolic_fun[l]( + x, singularity_avoiding=singularity_avoiding, y_th=y_th + ) else: - x_symbolic = 0. - postacts_symbolic = 0. + x_symbolic = 0.0 + postacts_symbolic = 0.0 x = x_numerical + x_symbolic - + if self.save_act: # save subnode_scale self.subnode_actscale.append(torch.std(x, dim=0).detach()) - + # subnode affine transform - x = self.subnode_scale[l][None,:] * x + self.subnode_bias[l][None,:] - + x = self.subnode_scale[l][None, :] * x + self.subnode_bias[l][None, :] + if self.save_act: postacts = postacts_numerical + postacts_symbolic # self.neurons_scale.append(torch.mean(torch.abs(x), dim=0)) - #grid_reshape = self.act_fun[l].grid.reshape(self.width_out[l + 1], self.width_in[l], -1) + # grid_reshape = self.act_fun[l].grid.reshape(self.width_out[l + 1], self.width_in[l], -1) input_range = torch.std(preacts, dim=0) + 0.1 - output_range_spline = torch.std(postacts_numerical, dim=0) # for training, only penalize the spline part - output_range = torch.std(postacts, dim=0) # for visualization, include the contribution from both spline + symbolic + output_range_spline = torch.std( + postacts_numerical, dim=0 + ) # for training, only penalize the spline part + output_range = torch.std( + postacts, dim=0 + ) # for visualization, include the contribution from both spline + symbolic # save edge_scale self.edge_actscale.append(output_range) - + self.acts_scale.append((output_range / input_range).detach()) self.acts_scale_spline.append(output_range_spline / input_range) self.spline_preacts.append(preacts.detach()) @@ -836,68 +923,82 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): self.spline_postsplines.append(postspline.detach()) self.acts_premult.append(x.detach()) - + # multiplication - dim_sum = self.width[l+1][0] - dim_mult = self.width[l+1][1] - + dim_sum = self.width[l + 1][0] + dim_mult = self.width[l + 1][1] + if self.mult_homo == True: - for i in range(self.mult_arity-1): + for i in range(self.mult_arity - 1): if i == 0: - x_mult = x[:,dim_sum::self.mult_arity] * x[:,dim_sum+1::self.mult_arity] + x_mult = ( + x[:, dim_sum :: self.mult_arity] + * x[:, dim_sum + 1 :: self.mult_arity] + ) else: - x_mult = x_mult * x[:,dim_sum+i+1::self.mult_arity] - + x_mult = x_mult * x[:, dim_sum + i + 1 :: self.mult_arity] + else: for j in range(dim_mult): - acml_id = dim_sum + np.sum(self.mult_arity[l+1][:j]) - for i in range(self.mult_arity[l+1][j]-1): + acml_id = dim_sum + np.sum(self.mult_arity[l + 1][:j]) + for i in range(self.mult_arity[l + 1][j] - 1): if i == 0: - x_mult_j = x[:,[acml_id]] * x[:,[acml_id+1]] + x_mult_j = x[:, [acml_id]] * x[:, [acml_id + 1]] else: - x_mult_j = x_mult_j * x[:,[acml_id+i+1]] - + x_mult_j = x_mult_j * x[:, [acml_id + i + 1]] + if j == 0: x_mult = x_mult_j else: x_mult = torch.cat([x_mult, x_mult_j], dim=1) - - if self.width[l+1][1] > 0: - x = torch.cat([x[:,:dim_sum], x_mult], dim=1) - + + if self.width[l + 1][1] > 0: + x = torch.cat([x[:, :dim_sum], x_mult], dim=1) + # x = x + self.biases[l].weight # node affine transform - x = self.node_scale[l][None,:] * x + self.node_bias[l][None,:] - + x = self.node_scale[l][None, :] * x + self.node_bias[l][None, :] + self.acts.append(x.detach()) - - + return x def set_mode(self, l, i, j, mode, mask_n=None): if mode == "s": - mask_n = 0.; - mask_s = 1. + mask_n = 0.0 + mask_s = 1.0 elif mode == "n": - mask_n = 1.; - mask_s = 0. + mask_n = 1.0 + mask_s = 0.0 elif mode == "sn" or mode == "ns": if mask_n == None: - mask_n = 1. + mask_n = 1.0 else: mask_n = mask_n - mask_s = 1. + mask_s = 1.0 else: - mask_n = 0.; - mask_s = 0. + mask_n = 0.0 + mask_s = 0.0 self.act_fun[l].mask.data[i][j] = mask_n - self.symbolic_fun[l].mask.data[j,i] = mask_s - - def fix_symbolic(self, l, i, j, fun_name, fit_params_bool=True, a_range=(-10, 10), b_range=(-10, 10), verbose=True, random=False, log_history=True): - ''' + self.symbolic_fun[l].mask.data[j, i] = mask_s + + def fix_symbolic( + self, + l, + i, + j, + fun_name, + fit_params_bool=True, + a_range=(-10, 10), + b_range=(-10, 10), + verbose=True, + random=False, + log_history=True, + ): + """ set (l,i,j) activation to be symbolic (specified by fun_name) - + Args: ----- l : int @@ -920,19 +1021,19 @@ def fix_symbolic(self, l, i, j, fun_name, fit_params_bool=True, a_range=(-10, 10 initialize affine parameteres randomly or as [1,0,1,0] log_history : bool indicate whether to log history when the function is called - + Returns: -------- None or r2 (coefficient of determination) - - Example 1 + + Example 1 --------- >>> # when fit_params_bool = False >>> model = KAN(width=[2,5,1], grid=5, k=3) >>> model.fix_symbolic(0,1,3,'sin',fit_params_bool=False) >>> print(model.act_fun[0].mask.reshape(2,5)) >>> print(model.symbolic_fun[0].mask.reshape(2,5)) - + Example 2 --------- >>> # when fit_params_bool = True @@ -942,46 +1043,50 @@ def fix_symbolic(self, l, i, j, fun_name, fit_params_bool=True, a_range=(-10, 10 >>> model.fix_symbolic(0,1,3,'sin',fit_params_bool=True) >>> print(model.act_fun[0].mask.reshape(2,5)) >>> print(model.symbolic_fun[0].mask.reshape(2,5)) - ''' + """ if not fit_params_bool: - self.symbolic_fun[l].fix_symbolic(i, j, fun_name, verbose=verbose, random=random) + self.symbolic_fun[l].fix_symbolic( + i, j, fun_name, verbose=verbose, random=random + ) r2 = None else: x = self.acts[l][:, i] mask = self.act_fun[l].mask y = self.spline_postacts[l][:, j, i] - #y = self.postacts[l][:, j, i] - r2 = self.symbolic_fun[l].fix_symbolic(i, j, fun_name, x, y, a_range=a_range, b_range=b_range, verbose=verbose) - if mask[i,j] == 0: - r2 = - 1e8 + # y = self.postacts[l][:, j, i] + r2 = self.symbolic_fun[l].fix_symbolic( + i, j, fun_name, x, y, a_range=a_range, b_range=b_range, verbose=verbose + ) + if mask[i, j] == 0: + r2 = -1e8 self.set_mode(l, i, j, mode="s") - + if log_history: - self.log_history('fix_symbolic') + self.log_history("fix_symbolic") return r2 def unfix_symbolic(self, l, i, j, log_history=True): - ''' + """ unfix the (l,i,j) activation function. - ''' + """ self.set_mode(l, i, j, mode="n") self.symbolic_fun[l].funs_name[j][i] = "0" if log_history: - self.log_history('unfix_symbolic') + self.log_history("unfix_symbolic") def unfix_symbolic_all(self, log_history=True): - ''' + """ unfix all activation functions. - ''' + """ for l in range(len(self.width) - 1): for i in range(self.width_in[l]): for j in range(self.width_out[l + 1]): self.unfix_symbolic(l, i, j, log_history) def get_range(self, l, i, j, verbose=True): - ''' + """ Get the input range and output range of the (l,i,j) activation - + Args: ----- l : int @@ -990,7 +1095,7 @@ def get_range(self, l, i, j, verbose=True): input neuron index j : int output neuron index - + Returns: -------- x_min : float @@ -1001,14 +1106,14 @@ def get_range(self, l, i, j, verbose=True): minimum of output y_max : float maximum of output - + Example ------- >>> model = KAN(width=[2,3,1], grid=5, k=3, noise_scale=1.) >>> x = torch.normal(0,1,size=(100,2)) >>> model(x) # do a forward pass to obtain model.acts >>> model.get_range(0,0,0) - ''' + """ x = self.spline_preacts[l][:, j, i] y = self.spline_postacts[l][:, j, i] x_min = torch.min(x).cpu().detach().numpy() @@ -1016,14 +1121,26 @@ def get_range(self, l, i, j, verbose=True): y_min = torch.min(y).cpu().detach().numpy() y_max = torch.max(y).cpu().detach().numpy() if verbose: - print('x range: [' + '%.2f' % x_min, ',', '%.2f' % x_max, ']') - print('y range: [' + '%.2f' % y_min, ',', '%.2f' % y_max, ']') + print("x range: [" + "%.2f" % x_min, ",", "%.2f" % x_max, "]") + print("y range: [" + "%.2f" % y_min, ",", "%.2f" % y_max, "]") return x_min, x_max, y_min, y_max - def plot(self, folder="./figures", beta=3, metric='backward', scale=0.5, tick=False, sample=False, in_vars=None, out_vars=None, title=None, varscale=1.0): - ''' + def plot( + self, + folder="./figures", + beta=3, + metric="backward", + scale=0.5, + tick=False, + sample=False, + in_vars=None, + out_vars=None, + title=None, + varscale=1.0, + ): + """ plot KAN - + Args: ----- folder : str @@ -1044,11 +1161,11 @@ def plot(self, folder="./figures", beta=3, metric='backward', scale=0.5, tick=Fa title varscale : float the size of input variables - + Returns: -------- Figure - + Example ------- >>> # see more interactive examples in demos @@ -1056,22 +1173,21 @@ def plot(self, folder="./figures", beta=3, metric='backward', scale=0.5, tick=Fa >>> x = torch.normal(0,1,size=(100,2)) >>> model(x) # do a forward pass to obtain model.acts >>> model.plot() - ''' + """ global Symbol - + if not self.save_act: - print('cannot plot since data are not saved. Set save_act=True first.') - + print("cannot plot since data are not saved. Set save_act=True first.") + # forward to obtain activations if self.acts == None: if self.cache_data == None: - raise Exception('model hasn\'t seen any data yet.') + raise Exception("model hasn't seen any data yet.") self.forward(self.cache_data) - - if metric == 'backward': + + if metric == "backward": self.attribute() - - + if not os.path.exists(folder): os.makedirs(folder) # matplotlib.use('Agg') @@ -1079,69 +1195,84 @@ def plot(self, folder="./figures", beta=3, metric='backward', scale=0.5, tick=Fa for l in range(depth): w_large = 2.0 for i in range(self.width_in[l]): - for j in range(self.width_out[l+1]): + for j in range(self.width_out[l + 1]): rank = torch.argsort(self.acts[l][:, i]) fig, ax = plt.subplots(figsize=(w_large, w_large)) num = rank.shape[0] - #print(self.width_in[l]) - #print(self.width_out[l+1]) + # print(self.width_in[l]) + # print(self.width_out[l+1]) symbolic_mask = self.symbolic_fun[l].mask[j][i] numeric_mask = self.act_fun[l].mask[i][j] - if symbolic_mask > 0. and numeric_mask > 0.: - color = 'purple' + if symbolic_mask > 0.0 and numeric_mask > 0.0: + color = "purple" alpha_mask = 1 - if symbolic_mask > 0. and numeric_mask == 0.: + if symbolic_mask > 0.0 and numeric_mask == 0.0: color = "red" alpha_mask = 1 - if symbolic_mask == 0. and numeric_mask > 0.: + if symbolic_mask == 0.0 and numeric_mask > 0.0: color = "black" alpha_mask = 1 - if symbolic_mask == 0. and numeric_mask == 0.: + if symbolic_mask == 0.0 and numeric_mask == 0.0: color = "white" alpha_mask = 0 - if tick == True: ax.tick_params(axis="y", direction="in", pad=-22, labelsize=50) ax.tick_params(axis="x", direction="in", pad=-15, labelsize=50) - x_min, x_max, y_min, y_max = self.get_range(l, i, j, verbose=False) - plt.xticks([x_min, x_max], ['%2.f' % x_min, '%2.f' % x_max]) - plt.yticks([y_min, y_max], ['%2.f' % y_min, '%2.f' % y_max]) + x_min, x_max, y_min, y_max = self.get_range( + l, i, j, verbose=False + ) + plt.xticks([x_min, x_max], ["%2.f" % x_min, "%2.f" % x_max]) + plt.yticks([y_min, y_max], ["%2.f" % y_min, "%2.f" % y_max]) else: plt.xticks([]) plt.yticks([]) if alpha_mask == 1: - plt.gca().patch.set_edgecolor('black') + plt.gca().patch.set_edgecolor("black") else: - plt.gca().patch.set_edgecolor('white') + plt.gca().patch.set_edgecolor("white") plt.gca().patch.set_linewidth(1.5) # plt.axis('off') - plt.plot(self.acts[l][:, i][rank].cpu().detach().numpy(), self.spline_postacts[l][:, j, i][rank].cpu().detach().numpy(), color=color, lw=5) + plt.plot( + self.acts[l][:, i][rank].cpu().detach().numpy(), + self.spline_postacts[l][:, j, i][rank].cpu().detach().numpy(), + color=color, + lw=5, + ) if sample == True: - plt.scatter(self.acts[l][:, i][rank].cpu().detach().numpy(), self.spline_postacts[l][:, j, i][rank].cpu().detach().numpy(), color=color, s=400 * scale ** 2) + plt.scatter( + self.acts[l][:, i][rank].cpu().detach().numpy(), + self.spline_postacts[l][:, j, i][rank] + .cpu() + .detach() + .numpy(), + color=color, + s=400 * scale**2, + ) plt.gca().spines[:].set_color(color) - plt.savefig(f'{folder}/sp_{l}_{i}_{j}.png', bbox_inches="tight", dpi=400) + plt.savefig( + f"{folder}/sp_{l}_{i}_{j}.png", bbox_inches="tight", dpi=400 + ) plt.close() def score2alpha(score): return np.tanh(beta * score) - - if metric == 'forward_n': + if metric == "forward_n": scores = self.acts_scale - elif metric == 'forward_u': + elif metric == "forward_u": scores = self.edge_actscale - elif metric == 'backward': + elif metric == "backward": scores = self.edge_scores else: - raise Exception(f'metric = \'{metric}\' not recognized') - + raise Exception(f"metric = '{metric}' not recognized") + alpha = [score2alpha(score.cpu().detach().numpy()) for score in scores] - + # draw skeleton width = np.array(self.width) width_in = np.array(self.width_in) @@ -1155,10 +1286,16 @@ def score2alpha(score): max_neuron = np.max(width_out) max_num_weights = np.max(width_in[:-1] * width_out[1:]) - y1 = 0.4 / np.maximum(max_num_weights, 5) # size (height/width) of 1D function diagrams - y2 = 0.15 / np.maximum(max_neuron, 5) # size (height/width) of operations (sum and mult) - - fig, ax = plt.subplots(figsize=(10 * scale, 10 * scale * (neuron_depth - 1) * (y0+z0))) + y1 = 0.4 / np.maximum( + max_num_weights, 5 + ) # size (height/width) of 1D function diagrams + y2 = 0.15 / np.maximum( + max_neuron, 5 + ) # size (height/width) of operations (sum and mult) + + fig, ax = plt.subplots( + figsize=(10 * scale, 10 * scale * (neuron_depth - 1) * (y0 + z0)) + ) # fig, ax = plt.subplots(figsize=(5,5*(neuron_depth-1)*y0)) # -- Transformation functions @@ -1166,77 +1303,94 @@ def score2alpha(score): FC_to_NFC = fig.transFigure.inverted().transform # -- Take data coordinates and transform them to normalized figure coordinates DC_to_NFC = lambda x: FC_to_NFC(DC_to_FC(x)) - + # plot scatters and lines for l in range(neuron_depth): - n = width_in[l] - + # scatters for i in range(n): - plt.scatter(1 / (2 * n) + i / n, l * (y0+z0), s=min_spacing ** 2 * 10000 * scale ** 2, color='black') - + plt.scatter( + 1 / (2 * n) + i / n, + l * (y0 + z0), + s=min_spacing**2 * 10000 * scale**2, + color="black", + ) + # plot connections (input to pre-mult) for i in range(n): if l < neuron_depth - 1: - n_next = width_out[l+1] + n_next = width_out[l + 1] N = n * n_next for j in range(n_next): id_ = i * n_next + j symbol_mask = self.symbolic_fun[l].mask[j][i] numerical_mask = self.act_fun[l].mask[i][j] - if symbol_mask == 1. and numerical_mask > 0.: - color = 'purple' - alpha_mask = 1. - if symbol_mask == 1. and numerical_mask == 0.: + if symbol_mask == 1.0 and numerical_mask > 0.0: + color = "purple" + alpha_mask = 1.0 + if symbol_mask == 1.0 and numerical_mask == 0.0: color = "red" - alpha_mask = 1. - if symbol_mask == 0. and numerical_mask == 1.: + alpha_mask = 1.0 + if symbol_mask == 0.0 and numerical_mask == 1.0: color = "black" - alpha_mask = 1. - if symbol_mask == 0. and numerical_mask == 0.: + alpha_mask = 1.0 + if symbol_mask == 0.0 and numerical_mask == 0.0: color = "white" - alpha_mask = 0. - - plt.plot([1 / (2 * n) + i / n, 1 / (2 * N) + id_ / N], [l * (y0+z0), l * (y0+z0) + y0/2 - y1], color=color, lw=2 * scale, alpha=alpha[l][j][i] * alpha_mask) - plt.plot([1 / (2 * N) + id_ / N, 1 / (2 * n_next) + j / n_next], [l * (y0+z0) + y0/2 + y1, l * (y0+z0)+y0], color=color, lw=2 * scale, alpha=alpha[l][j][i] * alpha_mask) - - + alpha_mask = 0.0 + + plt.plot( + [1 / (2 * n) + i / n, 1 / (2 * N) + id_ / N], + [l * (y0 + z0), l * (y0 + z0) + y0 / 2 - y1], + color=color, + lw=2 * scale, + alpha=alpha[l][j][i] * alpha_mask, + ) + plt.plot( + [1 / (2 * N) + id_ / N, 1 / (2 * n_next) + j / n_next], + [l * (y0 + z0) + y0 / 2 + y1, l * (y0 + z0) + y0], + color=color, + lw=2 * scale, + alpha=alpha[l][j][i] * alpha_mask, + ) + # plot connections (pre-mult to post-mult, post-mult = next-layer input) if l < neuron_depth - 1: - n_in = width_out[l+1] - n_out = width_in[l+1] + n_in = width_out[l + 1] + n_out = width_in[l + 1] mult_id = 0 for i in range(n_in): - if i < width[l+1][0]: + if i < width[l + 1][0]: j = i else: - if i == width[l+1][0]: - if isinstance(self.mult_arity,int): + if i == width[l + 1][0]: + if isinstance(self.mult_arity, int): ma = self.mult_arity else: - ma = self.mult_arity[l+1][mult_id] + ma = self.mult_arity[l + 1][mult_id] current_mult_arity = ma if current_mult_arity == 0: mult_id += 1 - if isinstance(self.mult_arity,int): + if isinstance(self.mult_arity, int): ma = self.mult_arity else: - ma = self.mult_arity[l+1][mult_id] + ma = self.mult_arity[l + 1][mult_id] current_mult_arity = ma - j = width[l+1][0] + mult_id + j = width[l + 1][0] + mult_id current_mult_arity -= 1 - #j = (i-width[l+1][0])//self.mult_arity + width[l+1][0] - plt.plot([1 / (2 * n_in) + i / n_in, 1 / (2 * n_out) + j / n_out], [l * (y0+z0) + y0, (l+1) * (y0+z0)], color='black', lw=2 * scale) + # j = (i-width[l+1][0])//self.mult_arity + width[l+1][0] + plt.plot( + [1 / (2 * n_in) + i / n_in, 1 / (2 * n_out) + j / n_out], + [l * (y0 + z0) + y0, (l + 1) * (y0 + z0)], + color="black", + lw=2 * scale, + ) - - plt.xlim(0, 1) - plt.ylim(-0.1 * (y0+z0), (neuron_depth - 1 + 0.1) * (y0+z0)) + plt.ylim(-0.1 * (y0 + z0), (neuron_depth - 1 + 0.1) * (y0 + z0)) - - plt.axis('off') + plt.axis("off") for l in range(neuron_depth - 1): # plot splines @@ -1246,73 +1400,110 @@ def score2alpha(score): N = n * n_next for j in range(n_next): id_ = i * n_next + j - im = plt.imread(f'{folder}/sp_{l}_{i}_{j}.png') + im = plt.imread(f"{folder}/sp_{l}_{i}_{j}.png") left = DC_to_NFC([1 / (2 * N) + id_ / N - y1, 0])[0] right = DC_to_NFC([1 / (2 * N) + id_ / N + y1, 0])[0] - bottom = DC_to_NFC([0, l * (y0+z0) + y0/2 - y1])[1] - up = DC_to_NFC([0, l * (y0+z0) + y0/2 + y1])[1] + bottom = DC_to_NFC([0, l * (y0 + z0) + y0 / 2 - y1])[1] + up = DC_to_NFC([0, l * (y0 + z0) + y0 / 2 + y1])[1] newax = fig.add_axes([left, bottom, right - left, up - bottom]) # newax = fig.add_axes([1/(2*N)+id_/N-y1, (l+1/2)*y0-y1, y1, y1], anchor='NE') newax.imshow(im, alpha=alpha[l][j][i]) - newax.axis('off') - - + newax.axis("off") + # plot sum symbols - N = n = width_out[l+1] + N = n = width_out[l + 1] for j in range(n): id_ = j - path = os.path.dirname(os.path.abspath(__file__)) + "/assets/img/sum_symbol.png" + path = ( + os.path.dirname(os.path.abspath(__file__)) + + "/assets/img/sum_symbol.png" + ) im = plt.imread(path) left = DC_to_NFC([1 / (2 * N) + id_ / N - y2, 0])[0] right = DC_to_NFC([1 / (2 * N) + id_ / N + y2, 0])[0] - bottom = DC_to_NFC([0, l * (y0+z0) + y0 - y2])[1] - up = DC_to_NFC([0, l * (y0+z0) + y0 + y2])[1] + bottom = DC_to_NFC([0, l * (y0 + z0) + y0 - y2])[1] + up = DC_to_NFC([0, l * (y0 + z0) + y0 + y2])[1] newax = fig.add_axes([left, bottom, right - left, up - bottom]) newax.imshow(im) - newax.axis('off') - + newax.axis("off") + # plot mult symbols - N = n = width_in[l+1] - n_sum = width[l+1][0] - n_mult = width[l+1][1] + N = n = width_in[l + 1] + n_sum = width[l + 1][0] + n_mult = width[l + 1][1] for j in range(n_mult): id_ = j + n_sum - path = os.path.dirname(os.path.abspath(__file__)) + "/assets/img/mult_symbol.png" + path = ( + os.path.dirname(os.path.abspath(__file__)) + + "/assets/img/mult_symbol.png" + ) im = plt.imread(path) left = DC_to_NFC([1 / (2 * N) + id_ / N - y2, 0])[0] right = DC_to_NFC([1 / (2 * N) + id_ / N + y2, 0])[0] - bottom = DC_to_NFC([0, (l+1) * (y0+z0) - y2])[1] - up = DC_to_NFC([0, (l+1) * (y0+z0) + y2])[1] + bottom = DC_to_NFC([0, (l + 1) * (y0 + z0) - y2])[1] + up = DC_to_NFC([0, (l + 1) * (y0 + z0) + y2])[1] newax = fig.add_axes([left, bottom, right - left, up - bottom]) newax.imshow(im) - newax.axis('off') + newax.axis("off") if in_vars != None: n = self.width_in[0] for i in range(n): if isinstance(in_vars[i], sympy.Expr): - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), -0.1, f'${latex(in_vars[i])}$', fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') + plt.gcf().get_axes()[0].text( + 1 / (2 * (n)) + i / (n), + -0.1, + f"${latex(in_vars[i])}$", + fontsize=40 * scale * varscale, + horizontalalignment="center", + verticalalignment="center", + ) else: - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), -0.1, in_vars[i], fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') - - + plt.gcf().get_axes()[0].text( + 1 / (2 * (n)) + i / (n), + -0.1, + in_vars[i], + fontsize=40 * scale * varscale, + horizontalalignment="center", + verticalalignment="center", + ) if out_vars != None: n = self.width_in[-1] for i in range(n): if isinstance(out_vars[i], sympy.Expr): - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), (y0+z0) * (len(self.width) - 1) + 0.15, f'${latex(out_vars[i])}$', fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') + plt.gcf().get_axes()[0].text( + 1 / (2 * (n)) + i / (n), + (y0 + z0) * (len(self.width) - 1) + 0.15, + f"${latex(out_vars[i])}$", + fontsize=40 * scale * varscale, + horizontalalignment="center", + verticalalignment="center", + ) else: - plt.gcf().get_axes()[0].text(1 / (2 * (n)) + i / (n), (y0+z0) * (len(self.width) - 1) + 0.15, out_vars[i], fontsize=40 * scale * varscale, horizontalalignment='center', verticalalignment='center') + plt.gcf().get_axes()[0].text( + 1 / (2 * (n)) + i / (n), + (y0 + z0) * (len(self.width) - 1) + 0.15, + out_vars[i], + fontsize=40 * scale * varscale, + horizontalalignment="center", + verticalalignment="center", + ) if title != None: - plt.gcf().get_axes()[0].text(0.5, (y0+z0) * (len(self.width) - 1) + 0.3, title, fontsize=40 * scale, horizontalalignment='center', verticalalignment='center') + plt.gcf().get_axes()[0].text( + 0.5, + (y0 + z0) * (len(self.width) - 1) + 0.3, + title, + fontsize=40 * scale, + horizontalalignment="center", + verticalalignment="center", + ) - def reg(self, reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff): - ''' + """ Get regularization - + Args: ----- reg_metric : the regularization metric @@ -1325,69 +1516,77 @@ def reg(self, reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff): coefficient penalty strength lamb_coefdiff : float coefficient smoothness strength - + Returns: -------- reg_ : torch.float - + Example ------- >>> model = KAN(width=[2,3,1], grid=5, k=3, noise_scale=1.) >>> x = torch.rand(100,2) >>> model.get_act(x) >>> model.reg('edge_forward_spline_n', 1.0, 2.0, 1.0, 1.0) - ''' - if reg_metric == 'edge_forward_spline_n': + """ + if reg_metric == "edge_forward_spline_n": acts_scale = self.acts_scale_spline - - elif reg_metric == 'edge_forward_sum': + + elif reg_metric == "edge_forward_sum": acts_scale = self.acts_scale - - elif reg_metric == 'edge_forward_spline_u': + + elif reg_metric == "edge_forward_spline_u": acts_scale = self.edge_actscale - - elif reg_metric == 'edge_backward': + + elif reg_metric == "edge_backward": acts_scale = self.edge_scores - - elif reg_metric == 'node_backward': + + elif reg_metric == "node_backward": acts_scale = self.node_attribute_scores - + else: - raise Exception(f'reg_metric = {reg_metric} not recognized!') - - reg_ = 0. + raise Exception(f"reg_metric = {reg_metric} not recognized!") + + reg_ = 0.0 for i in range(len(acts_scale)): vec = acts_scale[i] l1 = torch.sum(vec) p_row = vec / (torch.sum(vec, dim=1, keepdim=True) + 1) p_col = vec / (torch.sum(vec, dim=0, keepdim=True) + 1) - entropy_row = - torch.mean(torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1)) - entropy_col = - torch.mean(torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0)) - reg_ += lamb_l1 * l1 + lamb_entropy * (entropy_row + entropy_col) # both l1 and entropy + entropy_row = -torch.mean( + torch.sum(p_row * torch.log2(p_row + 1e-4), dim=1) + ) + entropy_col = -torch.mean( + torch.sum(p_col * torch.log2(p_col + 1e-4), dim=0) + ) + reg_ += lamb_l1 * l1 + lamb_entropy * ( + entropy_row + entropy_col + ) # both l1 and entropy # regularize coefficient to encourage spline to be zero for i in range(len(self.act_fun)): coeff_l1 = torch.sum(torch.mean(torch.abs(self.act_fun[i].coef), dim=1)) - coeff_diff_l1 = torch.sum(torch.mean(torch.abs(torch.diff(self.act_fun[i].coef)), dim=1)) + coeff_diff_l1 = torch.sum( + torch.mean(torch.abs(torch.diff(self.act_fun[i].coef)), dim=1) + ) reg_ += lamb_coef * coeff_l1 + lamb_coefdiff * coeff_diff_l1 return reg_ - + def get_reg(self, reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff): - ''' + """ Get regularization. This seems unnecessary but in case a class wants to inherit this, it may want to rewrite get_reg, but not reg. - ''' + """ return self.reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) - + def disable_symbolic_in_fit(self, lamb): - ''' + """ during fitting, disable symbolic if either is true (lamb = 0, none of symbolic functions is active) - ''' + """ old_save_act = self.save_act - if lamb == 0.: + if lamb == 0.0: self.save_act = False - + # skip symbolic if no symbolic is turned on depth = len(self.symbolic_fun) no_symbolic = True @@ -1398,19 +1597,46 @@ def disable_symbolic_in_fit(self, lamb): if no_symbolic: self.symbolic_enabled = False - + return old_save_act, old_symbolic_enabled - + def get_params(self): - ''' + """ Get parameters - ''' + """ return self.parameters() - - - def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_entropy=2., lamb_coef=0., lamb_coefdiff=0., update_grid=True, grid_update_num=10, loss_fn=None, lr=1.,start_grid_update_step=-1, stop_grid_update_step=50, batch=-1, - metrics=None, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', singularity_avoiding=False, y_th=1000., reg_metric='edge_forward_spline_n', display_metrics=None): - ''' + + def fit( + self, + dataset, + opt="LBFGS", + steps=100, + log=1, + lamb=0.0, + lamb_l1=1.0, + lamb_entropy=2.0, + lamb_coef=0.0, + lamb_coefdiff=0.0, + update_grid=True, + grid_update_num=10, + loss_fn=None, + lr=1.0, + start_grid_update_step=-1, + stop_grid_update_step=50, + batch=-1, + metrics=None, + save_fig=False, + in_vars=None, + out_vars=None, + beta=3, + save_fig_freq=1, + img_folder="./video", + singularity_avoiding=False, + y_th=1000.0, + reg_metric="edge_forward_spline_n", + display_metrics=None, + ): + """ training Args: @@ -1477,14 +1703,14 @@ def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_ >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.plot() # Most examples in toturals involve the fit() method. Please check them for useness. - ''' + """ + + if lamb > 0.0 and not self.save_act: + print("setting lamb=0. If you want to set lamb > 0, set self.save_act=True") - if lamb > 0. and not self.save_act: - print('setting lamb=0. If you want to set lamb > 0, set self.save_act=True') - old_save_act, old_symbolic_enabled = self.disable_symbolic_in_fit(lamb) - pbar = tqdm(range(steps), desc='description', ncols=100) + pbar = tqdm(range(steps), desc="description", ncols=100) if loss_fn == None: loss_fn = loss_fn_eval = lambda x, y: torch.mean((x - y) ** 2) @@ -1496,19 +1722,27 @@ def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_ if opt == "Adam": optimizer = torch.optim.Adam(self.get_params(), lr=lr) elif opt == "LBFGS": - optimizer = LBFGS(self.get_params(), lr=lr, history_size=10, line_search_fn="strong_wolfe", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32) + optimizer = LBFGS( + self.get_params(), + lr=lr, + history_size=10, + line_search_fn="strong_wolfe", + tolerance_grad=1e-32, + tolerance_change=1e-32, + tolerance_ys=1e-32, + ) results = {} - results['train_loss'] = [] - results['test_loss'] = [] - results['reg'] = [] + results["train_loss"] = [] + results["test_loss"] = [] + results["reg"] = [] if metrics != None: for i in range(len(metrics)): results[metrics[i].__name__] = [] - if batch == -1 or batch > dataset['train_input'].shape[0]: - batch_size = dataset['train_input'].shape[0] - batch_size_test = dataset['test_input'].shape[0] + if batch == -1 or batch > dataset["train_input"].shape[0]: + batch_size = dataset["train_input"].shape[0] + batch_size_test = dataset["test_input"].shape[0] else: batch_size = batch batch_size_test = batch @@ -1518,16 +1752,22 @@ def fit(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lamb_ def closure(): global train_loss, reg_ optimizer.zero_grad() - pred = self.forward(dataset['train_input'][train_id], singularity_avoiding=singularity_avoiding, y_th=y_th) - train_loss = loss_fn(pred, dataset['train_label'][train_id]) + pred = self.forward( + dataset["train_input"][train_id], + singularity_avoiding=singularity_avoiding, + y_th=y_th, + ) + train_loss = loss_fn(pred, dataset["train_label"][train_id]) if self.save_act: - if reg_metric == 'edge_backward': + if reg_metric == "edge_backward": self.attribute() - if reg_metric == 'node_backward': + if reg_metric == "node_backward": self.node_attribute() - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) + reg_ = self.get_reg( + reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff + ) else: - reg_ = torch.tensor(0.) + reg_ = torch.tensor(0.0) objective = train_loss + lamb * reg_ objective.backward() return objective @@ -1537,79 +1777,111 @@ def closure(): os.makedirs(img_folder) for _ in pbar: - - if _ == steps-1 and old_save_act: + if _ == steps - 1 and old_save_act: self.save_act = True - + if save_fig and _ % save_fig_freq == 0: save_act = self.save_act self.save_act = True - - train_id = np.random.choice(dataset['train_input'].shape[0], batch_size, replace=False) - test_id = np.random.choice(dataset['test_input'].shape[0], batch_size_test, replace=False) - if _ % grid_update_freq == 0 and _ < stop_grid_update_step and update_grid and _ >= start_grid_update_step: - self.update_grid(dataset['train_input'][train_id]) + train_id = np.random.choice( + dataset["train_input"].shape[0], batch_size, replace=False + ) + test_id = np.random.choice( + dataset["test_input"].shape[0], batch_size_test, replace=False + ) + + if ( + _ % grid_update_freq == 0 + and _ < stop_grid_update_step + and update_grid + and _ >= start_grid_update_step + ): + self.update_grid(dataset["train_input"][train_id]) if opt == "LBFGS": optimizer.step(closure) if opt == "Adam": - pred = self.forward(dataset['train_input'][train_id], singularity_avoiding=singularity_avoiding, y_th=y_th) - train_loss = loss_fn(pred, dataset['train_label'][train_id]) + pred = self.forward( + dataset["train_input"][train_id], + singularity_avoiding=singularity_avoiding, + y_th=y_th, + ) + train_loss = loss_fn(pred, dataset["train_label"][train_id]) if self.save_act: - if reg_metric == 'edge_backward': + if reg_metric == "edge_backward": self.attribute() - if reg_metric == 'node_backward': + if reg_metric == "node_backward": self.node_attribute() - reg_ = self.get_reg(reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff) + reg_ = self.get_reg( + reg_metric, lamb_l1, lamb_entropy, lamb_coef, lamb_coefdiff + ) else: - reg_ = torch.tensor(0.) + reg_ = torch.tensor(0.0) loss = train_loss + lamb * reg_ optimizer.zero_grad() loss.backward() optimizer.step() - test_loss = loss_fn_eval(self.forward(dataset['test_input'][test_id]), dataset['test_label'][test_id]) - - + test_loss = loss_fn_eval( + self.forward(dataset["test_input"][test_id]), + dataset["test_label"][test_id], + ) + if metrics != None: for i in range(len(metrics)): results[metrics[i].__name__].append(metrics[i]().item()) - results['train_loss'].append(torch.sqrt(train_loss).cpu().detach().numpy()) - results['test_loss'].append(torch.sqrt(test_loss).cpu().detach().numpy()) - results['reg'].append(reg_.cpu().detach().numpy()) + results["train_loss"].append(torch.sqrt(train_loss).cpu().detach().numpy()) + results["test_loss"].append(torch.sqrt(test_loss).cpu().detach().numpy()) + results["reg"].append(reg_.cpu().detach().numpy()) if _ % log == 0: if display_metrics == None: - pbar.set_description("| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " % (torch.sqrt(train_loss).cpu().detach().numpy(), torch.sqrt(test_loss).cpu().detach().numpy(), reg_.cpu().detach().numpy())) + pbar.set_description( + "| train_loss: %.2e | test_loss: %.2e | reg: %.2e | " + % ( + torch.sqrt(train_loss).cpu().detach().numpy(), + torch.sqrt(test_loss).cpu().detach().numpy(), + reg_.cpu().detach().numpy(), + ) + ) else: - string = '' + string = "" data = () for metric in display_metrics: - string += f' {metric}: %.2e |' + string += f" {metric}: %.2e |" try: results[metric] except: - raise Exception(f'{metric} not recognized') + raise Exception(f"{metric} not recognized") data += (results[metric][-1],) pbar.set_description(string % data) - - + if save_fig and _ % save_fig_freq == 0: - self.plot(folder=img_folder, in_vars=in_vars, out_vars=out_vars, title="Step {}".format(_), beta=beta) - plt.savefig(img_folder + '/' + str(_) + '.jpg', bbox_inches='tight', dpi=200) + self.plot( + folder=img_folder, + in_vars=in_vars, + out_vars=out_vars, + title="Step {}".format(_), + beta=beta, + ) + plt.savefig( + img_folder + "/" + str(_) + ".jpg", bbox_inches="tight", dpi=200 + ) plt.close() self.save_act = save_act - self.log_history('fit') + self.log_history("fit") # revert back to original state self.symbolic_enabled = old_symbolic_enabled return results - def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_history=True): - ''' + def prune_node( + self, threshold=1e-2, mode="auto", active_neurons_id=None, log_history=True + ): + """ pruning nodes Args: @@ -1618,7 +1890,7 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi if the attribution score of a neuron is below the threshold, it is considered dead and will be removed mode : str 'auto' or 'manual'. with 'auto', nodes are automatically pruned using threshold. with 'manual', active_neurons_id should be passed in. - + Returns: -------- pruned network : MultKAN @@ -1632,10 +1904,10 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model = model.prune_node() >>> model.plot() - ''' + """ if self.acts == None: self.get_act() - + mask_up = [torch.ones(self.width_in[0], device=self.device)] mask_down = [] active_neurons_up = [list(range(self.width_in[0]))] @@ -1643,36 +1915,53 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi num_sums = [] num_mults = [] mult_arities = [[]] - + if active_neurons_id != None: mode = "manual" for i in range(len(self.acts_scale) - 1): - mult_arity = [] - + if mode == "auto": self.attribute() - overall_important_up = self.node_scores[i+1] > threshold - + overall_important_up = self.node_scores[i + 1] > threshold + elif mode == "manual": - overall_important_up = torch.zeros(self.width_in[i + 1], dtype=torch.bool, device=self.device) + overall_important_up = torch.zeros( + self.width_in[i + 1], dtype=torch.bool, device=self.device + ) overall_important_up[active_neurons_id[i]] = True - - - num_sum = torch.sum(overall_important_up[:self.width[i+1][0]]) - num_mult = torch.sum(overall_important_up[self.width[i+1][0]:]) + + num_sum = torch.sum(overall_important_up[: self.width[i + 1][0]]) + num_mult = torch.sum(overall_important_up[self.width[i + 1][0] :]) if self.mult_homo == True: - overall_important_down = torch.cat([overall_important_up[:self.width[i+1][0]], (overall_important_up[self.width[i+1][0]:][None,:].expand(self.mult_arity,-1)).T.reshape(-1,)], dim=0) + overall_important_down = torch.cat( + [ + overall_important_up[: self.width[i + 1][0]], + ( + overall_important_up[self.width[i + 1][0] :][ + None, : + ].expand(self.mult_arity, -1) + ).T.reshape( + -1, + ), + ], + dim=0, + ) else: - overall_important_down = overall_important_up[:self.width[i+1][0]] - for j in range(overall_important_up[self.width[i+1][0]:].shape[0]): - active_bool = overall_important_up[self.width[i+1][0]+j] - arity = self.mult_arity[i+1][j] - overall_important_down = torch.cat([overall_important_down, torch.tensor([active_bool]*arity).to(self.device)]) + overall_important_down = overall_important_up[: self.width[i + 1][0]] + for j in range(overall_important_up[self.width[i + 1][0] :].shape[0]): + active_bool = overall_important_up[self.width[i + 1][0] + j] + arity = self.mult_arity[i + 1][j] + overall_important_down = torch.cat( + [ + overall_important_down, + torch.tensor([active_bool] * arity).to(self.device), + ] + ) if active_bool: mult_arity.append(arity) - + num_sums.append(num_sum.item()) num_mults.append(num_mult.item()) @@ -1681,12 +1970,12 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi active_neurons_up.append(torch.where(overall_important_up == True)[0]) active_neurons_down.append(torch.where(overall_important_down == True)[0]) - + mult_arities.append(mult_arity) active_neurons_down.append(list(range(self.width_out[-1]))) mask_down.append(torch.ones(self.width_out[-1], device=self.device)) - + if self.mult_homo == False: mult_arities.append(self.mult_arity[-1]) @@ -1697,63 +1986,85 @@ def prune_node(self, threshold=1e-2, mode="auto", active_neurons_id=None, log_hi for l in range(len(self.acts_scale) - 1): for i in range(self.width_in[l + 1]): if i not in active_neurons_up[l + 1]: - self.remove_node(l + 1, i, mode='up',log_history=False) - + self.remove_node(l + 1, i, mode="up", log_history=False) + for i in range(self.width_out[l + 1]): if i not in active_neurons_down[l]: - self.remove_node(l + 1, i, mode='down',log_history=False) - - model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun_name, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round).to(self.device) + self.remove_node(l + 1, i, mode="down", log_history=False) + + model2 = MultKAN( + copy.deepcopy(self.width), + grid=self.grid, + k=self.k, + base_fun=self.base_fun_name, + mult_arity=self.mult_arity, + ckpt_path=self.ckpt_path, + auto_save=True, + first_init=False, + state_id=self.state_id, + round=self.round, + ).to(self.device) model2.load_state_dict(self.state_dict()) - + width_new = [self.width[0]] - + for i in range(len(self.acts_scale)): - if i < len(self.acts_scale) - 1: num_sum = num_sums[i] num_mult = num_mults[i] - model2.node_bias[i].data = model2.node_bias[i].data[active_neurons_up[i+1]] - model2.node_scale[i].data = model2.node_scale[i].data[active_neurons_up[i+1]] - model2.subnode_bias[i].data = model2.subnode_bias[i].data[active_neurons_down[i]] - model2.subnode_scale[i].data = model2.subnode_scale[i].data[active_neurons_down[i]] - model2.width[i+1] = [num_sum, num_mult] - + model2.node_bias[i].data = model2.node_bias[i].data[ + active_neurons_up[i + 1] + ] + model2.node_scale[i].data = model2.node_scale[i].data[ + active_neurons_up[i + 1] + ] + model2.subnode_bias[i].data = model2.subnode_bias[i].data[ + active_neurons_down[i] + ] + model2.subnode_scale[i].data = model2.subnode_scale[i].data[ + active_neurons_down[i] + ] + model2.width[i + 1] = [num_sum, num_mult] + model2.act_fun[i].out_dim_sum = num_sum model2.act_fun[i].out_dim_mult = num_mult - + model2.symbolic_fun[i].out_dim_sum = num_sum model2.symbolic_fun[i].out_dim_mult = num_mult - + width_new.append([num_sum, num_mult]) - model2.act_fun[i] = model2.act_fun[i].get_subset(active_neurons_up[i], active_neurons_down[i]) - model2.symbolic_fun[i] = self.symbolic_fun[i].get_subset(active_neurons_up[i], active_neurons_down[i]) - + model2.act_fun[i] = model2.act_fun[i].get_subset( + active_neurons_up[i], active_neurons_down[i] + ) + model2.symbolic_fun[i] = self.symbolic_fun[i].get_subset( + active_neurons_up[i], active_neurons_down[i] + ) + model2.cache_data = self.cache_data model2.acts = None - + width_new.append(self.width[-1]) model2.width = width_new - + if self.mult_homo == False: model2.mult_arity = mult_arities - + if log_history: - self.log_history('prune_node') + self.log_history("prune_node") model2.state_id += 1 - + return model2 - + def prune_edge(self, threshold=3e-2, log_history=True): - ''' + """ pruning edges Args: ----- threshold : float if the attribution score of an edge is below the threshold, it is considered dead and will be set to zero. - + Returns: -------- pruned network : MultKAN @@ -1767,20 +2078,22 @@ def prune_edge(self, threshold=3e-2, log_history=True): >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model = model.prune_edge() >>> model.plot() - ''' + """ if self.acts == None: self.get_act() - - for i in range(len(self.width)-1): - #self.act_fun[i].mask.data = ((self.acts_scale[i] > threshold).permute(1,0)).float() + + for i in range(len(self.width) - 1): + # self.act_fun[i].mask.data = ((self.acts_scale[i] > threshold).permute(1,0)).float() old_mask = self.act_fun[i].mask.data - self.act_fun[i].mask.data = ((self.edge_scores[i] > threshold).permute(1,0)*old_mask).float() - + self.act_fun[i].mask.data = ( + (self.edge_scores[i] > threshold).permute(1, 0) * old_mask + ).float() + if log_history: - self.log_history('fix_symbolic') - + self.log_history("fix_symbolic") + def prune(self, node_th=1e-2, edge_th=3e-2): - ''' + """ prune (both nodes and edges) Args: @@ -1789,7 +2102,7 @@ def prune(self, node_th=1e-2, edge_th=3e-2): if the attribution score of a node is below node_th, it is considered dead and will be set to zero. edge_th : float if the attribution score of an edge is below node_th, it is considered dead and will be set to zero. - + Returns: -------- pruned network : MultKAN @@ -1803,20 +2116,20 @@ def prune(self, node_th=1e-2, edge_th=3e-2): >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model = model.prune() >>> model.plot() - ''' + """ if self.acts == None: self.get_act() - + self = self.prune_node(node_th, log_history=False) - #self.prune_node(node_th, log_history=False) + # self.prune_node(node_th, log_history=False) self.forward(self.cache_data) self.attribute() self.prune_edge(edge_th, log_history=False) - self.log_history('prune') + self.log_history("prune") return self - + def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True): - ''' + """ prune inputs Args: @@ -1825,7 +2138,7 @@ def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True): if the attribution score of the input feature is below threshold, it is considered irrelevant. active_inputs : None or list if a list is passed, the manual mode will disregard attribution score and prune as instructed. - + Returns: -------- pruned network : MultKAN @@ -1841,7 +2154,7 @@ def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True): >>> model.plot() >>> model = model.prune_input() >>> model.plot() - + Example2 -------- >>> # automatic @@ -1853,65 +2166,79 @@ def prune_input(self, threshold=1e-2, active_inputs=None, log_history=True): >>> model.plot() >>> model = model.prune_input(active_inputs=[0,1]) >>> model.plot() - ''' + """ if active_inputs == None: self.attribute() input_score = self.node_scores[0] input_mask = input_score > threshold - print('keep:', input_mask.tolist()) - input_id = torch.where(input_mask==True)[0] - + print("keep:", input_mask.tolist()) + input_id = torch.where(input_mask == True)[0] + else: input_id = torch.tensor(active_inputs, dtype=torch.long).to(self.device) - - model2 = MultKAN(copy.deepcopy(self.width), grid=self.grid, k=self.k, base_fun=self.base_fun, mult_arity=self.mult_arity, ckpt_path=self.ckpt_path, auto_save=True, first_init=False, state_id=self.state_id, round=self.round).to(self.device) + + model2 = MultKAN( + copy.deepcopy(self.width), + grid=self.grid, + k=self.k, + base_fun=self.base_fun, + mult_arity=self.mult_arity, + ckpt_path=self.ckpt_path, + auto_save=True, + first_init=False, + state_id=self.state_id, + round=self.round, + ).to(self.device) model2.load_state_dict(self.state_dict()) - model2.act_fun[0] = model2.act_fun[0].get_subset(input_id, torch.arange(self.width_out[1])) - model2.symbolic_fun[0] = self.symbolic_fun[0].get_subset(input_id, torch.arange(self.width_out[1])) + model2.act_fun[0] = model2.act_fun[0].get_subset( + input_id, torch.arange(self.width_out[1]) + ) + model2.symbolic_fun[0] = self.symbolic_fun[0].get_subset( + input_id, torch.arange(self.width_out[1]) + ) model2.cache_data = self.cache_data model2.acts = None model2.width[0] = [len(input_id), 0] model2.input_id = input_id - + if log_history: - self.log_history('prune_input') + self.log_history("prune_input") model2.state_id += 1 - + return model2 def remove_edge(self, l, i, j, log_history=True): - ''' + """ remove activtion phi(l,i,j) (set its mask to zero) - ''' - self.act_fun[l].mask[i][j] = 0. + """ + self.act_fun[l].mask[i][j] = 0.0 if log_history: - self.log_history('remove_edge') + self.log_history("remove_edge") - def remove_node(self, l ,i, mode='all', log_history=True): - ''' + def remove_node(self, l, i, mode="all", log_history=True): + """ remove neuron (l,i) (set the masks of all incoming and outgoing activation functions to zero) - ''' - if mode == 'down': - self.act_fun[l - 1].mask[:, i] = 0. - self.symbolic_fun[l - 1].mask[i, :] *= 0. - - elif mode == 'up': - self.act_fun[l].mask[i, :] = 0. - self.symbolic_fun[l].mask[:, i] *= 0. - + """ + if mode == "down": + self.act_fun[l - 1].mask[:, i] = 0.0 + self.symbolic_fun[l - 1].mask[i, :] *= 0.0 + + elif mode == "up": + self.act_fun[l].mask[i, :] = 0.0 + self.symbolic_fun[l].mask[:, i] *= 0.0 + else: - self.remove_node(l, i, mode='up') - self.remove_node(l, i, mode='down') - + self.remove_node(l, i, mode="up") + self.remove_node(l, i, mode="down") + if log_history: - self.log_history('remove_node') - - + self.log_history("remove_node") + def attribute(self, l=None, i=None, out_score=None, plot=True): - ''' + """ get attribution scores Args: @@ -1924,7 +2251,7 @@ def attribute(self, l=None, i=None, out_score=None, plot=True): specify output scores plot : bool when plot = True, display the bar show - + Returns: -------- attribution scores @@ -1938,44 +2265,56 @@ def attribute(self, l=None, i=None, out_score=None, plot=True): >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.attribute() >>> model.feature_score - ''' + """ # output (out_dim, in_dim) - + if l != None: self.attribute() out_score = self.node_scores[l] - + if self.acts == None: self.get_act() def score_node2subnode(node_score, width, mult_arity, out_dim): - assert np.sum(width) == node_score.shape[1] if isinstance(mult_arity, int): n_subnode = width[0] + mult_arity * width[1] else: n_subnode = width[0] + int(np.sum(mult_arity)) - #subnode_score_leaf = torch.zeros(out_dim, n_subnode).requires_grad_(True) - #subnode_score = subnode_score_leaf.clone() - #subnode_score[:,:width[0]] = node_score[:,:width[0]] - subnode_score = node_score[:,:width[0]] + # subnode_score_leaf = torch.zeros(out_dim, n_subnode).requires_grad_(True) + # subnode_score = subnode_score_leaf.clone() + # subnode_score[:,:width[0]] = node_score[:,:width[0]] + subnode_score = node_score[:, : width[0]] if isinstance(mult_arity, int): - #subnode_score[:,width[0]:] = node_score[:,width[0]:][:,:,None].expand(out_dim, node_score[width[0]:].shape[0], mult_arity).reshape(out_dim,-1) - subnode_score = torch.cat([subnode_score, node_score[:,width[0]:][:,:,None].expand(out_dim, node_score[:,width[0]:].shape[1], mult_arity).reshape(out_dim,-1)], dim=1) + # subnode_score[:,width[0]:] = node_score[:,width[0]:][:,:,None].expand(out_dim, node_score[width[0]:].shape[0], mult_arity).reshape(out_dim,-1) + subnode_score = torch.cat( + [ + subnode_score, + node_score[:, width[0] :][:, :, None] + .expand(out_dim, node_score[:, width[0] :].shape[1], mult_arity) + .reshape(out_dim, -1), + ], + dim=1, + ) else: acml = width[0] for i in range(len(mult_arity)): - #subnode_score[:, acml:acml+mult_arity[i]] = node_score[:, width[0]+i] - subnode_score = torch.cat([subnode_score, node_score[:, width[0]+i].expand(out_dim, mult_arity[i])], dim=1) + # subnode_score[:, acml:acml+mult_arity[i]] = node_score[:, width[0]+i] + subnode_score = torch.cat( + [ + subnode_score, + node_score[:, width[0] + i].expand(out_dim, mult_arity[i]), + ], + dim=1, + ) acml += mult_arity[i] return subnode_score - node_scores = [] subnode_scores = [] edge_scores = [] - + l_query = l if l == None: l_end = self.depth @@ -1989,23 +2328,31 @@ def score_node2subnode(node_score, width, mult_arity, out_dim): else: node_score = torch.diag(out_score).requires_grad_(True) node_scores.append(node_score) - - device = self.act_fun[0].grid.device - for l in range(l_end,0,-1): + device = self.act_fun[0].grid.device - # node to subnode + for l in range(l_end, 0, -1): + # node to subnode if isinstance(self.mult_arity, int): - subnode_score = score_node2subnode(node_score, self.width[l], self.mult_arity, out_dim=out_dim) + subnode_score = score_node2subnode( + node_score, self.width[l], self.mult_arity, out_dim=out_dim + ) else: mult_arity = self.mult_arity[l] - #subnode_score = score_node2subnode(node_score, self.width[l], mult_arity) - subnode_score = score_node2subnode(node_score, self.width[l], mult_arity, out_dim=out_dim) + # subnode_score = score_node2subnode(node_score, self.width[l], mult_arity) + subnode_score = score_node2subnode( + node_score, self.width[l], mult_arity, out_dim=out_dim + ) subnode_scores.append(subnode_score) # subnode to edge - #print(self.edge_actscale[l-1].device, subnode_score.device, self.subnode_actscale[l-1].device) - edge_score = torch.einsum('ij,ki,i->kij', self.edge_actscale[l-1], subnode_score.to(device), 1/(self.subnode_actscale[l-1]+1e-4)) + # print(self.edge_actscale[l-1].device, subnode_score.device, self.subnode_actscale[l-1].device) + edge_score = torch.einsum( + "ij,ki,i->kij", + self.edge_actscale[l - 1], + subnode_score.to(device), + 1 / (self.subnode_actscale[l - 1] + 1e-4), + ) edge_scores.append(edge_score) # edge to node @@ -2025,24 +2372,25 @@ def score_node2subnode(node_score, width, mult_arity, out_dim): if i == None: return self.node_scores_all[0] else: - # plot if plot: in_dim = self.width_in[0] - plt.figure(figsize=(1*in_dim, 3)) - plt.bar(range(in_dim),self.node_scores_all[0][i].cpu().detach().numpy()) - plt.xticks(range(in_dim)); + plt.figure(figsize=(1 * in_dim, 3)) + plt.bar( + range(in_dim), self.node_scores_all[0][i].cpu().detach().numpy() + ) + plt.xticks(range(in_dim)) return self.node_scores_all[0][i] - + def node_attribute(self): self.node_attribute_scores = [] - for l in range(1, self.depth+1): + for l in range(1, self.depth + 1): node_attr = self.attribute(l) self.node_attribute_scores.append(node_attr) - - def feature_interaction(self, l, neuron_th = 1e-2, feature_th = 1e-2): - ''' + + def feature_interaction(self, l, neuron_th=1e-2, feature_th=1e-2): + """ get feature interaction Args: @@ -2053,7 +2401,7 @@ def feature_interaction(self, l, neuron_th = 1e-2, feature_th = 1e-2): threshold to determine whether a neuron is active feature_th : float threshold to determine whether a feature is active - + Returns: -------- dictionary @@ -2067,15 +2415,19 @@ def feature_interaction(self, l, neuron_th = 1e-2, feature_th = 1e-2): >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.attribute() >>> model.feature_interaction(1) - ''' + """ dic = {} width = self.width_in[l] for i in range(width): - score = self.attribute(l,i,plot=False) + score = self.attribute(l, i, plot=False) if torch.max(score) > neuron_th: - features = tuple(torch.where(score > torch.max(score) * feature_th)[0].detach().numpy()) + features = tuple( + torch.where(score > torch.max(score) * feature_th)[0] + .detach() + .numpy() + ) if features in dic.keys(): dic[features] += 1 else: @@ -2083,8 +2435,21 @@ def feature_interaction(self, l, neuron_th = 1e-2, feature_th = 1e-2): return dic - def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=None, topk=5, verbose=True, r2_loss_fun=lambda x: np.log2(1+1e-5-x), c_loss_fun=lambda x: x, weight_simple = 0.8): - ''' + def suggest_symbolic( + self, + l, + i, + j, + a_range=(-10, 10), + b_range=(-10, 10), + lib=None, + topk=5, + verbose=True, + r2_loss_fun=lambda x: np.log2(1 + 1e-5 - x), + c_loss_fun=lambda x: x, + weight_simple=0.8, + ): + """ suggest symbolic function Args: @@ -2111,8 +2476,8 @@ def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=No function : c -> 'bits' weight_simple : float the simplifty weight: the higher, more prefer simplicity over performance - - + + Returns: -------- best_name (str), best_fun (function), best_r2 (float), best_c (float) @@ -2125,10 +2490,10 @@ def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=No >>> dataset = create_dataset(f, n_var=3) >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.suggest_symbolic(0,1,0) - ''' + """ r2s = [] cs = [] - + if lib == None: symbolic_lib = SYMBOLIC_LIB else: @@ -2137,9 +2502,18 @@ def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=No symbolic_lib[item] = SYMBOLIC_LIB[item] # getting r2 and complexities - for (name, content) in symbolic_lib.items(): - r2 = self.fix_symbolic(l, i, j, name, a_range=a_range, b_range=b_range, verbose=False, log_history=False) - if r2 == -1e8: # zero function + for name, content in symbolic_lib.items(): + r2 = self.fix_symbolic( + l, + i, + j, + name, + a_range=a_range, + b_range=b_range, + verbose=False, + log_history=False, + ) + if r2 == -1e8: # zero function r2s.append(-1e8) else: r2s.append(r2.item()) @@ -2149,29 +2523,31 @@ def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=No r2s = np.array(r2s) cs = np.array(cs) - r2_loss = r2_loss_fun(r2s).astype('float') + r2_loss = r2_loss_fun(r2s).astype("float") cs_loss = c_loss_fun(cs) - - loss = weight_simple * cs_loss + (1-weight_simple) * r2_loss - + + loss = weight_simple * cs_loss + (1 - weight_simple) * r2_loss + sorted_ids = np.argsort(loss)[:topk] r2s = r2s[sorted_ids][:topk] cs = cs[sorted_ids][:topk] r2_loss = r2_loss[sorted_ids][:topk] cs_loss = cs_loss[sorted_ids][:topk] loss = loss[sorted_ids][:topk] - + topk = np.minimum(topk, len(symbolic_lib)) - + if verbose == True: # print results in a dataframe results = {} - results['function'] = [list(symbolic_lib.items())[sorted_ids[i]][0] for i in range(topk)] - results['fitting r2'] = r2s[:topk] - results['r2 loss'] = r2_loss[:topk] - results['complexity'] = cs[:topk] - results['complexity loss'] = cs_loss[:topk] - results['total loss'] = loss[:topk] + results["function"] = [ + list(symbolic_lib.items())[sorted_ids[i]][0] for i in range(topk) + ] + results["fitting r2"] = r2s[:topk] + results["r2 loss"] = r2_loss[:topk] + results["complexity"] = cs[:topk] + results["complexity loss"] = cs_loss[:topk] + results["total loss"] = loss[:topk] df = pd.DataFrame(results) print(df) @@ -2180,11 +2556,19 @@ def suggest_symbolic(self, l, i, j, a_range=(-10, 10), b_range=(-10, 10), lib=No best_fun = list(symbolic_lib.items())[sorted_ids[0]][1] best_r2 = r2s[0] best_c = cs[0] - - return best_name, best_fun, best_r2, best_c; - def auto_symbolic(self, a_range=(-10, 10), b_range=(-10, 10), lib=None, verbose=1, weight_simple = 0.8, r2_threshold=0.0): - ''' + return best_name, best_fun, best_r2, best_c + + def auto_symbolic( + self, + a_range=(-10, 10), + b_range=(-10, 10), + lib=None, + verbose=1, + weight_simple=0.8, + r2_threshold=0.0, + ): + """ automatic symbolic regression for all edges Args: @@ -2213,28 +2597,51 @@ def auto_symbolic(self, a_range=(-10, 10), b_range=(-10, 10), lib=None, verbose= >>> dataset = create_dataset(f, n_var=3) >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.auto_symbolic() - ''' + """ for l in range(len(self.width_in) - 1): for i in range(self.width_in[l]): for j in range(self.width_out[l + 1]): - if self.symbolic_fun[l].mask[j, i] > 0. and self.act_fun[l].mask[i][j] == 0.: - print(f'skipping ({l},{i},{j}) since already symbolic') - elif self.symbolic_fun[l].mask[j, i] == 0. and self.act_fun[l].mask[i][j] == 0.: - self.fix_symbolic(l, i, j, '0', verbose=verbose > 1, log_history=False) - print(f'fixing ({l},{i},{j}) with 0') + if ( + self.symbolic_fun[l].mask[j, i] > 0.0 + and self.act_fun[l].mask[i][j] == 0.0 + ): + print(f"skipping ({l},{i},{j}) since already symbolic") + elif ( + self.symbolic_fun[l].mask[j, i] == 0.0 + and self.act_fun[l].mask[i][j] == 0.0 + ): + self.fix_symbolic( + l, i, j, "0", verbose=verbose > 1, log_history=False + ) + print(f"fixing ({l},{i},{j}) with 0") else: - name, fun, r2, c = self.suggest_symbolic(l, i, j, a_range=a_range, b_range=b_range, lib=lib, verbose=False, weight_simple=weight_simple) + name, fun, r2, c = self.suggest_symbolic( + l, + i, + j, + a_range=a_range, + b_range=b_range, + lib=lib, + verbose=False, + weight_simple=weight_simple, + ) if r2 >= r2_threshold: - self.fix_symbolic(l, i, j, name, verbose=verbose > 1, log_history=False) + self.fix_symbolic( + l, i, j, name, verbose=verbose > 1, log_history=False + ) if verbose >= 1: - print(f'fixing ({l},{i},{j}) with {name}, r2={r2}, c={c}') + print( + f"fixing ({l},{i},{j}) with {name}, r2={r2}, c={c}" + ) else: - print(f'For ({l},{i},{j}) the best fit was {name}, but r^2 = {r2} and this is lower than {r2_threshold}. This edge was omitted, keep training or try a different threshold.') - - self.log_history('auto_symbolic') + print( + f"For ({l},{i},{j}) the best fit was {name}, but r^2 = {r2} and this is lower than {r2_threshold}. This edge was omitted, keep training or try a different threshold." + ) - def symbolic_formula(self, var=None, normalizer=None, output_normalizer = None): - ''' + self.log_history("auto_symbolic") + + def symbolic_formula(self, var=None, normalizer=None, output_normalizer=None): + """ get symbolic formula Args: @@ -2243,7 +2650,7 @@ def symbolic_formula(self, var=None, normalizer=None, output_normalizer = None): input variables normalizer : [mean, std] output_normalizer : [mean, std] - + Returns: -------- None @@ -2257,8 +2664,8 @@ def symbolic_formula(self, var=None, normalizer=None, output_normalizer = None): >>> model.fit(dataset, opt='LBFGS', steps=20, lamb=0.001); >>> model.auto_symbolic() >>> model.symbolic_formula()[0][0] - ''' - + """ + symbolic_acts = [] symbolic_acts_premult = [] x = [] @@ -2294,41 +2701,43 @@ def ex_round(ex1, n_digit): num_mult = self.width[l + 1][1] y = [] for j in range(self.width_out[l + 1]): - yj = 0. + yj = 0.0 for i in range(self.width_in[l]): a, b, c, d = self.symbolic_fun[l].affine[j, i] sympy_fun = self.symbolic_fun[l].funs_sympy[j][i] try: yj += c * sympy_fun(a * x[i] + b) + d except: - print('make sure all activations need to be converted to symbolic formulas first!') + print( + "make sure all activations need to be converted to symbolic formulas first!" + ) return yj = self.subnode_scale[l][j] * yj + self.subnode_bias[l][j] if simplify == True: y.append(sympy.simplify(yj)) else: y.append(yj) - + symbolic_acts_premult.append(y) - + mult = [] for k in range(num_mult): if isinstance(self.mult_arity, int): mult_arity = self.mult_arity else: - mult_arity = self.mult_arity[l+1][k] - for i in range(mult_arity-1): + mult_arity = self.mult_arity[l + 1][k] + for i in range(mult_arity - 1): if i == 0: - mult_k = y[num_sum+2*k] * y[num_sum+2*k+1] + mult_k = y[num_sum + 2 * k] * y[num_sum + 2 * k + 1] else: - mult_k = mult_k * y[num_sum+2*k+i+1] + mult_k = mult_k * y[num_sum + 2 * k + i + 1] mult.append(mult_k) - + y = y[:num_sum] + mult - - for j in range(self.width_in[l+1]): + + for j in range(self.width_in[l + 1]): y[j] = self.node_scale[l][j] * y[j] + self.node_bias[l][j] - + x = y symbolic_acts.append(x) @@ -2337,46 +2746,56 @@ def ex_round(ex1, n_digit): means = output_normalizer[0] stds = output_normalizer[1] - assert len(output_layer) == len(means), 'output_normalizer does not match the output layer' - assert len(output_layer) == len(stds), 'output_normalizer does not match the output layer' - - output_layer = [(output_layer[i] * stds[i] + means[i]) for i in range(len(output_layer))] - symbolic_acts[-1] = output_layer + assert len(output_layer) == len(means), ( + "output_normalizer does not match the output layer" + ) + assert len(output_layer) == len(stds), ( + "output_normalizer does not match the output layer" + ) + output_layer = [ + (output_layer[i] * stds[i] + means[i]) for i in range(len(output_layer)) + ] + symbolic_acts[-1] = output_layer - self.symbolic_acts = [[symbolic_acts[l][i] for i in range(len(symbolic_acts[l]))] for l in range(len(symbolic_acts))] - self.symbolic_acts_premult = [[symbolic_acts_premult[l][i] for i in range(len(symbolic_acts_premult[l]))] for l in range(len(symbolic_acts_premult))] + self.symbolic_acts = [ + [symbolic_acts[l][i] for i in range(len(symbolic_acts[l]))] + for l in range(len(symbolic_acts)) + ] + self.symbolic_acts_premult = [ + [symbolic_acts_premult[l][i] for i in range(len(symbolic_acts_premult[l]))] + for l in range(len(symbolic_acts_premult)) + ] out_dim = len(symbolic_acts[-1]) - #return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 - + # return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 + if simplify: return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 else: return [symbolic_acts[-1][i] for i in range(len(symbolic_acts[-1]))], x0 - - + def expand_depth(self): - ''' + """ expand network depth, add an indentity layer to the end. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - + Args: ----- var : None or a list of sympy expression input variables normalizer : [mean, std] output_normalizer : [mean, std] - + Returns: -------- None - ''' + """ self.depth += 1 # add kanlayer, set mask to zero dim_out = self.width_in[-1] layer = KANLayer(dim_out, dim_out, num=self.grid, k=self.k) - layer.mask *= 0. + layer.mask *= 0.0 self.act_fun.append(layer) self.width.append([dim_out, 0]) @@ -2384,26 +2803,42 @@ def expand_depth(self): # add symbolic_kanlayer set mask to one. fun = identity on diagonal and zero for off-diagonal layer = Symbolic_KANLayer(dim_out, dim_out) - layer.mask += 1. + layer.mask += 1.0 for j in range(dim_out): for i in range(dim_out): if i == j: - layer.fix_symbolic(i,j,'x') + layer.fix_symbolic(i, j, "x") else: - layer.fix_symbolic(i,j,'0') + layer.fix_symbolic(i, j, "0") self.symbolic_fun.append(layer) - self.node_bias.append(torch.nn.Parameter(torch.zeros(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.node_scale.append(torch.nn.Parameter(torch.ones(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.subnode_bias.append(torch.nn.Parameter(torch.zeros(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) - self.subnode_scale.append(torch.nn.Parameter(torch.ones(dim_out,device=self.device)).requires_grad_(self.affine_trainable)) + self.node_bias.append( + torch.nn.Parameter(torch.zeros(dim_out, device=self.device)).requires_grad_( + self.affine_trainable + ) + ) + self.node_scale.append( + torch.nn.Parameter(torch.ones(dim_out, device=self.device)).requires_grad_( + self.affine_trainable + ) + ) + self.subnode_bias.append( + torch.nn.Parameter(torch.zeros(dim_out, device=self.device)).requires_grad_( + self.affine_trainable + ) + ) + self.subnode_scale.append( + torch.nn.Parameter(torch.ones(dim_out, device=self.device)).requires_grad_( + self.affine_trainable + ) + ) def expand_width(self, layer_id, n_added_nodes, sum_bool=True, mult_arity=2): - ''' + """ expand network width. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - + Args: ----- layer_id : int @@ -2414,79 +2849,117 @@ def expand_width(self, layer_id, n_added_nodes, sum_bool=True, mult_arity=2): if sum_bool == True, added nodes are addition nodes; otherwise multiplication nodes mult_arity : init multiplication arity (the number of numbers to be multiplied) - + Returns: -------- None - ''' - def _expand(layer_id, n_added_nodes, sum_bool=True, mult_arity=2, added_dim='out'): + """ + + def _expand( + layer_id, n_added_nodes, sum_bool=True, mult_arity=2, added_dim="out" + ): l = layer_id in_dim = self.symbolic_fun[l].in_dim out_dim = self.symbolic_fun[l].out_dim if sum_bool: - - if added_dim == 'out': + if added_dim == "out": new = Symbolic_KANLayer(in_dim, out_dim + n_added_nodes) old = self.symbolic_fun[l] in_id = np.arange(in_dim) - out_id = np.arange(out_dim + n_added_nodes) + out_id = np.arange(out_dim + n_added_nodes) for j in out_id: for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. + new.fix_symbolic(i, j, "0") + new.mask += 1.0 for j in out_id: for i in in_id: - if j > n_added_nodes-1: - new.funs[j][i] = old.funs[j-n_added_nodes][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j-n_added_nodes][i] - new.funs_sympy[j][i] = old.funs_sympy[j-n_added_nodes][i] - new.funs_name[j][i] = old.funs_name[j-n_added_nodes][i] - new.affine.data[j][i] = old.affine.data[j-n_added_nodes][i] + if j > n_added_nodes - 1: + new.funs[j][i] = old.funs[j - n_added_nodes][i] + new.funs_avoid_singularity[j][i] = ( + old.funs_avoid_singularity[j - n_added_nodes][i] + ) + new.funs_sympy[j][i] = old.funs_sympy[ + j - n_added_nodes + ][i] + new.funs_name[j][i] = old.funs_name[j - n_added_nodes][ + i + ] + new.affine.data[j][i] = old.affine.data[ + j - n_added_nodes + ][i] self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim, out_dim + n_added_nodes, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - self.node_scale[l].data = torch.cat([torch.ones(n_added_nodes, device=self.device), self.node_scale[l].data]) - self.node_bias[l].data = torch.cat([torch.zeros(n_added_nodes, device=self.device), self.node_bias[l].data]) - self.subnode_scale[l].data = torch.cat([torch.ones(n_added_nodes, device=self.device), self.subnode_scale[l].data]) - self.subnode_bias[l].data = torch.cat([torch.zeros(n_added_nodes, device=self.device), self.subnode_bias[l].data]) - - - - if added_dim == 'in': + self.act_fun[l] = KANLayer( + in_dim, out_dim + n_added_nodes, num=self.grid, k=self.k + ) + self.act_fun[l].mask *= 0.0 + + self.node_scale[l].data = torch.cat( + [ + torch.ones(n_added_nodes, device=self.device), + self.node_scale[l].data, + ] + ) + self.node_bias[l].data = torch.cat( + [ + torch.zeros(n_added_nodes, device=self.device), + self.node_bias[l].data, + ] + ) + self.subnode_scale[l].data = torch.cat( + [ + torch.ones(n_added_nodes, device=self.device), + self.subnode_scale[l].data, + ] + ) + self.subnode_bias[l].data = torch.cat( + [ + torch.zeros(n_added_nodes, device=self.device), + self.subnode_bias[l].data, + ] + ) + + if added_dim == "in": new = Symbolic_KANLayer(in_dim + n_added_nodes, out_dim) old = self.symbolic_fun[l] in_id = np.arange(in_dim + n_added_nodes) - out_id = np.arange(out_dim) + out_id = np.arange(out_dim) for j in out_id: for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. + new.fix_symbolic(i, j, "0") + new.mask += 1.0 for j in out_id: for i in in_id: - if i > n_added_nodes-1: - new.funs[j][i] = old.funs[j][i-n_added_nodes] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i-n_added_nodes] - new.funs_sympy[j][i] = old.funs_sympy[j][i-n_added_nodes] - new.funs_name[j][i] = old.funs_name[j][i-n_added_nodes] - new.affine.data[j][i] = old.affine.data[j][i-n_added_nodes] + if i > n_added_nodes - 1: + new.funs[j][i] = old.funs[j][i - n_added_nodes] + new.funs_avoid_singularity[j][i] = ( + old.funs_avoid_singularity[j][i - n_added_nodes] + ) + new.funs_sympy[j][i] = old.funs_sympy[j][ + i - n_added_nodes + ] + new.funs_name[j][i] = old.funs_name[j][ + i - n_added_nodes + ] + new.affine.data[j][i] = old.affine.data[j][ + i - n_added_nodes + ] self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - + self.act_fun[l] = KANLayer( + in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k + ) + self.act_fun[l].mask *= 0.0 else: - if isinstance(mult_arity, int): mult_arity = [mult_arity] * n_added_nodes - if added_dim == 'out': + if added_dim == "out": n_added_subnodes = np.sum(mult_arity) new = Symbolic_KANLayer(in_dim, out_dim + n_added_subnodes) old = self.symbolic_fun[l] @@ -2495,53 +2968,81 @@ def _expand(layer_id, n_added_nodes, sum_bool=True, mult_arity=2, added_dim='out for j in out_id: for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. + new.fix_symbolic(i, j, "0") + new.mask += 1.0 for j in out_id: for i in in_id: if j < out_dim: new.funs[j][i] = old.funs[j][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i] + new.funs_avoid_singularity[j][i] = ( + old.funs_avoid_singularity[j][i] + ) new.funs_sympy[j][i] = old.funs_sympy[j][i] new.funs_name[j][i] = old.funs_name[j][i] new.affine.data[j][i] = old.affine.data[j][i] self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim, out_dim + n_added_subnodes, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. - - self.node_scale[l].data = torch.cat([self.node_scale[l].data, torch.ones(n_added_nodes, device=self.device)]) - self.node_bias[l].data = torch.cat([self.node_bias[l].data, torch.zeros(n_added_nodes, device=self.device)]) - self.subnode_scale[l].data = torch.cat([self.subnode_scale[l].data, torch.ones(n_added_subnodes, device=self.device)]) - self.subnode_bias[l].data = torch.cat([self.subnode_bias[l].data, torch.zeros(n_added_subnodes, device=self.device)]) - - if added_dim == 'in': + self.act_fun[l] = KANLayer( + in_dim, out_dim + n_added_subnodes, num=self.grid, k=self.k + ) + self.act_fun[l].mask *= 0.0 + + self.node_scale[l].data = torch.cat( + [ + self.node_scale[l].data, + torch.ones(n_added_nodes, device=self.device), + ] + ) + self.node_bias[l].data = torch.cat( + [ + self.node_bias[l].data, + torch.zeros(n_added_nodes, device=self.device), + ] + ) + self.subnode_scale[l].data = torch.cat( + [ + self.subnode_scale[l].data, + torch.ones(n_added_subnodes, device=self.device), + ] + ) + self.subnode_bias[l].data = torch.cat( + [ + self.subnode_bias[l].data, + torch.zeros(n_added_subnodes, device=self.device), + ] + ) + + if added_dim == "in": new = Symbolic_KANLayer(in_dim + n_added_nodes, out_dim) old = self.symbolic_fun[l] in_id = np.arange(in_dim + n_added_nodes) - out_id = np.arange(out_dim) + out_id = np.arange(out_dim) for j in out_id: for i in in_id: - new.fix_symbolic(i,j,'0') - new.mask += 1. + new.fix_symbolic(i, j, "0") + new.mask += 1.0 for j in out_id: for i in in_id: if i < in_dim: new.funs[j][i] = old.funs[j][i] - new.funs_avoid_singularity[j][i] = old.funs_avoid_singularity[j][i] + new.funs_avoid_singularity[j][i] = ( + old.funs_avoid_singularity[j][i] + ) new.funs_sympy[j][i] = old.funs_sympy[j][i] new.funs_name[j][i] = old.funs_name[j][i] new.affine.data[j][i] = old.affine.data[j][i] self.symbolic_fun[l] = new - self.act_fun[l] = KANLayer(in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k) - self.act_fun[l].mask *= 0. + self.act_fun[l] = KANLayer( + in_dim + n_added_nodes, out_dim, num=self.grid, k=self.k + ) + self.act_fun[l].mask *= 0.0 - _expand(layer_id-1, n_added_nodes, sum_bool, mult_arity, added_dim='out') - _expand(layer_id, n_added_nodes, sum_bool, mult_arity, added_dim='in') + _expand(layer_id - 1, n_added_nodes, sum_bool, mult_arity, added_dim="out") + _expand(layer_id, n_added_nodes, sum_bool, mult_arity, added_dim="in") if sum_bool: self.width[layer_id][0] += n_added_nodes else: @@ -2550,141 +3051,159 @@ def _expand(layer_id, n_added_nodes, sum_bool=True, mult_arity=2, added_dim='out self.width[layer_id][1] += n_added_nodes self.mult_arity[layer_id] += mult_arity - - def perturb(self, mag=1.0, mode='non-intrusive'): - ''' + + def perturb(self, mag=1.0, mode="non-intrusive"): + """ preturb a network. For usage, please refer to tutorials interp_3_KAN_compiler.ipynb. - + Args: ----- mag : float perturbation magnitude mode : str pertubatation mode, choices = {'non-intrusive', 'all', 'minimal'} - + Returns: -------- None - ''' + """ perturb_bool = {} - - if mode == 'all': - perturb_bool['aa_a'] = True - perturb_bool['aa_i'] = True - perturb_bool['ai'] = True - perturb_bool['ia'] = True - perturb_bool['ii'] = True - elif mode == 'non-intrusive': - perturb_bool['aa_a'] = False - perturb_bool['aa_i'] = False - perturb_bool['ai'] = True - perturb_bool['ia'] = False - perturb_bool['ii'] = True - elif mode == 'minimal': - perturb_bool['aa_a'] = True - perturb_bool['aa_i'] = False - perturb_bool['ai'] = False - perturb_bool['ia'] = False - perturb_bool['ii'] = False + + if mode == "all": + perturb_bool["aa_a"] = True + perturb_bool["aa_i"] = True + perturb_bool["ai"] = True + perturb_bool["ia"] = True + perturb_bool["ii"] = True + elif mode == "non-intrusive": + perturb_bool["aa_a"] = False + perturb_bool["aa_i"] = False + perturb_bool["ai"] = True + perturb_bool["ia"] = False + perturb_bool["ii"] = True + elif mode == "minimal": + perturb_bool["aa_a"] = True + perturb_bool["aa_i"] = False + perturb_bool["ai"] = False + perturb_bool["ia"] = False + perturb_bool["ii"] = False else: - raise Exception('mode not recognized, valid modes are \'all\', \'non-intrusive\', \'minimal\'.') - + raise Exception( + "mode not recognized, valid modes are 'all', 'non-intrusive', 'minimal'." + ) + for l in range(self.depth): funs_name = self.symbolic_fun[l].funs_name - for j in range(self.width_out[l+1]): + for j in range(self.width_out[l + 1]): for i in range(self.width_in[l]): out_array = list(np.array(self.symbolic_fun[l].funs_name)[j]) - in_array = list(np.array(self.symbolic_fun[l].funs_name)[:,i]) - out_active = len([i for i, x in enumerate(out_array) if x != "0"]) > 0 + in_array = list(np.array(self.symbolic_fun[l].funs_name)[:, i]) + out_active = ( + len([i for i, x in enumerate(out_array) if x != "0"]) > 0 + ) in_active = len([i for i, x in enumerate(in_array) if x != "0"]) > 0 - dic = {True: 'a', False: 'i'} + dic = {True: "a", False: "i"} edge_type = dic[in_active] + dic[out_active] - - if l < self.depth - 1 or mode != 'non-intrusive': - - if edge_type == 'aa': - if self.symbolic_fun[l].funs_name[j][i] == '0': - edge_type += '_i' + + if l < self.depth - 1 or mode != "non-intrusive": + if edge_type == "aa": + if self.symbolic_fun[l].funs_name[j][i] == "0": + edge_type += "_i" else: - edge_type += '_a' + edge_type += "_a" if perturb_bool[edge_type]: self.act_fun[l].mask.data[i][j] = mag - - if l == self.depth - 1 and mode == 'non-intrusive': - - self.act_fun[l].mask.data[i][j] = torch.tensor(1.) - self.act_fun[l].scale_base.data[i][j] = torch.tensor(0.) - self.act_fun[l].scale_sp.data[i][j] = torch.tensor(0.) - + + if l == self.depth - 1 and mode == "non-intrusive": + self.act_fun[l].mask.data[i][j] = torch.tensor(1.0) + self.act_fun[l].scale_base.data[i][j] = torch.tensor(0.0) + self.act_fun[l].scale_sp.data[i][j] = torch.tensor(0.0) + self.get_act(self.cache_data) - - self.log_history('perturb') - - + + self.log_history("perturb") + def module(self, start_layer, chain): - ''' + """ specify network modules - + Args: ----- start_layer : int the earliest layer of the module chain : str specify neurons in the module - + Returns: -------- None - ''' - #chain = '[-1]->[-1,-2]->[-1]->[-1]' - groups = chain.split('->') - n_total_layers = len(groups)//2 - #start_layer = 0 + """ + # chain = '[-1]->[-1,-2]->[-1]->[-1]' + groups = chain.split("->") + n_total_layers = len(groups) // 2 + # start_layer = 0 for l in range(n_total_layers): current_layer = cl = start_layer + l - id_in = [int(i) for i in groups[2*l][1:-1].split(',')] - id_out = [int(i) for i in groups[2*l+1][1:-1].split(',')] + id_in = [int(i) for i in groups[2 * l][1:-1].split(",")] + id_out = [int(i) for i in groups[2 * l + 1][1:-1].split(",")] in_dim = self.width_in[cl] - out_dim = self.width_out[cl+1] + out_dim = self.width_out[cl + 1] id_in_other = list(set(range(in_dim)) - set(id_in)) id_out_other = list(set(range(out_dim)) - set(id_out)) - self.act_fun[cl].mask.data[np.ix_(id_in_other,id_out)] = 0. - self.act_fun[cl].mask.data[np.ix_(id_in,id_out_other)] = 0. - self.symbolic_fun[cl].mask.data[np.ix_(id_out,id_in_other)] = 0. - self.symbolic_fun[cl].mask.data[np.ix_(id_out_other,id_in)] = 0. - - self.log_history('module') - - def tree(self, x=None, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): - ''' + self.act_fun[cl].mask.data[np.ix_(id_in_other, id_out)] = 0.0 + self.act_fun[cl].mask.data[np.ix_(id_in, id_out_other)] = 0.0 + self.symbolic_fun[cl].mask.data[np.ix_(id_out, id_in_other)] = 0.0 + self.symbolic_fun[cl].mask.data[np.ix_(id_out_other, id_in)] = 0.0 + + self.log_history("module") + + def tree( + self, + x=None, + in_var=None, + style="tree", + sym_th=1e-3, + sep_th=1e-1, + skip_sep_test=False, + verbose=False, + ): + """ turn KAN into a tree - ''' + """ if x == None: x = self.cache_data - plot_tree(self, x, in_var=in_var, style=style, sym_th=sym_th, sep_th=sep_th, skip_sep_test=skip_sep_test, verbose=verbose) - - + plot_tree( + self, + x, + in_var=in_var, + style=style, + sym_th=sym_th, + sep_th=sep_th, + skip_sep_test=skip_sep_test, + verbose=verbose, + ) + def speed(self, compile=False): - ''' + """ turn on KAN's speed mode - ''' - self.symbolic_enabled=False - self.save_act=False - self.auto_save=False + """ + self.symbolic_enabled = False + self.save_act = False + self.auto_save = False if compile == True: return torch.compile(self) else: return self - + def get_act(self, x=None): - ''' + """ collect intermidate activations - ''' + """ if isinstance(x, dict): - x = x['train_input'] + x = x["train_input"] if x == None: if self.cache_data != None: x = self.cache_data @@ -2694,80 +3213,84 @@ def get_act(self, x=None): self.save_act = True self.forward(x) self.save_act = save_act - + def get_fun(self, l, i, j): - ''' + """ get function (l,i,j) - ''' - inputs = self.spline_preacts[l][:,j,i].cpu().detach().numpy() - outputs = self.spline_postacts[l][:,j,i].cpu().detach().numpy() + """ + inputs = self.spline_preacts[l][:, j, i].cpu().detach().numpy() + outputs = self.spline_postacts[l][:, j, i].cpu().detach().numpy() # they are not ordered yet rank = np.argsort(inputs) inputs = inputs[rank] outputs = outputs[rank] - plt.figure(figsize=(3,3)) + plt.figure(figsize=(3, 3)) plt.plot(inputs, outputs, marker="o") return inputs, outputs - - - def history(self, k='all'): - ''' + + def history(self, k="all"): + """ get history - ''' - with open(self.ckpt_path+'/history.txt', 'r') as f: + """ + with open(self.ckpt_path + "/history.txt", "r") as f: data = f.readlines() n_line = len(data) - if k == 'all': + if k == "all": k = n_line data = data[-k:] for line in data: print(line[:-1]) + @property def n_edge(self): - ''' + """ the number of active edges - ''' + """ depth = len(self.act_fun) complexity = 0 for l in range(depth): - complexity += torch.sum(self.act_fun[l].mask > 0.) + complexity += torch.sum(self.act_fun[l].mask > 0.0) return complexity.item() - + def evaluate(self, dataset): evaluation = {} - evaluation['test_loss'] = torch.sqrt(torch.mean((self.forward(dataset['test_input']) - dataset['test_label'])**2)).item() - evaluation['n_edge'] = self.n_edge - evaluation['n_grid'] = self.grid + evaluation["test_loss"] = torch.sqrt( + torch.mean( + (self.forward(dataset["test_input"]) - dataset["test_label"]) ** 2 + ) + ).item() + evaluation["n_edge"] = self.n_edge + evaluation["n_grid"] = self.grid # add other metrics (maybe accuracy) return evaluation - + def swap(self, l, i1, i2, log_history=True): - - self.act_fun[l-1].swap(i1,i2,mode='out') - self.symbolic_fun[l-1].swap(i1,i2,mode='out') - self.act_fun[l].swap(i1,i2,mode='in') - self.symbolic_fun[l].swap(i1,i2,mode='in') - + self.act_fun[l - 1].swap(i1, i2, mode="out") + self.symbolic_fun[l - 1].swap(i1, i2, mode="out") + self.act_fun[l].swap(i1, i2, mode="in") + self.symbolic_fun[l].swap(i1, i2, mode="in") + def swap_(data, i1, i2): data[i1], data[i2] = data[i2], data[i1] - - swap_(self.node_scale[l-1].data, i1, i2) - swap_(self.node_bias[l-1].data, i1, i2) - swap_(self.subnode_scale[l-1].data, i1, i2) - swap_(self.subnode_bias[l-1].data, i1, i2) - + + swap_(self.node_scale[l - 1].data, i1, i2) + swap_(self.node_bias[l - 1].data, i1, i2) + swap_(self.subnode_scale[l - 1].data, i1, i2) + swap_(self.subnode_bias[l - 1].data, i1, i2) + if log_history: - self.log_history('swap') - + self.log_history("swap") + @property def connection_cost(self): - - cc = 0. + cc = 0.0 for t in self.edge_scores: - + def get_coordinate(n): - return torch.linspace(0,1,steps=n+1, device=self.device)[:n] + 1/(2*n) + return torch.linspace(0, 1, steps=n + 1, device=self.device)[:n] + 1 / ( + 2 * n + ) in_dim = t.shape[0] x_in = get_coordinate(in_dim) @@ -2775,34 +3298,34 @@ def get_coordinate(n): out_dim = t.shape[1] x_out = get_coordinate(out_dim) - dist = torch.abs(x_in[:,None] - x_out[None,:]) + dist = torch.abs(x_in[:, None] - x_out[None, :]) cc += torch.sum(dist * t) return cc - - def auto_swap_l(self, l): + def auto_swap_l(self, l): num = self.width_in[1] for i in range(num): ccs = [] for j in range(num): - self.swap(l,i,j,log_history=False) + self.swap(l, i, j, log_history=False) self.get_act() self.attribute() cc = self.connection_cost.detach().clone() ccs.append(cc) - self.swap(l,i,j,log_history=False) + self.swap(l, i, j, log_history=False) j = torch.argmin(torch.tensor(ccs)) - self.swap(l,i,j,log_history=False) + self.swap(l, i, j, log_history=False) def auto_swap(self): - ''' + """ automatically swap neurons such as connection costs are minimized - ''' + """ depth = self.depth for l in range(1, depth): self.auto_swap_l(l) - - self.log_history('auto_swap') + + self.log_history("auto_swap") + KAN = MultKAN diff --git a/kan/Symbolic_KANLayer.py b/kan/Symbolic_KANLayer.py index 3b199293c..8c0e23936 100644 --- a/kan/Symbolic_KANLayer.py +++ b/kan/Symbolic_KANLayer.py @@ -1,13 +1,10 @@ import torch import torch.nn as nn -import numpy as np -import sympy from .utils import * - class Symbolic_KANLayer(nn.Module): - ''' + """ KANLayer class Attributes: @@ -25,11 +22,12 @@ class Symbolic_KANLayer(nn.Module): symbolic functions (sympy) affine : 3D array of floats affine transformations of inputs and outputs - ''' - def __init__(self, in_dim=3, out_dim=2, device='cpu'): - ''' + """ + + def __init__(self, in_dim=3, out_dim=2, device="cpu"): + """ initialize a Symbolic_KANLayer (activation functions are initialized to be identity functions) - + Args: ----- in_dim : int @@ -38,63 +36,74 @@ def __init__(self, in_dim=3, out_dim=2, device='cpu'): output dimension device : str device - + Returns: -------- self - + Example ------- >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=3) >>> len(sb.funs), len(sb.funs[0]) - ''' + """ super(Symbolic_KANLayer, self).__init__() self.out_dim = out_dim self.in_dim = in_dim - self.mask = torch.nn.Parameter(torch.zeros(out_dim, in_dim, device=device)).requires_grad_(False) + self.mask = torch.nn.Parameter( + torch.zeros(out_dim, in_dim, device=device) + ).requires_grad_(False) # torch - self.funs = [[lambda x: x*0. for i in range(self.in_dim)] for j in range(self.out_dim)] - self.funs_avoid_singularity = [[lambda x, y_th: ((), x*0.) for i in range(self.in_dim)] for j in range(self.out_dim)] + self.funs = [ + [lambda x: x * 0.0 for i in range(self.in_dim)] for j in range(self.out_dim) + ] + self.funs_avoid_singularity = [ + [lambda x, y_th: ((), x * 0.0) for i in range(self.in_dim)] + for j in range(self.out_dim) + ] # name - self.funs_name = [['0' for i in range(self.in_dim)] for j in range(self.out_dim)] + self.funs_name = [ + ["0" for i in range(self.in_dim)] for j in range(self.out_dim) + ] # sympy - self.funs_sympy = [[lambda x: x*0. for i in range(self.in_dim)] for j in range(self.out_dim)] + self.funs_sympy = [ + [lambda x: x * 0.0 for i in range(self.in_dim)] for j in range(self.out_dim) + ] ### make funs_name the only parameter, and make others as the properties of funs_name? - + self.affine = torch.nn.Parameter(torch.zeros(out_dim, in_dim, 4, device=device)) # c*f(a*x+b)+d - + self.device = device self.to(device) - + def to(self, device): - ''' + """ move to device - ''' + """ super(Symbolic_KANLayer, self).to(device) - self.device = device + self.device = device return self - - def forward(self, x, singularity_avoiding=False, y_th=10.): - ''' + + def forward(self, x, singularity_avoiding=False, y_th=10.0): + """ forward - + Args: ----- x : 2D array inputs, shape (batch, input dimension) singularity_avoiding : bool - if True, funs_avoid_singularity is used; if False, funs is used. + if True, funs_avoid_singularity is used; if False, funs is used. y_th : float the singularity threshold - + Returns: -------- y : 2D array outputs, shape (batch, output dimension) postacts : 3D array activations after activation functions but before being summed on nodes - + Example ------- >>> sb = Symbolic_KANLayer(in_dim=3, out_dim=5) @@ -102,8 +111,8 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): >>> y, postacts = sb(x) >>> y.shape, postacts.shape (torch.Size([100, 5]), torch.Size([100, 5, 3])) - ''' - + """ + batch = x.shape[0] postacts = [] @@ -111,61 +120,85 @@ def forward(self, x, singularity_avoiding=False, y_th=10.): postacts_ = [] for j in range(self.out_dim): if singularity_avoiding: - xij = self.affine[j,i,2]*self.funs_avoid_singularity[j][i](self.affine[j,i,0]*x[:,[i]]+self.affine[j,i,1], torch.tensor(y_th))[1]+self.affine[j,i,3] + xij = ( + self.affine[j, i, 2] + * self.funs_avoid_singularity[j][i]( + self.affine[j, i, 0] * x[:, [i]] + self.affine[j, i, 1], + torch.tensor(y_th), + )[1] + + self.affine[j, i, 3] + ) else: - xij = self.affine[j,i,2]*self.funs[j][i](self.affine[j,i,0]*x[:,[i]]+self.affine[j,i,1])+self.affine[j,i,3] - postacts_.append(self.mask[j][i]*xij) + xij = ( + self.affine[j, i, 2] + * self.funs[j][i]( + self.affine[j, i, 0] * x[:, [i]] + self.affine[j, i, 1] + ) + + self.affine[j, i, 3] + ) + postacts_.append(self.mask[j][i] * xij) postacts.append(torch.stack(postacts_)) postacts = torch.stack(postacts) - postacts = postacts.permute(2,1,0,3)[:,:,:,0] + postacts = postacts.permute(2, 1, 0, 3)[:, :, :, 0] y = torch.sum(postacts, dim=2) - + return y, postacts - - + def get_subset(self, in_id, out_id): - ''' + """ get a smaller Symbolic_KANLayer from a larger Symbolic_KANLayer (used for pruning) - + Args: ----- in_id : list id of selected input neurons out_id : list id of selected output neurons - + Returns: -------- spb : Symbolic_KANLayer - + Example ------- >>> sb_large = Symbolic_KANLayer(in_dim=10, out_dim=10) >>> sb_small = sb_large.get_subset([0,9],[1,2,3]) >>> sb_small.in_dim, sb_small.out_dim - ''' + """ sbb = Symbolic_KANLayer(self.in_dim, self.out_dim, device=self.device) sbb.in_dim = len(in_id) sbb.out_dim = len(out_id) - sbb.mask.data = self.mask.data[out_id][:,in_id] + sbb.mask.data = self.mask.data[out_id][:, in_id] sbb.funs = [[self.funs[j][i] for i in in_id] for j in out_id] - sbb.funs_avoid_singularity = [[self.funs_avoid_singularity[j][i] for i in in_id] for j in out_id] + sbb.funs_avoid_singularity = [ + [self.funs_avoid_singularity[j][i] for i in in_id] for j in out_id + ] sbb.funs_sympy = [[self.funs_sympy[j][i] for i in in_id] for j in out_id] sbb.funs_name = [[self.funs_name[j][i] for i in in_id] for j in out_id] - sbb.affine.data = self.affine.data[out_id][:,in_id] + sbb.affine.data = self.affine.data[out_id][:, in_id] return sbb - - - def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-10,10), b_range=(-10,10), verbose=True): - ''' + + def fix_symbolic( + self, + i, + j, + fun_name, + x=None, + y=None, + random=False, + a_range=(-10, 10), + b_range=(-10, 10), + verbose=True, + ): + """ fix an activation function to be symbolic - + Args: ----- i : int the id of input neuron - j : int + j : int the id of output neuron fun_name : str the name of the symbolic functions @@ -179,11 +212,11 @@ def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-1 sweeping range of a verbose : bool print more information if True - + Returns: -------- r2 (coefficient of determination) - + Example 1 --------- >>> # when x & y are not provided. Affine parameters are set to a = 1, b = 0, c = 1, d = 0 @@ -191,7 +224,7 @@ def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-1 >>> sb.fix_symbolic(2,1,'sin') >>> print(sb.funs_name) >>> print(sb.affine) - + Example 2 --------- >>> # when x & y are provided, fit_params() is called to find the best fit coefficients @@ -203,26 +236,36 @@ def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-1 >>> sb.fix_symbolic(2,1,'sin',x,y) >>> print(sb.funs_name) >>> print(sb.affine[1,2,:].data) - ''' - if isinstance(fun_name,str): + """ + if isinstance(fun_name, str): fun = SYMBOLIC_LIB[fun_name][0] fun_sympy = SYMBOLIC_LIB[fun_name][1] fun_avoid_singularity = SYMBOLIC_LIB[fun_name][3] self.funs_sympy[j][i] = fun_sympy self.funs_name[j][i] = fun_name - + if x == None or y == None: - #initialzie from just fun + # initialzie from just fun self.funs[j][i] = fun self.funs_avoid_singularity[j][i] = fun_avoid_singularity if random == False: - self.affine.data[j][i] = torch.tensor([1.,0.,1.,0.], device=self.device) + self.affine.data[j][i] = torch.tensor( + [1.0, 0.0, 1.0, 0.0], device=self.device + ) else: self.affine.data[j][i] = torch.rand(4, device=self.device) * 2 - 1 return None else: - #initialize from x & y and fun - params, r2 = fit_params(x,y,fun, a_range=a_range, b_range=b_range, verbose=verbose, device=self.device) + # initialize from x & y and fun + params, r2 = fit_params( + x, + y, + fun, + a_range=a_range, + b_range=b_range, + verbose=verbose, + device=self.device, + ) self.funs[j][i] = fun self.funs_avoid_singularity[j][i] = fun_avoid_singularity self.affine.data[j][i] = params @@ -237,34 +280,36 @@ def fix_symbolic(self, i, j, fun_name, x=None, y=None, random=False, a_range=(-1 self.funs[j][i] = fun self.funs_avoid_singularity[j][i] = fun if random == False: - self.affine.data[j][i] = torch.tensor([1.,0.,1.,0.], device=self.device) + self.affine.data[j][i] = torch.tensor( + [1.0, 0.0, 1.0, 0.0], device=self.device + ) else: self.affine.data[j][i] = torch.rand(4, device=self.device) * 2 - 1 return None - - def swap(self, i1, i2, mode='in'): - ''' - swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') - ''' + + def swap(self, i1, i2, mode="in"): + """ + swap the i1 neuron with the i2 neuron in input (if mode == 'in') or output (if mode == 'out') + """ with torch.no_grad(): - def swap_list_(data, i1, i2, mode='in'): - if mode == 'in': + def swap_list_(data, i1, i2, mode="in"): + if mode == "in": for j in range(self.out_dim): data[j][i1], data[j][i2] = data[j][i2], data[j][i1] - elif mode == 'out': - data[i1], data[i2] = data[i2], data[i1] + elif mode == "out": + data[i1], data[i2] = data[i2], data[i1] - def swap_(data, i1, i2, mode='in'): - if mode == 'in': - data[:,i1], data[:,i2] = data[:,i2].clone(), data[:,i1].clone() + def swap_(data, i1, i2, mode="in"): + if mode == "in": + data[:, i1], data[:, i2] = data[:, i2].clone(), data[:, i1].clone() - elif mode == 'out': + elif mode == "out": data[i1], data[i2] = data[i2].clone(), data[i1].clone() - swap_list_(self.funs_name,i1,i2,mode) - swap_list_(self.funs_sympy,i1,i2,mode) - swap_list_(self.funs_avoid_singularity,i1,i2,mode) - swap_(self.affine.data,i1,i2,mode) - swap_(self.mask.data,i1,i2,mode) + swap_list_(self.funs_name, i1, i2, mode) + swap_list_(self.funs_sympy, i1, i2, mode) + swap_list_(self.funs_avoid_singularity, i1, i2, mode) + swap_(self.affine.data, i1, i2, mode) + swap_(self.mask.data, i1, i2, mode) diff --git a/kan/__init__.py b/kan/__init__.py index 1ce0e47b2..8020b4cc6 100644 --- a/kan/__init__.py +++ b/kan/__init__.py @@ -1,3 +1,3 @@ from .MultKAN import * from .utils import * -#torch.use_deterministic_algorithms(True) \ No newline at end of file +# torch.use_deterministic_algorithms(True) diff --git a/kan/compiler.py b/kan/compiler.py index c8014829e..e54779c20 100644 --- a/kan/compiler.py +++ b/kan/compiler.py @@ -1,11 +1,11 @@ from sympy import * -import sympy import numpy as np from kan.MultKAN import MultKAN import torch + def next_nontrivial_operation(expr, scale=1, bias=0): - ''' + """ remove the affine part of an expression Args: @@ -27,7 +27,7 @@ def next_nontrivial_operation(expr, scale=1, bias=0): >>> input_vars = a, b = symbols('a b') >>> expression = 3.14534242 * exp(sin(pi*a) + b**2) - 2.32345402 >>> next_nontrivial_operation(expression) - ''' + """ if expr.func == Add or expr.func == Mul: n_arg = len(expr.args) n_num = 0 @@ -56,16 +56,16 @@ def next_nontrivial_operation(expr, scale=1, bias=0): scale = expr.args[n_num_id[i]] else: scale *= expr.args[n_num_id[i]] - + return next_nontrivial_operation(expr.func(*var_args), scale, bias) else: return expr, scale, bias else: return expr, scale, bias - + def expr2kan(input_variables, expr, grid=5, k=3, auto_save=False): - ''' + """ compile a symbolic formula to a MultKAN Args: @@ -93,9 +93,12 @@ def expr2kan(input_variables, expr, grid=5, k=3, auto_save=False): >>> x = torch.rand(100,2) * 2 - 1 >>> model(x) >>> model.plot() - ''' + """ + class Node: - def __init__(self, expr, mult_bool, depth, scale, bias, parent=None, mult_arity=None): + def __init__( + self, expr, mult_bool, depth, scale, bias, parent=None, mult_arity=None + ): self.expr = expr self.mult_bool = mult_bool if self.mult_bool: @@ -121,11 +124,9 @@ def __init__(self, expr, mult_bool, depth, scale, bias, parent=None, mult_arity= if parent != None: parent.child_index.append(self.index) - self.scale = scale self.bias = bias - class SubNode: def __init__(self, expr, depth, scale, bias, parent=None): self.expr = expr @@ -140,8 +141,8 @@ def __init__(self, expr, depth, scale, bias, parent=None): SubNodes[depth].append(self) self.index = index - self.parent_index = None # shape: (2,) - self.child_index = [] # shape: (n, 2) + self.parent_index = None # shape: (2,) + self.child_index = [] # shape: (n, 2) # update parent's child_index parent.child_index.append(self.index) @@ -149,90 +150,136 @@ def __init__(self, expr, depth, scale, bias, parent=None): self.scale = scale self.bias = bias - class Connection: - def __init__(self, affine, fun, fun_name, parent=None, child=None, power_exponent=None): + def __init__( + self, affine, fun, fun_name, parent=None, child=None, power_exponent=None + ): # connection = activation function that connects a subnode to a node in the next layer node - self.affine = affine #[1,0,1,0] # (a,b,c,d) - self.fun = fun # y = c*fun(a*x+b)+d + self.affine = affine # [1,0,1,0] # (a,b,c,d) + self.fun = fun # y = c*fun(a*x+b)+d self.fun_name = fun_name self.parent_index = parent.index self.depth = parent.depth self.child_index = child.index - self.power_exponent = power_exponent # if fun == Pow - Connections[(self.depth,self.parent_index,self.child_index)] = self - + self.power_exponent = power_exponent # if fun == Pow + Connections[(self.depth, self.parent_index, self.child_index)] = self + def create_node(expr, parent=None, n_layer=None): - #print('before', expr) - expr, scale, bias = next_nontrivial_operation(expr) - #print('after', expr) + # print('before', expr) + expr, scale, bias = next_nontrivial_operation(expr) + # print('after', expr) if parent == None: depth = 0 else: depth = parent.depth - if expr.func == Mul: mult_arity = len(expr.args) - node = Node(expr, True, depth, scale, bias, parent=parent, mult_arity=mult_arity) + node = Node( + expr, True, depth, scale, bias, parent=parent, mult_arity=mult_arity + ) # create mult_arity SubNodes, + 1 for i in range(mult_arity): # create SubNode expr_i, scale, bias = next_nontrivial_operation(expr.args[i]) - subnode = SubNode(expr_i, node.depth+1, scale, bias, parent=node) + subnode = SubNode(expr_i, node.depth + 1, scale, bias, parent=node) if expr_i.func == Add: for j in range(len(expr_i.args)): expr_ij, scale, bias = next_nontrivial_operation(expr_i.args[j]) # expr_ij is impossible to be Add, should be Mul or 1D if expr_ij.func == Mul: - #print(expr_ij) + # print(expr_ij) # create a node with expr_ij - new_node = create_node(expr_ij, parent=subnode, n_layer=n_layer) + new_node = create_node( + expr_ij, parent=subnode, n_layer=n_layer + ) # create a connection which is a linear function - c = Connection([1,0,float(scale),float(bias)], lambda x: x, 'x', parent=subnode, child=new_node) + c = Connection( + [1, 0, float(scale), float(bias)], + lambda x: x, + "x", + parent=subnode, + child=new_node, + ) elif expr_ij.func == Symbol: - #print(expr_ij) - new_node = create_node(expr_ij, parent=subnode, n_layer=n_layer) - c = Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) + # print(expr_ij) + new_node = create_node( + expr_ij, parent=subnode, n_layer=n_layer + ) + c = Connection( + [1, 0, float(scale), float(bias)], + lambda x: x, + fun_name="x", + parent=subnode, + child=new_node, + ) else: # 1D function case # create a node with expr_ij.args[0] - new_node = create_node(expr_ij.args[0], parent=subnode, n_layer=n_layer) + new_node = create_node( + expr_ij.args[0], parent=subnode, n_layer=n_layer + ) # create 1D function expr_ij.func if expr_ij.func == Pow: power_exponent = expr_ij.args[1] else: power_exponent = None - Connection([1,0,float(scale),float(bias)], expr_ij.func, fun_name = expr_ij.func, parent=subnode, child=new_node, power_exponent=power_exponent) - + Connection( + [1, 0, float(scale), float(bias)], + expr_ij.func, + fun_name=expr_ij.func, + parent=subnode, + child=new_node, + power_exponent=power_exponent, + ) elif expr_i.func == Mul: # create a node with expr_i new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) # create 1D function, linear - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) + Connection( + [1, 0, 1, 0], + lambda x: x, + fun_name="x", + parent=subnode, + child=new_node, + ) elif expr_i.func == Symbol: new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) + Connection( + [1, 0, 1, 0], + lambda x: x, + fun_name="x", + parent=subnode, + child=new_node, + ) else: # 1D functions # create a node with expr_i.args[0] - new_node = create_node(expr_i.args[0], parent=subnode, n_layer=n_layer) + new_node = create_node( + expr_i.args[0], parent=subnode, n_layer=n_layer + ) # create 1D function expr_i.func if expr_i.func == Pow: power_exponent = expr_i.args[1] else: power_exponent = None - Connection([1,0,1,0], expr_i.func, fun_name = expr_i.func, parent=subnode, child=new_node, power_exponent=power_exponent) + Connection( + [1, 0, 1, 0], + expr_i.func, + fun_name=expr_i.func, + parent=subnode, + child=new_node, + power_exponent=power_exponent, + ) elif expr.func == Add: - node = Node(expr, False, depth, scale, bias, parent=parent) - subnode = SubNode(expr, node.depth+1, 1, 0, parent=node) + subnode = SubNode(expr, node.depth + 1, 1, 0, parent=node) for i in range(len(expr.args)): expr_i, scale, bias = next_nontrivial_operation(expr.args[i]) @@ -240,22 +287,43 @@ def create_node(expr, parent=None, n_layer=None): # create a node with expr_i new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) # create a connection which is a linear function - Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) + Connection( + [1, 0, float(scale), float(bias)], + lambda x: x, + fun_name="x", + parent=subnode, + child=new_node, + ) elif expr_i.func == Symbol: new_node = create_node(expr_i, parent=subnode, n_layer=n_layer) - Connection([1,0,float(scale),float(bias)], lambda x: x, fun_name = 'x', parent=subnode, child=new_node) + Connection( + [1, 0, float(scale), float(bias)], + lambda x: x, + fun_name="x", + parent=subnode, + child=new_node, + ) else: # 1D function case # create a node with expr_ij.args[0] - new_node = create_node(expr_i.args[0], parent=subnode, n_layer=n_layer) + new_node = create_node( + expr_i.args[0], parent=subnode, n_layer=n_layer + ) # create 1D function expr_i.func if expr_i.func == Pow: power_exponent = expr_i.args[1] else: power_exponent = None - Connection([1,0,float(scale),float(bias)], expr_i.func, fun_name = expr_i.func, parent=subnode, child=new_node, power_exponent=power_exponent) + Connection( + [1, 0, float(scale), float(bias)], + expr_i.func, + fun_name=expr_i.func, + parent=subnode, + child=new_node, + power_exponent=power_exponent, + ) elif expr.func == Symbol: # expr.func is a symbol (one of input variables) @@ -265,19 +333,25 @@ def create_node(expr, parent=None, n_layer=None): node = Node(expr, False, depth, scale, bias, parent=parent) return_node = node for i in range(n_layer - depth): - subnode = SubNode(expr, node.depth+1, 1, 0, parent=node) + subnode = SubNode(expr, node.depth + 1, 1, 0, parent=node) node = Node(expr, False, subnode.depth, 1, 0, parent=subnode) - Connection([1,0,1,0], lambda x: x, fun_name = 'x', parent=subnode, child=node) + Connection( + [1, 0, 1, 0], + lambda x: x, + fun_name="x", + parent=subnode, + child=node, + ) node = return_node Start_Nodes.append(node) else: # expr.func is 1D function - #print(expr, scale, bias) + # print(expr, scale, bias) node = Node(expr, False, depth, scale, bias, parent=parent) expr_i, scale, bias = next_nontrivial_operation(expr.args[0]) - subnode = SubNode(expr_i, node.depth+1, 1, 0, parent=node) + subnode = SubNode(expr_i, node.depth + 1, 1, 0, parent=node) # create a node with expr_i.args[0] new_node = create_node(expr.args[0], parent=subnode, n_layer=n_layer) # create 1D function expr_i.func @@ -285,7 +359,14 @@ def create_node(expr, parent=None, n_layer=None): power_exponent = expr.args[1] else: power_exponent = None - Connection([1,0,1,0], expr.func, fun_name = expr.func, parent=subnode, child=new_node, power_exponent=power_exponent) + Connection( + [1, 0, 1, 0], + expr.func, + fun_name=expr.func, + parent=subnode, + child=new_node, + power_exponent=power_exponent, + ) return node @@ -307,20 +388,20 @@ def create_node(expr, parent=None, n_layer=None): # move affine parameters in leaf nodes to connections for node in Start_Nodes: - c = Connections[(node.depth,node.parent_index,node.index)] + c = Connections[(node.depth, node.parent_index, node.index)] c.affine[0] = float(node.scale) c.affine[1] = float(node.bias) - node.scale = 1. - node.bias = 0. - - #input_variables = symbol + node.scale = 1.0 + node.bias = 0.0 + + # input_variables = symbol node2var = [] for node in Start_Nodes: for i in range(len(input_variables)): if node.expr == input_variables[i]: node2var.append(i) - # Nodes + # Nodes n_mult = [] n_sum = [] for layer in Nodes: @@ -343,7 +424,7 @@ def create_node(expr, parent=None, n_layer=None): node_index_convert = {} connection_index_convert = {} mult_arities = [] - for layer_id in range(n_layer+1): + for layer_id in range(n_layer + 1): mult_arity = [] i_sum = 0 i_mult = 0 @@ -353,24 +434,36 @@ def create_node(expr, parent=None, n_layer=None): kan_node_id = n_sum[layer_id] + i_mult arity = len(node.child_index) for i in range(arity): - subnode = SubNodes[node.depth+1][node.child_index[i]] + subnode = SubNodes[node.depth + 1][node.child_index[i]] kan_subnode_id = n_sum[layer_id] + np.sum(mult_arity) + i - subnode_index_convert[(subnode.depth,subnode.index)] = (int(n_layer-subnode.depth),int(kan_subnode_id)) + subnode_index_convert[(subnode.depth, subnode.index)] = ( + int(n_layer - subnode.depth), + int(kan_subnode_id), + ) i_mult += 1 mult_arity.append(arity) else: kan_node_id = i_sum if len(node.child_index) > 0: - subnode = SubNodes[node.depth+1][node.child_index[0]] + subnode = SubNodes[node.depth + 1][node.child_index[0]] kan_subnode_id = i_sum - subnode_index_convert[(subnode.depth,subnode.index)] = (int(n_layer-subnode.depth),int(kan_subnode_id)) + subnode_index_convert[(subnode.depth, subnode.index)] = ( + int(n_layer - subnode.depth), + int(kan_subnode_id), + ) i_sum += 1 if layer_id == n_layer: # input layer - node_index_convert[(node.depth,node.index)] = (int(n_layer-node.depth),int(node2var[kan_node_id])) + node_index_convert[(node.depth, node.index)] = ( + int(n_layer - node.depth), + int(node2var[kan_node_id]), + ) else: - node_index_convert[(node.depth,node.index)] = (int(n_layer-node.depth),int(kan_node_id)) + node_index_convert[(node.depth, node.index)] = ( + int(n_layer - node.depth), + int(kan_node_id), + ) # node: depth (node.depth -> n_layer - node.depth) # width (node.index -> kan_node_id) @@ -380,28 +473,33 @@ def create_node(expr, parent=None, n_layer=None): for index in list(Connections.keys()): depth, subnode_id, node_id = index - # to int(n_layer-depth), + # to int(n_layer-depth), _, kan_subnode_id = subnode_index_convert[(depth, subnode_id)] _, kan_node_id = node_index_convert[(depth, node_id)] - connection_index_convert[(depth, subnode_id, node_id)] = (n_layer-depth, kan_subnode_id, kan_node_id) - + connection_index_convert[(depth, subnode_id, node_id)] = ( + n_layer - depth, + kan_subnode_id, + kan_node_id, + ) n_sum.reverse() n_mult.reverse() mult_arities.reverse() - + width = [[n_sum[i], n_mult[i]] for i in range(len(n_sum))] width[0][0] = len(input_variables) # allow pass in other parameters (probably as a dictionary) in sf2kan, including grid k etc. - model = MultKAN(width=width, mult_arity=mult_arities, grid=grid, k=k, auto_save=auto_save) - + model = MultKAN( + width=width, mult_arity=mult_arities, grid=grid, k=k, auto_save=auto_save + ) + # clean the graph for l in range(model.depth): for i in range(model.width_in[l]): - for j in range(model.width_out[l+1]): - model.fix_symbolic(l,i,j,'0',fit_params_bool=False) - + for j in range(model.width_out[l + 1]): + model.fix_symbolic(l, i, j, "0", fit_params_bool=False) + # Nodes Nodes_flat = [x for xs in Nodes for x in xs] @@ -410,24 +508,29 @@ def create_node(expr, parent=None, n_layer=None): for node in Nodes_flat: node_depth = node.depth node_index = node.index - kan_node_depth, kan_node_index = node_index_convert[(node_depth,node_index)] - #print(kan_node_depth, kan_node_index) + kan_node_depth, kan_node_index = node_index_convert[(node_depth, node_index)] + # print(kan_node_depth, kan_node_index) if kan_node_depth > 0: - self.node_scale[kan_node_depth-1].data[kan_node_index] = float(node.scale) - self.node_bias[kan_node_depth-1].data[kan_node_index] = float(node.bias) - - + self.node_scale[kan_node_depth - 1].data[kan_node_index] = float(node.scale) + self.node_bias[kan_node_depth - 1].data[kan_node_index] = float(node.bias) + # SubNodes SubNodes_flat = [x for xs in SubNodes for x in xs] for subnode in SubNodes_flat: subnode_depth = subnode.depth subnode_index = subnode.index - kan_subnode_depth, kan_subnode_index = subnode_index_convert[(subnode_depth,subnode_index)] - #print(kan_subnode_depth, kan_subnode_index) - self.subnode_scale[kan_subnode_depth].data[kan_subnode_index] = float(subnode.scale) - self.subnode_bias[kan_subnode_depth].data[kan_subnode_index] = float(subnode.bias) - + kan_subnode_depth, kan_subnode_index = subnode_index_convert[ + (subnode_depth, subnode_index) + ] + # print(kan_subnode_depth, kan_subnode_index) + self.subnode_scale[kan_subnode_depth].data[kan_subnode_index] = float( + subnode.scale + ) + self.subnode_bias[kan_subnode_depth].data[kan_subnode_index] = float( + subnode.bias + ) + # Connections Connections_flat = list(Connections.values()) @@ -439,60 +542,62 @@ def create_node(expr, parent=None, n_layer=None): # get symbolic fun_name fun_name = connection.fun_name - #if fun_name == Pow: + # if fun_name == Pow: # print(connection.power_exponent) - if fun_name == 'x': - kfun_name = 'x' + if fun_name == "x": + kfun_name = "x" elif fun_name == exp: - kfun_name = 'exp' + kfun_name = "exp" elif fun_name == sin: - kfun_name = 'sin' + kfun_name = "sin" elif fun_name == cos: - kfun_name = 'cos' + kfun_name = "cos" elif fun_name == tan: - kfun_name = 'tan' + kfun_name = "tan" elif fun_name == sqrt: - kfun_name = 'sqrt' + kfun_name = "sqrt" elif fun_name == log: - kfun_name = 'log' + kfun_name = "log" elif fun_name == tanh: - kfun_name = 'tanh' + kfun_name = "tanh" elif fun_name == asin: - kfun_name = 'arcsin' + kfun_name = "arcsin" elif fun_name == acos: - kfun_name = 'arccos' + kfun_name = "arccos" elif fun_name == atan: - kfun_name = 'arctan' + kfun_name = "arctan" elif fun_name == atanh: - kfun_name = 'arctanh' + kfun_name = "arctanh" elif fun_name == sign: - kfun_name = 'sgn' + kfun_name = "sgn" elif fun_name == Pow: alpha = connection.power_exponent - if alpha == Rational(1,2): - kfun_name = 'x^0.5' - elif alpha == - Rational(1,2): - kfun_name = '1/x^0.5' - elif alpha == Rational(3,2): - kfun_name = 'x^1.5' + if alpha == Rational(1, 2): + kfun_name = "x^0.5" + elif alpha == -Rational(1, 2): + kfun_name = "1/x^0.5" + elif alpha == Rational(3, 2): + kfun_name = "x^1.5" else: alpha = int(connection.power_exponent) if alpha > 0: if alpha == 1: - kfun_name = 'x' + kfun_name = "x" else: - kfun_name = f'x^{alpha}' + kfun_name = f"x^{alpha}" else: if alpha == -1: - kfun_name = '1/x' + kfun_name = "1/x" else: - kfun_name = f'1/x^{-alpha}' + kfun_name = f"1/x^{-alpha}" model.fix_symbolic(kc_depth, kc_i, kc_j, kfun_name, fit_params_bool=False) - model.symbolic_fun[kc_depth].affine.data.reshape(self.width_out[kc_depth+1], self.width_in[kc_depth], 4)[kc_j][kc_i] = torch.tensor(connection.affine) - + model.symbolic_fun[kc_depth].affine.data.reshape( + self.width_out[kc_depth + 1], self.width_in[kc_depth], 4 + )[kc_j][kc_i] = torch.tensor(connection.affine) + return model -sf2kan = kanpiler = expr2kan \ No newline at end of file +sf2kan = kanpiler = expr2kan diff --git a/kan/experiment.py b/kan/experiment.py index 9ab9e9de3..6b6380390 100644 --- a/kan/experiment.py +++ b/kan/experiment.py @@ -1,23 +1,33 @@ -import torch from .MultKAN import * -def runner1(width, dataset, grids=[5,10,20], steps=20, lamb=0.001, prune_round=3, refine_round=3, edge_th=1e-2, node_th=1e-2, metrics=None, seed=1): - +def runner1( + width, + dataset, + grids=[5, 10, 20], + steps=20, + lamb=0.001, + prune_round=3, + refine_round=3, + edge_th=1e-2, + node_th=1e-2, + metrics=None, + seed=1, +): result = {} - result['test_loss'] = [] - result['c'] = [] - result['G'] = [] - result['id'] = [] + result["test_loss"] = [] + result["c"] = [] + result["G"] = [] + result["id"] = [] if metrics != None: for i in range(len(metrics)): result[metrics[i].__name__] = [] def collect(evaluation): - result['test_loss'].append(evaluation['test_loss']) - result['c'].append(evaluation['n_edge']) - result['G'].append(evaluation['n_grid']) - result['id'].append(f'{model.round}.{model.state_id}') + result["test_loss"].append(evaluation["test_loss"]) + result["c"].append(evaluation["n_edge"]) + result["G"].append(evaluation["n_grid"]) + result["id"].append(f"{model.round}.{model.state_id}") if metrics != None: for i in range(len(metrics)): result[metrics[i].__name__].append(metrics[i](model, dataset).item()) @@ -27,7 +37,7 @@ def collect(evaluation): if i == 0: model = KAN(width=width, grid=grids[0], seed=seed) else: - model = model.rewind(f'{i-1}.{2*i}') + model = model.rewind(f"{i - 1}.{2 * i}") model.fit(dataset, steps=steps, lamb=lamb) model = model.prune(edge_th=edge_th, node_th=node_th) @@ -46,10 +56,11 @@ def collect(evaluation): return result -def pareto_frontier(x,y): - - pf_id = np.where(np.sum((x[:,None] <= x[None,:]) * (y[:,None] <= y[None,:]), axis=0) == 1)[0] +def pareto_frontier(x, y): + pf_id = np.where( + np.sum((x[:, None] <= x[None, :]) * (y[:, None] <= y[None, :]), axis=0) == 1 + )[0] x_pf = x[pf_id] y_pf = y[pf_id] - return x_pf, y_pf, pf_id \ No newline at end of file + return x_pf, y_pf, pf_id diff --git a/kan/feynman.py b/kan/feynman.py index 6cc55e96f..db5088c31 100644 --- a/kan/feynman.py +++ b/kan/feynman.py @@ -3,737 +3,1117 @@ def get_feynman_dataset(name): - global symbols - + tpi = torch.tensor(torch.pi) - - if name == 'test': - symbol = x, y = symbols('x, y') - expr = (x+y) * sin(exp(2*y)) - f = lambda x: (x[:,[0]] + x[:,[1]])*torch.sin(torch.exp(2*x[:,[1]])) - ranges = [-1,1] - - if name == 'I.6.20a' or name == 1: - symbol = theta = symbols('theta') + + if name == "test": + symbol = x, y = symbols("x, y") + expr = (x + y) * sin(exp(2 * y)) + f = lambda x: (x[:, [0]] + x[:, [1]]) * torch.sin(torch.exp(2 * x[:, [1]])) + ranges = [-1, 1] + + if name == "I.6.20a" or name == 1: + symbol = theta = symbols("theta") symbol = [symbol] - expr = exp(-theta**2/2)/sqrt(2*pi) - f = lambda x: torch.exp(-x[:,[0]]**2/2)/torch.sqrt(2*tpi) - ranges = [[-3,3]] - - if name == 'I.6.20' or name == 2: - symbol = theta, sigma = symbols('theta sigma') - expr = exp(-theta**2/(2*sigma**2))/sqrt(2*pi*sigma**2) - f = lambda x: torch.exp(-x[:,[0]]**2/(2*x[:,[1]]**2))/torch.sqrt(2*tpi*x[:,[1]]**2) - ranges = [[-1,1],[0.5,2]] - - if name == 'I.6.20b' or name == 3: - symbol = theta, theta1, sigma = symbols('theta theta1 sigma') - expr = exp(-(theta-theta1)**2/(2*sigma**2))/sqrt(2*pi*sigma**2) - f = lambda x: torch.exp(-(x[:,[0]]-x[:,[1]])**2/(2*x[:,[2]]**2))/torch.sqrt(2*tpi*x[:,[2]]**2) - ranges = [[-1.5,1.5],[-1.5,1.5],[0.5,2]] - - if name == 'I.8.4' or name == 4: - symbol = x1, x2, y1, y2 = symbols('x1 x2 y1 y2') - expr = sqrt((x2-x1)**2+(y2-y1)**2) - f = lambda x: torch.sqrt((x[:,[1]]-x[:,[0]])**2+(x[:,[3]]-x[:,[2]])**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.9.18' or name == 5: - symbol = G, m1, m2, x1, x2, y1, y2, z1, z2 = symbols('G m1 m2 x1 x2 y1 y2 z1 z2') - expr = G*m1*m2/((x2-x1)**2+(y2-y1)**2+(z2-z1)**2) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/((x[:,[3]]-x[:,[4]])**2+(x[:,[5]]-x[:,[6]])**2+(x[:,[7]]-x[:,[8]])**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,-0.5],[0.5,1],[-1,-0.5],[0.5,1],[-1,-0.5],[0.5,1]] - - if name == 'I.10.7' or name == 6: - symbol = m0, v, c = symbols('m0 v c') - expr = m0/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'I.11.19' or name == 7: - symbol = x1, y1, x2, y2, x3, y3 = symbols('x1 y1 x2 y2 x3 y3') - expr = x1*y1 + x2*y2 + x3*y3 - f = lambda x: x[:,[0]]*x[:,[1]] + x[:,[2]]*x[:,[3]] + x[:,[4]]*x[:,[5]] - ranges = [-1,1] - - if name == 'I.12.1' or name == 8: - symbol = mu, Nn = symbols('mu N_n') + expr = exp(-(theta**2) / 2) / sqrt(2 * pi) + f = lambda x: torch.exp(-(x[:, [0]] ** 2) / 2) / torch.sqrt(2 * tpi) + ranges = [[-3, 3]] + + if name == "I.6.20" or name == 2: + symbol = theta, sigma = symbols("theta sigma") + expr = exp(-(theta**2) / (2 * sigma**2)) / sqrt(2 * pi * sigma**2) + f = lambda x: torch.exp(-(x[:, [0]] ** 2) / (2 * x[:, [1]] ** 2)) / torch.sqrt( + 2 * tpi * x[:, [1]] ** 2 + ) + ranges = [[-1, 1], [0.5, 2]] + + if name == "I.6.20b" or name == 3: + symbol = theta, theta1, sigma = symbols("theta theta1 sigma") + expr = exp(-((theta - theta1) ** 2) / (2 * sigma**2)) / sqrt(2 * pi * sigma**2) + f = lambda x: torch.exp( + -((x[:, [0]] - x[:, [1]]) ** 2) / (2 * x[:, [2]] ** 2) + ) / torch.sqrt(2 * tpi * x[:, [2]] ** 2) + ranges = [[-1.5, 1.5], [-1.5, 1.5], [0.5, 2]] + + if name == "I.8.4" or name == 4: + symbol = x1, x2, y1, y2 = symbols("x1 x2 y1 y2") + expr = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) + f = lambda x: torch.sqrt( + (x[:, [1]] - x[:, [0]]) ** 2 + (x[:, [3]] - x[:, [2]]) ** 2 + ) + ranges = [[-1, 1], [-1, 1], [-1, 1], [-1, 1]] + + if name == "I.9.18" or name == 5: + symbol = G, m1, m2, x1, x2, y1, y2, z1, z2 = symbols( + "G m1 m2 x1 x2 y1 y2 z1 z2" + ) + expr = G * m1 * m2 / ((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + * x[:, [2]] + / ( + (x[:, [3]] - x[:, [4]]) ** 2 + + (x[:, [5]] - x[:, [6]]) ** 2 + + (x[:, [7]] - x[:, [8]]) ** 2 + ) + ) + ranges = [ + [-1, 1], + [-1, 1], + [-1, 1], + [-1, -0.5], + [0.5, 1], + [-1, -0.5], + [0.5, 1], + [-1, -0.5], + [0.5, 1], + ] + + if name == "I.10.7" or name == 6: + symbol = m0, v, c = symbols("m0 v c") + expr = m0 / sqrt(1 - v**2 / c**2) + f = lambda x: x[:, [0]] / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ranges = [[0, 1], [0, 1], [1, 2]] + + if name == "I.11.19" or name == 7: + symbol = x1, y1, x2, y2, x3, y3 = symbols("x1 y1 x2 y2 x3 y3") + expr = x1 * y1 + x2 * y2 + x3 * y3 + f = ( + lambda x: x[:, [0]] * x[:, [1]] + + x[:, [2]] * x[:, [3]] + + x[:, [4]] * x[:, [5]] + ) + ranges = [-1, 1] + + if name == "I.12.1" or name == 8: + symbol = mu, Nn = symbols("mu N_n") expr = mu * Nn - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [-1,1] - - if name == 'I.12.2' or name == 9: - symbol = q1, q2, eps, r = symbols('q1 q2 epsilon r') - expr = q1*q2/(4*pi*eps*r**2) - f = lambda x: x[:,[0]]*x[:,[1]]/(4*tpi*x[:,[2]]*x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.12.4' or name == 10: - symbol = q1, eps, r = symbols('q1 epsilon r') - expr = q1/(4*pi*eps*r**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]**2) - ranges = [[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.12.5' or name == 11: - symbol = q2, Ef = symbols('q2, E_f') - expr = q2*Ef - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [-1,1] - - if name == 'I.12.11' or name == 12: - symbol = q, Ef, B, v, theta = symbols('q E_f B v theta') - expr = q*(Ef + B*v*sin(theta)) - f = lambda x: x[:,[0]]*(x[:,[1]]+x[:,[2]]*x[:,[3]]*torch.sin(x[:,[4]])) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.13.4' or name == 13: - symbol = m, v, u, w = symbols('m u v w') - expr = 1/2*m*(v**2+u**2+w**2) - f = lambda x: 1/2*x[:,[0]]*(x[:,[1]]**2+x[:,[2]]**2+x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.13.12' or name == 14: - symbol = G, m1, m2, r1, r2 = symbols('G m1 m2 r1 r2') - expr = G*m1*m2*(1/r2-1/r1) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*(1/x[:,[4]]-1/x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.14.3' or name == 15: - symbol = m, g, z = symbols('m g z') - expr = m*g*z - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]] - ranges = [[0,1],[0,1],[-1,1]] - - if name == 'I.14.4' or name == 16: - symbol = ks, x = symbols('k_s x') - expr = 1/2*ks*x**2 - f = lambda x: 1/2*x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[-1,1]] - - if name == 'I.15.3x' or name == 17: - symbol = x, u, t, c = symbols('x u t c') - expr = (x-u*t)/sqrt(1-u**2/c**2) - f = lambda x: (x[:,[0]] - x[:,[1]]*x[:,[2]])/torch.sqrt(1-x[:,[1]]**2/x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[1,2]] - - if name == 'I.15.3t' or name == 18: - symbol = t, u, x, c = symbols('t u x c') - expr = (t-u*x/c**2)/sqrt(1-u**2/c**2) - f = lambda x: (x[:,[0]] - x[:,[1]]*x[:,[2]]/x[:,[3]]**2)/torch.sqrt(1-x[:,[1]]**2/x[:,[3]]**2) - ranges = [[-1,1],[-1,1],[-1,1],[1,2]] - - if name == 'I.15.10' or name == 19: - symbol = m0, v, c = symbols('m0 v c') - expr = m0*v/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[-1,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.16.6' or name == 20: - symbol = u, v, c = symbols('u v c') - expr = (u+v)/(1+u*v/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/(1+x[:,[0]]*x[:,[1]]/x[:,[2]]**2) - ranges = [[-0.8,0.8],[-0.8,0.8],[1,2]] - - if name == 'I.18.4' or name == 21: - symbol = m1, r1, m2, r2 = symbols('m1 r1 m2 r2') - expr = (m1*r1+m2*r2)/(m1+m2) - f = lambda x: (x[:,[0]]*x[:,[1]]+x[:,[2]]*x[:,[3]])/(x[:,[0]]+x[:,[2]]) - ranges = [[0.5,1],[-1,1],[0.5,1],[-1,1]] - - if name == 'I.18.4' or name == 22: - symbol = r, F, theta = symbols('r F theta') - expr = r*F*sin(theta) - f = lambda x: x[:,[0]]*x[:,[1]]*torch.sin(x[:,[2]]) - ranges = [[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.18.16' or name == 23: - symbol = m, r, v, theta = symbols('m r v theta') - expr = m*r*v*sin(theta) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*torch.sin(x[:,[3]]) - ranges = [[-1,1],[-1,1],[-1,1],[0,2*tpi]] - - if name == 'I.24.6' or name == 24: - symbol = m, omega, omega0, x = symbols('m omega omega_0 x') - expr = 1/4*m*(omega**2+omega0**2)*x**2 - f = lambda x: 1/4*x[:,[0]]*(x[:,[1]]**2+x[:,[2]]**2)*x[:,[3]]**2 - ranges = [[0,1],[-1,1],[-1,1],[-1,1]] - - if name == 'I.25.13' or name == 25: - symbol = q, C = symbols('q C') - expr = q/C - f = lambda x: x[:,[0]]/x[:,[1]] - ranges = [[-1,1],[0.5,2]] - - if name == 'I.26.2' or name == 26: - symbol = n, theta2 = symbols('n theta2') - expr = asin(n*sin(theta2)) - f = lambda x: torch.arcsin(x[:,[0]]*torch.sin(x[:,[1]])) - ranges = [[0,0.99],[0,2*tpi]] - - if name == 'I.27.6' or name == 27: - symbol = d1, d2, n = symbols('d1 d2 n') - expr = 1/(1/d1+n/d2) - f = lambda x: 1/(1/x[:,[0]]+x[:,[2]]/x[:,[1]]) - ranges = [[0.5,2],[1,2],[0.5,2]] - - if name == 'I.29.4' or name == 28: - symbol = omega, c = symbols('omega c') - expr = omega/c - f = lambda x: x[:,[0]]/x[:,[1]] - ranges = [[0,1],[0.5,2]] - - if name == 'I.29.16' or name == 29: - symbol = x1, x2, theta1, theta2 = symbols('x1 x2 theta1 theta2') - expr = sqrt(x1**2+x2**2-2*x1*x2*cos(theta1-theta2)) - f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2-2*x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]-x[:,[3]])) - ranges = [[-1,1],[-1,1],[0,2*tpi],[0,2*tpi]] - - if name == 'I.30.3' or name == 30: - symbol = I0, n, theta = symbols('I_0 n theta') - expr = I0 * sin(n*theta/2)**2 / sin(theta/2) ** 2 - f = lambda x: x[:,[0]] * torch.sin(x[:,[1]]*x[:,[2]]/2)**2 / torch.sin(x[:,[2]]/2)**2 - ranges = [[0,1],[0,4],[0.4*tpi,1.6*tpi]] - - if name == 'I.30.5' or name == 31: - symbol = lamb, n, d = symbols('lambda n d') - expr = asin(lamb/(n*d)) - f = lambda x: torch.arcsin(x[:,[0]]/(x[:,[1]]*x[:,[2]])) - ranges = [[-1,1],[1,1.5],[1,1.5]] - - if name == 'I.32.5' or name == 32: - symbol = q, a, eps, c = symbols('q a epsilon c') - expr = q**2*a**2/(eps*c**3) - f = lambda x: x[:,[0]]**2*x[:,[1]]**2/(x[:,[2]]*x[:,[3]]**3) - ranges = [[-1,1],[-1,1],[0.5,2],[0.5,2]] - - if name == 'I.32.17' or name == 33: - symbol = eps, c, Ef, r, omega, omega0 = symbols('epsilon c E_f r omega omega_0') - expr = nsimplify((1/2*eps*c*Ef**2)*(8*pi*r**2/3)*(omega**4/(omega**2-omega0**2)**2)) - f = lambda x: (1/2*x[:,[0]]*x[:,[1]]*x[:,[2]]**2)*(8*tpi*x[:,[3]]**2/3)*(x[:,[4]]**4/(x[:,[4]]**2-x[:,[5]]**2)**2) - ranges = [[0,1],[0,1],[-1,1],[0,1],[0,1],[1,2]] - - if name == 'I.34.8' or name == 34: - symbol = q, V, B, p = symbols('q V B p') - expr = q*V*B/p - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[-1,1],[-1,1],[-1,1],[0.5,2]] - - if name == 'I.34.10' or name == 35: - symbol = omega0, v, c = symbols('omega_0 v c') - expr = omega0/(1-v/c) - f = lambda x: x[:,[0]]/(1-x[:,[1]]/x[:,[2]]) - ranges = [[0,1],[0,0.9],[1.1,2]] - - if name == 'I.34.14' or name == 36: - symbol = omega0, v, c = symbols('omega_0 v c') - expr = omega0 * (1+v/c)/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*(1+x[:,[1]]/x[:,[2]])/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.34.27' or name == 37: - symbol = hbar, omega = symbols('hbar omega') + f = lambda x: x[:, [0]] * x[:, [1]] + ranges = [-1, 1] + + if name == "I.12.2" or name == 9: + symbol = q1, q2, eps, r = symbols("q1 q2 epsilon r") + expr = q1 * q2 / (4 * pi * eps * r**2) + f = lambda x: x[:, [0]] * x[:, [1]] / (4 * tpi * x[:, [2]] * x[:, [3]] ** 2) + ranges = [[-1, 1], [-1, 1], [0.5, 2], [0.5, 2]] + + if name == "I.12.4" or name == 10: + symbol = q1, eps, r = symbols("q1 epsilon r") + expr = q1 / (4 * pi * eps * r**2) + f = lambda x: x[:, [0]] / (4 * tpi * x[:, [1]] * x[:, [2]] ** 2) + ranges = [[-1, 1], [0.5, 2], [0.5, 2]] + + if name == "I.12.5" or name == 11: + symbol = q2, Ef = symbols("q2, E_f") + expr = q2 * Ef + f = lambda x: x[:, [0]] * x[:, [1]] + ranges = [-1, 1] + + if name == "I.12.11" or name == 12: + symbol = q, Ef, B, v, theta = symbols("q E_f B v theta") + expr = q * (Ef + B * v * sin(theta)) + f = lambda x: x[:, [0]] * ( + x[:, [1]] + x[:, [2]] * x[:, [3]] * torch.sin(x[:, [4]]) + ) + ranges = [[-1, 1], [-1, 1], [-1, 1], [-1, 1], [0, 2 * tpi]] + + if name == "I.13.4" or name == 13: + symbol = m, v, u, w = symbols("m u v w") + expr = 1 / 2 * m * (v**2 + u**2 + w**2) + f = ( + lambda x: 1 + / 2 + * x[:, [0]] + * (x[:, [1]] ** 2 + x[:, [2]] ** 2 + x[:, [3]] ** 2) + ) + ranges = [[-1, 1], [-1, 1], [-1, 1], [-1, 1]] + + if name == "I.13.12" or name == 14: + symbol = G, m1, m2, r1, r2 = symbols("G m1 m2 r1 r2") + expr = G * m1 * m2 * (1 / r2 - 1 / r1) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + * x[:, [2]] + * (1 / x[:, [4]] - 1 / x[:, [3]]) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "I.14.3" or name == 15: + symbol = m, g, z = symbols("m g z") + expr = m * g * z + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] + ranges = [[0, 1], [0, 1], [-1, 1]] + + if name == "I.14.4" or name == 16: + symbol = ks, x = symbols("k_s x") + expr = 1 / 2 * ks * x**2 + f = lambda x: 1 / 2 * x[:, [0]] * x[:, [1]] ** 2 + ranges = [[0, 1], [-1, 1]] + + if name == "I.15.3x" or name == 17: + symbol = x, u, t, c = symbols("x u t c") + expr = (x - u * t) / sqrt(1 - u**2 / c**2) + f = lambda x: (x[:, [0]] - x[:, [1]] * x[:, [2]]) / torch.sqrt( + 1 - x[:, [1]] ** 2 / x[:, [3]] ** 2 + ) + ranges = [[-1, 1], [-1, 1], [-1, 1], [1, 2]] + + if name == "I.15.3t" or name == 18: + symbol = t, u, x, c = symbols("t u x c") + expr = (t - u * x / c**2) / sqrt(1 - u**2 / c**2) + f = lambda x: (x[:, [0]] - x[:, [1]] * x[:, [2]] / x[:, [3]] ** 2) / torch.sqrt( + 1 - x[:, [1]] ** 2 / x[:, [3]] ** 2 + ) + ranges = [[-1, 1], [-1, 1], [-1, 1], [1, 2]] + + if name == "I.15.10" or name == 19: + symbol = m0, v, c = symbols("m0 v c") + expr = m0 * v / sqrt(1 - v**2 / c**2) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ) + ranges = [[-1, 1], [-0.9, 0.9], [1.1, 2]] + + if name == "I.16.6" or name == 20: + symbol = u, v, c = symbols("u v c") + expr = (u + v) / (1 + u * v / c**2) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / (1 + x[:, [0]] * x[:, [1]] / x[:, [2]] ** 2) + ) + ranges = [[-0.8, 0.8], [-0.8, 0.8], [1, 2]] + + if name == "I.18.4" or name == 21: + symbol = m1, r1, m2, r2 = symbols("m1 r1 m2 r2") + expr = (m1 * r1 + m2 * r2) / (m1 + m2) + f = lambda x: (x[:, [0]] * x[:, [1]] + x[:, [2]] * x[:, [3]]) / ( + x[:, [0]] + x[:, [2]] + ) + ranges = [[0.5, 1], [-1, 1], [0.5, 1], [-1, 1]] + + if name == "I.18.4" or name == 22: + symbol = r, F, theta = symbols("r F theta") + expr = r * F * sin(theta) + f = lambda x: x[:, [0]] * x[:, [1]] * torch.sin(x[:, [2]]) + ranges = [[-1, 1], [-1, 1], [0, 2 * tpi]] + + if name == "I.18.16" or name == 23: + symbol = m, r, v, theta = symbols("m r v theta") + expr = m * r * v * sin(theta) + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] * torch.sin(x[:, [3]]) + ranges = [[-1, 1], [-1, 1], [-1, 1], [0, 2 * tpi]] + + if name == "I.24.6" or name == 24: + symbol = m, omega, omega0, x = symbols("m omega omega_0 x") + expr = 1 / 4 * m * (omega**2 + omega0**2) * x**2 + f = ( + lambda x: 1 + / 4 + * x[:, [0]] + * (x[:, [1]] ** 2 + x[:, [2]] ** 2) + * x[:, [3]] ** 2 + ) + ranges = [[0, 1], [-1, 1], [-1, 1], [-1, 1]] + + if name == "I.25.13" or name == 25: + symbol = q, C = symbols("q C") + expr = q / C + f = lambda x: x[:, [0]] / x[:, [1]] + ranges = [[-1, 1], [0.5, 2]] + + if name == "I.26.2" or name == 26: + symbol = n, theta2 = symbols("n theta2") + expr = asin(n * sin(theta2)) + f = lambda x: torch.arcsin(x[:, [0]] * torch.sin(x[:, [1]])) + ranges = [[0, 0.99], [0, 2 * tpi]] + + if name == "I.27.6" or name == 27: + symbol = d1, d2, n = symbols("d1 d2 n") + expr = 1 / (1 / d1 + n / d2) + f = lambda x: 1 / (1 / x[:, [0]] + x[:, [2]] / x[:, [1]]) + ranges = [[0.5, 2], [1, 2], [0.5, 2]] + + if name == "I.29.4" or name == 28: + symbol = omega, c = symbols("omega c") + expr = omega / c + f = lambda x: x[:, [0]] / x[:, [1]] + ranges = [[0, 1], [0.5, 2]] + + if name == "I.29.16" or name == 29: + symbol = x1, x2, theta1, theta2 = symbols("x1 x2 theta1 theta2") + expr = sqrt(x1**2 + x2**2 - 2 * x1 * x2 * cos(theta1 - theta2)) + f = lambda x: torch.sqrt( + x[:, [0]] ** 2 + + x[:, [1]] ** 2 + - 2 * x[:, [0]] * x[:, [1]] * torch.cos(x[:, [2]] - x[:, [3]]) + ) + ranges = [[-1, 1], [-1, 1], [0, 2 * tpi], [0, 2 * tpi]] + + if name == "I.30.3" or name == 30: + symbol = I0, n, theta = symbols("I_0 n theta") + expr = I0 * sin(n * theta / 2) ** 2 / sin(theta / 2) ** 2 + f = ( + lambda x: x[:, [0]] + * torch.sin(x[:, [1]] * x[:, [2]] / 2) ** 2 + / torch.sin(x[:, [2]] / 2) ** 2 + ) + ranges = [[0, 1], [0, 4], [0.4 * tpi, 1.6 * tpi]] + + if name == "I.30.5" or name == 31: + symbol = lamb, n, d = symbols("lambda n d") + expr = asin(lamb / (n * d)) + f = lambda x: torch.arcsin(x[:, [0]] / (x[:, [1]] * x[:, [2]])) + ranges = [[-1, 1], [1, 1.5], [1, 1.5]] + + if name == "I.32.5" or name == 32: + symbol = q, a, eps, c = symbols("q a epsilon c") + expr = q**2 * a**2 / (eps * c**3) + f = lambda x: x[:, [0]] ** 2 * x[:, [1]] ** 2 / (x[:, [2]] * x[:, [3]] ** 3) + ranges = [[-1, 1], [-1, 1], [0.5, 2], [0.5, 2]] + + if name == "I.32.17" or name == 33: + symbol = eps, c, Ef, r, omega, omega0 = symbols("epsilon c E_f r omega omega_0") + expr = nsimplify( + (1 / 2 * eps * c * Ef**2) + * (8 * pi * r**2 / 3) + * (omega**4 / (omega**2 - omega0**2) ** 2) + ) + f = ( + lambda x: (1 / 2 * x[:, [0]] * x[:, [1]] * x[:, [2]] ** 2) + * (8 * tpi * x[:, [3]] ** 2 / 3) + * (x[:, [4]] ** 4 / (x[:, [4]] ** 2 - x[:, [5]] ** 2) ** 2) + ) + ranges = [[0, 1], [0, 1], [-1, 1], [0, 1], [0, 1], [1, 2]] + + if name == "I.34.8" or name == 34: + symbol = q, V, B, p = symbols("q V B p") + expr = q * V * B / p + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[-1, 1], [-1, 1], [-1, 1], [0.5, 2]] + + if name == "I.34.10" or name == 35: + symbol = omega0, v, c = symbols("omega_0 v c") + expr = omega0 / (1 - v / c) + f = lambda x: x[:, [0]] / (1 - x[:, [1]] / x[:, [2]]) + ranges = [[0, 1], [0, 0.9], [1.1, 2]] + + if name == "I.34.14" or name == 36: + symbol = omega0, v, c = symbols("omega_0 v c") + expr = omega0 * (1 + v / c) / sqrt(1 - v**2 / c**2) + f = ( + lambda x: x[:, [0]] + * (1 + x[:, [1]] / x[:, [2]]) + / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ) + ranges = [[0, 1], [-0.9, 0.9], [1.1, 2]] + + if name == "I.34.27" or name == 37: + symbol = hbar, omega = symbols("hbar omega") expr = hbar * omega - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [[-1,1],[-1,1]] - - if name == 'I.37.4' or name == 38: - symbol = I1, I2, delta = symbols('I_1 I_2 delta') - expr = I1 + I2 + 2*sqrt(I1*I2)*cos(delta) - f = lambda x: x[:,[0]] + x[:,[1]] + 2*torch.sqrt(x[:,[0]]*x[:,[1]])*torch.cos(x[:,[2]]) - ranges = [[0.1,1],[0.1,1],[0,2*tpi]] - - if name == 'I.38.12' or name == 39: - symbol = eps, hbar, m, q = symbols('epsilon hbar m q') - expr = 4*pi*eps*hbar**2/(m*q**2) - f = lambda x: 4*tpi*x[:,[0]]*x[:,[1]]**2/(x[:,[2]]*x[:,[3]]**2) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.39.10' or name == 40: - symbol = pF, V = symbols('p_F V') - expr = 3/2 * pF * V - f = lambda x: 3/2 * x[:,[0]] * x[:,[1]] - ranges = [[0,1],[0,1]] - - if name == 'I.39.11' or name == 41: - symbol = gamma, pF, V = symbols('gamma p_F V') - expr = pF * V/(gamma - 1) - f = lambda x: 1/(x[:,[0]]-1) * x[:,[1]] * x[:,[2]] - ranges = [[1.5,3],[0,1],[0,1]] - - if name == 'I.39.22' or name == 42: - symbol = n, kb, T, V = symbols('n k_b T V') - expr = n*kb*T/V - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'I.40.1' or name == 43: - symbol = n0, m, g, x, kb, T = symbols('n_0 m g x k_b T') - expr = n0 * exp(-m*g*x/(kb*T)) - f = lambda x: x[:,[0]] * torch.exp(-x[:,[1]]*x[:,[2]]*x[:,[3]]/(x[:,[4]]*x[:,[5]])) - ranges = [[0,1],[-1,1],[-1,1],[-1,1],[1,2],[1,2]] - - if name == 'I.41.16' or name == 44: - symbol = hbar, omega, c, kb, T = symbols('hbar omega c k_b T') - expr = hbar * omega**3/(pi**2*c**2*(exp(hbar*omega/(kb*T))-1)) - f = lambda x: x[:,[0]]*x[:,[1]]**3/(tpi**2*x[:,[2]]**2*(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[3]]*x[:,[4]]))-1)) - ranges = [[0.5,1],[0.5,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'I.43.16' or name == 45: - symbol = mu, q, Ve, d = symbols('mu q V_e d') - expr = mu*q*Ve/d - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'I.43.31' or name == 46: - symbol = mu, kb, T = symbols('mu k_b T') - expr = mu*kb*T - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]] - ranges = [[0,1],[0,1],[0,1]] - - if name == 'I.43.43' or name == 47: - symbol = gamma, kb, v, A = symbols('gamma k_b v A') - expr = kb*v/A/(gamma-1) - f = lambda x: 1/(x[:,[0]]-1)*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[1.5,3],[0,1],[0,1],[0.5,2]] - - if name == 'I.44.4' or name == 48: - symbol = n, kb, T, V1, V2 = symbols('n k_b T V_1 V_2') - expr = n*kb*T*log(V2/V1) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*torch.log(x[:,[4]]/x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'I.47.23' or name == 49: - symbol = gamma, p, rho = symbols('gamma p rho') - expr = sqrt(gamma*p/rho) - f = lambda x: torch.sqrt(x[:,[0]]*x[:,[1]]/x[:,[2]]) - ranges = [[0.1,1],[0.1,1],[0.5,2]] - - if name == 'I.48.20' or name == 50: - symbol = m, v, c = symbols('m v c') - expr = m*c**2/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[2]]**2/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[-0.9,0.9],[1.1,2]] - - if name == 'I.50.26' or name == 51: - symbol = x1, alpha, omega, t = symbols('x_1 alpha omega t') - expr = x1*(cos(omega*t)+alpha*cos(omega*t)**2) - f = lambda x: x[:,[0]]*(torch.cos(x[:,[2]]*x[:,[3]])+x[:,[1]]*torch.cos(x[:,[2]]*x[:,[3]])**2) - ranges = [[0,1],[0,1],[0,2*tpi],[0,1]] - - if name == 'II.2.42' or name == 52: - symbol = kappa, T1, T2, A, d = symbols('kappa T_1 T_2 A d') - expr = kappa*(T2-T1)*A/d - f = lambda x: x[:,[0]]*(x[:,[2]]-x[:,[1]])*x[:,[3]]/x[:,[4]] - ranges = [[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.3.24' or name == 53: - symbol = P, r = symbols('P r') - expr = P/(4*pi*r**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]**2) - ranges = [[0,1],[0.5,2]] - - if name == 'II.4.23' or name == 54: - symbol = q, eps, r = symbols('q epsilon r') - expr = q/(4*pi*eps*r) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'II.6.11' or name == 55: - symbol = eps, pd, theta, r = symbols('epsilon p_d theta r') - expr = 1/(4*pi*eps)*pd*cos(theta)/r**2 - f = lambda x: 1/(4*tpi*x[:,[0]])*x[:,[1]]*torch.cos(x[:,[2]])/x[:,[3]]**2 - ranges = [[0.5,2],[0,1],[0,2*tpi],[0.5,2]] - - if name == 'II.6.15a' or name == 56: - symbol = eps, pd, z, x, y, r = symbols('epsilon p_d z x y r') - expr = 3/(4*pi*eps)*pd*z/r**5*sqrt(x**2+y**2) - f = lambda x: 3/(4*tpi*x[:,[0]])*x[:,[1]]*x[:,[2]]/x[:,[5]]**5*torch.sqrt(x[:,[3]]**2+x[:,[4]]**2) - ranges = [[0.5,2],[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.6.15b' or name == 57: - symbol = eps, pd, r, theta = symbols('epsilon p_d r theta') - expr = 3/(4*pi*eps)*pd/r**3*cos(theta)*sin(theta) - f = lambda x: 3/(4*tpi*x[:,[0]])*x[:,[1]]/x[:,[2]]**3*torch.cos(x[:,[3]])*torch.sin(x[:,[3]]) - ranges = [[0.5,2],[0,1],[0.5,2],[0,2*tpi]] - - if name == 'II.8.7' or name == 58: - symbol = q, eps, d = symbols('q epsilon d') - expr = 3/5*q**2/(4*pi*eps*d) - f = lambda x: 3/5*x[:,[0]]**2/(4*tpi*x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'II.8.31' or name == 59: - symbol = eps, Ef = symbols('epsilon E_f') - expr = 1/2*eps*Ef**2 - f = lambda x: 1/2*x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[0,1]] - - if name == 'I.10.9' or name == 60: - symbol = sigma, eps, chi = symbols('sigma epsilon chi') - expr = sigma/eps/(1+chi) - f = lambda x: x[:,[0]]/x[:,[1]]/(1+x[:,[2]]) - ranges = [[0,1],[0.5,2],[0,1]] - - if name == 'II.11.3' or name == 61: - symbol = q, Ef, m, omega0, omega = symbols('q E_f m omega_o omega') - expr = q*Ef/(m*(omega0**2-omega**2)) - f = lambda x: x[:,[0]]*x[:,[1]]/(x[:,[2]]*(x[:,[3]]**2-x[:,[4]]**2)) - ranges = [[0,1],[0,1],[0.5,2],[1.5,3],[0,1]] - - if name == 'II.11.17' or name == 62: - symbol = n0, pd, Ef, theta, kb, T = symbols('n_0 p_d E_f theta k_b T') - expr = n0*(1+pd*Ef*cos(theta)/(kb*T)) - f = lambda x: x[:,[0]]*(1+x[:,[1]]*x[:,[2]]*torch.cos(x[:,[3]])/(x[:,[4]]*x[:,[5]])) - ranges = [[0,1],[-1,1],[-1,1],[0,2*tpi],[0.5,2],[0.5,2]] - - - if name == 'II.11.20' or name == 63: - symbol = n, pd, Ef, kb, T = symbols('n p_d E_f k_b T') - expr = n*pd**2*Ef/(3*kb*T) - f = lambda x: x[:,[0]]*x[:,[1]]**2*x[:,[2]]/(3*x[:,[3]]*x[:,[4]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.11.27' or name == 64: - symbol = n, alpha, eps, Ef = symbols('n alpha epsilon E_f') - expr = n*alpha/(1-n*alpha/3)*eps*Ef - f = lambda x: x[:,[0]]*x[:,[1]]/(1-x[:,[0]]*x[:,[1]]/3)*x[:,[2]]*x[:,[3]] - ranges = [[0,1],[0,2],[0,1],[0,1]] - - if name == 'II.11.28' or name == 65: - symbol = n, alpha = symbols('n alpha') - expr = 1 + n*alpha/(1-n*alpha/3) - f = lambda x: 1 + x[:,[0]]*x[:,[1]]/(1-x[:,[0]]*x[:,[1]]/3) - ranges = [[0,1],[0,2]] - - if name == 'II.13.17' or name == 66: - symbol = eps, c, l, r = symbols('epsilon c l r') - expr = 1/(4*pi*eps*c**2)*(2*l/r) - f = lambda x: 1/(4*tpi*x[:,[0]]*x[:,[1]]**2)*(2*x[:,[2]]/x[:,[3]]) - ranges = [[0.5,2],[0.5,2],[0,1],[0.5,2]] - - if name == 'II.13.23' or name == 67: - symbol = rho, v, c = symbols('rho v c') - expr = rho/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'II.13.34' or name == 68: - symbol = rho, v, c = symbols('rho v c') - expr = rho*v/sqrt(1-v**2/c**2) - f = lambda x: x[:,[0]]*x[:,[1]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2) - ranges = [[0,1],[0,1],[1,2]] - - if name == 'II.15.4' or name == 69: - symbol = muM, B, theta = symbols('mu_M B theta') - expr = - muM * B * cos(theta) - f = lambda x: - x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'II.15.5' or name == 70: - symbol = pd, Ef, theta = symbols('p_d E_f theta') - expr = - pd * Ef * cos(theta) - f = lambda x: - x[:,[0]]*x[:,[1]]*torch.cos(x[:,[2]]) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'II.21.32' or name == 71: - symbol = q, eps, r, v, c = symbols('q epsilon r v c') - expr = q/(4*pi*eps*r*(1-v/c)) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,[2]]*(1-x[:,[3]]/x[:,[4]])) - ranges = [[0,1],[0.5,2],[0.5,2],[0,1],[1,2]] - - if name == 'II.24.17' or name == 72: - symbol = omega, c, d = symbols('omega c d') - expr = sqrt(omega**2/c**2-pi**2/d**2) - f = lambda x: torch.sqrt(x[:,[0]]**2/x[:,[1]]**2-tpi**2/x[:,[2]]**2) - ranges = [[1,1.5],[0.75,1],[1*tpi,1.5*tpi]] - - if name == 'II.27.16' or name == 73: - symbol = eps, c, Ef = symbols('epsilon c E_f') + f = lambda x: x[:, [0]] * x[:, [1]] + ranges = [[-1, 1], [-1, 1]] + + if name == "I.37.4" or name == 38: + symbol = I1, I2, delta = symbols("I_1 I_2 delta") + expr = I1 + I2 + 2 * sqrt(I1 * I2) * cos(delta) + f = ( + lambda x: x[:, [0]] + + x[:, [1]] + + 2 * torch.sqrt(x[:, [0]] * x[:, [1]]) * torch.cos(x[:, [2]]) + ) + ranges = [[0.1, 1], [0.1, 1], [0, 2 * tpi]] + + if name == "I.38.12" or name == 39: + symbol = eps, hbar, m, q = symbols("epsilon hbar m q") + expr = 4 * pi * eps * hbar**2 / (m * q**2) + f = ( + lambda x: 4 + * tpi + * x[:, [0]] + * x[:, [1]] ** 2 + / (x[:, [2]] * x[:, [3]] ** 2) + ) + ranges = [[0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "I.39.10" or name == 40: + symbol = pF, V = symbols("p_F V") + expr = 3 / 2 * pF * V + f = lambda x: 3 / 2 * x[:, [0]] * x[:, [1]] + ranges = [[0, 1], [0, 1]] + + if name == "I.39.11" or name == 41: + symbol = gamma, pF, V = symbols("gamma p_F V") + expr = pF * V / (gamma - 1) + f = lambda x: 1 / (x[:, [0]] - 1) * x[:, [1]] * x[:, [2]] + ranges = [[1.5, 3], [0, 1], [0, 1]] + + if name == "I.39.22" or name == 42: + symbol = n, kb, T, V = symbols("n k_b T V") + expr = n * kb * T / V + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "I.40.1" or name == 43: + symbol = n0, m, g, x, kb, T = symbols("n_0 m g x k_b T") + expr = n0 * exp(-m * g * x / (kb * T)) + f = lambda x: x[:, [0]] * torch.exp( + -x[:, [1]] * x[:, [2]] * x[:, [3]] / (x[:, [4]] * x[:, [5]]) + ) + ranges = [[0, 1], [-1, 1], [-1, 1], [-1, 1], [1, 2], [1, 2]] + + if name == "I.41.16" or name == 44: + symbol = hbar, omega, c, kb, T = symbols("hbar omega c k_b T") + expr = hbar * omega**3 / (pi**2 * c**2 * (exp(hbar * omega / (kb * T)) - 1)) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] ** 3 + / ( + tpi**2 + * x[:, [2]] ** 2 + * (torch.exp(x[:, [0]] * x[:, [1]] / (x[:, [3]] * x[:, [4]])) - 1) + ) + ) + ranges = [[0.5, 1], [0.5, 1], [0.5, 2], [0.5, 2], [0.5, 2]] + + if name == "I.43.16" or name == 45: + symbol = mu, q, Ve, d = symbols("mu q V_e d") + expr = mu * q * Ve / d + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "I.43.31" or name == 46: + symbol = mu, kb, T = symbols("mu k_b T") + expr = mu * kb * T + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] + ranges = [[0, 1], [0, 1], [0, 1]] + + if name == "I.43.43" or name == 47: + symbol = gamma, kb, v, A = symbols("gamma k_b v A") + expr = kb * v / A / (gamma - 1) + f = lambda x: 1 / (x[:, [0]] - 1) * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[1.5, 3], [0, 1], [0, 1], [0.5, 2]] + + if name == "I.44.4" or name == 48: + symbol = n, kb, T, V1, V2 = symbols("n k_b T V_1 V_2") + expr = n * kb * T * log(V2 / V1) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + * x[:, [2]] + * torch.log(x[:, [4]] / x[:, [3]]) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "I.47.23" or name == 49: + symbol = gamma, p, rho = symbols("gamma p rho") + expr = sqrt(gamma * p / rho) + f = lambda x: torch.sqrt(x[:, [0]] * x[:, [1]] / x[:, [2]]) + ranges = [[0.1, 1], [0.1, 1], [0.5, 2]] + + if name == "I.48.20" or name == 50: + symbol = m, v, c = symbols("m v c") + expr = m * c**2 / sqrt(1 - v**2 / c**2) + f = ( + lambda x: x[:, [0]] + * x[:, [2]] ** 2 + / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ) + ranges = [[0, 1], [-0.9, 0.9], [1.1, 2]] + + if name == "I.50.26" or name == 51: + symbol = x1, alpha, omega, t = symbols("x_1 alpha omega t") + expr = x1 * (cos(omega * t) + alpha * cos(omega * t) ** 2) + f = lambda x: x[:, [0]] * ( + torch.cos(x[:, [2]] * x[:, [3]]) + + x[:, [1]] * torch.cos(x[:, [2]] * x[:, [3]]) ** 2 + ) + ranges = [[0, 1], [0, 1], [0, 2 * tpi], [0, 1]] + + if name == "II.2.42" or name == 52: + symbol = kappa, T1, T2, A, d = symbols("kappa T_1 T_2 A d") + expr = kappa * (T2 - T1) * A / d + f = lambda x: x[:, [0]] * (x[:, [2]] - x[:, [1]]) * x[:, [3]] / x[:, [4]] + ranges = [[0, 1], [0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "II.3.24" or name == 53: + symbol = P, r = symbols("P r") + expr = P / (4 * pi * r**2) + f = lambda x: x[:, [0]] / (4 * tpi * x[:, [1]] ** 2) + ranges = [[0, 1], [0.5, 2]] + + if name == "II.4.23" or name == 54: + symbol = q, eps, r = symbols("q epsilon r") + expr = q / (4 * pi * eps * r) + f = lambda x: x[:, [0]] / (4 * tpi * x[:, [1]] * x[:, [2]]) + ranges = [[0, 1], [0.5, 2], [0.5, 2]] + + if name == "II.6.11" or name == 55: + symbol = eps, pd, theta, r = symbols("epsilon p_d theta r") + expr = 1 / (4 * pi * eps) * pd * cos(theta) / r**2 + f = ( + lambda x: 1 + / (4 * tpi * x[:, [0]]) + * x[:, [1]] + * torch.cos(x[:, [2]]) + / x[:, [3]] ** 2 + ) + ranges = [[0.5, 2], [0, 1], [0, 2 * tpi], [0.5, 2]] + + if name == "II.6.15a" or name == 56: + symbol = eps, pd, z, x, y, r = symbols("epsilon p_d z x y r") + expr = 3 / (4 * pi * eps) * pd * z / r**5 * sqrt(x**2 + y**2) + f = ( + lambda x: 3 + / (4 * tpi * x[:, [0]]) + * x[:, [1]] + * x[:, [2]] + / x[:, [5]] ** 5 + * torch.sqrt(x[:, [3]] ** 2 + x[:, [4]] ** 2) + ) + ranges = [[0.5, 2], [0, 1], [0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "II.6.15b" or name == 57: + symbol = eps, pd, r, theta = symbols("epsilon p_d r theta") + expr = 3 / (4 * pi * eps) * pd / r**3 * cos(theta) * sin(theta) + f = ( + lambda x: 3 + / (4 * tpi * x[:, [0]]) + * x[:, [1]] + / x[:, [2]] ** 3 + * torch.cos(x[:, [3]]) + * torch.sin(x[:, [3]]) + ) + ranges = [[0.5, 2], [0, 1], [0.5, 2], [0, 2 * tpi]] + + if name == "II.8.7" or name == 58: + symbol = q, eps, d = symbols("q epsilon d") + expr = 3 / 5 * q**2 / (4 * pi * eps * d) + f = lambda x: 3 / 5 * x[:, [0]] ** 2 / (4 * tpi * x[:, [1]] * x[:, [2]]) + ranges = [[0, 1], [0.5, 2], [0.5, 2]] + + if name == "II.8.31" or name == 59: + symbol = eps, Ef = symbols("epsilon E_f") + expr = 1 / 2 * eps * Ef**2 + f = lambda x: 1 / 2 * x[:, [0]] * x[:, [1]] ** 2 + ranges = [[0, 1], [0, 1]] + + if name == "I.10.9" or name == 60: + symbol = sigma, eps, chi = symbols("sigma epsilon chi") + expr = sigma / eps / (1 + chi) + f = lambda x: x[:, [0]] / x[:, [1]] / (1 + x[:, [2]]) + ranges = [[0, 1], [0.5, 2], [0, 1]] + + if name == "II.11.3" or name == 61: + symbol = q, Ef, m, omega0, omega = symbols("q E_f m omega_o omega") + expr = q * Ef / (m * (omega0**2 - omega**2)) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / (x[:, [2]] * (x[:, [3]] ** 2 - x[:, [4]] ** 2)) + ) + ranges = [[0, 1], [0, 1], [0.5, 2], [1.5, 3], [0, 1]] + + if name == "II.11.17" or name == 62: + symbol = n0, pd, Ef, theta, kb, T = symbols("n_0 p_d E_f theta k_b T") + expr = n0 * (1 + pd * Ef * cos(theta) / (kb * T)) + f = lambda x: x[:, [0]] * ( + 1 + x[:, [1]] * x[:, [2]] * torch.cos(x[:, [3]]) / (x[:, [4]] * x[:, [5]]) + ) + ranges = [[0, 1], [-1, 1], [-1, 1], [0, 2 * tpi], [0.5, 2], [0.5, 2]] + + if name == "II.11.20" or name == 63: + symbol = n, pd, Ef, kb, T = symbols("n p_d E_f k_b T") + expr = n * pd**2 * Ef / (3 * kb * T) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] ** 2 + * x[:, [2]] + / (3 * x[:, [3]] * x[:, [4]]) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "II.11.27" or name == 64: + symbol = n, alpha, eps, Ef = symbols("n alpha epsilon E_f") + expr = n * alpha / (1 - n * alpha / 3) * eps * Ef + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / (1 - x[:, [0]] * x[:, [1]] / 3) + * x[:, [2]] + * x[:, [3]] + ) + ranges = [[0, 1], [0, 2], [0, 1], [0, 1]] + + if name == "II.11.28" or name == 65: + symbol = n, alpha = symbols("n alpha") + expr = 1 + n * alpha / (1 - n * alpha / 3) + f = lambda x: 1 + x[:, [0]] * x[:, [1]] / (1 - x[:, [0]] * x[:, [1]] / 3) + ranges = [[0, 1], [0, 2]] + + if name == "II.13.17" or name == 66: + symbol = eps, c, l, r = symbols("epsilon c l r") + expr = 1 / (4 * pi * eps * c**2) * (2 * l / r) + f = ( + lambda x: 1 + / (4 * tpi * x[:, [0]] * x[:, [1]] ** 2) + * (2 * x[:, [2]] / x[:, [3]]) + ) + ranges = [[0.5, 2], [0.5, 2], [0, 1], [0.5, 2]] + + if name == "II.13.23" or name == 67: + symbol = rho, v, c = symbols("rho v c") + expr = rho / sqrt(1 - v**2 / c**2) + f = lambda x: x[:, [0]] / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ranges = [[0, 1], [0, 1], [1, 2]] + + if name == "II.13.34" or name == 68: + symbol = rho, v, c = symbols("rho v c") + expr = rho * v / sqrt(1 - v**2 / c**2) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + ) + ranges = [[0, 1], [0, 1], [1, 2]] + + if name == "II.15.4" or name == 69: + symbol = muM, B, theta = symbols("mu_M B theta") + expr = -muM * B * cos(theta) + f = lambda x: -x[:, [0]] * x[:, [1]] * torch.cos(x[:, [2]]) + ranges = [[0, 1], [0, 1], [0, 2 * tpi]] + + if name == "II.15.5" or name == 70: + symbol = pd, Ef, theta = symbols("p_d E_f theta") + expr = -pd * Ef * cos(theta) + f = lambda x: -x[:, [0]] * x[:, [1]] * torch.cos(x[:, [2]]) + ranges = [[0, 1], [0, 1], [0, 2 * tpi]] + + if name == "II.21.32" or name == 71: + symbol = q, eps, r, v, c = symbols("q epsilon r v c") + expr = q / (4 * pi * eps * r * (1 - v / c)) + f = lambda x: x[:, [0]] / ( + 4 * tpi * x[:, [1]] * x[:, [2]] * (1 - x[:, [3]] / x[:, [4]]) + ) + ranges = [[0, 1], [0.5, 2], [0.5, 2], [0, 1], [1, 2]] + + if name == "II.24.17" or name == 72: + symbol = omega, c, d = symbols("omega c d") + expr = sqrt(omega**2 / c**2 - pi**2 / d**2) + f = lambda x: torch.sqrt( + x[:, [0]] ** 2 / x[:, [1]] ** 2 - tpi**2 / x[:, [2]] ** 2 + ) + ranges = [[1, 1.5], [0.75, 1], [1 * tpi, 1.5 * tpi]] + + if name == "II.27.16" or name == 73: + symbol = eps, c, Ef = symbols("epsilon c E_f") expr = eps * c * Ef**2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]**2 - ranges = [[0,1],[0,1],[-1,1]] - - if name == 'II.27.18' or name == 74: - symbol = eps, Ef = symbols('epsilon E_f') + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] ** 2 + ranges = [[0, 1], [0, 1], [-1, 1]] + + if name == "II.27.18" or name == 74: + symbol = eps, Ef = symbols("epsilon E_f") expr = eps * Ef**2 - f = lambda x: x[:,[0]]*x[:,[1]]**2 - ranges = [[0,1],[-1,1]] - - if name == 'II.34.2a' or name == 75: - symbol = q, v, r = symbols('q v r') - expr = q*v/(2*pi*r) - f = lambda x: x[:,[0]]*x[:,[1]]/(2*tpi*x[:,[2]]) - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'II.34.2' or name == 76: - symbol = q, v, r = symbols('q v r') - expr = q*v*r/2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/2 - ranges = [[0,1],[0,1],[0,1]] - - if name == 'II.34.11' or name == 77: - symbol = g, q, B, m = symbols('g q B m') - expr = g*q*B/(2*m) - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/(2*x[:,[3]]) - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.34.29a' or name == 78: - symbol = q, h, m = symbols('q h m') - expr = q*h/(4*pi*m) - f = lambda x: x[:,[0]]*x[:,[1]]/(4*tpi*x[:,[2]]) - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'II.34.29b' or name == 79: - symbol = g, mu, B, J, hbar = symbols('g mu B J hbar') - expr = g*mu*B*J/hbar - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]*x[:,[3]]/x[:,[4]] - ranges = [[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.35.18' or name == 80: - symbol = n0, mu, B, kb, T = symbols('n0 mu B k_b T') - expr = n0/(exp(mu*B/(kb*T))+exp(-mu*B/(kb*T))) - f = lambda x: x[:,[0]]/(torch.exp(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))+torch.exp(-x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.35.21' or name == 81: - symbol = n, mu, B, kb, T = symbols('n mu B k_b T') - expr = n*mu*tanh(mu*B/(kb*T)) - f = lambda x: x[:,[0]]*x[:,[1]]*torch.tanh(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]])) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.36.38' or name == 82: - symbol = mu, B, kb, T, alpha, M, eps, c = symbols('mu B k_b T alpha M epsilon c') - expr = mu*B/(kb*T) + mu*alpha*M/(eps*c**2*kb*T) - f = lambda x: x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]) + x[:,[0]]*x[:,[4]]*x[:,[5]]/(x[:,[6]]*x[:,[7]]**2*x[:,[2]]*x[:,[3]]) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'II.37.1' or name == 83: - symbol = mu, chi, B = symbols('mu chi B') - expr = mu*(1+chi)*B - f = lambda x: x[:,[0]]*(1+x[:,[1]])*x[:,[2]] - ranges = [[0,1],[0,1],[0,1]] - - if name == 'II.38.3' or name == 84: - symbol = Y, A, x, d = symbols('Y A x d') - expr = Y*A*x/d - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'II.38.14' or name == 85: - symbol = Y, sigma = symbols('Y sigma') - expr = Y/(2*(1+sigma)) - f = lambda x: x[:,[0]]/(2*(1+x[:,[1]])) - ranges = [[0,1],[0,1]] - - if name == 'III.4.32' or name == 86: - symbol = hbar, omega, kb, T = symbols('hbar omega k_b T') - expr = 1/(exp(hbar*omega/(kb*T))-1) - f = lambda x: 1/(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]))-1) - ranges = [[0.5,1],[0.5,1],[0.5,2],[0.5,2]] - - if name == 'III.4.33' or name == 87: - symbol = hbar, omega, kb, T = symbols('hbar omega k_b T') - expr = hbar*omega/(exp(hbar*omega/(kb*T))-1) - f = lambda x: x[:,[0]]*x[:,[1]]/(torch.exp(x[:,[0]]*x[:,[1]]/(x[:,[2]]*x[:,[3]]))-1) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'III.7.38' or name == 88: - symbol = mu, B, hbar = symbols('mu B hbar') - expr = 2*mu*B/hbar - f = lambda x: 2*x[:,[0]]*x[:,[1]]/x[:,[2]] - ranges = [[0,1],[0,1],[0.5,2]] - - if name == 'III.8.54' or name == 89: - symbol = E, t, hbar = symbols('E t hbar') - expr = sin(E*t/hbar)**2 - f = lambda x: torch.sin(x[:,[0]]*x[:,[1]]/x[:,[2]])**2 - ranges = [[0,2*tpi],[0,1],[0.5,2]] - - if name == 'III.9.52' or name == 90: - symbol = pd, Ef, t, hbar, omega, omega0 = symbols('p_d E_f t hbar omega omega_0') - expr = pd*Ef*t/hbar*sin((omega-omega0)*t/2)**2/((omega-omega0)*t/2)**2 - f = lambda x: x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]]*torch.sin((x[:,[4]]-x[:,[5]])*x[:,[2]]/2)**2/((x[:,[4]]-x[:,[5]])*x[:,[2]]/2)**2 - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0,tpi],[0,tpi]] - - if name == 'III.10.19' or name == 91: - symbol = mu, Bx, By, Bz = symbols('mu B_x B_y B_z') - expr = mu*sqrt(Bx**2+By**2+Bz**2) - f = lambda x: x[:,[0]]*torch.sqrt(x[:,[1]]**2+x[:,[2]]**2+x[:,[3]]**2) - ranges = [[0,1],[0,1],[0,1],[0,1]] - - if name == 'III.12.43' or name == 92: - symbol = n, hbar = symbols('n hbar') + f = lambda x: x[:, [0]] * x[:, [1]] ** 2 + ranges = [[0, 1], [-1, 1]] + + if name == "II.34.2a" or name == 75: + symbol = q, v, r = symbols("q v r") + expr = q * v / (2 * pi * r) + f = lambda x: x[:, [0]] * x[:, [1]] / (2 * tpi * x[:, [2]]) + ranges = [[0, 1], [0, 1], [0.5, 2]] + + if name == "II.34.2" or name == 76: + symbol = q, v, r = symbols("q v r") + expr = q * v * r / 2 + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / 2 + ranges = [[0, 1], [0, 1], [0, 1]] + + if name == "II.34.11" or name == 77: + symbol = g, q, B, m = symbols("g q B m") + expr = g * q * B / (2 * m) + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / (2 * x[:, [3]]) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "II.34.29a" or name == 78: + symbol = q, h, m = symbols("q h m") + expr = q * h / (4 * pi * m) + f = lambda x: x[:, [0]] * x[:, [1]] / (4 * tpi * x[:, [2]]) + ranges = [[0, 1], [0, 1], [0.5, 2]] + + if name == "II.34.29b" or name == 79: + symbol = g, mu, B, J, hbar = symbols("g mu B J hbar") + expr = g * mu * B * J / hbar + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] * x[:, [3]] / x[:, [4]] + ranges = [[0, 1], [0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "II.35.18" or name == 80: + symbol = n0, mu, B, kb, T = symbols("n0 mu B k_b T") + expr = n0 / (exp(mu * B / (kb * T)) + exp(-mu * B / (kb * T))) + f = lambda x: x[:, [0]] / ( + torch.exp(x[:, [1]] * x[:, [2]] / (x[:, [3]] * x[:, [4]])) + + torch.exp(-x[:, [1]] * x[:, [2]] / (x[:, [3]] * x[:, [4]])) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "II.35.21" or name == 81: + symbol = n, mu, B, kb, T = symbols("n mu B k_b T") + expr = n * mu * tanh(mu * B / (kb * T)) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + * torch.tanh(x[:, [1]] * x[:, [2]] / (x[:, [3]] * x[:, [4]])) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "II.36.38" or name == 82: + symbol = mu, B, kb, T, alpha, M, eps, c = symbols( + "mu B k_b T alpha M epsilon c" + ) + expr = mu * B / (kb * T) + mu * alpha * M / (eps * c**2 * kb * T) + f = lambda x: x[:, [0]] * x[:, [1]] / (x[:, [2]] * x[:, [3]]) + x[:, [0]] * x[ + :, [4] + ] * x[:, [5]] / (x[:, [6]] * x[:, [7]] ** 2 * x[:, [2]] * x[:, [3]]) + ranges = [ + [0, 1], + [0, 1], + [0.5, 2], + [0.5, 2], + [0, 1], + [0, 1], + [0.5, 2], + [0.5, 2], + ] + + if name == "II.37.1" or name == 83: + symbol = mu, chi, B = symbols("mu chi B") + expr = mu * (1 + chi) * B + f = lambda x: x[:, [0]] * (1 + x[:, [1]]) * x[:, [2]] + ranges = [[0, 1], [0, 1], [0, 1]] + + if name == "II.38.3" or name == 84: + symbol = Y, A, x, d = symbols("Y A x d") + expr = Y * A * x / d + f = lambda x: x[:, [0]] * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "II.38.14" or name == 85: + symbol = Y, sigma = symbols("Y sigma") + expr = Y / (2 * (1 + sigma)) + f = lambda x: x[:, [0]] / (2 * (1 + x[:, [1]])) + ranges = [[0, 1], [0, 1]] + + if name == "III.4.32" or name == 86: + symbol = hbar, omega, kb, T = symbols("hbar omega k_b T") + expr = 1 / (exp(hbar * omega / (kb * T)) - 1) + f = lambda x: 1 / ( + torch.exp(x[:, [0]] * x[:, [1]] / (x[:, [2]] * x[:, [3]])) - 1 + ) + ranges = [[0.5, 1], [0.5, 1], [0.5, 2], [0.5, 2]] + + if name == "III.4.33" or name == 87: + symbol = hbar, omega, kb, T = symbols("hbar omega k_b T") + expr = hbar * omega / (exp(hbar * omega / (kb * T)) - 1) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / (torch.exp(x[:, [0]] * x[:, [1]] / (x[:, [2]] * x[:, [3]])) - 1) + ) + ranges = [[0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "III.7.38" or name == 88: + symbol = mu, B, hbar = symbols("mu B hbar") + expr = 2 * mu * B / hbar + f = lambda x: 2 * x[:, [0]] * x[:, [1]] / x[:, [2]] + ranges = [[0, 1], [0, 1], [0.5, 2]] + + if name == "III.8.54" or name == 89: + symbol = E, t, hbar = symbols("E t hbar") + expr = sin(E * t / hbar) ** 2 + f = lambda x: torch.sin(x[:, [0]] * x[:, [1]] / x[:, [2]]) ** 2 + ranges = [[0, 2 * tpi], [0, 1], [0.5, 2]] + + if name == "III.9.52" or name == 90: + symbol = pd, Ef, t, hbar, omega, omega0 = symbols( + "p_d E_f t hbar omega omega_0" + ) + expr = ( + pd + * Ef + * t + / hbar + * sin((omega - omega0) * t / 2) ** 2 + / ((omega - omega0) * t / 2) ** 2 + ) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + * x[:, [2]] + / x[:, [3]] + * torch.sin((x[:, [4]] - x[:, [5]]) * x[:, [2]] / 2) ** 2 + / ((x[:, [4]] - x[:, [5]]) * x[:, [2]] / 2) ** 2 + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0, tpi], [0, tpi]] + + if name == "III.10.19" or name == 91: + symbol = mu, Bx, By, Bz = symbols("mu B_x B_y B_z") + expr = mu * sqrt(Bx**2 + By**2 + Bz**2) + f = lambda x: x[:, [0]] * torch.sqrt( + x[:, [1]] ** 2 + x[:, [2]] ** 2 + x[:, [3]] ** 2 + ) + ranges = [[0, 1], [0, 1], [0, 1], [0, 1]] + + if name == "III.12.43" or name == 92: + symbol = n, hbar = symbols("n hbar") expr = n * hbar - f = lambda x: x[:,[0]]*x[:,[1]] - ranges = [[0,1],[0,1]] - - if name == 'III.13.18' or name == 93: - symbol = E, d, k, hbar = symbols('E d k hbar') - expr = 2*E*d**2*k/hbar - f = lambda x: 2*x[:,[0]]*x[:,[1]]**2*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'III.14.14' or name == 94: - symbol = I0, q, Ve, kb, T = symbols('I_0 q V_e k_b T') - expr = I0 * (exp(q*Ve/(kb*T))-1) - f = lambda x: x[:,[0]]*(torch.exp(x[:,[1]]*x[:,[2]]/(x[:,[3]]*x[:,[4]]))-1) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2]] - - if name == 'III.15.12' or name == 95: - symbol = U, k, d = symbols('U k d') - expr = 2*U*(1-cos(k*d)) - f = lambda x: 2*x[:,[0]]*(1-torch.cos(x[:,[1]]*x[:,[2]])) - ranges = [[0,1],[0,2*tpi],[0,1]] - - if name == 'III.15.14' or name == 96: - symbol = hbar, E, d = symbols('hbar E d') - expr = hbar**2/(2*E*d**2) - f = lambda x: x[:,[0]]**2/(2*x[:,[1]]*x[:,[2]]**2) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'III.15.27' or name == 97: - symbol = alpha, n, d = symbols('alpha n d') - expr = 2*pi*alpha/(n*d) - f = lambda x: 2*tpi*x[:,[0]]/(x[:,[1]]*x[:,[2]]) - ranges = [[0,1],[0.5,2],[0.5,2]] - - if name == 'III.17.37' or name == 98: - symbol = beta, alpha, theta = symbols('beta alpha theta') - expr = beta * (1+alpha*cos(theta)) - f = lambda x: x[:,[0]]*(1+x[:,[1]]*torch.cos(x[:,[2]])) - ranges = [[0,1],[0,1],[0,2*tpi]] - - if name == 'III.19.51' or name == 99: - symbol = m, q, eps, hbar, n = symbols('m q epsilon hbar n') - expr = - m * q**4/(2*(4*pi*eps)**2*hbar**2)*1/n**2 - f = lambda x: - x[:,[0]]*x[:,[1]]**4/(2*(4*tpi*x[:,[2]])**2*x[:,[3]]**2)*1/x[:,[4]]**2 - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'III.21.20' or name == 100: - symbol = rho, q, A, m = symbols('rho q A m') - expr = - rho*q*A/m - f = lambda x: - x[:,[0]]*x[:,[1]]*x[:,[2]]/x[:,[3]] - ranges = [[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'Rutherforld scattering' or name == 101: - symbol = Z1, Z2, alpha, hbar, c, E, theta = symbols('Z_1 Z_2 alpha hbar c E theta') - expr = (Z1*Z2*alpha*hbar*c/(4*E*sin(theta/2)**2))**2 - f = lambda x: (x[:,[0]]*x[:,[1]]*x[:,[2]]*x[:,[3]]*x[:,[4]]/(4*x[:,[5]]*torch.sin(x[:,[6]]/2)**2))**2 - ranges = [[0,1],[0,1],[0,1],[0,1],[0,1],[0.5,2],[0.1*tpi,0.9*tpi]] - - if name == 'Friedman equation' or name == 102: - symbol = G, rho, kf, c, af = symbols('G rho k_f c a_f') - expr = sqrt(8*pi*G/3*rho-kf*c**2/af**2) - f = lambda x: torch.sqrt(8*tpi*x[:,[0]]/3*x[:,[1]] - x[:,[2]]*x[:,[3]]**2/x[:,[4]]**2) - ranges = [[1,2],[1,2],[0,1],[0,1],[1,2]] - - if name == 'Compton scattering' or name == 103: - symbol = E, m, c, theta = symbols('E m c theta') - expr = E/(1+E/(m*c**2)*(1-cos(theta))) - f = lambda x: x[:,[0]]/(1+x[:,[0]]/(x[:,[1]]*x[:,[2]]**2)*(1-torch.cos(x[:,[3]]))) - ranges = [[0,1],[0.5,2],[0.5,2],[0,2*tpi]] - - if name == 'Radiated gravitational wave power' or name == 104: - symbol = G, c, m1, m2, r = symbols('G c m_1 m_2 r') - expr = -32/5*G**4/c**5*(m1*m2)**2*(m1+m2)/r**5 - f = lambda x: -32/5*x[:,[0]]**4/x[:,[1]]**5*(x[:,[2]]*x[:,[3]])**2*(x[:,[2]]+x[:,[3]])/x[:,[4]]**5 - ranges = [[0,1],[0.5,2],[0,1],[0,1],[0.5,2]] - - if name == 'Relativistic aberration' or name == 105: - symbol = theta2, v, c = symbols('theta_2 v c') - expr = acos((cos(theta2)-v/c)/(1-v/c*cos(theta2))) - f = lambda x: torch.arccos((torch.cos(x[:,[0]])-x[:,[1]]/x[:,[2]])/(1-x[:,[1]]/x[:,[2]]*torch.cos(x[:,[0]]))) - ranges = [[0,tpi],[0,1],[1,2]] - - if name == 'N-slit diffraction' or name == 106: - symbol = I0, alpha, delta, N = symbols('I_0 alpha delta N') - expr = I0 * (sin(alpha/2)/(alpha/2)*sin(N*delta/2)/sin(delta/2))**2 - f = lambda x: x[:,[0]] * (torch.sin(x[:,[1]]/2)/(x[:,[1]]/2)*torch.sin(x[:,[3]]*x[:,[2]]/2)/torch.sin(x[:,[2]]/2))**2 - ranges = [[0,1],[0.1*tpi,0.9*tpi],[0.1*tpi,0.9*tpi],[0.5,1]] - - if name == 'Goldstein 3.16' or name == 107: - symbol = m, E, U, L, r = symbols('m E U L r') - expr = sqrt(2/m*(E-U-L**2/(2*m*r**2))) - f = lambda x: torch.sqrt(2/x[:,[0]]*(x[:,[1]]-x[:,[2]]-x[:,[3]]**2/(2*x[:,[0]]*x[:,[4]]**2))) - ranges = [[1,2],[2,3],[0,1],[0,1],[1,2]] - - if name == 'Goldstein 3.55' or name == 108: - symbol = m, kG, L, E, theta1, theta2 = symbols('m k_G L E theta_1 theta_2') - expr = m*kG/L**2*(1+sqrt(1+2*E*L**2/(m*kG**2))*cos(theta1-theta2)) - f = lambda x: x[:,[0]]*x[:,[1]]/x[:,[2]]**2*(1+torch.sqrt(1+2*x[:,[3]]*x[:,[2]]**2/(x[:,[0]]*x[:,[1]]**2))*torch.cos(x[:,[4]]-x[:,[5]])) - ranges = [[0.5,2],[0.5,2],[0.5,2],[0,1],[0,2*tpi],[0,2*tpi]] - - if name == 'Goldstein 3.64 (ellipse)' or name == 109: - symbol = d, alpha, theta1, theta2 = symbols('d alpha theta_1 theta_2') - expr = d*(1-alpha**2)/(1+alpha*cos(theta2-theta1)) - f = lambda x: x[:,[0]]*(1-x[:,[1]]**2)/(1+x[:,[1]]*torch.cos(x[:,[2]]-x[:,[3]])) - ranges = [[0,1],[0,0.9],[0,2*tpi],[0,2*tpi]] - - if name == 'Goldstein 3.74 (Kepler)' or name == 110: - symbol = d, G, m1, m2 = symbols('d G m_1 m_2') - expr = 2*pi*d**(3/2)/sqrt(G*(m1+m2)) - f = lambda x: 2*tpi*x[:,[0]]**(3/2)/torch.sqrt(x[:,[1]]*(x[:,[2]]+x[:,[3]])) - ranges = [[0,1],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'Goldstein 3.99' or name == 111: - symbol = eps, E, L, m, Z1, Z2, q = symbols('epsilon E L m Z_1 Z_2 q') - expr = sqrt(1+2*eps**2*E*L**2/(m*(Z1*Z2*q**2)**2)) - f = lambda x: torch.sqrt(1+2*x[:,[0]]**2*x[:,[1]]*x[:,[2]]**2/(x[:,[3]]*(x[:,[4]]*x[:,[5]]*x[:,[6]]**2)**2)) - ranges = [[0,1],[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2],[0.5,2]] - - if name == 'Goldstein 8.56' or name == 112: - symbol = p, q, A, c, m, Ve = symbols('p q A c m V_e') - expr = sqrt((p-q*A)**2*c**2+m**2*c**4) + q*Ve - f = lambda x: torch.sqrt((x[:,[0]]-x[:,[1]]*x[:,[2]])**2*x[:,[3]]**2+x[:,[4]]**2*x[:,[3]]**4) + x[:,[1]]*x[:,[5]] - ranges = [0,1] - - if name == 'Goldstein 12.80' or name == 113: - symbol = m, p, omega, x, alpha, y = symbols('m p omega x alpha y') - expr = 1/(2*m)*(p**2+m**2*omega**2*x**2*(1+alpha*y/x)) - f = lambda x: 1/(2*x[:,[0]]) * (x[:,[1]]**2+x[:,[0]]**2*x[:,[2]]**2*x[:,[3]]**2*(1+x[:,[4]]*x[:,[3]]/x[:,[5]])) - ranges = [[0.5,2],[0,1],[0,1],[0,1],[0,1],[0.5,2]] - - if name == 'Jackson 2.11' or name == 114: - symbol = q, eps, y, Ve, d = symbols('q epsilon y V_e d') - expr = q/(4*pi*eps*y**2)*(4*pi*eps*Ve*d-q*d*y**3/(y**2-d**2)**2) - f = lambda x: x[:,[0]]/(4*tpi*x[:,[1]]*x[:,x[:,[2]]]**2)*(4*tpi*x[:,[1]]*x[:,[3]]*x[:,[4]]-x[:,[0]]*x[:,[4]]*x[:,[2]]**3/(x[:,[2]]**2-x[:,[4]]**2)**2) - ranges = [[0,1],[0.5,2],[1,2],[0,1],[0,1]] - - if name == 'Jackson 3.45' or name == 115: - symbol = q, r, d, alpha = symbols('q r d alpha') - expr = q/sqrt(r**2+d**2-2*d*r*cos(alpha)) - f = lambda x: x[:,[0]]/torch.sqrt(x[:,[1]]**2+x[:,[2]]**2-2*x[:,[1]]*x[:,[2]]*torch.cos(x[:,[3]])) - ranges = [[0,1],[0,1],[0,1],[0,2*tpi]] - - if name == 'Jackson 4.60' or name == 116: - symbol = Ef, theta, alpha, d, r = symbols('E_f theta alpha d r') - expr = Ef * cos(theta) * ((alpha-1)/(alpha+2) * d**3/r**2 - r) - f = lambda x: x[:,[0]] * torch.cos(x[:,[1]]) * ((x[:,[2]]-1)/(x[:,[2]]+2) * x[:,[3]]**3/x[:,[4]]**2 - x[:,[4]]) - ranges = [[0,1],[0,2*tpi],[0,2],[0,1],[0.5,2]] - - if name == 'Jackson 11.38 (Doppler)' or name == 117: - symbol = omega, v, c, theta = symbols('omega v c theta') - expr = sqrt(1-v**2/c**2)/(1+v/c*cos(theta))*omega - f = lambda x: torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2)/(1+x[:,[1]]/x[:,[2]]*torch.cos(x[:,[3]]))*x[:,[0]] - ranges = [[0,1],[0,1],[1,2],[0,2*tpi]] - - if name == 'Weinberg 15.2.1' or name == 118: - symbol = G, c, kf, af, H = symbols('G c k_f a_f H') - expr = 3/(8*pi*G)*(c**2*kf/af**2+H**2) - f = lambda x: 3/(8*tpi*x[:,[0]])*(x[:,[1]]**2*x[:,[2]]/x[:,[3]]**2+x[:,[4]]**2) - ranges = [[0.5,2],[0,1],[0,1],[0.5,2],[0,1]] - - if name == 'Weinberg 15.2.2' or name == 119: - symbol = G, c, kf, af, H, alpha = symbols('G c k_f a_f H alpha') - expr = -1/(8*pi*G)*(c**4*kf/af**2+c**2*H**2*(1-2*alpha)) - f = lambda x: -1/(8*tpi*x[:,[0]])*(x[:,[1]]**4*x[:,[2]]/x[:,[3]]**2 + x[:,[1]]**2*x[:,[4]]**2*(1-2*x[:,[5]])) - ranges = [[0.5,2],[0,1],[0,1],[0.5,2],[0,1],[0,1]] - - if name == 'Schwarz 13.132 (Klein-Nishina)' or name == 120: - symbol = alpha, hbar, m, c, omega0, omega, theta = symbols('alpha hbar m c omega_0 omega theta') - expr = pi*alpha**2*hbar**2/m**2/c**2*(omega0/omega)**2*(omega0/omega+omega/omega0-sin(theta)**2) - f = lambda x: tpi*x[:,[0]]**2*x[:,[1]]**2/x[:,[2]]**2/x[:,[3]]**2*(x[:,[4]]/x[:,[5]])**2*(x[:,[4]]/x[:,[5]]+x[:,[5]]/x[:,[4]]-torch.sin(x[:,[6]])**2) - ranges = [[0,1],[0,1],[0.5,2],[0.5,2],[0.5,2],[0.5,2],[0,2*tpi]] - - return symbol, expr, f, ranges \ No newline at end of file + f = lambda x: x[:, [0]] * x[:, [1]] + ranges = [[0, 1], [0, 1]] + + if name == "III.13.18" or name == 93: + symbol = E, d, k, hbar = symbols("E d k hbar") + expr = 2 * E * d**2 * k / hbar + f = lambda x: 2 * x[:, [0]] * x[:, [1]] ** 2 * x[:, [2]] / x[:, [3]] + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "III.14.14" or name == 94: + symbol = I0, q, Ve, kb, T = symbols("I_0 q V_e k_b T") + expr = I0 * (exp(q * Ve / (kb * T)) - 1) + f = lambda x: x[:, [0]] * ( + torch.exp(x[:, [1]] * x[:, [2]] / (x[:, [3]] * x[:, [4]])) - 1 + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2]] + + if name == "III.15.12" or name == 95: + symbol = U, k, d = symbols("U k d") + expr = 2 * U * (1 - cos(k * d)) + f = lambda x: 2 * x[:, [0]] * (1 - torch.cos(x[:, [1]] * x[:, [2]])) + ranges = [[0, 1], [0, 2 * tpi], [0, 1]] + + if name == "III.15.14" or name == 96: + symbol = hbar, E, d = symbols("hbar E d") + expr = hbar**2 / (2 * E * d**2) + f = lambda x: x[:, [0]] ** 2 / (2 * x[:, [1]] * x[:, [2]] ** 2) + ranges = [[0, 1], [0.5, 2], [0.5, 2]] + + if name == "III.15.27" or name == 97: + symbol = alpha, n, d = symbols("alpha n d") + expr = 2 * pi * alpha / (n * d) + f = lambda x: 2 * tpi * x[:, [0]] / (x[:, [1]] * x[:, [2]]) + ranges = [[0, 1], [0.5, 2], [0.5, 2]] + + if name == "III.17.37" or name == 98: + symbol = beta, alpha, theta = symbols("beta alpha theta") + expr = beta * (1 + alpha * cos(theta)) + f = lambda x: x[:, [0]] * (1 + x[:, [1]] * torch.cos(x[:, [2]])) + ranges = [[0, 1], [0, 1], [0, 2 * tpi]] + + if name == "III.19.51" or name == 99: + symbol = m, q, eps, hbar, n = symbols("m q epsilon hbar n") + expr = -m * q**4 / (2 * (4 * pi * eps) ** 2 * hbar**2) * 1 / n**2 + f = ( + lambda x: -x[:, [0]] + * x[:, [1]] ** 4 + / (2 * (4 * tpi * x[:, [2]]) ** 2 * x[:, [3]] ** 2) + * 1 + / x[:, [4]] ** 2 + ) + ranges = [[0, 1], [0, 1], [0.5, 2], [0.5, 2], [0.5, 2]] + + if name == "III.21.20" or name == 100: + symbol = rho, q, A, m = symbols("rho q A m") + expr = -rho * q * A / m + f = lambda x: -x[:, [0]] * x[:, [1]] * x[:, [2]] / x[:, [3]] + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "Rutherforld scattering" or name == 101: + symbol = Z1, Z2, alpha, hbar, c, E, theta = symbols( + "Z_1 Z_2 alpha hbar c E theta" + ) + expr = (Z1 * Z2 * alpha * hbar * c / (4 * E * sin(theta / 2) ** 2)) ** 2 + f = ( + lambda x: ( + x[:, [0]] + * x[:, [1]] + * x[:, [2]] + * x[:, [3]] + * x[:, [4]] + / (4 * x[:, [5]] * torch.sin(x[:, [6]] / 2) ** 2) + ) + ** 2 + ) + ranges = [ + [0, 1], + [0, 1], + [0, 1], + [0, 1], + [0, 1], + [0.5, 2], + [0.1 * tpi, 0.9 * tpi], + ] + + if name == "Friedman equation" or name == 102: + symbol = G, rho, kf, c, af = symbols("G rho k_f c a_f") + expr = sqrt(8 * pi * G / 3 * rho - kf * c**2 / af**2) + f = lambda x: torch.sqrt( + 8 * tpi * x[:, [0]] / 3 * x[:, [1]] + - x[:, [2]] * x[:, [3]] ** 2 / x[:, [4]] ** 2 + ) + ranges = [[1, 2], [1, 2], [0, 1], [0, 1], [1, 2]] + + if name == "Compton scattering" or name == 103: + symbol = E, m, c, theta = symbols("E m c theta") + expr = E / (1 + E / (m * c**2) * (1 - cos(theta))) + f = lambda x: x[:, [0]] / ( + 1 + x[:, [0]] / (x[:, [1]] * x[:, [2]] ** 2) * (1 - torch.cos(x[:, [3]])) + ) + ranges = [[0, 1], [0.5, 2], [0.5, 2], [0, 2 * tpi]] + + if name == "Radiated gravitational wave power" or name == 104: + symbol = G, c, m1, m2, r = symbols("G c m_1 m_2 r") + expr = -32 / 5 * G**4 / c**5 * (m1 * m2) ** 2 * (m1 + m2) / r**5 + f = ( + lambda x: -32 + / 5 + * x[:, [0]] ** 4 + / x[:, [1]] ** 5 + * (x[:, [2]] * x[:, [3]]) ** 2 + * (x[:, [2]] + x[:, [3]]) + / x[:, [4]] ** 5 + ) + ranges = [[0, 1], [0.5, 2], [0, 1], [0, 1], [0.5, 2]] + + if name == "Relativistic aberration" or name == 105: + symbol = theta2, v, c = symbols("theta_2 v c") + expr = acos((cos(theta2) - v / c) / (1 - v / c * cos(theta2))) + f = lambda x: torch.arccos( + (torch.cos(x[:, [0]]) - x[:, [1]] / x[:, [2]]) + / (1 - x[:, [1]] / x[:, [2]] * torch.cos(x[:, [0]])) + ) + ranges = [[0, tpi], [0, 1], [1, 2]] + + if name == "N-slit diffraction" or name == 106: + symbol = I0, alpha, delta, N = symbols("I_0 alpha delta N") + expr = ( + I0 + * (sin(alpha / 2) / (alpha / 2) * sin(N * delta / 2) / sin(delta / 2)) ** 2 + ) + f = ( + lambda x: x[:, [0]] + * ( + torch.sin(x[:, [1]] / 2) + / (x[:, [1]] / 2) + * torch.sin(x[:, [3]] * x[:, [2]] / 2) + / torch.sin(x[:, [2]] / 2) + ) + ** 2 + ) + ranges = [[0, 1], [0.1 * tpi, 0.9 * tpi], [0.1 * tpi, 0.9 * tpi], [0.5, 1]] + + if name == "Goldstein 3.16" or name == 107: + symbol = m, E, U, L, r = symbols("m E U L r") + expr = sqrt(2 / m * (E - U - L**2 / (2 * m * r**2))) + f = lambda x: torch.sqrt( + 2 + / x[:, [0]] + * ( + x[:, [1]] + - x[:, [2]] + - x[:, [3]] ** 2 / (2 * x[:, [0]] * x[:, [4]] ** 2) + ) + ) + ranges = [[1, 2], [2, 3], [0, 1], [0, 1], [1, 2]] + + if name == "Goldstein 3.55" or name == 108: + symbol = m, kG, L, E, theta1, theta2 = symbols("m k_G L E theta_1 theta_2") + expr = ( + m + * kG + / L**2 + * (1 + sqrt(1 + 2 * E * L**2 / (m * kG**2)) * cos(theta1 - theta2)) + ) + f = ( + lambda x: x[:, [0]] + * x[:, [1]] + / x[:, [2]] ** 2 + * ( + 1 + + torch.sqrt( + 1 + 2 * x[:, [3]] * x[:, [2]] ** 2 / (x[:, [0]] * x[:, [1]] ** 2) + ) + * torch.cos(x[:, [4]] - x[:, [5]]) + ) + ) + ranges = [[0.5, 2], [0.5, 2], [0.5, 2], [0, 1], [0, 2 * tpi], [0, 2 * tpi]] + + if name == "Goldstein 3.64 (ellipse)" or name == 109: + symbol = d, alpha, theta1, theta2 = symbols("d alpha theta_1 theta_2") + expr = d * (1 - alpha**2) / (1 + alpha * cos(theta2 - theta1)) + f = ( + lambda x: x[:, [0]] + * (1 - x[:, [1]] ** 2) + / (1 + x[:, [1]] * torch.cos(x[:, [2]] - x[:, [3]])) + ) + ranges = [[0, 1], [0, 0.9], [0, 2 * tpi], [0, 2 * tpi]] + + if name == "Goldstein 3.74 (Kepler)" or name == 110: + symbol = d, G, m1, m2 = symbols("d G m_1 m_2") + expr = 2 * pi * d ** (3 / 2) / sqrt(G * (m1 + m2)) + f = ( + lambda x: 2 + * tpi + * x[:, [0]] ** (3 / 2) + / torch.sqrt(x[:, [1]] * (x[:, [2]] + x[:, [3]])) + ) + ranges = [[0, 1], [0.5, 2], [0.5, 2], [0.5, 2]] + + if name == "Goldstein 3.99" or name == 111: + symbol = eps, E, L, m, Z1, Z2, q = symbols("epsilon E L m Z_1 Z_2 q") + expr = sqrt(1 + 2 * eps**2 * E * L**2 / (m * (Z1 * Z2 * q**2) ** 2)) + f = lambda x: torch.sqrt( + 1 + + 2 + * x[:, [0]] ** 2 + * x[:, [1]] + * x[:, [2]] ** 2 + / (x[:, [3]] * (x[:, [4]] * x[:, [5]] * x[:, [6]] ** 2) ** 2) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0.5, 2], [0.5, 2], [0.5, 2], [0.5, 2]] + + if name == "Goldstein 8.56" or name == 112: + symbol = p, q, A, c, m, Ve = symbols("p q A c m V_e") + expr = sqrt((p - q * A) ** 2 * c**2 + m**2 * c**4) + q * Ve + f = ( + lambda x: torch.sqrt( + (x[:, [0]] - x[:, [1]] * x[:, [2]]) ** 2 * x[:, [3]] ** 2 + + x[:, [4]] ** 2 * x[:, [3]] ** 4 + ) + + x[:, [1]] * x[:, [5]] + ) + ranges = [0, 1] + + if name == "Goldstein 12.80" or name == 113: + symbol = m, p, omega, x, alpha, y = symbols("m p omega x alpha y") + expr = 1 / (2 * m) * (p**2 + m**2 * omega**2 * x**2 * (1 + alpha * y / x)) + f = ( + lambda x: 1 + / (2 * x[:, [0]]) + * ( + x[:, [1]] ** 2 + + x[:, [0]] ** 2 + * x[:, [2]] ** 2 + * x[:, [3]] ** 2 + * (1 + x[:, [4]] * x[:, [3]] / x[:, [5]]) + ) + ) + ranges = [[0.5, 2], [0, 1], [0, 1], [0, 1], [0, 1], [0.5, 2]] + + if name == "Jackson 2.11" or name == 114: + symbol = q, eps, y, Ve, d = symbols("q epsilon y V_e d") + expr = ( + q + / (4 * pi * eps * y**2) + * (4 * pi * eps * Ve * d - q * d * y**3 / (y**2 - d**2) ** 2) + ) + f = ( + lambda x: x[:, [0]] + / (4 * tpi * x[:, [1]] * x[:, x[:, [2]]] ** 2) + * ( + 4 * tpi * x[:, [1]] * x[:, [3]] * x[:, [4]] + - x[:, [0]] + * x[:, [4]] + * x[:, [2]] ** 3 + / (x[:, [2]] ** 2 - x[:, [4]] ** 2) ** 2 + ) + ) + ranges = [[0, 1], [0.5, 2], [1, 2], [0, 1], [0, 1]] + + if name == "Jackson 3.45" or name == 115: + symbol = q, r, d, alpha = symbols("q r d alpha") + expr = q / sqrt(r**2 + d**2 - 2 * d * r * cos(alpha)) + f = lambda x: x[:, [0]] / torch.sqrt( + x[:, [1]] ** 2 + + x[:, [2]] ** 2 + - 2 * x[:, [1]] * x[:, [2]] * torch.cos(x[:, [3]]) + ) + ranges = [[0, 1], [0, 1], [0, 1], [0, 2 * tpi]] + + if name == "Jackson 4.60" or name == 116: + symbol = Ef, theta, alpha, d, r = symbols("E_f theta alpha d r") + expr = Ef * cos(theta) * ((alpha - 1) / (alpha + 2) * d**3 / r**2 - r) + f = ( + lambda x: x[:, [0]] + * torch.cos(x[:, [1]]) + * ( + (x[:, [2]] - 1) / (x[:, [2]] + 2) * x[:, [3]] ** 3 / x[:, [4]] ** 2 + - x[:, [4]] + ) + ) + ranges = [[0, 1], [0, 2 * tpi], [0, 2], [0, 1], [0.5, 2]] + + if name == "Jackson 11.38 (Doppler)" or name == 117: + symbol = omega, v, c, theta = symbols("omega v c theta") + expr = sqrt(1 - v**2 / c**2) / (1 + v / c * cos(theta)) * omega + f = ( + lambda x: torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2) + / (1 + x[:, [1]] / x[:, [2]] * torch.cos(x[:, [3]])) + * x[:, [0]] + ) + ranges = [[0, 1], [0, 1], [1, 2], [0, 2 * tpi]] + + if name == "Weinberg 15.2.1" or name == 118: + symbol = G, c, kf, af, H = symbols("G c k_f a_f H") + expr = 3 / (8 * pi * G) * (c**2 * kf / af**2 + H**2) + f = ( + lambda x: 3 + / (8 * tpi * x[:, [0]]) + * (x[:, [1]] ** 2 * x[:, [2]] / x[:, [3]] ** 2 + x[:, [4]] ** 2) + ) + ranges = [[0.5, 2], [0, 1], [0, 1], [0.5, 2], [0, 1]] + + if name == "Weinberg 15.2.2" or name == 119: + symbol = G, c, kf, af, H, alpha = symbols("G c k_f a_f H alpha") + expr = -1 / (8 * pi * G) * (c**4 * kf / af**2 + c**2 * H**2 * (1 - 2 * alpha)) + f = ( + lambda x: -1 + / (8 * tpi * x[:, [0]]) + * ( + x[:, [1]] ** 4 * x[:, [2]] / x[:, [3]] ** 2 + + x[:, [1]] ** 2 * x[:, [4]] ** 2 * (1 - 2 * x[:, [5]]) + ) + ) + ranges = [[0.5, 2], [0, 1], [0, 1], [0.5, 2], [0, 1], [0, 1]] + + if name == "Schwarz 13.132 (Klein-Nishina)" or name == 120: + symbol = alpha, hbar, m, c, omega0, omega, theta = symbols( + "alpha hbar m c omega_0 omega theta" + ) + expr = ( + pi + * alpha**2 + * hbar**2 + / m**2 + / c**2 + * (omega0 / omega) ** 2 + * (omega0 / omega + omega / omega0 - sin(theta) ** 2) + ) + f = ( + lambda x: tpi + * x[:, [0]] ** 2 + * x[:, [1]] ** 2 + / x[:, [2]] ** 2 + / x[:, [3]] ** 2 + * (x[:, [4]] / x[:, [5]]) ** 2 + * ( + x[:, [4]] / x[:, [5]] + + x[:, [5]] / x[:, [4]] + - torch.sin(x[:, [6]]) ** 2 + ) + ) + ranges = [[0, 1], [0, 1], [0.5, 2], [0.5, 2], [0.5, 2], [0.5, 2], [0, 2 * tpi]] + + return symbol, expr, f, ranges diff --git a/kan/hypothesis.py b/kan/hypothesis.py index 4850f5098..1e11bde24 100644 --- a/kan/hypothesis.py +++ b/kan/hypothesis.py @@ -1,110 +1,121 @@ import numpy as np import torch -from sklearn.linear_model import LinearRegression from sympy.utilities.lambdify import lambdify from sklearn.cluster import AgglomerativeClustering from .utils import batch_jacobian, batch_hessian from functools import reduce from kan.utils import batch_jacobian, batch_hessian -import copy +import copy import matplotlib.pyplot as plt -import sympy +import sympy from sympy.printing import latex -def detect_separability(model, x, mode='add', score_th=1e-2, res_th=1e-2, n_clusters=None, bias=0., verbose=False): - ''' - detect function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - n_clusters : None or int - the number of clusters - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - results (dictionary) - - Example1 - -------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 + torch.exp(x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> detect_separability(model, x, mode='add') - - Example2 - -------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> detect_separability(model, x, mode='mul') - ''' +def detect_separability( + model, + x, + mode="add", + score_th=1e-2, + res_th=1e-2, + n_clusters=None, + bias=0.0, + verbose=False, +): + """ + detect function separability + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + mode : str + mode = 'add' or mode = 'mul' + score_th : float + threshold of score + res_th : float + threshold of residue + n_clusters : None or int + the number of clusters + bias : float + bias (for multiplicative separability) + verbose : bool + + Returns: + -------- + results (dictionary) + + Example1 + -------- + >>> from kan.hypothesis import * + >>> model = lambda x: x[:,[0]] ** 2 + torch.exp(x[:,[1]]+x[:,[2]]) + >>> x = torch.normal(0,1,size=(100,3)) + >>> detect_separability(model, x, mode='add') + + Example2 + -------- + >>> from kan.hypothesis import * + >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) + >>> x = torch.normal(0,1,size=(100,3)) + >>> detect_separability(model, x, mode='mul') + """ results = {} - - if mode == 'add': + + if mode == "add": hessian = batch_hessian(model, x) - elif mode == 'mul': + elif mode == "mul": compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F) - hessian = batch_hessian(compose(torch.log, torch.abs, lambda x: x+bias, model), x) - + hessian = batch_hessian( + compose(torch.log, torch.abs, lambda x: x + bias, model), x + ) + std = torch.std(x, dim=0) - hessian_normalized = hessian * std[None,:] * std[:,None] + hessian_normalized = hessian * std[None, :] * std[:, None] score_mat = torch.median(torch.abs(hessian_normalized), dim=0)[0] - results['hessian'] = score_mat + results["hessian"] = score_mat dist_hard = (score_mat < score_th).float() - + if isinstance(n_clusters, int): n_cluster_try = [n_clusters, n_clusters] elif isinstance(n_clusters, list): n_cluster_try = n_clusters else: - n_cluster_try = [1,x.shape[1]] - - n_cluster_try = list(range(n_cluster_try[0], n_cluster_try[1]+1)) - + n_cluster_try = [1, x.shape[1]] + + n_cluster_try = list(range(n_cluster_try[0], n_cluster_try[1] + 1)) + for n_cluster in n_cluster_try: - clustering = AgglomerativeClustering( - metric='precomputed', - n_clusters=n_cluster, - linkage='complete', + metric="precomputed", + n_clusters=n_cluster, + linkage="complete", ).fit(dist_hard) labels = clustering.labels_ groups = [list(np.where(labels == i)[0]) for i in range(n_cluster)] - blocks = [torch.sum(score_mat[groups[i]][:,groups[i]]) for i in range(n_cluster)] + blocks = [ + torch.sum(score_mat[groups[i]][:, groups[i]]) for i in range(n_cluster) + ] block_sum = torch.sum(torch.stack(blocks)) total_sum = torch.sum(score_mat) residual_sum = total_sum - block_sum residual_ratio = residual_sum / total_sum - + if verbose == True: - print(f'n_group={n_cluster}, residual_ratio={residual_ratio}') - + print(f"n_group={n_cluster}, residual_ratio={residual_ratio}") + if residual_ratio < res_th: - results['n_groups'] = n_cluster - results['labels'] = list(labels) - results['groups'] = groups - - if results['n_groups'] > 1: - print(f'{mode} separability detected') + results["n_groups"] = n_cluster + results["labels"] = list(labels) + results["groups"] = groups + + if results["n_groups"] > 1: + print(f"{mode} separability detected") else: - print(f'{mode} separability not detected') - + print(f"{mode} separability not detected") + return results @@ -115,15 +126,17 @@ def batch_grad_normgrad(model, x, group, create_graph=False): def jac(x): input_grad = batch_jacobian(model, x, create_graph=True) - input_grad_A = input_grad[:,group_A] + input_grad_A = input_grad[:, group_A] norm = torch.norm(input_grad_A, dim=1, keepdim=True) + 1e-6 - input_grad_A_normalized = input_grad_A/norm + input_grad_A_normalized = input_grad_A / norm return input_grad_A_normalized - + def _jac_sum(x): return jac(x).sum(dim=0) - - return torch.autograd.functional.jacobian(_jac_sum, x, create_graph=create_graph).permute(1,0,2)[:,:,group_B] + + return torch.autograd.functional.jacobian( + _jac_sum, x, create_graph=create_graph + ).permute(1, 0, 2)[:, :, group_B] def get_dependence(model, x, group): @@ -131,178 +144,186 @@ def get_dependence(model, x, group): group_B = list(set(range(x.shape[1])) - set(group)) grad_normgrad = batch_grad_normgrad(model, x, group=group) std = torch.std(x, dim=0) - dependence = grad_normgrad * std[None,group_A,None] * std[None,None,group_B] + dependence = grad_normgrad * std[None, group_A, None] * std[None, None, group_B] dependence = torch.median(torch.abs(dependence), dim=0)[0] return dependence + def test_symmetry(model, x, group, dependence_th=1e-3): - ''' - detect function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - group : a list of indices - dependence_th : float - threshold of dependence - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_symmetry(model, x, [1,2])) # True - >>> print(test_symmetry(model, x, [0,2])) # False - ''' + """ + detect function separability + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + group : a list of indices + dependence_th : float + threshold of dependence + + Returns: + -------- + bool + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) + >>> x = torch.normal(0,1,size=(100,3)) + >>> print(test_symmetry(model, x, [1,2])) # True + >>> print(test_symmetry(model, x, [0,2])) # False + """ if len(group) == x.shape[1] or len(group) == 0: return True - + dependence = get_dependence(model, x, group) max_dependence = torch.max(dependence) return max_dependence < dependence_th -def test_separability(model, x, groups, mode='add', threshold=1e-2, bias=0): - ''' - test function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_separability(model, x, [[0],[1,2]], mode='mul')) # True - >>> print(test_separability(model, x, [[0],[1,2]], mode='add')) # False - ''' - if mode == 'add': +def test_separability(model, x, groups, mode="add", threshold=1e-2, bias=0): + """ + test function separability + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + mode : str + mode = 'add' or mode = 'mul' + score_th : float + threshold of score + res_th : float + threshold of residue + bias : float + bias (for multiplicative separability) + verbose : bool + + Returns: + -------- + bool + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]+x[:,[2]]) + >>> x = torch.normal(0,1,size=(100,3)) + >>> print(test_separability(model, x, [[0],[1,2]], mode='mul')) # True + >>> print(test_separability(model, x, [[0],[1,2]], mode='add')) # False + """ + if mode == "add": hessian = batch_hessian(model, x) - elif mode == 'mul': + elif mode == "mul": compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F) - hessian = batch_hessian(compose(torch.log, torch.abs, lambda x: x+bias, model), x) + hessian = batch_hessian( + compose(torch.log, torch.abs, lambda x: x + bias, model), x + ) std = torch.std(x, dim=0) - hessian_normalized = hessian * std[None,:] * std[:,None] + hessian_normalized = hessian * std[None, :] * std[:, None] score_mat = torch.median(torch.abs(hessian_normalized), dim=0)[0] - + sep_bool = True - + # internal test n_groups = len(groups) for i in range(n_groups): - for j in range(i+1, n_groups): - sep_bool *= torch.max(score_mat[groups[i]][:,groups[j]]) < threshold - + for j in range(i + 1, n_groups): + sep_bool *= torch.max(score_mat[groups[i]][:, groups[j]]) < threshold + # external test group_id = [x for xs in groups for x in xs] nongroup_id = list(set(range(x.shape[1])) - set(group_id)) if len(nongroup_id) > 0 and len(group_id) > 0: - sep_bool *= torch.max(score_mat[group_id][:,nongroup_id]) < threshold + sep_bool *= torch.max(score_mat[group_id][:, nongroup_id]) < threshold return sep_bool + def test_general_separability(model, x, groups, threshold=1e-2): - ''' - test function separability - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - mode : str - mode = 'add' or mode = 'mul' - score_th : float - threshold of score - res_th : float - threshold of residue - bias : float - bias (for multiplicative separability) - verbose : bool - - Returns: - -------- - bool - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]**2+x[:,[2]]**2)**2 - >>> x = torch.normal(0,1,size=(100,3)) - >>> print(test_general_separability(model, x, [[1],[0,2]])) # False - >>> print(test_general_separability(model, x, [[0],[1,2]])) # True - ''' + """ + test function separability + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + mode : str + mode = 'add' or mode = 'mul' + score_th : float + threshold of score + res_th : float + threshold of residue + bias : float + bias (for multiplicative separability) + verbose : bool + + Returns: + -------- + bool + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: x[:,[0]] ** 2 * (x[:,[1]]**2+x[:,[2]]**2)**2 + >>> x = torch.normal(0,1,size=(100,3)) + >>> print(test_general_separability(model, x, [[1],[0,2]])) # False + >>> print(test_general_separability(model, x, [[0],[1,2]])) # True + """ grad = batch_jacobian(model, x) gensep_bool = True n_groups = len(groups) for i in range(n_groups): - for j in range(i+1,n_groups): + for j in range(i + 1, n_groups): group_A = groups[i] group_B = groups[j] for member_A in group_A: for member_B in group_B: + def func(x): grad = batch_jacobian(model, x, create_graph=True) - return grad[:,[member_B]]/grad[:,[member_A]] + return grad[:, [member_B]] / grad[:, [member_A]] + # test if func is multiplicative separable - gensep_bool *= test_separability(func, x, groups, mode='mul', threshold=threshold) + gensep_bool *= test_separability( + func, x, groups, mode="mul", threshold=threshold + ) return gensep_bool def get_molecule(model, x, sym_th=1e-3, verbose=True): - ''' - how variables are combined hierarchically - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - sym_th : float - threshold of symmetry - verbose : bool - - Returns: - -------- - list - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> get_molecule(model, x, verbose=False) - [[[0], [1], [2], [3], [4], [5], [6], [7]], - [[0, 1], [2, 3], [4, 5], [6, 7]], - [[0, 1, 2, 3], [4, 5, 6, 7]], - [[0, 1, 2, 3, 4, 5, 6, 7]]] - ''' + """ + how variables are combined hierarchically + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + sym_th : float + threshold of symmetry + verbose : bool + + Returns: + -------- + list + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 + >>> x = torch.normal(0,1,size=(100,8)) + >>> get_molecule(model, x, verbose=False) + [[[0], [1], [2], [3], [4], [5], [6], [7]], + [[0, 1], [2, 3], [4, 5], [6, 7]], + [[0, 1, 2, 3], [4, 5, 6, 7]], + [[0, 1, 2, 3, 4, 5, 6, 7]]] + """ n = x.shape[1] atoms = [[i] for i in range(n)] molecules = [] @@ -310,17 +331,14 @@ def get_molecule(model, x, sym_th=1e-3, verbose=True): already_full = False n_layer = 0 last_n_molecule = n - - while True: - + while True: pointer = 0 current_molecule = [] remove_atoms = [] n_atom = 0 while len(atoms) > 0: - # assemble molecule atom = atoms[pointer] if verbose: @@ -334,18 +352,25 @@ def get_molecule(model, x, sym_th=1e-3, verbose=True): n_atom += 1 else: # try assemble the atom to the molecule - if len(current_molecule+atom) == x.shape[1] and already_full == False and n_atom > 1 and n_layer > 0: + if ( + len(current_molecule + atom) == x.shape[1] + and already_full == False + and n_atom > 1 + and n_layer > 0 + ): full = True already_full = True else: full = False - if test_symmetry(model, x, current_molecule+atom, dependence_th=sym_th): + if test_symmetry( + model, x, current_molecule + atom, dependence_th=sym_th + ): current_molecule += atom remove_atoms.append(atom) n_atom += 1 pointer += 1 - + if pointer == len(atoms) or full: molecules.append(current_molecule) if full: @@ -357,16 +382,18 @@ def get_molecule(model, x, sym_th=1e-3, verbose=True): current_molecule = [] remove_atoms = [] pointer = 0 - + # if not making progress, terminate if len(molecules) == last_n_molecule: + def flatten(xss): return [x for xs in xss for x in xs] + moleculess.append([flatten(molecules)]) break else: moleculess.append(copy.deepcopy(molecules)) - + last_n_molecule = len(molecules) if len(molecules) == 1: @@ -374,70 +401,66 @@ def flatten(xss): atoms = molecules molecules = [] - + n_layer += 1 - - #print(n_layer, atoms) - - + + # print(n_layer, atoms) + # sort depth = len(moleculess) - 1 - for l in list(range(depth,0,-1)): - + for l in list(range(depth, 0, -1)): molecules_sorted = [] molecules_l = moleculess[l] - molecules_lm1 = moleculess[l-1] - + molecules_lm1 = moleculess[l - 1] for molecule_l in molecules_l: start = 0 - for i in range(1,len(molecule_l)+1): + for i in range(1, len(molecule_l) + 1): if molecule_l[start:i] in molecules_lm1: - molecules_sorted.append(molecule_l[start:i]) start = i - moleculess[l-1] = molecules_sorted + moleculess[l - 1] = molecules_sorted return moleculess def get_tree_node(model, x, moleculess, sep_th=1e-2, skip_test=True): - ''' - get tree nodes - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - sep_th : float - threshold of separability - skip_test : bool - if True, don't test the property of each module (to save time) - - Returns: - -------- - arities : list of numbers - properties : list of strings - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> moleculess = get_molecule(model, x, verbose=False) - >>> get_tree_node(model, x, moleculess, skip_test=False) - ''' + """ + get tree nodes + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + sep_th : float + threshold of separability + skip_test : bool + if True, don't test the property of each module (to save time) + + Returns: + -------- + arities : list of numbers + properties : list of strings + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 + >>> x = torch.normal(0,1,size=(100,8)) + >>> moleculess = get_molecule(model, x, verbose=False) + >>> get_tree_node(model, x, moleculess, skip_test=False) + """ arities = [] properties = [] - + depth = len(moleculess) - 1 for l in range(depth): molecules_l = copy.deepcopy(moleculess[l]) - molecules_lp1 = copy.deepcopy(moleculess[l+1]) + molecules_lp1 = copy.deepcopy(moleculess[l + 1]) arity_l = [] property_l = [] @@ -445,7 +468,7 @@ def get_tree_node(model, x, moleculess, sep_th=1e-2, skip_test=True): start = 0 arity = 0 groups = [] - for i in range(1,len(molecule)+1): + for i in range(1, len(molecule) + 1): if molecule[start:i] in molecules_l: groups.append(molecule[start:i]) start = i @@ -453,73 +476,88 @@ def get_tree_node(model, x, moleculess, sep_th=1e-2, skip_test=True): arity_l.append(arity) if arity == 1: - property = 'Id' + property = "Id" else: - property = '' + property = "" # test property if skip_test: gensep_bool = False else: - gensep_bool = test_general_separability(model, x, groups, threshold=sep_th) - + gensep_bool = test_general_separability( + model, x, groups, threshold=sep_th + ) + if gensep_bool: - property = 'GS' + property = "GS" if l == depth - 1: if skip_test: add_bool = False mul_bool = False else: - add_bool = test_separability(model, x, groups, mode='add', threshold=sep_th) - mul_bool = test_separability(model, x, groups, mode='mul', threshold=sep_th) + add_bool = test_separability( + model, x, groups, mode="add", threshold=sep_th + ) + mul_bool = test_separability( + model, x, groups, mode="mul", threshold=sep_th + ) if add_bool: - property = 'Add' + property = "Add" if mul_bool: - property = 'Mul' - + property = "Mul" property_l.append(property) - arities.append(arity_l) properties.append(property_l) - + return arities, properties -def plot_tree(model, x, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, skip_sep_test=False, verbose=False): - ''' - get tree graph - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - in_var : list of symbols - input variables - style : str - 'tree' or 'box' - sym_th : float - threshold of symmetry - sep_th : float - threshold of separability - skip_sep_test : bool - if True, don't test the property of each module (to save time) - verbose : bool - - Returns: - -------- - a tree graph - - Example - ------- - >>> from kan.hypothesis import * - >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 - >>> x = torch.normal(0,1,size=(100,8)) - >>> plot_tree(model, x) - ''' +def plot_tree( + model, + x, + in_var=None, + style="tree", + sym_th=1e-3, + sep_th=1e-1, + skip_sep_test=False, + verbose=False, +): + """ + get tree graph + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + in_var : list of symbols + input variables + style : str + 'tree' or 'box' + sym_th : float + threshold of symmetry + sep_th : float + threshold of separability + skip_sep_test : bool + if True, don't test the property of each module (to save time) + verbose : bool + + Returns: + -------- + a tree graph + + Example + ------- + >>> from kan.hypothesis import * + >>> model = lambda x: ((x[:,[0]] ** 2 + x[:,[1]] ** 2) ** 2 + (x[:,[2]] ** 2 + x[:,[3]] ** 2) ** 2) ** 2 + ((x[:,[4]] ** 2 + x[:,[5]] ** 2) ** 2 + (x[:,[6]] ** 2 + x[:,[7]] ** 2) ** 2) ** 2 + >>> x = torch.normal(0,1,size=(100,8)) + >>> plot_tree(model, x) + """ moleculess = get_molecule(model, x, sym_th=sym_th, verbose=verbose) - arities, properties = get_tree_node(model, x, moleculess, sep_th=sep_th, skip_test=skip_sep_test) + arities, properties = get_tree_node( + model, x, moleculess, sep_th=sep_th, skip_test=skip_sep_test + ) n = x.shape[1] var = None @@ -534,28 +572,42 @@ def plot_tree(model, x, in_var=None, style='tree', sym_th=1e-3, sep_th=1e-1, ski in_vars = var else: in_vars = [sympy.symbols(var_) for var_ in var] - def flatten(xss): return [x for xs in xss for x in xs] def myrectangle(center_x, center_y, width_x, width_y): - plt.plot([center_x - width_x/2, center_x + width_x/2], [center_y + width_y/2, center_y + width_y/2], color='k') # up - plt.plot([center_x - width_x/2, center_x + width_x/2], [center_y - width_y/2, center_y - width_y/2], color='k') # down - plt.plot([center_x - width_x/2, center_x - width_x/2], [center_y - width_y/2, center_y + width_y/2], color='k') # left - plt.plot([center_x + width_x/2, center_x + width_x/2], [center_y - width_y/2, center_y + width_y/2], color='k') # left + plt.plot( + [center_x - width_x / 2, center_x + width_x / 2], + [center_y + width_y / 2, center_y + width_y / 2], + color="k", + ) # up + plt.plot( + [center_x - width_x / 2, center_x + width_x / 2], + [center_y - width_y / 2, center_y - width_y / 2], + color="k", + ) # down + plt.plot( + [center_x - width_x / 2, center_x - width_x / 2], + [center_y - width_y / 2, center_y + width_y / 2], + color="k", + ) # left + plt.plot( + [center_x + width_x / 2, center_x + width_x / 2], + [center_y - width_y / 2, center_y + width_y / 2], + color="k", + ) # left depth = len(moleculess) - delta = 1/n + delta = 1 / n a = 0.3 b = 0.15 y0 = 0.5 - # draw rectangles - for l in range(depth-1): - molecules = moleculess[l+1] + for l in range(depth - 1): + molecules = moleculess[l + 1] n_molecule = len(molecules) centers = [] @@ -564,113 +616,145 @@ def myrectangle(center_x, center_y, width_x, width_y): for i in range(n_molecule): start_id = len(flatten(molecules[:i])) - end_id = len(flatten(molecules[:i+1])) + end_id = len(flatten(molecules[: i + 1])) - center_x = (start_id + (end_id - 1 - start_id)/2) * delta + delta/2 - center_y = (l+1/2)*y0 - width_x = (end_id - start_id - 1 + 2*a)*delta - width_y = 2*b + center_x = (start_id + (end_id - 1 - start_id) / 2) * delta + delta / 2 + center_y = (l + 1 / 2) * y0 + width_x = (end_id - start_id - 1 + 2 * a) * delta + width_y = 2 * b # add text (numbers) on rectangles - if style == 'box': + if style == "box": myrectangle(center_x, center_y, width_x, width_y) - plt.text(center_x, center_y, properties[l][i], fontsize=15, horizontalalignment='center', - verticalalignment='center') - elif style == 'tree': + plt.text( + center_x, + center_y, + properties[l][i], + fontsize=15, + horizontalalignment="center", + verticalalignment="center", + ) + elif style == "tree": # if 'GS', no rectangle, n=arity tilted lines # if 'Id', no rectangle, n=arity vertical lines # if 'Add' or 'Mul'. rectangle, "+" or "x" # if '', rectangle property = properties[l][i] - if property == 'GS' or property == 'Add' or property == 'Mul': - color = 'blue' + if property == "GS" or property == "Add" or property == "Mul": + color = "blue" arity = arities[l][i] for j in range(arity): - if l == 0: # x = (start_id + j) * delta + delta/2, center_x # y = center_y - b, center_y + b - plt.plot([(start_id + j) * delta + delta/2, center_x], [center_y - b, center_y + b], color=color) + plt.plot( + [(start_id + j) * delta + delta / 2, center_x], + [center_y - b, center_y + b], + color=color, + ) else: # x = last_centers[acc_arity:acc_arity+arity], center_x # y = center_y - b, center_y + b - plt.plot([last_centers[acc_arity+j], center_x], [center_y - b, center_y + b], color=color) + plt.plot( + [last_centers[acc_arity + j], center_x], + [center_y - b, center_y + b], + color=color, + ) acc_arity += arity - if property == 'Add' or property == 'Mul': - if property == 'Add': - symbol = '+' + if property == "Add" or property == "Mul": + if property == "Add": + symbol = "+" else: - symbol = '*' - - plt.text(center_x, center_y + b, symbol, horizontalalignment='center', - verticalalignment='center', color='red', fontsize=40) - if property == 'Id': - plt.plot([center_x, center_x], [center_y-width_y/2, center_y+width_y/2], color='black') - - if property == '': + symbol = "*" + + plt.text( + center_x, + center_y + b, + symbol, + horizontalalignment="center", + verticalalignment="center", + color="red", + fontsize=40, + ) + if property == "Id": + plt.plot( + [center_x, center_x], + [center_y - width_y / 2, center_y + width_y / 2], + color="black", + ) + + if property == "": myrectangle(center_x, center_y, width_x, width_y) - - # connections to the next layer - plt.plot([center_x, center_x], [center_y+width_y/2, center_y+y0-width_y/2], color='k') + plt.plot( + [center_x, center_x], + [center_y + width_y / 2, center_y + y0 - width_y / 2], + color="k", + ) centers.append(center_x) last_centers = copy.deepcopy(centers) # connections from input variables to the first layer for i in range(n): - x_ = (i + 1/2) * delta + x_ = (i + 1 / 2) * delta # connections to the next layer - plt.plot([x_, x_], [0, y0/2-width_y/2], color='k') - plt.text(x_, -0.05*(depth-1), f'${latex(in_vars[moleculess[0][i][0]])}$', fontsize=20, horizontalalignment='center') - plt.xlim(0,1) - #plt.ylim(0,1); - plt.axis('off'); + plt.plot([x_, x_], [0, y0 / 2 - width_y / 2], color="k") + plt.text( + x_, + -0.05 * (depth - 1), + f"${latex(in_vars[moleculess[0][i][0]])}$", + fontsize=20, + horizontalalignment="center", + ) + plt.xlim(0, 1) + # plt.ylim(0,1); + plt.axis("off") plt.show() def test_symmetry_var(model, x, input_vars, symmetry_var): - ''' - test symmetry - - Args: - ----- - model : MultKAN, MLP or python function - x : 2D torch.float - inputs - input_vars : list of sympy symbols - symmetry_var : sympy expression - - Returns: - -------- - cosine similarity - - Example - ------- - >>> from kan.hypothesis import * - >>> from sympy import * - >>> model = lambda x: x[:,[0]] * (x[:,[1]] + x[:,[2]]) - >>> x = torch.normal(0,1,size=(100,8)) - >>> input_vars = a, b, c = symbols('a b c') - >>> symmetry_var = b + c - >>> test_symmetry_var(model, x, input_vars, symmetry_var); - >>> symmetry_var = b * c - >>> test_symmetry_var(model, x, input_vars, symmetry_var); - ''' + """ + test symmetry + + Args: + ----- + model : MultKAN, MLP or python function + x : 2D torch.float + inputs + input_vars : list of sympy symbols + symmetry_var : sympy expression + + Returns: + -------- + cosine similarity + + Example + ------- + >>> from kan.hypothesis import * + >>> from sympy import * + >>> model = lambda x: x[:,[0]] * (x[:,[1]] + x[:,[2]]) + >>> x = torch.normal(0,1,size=(100,8)) + >>> input_vars = a, b, c = symbols('a b c') + >>> symmetry_var = b + c + >>> test_symmetry_var(model, x, input_vars, symmetry_var); + >>> symmetry_var = b * c + >>> test_symmetry_var(model, x, input_vars, symmetry_var); + """ orig_vars = input_vars sym_var = symmetry_var - + # gradients wrt to input (model) input_grad = batch_jacobian(model, x) # gradients wrt to input (symmetry var) - func = lambdify(orig_vars, sym_var,'numpy') # returns a numpy-ready function + func = lambdify(orig_vars, sym_var, "numpy") # returns a numpy-ready function - func2 = lambda x: func(*[x[:,[i]] for i in range(len(orig_vars))]) + func2 = lambda x: func(*[x[:, [i]] for i in range(len(orig_vars))]) sym_grad = batch_jacobian(func2, x) - + # get id idx = [] sym_symbols = list(sym_var.free_symbols) @@ -678,18 +762,21 @@ def test_symmetry_var(model, x, input_vars, symmetry_var): for j in range(len(orig_vars)): if sym_symbol == orig_vars[j]: idx.append(j) - - input_grad_part = input_grad[:,idx] - sym_grad_part = sym_grad[:,idx] - - cossim = torch.abs(torch.sum(input_grad_part * sym_grad_part, dim=1)/(torch.norm(input_grad_part, dim=1)*torch.norm(sym_grad_part, dim=1))) - - ratio = torch.sum(cossim > 0.9)/len(cossim) - - print(f'{100*ratio}% data have more than 0.9 cosine similarity') + + input_grad_part = input_grad[:, idx] + sym_grad_part = sym_grad[:, idx] + + cossim = torch.abs( + torch.sum(input_grad_part * sym_grad_part, dim=1) + / (torch.norm(input_grad_part, dim=1) * torch.norm(sym_grad_part, dim=1)) + ) + + ratio = torch.sum(cossim > 0.9) / len(cossim) + + print(f"{100 * ratio}% data have more than 0.9 cosine similarity") if ratio > 0.9: - print('suggesting symmetry') + print("suggesting symmetry") else: - print('not suggesting symmetry') - - return cossim \ No newline at end of file + print("not suggesting symmetry") + + return cossim diff --git a/kan/spline.py b/kan/spline.py index 6953bf081..06e080df8 100644 --- a/kan/spline.py +++ b/kan/spline.py @@ -1,10 +1,10 @@ import torch -def B_batch(x, grid, k=0, extend=True, device='cpu'): - ''' +def B_batch(x, grid, k=0, extend=True, device="cpu"): + """ evaludate x on B-spline bases - + Args: ----- x : 2D torch.tensor @@ -17,41 +17,43 @@ def B_batch(x, grid, k=0, extend=True, device='cpu'): If True, k points are extended on both ends. If False, no extension (zero boundary condition). Default: True device : str devicde - + Returns: -------- spline values : 3D torch.tensor shape (batch, in_dim, G+k). G: the number of grid intervals, k: spline order. - + Example ------- >>> from kan.spline import B_batch >>> x = torch.rand(100,2) >>> grid = torch.linspace(-1,1,steps=11)[None, :].expand(2, 11) >>> B_batch(x, grid, k=3).shape - ''' - + """ + x = x.unsqueeze(dim=2) grid = grid.unsqueeze(dim=0) - + if k == 0: value = (x >= grid[:, :, :-1]) * (x < grid[:, :, 1:]) else: - B_km1 = B_batch(x[:,:,0], grid=grid[0], k=k - 1) - - value = (x - grid[:, :, :-(k + 1)]) / (grid[:, :, k:-1] - grid[:, :, :-(k + 1)]) * B_km1[:, :, :-1] + ( - grid[:, :, k + 1:] - x) / (grid[:, :, k + 1:] - grid[:, :, 1:(-k)]) * B_km1[:, :, 1:] - + B_km1 = B_batch(x[:, :, 0], grid=grid[0], k=k - 1) + + value = (x - grid[:, :, : -(k + 1)]) / ( + grid[:, :, k:-1] - grid[:, :, : -(k + 1)] + ) * B_km1[:, :, :-1] + (grid[:, :, k + 1 :] - x) / ( + grid[:, :, k + 1 :] - grid[:, :, 1:(-k)] + ) * B_km1[:, :, 1:] + # in case grid is degenerate value = torch.nan_to_num(value) return value - def coef2curve(x_eval, grid, coef, k, device="cpu"): - ''' + """ converting B-spline coefficients to B-spline curves. Evaluate x on B-spline curves (summing up B_batch results over B-spline basis). - + Args: ----- x_eval : 2D torch.tensor @@ -64,24 +66,24 @@ def coef2curve(x_eval, grid, coef, k, device="cpu"): the piecewise polynomial order of splines. device : str devicde - + Returns: -------- y_eval : 3D torch.tensor shape (batch, in_dim, out_dim) - - ''' - + + """ + b_splines = B_batch(x_eval, grid, k=k) - y_eval = torch.einsum('ijk,jlk->ijl', b_splines, coef.to(b_splines.device)) - + y_eval = torch.einsum("ijk,jlk->ijl", b_splines, coef.to(b_splines.device)) + return y_eval def curve2coef(x_eval, y_eval, grid, k): - ''' + """ converting B-spline curves to B-spline coefficients using least squares. - + Args: ----- x_eval : 2D torch.tensor @@ -94,51 +96,51 @@ def curve2coef(x_eval, y_eval, grid, k): spline order lamb : float regularized least square lambda - + Returns: -------- coef : 3D torch.tensor shape (in_dim, out_dim, G+k) - ''' - #print('haha', x_eval.shape, y_eval.shape, grid.shape) + """ + # print('haha', x_eval.shape, y_eval.shape, grid.shape) batch = x_eval.shape[0] in_dim = x_eval.shape[1] out_dim = y_eval.shape[2] n_coef = grid.shape[1] - k - 1 mat = B_batch(x_eval, grid, k) - mat = mat.permute(1,0,2)[:,None,:,:].expand(in_dim, out_dim, batch, n_coef) - #print('mat', mat.shape) - y_eval = y_eval.permute(1,2,0).unsqueeze(dim=3) - #print('y_eval', y_eval.shape) + mat = mat.permute(1, 0, 2)[:, None, :, :].expand(in_dim, out_dim, batch, n_coef) + # print('mat', mat.shape) + y_eval = y_eval.permute(1, 2, 0).unsqueeze(dim=3) + # print('y_eval', y_eval.shape) device = mat.device - - #coef = torch.linalg.lstsq(mat, y_eval, driver='gelsy' if device == 'cpu' else 'gels').solution[:,:,:,0] + + # coef = torch.linalg.lstsq(mat, y_eval, driver='gelsy' if device == 'cpu' else 'gels').solution[:,:,:,0] try: - coef = torch.linalg.lstsq(mat, y_eval).solution[:,:,:,0] + coef = torch.linalg.lstsq(mat, y_eval).solution[:, :, :, 0] except: - print('lstsq failed') - + print("lstsq failed") + # manual psuedo-inverse - '''lamb=1e-8 + """lamb=1e-8 XtX = torch.einsum('ijmn,ijnp->ijmp', mat.permute(0,1,3,2), mat) Xty = torch.einsum('ijmn,ijnp->ijmp', mat.permute(0,1,3,2), y_eval) n1, n2, n = XtX.shape[0], XtX.shape[1], XtX.shape[2] identity = torch.eye(n,n)[None, None, :, :].expand(n1, n2, n, n).to(device) A = XtX + lamb * identity B = Xty - coef = (A.pinverse() @ B)[:,:,:,0]''' - + coef = (A.pinverse() @ B)[:,:,:,0]""" + return coef def extend_grid(grid, k_extend=0): - ''' + """ extend grid - ''' + """ h = (grid[:, [-1]] - grid[:, [0]]) / (grid.shape[1] - 1) for i in range(k_extend): grid = torch.cat([grid[:, [0]] - h, grid], dim=1) grid = torch.cat([grid, grid[:, [-1]] + h], dim=1) - return grid \ No newline at end of file + return grid diff --git a/kan/utils.py b/kan/utils.py index abb4d558b..b9297cd5a 100644 --- a/kan/utils.py +++ b/kan/utils.py @@ -2,7 +2,6 @@ import torch from sklearn.linear_model import LinearRegression import sympy -import yaml from sympy.utilities.lambdify import lambdify import re @@ -10,68 +9,168 @@ # name: (torch implementation, sympy implementation) # singularity protection functions -f_inv = lambda x, y_th: ((x_th := 1/y_th), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x) * (torch.abs(x) >= x_th)) -f_inv2 = lambda x, y_th: ((x_th := 1/y_th**(1/2)), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**2) * (torch.abs(x) >= x_th)) -f_inv3 = lambda x, y_th: ((x_th := 1/y_th**(1/3)), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**3) * (torch.abs(x) >= x_th)) -f_inv4 = lambda x, y_th: ((x_th := 1/y_th**(1/4)), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**4) * (torch.abs(x) >= x_th)) -f_inv5 = lambda x, y_th: ((x_th := 1/y_th**(1/5)), y_th/x_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(1/x**5) * (torch.abs(x) >= x_th)) -f_sqrt = lambda x, y_th: ((x_th := 1/y_th**2), x_th/y_th*x * (torch.abs(x) < x_th) + torch.nan_to_num(torch.sqrt(torch.abs(x))*torch.sign(x)) * (torch.abs(x) >= x_th)) -f_power1d5 = lambda x, y_th: torch.abs(x)**1.5 -f_invsqrt = lambda x, y_th: ((x_th := 1/y_th**2), y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1/torch.sqrt(torch.abs(x))) * (torch.abs(x) >= x_th)) -f_log = lambda x, y_th: ((x_th := torch.e**(-y_th)), - y_th * (torch.abs(x) < x_th) + torch.nan_to_num(torch.log(torch.abs(x))) * (torch.abs(x) >= x_th)) -f_tan = lambda x, y_th: ((clip := x % torch.pi), (delta := torch.pi/2-torch.arctan(y_th)), - y_th/delta * (clip - torch.pi/2) * (torch.abs(clip - torch.pi/2) < delta) + torch.nan_to_num(torch.tan(clip)) * (torch.abs(clip - torch.pi/2) >= delta)) -f_arctanh = lambda x, y_th: ((delta := 1-torch.tanh(y_th) + 1e-4), y_th * torch.sign(x) * (torch.abs(x) > 1 - delta) + torch.nan_to_num(torch.arctanh(x)) * (torch.abs(x) <= 1 - delta)) -f_arcsin = lambda x, y_th: ((), torch.pi/2 * torch.sign(x) * (torch.abs(x) > 1) + torch.nan_to_num(torch.arcsin(x)) * (torch.abs(x) <= 1)) -f_arccos = lambda x, y_th: ((), torch.pi/2 * (1-torch.sign(x)) * (torch.abs(x) > 1) + torch.nan_to_num(torch.arccos(x)) * (torch.abs(x) <= 1)) -f_exp = lambda x, y_th: ((x_th := torch.log(y_th)), y_th * (x > x_th) + torch.exp(x) * (x <= x_th)) - -SYMBOLIC_LIB = {'x': (lambda x: x, lambda x: x, 1, lambda x, y_th: ((), x)), - 'x^2': (lambda x: x**2, lambda x: x**2, 2, lambda x, y_th: ((), x**2)), - 'x^3': (lambda x: x**3, lambda x: x**3, 3, lambda x, y_th: ((), x**3)), - 'x^4': (lambda x: x**4, lambda x: x**4, 3, lambda x, y_th: ((), x**4)), - 'x^5': (lambda x: x**5, lambda x: x**5, 3, lambda x, y_th: ((), x**5)), - '1/x': (lambda x: 1/x, lambda x: 1/x, 2, f_inv), - '1/x^2': (lambda x: 1/x**2, lambda x: 1/x**2, 2, f_inv2), - '1/x^3': (lambda x: 1/x**3, lambda x: 1/x**3, 3, f_inv3), - '1/x^4': (lambda x: 1/x**4, lambda x: 1/x**4, 4, f_inv4), - '1/x^5': (lambda x: 1/x**5, lambda x: 1/x**5, 5, f_inv5), - 'sqrt': (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), - 'x^0.5': (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), - 'x^1.5': (lambda x: torch.sqrt(x)**3, lambda x: sympy.sqrt(x)**3, 4, f_power1d5), - '1/sqrt(x)': (lambda x: 1/torch.sqrt(x), lambda x: 1/sympy.sqrt(x), 2, f_invsqrt), - '1/x^0.5': (lambda x: 1/torch.sqrt(x), lambda x: 1/sympy.sqrt(x), 2, f_invsqrt), - 'exp': (lambda x: torch.exp(x), lambda x: sympy.exp(x), 2, f_exp), - 'log': (lambda x: torch.log(x), lambda x: sympy.log(x), 2, f_log), - 'abs': (lambda x: torch.abs(x), lambda x: sympy.Abs(x), 3, lambda x, y_th: ((), torch.abs(x))), - 'sin': (lambda x: torch.sin(x), lambda x: sympy.sin(x), 2, lambda x, y_th: ((), torch.sin(x))), - 'cos': (lambda x: torch.cos(x), lambda x: sympy.cos(x), 2, lambda x, y_th: ((), torch.cos(x))), - 'tan': (lambda x: torch.tan(x), lambda x: sympy.tan(x), 3, f_tan), - 'tanh': (lambda x: torch.tanh(x), lambda x: sympy.tanh(x), 3, lambda x, y_th: ((), torch.tanh(x))), - 'sgn': (lambda x: torch.sign(x), lambda x: sympy.sign(x), 3, lambda x, y_th: ((), torch.sign(x))), - 'arcsin': (lambda x: torch.arcsin(x), lambda x: sympy.asin(x), 4, f_arcsin), - 'arccos': (lambda x: torch.arccos(x), lambda x: sympy.acos(x), 4, f_arccos), - 'arctan': (lambda x: torch.arctan(x), lambda x: sympy.atan(x), 4, lambda x, y_th: ((), torch.arctan(x))), - 'arctanh': (lambda x: torch.arctanh(x), lambda x: sympy.atanh(x), 4, f_arctanh), - '0': (lambda x: x*0, lambda x: x*0, 0, lambda x, y_th: ((), x*0)), - 'gaussian': (lambda x: torch.exp(-x**2), lambda x: sympy.exp(-x**2), 3, lambda x, y_th: ((), torch.exp(-x**2))), - #'cosh': (lambda x: torch.cosh(x), lambda x: sympy.cosh(x), 5), - #'sigmoid': (lambda x: torch.sigmoid(x), sympy.Function('sigmoid'), 4), - #'relu': (lambda x: torch.relu(x), relu), +f_inv = lambda x, y_th: ( + (x_th := 1 / y_th), + y_th / x_th * x * (torch.abs(x) < x_th) + + torch.nan_to_num(1 / x) * (torch.abs(x) >= x_th), +) +f_inv2 = lambda x, y_th: ( + (x_th := 1 / y_th ** (1 / 2)), + y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1 / x**2) * (torch.abs(x) >= x_th), +) +f_inv3 = lambda x, y_th: ( + (x_th := 1 / y_th ** (1 / 3)), + y_th / x_th * x * (torch.abs(x) < x_th) + + torch.nan_to_num(1 / x**3) * (torch.abs(x) >= x_th), +) +f_inv4 = lambda x, y_th: ( + (x_th := 1 / y_th ** (1 / 4)), + y_th * (torch.abs(x) < x_th) + torch.nan_to_num(1 / x**4) * (torch.abs(x) >= x_th), +) +f_inv5 = lambda x, y_th: ( + (x_th := 1 / y_th ** (1 / 5)), + y_th / x_th * x * (torch.abs(x) < x_th) + + torch.nan_to_num(1 / x**5) * (torch.abs(x) >= x_th), +) +f_sqrt = lambda x, y_th: ( + (x_th := 1 / y_th**2), + x_th / y_th * x * (torch.abs(x) < x_th) + + torch.nan_to_num(torch.sqrt(torch.abs(x)) * torch.sign(x)) + * (torch.abs(x) >= x_th), +) +f_power1d5 = lambda x, y_th: torch.abs(x) ** 1.5 +f_invsqrt = lambda x, y_th: ( + (x_th := 1 / y_th**2), + y_th * (torch.abs(x) < x_th) + + torch.nan_to_num(1 / torch.sqrt(torch.abs(x))) * (torch.abs(x) >= x_th), +) +f_log = lambda x, y_th: ( + (x_th := torch.e ** (-y_th)), + -y_th * (torch.abs(x) < x_th) + + torch.nan_to_num(torch.log(torch.abs(x))) * (torch.abs(x) >= x_th), +) +f_tan = lambda x, y_th: ( + (clip := x % torch.pi), + (delta := torch.pi / 2 - torch.arctan(y_th)), + -y_th / delta * (clip - torch.pi / 2) * (torch.abs(clip - torch.pi / 2) < delta) + + torch.nan_to_num(torch.tan(clip)) * (torch.abs(clip - torch.pi / 2) >= delta), +) +f_arctanh = lambda x, y_th: ( + (delta := 1 - torch.tanh(y_th) + 1e-4), + y_th * torch.sign(x) * (torch.abs(x) > 1 - delta) + + torch.nan_to_num(torch.arctanh(x)) * (torch.abs(x) <= 1 - delta), +) +f_arcsin = lambda x, y_th: ( + (), + torch.pi / 2 * torch.sign(x) * (torch.abs(x) > 1) + + torch.nan_to_num(torch.arcsin(x)) * (torch.abs(x) <= 1), +) +f_arccos = lambda x, y_th: ( + (), + torch.pi / 2 * (1 - torch.sign(x)) * (torch.abs(x) > 1) + + torch.nan_to_num(torch.arccos(x)) * (torch.abs(x) <= 1), +) +f_exp = lambda x, y_th: ( + (x_th := torch.log(y_th)), + y_th * (x > x_th) + torch.exp(x) * (x <= x_th), +) + +SYMBOLIC_LIB = { + "x": (lambda x: x, lambda x: x, 1, lambda x, y_th: ((), x)), + "x^2": (lambda x: x**2, lambda x: x**2, 2, lambda x, y_th: ((), x**2)), + "x^3": (lambda x: x**3, lambda x: x**3, 3, lambda x, y_th: ((), x**3)), + "x^4": (lambda x: x**4, lambda x: x**4, 3, lambda x, y_th: ((), x**4)), + "x^5": (lambda x: x**5, lambda x: x**5, 3, lambda x, y_th: ((), x**5)), + "1/x": (lambda x: 1 / x, lambda x: 1 / x, 2, f_inv), + "1/x^2": (lambda x: 1 / x**2, lambda x: 1 / x**2, 2, f_inv2), + "1/x^3": (lambda x: 1 / x**3, lambda x: 1 / x**3, 3, f_inv3), + "1/x^4": (lambda x: 1 / x**4, lambda x: 1 / x**4, 4, f_inv4), + "1/x^5": (lambda x: 1 / x**5, lambda x: 1 / x**5, 5, f_inv5), + "sqrt": (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), + "x^0.5": (lambda x: torch.sqrt(x), lambda x: sympy.sqrt(x), 2, f_sqrt), + "x^1.5": ( + lambda x: torch.sqrt(x) ** 3, + lambda x: sympy.sqrt(x) ** 3, + 4, + f_power1d5, + ), + "1/sqrt(x)": ( + lambda x: 1 / torch.sqrt(x), + lambda x: 1 / sympy.sqrt(x), + 2, + f_invsqrt, + ), + "1/x^0.5": (lambda x: 1 / torch.sqrt(x), lambda x: 1 / sympy.sqrt(x), 2, f_invsqrt), + "exp": (lambda x: torch.exp(x), lambda x: sympy.exp(x), 2, f_exp), + "log": (lambda x: torch.log(x), lambda x: sympy.log(x), 2, f_log), + "abs": ( + lambda x: torch.abs(x), + lambda x: sympy.Abs(x), + 3, + lambda x, y_th: ((), torch.abs(x)), + ), + "sin": ( + lambda x: torch.sin(x), + lambda x: sympy.sin(x), + 2, + lambda x, y_th: ((), torch.sin(x)), + ), + "cos": ( + lambda x: torch.cos(x), + lambda x: sympy.cos(x), + 2, + lambda x, y_th: ((), torch.cos(x)), + ), + "tan": (lambda x: torch.tan(x), lambda x: sympy.tan(x), 3, f_tan), + "tanh": ( + lambda x: torch.tanh(x), + lambda x: sympy.tanh(x), + 3, + lambda x, y_th: ((), torch.tanh(x)), + ), + "sgn": ( + lambda x: torch.sign(x), + lambda x: sympy.sign(x), + 3, + lambda x, y_th: ((), torch.sign(x)), + ), + "arcsin": (lambda x: torch.arcsin(x), lambda x: sympy.asin(x), 4, f_arcsin), + "arccos": (lambda x: torch.arccos(x), lambda x: sympy.acos(x), 4, f_arccos), + "arctan": ( + lambda x: torch.arctan(x), + lambda x: sympy.atan(x), + 4, + lambda x, y_th: ((), torch.arctan(x)), + ), + "arctanh": (lambda x: torch.arctanh(x), lambda x: sympy.atanh(x), 4, f_arctanh), + "0": (lambda x: x * 0, lambda x: x * 0, 0, lambda x, y_th: ((), x * 0)), + "gaussian": ( + lambda x: torch.exp(-(x**2)), + lambda x: sympy.exp(-(x**2)), + 3, + lambda x, y_th: ((), torch.exp(-(x**2))), + ), + #'cosh': (lambda x: torch.cosh(x), lambda x: sympy.cosh(x), 5), + #'sigmoid': (lambda x: torch.sigmoid(x), sympy.Function('sigmoid'), 4), + #'relu': (lambda x: torch.relu(x), relu), } -def create_dataset(f, - n_var=2, - f_mode = 'col', - ranges = [-1,1], - train_num=1000, - test_num=1000, - normalize_input=False, - normalize_label=False, - device='cpu', - seed=0): - ''' + +def create_dataset( + f, + n_var=2, + f_mode="col", + ranges=[-1, 1], + train_num=1000, + test_num=1000, + normalize_input=False, + normalize_label=False, + device="cpu", + seed=0, +): + """ create dataset - + Args: ----- f : function @@ -90,59 +189,70 @@ def create_dataset(f, device. Default: 'cpu'. seed : int random seed. Default: 0. - + Returns: -------- dataset : dic Train/test inputs/labels are dataset['train_input'], dataset['train_label'], dataset['test_input'], dataset['test_label'] - + Example ------- >>> f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2) >>> dataset = create_dataset(f, n_var=2, train_num=100) >>> dataset['train_input'].shape torch.Size([100, 2]) - ''' + """ np.random.seed(seed) torch.manual_seed(seed) if len(np.array(ranges).shape) == 1: - ranges = np.array(ranges * n_var).reshape(n_var,2) + ranges = np.array(ranges * n_var).reshape(n_var, 2) else: ranges = np.array(ranges) - - + train_input = torch.zeros(train_num, n_var) test_input = torch.zeros(test_num, n_var) for i in range(n_var): - train_input[:,i] = torch.rand(train_num,)*(ranges[i,1]-ranges[i,0])+ranges[i,0] - test_input[:,i] = torch.rand(test_num,)*(ranges[i,1]-ranges[i,0])+ranges[i,0] - - if f_mode == 'col': + train_input[:, i] = ( + torch.rand( + train_num, + ) + * (ranges[i, 1] - ranges[i, 0]) + + ranges[i, 0] + ) + test_input[:, i] = ( + torch.rand( + test_num, + ) + * (ranges[i, 1] - ranges[i, 0]) + + ranges[i, 0] + ) + + if f_mode == "col": train_label = f(train_input) test_label = f(test_input) - elif f_mode == 'row': + elif f_mode == "row": train_label = f(train_input.T) test_label = f(test_input.T) else: - print(f'f_mode {f_mode} not recognized') - + print(f"f_mode {f_mode} not recognized") + # if has only 1 dimension if len(train_label.shape) == 1: train_label = train_label.unsqueeze(dim=1) test_label = test_label.unsqueeze(dim=1) - + def normalize(data, mean, std): - return (data-mean)/std - + return (data - mean) / std + if normalize_input == True: mean_input = torch.mean(train_input, dim=0, keepdim=True) std_input = torch.std(train_input, dim=0, keepdim=True) train_input = normalize(train_input, mean_input, std_input) test_input = normalize(test_input, mean_input, std_input) - + if normalize_label == True: mean_label = torch.mean(train_label, dim=0, keepdim=True) std_label = torch.std(train_label, dim=0, keepdim=True) @@ -150,25 +260,34 @@ def normalize(data, mean, std): test_label = normalize(test_label, mean_label, std_label) dataset = {} - dataset['train_input'] = train_input.to(device) - dataset['test_input'] = test_input.to(device) + dataset["train_input"] = train_input.to(device) + dataset["test_input"] = test_input.to(device) - dataset['train_label'] = train_label.to(device) - dataset['test_label'] = test_label.to(device) + dataset["train_label"] = train_label.to(device) + dataset["test_label"] = test_label.to(device) return dataset - -def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, iteration=3, verbose=True, device='cpu'): - ''' +def fit_params( + x, + y, + fun, + a_range=(-10, 10), + b_range=(-10, 10), + grid_number=101, + iteration=3, + verbose=True, + device="cpu", +): + """ fit a, b, c, d such that - + .. math:: |y-(cf(ax+b)+d)|^2 - + is minimized. Both x and y are 1D array. Sweep a and b, find the best fitted model. - + Args: ----- x : 1D array @@ -189,7 +308,7 @@ def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, i print extra information if True device : str device - + Returns: -------- a_best : float @@ -202,7 +321,7 @@ def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, i best fitted d r2_best : float best r2 (coefficient of determination) - + Example ------- >>> num = 100 @@ -212,29 +331,34 @@ def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, i >>> fit_params(x, y, torch.sin) r2 is 0.9999727010726929 (tensor([2.9982, 1.9996, 5.0053, 0.7011]), tensor(1.0000)) - ''' + """ # fit a, b, c, d such that y=c*fun(a*x+b)+d; both x and y are 1D array. - # sweep a and b, choose the best fitted model + # sweep a and b, choose the best fitted model for _ in range(iteration): a_ = torch.linspace(a_range[0], a_range[1], steps=grid_number, device=device) b_ = torch.linspace(b_range[0], b_range[1], steps=grid_number, device=device) - a_grid, b_grid = torch.meshgrid(a_, b_, indexing='ij') - post_fun = fun(a_grid[None,:,:] * x[:,None,None] + b_grid[None,:,:]) + a_grid, b_grid = torch.meshgrid(a_, b_, indexing="ij") + post_fun = fun(a_grid[None, :, :] * x[:, None, None] + b_grid[None, :, :]) x_mean = torch.mean(post_fun, dim=[0], keepdim=True) y_mean = torch.mean(y, dim=[0], keepdim=True) - numerator = torch.sum((post_fun - x_mean)*(y-y_mean)[:,None,None], dim=0)**2 - denominator = torch.sum((post_fun - x_mean)**2, dim=0)*torch.sum((y - y_mean)[:,None,None]**2, dim=0) - r2 = numerator/(denominator+1e-4) + numerator = ( + torch.sum((post_fun - x_mean) * (y - y_mean)[:, None, None], dim=0) ** 2 + ) + denominator = torch.sum((post_fun - x_mean) ** 2, dim=0) * torch.sum( + (y - y_mean)[:, None, None] ** 2, dim=0 + ) + r2 = numerator / (denominator + 1e-4) r2 = torch.nan_to_num(r2) - - + best_id = torch.argmax(r2) - a_id, b_id = torch.div(best_id, grid_number, rounding_mode='floor'), best_id % grid_number - - + a_id, b_id = ( + torch.div(best_id, grid_number, rounding_mode="floor"), + best_id % grid_number, + ) + if a_id == 0 or a_id == grid_number - 1 or b_id == 0 or b_id == grid_number - 1: - if _ == 0 and verbose==True: - print('Best value at boundary.') + if _ == 0 and verbose == True: + print("Best value at boundary.") if a_id == 0: a_range = [a_[0], a_[1]] if a_id == grid_number - 1: @@ -243,62 +367,66 @@ def fit_params(x, y, fun, a_range=(-10,10), b_range=(-10,10), grid_number=101, i b_range = [b_[0], b_[1]] if b_id == grid_number - 1: b_range = [b_[-2], b_[-1]] - + else: - a_range = [a_[a_id-1], a_[a_id+1]] - b_range = [b_[b_id-1], b_[b_id+1]] - + a_range = [a_[a_id - 1], a_[a_id + 1]] + b_range = [b_[b_id - 1], b_[b_id + 1]] + a_best = a_[a_id] b_best = b_[b_id] post_fun = fun(a_best * x + b_best) r2_best = r2[a_id, b_id] - + if verbose == True: print(f"r2 is {r2_best}") if r2_best < 0.9: - print(f'r2 is not very high, please double check if you are choosing the correct symbolic function.') + print( + "r2 is not very high, please double check if you are choosing the correct symbolic function." + ) post_fun = torch.nan_to_num(post_fun) - reg = LinearRegression().fit(post_fun[:,None].detach().cpu().numpy(), y.detach().cpu().numpy()) + reg = LinearRegression().fit( + post_fun[:, None].detach().cpu().numpy(), y.detach().cpu().numpy() + ) c_best = torch.from_numpy(reg.coef_)[0].to(device) d_best = torch.from_numpy(np.array(reg.intercept_)).to(device) return torch.stack([a_best, b_best, c_best, d_best]), r2_best def sparse_mask(in_dim, out_dim): - ''' + """ get sparse mask - ''' - in_coord = torch.arange(in_dim) * 1/in_dim + 1/(2*in_dim) - out_coord = torch.arange(out_dim) * 1/out_dim + 1/(2*out_dim) + """ + in_coord = torch.arange(in_dim) * 1 / in_dim + 1 / (2 * in_dim) + out_coord = torch.arange(out_dim) * 1 / out_dim + 1 / (2 * out_dim) - dist_mat = torch.abs(out_coord[:,None] - in_coord[None,:]) + dist_mat = torch.abs(out_coord[:, None] - in_coord[None, :]) in_nearest = torch.argmin(dist_mat, dim=0) - in_connection = torch.stack([torch.arange(in_dim), in_nearest]).permute(1,0) + in_connection = torch.stack([torch.arange(in_dim), in_nearest]).permute(1, 0) out_nearest = torch.argmin(dist_mat, dim=1) - out_connection = torch.stack([out_nearest, torch.arange(out_dim)]).permute(1,0) + out_connection = torch.stack([out_nearest, torch.arange(out_dim)]).permute(1, 0) all_connection = torch.cat([in_connection, out_connection], dim=0) mask = torch.zeros(in_dim, out_dim) - mask[all_connection[:,0], all_connection[:,1]] = 1. - + mask[all_connection[:, 0], all_connection[:, 1]] = 1.0 + return mask def add_symbolic(name, fun, c=1, fun_singularity=None): - ''' + """ add a symbolic function to library - + Args: ----- name : str name of the function fun : fun torch function or lambda function - + Returns: -------- None - + Example ------- >>> print(SYMBOLIC_LIB['Bessel']) @@ -306,26 +434,26 @@ def add_symbolic(name, fun, c=1, fun_singularity=None): >>> add_symbolic('Bessel', torch.special.bessel_j0) >>> print(SYMBOLIC_LIB['Bessel']) (, Bessel) - ''' + """ exec(f"globals()['{name}'] = sympy.Function('{name}')") - if fun_singularity==None: + if fun_singularity == None: fun_singularity = fun SYMBOLIC_LIB[name] = (fun, globals()[name], c, fun_singularity) - - + + def ex_round(ex1, n_digit): - ''' + """ rounding the numbers in an expression to certain floating points - + Args: ----- ex1 : sympy expression n_digit : int - + Returns: -------- ex2 : sympy expression - + Example ------- >>> from kan.utils import * @@ -333,7 +461,7 @@ def ex_round(ex1, n_digit): >>> input_vars = a, b = symbols('a b') >>> expression = 3.14534242 * exp(sin(pi*a) + b**2) - 2.32345402 >>> ex_round(expression, 2) - ''' + """ ex2 = ex1 for a in sympy.preorder_traversal(ex1): if isinstance(a, sympy.Float): @@ -342,19 +470,19 @@ def ex_round(ex1, n_digit): def augment_input(orig_vars, aux_vars, x): - ''' + """ augment inputs - + Args: ----- orig_vars : list of sympy symbols aux_vars : list of auxiliary symbols x : inputs - + Returns: -------- augmented inputs - + Example ------- >>> from kan.utils import * @@ -363,88 +491,102 @@ def augment_input(orig_vars, aux_vars, x): >>> aux_vars = [a + b, a * b] >>> x = torch.rand(100, 2) >>> augment_input(orig_vars, aux_vars, x).shape - ''' + """ # if x is a tensor if isinstance(x, torch.Tensor): - aux_values = torch.tensor([]).to(x.device) for aux_var in aux_vars: - func = lambdify(orig_vars, aux_var,'numpy') # returns a numpy-ready function - aux_value = torch.from_numpy(func(*[x[:,[i]].numpy() for i in range(len(orig_vars))])) + func = lambdify( + orig_vars, aux_var, "numpy" + ) # returns a numpy-ready function + aux_value = torch.from_numpy( + func(*[x[:, [i]].numpy() for i in range(len(orig_vars))]) + ) aux_values = torch.cat([aux_values, aux_value], dim=1) - + x = torch.cat([aux_values, x], dim=1) # if x is a dataset elif isinstance(x, dict): - x['train_input'] = augment_input(orig_vars, aux_vars, x['train_input']) - x['test_input'] = augment_input(orig_vars, aux_vars, x['test_input']) - + x["train_input"] = augment_input(orig_vars, aux_vars, x["train_input"]) + x["test_input"] = augment_input(orig_vars, aux_vars, x["test_input"]) + return x -def batch_jacobian(func, x, create_graph=False, mode='scalar'): - ''' +def batch_jacobian(func, x, create_graph=False, mode="scalar"): + """ jacobian - + Args: ----- func : function or model x : inputs create_graph : bool - + Returns: -------- jacobian - + Example ------- >>> from kan.utils import batch_jacobian >>> x = torch.normal(0,1,size=(100,2)) >>> model = lambda x: x[:,[0]] + x[:,[1]] >>> batch_jacobian(model, x) - ''' + """ + # x in shape (Batch, Length) def _func_sum(x): return func(x).sum(dim=0) - if mode == 'scalar': - return torch.autograd.functional.jacobian(_func_sum, x, create_graph=create_graph)[0] - elif mode == 'vector': - return torch.autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2) + + if mode == "scalar": + return torch.autograd.functional.jacobian( + _func_sum, x, create_graph=create_graph + )[0] + elif mode == "vector": + return torch.autograd.functional.jacobian( + _func_sum, x, create_graph=create_graph + ).permute(1, 0, 2) + def batch_hessian(model, x, create_graph=False): - ''' + """ hessian - + Args: ----- func : function or model x : inputs create_graph : bool - + Returns: -------- jacobian - + Example ------- >>> from kan.utils import batch_hessian >>> x = torch.normal(0,1,size=(100,2)) >>> model = lambda x: x[:,[0]]**2 + x[:,[1]]**2 >>> batch_hessian(model, x) - ''' + """ # x in shape (Batch, Length) jac = lambda x: batch_jacobian(model, x, create_graph=True) + def _jac_sum(x): return jac(x).sum(dim=0) - return torch.autograd.functional.jacobian(_jac_sum, x, create_graph=create_graph).permute(1,0,2) + return torch.autograd.functional.jacobian( + _jac_sum, x, create_graph=create_graph + ).permute(1, 0, 2) -def create_dataset_from_data(inputs, labels, train_ratio=0.8, device='cpu'): - ''' + +def create_dataset_from_data(inputs, labels, train_ratio=0.8, device="cpu"): + """ create dataset from data - + Args: ----- inputs : 2D torch.float @@ -452,11 +594,11 @@ def create_dataset_from_data(inputs, labels, train_ratio=0.8, device='cpu'): train_ratio : float the ratio of training fraction device : str - + Returns: -------- dataset (dictionary) - + Example ------- >>> from kan.utils import create_dataset_from_data @@ -464,23 +606,33 @@ def create_dataset_from_data(inputs, labels, train_ratio=0.8, device='cpu'): >>> y = torch.normal(0,1,size=(100,1)) >>> dataset = create_dataset_from_data(x, y) >>> dataset['train_input'].shape - ''' + """ num = inputs.shape[0] - train_id = np.random.choice(num, int(num*train_ratio), replace=False) + train_id = np.random.choice(num, int(num * train_ratio), replace=False) test_id = list(set(np.arange(num)) - set(train_id)) dataset = {} - dataset['train_input'] = inputs[train_id].detach().to(device) - dataset['test_input'] = inputs[test_id].detach().to(device) - dataset['train_label'] = labels[train_id].detach().to(device) - dataset['test_label'] = labels[test_id].detach().to(device) - + dataset["train_input"] = inputs[train_id].detach().to(device) + dataset["test_input"] = inputs[test_id].detach().to(device) + dataset["train_label"] = labels[train_id].detach().to(device) + dataset["test_label"] = labels[test_id].detach().to(device) + return dataset -def get_derivative(model, inputs, labels, derivative='hessian', loss_mode='pred', reg_metric='w', lamb=0., lamb_l1=1., lamb_entropy=0.): - ''' +def get_derivative( + model, + inputs, + labels, + derivative="hessian", + loss_mode="pred", + reg_metric="w", + lamb=0.0, + lamb_l1=1.0, + lamb_entropy=0.0, +): + """ compute the jacobian/hessian of loss wrt to model parameters - + Args: ----- inputs : 2D torch.float @@ -488,39 +640,36 @@ def get_derivative(model, inputs, labels, derivative='hessian', loss_mode='pred' derivative : str 'jacobian' or 'hessian' device : str - + Returns: -------- jacobian or hessian - ''' - def get_mapping(model): + """ + def get_mapping(model): mapping = {} - name = 'model1' + name = "model1" keys = list(model.state_dict().keys()) for key in keys: - y = re.findall(".[0-9]+", key) if len(y) > 0: y = y[0][1:] x = re.split(".[0-9]+", key) - mapping[key] = name + '.' + x[0] + '[' + y + ']' + x[1] - + mapping[key] = name + "." + x[0] + "[" + y + "]" + x[1] y = re.findall("_[0-9]+", key) if len(y) > 0: y = y[0][1:] x = re.split(".[0-9]+", key) - mapping[key] = name + '.' + x[0] + '[' + y + ']' + mapping[key] = name + "." + x[0] + "[" + y + "]" return mapping - - #model1 = copy.deepcopy(model) + # model1 = copy.deepcopy(model) model1 = model.copy() mapping = get_mapping(model) - + # collect keys and shapes keys = list(model.state_dict().keys()) shapes = [] @@ -528,10 +677,8 @@ def get_mapping(model): for params in model.parameters(): shapes.append(params.shape) - # turn a flattened vector to model params def param2statedict(p, keys, shapes): - new_state_dict = {} start = 0 @@ -539,56 +686,69 @@ def param2statedict(p, keys, shapes): for i in range(n_group): shape = shapes[i] n_params = torch.prod(torch.tensor(shape)) - new_state_dict[keys[i]] = p[start:start+n_params].reshape(shape) + new_state_dict[keys[i]] = p[start : start + n_params].reshape(shape) start += n_params return new_state_dict - - def differentiable_load_state_dict(mapping, state_dict, model1): + def differentiable_load_state_dict(mapping, state_dict, model1): for key in keys: - if mapping[key][-1] != ']': + if mapping[key][-1] != "]": exec(f"del {mapping[key]}") exec(f"{mapping[key]} = state_dict[key]") - # input: p, output: output def get_param2loss_fun(inputs, labels): - def param2loss_fun(p): - p = p[0] state_dict = param2statedict(p, keys, shapes) # this step is non-differentiable - #model.load_state_dict(state_dict) + # model.load_state_dict(state_dict) differentiable_load_state_dict(mapping, state_dict, model1) - if loss_mode == 'pred': - pred_loss = torch.mean((model1(inputs) - labels)**2, dim=(0,1), keepdim=True) + if loss_mode == "pred": + pred_loss = torch.mean( + (model1(inputs) - labels) ** 2, dim=(0, 1), keepdim=True + ) loss = pred_loss - elif loss_mode == 'reg': - reg_loss = model1.get_reg(reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy) * torch.ones(1,1) + elif loss_mode == "reg": + reg_loss = model1.get_reg( + reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy + ) * torch.ones(1, 1) loss = reg_loss - elif loss_mode == 'all': - pred_loss = torch.mean((model1(inputs) - labels)**2, dim=(0,1), keepdim=True) - reg_loss = model1.get_reg(reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy) * torch.ones(1,1) + elif loss_mode == "all": + pred_loss = torch.mean( + (model1(inputs) - labels) ** 2, dim=(0, 1), keepdim=True + ) + reg_loss = model1.get_reg( + reg_metric=reg_metric, lamb_l1=lamb_l1, lamb_entropy=lamb_entropy + ) * torch.ones(1, 1) loss = pred_loss + lamb * reg_loss return loss return param2loss_fun - - fun = get_param2loss_fun(inputs, labels) - p = model2param(model)[None,:] - if derivative == 'hessian': + + fun = get_param2loss_fun(inputs, labels) + p = model2param(model)[None, :] + if derivative == "hessian": result = batch_hessian(fun, p) - elif derivative == 'jacobian': + elif derivative == "jacobian": result = batch_jacobian(fun, p) return result + def model2param(model): - ''' + """ turn model parameters into a flattened vector - ''' + """ p = torch.tensor([]).to(model.device) for params in model.parameters(): - p = torch.cat([p, params.reshape(-1,)], dim=0) + p = torch.cat( + [ + p, + params.reshape( + -1, + ), + ], + dim=0, + ) return p diff --git a/pykan.egg-info/PKG-INFO b/pykan.egg-info/PKG-INFO index 005e7ee52..c51a699f8 100644 --- a/pykan.egg-info/PKG-INFO +++ b/pykan.egg-info/PKG-INFO @@ -1,15 +1,16 @@ -Metadata-Version: 2.1 +Metadata-Version: 2.4 Name: pykan -Version: 0.2.7 -Summary: Kolmogorov Arnold Networks +Version: 0.1.0 +Summary: Add your description here Author: Ziming Liu Author-email: zmliu@mit.edu -Classifier: Programming Language :: Python :: 3 -Classifier: License :: OSI Approved :: MIT License -Classifier: Operating System :: OS Independent Requires-Python: >=3.6 Description-Content-Type: text/markdown License-File: LICENSE +Dynamic: author +Dynamic: author-email +Dynamic: license-file +Dynamic: requires-python kan_plot @@ -59,6 +60,9 @@ setuptools==65.5.0 sympy==1.11.1 torch==2.2.2 tqdm==4.66.2 +pandas==2.0.1 +seaborn +pyyaml ``` After activating the virtual environment, you can install specific package requirements as follows: @@ -75,10 +79,12 @@ pip install git+https://github.com/KindXiaoming/pykan.git # For GitHub installa # or pip install pykan # For PyPI installation ``` +## Efficiency mode +For many machine-learning users, when (1) you need to write the training loop yourself (instead of using ``model.fit()``); (2) you never use the symbolic branch, it is important to call ``model.speed()`` before training! Otherwise, the symbolic branch is on, which is super slow because the symbolic computations are not parallelized! ## Computation requirements -Examples in [tutorials](tutorials) are runnable on a single CPU typically less than 10 minutes. All examples in the paper are runnable on a single CPU in less than one day. Training KANs for PDE is the most expensive and may take hours to days on a single CPU. We use CPUs to train our models because we carried out parameter sweeps (both for MLPs and KANs) to obtain Pareto Frontiers. There are thousands of small models which is why we use CPUs rather than GPUs. Admittedly, our problem scales are smaller than typical machine learning tasks, but are typical for science-related tasks. In case the scale of your task is large, it is advisable to use GPUs. +Examples in [tutorials](tutorials) are runnable on a single CPU typically less than 10 minutes. All examples in the paper are runnable on a single CPU in less than one day. Training KANs for PDE is the most expensive and may take hours to days on a single CPU. We use CPUs to train our models because we carried out parameter sweeps (both for MLPs and KANs) to obtain Pareto Frontiers. There are thousands of small models which is why we use CPUs rather than GPUs. Admittedly, our problem scales are smaller than typical machine learning tasks but are typical for science-related tasks. In case the scale of your task is large, it is advisable to use GPUs. ## Documentation The documentation can be found [here](https://kindxiaoming.github.io/pykan/). @@ -94,7 +100,7 @@ Get started with [hellokan.ipynb](./hellokan.ipynb) notebook. More Notebook tutorials can be found in [tutorials](tutorials). ## Advice on hyperparameter tuning -Many intuition about MLPs and other networks may not directy transfer to KANs. So how can I tune the hyperparameters effectively? Here is my general advice based on my experience playing with the problems reported in the paper. Since these problems are relatively small-scale and science-oriented, it is likely that my advice is not suitable to your case. But I want to at least share my experience such that users can have better clues where to start and what to expect from tuning hyperparameters. +Many intuition about MLPs and other networks may not directly transfer to KANs. So how can I tune the hyperparameters effectively? Here is my general advice based on my experience playing with the problems reported in the paper. Since these problems are relatively small-scale and science-oriented, it is likely that my advice is not suitable to your case. But I want to at least share my experience such that users can have better clues where to start and what to expect from tuning hyperparameters. * Start from a simple setup (small KAN shape, small grid size, small data, no reguralization `lamb=0`). This is very different from MLP literature, where people by default use widths of order `O(10^2)` or higher. For example, if you have a task with 5 inputs and 1 outputs, I would try something as simple as `KAN(width=[5,1,1], grid=3, k=3)`. If it doesn't work, I would gradually first increase width. If that still doesn't work, I would consider increasing depth. You don't need to be this extreme, if you have better understanding about the complexity of your task. diff --git a/pykan.egg-info/SOURCES.txt b/pykan.egg-info/SOURCES.txt index 13700da9f..f45589e14 100644 --- a/pykan.egg-info/SOURCES.txt +++ b/pykan.egg-info/SOURCES.txt @@ -1,9 +1,7 @@ LICENSE README.md +pyproject.toml setup.py -experiments/__init__.py -experiments/baselines/MLP.py -experiments/baselines/__init__.py kan/KANLayer.py kan/LBFGS.py kan/MLP.py diff --git a/pykan.egg-info/top_level.txt b/pykan.egg-info/top_level.txt index f7ee52c79..31e7c0933 100644 --- a/pykan.egg-info/top_level.txt +++ b/pykan.egg-info/top_level.txt @@ -1,2 +1 @@ -experiments kan diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 000000000..16588f147 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,18 @@ +[project] +name = "pykan" +version = "0.2.8" +description = "Kolmogorov Arnold Networks" +readme = "README.md" +requires-python = ">=3.11" +dependencies = [ + "matplotlib==3.6.2", + "numpy==1.24.4", + "scikit_learn==1.1.3", + "setuptools==65.5.0", + "sympy==1.11.1", + "torch==2.2.2", + "tqdm==4.66.2", + "pandas==2.0.1", + "seaborn==0.13.2", + "pyyaml==6.0.2" +] diff --git a/requirements.txt b/requirements.txt index eb22065bf..404a61b4c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,5 +6,5 @@ sympy==1.11.1 torch==2.2.2 tqdm==4.66.2 pandas==2.0.1 -seaborn -pyyaml +seaborn==0.13.2 +pyyaml==6.0.2 diff --git a/setup.py b/setup.py index b069e05e2..69bb6430f 100644 --- a/setup.py +++ b/setup.py @@ -15,11 +15,11 @@ # url="https://github.com/kindxiaoming/", packages=setuptools.find_packages(), include_package_data=True, - package_data={ - 'pykan': [ - 'figures/lock.png', - 'assets/img/sum_symbol.png', - 'assets/img/mult_symbol.png', + package_data={ + "pykan": [ + "figures/lock.png", + "assets/img/sum_symbol.png", + "assets/img/mult_symbol.png", ], }, classifiers=[ @@ -27,5 +27,5 @@ "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], - python_requires='>=3.6', + python_requires=">=3.6", ) diff --git a/tutorials/.ipynb_checkpoints/API_10_device-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_10_device-checkpoint.ipynb deleted file mode 100644 index 37be025c3..000000000 --- a/tutorials/.ipynb_checkpoints/API_10_device-checkpoint.ipynb +++ /dev/null @@ -1,175 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Demo 10: Device\n", - "\n", - "All other demos have by default used device = 'cpu'. In case we want to use cuda, we should pass the device argument to model and dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "7a4ac1e1-84ba-4bc3-91b6-a776a5e7711c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cpu\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "#device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "device = 'cpu'\n", - "print(device)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.83e-01 | test_loss: 7.21e-01 | reg: 1.04e+03 | : 100%|█| 50/50 [00:19<00:00, 2.56it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", - "\n", - "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f182cc1-51bf-4151-a253-a52fe854919e", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f6f8125e-d26d-4c97-9e5f-988099bb4737", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - } - ], - "source": [ - "device = 'cuda'\n", - "print(device)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "95017dfa-3a2a-43e0-8b68-fb220ca5abc9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.83e-01 | test_loss: 7.21e-01 | reg: 1.04e+03 | : 100%|█| 50/50 [00:01<00:00, 26.45it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", - "\n", - "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8230d562-2635-4adc-b566-06ac679b166a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_11_create_dataset-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_11_create_dataset-checkpoint.ipynb deleted file mode 100644 index af8190ef6..000000000 --- a/tutorials/.ipynb_checkpoints/API_11_create_dataset-checkpoint.ipynb +++ /dev/null @@ -1,178 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "53ff2e87", - "metadata": {}, - "source": [ - "# API 11: Create dataset" - ] - }, - { - "cell_type": "markdown", - "id": "25a90774", - "metadata": {}, - "source": [ - "how to use create_dataset in kan.utils" - ] - }, - { - "cell_type": "markdown", - "id": "2f9ae0c7", - "metadata": {}, - "source": [ - "Standard way" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "3e2b9f8b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "data": { - "text/plain": [ - "torch.Size([1000, 1])" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan.utils import create_dataset\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "f = lambda x: x[:,[0]] * x[:,[1]]\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "877956c9", - "metadata": {}, - "source": [ - "Lazier way. We sometimes forget to add the bracket, i.e., write x[:,[0]] as x[:,0], and this used to lead to an error in training (loss not going down). Now the create_dataset can automatically detect this simplification and produce the correct behavior." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b14dd4a2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([1000, 1])" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = lambda x: x[:,0] * x[:,1]\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "60230da4", - "metadata": {}, - "source": [ - "Laziest way. If you even want to get rid of the colon symbol, i.e., you want to write x[;,0] as x[0], you can do that but need to pass in f_mode = 'row'." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e764f415", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([1000, 1])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = lambda x: x[0] * x[1]\n", - "dataset = create_dataset(f, n_var=2, f_mode='row', device=device)\n", - "dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "8e1f1732", - "metadata": {}, - "source": [ - "if you already have x (inputs) and y (outputs), and you only want to partition them into train/test, use create_dataset_from_data" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "accf900a", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from kan.utils import create_dataset_from_data\n", - "\n", - "x = torch.rand(100,2)\n", - "y = torch.rand(100,1)\n", - "dataset = create_dataset_from_data(x, y, device=device)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c45062a8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_12_checkpoint_save_load_model-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_12_checkpoint_save_load_model-checkpoint.ipynb deleted file mode 100644 index 476f6f054..000000000 --- a/tutorials/.ipynb_checkpoints/API_12_checkpoint_save_load_model-checkpoint.ipynb +++ /dev/null @@ -1,286 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 12: Checkpoint, save & load model" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "Whenever the KAN (model) is altered (e.g., fit, prune ...), a new version is saved to the model.ckpt folder (by default 'model'). The version number is 'a.b', where a is the round number (starting from zero, +1 when model.rewind() is called), b is the version number in each round. " - ] - }, - { - "cell_type": "markdown", - "id": "0b257f90", - "metadata": {}, - "source": [ - "the initialized model has version 0.0" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, auto_save=True, device=device)\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "b672e3b9", - "metadata": {}, - "source": [ - "the auto_save is on (by default)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a3353b8a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.auto_save" - ] - }, - { - "cell_type": "markdown", - "id": "c117cf01", - "metadata": {}, - "source": [ - "After fitting, the version becomes 0.1" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c9d51cba", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.34e-02 | test_loss: 3.29e-02 | reg: 4.93e+00 | : 100%|█| 20/20 [00:03<00:00, 5.10it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "afdf5c2b", - "metadata": {}, - "source": [ - "After pruning, the version becomes 0.2" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6c9d99dd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "872915a5", - "metadata": {}, - "source": [ - "Suppose we want to revert back to version 0.1, use model = model.rewind('0.1'). This starts a new round, meaning version 0.1 renamed to version 1.1." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1692e33b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rewind to model version 0.1, renamed as 1.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# revert to version 0.1 (if continuing)\n", - "model = model.rewind('0.1')\n", - "\n", - "# revert to version 0.1 (if starting from scratch)\n", - "#model = KAN.loadckpt('./model' + '0.1')\n", - "#model.get_act(dataset)\n", - "\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "0e3ae1a0", - "metadata": {}, - "source": [ - "Suppose we do some more manipulation to version 1.1, we will roll forward to version 1.2" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "fb8a3d56", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.06e-02 | test_loss: 2.18e-02 | reg: 5.48e+00 | : 100%|█| 2/2 [00:00<00:00, 5.83it/s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 1.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=2);\n", - "model.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_1_indexing-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_1_indexing-checkpoint.ipynb deleted file mode 100644 index f27b7389d..000000000 --- a/tutorials/.ipynb_checkpoints/API_1_indexing-checkpoint.ipynb +++ /dev/null @@ -1,463 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 1: Indexing" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,3,2,1], noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x);\n", - "beta = 100\n", - "model.plot(beta=beta)\n", - "# [2,3,2,1] means 2 input nodes\n", - "# 3 neurons in the first hidden layer,\n", - "# 2 neurons in the second hidden layer,\n", - "# 1 output node" - ] - }, - { - "cell_type": "markdown", - "id": "c47ccd2b", - "metadata": {}, - "source": [ - "### Indexing of edges (activation functions)" - ] - }, - { - "cell_type": "markdown", - "id": "8c30add2", - "metadata": {}, - "source": [ - "Each activation function is indexed by $(l,i,j)$ where $l$ is the layer index, $i$ is the input neuron index, $j$ is the output neuron index. All of them starts from 0. For example, the one in the bottom left corner is (0, 0, 0). Let's try to make it symbolic and see it turns red." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c95dbc78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9785453677177429\n", - "saving model version 0.1\n", - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "bf721202", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.991183876991272\n", - "saving model version 0.3\n", - "saving model version 0.4\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,0,1,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1e7cd4a8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9494338631629944\n", - "saving model version 0.5\n", - "saving model version 0.6\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(0,1,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "18e0baa2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999909996986389\n", - "saving model version 0.7\n", - "saving model version 0.8\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(1,0,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(1,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "50eb8f8c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9998168349266052\n", - "saving model version 0.9\n", - "saving model version 0.10\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.fix_symbolic(2,1,0,'sin')\n", - "model.plot(beta=beta)\n", - "model.unfix_symbolic(2,1,0)" - ] - }, - { - "cell_type": "markdown", - "id": "960e5447", - "metadata": {}, - "source": [ - "### Indexing of nodes (neurons)" - ] - }, - { - "cell_type": "markdown", - "id": "f4a7880f", - "metadata": {}, - "source": [ - "Each neuron (node) is indexed by $(l,i)$ where $l$ is the layer index along depth, $i$ is the neuron index along width. In the function remove_node, we use use $(l,i)$ to indicate which node we want to remove." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c9e70d77", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.11\n", - "saving model version 0.12\n", - "saving model version 0.13\n" - ] - } - ], - "source": [ - "model.remove_node(1,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "a22c9e31", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "44553b6a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.14\n", - "saving model version 0.15\n", - "saving model version 0.16\n" - ] - } - ], - "source": [ - "model.remove_node(2,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "7c9b491a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "7b24fcdb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.17\n", - "saving model version 0.18\n", - "saving model version 0.19\n" - ] - } - ], - "source": [ - "model.remove_node(1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0a7e9373", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=beta)" - ] - }, - { - "cell_type": "markdown", - "id": "9ee64af1", - "metadata": {}, - "source": [ - "### Indexing of layers" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4c732dfc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n", - "2 3\n", - "2 3\n", - "3 5\n", - "3 5\n", - "5 1\n", - "5 1\n" - ] - } - ], - "source": [ - "# KAN spline layers are refererred to as act_fun\n", - "# KAN symbolic layers are referred to as symbolic_fun\n", - "\n", - "model = KAN(width=[2,3,5,1])\n", - "\n", - "i = 0\n", - "model.act_fun[i] # => KAN Layer (Spline)\n", - "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", - "\n", - "for i in range(3):\n", - " print(model.act_fun[i].in_dim, model.act_fun[i].out_dim)\n", - " print(model.symbolic_fun[i].in_dim, model.symbolic_fun[i].out_dim)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "1f0ccc8f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Parameter containing:\n", - "tensor([[0., 0., 0., 0., 0.]])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# check model parameters\n", - "model.act_fun[i].grid\n", - "model.act_fun[i].coef\n", - "model.symbolic_fun[i].funs_name\n", - "model.symbolic_fun[i].mask" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_2_plotting-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_2_plotting-checkpoint.ipynb deleted file mode 100644 index f9fd074b6..000000000 --- a/tutorials/.ipynb_checkpoints/API_2_plotting-checkpoint.ipynb +++ /dev/null @@ -1,590 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 2: Plotting" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Initialize KAN and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "8c6add1d", - "metadata": {}, - "source": [ - "Plot KAN at initialization" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ac76f858", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", - "model.plot(beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8071b133", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# if you want to add variable names and title\n", - "model.plot(beta=100, in_vars=[r'$\\alpha$', 'x'], out_vars=['y'], title = 'My KAN')" - ] - }, - { - "cell_type": "markdown", - "id": "ddf67e30", - "metadata": {}, - "source": [ - "Train KAN with sparsity regularization" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.20e-02 | test_loss: 5.35e-02 | reg: 4.93e+00 | : 100%|█| 20/20 [00:03<00:00, 5.22it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "$\\beta$ controls the transparency of activations. Larger $\\beta$ => more activation functions show up. We usually want to set a proper beta such that only important connections are visually significant. transparency is set to be ${\\rm tanh}(\\beta \\phi)$ where $\\phi$ is the scale of the activation function (metric='forward_u'), normalized scale (metric='forward_n') or the feature attribution score (metric='backward'). By default $\\beta=3$ and metric='backward'." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6383a22f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=100000)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "cbd0f521", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "d0925b09", - "metadata": {}, - "source": [ - "plotting with different metrics: 'forward_n', 'forward_u', 'backward'" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "34fe7629", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwlUlEQVR4nO3dd1wT9/8H8NclELaALMUNbsW9997bamuHSh21zrrrqFqte9S9qKvaVm3VKu6NE3FvEUVUXIBsSMi49+8Pv7kfWFQSLrkEPs/Hg0crJHfvfJK7Vz53n/scR0QEhmEYhhGRTOoCGIZhmLyHhQvDMAwjOhYuDMMwjOhYuDAMwzCiY+HCMAzDiI6FC8MwDCM6Fi4MwzCM6Fi4MAzDMKJj4cIwDMOIjoULwzAMIzoWLgzDMIzoWLgwDMMwomPhwjAMw4iOhQvDMAwjOhYuDMMwjOhspC6AYawBEeHt27dITU2Fs7MzPDw8wHGc1GUxjMViPReG+YjExEQsW7YMZcqUgZeXF0qVKgUvLy+UKVMGy5YtQ2JiotQlMoxF4tidKBkme0eOHEHPnj2Rnp4O4F3vRU/fa3F0dMSuXbvQtm1bSWpkGEvFwoVhsnHkyBF07NgRRASe5z/4OJlMBo7jcODAARYwDJMJCxeGeU9iYiKKFi0KpVL50WDRk8lkcHBwQHR0NNzc3ExfIMNYAXbOhWHes2XLFqSnp+coWACA53mkp6fj999/N3FlDGM9WM+FYTIhIpQpUwaRkZEwZNPgOA5+fn6IiIhgo8gYBixcGCaLuLg4eHl55er5Hh4eIlbEMNaJHRZjmExSU1Nz9fyUlBSRKmEY68bChWEycXZ2ztXzXVxcRKqEYawbCxeGycTDwwP+/v4GnzfhOA7+/v4oWLCgiSpjGOvCwoVhMuE4DiNGjDDquSNHjmQn8xnmf9gJfYZ5D7vOhWFyj/VcGOY9bm5u2LVrFziOg0z28U1Ef4X+7t27WbAwTCYsXBgmG23btsWBAwfg4OAAjuP+c7hL/zsHBwccPHgQbdq0kahShrFMLFwY5gPatm2L6OhoLF26FH5+fln+5ufnh6VLl+LFixcsWBgmG+ycC8PkABHh1KlTaNmyJU6cOIHmzZuzk/cM8xGs58IwOcBxnHBOxc3NjQULw3wCCxeGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYUTHwoVhGIYRHQsXhmEYRnQsXBiGYRjRsXBhGIZhRMfChWEYhhEdCxeGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4b5BI1GgxcvXuD+/fsAgMePHyM+Ph48z0tcGcNYLnabY4b5gMTEROzatQt//PEH7t69i5SUFKjVatjb28PLywuNGzfGgAED0LBhQ9jY2EhdLsNYFBYuDJONixcvYvTo0bh16xZq166Njh07okqVKnB2dkZiYiKuXr2K4OBgPHr0CJ9//jl++eUXeHl5SV02w1gMFi4M856jR4+if//+cHZ2xty5c9GhQweo1Wps374dGRkZKFCgAL744gtoNBps374dM2bMQKVKlbB161b4+PhIXT7DWAQWLgyTycOHD9GuXTs4OTlh+/btqFixIjiOQ2RkJGrUqIGkpCSUKlUKV69ehbu7O4gI586dw5dffolmzZrht99+g52dndQvg2Ekx07oM8z/6HQ6zJkzBwkJCVi5cqUQLB/DcRwaNWqEBQsWYO/evTh8+LCZqmUYy8bChWH+59GjRwgODkaPHj3QqFGjTwaLHsdx6NatG+rVq4egoCBotVoTV8owlo8NcWGY/7lw4QJSU1PRs2dPREVFIS0tTfhbdHQ0dDodAECtVuPu3bsoUKCA8HdfX1/06NEDM2bMwOvXr1G0aFGz188wloSFC8P8z4MHD+Do6Ag/Pz989913OH/+vPA3IkJGRgYA4OXLl2jdurXwN47jsHjxYgQEBCA9PR0vX75k4cLkeyxcGOZ/lEolbGxsYGdnh4yMDKhUqmwfR0T/+ZtWq4WDg0OWEGKY/IyFC8PgXWB4eXlBqVQiMTERdevWhZOTk/B3pVKJCxcuCCHSoEED4cJJjuNQvHhxxMTEQCaTwc3NTaJXwTCWg4ULky/pR+BnHolfo0YNaDQahIWFYf78+VkeHxkZidq1ayMpKQk+Pj7YsWNHlhDhOA6TJ09GoUKF4OvrC51OJwwI4Dgux4MDGCavYKPFmHyBiEBE4HkePM8L/9bv+LVaLfz8/FCsWDFs2bIFaWlpkMvlWX70OI6DTCYTfi+TyfDq1Svs3LkTvr6+cHBwgEwmE9bL8zx0Ol2WdTNMXsfChcmTPhUmMpkMMpkMarUaMTExiI6OhrOzM77//ntcu3YNy5cvz/GQ4oyMDMycOROvX7/GmTNn4O/vj2XLliEjIyNLAOnrYmHD5AcsXJg8IbswAZAlSGQymRAuGRkZeP36NV68eAG1Wg0vLy8ULVoUQ4YMQdeuXTF//nwsX74cSqVSWJaNjQ1sbGyEXgwRITk5GdOnT8eOHTuwatUqhIeHo3379hg3bhxKlSqFJUuWID09Pdvejn4ZLGyYvIhN/8JYpezOmWQ+x/EhGRkZSEhIQHp6OmxtbeHu7g4nJ6csz4mNjcWwYcOwf/9+tG3bFqNHj0aFChUQHh4OnuehUChQunRphIWFYdGiRbhx4wZmzpyJ77//Xgiex48fY86cOfj9999RsGBBTJgwAUOGDMkySOD916P/ye71sHM2jLVh4cJYBWPDRC+7UHF2dv7g49PS0hAUFITly5fjzZs38PPzQ5kyZeDi4oKEhASEh4fj5cuXqFmzJqZPn46mTZsKvZHMnjx5gjlz5mDz5s1wd3fH+PHjMXTo0A+GTObX+37Y6F8rCxvGGrBwYSxSbsNEz9BQed/r169x4sQJhISEIDIyEunp6ShYsCACAgLQpk0b1K1bF46Ojp9cTlRUFObOnYuNGzfC3d0d48aNw9ChQ3NcCwsbxtqwcGEsglhhoqdSqZCQkAClUgmFQgE3NzeDQiU7Go0GKpUKDg4ORt8c7OnTp0LIuLq6YuzYsRg2bBhcXFwMWg4LG8bSsXBhJCF2mOi9Hyr6cypi4HkeGRkZsLOzy/YQmCGePXuGefPmYcOGDXB2dsbYsWMxfPjwLPOVGYKFDWNpWLgwZmGqMNEzZajoiRkues+fP8e8efPw22+/wdnZGWPGjMGIESOMDhk9FjaM1Fi4MCZh6jDRM0eo6JkiXPSio6Mxf/58BAUFwdHREaNHj8bIkSPh6uoqyvIzB8377wkLG8YUWLgwuZb5I2TqMNHTzwFmjlDRM2W46L18+RLz58/HunXr4ODggB9++AGjRo0Sfb4yFjaMqbFwYQyW3U4JMG2Y6CmVSiQkJEClUsHOzg5ubm4mDxU9c4SL3suXL7FgwQKsW7cOdnZ2+OGHH/DDDz+YbFJMFjaM2Fi4MJ8kZZjovR8q7u7uORoCLCZzhoveq1evsHDhQqxduxa2trYYNWoUfvjhBxQsWNCk62Vhw+QWCxfmPywhTPQsIVT0pAgXvTdv3mDhwoVYvXo1bGxsMHLkSIwZM8bkIaPHwoYxFAsXxqLCRM+SQkVPynDRe/PmDRYtWoTVq1dDLpdjxIgRGDNmDDw8PMxaBwsb5lNYuORDlhgmeunp6UhISBB24pYQKnqWEC56MTExWLx4MVatWgWO4zB8+HCMHTsWnp6ektTDwoZ5HwuXfMCSw0Qvc6jY29vD3d0dDg4OUpeVhSWFi15cXBwWL16MlStXgogwbNgwjBs3Dl5eXpLWxcKGYeGSB1lDmOhZQ6joWWK46MXFxWHJkiVYsWIFeJ4XQsbb21vq0gB8Omz0/8/kHSxc8gBrChM9awoVPUsOF723b9/i119/xfLly6HT6fD9999j/Pjx8PHxkbq0LFjY5H0sXKyQNYaJnjWGip41hItefHw8li5dimXLlkGj0WDIkCGYMGECChUqJHVp2WJhk/ewcLEC1hwmemlpaUhMTLTKUNGzpnDRS0hIEEImIyNDCJnChQtLXdpHsbCxfixcLFBeCBO9tLQ0JCQkQK1Ww8HBAe7u7rC3t5e6LKNYY7joJSYmYtmyZVi6dClUKhUGDx6MiRMnwtfXV+rSciTzNsHCxjqwcLEAeSlM9PJSqOhZc7joJSUlYfny5ViyZAmUSiUGDRqEH3/8EUWKFJG6NIOwsLF8LFwkkBfDRC8vhopeXggXvaSkJKxYsQJLlixBWlqaEDJFixaVujSjsLCxPCxczCAvh4leamoqEhMT82So6OWlcNFLTk7GypUrsXjxYqSmpmLAgAGYNGkSihUrJnVpucLCRnosXEwgP4SJXmpqKhISEqDRaODo6Ag3N7c8Fyp6eTFc9FJSUrBq1SosWrQIycnJQsgUL15c6tJEwcLG/Fi4iCA/hYne+6Hi7u4OOzs7qcsyqbwcLnqpqalCyCQlJSEwMBCTJ09GiRIlpC5NVCxsTI+FixHyY5gA716v/pxKfgoVvfwQLnqpqalYs2YNFi5ciISEBPTv3x+TJ09GqVKlpC7NJFjYiI+FSw7k1zDRy++hopefwkUvLS1NCJn4+Hj069cPkydPhp+fn9SlmRQLm9xj4ZKN/B4mekQknKjPz6Gilx/DRS89PR1r167FggULEBcXh759+2LKlCnw9/eXujSzYGFjOBYuYGHyvvdDxcnJCW5ubvk2VPTyc7jopaenY/369Zg/fz5iY2Px9ddfY+rUqShdurTUpZnVx8JG/9/8tt94X74MFxYm2csuVNzd3aFQKKQuzSKwcPl/SqVSCJk3b94IIVOmTBmpS5MEC5v/yhfhwsLk4/ShkpCQAK1Wy0LlA1i4/JdKpUJQUBDmzZuH169f48svv8TUqVNRrlw5qUuTFAubPBouLExyhoiQkpKCxMREFio5wMLlw1QqFTZs2IC5c+fi1atX+OKLL/DTTz+hfPnyUpdmEfJj2OSJcGFhYhgWKsZh4fJpGRkZQsi8ePFCCJkKFSpIXZrF0QdNXg0bqw8XnueF/2dhkjMJCQlISEiAs7Mz3NzcWKjkEAuXnMvIyMCmTZswZ84cJCUl4eXLl3BycpK6LIv2ftjIZDKr3pdZXLiYsxxrfuMyS0tLM+jxOp0ORAQbG5scP4eIwHFcntpB6HQ6gx6fm3CRy+UGPd5S7d69G1qtFra2tiZdD8/z6Nmzp0nXYU75cb+W870LY7EyMjLg7u5usuWr1WrExcXB3t4+T4ULz/PgeR62trY52iBlMpnwYwitVptnwuXixYu4fv06fvzxRzRr1sxk65k4cWKeDRdT7vz1XwItgUWGi6kbPy8yZZulpaVlOfyYlxAReJ7PcS8ur4REbnTr1g19+vRBTEyMxezIrAHHccJhL1OdU7Gk/Rs7cMx8UlpaGhwdHaUuwyQ4jsuzwWkqQ4cORVxcHN68eSN1KVYlc6BkdzI/r2HhwnySVquFs7Oz1GWYhEwmy9MbuCnIZDL07t0b3bp1k7oUq/N+wGT+b05ZSzBZ5GGx9xlyHFHf4Ky7Lq68OqJMJpMZfGKfATZu3AhnZ2ekpaXlqfNw5pB536Tft+V0H5ddqFjqvs7iey4fuvgou8dl/nt2j7X0pLdEeb3NLHXDtHROTk6oX78++vbtK3UpVinzZRM57cFk3se93/uxRBbdc8ltw33o20DmN5TJmby6E86rr8sc9u3bBy8vLyiVSjg4OEhdjtXJ3GMxpAeT3bkbS/wcW3zP5X2sR2JeGo1G6hIYC+Xp6Ym6deuy3ksu6IMi80iyD+3jTDnKzBQsuuei97GexoeOP2bualrLm2GJkpOTTX7BnJTYZyN3Dhw4AE9PTyQkJJj0Wqu87v2eyPuy+937Q5stjdX0XN4/CZb5v9k95n2sd2OctLQ0FChQQOoyTI59Pozj4eGB7t27o0OHDqwNc+lDQ5Uzn2d5fx9niaGiZ7Hh8qGk/tDfP9bo7ENvPJ7n2Wgg5qP++OMPhIWF4erVq1KXYvUyHyb72O+sgcWGi15OGtSQRre2N0hKmSfQy+vYFxDjOTg4YOnSpWjTpg0b1i2CzGGS02CxxM+v1e01DOkWsiDJHf2V6/mhHdlOMXeGDx8Od3d3jBo1yiJ3dNYoJ6Fiydum1YULYFg38f3uJZNzKSkp+WIuLblczqaAySWO43DmzBmsXbsWISEhUpeT71hioFtluBjKGo9XWoKkpCS4ublJXYbJyeVyi9w4rU2RIkUQFBSEjh074sWLF1KXk29Y6r4tX4RLfiHmDlI/W3BenVMss0+NMtRPzc8C6NP69++Pfv36oX79+oiLi5O6HEZCLFzyiOTkZFEP7eTHOdreDw8iglarhVqthlqthlar/WTA8DwPrVabbw+zcRyHlStXon79+mjQoAGeP38udUmMRCwyXPLjji23UlJSEB8fL9ryEhMTYWNjky/egw+9RiKCTqeDQqGAQqGATqeDRqP5YMDwPA+1Wg2dTge1Wp1vezoymQx//PEHmjRpgnr16uH06dP5ti3MydLa2CLDhTGcp6cnUlNTRfmAERGSkpLg5eUlQmXWI3Nvg4igVqshl8uFu0/a2dmB53nhNtGZ6R9vY2MDhUIBuVwOtVpt7pdgMWxsbLB+/XqMHTsW3bt3x6RJk/D27VuL2wHmBZb6BZCFSx6hnxI/uyG1RASNRgOlUpmjb9T6naydnZ34hVoomUwGrVYr/FvfRpnvUMlxHBQKxX8OjxERMjIyIJfLIZfLwXEcbGxsrOKeG6Ykk8kwevRoHDt2DOfPn0f9+vWxdu1axMfH5+t2yS9YuOQRHMfB2dkZr1+/zrLh6nQ6xMfH49WrV3j79i3evHmD169fIz09/YNzGL158wZOTk4W+43IFPRhAPx/GOuDIjN9cOgPf+l7LPrfZ55KHUCWwMqPOI5DrVq1cPz4cUyfPh2//fYb6tevj1mzZiE8PDzft09exsIlD/H09IRWq0VKSgp0Oh3S09Px6tUrqNVq+Pj4wNfXF4UKFYKDgwPi4uIQExOTpSdDRFCpVMjIyICnp6fEr8a8spvTKXOvJfPj5HI5bGxsoNFokJGRAeBdz/H9ILK1tc23J/bfZ2dnhy+//BJnzpzBvHnzcOnSJbRq1Qrdu3fHpk2bEBkZma/PU4nB0trOKmZFZnKG4zj4+PggNjYWycnJICK4uLjA1dVV2PHJZDK4urrC2dkZiYmJePXqFRwdHeHg4ACtVovExER4enrmiylfMuM4DjKZTNjBfWwwgz5g9LdIlslk2T5WJpMJh9GYd+3m5OSE7t27o3PnzggPD8fevXvx22+/4eeff4afnx8aNWqE+vXrS12q1bHEe1RZdLhYWmNZssznSQoXLgytVgtbW1thB/h+W8pkMhQsWBDOzs5ITU1FcnIyOI6Dp6cnHB0d88037sztYmtrC41GA5lMlqMLK7O7H3p+oFKpRFmOv78/xowZg2HDhiEyMhLnz5/HmTNncPDgQTRt2lSUdViS/PQZAQCOLOwVm7OcvHJO4UPnT8TGcRwcHR1Nvh5zMed8YnllGp2DBw+atCdGRFAqlXBxcUHHjh1Nth5zy4/7NRYueQBrM+OwdjMcazPj5Md2s7hwYUxPP8Ipu5PQzMfxPJ/vzkflRnp6Oh48eIDy5cvnqV6vOVjqHSZzKk9sJfnl/IBY1Go1Xrx4ka8v8jMGz/PIyMhgnzcDPHjwADVr1sSDBw+kLsWq6Oe0s+bv/nkiXBiGYRjLwsKFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYUTHwoVhGIYRHQsXhmEYRnQsXBiGYRjRsXBhGIZhRMfChWEYhhEdCxeGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYUTHwoVhGIYRHQsXhmEYRnQsXBiGYRjRsXBhGIZhRMfChWEYhhEdCxeGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYURn1eFCRIiLi0NUVBTi4uJARFKXZPH0bRYdHc3azAD6dnv69ClrtxwiIiQkJAAAEhISWJvlUJ7Zr5EVSkhIoKVLl5K/vz8BEH78/f1p6dKllJCQIHWJFoe1mXFYuxmOtZlx8lq7WV24HD58mJycnIjjOOI4LsuboP+dk5MTHT58WOpSLQZrM+OwdjMcazPj5MV2s6pwOXz4MMnlcpLJZFka//0fmUxGcrncqt4IU2FtZhzWboZjbWacvNpuHJF1HNBLTExE0aJFoVQqwfP8Jx8vk8ng4OCA6OhouLm5mb5AC8TazDis3QzH2sw4ebndrOaE/pYtW5Cenp6jNwAAeJ5Heno6fv/9dxNXZrlYmxmHtZvhWJsZJy+3m1X0XIgIZcqUQWRkpEEjJziOg5+fHyIiIsBxnAkrtDyszYzD2s1wrM2Mk9fbzSrCJS4uDl5eXrl6voeHh4gVWT7WZsZh7WY41mbGyevtZhWHxVJTU3P1/JSUFJEqsR6szYzD2s1wrM2Mk9fbzSrCxdnZOVfPd3FxEakS68HazDis3QzH2sw4eb3drCJcPDw84O/vb/DxRY7j4O/vj4IFC5qoMsvF2sw4rN0Mx9rMOHm93awiXDiOw4gRI4x67siRIy36pJepsDYzDms3w7E2M05ebzerOKEP5O3x4KbC2sw4rN0Mx9rMOHm53ayi5wIAbm5u2LVrFziOg0z28bJlMhk4jsPu3bst/g0wJdZmxmHtZjjWZsbJ0+1m7ikBciunc/AcOXJE6lItBmsz47B2MxxrM+PkxXazunAhejd76LJly7KdPXTZsmWUmJgodYkWh7WZcVi7GY61mXHyWrtZZbjo8TxPJ06cIAB04sQJ4nle6pIsHmsz47B2MxxrM+PklXazmnMu2eE4Tjj26ObmZvGjJywBazPjsHYzHGsz4+SVdrPqcGEYhmEsEwsXhmEYRnQsXBiGYRjRsXBhGIZhRMfChWEYhhEdCxeGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYUTHwoVhGIYRHQsXhmEYRnQsXBiGYRjRsXBhGIZhRGe14ZKamoqHDx/i9u3bAIDXr19DrVZLXJXlS01NxdOnTwEA9+/fx/Pnz1m7fYJGo8GLFy9w//59AMDjx48RHx8Pnuclrsyysc+a4fLSfo0jIpK6CENERkbit99+w759+/D8+XNoNBpkZGSgQIECqF69Ovr164cePXrAxcVF6lItSuZ2e/r0KZRKJRQKBZycnBAQEMDaLRuJiYnYtWsX/vjjD9y9excpKSlQq9Wwt7eHl5cXGjdujAEDBqBhw4awsbGRulyLwT5rhsuL+zWrCRedToe//voLkydPhlKpRPv27dG6dWsUL14cPM/j0aNHOHToEE6dOoUaNWpgxYoVqFixotRlS461m3EuXryI0aNH49atW6hduzY6duyIKlWqwNnZGYmJibh69SqCg4Px6NEjfP755/jll1/g5eUlddmSYp81w+XpNiMroNPpaNWqVeTk5ETt27enmzdvklarpQsXLtCyZcto2bJldP/+fVKr1RQSEkK1atWicuXK0e3bt6UuXVKs3Yxz5MgRKly4MJUpU4b++ecfSk9Pp8TERFq7di0tW7aMNm3aREqlkpKTk2n9+vXk6+tLrVu3ptevX0tdumTYZ81web3NrCJcTp06RW5ubvTZZ59RfHw88TxPRERTp04lAASAtm7dSkREPM/T06dPqUGDBtSoUSNKSEiQsHJpsXYzXHh4OJUqVYoqV65Md+7cEdrs8ePH5OrqSgCoVKlSFB8fT0Tv2u3MmTNUtGhR+vrrr0mlUklZvmTYZ81web3NLP6EvlKpxMyZM+Hj44Nff/0Vbm5u4Djug4/nOA7FihXDihUr8PDhQ2zbts2M1VoO1m6G0+l0mDNnDhISErBy5UpUrFjxo20GvGu3Ro0aYcGCBdi7dy8OHz5spmotB/usGS4/tJnFh8vVq1cRGhqKoUOHokiRIp/c2IF3b0S1atXQu3dvbN68Genp6Wao1LKwdjPco0ePEBwcjB49eqBRo0Y5ajPgXbt169YN9erVQ1BQELRarYkrtSzss2a4/NBmFj/E5fTp07Czs0OrVq1w//79LBvumzdvhP9/9uwZbt26Jfzbzc0N3bp1w7Zt2xAVFWU9J8FEwtrNcBcuXEBqaip69uyJqKgopKWlCX+Ljo6GTqcDAKjVaty9excFChQQ/u7r64sePXpgxowZeP36NYoWLWr2+qXCPmuGyxdtJvVxuU/5+uuvqWzZsvTw4UMqXrw42dvbCz82NjbCsUlbW9ssfwsMDKQnT56Qp6cnHTp0SOqXYXas3Qw3YcIEcnNzo/v371PLli2ztIudnZ3QZhzHZfmbg4MDrV69ms6ePUsuLi506dIlqV+KWbHPmuHyQ5tZdM+FiKBSqWBnZwe5XA6VSgWVSpXtYzUaDTQajfBvtVoNhUIhPC8/Ye1mHKVSCRsbG9jZ2SEjI+ODr1/fvplptVo4ODiAiJCRkWGOci0C+6wZLr+0mUWHC8dx8PT0RFhYGHQ6HZo3b47ExETh7xEREYiMjAQABAQEwNfXV/hblSpVkJiYiNTUVEybNg1nz55FvXr1ULduXRQrVizHx9OtkRjtplQqhcNA+YW3tzeUSiUSExNRt25dODk5CX9TKpW4cOGCECINGjQQLpzkOA7FixdHTEwMZDIZ3N3dpXoJZqXRaHDx4kU8fvwYiYmJRn/WMjIyULBgQXOXb1ZKpRLXrl3DxYsXERoaikOHDqFgwYJ5u82k7DblRFBQEDk4ONCZM2dIq9Vm+Zk8ebLQfdyyZUuWv+l0Otq8eTMVKFCAPvvsMypXrhwpFApSKBRUvHhx6tWrFy1evJjOnj1L6enpUr9M0eW23TiOIwBUpUoVmjhxIp06dYrUarXUL8tk1Go1bd26lWxtbWnt2rX/abOHDx8KQ5FLlixJcXFx/2m3iRMnUvHixent27dSvxyTef78OQUFBVGPHj2oQIECBICcnZ3Jzs7O6M9aoUKFKDo6WuqXJhqe5ykyMpL+/PNPGjFiBNWuXZtsbW0JADk6OlLTpk2pXbt2ZG9vn6fbzKJ7LgDQokULuLi4YMuWLahfv36WaTZkMlmW/5fL5cK/09PT8fvvv6NNmzbYvn075HI5YmNjcenSJVy6dAmhoaGYNWsW0tPTYWNjgypVqqBu3bpC76ZkyZJW3btp3rw5bG1tjW63zp07o3fv3jh69Cg2bdqE+fPnw8XFBa1atUK7du3Qvn17FCtWzKyvSWxEhKSkJMTGxiIhIQE+Pj4oXrw4tmzZgj59+mQ5YZ+5jTiOy9JuRISXL1/i77//hk6nw/fff4/OnTujffv28PDwMPvrEpNarca5c+dw+PBhHDp0CHfu3IFMJkO9evUwbtw4tG/fHm5ubmjYsKHRn7VGjRqhUKFCZn1dYkpLS8PVq1eFXsnFixeFk/KlS5dG/fr10b9/f9SvXx8BAQGwsbFBZGQk6tevn7fbTOp0+xSdTkejR48mFxcX2r9/v3ChEVH2Fxvpn7Nq1Spyd3enkJCQDy5bo9HQjRs3aN26dfTtt99SxYoVhd5NkSJFqEePHrRgwQIKCQmh1NRUk75OMUVHR1OHDh2Eb5W5bTedTkdXrlyhX375hRo2bEgymYwAUKVKlWjs2LF0/Phxq7p4MCMjg6Kjo+n69esUGhpKt27dotevX5NGo6GVK1eSnZ0dzZo1izQajfCcD11ESUSkVCrpu+++I19fX9q3bx/NnTuXWrduTc2aNaMpU6ZQaGgo6XQ6KV6qUaKiomjNmjXUtWtXcnZ2JgDk4+ND/fr1o+3bt/+nZ5abbdTGxoYmTZqU5TmWjOd5ioiIoK1bt9LQoUOpRo0aJJfLhW2tRYsWNHnyZAoODqbY2NgPLseU+zVLYfHhQkT06tUrql27NhUrVoyOHz8ubKjTpk0jGxsbsrW1pW3bthHP86TRaGjr1q3k6elJkydPJq1Wa9C64uLi6ODBgzR9+nRq27YteXh4kEKhIAcHB6pduzaNGDGCtm7dShERERa3QfA8Txs3biRXV1cqXLgwbd682STtFh8fTzt27KDAwEAqXLgwASAnJyfq3LkzrV69mp48eWKmV5xzPM9TQkIChYeH06VLlygsLIweP35MKSkpWR6XmppKvXv3JmdnZ1q8eDGlp6cTz/P0+PFj8vDwIBsbGypdurRwRXVSUhJNmDCBXF1daePGjcJyUlJSaPfu3RQYGEhNmjShXr160ebNmz+6w5GKSqWio0eP0ujRo6lChQoEgORyOTVu3Jhmz55N165d+2Q4GruNVq5cmQBQhw4dLPIwT0pKCp04cYJmz55NnTp1Ik9PT2HHX65cOerfvz+tXbtWmLrFEObcr0nBKsKFiOju3btUo0YNKliwIE2ZMoUePXpEDx8+pNOnT9Pp06fp6dOndOvWLRoyZAi5urrSsGHDKC0tLdfr1Wq1dPv2bfrtt99o0KBBVKVKFaF3U7hwYeratSvNmTOHTp48SUlJSSK8UuM8e/aM2rVrRwCoX79+wjdrU7cbz/N0/fp1mjt3LjVp0kT4FleuXDn64Ycf6MiRI6RUKk31sj9J30u5du1all7KxzbOmJgY6tWrFzk4OFC3bt0oJCSEYmJi6OzZsxQSEkIXL16k2NhYOnDgADVv3pzc3d1pxYoV2S6T53m6d+8ezZ8/n9q0aUPNmjWjH3/8kc6fPy/pDuLx48e0cuVK6tixIzk6OhIA8vX1pQEDBtDff/9t1PQixn7W9u3bR4ULFxYCWqovbTzP04MHD2jTpk303XffUZUqVYReeoECBah169Y0bdo0OnjwoGjn1XLaZoMHDxZ1v2YOVjMrMvDuQrZ69eohJiYGrq6uqFixIooVKwadToeoqCiEh4fDw8MDEydOxDfffAM7OzuT1JGQkIArV64gNDQUly5dQlhYGJKSksBxHCpVqoS6desKP2XLls1yDFVsRIQNGzZg7NixcHFxwbp169CxY8csj3nx4gVmzZqFHTt2wMbGxqTtlpSUhBMnTuDQoUM4dOgQXrx4AQcHBzRv3hzt27dHu3btULp06dy+7I8iIiQmJiImJgaJiYmQyWTw9PSEt7d3lhFgH5OWloagoCAsX74cb968gZ+fH8qUKQMXFxckJCQgPDwcL1++RM2aNTF9+nQ0bdr0k+9zWloajh8/juDgYERERMDLywsdOnRAx44d4ePjI8ZL/yClUomQkBDhfYmIiICNjQ0aNWokvC8BAQG5Ps9o7GctISEBY8aMwebNm9G2bVsEBQWZ/JxeUlISwsLChHMloaGhSEhIAMdxqFixIurVq4f69eujXr16qFChgsm240+12YMHD5CYmIjhw4dj0aJFJtuvic2qwuXw4cPo168fFi9ejBcvXiAsLAwxMTGwtbVFqVKl0Lx5c7Rp0wbe3t5mrYvneTx8+BChoaEICwtDaGgo7t27ByKCm5sb6tSpIwwWqFWrFtzc3ERZ77NnzzBw4EAcO3YM3377LRYvXvzBZet0Oty/fx8HDhwwW7sREe7evSvs0M6dOweNRoPSpUujffv2aN++PZo2bQpHR0dR1peRkYHY2FjExsZCrVbDyckJ3t7e8PDwyHJS1BCvX7/GiRMnEBISgsjISKhUKri7u6Ny5cpo06YN6tata1T94eHhCA4OxvHjx6FSqVC3bl106tTpPyd3jUVEwnTthw4dwunTp6FSqVCsWDGh7Vu0aJFl0IJYcvNZO3ToEAYNGoTk5GQsXrwYAwcOFGVgDc/zePDgQZaT7vpt1N3dHfXq1RPCpE6dOnB1dc31Og3xsTZr1qwZVq9eDbVajStXrljNQCOrCRciQuvWrVGgQAHs3r1b+J1OpwPHcUbvPEwlOTn5P72b+Ph4AECFChWy9G4M/VZERFi/fj3GjRsHNzc3BAUFoV27dgY9X4p2S0lJwcmTJ4Ud3rNnz2Bvb4+mTZsKI9DKli1r0MZDREhISEBsbCwSExMhl8vh4eFhUC8lp3Q6HYgIMplMtG+xSqUSJ06cQHBwMB48eAAPDw+hN1O4cGGDlpWWlobTp08L7RsZGQmFQoHGjRsLgVKhQgWz7pyM+awlJSVh7Nix2LBhA1q3bo2goCCUKFHCoPUmJCTg0qVLQphcunQJSUlJkMlkqFy5cpZeiamPLhgquzY7ffo0mjdvjn///Rddu3aVuMKcsZpwOXjwIL799lvs2bMH9evXl7ocg+m/SWbu3dy5cwc8z6NAgQKoVauWMAy6Tp06H7xA6smTJxg4cCBOnjyJwYMHY+HChSb59mlqRIQHDx7g0KFDOHz4MEJCQqBWq1GqVCkhaFq0aPHBgMjIyEBMTAxiY2Oh0Wjg7OwMb29vFCxY0OK+aOSUfuLMY8eOIT09HbVq1ULnzp0/eKfL99vwzJkzyMjIQMmSJYUwad68OZydnSV4Nbl35MgRDBo0CAkJCVi4cCEGDx6cbQjodDrcvXtX6JGEhobiwYMHAAAPDw8hROrXr4/atWtb1d0cM9NfbHnt2jWr6L1YRbjwPI9WrVrB3d0du3btkroc0aSmpuLq1avCdTeXLl1CXFwcAKBMmTKoV68e6tSpg3r16qF8+fIICgrCxIkT4eHhgd9++w2tW7eW+BWIJy0tDadOnRKup8juW3f58uWFcylJSUmQy+XCuRSxDq1ZApVKhVOnTmHfvn24d+8e3N3d0aFDB3Tq1AkFChTAiRMnhHZ6+vQp7Ozs0KxZM6N7f5YsOTkZ48ePx/r169G8eXNs2LABLi4uwjmSixcvIiwsDKmpqZDL5ahSpUqWMPH3988zbRESEoJmzZph9+7d6N69u9TlfJJVhMv+/fsxcOBA7N27F3Xr1pW6HJMhIjx58kQIm7CwMNy8eRNarRZEBK1Wi5o1a2LixIlo1qxZnr2tLhEhIiJC2IHqzxcUKlQI9erVQ4sWLdC5c2cUL17cog5nmMLjx48RFBSEf//9F2/evEFycjJ4noe/vz86dOiAdu3aoVmzZnkqXDPTarW4ffs2Nm/ejA0bNiA9PR36XZa3tzfq168vhEmtWrVEPxRqaVq0aIG3b9/i+vXrFv/Zt/hw4XkeLVu2hKenJ/7++2+pyzErnuexZMkSTJ06FU5OTggICEBkZKRw9a+fn59wKK1u3bqoXLkybG1tJa5aHDzPIyEhATExMYiJicGtW7dw7do1nDt3Do8ePcoy0ql9+/aoXLlynvmGmpycjOPHjwuHu6Kjo2Fvb4+AgADY29tDpVKhcOHCaNeuHTp16mT1MyVk9ubNmyy9ksuXLwuzaAQEBAhhU7duXWzbts3kIw8tzdmzZ9GkSRPs2rULPXr0kLqcj7L4cNH3Wvbt24c6depIXY7ZREREYMCAATh79iyGDx+OuXPnwtnZGUSEZ8+eZend3LhxAxqNBg4ODqhVq5ZwKK1u3bomH+IqNqVSKYz40mq1cHFxEc6l6L+pPX78WOjVnDx5EkqlEkWKFBEOC7Vq1crso31yg4hw69Yt4US8foLMcuXKCeHZuHFjODg4AACioqKwf/9+HDlyBMnJyahWrRo6d+6MJk2aQKFQSPxqck6j0eDmzZtZRnA9efIEAFC4cOEsvZKaNWsKr//UqVMYMGAAXr9+jblz52LEiBEW/y1eTK1atUJMTAxu3Lhh0a/bosOF53m0aNECPj4+2LFjh9TlmIVOp8Py5csxZcoU+Pr6YsOGDWjatOlHn6NSqXD9+vUs86a9fPkSAFCiRAlhGHSdOnVQtWpVi9sB8TyP+Ph4xMTEICUlBTY2NvDy8oKXl5ewQ/kQlUqFs2fPCt/y79+/D7lcjgYNGgjXb1SrVs3iejWJiYk4duyYUPerV6/g5OSEFi1aCHWXKlXqo8tQq9U4c+YMgoODcePGDRQoUEDozRg6usocXr58meWk+5UrV6BSqaBQKFCjRo0sI7g+NXN5amoqJk+ejBUrVqBRo0bYuHEjypQpY8ZXI53z58+jUaNG+Pvvv/HZZ59JXc4HWXS47Nu3D4MHD0ZwcDBq164tdTkmFx4ejsDAQISGhmLkyJGYPXu20ceQX7x4IQwSuHTpEq5duwa1Wg07OzvUqFFDOJRWr169LFN6m5NSqURMTAzi4uKg1WpRoEABeHt7w93d3ehvZFFRUUKv5sSJE0hLS0OhQoXQrl07tGvXDm3atJFkSnye53Hjxg2hdxIaGgqdToeKFSsKvZNGjRoZfYHcs2fPsH//fhw+fBhJSUkICAhAly5d0LRpU0kuusvIyMD169ezhMmzZ88AAMWKFcty0r169epG13jmzBl8++23ePHiBWbPno1Ro0ZZ7WhBQ7Rp0wavXr3CzZs3Lbb3YrHhor/Pga+vL7Zv3y51OSal0+mwZMkSTJs2DcWKFcPGjRvRqFEjUdeRkZGBmzdvCsOgL126JGzsRYoUES4iq1OnTq429k95v5dia2srjPiyt7cXdV36GX31vYPMM/rqD6HVqFHDZBvn27dvcfToURw+fBhHjhzBmzdv4OzsjFatWgm9k+LFi4u6To1Gg7NnzyI4OBjXrl2Ds7Mz2rZti86dO3+yJ5Qbz58/zxIkV69eFb7M1KpVSwiTevXqoUiRIqKuOz09HVOmTMGyZctQr149bNy4EeXLlxd1HZbmwoULaNiwIXbs2IHevXtLXU62LDZc/v33XwwZMgQHDhxAzZo1pS7HZO7fv4/AwECEhYVhzJgxmDlzptlG/rx69SpL2Fy9elU4TFGtWrUsvZuiRYvm6tBSenq60EvR6XRwdXUVeinmOmT1/PlzHD58GIcPH8axY8eQkpICLy8vtG3bFu3bt0ebNm3g6elp9PJ5nseVK1eEnlNYWBh4nkeVKlWEMGvQoIHZDku+ePEC+/fvx6FDh5CQkIBKlSqhc+fOaN68ea6CXKVS4erVq1nC5MWLFwCAkiVLZumVmPMw7Pnz5xEYGIhnz55h1qxZGDNmTJ7uxbRt2xbR0dG4deuWRb5OiwwXnU6HZs2aoVixYvjzzz+lLscktFotFi1ahBkzZqBkyZLYtGmT5BeHajQa3Lp1K0vg6E+w6ocB6wOnRo0anzwfwvM83r59i5iYGKSmpsLW1lY4lyJ2L8VQGo0GFy5cEILg5s2b4DgOderUEYKgVq1an9xoY2NjceTIEaF3EhcXB1dXV7Ru3Vo4FCf2N3VDaTQanD9/Hvv378fly5fh5OSE1q1bo3Pnzp8cbUVEePr0aZaT7pkHkNSuXTtLr0Tqe4wolUpMmzYNS5YsQa1atbBp0yZUrFhR0ppMJTQ0FPXr18f27dvx+eefS13Of1hkuOzZswfff/89Dh06hOrVq0tdjuju3LmDwMBAXLt2DePGjcOMGTM+uaOWSkxMTJawuXLlijA0tGrVqllGpulvsJaWloaYmBi8ffsWOp0Obm5u8PLyMmsvxVAvX77EkSNHcOjQIRw9ehRJSUnw8PBAmzZt0L59e7Rt2xbe3t7Q6XQICwsTDrVduXIFRITq1asLoVSvXj2LHRL+8uVLHDhwAAcPHkR8fDwqVKiATp06oWXLlnBwcEB6ejquXLmSZTLH169fA3h346vMJ90DAgIs9nWGhoYiMDAQkZGRmDFjBsaPHy/KnG2Wpn379nj69Clu375tcb0XiwsXnU6Hpk2bokSJEvjjjz+kLkdUGo0GCxYswM8//4wyZcpg48aNVndRqFarFaba0IfOo0ePALybaqNSpUooX748qlatiiZNmqBEiRJWM4urnlarxaVLl4ST79euXQMAuLu7Q6lUQqVSwc3NLcvhNEPnAZOaVqvFhQsXsG3bNpw9exZpaWngeR6vXr0Cz/NwdnYWvjjUr18fdevWtbqLdlUqFWbMmIGFCxeiRo0a2LRpEypXrix1WaIKCwtD3bp18eeff6JPnz5Sl5OFxYXLrl27MGzYMBw+fBjVqlWTuhzR3Lp1C/3798etW7cwYcIETJs2TfJDQ2JIS0vDgwcPcO7cOdy+fRvh4eG4e/cu0tLSIJfLERAQkGWSTmuYjkOr1SI0NFQIl+vXrwMAChYsCKVSCaVSCXd3d7Ru3Vro1VhDuKSmpuLy5ctZeiWxsbEA3h32tLOzg0KhQEBAAL755hu0bt06T1zxHhYWhsDAQERERGDatGmYOHGixfa4jNGxY0dERkbizp07FtV7sahw0Wq1aNq0KUqVKoVt27ZJXY4o1Go15s6di9mzZ6NcuXLYtGkTatWqJXVZuaLT6RAXF4eYmBikp6dDoVDAy8sL3t7eUCgUwvTh+mHQly5dyjKRYOZDabVq1bKIiQRfvHghHBY7duyYcFgsc+9Ef1js8uXLQvDoD4tVq1ZNGAFWv359yXdeRCTcBkIfJrdv3xYmStUP1ND3SgoWLAidTodLly4hODgYoaGhUCgUaNWqFTp37oxy5cpZ/JeCj8nIyMDMmTMxf/58VKlSBZs2bULVqlWlLksU+t7Ltm3b8NVXX0ldjsCiwuXvv//GiBEjcOTIkTzxxt+4cQP9+/fHnTt3MHnyZEyZMsXqDhFllpqaKpxL0d+rxtvbG66urp/c8SQkJODy5cvCRZ6XL1/OcoO1zJN0lilTxuRj9/UnufUn9G/duiWc0Ndfd1KzZs0cndA/evQoDh06JJzQL1CgQJYT+kWLFjXpawH+/8ZX+jC5dOmScIuHihUrZhnBlZNbPMTGxuLgwYPYv38/YmJiULp0aXTu3NnqezNXr15F//798eDBA0ydOhWTJk2yuIuKjdGpUydERETg7t27FnNuyWLCRavVokmTJihdujR+//13qcvJFbVajV9++QVz585FpUqVsGnTJqsdmPB+L8XOzk4Y8ZWbjZLneYSHh2fp3WS+eVPt2rVFv8Ha8+fPhRPxx48fR0pKCry9vbP0Tjw8PHL1mq5evSqs49KlS+B5HgEBAcLJ/oYNG+Z6Z/axG1+5ubllOelep06dXLUdz/MICwvD/v37cf78edja2goTh1asWNEqezNqtRqzZ8/GnDlzULFiRWzevNlqt0+9K1euoHbt2ti6dSu+/vprqcsBYEHhsnPnTowcORLHjh1DQECA1OUY7erVqwgMDMT9+/et+ptRSkoKYmJiEB8fL+zwvby8ctRLMVZSUpJw/UTmG6xxHIfy5cv/5xYEn/r2nZGRkeUiyrt370Imk6F+/frCzr569eomvYjy2LFjwrU1+osoW7ZsKfSOcnIRpf7GV5l7JVLc+CouLg6HDh1CcHAw3rx5g1KlSqFz585o06aNRRzaNNT169cRGBiIO3fuYNKkSZg6dapVH1no0qULHjx4gHv37llE78UiwkWr1aJx48YoV64cNm/eLHU5RskLx3S1Wq3QS1EqlbCzs4O3tze8vLwkOYeQ+QZr+t5N5husZe7d1K5dGwULFkRUVJQQJvrpX/QzCLdr1w6tW7eWdPoX/WG4ixcvCtO/6IOucePGsLGxwb1797L0SjKfr9IHiZQ3vtL30IKDg3Hu3DnI5XI0a9YMXbp0sbrZqdVqNebNm4dZs2ahfPnyVn1O9Nq1a6hZsya2bNmCvn37Sl2OZYTLjh07MGrUKKvttVy+fBn9+/e32tEo2fVS9OdSLE1KSgquXbsmBE5oaCji4uLA8zxsbGyQkZEBjuNQvXp19OzZEx06dEDVqlUtboeXmJiI48ePY8+ePTh8+DDi4+Mhk8nAcRx0Oh1kMhmqVq2apVdSunRpi3sd8fHxOHToEPbv34+XL1+iRIkS6NSpE9q1a2dVd0i9desWAgMDcfPmTUyYMAHTp0+3yl5Mt27dcPfuXdy/f1/y3ovk4aLRaNCoUSNUrFgRmzZtkrIUg2UeR1+9enVs2rTJasJRq9UiNjYWMTExUKlUsLe3h7e3Nzw9PS0+GB8/fiyM1jp58iRUKhXc3d3h6+sLtVqN6Oho6HQ6ODs7o2bNmlluHy3ltRr6e5FkHsEVEREB4N0w50KFCkGpVOLZs2fQ6XQoW7ascPisSZMmFnuhLfCuN3P9+nUEBwfj7Nmz4DgOTZs2RefOnS0y3LPz/nVomzZtsrrbfFy/fl24pqd///6S1iJ5uPz1118YPXo0Tpw4gUqVKklZikEyXwH8888/Y9y4cZJ/U8iJ5ORkoZcCvNupeXt7W/S3zPT0dISEhAiB8ujRI9ja2ma5WVilSpWEHVh6ejquXr0qjJ4KDQ1FTEwMgP/eYC0gIMBk71tMTEyWw1uZb3xVrVq1LCO49LMbAO/eoxMnTgivNzo6Gg4ODmjWrJkw3NmSp5dPTEzE4cOHERwcjOjoaBQrVkzozYgxMMPU3p9B4+eff7aqa9K6d++OW7du4cGDB5J+UZQ0XDQaDRo2bIiAgABs2LBBqjIMolQq8dNPP+HXX3+1mrmLNBqNcC4lcy/Fy8vLIgNRf42G/vxESEgIVCoVihcvLoRJixYtcny+4WM3WHN0dETNmjWzXOhpzA3W9De+ytwriYyMBPDxG1/lpPZ79+4JQXP27FloNBr4+/sLQdO8eXOLvM0xEeHmzZsIDg5GSEgIiAiNGzdG586dTTqQQgz6uf+mT5+OUqVKWcTcfzl18+ZNVKtWDRs3bkRgYKBkdUgaLn/++SfGjBmDkydPWvwOGng36+q3336Lp0+fYtasWRg9erRF7pz1kpKSEBMTg4SEBHAcJ/RSLHFkT1paGk6ePCkEypMnT6BQKNCkSRMhUMqXLy/a4RWlUonr169n6d28evUKwLsbrGXu3VSpUuU/I/5evXqVpVeiv/GVra0tatSokaVX8qkbXxkiNTUVJ0+eFMLm6dOnsLOzQ9OmTYWBAZZ4wWNSUhKOHDmC4OBgPHv2DL6+vujcuTPat28vyQCLnLp37x6+/fZbhIWFYfTo0Zg1a5ZFBvn7evbsievXryM8PFyy3otk4aLRaNCgQQNUrVoVv/32mxQl5Jg13S9Co9EI51IyMjLg4OAgnEuxpCAkIty/f18Y2XXmzBmo1WqUKlVKCJPmzZub9YK96OjoLL0b/Q3W7O3tUbp0abi5uSEjIwNPnjwR7vRZrFixLCfdq1evbrZDKESE8PBwoQ1DQkKQkZGBkiVLCkHTokULODs7m6WenCAi3LlzB/v27cOpU6fA8zwaNWqEzp07o2bNmhbZm9HpdPj1118xdepUFC9e3CT3WxLbrVu3hH3rgAEDpCmCJLJ161by8fGhe/fuSVVCjoSEhJC/vz/Z29vT4sWLSavVSl3Sf/A8TwkJCRQeHk6XLl2isLAwevToESUnJ0tdWhbJycm0Z88e+u6776h48eIEgOzt7aldu3a0dOlSCg8PJ57npS6Tnj17Rjt37qQRI0ZQ5cqVycbGhgAQAOI4juRyOfn4+FDXrl1p2bJldPHiRVKpVFKXTampqbR//34aPnw4+fv7EwBSKBTUsmVLWrhwId25c8ci2lcvKSmJ/vnnH+rXrx81adKEevfuTb///jvFxsZKXVq2Hjx4QA0aNCCO42jUqFGUmpoqdUkf1bNnTypZsiRlZGRIsn5Jei4ajQb16tVDjRo1EBQUZO7V50haWhomTZok3KN7w4YNKFu2rNRlZaFWq4VeilqthqOjo9BLsYQJ7Oh/31L136zPnTsHjUaDMmXKCOcLmjZtKulhBpVKhWvXruHixYs5uvHV27dvs8wqkN0N1vSH1HJ7g7XcioiIEA4znjp1CiqVCsWKFRN6NS1btrSIgRz0v/NKwcHBOHnypHAutlOnTqhTp45F9WZ0Oh2WL1+OKVOmwNfXFxs2bEDTpk2lLitbt2/fRpUqVbB+/XoMGjTI7OuXJFy2bt2KCRMm4PTp0yhXrpy5V/9Jp06dwoABA/D69WvMmzcPw4cPt5gPOBFlOZcik8ng4eEBb29vizj8kZSUhOPHjwuB8uLFCzg4OKBFixZCoPj7+0tSG/3vxleZT7pfv349Vze+ev8Ga6GhoYiKigLw7kS+Pmzq1KmToxusmYpSqcSZM2eEczUPHz6EjY0NGjZsKLwvVapUkfxcTWpqKo4fP459+/bh8ePH8Pb2RqdOndChQweLmvI/IiIC3377Lc6dO4fhw4dj7ty5FrH9va93794ICwvDw4cPzT5TiNnDRd9rqVWrFtatW2fOVX9SSkoKJk6ciDVr1qBJkybYsGHDJ+/UZy5qtRoxMTGIjY0Veik+Pj7w8PCQtJdC/xsRpN9pXbhwATqdDuXLlxfOnTRu3FiSoZz6G19lDhP9ja/8/f2z9ErEvPFVTExMlt7N+zdYy3z76JIlS4qyTkNFRkYKvZqTJ08iPT0dvr6+Qq+mVatWkg4bJiI8ePAA+/fvx/Hjx6FWq1GvXj107twZdevWtYieOc/zWLlyJSZNmgQfHx/89ttvaNGihdRlZXH37l0EBARg7dq1GDx4sHlXbu7jcH///TcVKlSIwsPDzb3qTxowYAA5OTnRypUrSafTSV1OFjdu3KDLly9TZGSkRR3rffHiBQEgJycn6tKlC61Zs4aePHkidVlERLR9+3ahtubNm9PkyZNp3759FBMTY9Y6NBoNXb9+ndauXUuBgYFUsWJFUigUVKVKFbPW8SEqlYqOHTtGY8aMoQoVKhAAGjx4sNRlCVJTU2nv3r00cOBAatKkCR09elTqkrJ49OgRNW3alORyucV89jP7/PPPqXTp0mbfp+W652Lo04kIWq3WqG+JhnbZjanNmPUY8xxDa9Mf1zfm8Jypa8sNQ2oz9v00dD3GPN6Y2ogoX7+fgOG1paenw97e3uTtlpfazJz7tcxyPTb14MGDnyxAp9NBp9Pleor2Tp06GfScPXv2GB1khuB5Hj179jToOQkJCdDpdAZ175VKpaGlAXh3Fb4h9uzZ88H3VKfTQaPRiHKYy9B2+1hduaVUKoXzIca8n3v37jVJbfqLXvV4nkf37t0NWsaePXug0WhMfszdmHY7e/Zsjh5HRFCr1UbP90VEBp14N/SzxvM8VCoV7OzsDNqmjWkzMbYDtVoNnuc/uh0bU1sWue36zJgxgzQazQd/IiIiqHfv3tSmTRv666+/PvrYj/1Mnz7d4NrGjx9Pbdq0oQMHDhi93pz8jB071uDanj59Srdu3aL79+9TdHQ0paSkkFarJZ7nRf15+vSpwbWNGzcu29d5584dateuHdWoUYPWrFmT63YbM2aMQXWNHz/eJO/fsWPHqFq1ajRnzhyj388ff/xR9LpmzZpF9erVo7i4OOF3EyZMMLi2cePGUZMmTej8+fMm3Q4MfT+JiFavXv3J5T58+JAmTZpE3377Lc2ePZtev35tcG0rV640uM1ystyMjAzatWsXdezYkapWrUotW7akjRs3klKpNFmb5WY7uHPnDo0ZM4bq1atHtWrVomnTppFKpcr2scZsB5mJclXdhy7OS01NRdeuXdGtWzdUq1YN48ePh6OjI7p06SLGanPkq6++Qp8+fZCYmCj5SJj3lSxZEmlpaUhJSUFsbKxwIy53d3fJT1i+/56+evUKjRs3Rr9+/dC/f3/07dsXpUuXRqtWrSStK7d4nkeXLl3w66+/4vvvv8eYMWOMXpaYtalUKvzyyy9o2bIl+vbtiwMHDuRqeZUqVcLgwYNx584dkSoUz8faLTIyEqNGjUKHDh3QpUsXHDlyBEOHDkVQUJDBPXIx6wLeTREzdOhQHDhwACNGjED16tXx8OFDzJw5E8HBwfjrr79MNrOyoZ81nuexZMkSLFy4EM2bN8eoUaNga2uLSZMmISoqCps3bxZ9/2iyS7aJCF9++SWqVauGX375BcC7wzP9+vVD69atczwkU6PRIDEx0eg6vvnmGwQGBgoT6FkSFxcXODs7w8fHB2q1GgkJCXj58iVev36NIkWKwM3NzSICkYjQpEkTfPbZZ1iyZAmAd4fHunbtitTUVIuo0VhBQUFwdHTE4MGDMW/ePMyZM0fqkgAAM2bMgL+/P37//XcUKVIk18ubO3cu3NzcQERW836p1WqMHDkSffr0wddffw2O41C7dm0sXLgQw4cPxx9//CHZayEifPPNN8I1UiVKlADHcWjXrh369OmDDh06oGvXrjh06JDk7a3VajFgwACcPn0a27dvR9OmTYVzVk2aNEHhwoUxZswY0e8/ZbKLN06cOIEbN25gw4YN4DgOHMehRYsWqFatGoYNG5bj5dy+fRvt27c3ug6O4/DFF1+gV69eRi/DlPRtY2dnBx8fH1SsWBGenp6IiorC48ePoVarzXpyMTurV69GXFwc1qxZI9Tbp08fAO+O/1orIsLo0aOxbds2cByHoKAg7Nu3T+qyAAArV67Eli1bhG/nOp0uV8vTXyyZkpKS69rMgYgwa9YsFClSRAgWAJDL5Rg/fjzS0tLw119/SVbf4sWLceTIEZw/fz7LjNYcx8Hb2xunTp3CtWvXMGvWLMlqBN61Y79+/YTh+M2bN88yGMLLywszZsxAhw4dRF+3KOHC83yWHaBGo8HAgQOxatWqLCeMOI7D1q1bcfDgQahUqhwtW39Vd26sXbsWYWFhku+kP4XjONjY2AghQ0S4e/cukpKSJKtdq9Vi1KhROHz4cJZDdRzHYcOGDejXr5/Ft+uHZGRkQKVSoW3btgCAFi1a4PTp09IWhXfbk1arRc2aNYXPxNWrV3O1TI7jULZsWUyfPl2kKk3ryZMnOHfuHBYtWvSfb/5yuRxLlixBUFAQtFqt2Wt7+fIlJkyYgFOnTsHT0zPbx7i4uODMmTOYMWOGcG2VuRERJk2ahFOnTuHcuXPw9fXN9nGTJk3Cq1evjB4w9CGihMsPP/yAu3fvAnj3gsaMGYOSJUtmO7rL3d0d5cqVw08//ZSjZZ89ezbXN+BydnaGQqFASEhIrpZjLvqeTOnSpeHr64vHjx/j1atXkuzEx40bh1KlSmV706TPP/8cqampSE5ONntdYpg3bx6KFy8u7LxkMplF3H3z/PnzUCgUQl21atXCihUrcr3c9evXY/Xq1bleDvD/Q6lNQd+jHDhw4Adn8Pbz8xMuXDQnIkLLli0xaNAgVKlS5aOPLVeuHAIDA9GqVStJtt19+/Zh6dKlOHv27EdnN5DL5fDz88PMmTNFXb8o4eLn54evvvoKSqUSe/bswd69e/HPP/988Fjj1q1bsW3bthw1+N27d9G8efNc1cdxHKZMmWIR95U2hL6LXa5cObx+/RpPnz4164dUo9Fg+fLlOHr0aLbvpf4Y+NChQ81Wk5gWLFiA9evXS13Gf4wbNw5ffPGF8O9BgwbhyJEjuV5u48aNc32YlYhw9epVBAYGYtiwYSb5Vv7XX38J52w/hOM4zJ8/Hzt27DDrNnHt2jVERERg1apVnzyXwnEc1q5di3v37uHhw4dmqvCdmJgY9O7dGzt27MjRdEubNm3Cr7/+KmoNooTLyJEj4e7ujs8++wyTJ0/G5s2bP9hdBN5NU25jY4PLly9/ctkJCQlo2LBhrmucOHEioqOjre4QDsdxcHZ2RqVKlZCUlITIyEizvYaxY8eidOnSH52i5K+//hJ2BtaEiKBSqcw+2i0nbt68meXwVbt27UTpHcpkMtja2iI0NNToZYSFhaFZs2YoWLAg3r59i/r164t6aComJgZBQUH49ddfP7nzLl68OGxsbHDlyhXR1v8xRISOHTtizpw5OR6tZWtri/Hjx6Ndu3Zm20aICM2bN8eXX36Z45G5jRo1Ev38rijhIpPJsG/fPnz33XfYt2/fJ3saHMdh7Nix+O677z65bCISZf4lhUIBhUKBc+fO5XpZUrCzs0PFihWRmppqloDRaDRYuXLlB3sten5+fiAiJCQkmLQesZ07d87oGQ9MSf++Zj4+LuaQ2wEDBhg9Q64+jOfNm4fFixfjzz//hI2NTa6Gb+uXS0RISUnB8OHD0a1bN/j5+X3yeRzHYdiwYaIfzvmQ6OhoxMTEYNy4cQY9b/bs2YiKisrVqFdDzJ07F7GxsQgKCsrxSDWO4yCTyRARESFaHaJtWQUKFECXLl1QtmzZHL2gYcOG4dWrVzkaBSPWWPHx48ejX79+oixLCra2tqhYsSKSk5Px/PlzkwbM6NGjUbZsWZQoUeKjj9MfGhsxYkSOl63T6YR72ostp+cCBg8ejCFDhpikhtx48uSJMCJPT///Yrzfc+bMwd27d42aQuTzzz9HQEAAhg4dCo7jIJfLcfz4caxYsSJXtf30009YtWoVhg0bBj8/P4wYMSLHO8XOnTsjOTnZLCf2u3btim+++cbgLyQ2NjZo0aIFvv76axNV9v8iIyPx008/4dSpUwZfC9OgQQNMmTJFtFok+9pma2uLAgUK4J9//vngY/QfWLHGiU+ZMgVRUVFWdwgnM1tbW1SoUEGYIdlUr8Xb2xtHjhzJUdtv3boV27dvz3Etx44dM8md/FJTUzF79mwsW7YMGRkZH3wc/e8Ojj///LPoNeTWtGnTULdu3Wz/JsZ7rZ/pOD093aDnvX79Gvv27fvPdRvFixeHo6Mj9u7da3RN/fv3h1arRffu3fHLL78YtPOWy+Xw8PDAjh07jF5/TvA8j+vXr2PNmjVGPX/79u04ePCgSfc9Wq0WTZs2xfjx4426bfzs2bNFHYov6TGBefPmfTQpczu2/3329vaQy+W4efOmqMs1N3t7e5QrVw5RUVEG7yRy6qeffkLx4sVz9NiyZcuC5/kcD2UcM2aMMPxXLESEFi1a4MSJE9iyZQs6d+4MnuezfWxSUhIAWMSNst63d+9ezJs3L9u/xcfH53r5HMehVKlSmD17do6fQ0Ro27YtAgMD/zOajuM4LFq0yOBDRZlVqlQJo0aNQrdu3Yya5WDy5MnYtGmT0evPia1bt8LV1dXoG9t5enqadMQqEQnvz5w5c4z6Qt6gQYNcX/aRmaTh0q1bN6Smpn4wRKKiokS/unXgwIFWN2osO87OzihevDgePHggeggD+M+hmU89tlSpUjm+YOz+/fuiX2+xePFiREVF4dChQzhz5gzu37//wS8u48aNQ9WqVSW/cvp9RASNRpPtsG+FQiHal6L169cLMy3kRGxsLG7fvv3Bb+2DBg3CoUOHclWTIZ+399WsWRMajUbUHeP7RowYkav7T3Ech+nTp4t2aOzOnTvCtYI8z2PWrFk4cOAATp8+bfR5RP3zPvSlzODlibIUY1cuk6FAgQLYvXt3tn8PDg7O0d0ADbFgwQLcuXPHqg+NAe8+rD4+PnByckJ4eLjkr2fLli052mHpdwAeHh6irVun0+HHH3/EkSNHYG9vDxcXF4SEhGDBggXCXSH1iAhbtmzB77//Ltr6My87N+9DXFwcAGS7cyhSpAhOnjxp9LIza9GiBTIyMnK8E+natSt69er1wXOfNjY2KFOmjCi1GYPjOHh6emL79u0mWb5Op0NKSkquZ/kYP348Xrx4Icq2OnbsWLRv3x7//PMP+vXrhzVr1uDMmTMfHaX7KfqAf/ToUa7rAyQOFwCYOXMmpk6dmu3fdu/eLfq0BM7OzpDJZLh//76oy5WC/qprpVJpshPkOaUfyvipb4+bN2+Gu7u7qL2GhQsXwtvbG9WqVRN+5+fnh9GjR6N58+ZZNmb9rQ4qV64s2vr1vvvuOzx9+vSjj/nYjmX69OkfrKtWrVqijXSUyWRwdHTM0fH1tLQ0hIaGYvPmzaKs21QmTZqELVu2mGTZ27Ztg6ura65HFtra2sLOzk6UWSB27dqFKlWqYNmyZXBwcEBoaKgon+kyZcpg7dq1uV4OYAHh0qtXLyQlJWX7Lerx48fCHFZi4TgOAwYMMGq5aWlpOH36NDZv3owjR44gNTVV1NqMIZPJUK5cOTx9+tSkhwU+RX/B58qVKz/6uAkTJmDRokWirZeI8NNPP2Hfvn3/Caz58+cjNTUVCxcuFHbqffr0Qdu2bU1ySCwkJOSDO2Eiwr59+zBt2jSEhoZmGzJbt279YPs1a9YM4eHhotU6e/bsHF0K8M0336Bhw4ZGn2swF1MeGhs9erRon9nx48cjMDAw18txdnbG0qVLcfz4caxbt+6TozpzavDgwfjzzz9FWZbk4SKXy2Fvb48TJ0785288z6N8+fKir3Px4sW4fft2jrunRIQDBw6gcePGGDJkCP766y+MHTsWjRs3zvWcT2JwcnKCp6cn7t+/L+nhsY0bN350gAYRITExUdRzXmfOnIFcLkfNmjX/8ze5XI4TJ05gypQpOHToEO7cuYNjx46ZbMLDb7/9Flu3bs32bzt27EBgYCDevn2Lrl27YuPGjVneK5VKBY1G88GRYg0aNMj1NEiZDRs2DDExMR89NKZWq7Fnzx78+++/oq3XVPSHxsR+b/XXcPXv31+U5U2ePFm0mTb000SJ+UWpT58+oh0FkTxcgHffZseOHZvld/rGN8V9TZycnODg4ID9+/d/8rE8z2PatGno27cv+vfvj/Pnz2P//v04d+4cunfv/sFDeuakP6GuVqsRGxsrWR0dOnSAUqn84KSk+/fvh4ODg2j3PSEi9OrVCwsWLPjgBhYQEICNGzfi22+/Rdu2bTFt2jRhOK7Y+vXrhxcvXvzn9xkZGRg4cCB27tyJVatWYceOHRg7diy2bt0qfM7HjBmDSpUqffB1lCtXLtf3dMnM1tYWzs7OH70U4IcffkCFChVydRzfnKZOnYrff/9d1C9Yjx8/FiYPFYN+It83b96IsjyxiXmO2yLCZeDAgf/5FvX8+fNcjSD5GI7jsGLFik/O6MvzPL777jts2bIFp06dwogRI+Dh4QFbW1u4ubnhp59+wq5du0SvzxgcxwnDk00xeiynNZQvXx7jx4/P9u/9+/c3aJTSp8TGxiIuLg7Dhw//aE1ff/218KXAlLMC+/j4APjveZXBgwcjICAALVq0AMdxaNq0Kfbs2YMffvgBy5YtQ0hICDZt2vTRHoJMJhP9NsVr1qzBoEGDst0G1Go11q5dm+tRYOZUrVo1aDQaUQ9XDx8+HG3atBFteRzHoW7durme1cBUxLxg1yLCRaFQwNHRMcs3s/nz54t+85rM+vfvj8TERDx//jzbv/M8j6FDh+Lo0aO4cOECqlSp8p+g4zjOoo5FOzs7w8XFBREREZIdHtu9ezdWr179n/UnJCQgPj7e6KlHstO9e3d89tlnnzzRynEc/P39Ub16dZMOP9Yv++XLl8Lv0tPTsWPHDuzduzfLPT+aNWuGvXv3YufOnRg6dCjmz5+PokWLmqy27Hz55ZdITk4WRqll9t1336Fy5co5vtbJEnAchxo1agg3JxTDsWPHRJmROrO1a9di586doi5TbGJcP2cR4QK8C5MxY8YIO6W9e/ea9K6AMpkMQ4YMyXZCOZ7nMWbMGOzbtw8XLlww+0ZvLP3oseTkZNHvzZBT5cuXh729fZbDLUSE7t27o1OnTqId5oyPj8fFixdNfvGcoRo2bJjlEG/fvn3RqFEjeHt7Z3kcx3Fo3Lgxjh8/jtOnTxs05YlYZDIZevbsia5du2bZBp4/f47Nmzd/cl45SzR9+nSEhoYK08HoJyg1BhGB53mULl1azBJRtWpV6HQ6yS8f+BBbW1uEhYXlejkWEy49e/ZEamoqIiIikJaWBq1Wi+rVq5t0ncuWLcOTJ0+yTF2iVCoxbNgw7Ny5E+fPnxflFrPmJJfLUbRoUTx48ECSDy/Hcdi+fTv69u0rBNyVK1dw9uxZUU626q8lad++PT777DM4OTnlepliCgoKwt69e0FEiIyMxP79+z96XsPR0RFeXl6S7cR///13hIaG4tatWwDeDSxo0qQJRowYIfo1Zubg6uqKkiVLYsmSJSAihISEfPAw7afcuXMHcrlc9PdGPy/bnTt3RF2uWCpWrCjKiDFxzlKJQCaTYdy4cfjss89Qvnx5NG7c2OQbnK2tLfbu3Yvu3bsjMjISvr6+WL9+PVQqlXBfbGtUuHBhvHz5MtvDHebQqVMn1KlTB23atMGgQYMwYsQILF26FM7Ozrle9qpVq/Dy5Us8evQIZ86cEaFacZUqVQoeHh6YNWsWNm3ahAkTJphsAIEYHB0dsWDBAjRv3hwrV67E2rVrUahQIdHv7WEuHMdhyZIl6N27N8qVK4eVK1dixowZuHHjhsHLGjdunKjnWzJr3749fvjhhyzXZlmKnj17Yt26dfj8889ztRxRwsXYbuf7hg4diqdPn+LVq1dYt26dKMv91DKaNGmCv//+GytWrEBqairat2+PoUOHwtnZWbTX9SFiTbOQndKlSyMmJibLbaYNkdvX/u+//2Ls2LFYs2YNfv75ZwwaNEiU9gwJCUF8fDxOnDiRq0MepqCv5cCBAxg9ejS6du2KSZMmWUSNH6th+PDhyMjIwPLly1G9enXMnj3b5NOpZPaxSUaN4ezsjOnTp2P79u3o0aMHatWqZVS48DyPuXPnmuT9mzNnTo7vxpsdU36mOnXqhOPHj+d6ORzl8tjJ8ePHDRqdRETQarWwtbX94N95nv/PsXm5XG7wjZ0OHjyY46m4dTodeJ7/YF0fI5fL0bFjR4Oek5iYaPLDVkQEmUxm8DdnQ9rtU+vXaDQfHOVkaLsdPHgQarUaPM+LNjRUjLoA4PDhw1naTKPRfPSzZOyM33K5HO3btzfoOTl9P9Vqda5GpBnTbqGhoSYb3ajVaoXPiUwmQ/369XP83IMHD0KlUpnksJiefn9jaJuJtX1+iH4fbW9vb3BtmeU6XAx9ukqlQnJyMhQKBZycnAzamRv6Jhtam74nYcwQaFPXRkTIyMgw6qIpU9eWG4bUZshFr5n/a4nvp0ajgU6ng1wuh42NjUHryyvvJ2DcNqpSqWBvb2/wdCym+KyJwVRt9v52YMz0NbkJ1lyf0NdvuDn9sbOzw6VLl9CtWzcUL14cX3zxBS5fvpyj55q6tuTkZNSrVw9eXl64ceOGQc81dW1KpRK3bt2CUqk0+Lmmqm3z5s2Qy+UYMmQIiMjguozZ4X/sh+d5/Pnnn6hUqRLkcjm6dOmCK1euQCaTWUyb6X/UajVWr16NUqVKoUCBAhg2bBiePXtmEbXdunULXl5eqFWrFhISEiyq3R4/fowOHToIFzdK9VnT/xARBg4cCLlcjm3btpl8G8hJbSkpKZgzZw68vLzg4OCAkSNH4uXLl2apLQuSiE6no3379lHTpk3Jx8eHevXqRaGhoVKVI0hISKDatWuTu7s7Xb16VepyBKmpqRQaGkqpqalSl0JERBs2bCCO42jIkCGk0+kkrUWj0dDWrVupbNmyBIA6duxIly5dkrSmnEpJSaHFixdTkSJFyNHRkYYMGUJPnjyRuiy6efMmeXp6UvXq1ent27dSlyMIDw+nJk2aUHh4uNSlkE6no8DAQJLJZLR161apy6HExESaNWsWubu7k0KhoGHDhtHz588lq0eycNHT6XQUHBxMzZs3Jx8fH+rZsyddvHhR0poSExOpTp065O7uTleuXJG0Fj1LCpegoCACQN9//z3xPC9ZHRqNhrZs2UJlypQhANS5c2e6fPmyZPXkRmpqKv36669CyAwePJgiIyMlrenWrVvk6elJ1apVo7i4OElr0bOUcNFqtdS/f3+SyWT0xx9/SFpLYmIi/fzzz+Tm5kZ2dnY0YsQIio6OlrQmIgsIFz2dTkcHDhygFi1akI+PD3Xv3p3Onz8vWT2JiYlUt25dcnNzs4gdlqWEy7p16wgADRs2TLJg0Wg0tGnTJipdujQBoK5du1pULzM30tLSaNmyZVS0aFFycHCggQMH0qNHjySr5/bt2+Tl5UVVq1al2NhYyerQs4Rw0Wq11LdvX5LJZPTnn39KVkdCQgJNnz6dXF1dyd7enkaOHEkvXryQrJ73WUy46Ol0Ojp48CC1atWKfHx8qFu3bnTu3DlJdmRJSUlUv359cnV1pbCwMLOvPzNLCJe1a9cSABoxYoQk74daraaNGzeSn58fAaBu3brRtWvXzF6HOaSlpdHy5cupWLFi5ODgQAMGDKCIiAhJarlz5w55e3tTlSpVJA8YqcNFq9XSN998Q3K5nLZv3y5JDfHx8TRt2jQhVH744Qd6+fKlJLV8jMWFix7P83T48GEhZLp06UJnz541+04tKSmJGjRoQK6urpIex5c6XNasWUMAaOTIkWZ/D9RqNf32229UqlQpAkA9evSgGzdumLUGqaSnp9PKlSupePHiZG9vT4GBgfTw4UOz13H37l3y9vamgIAAiomJMfv69aQMF61WS1999RXJ5XLasWOH2df/9u1bmjp1KhUoUIAcHBxozJgx9OrVK7PXkVMWGy56PM/T0aNHqXXr1kLIhISEmHUHl5ycTA0bNqQCBQpINuhAynBZtWoVAaBRo0aZtd0zMjJo/fr1VLJkSQJAn332Gd28edNs67ckSqWSVq9eTSVLliR7e3vq168fPXjwwKw13L17l3x8fKhy5cr05s0bs65bT6pw0Wg09OWXX5JcLqedO3eadd1xcXE0ZcoUcnFxIQcHBxo7diy9fv3arDUYw+LDRY/neTp27Bi1bduWfHx8qFOnTnTq1Cmz7eySk5OpUaNG5OLiIsmAA6nCZeXKlQSARo8ebba2zsjIoHXr1lGJEiWI4zjq1asX3bp1yyzrtnRKpZLWrFlDpUqVIjs7O+rbty/dv3/fbOu/f/8+FSpUiCpVqiRJwEgRLhqNhr744guysbGhf/75x2zrjY2NpUmTJpGzszM5OjrS+PHjJQt1Y1hNuOjxPE8nTpyg9u3bk4+PD3Xo0IFOnjxplh1fSkoKNW7cmFxcXOjChQsmX19mUoTL8uXLCQCNHTvWLO2rUqlozZo1VLx4ceI4jj7//HO6c+eOyddrjVQqFa1du5b8/PzIzs6Ovv76a7p3755Z1q0PmIoVK5r9G7S5w0Wj0dDnn39ONjY2tGvXLrOsMyYmhiZOnEhOTk7k5OREEydOlPRQpLGsLlz0eJ6nkydPUocOHcjHx4fat29PJ06cMPlOMCUlhZo0aULOzs507tw5k64rM3OHy9KlSwkAjRs3zuRtqlKpaPXq1VSsWDHiOI769OlDd+/eNek68wqVSkXr168nf39/srOzo6+++sosbffgwQMqXLgwVahQwazH/c0ZLmq1mnr16kU2Nja0e/duk68vJiaGJkyYQE5OTuTs7Ew//vij5AMocsNqw0WP53k6deoUderUiXx8fKhdu3Z07Ngxk+4QU1NTqVmzZuTs7Exnz5412XreX6e5wuXXX38lADRhwgSTtqNSqaSVK1dS0aJFSSaT0Zdffmm2b995TUZGBgUFBVHp0qXJzs6O+vTpQ7dv3zbpOsPDw8nX15fKly9vtoAxV7io1Wr67LPPyNbWlv7991+TruvNmzc0btw4cnR0JBcXF5o8ebLFXFeUG1YfLno8z1NISAh16dKFfHx8qE2bNnT06FGT7RxTU1OpefPm5OTkRGfOnDHJOt5fnznCZcmSJQSAfvzxR5O1nVKppOXLl5Ovry/JZDL6+uuvzX5yOq/KyMigDRs2UJkyZUihUNDnn39u0vNVDx8+pCJFilD58uXNMhzWHOGiVqupZ8+eZGtrS3v37jXZel69ekVjxowhBwcHcnFxoalTp1rUbAi5lWfCRY/neTp79qwQMq1bt6bDhw+bZEeZlpZGLVq0ICcnJwoJCRF9+ZmZI1wWLVpEAGjSpEkmaa/09HRatmyZECp9+/aV/ErrvEqtVtOmTZuobNmypFAoqHfv3iYbaRcREUFFixalsmXLmvwiPlOHS0ZGBnXv3p1sbW1p3759JlnHq1evaPTo0eTg4EAFChSgn376KU+Fil6eCxc9nufp3Llz1K1bN/Lx8aFWrVrRwYMHRd9ppqWlUcuWLcnR0ZFOnz4t6rIzM3W4LFiwgADQlClTRG+j9PR0+vXXX6lQoUIkl8upX79+klyrkR+p1WravHkzlS9fnhQKBX322Wd0/fp10dfz6NEjKlasmMkDxpThkpGRQd26dSOFQkHBwcGiL//ly5c0atQosre3J1dXV5o+fTrFx8eLvh5LkWfDJbMLFy5Qjx49yMfHh1q0aEEHDhwQdbLF9PR0atWqFTk6OtKpU6dEW25mpgyX+fPnEwD66aefRA2WtLQ0Wrx4Mfn4+JBcLqfAwEBJpzLJzzQaDf3+++9UoUIFUigU1KNHD9FnN3j8+DEVK1aMypQpY7K5rUwVLhkZGdS1a1dSKBR04MABUZcdHR1NI0aMIDs7O3Jzc6Off/6ZEhISRF2HJcoX4aJ38eJF6tmzJ/n4+FDz5s0pODhYtJBJT0+n1q1bk4ODA504cUKUZWZmqnCZO3cuAaBp06aJFiypqam0aNEi8vb2JhsbGxowYAA9fvxYlGUzuaPRaGjbtm1UsWJFUigU1L17d1HnZXv8+DEVL16cSpcubZIZeU0RLiqVijp37kx2dnZ08OBB0ZYbHR1Nw4cPJzs7O3J3d6eZM2dSYmKiaMu3dPkqXPRCQ0OpV69e5OPjQ82aNaN9+/aJEjLp6enUtm1bcnBwoOPHj4tQ6f8zRbjMnj2bANCMGTNEWV5qaiotWLCAvLy8yMbGhgYOHCj5zL5M9jQaDf3xxx9UuXJlUigU1LVrV9EmaI2MjKQSJUqQv78/PXv2TJRl6okdLiqVijp16kR2dnZ06NAhUZb57NkzGjp0KCkUCipYsCD98ssvlJSUJMqyrUm+DBe9sLAw+vzzz8nHx4eaNGlCe/fuzXXIKJVKateuHdnb29OxY8dEqlT8cPnll18IAP3888+5XlZKSgrNmzePPD09ydbWlgYPHmwR9yRhPk2r1dJff/1FAQEBpFAoqHPnzqLMoffkyRMqWbIk+fn50dOnT0Wo9B0xw0WlUlHHjh3Jzs6ODh8+nOvlPX36lL7//ntSKBTk4eFBc+bMoeTk5Fwv11rl63DRu3z5Mn3xxRfk4+NDjRs3pj179pBWqzV6eUqlktq3b0/29vZ09OhRUWoUM1xmzpxJAGjmzJm5Wk5ycjLNnTuXPDw8yNbWloYMGUJRUVG5ro8xP61WSzt27KAqVaqQQqGgTp065XoevaioKCpZsiSVKlVKtM+FWOGiVCqpQ4cOZG9vT0eOHMnVsqKioui7774jW1tb8vDwoLlz5+brUNFj4ZLJlStXqE+fPuTj40ONGjWiXbt2GR0ymb8V5fbDSyReuMyYMYMA0C+//GL0MpKSkmj27NlUsGBBUigU9P3334v67ZSRjlarpZ07d1K1atVIoVBQhw4dcjXV0dOnT6lUqVJUsmRJUQJGjHAR6+jCkydPaNCgQWRra0uenp40f/58SklJMXp5eQ0Ll2xcu3aNvvrqK/Lx8aEGDRrQP//8Y1TIZD6em9tutxjhMn36dAJAc+bMMer5SUlJFnUbVcZ0dDod/fPPP1S9enVSKBTUrl07o6c7evbsGfn5+VHJkiVzfbg0t+GiVCpzfV40MjKSBg4cSDY2NuTt7U0LFy6U/CZ+loiFy0dcv36dvv76ayFkdu7cSRqNxqBliDUSJTfhwvM8TZs2jQDQ3LlzDX5+YmIizZw5k9zd3cnOzo6GDx/OQiWf0Ol0tHv3bqpRowYpFApq27atUVMePXv2jPz9/alEiRK5GuSRm3BJT0+nNm3aGD2i8/Hjx/Ttt98KobJo0SIWKh/BwiUHbt68SX379iUfHx+qX78+7dixw6CQEWMMvbHhwvM8TZ06lQDQ/PnzDXpuQkICzZgxg9zc3CzyNqqM+eh0OtqzZw/VqlWLFAoFtW7d2uBZKZ4/f06lS5em4sWLGz003dhw0V8qYMy1aBEREdS/f3+Sy+VUqFAhWrJkCaWlpRm0jPyIhYsBbt26Rf379ycfHx+qW7cubd++Pcchk/nq3/379xu8bmPChed5mjJlCgGghQsX5vh51nIbVcb8dDod7d27l2rXrk0KhYJatWplUMhER0dTmTJlqFixYkYFjDHhkpaWJlzkbMgsGg8fPqR+/fqRXC6nwoUL09KlSyk9Pd3gmvMrFi5GuH37NgUGBpKPjw/VqVOH/vzzT1Kr1Z98Xm7mLTI0XHiep0mTJhEAWrRoUY6e8/btW/rpp5+E26iOHj3aom+jykiH53kKDg6mOnXqkEKhoJYtW+b45n3R0dFUtmxZKlq0qMEzNhgaLsbM/xceHk7ffPMNyWQyKly4MC1btoyFihFYuOTCnTt3aMCAAeTj40O1a9embdu2fTJkjJ1x1ZBw4XmeJk6cSABoyZIln3y8td5GlZEez/O0f/9+qlevHikUCmrevHmO7qv04sULKleuHBUpUoQiIiJyvD5DwsXQmcvv379PX331FclkMipSpAitWLGClEpljmtjsmLhIoJ79+7RwIEDycfHh2rWrElbt279aMgYc6+InIYLz/M0YcIEAkC//vrrRx9r7bdRZSwHz/N08OBBatCgASkUCmratCkdP378oyHz8uVLKl++PBUpUiTHE5nmNFwMuefSvXv36MsvvySO46ho0aK0atUqFioiYOEiovv379OgQYOoUKFCVKNGDdqyZcsHQ8bQu9zlJFx4nqdx48YRAFq2bNkHHxcbG0s//vgjOTs7k5OTE02YMMEqb6PKWB6e5+nw4cPUsGFDUigU1KRJk4/eV+nVq1dUvnx58vX1zVFvJCfhktO7xd69e5e++OIL4jiOihUrRqtXryaVSvXpF8nkCAsXE3jw4AF99913VKhQIapevTpt2rSJMjIy/vM4Q+7P/alw4XmexowZQwBoxYoV2T4mr91GlbFcPM/TkSNHqHHjxqRQKKhRo0YfvK/S69evqWLFilS4cOFP3jTuU+GSkpJCjRs3JhcXFzp//ny2j7l9+zb17t2bOI6j4sWL09q1a1momAALFxN6+PAhff/991SoUCGqVq1atiGj0Wjoiy++IBsbG/rnn38+uKyPhQvP8zR69GgCQCtXrvzP3zPfRtXZ2TnP3EaVsXw8z9OxY8eoadOmpFAoqGHDhnTo0KH/hEzmgLl///4Hl/excElOTqZGjRqRi4tLtrMK3Lp1i3r16kUAqESJErR+/fpsv/Qx4mDhYgYRERE0dOhQKly4MFWrVo02bNiQ5ZuSRqOhPn36kFwup507d/7n+TzPU1RUFO3evZuioqKybJg8z9OoUaMIAK1atSrL816/fk1jx44V7s09ZcoUFiqMJHiepxMnTlCzZs1IoVBQ/fr16cCBA1k+y2/evKFKlSpRoUKF6N69e9kuIzQ0lOrUqUOhoaFZnpucnEwNGzakAgUK0MWLF7M87+bNm9SzZ08CQCVLlqSgoCAWKmbAwsWMHj16RMOHD6fChQtT1apVKSgoSDhxqNFo6KuvviK5XE47duwgoncXMS5dupT8/f0JgPDj7+9PS5cupfj4eBo5ciQBoDVr1gjryS+3UWWsD8/zdPLkSWrRogUpFAqqV68eBQcHC0ERExNDAQEB5OPjQ3fv3iWiT28HT58+pQYNGpCrq2uWGZ2vX79O3bt3JwBUqlQp2rBhQ44uGWDEwcJFAo8ePaIRI0aQr68vValShdavX09KpZK0Wi198803JJfLadKkSeTk5EQcxxHHcVk2Kv2/bWxsCACtW7eOiPLfbVQZ68XzPJ0+fZpatWpFCoWC6tSpQ/v27SOe5ykmJoaqVKlC3t7etG7duk9uBzKZjJycnCgsLIyI3s0N2K1bNyGANm7cyEJFAixcJBQZGUkjR44kX19fCggIoLVr11JKSgq1atUqy8bzsR+O4+iPP/6gkSNHkr29Pbm5udGMGTPyxW1UmbwhJCRECJnatWvTv//+S2/evCE/P78cbwcymYxWrFhBXbp0IQBUunRp2rx5s8FzATLi4YiIwEgqKioKy5Ytw86dO+Hq6opHjx5Bo9EYtAxXV1eMHTsWI0eOhKurq4kqZRjTOXv2LH755RecPn0aFStWxL1796BWqw1ahr+/P6ZPn44+ffrAxsbGRJUyOcHCxYI8ffoU/fr1Q0hIiMHPnTdvHiZOnGiCqhjGvM6dO4dBgwbhwYMHBj93yZIlGD16tAmqYgzFwsWCEBHKlCmDx48fG/Q8juPg5+eHiIgIcBxnouoYxjzYdpA3sHCxIHFxcfDy8srV8z08PESsiGHMj20HeYNM6gKY/5eampqr56ekpIhUCcNIh20HeQMLFwvi7Oycq+e7uLiIVAnDSIdtB3kDCxcL4uHhAX9/f4OPF3McB39/fxQsWNBElTGM+bDtIG9g4WJBOI7DiBEjjHruyJEj2UlMJk9g20HewE7oW5jExEQULVoUSqUSPM9/8vEymQwODg6Ijo6Gm5ub6QtkGDNg24H1Yz0XC+Pm5oZdu3aB4zjIZB9/e2QyGTiOw+7du9kGxeQpbDuwfixcLFDbtm1x4MABODg4gOO4/3Tz9b9zcHDAwYMH0aZNG4kqZRjTYduBdWPhYqHatm2L6OhoLF26FH5+fln+5ufnh6VLl+LFixdsg2LyNLYdWC92zsUKEBHi4+ORkpICFxcXFCxYkJ20ZPIdth1YFxYuDMMwjOjYYTGGYRhGdCxcGIZhGNGxcGEYhmFEx8KFYRiGER0LF4ZhGEZ0LFwYhmEY0bFwYRiGYUTHwoVhGIYRHQsXhmEYRnQsXBiGYRjRsXBhGIZhRMfChWEYhhEdCxeGYRhGdCxcGIZhGNH9H3LLiw4XXbpjAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='forward_n', beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e92f7c7a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='forward_u', beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "68e99753", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='backward', beta=100)" - ] - }, - { - "cell_type": "markdown", - "id": "9e788b91", - "metadata": {}, - "source": [ - "Remove insignificant neurons" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ed4800ea", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAuQ0lEQVR4nO3de1jUdd7/8dfnO8hJQA4iqEgKouIBFQQ8gIc0UdFbxdvW3EOlXZdZ5ubdXm3r3f1Ta93KzVutrC3b+0532+g2zLNimmcREFEUQSUkRRRRGQIGZoaZz++PZC4pU5TvMAdej+vqn8YZ3pZfn/P5HoWUUoKIiEhFiq0HICIi58O4EBGR6hgXIiJSHeNCRESqY1yIiEh1jAsREamOcSEiItUxLkREpDrGhYiIVMe4EBGR6hgXIiJSHeNCRESqY1yIiEh1jAsREamOcSEiItW52HoAIkcgpcStW7dQU1MDLy8vBAQEQAhh67GI7BZXLkT3odVqsWbNGkRERCAwMBA9evRAYGAgIiIisGbNGmi1WluPSGSXBJ9ESXRv6enpmDFjBnQ6HYAfVy+NGlctnp6eSEtLQ1JSkk1mJLJXjAvRPaSnpyM5ORlSSpjN5l/8dYqiQAiBHTt2MDBEd2FciH5Cq9UiJCQEdXV19w1LI0VR4OHhgdLSUvj6+lp/QCIHwGMuRD+xfv166HS6ZoUFAMxmM3Q6HTZs2GDlyYgcB1cuRHeRUiIiIgLFxcV4mE1DCIGwsDBcvHiRZ5ERgXEhauLmzZsIDAxs0fsDAgJUnIjIMXG3GNFdampqWvT+6upqlSYhcmyMC9FdvLy8WvR+b29vlSYhcmyMC9FdAgICEB4e/tDHTYQQCA8Ph7+/v5UmI3IsjAvRXYQQeOmllx7pvQsXLuTBfKI7eECf6Cd4nQtRy3HlQvQTvr6+SEtLgxACinL/TaTxCv1NmzYxLER3YVyI7iEpKQk7duyAh4cHhBA/293V+O88PDywc+dOjB8/3kaTEtknxoXoFyQlJaG0tBSrV69GWFhYk9fCwsKwevVqXL16lWEhugcecyFqBikl9u/fj7Fjx2Lfvn0YM2YMD94T3QdXLkTNIISwHFPx9fVlWIgegHEhIiLVMS5ERKQ6xoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhIiLVMS5ERKQ6xoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhegCj0YirV6+ioKAAAPDdd9/h9u3bMJvNNp6MyH7xMcdEv0Cr1SItLQ2ff/458vPzUV1dDYPBAHd3dwQGBiIxMRFz587FiBEj4OLiYutxiewK40J0DxkZGVi0aBHy8vIQGxuL5ORkREVFwcvLC1qtFjk5Odi2bRuKiorwq1/9Cn/+858RGBho67GJ7AbjQvQTe/bswTPPPAMvLy+89dZbmDRpEgwGA1JTU6HX6+Hj44NZs2bBaDQiNTUVS5cuRb9+/fCPf/wDQUFBth6fyC4wLkR3uXDhAiZMmID27dsjNTUVffv2hRACxcXFiI6ORlVVFXr06IGcnBz4+flBSokjR45g9uzZGD16ND799FO4ubnZ+rdBZHM8oE90h8lkwl/+8hdUVlbigw8+sITlfoQQSEhIwIoVK7Blyxbs3r27laYlsm+MC9EdRUVF2LZtG1JSUpCQkPDAsDQSQmDatGkYOnQo1q1bh4aGBitPSmT/eIoL0R3Hjh1DTU0NZsyYgZKSEtTW1lpeKy0thclkAgAYDAbk5+fDx8fH8nqXLl2QkpKCpUuX4vr16wgJCWn1+YnsCeNCdEdhYSE8PT0RFhaGefPm4ejRo5bXpJTQ6/UAgLKyMjzxxBOW14QQWLlyJQYMGACdToeysjLGhdo8xoXojrq6Ori4uMDNzQ16vR719fX3/HVSyp+91tDQAA8PjyYRImrLGBeiOzp16oS6ujpotVrEx8ejffv2ltfq6upw7NgxS0SGDx9uuXBSCIHQ0FDcuHEDiqLAz8/PVr8FIrvBuBDdERMTA6PRiKysLLzzzjtNXisuLkZsbCyqqqoQFBSEL7/8Er6+vpbXhRBYvHgxgoODuUuMCDxbjMgiLi4OYWFhWL9+PWpra6HRaJr800gIAUVRLP9eURRcu3YNX331FZKTk9GhQwcb/i6I7APjQnRHQEAAFixYgJMnT+K9995r9inFer0eb775Jurq6jBv3rxmn8JM5My4W4zoLs888wwOHTqEd955B56enpg/fz7c3d0BAC4uLnBxcbGsYqSUqK6uxvLly5GamopVq1ahd+/ethyfyG7w9i9EP1FRUYEXX3wR27dvR1JSEhYtWoTIyEicP38eZrMZrq6u6NmzJ7KysvDuu+/i1KlTeOONNzB//vwmu8+I2jLGhegeamtrsW7dOrz33nsoLy9HWFgYIiIi4O3tjcrKSpw/fx5lZWWIiYnBkiVLMGrUKCgK9zITNWJciO7j+vXr2LdvHw4ePIjTp08jKysLiYmJGDFiBMaPH4/4+Hh4enraekwiu8O4EDVTdnY24uLikJ2djSFDhth6HCK7xnU8UTNpNBrLachEdH/cSoiISHWMCxERqY5xISIi1TEuRESkOsaFiIhUx7gQEZHqGBciIlId40JERKpjXIiISHWMCxERqY5xISIi1TEuRESkOsaFiIhUx7gQEZHq+DwXomaSUsJsNkNRFAghbD0OkV3jyoXoIfBZLkTN42LrAYjUYDQacfnyZZjNZluP0mJCCISGhsLV1dXWoxA9MsaFnEJpaSleeOEFxMTEwGQyAfjxyZGOKCcnBx9++CHCw8NtPQrRI2NcyClIKTFgwAAkJibi73//O2bMmIFZs2bZeqxH8tprr4GHQsnRMS7kNKSU+Pzzz/H111/j1q1bmD59Otzd3W091kNhVMhZ8OgkOQ1FUfD000/D1dUVWVlZyM7O5l/WRDbCuJBTGT58OAYOHIj6+np89tlnTnGAn8gRMS7kVDw9PfH0009DCIEdO3agpKTE1iMRtUmMCzmdqVOnIiQkBBUVFUhNTeWuMSIbYFzI6XTu3BkzZ84EAPzzn//E7du3bTwRUdvDuJDTEULg6aefhq+vL4qKirB9+3auXohaGeNCTqlPnz6YMGECzGYz1q1bB51OZ+uRiNoUxoWckkajwbx58+Du7o4TJ05g//79XL0QtSLGhZySEALx8fEYOXIkjEYjPvroIxgMBluPRdRmMC7ktFxdXTF//ny0a9cOBw4cQEZGBlcvRK2EcSGnJYTA2LFjERcXh/r6enzwwQdoaGiw9VhEbQLjQk7N09MTL774IjQaDdLT05GVlcXVC1ErYFzIqQkhMGnSJMTExECn02HNmjVcvRC1AsaFnJ6XlxcWLlwIjUaDXbt28dgLUStgXMjpCSEwZcoUxMbGQqfT4b//+7955hiRlTEu1Ca0b98e//Ef/4F27dphz549+Pbbb7l6IbIixoXahMZjLyNHjoRer8eKFSt41T6RFTEu1Ga4u7vjj3/8Izw8PHD06FGkpaVx9UJkJYwLtRlCCIwcORJTp06FyWTC22+/jfLycluPReSUGBdqU1xcXPCnP/0JHTt2xIULF/D+++/zaZVEVsC4UJsihEDfvn3x/PPPAwA+/vhjnDx5krvHiFTGuFCboygKFixYgP79+6OyshL/7//9Px7cJ1IZ40JtUseOHbF06VK4u7tj7969WL9+PVcvRCpiXKhNEkIgOTkZTz31FEwmE5YvX46zZ88yMEQqYVyozXJxccGSJUvQq1cvXL9+HX/4wx9QXV1t67GInALjQm2WEAIhISF4++234eHhgW+//RbvvvsuTCaTrUcjcniMC7VpjbvHXnjhBUgpsWrVKmzevJm7x4haiHGhNs/FxQWLFy/G448/Dp1Oh5dffpmnJxO1EONCBKBDhw744IMPEBERgbKyMsydOxfFxcUMDNEjYlyI8OPusYiICHz88ccIDAzEmTNn8Oyzz+Lq1asMDNEjYFyI7mi899jatWvh4+ODo0eP4ne/+x0DQ/QIGBeiuwghMH36dLz33nvw8vLCwYMHMWvWLBQVFTEwRA+BcSH6CUVRMHv2bKxduxYdOnRARkYGpk+fzscjEz0ExoXoHjQaDWbPno3/+Z//QXBwMAoKCpCSkoLPPvsMBoOBkSF6AMaF6BcoioKpU6ciLS0NAwYMQEVFBV544QXMnz+fx2GIHoBxIboPIQTi4+Oxbds2zJw5E2azGZ999hnGjh2LL774AnV1dYwM0T0wLkQP0HibmP/93//F6tWrERwcjKKiIsyZMwczZszAkSNHYDQaGRmiuzAuRM0ghICHhweef/557N27FzNnzoSiKEhPT8ekSZPwm9/8BhkZGTweQ3QH40L0EIQQ6NOnDzZs2ICvvvoKI0aMgMFgwFdffYWkpCTMnDkTu3btQm1tLSNDbRrjQvSQhBBwdXXFxIkTsWvXLmzYsAFDhw6FwWDA9u3bkZKSgscffxwfffQRrly5ArPZzNBQm8O4ED0iIQTat2+PJ598Env27MHGjRuRlJSEdu3a4cSJE1i4cCGGDh2KuXPnIj09HVqtFlJKhobaBMaFqIUaIzNlyhRs3rwZe/fuxbx589C5c2eUl5djw4YNmDp1KoYOHYrf//732Lt3L27fvs0VDTk1F1sPQOQsGneXxcfHIzY2Fq+//jp2796N1NRUZGVl4eLFi7h48SI+/vhjhISEYNiwYRg/fjyGDh2Kbt26wd3d3da/BSLVMC5EVqAoCrp06YJnn30Wv/nNb1BUVIRdu3Zh27ZtOH36NEpKSlBSUoLU1FR4eXkhPDwccXFxSE5OhtlstvX4RC3GuBBZUeNqpm/fvoiMjMRLL72EkpISHDp0CHv27EF2djauXbuGU6dO4dSpU9Dr9ejYsaOtxyZqMcaFnI49H8do164dIiIiEBERgTlz5qCyshIFBQU4duwYjh07hokTJ+LEiRO2HpOoxRgXcgpCCJw5cwbLli2z9SiPLCoqCnl5eTh9+jSEELYeh6hFhLTnr3lEzWQwGFBcXAyTyWTrUVpMURSEh4fD1dXV1qMQPTLGhYiIVMfdYkTNdPf3MO62Iro/XkRJ1Ey5ubnQaDTIzc219ShEdo9xISIi1TEuRESkOsaFiIhUx7gQEZHqGBciIlId40JERKpjXIiISHWMCxERqY5xISIi1TEuRESkOsaFiIhUx7gQEZHqGBciIlId40JERKpjXIiISHWMC1EzSClRWVkJAKisrAQf4Ep0f4wL0X1otVqsWbMGERERGDduHKSUGDduHCIiIrBmzRpotVpbj0hkl4TkVzCie0pPT8eMGTOg0+kA3Psxx56enkhLS0NSUpJNZiSyV4wL0T2kp6cjOTkZUkqYzeZf/HWKokAIgR07djAwRHdhXIh+QqvVIiQkBHV1dfcNSyNFUeDh4YHS0lL4+vpaf0AiB8BjLkQ/sX79euh0umaFBQDMZjN0Oh02bNhg5cmIHAdXLkR3kVIiIiICxcXFD3VGmBACYWFhuHjxouV4DFFbxrgQ3eXmzZsIDAxs0fsDAgJUnIjIMXG3GNFdampqWvT+6upqlSYhcmyMC9FdvLy8WvR+b29vlSYhcmyMC9FdAgICEB4e/tDHTYQQCA8Ph7+/v5UmI3IsjAvRXYQQeOmllx7pvQsXLuTBfKI7eECf6Cd4nQtRy3HlQvQTvr6+SEtLgxACinL/TaTxCv1NmzYxLER3YVyI7iEpKQk7duyAh4cHhBA/293V+O88PDywc+dOjB8/3kaTEtknxoXoFyQlJaG0tBSrV69GWFhYk9fCwsKwevVqXL16lWEhugcecyFqBikl9u/fj7Fjx2Lfvn0YM2YMD94T3QdXLkTNIISwHFPx9fVlWIgegHEhIiLVMS5ERKQ6xoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhIiLVMS5ERKQ6xoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhegCj0YirV6+ioKAAAPDdd9/h9u3bMJvNNp6MyH7xMcdEv0Cr1SItLQ2ff/458vPzUV1dDYPBAHd3dwQGBiIxMRFz587FiBEj4OLiYutxiewK40J0DxkZGVi0aBHy8vIQGxuL5ORkREVFwcvLC1qtFjk5Odi2bRuKiorwq1/9Cn/+858RGBho67GJ7AbjQvQTe/bswTPPPAMvLy+89dZbmDRpEgwGA1JTU6HX6+Hj44NZs2bBaDQiNTUVS5cuRb9+/fCPf/wDQUFBth6fyC4wLkR3uXDhAiZMmID27dsjNTUVffv2hRACxcXFiI6ORlVVFXr06IGcnBz4+flBSokjR45g9uzZGD16ND799FO4ubnZ+rdBZHM8oE90h8lkwl/+8hdUVlbigw8+sITlfoQQSEhIwIoVK7Blyxbs3r27laYlsm+MC9EdRUVF2LZtG1JSUpCQkPDAsDQSQmDatGkYOnQo1q1bh4aGBitPSmT/eIoL0R3Hjh1DTU0NZsyYgZKSEtTW1lpeKy0thclkAgAYDAbk5+fDx8fH8nqXLl2QkpKCpUuX4vr16wgJCWn1+YnsCeNCdEdhYSE8PT0RFhaGefPm4ejRo5bXpJTQ6/UAgLKyMjzxxBOW14QQWLlyJQYMGACdToeysjLGhdo8xoXojrq6Ori4uMDNzQ16vR719fX3/HVSyp+91tDQAA8PjyYRImrLGBdq8y5duoQDBw7g8OHD0Ol00Gq1iI+PR/v27S2/pq6uDseOHbNEZPjw4ZYLJ4UQCA0NxY0bN2AymXDlyhXo9XqeNUZtGk9Fpjbn8uXLOHjwIPbv348DBw7g+++/hxACPXr0wKVLl7B27Vo899xzTd5TXFyM2NhYVFVVoXv37jhx4gR8fX0trwshsHjxYqxZswahoaHw8PDAoEGDEBsbi/j4eERFRcHV1bWVf6dEtsO4kNO7evUqDhw4YPmnuLgYADBw4ECMGjUKY8aMQWJiIsxmMxISEuDn54fdu3c3OWD/S9e5AD/uJisrK8OoUaMwZcoUzJs3D1lZWcjKykJ2djaqq6vh7u6OQYMGIS4uDnFxcRgwYADatWtnk/8eRK2BcSGnc/369SYxuXjxIgCgf//+lpiMHDkSAQEBP3vv2rVr8corr+D111/Ha6+9Ztn1db+41NfX4+WXX8a2bdvw7bffonfv3pbPM5lMOH/+vCU2J06cQE1NDdzd3REdHY24uDjEx8ejX79+vD8ZORXGhRzejRs3cPDgQUtMCgsLAQCRkZFNYtKpU6cHflZtbS3mzJmDnTt3YtmyZZg/fz7c3d1x6dIlxMXFWXaLZWVlwdfXF9XV1Vi+fDk+/vhjrFq1Cs8+++x9P99kMqGgoACZmZnIyspCTk4OdDodPD09ER0djfj4eMTHxyMyMhIajUaV/z5EtsC4kMO5efMmDh06ZIlJfn4+AKBXr16WmIwaNQrBwcGP9PkVFRV48cUXsX37diQlJWHRokWIjIzE+fPnYTab4erqip49eyIrKwvvvvsuTp06hTfeeAPz589/6CA0NDQgPz8fmZmZyM7ORk5ODurr6+Hl5YWYmBjLyqZ3796MDTkUxoXsXmVlJQ4dOoT9+/fj4MGDyMvLAwCEh4c3iUnXrl1V+5m1tbVYt24d3nvvPZSXlyMsLAwRERHw9vZGZWUlzp8/j7KyMsTExGDJkiUYNWoUFKXlN7wwGo04c+YMsrOzkZmZidzcXOj1enh7e2PIkCGWlU1ERIQqP4/IWhgXsjtVVVU4fPiwJSanTp2ClBLdu3fH6NGjLf9069bN6rNcv34d+/btw8GDB1FcXIz6+nr4+fmhf//+GD9+POLj4+Hp6Wm1n28wGJCXl2c5ZnPq1CkYDAZ06NDBciZaXFwcevbs2ezb1RC1BsaFbK66uhpHjhyx7OY6efIkzGYzQkJCMHr0aIwZMwajR49G9+7dbTqnyWSClBKKoths1aDX63Hq1CnLyub06dNoaGiAv79/k5VNjx49GBuyKcaFWl1NTQ2OHTtmWZmcOHECJpMJXbp0abIyCQsL41+QD1BfX4/c3FzLyiYvLw8mkwkBAQGW4zVxcXF47LHH+N+SWhXjQlan0+mQkZFhiUlWVhYaGhoQFBTUJCYRERH8C7CFdDqdJTaZmZnIz8+HyWRCp06dLNfYxMfHIyQkhP+tyaoYF1JdfX09jh8/bonJ8ePHYTQaERgYiFGjRlli0qdPH/4FZ2U1NTXIzc21nPp87tw5mM1mBAcHN1nZqHkyBBHAuJAK9Ho9MjMzLcdMjh8/Dr1eD39//yYx6devH2NiY9XV1Thx4oTlmE1hYSGklOjatWuTlc2jnsZN1IhxoYdmMBiQnZ2NAwcOYP/+/cjIyEB9fT18fX0xcuRIS0wGDBjA02XtXFVVFXJyciwrm/PnzwMAunXr1mRl05wLUInuxrjQAxmNRuTk5FhicuzYMeh0Ovj4+CAxMdFyncnAgQN5oZ+Dq6ysxIkTJyzHbIqKigAAjz32mCU0cXFx6Nixo40nJXvHuNDPNDQ0IDc31xKTo0ePoqamBl5eXkhISLCsTAYPHsz7YTm527dvW3ahZWVlWW76GRYWZlnZxMbGwt/f38aTkr1hXAgmkwmnT5+2xOTIkSP44Ycf4OnpiREjRlhWJjExMbyTbxtXUVGB7Oxsy8rm+++/BwD07NnTsrKJjY1t8jgCapsYlzbIbDbjzJkzlpgcPnwYWq0W7u7uGD58uCUmsbGxfAYJ3Vd5eXmTlc2VK1cAAL1797asbIYMGdLk8QXUNjAubYCUEvn5+ZaYHDp0CLdv34abmxuGDh1qiUl8fDyfnkgtcu3aNcsFnZmZmSgrK4MQAn369LGsbGJiYuDt7W3rUcnKGBcnJKVEYWFhk5hUVFSgXbt2GDp0qOWYydChQ+Hu7m7rccmJlZaWWlY2mZmZKC8vh6Io6Nu3r2VlEx0d3eSR0uQcGBcnIKXExYsXLTE5ePAgysvL4eLigri4OEtMhg0bZtWbLBLdj5QSpaWlll1omZmZqKiogEajQb9+/Swrm+joaHh4eNh6XGohxsUBSSlRXFzcJCZlZWXQaDQYMmSI5WaPw4YNg5eXl63HJbonKSW+//57S2iysrJw69YtaDQaREVFWVY2gwYN4grbATEuDqKkpKRJTK5cuQJFURAdHW2JyfDhw3nglByWlBKXLl2y7ELLzs5GZWUl2rVrh6ioKMtpz4MGDeKxQQfAuDiIvn374sKFCxg0aJAlJiNGjOApn+S0zGYzvvvuO8vKJjs7G1VVVVi5ciUmTpxo6/HoARgXB9H4v4n35qK2SkoJg8EAFxcX3gnCATAuRESkOt67QwVGoxGXL1+G2Wy29SgtJoRAaGgoL56kh2I0GnHt2jU4y3fVzp07cxtoIcZFBaWlpXjhhRcQExNj61FaLCcnBx9++CHCw8NtPQo5kPLycixbtgz9+/e39SgtdvbsWSxZsgShoaG2HsWhMS4qkFIiKioKy5cvb/Z79Ho9Dh48iPT0dNTV1SExMRGTJ0+2+ZXLr732mtN8+6TWI6VE79698fLLL6v+2bdv38bJkyeRl5eH27dvw9PTE3369EFsbCy6du2q+mMdVq5cyW1ABYyLyh50wF1KievXr2PRokXYsmULDAYDAODTTz/FmDFjsG7dOoSGhtrkwD03KFKDGn92pZT44YcfsHHjRnz55Ze4du3az3Y7+/r6YsKECXjuuefQuXNn1X4uqYNxaUWNYfn1r3+NgwcPol27dhg9ejR8fHywd+9e7Nu3D3PnzsXGjRvh5+dn63GJbEJKiQsXLuDNN99Ebm4upJTw9fVFZGQkgoODUVVVhcLCQly7dg2pqak4evQo/vM//xMJCQl8OJ0dYVxakU6nw+9//3scPHgQ3t7eWLFiBZ5++mloNBps3LgRzz//PA4cOICVK1fijTfe4IZCbY6UEtnZ2Vi8eDHKysrQvn17zJw5E7NmzUKXLl2g0WggpYRWq8XOnTvx97//HVeuXMGrr76KxYsXY/Lkydxu7AT/L7QSs9mMDz/8EJs3b4arqyveeecdPPfcc3Bzc4OLiwuefPJJLFy4EADwt7/9DXl5eVyiU5sipcTJkyfx6quvoqysDCEhIVi9ejVeeeUVhIaGwsXFBUIIKIoCf39//PrXv8Ynn3yCqKgo/PDDD3jzzTexZ88ebjd2gnFpBVJK5Obm4q9//StMJhPmzJmDOXPmNPmGpdFosHDhQvTt2xeVlZVYvXo1TCaTDacmaj2Nt35ZvHgxbty4ge7du2PNmjUYPnz4L14wKYRAz549sWrVKkRHR6O2thbLly/H6dOnGRg7wLi0gvr6eixduhS3bt1C//798V//9V/3fDxwx44dsXDhQiiKgq1bt6KgoMAG0xK1vqqqKixbtgxXrlxBcHAwVqxYgT59+jzwIL0QAsHBwXjrrbfQs2dP3Lp1C2+88QZu3rzJwNgY42JlUkps3boV33zzDVxdXbF06VIEBQXdc6MRQiAlJQW9evVCVVUVPvvsM6e4MJPofhoaGvDJJ5/gxIkT8PT0xOuvv45+/fo1++wvIQRCQkKwZMkSdOjQAYWFhVi7di0aGhqsPDndD+NiZVqtFu+88w6MRiOSk5MxadKk+240fn5++O1vfwsA2LRpE27cuNFaoxK1Oikljh8/ji+//BJCCDzzzDMYNWrUQ59WLITA4MGDMW/ePGg0GmzZsgVHjx7l6sWGGBcrklLiiy++wJkzZ+Dj44M//vGPD7ylhBACM2fOREBAAK5cuYL09HRuIOS0qqqqsHr1atTV1SEmJsZy9uSjUBQFM2fORFxcHPR6Pd5//31UVVWpPDE1F+NiRRUVFXj//fdhNpvx5JNPIjo6ulnfyLp3746xY8da4mQ0GlthWqLWJaXE//3f/6GgoADe3t5YtGhRix9u5+npiYULF8Lb2xuFhYXYtGkTv5zZCONiJVJKfP7557h48SL8/f0tB+qbQ1EUPPXUU9BoNDh+/DguXLhg5WmJWt+VK1fwr3/9C1JKpKSkYMCAAS2+yl4Igf79++Pf/u3fLNvg9evXVZqYHgbjYiU3b97Exx9/DCklZs2ahcjIyIc6QJmQkIAePXqguroa27dv57cvcipmsxn//Oc/cePGDXTu3Bm//e1vVXtGi0ajwe9+9zsEBgbi2rVr2LhxI7cfG2BcrEBKidTUVBQVFcHf3x/z589/6G9kfn5+SEpKAgBs2bIF9fX11hiVqNVJKVFSUoLt27dDCIHZs2ejc+fOqv6MkJAQzJgxAwDw9ddf49q1a6p+Pj0Y42IFt27dwt/+9jdIKTFz5kz07t37kZb706dPR7t27XD27Fle80JOQ0qJL7/8ElqtFiEhIZg6darqN2oVQuDf//3f0alTJ5SXl2Pbtm1cvbQyxkVlUkps3LgRFy5cgK+vL+bPn/9I9zoSQiA6Ohrh4eHQ6XTYuXMnNw5yCmVlZdi1a1eTMyOtITg4GMnJyQB+XL1UVlZa5efQvTEuKqusrMRHH30Es9mMlJQU9O3b95G/lfn4+OCJJ54AAOzcuRN6vV7NUYlanZQSO3bswM2bNxEUFITJkydb7fESiqIgJSUFPj4+KC0txYEDB/gFrRUxLipLS0tDQUEBOnTogBdffLHFd2idPHmyZdcYzxojR1dVVYWtW7cCACZOnIhOnTpZ9ed1794diYmJMJvN2LRpE7+gtSLGRUVarRZr166F2WzG1KlTW3xqpRACMTExeOyxx1BbW4u9e/fymxc5rMar8S9fvgwvLy9MnTrV6rfHVxQFM2bMsHxBO3v2LLehVsK4qCgtLQ35+fnw8fHBggULVNlwOnTogNGjRwP4cdeY2hdUSilRUVGB69ev815MZFUNDQ34+uuvYTKZEBsbix49elj9ZwohMHDgQPTp0wcGg4EH9lsR46ISo9GIb775BgAwbdo0DBw4UJV9yUIIJCcnQ6PRIDc3F5cvX27xZ/7UX//6V0RHR+PVV1/ljTLJakpKSnDy5EloNBpMmzbtnncGtwZ3d3dMnjwZAHDo0CHcvHmzVX5uW8e4qKRdu3b45JNPsH79erz66quqXRAmhEB8fLzl8a6HDh1S9ZuXwWBARkYGysvL4eHhYbWDq9S2SSmxZ88e1NbWIiQkBLGxsa32Z00IgTFjxsDf3x83btzAkSNHuHppBYyLinx8fPDUU0816zkUD6Njx44YNmyY5UwbNVcX5eXlOH/+PBRFwbBhwxgXsgqdTod9+/YBAB5//HF06NChVX9+586dERcXBykldu/ezV3ArYBxUZkQQvW/oBVFsZyyefz4cZSXl6v22WfOnEFlZSV8fX0RFRWl2ucSNZJSoqCgAN999x3c3Nwwfvz4Vv8SoygKJk6cCI1Gg9OnT+PKlSut+vPbIsbFATTea6xxWZ+RkaHKsl5KiSNHjsBsNqN3794IDg5WYVqin9u7dy+MRiMiIiLQq1evVv/5jWdeBgUFobq6GocPH+auMStjXBxESEgIoqOjYTabVbta32g04ujRowCA4cOHP/BZM0SPoqamBkeOHAHw4y4xd3d3m8zh6+uL4cOHAwD27dvHR1lYGePiIFxcXDBp0iQAP57xotVqW/yZZWVlKCgogKIoSExMbPHnEd1LQUEBLl++DA8Pj0d6yqRahBAYN24cXFxcLDOR9TAuDkIIgccffxxeXl64cuUKcnNzW7R6kVIiJycHWq0WAQEBGDx4sIrTEv1ISokDBw6goaEBPXv2bJVrW36JEAJRUVEIDg5GbW0tjh07xl1jVsS4OJCePXuiX79+MBqN2LlzZ4s/b9++fTCbzYiKikJQUJAKExI1pdPpkJGRAQBITEyEm5ubTefx8fFBXFwcAFiiR9bBuDgQNzc3yzNe9u7di5qamkf+rNraWsvxljFjxrTaBW3Utly6dAklJSVwdXVFQkKCzU91b7zmRVEUnDt3jk+ptCLGxYEIITBhwgS4u7vj4sWLOHv27CN/1vnz5y2nho4ePdrmGz05HyklMjIyoNfrERISgp49e9p6JMuusY4dO6K6uhonTpzgrjErYVwcTL9+/dCrVy/o9fpHPmtMSolvv/0WdXV16N69O/r27WuFSamtMxqNOHbsGAAgNjYW7du3t/FEP/L390dUVBSklDh8+DBveWQljIuDad++PSZMmADgxxtZ6nS6h/4Mo9GI3bt3AwBGjRoFHx8fVWckAoCKigoUFhZCURQkJCTYehyLu8+OPHXqFKqqqmw8kXNiXByMEAJTpkyBm5sbCgsLcebMmYf+jJKSEuTm5kKj0VhObyZSk5QSeXl5+OGHH+Dn54f+/fvbza7Xxgsqvby8cPPmTRQWFtp6JKfEuDigqKgo9O7dG/X19di6detD7RqTUuKbb75BVVUVunbtivj4eLvZ6Mm5NN5JIjIy0mqPMn5UXbt2RVhYGBoaGlS74wU1xbg4oPbt22PKlCkAgO3bt6O6urrZ7zUajdi8eTMAYPTo0ejYsaM1RqQ2TqfTITc3FwAQHx+v2l3C1eLq6mo5JTkrKwsGg8HGEzkfxsUBCSEwdepUeHp64sKFC8jMzGz2N6/z588jOzsbLi4umDFjBlctZBWXL1/G1atX4erqiiFDhtjdnzMhBIYOHQoXFxdcunQJ165ds/VITodxcVD9+vVDdHQ0jEYjvvjii2bFRUqJtLQ0VFdXIywsDCNGjLC7jZ4cn5QSubm5qK+vR1BQELp3727rke6pV69eCAgIQG1tLfLy8rhrTGWMi4Nyc3PDU089BSEEdu/e3axbiGu1WmzcuBEAMH36dPj6+lp5SmqLpJTIzs4G8OOXIG9vbxtPdG9+fn6IjIyElPKhVv/UPIyLgxJCYPLkyQgODsaNGzewadOm+24cUkqkp6fj4sWL8Pb2xqxZs7hqIauoqanBuXPnAKBVnzj5sBRFQWxsLADg9OnTqKurs/FEzoVxcWBdunTBtGnTIKXEZ599dt87JdfV1eGjjz6CyWTCE088gcjIyNYblNqU77//HuXl5XB3d8fAgQPtNi5CCERHR8PV1RVlZWW8S7LKGBcHJoTAnDlz4O3tjXPnzmHz5s33XL1IKbFr1y5kZmbC3d0dzz//PO8lRlaTl5cHg8GAoKAgdOvWzdbj3Ff37t0RFBSE+vp65OXl2Xocp8K4OLDG+yRNmTIFZrMZq1atws2bN3/26yorK/H222/DaDRi3LhxdnEDQXJOUkqcPHkSABAZGWk3t3z5Jd7e3pZVPO8zpi7GxcFpNBq88sor8PPzw7lz57By5comtxFvaGjAu+++i9zcXPj4+OBPf/oTnzhJVqPT6VBQUAAAGDx4sN1/iWm8Wh8A8vPzH+l2SnRvjIuDa1y9LFiwAADwwQcfYP369TAajTAYDPj000/x3nvvAQAWLFhg1wdYyfGVlZWhvLwcrq6uiIqKsvs/a0IIDBw4EK6urrh+/Xqzzrqk5uGOdyegKAoWLVqE7Oxs7N69GwsXLsT27dvR0NCAffv2Qa/XY/LkyfjDH/5gd1dKk3MpKChAfX09goODERoaautxmiU0NBSdOnVCaWkp8vPzbT2O0+DKxUn4+Phg3bp1mDx5MoxGI7Zu3YqdO3fCZDIhJSUFn3zyCe9+TFbX+Pjt8PBwu72+5ae8vb3Rq1cvAMDJkyd53EUlXLmozJZ/MDt37ox//etf2L59O/bu3QtFUTB+/HhMnDgRHh4eNp+PnF9MTAy0Wi3i4uKg0Wgc4s+boihISkpC586dkZiYiMzMTFuP5BQYFxUIIXDmzBksW7bM1qNYdO3aFQBw5syZh7ot/+nTp+1+PznZHyEELly4AE9PT4SFhaGiogJr16619VjNJqVEhw4dkJeXh/Pnz3MbUIGQjvDVws4ZDAYUFxfDZDLZepQWUxQF4eHhPKOMHorBYEBpaalTPNVRCIFu3bpxG2ghxoWIiFTHA/oOQkpp+YeorTKbzdDr9U6xQnJ2jIuDyM3NhYuLi+UBTERtUWFhIQYPHsxHEzsAxoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhIiLVMS5ERKQ6xoWIiFTHuBARkeoYFyIiUh3jQkREqmNciIhIdYwLERGpjnEhIiLVMS4OQEqJyspKAEBlZSUfGEZtUuN2YDQauR04AMbFjmm1WqxZswYREREYN24czGYzxo0bh4iICKxZswZardbWIxJZ3d3bQUJCAoqKipCQkMDtwM4JyfzbpfT0dMyYMQM6nQ4AmnxLE0IAADw9PZGWloakpCSbzEhkbdwOHBfjYofS09ORnJwMKeV9nxWuKAqEENixYwc3LHI63A4cG+NiZ7RaLUJCQlBXV3ffDaqRoijw8PBAaWkpfH19rT8gUSvgduD4eMzFzqxfvx46na5ZGxQAmM1m6HQ6bNiwwcqTEbUebgeOjysXOyKlREREBIqLix/qTBghBMLCwnDx4kXLfmgiR8XtwDkwLnbk5s2bCAwMbNH7AwICVJyIqPVxO3AO3C1mR2pqalr0/urqapUmIbIdbgfOgXGxI15eXi16v7e3t0qTENkOtwPnwLjYkYCAAISHhz/0/mIhBMLDw+Hv72+lyYhaD7cD58C42BEhBF566aVHeu/ChQt5EJOcArcD58AD+naG5/cTcTtwBly52BlfX1+kpaVBCAFFuf//nsYrkzdt2sQNipwKtwPHx7jYoaSkJOzYsQMeHh4QQvxsmd/47zw8PLBz506MHz/eRpMSWQ+3A8fGuNippKQklJaWYvXq1QgLC2vyWlhYGFavXo2rV69ygyKnxu3AcfGYiwOQUuL27duorq6Gt7c3/P39edCS2hxuB46FcSEiItVxtxgREamOcSEiItUxLkREpDrGhYiIVMe4EBGR6hgXIiJSHeNCRESqY1yIiEh1jAsREamOcSEiItUxLkREpDrGhYiIVMe4EBGR6hgXIiJS3f8HH6xbnCsvJ7MAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "61c8eeb1", - "metadata": {}, - "source": [ - "Resize the figure using the \"scale\" parameter. By default: 0.5" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "5cb8d57e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "67305f39", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=0.2)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "51c722ad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=2.0)" - ] - }, - { - "cell_type": "markdown", - "id": "03d4bf1b", - "metadata": {}, - "source": [ - "If you want to see sample distribution in addition to the line, set \"sample=True\"" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c6d24148", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAukklEQVR4nO3de3SM974/8Pd3MrlMbnKRIEXJxS2EiiQqQVQIDZZNHe3uWqeO7rPVsXVzutfZ2tNzSlW7dW+rOO1WrdONtjbacNqgaIkEITeXaCrk4hYhLslEkkkmk5nn98eW+RlPEPJM5pL3ay1/9PvMTD7U13u+l+f7CEmSJBARESlIZesCiIjI+TBciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSnNrWBRA5AkmScPv2bdTV1cHb2xuBgYEQQti6LCK7xZEL0UNotVqsWbMGERERCAoKQt++fREUFISIiAisWbMGWq3W1iUS2SXBJ1EStW7fvn2YOXMmdDodgH+MXlq0jFo8PT2RmpqK5ORkm9RIZK8YLkSt2LdvH1JSUiBJEkwm0wNfp1KpIITA7t27GTBE92C4EN1Hq9WiZ8+eaGhoeGiwtFCpVNBoNCgvL4efn5/1CyRyAFxzIbrPpk2boNPp2hQsAGAymaDT6bB582YrV0bkODhyIbqHJEmIiIhAWVkZHqdrCCEQGhqK4uJi7iIjAsOFyMKtW7cQFBTUrvcHBgYqWBGRY+K0GNE96urq2vX+2tpahSohcmwMF6J7eHt7t+v9Pj4+ClVC5NgYLkT3CAwMRFhY2GOvmwghEBYWhoCAACtVRuRYGC5E9xBCYOHChU/03tdff52L+UR3cUGf6D68z4Wo/ThyIbqPn58fUlNTIYSASvXwLtJyh/6OHTsYLET3YLgQtSI5ORm7d++GRqOBEEI23dXSptFosGfPHkycONFGlRLZJ4YL0QMkJyejvLwcq1evRmhoqMW10NBQrF69GlevXmWwELWCay5EbSBJEtLT0zF+/HgcOHAA48aN4+I90UNw5ELUBkII85qKn58fg4XoERguRESkOIYLEREpjuFCRESKY7gQEZHiGC5ERKQ4hgsRESmO4UJERIpjuBARkeIYLkREpDiGCxERKY7hQkREimO4EBGR4hguRESkOIYLEREpjuFCRESKY7gQEZHiGC5Ej2AwGHD16lWcPXsWAFBaWoqqqiqYTCYbV0Zkv/iYY6IH0Gq1SE1Nxddff43CwkLU1taiqakJHh4eCAoKwujRo/Hqq68iPj4earXa1uUS2RWGC1Erjh07hsWLF6OgoAAxMTFISUlBVFQUvL29odVqkZ+fj7S0NJSUlGD27Nl47733EBQUZOuyiewGw4XoPvv378ecOXPg7e2NDz74AM8//zyampqwdetW6PV6+Pr64sUXX4TBYMDWrVuxdOlSREZG4ssvv0S3bt1sXT6RXWC4EN3j/PnzmDRpEry8vLB161YMGjQIQgiUlZVh+PDhqKmpQd++fZGfnw9/f39IkoQjR47g17/+NRITE7Fhwwa4u7vb+rdBZHNc0Ce6y2g04v3330d1dTU+/vhjc7A8jBACCQkJ+PDDD/Hdd99h7969HVQtkX1juBDdVVJSgrS0NMyYMQMJCQmPDJYWQghMnz4dI0eOxOeff47m5mYrV0pk/7jFheiurKws1NXVYebMmbh48SLq6+vN18rLy2E0GgEATU1NKCwshK+vr/l6SEgIZsyYgaVLl+L69evo2bNnh9dPZE8YLkR3FRUVwdPTE6GhoZg3bx6OHj1qviZJEvR6PQCgoqICEyZMMF8TQmDVqlUYMmQIdDodKioqGC7U6TFciO5qaGiAWq2Gu7s79Ho9GhsbW32dJEmya83NzdBoNBYhRNSZMVyI7goODkZDQwO0Wi3i4uLg5eVlvtbQ0ICsrCxziIwaNcp846QQAr1798aNGzegUqng7+9vq98Ckd1guBDdFR0dDYPBgJycHKxcudLiWllZGWJiYlBTU4Nu3bph27Zt8PPzM18XQuCtt95C9+7dOSVGBO4WIzKLjY1FaGgoNm3ahPr6eri4uFj8aiGEgEqlMrerVCpcu3YN3377LVJSUtClSxcb/i6I7APDheiuwMBA/O53v8OJEyewdu3aNm8p1uv1WL58ORoaGjBv3rw2b2EmcmacFiO6x5w5c5CZmYmVK1fC09MT8+fPh4eHBwBArVZDrVabRzGSJKG2thYrVqzA1q1b8dFHH6F///62LJ/IbvD4F6L73Lx5EwsWLMCuXbuQnJyMxYsXY+DAgTh37hxMJhPc3NwQHh6OnJwc/OUvf8GpU6fw7rvvYv78+RbTZ0SdGcOFqBX19fX4/PPPsXbtWlRWViI0NBQRERHw8fFBdXU1zp07h4qKCkRHR+Odd97B2LFjoVJxlpmoBcOF6CGuX7+OAwcOICMjA6dPn0ZOTg5Gjx6N+Ph4TJw4EXFxcfD09LR1mUR2h+FC1Ea5ubmIjY1Fbm4uRowYYetyiOwax/FEbeTi4mLehkxED8deQkREimO4EBGR4hguRESkOIYLEREpjuFCRESKY7gQEZHiGC5ERKQ4hgsRESmO4UJERIpjuBARkeIYLkREpDiGCxERKY7hQkREimO4EBGR4vg8F6I2kiQJJpMJKpUKQghbl0Nk1zhyIXoMfJYLUduobV0AkRIMBgMuX74Mk8lk61LaTQiB3r17w83NzdalED0xhgs5hfLycvzqV79CeXk5mpubIYTA+PHjMWDAAFuX9tjy8/Px17/+FWFhYbYuheiJMVzIKUiShIqKCtTU1Jjbrl+/jo0bN8LHx8eGlT2+JUuWgEuh5Og4gUxOw2g0Wvx3Xl4e0tPTAfxjqskRfhE5C4YLOS2j0Yivv/5aFjpEZH0MF3IaPXv2hFptOdObnp6O0tJSG1VE1HkxXMhpxMfHY/DgwRZtVVVV2Lx5M9cwiDoYw4Wcho+PD/71X/9Vtnbx1VdfoaKiwkZVEXVODBdyKlOmTEGPHj0s2q5evYrt27dz9ELUgRgu5FRCQkIwe/ZsizZJkvDFF19Aq9XapiiiTojhQk5FCIG5c+eiS5cuFu1FRUXYvXs3Ry9EHYThQk6nX79+GDdunEWbyWTCZ599hsbGRhtVRdS5MFzI6bi4uGDBggXw8PCwaM/Ly0NmZiZHL0QdgOFCTkcIgfj4eCQmJlq06/V6rFmzBk1NTbYpjKgTYbiQU3Jzc8PcuXPh4uJi0Z6RkYH09HSOXoisjOFCTkkIgeTkZMTExFi0NzY24uOPP+bohcjKGC7ktLy8vLBgwQLZA74OHjyIjIwMjl6IrIjhQk5LCIGUlBQMGzbMol2v12PVqlVoaGiwTWFEnQDDhZyar68vFi1a1Oray759+zh6IbIShgs5NSEEpk2bhhEjRli0GwwGrFy50uLhYkSkHIYLOT1vb2+88cYbsuP48/PzsWXLFo5eiKyA4UJOTwiByZMnY8yYMRbtJpMJq1ev5onJRFbAcKFOQaPR4D/+4z9kd+2Xlpbiz3/+M59WSaQwhgt1CkIIJCYmYtasWbJrmzZtQm5uLqfHiBTEcKFOQ61W4w9/+AOCgoIs2u/cuYO3334b9fX1NqqMyPkwXKjTEEJg0KBB+N3vfid7WmVmZiY2btzI0QuRQhgu1KmoVCq89tprGDJkiEW70WjEBx98gMLCQgYMkQIYLtTpBAYG4t1335Ut7l+/fh3//u//jtraWhtVRuQ8GC7U6QghMGnSJLz88suya+np6Vi5ciWam5ttUBmR82C4UKekVquxdOlSDBw40KLdZDJh7dq1+O677zg9RtQODBfqlIQQ6NGjBz744AN4enpaXNPpdFi0aBFOnDjBgCF6QgwX6rRa7txfuHCh7Fj+iooK/OY3v8GlS5cYMERPgOFCnZparcabb76JiRMnyq4VFBTg1Vdfxc2bNxkwRI+J4UKdnre3N1avXo1+/frJrh06dAhz587FtWvXGDBEj4HhQp2eEALh4eHYsGEDunXrJrv+ww8/4KWXXsKFCxcYMERtxHAhwj8CZtSoUVi3bh38/Pxk148cOYIZM2bwDDKiNmK4EN0lhMDUqVPx6aefthowZ86cwfTp0/Hll1+iqamJIUP0EAwXonuoVCrMnDkT69evh7+/v+x6ZWUl5s2bh/nz5+Pq1asMGKIHYLgQ3UelUmHGjBn429/+hu7du8uuNzU1YePGjUhKSsK2bdvQ0NDAkCG6D8OFqBUqlQpTpkzBzp07ERUV1epriouL8corr2D69Ok4dOgQp8qI7sFwIXoAIQRiYmLw/fff44UXXoBarZa9prm5GT/99BOmTJmCf/qnf0J6ejoaGxsZMtTpMVyIHkIIgZ49e2Ljxo1YtWoVgoODW31dY2Mj0tLSMGXKFKSkpODbb7+FVqtlyFCnxXAhegQhBDQaDRYsWIAff/wR06dPh5ubW6uv1ev1OHToEF5++WUkJCTgvffeQ1FREZqbmxk01KkwXIjaSAiByMhIbNmyBZs3b8bQoUNlZ5K1MBqNOHv2LJYuXYpRo0Zh5syZ2LJlCyoqKmA0Ghk05PQYLkSPQQgBd3d3vPDCCzh48CA+/vhjDBw48IEhAwA1NTXYtWsXXnnlFcTExODFF1/Epk2bUFZWxk0A5LTkK5RE9EhCCPj5+eG3v/0tZs2ahZ07d+LTTz9FQUHBAx80JkkSrl+/jh07dmDnzp3o0qULBg8ejMTERCQmJiIyMhKBgYEd/Dshsg4h8WsTOYGysjKsW7cOH374IYQQHf7zJUlCfX090tPT8cUXXyA9Pf2xHpesVqsRHByMcePGwWg0YtmyZQgPD7dixUTWxWkxIgUIIeDt7Y0pU6Zg+/btOHLkCN58800MGDCg1S3M92tubkZFRQW+/vpr/PDDDx1QMZF1MVyIFCSEgKurKwYPHozly5cjKysLaWlpmDt3Lvr06QMXF5dHfobJZOqASomsi2su5HTsaabX19cXEyZMQFJSEqqrq5GTk4M9e/YgMzMTpaWlaGhosHWJRFbBcCGnIITAmTNnsGzZMluX8kgBAQGYOHEiiouLkZeXh+rqavM1IQT8/f1tsm5EpCQu6JNTaGpqQllZGYxGo61LaTeVSoWwsLAH3qhJ5AgYLkREpDhOixG10b3fwzhtRfRw3C1G1EYnT56Ei4sLTp48aetSiOwew4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMF6I2kCTJ/Kz76upq8AGuRA/HcCF6CK1WizVr1iAiIgJJSUmQJAlJSUmIiIjAmjVroNVqbV0ikV0SEr+CEbVq3759mDlzJnQ6HYDWH3Ps6emJ1NRUJCcn26RGInvFcCFqxb59+5CSkgJJkmAymR74OpVKBSEEdu/ezYAhugfDheg+Wq0WPXv2RENDw0ODpYVKpYJGo0F5eTn8/PysXyCRA+CaC9F9Nm3aBJ1O16ZgAQCTyQSdTofNmzdbuTIix8GRC9E9JElCREQEysrKHmtHmBACoaGhKC4uNq/HEHVmDBeie9y6dQtBQUHten9gYKCCFRE5Jk6LEd2jrq6uXe+vra1VqBIix8ZwIbqHt7d3u97v4+OjUCVEjo3hQnSPwMBAhIWFPfa6iRACYWFhCAgIsFJlRI6F4UJ0DyEEFi5c+ETvff3117mYT3QXF/SJ7sP7XIjajyMXovv4+fkhNTUVQgioVA/vIi136O/YsYPBQnQPhgtRK5KTk7F7925oNBoIIWTTXS1tGo0Ge/bswcSJE21UKZF9YrgQPUBycjLKy8uxevVqhIaGWlwLDQ3F6tWrcfXqVQYLUSu45kLUBpIkIT09HePHj8eBAwcwbtw4Lt4TPQRHLkRtIIQwr6n4+fkxWIgegeFCRESKY7gQEZHiGC5ERKQ4hgsRESmO4UJERIpjuBARkeIYLkREpDiGCxERKY7hQkREimO4EBGR4hguRESkOIYLEREpjuFCRESKY7gQEZHiGC5ERKQ4hgsRESmO4UL0CAaDAVevXsXZs2cBAKWlpaiqqoLJZLJxZUT2i485JnoArVaL1NRUfP311ygsLERtbS2amprg4eGBoKAgjB49Gq+++iri4+OhVqttXS6RXWG4ELXi2LFjWLx4MQoKChATE4OUlBRERUXB29sbWq0W+fn5SEtLQ0lJCWbPno333nsPQUFBti6byG4wXIjus3//fsyZMwfe3t744IMP8Pzzz6OpqQlbt26FXq+Hr68vXnzxRRgMBmzduhVLly5FZGQkvvzyS3Tr1s3W5RPZBYYL0T3Onz+PSZMmwcvLC1u3bsWgQYMghEBZWRmGDx+Ompoa9O3bF/n5+fD394ckSThy5Ah+/etfIzExERs2bIC7u7utfxtENscFfaK7jEYj3n//fVRXV+Pjjz82B8vDCCGQkJCADz/8EN999x327t3bQdUS2TeGC9FdJSUlSEtLw4wZM5CQkPDIYGkhhMD06dMxcuRIfP7552hubrZypUT2j1tciO7KyspCXV0dZs6ciYsXL6K+vt58rby8HEajEQDQ1NSEwsJC+Pr6mq+HhIRgxowZWLp0Ka5fv46ePXt2eP1E9oThQnRXUVERPD09ERoainnz5uHo0aPma5IkQa/XAwAqKiowYcIE8zUhBFatWoUhQ4ZAp9OhoqKC4UKdHsOF6K6Ghgao1Wq4u7tDr9ejsbGx1ddJkiS71tzcDI1GYxFCRJ0Zw4U6vQsXLuDQoUM4fPgwdDodtFot4uLi4OXlZX5NQ0MDsrKyzCEyatQo842TQgj07t0bN27cgNFoxJUrV6DX67lrjDo1bkWmTufy5cvIyMhAeno6Dh06hEuXLkEIgb59++LChQv45JNP8Jvf/MbiPWVlZYiJiUFNTQ369OmDvLw8+Pn5ma8LIfDWW29hzZo16N27NzQaDYYNG4aYmBjExcUhKioKbm5uHfw7JbIdhgs5vatXr+LQoUPmX2VlZQCAoUOHYuzYsRg3bhxGjx4Nk8mEhIQE+Pv7Y+/evRYL9g+6zwX4xzRZRUUFxo4di6lTp2LevHnIyclBTk4OcnNzUVtbCw8PDwwbNgyxsbGIjY3FkCFD4OrqapM/D6KOwHAhp3P9+nWLMCkuLgYADB482BwmY8aMQWBgoOy9n3zyCd544w28/fbbWLJkiXnq62Hh0tjYiEWLFiEtLQ0HDx5E//79zZ9nNBpx7tw5c9jk5eWhrq4OHh4eGD58OGJjYxEXF4fIyEieT0ZOheFCDu/GjRvIyMgwh0lRUREAYODAgRZhEhwc/MjPqq+vx9y5c7Fnzx4sW7YM8+fPh4eHBy5cuIDY2FjztFhOTg78/PxQW1uLFStWYP369fjoo4/wL//yLw/9fKPRiLNnzyI7Oxs5OTnIz8+HTqeDp6cnhg8fjri4OMTFxWHgwIFwcXFR5M+HyBYYLuRwbt26hczMTHOYFBYWAgD69etnDpOxY8eie/fuT/T5N2/exIIFC7Br1y4kJydj8eLFGDhwIM6dOweTyQQ3NzeEh4cjJycHf/nLX3Dq1Cm8++67mD9//mMHQnNzMwoLC5GdnY3c3Fzk5+ejsbER3t7eiI6ONo9s+vfvz7Ahh8JwIbtXXV2NzMxMpKenIyMjAwUFBQCAsLAwizB56qmnFPuZ9fX1+Pzzz7F27VpUVlYiNDQUERER8PHxQXV1Nc6dO4eKigpER0fjnXfewdixY6FStf/AC4PBgDNnziA3NxfZ2dk4efIk9Ho9fHx8MGLECPPIJiIiQpGfR2QtDBeyOzU1NTh8+LA5TE6dOgVJktCnTx8kJiaaf/Xq1cvqtVy/fh0HDhxARkYGysrK0NjYCH9/fwwePBgTJ05EXFwcPD09rfbzm5qaUFBQYF6zOXXqFJqamtClSxfzTrTY2FiEh4e3+bgaoo7AcCGbq62txZEjR8zTXCdOnIDJZELPnj2RmJiIcePGITExEX369LFpnUajEZIkQaVS2WzUoNfrcerUKfPI5vTp02hubkZAQIDFyKZv374MG7Iphgt1uLq6OmRlZZlHJnl5eTAajQgJCbEYmYSGhvIfyEdobGzEyZMnzSObgoICGI1GBAYGmtdrYmNj8fTTT/PPkjoUw4WsTqfT4dixY+YwycnJQXNzM7p162YRJhEREfwHsJ10Op05bLKzs1FYWAij0Yjg4GDzPTZxcXHo2bMn/6zJqhgupLjGxkYcP37cHCbHjx+HwWBAUFAQxo4daw6TAQMG8B84K6urq8PJkyfNW59/+eUXmEwmdO/e3WJko+RmCCKA4UIK0Ov1yM7ONq+ZHD9+HHq9HgEBARZhEhkZyTCxsdraWuTl5ZnXbIqKiiBJEp566imLkc2TbuMmasFwocfW1NSE3NxcHDp0COnp6Th27BgaGxvh5+eHMWPGmMNkyJAh3C5r52pqapCfn28e2Zw7dw4A0KtXL4uRTVtuQCW6F8OFHslgMCA/P98cJllZWdDpdPD19cXo0aPN95kMHTqUN/o5uOrqauTl5ZnXbEpKSgAATz/9tDloYmNj0bVrVxtXSvaO4UIyzc3NOHnypDlMjh49irq6Onh7eyMhIcE8MnnmmWd4HpaTq6qqMk+h5eTkmA/9DA0NNY9sYmJiEBAQYONKyd4wXAhGoxGnT582h8mRI0dw584deHp6Ij4+3jwyiY6O5km+ndzNmzeRm5trHtlcunQJABAeHm4e2cTExFg8joA6J4ZLJ2QymXDmzBlzmBw+fBharRYeHh4YNWqUOUxiYmL4DBJ6qMrKSouRzZUrVwAA/fv3N49sRowYYfH4AuocGC6dgCRJKCwsNIdJZmYmqqqq4O7ujpEjR5rDJC4ujk9PpHa5du2a+YbO7OxsVFRUQAiBAQMGmEc20dHR8PHxsXWpZGUMFyckSRKKiooswuTmzZtwdXXFyJEjzWsmI0eOhIeHh63LJSdWXl5uHtlkZ2ejsrISKpUKgwYNMo9shg8fbvFIaXIODBcnIEkSiouLzWGSkZGByspKqNVqxMbGmsPk2Wefteohi0QPI0kSysvLzVNo2dnZuHnzJlxcXBAZGWke2QwfPhwajcbW5VI7MVwckCRJKCsrswiTiooKuLi4YMSIEebDHp999ll4e3vbulyiVkmShEuXLpmDJicnB7dv34aLiwuioqLMI5thw4ZxhO2AGC4O4uLFixZhcuXKFahUKgwfPtwcJqNGjeLCKTksSZJw4cIF8xRabm4uqqur4erqiqioKPO252HDhnFt0AEwXBzEoEGDcP78eQwbNswcJvHx8dzySU7LZDKhtLTUPLLJzc1FTU0NVq1ahcmTJ9u6PHoEhouDaPnfxLO5qLOSJAlNTU1Qq9U8CcIBMFyIiEhxPLtDAQaDAZcvX4bJZLJ1Ke0mhEDv3r158yQ9FoPBgGvXrsFZvqv26NGDfaCdGC4KKC8vx7/9278hOjq6Ta83GAzIzMzE2bNnLdq7du2KKVOm2HSHV35+Pv76178iLCzMZjWQ46msrMSyZcswePBgRT/31q1bOHbsGGpqamTXXF1dMXz4cISFhSl6+vbPP/+Md955B71791bsMzsjhosCJElCVFQUVqxY8cjXarVavPXWWzhz5gz0er3FtYaGBhQXF2PDhg0ICQmxVrkPtWTJEqf59kkdR5Ik9O/fH4sWLVLk83Q6HXbs2IE9e/agsrKy1b+TDQ0NyMvLQ1BQEF577TXFnkGzatUq9gEFMFwU9qAFd0mSoNVqMXfuXKSlpbX6l9dkMmH//v2YO3cu/v73v3f4SbPsUKSE9mw6abnRcvny5cjKynrkVHNdXR2++eYb5Ofn46233sLIkSPbNYphH1AOn+TUQfR6PZYsWfLAYLnXgQMH8P7778NoNHZQdUS2J0kSSkpKsGDBAhw5cuSx1jDLysrwxhtv4KeffnKKtU9nwHDpAJIk4auvvsLGjRtlwaJSqWTPRJEkCRs2bEBeXh6/SVGn0BIsixcvNj+g7H5qtRq+vr4PvFu/pqYG//3f/42DBw+y39gBhouVSZKE8+fPY9myZWhubra45unpiT/96U/YsGGD7JTY2tpa/OlPf4LBYOjIcok6nCRJqKysxB//+Efzw8ju5e7ujmnTpuGLL77Azp07sW3bNrz++usIDAyUvfbOnTtYtmwZCgoKGDA2xjUXK2tqasJ//dd/oaKiwqJdrVZj+fLlWLhwIQCgpKQEK1assOgQP/74I7Kzs5GQkMCbJ8lp6XQ6rFixAkVFRbJr3bp1w9tvv40xY8ZArVab+0F4eDjGjx+PZcuW4cSJExbvuX37NpYtW4ZPP/0UQUFB7Ds2wpGLFUmShL179yItLU12bdasWXjttdfg4uICFxcXLFy4EP3797d4TUNDA/73f/+Xc8jktIxGIzZv3oz09HTZtZCQEKxevRrPPfccXF1dLUJCCIHw8HB89NFHiIuLk723qKgIa9as4cjfhhguVnTnzh28//77aGpqsmjv06cPli9fbnH4XmBgIObPny/7lrVnz54HzkETOTJJknDy5En87W9/k32BCgwMxMqVKxEVFfXAkYcQAl27dsWKFSswYMAA2fVdu3YhMzOT02M2wnCxEkmSsHXrVtmQ3cXFBW+++Sb69Okj+yb2wgsvyG7cun37NrZs2cIOQk6nrq4OH330Eerq6iza3d3dsWTJEgwfPvyRU1pCCPTo0QPvvPMO/P39La4ZDAb8z//8D6qrqxWvnR6N4WIlt27dwtq1a2XfyEaPHo0XX3yx1U7TrVs3zJ49W9a+Y8cO3Llzx2q1EnU0SZKwc+dOnD592qJdCIGXXnoJycnJbV4rEUJgyJAhmD9/vuxAy5KSEmzbto1TyzbAcLECSZKQmpqKc+fOWbS7u7vjj3/84wMf6SqEwMsvvyzbOXb+/HkcP36coxdyGteuXcPGjRtl/+gPGDAAv/3tb2Xb8x9FpVJhxowZGDlypEW7JEnYsmULLl68yP7TwRguVtAyarn/L3NycjLGjh370G9k/fr1Q3x8vEVbc3Mzvv/+e3YOcgomkwnbtm3D9evXLdrd3d2xaNEidOnS5Yk+V6PRYOHChbKz+W7fvo2vvvqK/aeDMVwUJkkS/v73v+P8+fMW7V5eXvjDH/7wyJNWXV1dW502++GHH3Dr1i3F6yXqaBcvXkRqaqqsPSkpCXFxcU+8dVgIgcjISEyZMkV2be/evSgrK2PAdCCGi8Ju376NdevWtTpqiY2NbdMC5XPPPSc7hO/KlSvIyMhg5yCHZjKZsH37dlRVVVm0+/v7Y968eXB1dW3X57u4uOCVV15B165dLdq1Wi2++eYb9p8OxHBR2LfffivbOuzp6Ynf//73bZ5H7tGjB8aMGWPRZjKZ8H//93/sHOTQrly5gl27dsnap02bhtDQUEVueOzVqxemTp0qa9+7dy+uXbvW7s+ntmG4KEir1WLdunWyRcqJEye2adTSQgiB6dOny053PXz4MG7evKlYvUQdSZIkfPfdd7JRS0BAAGbPnq3YM1lUKhVmzZolO1X85s2bbTo4lpTBcFHQt99+i19++cWizcPDAwsWLHis4b4QAmPGjEGPHj0s2q9du4ajR4+yc5BDqqqqanXUkpycrPiDuXr37o1JkybJ2tPS0lp98Bgpj+GikJqaGnzyySeyUUtiYiLi4+Mfe7gfHBzc6tTY7t27GS7kcCRJQkZGhuyMPR8fH8yaNUvx87+EEJg5c6Zs59jly5eRk5PDPtQBGC4KOXjwIAoLCy3a3NzcsHDhwid6FrcQAlOnTpV1usOHDyv6zctkMqG0tBR79+5FaWkpbzYjqzAYDNi1a5fs79eoUaMQHh5ulXCJiIiQ3fdiNBqxa9cu2QnlpDyGi0Ju374t6zhjxox55H0tDyKEwLPPPivb9XLlyhVZiD2plps94+PjMXXqVMTHx+PgwYOKfDbRvc6ePSu7G1+tVmPGjBmyu+qV4uLigmnTpsk+/9ixY7hw4YJVfib9fwwXK3Fzc8PixYsf+GCjtggJCUFsbKxFW1NTk2JTY3V1dVixYgVu3rwJk8mEW7duobS0tN2fS3QvSZLwww8/oKGhwaJ94MCBbTo/7EkJIRAXF4ewsDCL9vr6euzfv59TY1bGcFGIr6+v+RuSEAK/+tWvkJiY2K6O4+Li0urU2J49e1BfX9+ueoF/nLvEE5fJ2mpqalo9Uj8lJQWenp5W/dne3t5ISkqSte/fv1+RPkQPxnBRyLRp07B+/Xr88z//M/785z/jk08+sThS/0m07Bq7/6yxkpIS2a60xyVJEnJycmTfJomUJEkSTp06JVvI9/Pzw7hx46z+IC8hBJKSkmQhdvHiRfz8888cvVgRw0UhHh4emDNnDr744gssWrQI/v7+inScPn36YMiQIRZtjY2N+Omnn9rVMSRJwpEjR2TtfGofKalll5jRaLRoHzFihGyrvbWEhoZi2LBhFm3Nzc3Yv39/h/z8zorhojAhhKL/QLu5ubW6X3/fvn2yh5A9jrq6OuTl5Vm0ubi4oG/fvk/8mUT3q6qqQmZmpkWbSqXC5MmTrbaQfz9XV1dMnDhR1i+zsrJQW1vbITV0RgwXOyeEwPPPPy8b1p85cwaXLl164s8tLS3FlStXLNr8/f0xcODAJ/5Monu1TInduHHDor1r166Ijo7usFGyEAIJCQmyh4lVVFTg559/7pAaOiOGiwMIDw+X7Xi5c+fOEx9kKUkSsrKyZOstw4YNQ7du3dpVK1ELSZLw448/tjolFhgY2KG1BAcHtzo1xscgWw/DxQF4eXnJdrxIkoTvv/9e1nHbwmQytbp7Z/To0e0+lZaoxZ07d3Dq1CmLNpVKhaSkJMXOEWsrFxeXVjcQHDlyhLvGrITh4gCEEEhJSZHd6Z+TkyPbhdMWt2/fRm5urkWbWq3Gs88+2646iVpIkoQzZ87ITiEODAy06r0tDyKEQExMDHx9fS3ar1y5IntiLCmD4eIgnnnmGdnhflVVVcjKynrsYf0vv/wiewpgSEgIhg4d2u46iVpkZWXJjlkZOnRoh0+JtejRo4ds56XBYMDBgwc5NWYFDBcH4evri8TERIs2k8n02HcaS5KEgwcPyjp9TEyMbMGT6EnpdDocP37cok0IgcTExA6fEmuhVqvx3HPPydqPHz+OxsZGG1Tk3BguDkIIgVmzZskeOJaRkYHq6uo2f45Op0NaWprssydMmGCzTk/O5+LFi7LdjN7e3h26S+x+QgjExsbKbkq+ePEiLl68aJOanBn/NXEQQohWp8auXLmCQ4cOtXn0cvbsWRQXF1u0eXt7Y/To0YrVSp1by+kP948GIiIiOuzGyQd56qmnEBoaatHW0NCA3NxcTo0pjOHiQAICAjBhwgSLNqPRiO3bt7fpqHxJkrB3717ZFuSoqCjePEmKMRqNsikxABg5cqTNdyO6ubkhLi5O1n7s2LEn2nlJD8ZwcTBJSUmyO5sPHz7cpl1jjY2N2Lt3r6x98uTJT/TMGaLWVFdXy86+U6vVGDlypM2PFxJCYNSoUbLp5cLCQtnjl6l9GC4OpOUgy169elm037hxo01njZ0+fVp234GXlxcmT55s805PzuP8+fPQarUWbcHBwQgPD7dNQfcZOHBgqzsvz549a6OKnBPDxcEEBARg/PjxFm2SJGHbtm0wGAwPfJ8kSdi+fbtsSmzw4MHo37+/VWqlzun48eOyKaZhw4bJFtJtxdvbW3a3vslkQnZ2tm0KclIMFwcjhMBLL70kO87/2LFjOHPmzAPfV1VVhV27dsnaZ86c2a4HmhHdy2Aw4OTJk7L2mJgYu9qNGBMTIxut5+XlQa/X26gi52M//7epTVqerhcVFWXRXldXh61bt7Y6NSZJEnbv3i17tKu/v3+rDyMjelK3bt1CWVmZRZuHhweioqLs5u+ZEAKRkZHQaDQW7ZcvX0ZlZaWNqnI+DBcHpNFo8MILL8jav/nmG9lxG8A/tlp+9tlnsh1lzz33nGxbJlF7FBYW4s6dOxZtISEhsjUOW3vqqadkNdXW1qKgoMBGFTkfhosDEkJg+vTpsmM0ysvLZaMXSZLw008/IT8/3+K1rq6umDNnToc9U4M6hxMnTsi+xAwdOlQ2SrA1Dw8PREdHW7RJkoSCggLe76IQhouD6tu3L1JSUizaJEnC+vXrLYb2d+7cwcqVK2UPFhsxYgTGjh1rN1MV5PgMBkOr6362vCv/QVoOsrx/HSg3N5dHwSiE4eKgVCoV5s2bJ3uIWGlpKVatWoXm5maYTCZs2LABOTk5Fq9Rq9X4/e9/L3svUXtUVVXJ1vU0Gg2GDBlid+ECAJGRkfD29rZoq6iokD3cjJ4Mw8VBCSEQHR2N559/3qJdkiSsW7cOX375JVJTU7FixQrZNEVMTAzvbSHFFRcXo6amxqItJCQEISEhNqro4bp27Yqnn37aoq2+vp73uyiE4eLA1Go1lixZIjvNuKGhAQsWLMCcOXNknV2j0eA///M/4eXl1ZGlUidQWVkp+yITERFhd+stLdzc3GRH8EuSJOsz9GQYLg5MCIGhQ4di4cKFsrljvV4vmzsWQmDu3LlISkriqIUU19pCeGxsrF3/XYuLi7Or+2+cCf9UHZxKpcIbb7yBKVOmPPK148aNwzvvvGPzwwOpc3B1dcWgQYPsNlyEEOjfvz9H8VaifvRL6HHYYhujl5cX1q1bZ75Z8v6pCZVKhUmTJmH9+vUICAjgVkuyivtDpE+fPujTp49d/33r3r07oqKicPToUXObvYaho2G4KEAIgTNnzmDZsmU2rSM8PBxPP/207EbK4OBg9OvXD5999tkjP+P06dPsXPTYhBDw8/Mz71IUQiA4OBibN2+2dWmP5OfnB41GA5PJBJVKhYCAAPYBBQjJnr9WOIimpiaUlZU5xfMgVCoVwsLCeAQ/PZampiaUl5e36blC9k4IgV69erEPtBPDhYiIFMcFfQchSZL5F1FnZTKZoNfrnWKE5OwYLg7i5MmTUKvVrR5nTtRZFBUV4ZlnnkFRUZGtS6FHYLgQEZHiGC5ERKQ4hgsRESmO4UJERIpjuBARkeIYLkREpDiGCxERKY7hQkREimO4EBGR4hguRESkOIYLEREpjuFCRESKY7gQEZHiGC5ERKQ4hgsRESmO4eIAJElCdXU1AKC6upoPDKNOqaUfGAwG9gMHwHCxY1qtFmvWrEFERASSkpJgMpmQlJSEiIgIrFmzBlqt1tYlElndvf0gISEBJSUlSEhIYD+wc0Ji/Nulffv2YebMmdDpdABg8S1NCAEA8PT0RGpqKpKTk21SI5G1sR84LoaLHdq3bx9SUlIgSdJDnxWuUqkghMDu3bvZscjpsB84NoaLndFqtejZsycaGhoe2qFaqFQqaDQalJeXw8/Pz/oFEnUA9gPHxzUXO7Np0ybodLo2dSgAMJlM0Ol02Lx5s5UrI+o47AeOjyMXOyJJEiIiIlBWVvZYO2GEEAgNDUVxcbF5HprIUbEfOAeGix25desWgoKC2vX+wMBABSsi6njsB86B02J2pK6url3vr62tVagSItthP3AODBc74u3t3a73+/j4KFQJke2wHzgHhosdCQwMRFhY2GPPFwshEBYWhoCAACtVRtRx2A+cA8PFjgghsHDhwid67+uvv85FTHIK7AfOgQv6dob7+4nYD5wBRy52xs/PD6mpqRBCQKV6+P+eljuTd+zYwQ5FToX9wPExXOxQcnIydu/eDY1GAyGEbJjf0qbRaLBnzx5MnDjRRpUSWQ/7gWNjuNip5ORklJeXY/Xq1QgNDbW4FhoaitWrV+Pq1avsUOTU2A8cF9dcHIAkSaiqqkJtbS18fHwQEBDARUvqdNgPHAvDhYiIFMdpMSIiUhzDhYiIFMdwISIixTFciIhIcQwXIiJSHMOFiIgUx3AhIiLFMVyIiEhxDBciIlIcw4WIiBTHcCEiIsUxXIiISHEMFyIiUhzDhYiIFPf/ABYLXGxUg4JDAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(sample=True)" - ] - }, - { - "cell_type": "markdown", - "id": "a3fa482a", - "metadata": {}, - "source": [ - "The samples are more visible if we use a smaller number of samples" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "3856bcb6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.get_act(dataset['train_input'][:20])\n", - "model.plot(sample=True)" - ] - }, - { - "cell_type": "markdown", - "id": "4fa7ca2c", - "metadata": {}, - "source": [ - "If a function is set to be symbolic, it becomes red" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "3d502880", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9992202520370483\n", - "saving model version 0.3\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9992, device='cuda:0')" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,1,0,'x^2')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "f8f93b9c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "e75a0760", - "metadata": {}, - "source": [ - "If a function is set to be both symbolic and numeric (its output is the addition of symbolic and spline), then it shows up in purple" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "17df5fed", - "metadata": {}, - "outputs": [], - "source": [ - "model.set_mode(0,1,0,mode='ns')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "b5b13363", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "628e9c8a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_3_extract_activations-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_3_extract_activations-checkpoint.ipynb deleted file mode 100644 index 8933c83ad..000000000 --- a/tutorials/.ipynb_checkpoints/API_3_extract_activations-checkpoint.ipynb +++ /dev/null @@ -1,147 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 3: Extracting activation functions\n", - "\n", - "The KAN diagrams give intuitive illustration, but sometimes we may also want to extract the values of activation functions for more quantitative tasks. Using the indexing convention introduced in the indexing notebook, each edge is indexed as $(l,i,j)$, where $l$ is the layer index, $i$ is the input neuron index, and $j$ is output neuron index." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import matplotlib.pyplot as plt\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x)\n", - "model.plot(beta=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d3fe2e03", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "l = 0\n", - "i = 0\n", - "j = 3\n", - "x, y = model.get_fun(l,i,j)" - ] - }, - { - "cell_type": "markdown", - "id": "a9e62f17", - "metadata": {}, - "source": [ - "If we are interested in the range of some activation function, we can use get_range." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1a978202", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x range: [-1.61 , 3.38 ]\n", - "y range: [-0.19 , 0.56 ]\n" - ] - }, - { - "data": { - "text/plain": [ - "(array(-1.6111118, dtype=float32),\n", - " array(3.38374, dtype=float32),\n", - " array(-0.18606013, dtype=float32),\n", - " array(0.5614974, dtype=float32))" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.get_range(l,i,j)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6f92ea27-5c88-4771-95a8-3ab2eac97501", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_4_initialization-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_4_initialization-checkpoint.ipynb deleted file mode 100644 index 77c0825e1..000000000 --- a/tutorials/.ipynb_checkpoints/API_4_initialization-checkpoint.ipynb +++ /dev/null @@ -1,287 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 4: Initialization" - ] - }, - { - "cell_type": "markdown", - "id": "6581dacd", - "metadata": {}, - "source": [ - "Initialization is the first step to gaurantee good training. Each activation function is initialized to be $\\phi(x)={\\rm scale\\_base}*b(x) + {\\rm scale\\_sp}*{\\rm spline}(x)$.\n", - "1. $b(x)$ is the base function, default: 'silu', can be set with ${\\rm base\\_fun}$\n", - "\n", - "2. scale_sp sample from N(0, noise_scale^2)\n", - "\n", - "3. scale_base sampled from N(scale_base_mu, scale_base_sigma^2)\n", - "\n", - "4. sparse initialization: if sparse_init = True, most scale_base and scale_sp will be set to zero\n" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "Default setup" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "c3e6d104", - "metadata": {}, - "source": [ - "Case 1: Initialize all activation functions to be exactly linear. We need to set noise_scale_base = 0., base_fun = identity, noise_scale = 0." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "90d2d5de", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABnJ0lEQVR4nO3dd3hUVfoH8O+dkmTSK0lICKTRW+glCYJKEVSKgCiKIKviiquAZdVFUUBBqrqyCiogKEUQpKusQgq9lwCpkEpIMpNkMn3m/v7gd+9mkJJJZubeGd7P8+SR3ZQ5c+bO/c57z7nnMCzLsiCEEELsSCJ0AwghhLgfChdCCCF2R+FCCCHE7ihcCCGE2B2FCyGEELujcCGEEGJ3FC6EEELsjsKFEEKI3VG4EEIIsTsKF0IIIXZH4UIIIcTuKFwIIYTYHYULIYQQu6NwIYQQYncULoQQQuxOJnQDCHEFLMuisrISarUavr6+CAkJAcMwQjeLENGiyoWQu1CpVFi+fDkSExMRFhaG2NhYhIWFITExEcuXL4dKpRK6iYSIEkM7URJye/v27cOYMWOg0WgA3KxeOFzV4u3tjS1btmDIkCGCtJEQsaJwIeQ29u3bh+HDh4NlWVgsljv+nEQiAcMw2LVrFwUMIfVQuBByC5VKhejoaGi12rsGC0cikUChUKCoqAiBgYGObyAhLoDGXAi5xZo1a6DRaBoULABgsVig0Wiwdu1aB7eMENdBlQsh9bAsi8TEROTl5cGWtwbDMIiLi0N2djbNIiMEFC6EWKmoqEBYWFiTfj8kJMSOLSLENdFlMULqUavVTfr92tpaO7WEENdG4UJIPb6+vk36fT8/Pzu1hBDXRuFCSD0hISGIj4+3edyEYRjEx8cjODjYQS0jxLVQuBBSD8MwmD59eqN+99VXX6XBfEL+Hw3oE3ILus+FkKajyoWQWwQGBmLLli1gGAYSyd3fItwd+lu3bqVgIaQeChdCbmPIkCHYtWsXFAoFGIb5y+Uu7v9TKBTYvXs3Bg8eLFBLCREnChdC7mDIkCEoKirCsmXLEBcXZ/W9uLg4LFu2DMXFxRQshNwGjbkQ0gAsy+KPP/7Agw8+iP3792PgwIE0eE/IXVDlQkgDMAzDj6kEBgZSsBByDxQuhBBC7I7ChRBCiN1RuBBCCLE7ChdCCCF2R+FCCCHE7ihcCCGE2B2FCyGEELujcCGEEGJ3FC6EEELsjsKFEEKI3VG4EEIIsTsKF0IIIXZH4UIIIcTuKFwIIYTYHYULIYQQu6NwIYQQYncULoTcg9FoRHFxMbKysgAAubm5qKqqgsViEbhlhIgXbXNMyB2oVCps2bIF69evx4ULF1BbWwuDwQAvLy+EhYUhJSUFzz//PPr37w+ZTCZ0cwkRFQoXQm7j0KFDeP3113H27Fn07NkTw4cPR+fOneHr6wuVSoUTJ05gx44dyMnJwfjx4zF37lyEhYUJ3WxCRIPChZBb/Prrr3juuefg6+uLjz/+GI888ggMBgM2bNgAvV4Pf39/PPnkkzAajdiwYQM++OADdOjQAd9//z3Cw8OFbj4hokDhQkg9V65cwdChQ+Hj44MNGzagffv2YBgGeXl56NatG6qrqxEbG4sTJ04gKCgILMsiPT0dTz31FB544AGsWrUKnp6eQj8NQgRHA/qE/D+z2Yz58+dDqVTiiy++4IPlbhiGQXJyMhYuXIjt27dj7969TmotIeJG4ULI/8vJycGOHTswevRoJCcn3zNYOAzDYOTIkejTpw9WrlwJk8nk4JYSIn40xYWQ/5eZmQm1Wo0xY8agoKAAdXV1/PeKiopgNpsBAAaDARcuXIC/vz///ebNm2P06NH44IMPUFZWhujoaKe3nxAxoXAh5P9dunQJ3t7eiIuLw4svvoiMjAz+eyzLQq/XAwBKSkrw8MMP899jGAaLFy9Gp06doNFoUFJSQuFC7nsULoT8P61WC5lMBk9PT+j1euh0utv+HMuyf/meyWSCQqGwCiFC7mcULuS+xrIsbty4gfz8fFy/fh0ajQYqlQq9e/eGj48P/3NarRaZmZl8iPTr14+/cZJhGMTExKC8vBwmkwlZWVno0qWL1WUzQu43NBWZ3FdYlkV5eTny8/NRUFCAgoICaDQaSKVSVFVVYcWKFfj8888xdepUq9/Ly8tDz549UV1djVatWuH48eMIDAzkv88wDN555x0sXboUPj4+kMlk6NSpE/r374/+/fujT58+CAgIcPKzJUQ4FC7ErbEsi+vXr1uFiVarhVQqRXR0NGJjY9GqVStERkaitLQUQ4cORWhoKPbu3WtVedzpPhfuMUpKSpCamooOHTrg008/xbFjx5CZmYmMjAwUFxeDYRh07NgRycnJ6NevH/r06cP/PiHuiC6LEbdisVhw/fp1FBQUID8/H1evXuXHUqKjo9G7d2/ExsYiOjoacrkcJpMJarUaNTU18Pf3x7Rp0/DPf/4Tn332Gd5+++0GrRmm1+vx4YcfoqKiAtXV1ZgzZw7GjRuHZcuWQS6X49q1a8jIyEBGRgZ27NiBFStWgGEYtG/fHsnJyXxlExwc7IQeIsQ5qHIhLo0Lk/z8fD5MdDodZDIZWrRogVatWvFhUj8ojEYj6urqoNfrIZVK4evrCy8vL9TV1WHKlCnYvXs35syZg2nTpsHLywv5+fno1asXf1ns6NGjCAwMRG1tLebNm4evvvoKS5cuxZAhQ7Bx40b8/vvvCAgIwBNPPIHhw4db3bV/7do1vqrJyMjAtWvXAAAdOnRAv3790L9/f/Tt2xchISFO709C7IXChbgUi8WC0tJS/hJX/TCJiYlBq1at0KpVq7+ECedOoVLfjRs38Pe//x07d+7EkCFD8Prrr6Ndu3a4fPkyLBYLPDw8kJCQgKNHj2LRokU4ffo0PvzwQ0ybNg1SqRQAUFpaig0bNmD//v3w8/PjQ+bWxwKAwsJCZGZmIjMzE+np6bh69SoAoF27dujfvz8fOBQ2xJVQuBBRs1gsKCkpsQoTvV4PuVxuFSZRUVF3vYRVP1RkMhl8fHxue6Ln1NXVYeXKlfjss89w/fp1xMXFITExEX5+flAqlbh8+TJKSkrQvXt3vP/++xgwYAAkkr8ueFFWVoaNGzfit99+g6+vL5544gmMGDHiro9dXFxsVdnk5+cDANq0acNPEOjXrx+twkxEjcKFiIrZbP5LmBgMBsjlcrRs2dIqTLgq4W5sDZVblZWVYf/+/Thw4AAuXryI3NxcdOjQAT179sTgwYPRu3dveHt73/PvXL9+HRs3bsSvv/4KX19fjBkzBiNGjIBCobjn75aWlvJVTWZmJnJzcwEArVu35qua/v37o1mzZg1+XoQ4GoULERQXJtxsrmvXrsFgMMDDwwMxMTH8bK7mzZs3KEw4RqMRarUaBoOhUaFyO/n5+fj444/xzjvvoFWrVo36G+Xl5XzIeHt7Y8yYMXj00UcbFDKcsrIyq8omJycHAJCQkGBV2URERDSqjYTYA4ULcSqz2Yzi4mJ+Nte1a9dgNBrh4eHBVyaxsbGIjIy0KUw4jggVzrVr1zB//ny88847iImJadLfKi8vx6ZNm7Bv3z4oFAqMHj0ajz32WIOqoFtdv36dD5vMzExcuXIFABAfH49+/frx058jIyOb1GZCbEHhQhzKZDJZhUlhYSGMRiM8PT3/Eia3G7NoKEeGCsee4cK5ceMGNm3ahL179zY5ZOr/zfqVzeXLlwEAsbGxVpVNVFSUXZ4DIbdD4ULsymQyoaioiB8zuXbtGkwmEzw9PfnxEu6mxaaECcdgMKCuro4PFV9fX4dt1uWIcOFUVFRg8+bN2LNnDzw9PTFq1Cg8/vjjVkvQNOVvc7PRMjIykJWVBQBo2bIlX9X079+fFtskdkXhQprEZDKhsLCQD5PCwkKYTCZ4eXnxQRIbG4vw8HC7hAnHmaHCcWS4cCorK7F582bs3r0bHh4eGDVqFEaOHGmXkKn/GIcOHeIvo124cAEAEBMTY1XZOOo5kvsDhQuxidFotAqToqIifjHHli1bIjY2FrGxsWjWrJldw4QjRKhwnBEunMrKSvz000/YvXs35HI5Ro4ciVGjRtk1ZDhVVVU4fPgwMjIykJ6ejosXL4JlWbRo0cJqNlpMTEyDN1AjhMKF3BUXJtxsLm7TLG9vbz5MWrVqhfDwcIeeeOqHilwuh4+Pj9P3qndmuHCqqqrw008/YdeuXZDJZBg5ciRGjhwJPz8/hz2mUqnE4cOH+enP58+fB8uyiIqK4qua5ORktGzZksKG3BGFC7FiMBj4yiQ/Px/FxcV8mNS/zNWsWTOnnFgMBgPUajWMRqNgocIRIlw4SqUSW7ZswY4dOyCVSvH4449j9OjRDg0ZjkqlwpEjR/gJAufOnYPFYkFkZCRf1fTv3x+xsbEUNoRH4XKfMxgMuHbtmlWYWCwW+Pj4WIVJWFiYU08cYgoVjpDhwuFCZufOnZBIJHj88ccxatQop+4dU1NTgyNHjiA9PR0ZGRk4e/YsLBYLIiIi+Kqmf//+iIuLo7C5j1G43Gf0ej0fJgUFBXyY+Pr6WoVJaGioICcGMYYKRwzhwlGpVNi6dSt27NgBhmHw6KOPYsyYMYJsUFZbW2tV2Zw5cwZmsxnNmjWzqmwSEhIobO4jFC5uTq/X4+rVq3yYlJSU8GHCjZfExsYiJCRE0De+Xq9HXV0dHyq+vr7w8PAQrD23I6Zw4dTU1PCXy1iW5UNGyI3J1Go1HzaZmZk4deoUzGYzwsLCrBbibN26NYWNG6NwcTM6nQ7Xrl3jB+BLSkrAsiz8/PyswiQ4OFgUb2xXCBWOGMOFU1NTg61bt+KXX36BxWLhQ6b+bplCqaurw9GjR/nK5tSpUzCZTAgJCbGqbNq0aSOKY5LYB4WLi9PpdLh69SofJqWlpWBZFv7+/nyQtGrVSjRhwnGlUOGIOVw4NTU1+Pnnn7F9+3ZYLBaMGDECY8aMEdWulxqNBkePHuVv6jx58iSMRiNCQkLQr18/vrJp27atQ6azE+egcHExWq2Wv8yVn5+PsrIysCyLgIAAqzAJCgoSVZhw6oeKh4cHfHx8RB8qHFcIF05tbS22bduGbdu2wWQyYfjw4Rg7dqyoQoaj1Wpx7NgxvrI5efIkDAYDgoOD0bdvX76yadeuHYWNC6FwETmNRmMVJtevX+fDhLthsVWrVggMDBRlmHD0ej3UajVMJpPLhQrHlcKFo1ar+UrGaDTikUcewdixY0W9pbJOp8Px48f5mzpPnDgBg8GAwMBAPmySk5PRvn17ChsRo3ARGY1Gww++c2ECAEFBQVaViRiupTeEO4QKxxXDhVNXV4dt27bh559/htFoxLBhwzB27FiX2N1Sp9PhxIkTfGVz7NgxGAwGBAQEoG/fvvz05w4dOjRqJW3iGBQuAqurq7MKk/LycgA3w4QLElcKE447hQrHlcOFU1dXh+3bt2Pr1q0wGAwYNmwYxo0b5xIhw9Hr9Th58iS/edrRo0eh1+vh7++PPn368ItxduzY8a67kxLHonBxMrVabRUmN27cAAAEBwdbhYmQU0mbQqfToa6ujg8VX19fyOVyoZtlF+4QLpy6ujr88ssv2Lp1K3Q6HR8yoaGhQjfNZgaDASdPnuSnPh85cgQ6nQ5+fn7o3bs3HzadO3emsHEiChcH48KEm83FhUlISIjVZS4hbn6zJ3cOFY47hQtHo9HwIaPVajFkyBCMHz8eYWFhQjet0QwGA06dOsXPRjty5Ai0Wi18fX3Rp08ffjZa586d3e4YFRMKFzurra21qkwqKioAAKGhoVaViTPWhHKG+yFUOO4YLhytVosdO3Zgy5Yt0Gg0GDJkCMaNG4dmzZoJ3bQmMxgMOHPmDF/ZHD58GBqNBt7e3ujTpw9/Y2fXrl3d9tgVAoVLE9XU1FhVJpWVlQCAsLAwqzDx9fUVuKX2VT9UPD094ePj4/ZvTHcOF45Wq8XOnTvx008/QaPR4OGHH8aTTz7pFiHDMRqNOHv2LB82hw4dQl1dHby9vdGrVy8+bJKSklx+nFBIFC42qq6utgqTqqoqAECzZs34y1wtW7Z0uzDh3I+hwrkfwoWj1Wqxa9cu/PTTT1Cr1Xj44Ycxfvx4RERECN00uzOZTDh79iy/xcDhw4ehVqvh5eWF3r1785fRunXrRmFjAwqXe6iurkZ+fj4fJkqlEsDNMKlfmThiEycx0el0UKvVMJvN912ocO6ncOHodDo+ZGpra/HQQw/hySefdMuQ4ZhMJpw/f56f+nzo0CHU1tbC09OTr2z69++P7t27U9jcBYXLLVQqFR8k+fn5UKlUAIDw8HCrMPH29ha2oU6i1WpRV1d3X4cK534MF45er+dDprq6mg+ZyMhIoZvmcGazGRcuXOC3GDh8+DCqq6vh6emJHj168GHTo0cP0azgLQb3dbiwLAuVSmV1mUulUoFhGKswadmy5X0TJpxbQ8XX1/e+n8Z5P4cLR6/XY8+ePdi0aROqq6sxaNAgTJgwAc2bNxe6aU5jNptx8eJFq8pGpVLBw8PjL2Hj5eUldHMFc1+FC8uyUCqVVmFSXV0NhmEQERFhFSYKhULo5gqCQuXOKFz+x2AwYPfu3di8eTOUSiUfMlFRUUI3zeksFguysrL4mzozMzOhVCrh4eGBbt268ffZ9OzZ8746r7h1uLAsi6qqKqswqampAcMwiIyM5AfgY2Ji7qsX/XYoVO6NwuWvDAYD9u7di02bNqGqqgoDBw7EhAkTEB0dLXTTBGOxWHDp0iWryqayshJyuRzdunXjZ6P16tXLra+IuFW4sCyLyspKqzCpra0FwzBo3ry5VZjcz+Uqh2VZfvaX2WyGl5cXfHx8KFTugMLlzgwGA/bt24eNGzeiqqoKDzzwACZMmIAWLVoI3TTBWSwWXL58mb+pMyMjA5WVlZDJZOjWrRs/G61Xr15uNTHIpcOFC5P6A/BqtRoSiYQPE+4yFw20/Q+FSuNQuNyb0WjkQ6ayshIDBgzAU089RSFTD8uyuHLlCn+fTXp6OioqKiCTydC1a1c+bHr37u3StzS4dLiYzWZ8/PHHMJlMiIqK4sMkJiaGwuQu6urq+Hn8FCoNR+HScEajEb/++is2btyIuro6rF+/nq4W3AHLssjJyeGrmoyMDJSXl2P27Nl49dVXhW5eo4kuXC5evAiz2dzgpbNra2vh7e1t81LbLMuiQ4cOjWmi6Oh0Opt+3mKxgGXZRi1P7k4nCG5v94aGa21tLU6ePIlu3brZtHyPxWJBt27dGttMUcnIyIDJZGrwdHSWZaHRaGy+3GOxWJCcnNyYJorSzp07+Q3yGsJsNoNhGJv3q+G2uBYD0X1kLSwsxPXr1xEXF4e+ffs67HF+++03twkXo9HIr+3lyAFCrtpxF3l5eSgpKUHbtm0xaNCge/68xWJB586d4e3tbdOb/ueff3abcLl06RIKCgrQtWtXPP744w7boO7bb791q3A5fvw4srKykJqaihdeeMFh/fbhhx9SuNzNwIEDsWbNGlgsFqSkpIh6h0Wx8PHx4W/49Pb2pj5roOHDh+Pzzz+H2WzGkCFD7tpvUqnUZbdCsKenn34a7777LkwmE8aNG0fHWgO98cYbGDt2LIxGI/7xj3+4fb+Jco/QFi1aYMqUKUhPT8d///tfiOzKnSh5eHggKCgIdXV1qKuroz5roLi4OLz++uv49ddfsXPnTuq3Bmjbti0WLFiAn376CevXr6c+a6AePXpg+/bt+OKLL7BgwQK37zdRhgsANG/eHM8//zyOHj2K3377DRaLRegmiZ5cLkdwcDA0Gg3UarXbH7z2EhMTg1mzZuHAgQPYtm0bHWsNkJCQgE8//RQ7duzA999/T8daA3Xu3Bk7duzAd999h48++sitjzXRhgtwcz2vv/3tbzh16hT27Nnj1i+EvchkMgQHB0On06G2tpbe9A3UvHlzvPHGGzh06BA2b95Mx1oDtGrVCp9++il++eUXbN68mY61BmrXrh12796NDRs24N1333XbY03U4QLc3GTrhRdewMWLF7Fjxw63fSHsiQsYg8EAlUoFk8lEb/wGCA8Px5tvvonTp0/jxx9/pGOtAWJiYrBgwQL8+OOP2LFjB0wmk9BNcgnx8fHYs2cPdu3ahVmzZsFsNgvdJLsTfbgAQFBQEF544QXk5eVh8+bN0Gq1QjdJ9KRSKYKDgyGRSKBUKqmKaaDQ0FC8+eabyMrKwtq1a93yTW9v8fHxmDdvHrZs2YI5c+ZAo9EI3SSX0LJlS+zduxcHDhzAq6++6nbB7BLhAgABAQH429/+Bq1Wi5UrV1LANIBEIoG/vz8CAwNhMBhQW1srdJNcQlBQEN544w3k5+fj22+/pYBpgPbt22Pp0qWQSCR4++23qc8aqHnz5ti9ezeOHz+OF198EUajUegm2Y3LhAsA+Pr6YuLEiWjWrBm+++47umzRAAzDQC6XIygoCFqtlqqXBgoICMAbb7yB0tJSfPXVV271pneU4OBgvPfee9Dr9Vi4cCEFTAOFh4dj9+7duHLlCiZPngy9Xi90k+zCpcIFuDmeMHbsWGi1WuzevZtOlg3E3fTnLgeuM/j6+mLWrFlQqVRYsWIFBUwDyOVyfPrpp8jJycGSJUvoA2ADhYSEYOfOnSgpKcHEiRPd4sqMy4ULcHM8YerUqThz5gwOHjxIn5AagGEY+Pn5oaamhgLZBt7e3nj99deh1WrxxRdf0MmyAfz9/bF48WKcOXMGK1assHl5ovtVQEAAtm/fjtraWowbN47fUt1VuWS4ADdfiClTpuDEiRNYv349DSI2gEKhAMuy0Ov1MBgMYFmW/yJ3plAo8Nprr6G8vJymKTdQYGAglixZgkuXLuHtt99GZWWl0E1yCX5+fti6dSsCAgIwfPhwlz6vuWy4AEBkZCReeOEFyGQyfPPNN25RSjoSV71oNBqoVCr+bn66o//ePD09MWvWLFy4cAHr1q3DjRs3hG6S6DVr1gwLFy5ETEwMZsyYwS9PRO7O29sb3333HYKDg/HEE0+4bAXj0uEC3LwuPn78eISEhGDVqlWoq6sTukmiplAoEBQUhKCgIL6C0Wg0FMwNEBISgpkzZ0Kn02HBggWorq4Wukmix1V9HTt2xMyZM6nPGkgul2Pz5s2IjIzEo48+ioqKCqGbZDOXDxfg5hjM+PHjERYWhlWrVkGtVgvdJNFiGMZqBllQUBACAwPpPpgGCggIwNSpU9G5c2csWrQINTU1QjdJ9CQSCWbMmIGEhATMnDnTZT+JO5tCocBXX32F1q1bY9iwYbh+/brQTbKJW4QLcDNgxo4di+joaHz99df0CakBJBIJHzTAza1qyb1JJBJMnDgRcXFxWLhwIZ0sG0AqleLNN99EmzZtMGPGDJf8JC4EmUyGr7/+Gr1798YjjzyCkpISoZvUYG4TLsDNA3jUqFGIj4/H119/TW/6BmIYBv7+/qiurqbqpYEkEgkmTZqEtm3bYuHChXSybACpVIoZM2aga9eueP3111FWViZ0k1yCTCbD8uXLkZqaiqFDh+Lq1atCN6lB3CpcgJtv+kcffRTt27fH119/TW/6BvLy8oJMJoNSqaTZUA0kkUjw1FNPoWvXrli4cKHLXbYQglQqxfTp09GvXz/MmDEDRUVFQjfJJUilUixevBjDhw/HsGHDkJubK3ST7sntwgW4+aYfNmwYunbtipUrV6K8vFzoJokewzAICgoCwzCoqqpyu3WOHEUikWDs2LHo06cPPv30U5e6bCEUiUSCF198EQ8++CBmzZrlMp/EhSaRSDBv3jyMHz8ejzzyCC5duiR0k+7KLcMFuPlCDB48GL169cKqVatQWloqdJNEj2EYBAYGwsPDA1VVVXRHegNJJBKMGjUKAwYMwKJFi1BYWCh0k0RPIpFgypQpGD58OGbNmuUSn8TFQCKRYPbs2Zg8eTJGjBiBc+fOCd2kO3LbcAFuniwHDRqE5ORkfPPNN/SmbwDuXhhvb28olUoKmAZiGAYjRozA4MGDsWTJEuTl5QndJNFjGAYTJ07EE088gTfffFP0n8TFgmEYvPXWW3jllVfw2GOP4fjx40I36bbcOlyAmy9ESkoKBg4ciNWrV6OgoIAGre+BYRj4+PjAx8cHSqWSv5uf3B3DMBgyZAiGDx+O5cuXIzs7m/rtHhiGwbhx4/D000/jnXfewblz56jPGoBhGPzjH//Am2++iTFjxuDQoUOi6zeZ0A1wBoZh0K9fP8jlcnz//feYMGGC0E0SPYZh4O3tDYZhoFQqERgYKHSTXALDMHjwwQchl8vxxRdf4KWXXhK6SaLHMAxGjRoFT09PzJ49G//617+EbpJLYBgGL730Ery8vPDkk09izZo1QjfJiijDxVGXYpKSksAwDI4cOYKQkBCHPIZQHPWpRaFQAAC0Wi2kUqlDHkNIjjrW+vXrB4Zh8OeffyIsLMwhjyEUR90P9fDDDwMAdu7cicjISIc8hpActYDnhAkTwDAMvvnmG8TGxjrkMRqDYUVWS125csXhU2EtFgukUinatGnj0MdxFr1e75SSmGEYeHp6OvxxnOX8+fMOX1HbYrFAJpOhU6dODn0cZzl27JjD+8xsNkMul6NXr14OfRxn+v333x0+A9NkMsHT05MPaaGJLlyc2RyGYZz2WI5EfdY41G+2oz5rnPux30QXLrYyGo2oqKhAaGgov4wJuTuWZWEymSCTyURzILoCg8GAsrIyREREwMPDQ+jmuAS9Xo/CwkK0aNHCrapeR9NqtcjOzkZiYiJ/adrVuPxssYqKCqxYsYLuxLeByWSiGyUboaysDPPnz6dlS2xQWFiI6dOn020ANsrOzsagQYOQnZ0tdFMazeXDhRBCiPhQuBBCCLE7ChdCCCF2R+FCCCHE7ihcCCGE2B2FCyGEELujcCGEEGJ3FC6EEELsjsKFEEKI3VG4EEIIsTsKF0IIIXZH4UIIIcTuKFwIIYTYHYULIYQQu6NwIYQQYncULoQQQuyOwoUQQojdUbgQQgixOwoXQgghdkfhQgghxO4oXAghhNgdhQshhBC7o3AhhBBidxQuhBBC7I7ChRBCiN1RuBBCCLE7ChdCCCF2R+FCCCHE7ihcCCGE2J1LhwvLsqisrIRKpUJlZSVYlhW6SaLHsiwqKipw7do1VFRUUJ81EMuyqKqqQm1tLaqqqqjfGoDrM61WS31mA5ZloVQqYbFYoFQqXbffWBekVCrZZcuWsfHx8SwA/is+Pp5dtmwZq1QqhW6i6FCfNQ71m+2ozxrH3frN5cJl7969rI+PD8swDMswjNWLwP1/Pj4+7N69e4VuqmhQnzUO9ZvtqM8axx37zaXCZe/evaxUKmUlEolV59/6JZFIWKlU6lIvhKNQnzUO9ZvtqM8ax137jWFZ17igp1KpEB0dDa1WC4vFcs+fl0gkUCgUKCoqQmBgoOMbKELUZ41D/WY76rPGced+c5kB/TVr1kCj0TToBQAAi8UCjUaDtWvXOrhl4kV91jjUb7ajPmscd+43l6hcWJZFYmIi8vLybJo5wTAM4uLikJ2dDYZhHNhC8aE+axzqN9tRnzWOu/ebS4RLRUUFwsLCmvT7ISEhdmyR+FGfNQ71m+2ozxrH3fvNJS6LqdXqJv1+bW2tnVriOqjPGof6zXbUZ43j7v3mEuHi6+vbpN/38/OzU0tcB/VZ41C/2Y76rHHcvd9cIlxCQkIQHx9v8/VFhmEQHx+P4OBgB7VMvKjPGof6zXbUZ43j7v3mEuHCMAymT5/eqN999dVXRT3o5SjUZ41D/WY76rPGcfd+c4kBfcC954M7CvVZ41C/2Y76rHHcud9conIBgMDAQGzZsgUMw0AiuXuzJRIJGIbB1q1bRf8COBL1WeNQv9mO+qxx3LrfnL0kQFM1dA2effv2Cd1U0aA+axzqN9tRnzWOO/aby4ULy95cPXT58uW3XT10+fLlrEqlErqJokN91jjUb7ajPmscd+s3lwwXjsViYffv388CYPfv389aLBahmyR61GeNQ/1mO+qzxnGXfnOZMZfbYRiGv/YYGBgo+tkTYkB91jjUb7ajPmscd+k3lw4XQggh4kThQgghxO4oXAghhNgdhQshhBC7o3AhhBBidxQuhBBC7I7ChRBCiN1RuBBCCLE7ChdCCCF2R+FCCCHE7ihcCCGE2B2FCyGEELujcCGEEGJ3FC6EEELsjsKFEEKI3VG4EEIIsTuXDRe1Wo0rV67g3LlzAICysjIYDAaBWyV+arUaV69eBQBkZWWhsLCQ+u0ejEYjiouLkZWVBQDIzc1FVVUVLBaLwC0TNzrWbOdO5zWGZVlW6EbYIi8vD6tWrcIvv/yCwsJCGI1G6PV6+Pv7IykpCZMmTcLo0aPh5+cndFNFpX6/Xb16FVqtFh4eHvDx8UGnTp2o325DpVJhy5YtWL9+PS5cuIDa2loYDAZ4eXkhLCwMKSkpeP7559G/f3/IZDKhmysadKzZzh3Pay4TLmazGT/++CPeeecdaLVaDBs2DA8//DBiYmJgsViQk5ODPXv24I8//kC3bt3w+eefo3379kI3W3DUb41z6NAhvP766zh79ix69uyJ4cOHo3PnzvD19YVKpcKJEyewY8cO5OTkYPz48Zg7dy7CwsKEbrag6FiznVv3GesCzGYz++9//5v18fFhhw0bxp45c4Y1mUxsZmYmu3z5cnb58uVsVlYWazAY2AMHDrA9evRg27Rpw547d07opguK+q1x9u3bx0ZGRrKJiYnsTz/9xGo0GlalUrH/+c9/2OXLl7Pfffcdq9Vq2ZqaGvbrr79mmzdvzj788MNsWVmZ0E0XDB1rtnP3PnOJcPnjjz/YwMBA9oknnmCrqqpYi8XCsizLvvfeeywAFgD7/fffsyzLshaLhb169Srbr18/Njk5mVUqlQK2XFjUb7a7fPkyGxsby3bs2JE9f/4832e5ublsQEAAC4CNjY1lq6qqWJa92W8HDx5ko6Oj2YkTJ7I6nU7I5guGjjXbuXufiX5AX6vV4sMPP0R4eDiWLl2KwMBAMAxzx59nGAYtWrTA559/jitXrmDdunVObK14UL/Zzmw2Y/78+VAqlfjiiy/Qvn37u/YZcLPfkpOTsXDhQmzfvh179+51UmvFg441290PfSb6cDlx4gQOHz6Ml19+GVFRUfd8swM3X4iuXbti3LhxWL16NTQajRNaKi7Ub7bLycnBjh07MHr0aCQnJzeoz4Cb/TZy5Ej06dMHK1euhMlkcnBLxYWONdvdD30m+ikuf/75Jzw9PfHQQw8hKyvL6o17/fp1/t/Xrl3D2bNn+f8dGBiIkSNHYt26dSgoKHCdQTA7oX6zXWZmJtRqNcaMGYOCggLU1dXx3ysqKoLZbAYAGAwGXLhwAf7+/vz3mzdvjtGjR+ODDz5AWVkZoqOjnd5+odCxZrv7os+Evi53LxMnTmRbt27NXrlyhY2JiWG9vLz4L5lMxl+blMvlVt+bPHkym5+fz4aGhrJ79uwR+mk4HfWb7d588002MDCQzcrKYh988EGrfvH09OT7jGEYq+8pFAr2yy+/ZNPS0lg/Pz/2yJEjQj8Vp6JjzXb3Q5+JunJhWRY6nQ6enp6QSqXQ6XTQ6XS3/Vmj0Qij0cj/b4PBAA8PD/737ifUb42j1Wohk8ng6ekJvV5/x+fP9W99JpMJCoUCLMtCr9c7o7miQMea7e6XPhN1uDAMg9DQUBw9ehRmsxkDBw6ESqXiv5+dnY28vDwAQKdOndC8eXP+e507d4ZKpYJGo8GhQ4egUCgQHR2N6OhoBAQEOPupOJU9+k2v1yM4ONjZTRdUs2bNoNVqoVKp0Lt3b/j4+PDf02q1yMzM5EOkX79+/I2TDMMgJiYG5eXlkEgkCAoKEuopOJ3ZbEZQUBCqq6vpWLsLnU6Hixcv4tSpUzh9+jTS09Mhl8vdus9EHS4A0L17d6xZswZlZWVYv3691fdmz56N+fPnAwBmzZqFp59+mv8ewzD4/vvv4eHhgcTERFy5cgVHjhwBAPj6+vJBEx0djebNm7vdHdZN7TcvLy+0atWKX+KEYZgGD3C7opqaGlgsFuh0Ohw9ehQLFiyw+n5eXh569uyJ6upqhIeHY+PGjQgMDOS/zzAM3nnnHYSHh7v1eIvFYoHJZOK/WJZFp06dsG7duiYda/Hx8U59Ho7EsiyKi4tx+vRpPky4cRWFQoFOnTohOTkZu3btcus+E/0ZddCgQfDz88OaNWvQt29fqxCQSCRW/5ZKpfz/1mg0WLt2LQYOHIjJkydDKpWirq4ORUVFKC4uRlFREQ4cOACj0QiJRMKfFFq0aIGoqCiX//TZ1H5LTk7mPzGxN++HAvC/kHGHoLFYLMjKykJaWhrOnDkDo9GIZs2aYc2aNZgwYYLVgH39PmIYxqrfWJZFSUkJfvrpJzz00EMwGo2oq6uDQqGw6mtXVT9MuEkNUqkUnp6ekMlkGD58OObOndukYy0iIsJ5T8jOtFotzp8/zwfJ6dOnUVFRAQBo2bIlkpKSMHr0aCQlJaFNmzaQSqXIy8vDwYMH3brPRB8urVq1wtNPP41Vq1Zh1KhReOSRR+55YrNYLFi9ejVOnTqFbdu28S+Oj48P2rRpgzZt2vA/V15ejuLiYhQWFiI3NxfHjh3jf5arbKKiohAVFQW5XO7YJ2snFosFgYGBGDVqFH744YdG91v9A54LF5ZlraoZ7r+uFDYqlQqZmZlIT09HZWUloqKiMG7cOPTu3RtJSUmYOXMmPvvsM7z99tsNqmj1ej0++ugjaLVavPLKK/D09ERdXR3UajU8PT2hUCjg6enphGdmH7erThiGgVwu5wOl/uvdlPdoZmYm5s2b5zIhzLIsrl27xofI6dOncenSJZjNZnh7e6Nz58544oknkJSUhK5du97xQ6o9z2tiJfpwkUgkePPNN5Geno5p06bhu+++w8CBAyGRSCCRSPgDnWEYsCwLs9mMDRs24P3338e0adPQv3//u/7tiIgIREREoHv37gBufgopKiriv9LS0mAwGMAwDF/dcF9ivOap0+lQW1sLhmHwz3/+EydPnrRLv9UPEuB/1YyrVDUWiwUXLlxAWloazp07B5lMhp49eyI5ORmxsbF8m5977jkcPHgQCxYsgLe3N6ZNmwYvLy8AgEwmg0wms6pYamtrMW/ePGzYsAFLly5Fx44dAQB+fn7QarX8GI5UKoVCoRBtNcMFidFo5D88cJMb6j/n22nKe7Rv377Yt28flEolXnvtNYSEhDjrKTeIRqPB2bNnrS5xKZVKAEBsbCySkpIwfvx4JCUlISEhocEnfEee18TCZRauvHjxIp555hkUFBRg2rRpmDx5MiwWC0pKSgDcfKGrq6vx5Zdf4scff8TEiROxcOFCeHt7N+lxWZbFjRs3rAKHK3nrTxLgxm6E+oRqNputVu318/MDwzBO6bf6VU39w0kMYaNUKpGRkYH09HQolUq0aNECKSkp6NWrFxQKxW1/58aNG/j73/+OnTt3YsiQIXj99dfRrl07XL58GRaLBR4eHkhISMDRo0exaNEinD59Gh9++CGmTZt225OL0WiEVquFTqcDy7KiqGa46sRoNMJsNoNlWf6kxn3Z+ro19lg7e/YsPvvsM+j1erz44ot4+OGHBTlmWJZFQUEBHyKnTp1CdnY2LBYLfH190aVLF74i6dKli10mBjW0z/79739jw4YNdjuvOYPLhAsAFBcX45VXXsH+/fvh6emJ9u3bo0WLFjCbzSgoKMDly5cREhKCt956C88884zD3rw6nY4ft+G+uOmnzZo1swqckJAQh79RtFot1Go1GIaBv78/PDw8rL5fXFyMjz76CBs3boRMJnN4v91a0QDODRqLxYJz584hLS0N58+fh4eHB3r16oWUlBTExMQ0qA11dXVYuXIlPvvsM1y/fh1xcXFITEyEn58flEolLl++jJKSEnTv3h3vv/8+BgwYcM+KhJuCqtFoYDKZIJVK4eXlBYVC4fBLHNynX6PRCJPJZFWd3FqRNUVjjzW1Wo2vvvoKv/32G7p3747XXnvN4atM19bW4uzZs3yYnDlzBtXV1WAYBgkJCejatSv/FR8f77CKsyF9ZjQa8dprr+G9995zmUusLhUu5eXlOH78OAICApCeno6jR4+ivLwccrkcsbGxGDhwIAYPHoxmzZo5tV0sy6KystIqbMrLywEAXl5e/LgN91/uMktT3alaudPPZmVlYdeuXU7tN2dWNZWVlUhPT0dmZiZUKhVatmyJlJQU9OzZs9F9XlZWhv379+PAgQPIy8uDTqdDUFAQOnbsiMGDB6N3796N+hTpjGqmfnXC3QHe1OqkIZpyrB07dgzLli2DRqPBCy+8gKFDh9qljRaLBXl5eVaD7jk5OWBZFgEBAejSpQu6du2KpKQkdO7c2en7ptytzx544AGcP38eMpkMc+fOFeVl59txqXDJzMyEXC5Hz549Afzv0xjDMKIb3NLr9Xx1w/1Xq9UCAMLCwhAVFcXPTAsLC7P5gLlXtXI3Qvabvasas9mMs2fPIi0tDRcvXoSnp6dVlWJP9S8f2etTLFfNaLVafuYiNzZj62tzr+pELpc7fbynMcdaXV0dvv76a+zbtw/dunXDa6+9ZvMHn+rqapw5c4YPkjNnzqC2thYSiQSJiYl8kHTt2hWtWrUS1TjY7fosKysLc+fOxYwZM/jxYbFzmXC5fv06Tp8+jZ49e4pyIL0hblfdcJ9a61c20dHRdxwPqF+tKBQK+Pr6uswnmdtpbNhUVFQgPT0dGRkZqKmpQWxsLFJSUtCjRw+XuWxwK5PJxE8CYFkWHh4e8Pb2vuvzsVgsfJg4szpxhhMnTmDZsmVQq9WYOnXqHWdUmc1m5OTkWA26czchBgYG8iGSlJSETp06Wd0c60rmzp0LjUaDefPmucRr6hLhwrIsDh06ZFW1uAODwYCSkhKrwOFWOg0JCbEauwkLC4Ner4darYZEIoGfn59N1YoruFfQmEwmnDlzBmlpacjKyoJCoUCfPn2QnJzsVjcu3q2akUgkVtOExVCdOJJGo8GqVauwe/dudOnSBa+//jo8PT35iuTUqVM4e/YsNBoNpFIp2rRpg6SkJH7wvaFjbK6Aq15ef/119OjRQ+jm3JNLhAtXtfTq1cvlb268F6VSaRU2ZWVlMJvNsFgsaNasGVq1aoXExES0aNHCJWaMNAUXNNevX0d6ejoOHToEtVqN+Ph4pKamonv37m4XsLcymUxQq9Wora2F0Wi0mgQgl8shl8shlUrd5gR6K7PZjMuXL2Pbtm1Yv349bty4AZlMBh8fH4SGhvJVSdeuXdGpU6c7VvzuYt68eVCr1Zg/f77oX3PRhwtXtXh4eLhEWttbTU0NcnNzUVZWBqVSibKyMqjVagBAUFCQVXUTHh7uNp9aTSYTTp06hbS0NFy+fJmvUvr378+vHFD/0pnY32i2YFn2ttUJNzjPsixkMhm8vLzg7e0tuvHGpqioqODHSE6dOoVz585Bq9VCKpWidevWMJvNKC0tRc+ePTF79myrdbfuB5cvX8aHH36I1157TfRXcUQfLlzV0rt3b6u1nNyd2WxGTU0NjEbjX8ZWVCoVv6pAcXExSktLYbFYIJPJ+NUEuMDx9fUV+JnYpqysDGlpaTh06BDq6uqQmJiIlJQUdOvWzWqFBKGnO9ub2Wy2ChTg5tiJXC7npwlzz4sbm9HpdPx9N9xMM1d67iaTCZcuXbK6r6SoqAjAzUkvSUlJfGXSoUMHfsbfmTNnsHTpUlRVVWHKlCl4/PHHXep5N9X8+fNRU1ODjz/+WNTPW9ThwrIsMjMz4enpeV9VLRqNBnV1dZBIJPD397/nsjMmkwmlpaX8zLTCwkLU1tYCuDmgWX9mWkREhOg+6RqNRpw8eRJpaWnIzs6Gj48P+vbti5SUlAatn3S3oOH+LTb1qxOuGmEYxmogviH3zej1emi1WhgMBkgkEv6SmRgXYi0vL7cadD9//jz0ej3kcjk6dOhgdV9JZGTkXV83rVaL1atXY/v27ejQoQNmzJiBqKgoJz4b4Vy5cgVz5szBP/7xD/Tq1Uvo5tyRqMOlrKwMZ86cuW+qlvrVire3N3x8fBp9YqypqbEauyktLYXZbIZUKkXz5s35mWktWrRw+px+TklJCT+WotFo0KZNG6SkpCApKalJJ0exVjVcdcLdFQ9YVydNec63VjNyuZyfaSbEczYYDLh48aLVGlzcXeeRkZFWg+7t27dv9NjZuXPnsGTJElRWVuK5557DyJEj3ebS8N188sknUCqV+OSTT0T54QkQcbjcb1WLrdWKrcxmM8rKyqwCp7q6GgDg7+9vNXYTGRnpsOrGYDDgxIkTSEtLQ25uLvz8/NC3b18kJycjPDzc7o9XP2RuXQON+7ej2KM6acxj1q9mGIbhZ5o5spopLS21CpLz58/DaDTCw8MDHTt2tBp4t/frrNfrsXr1amzbtg1t27bFjBkz0KJFC7s+hthw1cv06dPRp08foZtzW6INl9LSUpw9e9btqxaTycTPBGpqtWKr2tpaq2VsSkpK+GVJIiIirAKnqesoFRUVIT09HYcPH4ZWq0W7du2QkpKCLl26OPUSjqOrmttVJ1Kp1CpQnMVsNvP3zXDVjEKhgJeXV5Oeq16vx4ULF6wucXH7vkdFRVndV9K2bVunrSZ+4cIFLFmyBOXl5Zg0aRJGjx7t1lXMJ598gqqqKnzyySeifJ6iDBeWZZGRkQGFQuEyd6M2hqOrFVtZLBaUlZVZTRbgVoD19fXlx20ausGaXq/H8ePHkZaWhvz8fPj7+6N///7o37+/w9eNaog7VTXcfxtyAuaqE+5GRmdUJ7ZqSjXD7VVTf9Cd2/jKy8sLnTp1slrMUejX1WAwYO3atdiyZQtat26NmTNn2n2lBrHIycnB+++/L9rqRZThwlUtffr0ccstiU0mE2pqamAymZxerdiK22CNmyxQXFzM39gXERFhNVmAuwepsLAQBw8exNGjR6HX69G+fXukpKSgc+fOoptMUF9Dq5r6S6wIXZ3Y6l7VzK0bX505cwY3btwAcHPjq/qD7m3atBHtc7106RIWL16M0tJSPPPMM3jiiSdEfew11sKFC1FRUSHK6kV04cJVLd7e3ujWrZvQzbG7uro61NXVQSaTwc/PT/BqxVbcBmv1x26qqqpgMplQWVmJyspKaLVaREREYPDgwXjggQdEt0dHQ9QPGW6JFe6SF2C9xIpcLhfth4O70el0yM7OxsmTJ3H+/HlkZWUhJycHFouF3/iKu7zVpUsXl1t2yWAwYN26ddi8eTMSExMxY8YMtGrVSuhm2VVubi5mz56Nv//97+jXr5/QzbEiunBx16rFlaqVhuJ25fv9999x4MABKJVKBAUFISgoCMHBwVbbR4t5g7XbuXVrX27BSqlUanVXvNAz0GxRf+Mr7quqqgosyyImJgYdOnRA+/btkZSUhA4dOrjFMQrcvPFw8eLFKCkpwdNPP42xY8eKtuJqjE8//RTl5eVYsGCBqKoXUYWLO1YtLMvyYysymQz+/v4uf2BrtVocPXoUaWlpKCwsRFBQED+WEhwcbNMGa1FRUaJYwuVOW/tylUn9BSDtMVbjaNzGV/UH3a9cuWK18VX9qoT7IMeNzej1ejAMY7XUjCszGo1Yv349Nm3ahNjYWMycORNxcXFCN8suuOrl5ZdfFtUOlaIKl5KSEpw7dw59+/aFv7+/0M1psvrVio+PD7y9vUVx4mkMlmWRn5+P9PR0HDt2DCaTCZ06dUJKSgo6dOhwz09MOp3OavsBoTdYA/5anQDgKxNbNs8Sw3013MZXXJhwG18BQEJCgtVU4IZsfGU2m/nFM81mM2QyGT8JwFWPYQDIzs7G4sWLUVhYiAkTJuDJJ590+Q97ALBo0SKUlZVhwYIFohlbEk24sCyL9PR0+Pj4uHzV4k7VikajwZEjR5CWlobi4mKEhIQgOTkZ/fr1a9IUcZZlUVFRYTUzzdEbrNlSnTTleXH/dVRVc7eNr/z9/a0G3Tt37tzkD2ruVs2YTCb8+OOP2LBhA2JiYjBr1izEx8cL3awmycvLw7/+9S9MmzYNycnJQjcHgIjCxV2qFneoVliWRV5eHg4ePIgTJ07AbDajS5cuSElJQbt27Rx2XfdeG6zVr25CQ0Mb1K/2qk4ayx5VDbfxFbeYo1AbX1ksFn6mWf1qxsvLS1TX+hsqNzcXixcvRkFBAcaPH4+nnnrKZQMTAD+utHDhQlFUL6IIF65q8fX1RVJSktDNaRR3qFbq6upw+PBhpKWlobS0FKGhoXyVItTkioZssMZVNwqF4o7VSf0lVoQK+9tVNYB12JjNZuTm5lrdV1J/4ysuSITe+MpgMECj0fDVjKenJ7y9vV3u5GwymbBx40b88MMPaNGiBWbMmIHWrVsL3axGKSgowLvvvouXXnoJKSkpQjdHHOFSXFyM8+fPu2zVYjQaUVtby1crrrTTHcuyyMnJQVpaGk6cOAGLxYKkpCSkpKSgbdu2oqu6brfBmlqthsViQUBAACIjI/l7b5o3b87P7BIjlmVRVVVlNXvr3Llz/AeUNm3aWF3iatmypeheD3epZvLz87F48WLk5eVh7NixmDhxossFJQAsWbIERUVF+PTTTwU/7gUPF5ZlkZaWBj8/P5erWliWRV1dHTQajctVK2q1GocOHUJaWhquX7+OZs2aITk52SUCnqtOuHtPlEolSktLUVZWhrKyMn7sxsPDg1+kk/sScoM1buOr+mFSUFAAAAgODkZSUhJ/bwm38ZUrTXc2GAz84plcNaNQKEQxG7AhTCYTNm/ejPXr16N58+aYOXMm2rRpI3SzbMJVLy+++CJSU1MFbYvg4cJVLf369RNsdd7GMBqNqKmpgcVi4cdWxI5lWVy+fBlpaWk4ffo0APBVSuvWrUV7AmNZ1uqu+Fu39r117MRoNKKkpIQftyksLERdXR0A526wVllZyY+R3LrxVbt27azW4IqKirLqfzHMQGssi8UCnU4HjUbDr8Tt7e3tMtVMQUEBlixZguzsbDzxxBN45plnXCYgAWDp0qW4du0aFi1aJGj1Imi4cFULN8PFFdSvVuRyOfz8/ERfrdTW1iIzMxPp6ekoLy9HeHg4UlNT0adPH9FuJsbdFX/r5ln1A8WWk+ydNliTy+VWWxA0doM1buOr+veVFBYWArj7xlcN0ZCxGrHiqhm9Xg+WZfmZZmI/WZvNZvz000/4/vvvERERgZkzZ6Jdu3ZCN6tBrl27hn/+85944YUXMGDAAMHaIWi4FBUV4cKFCy5TtbhStcKyLC5duoSDBw/i9OnTkEgk6N69O1JSUpCQkCC6E9Kdtvatv8SKPT/11t9gjfuqv8HardXNrZ8Ab9y4YTXozm18JZPJ0KFDB6v7Su618ZWtXLGq4aoZrVbLr7zN3Tcj5mrm2rVrWLJkCS5fvoxRo0Zh0qRJ8PT0FLpZ97Rs2TIUFBRg8eLFglUvgoWLxWJBenq6S1Qtt1Yr/v7+gg+W3Ul1dTVfpVRUVCAyMhIpKSno06eP6CYa3K06qb/EirPcaYM1hmFgsVigVqtx/fp15OXl8eM6kZGRVoPu7du3d/rJx9XCxmg08jPNuJl/3t7eoq1mLBYLtm7dijVr1qBZs2aYMWMGOnToIHSz7oqrXv72t7/hgQceEKQNgoWLq1QtrlCtWCwWZGVlIS0tDWfOnIFUKkWPHj2QkpKCuLg40ZxgnF2dNBa38dXJkydx+PBhXLhwgb/fJjQ0FBEREYiPj0ePHj3QsWNHh2+wZou7BQ33b7FwtWqmqKgIS5YsQVZWFh5//HE899xzdrm511GWL1+O/Px8LFq0SJBL94KEi8ViQVpaGgIDA9GlSxdnP3yDsCwLtVoNrVYr2mpFpVIhIyMD6enpqKqqQlRUFFJTU9GrVy/RhCC3krBYqpNb2brx1a3L2NxugzVuCwIxLLzqKlWN0WjkZ5px1YxCoRDdJSiLxYJt27Zh9erVCAkJwYwZM9CpUyehm3VbhYWFePvttzF16lQMHDjQ6Y8vSLhwVUv//v1FOaBsMBhQW1vLL/KnUCiEbhLPYrHg/PnzSEtLw7lz5yCXy9GzZ0+kpKSgVatWgp8wbledMAxjdVe8UJ9KuY2v6gfJxYsXm7Tx1a0brBUVFUGlUgEA/Pz8rG7ybMgGa47kClUNy7L8fTP1qxkvLy9RfbgrLi7GkiVLcOHCBTz22GOYPHmyqM4TnM8++4xficDZx57Tw0XMVYuYq5WqqipkZGQgIyMDSqUSLVq04KsUoUvzO1Un9e+KFwK38VX9xRy5ja9iYmKsBt3tufFV/Q3WuOqm/gZr9ScLCLmFt9irGrFXMyzL4pdffsG3336LoKAgvPbaa6IbPy4qKsLbb7+NKVOmYNCgQU59bKeHC7eGmBirltraWuh0OtFVKyzLYvbs2aiurkavXr2QkpKCmJgYUZwALBYLamtrRbe1LwDs3r0br732GhQKBb/EPPflzH1l7rTBWmhoKF5++WWnteNubg0ahmFE8RoCN9vGjc0YjUYEBAQI/oGqvtLSUr6K+e677xAeHi50k6x8/vnn/AoEzjxnNDlcGvPrdXV1jZq5ZGvH2No27s3VmDeVo9umVquhUCgaVUk5um0Wi6XRJyJb2taYdplMpkbtFOnoPjMajdDr9Y36gOXotjWFo9tmMpkaXWE68lgDbr5Hxfh6cltbNKbia0oYNTlcuMFPR+Ku20dERNj0ezqdDoDjryVzN4fZ4uTJk/xaTI7EsqzNWxgYjUYHteZ/6i8o2VC//vorjEajw9d8YlkWQ4YMsel3srKynPZ62nozH/ehyRmfWm19DG6pGEfiTnG2vEczMjL4DyaOZLFYbF4in9tPyRnHWq9evRr9+01unUqlQmJiYlP/zB1du3YNFRUV8PX1tTlcuDEAuVzu0NlTarXa5nDJy8tDSUkJ2rZtiwcffNBBLQO2bt1qc7hwA9yOYjAYYDKZ+HGZhjp16hSys7PRt29fPPvssw47KX366ac2hwu3YnNcXBx69erlsLb9/vvvjQ4XwLEftBoTYNxir46i0+mg1+shlUptOqazsrJw9epVdOnSBSNHjnRYv3377bc2h0t2djYKCwvRsWNHDBkyxGFt+/HHH4UNFwAOuTbL/v/Oh3l5eejRowfKysoa9Xd8fHz42Tti21tlxIgRWL58OcxmM4YOHSqqtjmiLSzLQq/XQ6/Xw8fHp1EV0iuvvILJkyfDaDTixRdfFFWfDRgwAOvWrYPZbEb//v1F1TaJRMLfV+SoAfvGXgRxVD+ZzWbU1tYiMDCQvzRki6eeegrvvvsuzGYzxo0bJ6rXc/To0ViwYAFMJhMee+wxUbWNI44Ru1uwLIvc3Fzk5+ejV69eTZpRI5fLERgYyO+1IoIdBnhxcXGYOXMm9u3bhx07doiqbfZWP1h8fX0bXdJ37doV69atw6pVq/DZZ5+Jqs+io6MxadIkZGZm4sCBA6JqGzdAf7sZYu6IZVkolcom7THTrl07LFy4EJs3b8b3338vqj5LTEzEe++9h127dmHz5s2iahtHdOHCsiyys7Nx7do19OrVyy7Lv8vlcgQFBUGr1UKtVovqhYiJicEbb7yBP//8E1u3buU/XboylmVhNBphMBjAsix/J7bBYICvr2+Tp3d36NABP/zwA9avX49FixaJqs8iIyMxadIkHDt2DPv37xfVsXY/BAx3n5VKpYJEIoGPj0+TPtUnJCRg0aJF2LVrF7799ltRHWutWrXC7Nmz8d///hfr168XVdsAkYULy7K4cuUKioqK0Lt3b7suCyOTyRAUFAS9Xo+amhpRvbGioqLw1ltv4fDhw9i0aZPoDhJb1V87Sq1Wo66uDmazGT4+Pna7b6h169bYuHEjfv75Z8ybN09UfRYeHo7JkyfjzJkz2Ldvn6iOtdsFzK1frspkMkGpVEKlUoFhGAQFBdnlclGrVq2wZMkS/P777/jPf/4jqmMtOjoac+bMwaFDh7B69WpRtU004cJVLMXFxejdu7dDBvm4gOE2mOL2VBeD8PBwvPXWWzh16hR++OEHUR0ktuDusPb29oaPjw+8vLzg5eVl12DhxMbGYuPGjdi3bx/mzJkjqj4LDQ3FlClTkJWVhd27d4uqbfUDxmKx8P/l/u2KuMtgHh4eCAoKQkBAgF3HIaKiorB06VJkZmbiiy++ENXrGR4ejjlz5uD06dNYuXKlaNominDhBu8LCwsdFiwcqVSKoKAgSKVSKJVK/o5yMQgNDcVbb72F8+fPY926daI5SGzBnZy4Gynlcnmj7jNpqBYtWmDz5s34448/MHv2bFH1WVBQEKZMmYLc3Fxs375dVG3jAqb+0i/1KxpXU1dXB4Zh+A8xjjjeIiIisHTpUhw7dgyff/65qF7P0NBQzJkzB1lZWaKprgQPF5ZlcfXqVeTl5aFXr15OWRaeYRj4+/vDy8tLdBVMcHAw3nrrLVy8eFGU11HvhduWwJmzVyIjI7Fp0yb8+eef+Oijj0R1cgwICMCUKVNQUlKCn376SVTHWv2lXurPIBNT/90NF4QmkwkajQaBgYEOP+7CwsKwZMkSHDt2DF9++aWo+iooKAhz5sxBdnY2VqxYIfi5Q9BwMZvNuHLlCnJzc9GjRw+nLr3PfcrhAkZsBwkXMGvWrBHVCeluLBYLzGazIEvnREREYNOmTdi3bx8+/vhjUb2evr6+mDJlCpRKJX788UdRVcu3BgvDMKLquzsxmUyoqamBSqXiZ4U5ax3AsLAwLF26FBkZGVi5cqWo+isgIAAffPABcnJyBK9gBAsXnU6H48ePo6KiAr179xZkAT+GYeDr6wuGYUQ3yB8UFIS3334b165dw5dfftmoefrOxG2m5eHhIdic++bNm2Pjxo3YuXMn5s6dK6qTuEKhwHPPPQe9Xo/169eLqm31uUL1wo2ZSiQSKBQKBAQENHlWmK24Cmb//v1YtWqVqD4A1g+Yf//73zAYDIK0Q5Bw0Wq1OHLkCBQKBXr37i3oApbcrBJuUzCTySSaN1ZAQADeeOMN6HQ6LF26lN+wSozq6uogk8kEX1CwRYsW2LhxI/7880+8+uqrqKmpEbQ99Xl6euKZZ56BwWDAhg0bBL9s0RBieS9wuIF7Ly8v+Pr6wsvLS7APNJGRkViyZAnS0tKwcOFC1NXVOb0Nd8IFTFlZGT755BNUVVU5vQ1ODxetVovDhw+jWbNm6NSpk6D7W3AkEgk/bVGpVPL3Z4iBt7c3/vGPf8DX1xeffvqpKAOGm22kUChEcacwN8iv1+sxfvx4lJaWCt0knoeHByZNmoTq6mpR3td06+sntgF+o9HI77MkhmMtKioKy5YtQ3V1NWbOnMlv6SAG/v7++Ne//oXQ0FDMnj0b165dc+rjOzVcDAYDjhw5gvDwcLRt21YUBwdHKpXCz88Pfn5+qK6uFtVlCw8PD7z00ksICgrC4sWLBb1EdruTDddXYno9g4ODsWLFCnTv3h3jxo0TXcBMnjwZJSUl2L59u6guqQA3X0duWnL96cpCY1kW1dXVogkWTnBwMD788EO0a9cOM2bMQHV1tdBN4nl5eeGll17CoEGD8NFHH6GoqMhpj+20cDGZTDhy5AiCg4PRrl07UR0cHIZh4OnpCV9fX6hUKlF9qpTJZJg2bRq8vb2xZMkSQSoYbl+NW8NNp9PBw8PD6e25Fw8PD3z44Yd48MEHMXbsWFy9elXoJvG8vb0xZcoUlJWVYePGjU5ZibqhuPcmtxo5FzZCMxqNYFlWVHstcTw8PDB9+nR07NgRs2bNEtUYqUQiwahRozB06FB89NFH/FqLDn9cZzyIyWTCsWPHoFAo0LFjR1EGC4dhGH63O7HNIpPJZJg+fTp8fHywcOFCKJVKpz6+yWSCwWCAXq+3OtlYLBbR7A54K4lEgtmzZ2PYsGEYP348srKyhG4Sz9fXF5MnT4ZOp8O6desEG3i9G7FMUbZYLKiuroafn59ozx8SiQSzZs1CQEAA3nvvPdF9YBg9ejS6d++OOXPm8NuROJLDw0Wn0+HYsWOQyWTo1q2baHa3uxuGYeDn5weJRAKlUimKT20cuVyOl19+GS1btsQnn3yC8vJypzwuy7LQaDRQKBSQyWR85eSMpdybSiKR4J133sGzzz6Lp59+GufPnxe6STwvLy8888wzkEqlWLt2rSg+8XI3VHI3WQoZLly1XFVVBQ8PD8EnjNyLVCrF3LlzodFo8NFHHznlJN5QDMNg6tSpCAsLwyeffOLwCQgOPdPX1NTg8OHD8PHxcZlg4TAMw9+UJcZLZM8++yx69OiBBQsWNHo7AltwJxa5XA6FQsHPqhPjeMvtMAyDadOm4eWXX8YzzzwjqgpGLpfjqaeegpeXF9asWSOKSRu3LssvxN37XLWiVqvh7e0Nf39/0R9nwM0PDAsXLoRarcZbb72F4uJi0VwB4aorhUKB999/HydOnHBY2xx2tlcqlTh69ChatGiBTp06Oe0GJ3viAkYqlaKqqkpUA68SiQRPPPEEkpOTsXDhQocPWNe/8557gxuNRmi1WtF/muQwDIPnn38eL7zwAiZOnIjs7Gyhm8STyWR48sknERAQgG+//VZUg8KcWwf6HclkMvHTZ4OCgkQzE7GhfHx88PHHHyMhIQEzZszA8ePHRRMwHh4emDlzJh5++GGsXLkSGzdudEjbHBIuKpUKx48fR2JiIuLi4lzqoLgVt1SMp6cnqqqqRDWLjGEYjBw5EqmpqVi4cCGKi4sd8ji33nnPMAy8vb2h1WrBsqwoB/PvhGEYvPTSS5g0aRImTJiAy5cvC90knkwmw9ixYxETE4NvvvkGJSUlojkh1b+T39EBYzQa+XtZAgICHLZWmKN5enrilVdewdSpUzF37lwcOXJENK+nTCbD4MGDMXv2bOzbtw8HDx60+2PYPVy4YGndujViYmJc8qC4FXcnv0KhgFKpFN1A3eOPP45Bgwbh008/tftcdpZlUVdX95f1wmQyGby9vUW3u2dDMAyD6dOnY9KkSXjqqadw8eJFoZvEk0gkGDFiBHr06IG1a9ciJydHNCckLlxuXVHZnoxGI1QqFb+qtqsdW7diGAYPPfQQZs6ciXnz5onqWGMYBs2bN8ebb76JVatW2X381m7hwt05e/z4cSQkJLhNsHC4tci8vb2hUqlEFzAjRozAkCFDsHjxYuTl5dnl73KD+AD+Mv2TYRh+xWNXxDAMXnnlFfztb3/D008/jdOnTwvdJB7DMEhJScGwYcOwefNmXL58WZQBA9jvJkuWZWEwGKBUKvn3mbucP7jXc9q0aXj33Xdx6dIloZtkpW3bthg+fDg++OADu16OtUu41A+WxMREtGzZ0m0OjPq4y0E+Pj6iu5OfYRgMHToUI0aMwNKlS3HlypUmtY3blthsNovupjV7YRgGL774IqZPn47nnnsOx44dE9Xr2blzZ4wcORJbtmwRVQUD2HdXS27nUpVKxV8hcLfjjWEYDBs2DM8++yzeeecdXLhwQTSvJ8MwGDduHNq3b48PPvjAbpdj7bL2SmVlJU6dOoW2bdsiOjra7Q6M+rj7YICblwCFWHDzTrgS3MPDA59//jmmTZvW6L9lMpn4/e7d/fWcPHkyvLy8MHXqVHz55ZdCN4nHMAzatWsHi8WCTZs24cknnxS6SVa4gOFutmwsLlj8/Pzg5eXltscbwzAYNWoUZDIZ3n33XcyePVvoJvEkEglefvll/PDDD5gzZw6mT5/e5L9pl3ApLCxE27Zt0bx5c1FN2QUcNzef+3Sl0WgaPRPOUZfW+vXrBwD4888/ERYW1qi/YTAYoFAo+E+nYuGo+0DGjBkDhmGwbt06xMTENOpvOGqyR9u2bWEwGHDs2DEEBwc36m848jXkBvkbGwoajYYPFkA8i2U66qbWoUOHQiqVYseOHWjevHmj/oaj2jZu3DiEhoZiz549iIyMbNLfYtgmvpI3btyw6cCyWCzQarU2bwrGMIzNJ0pbT0Qsy8JsNtu0mCbLsvyyMbY4d+6cw4PYbDZDLpejU6dONv2eraFnNpsbHbC2jNn8+eefNk8H1+v1Nr02ZrMZHh4eeOCBB2x6nOzsbJteT+7mOlumcVssFshkMiQmJtrUNlvf4twx3Ri2/p5er2/S49nCluPg2LFjNh1r3MQXW1Z4N5lM8PDwQK9evRr8OwBw+vRpm9pmNpuh0+lsOudy546kpCSb2lZfk8PF1l+vrKxEQUEB/P390bx5c5uesK0HoK1tq6urg16v56c/2sLRbTObzdBqtVAoFKJqG3evi7e3d6NWuLalbQ1tF/dGr66uhtFoRHR0tM1tc/TrefnyZZSVlSEyMhIxMTE2hYyj21Z/TTFbObptwM2TsliONU5BQQEqKirQqVMnmz9oOqrPzGYzSktLUVJSwq+QYqumhH6TL4vZ+uAhISEwmUzIzc1Ffn4+QkJCkJCQ4JCxC1vb5uPjA4PBwI+lOHI7AFvbVlJSgnnz5uHdd99t9GWbhmpo2wwGA7RaLTw8PJwya+xe7TKbzdi1axe+/PJL5OXlYcCAAXjllVdE0bZbxcXFoaqqCjt27IBOp0PXrl2RnJwsivcBN47C/duRbG2b0WhEVVUVgoODHfq6NrRdLMti2bJl+PXXXzFr1iyn3FB8r7ZptVrs27cPe/bsgU6nw8CBA/Hoo486fSzL6ZupMAyDiIgIhIeH4/r168jNzcWRI0cQEhKC+Ph4BAUFObtJVm0LCgrit04NCgoSxX4zYlQ/WIRepdZsNmPnzp3497//jYKCAjzwwANYuHAhOnfuLGi77sbDwwP9+vVDjx49cPz4cWRmZuL06dPo0qULUlJSBJ0oUn+g3mKxuNSyTc7EsiyWLl2K3377DW+88QYGDRokaHs0Gg1+/fVX7N69G3q9HgMHDsRjjz3W6HG6phLszFk/ZMrLy5Gbm4ujR48iODgYCQkJgoUMt+QLBcydiSVYzGYzduzYgS+//BIFBQUYNGgQlixZgo4dOwrWJltxIdOzZ08+ZM6cOYPOnTsjJSVF0PcBBcydWSwWLF26FL///jvefPNNDBw4ULC2aDQa7N27F3v27IHRaMSgQYPw6KOPCvpBHRAwXDgMwyA8PBzNmjX7S8jEx8cLkroUMHcmhmAxm83Yvn07VqxYgatXr+Khhx7C0qVL0aFDB0HaYw9yuRx9+/ZFjx49cOLECWRkZFiFjFDvAwqYv7JYLFiyZAn279+Pt956y+bJH/ai0WiwZ88e7N27V1ShwhHNGbN+yNy4cQO5ubn81EshQubWgAkMDHTZu9HtRehgMZlM2L59O7788ksUFhbioYcewvLly9G+fXunt8VR5HI5+vTpg+7du+PkyZPIyMjA2bNnBQsZChhrFosFixcvxh9//IG3334bAwYMcHob6urqsHfvXj5UHnzwQTz66KOiuucOEFG4cBiGQbNmzawqmWPHjiEoKAgJCQlOfXPVDxhukP9+DRghg8VkMuHnn3/GihUrUFRUhMGDB+Pf//432rZt69R2OJNcLkfv3r35kElPT8fZs2fRqVMnpKSkICQkxGltYRgGUqkUZrP5vg4Yi8WCRYsW4c8//8Tbb7+N1NRUpz6+Wq3Gnj17sG/fPpjNZjz00EMYPny46EKFI7pwqY8LmRs3biAnJ4cPmfj4eKe9uShg/hcsnp6eTl1e32g08qFSXFyMoUOHYsWKFWjTpo3T2iA0mUyGXr16oVu3bjh16hTS09Nx7tw5dOzYESkpKQgNDXVaW+7ngDGbzVi0aBEOHDiAf/7zn0hJSXHaY3OhsnfvXlgsFjz00EMYMWIEAgICnNaGxhB1uHDCwsIQFhbGXy47fvw4AgMDkZCQ4JSQuZ8DRohgMRqN2Lp1K/7zn/+gpKQEQ4cOxVdffYXWrVs75fHFSCaToWfPnkhKSsKpU6eQkZHBh0xqaqrTQuZ+DBiz2YyFCxciPT0d77zzDpKTk53yuLW1tdi9ezd+/fVXWCwWDB48GMOHD4e/v79THr+pXCJcOFzIVFRUICcnhw+Z+Ph4h7+57seAcXawGAwGbNmyBV999RVKS0sxbNgwfP311zbfke7OuJCpX8l8+eWX6NChA1JTUxu93I8tuIBpysoMruLWYOnfv7/DH7OmpoYPFQAYPHgwHnnkEZcJFY5LhQsnNDQUoaGhqKioQG5uLk6cOIGAgAAkJCQ4NGTup4DR6/XQ6XROCRaDwYCffvoJX331FcrKyjB8+HC8/PLLSEhIcOjjujKpVIoePXogKSkJp0+fRnp6OlasWOG0kLkfAsZkMmHBggXIzMzEu+++y6/Z5yg1NTXYtWsXfvvtNzAMgyFDhuCRRx6Bn5+fQx/XUVwyXDhcyFRWViInJ4cPmfj4eIe9ubiAqa6udtuAcVaw6PV6PlTKy8v5UImPj3fYY7obqVSK7t27o2vXrjhz5gzS0tKwYsUKtG/fHqmpqWjWrJlDH9tdA4YLlkOHDuG9995D3759HfZYNTU12LlzJ3777TdIJBIMHToUjzzyiE3rlImRS4cLJyQkBCEhIaisrERubi5OnjwJf39/JCQkOCRkGIZBQECAWwaMM4JFr9dj06ZN+Oqrr1BRUYFHH30UL7/8MmJjYx3yePcDqVSKbt26oUuXLjh79izS0tLwn//8B+3atUNqairCw8Md9rjuFjAmkwmffPIJDh8+jPfeew99+vRxyOOoVCrs2rULv//+OyQSCR555BEMGzbM5UOF4xbhwuFCpqqqCjk5OXzIxMfH2/0TnDsGjKODRafTYdOmTfj6669RUVGBxx57DC+//DJatWpl98e6X0mlUiQlJfEhc/DgQXz11VcODRl3ChiTyYT58+fj6NGjDgsWlUqFnTt3Yv/+/ZBKpRg+fDiGDh3qNqHCcatw4QQHB6NXr16oqqpCbm4uTp065ZCQcaeAcWSw6HQ6bNiwAStXrkRVVRUee+wxTJs2jULFgSQSCbp27YrOnTvzlcxXX32Ftm3bIjU1FREREXZ9PHcImPrB8q9//Qu9e/e2699XqVTYsWMH9u/fD7lcjhEjRmDo0KE2bz/iKtwyXDjBwcEIDg62Chk/Pz8+ZOyxSuitARMQEAAPDw87tN55HBUsWq2WDxWlUomRI0di2rRpDl/VmfxP/ZA5d+4c0tLS8PXXX6NNmzZITU1t8oZQ9blywJhMJsybNw/Hjh3D+++/j549e9rtbyuVSuzYsQP//e9/IZfL8dhjj2Ho0KHw9va222OIkVuHC4cLGaVSiZycHJw+fdquIVM/YKqrq10qYBwRLFqtFj/++CNWrlwJlUqF0aNH46WXXkKLFi3s8veJ7SQSCbp06YJOnTrh/PnzOHjwIFauXInWrVtjwIABdgsZVwwYo9GIefPm4cSJE3YNFqVSiV9++QV//PEHPDw88Pjjj2PIkCFuHyqc+yJcOEFBQejZsyeUSiVyc3P5kImLi0N4eHiTQsYVA4YLFi8vL5s3OLodrVaL9evXY9WqVaiursbo0aMxbdo0REdH26G1xB4kEgk6d+6Mjh074sKFC3zIJCYmYsCAAY3edrc+VwoYo9GIuXPn4uTJk3j//ffRo0ePJv/NyspK7NixA3/88Qe8vLwwcuRIDBkyRPCtKZztvgoXTlBQEHr06AGVSoWcnBycOXMGvr6+iI+Pb1LIuFLA2DNYNBoN1q1bh2+++Qa1tbUYM2YMXnrpJURFRdmptcTeJBIJOnXqZBUyq1atQkJCAgYMGNDk184VAsZoNOKjjz7CqVOn8MEHH6B79+5N+nuVlZX45Zdf8Oeff8LLywtjxozB4MGDnbpkkpjcl+HCCQwM5EMmNzeXD5m4uDhEREQ0eptXsQeMvYKlrq6ODxW1Wo2xY8fihRdeoFBxIQzDoGPHjujQoQMuXryIAwcO4JtvvkFCQgJSU1ObVHWKOWAMBgM++ugjnDlzpsnBUlFRwYeKQqG470OFc1+HCycwMBDdu3fnQ+bs2bPIzc1FfHx8o0JGzAFjj2BRq9V8qGg0Gj5U7HFJhQiDYRh06NAB7du3x8WLF3Hw4EF8++23iI+PR2pqaqPHy8QYMAaDAR9++CHOnj2LOXPmICkpqVF/58aNG9i+fTsOHjwIb29vjBs3Dg899NB9HyocCpd6uJCprq5ucshwAVNTUyOagNHpdNDr9Y0OFrVajbVr1+K7776DRqPBuHHj8OKLL9p9WisRTv2QycrKwsGDB/Hdd98hLi4OqampjZrpJ6aAMRgMmDNnDs6dO4cPP/wQXbt2tflv1A8VHx8fjB8/Hg899JBdxi3dCYXLbQQEBKBbt25/CZm4uDhERkY2OGQYhoG/v78oAqYpwVJbW4u1a9di9erV0Gq1GDduHF544QUKFTfGMAzat2+Pdu3a4dKlSzhw4ABWr16N2NhYDBgwwOaQEUPANDVYysvLsW3bNqSnp8PHxwdPPvkkHnzwQQqVO6BwuQsuZGpqapCbm4tz587xlUxDQ0YMAdPYYKmpqcGaNWuwZs0a6PV6jB8/Hi+88IJD16si4sIwDNq1a4e2bdvi0qVLOHjwIFavXo1WrVphwIABaNmyZYP/lpABYzAY8MEHH+DChQuYO3cuOnfu3ODfvX79Oh8q/v7+mDBhAh588EHBr0SIHYVLA/j7+yMpKekvIRMXF4fmzZvfM2SEDJjGBEt1dTUfKgaDARMmTMDf/vY3pyznTsSpfshcvnwZBw8exJo1a9CyZUsMGDCgwastCBEwer0eH3zwAS5evIi5c+eiU6dODfq9srIybNu2DRkZGfD398fTTz+NQYMGUag0EIWLDbiQqa2tRW5uLs6fP89XMvcKmfoBw93J7+hy2tZgqa6uxurVq7FmzRqYTCZMmDABU6dOpVAhPIZh0LZtWz5kDhw4gLVr16Jly5ZITU1t0OKjzgwYvV6P999/H5cuXWpwsJSWlvKhEhAQgIkTJ2LgwIEUKjaicGkEPz8/dO3a9S8hExcXh6ioqDuGzO1mkTkqYGwJFpVKhe+++w5r166F2WzGU089halTpzp1C13ietq0aYM2bdrgypUrOHDgAL7//nvExMQgNTUVcXFxd/1dZwSMTqfD+++/j8uXL2Pu3Lno2LHjXX++pKQE27ZtQ2ZmJgIDA/Hss89i4MCBLrteoNAoXJqgfsjk5eXhwoULyMvL4y+X3WkbWEcHTEODRalU4ttvv8X3338PlmXx9NNP4/nnn3fK1tHEfbRu3RqtW7dGdnY2Dhw4gHXr1qFFixYYMGDAXUPGkQGj0+kwe/ZsZGdnY968eejQocMdf7a4uBjbtm3DoUOHEBQUhEmTJuGBBx6gUGkiChc78PPzQ5cuXRAfH4/c3FxcuHDBqpK5Xcg4KmC4YFEoFHcs428NlYkTJ+L5559HcHCwXdpA7k+JiYlITExETk4OHzLR0dEYMGDAHTeAc0TAaLVazJ49Gzk5OZg7d+4dg6W4uBg///wzDh8+jODgYDz33HMYMGAAhYqdULjYka+vLx8yeXl5uHjxIl/J3C5kbr0PpqkBc69gqaqqwjfffIN169aBYRg888wzmDJlCoKCgpr0uITUl5CQgISEBOTk5ODgwYNYv349oqKiMGDAgNtuXW3PgNFqtfjXv/6F3NxczJs3D+3bt//LzxQVFeHnn3/GkSNHEBwcjMmTJyM1NZVCxc4oXBzA19cXnTt35isZLmRiY2MRHR1tFTL+/v4A0OSAuVuwVFZWYtWqVfjhhx/AMAwmTZqEKVOmIDAwsNHPkZB74UImNzcXBw8exA8//ICoqCikpqYiMTHR6mftETBarRbvvfce8vLyMH/+fLRr187q+4WFhXyohIaG4vnnn0dKSgpkMjoNOgLDsiwrdCPcXV1dHXJzc1FWVgZPT8/bhkxNTQ10Ot1tA4ZlWZw5cwYLFy7Em2++iS5dulhNGrhTsFRUVGDVqlX48ccfIZFI8Oyzz2Ly5MkUKkQQeXl5OHDgAAoLC9G8eXOkpqaidevWVj9jsVjAsuxtA4ZlWZSVlaGoqAjR0dFWq2ZwwZKfn4/58+ejbdu2/O9du3YNP//8M44ePYqwsDA8/vjjFCpOQOHiRHV1dcjLy0NpaSk8PDz4kOHeSLcGjEqlwpo1a/D5558jNzeX/zvx8fGYPn06Jk2aBE9PTxgMBqtguXHjBh8qMpkMkyZNwnPPPYeAgABBnjch9eXn5+PAgQO4du0aIiMjkZqaijZt2vDfvzVg7vU+GDt2LBYtWoSrV69i/vz5/N+6evUqtm7diuPHjyMsLAyjRo1CcnKy4EvQ3C8oXARwt5DhAubIkSOYMGECNBoNgJuf2jjcpzWFQoHvv/8eI0aMgIeHB27cuIGvv/4aGzZsgIeHB5577jk8++yzFCpElAoKCnDgwAFcvXoVERERGDBgAB8MXMD8/vvvGDNmzB3fByzLQiaToXfv3vj222/RunVrFBQU4Oeff8bx48cRHh6Oxx9/nEJFABQuAtJoNMjLy0NJSYlVyGzfvh1jx44Fy7K428vDMAwYhsEPP/yA7OxsbNy4EZ6enpg0aRImTZrEj+cQImYFBQU4ePAgCgoKEBERwVcye/fuxYgRI+75PgBu7k/z7bffoqKiAidPnkR4eDhGjRqFfv36UagIhMJFBOqHDLeGl1arbdDvclVMly5dMHXqVDz77LPw8/NzZHMJcYirV6/i4MGDyM/Ph5+fH959912b3gcSiQQvvfQSnnzySfTt25dCRWC3v8uPOJW3tzc6duyIlJQUZGRkNPgNBYD/VDdhwgT8/e9/p2AhLqtly5Z45pln8Nxzz+HEiRM2vw/MZjMSEhLoEphIUOUiIizLIjEx0WrQsiEYhkFcXByys7MbvUUzIWJB7wP3QOEiIhUVFU1aJLKiooKWbiEuj94H7oEui4mIWq1u0u/X1tbaqSWECIfeB+6BwkVEfH19m/T7NN5C3AG9D9wDhYuIhISEID4+3ubrxQzDID4+nhaeJG6B3gfugcJFRBiGwfTp0xv1u6+++ioNYhK3QO8D90AD+iKjUqkQHR0NrVYLi8Vyz5+XSCRQKBQoKiqiNcOI26D3geujykVkAgMDsWXLFv6msLuRSCRgGAZbt26lNxRxK/Q+cH0ULiI0ZMgQ7Nq1CwqFgl/ipT7u/1MoFNi9ezcGDx4sUEsJcRx6H7g2CheRGjJkCIqKirBs2bK/bBUbFxeHZcuWobi4mN5QxK3R+8B10ZiLC2BZFlVVVaitrYWfnx+Cg4Np0JLcd+h94FooXAghhNgdXRYjhBBidxQuhBBC7I7ChRBCiN1RuBBCCLE7ChdCCCF2R+FCCCHE7ihcCCGE2B2FCyGEELujcCGEEGJ3FC6EEELsjsKFEEKI3VG4EEIIsTsKF0IIIXZH4UIIIcTu/g88ZY1HvACanQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, base_fun = 'identity', device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "1d834a51", - "metadata": {}, - "source": [ - "Case 2: Noisy spline initialization (not recommended, just for illustration). Set noise_scale to be a large number." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a23d4e55", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "37884df0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=10., device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "4641f36a", - "metadata": {}, - "source": [ - "Case 3: scale_base_mu and scale_base_sigma" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "8d5348a7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, scale_base_mu=5, scale_base_sigma=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bb2b1358", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, sparse_init=True, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fc98e243", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_5_grid-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_5_grid-checkpoint.ipynb deleted file mode 100644 index 655b1059d..000000000 --- a/tutorials/.ipynb_checkpoints/API_5_grid-checkpoint.ipynb +++ /dev/null @@ -1,319 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 5: Grid" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "One important feature of KANs is that they embed splines to neural networks. However, splines are only valid for approximating functions in known bounded regions, while the range of activations in neural networks may be changing over training. So we have to update grids properly according to that. Let's first take a look at how we parametrize splines. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'B_i(x)')" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan.spline import B_batch\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from kan.spline import extend_grid\n", - "\n", - "# consider a 1D example.\n", - "# Suppose we have grid in [-1,1] with G intervals, spline order k\n", - "G = 5\n", - "k = 3\n", - "grid = torch.linspace(-1,1,steps=G+1)[None,:]\n", - "grid = extend_grid(grid, k_extend=k)\n", - "\n", - "# and we have sample range in [-1,1]\n", - "x = torch.linspace(-1,1,steps=1001)[None,:]\n", - "\n", - "basis = B_batch(x, grid, k=k)\n", - "\n", - "for i in range(G+k):\n", - " plt.plot(x[0].detach().numpy(), basis[0,:,i].detach().numpy())\n", - " \n", - "plt.legend(['B_{}(x)'.format(i) for i in np.arange(G+k)])\n", - "plt.xlabel('x')\n", - "plt.ylabel('B_i(x)')" - ] - }, - { - "cell_type": "markdown", - "id": "75af662c", - "metadata": {}, - "source": [ - "There are $G+k$ B-spline basis. The function is a linear combination of these bases $${\\rm spline}(x)=\\sum_{i=0}^{G+k-1} c_i B_i(x).$$ We don't need worry about the implementation since it's already built in KAN. But let's check if KAN is indeed implementing this. We initialize a [1,1] KAN, which is simply a 1D spline." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "4369a310", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.0099, grad_fn=)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import KAN\n", - "\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "# obtain coefficients c_i\n", - "model.act_fun[0].coef\n", - "assert(model.act_fun[0].coef[0].shape[1] == G+k)\n", - "\n", - "# the model forward\n", - "model_output = model(x[0][:,None])\n", - "\n", - "# spline output\n", - "spline_output = torch.einsum('j,ij->i',model.act_fun[0].coef[0][0], basis[0])[:,None]\n", - "\n", - "torch.mean((model_output - spline_output)**2)" - ] - }, - { - "cell_type": "markdown", - "id": "82150587", - "metadata": {}, - "source": [ - "They are not the same, what's happening? We want to remind that we model the activation function to have two additive parts, a residual function $b$(x) plus the spline function, i.e., $$\\phi(x)={\\rm scale\\_base}*b(x)+{\\rm scale\\_sp}*{\\rm spline}(x),$$ and by default $b(x)={\\rm silu}(x)=x/(1+e^{-x})$." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7d76a3c4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0., grad_fn=)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# residual output\n", - "residual_output = torch.nn.SiLU()(x[0][:,None])\n", - "scale_base = model.act_fun[0].scale_base\n", - "scale_sp = model.act_fun[0].scale_sp\n", - "torch.mean((model_output - (scale_base * residual_output + scale_sp * spline_output))**2)" - ] - }, - { - "cell_type": "markdown", - "id": "3d72e076", - "metadata": {}, - "source": [ - "What if my grid does not match my data? For example, my grid is in [-1,1], but my data is in [10,10] or [-0.5,0.5]. Use update_grid_from_sample to adjust grids to samples. This grid update applies to all splines in all layers." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "46717e8b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n", - "Parameter containing:\n", - "tensor([[-2.2000, -1.8000, -1.4000, -1.0000, -0.6000, -0.2000, 0.2000, 0.6000,\n", - " 1.0000, 1.4000, 1.8000, 2.2000]])\n", - "Parameter containing:\n", - "tensor([[-22., -18., -14., -10., -6., -2., 2., 6., 10., 14., 18., 22.]])\n" - ] - } - ], - "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-10,10,steps = 1001)[:,None]\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "de04db15", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n", - "Parameter containing:\n", - "tensor([[-2.2000, -1.8000, -1.4000, -1.0000, -0.6000, -0.2000, 0.2000, 0.6000,\n", - " 1.0000, 1.4000, 1.8000, 2.2000]])\n", - "Parameter containing:\n", - "tensor([[-1.1000, -0.9000, -0.7000, -0.5000, -0.3000, -0.1000, 0.1000, 0.3000,\n", - " 0.5000, 0.7000, 0.9000, 1.1000]])\n" - ] - } - ], - "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-0.5,0.5,steps = 1001)[:,None]\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "markdown", - "id": "e418ca2c", - "metadata": {}, - "source": [ - "Uniform grid or non-uniform? We consider two options: (1) uniform grid; (2) adaptive grid (based on sample distribution) such that there are (rougly) same number of samples in each interval. We provide a parameter grid_eps to interpolate between these two regimes. grid_eps = 1 gives (1), and grid_eps = 0 gives (0). By default we set grid_eps = 1 (uniform grid). There could be other options but it is out of our scope here." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d2c4f636", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n", - "Parameter containing:\n", - "tensor([[-2.2000, -1.8000, -1.4000, -1.0000, -0.6000, -0.2000, 0.2000, 0.6000,\n", - " 1.0000, 1.4000, 1.8000, 2.2000]])\n", - "Parameter containing:\n", - "tensor([[-8.3431, -6.8772, -5.4114, -3.9455, -2.4797, -1.0138, 0.4520, 1.9179,\n", - " 3.3837, 4.8496, 6.3154, 7.7813]])\n" - ] - } - ], - "source": [ - "# uniform grid\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "b9b354c6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n", - "Parameter containing:\n", - "tensor([[-2.2000, -1.8000, -1.4000, -1.0000, -0.6000, -0.2000, 0.2000, 0.6000,\n", - " 1.0000, 1.4000, 1.8000, 2.2000]])\n", - "Parameter containing:\n", - "tensor([[-8.3431, -6.8772, -5.4114, -3.9455, -0.8148, -0.2487, 0.2936, 0.8768,\n", - " 3.3837, 4.8496, 6.3154, 7.7813]])\n" - ] - } - ], - "source": [ - "# adaptive grid based on sample distribution\n", - "model = KAN(width=[1,1], grid=G, k=k, grid_eps = 0.)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", - "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7b8f994", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.ipynb deleted file mode 100644 index 11c12484f..000000000 --- a/tutorials/.ipynb_checkpoints/API_6_training_hyperparameter-checkpoint.ipynb +++ /dev/null @@ -1,440 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 6: Training Hyperparamters\n", - "\n", - "Regularization helps interpretability by making KANs sparser. This may require some hyperparamter tuning. Let's see how hyperparameters can affect training" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "Load KAN and create_dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Default setup" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.34e-02 | test_loss: 3.29e-02 | reg: 4.93e+00 | : 100%|█| 20/20 [00:05<00:00, 3.73it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "07f400a8", - "metadata": {}, - "source": [ - "### Parameter 1: $\\lambda$, overall penalty strength. \n", - "\n", - "Previously $\\lambda=0.01$, now we try different $\\lambda$." - ] - }, - { - "cell_type": "markdown", - "id": "9916490a", - "metadata": {}, - "source": [ - "$\\lambda=0$" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "77e8cafd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.51e-03 | test_loss: 6.14e-03 | reg: 1.52e+01 | : 100%|█| 20/20 [00:03<00:00, 5.84it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.00);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "d92f84a5", - "metadata": {}, - "source": [ - "$\\lambda=1$" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f1a96caf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.70e+00 | test_loss: 1.73e+00 | reg: 1.08e+01 | : 100%|█| 20/20 [00:04<00:00, 4.59it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1.0);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "650e7432", - "metadata": {}, - "source": [ - "### Parameter 2: (relative) penalty strength of entropy $\\lambda_{\\rm ent}$.\n", - "\n", - "The absolute magnitude is $\\lambda\\lambda_{\\rm ent}$. Previously we set $\\lambda=0.1$ and $\\lambda_{\\rm ent}=2.0$ (default). Below we fix $\\lambda=0.1$ and vary $\\lambda_{\\rm ent}$." - ] - }, - { - "cell_type": "markdown", - "id": "c0d92d91", - "metadata": {}, - "source": [ - "$\\lambda_{\\rm ent}=0.0$" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d57d3cee", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.20e-02 | test_loss: 4.50e-02 | reg: 2.57e+00 | : 100%|█| 20/20 [00:04<00:00, 4.68it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=0.0);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "25d3f9f1", - "metadata": {}, - "source": [ - "$\\lambda_{\\rm ent}=10.$" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "94450fdf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.83e-02 | test_loss: 7.74e-02 | reg: 1.54e+01 | : 100%|█| 20/20 [00:05<00:00, 3.77it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0);\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "c14919f1", - "metadata": {}, - "source": [ - "### Parameter 3: seed. \n", - "\n", - "Previously we use seed = 1. Below we vary seed." - ] - }, - { - "cell_type": "markdown", - "id": "c8debdf5", - "metadata": {}, - "source": [ - "${\\rm seed} = 42$" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "8fe1c782", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.67e-02 | test_loss: 5.72e-02 | reg: 5.81e+00 | : 100%|█| 20/20 [00:04<00:00, 4.81it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1692e33b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_7_pruning-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_7_pruning-checkpoint.ipynb deleted file mode 100644 index 2b175b1a5..000000000 --- a/tutorials/.ipynb_checkpoints/API_7_pruning-checkpoint.ipynb +++ /dev/null @@ -1,349 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 7: Pruning\n", - "\n", - "We usually use pruning to make neural networks sparser hence more efficient and more interpretable. KANs provide two ways of pruning: automatic pruning, and manual pruning." - ] - }, - { - "cell_type": "markdown", - "id": "7fd6a742", - "metadata": {}, - "source": [ - "## Pruning nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.46e-02 | test_loss: 3.46e-02 | reg: 4.91e+00 | : 100%|█| 20/20 [00:05<00:00, 3.36it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "280cc49f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mode = 'auto'\n", - "\n", - "if mode == 'auto':\n", - " # automatic\n", - " model = model.prune_node(threshold=1e-2) # by default the threshold is 1e-2\n", - " model.plot()\n", - "elif mode == 'manual':\n", - " # manual\n", - " model = model.prune_node(active_neurons_id=[[0]])" - ] - }, - { - "cell_type": "markdown", - "id": "cf7001ab", - "metadata": {}, - "source": [ - "## Pruning Edges" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "b58417be", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.84e-02 | test_loss: 7.80e-02 | reg: 7.26e+00 | : 100%|█| 6/6 [00:01<00:00, 3.72it/s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABG+0lEQVR4nO3deXxM5/4H8M+ZrJPJRhJLKZWI2imStLbQIkG1di2KtqqUai2XXu3t5nbTukJRqkWoLor2UpUpfrWr2KmSIILYI/vsc87z+6M95yaaMDM5M2eW7/v1yuvVmsyc7zw5Zz7zPM85z+EYYwyEEEKIjFRKF0AIIcT7ULgQQgiRHYULIYQQ2VG4EEIIkR2FCyGEENlRuBBCCJEdhQshhBDZUbgQQgiRHYULIYQQ2VG4EEIIkR2FCyGEENlRuBBCCJEdhQshhBDZUbgQQgiRHYULIYQQ2fkrXQAhnoAxhtu3b6OsrAyhoaGIiooCx3FKl0WI26KeCyF3UVRUhPnz5yM+Ph4xMTFo1KgRYmJiEB8fj/nz56OoqEjpEglxSxzdiZKQymm1WgwaNAh6vR7An70XkdhrCQkJwfr165GSkqJIjYS4KwoXQiqh1WrRt29fMMYgCEKVv6dSqcBxHDZv3kwBQ0g5FC6E3KGoqAj169eHwWC4a7CIVCoV1Go18vLyEBkZ6fwCCfEANOdCyB3S09Oh1+ttChYAEAQBer0eq1atcnJlhHgO6rkQUg5jDPHx8cjJyYE9hwbHcYiNjcXZs2fpLDJCQOFCSAX5+fmIiYmp1vOjoqJkrIgQz0TDYoSUU1ZWVq3nl5aWylQJIZ6NwoWQckJDQ6v1/LCwMJkqIcSzUbgQUk5UVBTi4uLsnjfhOA5xcXGoWbOmkyojxLNQuBBSDsdxePnllx167uTJk2kyn5C/0IQ+IXeg61wIqT7quRByh8jISKxfvx4cx0GluvshIl6hv2HDBgoWQsqhcCGkEikpKdi8eTPUajU4jvvbcJf4b2q1Gj///DN69eqlUKWEuCcKF0KqkJKSgry8PKSlpSE2NrbCY7GxsUhLS8OVK1coWAipBM25EGIDxhh+/fVXPPbYY9i+fTu6d+9Ok/eE3AX1XAixAcdx0pxKZGQkBQsh90DhQgghRHYULoQQQmRH4UIIIUR2FC6EEEJkR+FCCCFEdhQuhBBCZEfhQgghRHYULoQQQmRH4UIIIUR2FC6EEEJkR+FCCCFEdhQuhBBCZEfhQgghRHYULoQQQmRH4UIIIUR2FC6EEEJkR+FCyD1YLBZcuXIFp0+fBgCcP38eBQUFEARB4coIcV90m2NCqlBUVIT169djzZo1OHXqFEpLS2E2mxEcHIyYmBh06dIFzz//PDp16gR/f3+lyyXErVC4EFKJ/fv3Y8qUKThx4gQSEhLQt29ftG7dGqGhoSgqKsLhw4exadMmnDt3DsOGDcO///1vxMTEKF02IW6DwoWQO/zyyy8YM2YMQkND8cEHH6BPnz4wm8349ttvYTKZEB4ejqeeegoWiwXffvst3n77bbRo0QKrV69G7dq1lS6fELdA4UJIOdnZ2UhNTYVGo8G3336L5s2bg+M45OTkoF27diguLkajRo1w+PBh1KhRA4wx7NmzB8OHD0e3bt3wxRdfICgoSOm3QYjiaEKfkL/wPI/3338fhYWFWLhwoRQsd8NxHDp37ow5c+bgv//9LzIyMlxULSHujcKFkL+cO3cOmzZtwsCBA9G5c+d7BouI4zj0798fDz/8MJYtWwar1erkSglxf3SKCyF/2bdvH8rKyjBo0CDk5uZCp9NJj+Xl5YHneQCA2WzGqVOnEB4eLj1+3333YeDAgXj77bdx/fp11K9f3+X1E+JOKFwI+cuZM2cQEhKC2NhYvPjii9i7d6/0GGMMJpMJAHD16lX07NlTeozjOMydOxetWrWCXq/H1atXKVyIz6NwIeQvBoMB/v7+CAoKgslkgtForPT3GGN/e8xqtUKtVlcIIUJ8GYULIX+pVasWDAYDioqKkJSUBI1GIz1mMBiwb98+KUQ6duwoXTjJcRwaNGiAmzdvwmq14uTJk2jdujUiIiKUeiuEKI5ORSbkL1u2bEH//v2xYMECjB07tsJjOTk5SEhIQHFxMR544AEcOnQIkZGR0uMcx2HWrFmYO3cuAMDPzw9t27ZF165dkZycjE6dOlX4fUK8HZ0tRshfEhMTERsbi/T0dOh0Ovj5+VX4EXEcB5VKJf27SqXCtWvXsG7dOkyYMAGnT5/GZ599hmbNmmHdunUYMGAAateujcTERPzjH//Apk2bUFBQoOA7JcT5KFwI+UtUVBQmTZqEI0eOYMGCBTafUmwymTB79mzo9XoMHz4cUVFRePrpp7F8+XKcP38e2dnZ+Pzzz9GyZUts2LABgwYNQt26ddGhQwdMmzYNGzduxO3bt5387ghxLRoWI6QcnU6H5557Dj///DPeeecdTJgwAcHBwbhw4QISExOlYbHMzExERkaitLQU7733HpYuXYp58+Zh1KhRMBgMMJlMUKlUUKvVCAoKqnDNzMWLF7Fr1y7s3LkTO3fuxMWLFwEArVq1kobROnfujOjoaKWagZBqo3Ah5A63bt3CxIkT8dNPPyElJQVTpkxBs2bNkJWVBUEQEBgYiMaNGyMzMxOffPIJjh07hnfffRcTJkyQhs94nq8QMsHBwQgODq70wsxLly5h165dUuBcuHABANCiRQskJyeja9eu6NKlCy2MSTwKhQshldDpdFi2bBkWLFiAGzduIDY2FvHx8QgLC0NhYSGysrJw9epVtG/fHm+99RaSk5OhUv19lFkQBOj1eptCRpSXlycFza5du3D+/HkAQLNmzZCcnCz1bGiRTOLOKFwIuYvr169j+/bt2LlzJ06dOoXTp0+jbdu2SEpKQq9evZCUlISQkJB7vo4gCDAYDDAajTaHjOjq1asVwubs2bMAgKZNm0rDaF26dEGdOnWq/X4JkQuFCyE2ys7OxtSpUzFv3jzEx8c79BrlQ4bjOKjVaptDRnTt2rUKw2jZ2dkAgCZNmkjDaF27dkXdunUdqpEQOdBFlITYSDztuLLhL1upVCpoNBqo1WoYDAbo9XoYDAa7QqZu3boYNmwYhg0bBuDPsNmzZ4/Us1m2bBkAID4+XurZdO3aFffdd5/DdRNiLwoXQhQgR8iI6tatiyFDhmDIkCEAgBs3bkhhs3PnTnz55ZcAgLi4uAphQ+ufEWeicCFEQXeGjPjjSMiIateujUGDBmHQoEEAgJs3b2LPnj3SMNqKFSsAAI0aNZKCJjk5Gffff7+s7434NgoXQtyAM0JGVKtWLQwcOBADBw4EAOTn51cYRlu5ciUAoGHDhtLZaF27dkXDhg3leGvER1G4EOJGqgqZ4OBgqNXqaoWMKDo6Gv3790f//v0BALdv38bevXulYbTVq1eDMYYGDRpIvZrk5GQ0bNhQlu0T30DhQogbujNkjEYjjEajrCEjioqKwhNPPIEnnngCAFBQUIC9e/dKw2hr1qwBYwz169evMIzWqFEjChtSJQoXQtxY+ZARA8ZZISOqWbMm+vXrh379+gEACgsLsW/fPmkY7ZtvvoEgCLjvvvsqDKPFxcVR2BAJhQshHkClUiEkJATBwcEuCxlRjRo10LdvX/Tt2xcAUFxcXKFn891330EQBNStW7fCMFrjxo0pbHwYhQshHkTJkBFFRESgT58+6NOnDwCgpKQEe/fuxe7du7Fz506sW7cOPM+jTp060gWdycnJaNKkCYWND6FwIcQDiSFT2ZxMcHBwtS70tFd4eDh69+6N3r17AwBKS0uxb98+aRWBV155BTzPo3bt2ujSpYsUNk2bNqWw8WIULoR4MI7j3CZkRGFhYUhJSUFKSgoAoKysDPv375eG0aZOnQqr1YqYmBh06dJFGkZr1qwZhY0XoXAhxAu4Y8iIQkND0bNnT/Ts2RPAnytO79+/XxpGmz59OiwWC6Kjoyv0bJo3b65o3aR6KFwI8SJVhUxQUBDUarVbfFhrNBr06NEDPXr0AADo9Xr89ttv0jDazJkzYTabERUVhc6dO0tno7Vs2dIt6ie2oXAhxAtVFjImk8mtQkYUEhKCRx99FI8++igAwGAw4MCBA9Iw2muvvQaz2YwaNWpIYZOcnIxWrVq51fsgFVG4EOLFyoeM0WiU7o7pjiEjUqvV6NatG7p16wbgz7DJzMyUejavv/46TCYTIiMj0blzZ2kYrXXr1tKdQInyKFwI8QHl7x3jKSEjUqvVUm8FAIxGIw4ePIidO3di9+7dePPNN2E0GhERESGFTdeuXdGmTRv4+9NHnFKo5QnxIZWFTPnrZNw5ZETBwcHo0qULunTpAgAwmUw4dOiQFDZvv/02DAYDwsPD0alTJylsHnroIQobF6KWJsQHeUPIiIKCgtCpUyd06tQJAGA2m3Ho0CFpGG327NnQ6/UICwtDp06dpNOfH3roIQQEBChcvfei2xwTYqPz589jypQpmDdvHuLi4pQuR1aMMSlkGGMeGTJVMZvNOHLkiNSz2bt3L3Q6HTQaTYWeTfv27SlsZEThQoiNvDlcRN4cMiKLxYKjR49KYbNnzx6UlZVBo9HgkUcekcKmQ4cOCAwMVLpcj0XhQoiNfCFcRGLIGI1GCIKAoKAghISEeFXIiKxWK44ePSoNo+3ZswelpaVQq9Xo2LGjNIzWoUMHBAUFKV2ux6BwIcRGvhQuospCRq1We/Upv1arFcePH5d6Nrt370ZJSQmCg4Mr9GwSExMpbO6CwoUQG/liuIgYYzCZTDAYDD4TMiKe53HixAnpTp179+5FUVERgoODkZSUJIVNUlISgoODlS7XbVC4EGIjXw4XkS+HjIjneZw8eVJaQWDPnj0oLCxEUFDQ38JGrVYrXa5iKFwIsRGFy/9QyPyPIAj4/fffpTt17t69GwUFBQgMDERiYiKSk5PRpUsXPPzwwwgJCVG6XJehcCHERhQuf0ch83eCIOCPP/6QhtH27NmD/Px8BAQEICEhQQqbRx55BBqNRulynYbChRAbUbhUjUKmaoIg4PTp09Iw2u7du3Hr1i34+/sjISFBGkZ75JFHEBoaqnS5sqFwIcRGFC73RiFzb4wxnDlzRhpG27VrF27evAl/f3+0b99eCpuOHTsiLCxM6XId5n0nrRNCFMNxHIKDgxEZGQmNRgOLxYLi4mLQd9j/4TgOzZo1w/jx4/H111/j8uXLOHnyJNLS0tCgQQOsXr0a/fr1w5IlS5QutVqo50J81r59+2y6ra7VagXP8zCbzTh9+jRatGhh11g5YwwdO3asTqluw2w22/0cq9Vq14KRjDFwHOdVV8f/8MMP4Hne6QtnCoKAgQMHOnUbtqKFK4nPysrKwqhRoyp9jDGGixcvYtu2bTh37hzMZjPCw8PRsmVLdOjQwa7hipUrV3pNuFitVrtPr7VnvS6e56HT6RAQEOBV4XLgwAH8/vvvGDt2LB5//HGnbWfWrFkULoS4g8rmAgRBwLp167Bp0ya0b98e/fr1g0ajwZUrV7Bjxw7s2rULkydPRpMmTWzq+XgbZ75ns9nstUNozz33HEaPHo3CwkKvXEbnTt7/DgmxA2MMixcvRkZGBt544w288sor0oq5/fr1wwcffIBu3brhX//6F44ePap0uV7HbDZ77crEAwYMQEREBD744AOlS3EJChdC/sIYw/fff4/9+/fj448/RtOmTSt8w+Q4DkFBQRg8eDDGjx+P9957D5cuXVKwYu8jnmHmjTiOw5YtWzB79mwYjUaly3E6ChdC/nLp0iWsWbMGH3zwAaKjo6v8PY7j0L17dwwdOhT//Oc/YbFYXFil9/Pm05abN2+Odu3a4dlnn1W6FKejcCEEf/Za3njjDYwcORINGjS45+9zHIehQ4ciJiYG8+bN89p5AlfyhTbkOA6bNm3C+vXrcfPmTaXLcSoKF0IAbNy4EYIgYPDgwTY/h+M4zJ49G3v37sW1a9ecWJ1v8faTJKKiojBixAj06dPHqwOVwoX4PJ7nsWLFCrz99tt2f7CFhYVh0KBBeOONN7z6g8IVeJ5XugSXWbp0KX7//XecOHFC6VKchsKF+Lw1a9YgOjoajRs3duj5I0aMQEFBAXJycmSuzLcYDAanX2ToLgIDA/Hee+95de+FwoX4NEEQsH79eod6LSI/Pz8888wzeOedd7z2g8IVLBaLTy1JP2XKFBgMBnz99ddKl+IUFC7Ep2VkZCA0NBT16tWr1usMGDAARUVFKCgokKky3yKGsjefKXYnlUqFdevWYdy4cV55xiGFC/FpBw8exGuvvVbtSWSVSoXk5GS89957MlXmWwRBAOD9k/l36t69Oxo3boyJEycqXYrsKFyIT3v99dfRsmVLWV5r4sSJOHfunE9NTAN/9joYYxAEQfpve59fVlbmtRdP3g3HcdBqtUhPT8fFixeVLkdWFC7Ep/n7+8v2bTk4OBgRERHYvHmzLK/nCRhjMJvNKC0tRWlpKUpKSqDX62GxWKoMGvHfxUCyWCzged6n5lvKq1OnDl5++WX07NnTq+bsKFwIkdG0adOQnp7uVR8SVWGMwWAwQK/XIzAwECEhIdKKyTqdDiUlJdDpdDAajTCbzTCbzTCZTDAajdDpdFIY6XQ6aDQanxsSK++jjz5CaWkp5s6dq3QpsvGN8/4IcZE2bdrAYrFAr9d79f3RgT/nSYxGIyIiIqBSqaRwCAgIAGMMVqsVVqu1Qi+G4zioVCqoVCoEBARApVLBz8/Pp4MF+PNEhq1bt6JDhw7o27cvmjVrpnRJ1UY9F0JkxHEcmjRpgs8++0zpUpyutLQUQUFBfwsHMUACAwOhVqsRGhqKsLAwhIeHIywsDBqNBmq1GkFBQVLA+Hq4AECLFi3wxhtv4LHHHkNxcbHS5VQbhQshMps+fTp2797t1UNj4nzJveZJOI6r8odUxHEcXn/9dSQlJaFnz57Q6XRKl1QtFC6EyKx27dpgjHnFt8+qGAwG6nE4Acdx+O677xAREYGePXvixo0bSpfkMAoXQmTGcRxatmyJRYsWKV2K0xiNRq+fU1JKYGAgNm3ahAYNGqBLly4e2wumcCHECaZMmYLMzEyP/FC4F/E9+co6YEoIDg7GmjVrMG7cOAwZMgTTpk3D1atXPWp/onAhxAmio6PBGINer1e6FNn56tX0rubn54dp06ZBq9UiOzsbXbt2xezZs5GVlSWdgVeeuwUPffUgxAk4jkOjRo2wfPlyr7s4UK/XU6/FRTiOQ5s2bfDDDz9g+/bt+Oyzz5Ceno74+HgkJiYiLi4OGo0GJSUlyMvLU7rcCmgPIT7NbDY77bUnTZqEr776yqY7W3oSxhhCQkLc7puyuzMajdV6frdu3dClSxecO3cOu3btwqFDh7B3714YjUaEhISgYcOGqFmzpkzVVh/HaA8hPurQoUNOXwdMEAT4+/sjISHBqdtxFWeG8Z0CAwNdti1n27JlC6xWq6yvyRgDz/MQBEG6GNXf3x99+vSRdTuOonAhPsuVu763zE9QmznGF9uNwoUQG5lMJuTl5aF+/fo+uYKvI8Rv17TEi330ej2ysrLw4IMPeuycHZ0tRoiN8vLyMGXKFLebOHVnPM+juLjY525DUF1ZWVlISkpCVlaW0qU4jMKFEEKI7ChcCCGEyI7ChRBCiOwoXAghhMiOwoUQQojsKFwIIYTIjsKFEEKI7ChcCCGEyI7ChRBCiOwoXAghhMiOwoUQQojsKFwIIYTIjsKFEEKI7ChcCCGEyI7ChRBCiOwoXAghhMiOwoUQQojsKFwIIYTIjsKFEEKI7ChcCCGEyI7ChRBCiOwoXAghhMiOwoUQQojsKFwIIYTIjsKFEEKI7ChcCCGEyI7ChRBCiOwoXAghhMiOwoUQQojsPDpcGGPIz89Hbm4u8vPzwRhTuiS3R23mGMYYCgoKoNfrUVBQQO1mA3Ffu3TpEu1rdmCMobCwEABQWFjoue3GPFBhYSFLS0tjcXFxDID0ExcXx9LS0lhhYaHSJbodajPHULvZj9rMMd7Wbh4XLhkZGUyj0TCO4xjHcRX+COK/aTQalpGRoXSpboPazDHUbvajNnOMN7abR4VLRkYG8/PzYyqVqkLj3/mjUqmYn5+fR/0hnIXazDHUbvajNnOMt7Ybx5hnDOgVFRWhfv36MBgMEAThnr+vUqmgVquRl5eHyMhI5xfohqjNHEPtZj9qM8d4c7t5zIR+eno69Hq9TX8AABAEAXq9HqtWrXJyZe6L2swx1G72ozZzjDe3m0f0XBhjiI+PR05Ojl1nTnAch9jYWJw9exYcxzmxQvdDbeYYajf7UZs5xtvbzSPCJT8/HzExMdV6flRUlIwVuT9qM8dQu9mP2swx3t5uHjEsVlZWVq3nl5aWylSJ56A2cwy1m/2ozRzj7e3mEeESGhpareeHhYXJVInnoDZzDLWb/ajNHOPt7eYR4RIVFYW4uDi7xxc5jkNcXBxq1qzppMrcF7WZY6jd7Edt5hhvbzePCBeO4/Dyyy879NzJkye79aSXs1CbOYbazX7UZo7x9nbziAl9wLvPB3cWajPHULvZj9rMMd7cbh7RcwGAyMhIrF+/HhzHQaW6e9kqlQocx2HDhg1u/wdwJmozx1C72Y/azDFe3W6uXhKgumxdg0er1SpdqtugNnMMtZv9qM0c443t5nHhwtifq4fOnz+/0tVD58+fz4qKipQu0e1QmzmG2s1+1GaO8bZ288hwEQmCwLZv384AsO3btzNBEJQuye1RmzmG2s1+1GaO8ZZ285g5l8pwHCeNPUZGRrr92RPugNrMMdRu9qM2c4y3tJtHhwshhBD3ROFCCCFEdhQuhBBCZEfhQgghRHYULoQQQmRH4UIIIUR2FC6EEEJkR+FCCCFEdhQuhBBCZEfhQgghRHYULoQQQmRH4UIIIUR2FC6EEEJkR+FCCCFEdhQuhBBCZEfhQgghRHYeGy5lZWXIzs7GyZMnAQDXr1+H2WxWuCr3V1ZWhosXLwIATp8+jcuXL1O73YPFYsGVK1dw+vRpAMD58+dRUFAAQRAUrsy90b5mP2/6XOMYY0zpIuyRk5ODL774Ahs3bsTly5dhsVhgMpkQHh6Ohx56CKNHj8bAgQMRFhamdKlupXy7Xbx4EQaDAYGBgdBoNGjVqhW1WyWKioqwfv16rFmzBqdOnUJpaSnMZjOCg4MRExODLl264Pnnn0enTp3g7++vdLlug/Y1+3nj55rHhAvP8/jmm28wa9YsGAwG9O7dGz179kSDBg0gCALOnTuHLVu24Ndff0W7du3w6aefonnz5kqXrThqN8fs378fU6ZMwYkTJ5CQkIC+ffuidevWCA0NRVFREQ4fPoxNmzbh3LlzGDZsGP79738jJiZG6bIVRfua/by6zZgH4HmeLVq0iGk0Gta7d292/PhxZrVa2b59+9j8+fPZ/Pnz2enTp5nZbGY7d+5kHTp0YA8++CA7efKk0qUritrNMVqtltWtW5fFx8ezdevWMb1ez4qKitiSJUvY/Pnz2YoVK5jBYGAlJSXs888/Z/fddx/r2bMnu379utKlK4b2Nft5e5t5RLj8+uuvLDIykg0ePJgVFBQwQRAYY4y98cYbDAADwFavXs0YY0wQBHbx4kXWsWNH1rlzZ1ZYWKhg5cqidrNfVlYWa9SoEWvZsiX7/fffpTY7f/48i4iIYABYo0aNWEFBAWPsz3bbtWsXq1+/Phs5ciQzGo1Klq8Y2tfs5+1t5vYT+gaDAe+++y5q166NefPmITIyEhzHVfn7HMfh/vvvx6effors7Gx89dVXLqzWfVC72Y/nebz//vsoLCzEwoUL0bx587u2GfBnu3Xu3Blz5szBf//7X2RkZLioWvdB+5r9fKHN3D5cDh8+jN9++w0vvfQS6tWrd8+DHfjzD9G2bVsMHToUK1euhF6vd0Gl7oXazX7nzp3Dpk2bMHDgQHTu3NmmNgP+bLf+/fvj4YcfxrJly2C1Wp1cqXuhfc1+vtBmbn+Ky44dOxAUFIQePXrg9OnTFQ7cGzduSP996dIlnDhxQvr/yMhI9O/fH1999RVyc3M9ZxJMJtRu9tu3bx/KysowaNAg5ObmQqfTSY/l5eWB53kAgNlsxqlTpxAeHi49ft9992HgwIF4++23cf36ddSvX9/l9SuF9jX7+USbKT0udy8jR45kTZo0YdnZ2axBgwYsODhY+vH395fGJgMCAio89uyzz7ILFy6w6OhotmXLFqXfhstRu9lvxowZLDIykp0+fZo99thjFdolKChIajOO4yo8plar2eLFi9nu3btZWFgYO3DggNJvxaVoX7OfL7SZW/dcGGMwGo0ICgqCn58fjEYjjEZjpb9rsVhgsVik/zebzQgMDJSe50uo3RxjMBjg7++PoKAgmEymKt+/2L7lWa1WqNVqMMZgMplcUa5boH3Nfr7SZm4dLhzHITo6GpmZmeB5Ht27d0dRUZH0+NmzZ5GTkwMAaNWqFe677z7psdatW6OoqAgmkwk1a9Z0demKonZzTK1atWAwGFBUVISkpCRoNBrpMYPBgH379kkh0rFjR+nCSY7j0KBBA9y8eRMqlQo1atRQ6i0oIioqCsXFxbSv3YXBYMDx48dx4MABZGZm4pdffkF4eLh3t5mS3SZbLFu2jKnVarZr1y5mtVor/MyaNUvqPqanp1d4jOd5tnLlSlanTh2Wl5en9NtwOWo3+xQUFLBZs2YxPz8/tmTJkr+1WXZ2tnQq8gMPPMDy8/P/1m4zZ85kTZo08YjTRB0lCALjeZ5ZrVZmNpuZ2WxmS5YsoX2tHEEQ2IULF9jatWvZtGnTWNeuXVlkZCTTaDQsJiaGpaSksMcff9zr28ytey4A8OijjyIsLAzp6el45JFHKiyzoVKpKvy3n5+f9P96vR6rVq1C586dUadOHZfW7A6o3e5NEAQcO3YMWq0WmZmZsFqtiIqKQnp6Op5++ukKE/bl24jjuArtxhjD1atXsW7dOvTt2xchISHgeR4qlcrmM87cGWMMgiCA/XldHIA/28DPzw8cx6Fnz54+va/pdDocO3YMBw4cwMGDB3HgwAHcvHkTABAbG4ukpCSMHDkSiYmJaNGiBfz9/ZGTk4NHHnnEq9vM7cPlgQcewIgRI/DFF19gwIAB6NOnzz0PWEEQsHLlShw9ehQ//vhjhT+Or6B2q9rt27exbds2bN26FTdv3kTDhg0xduxYJCcnIz09HdOmTcOCBQvw2muv2bRmmMlkwuzZs2EwGDBhwgSoVCrwPC8FjPjjKcQQEUNFVNV7qc6+duTIEXz//fces68xxnDhwgVkZmZKYXLy5EnwPA+NRoMOHTpg9OjRSExMRGJiIqKioip9HZ84PpXrNNnu2rVrLCEhgd1///1s27ZtjOd5xhhjb775JvP392cBAQHsq6++YoIgMIvFwlavXs2io6PZrFmzmNVqVbh65VC7/Q/P8+zgwYNs9uzZ7Mknn2SDBw9m8+fPZ2fOnJGujGaMsbKyMjZ06FAWGhrK5s6dy/R6PRMEgZ0/f55FRUUxf39/1rhxY+mK6uLiYjZjxgwWERHBli9fXmGb4tCRyWRiZrOZWa3WCttyJ4IgMKvVyiwWizTcZbFYGM/zNtXs6L42ffp0dvPmTVZSUiI9x52UlZWxHTt2sDlz5rDBgwezBg0aMI1GwzQaDWvbti178cUX2RdffMFOnjxp9zHj7cenxyxc+ccff+CZZ55Bbm4uJkyYgGeffRaCIODq1asAgEaNGqG4uBiLFy/GN998g5EjR2LOnDkICQlRuHJl+Xq75efnY+vWrdi6dSvy8/MRGxuLlJQUJCcnV/keb926hYkTJ+Knn35CSkoKpkyZgmbNmiErKwuCICAwMBCNGzdGZmYmPvnkExw7dgzvvvsuJkyYUOm3ScYYeJ6XegHu0Jth5XomrNxQl/jjSG2O7msBAQHQ6XRgjCEkJARBQUGyvldbMcZw7ty5CsNbf/zxBwRBQFhYGBISEpCUlISEhAQkJCTIcuKGrW22cOFCfPfddx51fHpMuADAlStXMHv2bHz33Xfw9/dH8+bNcf/994PneeTm5iIrKwtRUVGYOXMmnnnmGcV2Unfja+3G8zwOHz6MjIwMHD58GEFBQUhOTkZKSgri4uJsmgfR6XRYtmwZFixYgBs3biA2Nhbx8fEICwtDYWEhsrKycPXqVbRv3x5vvfUWkpOTbfpAFgQBPM+DMSZ9iLtqboZVMXcibl+OGhzd1xhj0Ov1MJlMCAgIgEajcXr4lpSU4NChQ1KYZGZmoqioCBzHoWnTptLQVmJiIh588EGn1XOvNjtz5gx0Oh1efvllvP/++x5zfHpUuAB/fnCcPn0amzdvRmZmJm7evImAgAA0atQI3bt3R69evVCrVi2ly3Q7vtBuN2/elHopBQUFaNy4MVJSUtC1a1eo1WqHXvP69evYvn07du7ciZycHBiNRtSoUQMtW7ZEr169kJSU5NC3SFf0ZpzRO7FFdfY1i8XilF6MIAjIzs6u0Cs5c+YMGGOIjIxEYmKi1DPp0KFDhZM5XOFubdatWzds2LABgiDgxx9/9JiTRDwuXMoTD1DxzBViG29qN57nkZmZCa1Wi6NHjyI4OBjdunVDr169EBcXJ/u2GGOyh4CcvRlX9E7srcfefU2OXkxRUZHUG8nMzMTBgwdRUlIClUqF5s2bV+iVNG7c2K1OuKiszQ4cOIARI0ZgyZIl6NGjh8IV2sajw4X4ruvXr+OXX37Btm3bUFRUhCZNmiA1NRWdO3dGcHCw0uU5xJHejFK9E1ewtRcjfusXgyQzMxPZ2dkAgJo1a0rzJElJSWjfvj1CQ0Nd+TZkM2LECJSUlGDjxo0e0XuhcCEew2q14sCBA8jIyMDx48cREhKC7t27IyUlBQ888IDS5cnqbr2Z8j0Td+idOFNlvZjCwkKpN3LgwAEcOnQIOp0Ofn5+aNmypdQjSUpKQqNGjbymPTIzMzF8+HAsXrwYvXr1Urqce6JwIW7v6tWr+OWXX7B9+3YUFxejadOmSE1NRadOnTxmctNRYm/GarVCEIQKF3CWDxRvZbVacerUKezfvx/79u3D4cOHkZubC47jEBMTg6SkJClMHnrooQpL9nijkSNHoqioCBs3bnT7XimFC3FLFosFv/32GzIyMnDy5EmEhoZKvZQGDRooXZ7TVdY7ubOn4ufn53XhcvPmzQq9kiNHjkCv18Pf3x+tWrVCu3bt0LZtW3To0AHNmzf3+DlDex08eBBPP/00Fi1ahJSUFKXLuSsKF+JW8vLypF5KaWkpWrRogZSUFHTs2BGBgYFKl+c0d5s7uTNAxN8T7y/jDtfNOMJiseDkyZMV5kpyc3MBAHXq1JGGthITE9G2bVvpjL/yczFqtdpj59gcNWrUKNy+fRubNm1y6785hQtRnNlsxr59+6DVanHq1CmEhYXhscceQ69evbz6pltikNy5xEr5CXlbXkOcmwHg1r2Za9euST2SzMxMHD16FEajEYGBgWjbtm2FixTr169/1/fAGIPBYIDRaIS/vz80Go3P9GIOHz6MYcOGYeHChUhNTVW6nCpRuBDFXLp0CVqtFr/++ivKysrQqlUrpKam4uGHH0ZAQIDS5cnOnt6JI69dvjdTfthMCSaTCcePH5fC5ODBg7h8+TIAoH79+hVOBW7Tpo3Dc2dWqxVlZWU+14sZM2YMbt68iZ9++sltey8ULsSlTCYT9u7di4yMDJw5cwYRERF47LHH0LNnT9SrV0/p8mQnR+/EkW2KP4BrejN5eXkVguTo0aMwm80ICgrCQw89JA1vJSQkVLg/iRx8sRdz5MgRDB06FAsWLECfPn2ULqdSFC7EJXJzc6Veil6vR5s2bZCamoqkpCSbVh72FM7snThSixgy4inNcvRmjEYjjh07VmFlYHEtrIYNG1bolbRq1cplc2VWqxU6nQ48zyMkJMTrezFjxozB9evXsXnzZrcMUwoX4jRGoxF79uxBRkYGsrOzERkZiR49eqBXr15ufy8KeyjRO7HXnb2Z8qcz3w1jDJcuXaow6X7ixAlYLBao1Wq0a9dOmidJTExE7dq1XfF27lqvr/Rijh07hsGDB2P+/Pno27ev0uX8DYULkV1OTg60Wi127NgBo9GIhx56CCkpKUhMTPSKA72qJVY84bqTe/Vm9Ho9jh49WmExxxs3bgD488ZX4hlcCQkJaNGihdvOjZXvxajVaofXlnN3zz33HK5cuYKff/7Z7Y4tChciC4PBgF27dkGr1eLcuXOoUaMGevXqhZ49e3r8gpjA3Xsn7jqhei88zyMnJ0c6e+vw4cM4efIkBEGQbnwlDm8lJCQgOjpa6ZLt4gu9mOPHj2PQoEGYN28e+vXrp3Q5FVC4EIcxxnD+/HlotVrs3LkTJpMJ7du3R2pqKtq3b+/RB7In906qotPpcPjw4Qq9kvz8fDDGEB8fj4SEBClQWrZs6ba9Ent5ey9m7NixuHz5stv1XihciN30ej127twJrVaLnJwcREdHo2fPnujRowdiYmKULs8h5a+G94beiXjjq/JzJadOnapw46vyvRLxxleOzs14AoPBAIPBAD8/P4SGhrrVB3F1iL2XuXPn4sknn1S6HAmFC7EJYwzZ2dnQarXYvXs3LBYLOnTogNTUVLRr187jPnwB91uevjrEG1+VX2K+sLAQANC0adMKKwPbcuMrZ51ppjRv7cW88MILyM3NRUZGhtuEJoULuSudTocdO3YgIyMDFy9eRK1ataReSlRUlNLl2cVbeid3u/FVREREhVOBO3TogIiIiGpvz9t6M97Wizl58iQGDBjgVr0XChfyN4wxnDlzBlqtFnv27IHVakVSUhJSUlLQtm1bj/kQBryjdyLe+Kr8RYpK3Piqst6MGDSeiOd5lJWVeU0vZty4cdKZmu7wN6FwIZLS0lL8+uuv0Gq1uHz5MmrXro2UlBQ89thj0pi8u/P03gnP8zhz5kyFXkn5G1+Vv1eJkje+8qbeTPlejEaj8diLek+dOoUnn3wSH3/8MQYMGKB0ORQuvo4xhj/++ANarRZ79+6FIAh4+OGHkZqaitatW3vEh4Un905u375d4Xa8hw4dQllZmXTjK3GeJDExEbGxsW73XrylN8PzPHQ6HaxWq0f3YsaPH4+zZ8/il19+UfxvQOHio0pKSvB///d/0Gq1uHLlCurWrYuUlBQ8+uijiIyMVLq8u/LUW/uKN74qvzLw+fPnAUC68ZUYJp5446vKejOedisAT+/F/PHHH3jiiSfw0UcfYdCgQYrWQuHiQxhjOHnyJLRaLfbv3w8AeOSRR5CamoqWLVu63bfi8jyxd3Lr1q0Kw1vlb3zVunXrCnMlDRs2dMv34Cie5z22N1O+FxMcHAy1Wu1Rf5sJEybgzJkz2Lp1q6LhSOHiA4qLi7F9+3ZotVpcu3YN9erVk3op4eHhSpdXKU/rnYg3vio/6X7hwgUAd7/xlbfz5N6M0WiEXq/3uF7M6dOn0a9fP3z44YcYPHiwYnVQuHgpxhiOHz8OrVaL3377DSqVCp06dUJKSgqaN2/ult/EKru1r7v2Tq5fvy7Nkxw4cEC68VVAQADatm1boVdyrxtf+YrKejPuvtqBp/ZiJk6ciFOnTmHbtm2KhSKFi5cpLCyUeik3btzA/fffj9TUVHTr1g1hYWFKl1eBOy1PfzcmkwknTpyocLV7+Rtflb+DYps2bbx+qffqYoxJQQN4Rm/G03oxZ86cweOPP44PPvgAQ4YMUaQGChcvIAgCjh07Bq1WiwMHDsDf3x+dO3dGamoqHnzwQbf5kAY8o3dy542vjh07BpPJJN34qvzKwHLf+MrXeFJvxtN6MZMmTcLvv/+OrVu3KrJOHIWLB7t9+za2bduGX375Bbdu3ULDhg2lXoq7nGnk7r0To9GI48eP48CBA2514ytf40m9GaPRCIPBAI7jEBoa6ra9mKysLPTt2xfvvfcehg0b5vLtU7h4GEEQcPjwYWi1Whw8eBCBgYHo0qULUlNTER8fr/iHtVijO/ZOxBtfle+VHD9+3G1vfOWrBEEAz/Nu3ZvxlF7Myy+/jBMnTmDbtm0u771QuHiIW7duYdu2bdi6dSvy8/MRGxuLlJQUJCcnIyQkRNHa3LV3It74qvxciXjjq0aNGklnbyUmJrr1ja98lSf0Zsr3YjQajdvtQ2fPnkWfPn0we/ZsPPXUUy7dNoWLB2CMYfz48SgsLERycjJSUlIQFxfnFt+UGGOwWq0A3O/WvuvXr8fo0aOh0WjQvn37Cr0ST7vxla8r35vx9/d3q4ARBAFlZWWwWq2IjIx0q9oA4JVXXpHmXlxZG4WLQuxtdp1Oh+DgYIcuRLP3g96Vu4Q9tdlbl9ibcqT35A7h6Au8ZV8D/hwqc8fjU/zy58jcUHWOA/ecifIB+/fvr/QPxxiDxWKBSqWSZaKQMYaOHTva/RxXsWfn3bRpU5W/bzabAUCWCXdBENxm2XJv54p9TZy7sWdfs1gsDm2r/GKptrJ3n/3ll1/s/tDneR5msxnBwcE2P1cQBKSmptq1nfIoXBSSlZWFUaNGSf8vCAKOHDmC7du348aNGwgKCkLz5s3Rq1evak0sr1y50qFwqW73med5ALjrNzl7D8TMzEy8/fbbf/v377//HsuWLYNKpcLEiROrfS/xN998k8LFRQRBcOqyMGLv1d5VHaxWK6xWK0JCQpxan8FgsDtcjh49iunTp9v0u0ajEVqtFps2bUJBQQHi4uIwZcoUm06hnzNnDoWLp/Lz8wNjDNeuXcPKlStx9uxZ9OjRA7169UJZWRn27duH1157Dc888wx69Ojh0qEaR7clzsGI3xStViv8/f1lq/3O3ty3336LV199FR9//DHMZjNefPFFMMYwcOBAWbZHnM+Z+3X5a2jspVKpoNfr3XKJpHuNagiCgH379iEtLQ2lpaUYOnQoGjdujM2bN2PYsGH46aefnH6zPwoXBZ0/fx6//fYbtFot2rVrh48//hhRUVHSgdClSxccOnQICxYswLVr1/DMM8+4/VyAOMwhfturzsF9L/n5+Rg/fjx+/PFHJCcnAwAaNGiAYcOGoUePHm75oUBcqzr7nlqtRklJicwVOZ/BYMBbb72FXbt2YfTo0RgxYgTCwsLAcRy6dOmCGTNmYPjw4cjIyHDq54l7ndbgYxYsWICcnBxMnToVkydPRnR0dIU/tp+fHxITE/Hhhx8iIyMDa9eudel8iL3EU0fFm0aJ910Xh8jk3la/fv0wZMgQJCcnS9vr2bMnunfv7vLTLol7qk64iMNo7nzM3YnneYwePRq5ubn47rvvMH78eISHh0ttoFKp8OGHH+L27dtIT093ai3Uc1HQ7NmzodFo7jqmy3Ec7r//fnzwwQd49dVX0bhxY7Rv396FVdqv/MEs/rfcvZctW7bg7Nmz2LVr19+2t3r1atSpUwfFxcXVvn888Wzi/KEjAWHPvit+seJ5XjpVWolRhjfffBMFBQX46aefqlzjzt/fHytXrsTAgQMxfPhwp606QT0XBYWHh9s8WdiwYUNMnToV77//PgwGg5Mrc0z5uRZR+QNULkajEaNHj8by5csrvWhNo9Gga9euGDt2rGzbJJ6rOh/yKpUKRqPxnr9nsVhQVlYGs9mM0tJS6fRfVyooKMB3332Hr7/++p6Lp7Zo0QIPPvggXn/9dafVQ+HiQTp37oxWrVrh3Xffdbuu+p1zLeWpVCrZhsZ4nsfTTz+Ntm3b3vWssFWrViEjI8OhU0OJd6lOuKjVaphMprv+jiAI0Ol00Gg0CA0NhVqtRllZmcuP0fHjxyMlJQW1atW65+9yHIcVK1bghx9+gF6vd0o9FC4ehOM4/POf/8Tp06eRlZWldDkV3O1AkvOq4LFjx+Ls2bP44Ycf7vqhUbNmTYSGhuKHH36QbdvE99iynEtZWRkCAgKksyIDAwPh5+cHnU7nggr/xPM8jhw5gjlz5tj8nOjoaCQkJGDKlClOqYnCxcMEBQVh3LhxeOedd9yq98Lz/D3HmeWod9CgQfi///s/hIaG3vX3OI5DWloaJk+eXO1tElLVvivOtWg0GmnfF1dLtlgsLjtGf/zxR4SHh9u9GvqSJUuwfft2lJaWyl4ThYsH6t27N3iex65du5QuBcD/DryqeihyTmz27dvXpm4/AAwZMgQlJSX3HNYQMcZsGl8nnqH8IqqOEp9b1bCuwWCo9EuVuMJGWVmZw9u2x7vvvot33nnH7udFREQgOTkZEyZMkL0mChcPxHEcZs6ciQULFjjtm1H55fJt+V2xrqpwHCfLvIs9HxQqlQoNGjTARx99ZNPvf/nllxg6dKijpREvFRAQUOlJNIwxmEymKnvRoaGhsFqtTu+9iHM+ffv2dej5CxYswG+//SZ7EFK4eKh27dohKCgIW7ZsccrriyvQ2nJg2LJgn6Ong1bX8uXLkZaWds9tl5SUYOrUqXjhhRdcVBkpz52GeO+kVqsrPfvLlh67SqVy+tmdO3bsQHBwsMNzmxqNBomJiTYvKWMrChcPxXEc3njjDSxbtswpZ0SJZ3hVduOv8mwdenDGKcm2SExMhMViuecBPm7cOHTs2BGPP/64iyojImdcZAs4tohkZaq6mFKv199zaaPQ0FCYTCan7vf/+te/MGnSpGq9xsKFC7Ft2zZZ66Rw8WDNmjVDWFiYU86IEq+uF9cKKx805fE8b9OKs0otW8NxHJo0aYK33nqryt9hjGHz5s1YvXq12y+v443Eiw/lJi5YWV2VfTESVy+/1wS6GEziqt1yY4zhxo0bePbZZ6v1OjVq1EBQUJCs87gULh6M4zi89dZbWLVqlewXbYldej8/P+mKYzFo7uzN2LNqrBLDHytWrMCyZcuq3PbFixfBcRzdQEwh/v7+Tul9y7G6t8jPz6/C9SD29Ng1Gg30er1T9v2srCz4+fkhKCioWq/DcRymTp2KmTNnylQZhYvHi42NRb169bB06VKnvH752xX7+flJa4XxPA+r1WrXMhdyXkxpj1atWoHn+SonLF966SX07t2bei0KceaQqVzhEhISUuEeL+K1LbbsM+K1Ms64an/q1KmynYQyatQo5Ofny/Z3oHDxcBzHYfbs2dBqtcjPz3f6tjiOk3oyfn5+dh28St3+leM4tGrVqtJvZYwx7N69G/Pnz1egMgLYHi53m/tzNrF3Lm5fvLbFFhzHISQkRPar9hljyM7OxmuvvSbL64lhefnyZVlej8LFC0RFRaFv376YNWuW05c7Kd+TcXRxPiU+HFauXIk1a9ZUOikLoFo3ZCPV5+fnd9dv9uIHungTr8rm/+78fUC+uT5xDlKn00Gv19v9RUlcHFLOuRetVgu1Wo2QkBDZXjMxMRHvv/++LK9F4eIlxo4dC5PJhK+++sptT+tUctgpPj4egiDg2rVrFf79/fffR1xcHA2JKexuy9uLk+fi/J54E7p7BYzcxOtWLBaLdH8UW4lX7cs198LzPGbMmIGPPvpI1n339ddfx6+//irLa1G4eAk/Pz988MEHWL9+PbKzs5Uup0pyXUzpyHYHDBhQ4dbSjDF89tlnWLJkicvrIRWJH5B39rzFHsudw7H+/v7S3F9lH9bic+SkUqkQFhaG8PBwh4Z4xfrlWCjyH//4B6KiotC7d+9qv1Z5zZo1q7JN7UXh4kXuu+8+vPjii3jzzTfddhkTpS6mBIBFixbhwIED0tCETqeDxWJBUlKSIvWQisTAuPOUX0EQKlxPIg7LBgQEQBCESj8MBUGw6yxGW9k7z1gex3EICwuD2Wyu9hesHj164Pvvv5c9QMXXk+Pzg8LFy/Tu3RsPPvig2y1sKVLqYkoACAsLQ7NmzTBlyhQwxjBp0iR06NCBhsTcRPneizhxbrVapaGwyn5fDBhxmZXyE/7u+HdVqVQICgqq9uR+7969nXbqvEajwdatW6v9OnQnSi/DcRxef/11jBgxArt371a6nL+pavjDVTZu3IimTZsiKSkJGzZswNmzZxWpg/ydOPQlTuyLK23fracgBow4F+Ln5yddPOmO4QL87x4x1Zncd+Z769u3Lz7//HN07NixWq9D4aIgZ121y3EcZsyYga1bt6JOnToOvYYzexblPwDsVd3uemRkJJYuXYqlS5fivffeQ0REhNsOIfqK8vuaeFaWIAjS/Mqdv1MZ8UJM8UuLv79/tfdhZx4D4rIwjg6x2brStyNGjhwpyxljHHPHsRMfcOjQIadPbItj1QkJCXY/zx623GO8KvYcXFqt1u4L0cQPqTtZLJYqbwTl5+eH1NRUu7ZDHOPKHqw9+5oj92KxZQHXO4k9L3vs2LHDruNAHF60Zzs8zyMwMBDdu3e3q7byKFwUYm+zC4IAg8EAtVpt97cdez/47alNPJunqnHxe7HnOfbcAsBqtcJsNkMQBGg0Gqe3GXGMKz9+nLGvifR6PcxmMyIiIuzed5x1fAqCgNLSUpSUlEClUqFevXp2bceR2sqjCX2FiGPCtv7k5uZi+PDhyM3Ntfu5zqpNDJbyF1Q6s7Z7vZYgCFi7di06dOiAmjVrYvTo0dLaS85uM+IYR/4u4jIsSu5r5X/0ej1MJhNCQkIcOg7kbjOdTofPPvsMSUlJeOSRR/Dll186dAxU9zigORfiEPEU0PLj4kqxWq1Yt24dPvzwQ5w7dw6pqan4/PPP0aFDB0XrIt5Pp9NJNwwTr8JXSmlpKVatWoXly5dDr9dj2LBhGD9+vMPzrtVF4ULs5i7BYrVasXbtWnz00Uc4f/48+vTpg+XLl6Ndu3aK1UR8h7sES2lpKVauXIkVK1bAaDTiqaeewosvvqj4kkYULsQu7hAsVqsV3377LebMmYOcnBw8/vjjSE9PR9u2bRWph/gedwiWkpISKVTMZrMUKrVq1VKknjtRuBCbKR0sFotFCpULFy6gX79+WL16Ndq0aePyWojvUjpYiouLsXLlSqxcuRJmsxnDhw/HCy+84DahIqJwITZRMlgsFgu+/vprfPzxx8jNzcUTTzyBr7/+Gq1atXJpHYSUlZXBbDYrEixFRUVYsWIF0tPTYbVapVCJiYlxaR22onAh96RUsJjNZqxZswaffPIJLl68iP79++Pbb79Fy5YtXVYDISKlgqWoqAjLly9Heno6eJ7HiBEj8MILL7j9nVMpXMhdKREsZrMZX331FT755BNcvnwZ/fv3x9q1a9GiRQuXbJ+QOykRLIWFhfjyyy+xatUqMMYwcuRIjB07FlFRUS7ZfnVRuJAquTpYTCYTVq9ejblz5yIvLw8DBw7E+vXr0axZM6dvm5CquDpYCgoKpFAB/rz98PPPP4+aNWs6fdtyonAhlXJlsIih8sknn+DKlSsYPHgwZs6ciaZNmzp1u4TciyuDpaCgAF988QVWr14NjuMwevRoPP/886hRo4ZTt+ssFC7kb1wVLEajEatWrcLcuXNx7do1KVQefPBBp22TEFu5Klhu376NZcuWYc2aNVCpVBgzZgyef/55REZGOm2brkDhQipwRbAYjUasXLkSc+fOxY0bNzB06FDMnDkT8fHxTtkeIfZyRbDcunULy5Ytw9dffw0/Pz8899xzePbZZz0+VEQULkTi7GAxGAxYuXIl/vOf/+DGjRt46qmnMGPGDDRu3Fj2bRHiKDFYwsLC7F6x2Ba3bt3C559/jm+++Qb+/v4YO3YsxowZ4zWhIqJwIQCcGywGgwHLly/Hf/7zH+Tn50uhEhcXJ+t2CKkuZwbLzZs3pVAJDAzEuHHjMHr0aERERMi6HXdB4UKcFix6vR5ffvkl5s2bh9u3b2P48OGYMWMGGjVqJNs2CJGLs4Llxo0bWLp0Kb799lsEBwdj/PjxGD16NMLDw2XbhjuicPFxzggWnU4nhUphYSFGjBiB6dOnU6gQt1VaWgqLxSJrsNy4cQNLlizBd999B7VajZdeegmjR49GWFiYLK/v7ihcfJgYLH5+fg7fbrU8nU6HZcuWIS0tDUVFRRg5ciSmT5+OBx54oPrFEuIkcgfLtWvXsGTJEqxduxYajQaTJk3CqFGjEBoaKkO1noPCxUfJGSw6nQ5Lly7F/PnzUVJSgmeeeQbTpk1Dw4YNZaqWEOeQM1iuXr2KpUuXSqHyyiuv4JlnnoFGo5GpWs9C4eKD5AqWsrIyKVRKS0sxevRoTJ06FQ0aNJCxWkLkxxhDWVkZrFZrtYPlypUrWLJkCb7//nuEhob6fKiIKFx8jBzBUlpaiiVLlmDBggXQ6XQYNWoUpk2bhvvvv1/magmRX/lgCQ0NdThY8vLy8Nlnn2H9+vUICwvD1KlTMXLkSISEhMhcsWeicPEhPM9DEASHg6W0tBSLFy/Gp59+Cr1ejzFjxmDatGmoV6+eE6olRH5yBEteXh4WL16M9evXIzIyEtOnT8eIESOgVqudULHnonDxEdUJlpKSEixevBgLFy6EwWDAmDFjMHXqVAoV4lGqGyyXL1/G4sWLsWHDBkRGRmLGjBkYPnw4hUoVKFx8gKPBUlxcjEWLFmHRokUwmUx49tlnMXXqVNStW9eJ1RIiv+oEy8WLF7F48WL8+OOPqFmzJl577TU89dRTFCr3QOHi5RwJlqKiIilUzGYznn/+eUyZMgV16tRxcrWEyO/OyXt/f9s+9nJzc7F48WL897//RVRUFP75z3/iqaeeQnBwsJMr9g4ULl7M3mApLCyUQsVqtUqhUrt2bRdUS4j8HAmWCxcuYNGiRdi4cSOio6Mxa9YsDBs2jELFThQuXsqeYCkoKMDChQuxePFi8DyPF154Aa+++ipq1arlomoJkZ+9wXL+/HksXrwYmzZtQkxMDP71r39h6NChCAoKclHF3oXCxQvZGiy3b9/Gp59+is8++wyMMYwbNw6vvPIKYmJiXFgtIfKzJ1jOnz+PRYsWYdOmTahduzbeeustDB48mEKlmihcvIwtwXL79m0sWLAAS5YsAQApVKKjo11ZKiFOwRhDaWkpeJ6/a7CcO3cOCxcuxObNm1GnTh28/fbbGDJkiEtuZewLKFy8yL2CJT8/H/Pnz8fnn38OABg/fjwmT56MqKgoV5dKiFPYEizZ2dlYuHAhtmzZgrp16+Ldd9/FoEGDKFRkRuHiJe4WLLdu3UJaWhqWLVsGjuPw0ksv4eWXX0bNmjUVqpYQ+d0rWLKysqRQqVevHv79739j4MCBTrkhGKFw8QiMMRQUFECv16OgoACxsbHgOE56vKpguXnzJtLS0vDFF19ApVJh0qRJmDRpEoUK8UiMMeTn56OwsBA1atRAdHS0dBzcLVjOnDmDhQsXIiMjA/Xr18f777+PAQMGUKg4GyNuq7CwkKWlpbG4uDgGQPqJi4tjaWlprLCwkFmtVmY2mxnP89Lzrl+/zmbOnMmio6NZnTp12OzZs1lBQYGC74QQx93rOCgoKGDFxcWsoKCAWSwW6Xl//PEHmzBhAouLi2PJycls7dq1FR4nzkXh4qYyMjKYRqNhHMcxjuMqHFTiv4WEhLCffvpJCpZr166xf/zjHywqKorVrVuXvffee6ywsFDZN0JINdzrOADAQkJC2Pfffy8Fx6lTp9j48eNZXFwc6969e4XHiOtwjDGmSJeJVEmr1aJv375gjEEQhCp/j+M4cByH1atX4+jRo1ixYgWCgoIwceJETJw40WvvzU18g73HweLFi3HkyBFs374dDRs2xMSJE/Hkk0/KeutuYjsKFzdTVFSE+vXrw2Aw3PWAulPdunUxefJkvPTSS15/b27i/Rw5DjiOQ9euXfHqq6+iX79+FCoKowl9N5Oeng69Xg97M//VV1/FjBkznFQVIa7lyHHAGEP//v3Rv39/5xVGbEY9FzfCGEN8fDxycnLsOqg4jkNsbCzOnj1b4SwyQjwRHQfegcLFjeTn51dr6ZX8/Hy6IJJ4PDoOvIPjN1AnsisrK6vW80tLS2WqhBDl0HHgHShc3EhoaGi1nh8WFiZTJYQoh44D70Dh4kaioqIQFxdn93gxx3GIi4ujK++JV6DjwDtQuLgRjuPw8ssvO/TcyZMn0yQm8Qp0HHgHmtB3M/ae369SqaBWq5GXl4fIyEjnF0iIC9Bx4Pmo5+JmIiMjsX79enAcd887SKpUKnAchw0bNtABRbwKHQeej8LFDaWkpGDz5s1Qq9XS0hblif+mVqvx888/o1evXgpVSojz0HHg2Shc3FRKSgry8vKQlpaG2NjYCo/FxsYiLS0NV65coQOKeDU6DjwXzbl4APbX/VxKS0sRFhaGmjVr0qQl8Tl0HHgWChdCCCGyo2ExQgghsqNwIYQQIjsKF0IIIbKjcCGEECI7ChdCCCGyo3AhhBAiOwoXQgghsqNwIYQQIjsKF0IIIbKjcCGEECI7ChdCCCGyo3AhhBAiOwoXQgghsqNwIYQQIrv/B95A5LLPc4URAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=6, lamb=0.01);\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4d57cbfe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model.prune_edge()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e3a23aed", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "1db74fbd", - "metadata": {}, - "source": [ - "## Prune nodes and edges together" - ] - }, - { - "cell_type": "markdown", - "id": "4e7e2c8a", - "metadata": {}, - "source": [ - "just use model.prune()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1ea08f0e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.46e-02 | test_loss: 3.46e-02 | reg: 4.91e+00 | : 100%|█| 20/20 [00:05<00:00, 3.70it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "\n", - "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4fc161de", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5a8dd8a8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_8_regularization-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_8_regularization-checkpoint.ipynb deleted file mode 100644 index 3e8faa423..000000000 --- a/tutorials/.ipynb_checkpoints/API_8_regularization-checkpoint.ipynb +++ /dev/null @@ -1,184 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 8: Regularization\n", - "\n", - "Regularization helps interpretability by making KANs sparser. This may require some hyperparamter tuning. Let's see how hyperparameters can affect training" - ] - }, - { - "cell_type": "markdown", - "id": "6459e11a", - "metadata": {}, - "source": [ - "Load KAN and create_dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c3faa4ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "data": { - "text/plain": [ - "(torch.Size([1000, 2]), torch.Size([1000, 1]))" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" - ] - }, - { - "cell_type": "markdown", - "id": "d51cb2fa", - "metadata": {}, - "source": [ - "We apply L1 regularization to which tensor? Currently, we support five choices for reg_metric:\n", - "* 'edge_forward_spline_n': the \"norm\" of edge, normalized (output std/input std), only consider the spline (ignorning symbolic)\n", - "* 'edge_forward_sum': the \"norm\" of edge, normamlized (output std/input std), including both spline + symbolic\n", - "* 'edge_forward_spline_u': the \"norm\" of edge, unnormalized (output std), only consider the spline (ignorning symbolic)\n", - "* 'edge_backward': edge attribution score\n", - "* 'node_backward': node attribution score" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "97111d75", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.57e-02 | test_loss: 4.35e-02 | reg: 7.15e+00 | : 100%|█| 20/20 [00:04<00:00, 4.58it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# train the model\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_n'); # default\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_sum');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_u'); \n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_backward');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='node_backward');\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "c3ae48d1", - "metadata": {}, - "source": [ - "Note: To plot the KAN diagram, there are also three options\n", - "* forward_u: same as edge_forward_spline_u\n", - "* forward_n: same as edge_forward_spline_u\n", - "* backward: same as edge_backward" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c8761496", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='forward_u')\n", - "#model.plot(metric='forward_n')\n", - "#model.plot(metric='backward') # default" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1692e33b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/API_9_video-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/API_9_video-checkpoint.ipynb deleted file mode 100644 index c5a723c9b..000000000 --- a/tutorials/.ipynb_checkpoints/API_9_video-checkpoint.ipynb +++ /dev/null @@ -1,158 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# API 9: Videos\n", - "\n", - "We have shown one can visualize KAN with the plot() method. If one wants to save the training dynamics of KAN plots, one only needs to pass argument save_video = True to train() method (and set some video related parameters)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2075ef56", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.89e-01 | test_loss: 2.96e-01 | reg: 1.31e+01 | : 100%|█| 5/5 [00:09<00:00, 1.94s/it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", - "\n", - "image_folder = 'video_img'\n", - "\n", - "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"LBFGS\", steps=5, lamb=0.001, lamb_entropy=2., save_fig=True, beta=10, \n", - " in_vars=[r'$x_1$', r'$x_2$', r'$x_3$', r'$x_4$'],\n", - " out_vars=[r'${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$'],\n", - " img_folder=image_folder);\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c18245a3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Moviepy - Building video video.mp4.\n", - "Moviepy - Writing video video.mp4\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " \r" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Moviepy - Done !\n", - "Moviepy - video ready video.mp4\n" - ] - } - ], - "source": [ - "import os\n", - "import numpy as np\n", - "import moviepy.video.io.ImageSequenceClip # moviepy == 1.0.3\n", - "\n", - "video_name='video'\n", - "fps=5\n", - "\n", - "fps = fps\n", - "files = os.listdir(image_folder)\n", - "train_index = []\n", - "for file in files:\n", - " if file[0].isdigit() and file.endswith('.jpg'):\n", - " train_index.append(int(file[:-4]))\n", - "\n", - "train_index = np.sort(train_index)\n", - "\n", - "image_files = [image_folder+'/'+str(train_index[index])+'.jpg' for index in train_index]\n", - "\n", - "clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps=fps)\n", - "clip.write_videofile(video_name+'.mp4')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "88d0d737", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Community_1_physics_informed_kan-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Community_1_physics_informed_kan-checkpoint.ipynb deleted file mode 100644 index a100250a0..000000000 --- a/tutorials/.ipynb_checkpoints/Community_1_physics_informed_kan-checkpoint.ipynb +++ /dev/null @@ -1,290 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Community 1: Physics-informed KAN" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Disclaimer: This is uploaded from a github user, not the KAN authors. KAN authors did not writer this or proofread this carefully, hence are not responsible for mistakes in this notebook. If you have questions, please consult the github user who uploaded it. Thank you!**" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cpu\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Step: 195 | Loss: 0.011: 100%|██████████| 200/200 [2:52:51<00:00, 51.86s/it] \n" - ] - } - ], - "source": [ - "import torch\n", - "from torch import autograd\n", - "from torch.utils.tensorboard import SummaryWriter\n", - "from tqdm import tqdm\n", - "import matplotlib.pyplot as plt\n", - "from kan import KAN, LBFGS\n", - "\n", - "device = torch.device(\"cpu\")\n", - "print(\"Using device:\", device)\n", - "\n", - "rho = torch.tensor(1.0, device=device, requires_grad=False)\n", - "nu = torch.tensor(0.01, device=device, requires_grad=False)\n", - "eps = torch.tensor(1e-8, device=device, requires_grad=False)\n", - "\n", - "width, height = 10.0, 2.0\n", - "num_points_x, num_points_y = 100, 20\n", - "\n", - "x = torch.linspace(0, width, num_points_x, device=device, requires_grad=False)\n", - "y = torch.linspace(0, height, num_points_y, device=device, requires_grad=False)\n", - "X, Y = torch.meshgrid(x, y, indexing='ij')\n", - "coordinates = torch.stack([X.flatten(), Y.flatten()], dim=1).to(device)\n", - "coordinates.requires_grad = True # Ensure coordinates require grad\n", - "\n", - "model = KAN(width=[2,3,3, 3], grid=5, k=10, grid_eps=1.0,\n", - " noise_scale_base=0.25).to(device)\n", - "\n", - "def batch_jacobian(func, x, create_graph=False):\n", - " def _func_sum(x):\n", - " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1, 0, 2)\n", - "\n", - "def batch_hessian(func, x):\n", - " jacobian = batch_jacobian(func, x, create_graph=True)\n", - " hessians = []\n", - " for i in range(jacobian.size(1)):\n", - " grad = autograd.grad(jacobian[:, i].sum(), x, create_graph=True, retain_graph=True)[0]\n", - " hessians.append(grad.unsqueeze(1))\n", - " return torch.cat(hessians, dim=1)\n", - "\n", - "def navier_stokes_residuals(coords):\n", - " coords = coords.clone().detach().requires_grad_(True) # Ensure coords require grad\n", - " y_pred = model(coords)\n", - " grads = batch_jacobian(model, coords, create_graph=True)\n", - " hessians = batch_hessian(model, coords)\n", - "\n", - " u, v, p = y_pred[:, 0], y_pred[:, 1], y_pred[:, 2]\n", - " u_x, u_y = grads[:, 0, 0], grads[:, 0, 1]\n", - " v_x, v_y = grads[:, 1, 0], grads[:, 1, 1]\n", - " p_x, p_y = grads[:, 2, 0], grads[:, 2, 1]\n", - "\n", - " u_xx, u_yy = hessians[:, 0, 0], hessians[:, 0, 1]\n", - " v_xx, v_yy = hessians[:, 1, 0], hessians[:, 1, 1]\n", - "\n", - " continuity = u_x + v_y + eps * p\n", - " x_momentum = u * u_x + v * u_y + (1 / rho) * p_x - nu * (u_xx + u_yy)\n", - " y_momentum = u * v_x + v * v_y + (1 / rho) * p_y - nu * (v_xx + v_yy)\n", - "\n", - " no_slip_mask = (coords[:, 1] == 0) | (coords[:, 1] == height)\n", - " inlet_mask = (coords[:, 0] == 0)\n", - " outlet_mask = (coords[:, 0] == width)\n", - "\n", - " no_slip_loss = torch.mean(u[no_slip_mask] ** 2 + v[no_slip_mask] ** 2)\n", - " inlet_loss = torch.mean((u[inlet_mask] - 1) ** 2)\n", - " outlet_pressure_loss = torch.mean(p[outlet_mask] ** 2)\n", - "\n", - " bc_loss = no_slip_loss + inlet_loss + outlet_pressure_loss\n", - " total_loss = torch.mean(continuity ** 2 + x_momentum ** 2 + y_momentum ** 2) + bc_loss\n", - " return total_loss\n", - "\n", - "writer = SummaryWriter()\n", - "\n", - "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1,\n", - " history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - " \n", - " steps = 200 # 20 steps are enough\n", - " pbar = tqdm(range(steps), desc='Training Progress')\n", - "\n", - " for step in pbar:\n", - " def closure():\n", - " optimizer.zero_grad()\n", - " loss = navier_stokes_residuals(coordinates)\n", - " loss.backward()\n", - " return loss\n", - "\n", - " optimizer.step(closure)\n", - " if step % 5 == 0:\n", - " current_loss = closure().item()\n", - " pbar.set_description(\"Step: %d | Loss: %.3f\" %\n", - " (step, current_loss))\n", - " writer.add_scalar('Loss/train', current_loss, step)\n", - "\n", - "train()\n", - "\n", - "writer.close()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "u_pred = model(coordinates)[:, 0].detach().reshape(\n", - " num_points_x, num_points_y).T\n", - "\n", - "v_pred = model(coordinates)[:, 1].detach().reshape(\n", - " num_points_x, num_points_y).T\n", - "\n", - "\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", - "\n", - "plt.figure(figsize=(10, 5)) # Set the figure size as needed\n", - "plt.imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", - "plt.colorbar() # Add a colorbar to show the magnitude scale\n", - "plt.title('Velocity Magnitude Contour')\n", - "plt.xlabel('Width')\n", - "plt.ylabel('Height')\n", - "plt.axis('equal') # Ensure the plot has equal scaling\n", - "plt.tight_layout() # Adjust layout to prevent overlap\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Extracting predictions\n", - "u_pred = model(coordinates)[:, 0].detach().reshape(num_points_x, num_points_y).T\n", - "v_pred = model(coordinates)[:, 1].detach().reshape(num_points_x, num_points_y).T\n", - "p_pred = model(coordinates)[:, 2].detach().reshape(num_points_x, num_points_y).T\n", - "\n", - "# Velocity Magnitude\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", - "\n", - "# Plotting all subplots\n", - "fig, axs = plt.subplots(2, 2, figsize=(15, 10))\n", - "\n", - "# Velocity Magnitude\n", - "im0 = axs[0, 0].imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", - "fig.colorbar(im0, ax=axs[0, 0])\n", - "axs[0, 0].set_title('Velocity Magnitude Contour')\n", - "axs[0, 0].set_xlabel('Width')\n", - "axs[0, 0].set_ylabel('Height')\n", - "axs[0, 0].axis('equal')\n", - "\n", - "# u Component\n", - "im1 = axs[0, 1].imshow(u_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", - "fig.colorbar(im1, ax=axs[0, 1])\n", - "axs[0, 1].set_title('u Component')\n", - "axs[0, 1].set_xlabel('Width')\n", - "axs[0, 1].set_ylabel('Height')\n", - "axs[0, 1].axis('equal')\n", - "\n", - "# v Component\n", - "im2 = axs[1, 0].imshow(v_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", - "fig.colorbar(im2, ax=axs[1, 0])\n", - "axs[1, 0].set_title('v Component')\n", - "axs[1, 0].set_xlabel('Width')\n", - "axs[1, 0].set_ylabel('Height')\n", - "axs[1, 0].axis('equal')\n", - "\n", - "# Pressure\n", - "im3 = axs[1, 1].imshow(p_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", - "fig.colorbar(im3, ax=axs[1, 1])\n", - "axs[1, 1].set_title('Pressure')\n", - "axs[1, 1].set_xlabel('Width')\n", - "axs[1, 1].set_ylabel('Height')\n", - "axs[1, 1].axis('equal')\n", - "\n", - "plt.tight_layout() # Adjust layout to prevent overlap\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tutorials/.ipynb_checkpoints/Example_10_relativity-addition-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_10_relativity-addition-checkpoint.ipynb deleted file mode 100644 index 50d49d0eb..000000000 --- a/tutorials/.ipynb_checkpoints/Example_10_relativity-addition-checkpoint.ipynb +++ /dev/null @@ -1,427 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 10: Relativitistic Velocity Addition" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "In this example, we will symbolically regress $f(u,v)=\\frac{u+v}{1+uv}$. In relavitity, we know the rapidity trick $f(u,v)={\\rm tanh}({\\rm arctanh}\\ u+{\\rm arctanh}\\ v)$. Can we rediscover rapidity trick with KAN?" - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=10, k=3, device=device)\n", - "\n", - "# create dataset\n", - "f = lambda x: (x[:,[0]]+x[:,[1]])/(1+x[:,[0]]*x[:,[1]])\n", - "dataset = create_dataset(f, n_var=2, ranges=[-0.9,0.9], device=device)" - ] - }, - { - "cell_type": "markdown", - "id": "cb1f817e", - "metadata": {}, - "source": [ - "Train KAN and plot" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a87b97b0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.28e-03 | test_loss: 2.31e-03 | reg: 6.50e+00 | : 100%|█| 20/20 [00:03<00:00, 5.88it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f1cfc9d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "5ca6421a", - "metadata": {}, - "source": [ - "Retrain the model, the loss remains similar, meaning that the locking does not degrade model behavior, justifying our hypothesis that these two activation functions are the same. Let's now determine what this function is using $\\texttt{suggest_symbolic}$" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2ccb7048", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " function fitting r2 r2 loss complexity complexity loss total loss\n", - "0 arctanh 0.999992 -15.786788 4 4 -15.786788\n", - "1 tan 0.999825 -12.397871 3 3 -12.397871\n", - "2 arccos 0.998852 -9.753944 4 4 -9.753944\n", - "3 arcsin 0.998852 -9.753944 4 4 -9.753944\n", - "4 sqrt 0.982166 -5.808383 2 2 -5.808383\n" - ] - }, - { - "data": { - "text/plain": [ - "('arctanh',\n", - " ((x)>,\n", - " (x)>,\n", - " 4,\n", - " (x, y_th)>),\n", - " 0.999992311000824,\n", - " 4)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,1,0,weight_simple=0.0)" - ] - }, - { - "cell_type": "markdown", - "id": "0092be41", - "metadata": {}, - "source": [ - "We can see that ${\\rm arctanh}$ is at the top of the suggestion list! So we can set both to arctanh, retrain the model, and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1bb96fe1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999759197235107\n", - "saving model version 0.2\n", - "r2 is 0.999992311000824\n", - "saving model version 0.3\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000, device='cuda:0')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'arctanh')\n", - "model.fix_symbolic(0,1,0,'arctanh')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "83b852a3", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.94e-04 | test_loss: 9.43e-04 | reg: 4.12e+00 | : 100%|█| 20/20 [00:04<00:00, 4.34it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20, update_grid=False);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "9ccd0923", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "4b98a727", - "metadata": {}, - "source": [ - "We will see that ${\\rm tanh}$ is at the top of the suggestion list! So we can set it to ${\\rm tanh}$, retrain the model to machine precision, plot it and finally get the symbolic formula." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "99ad38b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " function fitting r2 r2 loss complexity complexity loss total loss\n", - "0 tanh 0.999998 -16.336284 3 3 -16.336284\n", - "1 arctan 0.999435 -10.764618 4 4 -10.764618\n", - "2 cos 0.995899 -7.926177 2 2 -7.926177\n", - "3 sin 0.995899 -7.926177 2 2 -7.926177\n", - "4 gaussian 0.994457 -7.492519 3 3 -7.492519\n" - ] - }, - { - "data": { - "text/plain": [ - "('tanh',\n", - " ((x)>,\n", - " (x)>,\n", - " 3,\n", - " (x, y_th)>),\n", - " 0.9999979138374329,\n", - " 3)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(1,0,0,weight_simple=0.)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "af24c80d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999979138374329\n", - "saving model version 0.5\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(1.0000, device='cuda:0')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(1,0,0,'tanh')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "01936f17", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.97e-06 | test_loss: 2.06e-06 | reg: 0.00e+00 | : 100%|█| 2000/2000 [00:21<00:00, 93.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.6\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=2000, update_grid=False, singularity_avoiding=True);" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "76bcc188", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "b62b0246", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\tanh{\\left(\\operatorname{atanh}{\\left(x_{1} \\right)} + \\operatorname{atanh}{\\left(x_{2} \\right)} \\right)}$" - ], - "text/plain": [ - "tanh(atanh(x_1) + atanh(x_2))" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula = model.symbolic_formula()[0][0]\n", - "nsimplify(ex_round(formula, 4))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_11_encouraing_linear-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_11_encouraing_linear-checkpoint.ipynb deleted file mode 100644 index ee2126327..000000000 --- a/tutorials/.ipynb_checkpoints/Example_11_encouraing_linear-checkpoint.ipynb +++ /dev/null @@ -1,223 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "095b0666", - "metadata": {}, - "source": [ - "# Example 11: Encouraging linearity\n", - "\n", - "In cases where we don't know how deep we should set KANs to be, one strategy is to try from small models, grudually making models wider/deeper until we find the minimal model that performs the task quite well. Another strategy is to start from a big enough model and prune it down. This jupyter notebook demonstrates cases where we go for the second strategy. Besides sparsity along width, we also want activation functions to be linear ('shortcut' along depth)." - ] - }, - { - "cell_type": "markdown", - "id": "ef047a0f", - "metadata": {}, - "source": [ - "There are two relevant tricks: \n", - "\n", - "(1) set the base function 'base_fun' to be linear; \n", - "\n", - "(2) penalize spline coefficients. When spline coefficients are zero, the activation function is linear." - ] - }, - { - "cell_type": "markdown", - "id": "91301ca0", - "metadata": {}, - "source": [ - "$f(x)={\\rm sin}(\\pi x)$. Although we know a [1,1] KAN suffices, we suppose we don't know that and use a [1,1,1,1] KAN instead." - ] - }, - { - "cell_type": "markdown", - "id": "77f9e16d", - "metadata": {}, - "source": [ - "without trick" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c881665b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.74e-04 | test_loss: 3.84e-04 | reg: 8.88e+00 | : 100%|█| 20/20 [00:05<00:00, 3.79it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", - "dataset = create_dataset(f, n_var=1, device=device)\n", - "\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, noise_scale=0.1, device=device)\n", - "\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "201ceacf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAHiCAYAAAAkiYF/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvVElEQVR4nO3de1SVdb7H8c+z90bYpIjgDcdKQTzhnDmZ1Xi0M42OjMyklqVNos6xpotZSaUlY5rdC5cVoE2W19LJrjjZEi+VOd1l1JjpVCszGQsQJZF9lIvB3s/v/DHKQTNFeWDD5v1ay7VcbHZ+Xcvdm9/zey6WMcYIAAAHuYI9AAAg9BAXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAc5wn2AEBrYIxRWVmZKioq1L59e8XGxsqyrGCPBbRYrFyAk/D5fMrOzlZiYqK6dOmi3r17q0uXLkpMTFR2drZ8Pl+wRwRaJIsnUQIntnHjRo0ZM0ZVVVWS/rV6OeroqiUyMlI5OTlKSUkJyoxAS0VcgBPYuHGjRowYIWOMbNv+0e9zuVyyLEu5ubkEBqiHuADH8fl86tmzp6qrq08alqNcLpe8Xq+KiooUHR3d9AMCrQB7LsBxnn/+eVVVVTUoLJJk27aqqqq0YsWKJp4MaD1YuQD1GGOUmJiogoICnc5Hw7IsxcfHa+fOnZxFBoi4AMfYv3+/unTp0qj3x8bGOjgR0DpxWAyop6KiolHvP3TokEOTAK0bcQHqad++faPe36FDB4cmAVo34gLUExsbq4SEhNPeN7EsSwkJCYqJiWmiyYDWhbgA9ViWpalTp57Re9PS0tjMB45gQx84Dte5AI3HygU4TnR0tHJycmRZllyuk39Ejl6hv3r1asIC1ENcgBNISUlRbm6uvF6vLMv6weGuo1/zer1at26dhg8fHqRJgZaJuAA/IiUlRUVFRcrKylJ8fPwxr8XHxysrK0vFxcWEBTgB9lyABjDGaPPmzRo2bJg2bdqkoUOHsnkPnAQrF6ABLMuq21OJjo4mLMApEBcAgOOICwDAccQFAOA44gIAcBxxAQA4jrgAABxHXAAAjiMuAADHERcAgOOICwDAccQFAOA44gIAcBxxAQA4jrgAABxHXAAAjiMuAADHERfgFGzb1oEDB/Ttt99KkkpKSlRZWRnkqYCWjcccAz/i8OHDeuedd7RixQpt3bpVpaWlqqioUMeOHdW7d28NHz5ckyZNUlJSEk+mBI5DXIATKCgo0IwZM5Sbm6sePXpo6NChuuCCCxQVFaWysjJt27ZNmzdvVm1traZNm6a0tDRFRkYGe2ygxSAuwHG++OILpaamqrCwUHfeeaduvPFGRUVFKT8/X36/XxEREerfv79KSkqUmZmp5cuXa/z48XryyScJDHAEcQHqKSsr0xVXXKEdO3ZoyZIlGjlypNxutwoKCjRw4ED5fD717t1beXl5io6Olt/v17JlyzRjxgxNnz5ds2fPlsvFVibgCfYAQEuycOFCbdu2TfPnz9eoUaOOCUVtba38fr/8fr8kybIshYWF6frrr1dhYaHmz5+vkSNHasCAAcEaH2gx+BELOKK0tFTLly/XoEGDNGHChAavQDwej9LS0tS1a1ctXrxYHAwAiAtQZ+vWrSosLNTEiRMVERGhQCBwzK+jjDE/eK1z58666qqr9Pbbb8vn8wXvLwG0EBwWA47Iz89Xu3btNGDAAKWnp+uzzz6re626urru2pZ9+/Zp3Lhx8nj+/+MzZcoUXXLJJVqwYIGKi4vVqVOnZp8faEmIC3BEaWmpIiIi1LFjR+Xl5emDDz444fdVV1dr06ZNx3xtxIgRGjx4sGzbZuUCiLgAdcLDw2Xbtvx+v1wu1w/2XGzbrvv98a9ZlqWamhpJUlhYWNMPC7RwxAU4IiEhQZWVlSoqKtLcuXNVXl5e91pJSYnS0tJUWVmpbt26acGCBWrfvn3d60lJSXr33XcVERGhbt26BWN8oEUhLsARAwcOVLt27bRhwwZlZGQcszopKCio22OJjIxUcnLyMfsqfr9f69atU1JSkuLi4pp9dqCl4Wwx4Ih+/fpp0KBBeumll7Rr164Gn1JsjFFeXp7eeustpaamKjw8vIknBVo+4gIcER4ervT0dPl8PqWnp+vgwYOnDIwxRiUlJZoxY4YSExM1bty4ZpoWaNmIC1DPkCFDdPfdd2v9+vW6+eabVVxcLGOM3G63unfvrri4OHXt2lUul0vGGH311VeaNGmSdu/erczMTE5BBo7g3mLAcb7//ntlZGRo3rx5OuecczRlyhQNHz5c4eHhcrvdCgQCqqio0Jo1a7Ro0SKFhYXp2Wef1bBhw4I9OtBiEBfgBAKBQN3G/vbt2+X1ehUXF6ezzjpLhw4d0p49e+R2uzV69GjNnDlTffr0CfbIQItCXICTqKqq0rZt2/T+++9ry5YtWrt2rcaOHavk5GQNGTJEffr0kdvtDvaYQItDXIAG+uSTT3ThhRdq+/bt3PkYOAU29IHTwOOMgYYhLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcx8PCgAYyxsi2bblcLp7rApwCKxfgNLhcfGSAhvAEewCgsWzb1t69exUIBII9imNcLpe6d+8ut9sd7FGAM8JhMbR65eXlGjdunPr27RvsURyzY8cOrVq1Sp07dw72KMAZYeWCVs8Yo7i4OGVmZjp22Mq2bRUWFmrr1q36+uuvZdu24uPjdfHFF6tXr15NuqIwxmjy5MmybbvJ/gygqREXhATLsmRZVqPjYozRN998o8zMTL322msqLS2t+5+8ZVmKjY3V5Zdfrrvuukt9+/Ztko19ooJQwO4kcEQgENAbb7yhlJQUPfXUU9q7d686duyo888/X/3791dsbKzKysq0bNkypaSk6NVXXw2pfR7ASaxcAEm1tbV69tlnNXv2bB06dEixsbG66aab9Pvf/15nn322JKmkpEQvv/yynnrqKRUWFuqGG25QaWmpbr75Znk8fJSA+li5oM2rra1VVlaW0tPTdejQIfXv31+vv/66HnzwQf3bv/2bIiMjFRkZqYSEBP3xj3/U2rVrddFFF6myslJ//OMf9dxzz3EoCzgOcUGbFggEtHjxYt1///06fPiwhgwZopycHA0aNOiE+zcul0sXXHCBXn75ZQ0aNEjV1dVKT0/X22+/LU68BP4fcUGbZYzR6tWrdc899+jw4cO69NJLtWLFCp177rkn3ai3LEvnnnuuli1bpvPOO08+n0+33367du/eTWCAI4gL2iRjjPLy8nTHHXfo0KFDOv/887Vs2TL16NGjQWeAWZalxMREPfXUU4qOjtZXX32lWbNmqaamphmmB1o+4oI2xxijoqIiTZkyRXv37tXZZ5+tpUuXqlevXqd1arFlWfrlL3+pGTNmyOVyafXq1XrttddYvQAiLmiDqqqqNG3aNH366afq0KGDsrOz1b9//zO6ZsXlcumWW27RpZdeqtraWj300EMqKSlpgqmB1oW4oE0JBALKzMzUmjVr5Ha7NXPmTI0cObJRF0O2b99eDz30kKKiorRz505lZ2dz9hjaPOKCNsMYo/Xr12vevHkKBAIaO3aspk6d2uhbuViWpYEDB2rSpEmSpGXLlumzzz7j8BjaNOKCNsEYo127dmnatGmqqKjQf/zHf2jevHnyer2O/PfdbrfuuOMO9ezZUwcOHNDjjz/O1fto04gL2oTKykpNnz5du3btUkxMjObPn9/gM8Ma6txzz9Utt9wiy7K0Zs0abd26ldUL2izigpAXCAQ0f/58rVu3Th6PR/fee68uueQSx286aVmWrrvuOvXp00cVFRXKysqS3+939M8AWgvigpBmjNFf//pXzZs3T7Zta+zYsbrxxhub7ImSXbp00ZQpU2RZltavX6/t27ezekGbRFwQsowx2rNnj6ZNm6aDBw8qKSlJGRkZioiIaLI/07IspaamKiEhQZWVlXrqqafYe0GbRFwQsmpqajRnzhx99tln6tChg5544gn17NmzSZ7BUl+XLl10ww03yLIs5ebm6vPPP2f1gjaHuCAkGWP0yiuvaNWqVXK5XEpLS1NycnKTh0X61+pl/Pjx6tmzpw4ePKjFixcTF7Q5xAUhxxijr776Svfee69qamp06aWXavr06U36aOLj9ejRQxMmTJAk5eTk6Jtvvmm2PxtoCYgLQk51dbVmzpypwsJCdenSRfPmzVNUVFSzzmBZliZNmqTY2FiVlpbqhRdeYPWCNoW4IKQYY/Tcc88pNzdXbrdbs2bNOuP7hjVWQkKCRo4cKUn685//rAMHDjT7DECwEBeElM8//1yPPPKI/H6/fvvb3+r6669vstOOT8XlcumGG26Q1+vVrl27tH79elYvaDOIC0JGdXW1Zs2apb179youLk6PPfaYY7d3OROWZenCCy/U4MGDZdu2li1bpu+//z5o8wDNibggJBhjtHLlSm3YsKHucFhSUlJQDofV165du7rVU15enrZt28bqBW0CcUHI8Hg86ty5s37zm99o0qRJQQ+L9K/Vy69//WslJibq8OHDeu6554gL2gTigpBw9L5eb731lrKzs4N6OOx4nTp10rhx4yRJubm5+vbbb4M8EdD0iAtChmVZ6tevn3r37t0iVi1HWZala665Rp06dVJpaan+8pe/sHpByCMuQDNISEjQsGHDJEkvvPCCKisrgzwR0LSIC9AM3G63Jk2aJI/Ho88++0wfffQRqxeENOICNAPLsvSLX/xC/fr1U21trVauXCnbtoM9FtBkiAvQTNq3b69rrrlGkvTmm2+ysY+QRlyAZmJZlsaMGaOYmBjt379fr7/+OofGELKIC9CM4uPjNXToUEnSSy+9pKqqqiBPBDQN4gI0I5fLpd///vfyeDz69NNPtXXrVlYvCEnEBWhGRzf2ExMTVVNTw634EbKIC9DMOnbsqDFjxkiSNmzYoL179wZ5IsB5xAVoZpZlaezYserQoYNKSkq4FT9CEnEBguC8887T4MGDZYzRqlWrVFNTE+yRAEcRFyAIPB6PJkyYIJfLpb/97W/6/PPPgz0S4CjiAgSBZVlKTk5Wz549VVVVpVdeeYVDYwgpxAUIki5dumjEiBGSpNdff10+ny+4AwEOIi5AkFiWpXHjxik8PFwFBQV69913Wb0gZBAXIEgsy9KAAQN0/vnnKxAIaNWqVdzMEiGDuABB5PV6625muXnzZu3evTu4AwEOIS5AEFmWpVGjRik2NlYHDhzQG2+8EeyRAEcQFyDIevXqVXczy5dffpmbWSIkEBcgyFwul8aPHy+3261PP/1U27dvD/ZIQKMRFyDILMvSpZdeqoSEBH3//fdas2YNZ42h1fMEewDACcYY2bYty7KCPcoZiYqK0i233KKKigpdeeWVmjdvXrBHAhqFuKDVc7lc2rdvn9LS0oI9SqMYY2RZlrKzs1VUVCSXiwMLaL0sw/obrZxt29q/f39IXSPicrkUGxsrt9sd7FGAM0JcAACO47AY0ED1fw5rrXs7QHPhoC7QQPn5+XK73crPzw/2KECLR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1yABjDGqLy8XJJUXl4ung4OnBxxAU7C5/MpOztbiYmJSk5OljFGycnJSkxMVHZ2tnw+X7BHBFoky/AjGHBCGzdu1JgxY1RVVSVJx6xWLMuSJEVGRionJ0cpKSlBmRFoqYgLcAIbN27UiBEjZIyRbds/+n0ul0uWZSk3N5fAAPUQF+A4Pp9PPXv2VHV19UnDcpTL5ZLX61VRUZGio6ObfkCgFWDPBTjO888/r6qqqgaFRZJs21ZVVZVWrFjRxJMBrQcrF6AeY4wSExNVUFBwWmeEWZal+Ph47dy5s24/BmjLiAtQz/79+9WlS5dGvT82NtbBiYDWicNiQD0VFRWNev+hQ4ccmgRo3YgLUE/79u0b9f4OHTo4NAnQuhEXoJ7Y2FglJCSc9r6JZVlKSEhQTExME00GtC7EBajHsixNnTr1jN6blpbGZj5wBBv6wHG4zgVoPFYuwHGio6OVk5Mjy7Lkcp38I3L0Cv3Vq1cTFqAe4gKcQEpKinJzc+X1emVZ1g8Odx39mtfr1bp16zR8+PAgTQq0TMQF+BEpKSkqKipSVlaW4uPjj3ktPj5eWVlZKi4uJizACbDnAjSAMUabN2/WsGHDtGnTJg0dOpTNe+AkWLkADWBZVt2eSnR0NGEBToG4AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AKdg27YOHDigb7/9VpJUUlKiysrKIE8FtGw85hj4EYcPH9Y777yjFStWaOvWrSotLVVFRYU6duyo3r17a/jw4Zo0aZKSkpJ4MiVwHOICnEBBQYFmzJih3Nxc9ejRQ0OHDtUFF1ygqKgolZWVadu2bdq8ebNqa2s1bdo0paWlKTIyMthjAy0GcQGO88UXXyg1NVWFhYW68847deONNyoqKkr5+fny+/2KiIhQ//79VVJSoszMTC1fvlzjx4/Xk08+SWCAI4gLUE9ZWZmuuOIK7dixQ0uWLNHIkSPldrtVUFCggQMHyufzqXfv3srLy1N0dLT8fr+WLVumGTNmaPr06Zo9e7ZcLrYyAU+wBwBakoULF2rbtm2aP3++Ro0adUwoamtr5ff75ff7JUmWZSksLEzXX3+9CgsLNX/+fI0cOVIDBgwI1vhAi8GPWMARpaWlWr58uQYNGqQJEyY0eAXi8XiUlpamrl27avHixeJgAEBcgDpbt25VYWGhJk6cqIiICAUCgWN+HWWM+cFrnTt31lVXXaW3335bPp8veH8JoIXgsBhwRH5+vtq1a6cBAwYoPT1dn332Wd1r1dXVdde27Nu3T+PGjZPH8/8fnylTpuiSSy7RggULVFxcrE6dOjX7/EBLQlyAI0pLSxUREaGOHTsqLy9PH3zwwQm/r7q6Wps2bTrmayNGjNDgwYNl2zYrF0DEBagTHh4u27bl9/vlcrl+sOdi23bd749/zbIs1dTUSJLCwsKaflighSMuwBEJCQmqrKxUUVGR5s6dq/Ly8rrXSkpKlJaWpsrKSnXr1k0LFixQ+/bt615PSkrSu+++q4iICHXr1i0Y4wMtCnEBjhg4cKDatWunDRs2KCMj45jVSUFBQd0eS2RkpJKTk4/ZV/H7/Vq3bp2SkpIUFxfX7LMDLQ1niwFH9OvXT4MGDdJLL72kXbt2NfiUYmOM8vLy9NZbbyk1NVXh4eFNPCnQ8hEX4Ijw8HClp6fL5/MpPT1dBw8ePGVgjDEqKSnRjBkzlJiYqHHjxjXTtEDLRlyAeoYMGaK7775b69ev180336zi4mIZY+R2u9W9e3fFxcWpa9eucrlcMsboq6++0qRJk7R7925lZmZyCjJwBPcWA47z/fffKyMjQ/PmzdM555yjKVOmaPjw4QoPD5fb7VYgEFBFRYXWrFmjRYsWKSwsTM8++6yGDRsW7NGBFoO4ACcQCATqNva3b98ur9eruLg4nXXWWTp06JD27Nkjt9ut0aNHa+bMmerTp0+wRwZaFOICnERVVZW2bdum999/X1u2bNHatWs1duxYJScna8iQIerTp4/cbnewxwRaHOICNNAnn3yiCy+8UNu3b+fOx8ApsKEPnAYeZww0DHEBADiOuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxPM8FaCBjjGzblsvl4tb7wCmwcgFOg8vFRwZoCE+wBwAay7Zt7d27V4FAINijOMblcql79+48QhmtFofF0OqVl5dr3Lhx6tu3b7BHccyOHTu0atUqde7cOdijAGeElQtaPWOM4uLilJmZ+aOHrQ4fPqzt27dr69atqqioUEJCgi655BKdffbZLW7/xBijyZMny7btYI8CnDHigpBgWZYsy/pBXIwx2rZtm+bMmaP33ntPhw8frvv+Hj166KabbtJtt92mjh07tpjIEBWEAnYnEbJs29brr7+u0aNH680335Tf71efPn10wQUXqFOnTiouLtYDDzyg8ePH69tvvxVHiAHnEBeEJGOM3nzzTd10003au3evzjnnHC1ZskQff/yx3n//fb377ru67rrr5PF4tHHjRqWmpuqbb74hMIBDiAtCjjFGO3bs0K233qoDBw4oMTFRr732miZOnKiYmBh5vV4lJSXpT3/6kzIyMhQZGam8vDzdcMMN2r9/P4EBHEBcEHKqq6uVnp6u3bt3q3PnzlqyZIkGDBhwzJ6KZVkKDw/Xrbfeqscee0zh4eH661//qrvvvrtuXwbAmSMuCCnGGL344ovasGGDPB6P7rvvPg0ePPhHN+s9Ho8mT56sO+64Q5Zl6cUXX9SiRYvYVAcaibggpJSUlGju3Lny+/1KTk7Wtddee8qr6sPCwjRz5kyNGDFCfr9fDz/8sLZs2cLhMaARiAtChjFGixYt0q5duxQVFaU5c+bI6/U26L3t27fXE088ofj4eB04cEB33XWXysvLm3hiIHQRF4SMwsJCLVu2TJL0u9/9ThdddFGDr12xLEvx8fHKyMhQRESE/va3v+mJJ54IqVvKAM2JuCAkGGO0cuVKFRcXq1OnTpo6depp32TSsixdfvnl+u///m8ZY/T000/rww8/5PAYcAaIC0LGJZdcossuu0ypqalKSko6oyvuPR6PZs+erfPOO08HDx7UPffco//93/9tgmmB0EZcEBIsy9KQIUP02muv6dFHHz3jW+MfvS3Mgw8+qPDwcOXl5enpp5/m7DHgNBEXhJTw8HB16NChUfcJsyxLo0aN0tVXXy3btpWVlaW///3vHB4DTgNxAU4gLCxMc+bM0TnnnKOysjLNnj1bVVVVwR4LaDWIC3ACR88emz17tjwej95++239+c9/ZvUCNBBxAX6EZVlKTU3Vb37zGwUCAT366KP6+uuvCQzQAMQFOAmv16sHH3xQXbp0UVFRke6//37V1NQEeyygxSMuwElYlqWf/exnmjZtmlwul1avXq033niD1QtwCsQFOAWXy6XJkydr0KBBqqmp0Zw5c1RcXExggJMgLkADREVF6ZFHHlFUVJS++uorPfLII/L7/cEeC2ixiAvQAJZlafDgwbrllltkWZZWrlypdevWsXoBfgRxARrI7XZr2rRpuuiii1RdXa177rmHw2PAjyAuwGmIiYlRRkaGoqKi9OWXX2rOnDmcPQacAHEBToNlWfrFL36h22+/XS6XSy+++KJefPFFVi/AcYgLcJrcbrfuvPNO/fKXv1RNTY1mzZrFvceA4xAX4AxERUUpMzNTP/nJT7R3715NnTpV3333HYEBjiAuwBmwLEv//u//rrlz58rr9WrLli1KT0/X4cOHgz0a0CIQF+AMWZalq6++WmlpabIsS6tWrdKTTz7J9S+AiAvQKB6PRzNnztTo0aPl9/uVkZGhVatW8XAxtHnEBWik9u3bKzs7WwMHDlRVVZWmT5+ujRs3sv+CNo24AI1kWZbi4uK0ZMkS9e3bVwcOHNDkyZP18ccfExi0WcQFcIBlWUpKStLSpUvVo0cPFRcX67rrrtP//M//EBi0ScQFcIhlWRo0aJAWLVqk2NhYff3117r22mtVUFBAYNDmEBfAQZZlKSUlRQsWLFCHDh30j3/8Q9ddd5327NlDYNCmEBfAYS6XS2PHjq27BubDDz/U5MmTVVZWRmDQZhAXoAm43W5df/31uvfee9WuXTtt2LBBaWlpqqioIDBoE4gL0EQ8Ho/uuOMO3XHHHXK5XHr11Vc1e/Zs7qKMNoG4AE0oPDxc9957ryZNmiRjjJ599lllZWVxFT9CHnEBmpjX69W8efM0YsQI1dbW6uGHH9Yrr7zCVfwIacQFaGKWZaljx47605/+pIsvvlhVVVW688479d5777H/gpBFXIBmYFmWfvKTn2jx4sXq3bu39u/fr8mTJ+vLL78kMAhJxAVoJkdv0//MM88oJiZGX3/9tW666Sbt27ePwCDkEBegGVmWpV/96ld6/PHH5fV69dFHH+n2229XRUVFsEcDHEVcgGbmcrk0YcIE3X333XK73Vq9erUeeughTlFGSCEuQBB4PB7dfffdmjhxoowxWrBggZYsWcIZZAgZxAUIkqOnKP/qV79STU2NZs2apbVr17L/gpBAXIAgsSxLMTExWrhwoX7605/q4MGDuu2227R169ZgjwY0GnEBgsiyLMXHx2vx4sXq0aOH9uzZo+XLlysQCAR7NKBRPMEeAHCCMUa2bcuyrGCPckYuuugiPfXUU3rzzTd13333aebMmcEeCWgUy3CAF62cz+dTamqqevXqFexRGuVoIN1utwoKCvTCCy+oc+fOwR4LOCPEBa2ebdvav39/SJ1p5XK5FBsbK7fbHexRgDNCXAAAjmPPBWig+j+Htda9HaC5cLYY0ED5+flyu93Kz88P9ihAi0dcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuAAAHEdcgAYwxqi8vFySVF5eLp4ODpwccQFOwufzKTs7W4mJiUpOTpYxRsnJyUpMTFR2drZ8Pl+wRwRaJMvwIxhwQhs3btSYMWNUVVUlScesVizLkiRFRkYqJydHKSkpQZkRaKmIC3ACGzdu1IgRI2SMkW3bP/p9LpdLlmUpNzeXwAD1EBfgOD6fTz179lR1dfVJw3KUy+WS1+tVUVGRoqOjm35AoBVgzwU4zvPPP6+qqqoGhUWSbNtWVVWVVqxY0cSTAa0HKxegHmOMEhMTVVBQcFpnhFmWpfj4eO3cubNuPwZoy4gLUM/+/fvVpUuXRr0/NjbWwYmA1onDYkA9FRUVjXr/oUOHHJoEaN2IC1BP+/btG/X+Dh06ODQJ0LoRF6Ce2NhYJSQknPa+iWVZSkhIUExMTBNNBrQuxAWox7IsTZ069Yzem5aWxmY+cAQb+sBxuM4FaDxWLsBxoqOjlZOTI8uy5HKd/CNy9Ar91atXExagHuICnEBKSopyc3Pl9XplWdYPDncd/ZrX69W6des0fPjwIE0KtEzEBfgRKSkpKioqUlZWluLj4495LT4+XllZWSouLiYswAmw5wI0gDFGmzdv1rBhw7Rp0yYNHTqUzXvgJFi5AA1gWVbdnkp0dDRhAU6BuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuACnYNu2Dhw4oG+//VaSVFJSosrKyiBPBbRsPOYY+BGHDx/WO++8oxUrVmjr1q0qLS1VRUWFOnbsqN69e2v48OGaNGmSkpKSeDIlcBziApxAQUGBZsyYodzcXPXo0UNDhw7VBRdcoKioKJWVlWnbtm3avHmzamtrNW3aNKWlpSkyMjLYYwMtBnEBjvPFF18oNTVVhYWFuvPOO3XjjTcqKipK+fn58vv9ioiIUP/+/VVSUqLMzEwtX75c48eP15NPPklggCOIC1BPWVmZrrjiCu3YsUNLlizRyJEj5Xa7VVBQoIEDB8rn86l3797Ky8tTdHS0/H6/li1bphkzZmj69OmaPXu2XC62MgFPsAcAWpKFCxdq27Ztmj9/vkaNGnVMKGpra+X3++X3+yVJlmUpLCxM119/vQoLCzV//nyNHDlSAwYMCNb4QIvBj1jAEaWlpVq+fLkGDRqkCRMmNHgF4vF4lJaWpq5du2rx4sXiYABAXIA6W7duVWFhoSZOnKiIiAgFAoFjfh1ljPnBa507d9ZVV12lt99+Wz6fL3h/CaCF4LAYcER+fr7atWunAQMGKD09XZ999lnda9XV1XXXtuzbt0/jxo2Tx/P/H58pU6bokksu0YIFC1RcXKxOnTo1+/xAS0JcgCNKS0sVERGhjh07Ki8vTx988MEJv6+6ulqbNm065msjRozQ4MGDZds2KxdAxAWoEx4eLtu25ff75XK5frDnYtt23e+Pf82yLNXU1EiSwsLCmn5YoIUjLsARCQkJqqysVFFRkebOnavy8vK610pKSpSWlqbKykp169ZNCxYsUPv27eteT0pK0rvvvquIiAh169YtGOMDLQpxAY4YOHCg2rVrpw0bNigjI+OY1UlBQUHdHktkZKSSk5OP2Vfx+/1at26dkpKSFBcX1+yzAy0NZ4sBR/Tr10+DBg3SSy+9pF27djX4lGJjjPLy8vTWW28pNTVV4eHhTTwp0PIRF+CI8PBwpaeny+fzKT09XQcPHjxlYIwxKikp0YwZM5SYmKhx48Y107RAy0ZcgHqGDBmiu+++W+vXr9fNN9+s4uJiGWPkdrvVvXt3xcXFqWvXrnK5XDLG6KuvvtKkSZO0e/duZWZmcgoycAT3FgOO8/333ysjI0Pz5s3TOeecoylTpmj48OEKDw+X2+1WIBBQRUWF1qxZo0WLFiksLEzPPvushg0bFuzRgRaDuAAnEAgE6jb2t2/fLq/Xq7i4OJ111lk6dOiQ9uzZI7fbrdGjR2vmzJnq06dPsEcGWhTiApxEVVWVtm3bpvfff19btmzR2rVrNXbsWCUnJ2vIkCHq06eP3G53sMcEWhziAjTQJ598ogsvvFDbt2/nzsfAKbChD5wGHmcMNAxxAQA4jrgAABxHXAAAjiMuAADHERcAgOOICwDAccQFAOA44gIAcBxxAQA4jrgAABxHXAAAjiMuAADHERcAgOOICwDAccQFAOA4HhYGNJAxRrZty+Vy8VwX4BQ8wR4AaCzbtrV3714FAoEm/7OMMc0SFpfLpe7du/MIZbRarFzQ6pWXl2vcuHHq27dvsEdpFNu2Jf0rLDt27NCqVavUuXPnIE8FnBlWLmj1jDGKi4tTZmamXK7Wu424bNkyffnll7rtttv00EMP1cUGaI2IC0KCZVmyLKvVxuWbb77Ro48+qm+++UYVFRXigAJau9b5SQRCSCAQ0BNPPKFvvvlGnTp10o033thqIwkcxb9gIIiMMcrLy9OKFSskSTfccIPOP//8IE8FNB5xAYKourpaDz74oA4dOqTExETdfvvtrFoQEvhXDASJMUavvvqqNm/eLI/Ho5kzZ6p79+7BHgtwBHEBgsAYoz179uixxx6T3+/X0KFDdfXVV3NxJkIGcQGCwLZtPfnkk9q5c6eioqJ03333yev1BnsswDHEBWhmxhht2bJFy5YtkyT94Q9/0M9//nNWLQgpxAVoZhUVFZozZ44OHjyovn37avr06dzmBSGHuADNyBijZcuW6b333lNYWJjmzJmjuLi4YI8FOI64AM3EGKPPP/9cc+fOlW3buvzyy3XllVdyOAwhibgAzaS6ulqzZs3Svn37FBcXpwceeEDh4eHBHgtoEsQFaAa2bWvp0qVav369PB6PZs2apfPOO49VC0IWcQGamDFGn3zyiR555BEFAgFddtllmjRpEmFBSCMuQBMyxqisrEx33HGHvvvuO51zzjnKyMjgmhaEPOICNKGamhrNmTNHW7ZsUUREhDIyMtS3b19WLQh5xAVoIrZta/HixXUXS95888266qqrCAvaBOICNAFjjNauXat7771XtbW1Gj58uO69916FhYUFezSgWRAXwGHGGH344Ye65ZZbdPDgQf30pz/VU089pY4dOwZ7NKDZEBfAQcYY5efn6w9/+INKSkrUs2dPLVmyRL179+ZwGNoU4gI4xBijf/zjH5o4caJ27dqlzp07a9GiRbr44osJC9oc4gI44Oi1LOPHj9eOHTvUqVMnLVy4UL/+9a8JC9ok4gI0kjFGH3zwga655hrt2LFDMTExeuaZZzR69GgeWYw2i3/5QCPYtq21a9cqNTVV//znP9WlSxctXrxYV111FWFBm8a/fuAM+f1+Pffcc7r22mtVUlKis88+WytXrtQVV1xBWNDmeYI9ANDaGGN0+PBhPf7445o7d66qq6vVr18/LV26lM174AjiApwGY4zKy8uVnp6uFStWyO/367/+67+0aNEibusC1ENcgAYyxuif//ynbr31Vr311luyLEtjxoxRdna2unfvTliAejgwDDSAMUYff/yxrrzySr355psKCwtTWlqali5dSliAE2DlApyC3+/Xq6++qunTp2vfvn3q2LGjHnroId14440KCwsjLMAJEBfgRxhjVFVVpXnz5umJJ55QVVWVzj33XC1YsEC//e1vOSMMOAniApyAMUYlJSWaPn26cnJyFAgE9J//+Z9auHChfvazn7FaAU6BH72A4xy9lcuVV16pV155RZI0fvx45eTkEBaggVi5APX4/X795S9/0bRp07Rnzx6dddZZSk9P15133imv10tYgAYiLoD+tVqprKzU448/Xre/0rNnTz3xxBO68sor5Xa7gz0i0KoQF7R5xhgVFRVp+vTpev311xUIBPTzn/9cTz/9tPr3789qBTgD7LmgTbNtWx999JGuuOIK5eTkyLIsTZgwQatXryYsQCOwckGbZIxRbW2tVq5cqVmzZum7775Thw4dNHPmTE2dOpX9FaCRiAvaHGOMDhw4oPvvv19Lly7V999/r969eyszM1OXXXYZ+yuAA4gL2hRjjD799FPdfvvt+uCDDyRJw4YNU3Z2ts477zxWK4BD2HNBm3D0MNiLL76oUaNG6f3331d4eLhuv/12vfzyy4QFcBgrF4Q8Y4z279+vhx9+WEuWLNHhw4fVo0cPZWRk6He/+508Hg9hARxGXBDSbNtWXl6e7rrrLuXl5UmSfvGLXygrK0vnn38+UQGaCHFBSDLGqKKiQosWLdLcuXNVVlYmr9eryZMn65577lFMTAxhAZoQcUHIsW1b+fn5mj17tjZt2qRAIKCEhAQ99thjuvzyyzkMBjQD4oKQUlZWpmeeeUbz58/X/v37FRYWpjFjxujhhx9WfHw8UQGaCXFBSDDGaP369XrggQeUn58vY4x69eqlOXPm6JprrlF4eDhhAZoRcUHI+Pvf/678/Hx5vV5dc801uueee9S7d2+iAgQBcUHIuOGGG/T1119r3LhxGjp0qMLCwmSMkTEm2KOdFtu2W93MwPEsw79itHI+n0+pqanq1auXAoFASNy+paCgQC+88II6d+4c7FGAM0Jc0OrZtq39+/fLtu1gj+IYl8ul2NjYkAgl2ibiAgBwHHsuQAPV/zmMkwSAk+PGlUAD5efny+12Kz8/P9ijAC0ecQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AAAcR1wAAI4jLgAAxxEXAIDjiAsAwHHEBQDgOOICAHAccQEAOI64AA1gjFF5ebkkqby8/JhHHgP4IeICnITP51N2drYSExOVnJwsY4ySk5OVmJio7Oxs+Xy+YI8ItEiW4Ucw4IQ2btyoMWPGqKqqSpKOWa1YliVJioyMVE5OjlJSUoIyI9BSERfgBDZu3KgRI0bIGCPbtn/0+1wulyzLUm5uLoEB6iEuwHF8Pp969uyp6urqk4blKJfLJa/Xq6KiIkVHRzf9gEArwJ4LcJznn39eVVVVDQqLJNm2raqqKq1YsaKJJwNaD1YuQD3GGCUmJqqgoOC0zgizLEvx8fHauXNn3X4M0JYRF6Ce/fv3q0uXLo16f2xsrIMTAa0Th8WAeioqKhr1/kOHDjk0CdC6ERegnvbt2zfq/R06dHBoEqB1Iy5APbGxsUpISDjtfRPLspSQkKCYmJgmmgxoXYgLUI9lWZo6deoZvTctLY3NfOAINvSB43CdC9B4rFyA40RHRysnJ0eWZcnlOvlH5OgV+qtXryYsQD3EBTiBlJQU5ebmyuv1yrKsHxzuOvo1r9erdevWafjw4UGaFGiZiAvwI1JSUlRUVKSsrCzFx8cf81p8fLyysrJUXFxMWIATYM8FaABjjA4cOKBDhw6pQ4cOiomJYfMeOAniAgBwHIfFAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBwHHEBADiOuAAAHEdcAACOIy4AAMcRFwCA44gLAMBxxAUA4DjiAgBw3P8BieRdtZ3ZE5kAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "13c725a5", - "metadata": {}, - "source": [ - "with tricks" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a22ffff3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 8.89e-03 | test_loss: 8.40e-03 | reg: 1.83e+01 | : 100%|█| 20/20 [00:04<00:00, 4.20it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", - "dataset = create_dataset(f, n_var=1, device=device)\n", - "\n", - "# set base_fun to be linear\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, base_fun='identity', noise_scale=0.1, device=device)\n", - "\n", - "# penality spline coefficients\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1e-4, lamb_coef=10.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c82c8db5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e3c92b0d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb deleted file mode 100644 index 943ae09b2..000000000 --- a/tutorials/.ipynb_checkpoints/Example_12_unsupervised_learning-checkpoint.ipynb +++ /dev/null @@ -1,251 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 12: Unsupervised learning" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "In this example, we will use KAN for unsupervised learning. Instead of trying to figure out how a target variable $y$ depends on input variables, we treat all variables on the equal footing (as input variables). Below we contruct a synthetic dataset where we have six variables $x_1, x_2, x_3, x_4, x_5, x_6$. $(x_1, x_2, x_3)$ are dependent such that $x_3={\\rm exp}({\\rm sin}(\\pi x_1)+x_2^2)$; $(x_4,x_5)$ are dependent such that $x_5=x_4^3$. And $x_6$ is independent of all other variables. Can we use KANs to discover these dependent groups?\n", - "\n", - "The idea is that we treat the problem as a classification problem. The dataset that satisfies these interdependent relations are 'positive' samples, while corrupted samples (by random permutation of features across samples) are 'negative' samples. We want to train a KAN to output 1 when it is a positive sample, and output 0 when it is a negative sample. We set the last layer activation to be Gaussian, so positive samples will have zero activation in the second to last layer, while negtive samples will have non-zero activation in the second to last layer. We can then define the relation implicitly as $g=0$ where $g$ is the activation in the second to last layer." - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import KAN\n", - "import torch\n", - "import copy\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "seed = 1\n", - "\n", - "model = KAN(width=[6,1,1], grid=3, k=3, seed=seed, device=device)\n", - "\n", - "# create dataset\n", - "\n", - "\n", - "def create_dataset(train_num=500, test_num=500):\n", - " \n", - " def generate_contrastive(x):\n", - " # positive samples\n", - " batch = x.shape[0]\n", - " x[:,2] = torch.exp(torch.sin(torch.pi*x[:,0])+x[:,1]**2)\n", - " x[:,3] = x[:,4]**3\n", - "\n", - " # negative samples\n", - " def corrupt(tensor):\n", - " y = copy.deepcopy(tensor)\n", - " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", - " return y\n", - "\n", - " x_cor = corrupt(x)\n", - " x = torch.cat([x, x_cor], dim=0)\n", - " y = torch.cat([torch.ones(batch,), torch.zeros(batch,)], dim=0)[:,None]\n", - " return x, y\n", - " \n", - " x = torch.rand(train_num, 6) * 2 - 1\n", - " x_train, y_train = generate_contrastive(x)\n", - " \n", - " x = torch.rand(test_num, 6) * 2 - 1\n", - " x_test, y_test = generate_contrastive(x)\n", - " \n", - " dataset = {}\n", - " dataset['train_input'] = x_train.to(device)\n", - " dataset['test_input'] = x_test.to(device)\n", - " dataset['train_label'] = y_train.to(device)\n", - " dataset['test_label'] = y_test.to(device)\n", - " return dataset\n", - "\n", - "dataset = create_dataset()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "79665292", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "45760ca2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "# set the (1,0,0) activation to be gausssian\n", - "#model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d951ae17", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "aa26622b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.80e-01 | test_loss: 1.78e-01 | reg: 3.77e+01 | : 100%|█| 50/50 [00:13<00:00, 3.76it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=50, lamb=0.002, lamb_entropy=10.0, lamb_coef=1.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9d162e40", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(in_vars=[r'$x_{}$'.format(i) for i in range(1,7)])" - ] - }, - { - "cell_type": "markdown", - "id": "b239996d", - "metadata": {}, - "source": [ - "This gives the dependence among $(x_4,x_5)$. Another random seed can give dependence among $(x_1,x_2,x_3)$." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6b5975f8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb deleted file mode 100644 index ae7a4241a..000000000 --- a/tutorials/.ipynb_checkpoints/Example_13_phase_transition-checkpoint.ipynb +++ /dev/null @@ -1,219 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 13: Phase transition" - ] - }, - { - "cell_type": "markdown", - "id": "6465ec94", - "metadata": {}, - "source": [ - "In this example, we will use KAN to learn phase transitions in data. Phase transition is an important concept in science. We consider a toy example $f(x_1,x_2,x_3)$ is 1 if $g(x_1,x_2,x_3)>0$, and is 0 if $g(x_1,x_2,x_3)<0$. $g(x_1,x_2,x_3)={\\rm sin}(\\pi x_1)+{\\rm cos}(\\pi x_2)+{\\rm tan}(\\frac{\\pi}{2}x_3)$." - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "Intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[3,1,1], grid=3, k=3, device=device)\n", - "\n", - "# create dataset\n", - "f = lambda x: (torch.sin(torch.pi*x[:,[0]]) + torch.cos(torch.pi*x[:,[1]]) + torch.tan(torch.pi/2*x[:,[2]]) > 0).float()\n", - "dataset = create_dataset(f, n_var=3, device=device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3837440b", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.5060, device='cuda:0')" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "torch.mean(dataset['train_label'])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fe38f7c5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8627b850", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "# set the last activation to be tanh\n", - "model.fix_symbolic(1,0,0,'tanh',fit_params_bool=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3957140b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "be0b0daf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.71e-02 | test_loss: 1.17e-01 | reg: 2.43e+02 | : 100%|█| 50/50 [00:09<00:00, 5.32it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=50);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2f9b37a8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d6d85bda", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb deleted file mode 100644 index 11bbfbef6..000000000 --- a/tutorials/.ipynb_checkpoints/Example_14_knot_supervised-checkpoint.ipynb +++ /dev/null @@ -1,154 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 14: Knot supervised" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0893a344", - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: './knot_data.csv'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/6j/b6y80djd4nb5hl73rv3sv8y80000gn/T/ipykernel_75986/3212158569.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;31m# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./knot_data.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/util/_decorators.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[0mstacklevel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstacklevel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 310\u001b[0m )\n\u001b[0;32m--> 311\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 312\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 313\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwds_defaults\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 677\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 678\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_read\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 679\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 680\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 573\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 574\u001b[0m \u001b[0;31m# Create the parser.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 575\u001b[0;31m \u001b[0mparser\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTextFileReader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 576\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 577\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0miterator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 930\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 931\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandles\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mIOHandles\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 932\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mengine\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 933\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 934\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1214\u001b[0m \u001b[0;31m# \"Union[str, PathLike[str], ReadCsvBuffer[bytes], ReadCsvBuffer[str]]\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1215\u001b[0m \u001b[0;31m# , \"str\", \"bool\", \"Any\", \"Any\", \"Any\", \"Any\", \"Any\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1216\u001b[0;31m self.handles = get_handle( # type: ignore[call-overload]\n\u001b[0m\u001b[1;32m 1217\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1218\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/common.py\u001b[0m in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoding\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"b\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 785\u001b[0m \u001b[0;31m# Encoding\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 786\u001b[0;31m handle = open(\n\u001b[0m\u001b[1;32m 787\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 788\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './knot_data.csv'" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import torch\n", - "from kan import *\n", - "import copy\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "seed = 42\n", - "torch.manual_seed(seed)\n", - "np.random.seed(seed)\n", - "\n", - "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n", - "df = pd.read_csv(\"./knot_data.csv\")\n", - "df.keys()\n", - "\n", - "X = df[df.keys()[1:-1]].to_numpy()\n", - "Y = df[['signature']].to_numpy()\n", - "\n", - "# normalize X\n", - "X_mean = np.mean(X, axis=0)\n", - "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", - "input_normalier = [X_mean, X_std]\n", - "\n", - "# normalize Y\n", - "max_signature = np.max(Y)\n", - "min_signature = np.min(Y)\n", - "Y = ((Y-min_signature)/2).astype(int)\n", - "n_class = int((max_signature-min_signature)/2+1)\n", - "output_normalier = [min_signature, 2]\n", - "\n", - "dataset = {}\n", - "num = X.shape[0]\n", - "n_feature = X.shape[1]\n", - "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", - "\n", - "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(Y[train_id_][:,0]).type(torch.long).to(device)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(Y[test_id_][:,0]).type(torch.long).to(device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e262aeca", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n", - "\n", - "model = KAN(width=[n_feature,1,n_class], grid=5, k=3, seed=seed, device=device)\n", - "model.fit(dataset, lamb=0.005, batch=1024, loss_fn = nn.CrossEntropyLoss(), metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2254d060", - "metadata": {}, - "outputs": [], - "source": [ - "model.plot(scale=1.0, beta=0.2)\n", - "\n", - "n = 17\n", - "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:-1][i], rotation=270, rotation_mode=\"anchor\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "54778a24", - "metadata": {}, - "outputs": [], - "source": [ - "scores = model.feature_score\n", - "features = list(df.keys()[1:-1])\n", - "\n", - "y_pos = range(len(features))\n", - "plt.bar(y_pos, scores)\n", - "plt.xticks(y_pos, features, rotation=90);\n", - "plt.ylabel('feature importance')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb deleted file mode 100644 index 95ecd68b5..000000000 --- a/tutorials/.ipynb_checkpoints/Example_15_knot_unsupervised-checkpoint.ipynb +++ /dev/null @@ -1,163 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 15: Knot unsupervised" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0893a344", - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: './knot_data.csv'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/6j/b6y80djd4nb5hl73rv3sv8y80000gn/T/ipykernel_76001/3712353914.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;31m# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_csv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./knot_data.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/util/_decorators.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[0mstacklevel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstacklevel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 310\u001b[0m )\n\u001b[0;32m--> 311\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 312\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 313\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwds_defaults\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 677\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 678\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_read\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 679\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 680\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 573\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 574\u001b[0m \u001b[0;31m# Create the parser.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 575\u001b[0;31m \u001b[0mparser\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTextFileReader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 576\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 577\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0miterator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 930\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 931\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhandles\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mIOHandles\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 932\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mengine\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 933\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 934\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/parsers/readers.py\u001b[0m in \u001b[0;36m_make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1214\u001b[0m \u001b[0;31m# \"Union[str, PathLike[str], ReadCsvBuffer[bytes], ReadCsvBuffer[str]]\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1215\u001b[0m \u001b[0;31m# , \"str\", \"bool\", \"Any\", \"Any\", \"Any\", \"Any\", \"Any\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1216\u001b[0;31m self.handles = get_handle( # type: ignore[call-overload]\n\u001b[0m\u001b[1;32m 1217\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1218\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/pandas/io/common.py\u001b[0m in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoding\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m\"b\"\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 785\u001b[0m \u001b[0;31m# Encoding\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 786\u001b[0;31m handle = open(\n\u001b[0m\u001b[1;32m 787\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 788\u001b[0m \u001b[0mioargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './knot_data.csv'" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import torch\n", - "from kan import *\n", - "import copy\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "seed = 2024\n", - "torch.manual_seed(seed)\n", - "np.random.seed(seed)\n", - "\n", - "dtype = torch.get_default_dtype()\n", - "\n", - "# Download data: https://colab.research.google.com/github/deepmind/mathematics_conjectures/blob/main/knot_theory.ipynb#scrollTo=l10N2ZbHu6Ob\n", - "df = pd.read_csv(\"./knot_data.csv\")\n", - "df.keys()\n", - "\n", - "X = df[df.keys()[1:]].to_numpy()\n", - "mean = np.mean(X, axis=0)\n", - "std = np.std(X, axis=0)\n", - "X = (X - mean[np.newaxis,:])/std[np.newaxis,:]\n", - "\n", - "# normalize X\n", - "X_mean = np.mean(X, axis=0)\n", - "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", - "input_normalier = [X_mean, X_std]\n", - "\n", - "dataset = {}\n", - "num = X.shape[0]\n", - "n_feature = X.shape[1]\n", - "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n", - "\n", - "def construct_contrastive_dataset(tensor):\n", - " y = copy.deepcopy(tensor)\n", - " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", - " return y\n", - "\n", - "dataset['contrastive_train_input'] = construct_contrastive_dataset(dataset['train_input'])\n", - "dataset['contrastive_test_input'] = construct_contrastive_dataset(dataset['test_input'])\n", - "\n", - "dataset['train_label'] = torch.cat([torch.ones(dataset['train_input'].shape[0],1), torch.zeros(dataset['contrastive_train_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['train_input'] = torch.cat([dataset['train_input'], dataset['contrastive_train_input']], dim=0).to(device)\n", - "\n", - "dataset['test_label'] = torch.cat([torch.ones(dataset['test_input'].shape[0],1), torch.zeros(dataset['contrastive_test_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['test_input'] = torch.cat([dataset['test_input'], dataset['contrastive_test_input']], dim=0).to(device)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e262aeca", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", - "\n", - "model = KAN(width=[n_feature,1,1], grid=5, k=3, seed=seed, device=device)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)\n", - "model.fit(dataset, lamb=0.001, batch=1024, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1ede24f0", - "metadata": {}, - "outputs": [], - "source": [ - "# seed = 2024\n", - "model.plot(scale=1.0)\n", - "\n", - "n = 18\n", - "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a3fb6b7a", - "metadata": {}, - "outputs": [], - "source": [ - "# seed = 0\n", - "model.plot(scale=1.0)\n", - "\n", - "n = 18\n", - "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb deleted file mode 100644 index ba369ab89..000000000 --- a/tutorials/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb +++ /dev/null @@ -1,396 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 1: Function Fitting\n", - "\n", - "In this example, we will cover how to leverage grid refinement to maximimze KANs' ability to fit functions" - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=1, device=device)\n", - "\n", - "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)" - ] - }, - { - "cell_type": "markdown", - "id": "cb1f817e", - "metadata": {}, - "source": [ - "Train KAN (grid=3)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a87b97b0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.16e-02 | test_loss: 4.35e-02 | reg: 9.79e+00 | : 100%|█| 20/20 [00:03<00:00, 6.03it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "52294efd", - "metadata": {}, - "source": [ - "The loss plateaus. we want a more fine-grained KAN!" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f1cfc9d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "# initialize a more fine-grained KAN with G=10\n", - "model = model.refine(10)" - ] - }, - { - "cell_type": "markdown", - "id": "f3cc5079", - "metadata": {}, - "source": [ - "Train KAN (grid=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "898b1794", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.96e-03 | test_loss: 6.10e-03 | reg: 9.75e+00 | : 100%|█| 20/20 [00:02<00:00, 7.32it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "bcdc0d3d", - "metadata": {}, - "source": [ - "The loss becomes lower. This is good! Now we can even iteratively making grids finer." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "a1c25e8a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.46e-02 | test_loss: 1.53e-02 | reg: 8.83e+00 | : 100%|█| 200/200 [00:10<00:00, 19.67\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "saving model version 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.84e-04 | test_loss: 3.29e-04 | reg: 8.84e+00 | : 100%|█| 200/200 [00:15<00:00, 13.09\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n", - "saving model version 0.4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.21e-05 | test_loss: 4.04e-05 | reg: 8.84e+00 | : 100%|█| 200/200 [00:09<00:00, 21.22\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n", - "saving model version 0.6\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.02e-05 | test_loss: 1.24e-05 | reg: 8.84e+00 | : 100%|█| 200/200 [00:10<00:00, 18.76\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.7\n", - "saving model version 0.8\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.64e-04 | test_loss: 1.74e-03 | reg: 8.86e+00 | : 100%|█| 200/200 [00:17<00:00, 11.72" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.9\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "grids = np.array([3,10,20,50,100])\n", - "\n", - "\n", - "train_losses = []\n", - "test_losses = []\n", - "steps = 200\n", - "k = 3\n", - "\n", - "for i in range(grids.shape[0]):\n", - " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k, seed=1, device=device)\n", - " if i != 0:\n", - " model = model.refine(grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=steps)\n", - " train_losses += results['train_loss']\n", - " test_losses += results['test_loss']\n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "6be8ba55", - "metadata": {}, - "source": [ - "Training dynamics of losses display staircase structures (loss suddenly drops after grid refinement)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "156f68a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(train_losses)\n", - "plt.plot(test_losses)\n", - "plt.legend(['train', 'test'])\n", - "plt.ylabel('RMSE')\n", - "plt.xlabel('step')\n", - "plt.yscale('log')" - ] - }, - { - "cell_type": "markdown", - "id": "6ed8d26b", - "metadata": {}, - "source": [ - "Neural scaling laws (For some reason, this got worse than pykan 0.0. We're still investigating the reason, probably due to the updates of curve2coef)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8301085c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'RMSE')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_params = 3 * grids\n", - "train_vs_G = train_losses[(steps-1)::steps]\n", - "test_vs_G = test_losses[(steps-1)::steps]\n", - "plt.plot(n_params, train_vs_G, marker=\"o\")\n", - "plt.plot(n_params, test_vs_G, marker=\"o\")\n", - "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.legend(['train', 'test', r'$N^{-4}$'])\n", - "plt.xlabel('number of params')\n", - "plt.ylabel('RMSE')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c521e5e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_3_deep_formula-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_3_deep_formula-checkpoint.ipynb deleted file mode 100644 index 93346074e..000000000 --- a/tutorials/.ipynb_checkpoints/Example_3_deep_formula-checkpoint.ipynb +++ /dev/null @@ -1,522 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 3: Deep Formulas\n", - "\n", - "The orignal Kolmogorov-Arnold theorem says that it suffices to have 2-Layer function composition (inner and outer functions), but the functions might be non-smooth or even fractal. We generalize KA representation to arbitrary depths. An example a 2-Layer KAN (with smooth activations) is unable to do is: $f(x_1,x_2,x_3,x_4)={\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$, which requires at least 3-Layer KANs." - ] - }, - { - "cell_type": "markdown", - "id": "7854503c", - "metadata": {}, - "source": [ - "### Three-layer KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.76e-02 | test_loss: 1.79e-02 | reg: 1.05e+01 | : 100%|█| 20/20 [00:05<00:00, 3.60it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b8c880c1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model = model.prune(edge_th=1e-2)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "585b699c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ee39c97b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 9.21e-03 | test_loss: 9.23e-03 | reg: 1.04e+01 | : 100%|█| 50/50 [00:10<00:00, 4.89it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.33e-03 | test_loss: 3.25e-03 | reg: 1.05e+01 | : 100%|█| 50/50 [00:10<00:00, 4.72it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.13e-03 | test_loss: 1.07e-03 | reg: 1.04e+01 | : 100%|█| 50/50 [00:09<00:00, 5.33it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.93e-04 | test_loss: 3.75e-04 | reg: 1.04e+01 | : 100%|█| 50/50 [00:05<00:00, 9.74it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.60e-05 | test_loss: 3.78e-05 | reg: 1.04e+01 | : 100%|█| 50/50 [00:04<00:00, 10.01it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "grids = [3,5,10,20,50]\n", - "#grids = [5]\n", - "\n", - "train_rmse = []\n", - "test_rmse = []\n", - "\n", - "for i in range(len(grids)):\n", - " #model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0, device=device).initialize_from_another_model(model, dataset['train_input'])\n", - " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=20);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" - ] - }, - { - "cell_type": "markdown", - "id": "8c345302-c8bc-4585-8022-c5d90eb64341", - "metadata": {}, - "source": [ - "Author's note: The scaling isn't optimal. Possibly because of updates on curve2coef, to be investigated. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "94f3930a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.009214929305016994, 0.0033308672718703747, 0.00112761405762285, 0.0003925061319023371, 3.601737262215465e-05]\n", - "[0.009230277501046658, 0.0032473765313625336, 0.0010660917032510042, 0.0003754299250431359, 3.784598084166646e-05]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "n_params = np.array(grids) * (4*2+2*1+1*1)\n", - "plt.plot(n_params, train_rmse, marker=\"o\")\n", - "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 10000*n_params**(-4.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "print(train_rmse)\n", - "print(test_rmse)" - ] - }, - { - "cell_type": "markdown", - "id": "f53644fe", - "metadata": {}, - "source": [ - "### Two-layer KAN\n", - "\n", - "Now we show that a 2 two-layer KAN performs much worse for this task" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ae7b654b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.98e-02 | test_loss: 6.11e-02 | reg: 1.25e+01 | : 100%|█| 20/20 [00:08<00:00, 2.35it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN, create_dataset\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,9,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", - "dataset = create_dataset(f, n_var=4, train_num=3000)\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);\n", - "model.plot(beta=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "869828f2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.98e-02 | test_loss: 2.21e-02 | reg: 1.70e+01 | : 100%|█| 50/50 [00:15<00:00, 3.23it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.15e-02 | test_loss: 1.40e-02 | reg: 1.71e+01 | : 100%|█| 50/50 [00:13<00:00, 3.75it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.69e-03 | test_loss: 9.05e-03 | reg: 1.72e+01 | : 100%|█| 50/50 [00:13<00:00, 3.69it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.38e-03 | test_loss: 8.05e-03 | reg: 1.73e+01 | : 100%|█| 50/50 [00:15<00:00, 3.17it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.02e-03 | test_loss: 9.89e-03 | reg: 1.73e+01 | : 100%|█| 50/50 [00:17<00:00, 2.88it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "grids = [3,5,10,20,50]\n", - "\n", - "train_rmse = []\n", - "test_rmse = []\n", - "\n", - "for i in range(len(grids)):\n", - " #model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", - " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4f0a99fd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.01983197219669819, 0.01147659495472908, 0.006687900051474571, 0.004380852449685335, 0.002016218611970544]\n", - "[0.022097894921898842, 0.013952379114925861, 0.009049860760569572, 0.008054238744080067, 0.00989140197634697]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGhCAYAAACphlRxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZw0lEQVR4nO3dd1xV9f8H8NflsmUJyEYlJ8RQEAfuPdLc9VVCzbJyVGammWlZlqXmRkstzdTsl6Vmmjly5giRoeKeoMhS9r73/P64cOXKhgvnjtfz8eChnHu8933J5MVnvD8SQRAEEBEREWkJA7ELICIiIqoOhhciIiLSKgwvREREpFUYXoiIiEirMLwQERGRVmF4ISIiIq3C8EJERERaxVDsAtRNLpfj4cOHsLS0hEQiEbscIiIiqgJBEJCRkQEXFxcYGFQ8tqJz4eXhw4dwd3cXuwwiIiKqgdjYWLi5uVV4j86FF0tLSwCKN29lZSVyNURERFQV6enpcHd3V34fr4jOhZfiqSIrKyuGFyIiIi1TlSUfXLBLREREWoXhhYiIiLQKwwsRERFpFYYXIiIi0ioML0RERKRVGF6IiIhIqzC8EBERkVZheCEiIiKtwvBCREREWkXnOuzWGbkMuHcayEwALByBJkGAgVTsqoiIiPQOw0tVxPwBHJgNpD98es3KBRjwNeD1onh1ERER6SFOG1Um5g/g/8apBhcASI9XXI/5Q5y6iIiI9BTDS0XkMsWIC4QyHiy6duBDxX1ERERULxheKnLvdOkRFxUCkP5AcR8RERHVC4aXimQmVO2+i/8HZCbWbS1EREQEgAt2K2bhWLX7LmwBLvwENO4EeA4GWg8GGjap29qIiIj0FMNLRZoEAVYuENLjISlj3YsAQGJiBdg+B8RHAvdPKz7+/ghw9gNaDwE8hwCNWgESSb2XT0REpIs4bVQRAykinv8QgiBA/kx2kQuAIAAR/guBN48D0y8ptk437QpIDID4KODoQmBtB2BNO+Dwp0BcuOIPERERUY1JBEG3vpump6fD2toaaWlpsLKyqtVzyeQCunz9D3wzTuAToy1wkTxWPvZQsMNnBSGIsuyGU7N7QWpQYmQlKxm4th+48idw+yggy3/6mJWrYlrJczDQOAiQcvCLiIioOt+/GV4qcOZWCsZsOAsAMIAc7Q2uwgGpSIQN/pO3hrxo4OrnSR3RqZld2U+Smw7cPARc2QtcPwgUZD19zMwWaDVIMbX0XA/AyLRW9RIREWmr6nz/1pkf+0NDQxEaGgqZTH09VxIzcpW/l8MAZ+VeZd4Xn5pT/pOYWgHeIxUfBbnA7WOKIHNtP5DzGIjcqvgwtgBa9FUEmRb9ABNLtb0PIiIiXcKRlwqUHHmpiKWpIUYHuGN0Ozd4OlfxNWWFisW9V/YqppcySvSTkRoDz/VUTC21GgQ0sK/hOyAiItIOnDZS85qXR2m5ZfbYBQADCVQW83q7WmF0gDuGtnGBjblx1V5ILgceRgBX9yrCTMrNp49JDIAmnZ+uk7F2q/H7ISIi0lQML2oKLwBw4FI8Jm+9AED1kIDi5blrxraFqZEUv56Pw5GrCSiQKe4ylhqg7/OOGB3ghq4tGqku6K2IIABJ14pGZP4AHkWrPu7irwgxni8C9i1q9+aIiIg0BMOLGsMLoAgwC/bGID7t6RoYZ2tTfDLECwO8nZXXHmflY3fEA/waHocr8enK605Wphjh74pRAW54rpFF9V78yT3g6p+KqaX7Z6ASoexbKdbIeA5R9JVhLxkiItJSDC9qDi+AYgrpvzuPkZiRCwdLU7T3sK1wNOXSgzTsDI/D7sgHSM0uUF5v16QhRrdzwwu+LrAwqeZ66cxE4Oo+RZi5fRyQP31eWDd+2t23cUfAQFrdt0hERCQahpc6CC81lVcow5Erifj1fCyOX09Sro8xM5JioI8TRge4o4OHLQyqOq1ULDdNsfX6yh/AzcNAQfbTx8ztgdaDFFNLHt0AQxP1vSEiIqI6wPCiQeGlpIT0XPx+4QF+PR+L28lP+72425phlL87Rga4wq2hefWfuCAHuPVP0Rbsv4Dc1KePmVgptl57DgGa9wFMqjltRUREVA8YXjQ0vBQTBAEX7j/BzvA47I2KR2ZeIQDFkpWgZnYYHeCOAd5OMDWqwdSPrAC4e0oRZK7uAzIfPX3M0BRo1ksRZFoOAMxt1fSOiIiIaofhpQ7DS0pKCuzsyummWwM5+TIcuByP/wuLw5nbKcrrliaGGOzngtHt3NDW3QaSmizGlcuBB+eLdi7tBZ7cefqYRAo07aIIMq1fAKxc1PBuiIiIaobhpY7CS1RUFDp37ow5c+bgww8/hFSq3kWxsY+zsTM8DjvD4/CgRNfe5g4WGB3ghuH+rnCwrOERAoIAJFwu2rm0F0i4pPq4a7unO5fsmtXiXRAREVUfw0sdhZePPvoIixYtAgB06dIFP/30E5o2barW1wAAuVzA2dsp+DU8Dn9dikdugRwAIDWQoEfLRhjdzg29WjvC2LAWh4I/vq3Yfn31TyD2nOpjDl5FIzKDAScfbsEmIqI6x/BSR+FFEAT89NNPmDp1KjIzM2FlZYW1a9ciODhYra9TUnpuAfZFx+PX87G4cD9Ved22gTGGtnHB6AB3eLnU8n2mxwPX9inCzN2TgLzw6WM2TZ6OyLi1BwxqEZiIiIjKwfBSxwt2b9++jVdeeQVnzpwBAIwZMwZr166FjY1NnbxesZuJmdgZHoffL8QhMSNPef15FyuMDnDD0DauaNigikcSlCfnCXD9b8XU0s3DQOHTxnywcHx6CnbTroBhLV+LiIioCMNLPew2KiwsxBdffIHPP/8cMpkMq1atwttvv11nr6fy2jI5Tt5Ixq/hsTgUo3okQR8vB4wOcEfXFvYwlNZylCQ/C7h5RBFkrv8N5KU9fczEGmg1QBFkmvUGjGuwxZuIiKgIw0s9bpU+c+YM1q9fj40bN6p9AW9VPMnKx55IxZEElx8+PZLA0coEw9u6YXQ7NzSr7pEEZSnMB+6eKNqCvR/ISnz6mKEZ0Lx30Rbs/oBZw/KfRy4D7p0GMhMUIzlNgtgNmIiIGF7E7POSnZ2NN954A/Pnz0fLli3r9bVjHqbj1/BY7I54gCcljiTwb2yD0e3cMdjXGZamRrV/IbkMiP2vaOfSH0Dq/aePGRgquvq2LjqqwNKxRIF/AAdmA+kPn16zcgEGfA14vVj7uoiISGsxvIgYXj744AMsXboU5ubmWLFiBV5//fWa9WiphfxCOY5cScCv4XE4di1ReSSBqZEBBno7Y3Q7N3T0sKv+kQRlEQTg0cWnvWSSrpR4UAK4t1eMyBiaAftnQvVs7qJ7AOClLQwwRER6jOFFxPASFxeH8ePH459//gEADB06FBs3boS9vX291wIAiem5+D1CcSTBraSnRxK4NTTDqAA3jPR3g7utGterJN8ErhYFmQfhVfxDEsUIzPSLnEIiItJTDC8iHw8gl8uxfPlyfPTRR8jPz4eTkxM2b96M/v37i1IPoNjmHRGbil/Px+HPqIfIyHu6HTqomR1Gt3PDgOedYWasxvCQ9kBxREHET8Cj6MrvH/8n4NFVfa9PRERag+FFQ842ioyMxNixY3HlimIq5dtvv8Wbb74pak2A4kiCvy8/wq/hsfj35rNHEjhjVIA7/BvX8EiCslzcCfz2WuX3WbsrDpF0bw+4BQK2z7FBHhGRnmB40ZDwAgA5OTmYNWsWtm/fjqioKLi5uYldkoq4J9n4LfwBdl6IRezjp0cSNGvUAKMC3DHC3xWOVjU8kqDYnZPAj4Or/+fM7RQhxq2dokGeqz9gYlm7WoiISCMxvGhQeCmWlJSERo0aKT8/cuQIevbsCQMN6Vgrlws4d+cxfg2PxV8XHyGnQAYAMJAA3Vs2wuh27ujt6QATwxpMK8llwApvRSffUgt2AUCi2DY9YJFinUxcGPAwEpDlPXObgeLoArdAxYd7e8CuOUdniIh0AMOLBoaXkvbu3YsXX3wRffv2xebNm+HiolknOmfkFmD/xXj8ej4O5+89UV5vaG6EoW1cMSrADd6u1tV70pg/gP8bV/RJyb9y5ew2KsxT7GKKC1Nsy447D6SV2JJdzNTmaZBxa6c4YNJUM/+7ExFR+RheNDy8bNmyBW+99RZycnJga2uLjRs3Yvjw4WKXVaZbSU+PJEhIfzoS4umsOJJgWFtX2Fb1SIIy+7y4AgO+qto26fR4RZgp/ngYoXp8AQBAAjh4Pp1qcgsE7FvyTCYiIg3H8KLh4QUArl69iuDgYFy4cAEA8Nprr2HFihWwsFBDN9w6IJMLOHEjCTvPx+FQTALyZYqTro2kEvTxdMTodm7o1qJR5UcSqLPDrqzg6ehM8QhN6r3S95lYA24BijDjHgi4BlTcBZiIiOodw4sWhBcAyM/Px/z587F48WIIgoDmzZtj27ZtaN++vdilVehJVj7+iHqIX8NjcenB0yMJHCxNMNzfFaMD3NHcoewQJpML+O/OYyRm5MLB0hTtPWwhVUezvGIZCcCD80+nmh5eAAqyS99n36pouilQEWoatWKPGSIiETG8aEl4KXbs2DGEhIQgLi4Ov//+u8ZOIZXlSnw6fj0fh92RD/A4K195vW1jG4wOcMdgP2dYFR1JcOBSPBbsjUF82tOpHmdrU3wyxAsDvJ3rpkBZIZBwSXW66fHt0vcZWz4dnSne4WRuWzc1ERFRKQwvWhZeAODJkyf47bff8PrrryuvFRYWwtDQUMSqqi6/UI5/riZiZ3gsjl5LgqzoTAJTIwMMeN4JTe0aYOWRG+UdDoB1r/jXXYB5Vlay6lTTgwtAQVbp++yaP51qcgtU7HTi6AwRUZ1geNHC8PKs+Ph4dO3aFQsWLEBwcLDY5VRLYkYudkc8wK/n43AjMbPS+yUAnKxNcWp2L/VOIVWVXAYkxhSFmTAg7j8g5Wbp+4wtAJe2RTubinY3NRDn2AciIl3D8KID4WX27NlYvHgxAGDMmDFYu3YtbGxsxC2qmgRBQGRsKkKP3sThK4mV3v/zpI7o1MyuHiqrguzHijUzcUVhJi4cyM8ofZ/tc6p9ZxyeB6TaMVpGRKRJGF50ILwUFhZi0aJFWLBgAWQyGRo3bowtW7age/fuYpdWbXsiH+DdHZGV3jcqwA1TezZHUzvzej+Ju1JyGZB0rSjIFI3QJF8rfZ+ROeDirxiVKT7mwMKh/uslItIyDC86EF6KnTt3DsHBwbh16xYkEglmz56NBQsWwNi4ir1VNMCZWykYs+Fsle93tzVDtxaN0LVFIwQ1t1Mu+NU4OU8UHYFjS4zO5KWVvs+mydMg4xYIOPkAUg19T0REImF40aHwAgCZmZmYPn06vv/+ewDAwoULMXfuXJGrqjqZXECXr//Bo7TcMg8HAABLU0N4OVviwv1UFMie3iU1kKCtuw26tWyEbi0bwcfVWpx1MVUhlwPJ159ONcWGAUlXUepIBENTxdqZktNNlk6ilExEpCm0OrzExsYiJCQEiYmJMDQ0xLx58zB69Ogq/3ldDC/Ffv/9dyxduhSHDh1CgwYNxC6nWg5cisfkrYqGfGUcDqDcbZSVV4izt1Nw4noSTt5Ixu1k1V1ANuZG6NzcHt1bNELXlvZwtjarnzdQU7lpRec1FfeeCQNyU0vfZ91YdarJyRcw1J7RNSLSE+psNPoMrQ4v8fHxSEhIQJs2bZCYmAh/f39cu3atyt+sdTm8AIpFsMXrQeRyOT7//HNMmTJF5dBHTVWTPi+xj7Nx4kYSTl5Pxr+3kpGRW6jyeAsHC3Rt0QjdWtqjg4cdzIw1fCuzXA48vvU0yMSFKXY6CXLV+6QmgEubp6MzboGAtasoJRMRASjniBcXYMDXVTvipRJaHV6e5evri3379sHd3b1K9+t6eClp2bJleP/99+Ho6IhNmzZh4MCBYpdUqdp02C2UyREZm4oTN5Jx4noSouNSIS/xt9fY0ADtm9qiW0t7dGvZCK0cLTVv4W9Z8jIUvWbi/ns6QpPzuPR9Vq6qU01OvoCRaf3XS0T6R3m4bjndup49XLcG6jS8nDhxAkuWLEF4eDji4+Oxa9cuDBs2TOWetWvXYsmSJYiPj8fzzz+PFStWoGvXrtV+I+fPn8eECRNw6dKlKv8ZfQovUVFRCA4OxuXLlwEA06ZNw+LFi2FmpuFTKWqSmp2Pf28qpphO3EhSGdEBFMcVFI/KdGluDzsLE5EqrSZBUHQBVp6oHQYkXAYEmep9UmNFgCk+UdutPWDtBmhDYCMi7SGXASu8VUdcVEgUIzDTL9ZqCqlOw8tff/2Ff//9F/7+/hg5cmSp8PLLL78gJCQEa9euRefOnfHdd99h48aNiImJQePGjQEAAQEByMvLK/XcBw8ehIuLCwAgJSUFXbt2xcaNGxEUFFRuPXl5eSrPlZ6eDnd3d70ILwCQk5OD2bNnY/Xq1QAALy8vbN++HX5+fiJXVr8EQcCtpEwcv56MkzeScPZ2CnILnk7FSCSAt4s1urZQjMr4N24IY0MtOmk6P0txinZxmIn9D8hOLn2fhdPT85rcAhVTT0b6EWaJSI3kcsXuyawU4NY/wF8fVP5nxv8JeFR/oKJYvU0bSSSSUuGlQ4cO8Pf3x7p165TXPD09MWzYMCxatKhKz5uXl4e+ffti0qRJCAkJqfDeTz/9FAsWLCh1XV/CS7EDBw5gwoQJSEhIgLGxMTZs2IBx48aJXZZocgtkCL/3pGhUJhlX4tNVHm9gLEWnZnZFIzONNLO3TEUEAXhyV/WYg4RLgFx1TRAMDBWjM8VTTW7tFFu3tem9ElHtFeQA2SmK41GyUxSNOLOLf198/XHR50W/f3a0tzIjvwd8RtW4RNHCS35+PszNzfHrr7+qHC747rvvIjIyEsePH6/0OQVBwNixY9GqVSt8+umnld6v7yMvJSUlJeG1117DgQMHcPbsWfj7+4tdksZITM/FyRuKUZmTN5KRUuIQSUDRW6Zri0bopum9ZSqSnw3ER6ouBs5MKH1fAwfVqSaXtoCxeeXPX4e7DIioGuQyRZ8plTBSInSUFVIKsmv2WsaWiuabWWX8W/Ksehx5UWsf8+TkZMhkMjg6Oqpcd3R0xKNHj6r0HP/++y9++eUX+Pr6Yvfu3QCAn376CT4+PmXeb2JiAhMTLVnLUMcaNWqEPXv2IDo6WmXa6NatW2jWrJmIlYnPwcoUIwPcMDLADXK5gJj4dJy4kYQT15MQfu8JYh/nYPu5+9h+7r5Kb5muLezh62ajub1lSjI2VwSKJkXTrIIApMWqhpn4aCArEbj6p+IDACRSwMn76VSTeyDQ0EN1dKaOdxkQ6S1BAPIzS4yApDwTRooCSMmQkvMEpRfOVoGBEWBup/hoYPf09+b2Rb/aKs5rMy/xmKFJiTUv8eW8btGalyblL/FQtzo5hOXZ4feS23sr06VLF8jl8spvpDJJJBKV4BIREYEOHTogJCQEK1euhIWFhYjVaQYDAwm8Xa3h7WqNKT2al9lb5vy9Jzh/7wmWHbqu7C3TrWi9jMb3likmkQA2jRUfxUO5BTmKABP339NQkxEPxEcpPsI2KO4zty/a2dROMRV17CuU+kcrPV6x+0ANuwyIdEZhvmK3YKlRkZRypmhSAFnpNaBVYmpTIozYK8KHShh55rqJVc2mjA2kih9U/m8cFLuLyujWNeCreh2JVWt4sbe3h1QqLTXKkpiYWGo0hurHv//+i8LCQvzwww84fvw4tm3bhg4dOohdlkZpYGKI3p6O6O2p+Dsa+zgbJ4u2Y/97Kxmp2QXYFx2PfdHxALSwt0xJRmZA4w6Kj2JpcaonasdHKX7iu/6X4qNcRf+A7ZuhOKDSrCFgaqU4fZtrakgXCIKiqWSpqZgKpmjKOiKkKgxNi0LHs6MfJUOJ3dPHzBrW7zEjXi8qflApcwT2q3r/AaZOFuwGBARg7dq1ymteXl4YOnRolRfs1oY+bZWuquPHjyMkJASxsbGQSqX45JNPMGfOHBga8vTjyhTK5IiKS8Xx65X3lunaohFaO2lJb5mKFOYVjc6EAdf2AXdPVe/PSwwUP+GZWgEm1opfTa1LXCv6XPn74vtKXDMyYwAi9SvIfWaRaiVTNDmPSy+CrwqJAWBmW8kUzTPXjbWka7q2dtjNzMzEzZs3AQBt27bFsmXL0LNnT9ja2qJx48bKrdLffvstOnXqhPXr12PDhg24fPkymjRpUvN3VYnQ0FCEhoZCJpPh+vXrDC/PSE1NxeTJk7Fjxw4AQOfOnfHTTz/Bw8ND5Mq0S3FvmZNF62UePtNbppGlCbq2sEf3lo20q7dMeS7uBH57rfL7jC2Awtya/UNfFgPDcgJPiWuVPW6o5V97qphcBuSklrFjpqydNEW/FmRV+rRlMrZQXQfSoMQakVJTNHaKv4dczF5tdRpejh07hp49e5a6Pn78eGzevBmAoknd4sWLER8fD29vbyxfvhzdunWrzsvUGEdeyicIArZt24apU6ciPT0d33zzDWbMmCF2WVqruLfMievJOFFGbxkA8Ha1Up6QHdBEy3rLAMCdk8CPgyu/b/yfQNMuijU1eelAbrriXKe8NMXv84o+V/6++PGi3+elFX2eUfqohJoyNK1gtMe6jPBTMhAV/SrVkdFJTd8pJgiKXkblTseUsWakxotWDVUXqKqEEbvSIcXMlp2s64lOHQ9QXQwvlbt79y5CQ0Px9ddfw8BAy76ZajCd7C1T1V0GteysqVS886JUuCkOP2VdeyYQ5WfUvo5iRg3KCTdVHA0ysQLE/n9MjJ1isoJneoZUYZqmxotWrcufiinrek0XrVKdY3hheKmWrKwsDB8+HB999BF69Oghdjk6o7LeMm4NzdCtpRb0llGeaQKUuctA03YbyWWKEZxyR3sqGA0qvlbTnhilSAATy0rCj5XqaM+z64FqswBaHefRCILia1LmjplypmhqumhValJ6FKSiKZr6XrRKdYrhheGlWubNm4eFCxdCIpHggw8+wOeffw5jY2Oxy9IpZfWWKZA9/V9P43vLlPnTu6souwzqhaxAEYAqHe2p4PGajiQ8SyJVBKCyFjZXNBpk1AD4aRiQWUGPLXN7YMAixRRMeVM02Sk1XMskeWbrbllTNM9cNzLnqIgeY3hheKmWzMxMvPfee9i4cSMAwN/fH9u2bUPr1q1Frkx3ldVbpiRrMyN0aW6v3MXkYqMBvWU0fd2EpinMKxFoUitY71NGCCr+vboWQKuDsUU5C1TL6C1ibgeY2fDvB1ULwwvDS43s2rULr7/+Oh4/fgwzMzN88803eOuttzR/XYYOeLa3TEau6jet5g4WioW/Le3RUdt6y1DNCEKJBdDFoz1p5YSfMhZAZyUp/nxl7FsBDp4VL1w1t+OiVapzehleuFVaPR4+fIgJEybg0KFDAIAFCxZg/vz5IlelX6raW6b4hGyd6C1D6lednWK1OI+GSF30MrwU48hL7cnlcqxatQpLlixBWFgYXFxcxC5Jr1Wnt0zn5vaw1/beMqQe9b1TjKiWGF4YXtQiJycHZmZP11rs2LEDQ4cOVblG9UsvesuQ+mjbTjHSawwvDC9qt3v3bgwfPhxeXl7Ytm0b2rRpI3ZJhMp7y5gbS9HpOTvFlmxt6S1D6qVvO8VIazG8MLyo3eHDhxESEoJHjx7B2NgYX3zxBWbMmMEmdxqm6r1l7BHU3F5ze8uQenGnGGkBhheGlzqRlJSESZMmYc+ePQCAXr164ccff4Sbm5vIlVFZSvaWOXk9GefvPS6zt0zxCdmV9ZaRyQX8d+cxEjNy4WBpivYetprVi4aItBrDC8NLnREEARs3bsT06dORnZ2Nhg0bYtOmTRg6dKjYpVElinvLFG/Jrk5vmQOX4rFgbwziSywWdrY2xSdDvDDA27ne3gMR6S69DC/cKl2/rl+/juDgYJw/fx67d+9meNFCVe0tY2ZsgLVHb5XXYB7rXvFngCGiWtPL8FKMIy/1p6CgAPv27cOwYcOU1zIyMmBpaSleUVQjJXvLnLyRhKhY1d4y5ZEAcLI2xanZvTiFRES1wvDC8CKKBw8ewN/fH1OmTMHcuXNhaGgodklUQ8W9ZXaGx+LotaRK71/1vzYY4ufCnUxEVGPV+f7NrSKkNj///DMSExPx6aefolu3brh9+7bYJVEN2Zgb4wVfZwxr61ql+9/ZEYl2Cw/jtc1hWPPPDZy6kYz03II6rpKI9BVHXkittm/fjsmTJyM9PR0WFhZYvXo1xo8fz5/ItdSZWykYs+FspfdJDQCZaq88SCRA80YWaONugzaNbdDG3QatHC1hKOXPTERUGqeNGF5EdffuXYSEhODUqVMAgNGjR+Pbb7+Fra2tyJVRdcnkArp8/Q8epeWW12AeTtamODyjO64+ykBkbCoi7j9BZGwq4p6UPhTQzEgKHzdrtG1sg7buNmjj3hBO1jzwj4gYXhheNIBMJsPXX3+NTz75BIWFhfjwww+xaNEiscuiGjhwKR6Tt14AUGaD+XJ3GyVl5CEyNhWRsYowExWbhsy8wlL3OVubKkZnij583Kxhbsz1UkT6huGF4UVjhIWF4fPPP8eOHTtgbm4udjlUQ+ro8yKTK85liryfiojYJ4i4n4rrCRmldjVJDSRo5WiJNkWjM20b2+A5ewsYcDcTkU5jeGF40VhyuRzvvvsupkyZAk9PT7HLoWqoiw67WXmFiI5LU47QRNxPRWJGXqn7LE0NVUZn2rjbwI6nZxPpFL0ML2xSpx1WrlyJ6dOnw9TUFN988w0mT57MxbykJAgC4tNyi8KMYv3MxQdppU7OBoDGtuZoUzQy08bdBl4uVjAx5Hk9RNpKL8NLMY68aLb4+HhMmDABBw8eBAC88MIL+P777+Ho6ChyZaSpCmRyXHuUgYjYVETeV4zQ3ErKKnWfsdQAXi5WykDT1r0h3G3NGI6JtATDC8OLRpPL5VizZg1mzZqFvLw8ODg4YNOmTRg0aJDYpZGWSMsuQFRcqsrupifZpfvK2DYwVoSZou3afu42PEmbSEMxvDC8aIWLFy8iODgYFy9eBAB89dVXmD17tshVkTYSBAH3H2cj4n5RoIlNRczDNJVTtIs1d7BQrptp25i9Z4g0BcMLw4vWyM3NxZw5c7Bu3TqcPXsWbdq0Ebsk0hG5BTLExKcX7W5STDfFPi6n94yrtXLtTJvGNnC2NivjGYmoLjG8MLxonbi4OLi5uSk/P3fuHAIDA2FgwJ+ISX2SM/OK1s2kFvWeSUVGGb1nnKxMlUGmLXvPENULhheGF60WHh6Ojh07omvXrvjxxx/h7u4udkmko+RFvWcilLubUnHtUXqZvWdaOloqR2fautugWSP2niFSJ4YXhhettnPnTowfPx7Z2dmwsbHB+vXrMXr0aLHLIj2RnV+Ii3Fpyt1NEbFPkJBeRu8ZE0P4lVg7w94zRLXD8MLwovVu3LiB4OBghIWFAQDGjx+PVatW8b8piSI+LUc53RRxPxXRD1LL7D3jbmuGtu4NlVNOz7P3DFGVMbwwvOiEgoICLFiwAIsWLYJcLoeHhwe2bt2KoKAgsUsjPVcok+NaQoZyd1NkbCpuJmaWus9YagBPF6uiQygVIzSNbc3Ze4aoDHoZXthhV3edPHkSISEhuHfvHpYtW4b33ntP7JKISknLKUB0XGqJ3U2peJyVX+q+4t4zxR9+7jawNmPvGSK9DC/FOPKim9LS0vDdd99h5syZyh1Icrmcu5FIYwmCgNjHOcpDKCNjUxHzMB35stLTTc0aNUAb94bK3U2tndh7hvQPwwvDi87LyspC9+7dMW3aNIwfP57D8KQV8gpliHmYXuLsplTcf5xd6j5TI4Oi3jMNldNN7D1Duo7hheFF5y1duhQffPABAGDUqFH47rvvYGtrK3JVRNWXkpmHqLhUlfUzGbmle884WpkUTTU1RNvGNvBxtUYDk6r1nqmLE8GJ1I3hheFF58lkMixZsgTz5s1DYWEhXF1dsWXLFvTq1Uvs0ohqRS4XcDs58+lRB/dTcS0hA7Jnms8YSFDUe6ah8uym5mX0njlwKR4L9sYgPi1Xec3Z2hSfDPHCAG/nenlPRFXB8MLwojfOnz+P4OBgXL9+HQAwc+ZMLFy4ECYm7LdBuiM7vxCXHqQrD6GMjE1VCSPFLE0M4etuXdRIryEeZ+dj9s5oPPuPfHG8WfeKPwMMaQyGF4YXvZKVlYX3338f3333HQDgnXfewcqVK0WuiqhuPUrLRWTsE0QUjc5cjEtDToGsyn9eAsDJ2hSnZvfiFBJpBIYXhhe9tGfPHsyZMwdHjhyBszN/miT9UiiT43pCZtFU0xOcvpWMB6mlR2ee9fOkjujUzK4eKiSqGMMLw4veenb7dGhoKEaNGgVHR0cRqyKqf3siH+DdHZGV3uftaoWQjk3Qs7UDHCxN674wonJU5/s3GwmQTikZXH777TdMmzYNPj4++PPPP0Wsiqj+VTWIXHqQjtm/XUT7L45g6JpTWHXkBi49SIOO/VxLOobhhXRWq1at4Ovri6SkJAwZMgSTJ09GdnbpnhpEuqi9hy2crU1R3moWCQB7C2NM79MCfm7WAICouDQsO3Qdg1efQtBX/2Duros4ejURudVYS0NUHzhtRDotNzcXc+fOxbJlywAoAs327dvh7+8vcmVEde/ApXhM3noBAFR2HJW12ygxPRf/XE3EkauJOHUjWWXxr5mRFJ2b26OPpwN6tXaAgxWnl0j9uOaF4YWecejQIYwfPx7x8fEwMjLCypUrMXnyZLHLIqpzNenzklsgw5lbKTh8JQH/XE0stS3b180avVs7orenA553sWKHa1ILvQwvPJiRKpOSkoJJkyZh165d2Lt3LwYPHix2SUT1ojYddgVBQEx8Oo5cScSRKwmIiktTedzZ2hS9Wjugt6cDgprZw9RIWhdvgfSAXoaXYhx5oYoIgoDTp0+jc+fOymsPHz6Ei4uLiFURaY/EjFwcvZqIw1c4vUTqxfDC8EJVFBcXB19fXwwePBhr1qzh3xmiasgtkOHM7RQcuZKAI1c4vUS1w/DC8EJVtGXLFrz66quQy+Xw8PDA1q1bERQUJHZZRFqneHrpnyuJOHw1EVGxqSqPO1mZopenA/pweonKwfDC8ELVcOrUKYSEhODu3bswMDDA3LlzMW/ePBgZGYldGpHWqmh6ydTIAF2a26O3pyN6c3qJijC8MLxQNaWlpeHtt9/GTz/9BADo0KEDtm7diubNm4tcGZH2Kzm99M+VRDwsY3qpV2sH9PF05PSSHmN4YXihGtqxYwfeeustpKWl4b333lP2hyEi9RAEAVfiM3DkSkKF00u9Wzugc3NOL+kThheGF6qF+/fv4/PPP8eqVatgZmYmdjlEOi0xIxfHribh8JUEnKxgeqlXawc4cnpJpzG8MLyQGslkMoSEhGDixIno06eP2OUQ6azi6aV/inrKPDu95ONqjd6enF7SVQwvDC+kRuvWrcOUKVMAADNmzMCXX34JExMTkasi0m0lp5eOXE1EVFwqSn63crQyQa/WjujjyeklXcHwwvBCapSdnY33338f3377LQDA19cX27dvx/PPPy9yZUT6Iykjr2j3UgJO3UxGdr7q9FLnZkW7lzw5vaStGF4YXqgO7N27F6+99hqSkpJgamqKxYsXY9q0aRy6JqpnuQUynL2dojyyoLzppd6tHeHtyuklbcHwwvBCdeTRo0d49dVXceDAAQDAO++8g5UrV4pcFZH+EgQBVx8V7V66UvH0UlAze5gZc3pJUzG8MLxQHRIEAaGhofj4449x4sQJ+Pr6il0SERVJysjD0WuKEZmTNzi9pE0YXhheqB6kp6er/B07cOAAunXrBnNzcxGrIqJilU0vebtaoXdrR/Tx5PSSJmB4YXihehYWFoagoCA0a9YM27ZtQ0BAgNglEVEJVZteUqyT6dyc00ti0MvwEhoaitDQUMhkMly/fp3hherVyZMn8b///Q8PHz6EoaEhPv/8c3zwwQeQSvkPIJEmqmh6ycRQtTmekzWnl+qDXoaXYhx5IbGkpKTgzTffxG+//QYA6N69O7Zs2YLGjRuLXBkRVSSvUIaztx8respcScSD1ByVx4unl3p7OsDbxRoGBpxeqgsMLwwvJBJBELB582a88847yMzMhLW1NdavX4+XXnpJ7NKIqAoEQcC1hAwcuaLoKRMZqzq95GBpotyGzekl9WJ4YXghkd26dQvBwcE4d+4cVq5ciXfeeUfskoioBpIz8/DP1UT8cyURJ24klZpe6tzcXhlmOL1UOwwvDC+kAQoKCrB9+3aEhITAwMAAAJCbmwtTU/4DR6SNKpteet7FCr09FT1lOL1UfQwvDC+kgTIyMtCuXTu89NJLmD9/PoyMjMQuiYhqqKrTS71aO6ILp5eqhOGF4YU00KZNmzBx4kQAQPv27bF161a0aNFC5KqISB2SMxVnLx25koiTN5KQVc70Uq/WDnC2NhOxUs3F8MLwQhrq//7v//Dmm28iNTUVDRo0wMqVKzFx4kQ2xyLSIXmFMpwrml46zOmlKmN4YXghDRYbG4tx48bh2LFjAIDhw4djw4YNsLOzE7cwIlK7ktNLR64kIKKM6aVerR3Q25PTSwwvDC+k4WQyGb755ht8/PHHKCgowPjx47F582axyyKiOlbZ9FJQMzvl2Uv6Nr3E8MLwQlriwoULeO+99/B///d/cHR0FLscIqpHVZ1e6t3aAT6uuj+9xPDC8EJa7PPPP8fw4cPh7e0tdilEVE8EQcD1hEwcvpJQ5vRSI0sT9G6tWPDbpYU9zI0NxSu2jjC8MLyQlvrtt98watQomJiYYPHixXj77be5mJdID6Vk5uHotSQcuZKAE9f1Y3qJ4YXhhbRUQkICJk6ciP379wMA+vfvj02bNsHZ2VnkyohILMXTS/9cVfSUiXuiOr3k5WyFPp6KRb/aPL3E8MLwQlpMEASsXbsWM2fORG5uLuzt7bFx40YMHTpU7NKISGQlp5f+uZqIC/eflJpe6tXKAb09tW96ieGF4YV0QExMDIKDgxEZGQkAmDNnDr788ktxiyIijVLR9JKxoQE6N7NDr6JFvy42mj29xPDC8EI6Ii8vDx9//DGWLVuGP//8EwMHDhS7JCLSUHmFMvx357HyyILyppd6eTrCVwOnlxheGF5Ix9y4cUPlKIHLly+jdevWkEr1t6EVEZVPEATcSCzevaQd00sMLwwvpMPu378PX19f+Pn5YcuWLWjSpInYJRGRhkvJzMOxa0k4cjUBJ64nIzOvUPmYccndS5VML8nkAv678xiJGblwsDRFew9bSNU0gsPwwvBCOuzAgQMYPXo0MjMzYW1tjXXr1mHMmDFil0VEWiK/UI5zd1LKnV7yLLF7qeT00oFL8ViwNwbxabnKe52tTfHJEC8M8K79jkiGF4YX0nG3bt3CK6+8grNnzwIAgoODERoaCmtra5ErIyJtUtn0kr2FCXq1boSGDYyx/vhtPBsYisdc1r3iX+sAw/DC8EJ6oLCwEF988QU+++wzyOVyNGnSBFu3bkWXLl3ELo2ItNTjrHzF2UtlTC+VRwLAydoUp2b3qtUUUnW+fxvU+FWISFSGhob45JNPcOrUKTz33HO4d+8edu7cKXZZRKTFbBsYY2SAG9YGB+DCvL7Y+loH9H++4nPXBADxabn4787j+ikSOhReQkND4eXlhcDAQLFLIapXnTp1QmRkJObOnYuvvvpKeV3HBlWJqJ4ZGxqgSwt7DPKp2nRQYkZu5Tepic6El6lTpyImJgZhYWFil0JU7ywtLbFw4UKYmpoCAGQyGQYNGoQNGzYwxBBRrThYmqr1PnXQmfBCRE9t374dBw4cwBtvvIERI0YgOTlZ7JKISEu197CFs7UpylvNIoFi11F7D9t6q4nhhUgHBQcHY8mSJTAyMsLu3bvh6+uLgwcPil0WEWkhqYEEnwzxAoBSAab480+GeKmt30tVMLwQ6SADAwPMnDkT586dg6enJ+Lj49G/f3+89957yM2tv3lpItINA7ydse4VfzhZq04NOVmbqmWbdHVxqzSRjsvOzsasWbMQGhoKABgzZgy2b98uclVEpI3YYbeOMLwQlW3fvn2YOnUq9u3bh+eff17scoiIVLDPCxGV8sILL+DGjRsqwWXHjh14+PChiFUREVUfwwuRHjEyMlL+/ty5c3jllVfg6+uL3bt3i1cUEVE1MbwQ6Slra2v4+voiJSUFw4cPx6RJk5CZmSl2WURElWJ4IdJTrVu3xtmzZzFr1ixIJBJs3LgR/v7+bPRIRBqP4YVIjxkbG+Prr7/GkSNH4Obmhhs3biAoKAhLly4VuzQionIxvBARevbsiejoaLz00ksoLCyEmZmZ2CUREZWLW6WJSEkQBBw6dAh9+/aFRKLo3ZCSkgI7OzuRKyMiXcet0kRUIxKJBP369VMGl/T0dAQGBmLs2LFITU0VtzgioiIML0RUrmPHjuH+/fv4+eef4efnhxMnTohdEhERwwsRle/FF1/EqVOn0KxZM9y/fx89evTARx99hPz8fLFLIyI9xvBCRBXq2LEjIiIi8Oqrr0IQBCxatAhBQUG4du2a2KURkZ5ieCGiSllaWuKHH37Azp070bBhQ4SHh2P+/Plil0VEeorhhYiqbOTIkbh48SL+97//YfXq1WKXQ0R6iuGFiKrF1dUVP//8MxwcHJTXZsyYgQMHDohYFRHpE4YXIqqV3bt3Y/ny5Rg4cCDeffdd5Obmil0SEek4hhciqpX+/ftj2rRpAIBVq1YhMDAQFy9eFLkqItJlDC9EVCtmZmZYvXo19u/fD0dHR1y6dAnt2rXD8uXLIZfLxS6PiHQQwwsRqcXAgQMRHR2NIUOGID8/HzNmzMCECRPELouIdBDDCxGpjYODA/bs2YN169bB3NwcwcHBYpdERDqIBzMSUZ1ISkpCo0aNlJ+fOXMGPj4+sLCwELEqItJUPJiRiERXMrjcvXsXAwYMQNu2bfHff/+JWBUR6QKGFyKqc0lJSbC2tsbNmzcRFBSEhQsXQiaTiV0WEWkphhciqnOBgYGIiorCyy+/DJlMhnnz5qF79+64c+eO2KURkRZieCGietGwYUP8/PPP2LJlCywtLfHvv//Cz88PW7duFbs0ItIyDC9EVG8kEglCQkIQFRWFzp07IyMjAxcuXBC7LCLSMoZiF0BE+sfDwwPHjh3D+vXrMXHiROX1wsJCGBrynyUiqhhHXohIFIaGhpgyZQpMTU0BKIJLz549MWfOHOTn54tcHRFpMo0LLxkZGQgMDESbNm3g4+ODDRs2iF0SEdWDv/76C6dOncJXX32FTp064dq1a2KXREQaSuOa1MlkMuTl5cHc3BzZ2dnw9vZGWFgY7OzsqvTn2aSOSHv9/vvvmDRpEh4/fgwzMzMsW7YMb775JiQSidilEVEd0+omdVKpFObm5gCA3NxcyGQyaFi+IqI6MmLECERHR6NPnz7IycnB5MmTMXToUCQlJYldGhFpkGqHlxMnTmDIkCFwcXGBRCLB7t27S92zdu1aeHh4wNTUFAEBATh58mS1XiM1NRV+fn5wc3PDrFmzYG9vX90yiUhLubq64u+//8ayZctgbGyMvXv3IiQkROyyiEiDVDu8ZGVlwc/PD2vWrCnz8V9++QXTp0/H3LlzERERga5du2LgwIG4f/++8p6AgAB4e3uX+nj48CEAwMbGBlFRUbhz5w62b9+OhISEGr49ItJGBgYGeO+99/Dff/+hXbt2WLZsmdglEZEGqdWaF4lEgl27dmHYsGHKax06dIC/vz/WrVunvObp6Ylhw4Zh0aJF1X6NyZMno1evXhg9enSZj+fl5SEvL0/5eXp6Otzd3bnmhUhHCIKgsuZl/fr16NChA/z8/ESsiojUTbQ1L/n5+QgPD0e/fv1Urvfr1w+nT5+u0nMkJCQgPT0dgOKNnDhxAq1atSr3/kWLFsHa2lr54e7uXvM3QEQap2RwOXPmDCZPnoz27dtj2bJlkMvlIlZGRGJRa3hJTk6GTCaDo6OjynVHR0c8evSoSs8RFxeHbt26wc/PD126dMG0adPg6+tb7v1z5sxBWlqa8iM2NrZW74GINFfz5s0xePBg5Ofn4/3330f//v3x4MEDscsionpWJ60sn93W+Oywb0UCAgIQGRlZ5dcyMTGBiYlJdcojIi3VqFEj7N69G+vXr8d7772Hw4cPw9fXF+vXr8fIkSPFLo+I6olaR17s7e0hlUpLjbIkJiaWGo0hIqoJiUSCN998ExEREQgICMDjx48xatQoTJs2TezSiKieqDW8GBsbIyAgAIcOHVK5fujQIQQFBanzpYhIz7Vq1QqnT5/GnDlzIJFI4O3tLXZJRFRPqj1tlJmZiZs3byo/v3PnDiIjI2Fra4vGjRtjxowZCAkJQbt27dCpUyesX78e9+/fx1tvvaXWwomIjI2N8eWXX+Lll19WWRt39+5duLm58ZBHIh1V7f+zz58/j549eyo/nzFjBgBg/Pjx2Lx5M15++WWkpKTgs88+Q3x8PLy9vbF//340adJEfVWXITQ0FKGhoZDJZHX6OkSkeUpum05LS0OPHj3g6uqKrVu3wsPDQ8TKiKguaNzZRrXFs42I9NupU6fwwgsvID09HZaWllizZg1CQkJ4PhKRhtPqs42IiGqjS5cuiIqKQpcuXZCRkYHx48djzJgxePLkidilEZGaMLwQkc5p2rQpjh07hoULF0IqleKXX36Bn58fjh07JnZpRKQGDC9EpJOkUinmzp2L06dPo3nz5oiNjcWqVavELouI1IDhhYh0Wvv27REREYEZM2Zg/fr1YpdDRGqgM+ElNDQUXl5eCAwMFLsUItIwFhYW+Oabb2Bvb6+8NmnSJKxbtw46tmeBSC9wtxER6Z2DBw+if//+AIDBgwfj+++/h4ODg8hVEek37jYiIqpAnz59sHz5chgbG+PPP/+Ej48P9u/fL3ZZRFRFDC9EpHcMDAwwffp0hIWFwdvbG4mJiXjhhRcwbdo05OTkiF0eEVWC4YWI9Javry/CwsLw7rvvAlCsnRs6dKjIVRFRZRheiEivmZqaYsWKFThw4ABcXFwwa9YssUsiokrw1DIiIgD9+/fHzZs3YWZmprx28OBBeHl5wc3NTcTKiOhZHHkhIipSMrjcuXMHo0aNgq+vL3bu3CliVUT0LJ0JL+zzQkTqJJfL0apVKzx58gSjR4/Gq6++ioyMDLHLIiKwzwsRUbkKCgqwYMECfPnllxAEAc899xy2bduGjh07il0akc5hnxciIjUwMjLCwoULcfz4cTRu3Bi3b99Gly5d8Pnnn4tdGpFeY3ghIqpE165dERUVhbFjx0ImkyE9PV3skoj0GncbERFVgY2NDbZt24aXXnoJAwYMUF7PyMiAhYUFJBKJiNUR6ReOvBARVcPQoUNhYmICACgsLES/fv3w8ssv4/HjxyJXRqQ/GF6IiGrozJkzOH/+PH799Vf4+vri6NGjYpdEpBcYXoiIaqhr1644ffo0WrRogQcPHqB3796YNWsW8vLyxC6NSKcxvBAR1UJgYCAiIiLwxhtvQBAELFmyBB07dsSVK1fELo1IZ+lMeGGTOiISS4MGDfDdd99h9+7dsLOzQ2RkpDLMEJH6sUkdEZEaxcfHY8qUKVi0aBFat24tdjlEWoNN6oiIROLs7Ixdu3apBJelS5di3759IlZFpFsYXoiI6tC5c+cwe/ZsDB48GFOnTkV2drbYJRFpPYYXIqI65Ofnh3fffRcAsHbtWgQEBCAiIkLkqoi0G8MLEVEdMjU1xbJly/D333/D2dkZV69eRYcOHbBkyRLI5XKxyyPSSgwvRET1oF+/foiOjsbw4cNRUFCAWbNmYejQodyRRFQDDC9ERPXE3t4ev/32GzZs2ABzc3MMGTKEZyIR1QC3ShMRiSAuLg6urq7K8HLp0iU0adIElpaWIldGJA5ulSYi0nBubm7K4JKamopBgwahTZs2OHPmjMiVEWk+nQkv7LBLRNoqLi4OBgYGuH37Nrp27YpPP/0UhYWFYpdFpLE4bUREpAHS0tIwbdo0bN26FQDQsWNHbN26Fc2aNRO5MqL6wWkjIiItY21tjZ9++gk///wzrK2tcfbsWbRp0wabNm3ijiSiZzC8EBFpkP/973+Ijo5G9+7dkZmZiT///FPskog0jqHYBRARkarGjRvjyJEjWL16NUJCQpQLe+VyOQwM+DMnEf8vICLSQFKpFNOnT4ednR0AQBAEBAcHY+bMmcjLyxO5OiJxceSFiEgLnDt3Djt27AAAHD58GNu3b4eXl5fIVRGJgyMvRERaoGPHjtizZw/s7e0RFRWFgIAArFmzhot5SS8xvBARaYkXX3wRFy9exIABA5Cbm4u3334bgwcPRkJCgtilEdUrhhciIi3i5OSE/fv3Y9WqVTAxMcH+/fsxcOBAjsCQXmF4ISLSMhKJBG+//TbOnz+PNm3aYOnSpTzgkfQKF+wSEWkpb29vhIeHq2yf3rVrF5o0aQJ/f38RKyOqWxx5ISLSYiWDy61btzBu3Dh07NgRixcvhkwmE7EyorqjM+GFBzMSkb6zsbFBv379UFBQgNmzZ6NPnz6IjY0VuywitePBjEREOkQQBGzatAnvvPMOsrKyYGNjg2+//RYvv/yy2KURVYgHMxIR6SmJRIKJEyciMjIS7du3R2pqKv73v/9hwoQJ3JFEOoPhhYhIBzVv3hynTp3CvHnzYGBgAGdnZ+5IIp3BaSMiIh0XFhYGPz8/GBsbAwASEhJga2sLIyMjkSsjeorTRkREpBQYGKgMLgUFBRgyZAi6du2KmzdvilwZUc0wvBAR6ZErV67gxo0bOHfuHNq0aYMffviBa2FI6zC8EBHpEV9fX0RHR6N79+7IysrCa6+9hlGjRiElJUXs0oiqjOGFiEjPuLu748iRI/jqq69gaGiI33//Hb6+vjh8+LDYpRFVCcMLEZEekkqlmD17Ns6ePYtWrVrh4cOH+OijjyCXy8UujahSDC9ERHosICAAFy5cwNtvv42tW7eqHDdApKm4VZqIiEr57LPP0LBhQ0ybNo39YaheVOf7N0+VJiIiFVFRUfj0008hCAL279+PTZs2wcnJSeyyiJQ4PkhERCp8fX2xatUqmJqa4sCBA/Dx8cHevXvFLotIieGFiIhUSCQSTJs2DefPn4efnx+Sk5Px4osv4q233kJWVpbY5RExvBARUdmef/55nDt3DjNnzgQAfPfdd+jevTt3JJHodCa8hIaGwsvLC4GBgWKXQkSkM0xMTLBkyRIcPnwYrq6umDJlCnckkei424iIiKokPT0dlpaWyt1HYWFhcHR0ROPGjUWujHQBD2YkIiK1s7KyUgaXJ0+eYMSIEfD19cXPP/8scmWkbxheiIio2jIzM+Hq6oq0tDSMHTsWISEhSEtLE7ss0hMML0REVG3u7u44efIk5s+fDwMDA2zduhV+fn44deqU2KWRHmB4ISKiGjEyMsKCBQtw8uRJeHh44N69e+jevTvmzZvHHUlUpxheiIioVoKCghAZGYlx48ZBLpfj2rVrPFKA6hSPByAiolqzsrLCjz/+iKFDh6JHjx7K8JKbmwsTExOGGVIrjrwQEZHajBgxAra2tgAAQRAQEhKCkSNHIiUlReTKSJcwvBARUZ2IiYnBnj17sGvXLvj4+ODQoUNil0Q6guGFiIjqRPHxAp6enoiPj0e/fv0wY8YM5Obmil0aaTmGFyIiqjNt27bF+fPnMWXKFADA8uXL0b59e1y6dEnkykibMbwQEVGdMjc3R2hoKP788084ODjg4sWLGDFiBGQymdilkZZieCEionrxwgsvIDo6GkOGDMGGDRsglUrFLom0FLdKExFRvXF0dMQff/yhcm3btm1o0KABhg0bJk5RpHU48kJERKK5desW3njjDQwfPhxvvPEGsrKyxC6JtADDCxERicbNzU25mHfDhg3w9/fH+fPnRa6KNB3DCxERicbExARLlizBkSNH4OrqiuvXr6NTp05YtGgRF/RSuRheiIhIdL169UJ0dDRGjx6NwsJCfPTRR+jbty8KCwvFLo00EMMLERFpBFtbW/zyyy/YvHkzLCws0KlTJxgacl8JlSYRBEEQuwh1Sk9Ph7W1NdLS0mBlZSV2OUREVAN3796Fq6srjIyMAAD37t2DjY0NrK2tRa6M6kp1vn9z5IWIiDRO06ZNlcElPz8fI0eOhJ+fH06ePClyZaQJGF6IiEijxcXF4cmTJ7h37x569OiBuXPnoqCgQOyySEQ6E15CQ0Ph5eWFwMBAsUshIiI1eu655xAZGYkJEyZALpfjyy+/ROfOnXH9+nWxSyORcM0LERFpjZ07d+KNN97AkydPYG5ujhUrVuD111+HRCIRuzSqJa55ISIinTRq1ChER0ejV69eyM7OxsaNG9kPRg9xDxoREWkVNzc3HDp0CCtWrMCLL76o3E4tCAJHYPQEwwsREWkdAwMDzJgxQ+XanDlzkJubi6+++gqmpqYiVUb1geGFiIi03s2bN7FkyRLI5XIcOXIE27dvh4+Pj9hlUR3R2/Aik8m41a6GjIyMIJVKxS6DiEipefPm+OOPPzBx4kRcunQJgYGB+Oqrr/DOO+/AwIDLO3WN3u02EgQBjx49Qmpqav0Xp0NsbGzg5OTE+WUi0iiJiYmYOHEi9u3bBwDo27cvNm/eDBcXF5Ero8pUZ7eR3oWX+Ph4pKamwsHBAebm5vzmW02CICA7OxuJiYmwsbGBs7Oz2CUREakQBAHffvst3n//feTk5MDDwwPXrl1TduwlzVSd8KJX00YymUwZXOzs7MQuR2uZmZkBUPyE4+DgwCkkItIoEokEkydPRo8ePRAcHIx33nmHwUXH6FV4KV7jYm5uLnIl2q/4a1hQUMDwQkQaydPTE+fOnVM5mfrkyZMwNTVlN3Ytp5ermDhVVHv8GhKRNjAyMlL+e5WSkoIxY8YgKCgIX3zxBZvbaTG9DC9ERKR/pFIpOnfujMLCQnz88cfo0aMH7t69K3ZZVAMML0REpBdsbGywY8cO/Pjjj7C0tMSpU6fg5+eHbdu2iV0aVRPDSw3J5ALO3ErBnsgHOHMrBTK59mzaatq0KVasWCF2GURE9U4ikWDcuHGIiopCUFAQ0tPT8corr2Ds2LHIz88XuzyqIr1asKsuBy7FY8HeGMSn5SqvOVub4pMhXhjgXTdbh3v06IE2bdqoJXSEhYWhQYMGtS+KiEhLeXh44Pjx41i0aBEWLFgAuVzOHUlahCMv1XTgUjwmb72gElwA4FFaLiZvvYADl+JFqUsQBBQWFlbp3kaNGnHHFRHpPUNDQ8ybNw+nT5/GunXrlAt709LSOAqj4fQ+vAiCgOz8wip9ZOQW4JM/LqOsCaLia5/+EYOM3IIqPV9V+wNOmDABx48fx8qVKyGRSCCRSLB582ZIJBL8/fffaNeuHUxMTHDy5EncunULQ4cOhaOjIywsLBAYGIjDhw+rPN+z00YSiQQbN27E8OHDYW5ujhYtWuCPP/6o2ReUiEjLtG/fHg0bNgSg+J4wYcIEBAUF4dq1ayJXRuXR+2mjnAIZvOb/rZbnEgA8Ss+Fz6cHq3R/zGf9YW5c+X+ClStX4vr16/D29sZnn30GALh8+TIAYNasWVi6dCmee+452NjYIC4uDoMGDcLChQthamqKH3/8EUOGDMG1a9fQuHHjcl9jwYIFWLx4MZYsWYLVq1cjODgY9+7dg62tbZXeCxGRLrh37x6OHz+OJ0+ewN/fH8uXL8ekSZPYHkLD6P3IizawtraGsbExzM3N4eTkBCcnJ2VjuM8++wx9+/ZFs2bNYGdnBz8/P7z55pvw8fFBixYtsHDhQjz33HOVjqRMmDABY8aMQfPmzfHll18iKysL//33X328PSIijdG0aVNER0ejV69eyM7Oxptvvonhw4cjKSlJ7NKoBL0feTEzkiLms/5Vuve/O48xYVNYpfdtfjUQ7T0qH7EwM6p9Z9p27dqpfJ6VlYUFCxbgzz//xMOHD1FYWIicnBzcv3+/wufx9fVV/r5BgwawtLREYmJiresjItI2bm5uOHToEJYvX46PPvoIe/bswblz57Bp0yYMGDBA7PIIDC+QSCRVmroBgK4tGsHZ2hSP0nLLXPciAeBkbYquLRpBalA/Q4zP7hr64IMP8Pfff2Pp0qVo3rw5zMzMMGrUqEoXnz27yl4ikUAul6u9XiIibWBgYID3338fffr0wdixYxETE4PJkyfj6tWrMDExEbs8vcdpo2qQGkjwyRAvAIqgUlLx558M8aqT4GJsbFylVtYnT57EhAkTMHz4cPj4+MDJyYkdJImIasjPzw/nz5/H22+/jS1btjC4aAiGl2oa4O2Mda/4w8naVOW6k7Up1r3iX2d9Xpo2bYpz587h7t27SE5OLndUpHnz5vj9998RGRmJqKgojB07liMoRES1YGZmhlWrVqFr167Kaz/88AOWL1/Of19FovfTRjUxwNsZfb2c8N+dx0jMyIWDpSnae9jW6VTRzJkzMX78eHh5eSEnJwebNm0q877ly5dj4sSJCAoKgr29PWbPno309PQ6q4uISN/cv38f06ZNQ05ODvbv348ff/wRLi4uYpelVyRCVZuNaIn09HRYW1sjLS0NVlZWKo/l5ubizp078PDwgKmpaTnPQFXBryUR6StBELB+/Xq89957yMnJga2tLTZs2IARI0aIXZpWq+j797M4bURERFQNEokEb775Ji5cuAB/f388fvwYI0eOxOuvv47MzEyxy9MLDC9EREQ10Lp1a5w5cwYffvghJBIJvv/+e7Rr1w65ubmV/2GqFYYXIiKiGjI2NsaiRYtw9OhRuLu74+WXX+ZUej3ggl0iIqJa6t69O6Kjo1V6b924cQOGhobw8PAQsTLdxJEXIiIiNbCxsVE2/MzPz8fLL78MPz8//PTTT1U+iJeqhuGFiIhIzVJTU2Fubo6MjAyMGzcOY8eORWpqqthl6QyGFyIiIjVzcHDAsWPH8Pnnn0MqlWLHjh3w9fXF8ePHxS5NJzC8EBER1QFDQ0N8/PHH+Pfff9GsWTPExsaiZ8+emDNnDgoKCsQuT6tpbHjJzs5GkyZNMHPmTLFLISIiqrEOHTogMjISr732GgRBwPHjxyGR1M/hvbpKY3cbffHFF+jQoYPYZZRPLgPunQYyEwALR6BJEGAgFbsqIiLSQBYWFti4cSMGDRoEPz8/GBoqvv0WFhZCKpUyzFSTRo683LhxA1evXsWgQYPELqVsMX8AK7yBHwcDv72m+HWFt+J6HenRowemT5+utuebMGEChg0bprbnIyKiyo0YMQLNmjVTfj5nzhwMHToUSUlJIlalfaodXk6cOIEhQ4bAxcUFEokEu3fvLnXP2rVrlWfeBAQE4OTJk9V6jZkzZ2LRokXVLa1+xPwB/N84IP2h6vX0eMX1OgwwRESkOx4+fIg1a9Zg79698PHxwV9//SV2SVqj2uElKysLfn5+WLNmTZmP//LLL5g+fTrmzp2LiIgIdO3aFQMHDsT9+/eV9wQEBMDb27vUx8OHD7Fnzx60bNkSLVu2rFI9eXl5SE9PV/moFkEA8rOq9pGbDvw1C0BZ+/WLrh2YrbivKs9XxX3/EyZMwPHjx7Fy5UpIJBJIJBLcvXsXMTExGDRoECwsLODo6IiQkBAkJycr/9zOnTvh4+MDMzMz2NnZoU+fPsjKysKnn36KH3/8EXv27FE+37Fjx6r3dSMiolpxcXHBuXPn4O3tjYSEBAwaNAhvv/02cnJyxC5N49XqVGmJRIJdu3apTD906NAB/v7+WLdunfKap6cnhg0bVqXRlDlz5mDr1q2QSqXIzMxEQUEB3n//fcyfP7/M+z/99FMsWLCg1PUqnyqdnwV8KdJR5h89BIwbVHpbWloaBg4cCG9vb3z22WcAAJlMhjZt2mDSpEkYN24ccnJyMHv2bBQWFuKff/5BfHw8GjdujMWLF2P48OHIyMjAyZMnMW7cOADAa6+9hvT0dGzatAkAYGtrC2Nj4yqXzlOliYjUIzc3Fx9++CFWrlwJAPDy8sL27dvh5+cncmX1qzqnSqt1wW5+fj7Cw8Px4Ycfqlzv168fTp8+XaXnWLRokTLkbN68GZcuXSo3uACKsDNjxgzl5+np6XB3d69B9ZrL2toaxsbGMDc3h5OTEwBg/vz58Pf3x5dffqm874cffoC7uzuuX7+OzMxMFBYWYsSIEWjSpAkAwMfHR3mvmZkZ8vLylM9HRETiMDU1xYoVKzBw4EBMmDABMTEx6Nu3L+7evQtzc3Oxy9NIag0vycnJkMlkcHR0VLnu6OiIR48eqfOllExMTGBiYlLzJzAyV4yAVMW908C2UZXfF7xTsfuoKq9dQ+Hh4Th69CgsLCxKPXbr1i3069cPvXv3ho+PD/r3749+/fph1KhRaNiwYY1fk4iI6k7//v0RHR2NSZMmYdSoUQwuFaiTrdLPbvkSBKFG28AmTJigpooqIJFUaeoGANCsF2DlolicW+a6F4ni8Wa96nzbtFwux5AhQ/D111+XeszZ2RlSqRSHDh3C6dOncfDgQaxevRpz587FuXPneEgYEZGGatSoEXbt2qVy7ciRI3jy5AlGjarCD896Qq1bpe3t7SGVSkuNsiQmJpYajdFKBlJgQHFYeDaMFX0+4Ks6CS7GxsaQyWTKz/39/XH58mU0bdoUzZs3V/koPtVUIpGgc+fOWLBgASIiImBsbKz8n+LZ5yMiIs1QvJECAFJSUhASEoLRo0dj4sSJyMjIELk6zaDW8GJsbIyAgAAcOnRI5fqhQ4cQFFSFaRRt4PUi8NIWwMpZ9bqVi+K614t18rJNmzbFuXPncPfuXSQnJ2Pq1Kl4/PgxxowZg//++w+3b9/GwYMHMXHiRMhkMpw7dw5ffvklzp8/j/v37+P3339HUlISPD09lc8XHR2Na9euITk5ma2qiYg0kKWlJSZMmACJRIJNmzahbdu2OHv2rNhliU+opoyMDCEiIkKIiIgQAAjLli0TIiIihHv37gmCIAg7duwQjIyMhO+//16IiYkRpk+fLjRo0EC4e/dudV+qWtasWSN4enoKLVu2FAAIaWlppe7JyckRYmJihJycnNq/oKxQEG6fEIToXxW/ygpr/5wVuHbtmtCxY0fBzMxMACDcuXNHuH79ujB8+HDBxsZGMDMzE1q3bi1Mnz5dkMvlQkxMjNC/f3+hUaNGgomJidCyZUth9erVyudLTEwU+vbtK1hYWAgAhKNHj1arHrV+LYmIqELHjh0T3N3dBQCCVCoVFixYIBQUFIhdllqlpaWV+/37WdXeKn3s2DH07Nmz1PXx48dj8+bNABRN6hYvXoz4+Hh4e3tj+fLl6NatWy1jVtVUtNWK23vVh19LIqL6lZqaiilTpuDnn38GAAQFBeHgwYPKpQLark63Svfo0QOV5Z0pU6ZgypQp1X1qIiIiKoeNjQ22b9+OF154AVOmTEHTpk11JrhUl8YezEhERESlBQcHo3PnzrCxsVFeS0lJgYGBgd60w9DIgxmJiIiofE2bNlWGF0EQMHHiRPj6+uLo0aPiFlZPGF6IiIi0WFJSEq5cuYK4uDj07t0bs2fPRn5+vthl1SmGFyIiIi3m4OCACxcu4PXXX4cgCFi8eDE6duyIK1euiF1andGZ8BIaGgovLy8EBgaKXQoREVG9srCwwIYNG/D777/Dzs4OERERCAgIwNq1ayvdZKONdCa8TJ06FTExMQgLCxO7FCIiIlEMHz4c0dHR6NevH3JycrB06VJkZWWJXZbacbcRERGRDnFxccFff/2F1atXo127dmUe4KvtGF6IiIh0jIGBAd59912Va+vWrcPly5exZMkSmJmZiVSZeujMtBERERGVLSkpCTNnzkRoaCgCAgIQGRkpdkm1wvCix7Kzs9GkSRPMnDlT7FKIiKgONWrUCL///jucnJxw5coVtG/fHkuXLoVcLhe7tBpheNFjX3zxBTp06CB2GUREVA/69++PixcvYujQoSgoKMAHH3yAvn37Ii4uTuzSqk1nwgu3SlfPjRs3cPXqVQwaNEjsUoiIqJ7Y29tj165dWL9+PczNzfHPP//A398f6enpYpdWLToTXvRlq3S3bt0gkUiUp4oWW7t2LRwcHKr8PDNnzsSiRYvUXR4REWk4iUSCSZMmISIiAu3atcPUqVMrPcVZ03C3kRYRBAGRkZFwdnbGb7/9hjFjxigfu3DhAvz9/ZWfBwQEIC8vr9RzHDx4EGFhYWjZsiVatmyJ06dP10vtRESkWYq/B0gkEuW1mJgYpKWloVOnTiJWVjmGFy1y48YNZGRk4KuvvsIHH3yA7OxsmJubAwDCw8NVpoDCw8PLfZ6zZ89ix44d+PXXX5GZmYmCggJYWVlh/vz5df4eiIhIcxgZGSl/n5eXhzFjxuDy5cuYN28e5s6dC0NDzYwJOjNtVFtZWVnlfuTm5lb53pycnCrdWxPh4eEwNTXF66+/DisrK/z1118AFH/hLl++rDLyUpFFixYhNjYWd+/exdKlSzFp0iQGFyIiPZefnw8fHx/IZDJ8+umn6NatG27fvi12WWVieCliYWFR7sfIkSNV7nVwcCj33oEDB6rc27Rp0zLvq4kLFy7A19cXxsbGGD58OHbu3AkAiI6ORkFBAQICAmr25omISO9ZWlpi69at2LZtG6ysrHDmzBn4+flh8+bNGnc+EsOLFgkPD1eOrowYMQL79u1DXl4ewsPDYWtri6ZNm1b7OSdMmIClS5equVIiItJWY8eORXR0NLp27YrMzEy8+uqreOmll5CZmSl2aUqaOZklgor+o0ilUpXPExMTy73XwEA1D969e7dWdZUUERGBsWPHAgB69OgBY2Nj/P3337hw4QLatm2rttchIiL91qRJExw9ehSLFy/G/PnzER8fr1FHCjC8FGnQoIHo91bk9u3bSE1NVY68GBoaYsiQIfjtt99w6dIl9OnTRy2vQ0REBCh+cJ8zZw769u0LOzs75Q/yxTtZTUxMRKtNZ6aNdL1JXXh4OIyNjeHt7a28NnLkSPzxxx+4dOlSlRfrEhERVUe7du3g4eGh/HzNmjWiTyHpTHjR9SZ1Fy5cgLe3N4yNjZXX+vbtC5lMhvz8fIYXIiKqc0+ePEFAQADs7OxErUMiaNoS4lpKT0+HtbU10tLSSnUMzM3NxZ07d+Dh4QFTU1ORKtQN/FoSEZE6VfT9+1k6M/JCRERE+oHhhYiIiLQKwwsRERFpFYYXIiIi0ioML0RERKRV9DK86NgGK1Hwa0hERGLRq/BSfPR3dna2yJVov+KvYcnj1ImIiOqDXh0PIJVKYWNjozybyNzcHBKJROSqtIsgCMjOzkZiYiJsbGxKnftERERU13QmvISGhiI0NBQymazC+5ycnABUfLgiVc7Gxkb5tSQiIqpPetVhtySZTIaCgoJ6rEx3GBkZccSFiIjUqjoddnVm5KW6pFIpvwETERFpIb1asEtERETaj+GFiIiItArDCxEREWkVnVvzUrz+OD09XeRKiIiIqKqKv29XZR+RzoWXjIwMAIC7u7vIlRAREVF1ZWRkwNrausJ7dG6rtFwux8OHD2FpackGdGoWGBiIsLAwscsQlbZ+DTStbjHqqY/XrIvXUOdz1va50tPT4e7ujtjY2Eq3spLm0bR/B54lCAIyMjLg4uICA4OKV7Xo3MiLgYEB3NzcxC5DJ0mlUr3/B0tbvwaaVrcY9dTHa9bFa6jzOdX1XFZWVhr194mqRtP+HShLZSMuxbhgl6ps6tSpYpcgOm39Gmha3WLUUx+vWRevoc7n1LS/B1S/dOm/v85NGxERUd2oTgdUorrEkRciIqoSExMTfPLJJzAxMRG7FNJzHHkhIiIircKRFyIiItIqDC9ERESkVRheiIiISKswvBAREZFWYXghIiIircLwQkREtZKRkYHAwEC0adMGPj4+2LBhg9glkY7jVmkiIqoVmUyGvLw8mJubIzs7G97e3ggLC4OdnZ3YpZGO4sgLERHVilQqhbm5OQAgNzcXMpkM/LmY6hLDCxGRnjtx4gSGDBkCFxcXSCQS7N69u9Q9a9euhYeHB0xNTREQEICTJ0+qPJ6amgo/Pz+4ublh1qxZsLe3r6fqSR8xvBAR6bmsrCz4+flhzZo1ZT7+yy+/YPr06Zg7dy4iIiLQtWtXDBw4EPfv31feY2Njg6ioKNy5cwfbt29HQkJCfZVPeohrXoiISEkikWDXrl0YNmyY8lqHDh3g7++PdevWKa95enpi2LBhWLRoUannmDx5Mnr16oXRo0fXR8mkhzjyQkRE5crPz0d4eDj69euncr1fv344ffo0ACAhIQHp6ekAFCdPnzhxAq1atar3Wkl/GIpdABERaa7k5GTIZDI4OjqqXHd0dMSjR48AAHFxcXjttdcgCAIEQcC0adPg6+srRrmkJxheiIioUhKJROVzQRCU1wICAhAZGSlCVaSvOG1ERETlsre3h1QqVY6yFEtMTCw1GkNUXxheiIioXMbGxggICMChQ4dUrh86dAhBQUEiVUX6jtNGRER6LjMzEzdv3lR+fufOHURGRsLW1haNGzfGjBkzEBISgnbt2qFTp05Yv3497t+/j7feekvEqkmfcas0EZGeO3bsGHr27Fnq+vjx47F582YAiiZ1ixcvRnx8PLy9vbF8+XJ069atnislUmB4ISIiIq3CNS9ERESkVRheiIiISKswvBAREZFWYXghIiIircLwQkRERFqF4YWIiIi0CsMLERERaRWGFyIiItIqDC9ERESkVRheiIiISKswvBAREZFWYXghIiIirfL/+k0afJi6DFgAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "n_params = np.array(grids) * (4*9+9*1)\n", - "plt.plot(n_params, train_rmse, marker=\"o\")\n", - "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 300*n_params**(-2.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "print(train_rmse)\n", - "print(test_rmse)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5776b6e1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_4_classfication-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_4_classfication-checkpoint.ipynb deleted file mode 100644 index 2887838d6..000000000 --- a/tutorials/.ipynb_checkpoints/Example_4_classfication-checkpoint.ipynb +++ /dev/null @@ -1,504 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 4: Classification" - ] - }, - { - "cell_type": "markdown", - "id": "31bcb9ac", - "metadata": {}, - "source": [ - "## Regression formulation\n", - "\n", - "Let's first treat the problem as a regression problem (output dimension = 1, MSE loss). " - ] - }, - { - "cell_type": "markdown", - "id": "908489de", - "metadata": {}, - "source": [ - "create the two moon dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "763d1fb4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.datasets import make_moons\n", - "import numpy as np\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "\n", - "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label[:,None]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label[:,None]).type(dtype).to(device)\n", - "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:,0].cpu().detach().numpy())" - ] - }, - { - "cell_type": "markdown", - "id": "06649143", - "metadata": {}, - "source": [ - "Train KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.55e-01 | test_loss: 1.56e-01 | reg: 3.94e+00 | : 100%|█| 20/20 [00:01<00:00, 15.55it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "(1.0, 0.9980000257492065)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model = KAN(width=[2,1], grid=3, k=3, device=device)\n", - "\n", - "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).type(dtype))\n", - "\n", - "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).type(dtype))\n", - "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" - ] - }, - { - "cell_type": "markdown", - "id": "2d92afc4", - "metadata": {}, - "source": [ - "Automatic symbolic regression" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ec64a6b4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with sin, r2=0.9654733538627625, c=2\n", - "fixing (0,1,0) with x, r2=0.975755512714386, c=1\n", - "saving model version 0.2\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\displaystyle - 0.853 x_{2} - 0.3885 \\sin{\\left(3.1242 x_{1} - 1.5464 \\right)} + 0.7063$" - ], - "text/plain": [ - "-0.853*x_2 - 0.3885*sin(3.1242*x_1 - 1.5464) + 0.7063" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','tan','abs']\n", - "model.auto_symbolic(lib=lib)\n", - "formula = model.symbolic_formula()[0][0]\n", - "ex_round(formula, 4)" - ] - }, - { - "cell_type": "markdown", - "id": "cee6c7c8", - "metadata": {}, - "source": [ - "How accurate is this formula?" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "dd5226ea", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train acc of the formula: tensor(0.9980, device='cuda:0')\n", - "test acc of the formula: tensor(0.9970, device='cuda:0')\n" - ] - } - ], - "source": [ - "# how accurate is this formula?\n", - "def acc(formula, X, y):\n", - " batch = X.shape[0]\n", - " correct = 0\n", - " for i in range(batch):\n", - " correct += np.round(np.array(formula.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)) == y[i,0]\n", - " return correct/batch\n", - "\n", - "print('train acc of the formula:', acc(formula, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula, dataset['test_input'], dataset['test_label']))" - ] - }, - { - "cell_type": "markdown", - "id": "8a77c90a", - "metadata": {}, - "source": [ - "## Classification formulation\n", - "\n", - "Let's then treat the problem as a classification problem (output dimension = 2, CrossEntropy loss). " - ] - }, - { - "cell_type": "markdown", - "id": "b03f2dd0", - "metadata": {}, - "source": [ - "Create the two moon datatset" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "71c1d738", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import KAN\n", - "import matplotlib.pyplot as plt\n", - "from sklearn.datasets import make_moons\n", - "import torch\n", - "import numpy as np\n", - "\n", - "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label).type(torch.long).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label).type(torch.long).to(device)\n", - "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:].cpu().detach().numpy())" - ] - }, - { - "cell_type": "markdown", - "id": "494fe1d3", - "metadata": {}, - "source": [ - "### Train KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "13ec74e5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 0.00e+00 | test_loss: 2.37e-01 | reg: 4.10e+02 | : 100%|█| 20/20 [00:01<00:00, 18.81it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model = KAN(width=[2,2], grid=3, k=3, seed=2024, device=device)\n", - "\n", - "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).type(dtype))\n", - "\n", - "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).type(dtype))\n", - "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc), loss_fn=torch.nn.CrossEntropyLoss());" - ] - }, - { - "cell_type": "markdown", - "id": "5e36b0f3", - "metadata": {}, - "source": [ - "Automatic symbolic regression" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "91b4c228", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with x, r2=0.48220324516296387, c=1\n", - "fixing (0,0,1) with x, r2=0.3202315866947174, c=1\n", - "fixing (0,1,0) with x, r2=0.9358773231506348, c=1\n", - "fixing (0,1,1) with x, r2=0.9290410876274109, c=1\n", - "saving model version 0.2\n" - ] - } - ], - "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", - "model.auto_symbolic(lib=lib)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "83606957", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle - 15.0316 x_{1} + 177.9349 x_{2} - 63.0716$" - ], - "text/plain": [ - "-15.0316*x_1 + 177.9349*x_2 - 63.0716" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula1, formula2 = model.symbolic_formula()[0]\n", - "ex_round(formula1, 4)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9fa988e3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 60.4718 x_{1} - 156.0295 x_{2} + 16.9$" - ], - "text/plain": [ - "60.4718*x_1 - 156.0295*x_2 + 16.9" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ex_round(formula2, 4)" - ] - }, - { - "cell_type": "markdown", - "id": "0cfce819", - "metadata": {}, - "source": [ - "How accurate is this formula?" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ecd368f8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train acc of the formula: tensor(0.8870, device='cuda:0')\n", - "test acc of the formula: tensor(0.8810, device='cuda:0')\n" - ] - } - ], - "source": [ - "# how accurate is this formula?\n", - "def acc(formula1, formula2, X, y):\n", - " batch = X.shape[0]\n", - " correct = 0\n", - " for i in range(batch):\n", - " logit1 = np.array(formula1.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " logit2 = np.array(formula2.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " correct += (logit2 > logit1) == y[i]\n", - " return correct/batch\n", - "\n", - "print('train acc of the formula:', acc(formula1, formula2, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula1, formula2, dataset['test_input'], dataset['test_label']))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "82b2337e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_5_special_functions-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_5_special_functions-checkpoint.ipynb deleted file mode 100644 index 9894cbf46..000000000 --- a/tutorials/.ipynb_checkpoints/Example_5_special_functions-checkpoint.ipynb +++ /dev/null @@ -1,357 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 5: Special functions" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Let's construct a dataset which contains special functions $f(x,y)={\\rm exp}(J_0(20x)+y^2)$, where $J_0(x)$ is the Bessel function." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.15e-01 | test_loss: 5.86e-01 | reg: 5.84e+00 | : 100%|█| 20/20 [00:03<00:00, 5.89it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=2, device=device)\n", - "f = lambda x: torch.exp(torch.special.bessel_j0(20*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "2f30c3ab", - "metadata": {}, - "source": [ - "Plot trained KAN, the bessel function shows up in the bettom left" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "187d19f9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.54e-02 | test_loss: 4.73e-02 | reg: 7.50e+00 | : 100%|█| 20/20 [00:02<00:00, 6.93it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model = model.refine(20)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8d50bcef", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "733a2a41", - "metadata": {}, - "source": [ - "suggest_symbolic does not return anything that matches with it, since Bessel function isn't included in the default SYMBOLIC_LIB. We want to add Bessel to it." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "031db28f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " function fitting r2 r2 loss complexity complexity loss total loss\n", - "0 0 0.000000 0.000014 0 0 0.000003\n", - "1 x 0.001602 -0.002298 1 1 0.799540\n", - "2 sin 0.161428 -0.253977 2 2 1.549205\n", - "3 cos 0.161428 -0.253977 2 2 1.549205\n", - "4 1/x^2 0.099456 -0.151116 2 2 1.569777\n" - ] - }, - { - "data": { - "text/plain": [ - "('0',\n", - " ((x)>,\n", - " (x)>,\n", - " 0,\n", - " (x, y_th)>),\n", - " 0.0,\n", - " 0)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "4b8549a2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['x', 'x^2', 'x^3', 'x^4', 'x^5', '1/x', '1/x^2', '1/x^3', '1/x^4', '1/x^5', 'sqrt', 'x^0.5', 'x^1.5', '1/sqrt(x)', '1/x^0.5', 'exp', 'log', 'abs', 'sin', 'cos', 'tan', 'tanh', 'sgn', 'arcsin', 'arccos', 'arctan', 'arctanh', '0', 'gaussian'])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "SYMBOLIC_LIB.keys()" - ] - }, - { - "cell_type": "markdown", - "id": "5db9e7cf", - "metadata": {}, - "source": [ - "add bessel function J0 to the symbolic library. we should include a name and a pytorch implementation. c is the complexity assigned to J0." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "cbde1924", - "metadata": {}, - "outputs": [], - "source": [ - "add_symbolic('J0', torch.special.bessel_j0, c=1)" - ] - }, - { - "cell_type": "markdown", - "id": "bda24c6d", - "metadata": {}, - "source": [ - "After adding Bessel, we check suggest_symbolic again" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "83e5cfdd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " function fitting r2 r2 loss complexity complexity loss total loss\n", - "0 0 0.000000 0.000014 0 0 0.000003\n", - "1 J0 0.198505 -0.319216 1 1 0.736157\n", - "2 x 0.001602 -0.002298 1 1 0.799540\n", - "3 sin 0.161428 -0.253977 2 2 1.549205\n", - "4 cos 0.161428 -0.253977 2 2 1.549205\n" - ] - }, - { - "data": { - "text/plain": [ - "('0',\n", - " ((x)>,\n", - " (x)>,\n", - " 0,\n", - " (x, y_th)>),\n", - " 0.0,\n", - " 0)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# J0 fitting is not very good\n", - "model.suggest_symbolic(0,0,0)" - ] - }, - { - "cell_type": "markdown", - "id": "4180de14", - "metadata": {}, - "source": [ - "The fitting r2 is still not high, this is because the ground truth is J0(20x) which involves 20 which is too large. our default search is in (-10,10). so we need to set the search range bigger in order to include 20. now J0 appears at the top of the list\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e78f4674", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " function fitting r2 r2 loss complexity complexity loss total loss\n", - "0 J0 0.998912 -9.830484 1 1 -1.166097\n", - "1 0 0.000000 0.000014 0 0 0.000003\n", - "2 x 0.001602 -0.002298 1 1 0.799540\n", - "3 cos 0.583964 -1.265186 2 2 1.346963\n", - "4 sin 0.583964 -1.265186 2 2 1.346963\n" - ] - }, - { - "data": { - "text/plain": [ - "('J0',\n", - " (,\n", - " J0,\n", - " 1,\n", - " ),\n", - " 0.9989116787910461,\n", - " 1)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.suggest_symbolic(0,0,0,a_range=(-40,40))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_6_PDE_interpretation-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_6_PDE_interpretation-checkpoint.ipynb deleted file mode 100644 index a85aa1188..000000000 --- a/tutorials/.ipynb_checkpoints/Example_6_PDE_interpretation-checkpoint.ipynb +++ /dev/null @@ -1,328 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 6: Solving Partial Differential Equation (PDE)" - ] - }, - { - "cell_type": "markdown", - "id": "7d568912", - "metadata": {}, - "source": [ - "We aim to solve a 2D poisson equation $\\nabla^2 f(x,y) = -2\\pi^2{\\rm sin}(\\pi x){\\rm sin}(\\pi y)$, with boundary condition $f(-1,y)=f(1,y)=f(x,-1)=f(x,1)=0$. The ground truth solution is $f(x,y)={\\rm sin}(\\pi x){\\rm sin}(\\pi y)$." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0e2bc449", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "pde loss: 2.23e+00 | bc loss: 5.99e-03 | l2: 3.78e-03 : 100%|███████| 20/20 [00:22<00:00, 1.11s/it]\n" - ] - } - ], - "source": [ - "from kan import *\n", - "import matplotlib.pyplot as plt\n", - "from torch import autograd\n", - "from tqdm import tqdm\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "dim = 2\n", - "np_i = 21 # number of interior points (along each dimension)\n", - "np_b = 21 # number of boundary points (along each dimension)\n", - "ranges = [-1, 1]\n", - "\n", - "model = KAN(width=[2,2,1], grid=5, k=3, seed=1, device=device)\n", - "\n", - "def batch_jacobian(func, x, create_graph=False):\n", - " # x in shape (Batch, Length)\n", - " def _func_sum(x):\n", - " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", - "\n", - "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "\n", - "# interior\n", - "sampling_mode = 'random' # 'radnom' or 'mesh'\n", - "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", - "x_i = x_i.to(device)\n", - "\n", - "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "xb1 = helper(X[0], Y[0])\n", - "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", - "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", - "\n", - "x_b = x_b.to(device)\n", - "\n", - "steps = 20\n", - "alpha = 0.01\n", - "log = 1\n", - "\n", - "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", - "\n", - " for _ in pbar:\n", - " def closure():\n", - " global pde_loss, bc_loss\n", - " optimizer.zero_grad()\n", - " # interior loss\n", - " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", - " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", - " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", - " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", - "\n", - " # boundary loss\n", - " bc_true = sol_fun(x_b)\n", - " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", - "\n", - " loss = alpha * pde_loss + bc_loss\n", - " loss.backward()\n", - " return loss\n", - "\n", - " if _ % 5 == 0 and _ < 50:\n", - " model.update_grid_from_samples(x_i)\n", - "\n", - " optimizer.step(closure)\n", - " sol = sol_fun(x_i)\n", - " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", - "\n", - " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", - "\n", - "train()" - ] - }, - { - "cell_type": "markdown", - "id": "e2246bab", - "metadata": {}, - "source": [ - "Plot the trained KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "02e2a0ba", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=10)" - ] - }, - { - "cell_type": "markdown", - "id": "64d2573b", - "metadata": {}, - "source": [ - "Fix the first layer activation to be linear function, and the second layer to be sine functions (caveat: this is quite sensitive to hypreparams)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e2e78752", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.8357976675033569\n", - "r2 is not very high, please double check if you are choosing the correct symbolic function.\n", - "saving model version 0.1\n", - "r2 is 0.8300805687904358\n", - "r2 is not very high, please double check if you are choosing the correct symbolic function.\n", - "saving model version 0.2\n", - "r2 is 0.8376883268356323\n", - "r2 is not very high, please double check if you are choosing the correct symbolic function.\n", - "saving model version 0.3\n", - "r2 is 0.8372848629951477\n", - "r2 is not very high, please double check if you are choosing the correct symbolic function.\n", - "saving model version 0.4\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.8373)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'x')\n", - "model.fix_symbolic(0,0,1,'x')\n", - "model.fix_symbolic(0,1,0,'x')\n", - "model.fix_symbolic(0,1,1,'x')" - ] - }, - { - "cell_type": "markdown", - "id": "3fae3f32", - "metadata": {}, - "source": [ - "After setting all to be symbolic, we further train the model (affine parameters are still trainable). The model can now reach machine precision!" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "308b72af", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "pde loss: 1.71e+01 | bc loss: 1.14e-02 | l2: 1.37e-01 : 50%|███▌ | 10/20 [00:11<00:11, 1.20s/it]\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/6j/b6y80djd4nb5hl73rv3sv8y80000gn/T/ipykernel_75424/3364925475.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/var/folders/6j/b6y80djd4nb5hl73rv3sv8y80000gn/T/ipykernel_75424/2545871995.py\u001b[0m in \u001b[0;36mtrain\u001b[0;34m()\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_grid_from_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_i\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclosure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 79\u001b[0m \u001b[0msol\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msol_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_i\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0malpha\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mpde_loss\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mbc_loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/torch/optim/optimizer.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 383\u001b[0m )\n\u001b[1;32m 384\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 385\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 386\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_optimizer_step_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 387\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/torch/utils/_contextlib.py\u001b[0m in \u001b[0;36mdecorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mctx_factory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Desktop/2022/research/code/pykan/kan/LBFGS.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mobj_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 442\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_directional_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclosure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 443\u001b[0;31m loss, flat_grad, t, ls_func_evals = _strong_wolfe(\n\u001b[0m\u001b[1;32m 444\u001b[0m obj_func, x_init, t, d, loss, flat_grad, gtd)\n\u001b[1;32m 445\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Desktop/2022/research/code/pykan/kan/LBFGS.py\u001b[0m in \u001b[0;36m_strong_wolfe\u001b[0;34m(obj_func, x, t, d, f, g, gtd, c1, c2, tolerance_change, max_ls)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmemory_format\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontiguous_format\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0;31m# evaluate objective and gradient using initial step\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 50\u001b[0;31m \u001b[0mf_new\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mg_new\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mobj_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 51\u001b[0m \u001b[0mls_func_evals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0mgtd_new\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mg_new\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Desktop/2022/research/code/pykan/kan/LBFGS.py\u001b[0m in \u001b[0;36mobj_func\u001b[0;34m(x, t, d)\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mobj_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 442\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_directional_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclosure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 443\u001b[0m loss, flat_grad, t, ls_func_evals = _strong_wolfe(\n\u001b[1;32m 444\u001b[0m obj_func, x_init, t, d, loss, flat_grad, gtd)\n", - "\u001b[0;32m~/Desktop/2022/research/code/pykan/kan/LBFGS.py\u001b[0m in \u001b[0;36m_directional_evaluate\u001b[0;34m(self, closure, x, t, d)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_directional_evaluate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclosure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclosure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 292\u001b[0m \u001b[0mflat_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_gather_flat_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_param\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/torch/utils/_contextlib.py\u001b[0m in \u001b[0;36mdecorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mctx_factory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/var/folders/6j/b6y80djd4nb5hl73rv3sv8y80000gn/T/ipykernel_75424/2545871995.py\u001b[0m in \u001b[0;36mclosure\u001b[0;34m()\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0malpha\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mpde_loss\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mbc_loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m 520\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 521\u001b[0m )\n\u001b[0;32m--> 522\u001b[0;31m torch.autograd.backward(\n\u001b[0m\u001b[1;32m 523\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 524\u001b[0m )\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m 264\u001b[0m \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 266\u001b[0;31m Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m 267\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "train()" - ] - }, - { - "cell_type": "markdown", - "id": "35985ae9", - "metadata": {}, - "source": [ - "Print out the symbolic formula" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f0ec310e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle - 0.5 \\sin{\\left(3.141592 x_{1} + 3.141593 x_{2} - 4.712389 \\right)} + 0.5 \\sin{\\left(3.141593 x_{1} - 3.141592 x_{2} + 1.570797 \\right)}$" - ], - "text/plain": [ - "-0.5*sin(3.141592*x_1 + 3.141593*x_2 - 4.712389) + 0.5*sin(3.141593*x_1 - 3.141592*x_2 + 1.570797)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula = model.symbolic_formula()[0][0]\n", - "ex_round(formula,6)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5c3e90ca", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_7_PDE_accuracy-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_7_PDE_accuracy-checkpoint.ipynb deleted file mode 100644 index 0d7f03913..000000000 --- a/tutorials/.ipynb_checkpoints/Example_7_PDE_accuracy-checkpoint.ipynb +++ /dev/null @@ -1,229 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 7: Solving Partial Differential Equation (PDE)" - ] - }, - { - "cell_type": "markdown", - "id": "7d568912", - "metadata": {}, - "source": [ - "We aim to solve a 2D poisson equation $\\nabla^2 f(x,y) = -2\\pi^2{\\rm sin}(\\pi x){\\rm sin}(\\pi y)$, with boundary condition $f(-1,y)=f(1,y)=f(x,-1)=f(x,1)=0$. The ground truth solution is $f(x,y)={\\rm sin}(\\pi x){\\rm sin}(\\pi y)$." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0e2bc449", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "pde loss: 2.13e+00 | bc loss: 1.80e-03 | l2: 3.11e-03 : 100%|███████| 50/50 [00:35<00:00, 1.43it/s]\n", - "pde loss: 5.68e-01 | bc loss: 5.30e-04 | l2: 1.03e-03 : 100%|███████| 50/50 [00:35<00:00, 1.43it/s]\n", - "pde loss: 1.23e-01 | bc loss: 1.51e-04 | l2: 1.74e-04 : 100%|███████| 50/50 [00:35<00:00, 1.42it/s]\n" - ] - } - ], - "source": [ - "from kan import KAN, LBFGS\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "from torch import autograd\n", - "from tqdm import tqdm\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "\n", - "dim = 2\n", - "np_i = 51 # number of interior points (along each dimension)\n", - "np_b = 51 # number of boundary points (along each dimension)\n", - "ranges = [-1, 1]\n", - "\n", - "\n", - "def batch_jacobian(func, x, create_graph=False):\n", - " # x in shape (Batch, Length)\n", - " def _func_sum(x):\n", - " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", - "\n", - "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "\n", - "# interior\n", - "sampling_mode = 'mesh' # 'radnom' or 'mesh'\n", - "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", - "x_i = x_i.to(device)\n", - "\n", - "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", - "xb1 = helper(X[0], Y[0])\n", - "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", - "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", - "\n", - "x_b = x_b.to(device)\n", - "\n", - "alpha = 0.01\n", - "log = 1\n", - "\n", - "\n", - "grids = [5,10,20]\n", - "steps = 50\n", - "\n", - "pde_losses = []\n", - "bc_losses = []\n", - "l2_losses = []\n", - "\n", - "for grid in grids:\n", - " if grid == grids[0]:\n", - " model = KAN(width=[2,2,1], grid=grid, k=3, seed=1, device=device)\n", - " model = model.speed()\n", - " else:\n", - " model.save_act = True\n", - " model.get_act(x_i)\n", - " model = model.refine(grid)\n", - " model = model.speed()\n", - "\n", - " def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", - "\n", - " for _ in pbar:\n", - " def closure():\n", - " global pde_loss, bc_loss\n", - " optimizer.zero_grad()\n", - " # interior loss\n", - " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", - " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", - " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", - " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", - "\n", - " # boundary loss\n", - " bc_true = sol_fun(x_b)\n", - " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", - "\n", - " loss = alpha * pde_loss + bc_loss\n", - " loss.backward()\n", - " return loss\n", - "\n", - " if _ % 5 == 0 and _ < 20:\n", - " model.update_grid_from_samples(x_i)\n", - "\n", - " optimizer.step(closure)\n", - " sol = sol_fun(x_i)\n", - " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", - "\n", - " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", - "\n", - " pde_losses.append(pde_loss.cpu().detach().numpy())\n", - " bc_losses.append(bc_loss.cpu().detach().numpy())\n", - " l2_losses.append(l2.cpu().detach().numpy())\n", - " \n", - " \n", - " train()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "dcbfa677", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(pde_losses, marker='o')\n", - "plt.plot(bc_losses, marker='o')\n", - "plt.plot(l2_losses, marker='o')\n", - "plt.yscale('log')\n", - "plt.xlabel('steps')\n", - "plt.legend(['PDE loss', 'BC loss', 'L2 squared'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bce40477", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_8_continual_learning-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_8_continual_learning-checkpoint.ipynb deleted file mode 100644 index 6df4a2618..000000000 --- a/tutorials/.ipynb_checkpoints/Example_8_continual_learning-checkpoint.ipynb +++ /dev/null @@ -1,297 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 8: Continual Learning" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Setup: Our goal is to learn a 1D function from samples. The 1D function has 5 Gaussian peaks. Instead of presenting all samples to NN all at once, we have five phases of learning. In each phase only samples around one peak is presented to KAN. We find that KANs can do continual learning thanks to locality of splines." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "import numpy as np\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "datasets = []\n", - "\n", - "n_peak = 5\n", - "n_num_per_peak = 100\n", - "n_sample = n_peak * n_num_per_peak\n", - "\n", - "x_grid = torch.linspace(-1,1,steps=n_sample)\n", - "\n", - "x_centers = 2/n_peak * (np.arange(n_peak) - n_peak/2+0.5)\n", - "\n", - "x_sample = torch.stack([torch.linspace(-1/n_peak,1/n_peak,steps=n_num_per_peak)+center for center in x_centers]).reshape(-1,)\n", - "\n", - "\n", - "y = 0.\n", - "for center in x_centers:\n", - " y += torch.exp(-(x_grid-center)**2*300)\n", - " \n", - "y_sample = 0.\n", - "for center in x_centers:\n", - " y_sample += torch.exp(-(x_sample-center)**2*300)\n", - " \n", - "\n", - "plt.plot(x_grid.detach().numpy(), y.detach().numpy())\n", - "plt.scatter(x_sample.detach().numpy(), y_sample.detach().numpy())" - ] - }, - { - "cell_type": "markdown", - "id": "19477c89", - "metadata": {}, - "source": [ - "Sequentially prensenting different peaks to KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "831a9456", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABMcAAADLCAYAAABqHvQ/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA2JElEQVR4nO3de4xc9X3//9fszl6xvQZ8J7bBgNdQCNm1wZhcIIkEpjQlqVRBRcEhVRoqQklBqkBpCY6amkj9UqlKSRRKKFWpWqVAeoGg0MYXKggFY8em6wvEwJqLAxh718be2Z2Zz+8P/8747Ozs7tzOmc97zvMhWTCzc/nMZz7v9/vMe86Zk3LOOQEAAAAAAAAJ1NLoAQAAAAAAAACNQnMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJFWlzbMOGDbr44os1c+ZMzZs3T1/84he1Z8+eKJ8SQJmIT8BvxCjgL+IT8BsxCqBSkTbHNm/erFtvvVW/+MUv9MwzzyibzerKK6/URx99FOXTAigD8Qn4jRgF/EV8An4jRgFUKuWcc3E92fvvv6958+Zp8+bN+sxnPhPX0wIoA/EJ+I0YBfxFfAJ+I0YBTCcd55MNDQ1Jkk477bSSf89kMspkMoXL+XxeH374oU4//XSlUqlYxggk1VtvvSVJam9v1/DwcMnbFMdoLpfT/v379Ru/8RtqbW2NZZxAUk0Xo8Qn0DjUUMBv1FCguTjndOTIES1atEgtLfU5IDK2Pcecc7r22mt16NAhPfvssyVvc++992r9+vVxDAcAAAAAAABG7d+/Xx/72Mfq8lixNcduvfVWPfnkk/qf//mfSQdf3LEfGhrSkiVLtH//fs2aNSuOYQKJdOedd+pnP/uZnn76aZ1xxhmT3q44Rt955x2tXr2aGAUiVk6MEp9AY1BDAb9RQ4HmMzw8rMWLF+vw4cPq6empy2PGcljlbbfdpn//93/Xli1bpuzqdXR0qKOjY8L1s2bNIikBEbntttv09NNPa8uWLTrrrLOqegxiFIhOrTFKfALRoYYCfqOGAs2tnj+/FWlzzDmn2267TU888YQ2bdpU9UYDgPojPgG/EaOAv4hPwG/EKIBKRdocu/XWW/VP//RP+rd/+zfNnDlTBw4ckCT19PSoq6sryqcGMA3iE/AbMQr4i/gE/EaMAqhUpL85Ntkubg8//LC+/OUvT3v/4eFh9fT0aGhoiN1ZgTqrNT6lE2f+Wbx4MTEKRKDWGCU+gehQQwG/UUOB5hZFryjywyoB+In4BPxGjAL+Ij4BvxGjACrV0ugBAAAAAAAAAI1CcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIlFcwwAAAAAAACJRXMMAAAAAAAAiUVzDAAAAAAAAIkVaXNsy5Yt+sIXvqBFixYplUrpJz/5SZRPB6BCxCjgL+IT8BsxCviL+ARQqUibYx999JEuuugife9734vyaQBUiRgF/EV8An4jRgF/EZ8AKpWO8sGvvvpqXX311VE+BYAaEKOAv4hPwG/EKOAv4hNApSJtjvns2LFjeuqpp9TW1qarrrpKnZ2djR5S2TKZjFKplNrb2xs9lIrk83llMhl1dHSopcXWz92Njo5Kkrk5z+VyymQy6uzsNDfnmUxGktTR0dHgkVTm2LFj+ulPf6p0Ok1uiYnl3GJ1nefzeY2MjJjNLRbXueXtFmpo/CznltHRUbW3t5ucc3JLvCyvc2povCxvK1qtoR999JF++tOfmsotXjXHMplMIclJ0vDwcCTPMzw8rLlz5xYWWkdHhz744APNmDEjkuerpyNHjujIkSOSpJ6eHp1yyikNHlF58vm83n//feVyObW2tmru3LlmEpP1Oc/n83Wb8+IYDeal3qzOObklfvl8Xu+9915d13lc6j3nccVn8ZzPmzdPqVQqkueqN6vrnNwSP2po/NhWjB+55SRq6PSsrnNyS/ys5havVsWGDRvU09NT+Ld48eK6P0c2m1VfX1/hjZJOJMP+/n5ls9m6P1895fN5HT16tHB5eHhYzrkGjqh8R48eVS6Xk3Tim9iPPvqowSMqT/GcHzlyxNSc5/N5SfWb8+IYPf/882t+zGJW13kz5Zakr/M4RLHO44hPaeKch1+Hz8gt8SO3jEcNnRrbivFqptxCDY0euSV+5Jb4edUcu/vuuzU0NFT4t3///ro/x759+7Rv374J17/66qslr/fJ8ePH5ZxTW1ub0um0nHMaGRlp9LDKcvz4cUkq7E4ZXPbdyMiInHNKp9NKp9OF3aAtOHbsmCSpq6tLUn3mvDhGBwYGan7MYlbXueXcEqzzYM4trXOruSWKdR5HfErR5JY4kFviRw0djxo6Nau5xWoNtZxbqKHxs5xbrG4rWq2hlnOLV82xjo4OzZo1a9y/eps7d24hMMLHS3d0dGjRokV1f756CoKhq6ur8BosBEg2m1Uul1MqldLs2bOVSqWUzWa97xxLdud8bGxM+XxeqVRKPT09kk6+D7UojtGZM2fWY7jjBLu0h+c8vJu7r+bMmWM+t3R2dhY21iysc8u5JYp1Hkd8FueWYM5rzS1xsJrP582bZz63WJtzamj8RkdHlc/n1dLSMi63WMjnVmuo5dxCDY2f1XxueVvR6pxb7rdE2hw7evSotm/fru3bt0uSXn/9dW3fvl2Dg4NRPu2kstmsPvnJTxYWlXOusLtfJpPRmjVrvA6U8DG7wQ9PhndX9FUw38GPq7a1tUnyf+zOuUKh7ezsNLWRGf6B0paWlkJSKh67bzEqjf/RyWCd+z7n2WxWn/rUp0zmlvA67+joKKwV3+NTOplbite5hbGXyucW4jMYY3E+9z1GJZs1NJvN6rLLLjOfW6ih8bFYQ6Xx47a6rWiphlrOLRI1tBEs1lCJz6Fxs95vibQ59tJLL6mvr099fX2SpDvuuEN9fX265557onzaSe3bt0+7du0qXL7gggu0YsWKwuVXXnnF2139xsbG5JxTKpVSW1tbofjmcjnvv20IB7YkUxsOzrlCIg2SaT6f937Oi89qMtmGg28xGv5Grb29Xe3t7UqlUt6v82bILcEHQEu5JbyhJtnJLeF1HuTzYJ2HNxh8i09p4pxb2UC2WkMt5xZqaPys1lBp4pxbyucWa6jl3EINjZ/VGirxOTRulnOLFPHZKq+44gqvfjRu2bJl+vjHP64dO3bo/PPP14svvqhMJqNLLrlEe/fu1apVq7Rs2bJGD7Ok4o2GYMNndHRUmUxG3d3djRzelMbGxiSpENQdHR06evSo90kpGF8w7qAgjI2NaXR0tLDrvI/K3cj0LUZLrfO2tjbv17nl3FIcn+HcYmWdB2O38m3gVOt8dHRU6fSJ0uxbfEqT5xbfv8m0WkMt5xZqaPys1lCpdEPy6NGj3ucWqzW0VG4ZGRnR6tWrzeQWamh8rNZQic+hcbO83SJ59ptjUcvn84Uk2dnZqXQ6ra6urkLXPjhziI+CwA6SUvj/g7/5KJfLFea1+ANsNps1MefBeCUb3zZMNefhv/ko+Mav1Jz7vs6bMbdYW+fBuK3klvCcB6/B53Wez+fN5hbLNdR6bqGGxsdyDQ3vCSTZmXPLNbQ4t3R3d5vKLdTQ+FiuoXwOjZfl7RYpYc2xgYEB7dy5U5L08ssva9++fXrjjTfGXbd3795GDnFSpQIk+GbE56QUHncqlZIktbS0mBq7tUIQbByn0+lxc97a2irJztgDFtZKs+UWCxuZlnNLqXVuYc6Dcbe2tprLLVZraDPkFmpofKzW0GBsFufcag21nFuoofGzWkMtbytaraG7du0ym1ukBDXHstmsbr755sLlYJe+ZcuW6aKLLipcf9NNN3n5I3FTFQIfxxsolUylk6/D17E756YsBL6OWyq9ViS768X3cWezWX3lK18pXLaUWyyvc6u5RWq+fG5h7BbnnNzSGNTQ+Fmdc6vr3HJukWzmc4ka2ghWtxUt5xbL/RYpQc2xffv2Fc5WIkmPPPKI0um00um0HnzwwcL1W7du9e5H4oIf5EulUiW/DfT5h/mmKwS+dr6D+UylUoVvdCQbcz7dRqavcx7e3bx4nadSKW/n3HpukcZ/cynZWOfhPQ3CWOfRsZpbrNZQy7mFGho/y7nF6rai1RpqObdYXudWc4vVGirZzS1Wa6jl3BJITHMs3LHs6+vT8uXLC38777zzdOGFF0qSlz8SN1kyDf82g6/BbbUQTJZMw4XB14631UJQandzafyc+zj24IcnJam/v79pcovPcy6V/m0dyf9v1UodPiTZmnNr+dxqDbWcW6ih8bNaQ6XmzC0+z/lUuWXFihUmcgs1ND5Wa6hkd86t1tBwv8XadksgMc0xSZOesSQcML6d1USaPLDD1/kYIM65Scfu87glu3MuTT5238c92Z5A4et8HftkLOcW33eXD74xs7bOLeeWyWLU93FbnXPnHNstDUANjZ/VObdcQydDbokONTRefA5tDKvbLYHENMdee+017dixQ5K0bdu2cbvyvfnmm4UfifNxN79yiq+Pne/JdgmVTn7j45zzcrdQq3M+2e7mkgrvge9zXvwtieR3IXj11VcLuSX44cnA4OAguSUC4V38S+UWyd9dzq1u8JQ6y1Yg2FPF99xibZ2/+uqrE37UNkBuiQY1NH7hM5uxrRiPvXv3NuV2i8/rnBoaPz6Hxi/cbynOLb73WwKJaY4tWrRIvb29kqSLL7543K58Z5999rjdi33bzc9qIZhq3OHrfQxu63NefFiF5P+uuFbnfKrcUnzoArmlPqYaN+s8GtPllmDD0+exW5tzckv8qKHxC4+7eM6D6yW2FeuJz0Txo4bGj8+h8bOcWwKJaI5ls1ldccUV2rNnj1asWKEtW7aUPG5aUqGr7xOrAVJuUrI2dp879pMdox6wOue+jjubzeqzn/0suSVmljd4porRZphza2P3ddzZbFaf+9zntGfPHp133nlNlVuoodGwuM4lckvcrOcWamj8LK5zqXnn3Ncaar3fEkhEc2zfvn3atm2bJGn37t0aHByc8Pdf/vKXkqTt27d7tZtfLpebdBf/4Dpfdwu1mpSCXfyLz8oS8PnQCqtzHj4EbqriG94t3QfWc8tU69xybvH1t16mOmQrfJ1v61yy2zSwWkPDuWXXrl1NlVuoofVntYZKtnOLxRpqObdQQ+NntYZKdvO51Rpq+TNRWCKaY8VnqizejW/ZsmXq7++XdOJMCkuWLIl9jJOZbnfz4G+Sfx1kq4UgvOtzKT4fWmG1EITnvKVlYlrydZfz4rOyWMotU/14c8DHOZeaY52Xyue+rnPJbkPSag2d7rBJn3MLNTR+VmuoVH5u8Sk+Jbs11PJ2CzU0flZrqMTn0LiV02/p6+uT5F9uCUtEc0ya+qwI6XRamzZtUm9vr3bt2qVPf/rT3iy26ZJp+G++jDlgfYNnsmQq2Z1zq+OW/N1wmC63bN682WxusRqjlte51bFbHXf4b76NfSo+5xZqaPws19AkzLlvNZTPRPFr5nVudey+xqflGmo1t4Qlojn2q1/9atIzVQbeeecd7dmzR5L00ksvebOrn9WkNNXZhwK+7hZqdc6nO6wifH14N2kfWJ3zqc7KEiC31Fc5ucXXQyvK2eDx8QNsOEeTW+Ix1VlwA2+//Ta5pY6oofGb7jC54HofD9uyOufl5BZft1uoofGzus75HBq/8Gcia/2WsEQ0xxYvXqwLL7xQkrRq1aqSZ0fw9QwKVr+ZKmc3XF93C7U+55MdViFJLS0tXu5yXsm3JD7N+ZIlS6bNLb6eVc5q8S03twTr3Kf1Usmc+zTuYCxT5RZfD2exms/LyS1st9QXNTR+0x0mF7Cez31aK82eW3xc59TQ+PE5NH7l5JZzzjnHy9wSlojmWHjBT7W7XxA8U90mbuX8poHVwA7/3drYrY47/HdrY/dx3OGiVE5u4dvA2pW7zn389rjZ59zHsVuvoRK5JS6W17nVOS8nPiXyeT2RW+JnObdYr6EW59z6Opfs9VvCEtEce+2117Rz505J0tatW0vuwhc+g8JkuwLGLby7+VTfBgbfuPm0W6jVpFTOLv7hv/l02JbVOS9nd/Pw38K7SjdapbnFl7OzsM7jZ3mdW51zyzWU3BI/q+u8GXLLVPEp+Tfnlte51dzSDOvcWm6xXEObYc6bPbf40m8plojm2IIFC9Tb2ytJuvjiiyc99Mm3MyiUu7u5j7viVrp3hy+7hVqe83K/gfWtEATjaGlpmXR38+K/+zL2cnOLb2d+qmSd+3aIgtUNnmD+LK5zq3NuOZ8nIbf4NufU0PglIbf4VkOtfiaihsbPcj7nc2j85s+fbzK3FGv65lg2m9Vv/uZvas+ePTr//PO1ZcuWkoGSTqe1ceNGr86gUG5gS/4Gt9VCUM6c+zp2a9/AlvNbKQGfxp7NZnXNNdeUlVt8O6tcM6xzq7nF2jqXyo9R38ZttYZWklt8O/NTM+QWa+vcag2V7H+AtbbOmyG3WFzn1ND4Wd9WbObc4lu/pVjTN8d+9atfFXbfGxgY0ODg4KS39e0MClYDJHzGp3ILgS+7hVrdyCx3d3Np/G93+LDLudV1Xklu8e2sclbXeTW5xZdDK6rZyPRhzivJLeG1Ym3OfVrnr732mtntFqu5hRoav0rm3Lezylld55ZzCzU0flZzC59D41fJZ6J3333Xq9xSrOmbY+WcOSFw7rnnFs6gsHLlyoafQcFqUip3l1DJv91Crc/5dLubF9/Gp7Fbm/NKcotvZ36yOueV5JZmWOc+fANbSW4Jvy8+fIC1us7JLfGjhsavkjn37axyVue8ktzi21nlqKHxs7rO+RwaP8u5pVjTN8fCC6acLrxPZ2eppHvs0+6slQR2+HbWxu7jnJezViS/Emq5v/Mi+TXn5Z6pMuBTbrG+kVlubvFxvVj7NjApc+7TuC1vt1BD42e9hpY75z6N3XoNlSrLLT7sxUQNjZ/1Gsrn0PhYzi3Fmr459uqrr0575oSAT2dQqGQ3XMmvXc6rLQSNLmKVzrlPh21VsnEcvp1Pc17JBk+j17hU3llZAj6d+anSdR68Lz7scl7tBo9P67zSbwN9yS3WmgaWa2hScgs1tHaWa2hS8rlPNbTa3GLtMxE1tHaWayifQ+Nntd9SStM3x8o5K0sgfAaF888/v6FnUCj3rCwBn3Y5t1oIgnG3traWNec+HVph9ZupSnY3l8afLrrRc17OWVkCPp1VrtJ17tMu51ZzSzXr3Gpu8WXOLdfQSnOLL2d+oobGz3INtdqQtFxDreYWamj8LNdQq9uKlmtotf2WRueWUpq6OZbNlnemykA6ndbPf/5z9fb2amBgoKFnUKh0F3/Jn+C2WggqHXf4to0eu/VCYG2dZ7PlnZUlkE77c+Yny+vcam6xus4lu7nFag0ltzSG1XVuObdYPZTV6jqvJrf4clY5y+vcam6xWkPDz29tW9Fybqm03+JLbimlqZtjlZyVJeDL2Vkq/UZN8uObzEp3CQ3frtG7hVpNSuGzslRTCBo559Wscx/m3HJusbrOa8ktjV7nVue81tzSSFZraCVnfAqQW2pDDY1fLXMevm8jWF3n5Jb4UUPjx+fQ+Fn+TFRKUzfHKjlzQmD58uVenLHSase+0l2fg9sGu5w3MqFaTUrBc5e7G25wWx/OiFPNOveh+FaTW3w5q1w169yHOa8mt/iyzq1+611Nbkmn014ctmW1hlaTW3w58xM1NH5Wa2g1c+7LYVtWa2g1ueXcc8/14jMRNTR+Vmson0PjZzm3lNLUzbFKzyYX8OHMT1YLQTXjluyOPRh3I5NptXPuw8ZaNWP3adwSuSUuteYWH9aL1XWelNzi0zqXqsstPuzFRA2NT9Jyi08xmpTcErC23WJ5nVsdu0/rPGm5xYe1Itn7TFRKUzfHdu/eXfaZEwLFZ1DYu3dvpGMsJXxGm2q6x43c5dxqUgrPWTXFt5GHVlSz63P49o2c82rWuQ9zXmtu2b59e8NySzXr3IddzmvdyGzUOs/lcjXl80au82q+xZQav2FvuYbu2rXL7HYLNTRelmuo5dxitYZWm1t27NghqXG5hRoaP8s1lM+h8bO63TKZpm2OZbNZfe1rXytcLnc3v/AZFCTppptuij1QwhtqQVe1HD7scm41KVU75+FdpRtVxKrZ9Tl8+9HR0bqPqRzVznmjd39OYm7x4Yw4tTbHGrXOwxvH1nKL1W+9rdbQWnLLJz7xicJlS7nFh3VODY1f0rYVG11DLecWamj8rNZQKXm5pdHrPJvN6pZbbilctpRbJtO0zbFwR1KSHnnkkbK63+l0Wg8//HDhcrkd0Hqq9lvM8H0aHdxWNzIrHXf4Po0uYpaLb6UaOfZmyC21rHNrMerLOie3xMdqDU16bmn0eknSOrc6dqvbuOH7NKKGklvILZWwWkMlPofGzXJumUzTNscWLVqkzs5OSVJ3d3dFP/S2fPlydXV1SZK6urq0ZMmSSMY4mSAw29vbK75vI489DnbpDH9zUK4gsBu1K67VpNQMc17NOm/knC9cuLCm3BLctxG5pZZ1HrxPrPPKJHHOg28+GzXnVmtoLdstvb29ZnMLNbQ6Vmvo2NhYYc6r3buj0XNuLZ8nNbdQQ6tjtYY2Qz63VkMt55bJNG1zbM+ePRoZGZEkHTt2rKzTigb279+v48ePS5KOHz/esG9JqklKwX0a0fkOnrOawA5vJFkbeyOLb73mvJFjr2XDvhFrZe/evTXlluC+jcgttawXq/EZ3kiyFqNW47PRc261hta63WI1t1BDq2O1htYSn77MubUamtTc4sNaoYbGh8+h8a8Vy7llMk3ZHMtms/qDP/iDwuVyj38NLFu2TBdddFHhcpzHweZyuap+kC8QBEg2m4397A+1FILw/eIO7vCc1/oNrLU5b1QhqHWdN+oHKOuRWxp1jH2t6zycW+L+0c9a13lHR8e4x4lLM+SWauIzfD9ruaVRNTTJucWHdU4NjU+tuaVRH76t1lByCzW0ElZrqMTn0LjXueV+y1SasjlW7fGvgXQ6rR/96EeFy3EeBxtOppX8IF+gpaWlYd82WN3IrHXOW1tbC3PeqLHX2jTIZDJ1G1M56jHnwQ8Kxzn2euSWhx56qHDZWm4J5tzaOg/uZ3Gdk1sqY7WG1iO3/N3f/V3hsqXcwjqvnNUaKtUvn1vbVmxUDU3ydgu5pXJWa6jE59DwY8XBcr9lKk3ZHDvjjDPGHcNaSRcz0KjjYIMkWG1gh+8bZ0LN5/OFbm899u6Is/NdazIN3zfOpFSPOQ9/SxLnN5n1mPNG7A1kObfUc86t5RbL67wRuSWXy9V1zuPM51Zr6Mc+9rGac8uKFSvM5hZqaGWs1tB65pbR0VGzc24tt1jebqGGVsZqDeVzaPzr3HJumUpTNsd279497hjWSo5/Dbz99tsNOQ42SCRBgFajEcU3eK62trbCKWUr1ajOd/A+1zLnjSgEwbhrnfNGfHtcjzlvxDq3nFusznnS13kjcovlfG61hiY9t1BDK2M1n9crtzDn5du1axe5RTbXOTW0fJbn3Oo6t5xbptJ0zbFsNquvfOUrhcuVHv8aKD7G/sYbb4z8ONhsNqtcLqdUKlWXpDQ2NhbbGTeChR10f6sVd0Kt15wHrzvOOQ/mqNY5D+4fvIdRq9ech79Vi2POyS3jc0tc36olfZ1bzi3B67Y253HX0Gw2q5tvvrlwOYm5xfI6t5pb4q6hUn0+eEt25zzuGsp2i+3cQg0tH59D413nlnPLdJquObZnzx7t2LGjcPmhhx6q+HSu0onjYB988MHC5Zdffll79+6tyxgnE5whs729vapjjgMtLS2FjZ44Eqpzri5db+lkcAdzEbVg3Bbn3OpGZr3mvLW1NdY5t5xboljnccRoFLnF2jpvhnwe15xbraHkFmpoJazW0HBuqVdDMq4PsFZrKLmFGloJqzWUz6Fst9RT0zXHPvroo3GXq3mjAl1dXeMuR93JDAKx+HmrEWdwj4yMyDk3bkOrWu3t7WppaVE+n49lo+fYsWOSbM55Pp9P/JwHjxHHnFvOLVbnnNxyAvm8PFZrKLnlBGpoecjnJ+c8l8sx51Mgt5xADS2P1Rpqec6trnPLuWU6TdUcy2az+upXv1q4vHLlSi1fvrzqx+vt7R13itGbb745sjdsdHRU2WxWqVSqLgHS3d2tVCql0dHRyM8WEgR2d3d3zY8Vfv3FgVdvzPkJluc8KARRzzm55aS45lxinQeCx2DOJ2c1n5NbTqKGTq8Z8nk9xs2cT4/cchI1dHrk8xOY8+lZzi3laKrm2MsvvzxuF78f/ehHNXUyi08xWvz49XTkyBFJJxJ4LbtVBlpaWgoFOHjsKIyOjhY66/VISpJ0yimnSDrxTUCUwR3lnB89erTmx5sMc35Sa2troaBEOefklpPimnPW+UnM+fSs1lByy0nU0OlZzy2pVKowV7VizqdGbjmJGjo9qzWUOT8prhpqObeUI5bm2AMPPKCzzjpLnZ2dWrlypZ599tm6P8ehQ4d02WWXjbuuljcqUPy7CJdeemndF9zx48cLgT1z5sy6PW7wWCMjI5HsGuqc09DQkKQTCSk4e1Ct0ul0oYgFj19vwZynUqm6zvmMGTPGPX69hef8lFNOqcucP/DAAzr33HO1bNkyrV27Vk8//XTNj1mK1TmPK7esXr06stwS5ZxH8dsGUaxzyW5ueeCBB9Tf369ly5bp8ssv13//93/X5XHDopzzYK1HPeeSrRraDNst1vI5NXSiOOe8q6srsnzunKvL44ZZraHklpOCz6ALFy7U2rVrtWnTJjO5RaKGToXPoRM1y2eiKHJLuSJvjv3Lv/yLvvGNb+ib3/ymtm3bpk9/+tO6+uqrqzrdZynZbFYvvPCC5s6dO+7sDOeee25Nu/gFli9fPu7sC2NjYzrnnHO0bdu2uuzyl8lkdPjwYUknkki9Als6sViD7vehQ4fqelpa55wOHTqksbExtbS0aNasWXV7bEmaNWtWYdfQQ4cO1XWjJzznM2bMqOuct7W1xTbnQQKsRTg+X3rpJa1evVrXX3+9du7cmfg5jzu3ZLPZyHJLlHN++PDhSNd5PTcaJHu5JRyjW7Zs0SWXXKLf/u3f1muvvVbzYweiyC1hPT09scy5lRraTNstVvK5RA2dTJxzHuW24uHDh03OeT1rKLllvOLPoJ/85Cf1+7//+9q5c6f3uSWMGjoRn0NLa5bPRPXOLZVIuSi+aglZvXq1+vv79f3vf79w3XnnnacvfvGL2rBhw5T3HR4eVk9Pj/7hH/5BHR0dyuVyOnDggObPn6/W1laNjY3pz//8z/XGG2+Mu19bW5s+/PDDuiWnbdu2qb+/f8L1S5cu1V/+5V8qlUrp17/+tRYsWKCWlhP9xtbWVp199tk677zzCos+mGrnnLLZrEZGRsadXeP000+vy3jDnHM6ePBgITi6urrU0dGh1tbWwrhK7cpZvCyCy7lcTmNjYzp27FghOE4//fSazw5SysjIiD788ENJJ+azu7tbbW1tamlpUUtLy7S7oDrnvJrzdDpdWB+TjT0875PNeSqV0mmnnVaXOS+Oz5GREV144YVau3at/uzP/qww562trYUxh8f+1ltv6cwzz9SHH35YaGIE487n88pms8pkMg2d81QqVZj3QDab1cDAgPbt26dcLud1bjlw4IAWLlw4IbesWLFi3Lc1zjnl83nlcrmGr/NSc17q/sF/g7E3OrdMts6Lxxz+/6jnPByjwZyvWbNGa9eu1be//e0pc0up+AyPPZvNKpvNRpJbitWSz8NrJfhvo/P5ZDXUUm6ZarslnU5TQ8uQ1Bpa6v7h/+ZyOY2Ojur48eMNyy2V5PPgss81dKrc0tLSomw2601uKWe7JY4aWhyfzjn19vbqqquu0t133z1tbqGG1o7Pof7M+WTr3NJ2S3FuyWQyuummmzQ0NFS3BmmkzbHR0VF1d3frxz/+sb70pS8Vrr/99tu1fft2bd68edztM5nMuF0Ah4eHtXjx4oqf94UXXtAll1xS/cCLZLNZXXTRRRoYGKj4vhdeeKH+8z//c8pdDru7uwvfCkTBOafDhw/X/ewVra2tOvXUU2s+M8hURkZGNDQ0NK5LXQ/M+eTxeeutt+rll1/WY489NuE+mUxm3LcQBw4c0BVXXKHdu3dPu4ePL3OezWZ1zTXX6JVXXqn4Ocgt41lY55PJZDI6dOiQ8vl8XR+3nnNeKkadc7rlllu0Y8eOCTFaS3y2trZq9uzZkWxgBkZGRnT48GGv57wUcstEvsx5paihk4tyzqPOLRbyeSnklonqNeeTxecf//Efa+vWrfrxj3884T7UUHu5hc+hpSUtt9SzOVb7QaJT+OCDD5TL5TR//vxx18+fP18HDhyYcPsNGzZo/fr1NT1nX19fya5jLdLptLZu3ar+/n7t2rWrovvu3LlTg4ODOueccySd6NSmUqnC6Wa7urrqcqzuVFKplE499VTNmDFDIyMjGh0dVS6XUz6fn/Ata3GQhi8H425tbVVHR0fdfkBwKp2dnero6CgcO53NZgvjLtXXDa4Lf1sYnvO2tjZ1d3fHOufHjx/X2NiYd3M+WXyeccYZ+q//+i/Nnj17wpx/73vf0/3331/y9Qb/wpfT6bTS6bRXcz44OFhVEfAxt+zfv19nn3124bqWlhYv13lYOEbD66WlpUXpdDq23NLR0aH58+dPm1uKY7T4/6Nc56ViNJVKaenSpdq4caNmzJgxbs7Ljc/guiC3dHZ2qrOzM5Z8XmrOJ9vQD899cW7xsYa++eabTZNbBgcHdfbZZ1NDp5DUGhootb0V/DfI53HllnLy+XRrRfK3hjbrdkuU63yy+FywYIE++OADzZ07d8KcU0OjwedQf2tos2y31JWL0Ntvv+0kueeee27c9X/xF3/hent7J9x+ZGTEDQ0NFf7t37/fSSrr37Jly9zLL7/sxsbGIns9Y2NjbuvWrW7ZsmVlj2vlypWRjgmoVqXx6dzEGB0YGHCS3NDQUBxDrouxsTHX399PboH3aq2hFuPTMnJLsiS1hiJ+5JbKEZ/A9Jolt9QzRiNtW86ZM0etra0T9hJ77733JnTypRPf/JTaHfXRRx8d95tjCxYsKBynXPwbGVFKp9Pq7+/Xnj17Sh6b26hxAdWoND6liTE6PDwc6RijkE6n9cILL3gVw+QWlFJrDbUYn5aRW5IlqTUU8SO3VI74BKZnPbdkMhndcMMNdX3+WH6Qf+XKlXrggQcK151//vm69tpry/5B/noeRwrgpFriUzrxY6WLFy8mRoGI1BKjxCcQLWoo4C/iE2huUfSKIm/f33HHHbrxxhu1atUqrVmzRj/84Q81ODioW265JeqnBjAN4hPwGzEK+Iv4BPxFfAKoVOTNseuuu04HDx7Ut7/9bb377ru64IIL9NRTT2np0qVRPzWAaRCfgN+IUcBfxCfgL+ITQKUiP6yyFhxWCfiNXc4BfxGfgN+IUcBfxCfgtyh6RS11eRQAAAAAAADAIJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABILJpjAAAAAAAASCyaYwAAAAAAAEgsmmMAAAAAAABIrEibY9/5znd02WWXqbu7W7Nnz47yqQBUiPgE/EV8An4jRgG/EaMAKhVpc2x0dFS/+7u/qz/6oz+K8mkAVIH4BPxFfAJ+I0YBvxGjACqVjvLB169fL0n6+7//+yifBkAViE/AX8Qn4DdiFPAbMQqgUpE2xyqVyWSUyWQKl4eGhiRJw8PDjRoS0PSOHz8uqbw4K47Rd955p+z7Aqgc8Qn4jRgF/FZujBKfgC1BbDrn6vaYXjXHNmzYUOjyhy1evLgBowGSpaenp+r7EqNAtIhPwG/EKOC3amOU+AT8dvDgwZpqcFjFzbF77723ZAMr7MUXX9SqVasqHszdd9+tO+64o3D58OHDWrp0qQYHB+v2gn00PDysxYsXa//+/Zo1a1ajhxOZpLxOqXGvdcOGDbrvvvumvM3GjRvV399fuPzoo4/q7rvv1uDg4LSPX/yt2ltvvaU1a9Zo586dWrJkSfUD91xS1i6vM1rEZzRYt82HGG0uSVm7vM7oRRmjxCfrtlkk5bUODQ1pyZIlOu200+r2mBU3x77+9a/r+uuvn/I2Z555ZlWD6ejoUEdHx4Tre3p6mvqNDcyaNYvX2WTifq133nmn1q1bN+VtzjzzTHV2dhYud3V1SVJN45w9e3Yi3tOkrF1eZzSIz2ixbpsPMdpckrJ2eZ3RaUSMEp/NJSmvU0rOa21pqd85Jitujs2ZM0dz5syp2wAA1A/xCfiL+AT8RowCfiNGAUQp0t8cGxwc1IcffqjBwUHlcjlt375dknTOOedoxowZUT41gGkQn4C/iE/Ab8Qo4DdiFEClIm2O3XPPPXrkkUcKl/v6+iSdOBb8iiuumPb+HR0d+ta3vlXyUMtmwutsPhZea63xKZ3YXffyyy9v+l12Lbyf9cDr9AfxWT4L72c9JOV1SjZeKzFaPgvvZz3wOv1Sa4wSn80lKa9TSs5rjeJ1plw9z30JAAAAAAAAGFK/Xy8DAAAAAAAAjKE5BgAAAAAAgMSiOQYAAAAAAIDEojkGAAAAAACAxPKuOfad73xHl112mbq7uzV79uyy7uOc07333qtFixapq6tLV1xxhf7v//4v2oHW6NChQ7rxxhvV09Ojnp4e3XjjjTp8+PCU9/nyl7+sVCo17t+ll14az4DL9MADD+iss85SZ2enVq5cqWeffXbK22/evFkrV65UZ2enli1bph/84AcxjbQ2lbzOTZs2TXjfUqmUdu/eHeOIK7dlyxZ94Qtf0KJFi5RKpfSTn/xk2vgs9X4Sn34hRiciRolRXxCfExGfxKdPiNGJiFFi1BfE50TNFJ/Tqcv76Txzzz33uPvvv9/dcccdrqenp6z73HfffW7mzJnuscceczt37nTXXXedW7hwoRseHo52sDVYu3atu+CCC9xzzz3nnnvuOXfBBRe43/qt35ryPuvWrXNr16517777buHfwYMHYxrx9P75n//ZtbW1uQcffNANDAy422+/3Z1yyinuzTffLHn7ffv2ue7ubnf77be7gYEB9+CDD7q2tjb3r//6rzGPvDKVvs6NGzc6SW7Pnj3j3rtsNhvzyCvz1FNPuW9+85vusccec5LcE088MWV8TvZ+3nDDDcSnJ4hRYpQY9TdGiU/ik/j0Nz6dI0aJUWLU5xglPps/PqdSr/fTu+ZY4OGHHy6rOZbP592CBQvcfffdV7huZGTE9fT0uB/84AcRjrB6AwMDTpL7xS9+Ubju+eefd5Lc7t27J73funXr3LXXXhvDCKtzySWXuFtuuWXcdStWrHB33XVXydv/6Z/+qVuxYsW46772ta+5Sy+9NLIx1kOlrzNISocOHYphdNEoTkql4rPU+/mHf/iHrq2tjfj0BDFKjBKj18YwwuoQn8Qn8XltDCOsHjFKjBKj18YwwuoQn8mJz1Lq9X56d1hlpV5//XUdOHBAV155ZeG6jo4OXX755XruuecaOLLJPf/88+rp6dHq1asL11166aXq6emZdsybNm3SvHnztHz5cn31q1/Ve++9F/VwyzI6OqqtW7eOex8k6corr5z0NT3//PMTbn/VVVfppZde0tjYWGRjrUU1rzPQ19enhQsX6vOf/7w2btwY5TAbotT7+YlPfEJjY2P67Gc/W7iO+GwMYpQYJUb9jVHik/gkPv2NT4kYJUaJUcnfGCU+ic96vZ/mm2MHDhyQJM2fP3/c9fPnzy/8zTcHDhzQvHnzJlw/b968Kcd89dVX69FHH9XPf/5z/b//9//04osv6nOf+5wymUyUwy3LBx98oFwuV9H7cODAgZK3z2az+uCDDyIbay2qeZ0LFy7UD3/4Qz322GN6/PHH1dvbq89//vPasmVLHEOOTan3s6XlRIppa2sbdz3xGT9ilBglRv2NUeKT+CQ+/Y1PiRglRolRn2OU+CQ+6/V+pus9sFLuvfderV+/fsrbvPjii1q1alXVz5FKpcZdds5NuC5q5b5OaeJ4penHfN111xX+/4ILLtCqVau0dOlSPfnkk/qd3/mdKkddX5W+D6VuX+p631TyOnt7e9Xb21u4vGbNGu3fv19/9Vd/pc985jORjrMc5azbck32fgYbD+Hric/GIEYnIkaJUV9ilPiciPgkPn2JT4kYLYUYJUZ9iVHicyLf47Oe6vF+xtIc+/rXv67rr79+ytuceeaZVT32ggULJJ3oFi5cuLBw/XvvvTehexi1cl/njh079Otf/3rC395///2Kxrxw4UItXbpUr776asVjrbc5c+aotbV1Qtd6qvdhwYIFJW+fTqd1+umnRzbWWlTzOku59NJL9Y//+I/1Hl5Vylm355133rSPU+r9DJJS8bdKxGf8iFFilBgdz6cYJT6JT+JzPJ/iUyJGiVFitJhPMUp82o3PeqnX+xlLc2zOnDmaM2dOJI991llnacGCBXrmmWfU19cn6cTxuJs3b9Z3v/vdSJ5zMuW+zjVr1mhoaEj/+7//q0suuUSS9MILL2hoaEiXXXZZ2c938OBB7d+/f1xTsFHa29u1cuVKPfPMM/rSl75UuP6ZZ57RtddeW/I+a9as0X/8x3+Mu+5nP/uZVq1aNWH3ZF9U8zpL2bZtmxfvm1S/+Cz1fv7yl79UW1ubNm3aVFjrxGdjEKPEKDE6nk8xSnwSn8TneD7Fp0SMEqPEaDGfYpT4tBuf9VK397Oin++PwZtvvum2bdvm1q9f72bMmOG2bdvmtm3b5o4cOVK4TW9vr3v88ccLl++77z7X09PjHn/8cbdz5073e7/3eyZOofvxj3/cPf/88+755593F1544YRT6IZf55EjR9ydd97pnnvuOff666+7jRs3ujVr1rgzzjjDm9cZnFr2oYcecgMDA+4b3/iGO+WUU9wbb7zhnHPurrvucjfeeGPh9sEpV//kT/7EDQwMuIceesjUKXTLfZ1//dd/7Z544gm3d+9e98orr7i77rrLSXKPPfZYo15CWY4cOVKIP0nu/vvvd0899ZR76qmn3Pr16117e7u75pprCvEZvJ+nnnqq+5u/+ZvC+3nDDTcQn54gRolRYtTfGCU+iU/i09/4dI4YJUaJUZ9jlPhs/vjctm2be/PNN51z0b2f3jXH1q1b5yRN+Ldx48bCbSS5hx9+uHA5n8+7b33rW27BggWuo6PDfeYzn3E7d+6Mf/AVOHjwoLvhhhvczJkz3cyZM90NN9ww4RSr4dd57Ngxd+WVV7q5c+e6trY2t2TJErdu3To3ODgY/+Cn8Ld/+7du6dKlrr293fX397vNmzcX/rZu3Tp3+eWXj7v9pk2bXF9fn2tvb3dnnnmm+/73vx/ziKtTyev87ne/684++2zX2dnpTj31VPepT33KPfnkkw0YdWWCU/+W8y+Iz02bNjlJrrW1tfB+Ep9+IUaJUWLU3xglPolP4tPf+HSOGHWOGCVG/Y1R4rP543PdunXOuejez5Rz///B0gAAAAAAAEDCtEx/EwAAAAAAAKA50RwDAAAAAABAYtEcAwAAAAAAQGLRHAMAAAAAAEBi0RwDAAAAAABAYtEcAwAAAAAAQGLRHAMAAAAAAEBi0RwDAAAAAABAYtEcAwAAAAAAQGLRHAMAAAAAAEBi0RwDAAAAAABAYtEcAwAAAAAAQGL9f/Hqc4LbQ9rgAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.subplots(1, 5, figsize=(15, 2))\n", - "plt.subplots_adjust(wspace=0, hspace=0)\n", - "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", - " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.scatter(x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), color=\"black\", s=2)\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" - ] - }, - { - "cell_type": "markdown", - "id": "3e487a84", - "metadata": {}, - "source": [ - "Training KAN" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "11a1d129", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.99e-06 | test_loss: 3.99e-06 | reg: 3.31e+00 | : 100%|█| 100/100 [00:01<00:00, 89.80\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.99e-06 | test_loss: 3.99e-06 | reg: 3.31e+00 | : 100%|█| 100/100 [00:01<00:00, 76.04\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.99e-06 | test_loss: 3.99e-06 | reg: 3.31e+00 | : 100%|█| 100/100 [00:01<00:00, 92.65\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.99e-06 | test_loss: 3.99e-06 | reg: 3.31e+00 | : 100%|█| 100/100 [00:01<00:00, 79.18\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.99e-06 | test_loss: 3.99e-06 | reg: 3.31e+00 | : 100%|█| 100/100 [00:01<00:00, 87.63\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n" - ] - } - ], - "source": [ - "ys = []\n", - "\n", - "# setting bias_trainable=False, sp_trainable=False, sb_trainable=False is important.\n", - "# otherwise KAN will have random scaling and shift for samples in previous stages\n", - "\n", - "model = KAN(width=[1,1], grid=200, k=3, noise_scale=0.1, sp_trainable=False, sb_trainable=False, base_fun='zero')\n", - "\n", - "for group_id in range(n_peak):\n", - " dataset = {}\n", - " dataset['train_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['train_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " model.fit(dataset, opt = 'LBFGS', steps=100, update_grid=False);\n", - " y_pred = model(x_grid[:,None])\n", - " ys.append(y_pred.detach().numpy()[:,0])" - ] - }, - { - "cell_type": "markdown", - "id": "dbb9a1b7", - "metadata": {}, - "source": [ - "Prediction of KAN after each stage" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "12379f4a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.subplots(1, 5, figsize=(15, 2))\n", - "plt.subplots_adjust(wspace=0, hspace=0)\n", - "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", - " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.plot(x_grid.detach().numpy(), ys[i-1], color='black')\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d2002726", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Example_9_singularity-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Example_9_singularity-checkpoint.ipynb deleted file mode 100644 index 5fd011664..000000000 --- a/tutorials/.ipynb_checkpoints/Example_9_singularity-checkpoint.ipynb +++ /dev/null @@ -1,459 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Example 9: Singularity" - ] - }, - { - "cell_type": "markdown", - "id": "2571d531", - "metadata": {}, - "source": [ - "Let's construct a dataset which contains singularity $f(x,y)=sin(log(x)+log(y))\n", - " (x>0,y>0)$" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2075ef56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.14e-01 | test_loss: 1.29e-01 | reg: 6.34e+00 | : 100%|█| 20/20 [00:03<00:00, 5.03it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=2, device=device)\n", - "f = lambda x: torch.sin(2*(torch.log(x[:,[0]])+torch.log(x[:,[1]])))\n", - "dataset = create_dataset(f, n_var=2, ranges=[0.2,5], device=device)\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3f95fcdd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ccb7ec43", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9974619150161743\n", - "saving model version 0.2\n", - "r2 is 0.997527003288269\n", - "saving model version 0.3\n", - "r2 is 0.9740613698959351\n", - "saving model version 0.4\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9741, device='cuda:0')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'log')\n", - "model.fix_symbolic(0,1,0,'log')\n", - "model.fix_symbolic(1,0,0,'sin')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "0937db67", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.66e-07 | test_loss: 2.75e-07 | reg: 0.00e+00 | : 100%|█| 20/20 [00:01<00:00, 15.69it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e959cda3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle - 1.0 \\sin{\\left(2.0 \\log{\\left(5.017 x_{1} \\right)} + 2.0 \\log{\\left(1.512 x_{2} \\right)} - 7.194 \\right)}$" - ], - "text/plain": [ - "-1.0*sin(2.0*log(5.017*x_1) + 2.0*log(1.512*x_2) - 7.194)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ex_round(model.symbolic_formula()[0][0], 3)" - ] - }, - { - "cell_type": "markdown", - "id": "16e4da06", - "metadata": {}, - "source": [ - "We were lucky -- singularity does not seem to be a problem in this case. But let's instead consider $f(x,y)=\\sqrt{x^2+y^2}$. $x=y=0$ is a singularity point." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1ce52cec", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.65e-03 | test_loss: 3.97e-03 | reg: 4.84e+00 | : 100%|█| 20/20 [00:03<00:00, 5.36it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "from kan import *\n", - "import torch\n", - "\n", - "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=0)\n", - "f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2)\n", - "\n", - "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "3a69ec41", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "abef7aa9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "r2 is 0.9999973773956299\n", - "saving model version 0.2\n", - "r2 is 0.9999948740005493\n", - "saving model version 0.3\n", - "r2 is 0.9998846650123596\n", - "saving model version 0.4\n" - ] - }, - { - "data": { - "text/plain": [ - "tensor(0.9999)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fix_symbolic(0,0,0,'x^2')\n", - "model.fix_symbolic(0,1,0,'x^2')\n", - "model.fix_symbolic(1,0,0,'sqrt')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "aa71848c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rewind to model version 0.4, renamed as 1.4\n" - ] - } - ], - "source": [ - "model = model.rewind('0.4')\n", - "model.get_act(dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e14000d8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.00775534257195 \\sqrt{0.999962771771901 \\left(6.10769914067904 \\cdot 10^{-5} - x_{1}\\right)^{2} + \\left(9.20887777110479 \\cdot 10^{-5} - x_{2}\\right)^{2} + 0.00441348508007971} - 0.00955450534820557$" - ], - "text/plain": [ - "1.00775534257195*sqrt(0.999962771771901*(6.10769914067904e-5 - x_1)**2 + (9.20887777110479e-5 - x_2)**2 + 0.00441348508007971) - 0.00955450534820557" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "formula = model.symbolic_formula()[0][0]\n", - "formula" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c56ee3d5", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.01 \\sqrt{1.0 x_{1}^{2} + x_{2}^{2}} - 0.01$" - ], - "text/plain": [ - "1.01*sqrt(1.0*x_1**2 + x_2**2) - 0.e-2" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ex_round(formula, 2)" - ] - }, - { - "cell_type": "markdown", - "id": "1fd57d41", - "metadata": {}, - "source": [ - "w/ singularity avoiding (LBFGS may still get nan because of line search, but Adam won't get nan)." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "de708f21", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.11e-04 | test_loss: 5.64e-04 | reg: 0.00e+00 | : 100%|█| 1000/1000 [00:14<00:00, 70.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 1.5\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"Adam\", steps=1000, lr=1e-3, update_grid=False, singularity_avoiding=True);" - ] - }, - { - "cell_type": "markdown", - "id": "6fd34c4c", - "metadata": {}, - "source": [ - "w/o singularity avoiding, nan may appear" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "031fabd6", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: nan | test_loss: nan | reg: nan | : 100%|█████████| 1000/1000 [00:17<00:00, 57.55it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 1.6\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"Adam\", steps=1000, lr=1e-3, update_grid=False);" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "124c9ca4", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_10A_swap-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_10A_swap-checkpoint.ipynb deleted file mode 100644 index fe87fbfd5..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_10A_swap-checkpoint.ipynb +++ /dev/null @@ -1,353 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "40ed9c0d", - "metadata": {}, - "source": [ - "# Interpretability 10A: swap" - ] - }, - { - "cell_type": "markdown", - "id": "53da4d75", - "metadata": {}, - "source": [ - "The task has 9 inputs bits $x_1, \\cdots, x_9\\in\\{0,1\\}$ and one output bit $y\\in \\{0,1\\}$.\n", - "\n", - "$y = {\\rm maj}({\\rm maj}(x_1,x_2,x_3), {\\rm maj}(x_4,x_5,x_6), {\\rm maj}(x_7,x_8,x_9))$\n", - "\n", - "where ${\\rm maj}$ outputs 1 and two or three input bits are 1, otherwise outputs 0." - ] - }, - { - "cell_type": "markdown", - "id": "e7e99852", - "metadata": {}, - "source": [ - "**KAN**" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "ef1ec71c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " train_loss: 2.40e-02 | train_acc: 1.00e+00 | test_acc: 1.00e+00 | reg: 2.69e+01 |: 100%|█| 20/20 [0" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "import torch\n", - "import numpy as np\n", - "from kan import *\n", - "\n", - "seed = 5\n", - "torch.manual_seed(seed)\n", - "np.random.seed(seed)\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "\n", - "inputs = []\n", - "for i in range(2**9):\n", - " string = \"{0:b}\".format(i)\n", - " sample = [int(string[i]) for i in range(len(string))]\n", - " sample = (9 - len(sample)) * [0] + sample\n", - " inputs.append(sample)\n", - " \n", - "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", - "inputs = torch.tensor(inputs)\n", - "labels = torch.tensor(labels)\n", - "\n", - "\n", - "dataset = create_dataset_from_data(inputs, labels, device=device)\n", - "\n", - "width = [9, 10, 10, 1]\n", - "model = KAN(width=width, seed=seed, noise_scale=1.0, device=device)\n", - "depth = len(width) - 1\n", - "\n", - "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", - "\n", - "\n", - "model.fit(dataset, lamb=0.001, lamb_entropy=5., steps=20, stop_grid_update_step=1000, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2f308d44", - "metadata": {}, - "outputs": [], - "source": [ - "#model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f085cbf2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model.auto_swap()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6c8499f1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c9664e27", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - } - ], - "source": [ - "model = model.prune(node_th=5e-2)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "969ac4aa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "d7c7cc02", - "metadata": {}, - "source": [ - "**MLP**" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "48d9c872", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " train_loss: 1.28e-02 | train_acc: 1.00e+00 | test_acc: 1.00e+00 | reg: 7.73e+01 |: 100%|█| 1000/100\n" - ] - } - ], - "source": [ - "import torch\n", - "import numpy as np\n", - "from kan import *\n", - "from kan.MLP import MLP\n", - "\n", - "seed = 5\n", - "torch.manual_seed(seed)\n", - "np.random.seed(seed)\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "inputs = []\n", - "for i in range(2**9):\n", - " string = \"{0:b}\".format(i)\n", - " sample = [int(string[i]) for i in range(len(string))]\n", - " sample = (9 - len(sample)) * [0] + sample\n", - " inputs.append(sample)\n", - " \n", - "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", - "inputs = torch.tensor(inputs)\n", - "labels = torch.tensor(labels)\n", - "\n", - "\n", - "dataset = create_dataset_from_data(inputs, labels, device=device)\n", - "\n", - "width = [9, 20, 20, 1]\n", - "model = MLP(width=width, seed=seed, device=device)\n", - "depth = len(width) - 1\n", - "\n", - "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", - "\n", - "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", - "\n", - "\n", - "model.fit(dataset, lamb=0.0001, lamb_entropy=2., steps=1000, reg_metric='w', metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4354ef50", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "682152ca", - "metadata": {}, - "outputs": [], - "source": [ - "model.auto_swap()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a66b4122", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "628b947b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_10B_swap-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_10B_swap-checkpoint.ipynb deleted file mode 100644 index f54b5b294..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_10B_swap-checkpoint.ipynb +++ /dev/null @@ -1,301 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "343914f4", - "metadata": {}, - "source": [ - "# Interpretability 10B: swap" - ] - }, - { - "cell_type": "markdown", - "id": "05a17f9f", - "metadata": {}, - "source": [ - "The multitask parity problem has 10 input bits $(x_1, x_2, \\cdots, x_{10})$, $x_i\\in\\{0,1\\}$.\n", - "\n", - "The are five output bits $y_1, \\cdots, y_5$, where $y_i = x_{2i-1} + x_{2i-1} ({\\rm mod} 2)$" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "b0ffa41a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 8.26e-02 | test_loss: 7.72e-02 | reg: 1.66e+01 | : 100%|█| 20/20 [00:04<00:00, 4.93it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[10,10,5], seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2), device=device)\n", - "\n", - "#f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2)\n", - "f = lambda x: torch.cat([x[:,[0]] + x[:,[1]], x[:,[2]] + x[:,[3]], x[:,[4]] + x[:,[5]], x[:,[6]] + x[:,[7]], x[:,[8]] + x[:,[9]]], dim=1)\n", - "dataset = create_dataset(f, n_var=10, device=device)\n", - "model.fit(dataset, steps=20, lamb=1e-2);\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c33be2a1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "da26aef7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model.auto_swap()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "726e6b54", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "008ec601", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.58e-03 | test_loss: 4.63e-03 | reg: 5.09e+01 | : 100%|█| 100/100 [00:04<00:00, 23.41\n" - ] - } - ], - "source": [ - "# MLP\n", - "from kan import *\n", - "from kan.MLP import MLP\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "inputs = []\n", - "for i in range(2**10):\n", - " string = \"{0:b}\".format(i)\n", - " sample = [int(string[i]) for i in range(len(string))]\n", - " sample = (10 - len(sample)) * [0] + sample\n", - " inputs.append(sample)\n", - " \n", - "inputs = np.array(inputs).astype(np.float32)\n", - "labels = np.sum(inputs.reshape(2**10,5,2), axis=2) % 2\n", - "inputs = torch.tensor(inputs)\n", - "labels = torch.tensor(labels)\n", - "\n", - "dataset = create_dataset_from_data(inputs, labels, device=device)\n", - "\n", - "model = MLP(width=[10,20,5], seed=5, device=device)\n", - "model.fit(dataset, steps=100, lamb=2e-4, reg_metric='w');" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c73085a7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "006462be", - "metadata": {}, - "outputs": [], - "source": [ - "model.auto_swap()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "fab579a4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "7ffe525c", - "metadata": {}, - "outputs": [], - "source": [ - "model.auto_swap()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "012fa5c8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(scale=1.5)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27ffab62", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6a500890-9758-4ab3-9407-03e59aa13cf7", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_10_hessian-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_10_hessian-checkpoint.ipynb deleted file mode 100644 index c889a6902..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_10_hessian-checkpoint.ipynb +++ /dev/null @@ -1,172 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5fcb9bb3", - "metadata": {}, - "source": [ - "# Interpretability 10: Hessian" - ] - }, - { - "cell_type": "markdown", - "id": "5230955e", - "metadata": {}, - "source": [ - "To understand the loss lanscape, we compute the hessian (loss wrt model parameters) and get its eigenvalues" - ] - }, - { - "cell_type": "markdown", - "id": "a480848a", - "metadata": {}, - "source": [ - "Try both KAN and MLP, you will usually see that KANs have more non-zero eigenvalues than MLPs, meaning that KANs have more effective number of parameters than MLP. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c9ed6509", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 8.51e-04 | test_loss: 8.26e-04 | reg: 1.11e+01 | : 100%|█| 1000/1000 [00:08<00:00, 114\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "from kan.utils import get_derivative\n", - "import torch\n", - "from kan.MLP import MLP\n", - "from kan.MultKAN import KAN\n", - "from kan.utils import create_dataset, model2param\n", - "import copy\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "f = lambda x: x[:,[0]]**2\n", - "dataset = create_dataset(f, n_var=1, train_num=1000, device=device)\n", - "\n", - "inputs = dataset['train_input']\n", - "labels = dataset['train_label']\n", - "\n", - "#model = MLP(width = [1,30,1])\n", - "model = KAN(width=[1,5,1], device=device)\n", - "model.fit(dataset, opt='Adam', lr=1e-2, lamb=0.000, steps=1000);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "1096bee1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6fdd3ac8", - "metadata": {}, - "outputs": [], - "source": [ - "hess = get_derivative(model, inputs, labels, derivative='hessian')\n", - "values, vectors = torch.linalg.eigh(hess)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "9c43e892", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "plt.plot(values.cpu().numpy()[0], marker='o');\n", - "plt.yscale('log')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "89095a9f", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "292cd529", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.ipynb deleted file mode 100644 index dfe4cef31..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_11_sparse_init-checkpoint.ipynb +++ /dev/null @@ -1,117 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "134e7f9d", - "metadata": {}, - "source": [ - "# Interpretability 11: sparse initialization" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "7fe675c2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN([5,5,5,1], sparse_init=False, device=device)\n", - "x = torch.rand(100,5).to(device)\n", - "model.get_act(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "6e6dc04e-6d7f-4d46-b78b-d24ceffc82bd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN([5,5,5,1], sparse_init=True, device=device)\n", - "x = torch.rand(100,5).to(device)\n", - "model.get_act(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a04657f8-6fa9-4dad-b2d6-135277cfd0ad", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb deleted file mode 100644 index a226b496b..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb +++ /dev/null @@ -1,366 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c982abca", - "metadata": {}, - "source": [ - "# Interpretability 1: Hello, MultKAN!" - ] - }, - { - "cell_type": "markdown", - "id": "30fde2f3", - "metadata": {}, - "source": [ - "Motivation: The original KAN has some level of interpretability, but sometimes not fully interpretable (fully interpretable = convert the network to a symbolic formula). The biggest limitation is the lack of multiplications operators. The original KAN only has addition operators. Although multiplication can be expressed as addition and single-variable functions (which is the core idea of Kolmogorov-Arnold representation theorem), we still hope to explicitly have multiplications in the KANs so that multiplications can be more easily read out from KANs. " - ] - }, - { - "cell_type": "markdown", - "id": "72377ee4", - "metadata": {}, - "source": [ - "We first show how multiplications can be represented by addition and single variable functions. Usually KAN would find solutions leveraging linear functions and quadractic functions (the solutions are not unique). $$xy=((x+y)^2-(x-y)^2)/4=((x+y)^2-x^2-y^2)/2=\\cdots$$" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "76538154", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.73e-03 | test_loss: 4.96e-03 | reg: 6.68e+00 | : 100%|█| 20/20 [00:04<00:00, 4.77it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "torch.set_default_dtype(torch.float64)\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,5,1], device=device)\n", - "\n", - "f = lambda x: x[:,0] * x[:,1]\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.fit(dataset, steps=20, lamb=0.001);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "939224b9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "2ec84826", - "metadata": {}, - "source": [ - "This network seems to be using the equality $xy=((x+y)^2-(x-y)^2)/4$ but not exactly." - ] - }, - { - "cell_type": "markdown", - "id": "b33ecf62", - "metadata": {}, - "source": [ - "Now we want to explicitly introduce multiplication operators, called MultKAN. Note that MultKAN and KAN are actually the same class in implementation, so you can use either class name. If you dig into MultKAN.py, there is a line 'KAN = MultKAN'. KAN is just a special case of MultKAN. To inlcude multiplications, you only need to modify the width parameter. For example, [2,5,1] KAN means 2 inputs, 5 hidden add neurons, and 1 output; [2,[5,2],1] MultKAN means 2 inputs, 5 hidden add neurons and 2 hidden mult neurons, and 1 output." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d8f94f0f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[5,2],1], base_fun='identity', device=device)\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4b39ad0c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.34e-02 | test_loss: 7.16e-02 | reg: 7.99e+00 | : 100%|█| 20/20 [00:04<00:00, 4.79it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20, lamb=0.01, lamb_coef=1.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "4c0314b5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2af1c553", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model = model.prune()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "aac1fb1c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "97851f1f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.37e-07 | test_loss: 1.66e-07 | reg: 6.31e+00 | : 100%|█| 20/20 [00:02<00:00, 6.90it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f27281df", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with x, r2=0.9999999997931204, c=1\n", - "fixing (0,0,1) with 0\n", - "fixing (0,1,0) with 0\n", - "fixing (0,1,1) with x, r2=0.99999999995849, c=1\n", - "fixing (1,0,0) with x, r2=0.9999999918922519, c=1\n", - "saving model version 0.4\n" - ] - } - ], - "source": [ - "model.auto_symbolic()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "fd45a429", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.43e-16 | test_loss: 1.28e-16 | reg: 0.00e+00 | : 100%|█| 20/20 [00:00<00:00, 37.98it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ffb84f4c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle x_{1} x_{2}$" - ], - "text/plain": [ - "x_1*x_2" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sf = model.symbolic_formula()[0][0]\n", - "nsimplify(ex_round(ex_round(sf, 3),3))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "900f7788", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_2_Advanced MultKAN-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_2_Advanced MultKAN-checkpoint.ipynb deleted file mode 100644 index 902191af8..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_2_Advanced MultKAN-checkpoint.ipynb +++ /dev/null @@ -1,251 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c982abca", - "metadata": {}, - "source": [ - "# Interpretability 2: Advanced MultKAN" - ] - }, - { - "cell_type": "markdown", - "id": "6b9ec6c4", - "metadata": {}, - "source": [ - "In the last tutorial, we introduced multiplications to KANs which makes interpretation easier in the case when multiplications are needed. Multiplication nodes by default takes in two numbers, but can take more variables specified by the user. This is done through the mult_arity argument (by default mult_arity=2)." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d8f94f0f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACQS0lEQVR4nO2dd1hU1/b3v1TpRWBEioCA2FBsgKgogt30eGPaTTG5yU29MabYNbFEo0k05aY3TXJjxBorgkgREBEUrICg9N5mhqlnvX/4zvmJUoZhGrI/z5PnXpwze6+955zz3WXttUyIiMBgMBgMhhYxNbQBDAaDwbj3YOLCYDAYDK3DxIXBYDAYWoeJC4PBYDC0DhMXBoPBYGgdJi4MBoPB0DpMXBgMBoOhdZi4MBgMBkPrMHFhMBgMhtZh4sJgMBgMrcPEhcFgMBhah4kLg8FgMLQOExcGg8FgaB0mLgwGg8HQOkxcGAwGg6F1mLgwGAwGQ+swcWEwGAyG1jE3tAEMRm+hrq4ODQ0NcHZ2houLi6HNYTCMGjZzYTC64MiRI4iJiYGrqysCAwPh6uqKmJgYHD161NCmMRhGiwkRkaGNYDCMlY0bN2LZsmUwMzODUqnk/13198aNG/H+++8b0EIGwzhh4sJgdMCRI0cwd+5cta6bPXu2HixiMHoPbFmMweiALVu2wMzMrNNrzMzMsHXrVj1ZxGD0HtjMhcFoh7q6Ori6uqp9fW1tLdvkZzBug81cGIx2aGho0On1DMa9DhMXBqMdnJ2ddXo9g3Gvw8SFwWgHFxcXREdHq7XnEhMTw5bEGIw7YOLCYHTAkiVL2rgft4dSqcTbb7+tJ4sYjN4DExcGowNmz56NDRs2AMBdMxjV3xs3bmRuyAxGOzBvMQajC44ePYqtW7fixIkT/L/FxMTg7bffZsLCYHQAExcGQ00SEhIQHR2N+Ph4TJ8+3dDmMBhGDVsWYzDUxMnJqc3/MhiMjmHiwmAwGAytw8SFwWAwGFqHiQuDwWAwtA4TFwaDwWBoHSYuDAaDwdA6TFwYDAaDoXWYuDAYDAZD6zBxYTAYDIbWYeLCYDAYDK3DxIXBYDAYWoeJC4PBYDC0DhMXBoPBYGgdJi4MBoPB0DpMXBgMBoOhdZi4MBgMBkPrMHFhMBgMhtZh4sJgMBgMrcPEhcFgMBhah4kLg8FgMLQOExcGg8FgaB0mLgyGmhCRoU1gMHoN5oY2gMEwZhQKBbKysnDo0CGkpqbCxMQE69evx4IFCzBz5kz079/f0CYyGEaJCbHhGIPRLlVVVVixYgVSUlIwY8YMhIaGwtbWFqWlpYiLi0NNTQ0++OADxMTEwMTExNDmMhhGBVsWYzDaob6+Hs8//zxqa2tx8OBBbNmyBZmZmfjqq68QEBCAv/76C2+//TbefvttHD161NDmMhhGB1sWYzDugIiwfft2tLS0YPfu3XBzc4NMJkNmZibS0tLw2GOPoV+/fnjkkUdgYWGBVatWYezYsRgwYIChTWcwjAY2c2Ew7qC2thZ//vkn3n77bbi6uoKIwHEc/7nqbyLC7Nmz4ePjg8OHDxvQYgbD+GAzFwbjDgoKCiCTyWBra4uFCxdCoVCA4zhcvXoVAPDf//4XR44cAQBERkZi+vTpSE1NxXPPPWdIsxkMo4KJC4NxB3V1dTA3N4dQKMS+ffsgl8vbfJ6dnY3s7GwAgLW1NebPn4/m5mYQEdvYZzD+P0xcGH0ejuNw8eJFnDhxAvHx8UhKSoKFhQXc3Nzw448/guM4KBQKbNy4EQUFBXj++ecxdepUAICfnx9OnTqF48eP49VXX8WMGTMQFRUFJycnwzaKwTAwzBWZ0SepqqpCQkIC4uPjkZCQgOrqatjY2GDKlCmwsrLC7t27sWHDBixevBgmJiaQSqWIiopCWloavvvuO7zwwgsAgMbGRsyePRtubm64fv06rl27BlNTU4SGhmLGjBmYOXMmxo8fD3NzNo5j9C3YHc/oE0gkEqSlpSE+Ph7x8fHIzc0FAISEhODpp59GdHQ0hEIhVqxYgQsXLiA0NBT//e9/MWnSJISFhd1VHhFBJpNhy5YtMDMzw5NPPokRI0bAysoKycnJiIuLwxdffIEPP/wQjo6OmD59OmbMmIEZM2bA19dXz61nMPQPm7kw7kmICFeuXOGXulJSUiCRSODu7o7o6GjExMQgKioKrq6uuHDhAt577z3ExcUhIiICH3/8McaOHYuPPvoIv//+O5YuXYq5c+fil19+QXFxMRYsWICBAwfik08+wZUrV/Dtt99CoVDws5ahQ4fC398fRIRz587h+PHjiIuLQ3p6OpRKJQICAnihmTp1KhwcHAzdXQyG1mHiwrhnqKur45e64uPjUVFRASsrK0yePBnR0dGIjo7GsGHD+E33kpISrF69Gjt27EBgYCA2btyI+++/n/9cLpdj3759+OSTTyCVShEYGAhbW1tUVFSgrKwMM2bMwDvvvAN3d3cAgFQqxaVLl1BUVARra2uMHDkSXl5efHlNTU38/kxcXByuX78Oc3NzhIeH80toY8aMgZmZmWE6kMHQIkxcGL0WmUyGjIwMXkxycnJARBg5ciQvJhEREbCysmrzvaamJmzatAnbt2+Hg4MDVq1ahUWLFsHCwqLdeoRCIS5evIiEhARs2bIFH374Ie6//354eHjA1PTuo2ItLS3Iy8tDeXk5nJ2dERwcDDc3t7uuu379Ok6cOIG4uDgkJCSgubkZ/fv3R3R0NGbMmIGYmBh4e3trp7MYDD3DxIXRayAiFBQUID4+HidOnEBycjJEIhHc3Nwwffp0fqlLNZO4E5lMhq+//hrr169Ha2srFi9ejLfffhv29vZq1Z+Xl4f58+fj77//xsiRI7u8vra2Frm5uaivr4e7uzuCg4M7XAJTKBQ4c+YM4uLiEBcXh8zMTHAch6FDh/JLaJGRkbC1tVXLVgbD0DBxYRg1DQ0NSExM5GcnJSUlsLS0REREBD87GTlyZLszCBVEhN27d2P58uUoLi7G888/j1WrVsHDw6NbtnRXXFSUlpYiLy8PYrEYvr6+GD58+F2zqTtpaGjAyZMn+SW0mzdv8u2eOXMmZsyYgVGjRnXabgbDkDBxYRgVcrkcZ8+e5cUkKyuLH8GrxGTSpElqj+BTUlLwzjvvIDMzE/PmzcPGjRsxfPhwjWzTVFyAW2dpioqKcOnSJSiVSgQGBiIoKEgtF2XVjE01qzl58iQ/Y4uJiUFMTAxmzJiBgQMHatQuBkMXMHFhGJyioiJeTBITE9HS0gJnZ2dMnz6dFxRPT89ulXnlyhUsXboUBw8exLhx47B582b+4KOm9ERcVMjlcly9ehUFBQUwNzfHsGHD4Ofn160ZiEwmQ3p6Oi82586d4/eaVEtokydPhrW1tUY2MhjagIkLQ+80Nzfj1KlTvKAUFRXB3NwcYWFhiImJQXR0NEaPHq2R11RlZSU++OAD/PDDDxg0aBDWrVuHBQsWaGX5SBvioqK1tRUXL17EjRs3YGdnh+Dg4G4v06mora1FfHw84uLicOLECZSVlcHKygpTpkzhxWbEiBEsNA1DrzBxYegcpVKJrKwsXkwyMzP58x6qmUlkZCTs7Ow0rkMoFOKTTz7B1q1bYWlpieXLl+Pf//43+vXrp7V2aFNcVDQ1NSE3NxdVVVVwcXFBcHAwXFxcNC5Pdb4nLi4Ox48fR1JSElpbWzFw4EB++Sw6OhoCgUAr9jMYHcHEhaETbt68yYvJyZMn0dTUBAcHB0RFRSE6OhrTp0/Xykl1hUKBn376CWvXrkVDQwNef/11vPfee3B2du55I+5AF+Kiorq6Grm5uWhsbISnpydGjhzZI7FVIZFIcPr0aX4J7fz58wBuRSZQzWoiIiK0KsIMBsDEhaElRCIRkpKSeDfhgoICmJmZYfz48fxS19ixY7UWY4uIcOjQISxduhSXL1/GU089hbVr18LHx0cr5beHLsUFuNWmkpIS5OXlQSKRYPDgwRg2bJhWX/yVlZX8bxQXF4eqqirY2Nhg6tSpvNgEBQWxJTRGj2HiwtAIjuOQk5PDz04yMjIgl8vh6+uLmJgYTJ8+HVOnToWjo6PW687MzMS7776L5ORkTJ8+HZs3b0ZISIjW67kTXYuLCqVSicLCQly5cgVEhKCgIAQGBmr95D4RIS8vj3d3TklJgVQqhZeXF2JiYjBz5kxMnz69R8t0jL4LExeG2pSVlbWJJFxfXw87OztMmzaN3zvx8/PT2ai3sLAQK1euxK5duzBy5Ehs3rwZM2bM0NsoW1/iokImk+HKlSsoLCyEpaUlRowYAR8fH521VywWIyUlhV9Cu3jxIkxMTDBu3Dh+VhMeHt5hJAMG43aYuDA6RCwWIzU1lZ+dXL58mX/ZqII/jh8/Xucvm7q6Oqxfvx7//e9/IRAIsHbtWjz99NN6j8Glb3FRIRKJcPHiRZSUlMDBwQHBwcEdRiHQJmVlZW280Gpra2FnZ4eoqChebPz9/dkSGqNdmLgweFTLJKpIwqdPn4ZMJuOXSaKjozFt2jSdbJa3R2trKz7//HNs2rQJHMfhvffewxtvvAEbGxu91H8nhhIXFfX19cjNzUVtbS0EAgGCg4P1lpSM4zicP3+eX0I7ffo05HI5fHx8+IgBLEka43aYuPRxOkqaFRkZyS91BQYG6nV0ynEcfvvtN6xatQoVFRV4+eWXsXz58naDP+oTQ4uLioqKCuTm5qKlpQWDBg3CiBEj9C64QqEQSUlJvMvz7UnSVGLDkqT1bZi49DE6S5qlEpOwsDCDuaaeOHEC7777Li5cuIBHHnkE69evR0BAgEFsuRNjERfg1iyzuLgYly5dgkwmQ0BAAIKCgmBpaWkQe27cuMEvocXHx6OhoYElSevjMHG5x1EdqlO5n7aXNGvatGkGnxW0l7CrvQyQhsSYxEWFQqFAfn7+XYnKDBnQUnVoVuUY0F6StGnTpqkdjZrRO2Hicg/S3aRZhqSrhF3GhDGKi4quEpUZks6SpKmW0FiStHsPJi73AOokzZo4caJRBTJsamrC5s2bsW3bNrUSdhkDxiwuKtRNVGZIWJK0vgETl15IV0mzVOFV9OGu2l1kMhm++eYbrFu3TqOEXYakN4iLiu4kKjMkcrkcmZmZLEnaPQgTl15CQ0MDTp06xbsJa5I0y5BoK2GXIelN4qJCk0RlhqSjJGmTJk3ixYYlSesdMHExUrSdNMuQaDNhlyHpjeIC9CxRmSG5PUna8ePHkZiY2CZJmmoJjSVJM06YuBgRXSXNmj59Ory8vAxtptrcnrBr7Nix+Pjjj3ucsMuQ9FZxUaGNRGWGhCVJ610wcTEgnSXNUrkJa5o0y5BUVlbiww8/xPfffw9vb2+sX79eawm7DElvFxcV2kxUZkhYkjTjhomLHlEqlTh37hy/b6KLpFmGRB8JuwzJvSIuKrSdqMyQqM5zqfZqWJI0w8PERcfoK2mWIdFnwi5Dcq+JiwpdJSozJCxJmuFh4qJlOkuapVrq0mbSLENiiIRdhuReFRdAP4nKDAlLkqZ/mLj0EFW0WNVSlz6TZhmSs2fP4p133tF7wi5Dci+Liwp9JSozJB0lSfP29uaX0FiStJ7DxEUDDJ00y5Bcv34dK1as4BN2bdq0CTNnzrwn23onfUFcVMhkMly+fBnXr19Hv379MHz4cJ0mKjMkXSVJmzlzJsLCwow6eoQxwsRFDbpKmhUdHY0JEybc0zdfXV0dNmzYgK+++sqgCbsMSV8SFxW3JypzdHREcHAwBgwYYGizdApLkqYdmLi0Q2dJs1T7JlOnTkX//v0NbarOMbaEXYakL4qLCkMmKjMkHMchJyeHn9WwJGnqw8Tl/2OMSbMMibEm7DIkfVlcVBhDojJDwpKkqU+fFRdjT5plSO5M2LVu3ToEBgYa2iyDw8TlFsaWqMyQdJUkbebMmfes92RX9BlxuT1pVnx8PFJSUtDa2mp0SbMMyZ0JuzZv3ozw8HBDm2U0MHFpizEmKjMkLElaW+5pcekoadakSZMQExNjVEmzDElvSthlSJi4tI9EIsHly5eNMlGZIenrSdLuKXHpjUmzDElvTNhlSJi4dE5vSFRmSPpakrReLS63J82Kj49HUlJSr0maZUh6c8IuQ8LERT16S6IyQ9IXkqT1anGRyWTw9vaGXC7HxIkT+aUuY06aZQysX78ea9euxXPPPYfVq1f3yoi4hoCJS/dQJSqTyWSYO3cu86DqhIaGBiQkJPBic/PmTaxfvx7vvvuuoU3TGKMXl8zMzE4/5ziuSyFpamqCpaUlIiMjtWma0ZKRkdHhZ5cuXcLly5cxfPhwDBs2rMuywsLCtGmaUZOdnd3p53K5HFVVVRgwYECHS4cXL17EsGHDMG7cOF2YaHTU19d3+jnHcRCJRJ3OiiUSCczNzftUxOLU1FRcu3YNI0aMaPdz1WtZnX2r0NBQrdqmLYxeXIioxxuDERERSExM7DOukh312datW7Fv3z5ER0fj5MmTiImJwYoVKzrsX230fW+iq/ZyHAeFQgFzc/N2BzRbtmzBxYsX8dlnn91zseQ6oqf3iCr46axZs/rUXl9tbS0efPBBhIeHY/ny5RpHEDfmZ7RPrB3l5ub2qRu3PdLS0rBjxw6cOHECa9asQVxcHC5duoStW7ca2rReg6mpKSwtLdsVltTUVGRnZ+OHH35g+wvd4Pz58wgMDOxzS2YuLi5ISEiAv78/YmJisHPnTigUCkObpVXu+ZlLU1MTFi5ciMOHDxutwmubO/uMiGBjY4P6+vo2nnJEhMDAQMTFxcHPz6/Lcu51NG2vqh+vXLkCc3PzPtVvPWlrQ0MDMjMzMWPGDADqLQHdK9zeb1VVVVi9ejWuXbuGDz74AJMmTVK7L4z5XrvnxWXy5Mk4fvw4rK2tjfZH0DZ39tnPP/+MkpISrFy58q5rGxsb4e/vj9ra2rv6x5hvXF2gaXt37twJqVSKRYsW9aic3oimbeU4DgcOHMD8+fP7nCAD7Q8Ac3JysHLlStjb2+PDDz9UKzimMffbPS8u9vb2aGlpMeofQdvc3lYigqWlJWQyWYftf+eddxAcHIx//vOfHZbTF9CkvUSEwYMH4/r16236vK/0m6Z9dvLkSYwcOZLfxO9LfQZ03F6O43D06FGsWbMGDz/8MJYsWdLpkqEx99s9vedSXV2NefPmGdoMgxIbG4ulS5d2egNu3rwZixYtgpGPM4yS1NRU/POf/zTaB9wYuXr1KpycnPqUd5i6mJqaYu7cuUhMTERDQwNmzpyJxsZGQ5ulEff0zGXUqFE4e/YsLC0tjVrhtY2qrUSEfv36QSqVdtn2jz76CB4eHm1mL32pzwDN2hsYGIhr167dtcTRV/qtu22tr69HZmbmXQnm+lKfAeq1l4hw4MABLFmyBFlZWe06ihhzv93TLhpFRUV9xv24PVJSUtQeVb/33nuwtLS8a2mM0TFNTU0YPHiw0T7cxoZMJkNycjLmzZvH+kwNTExM8MADD8DV1RUTJkzAhQsXelWU9ntWXK5fv45nnnnG0GYYlFmzZkEoFKp1rYmJCR588EFcvXoVQUFBOrbs3uDhhx/Gvn37DG1Gr4DjOJw4cQLTpk3rc27HPWXSpEnYvHkzJk+ejDNnzvQaYb5nl8UGDx6M/Px8PuKoMU8ftQ0R4fLly3jnnXdw6NAhtb+nUCjg7u6O2tpavpy+0mdA99pLRAgKCsK1a9d6VE5vR93lncTERAQGBsLLy0vjcu4lNGnvkiVLMGDAALzzzjs9Kkdf3JPiQkRwcnJCU1NTj8rprRAR+vfvj+rq6m4fHnVwcEBTUxO/Z9NX+gzo3j2yZs0azJo1CxMnTuxROb2drtpKRDh9+jQEAkGnCef6Up8Bmr/XBg4ciOvXr/PZP4253+5Jb7F169bhp59+MrQZBkMoFCIwMFCjqARxcXFYtmyZDqy6dyAi/PzzzyyRWhcQEc6ePQtHR0cEBAQY2pxej4mJCTIzMzF16lRDm6IW99zMheM4ODs7o7Gxsc96o4jFYgDQKLc5EcHCwgIKhaJP9Rmg/j2yc+dOiMVi/Otf/+pROfcCHbWViJCZmYl+/fph1KhRvfowoC7oSXs9PT2Rn58PGxsbo+63e25nbdGiRfj999+NtsP1QU+iEZiYmCAwMBBSqbRPe9p1BBFh1apVKCwsNLQpRotUKkVGRgYEAgGCgoL69LOoCzIyMjB16tQuI8YbmntmWYyI8Ndff6GsrAxz5841tDm9mqSkJCxYsMDQZhgdRITFixfjs88+Yy/MdiAi3Lx5E0lJSfDz82PCoiO8vLxQXl4OkUhkaFM6xeiXxZRKJS5evIigoCBYWlretdQF3DqY9f333+PYsWM4duxYu3sNxjx91DbaaKu5uTnkcnmf6TPglrdcQUEBrKys4ObmBhsbG779HMdhx44dOH78OHbu3NnlJnZf6TfVMygUCnH+/Hn069cPwcHBsLKy6nY5faXPgJ63t6ysDA888AAyMzONtt+MflmsubkZ69evR3NzMwYPHgwfHx/Y2NhALpejtrYWN2/eRGVlJebNm9ehsDC6z5AhQ6BQKPpUfyqVSnzxxRdobW1FS0sLBgwYgKCgIFhYWCAjIwM2Njb49ddfjfZhNgQKhQI5OTlobm5GcHAw3NzcWP/oAU9PT1RWVkIqlXZbyPWF0c9ccnJyQESorq5GYWEhPx20sLCAi4sLPD094e/v3yaUfEeEhITo3mAj4Ny5cz0uo6amBjY2NpgyZYoWLOod5OXlAfi/7IlFRUW4fv065HI5RowYgeHDh6tdVl9Jg1xfX4+amhq4urr2OLW4pgmzeiPaeEYrKytha2trtN5jRi8ut59V6Qh1Uh0D6DPZAdXpM3Wn5X2lz4Bbs+TOICI+E2VXfddXEobJ5fJOP+c4Dq2trbC2tu7yGe1Ls+S+8Iwavbh0RU5ODiZPnoyUlJQ+MzPpKdnZ2ZgwYQIyMzMxZswYQ5vTa8jLy8P8+fPx999/95mZSU9pbGxEfHw8oqOj4eTkZGhzeg3Z2dkIDQ3FmTNneu0zes94izEYDAbDeGDiwmAwGAytw8SFwWAwGFqHiQuDwWAwtA4TFwaDwWBoHSYuDAaDwdA6TFwYDAaDoXWYuDAYDAZD6zBxYTAYDIbWYeLCYDAYDK3DxIXBYDAYWoeJC4PBYDC0DhMXBoPBYGgdJi4MBoPB0DpMXBgMBoOhdZi4MBgMBkPrMHFhMBgMhtZh4sJgMBgMrcPEhcFgMBhah4kLg8FgMLQOExcGg8FgaB0mLgwGg8HQOkxcGAwGg6F1mLgwGAwGQ+swcWEwGAyG1mHiwmAwGAytw8SFwWAwGFqHiQuDwWAwtA4TFwaDwWBoHSYuDAaDwdA6TFwYDAaDoXWYuDAYDAZD6zBxYTAYDIbWYeLCYDAYDK1jbmgDGAzGvUdLSwvi4uJw4MAB5OXlYefOnYiIiMBDDz0Ef39/mJiYGNpEo0PVZ8eOHcPly5fBcRx++eUX2Nvb98o+6/Uzl8bGRhARGhsbDW1Kr0HVV6zPukdjYyMUCgXrty7Iy8vDQw89hK1bt2LEiBFYuXIl/vGPf+DGjRt49NFH8fXXX0MulxvaTKPi9j4LCAjA22+/jV9//RVyubz39hn1Ug4fPkzR0dEEgP8vOjqajhw5YmjTjBbWZ5rB+k19CgoKKCQkhJYvX06XLl0ihUJBREQcx1FZWRklJCRQZGQkffHFF8RxnIGtNQ5UfbZixYoO+2zSpEm9rs96pbhs2LCBAJCZmVmbB17198aNGw1totHB+kwzWL+pj0KhoGeeeYZeeOEF2r9/Pw0ZMoR++uknUigUdP36dZo0aRI9+OCDlJSURGPHjqXLly8b2mSDo+qzF198sdM+O3XqFA0ZMqRX9VmvE5fDhw+3ecg7+o+NKv8P1meawfqtexQUFJC3tzfl5ubS6tWrydzcnBwcHGjz5s00ceJEAkDBwcF0/fp1Wr58OX344YeGNtngFBQUkL+/v1p9tmzZMvrnP/9paJPVpteJy/Tp0+8aRd75n5mZGcXExBjaVKOB9ZlmsH7rHgcOHKDQ0FBqbW0lkUhEb731Fpmbm5OpqSkBoBEjRtCFCxeI4ziKj4+nBx54gJRKpaHNNigHDhygiRMnqt1nAwYM6DV91qs29Ovq6pCQkAClUtnpdUqlEidOnEBdXZ2eLDNeWJ9pBuu37lNeXg47OzuYm5vD2toaL7zwAtzc3MBxHExMTLBw4UIMHz4cJiYmcHBwQFNTEziOM7TZBqWlpQW2trZq91l9fT1qamoMbbZa9CpxaWho0On19yKszzSD9Vv3sbGxQUVFBcRiMYqLi/HCCy+goqICLi4uMDMzw8cff4ydO3dCqVTixo0bcHBwgJmZmaHNNiju7u6oqalRu88UCgWam5sNbbZa9CpxcXZ21un19yKszzSD9Vv3cXJyQmFhIVJTU7Fq1SqkpaVh5MiROHLkCF5//XWIxWIsXrwYGRkZiI2NRXR0dK87u6FtRo4cCYlEonafERH69+9vaLPVolcdonRxcUF0dDQSExM7Xa4wMzNDVFQUXFxc9GidcaLqs5MnT3a6BMH67P+QSCTYtm0bTExMQESdXtvX+42IEB8fjy1btuDYsWMwMzPD2rVrsXbtWohEIqxduxYjR47EiBEjYGZmBoVCgatXryI+Ph6ff/65oc03OAKBAM8++yw++OADrFmzptM+27dvHyIjI3vPvWbgPZ9uc+TIEebB001++OEH1mdqkpiYSEOGDCELCwt64oknWL91gEwmox07dtDo0aMJAIWEhNDOnTtp165dBIAiIyMpMTGRJBIJcRxHSqWSKioq6OOPPyYnJyfaunWroZtgFNTU1NC0adPU6rPedq/1OnEh+r+zB3f+x84e3E1JSQn5+PiQq6srO6/RCXV1dbRo0SICQJMmTaKLFy8SETvncieNjY20efNm8vT0JAA0Z84cOnHiRJvDfXPmzCEAZGtrS5MnT6Znn32WFixYQIGBgWRqakpvvPGGAVtgPGRlZfHP5sGDB2nGjBl39VlAQADvOdbb7rVeKS5ERGPHjiVnZ+c2D3xMTEyvUnZdU1VVRUFBQeTj40M3b96kI0eOUExMDOuz2+A4jv744w8SCATk6OhIX3/99V2unqzfiIqLi+mtt94iOzs7srS0pOeff57y8vLuuq6kpITs7e1pzpw5NGXKlDZ9FhYWRgcOHDCA9cbHzz//TFZWVjR+/Hi6ceMGEd26F3/77TcKCQlp02/jxo3rlfdarxSXhoYGMjc3p88//5xqa2spPz+famtrDW2WUVFfX0+jR4+mgQMHUkFBQZvPWJ/doqioiB9lL1iwgMrLyzu9vi/2W2ZmJi1cuJDMzMzI2dmZli9fThUVFR1e/+CDD9LAgQOpoaGBiPpmn3WGVCqlV199lQDQc889R62tre1eV1tbS1euXCFXV1d699139WylduiV4rJz504CQCUlJYY2xShpbm6msLAwcnFxaXd02deRy+W0detWsrGxIW9vbzaavgOlUkkHDx6kqVOnEgAaPHgwff755yQUCjv93p49ewgA7d69W0+W9i7KysooIiKCLCws6Ouvv1YrTtiiRYsoMDCwV8UUU9ErxeWRRx6hCRMmGNoMo0QsFtO0adPIwcGBzp49a2hzjI6zZ8/S2LFjycTEhN58801qbm42tElGQ2trK3377bc0dOhQAkDh4eG0e/duPpBiZzQ2NpKHhwfdf//9vfJFqGuSk5PJ3d2dPDw8KC0tTe3v/f333wSgVw4Se524iMVisrGxoQ0bNhjaFKNDKpXS3LlzydrampKTkw1tjlHR0tJCixcvJlNTUxo9ejSdOXPG0CYZDTU1NbR27VoSCARkYmJCDz30EKWmpnarjFdeeYXs7Ozo5s2bOrKyd8JxHH3xxRdkbm5OU6ZM6XRJsT1aW1vJzs6uV8Zh63Xisn//fgLQq6KD6gO5XE4LFiwgS0tLOn78uKHNMSoOHTpEPj4+ZG1tTZs3byaZTGZok4yCq1ev0ssvv0zW1tZkbW1Nr7zyCl27dq3b5aSmppKJiQlt375dB1b2XsRiMf3zn/8kAPTmm29qfN/94x//oLFjx2rZOt3T68Tl2WefpaFDhxraDKNCqVTSs88+S2ZmZrRv3z5Dm2M0VFZW0sKFCwkAzZgxgwoLCw1tksHhOI5SUlLowQcfJBMTExIIBPThhx9STU2NRuVJpVIaMWIEhYaGqrV81lcoKiqiMWPGkLW1Ne3YsaNHZf3xxx8EgIqLi7VknX7oVeIil8vJxcWFli5damhTjAaO4+i1114jExMT+u233wxtjlGgVCrpu+++IycnJ3J1daWdO3f2+X0AhUJBf/31F4WFhREAGjZsGH3//fcdeiupy7p168jc3JzOnz+vJUt7P8ePH6f+/fuTn58fZWdn97i8pqYmsrS0pM8++6znxumRXiUuCQkJBICtl9/G0qVLCQB98803hjbFKLh8+TJFRkYSAHr22Wf7vAtsS0sLbd++nfz8/AgARUVF0d9//62VsO1Xr16lfv360fvvv68FS3s/HMfRRx99RKampjRr1iyqq6vTWtlz5syhqVOnaq08fdCrxOX1118nLy+vPj8KVaE6Pc5CaRBJJBJau3YtWVpaUkBAAMXHxxvaJINSXl5OS5cuJWdnZzIzM6MnnniCsrKytFY+x3E0bdo08vf3J7FYrLVyeyvNzc30yCOPEABavny51pcIv/32WzI1NaXq6mqtlqtLeo24cBxH3t7e9NprrxnaFKPg888/JwC0Zs0aQ5ticJKTk2nYsGFkbm5Oy5cv79Mvu9zcXHr22WfJwsKC7O3tafHixfwJcG3y448/EgCKi4vTetm9jStXrtCwYcPI3t6e9uzZo5M6KisrycTEhH788UedlK8Leo24nD17lgD0+REpEdFPP/1EAOjtt9/u07O4hoYGeumll/gzGbm5uYY2ySBwHEdxcXE0a9YsAkCenp708ccfU2Njo07qq6qqImdnZ3r66ad1Un5vYu/evWRvb09Dhw7VuQfr5MmT6b777tNpHdqk14jL8uXLqX///iSXyw1tikHZtWsXmZqa0ksvvdRnhYXjONq1axe5u7uTvb09ffnll70m9as2kUql9Ouvv94VmVjXrtZPPPEEubi49KolGm2jUCho+fLlBIAefvhhvRzG3bp1K/Xr149aWlp0Xpc26DXiMnz4cHrmmWcMbYZBOXToEJmbm9OTTz7ZJ1+mREQ3btyg+fPn8w91aWmpoU3SOw0NDbRp06ZOIxPrClXKi19++UXndRkrdXV1NHv2bDI1NaWNGzfqbZB3/fp1AkB//fWXXurrKb1CXK5evUoA+vQZjpMnT5KVlRU9+OCDfXL2plAo6LPPPiNbW1vy9PSkvXv3GtokvaNuZGJdIRQKydfXl6Kjo/vsrDknJ4f8/Pyof//+dOzYMb3XP3r0aHriiSf0Xq8m9Apx+eijj8ja2ppEIpGhTTEI6enpZGdnRzNmzCCJRGJoc/ROdnY2jR8/nkxMTOi1116jpqYmQ5ukV7obmVhXLFmyhKysrCg/P1/vdRsDO3fuJGtraxozZgwVFRUZxIbVq1eTo6MjSaVSg9TfHXqFuISFhdFDDz1kaDMMQk5ODjk5OdHkyZO7jEp7ryESieidd94hMzMzGjlyZLcC/vV2NI1MrCuysrL4ZaC+hkwmozfffJMA0NNPP21Qb8ScnBwCQEePHjWYDepi9OJSWlpKAOjXX381tCl658qVK+Tm5kbjxo3TmeePsXL06FHy8/Ojfv360YYNG/pMPLCeRCbWFXK5nMaNG0fBwcF95ndQUVlZSZGRkXz+KEMvB3IcR35+fvTSSy8Z1A51MHpx+fLLL8nc3Jzq6+sNbYpeKSoqIi8vLxo+fLjGcZ96I1VVVfTkk08SAJo+fbpGgRR7I9qITKwrPvnkEzIxMaH09HRDm6JX0tLSyMPDg9zd3Y0qyvjixYvJ3d3d6J16jF5cYmJiKCYmxtBm6JWysjIaPHgw+fv7d5kd8V6B4zj66aefqH///uTi4kK//PKLwUeJ+kBbkYl1RVFREdnY2NDrr79uaFP0Bsdx9PXXX5OFhQVFRERQWVmZoU1qQ3JyMgEwmsFHRxi1uNTX15O5uTl9+eWXhjZFb9TU1NDw4cPJy8ur10VB1ZRr165RVFQUv6Z9r5+f4DiOkpOTtRaZWFdwHEdz5swhLy+vPpNUrbW1lRYtWkQA6JVXXjHKjXOFQkECgYCWLFliaFM6xajF5ddffyUAfeYsQ2NjI40dO5YEAgFdvXrV0OboHKlUSuvWraN+/frR4MGD7/k8NHK5nHbt2qX1yMS64n//+x8BoP379xvaFL1w48YNGj9+PPXr149++uknQ5vTKS+++CL5+/sb9ezeqMXloYceorCwMEOboReEQiFNmjSJnJ2d+0T48tOnT9OIESPIzMyM3n///XvazVyXkYl1RX19PQkEAnrkkUcMbYpeSEhIIFdXVxo0aFCvSA9++PBhAkAXLlwwtCkdYpTiwnEctbS0kLW1NX300UeGNkfrcBzX5sXS2tpKM2bMIDs7O8rIyDCgZT3nzrbdSWNjI73yyitkYmJCoaGhlJOTo0frekZXbbsTXUcm1ja3t++FF14gBwcHo9tv0BSlUtnuKJ/jONqyZQuZmppSdHS00S1NdoREIiF7e3tau3Zth20zNOYwEhQKBbKysnDo0CFcvHgRN2/eRGtrKywtLVFfX4/+/fsb2sQecWf7pFIpPD09MWXKFPz+++9ITk7G0aNHERoaamhTu01HbYuKisLMmTP5327v3r147bXX0NzcjG3btuGVV16BmZmZga3vHHXbdjt5eXnYunUrfvvtN1hZWeHFF1/Em2++iUGDBhmgBZ3TXvtMTU1x8OBBbNmyBR4eHoY2UWNaWloQFxeHY8eOoaysDLa2thg/fjweeugh+Pv7QyQSYdGiRdi1axfee+89rFu3DubmRvNK7BSZTIZRo0Zh+/btOHPmzF1tMzExMbSJMCEiMrQRVVVVWLFiBVJSUjBjxgyEhobC1tYWJSUlOHHiBGpqavDBBx8gJibGKDqtu3TUvtLSUhw9ehQJCQlYsWIFli1b1uva11nb4uLiUFNTg9dffx1//vknDhw4gPvuuw9ffvklvL29DW16l6jTNtV9CQDx8fHYsmULjh07Bi8vL7z55pt48cUX4ejoaOCWtE9nz93Ro0fR0NDQa5+7vLw8/Oc//0FrayseeOABBAQEQCwWIz09HSkpKXjooYfw119/obi4GD///DMeffRRQ5usNqq2iUQiPPDAAxgyZEibtr300kt44YUXYGFhYVhDDT11qquro7lz59KDDz5I+fn5JJVK6Y033qCYmBg6fPgwSSQS+uuvvyg4OJgOHz5saHO7zb3cPnXapope7OzsTLt37zbK6Xt7dOd3e/vtt/Uembin3Mv3ZUFBAYWEhNDKlSupsbGRsrOzaebMmfTaa6+RRCKh7OxsmjBhAgkEAr3GZtMGXbUtJyeHIiMj6YsvvjD4s2ZQceE4jlavXk1Tpkyhqqoq4jiOJBIJTZw4kQDQd999x1+3b98+Gj9+PFVWVhrS5G5xL7evO23bu3cvjR079p5s2549e8ja2pqmT5+ut8jEPeVevi8VCgU988wz9K9//YuPw5eQkEDm5uYUGhpKEomEOI6j3NxcCgkJ0XkOFm2ibtsuXrxIY8eONXjbTA05a6qtrcWff/6Jt99+G66uriAicBzHf676m4gwe/Zs+Pj44PDhwwa0uHvcy+3rTtvmzJkDPz+/e7Jtc+fOxdy5c/HUU08hOjq6Vywf3cv3ZXFxMVJSUvDGG2/AwsKCb4cK1d/Dhg3D/PnzsXv3bgNa2z3UbVtQUBDmzp1r8LYZdPeqoKAAMpkMtra2WLhwIRQKBTiOw9WrVwEA//3vf3HkyBEAQGRkJKZPn47U1FQ899xzhjRbbe7l9rG29c62Afd2+y5dugSBQICLFy9i5cqVAG6JqVKpRH5+Ph5//HGYmppi0KBBmDlzJr799ltwHAdTU4OOs9Wit7XNoOIiEolgaWkJoVCIffv2QS6Xt/k8Ozsb2dnZAABra2vMnz8f1dXVIKJeMULUpH0tLS29on2sbb2zbcCt9llYWNyT7ausrISNjQ2Ki4uxd+/eNp81NDRg//79AIARI0bgoYcegkgk6hXiIpfLcf78+V7VNoOKi0AggFgshpubG3788UdwHAeFQoGNGzeioKAAzz//PKZOnQoA8PPzQ1JSEo4cOYLg4GBMnDgREydOxKRJkzBkyBCjvOk1ad+VK1cQGxuLadOmwdXV1cAt6Jjuti05ORn9+/fvFS8oZ2dniESibrXN09PT6NslFApRWlqKwsJCtLS03BPtUyqVOH/+PJKSkpCYmIiMjAz0798fU6dOxS+//AIAuHz5MjZv3gxfX18sX74c5ubmcHJyQnV1NQQCgVG6w7e0tCAzMxMZGRk4c+YMsrKy0NLSAg8Pj97TNr3t7rSDUCikiRMn0ieffMJvhLa3sUh0K7VrREQErVq1it59912aPHky2dvbk62tLXl7e9Njjz1Gn332GZ05c8ZoPHW6276wsDAaPXo0ubm5kZubG0VHR9O6devo9OnTRtMmFWlpaeTs7Exbt25Vq20TJ06kTZs2UXJyMl2+fJnq6uqMbvO7paWFsrOz6Y8//qCgoKBu3Zf/+9//SCwWG12bRCIRXb16lU6cOEG7d++mffv2UWJiIo0bN07t9k2aNImOHDliqCbcRUVFBf3555/0yiuv0KhRo8jHx4dGjRpFr7zyCn377bcUFBREx48f59t256Y30a0cLU8//TT98MMPhmwKT2VlJe3bt4+WLVtG06dPJ3d3dxIIBDRs2DB67rnn6Ouvv6b4+HgaNmxYr2mbQWcutra2eOutt7Bs2TJMnDgRYWFhd11DRJDJZNi6dSvc3d3x/vvvw9raGsCtkdiZM2eQlpaG1NRUrFu3Dq2trbC2tsaECRMQERGBiIgIhIaGws7OTt/Ng62tLSZMmIAtW7ao1T5PT0/s3LkTQqEQp06dQkJCAnbu3Ilt27bBzs4OkydPRnR0NKKiogx2IK+5uRmbN2/Gb7/9Bl9fX3z55ZeIiIjosm0DBw7EokWL0NLSgpqaGlRVVcHc3Bxubm5wc3ODk5OTwUbG1dXVyM/PR2VlJfr164fRo0dj1apVWL16tVq/m0AgwKRJk9DQ0AAzMzPY2NjA1tbWYMsRra2tKCsrQ0lJCerr62FmZgZ3d3cMHToU7u7uMDMzw3vvvafWc7dlyxY4OTkhPDzcAC25hVQqxZkzZ5CUlIRTp07h2rVrMDU1xejRo/Hcc89h6tSpGDVqFD9KV53PGTlyJNzd3e8qj+M47N27F/n5+fj000/13RwQEQoLC5GRkYGMjAykp6fjxo0bAABfX1+Eh4dj0aJFCAsLw+DBg9s8F88++2yXbdu3bx+uX79ukLbdjsEPUcrlcnz00Uf4/fffsXTpUsydOxe//PILiouLsWDBAgwcOBCffPIJrly5gh9//BF+fn6dlpWTk4O0tDScPn0ap0+f5h+uUaNG8ctoEydOhEAg0Hnbdu3aheeffx4jRoxAc3OzRu3jOA65ubk4efIkEhISkJmZCaVSCX9/f0RFRWH69OmIiIiAjY2NTttCRNi3bx/WrVsHiUSCJUuWYOHChdiyZYtGv51QKERNTQ2qq6shkUhgYWEBNzc3CAQCvRw6VCqVKCkpQX5+Ppqbm+Ho6IjAwEB4e3vD1NRUo/tSoVBAJBJBLBYDuLVfYWdnp5dT31KpFKWlpSgtLUVtbS1MTU0xYMAAeHt7Y+DAgXfZoG77Ll++jE8++QQDBw6ElZUVHBwcdL7UQkQoKirCqVOncOrUKaSnp0MikWDAgAGIjIzE1KlTMXnyZDg5ObX7faFQiH//+98oKyvDhg0bYGdnh++++w5eXl545plnsGvXLqxZswZeXl5ISkqCg4ODTtsjl8tx8eJFpKen84JSV1cHU1NTjBgxAuHh4QgNDUVYWBgGDBjQaVnqtO3HH3/EF198gYiICJ22qysMLi7Arc7ft28f1qxZAwsLCwwdOhR2dnYoLy9HaWkpZsyYgXfeeaddpe4MIsK1a9d4oUlLS0NxcTEAwN/fn5/ZRERE3DVC6Cl79+7FM888g4ULF+Lzzz/HgQMH8Mknn0AqlWLIkCEat6+5uRkpKSk4efIk4uPjUVpaCktLS4SHh2P69OmYPn06goKCtNqWwsJCrFixAmlpaZg/fz5WrlzJPwSq364nbWtpaUF1dTVqamoglUphaWkJgUAANzc3rT/4EokE169fx/Xr1yGVSjFw4EAEBgbCzc3trms1bRvHcRCLxRCJRFAqlejXrx9sbW1hZWWl1bbIZDKUlZWhtLQUNTU1AG7thXl7e8PDw6PLE9rdaV9rayuam5tBRLC3t4etra1W2yIUCnH69GkkJiYiKSkJpaWlsLCwQGhoKKZOnYrIyMhu3dctLS3Yvn07/vjjDwgEAvj5+UEsFuPatWsYNGgQHnvsMbzxxhsYOXIkDhw4oNWVDZFIhHPnzvFicvbsWbS2tqJfv34YN24cwsLCEBYWhvHjx8Pe3r7b5XfUtqysLDg7O+Pbb7/F6NGjtdYeTTEKcQFuvTQPHjwIZ2dn1NXVQSKRwNPTE6NGjYKHh4fWlhjKy8vbzGzy8vJARBAIBG1mNsHBwRqPOP/++288+eSTePjhh/H999/zIz2hUIiLFy/i2rVrWmmfanqdkJCAkydPIjU1FRKJBAMHDkRUVBSioqIQGRkJZ2dnjdohkUjwxRdf4Ouvv4anpyfWrVuHKVOmtHutttrW1NSEmpoa1NTUQCaTwcrKip/R9OQF0NjYiPz8fJSWlsLU1BS+vr7w9/dXq0xN20ZEkEgkEAqFkMvlMDc3h62tLWxsbDQWf7lczr/8q6qqQERwc3PjBaVfv37dLlPd9nEch5aWFojFYlhYWMDR0VHjECMcx+HSpUv87OTcuXNQKBTw8/PjxSQ8PLxHM3IiQmVlJbKzs/nYYiNHjsTQoUNhaWmJM2fOYO7cuRgzZgz279+vcV21tbU4c+YMLya5ublQKpVwcnJCaGgowsPDER4ejlGjRmktJEt7bdu0aROGDh2KP//8Uyt19BSjEZfLly+joKAA8+bN0+tadXNzM9LT0/l9m6ysLEilUtja2iIsLIwXnPHjx6t18x07dgyPPfYY5s+fj59//lmvgfCkUinS09ORkJCAhIQEXL16FaamphgzZgw/qwkJCVFrWePkyZNYtWoVKisr8corr+Df//631kfenUFEaGpqQnV1NWprayGXy2Ftbc3PaNQZORMRKioqkJ+fj9raWtjY2CAgIAC+vr56j7skk8kgEonQ2toKU1NTfl9Gnd9CoVCgoqICpaWlqKysBMdxcHFxgbe3Nzw9PfX6uwC3BK6pqQlyuRw2Njawt7dX65mtq6tDUlISv3dSX18PW1tbRERE8IKi773E1NRU3HfffQgLC8PevXu77Esiwo0bN9oscRUWFgIAvLy8EB4ejrCwMISHhyMgIECv77ItW7Zg48aNKCkp0fkyuToYjbicOHECjo6OmDBhgkHtkEqlyM7ObrOU1tTUBHNzc4wZMwYTJ05EREQEJk6cCBcXlzbfjY+Px4IFCzBjxgzs3LnT4IHjysrKkJiYiISEBCQlJaGpqQlOTk6YOnUqpk+fjqioqLuWdCoqKvDBBx/gyJEjmDx5Mj788MNO97n0ARGhoaEBNTU1qK2thUKhgK2tLT+jUTl4qJDL5bhx4wYKCgogEong6uqKgIAAeHh4GNydVqlU8vsyHMfB2toatra2sLS0vOu6yspKlJaWoqKiAkqlEs7OzvD29oaXl9ddbTYEIpEILS0tMDExgYODw102KRQKnDt3jp+d5OXlAbh1DiMyMhLTpk3D2LFjDf6cJCUl4f7778eUKVOwe/fuNrM/pVKJS5cuIT09HWfOnEFGRgaqqqpgYmKCoUOH8mISFhZm8AjSBQUFCA4Oxp9//on777/foLYARiIuQqEQx48fR3h4uMF/oDvhOA6XL1/mZzanT59GWVkZACAoKIjfszExMcErr7yCqKgo/P777xotT+gShUKB7Oxs3jEgOzubD4MRFRWFadOm4cqVK/j8889hY2ODVatWYf78+QZ/Gd8Jx3FoaGhAdXU16urqoFQqYWdnB4FAABsbG5SWlqK4uBhKpRLe3t4ICAjQeFlQlxARvy+jUChgaWkJa2trNDU1oaysDOXl5VAoFHB0dOQFRdv7HNpAqVSipaWFT4/R0tKC1NRUnDp1CqmpqRCJROjfvz8iIyP5/4zx/FZCQgIefPBBREVFYfHixTh37hwyMjKQmZkJoVAICwsLjBkzht98nzBhQocOBYZkwoQJGDFiBH7++WdDm2Ic4nL16lVcvXoV8+bNM8oDTXdy8+bNNvs2Fy9eRGtrK2xtbfHggw8iMjISEydOxPDhw422PQ0NDby78+HDh1FSUgKlUolhw4bhpZdewpw5c7Tu5KBtOI5DXV0drl69itzcXNTU1MDBwQHBwcEYP3680Ya6vx0i4r3WVL+BaqY1aNAgjTZ89Ulra2ubpdgbN27AwsIC48ePx9SpUzF16lSMGDHCaE/ANzQ0IDMzE+np6fj7779x9uxZWFpawtPTk5+RhIWFYcyYMUY3YGyPDRs2YNu2bbh586bB7TUKcUlISOD3OHob6enpmD9/Pnx9fRETE4PMzEycO3cOcrkcDg4OCA8P5/dtxo4dq/f18c5obGzEpk2b8Pvvv2Pw4MGIiIjAlStXkJGRAZlMhkGDBiEqKgrR0dGYPHmyQc4KdQTHcSgpKUFBQQEaGxtha2sLFxcXWFpaoqmpCUQER0dHCAQCuLq63rXsZEiICLW1tSgtLUVZWRm/x+fu7g5nZ2feVtW+jDElsFJ5YKr2Tc6cOQOZTAZPT09ERkYiLCwMI0eOhIODAxwdHQ3+gruT0tJSfr8kPT0d165dAwAMHDgQYWFhsLKywnfffYeHHnoIv/zyi1H1vTpcunQJ48aNw549ezBnzhyD2mJwcRGJRDh27BhCQ0Ph5eVlSFO6zdmzZzF//nyMHj0ae/bs4ZctWltbkZWVxc9s0tPTIRQKYWlpibFjx/JLaeHh4QaZWhMR9uzZg/Xr10Mmk+Hdd9/Fk08+yc+yRCIRUlNT+SW0oqIimJubIzQ0lD9bY6jRqFQq5V2JJRIJ3N3dERgY2ObckkKhQF1dHaqrq9HQ0AAigrOzM9zc3ODq6mqwNf66ujr+LIpEIoGNjQ28vLzg5eXVZumO4ziIRCI+NpSVlRVsbW0N9qJuampCSkoKTp06haSkJP6waXh4OD87uX2Wq1Ao0NzcDKlUqrezMe2hCsZ5++Z7eXk5ACAwMLDN5ruXlxdv//79+/H444/jsccea+Pt2RsgIoSEhCAsLAzffvutQW0xuLjk5+fj0qVLmDdvXq8aJeTk5GDu3LkYNmwY9u/f3+moXqlUIi8vr82+jWpTcPjw4W1coHUtsNeuXcOKFStw5swZPPDAA1ixYkW7Zzxup7i4GCdPnsTJkyeRlJQEsVgMV1dX3t05KirqLucGbdPU1ISCggLcvHkTJiYm8PHxQUBAQJfLRnK5HLW1taiurkZjYyNMTEzg7OwMgUAAFxcXnd9zDQ0NvKCIxWJYWVnxgtK/f/9Olx2JCK2trRCJRLwrs52dHaytrXW6XKlUKpGbm8ufOcnJyQHHcRgyZAh/iHHChAldzsJ1fTbmTmQyGXJycvjN9zNnzvDOOKNGjeLFJDQ0tMu06bt378bTTz+Np59+Gl9//bXRLuu1x5o1a/DNN9/g5s2bBnWWMLi4JCYmol+/fpg4caIhzegWeXl5mD17Nvz9/XHw4MFuH/QjIhQXF/Mzm9OnTyM/Px8AMGjQIN4jLSIiAkFBQVq5scViMT7//HN899138Pb2xrp16zBp0qRulyOTyZCZmcnPavLy8mBiYoJRo0bxs5px48Zp5aZW+fIXFBSguroa1tbW8Pf3h5+fn0bLXDKZjD9D09TUBBMTE7i4uMDNzQ0uLi5aG6E2NTWhtLQUJSUlEIlE6NevHzw9PeHl5QVXV1eNhEEmk0EoFEIikcDU1JQ/L6Mtm6uqqvilrpSUFDQ2NsLBwQGTJ0/m3YQHDhzY7XKJCC0tLRCJRDA3N4ejo6PWliibmppw9uxZflZy7tw5PpXA+PHjeTEZO3asRt51f/zxB5577jksWrQIX3zxhVHvP97O+fPnER4ejoMHD/IpuA2BQcWltbUVR44cwfjx4w0WK6u7XL58GbNmzYK3tzcOHTqktWWtmpoa3kkgLS0NOTk5vPvp7e7PY8aM6fbDGRcXhzVr1qCmpgavvfYaXn75Za094NXV1UhMTORnNvX19bC3t8eUKVN4sfH29u5WmQqFgnclFgqF6N+/PwICAuDp6am1EaRUKuXDz7S0tMDU1LSN0HS3npaWFl5QWlpaYGFhAU9PT3h7e8PNzU1rL6Y7Q8xYWVnBzs6u22KuGiSolrquXLnCDxKmTZuGyMhIjB49WmszO03PxtxORUVFm8OKly5d4g+Rqpa3QkNDMWLECK3Z/euvv+LFF1/Ev//9b3z66ae9QmCICMOHD0d0dDS++OILg9lhUHEpLCxEbm4u5s2bZ3Bfd3XIz8/HzJkzIRAIcOTIkS6n1j1BJBIhMzOTn9mcOXOGX1YZP348P7MJCwvrcGmovLwcq1evRlxcHKZOnYoPPvgAPj4+OrOZ4zhcuHCBjxhw9uxZKJVKBAQE8OdqIiIiOhxFisViFBYWoqioCAqFAp6enggMDNRpPwO3IhGows8IhUKYmZnBxcUFAoEAzs7OHb4ERSIRLyiq5RcPDw94eXlhwIABOl1KuTPEjKWlJezs7DpcqlLNllVikpaWhtbWVri5ufH7JpMnT9a527ZYLEZzczNMTExgb2/f4WE/IkJBQUGb/ZKbN28CAAYPHtwmHpefn59OX/rff/89Xn31VbzxxhvYvHlzrxCYZcuWYceOHSguLjbYnpFBxSUpKQlmZmYaLc/om8LCQsyaNQuOjo44duyY3n315XI5Lly40MYFWhWgUJXfRrVv4+rqiu+//x7btm2Dg4MDVq1ahblz5+r9oVBtBKvERhUHbeLEiXzEgCFDhqC+vh4FBQUoKyuDubk5/Pz84O/vb5BTxmKxmJ/RiMVimJubw9XVFQKBAE5OTpBIJLygqKIgDxw4EF5eXnzEYX2jCjEjk8lgZmbGL5m1trbi9OnT/CHGkpIS3jFDdYhR23Ho1IHjODQ3N/NnYxwdHUFEyM3NbSMmDQ0N/P19u1twV3uEuuDrr7/Gm2++iSVLlmDdunVGLzCZmZmIjIzEsWPHEBkZaRAbDCYuUqkUhw4dwtixY+Hr62sIE9SmuLgYs2bNgrW1NY4dO9Zl5FJ9oBrZ3b5vU1RUBI7jYGZmBhMTE8TExGDVqlUYPXq0wR8GIkJ+fj6/fJaamorW1lY4OTlh6NChGD9+PB544IEexXTTNiKRCNXV1byY1NfX855ngwcP7jDisKGQSqXIysrCqVOnkJaWhtzcXHAcd1e8LmM4jCkUCpGeno5Tp04hKysLubm5kEqlsLa2xrhx4/j9knHjxhmNC/z27dvxzjvvYPny5Vi1apWhzekUIsKQIUNw33334ZNPPjGIDQYTl6KiIuTk5GDevHlGdQbhTkpKSjBr1iyYm5vj2LFjGm1q6oP6+nosX74csbGxcHBwgL29PQoLC8FxHFxdXflltIkTJ2p1Lb27yGQyFBUV4fLlyzh//jz//4uKimBqaoqxY8fys5rRo0cbbEovlUpRXl6OkpIS1NbWorW1FRYWFrCwsICDgwNsbGz48DO6DtneGfX19W3iddXV1cHa2hqhoaEYP348wsLCEBAQYFBXZuDWnqLqbMmZM2eQl5fHB3ccN24cRo0axdtrzAdHt27dimXLlmHNmjVYunSpoc3plHfeeQexsbEoKCgwiLebwcQlJSUFADB58mRDVK8W5eXlmDlzJogIx44dM8pzOBzH4a+//sLGjRvBcRzef/99LFy4EKampmhpaUFGRgY/szl79iwkEgmfxEwlOBMmTND5aLalpQUFBQW4ceMGiIh3JVa9mMvKyngPtKSkJDQ3N8PZ2ZmPgzZt2rRup1zoLqqIwyUlJaiurgYAuLm5wcvLC56envwgqLm5md+jkclk6NevHy80un4xquJ1qcREFdV7+PDh/N6JyltP5cosFAqhUChgYWEBW1tbnbsyq/KxqJa3MjIycP36dQC3vCFVm+8q4TMxMYFSqURTU5PBz8aow8aNG7FmzRqsX78eS5YsMbQ5HZKamoqYmBicPHnSIMneDCIuMpkMhw4dQkhIiMGDInZEZWUlZs+ejdbWVhw/flynG+GacuXKFSxfvhxZWVl45JFHsGzZsk7Pm8hkMmRnZ7fZt2lsbISZmRlCQkL4mc3EiRO1tq5dVVWF/Px8VFVVwcrKincl7mwUrXqBqsQmJyeHf4GqPNDCwsK0MuNVRRwuKSlBVVUVP9NTnUXpzE5V5GaVe7NcLoeVlRUEAgEEAoHWBLusrIzfN0lNTYVQKISzszOmTJnCL3d19XtJpVKIRKI2rszaypapUChw8eLFNp5cNTU1/Dmu28+XdDXzl0gkaG5uBsdxsLOzM5olsTtZu3YtNmzYgI8//hhvvPGGoc1pF1VSwcceewybNm3Se/0GEZcbN24gKysLc+fONapwKCpqamowa9YstLS04NixYxg8eLChTWqDSCTCZ599xmdAXLdunUYjE9UJ5tsjQKs8cgIDA9skU/P19VV7tKtUKnHz5k3k5+ejpaUFTk5OCAwMhJeXl0Yvs/r6+jbuzqozL7e7O3dnkKKKOFxSUoLKykoolUr079+fD2GvyZkIIkJjYyOfIkChUMDGxoZPEdAd54TW1lZkZGTws5PCwkKYmZlh7NixfPDHkSNHajSyby9bpq2tbbe8NVtbW+9KhiUSifgIFKqN9wkTJmi0ZKjLszHagoiwYsUKbNmyBdu2bcPLL79saJPa5c0338TRo0d5V3N9YhBxOX36NBQKhcG8GDqjrq4Oc+bMQW1tLY4dO4bAwEBDm8RDRDh+/DjWrFmD+vp6vPnmm3jxxRe16sZdWlrKRxJIS0vjzxK4u7u38Uhr7+XW2trKuxLLZDJ4eHggMDBQq551RIRLly7xs5qMjAzI5XL4+PjwQtNeHDSO41BVVYWSkhJUVFRAoVDAycmJjzisTc80IkJ9fT2fIkCpVMLW1paf0dw5oFI5O6jERBXbzcPDg1/qioiI0OreTneyZdbX17eZlVy4cIGP2KxyBw4LC0NISIhWReD2szHW1tZwcHAwqpPyRIT33nsP27Ztw5dffokXXnjB0CbdxcmTJzF37lykpqZi7Nixeq1b7+Iil8tx6NAhBAcHw9/fX59Vd0lDQwPmzp2L8vJyHD9+HEFBQYY2iaekpASrV69GQkICpk+fjrVr13b7cKImNDY2Ij09nZ/dqE5B29nZITw8HBEREQgODoatrS1qa2thZmbGuxLrwytJJBLxaZ8TEhJQXFzMp8edNm0aRo8eDVtbW1RUVPDBRFWCoo8lF47jUF9fz6cI4DgO9vb2sLKyQn5+Pk6fPo2kpCRUVFSgX79+CAsL4w8x+vv763y0qcqWKRKJeFfmhoYGXLhwgd8vUUWP8PDwaLNfoq3oEV0hFovR0tICAJ2ejTEERIS33noL//3vf/Htt9/imWeeMbRJbVAoFPDx8cHzzz+PDz/8UK91611cbt68ibNnz2LOnDlGkfBIRXNzM+bNm4fi4mIcPXoUI0aMMLRJAG6J8XfffYft27fD2dkZa9aswcyZMw3mWiyRSHDu3Dn+ha463Glubo7g4GBMmzYNkydPxsSJEw2SR+X69es4ePAgjh8/zjswODk5YdKkSZgzZw7mzp2r8zho7aFUKnH+/HkcOXIEiYmJuHjxIjiOg4+PDyIjIzF79mxMmjRJ78vESqWSj4SdmpqKjIwMVFZWAgCGDBnCR4cICwszqEPLnWdjHBwcjObgNRHh9ddfx/fff48ff/wRTzzxhKFNasO///1vJCcnIzc3V6/vDb2LS3p6OiQSCaZNm6bPajtFKBTivvvuw7Vr13DkyBGMGjXK0CYBuNVXK1asQFFRERYtWoQ333zT4GcU5HI5iouLUVBQALFYjP79+4PjuDZnbioqKgAAw4YNa+MCrasQP0TUJuKwVCqFjY0N3N3dUVlZycdCu3jxIkxMTDB69Gg+YsC4ceN05pZdXV3NL3UlJyejsbER9vb2mDx5MiZPnswvLarOzzg5OfEpAnT14lRlWlXNSjIzM9Hc3AwLCwuMHj0a4eHhGD9+PEaMGAFLS8tOs2UaAplMhqamJj4bqb29vcHPcAG3xO/ll1/Gjh07sGPHDjz66KOGNonn2LFjePDBB3HmzBkEBwfrrV69iotCocChQ4cwfPhwo9nLEIlEePDBB5Gbm4vDhw/rfV2yPerq6rB+/Xrs2bMH48aNw/r16zF06FCD2iQUCnlXYo7j+CyPd8ZWU+UYv90j7erVqwBu5Ri/fd9m2LBhPVpWqa+v5wWltbUV1tbWbSIO30lVVRWf9jkxMRENDQ1wcHDAlClTeLHpyehcJpPh7NmzSEpKQmJiYpt4XapowiEhIXeJmUKh4CM3NzQ08JGbVSkCeiJ+jY2NyMzM5MUkOzsbcrkcdnZ2mDBhAh9Gpb1cQ3dmy7SwsOBDzBjyhU5EEIlEEAqFMDU1hYODg1E4BimVSrzwwgv4888/8ccff+CBBx4wtEkAwOdmevXVV7Fy5Uq91atXcSktLcWZM2cwa9Ysg4/AgVtruY888gjOnTuHgwcPIjQ01KD2cByH//3vf/joo49gamqKpUuXYsGCBQbdxKypqUF+fj6/JzB48GAMHjy4Ww9zbW0tv2+TlpaG7OxsfkP49gjQ6mT7a2xs5AVFFXFYJSguLi7d8mg7f/48v1eTlZXFh5VXOQZMnDixy3YWFxfzs5O0tDQ+HcHt8bq6ExtNLpfzrs2qFAH9+/fnUwR05SFWXl7OH1bMyMjAlStXQEQQCARt8r13N0uqVCqFUCiEVCptE2LGkPfm7Wdj+vXrB0dHR4OfjVEoFHj22Wexb98+/Pnnn5g3b55B7VGxaNEiZGdn49y5c3qrU6/icubMGQiFQkyfPl1fVXaIRCLBggULkJ6ejv379yMiIsKg9ly6dAnLli1DTk4OFixYgKVLl+o8YGNHKJVKPstjU1MTHB0dERAQAG9vb608vCKRCFlZWbxHWkZGBi8U48aN42c24eHhcHBwQHNzMx+CRZV0TRXCXlsRhxsbG5GcnMy7O5eVlaFfv36IiIjgc9YMGTIEYrGY34RPSkrCjRs3YG5ujgkTJvCzk6FDh2rlpatKEVBdXY3m5ua7IjcDt4Kp3i4mpaWlAICAgACEhobyguLj46OVflIoFBAKhWhtbQVwy5XZzs7OoCFw7jwbY2tra9CZlVwux1NPPYXDhw8jNjYWM2fONJgtKv7++28sWLAAOTk5enNU0pu4KJVKHDp0CEFBQQb3wpJKpVi4cCGSk5Oxd+9eTJkyxWC2iEQibN26FT///DMCAgKwfv16TJgwwSC2SCQSPsujVCrFwIEDERgYqPNAgQqFArm5uW3ipNXU1LQ5yT98+HBMmzYNISEhEAgEOh0xq1L53h4xQHXmgohgaWmJgIAAREdHY+rUqZg4caLOZ+ISiQTl5eVITU1FVlYWLl++jKtXr/J2jRo1qk3YeV0HVlVlyxSLxbwrs52dncFCzBjb2RiZTIaFCxfixIkT2Ldvn8EH1BKJBN7e3liyZAnee+89vdSpN3EpLy9Heno6ZsyYYdDYQTKZDE8++STi4+Oxe/dug/3oRITDhw/jgw8+QHNzM/7zn/9g0aJFBhkBNjY2oqCgACUlJTA1NeVf6Po+HS0Wi/kZypUrV5Cfn4+SkhJcvnyZP9zp6+vbZiltyJAhWh+l1tfXt0nrq8oa6uzsDJFIhIaGBlhYWGDcuHH8Etro0aO1LngtLS04e/YsH48rKyuLXwIaOXIkAgMDERAQgKFDh8Lb25tPEaDPUbvKlVkoFPLZMlVLZoaYPSgUCjQ1NUEmkxn8bIxUKsWjjz6K5ORkHDhwwODn+p5++mlcu3YNGRkZeqlPb+Jy9uxZNDY2GjQzmlwuxzPPPIMjR47gzz//NNh09caNG1i5ciWSkpIwY8YMrF27Fh4eHnq1gYhQUVGBgoIC1NTUwMbGBv7+/vD19dXriE8Vwr60tBR1dXUwMzODu7s7vLy8MHDgQH4ZrqqqCunp6fxS2vnz58FxHPr379/GIy0kJKTbnlYKhQI5OTm8mFy4cAFEhKFDh/JnTsaPH8/3S2lpKZ9GICkpCS0tLXB2duaXz6ZNm6ZR5Oyqqqo28bhU7souLi5tzpeMGDGCb6NYLEZ1dTWqq6vR2toKc3NzuLm5wc3NDU5OTnp9wd+ZLdPGxga2trYG2QcxlrMxra2tePjhh5GRkYGDBw8aNL3I3r178cQTT+DSpUt6CbulF3HhOA6HDh1CQEAAhg0bpuvq2kWhUOCFF17A3r178ccff2Du3Ll6t0Emk+Hrr7/GF198ATc3N6xdu1bvYqtQKHhXYpFIBBcXFwQGBsLDw0NvLyKpVIqysjKUlpaipqYGpqamGDBgALy8vODh4aHW7E0oFOLMmTP8MlpmZibvMTZhwgR+3yYsLKzdJavy8nJeTFJSUniBUKX1nTJliloCIZfLce7cOV5szp8/DyLCiBEjeA+00NDQuwSbiFBYWNjm5HtxcTGAW7Oz25e41D1MKRQK+T0aiUQCCwsLPqCmo6Njl9/XFkqlEiKRCCKRCERkMFdmjuPQ0tICsVgMCwsLODo6GuRsjFgsxgMPPIDs7GwcOnQIYWFhercBuLUE7+3tjZUrV+Ktt97SeX16EZfKykqcPn0aMTExBglPrlQq8dJLL2HXrl3YsWOHQVwEU1NTsWLFCpSUlODFF1/E66+/rtfRlEgkQmFhIYqLi6FQKODl5YWAgAC9OQ3IZDI+4nBNTQ0AQCAQ8ILS0xePTCbD+fPneY+006dPo76+HmZmZhg1ahRCQ0Ph4uKCxsZGnDt3jg9DPmbMGN6zS9N4XbdTV1fXJg6aalY4adIkBAYGwsLCAgUFBcjIyEBdXR1MTU0xYsQI3osrNDRUK9GfW1pa+MjNqqU01YxGX8/gna7MlpaWfFRmfWIMZ2OEQiHuv/9+5OXl4ciRIxg3bpxe61fx2GOPoby8HMnJyTqvSy/icu7cOdTW1hpkGYrjOLz66qvYuXMnfvrpJ70fbqqpqcG6deuwf/9+hIaGYt26dRgyZIje6q+trUVBQQHKy8thYWHBh2bRxwMul8v5iMPV1dXgOK5NCHtdbv4qlUrEx8fjjz/+QEpKCm7evAm5XA4TExO4uLhgwoQJuP/++zFjxgydpMkVi8XIzMzEwYMHceLECeTn50MikQAAHBwcMGrUKMybNw///Oc/dZ5K4PbIzTKZDFZWVvyMRl/7aqoQM4Z0ZRaJRGhpaYGJiQkcHR31fjampaUF8+bNw7Vr13Ds2DGMHj1ar/UDwJ9//olnn30W165d03n4KJ2LC8dxOHz4MPz8/PQeUoWI8Oabb+LHH3/E999/j4ULF+qtbqVSid9++w0ff/wxLCwssHz5cjz88MN6GTFxHIfS0lIUFBSgoaEB9vb2CAgIgI+Pj87XvxUKRZuIw6o9A1XEYV0+0M3NzUhNTeUPMVZUVMDS0hJhYWGYOnUqgoKCUFVVxc9uVLlQBgwYwDsJTJw4UaNsmLW1tThz5gzvFpybm8snw1K5BAcHB6O5uRlJSUlISEjAzZs3YWFhgbCwMH4Jbfjw4Tq7R1QpAlQzGoVCAWtraz5ysz7OnsnlcohEIt6VWbUvoy9HFqVSiebmZkgkEvTr1w8ODg56daJpbGzE3LlzUVxcjLi4OL2/E5ubm+Ht7Y3169fjtdde02ldOheX6upqpKSkYPr06Xed5tYlRIR33nkH//3vf/H111/j6aef1lvdubm5WL58OS5cuIDHH38c7777rl7ibEmlUhQVFaGwsBASiQQDBgxAYGAgBAKBTkVNqVS2iTisVCrh7OzMH27U1fIfx3HIzc3lDzFmZ2fzOSxUS12hoaEdztKampraJFNTeWPZ2toiLCyMdxQYP358mzaoohDcnlmxoKAAwK0oBLdvvgcGBrY7Olcl1FK5O6ekpKC1tRUDBgzAtGnT+ARpurpviAgNDQ18igBV5GbVjEbXM1uVK7NIJALHcbCystJrtkypVIqmpiaDnI2pr6/H7NmzUV5ejhMnTug9+sbDDz+MpqYmxMfH67QenYtLdnY2qqqqMHv2bF1W0wYiwrJly7B9+3Z8/vnneP755/VSb0tLC7Zs2YIdO3ZgyJAh2LBhg17CyTQ3N6OgoIB31/Xx8YG/v79O19Y5jkN1dTVKSkpQXl7On7j38vKCt7e3zkbBNTU1beJ1NTQ0wM7ODpMnT+YPMXp6empUtkQiQU5ODu+RlpaWhqamJpibm2PIkCFwc3ODQqFASUkJ6urqYGJigqFDh7YRE029/mQyGTIyMnjHgEuXLsHExARjxozhvdDGjh2rk1E2x3G80NTV1UGpVMLOzo6f0ehytqnKlikSiSCXy/WWLVNVt1AohFAohLm5ORwcHPQmbqptgtraWsTHx+s1HNaOHTvw0ksv4fr16zpdktWpuKjOcgwaNEhvAdOICKtXr8bWrVuxdetWvSTxISIcPHgQH374IcRiMRYvXoxnnnlGp9NtIuKzPFZXV8PKygoBAQHw8/PTmVcOEaGmpoYXFJlMBnt7e15QdHF+SS6Xt4nXdfnyZQBoE69rzJgxWu1rVeTn9PR0xMXF4ezZs3yqYCKCmZkZBg0axM8uIiIiMGjQIK2+DCsrK/k4aKdOneLjoEVGRvJLaJqKaGdwHIe6ujrU1NTwKQIcHBx4ZwBdvnx1mS2zMwx1NqampgYxMTFobm5GfHy83pISNjQ0YNCgQdiyZQteeuklndWjU3Gpra1FUlISpk2bpjevpPXr12PDhg346KOP8Prrr+u8vqKiIqxcuRIpKSmYM2cOVq1a1WUq156gUChw8+ZNFBQU8O6zgYGB8PT01MkDoYo4XFJSgrKyMn7ZSCUounBxvXHjRpt4XSKRCK6urryYTJkyRav3U2NjY5v9kvPnz0Mul8Pe3v6uZFjV1dX8nk1qaiquXLkC4Fauk9vP23Q3dldnqOKgJSQkICEhAefOnQPHcQgKCuIPcYaHh2t9hqFUKlFXV4fq6mo+crOjoyM/o9GVW682smVqQmtrK5qbm0FEsLe318seVGVlJaKjoyGVSpGQkKCzyOF3ct9990GhUODIkSM6q0On4nL+/HmUl5dj9uzZelnP3Lx5M9auXYsPP/wQixcv1mldUqkUX331Fb766iu4u7vjgw8+QFRUlM7qa21tRUFBAYqKiqBQKPgsj7rKTVJfX4+SkhKUlpZCIpHwEYe9vb21vg8gEomQnp7OnzspLi6Gubk5xo0bxx9i7GkE5dspLS1tE49LFbXZ3d29zRLX0KFDuxSI+vr6NkE5z507xyclUyVTi4iIaDfqsKY0NjYiKSmJ369RBRWdNGkSLzYBAQFafeZUkZtramrQ0NAAIuIjN7u5uelsue72bJmWlpZ8VGZdYYizMWVlZYiOjgYRIT4+Xi95c3744Qe8+eabKC4u1lmoIJ2Ky5EjR+Dh4aEXl7szZ84gKioKK1euxPvvv6/z+jZu3IgffvgBL7/8Ml599VWdb4AeO3YMUqmUdyXW5RmZpqYmnDhxAlZWVvD09IS3tzf69++vswHCtm3b8Omnn8Lb27tNWl9djRyjo6ORl5eHwMDANmLi7e3d4zaKxWKcO3eO37dJT0+HUCjUWYRcVRy0+Ph4nDx5EmlpaTA1NUV+fr7OlrDkcjmfIqCxsRGurq4693pShZiRyWRwdnbW+fOmSrGsUCh0HssOuJVEMTo6GkOHDsXBgwd1Whdwa0nO19cXX375JZ599lmd1NEjcVH57XeEVCoFALVu8q5GI1VVVV2WoVQq1VqKUOfkteqgX2d1cRyn1qhGncCPXfWlSCSClZWVWu3rqi+7qgu45ZxgZ2fX5ctWnVFkdXV1p59zHAeO49Qa/QoEgh7Xp1AoYGpqqtYLQ536uro3lUolTE1N1RKuru7NrtpGRHzula5Qp20ymazTz+VyOTiOU+sZV2cvUKlUdvq5QqGAmZmZWn3Z1bPSVV0AeCeDntYFgM/w2RGqV7E6bVNnI76r+jiOU1s0Ndn479FcVi6X8///ypUrCAoKatMxKsNvv64junpJ1dfXo6ioCBcuXEB+fj7Mzc3h7++P4ODgbh/IU0dcmpub1SpL5a/fHunp6Rg2bJha4tJVH6myAnIc1+E1zc3NsLa27rIvO3phCIVCVFZWgojg5eWlld9NZVdPKSoqgru7u1ovxKamph7Xd/78efj6+uqtvosXL8LLy6vLe7Ojum7evIl9+/bhhRdeUHtWq07bFApFu/+uVCpRVlbGp2Ho6LrbUUdc7hzrKpVKfkkM+L+XuDYWXNQpQxUJuyNkMhnMzc3VEhfVb6dyQ09OToZCocCCBQu67dmpzsv+9nultbUVR48ehYWFBebPn9+tutSt7056NHMhIpiYmOD69eu8z3p4eLjG5XRGa2srXn75ZQQFBWHEiBGQy+W4du0arly5ArlcjuDgYDz88MN3CZwmdXXnuo64fPky/vOf/2Dfvn1qTeF7Wh8AHDx4EPPmzetyNKLaIPbz84OjoyOUSiUKCwtRU1PDr/cWFhYiPDy80xPc+upLAAgLC8Pp06fVeoh7Wp8qadjFixfVGrRoo32DBg1CYWFhl6NkqVSKvLw8jBkzhv+diQgjR47E0qVLsXPnTnzzzTfw9PTsdCaors0ymQxFRUV3RZ/Ozs6GQCBAc3Mzhg4d2mVZmtwrKu9EpVLZbScZderr6e+mVCpRW1ur9jkyuVyO48ePY//+/aipqUFUVBREIhGSkpIwdepUeHh4IDIyEr6+vlqxW/VqLy4uxr/+9S9MnDgRBw8exO+//96tGI8a9xP1AI7jiOM4io2NJY7jKDU1lcRisUblqHONTCZrc63q327evEm//fYb3XffffTpp592Wp46dXXnuo6+O3LkSKqvr9dLfUREra2tdOLECbXKUSqVVF5eTmlpaZSenk6nT5+my5cvk1wu568RCoV08OBBg/el6vs+Pj56q2/p0qX0559/6q2+q1ev0ty5c9Uqp6mpiZ577jl6/fXXKS8vjziOo59//pm2b99OHMfRsWPH6Pnnn6d//vOfpFQqe2wzx3FUUFBABQUF/Hc4jqOkpCTiOI7y8vKouLiYmpubuyxH3fpUiEQiam5upoqKim73sbrvFE1RKBRUVVVFUqlU7XKam5tpyZIllJKSQmKxmH9/3rhxg3bv3k3bt2+n6dOn065du7Ty3CkUCvrhhx9o2rRpdOzYMeI4jmpra2nw4MGUlpZGf//9N1VUVHRZjqb91GNxqauro7NnzxLRrcYcPXpUo3K0cY1IJKJnnnmGtm/f3qNyunNde2RlZdGKFSv0Vh8R0dGjR9W+0VXXKJVKamlp6fB7hYWFdOHChS7LUbc+TcnJyaENGzbopT6lUskLmb7a5+Pjw79s1KlLJpNRQkICxcTE0LZt2+4SXolEQrt27aL33nuvxzar+uHy5ctUXFxMRER1dXVUXl7Of15RUUFZWVnU2tqqlfpUlJeXE8dxJJVKuz1o1bW4qISlO+V0dU9xHEf19fU0f/58+vjjjzu8Vt36qqurafHixVRXV9fm37Oysuitt96iDz74gEJCQu76XNP67qTH4rJ///42le/Zs8egowyFQkG+vr7U0NDQo3J6cuONHDmSFAqF3uoTi8UUFxendjndsUk1K+1pOT1h5MiRpFQq9VLfsmXLKCkpqVvl9KS+q1ev0pw5c9Qu5/Zr6urq6K+//qK0tLR2rxMIBGqVo059qpWJ1tZWSk5Ovuv7MpmsjR0KhaLNTLi79cnlcqqpqeH/TSVm6qJLcVEoFG1eyNq+T6RSKS1atIg2b97co3I6EzPVZ2fPnqWQkBCtDAzupEfiohpB3U5xcTFdvny5XYM4jqPr16+3++9d0Z0GXr9+nUJDQ3tUjqYdynEcBQYG6rW+w4cPd2sU1Z26bty4QVevXu1ROT15+RYXF9Ps2bP1Up/qhXz7C1WX9RER+fr68qNybf92r7/+OhUVFfWonNuva2lpoXPnzlF6enq71546dYq//ty5c5SZmalRfarZ0O3Leu2Ji0Kh4AdxndndWV2aUFVV1ea7urhPlEolubi4tLu0qe36fvrpJ5o3bx5duXKlR+XcSY+ct01NTe/KPz9o0CDcuHGDz3BIt/kLnD17FtXV1fzJW13h5+fHZ1rUN/v27cNnn32mt/qqq6vh7Oyss5Av3t7eyM3N1Yp3TneRyWRYsGAB/ve//+mlvosXL+Lpp5/WWwDDsrIy+Pn56ezMxtatW/Hwww8D0I53lZ2dHYYPH46QkJB2Pw8MDER9fT2USiUUCoXGz3lra+td4fhNTU3btIH+f+SI2tpavd+bSqVS5/eIqakpDh48iPXr1+u0HgB45plnsGLFCsyZM6dTb9Ruo5EkdaFoEomEiouLKSUlhUpLS/lrY2NjSalU0rFjx9Qqp7vX3E59fT0NGzZM43I0VevAwECdj2pUKJVK2rdvX5vRjS768ty5c1RVVaVxOZq0jeM4euqpp+jAgQN6qY+IKCgoqM1IWNf1DR8+vM1GuC5+u8DAQDp//jxt27aNLl261O1yulMfx3GUnJxMOTk5JJVKqaCgQKPlYdVey+3IZDISCoX83/X19dTa2kpCoZCftXfXbk1+N4VCQfX19RqVo8l2gZWVlcbldLe+xMREevfdd3tcjgqdHDvt168ffHx8EB4ejszMTHAch/LycgQHB8PU1BRCoVAX1bbB2dkZLi4ufOpYfaBQKGBjY6OXkS8RISMjAxMmTND56eGQkBCcPn1aryPE3bt3w9fXVyOffE1QHYrVV753oVDIx7DSJfv378c333wDBwcH3HfffTqty8TEBK6urrCzs4OlpSX8/PyQn5/frTLo/4eVufMZMjc3589LcRwHmUyGfv36wcbGBg0NDVprQ1fU19frLXWIiYkJrKys9PbcRUZGYvv27dorUCNJ6oailZeXU0pKCu3du5e/PjY2ttvlaKKeTU1NNHjwYI3K0aS+JUuW0MWLF/VS382bN+n06dN3fU9XfXn+/HnKz8/XqBxNRmx+fn53rTfr8rd76623KCcnR2/1RUdH082bN7tdjqajbY7jKDQ0VOeOJnduIp86darb9XV0bU1NDUmlUqqurm7jLNDefoyu+lLTujStLzY2lk6ePKm3+saMGUMymazH5RDpaOZyO+7u7vD09MSECRP40Yirq6te1NjBwQHjxo1DRkaGzuuqqanBiRMnunU4SVNU+eLDwsL0tj8QHByMwsJCvYwSU1JS8NJLL+ktBS4R4X//+x9GjRqll/rEYjGuX7+u8zSzKlThUnbt2oWtW7fqtC4TE5Me35Mdfb9///4QCoWwtrbWa/ZIFUqlUm/5XlQ89NBDeOyxx/RW38GDB/HOO+9opzCNJKmHiiYWi9t4jenSs0Mmk5Gbm5tOPYAKCwspJiaGCgoKNC6nO/UdP36cmpqaNC5H076USCS0f/9+fkahqxFUUFCQXrxkVKxfv5527dqlt/pmzJhB165d06icnnimcRxH7u7u3SqnJ/UR/Z8Hmbbqa6+shoaGNv/W2tra6QFSdeu6kzu9xLpbjqZ92a9fP73V194+j9HOXNrDysoKFy5c0EtdFhYWWLhwoU5SehIREhIS8NZbb+Hjjz+Gv7+/1uu4k7q6OtjZ2ek0y2RH9OvXD6GhocjMzNRZHS0tLfDw8NDbrKW+vh6//vorHn30Ub3Ud+nSJbS2tuo186AKExMT7XoDqYGXl5daASLVpb2ZkYODA1paWgD8X/pmbc7oiQgymUzt4KPaZurUqWhsbNRLXSYmJrC2ttbOypJGktRDRSP6v30XdUc1PalLqVSSs7Nzt8rp6jqlUkl//fUXPfLII52ecNXmKIPjuLu8wzQtR1M4juMPyupiBHXfffdRdXV1j8pR9zqxWEwRERHtziJ0UZ9CoSBvb+8OQ6Xo+rcjIvrPf/5DNTU1epu5KJVKunTpks5H26q9EJFIRCKRSO2+7Og6hUJBEomE90irrq7u8LnTdV+2tLRQZGSk3uo7fvw4bdu2rcflGGTmcjsNDQ1qRd/tCaamppg9ezYuXrzYre+1F+m1paUFaWlpWLZsGRISErBjxw69ZdksLy/HoEGD9Daqbw8TExOEh4fzCba0BREhMzMTUqlUrSjSPa2ruLgYTz75JF5//XW9zCKICM8//zw++ugjnXuIdcamTZvw1FNP6a0+U1PTLtNX9JTbZxNNTU1qnxviOA4NDQ18+moVUqkUDQ0NkEqlfATx/v37G+y5s7OzQ319PeLi4vRSX0xMDFavXo3S0tKeFaSRJPVQ0YhunZ0QiUR3hY/RRV1Et/ZevLy81C6ntraWXn75ZSopKeHrP3r0KD311FO0cuVKSkhI6PB0sCZ2cxxHSqWS5HI5SSQSkkgkvJcP0a1wGPv27VNrTVpbNnX2/d27d3erbUKhkK5cuUJxcXF048YNfhQol8spOzubtm7dSvfffz81Njb22G6ZTEanTp1qM4LlOI4aGhooOTmZli9fTo8++iidPHmy0zK7MyM5deoUVVdX878Zx3EkkUiooaGBKisrafny5fT666/3uL6e/nZE1CYKgT7qu/3kvq7qUwW3VJ3HUrcvJRIJ1dTUkFAo5J/ByspKPtyQOjN0ffRlXV0dhYeHdxlMVlv1JSYmUmhoKKWnp2tcjlZC7msCx3GIi4uDhYUFoqKidB4eGwCGDRuG8+fPq3WaneM4JCYm4osvvsB9992H4uJi1NTUYPny5fDw8FDbFnXtpv8/cr9zTdza2hr29vYoKSnB0KFDu8z3oU592ujLY8eOYcaMGWqN5uRyOV555RXY2trCw8MDxcXFsLa2RkhICDIyMmBqaoqYmBhERUV1OqpX126RSIRVq1ahqqoKERERsLa2xrVr11BaWgoPDw9ERUVhypQpXWa6VLc+sViMlStXorS0FE5OTggKCoJcLkdeXh44jgMRYdy4cXjrrbc67S99/XaTJ0/GyZMn1UqCpY36srKyMHbsWJ2mZ5DJZGhpaYGTkxPMzMy61Zccx6G5uZlPtObk5NSt1MbdecZ70pfNzc0YNWoULl26pFbOnp7WV1RUhBkzZuD8+fMaZYXtkbh0tckkFothZWXV4QNVVlaGAQMGwNzcvMuDSbm5uV3a01XGv7KyMjg4OCAiIqLLsi5fvgzg1gZ6XFwcBg8ejHHjxrVJViSXy9USKnXckxsbGyEWi9skHpLL5WhpaYFIJIKjo6Paueu76kt1NgdbWlo6fdFLJBJYWFjAxcWly7IuXryIuro6ODs7w9TUFHK5HDk5Obh+/TpGjhyJYcOGqZ3Vc/jw4WrVx3EcSktLcebMGUilUgwePBhDhw6Fk5MTL+DqHJhUJ32vKjyOSCRCYWEhCgoKAADjxo3jl1M6y4tzO8HBwZ1+3tXSLhFBqVR26qpbWVkJBwcHTJgwoUt7ujrwLJfLQUSdPgeqhFrqOKH0ZIlcLBa3eel2dT/dWZdqCUzVFpXYqHNfqnNNV05MqldxZ4JQWFgIV1fXu8JuaVIfp0Ymyvz8fAwYMACTJ0/usr476ZG4dHYjEBGys7NBRPDw8MCAAQM6bUhXP05X2f44joNEIoG5uXmXL3xHR8dOPwe6zp7Y1NQEkUgEd3f3Ln8gbTxUHMehtbUV1tbWXdbX3YfqThobG/nMol0JmjoPVWd9qVQqUVdXB6VSCXd39y5HWur0ZUf1cRwHsVgMiUQCS0tLtcpS55rO7k1VnaamprC0tOzyfEZX92ZX96VYLIZIJIKdnV2Xew/qtK2rDJPXrl2DqakpAgICuixLnbMpXXmzqcRTnVTHXT0nXdUlFAohFovh6uraZVnqzOC7uk/kcjlMTEzUGrCq8w7rqD6O46BQKPgMn+oMstSp7y40WkxTE6FQSGfPnqU9e/bQ4cOHqbCwUC3/c0357bffyMXFhUJDQ+86Ta5t6uvracyYMfTSSy/ptB4VDQ0NtHv37g5TCWgLuVxOhw8f5sPO65KEhAQaNWoUTZo0qdO8MT2lrq6O1q5dS4MGDaKAgADaunVrl8mttMnp06dp9uzZZGtrS5GRkXT8+HGt7GW0h0wmo5UrV5Kbmxu98MIL1NLSopN6VDQ2NlJiYiIfQ1DXyGQyKisru+sUuS7qKS8v13n/KZVK+uijj8jKyopmzZrVoaekNrh06RI9/vjjZGVlRSNGjKDff/9drX1jTdGpuKhoaWmhM2fOUGxsLB05coSKiop0JjJ5eXk0atQoEggEtG/fPp3UoeLgwYPk4+NDhw4d0mk9RPoTl+zsbNq7d2+bIIHaRqFQ0Mcff0w+Pj703HPP6axNDQ0NtGHDBvLz8yM/Pz/auHGjzvuvMxITE2n69Olka2tL06dPp8TERJ3VdeDAAfLz86OJEyd2GEpdW1y7do2Sk5M7zQmiLfQlLjU1NXw+GV1RX19PDz74IFlaWtLq1at19qK/du0aPfPMM2RtbU1Dhgyhn3/+uU34HF2hF3FR0dTUROnp6RQbG0tHjx6lGzdu6GQE19zcTE8++STZ2NjQ+++/r7MbkeM4evHFF2ns2LE6f2npQ1xqampo9+7dOp311dbW0hNPPEF+fn705Zdf6mSQ0dzcTFu2bKGAgADy8fGhDz74oMtse/qC4zg6fvw4TZkyhWxtbWn27Nl0+vRpndRVUFBAkZGRNGjQIPrrr790UgfRrcFCWloanT9/Xmd1qNCHuLS0tFB5eblO6zh79iwFBgbSgAED6MiRIzqpo6ioiF588UWytbWlwYMH07fffttuBGldoVdxUdHY2EinT5+m2NhYOn78OJWUlGhdZDiOoy+++IIcHBwoOjqaysrKtFq+iqqqKgoODqbFixfrpHwVuhYXVYrqrtxze0JmZiaFhobS2LFjdfJCFYlEtG3bNhoyZAh5eXnRihUrdLrM0BM4jqO///6bwsPDydbWlu6///42ybW0hVgspldffZXc3NxoyZIlJJFItF4H0a2lx8TERLVysvcEXYuLXC6niooKnS2bchxH3377LdnZ2dHEiRPpxo0bWq+jpKSEXn31VbKzs6NBgwbRF198oZdZ5Z0YRFxU1NfXU0pKCsXGxtKJEyd0IgBpaWn8CPbO6KLaYteuXTotn0j34nLhwgXas2ePTh4qjuPo+++/J39/f3r00UepsrJSq+W3trbSf//7Xxo2bBh5enrSe++91+20uIZCqVTS3r17ady4cWRra0uPPvroXdGZewrHcfTrr7+Sp6cnxcTE3BWNWVtcvnyZUlJSdDo61rW41NTUUHV1tU4GWEKhkJ577jmytLSkN954Q+tCX1FRQYsXLyYHBwfy9PSkTz/9lEQikVbr6A4GFRcVtbW1lJycTLGxsRQfH6/10U9NTQ3NmzeP7OzsaNOmTVpfiuG4W4mtwsPDdbZXoUtxqa+vp9jYWLp8+bLWy25paaGXX36ZfHx8aP369Vpd65VKpfTDDz9QcHAwDRw4kN566y3+0GtvQ6FQ0J9//kmjRo0iW1tbeuKJJ9ok99IG58+fp3HjxlFgYCAdP35cq2UT3Xrxp6amUl5entbLvr0OXYmLUCik8vJynYjj1atXKSQkhJycnOiPP/7Qatk1NTX03nvvkZOTEw0YMIA2bdqkV4eVjjAKcVFRXV1NiYmJfA6D9rIfaopCoaAPP/yQbG1t6aGHHrorm1xPKSkpoWHDhtGKFSu0Wq4KXYmLUqmkuLg4OnHihNZF9/LlyzRt2jQaMWIEHT16VGvlymQy+vXXXykkJITc3d3ptdde6zBXfG9DLpfTjh07aMSIEWRnZ0fPPvtsh7HPNKGhoYGeeuopcnNz07rYE/3fM6yr5UhdiYtCoaCKiooOo433hL/++ov69+9PwcHBWh0w1NfX08qVK8nFxYXc3Nzoww8/7DTChb4xKnFRUVlZSQkJCRQbG0unTp3SqtfG8ePHydPTk4YOHUpZWVlaK5eI6KeffiIfHx/KyMjQarlEuhOXS5cuUWxsrNbL3b17NwUFBdHs2bO19uKXy+X0xx9/0Pjx42nAgAH0r3/9S6svXmNCNSsbMmQI2dvb04svvtgmTUVPUCqVtH37dhowYAA99NBDWheCvLw8Sk1N1cnsQlfiUldX12FIfU2RSqX01ltvkaWlJT355JNam000NjbShx9+SG5ubtS/f39asWKF0Tis3I5RiouKiooKio+Pp9jYWEpOTtZaB968eZMiIyPJycmJvv32W63dUEqlkh555BGaNm2a1jfQdCEuTU1NtGfPHq0uY0gkEnrvvffIx8eH3nnnHa30g0KhoNjYWJo4cSIJBAJ67rnntL5kZKxIJBL6+uuvyd/fnxwdHenVV1/V2p5JSkoKDR8+nEaOHElpaWlaKZPo1ks1JSVFJ8usuhAXkUhE5eXlWt0DKSkp4T0Cv/rqK628Y1paWmjTpk3k7u5OTk5O9N577xmtwwqRkYuLirKyMoqLi6PY2FhKTU3VygtWIpHQW2+9RTY2NvTcc89pba+koKCAAgMDaePGjVopT4W2xYXjOEpISKBjx45pzb/+xo0bNHfuXBoyZAj9+eefPS5PqVTSwYMHacqUKSQQCOjJJ5/U6WFLY0YsFtP27dvJx8eHnJ2d6a233tKK00JlZSXdf//95O7uTl9++aXWBloVFRWUmJio9RG1tsVFtRymzUHbiRMnyMPDgwYPHqyVVQyRSESffvopeXp6koODAy1evFjnXnnaoFeIC9Gtl2FJSQkdP36cYmNjKS0tTSvri3/++Se5ubnR2LFj6erVq1qwlOjLL78kPz8/rfr9a1tcrl27Rrt376ba2lqtlHf8+HEaOXIkRUZG0sWLF3tUFsdxdOzYMZo+fToJBAL6xz/+ofUlzN6KUCikLVu2kKenJ7m4uGhl9CqXy2nNmjXk5uZGzzzzjNb2HS5cuEBpaWlaPRyobXGpr6/noyD3FKVSSevWraN+/frRvHnzeryc39raSl988QX5+PiQnZ0dvfrqq73KYaXXiIsKjuPoxo0bdPToUYqNjaWMjIwer2VevnyZxowZQ25ublo5bCaXy2nu3Lk0a9YsrT0E2hQXoVBIe/fu1YrLq1wup40bN5KPjw+9+OKLPXoxqWZTs2bNIoFAQA8++KBWl2vuJZqbm2nDhg3k7u5Obm5utHLlyh7PEg4fPkz+/v40YcIErSyVtra2UnJyslb3xbQpLmKxmMrLy7WydKvySO3Xrx+tW7euR4IqlUrp22+/JX9/f7KxsdHqfps+6XXiokKpVFJRUREdOXKE9uzZQ5mZmT2KA9TS0kLPPvss2djY0Ntvv91jd8S8vDwaPHgwffbZZz0qR4U2xeXUqVN0+PDhHnsKVVdX0z/+8Q8aPHgwffPNNz1aUklJSaH58+eTQCCguXPnUlJSks4Oc95L1NfX05o1a0ggENCAAQN67DFUVFREUVFR5OXlRb///nuP7SstLaXExEStzbi1JS6qvC3a8BrNyMigwYMH08CBAykuLk7jcuRyOf38888UFBRE1tbW9Mwzz/Rqh5VeKy4qlEolFRYW0qFDh2jPnj2UlZWl8cEhjuPom2++IUdHR5o6dWqPN043b95M/v7+Wllu05a4XL9+nXbv3t1jN+/09HQaP348TZgwoUfryhkZGfTQQw+RQCCgmTNn0okTJ5ioaEBNTQ0tW7aMXF1dycPDgz766CONB1utra301ltvkZubG/3nP//p8cg+OzubMjIytLL0pC1xUSVx64lNHMfRV199Rba2tjRlyhSNl6wUCgX9/vvvNGLECLKysqLHH3+8x0vLxkCvFxcVCoWC8vPz6e+//6a9e/fSuXPnSCwWa1RWZmYmBQUFkZeXV49GIhKJhKZPn04PPPBAj9edtSEuYrGY9u/fT2fPntW4DNUD5efnR4899pjG6/3nzp2jxx57jAQCAU2bNo2OHDnCREULVFZW0pIlS8jZ2Zm8vb3pk08+0dhZ5Y8//iAvLy+KiorqkTu5SCSipKQkKiws1LgMFdoQF4lEQuXl5Rq/H4hurXQ89dRTZGlpSYsXL9ZopUOpVNLu3bspJCSErKys6NFHH9VLfDZ9cc+Iiwq5XE5Xr16lgwcP8vsKmoy86urq6MEHHyRbW9seraGePXuWfH196bvvvtPo+yq0IS6pqan0999/a/xgNjU10QsvvEA+Pj60adMmjZbVcnNz6amnniKBQECTJk2i/fv36zQNQ1+ltLSU3nzzTXJyciJfX1+N40vl5eVRaGgo+fv70+HDhzW25+bNm5SYmNjj/dGeiosqFXJP9qcuXbpEwcHB1L9/f432aDmOowMHDtCECRPIysqK7r///h4N+IyVe05cVMjlcrp8+TIdOHCA9u3bRxcuXOi2H7sq14KtrS3dd999GntWrVmzhoKCgqi4uFij7xP1XFxu3rxJu3fv1jh+W15eHk2ePJmCg4PpxIkT3f7+lStX6PnnnyeBQEDh4eG0e/duneaSYNyiuLiY/v3vf5ODgwMFBATQt99+2+3noKmpiZ599llyc3Oj1atXazSo4DiOzp49S5mZmT2aofZUXBobG6miokLje++PP/4gJycnCgkJ6fZyN8dxdOTIEZo4cSJZWVnR7Nmz72mHlXtWXFTIZDK6ePEi7d+/n/bv3095eXndvjETEhLI29ubAgMDNdpfEAqFNGnSJFq4cKHGD1ZPxEUikdDBgwcpPT2929/lOI7++OMPCgwMpHnz5nV7H6qgoIBeeuklGjBgAI0bN45+//13veSSYLSlsLCQFi1aRHZ2djR06FD66aefuvUcqJZD3d3d6b777tMo+GhLSwudOnWqR4OsnoiLVCql8vJyjfZkJRIJvfHGG2RpaUnPPvtst5YaOY6j+Ph4mjp1KllZWdH06dPp1KlT3baht3HPi4sKqVRKubm5tG/fPjpw4ABdunSpWzdoaWkpTZ8+nRwcHDQ6bJacnEw+Pj7022+/ddd0IuqZuGRkZNCBAwe6PWIVi8W0ePFi8vHxoaVLl3br+8XFxfT666+Tu7s7hYSE0C+//KLzBE+Mrrly5Qo9/fTTZGtrSyNHjqTffvutW6P49PR0Cg4OpuHDh1NKSkq36y8qKqJTp05pvA+kqbiolsM0WX24ceMGRUREkJ2dXbcjeqSkpNCMGTPIysqKJk+eTHFxcX1mb7HPiIsKiURC58+fp71799LBgwfpypUrao+kZTIZvffee2RjY0NPP/10t71x3n33XRo+fLhGJ6s1FZfy8nLavXt3t/NGXL9+nWbNmkVBQUEUGxur9vdKS0tp8eLF5OHhQSNHjqTvvvtOZzlEGJqTm5tLCxcuJFtbWwoJCaG//vpL7b2v6upqevjhh2nAgAG0bdu2bu2ZKZVKOnPmDGVlZWn0ktVUXJqamqiioqLbs+YjR47QgAEDKDAwsFsHeTMyMmjevHlkZWVFYWFhdOjQoT4jKir6nLioaG1t5VP6/v3333Tt2jW1R3B79uwhgUBAo0eP7laMq6amJpowYQI999xz3b7RNBEXmUxGf//9d7dHmIcPH6bhw4fTtGnT1E6RW1FRQe+//z4fFPSrr77qkTcOQz+cO3eOHn74YbK1taUJEybQ/v371bo3FQoFbdiwgdzc3OjJJ5/s1n3Z1NREiYmJGrnuaiIuMpmMysvLuzVbUigUtGrVKrK0tKQHHnhAbQeAc+fO0YMPPkhWVlY0duxY2rdvX591WOmz4qJCJBJRVlYW7dmzhw4dOkQFBQVq3QzXrl2jCRMmkKura7fyMxw/fpx8fHxo37593bJTE3HJysqiffv2qf2Sl8vl9MEHH5CPjw+98soras3MampqaOXKleTt7U1Dhgyhzz77TGc5bRi6Iz09nebPn0+2trYUERFBhw8fVktkjh8/ToGBgTRu3LhuudEWFBRQUlJStwcg3RUXjuOourq6W6FYqquradasWWRlZaV2/qfc3FxasGABWVlZ0ahRo2jXrl19VlRU9HlxUSEUCuns2bO0Z88eOnz4MF2/fr3Lm0MkEtELL7xANjY29MYbb6jt6vnqq69SSEhIt9Z/uysuVVVVtHv3brXPFlRUVNAjjzxC/v7+9MMPP3T5Yqmvr6cPP/yQfHx8yN/fnz7++GOd5MJg6JeUlBSaOXMm2dra0rRp09Q61Hrz5k2aMWMGeXp60i+//KL2zCc9Pb3bIYi6Ky7Nzc1UXl6u9nJYamoq+fr6kqenJyUmJnZ5/ZUrV+ipp54ia2trGjZsGO3cuZM5rPx/mLjcQXNzM505c4ZiY2Pp6NGjVFxc3OnDwnEc/fjjj+Ts7EyTJk1SyxOmtraWQkJC6NVXX1Xbru6Ii1wupyNHjtCpU6fUetBTUlJozJgxFB4e3uW6cmNjI23atIkGDx5Mvr6+tH79ep2lXmYYBlWMt6ioKLK1taUZM2ZQcnJyp9+RSqX0zjvvkJubG73yyitqzUjq6+spMTGxW+7x3REX1XKYOmdrOI6jbdu2kY2NDUVFRXW5L1pQUEDPP/882djYUGBgIP3444/MYeUOmLh0QFNTE6WlpVFsbCwdO3aMbt682emLOjs7m4YPH04eHh505MiRLsvfu3cv+fj4qJ1utjvikpOTQ3v37u1yWUupVNLnn39Ofn5+9NRTT3W6rtzS0kKffvopBQYG0qBBg2jNmjVai6jMME44jqOjR4/SpEmTyNbWlubNm9elO/tff/1FgwYNoilTplBBQUGXdVy9epWSk5PVdvrojrjU1NRQdXV1lwOspqYmeuyxx8jS0pLee++9Tsu+ceMGvfzyy2Rra0u+vr709ddfM4eVDmDi0gUNDQ2UmppKsbGxFBcXR6WlpR3erA0NDfToo4+SjY0NrV69ulMHAY7j6LnnnqMJEyaotZykrrjU1tbS7t27uwx419DQQM8++yz5+vrSp59+2qGtYrGYvvjiCwoKCiJPT09avny5RmccGL0X1Yny0NBQPk14ZzPcK1eu0MSJE8nPz48OHDjQadlyuZxOnz6tdp4edcWlpaWFysvLu7wuNzeXhg8fTq6urp3ug5aVldEbb7xB9vb25O3tTdu3b2cOK13AxEVN6urqKCUlhWJjY+nEiRMdTpuVSiVt3bqV7OzsaM6cOZ0GiCwvL6fhw4fTu+++22X96oiLUqmkY8eOUUJCQqejtZycHIqIiKDRo0d3uK4skUjo22+/pREjRpCHhwctWbJE49P9jHsDpVJJsbGxNGbMGLK1taXHHnusQ1FoaWmhF198kdzc3GjFihWdxt6qra2lxMREtQYt6oiLXC6nioqKLgdtv/76Kzk6OtL48eM7nGWpYrU5OjrSwIEDacuWLcxhRU2YuHST2tpaSkpKotjYWEpISOjwgUhKSiJfX18aPHgwpaamdljeb7/9Rj4+Pl26C6sjLnl5ebRnz54OHyqO42jHjh0UEBBA999/f7tiIZPJ6KeffqLRo0fTwIED6c033+z2GRnGvY0qiu/IkSPJ1taWnnrqqXZTGnMcR99//z15eHjQnDlzOh2cXLp0iVJSUrqcaagjLrW1tVRVVdXhAKu1tZVefvllsrS0pH/961/tzkBqa2tp6dKl5OzsTAMGDKANGzYwh5VuwsRFQ6qrqykxMZFiY2MpMTGx3ejAFRUVNHPmTLK3t6dt27a1e7MrlUp67LHHaPLkyZ2GpehKXBobGyk2NrbDczdCoZDefPNN8vHxoVWrVt31cMpkMvrtt99o7NixNGDAAHrllVe0EsWWce8ik8no559/pmHDhpGdnR09//zz7c4Azp49SyEhIRQUFNThTFkmk1FqamqXoea7EheRSETl5eUdzpSuX79OoaGh5ODgQD/99NNdnzc0NNDq1avJ1dWVXF1dac2aNcxhRUOYuPSQyspKSkhIoNjYWEpKSrprk1sul9OyZcvIxsaGFi5c2O7op7i4mIKCgmjt2rUd1tOZuHAcRydOnKC4uLh23afz8/MpJiaGhg0bdtcauEKhoF27dlFoaCgJBAJ68cUXe3WCIob+kUql9N1331FgYCA5ODjQyy+/fFeI/rq6OlqwYAEJBALasmVLu/dpVVUVJSYmdnompTNxUSgUVFFR0WGytIMHD5KbmxsNHTr0LhfopqYmWr9+PQ0YMID69+9Py5YtYw4rPYSJi5YoLy+nEydOUGxsLKWkpNyV4e7AgQPk7u5OwcHB7a5Tf/fdd+Tr69th6O3OxOXKlSsUGxvbbla9AwcO0LBhwyg6Opry8/P5f1cqlbRv3z6aNGkSCQQC+uc//6mV1LaMvktrayt9+eWX5OfnR46OjvTGG2+0OYWvUCho8+bNJBAI6LHHHmv3fs3NzaXTp093eFakM3Gpq6trdzlMNcCztLSkRx99tM0zJBQK6eOPP6aBAweSo6MjLVmypMeJ9Bi3YOKiRTiOo9LSUoqLi6PY2FhKTU1tcyMXFhZSeHg49e/fn3799dc231UoFHT//ffT9OnT23Vt7Ehcmpubac+ePXcJlkwmo1WrVpGPjw+98cYb/CYkx3F06NAhmjp1KgkEAnr88ccpOztbK+1nMIhuLU19+umn5O3tTc7OzvT2229TRUUF/3lCQgINGTKEQkJC7vI6k0gklJyc3GHYoY7ERSwWU3l5+V3PTmVlJcXExJC1tTV98sknvPCIxWLatm0beXl5kb29Pb355pvMYUXLMHHRARzH0c2bN+nYsWMUGxtLaWlp/HKYWCymV155hWxsbOjf//53m83Eq1ev8qfd76Q9ceE4jhITE+no0aNtXInLysrogQceoICAANqxYwdxHEccx9Hx48cpJiaGBAIBPfLII5SZmam7TmD0eVpaWmjTpk3k4eFBrq6utHTpUn7Jq7S0lGbPnk0eHh53RYQoLy+nxMTEdmc27YmLUqmkysrKuwZep06dIm9vbxo0aBB/CFQikdBXX31Fvr6+ZGtrS//+97+Zw4qOYOKiQziOo+LiYjp69CjFxsZSRkYGf1p4x44d1L9/fwoPD2+zcf7ZZ5/R4MGD79rYbE9cCgoKaPfu3W2cCU6dOkUhISE0ceJEysnJ4QVo9uzZJBAI6P777+/Ue43B0DaNjY20bt06GjBgAAkEAlq9ejXV19eTVCqlZcuWkZubG7300kttXHxzcnIoPT39rvNX7YlLfX09VVZW8vs4HMfRli1byNrammJiYqiyspJkMhl9//33FBAQQDY2NrRo0SLmsKJjmLjoAaVSSdevX6fDhw/Tnj17KDMzk4RCIV24cIGCg4PJ3d2d32iXyWQ0a9Ysmjt3bpt15zvFRSQS0b59++jcuXNEdGtZ7ZNPPiFfX1965plnqL6+nlJTU+n+++8ngUBAs2fPpsTExD4X9pthPNTV1dGqVavIzc2N3N3daf369dTU1ET79u0jX19fmjRpEp/dUSwWU1JSUpt9QqK7xaW1tZXKy8v5FYCGhgZ6+OGHydLSklasWEGtra3066+/0tChQ8na2pqefvpptSN9M3oGExc9olQqqaCggA4dOkR79uyhrKwsqqiooMcff5xsbGxo2bJlJJfLKScnh/z8/Oirr77iv3unuCQnJ9OhQ4dIJpNRXV0dPfXUU+Tr60vbt2+njIwMeuSRR0ggEFBMTAwdP36ciQrDaKiurqb333+fXFxcyNPTkzZv3kw5OTk0efJk8vHx4fMHlZSUUGJiYhvvr9vFRbUcplo+y87OpqCgIBIIBHTgwAH63//+R8HBwWRlZUWPPfYY5ebmGqS9fRUmLgZAoVDQtWvX6O+//6a9e/fSuXPnaMuWLWRvb08zZsygiooK2rBhAwUGBvJT98LCQvr888+psLCQiouLaffu3VRRUUFZWVkUHh5OY8aMoZ9++okef/xxEggEFBkZ2ScTFDF6D+Xl5bR48WJydnamQYMG0ebNm/lT/e+++y5JJBI6d+4cnTlzhl/yqqiooJSUFKqoqKCGhgY+AdgPP/xA9vb2FBoaSt988w2NHTuWrKys6OGHH+525GWGdjAhIgLDICgUChQWFuLatWvgOA5NTU1Yu3YtOI7Dd999h3Xr1kGhUKBfv35ISEjgvzdq1Cg899xzcHR0xPr16+Hn5wdnZ2ecOnUKgYGBeOedd3DffffB1NTUgK1jMNSjpKQEH3/8MX799Vf0798fU6ZMwYkTJxAcHIzPP/8cFRUVKCwsxG+//Yb4+Hj+e5MnT8Zrr72GEydO4JdffsHMmTNRVVWFvLw8xMTEYNWqVZgwYYIBW9a3YeJiBMjlchQUFKCgoAD19fX4/vvvkZOTg+DgYKSlpcHExAS3/0yqv+3t7REUFISbN2/C19cXS5YswcMPPwwzMzMDtobB0IyioiJs2rQJv//+O5ydnQEA/fr1w5gxY7Br1y6YmpqC4zj+etVzYGFhAT8/P9y8eRNTpkzB6tWrMWnSJEM1g/H/YeJiRMhkMuTn5+PatWvYtm0bTp061eV3/P398cEHH2DBggWwsLDQg5UMhm4pKCjAhg0bsGvXLhARxGJxl98JDg7Gtm3bMG3aNJiYmOjBSkZXMHExQqRSKSIjI5GZmYnOfh4TExNERUW1WSpgMO4VLl++jGnTpqG6urrT60xNTREVFYUTJ07oyTKGOjBxMULq6urg6uqq9vW1tbVwcXHRoUUMhv5hz0Hvhu34GiENDQ06vZ7B6A2w56B3w8TFCFFtZurqegajN8Ceg94NExcjxMXFBdHR0V16fZmZmSEmJoYtBTDuSdhz0Lth4mKkLFmyBEqlstNrlEol3n77bT1ZxGDoH/Yc9F6YuBgps2fPxoYNGwDgrpGb6u+NGzdi9uzZereNwdAX7DnovTBvMSPn6NGj2Lp1axs3y5iYGLz99tvsgWL0Gdhz0Ptg4tJLqKurQ0NDA5ydndnaMqPPwp6D3gMTFwaDwWBoHbbnwmAwGAytw8SFwWAwGFqHiQuDwWAwtA4TFwaDwWBoHSYuDAaDwdA6TFwYDAaDoXWYuDAYDAZD6zBxYTAYDIbWYeLCYDAYDK3DxIXBYDAYWoeJC4PBYDC0DhMXBoPBYGgdJi4MBoPB0DpMXBgMBoOhdZi4MBgMBkPrMHFhMBgMhtb5f3t1zDzundA+AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,[3,2],1], device=device)\n", - "x = torch.randn(100,2).to(device)\n", - "model(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "20be6142", - "metadata": {}, - "source": [ - "mult_arity=3" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "5fbe4670", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=3, device=device)\n", - "model(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "f76b85cc", - "metadata": {}, - "source": [ - "mult_arity=4" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f9fa6c9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACuF0lEQVR4nOydd3gU1frHv7vpvZFG6EkICYQUSigJvUoRCwgqV8TervWiCCpNRVHs7QoXlSIIUkSlS0KA0JMA6SSk916277y/P3Dml4SULbMpeD7Pw3O9sDvzzuzM+Z7ztiMhIgKDwWAwGCIi7WwDGAwGg3HnwcSFwWAwGKLDxIXBYDAYosPEhcFgMBiiw8SFwWAwGKLDxIXBYDAYosPEhcFgMBiiw8SFwWAwGKLDxIXBYDAYosPEhcFgMBiiw8SFwWAwGKLDxIXBYDAYosPEhcFgMBiiw8SFwWAwGKLDxIXBYDAYosPEhcFgMBiiw8SFwWAwGKLDxIXBYDAYosPEhcFgMBiiY97ZBjAY3QEiwpUrV5CZmQlfX1+Eh4dDIpF0tlkMRpeFiQuD0Q5FRUW45557cP78eeHvIiIisH//fnh5eXWiZQxG10VCRNTZRjAYXRUiwujRo3H58mVoNBrh783NzTFs2DDExcWxFQyD0QJMXBiMNrh8+TKGDx/e5r+Hh4d3oEUMRveABfQZjDbIzMxs899v3LjRQZYwGN0LJi4MRhv4+vq2+e9+fn4dZAmD0b1g4sJgtEF4eDgiIiJgbt4098Xc3BwREREICwvrJMsYjK4NExcGow0kEgn279+PYcOGNfn7YcOGYf/+/SyYz2C0AhMXBqMdvLy8EBcXh23btgEAtm3bhnPnzrE0ZAajDZi4MBg6IJFIEBgYCADC/zIYjNZh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJg6IBGo0FBQQEAQCaTdbI1DEbXR0JE1NlGMBhdmcTERLzzzjtwd3eHVCpFUVER5s2bh6VLl3a2aQxGl4WtXBiMNigrK8NTTz2Fr7/+GuPGjUNCQgL27NmDyspK/Pjjj51tHoPRZWHiwmC0wdKlS7Fnzx54eHigqKgIly5dglQqxYsvvoiPP/64s81jMLos5p1tAIPRlTlx4gQ++eQTXLx4Efn5+eA4DpMmTYJEIsHSpUuhUChgbW3d2WYyGF0OJi4MRjOICIWFhYiPj4dWq0Xv3r1RX18PlUqFmzdvIjAwEABQV1cHpVIJKysrSCSSTraawehasIA+gwFArVYjNTUV8fHxuHLlCsrKylBeXo4zZ87g9OnTCAkJwUcffYQ33ngDGo0GHMfBz88PR48eha2tLaysrGBtbQ0bGxuYmZl19uUwGJ0OExfGP5aamhokJCQgPj4e165dg0KhgJubG/r06YOTJ08iLi4OY8aMQV5eHr7//nvcuHEDW7ZswY4dO/Dmm2+irKwMvXv3xuzZsxEWFgaVSgUAsLCwEITG0tKyk6+SwegcmLgw/jEQEXJzcxEfH4/4+HhkZmYCAPz8/BAWFobAwEDs3bsXn332GVxdXbFu3TrMmzcPZWVlWL16NQoKClBTUwMnJyf85z//wZAhQ7B7927ExcWhf//+WLRoEXr27Am5XA6FQgGO4yCVSgWhsbKyglTKcmgY/wyYuDDuaFQqFZKSkgRBqayshLW1NYYOHYrw8HCEhITAwcEBhw4dwptvvomioiI899xzePXVV2FnZ9fkWBcvXsTixYuxZ88eDBkyRPj79PR0bN++HQUFBYiKisJ9990He3t7qFQqQWjUajUAwMrKCjY2NrC2toa5OQt5Mu5c2NPNuOOorKwUxCQpKQkqlQqenp4YOXIkwsPDERAQIAzsmZmZePzxx3H8+HFMmjQJv/76K3x9fVs8rp2dHczMzG5bfQwcOBDvvPMOoqOjsXfvXly6dAn33nsvxo8fDycnJzg5OUGr1QpCU1NTg+rqapibmwtCY2lpyZICGHcUTFwY3R4iQlZWlhCMz8nJgVQqRUBAAO6//36EhYXB29u7yeAtk8mwceNGfPnll/D09MTWrVtx1113GTzAS6VSTJo0CcOHD8evv/6Kbdu24dSpU3jooYfg5+cHMzMz2Nvbw97eHkQEhUIBhUIBmUyGuro6wX3G/2HuM0Z3h7nFGN0ShUKBa9euCSuU2tpa2NnZISQkBGFhYQgJCbnNrQXcEqLffvsNK1asQEVFBV588UW8+OKLsLGxafecycnJmD9/Pnbv3o2goKA2P5uVlYVt27YhJycHY8aMwfz58+Ho6NjiZ1UqlSA2fFKApaWlsKqxsLDQ4Y4wGF0LJi6MbkNZWRmuXLmC+Ph4pKSkQKPRwMfHB2FhYQgPDxdWCK2Rnp6O119/HTExMZgxYwbee+899OvXT+fz6yMuAMBxHGJjY/Hrr7+C4zjMmzcPkyZNanNVotVqBaFRKBQgIpibmwsrGlZTw+guMLcYo8ui1Wpx48YNwd1VUFAAMzMzBAUF4cEHH0RoaCg8PT3bPU59fT0+/PBDfPvtt+jduzd27tyJadOmmdx+qVSK8ePHY9iwYdi3bx927twpuMoCAgJa/I6ZmRns7OxgZ2cHIoJSqYRCoYBcLkd9fT0kEkkT9xmrqWF0VdjKhdGlkMlkSExMRHx8PBITE1FfXw9HR0eEhoYiLCwMQ4cO1bndChFhz549ePvtt1FTU4NXX30Vzz//PKysrAyyTd+VS3NycnKwbds2ZGVlISIiAvPnz4eLi4vO31er1YLQNHaf8anOzH3G6EowcWF0OkVFRcLqJC0tDRzHoU+fPggPD0dYWBh8fX31dgUlJSVh2bJliIuLw5w5c/Duu++iV69eRtlprLgAtwTv7Nmz2L17N1QqFebOnYspU6bonZbMcZwgNEqlEhzHwczMrElNDXOfMToT5hZjdDgajQZpaWlCML64uBgWFhYYMmQIlixZgtDQULi5uRl07JqaGqxfvx6bNm1C//79sXfvXkyYMEHcCzACiUSCsWPHIiwsDAcOHMCePXsQGxuLhx56SC/BkkqlsLW1ha2tLYioSU1NQ0MDJBJJk5oa5j5jdDRs5cLoEOrq6pCYmIgrV67g6tWrkMvlcHFxQVhYGMLCwjBkyBCjWqVwHIeff/4Zq1evhkwmw+uvv46nnnpK1PYrYqxcmpOfn4/t27cjPT0dw4YNw8KFC+Hq6mrUMTUajSA0SqUSwK2WNI1rahgMU8PEhWESiAj5+fnC6iQjIwNEBF9fX0FQ+vbtK4rrJiEhAcuWLcOlS5dw3333Yc2aNfD29hbhKppiCnEBbt2rCxcuYNeuXZDL5Zg1axamT58uSgyFd5/xf/iWNLzQWFtbM/cZwyQwtxhDNNRqNZKTkwVBKS8vh5WVFYKDg/HEE08gJCQEzs7Oop2vsrIS7777Ln744QcMGjQIBw8exNixY0U7fkchkUgQERGBoUOH4uDBgzhw4ADOnDmDRYsWYejQoUYdu7H7DICQfdbcfcYLDWtJwxALtnJhGEV1dbUgJteuXYNKpYK7u7tQezJo0CDRs5i0Wi22bt2KtWvXQqPRYPny5XjsscdMni1lqpVLc4qKirB9+3akpKQgJCQEixYtgru7u+jn0Wg0gtAolUoQkdDRma+pYTAMhYkLQy+ICNnZ2YKgZGVlQSKRYODAgYK7y8fHx2SulkuXLmHZsmVISEjAokWLsGrVKpMMvC3RUeIC3LrPly9fxq5du1BbW4u77roLM2fONFm8pHFLGrlc3qSjM2tJwzAEtgZmtItSqURSUpJQHV9dXQ1bW1sMHToU06dPFzoLm5KysjKsWbMG27dvx9ChQ3H48GGMHDnSpOfsTCQSCYYPH47g4GD88ccf+PPPPwVXWWhoqOjiLZFIYGNjAxsbG7i4uAgtaeRyOWQyGQA02RCNuc8Y7cGeEEaLVFRUCGKSnJwMtVoNb29vjBkzBuHh4Rg4cGCHpLdqNBps2bIF7733HiQSCT766CM88sgj/5jUWisrK9x7770YO3Ysfv75Z3z55ZcYMmQIHnzwQZ26ExiKpaUlLC0t4ejoKLSkkcvlqK2tRU1NjdCSht8QjSUFMJrD3GIMALeyijIzMwV3V25uLszMzBAQEIDw8HCEhoaaJAOrLeLi4rBs2TIkJydj8eLFeOuttwyufxGDjnSLtQQRITExET///DOqqqowffp0zJ49u0NjI3xLGj7VWavVCi1p+Aw05j5jAGzl8o9GLpfj2rVruHLlChITE1FbWwt7e3uEhobi7rvvxtChQ4Uso46kpKQE77zzDn755ReEh4fj+PHjCAsL63A7uhoSiQShoaEICgrC4cOH8eeffyIuLg4PPPAAhg8f3iGrh8a9zYBbGYK80FRWVgJgHZ0Zt2Di8g+jpKREaLWSmpoKrVaLXr16YcKECQgLC4Ofn1+nzTzVajW+//57rF+/HlZWVvj888/x4IMPsplwMywtLTF37lyMGTMGO3fuxLfffotBgwbhoYceQs+ePTvUFgsLC1hYWDRxnykUCsF9ZmZmJggNa0nzz4K5xe5wtFot0tPTBXdXYWEhzM3NERQUJLi7Oirbqi1OnTqFZcuW4caNG1i6dCmWL1+uV1PHjqCz3WKtce3aNezYsQPl5eWYMmUK5s6dq9P+NKakcUdnhUIBjUbDOjr/w2ArlzuQ+vp6XL16FfHx8UhISIBMJoOzszNCQ0PxwAMPYMiQITp3FjY1BQUFeOutt7B//35ERETg5MmTCA4O7myzuhXBwcFYu3Ytjh49ioMHD+L8+fOYP38+Ro0a1WkrhZbcZ7zQVFVVAfj/js6sJc2dCROXOwAiQmFhoeDuSk9PBxGhX79+mDFjBsLCwtC/f/8u5ZJQKpX45ptvsGHDBtjb2+Obb77BggULupSN3Qlzc3PcddddGDVqFHbt2oVNmzYhJiYGDz30EHr37t3Z5gnuMwcHhyYtaerr61FbWyt0dGYtae4cmFusm6JWq5Gamiq4u0pLS2FpaYkhQ4YI7q6u5lbiOXHiBN544w1kZ2fjySefxOuvv97qFsBdia7qFmuJlJQUbN++HcXFxZg4cSLuueeeTknOaA++ozOf6sy7zxrX1DD3WfeErVy6EbW1tUhISEB8fDyuXr0KhUIBNzc3oTI+KCioS7sXcnNzsWLFCvzxxx+IjIzE1q1bMWjQoM42644kMDAQq1atwokTJ3DgwAFcvHgR999/P8aOHdulVgW8kFhZWcHJyUloSSOXy1FdXY3q6mqhJQ1fU8PoHjBx6cIQEXJzc4XVSWZmJgDA19cXc+bMQXh4OHr37t2lBouWUCgU+Pzzz/HJJ5/A1dUVmzdvxrx587q83d0dc3NzTJ8+HREREdi9eze2bNmC6OhoPPzww+jXr19nm9ci5ubmsLe3h729PTiOE2pqGhoaUFdXJ7Sk4TdEY5mEXRfmFutiqFQqJCUlCYJSWVkJa2trDB06FOHh4QgJCekWLiTgljgePnwYb775JgoLC/Hss8/itddeg52dXWebZhDdyS3WEunp6di+fTsKCgowbtw43HvvvbC3t+9ss3Sm8YZoarUaAJpsiMZa0nQt2K/RBaiqqhKC8UlJSVCpVPDw8MDIkSMRFhaGQYMGdbsXJysrC8uXL8exY8cwceJE7N69G35+fp1t1j+agQMH4p133sHJkyexb98+XLp0Cffeey/GjRvXLVYAfEsaJycnaLVaQWhqampQXV0Nc3PzJhuisZVx59K9Rqw7BCJCVlaWsDrJzs6GVCrFwIEDcd999yE8PBze3t7d8uWQyWT45JNP8MUXX8DDwwM//fQTZs2a1S2v5U5EKpVi8uTJGDFiBH799Vds3boVp06dwkMPPQRfX9/ONk9nzMzMBPdZ447OMpmsifuMdXTuPJhbrINQKBS4fv06rly5goSEBNTU1MDOzg4hISEICwvD0KFDu5WLojlEhN9//x1vvvkmysvL8e9//xsvvfRSpxfziUl3d4u1RFZWFrZt24acnByMHTsW999/f7dxu7YGn32mUCigUqkAoMmGaKwlTcfAxMWElJWVCe6ulJQUaDQa+Pj4CNld/v7+d0SaZXp6Ol5//XXExMRg+vTpeO+999C/f//ONkt07kRxAW41LY2NjcWvv/4KjuMwb948TJo06Y6Y7TduSaNQKEBEQkdn1pLGtDC3mIhwHIeMjAzB3ZWfnw8zMzMEBgZi0aJFCAsLM2mb9I6mvr4eGzZswDfffINevXrh559/xvTp0zvbLIaeSKVSjB8/HsOGDcPevXuxc+dOxMbG4sEHH0RAQEBnm2cUZmZmsLOzg52dXZOWNHK5HPX19awljQlhKxcjkclkTVqt1NfXw9HREaGhoQgLC0NwcPAd5RoCbrnAfv31V7z11luoqanBK6+8ghdeeOGO3xb3Tl25NCcnJwfbtm1DVlYWIiIisGDBAjg7O3e2WaLDt6SRy+WC+4xvSWNjY8PcZ0bCxMUAioqKBHdXWloaOI5Dnz59EB4ejrCwMPj6+t6xS+3k5GQsW7YMZ8+exZw5c7Bu3bou0V6kI/iniAtwawJx5swZ7NmzByqVCnPnzsWUKVO6XdairvAtafgMNCISWtLwNTV36jttKu7MJ0VktFot0tLShJ0Zi4uLYWFhgcGDB2PJkiUIDQ3t1E2sOoKamhqsX78emzZtQv/+/fHrr79i4sSJnW0Ww0RIJBJERkYiPDwc+/fvx549e3D69Gk8+OCDd6SwSqVS2NrawtbWVmhJwwtNQ0OD0EmAT3Vm7rP2YSuXVqirq0NiYiLi4+ORmJgIuVwOFxcXIRg/ePDgO94NBNya0e3cuROrV69GQ0MDli1bhqeffvof2Ybjn7RyaU5+fj62b9+O9PR0DBs2DAsXLoSrq2tnm9UhaDQaQWiUSiWAW404G9fUMG6HicvfEBEKCgqE1UlGRgaICAMGDEBYWBjCw8PRt2/ff9TSODExEcuWLcPFixdx3333Yc2aNR2+1XFX4p8sLsCtd+T8+fP45ZdfIJfLMWvWLMyYMeOOdZW1ROOOzgqFAhzHQSqVCkLDOjr/P/+cp6IF1Go1kpOTheyu8vJyWFlZITg4GE888QRCQkLuyEBme1RVVWHdunX44YcfEBAQgN9++w2RkZGdbRajk5FIJBg1ahRCQkJw8OBBHDhwAGfOnMGiRYswdOjQzjavQ2jsPgPQZEO0xu4zXmj+ScLbnH/clVdXVwudha9duwalUokePXoIwfjAwMB/bJaIVqvFtm3bsHbtWqjVaqxbtw6PP/74P/Z+MFrGxsYGCxYsQGRkJHbs2IHPPvsMISEhWLRoUZfY1bQjaamjc+OWNHxHZ76m5p/EHe8WIyLk5OQI7q6srCxIJBL4+/sL7i4fH59//FL28uXLWLZsGeLj47Fo0SK888478PDw6GyzuhT/dLdYSxARLl++jJ07d6Kurg533XUXZs6c+Y+PQzRuSSOXywX32T+pJc0duXJRqVRNWq1UVVXBxsYGISEhmD59OkJCQuDg4NDZZnYJysvLsXr1amzfvh3BwcE4dOgQIiIiOtssRjdBIpFg+PDhCA4Oxu+//44//vgDZ8+excKFCxEaGvqPnbRJJBLY2NjAxsYGLi4uTTZEk8lkANBkQ7Q70X12x1xRRUWFEDtJSkqCWq2Gl5cXRo8ejbCwMAQEBLD0wUZoNBps2bIF7733HgBgw4YNWLJkCbtHDIOwsrLCfffdJ7jKvvzySwwZMgQPPvjgHdWVwlD4js6Ojo5CSxq5XI7a2lrU1NQILWn4DdHuBFHu1m4xjUaDffv24cqVK8jNzYWZmRkCAgKEdOF/cmZTW1y8eBGvvvoqkpKSsHjxYqxcuRI9evTobLO6PMwtphtEhISEBOzcuRNVVVWYPn065s6dy2J3LcC3pOFTnbVaLaRSKaysrGBvb9+t4zTdSlzy8/Nv8+VevXpVWHq6uLgIM28WL/h/cnJymvx/folua2srLMdVKhUsLCy67A6FHU1+fv5tf6dUKpGXl4fevXsLL71Go2H3rBFlZWXCf3Mch/z8fFRWViI0NLTJ57RaLby8vDrYuq6JRqNp8t9yuRxKpRJ2dnZNWkcRUbcS6G4lLjt27ICVlRXGjh3bbkV8d/oRTA1f+NUWL7zwAogI33//fQdY1PXhe001huM4qNVqWFhYQCqVQqlU4s0338QXX3zRCRZ2TfgdIhtDRLe5eT7++GO88cYbHWVWl0bXIbiioqJbeRi6lbgQEWpra/HXX3/ByckJEydOvCN8k53N+fPnERYWhoaGBri4uHS2Od0CmUyGt956C+vWrbvjGpOamsOHD2PEiBF3fMsksSAiVFVVwdnZuVtlmHUrceEhIqSmpuLSpUt4+OGHmcAYiYeHB0pLSzvbjG6DTCbDihUr8MEHH/zjU271pbS0FElJSawvnY7wwuLk5NTtkm26jww2QiKRIDAwEFOmTMEPP/zQ2eZ0e55//vnONqHboFar8frrr+PDDz9kwqInSqUSO3bsYMKiI0SE6upqODo6djthAbrpyqUxubm5iI+Px913393ZpnRLOI6DRCJhqz8dICI8++yz+Oyzz5iw6AnHcfj888/x73//u1u5djoLIkJNTQ3s7e27bQ1Mt/+V+/TpAw8PD6SlpXW2Kd2SJ598kgmLjqxevRrvvfceExY9ISJ88803eOaZZ5iw6AAvLHZ2dt1WWIA7QFwAYPTo0YiJidEpK4rRlH379nW2Cd2CPXv24L777mMJDwawdetWPPzww926ZqOjaCws3T3j9Y4QFwB44okn8P777+uc1se4xcaNGzvbhC5PfHw8tFotgoODO9uUbgUR4eDBg5g4cSKcnJw625wuDx9juROEBbgDYi6Nqa2txcmTJ1n8pRmJiYkIDg6GRqOBVCoVltpFRUXw8vJibrE2SE9Px2+//YbXXnuts03pVmg0Gvzxxx/o37//P6YdvzHwwuLg4NCtXWGNuTOu4m8cHR1hbW2Nqqoq5r5oxOXLl/Hnn38K27cuXLgQgwYNwsSJE5GamtrZ5nVJiAjnzp3D2bNn8eqrr3a2Od0Gvgv5qVOnMGPGDNYpQwe6c7pxW3SrlYtWq9Xpc++88w7WrVtnYmu6DxqNBlqtFmZmZuA4DuvXr4eLiwtGjhyJYcOGNfnsnTJrMpYNGzbAz88Pc+bMafez7J79P7/88gs8PT0xZsyYdoP3d9JAagyVlZVwcnLSKdmhO3kZupW4FBcX3/Z3Wq0WcrkcNjY2wsOqVCrRt2/fjjavy5KZmXnb3xUVFbXY2NPX17cjTOryJCUlwd7evsnfNW//wsOetf8nOzu7SccCjuMgk8lga2t72+DJuiXfQqVS3XZviAgajQbm5uZNBKVbTWSom3Pz5k168MEH6ebNm51tSrchISGBXFxcKCEhobNN6VYkJSVRUFAQJSUldbYp3Ybs7GxaunQpZWdnd7Yp3QqVSkV5eXmkUqk62xSDuWOyxRgMBoPRdWDiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwGAzRYeLCYDAYDNFh4sJgMBgM0WHiwmAwTIJGo0FeXh5qamrQ0NDQ2eZ0GzQaDW7evInMzEzU19d3tjkG063FhYhw7do15OTk4Nq1ayCizjapy0NESE5OhkqlQnJyMrtnOkJESEpKQm1tLZKSkth9a4fExETcf//9+Omnn9CzZ0+89tpr2Lx5c2eb1eXh79vGjRtx4MABPPLII933vlE3pbCwkCIiIgiA8CciIoKKioo627QuC7tnhsHum36UlpbSiBEj6McffySlUkkcx9HmzZvpvffeo88++6yzzeuy3Gn3rVuKC8dxFBERQebm5k1eeHNzc4qIiCCO4zrbxC4Hu2eGwe6b/syePZvy8vLIycmJ7r77bvrmm29IKpXSX3/9RQMHDmT3rBXutPvWLcXl0qVLTV705n8uX77c2SZ2Odg9Mwx23/TH2tqaOI6jEydOEACSSCT08ssvk1arpY8//pjOnj3b2SZ2Se60+9YtYy6ZmZlt/vuNGzc6yJLuQ3v3hN2zpjQ0NGDPnj144YUX2vwcu2+3yMnJwU8//YQ5c+ZApVIBANLT0wEAVlZWyMzMhEajQV1dHW7evNmZpnZJ6urqoNVqAdxB962z1c0Q2GxSP+Lj42nkyJHsnrVDfX097dq1i+6//36ytbUlADRw4EB235qh1Wrp6tWr9PXXX9P9999Pbm5ut92XixcvkoODAy1btoxOnDhB1tbWtHv3bnJ3d/9H3rPWuHbtGj377LNkb29/x923bikuHMeRp6fnbQ8084M3JS8vjx555BGSSCQ0cOBA8vf3JzMzM3bPGlFXV0c///wz3XfffWRjY0MAKDw8nN5//33KyMhgMRciUigUdObMGVq/fj3Nnj2bnJycBLcNfz+sra0JAPXo0YN69+5Nrq6u9NVXX5FSqSSNRkP79++nhx56iAIDA/8R96wtlEol7dy5k8aNG0cAyM3NjTw9PcnCwoLc3d3vmPvWLcXlypUrJJVKqU+fPiyDpwVqamrozTffJGtra+FhValUVFRUxLKeiKi2tpZ27NhB99xzjzAoDhs2jNavX083bty47fP/tPtWXV1Nhw4dojfffJPGjRsn3CMLCwtycnIiiUQiTFh69uxJACg0NJTeffdd6t27N3l5edGOHTuoZ8+eFBoaSlFRUeTq6kpBQUF37D3ThdzcXFq5cqUwMR43bhw9+uijZG1tTUFBQZSQkEArVqwgc3PzJvfNwcGhW963bicuWq2WRo0aRYMHDyalUkmXL1+mXbt2dbsloylQqVT05Zdfkru7O1lbW9Obb75JNTU1TT7Dcdw/8p7V1NTQtm3b6O677yYrKysCQCNGjKAPP/yQsrKy2v3+nXzfCgsLadeuXfT8889TaGgoSaVSAkAuLi40cOBA8vDwIABkY2NDs2bNogULFpC3tzcBoJkzZ9Lx48dpz549ZGtrS8OGDaO8vDwiunXPYmNjacuWLXTx4sVOvsrOQavV0tGjR2nevHkklUrJwcGBnnvuOYqOjqa77rqLANDzzz9PMpmMOI6joUOH0rx584T7tnbtWgJAhw8f7uxL0ZtuJy6bNm0iABQTE9PZpnQZOI6jffv20cCBA0kikdAjjzwivOD/ZKqrq+mnn36iuXPnCoISERFBH330Ed28ebOzzesUOI6j1NRU+v777+mRRx6hAQMGCKuxAQMG0JQpU2j8+PHk7u4uuLmWLl1K33//PT3//PNkb29PlpaWtHTpUrp+/TpxHEdr1qwhAPTAAw9QQ0NDZ19il6CyspI2btxI/v7+BICCg4Pp22+/pdraWvr999/J3d2dPDw86I8//hC+ExcXRwDo0KFDwt9xHEcTJ04kPz8/ksvlnXEpBtOtxKWiooLc3Nzo4Ycf7mxTugznzp2jyMhIAkBTpkyh+Pj4zjapU6mqqqIff/yRZs+eTZaWlgSARo0aRR9//DHl5OR0tnkdjlqtpgsXLtDGjRvpnnvuEURDKpVSWFgYPfnkk/TCCy/Q7NmzhaCyr68vvfrqqxQbG0vnzp2jhQsXkpmZGbm4uNCKFSsEF01DQwM98MADBIDWrFnT7WICpuDSpUu0dOlSsrGxIQsLC1q0aBHFxsYSx3HU0NBAzz77LAGgWbNmUUlJSZPvLlmyhPr160darbbJ3yclJZG5uTmtXbu2Iy/FaLqVuDz11FPk6OjYLf2PYpOZmSm82EOGDKFDhw79Y1/uyspK2rJlC911111kYWFBAGjMmDH0ySefUG5ubmeb16HU19fT8ePHadWqVTR58mSys7MTAu7jx4+nlStX0k8//UQffvghTZ48WUhUGDFiBL377rt0/fp10mg0dPDgQRo/frywovniiy+ovr5eOE9+fj4NGzaMbG1tac+ePZ14xZ2PTCajH374QcjI7NOnD7377rtUXFwsfCY+Pp4CAwPJ2tqavvrqq9ve1aqqKrKxsaF33323xXMsW7aMrK2tdXLhdhW6jbhcuHCBJBIJff75551tSqdSUVFBL7/8MllYWFDPnj1p8+bNpNFoOtusDqeiooI2b95MM2fOJAsLC5JIJBQZGUmffvrpP8olWFpaSvv27aNXXnmFRo4cKYiFi4sLzZkzhz744AM6c+YMXbx4kVavXk1hYWFCcH769On09ddfU35+PhERyeVy+u9//0uDBg0SVnx79uy57fk6f/48eXt7U+/evenKlSudcdldghs3btBrr71Grq6uBIBmzJhBv/32W5P7pdVqacOGDWRhYUGhoaGUlJTU4rE+//xzMjc3b3XiXFdXR7169aK5c+ea5FpMQbcQF41GQ8OHD6fQ0FBSq9WdbU6noFAo6KOPPiJnZ2eyt7enNWvWNJlJ/hMoLy+nTZs20fTp08nc3JwkEglFRUXR559/TgUFBZ1tnsnhOI4yMzPpxx9/pMcff1wQAX62/NBDD9E333xD169fJ6VSSSdPnqQXX3yR+vXrRwDI0dGRFi5cSDt37qTq6mrhuGVlZbR69Wry8PAgiURC99xzD505c6ZFG7Zv305WVlY0evTof6QHQaPR0G+//UYzZswQRPzVV1+ljIyM2z6bn59PkydPJgD02muvkUKhaPGYHMfR4MGD6b777mvz3Lt37yYAdPDgQVGuxdR0C3H55ptvCECrD/ydjFarpR07dlC/fv3IzMyMnn766SbL7TudsrIy+u9//0tTp04lMzMzkkgkNH78ePryyy+psLCws80zKRqNhhISEuiLL76gBQsWCGm/vCv06aefpu3btwuxpPr6evr111/pX//6lzCb9vHxoWeffZaOHDlCSqWyyfHT0tLo6aefJhsbG7KxsaFnn32W0tPTW7RFq9XSm2++SQDoX//6V6sD5Z1KSUkJvffee0L5w8iRI2nLli0kk8la/PyePXvIxcWFevbsScePH2/z2KdPnyYAdPTo0TY/x3EcTZs2jfr379/qebsSXV5cSktLycXFhR599NHONqXDiYmJoREjRhAAmjNnDiUnJ3e2SR1CaWkpfffddzRlyhQyMzMjqVRKEydOpK+++uqOni3L5XI6deoUvfvuuzRz5kyhWNHCwoJGjx5Ny5Yto4MHD1JFRYXwnZKSEtq0aRPNnj1bqEcZMmQIrVy5ki5evHibb5/jODp9+jTNmzePJBIJeXh40Nq1a6msrKxVu+rq6ujuu+8miURCGzZs+MfE9vh79eCDD5KFhQVZW1vT0qVL20yrrquro6VLlxIAuu+++6i8vLzd8yxevJgGDBhwWyC/JdLS0sjS0pLefvttva6lM+jy4rJ06VJycXGh0tLSzjalw0hNTaW7775bKO47efJkZ5tkckpKSuibb76hSZMmkVQqJalUSpMmTaJvvvnmjl2pVVVV0e+//05vvPEGjR07Vshuc3BwoOnTp9O6desoOjr6tllqeno6ffjhhzR27FiSSCQklUpp3Lhx9PHHH7dYBEp0axW0e/duoRg0MDCQNm3a1G56a3Z2Ng0dOpQcHBy6jTvGWOrq6ujbb7+loUOHEgDy8/OjjRs3NhH1ljh//jz5+fmRnZ0dbd68WScRrqioICsrK1q/fr3O9q1YsYKsrKxadMV1Jbq0uJw9e5YA0DfffNPZpnQIJSUl9Mwzz5CZmRn17duXtm/frtNsprtSVFREX331FU2cOJGkUimZmZnRlClT6LvvvrsjJxN5eXm0Y8cOevbZZyk4OFhon+Ll5UXz58+nzz//nK5cuXJbAF2r1dK5c+do+fLlFBgYKBQ03n333bRly5Y271VdXR19/vnn1L9/fwJAEydOpN9//12n5yo2Npbc3d2pf//+dP36daOvv6uTlJREzz//PDk4OJBUKqV58+bR0aNH271XGo2G1q5dS2ZmZjRy5Ei9Bv1PPvmELCwsbktLbouGhgbq27cvzZw5s0uvIrusuKjVagoNDaXhw4ff8dlQDQ0NtG7dOrK3tycnJyfasGFDtyuY0pXCwkL68ssvafz48SSRSMjMzIymTZtG//3vf9t0zXQ3OI6jpKQk+u677+jhhx8Wgup8M8zHHnuMtmzZQjdu3GhxgFAoFHTo0CF66qmnhGr4Hj160KOPPkr79+9vt1ixsLCQli9fTi4uLmRmZkYPPvigXp0FNm/eTBYWFjR+/Pg76ndpjkqlol9++YUmTJhAAMjT05NWrlypcwr7zZs3aezYsSSVSumtt94ilUql87k5jqNBgwbRggUL9LZ7//79BID27t2r93c7ii4rLp9//jlJJBK6cOFCZ5tiMjQaDW3ZsoV8fHzIwsKCXnrpJZ18tN2NgoIC+vzzzykqKookEgmZm5vT9OnTadOmTXfM9SqVSoqLi6MNGzbQ3LlzhU7BZmZmNHz4cHr55Zfp119/bXOGWlVVRdu3b6f58+eTg4ODUGPyyiuv0KlTp3SaZF27do2WLFlCFhYW5ODgQK+88opexaMajYZeeeUVAkBPPvnkbUkAdwp5eXn09ttvk5eXl9Dna+fOnXpd77Zt28jR0ZH69u1LsbGxetsQExNDAOjEiRN6f5fjOJo1axb17t27y2aNdklxKS4uJkdHR3rqqac62xSTceTIEcGnO3/+/FZ95d2V/Px8+vTTTykyMlIQlJkzZ9L//ve/dn3X3YHa2lo6evQovfXWWzRhwgSho7KtrS1NmjSJ3n77bTp27BjV1dW1eZzc3Fz64osvaMqUKUKNyvDhw2ndunV07do1ndweHMfRsWPHaPr06UKG2IYNG5qkG+tCdXU1zZgxg8zMzOiLL77o0i4XQ+A4jo4fP0733nsvmZmZkb29PT377LN07do1vY5TVVVFDz74IAGghx56SO/7zPPggw+Sv7+/wfc5MzOTrKysaPny5QZ939R0SXFZvHgxubm53TGz2sYkJibStGnTCACNHTuW4uLiOtsk0cjNzaVPPvmExowZI2Q5zZo1i7Zs2UKVlZWdbZ5RFBcX0549e+jFF1+kYcOGCVsXuLm50d13300fffQRnT9/vl23CMdxlJiYSGvWrKHw8HChff+0adPoq6++0qsAVKlU0k8//UQhISFCZ+Jt27bp5ZrhSU9Pp0GDBpGzs3O7KbHdjaqqKvr0008pICBAyKb7+uuvqba2Vu9jnTp1ivr06UOOjo60fft2g20qKysjS0tL2rBhg8HHICJatWoVWVhYUEpKilHHMQVdTlz4peKmTZs62xRRyc/Pp0cffZQkEgn5+/vTr7/+ekfMDHNycujjjz+mUaNGEQCytLSk2bNn048//khVVVWdbZ5BcBxHGRkZ9L///Y+WLl0qNB8EQP3796fFixfTf//7X0pOTtbpN1Sr1RQdHU0vvfSSEFh3cHCgBx54gH7++We9Z75VVVX0wQcfkI+PT5POxIY+T8ePHxc6IKelpRl0jK7I5cuX6fHHHxf6fC1cuJBOnTpl0H1SqVS0YsUKkkqlFBUVRdnZ2UbZtmHDBrK0tDQ6niWXy4WGo11tPOlS4qJSqWjIkCE0atSoOyZLqra2llasWEE2Njbk5uZGX3zxhUEzy67EzZs36aOPPhLSWi0tLWnu3Lm0detWg10EnYlGo6HLly/Tp59+Svfff7/gh5dIJBQSEkLPPfcc7dy5U69VRX19Pe3du5ceeeQRIf7Ss2dPeuaZZ+jw4cMGFSFmZ2fTyy+/fFtnYmP46quvhKSK7r66JLo12P7444/CZKd37960bt06o+qj0tPTacSIEWRubk7vvvuu0QlGHMeRv78/Pfjgg0Ydh+ePP/4gALRr1y5RjicWXUpcPv74Y5JKpXdEvyK1Wk1ff/01eXh4kLW1Nb3xxhvdcuDlycrKog8//FAo6rSysqJ58+bRtm3bbtszpqsjk8no5MmTtHbtWpo2bZoQPLe0tKTIyEhavnw5/fHHH3qvvEpKSmjz5s00Z84coaBx8ODB9Oabb9KFCxcMnjBdvHix1c7EhqJSqeiZZ54hAPTiiy92+7ZKmZmZ9J///EcQ8mnTptH+/fuNui6O42jTpk1kZ2dH/v7+oiUXnThxQvRtQ+bNm0c9e/Y0yNVnKrqMuBQUFJC9vT09//zznW2KUXAcRwcOHKBBgwaRRCKhxYsXd9tW75mZmbR+/XoaNmyY0Fn3nnvuoR07dnSph7g9Kioq6LfffqP//Oc/NGrUKKFzspOTE9111130/vvvU2xsrEHp3+np6bRhwwYhcYFvoPnRRx8ZVeSm1Wrb7UxsKOXl5TRx4kQyNzen//73v0Yfr7PQaDT0+++/08yZM0kikZCLiwu98sorrbaw0Yfy8nK69957CQA9/vjj7SZm6MOCBQtE37Y4OzubbGxs6LXXXhPtmMbSZcRl4cKF5OHh0W399ES3Ojfz+2JPnjy5W67AMjIy6P333xeCzTY2NnTffffRzp07RX3BTEl2djZt27aNnnrqKRo8eLAQL/Hx8aGFCxfSl19+SYmJiQa5N7RaLZ0/f56WL19OQUFBgujOnTuXNm/erFcxXEvo2pnYUJKTk8nX15fc3NwoOjpalGN2NKWlpfT+++9T3759hS4W//vf/0TbqOzYsWPUs2dPcnV1pV9//VWUY/KUlJSQhYUFffLJJ6Iel4jo3XffJXNz8y5T8NolxOX48eMEgH788cfONsUgbt68SYsWLRLcIH/++WeXC661RXp6Or377rsUGhoqpNPOnz+fdu3a1eUFRavV0tWrV+nrr7+mRYsWUe/evQUxCQwMpCeeeIJ++uknunnzpsG/CV/Q+PTTTwsFjW5ubrRkyRLat2+fKKsJfToTG8qff/5Jjo6ONHjw4G61LwjRLY/AmTNn6KGHHiJLS0uytramJUuWiFoHp1Ao6NVXXxU23uO3IhCT9evXk5WVlUnS8RUKBQ0cOJDGjRvXJcafThcXpVJJgwYNosjIyC5xQ/ShsrKSXn31VbK0tCQvLy/6/vvvu43vOjU1ldauXSvU2tja2tKCBQto9+7dXbYoi+jWC3TmzBlav349zZ49m1xcXIR03oiICHr11Vdp//79RmfhVFVV0Y4dO2jBggVNChpffvlliomJEe131qczsaFwHCfEM+fMmdOtYmR1dXX03XffCenWvr6+9NFHH4lepnD9+nUKCQkhS0tL+vjjj02SUKTVamnAgAG0ePFi0Y/Nc/ToUQJA27ZtM9k5dKXTxWX9+vVkZmZGV69e7WxTdEahUNDGjRvJxcWF7OzsaNWqVV1+hk90yyWyZs0aCg4OJgBkZ2dHCxcupD179nTZvc9ramro0KFD9Oabb9K4ceOEQLmdnR1NnTqVVq9eTX/99ZcogpiXl0dffvklTZ06VShoHDZsGK1du5auXr0q2uSH4ziKjY3VqzOxoSgUCnr00UcJAL3xxhvdppVScnIyvfDCC+To6EhSqZTmzp1Lhw8fFn3Q5ziOvvzyS7K2tqagoCBKSEgQ9fiN4Qf+06dPm+wcRETz588nT0/PTk8g6lRxyc3NJVtbW3r55Zc70wyd4TiOdu3aRf379yepVEpPPvlkl99TJCkpiVatWiXEHuzt7WnRokW0d+/eLrknRGFhIe3atYteeOEFCg0NJalUSgDIw8OD7r33Xvrkk0/o4sWLoqwcOI6jq1ev0tq1a4WkBXNzc5o6dSp9+eWXom+RrFar6ZdfftG7M7GhlJSUCN2Wf/rpJ5OcQ0xUKhXt3r2bJk6cKPzmK1asMFlCTHFxMd11110EgJ5//nmTvw/33XcfDR482OQemry8PLKzs6MXX3zRpOdpj04Vl/vuu4+8vb27xTI9NjZWGBRmzZrVZYJmzeE4jq5du0Zvv/220EHXwcGBHnroIdq/f3+XEhSO4yg1NZU2bdpEjzzyCA0YMECIl/j6+tKSJUto8+bNlJaWJtoLqVarKSYmhl5++WXhfA4ODrRgwQLasWOHSRJKjOlMbCgJCQnUp08f8vT07PJdIPLz8+mdd94R4lmRkZG0Y8cOk25I9vvvv5O7uzt5eHjQH3/8YbLz8BQVFZG5uXmHbdP+4YcfklQqNelKrD06TVwOHz5MAGjHjh2dZYJOpKWl0bx58wgAhYWFGdRkztTwLUXeeustIcvI0dGRFi9eTAcOHOgyHZbVajVduHCBNm7cSPfccw+5u7sTAJJKpRQWFkb//ve/6ZdffhF9NdjQ0ED79u2jJUuWCHUQ3t7e9PTTT9OhQ4dMNogZ25nYUPbt20d2dnYUFhYm+upLLDiOoxMnTtB9990n9Pl6+umnKTEx0aTnlclk9NxzzwmTRGOz+3Tl3XffJRsbmw7LhlWpVBQUFERjxozptIL0ThEXhUJBfn5+NHHixC4bxC8tLaXnnnuOzM3NqU+fPrR169Yu1TWA4zhKSEigFStW0MCBA4W6jX/961908ODBLrENbX19PR0/fpxWrVpFkydPJjs7OyF1d/z48bRixQo6fPiwSVaupaWltHnzZpo7d67QVDIoKIiWL19O58+fN+lvaWxnYkPhOI7effddAkD3339/l0zMqKqqos8++0yYBAUFBdFXX33VId6L+Ph4CgwMJGtra/r66687bOzRarXUr18/WrJkSYecj+fkyZMEgLZs2dKh5+XpMHFRq9WUlZVFqamptHLlSjI3N6ekpKSOOn2rtjQPxMtkMnrvvffIwcGBHB0daf369SZ1JbVlS3M4jqMrV67Q8uXLhX5Xzs7OtGTJEvrjjz9EERR97GlOaWkp7du3j1555RUaOXKkEBR3cXGhOXPm0AcffEBnz57V2U59bcnIyKCPPvqIIiMjSSqVCgWNGzZsMDoDqz1bmncm7tWrl0GdiQ21RSaTCenwq1at6rCJkK6/UXx8PD3xxBNka2tL5ubm9MADD1BMTIzoA3xL9mi1WtqwYQNZWFhQaGhoh407vC3ff/89AegU9+SDDz5I7u7uVFpaavB7bSgSIiKYmMTERLzzzjvw8vKCjY0NTp48CW9vbxw6dMjUp27TFltbW+Tn52PGjBlYsmQJtm7dipUrV6K4uBjPPvss3nrrLfTo0aPDbVm6dKnwGSLClStXsGfPHuzevRuZmZlwcXHBvHnzMH/+fEyePBmWlpYdZk9ju7KzsxEbG4vY2FicPn0aqampAIA+ffogMjISUVFRiIyMRFBQEKRSqei2cByHy5cvY//+/Thw4ACSkpJgbW2NqVOnYt68eZg9ezY8PDyMuynt2KJSqbBr1y58/PHHSExMRGhoKF577TUsWLAAFhYWRp9bF1tGjRqFn3/+GUlJSfjxxx8xf/580c+rqy2NfyOFQoE9e/bg66+/RlxcHHr16oWnnnoKjz/+OLy8vDrEnoiICBw6dAgnTpzAa6+9hnXr1sHKykr0c7dli1QqxaVLl/DUU0/hscceM/m5G1NUVAQ/Pz/0798fkZGR7b7XomJq9SotLaWIiAgqKCign376iUaOHElKpZI2bNhAP/zwg6lPr5MtH374IfXp00dwJ3TE3tRt3ZctW7bQxYsXadmyZULQ2dXVlR577DE6fPiwSRpftvc7aTQaSkhIoC+++IIeeOAB6tmzpxB8HzJkCD399NO0fft2Udw/bdmyadMmOnz4MD3zzDOCDa6urvTII4/Q3r17RXcFtWXLggULROtMbIwt69evJ2dn5w6J57Rny4YNG2jDhg30+uuvU48ePQgATZ06lfbt22fSGrD27s3x48dNdm5dbemsMS80NLRTbDG5uMyePZvy8vJIrVbTBx98QFKplNRqNalUKgoODjb16XW2ZeDAgaJXRBtqC+/ycnNzoyeeeIKOHj1q8k7KbdkTEBBATk5Owh4to0ePpmXLltHBgwdNUmmsy73p378/vfTSSxQdHW3SQastW/z8/ETpTCyGLUOGDOkQG3Sxxc/Pj5ydnenll1/usBb+3eXedKUxz9S2mNwtZmtri2eeeQYXL15Efn4+bt68iaioKEgkEtxzzz14+umnYW1tbUoTup0t8+bNQ0BAAKZNmwZzc/MuYU9NTQ0mTpyIkSNHwsbGplNtiYyMxPDhwyGRSExqR3u2dKVnpqvZ8q9//Quurq4dYosu9nSle/NPscXkI5dUKkXv3r1RX18PlUqFmzdvIjAwEABQV1eHw4cPIygoCP379zeJj1pXW2pra7FlyxZMnjwZ/v7+Jh+42rKlvr4ePj4+0Gg0HSYu7dnzxhtvdNgL0Z4tISEhHSIs7dlSV1endyzJULRaLSQSSZewheO4du+Lvb19h9iiVquhVCq7xO9EtzxBnW6LVquFUqmESqXq3GfGpOsiInrmmWcoPj6eOI4TCns4jiONRkP9+vWj1157jZ555hl64YUX6OOPP6aDBw9SWlqaSdxAbdni4+ND/fv3Jx8fHxo+fDi9+uqr9Ntvv5lsA6W2bOnfvz9t3LiRPvnkE/rll1/o8uXLJm3lUF1dTRMmTGjVnr59+9Jnn31GR48eNUkzPx6O46i4uJjmz5/fqi29evWijRs3ilal3xrV1dWUnJxM9957b6u29O7dm/bv32/S7Jvq6mqKi4ujH374gcaNG9fmM2PsHi9twXEcKZVKqq+vp+rqanrsscdatSUgIMCkdigUCqqpqaHS0lIqLi6m0tLSNu0ZNGiQyWzRarWk0WhIrVaTWq0mjUZDTz/9dIfaotFoqKGhgaqqqqi4uJgKCgqooKCg0+4Lj8ndYnK5HFFRUfj6669x48YNbNmyBTt27MDKlSvx0EMPISoqCoWFhUhPT0dGRgYyMjLQ0NAAc3Nz9OvXDwMHDsTAgQNFWdnI5XKMGDECmzdvRmZm5m22jBgxAufPn0dMTAxiYmKQnp4OiUSCkJAQTJgwAePGjUN4eLgoq4mjR4/ikUcewf79+1u0JTw8HFlZWcjMzEReXh60Wi3c3Nzg5+cHX19feHh4iDJ7T09Px969ewEAu3btwnfffXfb7zRjxgw4OjoiOTkZ9fX1cHZ2RmBgIAYPHgx3d3ejbQCAmpoaFBQUQKVSwc7ODosWLWrxmQkPD0dDQwMyMjJgb2+PMWPGIDIyUjQ7KisrUVhYiIaGBtjZ2cHV1RVz5869zZYVK1agZ8+eKC8vBwCMGzcO06ZNg7Ozs9E2cByHmzdvIiUlBQUFBbCyskJAQAD69euHOXPmtGiLvb09XF1dER4ejgkTJsDW1tZoO4gIGo0GKpUKGo0GAGBubg4LCwtoNBqMGzeuxd9oxowZmDhxIpycnER5RjmOg0qlgkKhgEqlAhHBzMwMVlZWsLKygqWlZbvjzLhx44y2A7h1TziOQ+NhUyKRNPljalsar0yUSiW0Wi0AwMLCQrgflpaWkEqlHXZfWqJDUpFLS0vxzDPPQKPRwN7eHhKJBM888wzGjh1722eJqF2x8ff3x4ABA/QWG7lcjldeeQUZGRlwdXWFhYVFm7YUFRUJQhMbG4vq6mo4ODhg7NixGD9+PMaPH48+ffrofT/OnTuHF154QYgblJeXt2mLSqVCTk4OMjMzcfPmTSgUCtjb22PAgAHw9fVF7969YWZmppcNWq0WJ06cwOnTpzFw4EDce++9qK+vx+rVq1FWVtaiPUSEvLw8JCUlITU1FQqFAu7u7hg8eDACAwMNGlgVCgUKCgpQW1sLBwcH9OrVC9bW1igtLW3TluLiYsTGxiIuLg5yuRyDBg1CVFQUQkJC9L4XRISKigoUFhZCLpfD0dERPXv2hJOTEwC0aUt9fT1OnDiBkydPQqlUYvTo0ZgxY4ZBKdC1tbVISUlBWloa5HI5vLy8EBQUhAEDBgjX1Joto0ePxsWLFxETEwOJRIIJEyZg2LBhBrk91Go11Go1NBqNMJBbWloK5+NpzZZhw4ahuroaZmZmcHZ2NmhSyA+g/CAK/P/gaWVl1eIEr7k9ALBkyRJERkYaHCekv11d/B/gdjFpiea2KJVKPPXUU5g6dareNjS/F22JSXu2mJubQyKR4Nlnn21xzBOTDhEXIsLhw4fRs2dP9OvXDw4ODjo/9ESEoqIipKenC4LTktj079+/3XqPPXv2IDo6GmvXroWFhQW0Wq3Otmi1Wly7dk0Qm8uXL0Or1aJfv37CqmbMmDHt+prj4+Px9NNPY/jw4fj0009hYWGB+vp6nW3hOA6FhYXIzMxEZmYmampqYGlpiX79+mHAgAHo379/u7GRmpoa7N69G/n5+Zg6dSrGjBnT5CXRxR6tVousrCwkJycjIyMDarUaPj4+CAoKQmBgIOzs7Nq0QavVori4GGVlZbC0tISPj48wmDemPVvUajUuX76M2NhYZGVlwdHRUVjNuLm5tWkDx3EoKytDUVERlEolXFxc0LNnz1Z/w7ZsUSgUiImJwbFjx1BXV4fhw4dj5syZ6NWrV7s25OTkIDk5Gfn5+bC0tMTAgQMRFBQEFxeXVr/Xmi0ymQwnT57ElStX4O7ujunTp6N///5t2gAAGo1GEBVeUCwsLGBhYdHuM9mSLRqNBtXV1dBoNHB0dNRpJcXHT5RKJTQaDSQSCSwsLGBtbQ0rKyudx4zG9hARZDIZzM3NdRKYlsQEuBV7a0tM2rOF4zjI5XJ4enq2O/nhV4uGiklbttTW1sLNza1Dan06RFwaGhrw119/YdSoUUa7LxqLTUZGBtLT09HQ0AAzM7Pb3GiNxaa0tBTvvPMOZs2ahdmzZxt7Sairq8OZM2cEscnNzYW5uTmGDRuGCRMmYPz48RgyZEiTByApKQlPPPEEAgMD8fXXX4vyA5eXlwtCU1JSAolEgl69esHX1xe+vr5wdHRs8vm0tDTs3bsXlpaWWLBgAXr37m20DWq1GhkZGUhOTkZmZiaICP369UNQUBACAgKaXCcRCa4njuPg5eUFd3d3UQKLhYWFiI2Nxfnz56FQKBAUFISoqCgEBwc3Ob5Wq0VpaSmKioqgVqvh5uaGnj17iuJKUqvVOHv2LA4fPoyKigoMHToUd911FwYMGNDkc3V1dUhNTUVqaipkMhk8PT2FVYoYbteioiIcOXIEeXl5GDRoEKZOnXrbylKr1QqCwgfpeUHRd/XXEkSE2tpayGQyWFtbw9nZucngTERQq9VQKBRQKpWCDZaWlsIKRQy3mkajgVwuF4SqJTt5dxePLqsTfeA4DiUlJbC2tr5t0mAqMWkJuVwOqVR654hLYWEhLl++jOnTp4tWTc7TXGwyMjJQX18viI2/vz8GDhyIo0ePorCwEGvWrBHdBgDIzs4WhObMmTNoaGiAq6srxo0bh3HjxqF37954/fXX0bdvX3z77bftzuwNob6+XhCavLw8cByHHj16wNfXF/369cO1a9dw5swZBAQE4N577zVJSrFcLkdaWhqSk5ORk5MDMzMz+Pr6YvDgwfD29kZxcTFkMhlcXV3Rs2dPk2QIKpVKXLlyBadOnUJ2djacnJwwduxYREREQKVSobi4GBzHwd3dHd7e3ibJgtNqtbh48SIOHTqEoqIiBAQEYPr06bCzs0NKSgry8vJgaWkJf39/BAYGtrvKMpTr16/j+PHjkMlkGD16NMaMGSMM6hzHCasDS0tLUQSlJRQKBaqrqyGVSuHk5AQiElYoLcVPTEFjgbGysjLI1WUsDQ0NqK6uhqurq3APTC0mzeHPZ+pyAqCDxCUlJUVwwZgaIkJxcXETN1peXh6uXr2KKVOmYPLkyRg4cCAGDBhgsgdZrVbjypUriI6ORkxMDBISElBZWQknJyc88cQTmDZtGiIiIkw6e1CpVMjOzkZmZiaSkpJw4cIFyOVyTJs2DXPmzDEoTqMvdXV1SElJwbVr15CWlgaNRgN/f39ERUUZ1BLGEPLz83Hy5EmcPHkStbW18PX1xaRJkzB+/PgOSa0mIsTFxWHbtm1ISUmBo6MjoqKiMGvWLPj7+3dIqrlSqRQmPdbW1pg4cSJCQkJgYWHRIefXarWQyWQoKSmBXC6Hvb09nJyc2oyfiAkvIiqVCnK5XFgZ8UJi6ueQX5koFAoUFhYCgBDzNbWYtGSLUqk0yeS2OR0iLufOnYNUKsXIkSNNfarb0Gq1eP3111FXV4dhw4bhxo0bt61s/P394evraxKxKSwsxIMPPgi5XI5hw4bh/PnzKCkpgZWVFUaNGiW40ExVW5OWloY9e/ZAoVAgODgYdXV1qK2tFeI0vr6+6N+/v0mEjuM4lJaWoqSkRDhvfn4+KioqYGNjI2Sc+fj4mOTaFQoFioqKUFZWBo1Gg+LiYmGi4+LigrFjx2Ls2LGiZHg1h09+SE5ORm5urhDDyM7ORn5+Pry9vTFz5kyMGDHCJCLPr074wDxwa+YcExODGzduoHfv3pg+fTq8vb1FPzdwe/wEuDUz522ys7O7zU0mJq0F4tVqNVQqlSBspqAtNxcRoa6uDl5eXh0ywDeHj/3Y2NiYXMw6RFyOHj2Kvn37IiAgwNSnuo2YmBhs374db775Jvr16yesbPh4TXp6Ourr6yGVSpskCIghNmVlZViyZAkkEgm2bNkCd3d3EBHS09MRHR2NU6dOIS4uDiqVCl5eXkIGWlRUVJvBXF3QarU4duwYzp49i0GDBuGee+4RlsJlZWXIzMxEVlYWSkpKIJVKhTjNgAEDbovTGEJ1dTUKCgqgVqvh7u4OLy8vYRAtKSlBcnIykpOTUVtbC0dHRwQFBSEoKAienp5Gn1smk6GwsBAVFRWwsLCAt7c3PDw8hPPn5OQgNjYWly5dglqtRnBwsLCaMnawa2hoQFpaGlJSUlBfX48ePXogMDAQ/v7+ggswMzMThw4dwtWrV+Hm5oYZM2ZgzJgxRrsIW0sdtrS0FLKEgFsu3MOHD6OsrAxhYWGYOHGi0QMdL2a8oPBFn/wg3jh+0thN5uLiIoprVJ+sLn7gF8sNp2/MpKKiAmq1Gp6enh1WDNyYhoaGDlkxmlxcFAoFjh07hhEjRpikE2pbyGQyrFy5EsHBwXj00Udb/ExzscnIyBAqVxvHbAYMGKDXTKeqqgpLly6FTCbDDz/80OoMUaFQCLU10dHRQm3N0KFDhSy0YcOG6fUgVFdX45dffkFhYSGmTZuG0aNHt/oQtxSncXd3FxIC9E2pVSgUyM/PR11dHRwdHdGrV69W7xsRoaCgAElJSUhJSYFcLoebmxsGDx7cbrZUa9dSUFCA6upqWFlZwdvbu81kAYVCgQsXLiA2Nhb5+flwc3NDZGQkxowZo5fAEhHy8/ORkpKC7OxsmJmZwc/PD0FBQW0msOTn5+PQoUO4dOkSHBwcMHXqVIPcdfxqQK1WA/j/WpTmqcON4TtKR0dHg4gwfvx4jBgxQq/ZbOPYib7xE61Wi6qqKmg0Gjg4OBgkbny9SVs1J63BC4G1tbXe4taamPAi0tjt1tr3S0pK4OjoCAcHB73OLQYdFdQ3ubiUlJTgwoULmDx5sijZOPqwe/duxMTEYN26dTq7PogIJSUlTbLR9BWburo6PPbYYygvL8eWLVvQt29fnW0uKirCqVOnEBMTg1OnTjWprRk3bhwmTJjQZm1Namoq9u7dC2trayxYsKDdVNjGKJVKIU6TnZ0NpVIJBwcHoZ6mV69erbpwtFotioqKUF5eDktLS/Tq1UuvAZrjOGRnZyMpKQnp6elQqVTw9vYWVjRtpXjX1NSgsLAQtbW1sLGxQc+ePeHm5qbzrJAabR9w6dIlaLVahISEICoqCoMGDWr1OHK5HKmpqUhJSUFdXR1cXV0RFBQEf39/vWbEpaWlOHLkCM6ePQsrKytMnDgRkydPbvOajUkdboxMJkN0dDSuXLkCNzc3TJs2Db6+vq1+3pD6k9bgXUQNDQ2wtraGk5NTm7YbWnPSGroKDB+nUKlULYoJL6T6nL+mpgYNDQ06pSaLDZ+ZZ+qgvsnFJSMjA5mZmZgxY4YpT3MbJSUleOeddzBnzhzMmjXL4OM0F5uMjAzU1tZCKpWib9++TdxoVlZWaGhowNNPP42cnBz873//g5+fn8Hn1mq1uH79epPaGo1Gg759+wqrmrFjx8Le3r5NN5ghcByH/Px8YVVTV1cHS0tL9O/fX8g+47NuKioqUFRUBI7jhNWCMct9jUaDGzduICkpCZmZmdBqtejbt6+Q2sxfV1VVFQoKCoRqeh8fH6PdiXK5HOfOnUNsbCyKiorg7u6OyMhIjB49WqibKCwsRHJyMrKzsyGRSODr6yuKS6+qqgrHjh3DqVOnANxe9a/VaqFSqQRB4VOHxQgGl5SU4MiRI8jJycHAgQMxdepUofGkRqMR0oV5d1vjdGFjB8fW3GRi15y0dm61Wg0bGxtBGBuLCT8QA8aJSXPaSk02NXzcydQxH5OLC+/XHj16tClPcxtfffUV8vPzsWbNGlHTXXmxaexG48XGx8cHJ06cQHl5OX744QeEhoaKdl7g1oro7Nmzgtjk5OTA3NwcQ4cOha2tLVxcXPDwww/fVhQpBnycJjMzE6WlpZBKpejRowdsbW3h7u6O3r17myS1WKFQID09XRjMAcDDwwMuLi7w8PAQUppbKsA0BiJCVlYWYmNjcfnyZajVanh5ecHJyQk2NjZNViliuxcaV/0rFAqMHDkSEyZMgJubm+i1KM1JTk7GsWPHUFtbi9DQUAwbNgxmZmatxk/EgneTqVQqODg4NJkYmTpNuL6+Xkjy4QseAXHFpCX41GQPDw+TN+1tjFarhUKhMHlQ3+TicuLECXh5eWHw4MGmPE0TkpOT8emnn+LJJ5/E8OHDTXouXmxSUlKwdu1apKamIjIyEh4eHujTp49Q1DlgwADRU19zcnLw888/Y8+ePUJGUo8ePYTamvHjx5skzlVRUYHz588jOTkZVVVVQmyFj9OI1eerMbzbLC4uTkjCcHV1xZAhQzB48GD079/fJINtUVERLl++jL/++gs3btwAAPj7+2PmzJkYPXq0SWZ/HMdBrVajrq4Op06dwsmTJyGTyTBy5EjMmjVLL1enrjSOn9TX1+PixYu4dOkS7OzsMG3aNISFhZlkIGq8MuE4DnV1dZDJZLCxsYGzs7NJftOWViZyuRxmZmZwcnKCra2tScSkJUpLSyGRSEzyzrQG37XA1EF9k4qLWq3G4cOHERYWZpIXoiU4jsOaNWtga2uL//znPx3ygGi1WixbtgynTp3C559/jgEDBjSJ2fArGzHFRqvV4ujRo4iLi0NgYCDmzJmDpKQkYVVz9epVEBECAgKELLSIiAijztk4tdjMzAw9e/aEnZ2dEKe5efOmMPPkhaZXr15GDUqtVdOrVCqkpKQgKSkJZWVlsLGxQUBAAAYPHozevXsb9bsrlUoh46u6uhpOTk7CKiU/Px+xsbGIj48HAISHhyMqKgq+vr5GnZPPtuJ9+hKJRMj0IiKcOXMGR44cabPqX19aip+Ym5sL7VYaGhpw/PhxJCcnw8fHBzNmzEDPnj2NOmdrrq7GNScKhQI1NTWQSCSiZJPp6uZSKBRCgWFHxUGUSiXKy8vh6uraIYWNPHxLHFPV+gEmFpeKigqcPXsWEyZM6LCsiOjoaPz8889488039QqkGwrHcVi5ciUOHz6MTz75BOPHj2/y70SEsrKyJkWdNTU1gtjwCQK+vr46D/xVVVX45ZdfUFxcjOnTpyMiIuK2ga2yshKxsbE4deoUoqOjm9TW8GIzcOBAnQfExqnFHh4ewt7gjdFqtUKcJisrC3V1dbCysmpST6Prw8zXpehSTV9WVoakpCQkJyejpqYG9vb2QiKAPnUcxcXFSE5ORlZWFogI/fv3R1BQUIsDan19PeLi4hAbG4uysjJ4e3sjMjISo0aN0jlxpaVaFN7l1Th1mKelqv+ZM2ciMDBQ59+RH2iVSqWQXdZe/CQnJwdHjhxBSUkJQkJCMGnSJL32azEkEM+7ydRqNRwdHfVaIRoTM5HJZEKwu6MEpjNSk/nsPlMWEptUXLKyspCSkoK77rqrQ26aTCbDihUrEBISgiVLlpj8fESEdevWYe/evVi/fj2mT5+u03faExt/f3/4+fm1+MOnpKRg3759sLGxwYIFC+Dj46PTOTMyMoSOAefOnYNSqYSnp2eT2pqWdg6Uy+XIz89HfX09nJyc4OPjo3OMobS0VIjTlJWVCZso8aualgYolUqFoqIilJaWArgVX/H29tZZlAoKCpCcnIyUlBShBQ8vNC21WFGpVEJMh3fxBQYGNkkcaAsiQlpaGmJjY5GQkAAzMzMMGzYMUVFR6N+//23PPV+Lom/qcPNjJCQk4M8//0ROTg769u2Lu+66C6GhoS1+nx9k26s/ae+cV65cwcmTJ6HVajFu3DiMHDmyxQFYrKwuXbPJxAzAExHkcjk4joOtrW2HVc2XlpbCwcGhwybh/PNnygxek4pLfHw86uvrERUVZapTNOGXX35BbGws1q1bJ3qAtzlEhI8//hhbt27FmjVrcPfddxt8nLKysiZFnbxLgHej+fv7o1+/fjh16hTOnTuHoKAgzJs3z+BZB19bw69q0tLSIJFIEBwcLHQMCAkJQVlZGcrLy2FtbQ0fHx+jiitra2uF/Wny8/PBcRw8PDwEoXFwcBCq6aVSKby8vODl5WWwT7hxt+G0tDRBTHmhkcvlSElJQWZmJjiOExpt9uzZ0+CJUG1tLeLi4nD69GmUl5fDx8cHUVFRGDlyJCwsLITiRmNShxtDREhJScGhQ4eQlpYmVP0PHz68yQqlef2JriLWEnK5HDExMbh06RJcXFwwbdo0+Pv7G1Vz0h7N3WQSicSk2Vx8TIKIOkxgOjo1mQ/q29rammzib1JxiYmJgYuLC4YOHWqqUwgUFxdj1apVmDt3Lu666y6Tn+/rr7/Gd999h+XLl2PhwoWiHbclsSktLcWNGzdgaWmJyZMnY9asWfDz8xPNR1tSUiLEak6dOoWKigpYWVkhJCQEkydPxpw5c9CvXz9RzgXcGiz4OE16erqw4Vbfvn0RHh4u9L0SC41Gg6ysLCQmJuL8+fMoKiqClZWV0GcsJCRE1BkcP+hHR0cjMTERUqkUoaGhiIyMFDo/iD1gpaen4/fff0diYiKcnJwwceJEjB49Gvb29oKgiAmfunzz5k34+vpi6tSp6NGjh0myujQaDWQyGUpLS4W0cz7obqpsro4WmI5OTeavz9ra2mRiZjJx4TgOf/75J4KDgzsk9vHFF18IXY9Nnda3ZcsWfPrpp3jppZdarfwXi6SkJGzfvh319fXo378/SktLm6xsGsdsjBWburo65Obm4vr160hNTUViYiKuXLkCjUaDPn36NKmtMXb5zlfTV1RUoLq6GnK5HOXl5UIWS+N6GjHa8CQnJ+PGjRtQKBQwNzeHVqsV3JF8bGXgwIFGn6t5G/u6ujpcvnwZ586dQ3V1NXr37o2oqCiMGDHCaH93S/GTsrIyxMTEIDExEY6OjgZX/TentUB8eno6jh8/jrq6OowcORLjxo0zOjW7JTcXn+DA1/k4OjrC2dnZpIM+PwADMOkMn4dPTXZ3dzdpoJ3H1EF9k4lLTU0NTp06hcjISJMrcVJSEj777DM89dRTGDZsmEnPtXPnTrz//vt48skn8dxzz5nsPBqNBkeOHMH58+cxePBg3H333bC2tgYRoby8vEk2WnV1dROx4WM2uoqNSqUS2qbY2dmhV69ewky+rq4OcXFxwsomOztb2LeG7xgwZMgQnWc/7VXTl5SUCHGa8vJymJmZNUlz1jWQrFarcePGDSQnJ6O8vBz29vYYNGgQBg0aJASHZTIZUlNTkZSUhPz8fJibm8Pf3x9BQUHw9fXV+Zr41GGVStWkjX3jrsMcxyE5ORmxsbG4du0aLC0tMWLECERFRem1m2lb8ZPGK6LS0lIcPnwYcXFxOlf9N6dxijBPS64ujUaDc+fO4fTp07C0tBRWg4YkGTS/h417czXuTSZmNllbcBwHmUwGiUTSIQLTkanJCoUCAEwW1DeZuOTm5uLq1auYOXOmSX2IHMdh9erVsLe3x2uvvWbSH//AgQN4++23sXjxYrz66qsmO1dlZSV++eUXlJSUCJ1zWzsXLzaN3Wi82PTu3VuI2bQkNvxSvKSkBObm5jpVuOfm5gpCc/r0adTX18PFxQVRUVEYP348xo0b12KGliHV9DU1NU3iNEQET09PQWh69Ohx23cqKiqE3TH5FVdgYCD69OnT5u9VW1srNNPkM+sGDRqEoKAg9O3b97bv8oKiVqtvSx1uL05UVVWFM2fO4MyZM6iurkbfvn0RFRWF4cOH3zbrb1x/wg+8fF8ovm1JW9fVXtV/83MZE4ivra3FiRMncP36dXh7e2PGjBktliDwQqyrmLSEMdlk+tKRAtORqcl8DNBUQX2Ticu1a9dQXl6OiRMnmuLwAidPnsTOnTuxYsUKg/az15UjR47gjTfewL333ouVK1ea7AFLSkrC/v37YWdnhwceeEDvluiNxSYjIwNpaWmC2PTq1Uuos3Fzc0NlZSU0Gg08PT3h6empt4tBo9HgypUrgtgkJiaCiDBw4EAhC83Pzw+VlZUt7k2vD43jNDdv3oRarYaTkxMGDBiAvn37CpuUlZaWws7ODgEBAQgMDNRrps5TUVEhpDZXVVXBzs4OgYGBCAwMhIeHh86pw+3BcRyuX7+OU6dOITk5GVZWVoiIiMDYsWPRo0cPoTUJEcHc3LxJQF5fGlf9q1QqjB49GtOmTRM6dTcPxPMtVgwhLy8PR44cQVFREYKDgwVXmTFi0hq1tbVCl19Tusl4gZFKpbCxsTGpwHRUajK/YjSVYJpMXE6fPg1bW1uEh4eb4vAAbvkoV65cidDQUDzyyCMmO09MTAxefvllzJgxA+vWrTPJA6zRaHD48GFcuHABQ4YMwd133y1KWxG+9xfvRrt+/ToKCwuhVqvRt29fDBs2DIMHDxYlQaCqqgqxsbGIiYnB8ePHUVxcDHNzc4SFhWHq1KmYPn06AgICjH6QtVot8vLyEB8fj3PnziE3NxcSiQSDBg1CVFQURo8eLdpSv7CwENeuXcP169dRW1srFFQOHToU3t7eor2UfFLF6dOnUVNTgz59+iAyMhIRERFwcHAQbfUvl8sRHR2NY8eOoa6uDsOHD8fMmTPRq1cv0QLxfOv9S5cuITo6GiqVChEREYiIiICdnZ1RYtISSqVSmEA5OzubLIag1WqFjsKmTOHtqNRkvjOBqYL6JhEXIsKhQ4cQEBDQZodVY9m5cyfOnj2LdevWibIHSUucO3cOL7zwAqKiorBhwwaT/AiVlZXYtWsXysrKhFRSsWcSGo0GhYWFKC8vh0KhgEwmQ0FBAdLT01FVVSWsbPgEAT8/P71foMbV9CqVCnV1dUhPT8fZs2dvq63hW9S0VFvT3nVkZWUJ7itra2uhNxPfldnMzEyopxkwYIBBq5fG+6LwTSL5rRnS0tKgUCjg7u4ubA9gyGqspfiJubk50tPTcf78eaSmpsLGxgajRo1CVFSUQRt7tebq0mg0OHv2LI4ePYqKigqEhIRg5syZBlX9t+XmIiKcP38eCQkJcHZ2xtSpU02yr5NWq0V1dTVUKpVJ3WT8rprm5uYmdVt1VGqyTCYTVt9iYxJxqa+vx8mTJzF69OgW/eJiUFRUhNWrV2PevHkm67gcHx+Pp59+GsOHD8enn35qkh/g+vXrOHDggMFusPbgU5uLi4sBAN7e3kLKKP/vlZWVTYo6Kysr9RIbXarplUplk9qa1NRUobaGd6ENGzas1XtcVVWFlJQUpKenQ6lUwsfHB0FBQejXr1+TlWRNTY2QEFBQUAAigpeXFwYMGAA/P78296rXtY29VqsVBC4jIwNqtRo+Pj4YPHhwk4SBln4LfrtbXeInZWVlOH36NM6ePYv6+nr4+fkhKioKYWFhbT6L+tScaLVaXLhwAYcOHUJxcTECAgJw1113tbnVgCExk/Lychw9ehSZmZkYMGAApk+fbpKxoa6uDvX19SZ1k2k0GsjlcpMKTEelJisUCiEpRGxMIi4FBQW4cuUKZsyYYbJMjs8//xzFxcVYvXq1Sc6RlJSEJ554AoGBgfj6669Fv/mmcoM1pq6uDvn5+VAoFOjRowe8vb11KkqsqKhokiDAi42Pj48Qs/H19RVWC4ZU05eUlDTZt6ayshJ2dnZN9q3p1asXsrOzkZycjKKiIlhbWwsZX7qsFBQKBW7evCnsT8PHafiEgJ49ezZpwcIP9vp0HVar1cjIyEBSUpLQNoYvyAwICICFhUWTgLwh8RONRoPExETExsYiLS0NdnZ2GD16NCIjI+Hp6SlKRTwRIT4+HocOHUJOTg769euHmTNnIjQ09LbNsYyJmaSnp+Po0aOorq7GiBEjREmTbk5HuMl4gbGwsDBZtlVHpCbzvexMIZImEZeUlBQUFBRgypQpYh8awK3Z/ueff46nn37aJDGdGzduYOnSpejbty++/fZb0ZfYFRUV2LVrF8rLy03iBlMqlSgoKBD6bPXq1cuoh6e52JSVlUEmk8HBwQF9+vRBeHg4IiIiDO6K0DiwHR0djQsXLkChUAhCMGrUKNxzzz16pTw3R6PRIC8vD1lZWcI2CRYWFujbt69QU2NnZ2eUC4JPKrh69Spu3rwJIhK6LAQEBMDOzs7o/U9KSkqE1UxDQwP8/PwQGRmJ0NBQYYA3toHm1atX8ccffyAtLQ09evTAhAkTEB4eDmtr6ya7LRp6Hq1WK6xiLSwsMHHiRISFhYn6DjR2kzk4OBjkGm2PjhAYU6cm80F9U7gRTSIu586dg5mZGUaMGCH2oaHVarF69Wo4OjqaJB04JycHjz76KHr06IFNmzaJHsu5du0aDhw4AAcHBzzwwAOitsTnOA7FxcUoLS2FhYUFevbsKeqSmt+bPisrC0VFRaipqUFJSYkQs/Hx8WniRtPngeU4Djdv3hQaR+bn56OsrAxpaWnIy8sTenbxq5rg4GC9BunGqcMajQZlZWXIy8tDTk4OqqurYWZmhj59+ghxGn1ftubxk4aGBty8eRNZWVkoKyuDlZUVAgICWnTl6QJfb8K/rmq1GomJiThz5gwyMjLg4OCA0aNHIyoqSu+BqDU3V0FBAaKjo5GSkgJ3d3fMnDkTY8aMEc1TUFdXh7/++gtXr16Fl5cXZsyYgd69e4ty7MbnMKWbTK1WQ6FQCJ0CxIZPTXZxcTFJEgEf1DfF3i4mEZcjR46gX79+Jgnc/fXXX9i1axdWrlwp+oNYWFiIJUuWwM7ODv/73/9EHZj57QcuXryI4OBgzJ07V9SHsbKyEoWFhdBqtfDw8DAotbg16uvrUVhYiKqqqhb3pm+8ssnIyEBFRUUTseH/tDRg19bWIiUlBWlpaZDL5fDy8kJQUBAGDBggiEfj2pozZ86grq4Ozs7OQm3N+PHjW4xVtdV1uPEAWV1dLXRybhyn4d1nLcVp2oqfNG9HUllZKdTQVFRUwNbWFoMGDcLgwYPh4+PT4gRJH1dXcXExYmNjERcXB7lcLmTNhYSEtCjAfDYXv20vLyaN26k0jv/k5+fj0KFDuHTpEhwcHESr+ucpKCjA4cOHUVhYiCFDhmDy5MmiTupM7SbjhdlUAlNZWQmVSmWy1OSGhgZYWlqKHl4QXVwUCgWOHTuGESNGiL5RVUNDA1asWIFhw4Zh8eLFoh67rKwMjz76KIgIP/zwg6jL0MZusFmzZiE8PFy0h0QmkyE/Px8NDQ1wdnaGj4+PaC+PoXvTV1ZWNnGjVVRUAIAQs+H7a+Xk5CA/Px+WlpYYOHAggoKC2hV0jUaD+Ph4xMTECL27+NoafoM0fvdEXlAaFze2Z7tCoRAKN3NycqBWq+Hs7CxsGeDm5iYMyobET0pKSpCcnIykpCTU1dXB0dFRaKZpbM2JWq3G5cuXERsbi6ysLDg6OmLMmDEYOXIkHBwcdBaT1mhe9T9p0iRMnjxZFJcKESExMRF//fUXVCoVxo4di9GjR4u2mZWp3WS8wPATCzExdWoyn14ttjCKLi4lJSW4cOECpkyZInqQ6Oeff0ZcXJzoqcdVVVVYunQpGhoa8MMPPxi9IVJjTOUG41OLKyoqYGNjg169eon2woi9Nz0vNomJibhw4QJu3rwJjUaDXr16YcSIEYiMjMSgQYMMsr+6uhqxsbGIjo5GdHQ0iouLYWFhIQSLJ02apNd+J43RaDS4efMm0tLShN0v+YaXAQEB8Pf3N3j2TkTIy8tDUlISUlJSIJfL4erqisGDB2Pw4MFwdXU1eAKiVquRnZ2NU6dOCfErf39/REVFITQ0FDY2NkZ1Rm5c9S+RSDBu3DhMnTq1xap/fVEqlYiNjcX58+eF3miDBg0y+rg8pnST8atBPvNPTEyZmsz3bxN7vBZdXNLT05GVlSV6ejDflPKee+7Rad8UXamrq8Njjz2G8vJybNmyRbQmm2q1WnAlDB06FHPmzBGtKLKsrAxFRUWQSCQ6ryZ0OW5FRQUKCwuNrqZvDMdxyM3NRXJyMvLy8mBpaQlPT0+Ym5ujtLS0SVfknj17Ctlofn5+7YpN89RhqVSK3NxcnDlzRtiegK9HGT9+PCZMmICoqKg205GBlutPLCwsUFVVhfz8fGRnZ6OiogLm5uZN4jTt+cRbc3UREbKzs4VUa5VKBW9vbwwePFinLgNtubmICMnJyTh79ixycnLg5OSEsWPHYuzYsXrXGDWHj5n89ddfUKvVGD16NKZPnw4PDw+jjgvcWu0fPXoUN27cQL9+/UQ7LmBaN5mpBIaIUFxcbJLUZD7mJnZQX3RxuXjxIjQaDUaPHi3aMYkIn332GcrKyrB69WrRlsoymQxPPfUUcnJysHnzZvj7+4ty3PLycuzatQsVFRWiusFqa2uRn58PpVIp1JIYO4vhOE4QK6VSCWdnZ/Ts2VOUrsepqalITU1FQ0MD3N3dERQUBD8/v9t+P35lw/8pKysD8P9iw8ds7O3todVqhc64vKBYWFi02MZeqVTiwoULQhZaSkoKADSprRk+fLjQbZcXlLbiJzx8nCYzMxOFhYUgInh7ewtxGn7g1nefE7VajczMTCQlJSEzMxNarRZ9+/bF4MGDERAQAGtra71jJjz8Fs0XLlyAUqnE4MGDERUVhSFDhhg1g1coFIiOjha6I48YMQIzZ87UaSO79rhx4waOHj2KyspKDBs2DBMmTBBlhm1KNxnftsfGxkbUPepNlZrM7+0idlBfdHE5ceIEvL29ERQUJNoxr127hi+++ALPPvssQkNDRTmmUqnEc889h+TkZHz//fcYPHiwKMe9evUqfvvtNzg6OuKBBx6Ap6en0cdUKpXIz89HbW2tKKnFQOt70xuTkcK7epKTk5Gbmyt0GQ4MDNSrYK6qqqpJgkBpaWmTzcX8/PwwaNAguLi46CWupaWlgtDExsaivLwctra2GD58OCIiIjBu3DjB1aXPrFMulwtxmuzsbGg0GqHv2YABA+Dj4yPETfSZZCgUCiG1OSsrCxzHCYWtfEabPjETHqVSiYsXLyI2Nha5ublwcXERVjPGuLbUajXOnDmDI0eOGF313xi+0PPUqVMwMzPDxIkTRZuwmcpNZiqBMUVqMr+1gJWVlai2iioufEZUeHi4KLMW4NaDtWrVKjg7O+OVV14RrffRSy+9hEuXLuHbb79FWFiYKMf8888/cfnyZYSEhGDOnDmi7A1SXFyMsrIyWFhYwMfHx2i/tj570+tKQ0MD0tLSkJKSgvr6evTo0QOBgYHw9/c32DXQOHW4oqICWVlZyM7ORlZWlpAg4O3t3cSN1t5qq3Frd6VSibS0NFy4cAHnzp0T9q3p3bu34ELTZd+a5q4ujUaD3Nxc3Lx5Ezdv3hTSPAcMGABfX1/07du33Re48cqE30lSLpcLBaHNU5v79+9v8Ao2JycHsbGxuHTpEtRqNYKDgxEVFYXAwECDB1pDqv51ge/8kZCQAE9PT0yfPl0UN7ap3GRyuVzoOixWnMRUqclyuRxmZmairohEFZfy8nLExcVhwoQJomU1HD9+HLt378Zbb73VYvtufdFqtVi2bBliYmLw5ZdfYtSoUUYfk3eDVVZWYtasWaIUhFVWVqKgoAAcx8HT0xMeHh5GzaqM3Zu+OUSE/Px8pKSkIDs7G2ZmZvDz8xOyngw9Ju//bdxrq6XU4cb72fBuNG9vb6HOxt/fHw4ODkIdQuP4CT/bt7KyEu5pQ0NDk31rsrKyYGZmhvDwcKG2ZujQoTAzM7ut5gRo2dXF+8l591llZWWLcZqWxKQtN1d1dbWQcVZeXg4bGxsEBARg8ODB6N27t0HPnkKhwIULFxAbG4v8/Hy4uroiMjISY8aMMTju1lLV/1133aXXXi8tUVhYiMOHD6OgoABBQUGYMmWK0bFBU7nJ5HK5UAEvlsCYIjWZf+7ELAYVVVyysrKQmpqKmTNninLR9fX1WLlyJYYPH46HH37Y6ONxHIeVK1fi8OHD+OSTTzB+/Hijj5mYmIiDBw/C0dERCxcuNDro2NDQgPz8fMhkMri4uKBnz55GzSYUCoWoe9PL5XKkpqYiJSUFdXV1cHV1RVBQEPz9/Q2ys6VaFH1Sh4Fbg23j1Ofi4mJotVr06NED/fv3F9xoPXr00LmyPDc3V2hPc/r0adTV1QnBcD7lma9R0fVZr6qqQmZmplAYqtVq4ebmhr59+6Jfv37w8PAQYjy6urnKysqE7QFqamrg4OAgpDYbkpnIJxfwqxmtVouQkBBERUUZvPKgv7d9/vPPP5Geng5vb2/MnDkTI0eONHjCRES4du0aTpw4AYVCgTFjxohS4Cm2m4xfdfLZWGIIjFarRUlJCezt7UXLmuXfQTFXQ6KKS3x8PBoaGhAZGSnK8Xbs2IFz587h3XffNXolRERYt24d9u7di/Xr1xudcaZWq/HHH3/gypUrCA0NxezZs40SAbVajcLCQlRWVoqSWsxX01dUVMDCwgLe3t7w8PAw6OEmIhQWFiI5ORnZ2dmQSCTw9fVFUFCQQTEl3n3EP9AAmqxQDNkXpXH/rurqauTk5CA3N1fI7AL+f2XD/2ntxWzJ1ZWQkIDY2FicOnUKiYmJ4DgO/v7+wqpm1KhRrcbB+MB74/5ivOjn5+cLCQGurq5CQoAh7fwLCgqEYk2ZTCYIf1BQULsZci0hl8tx7tw5xMbGoqioCO7u7oiMjMTo0aMNfh9v3LiBQ4cO4dq1a3Bzc8OMGTOMEgWVSoXTp0/j3LlzsLOzw9SpU42O9/JuMgBwcXEx2lXUWGBsbW1FievU1taivr5etNRkPqgv5t4uoopLdHQ0XF1dMXToUKOPVVBQgDVr1uD+++/H1KlTjToWEeHjjz/G1q1bhU7KxlBWVoZdu3ahqqoKs2fPNipmQ0QoLS1FcXExpFIpvL29jUotbq+aXh/4gHJKSgpqamrg4uIirFIMSavWteuwrsdqvn8830ix+f4UNTU1TVY2vGvQy8uryU6dDg4OOlXEV1dX4/Tp04ILrbCwEBYWFoiIiMD48eMxZswYDBgwoEmxZWN3XPOViUajQU5OjtAlQC6Xw9bWVuh5pkucpjEcxyEnJwfJyclIS0uDUqkUOh8EBgbqPdslImRlZSE2NhaXL18GESEsLAxRUVHw9/c36FnNy8vD4cOHRav6r6ysxLFjx5Ceno4+ffpgxowZRiXTcByHqqoq0dxkfNCciEQRGN7lamVlZXRKeWP7xAzqiyYuWq0Whw4dQnBwsNFBNiLCp59+ioqKCqxatcroi/3666/x3Xff4Y033sCiRYuMOlZCQgIOHjwIZ2dnPPDAA0a5wWpqalBQUACVSiV0LTZ0FmJoNX1LFBYWIiUlBVlZWZBIJBgwYAACAwMN2g6gpdRhfnDV9wXjYxNKpRIajabV+El71NTUID09HWlpacjIyEBJSQmAW2Lj7++PgIAADBw4UKdBmOM4pKSkIDo6GjExMbh48SIUCgXc3NwQGRkprGx0XYkQEYqKioQ4TVVVFczNzdG3b18hTqNPpqBGo0FmZiaSk5Nx48YNIWmB3x5A36zDhoYGYTVTUlICT09PREZGYtSoUQYNwGJX/WdlZQnZauHh4ZgwYYJRrh4x3WRiC4xMJkNVVZVoqcn8PjViBfVFExe+UjoqKsrojKbExER89dVXeO655xASEmLUsbZs2YJPP/0UL774IpYuXWrwcVQqFf744w/Ex8cjLCwMs2bNMvhHUCgUKCgoQG1tLRwcHNCrVy+DZ2zNq+l79uxp0EyGz55KSUlBdXW1sOPiwIED9bZNq9Ua1caeh+/fpU/9SVu0VnNSW1uLGzdu4MaNG0hPT79NbPjVjaOjY5Okg8ZuLl7oJBIJEhMTcfbsWcTExCA5ORkAMGTIEKG2ZsSIETq7gfg4DV9PA9yq/+HdZ/oU1CmVSqSnpyM5ORk3b96ERCJB//79hd9Zn+eZiHDjxg3ExsYiPj4eABAWFoZx48bB19dX70kNX/UfExMDqVRqVNU/x3G4ePEiYmJiIJFIMGHCBAwbNszgwVxMNxkvMABEcUGJmZqsUCgAQLSgvmjikpOTg2vXrmHmzJlG+QA1Gg1WrVoFNzc3vPTSS0bd/J07d+L999/Hk08+ieeee87g45SVlWHnzp2orq7GnDlzDK61aZxabGlpCR8fH4OyXMSspi8uLhY6ERORMNjo2wKHTx1uvt8Hv7+8Psdpvv+JmZkZrK2t9d4/3tB9Tng3Gu9KKywsBMdxcHV1FVr0DxgwAD169Gg3AF9WVibU1pw6dUpoXDlmzBhBbPr376/Tcy6TyYR6mtzcXGg0miZxGi8vL53fF5lMhtTUVCQlJSE/P1+oSRo8eHCTpqG6UF9fj7i4OMTGxqKsrAxeXl6IiorCqFGj9F41NK/6HzNmDKZPn27Q4CmTyXDy5ElcuXIF7u7umD59Ovr376/3cQBx3WQcx0Emk0EikRgtMCqVCmVlZaKkJvM7r4oV1BdNXK5evYrKykpMmDDBqOMcO3YMe/bswdtvv21UrcyBAwfw9ttvY/HixUa15o+Pj8fvv/8OZ2dnLFy40KCHnP7e7ZEfpLy8vAyKg4hVTa9UKpGRkYHk5GRUVVXB0dERgYGBCAgI0MtNwq8s1Gp1k9RhPtNLV7RaLZRKpVB4Bvx//EQfH3BLYgJArwLGllYmtbW1yM7OFpIEGmfeNe4g0J64cxyH5ORkIVZz4cIFwU3Fu8/Gjh2rkztOrVYjNzf3tjgNX0/Tp08fne9bTU0NUlJSkJSUhNLSUlhbWws1NH379tX53SEipKWlITY2FgkJCcI2CVFRUToLKA9f9X/s2DHU19cbVfVfVFSEI0eOIC8vD4MGDTKqD1p9fT3q6upgaWkJFxcXg1dDYgqMWKnJfBxTrKC+aOJy+vRp2NnZGRXcrqurw8qVKzFy5Eg89NBDBh/n6NGjeP3113Hvvfdi5cqVBt0olUqF33//HQkJCUa5wRqnFru6uqJnz54GZcYUFRUZXU1fV1eHy5cvIzMzExzHCTsm9uzZU697xA++zdvY65o6DNwaiBoaGoyOn+hac9IeDQ0NQvv8lgLwjX/72traJh0E+C2kPTw8MHDgQEyePFmnYDIfv+DjNXxtTVhYGCZOnIh///vfOgtiYWGh4D6rrq4W4jShoaHo06ePTvcAuNXTi09trqqqgp2dHQIDAzF27Fi9nrfa2lrExcXh9OnTKC8vh4+PDyZOnIixY8fqfAzg1rN2+vRpHDlyBJWVlQgJCcG8efMMEpnr16/j+PHjkMlkwt43hsRzVSoVqqqqABjnJuMFRiqVwsbGxqjN18RITeb3dmmeEGMoBokL7zMEbqmdubk5UlNT4eLicttL1dYDyTcs5OEDrSEhIU1+MK1W2+bLWlBQ0OT/l5SUCCuExj+YUqlstRUF/7AAtx4eiUSC+Ph49OnT57Z6gbb83Eqlssn/r6urQ2VlJTw8PJqsCtoqWGp+DOCW29HCwgJubm5CplZ7RU+1tbXQarXCzF2pVAobM3l6eja5x209lBzHCecD/n/53FLqcGuioNVqb/u7yspKoS8YH6/g29i3RvPHlReXlsSkrZdVo9EIIgLcevY4jhNsaTwBaM0e/vmVyWRoaGhATU0NqqurERgYeFtAuq32N7m5uQD+fwXHx5eapw9rNJpWn9+ampomxygvL0dFRQW8vLxuS8Roa4XFxxaAW89uSUkJKioqMHz48CYDDu8mbI3G73ZVVRWKiopgYWFxW/++tt5t/hgqlQrAreclPz+/xWSLtu5v43eb36W1urq6xWLn1t5tfiLFw3EcamtrYWlpedsY19bzy79LPG319WprgtXcnrq6Omi12ttWZETU6mS2uS3ArRWjubn5bddgyArNIHHhB4qMjAxIJBJ4e3u3mt3RlgLyLpDGNH7hedavX4+33nqr1ePwD19bx9m9ezfy8/Px+uuvt3gMpVIp7AFy5MgRSCQSzJgxo8Wbqs/D0xrp6emtthLX9RjJyckYMmRIq/9eWVmJq1evQiqVYsSIEW3OsNr7nfjfXCKRgOM4WFlZtTh4tzag6/qYVVZWtlmToetxOI5r85oaGhqEazIzM4NUKm3xpQJavya1Wi0057S2tm6zE3hbq9WWJhPN0Wg0ePTRR/HLL7+0+u8ajQZnzpzBuHHj2hTWtp7f5oNWa2zfvh2PPPJIq//e0rvdnOjoaOTl5bWaaHPx4kXk5eUJkw6O4xAcHNyiwLZ1f+Pi4oRnmK85CQsLazHTs7V7o+tzV15e3qbrXJfj8Mk5bf2GuhyHj822Zo+u18SLn96QAWRlZVFycjLV1NQQx3F06tQpQw6jExzH0W+//Wb0cSIjI0mr1bb677/99hvl5eXRtm3bSKvVUlVVFe3fv7/N7xhDfHy8Ud/nOI5KSkra/MyFCxdIq9WSRqOh6OhounnzJnEcp/e5NBoNcRzX5E99fb1Bx2qP9q5JVzQaTZv/rlKphGtRq9WkUqmovr6e6uvrdT7HL7/8QgkJCaTVaik+Pl64vw0NDcaafxvPPfcclZaWtvrvGo2GDhw4QBzH0a5du0Q/f2MuX75MZWVlRh1Do9FQVVUVqdXqVj+TmZlJcrlc+J00Gg1t3bq1ze+0RF1dHcnlcuE312g0dOnSJTp37pxR19ASbf1GuqBQKEihUIhiS0VFRbvvgS4Y+jwbJC5yubzJoKvRaOjGjRsGGdAev/76qyiDWEFBQZv/rtVqKSEhgZRKpfB3MpmMfvzxR73P1doAxXEcFRcXE9GtF8cYUlNT2/1M4/vGcRzl5eVRdHS0KILJcZxoL0HjY+o7cLSGodcok8lIpVLp9NnGzwoR0a5du2jfvn20f/9+UV5qnpycHJLL5W1+5sCBA8K9+/3330mtVptE/DmOo7i4OKOPs3HjRoPPv2HDBlGu7ezZs6JOHnkRNIba2lpR3gNeSMXA0GfZIHFpidTU1HZfAH3hOI6++eYbo4+TlJRk8Hdzc3NvG0TaIzExscUfNicnh6qqqoz+4XmhMAS5XE4nTpzQ+5paQqlUijqIVldXG32MxqsrQzF09cRxHCmVSuI4jj788EODz9+cQYMGtfuZxr8nx3F09uxZOnbsGHEcJ+oAevr0aVEGrWeeecbg71ZUVND+/fuNtoGIaOvWraIch4ioqqrK6GPU1tYSkeGrBZ72JtPtwf/GxvzWou0MM3DgQCQlJaG+vl6sQ+K3337DU089ZfRx2vINt0fv3r3x7bff6vUdf39/IYOoMZWVlXB2dkZ5eblRqX7Z2dkGp2lbW1sjKioKJ0+e1Nnn2hqWlpZCdpUxEBHq6+tF6eHE/68x97dHjx46x70a07iQ0tfX1+DzN2fgwIHtfqbxvZNIJBg1ahRGjx6NM2fO4OjRo6LZcvbsWVHSVKOiogz+rqurK2xtbQ36jZoTGBioU3xIF+RyucHf5eN/fLKOsfs1GdvAk3+vW4pn64xR8tYMjuMoJSWF6urqjD6WWq0WzXf8r3/9y6jvX7lyReeZfk1NDRG1HFPh3WXGrlqys7MN/j6PRqMRxb0hRoyhvr5eFHcYv4oSY2ZtbOyH4zjKyMgw2g6VSmXUKlOr1ZJCoRBtVci7dY1Bq9Ua/RtxHEdffPGF0bYQEf33v/81+hhqtdqgZ5hfZSsUClHcao2PqSstrWzVajXJ5XKj3m3x9rTErRlTQEAAEhISjD7Wxo0bMX/+fKOOQUS4evUqNm3aZNRxwsLCsHPnTp1mSllZWQCazhzq6upQUVEhZNQZM/PjG/MZi5mZmdAt2BgkEonR/Za0Wq1R/eOo2cpJjJm1sX2fJBIJPv/8c6PtuP/++41a0fHtcrZt22aUHUSEX3/91eidVYkImzdvNvo34osPxWDevHloaGgw+PsqlQoNDQ06PcONs/E0Gg1kMhmUSiUsLS2hUChEeXb18YxwHHfbuMZnWvJF0YYiqrgAt370MWPGICcnx+BjXLx4EY888ojBN5qIUFdXh82bN+Ovv/4yeokIAA888AB++umndj/H1xQEBAQA+P+HqfkAqCv0dwomvy2xvgWPbTFz5kxRBMbKysrg5TPfX00fGt9LalSRL+b+325ubka7+5599tkW63t0Zf/+/Ub1w2tM8/oSfVAqlfjrr78wfPhwo2zgOA6//vqr0dse8zz66KM4e/as0cdxd3fHd999Z9B36W+Xrq7Fi43dyPwupcCtcdOQTuPNbdFoNDpPRujvbhTm5uZNatl4kWte76UvoosLcGu2lJ+fb9B3NRoNUlJS9JohXbt2TfjvAwcO4Ntvv8XmzZsxZ84cvPjiiwbZ0Ry+Y2t7qxc+d97c3Fxoh+Hg4KDXHvKNB7WCggIUFRWhuLgY1tbWou3wCdz6nX777Tejj8MXaLZH88Ga4zi9929pLCb8Mfg6CLFEF7h1TcYK76BBg/DFF1+0+7nmcUqFQoHk5GQ0NDTg7rvvNsoGnqlTpwrFmm3BF2MCt+51UlISTp48ibFjx6Jfv346n6+x94Lf9njLli2YM2cOJk+erI/prSKRSHDy5ElRjjVp0iSDJhP8VhS6Pns2NjbCu8Kv+nlR0Wdy1Hwc0mg0qKurg0wm01no+BUT8P9NK9VqtWCPPh0uWsRgh1o7aLXadjMWbt68Senp6UIsQqvV0kcffaS333H58uWkUCiopKSE9u3bJ2oaXnN++uknnT9bXl5OycnJep8jLy+POI6juro6qq6uFs0X2xIVFRVCnMgY2kufVKvVVFtbSw0NDcL1VFZW6n0e3l/P197w/mJT3J+qqiqjj5uZmdluZt/KlSspJiaGOI6jzz//nD766CP64IMPjDpvSxw/fpxkMlmbn4mJiaFr164Rx3F08uRJKigoMOgeXLx4kf78808hdbioqKjdcxuCWq2my5cvi3KsmJiYVv+teZ0Xx3Ekk8kMuiY+vmJMFl9VVRXJZDIhQ7GmpkZ4J3Sl8WcbGhpEiYU1xqAKfV2zNKKjozFp0qRW/z0+Ph7m5ua4ceMGrK2tUVVVhRkzZrTYnqKtamuNRoN///vfcHR0xLp169q0qTUfYkvuC2phNvzFF1/gpZdeavX4jW9nUlISAgMDW52RtDYraGhoQFlZGSQSSbvxlbZmFrr+Tnv37sX999/f6r/r+og0NDS02i22oaEBNjY2QnM8juNanWHpWpnc0u9jyHHaoqqqqtU2J7q6vN577702O0xoNBocPHgQmZmZ6Nu3L+65555WP9va89vSb93S/fnll1+wcOHCVo/P/b3RWHZ2NlxdXREcHNzqfW5rpq3ValFQUIBLly5h6NChbXYjbu3d1vX+vvPOO22+97q+B998802r3dNra2uF/+ZXyhYWFi22X9LluVMqle26wdo7Dt8qiIjabOmjS9cM/nittZMyZAVjkLi0lG6ckpIi7CfCvwBtDSAAhH0zgFtBb35jIz8/v9t65LTlJsvJyWnivywtLYVWq22xBXlrG5k1d4EolUokJibC39+/Sb8hlUrV5qZZjd1DWq0W9fX1qKqqatGl0NrDpVAohJ5tPNzfreibN3Vsq7dYYxcHf9yrV68iKCioiQhoNJo2W640f8lVKhW0Wm2L6ZKtDRSNA5l8o8na2lrY2dnd5iPWp7cYf6yWzttebzEetVqNhoYGmJmZ3eZ25AeRluB3tORRqVRISEiAj48PvL29hd9JpVKhV69erdpy8+ZNALd+LycnJzQ0NEAul8PZ2fm2e9HaIN24fxZw674kJibC3d29ybk1Gk2b7UkqKysFmy0tLVFdXY309HSEhobe9ju11VuMvzcKhQLW1ta4ceMGOI5rMa26tQ33Go8Pja9LJpM12WxLpVKhd+/e7V4TT1FREQoLCxEaGtrkuVGr1a2OM82fX4lEgpqaGoN7i/GCbWxvMd6W2tpacBzXYm80XSck/MZ+lpaWt71PhsQzDUoFaD475TgOzs7OuHHjBrKzs4W23+0Fgxr/kJ6enigvL8cff/yBAwcOIDIyEvPnz9cp37u5YKSnp+PNN99EcHAwPvnkE532OWk+uHIch6NHj+Lq1at49tlndY51NBcMjuNQUFAAtVqt8x4QLQlGQ0MD0tPTMWTIEJ0382l+3RkZGcjLy8PEiRP1ygJp/KBpNBqoVCq9O6c2Pp9Go0FVVZUQNNTHFl4wqFE3ZL4xpz6Ym5sLfmq5XA5zc3PY2dnpZUvzQbG2thZVVVU4dOgQXFxcMGvWLERERLT7YjYXjLNnz+K1115DaWkpXn/9dSxdurTde918UOFF8fjx4wgLC8P48eN1ukfNBcPKygq///47KisrsXDhQp0Hmeb35uLFizh27Bg++OADnQPXLQ30ubm5+OCDD7By5UqdsyabX9Pvv/+u9wZbzZ+Luro6qNVqODo66vXMNL5/arUaCoUCZmZmQnaWvvYoFApUV1eD4zg4OTkZZAsvKnyWGN9rz1hECehLpVL4+/tjypQp6N+/P7KysnDixAncuHFDr2yZHj164JVXXsHDDz+MS5cu4Z133sHVq1f1tmfq1Kn4/vvvkZmZiUceeeS2rsm6IJVKMX/+fEilUuzevdvggi17e3tYWVmJkpVlDPR3coGvr6/B6YX8rNHc3NzgzBaVSoXKykqYmZnB1dXVIFv47DkABr0IWq0W1dXVKC0thUqlgrOzM9zd3Y0uXHN0dMTixYvx1ltvoV+/fti6dSvWrl2LK1eu6BUsHjNmDI4fP46HHnoIa9aswT333IOMjAy9bJFIJIiKisKkSZOQkJCA33//XeemlI2xs7PDvHnzkJubi9jYWL2/zzN69GioVCpcuXLF4GOIQWVlJXJycgze8A+45Z2or6+Hg4ODwWniKpUKCoUCFhYWBu2fwv29eVlFRQXMzc3h6emp99bQHMdBoVA02YHS2tpatKxLUbPFLCwsEBgYiEmTJsHHxwepqak4ceIEsrOzdR6cJRIJxo0bh1WrVqF379748ssvsXnzZr3z0ENDQ7F161ZoNBo8/PDDSEpK0vt67OzssGDBAuTm5uLEiRN6f5/H1dUV1dXVRqWlGkthYSHq6+tb7cSsC403NzIEuVyOqqoqgzdaor9rYri/tzvWd7bH/d0mvbS0FAqFAo6OjvDw8BBtcyQeLy8vPP7441i+fDl69OiBTZs2Yf369UhKStJZZGxtbbF69Wrs27cPNTU1mDZtGr744gu9BSIkJARz585FdnY2du/e3WS7DF3p06cPJkyYgLNnz+LGjRt6fx+49Q4EBASIkjpsDImJibCysjL4PeAnJlZWVgbvRqlQKAQXtyFbCsvlcuEZdnFxQY8ePfTyIvCiIpfLhW07bGxsRNnDpTEmSUW2trZGcHAwJk2aBHd3d1y7dg0nT55Efn6+zi+Xq6srnn/+eSxduhTXrl3D22+/jcuXL+tlR58+fbB161b06tULS5cuRXR0tN7X0rdvX0ydOhWxsbFITU3V+/vALZcbx3FN9sroaFJTU+Hs7GxwEZxCoYBWqzV4IK6vr0dtbS1sbGzg7Oxs0EzN0NUK/V33VFJSIiQdeHp6wt7eXlRRaU7v3r3x3HPP4ZVXXoGlpSW++uorbNy4Ua8Bevjw4Th69CiefPJJfPTRR5g9e7beE6UBAwZgwYIFqK2txc6dO2+Lz+hCREQE/Pz8cPDgwdtieboyZswY3Lhxo8VYSkdAfxdVDx482KD6DSIS3LmG7GRJf7f7V6vVsLa21nvVw3EcKisrhX2Q+ImRPudXKpWQy+XCthmmEBUek4gLj62tLcLCwjBhwgQ4OTkhPj4e0dHRKCoq0un7fI+kNWvWwN/fH9999x2+/fbbJpkb7eHi4oJNmzZhzJgxePnll7Fz5069r2PMmDEIDAzE3r17DXoxLSws4Ojo2GmuMaVSiZs3bwqFnfqiVquFTBJ9H0QiQk1NjTCo67tTnjGrFfq7wK2kpAT19fWws7ODp6cnHBwcTCoqzfHz88Mrr7yC5557DiqVChs3bsSXX36JvLw8nb5vZWWF5cuX4+DBg9BqtZg1axY2bNigV+Gqp6cnFi1aBDMzM+zcuROFhYV6XYNEIsHs2bNhZWWF/fv3G7QKDw0NhY2NDc6dO6f3d8UgKysLtbW1Bu+Wy8dZDF11y2QyYYKmr7jJZDKUlJRAqVTC1dUVbm5uOr+L9HePMP78fBKCMdX3umBSceFxcHDA8OHDERUVBRsbG1y6dAmnTp1CWVmZTt93dHTE008/jaeeegoZGRl4++23ERcXp/MqyMrKCh9//DEefPBBvP/++9i4caNeMRSJRIJ77rkHNjY22LVrl0G+azc3N2Er3Y6G39ZYlwaIzeH+3vqU39NeH4gI1dXVUCqVcHJyMsgnbMhqhf7eQrm0tFRYLXl4eMDR0VHUKn59kEgkGDx4MN544w08/vjjqKiowPvvv4/vv/++xSanLTF06FD8+eefeOmll/DVV19hxowZiI+P19kGR0dHPPDAA3Bzc8OePXuQnp6u1zXY2NjgnnvuQUlJiUFuYgsLC4wcORJxcXGiNJ3Ul4SEBLi7u6Nnz556f1ehUKChoQGOjo56CwPHcWhoaAARwdbWVq8JmlarRUVFBaqqqmBlZQVPT0+dY4ONRYWv3DdE2AylQ980Z2dnjBo1CmPGjIFUKsW5c+dw9uzZ21IFW2PYsGFYs2YNhg4dii1btuCLL77Q+btSqRT/+c9/sGzZMvz00094/fXXdaoq57G2tsbChQtRWlqKw4cP6/w9HicnJ9H6eelLamoq+vTpo3eshJ9tSSQSvYPdWq0WlZWV0Gg0cHZ21su3bMxqhfdH82miHh4ewr3vCkgkEoSHh+Ott97C4sWLkZOTg7Vr12Lr1q06PcsWFhZ46aWXcOTIEdjY2ODuu+/G2rVrde7Ia21tjfvuuw9+fn74448/9HY1e3t7Y8qUKbh8+TJSUlL0+i5wK7BfU1OD5ORkvb9rDHK5HGlpaQYF8jUaDaqrq2FjY6P3BEmr1QrvkJ2dnV6TG5lMhtLSUqjVari5ucHV1VWn79PfbV14F5yFhQVsbGw6TFR4OmUa5+bmhsjISIwcORJqtRpnzpzBhQsXdHJ32dnZYenSpXj++eeRn5+PVatW4dSpUzqvYh566CFs3LgRMTExePLJJ/WKg3h7e+Ouu+7ChQsX9M5ik0gkcHV1RWVlpdE9q/ShsrISZWVlBrnEDI2zqNVq4TpdXFz08i0bulpRKBQoLS1FVVUVLCws4O7uDhcXF5Mv/Q1FKpVi9OjRWLVqFebPn4/r16/jnXfewS+//KLTexAQEIADBw5g+fLl+OGHHzB16lSd3U1mZmaYOXMmRo4ciVOnTuGvv/7S65kMDw9HUFAQ/vzzT70nS3369IGPjw/i4uL0+p6xXL9+HUSE4OBgvb7Hx1nMzMx0KmlojFqthkwmg5mZmV7vkFarRXl5OaqqqmBtbQ0PDw+dJ2e8qKhUKpibm8PW1lbYBqKj6Rwfwd94enpi3LhxCA8PR319PWJiYnDlyhWdMsOGDh2K1atXY8SIEdi2bRs2btyos5tt0qRJ2LRpE7Kzs7F48WKdfd/ArdVTSEgIfvvtN53Px+Pm5gaNRqNXzMhY0tLSYG1t3WrxaGuoVCqoVCq9A35KpVJ4GfVJNTZ0taJUKlFeXi6kN/fo0QOurq4dPkszFHNzc0yYMAFr1qzB7Nmzcf78ebz99ts4cOBAu5ld5ubmeOaZZ3Ds2DF4eHjg/vvvx4oVK3TaU0kikWDs2LGYMmUKrl69it9++02vfU1mzpwJBwcH7N27V6/v8Y1tExMTRd37qT0SEhLg7++v98qjtrYWWq1Wr/5hQNNUYxsbG52/29DQgJKSEqGwWdf4Dt9hWaVSCWLWWaLC06niAtx62Hx8fDBhwgSEhISgoqICJ0+eRGJiYrtLfRsbGyxevBivvPIKysvLsWrVKhw/flwnf+7QoUOFNuSLFy9u0vyyPXvnzJkDZ2dn7Ny5U6+gqo2NDWxsbDrMNcZxHNLT0zFw4EC9luN81bClpaVeqw65XI7q6mq9U40NWa2oVCpUVFQI99LNzQ1ubm5GbzjWWVhZWWH69OlYu3YtJk6ciJMnT+Ktt97CkSNH2n3GBgwYgD179mDt2rXYvXs3Jk+ejJiYGJ3OGxwcjHnz5iEvL0+vVGVLS0vce++9qKmpwZEjR3T6Ds/IkSMBABcuXNDre4ZSXFyM4uJivV1iMpkMMplM7+JEQ1KNNRoNysrKUF1dDVtbW3h6eur0XY1GA7lcDqVSCTMzM9jY2MDKyqpTRYWn08WFRyqVok+fPpg8eTKCgoJQXFyMv/76C0lJSe3GRgYNGoRVq1YhKioKu3fvxocffqhTRlrv3r2xdetW9O3bF4899hj++usvnWy1tLTEwoULUVNTg99++00vl4Kbmxtqa2sNSgrQl5ycHCgUCr1cYnycRSqV6hUn4VONbW1tdU41pr9bhOuzWuFdbuXl5dBqtXB1dUWPHj2MblfeVbC1tcXdd9+NNWvWICIiAr///jveeustREdHt/nMSKVSPProozhx4gQGDBiAhx56CK+++qpOacP9+vXDggULUF9fj59//lnnOGaPHj0wc+ZMXLt2DYmJiTpfo729PYYOHYqzZ892iIs4MTERdnZ28PPz0/k7arVaeJ71CaAbkmpcX1+P0tJScByHHj166PT+aLVaQVT4mGjz1lCdTdex5G+kUikGDBiAyZMnw9/fXyhgTE1NbXP5bWVlhYULF+I///kPGhoasHbtWhw6dKjdlElnZ2f897//xbhx4/DKK69gx44dOtnZo0cP3H333bh69SouXbqk8/XxbTp0fYGNIS0tDe7u7m32gGoOX1ilq4+4caqxg4ODzm1ytFottFqtsCFRey8F3zKmrKxMSAfVxxfd3XB0dMSCBQuwatUqDBkyBLt378aqVavazbTq3bs3duzYgQ0bNuDPP//EhAkTdFpZeHh4YOHChbCwsMCuXbt07moxePBghIWF4ciRI3rVr4wZMwYFBQV6uaQNQavV4tq1axg6dKhe2YbV1dUwNzfXOXXekFRjtVqNsrIy1NTUwM7ODh4eHu1OknhR4fdcEbuqXky6nkV/Y25ujoEDB2Ly5Ml6tZTx8/PD22+/jSlTpmD//v14//33232Arays8OGHH+Jf//oXPvjgA2zYsEEn11pwcDAiIiLw559/6lw3YG5uDmdnZ5O7xhoaGpCbm6tXJbJKpYJarW6xiV5L8IWhfKqxLtlo/GqFbzbZXjxHq9WipqZGaNXi5OQEDw8Po1u1dBfc3Nz0bikjkUiwaNEinDx5EqGhoXjsscfw7LPPtvvM8anK7u7u+PXXX5GWlqaTjVOmTIG7uzv27dunc6p9UFAQnJycTF6xn5aWBrlcrpdLjO+moWuchU81BqBTqjFf1FtWVgaO4+Du7g4nJ6d2O5y31Kqlq2RBtkSXFRceS0tLvVvKWFhY4N5778Wbb74JrVaLd999FwcOHGjXrfDKK69g+fLl2LFjB1577TWdUpWnT58OLy8v7Ny5U+d0UFdXVygUCoNacehKRkYGpFKpzq4AfkZkZWWl06xLq9WiqqoKGo0GLi4uOq0gmq9W2nuZ+FYtcrlcaNViZ2fXJfzJHU3jljJubm46tZTx8vLC//6vvXMPaupMw/hzDrlBSIBAQEsBKwIKIi6KSFqtKCLFasFaLzvIjlXbuuu23XXs1rVeUq3W3d7W0aJTbavFUZSV2K0sUvHSosVaJajQQBWqUFkU5WpISEL2j91zJiE5SbSgIN/vT8KY4HB4v/d9n+95Pv0UW7duxbfffovExEQcPnzY4ShKKBQiPT0d4eHhyM/Px7lz55x+Nh6Ph/T0dGi1Whw5csSln4emacTHx+P777+/J0HAvcK4VLsa1sfcRfP29nbpDzezSGdskZwdyphupbW1FZ6envD393c4PntQVi29QZ8vLgz3YykTEhKCVatWYfr06SgoKMD69etZe3Mu5s2bhw8//BDFxcVYvHix0xv5PB4Pc+fOhV6vx6FDh1yaIUskEvD5/F7tXiorK/HEE0+4NPdlWno3NzeXioSl1NgVZda9dCsPy6qlvxAUFIRly5a5bClDURTS0tLYNMk//OEPWLRokcMRlpubG1JSUhAfH4/i4mIUFRU57eS9vb0xY8YMVFVVubyoVygU6OjouKd9zb3Q2tqK6upql7uWzs5ONgbC1eego6PDJakxEzHBRBEwl3odZa08SKuW3qDfFBcGe5Yyp06d4lzg83g8zJgxA2+99RYEAgHeffdd5ObmOjwtTZo0CZ999hnq6uqwYMECp/Gw3t7eeP7551FZWYnTp087/RkoioKvry+ampp65aZyQ0MDmpubXR6JabVads/ijO5SY1fGWq50K33FqqW/YM9SZtu2bZwjYD8/P2RlZWHnzp0oLS3FpEmTkJOT4/AwpFAokJycjEuXLrkkVQ4LC8P48eNx/Phxl2LOAwICEBoa2mujsYsXL8LNzQ1RUVFOv5cZ8QoEApf2LHq93mWpcWdnJ27evIn29nZIpVLI5XLOA9nDsmrpDfpdcWGwtJQRiUT44Ycf8O2333LePQkMDMTKlSsxa9YsHD9+HEql0qGNeVRUFLKzs+Hm5oYFCxZYZYLbIzw8HBMnTsSxY8fw888/O/38MpmM3Sf0NBqNBhKJxCWbC71eD6PR6FJLr9VqXZYad3V1udSt9EWrlv5Cd0uZxsZGbNq0CTt37uS0lElJScHJkyfxzDPPYPny5cjIyHBYCKKiopCeno66ujocOHDA6R20p59+Go8//jhUKpVLY1+FQgGNRtMrApeysjJERka6pCRsbm6G2Wx2yZBSp9Ohs7PTqdSYEbvcunULNE3D39+f87D0sK1aeoN+//QyljIJCQmgKMqhpQxN05g2bRrWrFkDqVSKv//979i3bx/nEjIwMBB79uxBaGgolixZgq+//trhZ5k8eTKCg4Nx8OBBpxfEGMvunh6NMWme4eHhTk/8RqMROp0OQqHQ6cmora0NbW1tTqXG3S9DOupW+rpVS3+hu6XMzz//7NBSxsvLCx988AGys7Px008/YcqUKdi9ezdnFx0SEoK5c+dCq9Vi3759Dn9naZpGWloaTCaTSzL92NhY8Pl8nD179t5+aCdcv34dd+7ccWkk1t7eDr1e73TPwoyPXZEa6/V6drTr5eUFuVxu9xnrK1YtvUG/Ly4Mfn5+LlvKDBo0CCtWrMC8efNw+vRpKJVKTq8jLy8vbN++HZMnT8aKFSvwxRdfcD4wTMCY2WxGbm6u05GXr68v2tra7ukipjOqq6thMBic3m1hHhQej+fS6Uur1TqVGrt6GbK/WbX0F+xZyqxbt47TUmbSpEkoKirCrFmzsGrVKrzwwgucO0m5XI758+dDKBQiJyfHoQLT09MTzz33HGpqalBcXOzwM4tEIowZM6bH77yo1Wr4+Pg4TavU6/Voa2uDRCJx2OEwQXldXV0OOwpmvNbY2Agejwd/f3/O3Je+ZNXSGzwyxYXBVUsZiqIwefJkrFu3DnK5HB999BF2795tt5UXCATYtGkTFi5ciPfeew+bN2/mLBwSiYR9SE+cOOHws3p7e4Om6R7tXjQaDQIDA53eN3El+ItJu2NOdVzf66p1S3+3aukvWFrKpKamspYyX375pc3vt0QiwaZNm3Dw4EHU19cjKSkJO3bssCv39/T0xJw5cxAQEIBDhw45NK4cMmQIJk6ciOLiYqciGoVCgcbGxntO2+Sis7MTFRUViImJcfiH2tXgL6awAI6lxsyhSavVwtvbG35+fnYPTH3RqqU3eOSKC3BvljJ+fn7405/+hMzMTJw/fx5r1661q16haRqvvfYaVq9ejZycHPz5z3/mHKc98cQTrAWHoweGpmn4+Pj02Ly5paUF9fX1Thf5Op0ORqPR4SKScTVm9P5cpzpXupVHzaqlvyAUCpGSksJayhw/fpzTUiYhIQHHjh1DZmYmNmzYgOeee86uJT8jVR4xYgQKCgocjrMUCgWGDh2Kw4cPo62tjfP7QkNDIZfLe2yxX15eDoPBgJiYGIff19zc7DT4iykENE1z7iUtI4f5fD5n5HBftmrpDR7J4sLgyFLG8uGiKApPPfUUlEolQkJCsG3bNuzcudPuAzF79mxs2bIFJSUlWLRoEWdhmDBhAsLDw5Gbm+twae/r64vOzk6HD5+rVFVVQSAQYMiQIZzfYxn8xTWGYqTGADg7C1e6lUfdqqW/YM9SZs2aNTaWMh4eHli7di1UKhXu3r2L5ORk/OMf/7C5H0bTNJKTk5GQkIAzZ87g66+/ttvJUxSFmTNngs/nIy8vj7PbZ8wsL1y40CN5R2VlZRg6dKhD1Vdrays6OzvZ6YE9LKXGXAexjo4ONDQ0sJHD9kK8+oNVS2/waP90/4fLUqaystJKXunj48PeAygvL8fatWtx7tw5m1nwhAkT8Omnn+I///kPMjIy7KrDKIrC888/z86ouVwFxGIxhELhrx6Nmc1mVFZWYtiwYZxFw5XgL1ekxs66lYFm1dJfsLSUiYyM5LSUGTNmDAoKCrB06VJ88MEHSE1NtWvsOn78eEybNg0VFRVQqVR2d4fu7u5IS0tDfX29wzFxfHw8jEbjPVkp2eP27duora11uMi3DP7i6p6dSY0tI4eFQqHdyOH+ZNXSGwyMn/L/WFrKDBkyBFeuXLGxlKEoCvHx8VAqlYiIiMAnn3yCrKwsm+4jMjIS2dnZEAqFWLBgAS5cuGDzfu7u7pg7dy7q6+sd+jv5+vqipaXlvqJjGerq6nD37l2HIzFnwV+M1FgoFNqVGjvrVga6VUt/wdfXF5mZmVi9ejVCQkLsWsoIhUL85S9/YW/cP/vss3j33XdtXCsiIyORnp6O+vp6HDhwwK5KMjAwEFOmTMH333/PaSnj4+ODyMjIXz0aU6vVEIlEnIIWZs8iEok47fedSY27Rw53P4T1R6uW3mBAFRcGxlJmypQpnJYyUqkUL7/8Ml555RVUV1dj7dq1NoqWwYMHY8+ePQgPD8dLL71kt4AEBgYiJSUFJSUlKC8vt/t5ZDIZG0p0v1RWVkImk0Eul9t9vaOjw2Hwl6XU2J7PkaNuhVi19E8GDRqEJUuW4M0337SylKmoqGB/z0eOHIn8/HwsX74cO3bswLRp02zSK4ODgzF37lx0dHRg3759aGxstHmvsWPHYvjw4Thy5Ajn77lCoUBNTY3Lsc/d6erqwsWLFxEdHc0p+2W6cnt7Fkupsbu7u01XYxk5LBKJbCKHu7q62Fv1ZrO5X96q70kGZHFhcMVSJjY2FkqlEjExMfj888+xZcsWqxGWRCJBVlYWkpOT8cYbb+Czzz6zGaONGzcO0dHRyMvLs/vg8fl8SKXS+x6N6XQ61NTUcJ7WDAYDZ/AX4wDLJTV21K0Qq5ZHg+DgYCtLma1bt+LDDz9kLWV4PB5effVVHD16FJ6enkhLS8O6deuslGd+fn6YP38+3N3dkZOTY9fVIjU1FWKxGIcOHbLr8zdq1CiIxeL77l6uXr2K9vZ2zkU+E3Vh755Wd6lx9+LEhHgxkcOWnb2lVYvJZGKLykCX1g/o4sJgaSkjlUpZSxnmBCUWi7Fw4UK8+uqruHHjBtatW4dTp06xRUQgEOCdd97BkiVL8NFHH2Hjxo1WIy5msSmVSrF//367NhoymQxardZl80tLmD8CYWFhNq9Z7lm6n8QYlQuz2Ow+M+bqVohVy6OJpaWMTqezsZQJDw/H4cOHsXr1anzxxRdISkqyKgSMVHnw4MHIy8uzuTvGKM3u3LmDwsJCm/fn8XgYN24czp49e18jYrVajYCAAAwePNjmtY6ODmi1WkilUhuBCpNzD9hKjY1GIxobG9Hc3My6RzCjskfJqqU3IMXFAolEgri4ONZS5ty5c1aWMiNHjoRSqUR8fDz27t2L9957jzWioygKy5Ytw9q1a5Gbm4vXX3/dqlAweTNNTU3417/+ZdPdMGl39yNL1mg0CAkJsdltMNYqNE3bvOZIaswV4kWsWh59GEuZlStX2rWUcXNzw0svvYSioiI89thjmDNnDt58801W7SgQCJCWlobIyEgcPXoUJSUlVv++v78/pk2bhrKyMly8eNHm/RUKBVpbWzlHyFxotVpUVVXZXeQbjUa0tLTA3d3d5gDFyIPtSY2ZEC+j0Qg/Pz+2W3kUrVp6A/IXwQ5cljLMrDUjIwPLly9Hc3MzlEqllRRz1qxZ2LZtG3744Qe8+OKLVmMwf39/zJw5E2q1GqWlpVbvSVEUZDIZ6zbsKo2Njbh9+7bdkRhX8BcjEWbe0/KhYLoViqKsuhVi1TKwsLSUycjIQE1NDdavX4/s7GzcuXMHQ4YMwYEDB7Bx40bk5eVh8uTJrBqMpmlMnToVTz75JL777jsUFhZadSKjRo1CTEwMjh49auMF+PjjjyM4OPieR2OXLl0CRVGIjo62+rrlnsXLy8vqNS6pMRM53NLSwkYOC4XCR9qqpTcgxcUB3S1liouLWUuZiIgIrFmzBk8//TRyc3OxefNmNjBMoVDg888/x61bt5CRkYHq6mr234yJicHYsWPx1Vdf2SwufX192VOWq1RWVsLDwwNBQUFWX+cK/mKkxjweDz4+Pmxx4OpWiFXLwIamaSgUCiiVSsyePRuXLl3CunXrWP+8zMxMFBUVITw8HAsWLMDrr7+O5uZmAP/bNT7zzDP48ccfoVKprJRmycnJkMlkOHTokI0CLSEhAZcuXbJrWcOFWq1GeHi4TYfOqDC7B38xUmOBQGBVWNra2tjIYblczu5nHnWrlt6AFBcX4LKUMRqNmDNnDt544w10dHRgw4YNyM/Ph8lkQkREBLKzsyEWi5GZmWml309NTYVcLsf+/futLo2JRCJ4eHi4PBozmUz46aefEB4eblVAGH29QCCwOlVZSo0tL4/ZixwmVi0ES3g8HhITE1lLmZKSEtZSRiaTITs7G++//z4KCwuRmJiIgoICAMDw4cMxa9YsNDQ0WEmVmYCx9vZ25OfnW71XXFwcaJp2ORemvr4eN2/etBmJMTtMb29vq8MQUySEQiE7DjYYDOy4l4kcFggEA8aqpTcgxcVFHFnKPPbYY1i9ejWmTp2KL7/8Ehs3bsT169cxaNAg7N69G5GRkXj55ZfZh4gJGNNqtVCpVFZjMF9fX7S2trqUznft2jXo9XqrkZhl8JflKY6RGovFYlZqbC/Ei1i1EBzBZSlTWFiI9PR0nDhxArGxsVi8eDFeeeUVNDY2IigoiA3U27dvHzsKk8lkePbZZ6HRaKwOX2KxGKNHj3bZzFKtVkMikSA0NJT9msFgYLPpLRfwzJ6EkRp3D/FiIoctb9UPBKuW3oAUl3uEy1KmqqoK06dPx1//+leYzWZs3LgRKpUKIpEI27ZtQ2pqKlauXIldu3axCY7p6emoqKjAd999x/77TPvuSvei0WgQEBBgpdm33LMA1lJjqVTKGvR171aMRiOxaiG4DJelzI8//ojt27fj448/xpkzZ5CYmAiVSgWZTIb58+fDw8MDBw4cwLVr1wAAERERiIuLQ1FRETtWBv43Gquvr2e/jwuj0YjLly9j1KhR7B9+RgXJ5/NZab09qXFnZydu3brFuiLL5XK4ubkNSKuW3oD8j90nXJYyHR0dWLFiBWbMmIGjR49i/fr1qK2txdtvv42lS5diy5YtWL9+PUwmE0aMGIEnn3wShYWF7L0AZvHo7M5Le3s7amtrrW7k6/V6GAwGVvXSXWrs7u5uE+LFLDyJVQvhfrBnKaNUKuHv74+ioiJMnDgRy5Ytw8KFC9HW1oY5c+YgMDAQeXl5rCIsMTGRlS8zCsvhw4fDx8fH6WJfo9FAp9NZjcSY4C/moNZdakzTNBviBYC98MvsYQaiVUtvQP7nfiWWljIhISG4cuUKTp06hYiICKxcuRJCoRCbN29Gbm4uXnzxRbz99ttQqVT44x//iLt37yIpKQlBQUFWKX++vr7Q6/UOU/+qqqrA4/EwdOhQALbBX0wnYik1Zi5DUhQFiqLYcQCxaiH8WrpbyuzZswdZWVlYvHgxdu7ciYsXLyIxMRG5ubmYMWMGoqOjUVhYiDNnzsDNzQ1paWkwGAysTJ+maYwfPx7nzp1zmHekVqsRHBwMmUwGwDb4q7ursdFoxM2bN1lvMT8/P5hMJuh0OpjN5gFr1dIbkOLSQwgEAkRGRlpZylRWVmLevHlIT0/HyZMnoVQqMXz4cHz88cdQq9VYuHAh7ty5gxdeeAEmkwn//Oc/0dXVBYlEAoFA4LB7qaysxNChQ9m5sWXwl8FgQFNTEys1Zh4ys9kMiqLYuyrEqoXQ01hayshkMnzyyScoLS1FVlYWUlNTsWLFCmRkZCAsLAwTJkzA2bNnUVBQALFYjJkzZ+Lq1avsmDghIQE6nY4zYrylpQU1NTVs18K4i3t6ekIoFKKzsxMdHR3g8Xhwd3e3ihz28/ODQCAgVi29CCkuPYylpYyfnx/Ky8vB5/OxZMkSeHl54f3338fVq1exY8cONDU1ISMjAzdv3sTs2bNx9epVnDp1CsD/lp1NTU12bcrr6+vR2trKjsQsW36dTsdKjZldDNOtMHdViFULobfpbimze/duBAYG4m9/+xuqq6uRlJSES5cuISUlBVVVVcjLy0NgYCCeeuopfPPNN7h27RrkcjnCwsI4R2NlZWXg8/kYMWIEOwIWCASQSCTQ6/XQ6/UQCASgaRoNDQ3s3lEqlcJgMBCrll6GFJdeorulTG1tLeLi4lgTy7179+Ktt96CVCpFZmYmbt++jcTERJw8eRJXr16Fr68vG5naHY1GA6lUisGDB7PBXx4eHtBqtWhpaYFQKIRUKoXZbIbZbEZHRwdu3bpFrFoIDxzGUub3v/89dDodiouLMXfuXKSkpGD16tVYtWoVxo4di1u3biEnJwcxMTEICQmBSqVCe3s7FAoFKisrbTz5zGYzysrKEBUVBYFAwJph+vj4sFJjPp8PrVaLxsZG1qySpmli1fKAIMWll7G0lGFu806bNg2enp7Yu3cvpkyZghEjRmDp0qVobW1FaGgoDh48CJ1OB4lEYjMaMxgMqK6uRkREBIxGIxv8pdVq0d7eDg8PD3h6erKeYrdv30ZbWxuxaiE8NCiKwsiRI7Fy5UosWrSINZD83e9+h19++QUZGRlob2+HTqfD/v37kZCQAJqmoVKpEBMTA5FIZGMjU1dXh+bmZowePRptbW2saIU5bFEUxaokPTw8WPUksWp5cFDme/EaIfxqGhsbodFocOfOHdy4cQOlpaUQi8W4e/cuSkpKsHjxYjbVLi0tDbW1tYiMjGQll3w+H+fOncNvf/tbdvHJFBlm1syEIZlMJri7u0MikZATGqHP0NXVhZKSEhw5coS1LyopKUFUVBSmTp0KkUiE2NhYfPPNN4iPj8eNGzdQUVGBDRs2oLa2Fhs2bEBcXBwMBgObBuvp6cl2JZ2dndDpdODxeBCLxaBpGnw+H3w+n3TrDxBSXB4SDQ0N0Gg0uHHjBi5cuICbN2/CZDKhrKwMU6ZMgVQqRUJCAgIDAyGXyyGVSnH58mXU1NRAKpVi4sSJMJlMMBqNMBqNkEqlMJlMaG9vR1dXF0QiESQSCTmhEfosjKXSv//9b9TW1rKWL0lJSYiKisKgQYNw/fp1jBs3Drm5uXjttdfg4eEBpVIJPz8/TJ8+HREREXBzc4NIJIJOp4Ner2dzi5hJASkqDwdynH1IBAQEwN/fHzdu3IC/vz/UajUuXLiAkJAQFBQUYPjw4ejs7ERycjJomoZEImF9j6Kjo6HX69lMDJFIxI4amKJCbtQT+jp8Ph+JiYlQKBQ4ceIECgoKcP78eXz11VcoLS1FUlISvL29oVar4e3tjTNnziApKQlNTU3w9vZGcHAwTCYT+Hw+mpubYTQaWSGLUCgkNi0PGVJcHiKMpczgwYMRFhaGYcOG4dixY7h79y7UajXq6upgNBoxffp01NXVQaVSwcvLi81+oSgKNE2jra0NIpGIfagIhP4EYykzYcIEHDt2DAcPHkRxcTF27tyJuLg4DB06FB4eHjh//jy8vLyg0WgQFBQEiqLQ1dWFxsZG8Hg8SKVStlsne8WHDxmL9SFMJhOuXbuGgoICqFQq1kacsQBniI6ORlZWFoKCgiAUCuHl5UVu1BMeGVpaWpCfn4/t27fjwoULEIvFGDZsGC5fvmzlGD5y5Ehs3boVoaGhkMlk5EZ9H4MUlz6I0WhEeXk5srKysGvXLruRsKNHj8bp06dtwo8IhEeF27dvY9euXdiyZQt++eUXm9eZzJmSkhIiWOmDkOLShykpKUFCQgLn6+fPn0dsbOwD/EQEwoMnPz8f06dP53ydPAd9E9JD9mEYM0surly58oA+CYHw8GAyYLggz0HfhBSXPoxlPoU9hg0b9oA+CYHw8CDPQf+EFJc+TGxsLOLj423myTweD/Hx8fjNb37zkD4ZgfDgIM9B/4QUlz4MRVFQqVQYM2aM1dfHjBkDlUpFNPyEAQF5DvonZKHfDzCbzSgtLcWVK1cwbNgwsrwkDEjIc9C/IMWFQCAQCD0OGYsRCAQCocchxYVAIBAIPQ4pLgQCgUDocUhxIRAIBEKPQ4oLgUAgEHocUlwIBAKB0OOQ4kIgEAiEHocUFwKBQCD0OKS4EAgEAqHHIcWFQCAQCD0OKS4EAoFA6HFIcSEQCARCj0OKC4FAIBB6HFJcCAQCgdDjkOJCIBAIhB6HFBcCgUAg9DikuBAIBAKhxyHFhUAgEAg9zn8BJEX1aggtJBsAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=4, device=device)\n", - "model(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "ae15bae4", - "metadata": {}, - "source": [ - "You may want different multiplication nodes to take in different number of variables. This is also possible: pass in mult_arity as a list of lists, specifying the arities in each layer, including input layer, hidden layer(s), and output layer." - ] - }, - { - "cell_type": "markdown", - "id": "4f81c620", - "metadata": {}, - "source": [ - "In the following example, we have 0 multiplications in the input or in the output layer, corresponding to empty lists. In the hidden layer, we have two multiplications with arity = 2 and arity = 3, so we have the list [2,3] in the middle." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1cbc4656", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACQM0lEQVR4nO2dd3xUdbr/PzOT3nvvhSRAQi+hCgLiiquIiihWbCvYVl3b3atXr6669ra6q2ClWLAhKr0khBYChJDe6yQzmcn0ds739wf3nF8SUiYzZ0rC9/168bp3zcw5z5yZcz7fp3yfR0QIIaBQKBQKRUDErjaAQqFQKGMPKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHA9XG0ChjAakUim2bdsGqVSK6OhorF69GtHR0a42i0JxW0SEEOJqIygUd4VlWTzzzDN44403wLIsJBIJGIaBWCzGY489hpdffhliMQ0AUCj9oeJCoQzBU089hVdffXXQvz/55JN45ZVXnGgRhTI6oOJCoQyCVCpFQkICLBbLoK/x8PBAS0sLDZFRKP2g/jyFMgjbtm0Dy7JDvoZlWWzbts1JFlEoowcqLhTKIEilUkgkkiFfI5FIIJVKnWQRhTJ6oOJCoQxCdHQ0GIYZ8jUMw9CQGIUyADTnQqEMAs25UCi2Qz0XCmUQoqOj8dhjjw35mscee4wKC4UyAHQTJYUyBC+//DIA4I033gDDMCCEQCQSQSKR8PtcKBTKxdCwGIViBVKpFK+//jpef/11PP7443j88cepx0KhDAEVFwrFSk6dOoVp06ahuLgYU6dOdbU5FIpbQ3MuFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFAqFQhEcKi4UCoVCERwqLhQKhUIRHCouFIqVMAwDACCEuNgSCsX9oeJCoQwBIQRnz57FU089hYcffhienp54/vnn8cMPP0Cv17vaPArFbRERugyjUAbEYrHggw8+wKeffopVq1Zh1qxZ8PLyQmdnJ7755htIJBK8++67iI2NdbWpFIrbQT0XCmUQvvrqK3z99dfYvHkz/v73v+O7777D3XffjbS0NGzevBnTp0/Hgw8+CJ1O52pTKRS3g4oLhTIAXV1deOutt/D6669jwoQJAACZTIbm5mYYjUb4+Pjg0Ucfha+vL37++WcXW0uhuB9UXCiUASgqKkJkZCSSk5NRU1OD6upqaDQaEELQ0tKC6upqNDc3Y+3atfjhhx/AsqyrTaZQ3AoPVxtAobgj1dXVyMnJwVNPPYUdO3YAAPR6PRiGwbp16yCRSBAUFITNmzdDKpXCbDbD29vbxVZTKO4DFRcKpR9msxnNzc0wGAyIj49HdnY2AKCmpgZKpRLJyckICAhAQEAARCIRCCEQiUQutppCcS9otRiFAqClpQW7du3Crl27sG/fPiiVSowfPx779++Hn58fCCG48cYb8dtvv+GPP/7A3LlzAQDbt2/Hq6++iltvvRXZ2dnIzs5GSkoKJBKJiz8RheJaqOdCuSQxGo0oLCzkBeX8+fMQi8WYNWsWHnzwQUyZMgUvv/wyfvjhB9xxxx0AALH4QorS09MTXl5e6O7uxscff4zVq1cjJiYGJ0+exP79++Ht7Y2MjAxkZ2cjKysLYWFhLvykFIproOJCuWSoq6vjxeTAgQPQ6XSIjY3FsmXL8Oyzz2LBggXw8PCA0WiEl5cXXn31Vdx///3w9vbGddddh4yMDEyfPh0BAQFobm7G3/72N+Tm5iI/Px+enp5YuHAhAKCqqgoVFRV8oj8qKgpZWVnIzs5Geno6PDzobUcZ+9CwGGXMotPpcOjQIezatQt//PEHamtr4enpiTlz5mDZsmW44oorMGHCBBBCoNFooNPpIJFIEBgYCB8fHwBAYWEhnn76afj4+GD27NkICAhAXV0diouLsXr1ajz44IMQiUSor69He3s7/Pz8kJ6ejvDwcBgMBlRXV6OiogIVFRXo6emBp6cn0tPTea8mIiKC5msoYxIqLpQxAyEElZWVvJgUFBTAaDQiKSkJV1xxBa644gosXLgQgYGB/Ot1Oh00Gg0AICAgAH5+fhc97NVqNYqKinD48GGcOXMGy5cvx1VXXYWkpKQ+r9VoNKitrYVCoUBoaCgyMjLg7+/Pn0sqlaKyshIVFRWoq6sDwzAIDw/v49XQijPKWIGKC2VUo1KpsH//fj7c1dzcDG9vbyxYsABXXHEFli1bhszMzIsEw2AwQK1Wg2EY+Pn5ISAggM+pDIZcLsdPP/2Ea665BuHh4UO+rra2Fnq9HjExMUhNTYWXl1ef15hMJtTU1PBiI5fLIZFIkJqayhcGREdHU6+GMmqh4kIZVRBCUFpaij/++AO7du1CUVERLBYLMjMzeTGZN28e/Pz8Bny/2WyGWq2GyWSCt7c3AgMDrc6BWCsunJ2tra1oaGgAIQTJyclISEgYVMBkMhkqKipQWVmJmpoamM1mBAcH815NZmYmfH19rbKTQnEHqLhQ3J7u7m7s3buX906kUin8/f2xaNEiLFu2DEuXLkVqauqQx2AYBhqNBnq9Hh4eHggMDBxxCGok4sJhNpvR2NiI1tZWeHt7Iy0tDVFRUUO+x2KxoK6ujhcbqVQKsViM5ORkZGVlIScnB3FxcdSrobg1VFwobgfLsiguLubF5MSJE2BZFhMnTsSyZcuwbNky5OfnWyUOhBBotVpotVqIRCI+r2ILtogLh06nQ11dHWQyGYKCgpCRkYGgoCCr3qtQKPjwWXV1NYxGIwICAnivZty4cXxuh0JxF6i4UNyCzs5O7NmzB7t27cLu3bshl8sRHByMyy+/nPdO4uPjR3RMvV4PtVoNQgifV7FntW+PuHAoFArU1tZCo9EgKioKaWlpfGWaNTAMg4aGBl5s2traIBKJkJiYyItNYmLisPkjCsXRUHGhuASLxYLjx4/z3smpU6cAAFOnTuW9k5kzZ9q0J8RkMkGtVsNsNsPHxweBgYGC7JgXQlyAC95UR0cH6uvrYbFYkJiYiKSkJJtsVKlUqKys5P/p9Xr4+voiKyuL/2eth0ShCAkVF4rTaG1txe7du7Fr1y7s3bsXPT09CAsL48VkyZIlw+YjhoJhGKjVahgMBnh6eiIwMPCiKi17EEpcOBiGQVNTE5qbm+Hh4YHU1FTExMTY7F2xLIvm5mY+V9Pc3AxCCOLi4vh9NbQ1DcVZUHGhOAyj0YiioiJ+30lZWRnEYjFmzJjBC8rUqVPtftixLMvnVSQSCQICAhxSWSW0uHAYjUbU1dVBKpUiICAA6enpCA0Ntfu4Go2G38RZWVkJjUYDb29vZGZm8uXOISEh9n8ACmUAqLhQBKWhoYEXkwMHDkCr1SI6OpoXk8svv1zQXlvcJkhCCPz9/eHv7++wKipHiQuHSqVCbW0tenp6EB4ejvT0dJuLD/rDlUZzQtPY2AiWZREdHc17NWlpabQ1DUUwqLhQ7EKv1+Pw4cP8vpPq6mp4eHggPz+fb7GSm5sr+APfaDRCrVbDYrHA19cXgYGBDk9iO1pcOLq6ulBbWwuj0Yi4uDikpKTA09NT0HPo9fo+Xg3XmqZ3w82IiAhBz0m5tKDiQhkRhBBUV1fzYnL48GEYDAYkJibyYnLZZZc5LIlssVigUqlgMpng5eWFwMBAwR+8g+EscQEuhPpaWlrQ2NgIkUiElJQUxMXFOURAuQIDrgKtvr6eb03Dhc/S09MFzV9Rxj5UXCjDolarceDAAb6yq7GxEV5eXpg/fz6/Kz4rK8uhm/pYlu3TXDIoKMjpfbicKS4cJpMJDQ0NaG9vh4+PD9LT0x3uURiNxj6tabq7uyGRSJCWlsaLTVRUFN3ESRkSKi6UiyCE4Ny5c7yYHDlyBGazGenp6byYzJ8/3ykb93o3l+Q2Qfr6+rrkweYKceHQarWora1Fd3c3QkJCkJGRgYCAAIeflxByUWsai8WCkJAQvltARkbGiPbqUC4NqLhQAABKpbJPixWuffxll13Gb2JMT093qk22NJd0JK4UF47u7m7U1NRAp9MhJiYGaWlpTg1Xmc1mvjVNRUUFurq6IBaLkZKSwns1sbGx1KuhUHG5VGFZFiUlJbyYHD9+HAzDYPz48Xxl15w5c1yyIjWbzVCpVDCbzSNuLulI3EFcgAveRFtbGxoaGsCyLJKSkpCQkOCS/Svd3d19WtOYTCYEBgb2aU0jVMUbZXRBxeUSQiaT8ZsYd+/ezfe5Wrx4Me+dJCYmusy+3psgPTw8EBQU5FZJZHcRFw6LxYLGxka0tLTAy8uLb4rpKq+BYRjU19fzYtPe3g6RSISkpCRebIbqDE0ZW1BxGcNYLBacPHmS906Ki4tBCMHkyZN572TWrFlOq7YajP7NJQMDA92yvby7iQuHXq9HXV0durq6EBgYiIyMDAQHB7vaLPT09PRpTWMwGODn59enNQ03uI0y9qDiMsZob2/v02JFoVAgLCwMS5Ys4b2T6OhoV5vJ07u5pKM3QdqLu4oLh1KpRG1tLdRqNSIjI5Genu42iXaWZdHU1NSnNQ0AxMfH87ma5ORk6tWMIai4jHJMJhOOHj3K74ovLS2FSCTC9OnT+cquadOmuV0/KZPJBJVKBYvFImhzSUfi7uIC/P9xyvX19TCbzUhISEBSUpJb5Kx6o9Fo+ng1Wq0WPj4+GDduHB9Ccwfvi2I7VFxGIU1NTbyY7N+/HxqNBpGRkXyoa+nSpYK2WBESi8UCtVoNo9EIT09PBAUFuTwsZy2jQVw4GIZBc3MzmpubIRaLkZqa6rZVXIQQtLS09GlNQwhBTEwM3y0gNTXV7QSSMjRUXEYBBoMBBQUF/K74yspKSCQSzJ49m98Vn5eX59Yhhf6bIAMDA90mZGMto0lcOIxGI+rr69HR0QF/f3+kp6e77cKDQ6/Xo6qqihcblUoFLy+vPq1pRsv1v5Sh4uKGEEJQW1vLi8mhQ4eg1+sRHx/Pi8miRYtGTdigd3NJbhKkO66gh2M0iguHWq1GbW0tlEolwsLCkJ6ePiqmV3Ktabh9NfX19WBZFhEREX1a04wW7/dSgoqLm6DRaHDw4EG+squ+vh5eXl6YO3cunzvJyckZVQ/l3s0l3WETpL2MZnHhkMlkqK2thcFgQGxsLFJTU0fVg9lgMPCtacrLy6FUKuHh4YG0tDTk5OQgKysLkZGRo+o+GatQcXERhBCcP3+eF5PCwkKYTCakpqbyYrJgwQKntPgQGrPZDLVazTeXDAoKGhPx8rEgLsCFEGVraysaGxsBAMnJyYiPjx91wk8IQVdXF+/V1NXVwWKxIDQ0lPdqMjIynN6DjnIBKi5OpKenB/v27eMFpbW1Fb6+vli4cCGfjE9PTx+1qy6WZaFWq6HX6+Hh4YHAwMAxdWOPFXHhMJvNaGhoQFtbG7y9vZGeno7IyEhXm2UzZrMZtbW1vNjIZDK+mIETG3smfVJGBhUXB8KyLM6cOcOLydGjR8EwDLKzs3kxmTt3rltuGBwJ/TdBcnmVscZYExcOnU6H2tpayOVyBAcHIyMjY0xsbpTL5X1a05jNZgQFBfVpTTPa7z13hoqLwMjlcuzZs4dvsdLZ2YmAgIA+LVaSk5NdbaZg9G4uyW2CHG3hFWsZq+LCoVAoUFNTw08PTUtLGzOep8Vi6dOapqOjAyKRCMnJyX1a01CvRjiouNgJwzAoLi7m952cPHkShBDk5eXx3sns2bPdqkeWEPRuLjlaNkHay1gXF+CCF9re3o6GhgZYLBYkJSUhMTFxzH23SqWS38BZVVUFg8EAf3//Pq1pRmO+052g4mIDUqmUb7GyZ88efsZG7xYrsbGxrjbTIfRuLunp6YnAwMAxJ5yDcSmIC4fFYkFTUxNaWlr4aqzo6OgxubJnGIZvTVNRUYHW1laIRCIkJCTwXk1SUtKY9cgdBRUXKzCbzTh27BjvnZw5cwYikQjTpk3j951MmzZtTFREDQYhhN8E6c7NJR3JpSQuHAaDAXV1dejs7ERgYCDS09MREhLiarMcilqt7tOaRqfTwdfXl29Nk5WVNWr2mLkSKi6D0NzcjN27d+OPP/7Avn37oFarERERgaVLl/LeiaPHzboLvTdBuntzSUdyKYoLR09PD2pra6FSqRAREYH09PRLYnHBsmyf1jRNTU0ghCA2NrZPa5qxFjYUAiou/4fRaERhYSG/K768vBxisRizZs3ivZPJkydfUq5x7+aSvr6+CAgIuKRvoktZXIAL3mtnZyfq6upgMpmQkJCA5OTkMe2x90en0/VpTaNWq+Ht7d2nNY27t9dxFpe0uNTV1fFicvDgQeh0OsTGxvZpsRIaGupqM51O7+aSXl5eCAwMHFW7uB3FpS4uHCzLorm5GU1NTfyI47i4uEvOm+WKH7hcDTcZNDIykt9Xk5aWdsneO5eUuOh0uj4tVmpra+Hp6Yk5c+bwu+InTJhwyd0kHGOhuaQjoeLSF5PJhPr6erS3t8PPzw/p6emX9HXhWtOUl5ejsrKSb03T26uJiIi4ZJ4vY1pcCCGoqKjgxaSgoABGoxHJycm8mCxcuHBMbBizB0IIn1cBMKqbSzoSKi4Do9FoUFtbC4VCgdDQUGRkZIyKppiOhAsh9m5NwzAMwsLC+jTcHCv7iAZizImLSqXC/v37eUFpbm6Gj48PFixYwO87yczMpA/O/6P3Jsix0FzSkVBxGRq5XI7a2lro9XrExsYiJSXlkilTHw6TydSnNY1cLodEIunTmmaslXqPenEhhODs2bO8mBQVFcFisWDcuHG8mMyfP/+SqGwZCb2bS3p7eyMwMPCSSszaAhWX4WFZFm1tbWhoaAAhBMnJyUhISKALln7IZDK+W0BNTQ3MZjOCg4P5fTWZmZmj/pk1qsXFZDJh/PjxaGlpgb+/PxYtWsSXCaemprraPLdFp9NBpVKNyeaSjoSKi/WYzWY0NjaitbUV3t7emDFjxiVdaTgUFosFdXV1vNhIpVKIxWJcc801mDt3rqvNs5lRIS51dXWD/s1isUAsFkMkEl3kUiqVSvz000/4n//5H0eb6HZw0/sG8kYYhoHJZBpyZXSpejEqlWrQv2k0Gpw+fRqTJ0++qDUIIQRVVVWYMWOGo010O/R6/aB/48KuA3Vbtlgs6OrqQlpamiPNc1t27NiBrKysiypSjUYjuru7ERQUNGTuyt332Y0KcbGF9vZ2XHXVVfjpp5+QmJjoanOcDtemRSwWIzAwcEzFcl0FwzDQ6/Xw9fW9aBW+e/duzJ49+5IvDrEWhmFw8uRJTJo06ZKtSFQoFNiyZQvmzJmDSZMmjbl7dEyKS3NzM/785z/j999/R3R0tKvNcRmEEJhMJmg0GoSGhtK4t4OQy+U4f/485s+f72pTRgUsy6K4uBgTJkwYk6MZRgLDMPjhhx8QFBSEpUuXjimBGXNPG61Wi6VLl+LAgQOXtLAAgEgkgre3N4KDgyGXy8GyrKtNGnMQQrBz507MmzfP1aaMCgghKCkpQXZ29iUvLAAgkUiwatUqeHt7Y9u2bRhLa/0x5bkQQjBx4kTs378fUVFRrjbHrWAYBt3d3ZfUJi5ncPDgQeTl5V2SnRxGCiEEpaWlSExMpNdrAIqLi3Hu3DncdtttY+IeHVOeyxNPPIG3336bCssASCQShIaGQi6Xj6nVkSvh5tnQB+XwcBuaY2Ji6PUahGnTpmHq1Kn47LPPxsQ9OmbEpa6uDrW1tVi6dKmrTXFbPDw8EBQUBIVCMSZ+vK6EEIKffvoJl19+uatNcXsIIairq0NgYCBd+A1Dbm4upk6diq+++mrU36NjIixGCEFMTAza29tp0toKdDodGIahlU12cOzYMaSkpFzyeT1raGpqgsViuWRLjm3h+PHjaGpqwqpVq0ZtiGxMPInXr1+PX3/9lQqLlfj5+YFlWRgMBlebMiqRSqVQqVRUWKygvb0der2ebmoeITNnzkRYWBh27drlalNsZtQ/jc+fPw+5XI7p06e72pRRRVBQEDQaDSwWi6tNGVX09PSgoKAAS5YscbUpbo9UKoVCocC4ceNG7erblSxatAh6vR7Hjh1ztSk2MarDYmazGSkpKWhpaaE/XhsghKCrqwsRERHU67MCmUyGgoICrFix4pLtYGAtnZ2d6OzsvKRHWAgBIQRffPEFZs2ahezsbFebMyJG7ROFEIJFixahsLCQ/nhtRCQSISIiglaQDQMhBNXV1Thx4gQVFivo6OigwiIQIpEIt912G/bs2YOWlhZXmzMiRqXnYrFYcMcdd+DGG2/En//8Z1ebM+oxm81QqVQICwujD4NeEEKg1Wpx/PhxhISEXHJjrkcKIQStra3QaDTIysqivyUBYRgGb775Ju66665R0zR1VIkLIQRlZWX429/+hnvuuQcrV650tUljBqPRCI1GQwXm/9Dr9SgrK4NCocC0adMQGhpKr8sQEEJQW1sLkUiEtLQ0eq0cgMlkwptvvokHHngAQUFBrjZnWEaFuHR1deHw4cPYvn07fHx88N///d9ISkpytVljDk5gLuU+ZEajEWVlZZDJZBg/fjzi4+Ppg3IYzGYzzp8/j+jo6DE38Mrd0Ov1ePvtt/HII4+4/byXUSEua9euRXp6Oq666iqbOhzHxsY6wCr3hmEYm95nsVhgNBpHxcrIERQWFiI8PNzmAVeXYr+smpoahIaGXjSGwFou1XlCQ413GAq1Wo1Tp07h6quvFtgiYRkV4tLc3Dzk3wkhQ66WLtWW+4NBCIHFYoGHh8eg1+1SHeyk0WgG/RvLsnzL/cGEx9YH7GhmqP1S3H4qHx+fQa/ZpdpyX6lUDvo3hmGg0+ng5+c36L0YEhLiGMMEYlSIy1CUlJQgPz8fRUVFmDJliqvNGRWYzWbI5XKEh4fD09PT1eaMGugkypGjVqtRXFyMadOm0Y4QI6C1tRVvvfUWHn30UcTHx7vaHJu4NAPrFAqFQnEoVFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBQKhSI4VFwoFAqFIjhUXCgUCoUiOFRcKBSKQ2EYBhaLBYQQV5syamAYBizLjupr5uFqAygUytiDEILS0lJ89tlnKCwshI+PD1JSUnDttddi+fLl8PX1dbWJbgd3zTZv3oxjx46hoaEBzc3NuPnmm0flNRvVnotUKsWWLVtgsViwZcsWSKVSV5vk9kilUrz//vv4xz/+gffff59eMyuRSqX497//je3bt+Pf//43vW5DYLFY8O677+Lmm29GcHAw3njjDbz99tu4+uqr8eWXX+K2225De3u7q810K7hrtnbtWvj6+uLFF1/E9u3bceONN+KLL74YndeMjEIYhiFPPvkk8fDwICKRiAAgIpGIeHh4kCeffJIwDONqE92O/tes9/+l12xw+l83iURCr9swfPrpp2Ty5Mlk37595MSJE4RlWcKyLJFKpeSXX34hL7/8Mlm1ahXRarWuNtVt2LRpE5kxY8ag1+yll14i11133ai6ZqNSXJ588kkCYNB/Tz75pKtNdDvoNbMNet1GRmdnJ4mLiyO//PILWbFiBYmJiSG///47aW9vJ8uXLydBQUFk+/btZO3atWTLli2uNtct6OzsJHl5eWTHjh1DXrM1a9aMqms26sSlo6ODeHh4DHnDe3h4kI6ODleb6jbQa2Yb9LqNnM8//5wsWrSIaDQa8uyzzxJPT08SFRVFZsyYQUQiEZk1axapr68ne/fuJTfeeCP1/AghP/30E1myZMmw12z37t3kmmuuGTXXbNTlXLZt2waWZYd8Dcuy2LZtm5Mscn/oNbMNet1Gzvbt2zF+/Hj4+fnh73//O9avX4/Ozk6cOHEC2dnZ2Lx5M5KTk5GRkQGpVAqz2exqk11OdXU1srOzh71m48aNQ1VV1ai5ZqNOXKRSKSQSyZCvkUgkNOHaC3rNbEMqlUIkEg35Gnrd+tLd3Q2j0QgAUCqVKC8v5/8ml8tRXV0NADCbzRCLxcNe30sBLy8vq6+ZxWIZNdds1IlLdHQ0GIYZ8jUMwyA6OtpJFrk/0dHRsFgsQ76GXrO+HDp0CN9//z39rVlBZ2cnPvzwQyxYsACHDx/GiRMn0NbWhrvuugu7du3CrFmzsH79eigUCtx+++04cOAATpw4gXHjxsHLy8vV5ruUpqYmHD16FMePHx/2mh0/fhxRUVGj55q5Oi43UmgcfOQUFhYOeb3oNbsAy7Lkt99+I/PmzSMAyIQJE4hYLKbXbQC6u7vJp59+SpYuXUrEYjHx8PAgl112GcnOziYSiYS8/fbb5Pbbbyf5+fmkrq6OGAwG8uyzz5KEhATy7bffkssuu4wcOnTI1R/DJbAsS/bt20euu+46IhaLSWBgIImLixv2ms2YMYP8+OOPrjbfakaduBBCK3hGwq+//kqCg4NJWFgYvWaDwDAM2b59O5k2bRoBQGbNmkV++eUXwrIs/a31Qq1Wk6+//ppcffXVxNPTk4hEIrJo0SLy0UcfkTfeeIMEBgaS+Ph4smjRIhIaGkr+9a9/kaamJr6sVq/Xkz179pBVq1aRZ599llgsFld/JKei0WjIRx99RCZOnEgAkPHjx5MPP/yQ9PT0kKuvvnrIa7Zy5UoyZ86cUXXNRqW4mM1mEhwcTEQiERGLxcTT05NfPdG9BxdgWZa89NJLRCQSkRUrVpDu7m5+vwa9Zhcwm83kq6++IhMmTCAAyKJFi8iePXsIy7L8a3rvc7kUr5teryfbt28nN954I/H19SUASH5+PnnnnXdIW1sbqa2tJYsXLyYAyN13302USiVhGIbccsstxNPTkyxcuJA8//zz5M033yT33nsvycrKIq+99hoxGAyu/mhOo7a2lvz1r38lISEhRCwWk2uvvZbs3buXF5D169cTkUhEnn32WZKcnHzRNYuPjyeXXXYZ0el0rv4oI2JUisuvv/5KAJCdO3eSd955hzzzzDPknXfeuSTDEwOhVqvJqlWrCADy3//9330egB0dHZf8NTMajeQ///kPSU9PJwDIn/70J1JYWDjkey6l62YymcjOnTvJbbfdRgIDAwkAMmXKFPLqq6+S+vp6QsgF0X3nnXeIn58fSU5OJrt27broODU1NeQvf/kLueyyy8gVV1xB3n33XdLQ0NBHvMcqDMOQ33//nVx11VVEJBKRsLAw8re//Y2/foRcWAD+9a9/JQDIv//9b0IIISqVimzdupWsWLGCzJ07l8TGxpIJEyaMyms2KsXlqquuIlOnTh2VF9zR1NTUkIkTJ5KAgADyww8/uNoct0Kr1ZJ33nmHJCQkEJFIRK6//npy6tQpV5vlFlgsFrJv3z5y77338iHU7Oxs8vzzz5OKioo+r62srCRz584lAMiGDRuIWq12kdXuR09PD3n33XfJuHHjCAAyadIk8sknnwzodTz77LMEAHnvvfcGPd5PP/1EAJATJ0440myHMOrEpa6ujohEIvLJJ5+42hS34/fffychISEkMzOTlJWVudoct6Gnp4e88sorJCoqikgkEnLrrbeS8+fPu9osl8OyLDly5Ah56KGHSExMDAFAUlJSyFNPPUVOnz590eLNbDaT1157jfj4+JCMjAxy8OBBF1nufpSXl5P169eTgIAAIpFIyI033kgOHz486AL4xRdfJADI66+/PuRxLRYLSUpKInfddZcjzHYoo05cnnzySRISEjKqeuw4GpZlyauvvkrEYjG58soriUKhcLVJboFcLifPPfccCQ0NJV5eXuTee+8ltbW1rjbLpbAsS0pKSsiTTz5JkpOTCQASGxtLHnnkEXL06NFBH4alpaVkxowZRCwWk8cee4zef+TCg//nn38mS5cuJQBIVFQU+fvf/05aWlqGfN9rr71GAJD//d//teo8L7/8MvHx8SHd3d1CmO00RpW46PV6Eh4eTh599FFXm+I2aDQasnr1agKAPPPMM6OqmsRRtLe3kyeeeIIEBAQQX19f8sgjjwx7w491ysvLyXPPPUeysrIIABIeHk7uv/9+cuDAgSF/MyaTibzwwgvE09OT5OTkkKKiIida7Z50d3eT119/naSmphIAZObMmeTLL7+0qkjh3XffJQDIf/3Xf1l9PqlUSjw9Pckbb7xhj9lOZ1SJyxdffEEAkMrKSleb4hbU1dWRvLw84u/vT7799ltXm+NyGhsbyYYNG4iPjw8JDAwkTz/9NJFKpa42y2XU1dWRf/zjH2TSpEkEAAkKCiK33347+e2334jJZBr2/adOnSKTJk0iEomEPPvss5dUhddAnD17ltxzzz3E19eXeHp6krVr15Jjx45Z/f6PP/6YACCPP/74iPPFN998M8nIyBhV1YmjSlxmz55Nli5d6moz3ILdu3eTsLAwkpaWRkpLS11tjkuprq4m69atI56eniQsLIy88MILoy6EIBStra3krbfeIrNmzSIAiK+vL1m9ejX54YcfiF6vt+oY3OY9iURCJk2adEkXPZjNZvLdd9+RhQsXEgAkLi6OvPjiiyOuFvzss8+ISCQiGzZssKkQqaCggAAgf/zxx4jf6ypGjbgUFxcTAKNqh6ojYFmWvP7660QsFpNly5YRuVzuapNcRmlpKVmzZg0Ri8UkJiaGvP7665dk5VJXVxf56KOPyMKFC4lIJCJeXl7kmmuuIVu2bBnx9Th69CjJyckhnp6e5IUXXiBGo9FBVrs3nZ2d5KWXXiIJCQkEAJk3bx7Ztm2bVR5ff7Zs2ULEYjG55557bPY8WJYlkyZNItdcc41N73cFo0Zc1q1bRxITE4nZbHa1KS5Dq9WSm2++md8ZfqnmV06cOEGuvfZaAoAkJSWRDz74wOpV+VhBqVSSzz77jCxfvpxIJBIikUjIsmXLyMaNG20q6NBqteSxxx4jYrGYzJgx45L1hk+ePEluv/124u3tTXx8fMi6detISUmJzcfbvn07X6Fob0jr448/JmKxmDQ2Ntp1HGcxKsSlu7ub+Pr6Wl1dMRZpaGggU6ZMIb6+vmTr1q2uNsclHDp0iFxxxRUEAMnMzCQbN260aSU5WtFoNGTr1q3k2muvJV5eXkQkEpEFCxaQDz/80K7c0sGDB0lGRgbx9vYmr7322iW3gDMajeTrr78ms2fPJgBIcnIyefXVV4lMJrPruDt27CCenp5k9erVglxTtVpNgoKCyDPPPGP3sZzBqBCXt956i3h6eo7pXdFDsW/fPhIREUFSUlLI6dOnXW2OU2FZlvzxxx9k/vz5BADJzc0lW7duvWS8NoPBQH788Udy0003ET8/P7466c033yTNzc12HVutVpMNGzYQAGTu3LkXbZYc67S1tZHnnnuO3+Nz+eWXkx9//FGQ39auXbuIt7c3ufbaawVdAD300EMkKipqVBRXuL24MAxDMjMzyZo1a1xtitNhWZa8/fbbRCKRkMsvv9zuldRogmEY8sMPP5Dp06fzD9SffvppVFXL2IrZbCZ//PEHufPOO0lwcDABQPLy8sjLL78s2D6d3bt3k5SUFOLn50feeeedS0asWZYlhYWFZM2aNcTDw4P4+/uTv/zlL4JuOj5w4ADx9fUlf/rTnwQXgfLycgKAfP3114Ie1xG4vbjs2rWLACCHDx92tSlORafTkdtuu40AII899tglE6qwWCxk8+bNfOfYhQsXkt27d4/5Vj8Mw5CDBw+Sv/zlLyQiIoIP/f39738X9MGnVCrJ3XffzTfqvFQ2ler1erJp0yYydepUAoBkZGSQt956S/ANx4WFhcTf358sWbLEYXnAxYsXk7lz5zrk2ELi9uJy7bXXktzc3DH/cOlNU1MTmTZtGvHx8RkVKxQhMBqN5JNPPiEZGRkEALnyyitJQUGBq81yKCzLkmPHjpFHH32UxMfHEwAkMTGRPPHEE6S4uFjw3/yOHTtIfHw8CQwMJB9//PElcU81NjaSp59+mhfsK6+8kuzcudMhHvCJEydIUFAQWbBgAdFoNIIfn+O7774jANw+RO7W4tLU1ETEYjH56KOPXG2K0zh48CCJjIwkSUlJpLi42NXmOBydTkfee+89kpiYSACQ6667jpw8edLVZjkMlmXJmTNnyNNPP83v8I6OjiYPPvggKSwsdMhDTy6Xk7Vr1xIAZPny5aSpqUnwc7gTLMuS/fv388O4goKCyMMPP0yqqqocds7Tp0+T0NBQMnv2bKJSqRx2HkIuhE3j4uLIfffd59Dz2Itbi8uzzz5LAgMDL4m9CyzLkvfff5+f6NfZ2elqkxyKSqUir732GomOjiZisZjccsst5Ny5c642y2FUVlaSF154geTk5BAAJDQ0lNxzzz1k7969Ds13fP/99yQ6OpqEhISQzz77bEx7KxqNhnz88cckNzeXACA5OTnkww8/dPjzo6ysjERERJBp06Y5ra/f//zP/xB/f3+iVCqdcj5bcFtxMRqNJCoqimzYsMHVpjgcvV5P7rrrLgKAPPzww2O6vLa7u5s8//zzJDQ0lHh6epJ77rmH1NTUuNosh9DQ0EBee+01Ps4fEBBA1q5dS3bs2OHwzYlSqZTccMMNBAC55pprSFtbm0PP50r6D+O65pprLhr65igqKytJTEwMycvLc2rBTVtbG/Hw8CDvvvuu0845UtxWXLZs2UIAjPnW6C0tLWTmzJnE29ubfP755642x2F0dHSQJ598kgQGBhIfHx/y0EMPjcnwTHt7O3n33XfJnDlzCADi4+NDrr/+evLdd985ZZIgy7Lk66+/JuHh4SQiIoJs3bp1THorDMOQP/74g6xYsWLQYVyOpra2lsTHx5OcnByX9LC78cYbSXZ2ttt+v24rLvPmzSOLFi1ytRkOpaCggERHR5OEhIRROQzIGpqbm8lDDz3EN5N88sknx9x+JZlMRv7973+TxYsX86OQV6xYQb766iuHx99709raSq6++moCgKxevXpMhla5YVxcd2duGJezRwA0NjaSlJQUkpGR4TKv8MCBAwQA2bt3r0vOPxxuKS5nzpwhAMZ0p9+PPvqIeHp6kvnz54+5hy0hFyZi3n333cTT05OEhoaS//mf/xlTzSRVKhX58ssvyVVXXUU8PDyIWCwmS5YsIZ988onT+72xLEs2btxIgoODSUxMDNm+fbtTz+8MKioqyIYNG/hhXDfccAM5dOiQS1btra2tJCMjg6SkpLjU+2ZZlowfP56sWrXKZTYMhVuKy/3330/i4uLGZO7BYDCQe+65hx8RO9Y+47lz58gtt9xCxGIxiY6OJq+99ppTV++ORKfTkW+//ZasWrWK+Pj48Dvb33vvPdLe3u4SmxoaGsiyZcsIAHL77bePqUam3DAu7vNFRUWR//qv/3LpbB6pVEqys7NJQkICqaurc5kdHO+//z6RSCRuOa/I7cSlp6eH+Pv7k+eff97VpghOW1sbyc/PJ15eXuTTTz91tTmCUlxcTK677jp+r8b777/vlByDozEajeSXX34ht9xyCwkICCAAyLRp08g///lPlzYQZBiGfPjhhyQgIIAkJCSQnTt3uswWoeGGcaWlpREAZMaMGeSLL75wecsTmUxGcnNzSUxMjEPLmkdCT08PCQgIIM8995yrTbkItxOX9957j0gkEtLa2upqUwSlqKiIxMbGkri4OHL06FFXmyMYhw8fJsuXL+d3PX/66aejvk27xWIhe/bsIXfffTcJDQ0lAMj48ePJiy++6BYPlZqaGnLZZZcRAOS+++4jPT09rjZJEM6ePUvuvfde4ufnZ9MwLkeiUCjI1KlTSWRkpKAdE4TgL3/5C4mNjXW7KIjbiIvFYiEmk4lkZ2eT66+/3tXmjBiLxULMZvOAMeD//Oc/xMvLi8yZM8dl4RNrGOoz9IZlWbJr1y5+gNLEiRPJ5s2bXd6ixlr7B4JhGFJQUEA2bNhAoqOjCQCSlpZGnn32Wae1nx/OfovFQt566y3i6+tLUlNTyZ49e5xi10gY6Xcw0DCuF154wWV5yIHsV6lUZNasWSQsLIycOXPGJXYNxdmzZwkA8s033xBC7LsPhMQDLoQQgtLSUmzevBmnT59GV1cXKisrsWbNGuj1evj6+rrSvGHpb7/JZEJiYiKuvfZaLF++HBKJBI888gj+9a9/4f7778c777wDLy8vV5vdh+E+Q+/vgGVZ7NixAy+99BKOHz+O6dOn48cff8TVV18NsVjs9vYP9N5Tp05h69at2LZtG5qbmxEfH49bbrkFN910E6ZPnw6RSOQW9ldUVOCuu+7C0aNH8eCDD+Kll15CQECAQ22zFlu+A5lMhv/85z/417/+hebmZsybNw/btm3DypUr4enp6Tb2z58/H9dddx3Ky8uxb98+5OXlOdU2a8jNzcW8efPw2muvobi4eMT3gaMQEUKI088KwGKx4IMPPsCnn36KVatWYdasWfDy8oJUKsW3334LiUSCd999F7Gxsa4wb1gGs7+zsxPffPMNLBYLpFIpSkpK8MEHH+Cee+5xtckXMdxn4L6DqKgofPvtt3j55ZdRWlqKBQsW4Nlnn8XSpUsd/vAVwv7+v6GysjJs3boVW7duRU1NDSIjI3HDDTfgpptuwty5c50mlNbY/+abb+Lrr7/G888/j+TkZHz66aeYN2+eU+yzhpF+B8XFxXjvvfewdetWiEQi3HzzzdiwYQOmTJnidvZv27YNR48ehUqlwp49e5Cfn+8SG4fDYrFg3bp12L17N+677z6r7wOH4yqXadOmTfzEO4ZhyLp160hqaio5duwY0ev15JVXXiGrVq1yev26tQxn/z/+8Q/i7+/vtjXohFj3HcyYMYNvJnnFFVeQQ4cOudpsnpH8hmpqashLL73EtwYJDg4md911F9m1a5fLwnnW2B8REUFEIhH529/+5pYFEtZ8hpUrV5JNmzaR/Px8fnroK6+84hYjJKy5jy+77DK3fQ4R4r7PUpeIS2dnJ8nLyyMHDx4kLMsShmHINddcQzw8PPiHl9FoJGvXriVbtmxxhYlDYq39t9xyi1vaT4j1n2H16tVk+vTpbrfJ01r7b775Zr7qyN/fn9x8883k559/dnnlkbX233TTTW47gXUkvyEAZPHixeSHH35wm9kxo/05RIh7fwaX5FyKiooQGRmJ5ORk1NTUgGVZaDQaEELQ0tKC6upqiMVirF27Fhs3bsSNN97ospj+QFhr/6233uqW9gPWf4Y777wTGzduxNSpU11tch9G8hs6fPgwtmzZgj//+c/w8/NztekArLf/jjvuwMaNG8Gy7Kj9Dd1xxx3o6enBr7/+6lafYbQ/hwD3/gwuEZfq6mrk5OTgqaeewo4dOwAAer0eDMNg3bp1kEgkCAoKwubNmyGVSmE2m+Ht7e0KUwdktNsPjP7PMBL709LSsHLlylFrvztef2Bkn0Gv17vdZ7jUvgNnfwaXiIuXlxeMRiPi4+ORnZ0NAKipqYFSqURycjICAgIQEBAAkUgEg8EAhmFcYeagjMR+sVjs0qT3YIz2z0Dtdz0Mw8BgMIzKz0AIAcuyo9Z+g8EAqVSK9vZ29/0MTg3C/R8HDx4kM2fOJN3d3cRgMBC9Xk+uvvpq4uHhQfbu3UsMBgMxGAzk66+/Jj4+PiQpKYnccMMN5I033iBFRUUuj5dba/+WLVvI7bffThQKBdFqtcRkMrm89pzj4MGDZMaMGVZ9hpUrV5K2tja3ml+/a9cuq+2/88473ea6E3Khjcy2bdvI9OnTrbLfnYZCdXd3k6KiIrJp0yZyzz33kKlTp46az2AwGEhHRwepqKggx44dIx988MGo+Q40Gg2pra0lR44cIT/++CP5/PPPyeeff05efPFFt/0MLgkgTps2Db6+vvjhhx/g6ekJLy8vPg7I/W+NRoNPP/0Ub7/9Nh577DGIxWK89957WLFiBVJTU7FixQq8/PLL2LdvHzQajVva/5///Ae33norPDw8YDQaoVKpoFAooFKpXOqREUIQGRkJhmGG/Qwff/wx5s6di4KCAvz00084duwYWltbXWa7wWBAY2MjAgMDIRKJhrX/3//+NxYtWoSqqipIpVKYTCaX2M2yLORyOc6fP4+zZ88iLi4OHh4eVl3/BQsWQKFQgLhm1wDkcjmOHDmCjRs34qOPPkJBQQGCg4Nx3333ISAgwKr74JZbbnG63SzLQqFQoL6+HiUlJTh16hTq6+thNpsRFxeHVatWwd/ff1j7P/nkE6fb39PTg6qqKhQUFOD777/H999/j4KCAnR1dSEmJgYLFizA9ddfj0cffdRtP4NLwmL+/v74xz/+gbvvvhteXl5YtWoVMjIyMH36dAQEBKC5uRl/+9vfkJ+fj7vvvhsSiQQPPfQQGIZBeXk5jhw5gqKiInzxxRd48803IZFIkJubizlz5mD27NmYNWsWwsPDHWr/iy++iPvuuw/e3t647rrrBrX/sssug0QiAXAhjGAymWA2m6HVagEAYrEYXl5e8PT0hKenp8PdVoPBgKqqKuh0Ojz33HN4+umnh/wMc+fOxSOPPAKtVouWlha0tLSgqakJHh4eiI2NRUJCAmJiYuDh4difktFohFQqhVKphJeXF7KysvDWW2/hnnvuGdL+OXPm4Prrr4dKpYJSqYRcLoe/vz9CQkIQFBTklOvd2dmJrq4uWCwWBAUFISMjA6GhoXjzzTdx9913D2n/7NmzMX/+fHR0dEAulyMiIgLBwcEOt1smk6GiogIVFRXo6uqCl5cXMjIyMHfuXKSlpfEbHV955ZUhP8MTTzyBoKAghISEgBDicLu1Wi16enqgVCqhUqlACIG3tzdCQkKQnJyM4OBg/n4EwD+HBrP/8ccfx+zZszFnzhyH2UwIgUKhgFQqhVQqRWdnJwwGA0QiEcLDw5GcnIzo6GhERUUNmC8Z7jNwvyNHfoaBcNkmSgAoLCzEypUrMXHiRMyfPx/+/v6oq6tDcXExVq9ejQcffHDI5BMhBLW1tSgqKuL/NTc3AwCys7P5Czp79mzExcUJZjfLslCpVDh+/Dj+93//Fz4+PsjPzx+R/YQQmM1m/h/nCXh4ePBiI/QDu6urC3V1dfDy8sK4cePg7++PwsJCPP300yP6DGq1Gq2trWhuboZSqYREIuGFJjY2VlC7TSYTOjs7oVAo4OHhgaioKISFhfEPqZHYTwjhvUedTgeJRIKQkBCEhoYK2jmBWzF3dnZCpVLBw8MDkZGRiIqKgo+PT5/XWmu/0WiETCaDSqWCl5cXIiMjERQUJJjNANDZ2ckLilwuh7e3NzIzM5GdnY3U1NRBv9ehPsONN96I+fPno6amBrGxsZgzZ46gu8UtFguUSiX/z2w2QywWIzg4GMHBwQgJCRn2fIPZf+zYMYSEhODJJ5/E8uXLBbOZ82J7i4nZbIZEIkFERAQvJJGRkVZ3K+j9GWbPng1/f3/U19db/Sx1BC4VF41Gg/T0dNxyyy2IjIyEXq9HRkYGFi5ciKSkJJtWOS0tLTh69CiOHDmCo0ePoqqqCgCQnJyM/Px8/l9qaqpNxyeEQK1Wg2VZBAUFQavVoqioCMXFxXbZz7Is79WYzWZ+ldfbq7G1hJBhGNTV1UEmkyEqKgopKSl9Vm9qtdrmz6DRaNDa2oqWlhZ0d3dDLBYjJiYGCQkJiIuLs7mVh9lsRmdnJ7q7uyGRSHhRGega2GK/0WjkH0gMw8Df3x+hoaF8uM0W+nspgYGBiI6ORmho6JDf3UjsNxgM6Orqgkajgbe3NyIjIxEYGGiTvQDQ0dGBiooKVFZWoru7Gz4+Phg3bhyysrKQmpra53cyFMN9hvb2dhw5cgSEEOTn5yM+Pt4me7n7T6lUoqenhw+J+/n5ISQkBCEhIQgMDBzxvTKY/VVVVdi7dy/Wrl2LiRMn2mSzxWJBV1cXLyRdXV1gGAaenp6IiopCVFQUoqOjER4ebvX1HuoznDx5EocOHcLUqVNx33332fwstReXisvvv/+OW2+9FcePH0dqaqpDziGTyXD06FFecM6dOweWZREVFcV7Nfn5+cjJybHqB6nRaGA2mxEYGOjQUFBvr8ZisQAAJBJJH6/Gmh+MWq1GdXU1LBYL0tLSEBER4TCbdTodHzqTy+UQi8WIjo7mhcYa74C7EWUyGcRiMSIjIxEREeGw2nx7vRlCCLq7u/t4KREREYiKinJoPye9Xo+uri5otVr4+PggMjLS6l5j7e3tvIeiVCrh6+uLcePGITs7G8nJyXY94IbCYDCgqKgIra2tyM7OxpQpU6w6V++FQE9PDxiGgYeHBy8mwcHBDuvZRwjBli1bUF5ejr/85S9WRUCMRiMvJlKpFHK5nA/PRUdH855Jbw9caH755RfI5XLccccdDjm+NbhUXJ588kns3bsXJ0+edNo51Wo1jh8/zofRSkpKYDKZEBwcjFmzZvGCM2nSpItW3Xq9Hnq9HgEBAU5tQMmybB+xYVkWIpGI92g8PT0vukkJIbxHERAQgMzMTKe6xXq9nhcamUwGkUjUR2j628IwDC8qAHhRcdSDbiCMRiMUCgX/ABvKm+G8FJlMxi82hvKuHIVOp0NnZyff6DUqKuqijaKEELS1tfGColKp4Ofnh6ysLGRnZyMpKcmpNldUVODUqVMIDg7GvHnzEBwc3OfvLMvyeROlUsnnHwICAnhB8ff3d9pq3Gw246OPPoJGo8GGDRsu8hS574DzTBQKBYAL3hQnJtHR0Rd9Tkdy7tw5/Prrr3jwwQddtnHYpeIyY8YMLFq0CK+99pqrTIDBYMCpU6f4MNrx48eh0+ng6+uLGTNm8Hmb3NxcMAwDX19fl3drtlgsfcQG6FsYQAhBTU0NVCoVEhISkJCQ4NIafYPBwAtdV1cXACAqKorP0ajVanR1dYEQgvDwcERGRjq8QGAo+nsz3Co5ODgYWq0WnZ2d6OnpgUQi4XMprv5NaDQadHV1wWAwwN/fHxEREZDL5XzIS61Ww9/fH9nZ2cjOzkZiYqJLfxMKhQIFBQXQaDSYMWMG4uLieDHpn4jnii9c+ZtQqVR47733EBoaijVr1qC7u5v3TNRqNQAgKCiI90qio6Nd2rVaq9Xi/fffx9VXX43x48e7xAaXiUtDQwNmzJiBL774AldeeaUrTBgQs9mM0tJS3rM5evQolEolPDw8kJeXh3nz5mHOnDmYOXOm4AlVW+hfGCCTyVBfXw8vLy9kZ2cjPDzcpTdlfwwGA9ra2tDU1IS6ujr09PQgODgYWVlZyMvLsyt/4AiMRiM6OjpQX18PmUwGDw8PxMXFITU1FeHh4W7VDoRlWZSXl+PEiROoqqoCwzCIiYlBbm4usrOzER8f7zYbAS0WC2QyGQoKClBeXo7w8HDk5eUhPDycFxRXCzZw4f7q6emBVCpFaWkptmzZgpiYGMycORNhYWF9wlzuYG9vNm3ahMjISKxYscIl53eZuGzcuBHPPvssqqqq3O6B0huLxYLi4mKcPHkSJSUlKCoqglQqhUgkwoQJE/rkbSIjI11mJ8uyaGhoQHt7OwIDA5GYmAhyoTGpYIUBQtA7R6HT6WA0GmE0Gvm4dEREBO9tufJm5cpDOS9FJBLBx8eH9ww5byY0NNTp80d6w7IsGhsbUVFRwZeYBwUFITExEeHh4QgNDUVQUBAiIyNd2rqEEAKNRsN7J70T8VqtFlVVVQgICMCCBQsQFRXlUjvlcnmfMJfRaIRIJEJERASUSiUKCgqwcuVKLFmyxGV2WsOBAwdw7tw5rF+//tJK6N92221QKBT45ZdfXHF6q1GpVHxlmFgsBiEEjY2NfBjtyJEjaGhoAABkZGT0qUhLTEx0io06nQ5VVVUwGo1ISUlBdHQ0/zehCgPspffD2mQyITQ0FNHR0XzuymQyoa2tDS0tLZBKpWBZFuHh4bzQOCtubDQa+Yoes9mMgIAAREdH98mlcLkZpVIJlmX5XIA9lWYjgWGYPoKi1+sREhLCh7y4uR3cqpvLCwUHByMiIsJp+cLBEvFciXBISAhvi06n4zcJTpw4EXl5eU67ljKZjA9xcZV+XMiT80wiIiL4CMCuXbuwf/9+3HrrrS4LOVlDY2Mjtm7dijvvvNMlgu0ScTGbzRg3bhweeughPProo84+vdVotVoYjcZh470dHR199tqUl5cDAOLj45Gfn897N5mZmYLfMB0dHWhsbORLSIda7dtSGGAvvcMKRqMRwcHBiI6Ovmi/R2/MZjPa29vR0tKC9vZ2sCyLsLAwXmj8/f0Ft1GpVEIqlfK5FK7iayhR4/Y7KRQK6PV6h3ozDMOgvr4eFRUVqK6uhsFgQFhYGC8ovRcUg30+mUwGi8WCkJAQRERECG4jl4jv6emBQqEYcSKeEIJz587h7NmziIiIwNy5cwXPW3Al7pxnIpPJwLIsvLy8+FxJVFTUkCFPQgi+/vprVFVV4YEHHkBMTIygNgoFwzB45513MHfuXMyaNcvp53eJuBQVFeHPf/4zdu/ejcmTJzv79FZhMBig0+lsqgzr7u7G8ePHee/mzJkzYBgG4eHhyM/P54sEJkyYYPPD3Gw2o7a2FgqFArGxsTZV/AxXGGBvxwBOVAwGA5/sHGmoy2Kx9BEahmEQEhKCxMRExMfH2xVS5UpGuU1sAQEBwz5YBsNgMPCVZpw3ExoayjcNtAWLxYK6ujpUVFSgpqYGRqMR4eHhyMnJQXZ29ojDsJz3yD1QOZGxJyen0+kET8R3dXWhoKAAJpMJs2fPRnJyss32cVV9XIiru7sbhBD4+Pj0qeQKCQkZ0fdkMpnw0UcfQa/XY8OGDYIveITiu+++g8ViwU033eT0c7tEXF566SV88cUXKC8vd6uEKIfZbIZarRasMkyr1eLEiRN8GO3kyZMwmUwIDAzEzJkz+TDalClTrBKynp4efnYD10rEXoTsGKBWq9HR0cGXbcfExAgS1rJYLOjo6OCFxmKxIDg4mPdorCmw4FbxnZ2dfHcBa7wUaxnImwkNDUVISIhVngK3aOAExWw2IzIykvdQhNinxHUQkMvlvFdo7Qa+3jvie3p6YDKZIBaL+RYvQiXiTSYTjh07hsbGRqSnp2PGjBlW/f60Wi0vJJwnCoAPb3KeiRDFOEqlEu+//z4iIiJw9913u1XhDEdxcTH279+Phx9+2Om5QZeIy5IlS5Ceno6PP/7Y2aceFoZhoFKp4Onp6bBSQpPJxBcHFBUV4dixY/yO62nTpvFhtBkzZvRZERFC0NTUhLa2NgQHByMjI8Nh8XNbOgZoNBp0dHRAp9PB39/foeWYDMPwQtPW1sb37eKEpv+eAq6NTFdXF0wmE2+fIyu+rPVmTCYTLyi1tbUwm82Ijo5GdnY2srKyHNYnj2EYdHd3o7u7GwAQFhaGsLCwPiIzVCLenh3x1lJbW4sTJ07Az88P8+bNQ1hYWJ+/q1SqPm1UOPu48CsnJo7yLJqamvDxxx9jypQpWLVqldtU43F0d3fjP//5D66//nqkp6c79dxOFxe5XI6cnBy8++67LnHVhoLLD4hEIqc0NeSwWCw4f/48H0YrKiqCXC6HRCJBXl4e8vPzMX36dH51mZSUJGivNGsYqjCAK4HWarXw9fVFTEyMUysAGYZBZ2cnmpub0dbWxm9q5MJmXGJZIpEgPDzcoQ+bgRjIm/Hz84NMJkNtbS3q6upgsVgQGxvLC4oQ3qi1MAwDuVzOt+/x9/eHWCyGSqUaNhHvDFQqFQoKCqBQKJCWloaQkBDeM+HyOlxZMNdOZaicntCcOnUK33zzDa666irMnz/faee1ln/961/IzMx0enWb08Xl+++/x/3334/S0lK3S4T1rwxzFYQQVFdX82G0w4cPo7W1FSKRCDk5OZg3bx4fSnPFNeQKA1QqFVpbW6FSqeDj44P4+HiEh4c7pDBgJLa1tLSgtLSUr6QKDQ1FTk4OJk6c6ND2N8NhMBhw7tw5nDp1ClVVVbBYLEhOTsbkyZMxdepUp+7g7g2XiJfL5WhsbERnZyfEYjESEhKQlJSE0NBQp+6I720X1+Cxo6MDx48fR2NjI8LCwjB79mwkJSUhOjp6RA0eHcVvv/2GQ4cO4Y477kBWVpZLbenP77//jubmZtxzzz1OPa/TxeXBBx/EmTNncOjQIWeedlisrQxzJr0bTlosFrS2tuLYsWMoKipCTU0NACAlJYUXmjlz5iA5OdkpbeS5eLa3tzfCw8Ph7+/vsMIAa+C8Tq79hkQiQWhoKEQiERQKBVpbW2E0GuHn58eHzhzZ24lDr9ejqqoKFRUVaGhoAMuySEhIwLhx4xATE8NPc/T09OS9Amc8KIdKxPv5+cFsNkOj0fC90kaa8LYFbmNl77JgzmviKrkIIaioqIBYLMacOXOc7sEPBiEEX375JWpra7F+/XqX7tXpT2VlJX788Ufcf//9Tl3AOFVcCCHIzc3F9ddfj+eff95Zpx0WrjLM39/fbWZkD9dwsquriw+hHTlyBGVlZSCEICYmhheb2bNnIzs7WzAvrP9MlYGqbAYrDOhd7ix0S36u4ovLpXAVX/1zB11dXWhpaUFraysMBgN8fX15oQkPDxfs4cntO+IEBQASExP5kFf/PJRer+cT5CzLIjAwkM/NCIUtiXiTyQSZTIaenh54enoKPkuGy4Nx+RKZTMaLHCcm3B6j3ue0tQGmozEajfjXv/4Fk8mE9evXu00FmdFoxDvvvINly5Y5tTrXqeJy/vx5LFy4EN999x0WLlzorNMOCVcZ5uPj47IGb73hmgw2NzePqOFkT08PTpw4wedtSkpKYDabERISwncQyM/PR25u7ohXxsPNVBkKhmH6iI0QHQP6eylisZiv+LLmhuZ2YXONNfV6PXx8fHihiYiIGPEDVKPR8ILS1NQE4MKYh+zsbH52znBw4SlujwjnzYSGho5YkIVMxAs1S0av1/NiIpVKL2rwyAmKtQLWuwHm/Pnz3aIdk0KhwPvvv4/o6GisW7fOLUQPAL766iv4+/tj5cqVTjunU8Xl/fffx6uvvoqamhq38BC4yjAPDw+3aEFjMplQXV0NlUqF+Ph4u5oL6vV6FBcX8xVpJ06cgF6vh5+fH2bMmMGH0aZOnTpo8nMkM1WsZaDCAA8Pjz5ezWCfub+X4ufnh6ioKLu6J3PtaDih0el08Pb25oUmMjJyUHvUajUqKytRUVGB5uZmiMVipKSk8IJiT0muXq/nR2Jb682MZEe8LYx0loxGo+lTyaVSqQCAn3PDCYo9955CocDhw4eh0+kwffp0ZGRk2HwsoWhoaMB//vMfTJs2DStXrnSLCrLCwkKcOHECDz30kNPyyU4Vl1WrVsHT0xNbt2511ikHxVWVYYPR3d2N2tpaiMViZGZmCr4KM5vNOHv2LB9GO3bsGHp6euDl5YUpU6bwYbSZM2fCz8/PKTNVrO0Y0HtfCjf6NSoqyiFlzr2FRqvVwsvLC/Hx8UhISEBUVBQ0Gg3fabilpQVisRhpaWnIyspCZmam4P3QBvJmuH0zXEUXJyh6vR7AhYe3I1vTDzZLhts0y/3T6XQAgNDQ0D5hLqGvkcViwcmTJ1FTU4OkpCTMnj3bqdVsA3Hy5El89913+POf/+z08cID0dbWhi+//BK33HILEhISnHJOp4mLTqdDZmYmnnvuOdx7773OOOWQqNVqfhOeKyvDuIaTUqkUYWFhSE9Pd0pBAddBl+v8fOTIEXR2dgIA0tPTMWnSJMyfPx9XXHGF05KTvTsG6HQ6yGQydHd38xV8cXFxiIyMdFqoQaFQoKWlhe/h1dnZCYvFgtDQUOTl5WH8+PFOnZOj1+v5/mucF9A7zMWNBXDG74cQwl+b1tZWPrTs4+OD8PBwXkic2TCzqakJR48ehaenJ+bOnevypPqvv/6KgoIC3HXXXcjMzHSpLYQQvPvuu5g6darTyqWdJi579uzBmjVrUFhYiHHjxjnjlIPiLpVhOp2O7xPVv+GkM2FZFl1dXSgpKcHp06dRWVmJM2fO8LmDzMzMPj3SHLny4XIp3d3dYBiGTzhzq11HFQb0p7u7mw95dXR0wGw2IygoCL6+vvz/jYuLQ0JCAqKjox0meBaLpc/gLJPJxOetAMDb25sPmYWEhDjsmnB7YXqHubgGjwEBAXxomZvR46qO1lqtFoWFhejq6kJubi5yc3NdFpVgWRaff/45GhsbsX79epd2TQeAn376CT09Pbjtttuccj6nicuzzz6LX3/9FSUlJS4fXOUOlWG9G05mZma6pJiA20fAlXxyg7q4hH9bWxvv1Rw9ehQVFRUALlQ+cf3R8vPzkZ6ebtd3ajab+VyK0WiEr68v34mWe2gPVBggFov7iI29Hig3XKuiogKdnZ3w9PRERkYGsrOzkZ6ezl8XlUrFh856enrg4eGB2NhYJCYmIiYmxi6hGSoRz+VOeu/D4nIzXJsTTmjsrVTivpPeo3p7z33vXcnFfV5u6JvRaERAQAAiIyOdupmRo38DzHnz5rmscstoNOKDDz4AwzBYv369S4uGzp49i99++w0PP/ywU74Xp4nLnDlzMGvWLLz11lvOON2AuENlmMViQU1NDRQKBWJiYpCcnOz0sFzvmSpcmCc6OnrYKjK5XI5jx47xgnP27FmwLIuIiIg+e21ycnKsesD2rvjidllbm+AdrjDA2oq4rq4uXlBkMhm8vLyQmZmJ7OxspKamDnsctVrNCw3XBSA2NpZfwVvjSXCJeM5DsSURzzAMn5sxGo3w8vLi32utDb0rufo3eOQEhds7NBQqlYpvsxMUFISIiAiXLOSEbIBpD93d3Xj//fcRFxeHO++802UVZGq1Gh9++CGuueYaZGdnO/x8ThGXlpYWTJkyBRs3bsTVV1/t6NMNiDtUhjmi4eRIGG6mykjRaDQ4ceIEXyRw6tQpviHnrFmz+DDa5MmT+XNwK2JuJC83992e7rwjHSUglUr5pLxcLoe3tzfGjRuHrKwspKam2myHRqPhhYbbyBkTE8MLDSdUXDuYwRLxwcHBdnVT1ul0fKUZd9z+3oxOp+vT4FGpVAIA33ON+2drYYmrZ8lw9G6AmZGRgenTp7skFF5XV4dPPvkEs2bNwjXXXOP083N8+umniIuLc8r0X6eIy5dffonHH38clZWVCAkJcfTpLoKbiQ7AJZVhhBA0NzejtbXV4Q0nB4ObV2LtTBVbMBqNFzXk5CqKJk+ejJycHGRkZGD8+PGIi4uzuwx1MAYaJdDV1YW6ujrU1dVBpVLBz8+PF5SUlBTBV5NarZYXmu7ubpjNZvj7+8Pf3x++vr58BwNHJuJ7ezNyuRxqtRpGoxFarZYXNO63wHkmjpqV4+hZMsMxXANMZ3D8+HFs374d1157LWbPnu308wPAvn37UFFRgQceeMDh53KKuNx5552QSqXYuXOno081IK6sDDMYDKiuroZWq+VnkDgTIWaq2Iper0dhYSH279+PkpISlJWVQa1Ww8vLC5MmTeJDabNmzRJ80cFtRq2oqEBZWRkUCgW8vLyQlpaGzMxMpKWlwdvb22GFAb0T8R0dHWhtbYVMJoPRaERgYCBSU1ORnp6OuLg4wRcavYef9fZMdDodvLy8EB4ejuTkZGRkZDis4/JANgk9S2akcA0wlUolpkyZguzsbKcvNH/55RcUFRVh3bp1Tu9SDAD19fX45ptvsG7dOof32XO4uFgsFmRlZeH+++/HE0884chTDYhOp4PBYEBgYKDTV0tdXV2or6+Hp6cnMjMzHdZ+fiAcNVPFGlQqFV/x1TuX4u/vj+rqat6zOXLkCNrb2yESiTB+/Pg+nQRsqZwjhKC1tZXPoajVavj7+yMrKwvZ2dlITEy8qD2NUIUBgyXifX19+wzOMhqNaG1tRUtLC7q6uiASiRAVFYWEhATEx8fblJtgWRbd3d19Krm49i4RERG8Z8KVcSuVSigUCphMJnh5efGVZs7IBXC2ciXmI5klIwQMw+D06dMoLy9HXFwc5syZ49SiA5Zl8dlnn6G5uRnr1693eiNVi8WCt99+GwsXLsSMGTMcei6Hi8uJEyfwpz/9CTt37nT4h+kPFwJwdmVY74aTkZGRSE1NddrN48yZKr2xWCx8xZfBYOATwUOtTrn5NL332tTV1QEAUlNT+Wq0/Px8JCUlDbjK5EKOXA5Fo9EgICCAH66VkJAw5OrUnsIAk8nUZ0e8xWIZUSLeYDD0ERoAiIyM5IVmsIce1+CR80q4ue8eHh4XzX0f6nfXPzcTFBSE0NBQpyxCrJkl40ja2tpw5MgRAHB6A0y9Xo8PP/wQAPDAAw84vWx727ZtEIlEuPHGGx16HoeLy2uvvYZ///vfqKiocKoL7KrKMI1Gg+rqapjN5gEbTjoKnU6Hjo4OaDQap85U6e2lAOC9FFsTwZ2dnbxnU1RUhPPnz4MQgtjY2D5hNB8fH1RVVaGyshI6nQ5BQUF8Y8j4+Hibwh3DFQZIJBJotdoBE/GcoNiaiO/t0XR2doIQwgtNZGRkn1Yq3ARJrnkoly+xtTUPwzAu82b6z5LhRMYZ4WuDwYAjR46gra0NOTk5mDx5stPETSaT4YMPPkBiYiLuuOMOp4brjx8/jsOHD+Phhx926DPZ4eJy5ZVXIjY2Fhs3bnTkafrgisqw3g0n/f39kZmZ6RR3W6/XQyqV8jNVYmJiHN7Ar/fKmWv6yIVdhP6xKpVKHD9+HEeOHMG+fftQWloKs9kMHx8fpKWlIT8/H1dddRUWL14s+Lm5vIlcLucT4sCFPSfcniBHbFxUqVQ4e/YsysvLUVdXB7VajcDAQH6YWHJyMqKiohzSBl+r1UKhUPCf1VneDPebUiqVfDjPmrJne+Fa+JeUlCAkJATz5s1zWgPMmpoabNy4Efn5+U6tou3q6sLGjRtx4403IjU11WHncai4KJVKZGVl4Y033sDatWsddZo+uKIyzGQyoaamBj09PXY3nLSW/jNVuPb3jkStVvNeCiHEbi9lOBiGQUNDA99+xWAw8NVMXV1dKC0txcmTJ/n/PnPmTN67mTp1qk2h0IF2xIvFYgQGBvLVXh4eHoKOEuDmvnP/epcQc1VNJpOJb2IZFhbGN9Z01ObA/t6Mt7c3QkNDERwc7NDVPTfVVKlUOnWWTHd3NwoKCpzeALOoqAg//fQTrrvuOsycOdMp5wSADz/8ENnZ2Vi8eLHDzuFQcfn555+xbt06nD592mlVUlxlWFBQkFNcXIVCgZqaGojFYmRkZDh8GI/JZEJHR8eQM1WEZDAvxVHlpBaLBfX19aioqEB1dTWMRiPCw8P5HEr/flEmkwlnzpzpU/7MtYafOnUqLzYzZ84cMPfUOxHf09PDr9j7J+L7hy3s6RjAVfBxOROtVgsACAkJ6dMtuL+3YDab0d7ejpaWFnR0dIBhGISGhvJC46jcmiu8GUfPkhmI3g0wk5OTMWvWLKdsGfjpp59w7Ngx3H333UhLS3P4+QBg586daG9vx7p16xx2DoeKyyOPPIITJ06gsLDQUafogzMrw1iWRWNjIzo6OpzScNJsNvMzMEY6U8UW+nsp3IZLR3gpZrMZdXV1qKioQE1NDUwmEyIjI3lBGUneimEYviEnV5HGdXfOzc3FnDlzMH36dGRlZUEsFtuUiB/sMwxUGODh4QGNRsNXc3EFD727O3NiMhJPy2Kx8ELT3t4OhmEQEhLCC42j9g9x+2ac5c0INUtmJDQ2NuLo0aPw8vLCvHnzHN4TjGEYbNq0CW1tbdiwYYNT9uCUl5fj559/xgMPPOCw1IHDxIUQgsmTJ+Pqq6/G//7v/zriFH3gKsP8/Pwcnuvo3XAyOTnZoXPsHTFTZTD6eyncREBHzCg3mUyora1FRUUFamtrYTabERUVhZycHGRlZQm2/4IQgpqaGuzduxeFhYU4efIk2tvbAVyoSJs5cybmz5+PRYsWCeJdMwyDrq4utLa2or29He3t7TCbzfx3FxcXh/j4eMTExAi2GGEYBh0dHWhpaUFbWxvvuScmJiIhIcEhD2NnezMjnSVjL1qtFgUFBZDJZMjLy8PEiRMd6jXpdDp88MEHkEgkWL9+vcOrW/V6Pd59911ceeWVyMvLc8g5HCYulZWVmDdvHrZu3YrLL7/cEafgsVgsUKlU8Pb2dniDOmc1nORKex09UwX4/0OdenspUVFRgof4jEZjH0GxWCyIiYnhq7yEXLHpdDo+d8LlKrgd8TqdDufPn8fx48dRVFSEqqoqABcmR/bea5OWljbsA4X7nrh8iUwm69PgkRu5HBQUxFejAYBEIukTQhPqwcUwDKRSKS80ZrOZ71ackJAgeF6OG5+sUChgNpsd7s0MNkvGERBCUFpaitLSUkRGRmLu3LkOfb50dXXhgw8+QHJyMm6//XaHV5B98cUXCA4Odlg7GoeJy8cff4wXXngBNTU1Dq3j5oYpOboyzGKxoLa2Ft3d3Q5tOMmtfGUyGQDwoiL0jcowDO+lcNMXHeGlGAwG1NTUoKKiAnV1dWAYBnFxcbygCPWwGywRz7XsDw4OHnQhIJfLcfToUT6Mdu7cObAsi8jISL4/GteQk/MkuRCXXC7n57737sk1WKVT/02cQhYG9Idl2T5CYzKZEBAQwAuN0L3tuNwV580EBwcjNDTUIfe/TqfjPWyuP52jFnqdnZ0oKCiAxWLB7NmzkZSU5JDzAEB1dTU2btyI+fPn409/+pPDzgMAhw8fxqlTp/DQQw85xCtzmLisXr0aDMPgu+++c8ThAfz/yjBCiEOTfc5oOMmyLGQyGbq6ukAI4Utdhc7jaDSaPg9FR3gper0e1dXVqKioQH19PViWRUJCAi8oQoRpbE3EW4Narea9msLCQpw6dYofBZCcnIzMzExMnDgRM2fORHx8PD/33RacMUoAuPD76uzsREtLC1pbW2EymeDv788LjZBeY39vxsfHh/9OhF6QaTQavgmqv78/IiMjHSJmJpMJR48eRVNTk8MbYBYWFuKXX37BDTfcgGnTpjnkHMCFhsJff/01brvtNsTGxgp+fIeIi9FoREZGBp566imsX79e6MPzOLoyzBkNJ4ebqSIEA3kpkZGRiIqKEuw8Op0OVVVVqKioQGNjI1iWRVJSEj9PXgivcqAd8RKJpE/zR3tj1Wq1uk8ll1qt5iuXWltbUVNTg3PnzvGVczNmzOBHDUybNs2uBxshpE/TTXtGCQx3nq6uLr6xptFohJ+fXx+hEWqhptFo+NwM50k6wptx1iyZmpoanDx5En5+fpg/f75DFpqEEPzwww8oLi7Gvffe67BRASzL4t1338XMmTMdMorZIeJy4MAB3HDDDTh06BBycnKEPjwAx1eG9W84GRcXJ6hnZOtMlZHQ30sJCQnhvRQhPotWq0VVVRXKy8v5qZWcoGRlZdkdnx6sNX1AQAAvKPa0pufawvfuycXNfQ8LC+uz+733g8psNuPcuXN8RdrRo0ehUCjg6emJyZMn82G0mTNn2uUR9u4Y0HsC5WCjBGy9BjKZjBcabgxCfHw8EhISEBERIchvZSBvhsvNCOnNOGOWjEqlwuHDh9HT04OpU6c6ZDYKwzD49NNPIZVKsWHDBoeN5/jhhx+g0+lwyy23CH5sh4jLc889h+3bt+Ps2bMOCVWZTCZoNBqHVYbpdDqcO3fOYQ0nWZZFVVWVIDNVBqO6uhrd3d3w8vLicylCnuPo0aPYv38/RCIRUlJSeA9FqLi3UqlEZWVln0S8kK3pDQYDfvrpJxiNRojF4ovmvo/kWrEsi8rKSr4/WlFRETo6OiASifDII4/g2WeftdteYOBRAp6enoJVgxFCIJfLeaHhvLMrr7xS0BBQf28mOTlZUE+m/yyZmJgYwR/OvRtgpqenIz8/X9DjAxcWbx988AG8vLzw4IMPOiQ6c/r0aezatQsPP/yw4CJss7jU19f3+d/l5eXYvn07brjhBqSlpYFhmCGNtabtAMMwIITAYDDAy8uLv7jcim64izHcl2EwGAb879xqbqBGetyY5LCwsGGFzWg0Dvq3np4e+Pr6DvgQ42ZfDOcOGwwGEELQ3t4OX1/fPjcQl4MYamU/nP0KhYL//7nRsQqFAvn5+TAYDNBqtQgPDx/U27Lmhh7sO+BWugEBAYPa2dLSMuxOau46VFZWIjg4uE/ZeEtLCwICAhAYGDjob2W4cF7/+4CD+41KJJJBH8ybNm3CCy+8MOTxuYR/f7jCAAB9fkOEEBiNRv6aDXcPcN2bBzq+RqOBRqMZNB5fWVlpVU7AZDIN+N8tFgvUavWQm4BlMtmwTSUHOz4hBGq1Gr6+vhf9RuVyOfz8/GA0Gi/amNsf7jc0EAqFAmKxeFAPtaKiYtiGvXK5HMCF75obDzF//nyIxWLodDqoVKohtztYU7bf+17ujdFoRFdX15Cl8cePH8cVV1wx7Dn6Y7O4fP/995g8eTJSUlJw7NgxvPDCC/jnP/+J559/Hrfffjuuvvpqu70Wo9HIJ1L1ej38/PwgkUjAMAzEYrHTZ7MAwLFjx8CyrENWKsCFFTvLslZ5ZQaDAXV1dYiOjua9uYyMDMG8xYKCAvj6+iIgIABnz57lJyru2bMHt912m9MHnvWGEAKpVGrVHiOFQoGzZ8/yCV9XjbvtzZtvvolrrrlG8JkeSqWSD4E6ejd7d3f3sA9me89hMpkErwLjZvvo9XoEBwc7bMN1Z2cnPD09h11kcWHWU6dOYeLEifDx8cGxY8eQn5+P+Ph4lww24+D2MyUkJIz8zcRGduzYQR5++GFy5513kscff5yYTCZCCCEWi4U899xzZN26dcRisdh6eEIIIWazmbAsSwghhGVZolQqiVarJWq1mnR3d/N/cyZHjhwhp06dctjxz549a/VrOzo6iF6v5/93V1cXqaioIFKplCiVSruvf0tLC6muriYlJSVEpVLx/727u5t88sknRKlU2nV8e9BqtVZ9/wzDkC1bthCWZQnLsmTz5s0u+d30hmVZkpyc7JBjy+VywjAM0Wq1Djk+x969ex1+HauqqhxyjvLycsGPORBff/21Va/75ZdfyOHDh/vcywqFghw7doxs2rSJVFZWOsrEYfnwww9t/g5sFhdC/v8Dv//JWZYlx44dIytWrLDn8AOez2QyEZZlidlsJkajUdDjW8Pp06eJyWRyyLlZliU1NTUjen1/DAYDkcvlpLW1lZSVlTnsIdPT00M2bdpEOjs7HXL84Th58qRVr+svjGq1muzZs8du4bWHF198kdTW1jrk2AqFghByYQHgyM/47bffOuzYHGVlZQ45rrPEZdu2bVa9jmGYIf/25ptvumwh98orr9j8XrviSiKRaMDKI5FIxLfVqK6utucUFx2X283M9WxyBD09PQPGugkhyM7Ohqen56CxdntQqVQjaoE9UNjD29sbYWFhiIuLw7hx41BTU8PH5oUkKCgIa9euxZYtW0AcPyn7Iqz9THl5eX3yJgEBAcjIyMC+fftQVVXldNsJIdi4caNDGhQSQvjkfnBwMF/KPFpxxD4S8n8hQ0fT1dVl9SbIocL7YrEYGzZswL///e8hcz+Owp5r5dCkxRNPPIElS5Y47PgSiUTwhwPXEPDMmTMX/U0ul/N5hnHjxgl6XgBoamoSNI/k4eGBiRMnorS01CEPUQ8PD9x111345ptvBD/2QHR1dYFl2RG9Z6DrmZycjMsuuwwMw2D//v2QyWRobGwcNHkuJB999BEOHDjgkGPrdDp+wSEWix2WEyOEOGyLAQfDMEhJSRH8uGaz2aYR2iNl9+7dglWZenp64oEHHsA777zj1MWQSqXCrbfeavP7HSou3CjNnp4ehxw/KCiI3/sgFGfPnuUbJ/Z/kNXW1vI3rzPmxAgBV+rJtZMRmoCAAD7x6kjUajWMRiPKysrAMIzdSXlPT0/k5ORgypQpaG5uhslkws6dOwWydnD++7//22HtQ4xGY5/fpaN+o11dXRg/frxDjs3R0NDgEHFsampyygAyoW339/fHnXfeiZMnTwp63KH46quv7CqmcHi51WuvvYZFixY55NgikYgvxxUK7gZNSkrC+fPn+/xtpKvmkcCyrMPmeIeHh6O+vt5hq541a9Y4fNLo+fPn+cqZsrIywTpRh4aGYsqUKfzkUEeuDNvb2/HSSy8JcixXhCI5CgsLHf6AHqqM3x4cHSo0mUw4fPgwVqxYIfix4+Pj8f333wt+3MGwNwzncHERiUSYPXu2Q3IUwIXYslqthsFgGPHDv/8NSghBYmIigAt2OyLGSS4UUVz03+vr6x1acjhhwgRIpVKHHFssFiMzMxNtbW0OOT6XSxCJRIiLi0NWVpZDHm6XX345ysvLBT8ux8KFC3HPPfeM6D0D/VYIIdBqtTAajfzfCSEOnSek1+v5PJejwofk/9rfOPKzOFIUtVot9u7di6SkJIeN/Zg7d65Dw7ednZ04dOgQ9Ho9/yy0FadsFPnggw+wbNkyh6y2JBIJAgICIBaLoVarRyQwDQ0NfWxqb2/vM9MjKChIcJs7OjrQ3NzMe1yEEDAMA5PJ5NAfvr+/PxobGx12/MWLF2Pz5s02X6+hVpS1tbV8iw2RSOSwWRdisdhhYYeTJ0/i5ptvHvF3rNfrL7qm3KAuhmGg0WhgNBphMpkc2hV89+7d2LdvHwghDntwdnV18XNpHFHwwDCMQzsa79ixA5dffrlDckUcK1aswJdffumw43/xxRfIzMzEzp07sXr1aruO5RRxEYlE+O677/DEE0845Phc8jIoKGhE+Z2kpKQ+q/nGxsY+N39OTg6USiX/v+2tMrFYLGBZFjExMejs7ERTUxOam5vR2NiIzMxMu45tDTk5OYPu1LUXkUiE22+/HX/88ceI30v+b/d/V1fXgH+Ty+WjJsc1ECdOnMDTTz+N5557bsTv9fX1veg3rdVq4enpCV9fX/j7+/OdlR11jVpbWzF79mzMnz8fhYWFWLp0qUPOI5PJ+C7TQnsuhBDU19c7VBinTJni8I3FIpEIFRUVDjm20WjEjBkzEBsbi5UrV9rdbsZpW9wnTZqEoqIih+YtRCIRfH19rT6HRCIZMlwnFov5L5IQMmIB6L/qrKmpQVxcHLy8vPgpgXFxcUhJSXFoSIMjKCiIH4zlCCIjI1FTUzNi76WqqgrZ2dno6Oi46L1tbW2YOHGikGYOyYwZMwT1Vs1mM/7yl79g586dNj38OU9toNJrkUgEsVjMi4wjIITg6NGj/LyU6dOnO8Rz1Ol0SE5OhkgkEvwBTQhBS0uLYE04+8OyLPbs2eOUBSIAXH/99fw0VVswGAwDFkJ9/vnnWLBgAYChy6Otxan9U3bv3o3777/foefw9vYekffCJXGHq39vbGwcsZJzLeI5LBZLn2ozru+UM9vYpKSk8J1/HcG6deuwa9cuq1+vUqng6ekJHx8fTJgwAbW1tfzfjEYjuru7HT5dtDfZ2dk4ceKEYMe7+uqrsX//frtajPj4+PD5P0LIRSWuIpHI7ocmIQQKhYLvc8X9t9LSUsydO7ePLfacQ6VS9TkH998bGxtt/p7VavVFeQij0Qi1Wg1CCFpbWxEREWFX5IHLB3V1dfW5f1iWxd69e7Fs2TKnedfTpk3Dv/71rxEvggghaGtrw86dO/HJJ5/0+e+1tbWDDrizFaeKi5+fH37++WeHnkMkEo3ooufm5kIul0OhUCArK+uiv2dlZcFoNKK9vX3EFz44OBhtbW18AtYRceSREhUVhXPnzjns+L6+vjh16pTVryeE8BtHxWIxXzLNPdgmTJjgEDsHY6Rhh19++QVNTU19fnNc08qSkhKkp6fbnQsRiUQICgqCxWLhQ2JCwT3wS0pK0NzcjKKiIv6zVFZWAoAglXkMw6CjowNms5nvf0Z6tfu3p1LS09MTzc3N/Gqc/N8cJr1ezzd1tafrcmtrK06ePInDhw+jo6MDv/76K2//H3/8gUmTJlnVPFIoRCIR7r33Xmzfvt3q9xiNRuzduxenTp3Ctddei8mTJ0Or1YIQgu+//x7Nzc24/vrrhbWTOLmmcefOncjNzbW7EmEoOA/BWk+jqKgIXl5eA3Z4JYTg5MmTEIlEmD59+ohtMZlM6OzshFqtdvjGM2tpbGxEXFycwxr2lZWVITEx0aZW8NzsGZlMhqSkJIeNrh2KQ4cOIS8vD0ajcdgNd/v378fWrVv5nJO3tzfef/99vpv35s2bBVsNKhQKEEIErSo8c+YMTCYT0tPTERoayk9czMjIQGtrK2bMmGG3/dw8nsjISPj7+4NlWTQ2NiIoKAgsyw7YfXykMAyD9vZ2BAcHQ6lUIi4uDmKxGAzDQCKR2PUZ6uvr+cmmEokEcrkctbW1/CgIRybwh2LTpk248cYbrfL4CgsLERsbi9TUVH4B/v7772P69OkICAjAxIkTBfe8bBYXe8pa//GPf+Dtt98e9nX25Gd0Ot2wO2S5jX+tra1DJhF7enrg7+9/0d+Hiw1zcfKOjg5ERkaO+AYa7uFvz8bF1tbWYVvN2NNe59ChQ1a1vxjoM9TX1yMwMBARERHDvn+478DWEGBRURHCwsIwZcqUIV8nlUr5sM73338PmUyG9evXIzw8HD4+PsPesMOJV+97gGVZvku4tQwXclWr1Rf9rhsbG9HT04O8vLxhj2+NLRqNBl5eXn2uhVKphNlsRmRk5LDvH+4+4CoNudAewzBWHZdjuHznQL+h8vJysCxrlWc93AJJpVINe4yBIITg4MGD+POf/zzsa9Vq9UW/xfLycnR1dfF5lqGwpduAzeLS2to66N/MZjNYlh0y8de75HcwhpplwZVjDsVwD/PBNmpxo4fDw8OHvDmHO/9QD/+enh74+PgMeYzhHpxDbTRTqVQQi8VD/iiGs3+oH71Op+NXiINhjecy2GdgGAbd3d3DPiSG+wxarXbQ43d0dAw76nm4VeFQ94HRaBxyngsw/H0w1J4Gbk/IUPYPdw8MJb7ceOehvmNrPMvB+sBx81yGm0Y5nLgM1WduqLlJ1h5/sN8QAHR3d8PT03PI0Odwv6Heedn+WDPPxZpc0mD3stFohFQqHbZE25YohM0lSkPdFH//+9/x0UcfYcKECXj66adtTnYNdmOYTCYYDAZYLBZ+j4stDPZg0ul0aG1thV6vt6sCZKgftEwmQ3BwsF3x+KEerB0dHfDz87MrFjzYD8pgMGDLli0QiUS466677Kp0G+gzqNVqVFdXg2EYhIeH2xUv739jMwyDqqoqlJaWwmQyYf78+Xa1khnsPmBZFkuXLsWZM2dw5ZVX4qmnnrIpfzSUOBgMBhgMBvj4+MDPz8+me2wocejs7ERJSQlEIpFdc2cGe3hz4U9fX1+77oPBjs8wDLq6uhAbG2tXUchg7+3u7kZBQQFSUlLsmu80kDgQQnD8+HHs2LEDERER2LBhg12hw/73slarxdGjR1FSUgIvLy/cdtttgjf0dEhC/8UXX8SOHTsQHByMtWvXYvny5Thw4IBgJZ7cnhaWZdHT0yN4Xys/Pz9kZGTwyUZHEBgY6LCuzmazGTqdzq757YPBsix+/PFH6PV63HDDDYKWUHOJ2HPnzsHb2xt5eXmCjb/lRkv/8MMPOHnyJBISEnDttdc6bHCYWCzGrl278K9//Qvnz5/nd+cL2SXc398f/v7+MBqNg3bytoeUlBRkZGSgpKQEnZ2dgh4buHAfe3l5Oew+4DwOR1Qb6vV67N+/HyEhIZg5c6agx9bpdPj666/xww8/YOrUqXjggQcEG3FsMBhw8OBBfPzxxygtLcWcOXNw3333OaRTtEMT+oQQHDp0CP/4xz9QXFyM/Px8PPPMM5g9e7Zgx9dqtXyIzNbV22C0tLSgubkZ48aNE7waRKlUoqmpCTk5OYIn1mUyGWprazF16lTBj717926cOnUKN910k6APZqPRiOrqaqjVaiQmJiI+Pl6Q75IQgrq6Opw9exZqtRqpqamYNGmSYHPnrcFsNmPr1q345z//iY6ODtx444144oknBLt+DMPw3SmsmWA6EgghOHz4MBQKBS6//HLBOv1ytLe3Q6vVDjuu2tZj6/V6was0GYbBrl27oNfrceWVVwq2AAKAuro6bNu2DSaTCddff71g1ZJGoxEnT57EiRMnwLIspk+fjpkzZzpsUyngpGoxQgh2796Nl19+GWVlZVi0aBGefvrpYZOl1mI0GqHT6fgcg1AqD1zY4KdQKDBx4kRBV0DcvOyEhATBe4rV1tZCr9cLvvmwpKQEv//+O5YvXy7YdweAr77x8PBAZmamIG1MuCT7mTNn0NPTg8TEREyePHnYkbOOxGg04osvvsCbb74JhUKBtWvX4q9//asgDUsJIdDpdDAYDPDy8kJAQIBgCy2TyYR9+/YBuNB/TcgFi1qtRnNzMzIyMgTfPFldXY2goCDBW+wXFBSgubkZV1xxhWD3LrcRc//+/UhNTcXq1asFiTyYzWYUFxfj2LFjMJvNmDp1KmbPnu2UKkynliKzLItff/0Vr7zyCqqqqvhYtBDtu7k+SwzDCLp6Y1kWZWVlMJlMyMvLE/TGqqmpgaenp+ChmVOnTiEyMlLQcu/GxkZs3boVU6ZMwbJlywQ5JsuyqK+vR2dnJ8LDw5GWliZImK2lpQUlJSVQKBSIj4/H5MmTnboPYTj0ej0+/fRTvPPOO9Bqtbjrrrvw8MMPj6jCaTBMJhM0Gg1EIhECAgIE+72q1Wrs3bsX4eHhmDdvnmDCxbIsKisrERMTI6jwG41G1NXVISkpSdBF4blz53D69Gm7c3W96e7uxtatW9HS0oIlS5bgsssus3tjtcViwZkzZ1BUVAS9Xo9JkyYhPz/fof3n+uP0fS7ABSHYvn07Xn31VTQ2NuLaa6/F3/72N7vbJxBCoNfrYTAY4OnpKdjqzWQyobS0FN7e3hg/frxgO+qlUilkMhnGjx8v2M2q1Wpx7tw55OTkCBb6USgU+PzzzxEdHY3Vq1cL8vm1Wi2qq6thNBqRmpqKqKgou4/Z3t6OkpISyGQyREdHY8qUKYIc11Go1Wp89NFH+PDDD2GxWHDvvfdiw4YNdj9kWZaFRqOB2WyGr6+vYKtUqVSKw4cPIzMzE5MmTRLkmMCFBrISiUTQxVB3dzc6Ozsxbtw4we7X5uZmHDx4EHl5eVaVaVvDmTNnsH37dvj5+WHNmjV2N9ZkWRZnz57FkSNHoNFoMHHiRMydO9ch+dfhcIm4cHCx6Ndff71PLNreC2w2m/nVm7+/vyCrN41Gg7KyMoSHhwsWH9ZqtaitrUVGRoZgD4C2tja0trZi+vTpggiW0WjE559/DkIIbr/9dkE8wvb2djQ2NsLPzw+ZmZl2x6y5qiapVIqIiAhMmTIFsbGxdtvpLBQKBT744AN8/PHH8PDwwAMPPID777/f7lWmXq+HTqeDh4eHYOHimpoalJSUYPr06SMayT0UMpkMMplM0FEKTU1NACBYF2SFQoE//vgD8fHxmD9/vt3HM5lM+Omnn1BcXIxJkyZh5cqVdrfWKSsrQ2FhIZRKJcaPH4+5c+c6dIzHcLhUXDiMRiO+/PLLPrHoRx991K5YNMuy0Gq1MJvNfKmmvcjlclRVVSEpKcmqfTrDQQjB+fPnERERIVhcuLy8HGKxeMBWNiOFEIJvv/0Wra2tuP322+3+oZrNZtTU1ECpVCI2NhZJSUl2rSplMhlOnz6NtrY2hIWFYfLkyUhISLDLRlcik8nwzjvv4NNPP4W/vz8eeughrFu3zq7frsVigUajAcuy8Pf3F6Tp5KlTp1BfX48FCxYIEsrT6/Wor69HSkqKIPcpIQSVlZWIiooS5OGq1+vx22+/wcfHB8uWLbM7dNva2ootW7ZApVLhmmuuwdSpU20WVe6zFhQUQC6XIzMzE/Pnzxfke7EXtxAXDi4W/e6770Kr1eLOO++0OxZtMBj41Zu/v7/dq7fm5ma0tLQgKytLkB9uY2MjzGazIN4QwzAoLi5GcnKyIGK1d+9enDhxAqtXr7Z7lapUKlFTUwMAyMjIsKv0UaFQ4PTp02hubkZwcDAmT56MpKSkUd2Wvzft7e1488038eWXXyI0NBSPPvoo31rGFnoPF/P29oa/v79d14plWRw+fBhKpRJLliwRJKdRWVmJ0NBQQcKYWq0WTU1NSEtLs1tMGYbB7t27odVqceWVV9olflzl3R9//IGYmBisWbPGqi4Ug1FTU4PDhw+js7MTaWlpmD9/vmATWoXArcSFQ61W4+OPP+4Ti16/fr3NsWiu4R9XqmnvD46rIMvNzbV7pdXd3Y3W1laMHz/ebuFTKBSoqqrCpEmT7A5fnTlzBjt37sSyZcsG7LlmLSzLoqmpCe3t7QgJCUFGRobNYcqenh6cOXMGDQ0NCAwMxKRJk/heSWORxsZGvP7669i2bRtiYmLw+OOPY82aNTZfP6PRCK1Wy1dV2rMCN5lM2Lt3L8RiMRYvXmx36Lm1tRVGo1GQsmGpVAqVSiVIC/wjR46gsbERy5Yts6soRK1W45tvvkF1dTUWLFiAK664wub7vaGhAYcOHUJ7ezsSExOxYMECt/TY3VJcOBQKBT788MM+sej77rvPplg0V6ppNBrh5eVl1+qNZVmcO3cOFosFubm5dt1YJpMJFRUVSE5Otjvp1tDQAKVSicmTJ9t1nObmZmzevBmTJk3C8uXLbT6OXq9HdXU1P6vD1jyIWq3G2bNnUVdXBz8/P+Tl5SE9Pd2powpcSU1NDV599VX88MMPSE5OxpNPPolVq1bZ9HDiqiotFgv8/PzsynepVCrs27cPERERmDt3rl0ir1Qq0dbWhqysLLsXWXV1dfD19bU771ZWVoaSkhLMmzfPruaUlZWV+OabbyAWi3HjjTfaLHotLS04dOgQmpubERcXhwULFjhsE7AQuLW4cHCx6I0bN8Lf3x8PPvigzbFok8kErVbLl2raunozmUw4e/YsfHx87K4gq6yshL+/v92rjzNnziAoKMiuEJZSqcRnn32GyMhIrFmzxubP1dnZifr6enh7eyMzM9Om0IlOp8PZs2dRXV0NHx8f5ObmIjMzU9B9TKOJsrIyvPrqq9i5cycyMzPx1FNP4eqrr7bpO9LpdNDr9XxVpa3fc0dHBwoKCjBu3Di7KqgsFguqqqoQHx9v1yKLy+vFx8fbVS3Z0tKCAwcOIDc31+bKOIvFgt9++w2FhYXIzs7GDTfcYNN90N7ejsOHD6O+vh5RUVFYsGCBXe14nMWoEBeO9vZ2vPXWW31i0bfddtuIw1xcqabFYrFr1oNareYT8vZ82W1tbejp6bGrJb/RaMTp06cxbtw4m8OHJpMJX3zxBSwWC26//XabrovFYkFdXR3kcjmioqKQmpo64geXwWBAaWkpqqqq4OHhgYkTJyIrK8sp0zpHAyUlJXjllVewd+9eTJgwAc8884xN/fu4qkpuAJmtmxirq6tx+vRpzJgxw64Vfm1tLXx8fOwqllEqlWhvb8e4ceNsXoQolUr8/vvviI2NxYIFC2zyyDo7O7FlyxZ0dnbiT3/6E+bMmTPi43R1deHQoUOoqalBeHg45s+fj3Hjxo2aMPCoEheOpqYm/POf/8Q333yDmJgYPPbYYzbFovV6Pb968/f3t2n1JpPJUF1djeTkZJur21QqFRoaGpCVlWVzPqizsxMNDQ2YNm2aTTcVNzSoqakJt99+u03xZa7hpMViQXp6+oiPYTQaUVZWhoqKCohEIkyYMMEh7XHGCkePHsXLL7+MI0eOYOrUqXjmmWewcOHCET18CCHQaDQwmUx2NcA8efIkGhsbcdlll9mcm5BKpejp6cG4ceNsej9wIXdjNpttFjmDwYDff/8dnp6euOKKK0a8oCGE4MSJE/jll18QGhqKNWvWjDg8J5fLUVhYiPLycoSEhGDevHmC7oVzFqNSXDhqamrw2muv8bHov/3tbyOORZvNZn4im7+/v02rt6amJrS2tiI7O9smr4HrAhAbG2tz9UhVVRUsFovN3Q7279+PY8eO4YYbbhixF8aNkm1ubkZgYCAyMzNHJJJmsxnnz5/H+fPnQQhBTk4Oxo8f75BZ7WMNrn/fyy+/zPfve/bZZ0fcv4+rqhSLxQgMDBzxAoVlWRw6dAgqlQpLliyxKWSt1WrR2NiItLQ0mwtSqqqqEBoaalOFKcMw2Lt3L1QqFa688soRh7D0ej2+//57nDt3DjNnzsTVV189ooWRUqlEYWEhysrKEBgYiDlz5iA3N3fU5hZHtbhwnD9//qJY9IoVK6z+UoRogFlZWYmenh5MnDjRphurrq4OIpHIpnwJIQTFxcWIjY21KaRQWlqKHTt24PLLLx9xh1ej0YiamhqoVCokJCQgISHB6mtnsVhQUVGBsrIyWCwWZGVlYeLEiQ5tpjdW4fr3vfTSSygrK8PixYtH3L/P3gaY3ChdDw8PLF682KZVf0VFBaKiomzyfvR6PRoaGpCcnGzTPVhUVIT6+nosXbp0xOJUX1+PrVu3wmQyYdWqVSPq66dWq3HkyBGcPXsWvr6+mDNnDiZNmjTqc4tjQlw4uFj0vn37bJolY08DTIZhcO7cOTAMg7y8vBHfWF1dXZBKpZgwYcKIhY3L/djSXLOlpQWbN2/GxIkTrZoc2Ru5XI66ujqIxWJkZmZanUDtP1MlMzNTkLJuygUPYseOHRf177O2u669DTBVKhX27t2L6Oho5Ofnj/i33NTUBEKITVVQMpkMcrncprxEeXk5iouLMWfOnBGVQ7Msi71792Lfvn1ISUnBTTfdZHVBQv+ZKrNmzXJIJ3NXMabEhePYsWN9YtFPP/201bFoexpgGo1GlJaWwtfXd8QxUoPBgKqqKqSlpY24rXlLSwukUumId/qqVCps2rQJ4eHhWLNmjdViyrIsGhoaIJVKR9RwkmVZ1NTU4OzZs9Dr9UhPT0deXp7gbdwp/79/3yuvvILGxkasXLlyRP377GmA2d7ejoKCAuTk5Iy4M3d3dzekUimysrJGHA5qaGiAh4fHiKsuW1tbceDAAYwfP35Enp5CocDWrVvR3NyMyy+/HIsWLbLKZoPBgGPHjqG4uBhisRgzZ87EtGnTxlwYeEyKC2DfLBl7GmCq1WqUlZUhKipqxBvCzp8/j9DQ0BEnAM+dOwcfH58R7fI3mUz48ssvYTQacccdd1jtNdjScNIdZqpcqtgzS8aeBpiVlZU4e/YsZs2aNaL+XkajEbW1tUhKShrRosPW7so9PT34/fffER0dPaJiiLNnz2L79u3w9fW1eraRK2aquJIxKy4c9sySsbUBZldXF2pqapCSkjIioWhuboZerx9RtYzFYkFxcTHS0tKsjhMTQrB9+3Y0NDTgtttus/p9I2046Y4zVS5V7Jkl07sBZmBgoNUexYkTJ9DU1IRFixaNqFVSdXU1AgMDR9TKRK1Wo6WlZUQdIIxGI3777Td4eHjgiiuusOp9JpMJP//8M06ePIm8vDysXLly2PvAlTNVXMmYFxeO3rHo6upqq2fJ2NoAs7GxEW1tbcjJybG6j5Yt0ynlcjlqamowZcoUqyvdDh48iCNHjuCGG26wytsxm82ora2FQqGwuuFk/5kqkyZNsquPEkUYdDpdn/591s6SsVgsUKvVfFWlNSEclmVx8OBBaDQaXH755VbfO21tbXzY1Fo6Ojqg1Wqtfg+XK+np6cHy5cut8pJG2nDSHWaquJJLRlw4GIbB999/j9dee21Es2R6N8C0Zkcz161UpVIhNzfXqg2JFosF58+fR2JiotWr+7q6Omg0Gqt3R5eVleHnn3/GokWLrAoRjrTh5GibqXKpYsssGVsaYBqNRuzZswdeXl5YtGiRVbk5lUqFlpYWZGZmWr3IqqmpQUBAgNXezrFjx1BbW4slS5YM+/skhKCgoAC///67VQ0n3Wmmiiu55MSFw5ZZMlz7ckKIVQ0wuQoylmWRm5tr1Y1VXV0Nb29vq+PUJSUlCA8Pt+r1bW1t+OqrrzB+/HisWLFiyNcSQtDU1IS2tjarGk6O9pkqlyq2zJIZaQPMnp4e7Nu3DzExMZg9e/awgsQwDCorKxEbG2vVIstkMqG2thaJiYlWeSCVlZU4ceIE8vPzh/V0ejecnD9/PpYvXz5o4Uv/mSo5OTmYN2+eS2equJJLVlw4uFj0W2+9ZdUsmZE2wORamfj7+yMnJ2fYG6ujowPd3d1WbYbU6XQoLS1Fdnb2sKsitVqNTZs2ISQkBLfccsuQlWFc5Zo1DSd7z1QJDQ3FlClT3LJDK2Vourq6+vTvG26WzEgbYLa1taGwsBDjx4+3qiy6vr4enp6eVv2WRjJ1sr29Hfv27UN2dvaw3b4rKyvx7bffAgBWr149aHTDnWequJJLXlw4uFj0e++9Z9UsmZE0wFSpVDh//jyio6OH3STJTae0JmHe3t6OlpYWTJs2bcibymw246uvvoJOp8Mdd9wx5F6Yrq4u1NXVwcvLC+PGjRv0tWN9psqlSltbG95880189dVXfP++O+64Y9B83kgaYFZUVKC0tBSzZ88edqRxV1cX5HK5VdMpm5ubwbLssBVbKpUKv/32G6KionDZZZcNelyLxYLff/8dBQUFyMrKwg033DCoR9R/psq8efOox/5/UHHpR/9ZMvfddx8eeOCBAd3zkTTA7OzsRG1tLVJTU4eMC3OudVRU1LCxYK4H11BTJwkh+PHHH1FbW4vbbrtt0GNaLBbU19dDJpMhKioKKSkpA3o3l9pMlUuV3rNkYmNj8fjjj+Omm24aMDQ6kgaYx44dQ2trKxYtWjRkyMva6ZSEEFRVVSEiImLIXf0mkwm//fYbxGIxli9fPmiIt6urC1u2bIFUKh2y4eRomaniSqi4DMJIZslY2wCzoaEBHR0dyMnJGTKM1dDQAIZhhowHsyyL4uJiJCYmDilWhw8fRkFBAVatWjVoibM1DSc1Gg3OnDnDz8qYNGnSJTVT5VLF2lkyXFXlcA0wGYbBgQMHoNfrcfnllw+6IONEIywsbMjwEjd1MjU1ddD9IizLYt++feju7saVV1454D1MCMHJkyfx888/IyQkBGvWrBkwNN5/psr8+fPt6gQ9lqHiMgxcLHrTpk1DzpKxpgEm1ztJo9EgNzd30JtBLpejra0NEyZMGPThrVQqUVlZiby8vEFv0PLycvz4449YuHAh5syZM6A9ra2taGlpQUBAwIANJ3vPVPH29kZeXt4lPVPlUqWsrAyvvPIKfvvtN4wbNw5PPvnkgLNkrGmAaTAYsGfPHvj4+GDRokWD/pZaWlpgNpuHDCV3dnaip6dnyGrPEydOoKqqCkuWLBlw/Lder8f27dtRWlqKmTNnYsWKFRfdv6N1pooroeJiJW1tbXjrrbf4WPRf//pX3HbbbX1+hNY0wGQYBqWlpQCAiRMnDpir4aZTpqSkDLqLvbGxEd3d3YNuBu3o6MCXX36JrKws/PnPfx7wHNXV1YM2nKQzVSgDUVJSgn/84x/Yt28fJk6ciGeeeQZLly7t89uxpgGmUqnEvn37EBcXN2hJvDXTKbmBdIMV4FRVVeH48eOYPXv2gHu6GhoasHXrVhiNRlx33XXIzc3t8/euri4cPnwY1dXVo3Kmiiuh4jJCes+SiY2NxWOPPXZRLHq4BpjcgzsgIADZ2dkD/lArKioQGBg4aJfjs2fPIiAgYMAWMxqNBps2bUJQUBBuueWWiwShu7sbtbW1AzacpDNVKNZw9OhRvPTSSygqKsK0adPwzDPP9BmsZU0DzJaWFhQVFWHixIkDDsozm82orq5GQkLCgIssi8WC6upqxMXFDRhm7ujowN69e5GVlYXp06f3+RsXKtu7dy9SUlKwevXqPnu4xspMFVdCxcVGhpslw5Vqcqu3/uGmnp4elJeXIyYmZsCYbWtrK9RqNbKzsy/6m8lkQklJCTIzMy+qobdYLPjqq6+g0Whwxx139Kly6d1wMiwsDOnp6bzwmM1mlJeXo6ysjM5UoVgF17/vpZdewqlTpzBnzpyL+vcN1wDz/PnzKCsrQ35+/oAJ8draWvj6+g7omfT09KCtrQ2ZmZkXLaDUajV+++03hIeHY/HixX1EgWs42dTUhCVLlvRpONnT04OCggKUlZUhICAAc+fOHdUzVVwJFRc7OX/+/EWxaG6WTO8GmAPtiZFKpairq0NaWtpFsWBuOmV2dvZF8V9uPv20adMuuql++uknVFVV4dZbb+2T6O/dcDIlJYU/n8ViQWVlJc6dO0dnqlBsYrhZMsM1wDx69Cja2tqwePHiizpAdHR0QK1WD5hTaWtr4xuo9sZkMuH3338HACxfvrzP/VNaWorvv/8ePj4+WLNmDV++rFarUVRUhDNnzsDX1xf5+fmYNGkSDQPbARUXgeBi0fv378fEiRPx9NNP87Ho3nti+jfArK+vh1Qqxfjx4/u4/gzD4Pz584iLi7uoequ6uhomk+mizWhHjhzBwYMHsXLlyj4eT3t7O5qamuDr68vvn+k9U8VoNGLcuHF0pgrFLliWxS+//NKnf9/TTz/NbwgerAEmwzDYv38/DAYDlixZ0mdho9Fo0NTUhPT09Iu86KqqKoSEhPQpryeEYP/+/ZDJZH0qw0wmE3755RecOHGiT8PJ3jNVPD09MXv27DE1U8WVUHERGG6uOReLfvrpp7FgwQI+2c+t3rgKL0IIysvLodVqL6ogq62thUQi6RM246ZOxsTE9AkjVFZWYvv27Zg/fz7mzZsHYOCGkwD6zFRJS0vDpEmT6EwVimBw/fteffVVNDU14dprr8WTTz6JjIyMQRtg6vV67N27F76+vrjsssv48DLXSr//dEqDwYD6+vqLpk6ePHkSlZWVuPzyy3nPva2tDVu2bIFSqcQ111yDadOmwWg09pmpMmPGDEyfPp2GgQWEiosD6D3XvHcsetasWQM2wLRYLCgtLYVIJEJubi5/Y3V2dqKzs7PPdEqNRoOysjKMHz+eX5VJpVJ8+eWXyMjIwLXXXgvgQuy4uroaAJCeno6QkBDU19fjzJkzUKvVSElJweTJk+lMFYrD6D9LZvXq1Xj88ceRlJQ0YAPM7u5uHDhwAAkJCX3GbTc2NkIkEvXpnyeXyyGTyfpUbtXU1ODo0aOYOXMmxo0bB0IICgsL8dtvvyE6Ohpr1qxBUFBQn5kq06ZNw6xZs2gY2AFQcXEgg82Syc3N5Xc0c3ti9Ho9SktLERQUxLe80Ov1qK6uRnp6Ot+GpbW1Fe3t7Zg2bRpEIhG0Wi0+++wz+Pn5Ye3atfDw8OAbTgYHByM9PR0dHR04ffo0nalCcQlGoxGff/55n/59f/3rXxEeHn5RA8zm5mYcPXoUubm5fGhXLpejs7OzT2VlY2MjxGIx30ZGKpViz549yMzMxMyZM6HRaPDNN9+gqqoK8+fPx+LFi3H27FkcPXr0kpqp4kqouDiBwWbJJCUl9dkT09PTg4qKCsTGxvKJxvPnzyMsLIx38cvKyuDl5YXMzExYLBZs3rwZPT09uOOOO+Dp6Ynq6mpotVokJSWBZVk6U4XiNvSfJbNu3Tps2LABPj4+fRpglpWV4fz585g7dy7i4uL46ZTJycnw9/cHy7KoqqpCdHQ0QkNDodFo8NtvvyE0NBSLFy9GTU0NvvnmGwDAddddB71ef8nOVHElVFycSO9ZMlws+pFHHkFsbCxfqimTyVBfX4/09HRERUWhqakJRqORF5Pi4mJ+vPAvv/yCiooK3HLLLfD09OQbTgYGBqKqqorOVKG4Jf1nydx3332488474ePjw7dQOn78ODo6OrB48WIEBwejqqoKwcHBiI6OhkajQXNzM9LT0yESifD777+DZVksXboU+/fvx+HDh5GRkYHx48fj9OnTl/RMFVdCxcUF9J8lc8MNN+Avf/kLYmNj4efnh7a2NnR2dmL8+PFgGAbNzc0YP348VCoVqqurMWXKFJw6dQr79+/HihUr4OPjA5lMBrFYzMei6UwVirvTf5bMfffdh5tvvhmBgYHw9vZGYWEhTCYTlixZArlczk+n7OjogEajQXp6Og4cOIDOzk7MmDEDO3bs4Hv3abVa9PT0XPIzVVwJFRcX0n+WzOrVq3HPPfcgMTERjY2NMBgMyMnJwYkTJ3Ds2DE0NzcjICAA1157LQ4cOMB7JDKZDGq1Glqtls5UoYw6es+S8fPzw3333YebbroJPj4+KCoqQmBgIKZMmYKzZ8+iuLiY35U/a9YsfjhdQUEBzGYzIiMjwTAMnaniBlBxcQN6z5LRaDS45ZZbsG7dOvT09ODjjz/G559/DkIIJBIJLBYLRCIRli1bhocffhjt7e0ghCAiIoLOVKGManrPkgkODsb999+Pq666CiUlJdixYwe2bNkChmHg4eHB3wcLFy7kxyHHx8cjMzOTzlRxE6i4uBHcLJkPPvgAZrMZ8fHxOH78+KCvX7x4MdavX4/JkyfTmSqUMQM3S2br1q180r6goGDQ10+bNg1//etf6UwVN4OKixuiUCjw2muv4ZVXXhnydRKJBM3NzXSVRhmT1NTU4LnnnsPmzZuHfJ1EIkFra+uA7fQproN2Y3NDQkND+QqyoSCE8DO+KZSxRkZGBmbNmmXVfbBt2zYnWUWxFioubopUKh22aZ5EIoFUKnWSRRSK86H3weiFioubEh0dDYZhhnwNwzA0FEAZ09D7YPRCcy5uilQqRUJCAiwWy6Cv8fDwQEtLC72xKGMWeh+MXqjn4qZER0fjscceG/I1jz32GL2hKGMaeh+MXugkHDfm5ZdfBgC88cYbYFkWEokEDMNALBbjscce4/9OoYxl6H0wOqFhsVGAVCrFtm3bIJVKER0djdWrV9OVGuWSg94HowsqLhQKhUIRHJpzoVAoFIrgUHGhUCgUiuBQcaFQKBSK4FBxoVAoFIrgUHGhUCgUiuBQcaFQKBSK4FBxoVAoFIrgUHGhUCgUiuBQcaFQKBSK4FBxoVAoFIrgUHGhUCgUiuBQcaFQKBSK4FBxoVAoFIrgUHGhUCgUiuBQcaFQKBSK4FBxoVAoFIrgUHGhUCgUiuD8P6ypsferHEyEAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=[[],[2,3],[]], device=device)\n", - "model(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "b8992507", - "metadata": {}, - "source": [ - "Make a deeper network" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5da9e2b1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[2,2],[1,3],[3,2],[1,1]], mult_arity=2, device=device)\n", - "model(x)\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79f8150d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_3_KAN_Compiler-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_3_KAN_Compiler-checkpoint.ipynb deleted file mode 100644 index a328a235f..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_3_KAN_Compiler-checkpoint.ipynb +++ /dev/null @@ -1,324 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c982abca", - "metadata": {}, - "source": [ - "# Interpretability 3: KAN Compiler" - ] - }, - { - "cell_type": "markdown", - "id": "6b9ec6c4", - "metadata": {}, - "source": [ - "We have shown in many examples how to extract symbolic formulas from KANs. Now we want to consider the reverse task: compiling a symbolic formula into KANs. This might be needed for many reasons. One use case is that we have prior knowledge which is the approximate ground truth (empirical/constitutive laws etc.) and we want to build this knowledge into neural networks and only fine tune the network to real data." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d8f94f0f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan.compiler import kanpiler\n", - "from sympy import *\n", - "from kan.utils import create_dataset\n", - "import torch\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "input_variables = x,y = symbols('x y')\n", - "expr = exp(sin(pi*x)+y**2)\n", - "\n", - "model = kanpiler(input_variables, expr).to(device)\n", - "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,0]) + x[:,1]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.get_act(dataset)\n", - "\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "535c253f", - "metadata": {}, - "source": [ - "if you want more complicated formulas, you can load in an equation in the Feynman dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e9cf1b61", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan.feynman import get_feynman_dataset\n", - "import matplotlib.pyplot as plt\n", - "\n", - "problem_id = 36 # problem_id in 1-120\n", - "input_variables, expr, f, ranges = get_feynman_dataset(problem_id)\n", - "n_var = len(input_variables)\n", - "model = kanpiler(input_variables, expr)\n", - "\n", - "dataset = create_dataset(f, n_var=n_var, ranges=ranges)\n", - "model.get_act(dataset)\n", - "#model.plot(in_vars=input_variables, out_vars=[expr], beta=10000, title='P{}'.format(problem_id))\n", - "model.plot(in_vars=input_variables, out_vars=[symbols('omega')], beta=10000)\n", - "#plt.savefig('./fig1.pdf', bbox_inches='tight', dpi=200)" - ] - }, - { - "cell_type": "markdown", - "id": "d1db913e", - "metadata": {}, - "source": [ - "We can check that the model indeed achieves zero loss (near machine precision) on the data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "910c99a9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(1.5383e-15, grad_fn=)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "torch.mean((model(dataset['train_input'])-dataset['train_label'])**2)" - ] - }, - { - "cell_type": "markdown", - "id": "35c347d2", - "metadata": {}, - "source": [ - "Assume we have a dataset for which the symbolic formula is only an approximate ground truth, we want to train on the real data to fine tune the model. The current model has the symbolic front turned on and the spline front turned off. So only the affine parameters in the symbolic equations are trainable. Depending on how much expressive power you would like, you may need:\n", - "\n", - "* If you want to keep the symbolic functions, but just train the affine parameters, no need to do anything.\n", - "* If you want to the functions to be trainable, call model.perturb(). If you want only the currently active functions to be trainable while the currently dead functions to remain dead, use mode='minimal'. Otherwise if you want to allow the currently dead functions to be active, use mode = 'all' (by default).\n", - "* If you think the ground truth should be more complicated than the current network, you can expand it first using expand_width and/or expand_depth, and then use model.perturb().\n", - "\n", - "In the following, we present the most complicated case where you want to expand the network first." - ] - }, - { - "cell_type": "markdown", - "id": "63af424e", - "metadata": {}, - "source": [ - "step 1: expand depth, add an extra linear function in the end" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "381b8a03", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.expand_depth()\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "27a934fe", - "metadata": {}, - "source": [ - "step 2: add two addition nodes in layer 1." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5c5f92c9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.expand_width(1, 2)\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "3459fc85", - "metadata": {}, - "source": [ - "step 3: add two multiplication nodes in layer 2, with arity 2 and 3." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ec1bfb11", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.expand_width(2, 2, sum_bool=False, mult_arity=[2,3])\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "038ea175", - "metadata": {}, - "source": [ - "step 4: now we perturb all edges (mode='minimal' only perturb the currently active edges, mode='all' perturbs all neurons)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "45c8e738", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.perturb(mag=0.1, mode='all')\n", - "model.get_act(dataset)\n", - "model.plot(metric='forward_n')\n", - "# purple means both symbolic front (red) and spline front (black) are active" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "6feae91b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(beta=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eabf7aa3", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_4_feature_attribution-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_4_feature_attribution-checkpoint.ipynb deleted file mode 100644 index 5f0d764bc..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_4_feature_attribution-checkpoint.ipynb +++ /dev/null @@ -1,446 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f8ba3161", - "metadata": {}, - "source": [ - "# Interpretability 4: Feature attribution" - ] - }, - { - "cell_type": "markdown", - "id": "6535c1f2", - "metadata": {}, - "source": [ - "How to determine the importance of features? This is known as feature attribution. This notebook shows how to get feature scores in KANs." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1d88fa9d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 8.00e-03 | test_loss: 8.47e-03 | reg: 4.61e+00 | : 100%|█| 40/40 [00:07<00:00, 5.20it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "from sympy import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# let's construct a dataset\n", - "f = lambda x: x[:,0]**2 + 0.3*x[:,1] + 0.1*x[:,2]**3 + 0.0*x[:,3]\n", - "dataset = create_dataset(f, n_var=4, device=device)\n", - "\n", - "input_vars = [r'$x_'+str(i)+'$' for i in range(4)]\n", - "\n", - "model = KAN(width=[4,5,1], device=device)\n", - "model.fit(dataset, steps=40, lamb=0.001);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "36296de7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "8c782f62", - "metadata": {}, - "source": [ - "get feature score (for input variables)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2693a8c7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([0.8916, 0.5155, 0.1079, 0.0040], device='cuda:0',\n", - " grad_fn=)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.feature_score" - ] - }, - { - "cell_type": "markdown", - "id": "9fb3a0a8", - "metadata": {}, - "source": [ - "Inspect how hidden nodes depend on features" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2f80a6e4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([0.8915, 0.5146, 0.1079, 0.0040], device='cuda:0',\n", - " grad_fn=)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# the 2nd neuron (index start from 0) in the 1st layer\n", - "model.attribute(1,2)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2a297860", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([4.6616e-05, 8.2072e-04, 3.2453e-06, 1.3511e-05], device='cuda:0',\n", - " grad_fn=)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# the 3nd neuron (index start from 0) in the 1st layer\n", - "# note the y axis scale is really small\n", - "model.attribute(1,3)" - ] - }, - { - "cell_type": "markdown", - "id": "6182005a", - "metadata": {}, - "source": [ - "prune inputs" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "cac3ea5f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "keep: [True, True, True, False]\n", - "saving model version 0.2\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune_input()\n", - "model.plot(in_vars=input_vars)" - ] - }, - { - "cell_type": "markdown", - "id": "9e7eaa42", - "metadata": {}, - "source": [ - "Let's consider a high-dimensional case. In the case of many inputs but only few are important, the users may want to prune input otherwise too many inputs make interpretable hard." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6a5b6ccf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.20e-02 | test_loss: 5.46e-02 | reg: 1.71e+01 | : 100%|█| 50/50 [00:16<00:00, 3.12it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "# let's construct a dataset\n", - "n_var = 100\n", - "\n", - "def f(x):\n", - " y = 0\n", - " for i in range(n_var):\n", - " # exponential decay\n", - " y += x[:,[i]]**2*0.5**i\n", - " return y\n", - " \n", - "dataset = create_dataset(f, n_var=n_var, device=device)\n", - "\n", - "input_vars = [r'$x_{'+str(i)+'}$' for i in range(n_var)]\n", - "\n", - "model = KAN(width=[n_var,10,10,1], seed=2, device=device)\n", - "model.fit(dataset, steps=50, lamb=1e-3);" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "dd91e538", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "eefc4650", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "rewind to model version 0.1, renamed as 1.1\n" - ] - } - ], - "source": [ - "model = model.rewind('0.1')" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "3e42f8d6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'feature attribution score')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(np.arange(n_var)+1, model.feature_score.cpu().detach().numpy())\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.xlabel('rank of input features', fontsize=15)\n", - "plt.ylabel('feature attribution score', fontsize=15)" - ] - }, - { - "cell_type": "markdown", - "id": "7bf0deb1", - "metadata": {}, - "source": [ - "Since there are 100D inputs, it's very time consuming to plot the whole diagram and hard to read anything meaningful out of the diagram. So we want to prune the network first (including pruning hidden nodes and pruning inputs) and then plot it." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "9e0b3dad", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 1.2\n", - "keep: [True, True, True, True, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]\n", - "saving model version 1.3\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune()\n", - "model = model.prune_input(threshold=3e-2)\n", - "model.plot(in_vars=input_vars)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "42003070", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_5_test_symmetry-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_5_test_symmetry-checkpoint.ipynb deleted file mode 100644 index 6f4c0bde8..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_5_test_symmetry-checkpoint.ipynb +++ /dev/null @@ -1,403 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f8ba3161", - "metadata": {}, - "source": [ - "# Interprebility 5: Test symmetries" - ] - }, - { - "cell_type": "markdown", - "id": "6535c1f2", - "metadata": {}, - "source": [ - "Figuring out the symbolic formula represented by a model is ideal but sometimes too challenging. In this case, we might be content with simply figuring out some modular structures or symmetries. These hypothesis testing is partially inspired by AI Feynman." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1416f4c8", - "metadata": {}, - "outputs": [], - "source": [ - "from kan.hypothesis import *\n", - "import torch" - ] - }, - { - "cell_type": "markdown", - "id": "6ee16e29", - "metadata": {}, - "source": [ - "Case 1: detect separability.\n", - "* Additive separability: $f(x_1, x_2, ...) = g_1(x_1,x_2) + g_2(x_3) + g_3(x_4,x_5,x_6) + ...$\n", - "* Multiplicative separability: $f(x_1, x_2, ...) = g_1(x_1,x_2)g_2(x_3)g_3(x_4,x_5,x_6)...$\n", - "* General separability: $f(x_1, x_2, x_3, ...) = h(p(x_1,x_2)+q(x_3,\\cdots))$. (Note that general additive separability = general multiplicative separability)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "87f1e596", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "add separability detected\n" - ] - }, - { - "data": { - "text/plain": [ - "{'hessian': tensor([[0.0000, 0.3147, 0.0000, 0.0000, 0.0000, 0.0000],\n", - " [0.3147, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, 0.3619, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.3619, 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.3358],\n", - " [0.0000, 0.0000, 0.0000, 0.0000, 0.3358, 0.0000]]),\n", - " 'n_groups': 3,\n", - " 'labels': [2, 2, 1, 1, 0, 0],\n", - " 'groups': [[4, 5], [2, 3], [0, 1]]}" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = lambda x: x[:,[0]] * x[:,[1]] + x[:,[2]] * x[:,[3]] + x[:,[4]] * x[:,[5]]\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'add')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0b63eed4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mul separability detected\n" - ] - } - ], - "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'mul');" - ] - }, - { - "cell_type": "markdown", - "id": "3933b0dd", - "metadata": {}, - "source": [ - "We could also test separability by providing a group partition as an argument." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "96110a32", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(True)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "groups = [[0,1],[2,3],[4,5]]\n", - "test_separability(f, x, groups, 'mul')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e81778e9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(False)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_separability(f, x, [[0,1],[2,4],[3,5]], 'mul')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3c088092", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(False)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = lambda x: torch.sin((x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]]))\n", - "x = torch.rand(100,6) * 2 - 1\n", - "test_separability(f, x, [[0,1],[2,3],[4,5]], 'mul')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "b42e3b47", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(True)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_general_separability(f, x, [[0,1],[2,3],[4,5]])" - ] - }, - { - "cell_type": "markdown", - "id": "fbe1d482", - "metadata": {}, - "source": [ - "Case 2: test symmetry.\n", - "* Symmetry means the output $y$ is only dependent on a scalar function of a few variables, but otherwise does not gain more infomration from knowing the individual values of these variables. \n", - "* For example, we say a function has a symmetry $h(x_1, x_2)$ if $f(x_1,x_2,x_3,\\cdots)= g(h(x_1, x_2), x_3,\\cdots)$.\n", - "* To hypothesis test $h$, use test_symmetry_var" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "29640f8f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0,1]: tensor(True)\n", - "[0,2]: tensor(False)\n", - "[2,3]: tensor(True)\n" - ] - } - ], - "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "print('[0,1]:', test_symmetry(f, x, [0,1]))\n", - "print('[0,2]:', test_symmetry(f, x, [0,2]))\n", - "print('[2,3]:', test_symmetry(f, x, [2,3]))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "a392089f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100.0% data have more than 0.9 cosine similarity\n", - "suggesting symmetry\n" - ] - } - ], - "source": [ - "from sympy import *\n", - "\n", - "# the function is only dependent on b/c, but not on the individual values of b and c.\n", - "f = lambda x: x[:,[0]] * torch.sqrt(1 + (x[:,[1]]/x[:,[2]])**2)\n", - "input_vars = a, b, c = symbols('a b c')\n", - "symmetry_var = b/c\n", - "x = torch.rand(100,3) * 2 - 1\n", - "test_symmetry_var(f, x, input_vars, symmetry_var);" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b8212789", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20.0% data have more than 0.9 cosine similarity\n", - "not suggesting symmetry\n" - ] - } - ], - "source": [ - "not_symmetry_var = b * c\n", - "test_symmetry_var(f, x, input_vars, not_symmetry_var);" - ] - }, - { - "cell_type": "markdown", - "id": "8c782f62", - "metadata": {}, - "source": [ - "Case 3: Plot tree graph. By applying the hypothesis testing above iteratively, we are able to figure out the tree graph. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "42003070", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + ((x[:,[4]]**2 + x[:,[5]]**2) ** 2 + (x[:,[6]]**2 + x[:,[7]]**2) ** 2) ** 2\n", - "x = torch.rand(100,8) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8104aede", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGbCAYAAABZBpPkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkNklEQVR4nO3de3DU1f3/8dduLhuzS6UQkoBAGESMoCKl4GWoxRsqWosaKAoVkFutQ0VRRCyTKa3DgPU2tmoFqwMq1UK9IFJEWkbwgjdgCGUgWC7aaCCKYhLDbd+/P/xlv8FELsnZ7G7O8zGTmeWznz0577z3LK98Pp/dBMzMBAAAvBVM9AQAAEBiEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwXHqiJwAgccxM1dXVkqTs7GwFAoEEzwhAInBkAPBYdXW1IpGIIpFILBQA8A9hAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPBcuusBo9GoKioqJEnZ2dkKBAKuvwUAR6qqqhq8DSD5mJmqq6slSTk5OQoG3f0+HzAzczaapF27dikvL8/lkAAAoI7y8nLl5uY6G4/TBAAAeM75aYLs7OzY7fLycoXDYdffAoAjdQ87cloPSG5VVVWxI+91/691wXkYqPtiEg6HCQNAkotEIomeAoDj5Dq4c5oAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAaCHWrFmjQCCgQCCgmTNnNmqMAQMGKBAIaPv27cf8mFGjRikQCGjlypWN+p4AEo8wALQQ8+fPb/A2ABwNYQBoAQ4cOKDnnntOgUBA+fn52rRpkz788MNETwtAiiAMAC3A0qVLVVFRofPPP1/jx4+XxNEBAMeOMAC0ALX/8Y8YMUIjRoyQJC1YsECHDh1qcP/HH39cZ5xxhrKysnTSSSdp4sSJ+uqrr474PRYtWqR+/frphBNOUF5enm644QaVlZW5LQRAQqQnegIAmuarr77SK6+8olAopKKiIrVu3Vr9+vXTu+++q+XLl+uyyy47bP/bb79d9913n0KhkC688EJlZ2frmWee0ZtvvqlQKNTg9/jTn/6kiRMnKi0tTT/96U+Vk5Oj119/Xeecc4569erVHGUCiCOODAAp7vnnn1dNTY2uvPJKtW7dWpJiRweefvrpw/Z96623dN9996lNmzb64IMP9Oqrr2rhwoUqLS3VoUOH9M4779Qbf/v27br99tsVCoX0+uuva8WKFXruuee0detWFRYW6pVXXol7jQDiizAApLi6pwhqDRs2TOnp6XrhhRdUWVkZ2/7YY49JkiZPnqyePXvGtrdt21b33ntvg+P/9a9/1b59+3TDDTdowIABse3Z2dl6+OGHFQgEXJYDIAEIA0AK2759u1avXq02bdpo0KBBse3t2rXTpZdequrqar3wwgux7atXr5YkDR06tN5YAwcOVJs2beptP9JjTj31VPXu3bvJdQBILMIAkMKefvppmZmGDh2qzMzMw+6rPVJQ910FZWVlCgQC6tSpU4Pjde7cud622osEG7rvSNsBpA4uIARSWO01AStWrFD//v0Pu2/fvn2x+z799FO1b9++Ud/DzCSJ0wFAC8aRASBFvfvuu9q8ebMkqbS0VG+++eZhX++//74kKRqN6tlnn5UktW/fXmamjz/+uMExd+7cWW9bhw4dJEk7duw45scASC2EASBF1R7+v+OOO2RmDX699tprkv7vCELt0YO///3v9cZbvny5vvjii3rbj/SYLVu2aN26dU7qAZA4hAEgBR08eFDPPfecJOm666773v0uvPBC5ebmat26dSopKdGECRMkSffff782bdoU2++LL77QlClTGhxj9OjRyszM1Lx587Rq1arY9m+++Ua33HKLotGoi5IAJBBhAEhBS5cu1e7du496NX9aWpqKiookfXt0oH///po0aZIqKirUu3dvXXnllRoyZIhOOeUUSdI555xTb4yuXbtq1qxZqqmp0QUXXKCLL75Yw4YNU7du3VRSUqIrr7wyPkUCaDaEASAF1Z4iGDZs2FH3rT1y8Mwzzygajer+++/Xo48+qm7dumn58uV68803NXToUP373//+3k8gnDRpkp5//nmdddZZWr16tVasWKEBAwbonXfeUdu2bd0VBiAhAlZ7qbAjVVVVikQikqTKykqFw2GXwwMA4KV4/v/KkQEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8l+56QDOL3a6qqnI9POLMzFRdXS1Jys7OViAQSPCMALjC+k5tdf9Prft/rQvOw0DtE02S8vLyXA8PAID3qqurFYlEnI3HaQIAADwXMMfHGqLRqCoqKiRxGCoVVVVVxY7olJeXKxwOJ3hGAFxhfae2uqd5cnJyFAy6+33e+WmCYDCo3Nxc18MiAcLhMC8WQAvF+k5NLk8N1MVpAgAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPJfuesBoNKqKigpJUnZ2tgKBgOtvgTiqqqpq8DZSg5mpurpakpSTk6Ng0G3eZ32nNtZ3aovn+g6YmTkbTdKuXbuUl5fnckgAjVBeXq7c3FynY7K+geTgen1zmgAAAM85P02QnZ0du11eXq5wOOz6WyCO6h6G4jBw6qmqqor95l53LbrC+k5trO/UFs/17TwM1H1yhcNhXixSUCQSSfQU4EA8XuhZ36mP9d0yuF7fnCYAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxjwTHV1tR5++GENHDhQ7du3V2Zmplq1aqUePXpo9OjRWrx4saLRaL3HLV++XIMHD1Z+fr4yMzPVtm1b9ejRQ8OHD9ecOXO0f//+BFQDoC7WNxorYGbmcsCqqipFIhFJUmVlpcLhsMvh0QRvv/22ioqKVFZWpqysLPXr108dOnRQTU2NSktLtXHjRknSmWeeqfXr18ceV1xcrBkzZkiSTj/9dHXv3l1paWnavHmzNmzYIDPTp59+qvz8/ITUhf8T7/XH+k5erO+WL67rzxyrrKw0SSbJKisrXQ+PRlq7dq1lZWVZIBCwqVOn2t69e+vts23bNps4caJFIpHYtvfee88kWWZmpi1ZsqTeYz755BMrLi62L774Iq7zx7GJ9/pjfScn1rcf4rn+CAMeiEaj1rNnT5NkM2fOPOr+77//fuz2tGnTTJKNGDEinlOEI4QB/7C+/RHP9cc1Ax549dVXtXHjRhUUFGjKlClH3b9Pnz6x27t375YktWvXLm7zA9B4rG+4QBjwwNKlSyVJRUVFCgaPr+UdO3aUJC1atCj2wgEgebC+4QJhwAO1Fwv17t37uB87fPhwZWVlaefOnerWrZtGjhypuXPnauPGjTK3154CaATWN1xIT/QEEH8VFRWSpJycnAbvHzVqVL1tN910k84++2ydfPLJeumllzR69GiVlZVp3rx5mjdvniQpNzdXI0eO1LRp09S6det4TR/AEbC+4QJvLfRAYWGhNm/erGXLlmngwIH17g8EAvW2LViwQMOGDYv9e9++fXr55Ze1fPlyrVmzRiUlJbH3K3fr1k1vvfUW5x2TAG8t9A/r2x/xXH+cJvBA7W8Mtb9BfJd9+64SmZlGjhzZ4D6hUEhDhgzR448/rvXr1+uzzz7T7NmzlZ2dra1bt2ratGlxmz+A78f6hguEAQ/06tVLkvThhx86G7Ndu3a64447NGvWLEnSkiVLnI0N4NixvuECYcADl19+uSRp4cKFDX4UaVMMGDBA0vf/VgIgvljfcIEw4IFBgwbptNNO044dO2JJ/1gd7ZKSjz76SJLUoUOHRs8PQOOxvuECYcADwWBQ8+fPVygU0t1336277rpLX3/9db39duzYoS1bthy2bfr06ZoyZYq2bdtWb//S0lJNnjxZknTNNdfEZ/IAjoj1DRd4N4FHVq9eraKiIpWXlx/2h0y++eYbffLJJ1q7dq2i0ah69uyphQsXqrCwUJMmTdJDDz2kQCCgU089VaeddpoyMjK0c+dOvfvuu4pGo+rTp49WrFihE088MdEleo93E/iL9d3yxXP9EQY8U1VVpTlz5mjx4sUqKSnRnj17FAqF1LFjR/Xt21dDhgzRoEGDlJaWJunbc4VLly7VsmXLtH79epWVlWnv3r1q3bq1zjjjDBUVFWns2LHKzMxMcGWQCAO+Y323bIQBAMeEMAC0XHzOAAAAiBvCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOC5dNcDmlnsdlVVlevhm42Zqbq6WpKUnZ2tQCCQ4BkhnlpKv+uuubpr0RXWN1JRS+l3PNe38zBQ+wOXpLy8PNfDAzhG1dXVikQizsesxfoGEsf1+uY0AQAAnguY42MN0WhUFRUVklL/cEztbz7l5eUKh8MJnhHiqaX0u+7h0JycHAWDbvM+6xupqKX0O57r2/lpgmAwqNzcXNfDJlQ4HE7ZJw+OX6r32/WpgbpY30h1qd7veK1vThMAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOA5wgAAAJ4jDAAA4DnCAAAAniMMAADgOcIAAACeIwwAAOC5dNcDRqNRVVRUSJKys7MVCARcf4tmUVVV1eDtVGNmqq6uliTl5OQoGHSb/+h3cqHfx4Z+Hxv6nVzi2e+AmZmz0STt2rVLeXl5LoeEI+Xl5crNzXU6Jv1OXvTbL/TbL677zWkCAAA85/w0QXZ2dux2eXm5wuGw62/RLOoejkn1w2O1yb5ub1yh38mFfh8b+n1s6HdyiWe/nYeBuj/kcDicsk8eSYpEIomeglPxWAD0O3nR7yOj38c3Jv1OLq77zWkCAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc96Ggerqaj388MMaOHCg2rdvr8zMTLVq1Uo9evTQ6NGjtXjxYkWj0XqPW758uQYPHqz8/HxlZmaqbdu26tGjh4YPH645c+Zo//79CagGR0O//UK//UK/my5gZuZywKqqKkUiEUlSZWWlwuGwy+GdePvtt1VUVKSysjJlZWWpX79+6tChg2pqalRaWqqNGzdKks4880ytX78+9rji4mLNmDFDknT66aere/fuSktL0+bNm7VhwwaZmT799FPl5+cnpK6GxLsf9Jt+Jxv6nTrju0C/HTHHKisrTZJJssrKStfDN9natWstKyvLAoGATZ061fbu3Vtvn23bttnEiRMtEonEtr333nsmyTIzM23JkiX1HvPJJ59YcXGxffHFF3Gd//GKdz/oN/1OJvQ7tcZvKvrtjldhIBqNWs+ePU2SzZw586j7v//++7Hb06ZNM0k2YsSIeE7ROZ9fLOg3/T4S+p348ZuCfrvth1fXDLz66qvauHGjCgoKNGXKlKPu36dPn9jt3bt3S5LatWsXt/nBLfrtF/rtF/rtlldhYOnSpZKkoqIiBYPHV3rHjh0lSYsWLYo9kZDc6Ldf6Ldf6LdbXoWB2otHevfufdyPHT58uLKysrRz505169ZNI0eO1Ny5c7Vx40aZ22sw4Qj99gv99gv9dis90RNoThUVFZKknJycBu8fNWpUvW033XSTzj77bJ188sl66aWXNHr0aJWVlWnevHmaN2+eJCk3N1cjR47UtGnT1Lp163hNH8eJfvuFfvuFfjvm9AoES+4LTk499VSTZMuWLWvw/tp51/1asGDBYfvU1NTY888/b+PGjbMzzzzTgsFgbN9u3brZrl27mqOUY+bzBUb0m37XRb+Tb/ymoN9cQNhotQmyNlF+l3377gqZmUaOHNngPqFQSEOGDNHjjz+u9evX67PPPtPs2bOVnZ2trVu3atq0aXGbP44P/fYL/fYL/XbLqzDQq1cvSdKHH37obMx27drpjjvu0KxZsyRJS5YscTY2moZ++4V++4V+u+VVGLj88sslSQsXLmzwoymbYsCAAZK+P6Wi+dFvv9Bvv9Bvt7wKA4MGDdJpp52mHTt2xJLfsbKjXGH60UcfSZI6dOjQ6PnBLfrtF/rtF/rtlldhIBgMav78+QqFQrr77rt111136euvv663344dO7Rly5bDtk2fPl1TpkzRtm3b6u1fWlqqyZMnS5Kuueaa+Ewex41++4V++4V+O+b0ckRL7qtPa61atcry8vJMkmVlZdn5559vw4YNs5///OfWp0+f2BWlPXv2tE2bNpmZ2S233GKSLBAIWGFhoV199dU2dOhQO+ecc2L79+nTx7788ssEV3c4n682rkW/U2d8F+h36ozvAv12w8u/Wih9O885c+Zo8eLFKikp0Z49exQKhdSxY0f17dtXQ4YM0aBBg5SWlibp23NHS5cu1bJly7R+/XqVlZVp7969at26tc444wwVFRVp7NixyszMTHBlh+Ovmn2LfqfG+K7Q79QY3xX63XTehgFf8GLhF/rtF/rtl3j2w6trBgAAQH2EAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBzhAEAADxHGAAAwHOEAQAAPEcYAADAc4QBAAA8RxgAAMBz6a4HNLPY7aqqqiaPVV1dLUnKzs5WIBBo0nipwmXddXtQtzeu0O+mo9/0u7Hod/JLlX47DwO1RUtSXl6e6+HRBNXV1YpEIs7HrEW/kwv99gv99ovrfnOaAAAAzwXM8bGGaDSqiooKSW4OidSm0fLycoXDYSdzTHYu6657iConJ0fBoNv8R7+bjn7T78ai38kvVfrt/DRBMBhUbm6u62EVDoe9efLU5aJu14cO66LfbtFvv9BvvyRzvzlNAACA5wgDAAB4jjAAAIDnCAMAAHiOMAAAgOcIAwAAeI4wAACA5wgDAAB4jjAAAIDnCAMAAHiOMAAAgOcIAwAAeI4wAACA5wgDAAB4jjAAAIDnCAMAAHiOMAAAgOcIAwAAeI4wAACA5wJmZomexPcxM1VXV0uSsrOzFQgEEjyj5kHd1O0D6qZuH6RK3UkdBgAAQPxxmgAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPBcQsJAVVWV8vLyFAgE1LVrVx04cKDB/WpqatS/f38FAgGFQiGtXLmyeSfqGHVTd0Oom7pTGXW3kLotQR588EGTZJLs8ccfr3d/NBq1oqIik2SBQMAWLFiQgFm6R93UXRd1U3dLQN2pX3fCwkBNTY117tzZJFlBQYHt27fvsPtvvfXW2A/5j3/8Y4Jm6R51U3dd1E3dLQF1p37dCQsDZmZz586N/aAeffTR2Pa6aWvSpEkJnGF8UDd1m1E3dbcs1J3adSc0DBw8eNC6d+9ukqxTp062b98+W7RokQWDQZNkQ4YMsUOHDiVyinFB3dRN3dTd0lB3ated0DBgZva3v/0tlp7GjBljWVlZJsnOP/98q6mpSfT04oa6qZu6qbuloe7UrTvhYSAajdpZZ50V+0FKsp49e9qePXuO+Lj58+fb+PHjrU+fPpaZmWmS7Mknn2yWObvQmLo/+eQTe+CBB+ySSy6xTp06WUZGhuXl5dk111xj77zzTvNNvgkaU/eePXts4sSJds4551heXp5lZmZahw4d7IILLrCFCxdaNBptvgIaqbHP8++aNWtW7PFvv/12fCbrUGPrLigoOOwxdb8mTJjQPJNvgqb2+x//+IddfPHF1qZNG8vKyrIuXbrYsGHDbOfOnfGdeBM1pu4nn3zye3td+3XhhRc2XxGN0Nh+R6NRW7RokQ0YMMDy8/PthBNOsO7du9v48ePto48+ap7J/38JDwNmZn/+859jP8Dc3NxjesLXvljk5OTEbqdSGDA7/rrvvPNOk2Qnn3yy3XjjjTZ16lS79tprLS0tzYLBoD333HPNNPOmOd66S0tLLRwO20UXXWQTJkywu+66y8aMGWO5ubkmycaNG9dMM2+axjzP6/rPf/5joVDIwuFwyoQBs8av7xNPPNGKi4vrfS1evLgZZt10jak7Go3a+PHjY+v817/+td155532y1/+0jp37myrVq1qhpk3zfHWvXbt2gb7XFxcbD179jRJNmvWrGaafeM1pt+33XabSbL27dvbr371K5syZYpdeumlFggErFWrVrZhw4ZmmPm3Eh4GtmzZYjk5ObEfYjgctvLy8qM+bvny5bZ9+3YzM5s5c2bKhYHG1L1o0SJ744036m1/4403LCMjw9q0aZP0h6QaU/fBgwftwIED9bbv3bvXevToYZKspKQkXlN2orHP81oHDx60vn37Wr9+/WzEiBEpEwYaW3dBQYEVFBTEf4Jx0ti6H3roIZNkN998sx08eLDe/Q2tg2TS1Od5Xfv27bO2bdtaenq6ffbZZ45n6lZj6v70008tGAxaly5d7KuvvjrsvgceeMAk2ejRo+M57cMkNAyUl5db165dTZK1bds29oP8zW9+c1zjpFoYcFV3XQMHDjRJ9t577zmcqVvxqLv2rTsvvviiw5m65aLue+65xzIzM62kpMRGjhyZEmGgKXWnchhobN3V1dXWpk0b69q1a9L/p98Q1+u79jz84MGDHc/UrcbW/fbbb5skGz58eL37tmzZYpLsiiuuiNe060lYGKisrLQf//jHJskikYh98MEHNnjwYJNkoVDIduzYccxjpVIYcFl3XVdccYVJsrVr17qdsCPxqPubb76xXr16WSAQsC1btsRh1k3nou4NGzZYZmamzZgxw8wsJcJAU+suKCiw/Px8e+qpp+yee+6xRx55xNatW9dMs2+8ptT90ksvmSS77bbbrKamxhYtWmQzZ860Rx991EpLS5uxiuMXj/V9ySWXmCR75ZVX4jBjN5pSd0VFhWVmZlqXLl1s7969h91X+7bE++67L94lxCQkDBw4cMAuv/xyk2Tp6en26quvmpnZ+vXrLRAImCS78cYbj3m8VAkDruuutWPHDguFQpafn9/gocVEc1X3nj17rLi42KZPn24TJkywTp06mSQrLi6OcwWN46LuAwcOWJ8+faxXr162f/9+M0v+MOCi7u+7gPCyyy6z3bt3N0cZx62pdU+fPt0k2ZQpU+zUU089rO5gMGiTJ09urlKOSzxe17Zv327BYNBOOumkpHxNM3NT97333muS7KSTTrKbbrrJpkyZYpdffrllZGTY+PHjY2u+OSQkDIwZMyb2JJ8zZ85h99V+dGNaWppt3rz5mMZLlTDgum4zs/3799v5559vkmzevHmup+yEq7q3bdt22AtkRkaG3XvvvUn7bgIXdf/ud7+z9PR0++CDD2Lbkj0MuKp75cqVtnv3btu7d6+98847sRfec889Nyl73tS6J0yYENunb9++9u6779rXX39tb7zxhhUWFpoke+SRR5qjlOMSj9e14uJik2S//e1vXU/XGVd1P/PMMxaJRA57bTvvvPMavD4snpo9DNQ2WZJNnz693v0lJSWxD2sYOnToMY2ZCmEgHnUfOnQodjFZsl5RH4+6Dx48aNu2bbOZM2daZmamXX311Ul3jtVF3evWrbOMjAybOnXqYduTOQzEo9+1Dh06ZP3790/KQ8cu6h43bpxJshNOOMH+97//Nfj4k08+OS7zb6x4va517tzZAoGA/fe//3U9ZSdc1f373//eMjIy7J577rGPP/7YKisrbfXq1davXz9LS0uzRYsWxbOMwzRrGKj7sY0jR4783v2GDRtm0rd/2OFYzoEnexiIR93RaNRuvPFGk2QjRoxIyk+4ile/65o9e3bS/cbkqu5evXpZYWFhvXeIJGsYaI5+P/HEEybJ7rrrrqZN1iFXdd9+++0myX7yk580+Phu3bqZpOP+bIp4iVe///nPf5oku+iii9xN1iFXda9YscIk2a233lrvvl27dlkkErHOnTs7nPmRNVsYWLJkiaWnp5sku/jii494LmTTpk2WlpZmkmzQoEFHHTuZw0A86j506JCNHj3aJNl1112XlOfU4tnvutatW9eo3zLjxWXdDZ0zb+jrhRdeiGNFx6a5+l17kd0tt9zSxBm74bLuOXPmmCT72c9+1uDjay9UKysrczb/xopnv4cMGWKSkvIv/Lmsu/YzBl5++eUGH3/uueeapGa7RiZdzWTQoEHf+/eev6uwsFAHDx6M84yah+u6o9Goxo4dqyeffFK/+MUvNH/+fKWlpbmYqlPN1e+ysjJJUnp6sz2Vj8hl3WPGjGlw+xtvvKHS0lJdddVVateunbp06dKYqTrVXP1es2aNJCVFzZLbui+44AJJ0qZNm+rdd+DAAW3dulXhcFjt2rVr3GQdile/P//8c7300ktq06aNrr766qZMMS5c1r1//35J0u7duxu8v3Z7KBQ6zlk2UrNEjjhL5iMDLh06dMhGjRpl0rd//CLZzpPHy9q1a+3LL7+st/3zzz+PfQTo/PnzEzCzxEjW0wSubNy4scFD4atWrbKsrKwmvQU32dV+Xsh3L0ibMWNG7JRgS1b7YTtN+eyRVLFgwQKTvv3Y4u++vj311FMmyfr06dNs80mOX6caYe7cuVq9erUkacOGDbFtK1eulCQNHjxYgwcPTtDs4mPGjBl66qmnFIlE1L17d/3hD3+ot8/gwYN11llnNf/k4uipp57S3LlzdcEFF6igoEDhcFg7duzQkiVLVFlZqWuvvVbXX399oqcJR55//nnNnj1bF110kbp06aJQKKSSkhK99tprCgaDeuyxx9S5c+dETzMuHnnkEZ133nkaN26cXnzxRRUWFmrt2rX617/+pYKCAt17772JnmJcPfHEE5KksWPHJngm8TdkyBD95S9/0cqVK3XKKafoqquu0g9/+EOtX79ey5cvVygU0oMPPth8E2q22OFY7W9H3/eVrO89b4qj1awWenRk1apVNmrUKCssLLQf/OAHlp6ebrm5uXbZZZfZs88+m5RvM4unln5kYOXKlTZ06FDr1q2btWrVyjIyMqxjx442bNgwW7NmTaKnF3c7d+60UaNGWX5+vmVkZFinTp3s5ptvbvTH+qaKNWvWmCTr169foqfSbGpqamzWrFn2ox/9yLKzsy09Pd1OOukku/7665v17xKYmQXMzJovegAAgGQTTPQEAABAYhEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8BxhAAAAzxEGAADwHGEAAADPEQYAAPAcYQAAAM8RBgAA8Nz/A0Rn2hxPEaP7AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_tree(f, x, style='box')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a2136344", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + x[:,[4]]**2\n", - "x = torch.rand(100,5) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "8b0c7563", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_tree(f, x, style='box')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1333bed5", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_6_test_symmetry_NN-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_6_test_symmetry_NN-checkpoint.ipynb deleted file mode 100644 index 64edab6a5..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_6_test_symmetry_NN-checkpoint.ipynb +++ /dev/null @@ -1,134 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f8ba3161", - "metadata": {}, - "source": [ - "# Interprebility 6: Test symmetries of trained NN" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "87f1e596", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from kan import *\n", - "from kan.hypothesis import plot_tree\n", - "\n", - "f = lambda x: (x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2\n", - "x = torch.rand(100,4) * 2 - 1\n", - "plot_tree(f, x)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "58c2ece4-a8dc-4b4e-83cc-49a3f04c1ec5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.58e-03 | test_loss: 4.79e-03 | reg: 2.38e+01 | : 100%|█| 100/100 [00:20<00:00, 4.93" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "dataset = create_dataset(f, n_var=4, device=device)\n", - "model = KAN(width=[4,5,5,1], seed=0, device=device)\n", - "model.fit(dataset, steps=100);" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "c02037c9-c903-4fc8-96bf-c78609ce0696", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.tree(sym_th=1e-2, sep_th=5e-1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c2f31d6-be08-4bb8-a678-2c0d3f456722", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_8_adding_auxillary_variables-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_8_adding_auxillary_variables-checkpoint.ipynb deleted file mode 100644 index f8dc95b2e..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_8_adding_auxillary_variables-checkpoint.ipynb +++ /dev/null @@ -1,325 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "f8ba3161", - "metadata": {}, - "source": [ - "# Interpretability 8: Adding auxiliary variables" - ] - }, - { - "cell_type": "markdown", - "id": "6535c1f2", - "metadata": {}, - "source": [ - "When we do a regression task, it might be good to include auxiliary input variables, even though they might be dependent on other variables. For example, to regress $m(m_0, v, c)=m_0/\\sqrt{1-(v/c)^2}$, it is desirable to include the dimensionaless varabile $\\beta = v/c$ as a separate input variable. If we also know this is a task in relativity, we may also include $\\gamma=1/\\sqrt{1-(v/c)^2}$ because $\\gamma$ appears frequently in relativity." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "3b818211", - "metadata": {}, - "outputs": [], - "source": [ - "from kan.MultKAN import MultKAN\n", - "from sympy import *\n", - "from kan.utils import create_dataset, augment_input\n", - "import torch\n", - "\n", - "seed = 1\n", - "torch.manual_seed(seed)\n", - "torch.set_default_dtype(torch.float64)\n", - "\n", - "input_variables = m0, v, c = symbols('m0 v c')\n", - "\n", - "# define auxillary variables\n", - "beta = v/c\n", - "gamma = 1/sqrt(1-beta**2)\n", - "\n", - "aux_vars = (beta, gamma)\n", - "\n", - "f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2)\n", - "dataset = create_dataset(f, n_var=3, ranges=[[0,1],[0,0.9],[1.1,2]])\n", - "\n", - "# add auxillary variables\n", - "dataset = augment_input(input_variables, aux_vars, dataset)\n", - "input_variables = aux_vars + input_variables" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c386c245", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "model = MultKAN(width=[5,[0,1]], mult_arity=2, grid=3, k=3, seed=seed)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "59c8b0d0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model(dataset['train_input'])\n", - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2951afef", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.13e-04 | test_loss: 6.64e-04 | reg: 3.18e+00 | : 100%|█| 50/50 [00:07<00:00, 7.10it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=50, lamb=1e-5, lamb_coef=1.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "71656f49", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAIOCAYAAAA/cHtrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9hElEQVR4nO3deVxU5f4H8M+ZGTZBUMgF9w1zwx01c8mt3C2FuqGmll3NMnPPrllZmnnFbC+7lZloN8gU9zRF09RcUARExX0XUEGRZZbz+8M75zcDAwwwc84sn/frxUuHOTPzHeaZOfM5z/OcRxBFUQQREREREZENqZQugIiIiIiIXA+DBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhERERER2RyDBhGRG9m/fz8EQYAgCDhw4AByc3OxbNkydOnSBVWrVkXVqlXRq1cv/PHHH2a3O3nyJF577TU0bdoUPj4+qF69Ol544QVcv35doWdCRESOTqN0AUREJJ+jR48CAARBAAC0bt0aaWlpZtvEx8fjzz//xMaNG9G/f39ERUXhrbfeQkFBgbRNXl4efvrpJ+zfvx/Hjh2Dr6+vfE+CiIicAns0iIjciDFo+Pr6YtiwYfD09MSaNWtw9epVXLhwAe+//z4AQK/XY8GCBVi4cCFmzJiBZ599Fn/99RcyMjJw5MgRPPHEEwCAtLQ0REdHK/V0iIjIgQmiKIpKF0FERPJo164djh07BgDo1asXNm3aBB8fH7NtnnnmGaxbtw6CIEAURXz11VeYOHGi2TaZmZkIDg6GVqvFyy+/jOXLl8v1FIiIyEmwR4OIyE0UFBQgOTkZAFCzZk38/PPPRUIGALRv3x4AIIoixo0bVyRkAEBQUBDq1asHAMjPz7dj1URE5KwYNIiI3MSJEyeg1WoBAJMnT0b16tUtbnf37l0AD+dxvPvuu8XeX1ZWFgAgODi4yHV79+5Fv379EBAQgMqVK+OJJ57Ajh07KvYEiIjIqTBoEBG5CeP8DAD4xz/+Uex2iYmJAIAuXbpIvRaF3bx5ExkZGQCAFi1amF23bds2PPHEEzh06BAiIyPx0ksv4dSpU3jyySexdu3aij4NIiJyEjzrFBGRm0hISAAA1KlTB40aNSp2O2Mg6dmzZ6nbAP8/1Ap4ODxrwoQJ8PT0xL59+9CyZUsAwOzZs9G2bVtMmjQJ/fv3R6VKlSr0XIiIyPGxR4OIyE0Yw4FpMCjswoULuH37NgCgQ4cOpd6Xj48PmjdvLv1+x44duHjxIkaOHCmFDODh8KrJkyfj5s2b2LBhQ4WeBxEROQcGDSIiN6DX66UhUSUFiCNHjkj/tyZotG7dGmq1Wvr9nj17AAD9+vUrchvj73bv3l2GyomIyFkxaBARuYGTJ08iNzcXgHUBIjAwEA0bNix1u8L3ZVz8r0mTJkVuY/xd4QUCiYjINTFoEBG5geLmVBRm7NEoKYzcuXMHFy5csHhf2dnZAAB/f/8itzP+zni2KiIicm0MGkREbsAYNIKDgy2ejtbIOGHcml4PoGjQMK4BKwhCkdtZ+h0REbkuBg0iIjdQ3FAnU5cvX8atW7dK3c54X56enmjVqpXZdQEBAQAs91oYf2fchoiIXBuDBhGRixNFEcePHwdQ8rAp054Ka4JGq1at4OHhYXZdSfMwSpq/QURErodBg4jIxQmCgKysLIiiiPfee6/Y7YYNGwZRFCGKYokTwdesWQNRFM3OUGXUo0cPAMD27duLXGf8nXEbIiJybYJoHFBLRERUQQUFBQgJCUF6ejoOHTokraVx/fp1tG3bFgBw7tw5+Pr6KlglERHJgUGDiIhsauvWrRg8eDD8/Pzw/PPPw8vLC//9739x8+ZNxMbGYvjw4UqXSEREMmDQICIim9u7dy/effddHDx4EKIookOHDnj77bfRt29fpUsjIiKZMGgQEREREZHNcTI4ERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZnEbpAoiIXI0gCEqXQBXEJaaIiCqOPRpERERERGRz7NEgIrIxHg0nIiJijwYREREREdkBgwYREREREdkcgwYREREREdkcgwYRkZNLT0/Hf/7zH5w5c0bpUoiIiCScDE5E5OTWrFmDKVOmKF2GS+GEfiKiihNEfpoSETm1fv364fz580hLS1O6FCIiIgmHThERObHs7Gzs3r0bQ4cOVboUIiIiMwwaRERObMuWLdBqtRgyZIjSpRAREZlh0CAicmIbNmxA1apV0b17d6VLISIiMsOgQUTkpPR6PbZs2YIBAwZAo+G5PYiIyLEwaBAROak///wTt2/f5vwMIiJySAwaREROKi4uDh4eHujfv7/SpRARERXBoEFE5KQ2bNiAnj17IiAgQOlSHMrChQvRvn17+Pn5ITg4GOPGjUN6errSZRERuR0GDSIiJ3Ty5EmkpaVx2JQFe/fuxbRp03D48GGsX78eKSkpeO6555Qui4jI7XD2IBGRE4qLiwMAntbWgs2bN5tdXrZsGbp27YqsrCz2/hARyYg9GkRETmjDhg0IDQ1FgwYNlC7F4WVkZMDb2xu+vr5Kl0JE5FYYNIiInExGRgb279/PYVNWyM/Px/z58zFmzBieApiISGYMGkRETmbjxo0wGAwMGqXQ6/UYNWoUAGDJkiUKV0NE5H4YNIiInExcXByCg4MRFhamdCmymDVrFgRBwI4dOyxeP2XKFAiCgD179ki/MxgMGDt2LFJTU7Ft2zb4+fnJVS4REf0PgwYRkRPJz8/H9u3bMXjwYAiCoHQ5smjVqhUAICUlpch1Fy5cwNdff41BgwahR48eAABRFDF+/HgcOHAA27dvR2BgoKz1EhHRQxywSkTkRHbu3In79++71dmmQkNDATw8pW9h8+bNg06nw6JFi6TfTZw4ERs2bMCmTZsAADdu3AAAVKtWDWq1WoaKiYgIAARRFEWliyAiIuu88sorWLlyJTIyMuDj41Pq9ufOncPhw4dx6NAhHD58GEeOHMG9e/cAAD/88APGjh1r54orLi8vD35+fnj88cexe/du6fcnTpxA27ZtMXr0aKxYsUL6fXE9PefPn+dZuoiIZMQeDSIiJ7Jx40b07dvXqpABAI0bN7ZzRfbn7e2Nxo0bF+nRmDNnDjw8PDB//nyz3/P4GRGRY+AcDSIiJ3H06FFcuXKlXGebCgwMRL9+/fDss8/aoTL7Cw0NRXp6OjIyMgAAf/75JzZt2oTJkyejXr16CldHRESWMGgQETmJuLg4CIKAwYMHW32b//73vzh79iwyMzPx+++/45VXXrFjhfZjnBBu7NV48803UaVKFcyZM0fJsoiIqAQcOkVE5CTi4uLQuXNn1KhRw+rbOGsPRmGmZ566ffs2/vrrLyxatIhnlCIicmDs0SAicgJXr15FQkKC2y7SZzzzVFJSEt566y3Url0br7/+usJVERFRSdijQUTkBOLi4gDArU5ra6pJkybw9vbG999/jwcPHuA///mP1RPiiYhIGezRICJyAnFxcWjYsKE0hMjdqNVqNG/eHA8ePECLFi2c4rS8RETujkGDiEgmV65cQbdu3TB9+vQy3S4nJwe7du1y22FTRkePHoUoikhOTubCe0REToBBg4hIBtu3b0e7du2wb98+rF27tky33bZtG/Lz890+aBARkXNh0CAisiODwYD58+ejf//+0hoQFy5cQGJiotX3ERcXhypVqqBHjx72KrPMLly4AEEQKvRTs2ZNpZ8GERHZEYMGEZEdTZkyBZmZmfj8888REhIi/X79+vVW3d5gMGDz5s0YMGAANBqev4OIiJwH91pERHa0bNkyaT5BWFgYwsLCADzspXj77bdLvf3+/fuRnp7ucGebql27trR4XnkxOBERuTZ+yhMR2ZHppOWOHTuiZcuWSE5OxpEjR3D16lXUrl27xNvHxcVBo9FgwIAB9i61TDw8PNCsWTOlyyAiIgfGoVNERDIyTugWRVFaG6MkcXFx6NGjB6pUqWLnyhxTReeBlPRDRET2xaBBRCSjYcOGSf8vbZ5GWloaUlNT3fpsU6Io2u2HiIjsi0GDiEhGnTp1QnBwMABg165dyM7OLnZbY4+HOwcNIiJyXgwaREQyEgRBmthdUFCArVu3FrttXFwcWrVqhYYNG5b78c6ePYsDBw5IPykpKVZd58wWLlyI9u3bw8/PD8HBwRg3bhzS09OVLouIyO0IIvuPiYhktXnzZgwaNAgAEBkZiejo6CLb3LlzB9WrV8esWbOwYMGCcj/W2LFj8eOPP1q1bc+ePREfH1/ux3IUAwcORGRkJDp27Ijs7GxMnjwZvr6+2Llzp9KlERG5FZ51iohIZn369IGfnx/u37+PzZs3Q6fTFTnVq/H3jnZaW2ewefNms8vLli1D165dkZWVhYCAAIWqIiJyPxw6RUQkMy8vLzz11FMAgLt372LPnj1FtomLi0ONGjXQuXPnCj3WihUrrJ4c7Qq9GZZkZGTA29sbvr6+SpdCRORWGDSIiBRgOsG78NmntFottm7disGDB/M0rBWUn5+P+fPnY8yYMVwgkIhIZgwaREQKGDx4sLSYX+GgsXv3bmRnZ/NsUxWk1+sxatQoAMCSJUsUroaIyP0waBARKSAwMBDdunUDAFy8eBHHjx+XrouLi4OPjw/69eunVHkOSRRFREdHo2/fvggMDISPjw8effRRvPbaa7h9+7bZtgaDAWPHjkVqaiq2bdsGPz8/haomInJfDBpERAopbvG+DRs2oG/fvvDx8VGiLIeUn5+PoUOHYtSoUbh06RJGjx6NiRMnonbt2vjqq6/MhkWJoojx48fjwIED2L59OwIDAxWsnIjIffH0tkRECjl37hwaN24MAGjfvj2OHDmCxMREtGnTBsuXL8fLL7+scIWOY+TIkVi9ejXmzJmD9957Dx4eHtJ1J0+eRPPmzaXLEyZMwNq1a7Fp0ybUq1dP+n21atWk4WpERGR/DBpERAoKDQ1FUlISAODy5cv48ccf8fbbb+PatWuoWbOmwtU5ht9//x1PPfVUsWuOFFbcBPrz58+jQYMGNq6OiIiKw6FTREQKMh0+FRcXh7i4OISFhTFkmPj0008hCILVCxcWd/pehgwiInkxaBARKcj0zFLffPMNDh06xLNNmRBFETt37kSbNm0YFIiInAyDBhGRgsLCwlCrVi0AQGJiIkRRZNAwkZmZidzcXIYMIiInxKBBRKQgQRAwZMgQ6XKDBg0QGhqqYEWOxWAwAADS09MVroSIiMqKQYOISGGm8zTYm2GuevXqqFu3Lg4ePIgjR46YXafX63H27FmFKiMiotIwaBARKax3797SgnKmvRv00Pz586HT6fD4448jMjISs2fPxsiRI1G3bl2sXr1a6fKIiKgYPL0tEZEDiIiIwPbt25Genm62RgQ9tG7dOkRFReHYsWPQ6XQIDg5Gz5498dZbbyEkJETp8oiIyAIGDSIiB3Dp0iVkZmaiXbt2SpdCRERkEwwaRERERERkc5yjQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENsegQURERERENqdRugAiInJMBoMBN27cQGJiIo4fP47z58/jzp07MBgMCAgIQL169dC6dWu0adMGdevWhUbDXQoREf0/7hWIiMhMXl4e/vzzT6xYsQLx8fG4desW9Ho9AEAURWk7QRCgUqlQtWpVdOnSBS+88AL69++PypUrK1U6ERE5EEE03WsQEZHbEkURf//9N+bPn4+dO3ciPz9fChYajQa+vr7w8/ODWq1GXl4e7t+/j9zcXIiiCEEQoNFo0KFDB7z99tt48skn2cNBROTmGDSIiAh5eXn48ssvsXDhQty+fRuiKMLDwwOhoaEYNGgQunfvjkaNGqFy5cpQqVQoKChAeno6Tpw4ga1bt+KPP/7AjRs3IAgCKlWqhAkTJmDevHkICAhQ+qkREZFCGDSIiNzc/fv3MWfOHCxfvhxarRaCIKBTp06YNWsW+vbtCz8/PwAPh0oVJooiDAYDLl68iO+++w7Lly9HRkYG1Go1Bg8ejG+++QY1atSQ+ykREZEDYNAgInJjeXl5mDFjBr7++mvo9Xr4+vpi2rRpmDZtGgICAiyGi+IYDAYkJCTgjTfewL59+wAAgwYNwo8//ojAwEB7PQUiInJQPL0tEZGbEkURX3zxBZYvXw69Xo8qVargyy+/xLx58+Dv74+bN2/CYDBYdT+pqam4ffs22rdvj9jYWDzzzDMAgM2bN2Pu3LkoKCiw99MhIiIHw6BBROSmDh48iIULF0Kr1cLHxwdLly7FqFGjoFKpsHHjRvTq1Qvr168vMWwYJ5APGTIE48aNQ3p6OqpXr45vvvkGTz75JAwGA3744QesXbtWxmdGRESOgEGDiMgN5eXl4b333sOdO3cgCAImTpyIUaNGAQA2bdqE8ePHIzU1FS+//HKxYcMYMkaOHIm0tDRs2rQJL730EtLT0xEUFITPPvsMjRo1Ql5eHj744APcunVL7qdJREQKYtAgInJD8fHxiI+PhyiKaNGiBWbPng21Wm0WFgAgMzPTYtgQRRGHDh3CyJEjcfbsWel3prdv0qQJ5s6dC41Gg5MnT+Lnn39W5LkSEZEyGDSIiNyMXq/HDz/8gPz8fKhUKkyePBnVq1fH9evXMX36dClkGBUOG8aejMjISClkGImiiB07dmD37t0AgPDwcLRv3x4GgwErV65ETk6ObM+TiIiUxaBBRORmrl+/jj179kAURdSpUwfDhg2DIAgIDg7Gu+++iypVqhS5jTFsrFu3DgcPHjTryTDl5eWFefPmSffp5+eH0aNHQxAEJCcn48SJEzI8QyIicgRctpWIyM0cO3YMGRkZAIAePXqgevXqAACVSoV//OMfEAQBkyZNwt27d81ul5mZiZdeegne3t64ceNGkfv18vLCO++8g+nTp8PT0xPAw7U3+vXrh4CAANy9exd79+5Fly5d7PsEiYjIIbBHg4jIzRw7dgx6vR4A8Pjjj5utlaFSqfDcc8/hiy++sNizcffuXatDhlHdunXRsGFDAEBCQgK4fBMRkXtg0CAicjPnz58HAGg0GjRt2rTIonzGno0vvvgCAQEBpd5fSSEDALy9vaWgcenSJeh0Ohs8CyIicnQMGkREbkQURdy+fRuiKEKj0aBq1aoWtzOGjS+//BKVK1cu9v48PDwwb968YkMG8HD41COPPAIAuHPnDoMGEZGbYNAgInIzxqFLgiAU6c0wJQgCGjZsiEqVKhW7jYeHB0JCQqDRlDzlT6V6uLuxZqVxIiJyDQwaRERuxt/fHwCg0+lw7949i9sYT2E7atQo3Lx5s9j7evDgAV555ZUSVxAXRVGaWO7n5we1Wl2xJ0BERE6BQYOIyI0IgoC6detCEATodDqcP3++yORs0xW/z507V+p9Freon5FWq8XFixcBPJwYXlrvBxERuQYGDSIiN1OzZk0ADwPFwYMHza6ztOK3KQ8PD3h7exf5fUlh4+bNm9J9hYaGSsOoiIjItfGwEhGRGzh37hxiYmIQExODI0eOSL+Pj49HVlYWqlSpYtaTUdJifHXq1MGUKVMsrrPx8ssvAwCGDRsGlUoFURSxb98+ad2ONWvWoFKlSggPD0ejRo3s94SJiEhxgsgTmhMRuaS0tDTExsYiJiYGR48etbiNh4cHfvnlFwwbNgwnT57EsGHDkJaWVmQ701PYajQa/Pzzz3j11VeLhA0ACAoKwvfff48hQ4agoKAAzzzzDLZs2VJku/bt2yMiIgIRERFo3LhxhZ8vERE5FvZfExG5kDNnzmDhwoVo164dQkJCMGfOnCIhw/gFX6PRQKvV4pNPPkFOTg4CAwPRoEGDIvdZeJ0M01PfWlrULy8vD+np6QCA3bt3Iz4+HgBQo0YNs+2OHj2KOXPmoEmTJmjXrh0WLlyIM2fO2OTvQEREymOPBhGRkzt16pQ0LCoxMdHiNh06dEBERATCw8PRuHFj3L17F3369EFCQgLUajWWLl2KV199FTdu3MCYMWOwY8cOACUvxmcwGIr0bFSqVAmLFy/GhAkTcPfuXQwZMgQHDhxAUFCQNB/E2MtiOoTLVJs2baRaH330URv9lYiISG4MGkRETujkyZPSF/YTJ05Y3CYsLEz6wm5cmdvU2rVrMWrUKOTm5uKRRx5BbGwsevTogevXr2PMmDHYu3cv3nnnHUybNq3YxfgMBgP++9//YtKkSdBqtfjoo48wYcIE6HQ6TJs2DV9//TUAYNGiRZg5c6bZuh3nzp3Dr7/+ipiYGBw6dMji/YeGhkrDq5o1a1bWPxMRESmIQYOIyEmkpKRIPRfJyckWt+ncuTMiIiIwYsQIi8OgTGm1WkyZMgXffPMNDAYDGjVqhFWrVqFLly64fv06du/ejREjRhQbMowMBgNiYmKQnZ2NcePGQavVYsGCBVi8eDG0Wi369OmDtWvXSut3WHLhwgUpOP39998Wt2nZsqUUOlq0aFFiTUREpDwGDSIiByWKIpKTk6VwcfLkSYvbdenSReq5qFevXpkeIzMzE5GRkdi+fTtEUUSdOnXw8ccfY9iwYdBoNCWuHF64VlEUkZ6ejrlz52LFihXQ6XQICQnB5s2b0aRJE6trunjxotTTceDAAYvbtGjRQnrOLVu2tLpOIiKSD4MGEZEDEUURJ06ckI7up6amWtyua9euUs9F3bp1K/SYV69exdixY7Fz504YDAb4+Phg5MiRmDZtGpo2bQqVSlXiF3lRFPHgwQNs2bIFCxYswPHjxyGKIkJCQhAbG4vWrVuXu7bLly9LoeOvv/6yuE2zZs2kno5WrVoxdBAROQgGDSIihYmiiMTERKnn4vTp00W2EQQBjz/+OMLDwzFixAjUqVPHpjWkp6dj5syZWLNmDQoKCgAA1apVw8CBAzF8+HC0bdsWjzzyCDw8PCAIAgwGAx48eIBLly5h165d+O9//4sjR46goKAAgiDgiSeewPLly8vUk1GaK1euSKFj3759Frd59NFHER4ejoiICLRu3Zqhg4hIQQwaREQKEEURx44dQ0xMDGJjYy2e1lUQBHTr1k3quahVq5Zda8rPz8eaNWuwcOFCnD17VlrhW61Wo2rVqqhVqxaCgoKg0WiQk5ODmzdv4saNG8jJyZHuIzAwEDNnzsSkSZNKnJNRUVevXsXatWsRExODvXv3wtKuLCQkRBpe1bZtW4YOIiKZMWgQEclEFEUcPXpUGhZlafVtQRDQo0cPREREYPjw4QgODpa9zmvXrmHVqlWIjo5Gamqq1MNRHJVKhTp16uD555/HSy+9hCZNmsj6pf7atWtYu3YtYmNjsWfPHouho0mTJlJPR7t27Rg6iIhkwKBBRGRHoijiyJEjUs/FuXPnimyjUqnQs2dPhIeHY/jw4ahZs6YClRaVnZ2NhIQE/Pnnn0hISMCVK1dw9+5dGAwGVK5cGbVr10ZoaCi6d++OsLAwBAUFKf4F/saNG1JPx549e6ReGVONGjWSQkeHDh0Ur5mIyFUxaBAR2Zgoijh06JAULi5cuFBkG5VKhSeeeAIRERF45plniqya7WhEUURBQQF0Oh2Ah8OpjKuEO6qbN2/it99+Q0xMDOLj4y2GjoYNGyI8PBzh4eEICwtj6CAisiEGDSIiGxBFEX///bcULi5evFhkG7VajV69eiE8PBzPPPMMqlevrkCl7unWrVtS6Ni1a5fF0FG/fn2pp6NTp04MHUREFcSgQURUTgaDAQcPHpTCxeXLl4tso1ar0bt3b0RERODpp59GtWrVFKiUTKWnp2PdunWIiYnBzp07odfri2xTr149qaejc+fODt1zQ0TkqBg0iIjKwGAwYP/+/YiNjUVsbCyuXLlSZBuNRoM+ffpI4SIoKEiBSskaGRkZWLduHWJjY/HHH39IQ8NM1alTR+rp6NKlC0MHEZGVGDSIiEphMBjw119/ISYmBr/++iuuXr1aZBuNRoN+/fohPDwcTz/9NAIDAxWolCoiMzMT69evR0xMDHbs2GExdNSuXRsjRoxAREQEunbtytBBRFQCBg0iIgv0ej327dsnhYvr168X2cbDwwP9+vVDREQEhg0bhqpVqypQKdnDnTt3pNCxfft2aLXaItvUqlXLLHSo1WoFKiUiclwMGkRE/6PX67F3714pXNy4caPINp6ennjyyScRERGBoUOHokqVKvIXSrK6c+cO4uLiEBsbi99//93iuiI1a9aUQke3bt0YOoiIwKBBRG5Or9djz549iImJwdq1a3Hz5s0i23h6eqJ///4IDw/H0KFDERAQoECl5AiysrIQFxeHmJgYbNu2zWLoqFGjBoYPH46IiAj06NGDoYOI3BaDBhG5HZ1Oh927dyMmJga//fYbbt26VWQbLy8v9O/fHxERERgyZAj8/f0VqJQcWVZWFjZu3IiYmBhs3boV+fn5RbapXr26WejQaDQKVEpEpAwGDSJyCzqdDvHx8VK4SE9PL7KNt7c3BgwYgIiICAwaNIjhgqyWnZ2NjRs3IjY2Flu2bEFeXl6RbapVq4ZnnnkGEREReOKJJxg6iMjlMWgQkcvSarXYtWuXFC4yMzOLbOPj44OBAwciPDwcgwYNQuXKlRWolFzJvXv3sGnTJsTExGDz5s0WQ0dQUJAUOnr16gUPDw8FKiUisi8GDSJyKVqtFn/88QdiYmKwbt063L59u8g2Pj4+GDRoECIiIjBw4ED4+fkpUCm5g/v372Pz5s2IiYnBpk2bkJubW2SbwMBAKXT07t2boYOIXAaDBhE5vYKCArNwcefOnSLbVKpUCYMHD0ZERAQGDBgAX19fBSold5aTk4PNmzcjNjYWGzduxIMHD4psU7VqVTz99NOIiIhAnz594OnpqUClRES2waBBRE6poKAA27dvR0xMDNavX4+7d+8W2cbX1xdDhgxBeHg4BgwYgEqVKslfKJEFDx48wJYtWxATE4ONGzciJyenyDZVqlTBsGHDEBERgX79+jF0EJHTYdAgIqeRn5+P33//HTExMYiLi0NWVlaRbfz8/DBkyBBERESgf//+8PHxUaBSIuvl5uZi69atiImJwYYNG3D//v0i2wQEBJiFDi8vLwUqJSIqGwYNInJoeXl5ZuEiOzu7yDaVK1fG0KFDERERgSeffJLhgpxWbm4utm3bhtjYWMTFxeHevXtFtvH39zdr797e3gpUSkRUOgYNInI4xi9bxiO8xX3ZGjZsGMLDw/lli1xSWUJ2eHg4+vfvz/cBETkUBg0icgi5ubnYsmULYmNjOXyEqJD8/HyzOUkcNkhEzoBBg4gUY+2EWNOz8DBckLvLz8/Hjh07Sj0RgulZ1ngiBCJSAoMGEcnKeIpP47oCPMUnUfmV5dTO4eHhGDhwIE/tTESyYdAgIru7f/8+Nm3ahNjYWC5aRmQnxsUqY2Nj8dtvv1lcrLJSpUoYOHAgF6skIlkwaBCRXdy/fx8bN25ETEwMtmzZYjFcBAUFSeGiV69eDBdENqLVarFr1y7ExMTgt99+Q2ZmZpFtfHx8MGDAAERERGDw4MEMHURkcwwaRGQz9+7dw4YNGxAbG4stW7YgLy+vyDaPPPIIhg8fjoiICDzxxBPQaDQKVErkPrRaLXbv3o2YmBisXbsWGRkZRbbx9vY2Cx2VK1dWoFIicjUMGkRUIdnZ2diwYQNiYmKwdetW5OfnF9mmevXqUrjo0aMHwwWRQnQ6nVnoSE9PL7KNl5cX+vfvj4iICAwZMgT+/v4KVEpEroBBg4jKLCsrC3FxcYiJicG2bdtQUFBQZJsaNWqYhQu1Wq1ApURUHL1ejz179kih4+bNm0W28fLywlNPPYXw8HAMHToUAQEBClRKRM6KQYOIrHL37l2sX78esbGx+P333y2Gi5o1a2LEiBGIiIhAt27dGC6InIRer8fevXsRExODX3/9FTdu3CiyjaenJ5588klERERg6NChqFKlivyFEpFTYdAgomLduXMH69evR0xMDLZv3w6tVltkm+DgYISHhyMiIgJdu3ZluCBycnq9Hvv27ZNCx/Xr14ts4+HhgX79+iEiIgLDhg1D1apVFaiUiBwdgwYRmbl9+zbWrVuHmJgY7NixAzqdrsg2tWvXlnouunbtCpVKpUClRGRvBoMBf/31F2JiYhAbG4tr164V2cbDwwN9+/ZFeHg4nn76aQQGBipQKRE5IgYNIkJmZiZ+++03xMbG4o8//rAYLurUqSP1XHTp0oXhgsjNGAwG7N+/H7GxsYiNjcWVK1eKbKPRaNCnTx9ERETg6aefRlBQkAKVEpGjYNAgclMZGRn47bffEBMTg507d0Kv1xfZpl69eggPD0d4eDg6d+7McEFEAB6GjoMHD0o9HZcvXy6yjVqtRu/evREREYFnnnkGjzzyiAKVEpGSGDSI3MitW7ekcBEfH28xXNSvX1/quejUqRMEQVCgUiJyFqIo4u+//5ZCx8WLF4tso1ar0atXL4SHh2P48OGoVq2aApUSkdwYNIhc3M2bN7F27VrExsYiPj4eBoOhyDYNGjRAREQEIiIi0LFjR4YLIioXURRx6NAhxMbGIiYmBhcuXCiyjUqlwhNPPIGIiAgMHz4c1atXl79QIpIFgwZRMQwGA27cuIHExEQcP34c58+fx507d2AwGBAQEIB69eqhdevWaNOmDerWretQi9DduHEDa9euRUxMDPbs2WMxXDRq1AgREREIDw9Hhw4dGC6IyKZEUcSRI0cQExODmJgYnD9/vsg2KpUKPXr0kEJHzZo1Fai0ZM68LyBSGoMGUSF5eXn4888/sWLFCsTHx+PWrVvSECPTt4sgCFCpVKhatSq6dOmCF154Af3790flypUVqfv69ev49ddfERMTgz///BOW3tqNGzeWei7atWvHcEFEshBFEQkJCVLoOHv2bJFtBEFAjx49EB4ejhEjRiA4OFiBSv+fs+4LiBwJgwbR/xjHGc+fPx87d+5Efn6+tDPRaDTw9fWFn58f1Go18vLycP/+feTm5kIURQiCAI1Ggw4dOuDtt9/Gk08+KctRratXr+LXX39FbGws9u7dazFchISESOGiTZs2DBdEpChRFHHs2DFpeNWZM2eKbCMIArp164aIiAiMGDECtWrVkrU+Z9sXEDkqBg0iPDxy9eWXX2LhwoW4ffs2RFGEh4cHQkNDMWjQIHTv3h2NGjVC5cqVoVKpUFBQgPT0dJw4cQJbt27FH3/8gRs3bkAQBFSqVAkTJkzAvHnzEBAQYPNar1y5IvVc7Nu3z+I2jz76qDQsqnXr1gwXROSQRFFEYmKi1NNx+vTpItsIgoCuXbtKoaNOnTp2q8eZ9gVEzoBBg9ze/fv3MWfOHCxfvhxarRaCIKBTp06YNWsW+vbtCz8/vxJvbzAYcPHiRXz33XdYvnw5MjIyoFarMXjwYHzzzTeoUaNGhWu8fPmydPRv//79Frdp1qyZ1HPRqlUrhgsiciqiKCIpKUkKHampqRa3Mw0ddevWtdnjO8O+gMjZMGiQW8vLy8OMGTPw9ddfQ6/Xw9fXF9OmTcO0adMQEBAgfVk/fPgw1q1bZzY0qWrVqpg0aRIqVaoE4OFOJiEhAW+88YbU0zBo0CD8+OOP5Vop9+LFi1LPxYEDByxu06JFCylctGzZssyPQUTkiERRRHJysnSAJSUlxeJ2Xbp0kXpv69WrV+7Hc+R9AZFTE4nclMFgEJcsWSJ6eHiIAMQqVaqIP/74o6jVaots+5///EcEYPZTv359MTMzs8h93rhxQxw+fLgoCIKoUqnEV155RczPz7eqpvPnz4v//ve/xU6dOhV5PONPq1atxPfee09MTk62yd+BiMjRJScni++++67YsmXLYj8bO3XqJP773/8Wz58/X6b7dsR9AZGrYNAgt7V//34xMDBQBCD6+PiI33//vajX6y1ua+3ORRQf7mDS09PFp556SgQgent7i2vWrCm2jnPnzokfffSR2LFjx2J3oKGhoeL8+fPFkydP2uz5ExE5o5SUFHH+/PliaGhosZ+ZYWFh4uLFi8Vz586Ven+Osi8gckUMGuSWcnNzxf79+4uCIIiCIIhTp04VCwoKit2+LDsXUXy4gzl9+rTYqFEjURAEsWXLluLNmzel69PS0sRFixaJHTp0KHZH2aZNG/GDDz4QU1NTbf78iYhcQWpqqvj++++LrVu3LvaztEOHDuKiRYvEs2fPFrm90vsCIlenqujQKyJnFB8fj/j4eIiiiBYtWmD27Nnw8PCw2f0LgoAmTZpg7ty5UKvVOHnyJD777DN8+OGHaN++PZo0aYI333wTR44cMbtd27ZtsWDBApw6dQrHjh3Dv/71Lzz66KM2q4uIyJU8+uijmDt3Lo4fP45Tp05hwYIFaNu2rdk2R44cwZtvvonGjRujffv2+PDDD5GWlgZAmX3Bzz//bLP7J3J0nAxObkev1yMyMhIxMTEQBAFffvkl/vnPf5Z4lqbvvvsO48ePN/td/fr1cfTo0RIn9927dw99+/bF33//Xew27du3lyYzNmnSpOxPiIiIzKSlpUkTyY8ePWpxmzZt2sBgMCApKUm2fcGhQ4fQvn177N69G76+vuV7ckROhD0a5HauX7+OPXv2QBRF1KlTB8OGDbPbqWD9/PwwevToIvffsWNHfPTRR0hLS5OOtjFkEBHZhmmvcVpaGhYtWoQOHTqYbXP8+HGcOHFC1n0BAKSkpODEiRN2eRwiR8OgQW7n2LFjyMjIAAD06NED1atXh/hwvlKxPyUp7Xb9+vWTFmsaNGgQzp07h0OHDmHWrFlo3LixfZ8sEZGba9y4MWbPno3Dhw/j3LlzWLx4McLCwsy2kXNfkJeXh71799rt+RI5Eo3SBRDJ7dixY9Dr9QCAxx9/HACwfPlynDp1qtjbJCUlFfndnTt3MHfuXHh7e1u8TbVq1TB16lTUrVsXDRs2REJCAgICAtCgQYOKPwkiIiqzhg0bYubMmZg5cyamT5+Ojz/+GKIoyr4vSEhIgCiKXFiVXB6DBrmd8+fPAwA0Gg2aNm0Kg8GAtWvX4vfffy/T/WRnZ+Orr74q9vqmTZti0qRJqFy5srRzuXTpEnQ6nU0nGxIRUdndvXsXAPcFRPbEoVPkVkRRxO3btyGKIjQaDapWrWr3xxQEAY888ggAICsrCzqdzu6PSURExeO+gEgeDBrkdozjZQVBkK3bWqVSmT02EREpi/sCIvtj0CC34+/vDwDQ6XS4d++e3R9PFEWpi97Pzw9qtdruj0lERCXjvoDI/jhHg9yKIAioW7cuBEGATqfD+fPn0bVrV4SGhiIvL6/Y2924cQOnT582+52Xlxc6dOgAjcby26hu3brQaDTQarW4ePEiACA4OBgqlQoGg0Gqp3B9RERkX4IgoE6dOortC2rVqlXs9kSuhK2c3E7r1q0hCAIMBgMOHjyI0aNHY9GiRSV2Zf/www+YMGGC2e9q1KiBtWvXlrhIk0ajweXLl3H27FkIgoBWrVpBEATpbCOFH9P0smnoYAAhIqqYwp+3Su4LQkNDpWFURK6MQYPcTvv27REQEIA7d+4gPj4eWVlZqFKlSom3sdTFLQgCPDw8SjxriCiK2LdvHzIyMuDh4YFu3bpJAaPwzqxwmDC9vrgAYukyERGVPg9C6X0BkTtgnCa3U6dOHbRv3x6CIODMmTOIj4+328S8goIC/PTTTzAYDGjQoAE6dOgAQRCgUqnMfkzDQmmLQxVeCMpgMEg/1i4sRUTkSsqzuN6ZM2ekz1659wXt27e3y+MQORoGDXILoihCp9OhoKAAarUaI0eOhFqthlarxSeffIKcnBy7PObu3bsRHx8PQRAwYsQIBAUFSWc4KTw0yvhjGkAK3581j2kpgDCEEJErKUuoAP7/M1ar1WLVqlVo3749hgwZgtu3bwOArPuC8PDwEodZEbkSBg1yacaAodVqpQnYADBo0CCEhoZCEATs3bsXP/zwg9n1tpCZmYl33nkHeXl5CA4Oxosvvlhkp2gaMCwNgSocQIoLKdawpheEIYSIHE1ZeyuAop+t2dnZWLJkCRo3bowxY8YgMTFR2tbT01P2fQGRu2DQIJdkMBig1WqLBAzg4RjbatWqYe7cufD29oZOp8P8+fPx559/2uyLdl5eHubNm4eDBw9CpVLh9ddfR6NGjaTri9thlhY8LG1r6XbW3kfhWjgUi4iUVp6DH8V97l25cgWzZs1CvXr1MGvWLFy9elW6rlOnToiJiUF0dLRs+4IpU6aY7QuIXB2DBrkUY8DQ6XRFeg7UajU8PT2hVqshCAKGDBmCsWPHQqVSISMjAy+++CIOHDhQoR2MKIrIzc3FBx98gP/85z8AgH79+uGVV14p9gwjJe1MyxMcCis8F6Qs98NeECKyt4r2Vlj6PEtMTMSYMWPQqFEjLFmyBNnZ2dJ1Q4YMwe7du7F//36Eh4dj2LBhsu0LJk6cyBN4kFth0CCXoNfrUVBQYDFgaDQaeHh4FDlbiIeHB95//3307dsXgiDg3LlzePbZZ/Hrr79Cq9Wa3Y9Go4Gfnx98fX2ln0qVKhWZxH3r1i28/vrr+Oijj6DT6dCqVSt89tln0sJQJX3JL+9OtjSWduCF54KwF4SI5GCLYVAl3feOHTswYMAAtG3bFj/99BN0Oh2Ah8Ojxo8fj5SUFKxfvx7du3eX7kuJfQGRuxBEfhsgJyWKIvR6vcXxtMVNqLbk6tWrGDt2LHbu3AmDwQAfHx+MHDkS06ZNQ9OmTaFSqXD37l2zLnfg4Y6rcePGUKlUePDgAbZs2YIFCxbg+PHjAIBWrVph1apVaN26dYnPoTgVOepV1rd1aTvv8t5vSY/Do3pErs+Wn0XF0Wq1+OWXXxAVFYVjx46ZXVe1alVMmjQJr776KmrWrFni/Si5LyByVQwa5HRKCxjGoVFlkZ6ejpkzZ2LNmjXSEaxq1aph4MCBGD58ONq2bYtHHnkEHh4e0gJPDx48wKVLl7Br1y7897//xZEjR6DVaqFSqdCnTx988cUXaNKkSZmelyW2+EJenre5tT0bFXkMS4/FAELknOz1OVOce/fu4dtvv8Unn3yCy5cvm13XoEEDTJ06FePGjYOfn5/V9+kI+wIiV8KgQU7DYDBAr9db3Jmp1eoi61GUVX5+PtasWYOFCxfi7NmzUre+Wq1G1apVUatWLQQFBUGj0SAnJwc3b97EjRs3pNMhCoKAmjVr4vXXX8ekSZPK3UVur14Oax/DFo9d+P4ZQohcj9zBwujatWv49NNP8c033yArK8vsuo4dO2LGjBkYPnw4NJryrUnsKPsCIlfAoEEOr7iAYZxnYGml1oq4du0aVq1ahejoaJw6dQoFBQUl9jZoNBrUr18fI0aMwEsvvYQmTZrYvRfCHl+45RjiUPhxbBVAKlIPEVlHrs+I4iQlJWHp0qWIjo6GVqs1u27QoEGYPn06evbsabPHdZR9AZEzY9Agh2UcHmUpYBh7MOwpOzsbCQkJ+PPPP5GQkIANGzZAq9VCo9GgTZs2CA4ORmhoKLp3746wsDBpMT5bkztwWPO4xbHlvBL2ghApR6neCkt17Nq1C1FRUdiyZYvZdZ6enhg1ahSmTp2Kli1b2vyxjQrvC65cuYLs7GyIogg/Pz/Z9gVEzohBgxyK8QxGer2+yHVyBYzi6qpbty6uXr2KWrVq4ezZs/D09JS1FqUCh7U1WGKPoV6ckE5ke0r3VhSm0+kQExODqKgoHD161Oy6KlWq4JVXXsFrr72G4OBgu9ZRmCiK0hkOAUinTVdiv0TkDMo3gJHIxuwxwduWCq/Q7e3trUgNRsUd/bf336jw/Zf25cTS9eWpsaRwUNYQUtz2DCDkLhylt8KS+/fv47vvvsOyZctw8eJFs+vq16+PN954Ay+++CIqV64sSz2FCYIALy8veHl5KfL4RM6GQYMUZe8J3q7K+DcpabiRHH+3sgYPS9tUtM7iAoKtAkhJj0HkDBw5WBhdv34dn3/+Ob766ivcvXvX7Lp27dphxowZiIiIKPcEbyJSBt+xpAi5J3i7quICh+nv5PzCYOmxytrrYat65e4FsXSZSAmONgyqJCkpKVi6dClWrVqFgoICs+sGDBiA6dOno1evXnxvETkpBg2SldITvF2VowUOU0oNt7K2JmuGpBXH2h4lfkkie3GG3orCRFHEnj17sGTJEmzatMnsOg8PD0RGRmL69Olo1aqVQhUSka0waJDdOeoEb1fkyIHDyJF6PQorqYeCvSDkCJypt6IwnU6HtWvXIioqCocOHTK7zt/fHxMnTsTkyZNRu3ZthSokIltj0CC7cfQJ3q7MESaOl0VFez3kno9SkaFY7AWhsnDmYGGUk5OD77//HsuWLcP58+fNrqtbty6mTJmC8ePHc2E7IhfEoEE2ZzAYpJ/CGDDk5ygTx8vCEYdblYQT0skWnHEYVElu3ryJzz//HF9++SXu3Lljdl2bNm0wY8YMPPvss/Dw8FCoQiKyNwYNspnSziDFCd7KcoZhVcVx5OFWJeGEdCqJK/RWWJKamoqlS5fip59+Qn5+vtl1Tz75JGbMmIE+ffo4zfMhovJj0KAK4wRv5+LMgcOUs/V6lPTYnJDu+lytt6IwURSxd+9eLFmyBBs2bDC7TqPR4Pnnn8f06dPRunVrhSokIiUwaFC5cIK383OVwGHkrL0ehXFCumtw1d6KwvR6PX777TdERUXh4MGDZtdVrlwZEyZMwOTJk1G3bl2FKiQiJTFoUJlwgrfrcbaJ42XhDJPMy4K9II7LXYKF0YMHD/DDDz/g448/xrlz58yuq127NqZMmYKXX34ZAQEBClVIRI6AQYOswgne7sEZJ46XhbMPtyqOHL0ghe/XEf8OcnH1YVAluXXrFr744gt8+eWXyMzMNLsuNDQUM2bMwHPPPQdPT0+FKiQiR8KgQSUqbYK3SqVymR0o/T9XG1ZVHFcZblUSuSekO/rfozzcrbfCktOnT+Pjjz/Gjz/+iLy8PLPr+vbtixkzZqBfv34u+dyJqPwYNMgiTvAmwH0ChylX7fWwxB5DsZy9F8Sdeyss2bdvH6KiorB+/Xqzv41arcY//vEPTJs2De3atVOwQiJyZAwaJOEEbyqOOwYOo7IGD0vbONvfxp0mpDNYFKXX6xEXF4clS5Zg//79Ztf5+fnhn//8J15//XXUq1dPoQqJyFkwaBAneJPVXHniuLXcYbhVSZx9QjqHQRUvNzcXP/74Iz7++GOcOXPG7Lrg4GC8/vrrmDBhAqpUqaJMgUTkdBg03BgneFNFlDZx3J3ajjsNtyqOI05IZ2+FddLT0/Hll1/iiy++QEZGhtl1LVu2xPTp0xEZGckJ3kRUZgwabogTvMmWXP1MVeXh7r0ehck1Ib2sIdeV/sblkZaWho8//hg//PBDkQnevXv3xvTp09G/f3+3/zsRUfkxaLiRkiZ4G3swiMrLnedxWIO9HpZZMxSrpDZlzfbG+xUEwSX/hmV14MABLFmyBL/99luRCd4RERGYPn06OnTooGCFROQqGDRcHCd4k9wYOKzjjpPMy6JwACkcJEpqZ5buw7itI05Il4PBYMCGDRuwZMkS7Nu3z+w6X19fjB8/HlOmTEGDBg2UKZCIXBKDhoviBG9SGieOlw2HW5mzNkCY9lY4y4R0OeXl5WHlypVYunQpTp8+bXZdzZo1MXnyZEycOBFVq1ZVqEIicmUMGi6GE7zJEXHiePm4y3ArW03adqfT8pYmMzNTmuB969Yts+uaN2+O6dOnY+TIkfDy8lKoQiJyBwwaLoITvMkZcOJ4xbhKr4cSp5h19tPyWuvcuXP4+OOP8f333yM3N9fsup49e2LGjBkYMGAAh8wSkSwYNJwcJ3iTM+I8Dttx9F4PRz/FrCOelrc8/v77byxZsgRr164169FWqVQIDw/H9OnTERYWZvPHJSIqCYOGE+IEb3IVDBy2p/Qkc0cPFmUh12l5i3vM0hgMBmzatAlRUVHYs2eP2XWVKlXCSy+9hDfeeAMNGza0+j6JiGyJQcOJlDbB2/hD5Gw4cdx+7D3cyl1X2lZyKFZeXh5WrVqFpUuXIjU11ez21atXlyZ4BwUFWfFMiIjsh0HDCXCCN7kTThy3v/IOtyrPXBp3e73sORTr9u3b+Prrr/H555/j5s2bZo/x6KOPYvr06Rg1ahS8vb0r8hSIiGyGQcOBcYI3uTNOHJdPcb0eJX0ZttTrwdejZOXtBTl//jw+/fRTfPfdd8jJyTG7rnv37pg2bRoGDx4s7RMYyonIUTBoOCBO8Cb6f5zHIZ+ShkxZM4mcIbB8iusFOXz4MJYsWYKYmJgiE7yHDx+OadOmoXPnzma3VXJCOhFRYQwaDoITvIlKxsBhW+WZW1Fa8Cjt/vn6lM5gMGDLli2IiopCfHy89HtBEODj44MXX3wRb7zxBho3bmyXCel8jYjIlhg0FMYJ3kRlw4nj5WPrSduusqaHo8jPz8fq1asRFRWFlJQUs+uqVauGV199FZMmTcIjjzwi/d6aoViOflpeInJtDBoKKS1gcII3Uek4cdwypU4x6+hrejiiO3fu4JtvvsFnn32G69evm10XEhKCadOm4YUXXoCPj4/V9+nop+UlIvfBoCEzTvAmsj13nzjuqKeYZa9H8S5evIhPPvkE//nPf3D//n2z67p27YoZM2Zg6NChNu/RdpcV0onIMTBoyIQTvInsz13mcThqsLBGRXs9HOm5lEdCQgKWLFmCX375xWxOniAIePrppzF9+nR07dpV9rpcZYV0InIsDBp2xAneRMpwpcDhSittW+IOw61EUcS2bdsQFRWFP/74w+w6b29vjB07FlOnTkVISIhCFZZM7qFYjv56EpH1GDTsgBO8iRyDMwYOZ+6tsAVXGm5VUFCANWvWICoqCklJSWbXBQUF4bXXXsOkSZNQrVo1hSqsOE5IJ6KSMGjYECd4EzkmRz1Tlav3VtiKs/V6ZGVl4ZtvvsGnn36Ka9eumV3XuHFjTJs2DWPGjEGlSpVkq0lunJBORACDhk1wgjeR81By4jiDhW2UNXhY2sYef9fLly/jk08+wbfffot79+6ZXdelSxfMmDEDw4YNc/s5eZyQTuQ+GDQqoLiAwQneRI5PjmFV7j4MSi5KD7c6fvw4oqKi8PPPP0On05nd59ChQzFjxgx07dqVr28p5JiQzl4QInkxaJSDXq/nBG8iF2GrwMHeCsdi7+FWoihi+/btiIqKwvbt282u8/LywpgxYzB16lQ8+uijZaiaisNeECLnxKBhJU7wJnJtZQ0c7K1wLrbq9dBqtfj5558RFRWFxMREs+sDAwPx6quv4tVXX0X16tUrXjSViqflJXJsDBql4ARvIvdi6YtK4X+tec/zc8HxlaXXIzs7G8uXL8enn36KK1eumN1Ho0aNMHXqVIwdOxa+vr52q5fKhhPSiZTHoFEMTvAmcl9lOdJt/Bzg54Hzs/Rl9MqVK/jss8/wzTffIDs72+z6sLAwzJgxA8OHD+ecPCfDoVhE8mDQKIQTvIncT2lfJgoPq+KXBteXmJiIpUuXYvXq1dIEb0EQIIoihgwZgunTp6N79+6l9oqwrTgXTkgnsi0Gjf/hBG8i91CRSdvOuAAgWU8URezcuRNLlizBtm3bzK7z9PTE6NGjMW3aNDRv3tzsNqXdZ2FsI86JvSBEZefWQUMURakHozBO8CZyDfaYtM3A4Vq0Wi1iYmIQFRWFhIQEs+uqVq2KSZMm4dVXX0XNmjWL3FbpU+uS8jghnah4bhk0OMGbyDXJfYpZR11xnKxz7949/Oc//8Enn3yCS5cumV3XoEEDvPHGG3jxxRfh5+dXpvt1tpXMyX7knpDOdkOOxq2CBid4E7kWR1q7QskVx6lsrl27hs8++wxff/01srKyzK7r0KEDZsyYgREjRkCjsc0u0lFXMidlWTMUi70g5OzcImhwgjeRa3CGtSs4rMpxJScnIyoqCtHR0dBqtWbXDRw4EDNmzEDPnj3t/vpwuBWVhKflJVfi0kHDODzK0gc0J3gTOTZH6q0oDwYOxyCKIuLj47FkyRJs2bLF7DoPDw+MGjUK06ZNQ8uWLRWq8CEOtyJrcEI6ORuXCxolTfBmwCByXM7QW1EeDBzK0Ol0iI2NRVRUFI4cOWJ2XUBAAF555RW89tprqFWrlkIVloy9HlQWnJBOjsplggYneBM5D2fvrSgPThyXx/379/Hdd99h2bJluHjxotl19erVwxtvvIGXXnoJlStXVqjC8mOvB5UHJ6STkpw+aHCCN5Hjc8dgURJOHLe969ev4/PPP8dXX32Fu3fvml3Xrl07zJgxAxERETab4O0IOMmcKooT0snenPoTV6vVFhswOMGbSHnWBgx33fmUNqzKXf8uZfXzzz9j7NixKCgoMPt9//79MWPGDPTq1cst/pYVGW7lDn8fsp49e0EEQWB7cyOCWJ5DjQ5Cp9NJQ6U4/4LszXTeD4OsdYr7eOFOxjIebS4f49w8I+MXGf79iuJ7kuzF2gnp/J7mXmTp0RBFsVxDJ0ojCAJEUTQLGJbmaFT0MfgB7DwuXbqEgwcP2uW+TduWPT4oO3fujHr16tn8fpXG94/1SurhcAX2fH/a+8i8q7w/y9PrQe7Dlm2hIkOxbPGY5BhkCRrGU8waG4CtGoIgCPDw8LDJfVnCLmXnc+DAAZw6dQq1a9dGQUEB6tSpo3RJVjl69CgAuMQXGVN875SPq/7djO/POnXqID8/n+9PB+Gq7Y0cB9uY+5JtjoYgCFLg8PDwcIpGZ+veEbI/QRDQoEEDrFq1Crdv38bKlSvRrFkzh29vKpUKOTk5SpdBZFeCIKB+/fqIjo7G7du3sWrVKjRt2pTvTyIH5ujvT4C9co5M1oFyxobABkH2lJOTg4yMDBw9ehTPP/88kpKS2OaIHERubq70/oyMjMSpU6f4/iQiclGyBQ3OdSC51K9fH6tXr0aHDh1w4sQJ/OMf/0BCQgK/zBA5gHr16mHVqlVo27Ytjh07hsjISJw8eZLvTyIiFyRrj4bpREfuVMiemjZtijVr1qBLly5ITU3F888/j7///pvtjsgBNGvWDNHR0WjXrh2OHz+OkSNHMmwQEbkgxYIGkT0JgoBGjRohOjoa3bt3R1paGiIjI7Fv3z62PyKFCYKARx99FNHR0Wjfvj0SExPZs0FE5IIYNMhlGSeerlq1Cn379sWFCxcwcuRI7Nq1i22QSGGCIKBp06aIjo6WhjlGRkYiJSWF708iIhehyKop3ImQXARBQO3atbFixQoMHDgQV69exQsvvIBt27axHRIpTBAEhISEmIWNkSNHIjk5me9PIgfB9yJVhCI9GoA8Ddc4F0QURej1euj1eukUu3zjuA9BEFCzZk189913GDp0KG7cuIFx48Zhw4YNPIUxkcIEQUCTJk0QHR2Njh07MmwQEbkQ2Xs0rJ0QbhoSTH+sZdxWr9dDq9VKQUOn00Gv15ttQ65PEARUq1YN3377LcLDw5Geno7x48dj7dq1DBtECjOGjVWrVqFjx45ISkpi2CAicgGKBg1LjIHCYDBAq9VKP2UJB8b70Ol00pdI09PrGgwG6f7IfQiCgMDAQHz11VcYOXIk7ty5gwkTJuDnn39meyBSmGnYCAsLk8IG52wQETkv2YOGSvXwIUvacRh7H0wZg4dx6FNxTEOGKIoQBAEajcbsx3h/pd0XuR5BEFClShV89tlnGDt2LO7du4dXX30VK1asYNggUhh7NoiIXIvsczRK6tEw9mQYeyHUajU8PDyg0Wik2xlDSOGhVKY9ITqdTno8421Nf9RqtXRf5H4EQUDlypXx8ccfY+LEiXjw4AGmTp2Kr7/+Wmo7RKQMQRDQuHFjztkgInIBipx1ynQIk3HHYTppG3gYMlQqlRQONBqN1BtiDBOF526Y9oSoVCqp98J0ErogCNL9Gm/DnZf7EQQBvr6+WLRoEaZMmYKCggLMnj0bn3zyCbRardLlEbk1Y9go3LPBYVRERM5FkaBhGhgA84nbxutNw4BpT4QxPBiHRxnDhXFYFfAwpBh7LUxDhinj9ZwI7L4EQUClSpUwf/58zJo1C3q9Hm+//TYWL16M/Px8pcsjcmvFDaNi2CAich6KTAY3nadhGjKM/zeGAEu3NR0OBcBsqJVpz4fpMK3i7sdSzwq5H29vb8ydOxfz5s2DIAj44IMP8MEHHyAvL0/p0ojcWuGwYRxGxbBBROQcFOnRAP6/V8N4ylljWLA03MmUadjQaDTSECvj5ZIChqX7AniaWwI8PT0xY8YMfPDBB1Cr1Vi8eDHmzp2LBw8esH0QKYhhg4jIeSkWNNRqNQRBMOvVMP6utKBg3MY4xMr0dmUJGYWHcJF78/DwwOTJk7F48WJ4eXnh008/xaxZs5CTk8MvNEQKMg0bpiuIM2wQETk2RSeDG4c5GXskTOdllOW+yhIwLN0WKH0BQXIPGo0GEyZMwLJly+Dr64vly5dj6tSpuHfvHtsHkYIYNoiUw/cYlZdiPRrGL/jGidvlDQu2qoO9GmSkVqsxZswYfPnll/D398eKFSvw2muv4e7du/ywJVKQIAgICQkpcupbhg0iIsekWNAAzHsjlAgZgHULCJL7UavVeO655/DNN9+gatWqWL16NSZOnIjbt2+zrRApiD0bRETOQ9GgobTSFhAk96ZSqfDMM8/gu+++Q7Vq1fDrr7/in//8JzIyMtheiBRkDBvR0dEMG0R2oNTBX3I9bh00jHiaWyqOSqXC4MGDsWLFCtSsWRPr16/Hiy++iJs3b7KtECnINGwYh1FFRkYybBApzHQxZVvMf7XV/ZAyGDTA09xSyQRBwJNPPomVK1eidu3a2Lx5M1588UVcv36dbYZIQVzUj8ixFPe+K09QsHQbBg7nw6ABztOg0gmCgF69euGnn35CvXr1sG3bNowdOxbXrl1juyFSUHHrbCQnJ/O9SSQja95v1r4n+d51HW4fNDhPg6wlCAK6d++O6OhoNGjQAH/88QfGjBmDq1evsu0QKYhhg8i98H3tPNw+aBTGxkslEQQBjz32GKKjo9GoUSPs2rULL7zwAq5cucK2Q6Sg4oZRMWwQ2V9Z3mOlbcv3q2th0Pgf9mqQtQRBQOfOnREdHY3GjRtj9+7dGDNmDMMGkcJMw0ZYWBiSkpIQGRmJpKQkvjeJZFbS0gUlzeUo7r6s3ZYcC4PG/3CFcCoLQRAQFhaG6OhoNGnSBLt378bYsWMZNogUZho2OnXqhOTkZIwcOZJhg6iCyhIOTIOBtWGjLCGDnAeDxv+wR4PKShAEdOzYEatWrULjxo0RHx+PsWPHcs4GkcIEQUDjxo2LhI0TJ07wvUmkgLL2bJTlPsixMWiAE8Kp/EzDRqNGjRAfH49x48bx1LdEChMEAY0aNWLYIConub7YlzSSpLQa+F52fAwa/8OkTOVlHEb1008/oWHDhti5cydeeuklLupHpLDCYSMlJYVhg8iGShs2Zc3vi8PvZa6BQcMEezWovIwTxFeuXIn69evj999/x4QJE5CZmcn2RKQg07DRuXNnpKSkIDIyEomJiXxvEsnM2vBgq7BCymPQsIATwqk8jKe+XbFiBWrXro1NmzbhtddeQ3Z2NtsTkYJMw0aXLl1w8uRJjBw5kmGDyMasCQKlbcMw4VoYNEywR4Mqyrio37fffotHHnkEv/76K6ZPn46cnBylSyNya4IgoGHDhvjpp58YNojKyfS9UpH3TXGnvi1PyOD717ExaJhg0CBbEAQBTz75JL7++msEBARg5cqV+Ne//oXc3FylSyNya8awYdqzERkZiePHj/Nzn0gBxsBR0pob5NwYNP6HZ54iWxIEAUOHDsWnn36KSpUq4euvv8YHH3yA/Px8pUsjcmuCIKBBgwb46aef8NhjjyE1NZU9G0TFKMuXf7mCAgOJc2HQMMHGS7akUqnw3HPP4d///jc8PT2xdOlSREVFQavVKl0akVsrPIzKGDbYs0FkHb5PyFoMGoWwV4NsSa1WY9y4cZg/fz4EQcCCBQvw5ZdfQqfTKV0akVsz9mysWrUKjz32GOdsEFmJ7w8qCwaNYvCNRLai0Wjw2muvYc6cOdDr9Xj77bexcuVKGAwGpUsjcmumw6hMeza4zgZR2XBECBWHQaMQ9miQPXh4eGDWrFl44403kJeXh5kzZyIuLo7tjEhhhcOGsWeDYYPoIYYIqggGjUL4hiJ78fLywrx58/Diiy8iOzsbkyZNwu7du/llhkhhpnM2jIv6jRw5EklJSXx/EpWC35uoJAwaJnjmKbI3Hx8ffPTRR3jmmWdw8+ZNvPzyyzh27JjSZRG5PdOw0alTJ6SkpGDUqFFISUlRujQiKoThxnkwaBSDq4OTPQiCAH9/f3z22Wfo1asXzp07h5deeglXrlxRujQit2dcQfynn35Cx44dkZSUhFGjRuHSpUtKl0akqOK+2PMLP5WGQaMQ45uGbx6yF0EQUL16dXz77bfo0KEDatasCU9PT6XLIiI8fH82btwYq1atQocOHVCrVi1UqlRJ6bKIFFd4cT1+TyJraOR6IGc6w45arQbwsFeDbyTnIooiDh486DQL440ePRp+fn44f/48WrVqpXQ5RHblbO/PMWPGwNvbG2fPnuX7k9wKR3SQrQiiDK3JmYchMbU7l8uXL+Pw4cNKl1EuYWFhqFOnjtJlENkN359Ejs1Zv6sZ8fua45ElaNgbex5IDsa3CtsakePh+5OIyPHINnTKHvR6PfR6PQRBgIeHh9LlkIsy9sgZv8ioVCp+mbESv/yVD/9uZSOKojQ8l+PHy4ZtjeRQeB9K7sOpX23jjsV0J0Nka6IoomPHjvDw8ICHhweio6OVLsnpuEDHqWz4tyq7VatWSe/PsLAw/g2txL8TycW0rbHduRenHjplMBig0+kAgL0aZFc7duzAk08+CQCoV68eUlNT4e3trXBVjs30o4VHS8uGfzvr5ebmolmzZrh8+TIAYPv27ejTp4/CVTkPtjWSQ+G5uuzVcB9O/UqrVCqpsYqiCL1er3BF5Kr69u2L/v37AwAuXbqEzz77TOGKiAgAPvvsMylkDBgwgCGDyAEVHs7oxMe4qYycukcDeNhYtVqtdJnrEZC9JCYmol27dhBFEQEBAUhLS0NQUJDSZTkkHiWtOP4NS5eZmYkmTZogKysLKpUKCQkJCA0NVbosp8O2RnIxHebOXg334PSvsiAIZo2VvRpkL61bt8bYsWMBAFlZWVi4cKGyBTkoJz924ZD4N7VswYIFyMrKAgCMHTuWIcMG2NbIntir4X6cvkcDKNqr4eHhwaMyZBdXrlzBo48+itzcXHh4eODkyZNo1KiR0mU5FB4dtR3+LYt39uxZtGjRAlqtFj4+Pjh9+jRq166tdFlOi22N5MJeDffiEq+wIAjSat4AezXIfurUqYOpU6cCALRaLebOnatwRY7FBY5bOCz+bc3NnTtXOsA0bdo0hgwbYlsje2KvhntxiR4No4KCAun/7NUge8nKykJISAgyMjIAAAcPHkRYWJjCVTkGHhW1Pf5Ni/r777/RpUsXAEC1atVw5swZ+Pv7K1yV82NbI7mwV8N9uNSra9qrYTztLZGtBQQEYN68edLlWbNm8agM+CXFXnj0z5woipg1a5Z0ed68eQwZNsK2RnIxbWtcB821uVSPBvBwOIvxKWk0GiZlsgutVotWrVrhzJkzAID169djyJAhClelLAYN++Hf9v/FxcXh6aefBgCEhIQgKSmJayjZENsaycU0YBQ+/S25Dpf7Fs65GiQHDw8Ps7NOvfnmm27di8YvJ/bFI80P6XQ6vPnmm9LlDz/8kCHDxtjWSC5sa+7B5YKGSqWSGq8oiuySI7sZPnw4HnvsMQDAyZMn8f333ytcEZFr++6775CamgoA6Nq1K5555hmFKyKi8ip8UIphwzW53NApwPx0t4Ig8IgX2c1ff/2Fbt26AQBq1qyJ06dPw8/PT+Gq5MXeDPm489/6/v37CAkJwc2bNwEAe/fuRdeuXRWuynW5c1sjeXFiuGtzyVfUdBE/URQ5hIrspmvXrhg+fDgA4MaNG4iKilK4Inm54HEKclBRUVFSyBgxYgRDBpGL4BAq1+aSPRoAF/Ej+Zw+fRqtWrWCTqeDr68vzpw5g5o1aypdlix41FN+7vg3v379Opo2bYqcnBxoNBokJycjJCRE6bJcnju2NVIGezVcl8u+mlzEj+TStGlTTJgwAQCQk5OD9957T+GK5OGixyiciru8Bu+99x5ycnIAABMnTmTIUIC7tDVSBns1XJfL9mgA7NUg+dy6dQshISG4d+8e1Go1EhMT0bx5c6XLsise7VSOO/3tU1JS0Lp1axgMBlSuXBlpaWmoVq2a0mW5DXdqa6Qs9mq4Jpd+JdmrQXKpXr26tIiYXq/HnDlzFK7IvvjlQ1nudPRvzpw50heQ2bNnM2TIzJ3aGimLbc01uXSPhpHpIn7s1SB7efDgAZo2bYpr164BAOLj49GjRw+Fq7IPBg3lucNrsHv3bvTq1QsAULt2bZw6dQqVKlVSuCr34w5tjRwDezVcj1u8iqa9Gu68qBrZV6VKlTB//nzp8syZM13yqAy/dDgGVz/6ZzAYMHPmTOny/PnzGTIU4uptjRyHaVvjOmiuwS2CBhfxI7mMGTMGrVq1AgAcOnQIv/zyi8IVETmnX375BYcPHwYAhIaG4oUXXlC4IiKyNy7i53rcYugU8DAZG3szuIgf2dOWLVswaNAgAEDDhg2RkpICLy8vhauyDfZmOB5XfE3y8/PRokULnD9/HgCwefNm9O/fX+GqyBXbGjkeURTN2hqHUDk3t3n1VCoVF/EjWfTv3x99+vQBAJw/fx5fffWVwhUROZcvv/xSChl9+/bFU089pXBFRCQXQRA4XM+FuE2PBlD0dLeenp4KVkOu7OjRo+jYsSMAIDAwEGlpaahSpYqyRVUQj2Y6Lld6be7cuYMmTZrgzp07EAQBhw8fRrt27ZQui/7HldoaOTZODHcNbvXKCYJg1ljZq0H20r59e4waNQoAcPv2bSxatEjhiirGjY5HOD1nf60WLVqEO3fuAABGjRrFkOHAnL2tkWNjr4ZrcKseDYCL+JF8Ll68iGbNmiE/Px9eXl44deoU6tWrp3RZ5cKjmI7PFV6jwu+Z1NRU1K9fX+myqBBXaGvkHNir4fzc7lXjIn4kl/r16+P1118H8HBy69tvv61wReXjZsciXIKzvmZvv/028vPzAQBTpkxhyHACztrWyDmwV8P5uV2PhlFBQYH0f/ZqkL24wnhzHr10Hs78WiUkJKBDhw4AXGdekytz5rZGzoW9Gs7NbV8x9mqQHKpWrYq5c+cCeLhjnj17tlMdleGXCefirEf/RFHErFmzpMtz585lyHBwztrWyPmwrTk3t+3RAACtVis1Wo1Gw6RMduHMawIwaDgfZ3zNXHntGVfmjG2NnJNpr0bh09+SY3Prb9bs1SA5eHl5YcGCBdLl2bNnO0V745cI5+RsR//0ej1mz54tXV64cCFDhpNwtrZGzottzXm5ddBQqVRS4xVF0SwxE9nSs88+K62rceLECaxcuVLhiogcw48//oikpCQAQFhYGJ599lmFKyIiR1P4YBfDhvNw66FTwMPuOJ1OB+BhQ/bw8FC4InJV8fHx6N27NwCgdu3aOHXqFCpVqqRwVZaxN8P5OcNr+ODBAzRt2hTXrl0DAOzatQs9e/ZUuCoqK2doa+T8RFE0a2sc7u4c3P5VUqlUUmMVRdEphrSQc3riiScwePBgAMDVq1exbNkyZQsiUtjHH38shYwhQ4YwZBBRsQrPzXDz4+ROw+17NICii/h5enoqWA25spSUFLRu3RoGgwGVK1dGWloaqlWrpnRZZnh00nU48mt569YthISE4N69e1CpVDhx4gSaN2+udFlUTo7c1si18HS3zoWvEB5+KJo2VvZqkL20aNECL730EgDg3r17eP/99xWuyByPO7guR3tt33//fdy7dw8AMH78eIYMF+JobY1cC3s1nAt7NP6ncK8GF/Eje7l+/TqaNm2KnJwcaDQaJCcnIyQkROmyAPCopCtyxNf09OnTaNWqFXQ6HXx9fXHmzBnUrFlT6bKoghyxrZFrYq+G8+Cr8z+CIPB0tySL4OBgzJgxAwCg0+nw1ltvKVzRQ/yS4Poc5bjSW2+9JZ2EY8aMGQwZLshR2hq5JvZqOA/2aBRiuogfezXIXu7fv4+QkBDcvHkTALBv3z489thjitbEoOG6HOm1/euvv9CtWzcAQM2aNXH69Gn4+fkpWhPZjiO1NXJt7NVwDnxlCjHt1TAecSOyNT8/P7z77rvS5ZkzZyp6VIZfDlyboxz9E0URM2fOlC6/++67DBkuxlHaGrk+07bGddAcF3s0LDDt1dBoNEzKZBc6nQ6tW7dGamoqAODXX3/FM888o0gtDBquzxFe47Vr1yI8PBwA0Lx5cxw/fhwajUaRWsh+HKGtkXswDRiFT39LjoFBwwIu4kdyiYuLw9NPPw0ACAkJQVJSkuztjV8K3IeSr7VWq0WrVq1w5swZAMD69esxZMgQWWsg+fBzheTARfwcH18RC1QqlfTByEX8yJ6GDBmC7t27AwDOnDmD5cuXK1wRkX188803Usjo0aOHtHglEVF5FQ6xPHbueNijUQwu4kdy+fvvv9GlSxcAQLVq1XDmzBn4+/vL8tg86uh+lHjNs7Oz0aRJE2RkZAAADhw4gE6dOsny2KQcfr6QXDgx3HHx1SgGF/EjuXTq1AnPPvssACA9PR3//ve/ZXlcHmMgudrA4sWLpZDx3HPPMWS4IX7ekD3xJASOiz0aJeAifiSXs2fPokWLFtBqtfDx8cHp06dRu3Ztuz4mjza6Lzlf+ytXrqBp06bIy8uDh4cHTp48iUaNGtn1Mclx8HOG5MJeDcfEV6IEXMSP5NK4cWNMmjQJAJCbm4t33nnHro/H4wtkZO+28M477yAvLw8A8OqrrzJkuDF+7pA9sVfDMbFHwwoFBQXS/9mrQfaSmZmJJk2aICsrCyqVCgkJCQgNDbXLY/EoI8nRBk6cOIG2bdtCFEUEBAQgLS0NQUFBdnksclz8vCG5sFfD8fBVsAJ7NUgOQUFBePPNNwE8/LA0/t/WuNMnQJ6jf7Nnz5bue86cOQwZbopHmkkubGuOhz0aVuIifiSH3NxcNGvWDJcvXwYAbN++HX369LHpYzBokJE928KOHTvw5JNPAgDq1auH1NRUeHt72/QxyHnwc4fkwkX8HAu/LVuJvRokBx8fH3zwwQfS5VmzZpl9aFYUd/Zkyl5H/wwGA2bPni1d/uCDDxgy3ByPNJNc2NYcC4OGlQov4mfLL39EpkaOHIm2bdsCABISErBmzRplCyIqo9WrVyMhIQEA0K5dO0RGRipcERG5Cy7i51g4dKoMDAYDdDodgIcN2cPDQ+GKyFXZY9gJezOoOLZsG3l5eWjWrBkuXboEwD7D/8h58XOI5CCKollb43B35fAvXwYqlUpqrKIocggV2U3fvn3x1FNPAQAuXbqEzz//XOGKiKzz2WefSSGjf//+DBlEJLvCczN4TF057NEoo8KL+Hl6eipYDbmyxMREtGvXDqIookqVKkhLS0NgYGC57otHEak0tmgjpqdoFgQBx44ds9spmsl58fOI5MLT3SqPf/UyEgTBrLGyV4PspXXr1hgzZgwA4O7du1iwYEG57ofHEqisyttmFixYgKysLADA2LFjGTKoVPx8Intir4by2KNRDoV7NSwt4ieKIu7du4eCggJ4enqicuXKPHJDZXblyhU0bdoUeXl58PDwQGpqKho2bGi2TWltjUcPyVqltZWS2tq5c+fQvHlzaLVa+Pj44NSpU6hTp45stZNzqUhbIyqL0no12NbsS6N0Ac5IEASo1WqpN0Ov10Oj0SApKQmrV6/GwYMHcfjwYWRnZ0u38ff3R8eOHdG5c2dERkaiVatWSpVPTqROnTqYOnUqPvzwQ2i1WvzrX//C6tWrrW5rzz//PNsalYsoihAEweq2duzYMekAzNSpUxkyyGplbWvch1JZCIIgBVu2NQWIVG75+flifn6++Ntvv4ldu3YVAYgajUYUBEEEUORHEARRo9GIAMTHH39c3LRpk9JPgZzA3bt3xWrVqomCIIiCIIitW7cuU1vr2rWruHHjRqWfBjkJg8EgGgwGccOGDeLjjz9uVVtTq9XS5YCAADErK0vpp0FOoDxtjftQKg+9Xi/q9XoxLi6ObU1mDBoVcPPmTfHZZ5+VGqWlxlrcj0qlEgGIkZGRYmZmptJPhRzchx9+WKb2VfgDk22NrJWRkSH+4x//KNfnmvGHbY2sUZG2xn0olUV6ejrbmkI4R6OcEhMT0a9fP2RkZFRo8T61Wo2goCDs2LGDEyfJosTERPTt2xfp6ekVuh+2NSoNP9dILmxrJBe2NWUxaJRDYmIiunfvjpycHJucdUqtVsPX1xd79+5l4yUzbGskF7Y1kgvbGsmFbU15DBpllJmZiRYtWiAzM9Omp7Y1JuWTJ0+We60Eci1sayQXtjWSC9sayYVtzTFwHY0ymjx5ss0bLfDwzFWZmZmYPHmyTe+XnBfbGsmFbY3kwrZGcmFbcwzs0SiDTZs2YfDgwbI8zsCBA+3+OOS42NZILmxrJBe2NZIL25rjYNAog27dumH//v0VmkxUGrVajcceewx//vmn3R6DHB/bGsmFbY3kwrZGcmFbcxwMGlZKSkqSdeJPUlISWrZsKdvjkeNgWyO5sK2RXNjWSC5sa46FczSstHr1amg08iykrtFosHr1alkeixwP2xrJhW2N5MK2RnJhW3MsDBpWOnjwIHQ6nSyPpdfrcfDgQVkeixwP2xrJhW2N5MK2RnJhW3MsHDplBVEUUaVKFWRnZ8v2mP7+/rh79y4EQZDtMUl5bGskF7Y1kgvbGsmFbc3xsEfDCvfu3ZO10QJAdnY27t+/L+tjkvLY1kgubGskF7Y1kgvbmuNh0LBCQUGBWz0uKYdtjeTCtkZyYVsjubCtOR4GDSt4enq61eOSctjWSC5sayQXtjWSC9ua42HQsELlypXh7+8v62P6+/vDz89P1sck5bGtkVzY1kgubGskF7Y1x8OgYQVBENCxY0dZHy8sLIwTi9wQ2xrJhW2N5MK2RnJhW3M8DBpW6ty5s2znZVar1ejcubMsj0WOh22N5MK2RnJhWyO5sK05Fp7e1kpcaZLkwrZGcmFbI7mwrZFc2NYcC3s0rNSqVSs8/vjjUKns+ydTq9Xo1q0bG60bY1sjubCtkVzY1kgubGuOhUGjDObMmQODwWDXx9Dr9ZgzZ45dH4McH9sayYVtjeTCtkZyYVtzHAwaZTBo0CA8//zzUKvVdrl/tVqNyMhIDBw40C73T86DbY3kwrZGcmFbI7mwrTkOztEoo8zMTLRo0QKZmZnQ6/U2u1+1Wo2goCCcPHkSgYGBNrtfcl5sayQXtjWSC9sayYVtzTGwR6OMgoKCsGPHDvj6+tosKavVavj6+mLHjh1stCRhWyO5sK2RXNjWSC5sa46BQaMcQkNDsXfvXgQFBVW48RqT8d69e2U9SwI5B7Y1kgvbGsmFbY3kwramPAaNcgoNDcXJkyfx3HPPAUCZG7Bx+3/84x84efIkGy0Vi22N5MK2RnJhWyO5sK0pTKQK27Rpk9itWzcRgKjRaERBEEQARX4EQRA1Go0IQOzWrZu4adMmpUsnJ8O2RnJhWyO5sK2RXNjW5MfJ4DaUnJyM1atX4+DBgzh06BCys7Ol6/z9/REWFobOnTsjMjKS512mCmFbI7mwrZFc2NZILmxr8mHQsBNRFHH//n0UFBTA09MTfn5+EARB6bLIBbGtkVzY1kgubGskF7Y1+2LQICIiIiIim+NkcCIiIiIisjkGDSIiIiIisjkGDSIiIiIisjkGDSIiIiIisjkGDSIiIiIisjkGDSInc+7cOfzyyy+YOXMmevXqBX9/fwiCAEEQsGLFCqXLIyIiIgIAaJQugIjKpnHjxkqXQERERFQqBg0iJxUYGIgOHTqgatWq+OWXX5Quh4iIiMgMh04ROZn//ve/OHv2LDIzM/H777/jlVdeUbokIiIioiLYo0HkZJ599lmlSyAiIiIqFXs0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5hg0iIiIiIjI5jRKF0BEZXP27Fmkp6dLl1NSUsyuO3DggHTZ398fLVq0kLU+IiIiIgAQRFEUlS6CiKw3duxY/Pjjj1Zt27NnT8THx9u3ICIiIiILOHSKiIiIiIhsjkGjgkRRROXKlSEIAsaMGVPq9suWLYMgCNBoNEhOTpahQnI1K1asgCiKVv2wN4OIiIiUwqBRQYIgoFWrVgCApKSkEre9c+cO3n//fQDAP//5T7Rs2dLu9RERERERKYFBwwbatGkDADh58iQMBkOx273//vu4ffs2/P398d5778lVHhERERGR7Bg0bKB169YAgNzcXJw7d87iNmfPnsUXX3wBAJg7dy6qVasmW31ERERERHJj0LABY9AAih8+NXv2bBQUFKBhw4Z4/fXX5SqNiIiIiEgRDBo20Lp1awiCAAAWJ3jv27cPv/76KwBg8eLF8PLykrU+IiIiIiK5MWjYgL+/P+rXrw+gaI+GKIqYNm0aAKBbt24IDw+XvT4iIiIiIrlxZXAbadOmDS5cuFCkR+Pnn3/G33//DUEQsHTpUoWqIwBSrxM5L64vSkRE5DzYo2Ejxnkap06dgk6nAwDk5+djzpw5AICRI0ciLCxMsfqIiIiIiOTEHg0bMQaNgoICnD59Gi1atMCyZctw8eJF+Pj44MMPP1S4QuLRcCIiIiL5sEfDRoxraQAPJ4Snp6dj4cKFAIAZM2agTp06SpVGRERERCQ79mjYSOPGjeHr64ucnBwkJSUhPj4e2dnZCA4OxuzZs5Uuj4iIiIhIVgwaNqJSqdCqVSscPHgQcXFx0tmnFixYAF9fX4WrIyIq6vjx40hOTsaVK1eg0WjQokUL9O7dG56ensXepqCgAPv27UNycjKysrJQpUoVdOjQAZ07d+YJF4jIad25cwcHDhzAtWvXkJGRAQAICgpC8+bN0bFjRy5NUF4i2czLL78sApB+2rVrJ+r1eqXLIoXcunVL/Pbbb8XTp08rXQq5qcmTJ0ufR9WrVxdFURQNBoP41Vdfic2bNzf7vDL+1KhRQ4yNjS1yX7dv3xZnzpwpBgQEWLxd69atxcTERLmfIjmpS5cumbWfSZMmlfk+5s2bJ91eEATx8OHDdqiUXFl+fr743XffiR07dhRVKpXFzzYAYqVKlcRhw4aJW7duVbpkp8OgYUOff/65WcPctWuX0iWRgj755JNiP7T4U74fKpvHH39c+tsNGDBAvHr1qtijR49S/86CIIi//PKLdD9//PGHWKNGjVJvV6VKFfHcuXMKPmNyJoGBgVLb6d69e5lue/nyZbFSpUrS7ceNG2enKslV7d69W6xXr16Z9kGDBg1SumynI4giT8VDZA/9+vXD+fPnkZaWpnQp5IYMBgP8/f2Rk5MDAJg4cSLi4+ORmpoKQRDQsWNHPPbYY/D19cXp06exYcMGFBQUSLevUaMGLl26hLi4ODz//PPQ6XTw8vJC79690bJlSxgMBhw7dgw7d+40e9zIyEhER0fL+lzJOfXu3Ru7du0CAFSpUgV37tyx+rYjR47E6tWrAQCVK1fG6dOnUbNmTbvUSa7nk08+wfTp06HX66XfeXp6omvXrmjZsiWCgoKQnZ2N06dPY9++fcjKygIAvPPOO3j33XcVqtpJKZ10iFxRVlaW6OHhIU6dOlXpUshNJScnmx2J8/DwEAGInTt3FhMSEixu/8gjj5jdZv78+dLtRo8eLV6/fr3I7datWycKgiDdplKlSmJBQYEMz5Cc3dSpU83a25UrV6y63f79+83a3KJFi+xcKbmSjz/+2KzdVapUSXz33XfFu3fvWtw+Ly9PjI6OFkNCQsSNGzfKXK3z4+ltiexgy5Yt0Gq1GDJkiNKlkJs6evSo2WWtVouIiAjs2bMHbdu2LbJ9ixYt8MEHH5j9bt68edBqtVi8eDFWrlxp8YjxsGHDMHr0aOnygwcPcP78eds8CXJppqeFB4ATJ06UehtRFDF16lRpXaRGjRrhjTfesEd55IK2bt2K6dOnS5dr166Nv/76C++88w4CAgIs3sbLywuRkZE4ceIEevfuLVepLoNBg8gONmzYgKpVq6J79+5Kl0Ju6siRI2aXw8LCsGrVqhLPKPX4448X+d2rr76KmTNnlvhYXbt2Nbt87969MlRK7qpw4LUmaKxevRoHDhyQLkdFRfFsQGSVu3fvYty4cTAYDAAAHx8fxMXFFQm8xfHy8oKPj489S3RJDBpENqbX67FlyxYMGDAAGg3PIE3KMA0agiDg22+/LTFkAA/HyZsKDg7GRx99VOpj+fv7m13mKb3JGi1atICHh4d02Xha+OLk5uZizpw50uXevXvj6aeftld55GLmz5+PGzduSJe/+OILtG/fXsGK3AODBpGN/fnnn7h9+zaGDh2qdCnkpkRRxLFjx6TL/fr1s+qo3dWrV80uv/LKK1aFhsuXL5tdrlu3brHb7t69G8899xzq1q0LLy8vBAcHY/DgwYiLiyv1cci1eHh4oHnz5tLl0no0Fi9eLLU1tVqNZcuW2bM8ciG3b9/G119/LV1u27Ytxo4dq1xBboRBg8jG4uLi4OHhgf79+ytdCrmp06dPmw1fGj58uFW3K/xFz9rbpaSkSP+vW7duseHkrbfeQq9evfDLL7/gypUrKCgowI0bN7Bp0yYMGzYML7zwgjSsgdyD6fCpkydPmp0FyNTVq1exePFi6fI///lPhIaG2rs8chE///wzcnNzpcvz5s3jAqMyYdAgsrENGzagZ8+exU4sc1cLFy5E+/bt4efnh+DgYIwbNw7p6elKl+WSCs/P6NGjh1W3M51AHhQUhJYtW5b5du3atbO4zZdffokPP/wQoiiiY8eO2LFjB27duoWEhARERkYCAH766SezoTHk+kx72vLy8oo9Hfibb76JBw8eAHg4xG/+/Pmy1EeuYcOGDdL/fX19MWDAAAWrcS8MGhUgCIJNfsh1nDx5EmlpaRw2ZcHevXsxbdo0HD58GOvXr0dKSgqee+45pctySaZf/P38/PDoo49adTvTgNKhQwerbpOXl4eTJ0+WeLs7d+7gX//6FwAgJCQE8fHx6NOnD6pVq4a2bdsiOjoazz//PABg6dKlOHPmjFWPTc7Pmgnhhw4dMlub5d1338Ujjzxi79LIhezfv1/6f+/eveHt7a1gNe6FQYPIhozjzHla26I2b96MUaNGoVmzZujUqROWLVuGXbt2SQshke2YBob27dtDpSr9o16n05l9yevYsaNVj5WYmAidTmf2eIX99NNPuHv3LoCHEzItDa1avHgx1Go1dDqd2Vhqcm2F5w5ZmhD+xhtvSKezbdasGV599VVZaiPXcPPmTbP9TNOmTRWsxv0waFSAKIo2+SHXsWHDBoSGhqJBgwZKl+LwMjIy4O3tzTMU2ZgoikhISJAuW9szkZKSYjaG2drbFV6vw1LQWL9+PYCHp4cs7ixBderUkU6vu27dOqsem5xfUFAQ6tSpI10u3KOxZs0a/PXXX9LlpUuX8mx+VCa3bt0yuxwcHKxQJe6JQYPIRjIyMrB//34Om7JCfn4+5s+fjzFjxvBLg42dPXvW7OhdeQNDeW5Xo0YN1KpVq8g2xh6W9u3blzhkwbgex7lz56QeEHJ9pr0apj0aubm5ePPNN6XLAwcO5Nh6KrP8/Hyzy9b08JLt8K9NZCMbN26EwWBg0CiFXq/HqFGjAABLlixRuBrXU3giuLWBwfR2QUFBqF+/vlW3Mw0alnozrl+/LgWfxo0bl3hfjRo1kv5vOu+DXJtp0EhLS5N61pYsWYJLly4BeHgq3KVLlypSHzm3wusDXblyRZlC3BSDhp0kJydj+vTp6NChA4KCguDl5YUGDRqgT58++Pjjj9nQXVBcXByCg4MRFhamdCmymDVrFgRBwI4dOyxeP2XKFAiCgD179ki/MxgMGDt2LFJTU7Ft2zb4+fnJVa7bMA0Mfn5+Vo9HLs9EcK1Wa3YE2tLtTM8sVqNGjRLvz/T6jIwMq2og52c6IdxgMCAlJQXXr183Wyzytddes/qkBkSmateubbZY6e+//65gNe6HQcPGcnJyMG7cOISGhmLp0qU4evQobt++jYKCAly8eBE7d+7EtGnTzM6gQc4vPz8f27dvx+DBg93mTGKtWrUCYL6GgtGFCxfw9ddfY9CgQdKpVUVRxPjx43HgwAFs374dgYGBstbrLgr3MFgzTECv1+P48ePSZWsngicnJ5sNS7DUo3H//n3p/6Wd6cXHx8fi7ci1WZoQPmfOHOTk5AAAHnnkEcybN0+J0sgF+Pj44LHHHpMuJyUl4eeff7b69qZz16jsGDRsKCcnB71798aKFSsAAM899xw2bdqEq1evIjMzE0ePHsWiRYtQr149dOrUSdliyaZ27tyJ+/fvu9XZpoyLZVka4jJv3jzodDosWrRI+t3EiROxYcMGKWTfuHEDN27cKHaBLiof06Bhbc9EamqqtEZBWW5nzURwU6WFcHcJ6WSuSZMmZieFWLlyJVauXCld/uCDD4oMfyEqi8JnKnvppZfw3XffFbv/ycvLw4YNG/DMM8/gww8/lKNEl8VZmDYiiiJGjBiBv//+G56envj1118xePBgs20CAwPRrl07vP7665yM5GLi4uJQqVIl9O3b16rtz507h8OHD+PQoUM4fPgwjhw5Iq3k/MMPP2Ds2LF2rNY2mjdvDrVaXaRH48SJE4iOjsbo0aOlXg8AWL58OQCgc+fOZtufP3+eZ+mykXPnzuHOnTvS5fLMzyjL7Qov8GdpXofp8LjSjgyaXs9hde5DpVIhNDQUBw4cAPDwwI1R69atMX78eKVKIxcRHh6O/v37Y+vWrQCABw8eYPz48XjnnXfwxBNPoG7duvD09ERGRgaSk5Nx+PBhqUfNuKAolQ+Dho2sWLEC27ZtA/DwC1XhkGHKdHgAuYaNGzeib9++Vr+2pU2KdQbe3t5o3LhxkR6NOXPmwMPDo8jKvTyVs/3Z4sxR5Z0IXtyK4KYLqxU+zWRhN2/eNKuD3Efbtm2loGFq2bJlUKvVClRErkQQBPzyyy8YMWIEtm/fLv3+6tWrpQ5lL+6zjazDw+o2oNPppFVve/XqhTFjxihcEcnp6NGjuHLlSrnONhUYGIh+/frh2WeftUNl9hcaGor09HRp4u6ff/6JTZs2YfLkyahXr57C1bkfOSeCGwwGJCYmSpeLGzZVq1Yt+Pv7A3h46t2SnDt3Tvp/8+bNraqDXEPheRoAMHz4cPTq1UuBasgVVa5cGdu2bcO3336LFi1alLitRqNB165d8cknn7jEgUElCSIPM1bYH3/8IQ2Z2bRpEwYOHKhwRSSnd999F/Pnz8f169dLPauO0S+//IKOHTtKp/OMj4+XdqjOMnQKePjc33vvPezZswfdu3fH448/jpSUFJw9e5aTvUnSu3dv7Nq1C97e3rh79y68vLwsbvfEE09g9+7daNSoUamhhIioIs6fP49Dhw7hxo0byM7OhpeXF4KCgtCkSRO0b9+ewzdthEOnbMB4qjQfHx/06dNH4WpIbnFxcejcubPVIQOA0/ZgFGZ65qnbt2/jr7/+wqJFixgyyMzTTz+NXbt2IS8vD+vWrcNzzz1XZJurV69i79690vZERPbUsGFDNGzYUOkyXB6HTtmAcUGhunXrFnukjlzT1atXkZCQ4LaL9BnPPJWUlIS33noLtWvXxuuvv65wVeRoRo8eLZ01aN68eWZnuDKaPXs29Ho9NBoNJk6cKHOFRERkDwwaNpCZmQng4cql5F7i4uIAwK1Oa2uqSZMm8Pb2xvfff4+UlBS89957PNkBFVG1alUsWLAAAHD69Gk88cQT2LVrFzIyMpCYmIhRo0ZJEzKnTZuGkJAQJcslIiIb4dApGwgICAAApKWlQafTQaPhn9VdxMXFoWHDhmancXUnarUazZs3R0JCAlq0aOE0c0tIfpMmTcKVK1ewaNEiHDp0CL179y6yzejRo3nOeiIiF8IeDRvo0qULgIerQ3/yySclbmtpyAAp68qVK+jWrRumT59eptvl5ORg165dbjtsyujo0aMQRRHJyck8DSWVaOHChdi1axciIiJQu3ZteHp6okaNGhg0aBDWrVuHlStXco0hIiIXwkPvNjB27Fh88MEHuHv3LubMmYOMjAw899xzqF+/PgoKCpCWloadO3di9erVWLFiRZEFy0g527dvR2RkJDIyMnD16lVERUVZfdtt27YhPz/f7YMGUVn07NkTPXv2VLoMIiKSAQ8d2UBQUBB+/fVXVKlSBVqtFosWLUK7du0QGBiImjVrolu3bpg3bx7S0tLQunVrpcslPFwDYP78+ejfv7+0BsSFCxfM1gUoTVxcHKpUqYIePXrYq8wyu3DhAgRBqNBPzZo1lX4aRERE5AIYNGykd+/eSEpKwptvvol27drB398fHh4eqFmzJtq1a4cpU6Zg27ZtnCjrIKZMmYLMzEx8/vnnZhNP169fb9XtDQYDNm/ejAEDBnBODhEREZEFXLCP3JJer5fmExw+fBhhYWEAgI4dO+LQoUOl3n7fvn3o1q0bVq9ejeeff77C9dhqwT6tVlvhhc40Gg2aNGlSofsgIiIi4qFYckumk5Y7duyIli1bIjk5GUeOHMHVq1dRu3btEm8fFxcHjUaDAQMG2LvUMvHw8ECzZs2ULoOIiIiIQ6eIAEgTukVRlNbGKElcXBx69OghLULmbio6D6SkHyIiInINDBpEAIYNGyb9v7R5GmlpaUhNTXXrs02Jomi3HyIiInINDBpEADp16oTg4GAAwK5du5CdnV3stsYeD3cOGkRERESlYdAgwsOhQEOGDAEAFBQUYOvWrcVuGxcXh1atWqFhw4blfryzZ8/iwIED0k9KSopV1zmzhQsXon379vDz80NwcDDGjRuH9PR0pcsiIiIiO+FZp4j+Z/PmzRg0aBAAIDIyEtHR0UW2uXPnDqpXr45Zs2ZhwYIF5X6ssWPH4scff7Rq2549eyI+Pr7cj+UoBg4ciMjISHTs2BHZ2dmYPHkyfH19sXPnTqVLIyIiIjvgWaeI/qdPnz7w8/PD/fv3sXnzZuh0uiJrZBh/b+z9IOtt3rzZ7PKyZcvQtWtXZGVlISAgQKGqiIiIyF44dIrof7y8vPDUU08BAO7evYs9e/YU2SYuLg41atRA586dK/RYK1assHpytCv0ZliSkZEBb29v+Pr6Kl0KERER2QGDBpEJ0wnehc8+pdVqsXXrVgwePJinYa2g/Px8zJ8/H2PGjOHK6kRERC6KQYPIxODBg6XF/AoHjd27dyM7O5tnm6ogvV6PUaNGAQCWLFmicDVERERkLwwaRCYCAwPRrVs3AMDFixdx/Phx6bq4uDj4+PigX79+SpXnkERRRHR0NPr27YvAwED4+Pjg0UcfxWuvvYbbt2+bbWswGDB27FikpqZi27Zt8PPzU6hqIiIisjcGDaJCilu8b8OGDejbty98fHyUKMsh5efnY+jQoRg1ahQuXbqE0aNHY+LEiahduza++uors2FRoihi/PjxOHDgALZv347AwEAFKyciIiJ74+ltiQo5d+4cGjduDABo3749jhw5gsTERLRp0wbLly/Hyy+/rHCFjmPkyJFYvXo15syZg/feew8eHh7SdSdPnkTz5s2lyxMmTMDatWuxadMm1KtXT/p9tWrVpOFqRERE5DoYNIgsCA0NRVJSEgDg8uXL+PHHH/H222/j2rVrqFmzpsLVOYbff/8dTz31VLFrjhRW3AT68+fPo0GDBjaujoiIiJTGoVNEFpgOn4qLi0NcXBzCwsIYMkx8+umnEATB6oULizt9L0MGERGRa2LQILLA9MxS33zzDQ4dOsSzTZkQRRE7d+5EmzZtGBSIiIjIIgYNIgvCwsJQq1YtAEBiYiJEUWTQMJGZmYnc3FyGDCIiIioWgwaRBYIgYMiQIdLlBg0aIDQ0VMGKHIvBYAAApKenK1wJEREROSoGDaJimM7TYG+GuerVq6Nu3bo4ePAgjhw5YnadXq/H2bNnFaqMiIiIHAWDBlExevfuLS0oZ9q7QQ/Nnz8fOp0Ojz/+OCIjIzF79myMHDkSdevWxerVq5Uuj4iIiBTG09sSlSAiIgLbt29Henq62RoR9NC6desQFRWFY8eOQafTITg4GD179sRbb72FkJAQpcsjIiIiBTFoEJXg0qVLyMzMRLt27ZQuhYiIiMipMGgQEREREZHNcY4GERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZHIMGERERERHZ3P8BRLukptk21NQAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "b2b17686", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model = model.prune(edge_th=5e-2)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bdd1a705", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d2e07789", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 3.15e-06 | test_loss: 1.99e-05 | reg: 2.74e+00 | : 100%|█| 100/100 [00:10<00:00, 9.48" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=100, lamb=0e-3);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6e8cfa58", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with 0\n", - "fixing (0,0,1) with 0\n", - "fixing (0,1,0) with x, r2=0.999998976626967, c=1\n", - "fixing (0,1,1) with 0\n", - "fixing (0,2,0) with 0\n", - "fixing (0,2,1) with x, r2=0.9999999998075859, c=1\n", - "fixing (0,3,0) with 0\n", - "fixing (0,3,1) with 0\n", - "fixing (0,4,0) with 0\n", - "fixing (0,4,1) with 0\n", - "saving model version 0.4\n" - ] - } - ], - "source": [ - "model.auto_symbolic()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a230671a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle 1.0 \\cdot \\left(0.000189505852432992 - \\frac{0.817980335069318}{\\sqrt{1 - \\frac{v^{2}}{c^{2}}}}\\right) \\left(- 1.22278885546569 m_{0} - 2.33019836537451 \\cdot 10^{-7}\\right)$" - ], - "text/plain": [ - "1.0*(0.000189505852432992 - 0.817980335069318/sqrt(1 - v**2/c**2))*(-1.22278885546569*m0 - 2.33019836537451e-7)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sf = model.symbolic_formula(var=input_variables)[0][0]\n", - "sf" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c8414225", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{m_{0}}{\\sqrt{1 - \\frac{v^{2}}{c^{2}}}}$" - ], - "text/plain": [ - "m0/sqrt(1 - v**2/c**2)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from kan.utils import ex_round\n", - "\n", - "nsimplify(ex_round(ex_round(ex_round(sf,6),3),3))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "151a6d23-a38f-439f-b9ec-30622f8b045c", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/.ipynb_checkpoints/Interp_9_different_plotting_metrics-checkpoint.ipynb b/tutorials/.ipynb_checkpoints/Interp_9_different_plotting_metrics-checkpoint.ipynb deleted file mode 100644 index 2cfaccaba..000000000 --- a/tutorials/.ipynb_checkpoints/Interp_9_different_plotting_metrics-checkpoint.ipynb +++ /dev/null @@ -1,151 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c982abca", - "metadata": {}, - "source": [ - "# Interpretability 9: Different plotting metrics" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d8f94f0f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cuda\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.48e-02 | test_loss: 1.53e-02 | reg: 7.01e+00 | : 100%|█| 20/20 [00:04<00:00, 4.64it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,5,1], device=device)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.fit(dataset, steps = 20, lamb=1e-3);" - ] - }, - { - "cell_type": "markdown", - "id": "2ec5f5b0", - "metadata": {}, - "source": [ - "Note: To plot the KAN diagram, there are also three options\n", - "* forward_u: the \"norm\" of edge, normalized (output std/input std)\n", - "* forward_n: the \"norm\" of edge, unnormalized (output std)\n", - "* backward: the edge attribution score (default)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "1c7c3c05", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='forward_u')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3bdd9213", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='forward_n')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8e92a57d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxN0lEQVR4nO3dfVhUdf4+8PsMg4iADiI+P4JoElqShgqYlopJmSGmmaWAfqttrXV78quWRWWm9k00yw0F0WoxlUxEwdVVBHxAUTNd8olEUdFURgUGhpn5/P5omZ+UKQOHOTPD/bourmvXefCeN3O6/Zxz5owkhBAgIiKSkUrpAERE5HhYLkREJDuWCxERyY7lQkREsmO5EBGR7FguREQkO5YLERHJjuVCRESyY7kQEZHsWC5ERCQ7lgsREcmO5UJERLJjuRARkexYLkREJDuWCxERyU6tdAAieyCEwLVr11BaWgp3d3d4eXlBkiSlYxHZLK5ciO5Cq9UiLi4Ofn5+8Pb2Rrdu3eDt7Q0/Pz/ExcVBq9UqHZHIJkn8JkqiO8vIyMDYsWNRXl4O4LfVS7XqVUuzZs2wYcMGhIWFKZKRyFaxXIjuICMjA+Hh4RBCwGQy/en9VCoVJElCWloaC4boNiwXot/RarXo2LEjdDrdXYulmkqlgqurK4qKiqDRaBo+IJEd4DEXot9JSkpCeXl5rYoFAEwmE8rLy7F69eoGTkZkP7hyIbqNEAJ+fn4oKCiAJZuGJEnw8fHBqVOneBYZEVguRDVcvXoV3t7e9Xq8l5eXjImI7BN3ixHdprS0tF6Pv3XrlkxJiOwby4XoNu7u7vV6vIeHh0xJiOwby4XoNl5eXvD19bX4uIkkSfD19UXLli0bKBmRfWG5EN1GkiRMnz69To999dVXeTCf6L94QJ/od/g5F6L648qF6Hc0Gg02bNgASZKgUt19E6n+hH5KSgqLheg2LBeiOwgLC0NaWhpcXV0hSdIfdndV/5mrqyu2bNmCESNGKJSUyDaxXIj+RFhYGIqKirB48WL4+PjUuM3HxweLFy/GhQsXWCxEd8BjLkS1IITAzp078dhjj2HHjh0YOnQoD94T3QVXLkS1IEmS+ZiKRqNhsRDdA8uFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4XoHqqqqnDhwgXk5+cDAM6cOYPr16/DZDIpnIzIdvFrjon+hFarxYYNG/DNN9/g+PHjuHXrFvR6PZo2bQpvb2+EhoYiJiYGwcHBUKvVSsclsiksF6I72Lt3L2bMmIGjR4+if//+CA8PR58+feDu7g6tVou8vDykpqbi9OnTGD9+PD788EN4e3srHZvIZrBciH5n27ZtmDJlCtzd3fHxxx9j1KhR0Ov1SE5ORmVlJZo3b44JEyagqqoKycnJeO+993D//fdjzZo1aNOmjdLxiWwCy4XoNidPnsTIkSPh5uaG5ORk+Pv7Q5IkFBQUIDAwEDdu3EC3bt2Ql5cHT09PCCGQnZ2NiRMnYsiQIVixYgVcXFyUfhlEiuMBfaL/MhqNmDdvHkpKSvD555+bi+VuJElCSEgIFixYgB9++AHp6elWSktk21guRP91+vRppKamIiIiAiEhIfcslmqSJGHMmDEYMGAA4uPjYTAYGjgpke3jKS5E/7Vnzx6UlpZi7NixOHv2LMrKysy3FRUVwWg0AgD0ej2OHz+O5s2bm29v3749IiIi8N5776G4uBgdO3a0en4iW8JyIfqvn3/+Gc2aNYOPjw9efPFF5OTkmG8TQqCyshIAcPHiRQwfPtx8myRJ+PTTT9G7d2+Ul5fj4sWLLBdq9FguRP+l0+mgVqvh4uKCyspKVFRU3PF+Qog/3GYwGODq6lqjhIgaM5YL0X+1bt0aOp0OWq0WQUFBcHNzM9+m0+mwZ88ec4kMGjTI/MFJSZLQuXNnXLlyBSqVCp6enkq9BCKbwXIh+q+HHnoIer0eubm5+OSTT2rcVlBQgP79++PGjRto06YN1q5dC41GY75dkiTMmjULbdu25S4xIvBsMSIAwJEjR7Bs2TJUVVUhMTERZWVlcHJyqvFTTZIkqFQq85+rVCpcunQJ69evR3h4OFq0aKHgKyGyDSwXatQOHz6Mp59+GoGBgThx4gQmTZqEI0eOYMmSJbU+pbiyshIffPABdDodXnzxxVqfwkzkyLhbjBqlvLw8xMbGIjU1Fd27d8eqVaswceJEVFZWQq/X45NPPkGzZs3w8ssvo2nTpgAAtVoNtVptXsUIIXDr1i189NFHSE5OxmeffYaePXsq+bKIbAYv/0KNysGDBxEbG4vNmzejR48emD17Np599tkaVzX+9ddf8corr2Dz5s0ICwvDjBkz0KtXL5w4cQImkwlNmjRB9+7dkZubi0WLFuHIkSOIjY3Fyy+/XGP3GVFjxnKhRiE3NxexsbHYsmULevbsiTlz5mDChAl/WgZlZWWIj4/HkiVLcPnyZfj4+MDPzw8eHh4oKSnBiRMncPHiRTz00EOYO3cuHnnkEahU3MtMVI3lQg5t//79iI2NxdatW3HffffhnXfewTPPPFPrFUZxcTF27NiBzMxMFBQUoKKiAp6enggICMCIESMQFBSEZs2aNfCrILI/LBdySHv37kVsbCwyMjLg7++POXPmYNy4cfXabWU0GiGEgEql4iqF6B64hZBDycnJQVhYGIKDg1FUVITk5GQcPXr0rrvAasvJyQlqtZrFQlQL3ErIIWRnZ2PEiBEIDQ3FpUuX8N133+HHH3/EM888wzIgUgC3OrJru3fvxrBhwzB48GBcuXIF69atw5EjRxAZGclSIVIQtz6yS7t27cKjjz6KIUOG4Pr169iwYQMOHTqEsWPHslSIbAC3QrIbQgjs3LkTQ4cOxaOPPoobN27g+++/R15eHp5++mmWCpEN4dZINk8IgR07dmDIkCF47LHHcOvWLWzcuBEHDx7EU089xcutENkglgvZLCEEtm/fjsGDB2P48OHQ6XTYtGkTDhw4gNGjR7NUiGwYy4VsjhAC27ZtQ2hoKEaMGAG9Xo/Nmzdj//79eOKJJ1gqRHaA5UI2QwiB9PR0BAcHY+TIkTAajUhLS8O+ffswatQolgqRHWG5kOKEENi6dSsGDRpkLpGtW7diz549ePzxx1kqRHaI5UKKEUIgLS0NAwYMQHh4OJycnJCRkYHs7GyEhYWxVIjsGMuFrE4IgdTUVAQFBeHJJ5+Ei4sLtm3bhqysLAwfPpylQuQAWC5kNUIIbNq0Cf3798dTTz2FZs2aYfv27cjMzMSwYcNYKkQOhOVCDU4IgY0bN6Jfv34YM2YMPDw88O9//9v8KXuWCpHjYblQgzGZTEhJSUFgYCAiIiKg0Wiwc+dO7Ny5E0OGDFE6HhE1IJYLyc5kMmHDhg0IDAxEZGQkWrVqhczMTOzYsQOPPPKI0vGIyApYLiQbk8mEdevW4cEHH8S4cePQunVr7N69G//6178QGhqqdDwisiKWC9Wb0WjE2rVr8cADD2D8+PFo3749srOzsW3bNoSEhCgdj4gUwHKhOjMajUhOTkafPn3w7LPPolOnTsjJyUF6ejoGDRqkdDwiUhDLhSxmNBrx7bffonfv3pg4cSK6du2KvXv3YsuWLRg4cKDS8YjIBrBcqNYMBgO+/vprBAQEYNKkSfD19cW+ffuQlpaGoKAgpeMRkQ1hudA9GQwGrFmzBvfffz9eeOEF+Pn5Yf/+/UhNTcXDDz+sdDwiskEsF/pTBoMBSUlJ8Pf3x+TJk9GrVy8cOHDA/Cl7IqI/w3KhP6iqqkJiYiJ69eqFqKgoBAQEIC8vDxs3bsRDDz2kdDwisgNqpQOQ7aiqqsKaNWswb948FBQU4OmnnzZ/boWIyBIsF0JVVRWSkpLw8ccf45dffsHYsWORkpKCPn36KB2NiOwUy6UR0+v1WLVqFT7++GMUFhZi3Lhx2LhxI3r37q10NCKycyyXRkiv1yMxMREff/wxzp8/j3HjxiE1NRUBAQFKRyMiB8ED+o3QggUL8Je//AWDBg3CTz/9hOTkZBYLEclKEkIIpUNQ/aSkpMBgMMDZ2blB/x6TyYSxY8c26N9BRI6Bu8UcwL59+3Dw4EHExsZiwIABDfb3zJw5k+VCRLXCcnEQQUFBiIqKwqlTp5SOQkTEYy6OYu7cuSgoKAD3chKRLWC5OIimTZvC1dUVqampSkchImK5OJK4uDhER0crHYOIiOXiSKKiolBSUoKbN28qHYWIGjmWiwNRqVQIDQ3FlClTlI5CRI0czxZzMOvWrUPbtm1hMBigVvPXS0TK4MrFwbRq1QrdunXD7NmzlY5CRI0Yy8XBSJKErVu34tNPP4Ver1c6DhE1UiwXB9S9e3cEBATgpZdeUjoKETVSLBcHJEkSMjIykJSUhHPnzikdh4gaIZaLg2rTpg1ee+01DB06FCaTSek4RNTIsFwc2MKFC2EwGPDWW2/xsjBEZFU8V9WBOTk5ITMzE7169UJQUBAiIyMhSZLSsYioEeDKxcF17doV69evxwsvvICdO3dyBUNEVsFyaQRGjRqFL7/8EqNHj8bWrVtZMETU4FgujYAkSZg8eTK+/PJLTJgwAcuXL+dBfiJqUDzm0khIkoRJkyahQ4cOeOGFF5CTk4OFCxeibdu2PA5DRLLjyqURkSQJjz76KPbu3YvS0lIMHDgQX331FW7evMldZUQkK5ZLI9SpUyesX78eCxcuxPLlyxESEoK4uDgUFhbCaDQqHY+IHADLpZFSq9WIjIzE7t278dZbb2HTpk0YMmQIJkyYgMTEROTn56OsrAwmk4mrGiKyGI+5NGKSJMHDwwOTJk3CM888g2PHjiEtLQ1JSUn46KOPoNFo0KtXLzzwwAPo1auX0nGJyI6wXBxERUVFvZ/D398f/v7+eO2113Dx4kUcP34chw8fRnZ2Nr777jsMHjxYhqRE1BhIgvs87N6WLVtgMBga7PlNJhP0ej3c3NwQHh7eYH8PETkOlosDsOavkKctE1Ft8IC+A5AkyaIfnU6Hw4cPQ6fTWfxYIqLaYLk0Qj///DP69euHn3/+WekoROSgWC5ERCQ7lgsREcmO5UJERLJjuRARkexYLkREJDuWCxERyY7lQkREsmO5EBGR7FguREQkO5YLERHJjuVCRESyY7kQEZHsWC5ERCQ7lgsREcmO5UJERLJjuRARkexYLkREJDuWCxERyY7lQkREsmO5EBGR7FguREQkO5YLERHJjuVCRESyY7kQEZHsWC5ERCQ7lgsREcmO5UJERLJjuRARkexYLkREJDu10gHqQwiBa9euobS0FO7u7vDy8oIkSUrHsmlCCJSUlAAASkpKIITgzGqB7zXLcWZ14yhzs8uVi1arRVxcHPz8/ODt7Y1u3brB29sbfn5+iIuLg1arVTqizbl9ZsOGDYMQAsOGDePM7oHvNctxZnXjcHMTdiY9PV24ubkJSZKEJEkCgPmn+s/c3NxEenq60lFtBmdWN5yb5TizunHEudlVuaSnpwsnJyehUqlqDP/3PyqVSjg5OdnVL6KhcGZ1w7lZjjOrG0edmySEEHKvhhqCVqtFx44dodPpYDKZ7nl/lUoFV1dXFBUVQaPRNHxAG8SZ1Q3nZjnOrG4ceW52c8wlKSkJ5eXltfoFAIDJZEJ5eTlWr17dwMlsF2dWN5yb5TizunHkudnFykUIAT8/PxQUFMCSuJIkwcfHB6dOnbLLsy3qgzOrG87NcpxZ3Tj63OyiXK5evQpvb+96Pd7Ly0vGRLaPM6sbzs1ynFndOPrc7GK3WGlpab0ef+vWLZmS2A/OrG44N8txZnXj6HOzi3Jxd3ev1+M9PDxkSmI/OLO64dwsx5nVjaPPzS7KxcvLC76+vhbvX5QkCb6+vmjZsmUDJbNdnFndcG6W48zqxtHnZhflIkkSpk+fXqfHvvrqqzZ90KuhcGZ1w7lZjjOrG0efm10c0Acc+3zwhsKZ1Q3nZjnOrG4ceW52sXIBAI1Ggw0bNkCSJKhUd4+tUqkgSRJSUlJs/hfQkDizuuHcLMeZ1Y1Dz83alwSor9pegycjI0PpqDaDM6sbzs1ynFndOOLc7K5chBCipKRExMXFCV9f3xq/BF9fXxEXFye0Wq3SEW0OZ1Y3nJvlOLO6cbS52WW5VDOZTGLHjh0CgNixY4cwmUxKR7J5nFndcG6W48zqxlHmZjfHXO5EkiTzvkeNRmPzZ0/YAs6sbjg3y3FmdeMoc7PrciEiItvEciEiItmxXIiISHYsFyIikh3LhYiIZMdyISIi2bFciIhIdiwXIiKSHcuFiIhkx3IhIiLZsVyIiEh2LBciIpIdy4WIiGTHciEiItmxXIiISHYsFyIikp3dlktpaSlOnjyJn376CQBQXFwMvV6vcCrbV1paisLCQgBAfn4+zp8/z7ndQ1VVFS5cuID8/HwAwJkzZ3D9+nWYTCaFk9k2vtcs50j/XZOEEELpEJYoKCjAihUrsGnTJpw/fx5VVVWorKxE8+bN0bdvX0yePBkRERHw8PBQOqpNuX1uhYWF0Ol0aNKkCdzc3NC7d2/O7Q60Wi02bNiAb775BsePH8etW7eg1+vRtGlTeHt7IzQ0FDExMQgODoZarVY6rs3ge81yjvjfNbspF6PRiH/+85+YNWsWdDodHn/8cQwfPhydO3eGyWTC6dOnsXXrVuzcuROBgYFYunQp/P39lY6tOM6tbvbu3YsZM2bg6NGj6N+/P8LDw9GnTx+4u7tDq9UiLy8PqampOH36NMaPH48PP/wQ3t7eSsdWFN9rlnPomQk7YDQaxbJly4Sbm5t4/PHHxY8//igMBoPYs2ePiIuLE3FxcSI/P1/o9XqRmZkp+vXrJ3r27Cl++uknpaMrinOrm4yMDNGuXTvh5+cn1q9fL8rLy4VWqxXLly8XcXFxIjExUeh0OnHz5k3x1Vdfifbt24vhw4eL4uJipaMrhu81yzn6zOyiXHbu3Ck0Go2IjIwU169fFyaTSQghxJw5cwQAAUCsWbNGCCGEyWQShYWFYtCgQSIkJESUlJQomFxZnJvlTpw4Ibp16yYCAgLEsWPHzDM7c+aMaNGihQAgunXrJq5fvy6E+G1uu3fvFh07dhSTJk0SFRUVSsZXDN9rlnP0mdn8AX2dTofY2Fi0adMGn332GTQaDSRJ+tP7S5KETp06YenSpTh58iS+/vprK6a1HZyb5YxGI+bNm4eSkhJ8/vnn8Pf3v+vMgN/mFhISggULFuCHH35Aenq6ldLaDr7XLNcYZmbz5ZKXl4d9+/bhL3/5Czp06HDPjR347Rfx4IMP4plnnsGqVatQXl5uhaS2hXOz3OnTp5GamoqIiAiEhITUambAb3MbM2YMBgwYgPj4eBgMhgZOalv4XrNcY5iZzZ/ismvXLri4uGDYsGHIz8+vseFevnzZ/L/PnTuHo0ePmv+/RqPBmDFj8PXXX+Ps2bP2cxBMJpyb5fbs2YPS0lKMHTsWZ8+eRVlZmfm2oqIiGI1GAIBer8fx48fRvHlz8+3t27dHREQE3nvvPRQXF6Njx45Wz68Uvtcs1yhmpvR+uXuZNGmS6NGjhzh58qTo3LmzaNq0qflHrVab9006OzvXuC0qKkr88ssvolWrVmLr1q1Kvwyr49ws99ZbbwmNRiPy8/PFY489VmMuLi4u5plJklTjNldXV/HFF1+IrKws4eHhIfbv36/0S7Eqvtcs1xhmZtMrFyEEKioq4OLiAicnJ1RUVKCiouKO962qqkJVVZX5/+v1ejRp0sT8uMaEc6sbnU4HtVoNFxcXVFZW/unrr57v7QwGA1xdXSGEQGVlpTXi2gS+1yzXWGZm0+UiSRJatWqF3NxcGI1GDB06FFqt1nz7qVOnUFBQAADo3bs32rdvb76tT58+0Gq1qKysRMuWLa0dXVFyzE2n09X6mIOjaN26NXQ6HbRaLYKCguDm5ma+TafTYc+ePeYSGTRokPmDk5IkoXPnzrhy5QpUKhU8PT2VeglWx23Uco1mZkoum2ojPj5euLq6it27dwuDwVDjZ9asWeblY1JSUo3bjEajWLVqlWjbtq0oKipS+mVYXX3n5uzsLHr27CkiIiLE//3f/4nc3FxRVVWl9MtqUFu2bBFNmjQRy5cv/8PMTp48aT4VuWvXruLq1at/mNvbb78tevToYRenicqJ26jlGsPMbP5ssUcffRQeHh5ISkqCEAJOTk7mH5Xq/8dXqVQ1bquoqMDq1asREhKCtm3bKvgKlDF06FA4OzvXeW6jRo3CwoULcd9992Hjxo2Ijo5GSEgI/va3v2H9+vUoLi5W8NU1jIcffhg+Pj5ISkpCWVlZjbk4OTmZ7ydJUo25qVQqXLp0CevXr0d4eDhatGih4KuwPm6jlmsMM7P5cunatSuee+45fPfdd8jIyICoxdVqTCYTVq1ahcOHD2P69Ok1/sPQGFy4cAGvvfYabt68ibVr19Zpbn//+9/x5JNP4qOPPsLOnTuxdu1aREdH4/r16/jggw8wfPhwPP3001i0aBH2799vtxfXu52Xlxf++te/4tChQ1iyZEmtTymurKzEBx98AJ1OhxdffLHR7U7kNmq5RjEz5RZNtXfp0iXRv39/0alTJ7F9+3ZhNBqFEEK8++67Qq1WC2dnZ/H1118Lk8kkqqqqxJo1a0SrVq3ErFmzhMFgUDi99ZhMJpGYmCg8PT1Fhw4dRFJSUoPM7caNGyI9PV3MmTNHDB06VAQEBIj+/fuLv/71ryI5OVlcuHDBWi9ZdqWlpeKZZ54R7u7u4tNPPxXl5eXCZDKJM2fOCC8vL6FWq0X37t3Nn6i+ceOGeOutt0SLFi1EQkKC0vEVw23Uco4+M7soFyGEOH78uAgMDBQtW7YUs2fPFqdPnxYnT54Uu3btErt27RKFhYXi6NGj4qWXXhItWrQQr7zyiigrK1M6ttWcO3dOPP7440KlUokpU6aYL0/S0HMzmUwiPz9frFixQkyePFn06dNHBAQEiCeeeEJ88sknIicnx+4uiXLlyhUxbtw44erqKsaMGSMyMzPFlStXRFZWlsjMzBR79+4Vv/76q0hLSxNDhw4Vnp6eYunSpXaxwTckbqOWc+SZ2c1VkYHfdvd88MEHWLt2LdRqNfz9/dGpUycYjUacPXsWJ06cgJeXF95++208//zzcHFxUTpygxNCICEhAW+88QY8PDywfPlyjBo1qsZ9rDm30tJS7Nu3D9nZ2cjKysKVK1fg4uKChx9+GKGhoQgODkbnzp3r+7IbXFlZGeLj47FkyRJcvnwZPj4+8PPzg4eHB0pKSnDixAlcvHgRDz30EObOnYtHHnmkxr7yxorbqOUcdWZ2VS7Ab9d/ys/PR1paGnJzc3HlyhU4OzujW7duGDp0KEaMGIHWrVsrHdMqzp07h2nTpmH79u2IiorCokWLoNFo7nhfJeYmhMCZM2eQlZWF7OxsHDp0CAaDAZ07d0ZISAhCQ0PRr18/NG3aVNa/V07FxcXYsWMHMjMzUVBQgIqKCnh6eiIgIAAjRoxAUFAQmjVrpnRMm8Jt1HKOODO7K5fbCSFgNBohSZLtH9ySkRAC8fHxePPNN6HRaPDVV18hLCzMoscrMbeysjLk5uaay+bSpUtwcXFBv379EBwcjNDQUHTp0sVmD4gbjUYIIaBSqbhKqaXGuo3Wh6PMzK7LpTH65ZdfMG3aNOzcuRPTpk3DggULalzjyl4IIfDLL78gOzsb2dnZOHjwIKqqqtChQweEhIQgJCQEQUFBcHV1VToqEdUBy8VOmEwmLF++HDNnzoSXlxfi4+MxbNgwpWPJRqfTITc3Fzk5OcjKykJRURGcnZ0RGBiI0NBQhISEwMfHx2ZXNURUE8vFDpw5cwbTpk1DZmYmXnrpJcyfP9+uvkvbUkIInDt3zryqOXDgACorK9GuXTvz7rPfX56FiGwLy8WGmUwmLFu2DLNmzUKbNm0QHx+PoUOHKh3L6iorK3HgwAFz2RQWFsLJyQmBgYHmEwO6d+/OVQ2RDWG52KhTp05h2rRpyMrKwiuvvIJ58+bB3d1d6Vg24fz58+ai2b9/PyorK9G6dWvzsZqBAwdyVkQKY7nYGKPRiKVLl2LOnDlo37494uPj8cgjjygdy2ZVVlbi0KFD5rIpKCiASqXCgw8+aP5czX333cdVDZGVsVxsyIkTJxATE4N9+/Zh+vTp+PDDD3lcwUIXL140F82+ffug0+nQqlUrBAcHIyQkBIMGDbLLs+uI7A3LxQYYjUZ89tlnmDt3Ljp16oQVK1YgJCRE6Vh2r6qqqsaq5vTp01CpVOjTp495F1qvXr34mRWiBsByUVh+fj5iYmKQm5uLGTNm4P333+cnvhtIcXExsrOzkZOTg71796KsrAyenp7mM9AGDhzYqL7oi6ghsVwUYjAY8Omnn+L9999H165dsXLlSgwcOFDpWI2GwWDAkSNHzKuaEydOQJIk9O7d27wLLSAggKsaojpiuSjg2LFjiImJwaFDh/D6669j7ty5/CS6wq5cuYI9e/YgKysLe/bsQWlpKTQaDQYNGoSQkBAEBwfb/tfKEtkQlosVVVVVYeHChYiNjYWfnx9WrFiBoKAgpWPR7xiNRhw9etR8Zef8/HwAgL+/v/lqAb1797br6z4RNTSWi5UcPXoU0dHROHr0KN5880288847Nn01YPr/rl27hpycHGRnZ2PPnj24ceMGmjdvjoEDByI0NBSDBg2Ct7e30jGJbArLpYHp9XrMnz8f8+bNQ8+ePbFy5Ur069dP6VhURyaTCceOHTNf2fn48eMQQuC+++4zn4H2wAMPQK1WKx2VSFEslwZ05MgRREdH49ixY/jf//1fzJo1y26+6Idqp6SkpMaxmpKSEri7u2PgwIHmEwPatGmjdEwiq2O5NAC9Xo+PPvoI8+fPx/3334+VK1eib9++SseiBmYymfCf//zHfAbaTz/9BJPJBD8/P/Oqpm/fvnB2dlY6KlGDY7nILC8vDzExMcjPz8fs2bMxc+ZMNGnSROlYpACtVou9e/eaj9dcu3YNzZo1Q1BQkPnEgHbt2ikdk6hBsFxkUllZiQ8++AALFixAnz59sHLlSjzwwANKxyIbYTKZcOLECfOq5siRIzCZTPD19TV/iDMwMJD/ECGHwXKRwYEDBxAdHY1Tp07hnXfewVtvvcVdH3RXt27dwt69e81XDLhy5QqaNm2KoKAg89cIdOjQQemYRHXGcqmHiooKvP/++1i0aBH69u2LlStXonfv3krHIjsjhMCpU6fMn6s5fPgwjEYjunTpYt591q9fP54MQnaF5VJH+/btQ0xMDAoKCvDee+/h9ddf5+mnJIvS0lLs37/fXDaXL1+Gi4sL+vfvb/4agS5duigdk+iuWC4W0ul0ePfdd7F48WL069cPK1euhL+/v9KxyEEJIXDmzBnzsZq8vDwYDAZ06tTJfAbaww8/zA/kks1huVggJycHU6dORWFhIWJjY/G3v/2NqxWyqvLycvOqJjs7GxcvXkSTJk3Qr18/84kBXbt25ZejkeJYLrVQXl6OOXPmYMmSJRgwYABWrFiB++67T+lY1MgJIXD27FlkZWUhJycHBw8ehF6vR/v27c2rmqCgIH6FAymC5XIPu3fvxtSpU3HhwgV8+OGHePXVV3nBQrJJOp0OBw4cMK9qzp8/D2dnZwQGBprLxtfXl6sasgqWy58oKyvDrFmz8PnnnyMkJATx8fHo0aOH0rGIaq2wsBA5OTnIysrCgQMHUFlZibZt29ZY1bi7uysdkxwUy+UOdu3ahalTp6K4uBgff/wxXnnlFX5pFNm1yspKHDx40HwGWmFhIZycnNC3b1/zGWg9evTgqoZkw3K5za1btzBz5kwsX74cgwcPRnx8PLp37650LCLZFRUVmXef7d+/HxUVFWjdurX5YpsDBw6Eh4eH0jHJjrFcbjNt2jSsXbsW8+fPx0svvcTVCjUKer0ehw4dMn+NQEFBASIjIzF37lylo5Edc+hysfSlVd+/LrsGuDuBbJWl20FVVRUA1OkSRtwOqJpDf0jj+++//9M3e2VlJdRqtSxnfplMJowdO7bez0PUEHbs2GHRf/RNJhP0ej2aNGli0erdZDJh+PDhdYlIDsihy2Xfvn2YN29ejT8TQuDLL7/EmjVr0Lp1a8TFxaFr1671+ntmzpzJciGb9eOPP+K111675/2EENi1axdSUlJw9epVtG7dGpGRkQgJCalVOS1evJjlQmYOXS4A/vAJ+sWLFyM2Nhb/+Mc/kJmZiUceeQRnz57lVYzJod3rShJCCHzyySfYunUrXnjhBfTs2RP5+fmYO3cuxowZgxkzZnCXF1nE4cvldlevXsUbb7yB3NxcBAYGYuzYscjOzsaLL76IhIQEpeMRKUIIgc8++wwZGRlYvXo1OnfuDEmSEBwcjMceewxTpkxB06ZN8fLLL7NgqNYa1elQTzzxBCIjI81fOaxSqZCeno6kpCTo9XqF0xEp49ChQ1izZg1Wr16NLl26mAtEkiT4+Phg1apViI+Px3/+8x+Fk5I9aTTlcvPmTRw4cACrVq2q8a+vtm3bwtfXF7Nnz1YwHZEyjEYjXnnlFbz77rvo1KnTHe/j4+ODN998E//zP/8Dk8lk5YRkrxpNucTExCA4OPiOlyb//vvvsXjxYotP2SSyd1988QU8PDwwZsyYu97v2WefhbOzM5KSkqwTjOxeoygXIQRSUlLw3Xff3fF2f39/8/dmEDUWBoMBK1aswFdffXXPYymSJGH58uWIi4uD0Wi0UkKyZ42iXA4ePAi1Wo02bdrc8XZJkvDcc89h4sSJVk5GpJwvvvgC7dq1q/Wp+D179oSnpydWr17dsMHIITSKcnnuuefw2muv3fVfZ0uXLkVeXh53jVGjIIRAQkICli1bVuszwCRJwtKlS7FkyRJuJ3RPDl8u1bu73n///bvez8PDA05OTjh27JiVkhEpJycnB87OzvDx8bHocffffz8kScLhw4cbKBk5CocvlxMnTkClUt3zO8YlScKUKVPw/PPP1/q5hRA8hZns0syZM/H2229b/LkVSZIwffp0vPHGGw2UjByFw5fL1KlTMXbs2FptRIsWLcJPP/1U6yV/Xl4eRo0aVd+IRFZVUVGBmzdvIiIiok6Pf/7553H16lXzBS6J7sThy2XkyJGIi4ur1X09PDygUqlw6tSpWt3/xRdfRJcuXeoTj8jqFi9ejK5du9b5KyXUajXatWuH+Ph4mZORI3H4cpk9ezZat25dq/tKkoTx48fjhRdeuOd9hRA4cuQIFixYUN+IRFYjhMDatWuxaNGiej3PggULsGLFCh7Ypz/l8NcWs3Sf8tKlS9GqVSsIIe76WK1WCwBo2bJlfeIRWVVZWRmMRiP8/Pzq9Tx9+vSBwWBARUUFXF1dZUpHjsThVy6W0mg0tdo19uqrr6J///68kB/ZlYULF6Jnz571ft9KkoTOnTtj2bJlMiUjR8Ny+R1JkvD888/f9QOVQggkJydjzZo1VkxGVH+bNm36w3cc1dW8efPw7bffyvJc5HgcfrdYXcTFxUGj0fzprrHz589DCIHu3bsrkI6obqqqqmA0GmV73/bu3RsGgwEGg+Ge3xdDjQ9XLnfg7u4ONzc3pKSk3PH2yMhITJw4kbvEyK4kJyejZcuWsr1vJUmCh4cHNm/eLMvzkWNhudyBJEn4xz/+gZiYmD+cDaPT6ZCXl4cvv/xSoXREdbNs2TLMnDlT1uecMWMGPv30U1mfkxwDy+VPTJgwAWVlZTUucyGEwOTJkzFgwAC4ubkpmI7IMkIIlJeXy/4d90899RRu3LjBU5LpD7ij9E9IkoT58+dj1KhROH/+PNRqNfLy8pCSkoIrV64oHY/IIoWFhVCpVHBycpL1eZ2dnSFJErcJ+gOuXO7i73//O9q0aYPIyEisXr0aw4cPx2effcbPtpDdmTdvHoKDgxvkuR988EHMnz+/QZ6b7JfDr1wqKirq9fht27bh9ddfR3x8PD766CNER0fX+zmJrM3b2xsxMTGorKyU/bnffvvtWl9iiRoPSTjwztItW7bAYDDU+3mEEDAYDHB2dr7j7U5OTggPD6/330PUELKysizaDvR6PdRqtUXXHjOZTHB2dsbgwYPrEpEckEOXi6UvzWQyQQgBlUpVp0uRE9kiS7YDIQTOnj0LJycndOjQweJjNNwOqJpDH3ORJMmin5s3byI4OBht2rTBkSNHLHoska2y5H2sUqlQVVWFSZMmYeLEibh58ya3A6oThy4XS3l6eiIjIwO+vr4YPnw4Dh06pHQkIqvr2bMnVq5cieLiYkybNg03btxQOhLZIZbL72g0GmRkZMDPzw8jRoxAXl6e0pGIrK5Hjx7mgpk6dar5KuBEtcVyuYMWLVogPT0dPXr0wIgRI3Dw4EGlIxFZnZ+fHxISEnD58mVMnToVJSUlSkciO8Jy+RPVBdOrVy+MGDECBw4cUDoSkdV1794dCQkJ+PXXX1kwZBGWy100b94cW7Zswf3334+wsDDk5uYqHYnI6qoL5urVq4iJiWHBUK2wXO6humACAgIQFhaG/fv3Kx2JyOp8fX2RkJCA69evIzo6GtevX1c6Etk4lksteHh4IC0tDX369EFYWBj27dundCQiq/P19UViYiK0Wi1iYmJYMHRXLJdaqi6YBx98ECNHjsTevXuVjkRkdd26dUNCQgK0Wi2io6Nx7do1pSORjWK5WMDd3R2bN29G3759MXLkSOTk5CgdicjqunXrhsTERNy8eRPR0dG4evWq0pHIBrFcLFRdMA899BBGjRqF7OxspSMRWV3Xrl2RmJiI0tJSFgzdEculDtzc3JCamop+/fph1KhRyMrKUjoSkdV16dIFCQkJKCsrQ3R0NH799VelI5ENYbnUUXXBPPzwwwgPD8fu3buVjkRkdV26dEFiYiLKy8sRFRXFLw0jM5ZLPTRr1gybNm1CUFAQwsPDkZmZqXQkIqvr3LkzEhMTUVlZiejoaBYMAWC51Ft1wQwcOBBPPPEEC4YapU6dOrFgqAaWiwxcXV3xww8/YNCgQQgPD8fOnTuVjkRkdR07dkRiYiL0ej2ioqJw+fJlpSORglguMnF1dcXGjRsRGhqKJ598Ev/+97+VjkRkddUFYzAYEBUVheLiYqUjkUJYLjJydXXF999/j8GDB+PJJ5/Ejh07lI5EZHUdOnRAYmIijEYjoqKicOnSJaUjkQJYLjJr2rQpUlJSMGTIEIwePRrbt29XOhKR1bVv3x6JiYkwmUyIiorCxYsXlY5EVsZyaQDVBfPoo49i9OjR+Ne//qV0JCKra9++PVatWgUALJhGiOXSQFxcXLB+/XoMGzYMTz31FLZt26Z0JCKra9euHVatWgWVSsWCaWRYLg3IxcUF69atw/DhwzFmzBikp6crHYnI6tq2bYvExEQ4OTkhKioKFy5cUDoSWQHLpYFVF0xYWBiefvppbN26VelIRFZXXTBqtRpRUVEoKipSOhI1MJaLFTRp0gRr167F448/joiICGzZskXpSERW16ZNGyQmJqJJkyYsmEaA5WIlTZo0QXJyMkaNGoWIiAhs3rxZ6UhEVte6dWskJCTAxcUFU6ZMwfnz55WORA2E5WJF1QXz5JNPIjIyEqmpqUpHIrK66oJxdXXFlClTcO7cOaUjUQNguViZs7Mzvv32W4wePRrjxo3Dpk2blI5EZHXVBePm5oaoqCgUFhYqHYlkxnJRgLOzM7755hs89dRTGDduHDZu3Kh0JCKr8/b2NhdMdHQ0C8bBsFwUUl0wERERGD9+PL7//nulIxFZXatWrZCYmAgPDw9ERUXh7NmzSkcimbBcFKRWq7FmzRqMHTsWEyZMQEpKitKRiKzOy8sLK1euRPPmzREdHY1ffvlF6UgkA0kIIZQO0dgZDAZMnjwZ69atw7fffovIyMgatwshcO3aNZSWlsLd3R1eXl6QJEmhtEQN4/r164iJiYFWq8XKlSvh4+NT43ZuB/aFKxcboFarkZSUhPHjx2PixIlYt24dAECr1SIuLg5+fn7w9vZGt27d4O3tDT8/P8TFxUGr1SobnEhGLVu2REJCAjw9PREdHY0zZ84A4HZgr7hysSFGoxHR0dH45z//iTfffBNxcXEoLy8H8Nu/2qpV/2utWbNm2LBhA8LCwhTJS9QQSkpKMHXqVFy9ehVTpkzB9OnTuR3YIZaLjTEajRg5ciS2b98OSZJwt1+PSqWCJElIS0vjhkUOpaSkBKNHj0Z2dja3AzvFcrExWq0WHTp0MP9L7V5UKhVcXV1RVFQEjUbTsOGIrITbgf3jMRcbk5SUBJ1OV+v7m0wmlJeXY/Xq1Q2Yisi6uB3YP65cbIgQAn5+figoKLjrboDfkyQJPj4+OHXqFM+eIbvH7cAxsFxsyNWrV+Ht7V2vx3t5ecmYiMj6uB04Bu4WsyGlpaX1evytW7dkSkKkHG4HjoHlYkPc3d3r9XgPDw+ZkhAph9uBY2C52BAvLy/4+vpavL9YkiT4+vqiZcuWDZSMyHq4HTgGlosNkSQJ06dPr9NjX331VR7EJIfA7cAx8IC+jdFqtejYsSN0Oh1MJtM978/z+8kRcTuwf1y52BiNRoMNGzZAkiSoVHf/9VR/MjklJYUbFDkUbgf2j+Vig8LCwpCWlgZXV1dIkvSHZX71n7m6umLLli0YMWKEQkmJGg63A/vGcrFRYWFhKCoqwuLFi/9w6XEfHx8sXrwYFy5c4AZFDo3bgf3iMRc7IITA9evXcevWLXh4eKBly5Y8aEmNDrcD+8JyISIi2XG3GBERyY7lQkREsmO5EBGR7FguREQkO5YLERHJjuVCRESyY7kQEZHsWC5ERCQ7lgsREcmO5UJERLJjuRARkexYLkREJDuWCxERyY7lQkREsvt/E1+PIY8Gdz8AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot(metric='backward')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/API_demo/API_10_device.ipynb b/tutorials/API_demo/API_10_device.ipynb index 37be025c3..d34034c97 100644 --- a/tutorials/API_demo/API_10_device.ipynb +++ b/tutorials/API_demo/API_10_device.ipynb @@ -29,11 +29,11 @@ "import torch\n", "\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "#device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "device = 'cpu'\n", + "# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = \"cpu\"\n", "print(device)" ] }, @@ -67,13 +67,27 @@ } ], "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 100, 100, 100, 1], grid=3, k=3, seed=0).to(device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=50,\n", + " lamb=1e-3,\n", + " lamb_entropy=5.0,\n", + " update_grid=False,\n", + ");" ] }, { @@ -99,7 +113,7 @@ } ], "source": [ - "device = 'cuda'\n", + "device = \"cuda\"\n", "print(device)" ] }, @@ -133,13 +147,27 @@ } ], "source": [ - "model = KAN(width=[4,100,100,100,1], grid=3, k=3, seed=0).to(device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 100, 100, 100, 1], grid=3, k=3, seed=0).to(device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=1000, device=device)\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=50, lamb=1e-3, lamb_entropy=5., update_grid=False);" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=50,\n", + " lamb=1e-3,\n", + " lamb_entropy=5.0,\n", + " update_grid=False,\n", + ");" ] }, { diff --git a/tutorials/API_demo/API_11_create_dataset.ipynb b/tutorials/API_demo/API_11_create_dataset.ipynb index af8190ef6..8468c44b6 100644 --- a/tutorials/API_demo/API_11_create_dataset.ipynb +++ b/tutorials/API_demo/API_11_create_dataset.ipynb @@ -52,12 +52,12 @@ "from kan.utils import create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: x[:,[0]] * x[:,[1]]\n", + "f = lambda x: x[:, [0]] * x[:, [1]]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" + "dataset[\"train_label\"].shape" ] }, { @@ -86,9 +86,9 @@ } ], "source": [ - "f = lambda x: x[:,0] * x[:,1]\n", + "f = lambda x: x[:, 0] * x[:, 1]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_label'].shape" + "dataset[\"train_label\"].shape" ] }, { @@ -118,8 +118,8 @@ ], "source": [ "f = lambda x: x[0] * x[1]\n", - "dataset = create_dataset(f, n_var=2, f_mode='row', device=device)\n", - "dataset['train_label'].shape" + "dataset = create_dataset(f, n_var=2, f_mode=\"row\", device=device)\n", + "dataset[\"train_label\"].shape" ] }, { @@ -140,8 +140,8 @@ "import torch\n", "from kan.utils import create_dataset_from_data\n", "\n", - "x = torch.rand(100,2)\n", - "y = torch.rand(100,1)\n", + "x = torch.rand(100, 2)\n", + "y = torch.rand(100, 1)\n", "dataset = create_dataset_from_data(x, y, device=device)" ] }, diff --git a/tutorials/API_demo/API_12_checkpoint_save_load_model.ipynb b/tutorials/API_demo/API_12_checkpoint_save_load_model.ipynb index 476f6f054..62ec0c3cc 100644 --- a/tutorials/API_demo/API_12_checkpoint_save_load_model.ipynb +++ b/tutorials/API_demo/API_12_checkpoint_save_load_model.ipynb @@ -54,12 +54,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, auto_save=True, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, auto_save=True, device=device)\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -133,7 +133,7 @@ } ], "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, @@ -208,11 +208,11 @@ ], "source": [ "# revert to version 0.1 (if continuing)\n", - "model = model.rewind('0.1')\n", + "model = model.rewind(\"0.1\")\n", "\n", "# revert to version 0.1 (if starting from scratch)\n", - "#model = KAN.loadckpt('./model' + '0.1')\n", - "#model.get_act(dataset)\n", + "# model = KAN.loadckpt('./model' + '0.1')\n", + "# model.get_act(dataset)\n", "\n", "model.plot()" ] @@ -257,7 +257,7 @@ } ], "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=2);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=2)\n", "model.plot()" ] } diff --git a/tutorials/API_demo/API_1_indexing.ipynb b/tutorials/API_demo/API_1_indexing.ipynb index f27b7389d..c5b9b0d1f 100644 --- a/tutorials/API_demo/API_1_indexing.ipynb +++ b/tutorials/API_demo/API_1_indexing.ipynb @@ -37,12 +37,12 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,3,2,1], noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x);\n", + "model = KAN(width=[2, 3, 2, 1], noise_scale=0.3, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x)\n", "beta = 100\n", "model.plot(beta=beta)\n", "# [2,3,2,1] means 2 input nodes\n", @@ -94,9 +94,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'sin')\n", + "model.fix_symbolic(0, 0, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,0)" + "model.unfix_symbolic(0, 0, 0)" ] }, { @@ -126,9 +126,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,1,'sin')\n", + "model.fix_symbolic(0, 0, 1, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,0,1)" + "model.unfix_symbolic(0, 0, 1)" ] }, { @@ -158,9 +158,9 @@ } ], "source": [ - "model.fix_symbolic(0,1,0,'sin')\n", + "model.fix_symbolic(0, 1, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(0,1,0)" + "model.unfix_symbolic(0, 1, 0)" ] }, { @@ -190,9 +190,9 @@ } ], "source": [ - "model.fix_symbolic(1,0,0,'sin')\n", + "model.fix_symbolic(1, 0, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(1,0,0)" + "model.unfix_symbolic(1, 0, 0)" ] }, { @@ -222,9 +222,9 @@ } ], "source": [ - "model.fix_symbolic(2,1,0,'sin')\n", + "model.fix_symbolic(2, 1, 0, \"sin\")\n", "model.plot(beta=beta)\n", - "model.unfix_symbolic(2,1,0)" + "model.unfix_symbolic(2, 1, 0)" ] }, { @@ -262,7 +262,7 @@ } ], "source": [ - "model.remove_node(1,0)" + "model.remove_node(1, 0)" ] }, { @@ -303,7 +303,7 @@ } ], "source": [ - "model.remove_node(2,1)" + "model.remove_node(2, 1)" ] }, { @@ -344,7 +344,7 @@ } ], "source": [ - "model.remove_node(1,2)" + "model.remove_node(1, 2)" ] }, { @@ -401,11 +401,11 @@ "# KAN spline layers are refererred to as act_fun\n", "# KAN symbolic layers are referred to as symbolic_fun\n", "\n", - "model = KAN(width=[2,3,5,1])\n", + "model = KAN(width=[2, 3, 5, 1])\n", "\n", "i = 0\n", - "model.act_fun[i] # => KAN Layer (Spline)\n", - "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", + "model.act_fun[i] # => KAN Layer (Spline)\n", + "model.symbolic_fun[i] # => KAN Layer (Symbolic)\n", "\n", "for i in range(3):\n", " print(model.act_fun[i].in_dim, model.act_fun[i].out_dim)\n", diff --git a/tutorials/API_demo/API_2_plotting.ipynb b/tutorials/API_demo/API_2_plotting.ipynb index f9fd074b6..71bb2088a 100644 --- a/tutorials/API_demo/API_2_plotting.ipynb +++ b/tutorials/API_demo/API_2_plotting.ipynb @@ -45,16 +45,16 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -84,7 +84,7 @@ ], "source": [ "# plot KAN at initialization\n", - "model(dataset['train_input']);\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=100)" ] }, @@ -107,7 +107,7 @@ ], "source": [ "# if you want to add variable names and title\n", - "model.plot(beta=100, in_vars=[r'$\\alpha$', 'x'], out_vars=['y'], title = 'My KAN')" + "model.plot(beta=100, in_vars=[r\"$\\alpha$\", \"x\"], out_vars=[\"y\"], title=\"My KAN\")" ] }, { @@ -248,7 +248,7 @@ } ], "source": [ - "model.plot(metric='forward_n', beta=100)" + "model.plot(metric=\"forward_n\", beta=100)" ] }, { @@ -269,7 +269,7 @@ } ], "source": [ - "model.plot(metric='forward_u', beta=100)" + "model.plot(metric=\"forward_u\", beta=100)" ] }, { @@ -290,7 +290,7 @@ } ], "source": [ - "model.plot(metric='backward', beta=100)" + "model.plot(metric=\"backward\", beta=100)" ] }, { @@ -456,7 +456,7 @@ } ], "source": [ - "model.get_act(dataset['train_input'][:20])\n", + "model.get_act(dataset[\"train_input\"][:20])\n", "model.plot(sample=True)" ] }, @@ -494,7 +494,7 @@ } ], "source": [ - "model.fix_symbolic(0,1,0,'x^2')" + "model.fix_symbolic(0, 1, 0, \"x^2\")" ] }, { @@ -533,7 +533,7 @@ "metadata": {}, "outputs": [], "source": [ - "model.set_mode(0,1,0,mode='ns')\n" + "model.set_mode(0, 1, 0, mode=\"ns\")" ] }, { diff --git a/tutorials/API_demo/API_3_extract_activations.ipynb b/tutorials/API_demo/API_3_extract_activations.ipynb index 8933c83ad..b63249265 100644 --- a/tutorials/API_demo/API_3_extract_activations.ipynb +++ b/tutorials/API_demo/API_3_extract_activations.ipynb @@ -38,14 +38,13 @@ ], "source": [ "from kan import *\n", - "import matplotlib.pyplot as plt\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", "model(x)\n", "model.plot(beta=100)" ] @@ -71,7 +70,7 @@ "l = 0\n", "i = 0\n", "j = 3\n", - "x, y = model.get_fun(l,i,j)" + "x, y = model.get_fun(l, i, j)" ] }, { @@ -111,7 +110,7 @@ } ], "source": [ - "model.get_range(l,i,j)" + "model.get_range(l, i, j)" ] }, { diff --git a/tutorials/API_demo/API_4_initialization.ipynb b/tutorials/API_demo/API_4_initialization.ipynb index 77c0825e1..7973d353d 100644 --- a/tutorials/API_demo/API_4_initialization.ipynb +++ b/tutorials/API_demo/API_4_initialization.ipynb @@ -58,15 +58,15 @@ } ], "source": [ - "from kan import KAN, create_dataset\n", + "from kan import KAN\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -104,9 +104,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, base_fun = 'identity', device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, base_fun=\"identity\", device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -144,9 +144,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=0.3, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, noise_scale=0.3, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -176,9 +176,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, noise_scale=10., device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, noise_scale=10.0, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -216,9 +216,17 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, scale_base_mu=5, scale_base_sigma=0, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(\n", + " width=[2, 5, 1],\n", + " grid=5,\n", + " k=3,\n", + " seed=0,\n", + " scale_base_mu=5,\n", + " scale_base_sigma=0,\n", + " device=device,\n", + ")\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, @@ -248,9 +256,9 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, sparse_init=True, device=device)\n", - "x = torch.normal(0,1,size=(100,2)).to(device)\n", - "model(x) # forward is needed to collect activations for plotting\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, sparse_init=True, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2)).to(device)\n", + "model(x) # forward is needed to collect activations for plotting\n", "model.plot()" ] }, diff --git a/tutorials/API_demo/API_5_grid.ipynb b/tutorials/API_demo/API_5_grid.ipynb index 655b1059d..b783a4eed 100644 --- a/tutorials/API_demo/API_5_grid.ipynb +++ b/tutorials/API_demo/API_5_grid.ipynb @@ -54,20 +54,20 @@ "# Suppose we have grid in [-1,1] with G intervals, spline order k\n", "G = 5\n", "k = 3\n", - "grid = torch.linspace(-1,1,steps=G+1)[None,:]\n", + "grid = torch.linspace(-1, 1, steps=G + 1)[None, :]\n", "grid = extend_grid(grid, k_extend=k)\n", "\n", "# and we have sample range in [-1,1]\n", - "x = torch.linspace(-1,1,steps=1001)[None,:]\n", + "x = torch.linspace(-1, 1, steps=1001)[None, :]\n", "\n", "basis = B_batch(x, grid, k=k)\n", "\n", - "for i in range(G+k):\n", - " plt.plot(x[0].detach().numpy(), basis[0,:,i].detach().numpy())\n", - " \n", - "plt.legend(['B_{}(x)'.format(i) for i in np.arange(G+k)])\n", - "plt.xlabel('x')\n", - "plt.ylabel('B_i(x)')" + "for i in range(G + k):\n", + " plt.plot(x[0].detach().numpy(), basis[0, :, i].detach().numpy())\n", + "\n", + "plt.legend([\"B_{}(x)\".format(i) for i in np.arange(G + k)])\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"B_i(x)\")" ] }, { @@ -106,18 +106,18 @@ "source": [ "from kan import KAN\n", "\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", "# obtain coefficients c_i\n", "model.act_fun[0].coef\n", - "assert(model.act_fun[0].coef[0].shape[1] == G+k)\n", + "assert model.act_fun[0].coef[0].shape[1] == G + k\n", "\n", "# the model forward\n", - "model_output = model(x[0][:,None])\n", + "model_output = model(x[0][:, None])\n", "\n", "# spline output\n", - "spline_output = torch.einsum('j,ij->i',model.act_fun[0].coef[0][0], basis[0])[:,None]\n", + "spline_output = torch.einsum(\"j,ij->i\", model.act_fun[0].coef[0][0], basis[0])[:, None]\n", "\n", - "torch.mean((model_output - spline_output)**2)" + "torch.mean((model_output - spline_output) ** 2)" ] }, { @@ -147,10 +147,12 @@ ], "source": [ "# residual output\n", - "residual_output = torch.nn.SiLU()(x[0][:,None])\n", + "residual_output = torch.nn.SiLU()(x[0][:, None])\n", "scale_base = model.act_fun[0].scale_base\n", "scale_sp = model.act_fun[0].scale_sp\n", - "torch.mean((model_output - (scale_base * residual_output + scale_sp * spline_output))**2)" + "torch.mean(\n", + " (model_output - (scale_base * residual_output + scale_sp * spline_output)) ** 2\n", + ")" ] }, { @@ -182,11 +184,13 @@ } ], "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-10,10,steps = 1001)[:,None]\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.linspace(-10, 10, steps=1001)[:, None]\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -211,11 +215,13 @@ } ], "source": [ - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.linspace(-0.5,0.5,steps = 1001)[:,None]\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.linspace(-0.5, 0.5, steps=1001)[:, None]\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -249,11 +255,13 @@ ], "source": [ "# uniform grid\n", - "model = KAN(width=[1,1], grid=G, k=k)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", + "model = KAN(width=[1, 1], grid=G, k=k)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.normal(0, 1, size=(1000, 1))\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { @@ -279,11 +287,13 @@ ], "source": [ "# adaptive grid based on sample distribution\n", - "model = KAN(width=[1,1], grid=G, k=k, grid_eps = 0.)\n", - "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", - "x = torch.normal(0,1,size=(1000,1))\n", + "model = KAN(width=[1, 1], grid=G, k=k, grid_eps=0.0)\n", + "print(model.act_fun[0].grid) # by default, the grid is in [-1,1]\n", + "x = torch.normal(0, 1, size=(1000, 1))\n", "model.update_grid_from_samples(x)\n", - "print(model.act_fun[0].grid) # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" + "print(\n", + " model.act_fun[0].grid\n", + ") # now the grid becomes in [-10,10]. We add a 0.01 margin in case x have zero variance" ] }, { diff --git a/tutorials/API_demo/API_6_training_hyperparameter.ipynb b/tutorials/API_demo/API_6_training_hyperparameter.ipynb index 11c12484f..5d22f26b8 100644 --- a/tutorials/API_demo/API_6_training_hyperparameter.ipynb +++ b/tutorials/API_demo/API_6_training_hyperparameter.ipynb @@ -46,12 +46,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -103,8 +103,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, @@ -167,8 +167,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.00);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.00)\n", "model.plot()" ] }, @@ -221,8 +221,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=0, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=0, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1.0)\n", "model.plot()" ] }, @@ -285,8 +285,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=0.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=0.0)\n", "model.plot()" ] }, @@ -339,8 +339,8 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0);\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, lamb_entropy=10.0)\n", "model.plot()" ] }, @@ -402,8 +402,8 @@ } ], "source": [ - "model = KAN(width=[2,5,1], grid=3, k=3, seed=42, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=42, device=device)\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", "model.plot()" ] }, diff --git a/tutorials/API_demo/API_7_pruning.ipynb b/tutorials/API_demo/API_7_pruning.ipynb index 2b175b1a5..1b0961768 100644 --- a/tutorials/API_demo/API_7_pruning.ipynb +++ b/tutorials/API_demo/API_7_pruning.ipynb @@ -61,20 +61,20 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -103,13 +103,13 @@ } ], "source": [ - "mode = 'auto'\n", + "mode = \"auto\"\n", "\n", - "if mode == 'auto':\n", + "if mode == \"auto\":\n", " # automatic\n", - " model = model.prune_node(threshold=1e-2) # by default the threshold is 1e-2\n", + " model = model.prune_node(threshold=1e-2) # by default the threshold is 1e-2\n", " model.plot()\n", - "elif mode == 'manual':\n", + "elif mode == \"manual\":\n", " # manual\n", " model = model.prune_node(active_neurons_id=[[0]])" ] @@ -163,17 +163,18 @@ ], "source": [ "from kan import *\n", + "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=6, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=6, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, @@ -273,17 +274,18 @@ ], "source": [ "from kan import *\n", + "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,5,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 5, 1], grid=5, k=3, seed=1, device=device)\n", "\n", "# create dataset f(x,y) = exp(sin(pi*x)+y^2)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape\n", + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01);\n", - "model(dataset['train_input'])\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01)\n", + "model(dataset[\"train_input\"])\n", "model.plot()" ] }, diff --git a/tutorials/API_demo/API_8_regularization.ipynb b/tutorials/API_demo/API_8_regularization.ipynb index 3e8faa423..170dc0d76 100644 --- a/tutorials/API_demo/API_8_regularization.ipynb +++ b/tutorials/API_demo/API_8_regularization.ipynb @@ -46,12 +46,12 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "dataset['train_input'].shape, dataset['train_label'].shape" + "dataset[\"train_input\"].shape, dataset[\"train_label\"].shape" ] }, { @@ -108,12 +108,14 @@ ], "source": [ "# train the model\n", - "model = KAN(width=[2,5,1], grid=3, k=3, seed=1, device=device)\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_n'); # default\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_sum');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_u'); \n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_backward');\n", - "#model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='node_backward');\n", + "model = KAN(width=[2, 5, 1], grid=3, k=3, seed=1, device=device)\n", + "model.fit(\n", + " dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric=\"edge_forward_spline_n\"\n", + ") # default\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_sum');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_forward_spline_u');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='edge_backward');\n", + "# model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.01, reg_metric='node_backward');\n", "model.plot()" ] }, @@ -146,9 +148,9 @@ } ], "source": [ - "model.plot(metric='forward_u')\n", - "#model.plot(metric='forward_n')\n", - "#model.plot(metric='backward') # default" + "model.plot(metric=\"forward_u\")\n", + "# model.plot(metric='forward_n')\n", + "# model.plot(metric='backward') # default" ] }, { diff --git a/tutorials/API_demo/API_9_video.ipynb b/tutorials/API_demo/API_9_video.ipynb index c5a723c9b..e414de35c 100644 --- a/tutorials/API_demo/API_9_video.ipynb +++ b/tutorials/API_demo/API_9_video.ipynb @@ -53,22 +53,36 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 2, 1, 1], grid=3, k=3, seed=1, device=device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", "\n", - "image_folder = 'video_img'\n", + "image_folder = \"video_img\"\n", "\n", "# train the model\n", - "#model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", - "model.fit(dataset, opt=\"LBFGS\", steps=5, lamb=0.001, lamb_entropy=2., save_fig=True, beta=10, \n", - " in_vars=[r'$x_1$', r'$x_2$', r'$x_3$', r'$x_4$'],\n", - " out_vars=[r'${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$'],\n", - " img_folder=image_folder);\n" + "# model.train(dataset, opt=\"LBFGS\", steps=20, lamb=1e-3, lamb_entropy=2.);\n", + "model.fit(\n", + " dataset,\n", + " opt=\"LBFGS\",\n", + " steps=5,\n", + " lamb=0.001,\n", + " lamb_entropy=2.0,\n", + " save_fig=True,\n", + " beta=10,\n", + " in_vars=[r\"$x_1$\", r\"$x_2$\", r\"$x_3$\", r\"$x_4$\"],\n", + " out_vars=[r\"${\\rm exp}({\\rm sin}(x_1^2+x_2^2)+{\\rm sin}(x_3^2+x_4^2))$\"],\n", + " img_folder=image_folder,\n", + ");" ] }, { @@ -105,24 +119,26 @@ "source": [ "import os\n", "import numpy as np\n", - "import moviepy.video.io.ImageSequenceClip # moviepy == 1.0.3\n", + "import moviepy.video.io.ImageSequenceClip # moviepy == 1.0.3\n", "\n", - "video_name='video'\n", - "fps=5\n", + "video_name = \"video\"\n", + "fps = 5\n", "\n", "fps = fps\n", "files = os.listdir(image_folder)\n", "train_index = []\n", "for file in files:\n", - " if file[0].isdigit() and file.endswith('.jpg'):\n", + " if file[0].isdigit() and file.endswith(\".jpg\"):\n", " train_index.append(int(file[:-4]))\n", "\n", "train_index = np.sort(train_index)\n", "\n", - "image_files = [image_folder+'/'+str(train_index[index])+'.jpg' for index in train_index]\n", + "image_files = [\n", + " image_folder + \"/\" + str(train_index[index]) + \".jpg\" for index in train_index\n", + "]\n", "\n", "clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps=fps)\n", - "clip.write_videofile(video_name+'.mp4')" + "clip.write_videofile(video_name + \".mp4\")" ] }, { diff --git a/tutorials/Community/Community_1_physics_informed_kan.ipynb b/tutorials/Community/Community_1_physics_informed_kan.ipynb index a100250a0..68139f066 100644 --- a/tutorials/Community/Community_1_physics_informed_kan.ipynb +++ b/tutorials/Community/Community_1_physics_informed_kan.ipynb @@ -54,26 +54,35 @@ "\n", "x = torch.linspace(0, width, num_points_x, device=device, requires_grad=False)\n", "y = torch.linspace(0, height, num_points_y, device=device, requires_grad=False)\n", - "X, Y = torch.meshgrid(x, y, indexing='ij')\n", + "X, Y = torch.meshgrid(x, y, indexing=\"ij\")\n", "coordinates = torch.stack([X.flatten(), Y.flatten()], dim=1).to(device)\n", "coordinates.requires_grad = True # Ensure coordinates require grad\n", "\n", - "model = KAN(width=[2,3,3, 3], grid=5, k=10, grid_eps=1.0,\n", - " noise_scale_base=0.25).to(device)\n", + "model = KAN(width=[2, 3, 3, 3], grid=5, k=10, grid_eps=1.0, noise_scale_base=0.25).to(\n", + " device\n", + ")\n", + "\n", "\n", "def batch_jacobian(func, x, create_graph=False):\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1, 0, 2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "def batch_hessian(func, x):\n", " jacobian = batch_jacobian(func, x, create_graph=True)\n", " hessians = []\n", " for i in range(jacobian.size(1)):\n", - " grad = autograd.grad(jacobian[:, i].sum(), x, create_graph=True, retain_graph=True)[0]\n", + " grad = autograd.grad(\n", + " jacobian[:, i].sum(), x, create_graph=True, retain_graph=True\n", + " )[0]\n", " hessians.append(grad.unsqueeze(1))\n", " return torch.cat(hessians, dim=1)\n", "\n", + "\n", "def navier_stokes_residuals(coords):\n", " coords = coords.clone().detach().requires_grad_(True) # Ensure coords require grad\n", " y_pred = model(coords)\n", @@ -93,27 +102,37 @@ " y_momentum = u * v_x + v * v_y + (1 / rho) * p_y - nu * (v_xx + v_yy)\n", "\n", " no_slip_mask = (coords[:, 1] == 0) | (coords[:, 1] == height)\n", - " inlet_mask = (coords[:, 0] == 0)\n", - " outlet_mask = (coords[:, 0] == width)\n", + " inlet_mask = coords[:, 0] == 0\n", + " outlet_mask = coords[:, 0] == width\n", "\n", " no_slip_loss = torch.mean(u[no_slip_mask] ** 2 + v[no_slip_mask] ** 2)\n", " inlet_loss = torch.mean((u[inlet_mask] - 1) ** 2)\n", " outlet_pressure_loss = torch.mean(p[outlet_mask] ** 2)\n", "\n", " bc_loss = no_slip_loss + inlet_loss + outlet_pressure_loss\n", - " total_loss = torch.mean(continuity ** 2 + x_momentum ** 2 + y_momentum ** 2) + bc_loss\n", + " total_loss = torch.mean(continuity**2 + x_momentum**2 + y_momentum**2) + bc_loss\n", " return total_loss\n", "\n", + "\n", "writer = SummaryWriter()\n", "\n", + "\n", "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1,\n", - " history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - " \n", - " steps = 200 # 20 steps are enough\n", - " pbar = tqdm(range(steps), desc='Training Progress')\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", + "\n", + " steps = 200 # 20 steps are enough\n", + " pbar = tqdm(range(steps), desc=\"Training Progress\")\n", "\n", " for step in pbar:\n", + "\n", " def closure():\n", " optimizer.zero_grad()\n", " loss = navier_stokes_residuals(coordinates)\n", @@ -123,13 +142,13 @@ " optimizer.step(closure)\n", " if step % 5 == 0:\n", " current_loss = closure().item()\n", - " pbar.set_description(\"Step: %d | Loss: %.3f\" %\n", - " (step, current_loss))\n", - " writer.add_scalar('Loss/train', current_loss, step)\n", + " pbar.set_description(\"Step: %d | Loss: %.3f\" % (step, current_loss))\n", + " writer.add_scalar(\"Loss/train\", current_loss, step)\n", + "\n", "\n", "train()\n", "\n", - "writer.close()\n" + "writer.close()" ] }, { @@ -149,22 +168,20 @@ } ], "source": [ - "u_pred = model(coordinates)[:, 0].detach().reshape(\n", - " num_points_x, num_points_y).T\n", + "u_pred = model(coordinates)[:, 0].detach().reshape(num_points_x, num_points_y).T\n", "\n", - "v_pred = model(coordinates)[:, 1].detach().reshape(\n", - " num_points_x, num_points_y).T\n", + "v_pred = model(coordinates)[:, 1].detach().reshape(num_points_x, num_points_y).T\n", "\n", "\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", + "magnitude = torch.sqrt(u_pred**2 + v_pred**2)\n", "\n", "plt.figure(figsize=(10, 5)) # Set the figure size as needed\n", - "plt.imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", + "plt.imshow(magnitude, extent=(0, width, 0, height), origin=\"lower\", cmap=\"viridis\")\n", "plt.colorbar() # Add a colorbar to show the magnitude scale\n", - "plt.title('Velocity Magnitude Contour')\n", - "plt.xlabel('Width')\n", - "plt.ylabel('Height')\n", - "plt.axis('equal') # Ensure the plot has equal scaling\n", + "plt.title(\"Velocity Magnitude Contour\")\n", + "plt.xlabel(\"Width\")\n", + "plt.ylabel(\"Height\")\n", + "plt.axis(\"equal\") # Ensure the plot has equal scaling\n", "plt.tight_layout() # Adjust layout to prevent overlap\n", "plt.show()" ] @@ -192,42 +209,50 @@ "p_pred = model(coordinates)[:, 2].detach().reshape(num_points_x, num_points_y).T\n", "\n", "# Velocity Magnitude\n", - "magnitude = torch.sqrt(u_pred ** 2 + v_pred ** 2)\n", + "magnitude = torch.sqrt(u_pred**2 + v_pred**2)\n", "\n", "# Plotting all subplots\n", "fig, axs = plt.subplots(2, 2, figsize=(15, 10))\n", "\n", "# Velocity Magnitude\n", - "im0 = axs[0, 0].imshow(magnitude, extent=(0, width, 0, height), origin='lower', cmap='viridis')\n", + "im0 = axs[0, 0].imshow(\n", + " magnitude, extent=(0, width, 0, height), origin=\"lower\", cmap=\"viridis\"\n", + ")\n", "fig.colorbar(im0, ax=axs[0, 0])\n", - "axs[0, 0].set_title('Velocity Magnitude Contour')\n", - "axs[0, 0].set_xlabel('Width')\n", - "axs[0, 0].set_ylabel('Height')\n", - "axs[0, 0].axis('equal')\n", + "axs[0, 0].set_title(\"Velocity Magnitude Contour\")\n", + "axs[0, 0].set_xlabel(\"Width\")\n", + "axs[0, 0].set_ylabel(\"Height\")\n", + "axs[0, 0].axis(\"equal\")\n", "\n", "# u Component\n", - "im1 = axs[0, 1].imshow(u_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im1 = axs[0, 1].imshow(\n", + " u_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im1, ax=axs[0, 1])\n", - "axs[0, 1].set_title('u Component')\n", - "axs[0, 1].set_xlabel('Width')\n", - "axs[0, 1].set_ylabel('Height')\n", - "axs[0, 1].axis('equal')\n", + "axs[0, 1].set_title(\"u Component\")\n", + "axs[0, 1].set_xlabel(\"Width\")\n", + "axs[0, 1].set_ylabel(\"Height\")\n", + "axs[0, 1].axis(\"equal\")\n", "\n", "# v Component\n", - "im2 = axs[1, 0].imshow(v_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im2 = axs[1, 0].imshow(\n", + " v_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im2, ax=axs[1, 0])\n", - "axs[1, 0].set_title('v Component')\n", - "axs[1, 0].set_xlabel('Width')\n", - "axs[1, 0].set_ylabel('Height')\n", - "axs[1, 0].axis('equal')\n", + "axs[1, 0].set_title(\"v Component\")\n", + "axs[1, 0].set_xlabel(\"Width\")\n", + "axs[1, 0].set_ylabel(\"Height\")\n", + "axs[1, 0].axis(\"equal\")\n", "\n", "# Pressure\n", - "im3 = axs[1, 1].imshow(p_pred, extent=(0, width, 0, height), origin='lower', cmap='coolwarm')\n", + "im3 = axs[1, 1].imshow(\n", + " p_pred, extent=(0, width, 0, height), origin=\"lower\", cmap=\"coolwarm\"\n", + ")\n", "fig.colorbar(im3, ax=axs[1, 1])\n", - "axs[1, 1].set_title('Pressure')\n", - "axs[1, 1].set_xlabel('Width')\n", - "axs[1, 1].set_ylabel('Height')\n", - "axs[1, 1].axis('equal')\n", + "axs[1, 1].set_title(\"Pressure\")\n", + "axs[1, 1].set_xlabel(\"Width\")\n", + "axs[1, 1].set_ylabel(\"Height\")\n", + "axs[1, 1].axis(\"equal\")\n", "\n", "plt.tight_layout() # Adjust layout to prevent overlap\n", "plt.show()" diff --git a/tutorials/Community/Community_2_protein_sequence_classification.ipynb b/tutorials/Community/Community_2_protein_sequence_classification.ipynb index 99c734517..f16cad513 100644 --- a/tutorials/Community/Community_2_protein_sequence_classification.ipynb +++ b/tutorials/Community/Community_2_protein_sequence_classification.ipynb @@ -53,10 +53,10 @@ "outputs": [], "source": [ "# Hyperparameters\n", - "PROTEIN_WINDOW_SIZE = 5 \n", + "PROTEIN_WINDOW_SIZE = 5\n", "\n", "# define the universe of possible input amino acids, ie. vocab list\n", - "aa_list = 'ARNDCQEGHILKMFPSTWYVX'" + "aa_list = \"ARNDCQEGHILKMFPSTWYVX\"" ] }, { @@ -78,10 +78,10 @@ " \"\"\"\n", " # Create a dictionary mapping amino acids to indices\n", " aa_to_index = {aa: i for i, aa in enumerate(aa_list)}\n", - " \n", + "\n", " # Initialize an array of zeros with shape (sequence_length, alphabet_length)\n", " encoding = np.zeros((len(protein_sequence), len(aa_list)))\n", - " \n", + "\n", " # Iterate over the protein sequence and set the corresponding index to 1\n", " for i, aa in enumerate(protein_sequence):\n", " if aa in aa_to_index:\n", @@ -89,7 +89,7 @@ " else:\n", " # If the amino acid is not in the alphabet, set the last index to 1 (unknown)\n", " encoding[i, -1] = 1\n", - " \n", + "\n", " return encoding" ] }, @@ -149,7 +149,7 @@ "source": [ "def generate_sample_protein_dataset(num_samples=20, protein_window_size=5):\n", " \"\"\"\n", - " Generate a dataset of protein sequences of length 11, keeping Lysine(K) in the center for label 1 and Serine(S) for label 0. \n", + " Generate a dataset of protein sequences of length 11, keeping Lysine(K) in the center for label 1 and Serine(S) for label 0.\n", "\n", " Args:\n", " num_samples (int): Number of samples to generate.\n", @@ -158,9 +158,9 @@ " Returns:\n", " dict: A dictionary containing train_input, test_input, train_label, and test_label.\n", " \"\"\"\n", - " \n", - " dataset = {'train_input': [], 'test_input': [], 'train_label': [], 'test_label': []}\n", - " alphabet = 'ARNDCQEGHILKMFPSTWYVX'\n", + "\n", + " dataset = {\"train_input\": [], \"test_input\": [], \"train_label\": [], \"test_label\": []}\n", + " alphabet = \"ARNDCQEGHILKMFPSTWYVX\"\n", "\n", " # Generate half of the samples with label 1 and half with label 0\n", " label_sequence = [1] * (num_samples // 2) + [0] * (num_samples // 2)\n", @@ -169,29 +169,42 @@ " for label in label_sequence:\n", " # Generate a protein sequence with 'K' in the middle for label 1 and 'S' for label 0\n", " if label == 1:\n", - " center_aa = 'K'\n", + " center_aa = \"K\"\n", " else:\n", - " center_aa = 'S'\n", - " sequence = ''.join(random.choices(alphabet.replace(center_aa, ''), k=protein_window_size//2)) + center_aa + ''.join(random.choices(alphabet.replace(center_aa, ''), k=protein_window_size//2))\n", + " center_aa = \"S\"\n", + " sequence = (\n", + " \"\".join(\n", + " random.choices(\n", + " alphabet.replace(center_aa, \"\"), k=protein_window_size // 2\n", + " )\n", + " )\n", + " + center_aa\n", + " + \"\".join(\n", + " random.choices(\n", + " alphabet.replace(center_aa, \"\"), k=protein_window_size // 2\n", + " )\n", + " )\n", + " )\n", " print(sequence, label)\n", " encoded_sequence = one_hot_encode(sequence).flatten()\n", "\n", " # Split the dataset into train and test (50% each)\n", - " if len(dataset['train_input']) < num_samples // 2:\n", - " dataset['train_input'].append(encoded_sequence)\n", - " dataset['train_label'].append(label)\n", + " if len(dataset[\"train_input\"]) < num_samples // 2:\n", + " dataset[\"train_input\"].append(encoded_sequence)\n", + " dataset[\"train_label\"].append(label)\n", " else:\n", - " dataset['test_input'].append(encoded_sequence)\n", - " dataset['test_label'].append(label)\n", + " dataset[\"test_input\"].append(encoded_sequence)\n", + " dataset[\"test_label\"].append(label)\n", "\n", " # Convert lists to tensors\n", - " dataset['train_input'] = torch.tensor(dataset['train_input'])\n", - " dataset['test_input'] = torch.tensor(dataset['test_input'])\n", - " dataset['train_label'] = torch.tensor(dataset['train_label']).view(-1, 1)\n", - " dataset['test_label'] = torch.tensor(dataset['test_label']).view(-1, 1)\n", + " dataset[\"train_input\"] = torch.tensor(dataset[\"train_input\"])\n", + " dataset[\"test_input\"] = torch.tensor(dataset[\"test_input\"])\n", + " dataset[\"train_label\"] = torch.tensor(dataset[\"train_label\"]).view(-1, 1)\n", + " dataset[\"test_label\"] = torch.tensor(dataset[\"test_label\"]).view(-1, 1)\n", "\n", " return dataset\n", "\n", + "\n", "# Generate dataset with 10 samples\n", "dataset = generate_sample_protein_dataset(40)" ] @@ -275,7 +288,7 @@ "# create a KAN: 105 inputs, 2D output, and 3 hidden neurons. k=2, 3 grid intervals (grid=3).\n", "# considering window size: 5, 5 times 21(vocab size), input-> 21 * 5\n", "\n", - "model = KAN(width=[105,3,2], grid=3, k=2)" + "model = KAN(width=[105, 3, 2], grid=3, k=2)" ] }, { @@ -304,13 +317,25 @@ ], "source": [ "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).float())\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"train_input\"])[:, 0])\n", + " == dataset[\"train_label\"][:, 0]\n", + " ).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).float())\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"test_input\"])[:, 0])\n", + " == dataset[\"test_label\"][:, 0]\n", + " ).float()\n", + " )\n", + "\n", "\n", - "results = model.train(dataset, opt=\"LBFGS\", steps=5, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" + "results = model.train(dataset, opt=\"LBFGS\", steps=5, metrics=(train_acc, test_acc))\n", + "results[\"train_acc\"][-1], results[\"test_acc\"][-1]" ] }, { @@ -648,7 +673,7 @@ } ], "source": [ - "lib = ['x','x^2']\n", + "lib = [\"x\", \"x^2\"]\n", "\n", "model.auto_symbolic(lib=lib)" ] diff --git a/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb b/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb deleted file mode 100644 index 13a3991c9..000000000 --- a/tutorials/Example/.ipynb_checkpoints/Example_1_function_fitting-checkpoint.ipynb +++ /dev/null @@ -1,415 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5d904dee", - "metadata": {}, - "source": [ - "# Example 1: Function Fitting\n", - "\n", - "In this example, we will cover how to leverage grid refinement to maximimze KANs' ability to fit functions" - ] - }, - { - "cell_type": "markdown", - "id": "94056ef6", - "metadata": {}, - "source": [ - "intialize model and create dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "0a59179d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cpu\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=1, device=device)\n", - "\n", - "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device)" - ] - }, - { - "cell_type": "markdown", - "id": "cb1f817e", - "metadata": {}, - "source": [ - "Train KAN (grid=3)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a87b97b0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.36e-02 | test_loss: 1.39e-02 | reg: 1.17e+01 | : 100%|█| 20/20 [00:03<00:00, 6.55it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "52294efd", - "metadata": {}, - "source": [ - "The loss plateaus. we want a more fine-grained KAN!" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3f1cfc9d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "# initialize a more fine-grained KAN with G=10\n", - "model = model.refine(10)" - ] - }, - { - "cell_type": "markdown", - "id": "f3cc5079", - "metadata": {}, - "source": [ - "Train KAN (grid=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "898b1794", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 5.92e-04 | test_loss: 6.16e-04 | reg: 1.17e+01 | : 100%|█| 20/20 [00:04<00:00, 4.87it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, opt=\"LBFGS\", steps=20);" - ] - }, - { - "cell_type": "markdown", - "id": "bcdc0d3d", - "metadata": {}, - "source": [ - "The loss becomes lower. This is good! Now we can even iteratively making grids finer." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a1c25e8a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cpu\n", - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.35e-02 | test_loss: 1.39e-02 | reg: 1.12e+01 | : 100%|█| 200/200 [00:14<00:00, 14.00\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n", - "saving model version 0.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.25e-03 | test_loss: 7.19e-03 | reg: 1.12e+01 | : 100%|█| 200/200 [00:14<00:00, 13.72\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n", - "saving model version 0.4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 4.74e-04 | test_loss: 4.96e-04 | reg: 1.12e+01 | : 100%|█| 200/200 [00:15<00:00, 12.77\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n", - "saving model version 0.6\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 7.72e-05 | test_loss: 1.06e-04 | reg: 1.12e+01 | : 100%|█| 200/200 [00:12<00:00, 16.41\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.7\n", - "saving model version 0.8\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 2.72e-05 | test_loss: 6.12e-05 | reg: 1.12e+01 | : 100%|█| 200/200 [00:14<00:00, 13.68\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.9\n", - "saving model version 0.10\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.89e-05 | test_loss: 6.10e-05 | reg: 1.12e+01 | : 100%|█| 200/200 [00:13<00:00, 15.24" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.11\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from kan import *\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", - "dataset = create_dataset(f, n_var=2, device=device, train_num=1000)\n", - "\n", - "\n", - "grids = np.array([3,5,10,20,50,100])\n", - "#grids = np.array([3,10])\n", - "\n", - "\n", - "train_losses = []\n", - "test_losses = []\n", - "steps = 200\n", - "k = 3\n", - "\n", - "for i in range(grids.shape[0]):\n", - " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k, seed=0, device=device)\n", - " if i != 0:\n", - " model = model.refine(grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=steps)\n", - " train_losses += results['train_loss']\n", - " test_losses += results['test_loss']\n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "6be8ba55", - "metadata": {}, - "source": [ - "Training dynamics of losses display staircase structures (loss suddenly drops after grid refinement)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "156f68a2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(train_losses)\n", - "plt.plot(test_losses)\n", - "plt.legend(['train', 'test'])\n", - "plt.ylabel('RMSE')\n", - "plt.xlabel('step')\n", - "plt.yscale('log')" - ] - }, - { - "cell_type": "markdown", - "id": "6ed8d26b", - "metadata": {}, - "source": [ - "Neural scaling laws (For some reason, this got worse than pykan 0.0. We're still investigating the reason, probably due to the updates of curve2coef)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8301085c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'RMSE')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_params = 3 * grids\n", - "train_vs_G = train_losses[(steps-1)::steps]\n", - "test_vs_G = test_losses[(steps-1)::steps]\n", - "plt.plot(n_params, train_vs_G, marker=\"o\")\n", - "plt.plot(n_params, test_vs_G, marker=\"o\")\n", - "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.legend(['train', 'test', r'$N^{-4}$'])\n", - "plt.xlabel('number of params')\n", - "plt.ylabel('RMSE')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c521e5e", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/Example/Example_10_relativity-addition.ipynb b/tutorials/Example/Example_10_relativity-addition.ipynb index 50d49d0eb..ae165ee94 100644 --- a/tutorials/Example/Example_10_relativity-addition.ipynb +++ b/tutorials/Example/Example_10_relativity-addition.ipynb @@ -43,15 +43,15 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=10, k=3, device=device)\n", + "model = KAN(width=[2, 1, 1], grid=10, k=3, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: (x[:,[0]]+x[:,[1]])/(1+x[:,[0]]*x[:,[1]])\n", - "dataset = create_dataset(f, n_var=2, ranges=[-0.9,0.9], device=device)" + "f = lambda x: (x[:, [0]] + x[:, [1]]) / (1 + x[:, [0]] * x[:, [1]])\n", + "dataset = create_dataset(f, n_var=2, ranges=[-0.9, 0.9], device=device)" ] }, { @@ -159,7 +159,7 @@ } ], "source": [ - "model.suggest_symbolic(0,1,0,weight_simple=0.0)" + "model.suggest_symbolic(0, 1, 0, weight_simple=0.0)" ] }, { @@ -198,8 +198,8 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'arctanh')\n", - "model.fix_symbolic(0,1,0,'arctanh')" + "model.fix_symbolic(0, 0, 0, \"arctanh\")\n", + "model.fix_symbolic(0, 1, 0, \"arctanh\")" ] }, { @@ -299,7 +299,7 @@ } ], "source": [ - "model.suggest_symbolic(1,0,0,weight_simple=0.)" + "model.suggest_symbolic(1, 0, 0, weight_simple=0.0)" ] }, { @@ -328,7 +328,7 @@ } ], "source": [ - "model.fix_symbolic(1,0,0,'tanh')" + "model.fix_symbolic(1, 0, 0, \"tanh\")" ] }, { @@ -353,7 +353,14 @@ } ], "source": [ - "model.fit(dataset, opt=\"Adam\", lr=1e-3, steps=2000, update_grid=False, singularity_avoiding=True);" + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " lr=1e-3,\n", + " steps=2000,\n", + " update_grid=False,\n", + " singularity_avoiding=True,\n", + ");" ] }, { diff --git a/tutorials/Example/Example_11_encouraing_linear.ipynb b/tutorials/Example/Example_11_encouraing_linear.ipynb index ee2126327..0c885326d 100644 --- a/tutorials/Example/Example_11_encouraing_linear.ipynb +++ b/tutorials/Example/Example_11_encouraing_linear.ipynb @@ -78,14 +78,14 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", + "f = lambda x: torch.sin(torch.pi * x[:, [0]])\n", "dataset = create_dataset(f, n_var=1, device=device)\n", "\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, noise_scale=0.1, device=device)\n", + "model = KAN(width=[1, 1, 1, 1], grid=5, k=3, seed=0, noise_scale=0.1, device=device)\n", "\n", "model.fit(dataset, opt=\"LBFGS\", steps=20);" ] @@ -159,11 +159,19 @@ "from kan import *\n", "\n", "# create dataset f(x,y) = sin(pi*x). This task can be achieved by a [1,1] KAN\n", - "f = lambda x: torch.sin(torch.pi*x[:,[0]])\n", + "f = lambda x: torch.sin(torch.pi * x[:, [0]])\n", "dataset = create_dataset(f, n_var=1, device=device)\n", "\n", "# set base_fun to be linear\n", - "model = KAN(width=[1,1,1,1], grid=5, k=3, seed=0, base_fun='identity', noise_scale=0.1, device=device)\n", + "model = KAN(\n", + " width=[1, 1, 1, 1],\n", + " grid=5,\n", + " k=3,\n", + " seed=0,\n", + " base_fun=\"identity\",\n", + " noise_scale=0.1,\n", + " device=device,\n", + ")\n", "\n", "# penality spline coefficients\n", "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=1e-4, lamb_coef=10.0);" diff --git a/tutorials/Example/Example_12_unsupervised_learning.ipynb b/tutorials/Example/Example_12_unsupervised_learning.ipynb index 943ae09b2..9656933c7 100644 --- a/tutorials/Example/Example_12_unsupervised_learning.ipynb +++ b/tutorials/Example/Example_12_unsupervised_learning.ipynb @@ -47,49 +47,59 @@ "import torch\n", "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 1\n", "\n", - "model = KAN(width=[6,1,1], grid=3, k=3, seed=seed, device=device)\n", + "model = KAN(width=[6, 1, 1], grid=3, k=3, seed=seed, device=device)\n", "\n", "# create dataset\n", "\n", "\n", "def create_dataset(train_num=500, test_num=500):\n", - " \n", " def generate_contrastive(x):\n", " # positive samples\n", " batch = x.shape[0]\n", - " x[:,2] = torch.exp(torch.sin(torch.pi*x[:,0])+x[:,1]**2)\n", - " x[:,3] = x[:,4]**3\n", + " x[:, 2] = torch.exp(torch.sin(torch.pi * x[:, 0]) + x[:, 1] ** 2)\n", + " x[:, 3] = x[:, 4] ** 3\n", "\n", " # negative samples\n", " def corrupt(tensor):\n", " y = copy.deepcopy(tensor)\n", " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", + " y[:, i] = y[:, i][torch.randperm(y.shape[0])]\n", " return y\n", "\n", " x_cor = corrupt(x)\n", " x = torch.cat([x, x_cor], dim=0)\n", - " y = torch.cat([torch.ones(batch,), torch.zeros(batch,)], dim=0)[:,None]\n", + " y = torch.cat(\n", + " [\n", + " torch.ones(\n", + " batch,\n", + " ),\n", + " torch.zeros(\n", + " batch,\n", + " ),\n", + " ],\n", + " dim=0,\n", + " )[:, None]\n", " return x, y\n", - " \n", + "\n", " x = torch.rand(train_num, 6) * 2 - 1\n", " x_train, y_train = generate_contrastive(x)\n", - " \n", + "\n", " x = torch.rand(test_num, 6) * 2 - 1\n", " x_test, y_test = generate_contrastive(x)\n", - " \n", + "\n", " dataset = {}\n", - " dataset['train_input'] = x_train.to(device)\n", - " dataset['test_input'] = x_test.to(device)\n", - " dataset['train_label'] = y_train.to(device)\n", - " dataset['test_label'] = y_test.to(device)\n", + " dataset[\"train_input\"] = x_train.to(device)\n", + " dataset[\"test_input\"] = x_test.to(device)\n", + " dataset[\"train_label\"] = y_train.to(device)\n", + " dataset[\"test_label\"] = y_test.to(device)\n", " return dataset\n", "\n", + "\n", "dataset = create_dataset()" ] }, @@ -111,7 +121,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -131,8 +141,8 @@ ], "source": [ "# set the (1,0,0) activation to be gausssian\n", - "#model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)" + "# model.fix_symbolic(1,0,0,lambda x: torch.exp(-x**2/10),fit_params_bool=False)\n", + "model.fix_symbolic(1, 0, 0, \"gaussian\", fit_params_bool=False)" ] }, { @@ -153,7 +163,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -207,7 +217,7 @@ } ], "source": [ - "model.plot(in_vars=[r'$x_{}$'.format(i) for i in range(1,7)])" + "model.plot(in_vars=[r\"$x_{}$\".format(i) for i in range(1, 7)])" ] }, { diff --git a/tutorials/Example/Example_13_phase_transition.ipynb b/tutorials/Example/Example_13_phase_transition.ipynb index ae7a4241a..be688b9d8 100644 --- a/tutorials/Example/Example_13_phase_transition.ipynb +++ b/tutorials/Example/Example_13_phase_transition.ipynb @@ -44,14 +44,19 @@ "from kan import KAN, create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[3,1,1], grid=3, k=3, device=device)\n", + "model = KAN(width=[3, 1, 1], grid=3, k=3, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: (torch.sin(torch.pi*x[:,[0]]) + torch.cos(torch.pi*x[:,[1]]) + torch.tan(torch.pi/2*x[:,[2]]) > 0).float()\n", - "dataset = create_dataset(f, n_var=3, device=device)\n" + "f = lambda x: (\n", + " torch.sin(torch.pi * x[:, [0]])\n", + " + torch.cos(torch.pi * x[:, [1]])\n", + " + torch.tan(torch.pi / 2 * x[:, [2]])\n", + " > 0\n", + ").float()\n", + "dataset = create_dataset(f, n_var=3, device=device)" ] }, { @@ -74,7 +79,7 @@ } ], "source": [ - "torch.mean(dataset['train_label'])" + "torch.mean(dataset[\"train_label\"])" ] }, { @@ -95,7 +100,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, @@ -115,7 +120,7 @@ ], "source": [ "# set the last activation to be tanh\n", - "model.fix_symbolic(1,0,0,'tanh',fit_params_bool=False)" + "model.fix_symbolic(1, 0, 0, \"tanh\", fit_params_bool=False)" ] }, { @@ -136,7 +141,7 @@ } ], "source": [ - "model(dataset['train_input'])\n", + "model(dataset[\"train_input\"])\n", "model.plot(beta=10)" ] }, diff --git a/tutorials/Example/Example_14_knot_supervised.ipynb b/tutorials/Example/Example_14_knot_supervised.ipynb index 11bbfbef6..45a868f71 100644 --- a/tutorials/Example/Example_14_knot_supervised.ipynb +++ b/tutorials/Example/Example_14_knot_supervised.ipynb @@ -37,9 +37,8 @@ "import numpy as np\n", "import torch\n", "from kan import *\n", - "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 42\n", @@ -51,33 +50,35 @@ "df.keys()\n", "\n", "X = df[df.keys()[1:-1]].to_numpy()\n", - "Y = df[['signature']].to_numpy()\n", + "Y = df[[\"signature\"]].to_numpy()\n", "\n", "# normalize X\n", "X_mean = np.mean(X, axis=0)\n", "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", + "X = (X - X_mean[np.newaxis, :]) / X_std[np.newaxis, :]\n", "input_normalier = [X_mean, X_std]\n", "\n", "# normalize Y\n", "max_signature = np.max(Y)\n", "min_signature = np.min(Y)\n", - "Y = ((Y-min_signature)/2).astype(int)\n", - "n_class = int((max_signature-min_signature)/2+1)\n", + "Y = ((Y - min_signature) / 2).astype(int)\n", + "n_class = int((max_signature - min_signature) / 2 + 1)\n", "output_normalier = [min_signature, 2]\n", "\n", "dataset = {}\n", "num = X.shape[0]\n", "n_feature = X.shape[1]\n", "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", + "train_id_ = np.random.choice(num, int(num * train_ratio), replace=False)\n", + "test_id_ = np.array(list(set(range(num)) - set(train_id_)))\n", "\n", "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(Y[train_id_][:,0]).type(torch.long).to(device)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(Y[test_id_][:,0]).type(torch.long).to(device)\n" + "dataset[\"train_input\"] = torch.from_numpy(X[train_id_]).type(dtype).to(device)\n", + "dataset[\"train_label\"] = (\n", + " torch.from_numpy(Y[train_id_][:, 0]).type(torch.long).to(device)\n", + ")\n", + "dataset[\"test_input\"] = torch.from_numpy(X[test_id_]).type(dtype).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(Y[test_id_][:, 0]).type(torch.long).to(device)" ] }, { @@ -90,13 +91,30 @@ "outputs": [], "source": [ "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"train_input\"]), dim=1) == dataset[\"train_label\"]\n", + " ).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"test_input\"]), dim=1) == dataset[\"test_label\"]\n", + " ).float()\n", + " )\n", + "\n", "\n", - "model = KAN(width=[n_feature,1,n_class], grid=5, k=3, seed=seed, device=device)\n", - "model.fit(dataset, lamb=0.005, batch=1024, loss_fn = nn.CrossEntropyLoss(), metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" + "model = KAN(width=[n_feature, 1, n_class], grid=5, k=3, seed=seed, device=device)\n", + "model.fit(\n", + " dataset,\n", + " lamb=0.005,\n", + " batch=1024,\n", + " loss_fn=nn.CrossEntropyLoss(),\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"reg\", \"train_acc\", \"test_acc\"],\n", + ");" ] }, { @@ -110,7 +128,13 @@ "\n", "n = 17\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:-1][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:-1][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] }, { @@ -125,8 +149,8 @@ "\n", "y_pos = range(len(features))\n", "plt.bar(y_pos, scores)\n", - "plt.xticks(y_pos, features, rotation=90);\n", - "plt.ylabel('feature importance')" + "plt.xticks(y_pos, features, rotation=90)\n", + "plt.ylabel(\"feature importance\")" ] } ], diff --git a/tutorials/Example/Example_15_knot_unsupervised.ipynb b/tutorials/Example/Example_15_knot_unsupervised.ipynb index 95ecd68b5..b278ac0ca 100644 --- a/tutorials/Example/Example_15_knot_unsupervised.ipynb +++ b/tutorials/Example/Example_15_knot_unsupervised.ipynb @@ -39,7 +39,7 @@ "from kan import *\n", "import copy\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "seed = 2024\n", @@ -55,37 +55,57 @@ "X = df[df.keys()[1:]].to_numpy()\n", "mean = np.mean(X, axis=0)\n", "std = np.std(X, axis=0)\n", - "X = (X - mean[np.newaxis,:])/std[np.newaxis,:]\n", + "X = (X - mean[np.newaxis, :]) / std[np.newaxis, :]\n", "\n", "# normalize X\n", "X_mean = np.mean(X, axis=0)\n", "X_std = np.std(X, axis=0)\n", - "X = (X - X_mean[np.newaxis,:])/X_std[np.newaxis,:]\n", + "X = (X - X_mean[np.newaxis, :]) / X_std[np.newaxis, :]\n", "input_normalier = [X_mean, X_std]\n", "\n", "dataset = {}\n", "num = X.shape[0]\n", "n_feature = X.shape[1]\n", "train_ratio = 0.8\n", - "train_id_ = np.random.choice(num, int(num*train_ratio), replace=False)\n", - "test_id_ = np.array(list(set(range(num))-set(train_id_)))\n", - "dataset['train_input'] = torch.from_numpy(X[train_id_]).type(dtype)\n", - "dataset['test_input'] = torch.from_numpy(X[test_id_]).type(dtype)\n", + "train_id_ = np.random.choice(num, int(num * train_ratio), replace=False)\n", + "test_id_ = np.array(list(set(range(num)) - set(train_id_)))\n", + "dataset[\"train_input\"] = torch.from_numpy(X[train_id_]).type(dtype)\n", + "dataset[\"test_input\"] = torch.from_numpy(X[test_id_]).type(dtype)\n", + "\n", "\n", "def construct_contrastive_dataset(tensor):\n", " y = copy.deepcopy(tensor)\n", " for i in range(y.shape[1]):\n", - " y[:,i] = y[:,i][torch.randperm(y.shape[0])]\n", + " y[:, i] = y[:, i][torch.randperm(y.shape[0])]\n", " return y\n", "\n", - "dataset['contrastive_train_input'] = construct_contrastive_dataset(dataset['train_input'])\n", - "dataset['contrastive_test_input'] = construct_contrastive_dataset(dataset['test_input'])\n", "\n", - "dataset['train_label'] = torch.cat([torch.ones(dataset['train_input'].shape[0],1), torch.zeros(dataset['contrastive_train_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['train_input'] = torch.cat([dataset['train_input'], dataset['contrastive_train_input']], dim=0).to(device)\n", + "dataset[\"contrastive_train_input\"] = construct_contrastive_dataset(\n", + " dataset[\"train_input\"]\n", + ")\n", + "dataset[\"contrastive_test_input\"] = construct_contrastive_dataset(dataset[\"test_input\"])\n", + "\n", + "dataset[\"train_label\"] = torch.cat(\n", + " [\n", + " torch.ones(dataset[\"train_input\"].shape[0], 1),\n", + " torch.zeros(dataset[\"contrastive_train_input\"].shape[0], 1),\n", + " ],\n", + " dim=0,\n", + ").to(device)\n", + "dataset[\"train_input\"] = torch.cat(\n", + " [dataset[\"train_input\"], dataset[\"contrastive_train_input\"]], dim=0\n", + ").to(device)\n", "\n", - "dataset['test_label'] = torch.cat([torch.ones(dataset['test_input'].shape[0],1), torch.zeros(dataset['contrastive_test_input'].shape[0],1)], dim=0).to(device)\n", - "dataset['test_input'] = torch.cat([dataset['test_input'], dataset['contrastive_test_input']], dim=0).to(device)\n" + "dataset[\"test_label\"] = torch.cat(\n", + " [\n", + " torch.ones(dataset[\"test_input\"].shape[0], 1),\n", + " torch.zeros(dataset[\"contrastive_test_input\"].shape[0], 1),\n", + " ],\n", + " dim=0,\n", + ").to(device)\n", + "dataset[\"test_input\"] = torch.cat(\n", + " [dataset[\"test_input\"], dataset[\"contrastive_test_input\"]], dim=0\n", + ").to(device)" ] }, { @@ -98,14 +118,26 @@ "outputs": [], "source": [ "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", + "\n", "\n", - "model = KAN(width=[n_feature,1,1], grid=5, k=3, seed=seed, device=device)\n", - "model.fix_symbolic(1,0,0,'gaussian',fit_params_bool=False)\n", - "model.fit(dataset, lamb=0.001, batch=1024, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'reg', 'train_acc', 'test_acc']);" + "model = KAN(width=[n_feature, 1, 1], grid=5, k=3, seed=seed, device=device)\n", + "model.fix_symbolic(1, 0, 0, \"gaussian\", fit_params_bool=False)\n", + "model.fit(\n", + " dataset,\n", + " lamb=0.001,\n", + " batch=1024,\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"reg\", \"train_acc\", \"test_acc\"],\n", + ");" ] }, { @@ -120,7 +152,13 @@ "\n", "n = 18\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] }, { @@ -135,7 +173,13 @@ "\n", "n = 18\n", "for i in range(n):\n", - " plt.gcf().get_axes()[0].text(1/(2*n)+i/n-0.005,-0.02,df.keys()[1:][i], rotation=270, rotation_mode=\"anchor\")" + " plt.gcf().get_axes()[0].text(\n", + " 1 / (2 * n) + i / n - 0.005,\n", + " -0.02,\n", + " df.keys()[1:][i],\n", + " rotation=270,\n", + " rotation_mode=\"anchor\",\n", + " )" ] } ], diff --git a/tutorials/Example/Example_1_function_fitting.ipynb b/tutorials/Example/Example_1_function_fitting.ipynb index e79e82f9a..3dba220e3 100644 --- a/tutorials/Example/Example_1_function_fitting.ipynb +++ b/tutorials/Example/Example_1_function_fitting.ipynb @@ -37,14 +37,14 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# initialize KAN with G=3\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 1, 1], grid=3, k=3, seed=1, device=device)\n", "\n", "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)" ] }, @@ -204,16 +204,16 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create dataset\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device, train_num=1000)\n", "\n", "\n", - "grids = np.array([3,5,10,20,50,100])\n", - "#grids = np.array([3,10])\n", + "grids = np.array([3, 5, 10, 20, 50, 100])\n", + "# grids = np.array([3,10])\n", "\n", "\n", "train_losses = []\n", @@ -223,13 +223,12 @@ "\n", "for i in range(grids.shape[0]):\n", " if i == 0:\n", - " model = KAN(width=[2,1,1], grid=grids[i], k=k, seed=0, device=device)\n", + " model = KAN(width=[2, 1, 1], grid=grids[i], k=k, seed=0, device=device)\n", " if i != 0:\n", " model = model.refine(grids[i])\n", " results = model.fit(dataset, opt=\"LBFGS\", steps=steps)\n", - " train_losses += results['train_loss']\n", - " test_losses += results['test_loss']\n", - " " + " train_losses += results[\"train_loss\"]\n", + " test_losses += results[\"test_loss\"]" ] }, { @@ -260,10 +259,10 @@ "source": [ "plt.plot(train_losses)\n", "plt.plot(test_losses)\n", - "plt.legend(['train', 'test'])\n", - "plt.ylabel('RMSE')\n", - "plt.xlabel('step')\n", - "plt.yscale('log')" + "plt.legend([\"train\", \"test\"])\n", + "plt.ylabel(\"RMSE\")\n", + "plt.xlabel(\"step\")\n", + "plt.yscale(\"log\")" ] }, { @@ -303,16 +302,16 @@ ], "source": [ "n_params = 3 * grids\n", - "train_vs_G = train_losses[(steps-1)::steps]\n", - "test_vs_G = test_losses[(steps-1)::steps]\n", + "train_vs_G = train_losses[(steps - 1) :: steps]\n", + "test_vs_G = test_losses[(steps - 1) :: steps]\n", "plt.plot(n_params, train_vs_G, marker=\"o\")\n", "plt.plot(n_params, test_vs_G, marker=\"o\")\n", - "plt.plot(n_params, 100*n_params**(-4.), ls=\"--\", color=\"black\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.legend(['train', 'test', r'$N^{-4}$'])\n", - "plt.xlabel('number of params')\n", - "plt.ylabel('RMSE')" + "plt.plot(n_params, 100 * n_params ** (-4.0), ls=\"--\", color=\"black\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"])\n", + "plt.xlabel(\"number of params\")\n", + "plt.ylabel(\"RMSE\")" ] }, { diff --git a/tutorials/Example/Example_3_deep_formula.ipynb b/tutorials/Example/Example_3_deep_formula.ipynb index 93346074e..3b839f220 100644 --- a/tutorials/Example/Example_3_deep_formula.ipynb +++ b/tutorials/Example/Example_3_deep_formula.ipynb @@ -58,16 +58,22 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,2,1,1], grid=3, k=3, seed=1, device=device)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 2, 1, 1], grid=3, k=3, seed=1, device=device)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000, device=device)\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);" + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.0);" ] }, { @@ -210,18 +216,18 @@ } ], "source": [ - "grids = [3,5,10,20,50]\n", - "#grids = [5]\n", + "grids = [3, 5, 10, 20, 50]\n", + "# grids = [5]\n", "\n", "train_rmse = []\n", "test_rmse = []\n", "\n", "for i in range(len(grids)):\n", - " #model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0, device=device).initialize_from_another_model(model, dataset['train_input'])\n", + " # model = KAN(width=[4,2,1,1], grid=grids[i], k=3, seed=0, device=device).initialize_from_another_model(model, dataset['train_input'])\n", " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=20);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" + " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=20)\n", + " train_rmse.append(results[\"train_loss\"][-1].item())\n", + " test_rmse.append(results[\"test_loss\"][-1].item())" ] }, { @@ -261,13 +267,13 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "n_params = np.array(grids) * (4*2+2*1+1*1)\n", + "n_params = np.array(grids) * (4 * 2 + 2 * 1 + 1 * 1)\n", "plt.plot(n_params, train_rmse, marker=\"o\")\n", "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 10000*n_params**(-4.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", + "plt.plot(n_params, 10000 * n_params ** (-4.0), color=\"black\", ls=\"--\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"], loc=\"lower left\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", "print(train_rmse)\n", "print(test_rmse)" ] @@ -326,12 +332,18 @@ "import torch\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[4,9,1], grid=3, k=3, seed=0)\n", - "f = lambda x: torch.exp((torch.sin(torch.pi*(x[:,[0]]**2+x[:,[1]]**2))+torch.sin(torch.pi*(x[:,[2]]**2+x[:,[3]]**2)))/2)\n", + "model = KAN(width=[4, 9, 1], grid=3, k=3, seed=0)\n", + "f = lambda x: torch.exp(\n", + " (\n", + " torch.sin(torch.pi * (x[:, [0]] ** 2 + x[:, [1]] ** 2))\n", + " + torch.sin(torch.pi * (x[:, [2]] ** 2 + x[:, [3]] ** 2))\n", + " )\n", + " / 2\n", + ")\n", "dataset = create_dataset(f, n_var=4, train_num=3000)\n", "\n", "# train the model\n", - "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.);\n", + "model.fit(dataset, opt=\"LBFGS\", steps=20, lamb=0.002, lamb_entropy=2.0)\n", "model.plot(beta=10)" ] }, @@ -436,17 +448,17 @@ } ], "source": [ - "grids = [3,5,10,20,50]\n", + "grids = [3, 5, 10, 20, 50]\n", "\n", "train_rmse = []\n", "test_rmse = []\n", "\n", "for i in range(len(grids)):\n", - " #model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", + " # model = KAN(width=[4,9,1], grid=grids[i], k=3, seed=0).initialize_from_another_model(model, dataset['train_input'])\n", " model = model.refine(grid=grids[i])\n", - " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30);\n", - " train_rmse.append(results['train_loss'][-1].item())\n", - " test_rmse.append(results['test_loss'][-1].item())" + " results = model.fit(dataset, opt=\"LBFGS\", steps=50, stop_grid_update_step=30)\n", + " train_rmse.append(results[\"train_loss\"][-1].item())\n", + " test_rmse.append(results[\"test_loss\"][-1].item())" ] }, { @@ -478,13 +490,13 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "n_params = np.array(grids) * (4*9+9*1)\n", + "n_params = np.array(grids) * (4 * 9 + 9 * 1)\n", "plt.plot(n_params, train_rmse, marker=\"o\")\n", "plt.plot(n_params, test_rmse, marker=\"o\")\n", - "plt.plot(n_params, 300*n_params**(-2.), color=\"black\", ls=\"--\")\n", - "plt.legend(['train', 'test', r'$N^{-4}$'], loc=\"lower left\")\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", + "plt.plot(n_params, 300 * n_params ** (-2.0), color=\"black\", ls=\"--\")\n", + "plt.legend([\"train\", \"test\", r\"$N^{-4}$\"], loc=\"lower left\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", "print(train_rmse)\n", "print(test_rmse)" ] diff --git a/tutorials/Example/Example_4_classfication.ipynb b/tutorials/Example/Example_4_classfication.ipynb index 2887838d6..bf032db51 100644 --- a/tutorials/Example/Example_4_classfication.ipynb +++ b/tutorials/Example/Example_4_classfication.ipynb @@ -66,22 +66,30 @@ "from sklearn.datasets import make_moons\n", "import numpy as np\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", + "train_input, train_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", + "test_input, test_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", "\n", "dtype = torch.get_default_dtype()\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label[:,None]).type(dtype).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label[:,None]).type(dtype).to(device)\n", + "dataset[\"train_input\"] = torch.from_numpy(train_input).type(dtype).to(device)\n", + "dataset[\"test_input\"] = torch.from_numpy(test_input).type(dtype).to(device)\n", + "dataset[\"train_label\"] = torch.from_numpy(train_label[:, None]).type(dtype).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(test_label[:, None]).type(dtype).to(device)\n", "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:,0].cpu().detach().numpy())" + "X = dataset[\"train_input\"]\n", + "y = dataset[\"train_label\"]\n", + "plt.scatter(\n", + " X[:, 0].cpu().detach().numpy(),\n", + " X[:, 1].cpu().detach().numpy(),\n", + " c=y[:, 0].cpu().detach().numpy(),\n", + ")" ] }, { @@ -139,16 +147,29 @@ } ], "source": [ - "model = KAN(width=[2,1], grid=3, k=3, device=device)\n", + "model = KAN(width=[2, 1], grid=3, k=3, device=device)\n", + "\n", "\n", "def train_acc():\n", - " return torch.mean((torch.round(model(dataset['train_input'])[:,0]) == dataset['train_label'][:,0]).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"train_input\"])[:, 0])\n", + " == dataset[\"train_label\"][:, 0]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.round(model(dataset['test_input'])[:,0]) == dataset['test_label'][:,0]).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.round(model(dataset[\"test_input\"])[:, 0])\n", + " == dataset[\"test_label\"][:, 0]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc));\n", - "results['train_acc'][-1], results['test_acc'][-1]" + "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc))\n", + "results[\"train_acc\"][-1], results[\"test_acc\"][-1]" ] }, { @@ -189,7 +210,7 @@ } ], "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','tan','abs']\n", + "lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"tan\", \"abs\"]\n", "model.auto_symbolic(lib=lib)\n", "formula = model.symbolic_formula()[0][0]\n", "ex_round(formula, 4)" @@ -224,11 +245,25 @@ " batch = X.shape[0]\n", " correct = 0\n", " for i in range(batch):\n", - " correct += np.round(np.array(formula.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)) == y[i,0]\n", - " return correct/batch\n", + " correct += (\n", + " np.round(\n", + " np.array(formula.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", + " )\n", + " == y[i, 0]\n", + " )\n", + " return correct / batch\n", "\n", - "print('train acc of the formula:', acc(formula, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula, dataset['test_input'], dataset['test_label']))" + "\n", + "print(\n", + " \"train acc of the formula:\",\n", + " acc(formula, dataset[\"train_input\"], dataset[\"train_label\"]),\n", + ")\n", + "print(\n", + " \"test acc of the formula:\",\n", + " acc(formula, dataset[\"test_input\"], dataset[\"test_label\"]),\n", + ")" ] }, { @@ -281,20 +316,27 @@ "import matplotlib.pyplot as plt\n", "from sklearn.datasets import make_moons\n", "import torch\n", - "import numpy as np\n", "\n", "dataset = {}\n", - "train_input, train_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", - "test_input, test_label = make_moons(n_samples=1000, shuffle=True, noise=0.1, random_state=None)\n", + "train_input, train_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", + "test_input, test_label = make_moons(\n", + " n_samples=1000, shuffle=True, noise=0.1, random_state=None\n", + ")\n", "\n", - "dataset['train_input'] = torch.from_numpy(train_input).type(dtype).to(device)\n", - "dataset['test_input'] = torch.from_numpy(test_input).type(dtype).to(device)\n", - "dataset['train_label'] = torch.from_numpy(train_label).type(torch.long).to(device)\n", - "dataset['test_label'] = torch.from_numpy(test_label).type(torch.long).to(device)\n", + "dataset[\"train_input\"] = torch.from_numpy(train_input).type(dtype).to(device)\n", + "dataset[\"test_input\"] = torch.from_numpy(test_input).type(dtype).to(device)\n", + "dataset[\"train_label\"] = torch.from_numpy(train_label).type(torch.long).to(device)\n", + "dataset[\"test_label\"] = torch.from_numpy(test_label).type(torch.long).to(device)\n", "\n", - "X = dataset['train_input']\n", - "y = dataset['train_label']\n", - "plt.scatter(X[:,0].cpu().detach().numpy(), X[:,1].cpu().detach().numpy(), c=y[:].cpu().detach().numpy())" + "X = dataset[\"train_input\"]\n", + "y = dataset[\"train_label\"]\n", + "plt.scatter(\n", + " X[:, 0].cpu().detach().numpy(),\n", + " X[:, 1].cpu().detach().numpy(),\n", + " c=y[:].cpu().detach().numpy(),\n", + ")" ] }, { @@ -342,15 +384,32 @@ } ], "source": [ - "model = KAN(width=[2,2], grid=3, k=3, seed=2024, device=device)\n", + "model = KAN(width=[2, 2], grid=3, k=3, seed=2024, device=device)\n", + "\n", "\n", "def train_acc():\n", - " return torch.mean((torch.argmax(model(dataset['train_input']), dim=1) == dataset['train_label']).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"train_input\"]), dim=1) == dataset[\"train_label\"]\n", + " ).type(dtype)\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean((torch.argmax(model(dataset['test_input']), dim=1) == dataset['test_label']).type(dtype))\n", + " return torch.mean(\n", + " (\n", + " torch.argmax(model(dataset[\"test_input\"]), dim=1) == dataset[\"test_label\"]\n", + " ).type(dtype)\n", + " )\n", "\n", - "results = model.fit(dataset, opt=\"LBFGS\", steps=20, metrics=(train_acc, test_acc), loss_fn=torch.nn.CrossEntropyLoss());" + "\n", + "results = model.fit(\n", + " dataset,\n", + " opt=\"LBFGS\",\n", + " steps=20,\n", + " metrics=(train_acc, test_acc),\n", + " loss_fn=torch.nn.CrossEntropyLoss(),\n", + ");" ] }, { @@ -380,7 +439,7 @@ } ], "source": [ - "lib = ['x','x^2','x^3','x^4','exp','log','sqrt','tanh','sin','abs']\n", + "lib = [\"x\", \"x^2\", \"x^3\", \"x^4\", \"exp\", \"log\", \"sqrt\", \"tanh\", \"sin\", \"abs\"]\n", "model.auto_symbolic(lib=lib)" ] }, @@ -462,13 +521,24 @@ " batch = X.shape[0]\n", " correct = 0\n", " for i in range(batch):\n", - " logit1 = np.array(formula1.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", - " logit2 = np.array(formula2.subs('x_1', X[i,0]).subs('x_2', X[i,1])).astype(np.float64)\n", + " logit1 = np.array(formula1.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", + " logit2 = np.array(formula2.subs(\"x_1\", X[i, 0]).subs(\"x_2\", X[i, 1])).astype(\n", + " np.float64\n", + " )\n", " correct += (logit2 > logit1) == y[i]\n", - " return correct/batch\n", + " return correct / batch\n", + "\n", "\n", - "print('train acc of the formula:', acc(formula1, formula2, dataset['train_input'], dataset['train_label']))\n", - "print('test acc of the formula:', acc(formula1, formula2, dataset['test_input'], dataset['test_label']))" + "print(\n", + " \"train acc of the formula:\",\n", + " acc(formula1, formula2, dataset[\"train_input\"], dataset[\"train_label\"]),\n", + ")\n", + "print(\n", + " \"test acc of the formula:\",\n", + " acc(formula1, formula2, dataset[\"test_input\"], dataset[\"test_label\"]),\n", + ")" ] }, { diff --git a/tutorials/Example/Example_5_special_functions.ipynb b/tutorials/Example/Example_5_special_functions.ipynb index 9894cbf46..25a2f586e 100644 --- a/tutorials/Example/Example_5_special_functions.ipynb +++ b/tutorials/Example/Example_5_special_functions.ipynb @@ -49,12 +49,12 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=3, k=3, seed=2, device=device)\n", - "f = lambda x: torch.exp(torch.special.bessel_j0(20*x[:,[0]]) + x[:,[1]]**2)\n", + "model = KAN(width=[2, 1, 1], grid=3, k=3, seed=2, device=device)\n", + "f = lambda x: torch.exp(torch.special.bessel_j0(20 * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "\n", "# train the model\n", @@ -195,7 +195,7 @@ } ], "source": [ - "model.suggest_symbolic(0,0,0)" + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -234,7 +234,7 @@ "metadata": {}, "outputs": [], "source": [ - "add_symbolic('J0', torch.special.bessel_j0, c=1)" + "add_symbolic(\"J0\", torch.special.bessel_j0, c=1)" ] }, { @@ -282,7 +282,7 @@ ], "source": [ "# J0 fitting is not very good\n", - "model.suggest_symbolic(0,0,0)" + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -329,7 +329,7 @@ } ], "source": [ - "model.suggest_symbolic(0,0,0,a_range=(-40,40))" + "model.suggest_symbolic(0, 0, 0, a_range=(-40, 40))" ] } ], diff --git a/tutorials/Example/Example_6_PDE_interpretation.ipynb b/tutorials/Example/Example_6_PDE_interpretation.ipynb index a85aa1188..b79e2b631 100644 --- a/tutorials/Example/Example_6_PDE_interpretation.ipynb +++ b/tutorials/Example/Example_6_PDE_interpretation.ipynb @@ -41,51 +41,78 @@ ], "source": [ "from kan import *\n", - "import matplotlib.pyplot as plt\n", "from torch import autograd\n", "from tqdm import tqdm\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dim = 2\n", - "np_i = 21 # number of interior points (along each dimension)\n", - "np_b = 21 # number of boundary points (along each dimension)\n", + "np_i = 21 # number of interior points (along each dimension)\n", + "np_b = 21 # number of boundary points (along each dimension)\n", "ranges = [-1, 1]\n", "\n", - "model = KAN(width=[2,2,1], grid=5, k=3, seed=1, device=device)\n", + "model = KAN(width=[2, 2, 1], grid=5, k=3, seed=1, device=device)\n", + "\n", "\n", "def batch_jacobian(func, x, create_graph=False):\n", " # x in shape (Batch, Length)\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", + "sol_fun = lambda x: torch.sin(torch.pi * x[:, [0]]) * torch.sin(torch.pi * x[:, [1]])\n", + "source_fun = (\n", + " lambda x: -2\n", + " * torch.pi**2\n", + " * torch.sin(torch.pi * x[:, [0]])\n", + " * torch.sin(torch.pi * x[:, [1]])\n", + ")\n", "\n", "# interior\n", - "sampling_mode = 'random' # 'radnom' or 'mesh'\n", + "sampling_mode = \"random\" # 'radnom' or 'mesh'\n", "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", + "x_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", + "y_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "if sampling_mode == \"mesh\":\n", + " # mesh\n", + " x_i = torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + " ).permute(1, 0)\n", "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", + " # random\n", + " x_i = torch.rand((np_i**2, 2)) * 2 - 1\n", + "\n", "x_i = x_i.to(device)\n", "\n", "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "helper = lambda X, Y: torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + ").permute(1, 0)\n", "xb1 = helper(X[0], Y[0])\n", "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", + "xb3 = helper(X[:, 0], Y[:, 0])\n", + "xb4 = helper(X[:, 0], Y[:, -1])\n", "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", "\n", "x_b = x_b.to(device)\n", @@ -94,28 +121,38 @@ "alpha = 0.01\n", "log = 1\n", "\n", + "\n", "def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", + " pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", " for _ in pbar:\n", + "\n", " def closure():\n", " global pde_loss, bc_loss\n", " optimizer.zero_grad()\n", " # interior loss\n", " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", + " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:, 0, :]\n", " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", + " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:, :, :]\n", " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", + " pde_loss = torch.mean((lap - source) ** 2)\n", "\n", " # boundary loss\n", " bc_true = sol_fun(x_b)\n", " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", + " bc_loss = torch.mean((bc_pred - bc_true) ** 2)\n", "\n", " loss = alpha * pde_loss + bc_loss\n", " loss.backward()\n", @@ -127,10 +164,18 @@ " optimizer.step(closure)\n", " sol = sol_fun(x_i)\n", " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", + " l2 = torch.mean((model(x_i) - sol) ** 2)\n", "\n", " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", + " pbar.set_description(\n", + " \"pde loss: %.2e | bc loss: %.2e | l2: %.2e \"\n", + " % (\n", + " pde_loss.cpu().detach().numpy(),\n", + " bc_loss.cpu().detach().numpy(),\n", + " l2.cpu().detach().numpy(),\n", + " )\n", + " )\n", + "\n", "\n", "train()" ] @@ -208,10 +253,10 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'x')\n", - "model.fix_symbolic(0,0,1,'x')\n", - "model.fix_symbolic(0,1,0,'x')\n", - "model.fix_symbolic(0,1,1,'x')" + "model.fix_symbolic(0, 0, 0, \"x\")\n", + "model.fix_symbolic(0, 0, 1, \"x\")\n", + "model.fix_symbolic(0, 1, 0, \"x\")\n", + "model.fix_symbolic(0, 1, 1, \"x\")" ] }, { @@ -292,7 +337,7 @@ ], "source": [ "formula = model.symbolic_formula()[0][0]\n", - "ex_round(formula,6)" + "ex_round(formula, 6)" ] }, { diff --git a/tutorials/Example/Example_7_PDE_accuracy.ipynb b/tutorials/Example/Example_7_PDE_accuracy.ipynb index 0d7f03913..52884844a 100644 --- a/tutorials/Example/Example_7_PDE_accuracy.ipynb +++ b/tutorials/Example/Example_7_PDE_accuracy.ipynb @@ -48,13 +48,13 @@ "from torch import autograd\n", "from tqdm import tqdm\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "\n", "dim = 2\n", - "np_i = 51 # number of interior points (along each dimension)\n", - "np_b = 51 # number of boundary points (along each dimension)\n", + "np_i = 51 # number of interior points (along each dimension)\n", + "np_b = 51 # number of boundary points (along each dimension)\n", "ranges = [-1, 1]\n", "\n", "\n", @@ -62,33 +62,60 @@ " # x in shape (Batch, Length)\n", " def _func_sum(x):\n", " return func(x).sum(dim=0)\n", - " return autograd.functional.jacobian(_func_sum, x, create_graph=create_graph).permute(1,0,2)\n", + "\n", + " return autograd.functional.jacobian(\n", + " _func_sum, x, create_graph=create_graph\n", + " ).permute(1, 0, 2)\n", + "\n", "\n", "# define solution\n", - "sol_fun = lambda x: torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", - "source_fun = lambda x: -2*torch.pi**2 * torch.sin(torch.pi*x[:,[0]])*torch.sin(torch.pi*x[:,[1]])\n", + "sol_fun = lambda x: torch.sin(torch.pi * x[:, [0]]) * torch.sin(torch.pi * x[:, [1]])\n", + "source_fun = (\n", + " lambda x: -2\n", + " * torch.pi**2\n", + " * torch.sin(torch.pi * x[:, [0]])\n", + " * torch.sin(torch.pi * x[:, [1]])\n", + ")\n", "\n", "# interior\n", - "sampling_mode = 'mesh' # 'radnom' or 'mesh'\n", + "sampling_mode = \"mesh\" # 'radnom' or 'mesh'\n", "\n", - "x_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", - "y_mesh = torch.linspace(ranges[0],ranges[1],steps=np_i)\n", + "x_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", + "y_mesh = torch.linspace(ranges[0], ranges[1], steps=np_i)\n", "X, Y = torch.meshgrid(x_mesh, y_mesh, indexing=\"ij\")\n", - "if sampling_mode == 'mesh':\n", - " #mesh\n", - " x_i = torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "if sampling_mode == \"mesh\":\n", + " # mesh\n", + " x_i = torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + " ).permute(1, 0)\n", "else:\n", - " #random\n", - " x_i = torch.rand((np_i**2,2))*2-1\n", - " \n", + " # random\n", + " x_i = torch.rand((np_i**2, 2)) * 2 - 1\n", + "\n", "x_i = x_i.to(device)\n", "\n", "# boundary, 4 sides\n", - "helper = lambda X, Y: torch.stack([X.reshape(-1,), Y.reshape(-1,)]).permute(1,0)\n", + "helper = lambda X, Y: torch.stack(\n", + " [\n", + " X.reshape(\n", + " -1,\n", + " ),\n", + " Y.reshape(\n", + " -1,\n", + " ),\n", + " ]\n", + ").permute(1, 0)\n", "xb1 = helper(X[0], Y[0])\n", "xb2 = helper(X[-1], Y[0])\n", - "xb3 = helper(X[:,0], Y[:,0])\n", - "xb4 = helper(X[:,0], Y[:,-1])\n", + "xb3 = helper(X[:, 0], Y[:, 0])\n", + "xb4 = helper(X[:, 0], Y[:, -1])\n", "x_b = torch.cat([xb1, xb2, xb3, xb4], dim=0)\n", "\n", "x_b = x_b.to(device)\n", @@ -97,7 +124,7 @@ "log = 1\n", "\n", "\n", - "grids = [5,10,20]\n", + "grids = [5, 10, 20]\n", "steps = 50\n", "\n", "pde_losses = []\n", @@ -106,7 +133,7 @@ "\n", "for grid in grids:\n", " if grid == grids[0]:\n", - " model = KAN(width=[2,2,1], grid=grid, k=3, seed=1, device=device)\n", + " model = KAN(width=[2, 2, 1], grid=grid, k=3, seed=1, device=device)\n", " model = model.speed()\n", " else:\n", " model.save_act = True\n", @@ -115,27 +142,40 @@ " model = model.speed()\n", "\n", " def train():\n", - " optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", + " optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + " )\n", "\n", - " pbar = tqdm(range(steps), desc='description', ncols=100)\n", + " pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", " for _ in pbar:\n", + "\n", " def closure():\n", " global pde_loss, bc_loss\n", " optimizer.zero_grad()\n", " # interior loss\n", " sol = sol_fun(x_i)\n", - " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[:,0,:]\n", + " sol_D1_fun = lambda x: batch_jacobian(model, x, create_graph=True)[\n", + " :, 0, :\n", + " ]\n", " sol_D1 = sol_D1_fun(x_i)\n", - " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:,:,:]\n", - " lap = torch.sum(torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True)\n", + " sol_D2 = batch_jacobian(sol_D1_fun, x_i, create_graph=True)[:, :, :]\n", + " lap = torch.sum(\n", + " torch.diagonal(sol_D2, dim1=1, dim2=2), dim=1, keepdim=True\n", + " )\n", " source = source_fun(x_i)\n", - " pde_loss = torch.mean((lap - source)**2)\n", + " pde_loss = torch.mean((lap - source) ** 2)\n", "\n", " # boundary loss\n", " bc_true = sol_fun(x_b)\n", " bc_pred = model(x_b)\n", - " bc_loss = torch.mean((bc_pred-bc_true)**2)\n", + " bc_loss = torch.mean((bc_pred - bc_true) ** 2)\n", "\n", " loss = alpha * pde_loss + bc_loss\n", " loss.backward()\n", @@ -147,16 +187,22 @@ " optimizer.step(closure)\n", " sol = sol_fun(x_i)\n", " loss = alpha * pde_loss + bc_loss\n", - " l2 = torch.mean((model(x_i) - sol)**2)\n", + " l2 = torch.mean((model(x_i) - sol) ** 2)\n", "\n", " if _ % log == 0:\n", - " pbar.set_description(\"pde loss: %.2e | bc loss: %.2e | l2: %.2e \" % (pde_loss.cpu().detach().numpy(), bc_loss.cpu().detach().numpy(), l2.cpu().detach().numpy()))\n", + " pbar.set_description(\n", + " \"pde loss: %.2e | bc loss: %.2e | l2: %.2e \"\n", + " % (\n", + " pde_loss.cpu().detach().numpy(),\n", + " bc_loss.cpu().detach().numpy(),\n", + " l2.cpu().detach().numpy(),\n", + " )\n", + " )\n", "\n", " pde_losses.append(pde_loss.cpu().detach().numpy())\n", " bc_losses.append(bc_loss.cpu().detach().numpy())\n", " l2_losses.append(l2.cpu().detach().numpy())\n", - " \n", - " \n", + "\n", " train()" ] }, @@ -188,12 +234,12 @@ } ], "source": [ - "plt.plot(pde_losses, marker='o')\n", - "plt.plot(bc_losses, marker='o')\n", - "plt.plot(l2_losses, marker='o')\n", - "plt.yscale('log')\n", - "plt.xlabel('steps')\n", - "plt.legend(['PDE loss', 'BC loss', 'L2 squared'])" + "plt.plot(pde_losses, marker=\"o\")\n", + "plt.plot(bc_losses, marker=\"o\")\n", + "plt.plot(l2_losses, marker=\"o\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"steps\")\n", + "plt.legend([\"PDE loss\", \"BC loss\", \"L2 squared\"])" ] }, { diff --git a/tutorials/Example/Example_8_continual_learning.ipynb b/tutorials/Example/Example_8_continual_learning.ipynb index 6df4a2618..21b121ca9 100644 --- a/tutorials/Example/Example_8_continual_learning.ipynb +++ b/tutorials/Example/Example_8_continual_learning.ipynb @@ -56,21 +56,28 @@ "n_num_per_peak = 100\n", "n_sample = n_peak * n_num_per_peak\n", "\n", - "x_grid = torch.linspace(-1,1,steps=n_sample)\n", + "x_grid = torch.linspace(-1, 1, steps=n_sample)\n", "\n", - "x_centers = 2/n_peak * (np.arange(n_peak) - n_peak/2+0.5)\n", + "x_centers = 2 / n_peak * (np.arange(n_peak) - n_peak / 2 + 0.5)\n", "\n", - "x_sample = torch.stack([torch.linspace(-1/n_peak,1/n_peak,steps=n_num_per_peak)+center for center in x_centers]).reshape(-1,)\n", + "x_sample = torch.stack(\n", + " [\n", + " torch.linspace(-1 / n_peak, 1 / n_peak, steps=n_num_per_peak) + center\n", + " for center in x_centers\n", + " ]\n", + ").reshape(\n", + " -1,\n", + ")\n", "\n", "\n", - "y = 0.\n", + "y = 0.0\n", "for center in x_centers:\n", - " y += torch.exp(-(x_grid-center)**2*300)\n", - " \n", - "y_sample = 0.\n", + " y += torch.exp(-((x_grid - center) ** 2) * 300)\n", + "\n", + "y_sample = 0.0\n", "for center in x_centers:\n", - " y_sample += torch.exp(-(x_sample-center)**2*300)\n", - " \n", + " y_sample += torch.exp(-((x_sample - center) ** 2) * 300)\n", + "\n", "\n", "plt.plot(x_grid.detach().numpy(), y.detach().numpy())\n", "plt.scatter(x_sample.detach().numpy(), y_sample.detach().numpy())" @@ -105,13 +112,22 @@ "plt.subplots(1, 5, figsize=(15, 2))\n", "plt.subplots_adjust(wspace=0, hspace=0)\n", "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", + "for i in range(1, 6):\n", + " plt.subplot(1, 5, i)\n", " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.scatter(x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak].detach().numpy(), color=\"black\", s=2)\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" + " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color=\"black\", alpha=0.1)\n", + " plt.scatter(\n", + " x_sample[group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak]\n", + " .detach()\n", + " .numpy(),\n", + " y_sample[group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak]\n", + " .detach()\n", + " .numpy(),\n", + " color=\"black\",\n", + " s=2,\n", + " )\n", + " plt.xlim(-1, 1)\n", + " plt.ylim(-1, 2)" ] }, { @@ -213,17 +229,33 @@ "# setting bias_trainable=False, sp_trainable=False, sb_trainable=False is important.\n", "# otherwise KAN will have random scaling and shift for samples in previous stages\n", "\n", - "model = KAN(width=[1,1], grid=200, k=3, noise_scale=0.1, sp_trainable=False, sb_trainable=False, base_fun='zero')\n", + "model = KAN(\n", + " width=[1, 1],\n", + " grid=200,\n", + " k=3,\n", + " noise_scale=0.1,\n", + " sp_trainable=False,\n", + " sb_trainable=False,\n", + " base_fun=\"zero\",\n", + ")\n", "\n", "for group_id in range(n_peak):\n", " dataset = {}\n", - " dataset['train_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['train_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_input'] = x_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " dataset['test_label'] = y_sample[group_id*n_num_per_peak:(group_id+1)*n_num_per_peak][:,None]\n", - " model.fit(dataset, opt = 'LBFGS', steps=100, update_grid=False);\n", - " y_pred = model(x_grid[:,None])\n", - " ys.append(y_pred.detach().numpy()[:,0])" + " dataset[\"train_input\"] = x_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"train_label\"] = y_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"test_input\"] = x_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " dataset[\"test_label\"] = y_sample[\n", + " group_id * n_num_per_peak : (group_id + 1) * n_num_per_peak\n", + " ][:, None]\n", + " model.fit(dataset, opt=\"LBFGS\", steps=100, update_grid=False)\n", + " y_pred = model(x_grid[:, None])\n", + " ys.append(y_pred.detach().numpy()[:, 0])" ] }, { @@ -255,13 +287,13 @@ "plt.subplots(1, 5, figsize=(15, 2))\n", "plt.subplots_adjust(wspace=0, hspace=0)\n", "\n", - "for i in range(1,6):\n", - " plt.subplot(1,5,i)\n", + "for i in range(1, 6):\n", + " plt.subplot(1, 5, i)\n", " group_id = i - 1\n", - " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color='black', alpha=0.1)\n", - " plt.plot(x_grid.detach().numpy(), ys[i-1], color='black')\n", - " plt.xlim(-1,1)\n", - " plt.ylim(-1,2)" + " plt.plot(x_grid.detach().numpy(), y.detach().numpy(), color=\"black\", alpha=0.1)\n", + " plt.plot(x_grid.detach().numpy(), ys[i - 1], color=\"black\")\n", + " plt.xlim(-1, 1)\n", + " plt.ylim(-1, 2)" ] }, { diff --git a/tutorials/Example/Example_9_singularity.ipynb b/tutorials/Example/Example_9_singularity.ipynb index 5fd011664..af0cfa0f2 100644 --- a/tutorials/Example/Example_9_singularity.ipynb +++ b/tutorials/Example/Example_9_singularity.ipynb @@ -58,13 +58,13 @@ "from kan import *\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=2, device=device)\n", - "f = lambda x: torch.sin(2*(torch.log(x[:,[0]])+torch.log(x[:,[1]])))\n", - "dataset = create_dataset(f, n_var=2, ranges=[0.2,5], device=device)\n", + "model = KAN(width=[2, 1, 1], grid=5, k=3, seed=2, device=device)\n", + "f = lambda x: torch.sin(2 * (torch.log(x[:, [0]]) + torch.log(x[:, [1]])))\n", + "dataset = create_dataset(f, n_var=2, ranges=[0.2, 5], device=device)\n", "\n", "# train the model\n", "model.fit(dataset, opt=\"LBFGS\", steps=20);" @@ -121,9 +121,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'log')\n", - "model.fix_symbolic(0,1,0,'log')\n", - "model.fix_symbolic(1,0,0,'sin')" + "model.fix_symbolic(0, 0, 0, \"log\")\n", + "model.fix_symbolic(0, 1, 0, \"log\")\n", + "model.fix_symbolic(1, 0, 0, \"sin\")" ] }, { @@ -224,8 +224,8 @@ "import torch\n", "\n", "# create a KAN: 2D inputs, 1D output, and 5 hidden neurons. cubic spline (k=3), 5 grid intervals (grid=5).\n", - "model = KAN(width=[2,1,1], grid=5, k=3, seed=0)\n", - "f = lambda x: torch.sqrt(x[:,[0]]**2+x[:,[1]]**2)\n", + "model = KAN(width=[2, 1, 1], grid=5, k=3, seed=0)\n", + "f = lambda x: torch.sqrt(x[:, [0]] ** 2 + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2)\n", "\n", "# train the model\n", @@ -283,9 +283,9 @@ } ], "source": [ - "model.fix_symbolic(0,0,0,'x^2')\n", - "model.fix_symbolic(0,1,0,'x^2')\n", - "model.fix_symbolic(1,0,0,'sqrt')" + "model.fix_symbolic(0, 0, 0, \"x^2\")\n", + "model.fix_symbolic(0, 1, 0, \"x^2\")\n", + "model.fix_symbolic(1, 0, 0, \"sqrt\")" ] }, { @@ -303,7 +303,7 @@ } ], "source": [ - "model = model.rewind('0.4')\n", + "model = model.rewind(\"0.4\")\n", "model.get_act(dataset)" ] }, @@ -388,7 +388,14 @@ } ], "source": [ - "model.fit(dataset, opt=\"Adam\", steps=1000, lr=1e-3, update_grid=False, singularity_avoiding=True);" + "model.fit(\n", + " dataset,\n", + " opt=\"Adam\",\n", + " steps=1000,\n", + " lr=1e-3,\n", + " update_grid=False,\n", + " singularity_avoiding=True,\n", + ");" ] }, { diff --git a/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb b/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb deleted file mode 100644 index 985eb3ad5..000000000 --- a/tutorials/Interp/.ipynb_checkpoints/Interp_1_Hello, MultKAN-checkpoint.ipynb +++ /dev/null @@ -1,347 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c982abca", - "metadata": {}, - "source": [ - "# Interpretability 1: Hello, MultKAN!" - ] - }, - { - "cell_type": "markdown", - "id": "30fde2f3", - "metadata": {}, - "source": [ - "Motivation: The original KAN has some level of interpretability, but sometimes not fully interpretable (fully interpretable = convert the network to a symbolic formula). The biggest limitation is the lack of multiplications operators. The original KAN only has addition operators. Although multiplication can be expressed as addition and single-variable functions (which is the core idea of Kolmogorov-Arnold representation theorem), we still hope to explicitly have multiplications in the KANs so that multiplications can be more easily read out from KANs. " - ] - }, - { - "cell_type": "markdown", - "id": "72377ee4", - "metadata": {}, - "source": [ - "We first show how multiplications can be represented by addition and single variable functions. Usually KAN would find solutions leveraging linear functions and quadractic functions (the solutions are not unique). $$xy=((x+y)^2-(x-y)^2)/4=((x+y)^2-x^2-y^2)/2=\\cdots$$" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "76538154", - "metadata": {}, - "outputs": [ - { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'kan'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mkan\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;241m*\u001b[39m\n\u001b[1;32m 2\u001b[0m torch\u001b[38;5;241m.\u001b[39mset_default_dtype(torch\u001b[38;5;241m.\u001b[39mfloat64)\n\u001b[1;32m 4\u001b[0m device \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mdevice(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcuda\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcuda\u001b[38;5;241m.\u001b[39mis_available() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcpu\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'kan'" - ] - } - ], - "source": [ - "from kan import *\n", - "torch.set_default_dtype(torch.float64)\n", - "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "print(device)\n", - "\n", - "model = KAN(width=[2,5,1], device=device)\n", - "\n", - "f = lambda x: x[:,0] * x[:,1]\n", - "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.fit(dataset, steps=20, lamb=0.001);" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "939224b9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "2ec84826", - "metadata": {}, - "source": [ - "This network seems to be using the equality $xy=((x+y)^2-(x-y)^2)/4$ but not exactly." - ] - }, - { - "cell_type": "markdown", - "id": "b33ecf62", - "metadata": {}, - "source": [ - "Now we want to explicitly introduce multiplication operators, called MultKAN. Note that MultKAN and KAN are actually the same class in implementation, so you can use either class name. If you dig into MultKAN.py, there is a line 'KAN = MultKAN'. KAN is just a special case of MultKAN. To inlcude multiplications, you only need to modify the width parameter. For example, [2,5,1] KAN means 2 inputs, 5 hidden add neurons, and 1 output; [2,[5,2],1] MultKAN means 2 inputs, 5 hidden add neurons and 2 hidden mult neurons, and 1 output." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d8f94f0f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "checkpoint directory created: ./model\n", - "saving model version 0.0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = KAN(width=[2,[5,2],1], base_fun='identity', device=device)\n", - "model.get_act(dataset)\n", - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "4b39ad0c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 6.34e-02 | test_loss: 7.16e-02 | reg: 7.99e+00 | : 100%|█| 20/20 [00:04<00:00, 4.79it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.1\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20, lamb=0.01, lamb_coef=1.0);" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "4c0314b5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2af1c553", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.2\n" - ] - } - ], - "source": [ - "model = model.prune()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "aac1fb1c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "97851f1f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.37e-07 | test_loss: 1.66e-07 | reg: 6.31e+00 | : 100%|█| 20/20 [00:02<00:00, 6.90it\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.3\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f27281df", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fixing (0,0,0) with x, r2=0.9999999997931204, c=1\n", - "fixing (0,0,1) with 0\n", - "fixing (0,1,0) with 0\n", - "fixing (0,1,1) with x, r2=0.99999999995849, c=1\n", - "fixing (1,0,0) with x, r2=0.9999999918922519, c=1\n", - "saving model version 0.4\n" - ] - } - ], - "source": [ - "model.auto_symbolic()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "fd45a429", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| train_loss: 1.43e-16 | test_loss: 1.28e-16 | reg: 0.00e+00 | : 100%|█| 20/20 [00:00<00:00, 37.98it" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saving model version 0.5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "model.fit(dataset, steps=20);" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ffb84f4c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle x_{1} x_{2}$" - ], - "text/plain": [ - "x_1*x_2" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sf = model.symbolic_formula()[0][0]\n", - "nsimplify(ex_round(ex_round(sf, 3),3))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "900f7788", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorials/Interp/Interp_10A_swap.ipynb b/tutorials/Interp/Interp_10A_swap.ipynb index fe87fbfd5..1290edd41 100644 --- a/tutorials/Interp/Interp_10A_swap.ipynb +++ b/tutorials/Interp/Interp_10A_swap.ipynb @@ -74,7 +74,7 @@ "torch.manual_seed(seed)\n", "np.random.seed(seed)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "\n", @@ -84,10 +84,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (9 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", + "middle = np.array(\n", + " [\n", + " np.sum(inputs[:, :3], axis=1) > 1.5,\n", + " np.sum(inputs[:, 3:6], axis=1) > 1.5,\n", + " np.sum(inputs[:, 6:9], axis=1) > 1.5,\n", + " ]\n", + ").astype(np.float32)\n", + "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:, None]\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", @@ -98,14 +104,28 @@ "model = KAN(width=width, seed=seed, noise_scale=1.0, device=device)\n", "depth = len(width) - 1\n", "\n", + "\n", "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", "\n", "\n", - "model.fit(dataset, lamb=0.001, lamb_entropy=5., steps=20, stop_grid_update_step=1000, metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" + "model.fit(\n", + " dataset,\n", + " lamb=0.001,\n", + " lamb_entropy=5.0,\n", + " steps=20,\n", + " stop_grid_update_step=1000,\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"train_acc\", \"test_acc\", \"reg\"],\n", + ");" ] }, { @@ -115,7 +135,7 @@ "metadata": {}, "outputs": [], "source": [ - "#model.plot()" + "# model.plot()" ] }, { @@ -235,7 +255,7 @@ "torch.manual_seed(seed)\n", "np.random.seed(seed)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "inputs = []\n", @@ -244,10 +264,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (9 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "middle = np.array([np.sum(inputs[:,:3], axis=1) > 1.5, np.sum(inputs[:,3:6], axis=1) > 1.5, np.sum(inputs[:,6:9], axis=1) > 1.5]).astype(np.float32)\n", - "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:,None]\n", + "middle = np.array(\n", + " [\n", + " np.sum(inputs[:, :3], axis=1) > 1.5,\n", + " np.sum(inputs[:, 3:6], axis=1) > 1.5,\n", + " np.sum(inputs[:, 6:9], axis=1) > 1.5,\n", + " ]\n", + ").astype(np.float32)\n", + "labels = (np.sum(middle, axis=0) > 1.5).astype(np.float32)[:, None]\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", @@ -258,14 +284,28 @@ "model = MLP(width=width, seed=seed, device=device)\n", "depth = len(width) - 1\n", "\n", + "\n", "def train_acc():\n", - " return torch.mean(((model(dataset['train_input']) > 0.5) == dataset['train_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"train_input\"]) > 0.5) == dataset[\"train_label\"]).float()\n", + " )\n", + "\n", "\n", "def test_acc():\n", - " return torch.mean(((model(dataset['test_input']) > 0.5) == dataset['test_label']).float())\n", + " return torch.mean(\n", + " ((model(dataset[\"test_input\"]) > 0.5) == dataset[\"test_label\"]).float()\n", + " )\n", "\n", "\n", - "model.fit(dataset, lamb=0.0001, lamb_entropy=2., steps=1000, reg_metric='w', metrics=[train_acc, test_acc], display_metrics=['train_loss', 'train_acc', 'test_acc', 'reg']);" + "model.fit(\n", + " dataset,\n", + " lamb=0.0001,\n", + " lamb_entropy=2.0,\n", + " steps=1000,\n", + " reg_metric=\"w\",\n", + " metrics=[train_acc, test_acc],\n", + " display_metrics=[\"train_loss\", \"train_acc\", \"test_acc\", \"reg\"],\n", + ");" ] }, { diff --git a/tutorials/Interp/Interp_10B_swap.ipynb b/tutorials/Interp/Interp_10B_swap.ipynb index f54b5b294..d9354682c 100644 --- a/tutorials/Interp/Interp_10B_swap.ipynb +++ b/tutorials/Interp/Interp_10B_swap.ipynb @@ -58,16 +58,25 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[10,10,5], seed=1, device=device)\n", - "x = torch.normal(0,1,size=(100,2), device=device)\n", + "model = KAN(width=[10, 10, 5], seed=1, device=device)\n", + "x = torch.normal(0, 1, size=(100, 2), device=device)\n", "\n", - "#f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2)\n", - "f = lambda x: torch.cat([x[:,[0]] + x[:,[1]], x[:,[2]] + x[:,[3]], x[:,[4]] + x[:,[5]], x[:,[6]] + x[:,[7]], x[:,[8]] + x[:,[9]]], dim=1)\n", + "# f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]])+x[:,[1]]**2)\n", + "f = lambda x: torch.cat(\n", + " [\n", + " x[:, [0]] + x[:, [1]],\n", + " x[:, [2]] + x[:, [3]],\n", + " x[:, [4]] + x[:, [5]],\n", + " x[:, [6]] + x[:, [7]],\n", + " x[:, [8]] + x[:, [9]],\n", + " ],\n", + " dim=1,\n", + ")\n", "dataset = create_dataset(f, n_var=10, device=device)\n", - "model.fit(dataset, steps=20, lamb=1e-2);\n" + "model.fit(dataset, steps=20, lamb=1e-2);" ] }, { @@ -156,7 +165,7 @@ "from kan import *\n", "from kan.MLP import MLP\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "inputs = []\n", @@ -165,16 +174,16 @@ " sample = [int(string[i]) for i in range(len(string))]\n", " sample = (10 - len(sample)) * [0] + sample\n", " inputs.append(sample)\n", - " \n", + "\n", "inputs = np.array(inputs).astype(np.float32)\n", - "labels = np.sum(inputs.reshape(2**10,5,2), axis=2) % 2\n", + "labels = np.sum(inputs.reshape(2**10, 5, 2), axis=2) % 2\n", "inputs = torch.tensor(inputs)\n", "labels = torch.tensor(labels)\n", "\n", "dataset = create_dataset_from_data(inputs, labels, device=device)\n", "\n", - "model = MLP(width=[10,20,5], seed=5, device=device)\n", - "model.fit(dataset, steps=100, lamb=2e-4, reg_metric='w');" + "model = MLP(width=[10, 20, 5], seed=5, device=device)\n", + "model.fit(dataset, steps=100, lamb=2e-4, reg_metric=\"w\");" ] }, { diff --git a/tutorials/Interp/Interp_10_hessian.ipynb b/tutorials/Interp/Interp_10_hessian.ipynb index c889a6902..02306cc4b 100644 --- a/tutorials/Interp/Interp_10_hessian.ipynb +++ b/tutorials/Interp/Interp_10_hessian.ipynb @@ -57,23 +57,21 @@ "source": [ "from kan.utils import get_derivative\n", "import torch\n", - "from kan.MLP import MLP\n", "from kan.MultKAN import KAN\n", - "from kan.utils import create_dataset, model2param\n", - "import copy\n", + "from kan.utils import create_dataset\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "f = lambda x: x[:,[0]]**2\n", + "f = lambda x: x[:, [0]] ** 2\n", "dataset = create_dataset(f, n_var=1, train_num=1000, device=device)\n", "\n", - "inputs = dataset['train_input']\n", - "labels = dataset['train_label']\n", + "inputs = dataset[\"train_input\"]\n", + "labels = dataset[\"train_label\"]\n", "\n", - "#model = MLP(width = [1,30,1])\n", - "model = KAN(width=[1,5,1], device=device)\n", - "model.fit(dataset, opt='Adam', lr=1e-2, lamb=0.000, steps=1000);" + "# model = MLP(width = [1,30,1])\n", + "model = KAN(width=[1, 5, 1], device=device)\n", + "model.fit(dataset, opt=\"Adam\", lr=1e-2, lamb=0.000, steps=1000);" ] }, { @@ -104,7 +102,7 @@ "metadata": {}, "outputs": [], "source": [ - "hess = get_derivative(model, inputs, labels, derivative='hessian')\n", + "hess = get_derivative(model, inputs, labels, derivative=\"hessian\")\n", "values, vectors = torch.linalg.eigh(hess)" ] }, @@ -127,8 +125,9 @@ ], "source": [ "import matplotlib.pyplot as plt\n", - "plt.plot(values.cpu().numpy()[0], marker='o');\n", - "plt.yscale('log')" + "\n", + "plt.plot(values.cpu().numpy()[0], marker=\"o\")\n", + "plt.yscale(\"log\")" ] }, { diff --git a/tutorials/Interp/Interp_11_sparse_init.ipynb b/tutorials/Interp/Interp_11_sparse_init.ipynb index dfe4cef31..5b6945a86 100644 --- a/tutorials/Interp/Interp_11_sparse_init.ipynb +++ b/tutorials/Interp/Interp_11_sparse_init.ipynb @@ -37,11 +37,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN([5,5,5,1], sparse_init=False, device=device)\n", - "x = torch.rand(100,5).to(device)\n", + "model = KAN([5, 5, 5, 1], sparse_init=False, device=device)\n", + "x = torch.rand(100, 5).to(device)\n", "model.get_act(x)\n", "model.plot()" ] @@ -75,11 +75,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN([5,5,5,1], sparse_init=True, device=device)\n", - "x = torch.rand(100,5).to(device)\n", + "model = KAN([5, 5, 5, 1], sparse_init=True, device=device)\n", + "x = torch.rand(100, 5).to(device)\n", "model.get_act(x)\n", "model.plot()" ] diff --git a/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb b/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb index 985eb3ad5..3e5362397 100644 --- a/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb +++ b/tutorials/Interp/Interp_1_Hello, MultKAN.ipynb @@ -44,14 +44,15 @@ ], "source": [ "from kan import *\n", + "\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], device=device)\n", + "model = KAN(width=[2, 5, 1], device=device)\n", "\n", - "f = lambda x: x[:,0] * x[:,1]\n", + "f = lambda x: x[:, 0] * x[:, 1]\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "model.fit(dataset, steps=20, lamb=0.001);" ] @@ -119,7 +120,7 @@ } ], "source": [ - "model = KAN(width=[2,[5,2],1], base_fun='identity', device=device)\n", + "model = KAN(width=[2, [5, 2], 1], base_fun=\"identity\", device=device)\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -311,7 +312,7 @@ ], "source": [ "sf = model.symbolic_formula()[0][0]\n", - "nsimplify(ex_round(ex_round(sf, 3),3))" + "nsimplify(ex_round(ex_round(sf, 3), 3))" ] }, { diff --git a/tutorials/Interp/Interp_2_Advanced MultKAN.ipynb b/tutorials/Interp/Interp_2_Advanced MultKAN.ipynb index 902191af8..aa7b7eb86 100644 --- a/tutorials/Interp/Interp_2_Advanced MultKAN.ipynb +++ b/tutorials/Interp/Interp_2_Advanced MultKAN.ipynb @@ -45,11 +45,11 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,[3,2],1], device=device)\n", - "x = torch.randn(100,2).to(device)\n", + "model = KAN(width=[2, [3, 2], 1], device=device)\n", + "x = torch.randn(100, 2).to(device)\n", "model(x)\n", "model.plot()" ] @@ -88,7 +88,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=3, device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=3, device=device)\n", "model(x)\n", "model.plot()" ] @@ -127,7 +127,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=4, device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=4, device=device)\n", "model(x)\n", "model.plot()" ] @@ -174,7 +174,7 @@ } ], "source": [ - "model = KAN(width=[2,[3,2],1], mult_arity=[[],[2,3],[]], device=device)\n", + "model = KAN(width=[2, [3, 2], 1], mult_arity=[[], [2, 3], []], device=device)\n", "model(x)\n", "model.plot()" ] @@ -213,7 +213,7 @@ } ], "source": [ - "model = KAN(width=[2,[2,2],[1,3],[3,2],[1,1]], mult_arity=2, device=device)\n", + "model = KAN(width=[2, [2, 2], [1, 3], [3, 2], [1, 1]], mult_arity=2, device=device)\n", "model(x)\n", "model.plot()" ] diff --git a/tutorials/Interp/Interp_3_KAN_Compiler.ipynb b/tutorials/Interp/Interp_3_KAN_Compiler.ipynb index a328a235f..3ed847eec 100644 --- a/tutorials/Interp/Interp_3_KAN_Compiler.ipynb +++ b/tutorials/Interp/Interp_3_KAN_Compiler.ipynb @@ -46,15 +46,15 @@ "from kan.utils import create_dataset\n", "import torch\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "input_variables = x,y = symbols('x y')\n", - "expr = exp(sin(pi*x)+y**2)\n", + "input_variables = x, y = symbols(\"x y\")\n", + "expr = exp(sin(pi * x) + y**2)\n", "\n", "model = kanpiler(input_variables, expr).to(device)\n", "\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,0]) + x[:,1]**2)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, 0]) + x[:, 1] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", "model.get_act(dataset)\n", "\n", @@ -88,18 +88,17 @@ ], "source": [ "from kan.feynman import get_feynman_dataset\n", - "import matplotlib.pyplot as plt\n", "\n", - "problem_id = 36 # problem_id in 1-120\n", + "problem_id = 36 # problem_id in 1-120\n", "input_variables, expr, f, ranges = get_feynman_dataset(problem_id)\n", "n_var = len(input_variables)\n", "model = kanpiler(input_variables, expr)\n", "\n", "dataset = create_dataset(f, n_var=n_var, ranges=ranges)\n", "model.get_act(dataset)\n", - "#model.plot(in_vars=input_variables, out_vars=[expr], beta=10000, title='P{}'.format(problem_id))\n", - "model.plot(in_vars=input_variables, out_vars=[symbols('omega')], beta=10000)\n", - "#plt.savefig('./fig1.pdf', bbox_inches='tight', dpi=200)" + "# model.plot(in_vars=input_variables, out_vars=[expr], beta=10000, title='P{}'.format(problem_id))\n", + "model.plot(in_vars=input_variables, out_vars=[symbols(\"omega\")], beta=10000)\n", + "# plt.savefig('./fig1.pdf', bbox_inches='tight', dpi=200)" ] }, { @@ -128,7 +127,7 @@ } ], "source": [ - "torch.mean((model(dataset['train_input'])-dataset['train_label'])**2)" + "torch.mean((model(dataset[\"train_input\"]) - dataset[\"train_label\"]) ** 2)" ] }, { @@ -233,7 +232,7 @@ } ], "source": [ - "model.expand_width(2, 2, sum_bool=False, mult_arity=[2,3])\n", + "model.expand_width(2, 2, sum_bool=False, mult_arity=[2, 3])\n", "model.get_act(dataset)\n", "model.plot()" ] @@ -264,9 +263,9 @@ } ], "source": [ - "model.perturb(mag=0.1, mode='all')\n", + "model.perturb(mag=0.1, mode=\"all\")\n", "model.get_act(dataset)\n", - "model.plot(metric='forward_n')\n", + "model.plot(metric=\"forward_n\")\n", "# purple means both symbolic front (red) and spline front (black) are active" ] }, diff --git a/tutorials/Interp/Interp_4_feature_attribution.ipynb b/tutorials/Interp/Interp_4_feature_attribution.ipynb index 5f0d764bc..d138fffed 100644 --- a/tutorials/Interp/Interp_4_feature_attribution.ipynb +++ b/tutorials/Interp/Interp_4_feature_attribution.ipynb @@ -57,16 +57,16 @@ "from kan import *\n", "from sympy import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "# let's construct a dataset\n", - "f = lambda x: x[:,0]**2 + 0.3*x[:,1] + 0.1*x[:,2]**3 + 0.0*x[:,3]\n", + "f = lambda x: x[:, 0] ** 2 + 0.3 * x[:, 1] + 0.1 * x[:, 2] ** 3 + 0.0 * x[:, 3]\n", "dataset = create_dataset(f, n_var=4, device=device)\n", "\n", - "input_vars = [r'$x_'+str(i)+'$' for i in range(4)]\n", + "input_vars = [r\"$x_\" + str(i) + \"$\" for i in range(4)]\n", "\n", - "model = KAN(width=[4,5,1], device=device)\n", + "model = KAN(width=[4, 5, 1], device=device)\n", "model.fit(dataset, steps=40, lamb=0.001);" ] }, @@ -159,7 +159,7 @@ ], "source": [ "# the 2nd neuron (index start from 0) in the 1st layer\n", - "model.attribute(1,2)" + "model.attribute(1, 2)" ] }, { @@ -193,7 +193,7 @@ "source": [ "# the 3nd neuron (index start from 0) in the 1st layer\n", "# note the y axis scale is really small\n", - "model.attribute(1,3)" + "model.attribute(1, 3)" ] }, { @@ -284,18 +284,20 @@ "# let's construct a dataset\n", "n_var = 100\n", "\n", + "\n", "def f(x):\n", " y = 0\n", " for i in range(n_var):\n", " # exponential decay\n", - " y += x[:,[i]]**2*0.5**i\n", + " y += x[:, [i]] ** 2 * 0.5**i\n", " return y\n", - " \n", + "\n", + "\n", "dataset = create_dataset(f, n_var=n_var, device=device)\n", "\n", - "input_vars = [r'$x_{'+str(i)+'}$' for i in range(n_var)]\n", + "input_vars = [r\"$x_{\" + str(i) + \"}$\" for i in range(n_var)]\n", "\n", - "model = KAN(width=[n_var,10,10,1], seed=2, device=device)\n", + "model = KAN(width=[n_var, 10, 10, 1], seed=2, device=device)\n", "model.fit(dataset, steps=50, lamb=1e-3);" ] }, @@ -335,7 +337,7 @@ } ], "source": [ - "model = model.rewind('0.1')" + "model = model.rewind(\"0.1\")" ] }, { @@ -366,11 +368,11 @@ } ], "source": [ - "plt.scatter(np.arange(n_var)+1, model.feature_score.cpu().detach().numpy())\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.xlabel('rank of input features', fontsize=15)\n", - "plt.ylabel('feature attribution score', fontsize=15)" + "plt.scatter(np.arange(n_var) + 1, model.feature_score.cpu().detach().numpy())\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"rank of input features\", fontsize=15)\n", + "plt.ylabel(\"feature attribution score\", fontsize=15)" ] }, { diff --git a/tutorials/Interp/Interp_5_test_symmetry.ipynb b/tutorials/Interp/Interp_5_test_symmetry.ipynb index 6f4c0bde8..15fbb8873 100644 --- a/tutorials/Interp/Interp_5_test_symmetry.ipynb +++ b/tutorials/Interp/Interp_5_test_symmetry.ipynb @@ -71,9 +71,9 @@ } ], "source": [ - "f = lambda x: x[:,[0]] * x[:,[1]] + x[:,[2]] * x[:,[3]] + x[:,[4]] * x[:,[5]]\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'add')" + "f = lambda x: x[:, [0]] * x[:, [1]] + x[:, [2]] * x[:, [3]] + x[:, [4]] * x[:, [5]]\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "detect_separability(f, x, \"add\")" ] }, { @@ -91,9 +91,13 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "detect_separability(f, x, 'mul');" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "detect_separability(f, x, \"mul\");" ] }, { @@ -122,10 +126,14 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "groups = [[0,1],[2,3],[4,5]]\n", - "test_separability(f, x, groups, 'mul')" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "groups = [[0, 1], [2, 3], [4, 5]]\n", + "test_separability(f, x, groups, \"mul\")" ] }, { @@ -146,7 +154,7 @@ } ], "source": [ - "test_separability(f, x, [[0,1],[2,4],[3,5]], 'mul')" + "test_separability(f, x, [[0, 1], [2, 4], [3, 5]], \"mul\")" ] }, { @@ -167,9 +175,11 @@ } ], "source": [ - "f = lambda x: torch.sin((x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]]))\n", - "x = torch.rand(100,6) * 2 - 1\n", - "test_separability(f, x, [[0,1],[2,3],[4,5]], 'mul')" + "f = lambda x: torch.sin(\n", + " (x[:, [0]] + x[:, [1]]) * (x[:, [2]] + x[:, [3]]) * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "test_separability(f, x, [[0, 1], [2, 3], [4, 5]], \"mul\")" ] }, { @@ -190,7 +200,7 @@ } ], "source": [ - "test_general_separability(f, x, [[0,1],[2,3],[4,5]])" + "test_general_separability(f, x, [[0, 1], [2, 3], [4, 5]])" ] }, { @@ -221,11 +231,15 @@ } ], "source": [ - "f = lambda x: (x[:,[0]] + x[:,[1]]) * (x[:,[2]] + x[:,[3]]) * (x[:,[4]] + x[:,[5]])\n", - "x = torch.rand(100,6) * 2 - 1\n", - "print('[0,1]:', test_symmetry(f, x, [0,1]))\n", - "print('[0,2]:', test_symmetry(f, x, [0,2]))\n", - "print('[2,3]:', test_symmetry(f, x, [2,3]))" + "f = (\n", + " lambda x: (x[:, [0]] + x[:, [1]])\n", + " * (x[:, [2]] + x[:, [3]])\n", + " * (x[:, [4]] + x[:, [5]])\n", + ")\n", + "x = torch.rand(100, 6) * 2 - 1\n", + "print(\"[0,1]:\", test_symmetry(f, x, [0, 1]))\n", + "print(\"[0,2]:\", test_symmetry(f, x, [0, 2]))\n", + "print(\"[2,3]:\", test_symmetry(f, x, [2, 3]))" ] }, { @@ -247,10 +261,10 @@ "from sympy import *\n", "\n", "# the function is only dependent on b/c, but not on the individual values of b and c.\n", - "f = lambda x: x[:,[0]] * torch.sqrt(1 + (x[:,[1]]/x[:,[2]])**2)\n", - "input_vars = a, b, c = symbols('a b c')\n", - "symmetry_var = b/c\n", - "x = torch.rand(100,3) * 2 - 1\n", + "f = lambda x: x[:, [0]] * torch.sqrt(1 + (x[:, [1]] / x[:, [2]]) ** 2)\n", + "input_vars = a, b, c = symbols(\"a b c\")\n", + "symmetry_var = b / c\n", + "x = torch.rand(100, 3) * 2 - 1\n", "test_symmetry_var(f, x, input_vars, symmetry_var);" ] }, @@ -300,9 +314,16 @@ } ], "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + ((x[:,[4]]**2 + x[:,[5]]**2) ** 2 + (x[:,[6]]**2 + x[:,[7]]**2) ** 2) ** 2\n", - "x = torch.rand(100,8) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" + "f = (\n", + " lambda x: (\n", + " (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2 + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + " )\n", + " ** 2\n", + " + ((x[:, [4]] ** 2 + x[:, [5]] ** 2) ** 2 + (x[:, [6]] ** 2 + x[:, [7]] ** 2) ** 2)\n", + " ** 2\n", + ")\n", + "x = torch.rand(100, 8) * 2 - 1\n", + "plot_tree(f, x, style=\"tree\") # by default, style = 'tree'" ] }, { @@ -323,7 +344,7 @@ } ], "source": [ - "plot_tree(f, x, style='box')" + "plot_tree(f, x, style=\"box\")" ] }, { @@ -344,9 +365,15 @@ } ], "source": [ - "f = lambda x: ((x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2) ** 2 + x[:,[4]]**2\n", - "x = torch.rand(100,5) * 2 - 1\n", - "plot_tree(f, x, style='tree') # by default, style = 'tree'" + "f = (\n", + " lambda x: (\n", + " (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2 + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + " )\n", + " ** 2\n", + " + x[:, [4]] ** 2\n", + ")\n", + "x = torch.rand(100, 5) * 2 - 1\n", + "plot_tree(f, x, style=\"tree\") # by default, style = 'tree'" ] }, { @@ -367,7 +394,7 @@ } ], "source": [ - "plot_tree(f, x, style='box')" + "plot_tree(f, x, style=\"box\")" ] }, { diff --git a/tutorials/Interp/Interp_6_test_symmetry_NN.ipynb b/tutorials/Interp/Interp_6_test_symmetry_NN.ipynb index 64edab6a5..ea7d8d6a7 100644 --- a/tutorials/Interp/Interp_6_test_symmetry_NN.ipynb +++ b/tutorials/Interp/Interp_6_test_symmetry_NN.ipynb @@ -29,8 +29,11 @@ "from kan import *\n", "from kan.hypothesis import plot_tree\n", "\n", - "f = lambda x: (x[:,[0]]**2 + x[:,[1]]**2) ** 2 + (x[:,[2]]**2 + x[:,[3]]**2) ** 2\n", - "x = torch.rand(100,4) * 2 - 1\n", + "f = (\n", + " lambda x: (x[:, [0]] ** 2 + x[:, [1]] ** 2) ** 2\n", + " + (x[:, [2]] ** 2 + x[:, [3]] ** 2) ** 2\n", + ")\n", + "x = torch.rand(100, 4) * 2 - 1\n", "plot_tree(f, x)" ] }, @@ -72,11 +75,11 @@ } ], "source": [ - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", "dataset = create_dataset(f, n_var=4, device=device)\n", - "model = KAN(width=[4,5,5,1], seed=0, device=device)\n", + "model = KAN(width=[4, 5, 5, 1], seed=0, device=device)\n", "model.fit(dataset, steps=100);" ] }, diff --git a/tutorials/Interp/Interp_8_adding_auxillary_variables.ipynb b/tutorials/Interp/Interp_8_adding_auxillary_variables.ipynb index f8dc95b2e..c9d8eeeb6 100644 --- a/tutorials/Interp/Interp_8_adding_auxillary_variables.ipynb +++ b/tutorials/Interp/Interp_8_adding_auxillary_variables.ipynb @@ -32,16 +32,16 @@ "torch.manual_seed(seed)\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "input_variables = m0, v, c = symbols('m0 v c')\n", + "input_variables = m0, v, c = symbols(\"m0 v c\")\n", "\n", "# define auxillary variables\n", - "beta = v/c\n", - "gamma = 1/sqrt(1-beta**2)\n", + "beta = v / c\n", + "gamma = 1 / sqrt(1 - beta**2)\n", "\n", "aux_vars = (beta, gamma)\n", "\n", - "f = lambda x: x[:,[0]]/torch.sqrt(1-x[:,[1]]**2/x[:,[2]]**2)\n", - "dataset = create_dataset(f, n_var=3, ranges=[[0,1],[0,0.9],[1.1,2]])\n", + "f = lambda x: x[:, [0]] / torch.sqrt(1 - x[:, [1]] ** 2 / x[:, [2]] ** 2)\n", + "dataset = create_dataset(f, n_var=3, ranges=[[0, 1], [0, 0.9], [1.1, 2]])\n", "\n", "# add auxillary variables\n", "dataset = augment_input(input_variables, aux_vars, dataset)\n", @@ -64,7 +64,7 @@ } ], "source": [ - "model = MultKAN(width=[5,[0,1]], mult_arity=2, grid=3, k=3, seed=seed)" + "model = MultKAN(width=[5, [0, 1]], mult_arity=2, grid=3, k=3, seed=seed)" ] }, { @@ -85,8 +85,13 @@ } ], "source": [ - "model(dataset['train_input'])\n", - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model(dataset[\"train_input\"])\n", + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -139,7 +144,12 @@ } ], "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -178,7 +188,12 @@ } ], "source": [ - "model.plot(in_vars=input_variables, out_vars=[m0/sqrt(1-v**2/c**2)], scale=1.0, varscale=0.7)" + "model.plot(\n", + " in_vars=input_variables,\n", + " out_vars=[m0 / sqrt(1 - v**2 / c**2)],\n", + " scale=1.0,\n", + " varscale=0.7,\n", + ")" ] }, { @@ -289,7 +304,7 @@ "source": [ "from kan.utils import ex_round\n", "\n", - "nsimplify(ex_round(ex_round(ex_round(sf,6),3),3))" + "nsimplify(ex_round(ex_round(ex_round(sf, 6), 3), 3))" ] }, { diff --git a/tutorials/Interp/Interp_9_different_plotting_metrics.ipynb b/tutorials/Interp/Interp_9_different_plotting_metrics.ipynb index 2cfaccaba..3a4bb7876 100644 --- a/tutorials/Interp/Interp_9_different_plotting_metrics.ipynb +++ b/tutorials/Interp/Interp_9_different_plotting_metrics.ipynb @@ -41,13 +41,13 @@ "source": [ "from kan import *\n", "\n", - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)\n", "\n", - "model = KAN(width=[2,5,1], device=device)\n", - "f = lambda x: torch.exp(torch.sin(torch.pi*x[:,[0]]) + x[:,[1]]**2)\n", + "model = KAN(width=[2, 5, 1], device=device)\n", + "f = lambda x: torch.exp(torch.sin(torch.pi * x[:, [0]]) + x[:, [1]] ** 2)\n", "dataset = create_dataset(f, n_var=2, device=device)\n", - "model.fit(dataset, steps = 20, lamb=1e-3);" + "model.fit(dataset, steps=20, lamb=1e-3);" ] }, { @@ -79,7 +79,7 @@ } ], "source": [ - "model.plot(metric='forward_u')" + "model.plot(metric=\"forward_u\")" ] }, { @@ -102,7 +102,7 @@ } ], "source": [ - "model.plot(metric='forward_n')" + "model.plot(metric=\"forward_n\")" ] }, { @@ -123,7 +123,7 @@ } ], "source": [ - "model.plot(metric='backward')" + "model.plot(metric=\"backward\")" ] } ], diff --git a/tutorials/Physics/Physics_1_Lagrangian.ipynb b/tutorials/Physics/Physics_1_Lagrangian.ipynb index f847e427f..d8dfb54fe 100644 --- a/tutorials/Physics/Physics_1_Lagrangian.ipynb +++ b/tutorials/Physics/Physics_1_Lagrangian.ipynb @@ -24,44 +24,43 @@ "seed = 0\n", "torch.manual_seed(seed)\n", "\n", - "#example = 'harmonic_oscillator'\n", - "#example = 'single_pendulum'\n", - "example = 'relativistic_mass'\n", + "# example = 'harmonic_oscillator'\n", + "# example = 'single_pendulum'\n", + "example = \"relativistic_mass\"\n", "\n", "# three examples: harmonic oscillator, single pendulum, double pendulum\n", "\n", "# dimension of q\n", "# Lagrangian: (q, qd) -> (qdd)\n", "\n", - "if example == 'harmonic_oscillator':\n", + "if example == \"harmonic_oscillator\":\n", " n_sample = 1000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qd = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qdd = - q\n", + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qd = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qdd = -q\n", " x = torch.cat([q, qd], dim=1)\n", - " \n", - "if example == 'single_pendulum':\n", + "\n", + "if example == \"single_pendulum\":\n", " n_sample = 1000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qd = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " qdd = - torch.sin(q)\n", + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qd = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " qdd = -torch.sin(q)\n", " x = torch.cat([q, qd], dim=1)\n", - " \n", - "if example == 'relativistic_mass':\n", + "\n", + "if example == \"relativistic_mass\":\n", " n_sample = 10000\n", " # harmonic oscillator\n", " d = 1\n", - " q = torch.rand(size=(n_sample,1)) * 4 - 2\n", - " #qd = torch.rand(size=(n_sample,1)) * 1.998 - 0.999\n", - " #qd = 0.95 + torch.rand(size=(n_sample,1)) * 0.05\n", - " qd = torch.rand(size=(n_sample,1)) * 2 - 1\n", - " qdd = (1 - qd**2)**(3/2)\n", - " x = torch.cat([q, qd], dim=1)\n", - "\n" + " q = torch.rand(size=(n_sample, 1)) * 4 - 2\n", + " # qd = torch.rand(size=(n_sample,1)) * 1.998 - 0.999\n", + " # qd = 0.95 + torch.rand(size=(n_sample,1)) * 0.05\n", + " qd = torch.rand(size=(n_sample, 1)) * 2 - 1\n", + " qdd = (1 - qd**2) ** (3 / 2)\n", + " x = torch.cat([q, qd], dim=1)" ] }, { @@ -82,8 +81,8 @@ "from kan.compiler import kanpiler\n", "from sympy import *\n", "\n", - "input_variables = symbol_x, symbol_vx = symbols('x v_x')\n", - "expr = symbol_vx ** 2\n", + "input_variables = symbol_x, symbol_vx = symbols(\"x v_x\")\n", + "expr = symbol_vx**2\n", "model = kanpiler(input_variables, expr, grid=20)" ] }, @@ -134,7 +133,7 @@ } ], "source": [ - "model.perturb(mode='best', mag=0.1)\n", + "model.perturb(mode=\"best\", mag=0.1)\n", "model.get_act(x)\n", "model.plot()" ] @@ -157,49 +156,54 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", + "from kan.utils import create_dataset_from_data\n", "\n", "torch.use_deterministic_algorithms(True)\n", "\n", + "\n", "def closure():\n", - " \n", " global loss\n", " optimizer.zero_grad()\n", - " \n", + "\n", " jacobian = batch_jacobian(model, x, create_graph=True)\n", " hessian = batch_hessian(model, x, create_graph=True)\n", - " Lqdqd = hessian[:,d:,d:]\n", - " Lq = jacobian[:,:d]\n", - " Lqqd = hessian[:,d:,:d]\n", + " Lqdqd = hessian[:, d:, d:]\n", + " Lq = jacobian[:, :d]\n", + " Lqqd = hessian[:, d:, :d]\n", "\n", - " Lqqd_qd_prod = torch.einsum('ijk,ik->ij', Lqqd, qd)\n", + " Lqqd_qd_prod = torch.einsum(\"ijk,ik->ij\", Lqqd, qd)\n", "\n", - " qdd_pred = torch.einsum('ijk,ik->ij', torch.linalg.inv(Lqdqd), Lq - Lqqd_qd_prod)\n", - " loss = torch.mean((qdd - qdd_pred)**2)\n", + " qdd_pred = torch.einsum(\"ijk,ik->ij\", torch.linalg.inv(Lqdqd), Lq - Lqqd_qd_prod)\n", + " loss = torch.mean((qdd - qdd_pred) ** 2)\n", "\n", " loss.backward()\n", " return loss\n", "\n", + "\n", "steps = 20\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(params, lr=1e-2)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(params, lr=1e-2)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "\n", "for _ in pbar:\n", - " \n", " # update grid\n", " if _ < 5 and _ % 20 == 0:\n", " model.update_grid(x)\n", - " \n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())\n", - " \n", - " " + " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())" ] }, { @@ -287,8 +291,8 @@ } ], "source": [ - "model.unfix_symbolic(0,0,0)\n", - "model.suggest_symbolic(0,0,0)" + "model.unfix_symbolic(0, 0, 0)\n", + "model.suggest_symbolic(0, 0, 0)" ] }, { @@ -328,8 +332,8 @@ } ], "source": [ - "model.unfix_symbolic(0,1,0)\n", - "model.suggest_symbolic(0,1,0)" + "model.unfix_symbolic(0, 1, 0)\n", + "model.suggest_symbolic(0, 1, 0)" ] }, { @@ -350,7 +354,7 @@ } ], "source": [ - "x, y = model.get_fun(0,1,0)" + "x, y = model.get_fun(0, 1, 0)" ] }, { @@ -370,11 +374,9 @@ } ], "source": [ - "from kan.utils import create_dataset_from_data\n", - "\n", - "dataset2 = create_dataset_from_data(x[:,None], y[:,None])\n", - "model2 = KAN(width=[1,1,1])\n", - "model2.fix_symbolic(0,0,0,'x^2',fit_params_bool=False)" + "dataset2 = create_dataset_from_data(x[:, None], y[:, None])\n", + "model2 = KAN(width=[1, 1, 1])\n", + "model2.fix_symbolic(0, 0, 0, \"x^2\", fit_params_bool=False)" ] }, { @@ -520,7 +522,7 @@ } ], "source": [ - "model2.suggest_symbolic(1,0,0)" + "model2.suggest_symbolic(1, 0, 0)" ] }, { @@ -550,7 +552,8 @@ ], "source": [ "from kan.utils import fit_params\n", - "fit_params(x**2, y, lambda x: x**(1/2))" + "\n", + "fit_params(x**2, y, lambda x: x ** (1 / 2))" ] }, { @@ -595,6 +598,7 @@ ], "source": [ "from kan.utils import ex_round\n", + "\n", "ex_round(model2.symbolic_formula()[0][0], 2)" ] }, diff --git a/tutorials/Physics/Physics_2A_conservation_law.ipynb b/tutorials/Physics/Physics_2A_conservation_law.ipynb index 25838b472..49d4e34f6 100644 --- a/tutorials/Physics/Physics_2A_conservation_law.ipynb +++ b/tutorials/Physics/Physics_2A_conservation_law.ipynb @@ -47,20 +47,23 @@ "source": [ "from kan import *\n", "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", "\n", - "model = KAN(width=[2,1], seed=42)\n", + "model = KAN(width=[2, 1], seed=42)\n", "\n", "# the model learns the Hamiltonian H = 1/2 * (x**2 + p**2)\n", - "x = torch.rand(1000,2) * 2 - 1\n", - "flow = torch.cat([x[:,[1]], -x[:,[0]]], dim=1)\n", + "x = torch.rand(1000, 2) * 2 - 1\n", + "flow = torch.cat([x[:, [1]], -x[:, [0]]], dim=1)\n", + "\n", "\n", "def pred_fn(model, x):\n", " grad = batch_jacobian(model, x, create_graph=True)\n", - " grad_normalized = grad/torch.linalg.norm(grad, dim=1, keepdim=True)\n", + " grad_normalized = grad / torch.linalg.norm(grad, dim=1, keepdim=True)\n", " return grad_normalized\n", "\n", - "loss_fn = lambda grad_normalized, flow: torch.mean(torch.sum(flow * grad_normalized, dim=1)**2)\n", + "\n", + "loss_fn = lambda grad_normalized, flow: torch.mean(\n", + " torch.sum(flow * grad_normalized, dim=1) ** 2\n", + ")\n", "\n", "\n", "dataset = create_dataset_from_data(x, flow)\n", @@ -130,6 +133,7 @@ ], "source": [ "from kan.utils import ex_round\n", + "\n", "ex_round(model.symbolic_formula()[0][0], 3)" ] }, diff --git a/tutorials/Physics/Physics_2B_conservation_law_2D.ipynb b/tutorials/Physics/Physics_2B_conservation_law_2D.ipynb index 33189decb..751163190 100644 --- a/tutorials/Physics/Physics_2B_conservation_law_2D.ipynb +++ b/tutorials/Physics/Physics_2B_conservation_law_2D.ipynb @@ -34,63 +34,71 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", + "from kan.utils import batch_jacobian\n", "\n", "torch.use_deterministic_algorithms(True)\n", "\n", "\n", - "#model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", - "#model = KAN(width=[4,[0,2],1], seed=2, base_fun='identity')\n", - "model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=2, base_fun='identity')\n", + "model = KAN(width=[4, [0, 2], 1], seed=12, base_fun=\"identity\")\n", "\n", "# the model learns the Hamiltonian H = 1/2 * (x**2 + p**2)\n", - "x = torch.rand(1000,4) * 2 - 1\n", - "flow = torch.cat([x[:,[1]], -x[:,[0]], x[:,[3]], -x[:,[2]]], dim=1)\n", - "flow = flow/torch.linalg.norm(flow, dim=1, keepdim=True)\n", + "x = torch.rand(1000, 4) * 2 - 1\n", + "flow = torch.cat([x[:, [1]], -x[:, [0]], x[:, [3]], -x[:, [2]]], dim=1)\n", + "flow = flow / torch.linalg.norm(flow, dim=1, keepdim=True)\n", "\n", - "loss_fn = lambda v1, v2: torch.mean(torch.sum(v1 * v2, dim=1)**2)\n", + "loss_fn = lambda v1, v2: torch.mean(torch.sum(v1 * v2, dim=1) ** 2)\n", "\n", "\n", "def get_grad_normalized(model, x):\n", " grad = batch_jacobian(model, x, create_graph=True)\n", - " grad_normalized = grad/torch.linalg.norm(grad, dim=1, keepdim=True)\n", + " grad_normalized = grad / torch.linalg.norm(grad, dim=1, keepdim=True)\n", " return grad_normalized\n", "\n", + "\n", "def closure():\n", - " \n", " global cq_loss, reg_loss\n", " optimizer.zero_grad()\n", "\n", " grads = []\n", " grad = get_grad_normalized(model, x)\n", " cq_loss = loss_fn(grad, flow)\n", - " reg_loss = model.reg(lamb_l1=1., entropy_offset=1e-4, lamb_coef=1.)\n", - " \n", + " reg_loss = model.reg(lamb_l1=1.0, entropy_offset=1e-4, lamb_coef=1.0)\n", + "\n", " lamb = 1e-2\n", " objective = cq_loss + lamb * reg_loss\n", " objective.backward()\n", " return objective\n", "\n", + "\n", "steps = 50\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(params, lr=1e-2)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(params, lr=1e-2)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "\n", "for _ in pbar:\n", - " \n", " # update grid\n", " if _ < 5 and _ % 20 == 0:\n", " model.update_grid_from_samples(x)\n", - " \n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| cq_loss: %.2e | reg_loss: %.2e |\" % (cq_loss.cpu().detach().numpy(), reg_loss.cpu().detach().numpy()))\n", - " \n", - " " + " pbar.set_description(\n", + " \"| cq_loss: %.2e | reg_loss: %.2e |\"\n", + " % (cq_loss.cpu().detach().numpy(), reg_loss.cpu().detach().numpy())\n", + " )" ] }, { @@ -111,7 +119,7 @@ } ], "source": [ - "#model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=12, base_fun='identity')\n", "model.plot()" ] }, @@ -176,7 +184,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),3)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 3)" ] }, { @@ -205,7 +214,7 @@ } ], "source": [ - "#model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", + "# model = KAN(width=[4,[0,2],1], seed=0, base_fun='identity')\n", "model.plot()" ] }, @@ -275,8 +284,8 @@ } ], "source": [ - "model.unfix_symbolic(1,0,0)\n", - "model.fix_symbolic(1,0,0,'x')" + "model.unfix_symbolic(1, 0, 0)\n", + "model.fix_symbolic(1, 0, 0, \"x\")" ] }, { @@ -302,7 +311,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),3)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 3)" ] }, { @@ -409,8 +419,8 @@ } ], "source": [ - "model.unfix_symbolic(1,1,0)\n", - "model.fix_symbolic(1,1,0,'x')" + "model.unfix_symbolic(1, 1, 0)\n", + "model.fix_symbolic(1, 1, 0, \"x\")" ] }, { @@ -436,7 +446,8 @@ "source": [ "from kan.utils import ex_round\n", "from sympy import *\n", - "ex_round(expand(ex_round(model.symbolic_formula()[0][0],5)),4)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula()[0][0], 5)), 4)" ] }, { diff --git a/tutorials/Physics/Physics_3_blackhole.ipynb b/tutorials/Physics/Physics_3_blackhole.ipynb index 8decd1c05..321221fa4 100644 --- a/tutorials/Physics/Physics_3_blackhole.ipynb +++ b/tutorials/Physics/Physics_3_blackhole.ipynb @@ -23,41 +23,87 @@ "torch.use_deterministic_algorithms(True)\n", "torch.set_default_dtype(torch.float64)\n", "\n", - "#model = KAN(width=[1,5,5,1], grid=5, grid_range=[1.2,3], grid_eps=0.)\n", - "#model = KAN(width=[1,1], grid=1, grid_range=[1.2,3], grid_eps=0., base_fun='zero')\n", - "#model.speed()\n", - "model = MLP(width=[1,20,20,1])\n", + "# model = KAN(width=[1,5,5,1], grid=5, grid_range=[1.2,3], grid_eps=0.)\n", + "# model = KAN(width=[1,1], grid=1, grid_range=[1.2,3], grid_eps=0., base_fun='zero')\n", + "# model.speed()\n", + "model = MLP(width=[1, 20, 20, 1])\n", + "\n", + "# model = lambda x: 2 * torch.sqrt(x) + torch.log((torch.sqrt(x)-1)/(torch.sqrt(x)+1))\n", "\n", - "#model = lambda x: 2 * torch.sqrt(x) + torch.log((torch.sqrt(x)-1)/(torch.sqrt(x)+1))\n", "\n", "# Schwarzschild 2M = 1\n", "def g(x_):\n", " bs = x_.shape[0]\n", - " t = x_[:,0]\n", + " t = x_[:, 0]\n", " a = torch.ones_like(t)\n", - " x = x_[:,1]\n", - " y = x_[:,2]\n", - " z = x_[:,3]\n", - " r = torch.sqrt(x**2+y**2+z**2)\n", - " stack1 = torch.stack([torch.ones(bs,)-1/r, torch.zeros(bs,), torch.zeros(bs,), torch.zeros(bs,)])\n", - " stack2 = torch.stack([torch.zeros(bs,), -(1+x**2/((r-1)*r**2)), -x*y/((r-1)*r**2), -x*z/((r-1)*r**2)])\n", - " stack3 = torch.stack([torch.zeros(bs,), -x*y/((r-1)*r**2), -(1+y**2/((r-1)*r**2)), -y*z/((r-1)*r**2)])\n", - " stack4 = torch.stack([torch.zeros(bs,), -x*z/((r-1)*r**2), -y*z/((r-1)*r**2), -(1+z**2/((r-1)*r**2))])\n", - " gs = torch.stack([stack1, stack2, stack3, stack4]).permute(2,0,1)\n", + " x = x_[:, 1]\n", + " y = x_[:, 2]\n", + " z = x_[:, 3]\n", + " r = torch.sqrt(x**2 + y**2 + z**2)\n", + " stack1 = torch.stack(\n", + " [\n", + " torch.ones(\n", + " bs,\n", + " )\n", + " - 1 / r,\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " ]\n", + " )\n", + " stack2 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -(1 + x**2 / ((r - 1) * r**2)),\n", + " -x * y / ((r - 1) * r**2),\n", + " -x * z / ((r - 1) * r**2),\n", + " ]\n", + " )\n", + " stack3 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -x * y / ((r - 1) * r**2),\n", + " -(1 + y**2 / ((r - 1) * r**2)),\n", + " -y * z / ((r - 1) * r**2),\n", + " ]\n", + " )\n", + " stack4 = torch.stack(\n", + " [\n", + " torch.zeros(\n", + " bs,\n", + " ),\n", + " -x * z / ((r - 1) * r**2),\n", + " -y * z / ((r - 1) * r**2),\n", + " -(1 + z**2 / ((r - 1) * r**2)),\n", + " ]\n", + " )\n", + " gs = torch.stack([stack1, stack2, stack3, stack4]).permute(2, 0, 1)\n", " return gs\n", "\n", + "\n", "def transform_g(transform, g, x):\n", - " jac = batch_jacobian(transform, x, create_graph=True, mode='vector')\n", + " jac = batch_jacobian(transform, x, create_graph=True, mode=\"vector\")\n", " jac_inv = torch.inverse(jac)\n", - " return torch.matmul(torch.matmul(jac_inv.permute(0,2,1), g(x)),jac_inv)\n", + " return torch.matmul(torch.matmul(jac_inv.permute(0, 2, 1), g(x)), jac_inv)\n", + "\n", "\n", "def transform(x):\n", - " t = x[:,[0]]\n", - " r = torch.linalg.norm(x[:,1:], dim=1, keepdim=True)\n", + " t = x[:, [0]]\n", + " r = torch.linalg.norm(x[:, 1:], dim=1, keepdim=True)\n", " tp = t + model(r)\n", - " #u = torch.sqrt(r)\n", - " #tp = t - (2*u+torch.log((u-1)/(u+1)))\n", - " return torch.cat([tp, x[:,1:]], dim=1)\n" + " # u = torch.sqrt(r)\n", + " # tp = t - (2*u+torch.log((u-1)/(u+1)))\n", + " return torch.cat([tp, x[:, 1:]], dim=1)" ] }, { @@ -76,50 +122,58 @@ ], "source": [ "from kan import *\n", - "from kan.utils import batch_jacobian, create_dataset_from_data\n", - "import numpy as np\n", "\n", "\n", "steps = 5\n", "log = 1\n", - "optimizer = LBFGS(model.parameters(), lr=1, history_size=10, line_search_fn=\"strong_wolfe\", tolerance_grad=1e-32, tolerance_change=1e-32, tolerance_ys=1e-32)\n", - "#optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)\n", - "#optimizer = torch.optim.Adam([], lr=1e-3)\n", - "pbar = tqdm(range(steps), desc='description', ncols=100)\n", + "optimizer = LBFGS(\n", + " model.parameters(),\n", + " lr=1,\n", + " history_size=10,\n", + " line_search_fn=\"strong_wolfe\",\n", + " tolerance_grad=1e-32,\n", + " tolerance_change=1e-32,\n", + " tolerance_ys=1e-32,\n", + ")\n", + "# optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)\n", + "# optimizer = torch.optim.Adam([], lr=1e-3)\n", + "pbar = tqdm(range(steps), desc=\"description\", ncols=100)\n", "\n", "n_train = 10000\n", - "W = torch.normal(0,1,size=(n_train,4))\n", - "input_ = torch.empty(n_train,4, requires_grad=False)\n", - "input_[:,0] = torch.rand(n_train, requires_grad=True)\n", - "#rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", - "rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", - "input_[:,1:] = W[:,1:]/torch.norm(W[:,1:], dim=1, keepdim=True)*torch.unsqueeze(rs, dim=1)\n", + "W = torch.normal(0, 1, size=(n_train, 4))\n", + "input_ = torch.empty(n_train, 4, requires_grad=False)\n", + "input_[:, 0] = torch.rand(n_train, requires_grad=True)\n", + "# rs = 1.2 + 1.8 * torch.linspace(0,1,n_train)\n", + "rs = 1.2 + 1.8 * torch.linspace(0, 1, n_train)\n", + "input_[:, 1:] = (\n", + " W[:, 1:] / torch.norm(W[:, 1:], dim=1, keepdim=True) * torch.unsqueeze(rs, dim=1)\n", + ")\n", "x = input_.detach().requires_grad_(True)\n", "\n", + "\n", "def closure():\n", - " \n", " global loss\n", " global x\n", " optimizer.zero_grad()\n", - " \n", + "\n", " g_GP = transform_g(transform, g, x)\n", " num = x.shape[0]\n", - " loss = torch.mean((g_GP[:,1:,1:] + torch.eye(3,3)[None,:,:].expand(num,3,3))**2)\n", + " loss = torch.mean(\n", + " (g_GP[:, 1:, 1:] + torch.eye(3, 3)[None, :, :].expand(num, 3, 3)) ** 2\n", + " )\n", "\n", " loss.backward()\n", " return loss\n", "\n", + "\n", "for _ in pbar:\n", - " \n", - " '''if _ < 50 and _ % 5 == 0:\n", - " model.update_grid(x)'''\n", - " \n", + " \"\"\"if _ < 50 and _ % 5 == 0:\n", + " model.update_grid(x)\"\"\"\n", + "\n", " optimizer.step(closure)\n", - " \n", + "\n", " if _ % log == 0:\n", - " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())\n", - " \n", - " " + " pbar.set_description(\"| loss: %.2e |\" % loss.cpu().detach().numpy())" ] }, { @@ -176,15 +230,21 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())\n", + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())\n", "u = torch.sqrt(rs)\n", - "dt = 2*u + torch.log((u-1)/(u+1))\n", - "#plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", - "plt.plot(rs, -dt-23.85, color='orange', ls='--', lw=2)\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel(r'$\\Delta t$', fontsize=20)\n", - "#plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", - "plt.text(1.5,-23.3,r'$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C$',color='orange',fontsize=20)" + "dt = 2 * u + torch.log((u - 1) / (u + 1))\n", + "# plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", + "plt.plot(rs, -dt - 23.85, color=\"orange\", ls=\"--\", lw=2)\n", + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(r\"$\\Delta t$\", fontsize=20)\n", + "# plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", + "plt.text(\n", + " 1.5,\n", + " -23.3,\n", + " r\"$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C$\",\n", + " color=\"orange\",\n", + " fontsize=20,\n", + ")" ] }, { @@ -215,15 +275,27 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())\n", + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())\n", "u = torch.sqrt(rs)\n", - "dt = 2*u + torch.log((u-1)/(u+1))\n", - "plt.plot(rs, dt+3.65, color='red', ls='--', lw=2)\n", - "plt.plot(rs, -dt+6.5, color='orange', ls='--', lw=2)\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel(r'$\\Delta t$', fontsize=20)\n", - "plt.text(1.5,3,r'$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$',color='red',fontsize=20)\n", - "plt.text(1.5,7,r'$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C_2$',color='orange',fontsize=20)" + "dt = 2 * u + torch.log((u - 1) / (u + 1))\n", + "plt.plot(rs, dt + 3.65, color=\"red\", ls=\"--\", lw=2)\n", + "plt.plot(rs, -dt + 6.5, color=\"orange\", ls=\"--\", lw=2)\n", + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(r\"$\\Delta t$\", fontsize=20)\n", + "plt.text(\n", + " 1.5,\n", + " 3,\n", + " r\"$2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1})+C_1$\",\n", + " color=\"red\",\n", + " fontsize=20,\n", + ")\n", + "plt.text(\n", + " 1.5,\n", + " 7,\n", + " r\"$-(2\\sqrt{r}+{\\rm log}(\\frac{\\sqrt{r}-1}{\\sqrt{r}+1}))+C_2$\",\n", + " color=\"orange\",\n", + " fontsize=20,\n", + ")" ] }, { @@ -254,7 +326,7 @@ } ], "source": [ - "plt.scatter(rs.detach().numpy(), model(rs[:,None])[:,0].detach().numpy())" + "plt.scatter(rs.detach().numpy(), model(rs[:, None])[:, 0].detach().numpy())" ] }, { @@ -266,7 +338,9 @@ "source": [ "g_GP = transform_g(transform, g, x)\n", "num = x.shape[0]\n", - "loss = torch.mean((g_GP[:,1:,1:] + torch.eye(3,3)[None,:,:].expand(num,3,3))**2, dim=[1,2])" + "loss = torch.mean(\n", + " (g_GP[:, 1:, 1:] + torch.eye(3, 3)[None, :, :].expand(num, 3, 3)) ** 2, dim=[1, 2]\n", + ")" ] }, { @@ -320,9 +394,9 @@ ], "source": [ "plt.plot(rs.detach().numpy(), loss.detach().numpy())\n", - "plt.xlabel(r'$r$', fontsize=20)\n", - "plt.ylabel('Minkowski Loss', fontsize=20)\n", - "plt.plot([2.282,2.282],[0,0.08], ls='--', color='black')" + "plt.xlabel(r\"$r$\", fontsize=20)\n", + "plt.ylabel(\"Minkowski Loss\", fontsize=20)\n", + "plt.plot([2.282, 2.282], [0, 0.08], ls=\"--\", color=\"black\")" ] }, { diff --git a/tutorials/Physics/Physics_4A_constitutive_laws_P11.ipynb b/tutorials/Physics/Physics_4A_constitutive_laws_P11.ipynb index a8ada9edb..db089d05f 100644 --- a/tutorials/Physics/Physics_4A_constitutive_laws_P11.ipynb +++ b/tutorials/Physics/Physics_4A_constitutive_laws_P11.ipynb @@ -15,9 +15,11 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", @@ -33,19 +35,19 @@ "N = 1000\n", "sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -53,8 +55,7 @@ "\n", "# P12\n", "# linear: P12 = mu * (F12 + F21)\n", - "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)\n", - "\n" + "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)" ] }, { @@ -83,14 +84,22 @@ ], "source": [ "mu, lambda_ = linear.get_lame_parameters()\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "P11_l_expr = 2 * mu * (F11 - 1) + lambda_ * (F11 + F22 + F33 - 3)\n", "model = kanpiler(input_vars, P11_l_expr)\n", "\n", "F_flatten = F.reshape(N, -1)\n", "\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -120,7 +129,13 @@ "source": [ "model.perturb()\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -176,7 +191,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -186,8 +207,15 @@ "metadata": {}, "outputs": [], "source": [ - "detF = F11 * F22 * F33 + F12 * F23 * F31 + F13 * F21 * F32 - F11 * F23 * F32 - F12 * F21 * F33 - F13 * F22 * F31\n", - "D = symbols('|F|')\n", + "detF = (\n", + " F11 * F22 * F33\n", + " + F12 * F23 * F31\n", + " + F13 * F21 * F32\n", + " - F11 * F23 * F32\n", + " - F12 * F21 * F33\n", + " - F13 * F22 * F31\n", + ")\n", + "D = symbols(\"|F|\")\n", "\n", "dataset = augment_input(input_vars, [detF], dataset)" ] @@ -207,7 +235,7 @@ } ], "source": [ - "model.expand_width(0,1,perturb=True)" + "model.expand_width(0, 1, perturb=True)" ] }, { @@ -231,7 +259,13 @@ ], "source": [ "model.get_act(dataset)\n", - "model.plot(in_vars=[D] + list(input_vars), out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -263,7 +297,7 @@ } ], "source": [ - "model.fit(dataset, opt='LBFGS', steps=20);" + "model.fit(dataset, opt=\"LBFGS\", steps=20);" ] }, { @@ -285,7 +319,13 @@ ], "source": [ "model.get_act(dataset)\n", - "model.plot(in_vars=[D] + list(input_vars), out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -375,7 +415,7 @@ } ], "source": [ - "model.fit(dataset, opt='LBFGS', steps=100);" + "model.fit(dataset, opt=\"LBFGS\", steps=100);" ] }, { @@ -396,7 +436,13 @@ } ], "source": [ - "model.plot(in_vars=[D] + list(input_vars),out_vars=[r'$P_{11}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=[D] + list(input_vars),\n", + " out_vars=[r\"$P_{11}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -422,7 +468,7 @@ "source": [ "from kan.utils import ex_round\n", "\n", - "ex_round(ex_round(model.symbolic_formula(var= [D] + list(input_vars))[0][0],5),2)" + "ex_round(ex_round(model.symbolic_formula(var=[D] + list(input_vars))[0][0], 5), 2)" ] }, { @@ -443,7 +489,7 @@ } ], "source": [ - "0.28*np.log(2.5) - 0.67" + "0.28 * np.log(2.5) - 0.67" ] }, { diff --git a/tutorials/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb b/tutorials/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb index 1358cd1c9..91df35782 100644 --- a/tutorials/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb +++ b/tutorials/Physics/Physics_4B_constitutive_laws_P12_with_prior.ipynb @@ -15,9 +15,11 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", @@ -31,21 +33,21 @@ "torch.set_default_dtype(torch.float64)\n", "\n", "N = 1000\n", - "sigma = 0.2 # previously sigma = 0.2\n", + "sigma = 0.2 # previously sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -82,17 +84,25 @@ ], "source": [ "mu, lambda_ = linear.get_lame_parameters()\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "\n", "# compile more terms in ground truth\n", "# or make the network bigger\n", "P12_l_expr = mu * (F12 + F21)\n", - "model = kanpiler(input_vars, P12_l_expr, base_fun='identity')\n", + "model = kanpiler(input_vars, P12_l_expr, base_fun=\"identity\")\n", "\n", "F_flatten = F.reshape(N, -1)\n", "\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -121,7 +131,13 @@ ], "source": [ "model.expand_depth()\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -150,9 +166,15 @@ } ], "source": [ - "model.expand_width(1,5,sum_bool=False,mult_arity=2)\n", - "model.expand_width(1,4)\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.expand_width(1, 5, sum_bool=False, mult_arity=2)\n", + "model.expand_width(1, 4)\n", + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -170,7 +192,7 @@ } ], "source": [ - "model.perturb(mode='all')" + "model.perturb(mode=\"all\")" ] }, { @@ -191,7 +213,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -213,7 +241,7 @@ ], "source": [ "dataset = create_dataset_from_data(F_flatten, P12_n)\n", - "torch.sqrt(torch.mean((model(dataset['train_input']) - dataset['train_label'])**2))" + "torch.sqrt(torch.mean((model(dataset[\"train_input\"]) - dataset[\"train_label\"]) ** 2))" ] }, { @@ -245,9 +273,7 @@ } ], "source": [ - "from kan.utils import create_dataset_from_data\n", - "\n", - "#dataset = create_dataset_from_data(F_flatten, P12_n)\n", + "# dataset = create_dataset_from_data(F_flatten, P12_n)\n", "model.fit(dataset, steps=100, lamb=1e-5);" ] }, @@ -269,7 +295,13 @@ } ], "source": [ - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -298,7 +330,13 @@ ], "source": [ "model = model.prune()\n", - "model.plot(in_vars=input_vars, out_vars=[r'$P_{12}$'], varscale=0.75, scale=1.0, out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " varscale=0.75,\n", + " scale=1.0,\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -316,7 +354,7 @@ } ], "source": [ - "model = model.rewind('0.7')" + "model = model.rewind(\"0.7\")" ] }, { @@ -369,7 +407,7 @@ } ], "source": [ - "model.plot()\n" + "model.plot()" ] }, { @@ -504,7 +542,8 @@ ], "source": [ "from kan.utils import ex_round\n", - "ex_round(expand(ex_round(model.symbolic_formula(var=input_vars)[0][0],4)),2)" + "\n", + "ex_round(expand(ex_round(model.symbolic_formula(var=input_vars)[0][0], 4)), 2)" ] }, { diff --git a/tutorials/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb b/tutorials/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb index d3d5b7423..013016c25 100644 --- a/tutorials/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb +++ b/tutorials/Physics/Physics_4C_constitutive_laws_P12_without_prior.ipynb @@ -15,14 +15,15 @@ "metadata": {}, "outputs": [], "source": [ - "from constitutive_laws_generator import LinearElasticConstitutiveLaw, NeoHookeanConstitutiveLaw\n", + "from constitutive_laws_generator import (\n", + " LinearElasticConstitutiveLaw,\n", + " NeoHookeanConstitutiveLaw,\n", + ")\n", "import torch\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import random\n", "from sympy import *\n", "from kan import *\n", - "from kan.compiler import kanpiler\n", "\n", "random.seed(0)\n", "np.random.seed(0)\n", @@ -31,22 +32,22 @@ "torch.set_default_dtype(torch.float64)\n", "\n", "N = 1000\n", - "sigma = 0.5 # previously sigma = 0.2\n", + "sigma = 0.5 # previously sigma = 0.2\n", "\n", - "F = torch.eye(3,3)[None,:,:].expand(N,3,3) + (torch.rand(N,3,3)*2-1)*sigma\n", + "F = torch.eye(3, 3)[None, :, :].expand(N, 3, 3) + (torch.rand(N, 3, 3) * 2 - 1) * sigma\n", "det = torch.det(F)\n", - "F *= (det > 0)[:,None,None]\n", + "F *= (det > 0)[:, None, None]\n", "F_flatten = F.reshape(N, -1)\n", "\n", "linear = LinearElasticConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_l = linear(F)\n", - "P11_l = P_l[:,[0],[0]]\n", - "P12_l = P_l[:,[0],[1]]\n", + "P11_l = P_l[:, [0], [0]]\n", + "P12_l = P_l[:, [0], [1]]\n", "\n", "neo = NeoHookeanConstitutiveLaw(young_modulus=1.0, poisson_ratio=0.2)\n", "P_n = neo(F)\n", - "P11_n = P_n[:,[0],[0]]\n", - "P12_n = P_n[:,[0],[1]]\n", + "P11_n = P_n[:, [0], [0]]\n", + "P12_n = P_n[:, [0], [1]]\n", "\n", "# P11\n", "# linear: P11 = 2 * mu * (F11 - 1) + lambda * (F11 + F22 + F33 - 3)\n", @@ -55,7 +56,9 @@ "# P12\n", "# linear: P12 = mu * (F12 + F21)\n", "# neohookean: P12 = mu * (F12 * F11 + F22 * F21 + F32 * F31)\n", - "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols('F11 F12 F13 F21 F22 F23 F31 F32 F33')\n", + "input_vars = F11, F12, F13, F21, F22, F23, F31, F32, F33 = symbols(\n", + " \"F11 F12 F13 F21 F22 F23 F31 F32 F33\"\n", + ")\n", "dataset = create_dataset_from_data(F_flatten, P12_n)" ] }, @@ -97,7 +100,7 @@ ], "source": [ "# train from scratch without prior knowledge\n", - "model2 = KAN(width=[9,[5,5],1], base_fun='identity', sparse_init=True, seed=2)\n", + "model2 = KAN(width=[9, [5, 5], 1], base_fun=\"identity\", sparse_init=True, seed=2)\n", "model2.fit(dataset, steps=100, lamb=1e-5, lamb_coef=1.0);" ] }, @@ -127,9 +130,15 @@ } ], "source": [ - "model = KAN(width=[9,[5,5],1], base_fun='identity', sparse_init=True, seed=2)\n", + "model = KAN(width=[9, [5, 5], 1], base_fun=\"identity\", sparse_init=True, seed=2)\n", "model.get_act(F_flatten)\n", - "model.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -152,7 +161,13 @@ } ], "source": [ - "model2.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model2.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -191,7 +206,13 @@ } ], "source": [ - "model2.plot(in_vars=input_vars, scale=1.0, varscale=0.75, out_vars=[r'$P_{12}$'], out_vars_offset=0.08)" + "model2.plot(\n", + " in_vars=input_vars,\n", + " scale=1.0,\n", + " varscale=0.75,\n", + " out_vars=[r\"$P_{12}$\"],\n", + " out_vars_offset=0.08,\n", + ")" ] }, { @@ -333,10 +354,10 @@ } ], "source": [ - "model2.unfix_symbolic(1,1,0)\n", - "model2.fix_symbolic(1,1,0,'x')\n", - "model2.unfix_symbolic(1,2,0)\n", - "model2.fix_symbolic(1,2,0,'x')" + "model2.unfix_symbolic(1, 1, 0)\n", + "model2.fix_symbolic(1, 1, 0, \"x\")\n", + "model2.unfix_symbolic(1, 2, 0)\n", + "model2.fix_symbolic(1, 2, 0, \"x\")" ] }, { @@ -393,7 +414,10 @@ ], "source": [ "from kan.utils import ex_round\n", - "ex_round(expand(ex_round(ex_round(model2.symbolic_formula(var=input_vars)[0][0], 8), 5)), 2)" + "\n", + "ex_round(\n", + " expand(ex_round(ex_round(model2.symbolic_formula(var=input_vars)[0][0], 8), 5)), 2\n", + ")" ] }, {