From 6ce114de1aa9f6c4e8d2f6cb9142d7f946f70a03 Mon Sep 17 00:00:00 2001 From: arjay55 Date: Sun, 23 Jun 2024 23:14:52 +0800 Subject: [PATCH 1/7] first commit CL walkthrough --- .gitignore | 1 + tutorials/continual_learning_structural.ipynb | 244 ++++++++++++++++++ 2 files changed, 245 insertions(+) create mode 100644 tutorials/continual_learning_structural.ipynb diff --git a/.gitignore b/.gitignore index ad8827435..30f07ef55 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ docs/_static/ docs/_templates folder test +tutorials/figures/ diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb new file mode 100644 index 000000000..e74bc941a --- /dev/null +++ b/tutorials/continual_learning_structural.ipynb @@ -0,0 +1,244 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# %%\n", + "from kan import *\n", + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import pdb\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# %%\n", + "import math\n", + "from torch.utils.data import Dataset\n", + "\n", + "# f = lambda x: (x[:,[0]]**2 + x[:,[2]] + 3*torch.sin(x[:,[1]]))/(x[:,[0]] + 2*x[:,[1]] - x[:,[2]])\n", + "# sin(x) * cos(y) + exp(z/2) - x^2 * y\n", + "f = lambda x: torch.sin(x[:, [0]]) * torch.cos(x[:, [1]]) + torch.exp(x[:, [2]]/2) - x[:, [0]]**2 * x[:, [1]]\n", + "datasetall = create_dataset(f, n_var=3, train_num=20000, test_num=4000, seed=0, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", + "datasetoct0 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ## build KAN architecture" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Training KAN" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 3.63e-02 | test loss: 4.08e-02 | reg: 1.96e+01 : 100%|██| 80/80 [00:31<00:00, 2.54it/s]\n" + ] + } + ], + "source": [ + "# %%\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=[3,5,1], grid=5, k=3, noise_scale=0.1, bias_trainable=False, sp_trainable=False, sb_trainable=False, device=\"cpu\")\n", + "model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.1, device=\"cpu\")\n", + "# model.train(dataset, opt = 'Adam', steps=2000, update_grid=False, device=\"cuda\", lr=0.5e-3)\n", + "model.train(datasetoct0, opt=\"LBFGS\", steps=80);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Prediction of KAN after each stage" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "f_pred = model(datasetoct0['test_input']).to('cpu').detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9999982755051633\n" + ] + } + ], + "source": [ + "# compute R^2 between prediction and true value\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### now prune network" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = model.prune(threshold=0.1)\n", + "model(datasetoct0['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## retrain network using such model and see" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 1.12e-01 | test loss: 1.02e-01 | reg: 1.14e+01 : 100%|██| 80/80 [00:19<00:00, 4.12it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9999892189089223\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "model.train(datasetoct0, opt=\"LBFGS\", steps=80);\n", + "f_pred = model(datasetoct0['test_input']).to('cpu').detach().numpy()\n", + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## looks good, as R^2 > 0.95. We will use the network for the next dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "datasetoct1 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### freeze/slow down/regularize network and determine nodes that is the opposite of pruning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pykan-env", + "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": 2 +} From 5b4ea2e48373cb359d37813df0070398c9128fda Mon Sep 17 00:00:00 2001 From: arjay55 Date: Tue, 25 Jun 2024 00:03:00 +0800 Subject: [PATCH 2/7] latest progress --- kan/KAN.py | 9 +- tutorials/continual_learning_structural.ipynb | 489 ++++++++++++++++-- 2 files changed, 454 insertions(+), 44 deletions(-) diff --git a/kan/KAN.py b/kan/KAN.py index 76e7c321f..d3e1a70b3 100644 --- a/kan/KAN.py +++ b/kan/KAN.py @@ -760,7 +760,7 @@ def score2alpha(score): plt.gcf().get_axes()[0].text(0.5, y0 * (len(self.width) - 1) + 0.2, title, fontsize=40 * scale, horizontalalignment='center', verticalalignment='center') def train(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., stop_grid_update_step=50, batch=-1, - small_mag_threshold=1e-16, small_reg_factor=1., metrics=None, sglr_avoid=False, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', device='cpu'): + small_mag_threshold=1e-16, small_reg_factor=1., metrics=None, sglr_avoid=False, save_fig=False, in_vars=None, out_vars=None, beta=3, save_fig_freq=1, img_folder='./video', device='cpu', custom_lr_param = []): ''' training @@ -800,6 +800,8 @@ def train(self, dataset, opt="LBFGS", steps=100, log=1, lamb=0., lamb_l1=1., lam device save_fig_freq : int save figure every (save_fig_freq) step + custom_lr_param: list + custom learning rate parameters for Adam optimizer Returns: -------- @@ -851,7 +853,10 @@ def nonlinear(x, th=small_mag_threshold, factor=small_reg_factor): grid_update_freq = int(stop_grid_update_step / grid_update_num) if opt == "Adam": - optimizer = torch.optim.Adam(self.parameters(), lr=lr) + if custom_lr_param == []: + optimizer = torch.optim.Adam(self.parameters(), lr=lr) + else: + optimizer = torch.optim.Adam(custom_lr_param, 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) diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb index e74bc941a..6dab54cb3 100644 --- a/tutorials/continual_learning_structural.ipynb +++ b/tutorials/continual_learning_structural.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 8, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -47,14 +47,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "train loss: 3.63e-02 | test loss: 4.08e-02 | reg: 1.96e+01 : 100%|██| 80/80 [00:31<00:00, 2.54it/s]\n" + "train loss: 6.44e-02 | test loss: 8.14e-02 | reg: 2.31e+01 : 100%|██| 80/80 [00:34<00:00, 2.30it/s]\n" ] } ], @@ -63,80 +63,216 @@ "# 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=[3,5,1], grid=5, k=3, noise_scale=0.1, bias_trainable=False, sp_trainable=False, sb_trainable=False, device=\"cpu\")\n", - "model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.1, device=\"cpu\")\n", - "# model.train(dataset, opt = 'Adam', steps=2000, update_grid=False, device=\"cuda\", lr=0.5e-3)\n", + "model = KAN(width=[3,5,1], grid=10, k=3, sp_trainable=False, sb_trainable=False, noise_scale=0.1, device=\"cpu\")\n", + "# model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.1, device=\"cpu\")\n", + "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=0.02);\n", "model.train(datasetoct0, opt=\"LBFGS\", steps=80);" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 4, "metadata": {}, + "outputs": [], "source": [ - " Prediction of KAN after each stage" + "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()" + ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9999931568754619\n", + "R^2 of total dataset: -0.032715797424316406\n" + ] + } + ], + "source": [ + "# compute R^2 between prediction and true value\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = model.prune(threshold=0.1)\n", + "model(datasetoct0['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## retrain network using such model and see" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 7.82e-02 | test loss: 8.80e-02 | reg: 1.67e+01 : 100%|██| 80/80 [00:30<00:00, 2.60it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9999919903002592\n", + "R^2 of total dataset: 0.1378278136253357\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=0.02);\n", + "model.train(datasetoct0, opt=\"LBFGS\", steps=80);\n", + "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## looks good, as R^2 > 0.95. We will use the network for the next dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "f_pred = model(datasetoct0['test_input']).to('cpu').detach().numpy()" + "datasetoct1 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### freeze/slow down/regularize/stop early network and determine nodes that is the opposite of pruning" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()" + "# model.train(datasetoct1, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=lr_half);" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 8.38e-02 | test loss: 9.65e-02 | reg: 1.83e+01 : 100%|██| 40/40 [00:15<00:00, 2.63it/s]" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999982755051633\n" + "R^2: 0.9999920646541796\n", + "R^2 of total dataset: 0.08780598640441895\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] } ], "source": [ - "# compute R^2 between prediction and true value\n", + "model.train(datasetoct1, opt=\"LBFGS\", steps=int(80/2));\n", + "f_pred = model(datasetoct1['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct1['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2: {r2}\")" + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### now prune network" + "Less catastrophic forgetting PROVIDED that the network is well pruned. Occam's Razor?" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -145,34 +281,92 @@ ], "source": [ "model = model.prune(threshold=0.1)\n", - "model(datasetoct0['train_input'].to(\"cpu\"))\n", + "model(datasetoct1['train_input'].to(\"cpu\"))\n", "model.plot()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 13, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 4.26e-01 | test loss: 4.04e-01 | reg: 1.92e+01 : 100%|██| 26/26 [00:09<00:00, 2.70it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9998500347865047\n", + "R^2 of total dataset: -2.429469585418701\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ - "## retrain network using such model and see" + "datasetoct2 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [0, 5], [-5, 0]])\n", + "model.train(datasetoct2, opt=\"LBFGS\", steps=int(80/3));\n", + "f_pred = model(datasetoct2['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct2['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = model.prune(threshold=0.1)\n", + "model(datasetoct2['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "train loss: 1.12e-01 | test loss: 1.02e-01 | reg: 1.14e+01 : 100%|██| 80/80 [00:19<00:00, 4.12it/s]" + "train loss: 4.44e-01 | test loss: 4.49e-01 | reg: 2.04e+01 : 100%|██| 20/20 [00:07<00:00, 2.60it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999892189089223\n" + "R^2: 0.9997848986677127\n", + "R^2 of total dataset: -3.043355941772461\n" ] }, { @@ -184,40 +378,251 @@ } ], "source": [ - "model.train(datasetoct0, opt=\"LBFGS\", steps=80);\n", - "f_pred = model(datasetoct0['test_input']).to('cpu').detach().numpy()\n", - "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + "datasetoct3 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [0, 5], [0, 5]])\n", + "model.train(datasetoct3, opt=\"LBFGS\", steps=int(80/4));\n", + "f_pred = model(datasetoct3['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct3['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2: {r2}\")" + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 16, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## looks good, as R^2 > 0.95. We will use the network for the next dataset" + "model = model.prune(threshold=0.1)\n", + "model(datasetoct3['train_input'].to(\"cpu\"))\n", + "model.plot()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 3.93e-01 | test loss: 4.16e-01 | reg: 1.68e+01 : 100%|██| 16/16 [00:06<00:00, 2.41it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9998272083030315\n", + "R^2 of total dataset: -0.3068668842315674\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], "source": [ - "datasetoct1 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" + "datasetoct4 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [-5, 0], [-5, 0]])\n", + "model.train(datasetoct4, opt=\"LBFGS\", steps=int(80/5));\n", + "f_pred = model(datasetoct4['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct4['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 18, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "### freeze/slow down/regularize network and determine nodes that is the opposite of pruning" + "model = model.prune(threshold=0.1)\n", + "model(datasetoct4['train_input'].to(\"cpu\"))\n", + "model.plot()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 19, "metadata": {}, - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 4.05e-01 | test loss: 3.67e-01 | reg: 1.76e+01 : 100%|██| 13/13 [00:05<00:00, 2.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9998897911209497\n", + "R^2 of total dataset: -0.27749812602996826\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "datasetoct5 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [-5, 0], [0, 5]])\n", + "model.train(datasetoct5, opt=\"LBFGS\", steps=int(80/6));\n", + "f_pred = model(datasetoct5['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct5['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")\n", + "\n", + "model = model.prune(threshold=0.1)\n", + "model(datasetoct5['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 1.26e+00 | test loss: 1.18e+00 | reg: 1.68e+01 : 100%|██| 11/11 [00:04<00:00, 2.54it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9984267080435529\n", + "R^2 of total dataset: 0.1288338303565979\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "datasetoct6 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [0, 5], [-5, 0]])\n", + "model.train(datasetoct6, opt=\"LBFGS\", steps=int(80/7));\n", + "f_pred = model(datasetoct6['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct6['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")\n", + "\n", + "model = model.prune(threshold=0.1)\n", + "model(datasetoct6['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "train loss: 2.70e+00 | test loss: 2.71e+00 | reg: 3.72e+00 : 100%|██| 10/10 [00:02<00:00, 4.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2: 0.9900069534778595\n", + "R^2 of total dataset: 0.15127569437026978\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxKElEQVR4nO3dfXAU530H8O/u3el0pzvpJCEhEAiQEJJASIAt2+kE82oUg7HdgO3a4zppEnfyUpym03bSNtNpm7Zpp9MaMk2b1Mm0kInbKcHB9oCrkHFr8EsCKRjxJiwkJJCQAEl36E73fvv0D7rrW0kQgU7s7t33M+PBewh4EM/dd599nuf3SEIIASIiogySjW4AERFlH4YLERFlHMOFiIgyjuFCREQZx3AhIqKMY7gQEVHGMVyIiCjjGC5ERJRxDBciIso4hgsREWUcw4WIiDKO4UJERBnHcCEiooxjuBARUcYxXIiIKOPsRjeAyAqEEBgeHkYoFILH40FpaSkkSTK6WUSmxZEL0W0EAgHs2rULtbW1KCsrw6JFi1BWVoba2lrs2rULgUDA6CYSmZLEkyiJJtfW1oZt27YhHA4DuDl6UamjFrfbjX379qG1tdWQNhKZFcOFaBJtbW3YsmULhBBQFOWWXyfLMiRJwoEDBxgwRGkYLkTjBAIBzJs3D5FI5LbBopJlGS6XC319ffD5fDPfQCIL4JwL0Ti7d+9GOByeUrAAgKIoCIfD2LNnzwy3jMg6OHIhSiOEQG1tLbq7u3Enbw1JklBdXY3Ozk6uIiMCw4VIZ2hoCGVlZdP69aWlpRlsEZE18bEYUZpQKDStXx8MBjPUEiJrY7gQpfF4PNP69V6vN0MtIbI2hgtRmtLSUtTU1NzxvIkkSaipqUFJSckMtYzIWhguRGkkScKOHTvu6te+9NJLnMwn+n+c0Ccah/tciKaPIxeicXw+H/bt2wdJkiDLt3+LqDv0X3vtNQYLURqGC9EkWltbceDAAbhcLkiSNOFxl/qay+XCwYMHsWnTJoNaSmRODBeiW2htbUVfXx927tyJ6upq3c9VV1dj586d6O/vZ7AQTYJzLkRTIITA4cOHsXXrVrz55pt4+OGHOXlPdBscuRBNgSRJ8Pl8uh+J6NYYLkRElHEMFyIiyjiGCxERZRzDhYiIMo7hQkREGcdwISKijGO4EBFRxjFciIgo4xguRESUcQwXIiLKOIYLERFlHMOFiIgyjuFCREQZx5L7RFOUSqUQDAbh9Xphs9mMbg6RqTFciKZICAFFUbSjjYno1hguRESUcZxzISKijLMb3QAiVSqVwtGjRxEMBo1uiuWtWLEC5eXlRjeDchgfi5FpRCIRfOpTn0I0GoXH4zG6OZYkhEBXVxf++Z//GZs3bza6OZTDOHIh0xBCQJZl/PVf/zU++clPGtoWRVEQjUahKAry8/Nht1vjrZJIJPDUU0+B94xkNGu8Yyin2O12OJ3Oe/7nCiEwPDyMtrY2vPnmm+jq6kIqlcK8efOwadMmPPHEE5g3b56pV4pJkmTq9lHuYLiQKV2/fh29vb2IRCJIJBIAgPz8fBQWFsLn86GwsBBut1vbbzKdD1Q1VPbu3Ysf/OAH6O7uhqIo2s93d3fj8OHD+O53v4vPfe5zeOGFF1BaWsoPcaLbYLiQKb3xxhv4+te/DkVRtEc8sizDbrfD5XKhuLgYlZWVqK2txbJly1BfX48FCxagpKQE+fn52gf/rQJACIFUKoW+vj688cYb+OEPf4gLFy7c9nFSX18fvvnNb+I///M/sWPHDmzduhVer/euQkb9869evYpz586hp6cHiqKgpqYGK1euRHFxMcOLLI3hQqaUl5enjVhUiqIgmUwiGo3C7/eju7sbR44cAXDzUVphYSHmzp2LxYsXo66uDosWLUJlZSWKiorgcrkAAOFwGIODgzhz5gzef/99nDhxAsPDwxP+fLfbjfr6ejidTpw7dw6BQADAzVDo6OjASy+9hFdeeQXPPfccNm3ahLlz58LhcNw2zAAgHo9jYGAA77//Pg4cOIBjx45heHgYqVQKAGCz2VBdXY3f/d3fxVNPPYW8vLyMfD+J7jWGC5mSOvqY6sR0MpnEyMgIRkZGcPr0ae11m80Gh8OhPT5LJpNIJBK6x17pvF4vtmzZgs9//vNYvnw5ZFlGd3c3/uVf/gU//vGPMTo6CuDmsukPP/wQJ0+exN/8zd9g2bJlWLVqFerr6zF37lytREwsFoPf78fly5fR0dGB9vZ2dHZ2IhAITPp3S6VS6OzsxO/93u+hp6cHv//7v2/I/BPRdDFcyJSamprw53/+58jPz4fL5YIQAqFQCENDQ+jv78elS5fQ19eHkZERhMPhW4ZQKpXSRgW34/P58KlPfQovvvgimpubYbPZtFFIXV0d/u7v/g7PP/88Xn75ZRw6dAjRaBTAzRHJyMgIjhw5oo2ibDabFmbq469bhZlKLSmjtjUWi2HXrl3w+Xz44he/yFpmZDkMFzKluro61NXV6V5LD5BkMolQKITBwUF0dXXh9OnTOHPmDLq6ujA4OIhQKIREInHL0LHZbCgsLERdXR02bdqExx57DNXV1bpQUUmSBJvNhpUrV+L73/8+3nvvPXz/+9/Hu+++q41k0k010NxuNxoaGrBx40a0tLRAURTs2bMHBw8ehKIoiMfj+Nu//VvU1dVhw4YNnIMhS2G4kGWkf7g6HA4UFxejuLgYDQ0N2LJlC4QQiEQi8Pv9GBwcRH9/P65cuQK/349wOAwAKCgowOzZs7Fo0SJUV1ejoqICeXl5U/rgliQJTqcT69atw+rVq9HZ2YlDhw7hv//7v9HR0QG/3494PD5poMmyjPz8fMyaNQv19fVYvXo11qxZg9raWt0jwF/7tV/DH/7hH+Lf//3fIYTA6Ogo/uRP/gT19fWorKxkwJBlMFwoK6j7OwoKClBQUIB58+bh/vvvv+XIZTof0pIkweFwYOnSpWhoaMCXv/xl+P1+9Pf34/Lly7h69SpCoRBSqRScTid8Ph8qKiowb948VFRUoLCwcNLKymr7v/nNb6K3txfvvfceAOD8+fPYtWsXvvWtb1lmMycReypltZm+01eDpry8HOXl5Vi5cuW0f7+SkhJ861vfwvbt23Ht2jUAwN69e/Gbv/mbWL58OUcvZAmsikxkMpIkobGxEV/60pe0IAkEAnj11VdZ1oUsg+FCZEKyLOPZZ59FVVWV9tpbb72FoaEhA1tFNHUMFyKTKi8vx9atW7Xrvr4+vPvuuxy9kCUwXIhMSpIkPPHEE3C73QBuLnF+4403prTMmchoDBcik5IkCUuXLsXSpUu11z744AMMDAwY2CqiqWG4EJmY2+3Go48+ql1fv34d77//Ph+NkekxXIhMTJIkbNy4EQUFBQBuFu98++23GS5kegwXIpOrqalBTU2Ndn38+PFJy84QmQnDhcjkCgoK0NLSol1fuXIFly5dMrBFRL8aw4XIAu6//35tQ2U4HEZHRwcfjZGpMVyITE6SJDQ0NCA/Px/AzerQ6WfWEJkRw4XIAiorK1FSUqJdnz9//leeEUNkJIYLkQUUFhaisrJSu+7t7dWOESAyI4YLkQU4HA7dirFr167B7/cb2CKi22O4EFmAJEm6cAmFQtypT6bGcCGyiMWLF2srxhKJBHp6erhijEyL4UJkAZIkoaqqCk6nE8DNFWPd3d0Gt4ro1hguRBZRXl4Oj8ejXV+8eJEjFzIthguRRfh8PpSVlWnXly5dQiKRMLBFRLfGcCGyiPz8fN1y5IGBAYyNjRnYIqJbY7gQWYTNZsOCBQu0a7/fz+XIZFoMFyILWbhwofb/kUgEg4ODxjWG6DYYLkQWIUkSFixYAFm++bZNJpPo6+szuFVEk2O4EFnInDlz4HA4ANxcjtzX18cVY2RKDBciCykrK4PL5dKuOXIhs2K4EFlIYWEhCgsLteuBgQFWRyZTYrgQWYjL5dKV3r927Rr3upApMVyILMThcOg2Uvr9fkSjUQNbRDQ5hguRhdhsNl24BINBbqQkU2K4EFnM7Nmztf+PRCIYHR01sDVEk2O4EFlM+sglHo8jEAgY1xiiW2C4EFmIJEmYNWuWdq5LKpXCyMiIwa0imojhQmQxpaWl2i59RVEwMjLCjZRkOgwXIospKiqC3W7XrjlyITNiuBBZTGFhIfLy8rTr4eFhA1tDNDmGC5HFFBQUID8/X7vmyIXMiOFCZDEul0tXX8zv93POhUyH4UJkMXl5efB4PNr1jRs3kEqlDGwR0UQMFyKLcTgcunAZHR1FMpk0sEVEEzFciCzGbrejqKhIuw6FQojFYga2iGgihguRxUiSBJ/Pp12Hw2GGC5kOw4XIYiRJQnFxsXYdjUYRiUQMbBHRRAwXIgtKD5d4PI5QKGRga4gmYrgQWVD6Y7FEIoFgMGhcY4gmwXAhspjxcy6pVIpl98l0GC5EFuTz+bTilUIIlt0n02G4EFlQUVERbDYbgI/Dhbv0yUwYLkQW5PV6dZWR/X6/ga0hmojhQmRBHo9HVxmZj8XIbBguRBbkcrl0lZE5ciGzYbgQWVB+fr6uMnIgEICiKAa2iEiP4UJkQeMrI4+OjrIyMpkKw4XIgux2O7xer3YdDAZZGZlMheFCZEE2m21CZeR4PG5gi4j0GC5EFiTLsi5cwuEwotGogS0i0mO4EFlUevHKWCyGcDhsYGuI9BguRBaVXl8sHo9jbGzMuMYQjcNwIbKg8We6JJNJFq8kU2G4EFlUcXExJEkCcLMy8o0bNwxuEdHHGC5EFlVSUqJVRlYUBSMjIwa3iOhjDBciiyouLtYVr7x+/bqBrSHSY7gQWVRRURGcTqd2zXAhM2G4EFmUx+PR1RcbGhrimS5kGgwXIotyuVy6EjBDQ0OsL0amwXAhsqj8/HzdcuShoSGWgCHTYLgQWZTdbkdZWZl27ff7WQKGTIPhQmRRsiyjoqICwM1NldFoFKFQyOBWEd1k/9VfQkRm9eu//utoaGjAnDlzUFFRgfLycqObRASA4UImoygKjh49yjpZd6CyshIAcO3aNQwMDPDIYzIFhguZhizLaGhowKFDh3Do0CGjm2NZXq9XV9SSyAiS4MJ4MgkhBJLJJPdqZIDdbtdKwxAZgeFCREQZx1sbIiLKOIYLERFlHMOFiIgyjuFCREQZx3AhmiIhBFKpFFezEU0Bw4Voitrb21FSUoL29najm0JkegwXIiLKOIYLERFlHMOFiIgyjuFCREQZx3AhIqKMY7gQEVHGMVyIiCjjGC5ERJRxDBciIso4hgsREWUcw4WIiDKO4UJERBnHcCEiooxjuBARUcYxXIimQAgBv9+v+5GIbo3hQnQbgUAAu3btQm1tLdatW4dgMIh169ahtrYWu3btQiAQMLqJRKYkCd6CEU2qra0N27ZtQzgcBgDdaEWSJACA2+3Gvn370NraakgbicyK4UI0iba2NmzZsgVCCCiKcsuvk2UZkiThwIEDDBiiNAwXonECgQDmzZuHSCRy22BRybIMl8uFvr4++Hy+mW8gkQVwzoVonN27dyMcDk8pWABAURSEw2Hs2bNnhltGZB0cuRClEUKgtrYW3d3dd7QiTJIkVFdXo7OzU5uPIcplDBeiNENDQygrK5vWry8tLc1gi4isyW50A4jMIBQK4fTp03j77ben9fsEAgGGCxEYLpRjFEXBxYsX0d7ervuvq6sLAGCz2ab1+0ciEQwMDMDhcMDhcMBut2v/z8dllEv4WIyy1ujoqBYep06d0n4MhUIAgFmzZqG5uRlNTU1Yvnw5mpubUV9fj+XLl9/VnMuiRYtw5swZJJNJJBIJJBIJJJNJ7WtsNpsWNGrw2O28v6PsxJ5NlpdKpdDV1TVhNNLT0wMAsNvtaGhoQHNzM5588kk0NTWhqakJFRUVk44mduzYga997Wt33I6vfvWryM/P170mhNDCRv1xbGxMW4kmSdKEEY7dbocscyEnWRtHLmQpfr9fNxo5efIkTp8+jUgkAgCoqKjQwkP9r76+Hnl5eVP+M+7FPhdFUbTRjRo8yWRSGy2lj3LU4OEoh6yE4UKmlEwm0dnZiZMnT2qPtNrb23H58mUAQF5eHpYtW6Y90lKDpLy8PCN//p3u0D948CA2bdo0rT9THeWMf6yWSqUA3BzljB/hOBwOjnLIlBguZLihoaEJj7TOnDmDWCwGAKisrERTUxOam5u1IFmyZAkcDseMtmuqtcVee+21aQfL7aSPctIfsY0f5YwPHiIjMVzonkkkEujo6NBNsJ88eRIDAwMAgPz8fDQ2Nuom2JcvX27o0t5AIIA9e/bg29/+traiDABqamrw0ksv4TOf+QyKiooMadv4EU4ikZh0lJMeOhzl0L3CcKEZcfXqVS081CA5e/YsEokEAKCqqkq3UqupqQm1tbXTXgo8U4QQOH78OL7xjW/gL//yL7Fq1SpTLi1WFEUXOuNHObIsT7pizYx/F7I2jp1pWmKxGM6dO6ebYG9vb8e1a9cA3HxstHz5cjzwwAP4whe+oIWJ1Qo8SpKE4uJiuN1uFBcXm/bDWJZl5OXlTVjAMH7FWiQS0ZZkq6Oc9BEORzk0XQwXmhIhBAYGBrTwUEcjHR0d2l6O6upqNDU14Ytf/KL2WKu6upofUiYw2Z6a9FGO+mM0Gp10lJP+iM2swUrmwnChCSKRCM6ePTthkn14eBgA4PF40NTUhNWrV+PLX/4ympqa0NjYiMLCQoNbTnfidqOc9Edr0WhUtxl0shVrZn2cScZhuOQwIQQuX748Yd/IRx99BEVRIEkSFi9ejKamJuzYsUObI1mwYAFHI1lMHeWkbwgVQkxYPDDZKGd88HCUk7sYLjlibGwMZ86cmbBvRD0DvqioCM3Nzdi4cSO+9rWvaaORgoICYxtOpiBJ0qSjnFQqpQudWCyGsbEx7ecnW7HGUU5uYLhkGSEEenp6JjzSunDhAoQQkGUZS5YsQVNTEzZt2qRtPpw/fz7vMumO2Ww22Gy2CaOc8SvWYrGYthlVluVJH62x/2UXhouFBYNBXUFGNUiCwSAAoKSkBM3Nzdi8ebM2wb506VK4XC6DW07ZTK2XNn6TqzrKUYNnslHO+BVrHOVYF8PFAhRFQXd394TRSHd3N4Cbd4/19fVobm7GY489po1G5s6dy7tBMg11lJNuqoU9eXyB9TBcTCYQCOhGI2phRvUOr6ysbEJ134aGBjidToNbTnTnbjfKSX+0Fo/HdaMcFvY0P/5rGCSVSuHChQsTJth7e3sBAA6HA0uXLkVTUxO2bdum1daaPXu2wS0nmnnqKCf9pmmywp48vsC8GC73wMjIyIRHWqdPn0Y0GgUAzJkzB01NTXjmmWe0Uih1dXV3VCaeKNulj3LS5w0nK+wZiURY2NNg/A5nUDKZxPnz5ycUZuzv7wcAOJ1OrUz8s88+qxVmLCsrM7jlRNYlyzKcTueEUU76Mulblbzh8QUzh+Fyl65fvz6hMOOZM2cQj8cBAPPmzUNzczNeeOEFXZl43jERzbz0emmTjXLSH62NH+VMtmKNCwjuHD/ppmB0dBRvvPGGrjDj4OAgAMDlcqGxsRGrVq3CZz/7Wa0wY0lJicGtJqLxJhvlABOPL7jVKMdut8PpdM74WULZgCX3p0AIgfHfpvQ7Gd7V5IaxsTGcOnUKy5cvZ+WCHKAW9kxfKp1MJuFyuVhHbwoYLlOgfosYIrktlUohGo0iPz+fm/tymBCCnwVTwHAhIqKM49IIIiLKONNM6KdSKXzwwQcYHR01uimWd99991lys2UqlcJHH32EcDhsdFMsr6amxnKnfQIfl/ZXN0bS3TO6NptpHotFIhGsXr0akUgEXq/X6OZYkhACnZ2d+Ld/+zc8/vjjRjfnjsViMXzjG99APB7XVdmlOzMwMIAdO3agpaXF6KbcMSEEhoaGAHCOczqSySR8Pp+h7yPTjFzUcvD/8A//gLVr1xrdHNNTN4nFYjFEIhGkUikUFxdjy5YtE1a2WYkkSfjsZz+LxsZGo5tiGcFgEP/7v/+LT3ziE7DZbPirv/ory/cBr9eLvLw8KIqiLaLgBsepEUJgZGTE6GaYJ1xU6jryXKV+KKh1lCKRCAKBAK5du4b+/n709vait7cXly9fxsDAAIaHhzE6Oor6+nr85Cc/yYq7PbVcB92aenNx6tQpvPrqq+jt7UUqlcKGDRuMblrGKIqC0dFRRKNRJBIJFBUVZUX/zhWmC5dcoO6bUcPjxo0buHbtGq5cuYJLly6ht7cXly5dQl9fH65evQq/34+xsTEkEolb3pEWFBQgFovd478J3Wtq37ly5Qpef/11vPfee9q/+09+8hM0NDQY3MLMEELgxo0b2t8tEonAZrPB4/EwYCyC4TJD1BBIJBIIhUIYGhpCX18fenp60NXVhYsXL+LSpUsYHByE3+9HOBxGPB6/68cZwWBQV5KcsosaKlevXsWhQ4fwP//zP7hx44bua8LhMC5evGhQCzNLPVY5/YZpbGxMO2qZAWN+DJdpSg+R0dFRDAwM4MKFC+jo6EBHRwcuXLiA/v5+jIyMaHMj06GWIfd6vSguLsasWbNQVlaGBQsWsIpyFhJCQFEU9PX14Wc/+xnee++9CaEiSRLq6+vx/PPPo7q6Gj/72c8Mam1mFRQUIJVKaasHhRAIBoMoKSlhuFgAw+UOqHeP0WgUQ0NDuHjxIs6cOYNTp07hzJkz6Onp0ULkbkcgNpsNeXl58Hg8KC0tRUVFBaqqqrBw4UIsWLAA8+fPx5w5c1BaWgqPxwOn06kV1kskEhn+G5NR1DmV7u5utLW14dixY5OOTGfNmoWtW7di3bp1cLvdSCaTBrR2ZqgT+2rNL+DmTVw4HEZBQQEDxuQYLreg3jGOjY1hYGAAnZ2d2lksHR0d6Ovrw+jo6B2/mdXhvtfrRUlJCebOnauFR1VVlS48vF6vrtQI30zZT52L6+jowMGDB3Hy5MlJ59J8Ph/WrVuH1tZWzJo1K2v7hhowfr9fu2EbGxvT3hfZ+vfOBgyX/6eGydDQEM6cOYMPPvgAx44dw7lz5zA4OKg78W4q7HY7CgoKUF5ejqqqKtTU1KC2thY1NTWoqqpCeXk5ioqKkJ+fr5Xh5xsld6mhcvbsWbz55ps4ffr0hJGoJEkoLS3FmjVrsH79epSXl0OSpKzuN+rNmMvl0h6PqTd9LB5pbjkbLupdUDQaRU9PD9555x20tbXhl7/8Ja5evTrlEYksy3C5XCgvL0d1dTWWLl2KZcuWoa6uDlVVVSgtLYXb7ebogyalPv46f/48Xn/9dbS3t08aKnPmzMGGDRuwevXqnJxzKCgoQDQa1W7wIpEI8vPzOblvYlkfLmo5ifPnz+Ps2bMIhUIQQiAQCOD8+fM4ceIEOjs7EQwGf+XvZbfb4fV6UVlZifr6et0hYHPmzIHH42GI0JQpioJLly5h//79OHr06ITHX7IsY8GCBdi0aRMeeugheL3enOxXkiTBZrOhoKBAe58KIRAKhVBcXDzp9+R2R2TQvZHV4SKEQFdXF/7oj/4IbW1tGBsbm/JEu81mg8/nw6JFi7B8+XI0NzejsbER1dXVKCsrg8vlyvpHEjQz1Jubt956Cz/96U8n3NjIsozq6mps3rwZ999/P9xud873M0mS4Ha7tQ2VABCPxydM7quLbmKxmLa0X11hqW7MzfXv5b2SteGiBsv27dvR3t4+pV/j9XqxdOlSrF27Fg8//DCWLVuG8vJyrWIAOyVNhxAC8Xgcv/jFL7Bv3z709/frbnYkScLChQuxdetWtLS0aDcwdJMkSfB4PPD7/dproVBIq+qhKAoikQgikciEx9rqIgCv1wtZlvl9vQeyNlwikQj+4A/+YEKwqPWJZFlGfn4+Zs+ejRUrVmD9+vVYs2YNFi1apBV7YwekTFGXFe/duxcffvjhhP1OFRUV2Lp1Kz75yU9yme0tSJIEp9MJt9ut2/sSCARgt9uRSqVuuehGCIFIJIJEIgGfzwe73c7v8QzLynARQuDAgQM4ePCg9lpFRQW+/vWvo66uDgDgcrkwe/ZsVFRUwOPx8G6GZoRaRPDNN9/E22+/PWGvisfjwcaNG7F58+acnKi/Gx6PR7f3RZ1XnYwkSbrRYTKZhN/vR1FRERcDzLCsDJdoNIp/+qd/0jqc0+nE3//93+M3fuM32JnonlA327777rvYv38/BgcHdT9vt9uxcuVKPP3001i4cCEr/k6RJEmQZRk+nw+BQGDSUEkf4dhsNsRiMYRCIW1Uk0qlEAgEUFRUBKfTyc+EGZJ14SKEwPHjx3H06FHttTVr1uDJJ59kJ6IZp+6XOnfuHPbu3YuzZ8/qHtVIkoT58+dj+/btaGlpgcPhYL+8Q+rqseLiYoTDYcRiMSiKAlmWtT0x6XvHbDYb7HY7bty4oT2OVBQFgUAAhYWFcLlc2tdS5mRduADA/v37EYlEANxc9fW5z32Oh0/RjBNC4Nq1a9i/fz8OHz6MaDSq+/nCwkI8+uijaG1tRWFhIT/MpkENDY/HA4/HAyGE9v0c/31VN2IWFxcjEAhok/1q5eVEIoGCggJuI8iwrAuXUCiEQ4cOaddVVVVYu3YtOwzNGHUV2DvvvIPXXnsN169f1/28w+HAgw8+iG3btmHevHl8BJZBtwqUyb7ObrdrAZP+OC0cDiMSicDpdGpLltNLy/Cz4+5kXbh89NFHuHDhgna9Zs0azJo1y8AWUTYTQuDy5cv40Y9+hBMnTuhWgUmShJqaGjz11FNobm7mCiWDpT9OSz8rBvh4jkwdbaoH1jmdTuTl5XFUcxeyKlyEEHj//fe1ZYqyLGPjxo3sEJRx6gqlI0eO4D/+4z8mHCtbUlKCxx57DBs2bODSYhNJXxAQDodvWTMwlUohlUohGo1ClmVtgQA3Yk5dVoWLoih4//33teuioiK0tLSwI1BGqXsrfvSjH+HIkSO6DXvqI7Cnn34ac+fOZd8zIbWyRkFBAfLz8xGJRBCNRpFKpSat4JG+OdPpdMLj8TBkpiCrwiUUCuHkyZPadU1NDSorKw1sEWUbIQQ6OzvxyiuvoLu7W/dzFRUVePbZZ/Hggw/yEZgFqPMwHo9HO5gskUggHo8jkUhMGjZqWRmXy8X9cb9CVoXL5cuX0dfXp13fd9992jJDoulKpVJ49913sWfPHgQCAe11m82GT3ziE3juuee0MvhkHepIRpZl2O127TMjmUxq8zDpo1MhhLYEWj1zSf196GNZEy5CCJw9e1bbAS1JEu6//36DW0XZQF0Ntn//fuzfvx/xeFz7Oa/Xi6effhobNmzgju8skP7v53A4tHOZotEoxsbGdCGjbsZ0uVysWTaJrAkXAPjwww+1YazT6cTy5cv5j03TopZ23717N9555x3d5G9VVRVefPFF1NfXc3lxllJHNS6XC/n5+ZMuAlBrlhUVFXFTbJqsCZdUKqUrUjlr1iwsWLDAwBaR1al1wb73ve/h+PHj2o2LJEm477778IUvfCGrjximj6UvAnA6nQgGg7qlzGrNssLCQuTn57NPIIvCJRQKobOzU7uurq5GcXGxgS0iKxNC4OrVq/jHf/xHnDt3TnvdbrejtbUVzzzzDM9ZyUHqIgCfz4dIJIJgMKjddCiKghs3bkBRFPYNZFG4DA4O4urVq9r10qVLteWCRHdCCIErV65g165d6Orq0l53Op145plnsHnzZq4Gy2HqKEbd93Ljxg1dSZnR0VEoigKPx5PTfSRrwqWrq0tXzryxsdHA1pBVCSHQ39+Pl19+GT09PdrrBQUF+K3f+i08/PDD2m5tym2SJMHhcGg7/tMXeoRCIQDI6YDJillIdaWYWnrDbrejvr4+Z/9R6e4IITAwMICdO3fqgqWwsBBf+cpXsGbNGgYL6aSXlBlfHDcUCt3R0erZJitGLkII3XPxwsJCLFy40LgGkeUIITA0NIRvf/vbuHjxova6z+fDV77yFaxYsYIrwmhS6k1sUVERJEnSKrIDNwNGluWcPLI6K94tiUQCH330kXY9e/ZslJWVGdgishK19Pp3vvMd3aIQn8+H3/md38HKlSsZLHRb6jyMulpMpc7BxOPxnBvBZMU7ZnR0FJcvX9auFy1axJ35NCVCCIyNjeF73/seTp06pb3u9XrxpS99CStWrMi5O066O2rAqCdcqtSbl2QymVMBkxXhMjAwoKtKW1dXx2fjNCXRaBT/+q//imPHjmmvuVwuvPjii1i1ahWDhe5IesCkr1ZNpVIYHR2FECJnAiYrwuXixYu655wNDQ0GtoasIhaL4dVXX8Xhw4d1lR0+85nP4KGHHuKjMLorap2yoqIi3U1uPB5HMBg0sGX3luXfPUIIfPTRR1o5BofDgcWLF/OOk24rHo9j7969aGtr0/qO3W7H008/jfXr13PkS9OibrYcf5y1euplLoxeLB8uAHST+R6PB/PnzzewNWRmQgjEYjHs3bsXb7zxhrZ83Waz4YknnsCWLVsYLJQRkiRp57+kCwaDOTH/YvlwSSQSumONy8rKeKwxTUotlb5nzx68/vrrWrDIsozW1lZs27aNVR0oo9Sd/OkryBRF0eZfspnl97mMjY3pVopVVVXB7XYb2CIyI/X0yFdeeQVHjx7V3tjqUdjPPfcc8vLyDG4lZSNJkuD1erUDyICbj2XHxsayege/5cPl+vXrGB4e1q5ra2tht1v+r0UZdKsilDabDY888gief/55VrKlGaPu4i8sLEQgENBubMbGxpCXl5e15wBZ/rHYpUuXdDXFlixZYmBryGyEELh27RpefvllXbDk5eXhqaeewgsvvMBgoRmnzr+kP1URQuiqKmcbS9/iCyFw4cIFrSKpzWZDbW0tPygIwMcHfX33u9/VzcsVFBTghRdewNq1aznKpXtGkiR4PB7E43EkEgkAN+eMs/XxmOVHLukrxVwuFw8II00qlcKPf/xj3c57tQjl+vXrGSx0z6nzL+lBMjY2hkQikXUjGEuHSyqV0oVLSUkJZs+ebWCLyCyEEDh16hQOHTqkvWldLhd++7d/Gy0tLdwgSYaQJAl5eXk58XjM0u+wSCSC3t5e7bqyshJer9fAFpFZRCIR7N27VzuKVpZlPPnkk3jggQcYLGQo9bjk9JFzPB5HNBrNqoCx9LtsZGREd/pkTU0N9ykQhBA4duyYbp6loaEBjz76KDdIkinIsjzhRjgUCkFRlKwJGEuHS39/P0ZHR7XrJUuWZN2kGN25aDSKtrY2bU9BXl4ePv3pT3P/E5mGunosfXNlKpVCOBw2sFWZZelw6erq0lZdSJLEcCEIIdDR0YGuri7tteXLl2PZsmXsG2Q641eJhcNhpFKprBi9WDZc1IKV6dVsq6urDW4VGU1RFBw5ckS3PP2RRx7hyjAyHbW4ZfqIWlEU3b49K7N8uKh8Ph/mzJljYIvIDPx+P9rb27Xr+fPnY+nSpRy1kCmptcfS5wIjkUhWFLa0bLjEYjHdo485c+aguLjYwBaR0YQQOH36NAKBgPbagw8+yLkWMjWbzTZhaXI2zL1YNlwCgQCuXLmiXVdXV+uOFqXcoygKfvnLX2p3fPn5+bj//vs5aiFTkyQJLpcr60Yvlg2X/v5+3R1qfX099y/kuEAggPPnz2vXCxYsQGVlpYEtIpoaWZYnjF7ST9e1Ikt+Ggsh0NXVpW2QkyQJdXV1BreKjKTWmUu/4VixYgXL6JMl3Gr0oi6ntyJLhgsAnDt3Thsy5uXlsWBljhNC4MMPP9Qdd93U1MQ+QZYhyzJcLpd2rSiKpY9EtmS4CCFw9uxZ7bq4uBjz5s0zsEVktGg0io6ODu169uzZPO6aLEUdvaQ/3o9EItoNk9VYMlwikYiutEdlZSVXiuW4K1eu6EoB1dXV6e4CiazAZrNN2LVv1ZpjlgyX4eFh9Pf3a9dLlizR/YNQblFHsulzcHwkRlblcrl0fdeqj8YsGS49PT26iVuW9shtiqLg9OnT2rXH48HixYvZJ8hyJEmCw+HQbatIJBKIx+OWCxjLhYu6UU6tKSbLMhobG/lBksMCgQAuXryoXVdVVaG0tNTAFhFNz/iNv1bcVGm5cAGAkydPav/v8XiwZMkSA1tDRhJC4OLFi7qRbGNjI2uJkWWpB4qlL6OPxWKWO63ScuESi8V0x9bOmTOHNcVy3KlTp7QVNXa7nSNZygpWH71YLlyuX7+uewTS0NAAj8djYIvISLFYTLcsfdasWVyCTJannveSPgKPRqNatW8rsFy4nD9/HiMjI9r1qlWrWPYlhw0ODmJgYEC7XrJkCQoKCgxsEVFmqPteVGpJGKs8GrPUp7IQAr/4xS+0yXy73Y6WlhY+AslRQgicO3dOq8HEJciUTaxeEsZS4ZJKpfDBBx9o16WlpVi6dKmBLSIjKYqiW9zhdrt5GillFVmWdXv4rFQSxlLhcv36dd2HSUNDA2bPnm1gi8hIgUBAV6mhqqoKZWVlBraIKPPcbrfu0b96FLLZWSZchBA4ceKErsTH6tWr4XA4DGwVGUU9ifTGjRvaa83NzewPlFUkSZpQEsYqoxfLhAsAtLW1aasl8vLysG7dOoNbREZRDwZTlyDn5eWhubnZ4FYRzYyCgoJJRy9mDhjLhIvf78ehQ4e06wULFnDyNofduHFDV/KlsrIS8+fPZ3+grKOOXsaX4w+FQga26lezRLgIIfDee++hq6tLe23Dhg3w+XzGNYoMI4TAqVOnMDw8rL22atUqFi+lrCVJEtxut27lWDQaNXXNMUuESzKZxO7du7UlyE6nE5/+9Kd5l5qjkskkDh8+rL2pnE4nHnjgAfYHymo2m023h0sIgWAwCEVRTBkwpg8XIQR+/vOf46c//an2WnNzMx588EF+mGQxIcSkbxh1Iv/cuXPaa7W1taiqqrqXzSO659R9L+mLVhKJhGkfj5k6XIQQGBkZwZ/+6Z9q30BZlvH5z3+eJV+yXDwex89//nP09PRoK2PUHcr79u3Tzm6RZRnr16/nKjHKCZIkwev16m6sw+EwwuGw6UYvpiwde+nSJZw+fRqjo6P44Q9/iMOHD2s/t2rVKmzfvp2jlix39epVfOc734GiKKioqEBjYyNqampw4sQJtLe3a1+3aNEi3HfffewPlBPUiskejwfBYFB7PRgMQggBt9ttmveCKcPlzTffxFe/+tUJj0a8Xi/+4i/+ghP5OaCzs1M73rW3txe9vb0TvsbpdGL79u2sJUY5RZ3cTyQSiEajAD6ef4nFYvB6vQa38CZTPhZzuVwTJqlcLhf+7M/+DI888ohpkplmhjqvcjs2mw2PP/44Vq1axf5AOUeSJBQVFelOrARuPk5W934ZzZQjl/QzpO12O5YsWYI//uM/xvbt23VL8Sg7SZKEJ598EnV1dWhvb9cqYadSKUiShNLSUjz++OPYuHEjDwWjnKR+Pvp8PgSDQe2sF5fLpTtkzEimfGc+9NBD+MEPfgCXy4W5c+eisbERPp+Pd6g5ZM6cOaioqMDatWsRCoVw5coV+P1+uN1uVFVVsT9QzlP7f2FhIZxOJ8LhMAoKCkzzvjBVuCiKgg8++ABjY2MoKSkBcHNn/pEjRwxumTUkk0ndWTdWpD4SU1eDpbPb7YjH47pilaSXSqVMuzR1qoQQpt4caFYulwupVArJZNIU3zvThIssy1i2bBneeustvPXWW0Y3x7IKCwtRXFxsdDPuiiRJmD9/Po4fP47jx48b3RzLcrvdll6q73A4EIvFJr3BoKmRJMnwEYwkzBBxuHm3YpbEtTq73W7J0zmFEKYvxmcVNpvNsn2AMsfIgDFNuBARUfaw3q0NERGZHsOFiIgyjuFCREQZx3AhIqKMY7hMkVrnjOsfclcqlcLY2BhSqZTRTSGDCCGQSCT4OTAFDJcpOnHiBGw2G06cOGF0U8ggvb29eOGFFyYtokm5IZlM4vr160gmk0Y3xfQYLkRElHEMFyIiyjiGCxERZRzDhYiIMo7hQkREGcdwISKijGO4EBFRxjFciIgo4xguRESUcQwXIiLKOIYLERFlHMOFiIgyjuFCREQZx3AhIqKMY7hMgRACfr8fAOD3+3mWQw4SQmBkZAThcBgjIyPsAzlICIGhoSFcvnwZQ0ND7AO/AsPlNgKBAHbt2oXa2lps3LgRQghs3LgRtbW12LVrFwKBgNFNpBmW3gdaWlrwX//1X2hpaWEfyCHpfWDu3Ll46KGHMHfuXPaBX0ESjN9JtbW1Ydu2bQiHwwCgu0uRJAkA4Ha7sW/fPrS2thrSRppZ7APEPnD3GC6TaGtrw5YtWyCEgKIot/w6WZYhSRIOHDjAjpVl2AeIfWB6GC7jBAIBzJs3D5FI5LYdSiXLMlwuF/r6+uDz+Wa+gTTj2AeIfWD6OOcyzu7duxEOh6fUoQBAURSEw2Hs2bNnhltG9wr7ALEPTB9HLmmEEKitrUV3d/cdrQSRJAnV1dXo7OzUnsOSNbEPEPtAZjBc0gwNDaGsrGxav760tDSDLaJ7jX2A2Acyg4/F0oRCoWn9+mAwmKGWkFHYB4h9IDMYLmk8Hs+0fr3X681QS8go7APEPpAZDJc0paWlqKmpuePnpZIkoaamBiUlJTPUMrpX2AeIfSAzGC5pJEnCjh077urXvvTSS5zEywLsA8Q+kBmc0B+H69uJfYDYB6aPI5dxfD4f9u3bB0mSIMu3//aoO3Nfe+01dqgswj5A7APTx3CZRGtrKw4cOACXywVJkiYMc9XXXC4XDh48iE2bNhnUUpop7APEPjA9DJdbaG1tRV9fH3bu3Inq6mrdz1VXV2Pnzp3o7+9nh8pi7APEPnD3OOcyBepZHsFgEF6vFyUlJZy0yzHsA8Q+cGcYLkRElHF8LEZERBnHcCEiooxjuBARUcYxXIiIKOMYLkRElHEMFyIiyjiGCxERZRzDhYiIMo7hQkREGcdwISKijGO4EBFRxjFciIgo4xguRESUcQwXIiLKuP8DdWmGX36LVTwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "datasetoct7 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [0, 5], [0, 5]])\n", + "model.train(datasetoct7, opt=\"LBFGS\", steps=int(80/8));\n", + "f_pred = model(datasetoct7['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct7['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2: {r2}\")\n", + "\n", + "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of total dataset: {r2}\")\n", + "\n", + "model = model.prune(threshold=0.1)\n", + "model(datasetoct7['train_input'].to(\"cpu\"))\n", + "model.plot()" + ] } ], "metadata": { From e88cd96e91412c120391537a2ea2e09b6f42f9a6 Mon Sep 17 00:00:00 2001 From: arjay55 Date: Tue, 25 Jun 2024 08:39:48 +0800 Subject: [PATCH 3/7] for laptop --- tutorials/continual_learning_structural.ipynb | 211 +++++++----------- 1 file changed, 76 insertions(+), 135 deletions(-) diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb index 6dab54cb3..8e994cc2a 100644 --- a/tutorials/continual_learning_structural.ipynb +++ b/tutorials/continual_learning_structural.ipynb @@ -27,8 +27,16 @@ "# f = lambda x: (x[:,[0]]**2 + x[:,[2]] + 3*torch.sin(x[:,[1]]))/(x[:,[0]] + 2*x[:,[1]] - x[:,[2]])\n", "# sin(x) * cos(y) + exp(z/2) - x^2 * y\n", "f = lambda x: torch.sin(x[:, [0]]) * torch.cos(x[:, [1]]) + torch.exp(x[:, [2]]/2) - x[:, [0]]**2 * x[:, [1]]\n", - "datasetall = create_dataset(f, n_var=3, train_num=20000, test_num=4000, seed=0, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", - "datasetoct0 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" + "\n", + "trainpoints = int((5/0.05)**3)\n", + "testpoints = trainpoints//5\n", + "\n", + "trainpoints_subtask = trainpoints // 5\n", + "testpoints_subtask = testpoints // 5\n", + "pruning_threshold = 0.05\n", + "\n", + "datasetall = create_dataset(f, n_var=3, train_num=trainpoints, test_num=testpoints, seed=0, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", + "datasetoct0 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" ] }, { @@ -54,7 +62,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 6.44e-02 | test loss: 8.14e-02 | reg: 2.31e+01 : 100%|██| 80/80 [00:34<00:00, 2.30it/s]\n" + "train loss: 9.83e-02 | test loss: 9.91e-02 | reg: 3.92e+01 : 100%|██| 80/80 [28:25<00:00, 21.32s/it]\n" ] } ], @@ -63,7 +71,11 @@ "# 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=[3,5,1], grid=10, k=3, sp_trainable=False, sb_trainable=False, noise_scale=0.1, device=\"cpu\")\n", + "model = KAN(width=[3,5,1], grid=5, k=3, sp_trainable=False, sb_trainable=False, noise_scale=0.1, device=\"cpu\")\n", + "# make a 3D tensor with 5 points in each dimension\n", + "x = torch.linspace(-5, 5, steps=11).repeat(3, 1).T\n", + "\n", + "model.update_grid_from_samples(x)\n", "# model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.1, device=\"cpu\")\n", "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=0.02);\n", "model.train(datasetoct0, opt=\"LBFGS\", steps=80);" @@ -96,8 +108,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999931568754619\n", - "R^2 of total dataset: -0.032715797424316406\n" + "R^2: 0.9999906831053522\n", + "R^2 of total dataset: -0.011580586433410645\n" ] } ], @@ -119,9 +131,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -150,15 +162,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 7.82e-02 | test loss: 8.80e-02 | reg: 1.67e+01 : 100%|██| 80/80 [00:30<00:00, 2.60it/s]" + "train loss: 6.46e-01 | test loss: 6.46e-01 | reg: 7.02e+00 : 100%|██| 80/80 [04:35<00:00, 3.44s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999919903002592\n", - "R^2 of total dataset: 0.1378278136253357\n" + "R^2: 0.9996043009450659\n", + "R^2 of total dataset: 0.3281276822090149\n" ] }, { @@ -196,7 +208,7 @@ "metadata": {}, "outputs": [], "source": [ - "datasetoct1 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" + "datasetoct1 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" ] }, { @@ -224,15 +236,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 8.38e-02 | test loss: 9.65e-02 | reg: 1.83e+01 : 100%|██| 40/40 [00:15<00:00, 2.63it/s]" + "train loss: 3.23e+00 | test loss: 3.22e+00 | reg: 9.33e+00 : 100%|██| 40/40 [02:14<00:00, 3.37s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999920646541796\n", - "R^2 of total dataset: 0.08780598640441895\n" + "R^2: 0.9917527427896857\n", + "R^2 of total dataset: -7.52069091796875\n" ] }, { @@ -270,9 +282,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -280,7 +292,7 @@ } ], "source": [ - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct1['train_input'].to(\"cpu\"))\n", "model.plot()" ] @@ -294,15 +306,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 4.26e-01 | test loss: 4.04e-01 | reg: 1.92e+01 : 100%|██| 26/26 [00:09<00:00, 2.70it/s]" + "train loss: 1.57e+00 | test loss: 1.57e+00 | reg: 4.82e+00 : 100%|██| 26/26 [01:28<00:00, 3.40s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9998500347865047\n", - "R^2 of total dataset: -2.429469585418701\n" + "R^2: 0.997611640021205\n", + "R^2 of total dataset: -2.849461078643799\n" ] }, { @@ -314,7 +326,7 @@ } ], "source": [ - "datasetoct2 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [0, 5], [-5, 0]])\n", + "datasetoct2 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [0, 5], [-5, 0]])\n", "model.train(datasetoct2, opt=\"LBFGS\", steps=int(80/3));\n", "f_pred = model(datasetoct2['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct2['test_label'].to('cpu').detach().numpy()\n", @@ -334,9 +346,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -344,7 +356,7 @@ } ], "source": [ - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct2['train_input'].to(\"cpu\"))\n", "model.plot()" ] @@ -358,15 +370,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 4.44e-01 | test loss: 4.49e-01 | reg: 2.04e+01 : 100%|██| 20/20 [00:07<00:00, 2.60it/s]" + "train loss: 2.53e+00 | test loss: 2.52e+00 | reg: 5.12e+00 : 100%|██| 20/20 [01:08<00:00, 3.41s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9997848986677127\n", - "R^2 of total dataset: -3.043355941772461\n" + "R^2: 0.9928696481510997\n", + "R^2 of total dataset: -4.074105739593506\n" ] }, { @@ -378,7 +390,7 @@ } ], "source": [ - "datasetoct3 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[-5, 0], [0, 5], [0, 5]])\n", + "datasetoct3 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [0, 5], [0, 5]])\n", "model.train(datasetoct3, opt=\"LBFGS\", steps=int(80/4));\n", "f_pred = model(datasetoct3['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct3['test_label'].to('cpu').detach().numpy()\n", @@ -398,9 +410,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -408,7 +420,7 @@ } ], "source": [ - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct3['train_input'].to(\"cpu\"))\n", "model.plot()" ] @@ -422,15 +434,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 3.93e-01 | test loss: 4.16e-01 | reg: 1.68e+01 : 100%|██| 16/16 [00:06<00:00, 2.41it/s]" + "train loss: 1.39e+01 | test loss: 1.39e+01 | reg: 4.39e+02 : 100%|██| 16/16 [00:55<00:00, 3.44s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9998272083030315\n", - "R^2 of total dataset: -0.3068668842315674\n" + "R^2: 0.8182587772607803\n", + "R^2 of total dataset: -1.3164293766021729\n" ] }, { @@ -442,7 +454,7 @@ } ], "source": [ - "datasetoct4 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [-5, 0], [-5, 0]])\n", + "datasetoct4 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [-5, 0], [-5, 0]])\n", "model.train(datasetoct4, opt=\"LBFGS\", steps=int(80/5));\n", "f_pred = model(datasetoct4['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct4['test_label'].to('cpu').detach().numpy()\n", @@ -461,55 +473,36 @@ "metadata": {}, "outputs": [ { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtHElEQVR4nO2dd3gUVfv3v7Ob3ntIJwkJJIR0OkhTUFSkiSBiQxCkigWVKk1EqVIEEaWJIE14RIoFlU5C6CQkhPSeTe+7e79/8Nt9QwhkN5nd2d2cz3Vx+TywM+fenTPznXOfu3BERGAwGAwGg0dEQhvAYDAYDMODiQuDwWAweIeJC4PBYDB4h4kLg8FgMHiHiQuDwWAweIeJC4PBYDB4h4kLg8FgMHiHiQuDwWAweIeJC4PBYDB4h4kLg8FgMHiHiQuDwWAweIeJC4PBYDB4h4kLg8FgMHiHiQuDwWAweIeJC4PBYDB4x0hoAxgMfYCIUFhYiPLyclhZWcHR0REcxwltFoOhs7CVC4PxBIqLi7F27VoEBATA2dkZvr6+cHZ2RkBAANauXYvi4mKhTWQwdBKOdaJkMBrnxIkTGDFiBCorKwE8WL0oUKxaLCwscODAAQwaNEgQGxkMXYWJC4PRCCdOnMDzzz8PIoJcLn/s50QiETiOw2+//cYEhsGoBxMXBqMBxcXF8PT0RFVV1ROFRYFIJIK5uTkyMjJgZ2eneQMZDD2A7bkwGA3Yvn07KisrVRIWAJDL5aisrMSOHTs0bBmDoT+wlQuDUQ8iQkBAAJKTk6HOrcFxHPz8/JCYmMiiyBgMMHFhMB6ioKAAzs7OLTre0dGRR4sYDP2EucUYjHqUl5e36PiysjKeLGEw9BsmLgxGPSwtLVt0vLW1NU+WMBj6DRMXBgOARCLBmjVr0KdPn2afw8rKCrdv31Zrr4bBMFSYuDBaLUSEM2fOYNy4cXB3d8fHH3+M0NBQvPfee806n4WFBfr164ewsDCsW7cORUVFPFvMYOgPbEOf0eooKirCjh07sGXLFty+fRv+/v6YOHEi3nzzTbi4uKC4uBgeHh7KzPymUOS5pKWl4erVq9iyZQsOHz4MIyMjjBw5EhMnTkT37t1ZFBmjVcHEhdEqICKcP38emzdvxr59+yCVSjFs2DBMnDgR/fv3h0j0/xfxMpkM3bt3x+XLl8FxXJNuLpFIhN9//x0DBw5U/l1ubi62b9+OrVu3Ijk5GR07dsSECRPw2muvsURLRuuAGAwDpqioiNatW0chISEEgPz8/OiLL76gnJycxx4za9YsEovFtGzZMrK0tCSO44jjOAKg/KP4/2KxmFxcXOj+/fuNnksmk9GpU6fo5ZdfJlNTU7KysqK33nqLzp8/T3K5XEPfmsEQHiYuDINDLpfTuXPn6M033yRzc3MyMjKiESNG0MmTJ0kmkz3x2K1btxIA+uabb4jogTitXbuW/P39HxIXf39/Wrt2LaWkpFBISAhFR0dTaWnpE8+dnZ1NX3zxBbVr147EYjGFhYXR+vXrqaioiK+vzmDoDExcGAZDcXExrV+/njp16kQAqG3btrR06VLKzs5W6fh///2XjI2N6d13331kVSGXy6mgoIDu379PBQUFD/17fHw8tWnThkaOHElSqbTJcWQyGZ04cYJGjBhBJiYmZGVlRePHj6eLFy+y1QzDYGDiwtBr5HI5Xbhwgd5++22ysLAgsVhMw4YNo+PHjze5SqlPcnIyOTk5Ud++fam2tlZtO06ePEnW1tY0Z84ctY7LysqipUuXkp+fH4nFYoqIiKCNGzdScXGx2jYwGLoEExeGXlJSUkIbN26ksLAwAkA+Pj60ZMkSyszMVPtcpaWlFBISQv7+/lRQUNBsm9avX0+Wlpa0a9cutY+VSqV0/PhxGj58OJmYmJC1tTVNmDCBLl++zFYzDL2EiQtDb5DL5XTp0iUaP368cpXy0ksv0bFjx1RyRzWGVCqlF198kWxsbOj27dsttm/KlClkb29PFy5caPZ5MjIyaPHixdS2bVsSi8UUGRlJ3377bZN7OgyGLsHEhaHzlJaW0rfffksREREEgLy8vGjRokWUkZHR4nPPnj2bRCIRHTt2jAdLiWpqamjgwIHUtm1bSk1NbdG5pFIpHTt2jIYOHUrGxsZkY2ND7777LsXGxvJiK4OhSZi4MHSWmJgYmjBhAllaWpJIJKIXX3yR/ve//zV7ldKQ7du3EwBatWoVL+dTUFBQQB07dqSuXbtSeXk5L+dMT0+nzz//nHx8fEgsFlN0dDRt2bKFrWYYOgsTF4ZOUVpaSps3b6aoqCgCQJ6enrRw4UJKT0/ndZyzZ8+SiYkJjR8/XiN7Grdv3yYXFxcaPXq0WoEFTSGVSul///sfDRkyhIyNjcnW1pYmTZpEV65c4W0MBoMPmLgwdIIrV67Qu+++S1ZWViQSiej555+nI0eOUF1dHe9jpaamkouLC/Xu3Ztqamp4P7+CY8eOkZWVFS1cuFAj509NTaWFCxeSt7c3icVi6tKlC23dupXKyso0Mh6DoQ5MXBiCUVZWRt999x117tyZAJC7uzvNnz+/xXsVTY0ZFhZGbdu2pby8PI2No2DNmjVkaWlJP//8s8bGqKuroyNHjtALL7xARkZGZGdnR++99x5dvXpVY2MyGE3BxIWhda5evUqTJ08ma2tr4jiOBg8eTIcPH9bIKqU+MpmMhg0bRlZWVnTjxg2NjqVALpfTxIkTycHBgS5duqTx8VJSUmjBggXk5eVFYrGYunXrRtu2beNt74fBUBUmLgytUF5eTt9//z116dKFAJCbmxvNnTuXUlJStGbDnDlziOM4OnLkiNbGJCKqrq6m/v37k5+fH+97R4+jrq6ODh8+TIMHDyYjIyOyt7enqVOn0vXr17UyPoPBxIWhUa5fv05TpkwhGxsb4jiOnn32WTp48GCzsuBbwu7duwkAffnll1odV0FeXh516NCBevToofVVxP3792nevHnk4eFBYrGYevToQT/++CNVVFRo1Q5G64KJC4N3Kioq6IcffqBu3boRAGrTpg199tlnlJycLIg9Fy9eJFNTU3r99dcFzXa/ceMGubi40NixY3mNIFOV2tpaOnjwID333HNkZGREDg4ONH36dLp586bWbWEYPkxcGLxx48YNmjZtGtna2hIAGjhwIB04cEDrq5T6pKenU5s2bah79+5UXV0tmB0Kjh49SlZWVrRkyRJB7UhOTqY5c+aQu7s7icVi6tWrF23fvp0qKysFtYthODBxYbSIyspK2r59O/Xo0YMAkIuLC33yySd07949oU2jiooKioyMJG9v7yf2b9E2X331FVlaWtL+/fuFNoVqampo//79NGjQIBKLxeTo6EgzZ86kW7duCW0aQ89h4sJoFrdu3aLp06eTnZ0dAaCnn36afvnlF43mjaiDTCajl19+mSwsLHQuJFcul9Pbb79Njo6OOlXKJSkpiT799FNyc3MjsVhMTz31FO3cuZOtZhjNgokLQ2UqKytp586d1KtXLwJAzs7ONHv2bEpMTBTatEdYuHAhAaCDBw8KbUqjVFVVUd++faldu3aUlZUltDkPUVNTQ7/88gs988wzJBaLycnJiWbNmtXiwp6M1gUTF0aT3Llzh2bOnEn29vYEgPr370979+7VmVVKQ/bt20cAaOnSpUKb8kRycnIoMDCQnnrqKZ1dHdy9e5dmz55Nrq6uJBaLqU+fPrR7926qqqoS2jSGjsPEhdEoVVVVtHv3bnrqqacIADk5OdFHH31Ed+/eFdq0JxITE0Pm5ub06quv6kUflLi4OHJycqI33nhDp+2trq6mvXv30oABA0gsFpOLiwt9+OGHdOfOHaFNY+goTFwYDxEfH0+zZs0iR0dHAkD9+vWjPXv26ESkVVNkZWWRh4cHdenSRWdXAo1x6NAhsrS0pOXLlwttikokJCTQxx9/TC4uLiQWi/VqjjC0BxMXBlVXV9NPP/1Effv2JQDk6OhIH3zwASUkJAhtmspUVlZS586dycPDQ+f2MFRh2bJlZGlpSYcPHxbaFJWprq6mPXv2UL9+/ZSrmY8++kiv5g1DczBxacXcvXuXPvzwQ3JyciIAeutPl8vlNGbMGDI3N9ep6Ct1kMvl9Prrr5Ozs7PORbepwp07d+iDDz4gZ2dnEovFNGDAAJ3el2NoHiYurYyamhr6+eefqX///gSAHBwc6P3339dr3/mSJUsIAO3bt09oU1pEZWUl9e7dmwIDA3UqL0cdFHt1ffr0IbFYTG3atNHZiEKGZmHi0kpITEykjz/+mJydnQkA9e7dm3bu3Kl3q5SGHDx4kABorGeKtsnMzCR/f3/q16+f3l+bW7du0axZs8jJyYnEYjE988wztG/fPraaaSUwcTFgampqaN++fTRgwAACQHZ2djRjxgyDyb6Oi4sjCwsLGjVqlE5HWqlLTEwMOTo6aqxLprZR5Ef17t2bxGIxubm50aeffkpJSUlCm8bQIExcDJB79+7RJ598Qi4uLgSAevbsSTt27NCrCKqmyMnJIS8vL4qKijLI6r6//PILWVpa0sqVK4U2hVdu3bpFM2fOJEdHRxKLxTRo0CDav3+/oPXnGJqBiYuBUFtbS/v376dnnnmGAJCtrS1NmzZNa02xtElVVRV1796d3NzcKCMjQ2hzNMbixYvJysqK/ve//wltCu9UVFTQ9u3bqVevXiQWi8nd3Z3mzJkjWOVsBv8wcdFzkpOT6dNPPyVXV1cCQN27dzfoXh1yuZzGjRtHZmZmdPHiRaHN0SgymYxeffVVcnFxMciXBAU3btyg6dOnk4ODAxkZGQnW84fBL0xc9BBFX45BgwYRx3FkY2NDU6ZMaRVdBr/88ksCQD/99JPQpmiF8vJy6tGjBwUFBVFeXp7Q5mgURR+gHj16kFgsJk9PT5o3bx7dv39faNMYzYCJix6RkpJCc+bMITc3NwJAXbt2bVX90X/99VfiOI7mzp0rtClaJT09nXx9fWnAgAGtJgv+2rVrNHXqVLK3tycjIyMaPHgwHT58mOrq6oQ2jaEiTFx0HEUv9Oeee444jiNra2t677339DLRriVcv36drKysaNiwYYJ0cRSaixcvkoODA02aNMkgIshUpby8nLZt20bdunUjsVhMXl5etGDBAkpNTRXaNEYTMHHRUVJTU2nevHnk7u5OAKhz5860devWVrNKqU9eXh61bduWwsLCWuX3V7Bnzx6ytLSktWvXCm2KIFy9epXee+89srOzIyMjI3rhhRfoyJEjbDWjozBx0SHq6uroyJEj9Pzzz5NIJCJra2uaNGkSXblyRWjTBKOmpoZ69epFrq6u7G2ViObPn09WVlZ0/PhxoU0RjLKyMtq6dSt16dKFxGIxeXt70+eff05paWlCm8aoBxMXHSAtLY0WLFhAnp6eBICio6Npy5YtVFZWJrRpgqLo2GhiYkLnzp0T2hydQCaT0SuvvEKurq6seRcRXblyhSZPnky2trZkbGxMQ4YMof/9738klUqFNq3Vw8RFIKRSKR09epReeOEFEolEZGVlRRMnTtTbwouaYNWqVQSAduzYIbQpOkVZWRl16dKFQkJCqKCgQGhzdILS0lLasmULRUdHk1gsJh8fH/r8888pPT1daNNaLUxctExGRgZ9/vnn5OXlRQAoIiKCvv32WyotLRXaNJ3i2LFjJBKJaPbs2UKbopOkpqaSj48PDRo0iNXqakBMTAy9++67ZGNjQ8bGxjR06FA6duwYW81oGSYuWkAqldJvv/1GQ4YMIZFIRJaWlvTOO+/Q5cuXhTZNJ7l16xbZ2NjQiy++2Cojw1Tl/PnzZGdnR1OnTm1VEWSqUlJSQt9++y1FRkaSWCwmX19fWrx4MWVmZgptWquAiYsGyczMpMWLF5O3tzcBoPDwcNq0aROVlJQIbZrOUlBQQH5+ftSpUye2mlOBnTt3kqWlJW3cuFFoU3QWuVxOly9fpgkTJpC1tTWZmJjQ8OHD6fjx42w1o0GYuPCMTCaj33//nYYOHUpisZgsLCzo7bffposXL7K3yyaoqamhvn37kpOTE8vKVoPPPvuMrK2t6dSpU0KbovMUFxfTxo0bKTw8nMRiMfn5+dHSpUv1snuprsPEhSeysrJo6dKl1LZtWwJAoaGhtGHDBiouLhbaNL1ALpfTxIkTydjYmP777z+hzdErpFIpjRgxgtzc3FiLYRWRy+V08eJFGj9+PFlZWZGpqSmNHDmSTpw4wVyxPMHEpQXIZDI6ceIEDR8+nIyMjMjc3JzefPNNOn/+PFulqMm6desIAH3//fdCm6KXlJaWUlRUFHXq1IkkEonQ5ugVRUVFtH79egoNDSWxWEzt2rWjL774grKzs4U2Ta9h4tIMcnJyaNmyZeTr60sAKCQkhL755hsqKioS2jS95MSJEyQSiWjWrFlCm6LXJCcnk5eXFz3//POsonAzkMvldP78eXrrrbfI0tKSTE1N6eWXX6ZTp06x1UwzYOKiIjKZjE6dOkUjR44kIyMjMjMzozfeeIPOnj3LViktID4+nmxtbWnw4MFsc5UH/vvvP7K1taWZM2cKbYpeI5FI6JtvvqFOnTqRWCymwMBA+vLLLyknJ0do0/QGJi5NkJubS8uXLyd/f38CQMHBwbR27VrmeuCBwsJCCggIoODgYBZBxyM//PADWVpa0pYtW4Q2Re+Ry+V09uxZeuONN8jCwoLMzMzolVdeoT///JOtZpqAiUsjyGQy+vPPP2nUqFFkbGxMpqamNG7cODpz5gxbpfBEbW0tDRgwgBwcHFgvdQ3w0UcfkY2NDf39999Cm2IwFBYW0tq1aykkJITEYjG1b9+evvrqK4Pvs9NcmLjUIy8vj1asWEHt2rUjANShQwdavXo1FRYWCm2awTFlyhQyMjJiDz8NUVdXRy+99BJ5eHgw8eYZuVxO//33H40bN065mhkzZgz9/fff7OWzHq1eXORyOf311180evRoMjExIVNTUxo7diz9+++/bKJoiI0bNxIA2rx5s9CmGDTFxcUUHh5O4eHhLCReQxQUFNDq1aspODiYxGIxdejQgb7++mvKz88X2jTBabXikp+fT19//TUFBgYSAGrfvj2tXLmSFQLUMH/++SeJxWKaPn260Ka0CpKSksjDw4OGDBnC+p5oELlcTv/88w+NHTuWzM3NydzcnMaOHUv//PNPq31JbVXiIpfL6fTp0/Tqq6+SiYkJmZiY0JgxY+j06dOtdgJok8TERLK3t6eBAweyB50WOX36NNnY2NBHH30ktCmtgvz8fFq5ciUFBQWRWCym4OBgWrVqVat7cW0V4lJYWEirVq2iDh06EAAKDAxkS1ctU1RURB06dKD27duzfCAB+O6778jS0pK2bdsmtCmthvovs2ZmZmRhYUHjxo1rNRUoOCIi6DkymeyJ/04PRBQAwHEcOI5r8pxisZgX21oLql4DVX9/gF0DdWjq9weA6upqyGQyWFhYsHtAAzzpGijmv1wuB8dxKv+2+nwNjIQ2gA8OHToEU1NTmJiY8HK+q1evYvbs2bycq7Xwww8/wMPDAyKRiJfzsWugHn///bdKn1MI/JOIjY2FiYkJ3n//fT5MazUcOnQIZmZmTT6HVLkGwIN74OOPP+bLPK1jEOKSmZmJXbt24dKlSyq/FT+JtLQ0HqxqXaSkpKBDhw7o1asXL+dj10A9nn76aV7OQ0R45ZVXsHLlSl7O15rIy8vDjh07cOLECdja2rb4fPp+D/Dzmikw06dPR3BwMD766COhTWm1zJo1CzNmzBDaDEYL2b59OwYMGCC0GXrJ5MmTMW/ePPTu3VtoU3QCgxAXjuPwww8/YOPGjcjJyRHanFaJvb094uLihDaD0QKICNOnT8dPP/0ktCl6CcdxGDx4MG7fvi20KTqBQYgLAIhEIpw5cwbh4eGQy+VCm9Pq4MMdyRCWL774AuPHj4eRkUF4ywWB3Qf/H4OaRZGRkRg1ahRGjx6NvXv3sgstAKpuVjJ0CyLCF198gZKSEqFN0Xs4jmP3AQxo5aJg7dq1kEgk+Pjjj2EAUdZ6RVBQEIqKioQ2g9EMFixYgBkzZvAW7deaiY6ORkFBgdBmCI7BzSSO43D8+HFcunQJ06dPh1QqFdqkVsOuXbswadIkoc1gqAkRYfXq1Vi8eLHQphgEGzZswKxZs4Q2Q3AMTlwAwMjICH/++SeKi4sxYMAA5ObmCm1SqyA8PBwHDhwQ2gyGmixfvhyTJk1q9W4cvoiIiMDPP/8stBmCY1B7LvUxMjLCjh078N133yEiIgK//fYbIiIihDbLoFH4mhn6AxFh2bJlbK+FRxT3QWvfdzHIlYsCjuMwceJEHD58GAMHDsTRo0fZw0/D2NnZoaqqSmgzGCqyc+dODB8+nO218MysWbPw1VdfCW2GoLSKGdWlSxdcvnwZH330EebOncv2YTTIL7/8gnfffVdoMxgqQESYOnUqvv/+e6FNMTiWL1+OOXPmtOoXrVYhLgDQtm1bXLlyBWlpaRgwYAAkEonQJhkk/fv3x65du4Q2g6ECFy5cQHh4OMtr0QAikQjfffcdunXrhtzcXGXRyurqauTn56OgoMDg8/Fa1ayysLDAjh07sGnTJoSHh+PUqVNo37690GYZFBzHQSQSQS6XM1eLjjNkyBDcv39faDMMljfeeANlZWXo27cvgoKCIJVKkZeXB5lMBiKCq6sr1q9fD19fX6FN1QitSlyABw+/yZMnIygoCL1798bOnTsxcODAVr3xxjcrV67E3LlzsWzZMqFNYTyG/Px8mJubw8rKSmhTDBaO4zB16lSMGjUK8fHxEIvF8PT0hIODA+RyOU6dOoXOnTvj1q1bcHV1Fdpc3ml14gI8uOj9+vXDmTNnMHz4cPTt2xdfffUVzM3NhTbNIJg+fTrEYjETFx1mwIAB+OOPP4Q2w+DhOA6urq6NisfLL78MJycnREREICMjw+BW+ob1bdQkMDAQly9fhrm5OaKjo1FWVia0SQYBx3Hw8fFBfHy80KYwGqGurg5paWkIDAwU2pRWT79+/TB69GiMHz9eaFN4p1WuXOpjbm6OFStWIDg4GFFRUUhISBDaJIPgwoUL6NChAyQSCXM56hijR4/G1q1bhTaD8X+sXLkSXl5eOHPmDG/9kHSBVi8uwIM37TfffBPHjh3DypUreWn009pxdXVFz5498cknn2DRokXK7nxSqRQlJSXIzs5Gbm4usrKyUFZWhjZt2iAiIgI+Pj563dpVKAoLC5GWloabN2+isLAQAQEBeOqpp2BlZaUUd5lMhjNnzuDChQvYv3+/wBYzFHAchytXrsDX1xdJSUlwc3NDZWWl0Ga1GCYu/wfHcfj5559hbGyMzZs3C22OQfDrr79i5MiR6N27N4KDg5XumPLyctja2sLFxQVubm6wtbVFTEwMli5dCltbWwwZMoRtNKvJpk2bcP78eXTs2BEuLi7Ys2cPFi5ciH79+iE4OBjm5ubYvn07xGIxzp07x1aTOoaLiwsOHTqEzp07Y8mSJVi5ciWmTZsmtFktwiDEJSMjg7dz9e/fn5XCaAaPuwbr1q1DfHw8kpKSYGRkBB8fH3h4eMDKygoikeihh1xVVRWuX7+OI0eOoFOnTtoy3SB47bXX8MYbbyg3hUePHo20tDT8888/+O+//1BVVYU+ffrg1VdfhUgkQmZm5hPPx+4B9Wnpcyg4OBibNm3Czp078c477+j9HjBHBlAP5datW7yeTyqVIiwsjNdzGjrsGgjLnTt3eD2fVCplAq8m7B54GIMQl6ao/xWZO0AY2DUQHkWWeMMVI0N7tKb7oFWEIsfFxUEkErEe7wLCroHwXLt2Dba2trh27ZrQprRarl69CmNjY1y9elVoUzROqxAXBoPBYGgXJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdgxcXIkJRUREAoKioCEQksEWtD3YNhEdxDer/l6FdWt19QAZKUVERrVmzhvz9/QmA8o+/vz+tWbOGioqKhDbR4GHXQHjYNRCe1noNDFJcjh8/TpaWlsRxHHEc99AFVfydpaUlHT9+XGhTDRZ2DYSHXQPhac3XwODE5fjx4yQWi0kkEj10IRv+EYlEJBaLDfKiCg27BsLDroHwtPZrwBEZjuOvuLgYnp6eqKqqglwub/LzIpEI5ubmyMjIgJ2dneYNbAWwayA87BoID7sGBrahv337dlRWVqp0MQFALpejsrISO3bs0LBlrQd2DYSHXQPhYdcAMJiVCxEhICAAycnJakVhcBwHPz8/JCYmguM4DVpo+LBrIDzsGggPuwYPMBhxKSgogLOzc4uOd3R05NGi1ge7BsLDroHwsGvwAINxi5WXl7fo+LKyMp4sab2wayA87BoID7sGDzAS2gC+sLKyatHxFhYWkMvl4DjOIJakQtDSa2Btbc2TJa0XMzOzFh3PrkHzqK2txe3btxEXF4fz58+36FyGcg0MRlwcHR3h7++vtp8TAPz8/GBvbw+ZTAYASoHhOA4ikcEs7jSO4hrcu3dPreMUvmYHBwcNWWbYEBGSk5MRGxuLuLg42NraoqSkRK1zsGugHjKZDAkJCYiLi8PVq1dx8+ZN1NXVwcbGBmFhYXB1dUVubq5a5zS0a2Aw4sJxHKZNm4b3339f7WPHjRsHkUgEsVgMuVwOepD/A7lcDplMxsRGRcrKyjBgwAC1xQUApk+fzlaMapKbm4vY2FjExsaiqKgI9vb26N27NywtLTF//ny1XrKICFOnTmXX4DEoBDwuLg5xcXG4ceMGKisrYWFhgdDQULzzzjsIDw+Hn58fzp07h127dqktLoBh3QcGs6EPqB9bznEczMzMcOzYMdjZ2cHLy+uRjbT6YqP4qeoLjaFMhJYglUpx9epVXL16FUSEGTNmoKamptXG92uSsrIyxMXFISYmBhkZGTA3N0d4eDiioqLg6+sLjuOalWNhZmaG1NRU2Nvbs3mNB2KSkZGhFJOrV6+irKwMJiYmCAkJQUREBMLDwxEYGAixWAwAyMnJweLFi3H06FGEh4fjjz/+aNX3gcGsXADAzs4OBw4cwPPPPw+O45745qa4gQ4fPowePXogLS0NycnJyM/Ph4+PD8zNzZWfU1BfZIgIUqkUQOsWm9TUVJw7dw4VFRUICwtDREQEvL298fzzz0MkEj3xxlL8bgcPHjSYG0oT1NbW4ubNm4iJicHdu3fBcRyCg4Px9NNPIzg4GEZGD9/GzbkPDh06BEdHR+VqXSQStbpVek5ODq5evaoUFIlEArFYjA4dOuCll15CREQEgoKCYGJi8tBxUqkU33//PdasWQMzMzOsWbMGw4YNw8mTJ1W6DxTXwNDuA4NauSg4dOgQRowYASJ65OZSPPwtLCxw8OBBDBw4UPlvJSUlSEtLQ01NDVxdXeHu7q58K2mM+kJTf/LUFxpDFZvS0lKcO3cOaWlp8PT0RM+ePWFra6v89xMnTmDEiBGorKwEgEYfcKampjhy5MhD14DxALlcjqSkJMTExODGjRuoqamBr68voqKiEB4eDgsLiybPcfDgQYwdOxbV1dVq3QdyuVw5nw1ZZCQSyUNikpOTA47jEBAQgPDwcERERCAkJET5otkY586dw7x583Dv3j288cYb+OCDD2BjY6P8d1XuAwsLCxw6dMjg7gODFJeFCxfi66+/xocffohdu3Y9tAfg7++P6dOn44033njoYaiAiJCTk4OsrCyIxWJ4e3urvMFWX2ga3siGIjZSqRTXrl3D1atXYW5uju7du8PX17fRzxYXF2PHjh1Yt27dI9dgzJgxsLW1xejRo+Hp6akt83UaIkJ2djZiYmJw5coVlJaWwtnZGVFRUYiKilI790Hx9n3z5k188803at0HwP8XGUNZlZeVlSnnblxcHFJTUwEAbdu2VYpJaGioStFaubm5WLJkCX799VdERUVhyZIl6NixY6OffdJ9MHXqVLz22mtwcnLi50vqEAYnLpmZmQgKCsK0adOwdOlSEBEkEgnKyspgbW0NBwcHlW6S2tpapKWloaioCDY2NvD29n7iG0xjPE5s6guNPt2waWlpOHfuHMrLyxEaGorIyMhHXDKN8bhrsH//fsjlcrz88st69TvwTXFxMa5cuYLY2FhkZ2fD0tISERERiI6OhpeXV7N+m4KCAty4cQNhYWFwcHBo9n1Qf/7q2yqmqqoKN27cUIpJUlISiAju7u5KMVH8PqoilUrx448/YtWqVTA1NcWcOXMwfPhwlX6Xx12Duro6ZUCRIWFw4vLOO+/gt99+Q3x8/GPfyNShpKQEqampqK2tRZs2beDu7t7sG6z+japPYlNWVobz588jJSUFHh4e6NmzJy++4ezsbBw8eBBPP/002rdv33JD9Yjq6mpcv34dsbGxSEpKglgsRkhICKKjo9G+ffsWPWiICBcvXoS5uTnCwsJ4sVcfXGX1c02uXr2K+Ph4yGQyODo6KjfgIyIi4Orq2qzzX7x4EXPnzkViYiLGjRuHDz/8kJdnjGKfy8jISCfv/+ZiUOJy/fp1REdHY+3atZg8eTJv55XL5cjJyUF2djaMjIzg5eXFSyx6Y2KjS2HPMpkM165dQ1xcHMzMzNC9e3f4+fnxOsbx48eRm5uLsWPHqrQK0mcUuRExMTG4efMmZDIZ/P39ER0djdDQ0BYnQCrIyMhAYmIiOnfu3OLE1obIZDLlXqbQrrIn5ZoohCQ8PByenp4tsjM/Px9Lly7FwYMHERkZiSVLliAkJITHb/JgRcRxnEGtXgxKXAYPHoyUlBRcu3YNxsbGvJ+/pqYGaWlpKC4uho2NDXx8fHh7IABPDnvWttikp6fj7NmzKC8vR6dOnRAZGamR37S4uBh79uxB165dERkZyfv5hYaIkJ6erkxwLC8vR5s2bRAdHY3IyEjeo4OkUikuXLgAJycndOjQgddzKxDKVdZUrolCTPz8/HgRPalUip07d+Krr76CiYkJPv30U7z88ssa+b6GuHoxmFfFkydP4tSpU9i/f79GHoLAg+imgIAAFBcXIy0tDTdv3myxq6w+Dc/xpIROTb01lpeX49y5c0hJSYG7uzueffZZjYZH2tnZISQkBDExMQgKClJ7X0tXkUgkiImJQWxsLPLz82FjY4Po6GhERUXB3d1dYw+QtLQ0yGSyxwZZ8IHiDVvhKpPL5RoRmaZyTcaMGfNIrglfXL58GXPnzkV8fDzGjh2Ljz/+WKP3gSJcWSEwhoBBrFxkMhmioqJgb2+Pv/76SyvK39BV5u3tDXt7e42N1zDHhu+ETplMhuvXryMuLg4mJibo3r07/P39+TL/iVRXV2Pnzp1o3749nnrqKa2MqQkqKytx7do1xMTE4P79+zAxMUFoaCiio6PRrl07jb/hV1dX4+LFi/D29taouDSET1fZk3JNIiIiHptrwhcFBQVYtmwZ9u/fj7CwMCxduhShoaEaGashitw5sVgsuEucDwxCInfu3Ilbt27h3LlzWltSikQiuLu7w9HREWlpaUhKSoKtrS28vb15dZUpaLjZ3zDHRrHZ2pyw54yMDJw9exZlZWUICQlBVFSUxlZ/jWFmZobo6GhcuHABoaGhepVIJpVKcfv2bcTGxuL27duQy+Vo3749xo4di06dOmnsIdgY9+/fV77oaBOxWPzQ6lqdVcyTck2efvpplXJN+EAqlWLXrl346quvIBaLsXz5cowePVqrD3nFPatYCeo7er9yqaioQFBQEJ566ins2rVLMDsUrrLa2lq4ubnBzc1NqxOkOTk25eXluHDhApKTk+Hm5oZevXppdPX1JGQyGXbv3g1nZ2c899xzgtigKkSElJQUxMTE4OrVq6iqqoKnpyeio6MREREhSFXbsrIyxMTEoH379nB3d9f6+Arqv+iIxeJH5hyfuSZ8ERsbi7lz5+L27dsYM2YMZs+eLdh9YEirF71fuaxevRqFhYVYsmSJoHbY2dnBxsYG2dnZyM7ORkFBgcZdZfVpuOnfcK9GgUgkAhHhxo0bShdY//790a5dO63Y+TjEYjG6deuGU6dOISsrS9AH5OPIy8tTFoqUSCSwt7dHjx49EB0d3ezwVr5ISkqChYUF3NzcBLVDsWqRyWSQyWSorq7GrVu3lFGHDXNNXnvtNbVzTfiisLAQy5cvx969e9GpUyf8+uuvCA8P17od9VHcw4oVoD6j1yuXnJwcdOjQAe+++y6+/PJLoc1RUlNTg9TUVJSUlMDW1hY+Pj4wNTUV1CaF0ChcYCUlJcq8ClNTU53IsSEi7N+/HwAwcuRIwe0BHqzuFIUi09PTYWZmpiwUyVdUUkspLCzE9evXERoaKngHw/q5JnFxcYiPj4dUKoWTkxMiIyNbnGvCBzKZDD/99BO+/PJLcByH2bNnY8yYMToVBmwIiZV6LS6TJ0/GgQMHkJCQINgy9kkUFRUhLS0NdXV1grjK6lNRUYELFy7g3r17aNOmjTIRUhfCnuuTlZWlrLMUEBAgiA21tbW4desWYmJikJCQAAAICgpCdHQ0OnbsqFPRPESES5cuwdTUVJC3bplMhrt37yrF5NatW6itrX0o1yQ0NFQZIdeYq0ybXL16FXPmzMGNGzcwevRozJ49W3BBbgxDCE3WnbtETW7fvo1t27bhq6++0klhAQB7e3vY2toqXWWFhYXw9vbW6oa1XC7HzZs3ERsbCyMjI/Tr16/Rh7au9LFxd3eHr68vzp8/Dz8/P629ucnlcty7dw8xMTG4fv06ampq0LZtWwwbNgzh4eGwtLTUih3qkp2djcrKSgQHB2tlvKZyTcaPH//YXBOFq0yIBEyJRIIVK1Zgz549CA4OxqFDhxAVFaW18dVF4RqTy+V6u3rR25XLkCFDkJCQgBs3bmg1Iqe5VFdXIy0tDSUlJbCzs4O3t7fGXWVZWVk4e/YsiouL0bFjR0RHR6v8WwnZx6aoqAh79uxB9+7dERERobFxADxUKLKkpAROTk6IiopCdHS0Tr7R1kcmk+HChQtwcHBAUFCQRsZoTl+Tps6nzQRMmUyGvXv3Yvny5ZDL5fj4448xduxYvXhg6/vqRS9XLn/99Rd+//13/Pzzz3ohLMCDcNvAwEClq+zmzZtwc3NDmzZteL/BKisrceHCBSQlJcHV1RXDhw9X+0EpZB8be3t7dOzYEbGxsQgKCuI9tLukpERZKDIrK0tZKDIqKgre3t56cyOnpaVBKpXyntOSm5urFBN1+pqoQmMJmJpylV27dg1z587FtWvX8PLLL+Ozzz7T+ReG+uh7YqXerVzkcjm6dOkCc3Nz/Pvvv3rzIKiPXC5HVlYWcnJyYGJiAh8fH94K4Cn2ChTRVwEBAbz/RtroY1NVVYWdO3ciODgYvXr1aqnJqKmpURaKTExMhFgsVq7mOnTooBdvsvWpqanBhQsX4OXl1eJ6b4pcE0V4cHZ2ttp9TZqLJmqVFRUVYcWKFfjpp58QFBSEJUuWIDo6mgdrtY8+hybrnRzu3r0b165d01thAR68kXh6esLJyQmpqam4e/dui11l2dnZOHv2LIqKihAcHKyMAtME9cVDkUDXWNhzS8TG3NwcUVFRuHTpEjp16tQs8ZXL5UhISEBsbCxu3LiBuro6tGvXDqNGjUJYWJhGkl21xf3795X9htTlSbkmXbt21WquSUsSMBsil8uxb98+fPHFF6irq8PChQsxbtw4vXzrV6DPiZV6tXKpqqpCcHAwunbtip9//lloc3hDIpEgPT0dUqlUGVWm6sO4srISFy9eRGJiIlxcXNCrVy/BGw/x1cdGKpVi9+7dcHV1xbPPPqvy2BkZGYiNjcWVK1dQXl4OV1dXZaFIXQ3+UIfy8nJcvnwZgYGB8PDwaPLzmuhrogmaSsB8Ejdv3sScOXMQFxeH4cOHY86cOXB2dtaUqVpFX1cveiXp69atQ25uLpYuXSq0Kbzi4OAAOzs7ZGVlISsrCwUFBU26yuRyOW7fvo2YmBiIRCL06dMHgYGBOrGaayyhUyE09cvUNPzTECMjI3Tt2hV//vkncnJy0KZNm8eOKZFIcOXKFcTExCAvLw/W1tbKjXlNFooUgnv37sHCwuKxiaZN9TVR7JsInfjZEMXLR/1oxaZcZSUlJfjqq6+Utel++eUXdO3aVYtWax59TazUm5VLXl4eOnTogDfffBOrVq0S2hyNUVVVhbS0NJSWlsLe3h7e3t6PbJzm5OTgzJkzkEgkCA4ORufOnQVP0lQHdfrYEBH27dsHIyMjjBgx4qHzVFVVKQtFJicnw8TEBJ06dUJUVBQCAwP16kZUFYlEgmvXrqFTp07KFaoquSZ89DXRJk1Flcnlcuzfvx9ffPEFampq8MEHH+CNN97QaxfYk1CsXvQpsVJvxGXatGnYs2cPEhIS9Crio7lIJBJl+XR3d3e0adNGWfX27t27cHFxQc+ePQ1i6d9UH5usrCz8+uuvePbZZ+Hj44M7d+4gNjYWt27dglwuR2BgIKKjoxESEqJXIqsuRITLly/DyMgItra2WutrIiSNucpu3bqFuXPnIjY2FsOGDcOcOXPg4uIisKWaR5H3oi+hyXohLnfv3kVoaCiWLVuGWbNmCW2O1pDJZMjKykJ2djYyMzORk5MDCwsLdO3aFe3bt9eLCdYcGooNEeGHH37AjRs3YGVlhdraWnh4eCgLRdrY2AhtskZR7CP9+eefOH36NAoKClBdXd3sXBN9Q7GKKSkpwerVq7Fjxw4EBARgyZIl6Natm9DmaRV9KgujF+IyYsQIXLt2DTdv3tTrCJ/mkJubiz///BNJSUlo06YNevXqhXbt2ulNfk9LyM/PR0xMDGJiYpCZmYm0tDQMHDgQI0aMUAY9CN1qV1M0zDUpLCxEWVkZAgMDlaXoNdnXRJcgIhw8eBCLFy9GdXU1ZsyYgfHjx7eK794QfUqs1Hlx+ffffzFgwADs3LkTo0ePFtocraFwgSUkJMDJyQm9evWCWCxGenr6Q64yXZ9g6lJeXo6rV68iJiYGaWlpMDMzQ1hYGKKiopCWlobk5GSMHTsWJiYmGsuxEYKmck1cXV1hbm6Op556qlW9YN25cwdz587F5cuXMWTIEMydOxcuLi7NjiozBBRJzLq+v6TT4iKXy9GjRw9wHIezZ88a5AZtQ4gId+7cwaVLl8BxHDp37oygoCDlDSSTyZCZmYm8vDyYmprCx8dH791CdXV1yuTP+Ph4AA8KRUZFRaFjx47KxmWVlZXYtWsXQkJC0KNHDwDN62OjC6jT16S2thYXLlyAh4eH1rqDCk1ZWRlWrVqFH3/8Eb6+vliyZInymgMPb/gb8gq2MRSb+7q+etFp6du3bx9iY2Px119/tQphycvLw5kzZ1BQUIAOHTqgS5cuj7ylKhLnFAmYCQkJcHBwgJeXl165CYhIWSjy2rVrqKmpgY+PD4YOHYrw8HBYWVk9coyFhQUiIiIQGxuLTp06wdraWq0+Nurk2PBNU7kmT+prcv/+fXAcBx8fH63brW2ICIcPH8aSJUtQUVGB2bNnY/z48Y90RlWUkSEiZUFMbdQq0wUUc1jXy8Lo7MqluroaISEhCAsLw4EDB4Q2R6NUV1fj0qVLiI+PV7rAVI1+KSwsVLrKPDw84OrqqtNvM9nZ2coEx+LiYjg6OiIqKgpRUVEqRb7V1dVh165d8PDwwMCBA5v8fFNhz5oSm6ZyTVTta1JRUYHLly/D398fXl5evNupSyQkJGDu3Lm4ePEiXnjhBcybN0/l5meKqLLWsorRh8RKnZW9DRs2ICMjA8eOHRPaFI1BRIiPj8elS5dAROjVq9dDLjBVcHR0hJ2dHTIzM5Genq5MwBSi1e7jKC0tVRaKzMzMhIWFBcLDwxEdHQ0fHx+1vq+xsTG6du2Kv//+G+Hh4U2KsOINV0FTCZ3NvVGbyjWZOnVqs3JN7t27BzMzM5Uy8fWV8vJyrF69Gtu2bYOPjw92796N3r17q3WO5iRg6jP6kFipkyuXwsJCtG/fHq+++irWrVsntDkaIT8/H2fOnEF+fj4CAwPRtWvXFhcGrKysRGpqKsrLy+Ho6AgvL69H3AnaoqamBjdu3EBMTAwSExMhEomUhSKDgoJaFEpJRPj5559hZmaGYcOGtcjOpnJsHnfjNtXXhI9ck6KiIly9ehUhISEGkc/UECLCkSNHsHjxYpSVlWHGjBl45513WuzeVbjKABi0q0zXEyt1UlxmzZqFH3/8EQkJCQZ3U1VXV+Py5cu4c+cOHB0d0bNnzyeWNWkOBQUFSE9PBxHBw8MDLi4uWnmDk8vluHv3rrJQZG1tLfz9/REVFYWwsDBeq+qmpaXh6NGjGDx4MK8l5x8nNsCD/jiKPZNr166htLRUY7kmRKSsbh0ZGdni8+kaiYmJmDdvHs6dO4fBgwdj3rx5vK/OWoOrTJcTK3XOLXbv3j1s2rQJCxcuNChhISIkJCTg0qVLyii44OBgjbxVOTk5KV1laWlpyM/P15irjIiQmZmJmJgYxMXFoaysDC4uLnj66acRFRWlsUKR3t7e8PLywrlz5+Dj48Pb71j/PDk5Obhy5YpSUAoLC5V9TV544QVERkYiODhYI4EUubm5KC8vNzhhqaiowNq1a7F161Z4eXlh586d6NOnj0bGag2usvq9cXRt9aJzK5fRo0fj4sWLuH37tkb6RwhBQUEBzpw5g7y8PN5cYKqiKVdZUVGRslBkbm4urKysEBkZiejoaHh4eGjlBi4oKMDevXvRp08fhISEtPh8TeWahIeHo2PHjjAzM9Nojo1cLseFCxdgY2PDy/fSBYgIv/32GxYtWoTi4mJMnz4dEydO1FqEoyG7ynQ1sVKnVi7nz5/HgQMH8MMPPxiEsNTU1ODy5cu4ffs2HBwcMGTIEN5dYE1hYWGBoKAgpausuLi42a4yRaHI2NhY3Lt3D8bGxujUqRNeeuklQQpFOjk5ISgoCBcvXkRgYKDaD6qW9DXRVB8bAEhPT1e6FA2Be/fuYd68eThz5gwGDRqEBQsWwNPTU6s2cBwHIyMj5Vu+oiCmLj2Mm4uudqzUmZULEaF3796oqanBxYsX9frNgohw9+5dXLx4ETKZDNHR0ejYsaPg30kqlSoTMC0sLODj49NoPkl9ZDIZ4uPjERMTg1u3bkEmkyEgIADR0dHo1KmT4IUiKyoqsGvXLoSFhTVZZ0rTfU346GOjSJh0c3NDQEBAs+zQFSorK7Fu3Tps2bIFHh4e+Pzzz9G/f3+hzXokAVPX3EnNQRdXLzojcwcOHMDFixdx8uRJwR/CLaGwsBBnzpxBbm4u2rVrh27dusHCwkJoswA8KBfh4+OjTMC8c+cOnJyc4Onp+ZCrjIiQmpqK2NhYXL16FRUVFXB3d8fgwYMRGRmpUxUBLC0tER4ejri4OISEhDwklrW1tbhz544yokvTfU346GOTkpICjuPQtm1bXmwSAiLC77//jkWLFqGwsBAzZszApEmTBH8RUdAwAVMRcaXPzx1dXL3oxMqltrYWISEhCAoKwq+//iq0Oc2itrZW+XZvZ2eHXr16qZwAJhT5+fnIyMgAESnzLxT7KIWFhbC1tVUmOOryd6mrq8POnTvh4eEBb29vne1r0lRCpyKZ1s/Pr1nti3WB5ORkzJ8/H//++y+eeeYZLFy4UOeTPw0lqkzXEit1QuK+/fZbpKam6q2wKFxgUqkUXbt2RUhIiE5c3KZwdnaGiYkJTp06hd27dyM/Px/Ozs7o3LkzRo0aBX9/f53+HvVzTc6fP48LFy7A3t4ednZ2CA0Nxfjx43Wqr0lDF0x9oZHL5YiPj4dYLIabm5ve9UyvqqrCN998g82bN6NNmzb44YcfMGDAAKHNUonGosr00VWmEEddmTuCr1yKiorQvn17jBgxAps2bRLSFLWRSCQ4c+YMcnJydM4F9iSkUqmyUOSdO3cAAL6+vmjTpg3c3Nzg5uYGLy8vnVleK1D0NVGsTOrnmnTs2BFVVVXo0KEDJk+erHcPh+LiYsTGxiIoKAguLi6PrGx09Y2aiHDy5EksXLgQ+fn5mDJlCiZPnqy3lZv1PapMl1Yvgj89li9fjtraWixYsEBoU1SmtrYWsbGxuHnzJmxtbfHCCy88tp+5rqB4y1cUiqyuroa3t7dy38HKygpEhPz8fGRmZiqjypydnQV9qCn6mjSWazJkyJCH+pqkpKTgt99+Q0ZGhl4VeVQU8bSzs1P2qWnYLE1RZl2XxCYlJQULFizA33//jf79++Pnn3/Wq9+9MfQ9qkyXysIIKi4pKSlYv349PvvsM62H6DaXpKQkXLhwAbW1tejSpQs6deok+EV8Erm5uYiJicGVK1dQVFQEBwcHPPXUU4iMjHykLhfHcXBxcYGDgwMyMjKQmpqqrFVmaWmpFXuflGsyYMAAREREICQkpNFQ9bZt28LDwwPnzp2Dl5eXTl+X+uTl5aG0tBQRERHKh1jDzf76QlO/9a8QrQWqq6uxYcMGbNy4ES4uLti6dSueeeYZvXkAq4I+u8oUiZUymUxQmwV1i7322mv4999/cefOHa09vJqLRCLB2bNnkZ2dDT8/P3Tv3l1nbS4rK1MWiszIyIC5ubmyUGTbtm1VfgiUl5cjNTUVlZWVcHZ2hqenJ++uMnX6mqhCfn4+9u3bh759+6Jjx4682qoJ5HI5Ll68CCsrK3Tq1Enl44TqY/PHH39g/vz5yM3NxeTJkzFlyhSDyEl7EvroKtOF0GTBVi6XL1/G3r178d133+nsQxp44AK7cuUKbty4AVtbWzz//PM6WaG2trYWN27cQGxsLBISEpSFIp955hkEBQU1SxSsrKwQHBysjCorKiqCp6dni8rytKSviSo4Ozujffv2uHTpEgIDAwUr3KkqGRkZqKmpQVhYmFrHabuPTVpaGhYsWIA///wTffr0we7du3mt6abL6KOrTBdCkwVZuRAR+vfvj+LiYmVxPl2kvgssMjISoaGhOvXWIpfLkZiYiNjYWFy/fh21tbXw9fVFdHQ0wsPDeX2jrKurQ0ZGBgoKCmBpaamyq6ypXBNV+5qoQ1lZGXbv3o3IyEh06dKFt/PyTV1dHS5cuABXV1cEBgbyem6++thUV1dj06ZN2LBhA5ydnbFgwQIMGjRIpx+smkSfEjCFXr0IImlHjhzBmTNn8Ntvv+nkxSkqKsLZs2eRlZUFX19fdO/evclMdm1BRMjKylIWiiwtLYWzszMGDBiAqKioZr/xN4WxsTF8fX3h7OyM1NRU3L59Gy4uLvDw8HjozUhTfU3UwdraGmFhYYiLi0PHjh11dmWckpICItLICoCPPjZ//fUX5s+fj6ysLEyaNAlTp07Vi2hITaJPCZhCr160vnKpq6tDaGgofH19da4RWF1dndIFZm1tjZ49e2q9BtLjKC4uViY45uTkwMrKChEREYiOjtZ6UiARIS8vD5mZmQAehDanpaVprK9Jc6itrcXOnTvh6+urEyVHGlJVVYWLFy/C19dXkAirJ/WxyczMxKJFi3Dy5En07t0bixYtMpg6Z3yj6wmYQoYma13Otm7dinv37mHfvn3aHvqJJCcn4/z586ipqUFUVBRCQ0MFX1VVV1c/VCjSyMgInTp1wosvvshb3xB1qZ9rEhMTg4sXL6KoqAhmZmaIiorCmDFjeO1r0lxMTEzQpUsX/PvvvwgLC4Ojo6NgtjTGvXv3YGJiIlj2esMHjVwuR3V1NTZv3owNGzbA3t4eGzZswHPPPSf4faDL6HpUmZCJlVpduZSUlCh7YXz33XfaGvaJFBcX4+zZs8jMzETbtm3RvXt3QVsEy2QyJCQkICYmBjdv3oRMJkO7du2UhSKFSE57Uq5JREQEAgMDYW5uDqlU2qirTCjkcjn27NkDGxsbvPjii0Kbo6SkpARXrlxBUFCQzoTgnz59GvPnz0dGRgbeeecdTJs2DRYWFo2ubHTxDV0XqB8irkuuMqFWL1p9AqxYsQIVFRVYuHChNodtFKlUiitXruD69euwsrLCs88+K1g9JyJCWloaYmNjERcXh4qKCri5ueG5555DZGQkbG1ttWpPc3JN6rvKJBIJvLy84OTkpFW7GyISidC9e3f8/vvvSEtL05l6XUlJSbCysuI1iKG5ZGZm4vPPP8fx48fRo0cPbNu2De3atXvoM7qUY6PLKARF16LKhEqs1Jq4pKWlYe3atfjwww8FD+W9f/8+zp8/j6qqKkRGRiIsLEyQpWxhYSFiY2MRGxuL/Px82NjYoEuXLoiKitJqxn9L+poo4DgOrq6ucHBwQHp6Ou7fv6/sgCnkJrCfnx/c3NyUiZVC3+iKhMnw8HBBbamtrcWWLVuwbt062NraYuPGjXj++ecbtam+eGiyj42hoIuuMiESK7XmFnvrrbdw6tQp3LlzRzC3U0lJCc6ePassD9KjRw+t21JRUYFr164hJiYGKSkpMDU1RWhoKKKjo7VWKLKqqgo3b95UuroSExN57WsCPBCs1NRUVFVVwdXVFR4eHoLdYLm5udi/fz/69++PoKAgQWwAHrhNLl26pAx2EIp///0X8+fPR1paGsaPH48ZM2a0KBqSjz42hoouucq0HZqsFXGJi4tDly5dsHHjRkyYMEHTwz2CVCpVFjq0tLREz549teoikclkuHXrFmJjY3H79m0QEdq3b4+oqCiEhIRopdXr7du3cenSJa3lmgAPHjq5ubnIzMyEWCyGl5eXYBvrJ0+eRFZWFsaOHStYYmV6ejru3buHzp07CxIenZWVhUWLFuHYsWPo3r07Fi9ezHt+DdB0jo2u7EVoE12JKpNKpVpbSbVYXOovix+HVCoFEamsmOp+8fr9zBujuLgYN2/ehJeXl8o1p9S5AZoaXy6X4/z58zA3N4erq6uy1D1f46tyDe7fv4+ysjJYWVnBxsYG1tbWT2zepO41eNI0qqurQ25uLsrLyxEQEKDyudW5AZu6BtXV1YiJiUGHDh1U3gtS5xqochvFx8fD0tJS5Qgxdb6/KnOgtLQUFRUVsLW1VclVydccaFiEUywWq/zd9GnF09QcqC+2qs4tdb9/UzYoRE4b16DF4nLgwAGIRCLe3sSuXbuGjz76SK1jkpKSmuxyV1tbq/IKobCwEOHh4SqPf/HiRYjF4ie6Furq6lR+Y87MzFSrF8bJkychk8lga2v72O+oiBZRZaIkJSVh9OjRKo8PPHA5NoVUKlUpiqy8vBwikUitBmVpaWlNfqaxOUBEyoKe9SkoKEBkZKTK4xcWFjb5GcUbfVMP7aqqKshkMrXyX/755x+VxgeafljEx8dDLpdj8uTJKo8PNC3wzUGfVjm68P3rVw/gA8XLQHNo8YZ+WloafvjhB8yaNQsvvvgiHBwcWvTF0tPT1T6mtrYW6enp6NevX7PHrU9FRYVan1f04ujWrRu6du0KCwuLFv0GRUVFan0+NzcX58+fBwAMGzYMTz/9dIvGz8vLU/sYPiPa7t69q3ab3+a6Of/44w8UFBQgIiIC7du3V/59WVmZWufhy91XXV2NmzdvIiAgQK3j+vTpw8v4RISJEyc2uwVGY9n/ivMqUHUPRhMPa03SHCGsvycD4KEXwOZ+f7lc/oiXqLmC05Jr0OLXgpkzZ+Knn35S9nSYPn06ysvLW3patQgKCkJSUpJgk/GZZ57B1KlTkZubiw0bNuDHH39UZq9rg9deew2rVq3Cxx9/jCNHjmDTpk0quWl0EW3aTURISEjAiBEj8Mcff+jEb3br1i1BH6pZWVlwd3dv1oNI4ctX5FPUjyhT/LaKsin1XUStlforWcVvpop7sykUv72ChgKmLVosLhzHISQkBD/++CNOnToFFxcXdO7cWe03v5ba8NRTT+GPP/7Q2pj1EYlEsLGxwejRo/Hee+8hMjIS3333Ha5du6aV8TmOg5mZGdq2bYvVq1cjNTUV69ev18ubNzs7W2tZ61evXkWXLl1gbGyMNm3aICcnRyvjPonS0lKEhIQINv7YsWOxZ8+eZh3bsCim4oGp+G/9PzKZ7JFN/9aEQmQVKxW+Iurq/771x2kYyacNeHNoKhpNzZ07F5988gk6d+6Muro6vk7fJIGBgcjKykJ2drZgb34cx8HKygphYWGYNWsWDh48iFu3bmnVBiMjIyxbtgwpKSnYunWr3t24mZmZWksuPH/+PKKjowEAQ4YMwZEjR7QyblO0pKVBS7l//z6vv3/DB6ciWkrhxxfqwacr1BeUxlyILTlnfQFTJHdqE953yziOw+uvv47XX38dTz/9tNYmDcdxGD58OM6dO4djx46ptMGsSWxsbPDhhx9i586dyMrK0urYYrEYK1asQExMDA4ePKjVsVuCqhvOfI6nGMvY2Fj5oNM3Xz9fKH4PreRA1BMZjuMecp0ZOvUf+g3hSwQUqxfFNTUIcQEeTJxPP/0Ubdu2xcSJE7U2aWxsbDB06FCEhobi0KFDWt/7aYi1tTXef/99rF27FtXV1VodWywW45tvvsH+/ftx9uxZrY7dXKRSqda6GtbW1j4SjtunTx/89ddfOHz4sFZsaIjQD9fY2Fi89NJLWhuvtdYqe9JLFMdxvMwDxW+q2NhvOJY23JEai/PjOA4//vgjrl+/jvXr12tqmEcQi8Xw9vbGoEGDcODAAcEFxtXVFa+++iq+/vprrb85mJiYYPPmzfjyyy9x7949rY7dHJKTk7VW2v306dN49tlnH/q74OBgZdkaoRCy4OfkyZOxbNkyQcbmazNb12kqHJ0vkVXseTUmKor/KvIPNYVGg8g5jsO///6L5cuX4++//9bkUI/g5uaGvn374vDhw0hNTRX0rTA0NBRBQUHYvXu31u2wsbHBhg0bMGPGDLVDnLVNaWmp1qo+JyYmPlKRmOM4jB49Wu0cH74oKSnRak25huTl5QnWWK21rFy06XpsSGN7MY0JOl+rGo1nKJmamiqX24qCiNrCx8cHzz//PGJjY/H333+joqJCEJFR7AdlZWXhypUrWh/fy8sLCxcuxLvvvova2lqtj68O2rjpnuSWsLa21noVagXJycmC9XcR2iXXGlCsWoRKDBWLxcrVikLgGrvuMpmMlz0wrXzLNm3a4I8//kDnzp1RWVmpjSGV2Nvb46WXXoKTkxOOHDmCW7duCSYwM2fOxN69eyGRSLQ+fnR0NMaMGYPp06fr5Ia1Nq9JcXGx4O0AGqOkpESwumcxMTE60fPGkEVOUVtMlRcoTf4O9UOgGxtX8aelbkqtSWiXLl2wYsUKdOvWTesPN7FYjE6dOmHIkCHIzMzEqVOnBJnEpqammD59OlauXAmpVKr18YcOHYrg4GAsWrRI525iuVzeZAkfvjh8+DCGDBmilbHURSj30MSJE7FixQpBxlbQMPnPkFA8sFVZtWhqDtRPcm2YvV//fys+pxcrFwVvvPEGBg0ahOHDh2t9EnEcB0tLSwwcOBAWFhY4ceKEIBPZ09MTzz77LNatWyfIbzBt2jTU1NRgy5YtOnUjZ2dna6WXfHl5OWpqarQWlaYKRITa2lpBe35IJBJB++4AUPZAMTQaJkw2BV8RY43RsOx/Q3vq29nS4BKtigvHcVixYgVkMhk+/fRTwdxTPXv2BABcunRJ6+MDQK9eveDm5oZdu3YJIjBLlizB5cuX8b///U+rYz+JnJwc2NjYaHSMuro67N27FyNHjtToOOogk8lw8+ZNxMbGIiIiQhAbSkpKBGuF0BpQdxNfmyLb2KY+XxUDtL6zxHEcDh8+jGPHjuGHH37Q9vBKGwYOHIikpCRkZGQIMv7o0aNRUVGBI0eOaF1gxGIxNmzYgB07duDy5ctaHftx8FnJtTFqamqwb98+dOnSRaf2W65cuQIHB4cmO31qkldffRU//fSTIGPXxxAjxoTexFcFja2SNHLWJhCLxbhw4QLmzp2Lv/76SwgTIBKJMGLECJw4cULrQQbAgxtp4sSJSExMVKlcOt+Ymppiy5YtWLx4MZKTk7U+vjYpLi7G3r17ERYWJmjdrobU1dWhqqoK7u7ugoUAS6VS3Lx586GK0EKjS+7alqCuO0yBNkX2cXsvfCCYnFpYWCA2NhbDhw9HfHy8IDaYmZlh8ODBOHDggFbroCkQiUSYOXMm/vnnH9y8eVPr49vb22P9+vWYMWMGCgoKtD6+AlU3Optz3oSEBBw6dAh9+vRBx44ddertODY2FpGRkYLZREQYP348Fi9erDO/i67Y0VIUwqJP1QdU6TWkDoKu1dzc3PDvv/+iR48egmVFu7m5ITo6GocOHRIkQ9jIyEhZgyw3N1fr43t7e2PJkiWYOHGi2n1s6lNdXY3y8nJUVFSgpqYGUqlU5aq3OTk5vOZ3EBEKCwtx9OhR3L59GyNHjoSPj49Gb3JFTTKpVPrQd69vU/2/IyJUVVUJtmKRyWT44osvUF5ejnHjxgliQ2Poe6Z+/TYDDTfPdRmF3XzeI8LVmvg/QkNDsWvXLkRFRSEhIUEQGzp06ICqqiocPXpUkBBVS0tLzJw5E6tXr8bChQu1Pn5YWBimTp2Kd999F9u2bWvWOSQSCcrKyh56iHIcB2NjY5iZmcHMzAwmJiYwNTWFiYnJQ1VyMzMzERUV1eLvQUQoKSlBXFwcsrKyEB0djYCAAK3c4Onp6SgoKFBuxIpEIpibm8Pa2hoWFhYoKytDQUEBzM3NERwcjPT0dHh4eGi1SCcRoby8HHfv3sXq1athbm6On3/+WSffrPXRNVZ/7qvrChOS+tFpBiUuADB48GB89tln6N69O6ZNm6b18TmOQ0REBGpqanDs2DG0a9dO6za4ubnhlVdewcqVK9G/f3+tj9+vXz9IJBJMmzatWcUL3dzclG2JFTeZVCpFbW0tqqurUVVVhZKSEtTU1AB4UIXYyMgINjY2vESm5Ofn4/LlyygpKUGHDh3Qs2dPldta84G3tzecnJxgZGQEkUiEuro6VFRUoKysDDk5OTAzM0NwcDBSU1Nx69Yt5Ofno2/fvryNf+bMGWRlZT3SgbCmpgYlJSVIT09HSkoKCgsLYWtrizFjxuDFF1/UuTdrxVzg+y1aG9SvQKxPtisy9/mmxeLCV7TVCy+8gLNnz6K4uFjtY/kqTtmpUyfExMQoH4Cq0hybG8PX1xdeXl6oqqpS6zi+XIp9+vRBYmJis37PxvasRCKRctWiQC6Xo66uTvmnqKgIgYGBj5SlUXey5+XlwcPDA927d4exsTFqa2tbVOpG3WNramqUiWcKl4i1tfUjEWC+vr5ISUlBYGDgE+eZut//1q1buH79+kPFCDmOg6mpKWxsbODh4YGePXvCy8sL9vb2EIlET3TDlpaWqjU+wN9qQ4jy8HzA5+Z4c8WpueM+LnGyJd+Doxb+Crdv327yM+osuaRSKUJDQ9WyQZVyKlKpVOWkICJSK+5flQ6GdXV1Kpf2kMlk8PDwUHn8lJQUlc6peKtS5bPqVidWRRDVvQbqJPUVFhY2+Rl1y2+oE7Ksyn6Vut/fyspK5fHv3r2r0jlV3bSVSqUIDg5WeXzF+VX5jK5GTrUUTbjy1P3+unQNWiwuqqB4m2q4ZNcWRUVFuHHjBrp06aK1qrv1ISKcPXsWbdu2haenp9bHl8vlSEpKAsdxCAgI0Pr4wINrkJubC19fX62VealPdXU1Ll26hJCQEDg4OGh9fABISEiAubk5vL29BRm/uLgY1dXVcHV1FeQ+VJR5F+o5oAvU35MRanyZTKaVa6AVh2tqaio8PT3x3HPPCVJTy8LCAgkJCSq94WuC1NRUHDx4ULAomA0bNmDatGmC5PMosLGxQV1dHe7evSvI72BmZobk5GSVVtqaoK6uDllZWYIVpty5cydCQ0Px119/CfZgV6waNd1HRJcRci9J2+HRWhEXf39/7N27F//88w8++OADbQz5EKampnB2dhYkGx/4/2+sQpRTP3r0KH799VdMnz4dYWFhWh9fgVgsRmBgIKRSKe7duyfIw8Xb2xvp6elaHxeAspeOEKums2fPYv78+Xj77bfx6quvan38+ijemPU53Li5aLuNd8OxpVKpcm9FG2gtVKRv375Yu3YtNm7ciC1btmhrWCWenp7IzMwU5KEWHx+PwMBArUfmxMXF4ZtvvsHQoUPx/PPPa3XsxjA1NYW/vz9KS0sFech7e3tDIpEI0p1UIpHA0tJS6y7B+/fvY9KkSejVqxfmzp2r1bEfh2LjWAgvhpAIKS6KPVdtdjrV6tNu4sSJeO+99zBjxgycPn1am0PDy8sLNTU1Wk/WrKqqQlpaGjp06KDVcTMzM7Fo0SJERERg8uTJWh37SdjY2MDb2xu5ublavxaenp7gOA5paWlaHRd4IC7aXrWUlpbi7bffhpOTEzZs2CBoC+X6KB5yfPQM0Sc0XT/vcSjckNre59F6kPvKlSvRp08fjBo1Sqt93Z2dnWFiYqL1N+a7d++CiLRau6m8vBxz586Fra0t5s6dK2gp98ZwcXGBi4sLUlNTUVZWprVxzczM4OLiovU5oKhaoE1xkUqlmDJlCgoKCrBt2zaNV5xWF4V7RlHZoDUghLgoOkoKEUShdXExMjLCnj174OjoiKFDh6KkpEQr44pEInh4eGh93yU+Ph6urq6ws7PTyngymQxLlixBUVERlixZIlil3abw9vaGtbU1kpKS1M4raum46enpWnWPSiQSiEQirc0BAFiyZAnOnDmDb7/9Fr6+vlobVx0U5VH4aKmr6wjhElMIt1DVAgRJz7W3t8evv/6KnJwcjB07VmtLY09PT+Tl5WntYaYonKjNVcuWLVtw5coVzJ8/X5CwZ1XhOA7+/v4wMjJCYmKi1uaAwj2al5enlfGAB+JiZ2entT23n376Cdu2bcPnn3+u7F2kqygefIYeQaZtcakfGSZUFQbBaj8EBgZiz549+OOPPzB79mytjOnl5QUiQlZWllbGy8vLQ3Fxsdb2W44dO4YDBw5gypQpiIyM1MqYLcHIyAgBAQGora3VWgSZq6srTExMtLbvIpfLUVxcrDWXmKKVxeuvv47XX39dK2O2lNYQQaapyt+PG0vbkWGNIWhhoaeffhqrVq3C2rVrtdI4zMrKCnZ2dlrzuSckJMDIyAh+fn4aH+v69etYu3YtXnzxxWbVBhMKMzMztGvXDqWlpVpxWYpEInh6empNXIqLiyGXy7UiLmlpaXj33XfRtWtXQQqgtgRDjyDT5n6LEJFhjSF41brJkydjwoQJmDJlCv777z+Nj+fp6am1fZf4+Hj4+flpvIBidnY2Fi5ciNDQUEyZMkWjY2kCGxsbeHl5IScnRyt9ZRTRatpwj0okEpiammq8tH55eTneeust2NraYtOmTYI/WNTFkCPIFAEL2hAXoSLDGkNwceE4DmvXrkWPHj0watQojWfRe3p6ory8nLdik49DkSyoaZdYZWUl5s6dCysrK8yfP1/vHioKXF1d4ezsjJSUFI1HkHl7e4OItPKSoY0QZJlMhqlTpyInJwc//PCDVgMH+MRQI8i0tWoRMjKsMQQXF+BB+fW9e/fCxsYGL730UrMqsqqKu7s7RCKRxh8sycnJqKur0+hmvlwux9KlS5Gfn6/TkWGq4uPjAysrK41HkFlbW8POzk7jrrGamhpUVFRoXFyWL1+O06dPY9OmTWoXHNU1DDGCTBviInRkWGPohLgAgKOjI3799VdkZGTg9ddf19jS2MjICG5ubhrfd4mPj4eNjQ3atGmjsTG2bt2KS5cuYd68eYIVQ+QTjuPQrl07iMVijUeQaaMUjKJat729vcbG+OWXX7B582YsWLAATz31lMbG0SaGFEGmjSgxXYgMawzdsQQPOkLu3r0bv//+u0ZLVXh6eiI7O1ujDy9FCLKmJtWJEyewb98+TJo0CZ07d9bIGEJQP4IsOTlZYw8Xb29vlJWVKWt+aQKJRAIbGxuNFauMiYnB7Nmz8eqrr+LNN9/UyBhCYSgRZJoWF12JDGsMnRIXAHj22WexYsUKfP3119ixY4dGxvD09IRUKlWpD0tzKC0tRXZ2tsb2W27duoXVq1dj8ODBGD58uEbGEBJzc3P4+/ujuLgYmZmZGhnD3d0dYrFYY6sXIkJRUZHGXGIZGRmYMGECoqOjsXjxYp1xhfBJ/eZr+oqmXWK6EhnWGDonLgAwffp0vPXWW5g8eTLOnz/P+/kdHR1hYWGhsX2XhIQEcByHwMBA3s+dk5OD+fPnIzg4GNOnTzfIhwoA2NrawtvbG9nZ2RqJIDM2Noabm5vG9l3KyspQV1enEXEpLy/H22+/DUtLS2zevFmwMv6aRvHQVPQg0Uc0KS6KfSldW7Eo0Elx4TgO69evR5cuXTBy5EikpqbyPoanp6fG3lrj4+Ph5eXFe/hpVVUV5s2bB3NzcyxYsEAn31b4xNXVFU5OTkhJSdFIJWMvLy9kZmZq5MElkUhgZGTEe00vuVyOGTNmICMjA9u2bdPofo4uoM8RZJp0iclkMsjlcp2JDGsMnRQXADAxMcG+fftgbm6OYcOG8f5w8fT0hEQi4b2Bllwux927d3mPEiMifPHFF8jJycGSJUtga2vL6/l1lbZt2yojyNTta98U3t7ekEqlyM7O5vW8wANxsbe35/3GX7FiBf744w+sX79eIytjXURfI8gUqxa+54AuRoY1hs6KC/CgkvGvv/6K+/fv48033+T1zUVRd4tv11hGRgYqKip432/Ztm0bzp8/jzlz5qBt27a8nluXUUSQiUQiJCYm8joHnJycYGFhwbtrTCqVorS0lHeX2MGDB7Fx40bMmTMH/fv35/Xcuo4+RpBpouukrkaGNYZuWwegY8eO2LlzJ44cOYIFCxbwdl4zMzM4OTnxLi4JCQkwMzPjNTT4jz/+wJ49ezBhwgR069aNt/PqC4oIsurqaiQnJ/N6bi8vL97FpaioCETEq7hcuXIFH3/8MUaNGoUJEybwdl59Qp8iyDThEtPlyLDG0HlxAYAXXngBy5Ytw/Lly7Fnzx7ezqsoBcPnm1B8fDwCAgJ4u/h37tzBypUrMXDgQLz88su8nFMfUUSQFRUV8RpB5u3tjcLCQl7doxKJBObm5jAzM+PlfFlZWXjnnXcQFhaGZcuW6bQrRNPoSwSZJsRFlyPDGkMvxAUAPvjgA4wbNw4TJkzApUuXeDmnl5cXqqurUVhYyMv5qqurkZqaytt+S35+PubPn4/AwEC8//77rfqhAgB2dnbw9PREVlaWMkGxpXh5eQEAr8EdEokEjo6OvJyrsrIS48ePh6mpKbZs2aLxOnW6Tv0Nfl0WGL6jxHQ9Mqwx9EZcOI7Dxo0bERERgREjRvDyMHB1dYWxsTFvDxbFngAf+y3V1dWYO3cujI2N8fnnnxtsuKm6uLm5wcnJCcnJyaioqGjx+czNzeHs7Myba6yyshLV1dW8uMTkcjnef/993L9/H9u2beNNsPQdkUik8xFkfIqLIjJM1zfwG6I34gI82CfZv38/TExMMHz48BY/XEQiEdzd3Xnbd0lISICzs3OLHyxEhC+//BKZmZlYsmSJ3hYi1BQ+Pj6wtLREYmIiLxFk3t7eSEtL48U9KpFIwHEcL9ds9erVOH78OL755hsEBQW1+HyGhC5HkPHpEqsfGabrG/gN0S9r8WC1cejQIdy9exfjx49v8ZuLl5cXcnNzW/yQIiLEx8fz4hLbvn07zpw5g88++0wrvWD0DZFIhHbt2oHjOCQlJbV4Dnh7e6O6upqXZE1F18mWui+OHDmCtWvX4pNPPsEzzzzTYrsMEV2NIONLXPQpMqwx9M9iAKGhodi+fTsOHDiAJUuWtOhcnp6ekMvlLe5OWVBQAIlE0mKX2OnTp7Fr1y68/fbb6NGjR4vOZcgYGxsjICAAVVVVuH//fovOpXCPttQ1xlfXyWvXruGDDz7A8OHDMWnSpBady9DRxQgyPlxi+hYZ1hh6KS4AMHToUCxevBiLFy/GL7/80uzz2NjYwMbGpsWusYSEBIjF4haVPE9ISMCKFSswYMAAjB49ukX2tAYsLCzg5+cHiUTSopcDsVjMS3fKkpISyGSyFolLTk4Oxo8fj44dO+LLL7/UKx+7UOhaBBkfLY31LTKsMfRWXABg9uzZGDNmDN5++23ExsY2+zx8dKeMj4+Hr68vTE1Nm3V8QUEB5s2bB39/f3zwwQfsoaIi9vb28PDwQGZmZosiyBSdMFviHpVIJDAxMWl22Z+qqiq88847MDIywnfffdfsudTa0KUSMXy4xPQxMqwx9FpcOI7D5s2b0alTJwwfPrzZb6+enp4oLS1tdpMymUyGpKSkZu+31NTUYP78+RCLxfj8889bfbipuri7u8PBwQH3799vdpCHt7c35HJ5i3JoWlLyhYjw4YcfIjExEd9//z2cnZ2bbUdrRBFBpoisEoqWZuXrS2kXVdBrcQEehJIeOHAAHMdhxIgRqKqqUvscLe1Oef/+fdTW1jZrv4WI8NVXXyE1NRWLFi3SeNdCQ8XX1xfm5uZISkpCXV2d2sfb2trCxsam2a6x2tpalJeXNztceO3atTh69CjWrFmDjh07NuscrR1diCBryX6LIndHHyPDGkP/vwEe5D4cOnQIt27dwoQJE9SeWCYmJnB1dW12vktCQgKsrKzg7u6u9rG7d+/G6dOn8cknnyAgIKBZ4zMePFgUv19za5C1pDtlS7pOHjt2DKtWrcKHH36I5557rlnjMx6geOMXYv+lJS4xfY8MawzD+BYAIiIisG3bNuzduxdffPGF2scrMr+b81BShCCrO6n+++8//Pjjj3jzzTfRu3dvtcdlPIyxsTHatWvX7Agyb29vlJSUoKSkRO1jJRIJrKys1HZp3rx5EzNnzsSQIUMwbdo0tcdlPIpir0IqlWp13JaIi2IDX9/3WepjMOICACNHjsT8+fOxYMECHDp0SK1jvby8UFdXh9zcXLWOKysrQ2ZmptousaSkJCxfvhx9+/bF2LFj1TqW8XgsLS3h6+sLiUSidil9Dw8PiEQitVcvRNSski95eXkYP3482rdvj6+//lrvfey6guIhre0Isua6xBQiaEjCAhiYuADA3Llz8fLLL+PNN9/E1atXVT7O0dERZmZmaj9Y7t69CwBq9daQSCSYN28efHx88NFHH7GHCs84ODjAw8MDGRkZKCoqUvk4ExMTtGnTRu19l/LycrW7TtbU1GDChAmQy+XYunUrb0UuGQ8QIoKsOeJSPzLM0J4DBicuHMdh69at6NChA4YPH46cnByVj2tOSHJ8fDw8PDxgbW2t0udra2uxYMECyGQyLFq0iIWbaghFBFlycrJaFY+9vLyQkZGh1huvRCKBWCxWueskEeHjjz/GnTt38P3338PV1VXlsRiqU3+DX9MC0xyXmCFFhjWGwYkL8CC57uDBg5BKpRg5ciSqq6tVOs7T0xMFBQUqf56I1Oo6SURYuXIl7t27h8WLF8PJyUml4xjNw9fXF2ZmZkhMTFQ5gszb21tt96ii5IuqG7EbN27EoUOHsGrVKoSGhqo8DkN9FJFXmo4gU7frpCIyzJA28BtimN8KD/znBw4cwLVr1zB58mSVJpa63SmzsrJQVlam8n7L3r178eeff+Kjjz7ivQ0y41EUEWREhKSkJJXmgLOzM8zMzFR2jclkMpSUlKjsEjt58iS+/PJLzJw5Ey+88IJKxzBahjYiyNRxidWPDDO0fZb6GKy4AEDnzp3x3XffYdeuXfj666+b/LyFhQUcHBxUFpeEhASYmJjA19e3yc+eO3cO33//PV577TX069dPpfMzWo6JiQkCAgJQWVmJlJSUJj/PcZxa3SkVXSdV2cy/ffs2pk+fjsGDB2PmzJkqnZ/BD4oNfk1EkBGRWuJiiJFhjWHQ4gIAo0ePxmeffYY5c+bg6NGjTX5e4XNXhfj4eLRr167JSXLv3j0sW7YMvXr1whtvvKHSuRn8oYggKygoUCmCzNvbG/n5+Sol5EokEpiZmcHc3PyJnysoKMD48ePh5+eH1atXG6wrRFdR1OnSRASZOvstigrOhi4sQCsQFwBYsGABXnrpJYwbNw43btx44mc9PT1RWVnZZHfKmpoa3L9/v0mXWHFxMebNmwdPT0/Mnj3bIDfu9AEHBwdl757i4uInftbb2xuAat0pVQlBrq2txYQJE1BbW4vvv/++SSFiaAZNRZCpumpR7PsoKjkbOq1CXEQiEX788Uf4+/tj2LBhyMvLe+xn27RpAyMjoyZXL/fu3YNMJnvi3kldXR0WLFiAuro6LF68mIWbCoyHhwfs7e1x7969J65KLCws4Ojo2KRrrKqqClVVVU/cbyEifPLJJ7hx4wa2bt0KNze3ZtvPaDmaiCBTRVwMPTKsMVqFuAAPXCOHDh1CdXU1Ro0ahZqamkY/JxaL4ebm1uRba3x8PBwcHB4b8UVEWLNmDe7evYtFixaxQoQ6gp+fnzKC7En+d1VKwajSdXLLli3Yv38/vv76a0RERDTXbAaP8BlBpopLrDVEhjVG6/mmePDA2L9/Py5fvowpU6Y8dmIpyq8/6eGTkJDwxJIvv/zyC06cOIEPPviAtajVIRQRZHK5/IkRZF5eXk26RyUSCWxsbB7bc+PPP//EsmXLMHXqVAwdOpQP8xk8wVcEWVPi0loiwxqjVYkLAHTr1g2bN2/G9u3bsXbt2kY/01R3SolEgvz8/Mfut1y8eBHfffcdRo8ejaeffpo32xn8YGJignbt2qG8vPyxEWTu7u4wMjJ6rGuMiFBUVPRYl1hCQgKmTp2KgQMH4sMPP+TLdAaP8BFB1pRLrLVEhjVGqxMXAHjttdfw0UcfYfbs2fj9998f+Xc7OztYWVk9dt8lISHhoSq89UlJScHSpUvRvXt3jB8/nnfbGfxgZWWljCBrLGFSLBbDw8PjseLypK6TEokEb7/9Nnx8fLBmzZpW5QrRJ/iIIHuSuLSmyLDGaLWzfsmSJRg8eDDGjh2L27dvP/LvTyoFEx8fDx8fn0c26EtKSjB37ly0adMGn376aavZuNNXHB0d4ebmhrS0tEYrIXt5eSE7O7vR7H6JRAJjY+NHyv7U1dXh3XffRWVlJb7//vtmd6VkaIeWRJApXGKNvTy0tsiwxmi14iISibBjxw74+Phg6NChKCgoeOjfvby8UFxcjPLy8of+XiaTITEx8RGXmFQqxeeff46qqiosXryYhZvqCR4eHrCzs2s0gszb2xsymaxR92hjXSeJCHPmzMGVK1ewdetWeHh4aNx+RstpbpOxx3WdbI2RYY3RasUFAKytrXH48GGUlZXhlVdeeah/uru7OziOeyRiKC0tDdXV1Q+FIBMR1q1bh9u3b2PRokWsEKEewXEc/Pz8YGJi8kgEmb29PaysrB5xjdXV1aGsrOwRl9i2bdvw888/48svv0RUVJRW7Gfwg0IIFK4sVWjMJWaITb+aS+v+9gB8fHywf/9+nD9/HtOnT1dOLFNTU7i4uDziGktISICFhYWyDhkAHDp0CMeOHcP777/PWtTqIWKxGAEBAZDJZI9EkDUWkqwo419fXE6fPo3Fixdj0qRJGDlypHYMZ/CKwoWlyv5LY1FiiuCA1rqB35BWLy4A0LNnT2zcuBHff/89NmzYoPx7T09PZGZmPuSLjY+PR2BgoPKt5PLly9i0aRNGjRqFQYMGad12Bj+YmpoqI8hSU1OVf+/t7Y2ioiKUlZUp/66wsBCWlpbKdglJSUl477330K9fP8yePVvrtjP4Q9UIssbERREZ9rjQ9NYGE5f/480338TMmTPxwQcf4NSpUwAe7LvU1tYiLy8PBQUFuH379kMl9tPT07F48WJ06dIF77zzjpDmM3jA2toabdu2RX5+vrKKg6enJziOQ1paGgoKCpCSkoL79+/D3t4ewINVzFtvvQV3d3d888037I1Vz3lSBBkRKedAfn7+Q//W2iPDGoMjTTY50DNkMhmGDRuGc+fO4ezZs3BxccHUqVPxzz//IDMzU/m5tm3bYtKkSbh69SosLS2xbt06WFhYCGg5g0/S09ORm5uLwMBAyOVyzJo1C8ePH3+o6GXbtm0xbdo0nDlzBsnJyTh69Ci8vLwEtJrBJ4qserFYjNLSUmzfvh3ffPMN7t27p/yMn58fpk+fjtdee02ZTNuaN/AbwsSlAaWlpejVqxeKioogkUie2MVQLBZjx44dePXVV7VoIUPTEBESExNx8uRJzJ49+4lzgOM4rF69GjNmzNCihQxtIJPJcPz4cYwaNUoZSdjY49LCwgL79+/Hc889p20TdRomLo3w448/4q233mrycxzHQSQS4bfffmP7LQbGsWPH8OKLLyp7dTwONgcMlxMnTmDw4MFsDjQTJi4NKC4uVpbdV+WnEYlEMDc3R0ZGxhMLGDL0BzYHGIo5UFVVpVJyJZsDj8I29Buwfft2lR8qwAPfbGVlJXbs2KFhyxjags0BhmIOqJq1z+bAo7CVSz2ICAEBAUhOTlYrU1eRiJeYmMg29PQcNgcYbA7wAxOXehQUFLSo70pBQYFKvdQZugubAww2B/iBucXq0bCOmLrUT7Rj6CdsDjDYHOAHJi71sLKyatHxDSvkMvQPNgcYbA7wAxOXejg6OsLf319tfynHcfD3939iL3WGfsDmAIPNAX5g4lIPjuMwbdq0Zh07ffp0tolnALA5wGBzgB/Yhn4DWHw7g80BBpsDLYetXBpgZ2eHAwcOKLNun4RIJALHcTh48CCbUAYEmwMMNgdaDhOXRhg0aBB+++03mJubg+O4R5a5ir8zNzfHsWPHMHDgQIEsZWgKNgcYbA60DCYuj2HQoEHIyMjAmjVr4Ofn99C/+fn5Yc2aNcjMzGQTyoBhc4DB5kDzYXsuKkBEkEgkKCsrg7W1NRwcHNimXSuDzQEGmwPqwcSFwWAwGLzD3GIMBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8HgHSYuDAaDweAdJi4MBoPB4B0mLgwGg8Hgnf8HFwMcHZ1kzmgAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "RuntimeError", + "evalue": "stack expects a non-empty TensorList", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m model \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mprune(threshold\u001b[38;5;241m=\u001b[39mpruning_threshold)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdatasetoct4\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtrain_input\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcpu\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m model\u001b[38;5;241m.\u001b[39mplot()\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/kan/KAN.py:314\u001b[0m, in \u001b[0;36mKAN.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 311\u001b[0m x_numerical, preacts, postacts_numerical, postspline \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mact_fun[l](x)\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msymbolic_enabled \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m--> 314\u001b[0m x_symbolic, postacts_symbolic \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msymbolic_fun\u001b[49m\u001b[43m[\u001b[49m\u001b[43ml\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 315\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 316\u001b[0m x_symbolic \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.\u001b[39m\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/kan/Symbolic_KANLayer.py:111\u001b[0m, in \u001b[0;36mSymbolic_KANLayer.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 109\u001b[0m xij \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfuns[j][i](\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m*\u001b[39mx[:,[i]]\u001b[38;5;241m+\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m1\u001b[39m])\u001b[38;5;241m+\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m3\u001b[39m]\n\u001b[1;32m 110\u001b[0m postacts_\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmask[j][i]\u001b[38;5;241m*\u001b[39mxij)\n\u001b[0;32m--> 111\u001b[0m postacts\u001b[38;5;241m.\u001b[39mappend(\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstack\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpostacts_\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 113\u001b[0m postacts \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mstack(postacts)\n\u001b[1;32m 114\u001b[0m postacts \u001b[38;5;241m=\u001b[39m postacts\u001b[38;5;241m.\u001b[39mpermute(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m3\u001b[39m)[:,:,:,\u001b[38;5;241m0\u001b[39m]\n", + "\u001b[0;31mRuntimeError\u001b[0m: stack expects a non-empty TensorList" + ] } ], "source": [ - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct4['train_input'].to(\"cpu\"))\n", "model.plot()" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 4.05e-01 | test loss: 3.67e-01 | reg: 1.76e+01 : 100%|██| 13/13 [00:05<00:00, 2.48it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9998897911209497\n", - "R^2 of total dataset: -0.27749812602996826\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "datasetoct5 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [-5, 0], [0, 5]])\n", + "datasetoct5 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [-5, 0], [0, 5]])\n", "model.train(datasetoct5, opt=\"LBFGS\", steps=int(80/6));\n", "f_pred = model(datasetoct5['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct5['test_label'].to('cpu').detach().numpy()\n", @@ -521,44 +514,18 @@ "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", "print(f\"R^2 of total dataset: {r2}\")\n", "\n", - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct5['train_input'].to(\"cpu\"))\n", "model.plot()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.26e+00 | test loss: 1.18e+00 | reg: 1.68e+01 : 100%|██| 11/11 [00:04<00:00, 2.54it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9984267080435529\n", - "R^2 of total dataset: 0.1288338303565979\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "datasetoct6 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [0, 5], [-5, 0]])\n", + "datasetoct6 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [0, 5], [-5, 0]])\n", "model.train(datasetoct6, opt=\"LBFGS\", steps=int(80/7));\n", "f_pred = model(datasetoct6['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct6['test_label'].to('cpu').detach().numpy()\n", @@ -570,44 +537,18 @@ "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", "print(f\"R^2 of total dataset: {r2}\")\n", "\n", - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct6['train_input'].to(\"cpu\"))\n", "model.plot()" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.70e+00 | test loss: 2.71e+00 | reg: 3.72e+00 : 100%|██| 10/10 [00:02<00:00, 4.89it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9900069534778595\n", - "R^2 of total dataset: 0.15127569437026978\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "datasetoct7 = create_dataset(f, n_var=3, train_num=2500, test_num=500, seed=0, ranges=[[0, 5], [0, 5], [0, 5]])\n", + "datasetoct7 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [0, 5], [0, 5]])\n", "model.train(datasetoct7, opt=\"LBFGS\", steps=int(80/8));\n", "f_pred = model(datasetoct7['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct7['test_label'].to('cpu').detach().numpy()\n", @@ -619,7 +560,7 @@ "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", "print(f\"R^2 of total dataset: {r2}\")\n", "\n", - "model = model.prune(threshold=0.1)\n", + "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct7['train_input'].to(\"cpu\"))\n", "model.plot()" ] From 9e6fe96ca21063372671dd6cf0c6cf052d2b1ca8 Mon Sep 17 00:00:00 2001 From: Arjeus Guevarra Date: Tue, 25 Jun 2024 21:06:59 +0800 Subject: [PATCH 4/7] insights on datasets --- tutorials/continual_learning_structural.ipynb | 82 ++++++++++++++----- 1 file changed, 62 insertions(+), 20 deletions(-) diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb index 8e994cc2a..564f2ea12 100644 --- a/tutorials/continual_learning_structural.ipynb +++ b/tutorials/continual_learning_structural.ipynb @@ -7,6 +7,12 @@ "outputs": [], "source": [ "# %%\n", + "\n", + "import site\n", + "import sys\n", + "\n", + "site.addsitedir('../') # Always appends to end\n", + "\n", "from kan import *\n", "import numpy as np\n", "import torch\n", @@ -28,7 +34,8 @@ "# sin(x) * cos(y) + exp(z/2) - x^2 * y\n", "f = lambda x: torch.sin(x[:, [0]]) * torch.cos(x[:, [1]]) + torch.exp(x[:, [2]]/2) - x[:, [0]]**2 * x[:, [1]]\n", "\n", - "trainpoints = int((5/0.05)**3)\n", + "# trainpoints = int((5/0.05)**3)\n", + "trainpoints = 20000\n", "testpoints = trainpoints//5\n", "\n", "trainpoints_subtask = trainpoints // 5\n", @@ -62,7 +69,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 9.83e-02 | test loss: 9.91e-02 | reg: 3.92e+01 : 100%|██| 80/80 [28:25<00:00, 21.32s/it]\n" + "train loss: 9.23e-02 | test loss: 1.00e-01 | reg: 3.23e+01 : 100%|██| 80/80 [01:48<00:00, 1.35s/it]\n" ] } ], @@ -108,8 +115,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999906831053522\n", - "R^2 of total dataset: -0.011580586433410645\n" + "R^2: 0.9999897634188528\n", + "R^2 of total dataset: 0.1587788462638855\n" ] } ], @@ -131,9 +138,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -162,15 +169,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 6.46e-01 | test loss: 6.46e-01 | reg: 7.02e+00 : 100%|██| 80/80 [04:35<00:00, 3.44s/it]" + "train loss: 2.25e-01 | test loss: 2.42e-01 | reg: 1.49e+01 : 100%|██| 80/80 [00:48<00:00, 1.63it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9996043009450659\n", - "R^2 of total dataset: 0.3281276822090149\n" + "R^2: 0.9999402495777758\n", + "R^2 of total dataset: -0.06917226314544678\n" ] }, { @@ -236,15 +243,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "train loss: 3.23e+00 | test loss: 3.22e+00 | reg: 9.33e+00 : 100%|██| 40/40 [02:14<00:00, 3.37s/it]" + "train loss: 2.13e-01 | test loss: 2.23e-01 | reg: 1.55e+01 : 100%|██| 40/40 [00:21<00:00, 1.86it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9917527427896857\n", - "R^2 of total dataset: -7.52069091796875\n" + "R^2: 0.9999581105221296\n", + "R^2 of datasetoct0: 0.9855069778859615\n", + "R^2 of total dataset: 0.12102442979812622\n" ] }, { @@ -262,6 +270,11 @@ "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", "print(f\"R^2: {r2}\")\n", "\n", + "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "print(f\"R^2 of datasetoct0: {r2}\")\n", + "\n", "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", @@ -272,6 +285,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "Also total dataset has bad r^2. Lack of data? \n", "Less catastrophic forgetting PROVIDED that the network is well pruned. Occam's Razor?" ] }, @@ -282,9 +296,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -299,22 +313,31 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "train loss: 1.57e+00 | test loss: 1.57e+00 | reg: 4.82e+00 : 100%|██| 26/26 [01:28<00:00, 3.40s/it]" + "description: 0%| | 0/1 [00:00 Date: Wed, 26 Jun 2024 22:17:21 +0800 Subject: [PATCH 5/7] hopefully the utils fixing be okay --- kan/utils.py | 39 ++- tutorials/continual_learning_structural.ipynb | 321 +++++++----------- 2 files changed, 156 insertions(+), 204 deletions(-) diff --git a/kan/utils.py b/kan/utils.py index 7a029a825..644c8d5ad 100644 --- a/kan/utils.py +++ b/kan/utils.py @@ -39,6 +39,7 @@ def create_dataset(f, ranges = [-1,1], train_num=1000, test_num=1000, + step_size=None, normalize_input=False, normalize_label=False, device='cpu', @@ -56,6 +57,8 @@ def create_dataset(f, the number of training samples. Default: 1000. test_num : int the number of test samples. Default: 1000. + step_size : float + step_size within the specified range. Default: None. normalize_input : bool If True, apply normalization to inputs. Default: False. normalize_label : bool @@ -64,6 +67,7 @@ def create_dataset(f, device. Default: 'cpu'. seed : int random seed. Default: 0. + Returns: -------- @@ -87,13 +91,34 @@ def create_dataset(f, 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 step_size is None: + 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] + else: + # generate warning that if step_size is provided, test_num is only the required argument + if test_num is not None: + print('Warning: if step_size is provided, test_num is only the required argument. train_num equals to all possible combinations minus test_num.') + def generate_grid(dimensions, range_start, range_end, step_size): + # Generate an array of values for each dimension + ranges = [np.arange(range_start, range_end, step_size) for _ in range(dimensions)] + + # Create the grid using numpy's meshgrid function + grid = np.meshgrid(*ranges, indexing='ij') + + # Reshape the grid to list all possible combinations of coordinates + grid = np.stack(grid, axis=-1).reshape(-1, dimensions) + + return grid + + all_data = torch.from_numpy(generate_grid(n_var, ranges[:,0], ranges[:,1], step_size)).float() + train_input = all_data[np.random.choice(all_data.shape[0], all_data.shape[0]-test_num, replace=False)] + test_input = all_data[np.random.choice(all_data.shape[0], test_num, replace=False)] + + train_label = f(train_input) test_label = f(test_input) diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb index 564f2ea12..34d34b9cd 100644 --- a/tutorials/continual_learning_structural.ipynb +++ b/tutorials/continual_learning_structural.ipynb @@ -17,14 +17,28 @@ "import numpy as np\n", "import torch\n", "import matplotlib.pyplot as plt\n", - "import pdb\n" + "import pdb\n", + "\n", + "from copy import deepcopy\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "create_dataset() got an unexpected keyword argument 'step_size'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 14\u001b[0m\n\u001b[1;32m 11\u001b[0m seednum \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# datasetall = create_dataset(f, n_var=3, test_num=test_num, seed=seednum, step_size=0.1, ranges=[[-5, 5], [-5, 5], [-5, 5]])\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m datasetoct0 \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_var\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_num\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtest_num_sub\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseednum\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mranges\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mTypeError\u001b[0m: create_dataset() got an unexpected keyword argument 'step_size'" + ] + } + ], "source": [ "# %%\n", "import math\n", @@ -34,16 +48,12 @@ "# sin(x) * cos(y) + exp(z/2) - x^2 * y\n", "f = lambda x: torch.sin(x[:, [0]]) * torch.cos(x[:, [1]]) + torch.exp(x[:, [2]]/2) - x[:, [0]]**2 * x[:, [1]]\n", "\n", - "# trainpoints = int((5/0.05)**3)\n", - "trainpoints = 20000\n", - "testpoints = trainpoints//5\n", + "test_num = int((10/0.1)*0.5)\n", + "test_num_sub = int((10/0.1)*0.5/8)\n", + "seednum = 1\n", "\n", - "trainpoints_subtask = trainpoints // 5\n", - "testpoints_subtask = testpoints // 5\n", - "pruning_threshold = 0.05\n", - "\n", - "datasetall = create_dataset(f, n_var=3, train_num=trainpoints, test_num=testpoints, seed=0, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", - "datasetoct0 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" + "datasetall = create_dataset(f, n_var=3, test_num=test_num, seed=seednum, step_size=0.1, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", + "datasetoct0 = create_dataset(f, n_var=3, test_num=test_num_sub, seed=seednum, step_size=0.1, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" ] }, { @@ -62,14 +72,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "train loss: 9.23e-02 | test loss: 1.00e-01 | reg: 3.23e+01 : 100%|██| 80/80 [01:48<00:00, 1.35s/it]\n" + "train loss: 2.97e-05 | test loss: 3.50e+01 | reg: 3.60e+01 : 100%|██| 80/80 [00:11<00:00, 7.08it/s]\n" ] } ], @@ -115,8 +125,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999897634188528\n", - "R^2 of total dataset: 0.1587788462638855\n" + "R^2: 0.9999914228965281\n", + "R^2 of total dataset: 0.20941400527954102\n" ] } ], @@ -131,91 +141,63 @@ "print(f\"R^2 of total dataset: {r2}\")" ] }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = model.prune(threshold=0.1)\n", - "model(datasetoct0['train_input'].to(\"cpu\"))\n", - "model.plot()" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## retrain network using such model and see" + "continue pruning until R^2 is close to 0.95" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.25e-01 | test loss: 2.42e-01 | reg: 1.49e+01 : 100%|██| 80/80 [00:48<00:00, 1.63it/s]" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999402495777758\n", - "R^2 of total dataset: -0.06917226314544678\n" + "R^2 of datasetoct0: 0.9999914228965281\n", + "R^2 of datasetoct0: 0.9999914228965281\n", + "R^2 of datasetoct0: 0.9999914228965281\n", + "R^2 of datasetoct0: 0.9999914228965281\n", + "R^2 of datasetoct0: 0.9999914228965281\n", + "R^2 of datasetoct0: 0.9387973248958588\n" ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=0.02);\n", - "model.train(datasetoct0, opt=\"LBFGS\", steps=80);\n", - "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", - "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", - "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2: {r2}\")\n", + "for x in range (1,100):\n", + " threshold_value = 0.01 * x\n", + " model = model.prune(threshold=threshold_value)\n", + " model(datasetoct0['train_input'].to(\"cpu\"))\n", + " f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + " f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + " r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + " print(f\"R^2 of datasetoct0: {r2}\")\n", + " if r2 < 0.96:\n", + " break\n", "\n", - "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", - "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", - "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## looks good, as R^2 > 0.95. We will use the network for the next dataset" + "model.plot()" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "datasetoct1 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [-5, 0], [0, 5]])" + "datasetoct1 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=seednum, ranges=[[-5, 0], [-5, 0], [0, 5]])" ] }, { @@ -227,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -236,23 +218,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "train loss: 2.13e-01 | test loss: 2.23e-01 | reg: 1.55e+01 : 100%|██| 40/40 [00:21<00:00, 1.86it/s]" + "train loss: 2.04e-01 | test loss: 2.02e-01 | reg: 2.24e+01 : 100%|██| 40/40 [01:12<00:00, 1.82s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "R^2: 0.9999581105221296\n", - "R^2 of datasetoct0: 0.9855069778859615\n", - "R^2 of total dataset: 0.12102442979812622\n" + "R^2: 0.9999669947537768\n", + "R^2 of datasetoct0: 0.9853335656225681\n", + "R^2 of total dataset: 0.37371963262557983\n" ] }, { @@ -291,14 +273,44 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.9999669947537768\n", + "R^2 of datasetoct1: 0.8431994915008545\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -306,38 +318,40 @@ } ], "source": [ - "model = model.prune(threshold=pruning_threshold)\n", - "model(datasetoct1['train_input'].to(\"cpu\"))\n", + "for x in range (1,100):\n", + " threshold_value = 0.01 * x\n", + " model = model.prune(threshold=threshold_value)\n", + " model(datasetoct1['train_input'].to(\"cpu\"))\n", + " f_pred = model(datasetoct1['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + " f_true = datasetoct1['test_label'].to('cpu').detach().numpy()\n", + " r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + " print(f\"R^2 of datasetoct1: {r2}\")\n", + " if r2 < 0.96:\n", + " break\n", + "\n", "model.plot()" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "description: 0%| | 0/1 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct2['train_input'].to(\"cpu\"))\n", @@ -405,32 +407,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.53e+00 | test loss: 2.52e+00 | reg: 5.12e+00 : 100%|██| 20/20 [01:08<00:00, 3.41s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9928696481510997\n", - "R^2 of total dataset: -4.074105739593506\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "datasetoct3 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [0, 5], [0, 5]])\n", "model.train(datasetoct3, opt=\"LBFGS\", steps=int(80/4));\n", @@ -447,20 +426,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAFICAYAAACcDrP3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAw4UlEQVR4nO3de3BUVYI/8O+53Xl00nkRkpAHAgkJCvIKITxEQYxBRGB8lOJzx3HGrZoZnZ3aqdrZqp3dqq3d2pqqXzniTgnWzq6LzjjODM9BQBAEFAigvCWg4SWGACGETifpd9/z+yN7r91JwITc5N7u/n6qKOiTBA7J6f72eQsppQQREZGBFLMrQERE8YfhQkREhmO4EBGR4RguRERkOIYLEREZjuFCRESGY7gQEZHhGC5ERGQ4hgsRERmO4UJERIZjuBARkeEYLkREZDiGCxERGY7hQkREhmO4EBGR4exmV4AoFkgpcf36dXR0dMDpdCI3NxdCCLOrRWRZ7LkQ3YLL5cLy5ctRXl6OvLw8jBkzBnl5eSgvL8fy5cvhcrnMriKRJQneREnUu61bt+Lxxx+Hx+MB0NV70Wi9lrS0NKxZswYLFiwwpY5EVsVwIerF1q1bsWjRIkgpoarqTT9PURQIIbBp0yYGDFEEhgtRNy6XCyUlJfB6vbcMFo2iKHA4HGhsbER2dvbgV5AoBnDOhaibVatWwePx9ClYAEBVVXg8HrzzzjuDXDOi2MGeC1EEKSXKy8tx7tw59OepIYRAaWkpGhoauIqMCAwXoigtLS3Iy8sb0Nfn5uYaWCOi2MRhMaIIHR0dA/r69vZ2g2pCFNsYLkQRnE7ngL4+IyPDoJoQxTaGC1GE3NxclJWV9XveRAiBsrIyDBs2bJBqRhRbGC5EEYQQeOWVV27ra1999VVO5hP9H07oE3XDfS5EA8eeC1E32dnZWLNmDYQQUJRbP0W0Hfpr165lsBBFYLgQ9WLBggXYtGkTHA4HhBA9hru0MofDgc2bN6O2ttakmhJZE8OF6CYWLFiAxsZGvP766ygtLY36WGlpKV5//XVcunSJwULUC865EPWBlBI7d+7EAw88gB07duD+++/n5D3RLbDnQtQHQgh9TiU7O5vBQvQdGC5ERGQ4hgsRERmO4UJERIZjuBARkeEYLkREZDiGCxERGY7hQkREhmO4EBGR4RguRERkOIYLEREZjuFCRESGY7gQEZHhGC5ERGQ4HrlP1EdSSkgpe708jIiisedC1A8MFaK+sZtdAaJYwWAh6jv2XIiIyHDsuZBlhMNh1NXVwe12m12VmDdt2jQUFBSYXQ1KYJzQJ8vwer2499574fV6kZGRYXZ1YpKUEg0NDfjf//1fLFmyxOzqUAJjz4UsQ0oJRVHw2muvYd68efrqrMiP3+qXqqpQVTXqa7SVXYqi6L9H/oq3lV/BYBAPP/ww+J6RzMZwIcux2+3YtWsXVq5ciVAohGAwiFAohFAohHA4jHA4rP85skz71f2FVQsSu92OpKQkpKSkIDU1Fenp6cjIyEB2djZyc3ORn5+PoqIiFBUVobCwEMOHD0d6ejrs9q6nSSyEULyFJcUuhgtZ0sWLF7Fhw4Yh/3eFELDZbEhLS0Nubi5GjRqFiRMnoqqqClOnTsXo0aORnp6ufy4R9Y7hQpaUlJRkyr8rpUQoFILb7Ybb7cb58+exa9cuCCGQlpaGMWPG4L777sPChQsxc+ZMDBs2DACDhqg7hgtZUmZmJkaOHKkPadlsNv2X3W7v8TjylzaXAgCqqurDZcFgEIFAAH6/H36/H16vFz6fDz6fD36/H8FgsNdhNaArdDo7O/HFF1/giy++wFtvvYVRo0Zh8eLFeOaZZzB58mQkJSUxZIj+D8OFLGnRokWYO3dur5PvkX+O/AXcvAehBYY26a/N12gh43a70draisuXL+Prr7/GmTNn0NDQgAsXLqC5uRk+ny/q7wuHwzh37hyWL1+O3/3ud5g/fz5+8pOfYO7cuUhOTmbIUMJjuJAlpaSkICUlxZR/WwsibXjs4sWLOHToED755BPU1dXh4sWLCAaD+ud3dnZi48aN2LZtG2pra/HLX/4S1dXVsNlsptSfyAoYLkTdaL2OpKQk5ObmIjc3F1OmTMEPfvADtLW14fDhw1i3bh02bdqEb775BqqqAgD8fj82btyITz75BD/84Q/xi1/8Avn5+ezFUELi8S9EfaANx+Xk5GD+/Pl44403sH//fqxcuRLTp0+P6qW0tbXhtddew0MPPYQdO3YgHA6bWHMiczBciPpJC5qCggK89NJL2L59O95++21MmjRJ76VIKXHs2DE88cQT+H//7//B4/FwYyMlFIYL0QAIIZCRkYFnn30W27dvxz//8z/ry5MBwO1241e/+hV++tOforW1lQFDCYPhQmQAIQSGDx+OX/3qV/jggw8wa9YsvRcTCoWwatUqPPfcc2hsbGTAUEJguBAZSFEUzJgxAxs2bMDf/u3f6ptBpZTYunUrnn32WVy4cIEBQ3GP4UJkMCEEcnNz8Zvf/Ab/8R//AafTqX9sz549eOGFF9iDobjHcCEaBEIIpKSk4Gc/+xlWrFiBnJwc/WN79+7Fyy+/jOvXrzNgKG4xXIgGkc1mw9NPP4233norKmC2bduGX/7ylz12/hPFC4YL0SBTFAWPPfYY3njjDf0SNCkl3n33XaxcuVLfhEkUTxguRENAURQsW7YM//Iv/6JP8geDQfz7v/879u7dy+ExijsMF6IhYrPZ8OMf/xjf//739WXKra2t+Id/+Ae0traaXDsiYzFciIZQamoq/vVf/xXTpk3Tyw4cOID//M//5PAYxRWGC9EQy8/Px69//WtkZWUB6Jp/efPNN3H8+HEOj1HcYLgQDTEhBO677z68/PLL+vBYS0sLfv3rX0cd5U8UyxguRCaw2Wz4u7/7O4wbN04v047rZ++F4gHDhcgkI0aMwN///d/rx/V7PB785je/gd/vN7lmRAPHcCEyiRACTzzxBKZPn66X7dy5E59++il7LxTzGC5EJsrMzMSrr74Ku73rUlifz4cVK1Zw7oViHsOFyERCCDz88MOorKzUy3bs2IGjR4+y90IxjeFCZLKMjAz86Ec/gqJ0PR3b29uxatUqhgvFNIYLkcmEEFi8eDHKysr0sg0bNqCxsdHEWhENDMOFyALy8vKwbNky/fHly5exceNG9l4oZjFciCxACIEnn3xSP5ZfSon3338fXq/X5JoR3R6GC5FFVFRU4L777tMfHzlyBMePHzexRkS3j+FCZBF2ux3Lli2L2lS5bt06Do1RTGK4EFmEEALz5s3DyJEj9bJNmzahra3NxFoR3R6GC5GF5OXl4cEHH9QfnzlzBp9//jl7LxRzGC5EFiKEwPe+9z39tspAIIAPPvjA5FoR9R/DhchChBCorq7G6NGj9bIdO3bA7XabVymi28BwIbKYnJwczJs3T3985swZrhqjmMNwIbIY7bwxbdWY3+/H9u3bOe9CMYXhQmQx2tBYYWGhXrZ9+3b4fD4Ta0XUPwwXIgvKz8/HjBkz9Mf19fU4f/68iTUi6h+GC5EFKYqCmpoaCCEAAG63G3v37uXQGMUMhguRBQkhMGfOHGRkZADoOmvs448/hqqqJteMqG8YLkQWNWbMGIwbN05//Nlnn+HGjRsm1oio7xguRBblcDhw77336o8bGxtx6tQpE2tE1HcMFyILmzdvnr4kORAI4NNPP+W8C8UEhguRRQkhMHnyZAwfPlwv+/TTTxEKhUysFVHfMFyILKygoAATJ07UHx8/fhzNzc0m1oiobxguRBaWlJSEOXPm6I+vXbuGL774wsQaEfUNw4XIwoQQuOeee/RTkkOhEPbt28d5F7I8hguRxU2YMAH5+fn647179yIYDJpYI6LvxnAhsrjc3NyoeZf6+nrOu5DlMVyILM5ut2PWrFn645aWFpw8eZJDY2RpDBciixNCYPbs2VHzLnV1dSbXiujWGC5EMeCuu+5CXl6e/njfvn3c70KWxnAhigF5eXmYMGGC/ri+vh4tLS0m1ojo1hguRDHAbrdj5syZ+uNr167h9OnTJtaI6NYYLkQxYubMmfo5Y8FgEAcOHOCkPlkWw4UoBgghMGHCBOTm5upl+/fvRzgcNrFWRDfHcCGKEQUFBaioqNAfnzhxAi6Xy7wKEd0Cw4UoRiQnJ6O6ulp/fPnyZZw5c8bEGhHdHMOFKIbMmjULitL1tPX5fDh48CDnXciSGC5EMUIIgUmTJiErK0sv279/P8OFLInhQhRDiouLUVpaqj8+evQo2tvbTawRUe8YLkQxxOFwoKqqSn/8zTff4MKFC+ZViOgmGC5EMWbWrFkQQgAAPB4PDh8+zKExshyGC1EMEUJg6tSpcDqdAAApJerq6hguZDkMF6IYM2rUKNxxxx3640OHDsHr9ZpYI6KeGC5EMcbpdGLq1Kn643PnzqGxsdHEGhH1xHAhijFCiKjLw9rb23H06FEOjZGlMFyIYowQAlVVVXA4HAAAVVWxf/9+k2tFFI3hQhSDysrKUFRUpD8+ePAg/H6/iTUiisZwIYpBWVlZmDhxov64oaEBV69eNbFGRNEYLkQxSFGUqHmXGzdu4IsvvjCxRkTRGC5EMUgIgerqaiQnJwMAwuEw513IUhguRDFq3LhxyM/P1x8fOHAAwWDQxBoRfYvhQhSjcnNzMX78eP1xfX09WlpaTKwR0bcYLkQxym63Y+bMmQC65mDC4TAuXbpkcq2IutjNrgAR3b6FCxfC7/dj5syZmDRpUtQwGZGZGC5kKaqqoq6uDp2dnWZXJWZoq8ZOnDiBUCiE1tZWk2tExHAhC1EUBRMmTMCWLVuwZcsWs6sTszIzM5GTk2N2NSjBCckDicgipJQIhUI8I8sAdrsdisIpVTIPw4WIiAzHtzZERGQ4hgsRERmO4UJERIZjuBARkeG4FJmojyLXvgghTKwJkfWx50LUR0eOHIGiKDhy5IjZVSGyPIYLEREZjuFCRESGY7gQEZHhGC5ERGQ4hgsRERmO4UJERIZjuBARkeEYLkREZDiGCxERGY7hQkREhmO4EBGR4RguRERkOIYLEREZjuFCRESGY7gQ9YGUEjdu3AAA3LhxI+puFyLqieFCdAsulwvLly9HeXk5ampqAAA1NTUoLy/H8uXL4XK5zK0gkUUJybdgRL3aunUrHn/8cXg8HgC930SZlpaGNWvWYMGCBabUkciqGC5Evdi6dSsWLVoEKSVUVb3p5ymKAiEENm3axIAhisBwIerG5XKhpKQEXq/3lsGiURQFDocDjY2NyM7OHvwKEsUAzrkQdbNq1Sp4PJ4+BQsAqKoKj8eDd955Z5BrRhQ72HMhiiClRHl5Oc6dO9evFWFCCJSWlqKhoUGfjyFKZAwXoggtLS3Iy8sb0Nfn5uYaWCOi2GQ3uwJEVuD3+9HU1ITPP/98QH+Py+ViuBCB4UIJRkqJ69ev49KlS1G/WlpaAHSFzECEw2Fcv34ddrsdNpst6ncOl1Ei4bAYxS2fz6eHR1NTk/67FiBOpxPFxcUoLi5GUVERSkpKkJ+fj/Hjx9/WnMuYMWNQX18PVVURCoUQCoUQDof1z7HZbHrQaKFjs9kM/38TWQF7LhTzVFVFS0tLVE+kqakJ169fB9C1VHjEiBEoLi7G5MmT9TDJzMzstTfxyiuv4Oc//3m/6/Gzn/0MKSkpUWVSSoTDYYTDYT1wfD6fvhJNCNEjcNjLoXjAngvFFI/HE9UT0f4cDAYBAJmZmVE9kaKiIowYMaJfPYSh2OeiqmpU4Gh/jvw7uwcOezkUSxguZEmqqqK5ubnHsJZ2eKTNZkNhYaE+rKUFSkZGhiH/fn936G/evBm1tbUD/ncjg0b7vbdeTmRvh70csiKGC5muo6Mjqidy6dIlXL58WX8nn52dHdUTKS4uRn5+/qC/k+/r2WJr1641JFhuJrKXE/m7Vh+tl9N9eI3ITAwXGjLhcBhXr17t0Rtpa2sDACQlJfXaG0lPTzetzi6XC++88w7eeOMNnD17Vi8vKyvDq6++ir/5m79BVlaWKXXrbVgtspfVW+AoCg/loKHBcKFB0d7e3mO575UrV/TVUzk5OVE9keLiYuTl5Vn2xU9KiWPHjuHf/u3f8E//9E+YPHmyJYejpJQ9Aqd7L6e3BQRERmOrogEJhUK4cuWK3hNpbGxEU1MT2tvbAQDJyckoKirC6NGjcc899+i9EYfDYXLN+0cIgZycHDidTuTk5FgyWICueiYlJSEpKSmqvPuwWiAQgNfr1T/e274cqwY9xQaGC/WJlBJut7vHct8rV67oQzHDhw9HUVER5syZo/dGhg8fbtkX4kTS254arZcTObwWCARu2cux2Wz8eVKfMFyoh2AwiMuXL0f1RC5duoTOzk4AQEpKCoqLi1FWVob77rsPRUVFKCoqQmpqqsk1p/64VS+ne+BE9nJ6G1ZjL4e6Y7gkMCklXC5Xj7mR5uZmSCkhhMDw4cNRXFyMefPm6b2RYcOG8d1rHNN6KMnJyXqZthk0cj7H4/HovRwhRK/7cthOEhfDJUEEAgFcvnw5qidy6dIl/R2pw+FAcXEx7rzzTsyfP1+fG4l8gaHEFRkekSJ7OeFwGIFAoMeRN91XrbGXkxgYLnFGSonW1tZeD2bUeiP5+fkoLi7GXXfdpfdGsrOz+S6T+u27ejmRCwi693K6D6+x/cUXhksM8/l8aGpq6nEUis/nA9C1wa+kpAQTJkzQQ6SwsLDHGDuRkW7Wy9EO9NQCJxgM6m0V4MGe8YbhEgOklL0ezKgdE68oCgoKClBcXIyJEyfqQ1pZWVl8N0iWoShKj2HW3no5Xq83qpfDgz1jE8PFYrxeb4+jUJqamhAIBAB8e0z8pEmT9N7IiBEjuBGOYlJfeznaadKayF4OD/a0Jr4imURVVVy7dq3HUSitra0Aup482jHxU6dO1c/WMupgRiIr662XA6DXwOH1BdbEcBkC2jHx3Q9m1I6Jz8rKQlFRESorK/XeSEFBAd+JEXWjBUfkvTndry/o3svh9QXmYLgYSFVV/WDGyKEtl8sFoOuJoR3MWFVVpZ+t5XQ6za04UQxTFAWKotz0yButt3OzXk7k71wmbRyGy23q6OjotTeirfHPzs5GSUkJqqur9d5Ifn4+Gy/RENHmZW7Wy9F+9/v9vL5gEDBc+sDn8+HEiRNRQeJ2uwF0HRNfVFSEkSNHYtasWfopv2lpaSbXmoi6+65eTmTg3Oxgz6SkJC6g6QMeud8HgUAAdXV1SE1NRXp6OpxOJ9LT05Geng6Hw8EJwwTR0dGBI0eOYOrUqRzKTADdD/bUTiNITk7mz78PGC59oK3F57uVxBYOh+H1euFwODhUksC0ky7o1hguRERkOM4uExGR4SwzzqOqKs6fPx+1Pp1uz8iRI5GZmWl2NfpNVVWcOXMmaiKVbs/o0aORlZVldjX6TZvn4IDKwJl9ArVlwiUUCmH16tUIBoNRSwepf5qbm/H8889j0qRJZlel30KhEN577z0EAgFePDYAV69exQ9/+ENMnTrV7Krclo6ODgDgvMYAhMNhOJ1OU19LLRMuQFdjeuyxx1BeXo7z589DSokxY8awkfWRqqp48803za7GbdMmSp9++mnceeedZlcnZgSDQbS0tMBmsyE3NxevvfZaTL/zF0IgLS1twKd3R34PEu01pK2tzewqWCtcgK6NT4FAAOvXr8fVq1dRVVWFmpoa3sXeB6FQyOwqGMJms/FagFuQUsLn8+Hrr7/G8ePHcerUKVy5cgVVVVV44YUX4uZ5IoToV0BonxsMBhEIBBAKhaCqqr4bPzk5GcnJyRBCxM33qDdWeWNhuXCRUmL//v345ptvIKXE3r17UV9fjwcffBDV1dVISUmJ64ZB1BspJaSUaG5uxueff47PPvsMTU1NUW8ozp49G1fzVVJKqKoKj8eD1NTUmx5CGRkqXq9XP7MvknZLpqIoSEtL04eL+FoyeCwXLsFgEF999VVU2Y0bN7B69WocOXIES5cuxR133MFjVCghaHusvv76a+zatQtHjx7V5yS6a2lpwdWrV4e4hoMnGAyis7NT37yYkZEBRVGiAkH7/ni9Xvj9/u/8O1VVRUdHBwKBANLT03v8fWQcy4VLcnIyXnjhBdTV1WHnzp362KGqqmhoaMCbb76JuXPnYt68eUhLS2PDoLikrZpqaGjAjh07cPLkyV5fPBVFQXZ2NkpLSzF+/HgMHz7chNoaT0oJr9ern9UXCoXQ0dEBp9Opv7FUVRU+nw8+n6/XoSBFUWCz2fTvZaRAIKAHFq9YHhyWCxcASE9PxwMPPIBJkyZh69atOHz4sN7V9Xg82LJlC06fPo3vfe97GDNmDHsxFDciQ+Wjjz7CyZMnex3mcTqdmDBhAqZPn46xY8ciIyMDQgj9xTjWCSGQnp4Ot9sdNezV1tYGu91+yyXLdrsdDocDSUlJemhoN1xql+4BXUNlbrcbGRkZvPdlEFgyXICuxpWXl4dnnnkGU6ZMwcaNG9HU1KR//Pz581i5ciXmz5+PefPmITU1lY2DYlZkqGzbtg319fU9QkUIgYKCAsyePRvV1dXIy8uL68lpu92O9PT0qGFAVVWjAiKSoihwOBz6vGzk98VutyMjIwN+vx+dnZ16KKmqivb2dgbMILBsuADf3rlw9913Y9SoUdixYwf27NmjDw94vV5s3rwZX331FR577DEUFxezF0MxpS89FUVRUFJSgvvvvx/Tpk2D0+lMiBdBIYQ+8R4ZCL19XmpqKlJTU286h6KVpaSkQFEUdHR06He7aPMwHCIzlqXDRSOEQEZGBpYuXYrx48dj/fr1+OabbwB0PTm1uZja2lrMnj1bX25IZFVSSgQCAZw6dQo7duzAl19+2WuojBw5EjU1NaisrEzIE7i1gLHb7fD5fAgGg/ryYu0qZC0w+vK9EUIgKSkJGRkZaG9v1wMmHA7rAcNJfmPERLgA0Lu5FRUV+PGPf4yPPvoIe/bs0bvI7e3tWLduHb766issXboUBQUFbCBkOdpE9bFjx7Bz506cO3euxzwJQyWaNoKRnp4O4Nulx9r3pL/fGyGEPkwWGTDaooGMjIzb+nspWsyEi0YIAafTiaVLl6K8vBwbNmzAlStXAHR1b0+cOIHGxkY88sgjqKys5DgqWYKUEu3t7fj888+xa9cuXLp0SX9R0zBUbi7y+2DE90QLGKfTifb29qhFA52dnbyvxQAxFy5A9FxMSUkJNm/ejM8++0xfbnjjxg289957+PLLL7Fo0SIMGzaMT1IyhZQSbW1tqKurw+7du9Hc3Nxj7sBms2H06NGoqanB5MmTuThliGhDZFrAaPx+v77Zkj+H2xeT4aIRQiA7OxtPPfUUKioqsHHjRrS2tgLoGkM9ePAgzp8/jyVLlmDSpEkcS6UhI6WE2+3Gnj17sGvXLly/fr1HqCQlJaGiogLz58/H+PHjefqECYQQSE5ORlpaGjwej17u9Xphs9n4MxmAmA4X4NvubVVVFUaPHo0NGzbg+PHj+pDDtWvXsGrVKsyYMQMLFy5EVlYWGwsNGiklPB4P6urq8NFHH+HatWs9QiUlJQUTJ07E/PnzMXbsWA7dmkwIAYfDoW/K1HR2dkJRlKj9MtR3MR8uGiEEhg8fjhdeeAEHDhzAli1b4Ha7AXRN1O3duxfnzp3Do48+inHjxvGaWjKUtqT42LFj+OCDD3Dx4sUeoZKWlobKykrMnz8fI0eO5LJXC9FOYo7cRyOl1Cf4+Qag/+ImXIBvu7hz5sxBaWkpNmzYgNOnT+u9mMuXL+O///u/MXfuXNTU1HDClAyhqiqampqwYcMGHD16tMdRI2lpaaiqqsIDDzyAkpKSuN74GMu0xUJut1v/GXIPzO2Lq3DRCCFQVFSEl156CXv27MG2bdvQ2dkJoGuybtu2bTh37hwef/xx/clO1F9SSvj9fuzevRubN2/We8qalJQUTJs2DQsWLGCoxADtZ6NN8GtLxLkH5vbEZbgA326+uv/++zF27FisW7cOZ8+e1Ycqzpw5gxUrVmDJkiWoqqriuxLqFyklGhsb8ec//xn19fVRy4oVRcFdd92FxYsXo6ysjG0rhmgrUbWA4R6Y2xe34aJRFAV33HEHXn75ZezYsQO7du3Sj49xu914//330djYiIcffpjDZPSdtLmVuro6rF27tseNf/n5+Vi8eDGmT5/OkyJi1K32wGgnM2ufRzcX9+ECfDtZt2jRIpSWlmLt2rX6vRehUAi7du3ClStX8NRTT/HGS7opbXnx6tWrsX///qi5laSkJMyePRuLFy/mvqo4ELkHpqOjQw+YQCCAzs5O/bQA/pxvLiHCRaMoCsaPH48RI0Zg3bp1UUuWT58+jbfeegvPPPMMxowZw0ZDUaSUuHDhAt59912cP38+6mMFBQV44oknMGXKFA6BxRFtgVD3k5n9fr9+JQDdXMIdISyEwLBhw/D888/j4Ycf1k9dBYArV67gd7/7XVToUGLThsH27t2L119/PSpYFEVBdXU1fvGLX2DatGlcrhqHtLnbtLS0qHKfzwePx2OZ++qtKKF6LhqtwdTW1qKgoACrV6/Wx87dbjd+//vf49FHH8WMGTO4HyaBaYdMbtiwAR9//HHUMFh6ejqWLl2KuXPncpNdnNM2WWrtQeP1evWP8effU0KGi0ZRFEyZMgU5OTl477339MvIvF4vVq9ejUAggHvvvZcBk4CklLh+/Tp+//vf4/jx41HvUIuLi/Hcc8+hoqKC9wclCG3eVkoZtYvf4/FAURQeE9OLhH9mCCEwatQo/OhHP8LYsWP18kAggA0bNmDXrl1xc3Us9Y2UEmfPnsXy5ctx7NgxPVgURUFVVRV+/vOfY9y4cQyWBJSenh41lA50HRMTCAQ4RNYNnx349uiYF198EXfffbdeHgwG8cEHH+CTTz5hwCSIcDiMAwcO4Le//S0aGxv18uTkZDzyyCN46aWXuBosQWk/8/T0dCQnJ+vl2jExoVCIAROB4fJ/hBDIzMzEc889hylTpujlwWAQGzduRF1dHSf545h2M+TmzZvx9ttvR+1fyczMxPe//30sWbKEx+EnOO2UBafTiaSkJL1cu68nHA4zYP5PQs+5dKctL3z66aehKAoOHz4MoGuIbP369XA4HJg6dSqHQ+KMdpLxn//8Z+zZsyfqTURJSQleeOEFjB07lqFCAKKPiXG73fqohnYOWWZmZtTnJSqGSzfaxN2TTz6JUCiE48ePA+haeviXv/wFTqcTFRUVCd9w4oWUEi6XC6tWrYqauBdCYOLEiXj++eeRm5vLnzdFEUJAURRkZGTA7XZHHRPDmyy78C14L7QezLJlyzBu3Di9vKOjA3/84x/R1NTErm8ckFLi2rVrWLFiRdTEvc1mw/3334+XX36ZwUI3FXkOWWQb8fv98Hq9Cf8awXC5CSEEMjIy8Oyzz2LkyJF6eUtLC/74xz/C7XYnfOOJZVJKNDc3Y+XKlWhoaNDLU1JS8Oijj2LZsmW85pa+k3ZMTPdNlh6PJ+FXkDFcbkEIgZycHDz77LMYPny4Xn7hwgWsW7dOv1SIYou2h+W//uu/onbcp6Wl4bnnnsNDDz3EjZHUZ0IIpKamIjU1Naq8s7MzoSf4GS7fQQiB4uJiPPXUU1HvTg4fPoxdu3ZxBVmM0Vb1vP322zh79qxenpGRgR/84AeYPXs2N83SbUlLS4taQaaqKjo7OxkudHNCCIwbNw6LFy+G3d61BkJVVWzbtg319fUJ23hiUSAQwJ/+9CecOnVKL3M6nXjxxRe5EpBuW+QS5cg2FAwGE3b+hc+kPlIUBbNmzcI999yjl/n9fqxZswYtLS0J2Xhijaqq+Oijj7B//3795+VwOPD8889j8uTJDBYaEG0FWffTkn0+H4LBYMK9RvDZ1A82mw0PP/wwysvL9bJr165h/fr1nH+xOCklTp48ic2bN+tDmXa7HY899hiqqqoYLGQI7Zh+h8Ohl0kp0dnZCVVVEypg+IzqB20PzBNPPIGcnBy9/MSJEz0235F1aHtZ/vSnP+mn2gohMG/ePMydO5fBQobSTkrWhtCBrmOFPB6PibUaenxW9ZMQAkVFRb3Ov1y8eDGh3pnEinA4jI0bN+LSpUt6WUVFBZYuXRr1AkBkFG2vXPf9L4m0PJnhchuEEKisrMTMmTP1ss7OTqxfvz7qvgcyn5QSp06dwr59+/SyzMxMLFu2rMeTn8goQgjY7fYe+18SaXiM4XKbbDYbFi5ciJKSEr3s7Nmz2L17N4fHLES77Mvv9wPoWpixcOFC3HHHHQwWGlTa/pfuy5MTZXiM4XKbtFOUly5dqt/vIKXEzp07OTxmEVJK1NXVRW2ULC8v5zwLDalEHR7jM2wAhBCoqKiIWp7s8XiwceNG/Z0ymaetrQ0fffSR3pNMSUnRj80nGgra+WO9HQ8jpYzrgGG4DJCiKKipqYkaHmtoaIjaS0FDT0qJPXv2oLm5WS+rqqriidY05HobHkuE1WMMlwHSDrh85JFH9NvpVFXF9u3b0dzczIAxicvlwu7du/Xvv9PpRG1tLY92IdN0PwjV7/fH9eZKhosBhBC46667UFVVpZe5XC58+OGHvB7ZBFJK7N+/H9evX9fLqqurUVJSwl4LmUJbPdZ9c6U2PBaPGC4GURQFtbW1yM3N1cuOHj2KU6dOxW3jsaqOjg58+umn+vc9PT0d999/P4OFTKUNj0XurQqFQvD5fHH5GsFwMYgQArm5uXjwwQf1lUjBYBAffvhh3I+tWomUEseOHcPVq1f1sqlTp6KoqIjhQqbTTvmI5PV64/JofoaLgYQQmD59etTZYxcvXkRdXV3cNRyrCgaDUUfxpKSkYO7cuQwWsgTtcrHIFYva8Fi8YbgYLDk5GQsXLtQbj7b35dq1awyYQSalxIULF3Du3Dm9rKKiAqNGjWK4kKU4HI6ovVaBQCDu9r4wXAwmhMCYMWMwffp0vaytrQ3bt2/nzv1Bpm2aDAaDALrmwebMmcPzw8hStKP5433vC8NlECiKggceeADDhg3Tyw4dOoQzZ87ETcOxIpfLhWPHjumPCwoKMH78ePZayHKEEEhJSdG3LwBde1/i6WxChssg0Cb358+fr7+w+f1+fPjhh9y5P0iklDhx4gRcLpdeVlVV1ePiJiIr6b73xefzIRQKxcWbUIbLIBFCoLq6GqNGjdLLzp49i8OHD8dFw7GaUCiEgwcPRt0wWVVVxV4LWZZ2NEy8Tu4zXAaRw+HAQw89pB/7oO3cb2trY8AYSEqJS5cu4ezZs3pZWVkZioqKTKwV0XfTLhaLPDkiGAzC7/fH/GsEw2UQCSFw5513YtKkSXpZc3MzPvnkk5hvOFZz6NAhfchRCIEZM2bwqBeKCb3tffF4PDF/7wvDZZDZbDbU1tbC6XTqZXv37kVTU1NMNxwr8Xq9OHz4sP44JycHEyZM4JAYxQQhBJKTk/WrO4CuUY5Yn9xnuAwyIQQKCwujjuXv7OzEtm3bEAqFTKxZfJBSoqGhIWpH/t13342srCwTa0XUf933vvh8vpg+2JLhMgQURcG9996LgoICvez48eM4ffp0zDYcq5BS4rPPPtMPCLXb7aiurmavhWJKb5P7AGL6YEuGyxDJyspCTU2N/s4kFAph69atMd/1NduNGzdQX1+vPx4xYgTGjBnDcKGYc7ODLWN1cp/hMkSEEKisrIw6d+zrr7+OWj5L/SOlRH19fdTelsrKyqhjzYliSTwdbMlwGULJyclYsGCBPnEnpcTHH3+M69evx1zDsYJQKIQDBw7o37vU1FRMmzaNvRaKWb0dbKmqakzufWG4DCEhBMrKylBZWamXtba2YufOnQyX23D58uWoQypLS0tRWFhoYo2IjBEPB1syXIaYoiioqamJWs108OBBXLhwIaYajtmklDh06JA+Z6WdiMBDKinWfdfBlrGC4TLEhBDIy8uLumPE6/Viy5YtCAQCJtcudng8Hhw6dEh/nJ2djbvvvptDYhQXtIMttdM9gG8PtoyVgGG4mEBRFMyePRvFxcV62ZdffolDhw7FTMMxk5QSX375JS5fvqyXTZw4ETk5OSbWish46enpMXuwJcPFJOnp6Vi4cKE+jKOqKrZt24YbN27ERMMxUzgcxr59+/T7cex2O2bMmMFeC8UVbe9L5OpHKSU6Oztj4jWC4WISIQTGjx+PyZMn62UtLS3Ytm0bLxX7DleuXMGpU6f0x3fccQfKysoYLhR3brb3xefzWT5gGC4mstvteOihh5CZmamXHTx4kDv3b0FVVezbt09fmimEwKxZs6IuXSKKJzfb+2L14TGGi4mEECgoKMADDzygLzsMBALYuHEj2tvbLd1wzOJyuXDw4EH9cU5ODiorK9lrobjV294X7d4XK79GMFxMpk3ul5WV6WWNjY3YunVrn4bH4unO7e8ipcSBAwfQ2tqql02fPh3Z2dnmVYpoiKSlpfW498XKw2MMFwtITU3FkiVLoq7k3bdvH44ePXrLhqOqKj777DM0NTUlxDxNW1sbdu/erX9P0tPTMWfOHPZaKO4JIWLuaBiGiwUIITBq1Kiogy2DwSDWrVuHixcv9tpwpJQ4f/48/vKXv+C3v/0tdu3aBZ/PN9RVHzKqqmL37t1obm7WyyorK1FUVMRwoYSg3fvSfXjMqqvHGC4WoR3LP378eL3M5XLhD3/4A5qbm6Majzbe+te//hVerxft7e3YsGEDjhw5YkbVB52UEo2Njfj444+jei01NTUMFko4vV2LbMXhMYaLhaSkpODxxx/HiBEj9LKmpia8/fbb+Oabb/RrTwOBAP76179G3RlfXFyMiRMnmlHtQaHNJUkp0dHRgffffx9ut1v/+Jw5c1BSUsJwoYSiHQ0TOYQOdA2PWe1iMR7EZCFCCAwfPhzLli3D//zP/+gvpo2NjVixYgVmzJiBESNG4MiRI1H7PFJSUrBkyZKoq5RjXWtrK/bv34/MzEwcOnQIp0+f1j9WWFiI2tpaBgslJG31mMPh0M/W04bHMjMzow68NBPDxWK0k5OfeeYZ/OEPf0B7ezsAoL29Hdu3b+/x+TabDbW1taioqIirSf3GxkasXbu2x/8pNTUVTz75JHJychgulNAcDgeCwaB+XXo4HIbH4+nRqzGLNSKOogghMGHCBLz44otRQ2Td2e12zJ8/H/Pnz7fMuxWj3Lhxo0ewJCUl4dFHH8WkSZMYLJTQtNVj3c8e8/v9ljkAlz0XixJCoLy8HD/5yU+wY8cOHDlyBO3t7VBVFTabDSNGjEBNTQ2mTp0aNbkXL9xuN2w2G1RV1U+SXrp0Kaqrq+MuSIluhxACdrsdaWlp6OzsBND1Bswq105YoxbUKyEEsrOz8dhjj6GmpgZXrlyB1+tFVlYWCgsLkZqaGrfv4OfOnYvx48fD7XYjJSUFI0eOREZGRtz+f4luh3b2WCgUgqIocDgclnmOWCpctL0bfr/f7KpYls1mQ0dHBxoaGnp8LFavQ40kpcSZM2f0NiCEQCAQiFoZRzcXDof1d7GxSkpp+XOzrEY7Wy8YDAKAJb53lgkXIQQKCwtx8uRJnDx50uzqxKzU1NQeu3hjhaIoKC4uxvHjx3H8+HGzqxOzUlNTLTOpezvsdrtl5g1ilbZk2dQ6SCtEHLqSVtvHQQOjKIrpDet2SCkRDofNrkZciOU2QMYxc4jMMuFCRETxI/be2hARkeUxXIiIyHAMFyIiMhzDhYiIDMdw6aNwOIz29nauZkpg4XAYHR0dbAMJjHtw+o7h0kdNTU34x3/8RzQ1NZldFTJJY2MjfvrTn6KxsdHsqpBJwuEwXC4X32D0AcOFiIgMx3AhIiLDMVyIiMhwDBciIjIcw4WIiAzHcCEiIsMxXIiIyHAMFyIiMhzDhYiIDMdwISIiwzFciIjIcAwXIiIyHMOFiIgMx3AhIiLDMVz6QEqJ1tZWuN1utLa28i6HBKS1gY6ODraBBCWlREtLCy5evIiWlha2ge/AcLkFl8uF5cuXo7y8HFOmTMG7776LKVOmoLy8HMuXL4fL5TK7ijTIIttAZWUl1qxZg8rKSraBBBLZBgoLCzFt2jQUFhayDXwHIRm/vdq6dSsef/xxeDweAIh6lyKEAACkpaVhzZo1WLBggSl1pMHFNkBsA7eP4dKLrVu3YtGiRZBSQlXVm36eoigQQmDTpk1sWHGGbYDYBgaG4dKNy+VCSUkJvF7vLRuURlEUOBwONDY2Ijs7e/ArSIOObYDYBgaOcy7drFq1Ch6Pp08NCgBUVYXH48E777wzyDWjocI2QGwDA8eeSwQpJcrLy3Hu3Ll+rQQRQqC0tBQNDQ36OCzFJrYBYhswBsMlQktLC/Ly8gb09bm5uQbWiIYa2wCxDRiDw2IROjo6BvT17e3tBtWEzMI2QGwDxmC4RHA6nQP6+oyMDINqQmZhGyC2AWMwXCLk5uairKys3+OlQgiUlZVh2LBhg1QzGipsA8Q2YAyGSwQhBF555ZXb+tpXX32Vk3hxgG2A2AaMwQn9bri+ndgGiG1g4Nhz6SY7Oxtr1qyBEAKKcutvj7Yzd+3atWxQcYRtgNgGBo7h0osFCxZg06ZNcDgcEEL06OZqZQ6HA5s3b0Ztba1JNaXBwjZAbAMDw3C5iQULFqCxsRGvv/46SktLoz5WWlqK119/HZcuXWKDimNsA8Q2cPs459IH2l0e7e3tyMjIwLBhwzhpl2DYBohtoH8YLkREZDgOixERkeEYLkREZDiGCxERGY7hQkREhmO4EBGR4RguRERkOIYLEREZjuFCRESGY7gQEZHhGC5ERGQ4hgsRERmO4UJERIZjuBARkeEYLkREZLj/DzvTktDpVzv1AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct3['train_input'].to(\"cpu\"))\n", @@ -469,32 +437,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 1.39e+01 | test loss: 1.39e+01 | reg: 4.39e+02 : 100%|██| 16/16 [00:55<00:00, 3.44s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.8182587772607803\n", - "R^2 of total dataset: -1.3164293766021729\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "datasetoct4 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [-5, 0], [-5, 0]])\n", "model.train(datasetoct4, opt=\"LBFGS\", steps=int(80/5));\n", @@ -511,27 +456,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "stack expects a non-empty TensorList", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[18], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m model \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mprune(threshold\u001b[38;5;241m=\u001b[39mpruning_threshold)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdatasetoct4\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtrain_input\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcpu\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m model\u001b[38;5;241m.\u001b[39mplot()\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/kan/KAN.py:314\u001b[0m, in \u001b[0;36mKAN.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 311\u001b[0m x_numerical, preacts, postacts_numerical, postspline \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mact_fun[l](x)\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msymbolic_enabled \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m--> 314\u001b[0m x_symbolic, postacts_symbolic \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msymbolic_fun\u001b[49m\u001b[43m[\u001b[49m\u001b[43ml\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 315\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 316\u001b[0m x_symbolic \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.\u001b[39m\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1511\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1509\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1510\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1511\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/torch/nn/modules/module.py:1520\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1515\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1518\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1520\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1523\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/code/pykan-env/lib/python3.10/site-packages/kan/Symbolic_KANLayer.py:111\u001b[0m, in \u001b[0;36mSymbolic_KANLayer.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 109\u001b[0m xij \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m2\u001b[39m]\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfuns[j][i](\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m*\u001b[39mx[:,[i]]\u001b[38;5;241m+\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m1\u001b[39m])\u001b[38;5;241m+\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maffine[j,i,\u001b[38;5;241m3\u001b[39m]\n\u001b[1;32m 110\u001b[0m postacts_\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmask[j][i]\u001b[38;5;241m*\u001b[39mxij)\n\u001b[0;32m--> 111\u001b[0m postacts\u001b[38;5;241m.\u001b[39mappend(\u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstack\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpostacts_\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 113\u001b[0m postacts \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mstack(postacts)\n\u001b[1;32m 114\u001b[0m postacts \u001b[38;5;241m=\u001b[39m postacts\u001b[38;5;241m.\u001b[39mpermute(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m3\u001b[39m)[:,:,:,\u001b[38;5;241m0\u001b[39m]\n", - "\u001b[0;31mRuntimeError\u001b[0m: stack expects a non-empty TensorList" - ] - } - ], + "outputs": [], "source": [ "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct4['train_input'].to(\"cpu\"))\n", @@ -624,7 +551,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.10.12" } }, "nbformat": 4, From dcf5626659c9db496fe13dbf74246dfec09b124a Mon Sep 17 00:00:00 2001 From: arjay55 Date: Thu, 27 Jun 2024 23:08:24 +0800 Subject: [PATCH 6/7] prior to running for CL test --- .gitignore | 2 + kan/utils.py | 11 +- tutorials/continual_learning_structural.ipynb | 344 +++++++----------- 3 files changed, 135 insertions(+), 222 deletions(-) diff --git a/.gitignore b/.gitignore index 30f07ef55..1b8696437 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,5 @@ docs/_templates folder test tutorials/figures/ +tutorials/model_ckpt/model_oct0.ckpt +tutorials/continual_learning_structural.py diff --git a/kan/utils.py b/kan/utils.py index 644c8d5ad..1ec1d2791 100644 --- a/kan/utils.py +++ b/kan/utils.py @@ -2,6 +2,7 @@ import torch from sklearn.linear_model import LinearRegression import sympy +import pdb # sigmoid = sympy.Function('sigmoid') # name: (torch implementation, sympy implementation) @@ -102,19 +103,21 @@ def create_dataset(f, # generate warning that if step_size is provided, test_num is only the required argument if test_num is not None: print('Warning: if step_size is provided, test_num is only the required argument. train_num equals to all possible combinations minus test_num.') - def generate_grid(dimensions, range_start, range_end, step_size): + def generate_grid(dimensions, ranges, step_size): # Generate an array of values for each dimension - ranges = [np.arange(range_start, range_end, step_size) for _ in range(dimensions)] + axisvalues = [] + for _ in range(dimensions): + axisvalues.append(np.arange(ranges[_][0], ranges[_][1], step_size)) # Create the grid using numpy's meshgrid function - grid = np.meshgrid(*ranges, indexing='ij') + grid = np.meshgrid(*axisvalues, indexing='ij') # Reshape the grid to list all possible combinations of coordinates grid = np.stack(grid, axis=-1).reshape(-1, dimensions) return grid - all_data = torch.from_numpy(generate_grid(n_var, ranges[:,0], ranges[:,1], step_size)).float() + all_data = torch.from_numpy(generate_grid(n_var, ranges, step_size)).float() train_input = all_data[np.random.choice(all_data.shape[0], all_data.shape[0]-test_num, replace=False)] test_input = all_data[np.random.choice(all_data.shape[0], test_num, replace=False)] diff --git a/tutorials/continual_learning_structural.ipynb b/tutorials/continual_learning_structural.ipynb index 34d34b9cd..a56a71cba 100644 --- a/tutorials/continual_learning_structural.ipynb +++ b/tutorials/continual_learning_structural.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -19,26 +19,14 @@ "import matplotlib.pyplot as plt\n", "import pdb\n", "\n", - "from copy import deepcopy\n" + "from copy import deepcopy" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "create_dataset() got an unexpected keyword argument 'step_size'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 14\u001b[0m\n\u001b[1;32m 11\u001b[0m seednum \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# datasetall = create_dataset(f, n_var=3, test_num=test_num, seed=seednum, step_size=0.1, ranges=[[-5, 5], [-5, 5], [-5, 5]])\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m datasetoct0 \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_dataset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_var\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtest_num\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtest_num_sub\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mseed\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mseednum\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mranges\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mTypeError\u001b[0m: create_dataset() got an unexpected keyword argument 'step_size'" - ] - } - ], + "outputs": [], "source": [ "# %%\n", "import math\n", @@ -48,89 +36,86 @@ "# sin(x) * cos(y) + exp(z/2) - x^2 * y\n", "f = lambda x: torch.sin(x[:, [0]]) * torch.cos(x[:, [1]]) + torch.exp(x[:, [2]]/2) - x[:, [0]]**2 * x[:, [1]]\n", "\n", - "test_num = int((10/0.1)*0.5)\n", - "test_num_sub = int((10/0.1)*0.5/8)\n", + "test_num = int(((10/0.1)**3)*0.2)\n", + "test_num_sub = test_num // 8\n", "seednum = 1\n", "\n", - "datasetall = create_dataset(f, n_var=3, test_num=test_num, seed=seednum, step_size=0.1, ranges=[[-5, 5], [-5, 5], [-5, 5]])\n", - "datasetoct0 = create_dataset(f, n_var=3, test_num=test_num_sub, seed=seednum, step_size=0.1, ranges=[[-5, 0], [-5, 0], [-5, 0]])\n" + "datasetall = create_dataset(f, n_var=3, test_num=test_num, seed=seednum, step_size=0.1, ranges=[[-5,5], [-5,5], [-5,5]], device=\"cpu\")\n", + "datasetoct0 = create_dataset(f, n_var=3, test_num=test_num_sub, seed=seednum, step_size=0.1, ranges=[[-5,0],[-5,0],[-5,0]], device=\"cpu\")\n", + "# we really do need 3 ranges\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " ## build KAN architecture" + " ## build KAN architecture" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " Training KAN" + " Training KAN" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.97e-05 | test loss: 3.50e+01 | reg: 3.60e+01 : 100%|██| 80/80 [00:11<00:00, 7.08it/s]\n" - ] - } - ], + "outputs": [], "source": [ "# %%\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=[3,5,1], grid=5, k=3, sp_trainable=False, sb_trainable=False, noise_scale=0.1, device=\"cpu\")\n", + "model = KAN(width=[3,3,3,1], grid=100, k=3, sp_trainable=False, sb_trainable=False, noise_scale=0.1, device=\"cpu\")\n", + "\n", "# make a 3D tensor with 5 points in each dimension\n", "x = torch.linspace(-5, 5, steps=11).repeat(3, 1).T\n", "\n", - "model.update_grid_from_samples(x)\n", - "# model = KAN(width=[3,5,1], grid=5, k=3, noise_scale=0.1, device=\"cpu\")\n", - "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=0.02);\n", - "model.train(datasetoct0, opt=\"LBFGS\", steps=80);" + "model.update_grid_from_samples(x.to(\"cpu\"))\n", + "# model.train(datasetoct0, opt=\"LBFGS\", update_grid=False, steps=200, device=\"cuda\", lr=0.5);\n", + "model.train(datasetoct0, opt=\"LBFGS\", update_grid=False, steps=80, device=\"cpu\");\n", + "# model.train(datasetoct0, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=1e-6);\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.save_ckpt(\"model_oct0.ckpt\")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()" + "# %%\n", + "f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()" + "# %%\n", + "f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9999914228965281\n", - "R^2 of total dataset: 0.20941400527954102\n" - ] - } - ], + "outputs": [], "source": [ + "# %%\n", "# compute R^2 between prediction and true value\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", "print(f\"R^2: {r2}\")\n", @@ -138,115 +123,73 @@ "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" + "print(f\"R^2 of total dataset: {r2}\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "continue pruning until R^2 is close to 0.95" + " continue pruning until R^2 is close to 0.95" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2 of datasetoct0: 0.9999914228965281\n", - "R^2 of datasetoct0: 0.9999914228965281\n", - "R^2 of datasetoct0: 0.9999914228965281\n", - "R^2 of datasetoct0: 0.9999914228965281\n", - "R^2 of datasetoct0: 0.9999914228965281\n", - "R^2 of datasetoct0: 0.9387973248958588\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "for x in range (1,100):\n", - " threshold_value = 0.01 * x\n", - " model = model.prune(threshold=threshold_value)\n", - " model(datasetoct0['train_input'].to(\"cpu\"))\n", - " f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", - " f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", - " r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - " print(f\"R^2 of datasetoct0: {r2}\")\n", - " if r2 < 0.96:\n", - " break\n", + "# %%\n", + "# for x in range (1,100):\n", + "# threshold_value = 0.01 * x\n", + "# model = model.prune(threshold=threshold_value)\n", + "# model(datasetoct0['train_input'].to(\"cpu\"))\n", + "# f_pred = model(datasetoct0['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "# f_true = datasetoct0['test_label'].to('cpu').detach().numpy()\n", + "# r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "# print(f\"R^2 of datasetoct0: {r2}\")\n", + "# if r2 < 0.96:\n", + "# break\n", "\n", - "model.plot()" + "# model.plot()\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "datasetoct1 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=seednum, ranges=[[-5, 0], [-5, 0], [0, 5]])" + "# %%\n", + "datasetoct1 = create_dataset(f, n_var=3, test_num=test_num_sub, step_size=0.1, seed=seednum, ranges=[[-5, 0], [-5, 0], [0, 5]])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### freeze/slow down/regularize/stop early network and determine nodes that is the opposite of pruning" + " ### freeze/slow down/regularize/stop early network and determine nodes that is the opposite of pruning" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# model.train(datasetoct1, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=lr_half);" + "# %%\n", + "# model.train(datasetoct1, opt = 'Adam', steps=5000, update_grid=False, device=\"cuda\", lr=lr_half);\n" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 2.04e-01 | test loss: 2.02e-01 | reg: 2.24e+01 : 100%|██| 40/40 [01:12<00:00, 1.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9999669947537768\n", - "R^2 of datasetoct0: 0.9853335656225681\n", - "R^2 of total dataset: 0.37371963262557983\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ - "model.train(datasetoct1, opt=\"LBFGS\", steps=int(80/2));\n", + "# %%\n", + "# model.train(datasetoct1, opt=\"Adam\", steps=int(80/2));\n", + "model.train(datasetoct1, opt=\"LBFGS\", update_grid=False, steps=80, device=\"cpu\");\n", "f_pred = model(datasetoct1['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct1['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", @@ -260,111 +203,57 @@ "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" + "print(f\"R^2 of total dataset: {r2}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.save_ckpt(\"model_oct1.ckpt\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Also total dataset has bad r^2. Lack of data? \n", - "Less catastrophic forgetting PROVIDED that the network is well pruned. Occam's Razor?" + " Also total dataset has bad r^2. Lack of data?\n", + "\n", + " Less catastrophic forgetting PROVIDED that the network is well pruned. Occam's Razor?" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.9999669947537768\n", - "R^2 of datasetoct1: 0.8431994915008545\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "for x in range (1,100):\n", - " threshold_value = 0.01 * x\n", - " model = model.prune(threshold=threshold_value)\n", - " model(datasetoct1['train_input'].to(\"cpu\"))\n", - " f_pred = model(datasetoct1['test_input'].to('cpu')).to('cpu').detach().numpy()\n", - " f_true = datasetoct1['test_label'].to('cpu').detach().numpy()\n", - " r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - " print(f\"R^2 of datasetoct1: {r2}\")\n", - " if r2 < 0.96:\n", - " break\n", + "# %%\n", + "# for x in range (1,100):\n", + "# threshold_value = 0.01 * x\n", + "# model = model.prune(threshold=threshold_value)\n", + "# model(datasetoct1['train_input'].to(\"cpu\"))\n", + "# f_pred = model(datasetoct1['test_input'].to('cpu')).to('cpu').detach().numpy()\n", + "# f_true = datasetoct1['test_label'].to('cpu').detach().numpy()\n", + "# r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", + "# print(f\"R^2 of datasetoct1: {r2}\")\n", + "# if r2 < 0.96:\n", + "# break\n", "\n", - "model.plot()" + "# model.plot()\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "train loss: 5.57e-01 | test loss: 5.41e-01 | reg: 3.12e+01 : 100%|██| 26/26 [00:34<00:00, 1.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R^2: 0.9996949064661749\n", - "R^2 of datasetoct1: -0.6903258562088013\n", - "R^2 of datasetoct0: -1.0515315532684326\n", - "R^2 of total dataset: 0.03302896022796631\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ - "datasetoct2 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [0, 5], [-5, 0]])\n", - "model.train(datasetoct2, opt=\"LBFGS\", steps=int(80/3));\n", + "# %%\n", + "datasetoct2 = create_dataset(f, n_var=3, test_num=test_num_sub, step_size=0.1, seed=0, ranges=[[-5, 0], [0, 5], [-5, 0]])\n", + "model.train(datasetoct2, opt=\"LBFGS\", steps=80);\n", "# model = model_bk\n", "f_pred = model(datasetoct2['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetoct2['test_label'].to('cpu').detach().numpy()\n", @@ -384,14 +273,23 @@ "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" + "print(f\"R^2 of total dataset: {r2}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.save_ckpt(\"model_oct2.ckpt\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "A single iteration of LBFGS causes immediate catastrophic forgetting. Also, repeated dataset creation greatly varies r^2. Dataset quality is the problem." + " A single iteration of LBFGS causes immediate catastrophic forgetting. Also, repeated dataset creation greatly varies r^2. Dataset quality is the problem." ] }, { @@ -400,9 +298,10 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct2['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n" ] }, { @@ -411,6 +310,7 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "datasetoct3 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[-5, 0], [0, 5], [0, 5]])\n", "model.train(datasetoct3, opt=\"LBFGS\", steps=int(80/4));\n", "f_pred = model(datasetoct3['test_input'].to('cpu')).to('cpu').detach().numpy()\n", @@ -421,7 +321,7 @@ "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" + "print(f\"R^2 of total dataset: {r2}\")\n" ] }, { @@ -430,9 +330,10 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct3['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n" ] }, { @@ -441,6 +342,7 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "datasetoct4 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [-5, 0], [-5, 0]])\n", "model.train(datasetoct4, opt=\"LBFGS\", steps=int(80/5));\n", "f_pred = model(datasetoct4['test_input'].to('cpu')).to('cpu').detach().numpy()\n", @@ -451,7 +353,7 @@ "f_pred = model(datasetall['test_input'].to('cpu')).to('cpu').detach().numpy()\n", "f_true = datasetall['test_label'].to('cpu').detach().numpy()\n", "r2 = 1 - np.sum((f_pred - f_true)**2)/np.sum(f_true**2)\n", - "print(f\"R^2 of total dataset: {r2}\")" + "print(f\"R^2 of total dataset: {r2}\")\n" ] }, { @@ -460,9 +362,10 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct4['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n" ] }, { @@ -471,6 +374,7 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "datasetoct5 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [-5, 0], [0, 5]])\n", "model.train(datasetoct5, opt=\"LBFGS\", steps=int(80/6));\n", "f_pred = model(datasetoct5['test_input'].to('cpu')).to('cpu').detach().numpy()\n", @@ -485,7 +389,7 @@ "\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct5['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n" ] }, { @@ -494,6 +398,7 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "datasetoct6 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [0, 5], [-5, 0]])\n", "model.train(datasetoct6, opt=\"LBFGS\", steps=int(80/7));\n", "f_pred = model(datasetoct6['test_input'].to('cpu')).to('cpu').detach().numpy()\n", @@ -508,7 +413,7 @@ "\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct6['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n" ] }, { @@ -517,6 +422,7 @@ "metadata": {}, "outputs": [], "source": [ + "# %%\n", "datasetoct7 = create_dataset(f, n_var=3, train_num=trainpoints_subtask, test_num=testpoints_subtask, seed=0, ranges=[[0, 5], [0, 5], [0, 5]])\n", "model.train(datasetoct7, opt=\"LBFGS\", steps=int(80/8));\n", "f_pred = model(datasetoct7['test_input'].to('cpu')).to('cpu').detach().numpy()\n", @@ -531,7 +437,9 @@ "\n", "model = model.prune(threshold=pruning_threshold)\n", "model(datasetoct7['train_input'].to(\"cpu\"))\n", - "model.plot()" + "model.plot()\n", + "\n", + "\n" ] } ], From 2cece15706478822ed0bb7378a46c5fd5d85668e Mon Sep 17 00:00:00 2001 From: arjay55 Date: Fri, 28 Jun 2024 11:02:28 +0800 Subject: [PATCH 7/7] for PR --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 1b8696437..c3f9b1934 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,7 @@ test tutorials/figures/ tutorials/model_ckpt/model_oct0.ckpt tutorials/continual_learning_structural.py +tutorials/model_ckpt/model_oct1.ckpt +tutorials/model_ckpt/model_oct2.ckpt +tutorials/continual_learning_step_by_stop.ipynb +tutorials/continual_learning_structural.ipynb