diff --git a/Experiment_MultiTaskForestClassifier.ipynb b/Experiment_MultiTaskForestClassifier.ipynb new file mode 100644 index 0000000..8ba6b25 --- /dev/null +++ b/Experiment_MultiTaskForestClassifier.ipynb @@ -0,0 +1,924 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "##PACKAGE IMPORT SECTION" + ], + "metadata": { + "id": "7D7gjnvafFQG" + } + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 73 + }, + "id": "kioojXl1ampB", + "outputId": "d1020004-0976-4b0f-9fd2-9e456478b5e4" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving multi_task_forest1.py to multi_task_forest1 (2).py\n" + ] + } + ], + "source": [ + "from google.colab import files\n", + "uploaded = files.upload()" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install git+https://github.com/neurodata/treeple.git" + ], + "metadata": { + "collapsed": true, + "id": "Nr-GfxD_csnG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip install proglearn" + ], + "metadata": { + "collapsed": true, + "id": "JxRKAMqGeXgG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from multi_task_forest1 import MultiTaskForestClassifier\n", + "from proglearn.sims import generate_gaussian_parity\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "import numpy as np\n", + "from tensorflow.keras.datasets import cifar10\n", + "from skimage.transform import rotate\n", + "from proglearn.sims import generate_spirals" + ], + "metadata": { + "id": "Cy3d5mLQa5aW" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#Testing\n" + ], + "metadata": { + "id": "cBG9L0PSfPXh" + } + }, + { + "cell_type": "markdown", + "source": [ + "##XOR/RXOR" + ], + "metadata": { + "id": "TBjTZahMSx8K" + } + }, + { + "cell_type": "code", + "source": [ + "X_xor, y_xor = generate_gaussian_parity(1000)\n", + "X_rxor, y_rxor = generate_gaussian_parity(1000, angle_params=np.pi / 4)\n", + "X_train_xor, X_test_xor, y_train_xor, y_test_xor = train_test_split(X_xor, y_xor, test_size=0.2, random_state=42)\n", + "X_train_rxor, X_test_rxor, y_train_rxor, y_test_rxor = train_test_split(X_rxor, y_rxor, test_size=0.2, random_state=42)\n", + "" + ], + "metadata": { + "id": "5bdOU2Frb_yY" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###Train on same task and test on the same task (like a base line)" + ], + "metadata": { + "id": "HGqXnXAtfXAy" + } + }, + { + "cell_type": "code", + "source": [ + "clf = MultiTaskForestClassifier(clf_type=\"SPORF\")\n", + "clf.add_task(0, X_train_xor, y_train_xor)\n", + "clf.add_task(1, X_train_rxor, y_train_rxor)\n", + "clf.fit([0, 1])\n", + "acc_xor = clf.score(X_test_xor, y_test_xor, task_id=0)\n", + "acc_rxor = clf.score(X_test_rxor, y_test_rxor, task_id=1)\n", + "\n", + "print(f\"XOR Accuracy: {acc_xor:.3f}\")\n", + "print(f\"RXOR Accuracy: {acc_rxor:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "up6zK1ibe3mu", + "outputId": "fbe6154b-55b6-463a-c2e9-c2f4b73e27f2" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "XOR Accuracy: 0.965\n", + "RXOR Accuracy: 0.950\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Forward training, backward training, reverse training" + ], + "metadata": { + "id": "5yHIoUtIfc0b" + } + }, + { + "cell_type": "code", + "source": [ + "results = clf.evaluate_transfer_general(\n", + " forward_train_ids=[0],\n", + " forward_test_id=1,\n", + " backward_train_ids=[0, 1],\n", + " backward_test_ids=[0, 1],\n", + " do_reverse=True\n", + ")\n", + "\n", + "print(\"Transfer Learning Results:\")\n", + "fwd = results[\"forward_transfer\"]\n", + "print(f\"\\n Forward Transfer:\\n Train on: {fwd['train_on']}\\n Test on: {fwd['test_on']}\\n Accuracy: {fwd['accuracy']:.3f}\")\n", + "\n", + "print(\"\\n Backward Transfer:\")\n", + "for task, stats in results[\"backward_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")\n", + "\n", + "if \"reverse_transfer\" in results:\n", + " print(\"\\n Reverse Transfer:\")\n", + " for task, stats in results[\"reverse_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zwgrhdgYe-yb", + "outputId": "1f62adb9-739a-4703-b560-6aeef180dbc5" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Transfer Learning Results:\n", + "\n", + " Forward Transfer:\n", + " Train on: [0]\n", + " Test on: 1\n", + " Accuracy: 0.535\n", + "\n", + " Backward Transfer:\n", + " task0:\n", + " Train on: [0, 1]\n", + " Test on : 0\n", + " Accuracy: 0.994\n", + " task1:\n", + " Train on: [0, 1]\n", + " Test on : 1\n", + " Accuracy: 0.991\n", + "\n", + " Reverse Transfer:\n", + " task0:\n", + " Train on: [1]\n", + " Test on : 0\n", + " Accuracy: 0.460\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## CIFAR 10 (Rotation)\n" + ], + "metadata": { + "id": "j-0FEJVNnZqI" + } + }, + { + "cell_type": "code", + "source": [ + "(X_train, y_train), (X_test, y_test) = cifar10.load_data()\n", + "X = np.concatenate([X_train, X_test])\n", + "y = np.concatenate([y_train, y_test]).flatten()" + ], + "metadata": { + "id": "HE-9-jQhfgd6" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "class0_idx = y == 0\n", + "X_class0 = X[class0_idx]\n", + "y_class0 = y[class0_idx]\n", + "\n", + "X0 = X_class0[:1000]\n", + "y0 = np.zeros(len(X0))\n", + "\n", + "X1 = np.array([rotate(img, angle=90, resize=False) for img in X_class0[1000:2000]])\n", + "y1 = np.ones(len(X1))\n", + "\n", + "X0 = X0.reshape(X0.shape[0], -1) / 255.0\n", + "X1 = X1.reshape(X1.shape[0], -1) / 255.0\n", + "X0_train, X0_test, y0_train, y0_test = train_test_split(X0, y0, test_size=0.2, random_state=42)\n", + "X1_train, X1_test, y1_train, y1_test = train_test_split(X1, y1, test_size=0.2, random_state=42)" + ], + "metadata": { + "id": "dJIbsQeNnvi7" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###Train on same task and test on the same task (like a base line)\n" + ], + "metadata": { + "id": "6ohRTBv43e2k" + } + }, + { + "cell_type": "code", + "source": [ + "clf = MultiTaskForestClassifier(clf_type=\"SPORF\")\n", + "clf.add_task(0, X0_train, y0_train)\n", + "clf.add_task(1, X1_train, y1_train)\n", + "\n", + "clf.fit([0, 1])\n", + "\n", + "acc_task0 = clf.score(X0_test, y0_test, task_id=0)\n", + "acc_task1 = clf.score(X1_test, y1_test, task_id=1)\n", + "\n", + "print(f\"Task 0 (Original Class 0) Accuracy: {acc_task0:.3f}\")\n", + "print(f\"Task 1 (Rotated Class 0) Accuracy: {acc_task1:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Q6l9ENVp3Obi", + "outputId": "17c1e9aa-78ed-465e-b131-cca7435344e4" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Task 0 (Original Class 0) Accuracy: 1.000\n", + "Task 1 (Rotated Class 0) Accuracy: 1.000\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Forward training, backward training, reverse training" + ], + "metadata": { + "id": "sqmRa_CU3kPQ" + } + }, + { + "cell_type": "code", + "source": [ + "results = clf.evaluate_transfer_general(\n", + " forward_train_ids=[0],\n", + " forward_test_id=1,\n", + " backward_train_ids=[0, 1],\n", + " backward_test_ids=[0, 1],\n", + " do_reverse=True\n", + ")\n", + "print(\"Transfer Learning Results:\")\n", + "fwd = results[\"forward_transfer\"]\n", + "print(f\"\\n Forward Transfer:\\n Train on: {fwd['train_on']}\\n Test on: {fwd['test_on']}\\n Accuracy: {fwd['accuracy']:.3f}\")\n", + "\n", + "print(\"\\n Backward Transfer:\")\n", + "for task, stats in results[\"backward_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")\n", + "\n", + "if \"reverse_transfer\" in results:\n", + " print(\"\\n Reverse Transfer:\")\n", + " for task, stats in results[\"reverse_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NZ1Ge8yqn1fO", + "outputId": "33221dcc-4386-4b77-cb7a-2c5c04120599" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Transfer Learning Results:\n", + "\n", + " Forward Transfer:\n", + " Train on: [0]\n", + " Test on: 1\n", + " Accuracy: 0.000\n", + "\n", + " Backward Transfer:\n", + " task0:\n", + " Train on: [0, 1]\n", + " Test on : 0\n", + " Accuracy: 1.000\n", + " task1:\n", + " Train on: [0, 1]\n", + " Test on : 1\n", + " Accuracy: 1.000\n", + "\n", + " Reverse Transfer:\n", + " task0:\n", + " Train on: [1]\n", + " Test on : 0\n", + " Accuracy: 0.000\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##CIFAR 10 (Randomly pick 3 classes as 3 tasks)" + ], + "metadata": { + "id": "EK2vNf5zSnL4" + } + }, + { + "cell_type": "code", + "source": [ + "selected_classes = [0, 3, 7]\n", + "\n", + "task_data = {}\n", + "for task_id, cls in enumerate(selected_classes):\n", + " idx = y == cls\n", + " X_cls = X[idx][:1000] # Use 1000 per class for speed\n", + " y_cls = np.full(len(X_cls), task_id) # Relabel for task (0, 1, 2)\n", + "\n", + " X_cls = X_cls.reshape(X_cls.shape[0], -1) / 255.0\n", + " X_train_task, X_test_task, y_train_task, y_test_task = train_test_split(X_cls, y_cls, test_size=0.2, random_state=42)\n", + "\n", + " task_data[task_id] = (X_train_task, X_test_task, y_train_task, y_test_task)" + ], + "metadata": { + "id": "oNJR5Hzxovf_" + }, + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###Train on same task and test on the same task (like a base line)" + ], + "metadata": { + "id": "fzNB0zjvSkVm" + } + }, + { + "cell_type": "code", + "source": [ + "clf = MultiTaskForestClassifier(clf_type=\"SPORF\")\n", + "\n", + "for task_id in task_data:\n", + " X_train, X_test, y_train, y_test = task_data[task_id]\n", + " clf.add_task(task_id, X_train, y_train)\n", + "\n", + "clf.fit([0, 1, 2])\n", + "\n", + "for task_id in task_data:\n", + " X_test = task_data[task_id][1]\n", + " y_test = task_data[task_id][3]\n", + " acc = clf.score(X_test, y_test, task_id=task_id)\n", + " print(f\"Task {task_id} (Class {task_id}) Baseline Accuracy: {acc:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "I2j0aEf3o5CY", + "outputId": "e7926632-4a8c-4863-dd9f-1e3c2f64c9fe" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Task 0 (Class 0) Baseline Accuracy: 1.000\n", + "Task 1 (Class 1) Baseline Accuracy: 1.000\n", + "Task 2 (Class 2) Baseline Accuracy: 1.000\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Forward training, backward training, reverse training" + ], + "metadata": { + "id": "36JZEENjShq2" + } + }, + { + "cell_type": "code", + "source": [ + "results = clf.evaluate_transfer_general(\n", + " forward_train_ids=[0, 1, 2], # Train on all 3\n", + " forward_test_id=0,\n", + " backward_train_ids=[0, 1, 2],\n", + " backward_test_ids=[0, 1, 2], # But test on each task individually\n", + " do_reverse=True\n", + ")\n", + "print(\"Transfer Learning Results:\")\n", + "fwd = results[\"forward_transfer\"]\n", + "print(f\"\\n Forward Transfer:\\n Train on: {fwd['train_on']}\\n Test on: {fwd['test_on']}\\n Accuracy: {fwd['accuracy']:.3f}\")\n", + "\n", + "print(\"\\n Backward Transfer:\")\n", + "for task, stats in results[\"backward_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")\n", + "\n", + "if \"reverse_transfer\" in results:\n", + " print(\"\\n Reverse Transfer:\")\n", + " for task, stats in results[\"reverse_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DayRSEPt7p5y", + "outputId": "4c696d1d-1764-4b69-f562-622aac19f210" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Transfer Learning Results:\n", + "\n", + " Forward Transfer:\n", + " Train on: [0, 1, 2]\n", + " Test on: 0\n", + " Accuracy: 1.000\n", + "\n", + " Backward Transfer:\n", + " task0:\n", + " Train on: [0, 1, 2]\n", + " Test on : 0\n", + " Accuracy: 1.000\n", + " task1:\n", + " Train on: [0, 1, 2]\n", + " Test on : 1\n", + " Accuracy: 1.000\n", + " task2:\n", + " Train on: [0, 1, 2]\n", + " Test on : 2\n", + " Accuracy: 1.000\n", + "\n", + " Reverse Transfer:\n", + " task0:\n", + " Train on: [0]\n", + " Test on : 0\n", + " Accuracy: 1.000\n", + " task1:\n", + " Train on: [0]\n", + " Test on : 1\n", + " Accuracy: 0.000\n", + " task2:\n", + " Train on: [0]\n", + " Test on : 2\n", + " Accuracy: 0.000\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##Sprial 3 & Spiral 5" + ], + "metadata": { + "id": "7QTqhk2CXmgq" + } + }, + { + "cell_type": "code", + "source": [ + "n_samples = 750\n", + "X3, y3 = generate_spirals(n_samples, 3, noise=0.8)\n", + "X5, y5 = generate_spirals(n_samples, 5, noise=0.4)\n", + "X3_train, X3_test, y3_train, y3_test = train_test_split(X3, y3, test_size=0.2, random_state=42)\n", + "X5_train, X5_test, y5_train, y5_test = train_test_split(X5, y5, test_size=0.2, random_state=42)\n", + "\n", + "task_data = {\n", + " 0: (X3_train, X3_test, y3_train, y3_test), # Spiral 3\n", + " 1: (X5_train, X5_test, y5_train, y5_test) # Spiral 5\n", + "}" + ], + "metadata": { + "id": "uG7K8mAMUkJ4" + }, + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###Train on same task and test on the same task (like a base line)" + ], + "metadata": { + "id": "PvCqeLU3XjRC" + } + }, + { + "cell_type": "code", + "source": [ + "clf = MultiTaskForestClassifier(clf_type=\"SPORF\")\n", + "\n", + "for task_id in task_data:\n", + " X_train, X_test, y_train, y_test = task_data[task_id]\n", + " clf.add_task(task_id, X_train, y_train)\n", + "\n", + "clf.fit([0, 1])\n", + "for task_id in task_data:\n", + " X_test = task_data[task_id][1]\n", + " y_test = task_data[task_id][3]\n", + " acc = clf.score(X_test, y_test, task_id=task_id)\n", + " print(f\"Task {task_id} (Spiral {3 if task_id==0 else 5}) Baseline Accuracy: {acc:.3f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HskMxjLAUuhk", + "outputId": "cee65063-3bd8-4716-f928-596e9edaa793" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Task 0 (Spiral 3) Baseline Accuracy: 0.740\n", + "Task 1 (Spiral 5) Baseline Accuracy: 0.740\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###Forward training, backward training, reverse training" + ], + "metadata": { + "id": "v676uVp0XgQ9" + } + }, + { + "cell_type": "code", + "source": [ + "results = clf.evaluate_transfer_general(\n", + " forward_train_ids=[0],\n", + " forward_test_id=1,\n", + " backward_train_ids=[0, 1],\n", + " backward_test_ids=[0, 1],\n", + " do_reverse=True\n", + ")\n", + "\n", + "fwd = results[\"forward_transfer\"]\n", + "print(f\"\\nForward Transfer:\\n Train on: {fwd['train_on']}\\n Test on: {fwd['test_on']}\\n Accuracy: {fwd['accuracy']:.3f}\")\n", + "\n", + "print(\"\\nBackward Transfer:\")\n", + "for task, stats in results[\"backward_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")\n", + "\n", + "if \"reverse_transfer\" in results:\n", + " print(\"\\nReverse Transfer:\")\n", + " for task, stats in results[\"reverse_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ozb6xBr0UzKB", + "outputId": "5976d514-c7c9-4e5e-d9a4-fe38bd5e47bd" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Forward Transfer:\n", + " Train on: [0]\n", + " Test on: 1\n", + " Accuracy: 0.160\n", + "\n", + "Backward Transfer:\n", + " task0:\n", + " Train on: [0, 1]\n", + " Test on : 0\n", + " Accuracy: 0.960\n", + " task1:\n", + " Train on: [0, 1]\n", + " Test on : 1\n", + " Accuracy: 0.982\n", + "\n", + "Reverse Transfer:\n", + " task0:\n", + " Train on: [1]\n", + " Test on : 0\n", + " Accuracy: 0.218\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/MNIST(Sporf).ipynb b/MNIST(Sporf).ipynb new file mode 100644 index 0000000..8d0892e --- /dev/null +++ b/MNIST(Sporf).ipynb @@ -0,0 +1,720 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "id": "UbX1gA36jSyU" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "from treeple import ObliqueRandomForestClassifier\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import numpy as np\n", + "from sklearn.metrics import accuracy_score\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import treeple" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mq6xlOE441x2" + }, + "outputs": [], + "source": [ + "!pip install proglearn\n", + "!pip install git+https://github.com/neurodata/treeple.git" + ] + }, + { + "cell_type": "markdown", + "source": [ + "#MNIST and Fashion MNIST" + ], + "metadata": { + "id": "Kpq9vuCOEfJd" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dstOzfP567A5", + "outputId": "e6bc09fd-d9bf-4620-e46e-0310d2c441fd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPORF Accuracy on MNIST: 0.9697\n" + ] + } + ], + "source": [ + "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0\n", + "x_train = x_train.reshape(-1, 28*28)\n", + "x_test = x_test.reshape(-1, 28*28)\n", + "\n", + "sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + "sporf.fit(x_train, y_train)\n", + "accuracy = sporf.score(x_test, y_test)\n", + "print(f\"SPORF Accuracy on MNIST: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2qAUUQSA8zUo", + "outputId": "dc1e1426-af4c-45f2-ee2f-3e0f6724e7e5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPORF Accuracy on Fashion-MNIST: 0.8751\n" + ] + } + ], + "source": [ + "(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()\n", + "\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0\n", + "\n", + "x_train = x_train.reshape(-1, 784)\n", + "x_test = x_test.reshape(-1, 784)\n", + "\n", + "sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + "sporf.fit(x_train, y_train)\n", + "\n", + "y_pred = sporf.predict(x_test)\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(f\"SPORF Accuracy on Fashion-MNIST: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4sR-zdXBKRsq" + }, + "outputs": [], + "source": [ + "import time\n", + "import matplotlib.pyplot as plt\n", + "num_trials = 10\n", + "mnist_accuracies = []\n", + "mnist_times = []\n", + "\n", + "for _ in range(num_trials):\n", + " (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n", + " x_train, x_test = x_train / 255.0, x_test / 255.0\n", + " x_train = x_train.reshape(-1, 28*28)\n", + " x_test = x_test.reshape(-1, 28*28)\n", + "\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=50)\n", + " start_time = time.time()\n", + " sporf.fit(x_train, y_train)\n", + " y_pred = sporf.predict(x_test)\n", + " end_time = time.time()\n", + "\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + " mnist_accuracies.append(accuracy)\n", + " mnist_times.append(end_time - start_time)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 456 + }, + "id": "5DRzwUbipK0w", + "outputId": "1c6391c0-4c6a-460a-c656-17093abe9b53" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAGUCAYAAADXrfGFAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjN9JREFUeJzs3XdYk+fXB/BvEvaWDcoSByIqDkDco866N+5VrVa7rbWtq9ba1tZWX1urbd2zUq3FWq171IUDq+JEURRwsVeA5H7/oMnPSICAQBjfz3XlUp55kpBwcuc855YIIQSIiIiIiKooqb4DICIiIiIqS0x4iYiIiKhKY8JLRERERFUaE14iIiIiqtKY8BIRERFRlcaEl4iIiIiqNCa8RERERFSlMeElIiIioiqNCS8RERERVWlMeAkAcOvWLUybNg2+vr4wNzeHiYkJatWqhYCAAEybNg2//fZbvn06dOgAiUSicTMyMoKLiwt69+6NsLCwQs8ZExODmTNnomnTpqhRowaMjY1Rq1Yt9O/fH1u3bkVhkwB6enrmO7dq/759+2L37t0F7jtv3rx8+7548/f31/mxGzt2rM77hYeHa5znxIkTBcbWq1evAo+zceNGSCQSdOjQId861f5HjhzJt04ul2PZsmVo164dbG1tYWhoCHt7ezRo0ABDhgzB0qVL8eTJk3yxFOem7bxFWbJkiXr///u//yv2/lR2Vq9eDYlEgpo1a0KhUBS5/cWLFyGRSGBgYIDY2Ngyi+vIkSMFvgaquwsXLqhfTwMHDtR3OBVWWb3Hqf4mrF27tlTiVP2tLcl7K/2Pgb4DIP3bsWMHhg8fDrlcDjs7O7Ru3RoODg5ITExEREQEvv/+e2zdurXAN84mTZqoE720tDRcvHgRu3fvxu7du/Hmm29i6dKl+fb5/vvv8d5776nP2aZNG1hYWCAqKgq7du3C77//jiVLluD333+Hq6trgbG3bt0aderUAQAkJyfj4sWL+OOPP/DHH3/gnXfewZIlSwrc18nJCd27d9e6zt3dvcD9CnPp0iWcP38ezZs317r+l19+0flYf/75J44dO4Z27dqVKJYXPXr0CF26dMHly5chk8kQGBgINzc3KJVK3Lx5E7/99hu2b98Ob29v9OrVC/7+/hgzZky+4+zduxePHj3SeN6f5+zsXOzYnn9cVq9ejenTpxf7GFQ2hgwZgrfeeguxsbHYt28fevbsWej2q1evBgD06NGj0NculZ3nX09hYWF48uQJHBwc9BhRxVSe73FUAQiq1uLj44WFhYUAIN577z2RmZmZb5tz586JDz/8MN/y9u3bCwBi7ty5GssVCoWYNWuWACAAiIMHD2qs/+677wQAIZVKxRdffCGys7M11l+7dk00b95cABC1a9cWiYmJ+c7t4eEhAIg1a9ZoLM/JyRHTpk1Tn/vs2bP59p07d64AINq3b6/9QSmmMWPGCACiRYsWAoCYOnWq1u0yMjKEtbW1cHFxEbVq1RIAxPHjx7XGZmZmJgCIli1baj3Whg0bCrwPqvt++PBhjeWDBg0SAETDhg1FdHR0vv0ePXokvvvuO62P2fMKet5L6tSpUwKAsLGxEebm5gKAOH/+fKkcm0rHhAkTBAAxcODAQrfLysoStra2AoDYuXNnmcaUnp4url27Ju7du1em56lsMjMzhY2NjQAgatasKQCIb775Rt9hVSov+x4XGxsrrl27JpKSkko1nhff06l4WNJQze3evRtpaWlwdXXF119/DRMTk3zbNG/eHIsWLdL5mFKpFAsWLEDt2rUBAL/++qt6XWRkJGbMmAEA+PbbbzFz5kwYGhpq7O/j44ODBw/C29sbd+7cKdZon4GBARYvXgwrKysAKLKsojS9+uqrcHJywpYtW5CVlZVvfWhoKJKTkzF69GjIZLJCj9W/f3+4ubnh9OnT2Llz50vHlpWVhV27dgHIKx/w8PDIt42joyPeeustBAQEvPT5ikM1GhUSEoLBgwdrLKOKYcKECQDyXk/Pnj0rcLtdu3YhISEBjo6OhZbklAYzMzP4+PiU+NuYquq3335DUlISfH19sXDhQgB8PZU3FxcX+Pj4wNraWt+h0HOY8FZzjx49AoBS/7pLJpOpvwqKjo5WL1+8eDFycnLQuHHjQhNZa2trLF68GACwZcsW3LlzR+dzm5iYoG7dugD+d//Kg4GBAUaNGoXExEStSarqq97x48cXeSwTExN8+umnAICPPvpIp9rJwiQkJCAnJwdAXmJbUaSnp2Pbtm0A8pIqVWK1efNmrR8aVIQQ2LFjB3r16gVnZ2cYGRnB2dkZbdq0wZdffonMzMx8+5w/fx5jxoyBl5cXTExMYGtriyZNmmDGjBm4d++eeru1a9dCIpFg7NixWs8dHR0NiUQCT0/PApcrFAosWbIETZs2hYWFBSQSiXq7yMhIzJ07F61bt0bNmjVhZGQEOzs7vPLKKxofDrV5+PAhZsyYgUaNGsHS0hLm5uaoV68exo4di5MnTwIAoqKiIJPJUKNGDWRkZBR4rIYNG0IikWDPnj2FnhMAgoOD4evri+zsbGzcuLHA7VS/46NHj4aBQV7F3I4dOzBx4kT4+fmhRo0aMDExgZeXF8aPH48bN25oPc7zNZBXrlzB0KFD4eLiAplMhnnz5gEovIb3wIEDmD59Ovz9/WFvb6+u7x86dCjCw8O1nlNVzzlv3jw8efIEb7zxBtzc3GBkZAQ3NzdMnz4dSUlJBd73mzdvYurUqahfvz7MzMxgZWUFX19fTJ06FVeuXMm3fWJiIubOnQt/f39YWlrCzMwMjRo1wmeffVbo81aUn3/+GUDe+8zgwYNhZWWFyMhInD59utD9dH19PP+4Z2RkYM6cOWjQoAHMzMzyvSa2bt2Kzp07w9bWFsbGxvDw8MD48eNx8+ZNrTHExcXhrbfeQr169WBiYgIzMzO4ubmhc+fO+Prrr/Ntf+DAAfTu3RtOTk4wNDREjRo1ULduXYwcORLHjh0r5iOnG1UdLwCsWbMGwcHBsLa2hkQiUf+tK6iGNzU1FT/99BMGDBiAunXrwtzcHObm5mjUqBE+/vjjQn+/tJHL5Vi8eDGaN28OS0tL9ftgQEAAPvjgAyQkJJTCPa5C9D3ETPql+mpcJpOJAwcOFGvfor72eeWVVwQA0adPHyGEEEqlUv115+LFi4s8fk5OjvqruWXLlmmsK6ikQaVu3boCgJg9e3a+dWVV0rBgwQIRGRkpAIhXXnlFY5vbt28LiUQiWrdurRF/QSUNEyZMEAqFQvj5+QkAYtWqVRrbFbekQS6Xq8skxo8fLxQKRYnvb2mWNPzyyy8CgGjcuLF6Wb169QQAsWnTJq37ZGdniwEDBqjLYlq2bClCQkJEly5d1F/h3r17V2Ofr776SkilUgFA1KtXTwwZMkT07t1bNGjQIN/v0Zo1awQAMWbMGK3nv3v3rgAgPDw8tC53d3cXffr0EUZGRqJz584iJCRE4/6pygN8fHxEt27dxNChQ0VwcLA6vnfeeUfreQ8cOKB+PTg6Ooq+ffuKwYMHi4CAAGFoaKgRb+/evbX+3qgcOnRIABDe3t5CqVRq3eZF33zzjQAgmjRponV9TEyM+j5cu3ZNvVwmkwkzMzPRokULMWDAANGnTx9Ru3ZtAUCYm5uLf/75J9+xVK+p1157TRgbGwtPT0/1c/b1118LIYQ4fPhwga8Bb29vYWRkJJo2bSr69OkjBgwYIHx9fQUAYWBgIEJDQ/Pto3rtjR8/XtSqVUs4OTmJAQMGiJ49ewpra2sBQAQEBOQrwRJCiE2bNgljY2P18z9w4EDRv39/0aRJEyGRSPK9Vq5evSrc3NwEAOHi4iK6d+8uevfuLZycnAQA4e/vX6Kvw1XvM4aGhuLRo0dCCCFee+019WNZkOK8PlSPe1BQkAgICBDm5uaiR48eYujQoer3PaVSKUaPHq1+vDt16iSGDRumfm2bmZmJv/76SyOGuLg44erqqn4M+/btK4YOHSratm0rbG1thbW1tcb2a9euFRKJREgkEhEUFCSGDh0q+vTpI5o1ayZkMpl46623iv34qRT2Hqd6f502bZqQSqWiTZs2IiQkRAQFBalLxVS/vy/+fTp+/LgAIBwcHESbNm3E0KFDRdeuXYWdnZ0AIOrUqSOePn1aYDzPv6crFArRuXNnAUBYWVmJHj16iJCQEPHKK6+o/75cvHixxI9BVcSEt5pLTU1VJwkSiUR06NBBLFiwQPz555/i8ePHhe5b2JtCbGyssLS0FADEnDlzhBBCREVFqd8sjh49qlN8HTt2FADE6NGjNZYXlvBGRkYKmUwmAIjw8PB868sy4RVCqJOX52sLP/74YwFArF69WiP+whJeIYT4448/1LV4GRkZ6u1KUsP71ltvqdd5enqK6dOniw0bNoirV6/qnPQIUboJb6tWrQQA8d1336mXLVq0SAAQnTp10rrPu+++q74PERERGuuUSqU4cOCARrKwa9cuAUCYmJiIbdu25Tve1atXRWRkpPrnl014AYhatWqJGzduaN3/yJEjIioqKt/y69evq2u7z5w5o7Hu/v376qTrww8/FHK5XGP9o0ePNH6X9u/fX2hyOnDgwGLXdj5+/FgYGhoWWGP92WefCQCiVatWGsu3bt0q0tLSNJYplUrx/fffq2vKX/z9U72mVPdX2we0whLenTt3ioSEBK3LDQwMhJ2dncbrSYj/vfYAiLFjx4qsrCz1uvv376vfJzdv3qyx37lz54ShoaGQSCRi2bJl+WKNjo4W586dU/+ckZEhvL29BQDxySefaDyX6enpIiQkRAAQ48aNyxd/UT766CMBQPTr10+9TFUjb2lpme95EKL4rw/V4676oBoXF5dvnxUrVggAwt7eXiPpUiqV6sfZxsZG42/M/PnzBQAxadKkfL8P2dnZ+QZkvLy8tL6HCpH3erhw4YKWR0g3uiS8VlZW4tSpU1r3LyjhjYmJEQcOHMj3O5Kenq7+gKDtGhBtCe/Ro0cFANG0aVORkpKSb5/w8HCtyXN1xoSXxPXr10VQUJD6hfz8zd/fX6xYsULk5ubm20/bm0JaWpo4evSoaNasmXoE5/79+0IIIU6fPq0+7vXr13WKbdiwYQKA6NGjh8ZybQlvUlKS2Ldvn/Dx8VH/MdHm+T9sBd1eHCEszIsJ708//SQAiHnz5gkh8j6J16pVS1hYWKj/4Oia8AohRNu2bQUAsWjRIvWykiS82dnZ4u2331YnLc/f7O3txRtvvCEePHhQ5P0trYT32rVrAoAwMjLSeGOOjY0VMplMSCQScefOHY19Hj16JIyMjAQAjSSiMP7+/sVK7koj4V2/fr1O53rRypUrBQAxY8YMjeVvv/22ACB69+6t87EaNmyo9XcsJiZGGBgYCDMzM60XhBZGlSi/8cYb+dbVqVNHABA///yzzscLDg4WAMTVq1c1lqteU/Xq1dP63iNE4QlvYVQJ5Z9//qmxXPXaq1WrlkhPT8+33xdffCGAvBHg5/Xr108AENOnT9fp/KpksFevXlrXp6amCkdHR2FgYKA1aS9Ibm6ueoQ0LCxMY51qdFvbAEFxXx/PJ7zHjh3Tuo0qoX/xmzkh8pLexo0bCwBi4cKF6uVTp04VAMSOHTt0isPMzCzfqG9p0SXh/fTTTwvcv6CEtzDp6enCwMBAODg4FBjP8+/pv/76qwAg3nzzTZ3PUd2xhpdQv359nD59GmfOnMGcOXPQrVs3dU1vREQEpkyZgu7duyM7O1vr/vPnz1fXNVlYWKB9+/a4cOECHB0dsWvXLri5uZU4NlFIL14AGDdunPrcNjY26NatG27duoWNGzdiwYIFhe7r5OSEMWPGaL1ZWFiUOOahQ4fC3Nwca9euhRAC+/btw4MHDzBkyBCYm5sX+3hffvml+t+XqckyNDTEt99+i/v372PFihUYPnw4fHx8IJFI8PTpU3z//fdo3Lgxzp8/X+JzFIeq1rBv376ws7NTL3dxcUGPHj0ghFDXhKocPnwY2dnZaN68eYGt354XHx+PiIgISKVSdX1weSiq92laWhq2b9+Ojz76CJMmTcLYsWMxduxYdb/rF2tb9+7dCwCYNGmSzjG8+eabAIDly5drLF+5ciVyc3MxYsQI2NjY6Hw8AJg4cSKAvBpruVyuXn706FHcvn0bFhYWGDp0aL79bt++jeXLl+Ptt9/GhAkT1PdXVWNfUC1vv379irzAsyCxsbH46aef8N5772HixInqc169erXQc3bu3BlmZmb5ljdo0ABAXh21ikKhwP79+wHo/tz8+eefAKD1cQIACwsLtGjRArm5uQXWG2vz119/ITY2Vv36eZ7quoEXL157mdeHo6Mj2rZtm2/5gwcPEBUVBQBaW35JJBKMGzcOQN7rWSUwMBAA8OGHH2LHjh1IS0sr9PyBgYHqi4DPnz8PpVJZrPhf1qBBg0q878mTJ/Hll1/ijTfewLhx4zB27FhMnToVRkZGePLkCRITE4s8RrNmzSCTybB69Wp8//33iIuLK3E81QX78JJaYGCg+k1HCIGLFy9i8eLF2Lp1Kw4cOIClS5eqOyw87/lehYaGhrC1tUXz5s3Ru3dvmJqaqrezt7dX///Ro0eoX79+kTE9fvwYQMEX1T3fh/fJkyc4fvw4UlNTMWXKFNStW1d9f7Tx8fEptcbgz7O0tMSgQYOwbt06HDp0qFgXq2kTHByMfv364ffff8fnn3+u9eKN4nB2dsbrr7+O119/HUDec7F582bMnz8fCQkJGD16tDopKCs5OTnYsGEDAO2Py/jx47F7926sW7cO8+fPh1Sa99lcdfGMj4+PTue5f/8+gLwkuryumHZ0dNSaMKmEhYVh3LhxhXY7SElJ0fi5uPcbAEaOHKlOHuLi4uDi4oLs7Gz89NNPAIBp06bpfCyVrl27ws3NDTExMdi5cyeGDRsG4H8Xqw0ZMkTjw6JCocC0adOwcuXKQj+8vnh/VV68CEpX8+fPx8KFC9UXahbnnAV1fVB1fnn+Yspnz54hPT0dAHR6PwOgvgB31KhRGDVqVKHbqiaB0YUqmdXWBWbUqFGYNWsWTpw4gZs3b6JevXoAXu71UdBzo/pAYGdnp37MXuTt7a2xrSrG/fv3Y9OmTRg4cCBkMhl8fX3Rpk0bDBo0CJ06ddI4xg8//IBevXphw4YN2LBhAywtLREQEIBOnTph1KhRZd69oyS/m48fP8bAgQPzTTj0opSUFNSoUaPQbby9vfHtt99ixowZmDZtGqZNmwYPDw8EBwejV69eGDx4MIyMjIodY1XGEd4iHDt2DL1794arqyskEgl+//33Mj/nw4cPMXLkSNjZ2cHU1BSNGjXCuXPnyvy8z5NIJGjWrBm2bNmCPn36AECB971fv35Yu3Yt1q5di59++glffvklhgwZopHsAoCXl5f6RXzmzJkiY8jNzcWFCxcAoMDRvIkTJ6rP/eeffyImJgYdO3ZEamoqhgwZ8lJXO78MVRK3ePFi/PHHH6hfvz5at25d4uN9/vnnkMlk+P777xETE1NaYQLIG+l+5513sGbNGgB5XQRu3bpVqud4UVhYmPrDzKeffoo2bdpo3FSj2jExMfj777/LNJbiKmok6cXf++c9fPgQQ4cOxbNnz/DBBx/g0qVLSE5OhkKhUH8bABT9zYYuzMzM8NprryEnJwerVq0CkNey6tGjR2jbti0aN25c7GNKpVJ19wrV70tqaipCQ0MBIN8o4dKlS/Hjjz/CyckJmzdvRnR0NDIzMyHyyukQEhICoOD7W9hjWZAdO3Zg3rx5MDY2xsqVK3Hr1i2kp6dDqVRCCIFZs2YVek7Vh6uyovr96d69e4HfMKlu2toHavPo0SP17JJhYWH5Xk8DBgxQt3988VuTkirJc1MYqVSKjRs34urVq/jqq6/Qq1cvxMXFYcWKFejcuTP69Omj0a2mQYMGuHHjBv7880+899578PPzw/Hjx/HJJ5+gbt26hXYTKQ0luf8TJ07EiRMnEBwcjL///huPHj1Cdna2+vXg4uICQPfX//Tp03Hv3j2sWrVK/UFn69atGDlyJHx9fTnq+wImvEVIT09HkyZN8P3335fL+RITE9G6dWsYGhrir7/+QmRkJL755psiP+2Vpa5duwIAnj59+lLHkUql6N27NwBgw4YNRb6o//jjDyQnJ0MqleLVV1/V6RzW1tbYtm0bbG1tce/evUJnWitL7dq1Q506dbBv3z5kZ2erv8IrqQYNGmDs2LHIysrCnDlzSilKTarnGXj557ooz3+1eurUKfzzzz8at+c/ED2/rWrU5vr16zqdR7V9XFwckpOTddpHNSqSmpqqdf3zLZqKKywsDJmZmejfvz++/PJLNG7cGFZWVuokq6APGsW93ypvvPEGZDIZVq1ahZycHHV5Q0lGd1XGjx8PiUSCAwcOICYmBtu2bUNGRgZ8fHzQqlUrjW1VbdZWrlyJkJAQeHh4aPT6LosPVqpzLly4EJMmTUKdOnVgZmambiVVmue0s7NTj+YXVCLxIlWJ14QJE9Qf1gu6tWnTRqdjrl+/Hrm5uQDyPrC++Hr6559/1B/+161bp962JK+PotSsWRNA3uh3QaPoqlFu1bbP8/X1xYwZM/D777/j8ePHOHDgABwdHREWFob169drbGtgYICePXvi66+/xsmTJ/H06VPMnTsX2dnZmDx5snr0vSJIT0/Hnj17IJVKsWfPHnTp0gWOjo7qDyLp6emIj48v9nGdnJzw2muvYd26dYiKisK1a9cQHByMqKgofPjhh6V9Nyo1JrxF6NGjBz777DP0799f63q5XI73338fNWvWhLm5OYKCgl5qvusvv/wSbm5uWLNmDQIDA+Hl5YWuXbuqvwIqbbp8klR97VWrVq2XPt+MGTNgYGCAy5cvY9myZQVul5ycjA8++ABAXq1bce6/g4MDPvnkEwDA119/XezehqXl9ddfh52dHRwdHTF69OiXPt78+fNhamqK9evXF7vkoDjPM6D9D1FpefDggXok89q1a+rRjRdvkZGRAPI++KgS8E6dOsHIyAjnz59Xj/4XxtnZGU2aNIFSqdR5ZEt13wtKLlU1mCWhqsHWNnInhMDmzZu17qeaAltVjqArd3d39OvXD7GxsZgzZw5OnjwJV1dXDBgwoJiR/4+npyc6d+4MpVKJtWvXFlqyU9j9vXr1KiIiIkocR0EKO+fjx4/VNbelQSaToUuXLgB0f25U9bVF9VwuDtWHwhUrVhT4esrNzYWLiwvi4+PVvZdL8vooSq1atdTv19pKxoQQ6uUdO3Ys9FgSiQSdO3fG8OHDAaDI3xcrKyvMmzcPNjY2yMjIKLDfrz6ovsmxsrLSWju/cePGUvlmx8fHBzNnzgRQ9ONV3TDhfUnTpk3DqVOnsHXrVvz7778YPHgwunfvXuJRhD/++AMtWrTA4MGD4ejoiKZNmxb7j1xx/PDDDxgzZoy6af3zxH/N/VWjQqp6vZfh5+en/rr63XffxVdffaUebVC5fv06XnnlFURFRcHT0zPfRTe6mDp1Ktzd3ZGcnIxvvvnmpeMuiffeew9Pnz7Fo0eP1F9VvYyaNWti+vTpUCqVhX5Y0CY5ORnNmjXDhg0btF4McufOHXXC0qpVqzKtf1u7di0UCgUCAwMLrUlt0KABWrRooTHZgaOjI6ZMmQIAGDx4cL6G/kIIHDp0SGO0au7cuQCAjz/+WH1R2PMiIyNx7do19c+BgYHqZv2qOmOV7du3F/uxf/E+AXmz7j3/daNCoVAnpNq8++67sLS0xB9//IFPPvkkX23q48ePC6wLfOuttwAAX3zxBQBg8uTJ6kkhSkpVurBs2TKcOnUKBgYGWj/Uqe7v999/r1EKEhcXh9GjR+d77ZcG1TlXrVqlcaFtcnIyxowZU2ojmSoff/wxDAwMsHz5cvzwww/5kpZ79+5pXAg6adIkeHh4YPv27Zg5c6bWbxLi4+N1ft8/ceIEbty4AWNj4wIvhAPykvMRI0YA0CxrKO7rQxfvv/8+AGDBggW4dOmSerkQAp999hkiIiJgY2OD1157Tb1u/fr1Wi+YTU1NVQ8iqT7EZGRkYMmSJVprnI8fP46kpCTIZLJSGaQpLU5OTqhRowaSkpLyva+cPn1aXWqjq0OHDmHPnj353guEEOryFl1LYqqNsmwBUdUAmvPD37t3T8hkMvHw4UON7Tp37ixmzZpVonMYGxsLY2NjMWvWLHHhwgWxcuVKYWJiItauXfsyoRfo22+/VbdZcXBwEF27dhXDhw8XPXv2FJ6enup1I0eOzNc78GXaUy1dulTdXsrOzk707t1bDBs2TAQFBQmJRCIAiObNm4uYmBit+xc18YQQQqxevVrdf/LZs2fq5WXdh1cXxWlL9rzExERRo0YN9fOia1uyxMRE9XJjY2MRGBgoBg8eLAYNGiSCgoLUTec9PDzEzZs3C439ZZ53pVKpnnTg+++/L3L7ZcuWCQDCz89PvUwul4s+ffoIIG/iieDgYDF8+HDRtWvXAieeWLhwofr3ysfHR92kvqB2Tc+/LoKDg8WgQYNEw4YNhUQiEbNnzy60LdmLy5+Xk5MjmjdvLgAICwsL8eqrr4ohQ4YIDw8PYWhoKGbOnFng87pv3z51b2snJyfRr18/MXjwYBEYGJhv4okXNW3aVAAQhoaGWvumFldWVpZ6EhlAs+/r806fPq1+ndepU0cMGTJEdO/eXZiamoqGDRuK/v37a338dWnrVFBbsjt37qgn6KhZs6YYOHCg6NOnj7C2thYuLi5i/PjxWn9/Va+9gn6vC2uDtm7dOnW7Pw8PDzFo0CAxYMAA4e/vr3XiiStXrqjfX21sbES7du3E8OHDRb9+/YSvr6+QSCTCycmpwPv+vLFjxwoAYvDgwUVu+++//wogbzKI+Ph49fLivD50aQenVCrFqFGj1OdSTcBSv359AUCYmpqKPXv2aOzTt29fAUC4urqKnj17ihEjRmhM+uHn56fuN6t6P5NKpaJJkyZi0KBBIiQkRAQHB6vvh6r/e0no0pasMAX9/j7/vhIUFCRCQkJE69athUQiEaNGjVL/XXjx/UtbWzLVsaysrESHDh3E8OHDRf/+/dXHsLa25sQTL2DCWwwvJry7d+8WQF6v2edvBgYGYsiQIUKI//UaLew2c+ZM9TENDQ1FcHCwxnmnT58uWrZsWSb3KSUlRfz+++9i+vTpIjAwUNSqVUsYGhoKU1NT4e3tLUJCQvLNiKPysv1Yo6OjxYwZM0STJk2EtbW1MDIyEq6urqJPnz5i06ZNhc4GpkvCm5ubq37D/vDDD9XLK3PCK0TerEjFTXiVSqU4c+aM+Pzzz0XXrl1F3bp1haWlpTA0NBSOjo6iY8eOYsmSJVob07/oZZ73gwcPCiCv9+7zH0IK8uTJE3Ui8fxkDEqlUmzevFk9S5GhoaFwdnYWbdu2FYsXLxaZmZn5jnXq1CkREhIiatasKQwNDYWtra1o0qSJ+OCDDzQmCVFZt26daNasmTAxMRFWVlaiU6dOYv/+/UX24S0s4RUir8/qRx99JOrXry9MTEyEo6Oj6Nevnzh37lyRycS9e/fEW2+9pd7XwsJC1KtXT4wfP77AJvhCCHUiHRISUmhsxTF9+nT179off/xR4Hb//vuv6NOnj3BxcREmJiaibt264oMPPhApKSkFJgYvk/AKkfdcjBgxQri7uwtjY2Ph4eEhXn/9dREfH19gYvsyCa8QeRM0TJgwQXh5eQljY2NhbW0tfH19xbRp0/L1GRYi7733q6++EsHBwcLGxkYYGhoKFxcXERAQIGbMmCFOnjxZ4H1//hjm5uYCgNi9e3eR2wvxv767X375pcZyXV8fxel/vHnzZtGhQwf1/XNzcxNjx47V2of92LFj4u233xaBgYHC2dlZGBkZCWdnZxEcHCz+7//+T+O9KScnR/z4448iJCRE+Pj4CGtra/XfrIEDB4qDBw/q9FgUpKwSXiGE+P3330WrVq2EjY2NsLCwEC1atBA//PCDUCqVxUp4b9++LebNmyc6d+4s3N3dhYmJiahRo4Zo3Lix+PDDDwscLKrOJEKUQtFINSGRSLBz507069cPALBt2zaMGDECV69ezdcGxsLCAs7OzsjOzlYX6BfEzs5O3XbLw8MDXbp0UfcoBfLqsj777DONFi5ERLpQKBTw9vbGvXv3cPLkSQQHB+s7JCKicsc+vC+hadOmUCgUePz4sdYG3EDeFd/F6Z3ZunXrfFf73rx5k7U4RFQiq1atwr179xAcHMxkl4iqLSa8RUhLS8Pt27fVP9+9excRERGwtbVFvXr1MGLECIwePRrffPMNmjZtiidPnuDgwYNo3Lixzq20nvfOO++gVatW+PzzzzFkyBCcPXsWq1atUvfRJCIqyo0bN7B48WLEx8dj7969kEqlLz1hCRFRZcaShiIcOXJEa+uUMWPGYO3atcjJycFnn32G9evX4+HDh7C3t0fLli0xf/58NGrUqETn3L17N2bNmoVbt27By8sL7777rsbVrEREhVG9b6m+YZo3b16BrRWJiKoDJrxEREREVKWxDy8RERERVWlMeImIiIioSuNFawVQKpWIjY2FpaWleg52IiIiIqo4hBBITU2Fq6srpNKCx3GZ8BYgNjYWbm5u+g6DiIiIiIoQExNT6HTSTHgLYGlpCSDvAbSystJzNERERET0opSUFLi5uanztoIw4S2AqozBysqKCS8RERFRBVZU+SkvWiMiIiKiKo0JLxERERFVaUx4iYiIiKhKY8JLRERERFUaL1orBQqFAjk5OfoOg4gqMAMDA8hkMvb1JiLSAya8L0EIgfj4eCQlJek7FCKqBGQyGRwdHWFtbc3El4ioHDHhfQmqZNfR0RFmZmb8A0ZEWgkhkJubi5SUFMTFxSEzMxMuLi76DqvcKJQCZ+8m4HFqFhwtTRDoZQuZlO+XRFR+mPCWkEKhUCe7dnZ2+g6HiCoBS0tLGBsb4+nTp3B0dIRMJtN3SGVu75U4zA+LRFxylnqZi7UJ5vb2RXe/6pP0E5F+8aK1ElLV7JqZmek5EiKqTMzNzSGEqBZ1/3uvxGHKxgsayS4AxCdnYcrGC9h7JU5PkRFRdcOE9yWxjIGIiqO6vGcolALzwyIhtKxTLZsfFgmFUtsWRESliwkvERGVurN3E/KN7D5PAIhLzsLh64/LLygiqrZYw0tERKXucWrBye7zJq4/Bx9nSwR42iLQK+/mZGVSxtERUXXDhJeIKoW1a9di3LhxuHv3Ljw9PfUdDhXB0VL3pPV6fCqux6diw+l7AAB3W7P/EuAaCPSyg6cdu+AQ0cupcCUNaWlpmDt3Lrp37w5bW1tIJBKsXbtWp30PHjyI8ePHo169ejAzM0Pt2rUxceJExMXxwojiWLt2LSQSCSQSCU6cOJFvvRACbm5ukEgk6NWrl8Y61X7ffPNNgcc9d+6cetm8efMgkUjw9OlTjW3DwsLQvn17dcu32rVrY8iQIdi7dy8AoEOHDupzFXabN2+eTvd5yJAhkEgkmDlzpk7bE9C4cWO4u7tDiIJrMFu3bg0nJyfk5uaWY2RUEQR62cLFuuCkV4K8bg2nZ3XGihHNMK61J/xqWkEqAe4nZOC3Cw8w87fL6Pj1EQQsPIipm85jzT93ceVhMut+iajYKtwI79OnT/Hpp5/C3d0dTZo0wZEjR3Ted+bMmUhISMDgwYNRt25d3LlzB8uXL8fu3bsREREBZ2fnsgu8CjIxMcHmzZvRpk0bjeVHjx7FgwcPYGxsXOC+ixcvxpQpU0rUxeLrr7/GjBkz0L59e8yaNQtmZma4ffs2Dhw4gK1bt6J79+74+OOPMXHiRPU+4eHhWLZsGT766CM0aNBAvbxx48ZFni8lJQVhYWHw9PTEli1b8MUXX3A0SQcjRozAhx9+iOPHj6Ndu3b51kdHR+PUqVOYNm0aDAxe/q1m1KhRGDZsWKG/d1RxyKQSzO3ti9c3Xsi3TvXqmtvbF87WJujRyAU9GuW1KEvNysH5e4kIj05A+N1ERDxIwtM0OfZcjseey/EAAEtjAzTzqKEugWhcyxrGBlW/xRsRlVyFS3hdXFwQFxcHZ2dnnDt3DgEBATrvu2TJErRp0wZS6f8Grrt374727dtj+fLl+Oyzz8oi5FJVkRq09+zZE9u3b8eyZcs0EpbNmzejefPm+UZlVfz9/REREYEff/wR7777brHOmZubiwULFqBLly74+++/861//DjvApcuXbpoLDcxMcGyZcvQpUsXdOjQoVjn/O2336BQKLB69Wp06tQJx44dQ/v27Yt1jPIghEBWVhZMTU31HQoAYPjw4Zg1axY2b96sNeHdsmULhBAYMWLES50nPT0d5ubmkMlk1aJvbVUSXNsehjIJchSaI7LOhfThtTQxRIf6juhQ3xEAkJWjwOWHyTh7NwFn7ybgwr1EpMpzcfTmExy9+QQAYGQghX8tGwR41UCApy2ae9SApYlh2d9BIqo0KlxJg7GxcYlHYtu1a6eR7KqW2dra4tq1a6URXpnaeyUObb48hJCfTuOtrREI+ek02nx5SG+9KkNCQvDs2TPs379fvSw7OxuhoaEYPnx4gfu1bt0anTp1wldffYXMzMxinfPp06dISUlB69atta53dHQs1vF0sWnTJnTp0gUdO3ZEgwYNsGnTJq3bXb9+HUOGDIGDgwNMTU1Rv359fPzxxxrbPHz4EBMmTICrqyuMjY3h5eWFKVOmIDs7G8D/SjhepCr3iI6OVi/z9PREr169sG/fPrRo0QKmpqZYuXIlAGDNmjXo1KkTHB0dYWxsDF9fX6xYsUJr3H/99Rfat28PS0tLWFlZISAgAJs3bwYAzJ07F4aGhnjy5Em+/SZNmgQbGxtkZWm/+MjNzQ3t2rVDaGio1p6ymzdvhre3N4KCgnDv3j1MnToV9evXh6mpKezs7DB48GCN+/v843D06FFMnToVjo6OqFWrVoGP0a5du/Dqq6+qH29vb28sWLAACoVC47gdOnSAn58fIiMj0bFjR5iZmaFmzZr46quv8sWdlZWFefPmoV69ejAxMYGLiwsGDBiAqKgo9TZKpRLfffcdGjZsCBMTEzg5OWHy5MlITEzU+lhVV6EXHiBHIVDfyQJbXgvC0mH+2PJaS5yY2UnnSSdMDGUI8LTFGx3rYN34QETM7Yrd09tgbm9f9GzkDHsLY2TnKnE2OgHfH47C2DXhaDL/b/T6v+OYH3YVf12Ow9M0eRnfUyKq6Cpcwlva0tLSkJaWBnt7e32HUqiK2KDd09MTwcHB2LJli3rZX3/9heTkZAwbNqzQfefNm4dHjx4VmIQVxNHREaampggLC0NCQkKJ4i6O2NhYHD58GCEhIQDykvzQ0FB1gqry77//IigoCIcOHcJrr72GpUuXol+/fggLC9M4VmBgILZu3YqhQ4di2bJlGDVqFI4ePYqMjIwSxXfjxg2EhISgS5cuWLp0Kfz9/QEAK1asgIeHBz766CN88803cHNzw9SpU/H9999r7L927Vq8+uqrSEhIwKxZs/DFF1/A399fXQs9atQo5ObmYtu2bRr7qT7YDBw4ECYmBddhjhgxAs+ePcO+ffs0ll++fBlXrlxRj+6Gh4fj5MmTGDZsGJYtW4bXX38dBw8eRIcOHbQ+NlOnTkVkZCTmzJmDDz/8sMDzr127FhYWFnj33XexdOlSNG/evMB9EhMT0b17dzRp0gTffPMNfHx8MHPmTPz111/qbRQKBXr16oX58+ejefPm+Oabb/DWW28hOTkZV65cUW83efJkzJgxA61bt8bSpUsxbtw4bNq0Cd26dasWE0roQqkU2PjfRWijW3ki2Nseff1rItjb7qW+tZJJJfCraY1xrb3ww4jmCP+4Mw691x5fDmyEgc1qwd3WDEoBXHmYgjX/RGPKpgto8dkBdPr6CGaG/ovQ8w8Qk5BRaO05EVVBogILDw8XAMSaNWtKfIwFCxYIAOLgwYOFbpeVlSWSk5PVt5iYGAFAJCcna90+MzNTREZGiszMTI3lSqVSpMtzinVLycwWgQv3C4+Zu7XePGfuFkELD4iUzOxiH1upVBb7MVuzZo0AIMLDw8Xy5cuFpaWlyMjIEEIIMXjwYNGxY0chhBAeHh7i1Vdf1dgXgHjjjTeEEEJ07NhRODs7q/d9/rgqc+fOFQDEkydP1MvmzJkjAAhzc3PRo0cPsXDhQnH+/PlCY96+fbsAIA4fPlys+/r1118LU1NTkZKSIoQQ4ubNmwKA2Llzp8Z27dq1E5aWluLevXsay59/fEePHi2kUqnG/XtxO9X9fZHqsbl79656mYeHhwAg9u7dm2971WP6vG7duonatWurf05KShKWlpYiKChI6++pSnBwsAgKCtJYv2PHDp0ez4SEBGFsbCxCQkI0ln/44YcCgLhx40aB8Z46dUoAEOvXr1cvUz0Obdq0Ebm5uRrba3uMtB138uTJwszMTGRlZamXtW/fPt+55HK5cHZ2FgMHDlQvW716tQAglixZku+4qsfs+PHjAoDYtGmTxvq9e/dqXf6igt47qppjNx8Lj5m7hd+cvSItK6dczx2XlCn+iHgoPtl5WXT79qjw/DD/+2rQwgNi2uYLYv3Ju+JaXLJQKIr/XklE+pecnFxovqZS4Wp4S9OxY8cwf/58DBkyBJ06dSp020WLFmH+/Pkvfc7MHAV85+wresNiEADiU7LQaF7+mtaiRH7aDWZGJX+ahwwZgrfffhu7d+9G9+7dsXv3bixbtkynfefNm4f27dvjxx9/xDvvvKPzOefPnw8fHx/88MMP2LdvH/766y98/PHHaNq0KTZt2qRxUdrL2rRpE1599VVYWloCAOrWrYvmzZtj06ZN6NevHwDgyZMnOHbsGN566y24u7tr7K8qT1Aqlfj999/Ru3dvtGjRIt95SnoRnJeXF7p165Zv+fN1vMnJycjJyUH79u2xb98+JCcnw9raGvv370dqaio+/PDDfKO0z8czevRoTJkyBVFRUfD29gaQ97i4ubkVWctco0YN9OzZE3/88Ye61lYIga1bt6JFixaoV69evnhzcnKQkpKCOnXqwMbGBhcuXMCoUaM0jvvaa6/pVK/7/HFTU1Mhl8vRtm1brFy5EtevX0eTJk3U6y0sLDBy5Ej1z0ZGRggMDMSdO3fUy3777TfY29tj+vTp+c6lesy2b98Oa2trdOnSRaOOvXnz5rCwsMDhw4cLLfmpLjacyhvdHdi8FsyNy/dPjbO1CXo3cUXvJq4AgOSMHJy7l4Cz0QkIv5uAfx8kIz4lC2GXYhF2KRYAYG1qiADPvBrgAC9b+Llaw8igyn8JSlRtVNlX8/Xr19G/f3/4+fnh559/LnL7WbNmITk5WX2LiYkphygrPgcHB7zyyivYvHkzduzYAYVCgUGDBum0b7t27dCxY8cS1fKGhITg+PHjSExMxN9//43hw4fj4sWL6N27d4E1pcV17do1XLx4Ea1bt8bt27fVtw4dOmD37t1ISUkBAHVC5OfnV+Cxnjx5gpSUlEK3KQkvLy+ty//55x+88sorMDc3h42NDRwcHPDRRx8ByEuAAahrTouKaejQoTA2NlbXLicnJ2P37t0YMWKETon6iBEjkJ6ejl27dgEATp48iejoaI2L1TIzMzFnzhy4ubnB2NgY9vb2cHBwQFJSkjpeXe73i65evYr+/fvD2toaVlZWcHBwUCe1Lx63Vq1a+e5PjRo1NOpuo6KiUL9+/UK7Sty6dQvJyclwdHSEg4ODxi0tLU19YWV19jApEweuPQIAjGzpXsTWZc/azBCdGzhhVo8G2DG1NS7P64bNrwXhnVfqoU0de5gZyZCcmYMD1x5j0V/XMeCHk2g8fx9CVp3Gkv03ceLWU2Rks7UeUWVWJUd4Y2Ji0LVrV1hbW2PPnj3q0bvCGBsbl0q7I1NDGSI/zT8iV5izdxMwdk14kdutHReAQC/bYsfzsoYPH47XXnsN8fHx6NGjB2xsbHTed+7cuejQoQNWrlxZrP1UrKys0KVLF3Tp0gWGhoZYt24dzpw5UypdFDZu3AgAeOedd7SOQP/2228YN27cS5/neQUlkC9eZKWirSNDVFQUOnfuDB8fHyxZsgRubm4wMjLCnj178O2330KpVBYrpho1aqBXr17YtGkT5syZg9DQUMjlco3R0ML06tUL1tbW2Lx5M4YPH47NmzdDJpNp1HlPnz4da9aswdtvv43g4GBYW1tDIpFg2LBhWuPVpRNFUlIS2rdvDysrK3z66afw9vaGiYkJLly4gJkzZ+Y7bkEjxqKYtZxKpRKOjo4FXtzo4OBQrONVRVvO3IdSAK287VDHsej33/JmaiRDK297tPLOu7YjR6FEZGwKwqMTcOZuAs5FJyAxIwen7jzDqTvPAAAGUgka1rRGoGoU2NMWNcyNijxXReq8Q1SdVbmE99mzZ+jatSvkcjkOHjwIFxfdrgQuLRKJpNglBG3rOsDF2gTxyVnQ9qdXgryv6NrWddDLG2X//v0xefJknD59Ot/FTUVp3749OnTogC+//BJz5sx5qThatGiBdevWlcpEIkIIbN68GR07dsTUqVPzrV+wYAE2bdqEcePGoXbt2gCgcdHSixwcHGBlZVXoNkBecgnkJWvPfwC4d++ezrGHhYVBLpfjjz/+0CixOHz4sMZ2qvKEK1euoE6dOoUec/To0ejbty/Cw8OxadMmNG3aFA0bNtQpHmNjYwwaNAjr16/Ho0ePsH37dnTq1Emj20poaCjGjBmjMSFJVlYWkpKSdDqHNkeOHMGzZ8+wY8cOjbZod+/eLfExvb29cebMGeTk5MDQUHtbK29vbxw4cACtW7euMC3iKpLsXCW2ht8HAIxq6aHnaHRjKJOiiZsNmrjZYGLb2lAqBaKepKlLIMKjE/EwKROXYpJwKSYJPx3P+x2r62ih7gUc4GkLVxvN34e9V+IwPyxS42Jkl0JashFR2am0JQ1xcXG4fv26xhXR6enp6NmzJx4+fIg9e/agbt26eoxQd6oG7cD/GrKrPN+gXV+jAhYWFlixYgXmzZuH3r17F3v/efPmIT4+HqtWrSpy24yMDJw6dUrrOtXV9PXr1y92DC/6559/EB0djXHjxmHQoEH5bkOHDsXhw4cRGxsLBwcHtGvXDqtXr8b9+/c1jqMaHZRKpequDc/PJPfidqok9NixY+p16enpWLdunc6xq0Yqnx+ZTE5Oxpo1azS269q1KywtLbFo0aJ8ZSAvjmr26NED9vb2+PLLL3H06FGdR3dVRowYgZycHEyePBlPnjzJ13tXJpPlO+f//d//FTiyrQttj0N2djZ++OGHEh9z4MCBePr0KZYvX55vneo8Q4YMgUKhwIIFC/Jtk5ub+1JJfFXw15U4PE3LhpOVMV7xddJ3OCUilUpQ18kSI4I88N2wpvjnw044MbMjvh3aBCGB7qjjaAEAuPU4DZvO3MdbWyPQ6otDaP3FIbyzLQKbz9zHmn/uVrjOO0TVWYUc4V2+fDmSkpIQG5t3MUFYWBgePHgAIO+rUWtra8yaNQvr1q3D3bt34enpCSDvj+7Zs2cxfvx4XLt2TaP3roWFhfoipIqou58LVoxslm80oLAG7eVpzJgxJd63ffv2aN++PY4ePVrkthkZGWjVqhVatmyJ7t27w83NDUlJSfj9999x/Phx9OvXD02bNi1xLCqbNm2CTCbDq6++qnV9nz598PHHH2Pr1q149913sWzZMrRp0wbNmjXDpEmT4OXlhejoaPz555+IiIgAAHz++ef4+++/0b59e0yaNAkNGjRAXFwctm/fjhMnTsDGxgZdu3aFu7s7JkyYgBkzZkAmk2H16tVwcHDIl0wXpGvXrjAyMkLv3r0xefJkpKWl4aeffoKjo6PG6LeVlRW+/fZbTJw4EQEBARg+fDhq1KiBS5cuISMjQyPJNjQ0xLBhw7B8+XLIZDJ1mzZdtW/fHrVq1cKuXbtgamqKAQMGaKzv1asXNmzYAGtra/j6+uLUqVM4cOAA7OzsinWe57Vq1Qo1atTAmDFj8Oabb0IikWDDhg0v1W5q9OjRWL9+Pd59912cPXsWbdu2RXp6Og4cOICpU6eib9++aN++PSZPnoxFixYhIiICXbt2haGhIW7duoXt27dj6dKlOte5V0WqVmTDAz1gKKu0Yyr51Kphhlo1zNC/aV5f6Gdpcpy7l4izdxMQHp2Aq7EpeJiUiZ0XH2LnxYcFHkcgbyBjflgkuvg6s7yBqJxUyIT366+/1viKd8eOHdixYwcAYOTIkbC2tta6nyrxWL16NVavXq2xzsPDo0InvEBe0tvF17lK1nvNmzcPHTt2LHI7Gxsb/PTTT/jzzz+xZs0axMfHQyaToX79+li8eDHefPPNl44lJycH27dvR6tWrWBrq70m2s/PD15eXti4cSPeffddNGnSBKdPn8bs2bOxYsUKZGVlwcPDA0OGDFHvU7NmTZw5cwazZ8/Gpk2bkJKSgpo1a6JHjx7qKZYNDQ2xc+dOTJ06FbNnz4azszPefvtt1KhRQ+d64fr16yM0NBSffPIJ3n//fTg7O2PKlClwcHDA+PHjNbadMGECHB0d8cUXX2DBggUwNDSEj4+P1prl0aNHY/ny5ejcuXOxS4GkUilCQkKwePFi9O7dO1/d/NKlSyGTybBp0yZkZWWhdevWOHDggNYOFLqys7PD7t278d577+GTTz5BjRo1MHLkSHTu3LnEx5XJZNizZw8WLlyIzZs347fffoOdnR3atGmDRo0aqbf78ccf0bx5c6xcuRIfffQRDAwM4OnpiZEjRxY4aUp1cC0uBeHRiTCQSjAs0E3f4ZQpOwtjdGvojG4N80p30uW5uHA/EeF3E7D/2iNci0stcF8BIC45C2fvJiDYu+Qf+ohIdxLxMsMhVVhKSgqsra2RnJwMKyurfOuzsrJw9+5deHl5FdqYn6iyuHTpEvz9/bF+/fp8bcKo9FTl946Pdl7G5jP38WojF3w/opm+w9GbXREP8dbWiCK3WzrMH339a5Z9QERVWFH5mkrV+b6JiF7KTz/9BAsLi3zlCES6SMnKwe//fZU/KrhyXKxWVhwtdfsg8+ORKBy58ZizvhGVgwpZ0kBE5ScsLAyRkZFYtWoVpk2bBnNzc32HRJXQjvMPkJGtQF1HCwQVs31iVRPoZVto5x2Va/GpGLsmHL4uVpjSwRs9G7lUiRI2ooqII7xE1dz06dMxb9489OzZs1RmG6TqRwiBDf9drDYq2KPEMwtWFUV13pEAWDTADxPbeMHMSIbIuBRM33IRnb45gs1n7iMrp+TdS4hIO47wElVz0dHR+g6BKrlTd54h6kk6zI1k6N+UNamA7p133uhYB+tP3cPak3dx71kGPtp5Gd8euImJbbwwPMgdliba+0ETUfEw4SUiopey4VTe6G7/ZjWZoD1Hl847NcyN8NYrdfFaOy9sPRuDn47fQVxyFhb9dR3LD9/G6GAPjGvtBXuLl58JlKg6Y8JLREQlFp+chb8jHwEARrX01G8wFZBMKtGp9ZiZkQHGt/HCyJYe2BXxED8ejULUk3R8fzgKPx+/i6EBbnitbW242ZqVQ9REVQ9reF8Sr64louKoau8ZW87eh0IpEOhli/rOlkXvQIUyMpBicAs37H+nPVaOao4mbjaQ5yqx/tQ9dPj6CN7ZFoEb8QX3+CUi7TjCW0KGhnlf22VkZMDU1LSIrYmI8qSnp0MikajfQyqzHIUSW87mzRA4qmX1bkVW2qRSCbo1dEZXXyecuvMMK45E4fitp+qZ3Dr7OGJqR28096jeHTGIdMWEt4RkMhlsbGzw+PFjAICZmVm1vzKZiLQTQiA3NxcpKSlISUmBjY0NZDKZvsN6aX9ffYTHqXI4WBqrZxyj0iWRSNDK2x6tvO1x+UEyfjwahT1X4nDw+mMcvP4YgZ62mNLRGx3qOfBvEFEhmPC+BGfnvDd4VdJLRFQYmUwGFxeXAqdHr2w2nI4GAIQEuMHIgBVyZa1RLWt8P6IZ7jxJw6pjd/DbhQc4G52As2sS4ONsiSkdvPFqIxcYyPhcEL2IUwsXQNep6gBAoVAgJyennCIjosrIwMAAMpmsyozC3XyUiq7fHoNMKsGJmR3hYs3SrvIWn5yFX07cwaYz95GRnde7193WDJPa1cag5rVgYlj5v0UgKoqu+RoT3gIUJ+ElIqpu5uy6gvWn7qF7Q2f8OKq5vsOp1pIysrH+1D2s+ecuEjPyBl/sLYwxoY0XRrR0hxVbxVEVxoT3JTHhJSLSLk2ei5afH0SaPBebJgahdR17fYdEADKyc/FreAx+On4XD5MyAQCWxgYYGeyB8a294GDJXr5U9eiar7HQh4iIimXnxYdIk+eitoM5WunQY5bKh5mRAca29sKRGR3wzeAmqOtogVR5LlYciULrLw/hk98v4/6zDH2HSaQXTHiJiEhnQghs/G9mtVEtPapMTXJVYiiTYmDzWtj3djusGtUc/m42yM5VYuPp++jw9WG8tfUirsWl6DtMonLFLg1ERKSz8OhE3HiUClNDGQY0q6XvcKgQUqkEXRs6o4uvE07fScCKo1E4dvMJdkXEYldELDrWd8DUjnUQ4MlevlT1MeElIiKdrT8VDQDo19QV1qa8GKoykEjypjcO9rbDlYfJWHE0Cn9djsPhG09w+MYTtPCogSkdvNHJx5Ej9lRl8aK1AvCiNSIiTY9Ts9Bq0SHkKgX+fLMNGrpWjX7C1dHdp+l5vXzPP0C2QgkA8HG2xOvtvdGrMXv5UuXBi9aIiKhUbTsbg1ylQHOPGkx2Kzkve3MsGtAIx2d2xOR2tWFuJMP1+FS8vS0CHb4+gg2nopGVo9B3mESlhiO8BeAILxHR/+QqlGj71WHEJWfhu6H+6Ne0pr5DolKUnJGDDaejseafaDxLzwYA2FsYYVxrL4xs6cHyFaqw2If3JTHhJSL6n71X4vH6xvOwMzfCyVmdYGzAWbyqosxsBX49F4NVx+6oe/laGBtgREt3TGjtBUcrEz1HSKSJJQ1ERFRqNp7Oa0U2NMCNyW4VZmokw5hWnjgyowO+HdoE9ZwskCbPxcqjd9Dmq8P4aOdl3HuWru8wiYqNI7wF4AgvEVGeqCdp6PzNUUglwLEPOqJWDTN9h0TlRKkUOHT9MX44chsX7icBAKQS4NXGrni9fW3WcpPe6ZqvsS0ZEREVSjW628nHicluNSOVSvCKrxM6N3DE2bt5vXyP3HiCsEuxCLsUi/b1HDC1gzcCvWw1WpoplAJn7ybgcWoWHC1NEOhlC5mULc9If5jwEhFRgTKycxF6/gEAYFSwh56jIX2RSCQIqm2HoNp2iIxNwYqjUfjz31gcvfkER28+QTN3G0zpUAedfRzxd2Q85odFIi45S72/i7UJ5vb2RXc/Fz3eC6rOWNJQAJY0EBEBW87ex6wdl+FpZ4ZD73WAlKN09J97z/J6+W4//wDZuXm9fF2sTTQSXRXVb82Kkc2Y9FKp4kVrRET0UoQQ2HAqr5xhZEsPJrukwcPOHAv7N8KJDzri9fbeMDeSaU12AUA1sjY/LBIKJcfZqPwx4SUiIq0u3E9CZFwKjA2kGNS8lr7DoQrK0coEH/bwwdKQpoVuJwDEJWfh7N2E8gmM6Dms4SUiIq02nIoGAPRp4gobMyP9BkMVXro8V6ftVh2LQrZCiUBPW5gascUdlQ8mvERElM/TNDn2XI4HAIwO9tRvMFQpOFrqNinF4RtPcPjGExgZSBHoaYu2de3Rtq4DfJwtWTZDZYYJLxER5fPruRhkK5Ro4maDRrXYa5WKFuhlCxdrE8QnZ0Fbla4EgLWZIV5p4Ih/bj9DXHIWTtx+ihO3n2LRX9dhb2GMtnXt0aaOPdrWteesblSqmPASEZEGhVJg0+n7AIBRLdmKjHQjk0owt7cvpmy8AAmgkfSqxm2/GNAI3f1cIIRA1JM0HL/1FMdvPcWpqGd4mibHzosPsfPiQwCAj7OlevQ30MsWJoYsf6CSq5BtydLS0rB48WKcOXMGZ8+eRWJiItasWYOxY8fqtH9SUhI++OAD7Ny5ExkZGQgMDMQ333yDZs2a6RwD25IRUXV1IPIRJq4/BxszQ5ye1ZmJBhXL3itxxe7DK89V4MK9JBy/9QTHbz3FldhkPJ+dvFj+0MDFUmOiC6q+dM3XKmTCGx0dDS8vL7i7u6N27do4cuSIzgmvUqlE27ZtcenSJcyYMQP29vb44YcfEBMTg/Pnz6Nu3bo6xcCEl4iqqzGrz+LozSeY3K42ZvVsoO9wqBJ62ZnWEtKz8c/tp+oE+MV2Zyx/IJVKPbWwi4sL4uLi4OzsjHPnziEgIEDnfUNDQ3Hy5Els374dgwYNAgAMGTIE9erVw9y5c7F58+ayCpuIqNKLfpqOozefQCIBRgSxnIFKRiaVINjbrsT725oboXcTV/Ru4sryByoVFTLhNTY2hrOzc4n2DQ0NhZOTEwYMGKBe5uDggCFDhmDjxo2Qy+UwNjYurVCJiKqUTWfyJproUM8B7nZmeo6GKG9a4zqOlqjjaIlxrb20lj9cj0/F9fhU/HT8LowMpAjysv1v9JflD5SnQia8L+PixYto1qwZpFLNOTUCAwOxatUq3Lx5E40aNcq3n1wuh1wuV/+ckpJS5rESEVUkWTkK/HruAQBgVDBHd6liMjaQIdjbDsHedvigu/byB9Vo8PPdH1QlECx/qJ6qXMIbFxeHdu3a5Vvu4pJXKB8bG6s14V20aBHmz59f5vEREVVUf1yKRXJmDmrVMEX7eo76DodIJ9rKH47dzGt3xvIHUqlyCW9mZqbWkgUTExP1em1mzZqFd999V/1zSkoK3NzcyiZIIqIKaOPpvHKGkS09inWBEVFF8Xz5w/g2upc/5I3+svyhKqtyCa+pqalGaYJKVlaWer02xsbGrO0lomorIiYJ/z5IhpGBFENa8MM+VQ3FKX8AXih/qGuv8+xxVPFVuYRX1eHhRaplrq6u5R0SEVGFt+FU3uhur0YusDU30nM0RGWjoPKH47ee4PSdBK3lD+3qOaBNHXudyx9etiUblY0ql/D6+/vj+PHjUCqVGheunTlzBmZmZqhXr54eoyMiqngS07MR9m8sAF6sRtVHccofVh27o1H+0LauA3yc85c/lGTSDSoflTrhjYuLQ3JyMry9vWFoaAgAGDRoEEJDQ7Fjxw51H96nT59i+/bt6N27N8sWiIhe8Ou5GGTnKuFX0wr+bjb6DodIL162/OHCvURM2XgBL87mFZ+chSkbL2DFyGZMevWowia8y5cvR1JSEmJj80YdwsLC8OBBXruc6dOnw9raGrNmzcK6detw9+5deHp6AshLeFu2bIlx48YhMjJSPdOaQqFgFwYiohcolQIb/+u9O6qlBy/YIfpPccsfDKSSfMkuAAgAEgDzwyLRxde5Spc3VORyjgo5tTAAeHp64t69e1rXqRLcsWPH5kt4ASAxMREzZszA77//jszMTAQEBODrr79GixYtdD4/pxYmourg8I3HGLcmHFYmBjjz0SswNWKLJqKivFj+cPlhsk77vdLAEbUdLGBqKIO5sQymRgYwN5LBzEgGMyMDmBnJYGokg/l//zczNoCpoazCJI2F0Vc5h675WoVNePWNCS8RVQfj14bj0PXHmNDGC7N7+eo7HKJKadPpe/j49ytldnxjAynM/0t+X0yUVf9XJcp5/+Yl0KZG/21vaABz4/yJtZFMWirf6uy9Eqe1nEN15LIs59A1X6uwJQ1ERFS2YhIycPjGYwB5vXeJqGRqO1jotN3AZjVhZ2GMjOxcZMgVyMhWID07F5nZCqRnK5CZnYuMbMV/t1wo/8sg5blKyHOzSz1uA6lEY0RZI2l+LlE2NZLB7Ln//y+xNoCRgRSf/H6lwpdzMOElIqqmNp25DyGAtnXt4WVvru9wiCqtQC9buFibID45S2viJwHgbG2CrwY10TnpE0JAnqvMS4rlucjM+e/fbO2Jct6/eYmy6v/59stRIEOuQLZCCQDIVQqkZuUiNSu39B6MF+8HgLjkLJy9m4Bgb7syO09RmPASEVVDWTkKbAu/DyDvYjUiKjmZVIK5vX0xZeMFSACNpFeV3s7t7VusEU6JRAITQxlMDGWl3hs7R5GXSGc+nzjLc5GR82Ki/L9kOuOFxFq13+PULCSk5xR5zsepWUVuU5aY8BIRVUN7LschMSMHrtYm6OTjqO9wiCq97n4uWDGyWb4Lt5wrYB9eQ5kU1qZSWJsavvSxTkU9Q8hPp4vcTt+z1jHhJSKqhjaczuuCM6KlBwxk0iK2JiJddPdzQRdf5wrbmqss6FrOEehlW96haWDCS0RUzVx5mIyL95NgKJNgSAs3fYdDVKXIpBK91qqWt7Io5ygL/FhPRFTNbDiVN7rbw88FDpacfZKIXo6qnMPZWrNswdnapMLMMMcRXiKiaiQ5Iwe7LuXNDDU6mBerEVHpqOjlHEx4iYiqke3nY5CVo4SPsyWae9TQdzhEVIVU5HIOljQQEVUTSqXApjP/tSIL9iiVGZaIiCoDJrxERNXEP1FPcfdpOiyNDdDPv6a+wyEiKjdMeImIqon1/12sNrB5LZgbs6KNiKoPJrxERNXAw6RMHLz2CAAwsqW7nqMhIipfTHiJiKqBLWfuQymAVt52qONoqe9wiIjKFRNeIqIqTp6rwNbw/y5Wa8lWZERU/TDhJSKq4vZeicfTtGw4WRnjFV8nfYdDRFTumPASEVVxG0/nXaw2PNADhjK+7RNR9cN3PiKiKuxaXArCoxNhIJVgWKCbvsMhItILJrxERFXYhv9Gd7s1dIaTlUkRWxMRVU1MeImIqqiUrBz8fvEhgLyZ1YiIqismvEREVdSO8w+Qka1APScLBHnZ6jscIiK9YcJLRFQFCSHU5QyjWnpAIpHoOSIiIv1hwktEVAWduvMMUU/SYW4kQ7+mNfUdDhGRXjHhJSKqgjacyhvd7d+sJixNDPUcDRGRfjHhJSKqYuKTs/B35CMAwKiWnvoNhoioAmDCS0RUxWw5ex8KpUCgly3qO1vqOxwiIr1jwktEVIXkKJTYcvY+gLyL1YiIiAkvEVGV8vfVR3icKoeDpTG6NXTWdzhERBUCE14ioipkw+loAEBIgBuMDPgWT0QEMOElIqoybj5Kxek7CZBJJQgJctd3OEREFQYTXiKiKmLjfxNNdGngBBdrUz1HQ0RUcVTIhFcul2PmzJlwdXWFqakpgoKCsH//fp32PXDgADp27Ah7e3vY2NggMDAQGzZsKOOIiYj0K02eix0XHgIARgXzYjUioudVyIR37NixWLJkCUaMGIGlS5dCJpOhZ8+eOHHiRKH7/fHHH+jatSuys7Mxb948LFy4EKamphg9ejS+/fbbcoqeiKj87bz4EGnyXNR2MEcrbzt9h0NEVKFIhBBC30E87+zZswgKCsLixYvx/vvvAwCysrLg5+cHR0dHnDx5ssB9u3btiqtXr+LOnTswNjYGAOTm5sLHxwfm5ua4dOmSznGkpKTA2toaycnJsLKyerk7RURUhoQQ6P7dcdx4lIq5vX0xrrWXvkMiIioXuuZrFW6ENzQ0FDKZDJMmTVIvMzExwYQJE3Dq1CnExMQUuG9KSgpq1KihTnYBwMDAAPb29jA1ZT0bEVVNZ+8m4MajVJgayjCgWS19h0NEVOFUuIT34sWLqFevXr4sPTAwEAAQERFR4L4dOnTA1atXMXv2bNy+fRtRUVFYsGABzp07hw8++KDQ88rlcqSkpGjciIgqgw3/XazWr6krrE0N9RwNEVHFY6DvAF4UFxcHFxeXfMtVy2JjYwvcd/bs2bh79y4WLlyIzz77DABgZmaG3377DX379i30vIsWLcL8+fNfInIiovL3ODULe6/EAwBGcmY1IiKtKtwIb2ZmpkZJgoqJiYl6fUGMjY1Rr149DBo0CFu2bMHGjRvRokULjBw5EqdPny70vLNmzUJycrL6VljpBBFRRbH1bAxylQLNPWqgoau1vsMhIqqQXnqENy0tDTdv3kR6ejratm370gGZmppCLpfnW56VlaVeX5Bp06bh9OnTuHDhAqTSvFx+yJAhaNiwId566y2cOXOmwH2NjY21JtpERBVVrkKJzWfuAwBGcXSXiKhAJR7hjY6ORt++fVGjRg0EBASgY8eO6nX//PMPfH19ceTIkWIf18XFBXFxcfmWq5a5urpq3S87Oxu//PILXn31VXWyCwCGhobo0aMHzp07h+zs7GLHQ0RUUR249hjxKVmwMzdCj0bO+g6HiKjCKlHCe//+fbRs2RJ79uxB3759ERwcjOe7mwUFBeHp06fYsmVLsY/t7++Pmzdv5rtoTDU66+/vr3W/Z8+eITc3FwqFIt+6nJwcKJVKreuIiCqrDaejAQBDA9xgbCDTbzBERBVYiRLeuXPnIjExEUePHkVoaCi6dOmisd7AwABt27bFP//8U+xjDxo0CAqFAqtWrVIvk8vlWLNmDYKCguDm5gYgL+m+fv26ehtHR0fY2Nhg586dGiO5aWlpCAsLg4+PD1uTEVGVcftxGv65/QxSCTA8yF3f4RARVWglquHdt28f+vfvj1atWhW4jYeHBw4dOlTsYwcFBWHw4MGYNWsWHj9+jDp16mDdunWIjo7GL7/8ot5u9OjROHr0qHpkWSaT4f3338cnn3yCli1bYvTo0VAoFPjll1/w4MEDbNy4sfh3lIiogtp0Jq8VWScfJ9SqYabnaIiIKrYSJbwJCQnw9PQsdBshhNaLz3Sxfv16zJ49Gxs2bEBiYiIaN26M3bt3o127doXu9/HHH8PLywtLly7F/PnzIZfL0bhxY4SGhmLgwIElioWIqKLJyM5F6PkHAIBRwbxYjYioKCVKeJ2cnHDr1q1Ct7l8+TLc3Uv2NZuJiQkWL16MxYsXF7hNQRfEDR8+HMOHDy/ReYmIKoNdEbFIzcqFp50Z2tax13c4REQVXolqeLt06YLdu3fj33//1br++PHjOHToEHr27PlSwRERkSYhBDacyitnGNnSA1KpRM8RERFVfCVKeD/55BOYmpqiXbt2WLhwIW7fvg0A+OuvvzB79mx0794d9vb2mDFjRqkGS0RU3V24n4jIuBQYG0gxqHktfYdDRFQplKikwdPTE/v27cOwYcMwe/ZsSCQSCCHQq1cvCCHg7u6O0NBQrVMEExFRyalGd/s0cYWNmZGeoyEiqhxKPNNaUFAQbt26hbCwMJw5cwYJCQmwsrJCUFAQ+vbtCyMjvhETEZWmp2ly7LkcDwAYHeyp32CIiCqRl5pa2MDAAP3790f//v1LKx4iIirAtvAYZCuUaOJmg0a1rPUdDhFRpVGiGl6FQoGUlBQolcpC13NmMyKi0qFQCmw+cx8AMKolW5ERERVHiRLe+fPnw9HREc+ePdO6PiEhAU5OTli4cOFLBUdERHkOX3+Mh0mZsDEzRK/GvD6CiKg4SpTw7t69G507d4aDg4PW9Q4ODnjllVewa9eulwqOiIjyrD+dd7Ha0BZuMDGU6TkaIqLKpUQJ7507d+Dj41PoNvXr18fdu3dLFBQREf1P9NN0HLv5BBIJMCKI5QxERMVVooQ3JycHUmnhu0okEmRlZZUoKCIi+p9NZ/JGdzvUc4C7nZmeoyEiqnxKlPDWqVMHhw4dKnSbQ4cOwcvLq0RBERFRnsxsBX499wAAMCqYo7tERCVRooR3wIABiIiIwJw5c/J1YlAoFJg9ezYiIiIwePDgUgmSiKi6Cvs3FsmZOahVwxTt6znqOxwiokpJIoQQxd0pLS0NAQEBuHnzJry9vdGxY0fUrFkTDx8+xOHDhxEVFYUGDRrg9OnTsLCwKIu4y1xKSgqsra2RnJwMKysrfYdDRNVUn+Un8O+DZHzYwwevt/fWdzhERBWKrvlaiSaesLCwwLFjxzBlyhTs3LkTt2/fVq+TSqUYNGgQfvjhh0qb7BIRVQQRMUn490EyjAykGNLCTd/hEBFVWiWeac3BwQGhoaF49OgRzp07h+TkZNjY2KBFixZwdOTXbkSknUIpcPZuAh6nZsHR0gSBXraQSSX6DqtC2nAq72K1Xo1cYGvO6dqJiErqpaYWBgAnJye8+uqrpRELEVVxe6/EYX5YJOKS/9fBxcXaBHN7+6K7HydTeF5iejbC/o0FwIvViIheVokuWiMiKq69V+IwZeMFjWQXAOKTszBl4wXsvRKnp8gqpl/PxSA7Vwm/mlbwd7PRdzhERJVaiUd4IyMjsXz5coSHhyMpKSlftwYgrxdvVFTUSwVIRJWfQikwPywS2q6QFQAkAOaHRaKLrzPLGwAolQIb/+u9O6qlByQSPiZERC+jRAnv0aNH0b17d8jlchgYGMDJyQkGBvkPVYIGEERUBZ29m5BvZPd5AkBcchbO3k1AsLdd+QVWQR299QQxCZmwMjFAnyY19R0OEVGlV6KE98MPP0Rubi5+/vlnjBkzBjIZ53UnooI9TtVt1kVdt6vqVBerDW7hBlMjvr8SEb2sEtXwXrp0CcOGDcP48eOZ7BJRkRwtTXTabs+/cbgam1zG0VRsMQkZOHzjMQBgZEterEZEVBpKNMJrbm7O1mNEpLPmHjVgYihFVo6y0O32RT7CvshHaOhqhaEBbujbpCaszQzLKcqKYdOZ+xACaFvXHl725voOh4ioSijRCG/Pnj1x/Pjx0o6FiKogpVLg452XC0x2Jf/dpneqg1cbucBQJsHV2BTM2XUVAZ8fwJtbLuKf20+hVFb9awKychTYFn4fQN7FakREVDpKNMK7ePFitGnTBm+++Sa++OILmJmZlXZcRFQFCCEwL+wqtp9/AKkEmNDGC7v/jdO4gM35hT68CenZ+P3iQ/x6LgbX41Pxx6VY/HEpFrVqmGJwczcMalELNW1M9XWXytSey3FIzMiBq7UJOvnwWzQiotIiESVopdCpUyckJSXh0qVLMDc3R7169bTOXyyRSHDw4MFSCbS86To3MxFpJ4TAF39dx8pjdyCRAEuGNEH/prV0nmlNCIHLD5OxLTwGf0TEIlWeCwCQSIA2dewxNMANXXydYGxQda4j6P/DP7h4PwkzutXHGx3r6DscIqIKT9d8rUQJr1SqWyWERCLR2p+3MmDCS/RyvjtwE98duAUA+Lx/IwwPci/xsTKzFdh7NQ6/hj/AqTvP1MttzAzRz78mhga4oYFL5X6dXnmYjF7/dwKGMglOftgZDpbG+g6JiKjC0zVfK1FJg1JZ+IUnRFS9/Xg0Sp3szunl+1LJLgCYGsnQv2kt9G9aC/eepWP7uQcIPf8A8SlZWHsyGmtPRqNRTWsMCXBDnyausDatfBe6qVqR9fBzYbJLRFTKSjTCWx1whJeoZNadjMbcP64CQJl+Na9QChy79QTbz8Vgf+Qj5Cjy3sqMDaTo4eeMIQFuaOllB2klmLktOSMHQYsOICtHidDXg9HC01bfIRERVQplOsJLRKTNr+Ex6mR3eqc6ZVqHKpNK0LG+IzrWd8SzNDl2/neh281Hafg9Iha/R8TC3dYMg5vXwqAWteBiXXEvdNt+PgZZOUr4OFuiuUcNfYdDRFTlvNQI74MHD3D48GHExsZCLpfnP7hEgtmzZ79UgPrCEV6i4tkV8RBvb4uAEMDENl74+NUGkEjKd3RVCIFLD/IudAu7FIu0/y50k0qAtnUdMDTADa80cIKRQYk6MpYJpVKg85KjuPs0HQv7+2FEENuRERHpqkwvWgOAGTNmYOnSpRoXpQkh1H/gVP/nRWtEVd/eK/F4Y/MFKJQCI4Lc8Vk/v3JPdl+Uma3Anstx+PVcDM7cTVAvtzU3Ul/oVt/ZUo8R5jl28wlGrz4LS2MDnP6oM8yN+cUbEZGudM3XSjTM8dNPP+Gbb75Bx44dERoaCiEExowZgy1btuD111+HgYEBBg8ejEOHDpUoeLlcjpkzZ8LV1RWmpqYICgrC/v37dd5/27ZtCA4Ohrm5OWxsbNCqVasSx0JEhTty4zGmb8lLdgc0q4kFffWf7AJ5F7oNbF4L2yYH48j7HTC1gzccLY2RkJ6N1f/cRbfvjqHv8hPYdOYeUrJy9BbnhtN5F6sNbF6LyS4RURkp0QhvQEAAnj17htu3b0MqlUIqlWLevHmYM2cOAODo0aPo0qULNm/ejEGDBhU7qJCQEISGhuLtt99G3bp1sXbtWoSHh+Pw4cNo06ZNofvOmzcPn376KQYNGoTOnTsjJycHV65cQevWrTFq1CidY+AIL1HRTkY9xbg14ZDnKvFqYxcsHeoPA1nFKRd4Ua5CiWO3nuDX8Ac4cO0Rcv+bvc3EUIqefi4YEuCGIC/bckvYHyZlou2Xh6AUwIF326GOo/5HnImIKpMyLWmwtLTEqFGj8MMPPwDI68v7ySef4NNPP1Vv079/f8TFxeH06dPFOvbZs2cRFBSExYsX4/333wcAZGVlwc/PD46Ojjh58mSB+54+fRqtWrXCN998g3feeae4d0sDE16iwp2/l4BRv5xFRrYCrzRwwoqRzWBYgZPdFz1Nk2PnhYfYdi4Gtx+nqZd72JlhSAs3DGxWC87WJmUaw+J91/H94Si08rbD5tdalum5iIiqojItaQAAGxsb9f/Nzc3x7NkzjfX169fH1atXi33c0NBQyGQyTJo0Sb3MxMQEEyZMwKlTpxATE1Pgvt999x2cnZ3x1ltvQQiBtLS0ArclopK7/CAZY1eHIyNbgbZ17bF8eNNKlewCgL2FMV5rVxv732mHHVNbYViAG8yNZLj3LAOL991Aqy8OYtyas9h7JQ7ZuaXfe1yeq8C28Lz3s1EteaEaEVFZKtFfqJo1a+LBgwfqn729vXHmzBmNba5cuQJzc/NiH/vixYtapyoODAwEAERERBS478GDBxEQEIBly5bBwcEBlpaWcHFxwfLly4sdBxFpdyM+FaNWn0GqPBeBXrZYNaoFTAwr7/S+EokEzdxr4IuBjRH+yStYPKgxAjxrQCmAwzee4PWNFxC86CA+2x2JW49SS+28e6/E42laNpysjPGKr1OpHZeIiPIr0RUSrVu3xvHjx9U/9+3bF5999hkmT56MPn364MSJE/jrr78wcODAYh87Li4OLi4u+ZarlsXGxmrdLzExEU+fPsU///yDQ4cOYe7cuXB3d8eaNWswffp0GBoaYvLkyQWeVy6Xa7RWS0lJKXbsRFVd1JM0jPj5DJIycuDvZoPVYwNgalR5k90XmRkZYHALNwxu4YY7T9Lw67kH+O3CAzxJlePnE3fx84m7aOpugyEt3NCrsQssTUo+o5tqZrXhgR6VbnSciKiyKVEN75EjR/Dll1/ixx9/hIeHB9LS0tC+fXtcvHgREokEQgh4enri8OHD8PAo3ld13t7eqF+/Pvbs2aOx/M6dO/D29sa3336Lt99+O99+MTExcHfPm75069atGDp0KIC8aZAbNWqElJSUQssh5s2bh/nz5+dbzhpeojwxCRkY/OMpxKdkwdfFClteawlrs8o3hW9x5SqUOHLjCX49F4ND1x+rL3QzNZShZyMXDA1wQ4BnjWJd6BYZm4Key47DQCrByQ87wdGqbGuFiYiqqjLvw/uinJwc7Nq1C1FRUfDw8EDv3r1LVNLg5+cHJycnHDx4UGN5ZGQkGjZsiB9//FHrSO3Tp0/h4OAAQ0NDZGZmQib736jTp59+irlz5+LevXvqpPhF2kZ43dzcmPASAYhLzsTgH0/hQWIm6jpaYOuklrCzMNZ3WOXuSaocOy48wLZzMbjzJF293MveHINb1MKgZrUKTF4VSoGzdxPwODULf1yKxcFrj/FqYxd8P7xZeYVPRFTllPvUwoaGhiVqQfYiFxcXPHz4MN/yuLg4AICrq6vW/WxtbWFiYgIbGxuNZBcAHB0dAeSVPRSU8BobG8PYuPr9AScqypNUOUb8dAYPEjPhaWeGTRODqmWyCwAOlsaY3N4bk9rVxoX7ifg1/AHC/o3F3afp+GrvDXzz9010qOeAIQFu6OTjqC5V2HslDvPDIhGXnKVxvPpObENGRFQeKlyXc39/fxw+fBgpKSkambrqojh/f3+t+0mlUvj7+yM8PBzZ2dkwMjJSr1PV/To4OJRd4ERVUGJ6Nkb+fAZ3nqajpo0pNr3Wkl+/I+9Ct+YetmjuYYs5vX3x5795M7qdu5eIg9cf4+D1x7C3MMKAZrXgYm2CT8Mioe2rtG/330Q9Jwt098t/3QIREZUenUoaPv30U0gkErzxxhuwtbXV6Ldb6MElEsyePbtYAZ05cwYtW7bU6MMrl8vh5+cHOzs7dV/f+/fvIyMjAz4+Pup9v/vuO7zzzjtYtWoVXnvtNQB5PXwbNmwIExOTYrVJYx9equ5SsnIw4qczuPwwGY6Wxtj+ejA87IpfplSd3H6chu3nYvDbhYd4miYvcnsJAGdrE5yY2Qkyqf5npyMiqmxKtYZXKpVCIpHg2rVrqFevHqRS3a4olkgkUCgUukf9nyFDhmDnzp145513UKdOHaxbtw5nz57FwYMH0a5dOwBAhw4dcPToUTwffmZmJgICAnDz5k289dZbcHd3x4YNG3DhwgWEhYWhR48eOsfAhJeqs3R5LkavPovz9xJhZ26EbZNbchawYshRKHH4+mP8ePQOLtxPLHL7La+1RLC3XTlERkRUtZRqDe/hw4cBQF3/qvq5rKxfvx6zZ8/Ghg0bkJiYiMaNG2P37t3qZLcgpqamOHToED744AOsXr0a6enp8Pf3x59//olu3bqVacxEVUVWjgIT153D+XuJsDIxwIYJQUx2i8lQJkXXhs7IzFHolPA+Ts0qchsiIiq5UuvSUNVwhJeqI3muApPWn8fRm09gYWyAjROD4O9mo++wKq1TUc8Q8lPR06tzhJeIqGTKdGrhTp06Fbs2l4gqtlyFEm9uuYijN5/AxFCK1WMDmOy+pEAvW7hYm6Cg6lwJABdrEwR62ZZnWERE1U6JEt4zZ86UqDaXiComhVLgve2XsO/qIxgZSPHz6AAmYaVAJpVgbm9fAMiX9Kp+ntvblxesERGVsRIlvD4+Prh3715px0JEeqBUCny04zJ2RcTCQCrBihHN0Kauvb7DqjK6+7lgxchmcLbWbOfmbG2CFSObsSUZEVE5KFEf3unTp2PatGmIjIyEr69vacdEROVECIH5YVex7VwMpBJgWUhTdG7gpO+wqpzufi7o4uusnmnN0TKvjIEju0RE5aNECW/t2rXRoUMHtGzZEpMnT0ZAQACcnJy0ziVfVGcFItIPIQS+2Hsd607dg0QCfD24CXo24mhjWZFJJbwwjYhIT0rUpUHVl1e1q7ZEV6Wy1vqySwNVdUsP3MK3B24CAD7v3wjDg7RPu01ERFRRlWof3hfNmTOn0CSXiCq2lUej1Mnu7F6+THaJiKhKYx/eAnCEl6qq9aeiMWdX3jTbM7rVxxsd6+g5IiIiopIp0z68RFQ5/XouRp3sTutYh8kuERFVC0x4iaqJXREPMfO3fwEAE9p44b2u9fQcERERUfkoccIbExODyZMnw9vbG6amppDJZPluBgYlKhEmolK272o83v31EoQARgS545NXG7AOn4iIqo0SZaR37txBUFAQEhMT0bBhQ8jlcnh4eMDExAR37txBTk4OmjRpAhsbm1IOl4iK68iNx5i++SIUSoEBzWpiQV8/JrtERFStlGiEd/78+UhOTsbBgwdx6dIlAMC4ceNw7do1REdHo0+fPkhPT0doaGipBktExXMq6hkmbziPbIUSrzZywVcDG0PKyQ6IiKiaKVHCe+DAAfTs2RPt27dXL1M1e3BxccG2bdsAAB999FEphEhEJXH+XiImrAuHPFeJVxo44tuh/jCQsWyfiIiqnxL99Xv69Cl8fHzUPxsYGCAjI0P9s7GxMbp06YLdu3e/fIREVGxXHiZj7OqzyMhWoG1deywf3gxGBkx2iYioeirRX0B7e3ukp6dr/BwdHa2xjYGBAZKSkl4mNiIqgRvxqRj1yxmkynMR6GmLVaNawMRQpu+wiIiI9KZECW/dunURFRWl/jkwMBD79u3DnTt3AABPnjxBaGgovL29SydKItLJnSdpGPHzGSRm5KCJmw1+GdsCpkZMdomIqHrTOeGVy+Xq//fo0QOHDh1Sj+C+/fbbSE1NRePGjREQEIB69eohPj4e06dPL/WAiUi7mIQMjPj5DJ6myeHrYoX14wJhaWKo77CIiIj0TueE18XFBdOmTcOFCxcwdepUHD16FDJZ3shRhw4dsHXrVnh4eODKlStwcnLCsmXL8Nprr5VZ4ET0P3HJmRj+82nEJWehjqMFNkwIhLUZk10iIiIAkAhVe4UimJmZISsrCxKJBE2aNMGECRMwYsSIKttrV9e5mYn07UmqHENXncKdJ+nwsDPDr5OD4WRlou+wiIiIypyu+ZrOI7yPHj3CihUr0KJFC0RERODNN9+Eq6srhg8fjoMHD5ZK0ERUPInp2Rj1yxnceZKOmjam2DQxiMkuERHRC3Qe4X1eZGQkVq9ejU2bNuHRo0eQSCRwd3fH+PHjMXbsWLi5uZVFrOWKI7xU0aVk5WDET2dw+WEyHC2N8evkYHjam+s7LCIionKja75WooRXRaFQICwsDKtXr8bevXuRm5sLqVSKLl26YMKECejbty8MDStnHSETXqrI0uW5GL36LM7fS4StuRG2TWqJuk6W+g6LiIioXJVLwvu8R48eYf369VizZg2uX78OiUQCOzs7PH78uDQOX+6Y8FJFlZWjwPi14TgZ9QxWJgbYMqklGrpa6zssIiKiclfqNbxFcXJywowZM7Bt2za0bt0aQgg8e/astA5PRADkuQq8vvE8TkY9g4WxAdZPCGKyS0REVASD0jhIamoqNm/ejF9++QXnz5+HEALm5uYYMmRIaRyeiADkKpR4a0sEjtx4AhNDKVaPDYC/m42+wyIiIqrwXirhPXz4MFavXo2dO3ciMzMTQgi0bNkSEyZMwNChQ2FhYVFacRJVawqlwHvbL2Hv1XgYyaT4aXQLBHrZ6jssIiKiSqHYCe+DBw+wZs0arF27FtHR0RBCwMHBAa+//jomTJiABg0alEWcRNWWUinw8c7L2BURCwOpBD+MaIa2dR30HRYREVGloXPCu23bNqxevRqHDh2CQqGAVCpFt27d1N0YDAxKpTqCiJ4jhMCnuyOxNTwGUgmwdFhTvOLrpO+wiIiIKhWds9SQkBAAgJeXF8aNG4exY8eiVq1aZRYYUXUnhMCXe29g7cloAMDiQU3wamMX/QZFRERUCRUr4Z0wYQI6depUlvEQ0X/+79Bt/Hg0CgCwsL8fBjbnB0wiIqKS0Dnh3bRpU1nGQUTPWXUsCkv23wQAzO7lixFBHnqOiIiIqPIqtT68pUkul2PmzJlwdXWFqakpgoKCsH///mIfp0uXLpBIJJg2bVoZRElUNjacisbne64DAGZ0q48Jbbz0HBEREVHlViET3rFjx2LJkiUYMWIEli5dCplMhp49e+LEiRM6H2PHjh04depUGUZJVPq2n4vB7F1XAQBvdPTGGx3r6DkiIiKiyq/CJbxnz57F1q1bsWjRIixevBiTJk3CoUOH4OHhgQ8++ECnY2RlZeG9997DzJkzyzhaotLzx6VYzPztXwDA+NZeeL9rfT1HREREVDVUuIQ3NDQUMpkMkyZNUi8zMTHBhAkTcOrUKcTExBR5jK+++gpKpRLvv/9+WYZKVGIKpcCpqGfYFfEQp6KeYe/lOLyzLQJKAQwPcsfsXg0gkUj0HSYREVGVUOGa5168eBH16tWDlZWVxvLAwEAAQEREBNzc3Arc//79+/jiiy+wevVqmJqa6nxeuVwOuVyu/jklJaWYkRPpZu+VOMwPi0Rccla+dQOa1sRnff2Y7BIREZWiCjfCGxcXBxeX/L1GVctiY2ML3f+9995D06ZNMWzYsGKdd9GiRbC2tlbfCkuqiUpq75U4TNl4QWuyCwCdGzhCKmWyS0REVJoqXMKbmZkJY2PjfMtNTEzU6wty+PBh/Pbbb/juu++Kfd5Zs2YhOTlZfdOldIKoOBRKgflhkRAFrJcA+OzPa1AoC9qCiIiISqLClTSYmppqlBaoZGVlqddrk5ubizfffBOjRo1CQEBAsc9rbGysNdEmKi1n7yYUOLILAAJAXHIWzt5NQLC3XfkFRkREVMVVuITXxcUFDx8+zLc8Li4OAODq6qp1v/Xr1+PGjRtYuXIloqOjNdalpqYiOjoajo6OMDMzK/WYiXTxOLXgZLck2xEREZFuKlxJg7+/P27evJnvorEzZ86o12tz//595OTkoHXr1vDy8lLfgLxk2MvLC3///XeZxk5UGEdLk1LdjoiIiHRT4UZ4Bw0ahK+//hqrVq1StxWTy+VYs2YNgoKC1BeT3b9/HxkZGfDx8QEADBs2TGsy3L9/f/Ts2ROvvfYagoKCyu1+EL0owLMGTA1lyMxRaF0vAeBsbYJAL9vyDYyIiKiKq3AJb1BQEAYPHoxZs2bh8ePHqFOnDtatW4fo6Gj88ssv6u1Gjx6No0ePQoi8C3x8fHzUye+LvLy80K9fv/IIn6hAa/6JLjTZBYC5vX0hY5cGIiKiUlXhEl4grwRh9uzZ2LBhAxITE9G4cWPs3r0b7dq103doRCXy99V4fP7XNQDA4Oa1cOL2U40L2JytTTC3ty+6++VvyUdEREQvRyJUQ6SkISUlBdbW1khOTs43CQZRcVx5mIzBP55CZo4CI1u6Y0FfPyhFXteGx6lZcLTMK2PgyC4REVHx6JqvVcgRXqKqIj45CxPXnUNmjgJt69pjbu+GkEgkkEnA1mNERETlpMJ1aSCqKjKyczFxfTjiU7JQx9ECy4c3g6GMLzkiIqLyxr++RGVAqRR4d9slXHmYAltzI6weEwBrU0N9h0VERFQtMeElKgNf7buBvVfjYSSTYtWo5nC344QnRERE+sKEl6iU/XouBj8ejQIAfDWoMVp4sq8uERGRPjHhJSpFp6Ke4aMdlwEAb3aqg35Na+o5IiIiImLCS1RK7j5Nx+sbzyNXKdCrsQve6VJP3yERERERmPASlYqkjGyMXxuO5MwcNHW3wdeDm0AiYV9dIiKiioAJL9FLys5V4vWN53H3aTpq2phi1agWMDGU6TssIiIi+g8TXqKXIITAJ79fxuk7CbAwNsDqsQFwsDTWd1hERET0HCa8RC9h5bE7+PXcA0glwP8Nb4r6zpb6DomIiIhewISXqIT2XonHl3uvAwDm9PJFx/qOeo6IiIiItGHCS1QCVx4m451tERACGB3sgbGtvfQdEhERERWACS9RMcUnZ2HCunBk5ijQvp4D5vTy1XdIREREVAgmvETFkC7PxYR14XiUIkc9Jwv83/CmMJDxZURERFSR8S81kY4USoG3t0XgamwK7MyN8MuYAFiZGOo7LCIiIioCE14iHX219zr2Rz6CkYEUq0a3gJutmb5DIiIiIh0w4SXSwdaz97Hy2B0AwOJBjdHco4aeIyIiIiJdMeElKsLJ20/xye9XAABvv1IXff1r6jkiIiIiKg4mvESFiHqShtc3nkeuUqBPE1e81bmuvkMiIiKiYmLCS1SAxPRsjF8bjpSsXDRzt8FXgxpDIpHoOywiIiIqJia8RFpk5yoxeeN53HuWgVo1TLFqdAuYGMr0HRYRERGVABNeohcIIfDRzss4ezcBlsYGWD02APYWxvoOi4iIiEqICS/RC1YcjULo+QeQSSVYPqIZ6jlZ6jskIiIieglMeIme89flOHy19wYAYF5vX7Sv56DniIiIiOhlMeEl+s+/D5Lwzq8RAICxrTwxKthTr/EQERFR6WDCSwQgNikTE9adQ1aOEh3qO+CTVxvoOyQiIiIqJUx4qdpLl+di4rpzeJIqR30nS/xfSFMYyPjSICIiqir4V52qNYVS4K2tFxEZlwJ7C2P8MrYFLE0M9R0WERERlSImvFStLdpzDQeuPYaRgRQ/jW6OWjXM9B0SERERlTImvFRtbT5zHz+fuAsA+GZwEzR1r6HniIiIiKgsVMiEVy6XY+bMmXB1dYWpqSmCgoKwf//+IvfbsWMHhg4ditq1a8PMzAz169fHe++9h6SkpLIPmiqVE7eeYvauKwCAd7vUQ+8mrnqOiIiIiMqKRAgh9B3Ei0JCQhAaGoq3334bdevWxdq1axEeHo7Dhw+jTZs2Be5nb28PV1dX9OvXD+7u7rh8+TJ+/PFH1K5dGxcuXICpqanOMaSkpMDa2hrJycmwsrIqjbtFFcTtx2no/8M/SM3KRf+mNbFkSBNIJBJ9h0VERETFpGu+VuES3rNnzyIoKAiLFy/G+++/DwDIysqCn58fHB0dcfLkyQL3PXLkCDp06KCxbP369RgzZgx++uknTJw4Uec4mPBWTQnp2ej3/T+4n5CBFh41sOm1IBgbyPQdFhEREZWArvlahStpCA0NhUwmw6RJk9TLTExMMGHCBJw6dQoxMTEF7vtisgsA/fv3BwBcu3at1GOlykWeq8DkDedwPyEDbramWDmqOZNdIiKiasBA3wG86OLFi6hXr16+LD0wMBAAEBERATc3N52PFx8fDyCv3KEwcrkccrlc/XNKSorO56CKTwiBWb9dRnh0IiyNDbB6TADsLIz1HRYRERGVgwo3whsXFwcXF5d8y1XLYmNji3W8L7/8EjKZDIMGDSp0u0WLFsHa2lp9K05STRXf94dvY8fFh5BJJfhhZDPUdbLUd0hERERUTipcwpuZmQlj4/wjbyYmJur1utq8eTN++eUXvPfee6hbt26h286aNQvJycnqW2GlE1S5/PlvHL7++yYAYH6fhmhb10HPEREREVF5qnAlDaamphqlBSpZWVnq9bo4fvw4JkyYgG7dumHhwoVFbm9sbKw10abKLSImCe/+GgEAGN/aCyNbeug3ICIiIip3FW6E18XFBXFxcfmWq5a5uhbdL/XSpUvo06cP/Pz8EBoaCgODCpfXUzl4mJSJievOQZ6rRCcfR3z8agN9h0RERER6UOESXn9/f9y8eTPfRWNnzpxRry9MVFQUunfvDkdHR+zZswcWFhZlFSpVYGnyXExYG46naXL4OFtiWUhTyKTstUtERFQdVbiEd9CgQVAoFFi1apV6mVwux5o1axAUFKS+mOz+/fu4fv26xr7x8fHo2rUrpFIp9u3bBwcH1mpWRwqlwJtbLuJ6fCrsLYzxy9gAWBhzlJ+IiKi6qnBZQFBQEAYPHoxZs2bh8ePHqFOnDtatW4fo6Gj88ssv6u1Gjx6No0eP4vl5M7p37447d+7ggw8+wIkTJ3DixAn1OicnJ3Tp0qVc7wvpx8I/r+HQ9ccwNpDi5zEtUNNG9xn2iIiIqOqpcAkvkDc72uzZs7FhwwYkJiaicePG2L17N9q1a1fofpcuXQIAfPXVV/nWtW/fnglvNbDx9D2s/ucuAODbof7wd7PRb0BERESkdxVuauGKglMLVz7Hbj7BuLXhUCgFZnSrjzc61tF3SERERFSGKu3UwkQlcetRKt7YdAEKpcCAZjUxtYO3vkMiIiKiCoIJL1V6z9LkGL8uHKnyXAR62mLRgEaQSNiRgYiIiPIw4aVKLStHgUkbziMmIRMedmb4cVRzGBvI9B0WERERVSBMeKnSEkJg1o7LOH8vEVYmBvhlTABszY30HRYRERFVMEx4qdL6v0O3sfPiQ8ikEqwY2Rx1HDnJCBEREeXHhJcqpbBLsViy/yYAYEFfP7SuY6/niIiIiKiiYsJLlc6F+4l4b3tez+WJbbwwPMhdzxERERFRRcaElyqVB4kZmLT+HLJzlXilgRNm9Wyg75CIiIiogmPCS5VGalYOJqw9h6dp2fB1scLSYf6QSdl+jIiIiArHhJcqhVyFEtO3XMSNR6lwtDTGL2NbwNy4Qs6MTURERBUME16qFD778xqO3HgCE0Mpfh7TAi7WpvoOiYiIiCoJJrxU4a0/FY21J6MBAN8N9UfjWjZ6jYeIiIgqFya8VKEdufEY8/64CgD4oHt9dPdz0XNEREREVNkw4aUK6+ajVEzffBFKAQxuXgtT2nvrOyQiIiKqhJjwUoX0NE2O8WvDkSrPRaCXLRb2bwSJhB0ZiIiIqPiY8FKFk5WjwKT15/AgMROedmZYObI5jAz4q0pEREQlwyyCKhQhBD4I/RcX7ifBysQAv4wNQA1zI32HRURERJUYE16qUJYevIU/LsXCQCrBj6Oaw9vBQt8hERERUSXHzv2kVwqlwNm7CXicmoVbj1Kx/HAUAOCzfn5o5W2v5+iIiIioKmDCS3qz90oc5odFIi45S2N5F18nDAt011NUREREVNWwpIH0Yu+VOEzZeCFfsgsAByIfYe+VOD1ERURERFURE14qdwqlwPywSIhCtpkfFgmFsrAtiIiIiHTDkgYqF0IIxCRk4vz9BPz5b5zWkV31tgDikrNw9m4Cgr3tyi9IIiIiqpKY8FKZyMpR4MrDZJy/l4gL9xNx/l4SnqbJi3WMx6kFJ8VEREREumLCS6XicUoWzt9LzLvdT8SVh8nIUWiWJBjKJPCraQ0XKxPsuRJf5DEdLU3KKlwiIiKqRpjwUrHlKpS4Hp/63OhtIh4kZubbzt7CCM3ca6C5R97Nr6Y1TAxlUCgFLn55CPHJWVrreCUAnK1NEOhlW+b3hYiIiKo+JrxUpKSMbFy8n6Qewb30IAkZ2QqNbaQSoL6zFZp72OQluO62cLM1hUQiyXc8mVSCub19MWXjBUgAjaRXtfXc3r6QSfPvS0RERFRcTHhJg1IpcOdpGi7cS1KXJ9x+nJZvO0tjAzT1qIHm/43gNnGzhqWJoc7n6e7nghUjm+Xrw+tsbYK5vX3R3c+lVO4PERERERPeai5dnotLD5Jw4b/R2wv3k5CcmZNvu9r25mjm8b/yhDoOFpC+5Ahsdz8XdPF1Vs+05miZV8bAkV0iIiIqTUx4qxEhBB4kZuLC/cS8BPd+Iq7Fpebrd2tsIEUTN1VpQg00dbeBnYVxmcQkk0rYeoyIiIjKFBPeKkyeq8DV2BT16O35e4l4nJq/NZirtYnG6G0DFysYyjgnCREREVUNFTLhlcvlmDNnDjZs2IDExEQ0btwYn332Gbp06VLkvg8fPsQ777yDv//+G0qlEh07dsS3336L2rVrl0Pk+vUkVf6/0dt7ifj3YTKyc5Ua2xhIJWjoaqVOcJu514CrjameIiYiIiIqexUy4R07dixCQ0Px9ttvo27duli7di169uyJw4cPo02bNgXul5aWho4dOyI5ORkfffQRDA0N8e2336J9+/aIiIiAnV3F/OpcoRTFrmNVKAVuxKfi/HMJ7v2EjHzb2ZprtgZrVNMapkaysrorRERERBWORAihrRWq3pw9exZBQUFYvHgx3n//fQBAVlYW/Pz84OjoiJMnTxa471dffYWZM2fi7NmzCAgIAABcv34dfn5++OCDD/D555/rHEdKSgqsra2RnJwMKyurl7tThdh7JS5fpwIXLZ0KkjNzEBGT1znhwr1ERMQkIU2eq3EsiQSo52ipUZ7gaWemtTUYERERUWWna75W4RLeDz74AEuWLEFCQoJG4IsWLcJHH32E+/fvw83NTeu+gYGBAPKS5ud169YNUVFRuH37ts5xlEfCu/dKHKZsvJBv8gVVb9rRwR7IUQhcuJeIm49T8eIzZWFsgKbuNuoRXH93G1gVozUYERERUWWma75W4UoaLl68iHr16uULWpXMRkREaE14lUol/v33X4wfPz7fusDAQPz9999ITU2FpaVl2QReTAqlwPywSK0zjamWrT91T2O5h50ZmrvXUI/g1nOyZAsvIiIioiJUuIQ3Li4OLi75Jx1QLYuNjdW6X0JCAuRyeZH71q9fX+v+crkccvn/OhikpKQUO/biOHs3QaOMoSC9m7igd2NXNPOoAfsyag1GREREVJVVuN5TmZmZMDbOn9iZmJio1xe0H4AS7QvklUxYW1urbwWVTZSWx6lFJ7sA8EoDJ3Rt6Mxkl4iIiKiEKlzCa2pqqjHSqpKVlaVeX9B+AEq0LwDMmjULycnJ6ltMTEyxYy8OR0uTUt2OiIiIiLSrcCUNLi4uePjwYb7lcXFxAABXV1et+9na2sLY2Fi9XXH2BfJGhrWNDpeVQC9buFibID45S2sdrwSAs3VeizIiIiIiKrkKN8Lr7++Pmzdv5quhPXPmjHq9NlKpFI0aNcK5c+fyrTtz5gxq165dYS5YA/Km1J3b2xdAXnL7PNXPc3v78qI0IiIiopdU4RLeQYMGQaFQYNWqVeplcrkca9asQVBQkLq29v79+7h+/Xq+fcPDwzWS3hs3buDQoUMYPHhw+dyBYuju54IVI5vB2VqzbMHZ2gQrRjbT6MNLRERERCVT4frwAsCQIUOwc+dOvPPOO6hTpw7WrVuHs2fP4uDBg2jXrh0AoEOHDjh69CieDz81NRVNmzZFamoq3n//fRgaGmLJkiVQKBSIiIiAg4ODzjGU18QTQMlmWiMiIiKq7iptH14AWL9+PWbPno0NGzYgMTERjRs3xu7du9XJbkEsLS1x5MgRvPPOO/jss8+gVCrRoUMHfPvtt8VKdsubTCpBsHfFnPaYiIiIqLKrkCO8FUF5jvASERERUfHpmq9VuBpeIiIiIqLSxISXiIiIiKo0JrxEREREVKUx4SUiIiKiKo0JLxERERFVaRWyLVlFoGpe8eKMb0RERERUMajytKKajjHhLUBqaioAqGd2IyIiIqKKKTU1FdbW1gWuZx/eAiiVSsTGxsLS0hISSdnPepaSkgI3NzfExMSw7281wee8+uFzXj3xea9++JyXHyEEUlNT4erqCqm04EpdjvAWQCqVolatWuV+XisrK744qhk+59UPn/Pqic979cPnvHwUNrKrwovWiIiIiKhKY8JLRERERFUaE94KwtjYGHPnzoWxsbG+Q6Fywue8+uFzXj3xea9++JxXPLxojYiIiIiqNI7wEhEREVGVxoSXiIiIiKo0JrxEREREVKUx4SUiIiKiKo0Jr57J5XLMnDkTrq6uMDU1RVBQEPbv36/vsKiMhIeHY9q0aWjYsCHMzc3h7u6OIUOG4ObNm/oOjcrRwoULIZFI4Ofnp+9QqIxduHABffr0ga2tLczMzODn54dly5bpOywqI7du3cKwYcNQq1YtmJmZwcfHB59++ikyMjL0HVq1xy4NehYSEoLQ0FC8/fbbqFu3LtauXYvw8HAcPnwYbdq00Xd4VMoGDRqEf/75B4MHD0bjxo0RHx+P5cuXIy0tDadPn2YCVA08ePAA9evXh0QigaenJ65cuaLvkKiM/P333+jduzeaNm2KoUOHwsLCAlFRUVAqlfjqq6/0HR6VspiYGDRu3BjW1tZ4/fXXYWtri1OnTmHt2rXo06cPdu3ape8QqzUmvHp09uxZBAUFYfHixXj//fcBAFlZWfDz84OjoyNOnjyp5wiptJ08eRItWrSAkZGRetmtW7fQqFEjDBo0CBs3btRjdFQehg0bhidPnkChUODp06dMeKuolJQU1KtXD61atUJoaCikUn6hWtV9/vnn+Pjjj3HlyhU0bNhQvXzMmDFYv349EhISUKNGDT1GWL3xFahHoaGhkMlkmDRpknqZiYkJJkyYgFOnTiEmJkaP0VFZaNWqlUayCwB169ZFw4YNce3aNT1FReXl2LFjCA0NxXfffafvUKiMbd68GY8ePcLChQshlUqRnp4OpVKp77CoDKWkpAAAnJycNJa7uLhAKpXme++n8sWEV48uXryIevXqwcrKSmN5YGAgACAiIkIPUVF5E0Lg0aNHsLe313coVIYUCgWmT5+OiRMnolGjRvoOh8rYgQMHYGVlhYcPH6J+/fqwsLCAlZUVpkyZgqysLH2HR2WgQ4cOAIAJEyYgIiICMTEx2LZtG1asWIE333wT5ubm+g2wmmPCq0dxcXFwcXHJt1y1LDY2trxDIj3YtGkTHj58iKFDh+o7FCpDP/74I+7du4cFCxboOxQqB7du3UJubi769u2Lbt264bfffsP48ePx448/Yty4cfoOj8pA9+7dsWDBAuzfvx9NmzaFu7s7hg0bhunTp+Pbb7/Vd3jVnoG+A6jOMjMztc6zbWJiol5PVdv169fxxhtvIDg4GGPGjNF3OFRGnj17hjlz5mD27NlwcHDQdzhUDtLS0pCRkYHXX39d3ZVhwIAByM7OxsqVK/Hpp5+ibt26eo6SSpunpyfatWuHgQMHws7ODn/++Sc+//xzODs7Y9q0afoOr1pjwqtHpqamkMvl+Zarvu4yNTUt75CoHMXHx+PVV1+FtbW1up6bqqZPPvkEtra2mD59ur5DoXKiev8OCQnRWD58+HCsXLkSp06dYsJbxWzduhWTJk3CzZs3UatWLQB5H3KUSiVmzpyJkJAQ2NnZ6TnK6oslDXrk4uKCuLi4fMtVy1xdXcs7JConycnJ6NGjB5KSkrB3714+11XYrVu3sGrVKrz55puIjY1FdHQ0oqOjkZWVhZycHERHRyMhIUHfYVIpU72mX7yAydHREQCQmJhY7jFR2frhhx/QtGlTdbKr0qdPH2RkZODixYt6iowAJrx65e/vj5s3b6qv7FQ5c+aMej1VPVlZWejduzdu3ryJ3bt3w9fXV98hURl6+PAhlEol3nzzTXh5ealv/9/e/YQ0/QZwHP98xzSEqMNwWvRnYnTJPwcP6sWGgZ46BLEIEgU9WYKGCCLqTDQIBgpikJoVQQehXYLoj2CCSCKuWxAddhoqiaxDKTr2O8RPkln85PfdvvXs/YJdnudhfL6MsQ9fnn2f9+/f69OnTyoqKtKdO3ecjgmbVVRUSPrx+f/s3/9msLXFPGtra0okEinjOzs7kqTd3d1MR8JPKLwOunr1qhKJhB48eLA3tr29renpaVVWVur06dMOpkM6JBIJXbt2TYuLi5qZmVF1dbXTkZBmJSUlCofDKa8LFy7ozJkzCofDam5udjombBYIBCRJU1NT+8YnJyfldrv3/tEPc5w/f16RSCTl5Mxnz57J5XKprKzMoWSQOHjCcYFAQOFwWB0dHTp37pweP36spaUlzc7Oqqamxul4sFl7e7tGR0d1+fLlvR/En924ccOBVHCC3+/n4AnDNTc36+HDhwoEArp48aLm5uY0MzOj7u5uDQ8POx0PNpufn1dtba08Ho9u3bolj8ejFy9e6OXLl2ppadHExITTEbMahddhW1tb6u3t1dOnT7W5uamysjINDg6qvr7e6WhIA7/fr3fv3v1ynq9j9qDwmm9nZ0fDw8Oanp5WLBbT2bNndfPmTbW3tzsdDWmytLSkYDCoSCSijY0NFRUVqbGxUV1dXXK7eU6Akyi8AAAAMBp7eAEAAGA0Ci8AAACMRuEFAACA0Si8AAAAMBqFFwAAAEaj8AIAAMBoFF4AAAAYjcILAAAAo1F4AQAAYDQKLwBkCZ/PJ5/P97/eIxgMyrIszc3N2ZIJADKBg50B4A9mWdah1nNaPACkovACwB+sv78/ZWxkZETxePzAud+ZnZ21KxYA/FUovADwBwsGgyljjx49UjweP3Dud4qLi+0JBQB/GfbwAoABotGoLMtSU1OTPn78qCtXrsjj8ciyLEWjUUkH7+GNxWLq7+9XVVWVvF6vjhw5Ip/Pp9bWVq2vr2f+QgAgDbjDCwAG+fz5s6qqqlRaWqqmpiZtbGwoNzf3l+vn5+cVCoV06dIlVVZWKicnR5FIRPfv39erV6+0srKi48ePZ/AKAMB+FF4AMMjCwoL6+vo0MDDwn9bX1tZqdXVVR48e3Tf+5MkTNTY2amxsTD09PemICgAZw5YGADBIYWHhoQqq1+tNKbuS1NDQoGPHjunt27d2xgMAR1B4AcAg5eXlv93CcJDnz5+rvr5e+fn5crvdsixLLpdLX79+VSwWS1NSAMgctjQAgEEKCgoOtT4UCqmzs1P5+fmqq6vTqVOnlJeXJ+nH48+2t7fTERMAMorCCwAGOcxBFbu7uxocHNSJEyf04cMHeb3evblkMql79+6lIyIAZBxbGgAgS3358kXxeFzV1dX7yq4kLS8v6/v37w4lAwB7UXgBIEt5vV7l5eVpZWVF37592xvf3NxUW1ubg8kAwF4UXgDIUi6XS62trYpGoyovL9ft27fV0tKikpISuVwunTx50umIAGALCi8AZLG7d+9qaGhIlmVpfHxcb9680fXr1/X69Wvl5OQ4HQ8AbGElk8mk0yEAAACAdOEOLwAAAIxG4QUAAIDRKLwAAAAwGoUXAAAARqPwAgAAwGgUXgAAABiNwgsAAACjUXgBAABgNAovAAAAjEbhBQAAgNEovAAAADAahRcAAABG+wdeov3Xj1ggCQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average MNIST Training Time: 113.15 sec per trial\n", + "Time Variance Across Trials: 0.9482 sec²\n" + ] + } + ], + "source": [ + "plt.figure(figsize=(8, 4))\n", + "\n", + "mnist_variance = [np.var(mnist_accuracies[:i+1]) for i in range(len(mnist_accuracies))]\n", + "\n", + "plt.plot(range(num_trials), mnist_variance, marker=\"o\", label=\"MNIST Accuracy Variance\")\n", + "\n", + "plt.xlabel(\"Trial\", fontsize=14)\n", + "plt.ylabel(\"Variance\", fontsize=14)\n", + "plt.title(\"SPORF MNIST Accuracy Variance Across Trials\", fontsize=16)\n", + "plt.legend(fontsize=12)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.show()\n", + "print(f\"Average MNIST Training Time: {np.mean(mnist_times):.2f} sec per trial\")\n", + "print(f\"Time Variance Across Trials: {np.var(mnist_times):.4f} sec²\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RkNOeM4Nupz5" + }, + "outputs": [], + "source": [ + "num_trials = 10\n", + "\n", + "fashion_accuracies = []\n", + "fashion_times = []\n", + "\n", + "for _ in range(num_trials):\n", + " (x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()\n", + "\n", + " x_train, x_test = x_train / 255.0, x_test / 255.0\n", + "\n", + " x_train = x_train.reshape(-1, 784)\n", + " x_test = x_test.reshape(-1, 784)\n", + "\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + " start_time = time.time()\n", + " sporf.fit(x_train, y_train)\n", + " fashion_times.append(time.time() - start_time)\n", + "\n", + " y_pred = sporf.predict(x_test)\n", + " fashion_accuracies.append(accuracy_score(y_test, y_pred))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 455 + }, + "id": "g4k8DfdousCh", + "outputId": "9175e30c-c898-44ee-bac6-ad948c39d29d" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final Fashion-MNIST Accuracy Variance: 0.0000\n" + ] + } + ], + "source": [ + "fashion_variances = [np.var(fashion_accuracies[:i+1]) for i in range(len(fashion_accuracies))]\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(range(num_trials), fashion_variances, marker=\"s\", label=\"Fashion-MNIST Accuracy Variance\")\n", + "\n", + "plt.xlabel(\"Trial\", fontsize=16)\n", + "plt.ylabel(\"Variance\", fontsize=16)\n", + "plt.title(\"SPORF Fashion-MNIST Accuracy Variance Across Trials\", fontsize=16)\n", + "plt.legend(fontsize=14)\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.show()\n", + "\n", + "print(f\"Final Fashion-MNIST Accuracy Variance: {fashion_variances[-1]:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 530 + }, + "id": "zpHhdI-adAGR", + "outputId": "0732be26-227e-4823-d4ef-6a277f25cdee" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n", + "\u001b[1m11490434/11490434\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n", + "\u001b[1m29515/29515\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n", + "\u001b[1m26421880/26421880\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n", + "\u001b[1m5148/5148\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n", + "\u001b[1m4422102/4422102\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0msporf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mObliqueRandomForestClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_estimators\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0mstart_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m \u001b[0msporf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_train_multi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 40\u001b[0m \u001b[0melapsed_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mstart_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/sklearn/base.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1387\u001b[0m )\n\u001b[1;32m 1388\u001b[0m ):\n\u001b[0;32m-> 1389\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfit_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1390\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1391\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/treeple/_lib/sklearn/ensemble/_forest.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, sample_weight, classes)\u001b[0m\n\u001b[1;32m 595\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 596\u001b[0m \u001b[0;31m# construct the trees in parallel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 597\u001b[0;31m self._construct_trees(\n\u001b[0m\u001b[1;32m 598\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 599\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/treeple/_lib/sklearn/ensemble/_forest.py\u001b[0m in \u001b[0;36m_construct_trees\u001b[0;34m(self, X, y, sample_weight, random_state, n_samples_bootstrap, missing_values_in_feature_mask, classes, n_more_estimators)\u001b[0m\n\u001b[1;32m 661\u001b[0m \u001b[0;31m# parallel_backend contexts set at a higher level,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 662\u001b[0m \u001b[0;31m# since correctness does not rely on using threads.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 663\u001b[0;31m trees = Parallel(\n\u001b[0m\u001b[1;32m 664\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 665\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/sklearn/utils/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdelayed_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m )\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterable_with_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1916\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_sequential_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1917\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1918\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreturn_generator\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1919\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1920\u001b[0m \u001b[0;31m# Let's create an ID that uniquely identifies the current call. If the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m_get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m 1845\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dispatched_batches\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1846\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dispatched_tasks\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1847\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1848\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_completed_tasks\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1849\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_progress\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/sklearn/utils/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mconfig_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/treeple/_lib/sklearn/ensemble/_forest.py\u001b[0m in \u001b[0;36m_parallel_build_trees\u001b[0;34m(tree, bootstrap, X, y, sample_weight, tree_idx, n_trees, verbose, class_weight, n_samples_bootstrap, missing_values_in_feature_mask, classes)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[0mcurr_sample_weight\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0mcompute_sample_weight\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"balanced\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindices\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 210\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 211\u001b[0;31m tree._fit(\n\u001b[0m\u001b[1;32m 212\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 213\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/treeple/_lib/sklearn/tree/_classes.py\u001b[0m in \u001b[0;36m_fit\u001b[0;34m(self, X, y, sample_weight, check_input, missing_values_in_feature_mask, classes)\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 410\u001b[0m \u001b[0;31m# build the actual tree now with the parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 411\u001b[0;31m self = self._build_tree(\n\u001b[0m\u001b[1;32m 412\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.11/dist-packages/treeple/tree/_classes.py\u001b[0m in \u001b[0;36m_build_tree\u001b[0;34m(self, X, y, sample_weight, missing_values_in_feature_mask, min_samples_leaf, min_weight_leaf, max_leaf_nodes, min_samples_split, max_depth, random_state)\u001b[0m\n\u001b[1;32m 999\u001b[0m )\n\u001b[1;32m 1000\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1001\u001b[0;31m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtree_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1002\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1003\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_outputs_\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "num_trials = 10\n", + "multitask_accuracies = []\n", + "multitask_times = []\n", + "\n", + "for _ in range(num_trials):\n", + " (x_train_mnist, y_train_mnist), (x_test_mnist, y_test_mnist) = keras.datasets.mnist.load_data()\n", + " (x_train_fashion, y_train_fashion), (x_test_fashion, y_test_fashion) = keras.datasets.fashion_mnist.load_data()\n", + "\n", + " task_train_mnist = np.zeros(y_train_mnist.shape, dtype=int)\n", + " task_test_mnist = np.zeros(y_test_mnist.shape, dtype=int)\n", + " task_train_fashion = np.ones(y_train_fashion.shape, dtype=int)\n", + " task_test_fashion = np.ones(y_test_fashion.shape, dtype=int)\n", + "\n", + " x_train_mnist, x_test_mnist = x_train_mnist / 255.0, x_test_mnist / 255.0\n", + " x_train_fashion, x_test_fashion = x_train_fashion / 255.0, x_test_fashion / 255.0\n", + " x_train_mnist = x_train_mnist.reshape(-1, 784)\n", + " x_test_mnist = x_test_mnist.reshape(-1, 784)\n", + " x_train_fashion = x_train_fashion.reshape(-1, 784)\n", + " x_test_fashion = x_test_fashion.reshape(-1, 784)\n", + "\n", + " x_train = np.concatenate([x_train_mnist, x_train_fashion], axis=0)\n", + " y_train = np.concatenate([y_train_mnist, y_train_fashion], axis=0)\n", + " task_train = np.concatenate([task_train_mnist, task_train_fashion], axis=0)\n", + " x_test = np.concatenate([x_test_mnist, x_test_fashion], axis=0)\n", + " y_test = np.concatenate([y_test_mnist, y_test_fashion], axis=0)\n", + " task_test = np.concatenate([task_test_mnist, task_test_fashion], axis=0)\n", + "\n", + " x_train_multi = np.column_stack((x_train, task_train))\n", + " x_test_multi = np.column_stack((x_test, task_test))\n", + "\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=50)\n", + " start_time = time.time()\n", + " sporf.fit(x_train_multi, y_train)\n", + " elapsed_time = time.time() - start_time\n", + "\n", + " y_pred = sporf.predict(x_test_multi)\n", + " accuracy = accuracy_score(y_test, y_pred)\n", + "\n", + " multitask_accuracies.append(accuracy)\n", + " multitask_times.append(elapsed_time)\n", + "\n", + "print(\"Finished running multi-task learning multiple times\")\n", + "\n", + "multitask_variances = [np.var(multitask_accuracies[:i+1]) for i in range(len(multitask_accuracies))]\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(range(num_trials), multitask_variances, marker=\"^\", label=\"Multi-Task Accuracy Variance\")\n", + "\n", + "plt.xlabel(\"Trial\", fontsize=16)\n", + "plt.ylabel(\"Variance\", fontsize=16)\n", + "plt.title(\"SPORF Multi-Task Accuracy Variance Across Trials\", fontsize=16)\n", + "plt.legend(fontsize=14)\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.show()\n", + "\n", + "print(f\"Final Multi-Task Accuracy Variance: {multitask_variances[-1]:.4f}\")\n", + "print(f\"Average Multi-Task Training Time: {np.mean(multitask_times):.2f} sec per trial\")\n", + "print(f\"Time Variance Across Trials: {np.var(multitask_times):.4f} sec²\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yTAzgryE8NyR" + }, + "outputs": [], + "source": [ + "multitask_variances = [np.var(multitask_accuracies[:i+1]) for i in range(len(multitask_accuracies))]\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(range(num_trials), multitask_variances, marker=\"^\", label=\"Multi-Task Accuracy Variance\")\n", + "\n", + "plt.xlabel(\"Trial\", fontsize=16)\n", + "plt.ylabel(\"Variance\", fontsize=16)\n", + "plt.title(\"SPORF Multi-Task Accuracy Variance Across Trials\", fontsize=16)\n", + "plt.legend(fontsize=14)\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.grid()\n", + "plt.show()\n", + "\n", + "print(f\"Final Multi-Task Accuracy Variance: {multitask_variances[-1]:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.datasets import mnist, fashion_mnist\n", + "num_trials = 10\n", + "\n", + "results = {\n", + " \"MNIST\": {\"accuracy\": [], \"time\": []},\n", + " \"Fashion-MNIST\": {\"accuracy\": [], \"time\": []},\n", + " \"Multi-Task\": {\"accuracy\": [], \"time\": []}\n", + "}\n", + "\n", + "for _ in range(num_trials):\n", + " (x_train_mnist, y_train_mnist), (x_test_mnist, y_test_mnist) = mnist.load_data()\n", + " (x_train_fashion, y_train_fashion), (x_test_fashion, y_test_fashion) = fashion_mnist.load_data()\n", + "\n", + " x_train_mnist = x_train_mnist.reshape(-1, 28*28) / 255.0\n", + " x_test_mnist = x_test_mnist.reshape(-1, 28*28) / 255.0\n", + " x_train_fashion = x_train_fashion.reshape(-1, 28*28) / 255.0\n", + " x_test_fashion = x_test_fashion.reshape(-1, 28*28) / 255.0\n", + "\n", + " start = time.time()\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf.fit(x_train_mnist, y_train_mnist)\n", + " y_pred = sporf.predict(x_test_mnist)\n", + " results[\"MNIST\"][\"accuracy\"].append(accuracy_score(y_test_mnist, y_pred))\n", + " results[\"MNIST\"][\"time\"].append(time.time() - start)\n", + "\n", + " start = time.time()\n", + " sporf.fit(x_train_fashion, y_train_fashion)\n", + " y_pred = sporf.predict(x_test_fashion)\n", + " results[\"Fashion-MNIST\"][\"accuracy\"].append(accuracy_score(y_test_fashion, y_pred))\n", + " results[\"Fashion-MNIST\"][\"time\"].append(time.time() - start)\n", + "\n", + " x_train = np.concatenate([x_train_mnist, x_train_fashion])\n", + " y_train = np.concatenate([y_train_mnist, y_train_fashion])\n", + " x_test = np.concatenate([x_test_mnist, x_test_fashion])\n", + " y_test = np.concatenate([y_test_mnist, y_test_fashion])\n", + "\n", + " start = time.time()\n", + " sporf.fit(x_train, y_train)\n", + " y_pred = sporf.predict(x_test)\n", + " results[\"Multi-Task\"][\"accuracy\"].append(accuracy_score(y_test, y_pred))\n", + " results[\"Multi-Task\"][\"time\"].append(time.time() - start)\n", + "\n", + "for key in results:\n", + " results[key][\"accuracy\"] = np.array(results[key][\"accuracy\"])\n", + " results[key][\"time\"] = np.array(results[key][\"time\"])\n", + "\n", + "for key in results:\n", + " print(f\"{key} Accuracy: {results[key]['accuracy'].mean():.4f} ± {results[key]['accuracy'].std():.4f}\")\n", + " print(f\"{key} Training Time: {results[key]['time'].mean():.2f} sec ± {results[key]['time'].std():.2f} sec\")\n", + "\n", + "plt.figure(figsize=(8, 5))\n", + "sns.stripplot(data=[results[\"MNIST\"][\"accuracy\"], results[\"Fashion-MNIST\"][\"accuracy\"], results[\"Multi-Task\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.xticks([0, 1, 2], [\"MNIST\", \"Fashion-MNIST\", \"Multi-Task\"], fontsize=12)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"SPORF Multi-Task Learning Accuracy\", fontsize=16)\n", + "plt.grid(axis=\"y\", linestyle=\"--\", alpha=0.6)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 578 + }, + "id": "ex4iIPiHV_IR", + "outputId": "f870a95d-a906-4dd0-cba7-b12a83e2f945" + }, + "execution_count": 38, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "MNIST Accuracy: 0.9688 ± 0.0007\n", + "MNIST Training Time: 235.42 sec ± 3.05 sec\n", + "Fashion-MNIST Accuracy: 0.8740 ± 0.0013\n", + "Fashion-MNIST Training Time: 297.14 sec ± 1.64 sec\n", + "Multi-Task Accuracy: 0.9198 ± 0.0007\n", + "Multi-Task Training Time: 571.23 sec ± 7.81 sec\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"MNIST\"][\"accuracy\"], results[\"Fashion-MNIST\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [results[\"MNIST\"][\"accuracy\"].mean(), results[\"Fashion-MNIST\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"MNIST\"][\"accuracy\"].std(), results[\"Fashion-MNIST\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Single-Task MNIST\", \"Single-Task Fashion-MNIST\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=16)\n", + "plt.title(\"Single-Task Learning Accuracy\", fontsize=16)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "kreOnhvrd2C8", + "outputId": "50173185-fdfe-408a-f438-bf2e8c1b9a5d" + }, + "execution_count": 49, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"Multi-Task\"][\"accuracy\"], results[\"Multi-Task\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [results[\"Multi-Task\"][\"accuracy\"].mean(), results[\"Multi-Task\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"Multi-Task\"][\"accuracy\"].std(), results[\"Multi-Task\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Multi-Task MNIST\", \"Multi-Task Fashion-MNIST\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=16)\n", + "plt.title(\"Multi-Task Learning Accuracy\", fontsize=16)\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "Mc4GfnxFeBqe", + "outputId": "06ceb506-9e20-44bf-ccb1-9ce9de538b9e" + }, + "execution_count": 50, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "mnist_mean = np.mean(results[\"MNIST\"][\"accuracy\"])\n", + "mnist_std = np.std(results[\"MNIST\"][\"accuracy\"])\n", + "fashion_mnist_mean = np.mean(results[\"Fashion-MNIST\"][\"accuracy\"])\n", + "fashion_mnist_std = np.std(results[\"Fashion-MNIST\"][\"accuracy\"])\n", + "multi_task_mean = np.mean(results[\"Multi-Task\"][\"accuracy\"])\n", + "multi_task_std = np.std(results[\"Multi-Task\"][\"accuracy\"])\n", + "\n", + "mnist_time_mean = np.mean(results[\"MNIST\"][\"time\"])\n", + "mnist_time_std = np.std(results[\"MNIST\"][\"time\"])\n", + "fashion_mnist_time_mean = np.mean(results[\"Fashion-MNIST\"][\"time\"])\n", + "fashion_mnist_time_std = np.std(results[\"Fashion-MNIST\"][\"time\"])\n", + "multi_task_time_mean = np.mean(results[\"Multi-Task\"][\"time\"])\n", + "multi_task_time_std = np.std(results[\"Multi-Task\"][\"time\"])\n", + "\n", + "print(f\"MNIST Accuracy: {mnist_mean:.4f} ± {mnist_std:.4f}\")\n", + "print(f\"MNIST Training Time: {mnist_time_mean:.2f} sec ± {mnist_time_std:.2f} sec\")\n", + "\n", + "print(f\"Fashion-MNIST Accuracy: {fashion_mnist_mean:.4f} ± {fashion_mnist_std:.4f}\")\n", + "print(f\"Fashion-MNIST Training Time: {fashion_mnist_time_mean:.2f} sec ± {fashion_mnist_time_std:.2f} sec\")\n", + "\n", + "print(f\"Multi-Task MNIST & Fashion-MNIST Accuracy: {multi_task_mean:.4f} ± {multi_task_std:.4f}\")\n", + "print(f\"Total Multi-Task Training Time: {multi_task_time_mean:.2f} sec ± {multi_task_time_std:.2f} sec\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C_qyTdeAfN86", + "outputId": "923daa27-dfcf-4872-bc3f-94c6b315b0ba" + }, + "execution_count": 48, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "MNIST Accuracy: 0.9688 ± 0.0007\n", + "MNIST Training Time: 235.42 sec ± 3.05 sec\n", + "Fashion-MNIST Accuracy: 0.8740 ± 0.0013\n", + "Fashion-MNIST Training Time: 297.14 sec ± 1.64 sec\n", + "Multi-Task MNIST & Fashion-MNIST Accuracy: 0.9198 ± 0.0007\n", + "Total Multi-Task Training Time: 571.23 sec ± 7.81 sec\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#XOR and RXOR" + ], + "metadata": { + "id": "FmnFQgtiEnMz" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Hliww_AJ9i-k", + "outputId": "094ae449-6297-4188-c4e3-39a025ed2e1f" + }, + "execution_count": 42, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['ExtendedIsolationForest', 'ExtraObliqueRandomForestClassifier', 'ExtraObliqueRandomForestRegressor', 'ExtraTreesClassifier', 'ExtraTreesRegressor', 'HonestForestClassifier', 'MultiViewRandomForestClassifier', 'NearestNeighborsMetaEstimator', 'ObliqueRandomForestClassifier', 'ObliqueRandomForestRegressor', 'PatchObliqueRandomForestClassifier', 'PatchObliqueRandomForestRegressor', 'RandomForestClassifier', 'RandomForestRegressor', 'UnsupervisedObliqueRandomForest', 'UnsupervisedRandomForest', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__treeple_SETUP__', '__version__', '_lib', 'ensemble', 'experimental', 'logger', 'logging', 'neighbors', 'os', 'stats', 'sys', 'tree']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "collapsed": true, + "id": "dfTIA_KmEsNo" + }, + "execution_count": 23, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "FNFxqhaZJLqj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "VYn7baO-JlAP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "ZIQMWyCzPc-N" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "w7Qtd_LzR73T" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/MultiTaskClf.ipynb b/MultiTaskClf.ipynb new file mode 100644 index 0000000..f1cda1c --- /dev/null +++ b/MultiTaskClf.ipynb @@ -0,0 +1,406 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "!pip install proglearn\n", + "!pip install git+https://github.com/neurodata/treeple.git" + ], + "metadata": { + "id": "JxBYpMdVyY57", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "outputId": "9aeb37bb-581e-4004-cdb2-5319dc898023" + }, + "execution_count": 54, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: proglearn in /usr/local/lib/python3.11/dist-packages (0.0.7)\n", + "Requirement already satisfied: tensorflow>=1.19.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (2.18.0)\n", + "Requirement already satisfied: scikit-learn>=0.22.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.6.1)\n", + "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.14.1)\n", + "Requirement already satisfied: joblib>=0.14.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.4.2)\n", + "Requirement already satisfied: numpy>=1.19.2 in /usr/local/lib/python3.11/dist-packages (from proglearn) (2.0.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=0.22.0->proglearn) (3.6.0)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (25.2.10)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.2.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (18.1.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.4.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (24.2)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (5.29.4)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.32.3)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (75.1.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.5.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (4.12.2)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.2)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.71.0)\n", + "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.8.0)\n", + "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.13.0)\n", + "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.4.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.37.1)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow>=1.19.0->proglearn) (0.45.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.0.8)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.14.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2025.1.31)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.7)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.0.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.1.2)\n", + "Collecting git+https://github.com/neurodata/treeple.git\n", + " Cloning https://github.com/neurodata/treeple.git to /tmp/pip-req-build-w7n461wi\n", + " Running command git clone --filter=blob:none --quiet https://github.com/neurodata/treeple.git /tmp/pip-req-build-w7n461wi\n", + " Resolved https://github.com/neurodata/treeple.git to commit 75c2cf919939574e4240fe261f053162039495cf\n", + " Running command git submodule update --init --recursive -q\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.25.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.5.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.14.1)\n", + "Requirement already satisfied: scikit-learn>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (3.6.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from treeple import ObliqueRandomForestClassifier\n", + "from proglearn.sims import generate_gaussian_parity\n", + "from sklearn.metrics import accuracy_score\n", + "from proglearn.sims import generate_spirals\n", + "from sklearn.preprocessing import StandardScaler\n", + "from tensorflow.keras.datasets import mnist, fashion_mnist\n", + "from sklearn.model_selection import train_test_split" + ], + "metadata": { + "id": "R9G4oQOFqN-d" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "class MultiTaskForestClassifier:\n", + " def __init__(self, clf_type=\"SPORF\", **kwargs):\n", + " if clf_type == \"SPORF\":\n", + " self.model_cls = ObliqueRandomForestClassifier\n", + " self.default_params = {\n", + " \"n_estimators\": 200,\n", + " \"feature_combinations\": 2.0,\n", + " \"max_depth\": 20,\n", + " \"min_samples_split\": 5,\n", + " \"min_samples_leaf\": 1,\n", + " \"max_features\": 0.5,\n", + " \"bootstrap\": True\n", + " }\n", + " elif clf_type == \"MORF\":\n", + " self.model_cls = MORFClassifier # Liora\n", + " self.default_params = { ... }\n", + " elif clf_type == \"HonestForest\":\n", + " self.model_cls = HonestForestClassifier # Riya\n", + " self.default_params = { ... }\n", + " else:\n", + " raise ValueError(f\"Unsupported tree: {clf_type}\")\n", + "\n", + " self.params = {**self.default_params, **kwargs}\n", + " self.model = None\n", + " self.task_data = {}\n", + "\n", + " def add_task(self, task_id, X, y):\n", + " self.task_data[task_id] = (X, y)\n", + "\n", + " def fit(self, task_ids):\n", + " X_all, y_all, task_labels = [], [], []\n", + " for task_id in task_ids:\n", + " X, y = self.task_data[task_id]\n", + " X_all.append(X)\n", + " y_all.append(y)\n", + " task_labels.append(np.full(len(y), task_id))\n", + "\n", + " X_all = np.vstack(X_all)\n", + " y_all = np.concatenate(y_all)\n", + " task_labels = np.concatenate(task_labels)\n", + " X_all = np.column_stack((X_all, task_labels))\n", + "\n", + " self.model = self.model_cls(**self.params, random_state=42)\n", + " self.model.fit(X_all, y_all)\n", + "\n", + " def predict(self, X, task_id):\n", + " X_task = np.column_stack((X, np.full(len(X), task_id)))\n", + " return self.model.predict(X_task)\n", + "\n", + " def score(self, X, y, task_id):\n", + " return accuracy_score(y, self.predict(X, task_id))\n", + "\n", + " def evaluate_transfer_general(self, forward_train_ids, forward_test_id, backward_train_ids, backward_test_ids, do_reverse=False):\n", + " \"\"\"\n", + " - Forward: train on `forward_train_ids`, test on `forward_test_id`\n", + " - Backward: train on `backward_train_ids`, test individually on each in `backward_test_ids`\n", + " - Reverse (not mandatory. default as False but can change to true): train on `forward_test_id`, test on `forward_train_ids`\n", + " \"\"\"\n", + " results = {}\n", + "\n", + " # Forward\n", + " self.fit(forward_train_ids)\n", + " X_test, y_test = self.task_data[forward_test_id]\n", + " forward_acc = self.score(X_test, y_test, task_id=forward_test_id)\n", + " results[\"forward_transfer\"] = {\n", + " \"train_on\": forward_train_ids,\n", + " \"test_on\": forward_test_id,\n", + " \"accuracy\": forward_acc\n", + " }\n", + "\n", + " # Backward\n", + " self.fit(backward_train_ids)\n", + " backward_accuracies = {}\n", + " for tid in backward_test_ids:\n", + " X, y = self.task_data[tid]\n", + " backward_accuracies[f\"task{tid}\"] = {\n", + " \"train_on\": backward_train_ids,\n", + " \"test_on\": tid,\n", + " \"accuracy\": self.score(X, y, task_id=tid)\n", + " }\n", + " results[\"backward_transfer\"] = backward_accuracies\n", + "\n", + " # Reverse\n", + " if do_reverse:\n", + " self.fit([forward_test_id])\n", + " reverse_accuracies = {}\n", + " for tid in forward_train_ids:\n", + " X, y = self.task_data[tid]\n", + " reverse_accuracies[f\"task{tid}\"] = {\n", + " \"train_on\": [forward_test_id],\n", + " \"test_on\": tid,\n", + " \"accuracy\": self.score(X, y, task_id=tid)\n", + " }\n", + " results[\"reverse_transfer\"] = reverse_accuracies\n", + "\n", + " return results\n" + ], + "metadata": { + "id": "EH1kTXubBcsK" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#TESTing" + ], + "metadata": { + "id": "nZ2fDAqB5Tdc" + } + }, + { + "cell_type": "markdown", + "source": [ + "##XOR/RXOR\n" + ], + "metadata": { + "id": "lRjYmHNl7-U3" + } + }, + { + "cell_type": "code", + "source": [ + "X_xor, y_xor = generate_gaussian_parity(1000)\n", + "X_rxor, y_rxor = generate_gaussian_parity(1000, angle_params=np.pi / 4)\n", + "X_train_xor, X_test_xor, y_train_xor, y_test_xor = train_test_split(X_xor, y_xor, test_size=0.2, random_state=42)\n", + "X_train_rxor, X_test_rxor, y_train_rxor, y_test_rxor = train_test_split(X_rxor, y_rxor, test_size=0.2, random_state=42)" + ], + "metadata": { + "id": "1ifFdkSq5TCK" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###Train on same task and test on the same task (like a base line)" + ], + "metadata": { + "id": "kn74DRo68aDE" + } + }, + { + "cell_type": "code", + "source": [ + "clf = MultiTaskForestClassifier(clf_type=\"SPORF\")\n", + "clf.add_task(0, X_train_xor, y_train_xor)\n", + "clf.add_task(1, X_train_rxor, y_train_rxor)\n", + "clf.fit([0, 1])\n", + "acc_xor = clf.score(X_test_xor, y_test_xor, task_id=0)\n", + "acc_rxor = clf.score(X_test_rxor, y_test_rxor, task_id=1)\n", + "\n", + "print(f\"XOR Accuracy: {acc_xor:.3f}\")\n", + "print(f\"RXOR Accuracy: {acc_rxor:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yZsElMQ88HKO", + "outputId": "0fbefa97-cae0-4058-cf3d-064ed5ca0581" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "XOR Accuracy: 0.935\n", + "RXOR Accuracy: 0.970\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "help(clf.evaluate_transfer_general)" + ], + "metadata": { + "id": "LGGs-JR5AMex", + "outputId": "bef8daa8-02e0-4eaa-f14e-41afc43d0361", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Help on method evaluate_transfer_general in module __main__:\n", + "\n", + "evaluate_transfer_general(forward_train_ids, forward_test_id, backward_train_ids, backward_test_ids, do_reverse=False) method of __main__.MultiTaskForestClassifier instance\n", + " - Forward: train on `forward_train_ids`, test on `forward_test_id`\n", + " - Backward: train on `backward_train_ids`, test individually on each in `backward_test_ids`\n", + " - Reverse (optional): train on `forward_test_id`, test on `forward_train_ids`\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Forward training, backward training, reverse training" + ], + "metadata": { + "id": "UrnIBOB3FGR2" + } + }, + { + "cell_type": "code", + "source": [ + "results = clf.evaluate_transfer_general(\n", + " forward_train_ids=[0],\n", + " forward_test_id=1,\n", + " backward_train_ids=[0, 1],\n", + " backward_test_ids=[0, 1],\n", + " do_reverse=True\n", + ")\n", + "\n", + "print(\"Transfer Learning Results:\")\n", + "fwd = results[\"forward_transfer\"]\n", + "print(f\"\\n Forward Transfer:\\n Train on: {fwd['train_on']}\\n Test on: {fwd['test_on']}\\n Accuracy: {fwd['accuracy']:.3f}\")\n", + "\n", + "print(\"\\n Backward Transfer:\")\n", + "for task, stats in results[\"backward_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")\n", + "\n", + "if \"reverse_transfer\" in results:\n", + " print(\"\\n Reverse Transfer:\")\n", + " for task, stats in results[\"reverse_transfer\"].items():\n", + " print(f\" {task}:\")\n", + " print(f\" Train on: {stats['train_on']}\")\n", + " print(f\" Test on : {stats['test_on']}\")\n", + " print(f\" Accuracy: {stats['accuracy']:.3f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o1FAFm5i79cj", + "outputId": "3be43b22-a5e7-446d-fc7e-5bc35a6bf361" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Transfer Learning Results:\n", + "\n", + " Forward Transfer:\n", + " Train on: [0]\n", + " Test on: 1\n", + " Accuracy: 0.546\n", + "\n", + " Backward Transfer:\n", + " task0:\n", + " Train on: [0, 1]\n", + " Test on : 0\n", + " Accuracy: 0.978\n", + " task1:\n", + " Train on: [0, 1]\n", + " Test on : 1\n", + " Accuracy: 0.991\n", + "\n", + " Reverse Transfer:\n", + " task0:\n", + " Train on: [1]\n", + " Test on : 0\n", + " Accuracy: 0.516\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Sporf_XOR_Spiral.ipynb b/Sporf_XOR_Spiral.ipynb new file mode 100644 index 0000000..282f16c --- /dev/null +++ b/Sporf_XOR_Spiral.ipynb @@ -0,0 +1,598 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "!pip install proglearn\n", + "!pip install git+https://github.com/neurodata/treeple.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "mJnM5z33iZJg", + "outputId": "733ebea4-4343-4c51-c65e-225e95aecbfe" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting proglearn\n", + " Downloading proglearn-0.0.7-py3-none-any.whl.metadata (3.1 kB)\n", + "Requirement already satisfied: tensorflow>=1.19.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (2.18.0)\n", + "Requirement already satisfied: scikit-learn>=0.22.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.6.1)\n", + "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.13.1)\n", + "Requirement already satisfied: joblib>=0.14.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.4.2)\n", + "Requirement already satisfied: numpy>=1.19.2 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.26.4)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=0.22.0->proglearn) (3.5.0)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (25.2.10)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.2.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (18.1.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.4.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (24.2)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (4.25.6)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.32.3)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (75.1.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.5.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (4.12.2)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.2)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.70.0)\n", + "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.8.0)\n", + "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.12.1)\n", + "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.4.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.37.1)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow>=1.19.0->proglearn) (0.45.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.0.8)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.14.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2025.1.31)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.7)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.0.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.1.2)\n", + "Downloading proglearn-0.0.7-py3-none-any.whl (27 kB)\n", + "Installing collected packages: proglearn\n", + "Successfully installed proglearn-0.0.7\n", + "Collecting git+https://github.com/neurodata/treeple.git\n", + " Cloning https://github.com/neurodata/treeple.git to /tmp/pip-req-build-cv6y8t_i\n", + " Running command git clone --filter=blob:none --quiet https://github.com/neurodata/treeple.git /tmp/pip-req-build-cv6y8t_i\n", + " Resolved https://github.com/neurodata/treeple.git to commit 75c2cf919939574e4240fe261f053162039495cf\n", + " Running command git submodule update --init --recursive -q\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.25.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.5.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.13.1)\n", + "Requirement already satisfied: scikit-learn>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (3.5.0)\n", + "Building wheels for collected packages: treeple\n", + " Building wheel for treeple (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for treeple: filename=treeple-0.10.3-cp311-cp311-linux_x86_64.whl size=2924556 sha256=6c55ecad7f937489288858a06682461e398f74a377238143e5cf45ef213c04f7\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-rt64ssk0/wheels/87/bd/56/9c9982c5af1eb667f0421e0000d3ed4b973b71c8e8903fa6cd\n", + "Successfully built treeple\n", + "Installing collected packages: treeple\n", + "Successfully installed treeple-0.10.3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from treeple import ObliqueRandomForestClassifier\n", + "from proglearn.sims import generate_gaussian_parity\n", + "from sklearn.metrics import accuracy_score\n", + "from proglearn.sims import generate_spirals\n", + "from sklearn.preprocessing import StandardScaler\n", + "from tensorflow.keras.datasets import mnist, fashion_mnist" + ], + "metadata": { + "id": "4NRBnZnUjtAb" + }, + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_xor, y_xor = generate_gaussian_parity(1000)\n", + "X_rxor, y_rxor = generate_gaussian_parity(1000, angle_params=np.pi / 4)\n", + "\n", + "X_train_xor, X_test_xor, y_train_xor, y_test_xor = train_test_split(X_xor, y_xor, test_size=0.2)\n", + "X_train_rxor, X_test_rxor, y_train_rxor, y_test_rxor = train_test_split(X_rxor, y_rxor, test_size=0.2)\n", + "\n", + "task_train_xor = np.zeros(len(y_train_xor), dtype=int)\n", + "task_train_rxor = np.ones(len(y_train_rxor), dtype=int)\n", + "task_test_xor = np.zeros(len(y_test_xor), dtype=int)\n", + "task_test_rxor = np.ones(len(y_test_rxor), dtype=int)\n", + "\n", + "X_train_multi = np.column_stack((np.vstack([X_train_xor, X_train_rxor]), np.hstack([task_train_xor, task_train_rxor])))\n", + "y_train_multi = np.hstack([y_train_xor, y_train_rxor])\n", + "\n", + "X_test_multi_xor = np.column_stack((X_test_xor, np.zeros(len(y_test_xor), dtype=int)))\n", + "X_test_multi_rxor = np.column_stack((X_test_rxor, np.ones(len(y_test_rxor), dtype=int)))\n" + ], + "metadata": { + "id": "XM24wO3LkBv4" + }, + "execution_count": 81, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "num_trials = 100\n", + "xor_accuracies = []\n", + "rxor_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " start_time = time.time()\n", + " sporf_mtl = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_mtl.fit(X_train_multi, y_train_multi)\n", + " training_time = time.time() - start_time\n", + " y_pred_xor = sporf_mtl.predict(X_test_multi_xor)\n", + " y_pred_rxor = sporf_mtl.predict(X_test_multi_rxor)\n", + "\n", + " xor_accuracies.append(accuracy_score(y_test_xor, y_pred_xor))\n", + " rxor_accuracies.append(accuracy_score(y_test_rxor, y_pred_rxor))\n" + ], + "metadata": { + "id": "7Rcb-umUlm5v" + }, + "execution_count": 82, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "xor_accuracies = np.array(xor_accuracies)\n", + "rxor_accuracies = np.array(rxor_accuracies)\n", + "single_task_xor_accuracies = []\n", + "single_task_rxor_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " start_time = time.time()\n", + " sporf_xor = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_xor.fit(X_train_xor, y_train_xor)\n", + " y_pred_xor = sporf_xor.predict(X_test_xor)\n", + " single_task_xor_accuracies.append(accuracy_score(y_test_xor, y_pred_xor))\n", + "\n", + " start_time = time.time()\n", + " sporf_rxor = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_rxor.fit(X_train_rxor, y_train_rxor)\n", + " y_pred_rxor = sporf_rxor.predict(X_test_rxor)\n", + " single_task_rxor_accuracies.append(accuracy_score(y_test_rxor, y_pred_rxor))\n", + "\n", + "single_task_xor_accuracies = np.array(single_task_xor_accuracies)\n", + "single_task_rxor_accuracies = np.array(single_task_rxor_accuracies)\n" + ], + "metadata": { + "id": "mWHtxhNONcw1" + }, + "execution_count": 83, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[single_task_xor_accuracies, single_task_rxor_accuracies],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [single_task_xor_accuracies.mean(), single_task_rxor_accuracies.mean()],\n", + " yerr=[single_task_xor_accuracies.std(), single_task_rxor_accuracies.std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Single-Task XOR\", \"Single-Task RXOR\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Single-Task Learning Accuracy (XOR & RXOR)\", fontsize=16)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "O2z_yngNNfSa", + "outputId": "b413c848-7615-469c-b431-1edb927ca2f7" + }, + "execution_count": 85, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "glPJZ2bxiX7E", + "outputId": "ad3516f6-27d3-4286-9374-545fcfc5fd0c" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[xor_accuracies, rxor_accuracies],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [xor_accuracies.mean(), rxor_accuracies.mean()],\n", + " yerr=[xor_accuracies.std(), rxor_accuracies.std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Multi-Task XOR\", \"Multi-Task RXOR\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Multi-Task Learning Accuracy (XOR & RXOR)\", fontsize=16)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "source": [ + "single_task_xor_mean = np.mean(single_task_xor_accuracies)\n", + "single_task_xor_std = np.std(single_task_xor_accuracies)\n", + "single_task_rxor_mean = np.mean(single_task_rxor_accuracies)\n", + "single_task_rxor_std = np.std(single_task_rxor_accuracies)\n", + "multi_task_xor_mean = np.mean(xor_accuracies)\n", + "multi_task_xor_std = np.std(xor_accuracies)\n", + "multi_task_rxor_mean = np.mean(rxor_accuracies)\n", + "multi_task_rxor_std = np.std(rxor_accuracies)\n", + "\n", + "single_task_xor_time = training_time\n", + "single_task_rxor_time = training_time\n", + "multi_task_time = training_time\n", + "\n", + "print(f\"Single-Task XOR Accuracy: {single_task_xor_mean:.4f} ± {single_task_xor_std:.4f}\")\n", + "print(f\"Single-Task RXOR Accuracy: {single_task_rxor_mean:.4f} ± {single_task_rxor_std:.4f}\")\n", + "\n", + "print(f\"Multi-Task XOR Accuracy: {multi_task_xor_mean:.4f} ± {multi_task_xor_std:.4f}\")\n", + "print(f\"Multi-Task RXOR Accuracy: {multi_task_rxor_mean:.4f} ± {multi_task_rxor_std:.4f}\")\n", + "\n", + "print(f\"Single-Task XOR Training Time: {single_task_xor_time:.2f} sec\")\n", + "print(f\"Single-Task RXOR Training Time: {single_task_rxor_time:.2f} sec\")\n", + "\n", + "print(f\"Total Multi-Task Training Time: {multi_task_time:.2f} sec\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GYiY0hiE3UHH", + "outputId": "4ad73d9c-7dd0-41fb-9ffc-97fe9ef74f71" + }, + "execution_count": 88, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Single-Task XOR Accuracy: 0.9565 ± 0.0034\n", + "Single-Task RXOR Accuracy: 0.9401 ± 0.0009\n", + "Multi-Task XOR Accuracy: 0.9540 ± 0.0054\n", + "Multi-Task RXOR Accuracy: 0.9421 ± 0.0048\n", + "Single-Task XOR Training Time: 0.21 sec\n", + "Single-Task RXOR Training Time: 0.21 sec\n", + "Total Multi-Task Training Time: 0.21 sec\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Spiral 3 vs Sprial 5\n" + ], + "metadata": { + "id": "G6bzznlFBwm8" + } + }, + { + "cell_type": "code", + "source": [ + "n_samples = 750\n", + "spiral3, y_spiral3 = generate_spirals(n_samples, 3, noise=0.8)\n", + "spiral5, y_spiral5 = generate_spirals(n_samples, 5, noise=0.4)\n", + "\n", + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(spiral3[:, 0], spiral3[:, 1], c=y_spiral3, cmap=\"viridis\", s=5)\n", + "plt.title(\"3 Spirals\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(spiral5[:, 0], spiral5[:, 1], c=y_spiral5, cmap=\"plasma\", s=5)\n", + "plt.title(\"5 Spirals\")\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + }, + "id": "CHrJNNdR_Nnc", + "outputId": "d910ee87-c676-47f4-c63a-fbc8ad134867" + }, + "execution_count": 36, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "num_trials = 100\n", + "\n", + "results = {\n", + " \"Spiral 3\": {\"accuracy\": [], \"time\": []},\n", + " \"Spiral 5\": {\"accuracy\": [], \"time\": []},\n", + " \"Multi-Task\": {\"accuracy\": [], \"time\": []}\n", + "}\n", + "\n", + "multi_task_spiral3_accuracies = []\n", + "multi_task_spiral5_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " spiral3, y_spiral3 = generate_spirals(750, 3, noise=0.8)\n", + " spiral5, y_spiral5 = generate_spirals(750, 5, noise=0.4)\n", + "\n", + " X_train_spiral3, X_test_spiral3, y_train_spiral3, y_test_spiral3 = train_test_split(spiral3, y_spiral3, test_size=0.2)\n", + " X_train_spiral5, X_test_spiral5, y_train_spiral5, y_test_spiral5 = train_test_split(spiral5, y_spiral5, test_size=0.2)\n", + "\n", + " scaler = StandardScaler()\n", + " X_train_all = np.vstack([X_train_spiral3, X_train_spiral5])\n", + " scaler.fit(X_train_all)\n", + "\n", + " X_train_spiral3 = scaler.transform(X_train_spiral3)\n", + " X_train_spiral5 = scaler.transform(X_train_spiral5)\n", + " X_test_spiral3 = scaler.transform(X_test_spiral3)\n", + " X_test_spiral5 = scaler.transform(X_test_spiral5)\n", + "\n", + " start = time.time()\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf.fit(X_train_spiral3, y_train_spiral3)\n", + " y_pred = sporf.predict(X_test_spiral3)\n", + " results[\"Spiral 3\"][\"accuracy\"].append(accuracy_score(y_test_spiral3, y_pred))\n", + " results[\"Spiral 3\"][\"time\"].append(time.time() - start)\n", + "\n", + " start = time.time()\n", + " sporf.fit(X_train_spiral5, y_train_spiral5)\n", + " y_pred = sporf.predict(X_test_spiral5)\n", + " results[\"Spiral 5\"][\"accuracy\"].append(accuracy_score(y_test_spiral5, y_pred))\n", + " results[\"Spiral 5\"][\"time\"].append(time.time() - start)\n", + "\n", + " X_train_multi = np.vstack([X_train_spiral3, X_train_spiral5])\n", + " y_train_multi = np.concatenate([y_train_spiral3, y_train_spiral5])\n", + " task_labels_train = np.concatenate([np.zeros(len(y_train_spiral3)), np.ones(len(y_train_spiral5))])\n", + " X_train_multi = np.column_stack((X_train_multi, task_labels_train))\n", + "\n", + " X_test_multi = np.vstack([X_test_spiral3, X_test_spiral5])\n", + " y_test_multi = np.concatenate([y_test_spiral3, y_test_spiral5])\n", + " task_labels_test = np.concatenate([np.zeros(len(y_test_spiral3)), np.ones(len(y_test_spiral5))])\n", + " X_test_multi = np.column_stack((X_test_multi, task_labels_test))\n", + "\n", + " start = time.time()\n", + " sporf.fit(X_train_multi, y_train_multi)\n", + " y_pred_multi = sporf.predict(X_test_multi)\n", + " results[\"Multi-Task\"][\"accuracy\"].append(accuracy_score(y_test_multi, y_pred_multi))\n", + " results[\"Multi-Task\"][\"time\"].append(time.time() - start)\n", + "\n", + " X_test_spiral3_with_task = np.column_stack((X_test_spiral3, np.zeros(len(y_test_spiral3))))\n", + " X_test_spiral5_with_task = np.column_stack((X_test_spiral5, np.ones(len(y_test_spiral5))))\n", + "\n", + " y_pred_spiral3 = sporf.predict(X_test_spiral3_with_task)\n", + " y_pred_spiral5 = sporf.predict(X_test_spiral5_with_task)\n", + "\n", + " multi_task_spiral3_accuracies.append(accuracy_score(y_test_spiral3, y_pred_spiral3))\n", + " multi_task_spiral5_accuracies.append(accuracy_score(y_test_spiral5, y_pred_spiral5))\n" + ], + "metadata": { + "id": "SOi9BoGiB4a5" + }, + "execution_count": 77, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "for key in results:\n", + " results[key][\"accuracy\"] = np.array(results[key][\"accuracy\"])\n", + " results[key][\"time\"] = np.array(results[key][\"time\"])\n", + "\n", + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"Spiral 3\"][\"accuracy\"], results[\"Spiral 5\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1], [results[\"Spiral 3\"][\"accuracy\"].mean(), results[\"Spiral 5\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"Spiral 3\"][\"accuracy\"].std(), results[\"Spiral 5\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Single-Task Spiral 3\", \"Single-Task Spiral 5\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Single-Task Learning Accuracy (Spiral 3 & Spiral 5)\", fontsize=16)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "xTZpH2BsCNeV", + "outputId": "0b9f7879-c25a-4e28-cea9-9dc54a0fd70c" + }, + "execution_count": 78, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqcAAAHLCAYAAAD1OzG4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0U9JREFUeJzs3Xd4FOX2wPHv7qZ3SA+EhN4JPfTeBUWkS5WiXLDhVUFBsHKv/EQsiF5FxYIgRQRBpIsoHZGO9FCSQChJSE92fn+MWbJkd7O72VTO53nyKDPvvPPOZrJ7duadczSKoigIIYQQQghRCmhLegBCCCGEEELkkuBUCCGEEEKUGhKcCiGEEEKIUkOCUyGEEEIIUWpIcCqEEEIIIUoNCU6FEEIIIUSpIcGpEEIIIYQoNSQ4FUIIIYQQpYYEp0IIIYQQotSQ4NQOp0+fZsqUKdSrVw9PT0/c3NyoXLkyLVq0YMqUKaxcuTLfNp06dUKj0bB9+/biH3Ae27dvR6PR0KlTpyLp/8svv0Sj0dj88+WXXxbJeHLl7sdRIiMji2Xcpc2YMWPK3HFnZmYSGBiIRqMhJCSE7Ozskh6SsOC9995Do9GYfB/NyMjg/fffp0OHDlSsWBFnZ2cCAgKoW7cugwcP5r333uP69esOGUdRv1eacuHCBTQaDZGRkTZt9/PPPzN+/HiaN29OaGgorq6ueHt707hxY1566SUSEhIKNa5vvvmG6OhoPD098fHxoW7dukycOJFdu3YVql+Abdu2MXToUCIiInBzc8Pb25uqVavSuXNnXn75ZXbv3l3ofeTKfd++cOGCw/osiD2f/bnngaWfadOm5dtu586daDQaXnjhBQceQclwKukBlDWrVq1i+PDhZGRk4O/vT9u2bQkMDOTWrVscOnSIBQsWsHTpUh555JGSHmqJqFGjBqNHj863fOfOnZw9e5bq1avTrl07k9sJURR+/PFHw4dzfHw869at46GHHirhUQlTrl+/zuzZs2nRokW+99D4+Hi6d+/OkSNH0Ol0tGzZkvDwcPR6PX///TcrV65k+fLlVK9enb59+5bQEZSMb7/9lm+//ZYaNWrQoEEDAgMDuXHjBnv37mXOnDksWrSIrVu3Ur9+fZv7njlzJm+88QYajYaOHTsSEhLC8ePH+fTTT8nMzKR169Z2j/uFF15g7ty5AFSrVo3u3bvj7e1NbGwsBw8eZPv27Zw6dYoVK1bYvY+yzNPTk4EDB5pc16xZs3zL2rVrxwMPPMB7773HhAkTqFmzZlEPsegowmpxcXGKl5eXAijPPfeckpaWlq/N/v37lWnTpuVbfvHiReXEiRNKSkpKcQzVrG3btimA0rFjx2Ld7+jRoxVAGT16dLHuNxegOPJ0j4iIUADliy++cFifZcHVq1eVEydOKLdv3y7poVitZ8+eCqBUqlRJAZR+/fqV9JCEGZMnT1YAZd26dfnWDRw4UAGU+vXrKxcuXMi3Pj4+Xpk/f76yd+9eh4wlJSVFOXHihHLx4kWH9GeN8+fPK4ASERFh03Z//vmnEhsbm295cnKyMmjQIAVQWrVqZfN4Ll26pOh0OsXJyUnZsmWL0bqjR48qS5YssbnPXD/99JMCKE5OTsp3332Xb31mZqaybt065cMPP7R7H/c6c+aMcuLECSUzM9NhfRakY8eOCqBs27bN6m3sPQ8URY1BAOXhhx+2edvSRIJTG3z22WcKoISFhZX0UOwmwalj3K/BaVkTExOjaLVaRafTKb///rui0WgUnU6nXL16taSHJu5x69YtxdPTU6lUqZKSk5NjtC4tLU1xdnZWAOWXX34poREWvcIEJebExMQY3v8SExNt2nb58uUKoDRv3txh48k1YsQIBVCGDRvm8L5Lk+IOThVFUaKiohStVqucP3/eru1LA5lzaoP4+HgAAgMDbd7W3LyTvHP4zp8/z8iRIwkJCcHV1ZXq1aszY8YMMjIyTPaZnZ3NO++8Q4MGDXBzcyMoKIhBgwZx/Phxw9zPMWPG2DTOW7duMWvWLBo3boy3tzceHh40bNiQN954g9TUVJuP2xqrVq1i/PjxNGjQgAoVKuDm5kbVqlV57LHHOHXqlMltMjIymDt3Ls2aNcPb2xsXFxdCQkJo0aIFL7zwAjdv3rRq3zk5OUyaNAmNRkPDhg25dOmSIw/NSFpaGu+88w6tWrXCz88PNzc3ateuzQsvvMCNGzfytc/KyuKbb77h0UcfpU6dOvj4+ODu7k7t2rV56qmnuHr1qsn95D3XfvvtN/r160dgYCBardYwVzTv3Ktt27bRo0cPKlSogLu7O02bNuWrr74y2be5OaezZ89Go9Ewe/Zsrl+/zuTJkwkPD8fFxYXw8HCefPJJbt++bbJPRVH4/PPPad68OR4eHvj7+9O7d2/++OOPQs/7+/zzz9Hr9fTu3Zs2bdrQpUsXcnJyWLx4scXtrly5wvPPP0/Dhg3x9vbG09OTWrVqMWbMGP7444987VNTU5k/fz7t2rWjQoUKuLq6EhERQb9+/ViyZIlR24LmvZl7jfMuP3r0KEOGDCE0NBSdTsfs2bMB+88ZUH8Pq1atom/fvoSEhBj+ptq1a8d///tf0tLSABg9ejQajYY5c+aY7ev7779Ho9HQsmVLs23u9cUXX5CSksLIkSPRao0/mm7evElWVhYAQUFBVvcJxufmxYsXGTVqFKGhobi5uVGrVi1mz55tOLa8zJ17eeeF5uTkMG/ePJo0aYKXl5fRvPbjx48za9Ys2rZtS6VKlXBxccHf359u3brx/fff23QMheHkpM7e02q1ODs727Xt5cuXyczMdOi4cj9Pbf195n39s7Ozefvtt6lfvz7u7u4EBAQwePBgTp48aXJbc3971rxnJicn8+mnnzJgwABq1qyJp6cnnp6eNGzYkJdfftns+1tJGDNmDHq9noULF5b0UOxX0tFxWfL1118rgKLT6ZTNmzfbtK25b0+5VxSffvppxcfHR4mIiFAGDx6sdOvWTXF3d1cApX///vn6y8nJUfr27asAiouLi9KjRw9lyJAhSrVq1RQPDw9lypQpJq9UWrpyeuzYMSU8PFwBlNDQUKVXr15Kv379lODgYAVQGjdubPftXEtXTnU6neLh4aE0b95cGTBggPLggw8q1apVUwDF09NT+f333/Mde9euXRVA8fHxUXr37q0MGzZM6datm+GK5p9//mm0DSaunCYnJyu9e/dWAKV79+42XVWw9crplStXlIYNGyqAUrFiRaVbt27Kww8/bOgnMjIy363KS5cuKYDi6+urtGrVShk0aJDSp08fJSwsTAGUwMBA5fTp0/n2lXuu/etf/1K0Wq1Sr149ZejQoUqPHj0Mt+Fy9ztz5kxFo9EozZo1U4YOHaq0atXK8Fq9++67+frO/T3ee9yzZs1SAOWxxx5TKleurAQHBysDBgxQ+vTpo/j6+iqA0qJFC5O30yZNmqQAilarVTp27KgMHTpUqV+/vqLT6ZTnnnvO7iv9er3ecJyrVq1SFEVRvv32WwVQatWqZXa7zZs3K35+fgqgBAUFKQ899JAyaNAgpUWLFoqzs3O+czgmJkapV6+eAigeHh5K9+7dlaFDhyrt27dXfH198139yB2Tuasa5l7j3OUTJkxQXF1dlcjISGXw4MFKv379lP/7v/9TFMX+cyYzM1MZMGCA4ffQqlUrZdiwYUr37t0N0yFyx3vgwAEFUKpUqaJkZ2ebPIYOHToogLJ48WKzr7O5bUy9t2ZkZCgeHh6Gc+zeK6uW5J6bo0aNUvz9/ZXg4GBl0KBBSt++fRVPT08FUNq2bZtvmpa598rcq1pVqlRRHnzwQcXFxUXp2rWrMmzYMKVRo0aGduPGjVMApU6dOkrPnj2VIUOGKK1bt1a0Wq0CKM8++2y+sTr6yml6eroyZswYBVB69uxp8/Y3b940vEZPPvmkQ8aUK/f1qVSpknL58mWrt8v7Gg0YMEBxdnZWunXrpgwdOtTwueHl5aX88ccf+bY197dnzXvmb7/9ZvgbateunTJkyBClR48eir+/vwIoNWrUUBISEvLtszBXTgMCApQ5c+Yojz/+uDJlyhTl3XffVU6ePFng9kePHi3wfa60k+DUBsnJyYY3ao1Go3Tq1El5/fXXlXXr1inXrl2zuG1BwSmgvPzyy0Zv9keOHDG8Mdz7h/bee+8Zgsi8J2t2drby9NNPG/q0NjhNTU1VqlevrgDKjBkzlIyMDMO6lJQUZdiwYQqgjB071opXKj9LwenSpUuVO3fuGC3T6/XKggULDHPM9Hq9Yd2vv/6qAEqTJk2UpKSkfP3t27cv35vEvcHp5cuXlcaNGxuOydY5SLYEp3q9Xmnbtq0CKOPGjTMac1ZWliEA69y5s9F2SUlJyo8//mj0u1AUNZCYPn26Aih9+vTJt7/ccw1QFixYYHH8zs7Oytq1a43WffHFF4YAJzU11WhdQcEpoIwZM0ZJT083rIuJiTH83dw7R+3HH380fJjc+yXknXfeMfRpT3C6ceNGQ4CZ+/tNS0szBJ47duzIt01MTIwhmJ42bVq+1z4+Pl757bffDP/OyclRmjdvrgBKjx498r0PpKWl5Zs/WdjgNHdspgI0e8+ZqVOnGr4kHTp0yGidXq9XNm/ebPTFNPd8zg368zpy5IjhQzzveWBJamqq4uLiomi1WpN/04qiGL2vRUZGKk8++aTy9ddfK8eOHTN6f7hX3nPzoYceMjqnL126pNSqVcvwmuZVUHAKKJUrV1ZOnTplcr/bt29Xzp49m2/5yZMnlcqVKyuAsmfPHpN92xucHjhwQBk9erQyatQopXfv3kpAQIDhi6EtAWBeL730kuF4X3/9dbv6MGXv3r2Kk5OTAiju7u7KwIEDlfnz5ys7duyw+GxG3tc/ICBA+euvvwzrsrOzlSeffNLwGt57/hUUnFp6z7x06ZKyefPmfH93KSkpyqhRowzB7b0KE5ya+tFoNMqIESOU5ORks9vr9XrD+9ylS5es3m9pIsGpjU6ePKlER0ebPGkaN26sLFy40OTVhIKC02bNmpl8g33iiScUQHnttdeMlud+Q/zkk0/ybZORkWEIBqwNThcuXKgASt++fU0ed3JyshIUFKQ4OTkpN2/eNNnGEnvnnLZu3VoBlGPHjhmWff/99wqgPPXUU1b3kzc4/euvvwwfDve+rtayJTj9+eefDedHVlZWvvU5OTlKgwYNFEA5cuSI1WMICwsz+WGee6516dKlwPFPnTrV5Po6deqYDOAKCk4rV65s8oPlP//5j+GqV15dunRRAGX69Okmx9GiRQu7g9MhQ4YooD68mNe//vUvs+fiM888o4D1D02tXr3a8CXR0odFXoUNTmvVqmX2imVBTJ0z8fHxiouLiwIo+/fvt6qf3L/Brl275lv3+OOPW/ydmrJv3z7D1UhzMjMzlWeeecYw9zTvT0BAgDJ58mSTAVjuuenu7m7yoaG1a9cqoN6FyXv11Jrg9KuvvrL6GPP65JNPFEB5/vnnTfZtb3D6ww8/5HttunXrZjJItsbKlSsVLy8vpU2bNoYr13PmzLGrL1PWrl1reC/O++Ps7Kx0795d2bhxY75t8r7+8+fPz7c+PT3d8Pn37bffGq0rKDi19J5pSUpKiuLk5KQEBgbmW2dPcHr16lVlwoQJyi+//KJcunRJSU1NVY4dO6a8/vrrhgtWPXr0sPilLPez88cff7TnkEqcpJKyUe3atdm9ezd79+5l3bp17Nmzh4MHD3L9+nUOHTrEpEmTWLlyJevWrcPFxcXqfvv27WsyD2fdunUBdQ5crsuXL3Pu3DkAhg8fnm8bFxcXBg4cyHvvvWf1/tetWwfAkCFDTK738vKiefPmrF+/nn379tGjRw+r+7bGmTNn2LBhA2fOnCE5OZmcnBzg7rykU6dOUa9ePQCaNm2KTqfj888/p1atWgwYMIDQ0FCr9vPLL78waNAgMjIy+PrrrxkxYoRDj8OU3Nf2kUceMczhykur1dKhQweOHj3KH3/8QYMGDYzW//XXX2zZsoXz58+TkpKCXq8H1DnHer2eM2fO0KRJk3z9mktBkle/fv1MLq9bty4nT540Ou+s0bVrVzw8PEz2B8bncXZ2tmH+5qOPPmqyv+HDh7Nv3z6bxgBw48YNVq9eDcBjjz1mtO6xxx7jo48+Yvny5XzwwQd4e3sb1m3YsAGAiRMnWrWf3PbDhw/Hy8vL5nHao3///uh0OottbDlntm3bRmZmJs2aNTOZnsaUhx9+mPDwcLZs2cLJkyepU6cOAImJiXzzzTfodDomTZpk9THl/p37+/ubbePs7My7777Liy++yOrVq/ntt984ePAgp06dIiEhgQULFvDdd9+xceNGk8fRo0cPQkJC8i3v27cv/v7+3Lhxg4MHD9KmTRurx11QysA7d+7w888/8+eff5KQkGCYtxkbGwtgdk69vfr374+iKOTk5HD58mU2b97MrFmzaNCgAV999ZVV7wm5tm7dypAhQ2jRogVbt25l165d9O3bl+nTp6PT6Xj++eeN2tesWZMzZ85w6tQpatWqZdU++vbtS8+ePfnll1/YvHkz+/bt49ChQ6SmprJp0yY2bdrEK6+8wquvvmpye1NpC11dXRkyZAjz5s1j+/btJj8jzbHm9fnjjz/47bffiImJITU1FUVRAPVz9/r169y6dYsKFSpYvU9TQkND+d///me0rF69etSrV48ePXrQpk0bNm7cyI8//kj//v1N9pH7t5T7t1XWSHBqp5YtWxom+yuKwp9//sncuXNZunQpmzdv5r333sv3x2tJlSpVTC738fEBID093bDs8uXLAAQEBJj9QLQ1iXNusDty5EhGjhxpsW1ukuudO3fy2Wef5Vvfv39/s38w98rJyWHKlCl88sknhj9yU5KSkgz/X716dd59912ef/55pkyZwpQpU4iIiKB169b07duXQYMGmf1i0LdvX7Kzsw0PjRSH3Nd25syZzJw502LbvAnEcx8O+eGHHyxuk/e1ycuac8CW884atvSXkJBg+Le5sdp6Huf65ptvyMjIIDo62vClJlezZs1o1KgRhw8fZunSpUyYMMGw7uLFiwCGYKsgtrZ3BEuviT3njD3H4OTkxL/+9S+mT5/Ohx9+yIcffgjA4sWLSUlJMQSv1kpMTATunieWhISE8MQTT/DEE08A6ofvkiVLePXVV7l58yajRo3i2LFj+barWrWq2T4jIyO5ceOG4b3VGkFBQSa/iOVau3YtY8eONfmwYy5zf7uFpdPpiIiIYNy4cXTt2pX69eszduxY2rVrZzJAv5eiKEyZMoXs7GwWLlyIq6srnTp14ueff6ZPnz688MIL6HQ6pk6dCqgPC128eJGwsDCbc2s6OzvTt29fQ27ajIwMtm/fzowZM9i/fz+vvfYaDzzwQL6H6/z8/PDz8zPZZ+7v2pbfJ1j+27p27RqPPPIIO3futNhHUlJSoYNTS1q2bEm/fv1YvXo1a9euNftZm/u3dOvWrSIbS1GS4NQBNBoNTZs25bvvviM1NZU1a9awevVqm4LTe59OtXa/9qwzJffKSq9evQgODrbYNiIiAlCvdpp66jkyMtLq4PS9997j448/JiQkhHnz5tGmTRuCg4Nxc3MD1CtS3333Xb7A9cknn2Tw4MGsWbOGnTt3snPnTpYuXcrSpUuZNWsWv/32m8mrqaNHj2bRokXMnDmTNm3aWPzAcpTc17Zdu3ZUr17dYtu8SbKnT5/ODz/8QJ06dfjPf/5DixYtCAgIMATebdq0YdeuXWaDend39wLHZs95V5z92VvVa9GiRYD64WSq6EPul4BFixYZBaelQe75Yo6l32thzxlbTJgwgddee42vvvqKOXPm4OXlxUcffQTAlClTbOorN8iwJ1gLDg7m2WefJTIykgEDBnD8+HFOnz5tVwJyW14XS7+HK1euMGTIENLS0njhhRd49NFHiYyMxMvLC61Wy8aNG+nZs6dDfg8FiYyMpHPnzqxbt45NmzYVePEB1CqIJ06cICgoiKioKMPy9u3bs2HDBnr37s1zzz2HTqfj6aefZunSpWRlZTF27NhCV+JzdXWlZ8+etG3bljp16nDlyhV+/PFHmzI/5LL19bX0Ox0/fjw7d+6kdevWvPrqq0RFRVGhQgVDBoSwsDBiY2OL5Xdat25dVq9ebTH4zv3CV5SBclGS4NTBevTowZo1awpdLs6SSpUqAeoHbEpKCp6envna2FqeLTw8nJMnTzJu3Dirb/2MGTPG5lRV98pNqfLJJ5/w4IMP5lt/+vRps9sGBwczYcIEQ3Bx8uRJHnvsMXbt2sW0adNMBs6ffvopXl5evPfee7Rv357NmzcX+VWv3CtIDz30EP/+97+t3i73tVm2bBmNGjXKt97Sa1MW+Pv74+rqSkZGBhcvXsx3hRNsP48B9u3bx5EjRwA1SLA0NWHPnj0cO3bM8KWgSpUqnDp1ipMnT1pVtSz3SrG51DWm5AaKycnJJtfnXsm0hz3njD3HAOrv79FHH+Wzzz7jq6++olatWobpN126dLGpr9x0QpauMhYk71SjhISEfMHp+fPnzW6be55VrlzZ7v3ntXbtWtLS0nj44Yf573//m299cf/t5n5GXLt2zar2uWmRcqdX5dW2bVt++eUXevXqxTPPPENqaioffvghgYGBNl2QKYiXlxetW7dmxYoVJj9Pb9++ze3bt01ePXX07zMlJYX169ej1WpZv359vn2mpKQQFxfnkH1ZI/fvJO+UJHNtCrrYVFpJnlMbWPONKCYmBnDcH4Up4eHhhtsP3333Xb71mZmZJutSW9K7d2+AYs2/BxjykeZejc3r2LFjHDp0yOq+6tSpw4svvghgdjuNRsP8+fOZMWMGV65coUOHDjbtwx65r+3y5ctt+lZt6bX55ZdfivQLUHFwdnY2lD68NxdoLlPnd0Fyp5oMGTIERX3o0+TP4MGDgbtXWUG9cwDqlxhr5Lb/7rvvSElJsWqb3C+XJ06cyLcuLi6OgwcPWtWPKfacM126dMHFxYUDBw7YvO+nnnoKgAULFhhu7U+ePNnWYVO/fn1cXFy4fPmyyaDdlvdeuPsa57Vx40aTwdn69eu5ceMG3t7eVs+5LYil34OiKGbP96KQkZFhuBVt7VzQ2rVr4+zszI0bN9i0aVO+9a1bt2bjxo34+vry0ksvcfXqVRYvXoyvr6/V43LE5+nXX3+db1lmZibLli0DsDs/8r0SExPJycnBx8fHZDD8zTffFMsVU1AD4bVr1wKYvZqs1+sN7y+OOqeLmwSnNvjoo48YPXq0ySTcyj8JrHPfoIcOHVqkY8n9UJg1axZ///23Ybler2f69Ok2J5OfOHEiERERLF++nBdffNHkB0RcXJzVH9rWyn1QZsGCBUa3M2NjYxk1ahTZ2dn5ttm6dSvr1683JOXOpSgKP/30E2D6QyGv119/nbfffpvr16/TuXNndu3aVdhDMeuhhx6iRYsW7N27l7FjxxrNK81169YtPv74Y6PjzX1tPvjgA6O2p06dMsy3K+tyz+P333+f3bt3G61777332LNnj039paamsnTpUsD0wxJ5jRo1ClA/WHLPpalTp+Lt7c2aNWuYMWNGvnPs2rVrRnPOHnzwQZo0acLVq1cZNGhQvit/6enp/Pzzz0bLunXrBsB///tfo8Td169fZ9SoUdy5c8eGIzZmzzkTFBRkeHhp0KBBHD161Gi9oihs3brVcJswr4YNG9KlSxdOnDjBmjVr8PHxMbyutnB3d6dVq1bo9XqTv/PExESaNm3K119/bfL1OXfunOHBtzZt2pic+5yWlsakSZOMEu5fvXqV5557DoAnnnjCMJ2osHJ/DytWrDA8/ATqlchXXnnF5GeIva5du8bChQtNTom4cuUKI0eO5OrVq0RGRtK9e3er+vT19WX8+PGA+rBibjCUV05OjtH81V9//dWmcY8bN44ZM2Zw5syZfOvS0tKYPXs2e/fuxcnJyezdvNdff93ofNXr9bz44otcvnyZ8PDwAh9Ys1ZwcDAVKlTg9u3b+QLi3bt3M336dIfsJ9f//vc/k5/h58+f56GHHiI2NhY/P798D3vmOnbsGImJidSqVcvkF7UyoXiSApQP7777riGFRWBgoNKjRw9l+PDhSp8+fZTIyEjDuhEjRuTLhVZQKilzKYlyc07em/YmOzvbkEDe1dVV6dWrlzJ06FClevXqiru7uyFdzoQJE4y2s5SE/+jRo4bj8PPzUzp06KAMHz5c6d+/v1KvXj1Fo9EowcHBtr5sRsd573Hs3r3bkMamRo0ayuDBg5VevXop7u7uSv369ZWHH3443+uT+3vw8fFROnXqpAwfPtwoob2vr69VSfgVRU2hpdFoFE9Pz3y1oy3J3Ve1atWU6Ohosz8HDhxQFEVNwp+bV9XT01Np06aNMnToUGXAgAFK48aNFZ1OpwBGqWxWrlypaDQaBVAaNmyoDB06VOnSpYvi7OysdOnSRWnTpo3Jc8qa1CWFTWdkLpXUrFmzTPZn6bybOHGiAmpxi06dOinDhg1TGjRooOh0OuXZZ59VQC2SYI0vv/xSAZSQkJAC0y1lZWUZCkysWLHCsPyXX35RvL29FUAJDg5W+vfvrwwaNEhp2bKlyST8Fy5cUGrXrq2AmoS/R48eyrBhw5QOHTqYTMJ/69Ytw+ufm+S/W7duiq+vr9KwYUOlf//+Nr32edl7zmRkZCgPPvigAmoS/tatWyvDhw9XevTokS8J/71y02lB4RK1z5s3TwGUF154Id+6W7duGfbh6uqqtGzZUhk0aJAycOBAJTo62pDYPiIiQvn777+Nts2bhL9ixYpKSEiIMmjQIKVfv36GtDytW7fOl9O3oFRSltI9ZWVlKc2aNVNAzeH7wAMPKIMHD1YiIiIUZ2dn5cUXX7S773vlbuPi4qK0bNlSGTx4sDJo0CClVatWhvfWsLCwfPlrC5KWlqY89NBDhte9Vq1aSv/+/ZWBAwcazndfX19l7ty5SmBgoAJqrm5r5e27WrVqSr9+/ZThw4cr3bp1UypUqGB4T/joo49MHm+VKlWUhx9+2JB2KvfzL/c9Nm8+4lwFpZKy9J6Z9/M/OjpaGTZsmNK2bVtFo9EoI0eOLFTf94qKilI0Go3SoEEDZcCAAcrQoUOV6OhoxdXVVQEUf39/5ddffzW7vaW/pbJCglMbJCUlKatXr1aefPJJpWXLlkrlypUVZ2dnxd3dXalevboybNgw5eeffza5raODU0VR8/69/fbbSr169RRXV1clICBAefjhh5UjR44or732moKJXIOWgoTcY3z77beV1q1bK35+foqzs7MSGhqqtGjRQnn++edNVt2whqU8p4cPH1YefPBBJTQ0VHFzc1Nq1qypvPDCC0pSUpLJ1+fMmTPK7Nmzla5duypVqlRR3NzclAoVKiiNGjVSpk2bZjLpsLngVFEU5ZtvvlGcnJwUNze3fAnpzcl9IyroJ+/vOz09Xfn444+Vzp07K/7+/oqTk5MSFBSkNG7cWJk8ebLJmuE7duxQunbtqgQEBCgeHh5KgwYNlDfffFPJyMgwe06VteBUr9crn376qdK0aVPFzc1N8fPzU3r06KHs2LFD+eqrrxSwvv52+/btFUD597//bVX73LymvXv3Nlp+8eJF5emnn1Zq166tuLm5KV5eXkqtWrWUxx57TNm1a1e+fpKTk5X//ve/SosWLRRvb2/F1dVViYiIUB588EFl6dKl+dpfvnxZGTVqlBIUFKS4uLgoVatWVZ5//nklOTnZ5tf+XvacM4qi/h6WLFliqHrj7OyshISEKO3bt1fmzp2br4JS3mPX6XSKRqOxqnqNObdu3VI8PT2VsLCwfF8s9Hq9smfPHuWtt95SevToodSsWVPx9vZWnJ2dlaCgIKVz587KvHnz8hXzUBTjc/PcuXPKsGHDlODgYMXFxUWpUaOG8sorr5jMzVuY4FRR1NflpZdeMpxDQUFBSv/+/ZX9+/cXuu+8UlJSlHfeeUd56KGHlOrVqyve3t6Kk5OTEhAQoHTo0EGZO3euTdXv7rVq1SpDpUAnJydD9bE33nhDuX79uqIoirJnzx5DHtRXXnnFqn4vX76sfPHFF8qIESOUqKgoQx5tb29vpVGjRsqUKVOUo0eP5tsu72uUlZWlvPnmm0qdOnUUV1dXpWLFisojjzxilBc7r8IGkKtXr1batGmj+Pn5KV5eXkrz5s2Vjz76yKganSOC00WLFimDBw9W6tSpo1SsWFFxcnJS/Pz8lBYtWiizZs1S4uPjLW4fFRWlaLVas+/vZYEEp+VU586dFUBZuXJlSQ9FCLuNHTtWAZR33nmnpIcizPj0008VUJOCF9bkyZMVQFmzZo0DRqYq6IuTKFscXeK1vNm/f78CKA8//HBJD6VQZM5pGXbo0CFDUudcmZmZzJ49m23bthEUFESfPn1KaHRCWOfYsWP5HibS6/V8+umnfPnll7i5uTFs2LASGp2wJCUlhTlz5gAY5m4WxqxZs/Dz8+O1114rdF9C3I9eeeUVXFxcTGaJKEsklVQZ9swzz3Do0CGioqIIDQ3l1q1bHDlyhNjYWNzc3Fi8eLHDJvgLUVTmzp3L999/T5MmTahUqRIpKSkcP36cCxcuoNPp+Oijj6yuACaKx9y5czl69Cg7d+7k3Llz9OrVyyFV4wIDA5k9ezbPPPMMK1assKmikRD3u507d7J+/Xqef/55u/L8liYSnJZhEyZM4Ntvv+Xw4cPs3bsXRVEICwvjscce47nnnjOZN1KI0mbIkCEkJSVx4MABDh06RHZ2NkFBQQwZMoRnnnmGVq1alfQQxT3WrVvHr7/+SkBAAGPGjGHevHkO6/vpp5/m6aefdlh/Qtwv2rVrV2wprYqaRimFR7JgwQLmzp1LXFwcUVFRfPDBBxarQ8yfP5+FCxcSExNDQEAAAwcOZM6cOYarhrNnz85Xm7d27dpGSafT09N57rnnWLp0KRkZGfTs2ZOPPvqozCawFUIIIYQoi0rdnNNly5YxdepUZs2axcGDB4mKiqJnz55mK1ssWbKEadOmMWvWLE6cOMGiRYtYtmwZL730klG7+vXrExsba/i5tz7us88+y9q1a1m+fDm//vorV69eZcCAAUV2nEIIIYQQIr9Sd+U0OjqaFi1aGJLZ6/V6wsPDefLJJ5k2bVq+9lOmTOHEiRNs2bLFsOy5555jz549hgB09uzZrF692mwloMTERAIDA1myZIlhjtPJkyepW7cuu3btktuKQgghhBDFpFTNOc3MzOTAgQNG1Ra0Wi3dunUzW8GnTZs2fPPNN+zdu5eWLVty7tw51q9fz8iRI43anT59mrCwMNzc3GjdujVz5swxVBE5cOAAWVlZhsotoJbCrFKlisXgNCMjg4yMDMO/9Xo9N2/exN/fH41GY/frIIQQQghREEVRSE5OJiwsDK221N0Mt1upCk4TEhLIycnJN88zODjYaH5oXsOHDychIcEwETg7O5snnnjC6LZ+dHQ0X375JbVr1yY2NpZXX32V9u3bc/ToUby9vYmLi8PFxSVfzdzg4GDi4uLMjnfOnDn55rIKIYQQQhSnS5cuUbly5ZIehsOUquDUHtu3b+ett97io48+Ijo6mjNnzvD000/z+uuvM3PmTAB69+5taN+oUSOio6OJiIjg+++/Z9y4cXbve/r06UydOtXw78TERKpUqcKlS5fw8fGx/6CEEEIIIQqQlJREeHg43t7eJT0UhypVwWlAQAA6nY74+Hij5fHx8YSEhJjcZubMmYwcOZLx48cD0LBhQ1JSUpg4cSIvv/yyycvcfn5+1KpVizNnzgAQEhJCZmYmt2/fNrp6amm/AK6urri6uuZb7uPjI8GpEEIIIYpFeZtKWKomKLi4uNCsWTOjh5v0ej1btmyhdevWJrdJTU3NF4DqdDoAs/m+7ty5w9mzZw2JvZs1a4azs7PRfk+dOkVMTIzZ/QohhBBCCMcrVVdOAaZOncro0aNp3rw5LVu2ZP78+aSkpDB27FgARo0aRaVKlQwl8/r168e8efNo0qSJ4bb+zJkz6devnyFI/fe//02/fv2IiIjg6tWrzJo1C51OZyiJ6Ovry7hx45g6dSoVK1bEx8eHJ598ktatW8uT+kIIIYQQxajUBadDhgzh+vXrvPLKK8TFxdG4cWM2bNhgeEgqJibG6ErpjBkz0Gg0zJgxgytXrhAYGEi/fv148803DW0uX77MsGHDuHHjBoGBgbRr147du3cTGBhoaPPuu++i1Wp55JFHjJLwCyGEEEKI4lPq8pyWZUlJSfj6+pKYmChzToUQQghRpMpr3FGq5pwKIYQQQoj7mwSnQgghhBCi1JDgVAghhBBClBoSnAohhBBCiFJDglMhhBBCCFFqlLpUUkIIIYQQRSYrHY6uhBNrID0JvEOg8XCo0Q3KWaWlskqCUyGEEELcHy7vh++GQco14+XHVkFIIxj+PfiElszYhIHc1hdCCCFE+XfjLHw9IH9gmivuMHz9MGSlFe+4RD4SnAohhBCi/Pv9PchItNzm+gk4srx4xiPMkuBUCCGEEOVbZiocWWFd2wOLi3YsokASnAohhBCifEuOhawU69rePFu0YxEFkuBUCCGEEOWbk6sNbd2KbhzCKhKcCiGEEKJ8860MgXWta1uja9GORRRIglMhhBBClH8tx1vXroWV7USRkeBUCCGEEOVfs7FQ+wHLbTq/DGFNimc8wiwJToUQQghR/ml1MPgr6PQSeAYZrwuoDf0/ho4vlMzYhBGNoihKSQ+ivEhKSsLX15fExER8fHxKejhCCCGE4+RkQdotcHYHV++SHk3h5GTBxT8gI1ktX1q5uXXbpd2CnGzwqKgGuyWsvMYdUr5UCCGEEObdOAu7FsDhZZB5R10W2R6iH4e6/Up2bPbSOUO1jta11efAn9/Avs/UKlIAnoHQZCS0mgReQZa3FzaTK6cOVF6/wQghhLhPXfgdlgyBzGTT66MnQe//FO+YilNOFiwbAX9vML3epxKMXgv+1Yt3XP8or3GHzDkVQgghRH5pt2DpMPOBKcCehepVxfJq6xvmA1OApCvw3TCQ63wOJcGpEEIIIfL781tIL6AWPcDuhUU/lpKQmQoHvii4XcIpOLO56MdzH5HgVAghhBD5HfvBunbxR+H6qaIdS0k4u8W64Bzg6KqiHct9RoJTIYQQQuSXftv6tmk2tC0rrA1MwbbXShRIglMhhBBC5HdvLlBLvAKLbhwlxdOGY7KlrSiQBKdCCCGEyK/RYOvaVW4JFasV7VhKQrXO1gfoUUOLdiz3GQlOhRBCCJFfo8HgHVZwu7ZPF/1YSoKTi5rHtCCVW0BEm6Ifz31EglMhhBBC5OfiCSNWgleImQYa6P461O1brMMqVu2ehaajza8PqgdDvi2+8dwnJAm/A5XXZLhCCCHuYyk34OCXaj7T25fAxQNq94GWE6BSs5IeXfE4sxn2LYJzv4I+CwJqQ/MxEDVMDeJLSHmNOyQ4daDyepIIIYQQ5UZyHJzeBFmp4FcFanQHnRXV3BMvw5ktkJ0OFapCja6g1RX9eC0or3GHFb8NIYQQQogyLuUGrH8OTqwFffbd5d6h0P459UqwKXeuwbqpcHI9KDl3l/tUhk4vQtNRRTvu+5AEp0IIIYQo39JuwRe91WpO90qOhfX/htSbarCZV0oCfN4Tbp7Lv13SZVjzpNp3eX0orITIA1FCCCGEKN9+fdt0YJrX9rcg4bTxsq1vmA5M89o8G27HFGp4wpgEp0IIIYQovzJT4ZCVT9TvW3T3/9OT4PD3BW+j6GH/5/aNTZhUKoPTBQsWEBkZiZubG9HR0ezdu9di+/nz51O7dm3c3d0JDw/n2WefJT093bB+zpw5tGjRAm9vb4KCgujfvz+nThl/g+rUqRMajcbo54knniiS4xNCCCFEMYk/Zn0p0os77/5/7CHISrFuuwu/2zwsYV6pC06XLVvG1KlTmTVrFgcPHiQqKoqePXty7do1k+2XLFnCtGnTmDVrFidOnGDRokUsW7aMl156ydDm119/ZfLkyezevZtNmzaRlZVFjx49SEkxPukmTJhAbGys4eftt98u0mMVQgghRBHL+/BTgW319m2X90EpUWil7oGoefPmMWHCBMaOHQvAxx9/zLp16/j888+ZNm1avvZ//PEHbdu2Zfjw4QBERkYybNgw9uzZY2izYcMGo22+/PJLgoKCOHDgAB06dDAs9/DwICTEXLJhIYQQQpQ5ATVB5wI5mQW3Dap79/8D64BGZ13gGVTP/vGJfErVldPMzEwOHDhAt27dDMu0Wi3dunVj165dJrdp06YNBw4cMNz6P3fuHOvXr6dPnz5m95OYqF7er1ixotHyb7/9loCAABo0aMD06dNJTU21ON6MjAySkpKMfoQQQghRingGQN1+1rVt/tjd//cJg1o9rduuxTjbxyXMKlVXThMSEsjJySE4ONhoeXBwMCdPnjS5zfDhw0lISKBdu3YoikJ2djZPPPGE0W39vPR6Pc888wxt27alQYMGRv1EREQQFhbG4cOHefHFFzl16hSrVq0yO945c+bw6quv2nGkQgghhCg2HaepVZ4szT2t0xci2xov6/wynN8BmXfMb9dwEIQ1ccw4BVDKrpzaY/v27bz11lt89NFHHDx4kFWrVrFu3Tpef/11k+0nT57M0aNHWbp0qdHyiRMn0rNnTxo2bMijjz7KV199xQ8//MDZs2fN7nv69OkkJiYafi5duuTQYxNCCCGEAwTWglE/gl+EiZUaaDQUBpp44j6kAYxcrSbcz7eZFpqMhP4LHT3a+16punIaEBCATqcjPj7eaHl8fLzZuaAzZ85k5MiRjB8/HoCGDRuSkpLCxIkTefnll9Fq78bfU6ZM4aeffmLHjh1UrmziRMsjOjoagDNnzlC9enWTbVxdXXF1dbX6+IQQQghRQsKawFOH4PQvcGo9ZKWp5UsbPwr+pj/nAQhvAU//pW5zeuPd8qVNRkAFU8GuKKxSFZy6uLjQrFkztmzZQv/+/QH1NvyWLVuYMmWKyW1SU1ONAlAAnU6tdasoiuG/Tz75JD/88APbt2+natWqBY7l0KFDAISGhtp5NEIIIYQoVbRaqN1b/bGFzgnqPaj+iCJXqoJTgKlTpzJ69GiaN29Oy5YtmT9/PikpKYan90eNGkWlSpWYM2cOAP369WPevHk0adKE6Ohozpw5w8yZM+nXr58hSJ08eTJLlizhxx9/xNvbm7i4OAB8fX1xd3fn7NmzLFmyhD59+uDv78/hw4d59tln6dChA40aNSqZF0IIIYQQ4j5U6oLTIUOGcP36dV555RXi4uJo3LgxGzZsMDwkFRMTY3SldMaMGWg0GmbMmMGVK1cIDAykX79+vPnmm4Y2Cxeq80E6depktK8vvviCMWPG4OLiwubNmw2BcHh4OI888ggzZswo+gMWQgghhBAGGiX33rcotKSkJHx9fUlMTMTHx6ekhyOEEEKIcqy8xh1l/ml9IYQQQghRfkhwKoQQQgghSg0JToUQQgghRKkhwakQQgghhCg1JDgVQgghhBClhgSnQgghhBCi1JDgVAghhBBClBoSnIpSJyM7h+vJGaRmZpf0UIQQQtgq9SakJIBeX9IjEWVUqasQJe5fp+KS+ey3c6w9fJX0LD0aDXSoGcjYtpF0qh1U0sMTQghhTk4WHFwM+xbBtePqMq8QaDYaop8Aj4olOz5RpkiFKAcqr5UaisPWk/FM+uYgGdmmv2k/3bUmz3avVcyjEkIIUaCsdFgyGM7/anp9hUgY/RP4hRfrsO4H5TXukNv6osTFJqYx+ds/zQamAO9tOc3GY3HFOCohhBBW2fiy+cAU4NYF+H5ksQ1HlH0SnIoSt2RPDGlZOQW2W7TzfDGMRgghhNXSbsOf3xbc7uqfcPGPIh+OKB8kOBUlbt3hWKva7Tl/k2vJ6UU8GiGEEFb7ewNkp1nX9uiqoh2LKDckOBUlLjEty+q2SWnyBL8QQpQaabetb5tuQ1txX5PgVJS4AC9Xq9ppNVDR06WIRyOEEMJqXoHWt/WUrCvCOhKcihLXv0klq9p1rBUowakQQpQmtXqDq691baOGFO1YRLkhwakocUNahFPBw9liG60GJnaoXkwjEkIIYRUXD2g5oeB21TpBaFSRD0eUDxKcihJX0dOFz8e0wM9MgKrTanjz4Ya0ru5fzCMTQghRoM4vQcPB5teHNYGBXxTfeESZJ0n4Hai8JsMtLteS0vl2TwwrDlwmPikdLzcnejcIYVTrSOqGyusphBCllqLA37/Avs/g4u+gz4HgetD8MTVwdXYr6RGWS+U17pDg1IHK4kmi1yvsPJPA+YQUXJy0tKsRQHhFj5IelkNcvZ3Gjr+vk56VQ0SAJx1qBqLTakp6WEIIIa7/DRd3qkFsUF2IbFfSI7Jf6k01pVZGMniHQK1e4GTdg76FVRbjDms4lfQARMn58dAV/m/jKS7dvJujTquBTrWDeL1/Ayr5uZfg6Ox3LTmdmauPsvnENXL0d797hfm68Uy3WgxuISX0hBCiRFz/G9Y/B+d3GC8PqA3dX4PavUpmXPbIuAMbXoQjKyA7Tw5uD39oPRnaTQWNXBCxh1w5daCy9A3mm90XmbH6qNn1ob5urPpXG0J9y1aAmnAng0cW/sHFG6lm27zcpy4TOlQrxlEJIYTg+t/weU9Iu2l6vUYLAz+H+g8X77jskZUGi/vB5X3m27QYDw+8U6TDKEtxhy3kgaj7UMKdDF5be9xim9jEdOasP1lMI3KcdzaeshiYAvxnw0mu3LayookQQgjH+Pl584EpgKKHtU9DpuX38FJh90LLgSn8M/9WSrbaQ4LT+9CyfZfIzNEX2G7D0TgS7mQUw4gcIyk9i9V/Xi2wXY5eYcmei8UwIiGEEAAknIZzvxbcLj0Rjiwv+vEUhl4P+63MPrDvs6IdSzklwel9aM95C99c88jM0XPw4q0iHo3jHLmcSFpWjlVt95yz7jUQQgjhABf/AKycRXjx9yIdSqElxqg/1rhQyo+llJLg9D6k11s/zVhfhqYkZ9twXDll6LiEEKLM02fb0Na6iwwlxpbxKaX8WEopCU7vQ7WCvYukbUmrGeSFtZmiapeh4xJCiDIvuL71bYPqFt04HMGnErhZWbK1tB9LKSXB6X3o0VZVrGrXupo/1QK9ing0jhPm507n2kFWtR3RKqKIRyOEEMKgSisIqldwO60zNB1V9OMpDGc3iBpuXdvmjxXtWMopCU7vQ9UDvXg02nKA6uqk5fletYtpRI7zXI/aeLroLLbp3ziMBpWs/NYrhBDCMbq/DhrL78+0ewa8rLvIUKLaPgXeoZbbRLSFOv2KZzzljASn96nXHmrAmDaRJismBXq78sWYFjStUqEERlY49cJ8+GpcNKG++UvlaTUwrGU4cwdFlcDIhBDiPlezGwz+CtxNfLboXKDDC9BlRvGPyx4+YTD6Jwg0c9u+Vm8YthR0UuvIHpKE34HKYjLc2MQ0vt93mXMJd3DRaelQK5BeDUJw1pXt7y3ZOXo2n4hn28nrpGfnEFHRg0HNw8tNaVYhhCizstLh6Er1qXx9tjovs/EI8Aos6ZHZTlHg3HY4sQbSk8AnVL3lH2zFFAYHKItxhzUkOHWg8nqSlEY7/r7O3F9OcfFGCmigRqAX0/vUpUVkxZIemhBC3H/SbsOhJXBmE2RngGcQOLtD4iV1fUgjdf5lQA3r+7x+CvZ/DnFHQauF8NZQMRJOb4TkeHDzgXoPQf0B6jzQXMlxcGDxP8FvDvjXAI+KEPuXWtmpQiQ0HQkRbRz4ApSM8hp3lMrgdMGCBcydO5e4uDiioqL44IMPaNmypdn28+fPZ+HChcTExBAQEMDAgQOZM2cObm5uVveZnp7Oc889x9KlS8nIyKBnz5589NFHBAcHWz3u8nqSlCZZOXr6L/idY1eTTK5vVbUiSya0QmvtY/tCCCEK58RaWPU4ZKUU0FAD0Y9DzzlqsGmOPgfW/1sNTK3hFQxDv4PKzWD3x7BxBuizCt6uWid1moG1T96XQuU17ih1926XLVvG1KlTmTVrFgcPHiQqKoqePXty7do1k+2XLFnCtGnTmDVrFidOnGDRokUsW7aMl156yaY+n332WdauXcvy5cv59ddfuXr1KgMGDCjy4xW2Gfq/3WYDU4Dd528y4av9xTgiIYS4j53/DZaPsSIwBVBgz8ew9TXLzTbOsD4wBbgTD988DL+/BxtetC4wBfV2/NJH1VvzolQpdVdOo6OjadGiBR9++CEAer2e8PBwnnzySaZNm5av/ZQpUzhx4gRbtmwxLHvuuefYs2cPO3futKrPxMREAgMDWbJkCQMHDgTg5MmT1K1bl127dtGqVSurxl5ev8GUFmev3aHrPCvK3wH7X+5KgHf+h6KEEEI40Bd9bK/opHOF506qt9rvlRwH79a3LWl/LhcvyLxj+3YjV0P1zrZvVwqU17ijVF05zczM5MCBA3Tr1s2wTKvV0q1bN3bt2mVymzZt2nDgwAH27t0LwLlz51i/fj19+vSxus8DBw6QlZVl1KZOnTpUqVLF7H5F8Zv7y0mr287bfLoIRyKEEIKEM/aVGs3JgL++M73u0Lf2BaZgX2AKcHCxfduJIlOqchwkJCSQk5OTb55ncHAwJ0+aDkyGDx9OQkIC7dq1Q1EUsrOzeeKJJwy39a3pMy4uDhcXF/z8/PK1iYuLMzvejIwMMjIyDP9OSjJ/u1kU3vmEVKvbno63801KCCGEdW6es3/bG2fNLDfdZ2yyntg7tt/oDfXSEOpdwHW4G2ds7lcUrVIVnNpj+/btvPXWW3z00UdER0dz5swZnn76aV5//XVmzpxZpPueM2cOr776apHuQ9zl4mT9hX5XG9oKIYSwg5NLIbZ1tanPTw5k8uqvmTbvZlZHF2Z3KmCKl5NMASttSlVwGhAQgE6nIz4+3mh5fHw8ISEhJreZOXMmI0eOZPz48QA0bNiQlJQUJk6cyMsvv2xVnyEhIWRmZnL79m2jq6eW9gswffp0pk6davh3UlIS4eHhNh2zsN4DjUI5ciXRqrYDmlYq4tEIIcR9rnJLcPWFDOvel43U6GpmeTeTD0M93syFB2s7Gy1Ly1Jo94V6R23nWA/cnfNnaQn1siJzS41uBbcRxapUXV5ycXGhWbNmRg836fV6tmzZQuvWrU1uk5qaivaelBQ6nVoeTVEUq/ps1qwZzs7ORm1OnTpFTEyM2f0CuLq64uPjY/Qjis5jbavirCv4jcbDRcfDTSQ4FUKIIuXiAY2trDGfV8XqUN1McFqrF/jmL68d6q2laajO6KdxyN1SqI1DdDRt3ChfmwJv6WudodkY249BFKlSFZwCTJ06lU8//ZTFixdz4sQJJk2aREpKCmPHjgVg1KhRTJ8+3dC+X79+LFy4kKVLl3L+/Hk2bdrEzJkz6devnyFILahPX19fxo0bx9SpU9m2bRsHDhxg7NixtG7d2uon9UXRc3HS8vYjjSy20QALhjdBo5E8p0IIUeS6vAyhNpSEdvGGRz4Dc+/RWp263tnTtnHU6g3DloGvLXcvNdDvPfA2f4dUlIxSdVsfYMiQIVy/fp1XXnmFuLg4GjduzIYNGwwPNMXExBhdKZ0xYwYajYYZM2Zw5coVAgMD6devH2+++abVfQK8++67aLVaHnnkEaMk/KJ0ebhpZTxcdcz44RjX72QYrQvxdWPeoCja1AgoodEJIcR9xtUbxqyDLa+rT+Bn5H0wWAP88xCTRgs1e0DXVyC4vuU+q0TDYz+rfZ7ZnKcPJ3Bxh4zk/NsM+B/4+MK4TbB5Nhz7Qc0KYBiKEyh5sgCENYVO06BWT9uPWRS5UpfntCwrr/nGSquDF2+x7dQ1tBoNPesHUy+s7Fb5EEKIMi/jjppaKvUGVKiqlhe9fkotYxpcH/zy364v0K0LEH/8bhnSChFw7Tgkx5Gid8arQS8A7ty5g6dnnqutKTfgygE1LVVQHfAKgZhdkJ2ujiOgllpy1dULXGy8SluKlNe4o9RdORXCWk0jKtA0okJJD0MIIcTN87D7Izi0JH++0cotoOVE9Za7rVOuUm/A0ZVwYg3kZIJGB7V7Q+vJEGBhOoGnP9TqYbysRleIOwq7FsCxVWqgqtGqD0S1mgTVu9g2NlFkJDgVQgghhP0u7YNvH4F0M0/tX96n/pzZDP0/Bq2Vj7v8tQx+/JdxUn4lB07+BCfXQec3bBvnyXWwfKzx7X5FD6c3qj9dZkCH523rUxSJUvdAlBBCCCHKiIxk+G6I+cA0r8PLYNcH1vUbfzx/YGpEgV9etnqY3I6BFY8ZB6b32voG/L3R+j5FkZHgVAghhBD2+WupeuvdWnv+p84fLcjeT6woY2rDIzP7Fqm38Quye4H1fYoiI8GpEEIIIexzbLVt7ZMuQ8xuK/r9wa7hFLq/c79C6k3H7lvYTIJTIYQQQtgn/bbjt1EU66YJOHKfd3du3zEJh5LgVAghhBD28Qy0Y5sgy+s1Gvv6Lcw+DfvWgYe/Y/ctbCbBqRBCCCHs02iIbe39a0Dl5o7v11H91e4NbpIzu6RJcCqEEEII+zQYYFty/TZPWZfrtMX4gkuY6lys32+z0eDmZ7mNRgetp1jfpygyEpwKIYQQwj5OrvDoSvCpVHDbts+oQaI1KlaFod+YD1B1rvCQDU/WewXB8O/NB6gaHTz4PkS0tr5PUWSkfKkDldcyYkIIIYRFqTfh4FdwcDHcuggo6oNNTu5Qu6d6JTSyne393roI+xfB4e8h5Tq4V4AGj0CLCaS4h+Ll5QWYKF9qTlIs7P8c/voOkmPB1QfqPaRWsAquZ/v4Slh5jTskOHWg4jhJFEXh9zM3OHv9Di5OWtpWD6CKv4ddfaVkZLPl5DVu3MmgoqcLXeoE4e3m7OARCyGEKBeunYSLv6uJ9zOSwCsYvEMgqL66PCtNXefqDc5uUK0z6JzVylBZaeAXoZYK1TmmOGXK7QS8KqgPTt3Z9SWeUQ+Bu5/pxgln4MIONcdqYG3wCoGTa+HaCfCoCNW7qeVNtTq1fU6WWjXq6l+QGAMBtdRpBDoXdfwR7SCwlvnBZWfA3xsgOU59PWr1UvfjYOU1OJXypWXIT4evMveXU1y8kWpYptFAx1qBvP5QA8IrWhekZufombvxFEt2x5CccTfJsaeLjiEtqjCtdx1cnGTGhxBCCNQAbt1zagBqMw1GyfK9w6Dj89D8MfvHo9fD9jmwc+HdZWuehC3ToPFw6PEGOLuryxPOwPrn1PyllpL27/lEfUq/22zIuAM7/g/SCiguENkeHphnHKQqCuycB7sWGBcncHKDhgOh13/B1cvWI77vyJVTByrKbzDL9sUwbdURzP22gn1cWTmpDZUrWA5Q9XqFyUsO8vPROLNtutQJ4tNRzdFprZi0LoQQovyKPw5f9HJ83tHC1LFf9TgcXkpKpoLXnGQA7kz3xtPln8+sqh3UebCJl2BRD0hNcNCgTXCvAI9tvBugrnsO9n1mvn3lFjB67d3guZDK65VTuTxWBtxOzeSVH4+ZDUwB4pMyeHPdiQL7Wn801mJgCrD15DV++POKrcMUQghR3qx7zvGBKcDWN+HGWdu3+3sjHF5quc35Herc159fLNrAFCDtFqz/t/r/F3dZDkwBLu+D3QsttxESnJYF3++/REa2vsB2m47HE59kuXbwV7suWrXPr3db104IIUQ5FX8MYv4oos4V9cEkW+371Lp2uxeqc12Lw/lf4frf1o9t/xfq1ARhlgSnZcDe89bV+c3WK+y/cMvsekVR2H/Bur7+unSb9Kwcq9oKIYQohy4WVWCa278dc1itHdPNs1icY+poF3+3fmyJMXBbLgBZIsFpGZCtt/4PLMfCvX+9ov5YSy/TkYUQ4v6lzy64TXH3X9RjspeSY9vYFLlyaokEp2VA7RBv69sGm2+r02qoEWTdU4LhFd3xcJFkDkIIcd8KKuK8n0H17djGyjG5Oz5tk0VB9a0fm5uvdUUL7mMSnJYBw1tWsaraW/OICgUGso9GW1dmbnjLCKvaCSGEKKeqdgD/GkXXvz3ppJqPta5di/EQ0sj2/u0RVE+tLGXt2KKGq3lghVkSnJYBEf6ejG4dabGNi5OWF3vXKbCvwc3DqVNAAFs90JNHW9lQK1kIIUT5o9FA99dBUwShQr2HoEq07ds1HAxhTSy38YuA6Ceg+2ugLeI7gBqd+hoB1OkHEW0tt/cOhbZPFe2YygEJTsuIV/rWY1y7qjiZyD0a4OXCotHNaRFZ8G0MT1cnvh4XTUszbZtU8WPJhFb4SKUoIYQQdfrAI4vUW9EOoVGvHA6w8sn2ezm7wYhVUK2T6fWhUWoeUU9/qN4Zhnxjwy1+jZrEv15/65q7V4BBX0LNbuq/dU4wfBnU7mO6fWAdGP0T+IRZOZ77lyThd6DiSIYbl5jO9/svce76HZx1WtrVDKB3g1C7KjodunSb1X9e4WZKJhU8nHmwcRjNIop5no4QQojSLzMVjq5Qc3kmXYWsFLV0qW8V8AmF6ych9Rak31YDWY+KpsuXNhkBFas6ZEgpZ3fjVaM1AHdWPIlnsyEQaeLKZVY6HPsBLvymliX1rwEunmp50cTLasWmyI4QPREq/DOlLeE0HPwKLu1RKz15+IOzh1qK1NVbvULa4BHzt+fjj8NfSyApFtx8oO6DakBtzRw9G5TXJPwSnDpQeT1JADKz9aw/EstPh2NJSssiwNuF/o0r0bVucLFUksrO0bPxeDw/HsoNpl3o3TCErByFjcfiSErLJtDHlUeaVqJTrSC0Ut1KCCGKXkYy/LVUDfQyU9XgrskIiGxne19JV+HAYjW3ql4PIQ3UeamBtdX1igJnt6ht4o6QkpyI18wLANz5cTqelzarwaDWSb313+N1CL7noasrB+HAl3DjDOhc1KurTUaCkysc/h5OroPMFPCtBDV7QsLfcGm3uu/gBmpgfWgJ3FL3S0At6DQdanSx9xUslPIad0hw6kDl9SQ5djWR8Yv3E5uYP8F/zSAvPh/TgvCKlsumFsa563d47Mt9XLiRalX7uqE+fD6mOaG+jikPJ4QQwoTTm2HFWMhIyr8usv0/t9T9rOvrjw9h8yzT6ZiajYGOL8LS4XD1T8Nis+VL86rXHwZ+ATkZsGoCnFibv43OVQ1os1KsG6spudMJHDb9wTrlNe6Q4NSByuNJcvV2Gn0/2MnNlEyzbSL9PVj7ZDu8i2Ce6s2UTPq+/xtXTQTGllQP9GTtk+0kHZYQQhSFywfgi95q0GdOlTYwdn3Bt7IPfgVrnrTcxsNfvb2eh1XBKUDT0WqZ0RNrLO+jsMKawoStDr91b0l5jDtAHogSBVi087zFwBTgwo1Ulu+/XCT7/3b3RZsDU4Cz11P44c8rRTAiIYQQ/Ppfy4EpqLfnCyohmpMN2+YUvL97AlObHPy66ANTgKsH1WkHotAkOBVmZeXoWXHAuqBz6b6YIhnD0n2X7N92r/3bCiGEMCPpKpzZZF3bA19aXn9mEyRfLfSQLCvGakx7Pyu+fZVjEpwKs26lZpKYlmVV2wsJ1s0HtUVmtp4rt9Ps3v5CQiHmDwkhhDDt1gXry2/ePGd5/Y2zhR5OqXLjdEmPoFyQ4FSY5eqks6Gt408lZ52mUJkAXJ3l9BZCCIfTudrQ1sXyeicb+ioLytvxlBD59BZm+bo7ExXuZ1XbDrUDHb5/jUZDuxoBdm/foZbjxySEEPe90EbgGWRd2xrdLK+v3gUoR6n/aj9Q0iMoFyQ4FRaNbh1hVbtRraxrZ/P+29jf78giGpMQQtzXdM7QbHTB7bROBdeb968ONbo6ZlzmuPuDs1fR7gPUMq8FHa+wigSnwqKHm1TiwSjLpdYe71iN6Gr+RbL/LnWCGdGqis3bPdW1Jk2qVCiCEQkhhKD9cxDeykIDDTzwDvhWLrivvvPBp5L59c6eajJ+e2j/KSk64BP1/4vSA+9KaVIHKbXB6YIFC4iMjMTNzY3o6Gj27t1rtm2nTp3QaDT5fh544O7ldVPrNRoNc+fONbSJjIzMt/4///lPkR5naafRaJg/pDEv9KpNiI9xmbaqAZ7MGdCQ6b3rFukY3ujfkNn96lG5gnFSfW83J7xcjd9sqgV6MndgI6Z2r1WkYxJCiPuaszuM/AFaT8mfeD60MQxdoibPt4ZfOIzbBA0H3zOfVaNOCxi7Hvq+CwM+g4DapvvQmAhn/GvC+K0Q3gLq9oWRq9Xcq3m5eKl5UFv9C9zvKd/t5ps/oNWayOftFQxDvoXmYwo4UGGtUpmEf9myZYwaNYqPP/6Y6Oho5s+fz/Llyzl16hRBQfnnudy8eZPMzLu5OG/cuEFUVBSfffYZY8aMASAuLs5om59//plx48Zx5swZqlWrBqjB6bhx45gwYYKhnbe3N56enlaNu7wmw82VnaNn/8VbJKZlEeDlStMqfmj+STZ8JyObtMwcfN2dcSmCh6MA9HqFAzG3DOVLm0dUIEdR2HfhJsnp2QR5u8rVUiGEcJSsNEhPUmvJu5ioAqjPUZPbZ2fA9ZNqe78q6pxUW+XkwM2zkJ6o5jRV9BBcDypEqv2n3oScLHDzVjMA3LxISuzfePWcDsCdpCQ8Y/+AS3vVwLn+w+qUAVOun1KzBCh6CKyjBrY5meAVBLF/3S1fGtYE7lxTq1Ipegiqp5ZnvfgHnNsOGh3U7A6Vmtp+vA5SXuOOUlk+Z968eUyYMIGxY9W5Gx9//DHr1q3j888/Z9q0afnaV6xo/G1n6dKleHh4MGjQIMOykJAQozY//vgjnTt3NgSmuby9vfO1FSonnZZW99y+33gsji//uMAfZ9UEyZ4uOh5qUonx7apSLdCxc3y0Wg0tIo1/11o0tKlu/0NTQggh7nF5P+xaoJb61GepVw9r91avklZpBSk3YM/HcHAx3IlXtwluAC3GQa2etu0r8YpaHercdlBy1GVaZzXoa/0UbHkdjq82LmvqGw4hDeHCobvLPmkPbSdAh3+rwaklSVdh/+emc7UG1Yfe/1EDU1AD1nuPKaKN+iOKTKm7cpqZmYmHhwcrVqygf//+huWjR4/m9u3b/PjjjwX20bBhQ1q3bs3//vc/k+vj4+OpXLkyixcvZvjw4YblkZGRpKenk5WVRZUqVRg+fDjPPvssTk7WxfDl9RuMOa//dJxFO8+bXOfpouOz0S1oXb1o5qIKIYQoAn9+qwaLuYFiXhotdJoOf34Nt80UXqneBYYttS6l0rWT8EmHgitNmWGyfGnlFjBiFbiZ+Qz+7R3Y8lrBnT/wDrQYb9e4ilN5jTtK3ZzThIQEcnJyCA4ONloeHByc79a8KXv37uXo0aOMH2/+pFq8eDHe3t4MGDDAaPlTTz3F0qVL2bZtG48//jhvvfUWL7zwgtl+MjIySEpKMvq5X6w6eNlsYAqQkpnDxK/3czvVculTIYQQpUTcEfOBKai3tre9aT4wBTi7FTa9Yt3+vuhld2Bq1uV9sG6q6XWnN1sXmAKs+zdc/9tx4xI2KXXBaWEtWrSIhg0b0rJlS7NtPv/8cx599FHc3Iwf8Jk6dSqdOnWiUaNGPPHEE7zzzjt88MEHZGSY/uOZM2cOvr6+hp/w8HCHHktp9tlv5gPTXMnp2Xy/X0qICiFEmbDnY/OBqS3+/Eadq2rJiZ/U+apF4dgP6q37e+1eYEMnihqIixJR6oLTgIAAdDod8fHxRsvj4+MLnAuakpLC0qVLGTdunNk2v/32G6dOnbJ4ZTVXdHQ02dnZXLhwweT66dOnk5iYaPi5dOn+CMTOXb/D8VjrrhL/dDi2iEcjhBDCIY6tdkw/mXfg9EbLbXbZEijaSJ+tzpfNK+0WnN1mWz9//+K4MQmblLrg1MXFhWbNmrFlyxbDMr1ez5YtW2jdurXFbZcvX05GRgYjRoww22bRokU0a9aMqKioAsdy6NAhtFqtyQwBAK6urvj4+Bj93A+S0rMLbvSPxLSsIhyJEEIIh8jJVoNKRynoqmhGouP2ZXL/t43/nZ4E2PiITXa6o0YjbFQqn9afOnUqo0ePpnnz5rRs2ZL58+eTkpJieHp/1KhRVKpUiTlz5hhtt2jRIvr374+/v+mHcJKSkli+fDnvvPNOvnW7du1iz549dO7cGW9vb3bt2sWzzz7LiBEjqFBB0hPl5e9ZQK3kPAK8pM6wEEKUejoncK/guFvtXgWUN/Uo4iwrXveUr3avoGYd0Ft/cQUX69JICscrlcHpkCFDuH79Oq+88gpxcXE0btyYDRs2GB6SiomJQas1vuh76tQpdu7cycaN5m8lLF26FEVRGDZsWL51rq6uLF26lNmzZ5ORkUHVqlV59tlnmTrVzMTq+1h4RQ+aR1Rg/8WC38QebmKh6ocQQojSo9EQdd5pYblXgJoFpJTq8Dyc/7Xw+zLFyQ3q9Tde5uYDtXrByZ+s76f+gILbiCJR6lJJlWXlNaWDKZuPxzP+q/0W2wT7uLL1uU54upbK70BCCCHyunEWPm4HWakWGmko8PZ4x2nQeXrB+5tXD5Ku2DJCIyZTSQG0mAAP/F/+DWL2wBe9rXvoS6uDp/5Sq1eVYuU17ih1c05F2dCtXjAzHqjLPwWi8gn0duXLsS0lMBVCiLLCvzoM/gqcTVSDAvWKZP+FEGKhAlTUMOj4onX7m7AVXH0tNDDzAWNJ7T7Q8y3T66pEw0Mf5i9Jmm+3Whj8dakPTMszuXLqQOX1G4wlhy/fZvEfF9l0PI60rBzC/NwZ3DycoS3C8Zf5pkIIUfbcugD7PoPDyyE1Qa0533CgmpTev7papvTwMtj/BVw7oQZ7kW3V9bZWiMpIgU0z4PD3dx/IcvOFxiMg+gk4+KVazSl3LqzGCcKbQ6UWpJzdhdfkrQDc+aQXnu2egDp91auellw7AXs/hb++M75KrHVSiwj0+o/50qelTHmNOyQ4daDiPknOXEvmm90XuZ6cQaifO6NbRxBesXxO4L6WnM72U9dJzcimUgUPOtUOxFknF/6FEKJY3TirztuMO6LOLa3WGWr2UB+ocpSY3Wr/Gq1aLjW4vslmKSkpeHmpZbLv3LmDp6eNn3/ZmXD6FzUnqouXGphePQiJl9WHoWr2KPjBrhJWXoNTuedaBp1PSOHxr/bz9zXjtB+f/XaeRpV9+WRkM0J9C6gtXEbcTs3klR+P8fPRWLJy7n6PCvJ25V+dqjOmbdUSHJ0QQtwnbp6DNU/Bhd+Ml+/9H7j5QeeXIXpi4fZxdhv88jJcO2a8vEpr6DMXQhoWrv+8fn8Pfn9fvTJsjtYZ6vdX9+0uWXuKk1w5daDi+AZzISGFB97/jZRM8xO6K3g4s+GZDgT7uJltUxYkpWcxaOEuTsUnm23zZJcaPNejdjGOSggh7jM3z8Oi7pBy3XK7ji9C55fs28ffG2HpMPOpnlx9YOx6owDV7iunP0+DPQutH1twAxj7s/rEfylTXq+cyn3RMualH45YDEwBbqVm8ca6E8U0oqKzYOsZi4EpwAdbz/B3AW2EEEIUwobpBQemAL/+F66fsr3/nCxYM8VyDtKMJFj7jO193+vyftsCU4D4o7BzXuH3LawmwWkZEnMjlV1nb1jV9ucjsdxMySziERWd9Kwcvt9vXTnYr3ddLOLRCCHEfep2jDov01r7PrN9H8d/hDvxBbe7sh+uHrK9/7z2fmrfdge/VueoimIhwWkZsu/CTauLr2XrFQ5dclCljxJwOv4Ot1KtK32657x1AbsQQggbxewGRW99+wu/276Pi3/Y0NaO/u3dV16pCXD9ZOH2LawmwWkZkqO3bXpwdk7ZnU6crbf+zdDW10UIIYSVbCn3CdYluC/MNvq7bXNy7v7/jh07jP7tkH05clthEwlOy5DaId5F2r40qRbghauTdadnWT5OIYQo1YLqFW17W7f5p+2qVauoV+/udn369CEyMpJVq1YVsH1d28cH4OQOFSQ7THGR4LQMiQr3o0aQdU8jtoysSIR/2c156uvhzAMNQ61q+2h0RBGPRggh7lNhjSGsifXtmz9m+z6ihpqvSpVXhUio3oVVq1YxcOBArlwxLn165coVBg4caDlAtWd8AA0GgLuffdsKm0kqKQcqjpQOv59JYMRneyzOPXXSalg5qQ1R4X5FMgaA2NhYYmNjbd4uNDSU0FDrgs7zCSk8/NHv3LYw97RrnSAWjWlh8ziEEEJY6fxv8HX/gm/x134Ahi2xbx+/vwebXrHQQAODvyKn9gNERkZy+fJl0600GipXrsz58+fR6UxUitLnwNcPw/lfrR+be0WYsAUqVrN+m2JSXlNJ2RWc7tmzh+jo6KIYT5lWXCfJxmNxPPndn2Rk55+X6eGiY9Ho5rSuHlBk+weYPXs2r776qs3bzZo1i9mzZ1vd/tjVRP717UEu3kg1Wq7RQL9GYbw9sBFuzgWUqhNCCFE4f2+EVeMhPdH0+gaD1Lr1zoXIr/3bPDUdVXa68XJXX3jg/6DRYLZv307nzp0L7Grbtm106tTJ9MqMO/DD42qlq4JUrAaDv4aQBgW3LQESnOah1Wpp2LAhEyZMYMSIEfj5+RXB0Mqe4jxJ0rNy+Gb3RVYdvEJSehYVPFwY1rIKg5pXLpaynqaunKalpdGuXTsAdu7cibt7/ipVtlw5zaXXK2z/+xqbjseTmplDJT93BjUPp2pA2Z22IIQQZU52Bhxdpdakv30JXDwgoi1EP+64WvSpN+HQt/+UL9VBlWhoOEgtJwp89913DB8+vMBulixZwrBhwyw3unYS/lpyt3xpWFO4eRaSrqjTDOr0hRrdQFt6Z0BKcJrHqFGjWLlyJWlpabi5uTFw4EAmTJhA+/bti2KMZUZRnSQZ2TmsPxLLusOxJKVlE+DtQpMqfpy9dodzCam4OmlpVyOAjrUCWX8klv0Xb6FXFOqF+vJoqypUD/Qy6i8tM4fVh66w8VgcKRk5hPq50TjcjxOxSVy4ofbXsVYgg5qH4+vubHZcCXcyWLo3hl3nbpCdoxDhq2XusFYA/LjvLBtO3SIhORMfd2f6Ngqld8MQXJ3kKqcQQgj7bN+ymc7duhfYzuKVU0dJjoMDi9X0VvocCK6nBrPnd0DsX2qb8GhoNgb8wotkCBKc3iMxMZFvvvmGRYsWcejQITQaDTVr1mTChAmMHj2agICiva1cGhXFSXLsaiLjF+8nNjG94MZmjGodwex+9dFqNew5d4MnvjlgVQ5Rd2cd7wyOoo+JB5OW7Ilh9ppjZObcnVqgz0zn0rsDAQh/dgVaF+PbO6G+bnw2ujn1w3ztPhYhhBD3qeunyPl6IJGvHuNKkmLy2QsNUNlHw/nvZ6Dr+VrRjWXPJ/DLy6C3Ih+3Rgedp0OH5x0+jPIanNp9rdrX15fJkydz8OBB9u/fz8SJE4mPj+f555+ncuXKDBkyhM2bNztyrPedK7fTGLlob6ECU4Cvdl3kPxtOcioumbFf7rM6uX1aVg5Pffcnf5xJMFq+7nAsL/1wxCgwtUZsYjojF+3lyu00m7YTQghxn7tzDRY/iC4phvd6qRc+NPc0yf33/F5u6Ha9BzvmFs1Y/loKP79gXWAKan7UrW/A7o+LZjzlkEMmUjRt2pSFCxdy9epVvvzySwICAlixYgU9e/akWrVqvP322yQnS/1zWy367bzDSpB++fsF3t30N6mZtiURztYrvLv5b8O/FUXhnY121E7+x82UTD7fed7u7YUQQtyH9v4P7sQBMKCuMysGuxPmbRyeVvbRsGKwOwPq/jMdbed7kOHg2EOvh21v2rftjrfVebuiQA6b5Xvr1i3+97//MXfuXK5evQpA27ZtSU5OZtq0adSuXZt9+/Y5anflXlaOnhUHrKstb43MHD2bjltRu9iEfRduceaa+ge+9/xNziWkFGosKw5cJsvGq65CCCHuYwe/MvrngLrOHP/X3Ydi1w935/zTXncDU4DMZDi60rHjOLcNbsfYt23qDTix1rHjKacKHZxu27aN4cOHU6lSJZ599lmuXbvG888/z+nTp9mxYweXL19mwYIFJCcn8+STTzpizPeFWymZJKXbWDauADmFSGl7PkFN5XThRuECU4DEtCxupTrmirAQQohyLuMO3Ml/cUWnvXvltEOEk9G/DW6cdexYbp4r2e3vE072bBQfH88XX3zBokWLOHfuHIqi0LFjR5544gkGDBiAs/Pdby6urq5MmjSJM2fOsGDBAocNvLwrbU+155YSdbGypGiB/ZlKjiyEEELcS+di/7ZOhci7akphxgLg5OqYcZRzdgWnlStXRq/XU6FCBZ555hkmTpxI7dq1LW4TGBhIZqZcLbOWr4czUZV9+euymYTHdgj0duV6su3zXbxdnWgWUQGAttUDcNZpyMqx/ypsVLgfvh7mU1QJIYQQBk4uULWDmqLJVjW6OXYs1buARguKnVPTHD2ecsquy2DR0dEsXryYK1eu8M477xQYmAJMmzYNvV7mGdpiVOtIh/VVpaIH49tVtWvbAU0r4emqfo8J8nGjR/2QQo1lVKuIQm0vhBDiPtNigu3bhDRUk/g7kl841Opl37ZV2kBwfceOp5yyKzjduXMnI0aMwNVVLk8XpQFNK9EvKqzQ/Xi66Hh/WBMea1eV9jVtyz9bL9SHf/c0/vIxu199Ivw97BpLv6gwBjStZNe2Qggh7lP1HoQmI61v7+oLD/+vaMbywDvgW8W2bTyD1PKuwip2BaeXL19mzZo13L592+T6W7dusWbNGq5cuVKYsd33NBoN7w1pzAu9ahPsY/xFwPWeuZ9uzloi/D1w1t2dEK7VQJc6QayY1IbG4X4467QsGt2CKZ1rUNHTeN6Mu7Nxf16uToxqHcGyx1vh7WZ8Cz7Q25WVk9owqFll3JxNn0KRAcbBa4iPGy/0qs17Qxqj0ZiYtC6EEEJY8uAH0PMt8LVUbUkDtR+ACVvUik1FwScMxm+CqGGgy/vZrAGPAIwysGqdof4Atb2jSrzeB+yqEPXEE0+wfPlyrl69avLqaUZGBpUqVWLo0KF8+OH9802hKCs1ZOfo2XfhFknpWQR4udK0ih9nr9/hfEIqzjoNzSIq4O3mzIWEFP68dAt3Jx31K/kSXvFukKjXK9xKzUSr0ZCRk8OfF2+DBir5uVMr2Js/Y26RcCcTbzcnWkRWNNzKt+R2aiZ/xtwmW68Q5qmhQWQwAMnJyZy6kUXCnQx83JxpEVkBJ50ayN7JyCYtMwdfd+cCH7DKztFzOy0LZ53WYilVIYQQpUhONqTdAp0zuPuZb5d6E5KvgZc/eAbmX5+VBulJ4OYDzu7qMn0OxOwmJeEqXi0GA3Bnw5t4VomCsMbga8XducxUNQeqmy84m3hoKj0JstPBvYJ6DOak3IArB0CfDUF1oGI1uH0J4o+qc1NDG4N3cMHjsVN5rRBlV3Baq1YtmjVrxnfffWe2zfDhwzl48CAnT54s1ADLkpI8SX45FseXv19g17kbgHorv3+TSoxrVxV/T1e+/OMCS/ZeJD7J+IGoAE8XAn1cOXPtDlk5iuFq62Ntq9Kmhm1TAFJSUvDy8gLgzp07eHp6Gq03N8bx7atRNcC4bVxiOp//fp7v91/i9j8VraIq+zKqdSQDmlaSq69CCFEaJcfB7o/gz2/UvJ4AYU3UOaNRw0CrVRPZ7/0Edr5rnCLKMxDaPAWtJ8OVg7DrQzi5Tq3EpHWCOg9A6ykQ3hIo+DPHpIt/wK4FcOpntXKTzgXq9lP3WakZHFutJvy/+Lva3tUHGg1R11e077mNoiTBaR6enp489dRTzJkzx2yb6dOn8+GHH95XlaFK6iR5be1xPv/ddNUlDxcdPm7OxCXZXgL1pT51mNjB+tsQlt4oXl17jC9+v2ByOy9XJxaNbk50NX8ATsYlMeKzPSTcMZ3doW+jUN4b2sR0TjshhBAl4/opWPygoZJTPnX7wYDPYOkwOLvVfD/+NeDGOcDEQ9QaLfSdD81G2x6c7v0U1j8PmAh7tE4Q0RbO/2p6W1dfGLHCEBiXFuU1OLVrzqmLiwtJSUkW2yQlJcnVrWKw8sBls4EpQGpmjl2BKcBb60+y83SCvUMzWL7/ktnAFNTb/BO+2k9iahZZOXrGfbnfbGAK8NPhWBZuP1PocQkhhHAQfQ4sGWI+MAW1OtLXD1sOTAFunMFkYApqCqefnlFvpdsiZrf5wBTU2/LmAlOAjET1+BxdDlWYZFdw2rBhQ9auXUtGhumcmenp6axZs4aGDRsWanCiYJ8VcZ16S4GvtRZZMcak9GyWH7jEhqNxXLmdVmD7r3ZdlBKoQghRWpxcB7es+LyI2VX4fSl62POJbdvs/gizgam10m7CX0sL14ewil3B6dixY7l8+TIPPvgg584Zl+I6e/YsDz30EFevXmX8+PEOGaQw7ez1O5yItXwFu7C2n7rGnQz7y6ieuXaHk3HWfdNceziWnw5ftartteQM9p6/afe4hBBCONCxH6xsWMgA0bC/1WDtrMTsTDV4doSjqxzTj7DIrgpRY8eOZf369axcuZI6depQtWpVKlWqxJUrVzh//jzZ2dkMGTKEsWPHOnq8Io+ktKwi34degeT0LLyseHLflEQbxpiUloWHs/VlTW3pWwghRBFKv128+8vJgKxU69pm3lFv2ztCcR/nfcruQunff/8977//PjVq1OD06dNs376d06dPU6tWLRYsWGDxSX7hGAFeRV8EwVmnwc/d/lrCgTaMMcDLBX8v6/dVHMcvhBDCCp5Bxbs/Fy9wtrIYjKsPOLk7Zr+m0l0Jh7M7ONVoNEyZMoXjx4+TnJzM5cuXSU5O5ujRo0yaNKnQA1uwYAGRkZG4ubkRHR3N3r17zbbt1KkTGo0m388DDzxgaDNmzJh863v1Mi5BdvPmTR599FF8fHzw8/Nj3Lhx3Llzp9DHUlTCK3oYat4XlZ71Q3B3sf5q5r2q+HvQtIqfVW0fblKZh5tYVz2qSkUPmhfxsQshhLBSo8HWtdPYHXbk35+1D13rnKDBAMfsN2qoY/oRFjnkLPH09CQsLMy6HGNWWLZsGVOnTmXWrFkcPHiQqKgoevbsybVr10y2X7VqFbGxsYafo0ePotPpGDRokFG7Xr16GbW79+ruo48+yrFjx9i0aRM//fQTO3bsYOLEiQ45pqLyRMeiqzjhpNUwvn21QvfzuBVjDPFxo3+TMDrXDqJOiHeB7Se0r4pWUkkJIUTpUL0LhDQquF2t3oXfl5MbRD9h2zatJqk5TQvDt4pa7UkUOQd9hXGsefPmMWHCBMaOHUu9evX4+OOP8fDw4PPPPzfZvmLFioSEhBh+Nm3ahIeHR77g1NXV1ahdhQp3r7ydOHGCDRs28NlnnxEdHU27du344IMPWLp0KVevWveQTknoXi+Yl/vUNfsF0t/Lxapg717OOg3vDI6icbhf4QaIevX1pT51zI4xyNuVxY+1xMPFCa1Ww6IxLfIl5c9rXLuqjGwdWehxCSGEcBCNBoYvg4Ba5tu0fByGLYHGIyz3FdkOdCaqNoF6e37QlxBY27bxhTSERz67p9xoHs6e0Hi4+e19KsGIlaarSQmHs+8pF+DSpUu88cYbbN68matXr5KZmT8vpUajITvbtknImZmZHDhwgOnTpxuWabVaunXrxq5d1qWgWLRoEUOHDs13JXf79u0EBQVRoUIFunTpwhtvvIG/v5r4fdeuXfj5+dG8eXND+27duqHVatmzZw8PP/xwvv1kZGQYpdMqKPdrUZnQoRrR1Sqy+I+LbDoeR1pWDmF+7gxuHs7QFuF4uTmx5tBVvt0Tw9Eriej/ecJRq9FQK9iLUF83jl1NIuFOJr7uzvRpGMqo1hHUDLY9qDVnYofqRFf156tdd8dYyc+dQc3DGdayChU9736jreTnzpopbVlx4DLf7Y3hfEIKLjotHWoFMrJ1BG2q21a5SgghRDHwCYMJ2+DQEjjwJdw4rV6trNYJWoyH6p3Vdv0XQN2+sPVNuHZMTQ2FBoLqQueX1GT9N8/Dvs/gyApITQAPf2gwEFqOV0uE2qPeQxBUH/Z9CkdXquVVPQPVKQLNx0GFCGj2mLr+1Ab1gasKEdBkJDQdBR4VHfRCiYLYFZyeO3eO6Ohobt26Rf369cnIyCAiIgI3NzfOnTtHVlYWUVFR+Pn52dx3QkICOTk5BAcb16INDg62qhTq3r17OXr0KIsWLTJa3qtXLwYMGEDVqlU5e/YsL730Er1792bXrl3odDri4uIICjKe0O3k5ETFihWJizOdVHjOnDm8+uqrNh5h0WhU2Y93BvsBUSbXD2oezqDm4SbXXUtKZ+vJa/8ErlA7xNtonmlqZjabT1zj5p0M/Dxc6Fo3CG+3guvcZ+fo+fXv6/x+JoGbKZnUDvFmQoeqvDPY9Bjz8nZzZmzbqoxta75c3LWkdLafuk5qZjYuTlr0egU9UD3QizbV/U0Wgbh4I4Xfz9wgW6+32E4IIUQet2PU5PnZmWpwWL2LWor0Xq5eED1R/TEnJ0tNA9V0JLh4Qo3u+evPV6wKPd9UfxwpoAb0fEsd/60L4OwONbqpgTVAeAv1ByAzFf7eACnX4fQmqNUT3P0sH9eehXD5ADi5qmVPa3R17PjvE3YFp6+++iqJiYls2bKFjh07otVqGTt2LK+88gqxsbFMmjSJ48ePs3nzZkePt0CLFi2iYcOGtGxpXGJs6NC7k5gbNmxIo0aNqF69Otu3b6drV/tOnunTpzN16lTDv5OSkggPNx0AlkY3UzJ55cejrD8Si/6edHEaoEudIMIquLP64BWS8+Q69XDRMaRFONN718XFyfTMkO/2xrDgt0vcSjVO9/TfDaeIquzLnAGNqBdmX6m13HFvOBpH9r0D/0ekvwfP96zDA41CAbh0M5UZq4+y4/R1o9R497YTQgiRR1IsrJuqBmlKnsInvlWg83TLt8JN2b0Qdr4Ld+LvLtM6q1c1H/g/cC/iB133fwG/vg3JeabraZ2gzgPQ5x3wClSrXW2fA3v/B+mJd9s5e0DjR6HHG/lv7/88Tb3imjdl1eFl6vE88gXU6Fy0x1XO2DXndPPmzfTp04eOHTsalin/fOKHhoaybNkyAF566SWb+w4ICECn0xEfH2+0PD4+npCQEIvbpqSksHTpUsaNG1fgfqpVq0ZAQABnzqhlMENCQvI9cJWdnc3NmzfN7tfV1RUfHx+jn7IiMTWLIZ/s4qfD+QNTUNMkbzl5ja93XTQKTEEtifrF7xeY+PV+ss1UaXpt7fF8gWmuvy4nMviTXRy9kmhyvbXjNheYAly4kcqU7w7y/f5LXLqZyiML/+DXv6/ny9lsaLfvks1jEUKIci05Dj7vAafWGwemAIkxsHqSGmxaa8trsGGacWAKoM+CoyvgiweMg0FH2/F/aunT5HueI9Fnw/Ef4YtekHIDfngCdszNP5asVDUA/W6IepU018qJ6hVTU7lU027BNw/D2W0OP5zyzK7gNCEhgTp16hj+7eTkRGrq3WS4rq6udO/enZ9++snmvl1cXGjWrBlbtmwxLNPr9WzZsoXWrVtb3Hb58uVkZGQwYkQBk62By5cvc+PGDUJD1StmrVu35vbt2xw4cLde79atW9Hr9URHR9t8HKXdB1tPc/pa4dJkbT91nVUHr9i17Z2MbF7+4YjN29kybkWBV348yuw1x7iWbLrUrqHdmqMkmgmmhRDivrTlNfV2viUbZ6hXVwsSfwx+e8dym2vH4Ld51o/PFjfPwdY3LLe5cUYNuI98b7ndue1w8Cv1/+OOwpFlBexcgRWPWTtSgZ3BaUBAACkpKUb/vnDhglEbJycnbt++bdegpk6dyqeffsrixYs5ceIEkyZNIiUlxVBxatSoUUYPTOVatGgR/fv3NzzklOvOnTs8//zz7N69mwsXLrBlyxYeeughatSoQc+ePQGoW7cuvXr1YsKECezdu5fff/+dKVOmMHToUMLCwuw6jtIqPSuH5QcuO6Svr3dftHvbvy4ncvjybavb2zPu9Cw9W0+ZTkF2b7vlB+TqqRBCAJB6U31oqCD6bPXhp4Ls/dS6/f75DWSbv5hgt32LsKp06lkrpyPu++e5li1WPneSdhPObCm4nQDsDE5r1qzJ2bNnDf9u2bIlv/zyC+fOnQPg+vXrrFixgurV7cvBOWTIEP7v//6PV155hcaNG3Po0CE2bNhgeEgqJiaG2Fjjb2qnTp1i586dJm/p63Q6Dh8+zIMPPkitWrUYN24czZo147fffsPV9W5aiW+//ZY6derQtWtX+vTpQ7t27fjf//5n1zGUZifjkh1W+vPIlURSM+0vC7fn3E2r29o7bmvLL++2YSxCCFGuXTkI2enWtb34uxVt/rCur9QEuF7ww882s3b/+hzr2l07pt6yv3Kg4La5Tqyxvu19zq4Honr37s3s2bO5ffs2fn5+PPPMM6xdu5ZGjRpRt25dzpw5Q1JSErNnz7Z7YFOmTGHKlCkm123fvj3fstq1axvmvd7L3d2dX375pcB9VqxYkSVLltg0zrIoR296nqj9/VkZ/Zna1trIEceP+156G8YihBDlmi216K0J6BQrgz5r+7OVLcdjdZ85to01pwiOq5yy68rppEmT2L59Ozqdmm6oU6dOLF26lIiICI4ePUpwcDDvv/8+EyZMcOhghWNUDfDCReeY+guV/NytSitlTm0bcqk6ctym1HJgXlchhCjTguqg5m2xpm1dx7QBtfqTvXlMLQmu79j+vEPBvaJtY61S/p5fKSp2fdL7+PgQHR2Nt/fdD/NBgwZx7Ngx0tLSOHnyJJMnT3bYIIVjVfR0oVcDy5kPrDU8uord21au4E7HWoFWt7dn3FoN1A8rOOjUamB4S/uPRQghypUKkWouUGs0t+JhH2vagFoe1FIuUXs1G2tdu9CC83AD0HS0mue10zTr2ju5QdTQgtsJwM7gtEuXLsycOdPRYxHF6OluNfFxs7tAGADVAjwZER1h17Ya4KU+ddFqbUuAb+u4R7eJZFa/BgVecR3VOpIq/h42jUUIIcq1rjPV3J6WNH4UQhoU3Fe1zlCzp+U27hWgw7+tH58tqkRDvf6W27j6QL/3ILSx5XYVIiH6cfX/a/aAoHoF77/TdNDZf5fxfmNXcLpnzx5yZO5EmVY90IslE1pRuYL5OsEBXi7UDTF91TEq3I9vJ0Tj62H6j+2hxuYzHHi66Jg3JIo+DW1PfJ877vCK7hbbOWk1jG9XlZkP1KNl1Yp8Nro5AV4uZtu90teKNxchhLifhDVR68l7m3iv1ujUq6H93reuL40GBi+GBo9gcrpAhaowei342/cgtVUGfKoG06b271sFRq5Wj3nkD1C1Y/42oAauo9feLWWq0cCErRYCWg10eB7aPVPY0d9XNIq5p4gsaNasGXXq1OHbb78tijGVWUlJSfj6+pKYmFhmEvLr9QpbT15jzV9XOBWXjB6oGejFA43C6Fk/GCedlr8u3Wb1oSvcuJNJBQ9n+kWF0Twyf43hlJQUvLy8ADV9V0I6fL3rIrvO3SAlI5tQX3ceaBTKgKaV8HAp3FXb3HFvORnPnfRs0rNzcNJqcXXSUj3Qi8Etwgn2MQ68M7P1/Hw0lp2nE8jK0ZttJ4QQIo+cbDj5E5zZpKZ5qlgdmowAPzsrIiacgUPfQOJl9cpsnQfUEqamyqFacO9njqenp3Ub3jyvpqy6fVEtX1qrl/qj1Rm3u3pIrfJ055o61aD+AIhsa77fq4dg82w1p6rWCap1hG6zwc3XpuOyRVmMO6xhV3D65ZdfMmXKFPbu3Uu9enLFKVd5PUnudeDiTZbuvcTFm6m4OmnpVDuIgc0q46TPtO+N4h+KorDjdAIrDlwmPjEdLzcnetYP5qHGlXBz1hmCy58Ox5KYmoW/lwsPNa5E93rB6P6ZHhCXmM6SvTHsv3ATvaJQN9SHjjUD2XkmgaNXE9GgoXlkBYa1rEKYn+Wrr0IIcV+78LuabP7SHrVaFIoazEW2V+vT5wan2ZlwfDUc+wHSbqslQBsNMR3w5VIUOLsVDi2BpKvg6gV1+kLDQeBi3RQro+D06xF4ZiaAqzfU7QcNB6pjzUpT87UeXwMZyeAdopZcrdENEk7D/s8h7ghk3lGfvNe5qIFozR7QeFiRBpaOUF7jDruC0x07dvD222+zY8cOHn/8cVq0aEFwcDAaTf5L5R06dHDIQMuC8nqS5ErJyGbykoNsP3U93zoPFx1v9a3Fw9HqLRlbg9NryelMWLyfvy7nL13n7+nCSw/UYd7G01y5nZZvffVATz4f04JfjsXx9oZTFsua5tJpNUztXovJnWtYPUYhhLgvpCfCshFwfofldu2mQoMBsGQIJJmoFhhYB4Z/DxXueTbhzjX4bqjpHKEe/jDkW4iwXBESICXuHF6h/3zmTPfG0yVPDOIZCJ1nwLY3IcVEIRYPf0i9YXkHLl7qVIA6fQocS0kpr3GHXcGpVqtFo9EY8oqaCkpz3U9zU8vrSZJr1Od72fF3/sA0lzY7g/PvPALYFpxmZOfQf8EfnIhNMttGg+XaHhU8nLllR/nRVx+sz+g2kTZvJ4QQ5ZKiwJcPWJdYH8DFEzJTzK+vUBUe3wFu/3wmZmfAZ13Vq5Vm+/SG8Zv/SWdlRlY6KR92xGvqXsBEcOooWmd1jqkVwXJJKK9xh10T/1555RWLAakof/acu2ExMAWsumJpyk9/xVoMTKHgonP2BKYA7285zbCWVXBxKrr8qUIIUWac2WJ9YAqWA1OAW+fh0LfQapL672OrLQemAJnJsPNdGPCJ+TZHV8L1E9aP0176LPj1PzDqx6LflzCwKzgtTOUnUTYt21d0deeLsu+C3EjJZOPxOPo2Mp9dQAgh7hsHFzu+zwOL7wanB7+ybptjP0Cft83P+bS2H0c49yvcuqCmkBLFQi4XCaucv1HAt+NS2rc1LiSU7P6FEKLUuHmuCPo8a/r/LcnJgEQT81ht7cchlKJ5XYRZEpwKqxRl2dCi7Nsark5mniYVQoj7jS5/PujC9+lqX/9OrubX6SysKwpOknKwONkVFWi1WnQ6XYE/Tk6Fy2UpSo+Ota0vM1qa+i4L+xdCiFKjRrci6LOr7f1XrG65bn3ePouae0UIa1p8+xP2zTnt0KGDyQeiEhMTOX36NCkpKURFReHn51fY8YlSYkjzcOZvPk1mtt7hfY9sFcF3e2OwPW9E4UVXrUitYNNVsIQQ4r7TfCzsnAf6bMf12XLC3f9vMV7NLVrQY64txqnVl8yuHw+7v3TE6ArWZAQ4y5XT4mTXldPt27ezbdu2fD8HDx4kPj6eKVOmkJKSwvLlyx09XlFC/L1cmTuwEVoL7xX1w+xLY1E31IcXelpIGQIE+1i+hTO4eeUC29wr0NuVtwc2smkbIYQo13zCoO+7mCzxeS9nDzVxviVtn4bIdnf/HVwPur9qeZsa3aDl45bbhDaCTtMst/EMsrzeGpWaFbwf4XAOn+zn4eHB+++/j6+vL88//7yjuxcl6KHGlfhibEsah/sZLfd2dWJMm0i+fKyl3X1P6lSd94Y2plawl9HyAC8Xnupakx3Pd2Z67zqE+hp/e43w9+D1/g14e2AUP/yrLQ81DjOaw6rVqEn8877NOus09IsKY9WkNkT421bFSgghyr2mo2DYd2qdeXNCouDJgzD4a+g6C7zvyXhSsTr0ew+6v5Z/27ZPwyOLIOieCpMeAWod+mFLQWfFjd22T5te7hkIHafB04eh0/T8QWpAbej8sloyVWMmDHL1hehJao5TF/mcKG52JeG3xtSpU/nmm2+4ds1EZYZyqqiT4Wbl6LmdmoVGA3pFwcfNGTdn9WGelIxsUjNz8HV3NpuzMztHz+20LJx1WnzdnU22ScvMITkjy6hvU07GJRFzIxVXZx3NIyrg6epkVEru8rWbuLl7UMHDBa2ly633yMjOYdfZGySlZ+Hv6Ur9MB8yc/T4ujvj6qQjR6+w78JNEtOy8HF3onqAF56uTni63n0jS7iTweHLt9HroXaIN+EVPbh8K5WTsclotdCwkh+B3sU8mV4IIcqiuCNwOwauHFQT6HtUhCYj1RKleeVkw6Xd/5QvDYLKLSzfls915eDd8qVVWlt+COoeRuVLT/2GZ85ttXxpldbglOfBq5wsuPjHP+VLQyGkgTpOVy9IuQ7XTqhBqrMHZCSpDz9VaWVfUJqVBulJ6jisLMNaGOU1CX+RBacjR45k5cqVpKamFkX3pVJRnSTnE1JYtPMcKw5cJj3r7pxPrQaaVPEjO0fh8JVEFAXcnXU81DiM8e2rUiNInUsZl5jO57+fZ/n+S4Zk9VGVfRnZOpIBTSqh1WrYc+4Gi3aeZ8vJa+ToFVx0Wno1CGF8+6o0quxn1ThvJSZT0U897vBnV6B1cSPYx5WhLaowtm0kfh7mn9I8FZfMZ7+dY+3hq4ZjrOjpwq3UTBQFXJ209G2kHpdOq+Gz386x5i+1rUYD7WsGMrZtJJ1rO+A2jhBCiFLPKDi1piph3BHYtUDNoZqdrgakNbqrOVirdy7cYC4fgF0fwom1auJ+rRPU7g2tJhdpdSkJTq2k1+v59ttvGTduHM2bN+ePP/5wZPelWlGcJHvO3WDc4v3cybBtcrq7s45PRjYj2MeNRz/bQ8KdDJPtHmgUSrMqFXh93XGTDyQ5aTX836Ao+jepZHF/6Vk5jPx4Byue6gLcDU5zRfh78N2EVoT5uefbdsuJeP717UEyrHjYykmnQQNk5Zg+bZ/qWpOp3WsV2I8QQoiyzabg9MRaWPEY5GSaXt9tNrR71r6BHPoOfpwMioly7Rot9H7b+KEwB5LgNI9q1Uynd8jOzubatWtkZWXh7OzML7/8QseOHQs9yLLC0SdJYloW7f+7laR0+56a9HTR4ePuTGxieqHG4azTsO6p9hafan/5hyN8/dvfXHp3IJA/OAWICvfjx8ltjZZdvZ1G13d+JS3LxB+1nT4Z2Yye9UMc1p8QQojSx+rg9OZ5WBCtJva3ZMRK21NpxR2F/3W0nN1Ao4XHfoFw+5/LMKe8Bqd2PRCl1+tRFCXfj7OzMw0aNGDixIkcOHDgvgpMi8Ly/ZfsDkwBUjJzCh2YgnqVcvEfF8yuv52aycqDlwvs569Ltzlw8abRsiV7YhwamAIs2nneof0JIYQow/Z9VnBgCrB7oe197/2k4LRbit6+vu9jduU5vXDhgoOHIUz56XBsSQ/B4KfDsbz5cEOT6zYdjzeaC2vJ2r9iaRZR0fDvdUccf4x7z9/kWlI6QT6Sl04IIe57x1Zb1+7MFvVBKXc/6/s++oN17U6sVR8asyYLgZDypaVZUlpWSQ/BICnd/Fhsubp77zElFtExFlW/Qgghypj021Y2VCA90fp+9TmQmWxl2yzIvGN93/c5u4LTy5cvs2bNGm7fvm1y/a1bt1izZg1XrlwpzNjuewFepSfdkb+n+bEEeFlfKzngnhROtmxrLa1GfdJfCCGEwNPKEtVaJzVVlrW0OrW0qTWcPdT0UsIqdgWnb7zxBmPHjsXdPf+T16Am4n/ssceYM2dOoQZ3vyvoCfni9HCTMLPrutUNxtvVulsVD99zTEVxjB1qBeJfigJ7IYQQJajREOva1e5jewBpbd8NHlGDWWEVu4LTrVu30qNHD1xdTQcArq6u9OjRg82bNxdqcPe7/k3CCCnEvEl/TxdqBnkV2E5XQJJ8Dxcdo1pHml3v6erEiNYRBe6nQ61A6oYaP004tEUVKniYLghgD60GJnYwnU1CCCHEfaj5WHDztdxGo4M2T9red/RE9aqoJToXNZeqsJpdwemVK1eIjIy02CYiIkJu6xeSh4sTix9rSZAd1Yz8PV34cmxLvnysJdUCzOd+e6xtVT4Y1sSo5Gdeni5qvtTwipb/+P7dozZ9GoaaXR9V2Zf3hzbOt7yipwuLxrTAz8oA1dNVh7er6W+fOq2GN/o3pE31AKv6EkIIcR/wDoFhy9SSpKZoneChBfaleqpYDYZ8Dc5mPmd1rmqp1uD6tvd9H7PrsTEXFxeSkpIstklKSkJjTekyYVHtEG82PNOB7/bGsGRPDLGJaYZk+b4eznSsFUhWjp4/zt4gJSObEF83BjYNZ3h0FUOJzjVPtmP5/kss3XuJcwl3cNFp6VArkJGtImhTQw3k6oR489Wui/x0+Cq3U7Pw93Khf5NKjIiOKDAwBTUw/L9BjfjkMfXf7s46FCctdUO8eTQ6ggcbh5kth9q0SgU2PtOBb/bEsPLAZeKT0vFw0RHk48a15HRSM3II9nFjQNNKPBodgVYD3+6JYcU/bb3cnOjdIISRrSKpF1Z+8rwJIYRwkIjW8K9dsP9z+Gsp3IlTr6bW668myA+qa3/fNbqpfe/7DI4sV0uiuldUb+W3nAD+1R12GPcLu5Lwd+jQgQsXLnD69GmTt/bT09OpWbMmVapU4ffff3fIQMuC0pQM93ZqJltOXCM5PYsgHze61AniZFwyRy7fBo2GJuF+NKiU/1vkmWt32HP+Bjl6hdrB3lTx92DH39dJy8whwt+TDrUCzU4DyJsQ+ctfT6DoXAvcprj8+vd11v51hbTMHBpV9mNEqwg8rZwnK4QQovSxuXxpUbpxFs7vUHOeuvlCZgrkZKmBabXOoC2a5EilKe5wJLs+nceOHcu4ceN48MEHWbhwoVHFqLNnz/Kvf/2Lq1ev8tprrzlsoMI6qZnZvLb2OD/8ecWoHKhOqyFHb/w9pHG4H68+WJ+ocD/OXLvDzNVH2XXuhsX+w3zdeKprTYa2rJJv3fXku0mOZ64+ZqgQFerrxtNmtilqm47H8/yKv7ideje11Lojcby94SQDmlZmzoCGOJmZ0iCEEEJYdPMcrHsOzm4DzFzr86sCXWZCo8HFOrSyzK4rpwCDBg1i5cqVODk5UbVqVSpVqsSVK1c4f/482dnZDBkyhO+++87R4y3VSvobTHpWDiM+28P+i7es3sbdWcfbAxvyyo/HuJVqfW7Qab3r8ETHu7cqbtzJ4OH3t/Lby30A0+VL792mqP18NJZ/fXPQ3NsFAG2r+/P1uGi0JXxlVwghhG1K/MrpzfOwqAekXLOufZ//U2/zO1BJxx1Fxe77mt9//z0LFizgo48+4uTJk5w+fRqAevXqMXnyZCZNkifTitvXuy7aFJgCpGXl8OLKI6Rm2lZC9O0NJ3mgYahhPuq8TX9zISHVpm2KUnpWDs99/5fFwBTg97M3WHckln5R5lNlCSGEKFmxsbHExhpXFExLSzP8/6FDh0ymtwwNDSU01PzDuoXyy0vWB6YAG6ZDvYfAK6hoxlOO2B2cajQapkyZwpQpU0hJSSExMRFfX9+SnfNxH1MUhW/2XLRrW1sDUwC9oj6UNK13HZLTs1j9Z8GZGfJuU9R+Ohxr9XF9suOsBKdCCFGKffLJJ7z66qtm17dr187k8lmzZjF79mzHD+h2DPy9wbZt9FlwcDF0eN7x4ylnHDLZztPTk7CwMIcGpgsWLCAyMhI3Nzeio6PZu3ev2badOnVCo9Hk+3nggQcAyMrK4sUXX6Rhw4aGsY4aNYqrV68a9RMZGZmvj//85z8OO6aiFJeUzsUblq9cOtre8+r81KNXkkjJzEHR3w0G0y8dNfp3rj3nLc9pdZRdZxOsbnv0ShJ6vV2zW4QQQhSDxx9/nAMHDtj88/jjjxfNgGL2gKIvuN29Ltw/D4kXhl1XTn///XdWrlzJCy+8QEhISL71sbGxzJ07l8GDB9OqVSub+1+2bBlTp07l448/Jjo6mvnz59OzZ09OnTpFUFD+y+GrVq0iMzPT8O8bN24QFRXFoEGDAEhNTeXgwYPMnDmTqKgobt26xdNPP82DDz7I/v37jfp67bXXmDDh7pwQb++yUW4sO6f4g6vcB6xy9Aqpp/7g5uZPDOuur5iNzjuAil0n4lG7jWF5cQWB9z78VRC9oqBF5p0KIURpVKS35+2hz7ZvO8X2O5X3I7uunM6bN4+1a9eaDExBPYl++ukn3n33XbsGNW/ePCZMmMDYsWOpV68eH3/8MR4eHnz++ecm21esWJGQkBDDz6ZNm/Dw8DAEp76+vmzatInBgwdTu3ZtWrVqxYcffsiBAweIiYkx6svb29uor7IyTSHYx82hlZasUTtEDdz/3rOZ66vfIueO8VXRnOQErq9+i9RTfxiW1QounmDflnynYb5u8sS+EEII6wXXs2+7IDu3u8/Y9Ym8b98+s/M7cnXo0IHdu3fb3HdmZiYHDhygW7duhmVarZZu3bqxa9cuq/pYtGgRQ4cOtRhYJiYmotFo8PPzM1r+n//8B39/f5o0acLcuXPJzjb/7SgjI4OkpCSjn5Li4qRlYLPKdm1rbw7SR6MjyMnJYdZ0y/Nnbm75n+EW/6OtCi5z6giDmoXjZOVxjW8v5U6FEELYIDQKwpravl3zxxw/lnLIruD02rVrVKpUyWKbkJAQrl2z4Sm2fyQkJJCTk0NwcLDR8uDgYOLi4grcfu/evRw9epTx48ebbZOens6LL77IsGHDjFIvPPXUUyxdupRt27bx+OOP89Zbb/HCCy+Y7WfOnDn4+voafsLDw604wqIzoX01Qn3dCm54j3HtIm0OUB+MCiMq3I/ffvuNy5cvW2ybk5xAxuVj9IsKo3G4n83js0cFTxer0lZV8nNnSIuS/b0JIYQog7q/Blob7lg2HQ2BtYtuPOWIXcGpn59fvtvh97p48aIh/1hxWrRoEQ0bNqRlS9M1crOyshg8eDCKorBw4UKjdVOnTqVTp040atSIJ554gnfeeYcPPviAjIwMk31Nnz6dxMREw8+lS5ccfjy2CPJx47sJragTYt2tcy9XJ/4zoCEv9anHguFNrapvr9XA4OaV+b9BUQD5UnuY0yJIwzv/bFNc/t2zNhPaVzU7k7R6oCerJ7eVSlFCCCFsV7U9DF0CHv6W22l00HIi9LVvquP9yK5P5VatWvHDDz9w6dIlk1cLY2JiWL16NV26dLG574CAAHQ6HfHx8UbL4+Pjzc5xzZWSksLSpUvNVqbKDUwvXrzI1q1bC0xYGx0dTXZ2NhcuXKB27fzfdlxdXU2Wby1JkQGebHimA3+cSWDdkViS07MJ9nGlZ/0QDl9O5OiVRNBAk3A/Hm5aGa9/ArNeDULoVDuQtX9dZc/5m+ToFWoEeRHk7cr+C7dIz86hSkUPBjcPN8pTau0E9ef6t8LFqfjndb78QD0mdarBu5v+5vezCWRl66lS0YMnu9agVbWAYh+PEEKIcqRWD5h6Ao6thvO/QnaG+hS/BjUo9a8BTUaAr33T7u5XdgWnU6dOZe3atbRt25Y33niD7t27ExoaSmxsLBs3bmTGjBmkpaXx3HPP2dy3i4sLzZo1Y8uWLfTv3x8AvV7Pli1bmDJlisVtly9fTkZGBiNGjMi3LjcwPX36NNu2bcPfv4BvOqhJfbVarckMAaVdmxoBtKlhHHw1Dvdj4/F4fjx0hVV/XuGb3TFoNODl5kRVf0/a1wzgVFwyl2+lokGDp4uOSzdTuXgzBQ0awit45Kuk1L59eypXrsyVK1cwVWxMo9FQuXJl2rdvb9dx7D1/k2X7LnHpZipuLjq61A7kkWaV8XYzfZX32NVEluyJ4cy1OzjrtLSu7s/QFuG83r+BXfsXQghRBPQ58Ns7at7P9CRwcoEaPaDnGwVfiSxIwhk48AXE/qX+Ozwamo0BvyKawuXkClFD1B/hEHaXL33vvfd47rnnDAGJRqMx/L9Wq2X+/PlMnjzZrkEtW7aM0aNH88knn9CyZUvmz5/P999/z8mTJwkODmbUqFFUqlSJOXPmGG3Xvn17KlWqxNKlS42WZ2VlMXDgQA4ePMhPP/1kNJ+1YsWKuLi4sGvXLvbs2UPnzp3x9vZm165dPPvss/Tu3ZvFixdbNe7SXEbs3PU7jFu8n/MJKYXqR6fV8EzXmjzZtaZh2apVqxg4cCCAUYCq0aiB7IoVKxgwYIBN+0lOz2LSNwfZeSZ/vlIvVyfeG9qYrnXv/h4zs/X8e/lfrPnrar72Ljotr/evz5AWVWwagxBCiCIQexg+7wFZaSZWauCB/4MW5p8bMUtR1KpNuxeSr869Rgedp5e7BPilOe4oDLuDU4DDhw/z8ccfs2/fPhITE/Hz86Nly5Y88cQTNGjQgIyMDLtve3/44YfMnTuXuLg4GjduzPvvv090dDSgJt2PjIzkyy+/NLQ/deoUderUYePGjXTv3t2orwsXLlC1alWT+9m2bRudOnXi4MGD/Otf/+LkyZNkZGRQtWpVRo4cydSpU60+htJ6ktxMyaTv+79xNTHdYX3O6lePsW3vvqarVq3iqaee4sqVu5WiwsPDmT9/vs2BqaIoDP90D7vOmU/Y76LT8t3EaJpFVARg6veHWHXQfJUqjQYWPtqUXg1KUZ48IYS436TegndqQ47pZzkMhi2D2r1s63vLa+rVWEt6vw3RRZSYvwSU1rijsAoVnJpz8OBBFi1axNKlS7lxo3gqApUGpfUk+WDLad7Z9LdD+6zo6cKu6V1wddIZluUeP/x/e/cdHlWZNn78OzPpnfSe0HsNEDosgqKyCiJI77giIMq7FlwV1H3dn+Kr4IqiiAiIICDSRWmirNQgQugEkgAhIZCENNJmzu+PbAJjJslMMpPMJPfnuua64Jyn3DM5ybnnnOc8D+zYsYMHH3wQjUZTXhPl+vViKuOWlb8iWIk+zfxYObkrl25mM+CD/ZWWb+rvxq45fU2ORwghhJlsngm/r6q8XIOGMPuE8e3mpsEHLaGokoswLr4w50zxrfg6wFrzjuoy2xMqGRkZfPzxx3Ts2JEuXbrw6aefkpdnvit1ourWHjX/LAJpOQX8eFr/obX7E9E+ffpUKTEF4+P99WIq19JzWXfMuPIXb2ZzLD6tSjEJIYQwg9PfG1cu/QpkmHDuOvlt5YkpQO4tOLfN+HZFrah2crp7925GjRpFcHAws2fP5o8//qBbt258/vnnRs1LKiyrUKvjeoahcT3VF1/N8avVbVdRIOF2rknjaKs75lYIIUQ1FGQbXzYl1viyt+NMKHvZ+LKiVlTpaf2rV6+yfPlyli9fTmJiIoqiEBISwvXr15k4cWK5y4yKmmenVqFRq0xea94YlpoaypR2He3UJpWvjemshBBC/JdKXTzVkjEcTJgr3ZTb9HYOxpcVtcLoM3VhYSHr169n0KBBNGrUiPnz53Pr1i3GjBnDTz/9REJCAgB2djKhuTVRqVT0bmqZ+Tz7NvOr1Xa9XR1oG+ppdHkHjZoejWVuUyGEqDXela/cBxSvvBTezfh2mzxgQtkBlZcRtcro5DQ4OJiRI0eye/du+vXrx4oVK0hOTmblypUMGDAAtVquSFmr8d3Nv559l8gGtAyyzODr0V3DsddUvpzqiM5hONppeKx9sFGrWw1qE4ife90YBC+EEDap31zjyjV7CDQmLA3a6C/g07TycuE9IKC18e2KWmF0Rnn79m1UKhUvvPAC33zzDePGjcPV1dWSsQkz6d8igHHdzJeg+ro5suBJyy1F6u/hxDtD26KqID/tEObF7P/Otepkr2HhUx1w0JR/ODf0deWNv7Yyd6hCCCFM0XZYcSJZERdfeOIL09pVqWDYUnCs4KKJqz88/rFp7YpaYXRyOnHiRJydnfnggw8IDQ3lscceY/369RQUFFgyPmEmbw9pw/y/tiK0gXO5ZTyc7PTWof9zbmivUfFouyC+f7YHkb6W/WIyvHMYyyZ0pn2oZ5kYp/RqyDfTonF2uDcbQL/m/nwzLZrujfRXFnGyV/NU5zA2PNMdXze5aiqEELVu/CboPAU0fx77qYKIHvD8SXAo/1xVruCOMPlHaPZw8djWEmp7aP0ETN0FPkYOKxC1yqR5TrOzs1m7di3Lli3j8OHDqFQqPDw8GDFiBOPGjaNPnz5MnTqVzz//3JIxWy1bmG9Mp1OISUwnLacAZ3sNOXlF5BQU0SLInTYhXlxLz+XcjSxQKYR7u1Ckg+tpuWg0KtqEeOLv7lRu2zk5Obi5FQ9gz87ONtuV9TNJmVxLz8XJXkOXSG+9pNSQy6nZxKXmYKdR0SmsAZ5G3PIXQghRwxQFTnwDty6CqzdETQJHd/O0nZEIKaeLk9SgDuAeAAU5xS8nz+IHqApyID8bnL1sdt5TW8g7qqLKk/CfPXuWL774gq+//prU1NTSpSp79erFypUriYgw/zhHa2dLB8kPp27w1W/xHL5SPO+nm6MdQzuGMKprGPvOp/LN4cTSKaga+boyOjqcsd0icLIvPzG0VHIqhBBCVNml3cVLml7aAyigdgA3P8i6UTxzgJ0TtB4K3WdAYNvajtYktpR3mKLaK0QVFRWxadMmli1bxq5du9DpdKjVavr27cvEiRMZN26cuWK1erZykLyxOZaVBxMM7lOroLxZpzqEebFqSlfcnQxfiZTkVAghhFX5+V34+R3jymoc4ckvoeVgy8ZkRraSd5jKrMuXXrt2jeXLl/PVV19x5coVVCoVWq3WXM1bPVs4SNYeSeSVjaeqXP+v7YP596iOBvdJciqEEMJqnNsBa0eZVsfOCWYchgaRFgnJ3Gwh76gKs87/FBoayuuvv05cXBy7du1i5MiR5mxemMGyA1eqVX/HqRsk35FlaYUQQli5Q5+YXqcoD44uM38swiQWm5z0gQceYPXq1ZZqXlTB+eQsLt40Yek4A7Q6hR2nbpgpIiGEEMICslMh/teq1T39vXljESaTmfPrkTt3C62qHSGEEMIi8u5Uve7dDLOFIapGktN6xNfNPOsJ+8oqS0IIIayZi7f+XKemcLPM0tzCeJKc1iON/NzKTGpvKkc7NYPbBpkpIiGEEMICXLyhycCq1W0nz8vUNklO65ln+lZvdYzhnUNp4GqeK7BCCCGExfR8zvSrp06eEDXRIuEI40lyWs883DaIlwe1KHe/vab8Be0HtPTnjcGtLRGWEEIIYV6RvWDwQlBVvKpgKSdPGL2ueDUpUavsajsAUfOm92tMt0berDqYwO6zKdwt1BLawIURncMY1imE/8Td4utDicRev4NKBZ3CGzC2WwQPtQ5Eoy4/eRVCCCGsStQECImCo0vhzBbIzwQXX/AIgvR4yM8C9yBoPxI6TwaP4NqOWGDmSfjru7o6Ga6xamISfkVROHj5NpduZqNRq+jeyIdGfm5G149LzebQ5dtodQrNAtzp1sjH7DEKIYSwQakXIOEA6LTg37L4yquVq6t5h1w5FTbjx9PJvPvDOS7fyindplJBz8a+vD2kDQ19y0+G41KzeX1TLL/F3dbb3tjPlbkPt2RAK7mNI4QQ9VLqBdjxP3DlF/3tvs1h4FvQfFDtxFWPyZhTYRM2n7jOM1/H6CWmAIoCBy7dYviS34j/074Sl1OzGb7kYJnEFCAuNYenVx1j28kki8QthBDCiqVegC8fKpuYAtw6X7z8qUzKX+MkORVWLzu/iH98H0tFA1BuZRfw5tbTBvfN23KatJyCcuvqFJi78RR3C7TVDVUIIYQt+eFFuJtW/n5FB1tnQ0FuzcUkJDkV1m/j8Wtk5xdVWm7/hVSupun/Abmcms2BS7cqrZuVV8SmE9erHKMQQggbc+siXN5febm8O3BqveXjEaUkORVW7/CVCr7V3kenwJE/lT0an1bhFVe9fi6Xve0vhBCijkr4DTDyBJHwH4uGIvRJciqsnk5n/IQS2j9lokUm1TW6qBBCCFunq/yO3L2yMuyrJklyKqxeswB3o8s2/1PZFoGm1DV+SiohhBA2LsCERWUCWlkuDlGGJKfC6o3qGo6dEZP/tw3xpH2Yl962qAhvoxJUe42KEV3CqhqiEEIIWxPeDfyNSDo1DtBxnOXjEaUkORVWL9DTiam9G1VYxl6j4pWHDS/L+uojLStNbv/WpzH+7k5VjlEIIYQNGvh25cub9nwe3PxrJBxRTJJTYRNeHtSc6f0aY68pm2Q2cLFnydgoejbxNVi3TzM/PhnTCS8X+zL7HDRqZvVvwv882MzsMQshhLByTQfAiJXg3KDsPo0D9HkJ+v+j5uOq52T5UjOqq8uIGasmli+9mZXH+mPXuJiShZ1GTfdGPgxuH4SjXSXffIG8Qi3bTt4oXb60aYAbIzqH4evmaPY4hRBC2JDCPIj9rvipfF1R8fKlHcaCm19tR1ahupp3SHJqRrZ0kBRpdfx0JoXNJ66TllNAAxcHHusQzEOtA7HXqFl37CpLfo4jNSsfjVpFp4gGTOnVkP0XUjl5LQMVKjqEezG6azhh3i5AzSSn97tboGXzietsO3mDhNs55BXq8HZ1oEOYJ2O6RdAu1AuAa+m5rDmSyPGEDBQU2oZ4MiY6gsgKljsVQghhJjf+gJivildj0thBw77QaTy4Gr7bBRQ/HX/hRzi5FrJTwdkLWg+FVo+DXSUXFBQFLv8MJ1bDnevg4AotHoV2I4r/XYfYUt5hCqtNThcvXsyCBQtITk6mffv2/Pvf/6Zr164Gy/br14/9+8tOpPvII4+wfft2ABRFYd68eSxdupSMjAx69uzJp59+StOmTUvLp6WlMWvWLLZu3YparWbYsGEsWrSoNOGqjK0cJJdTs5n81VHib5dd8SLEy4m7BVrScguNakutgpn9mzJnYLMaTU4PX77N9NXHK1z56aHWATQLcGfxvkv8eUYplQqm9mrIq4+0RKWq/GErIYQQJirKh03Ti69I/pnGEQZ/AB3Hlt2XngDfPAWpZ8vu8wiBUWshqJ3hPnNuwZpRcO1I2X3O3vDUKojsZdr7sGK2kneYyirHnH777bfMmTOHefPmcfz4cdq3b89DDz3EzZs3DZbfuHEjN27cKH3Fxsai0WgYPnx4aZn33nuPjz76iCVLlnD48GFcXV156KGHyMvLKy0zZswYTp8+za5du9i2bRu//PILTz/9tMXfb01Kyylg7BeHDSamANcz8oxOTKF44vuP9lzk81/izBVipS6kZDH5q6MVJqYAP55O4d97yyamUPzFeumvV/hw1wULRSmEEPXcllmGE1MAbT5snglnt+lvz8uEVUMMJ6YAmdeL92dcNdBmIax+0nBiCsXLlK4eASmGl7oW1sMqk9MPPviAadOmMWnSJFq1asWSJUtwcXHhyy+/NFje29ubwMDA0teuXbtwcXEpTU4VRWHhwoW89tprPP7447Rr146VK1eSlJTEpk2bADh79iw7d+7kiy++IDo6ml69evHvf/+btWvXkpSUVFNv3eJWH0og6U5e5QVN9PHeSzW2Nv0n+y6RY6a+Pv/1MnfuGp+MCyGEMELqeTj5bSWFFNj3v/qbTqyGtMsVV8u9DYc+Lbv97FZI+r3iuoU58Ov/VRKXqG1Wl5wWFBQQExPDgAEDSrep1WoGDBjAwYMHjWpj2bJljBw5svS28pUrV0hOTtZr09PTk+jo6NI2Dx48iJeXF507dy4tM2DAANRqNYcPHzbHW7MKa48a+LZpBpl5Rfx4Otkibd/vzt1CdsSar5+8Qh2bfr9utvaEEEIAMSuMK3fzDFy970rn8ZXG1TuxuvhK6f2OG9nn2a2Qa9yy2KJ2WF1yeuvWLbRaLQEBAXrbAwICSE6uPCk5cuQIsbGxTJ06tXRbSb2K2kxOTsbfX38eMzs7O7y9vcvtNz8/n8zMTL2XNSvU6riecddi7Sek5Vis7RI37tyloEhn1jav3LJ83EIIUa+kmTDU63ac4X9XJC+jbIJ5u5IrriW0BXDHMhdqhHlYXXJaXcuWLaNt27blPjxlTv/617/w9PQsfYWFWfcKQ3ZqFRojVlqqKkeN5Q8nBwv04Whf534NhBCidmkcjC97/9P3lT2Jr1fPoeL/V1hXFl2xZlZ3Vvb19UWj0ZCSkqK3PSUlhcDAwArr5uTksHbtWqZMmaK3vaReRW0GBgaWeeCqqKiItLS0cvudO3cud+7cKX1dvWrd38RUKhW9m1YwdUc19W5m+fngGvq6EuHjYtY2+9ZA3EIIUa80GVB5GSh+ar9hn/vqPWBcvZCoshPnG9unVwT4NK28nKg1VpecOjg4EBUVxZ49e0q36XQ69uzZQ/fu3Susu379evLz8xk7Vn9qioYNGxIYGKjXZmZmJocPHy5ts3v37mRkZBATE1NaZu/eveh0OqKjow325+joiIeHh97L2o3vHmGRdjuEedE62NMibd9PpVIxNtp876Gpvxs9GlsuYRdCiHqp7XBw8qq8XOsh+vOddplmXPuGynWZChhxd7DzZFBbXfoj7mOVP505c+awdOlSVqxYwdmzZ5k+fTo5OTlMmjQJgPHjxzN37twy9ZYtW8aQIUPw8fHR265SqXj++ef55z//yZYtWzh16hTjx48nODiYIUOGANCyZUsGDRrEtGnTOHLkCP/5z3+YOXMmI0eOJDg42OLvuab0bxHA2G7hZm3T29WB94e3N2ubFZnYM9KoK8AaFbg72pW7393JjoUjO5gxMiGEEAA4uMCwLyq+ve/TBB56R39bZE/oObvittsMg/Yjy273bVq2vT9r1A+6z6i4jKh15Z+5a9FTTz1Famoqb7zxBsnJyXTo0IGdO3eWPtCUmJiI+k/fes6fP8+BAwf46aefDLb50ksvkZOTw9NPP01GRga9evVi586dODndG3eyevVqZs6cyQMPPFA6Cf9HH31kuTdaS/45pC1N/Nz44sAVrqXfe0AqxMuZST0j0ep0/HtvHNn5RXr1XB005BXq0P533QY7tYoHWwfw0kMtiPR1JSenZh4ssteoWTahCx/tucjqwwmkG5iXtUtkA+YMbE6IlzPv7jzHT2eSKdQWx61Rq/hLc39eHtScpgHuNRKzEELUO00HwvgtxdNFxf96b7u9C7R9Eh6YD64+ZesNfAu8G8F/PtJ/sMo9GLpOg57PF6+kYkj3Z8E9sHi6qJTYe9tdfCBqIvR9BTT2ZnhzwpKsdoUoW2RrKzXodAoxiemly5d2jmiA+r4HpnadSeb3xAyc7DWM6BxKoKczSRl3OXujeFaCNiGeBHjcS+6rskLUnbuFFGp1OGhU5BXp8HS2x9FOY/R7yC/Sciw+ndSsfNJzCwjxcqaRnytN/PWTzpuZeZy6fgdFgZbBHoR4ORvdhxBCiGq6dbH4pbGH0C7Fy5FWRlHg2lHIvglOnhDevXj5U2Ml/X5v+dKIHqY9bGUjbC3vMJYkp2ZUVw8SYxmbnOp0Ct8dv8aqQwmcvHZHb5+jnZq/tg9mau+GtAisf5+hEEIIYay6mndY5W19UXdpdQqz1hxnx6ly5o4t0rEh5hpb/0hi8ehODGgVYLCcEEIIIeomq3wgStRd/957sdzE9H75RTpmrjlu0UUDhBBCCGF9JDkVNaagSMeqgwlGl88r1LH6kPHlhRBCCGH7JDkVNebg5dvczikwqc62kzcsFI0QQgghrJEkp6LG3LlbdsonS9QRQgghhO2S5FTUGF83E9Y9rkYdIYQQQtguSU5FjYlu6GPy/KJPdAq1UDRCCCGEsEaSnIoao1GrmNq7odHlvVzseapLmAUjEkIIIYS1keRU1KhJPRsysUdkpeU8ne1ZNqELvm51b0UPIYQQQpRPJuEXNW7+Y60Z2CqAlQfj+eV8KvlaHSpUKCgEeDgxPCqUMd0i9JZGFUIIIUT9IMmpqNC55EyOxaejKAqtgj2IivDW25+UcZdfLqSSV6jF3+Xedp1OYf+FVOJv5eBgp6Z3U19CG9wr0LOJLz2b+NbU2xBCCCGEjZDkVBh0JimTNzbHciwhXW97i0B3Xh/ciqb+bry2KZY9526i1SkA6ArySssN/HA/ybn36qlV0L9FAP8c0oZAT7kiKoQQQgjDJDkVZZxOusPIzw6RlV9UZt+55CwmfHmYBq6OpGbll9tGUkYeaod7SahOgd1nUziXnMnG6T3wl1v2QgghhDBAHogSZbz6fazBxLREkY4KE9OKXEu/y7s7z1c1NCGEEELUcZKcCj0nr2Xwx9UMi/ax7WQSGbmmLWMqhBBCiPpBklOh58iVNIv3kV+k43cLJ8BCCCGEsE2SnAo9Rf99uMnSdDXUjxBCCCFsiySnQk/zQHeL96FSQbMAy/cjhBBCCNsjyanQ07epH6ENnC3aR++mfoR5u1ReUAghhBD1jiSnQo9areLVR1qiUlVczl5TSYFyONtrePHB5lWqK4QQQoi6T+Y5FWU80jaID0d04PXNsWTl6U8p5Win5vkBzWjkms+LK34hNfvelFJK4b0n8AtvXgY7B726Pq4OvDuuD21DPS37BoQQQghhsyQ5FQYN6RjCg60D2PR7EjEJ95YvfTIqFC8XB+bPn8+pxW+WWz959UtltwFH/ebxaLfWFoxcCCGEELZMpSiKPDZtJpmZmXh6enLnzh08PDws0kdcajarDyVy5sYd1CoVnSMaMCo6nCBPw+NEk+/kseZIIkfj09DqFFoGeTC2WzhN/Mt/ICk1K59vjyZy8PJtirQKzQLcGR0dTsuge+/pxo0b3Lhxo/T/OflF7DmbwtGEdAoKdQR4OPFg6wDahBRfJb1bUMTe86mcvK1C5dKAkAbODO8cSo/Gvka/99jrd/jmSCKXbmbjoFHTs4kvQzoEc+DSLXbGJpOVV4SPmwOBHk7E384hJ19LgKcTT0aF0qepL6rKxioIIYSwDtpCOLMZYjfC3XRw9YG2I6DFo6DW1HZ0VqMm8o7aIMmpGVnyINHpFN7cepoVBxPK7NOoVfz9weZM79dYb/vSXy7z7s5zBqeHGhMdzluPt0Gj1k/YVh9O4M0tZyjQ6srUeaJjCO8+2Q57jf5Q5b3nUnhuzQmyDawq1auJL+O6R/Di+j/IzCu7v2ukN5+Pj8LLxaHMvhL5RVrmrPuD7SdvlFumMu1DPVk6oTP+7rJsqhBCWLWbZ+GbEZCRWHafTxMYvQ58GpfdVw9JcioqZcmD5F87zvLZL5crLPPPIW0Y2y0CgLVHEnll46kKy0/p1ZDXB7cq/f/WP5KYteb3Cus81TmMd59sV/r/mIR0Rn1+yGAyW0KlgoqOsk7hXqx/pkeZRLnEc2t+Z8sfSRXGZYyWQR5smtEDRzv51i2EEFYpKxk+6wPZKeWX8QyHv+0HF++ai8tK1dXkVJ7WtwG3svNZ/p/4Ssst2nORQq2OIq2OD3dfqLT8yoPx3MzKA0BRFD7YVXmddTFXSbydq9dnRYlpcdsVt3k8MYO9524a3Hc+OcssiSnA2RuZ7DhV9auvQgghLOzwZxUnpgB3EuH4ipqJR9QKSU5twMbj1ypNAKF4rOiesynsO59KSmZ+peULtQobYq4BcOhyGldu5VRaR1Fg7dHiWy3X0nP59WJqpXWMsfaIgds33OvLXNYcuWrW9oQQQpiJosDvq4wrGyPJaV0mT+vbgCu3cisvdF9Zu3Jujxssn1qckMbfrjwxvddHcdnE27mVXhU1us1y+o83ImE2qR8ztyeEEMJM8jMhx8gLHunxoNOBWq6x1UWSnNoARzvjf/kc7NQmJaeO9sVtO2iM76MkHgcT4qq8TcPjQM3ZR3E/8odMCCGsksbRhLL2kpjWYfKTtQF9m/mZVLZPM79KV3i6V94fgF5NfY1Oavs2L46nbagn3q7lP2VvivLeY0l85mLKZymEEKIG2TtBRC/jyjZ+wLKxiFolyakN6NvMj3Aj1qLv0diHJv5uNPR1pVeTyucPDfFy5oEWxclfybyklfF1c+CRtkFA8dXOp7qEVVqnMhq1ijHR4Qb3DekYjIeTeS7wq1QwrnuEWdoSQghhAV2nmrecsEmSnNoAtVrFR6M64uZYfpLm7+7Iu8PuTfH0ryfaEuhR/pyeLg4aPhrVEfV9V0vnP9a6wiTY0U7NopEd9W7BP9e/KR3DvSqMv6Gva4X75z/WmrBy+nVxsGPhyA4mDTsoz0sPtaBFYN2ZakMIIeqc1kOhw9iKy0Q/A00G1Ew8olZYZXK6ePFiIiMjcXJyIjo6miNHjlRYPiMjgxkzZhAUFISjoyPNmjVjx44dpfsjIyNRqVRlXjNmzCgt069fvzL7n3nmGYu9R1N1CPNi/TPd6d/Cn/vvvjto1DzWPpjvZ/TUS/BCG7iw8dkeDOkQrJfYqVXQr7kf6/7WnaiIBnp9+Ls78d30HgyPCtUbm6lSQc8mPqx5uhs9/3RF1tlBw+qp0Uzp1bDMFc72oZ58ObEzP8zuzd/6NMLLxV5vf+tgD5aMjWJct4qvZvZvEcDXU6OJbqg/p52zvYY2IZ74uOkPLfjz6IRmAW4sGtmhzCIFQgghrNDjH8OD/wSPUP3tDSLhkffh4XdrJSxRc6xuEv5vv/2W8ePHs2TJEqKjo1m4cCHr16/n/Pnz+PuXHX9YUFBAz5498ff359VXXyUkJISEhAS8vLxo3749AKmpqWi12tI6sbGxDBw4kH379tGvXz+gODlt1qwZb731Vmk5FxcXkya1ranJcK+m5XI+OQu1GtqGeOHnXvEg8lvZ+Zy8loFOB80D3cu9SqnVKaTnFmCvVqOg8HtiBkU6pXSoQGXuFmg5Gp9GXqEWT2d7mvi74eXiUDq5fubdQn65mIqiU2jo51a6tClAek4BCuDlbK93Nff+mDxd7IlLzeZyag52GhWdwhvg6WxPoVbH0StpZOUX4e/uSOtgT47Gp5GdX0SghxPtw7wq/1CFEEJYF50WEg/9d/lSXwjtKg9B/UldnYTf6pLT6OhounTpwscffwyATqcjLCyMWbNm8corr5Qpv2TJEhYsWMC5c+ewt7cvs9+Q559/nm3btnHx4sXS9db79etHhw4dWLhwYZVjt9WD5GZWHl8eiGf9savczikAoE2IB+O7RTIsKrTclZv+rEir49tjV1l1MIFzyVkA+Lk7MrClP9n5Rfx0JoW8Qh0qVfE42jHR4VxLv8vXhxKI+++UVkGeTozqGs7gdkFsiLnGumNXuZVdHFPrYA/GdYtgeOcwo2MSQggh6ipbzTsqY1XJaUFBAS4uLmzYsIEhQ4aUbp8wYQIZGRls3ry5TJ1HHnkEb29vXFxc2Lx5M35+fowePZqXX34Zjabs9EQFBQUEBwczZ84cXn311dLt/fr14/Tp0yiKQmBgIH/96195/fXXcXGp/EGkErZ4kFy6mc2YLw6VO2n/wFYBfDqmE3aVjPnML9IybWUMv1wwz6T8GrUKrc7woflAC3+WjIvC3gzjUIUQQghbZYt5hzGsap7TW7duodVqCQjQf2o8ICCAc+fOGaxz+fJl9u7dy5gxY9ixYweXLl3i2WefpbCwkHnz5pUpv2nTJjIyMpg4caLe9tGjRxMREUFwcDAnT57k5Zdf5vz582zcuLHcePPz88nPv5fUZWZmmvBua59Op/D0ymMVria160wKC3df5O8PNa+wrXd/OG+2xBQoNzEF2HPuJv/30wVeebiF2foTQgghhHWwquS0KnQ6Hf7+/nz++edoNBqioqK4fv06CxYsMJicLlu2jIcffpjg4GC97U8//XTpv9u2bUtQUBAPPPAAcXFxNG5s+EGaf/3rX7z55pvmfUM1aM+5m1w2YsWk1YcTmNm/CU72hifKz8or5FszLzNamW8OJzD7gaY4OxiOSQghhBC2yarui/r6+qLRaEhJSdHbnpKSQmBgoME6QUFBNGvWTO8WfsuWLUlOTqagoECvbEJCArt372bq1MrnR4uOjgbg0qVL5ZaZO3cud+7cKX1dvWpb67ZvP5lkVLn03EL+c+lWufv3nU8lp0Bb7n5LyMwr4peL5rtSK4QQQgjrYFXJqYODA1FRUezZs6d0m06nY8+ePXTv3t1gnZ49e3Lp0iV0Ol3ptgsXLhAUFISDg/4UQ8uXL8ff359HH3200lhOnDgBFCe/5XF0dMTDw0PvZUvu3C00S9lME9oxJ1PiF0IIIYRtsKrkFGDOnDksXbqUFStWcPbsWaZPn05OTg6TJk0CYPz48cydO7e0/PTp00lLS2P27NlcuHCB7du388477+jNYQrFSe7y5cuZMGECdnb6oxni4uJ4++23iYmJIT4+ni1btjB+/Hj69OlDu3btqKt83Yxfx7iisr5u5lnC1FR+JsQvhBBCCNtgdWNOn3rqKVJTU3njjTdITk6mQ4cO7Ny5s/QhqcTERNT3zXMWFhbGjz/+yAsvvEC7du0ICQlh9uzZvPzyy3rt7t69m8TERCZPnlymTwcHB3bv3s3ChQvJyckhLCyMYcOG8dprr1n2zdayoR1DWB9zrdJyAR6O9GjsU+7+fs398XKxJyO35q5k+rk70qtp5Uu0CiGEEMK2WNVUUrbOFqd0eOzjA5y8dqfCMv94pCXT+jSqsMzC3RdYuPuiOUOr0MuDWsiKT0IIIeo1W8w7jGF1t/VFzVo6vjNN/d3K3T+2W3iliSnAc/2bMqxTaKXl7lfRNPpO9uUfmqO6hvFM38pjEkIIIYTtkSunZmSr32By8ovYePwaqw8nli4N2rOJL+O7R9C7qZ9Jbe07d5NVhxI4dPk2RTqFZgFuDG4XTObdQjafSCIlMw93JzsGtQlibHQ4V9PvsvpwAsfi09EqCq2CPBjbLYIHWvqx7WQy3xxOJO5mNnYaFT0a+zKuewR9m5kWkxBCCFEX2WreURlJTs2oJg+SnPwi9py7ye3sfLxdHejfwh93p4qXb41JSOdM0h1Qqegc0YCWQXXnQBZCCCFqRc4tuPgT5GeBexA0ewjsauaB3bqanFrdA1GiYkVaHQt+Os83hxLJyi8q3e7qoOGpLuG88nALHOz0b4n/dukWb28/y9kb+itYRUU04M3HWtMmxLNGYhdCCCHqjLxM2PkKnNoA2vtWWnTxhR4zodcLtRebjZMrp2Zk6W8wOp3CjG+O80Nscrll+rfwZ+n4zmjUxSM6919IZeqKoxRqDf+Y3RztWPt0N0lQhRBCCGMV5MBXgyHpePllop+Bh9+1aBh19cqpPBBlQ36ITa4wMQXYe+4m3/9+HSi+yvryhpPlJqYA2flFzN14yqxxCiGEEHXawU8qTkwBDi+Bq0drJp46RpJTG7LyYLxR5Vb9t9yuMykkZ+ZVWv7U9Tv8nphejciEEEKIekKnhZjlxpU9utSysdRRkpzaCEVROBqfZlTZP67dIa9Qy+ErxpUHOGJCWSGEEKLeSo+HzOvGlU34zaKh1FWSnNoInQKmDA7W6hS0OuNrFJlQVgghhKi3dEWVl6lKWVFKklMboVGraOJX/mT59wtt4Iyrox3NA92Nbr+FCWWFEEKIesszDByNfPjIv5VlY6mjJDm1IaOjw40qNyY6AoAhHUNwddBUWj7Ey5m/NPevVmxCCCFEveDgAu1GGFe282TLxlJHSXJqQ0Z0Dqv0CmcjP1fGdCtOYt0c7XhhYLMKy6tUMPeRFqjVFS0mKoQQQohSvV4At4CKyzTsA80frpl46hhJTm2Iq6Mdq6ZE0zXS2+D+juFefDO1Gx73rRQ1tXcj5j7cwuBa9e6Odrz/ZHsGtwu2WMxCCCFEneMZChO2gW85F4BaDIaRa0Bd+d1LUZZMwm9GNTkZ7omrGWz6/TppOQU0cLHnsQ7BREUYTloBMnIL2BBzjTNJmaAqXh1qaMcQXBxkkTAhhBCiShQF4vbC2a3Fy5d6BEOHMeDfoka6r6uT8EtyakZ19SAx1u3sfL49dpXfLt2mQKujib8bo7uGW2T1qd8u3WJ9zDWup9/FxVHDgJYBDO0YgqujJNtCCCH+5PJ++P1ruHMNHFyhxSPQ7qnif9uwupp3SHJqRnX1IDHG+mNX+cemWAqKdGX2DW4XxP+NaI+jXfVvb6TnFPC3VTEcMTDnq6ezPYtHd6JXU99q9yOEEKIOyE2DNaPg6qGy+5y8YMRKaNS3xsMyl7qad8iYU1FtP55O5qXvThpMTAG2nbzBSxtOVrsfrU5h0ldHDSamAHfuFjJ15VFir9+pdl9CCCFsnLYIVj9pODEFyMuANSPhRvXPT8K8JDkV1fbBTxeo7Pr75hNJXEzJqlY/u86kcOJqRoVl8gp1fLz3UrX6EUIIUQec3w7XYyouU5gLv75fM/EIo0lyKqrleGI6541MOtccuVqtvr49mmhUud1nU7iVnV+tvoQQQti44yuNK3duO+TcsmwswiSSnIpqib+VY3zZ28aXNVw/16hyRTqFq2nGlRVCCFFH3Y4zrpyuCDISLBuLMIkkp6JaHOyMP4QcTShrsC+NKX3J3HJCCFGv2TmaUNbJcnEIk0lyKqqleyMfoxPUvs38qtVX3+bG1Q/ydKJ5JStpCSGEqOOaDDCunGcY+NXMvKTCOJKcimrxcXPk0bZBlZbzcLLj8Q4h1eprbHQExqyyOrprOBpZjlUIIeq3zpNBZUSaEzVRVnKyMpKcimp7fXArGvmVP5Gxg0bNopEdcXao3i9/uI8L8x9rXWGZbo28ebpvo2r1I4QQog7waQyD/l/FZSJ7Q49ZNROPMJokp6LavF0d2PBMD0Z1DcPZXj8B7dbIm9XTovlLC3+z9DW+eyRLxnaiVZD+ZMNeLvY807cxX03qKuNNhRBCFIv+W/FE+wFt9bc7e0OvF2Dsd6aNTRU1QlaIMiNbXqkhPacAnaLQwMUBtYFb4hm5BWh15e8vceduIccT0ynSKjTyc6Wxn5vFYo69foekjLu4ONjRLtST/CIdLg4aWcJUCCFsjaIUr+YE4OINKgsMzUo6AZnXwd4FwruDve0/BGXLeUdFJDk1I1s7SPKLtKw9cpVVhxK4dDMbgEAPJ0Z1DWdij0icHTSsPZrI14cSuJBSvD/Aw5GRXcKZ1DMSLxeH2gwfgEs3s1l24DKbfk/ibqEWlQp6NvZlUs9IHmgZUNvhCSGEqEhBDhxdBse+hPQrxdu8IqDzJOgyDRwtd4GjLrC1vMNYkpyakS0dJHcLtExcfoTDVwwvBRrh44KvmyMxCenl7l8zrRvBXs6WDLNCv15M5emVMdwt1Brc/0zfxrzysDyBKYQQVuluOqx8HG78YXh/QFuYsKX4SqowyJbyDlPImNN66q1tp8tNTAESbueWm5iW7J+++rglQjPKrex8pn99vNzEFGDJ/ji2/pFUg1EJIYQw2pZZ5SemACmnYNP0motHWA1JTuuhtJwCvjt+vdrt/HE1g5iE8hNcS1p7JJHs/KJKyy07cKUGohFCCGGS9PjiZUMrc+FH41d6EnWGJKf10K4zyRQU6czS1tY/bpilHVNtO2lcvyeuZnAtXZYyFUIIq3JmMyjGnIcUOL3R4uEI6yLJaT10526h2drKNGNblurXnO9XCCGEGdzNsExZUSdIcloP+bqZb043X/famR/Ox8j3oFKZ9/0KIYQwAzcT5r42payoE6wyOV28eDGRkZE4OTkRHR3NkSNHKiyfkZHBjBkzCAoKwtHRkWbNmrFjx47S/fPnz0elUum9WrTQf4o7Ly+PGTNm4OPjg5ubG8OGDSMlJcUi76+2Pdg6ENdqrtZUYkg1lyStcr8djeu3R2MfAjxsfy47IYSoU1o/AWr7ysupNNDmScvHI6yK1SWn3377LXPmzGHevHkcP36c9u3b89BDD3Hz5k2D5QsKChg4cCDx8fFs2LCB8+fPs3TpUkJC9JOX1q1bc+PGjdLXgQMH9Pa/8MILbN26lfXr17N//36SkpJ44oknLPY+a5Obox1ju0VUu50+zfxoFVw7U1c8GRWKr1vF86yqVPB0n8Y1FJEQQgijuQdA+5GVl2s7HDxr5yKIqD1WN89pdHQ0Xbp04eOPPwZAp9MRFhbGrFmzeOWVV8qUX7JkCQsWLODcuXPY2xv+FjZ//nw2bdrEiRMnDO6/c+cOfn5+fPPNNzz5ZPE3tHPnztGyZUsOHjxIt27djIrdluYbK9LqmP3tCbaX82BRhzBPgjyd+SE22eD+9qGerJjctVYn4o+9focJXx7hdk5BmX1qFcz7a2sm9Iis+cCEEEJUrjAP1o6GuD2G9zfsC6PWgoNLzcZlQ2wp7zCFVV05LSgoICYmhgEDBpRuU6vVDBgwgIMHDxqss2XLFrp3786MGTMICAigTZs2vPPOO2i1+vNfXrx4keDgYBo1asSYMWNITEws3RcTE0NhYaFevy1atCA8PLzcfgHy8/PJzMzUe9kKO42aj0d15PNxUfRu6ouzvQYHOzXtw7x478l2fPu37nwyphNLx3emTzO/e/tDPXlvWPH+2l4hqk2IJzuf78Ocgc0I83bGXqPC09meEZ1D2TKzlySmQghhzeydYPQ6ePJLiOgFds5g5wThPWDYMhi7URLTesqqFiG/desWWq2WgAD9ZScDAgI4d+6cwTqXL19m7969jBkzhh07dnDp0iWeffZZCgsLmTdvHlB8Nfarr76iefPm3LhxgzfffJPevXsTGxuLu7s7ycnJODg44OXlVabf5GTDVw4B/vWvf/Hmm29W703XIpVKxYOtA3mwdWC5ZQa2CmBgK+tdBtTP3ZHnHmjKcw80re1QhBBCmEpjB22GFb+E+C+rSk6rQqfT4e/vz+eff45GoyEqKorr16+zYMGC0uT04YcfLi3frl07oqOjiYiIYN26dUyZMqXKfc+dO5c5c+aU/j8zM5OwsLCqvxkhhBBCiHrOqpJTX19fNBpNmafkU1JSCAw0fHUvKCgIe3t7NJp7T5+3bNmS5ORkCgoKcHAoe+vZy8uLZs2acenSJQACAwMpKCggIyND7+ppRf0CODo64ugo0xQJIYQQQpiLVY05dXBwICoqij177g2O1ul07Nmzh+7duxus07NnTy5duoROd2+liQsXLhAUFGQwMQXIzs4mLi6OoKAgAKKiorC3t9fr9/z58yQmJpbbrxBCCCGEMD+rSk4B5syZw9KlS1mxYgVnz55l+vTp5OTkMGnSJADGjx/P3LlzS8tPnz6dtLQ0Zs+ezYULF9i+fTvvvPMOM2bMKC3z97//nf379xMfH89vv/3G0KFD0Wg0jBo1CgBPT0+mTJnCnDlz2LdvHzExMUyaNInu3bsb/aS+EEIIIYSoPqu6rQ/w1FNPkZqayhtvvEFycjIdOnRg586dpQ9JJSYmolbfy6nDwsL48ccfeeGFF2jXrh0hISHMnj2bl19+ubTMtWvXGDVqFLdv38bPz49evXpx6NAh/Pz8Sst8+OGHqNVqhg0bRn5+Pg899BCffPJJzb1xIYQQQghhffOc2rK6Ot+YEEIIIaxPXc07rO62vhBCCCGEqL8kORVCCCGEEFZDklMhhBBCCGE1JDkVQgghhBBWQ5JTIYQQQghhNaxuKilRvt/ibrH+2DWup9/F2UHDgFYBPNExhOz8ItYcSeTIlTS0OoWWQR6MiQ6naYB7bYcshBBCCGESmUrKjCw1pUNGbgFPr4rhyJW0Mvuc7NUUFOnQGfgpjuoaxj+HtEWjVpktFiGEEEJYB5lKStQKrU5h8ldHDSamAHmFhhNTgDVHrvL2tjMWjE4IIYQQwrwkObVye86mcDwxo8r1vz6UQPKdPPMFJIQQQghhQZKcWrlvj16tVv0incL6Y9VrQwghhBCipkhyauWu3M6xijaEEEIIIWqCJKdWzkFT/R+Ro53GDJEIIYQQQlieJKdWrm9zv+q30az6bQghhBBC1ARJTq3c2OiIak0FFezpxMBWAWaMSAghhBDCciQ5tXJh3i7Mf6w1qirkp872GhaN6ijznAohhBDCZsgKUTZgXLcI/Nwc+ffei5xOyizd7uViz+B2wWTeLWTn6WQKinQAqFTQu6kfLz3UnDYhnrUVthBCCCGEySQ5tRGD2gQyqE0gsdfvkJRRvHxpl0hvnOyLH3a6nZ3PH9cy0OqgeYA74T4utRyxEEIIIYTpJDm1MW1CPA1eDfVxc6R/CxlbKoQQQgjbJmNOhRBCCCGE1ZDkVAghhBBCWA1JToUQQgghhNWQ5FQIIYQQQlgNSU6FEEIIIYTVkORUCCGEEEJYDUlOhRBCCCGE1ZDkVAghhBBCWA1JToUQQgghhNWQFaLMSFEUADIzM2s5EiGEEELUdSX5Rkn+UVdIcmpGWVlZAISFhdVyJEIIIYSoL7KysvD0LLu0ua1SKXUt3a5FOp2OpKQk3N3dUalUtR1OrcjMzCQsLIyrV6/i4eFR2+EIIYSow+r7OUdRFLKysggODkatrjsjNeXKqRmp1WpCQ0NrOwyr4OHhUS//UAghhKh59fmcU5eumJaoO2m2EEIIIYSweZKcCiGEEEIIqyHJqTArR0dH5s2bh6OjY22HIoQQoo6Tc07dJA9ECSGEEEIIqyFXToUQQgghhNWQ5FQIIYQQQlgNSU6FEEIIIYTVsMnk9OLFi8ycOZNWrVrh6uqKk5MToaGhdOnShZkzZ/Ldd9+VqdOvXz9UKhU///xzzQd8n59//hmVSkW/fv0s0v5XX32FSqUy+fXVV19ZJJ4SJf2YU1WOg6qaOHFijXxO95s/fz4qlYr58+cbXUdRFN5++22GDh1K8+bN8fb2xt7eHn9/fx588EG+/vrrOrfMnRCWJuec8sk5p36fcwAiIyMr/Fl369bN5FhsbhL+jRs3Mnr0aPLz8/Hx8aFnz574+fmRnp7OiRMnWLx4MWvXrmXYsGG1HWqtaNKkCRMmTCiz/cCBA8TFxdG4cWN69eplsJ4tkePAMK1WyxtvvIGjoyNt27alefPmODs7k5CQwO7du9m1axfr1q3j+++/R6PR1Ha4Qlg9+VtTMTnnyHFQYtiwYbi5uZXZ3rhxY9MbU2xIcnKy4ubmpgDK//zP/yh3794tU+bYsWPKK6+8UmZ7QkKCcvbsWSUnJ6cmQi3Xvn37FEDp27dvjfY7YcIEBVAmTJhQo/2WABRzHW7VOQ6qKikpSTl79qySkZFhtjYrM2/ePAVQ5s2bZ3QdnU6n7Nu3z+BncvLkScXf318BlCVLlpgxUiHqJjnnVJ2cc6rHVs45iqIoERERCqBcuXLFbLHY1JXTbdu2kZ2dTXBwMO+//77BMlFRUURFRZXZHh4ebunwRA2pznFQVUFBQQQFBZmtPUup6PZd27ZtmTlzJm+88QY//fQTf/vb32o2OCFsjJxzBMg5pzbY1JjTlJQUAPz8/EyuW974n/vHdVy5coVx48YRGBiIo6MjjRs35rXXXiM/P99gm0VFRfzf//0fbdq0wcnJCX9/f4YPH86ZM2dKx+FMnDjRpDjT09OZN28eHTp0wN3dHRcXF9q2bcs///lPcnNzTX7fxti4cSNTp06lTZs2NGjQACcnJxo2bMjkyZM5f/68wTr5+fksWLCAqKgo3N3dcXBwIDAwkC5duvDSSy+RlpZmVN9arZbp06ejUqlo27YtV69erbROdY6DkrEx8fHxfP/99/Tq1QsPDw/c3d3p168fO3bsMFivvPE/94/RSUxMZMqUKYSFhWFvb6/3s6/KZ2wJdnbF30dlwmohKifnHDnngJxzaoNNXTkt+SYaGxvLnj17eOCBB8zW9okTJ5g9ezYNGjSgb9++pKWl8Z///If//d//5fTp03z//fd65XU6HUOHDmXbtm04ODjQr18/GjRowNGjR+nSpQuTJ082OYYzZ84waNAgrl69SlBQEL169cLe3p4jR47w+uuv89133/Hzzz/j6elprrcNwIgRI3B0dKRVq1b079+foqIiYmNjWb58OevWreOnn36iR48epeV1Oh2PPvooe/bswcPDg969e+Pl5UVqaioXL15kwYIFjB49Gm9v7wr7zc7OZsSIEfzwww8MHDiQDRs24OHhUWm85jgOPvroIz788EM6d+7M4MGDiYuLY//+/ezfv5+PPvqIWbNmmdTexYsX6dixIw4ODvTs2RNFUfD19S3db+pnbAlxcXF88sknADz22GMW7UuIukDOOXLOATnnGGv58uWkpaVRVFREcHAwffv2pU+fPlVrzGwDBGpAVlaWEhISogCKSqVS+vXrp7z99tvK9u3blZs3b1ZYt2/fvgqg7Nu3T297ybgYQPnHP/6hFBUVle47deqU4urqqgDKb7/9pldv0aJFCqAEBQUp586dK91eVFSkzJ49u7TNP4+3KW/8T25urtK4cWMFUF577TUlPz+/dF9OTo4yatQoBVAmTZpkxCdVVkXjf9auXatkZ2frbdPpdMrixYsVQGndurWi0+lK9+3fv18BlI4dOyqZmZll2jt69Khy69YtvW38afzPtWvXlA4dOpS+p4KCAqPfS3WOg5KxMSqVSvn666/LfA4qlUqxs7NTTp06pbev5PNbvny53vaSMTqAMnbsWCUvL89gv6Z+xve3ber4nxKLFi1SJkyYoIwaNUrp1auXotFoFLVabdZxUULUZXLOkXOOosg5pzIl79HQq0uXLsrFixdNak9RFMWmklNFUZRz584p0dHRBj+EDh06KJ9++qneL3uJyv5QREVFlflBKYqiPPPMMwqgvPXWW3rbGzVqpADKZ599VqZOfn5+6YFs7B+KTz/9VAGUwYMHG3zfWVlZir+/v2JnZ6ekpaUZLFORqg5O7969uwIop0+fLt22bt06BVCee+45o9u5/w/FH3/8oYSGhhr8XI1V1eOg5JdoyJAhBtsdNmyYAijTpk3T217ZHwpvb+8qD1w39Bnf33ZVk9PHH39c73Oxt7dX3nnnHSU3N7dK7QlRH8k5R845iiLnnIo8++yzyjfffKNcunRJuXv3rnLlyhVl5cqVSnh4uAIoISEhSkpKiklt2tRtfYDmzZtz6NAhjhw5wvbt2zl8+DDHjx8nNTWVEydOMH36dL777ju2b9+Og4OD0e0OHjzY4JxoLVu2BOD69eul265du8bly5cBGD16dJk6Dg4OPPnkkyxatMjo/rdv3w7AU089ZXC/m5sbnTt3ZseOHRw9epQHH3zQ6LaNcenSJXbu3MmlS5fIyspCq9UC98banD9/nlatWgHQqVMnNBoNX375Jc2aNeOJJ54weuD2jz/+yPDhw8nPz2fVqlWMHTu2SvFW9zgwNPVJyfaSW1mmGDBgQKW3vkz5jM1h06ZNAOTm5hIXF8dnn33Ga6+9xrfffsuOHTsIDg42W19C1FVyzpFzDsg5pyKLFy/W+39kZCSRkZE8+uijREVFER8fzzvvvMPChQuNbtPmktMSXbt2pWvXrgAoisLvv//OggULWLt2Lbt372bRokW8+OKLRrdX3pOVJeNR8vLySrddu3YNAF9fX4NzekHxD8cUJX94xo0bx7hx4yosm5qaChTPI/fFF1+U2T9kyBCGDBliVL9arZaZM2fy2WefVTg5e2ZmZum/GzduzIcffsiLL77IzJkzmTlzJhEREXTv3p3BgwczfPjwcv9IDx48mKKiIr7++mvGjBljVIwVqepx0LBhQ4PtlWwv+Rkbq6Kfd1U+Y3MqecDh448/JiIigpdeeonnnnuODRs2WKQ/IeoiOefIOQfknGMKb29vnn/+eZ5//nm2bt1aP5LT+6lUKjp16sSaNWvIzc1ly5YtbNq0yaQ/FGq16RMXVLT6hKkrU+h0OgAGDRpEQEBAhWUjIiKA4m9FK1asKLM/MjLS6D8UixYtYsmSJQQGBvLBBx/Qo0cPAgICcHJyAoq/pa9Zs6bMAT5r1ixGjBjBli1bOHDgAAcOHGDt2rWsXbuWefPm8euvvxr8ZjthwgSWLVvG66+/To8ePcr9ha0KcxwHJSr6hTbE2dm53H1V/YwtYdKkSbz00kts3boVrVYrE/ELUQVyztEn5xw555Sn5E6Aqcl3nUhO7/fggw+yZcsWbt26ZbE+QkJCgOJvkzk5Obi6upYpEx8fb1KbYWFhnDt3jilTpvDkk08aVWfixIkmTxvyZ+vWrQPgs88+M/gE98WLF8utGxAQwLRp05g2bRoA586dY/LkyRw8eJBXXnnF4B+xpUuX4ubmxqJFi+jduze7d++mRYsW1XoPhlR2HFy5coX27duX2V7ycwsNDTVbLNX5jM2t5FgtKCggIyMDHx+fGutbiLpIzjmmkXOOvrp+zrl9+zYA7u7uJtWzqXlOjcnyExMTAfP+oP8sLCys9JL6mjVryuwvKCgweY3dhx9+GLh3UNWUkrnhSr4Z3+/06dOcOHHC6LZatGjByy+/DFBuPZVKxcKFC3nttde4fv06ffr0MakPMM9xsGrVKoPbV65cCWDWdajN+RlX1549ewDw8fGpdNoVIeo7OeeYn5xz9NX1c87atWsBSodCGMumktNPPvmECRMm8Ntvv5XZpygKGzdu5OOPPwZg5MiRFo3lueeeA2DevHlcuHChdLtOp2Pu3LlGTex7v6effpqIiAjWr1/Pyy+/TFZWVpkyycnJLF26tHqB/0nJJffFixeX3uYBuHHjBuPHj6eoqKhMnb1797Jjxw4KCwv1tiuKwrZt2wDDvxT3e/vtt3nvvfdITU3lL3/5CwcPHjQ6ZnMcB99//33pL02JDRs28N1332FnZ2fynHMVqcpnXFXbtm3j559/NvjHdO/evUyfPh2AadOmmXwbUIj6Rs45cs4BOedUZPPmzcTExJTZnpWVxfPPP8+WLVsAmDNnjknt2tRt/cLCQlauXMnKlSvx8/OjY8eO+Pr6kpGRwZkzZ0ovj48dO5YpU6ZYNJbnnnuOXbt28cMPP9CuXTv+8pe/4OXlxdGjR0lKSuLZZ5/lk08+MfrpTVdXV7Zv387gwYN57733+Pzzz2nXrh2hoaHk5uZy4cIFzp49i7+/f+ktDXN49dVX2blzJ0uXLmXfvn106tSJzMxM9u/fT6NGjRg6dGiZyaBPnjzJCy+8gIeHB506dSI4OJi7d+9y/PhxEhIS8PT05K233qq07xdffBF3d3eeffZZBg4cyJYtW+jfv3+l9cxxHMyePZtRo0bxwQcf0LRpU+Li4jh8+DAA77//Pu3atas0DmNV5TOuqmPHjvHmm2+Wfi5+fn5kZGRw8eLF0hPa0KFDmT9/vln6E6Iuk3OOnHNAzjkV2bdvH4sWLSI8PJy2bdvi5eVFUlISJ06cID09HTs7O95//30GDBhgUrs2deV0ypQpbNq0iVmzZtGwYUPOnDnD+vXr2bdvHxqNhlGjRvHDDz+watWqKg02N4VGo2Hz5s289957NG7cmH379rF7927atWvHkSNHCAwMBNBbsaEyrVu35uTJk7z33nu0bNmSkydPsn79eg4fPoyrqyt///vfzXZAlYiOjubYsWM89thj5OTksGXLFuLi4pg1axYHDx40uHrGX//6V+bPn0+XLl24fPkyGzduLF1F5JVXXiE2NpYOHToY1f8zzzzDqlWryM/P59FHHy39FlwRcxwHs2fPZt26ddjZ2bFlyxZiY2Pp3bs3W7du5YUXXjAqdmNV5TOuqmHDhvHSSy/RtGlTTp8+zYYNG9izZw+FhYWMGDGCrVu3snHjRlm+VAgjyDlHzjkg55yKDBkyhClTpuDj48OxY8dYt25d6fH4zDPPcPz4cWbPnm1yuyqlJh7Xqof69+/Pvn37+O6773jiiSdqOxzxX5GRkSQkJHDlyhWTp14RQghrJecc6yTnnKqxqSun1ubEiRMUFBTobSsoKGD+/Pns27cPf39/HnnkkVqKTgghRF0i5xxRX9jUmFNr8/zzz3PixAnat29PUFAQ6enpnDp1ihs3buDk5MSKFStK5xUTQgghqkPOOaK+kCun1TBt2jR69OhBXFwcmzdvZv/+/Tg5OTF58mRiYmIYNGhQbYcohBCijpBzjqgvZMypEEIIIYSwGnLlVAghhBBCWA1JToUQQgghhNWQ5FQIIYQQQlgNSU6FEEIIIYTVkORUCCGEEEJYDUlOhRBCCCGE1ZDkVAghhBBCWA1JToUQQgghhNWQ5FQIIYQQQliN/w/0RkpRDsVIzQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"Multi-Task\"][\"accuracy\"], results[\"Multi-Task\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1], [results[\"Multi-Task\"][\"accuracy\"].mean(), results[\"Multi-Task\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"Multi-Task\"][\"accuracy\"].std(), results[\"Multi-Task\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Multi-Task Spiral 3\", \"Multi-Task Spiral 5\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Multi-Task Learning Accuracy (Spiral 3 & Spiral 5)\", fontsize=16)\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "fHTqKiy_RjYM", + "outputId": "f6bc15db-aff1-4761-978f-95ece3449f34" + }, + "execution_count": 79, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "spiral3_mean = np.mean(results[\"Spiral 3\"][\"accuracy\"])\n", + "spiral3_std = np.std(results[\"Spiral 3\"][\"accuracy\"])\n", + "spiral5_mean = np.mean(results[\"Spiral 5\"][\"accuracy\"])\n", + "spiral5_std = np.std(results[\"Spiral 5\"][\"accuracy\"])\n", + "\n", + "multi_task_spiral3_mean = np.mean(multi_task_spiral3_accuracies)\n", + "multi_task_spiral3_std = np.std(multi_task_spiral3_accuracies)\n", + "multi_task_spiral5_mean = np.mean(multi_task_spiral5_accuracies)\n", + "multi_task_spiral5_std = np.std(multi_task_spiral5_accuracies)\n", + "\n", + "spiral3_time_mean = np.mean(results[\"Spiral 3\"][\"time\"])\n", + "spiral3_time_std = np.std(results[\"Spiral 3\"][\"time\"])\n", + "spiral5_time_mean = np.mean(results[\"Spiral 5\"][\"time\"])\n", + "spiral5_time_std = np.std(results[\"Spiral 5\"][\"time\"])\n", + "multi_task_time_mean = np.mean(results[\"Multi-Task\"][\"time\"])\n", + "multi_task_time_std = np.std(results[\"Multi-Task\"][\"time\"])\n", + "\n", + "\n", + "print(f\"Spiral 3 Accuracy: {spiral3_mean:.4f} ± {spiral3_std:.4f}\")\n", + "print(f\"Spiral 3 Training Time: {spiral3_time_mean:.2f} sec ± {spiral3_time_std:.2f} sec\")\n", + "\n", + "print(f\"Spiral 5 Accuracy: {spiral5_mean:.4f} ± {spiral5_std:.4f}\")\n", + "print(f\"Spiral 5 Training Time: {spiral5_time_mean:.2f} sec ± {spiral5_time_std:.2f} sec\")\n", + "\n", + "print(f\"Multi-Task Spiral 3 Accuracy: {multi_task_spiral3_mean:.4f} ± {multi_task_spiral3_std:.4f}\")\n", + "print(f\"Multi-Task Spiral 5 Accuracy: {multi_task_spiral5_mean:.4f} ± {multi_task_spiral5_std:.4f}\")\n", + "\n", + "print(f\"Total Multi-Task Training Time: {multi_task_time_mean:.2f} sec ± {multi_task_time_std:.2f} sec\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z5LiMz2ESvOF", + "outputId": "f26ff263-9188-4060-8aea-46609b0dfca8" + }, + "execution_count": 80, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Spiral 3 Accuracy: 0.7242 ± 0.0403\n", + "Spiral 3 Training Time: 0.28 sec ± 0.07 sec\n", + "Spiral 5 Accuracy: 0.7637 ± 0.0360\n", + "Spiral 5 Training Time: 0.29 sec ± 0.07 sec\n", + "Multi-Task Spiral 3 Accuracy: 0.6557 ± 0.0517\n", + "Multi-Task Spiral 5 Accuracy: 0.6513 ± 0.0562\n", + "Total Multi-Task Training Time: 0.27 sec ± 0.07 sec\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Sporf_XOR_Spiral_hyperparamter tuning.ipynb b/Sporf_XOR_Spiral_hyperparamter tuning.ipynb new file mode 100644 index 0000000..c7ab265 --- /dev/null +++ b/Sporf_XOR_Spiral_hyperparamter tuning.ipynb @@ -0,0 +1,11760 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "!pip install proglearn\n", + "!pip install git+https://github.com/neurodata/treeple.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "mJnM5z33iZJg", + "outputId": "c70e2bd2-de9d-41e6-9550-fb659f0da578" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting proglearn\n", + " Downloading proglearn-0.0.7-py3-none-any.whl.metadata (3.1 kB)\n", + "Requirement already satisfied: tensorflow>=1.19.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (2.18.0)\n", + "Requirement already satisfied: scikit-learn>=0.22.0 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.6.1)\n", + "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.14.1)\n", + "Requirement already satisfied: joblib>=0.14.1 in /usr/local/lib/python3.11/dist-packages (from proglearn) (1.4.2)\n", + "Requirement already satisfied: numpy>=1.19.2 in /usr/local/lib/python3.11/dist-packages (from proglearn) (2.0.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=0.22.0->proglearn) (3.6.0)\n", + "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.4.0)\n", + "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.6.3)\n", + "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (25.2.10)\n", + "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.6.0)\n", + "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.2.0)\n", + "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (18.1.1)\n", + "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.4.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (24.2)\n", + "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (5.29.4)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.32.3)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (75.1.0)\n", + "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.0)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.5.0)\n", + "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (4.12.2)\n", + "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.17.2)\n", + "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (1.71.0)\n", + "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.8.0)\n", + "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (3.13.0)\n", + "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.4.1)\n", + "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow>=1.19.0->proglearn) (0.37.1)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow>=1.19.0->proglearn) (0.45.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (13.9.4)\n", + "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.0.8)\n", + "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.14.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow>=1.19.0->proglearn) (2025.1.31)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.7)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow>=1.19.0->proglearn) (3.0.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (2.18.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow>=1.19.0->proglearn) (0.1.2)\n", + "Downloading proglearn-0.0.7-py3-none-any.whl (27 kB)\n", + "Installing collected packages: proglearn\n", + "Successfully installed proglearn-0.0.7\n", + "Collecting git+https://github.com/neurodata/treeple.git\n", + " Cloning https://github.com/neurodata/treeple.git to /tmp/pip-req-build-g0tfiuzn\n", + " Running command git clone --filter=blob:none --quiet https://github.com/neurodata/treeple.git /tmp/pip-req-build-g0tfiuzn\n", + " Resolved https://github.com/neurodata/treeple.git to commit 75c2cf919939574e4240fe261f053162039495cf\n", + " Running command git submodule update --init --recursive -q\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.25.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.5.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.14.1)\n", + "Requirement already satisfied: scikit-learn>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from treeple==0.10.3) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.6.0->treeple==0.10.3) (3.6.0)\n", + "Building wheels for collected packages: treeple\n", + " Building wheel for treeple (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for treeple: filename=treeple-0.10.3-cp311-cp311-linux_x86_64.whl size=2924554 sha256=5c87cfc384972afe51cf400461c2af0adee8b103c393a827b1fb892612d86848\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-h6_qudr8/wheels/87/bd/56/9c9982c5af1eb667f0421e0000d3ed4b973b71c8e8903fa6cd\n", + "Successfully built treeple\n", + "Installing collected packages: treeple\n", + "Successfully installed treeple-0.10.3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from treeple import ObliqueRandomForestClassifier\n", + "from proglearn.sims import generate_gaussian_parity\n", + "from sklearn.metrics import accuracy_score\n", + "from proglearn.sims import generate_spirals\n", + "from sklearn.preprocessing import StandardScaler\n", + "from tensorflow.keras.datasets import mnist, fashion_mnist" + ], + "metadata": { + "id": "4NRBnZnUjtAb" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split" + ], + "metadata": { + "id": "oBccNjzZNgpZ" + }, + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_xor, y_xor = generate_gaussian_parity(1000)\n", + "X_rxor, y_rxor = generate_gaussian_parity(1000, angle_params=np.pi / 4)\n", + "\n", + "X_train_xor, X_test_xor, y_train_xor, y_test_xor = train_test_split(X_xor, y_xor, test_size=0.2,random_state=42)\n", + "X_train_rxor, X_test_rxor, y_train_rxor, y_test_rxor = train_test_split(X_rxor, y_rxor, test_size=0.2,random_state=42)\n", + "\n", + "task_train_xor = np.zeros(len(y_train_xor), dtype=int)\n", + "task_train_rxor = np.ones(len(y_train_rxor), dtype=int)\n", + "task_test_xor = np.zeros(len(y_test_xor), dtype=int)\n", + "task_test_rxor = np.ones(len(y_test_rxor), dtype=int)\n", + "\n", + "X_train_multi = np.column_stack((np.vstack([X_train_xor, X_train_rxor]), np.hstack([task_train_xor, task_train_rxor])))\n", + "y_train_multi = np.hstack([y_train_xor, y_train_rxor])\n", + "\n", + "X_test_multi_xor = np.column_stack((X_test_xor, np.zeros(len(y_test_xor), dtype=int)))\n", + "X_test_multi_rxor = np.column_stack((X_test_rxor, np.ones(len(y_test_rxor), dtype=int)))\n" + ], + "metadata": { + "id": "XM24wO3LkBv4" + }, + "execution_count": 29, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "num_trials = 10\n", + "xor_accuracies = []\n", + "rxor_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " start_time = time.time()\n", + " sporf_mtl = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_mtl.fit(X_train_multi, y_train_multi)\n", + " training_time = time.time() - start_time\n", + " y_pred_xor = sporf_mtl.predict(X_test_multi_xor)\n", + " y_pred_rxor = sporf_mtl.predict(X_test_multi_rxor)\n", + "\n", + " xor_accuracies.append(accuracy_score(y_test_xor, y_pred_xor))\n", + " rxor_accuracies.append(accuracy_score(y_test_rxor, y_pred_rxor))\n" + ], + "metadata": { + "id": "7Rcb-umUlm5v" + }, + "execution_count": 30, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "xor_accuracies = np.array(xor_accuracies)\n", + "rxor_accuracies = np.array(rxor_accuracies)\n", + "single_task_xor_accuracies = []\n", + "single_task_rxor_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " start_time = time.time()\n", + " sporf_xor = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_xor.fit(X_train_xor, y_train_xor)\n", + " y_pred_xor = sporf_xor.predict(X_test_xor)\n", + " single_task_xor_accuracies.append(accuracy_score(y_test_xor, y_pred_xor))\n", + "\n", + " start_time = time.time()\n", + " sporf_rxor = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf_rxor.fit(X_train_rxor, y_train_rxor)\n", + " y_pred_rxor = sporf_rxor.predict(X_test_rxor)\n", + " single_task_rxor_accuracies.append(accuracy_score(y_test_rxor, y_pred_rxor))\n", + "\n", + "single_task_xor_accuracies = np.array(single_task_xor_accuracies)\n", + "single_task_rxor_accuracies = np.array(single_task_rxor_accuracies)\n" + ], + "metadata": { + "id": "mWHtxhNONcw1" + }, + "execution_count": 31, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[single_task_xor_accuracies, single_task_rxor_accuracies],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [single_task_xor_accuracies.mean(), single_task_rxor_accuracies.mean()],\n", + " yerr=[single_task_xor_accuracies.std(), single_task_rxor_accuracies.std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Single-Task XOR\", \"Single-Task RXOR\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Single-Task Learning Accuracy (XOR & RXOR)\", fontsize=16)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "O2z_yngNNfSa", + "outputId": "8a5dac37-0e58-4825-e1ce-2213cce2a461" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApwAAAHLCAYAAABlKEh3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAd1xJREFUeJzt3XlcFPX/B/DXsrAsh4AJcouCB954IN4nAfo179s8sDTNI8U0LU3Nfpqa5p1m3pbmlVmZfpOMxDuV1BRTUfHAWwG5YT+/P/juxLq7sKyMgL6ejwePcuYzM+9Zlp3XznzmMwohhAARERERkUwsirsAIiIiInq5MXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXCWMpcuXcKoUaNQo0YN2NnZQa1Ww8vLC4GBgRg1ahR27Niht0zr1q2hUCjw+++/v/iC8/j999+hUCjQunVrWda/bt06KBSKQv+sW7dOlnq0tNspKhUrVnwhdZc0gwcPLnX7nZmZCRcXFygUCri5uSE7O7u4S6J8LFq0CAqFQudzNC0tDf7+/lAoFJg1a5bRZWNjY2FjYwMLCwtERUXpzT969CjefvttVKlSBfb29rCzs0PlypXx1ltv4fDhw0bXe+3aNYOfW7a2tqhSpQreeustnD179rn2W6PRYNGiRahTpw7UajXKli2LOnXqYOzYsfj777/NXq/2M//ZH3t7e9SsWRNjxozBtWvXDC7722+/wcLCAnZ2drh8+bLRbcyYMQMKhQI1a9ZERkaGzrysrCysWrUK7du3h7u7O1QqFcqVK4egoCDMmDEDDx48MLre6dOn69WtVCpRtmxZNG7cGLNmzcLTp08NLhsdHQ2FQoGJEycW/CK9SgSVGjt27BDW1tYCgChXrpx4/fXXRb9+/UT79u2Fu7u7NP1ZrVq1EgDEgQMHXnzReRw4cEAAEK1atZJl/QcPHhSDBg3S+/Hz8xMAhJ+fn8H5Bw8elKUeLQCiKP/UfHx8BACxdu3aIltnaTBo0KBSt99bt26Vfv8AxK5du4q7JDLi3r17wsnJSQQGBurNO3r0qFAqlUKlUokzZ87ozc/OzhaNGjUSAMTYsWN15mVkZIghQ4ZI7wE/Pz/RrVs30b17d1GlShVpenh4uMjIyNBb99WrV6U23bt3lz63QkJChJOTkwAgLC0txY4dO8ze9zfffFMAECqVSoSGhopevXqJypUrCwBi2rRpZq9X+5kPQKp74MCBom3btsLW1lYAEPb29uLw4cMGlx85cqQAIJo1ayZycnL05p88eVJYWloKS0tL8eeff+rMO3/+vPT6KpVK0axZM9G3b18RFhYmypQpIwAIBwcHo6/btGnTBADh6uoq1d6vXz/RuHFjoVAoBABRrVo1ce/ePYPL/+c//xEqlUr8888/hXzVXl4MnKXEnTt3hL29vQAgxo8fL9LS0vTa/Pnnn2LSpEl6069fvy4uXLggUlJSXkSpRskdOI3RBpVBgwa90O1qMXAWjdu3b4sLFy6IJ0+eFHcpJgsNDRUAhKenpwAg3njjjeIuiYzQhpuff/7Z4PxJkyYJACIgIEBkZmbqzJs5c6YUQFJTU3Xmde3aVToZ8OOPP+qtd8+ePcLFxUUAEN26ddObnzdwXr16VWfegwcPRNOmTQUA4ezsrLdtUxw+fFgKX2fPntWZd+TIEfHTTz8Vep1aeQPns+Lj46VAWKNGDYPLP336VDphMHfuXJ156enpombNmgKA+Pjjj3XmxcXFiddee00AEMHBweL69es681NTU8X7778vAAgLCwvx/fff621bGzgNHa+ioqKESqUSAMS7775rsPY///xTABBdu3Y1OP9VxMBZSnz99dcCgPDw8CjuUszGwFk0XtXAWdrEx8cLCwsLoVQqxaFDh4RCoRBKpVLcvn27uEujZzx+/FjY2dkJT09Pg2fShMg9U1mrVi0BQEydOlWaHhMTI6ysrIRSqRTHjh3TWearr74SAISVlZU4ceKE0e2fOnVKWFlZCQDi66+/1pmXX+AUQohDhw5J8yMjIwux17nmzZsnAIgePXoUetmC5Bc4hRDim2++keZfuXLFYJuDBw8KCwsLYW1tLf7++29p+oQJEwQAUb9+fb0vAM2aNRMAROPGjUV6errR+rSh09HRUTx48EBnXn6BUwghhg4dKgAIb29vo+uvW7eusLCwMPh7exWxD2cpcffuXQCAi4tLoZc11oczb5+4q1evYsCAAXBzc4O1tTX8/PwwZcoUvT4xWtnZ2Zg/fz5q1aoFtVqN8uXLo2fPnjh//rzUl3Lw4MGFqvPx48eYNm0aAgICUKZMGdja2qJ27dr49NNPkZqaWuj9NsXOnTvx9ttvo1atWihbtizUajUqVaqEIUOG4OLFiwaXycjIwLx589CgQQOUKVMGKpUKbm5uCAwMxMSJE/Ho0SOTtp2Tk4MRI0ZAoVCgdu3auHHjRlHumo60tDTMnz8fjRs3hpOTE9RqNapVq4aJEyfi4cOHeu2zsrKwadMm9O/fH/7+/nBwcICNjQ2qVauGMWPG4Pbt2wa3k/e9dvDgQbzxxhtwcXGBhYWF1PdS2wf12rVrOHDgAEJCQlC2bFnY2Nigfv362LBhg8F1G+vDqe1rNX36dNy/fx8jR46Et7c3VCoVvL29MXr0aDx58sTgOoUQWLNmDRo2bAhbW1uUK1cO7du3x+HDh5+7z/GaNWug0WjQvn17NG3aFG3btkVOTg7Wr1+f73K3bt3ChAkTULt2bZQpUwZ2dnaoWrUqBg8ebLCvX2pqKhYuXIjmzZujbNmysLa2ho+PD9544w18++23Om3zvvaGGHuN804/d+4cevfuDXd3dyiVSkyfPh2A+e8ZIPf3sHPnTnTs2BFubm7S31Tz5s0xZ84cpKWlAQAGDRoEhUKB2bNnG13X1q1boVAo0KhRI6NtnrV27VqkpKRgwIABsLAwfFhUqVTYsGEDrKysMHv2bJw8eRKZmZkYOHAgsrKy8MEHH+hsUwgh1Tl8+HA0bNjQ6Pbr1auHESNGAABmzZoFIYTJtdepU0f6f+1xojAsLS0BAFevXi30ss/LlNqbN2+OcePGISMjA4MGDUJ2djYOHz6M+fPnQ6VSYf369bCyspLaR0VF4dChQwCApUuXwtra2uj2Z86cifLlyyMxMRFLly41q/b8XvPBgwdDo9Hgyy+/LNS6X1rFm3fJVBs3bpT6ouzfv79Qyxrrw6k98/fee+8JBwcH4ePjI3r16iWCg4OFjY2NACC6dOmit76cnBzRsWNHqc9PSEiI6N27t/D19RW2trZi1KhRBs8o5neG8++//xbe3t4CgHB3dxdhYWHijTfeEK6urtJlLHMvpeZ3hlOpVApbW1vRsGFD0a1bN9GpUyfh6+srAAg7Oztx6NAhvX1v166ddAmqffv2om/fviI4OFg683j69GmdZWDgG35ycrJo3769ACBef/11kZiYaPL+FPYM561bt0Tt2rUFAPHaa6+J4OBg0bVrV2k9FStWFNeuXdNZ5saNG9I3/8aNG4uePXuKDh06CA8PDwFAuLi4iEuXLultS/tee/fdd4WFhYWoUaOG6NOnjwgJCRHffvutTv1Tp04VCoVCNGjQQPTp00c0btxYeq2++OILvXUb68OpPRMxZMgQ4eXlJVxdXUW3bt1Ehw4dhKOjowAgAgMD9c6CCCHEiBEjpMtqrVq1En369BE1a9YUSqVSjB8/3uwz8hqNRtrPnTt3CiH+PZtTtWpVo8vt379f6pdXvnx50blzZ9GzZ08RGBgorKys9N7D8fHxokaNGgKAsLW1Fa+//rro06ePaNGihXB0dBQ+Pj467bU1GTvjYuw11k4fOnSosLa2FhUrVhS9evUSb7zxhvj888+FEOa/ZzIzM0W3bt2k30Pjxo1F3759xeuvvy51RdDWe/LkSQFAVKhQQWRnZxvch5YtWwoAYv369UZfZ2PLmPLZOn36dOkysPY9UqdOHb3+lzExMdL7Ob+zm1raS7AAdPqJFnSG89atW891hjM2NlZYWFgIAGL+/PmFXj4/BZ3hzHt21tgZTiGESEtLE9WrVxcAxKRJk6RL8bNnz9ZrO3bsWAFA1KxZ06Qatcer+vXr60wv6Azn//3f/xV4hvPcuXMF/s2/Shg4S4nk5GTpw1ehUIjWrVuLmTNnip9//tlop2WtggInAPHRRx/pfICfPXtW2NnZCQB6HboXLVokBcPY2FhpenZ2tnjvvfekdZoaOFNTU6V+OlOmTNH54E5JSRF9+/YVQG6nenPkFzi3bNkinj59qjNNo9GIZcuWSR9aGo1GmhcVFSUAiHr16omkpCS99Z04cULv0syzH7g3b94UAQEB0j4ZCkL5KUzg1Gg00uWlt956S6fmrKws6YDZpk0bneWSkpLEDz/8oHcQzczMFJMnTxYARIcOHfS2p32vARDLli3Lt34rKyu9Pm1r166VQsuz/dEKCpwAxODBg3UuocXHx0t/N9rAq/XDDz8IIPemhWe/WMyfP19apzmB87///a8UGrW/37S0NClM/vHHH3rLxMfHSwF50qRJeq/93bt3dW5wy8nJEQ0bNhQAREhIiN7nQFpaml5/xOcNnNraDF12Nvc9ExERIX3xiYmJ0Zmn0WjE/v37db5sat/P2iCf19mzZ6Vwm9+l1LxSU1OFSqUSFhYWBv+mn5WVlSXq168vvR5WVlZ6dQshxOrVq6Uv5VlZWSatV9svcM2aNdL0ggKn9rK9i4uLWX04hRCiX79+0rGlMEG9IAUFzg8//FAAELVr19b5nDXk+PHjQqlUSutr0qSJwS8dLVq0KNTxYv369dKXnby/p4ICp7bv7MiRI42uW6PRSH/zN27cMKmelxkDZykSGxsrgoKCpD+4vD8BAQHiyy+/NPgHWFDgbNCggcE/9uHDhwsA4pNPPtGZrj0DuHLlSr1lMjIypAO8qYHzyy+/FABEx44dDe53cnKyKF++vLC0tBSPHj0y2CY/5vbhbNKkiQCg029Ie9fxmDFjTF5P3g/cv/76S3h5eRl8XU1VmMD5yy+/SO8PQwe9nJwcqV/aszcM5MfDw8PgAVr7Xmvbtm2B9UdERBic7+/vbzCUFRQ4vby8DN4Y99lnn0lnQPNq27atACAmT55ssI7AwECzA2fv3r0FkHuDX17vvvuu0fei9syMqTcW7dq1S/ril5ycbNIyzxs4q1atavTMYkEMvWfu3r0rhaxn7zI2Rvs32K5dO71577zzTr6/U0NOnDghnTU11ZYtW6S/a2PvY+37zs3NzeT1urm5CQBizpw50jRjgTMhIUF8/fXXwtHRUajVarNv7lm2bJmwsrISbdq0EUqlUlhYWIhNmzaZta5nGQqcGo1GxMfHi3nz5gmVSiXKli0rjh8/btL6wsLCDJ4Fzkv7+WHoBlpD9u7dK63z7t270nRDgTMzM1NcuHBBDB48WPpcffYEw7O0x5EffvjBpHpeZrmdN6hUqFatGo4ePYrjx4/j559/xrFjx3Dq1Cncv38fMTExGDFiBHbs2IGff/4ZKpXK5PV27NjR4DiR1atXB5Dbp0zr5s2biIuLAwD069dPbxmVSoUePXpg0aJFJm//559/BgD07t3b4Hx7e3s0bNgQe/bswYkTJxASEmLyuk1x+fJl7N27F5cvX0ZycjJycnIA/Ns35+LFi6hRowYAoH79+lAqlVizZg2qVq2Kbt26wd3d3aTt7Nu3Dz179kRGRgY2btyIN998s0j3wxDta9u9e3epr1ZeFhYWaNmyJc6dO4fDhw+jVq1aOvP/+usvREZG4urVq0hJSYFGowGQ24dXo9Hg8uXLqFevnt56e/ToUWBtb7zxhsHp1atXR2xsrM77zhTt2rWDra2twfUBuu9jbT8wAOjfv7/B9fXr1w8nTpwoVA0A8PDhQ+zatQsAMGTIEJ15Q4YMwfLly7Ft2zYsWbIEZcqUkebt3bsXADBs2DCTtqNt369fP9jb2xe6TnN06dIFSqUy3zaFec8cOHAAmZmZaNCgARo0aGBSDV27doW3tzciIyMRGxsLf39/AEBiYiI2bdoEpVIp9Yc0hfbvvFy5cia1T0tLw7Rp06R/7969GzNnzjT43issUUDfzUqVKulNc3Z2xsGDB1G7du1Cb2/Dhg0YOXIkunfvjm3btmHLli0YMGAABg0aBKVSiT59+ujUZm1tDY1Gg6SkpELvr6FjjJ+fH37//Xd4eXkVuHxkZCT27dsn/Xvz5s1m7fOzCnrNo6KiDNb+xhtvYPv27QUea7XvK3P6175sGDhLoUaNGkmd04UQOH36NObNm4ctW7Zg//79WLRoESZMmGDy+ipUqGBwuoODAwAgPT1dmnbz5k0AuR9yxg5yFStWNHnbAKQAO2DAAAwYMCDftvfv3weQO7Du119/rTe/S5cu6NKli0nbzcnJwahRo7By5cp8P3SSkpKk//fz88MXX3yBCRMmYNSoURg1ahR8fHzQpEkTdOzYET179jT6AdSxY0dkZ2dLN1a8CNrXdurUqZg6dWq+bbWvLQDpBorvv/8+32XyvjZ5mfIeKMz7zhSFWd+DBw+kfxurtbDvY61NmzYhIyMDQUFB0hcVrQYNGqBOnTo4c+YMtmzZgqFDh0rzrl+/DgBSgCpIYdsXhfxeE3PeM+bsg6WlJd59911MnjwZS5culW72WL9+PVJSUqRAaqrExEQA/75PCjJ58mRcvHgRTZo0gRACR48exaRJk7B48WKdds7OzgCAR48eITs72+AXvryys7OlGw6N3RzavXt32NvbIycnBzdu3EB0dDQePHiAXr164dChQ3jttddM2gcg9/c1btw4qFQqLF++HAqFAn379oVSqUT//v3x5ptvwsLCAr169QKQ+8U7KysLjRs3NitcDxo0CEDuzWVXrlzBsWPHcOXKFfTr1w/79+/PN7glJSVhyJAhEEJIn9lz585F165dERgYqNNW+7qbGvDu3bsHIPfLt6HXz9XVFWFhYQByb9D766+/8M8//+DHH3/E1KlTMWfOnHzXr31fPX782KR6XmYMnKWcQqFA/fr1sXnzZqSmpmL37t3YtWtXoQKnsbsyC9quOfMM0Z4BCQsLg6ura75tfXx8AOSelTR0t2/FihVNDpyLFi3CihUr4ObmhgULFqBp06ZwdXWFWq0GkHvmaPPmzXphdPTo0ejVqxd2796N6OhoREdHY8uWLdiyZQumTZuGgwcPGjzrOWjQIKxevRpTp05F06ZNDZ6tKGra17Z58+bw8/PLt23NmjWl/588eTK+//57+Pv747PPPkNgYCCcnZ2lg0LTpk1x5MgRo0HdxsamwNrMed+9yPWZ+3So1atXA8j9cta8eXO9+dpgv3r1ap3AWRJo3y/G5Pd7fd73TGEMHToUn3zyCTZs2IDZs2fD3t4ey5cvBwCMGjWqUOtycnICYPzLU15RUVFYvHgxbGxssG7dOmg0GtSrVw9Lly5F9+7d0apVK6mt9oxtZmYmTp8+rReMnhUTE4OsrCydZZ/1+eef64T+2NhYtGvXDrGxsRg+fDi2bt1a4D5oHTp0CI8ePUKjRo1Qvnx5aXqvXr2gVCrRt29f9O/fH0qlEt27d8fGjRsBAG+99ZbJ28jr2ZEPDh06hPbt2+PgwYOYMmUK5s6da3TZcePGIT4+Hu3atcPixYvh7OyM6dOnY/DgwTh16pTOnegNGjRAdHQ0jh07ZlJdx48fBwDUrVvX4JcCf39/vdqXLFmCMWPGYO7cuWjVqhU6dOhgdP3aLzRly5Y1qZ6XWnFdy6eit3TpUqmfVV4F9eE01hdQewNH3v5m8fHxUn+XZ2+20dL2RTO1D+frr78uAIht27aZspuFZqwPp7Y/rLG+NdobMkzpK3nhwgWpr87AgQN15mlfL41GI91U5enpKS5cuGDW/hSmD6d2rLh58+YVahva0QH++usvg/OdnZ0NvqdMearV8/YjNNaH09gTUQy97zIzM6WnduXto5vXwoULC92H8/jx4wb7WBv7OXfunLRstWrVBACDg4Mbou2v+Gw/0fxo7+411v9Ne7e2qa99Xua8ZzZv3iz1Iy+st99+WwAQS5culW7SMjaAeH5M7cOZnJwsKlWqJADdURS041j6+vrqfCZqNBpRsWJFAUCMGjWqwDpGjx4tgNybp/L2qS/opqH9+/dL8w3djGbMd999JwD9u7O1vv/+e2FlZSUsLS3FwoULhZ2dnahevbpJN0BpFXTTkHZ8aZVKZfQu9Z9++kkAuaOCaAdwz8zMFPXq1RMAxAcffKDT/rfffpO2WVC/4LS0NGnQ/Wc/Pwq6aUj7dKZq1arl+5poR99gH06Ow1lqCBPOCsTHxwOASf1hzOXt7S19w968ebPe/MzMTIPPc89P+/btAaBQ386LgvbylfasaV5///03YmJiTF6Xv78/PvjgAwAwupxCocDChQsxZcoU3Lp1Cy1btizUNsyhfW23bdtWqDNL+b02+/bty/cZxKWBlZUVmjRpAgB6Y1VqGXp/F0TbzaN3794QuTdlGvzRXqbUng0FIF22W7VqlUnb0rbfvHkzUlJSTFrG09MTAHDhwgW9eXfu3MGpU6dMWo8h5rxn2rZtC5VKhZMnTxZ622PGjAEALFu2TLqsPnLkyMKWjZo1a0KlUuHmzZtITk422m78+PG4evUqWrZsiffee0+aHhERgaZNmyIuLk76DABy/94nTZoEAFi5ciX+/PNPo+s+ffo0VqxYASD3THFhzq63a9cOnTp1AoACu83kpe2vHRMTg9jYWL35Xbp0wY4dO2BhYYGxY8ciKysL3377bYFdAwpjyJAhCAgIQGZmJmbMmKE3/9GjR9JVgAULFkjdZqysrLBu3TpYWVnh888/1zmb2aZNGzRu3BhA7vvB2FjSQO7rdf/+fTg4OBT6vTNnzhzY2Njg4sWL0tnfZ2k0GulvzdQ+yi8zBs5SYvny5Rg0aJDBgZ/F/wZN1n7o5u3oLQftB/20adPwzz//SNM1Gg0mT55c6AHMhw0bBh8fH2zbtg0ffPCBwQ/9O3fumHwgNpX2ZpJly5bpXEpMSEjAwIEDkZ2drbfMb7/9hj179kiXvrSEEPjpp58AGD7g5jVz5kzMnTsX9+/fR5s2bXDkyJHn3RWjOnfujMDAQBw/fhzh4eE6/TS1Hj9+jBUrVujsr/a1WbJkiU7bixcvYvjw4bLV+yJp38eLFy/G0aNHdeYtWrTI5EtyWqmpqdiyZQuAf/urGTNw4EAAuf09te+liIgIlClTBrt378aUKVP03mP37t1DdHS09O9OnTqhXr16uH37Nnr27Kk3gH96ejp++eUXnWnBwcEAcg+WeQfDv3//PgYOHIinT58WYo91mfOeKV++vHSDT8+ePXHu3Dmd+UII/Pbbb9Jlybxq166Ntm3b4sKFC9i9ezccHByk17UwbGxs0LhxY2g0GqO/83379uGrr76CnZ0d1q5dqxMILSwssHbtWtjY2GD58uU6D9gYNmwYOnXqhKysLISFhUmfEXnt3bsXoaGhyMrKQqdOnczqZjFr1ixYWFggKioKkZGRJi1To0YNtG/fHhqNBm+88YbOe0tLqVRKN71kZmYW+WeVQqHArFmzAADffPONzvEEyO0ekZCQgPbt2+tdyq9Tpw6mTp2KnJwcDB48WKeP9qZNm+Dk5IRjx46hY8eOesektLQ0TJw4EZ9//jkUCgXWrFlT6IeqeHh4YPTo0QCATz/91ODx4u+//0ZiYiKqVq0qfdl7pRXPiVUqrC+++EK6TODi4iJCQkJEv379RIcOHaTLNgDEm2++qTdGXlFeUhcid7xN7aDl1tbWIiwsTPTp00f4+fkJGxsbaeiXoUOH6iyX38Dv586dk/bDyclJtGzZUvTr10906dJF1KhRQygUCuHq6lrYl01nP5/dj6NHj0pDslSuXFn06tVLhIWFCRsbG1GzZk3pGch5Xx/t78HBwUG0bt1a9OvXT2cQdUdHR5MGfhcidzgohUIh7OzsCjVgs3Zbvr6+IigoyOjPyZMnhRC5A0Nrx/20s7MTTZs2FX369BHdunUTAQEB0th2aWlp0jZ27NghFAqFAHLHyOvTp49o27atsLKyEm3btpXGoCutl9S1hg0bJoDcByq0bt1a9O3bV9SqVUsolUoxbtw4AeQOzG+KdevWCfxvGJyChg7KysqSLkFv375dmr5v3z5RpkwZAUC4urqKLl26iJ49e4pGjRoZHPj92rVr0qV4W1tbERISIvr27StatmxpcOD3x48fS6+/dmD54OBg4ejoKGrXri26dOli9iV1c98zGRkZolOnTgLIHQuxSZMmol+/fiIkJERv4PdnaYeGAiBGjx6d72uenwULFggAYuLEiXrzHj9+LA1lZmxs2bzrqFSpks6l9fT0dJ1xTCtXriy6d+8uevToIXVxACAGDBhgcOzQgi6paw0cOFAAEM2aNTN5vx8+fCh1BQJyB7Dv0aOH6Nq1q6hQoYIAcofdmj9/vrCxsREKhUJ89dVXJq+/oEvqWtquHP369ZOmbd++XToe3Lx50+ByecdEnTBhgs68c+fOSeM7W1paiubNm4u+ffuK9u3bCwcHBwHkjsG7detWg+su6JK6EEI8evRIGmfT0OuS3/vqVcTAWUokJSWJXbt2idGjR4tGjRoJLy8vYWVlJWxsbISfn5/o27ev+OWXXwwuW9SBU4jcPjRz584VNWrUENbW1sLZ2Vl07dpVnD17VnzyyScC0B8Lr6BnqSclJYm5c+eKJk2aCCcnJ2FlZSXc3d1FYGCgmDBhgt4A9KbKbxzOM2fOiE6dOgl3d3ehVqtFlSpVxMSJE0VSUpLB1+fy5cti+vTpol27dqJChQpCrVaLsmXLijp16ohJkyYZHNw3vw/cTZs2CUtLS6FWq03uu6cNDAX95P19p6enixUrVog2bdqIcuXKCUtLS1G+fHkREBAgRo4cKfbt26e3nT/++EO0a9dOODs7C1tbW1GrVi3xf//3fyIjI8Poe6q0BU6NRiNWrVol6tevL9RqtXBychIhISHijz/+EBs2bBAARN++fY3uS17aAafff/99k9pr+zq3b99eZ/r169fFe++9J6pVqybUarWwt7cXVatWFUOGDBFHjhzRW09ycrKYM2eOCAwMFGXKlBHW1tbCx8dHdOrUSWzZskWv/c2bN8XAgQNF+fLlhUqlEpUqVRITJkwQycnJhX7tn2XOe0aI3N/Dt99+K0JCQkS5cuWElZWVcHNzEy1atBDz5s3T+TL07L4rlUqhUCh0HkJRWNpnqXt4eOh9WdAGuXbt2uU7OHlOTo5o3ry5ACBGjBihN//QoUMiPDxc+Pn5CVtbW2FjYyN8fX3F4MGDRXR0tNH1mho4r127JvVL3rt3b8E7/T/Z2dli7dq1Ijg4WPpseO2110Tr1q3FokWLpDFed+3aJSwsLIRCoRCrV682ad2mBs7Dhw9LXzjOnz8v7t69K/X5LWgg+rNnz0oD9z/795GRkSFWrlwpQkJChKurq7CyshJly5YVDRs2FB9//HG+D00xJXAKIcTs2bMFAOHj46P30AM+S12XQogiuGWQKI+2bdviwIED2LFjB7p161bc5RCZZciQIVi7di3mz5+PiIiI4i6HDPj6668xdOhQhISE6IzRaI5Ro0Zh2bJl2L17t9ExYolMdfLkSTRs2BBdu3bFzp07i7ucEoGBk8wSExODGjVq6IydlpmZiVmzZmHGjBkoX748rl+/Lg0xRFQS/f3336hYsSLs7OykaRqNBqtXr8Y777wDa2trxMXFmTy4P704KSkpqFOnDuLi4rBv377nfiDE/fv3UbVqVVSuXNmsAf+J8vrPf/6D/fv349y5c6hSpUpxl1MicBxOMsvYsWMRExODunXrwt3dHY8fP8bZs2eRkJAAtVqN9evXM2xSiTdv3jxs3boV9erVg6enJ1JSUnD+/Hlcu3YNSqUSy5cvZ9gsYebNm4dz584hOjoacXFxCAsLK5Knj7m4uGD69OkYO3Ystm/fbtLTsogMiY6Oxp49ezBhwgSGzTx4hpPM8s033+Cbb77BmTNn8PDhQwgh4OHhgTZt2mD8+PF6T1ghKol++eUXrFq1CidPnsSDBw+QnZ2N8uXLo1mzZhg7dqw0vAqVHK1bt0ZUVBScnZ3RsWNHLFiwgINqE5UCDJxEREREJCuOw0lEREREsmLgJCIiIiJZ8aahIqTRaHD79m2UKVOmUI8mIyIiIiosIQSSk5Ph4eEBC4uSfQ6RgbMI3b59G97e3sVdBhEREb1Cbty4AS8vr+IuI18MnEWoTJkyAHJ/8Q4ODsVcDREREb3MkpKS4O3tLeWPkoyBswhpL6M7ODgwcBIREdELURq68ZXsC/5EREREVOoxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWfJZ6KXL+dhIepmTAQW2FOl6OBp+d+vBpBi7eSQYAVHd3QFk71Ysu06j0rBycuZmIjOwcVCxnB+/XbHXm301Kx+V7T2GhUKCWpwPKqK2KqVIiIiIqSgycpcCu07ewIuoKYv8XJAHAp5wtwptWxKCmFaFQKBD/MBXzf72IX87eQWaOBgBgbWmB/9Rxx/iQavB0simu8pGamY1F+y/huz9v4ElqFgBAoQCa+TljbHAVlFFbYf5/LyIy9h5yNAIAYKdSoks9T0S8XhXl7K2LrXYiIiJ6fiXykvqyZctQsWJFqNVqBAUF4fjx40bbZmVl4ZNPPoGfnx/UajXq1q2LvXv36rW7desW3nzzTZQrVw42NjaoXbs2/vzzT2n+4MGDoVAodH7CwsJk2b/CWLj/H4z9LkYnbALA9YepmP7jeXyw4wwu30tG1+WH8EPMbSlsAkBGtgY7T91C12WHcP1hyosuHQCQkpGNvquOYeUfcVLYBAAhgOjLD9Dnq6PovCwa/z1/VwqbAJCSmYNvjsWj+5eHcT85ozhKJyIioiJS4s5wfvfdd4iIiMCKFSsQFBSEhQsXIjQ0FBcvXkT58uX12k+ZMgWbNm3CqlWr4O/vj3379qFr1644fPgw6tWrBwB4/PgxmjVrhjZt2uCXX36Bi4sLLl26hLJly+qsKywsDGvXrpX+bW1dvGfWTl5/jIX7L+XbZuufN3H4ykM8TMk02uZecgbe3/YXtg1vWmS1JSQkICEhocB2K6Ou4Phft6V/K+1fg6X9a9K/szUC2XmC5rOuPUzF1F3nsGJAg+crmIiIiIqNQghh/GhfDIKCghAYGIilS5cCADQaDby9vTF69GhMmjRJr72Hhwc++ugjjBw5UprWvXt32NjYYNOmTQCASZMm4dChQzh48KDR7Q4ePBhPnjzBrl27zK49KSkJjo6OSExMhIODg9nr0Xpvy2n8EHO74IYm2jOmBWp4PH9dADB9+nTMmDGj0Ms5NusLp+b9C7WM0kKBgxPbwKMYuwUQERGVNEWdO+RUos5wZmZm4uTJk5g8ebI0zcLCAsHBwThy5IjBZTIyMqBWq3Wm2djYIDo6Wvr37t27ERoaip49eyIqKgqenp549913MXToUJ3lfv/9d5QvXx5ly5ZF27Zt8emnn6JcuXJG683IyEBGxr+Xe5OSkgq1vwX5LfZeka7vwMV7RRY433nnHXTq1ElnWlpaGpo3bw4AiI6Oxvl76fj4h3M6bZR5zm6aKkcj8Mc/99GnUQXzCyYiIqJiU6IC54MHD5CTkwNXV1ed6a6uroiNjTW4TGhoKBYsWICWLVvCz88PkZGR2LlzJ3JycqQ2cXFx+PLLLxEREYEPP/wQJ06cwJgxY6BSqTBo0CAAuZfTu3XrhkqVKuHKlSv48MMP0b59exw5cgRKpdLgtmfPnm3WWT5TZWRpCm5UCOlZOQU3MpG7uzvc3d11pqWk/NtPNCAgAMlXk2Htll4k2yvK2omIiOjFKlGB0xyLFi3C0KFD4e/vD4VCAT8/P4SHh2PNmjVSG41Gg4YNG2LWrFkAgHr16uHcuXNYsWKFFDj79Okjta9duzbq1KkDPz8//P7772jXrp3BbU+ePBkRERHSv5OSkuDt7V1k++b9mg2u3C+6m32eHYZIbj7lim57L7p2IiIiKjol6i51Z2dnKJVK3L17V2f63bt34ebmZnAZFxcX7Nq1CykpKbh+/TpiY2Nhb28PX19fqY27uztq1Kihs1z16tURHx9vtBZfX184Ozvj8uXLRttYW1vDwcFB56co9Q40LbwqTfgtlrG2RMc67gU3LELV3R1Qx8vxudfj5qBG62r6N4wRERFR6VCiAqdKpUKDBg0QGRkpTdNoNIiMjESTJk3yXVatVsPT0xPZ2dnYsWMHOnfuLM1r1qwZLl68qNP+n3/+gY+Pj9H13bx5Ew8fPtS7bPwi9Q6sUOD4mY42VugbWHDfxnda+cJW9eJPaI8NrgIL/fHpC+W94CpQPu9KiIiIqNiUqMAJABEREVi1ahXWr1+PCxcuYMSIEUhJSUF4eDgAYODAgTo3FR07dgw7d+5EXFwcDh48iLCwMGg0GkycOFFqM27cOBw9ehSzZs3C5cuX8e233+Krr76S7mx/+vQpJkyYgKNHj+LatWuIjIxE586dUblyZYSGhr7YFyAPRxsrbHo7yOil6XJ2KqwLD8TMLrUwsInx8Dy0RSWMaltFrjLz1dbfFfN61IXKyGnYpn7l0KG24bPXFgpgYlg19OXNQkRERKVaievD2bt3b9y/fx8ff/wx7ty5g4CAAOzdu1e6kSg+Ph4WFv+Gl/T0dEyZMgVxcXGwt7dHhw4dsHHjRjg5OUltAgMD8f3332Py5Mn45JNPUKlSJSxcuBD9++cOz6NUKnHmzBmsX78eT548gYeHB0JCQjBz5sxiH4uzkrMdfh3XCnv/voPvT93E/acZcLSxwn9qe6BLPQ/prOUnnWuhf5APNh29jjO3EqEAEODthDcbV0Dl8mWKdR+6N/BCi6rO+O74DUT9cx8Z2RpUcrZDn0beaOrnDAD468YTfHPsOi7eSYaFhQKNKr2GN4N82HeTiIjoJVDixuEszUrTeFhySElJgb29PYDcs8Z2dnbFXBEREdHLqzTljhJ3SZ2IiIiIXi4MnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFaWxV0AyevqgxR8c/Q6ztxKBAAEeDuhf1AF+JSzk33bqZnZ+P70Lez7+y5SMrLh5qhGjwZeaF3VBQqFAjcepeLb4/E4ef0xIICang7oH+SDyuXtZa+NiIjIoIxk4K8twMU9QGYK4OgN1OsP+LYBFIrirq7UUgghRHEX8axly5Zh3rx5uHPnDurWrYslS5agUaNGBttmZWVh9uzZWL9+PW7duoVq1aphzpw5CAsL02l369YtfPDBB/jll1+QmpqKypUrY+3atWjYsCEAQAiBadOmYdWqVXjy5AmaNWuGL7/8ElWqVDG57qSkJDg6OiIxMREODg7mvwBFZPaeC/jqYBye/Q0rFMDwVn74IMy/SLeXkpICe/vcsPjb2esYtzMWT1Kz9NrV8XJEE99yWHUwDhoD775BTXww7Y2asLDgHzYREb1AVw4AWwcBGYn687yDgD6bAbtyL74uI0pa7shPibuk/t133yEiIgLTpk3DqVOnULduXYSGhuLevXsG20+ZMgUrV67EkiVLcP78eQwfPhxdu3bF6dOnpTaPHz9Gs2bNYGVlhV9++QXnz5/H/PnzUbZsWanN3LlzsXjxYqxYsQLHjh2DnZ0dQkNDkZ6eLvs+y2Fx5CWs/EM/bAKAEMCXv1/B8t8vy7b9EZtOGQybAHDmZiJW/mE4bALA+iPXMe+/F2WrjYiISM/tGGBzX8NhEwBuHAO+7QVocl5oWS+LEneGMygoCIGBgVi6dCkAQKPRwNvbG6NHj8akSZP02nt4eOCjjz7CyJEjpWndu3eHjY0NNm3aBACYNGkSDh06hIMHDxrcphACHh4eGD9+PN5//30AQGJiIlxdXbFu3Tr06dPHpNpLyjeN5PQsNJ4ViZTM/P8oylhb4thH7WCrKpqeFXnPcHqP2w4LldrsdaksLXBscjuUtVMVSW1ERET52tIfiP2p4Ha9NwHV35C/HhOUlNxhihJ1hjMzMxMnT55EcHCwNM3CwgLBwcE4cuSIwWUyMjKgVusGGxsbG0RHR0v/3r17Nxo2bIiePXuifPnyqFevHlatWiXNv3r1Ku7cuaOzXUdHRwQFBRndbkn2418JBYZNAEjOyMZPfyW8gIoKLzNbgx2nbhZ3GURE9Cp4eh+4+ItpbU+ul7eWl1SJCpwPHjxATk4OXF1ddaa7urrizp07BpcJDQ3FggULcOnSJWg0Gvz666/YuXMnEhL+DVJxcXFSf8x9+/ZhxIgRGDNmDNavz33TaNddmO0CuWE3KSlJ56ckuP4wxeS21wrR9kW7/jC1uEsgIqJXwZN4QJh4qfxRnLy1vKRKVOA0x6JFi1ClShX4+/tDpVJh1KhRCA8Ph4XFv7um0WhQv359zJo1C/Xq1cOwYcMwdOhQrFix4rm2PXv2bDg6Oko/3t7ez7s7RcLa0vRfq6oQbV+0wuwHERGR2Syt5WlLkhJ1RHd2doZSqcTdu3d1pt+9exdubm4Gl3FxccGuXbuQkpKC69evIzY2Fvb29vD19ZXauLu7o0aNGjrLVa9eHfHx8QAgrbsw2wWAyZMnIzExUfq5ceOG6Tsro1bVXExu27paeRkreT4luTYiInqJlK8OOHiZ1rZycMFtSE+JCpwqlQoNGjRAZGSkNE2j0SAyMhJNmjTJd1m1Wg1PT09kZ2djx44d6Ny5szSvWbNmuHhR967nf/75Bz4+PgCASpUqwc3NTWe7SUlJOHbsWL7btba2hoODg85PSdDA5zXU9Ci4lrpejgjwdiqy7ebk/Hs5Iv3GOYjnuJPP18UOzSqXnKEniIjoJWahBBqGF9xOoQQaDpG/npdQiQqcABAREYFVq1Zh/fr1uHDhAkaMGIGUlBSEh+e+EQYOHIjJkydL7Y8dO4adO3ciLi4OBw8eRFhYGDQaDSZOnCi1GTduHI4ePYpZs2bh8uXL+Pbbb/HVV19Jd7YrFAqMHTsWn376KXbv3o2zZ89i4MCB8PDwQJcuXV7o/heVL3oHwMnWyuj81+xUmN8roMi2t3PnTp2zyPe3T8etFW8h9eJhg+3trZVG11VGbYnFfepBwQF2iYjoRWk6BqjUMp8GCqDDXOC1Si+spJdJiXvSUO/evXH//n18/PHHuHPnDgICArB3717php74+Hid/pnp6emYMmUK4uLiYG9vjw4dOmDjxo1wcnKS2gQGBuL777/H5MmT8cknn6BSpUpYuHAh+vfvL7WZOHEiUlJSMGzYMDx58gTNmzfH3r179e6ALy2qupbBzhFNMW/fRfx6/i6y/zfopZVSgZAabpgQWg0VnYvmaUM7d+5Ejx498OwIWznJD3F/1yy4dPkQttWaAgCquztgZBs/BHg7Ye7ei9h77g4yczQAAKWFAm39y2NCaDVUdS1TJLURERGZxFIF9N8O/P4ZcGo9kPrw33nudYGWE4HqHYuvvlKuxI3DWZqV1PGw7ial4/ztJEAB1HR3QHmHogvROTk5qFixIm7eNDyEkUKhgIubBzbsOw7P1+xQy9NRZ/6Dpxk4eysREIC/exm4O9oUWW1ERERmyc4A4o8CWamAoxfgVru4KzKopOYOQ0rcGU4qeq4OargWYcjM6+DBg0bDJpA7qP69hFuwfvgPatVurTff2d4abXhzEBERlSSW1oBvq+Ku4qVS4vpwUumSd7zTomhHRERELx8GTnou7u7uRdqOiIiIXj4MnPRcWrRoAS8vL6N3lCsUCnh7e6NFixYvuDIiIiIqKRg46bkolUosWrQIAPRCp/bfCxcuhFJpfBgkIiIierkxcNJz69atG7Zv3w4PDw+d6V5eXti+fTu6detWTJURERFRScBhkYpQaRqeQA7a/QeAPXv2ICQkhGc2iYiIZFKacgfPcFKRyRsuW7ZsybBJREREABg4iYiIiEhmDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyMitwHjt2rKjrICIiIqKXlFmBs0mTJqhbty6WLl2KJ0+eFHFJRERERPQyUQghRGEXGjhwIHbs2IG0tDSo1Wr06NEDQ4cORYsWLeSosdRISkqCo6MjEhMT4eDgUNzlvHApKSmwt7cHADx9+hR2dnbFXBEREb0MEhISkJCQUOjl3N3d4e7uLkNFJUNpyh1mBU4ASExMxKZNm7B69WrExMRAoVCgSpUqGDp0KAYNGgRnZ+eirrXEK02/eDkUV+BMSs/C+dtJ0AiBqq5l4Gxv/UK2S0T0ShACSIgB0p4Adi6AW62iWe+Dy0DiDUBlD3jUA5SWRptOnz4dM2bMKPQmpk2bhunTpz9HkSVbacodZgfOvE6dOoVVq1Zhy5YtSExMhEqlQufOnTF06FAEBwcXRZ2lQmn6xcvhRQfOe0npmP/ff7D7r9tIy8oBAFgpFQit6YaI16vC18Ve1u0TEb30jq8Cjn4JPLry7zTXWkDTMUDd3uat89J+4I95wI2j/04r4w40HAI0HwcorfQWMXSGMy0tDc2bNwcAREdHw8bGRm85nuEsOYokcGqlpaVh27Zt+PDDD6U3ho+PD4YPH44RI0agTJkyJq9r2bJlmDdvHu7cuYO6detiyZIlaNSokcG2WVlZmD17NtavX49bt26hWrVqmDNnDsLCwqQ2hr4dVatWDbGxsdK/W7dujaioKJ0277zzDlasWGFSzaXpFy+HFxk4bz9JQ88VR3DrSZrB+Y42Vtg8tDFqeLx6vwcioiLx41jg5Frj81tOBNp+VLh1ntoI/DgGEBrD8yu/DvTdbDB0PovduEpX7iiyYZEeP36Mr776CvPmzcPt27cBAM2aNUNycjImTZqEatWq4cSJEyat67vvvkNERASmTZuGU6dOoW7duggNDcW9e/cMtp8yZQpWrlyJJUuW4Pz58xg+fDi6du2K06dP67SrWbOm9C0pISEB0dHReusaOnSoTpu5c+cW8pWgF2HSzrNGwyYAJKZlYfTmUyjC71NERK+O8z/kHzYB4I+5wPXDpq/zSTzw01jjYRMALv8KHFlm+jqp1HjuwHngwAH069cPnp6eGDduHO7du4cJEybg0qVL+OOPP3Dz5k0sW7YMycnJGD16tEnrXLBgAYYOHYrw8HDUqFEDK1asgK2tLdasWWOw/caNG/Hhhx+iQ4cO8PX1xYgRI9ChQwfMnz9fp52lpSXc3NykH0P9TG1tbXXalPRvDK+iuPtPcfDS/QLbXbmfgsNXHr6AioiIXjLHV5nY7ivT1/nnGkCTbUK71YAmn1BKpZJZgfPu3bv47LPPUKVKFQQHB2PLli0ICgrC5s2bcfPmTcyZMwe+vr4AAGtra4wYMQLDhg1DTExMgevOzMzEyZMndfp+WlhYIDg4GEeOHDG4TEZGBtRqtc40GxsbvTOYly5dgoeHB3x9fdG/f3/Ex8frreubb76Bs7MzatWqhcmTJyM1NdVorRkZGUhKStL5IfkduHgfpp64jLxg+Kw4EREZkZkCXDtoWtt//mv6ek1t+yQeuH/B9PVSqWD8lrB8eHl5QaPRoGzZshg7diyGDRuGatWq5buMi4sLMjMzC1z3gwcPkJOTA1dXV53prq6uOv0t8woNDcWCBQvQsmVL+Pn5ITIyEjt37kROTo7UJigoCOvWrUO1atWQkJCAGTNmoEWLFjh37pzUt7Rfv37w8fGBh4cHzpw5gw8++AAXL17Ezp07DW539uzZZt01R88nPSun4EbattmmtyUiIgBZ6aa3zTbetem52hamBioVzAqcQUFBGD58OHr27Alra9OGoJk0aRImTZpkzuYKtGjRIgwdOhT+/v5QKBTw8/NDeHi4ziX49u3bS/9fp04dBAUFwcfHB1u3bsVbb70FABg2bJjUpnbt2nB3d0e7du1w5coV+Pn56W138uTJiIiIkP6dlJQEb29vOXaR8vB+zdbkthUK0ZaIiADYOAFqJyD9ScFtnXxMX6+TD/AoruB2CiXg6GX6eqlUMOuSenR0NN58802Tw2ZhODs7Q6lU4u7duzrT7969Czc3N4PLuLi4YNeuXUhJScH169cRGxsLe3t76bK+IU5OTqhatSouX75stE1QUBAAGG1jbW0NBwcHnR+SX2hNV5S1LfgORiulAt3qe76AioiIXiIWSiCgn2lt6w80fb2mtq0aCpRxLbgdlSpmBc6bN29i9+7dRh9r+fjxY+zevRu3bt0q9LpVKhUaNGiAyMhIaZpGo0FkZCSaNGmS77JqtRqenp7Izs7Gjh070LlzZ6Ntnz59iitXruQ7Ppe2z+nLPIZXaWRtqcTINpULbNc/yAfly6gLbEdERM9oPAKwKZt/GwdPoMFg09dZ/Q3ArXb+bZQqoMX7pq+TSg2zAuenn36K8PBwg4OsArl3eg8ZMgSzZ882q6iIiAisWrUK69evx4ULFzBixAikpKQgPDwcQO6jNSdPniy1P3bsGHbu3Im4uDgcPHgQYWFh0Gg0mDhxotTm/fffR1RUFK5du4bDhw+ja9euUCqV6Nu3LwDgypUrmDlzJk6ePIlr165h9+7dGDhwIFq2bIk6deqYtR8kn7db+GJUm8pQKAzP79HAC1M71nixRRERvSycKgBv7gDsyhufP2AXYPua6etUWgH9dwDuAYbnW9kBvTYCXg0KWy2VAmb14fztt98QEhJi9JK6tbU1QkJCsH//frOK6t27N+7fv4+PP/4Yd+7cQUBAAPbu3SvdSBQfHw8Li3+zcnp6OqZMmYK4uDjY29ujQ4cO2LhxI5ycnKQ2N2/eRN++ffHw4UO4uLigefPmOHr0KFxcXADknlndv38/Fi5ciJSUFHh7e6N79+6YMmWKWftA8ns/tBq61ffEpqPxOBn/GEII1HB3wJuNfVDL07G4yyMiKt08GwDv/QWc3Qqc2/Hvoy3r9AZqdgEszehWV8YVGHoAuLQvdxD4pJu5QdO/AxDQv3ABlkoVs540ZGdnhzFjxuR7BnPy5MlYunQpkpOTn6vA0qQ0jfgvBz71gYiIXhQec0pX7jDrkrpKpSpwzMmkpCQojF3vJCIiIqJXhlmBs3bt2vjxxx+RkZFhcH56ejp2796N2rUL6BxMRERERC89swJneHg4bt68iU6dOiEuTndMrStXrqBz5864ffs23n777SIpkoiIiIhKL7NuGgoPD8eePXuwY8cO+Pv7o1KlSvD09MStW7dw9epVZGdno3fv3tJd5URERET06jLrDCcAbN26FYsXL0blypVx6dIl/P7777h06RKqVq2KZcuWYfPmzUVZJxERERGVUmbdpf6slJQUJCYmwtHR8ZW8S0yrNN0tJgfeMUhERC8KjzmlK3eYdUn9WXZ2dq/kL5qIiIiICmb2JXUiIiIiIlOYHThv3LiBd955B35+frCxsYFSqdT7sbQskhOoRERERFSKmZUI4+LiEBQUhMePH6NmzZrIyMiAj48P1Go14uLikJWVhbp16+o8WpJeLgkJCUhISNCZlpaWJv1/TEwMbGxs9JZzd3eHu7u77PURERFRyWFW4JwxYwYSExMRGRmJVq1awcLCAuHh4fj444+RkJCAESNG4Pz582Y/S51KvpUrV2LGjBlG5zdv3tzg9GnTpmH69OkyVUVEREQlkVmBc//+/ejQoQNatWolTdPe7O7u7o7vvvsOtWvXxocffoiVK1cWTaVUorzzzjvo1KlToZfj2U0iIqJXj1mB88GDB/D39/93JZaWSE1Nlf5tbW2N119/Hbt27XruAqlk4qVxIiIiMpVZNw05OzsjJSVF59/Xrl3TaWNpaYknT548T21ERERE9BIwK3BWqVIFV65ckf7dqFEj7Nu3T3qu+v3797F9+3b4+fkVTZVEREREVGqZFTjbt2+PAwcOSGcwx44di+TkZNSpUweBgYGoWrUq7ty5g9GjRxdlrURERERUCpkVOEeMGIHff/8dSqUSANC6dWts2bIFPj4+OHfuHFxdXbF48WIMHTq0SIslIiIiotKnSJ6lTrlK0zNNiYiISjM+S7105Q6zznC2bdsWU6dOLepaiIiIiOglZFbgPHbsGHJycoq6FiIiIiJ6CZkVOP39/XH9+vWiroWIiIiIXkJmBc7Ro0fjhx9+wPnz54u6HiIiIiJ6yZj1pCFfX1+0bt0ajRs3xjvvvIPAwEC4urpCoVDotW3ZsuVzF0lEREREpZdZd6lbWFhAoVBIz083FDS1XqW+nqXpbjEiIqLSjHepl67cYdYZzo8//jjfkElEREREpGVW4Jw+fXoRl0FERERELyuzbhoiIiIiIjIVAycRERERycqsS+ram4YKolAokJ2dbc4miIiIiOglYVbgbNmypcHAmZiYiEuXLiElJQV169aFk5PT89ZHRERERKWcWYHz999/NzovNTUVkyZNwt69e/Hrr7+aWxcRERERvSSKvA+nra0tFi9eDEdHR0yYMKGoV09EREREpYxsNw21aNECP//8s1yrJyIiIqJSQrbAef/+fTx9+lSu1RMRERFRKVHkgVOj0WDjxo347rvvEBAQUNSrJyIiIqJSxqybhnx9fQ1Oz87Oxr1795CVlQUrKyvMnj37uYojIiIiotLPrMCp0WgMDotkZWWFWrVqITAwEKNGjULNmjWfu0AiIiIiKt3MCpzXrl0r4jKIiIiI6GXFR1sSERERkazMCpw3b97E7t278eTJE4PzHz9+jN27d+PWrVvPUxsRERERvQTMCpyffvopwsPDYWNjY3C+ra0thgwZwpuGiIiIiMi8wPnbb78hJCQE1tbWBudbW1sjJCQE+/fvf67iiIiIiKj0Mytw3rp1CxUrVsy3jY+PDy+pExEREZF5gVOlUiEpKSnfNklJSQaHTiIiIiKiV4tZgbN27dr48ccfkZGRYXB+eno6du/ejdq1az9XcURERERU+pkVOMPDw3Hz5k106tQJcXFxOvOuXLmCzp074/bt23j77beLpEgiIiIiKr3MGvg9PDwce/bswY4dO+Dv749KlSrB09MTt27dwtWrV5GdnY3evXsjPDy8qOslIiIiolLG7IHft27disWLF6Ny5cq4dOkSfv/9d1y6dAlVq1bFsmXLsHnz5qKsk4iIiIhKKYUQQjzvSlJSUpCYmAhHR0fY2dkVRV2lUlJSEhwdHZGYmAgHB4fiLoeIiOillZKSAnt7ewDA06dPX8n8UZpyh1mX1J9lZ2f3Sv6iiYiIiKhgZl1SP3ToECIiInDnzh2D8xMSEhAREYGjR48+V3FEREREVPqZFTgXLFiAH3/8EW5ubgbnu7u746effsIXX3zxXMURERERUelnVuA8ceIEmjdvnm+bli1b8gwnEREREZkXOO/duwdPT89827i5ueHevXtmFUVERERELw+zAqeTkxPi4+PzbXP9+nXp7jEiIiIienWZFTgbN26M77//Hjdu3DA4Pz4+Hrt27ULTpk2fqzgiIiIiKv3MCpwRERFITU1Fs2bNsGHDBiQkJADIvTt9/fr1aNasGdLS0jB+/PgiLZaIiIiISh+zxuFs2bIlFixYgPHjx0uPr1QoFNCOIW9hYYFFixahZcuWRVcpmeVo3EN8d+IGbj5OhdpKibb+5dG9gRcc1FbFVtOx/9V04381talWHj0aFm9NRESUR8IZ4M81wIN/AAslULEFUH8QUMZV/m3HRQGnNwGJNwArW6Bae6BuH8C6jPzbLohGA/yzFzizBUi+C6gdgZpdgJrdACv1v+2uHwZObQAeXwMs1UCVECCgH2DjVEyFF7/netLQmTNnsGLFCpw4cQKJiYlwcnJCo0aNMHz4cNSqVQsZGRmwtrY2a93Lli3DvHnzcOfOHdStWxdLlixBo0aNDLbNysrC7NmzsX79ety6dQvVqlXDnDlzEBYWJrWZPn06ZsyYobNctWrVEBsbK/07PT0d48ePx5YtW5CRkYHQ0FAsX74crq6m/YGVpBH/E9OyMHzjSRyJe6g3z97aEov7BqCt/wv44MgjKT0LIzadxKHLhmta2DsAwTVebE1ERJRHdibww0jg7Fb9eRZWQPs5QOBb8mw79RGwpT8Qf1h/ntoR6LEWqNxOmqQ95gLAnj17EBISAqVSKU9tAJB4E/imF3Dvb/159m5A381AucrAtkHAld/026jsga4rgeodi6ykkpQ7CmL2s9QBoE6dOli+fDlOnDiBf/75B8ePH8fSpUuRmZmJkSNHwsPDw6z1fvfdd4iIiMC0adNw6tQp1K1bF6GhoUbvep8yZQpWrlyJJUuW4Pz58xg+fDi6du2K06dP67SrWbMmEhISpJ/o6Gid+ePGjcOPP/6Ibdu2ISoqCrdv30a3bt3M2ofiJITAsA1/GgybAPA0IxvDN57CqfjHL7SmdzYYDpvamt795hT+vPbohdVERETP+Gmc4bAJAJos4OcI4NzOot+uRgN829tw2ASA9ERgSz/gdu5xfefOnahRo4Y0u0OHDqhYsSJ27pShNgDITAE2dDEcNgHg6R1gY1fgm56GwyYAZD4Ftg3OPfv5CiqSZ6kDwJMnT7Bp0yasXr0aZ86cgRACNjY2SElJKfS6goKCEBgYiKVLlwIANBoNvL29MXr0aEyaNEmvvYeHBz766COMHDlSmta9e3fY2Nhg06ZNAHLPcO7atQsxMTEGt5mYmAgXFxd8++236NGjBwAgNjYW1atXx5EjR9C4ceMC6y4p3zSi/rmPQWuOF9iudTUXrAs3fNa4qEVfeoA3Vx8rsF2LKs7Y+FbQC6iIiIh0PLwCLGkAoIBYUK4yMOpPQKEoum3H7gG29C24nX9H7FR1R48ePfBsfFH8r57t27cX/cmiE18DPxfRfSmVWgGDdhfJqkpK7jDFc53hBID9+/ejb9++8PDwwHvvvYe//voLjRs3xldffWX00Zf5yczMxMmTJxEcHPxvkRYWCA4OxpEjRwwuk5GRAbVarTPNxsZG7wzmpUuX4OHhAV9fX/Tv319naKeTJ08iKytLZ7v+/v6oUKGC0e2WVFuO5z9kldYf/9zH7SdpMleTa/MJ02qKvvwANx6lylwNERHpOb0RBYZNAHh4Gbh+qGi3fWq9Sc1yLuzBe6NH6YVNANK0sWPHIicnp0jLw0nT6jPJ1SjgUVzRra+UMCtw3rhxA5988gkqVaqE0NBQfPfddyhXrhyEEBg8eDAOHTqEt99+G2XKFL6D74MHD5CTk6PXb9LV1dVogA0NDcWCBQtw6dIlaDQa/Prrr9i5c6d09zyQe9Z03bp12Lt3L7788ktcvXoVLVq0QHJyMgDgzp07UKlUcHJyMnm7GRkZSEpK0vkpCa4+MO2sskYA1x++mHB3zcSahADiGTiJiF68h1fkaVuE6zt4PRM3bycYnS+EwI0bN3Dw4MGiqixXUQdEBk7jsrKysG3bNoSFhcHX1xfTp0/HgwcP0L9/f/z3v//F9evXAQCWlmbd+P5cFi1ahCpVqsDf3x8qlQqjRo1CeHg4LCz+3b327dujZ8+eqFOnDkJDQ7Fnzx48efIEW7ca6atigtmzZ8PR0VH68fb2LordeW7WVqZ3mra2eu6T3CZRWZq+HetCtCUioiJiWYibfC3VBbeRYdsJyab1Asx7wqlIFOa1MWl9Rfz6lQImH9k9PDzQp08f7N+/H61bt8b69etx584dbNiwAcHBwTrh7nk4OztDqVTi7t27OtPv3r0LNzc3g8u4uLhg165dSElJwfXr1xEbGwt7e3v4+voa3Y6TkxOqVq2Ky5cvA8h9FGdmZiaePHli8nYnT56MxMRE6cfYQPgvWqsqzia1c7ZXoZaHo8zV5GpV1cWkdq/ZqVDb68XUREREeVQOLrgNkHu3um+rIt52u4LbAHAvb9rxzd3d/Xmq0ednWn0msSkLeDYouvWVEianxIcPH0KhUGDcuHH49ttvMWDAANjZ2RV5QSqVCg0aNEBkZKQ0TaPRIDIyEk2aNMl3WbVaDU9PT2RnZ2PHjh3o3Lmz0bZPnz7FlStXpDdlgwYNYGVlpbPdixcvIj4+3uh2ra2t4eDgoPNTEvQL8oGVsuDO3L0DvQt15vF59GtUASplwdvq1dAb1pYyDmtBRESG1ewK2JoQ6Kp3BMoYPhFjtoZvAYqCP/tb9BgBLy8v6QahZykUCnh7e6NFixZFW1+jYaa1szDhKm+9NwErm+erpxQyOW0MHjwYNjY2WLBgAby8vNCpUyds27YNmZmZRV5UREQEVq1ahfXr1+PChQsYMWIEUlJSpEHmBw4ciMmTJ0vtjx07hp07dyIuLg4HDx5EWFgYNBoNJk6cKLV5//33ERUVhWvXruHw4cPo2rUrlEol+vbNvSvO0dERb731FiIiInDgwAGcPHkS4eHhaNKkiUl3qJckbo5q/F/X2vneQNjApyxGt63ywmoq76DGrG61YZFPTfUrOOG9di+uJiIiysPSGuj+df6Xe1/zBdrPLfptl/UB/vM5gHwOEhVbQNkqAosWLQIAvdCp/ffChQuLfjxO70Cg1Qf5t6nRBei8DFDkE608GwCtJxuf/xIzOXCuWbMGCQkJWLlyJerXr4+ffvoJffr0gaurK9555x29O8KfR+/evfH555/j448/RkBAAGJiYrB3717pRqL4+Hid/hnp6emYMmUKatSoga5du8LT0xPR0dE6NwDdvHkTffv2RbVq1dCrVy+UK1cOR48ehYvLv5d6v/jiC3Ts2BHdu3dHy5Yt4ebmJt+YXjLr1dAbqwc1RN1nLk872lhhaItK2PRWENSF6OtZFHo08MLqQYGo6+2kM91BbYm3m1fCN283ho2KZzeJiIqNXxtg0E+Ab2vohD9Lm9wzc0P+C9iXl2fbDYcAvTcB7nV1p9u8BjQbC/TfDlhao1u3bti+fbveWN9eXl7yDImk1eZDoPNywLmq7vQy7kDbqUCPNblPROq/DfAK1G1j7Qg0fhcY9COgKvqrw6WB2eNwXrhwAV9//TU2bdqE+/fvS98smjdvjg0bNsDHx6dICy0NSup4WLF3knDjURpsrJRoWLHsCw+a+dWktrJAQ5/XGDSJiEqah1f+92hLK8CrQW7fwxflzlngyQ1AZQt4N9Z9bOT/vPAnDeV182TuYO9qx9z6lAYupd89n/toSyt1bhuVbZGXUVJzhyHPPfB7dnY2du3ahdWrV+PXX3+FRqOBhYUFWrVqhcGDB2PAgAFFVWuJV5p+8URERKVZSkoK7O3tAeTelyHHfSUlXWnKHUX2pCEg97L12rVrsW7dOly9ehUKhaLoB18twUrTL56IiKg0Y+AsXbmjSG9R9vLywtSpU3HlyhX8+uuv6NOnT1GunoiIiIhKIdlGaW/Xrh3atSvCcauIiIiIqFTiI12IiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkZVncBRAREVEJJgRw5wyQ9hiwcwFcaxZ3RSVD2hPg7rnc16d8DcCuXHFXVKIxcBIREZFhJ1YDR78EHl76d5prLaDpGKBu7+KrqzglJQAHPgXO7QSyUnOnKVVA9U5Amw+Bcn7FW18JVWIvqS9btgwVK1aEWq1GUFAQjh8/brRtVlYWPvnkE/j5+UGtVqNu3brYu3ev0fafffYZFAoFxo4dqzO9devWUCgUOj/Dhw8vql0iIiIqPX4eD/wcoRs2gdyzet8PAw7MKp66itOTG8DXwcDpTf+GTQDIyQTObQdWvw7ciy2++kqwEhk4v/vuO0RERGDatGk4deoU6tati9DQUNy7d89g+ylTpmDlypVYsmQJzp8/j+HDh6Nr1644ffq0XtsTJ05g5cqVqFOnjsF1DR06FAkJCdLP3Llzi3TfiIiISrwLPwInvs6/TdQc4PrhF1NPSfHDSCDppvH5qQ+BHW+9uHpKkRIZOBcsWIChQ4ciPDwcNWrUwIoVK2Bra4s1a9YYbL9x40Z8+OGH6NChA3x9fTFixAh06NAB8+fP12n39OlT9O/fH6tWrULZsmUNrsvW1hZubm7Sj4ODQ5HvHxERUYl2bKVp7Y5/JW8dJcm9WOBqVMHt7p4Drh2Sv55SpsQFzszMTJw8eRLBwcHSNAsLCwQHB+PIkSMGl8nIyIBardaZZmNjg+joaJ1pI0eOxH/+8x+ddT/rm2++gbOzM2rVqoXJkycjNTXVaNuMjAwkJSXp/BAREZVqmanAtYOmtf1nn7y1lCSXCrGv/xjv1veqKnE3DT148AA5OTlwdXXVme7q6orYWMP9IkJDQ7FgwQK0bNkSfn5+iIyMxM6dO5GTkyO12bJlC06dOoUTJ04Y3Xa/fv3g4+MDDw8PnDlzBh988AEuXryInTt3Gmw/e/ZszJgxw4y9JCIiKqGy0+VpW9pl8XV5HiUucJpj0aJFGDp0KPz9/aFQKODn54fw8HDpEvyNGzfw3nvv4ddff9U7E5rXsGHDpP+vXbs23N3d0a5dO1y5cgV+fvp3nU2ePBkRERHSv5OSkuDt7V2Ee0ZERPSCqR0BtROQ/qTgtk4V5K6m5CjrY3pbp0K0fUWUuEvqzs7OUCqVuHv3rs70u3fvws3NzeAyLi4u2LVrF1JSUnD9+nXExsbC3t4evr6+AICTJ0/i3r17qF+/PiwtLWFpaYmoqCgsXrwYlpaWOmdC8woKCgIAXL582eB8a2trODg46PwQERGVahZKIKC/aW3rD5S3lpKkeqfcMF4QpTVQt4/89ZQyJS5wqlQqNGjQAJGRkdI0jUaDyMhINGnSJN9l1Wo1PD09kZ2djR07dqBz584AgHbt2uHs2bOIiYmRfho2bIj+/fsjJiYGSqXS4PpiYmIAAO7u7kWzc0RERKVB4+GAjeGbayVlPID6g19IOSWCyhZoNrbgdo2GAnbOspdT2pTIS+oREREYNGgQGjZsiEaNGmHhwoVISUlBeHg4AGDgwIHw9PTE7NmzAQDHjh3DrVu3EBAQgFu3bmH69OnQaDSYOHEiAKBMmTKoVauWzjbs7OxQrlw5afqVK1fw7bffokOHDihXrhzOnDmDcePGoWXLlkaHUCIiInopOVUA3twBfNsbSLmvP9+xAvDm9lfv6TotInKfuHR4seH59QYAr3/yYmsqJUpk4Ozduzfu37+Pjz/+GHfu3EFAQAD27t0r3UgUHx8PC4t/T86mp6djypQpiIuLg729PTp06ICNGzfCycnJ5G2qVCrs379fCrfe3t7o3r07pkyZUtS7R0REVPJ5NgDe+ws4sxU4tyP3UY52zkCd3kDNroCV8XsiXmohM4F6b+Y+henm8dxHW7rXBQLfyv0vGaQQQojiLuJlkZSUBEdHRyQmJrI/JxERURHRPowlr7S0NDRv3hwAEB0dDRsbG73l3N3dX+pucaUpd5TIM5xEREREWitXrsx3GEJt8HzWtGnTMH36dJmqosJg4CQiIqIS7Z133kGnTp0KvdzLfHaztGHgJCIiohLtZb80/iooccMiEREREdHLhYGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVgycRERERCQrBk4iIiIikhUDJxERERHJioGTiIiIiGTFwElEREREsmLgJCIiIiJZMXASERERkawYOImIiIhIVpbFXQARERG9oh5cAv5cC9w5AygUgHcQ0GAw4OhV3JVRESuxZziXLVuGihUrQq1WIygoCMePHzfaNisrC5988gn8/PygVqtRt25d7N2712j7zz77DAqFAmPHjtWZnp6ejpEjR6JcuXKwt7dH9+7dcffu3aLaJSIiIgIAjQbYMxFY2hA4ugy4dhC4+gfwxzxgYR3g4PzirpCKWIkMnN999x0iIiIwbdo0nDp1CnXr1kVoaCju3btnsP2UKVOwcuVKLFmyBOfPn8fw4cPRtWtXnD59Wq/tiRMnsHLlStSpU0dv3rhx4/Djjz9i27ZtiIqKwu3bt9GtW7ci3z8iIqJXWuQM4PhKw/NEDhD5CXB81YutiWSlEEKI4i7iWUFBQQgMDMTSpUsBABqNBt7e3hg9ejQmTZqk197DwwMfffQRRo4cKU3r3r07bGxssGnTJmna06dPUb9+fSxfvhyffvopAgICsHDhQgBAYmIiXFxc8O2336JHjx4AgNjYWFSvXh1HjhxB48aNC6w7KSkJjo6OSExMhIODw/O8BERERC+nlAfAghpATkb+7ezKA+P+BixVL6auUqg05Y4Sd4YzMzMTJ0+eRHBwsDTNwsICwcHBOHLkiMFlMjIyoFardabZ2NggOjpaZ9rIkSPxn//8R2fdWidPnkRWVpbOPH9/f1SoUMHodomIiKiQ/tpccNgEgJR7wMU98tdDL0SJu2nowYMHyMnJgaurq850V1dXxMbGGlwmNDQUCxYsQMuWLeHn54fIyEjs3LkTOTk5UpstW7bg1KlTOHHihMF13LlzByqVCk5OTnrbvXPnjsFlMjIykJHx7x9NUlKSKbtIRET06np4xfS2jwrRlkq0EneG0xyLFi1ClSpV4O/vD5VKhVGjRiE8PBwWFrm7d+PGDbz33nv45ptv9M6EPo/Zs2fD0dFR+vH29i6ydRMREb2ULAtxHC5MWyrRSlzgdHZ2hlKp1Ls7/O7du3BzczO4jIuLC3bt2oWUlBRcv34dsbGxsLe3h6+vL4Dcy+X37t1D/fr1YWlpCUtLS0RFRWHx4sWwtLRETk4O3NzckJmZiSdPnpi83cmTJyMxMVH6uXHjxvO/AERERC+zyu0K0Va/CxyVTiUucKpUKjRo0ACRkZHSNI1Gg8jISDRp0iTfZdVqNTw9PZGdnY0dO3agc+fOAIB27drh7NmziImJkX4aNmyI/v37IyYmBkqlEg0aNICVlZXOdi9evIj4+Hij27W2toaDg4PODxEREeWjcjDwmm/B7Sq2AFyqyV8PvRAlrg8nAERERGDQoEFo2LAhGjVqhIULFyIlJQXh4eEAgIEDB8LT0xOzZ88GABw7dgy3bt1CQEAAbt26henTp0Oj0WDixIkAgDJlyqBWrVo627Czs0O5cuWk6Y6OjnjrrbcQERGB1157DQ4ODhg9ejSaNGli0h3qREREZAKFAuj+NbC+M5CZbLiNvSvQacmLrYtkVSIDZ+/evXH//n18/PHHuHPnDgICArB3717pRqL4+HipfyaQO2D7lClTEBcXB3t7e3To0AEbN27UuwGoIF988QUsLCzQvXt3ZGRkIDQ0FMuXLy/KXSMiIiLPBsCQvbnjbV7+FRCa3OkWVkCNTkDwdMCpQrGWSEWrRI7DWVqVpvGwiIiISoQn8cDdvwGFBeBRD7AvX9wVlRqlKXeUyDOcRERE9IpwqsCzma+AEnfTEBERERG9XBg4iYiIiEhWDJxEREREJCsGTiIiIiKSFQMnEREREcmKgZOIiIiIZMXASURERESyYuAkIiIiIlkxcBIRERGRrPikoSKkfUpoUlJSMVdCRERELztt3igNTyln4CxCycnJAABvb+9iroSIiIheFcnJyXB0dCzuMvKlEKUhFpcSGo0Gt2/fRpkyZaBQKIq7nGKRlJQEb29v3LhxAw4ODsVdDhERvcRe9WOOEALJycnw8PCAhUXJ7iXJM5xFyMLCAl5eXsVdRong4ODwSv7xExHRi/cqH3NK+plNrZIdh4mIiIio1GPgJCIiIiJZMXBSkbK2tsa0adNgbW1d3KUQEdFLjsec0oM3DRERERGRrHiGk4iIiIhkxcBJRERERLJi4CQiIiIiWb3SgfPSpUsYNWoUatSoATs7O6jVanh5eSEwMBCjRo3Cjh079JZp3bo1FAoFfv/99xdfcB6///47FAoFWrduLcv6161bB4VCUeifdevWyVKPlnY7ReG3336DhYUF7OzscPnyZaPtZsyYAYVCgZo1ayIjI0NnXlZWFlatWoX27dvD3d0dKpUK5cqVQ1BQEGbMmIEHDx4YXe/06dP1Xj+lUomyZcuicePGmDVrFp4+fVok+0pELwaPK8a9CscVAKhYsaLePlhbW8PLywudO3fGTz/9ZHC5tLQ0+Pv7Q6FQYNasWUbXHxsbCxsbG1hYWCAqKkpv/tGjR/H222+jSpUqsLe3h52dHSpXroy33noLhw8fNrrea9euGXz9bW1tUaVKFbz11ls4e/Zs4V+Q/3llB37fuXMn+vXrh4yMDJQrVw7NmjWDi4sLHj9+jJiYGCxbtgxbtmxB9+7di7vUYlG5cmUMGjRIb3p0dDSuXLkCPz8/NG/e3OBypUXbtm3x7rvvYtmyZRg8eDD++OMPvSc1nDp1Cp9++iksLS2xYcMGnTshL1y4gM6dO+PSpUtQKpVo3Lgx2rRpg8ePH+PQoUM4fvw4FixYgLVr16Jbt25G63B1dUVYWBiA3AAbFxeHY8eO4dixY9iwYQMOHjwIFxcXeV4EIioyPK7k71U4ruTVrFkzqfbExEScPn0au3fvxu7duzFu3DgsWLBAp72NjQ3Wr1+PZs2aYcaMGXjjjTdQu3ZtnTY5OTkYNGgQ0tPTMXbsWLRq1Uqal5mZiREjRmDNmjUAAD8/P4SGhkKhUODMmTNYs2YN1qxZg/DwcKxYsQIqlcpo7d27d4e9vT0AICEhAcePH8eaNWuwYcMGfPfdd/ke04wSr6A7d+4Ie3t7AUCMHz9epKWl6bX5888/xaRJk/SmX79+XVy4cEGkpKS8iFKNOnDggAAgWrVq9UK3O2jQIAFADBo06IVuVwuAKMq37dOnT4Wfn58AIObOnaszLz09XdSsWVMAEB9//LHOvLi4OPHaa68JACI4OFhcv35dZ35qaqp4//33BQBhYWEhvv/+e71tT5s2zejvMCoqSqhUKgFAvPvuu8+9n0QkLx5XzPeyHVd8fHwEALF27Vqd6VlZWWLUqFHS9o4fP25w+UmTJgkAIiAgQGRmZurMmzlzpgAgqlWrJlJTU3Xmde3aVQAQ5cqVEz/++KPeevfs2SNcXFwEANGtWze9+VevXpVqu3r1qs68Bw8eiKZNmwoAwtnZWW/bpnglA+fXX38tAAgPD4/iLsVs/GAoOgcPHhQWFhbC2tpa/P3339L0CRMmCACifv36en/0zZo1EwBE48aNRXp6utF1a0Ono6OjePDggc68/AKnEEIMHTpUABDe3t7m7xwRvRA8rpjvZTuuGAucQgiRlpYmHBwcBAAxdepUg8tnZGSIWrVq6bWJiYkRVlZWQqlUimPHjuks89VXXwkAwsrKSpw4ccJobadOnRJWVlYCgPj666915uUXOIUQ4tChQ9L8yMjIfF4Bw17JPpx3794FALMuUxrrazN48GCpr8nVq1cxYMAAuLm5wdraGn5+fpgyZYpe/z+t7OxszJ8/H7Vq1YJarUb58uXRs2dPnD9/XurzMnjw4ELV+fjxY0ybNg0BAQEoU6YMbG1tUbt2bXz66adITU0t9H6bYufOnXj77bdRq1YtlC1bFmq1GpUqVcKQIUNw8eJFg8tkZGRg3rx5aNCgAcqUKQOVSgU3NzcEBgZi4sSJePTokUnbzsnJwYgRI6BQKFC7dm3cuHHD5LqbN2+OcePGISMjA4MGDUJ2djYOHz6M+fPnQ6VSYf369bCyspLaR0VF4dChQwCApUuX5jvg8MyZM1G+fHkkJiZi6dKlJtcEAHXq1AHw7/uViEouHld4XDGFWq1GlSpVABj/bFepVNiwYQOsrKwwe/ZsnDx5EpmZmRg4cCCysrLwwQcfoFGjRlJ7IQRmz54NABg+fDgaNmxodPv16tXDiBEjAACzZs2CKMRQ7NpjUn6156vQEfUlsHHjRgFAKJVKsX///kIt26pVKwFAHDhwQGe69hvae++9JxwcHISPj4/o1auXCA4OFjY2NgKA6NKli976cnJyRMeOHQUAoVKpREhIiOjdu7fw9fUVtra20un3Z7/55fdN9O+//xbe3t4CgHB3dxdhYWHijTfeEK6urtJp+idPnhRqv5/dT0PfRJVKpbC1tRUNGzYU3bp1E506dRK+vr4CgLCzsxOHDh3S2/d27doJAMLBwUG0b99e9O3bVwQHB0vfEE+fPq2zDAx8E01OThbt27cXAMTrr78uEhMTC71faWlponr16gKAmDRpkqhSpYoAIGbPnq3XduzYsQKAqFmzpknr1v4O69evrzO9oDOc//d//8cznESlBI8rPK5o5XeGUwghHV+MneHUmj59ugAgatSoIcaPHy8AiDp16oiMjAyddjExMdI+5Hd2U+vPP/+U2p85c0aaXtAZzlu3bj3XGc5XMnAmJycLT09PAUAoFArRunVrMXPmTPHzzz+Le/fu5btsQR8MAMRHH30ksrOzpXlnz54VdnZ2AoA4fPiwznKLFi2S/oBjY2Ol6dnZ2eK9996T1mnqB0NqaqrUJ3HKlCk6b8yUlBTRt29fAUCEh4eb8Erpy++DYcuWLeLp06c60zQajVi2bJkU0DQajTQvKipKABD16tUTSUlJeus7ceKE3mXoZz8Ybt68KQICAqR9evbSd2EcP35cKJVKaRtNmjTR+T1qtWjRolCv4fr166W+nFlZWdL0ggKntr/MyJEjzdofInpxeFzhcUUrv8B5/vx56ThTUDjMysoS9evXl+qzsrISMTExeu1Wr14tfbnIe4zJb73aewTWrFkjTS8ocGov27u4uLAPZ2HExsaKoKAg6cXN+xMQECC+/PJLg2GjoA+GBg0a6Lz5tYYPHy4AiE8++URnuvab2sqVK/WWycjIkD7ATP1g+PLLLwUA0bFjR4P7nZycLMqXLy8sLS3Fo0ePDLbJj7l9bZo0aSIA6PSR3Lp1qwAgxowZY/J68n4w/PXXX8LLy8vg62qusLAwg9/88vL395fOhJpi79690jrv3r0rTTcUODMzM8WFCxfE4MGDpffisx+ORFQy8bjC44oQhgPnkydPxL59+6Tjx5QpU0xa15YtW6T6IiIiDLb57LPPBADh5uZmco1ubm4CgJgzZ440zVjgTEhIEF9//bVwdHQUarVa/PTTTyZvJ69XdlikatWq4ejRozh+/Dh+/vlnHDt2DKdOncL9+/cRExODESNGYMeOHfj555/zHTrgWR07djQ4nlf16tUBALdu3ZKm3bx5E3FxcQCAfv366S2jUqnQo0cPLFq0yOTt//zzzwCA3r17G5xvb2+Phg0bYs+ePThx4gRCQkJMXrcpLl++jL179+Ly5ctITk5GTk4OgH/7e1y8eBE1atQAANSvXx9KpRJr1qxB1apV0a1bN7i7u5u0nX379qFnz57IyMjAxo0b8eabbz537ZGRkdi3b5/0782bN+sNSWEOUUAfmaioKIPvmTfeeAPbt28v1PuPiIoPjys8ruQVHh6O8PBwnWlKpRKbNm1C//79C1w+LS0N06ZNk/69e/duzJw5E7a2ts9VF1DwcalSpUp605ydnXHw4EGzj4uvbODUatSokdT5VgiB06dPY968ediyZQv279+PRYsWYcKECSavr0KFCganOzg4AADS09OlaTdv3gSQ+0vUjnf1rIoVK5q8bQDSB82AAQMwYMCAfNvev38fQO4YaF9//bXe/C5duqBLly4mbTcnJwejRo3CypUr830jJyUlSf/v5+eHL774AhMmTMCoUaMwatQo+Pj4oEmTJujYsSN69uxp9EO5Y8eOyM7ONvkPtyBJSUkYMmQIhBDSfsydOxddu3ZFYGCgTltnZ2cApneavnfvHgDAwsICr732mt78vONwpqam4q+//sI///yDH3/8EVOnTsWcOXOeZ9eI6AXjcYXHFUB3HM779+/j4MGDSE5OxogRI1ClShWdG38MmTx5Mi5evIgmTZpACIGjR49i0qRJWLx4sU477THp0aNHyM7OhqVl/tEuOztbunHK2E1u2nE4c3JycOPGDURHR+PBgwfo1asXDh06ZPBYVpBXPnDmpVAoUL9+fWzevBmpqanYvXs3du3aVagPhmcHDjd1u+bMM0Sj0QAAwsLC4Orqmm9bHx8fALnfHtevX683v2LFiiZ/MCxatAgrVqyAm5sbFixYgKZNm8LV1RVqtRpA7jftzZs3631ojB49Gr169cLu3bsRHR2N6OhobNmyBVu2bMG0adNw8OBBg99OBw0ahNWrV2Pq1Klo2rSpwW9jhTFu3DjEx8ejXbt2WLx4MZydnTF9+nQMHjwYp06d0rkTvUGDBoiOjsaxY8dMWvfx48cBAHXr1jX4QeDv76/3JI0lS5ZgzJgxmDt3Llq1aoUOHTqYv3NEVGx4XNH1Kh1X3n77bZ2RABITE9G1a1ccOHAAvXr1wvnz542erYyKisLixYthY2ODdevWQaPRoF69eli6dCm6d++uM+B7gwYNAOQO/H769Gm9kyTPiomJQVZWls6yz/r88891vpjExsaiXbt2iI2NxfDhw7F161ZTXgJdZl2IfwUsXbpUABBVq1bVmV5QXxtjd6WtXbtWr49KfHy81F/i2U7RWto7ok3ta/P6668LAGLbtm2m7GahGetro+239MMPPxhcrmHDhvm+PnlduHBB6pszcOBAnXna10uj0Uid3z09PcWFCxfM3SXx008/CSD3jkbtAO6ZmZmiXr16AoD44IMPdNr/9ttvUh1//vlnvutOS0uTBtqdNm2azryCbhp68803BZA7wK8pHcGJqGTjccWwl+24kt9NQ/fu3ZMeGjJz5kyDyycnJ4tKlSoJAOKLL76Qps+bN08AEL6+vjq/W41GIypWrCgAiFGjRhVY3+jRowUAUbFiRZ2+wQXdNLR//35p/h9//FHgdp71So7DKUwYdyo+Ph4A4OXlJVsd3t7e0jeIzZs3683PzMw0+Nzd/LRv3x4AzPv28Ry0p+e1327z+vvvvxETE2Pyuvz9/fHBBx8AgNHlFAoFFi5ciClTpuDWrVto2bJlobah9ejRIwwdOhQAsGDBAunSlZWVFdatWwcrKyt8/vnnOmcz27Rpg8aNGwMARo4caXQcPACYOnUq7t+/DwcHB4wcObJQtc2ZMwc2Nja4ePEiNm7cWNhdI6IXiMeVoldajyv5cXFxwZQpUwDknkV88uSJXpvx48fj6tWraNmyJd577z1pekREBJo2bYq4uDhpX7R1T5o0CQCwcuVK/Pnnn0a3f/r0aaxYsQJA7iX7wpztbteuHTp16gQg99hWWK9k4Fy+fDkGDRpk8CH2Qgjs3LlTGqS7T58+stYyZswYAMC0adPwzz//SNM1Gg0mT55c6IFmhw0bBh8fH2zbtg0ffPABkpOT9drcuXMHq1ater7Cn6HtvL5s2TLp8guQ+wzWgQMHIjs7W2+Z3377DXv27JFO7WsJIfDTTz8BMPxBk9fMmTMxd+5c3L9/H23atMGRI0cKVfeoUaOQkJCA9u3b46233tKZV6dOHUydOhU5OTkYPHiwTj+pTZs2wcnJCceOHUPHjh31fk9paWmYOHEiPv/8cygUCqxZs6bQA0J7eHhg9OjRAIBPP/3U4GtIRCUDjys8rpjq3XffRYUKFZCYmIj58+frzNu3bx+++uor2NnZYe3atTqB0MLCAmvXroWNjQ2WL1+u86CAYcOGoVOnTsjKykJYWJi0r3nt3bsXoaGhyMrKQqdOnaSTLYUxa9YsWFhYICoqCpGRkYVbuNDnRF8CX3zxhXRa2MXFRYSEhIh+/fqJDh06SKelAYg333xT5OTk6CxblJc+hMgdF007uKy1tbUICwsTffr0EX5+fsLGxka8++67AoAYOnSoznL5DdB77tw5aT+cnJxEy5YtRb9+/USXLl1EjRo1hEKhEK6uroV92XT289n9OHr0qDSuV+XKlUWvXr1EWFiYsLGxETVr1pSe8Zr39dH+HhwcHETr1q1Fv379RNeuXaXLEY6OjiYN0CtE7rAdCoVC2NnZmTwg7fbt26XX6ObNmwbb5B0HbcKECTrzzp07J41NZ2lpKZo3by769u0r2rdvLz26zN7eXmzdutXgugu6pC6EEI8ePRJOTk4CgPjqq69M2i8ievF4XOFxRauggd+FEGLNmjUCgChTpox4+PChEEKIx48fS0MyLVu2zOiyCxYsEABEpUqVdC6tp6en64zdWrlyZdG9e3fRo0cPabB5AGLAgAEGH8lc0CV1rYEDBwoAolmzZgW/GHm8koEzKSlJ7Nq1S4wePVo0atRIeHl5CSsrK2FjYyP8/PxE3759xS+//GJw2aL+YBAit7/g3LlzRY0aNYS1tbVwdnYWXbt2FWfPnhWffPKJACAmT56ss0xBz7xNSkoSc+fOFU2aNBFOTk7CyspKuLu7i8DAQDFhwgS9gYJNld94aWfOnBGdOnUS7u7uQq1WiypVqoiJEyeKpKQkg6/P5cuXxfTp00W7du1EhQoVhFqtFmXLlhV16tQRkyZNEjdu3NDbhrEPBiGE2LRpk7C0tBRqtVr8+OOP+e7H3bt3hbOzswAg1q9fn2/bs2fPCpVKJSwsLMSRI0d05mVkZIiVK1eKkJAQ4erqKqysrETZsmVFw4YNxccff5zvgM+mBE4hhJg9e7YAIHx8fPSeMEFEJQOPKzyuaJkSOLOzs0WNGjUE8O+Yztog165dO4Pjrmrl5OSI5s2bCwBixIgRevMPHTokwsPDhZ+fn7C1tRU2NjbC19dXDB48WERHRxtdr6mB89q1a8La2loAEHv37jXa7lkKIQrxIE164dq2bYsDBw5gx44d6NatW3GXQ0REpRyPK1QcXsk+nCVNTEwMMjMzdaZlZmZi+vTpOHDgAMqXL89hcYiIyGQ8rlBJw3E4S4CxY8ciJiYGdevWhbu7Ox4/foyzZ88iISEBarUa69evl8YdIyIiKgiPK1TS8JJ6CfDNN9/gm2++wZkzZ/Dw4UMIIeDh4YE2bdpg/Pjx0iO7iIiITMHjCpU0DJxEREREJCv24SQiIiIiWTFwEhEREZGsGDiJiIiISFYMnEREREQkKwZOIiIiIpIVAycRERERyYqBk4iIiIhkxcBJRERERLJi4CQiIiIiWf0/hgGd1xidBk4AAAAASUVORK5CYII=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "glPJZ2bxiX7E", + "outputId": "76e2d77a-1598-4312-f158-22fb09e0ea93" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[xor_accuracies, rxor_accuracies],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1],\n", + " [xor_accuracies.mean(), rxor_accuracies.mean()],\n", + " yerr=[xor_accuracies.std(), rxor_accuracies.std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Multi-Task XOR\", \"Multi-Task RXOR\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Multi-Task Learning Accuracy (XOR & RXOR)\", fontsize=16)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "source": [ + "single_task_xor_mean = np.mean(single_task_xor_accuracies)\n", + "single_task_xor_std = np.std(single_task_xor_accuracies)\n", + "single_task_rxor_mean = np.mean(single_task_rxor_accuracies)\n", + "single_task_rxor_std = np.std(single_task_rxor_accuracies)\n", + "multi_task_xor_mean = np.mean(xor_accuracies)\n", + "multi_task_xor_std = np.std(xor_accuracies)\n", + "multi_task_rxor_mean = np.mean(rxor_accuracies)\n", + "multi_task_rxor_std = np.std(rxor_accuracies)\n", + "\n", + "single_task_xor_time = training_time\n", + "single_task_rxor_time = training_time\n", + "multi_task_time = training_time\n", + "\n", + "print(f\"Single-Task XOR Accuracy: {single_task_xor_mean:.4f} ± {single_task_xor_std:.4f}\")\n", + "print(f\"Single-Task RXOR Accuracy: {single_task_rxor_mean:.4f} ± {single_task_rxor_std:.4f}\")\n", + "\n", + "print(f\"Multi-Task XOR Accuracy: {multi_task_xor_mean:.4f} ± {multi_task_xor_std:.4f}\")\n", + "print(f\"Multi-Task RXOR Accuracy: {multi_task_rxor_mean:.4f} ± {multi_task_rxor_std:.4f}\")\n", + "\n", + "print(f\"Single-Task XOR Training Time: {single_task_xor_time:.2f} sec\")\n", + "print(f\"Single-Task RXOR Training Time: {single_task_rxor_time:.2f} sec\")\n", + "\n", + "print(f\"Total Multi-Task Training Time: {multi_task_time:.2f} sec\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GYiY0hiE3UHH", + "outputId": "faa589a8-5be0-45d5-cc0a-c48365190143" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Single-Task XOR Accuracy: 0.9117 ± 0.0042\n", + "Single-Task RXOR Accuracy: 0.9488 ± 0.0039\n", + "Multi-Task XOR Accuracy: 0.9136 ± 0.0052\n", + "Multi-Task RXOR Accuracy: 0.9466 ± 0.0068\n", + "Single-Task XOR Training Time: 0.21 sec\n", + "Single-Task RXOR Training Time: 0.21 sec\n", + "Total Multi-Task Training Time: 0.21 sec\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##Hyperparamter Tunning for XOR/RXOR" + ], + "metadata": { + "id": "0VH5SRdBRfsI" + } + }, + { + "cell_type": "code", + "source": [ + "results = []\n", + "\n", + "for n_estimators in [100,200,500,1000,2000,5000]:\n", + " for feature_combinations in [1.0, 1.5, 2.0, 3.0]:\n", + " xor_accs, rxor_accs = [], []\n", + "\n", + " for _ in range(10):\n", + " clf = ObliqueRandomForestClassifier(\n", + " n_estimators=n_estimators,\n", + " feature_combinations=feature_combinations,\n", + " random_state=42\n", + " )\n", + " clf.fit(X_train_multi, y_train_multi)\n", + " xor_preds = clf.predict(X_test_multi_xor)\n", + " rxor_preds = clf.predict(X_test_multi_rxor)\n", + "\n", + " xor_accs.append(accuracy_score(y_test_xor, xor_preds))\n", + " rxor_accs.append(accuracy_score(y_test_rxor, rxor_preds))\n", + "\n", + " results.append({\n", + " \"n_estimators\": n_estimators,\n", + " \"feature_combinations\": feature_combinations,\n", + " \"xor_acc\": np.mean(xor_accs),\n", + " \"rxor_acc\": np.mean(rxor_accs)\n", + " })\n", + "\n", + "results_df = pd.DataFrame(results)" + ], + "metadata": { + "id": "GlpqctRTXgSm" + }, + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(12, 6))\n", + "sns.lineplot(\n", + " data=results_df,\n", + " x=\"n_estimators\",\n", + " y=\"xor_acc\",\n", + " hue=\"feature_combinations\",\n", + " marker=\"o\",\n", + " palette=\"Blues\"\n", + ")\n", + "plt.title(\"XOR Accuracy vs. n_estimators (by feature_combinations)\", fontsize=14)\n", + "plt.ylabel(\"XOR Accuracy\")\n", + "plt.xlabel(\"Number of Estimators\")\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "sns.lineplot(\n", + " data=results_df,\n", + " x=\"n_estimators\",\n", + " y=\"rxor_acc\",\n", + " hue=\"feature_combinations\",\n", + " marker=\"o\",\n", + " palette=\"Oranges\"\n", + ")\n", + "plt.title(\"rXOR Accuracy vs. n_estimators (by feature_combinations)\", fontsize=14)\n", + "plt.ylabel(\"rXOR Accuracy\")\n", + "plt.xlabel(\"Number of Estimators\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8HzzLu894BJD", + "outputId": "fb44b434-6804-4366-da1d-69584059ec9f" + }, + "execution_count": 58, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "results = []\n", + "for max_depth in [None, 5, 10, 20]:\n", + " for min_samples_split in [2, 5]:\n", + " for min_samples_leaf in [1, 5]:\n", + " for bootstrap in [True, False]:\n", + " xor_accs, rxor_accs = [], []\n", + "\n", + " for _ in range(10):\n", + " clf = ObliqueRandomForestClassifier(\n", + " n_estimators=200,\n", + " feature_combinations=2.0,\n", + " max_depth=max_depth,\n", + " min_samples_split=min_samples_split,\n", + " min_samples_leaf=min_samples_leaf,\n", + " bootstrap=bootstrap,\n", + " random_state=42\n", + " )\n", + " clf.fit(X_train_multi, y_train_multi)\n", + " xor_preds = clf.predict(X_test_multi_xor)\n", + " rxor_preds = clf.predict(X_test_multi_rxor)\n", + "\n", + " xor_accs.append(accuracy_score(y_test_xor, xor_preds))\n", + " rxor_accs.append(accuracy_score(y_test_rxor, rxor_preds))\n", + "\n", + " results.append({\n", + " \"max_depth\": max_depth,\n", + " \"min_samples_split\": min_samples_split,\n", + " \"min_samples_leaf\": min_samples_leaf,\n", + " \"bootstrap\": bootstrap,\n", + " \"xor_acc\": np.mean(xor_accs),\n", + " \"rxor_acc\": np.mean(rxor_accs)\n", + " })\n", + "\n", + "# Convert to DataFrame and display\n", + "results_df = pd.DataFrame(results)\n", + "results_df" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 815 + }, + "id": "F7FlP4qr_u-j", + "outputId": "ee9b585c-cf6d-4cf1-f1ef-6212003734ca" + }, + "execution_count": 61, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " max_depth min_samples_split min_samples_leaf bootstrap xor_acc \\\n", + "0 NaN 2 1 True 0.960 \n", + "1 NaN 2 1 False 0.955 \n", + "2 NaN 2 5 True 0.945 \n", + "3 NaN 2 5 False 0.945 \n", + "4 NaN 5 1 True 0.955 \n", + "5 NaN 5 1 False 0.960 \n", + "6 NaN 5 5 True 0.945 \n", + "7 NaN 5 5 False 0.945 \n", + "8 5.0 2 1 True 0.935 \n", + "9 5.0 2 1 False 0.920 \n", + "10 5.0 2 5 True 0.935 \n", + "11 5.0 2 5 False 0.935 \n", + "12 5.0 5 1 True 0.935 \n", + "13 5.0 5 1 False 0.925 \n", + "14 5.0 5 5 True 0.935 \n", + "15 5.0 5 5 False 0.935 \n", + "16 10.0 2 1 True 0.960 \n", + "17 10.0 2 1 False 0.955 \n", + "18 10.0 2 5 True 0.945 \n", + "19 10.0 2 5 False 0.945 \n", + "20 10.0 5 1 True 0.950 \n", + "21 10.0 5 1 False 0.960 \n", + "22 10.0 5 5 True 0.945 \n", + "23 10.0 5 5 False 0.945 \n", + "24 20.0 2 1 True 0.960 \n", + "25 20.0 2 1 False 0.955 \n", + "26 20.0 2 5 True 0.945 \n", + "27 20.0 2 5 False 0.945 \n", + "28 20.0 5 1 True 0.955 \n", + "29 20.0 5 1 False 0.960 \n", + "30 20.0 5 5 True 0.945 \n", + "31 20.0 5 5 False 0.945 \n", + "\n", + " rxor_acc \n", + "0 0.950 \n", + "1 0.945 \n", + "2 0.965 \n", + "3 0.965 \n", + "4 0.960 \n", + "5 0.965 \n", + "6 0.965 \n", + "7 0.965 \n", + "8 0.965 \n", + "9 0.970 \n", + "10 0.965 \n", + "11 0.965 \n", + "12 0.970 \n", + "13 0.970 \n", + "14 0.965 \n", + "15 0.965 \n", + "16 0.955 \n", + "17 0.955 \n", + "18 0.965 \n", + "19 0.965 \n", + "20 0.965 \n", + "21 0.960 \n", + "22 0.965 \n", + "23 0.965 \n", + "24 0.950 \n", + "25 0.945 \n", + "26 0.965 \n", + "27 0.965 \n", + "28 0.960 \n", + "29 0.965 \n", + "30 0.965 \n", + "31 0.965 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
max_depthmin_samples_splitmin_samples_leafbootstrapxor_accrxor_acc
0NaN21True0.9600.950
1NaN21False0.9550.945
2NaN25True0.9450.965
3NaN25False0.9450.965
4NaN51True0.9550.960
5NaN51False0.9600.965
6NaN55True0.9450.965
7NaN55False0.9450.965
85.021True0.9350.965
95.021False0.9200.970
105.025True0.9350.965
115.025False0.9350.965
125.051True0.9350.970
135.051False0.9250.970
145.055True0.9350.965
155.055False0.9350.965
1610.021True0.9600.955
1710.021False0.9550.955
1810.025True0.9450.965
1910.025False0.9450.965
2010.051True0.9500.965
2110.051False0.9600.960
2210.055True0.9450.965
2310.055False0.9450.965
2420.021True0.9600.950
2520.021False0.9550.945
2620.025True0.9450.965
2720.025False0.9450.965
2820.051True0.9550.960
2920.051False0.9600.965
3020.055True0.9450.965
3120.055False0.9450.965
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "results_df", + "summary": "{\n \"name\": \"results_df\",\n \"rows\": 32,\n \"fields\": [\n {\n \"column\": \"max_depth\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.370220572706061,\n \"min\": 5.0,\n \"max\": 20.0,\n \"num_unique_values\": 3,\n \"samples\": [\n 5.0,\n 10.0,\n 20.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"min_samples_split\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 2,\n \"max\": 5,\n \"num_unique_values\": 2,\n \"samples\": [\n 5,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"min_samples_leaf\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 1,\n \"max\": 5,\n \"num_unique_values\": 2,\n \"samples\": [\n 5,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"bootstrap\",\n \"properties\": {\n \"dtype\": \"boolean\",\n \"num_unique_values\": 2,\n \"samples\": [\n false,\n true\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"xor_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.010549422855334056,\n \"min\": 0.9200000000000002,\n \"max\": 0.9600000000000002,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.9600000000000002,\n 0.9549999999999998\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rxor_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006591477880199716,\n \"min\": 0.945,\n \"max\": 0.9700000000000001,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.9499999999999998,\n 0.945\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 61 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Spiral 3 vs Sprial 5\n" + ], + "metadata": { + "id": "G6bzznlFBwm8" + } + }, + { + "cell_type": "code", + "source": [ + "n_samples = 750\n", + "spiral3, y_spiral3 = generate_spirals(n_samples, 3, noise=0.8)\n", + "spiral5, y_spiral5 = generate_spirals(n_samples, 5, noise=0.4)\n", + "\n", + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(spiral3[:, 0], spiral3[:, 1], c=y_spiral3, cmap=\"viridis\", s=5)\n", + "plt.title(\"3 Spirals\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(spiral5[:, 0], spiral5[:, 1], c=y_spiral5, cmap=\"plasma\", s=5)\n", + "plt.title(\"5 Spirals\")\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + }, + "id": "CHrJNNdR_Nnc", + "outputId": "16591b3d-8ca4-4b54-81a1-259a36266bfe" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "num_trials = 100\n", + "\n", + "results = {\n", + " \"Spiral 3\": {\"accuracy\": [], \"time\": []},\n", + " \"Spiral 5\": {\"accuracy\": [], \"time\": []},\n", + " \"Multi-Task\": {\"accuracy\": [], \"time\": []}\n", + "}\n", + "\n", + "multi_task_spiral3_accuracies = []\n", + "multi_task_spiral5_accuracies = []\n", + "\n", + "for _ in range(num_trials):\n", + " spiral3, y_spiral3 = generate_spirals(750, 3, noise=0.8)\n", + " spiral5, y_spiral5 = generate_spirals(750, 5, noise=0.4)\n", + "\n", + " X_train_spiral3, X_test_spiral3, y_train_spiral3, y_test_spiral3 = train_test_split(spiral3, y_spiral3, test_size=0.2)\n", + " X_train_spiral5, X_test_spiral5, y_train_spiral5, y_test_spiral5 = train_test_split(spiral5, y_spiral5, test_size=0.2)\n", + "\n", + " scaler = StandardScaler()\n", + " X_train_all = np.vstack([X_train_spiral3, X_train_spiral5])\n", + " scaler.fit(X_train_all)\n", + "\n", + " X_train_spiral3 = scaler.transform(X_train_spiral3)\n", + " X_train_spiral5 = scaler.transform(X_train_spiral5)\n", + " X_test_spiral3 = scaler.transform(X_test_spiral3)\n", + " X_test_spiral5 = scaler.transform(X_test_spiral5)\n", + "\n", + " start = time.time()\n", + " sporf = ObliqueRandomForestClassifier(n_estimators=100)\n", + " sporf.fit(X_train_spiral3, y_train_spiral3)\n", + " y_pred = sporf.predict(X_test_spiral3)\n", + " results[\"Spiral 3\"][\"accuracy\"].append(accuracy_score(y_test_spiral3, y_pred))\n", + " results[\"Spiral 3\"][\"time\"].append(time.time() - start)\n", + "\n", + " start = time.time()\n", + " sporf.fit(X_train_spiral5, y_train_spiral5)\n", + " y_pred = sporf.predict(X_test_spiral5)\n", + " results[\"Spiral 5\"][\"accuracy\"].append(accuracy_score(y_test_spiral5, y_pred))\n", + " results[\"Spiral 5\"][\"time\"].append(time.time() - start)\n", + "\n", + " X_train_multi = np.vstack([X_train_spiral3, X_train_spiral5])\n", + " y_train_multi = np.concatenate([y_train_spiral3, y_train_spiral5])\n", + " task_labels_train = np.concatenate([np.zeros(len(y_train_spiral3)), np.ones(len(y_train_spiral5))])\n", + " X_train_multi = np.column_stack((X_train_multi, task_labels_train))\n", + "\n", + " X_test_multi = np.vstack([X_test_spiral3, X_test_spiral5])\n", + " y_test_multi = np.concatenate([y_test_spiral3, y_test_spiral5])\n", + " task_labels_test = np.concatenate([np.zeros(len(y_test_spiral3)), np.ones(len(y_test_spiral5))])\n", + " X_test_multi = np.column_stack((X_test_multi, task_labels_test))\n", + "\n", + " start = time.time()\n", + " sporf.fit(X_train_multi, y_train_multi)\n", + " y_pred_multi = sporf.predict(X_test_multi)\n", + " results[\"Multi-Task\"][\"accuracy\"].append(accuracy_score(y_test_multi, y_pred_multi))\n", + " results[\"Multi-Task\"][\"time\"].append(time.time() - start)\n", + "\n", + " X_test_spiral3_with_task = np.column_stack((X_test_spiral3, np.zeros(len(y_test_spiral3))))\n", + " X_test_spiral5_with_task = np.column_stack((X_test_spiral5, np.ones(len(y_test_spiral5))))\n", + "\n", + " y_pred_spiral3 = sporf.predict(X_test_spiral3_with_task)\n", + " y_pred_spiral5 = sporf.predict(X_test_spiral5_with_task)\n", + "\n", + " multi_task_spiral3_accuracies.append(accuracy_score(y_test_spiral3, y_pred_spiral3))\n", + " multi_task_spiral5_accuracies.append(accuracy_score(y_test_spiral5, y_pred_spiral5))\n" + ], + "metadata": { + "id": "SOi9BoGiB4a5" + }, + "execution_count": 69, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "results = []\n", + "\n", + "for n_estimators in [100, 200, 500, 1000,2000,5000]:\n", + " for feature_combinations in [1.5, 2.0]:\n", + " clf = ObliqueRandomForestClassifier(\n", + " n_estimators=n_estimators,\n", + " feature_combinations=feature_combinations,\n", + " max_depth=10,\n", + " random_state=42\n", + " )\n", + " clf.fit(X_train_spiral3, y_train_spiral3)\n", + " acc3_single = accuracy_score(y_test_spiral3, clf.predict(X_test_spiral3))\n", + "\n", + " clf.fit(X_train_spiral5, y_train_spiral5)\n", + " acc5_single = accuracy_score(y_test_spiral5, clf.predict(X_test_spiral5))\n", + " clf.fit(X_train_multi, y_train_multi)\n", + " X_test3_multi = np.column_stack((X_test_spiral3, np.zeros(len(y_test_spiral3))))\n", + " acc3_multi = accuracy_score(y_test_spiral3, clf.predict(X_test3_multi))\n", + " X_test5_multi = np.column_stack((X_test_spiral5, np.ones(len(y_test_spiral5))))\n", + " acc5_multi = accuracy_score(y_test_spiral5, clf.predict(X_test5_multi))\n", + "\n", + " results.append({\n", + " \"n_estimators\": n_estimators,\n", + " \"feature_combinations\": feature_combinations,\n", + " \"max_depth\": max_depth,\n", + " \"spiral3_acc_single\": acc3_single,\n", + " \"spiral5_acc_single\": acc5_single,\n", + " \"spiral3_acc_multi\": acc3_multi,\n", + " \"spiral5_acc_multi\": acc5_multi\n", + " })\n", + "\n", + "spiral_results_df = pd.DataFrame(results)\n", + "spiral_results_df\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 425 + }, + "id": "ACmXW8kEKKiP", + "outputId": "324ddffc-c0b7-495c-fb0e-e78dfb01a7d1" + }, + "execution_count": 92, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " n_estimators feature_combinations max_depth spiral3_acc_single \\\n", + "0 100 1.5 10 0.646667 \n", + "1 100 2.0 10 0.713333 \n", + "2 200 1.5 10 0.640000 \n", + "3 200 2.0 10 0.706667 \n", + "4 500 1.5 10 0.620000 \n", + "5 500 2.0 10 0.700000 \n", + "6 1000 1.5 10 0.620000 \n", + "7 1000 2.0 10 0.706667 \n", + "8 2000 1.5 10 0.613333 \n", + "9 2000 2.0 10 0.713333 \n", + "10 5000 1.5 10 0.613333 \n", + "11 5000 2.0 10 0.706667 \n", + "\n", + " spiral5_acc_single spiral3_acc_multi spiral5_acc_multi \n", + "0 0.640000 0.566667 0.493333 \n", + "1 0.680000 0.680000 0.706667 \n", + "2 0.660000 0.566667 0.493333 \n", + "3 0.680000 0.680000 0.700000 \n", + "4 0.660000 0.580000 0.486667 \n", + "5 0.660000 0.700000 0.693333 \n", + "6 0.666667 0.573333 0.466667 \n", + "7 0.673333 0.686667 0.706667 \n", + "8 0.646667 0.573333 0.473333 \n", + "9 0.673333 0.673333 0.693333 \n", + "10 0.640000 0.566667 0.493333 \n", + "11 0.673333 0.680000 0.700000 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
n_estimatorsfeature_combinationsmax_depthspiral3_acc_singlespiral5_acc_singlespiral3_acc_multispiral5_acc_multi
01001.5100.6466670.6400000.5666670.493333
11002.0100.7133330.6800000.6800000.706667
22001.5100.6400000.6600000.5666670.493333
32002.0100.7066670.6800000.6800000.700000
45001.5100.6200000.6600000.5800000.486667
55002.0100.7000000.6600000.7000000.693333
610001.5100.6200000.6666670.5733330.466667
710002.0100.7066670.6733330.6866670.706667
820001.5100.6133330.6466670.5733330.473333
920002.0100.7133330.6733330.6733330.693333
1050001.5100.6133330.6400000.5666670.493333
1150002.0100.7066670.6733330.6800000.700000
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "spiral_results_df", + "summary": "{\n \"name\": \"spiral_results_df\",\n \"rows\": 12,\n \"fields\": [\n {\n \"column\": \"n_estimators\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1778,\n \"min\": 100,\n \"max\": 5000,\n \"num_unique_values\": 6,\n \"samples\": [\n 100,\n 200,\n 5000\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"feature_combinations\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.26111648393354675,\n \"min\": 1.5,\n \"max\": 2.0,\n \"num_unique_values\": 2,\n \"samples\": [\n 2.0,\n 1.5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"max_depth\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 10,\n \"max\": 10,\n \"num_unique_values\": 1,\n \"samples\": [\n 10\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral3_acc_single\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.04413020221429706,\n \"min\": 0.6133333333333333,\n \"max\": 0.7133333333333334,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.6466666666666666\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral5_acc_single\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.014343078669654783,\n \"min\": 0.64,\n \"max\": 0.68,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.64\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral3_acc_multi\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.059046862630727365,\n \"min\": 0.5666666666666667,\n \"max\": 0.7,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.5666666666666667\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral5_acc_multi\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.11291664337097675,\n \"min\": 0.4666666666666667,\n \"max\": 0.7066666666666667,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.49333333333333335\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 92 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10, 5))\n", + "for fc in [1.5, 2.0]:\n", + " subset = spiral_results_df[spiral_results_df[\"feature_combinations\"] == fc]\n", + " plt.plot(\n", + " subset[\"n_estimators\"],\n", + " subset[\"spiral3_acc_multi\"],\n", + " marker='o',\n", + " label=f'Multi Spiral 3 (fc={fc})'\n", + " )\n", + "\n", + "plt.title(\"Multi-Task Spiral 3 Accuracy vs n_estimators\")\n", + "plt.xlabel(\"n_estimators\")\n", + "plt.ylabel(\"Accuracy\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "for fc in [1.5, 2.0]:\n", + " subset = spiral_results_df[spiral_results_df[\"feature_combinations\"] == fc]\n", + " plt.plot(\n", + " subset[\"n_estimators\"],\n", + " subset[\"spiral5_acc_multi\"],\n", + " marker='o',\n", + " label=f'Multi Spiral 5 (fc={fc})'\n", + " )\n", + "\n", + "plt.title(\"Multi-Task Spiral 5 Accuracy vs n_estimators\")\n", + "plt.xlabel(\"n_estimators\")\n", + "plt.ylabel(\"Accuracy\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 957 + }, + "id": "qNiJY2ITXdW9", + "outputId": "504316ad-2263-45c6-eb03-99b55dec533b" + }, + "execution_count": 98, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "results = []\n", + "\n", + "for max_depth in [None, 5, 10, 20]:\n", + " for min_samples_split in [2, 5]:\n", + " for min_samples_leaf in [1, 5]:\n", + " for bootstrap in [True, False]:\n", + " spiral3_accs, spiral5_accs = [], []\n", + "\n", + " for _ in range(10):\n", + " clf = ObliqueRandomForestClassifier(\n", + " n_estimators=200,\n", + " feature_combinations=2.0,\n", + " max_depth=max_depth,\n", + " min_samples_split=min_samples_split,\n", + " min_samples_leaf=min_samples_leaf,\n", + " bootstrap=bootstrap,\n", + " random_state=42\n", + " )\n", + " clf.fit(X_train_multi, y_train_multi)\n", + "\n", + " # Spiral 3 prediction (task label = 0)\n", + " X_test3_multi = np.column_stack((X_test_spiral3, np.zeros(len(y_test_spiral3))))\n", + " preds_3 = clf.predict(X_test3_multi)\n", + " spiral3_accs.append(accuracy_score(y_test_spiral3, preds_3))\n", + "\n", + " # Spiral 5 prediction (task label = 1)\n", + " X_test5_multi = np.column_stack((X_test_spiral5, np.ones(len(y_test_spiral5))))\n", + " preds_5 = clf.predict(X_test5_multi)\n", + " spiral5_accs.append(accuracy_score(y_test_spiral5, preds_5))\n", + "\n", + " results.append({\n", + " \"max_depth\": max_depth,\n", + " \"min_samples_split\": min_samples_split,\n", + " \"min_samples_leaf\": min_samples_leaf,\n", + " \"bootstrap\": bootstrap,\n", + " \"spiral3_acc\": np.mean(spiral3_accs),\n", + " \"spiral5_acc\": np.mean(spiral5_accs)\n", + " })\n", + "\n", + "# Convert to DataFrame\n", + "spiral_tuning_df = pd.DataFrame(results)\n", + "spiral_tuning_df\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1910 + }, + "id": "YQgB_y9Lh9BS", + "outputId": "7bdb9678-b605-48df-b089-e530bc220f8b" + }, + "execution_count": 99, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " max_depth min_samples_split min_samples_leaf bootstrap spiral3_acc \\\n", + "0 NaN 2 1 True 0.713333 \n", + "1 NaN 2 1 False 0.640000 \n", + "2 NaN 2 5 True 0.733333 \n", + "3 NaN 2 5 False 0.706667 \n", + "4 NaN 5 1 True 0.720000 \n", + "5 NaN 5 1 False 0.666667 \n", + "6 NaN 5 5 True 0.733333 \n", + "7 NaN 5 5 False 0.706667 \n", + "8 5.0 2 1 True 0.600000 \n", + "9 5.0 2 1 False 0.526667 \n", + "10 5.0 2 5 True 0.573333 \n", + "11 5.0 2 5 False 0.546667 \n", + "12 5.0 5 1 True 0.580000 \n", + "13 5.0 5 1 False 0.546667 \n", + "14 5.0 5 5 True 0.573333 \n", + "15 5.0 5 5 False 0.546667 \n", + "16 10.0 2 1 True 0.680000 \n", + "17 10.0 2 1 False 0.660000 \n", + "18 10.0 2 5 True 0.693333 \n", + "19 10.0 2 5 False 0.700000 \n", + "20 10.0 5 1 True 0.706667 \n", + "21 10.0 5 1 False 0.660000 \n", + "22 10.0 5 5 True 0.693333 \n", + "23 10.0 5 5 False 0.700000 \n", + "24 20.0 2 1 True 0.706667 \n", + "25 20.0 2 1 False 0.660000 \n", + "26 20.0 2 5 True 0.726667 \n", + "27 20.0 2 5 False 0.706667 \n", + "28 20.0 5 1 True 0.726667 \n", + "29 20.0 5 1 False 0.660000 \n", + "30 20.0 5 5 True 0.726667 \n", + "31 20.0 5 5 False 0.706667 \n", + "\n", + " spiral5_acc \n", + "0 0.733333 \n", + "1 0.726667 \n", + "2 0.686667 \n", + "3 0.693333 \n", + "4 0.713333 \n", + "5 0.706667 \n", + "6 0.686667 \n", + "7 0.693333 \n", + "8 0.433333 \n", + "9 0.440000 \n", + "10 0.406667 \n", + "11 0.420000 \n", + "12 0.433333 \n", + "13 0.433333 \n", + "14 0.406667 \n", + "15 0.420000 \n", + "16 0.700000 \n", + "17 0.713333 \n", + "18 0.653333 \n", + "19 0.686667 \n", + "20 0.700000 \n", + "21 0.686667 \n", + "22 0.653333 \n", + "23 0.686667 \n", + "24 0.726667 \n", + "25 0.706667 \n", + "26 0.680000 \n", + "27 0.693333 \n", + "28 0.720000 \n", + "29 0.706667 \n", + "30 0.680000 \n", + "31 0.693333 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
max_depthmin_samples_splitmin_samples_leafbootstrapspiral3_accspiral5_acc
0NaN21True0.7133330.733333
1NaN21False0.6400000.726667
2NaN25True0.7333330.686667
3NaN25False0.7066670.693333
4NaN51True0.7200000.713333
5NaN51False0.6666670.706667
6NaN55True0.7333330.686667
7NaN55False0.7066670.693333
85.021True0.6000000.433333
95.021False0.5266670.440000
105.025True0.5733330.406667
115.025False0.5466670.420000
125.051True0.5800000.433333
135.051False0.5466670.433333
145.055True0.5733330.406667
155.055False0.5466670.420000
1610.021True0.6800000.700000
1710.021False0.6600000.713333
1810.025True0.6933330.653333
1910.025False0.7000000.686667
2010.051True0.7066670.700000
2110.051False0.6600000.686667
2210.055True0.6933330.653333
2310.055False0.7000000.686667
2420.021True0.7066670.726667
2520.021False0.6600000.706667
2620.025True0.7266670.680000
2720.025False0.7066670.693333
2820.051True0.7266670.720000
2920.051False0.6600000.706667
3020.055True0.7266670.680000
3120.055False0.7066670.693333
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "spiral_tuning_df", + "summary": "{\n \"name\": \"spiral_tuning_df\",\n \"rows\": 32,\n \"fields\": [\n {\n \"column\": \"max_depth\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.370220572706061,\n \"min\": 5.0,\n \"max\": 20.0,\n \"num_unique_values\": 3,\n \"samples\": [\n 5.0,\n 10.0,\n 20.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"min_samples_split\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 2,\n \"max\": 5,\n \"num_unique_values\": 2,\n \"samples\": [\n 5,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"min_samples_leaf\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 1,\n \"max\": 5,\n \"num_unique_values\": 2,\n \"samples\": [\n 5,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"bootstrap\",\n \"properties\": {\n \"dtype\": \"boolean\",\n \"num_unique_values\": 2,\n \"samples\": [\n false,\n true\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral3_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06496759600343814,\n \"min\": 0.5266666666666666,\n \"max\": 0.7333333333333333,\n \"num_unique_values\": 16,\n \"samples\": [\n 0.7133333333333333,\n 0.6399999999999999\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"spiral5_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.1214185863790201,\n \"min\": 0.4066666666666666,\n \"max\": 0.7333333333333333,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.42000000000000004,\n 0.6533333333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 99 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

Distributions

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_15['index'].plot(kind='hist', bins=20, title='index')\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_16['max_depth'].plot(kind='hist', bins=20, title='max_depth')\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_17['min_samples_split'].plot(kind='hist', bins=20, title='min_samples_split')\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_18['min_samples_leaf'].plot(kind='hist', bins=20, title='min_samples_leaf')\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

Categorical distributions

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "_df_19.groupby('bootstrap').size().plot(kind='barh', color=sns.palettes.mpl_palette('Dark2'))\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

2-d distributions

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_20.plot(kind='scatter', x='index', y='max_depth', s=32, alpha=.8)\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_21.plot(kind='scatter', x='max_depth', y='min_samples_split', s=32, alpha=.8)\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_22.plot(kind='scatter', x='min_samples_split', y='min_samples_leaf', s=32, alpha=.8)\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_23.plot(kind='scatter', x='min_samples_leaf', y='spiral3_acc', s=32, alpha=.8)\n", + "plt.gca().spines[['top', 'right',]].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

Time series

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "def _plot_series(series, series_name, series_index=0):\n", + " palette = list(sns.palettes.mpl_palette('Dark2'))\n", + " xs = series['index']\n", + " ys = series['max_depth']\n", + " \n", + " plt.plot(xs, ys, label=series_name, color=palette[series_index % len(palette)])\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5.2), layout='constrained')\n", + "df_sorted = _df_24.sort_values('index', ascending=True)\n", + "for i, (series_name, series) in enumerate(df_sorted.groupby('bootstrap')):\n", + " _plot_series(series, series_name, i)\n", + " fig.legend(title='bootstrap', bbox_to_anchor=(1, 1), loc='upper left')\n", + "sns.despine(fig=fig, ax=ax)\n", + "plt.xlabel('index')\n", + "_ = plt.ylabel('max_depth')" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "def _plot_series(series, series_name, series_index=0):\n", + " palette = list(sns.palettes.mpl_palette('Dark2'))\n", + " xs = series['index']\n", + " ys = series['min_samples_split']\n", + " \n", + " plt.plot(xs, ys, label=series_name, color=palette[series_index % len(palette)])\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5.2), layout='constrained')\n", + "df_sorted = _df_25.sort_values('index', ascending=True)\n", + "for i, (series_name, series) in enumerate(df_sorted.groupby('bootstrap')):\n", + " _plot_series(series, series_name, i)\n", + " fig.legend(title='bootstrap', bbox_to_anchor=(1, 1), loc='upper left')\n", + "sns.despine(fig=fig, ax=ax)\n", + "plt.xlabel('index')\n", + "_ = plt.ylabel('min_samples_split')" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "def _plot_series(series, series_name, series_index=0):\n", + " palette = list(sns.palettes.mpl_palette('Dark2'))\n", + " xs = series['index']\n", + " ys = series['min_samples_leaf']\n", + " \n", + " plt.plot(xs, ys, label=series_name, color=palette[series_index % len(palette)])\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5.2), layout='constrained')\n", + "df_sorted = _df_26.sort_values('index', ascending=True)\n", + "for i, (series_name, series) in enumerate(df_sorted.groupby('bootstrap')):\n", + " _plot_series(series, series_name, i)\n", + " fig.legend(title='bootstrap', bbox_to_anchor=(1, 1), loc='upper left')\n", + "sns.despine(fig=fig, ax=ax)\n", + "plt.xlabel('index')\n", + "_ = plt.ylabel('min_samples_leaf')" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "def _plot_series(series, series_name, series_index=0):\n", + " palette = list(sns.palettes.mpl_palette('Dark2'))\n", + " xs = series['index']\n", + " ys = series['spiral3_acc']\n", + " \n", + " plt.plot(xs, ys, label=series_name, color=palette[series_index % len(palette)])\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5.2), layout='constrained')\n", + "df_sorted = _df_27.sort_values('index', ascending=True)\n", + "for i, (series_name, series) in enumerate(df_sorted.groupby('bootstrap')):\n", + " _plot_series(series, series_name, i)\n", + " fig.legend(title='bootstrap', bbox_to_anchor=(1, 1), loc='upper left')\n", + "sns.despine(fig=fig, ax=ax)\n", + "plt.xlabel('index')\n", + "_ = plt.ylabel('spiral3_acc')" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

Values

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_28['index'].plot(kind='line', figsize=(8, 4), title='index')\n", + "plt.gca().spines[['top', 'right']].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_29['max_depth'].plot(kind='line', figsize=(8, 4), title='max_depth')\n", + "plt.gca().spines[['top', 'right']].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_30['min_samples_split'].plot(kind='line', figsize=(8, 4), title='min_samples_split')\n", + "plt.gca().spines[['top', 'right']].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "_df_31['min_samples_leaf'].plot(kind='line', figsize=(8, 4), title='min_samples_leaf')\n", + "plt.gca().spines[['top', 'right']].set_visible(False)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "

Faceted distributions

\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "figsize = (12, 1.2 * len(_df_32['bootstrap'].unique()))\n", + "plt.figure(figsize=figsize)\n", + "sns.violinplot(_df_32, x='index', y='bootstrap', inner='stick', palette='Dark2')\n", + "sns.despine(top=True, right=True, bottom=True, left=True)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "figsize = (12, 1.2 * len(_df_33['bootstrap'].unique()))\n", + "plt.figure(figsize=figsize)\n", + "sns.violinplot(_df_33, x='max_depth', y='bootstrap', inner='stick', palette='Dark2')\n", + "sns.despine(top=True, right=True, bottom=True, left=True)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "figsize = (12, 1.2 * len(_df_34['bootstrap'].unique()))\n", + "plt.figure(figsize=figsize)\n", + "sns.violinplot(_df_34, x='min_samples_split', y='bootstrap', inner='stick', palette='Dark2')\n", + "sns.despine(top=True, right=True, bottom=True, left=True)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "figsize = (12, 1.2 * len(_df_35['bootstrap'].unique()))\n", + "plt.figure(figsize=figsize)\n", + "sns.violinplot(_df_35, x='min_samples_leaf', y='bootstrap', inner='stick', palette='Dark2')\n", + "sns.despine(top=True, right=True, bottom=True, left=True)" + ], + "text/html": [ + "
\n", + " \n", + "
\n", + " \n", + " " + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "for key in results:\n", + " results[key][\"accuracy\"] = np.array(results[key][\"accuracy\"])\n", + " results[key][\"time\"] = np.array(results[key][\"time\"])\n", + "\n", + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"Spiral 3\"][\"accuracy\"], results[\"Spiral 5\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1], [results[\"Spiral 3\"][\"accuracy\"].mean(), results[\"Spiral 5\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"Spiral 3\"][\"accuracy\"].std(), results[\"Spiral 5\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Single-Task Spiral 3\", \"Single-Task Spiral 5\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Single-Task Learning Accuracy (Spiral 3 & Spiral 5)\", fontsize=16)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "xTZpH2BsCNeV", + "outputId": "90904141-7b7a-45f4-9ab0-85a5ef723781" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(7, 5))\n", + "sns.stripplot(data=[results[\"Multi-Task\"][\"accuracy\"], results[\"Multi-Task\"][\"accuracy\"]],\n", + " jitter=True, size=8)\n", + "\n", + "plt.errorbar([0, 1], [results[\"Multi-Task\"][\"accuracy\"].mean(), results[\"Multi-Task\"][\"accuracy\"].mean()],\n", + " yerr=[results[\"Multi-Task\"][\"accuracy\"].std(), results[\"Multi-Task\"][\"accuracy\"].std()],\n", + " fmt=\"o\", color=\"black\", capsize=5, zorder=3)\n", + "\n", + "plt.xticks([0, 1], [\"Multi-Task Spiral 3\", \"Multi-Task Spiral 5\"], fontsize=16)\n", + "plt.ylabel(\"Accuracy\", fontsize=14)\n", + "plt.title(\"Multi-Task Learning Accuracy (Spiral 3 & Spiral 5)\", fontsize=16)\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 476 + }, + "id": "fHTqKiy_RjYM", + "outputId": "16445803-ec1f-455a-80ab-b250f53bc10f" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "spiral3_mean = np.mean(results[\"Spiral 3\"][\"accuracy\"])\n", + "spiral3_std = np.std(results[\"Spiral 3\"][\"accuracy\"])\n", + "spiral5_mean = np.mean(results[\"Spiral 5\"][\"accuracy\"])\n", + "spiral5_std = np.std(results[\"Spiral 5\"][\"accuracy\"])\n", + "\n", + "multi_task_spiral3_mean = np.mean(multi_task_spiral3_accuracies)\n", + "multi_task_spiral3_std = np.std(multi_task_spiral3_accuracies)\n", + "multi_task_spiral5_mean = np.mean(multi_task_spiral5_accuracies)\n", + "multi_task_spiral5_std = np.std(multi_task_spiral5_accuracies)\n", + "\n", + "spiral3_time_mean = np.mean(results[\"Spiral 3\"][\"time\"])\n", + "spiral3_time_std = np.std(results[\"Spiral 3\"][\"time\"])\n", + "spiral5_time_mean = np.mean(results[\"Spiral 5\"][\"time\"])\n", + "spiral5_time_std = np.std(results[\"Spiral 5\"][\"time\"])\n", + "multi_task_time_mean = np.mean(results[\"Multi-Task\"][\"time\"])\n", + "multi_task_time_std = np.std(results[\"Multi-Task\"][\"time\"])\n", + "\n", + "\n", + "print(f\"Spiral 3 Accuracy: {spiral3_mean:.4f} ± {spiral3_std:.4f}\")\n", + "print(f\"Spiral 3 Training Time: {spiral3_time_mean:.2f} sec ± {spiral3_time_std:.2f} sec\")\n", + "\n", + "print(f\"Spiral 5 Accuracy: {spiral5_mean:.4f} ± {spiral5_std:.4f}\")\n", + "print(f\"Spiral 5 Training Time: {spiral5_time_mean:.2f} sec ± {spiral5_time_std:.2f} sec\")\n", + "\n", + "print(f\"Multi-Task Spiral 3 Accuracy: {multi_task_spiral3_mean:.4f} ± {multi_task_spiral3_std:.4f}\")\n", + "print(f\"Multi-Task Spiral 5 Accuracy: {multi_task_spiral5_mean:.4f} ± {multi_task_spiral5_std:.4f}\")\n", + "\n", + "print(f\"Total Multi-Task Training Time: {multi_task_time_mean:.2f} sec ± {multi_task_time_std:.2f} sec\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z5LiMz2ESvOF", + "outputId": "a7ee2781-e982-404a-c2d6-8c4cf04a4b75" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Spiral 3 Accuracy: 0.7293 ± 0.0350\n", + "Spiral 3 Training Time: 0.26 sec ± 0.05 sec\n", + "Spiral 5 Accuracy: 0.7715 ± 0.0386\n", + "Spiral 5 Training Time: 0.27 sec ± 0.05 sec\n", + "Multi-Task Spiral 3 Accuracy: 0.6505 ± 0.0550\n", + "Multi-Task Spiral 5 Accuracy: 0.6564 ± 0.0605\n", + "Total Multi-Task Training Time: 0.25 sec ± 0.05 sec\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/multi_task_forest1.py b/multi_task_forest1.py new file mode 100644 index 0000000..af2b2bd --- /dev/null +++ b/multi_task_forest1.py @@ -0,0 +1,109 @@ +# -*- coding: utf-8 -*- +"""MultiTaskClf.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1d7ipMRMx9b10KeaPRe-yLQq5tAo6Wnvd +""" + +import numpy as np +from sklearn.metrics import accuracy_score +from treeple import ObliqueRandomForestClassifier + +class MultiTaskForestClassifier: + def __init__(self, clf_type="SPORF", **kwargs): + if clf_type == "SPORF": + self.model_cls = ObliqueRandomForestClassifier + self.default_params = { + "n_estimators": 200, + "feature_combinations": 2.0, + "max_depth": 20, + "min_samples_split": 5, + "min_samples_leaf": 1, + "max_features": 0.5, + "bootstrap": True + } + elif clf_type == "MORF": + self.model_cls = MORFClassifier # Liora + self.default_params = { ... } + elif clf_type == "HonestForest": + self.model_cls = HonestForestClassifier # Riya + self.default_params = { ... } + else: + raise ValueError(f"Unsupported tree: {clf_type}") + + self.params = {**self.default_params, **kwargs} + self.model = None + self.task_data = {} + + def add_task(self, task_id, X, y): + self.task_data[task_id] = (X, y) + + def fit(self, task_ids): + X_all, y_all, task_labels = [], [], [] + for task_id in task_ids: + X, y = self.task_data[task_id] + X_all.append(X) + y_all.append(y) + task_labels.append(np.full(len(y), task_id)) + + X_all = np.vstack(X_all) + y_all = np.concatenate(y_all) + task_labels = np.concatenate(task_labels) + X_all = np.column_stack((X_all, task_labels)) + + self.model = self.model_cls(**self.params, random_state=42) + self.model.fit(X_all, y_all) + + def predict(self, X, task_id): + X_task = np.column_stack((X, np.full(len(X), task_id))) + return self.model.predict(X_task) + + def score(self, X, y, task_id): + return accuracy_score(y, self.predict(X, task_id)) + + def evaluate_transfer_general(self, forward_train_ids, forward_test_id, backward_train_ids, backward_test_ids, do_reverse=False): + """ + - Forward: train on `forward_train_ids`, test on `forward_test_id` + - Backward: train on `backward_train_ids`, test individually on each in `backward_test_ids` + - Reverse (not mandatory. default as False but can change to true): train on `forward_test_id`, test on `forward_train_ids` + """ + results = {} + + # Forward + self.fit(forward_train_ids) + X_test, y_test = self.task_data[forward_test_id] + forward_acc = self.score(X_test, y_test, task_id=forward_test_id) + results["forward_transfer"] = { + "train_on": forward_train_ids, + "test_on": forward_test_id, + "accuracy": forward_acc + } + + # Backward + self.fit(backward_train_ids) + backward_accuracies = {} + for tid in backward_test_ids: + X, y = self.task_data[tid] + backward_accuracies[f"task{tid}"] = { + "train_on": backward_train_ids, + "test_on": tid, + "accuracy": self.score(X, y, task_id=tid) + } + results["backward_transfer"] = backward_accuracies + + # Reverse + if do_reverse: + self.fit([forward_test_id]) + reverse_accuracies = {} + for tid in forward_train_ids: + X, y = self.task_data[tid] + reverse_accuracies[f"task{tid}"] = { + "train_on": [forward_test_id], + "test_on": tid, + "accuracy": self.score(X, y, task_id=tid) + } + results["reverse_transfer"] = reverse_accuracies + + return results \ No newline at end of file diff --git a/multitaskclf.py b/multitaskclf.py new file mode 100644 index 0000000..051e2a9 --- /dev/null +++ b/multitaskclf.py @@ -0,0 +1,78 @@ +# -*- coding: utf-8 -*- +"""MultiTaskClf.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1d7ipMRMx9b10KeaPRe-yLQq5tAo6Wnvd +""" + +import numpy as np +from sklearn.metrics import accuracy_score +from treeple import ObliqueRandomForestClassifier + +class MultiTaskForestClassifier: + def __init__(self, clf_type="SPORF", **kwargs): + if clf_type == "SPORF": + self.model_cls = ObliqueRandomForestClassifier + self.default_params = { + "n_estimators": 200, + "feature_combinations": 2.0, + "max_depth": 20, + "min_samples_split": 5, + "min_samples_leaf": 1, + "max_features": 0.5, + "bootstrap": True + } + elif clf_type == "MORF": + self.model_cls = MORFClassifier # Liora + self.default_params = { ... } + elif clf_type == "HonestForest": + self.model_cls = HonestForestClassifier # Riya + self.default_params = { ... } + else: + raise ValueError(f"Unsupported tree: {clf_type}") + + self.params = {**self.default_params, **kwargs} + self.model = None + self.task_data = {} + + def add_task(self, task_id, X_train, y_train, X_test, y_test): + """Add both training and testing data for each task.""" + self.task_data[task_id] = { + "train": (X_train, y_train), + "test": (X_test, y_test) + } + + def get_task_ids(self): + return list(self.task_data.keys()) + + def fit(self): + """Train on all tasks jointly (multi-task learning).""" + X_all, y_all, task_labels = [], [], [] + for task_id, data in self.task_data.items(): + X, y = data["train"] + X_all.append(X) + y_all.append(y) + task_labels.append(np.full(len(y), task_id)) + + X_all = np.vstack(X_all) + y_all = np.concatenate(y_all) + task_labels = np.concatenate(task_labels) + + # Add task ID as a feature + X_all = np.column_stack((X_all, task_labels)) + + self.model = self.model_cls(**self.params, random_state=42) + self.model.fit(X_all, y_all) + + def predict(self, X, task_id): + """Make predictions for a specific task.""" + X_task = np.column_stack((X, np.full(len(X), task_id))) + return self.model.predict(X_task) + + + def score(self, task_id): + """Return accuracy on the held-out test set for a specific task.""" + X_test, y_test = self.task_data[task_id]["test"] + return accuracy_score(y_test, self.predict(X_test, task_id)) \ No newline at end of file diff --git a/multitaskclf_ratiosplit.py b/multitaskclf_ratiosplit.py new file mode 100644 index 0000000..2b1b4e9 --- /dev/null +++ b/multitaskclf_ratiosplit.py @@ -0,0 +1,96 @@ +# -*- coding: utf-8 -*- +"""MultiTaskClf_ratiosplit.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1d7ipMRMx9b10KeaPRe-yLQq5tAo6Wnvd +""" + +import numpy as np +from sklearn.metrics import accuracy_score +from treeple import ObliqueRandomForestClassifier + +""" +MultiTaskForestClassifier: +A unified multi-task learning wrapper for SPORF, MORF, and HonestForest. +Trains on all tasks jointly and evaluates per-task performance. +""" + +class MultiTaskForestClassifier: + def __init__(self, clf_type="SPORF", task_ratios=None, random_state=42, **kwargs): + if clf_type == "SPORF": + self.model_cls = ObliqueRandomForestClassifier + self.default_params = { + "n_estimators": 200, + "feature_combinations": 2.0, + "max_depth": 20, + "min_samples_split": 5, + "min_samples_leaf": 1, + "max_features": 0.5, + "bootstrap": True + } + elif clf_type == "MORF": + self.model_cls = MORFClassifier + self.default_params = { ... } + elif clf_type == "HonestForest": + self.model_cls = HonestForestClassifier + self.default_params = { ... } + else: + raise ValueError(f"Unsupported tree: {clf_type}") + + self.params = {**self.default_params, **kwargs} + self.model = None + self.task_data = {} + + if task_ratios is None: + self.task_ratios = {0: 0.1, 1: 0.9} + else: + self.task_ratios = task_ratios + + self.random_state = random_state + + + def add_task(self, task_id, X, y, test_size=0.2): + from sklearn.model_selection import train_test_split + if task_id in self.task_ratios: + ratio = self.task_ratios[task_id] + X, _, y, _ = train_test_split(X, y, train_size=ratio, stratify=y, random_state=self.random_state) + + X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, stratify=y, random_state=self.random_state) + self.task_data[task_id] = { + "train": (X_train, y_train), + "test": (X_test, y_test) + } + + def get_task_ids(self): + return list(self.task_data.keys()) + + def fit(self): + """Train on all tasks jointly (multi-task learning).""" + X_all, y_all, task_labels = [], [], [] + for task_id, data in self.task_data.items(): + X, y = data["train"] + X_all.append(X) + y_all.append(y) + task_labels.append(np.full(len(y), task_id)) + + X_all = np.vstack(X_all) + y_all = np.concatenate(y_all) + task_labels = np.concatenate(task_labels) + X_all = np.column_stack((X_all, task_labels)) + + self.model = self.model_cls(**self.params, random_state=42) + self.model.fit(X_all, y_all) + + def predict(self, X, task_id): + """Make predictions for a specific task.""" + X_task = np.column_stack((X, np.full(len(X), task_id))) + return self.model.predict(X_task) + + + def score(self, task_id): + """Return accuracy on the held-out test set for a specific task.""" + X_test, y_test = self.task_data[task_id]["test"] + return accuracy_score(y_test, self.predict(X_test, task_id)) + diff --git a/multitaskclf_ratiosplit_with_transfer_efficiency_modified5.py b/multitaskclf_ratiosplit_with_transfer_efficiency_modified5.py new file mode 100644 index 0000000..115556e --- /dev/null +++ b/multitaskclf_ratiosplit_with_transfer_efficiency_modified5.py @@ -0,0 +1,169 @@ +# -*- coding: utf-8 -*- +"""MultiTaskClf_ratiosplit with transfer efficiency_modified5.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1d7ipMRMx9b10KeaPRe-yLQq5tAo6Wnvd +""" + +import numpy as np +from sklearn.metrics import accuracy_score +from treeple import ObliqueRandomForestClassifier +import warnings +from sklearn.model_selection import train_test_split + +""" +MultiTaskForestClassifier: +A unified multi-task learning wrapper for SPORF, MORF, and HonestForest. +Trains on all tasks jointly and evaluates per-task performance. +""" + +class MultiTaskForestClassifier: + def __init__(self, clf_type="SPORF", task_ratios=None, random_state=42, **kwargs): + if clf_type == "SPORF": + self.model_cls = ObliqueRandomForestClassifier + self.default_params = { + "n_estimators": 200, + "feature_combinations": 2.0, + "max_depth": 20, + "min_samples_split": 5, + "min_samples_leaf": 1, + "max_features": 0.5, + "bootstrap": True + } + elif clf_type == "MORF": + self.model_cls = PatchObliqueRandomForestClassifier + self.default_params = { + "n_estimators": 200 + } + elif clf_type == "HonestForest": + self.model_cls = HonestForestClassifier + self.default_params = { + + "n_estimators": 200, + "max_depth": None, + "min_samples_split": 2, + "min_samples_leaf": 5, + "bootstrap": True, + "max_features": "sqrt" + } + else: + raise ValueError(f"Unsupported tree: {clf_type}") + + self.params = {**self.default_params, **kwargs} + self.model = None + self.task_data = {} + + if task_ratios is None: + warnings.warn("No task_ratios provided. Using default {0: 0.5, 1: 0.5}. Override if needed.") + self.task_ratios = {0: 0.5, 1: 0.5} + else: + self.task_ratios = task_ratios + + + self.random_state = random_state + + + def add_task(self, task_id, X, y, test_size=0.2): + if test_size > 0: + X_train, X_test, y_train, y_test = train_test_split( + X, y, + test_size=test_size, + stratify=y, + random_state=self.random_state + ) + else: + X_train, y_train = X, y + X_test, y_test = None, None + + self.task_data[task_id] = { + "train": (X_train, y_train), + "test": (X_test, y_test) + } + + + def get_task_ids(self): + return list(self.task_data.keys()) + + def fit(self): + """Train on all tasks jointly (multi-task learning).""" + X_all, y_all, task_labels = [], [], [] + for task_id, data in self.task_data.items(): + X, y = data["train"] + X_all.append(X) + y_all.append(y) + task_labels.append(np.full(len(y), task_id)) + + X_all = np.vstack(X_all) + y_all = np.concatenate(y_all) + task_labels = np.concatenate(task_labels) + X_all = np.column_stack((X_all, task_labels)) + + self.model = self.model_cls(**self.params, random_state=42) + self.model.fit(X_all, y_all) + + def predict(self, X, task_id): + """Make predictions for a specific task.""" + X_task = np.column_stack((X, np.full(len(X), task_id))) + return self.model.predict(X_task) + + + def score(self, task_id): + """Return accuracy on the held-out test set for a specific task.""" + X_test, y_test = self.task_data[task_id]["test"] + return accuracy_score(y_test, self.predict(X_test, task_id)) + +def evaluate_transfer_efficiency( + X_source, y_source, + X_target, y_target, + target_ratios=[0.01], + seed=42, + clf_type="SPORF" #"SPORF", "MORF", "HonestForest" +): + """ + Evaluate transfer efficiency using the specified classifier type. + Fixes train/test split (80/20), and varies how much target training data is used. + """ + assert clf_type in ["SPORF", "MORF", "HonestForest"], f"Invalid clf_type: {clf_type}" + print(f"\n=== Transfer Efficiency using {clf_type} ===") + X_train_source, X_test_source, y_train_source, y_test_source = train_test_split( + X_source, y_source, test_size=0.2, stratify=y_source, random_state=seed + ) + X_train_target, X_test_target, y_train_target, y_test_target = train_test_split( + X_target, y_target, test_size=0.2, stratify=y_target, random_state=seed + ) + + for ratio in target_ratios: + if ratio < 1.0: + X_train_target_sub, _, y_train_target_sub, _ = train_test_split( + X_train_target, y_train_target, + train_size=ratio, + stratify=y_train_target, + random_state=seed + ) + else: + X_train_target_sub, y_train_target_sub = X_train_target, y_train_target + clf_base = MultiTaskForestClassifier( + clf_type=clf_type, + task_ratios={1: 1.0}, + random_state=seed + ) + clf_base.add_task(1, X_train_target_sub, y_train_target_sub, test_size=0) + clf_base.fit() + acc_base = accuracy_score(y_test_target, clf_base.predict(X_test_target, task_id=1)) + clf_transfer = MultiTaskForestClassifier( + clf_type=clf_type, + task_ratios={0: 1.0, 1: 1.0}, + random_state=seed + ) + clf_transfer.add_task(0, X_train_source, y_train_source, test_size=0) + clf_transfer.add_task(1, X_train_target_sub, y_train_target_sub, test_size=0) + clf_transfer.fit() + acc_transfer = accuracy_score(y_test_target, clf_transfer.predict(X_test_target, task_id=1)) + + print(f"Target Task Ratio: {int(ratio * 100)}%") + print(f" Baseline (Source 0%): Accuracy = {acc_base:.3f}") + print(f" Transfer (Source 100%): Accuracy = {acc_transfer:.3f}") + print("-" * 50) +