From fc9898aaf253ad3ee28818bda3ad57a8d26516f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Cabrero-Holgueras?= Date: Fri, 14 Jun 2024 11:13:13 +0000 Subject: [PATCH 1/4] feat: added multi-layer perceptron demo --- .gitignore | 2 + .../01_model_provider.ipynb | 784 +++++++++++ .../02_model_inference.ipynb | 491 +++++++ examples/multi_layer_perceptron/README.md | 3 + examples/multi_layer_perceptron/helpers.py | 74 + .../multi_layer_perceptron/nada-project.toml | 7 + .../multi_layer_perceptron/requirements.txt | 6 + examples/multi_layer_perceptron/src/main.py | 26 + examples/multi_layer_perceptron/src/my_nn.py | 26 + .../multi_layer_perceptron/tests/test.yaml | 1210 +++++++++++++++++ examples/multi_layer_perceptron/tmp.json | 1 + examples/neural_net/network/compute.py | 2 +- .../spam_detection/01_model_provider.ipynb | 1 - 13 files changed, 2631 insertions(+), 2 deletions(-) create mode 100644 examples/multi_layer_perceptron/01_model_provider.ipynb create mode 100644 examples/multi_layer_perceptron/02_model_inference.ipynb create mode 100644 examples/multi_layer_perceptron/README.md create mode 100644 examples/multi_layer_perceptron/helpers.py create mode 100644 examples/multi_layer_perceptron/nada-project.toml create mode 100644 examples/multi_layer_perceptron/requirements.txt create mode 100644 examples/multi_layer_perceptron/src/main.py create mode 100644 examples/multi_layer_perceptron/src/my_nn.py create mode 100644 examples/multi_layer_perceptron/tests/test.yaml create mode 100644 examples/multi_layer_perceptron/tmp.json diff --git a/.gitignore b/.gitignore index 9fcb490..67b18d0 100644 --- a/.gitignore +++ b/.gitignore @@ -159,3 +159,5 @@ bench/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +data/ \ No newline at end of file diff --git a/examples/multi_layer_perceptron/01_model_provider.ipynb b/examples/multi_layer_perceptron/01_model_provider.ipynb new file mode 100644 index 0000000..4b703b8 --- /dev/null +++ b/examples/multi_layer_perceptron/01_model_provider.ipynb @@ -0,0 +1,784 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi-layer perceptron" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This demo shows MLP" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "## If problems arise with the loading of the shared library, this script can be used to load the shared library before other libraries.\n", + "## Remember to also run on your local machine the script below:\n", + "# bash replace_lib_version.sh\n", + "\n", + "import platform\n", + "import ctypes\n", + "\n", + "if platform.system() == \"Linux\":\n", + " # Force libgomp to be loaded before other libraries consuming dynamic TLS (to avoid running out of STATIC_TLS)\n", + " ctypes.cdll.LoadLibrary(\"libgomp.so.1\")\n", + " ctypes.cdll.LoadLibrary(\n", + " \"/home/vscode/.local/lib/python3.12/site-packages/py_nillion_client/py_nillion_client.abi3.so\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "from typing import Dict\n", + "\n", + "import os\n", + "import torch\n", + "from torch import nn\n", + "from torchvision import transforms\n", + "import py_nillion_client as nillion\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_recall_fscore_support\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from dotenv import load_dotenv\n", + "\n", + "# Using Nada AI model client\n", + "from nada_ai.client import TorchClient\n", + "import nada_algebra as na\n", + "import py_nillion_client as nillion\n", + "from nillion_python_helpers import (\n", + " create_nillion_client,\n", + " getUserKeyFromFile,\n", + " getNodeKeyFromFile,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train an Covid classification model\n", + "\n", + "Before this step you must install kaggle" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# !kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class CovidDataset(torch.utils.data.Dataset):\n", + " def __init__(self, root_dir: os.PathLike, transform) -> None:\n", + " self.root_dir = root_dir\n", + " self.transform = transform\n", + " \n", + " self.classes = ['Non-COVID-19', 'COVID-19']\n", + "\n", + " self.data = []\n", + " self.targets = []\n", + "\n", + " for class_index, class_name in enumerate(self.classes):\n", + " class_dir = os.path.join(self.root_dir, class_name)\n", + " for filename in os.listdir(class_dir):\n", + " if filename.endswith('.png'):\n", + " img_path = os.path.join(class_dir, filename)\n", + " self.data.append(img_path)\n", + " self.targets.append(class_index)\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, index):\n", + " img_path = self.data[index]\n", + " label = self.targets[index]\n", + "\n", + " img = Image.open(img_path).convert('RGB')\n", + " img = self.transform(img)\n", + "\n", + " return img, label" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Create custom torch Module\n", + "class MyNN(torch.nn.Module):\n", + " \"\"\"My simple neural net\"\"\"\n", + "\n", + " def __init__(self) -> None:\n", + " \"\"\"Model is a two layers and an activations\"\"\"\n", + " super(MyNN, self).__init__()\n", + " self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n", + " self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", + "\n", + " self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n", + " \n", + " self.relu = torch.nn.ReLU()\n", + " self.flatten = torch.nn.Flatten()\n", + "\n", + " def forward(self, x: np.ndarray) -> np.ndarray:\n", + " \"\"\"My forward pass logic\"\"\"\n", + " x = self.relu(self.conv1(x))\n", + " x = self.pool(x)\n", + " x = self.flatten(x)\n", + " x = self.fc1(x)\n", + " return x\n", + "\n", + "\n", + "my_model = MyNN()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = CovidDataset(\n", + " os.path.join(\"data\", \"COVID-19_Lung_CT_Scans\"),\n", + " transform=transforms.Compose(\n", + " [\n", + " transforms.Grayscale(),\n", + " transforms.Resize((16,16)),\n", + " transforms.ToTensor(),\n", + " ]\n", + " ),\n", + ")\n", + "trainset, testset = torch.utils.data.random_split(dataset, [0.8, 0.2])\n", + "trainloader = torch.utils.data.DataLoader(trainset, batch_size=16, shuffle=True)\n", + "testloader = torch.utils.data.DataLoader(testset, batch_size=16, shuffle=True)\n", + "\n", + "loss_function = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.AdamW(my_model.parameters(), lr=1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting epoch 1...\n", + "Loss after mini-batch 100: 0.718\n", + "Accuracy after mini-batch 100: 11.250\n", + "Loss after mini-batch 200: 0.708\n", + "Accuracy after mini-batch 200: 11.312\n", + "Loss after mini-batch 300: 0.699\n", + "Accuracy after mini-batch 300: 11.000\n", + "Loss after mini-batch 400: 0.691\n", + "Accuracy after mini-batch 400: 74.875\n", + "Starting epoch 2...\n", + "Loss after mini-batch 100: 0.681\n", + "Accuracy after mini-batch 100: 90.375\n", + "Loss after mini-batch 200: 0.674\n", + "Accuracy after mini-batch 200: 88.688\n", + "Loss after mini-batch 300: 0.666\n", + "Accuracy after mini-batch 300: 90.062\n", + "Loss after mini-batch 400: 0.661\n", + "Accuracy after mini-batch 400: 87.562\n", + "Starting epoch 3...\n", + "Loss after mini-batch 100: 0.651\n", + "Accuracy after mini-batch 100: 88.875\n", + "Loss after mini-batch 200: 0.645\n", + "Accuracy after mini-batch 200: 88.812\n", + "Loss after mini-batch 300: 0.637\n", + "Accuracy after mini-batch 300: 89.375\n", + "Loss after mini-batch 400: 0.631\n", + "Accuracy after mini-batch 400: 89.250\n", + "Starting epoch 4...\n", + "Loss after mini-batch 100: 0.622\n", + "Accuracy after mini-batch 100: 89.562\n", + "Loss after mini-batch 200: 0.619\n", + "Accuracy after mini-batch 200: 88.000\n", + "Loss after mini-batch 300: 0.609\n", + "Accuracy after mini-batch 300: 89.750\n", + "Loss after mini-batch 400: 0.605\n", + "Accuracy after mini-batch 400: 89.000\n", + "Starting epoch 5...\n", + "Loss after mini-batch 100: 0.601\n", + "Accuracy after mini-batch 100: 88.062\n", + "Loss after mini-batch 200: 0.587\n", + "Accuracy after mini-batch 200: 90.688\n", + "Loss after mini-batch 300: 0.587\n", + "Accuracy after mini-batch 300: 88.688\n", + "Loss after mini-batch 400: 0.581\n", + "Accuracy after mini-batch 400: 89.125\n", + "Starting epoch 6...\n", + "Loss after mini-batch 100: 0.574\n", + "Accuracy after mini-batch 100: 89.188\n", + "Loss after mini-batch 200: 0.572\n", + "Accuracy after mini-batch 200: 88.312\n", + "Loss after mini-batch 300: 0.561\n", + "Accuracy after mini-batch 300: 89.750\n", + "Loss after mini-batch 400: 0.559\n", + "Accuracy after mini-batch 400: 89.000\n", + "Starting epoch 7...\n", + "Loss after mini-batch 100: 0.553\n", + "Accuracy after mini-batch 100: 89.000\n", + "Loss after mini-batch 200: 0.549\n", + "Accuracy after mini-batch 200: 88.750\n", + "Loss after mini-batch 300: 0.543\n", + "Accuracy after mini-batch 300: 89.000\n", + "Loss after mini-batch 400: 0.536\n", + "Accuracy after mini-batch 400: 89.375\n", + "Starting epoch 8...\n", + "Loss after mini-batch 100: 0.530\n", + "Accuracy after mini-batch 100: 89.562\n", + "Loss after mini-batch 200: 0.525\n", + "Accuracy after mini-batch 200: 89.500\n", + "Loss after mini-batch 300: 0.525\n", + "Accuracy after mini-batch 300: 88.688\n", + "Loss after mini-batch 400: 0.520\n", + "Accuracy after mini-batch 400: 88.750\n", + "Starting epoch 9...\n", + "Loss after mini-batch 100: 0.509\n", + "Accuracy after mini-batch 100: 89.812\n", + "Loss after mini-batch 200: 0.506\n", + "Accuracy after mini-batch 200: 89.625\n", + "Loss after mini-batch 300: 0.511\n", + "Accuracy after mini-batch 300: 87.875\n", + "Loss after mini-batch 400: 0.498\n", + "Accuracy after mini-batch 400: 89.000\n", + "Starting epoch 10...\n", + "Loss after mini-batch 100: 0.471\n", + "Accuracy after mini-batch 100: 88.500\n", + "Loss after mini-batch 200: 0.436\n", + "Accuracy after mini-batch 200: 88.125\n", + "Loss after mini-batch 300: 0.393\n", + "Accuracy after mini-batch 300: 89.438\n", + "Loss after mini-batch 400: 0.369\n", + "Accuracy after mini-batch 400: 89.688\n" + ] + } + ], + "source": [ + "accuracies, losses = [], []\n", + "for epoch in range(10):\n", + " print(f'Starting epoch {epoch+1}...')\n", + "\n", + " incorrect, correct = 0, 0\n", + " current_loss = 0\n", + " for i, data in enumerate(trainloader):\n", + " inputs, targets = data\n", + "\n", + " optimizer.zero_grad()\n", + "\n", + " outputs = my_model(inputs)\n", + " loss = loss_function(outputs, targets)\n", + "\n", + " preds = torch.argmax(outputs, axis=1)\n", + "\n", + " correct += (preds == targets).float().sum()\n", + " incorrect += (preds != targets).float().sum()\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " current_loss += loss.item()\n", + " if i % 100 == 99:\n", + " accuracy = 100 * correct / (incorrect + correct)\n", + " accuracies.append(accuracy)\n", + "\n", + " print('Loss after mini-batch %5d: %.3f' % (i + 1, current_loss / 100))\n", + " losses.append(current_loss/100)\n", + " print('Accuracy after mini-batch %5d: %.3f' % (i + 1, accuracy))\n", + "\n", + " correct, incorrect = 0, 0\n", + " current_loss = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(accuracies)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABHtklEQVR4nO3de1wU5f4H8M/swu4CclEuy0UUEFARQUVFvJQpiV21i0fLJK30ZFoaeSo7pWX9sqvHPHmiTFNPHTXNW2poYWoqgoIoGiIgCgjLTbkLC7vz+0PdIvGyCM7u8nm/XvNSZ2cev89r1P0488zzCKIoiiAiIiIyYTKpCyAiIiK6GQYWIiIiMnkMLERERGTyGFiIiIjI5DGwEBERkcljYCEiIiKTx8BCREREJo+BhYiIiEyeldQFtAa9Xo+CggLY29tDEASpyyEiIqJbIIoiqqqq4OnpCZnsxvdQLCKwFBQUwNvbW+oyiIiIqAXy8vLQuXPnGx5jEYHF3t4ewOUOOzg4SFwNERER3YrKykp4e3sbvsdvxCICy9XHQA4ODgwsREREZuZWhnNw0C0RERGZPAYWIiIiMnkMLERERGTyGFiIiIjI5DGwEBERkcljYCEiIiKTx8BCREREJo+BhYiIiEweAwsRERGZPAYWIiIiMnkMLERERGTyGFiIiIjI5DGw3MSHcafwnz1ZEEVR6lKIiIjaLYtYrbmtHMsrxxd7sg0//2RcKOxV1hJXRURE1P7wDssNhHo7YeGjvaGQy7DzZBHGLD2ArOIqqcsiIiJqdxhYbuKJgV2w7u+D4O6gwpmSGoz5/AB+SiuUuiwiIqJ2hYHlFvTt0hHbXhqKQX6dUKPVYfp3KVj4UzoadXqpSyMiImoXGFhukUsHJb59NhzT7vIDAHy59wye/iYJZdX1EldGRERk+RhYjGAll+GN+3vi8yf7wlYhx4GsMjz07/04nl8udWlEREQWjYGlBR4M8cTmGUPg62KHgoo6PB6bgO8P50ldFhERkcViYGmhQLU9tswcgnuD1NA26vHqD8cxd2Ma6ht1UpdGRERkcRhYboODyhpfPhWGOaMCIQjAmqRc/O3LQygovyR1aURERBaFgeU2yWQCZo4IwMopA+FoY41jeeW4f8lv+OX3IqlLIyIishgMLK3k7kBXbHtxKEI6O6K8tgHPrT6CBT/+Dm0jX30mIiK6XQwsrci7ky02PD8Yzw71BQCsOJCDx2MP4lxZjcSVERERmTcGllamsJLhrQeD8HV0fzjZWuN4fgUeWLIf244XSF0aERGR2WpRYFm6dCl8fHygUqkQHh6OpKSk6x47fPhwCIJwzfbAAw8YjhFFEfPmzYOHhwdsbGwQGRmJzMzMlpRmMiKD1Njx0jD079oR1fWNmPm/o3hjUxrqGvgWERERkbGMDizr1q1DTEwM5s+fj5SUFISGhiIqKgrFxcXNHr9x40YUFhYathMnTkAul2PcuHGGYz766CMsWbIEsbGxSExMhJ2dHaKiolBXV9fynpkATycbrJ02CDPv8YcgAP9LzMVYLqBIRERkNEEURdGYE8LDwzFgwAB8/vnnAAC9Xg9vb2+8+OKLeP311296/uLFizFv3jwUFhbCzs4OoijC09MTr7zyCubMmQMAqKiogFqtxsqVKzFhwoSbtllZWQlHR0dUVFTAwcHBmO7cMb9lluDldakordbCxlqOBWN64fGwzhAEQerSiIiIJGHM97dRd1i0Wi2Sk5MRGRn5RwMyGSIjI5GQkHBLbSxfvhwTJkyAnZ0dACAnJwcajaZJm46OjggPD79um/X19aisrGyymbphAa7YMWsYhvg741KDDv/YcBwx3x9DdX2j1KURERGZPKMCS2lpKXQ6HdRqdZP9arUaGo3mpucnJSXhxIkTeO655wz7rp5nTJsLFy6Eo6OjYfP29jamG5Jxs1dh9TPhmDMqEDIB2HT0PB7+936cOF8hdWlEREQm7Y6+JbR8+XL07t0bAwcOvK125s6di4qKCsOWl2c+6/jIr0w0t+7vEfBwVOFMaQ0e/c9BrNifAyOfzhEREbUbRgUWFxcXyOVyFBU1ncW1qKgI7u7uNzy3pqYGa9euxbPPPttk/9XzjGlTqVTCwcGhyWZuBvh0wo6Xhl1ei0inx4Jtv+PZVUdQVl0vdWlEREQmx6jAolAoEBYWhvj4eMM+vV6P+Ph4RERE3PDc9evXo76+Hk899VST/b6+vnB3d2/SZmVlJRITE2/aprnraKfAV5PCsGBMLyisZNh9qhj3ffYbDmaXSl0aERGRSTH6kVBMTAyWLVuGVatWIT09HdOnT0dNTQ2mTJkCAIiOjsbcuXOvOW/58uUYO3YsnJ2dm+wXBAGzZ8/Ge++9h61btyItLQ3R0dHw9PTE2LFjW9YrMyIIAqIjfLD5hSHo5mqH4qp6TPw6EZ/szECjjtP6ExERAYCVsSeMHz8eJSUlmDdvHjQaDfr06YO4uDjDoNnc3FzIZE1zUEZGBvbv349du3Y12+arr76KmpoaTJs2DeXl5Rg6dCji4uKgUqla0CXzFOTpgB9fHIp3tv6OdUfy8PmvWTiYXYrPJvSFdydbqcsjIiKSlNHzsJgic5iHxRg/HivAGxvTUFXfCHuVFT54NAQPhHhIXRYREVGrarN5WOjOeCjUEztmDUMfbydU1TVixv9SMHfjcVzSclp/IiJqnxhYTJR3J1usfz4C04d3gyAAa5Ly8NDn+5Gh4bT+RETU/jCwmDBruQyvje6B/z4TDld7JbKKq/Hofw5g18mbT9JHRERkSRhYzMDQABf8NGsYIvycUaPV4e/fJmPpr1mcaI6IiNoNBhYz4dJBidXPDsSkQV0hisDHOzMwe10q6ho4roWIiCwfA4sZsZbL8O7YYLw7NhhymYAtqQUY/2UCiirrpC6NiIioTTGwmKFJg7riv88MhKONNY7lV+Dhz/fjeH651GURERG1GQYWMzXY3wVbZgyBv1sHFFXWY1xsAn48ViB1WURERG2CgcWM+bjYYeMLg3FPd1fUN+rx4pqj+HRXBvR6DsYlIiLLwsBi5hxU1vj66QGYdpcfAODfu7Mw/btk1NQ3SlwZERFR62FgsQBymYA37u+JT8aFQiGXYefJIjz2xUHkX6yVujQiIqJWwcBiQR4P64w10wbBpYMCpzRVGPP5AWxMyecjIiIiMnsMLBYmrGtHbJk5FEEeDiir0SLm+2N4LPYgjuWVS10aERFRizGwWCAvJxtsmjEYr47uDluFHEdzyzFm6QH8Y/0xFFdxzhYiIjI/gmgB87sbszx1e1NUWYcPfzqFjUfPAwA6KK3w4gh/TBniC4UV8yoREUnHmO9vBpZ2IiX3It7ZehLH8isAAL4udnjrwZ4Y0UMtcWVERNReMbBQs/R6ET+k5OPDuAyUVtcDAIZ3d8VbDwahm2sHiasjIqL2hoGFbqiqrgGf787CigM5aNCJsJIJmDzYBy9FBsBBZS11eURE1E4wsNAtOVNSjf/bno74U8UAALWDEh88GoJ7erhJXBkREbUHxnx/c9RlO+bn2gHLJw/AyikD4Otih6LKekxZeRivbjiGyroGqcsjIiIyYGAhDO/uhh0vDcOzQ30hCMD3R/IR9a992He6ROrSiIiIADCw0BU2CjneejAI3/89Aj7OtiisqEP0iiTM3XgcVbzbQkREEmNgoSYG+HTCjlnDMHmwDwBgTVIeRi/+DfszS6UtjIiI2jUGFrqGrcIKbz/cC2unDUKXTrY4X34JTy1PxD83paGaq0ATEZEEGFjougb5OeOnWcMQHdEVAPBdYi5GL96Hg9m820JERHcWAwvdkJ3SCgvGBON/z4XDy8kG+Rcv4clliXhr8wmUVNVLXR4REbUTnIeFbll1fSMW7kjHd4m5AABruYD7e3sgOsIH/bo4QRAEiSskIiJzwonjqE3tzyzFpz9n4GhuuWFfL08HREd0xcOhXrBRyKUrjoiIzAYDC90RafkVWJ1wFluPFaC+UQ8AcLSxxt/6d8ZTg7qiq7OdxBUSEZEpY2ChO+pijRbfH8nDt4nnkHfhEgBAEIDhga6IHuyDuwNcIZPxcRERETXFwEKS0OlF7MkoxuqEc9j7p1lyuzrb4u93dcMTA705zoWIiAwYWEhyOaU1+PbQOaw/kofKustztzzQ2wMfPh6CDkoriasjIiJTwMBCJqNW24hvD53Dxzsz0KAT4edqhy+fCkOA2l7q0oiISGJcrZlMhq3CCtPu6oZ1f4+Ah6MKZ0pqMGbpAWxJPS91aUREZEYYWOiO6NelI7a9OBRD/J1Rq9Vh1tpUvL31JLRX3i4iIiK6EQYWumOcOyix+plwzLzHHwCw8uBZjP8qAYUVlySujIiITB0DC91RcpmAOVHdsfzp/nBQWeFobjkeWLIfB7K4PhEREV1fiwLL0qVL4ePjA5VKhfDwcCQlJd3w+PLycsyYMQMeHh5QKpUIDAzEjh07DJ+//fbbEAShydajR4+WlEZmYmRPNba9OAy9PB1woUaLScsTsfTXLOj1Zj8GnIiI2oDRgWXdunWIiYnB/PnzkZKSgtDQUERFRaG4uLjZ47VaLe69916cPXsWGzZsQEZGBpYtWwYvL68mx/Xq1QuFhYWGbf/+/S3rEZmNLs62+GH6YIzv7w29CHy8MwNTVx9BRW2D1KUREZGJMTqwLFq0CFOnTsWUKVMQFBSE2NhY2NraYsWKFc0ev2LFCly4cAGbN2/GkCFD4OPjg7vvvhuhoaFNjrOysoK7u7thc3FxaVmPyKyorOX48PEQfPhYbyisZIg/VYwHP/8NCdllUpdGREQmxKjAotVqkZycjMjIyD8akMkQGRmJhISEZs/ZunUrIiIiMGPGDKjVagQHB+P999+HTqdrclxmZiY8PT3h5+eHiRMnIjc3twXdIXM1fkAXbJw+GN6dbJB34RKeWHYIz606guySaqlLIyIiE2BUYCktLYVOp4NarW6yX61WQ6PRNHvOmTNnsGHDBuh0OuzYsQNvvfUWPv30U7z33nuGY8LDw7Fy5UrExcXhiy++QE5ODoYNG4aqqqpm26yvr0dlZWWTjcxfsJcjts0chkmDukIuE/BLehFG/Wsf5m05gbLqeqnLIyIiCbX5W0J6vR5ubm746quvEBYWhvHjx+Of//wnYmNjDcfcd999GDduHEJCQhAVFYUdO3agvLwc33//fbNtLly4EI6OjobN29u7rbtBd4ijrTXeHRuMnbOHIbKnG3R6EasTzmH4x3sQuzcbdQ26mzdCREQWx6jA4uLiArlcjqKioib7i4qK4O7u3uw5Hh4eCAwMhFwuN+zr2bMnNBoNtFpts+c4OTkhMDAQWVlZzX4+d+5cVFRUGLa8vDxjukFmwN/NHl8/PQD/ey4cvTwdUFXfiA9+OoWRn+7FltTzsIAVJYiIyAhGBRaFQoGwsDDEx8cb9un1esTHxyMiIqLZc4YMGYKsrCzo9X/MaHr69Gl4eHhAoVA0e051dTWys7Ph4eHR7OdKpRIODg5NNrJMg/1d8OPMofh0XCjcHVQ4X34Js9amYux/DuLw2QtSl0dERHeI0Y+EYmJisGzZMqxatQrp6emYPn06ampqMGXKFABAdHQ05s6dazh++vTpuHDhAmbNmoXTp09j+/bteP/99zFjxgzDMXPmzMHevXtx9uxZHDx4EI888gjkcjmeeOKJVugimTuZTMBjYZ3x65zheOXeQNgq5DiWV45xsQl4/r/JOFtaI3WJRETUxqyMPWH8+PEoKSnBvHnzoNFo0KdPH8TFxRkG4ubm5kIm+yMHeXt7Y+fOnXj55ZcREhICLy8vzJo1C6+99prhmPz8fDzxxBMoKyuDq6srhg4dikOHDsHV1bUVukiWwkYhx4sjAzB+oDf+9XMm1h3ORdxJDXafKsbzw7vhheHdoLKW37whIiIyO4JoAYMBjFmemixHhqYK723/Hb9lXp7W39fFDu+OCcbQAM7hQ0RkDoz5/uZaQmS2urvbY/UzA7H0yX5ws1cip7QGTy1PxOy1R1FSxdegiYgsCQMLmTVBEPBAiAfiX7kbkwf7QBCAzakFGPnpHnyXeI5rExERWQg+EiKLcjy/HG9sSsOJ85cnE+zXxQn/90hv9PTgnwsiIlPDR0LUboV0dsLmF4Zg3oNBsFPIkZJbjgf/vR8Ld6SjVtsodXlERNRCDCxkcazkMjwz1BfxrwzHfcHu0OlFfLnvDO5dtA+//F508waIiMjk8JEQWbzdp4rw1uaTOF9+CQAwvLsrXo3qgSBP/lkhIpKSMd/fDCzULtRqG/FZfCaW/5aDRr0IQQDGhHoi5t7u6OJsK3V5RETtEgML0XWcLa3BJ7sysO14IQDAWi7gyYFdMHNEAFztlRJXR0TUvjCwEN3EifMV+DDulGHSOVuFHM8N9cXUu/xgr7KWuDoiovaBgYXoFh3MKsWHOzNwLK8cANDR1hoz7vHHU4O6cpp/IqI2xsBCZARRFBF3QoOPd2XgTMnlhRS9nGwwOzIAj/brDLlMkLhCIiLLxMBC1AKNOj02JOdj8S+Z0FTWAQC6q+3xybhQ9O7sKHF1RESWh4GF6DbUNeiw6uBZ/GdPNiouNcBKJuDlewPx/N3deLeFiKgVcaZbotugspbj73d3w545lyeea9SL+HhnBp746hDyLtRKXR4RUbvEwEJ0HR3tFPjPxH74+PEQ2CnkSDp7Afd/9hs2Hc2HBdyYJCIyKwwsRDcgCALG9ffGT7PuQr8uTqiqb8TL647hpbWpqKhtkLo8IqJ2g4GF6BZ0cbbF93+PQMy9gZDLBPx4rACjP9uHg9mlUpdGRNQuMLAQ3SIruQwvjQzAD9MHw8fZFoUVdZj4dSIW7khHfaNO6vKIiCwaAwuRkfp4O2H7S8PwxEBviCLw5b4zGLv0IE4XVUldGhGRxeJrzUS3YddJDV7fmIYLNVoorWSYMMAbg/1dEO7bCU62CqnLIyIyaZyHhegOKq6qwz/WH8fe0yWGfYIA9HR3wCA/Zwzy64RwX2c42nKNIiKiP2NgIbrDRFHEz78XYV9mCQ6duYCs4uomnwsCEORxNcA4Y6BvJzjaMMAQUfvGwEIkseKqOiSeuYBDZ8pw6EwZsq+sUXSVIFweC/PumGAEe3HafyJqnxhYiExMcWUdDuVcCTDZZThTejnA2FjL8cm4UDwQ4iFxhUREdx4DC5GJK6y4hNd/SDOMe3lpZABmjwyAjGsVEVE7wrWEiEych6MNVkwegOeG+gIAlsRnYvp3yaipb5S4MiIi08TAQiQRuUzAmw8G4ePHQ6CQy7DzZBEe++IgF1gkImoGAwuRxMb198aaaYPg0kGJU5oqjFl6AIlnyqQui4jIpDCwEJmAsK4dsXXmEAR7OeBCjRYTv07EmqRcqcsiIjIZDCxEJsLTyQbr/z4YD4Z4oFEvYu7GNMzfcgINOr3UpRERSY6BhciE2Cjk+PcTfTFnVCAAYFXCOTy9IgkXa7QSV0ZEJC0GFiITIwgCZo4IwFeTwmCrkONgdhnGLD2AE+crpC6NiEgynIeFyISd0lTiuVVHkH/xEgAgpLMjxvbxwsN9POHSQSlxdUREt4cTxxFZkAs1Wry5OQ27ThahUX/5r6tcJmBYgAse6euFUUHusFHIJa6SiMh4DCxEFqisuh4/HivAptQCHMsrN+zvoLTC6GB3PNLXC4P8nCHnbLlEZCYYWIgsXHZJNTYfPY9NR88bHhcBgLuDCmP6euKRvl7o4c6/C0Rk2hhYiNoJURRx5NxFbDp6HtuOFaCy7o+p/YO9HDAuzBtj+njCyVYhYZVERM1jYCFqh+obdfj1VAk2Hc3H7lPFaNBd/qutkMtwb5Aa4/p3xrAAVz4yIiKT0eaLHy5duhQ+Pj5QqVQIDw9HUlLSDY8vLy/HjBkz4OHhAaVSicDAQOzYseO22iSippRWcowOdseXk/oj8Y1IzH8oCEEeDtDq9NieVojJ3xzGkA9246O4U8gprZG6XCIioxh9h2XdunWIjo5GbGwswsPDsXjxYqxfvx4ZGRlwc3O75nitVoshQ4bAzc0Nb7zxBry8vHDu3Dk4OTkhNDS0RW3+Fe+wEF3fifMV2JCcj82p51Fe22DYP8CnI8aFeeP+EA90UFpJWCERtVdt+kgoPDwcAwYMwOeffw4A0Ov18Pb2xosvvojXX3/9muNjY2Px8ccf49SpU7C2tm6VNv+KgYXo5uobdYhPL8b6I3nYe7oEV96Qhq1CjicHdsHc+3vycRER3VFt9khIq9UiOTkZkZGRfzQgkyEyMhIJCQnNnrN161ZERERgxowZUKvVCA4Oxvvvvw+dTtfiNuvr61FZWdlkI6IbU1rJcX9vD3wzZSAOvj4Sr47uDj8XO9Rqdfh6fw7e2nICFjCkjYgslFGBpbS0FDqdDmq1usl+tVoNjUbT7DlnzpzBhg0boNPpsGPHDrz11lv49NNP8d5777W4zYULF8LR0dGweXt7G9MNonbP3VGFF4b7I/6Vu7F4fB8IAvC/xFz86+fTUpdGRNSsNl9LSK/Xw83NDV999RXCwsIwfvx4/POf/0RsbGyL25w7dy4qKioMW15eXitWTNR+CIKAsX298N7YYADAkt1ZWHkgR+KqiIiuZdRIOxcXF8jlchQVFTXZX1RUBHd392bP8fDwgLW1NeTyP6YO79mzJzQaDbRabYvaVCqVUCq5jgpRa5kY3hUXqrX49OfTePvH39HRToExfbykLouIyMCoOywKhQJhYWGIj4837NPr9YiPj0dERESz5wwZMgRZWVnQ6/WGfadPn4aHhwcUCkWL2iSi1jdzhD8mD/YBALzy/THsPV0ibUFERH9i9COhmJgYLFu2DKtWrUJ6ejqmT5+OmpoaTJkyBQAQHR2NuXPnGo6fPn06Lly4gFmzZuH06dPYvn073n//fcyYMeOW2ySiticIAuY9GISHQz3RqBfx/H+TcTT3otRlEREBMPKREACMHz8eJSUlmDdvHjQaDfr06YO4uDjDoNnc3FzIZH/kIG9vb+zcuRMvv/wyQkJC4OXlhVmzZuG111675TaJ6M6QyQR8Mi4U5ZcasO90CaasPIwNz0fA381e6tKIqJ3j1PxEdI1abSOeXJaI1LxyeDiq8MP0wfB0spG6LCKyMG0+NT8RWTZbhRW+mTwA/m4dUFhRh0nLE3GhRit1WUTUjjGwEFGzOtopsPqZgfB0VCG7pAZTVh5GTX3jzU8kImoDDCxEdF2eTjZY/Ww4Otpa41heOZ7/NhnaRv3NTyQiamUMLER0Q/5uHfDNlIGwVcjxW2YpXll/DEWVdSiurENxVR1KqupRWl2Psup6XKjR4mKNFuW1WlTUNqDiUgMadQw4RHT7OOiWiG7JvtMleHbVYTTojPsnw8nWGi+NCMCkiK6wlvP/SET0Bw66JaJWd1egKz6b0BfOdgrIBEC4xYWdy2sbsGDb74havA+/nirmAotE1CK8w0JEt00URYgiIF79OQBRBPSiiE1Hz+OTnRkou/KW0V2BrnjzgZ4IVHNuF6L2zpjvbwYWImpzlXUNWPprFr7ZfxZanR5ymYCJ4V0wOzIQnewUUpdHRBJhYCEik3SurAbv70jHzpOXFzt1UFlhVmQgJg3qCoUVn1ATtTcMLERk0g5ml+LdbelIL6wEAPi52OGfD/TEiB5uEG51cAwRmT0GFiIyeTq9iPVH8vDJrgyUVl8e3zLU3wVvPtgTPdz595ioPWBgISKzUVXXgKW/ZmPF/hxodXrIBGDCwC6IuTcQLh2UUpdHRG2IgYWIzE5uWS3e35GOuJMaAIC90gozR/hj8hAfKK3kEldHRG2BgYWIzNahM2V4d9vvOFlweXxLl062eOP+Hojq5c7xLUQWhoGFiMyaXi/ih5R8fLQzAyVV9QCAcN9OeOvBIAR7OUpcHRG1FgYWIrIINfWNiN2bja/2nUF9ox6CADzerzP+EdUdbg4qqcsjotvEwEJEFuV8+SV8FHcKW1ILAAC2CjleGN4Nzw3zg8qa41uIzBUDCxFZpJTci3h32+84mlsOAHDpoEAf747o6WGPnh4O6OFuj67OdpDLONaFyBwwsBCRxRJFEVuPFeDDn06hoKLums9V1jJ0V9ujh7sDenhc/rGnhz2cbLkEAJGpYWAhIotX16DD0dxyZGgqkV5YhVOaSmQUVaGuQd/s8e4OKvytf2fMjgyEjHdgiEwCAwsRtUs6vYhzZTU4panCqcJKpGsuB5m8C5cMx9wX7I5/je/DsS9EJoCBhYjoT6rqGvDTCQ3e3HQCWp0eYV07Yll0f64UTSQxY76/uTwqEVk8e5U1/tbfG6ufHQgHlRWSz13EY18cxLmyGqlLI6JbxMBCRO3GID9nbHxhMLycbJBTWoNH/3MQR3MvSl0WEd0CBhYialf83eyxacZgBHs5oKxGiyeWHcKuK+sXEZHpYmAhonbHzV6FddMicE93V9Q16PH3b5Ox6uBZqcsiohtgYCGidslOaYVl0f3xxMAuEEVg/taTeH9HOvR6s38PgcgiMbAQUbtlJZfh/UeC8Y+o7gCAr/adwYtrj6KuQSdxZUT0VwwsRNSuCYKAGff4Y/H4PrCWC9h+vBCTlieivFYrdWlE9CcMLEREAMb29cKqZwbCXmWFw2cv4pH/HMTnuzOxJ6MYZdX1UpdH1O5x4jgioj85XVSFySuSrlmnyNNRhWAvRwR7OaL3lR9d7ZUSVUlkGTjTLRHRbSirrsemo+dxPL8CJwoqkFNag+b+pXR3UBkCzN3dXdHH2+mO10pkzhhYiIhaUVVdA34vqETa+QqcOF+BtPMVONNMiLk70BUv3xvI4EJ0ixhYiIjaWHV9I9ILK5GWX4Hk3IuIO6GB7sor0SN7uOHlewMR7OUocZVEpo2BhYjoDjtXVoN/787CxpR8XJ3KJaqXGi/fG4ge7vx3iag5DCxERBI5U1KNJfGZ2HKswPDI6IEQD8weGYAAtb20xRGZGAYWIiKJZRZVYXF8JrYfLwQACAIwJtQTL40MgJ9rB4mrIzINxnx/t2gelqVLl8LHxwcqlQrh4eFISkq67rErV66EIAhNNpVK1eSYyZMnX3PM6NGjW1IaEZFJCFDbY+mT/fDTrGGI6qWGKAKbUwsQuWgvXvn+GJLPXeAyAERGsDL2hHXr1iEmJgaxsbEIDw/H4sWLERUVhYyMDLi5uTV7joODAzIyMgy/FgThmmNGjx6Nb775xvBrpZLzGxCR+evp4YAvJ/XHifMV+NfPpxF/qhg/pOTjh5R8uNorMSpIjdHB7hjk5wxrOefyJLoeowPLokWLMHXqVEyZMgUAEBsbi+3bt2PFihV4/fXXmz1HEAS4u7vfsF2lUnnTY4iIzFWwlyOWTx6A1LxyfHMgB7vTi1FSVY/vEnPxXWIuHFRWiAxSI6qXO+4KcIWNQi51yUQmxajAotVqkZycjLlz5xr2yWQyREZGIiEh4brnVVdXo2vXrtDr9ejXrx/ef/999OrVq8kxe/bsgZubGzp27IgRI0bgvffeg7Ozc7Pt1dfXo77+j6myKysrjekGEZFk+ng74bMJfaFt1ONgdil2ntRg18kilNVosTHlPDamnIeNtRzDu7tidLA77unhBgeVtdRlE0nOqEG3BQUF8PLywsGDBxEREWHY/+qrr2Lv3r1ITEy85pyEhARkZmYiJCQEFRUV+OSTT7Bv3z6cPHkSnTt3BgCsXbsWtra28PX1RXZ2Nt544w106NABCQkJkMuv/V/G22+/jXfeeeea/Rx0S0TmSKcXkXzu8lwuO09qcL78kuEza7mA4d3dMH14N/Tr0lHCKolaX5u9JdSSwPJXDQ0N6NmzJ5544gm8++67zR5z5swZdOvWDb/88gtGjhx5zefN3WHx9vZmYCEisyeKIk4WVCLuhAZxJzXIKq42fDYswAUvjQzAAJ9OElZI1HqMCSxGPRJycXGBXC5HUVFRk/1FRUW3PP7E2toaffv2RVZW1nWP8fPzg4uLC7KyspoNLEqlkoNyicgiCYJgWGRxTlR3nC6qwrJ9Z7Dx6Hn8llmK3zJLEeHnjJdGBiCiW/OPzYkskVFD0hUKBcLCwhAfH2/Yp9frER8f3+SOy43odDqkpaXBw8Pjusfk5+ejrKzshscQEbUHgWp7fDwuFL++MhxPDPSGtVxAwpkyPLHsEP4Wm4D9maWwgOm0iG7K6Inj1q1bh6effhpffvklBg4ciMWLF+P777/HqVOnoFarER0dDS8vLyxcuBAAsGDBAgwaNAj+/v4oLy/Hxx9/jM2bNyM5ORlBQUGorq7GO++8g8ceewzu7u7Izs7Gq6++iqqqKqSlpd3SnRROHEdE7cX58kuI3ZONdYfzoNXpAQD9ujjhpZEBuDvQtdlpI4hMVZs9EgKA8ePHo6SkBPPmzYNGo0GfPn0QFxcHtVoNAMjNzYVM9seNm4sXL2Lq1KnQaDTo2LEjwsLCcPDgQQQFBQEA5HI5jh8/jlWrVqG8vByenp4YNWoU3n33XT72ISL6Cy8nG7w7Nhgz7vFH7N5srEnKRUpuOSZ/cxihnR3x0sgAjOjhxuBCFodT8xMRmbHiyjp8te8Mvk08h7qGy3dcQr2dMPe+HhjkxzEuZNq4lhARUTtTWl2PZb+dwX8TzqFWqwMAjOjhhtdG90B3dy66SKaJgYWIqJ0qrqrDkvhMrEnKg04vQiYAj/XrjJhRgfBwtJG6PKImGFiIiNq57JJqfLIzAz+d0AAAlFYyTB7igxeG+8PRhjPnkmlgYCEiIgBASu5FfLDjFJLOXgAAONpYY+Y9/pgU0RUqa65XRNJiYCEiIgNRFBGfXowP404h88rMuV5ONnhlVCDG9vGCTMY3ikgaDCxERHSNRp0eP6TkY9HPp1FUeXl5k54eDnjzgZ4Y4u8icXXUHjGwEBHRdV3S6vDNwRx88Ws2quobAQCRPd0w9/6e6ObaQeLqqD1hYCEiopu6UKPFZ7+cxreJudDpRVjJBDw1qCtmRwbAyVYhdXnUDjCwEBHRLcsqrsb7O9Kx+1QxgMsDc18aGYBJg7pCYWXUknNERmFgISIio/2WWYL/256OU5oqAICvix3euL8nIntyqn9qGwwsRETUIjq9iO+P5OHTXRkordYCACL8nPHmgz3Ry9NR4urI0jCwEBHRbamqa8AXe7Lx9f4caBv1EARgXFhnvDQyAJ072kpdHlkIBhYiImoVeRdq8dHODPx4rMCwL8LPGY/288J9vT3QQWklYXVk7hhYiIioVSWfu4hPd2XgYHaZYZ/KWobRvdzxaL/OGOLvAjknoCMjMbAQEVGbyLtQiy2p57Ex5TzOlNYY9qsdlBjbxwuP9uvM1aHpljGwEBFRmxJFEal55diYch5bjxWg4lKD4bNeng54tF9n3BfsDkcba1jLZbCWC3zTiK7BwEJERHdMfaMOv54qwcaUfPyaUYwGXfNfK9Zy4Up4kRlCzJ9/DPJ0wPj+3hjo24nhpp1gYCEiIklcqNFi2/EC/JByHsfyylvUhp+rHSYM8MZj/TrDuYOydQskk8LAQkREkmvU6dGgE6HV6dFwdWv8y691emgbRdRqG7HrZBF+PF6AWq0OwOU7MqOC3DFhoDeGdHPhqtIWiIGFiIjMUlVdA348Voi1h3NxPL/CsN+7kw3G9/fGuP7eUDuoJKyQWhMDCxERmb2TBRVYm5SHzUfPG1aVlssE3NPdDU+Ge+Oe7lwywNwxsBARkcW4pNVhe1oh1ibl4si5i4b9j/bzwoePhcBazgUazRUDCxERWaTMoiqsScrDqoSz0OlFRPZ0w+dP9oPKWi51adQCxnx/M5YSEZHZCFDbY95DQYh9KgwKKxl+SS9G9IokVNY13PxkMmsMLEREZHbuDVJj9TMDYa+0QlLOBUz48hBKquqlLovaEAMLERGZpUF+zlgzbRBcOijwe2ElxsUeRN6FWqnLojbCwEJERGYr2MsR658fDC8nG5wtq8XjsQdxuqhK6rKoDTCwEBGRWfN1scMP0wcjwK0Diirr8bcvE3A09+LNTySzwsBCRERmz91RhfXPR6CPtxPKaxsw8etE/JZZInVZ1IoYWIiIyCI42Srw3XPhGBbgglqtDs+sPIztxwvb7PfLu1CLeVtOYM76Y6i5MrEdtR0rqQsgIiJqLXZKK3z9dH/EfH8M248XYuaaFJRfCsbE8K6t9nucKanGf/ZkY9PR89DpL09lVlhxCSsmD4DSivPBtBXeYSEiIouitJJjyYS+eDK8C0QR+OemE/i/7b8js6gKtzNX6umiKry05igiF+3FhuR86PQiBndzhp1CjgNZZZi1JhWNOn0r9oT+jDPdEhGRRRJFEZ/uOo3Pf80y7PPuZIMR3d0woqca4b6dbmmG3JMFFfh8dxZ+OqEx7BvZww0zR/ijb5eOOJhViskrD0PbqMe4sM748LEQrix9izg1PxER0RXbjhdgQ3I+DmaXQdv4xx0QW4UcQ/1dMLKnG+7p7ga3v6wCfSyvHP/enYlf0osN+0b3csfMEf4I9nJscuyukxpM/y4FOr2IZ4f64s0HenJhxlvAwEJERPQXtdpGHMgqw+5TRYhPL0bxX2bG7e3liBE93NDTwwH/S8rFvtOX3zKSCcCDIZ6YOcIfgWr767a/ITkfc9YfAwDMGRWImSMC2q4zFoKBhYiI6AZEUcTJgkrEpxdjd0YxjuWVX3OMXCZgbB8vzLinG/xcO9xSuyv252DBtt8BAAvG9EJ0hE8rVm15GFiIiIiMUFxVhz0ZJdidXowTBRUYFuCC6Xf7o4uzrdFtLfr5NJbEZwIAFo/vg7F9vVq7XIvR5qs1L126FD4+PlCpVAgPD0dSUtJ1j125ciUEQWiyqVRNnxOKooh58+bBw8MDNjY2iIyMRGZmZktKIyIiMpqbvQp/6++N2Elh2P/aCCx8NKRFYQUAXo4MwOTBPgCAV9YfQ3x6UStW2n4ZHVjWrVuHmJgYzJ8/HykpKQgNDUVUVBSKi4uve46DgwMKCwsN27lz55p8/tFHH2HJkiWIjY1FYmIi7OzsEBUVhbq6OuN7REREJCFBEDDvwSA80tcLOr2IF75LwaEzZVKXZfaMDiyLFi3C1KlTMWXKFAQFBSE2Nha2trZYsWLFdc8RBAHu7u6GTa1WGz4TRRGLFy/Gm2++iTFjxiAkJASrV69GQUEBNm/e3KJOERERSUkmE/DR4yGI7OmG+kY9nlt1BCfOV0hdllkzKrBotVokJycjMjLyjwZkMkRGRiIhIeG651VXV6Nr167w9vbGmDFjcPLkScNnOTk50Gg0Tdp0dHREeHj4ddusr69HZWVlk42IiMiUWMtl+PzJfgj37YTq+kZEr0hCVnG11GWZLaMCS2lpKXQ6XZM7JACgVquh0WiaPad79+5YsWIFtmzZgm+//RZ6vR6DBw9Gfn4+ABjOM6bNhQsXwtHR0bB5e3sb0w0iIqI7QmUtx9dP90dvL0dcqNFi0vJE5F+slboss9TmU/NHREQgOjoaffr0wd13342NGzfC1dUVX375ZYvbnDt3LioqKgxbXl5eK1ZMRETUeuxV1lg5ZQC6udqhsKIOr/+QJnVJZsmowOLi4gK5XI6ioqYjnouKiuDu7n5LbVhbW6Nv377Iyro8VfLV84xpU6lUwsHBoclGRERkqpw7KLFi8gDIZQL2Z5UivZBDGYxlVGBRKBQICwtDfHy8YZ9er0d8fDwiIiJuqQ2dToe0tDR4eHgAAHx9feHu7t6kzcrKSiQmJt5ym0RERKauq7MdRve6/B/xFftzJK7G/Bj9SCgmJgbLli3DqlWrkJ6ejunTp6OmpgZTpkwBAERHR2Pu3LmG4xcsWIBdu3bhzJkzSElJwVNPPYVz587hueeeA3D5DaLZs2fjvffew9atW5GWlobo6Gh4enpi7NixrdNLIiIiE/DMUF8AwJbUApT8ZWkAujErY08YP348SkpKMG/ePGg0GvTp0wdxcXGGQbO5ubmQyf7IQRcvXsTUqVOh0WjQsWNHhIWF4eDBgwgKCjIc8+qrr6KmpgbTpk1DeXk5hg4diri4uGsmmCMiIjJnYV07oo+3E1LzyvHtoXN4+d5AqUsyG5yan4iI6A768VgBXlxzFC4dFNj/2giorOVSlySZNp+an4iIiFrmvmB3eDqqUFqtxdZjBVKXYzYYWIiIiO4gK7kM0VfWGlqxPwcW8KDjjmBgISIiusOeGNAFNtZynNJU4WA21xm6FQwsREREd5ijrTXG9e8MAFjOV5xvCQMLERGRBKYM8YUgALtPFSO7hGsM3QwDCxERkQR8XewwsocbAGDlgbPSFmMGGFiIiIgk8syQyxPJbUjOR3mtVuJqTBsDCxERkUQiujmjh7s9LjXosCaJC/neCAMLERGRRARBwLNXputfdfAsGnR6iSsyXQwsREREEnq4jydcOiihqazDjrRCqcsxWQwsREREElJayTFpUFcAnEjuRhhYiIiIJDZxUBcorGQ4ll+BlNyLUpdjkhhYiIiIJObSQYmxfTwBcCK562FgISIiMgHPXBl8G3dCg7wLtRJXY3oYWIiIiExAD3cHDPV3gV68/MYQNcXAQkREZCKuvuK87nAequsbJa7GtDCwEBERmYi7A13h52qHqvpGrD/CieT+jIGFiIjIRMhkAqZcma7/mwNnodPzFeerGFiIiIhMyGP9vOBoY43cC7X4Jb1I6nJMBgMLERGRCbFVWOHJ8C4A+IrznzGwEBERmZinI3xgJROQlHMBJwsqpC7HJDCwEBERmRh3RxXuDVIDALamFkhcjWlgYCEiIjJBD4denvl22/FCri8EBhYiIiKTdE8PN9gp5DhffglH88qlLkdyDCxEREQmSGUtR+SVx0LbjhVKXI30GFiIiIhM1IMhlx8LbU8rgL6dz8nCwEJERGSi7gp0gb3KCkWV9Th89oLU5UiKgYWIiMhEKa3kGBXkDuDy4Nv2jIGFiIjIhD0U6gEA+OlEIRp1eomrkQ4DCxERkQkb4u+CjrbWKK3WIjGn/T4WYmAhIiIyYdZyGUYHX30s1H4nkWNgISIiMnFX3xb66YQGDe30sRADCxERkYkL9+0Elw4KlNc2YH9WqdTlSIKBhYiIyMRZyWW4v/flwbftdRI5BhYiIiIzcPWx0K7fNahv1ElczZ3HwEJERGQG+nftCHcHFarqGrHvdPt7LMTAQkREZAZkMuGPx0Lt8G2hFgWWpUuXwsfHByqVCuHh4UhKSrql89auXQtBEDB27Ngm+ydPngxBEJpso0ePbklpREREFuvBK5PI/fx7ES5p29djIaMDy7p16xATE4P58+cjJSUFoaGhiIqKQnFx8Q3PO3v2LObMmYNhw4Y1+/no0aNRWFho2NasWWNsaURERBatr7cTvJxsUKvV4deMG3/vWhqjA8uiRYswdepUTJkyBUFBQYiNjYWtrS1WrFhx3XN0Oh0mTpyId955B35+fs0eo1Qq4e7ubtg6duxobGlEREQWTRAEw12W9vZYyKjAotVqkZycjMjIyD8akMkQGRmJhISE6563YMECuLm54dlnn73uMXv27IGbmxu6d++O6dOno6ys7LrH1tfXo7KysslGRETUHjx05W2h3aeKUVPfKHE1d45RgaW0tBQ6nQ5qtbrJfrVaDY1G0+w5+/fvx/Lly7Fs2bLrtjt69GisXr0a8fHx+PDDD7F3717cd9990Omafz63cOFCODo6GjZvb29jukFERGS2enk6wMfZFnUNevySXiR1OXdMm74lVFVVhUmTJmHZsmVwcXG57nETJkzAww8/jN69e2Ps2LHYtm0bDh8+jD179jR7/Ny5c1FRUWHY8vLy2qgHREREpkUQBMOcLNuOt59J5KyMOdjFxQVyuRxFRU0TXVFREdzd3a85Pjs7G2fPnsVDDz1k2KfXX14DwcrKChkZGejWrds15/n5+cHFxQVZWVkYOXLkNZ8rlUoolUpjSiciIrIYD4Z64PNfs7A3owQVlxrgaGMtdUltzqg7LAqFAmFhYYiPjzfs0+v1iI+PR0RExDXH9+jRA2lpaUhNTTVsDz/8MO655x6kpqZe91FOfn4+ysrK4OHhYWR3iIiILF93tT383TpAq9Pj59/bx2Mhox8JxcTEYNmyZVi1ahXS09Mxffp01NTUYMqUKQCA6OhozJ07FwCgUqkQHBzcZHNycoK9vT2Cg4OhUChQXV2Nf/zjHzh06BDOnj2L+Ph4jBkzBv7+/oiKimrd3hIREVkAQRAMg2/by9tCRj0SAoDx48ejpKQE8+bNg0ajQZ8+fRAXF2cYiJubmwuZ7NZzkFwux/Hjx7Fq1SqUl5fD09MTo0aNwrvvvsvHPkRERNfxYKgH/vXLaezPLMXFGi062imkLqlNCaIoilIXcbsqKyvh6OiIiooKODg4SF0OERHRHXHfZ78hvbASHzzaGxMGdpG6HKMZ8/3NtYSIiIjM1IMhVyeRs/y3hRhYiIiIzNTVcSwHs0tRUlUvcTVti4GFiIjITHVxtkVIZ0foRSDuhGXfZWFgISIiMmNX77L8aOGPhRhYiIiIzNgDV8axHD57AUWVdRJX03YYWIiIiMyYp5MNwrp2hCgC2y34LgsDCxERkZm7+rbQ9jQGFiIiIjJRo4Mvr+d3NPciymu1ElfTNhhYiIiIzJyHow0C3DpALwIHssqkLqdNMLAQERFZgLsCXQEA+06XSFxJ22BgISIisgDDAlwAAL9llsACVt25BgMLERGRBQj3dYbCSoaCijpkl1RLXU6rY2AhIiKyADYKOcJ9OwEA9p4ulbia1sfAQkREZCH+/FjI0jCwEBERWYirA28PnSlDXYNO4mpaFwMLERGRheiutoebvRJ1DXokn7sodTmtioGFiIjIQgiCgGEBlvl6MwMLERGRBbkr8PI4lr0MLERERGSqhvq7QBCAU5oqFFvQ6s0MLERERBbEuYMSwZ6OAIDfMi3n9WYGFiIiIgtz9bHQPgt6vZmBhYiIyMJcHXi7P7MUer1lTNPPwEJERGRh+nXpCDuFHGU1WvxeWCl1Oa2CgYWIiMjCKKxkiOhmWW8LMbAQERFZoKvjWCxlmn4GFiIiIgt015VxLMnnLqKmvlHiam4fAwsREZEF8nGxQ5dOtmjQiUjILpO6nNvGwEJERGShLGn1ZgYWIiIiC3V19eZ9FjCBHAMLERGRhRrczRlymYCc0hrkXaiVupzbwsBCRERkoexV1ujXxQmA+c96y8BCRERkwa6+LbTPzOdjYWAhIiKyYFfHsRzMKkODTi9xNS3HwEJERGTBgr0c4WRrjar6RhzLK5e6nBZjYCEiIrJgcpmAof5XVm8248dCDCxEREQW7upjob1m/HozAwsREZGFuzqB3PH8cpTXaiWupmVaFFiWLl0KHx8fqFQqhIeHIykp6ZbOW7t2LQRBwNixY5vsF0UR8+bNg4eHB2xsbBAZGYnMzMyWlEZERER/4eFog0B1B4gisD/LPO+yGB1Y1q1bh5iYGMyfPx8pKSkIDQ1FVFQUiouLb3je2bNnMWfOHAwbNuyazz766CMsWbIEsbGxSExMhJ2dHaKiolBXV2dseURERNQMc3+92ejAsmjRIkydOhVTpkxBUFAQYmNjYWtrixUrVlz3HJ1Oh4kTJ+Kdd96Bn59fk89EUcTixYvx5ptvYsyYMQgJCcHq1atRUFCAzZs3G90hIiIiutawK+NYfssshSiKEldjPKMCi1arRXJyMiIjI/9oQCZDZGQkEhISrnveggUL4Obmhmefffaaz3JycqDRaJq06ejoiPDw8Bu2SURERLcu3LcTlFYyFFbUIau4WupyjGZlzMGlpaXQ6XRQq9VN9qvVapw6darZc/bv34/ly5cjNTW12c81Go2hjb+2efWzv6qvr0d9fb3h15WVlbfaBSIionZJZS3HQN9O+C2zFHtPlyBAbS91SUZp07eEqqqqMGnSJCxbtgwuLi6t1u7ChQvh6Oho2Ly9vVutbSIiIkt1dRzLb2b4erNRgcXFxQVyuRxFRUVN9hcVFcHd3f2a47Ozs3H27Fk89NBDsLKygpWVFVavXo2tW7fCysoK2dnZhvNutU0AmDt3LioqKgxbXl6eMd0gIiJql67Ox5KYU4a6Bp3E1RjHqMCiUCgQFhaG+Ph4wz69Xo/4+HhERERcc3yPHj2QlpaG1NRUw/bwww/jnnvuQWpqKry9veHr6wt3d/cmbVZWViIxMbHZNgFAqVTCwcGhyUZEREQ3FqjuALWDEnUNehw5e1Hqcoxi1BgWAIiJicHTTz+N/v37Y+DAgVi8eDFqamowZcoUAEB0dDS8vLywcOFCqFQqBAcHNznfyckJAJrsnz17Nt577z0EBATA19cXb731Fjw9Pa+Zr4WIiIhaThAEDAtwxYbkfOzLLMHQgNYbrtHWjA4s48ePR0lJCebNmweNRoM+ffogLi7OMGg2NzcXMplxQ2NeffVV1NTUYNq0aSgvL8fQoUMRFxcHlUplbHlERER0A3cFXgksp0vwxv09pS7nlgmiOb6M/ReVlZVwdHRERUUFHw8RERHdwIUaLcLe+xmiCCS9MRJuDtLdHDDm+5trCREREbUjnewU6O3lCACIO9n89CGmiIGFiIionXm0rxcAIHZPNuobzeNtIQYWIiKidmbCwC5wd1ChoKIO6w6bx9QgDCxERETtjMpajhkj/AEAS3/NMos5WRhYiIiI2qG/9e8MLycbFFXW43+JuVKXc1MMLERERO2Q0kqOmVfusvxnTzYuaU37LgsDCxERUTv1eFhneHeyQWl1Pf576KzU5dwQAwsREVE7ZS2X4aURAQCA2L1nUFPfKHFF18fAQkRE1I490tcLPs62uFCjxaqEs1KXc10MLERERO2YlVyGWZGX77J8te8MquoaJK6oeQwsRERE7dzDoV7o5mqH8toGfHPgrNTlNIuBhYiIqJ2TywTMjgwEACz77QwqLpneXRYGFiIiIsIDvT3QXW2PqrpGLP/tjNTlXIOBhYiIiCCTCXj53stjWVYcOIuLNVqJK2qKgYWIiIgAAKOC3BHk4YDq+kYsM7G7LAwsREREBODqXZbLY1lWHjyLsup6iSv6AwMLERERGUT2dENIZ0fUanX4cp/p3GVhYCEiIiIDQfjjLsvqhLMorqqTuKLLGFiIiIioieGBrujbxQl1DXp8sSdb6nIAMLAQERHRXwiCgJgrd1m+S8yFpkL6uywMLERERHSNof4uGOjTCdpGPf6zJ0vqchhYiIiI6Fp/HsuyNikP58svSVoPAwsRERE1K6KbMyL8nKHV6fH5bmnvsjCwEBER0XXFjLp8l2X9kTzkXaiVrA4ryX5nIiIiMnkDfDphYngXDPDpBE8nG8nqYGAhIiKiG/q/R3pLXQIfCREREZHpY2AhIiIik8fAQkRERCaPgYWIiIhMHgMLERERmTwGFiIiIjJ5DCxERERk8hhYiIiIyOQxsBAREZHJY2AhIiIik8fAQkRERCaPgYWIiIhMHgMLERERmTyLWK1ZFEUAQGVlpcSVEBER0a26+r199Xv8RiwisFRVVQEAvL29Ja6EiIiIjFVVVQVHR8cbHiOItxJrTJxer0dBQQHs7e0hCEKrtl1ZWQlvb2/k5eXBwcGhVds2Jeyn5WgPfQTYT0vDfloOY/ooiiKqqqrg6ekJmezGo1Qs4g6LTCZD586d2/T3cHBwsNg/XH/GflqO9tBHgP20NOyn5bjVPt7szspVHHRLREREJo+BhYiIiEweA8tNKJVKzJ8/H0qlUupS2hT7aTnaQx8B9tPSsJ+Wo636aBGDbomIiMiy8Q4LERERmTwGFiIiIjJ5DCxERERk8hhYiIiIyOQxsNzE0qVL4ePjA5VKhfDwcCQlJUldUqt6++23IQhCk61Hjx5Sl3Vb9u3bh4ceegienp4QBAGbN29u8rkoipg3bx48PDxgY2ODyMhIZGZmSlPsbbhZPydPnnzNtR09erQ0xd6GhQsXYsCAAbC3t4ebmxvGjh2LjIyMJsfU1dVhxowZcHZ2RocOHfDYY4+hqKhIooqNdyt9HD58+DXX8/nnn5eo4pb54osvEBISYphQLCIiAj/99JPhc3O/jlfdrJ+WcC3/6oMPPoAgCJg9e7ZhX2tfTwaWG1i3bh1iYmIwf/58pKSkIDQ0FFFRUSguLpa6tFbVq1cvFBYWGrb9+/dLXdJtqampQWhoKJYuXdrs5x999BGWLFmC2NhYJCYmws7ODlFRUairq7vDld6em/UTAEaPHt3k2q5Zs+YOVtg69u7dixkzZuDQoUP4+eef0dDQgFGjRqGmpsZwzMsvv4wff/wR69evx969e1FQUIBHH31UwqqNcyt9BICpU6c2uZ4fffSRRBW3TOfOnfHBBx8gOTkZR44cwYgRIzBmzBicPHkSgPlfx6tu1k/A/K/lnx0+fBhffvklQkJCmuxv9esp0nUNHDhQnDFjhuHXOp1O9PT0FBcuXChhVa1r/vz5YmhoqNRltBkA4qZNmwy/1uv1oru7u/jxxx8b9pWXl4tKpVJcs2aNBBW2jr/2UxRF8emnnxbHjBkjST1tqbi4WAQg7t27VxTFy9fP2tpaXL9+veGY9PR0EYCYkJAgVZm35a99FEVRvPvuu8VZs2ZJV1Qb6dixo/j1119b5HX8s6v9FEXLupZVVVViQECA+PPPPzfpV1tcT95huQ6tVovk5GRERkYa9slkMkRGRiIhIUHCylpfZmYmPD094efnh4kTJyI3N1fqktpMTk4ONBpNk+vq6OiI8PBwi7uuALBnzx64ubmhe/fumD59OsrKyqQu6bZVVFQAADp16gQASE5ORkNDQ5Nr2qNHD3Tp0sVsr+lf+3jVd999BxcXFwQHB2Pu3Lmora2VorxWodPpsHbtWtTU1CAiIsIiryNwbT+vspRrOWPGDDzwwANNrhvQNn8vLWLxw7ZQWloKnU4HtVrdZL9arcapU6ckqqr1hYeHY+XKlejevTsKCwvxzjvvYNiwYThx4gTs7e2lLq/VaTQaAGj2ul79zFKMHj0ajz76KHx9fZGdnY033ngD9913HxISEiCXy6Uur0X0ej1mz56NIUOGIDg4GMDla6pQKODk5NTkWHO9ps31EQCefPJJdO3aFZ6enjh+/Dhee+01ZGRkYOPGjRJWa7y0tDRERESgrq4OHTp0wKZNmxAUFITU1FSLuo7X6ydgOddy7dq1SElJweHDh6/5rC3+XjKwtHP33Xef4echISEIDw9H165d8f333+PZZ5+VsDK6XRMmTDD8vHfv3ggJCUG3bt2wZ88ejBw5UsLKWm7GjBk4ceKE2Y+zupHr9XHatGmGn/fu3RseHh4YOXIksrOz0a1btztdZot1794dqampqKiowIYNG/D0009j7969UpfV6q7Xz6CgIIu4lnl5eZg1axZ+/vlnqFSqO/J78pHQdbi4uEAul18zormoqAju7u4SVdX2nJycEBgYiKysLKlLaRNXr117u64A4OfnBxcXF7O9tjNnzsS2bdvw66+/onPnzob97u7u0Gq1KC8vb3K8OV7T6/WxOeHh4QBgdtdToVDA398fYWFhWLhwIUJDQ/HZZ59Z1HUErt/P5pjjtUxOTkZxcTH69esHKysrWFlZYe/evViyZAmsrKygVqtb/XoysFyHQqFAWFgY4uPjDfv0ej3i4+ObPIe0NNXV1cjOzoaHh4fUpbQJX19fuLu7N7mulZWVSExMtOjrCgD5+fkoKyszu2sriiJmzpyJTZs2Yffu3fD19W3yeVhYGKytrZtc04yMDOTm5prNNb1ZH5uTmpoKAGZ3Pf9Kr9ejvr7eIq7jjVztZ3PM8VqOHDkSaWlpSE1NNWz9+/fHxIkTDT9v9et5+2OELdfatWtFpVIprly5Uvz999/FadOmiU5OTqJGo5G6tFbzyiuviHv27BFzcnLEAwcOiJGRkaKLi4tYXFwsdWktVlVVJR49elQ8evSoCEBctGiRePToUfHcuXOiKIriBx98IDo5OYlbtmwRjx8/Lo4ZM0b09fUVL126JHHlxrlRP6uqqsQ5c+aICQkJYk5OjvjLL7+I/fr1EwMCAsS6ujqpSzfK9OnTRUdHR3HPnj1iYWGhYautrTUc8/zzz4tdunQRd+/eLR45ckSMiIgQIyIiJKzaODfrY1ZWlrhgwQLxyJEjYk5OjrhlyxbRz89PvOuuuySu3Divv/66uHfvXjEnJ0c8fvy4+Prrr4uCIIi7du0SRdH8r+NVN+qnpVzL5vz17afWvp4MLDfx73//W+zSpYuoUCjEgQMHiocOHZK6pFY1fvx40cPDQ1QoFKKXl5c4fvx4MSsrS+qybsuvv/4qArhme/rpp0VRvPxq81tvvSWq1WpRqVSKI0eOFDMyMqQtugVu1M/a2lpx1KhRoqurq2htbS127dpVnDp1qlmG7eb6CED85ptvDMdcunRJfOGFF8SOHTuKtra24iOPPCIWFhZKV7SRbtbH3Nxc8a677hI7deokKpVK0d/fX/zHP/4hVlRUSFu4kZ555hmxa9euokKhEF1dXcWRI0cawooomv91vOpG/bSUa9mcvwaW1r6egiiKYsvuzRARERHdGRzDQkRERCaPgYWIiIhMHgMLERERmTwGFiIiIjJ5DCxERERk8hhYiIiIyOQxsBAREZHJY2AhIiIik8fAQkRERCaPgYWIiIhMHgMLERERmTwGFiIiIjJ5/w81LoT5J6c7iAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred = []\n", + "y_true = []\n", + "for i, data in enumerate(testloader):\n", + " inputs, targets = data\n", + "\n", + " outputs = my_model(inputs)\n", + " preds = torch.argmax(outputs, axis=1)\n", + "\n", + " y_pred.extend(preds.tolist())\n", + " y_true.extend(targets.tolist())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "precision: 87.848%\n", + "recall: 100.000%\n", + "f1: 93.531%\n", + "support: 1482\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/vscode/.local/lib/python3.12/site-packages/sklearn/metrics/_classification.py:1517: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + ] + } + ], + "source": [ + "precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred)\n", + "print(\"precision: {:.3f}%\".format(precision[1]*100))\n", + "print(\"recall: {:.3f}%\".format(recall[1]*100))\n", + "print(\"f1: {:.3f}%\".format(f1[1]*100))\n", + "print(\"support: {}\".format(support[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "disp = ConfusionMatrixDisplay(confusion_matrix(y_true, y_pred))\n", + "disp.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Provider flow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Authenticate with Nillion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To connect to the Nillion network, we need to have a user key and a node key. These serve different purposes:\n", + "\n", + "The `user_key` is the user's private key. The user key should never be shared publicly, as it unlocks access and permissions to secrets stored on the network.\n", + "\n", + "The `node_key` is the node's private key which is run locally to connect to the network." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load all Nillion network environment variables\n", + "assert os.getcwd().endswith(\n", + " \"examples/multi_layer_perceptron\"\n", + "), \"Please run this script from the examples/multi_layer_perceptron directory otherwise, the rest of the tutorial may not work\"\n", + "load_dotenv()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/tmp/tmpr0ektdn9\n" + ] + } + ], + "source": [ + "cluster_id = os.getenv(\"NILLION_CLUSTER_ID\")\n", + "print(os.getenv(\"NILLION_USERKEY_PATH_PARTY_1\"))\n", + "model_provider_userkey = getUserKeyFromFile(os.getenv(\"NILLION_USERKEY_PATH_PARTY_1\"))\n", + "model_provider_nodekey = getNodeKeyFromFile(os.getenv(\"NILLION_NODEKEY_PATH_PARTY_1\"))\n", + "model_provider_client = create_nillion_client(\n", + " model_provider_userkey, model_provider_nodekey\n", + ")\n", + "model_provider_party_id = model_provider_client.party_id\n", + "model_provider_user_id = model_provider_client.user_id" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "model_user_userkey = getUserKeyFromFile(os.getenv(\"NILLION_USERKEY_PATH_PARTY_2\"))\n", + "model_user_nodekey = getNodeKeyFromFile(os.getenv(\"NILLION_NODEKEY_PATH_PARTY_2\"))\n", + "model_user_client = create_nillion_client(model_user_userkey, model_user_nodekey)\n", + "model_user_party_id = model_user_client.party_id\n", + "model_user_user_id = create_nillion_client(\n", + " model_user_userkey, model_user_nodekey\n", + ").user_id" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Upload Nada program to Nillion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TODO: explain what the Nada program does" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "async def store_program(\n", + " *,\n", + " client: nillion.NillionClient,\n", + " cluster_id: str,\n", + " user_id: str,\n", + " nada_program_path: str,\n", + ") -> Dict[str, str]:\n", + " \"\"\"Stores Nada program binary in Nillion network.\n", + "\n", + " Args:\n", + " client (nillion.NillionClient): Client that will upload Nada program.\n", + " cluster_id (str): Nillion cluster ID.\n", + " user_id (str): User ID of user that will upload Nada program.\n", + " nada_program_path (str): Path to Nada program binary.\n", + "\n", + " Returns:\n", + " Dict[str, str]: Resulting `action_id` and `program_id`.\n", + " \"\"\"\n", + " action_id = await client.store_program(cluster_id, \"main\", nada_program_path)\n", + " program_id = f\"{user_id}/main\"\n", + "\n", + " return {\n", + " \"action_id\": action_id,\n", + " \"program_id\": program_id,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Program saved successfully!\n", + "action_id: 17da6b3d-16ff-401d-8223-f84001e87065\n", + "program_id: NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n" + ] + } + ], + "source": [ + "result_store_program = await store_program(\n", + " client=model_provider_client,\n", + " cluster_id=cluster_id,\n", + " user_id=model_provider_user_id,\n", + " nada_program_path=\"target/main.nada.bin\",\n", + ")\n", + "\n", + "action_id = result_store_program[\"action_id\"]\n", + "program_id = result_store_program[\"program_id\"]\n", + "\n", + "print(\"✅ Program saved successfully!\")\n", + "print(\"action_id:\", action_id)\n", + "print(\"program_id:\", program_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Upload weights to Nillion network" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Create and store model secrets via ModelClient\n", + "model_client = TorchClient(my_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "async def store_model(\n", + " *,\n", + " model_client: TorchClient,\n", + " client: nillion.NillionClient,\n", + " cluster_id: str,\n", + " program_id: str,\n", + " party_id: str,\n", + " model_user_user_id: str,\n", + " model_provider_user_id: str,\n", + ") -> Dict[str, str]:\n", + " \"\"\"Stores model params in Nillion network.\n", + "\n", + " Args:\n", + " model (MyModel): Model object to store in network.\n", + " client (nillion.NillionClient): Nillion client that stores model params.\n", + " cluster_id (str): Nillion cluster ID.\n", + " program_id (str): Program ID of Nada program.\n", + " party_id (str): Party ID of party that will store model params.\n", + " model_user_user_id (str): User ID of user that will get compute permissions.\n", + " model_provider_user_id (str): User ID of user that will provide model params.\n", + " precision (int): Desired precision.\n", + "\n", + " Returns:\n", + " Dict[str, str]: Resulting `provider_party_id` and `model_store_id`.\n", + " \"\"\"\n", + " \n", + " model_secrets = nillion.Secrets(\n", + " model_client.export_state_as_secrets(\"my_nn\", na.SecretRational)\n", + " )\n", + "\n", + "\n", + " secret_bindings = nillion.ProgramBindings(program_id)\n", + " secret_bindings.add_input_party(\"Party0\", party_id)\n", + "\n", + " permissions = nillion.Permissions.default_for_user(model_provider_user_id)\n", + " compute_permissions = {\n", + " model_user_user_id: {program_id},\n", + " }\n", + " # Give permission to model user to run inference\n", + " permissions.add_compute_permissions(compute_permissions)\n", + "\n", + " store_id = await client.store_secrets(\n", + " cluster_id, secret_bindings, model_secrets, permissions\n", + " )\n", + "\n", + " return {\n", + " \"provider_party_id\": party_id,\n", + " \"model_store_id\": store_id,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Model params uploaded successfully!\n", + "provider_party_id: 12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n", + "model_store_id: a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n" + ] + } + ], + "source": [ + "result_store_model = await store_model(\n", + " model_client=model_client,\n", + " client=model_provider_client,\n", + " cluster_id=cluster_id,\n", + " program_id=program_id,\n", + " party_id=model_provider_party_id,\n", + " model_user_user_id=model_user_user_id,\n", + " model_provider_user_id=model_provider_user_id,\n", + ")\n", + "\n", + "provider_party_id = result_store_model[\"provider_party_id\"]\n", + "model_store_id = result_store_model[\"model_store_id\"]\n", + "\n", + "print(\"✅ Model params uploaded successfully!\")\n", + "print(\"provider_party_id:\", provider_party_id)\n", + "print(\"model_store_id:\", model_store_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# This information is needed by the model user\n", + "with open(\"tmp.json\", \"w\") as provider_variables_file:\n", + " provider_variables = {\n", + " \"program_id\": program_id,\n", + " \"model_store_id\": model_store_id,\n", + " \"model_provider_party_id\": model_provider_party_id,\n", + " }\n", + " json.dump(provider_variables, provider_variables_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(my_model.state_dict(), \"./data/my_model.pt\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/multi_layer_perceptron/02_model_inference.ipynb b/examples/multi_layer_perceptron/02_model_inference.ipynb new file mode 100644 index 0000000..59acf1d --- /dev/null +++ b/examples/multi_layer_perceptron/02_model_inference.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**IMPORTANT**: Before starting this notebook make sure that the kernel of the previous notebook is shutdown or reset it's state to forget the previous `model_user` Nillion client" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "## If problems arise with the loading of the shared library, this script can be used to load the shared library before other libraries.\n", + "## Remember to also run on your local machine the script below:\n", + "# bash replace_lib_version.sh\n", + "\n", + "import platform\n", + "import ctypes\n", + "\n", + "if platform.system() == \"Linux\":\n", + " # Force libgomp and py_nillion_client to be loaded before other libraries consuming dynamic TLS (to avoid running out of STATIC_TLS)\n", + " ctypes.cdll.LoadLibrary(\"libgomp.so.1\")\n", + " ctypes.cdll.LoadLibrary(\n", + " \"/home/vscode/.local/lib/python3.12/site-packages/py_nillion_client/py_nillion_client.abi3.so\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict\n", + "import torch\n", + "import json\n", + "import os\n", + "import py_nillion_client as nillion\n", + "from torchvision import transforms\n", + "from PIL import Image\n", + "from dotenv import load_dotenv\n", + "import numpy as np\n", + "\n", + "import nada_algebra as na\n", + "import nada_algebra.client as na_client\n", + "import py_nillion_client as nillion\n", + "from nillion_python_helpers import (\n", + " create_nillion_client,\n", + " getUserKeyFromFile,\n", + " getNodeKeyFromFile,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Authenticate with Nillion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To connect to the Nillion network, we need to have a user key and a node key. These serve different purposes:\n", + "\n", + "The `user_key` is the user's private key. The user key should never be shared publicly, as it unlocks access and permissions to secrets stored on the network.\n", + "\n", + "The `node_key` is the node's private key which is run locally to connect to the network." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load all Nillion network environment variables\n", + "assert os.getcwd().endswith(\n", + " \"examples/multi_layer_perceptron\"\n", + "), \"Please run this script from the examples/multi_layer_perceptron directory otherwise, the rest of the tutorial may not work\"\n", + "load_dotenv()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "cluster_id = os.getenv(\"NILLION_CLUSTER_ID\")\n", + "model_user_userkey = getUserKeyFromFile(os.getenv(\"NILLION_USERKEY_PATH_PARTY_2\"))\n", + "model_user_nodekey = getNodeKeyFromFile(os.getenv(\"NILLION_NODEKEY_PATH_PARTY_2\"))\n", + "model_user_client = create_nillion_client(model_user_userkey, model_user_nodekey)\n", + "model_user_party_id = model_user_client.party_id\n", + "model_user_user_id = model_user_client.user_id" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Program ID: NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n", + "Model Store ID: a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n", + "Model Provider Party ID: 12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n" + ] + } + ], + "source": [ + "# This information was provided by the model provider\n", + "with open(\"tmp.json\", \"r\") as provider_variables_file:\n", + " provider_variables = json.load(provider_variables_file)\n", + " \n", + "program_id = provider_variables[\"program_id\"]\n", + "model_store_id = provider_variables[\"model_store_id\"]\n", + "model_provider_party_id = provider_variables[\"model_provider_party_id\"]\n", + "\n", + "print(\"Program ID: \", program_id)\n", + "print(\"Model Store ID: \", model_store_id)\n", + "print(\"Model Provider Party ID: \", model_provider_party_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model user flow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Read image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "test_image = transforms.Compose(\n", + " [\n", + " transforms.Grayscale(),\n", + " transforms.Resize((16,16)),\n", + " transforms.ToTensor(),\n", + " ]\n", + ")(Image.open(\"data/COVID-19_Lung_CT_Scans/COVID-19/COVID-19_0001.png\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 1, 16, 16)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_image_batch = np.array(test_image.unsqueeze(0))\n", + "test_image_batch.shape # (B, channels, H, W)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Send features to Nillion" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "async def store_images(\n", + " *,\n", + " client: nillion.NillionClient,\n", + " cluster_id: str,\n", + " program_id: str,\n", + " party_id: str,\n", + " user_id: str,\n", + " images: torch.Tensor,\n", + ") -> Dict[str, str]:\n", + " \"\"\"Stores text features in Nillion network.\n", + "\n", + " Args:\n", + " client (nillion.NillionClient): Nillion client that stores features.\n", + " cluster_id (str): Nillion cluster ID.\n", + " program_id (str): Program ID of Nada program.\n", + " party_id (str): Party ID of party that will store text features.\n", + " user_id (str): User ID of user that will get compute permissions.\n", + " images (torch.Tensor): Image batch.\n", + " precision (int): Scaling factor to convert float to ints.\n", + "\n", + " Returns:\n", + " Dict[str, str]: Resulting `model_user_party_id` and `images_store_id`.\n", + " \"\"\"\n", + " secrets = nillion.Secrets(na_client.array(images, \"my_input\", nada_type=na.SecretRational))\n", + "\n", + " secret_bindings = nillion.ProgramBindings(program_id)\n", + " secret_bindings.add_input_party(\"Party1\", party_id)\n", + "\n", + " images_store_id = await client.store_secrets(\n", + " cluster_id, secret_bindings, secrets, None\n", + " )\n", + "\n", + " return {\n", + " \"model_user_user_id\": user_id,\n", + " \"images_store_id\": images_store_id,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Images uploaded successfully!\n", + "model_user_user_id: 37Qew8NyqKYEjVCeDNMohPKKj4VSMxZMxRCYV6Snm8wvs1nJxRkynyUKMrXVk8Vkz2eoKpz8BaA58nGdA1SLyJAq\n", + "images_store_id: 00ecd070-3878-4bfa-a4b8-92b11975221a\n" + ] + } + ], + "source": [ + "result_store_features = await store_images(\n", + " client=model_user_client,\n", + " cluster_id=cluster_id,\n", + " program_id=program_id,\n", + " party_id=model_user_party_id,\n", + " user_id=model_user_user_id,\n", + " images=test_image_batch,\n", + ")\n", + "\n", + "model_user_user_id = result_store_features[\"model_user_user_id\"]\n", + "images_store_id = result_store_features[\"images_store_id\"]\n", + "\n", + "print(\"✅ Images uploaded successfully!\")\n", + "print(\"model_user_user_id:\", model_user_user_id)\n", + "print(\"images_store_id:\", images_store_id)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run inference & check result" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "async def run_inference(\n", + " *,\n", + " client: nillion.NillionClient,\n", + " cluster_id: str,\n", + " program_id: str,\n", + " model_user_party_id: str,\n", + " model_provider_party_id: str,\n", + " model_store_id: str,\n", + " images_store_id: str,\n", + ") -> Dict[str, str | float]:\n", + " \"\"\"Runs blind inference on the Nillion network by executing the Nada program on the uploaded data.\n", + "\n", + " Args:\n", + " client (nillion.NillionClient): Nillion client that runs inference.\n", + " cluster_id (str): Nillion cluster ID.\n", + " program_id (str): Program ID of Nada program.\n", + " model_user_party_id (str): Party ID of party that will run inference.\n", + " model_user_party_id (str): Party ID of party that will provide model params.\n", + " model_store_id (str): Store ID that points to the model params in the Nillion network.\n", + " images_store_id (str): Store ID that points to the images in the Nillion network.\n", + " precision (int): Scaling factor to convert float to ints.s\n", + "\n", + " Returns:\n", + " Dict[str, str | float]: Resulting `compute_id`, `output_0` and `output_1`.\n", + " \"\"\"\n", + " compute_bindings = nillion.ProgramBindings(program_id)\n", + " compute_bindings.add_input_party(\"Party0\", model_user_party_id)\n", + " compute_bindings.add_input_party(\"Party1\", model_provider_party_id)\n", + " compute_bindings.add_output_party(\"Party1\", model_user_party_id)\n", + "\n", + " _ = await client.compute(\n", + " cluster_id,\n", + " compute_bindings,\n", + " [images_store_id, model_store_id],\n", + " nillion.Secrets({}),\n", + " nillion.PublicVariables({}),\n", + " )\n", + "\n", + " while True:\n", + " compute_event = await client.next_compute_event()\n", + " if isinstance(compute_event, nillion.ComputeFinishedEvent):\n", + " inference_result = compute_event.result.value\n", + " break\n", + "\n", + " return {\n", + " \"compute_id\": compute_event.uuid,\n", + " \"output_0\": inference_result[\"my_output_0_0\"] / (2 ** na.get_log_scale()),\n", + " \"output_1\": inference_result[\"my_output_0_1\"] / (2 ** na.get_log_scale()),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'compute_id': 'e814f72b-55e8-49dd-b68c-4060516357f3',\n", + " 'output_0': -1.10308837890625,\n", + " 'output_1': 0.5345001220703125}" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_inference = await run_inference(\n", + " client=model_user_client,\n", + " cluster_id=cluster_id,\n", + " program_id=program_id,\n", + " model_user_party_id=model_user_party_id,\n", + " model_provider_party_id=model_provider_party_id,\n", + " model_store_id=model_store_id,\n", + " images_store_id=images_store_id,\n", + ")\n", + "result_inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare result to what we would have gotten in plain-text inference" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Create custom torch Module\n", + "class MyNN(torch.nn.Module):\n", + " \"\"\"My simple neural net\"\"\"\n", + "\n", + " def __init__(self) -> None:\n", + " \"\"\"Model is a two layers and an activations\"\"\"\n", + " super(MyNN, self).__init__()\n", + " self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n", + " self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", + "\n", + " self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n", + " \n", + " self.relu = torch.nn.ReLU()\n", + " self.flatten = torch.nn.Flatten()\n", + "\n", + " def forward(self, x: np.ndarray) -> np.ndarray:\n", + " \"\"\"My forward pass logic\"\"\"\n", + " x = self.relu(self.conv1(x))\n", + " x = self.pool(x)\n", + " x = self.flatten(x)\n", + " x = self.fc1(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_model = MyNN()\n", + "my_model.load_state_dict(torch.load(\"./data/my_model.pt\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.1628, 0.8372], grad_fn=)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.softmax(my_model(test_image.unsqueeze(0))[0], dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.1628, 0.8372])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.softmax(torch.Tensor([result_inference[\"output_0\"], result_inference[\"output_1\"]]), dim=0)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/multi_layer_perceptron/README.md b/examples/multi_layer_perceptron/README.md new file mode 100644 index 0000000..13f8b36 --- /dev/null +++ b/examples/multi_layer_perceptron/README.md @@ -0,0 +1,3 @@ +# Text classification +**This folder was generated using `nada init`** + diff --git a/examples/multi_layer_perceptron/helpers.py b/examples/multi_layer_perceptron/helpers.py new file mode 100644 index 0000000..b7f714a --- /dev/null +++ b/examples/multi_layer_perceptron/helpers.py @@ -0,0 +1,74 @@ +"""Helper functions and classes""" + +from typing import Dict +import torch +import py_nillion_client as nillion + +from torch import nn + + +class MyModel(nn.Module): + """Fully customizable model""" + + def __init__(self, model_name: str) -> None: + """Initialization + + Args: + model_name (str): Model name to be used as prefix for secret names. + """ + super().__init__() + self.model_name = model_name + self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4) + self.pool = nn.AvgPool2d(kernel_size=2, stride=2) + self.fc1 = nn.Linear(8, 2) + self.relu = nn.ReLU() + self.flatten = nn.Flatten() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Forward pass. + + Args: + x (torch.Tensor): Input array. + + Returns: + torch.Tensor: Output array. + """ + x = self.relu(self.conv1(x)) + x = self.pool(x) + x = self.flatten(x) + x = self.fc1(x) + return x + + def export_weights_as_secrets(self, precision: int) -> Dict: + """Exports all current model weights as quantized Nillion secrets. + + Args: + precision (int): Desired precision for quantization. + + Raises: + ValueError: Raised when unexpected layer is encountered + + Returns: + Dict: Model weight secrets. + """ + weight_secrets = {} + def return_data(result: dict, name: str, array: torch.Tensor): + if len(array.shape) == 1: + result.update( + { + f"{name}_{i}": nillion.SecretInteger(round(value.item() * precision)) + if round(value.item() * precision) != 0 + else nillion.SecretInteger(round(value.item() * precision)+1) + for i, value in enumerate(array) + } + ) + return + [return_data(result, f"{name}_{i}", array[i]) for i in range(array.shape[0])] + return result + + for weight_name, weight_tensor in self.state_dict().items(): + result = {} + return_data(result, f"{self.model_name}_{weight_name}", weight_tensor) + weight_secrets.update(result) + + return weight_secrets diff --git a/examples/multi_layer_perceptron/nada-project.toml b/examples/multi_layer_perceptron/nada-project.toml new file mode 100644 index 0000000..e13df53 --- /dev/null +++ b/examples/multi_layer_perceptron/nada-project.toml @@ -0,0 +1,7 @@ +name = "text_classification" +version = "0.1.0" +authors = [""] + +[[programs]] +path = "src/main.py" +prime_size = 128 diff --git a/examples/multi_layer_perceptron/requirements.txt b/examples/multi_layer_perceptron/requirements.txt new file mode 100644 index 0000000..1c717c5 --- /dev/null +++ b/examples/multi_layer_perceptron/requirements.txt @@ -0,0 +1,6 @@ +nada-dsl==0.1.1 +py-nillion-client==0.1.1 +scikit-learn~=1.4.2 +pandas~=2.2.2 +python-dotenv~=1.0.0 +requests~=2.31.0 \ No newline at end of file diff --git a/examples/multi_layer_perceptron/src/main.py b/examples/multi_layer_perceptron/src/main.py new file mode 100644 index 0000000..fd6f6d7 --- /dev/null +++ b/examples/multi_layer_perceptron/src/main.py @@ -0,0 +1,26 @@ +"""MLP Nada program""" + +import nada_algebra as na +from my_nn import MyNN + + +def nada_main(): + # Step 1: We use Nada Algebra wrapper to create "Party0" and "Party1" + parties = na.parties(2) + + # Step 2: Instantiate model object + my_model = MyNN() + + # Step 3: Load model weights from Nillion network by passing model name (acts as ID) + # In this examples Party0 provides the model and Party1 runs inference + my_model.load_state_from_network("my_nn", parties[0], na.SecretRational) + + # Step 4: Load input data to be used for inference (provided by Party1) + my_input = na.array((1, 1, 16, 16), parties[1], "my_input", na.SecretRational) + + # Step 5: Compute inference + # Note: completely equivalent to `my_model.forward(...)` + result = my_model(my_input) + + # Step 6: We can use result.output() to produce the output for Party1 and variable name "my_output" + return result.output(parties[1], "my_output") diff --git a/examples/multi_layer_perceptron/src/my_nn.py b/examples/multi_layer_perceptron/src/my_nn.py new file mode 100644 index 0000000..be277f6 --- /dev/null +++ b/examples/multi_layer_perceptron/src/my_nn.py @@ -0,0 +1,26 @@ +import nada_algebra as na +from nada_ai import nn + + +class MyNN(nn.Module): + """My brand new model""" + + def __init__(self) -> None: + """Model is a two layers and an activations""" + # Input size (1, 1, 16, 16) --> Output size (1, 2) + self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4) + # Input size (1, 2) --> Output size (1, 2) + self.pool = nn.AvgPool2d(kernel_size=2, stride=2) + self.fc1 = nn.Linear(in_features=8, out_features=2) + + self.relu = nn.ReLU() + self.flatten = nn.Flatten() + + + def forward(self, x: na.NadaArray) -> na.NadaArray: + """My forward pass logic""" + x = self.relu(self.conv1(x)) + x = self.pool(x) + x = self.flatten(x) + x = self.fc1(x) + return x diff --git a/examples/multi_layer_perceptron/tests/test.yaml b/examples/multi_layer_perceptron/tests/test.yaml new file mode 100644 index 0000000..20c697a --- /dev/null +++ b/examples/multi_layer_perceptron/tests/test.yaml @@ -0,0 +1,1210 @@ +--- +program: main +inputs: + secrets: + input_1_0_13_15: + SecretInteger: "3" + input_1_0_6_8: + SecretInteger: "3" + input_1_0_0_9: + SecretInteger: "3" + input_0_0_7_13: + SecretInteger: "3" + input_0_0_14_11: + SecretInteger: "3" + input_0_0_3_13: + SecretInteger: "3" + input_0_0_8_6: + SecretInteger: "3" + input_0_0_13_12: + SecretInteger: "3" + input_1_0_14_0: + SecretInteger: "3" + fc1.weight_19_1: + SecretInteger: "3" + input_0_0_9_7: + SecretInteger: "3" + input_0_0_11_12: + SecretInteger: "3" + input_0_0_12_7: + SecretInteger: "3" + input_1_0_1_14: + SecretInteger: "3" + input_0_0_13_11: + SecretInteger: "3" + input_1_0_1_1: + SecretInteger: "3" + input_0_0_7_12: + SecretInteger: "3" + fc1.weight_15_0: + SecretInteger: "3" + input_1_0_11_6: + SecretInteger: "3" + input_1_0_8_10: + SecretInteger: "3" + input_1_0_3_6: + SecretInteger: "3" + input_0_0_3_3: + SecretInteger: "3" + input_1_0_14_9: + SecretInteger: "3" + conv1.weight_1_0_0_1: + SecretInteger: "3" + input_1_0_11_11: + SecretInteger: "3" + input_1_0_10_2: + SecretInteger: "3" + input_1_0_8_13: + SecretInteger: "3" + input_0_0_7_2: + SecretInteger: "3" + input_1_0_1_10: + SecretInteger: "3" + fc1.weight_30_1: + SecretInteger: "3" + input_1_0_14_13: + SecretInteger: "3" + input_1_0_7_8: + SecretInteger: "3" + input_1_0_15_2: + SecretInteger: "3" + input_0_0_13_14: + SecretInteger: "3" + input_1_0_11_0: + SecretInteger: "3" + input_0_0_13_1: + SecretInteger: "3" + input_0_0_2_12: + SecretInteger: "3" + input_0_0_2_9: + SecretInteger: "3" + input_0_0_7_8: + SecretInteger: "3" + input_1_0_8_6: + SecretInteger: "3" + fc1.weight_25_1: + SecretInteger: "3" + input_1_0_11_1: + SecretInteger: "3" + input_1_0_0_11: + SecretInteger: "3" + input_1_0_0_12: + SecretInteger: "3" + input_1_0_2_2: + SecretInteger: "3" + input_0_0_5_5: + SecretInteger: "3" + fc1.weight_12_1: + SecretInteger: "3" + input_0_0_4_13: + SecretInteger: "3" + fc1.weight_5_0: + SecretInteger: "3" + input_1_0_9_4: + SecretInteger: "3" + input_1_0_10_8: + SecretInteger: "3" + input_0_0_11_2: + SecretInteger: "3" + input_1_0_14_5: + SecretInteger: "3" + input_1_0_7_6: + SecretInteger: "3" + conv1.weight_0_0_2_1: + SecretInteger: "3" + conv1.weight_1_0_1_1: + SecretInteger: "3" + fc1.weight_2_1: + SecretInteger: "3" + input_0_0_7_7: + SecretInteger: "3" + conv1.weight_0_0_1_1: + SecretInteger: "3" + conv1.weight_1_0_1_0: + SecretInteger: "3" + input_0_0_9_1: + SecretInteger: "3" + input_1_0_2_5: + SecretInteger: "3" + input_1_0_15_4: + SecretInteger: "3" + conv1.weight_0_0_1_2: + SecretInteger: "3" + fc1.weight_29_0: + SecretInteger: "3" + input_1_0_15_10: + SecretInteger: "3" + conv1.weight_0_0_2_0: + SecretInteger: "3" + input_1_0_10_12: + SecretInteger: "3" + input_0_0_9_0: + SecretInteger: "3" + input_1_0_9_13: + SecretInteger: "3" + input_1_0_2_11: + SecretInteger: "3" + input_1_0_0_6: + SecretInteger: "3" + input_1_0_14_4: + SecretInteger: "3" + fc1.weight_0_1: + SecretInteger: "3" + input_1_0_7_1: + SecretInteger: "3" + fc1.weight_30_0: + SecretInteger: "3" + fc1.weight_16_1: + SecretInteger: "3" + input_0_0_1_8: + SecretInteger: "3" + input_0_0_10_1: + SecretInteger: "3" + input_1_0_1_6: + SecretInteger: "3" + input_1_0_4_10: + SecretInteger: "3" + input_1_0_15_12: + SecretInteger: "3" + fc1.weight_31_1: + SecretInteger: "3" + input_0_0_15_14: + SecretInteger: "3" + input_1_0_6_3: + SecretInteger: "3" + fc1.weight_13_0: + SecretInteger: "3" + input_0_0_9_4: + SecretInteger: "3" + input_0_0_12_13: + SecretInteger: "3" + input_0_0_6_1: + SecretInteger: "3" + input_0_0_4_2: + SecretInteger: "3" + input_0_0_0_7: + SecretInteger: "3" + fc1.weight_20_1: + SecretInteger: "3" + input_0_0_10_8: + SecretInteger: "3" + input_0_0_10_11: + SecretInteger: "3" + input_0_0_15_3: + SecretInteger: "3" + input_0_0_12_0: + SecretInteger: "3" + input_0_0_11_0: + SecretInteger: "3" + input_1_0_9_5: + SecretInteger: "3" + input_0_0_9_11: + SecretInteger: "3" + input_1_0_6_11: + SecretInteger: "3" + input_0_0_12_4: + SecretInteger: "3" + input_0_0_11_4: + SecretInteger: "3" + fc1.weight_1_0: + SecretInteger: "3" + input_1_0_9_14: + SecretInteger: "3" + input_0_0_13_7: + SecretInteger: "3" + input_1_0_8_2: + SecretInteger: "3" + input_0_0_13_0: + SecretInteger: "3" + input_0_0_9_8: + SecretInteger: "3" + input_1_0_0_3: + SecretInteger: "3" + input_1_0_0_4: + SecretInteger: "3" + input_1_0_0_8: + SecretInteger: "3" + input_0_0_2_2: + SecretInteger: "3" + input_0_0_8_13: + SecretInteger: "3" + input_0_0_1_2: + SecretInteger: "3" + input_0_0_11_10: + SecretInteger: "3" + input_0_0_3_15: + SecretInteger: "3" + input_1_0_5_15: + SecretInteger: "3" + input_0_0_8_4: + SecretInteger: "3" + input_0_0_2_10: + SecretInteger: "3" + input_0_0_8_5: + SecretInteger: "3" + conv1.weight_1_0_2_0: + SecretInteger: "3" + input_0_0_8_15: + SecretInteger: "3" + input_1_0_0_10: + SecretInteger: "3" + input_1_0_3_2: + SecretInteger: "3" + input_1_0_5_8: + SecretInteger: "3" + fc1.weight_24_0: + SecretInteger: "3" + fc1.weight_12_0: + SecretInteger: "3" + input_0_0_0_1: + SecretInteger: "3" + input_0_0_11_7: + SecretInteger: "3" + fc1.weight_26_1: + SecretInteger: "3" + input_1_0_1_2: + SecretInteger: "3" + input_0_0_3_9: + SecretInteger: "3" + input_0_0_14_4: + SecretInteger: "3" + input_0_0_15_4: + SecretInteger: "3" + input_1_0_3_15: + SecretInteger: "3" + input_0_0_1_3: + SecretInteger: "3" + input_1_0_9_2: + SecretInteger: "3" + input_1_0_11_12: + SecretInteger: "3" + input_1_0_14_2: + SecretInteger: "3" + input_0_0_9_9: + SecretInteger: "3" + fc1.weight_3_0: + SecretInteger: "3" + fc1.weight_11_1: + SecretInteger: "3" + input_1_0_2_1: + SecretInteger: "3" + input_1_0_6_10: + SecretInteger: "3" + input_1_0_11_10: + SecretInteger: "3" + input_1_0_14_14: + SecretInteger: "3" + input_0_0_1_9: + SecretInteger: "3" + input_1_0_11_5: + SecretInteger: "3" + input_1_0_13_13: + SecretInteger: "3" + input_1_0_2_0: + SecretInteger: "3" + input_1_0_12_0: + SecretInteger: "3" + input_1_0_14_1: + SecretInteger: "3" + input_0_0_2_15: + SecretInteger: "3" + input_1_0_5_11: + SecretInteger: "3" + input_1_0_12_7: + SecretInteger: "3" + input_1_0_1_0: + SecretInteger: "3" + input_1_0_2_15: + SecretInteger: "3" + input_1_0_9_0: + SecretInteger: "3" + fc1.bias_1: + SecretInteger: "3" + input_1_0_3_7: + SecretInteger: "3" + input_0_0_11_5: + SecretInteger: "3" + fc1.weight_8_0: + SecretInteger: "3" + input_1_0_6_2: + SecretInteger: "3" + input_1_0_4_2: + SecretInteger: "3" + input_1_0_8_0: + SecretInteger: "3" + input_0_0_4_11: + SecretInteger: "3" + input_1_0_11_14: + SecretInteger: "3" + input_1_0_7_15: + SecretInteger: "3" + input_1_0_5_9: + SecretInteger: "3" + input_1_0_15_0: + SecretInteger: "3" + input_1_0_7_4: + SecretInteger: "3" + input_1_0_9_11: + SecretInteger: "3" + input_0_0_6_7: + SecretInteger: "3" + input_0_0_7_0: + SecretInteger: "3" + input_1_0_11_15: + SecretInteger: "3" + input_1_0_13_1: + SecretInteger: "3" + input_0_0_4_9: + SecretInteger: "3" + input_1_0_7_13: + SecretInteger: "3" + fc1.weight_18_1: + SecretInteger: "3" + input_0_0_11_6: + SecretInteger: "3" + input_0_0_8_9: + SecretInteger: "3" + input_0_0_2_6: + SecretInteger: "3" + input_0_0_15_5: + SecretInteger: "3" + input_1_0_15_7: + SecretInteger: "3" + input_1_0_0_2: + SecretInteger: "3" + input_1_0_12_12: + SecretInteger: "3" + input_0_0_7_9: + SecretInteger: "3" + input_0_0_14_14: + SecretInteger: "3" + input_1_0_3_13: + SecretInteger: "3" + input_0_0_9_12: + SecretInteger: "3" + input_1_0_2_9: + SecretInteger: "3" + conv1.weight_0_0_0_0: + SecretInteger: "3" + input_0_0_0_10: + SecretInteger: "3" + input_0_0_4_14: + SecretInteger: "3" + input_0_0_4_15: + SecretInteger: "3" + input_0_0_13_2: + SecretInteger: "3" + input_0_0_14_12: + SecretInteger: "3" + input_1_0_7_11: + SecretInteger: "3" + input_0_0_6_6: + SecretInteger: "3" + input_0_0_14_9: + SecretInteger: "3" + input_1_0_7_2: + SecretInteger: "3" + input_0_0_5_6: + SecretInteger: "3" + input_0_0_1_4: + SecretInteger: "3" + input_0_0_1_10: + SecretInteger: "3" + fc1.weight_16_0: + SecretInteger: "3" + input_0_0_1_12: + SecretInteger: "3" + input_0_0_14_8: + SecretInteger: "3" + input_1_0_5_13: + SecretInteger: "3" + fc1.weight_10_1: + SecretInteger: "3" + input_1_0_0_0: + SecretInteger: "3" + input_1_0_15_1: + SecretInteger: "3" + input_0_0_14_7: + SecretInteger: "3" + input_0_0_13_15: + SecretInteger: "3" + input_1_0_4_15: + SecretInteger: "3" + input_0_0_6_9: + SecretInteger: "3" + input_1_0_11_8: + SecretInteger: "3" + fc1.weight_27_1: + SecretInteger: "3" + input_0_0_10_13: + SecretInteger: "3" + input_1_0_4_4: + SecretInteger: "3" + conv1.weight_1_0_1_2: + SecretInteger: "3" + input_0_0_4_12: + SecretInteger: "3" + input_1_0_2_8: + SecretInteger: "3" + input_1_0_7_3: + SecretInteger: "3" + input_1_0_4_12: + SecretInteger: "3" + input_1_0_4_1: + SecretInteger: "3" + input_0_0_7_15: + SecretInteger: "3" + input_1_0_3_12: + SecretInteger: "3" + input_1_0_13_8: + SecretInteger: "3" + input_1_0_13_14: + SecretInteger: "3" + fc1.weight_0_0: + SecretInteger: "3" + input_0_0_5_8: + SecretInteger: "3" + input_0_0_7_11: + SecretInteger: "3" + input_0_0_14_0: + SecretInteger: "3" + input_0_0_13_9: + SecretInteger: "3" + input_0_0_13_6: + SecretInteger: "3" + input_1_0_3_3: + SecretInteger: "3" + input_1_0_8_8: + SecretInteger: "3" + input_0_0_2_8: + SecretInteger: "3" + fc1.weight_15_1: + SecretInteger: "3" + input_1_0_1_13: + SecretInteger: "3" + input_0_0_13_13: + SecretInteger: "3" + input_0_0_1_13: + SecretInteger: "3" + input_1_0_2_6: + SecretInteger: "3" + input_1_0_12_14: + SecretInteger: "3" + input_0_0_1_0: + SecretInteger: "3" + input_1_0_8_1: + SecretInteger: "3" + input_0_0_7_5: + SecretInteger: "3" + input_1_0_1_5: + SecretInteger: "3" + fc1.weight_22_0: + SecretInteger: "3" + conv1.bias_1: + SecretInteger: "3" + input_0_0_12_9: + SecretInteger: "3" + input_1_0_3_9: + SecretInteger: "3" + input_0_0_5_12: + SecretInteger: "3" + input_1_0_11_2: + SecretInteger: "3" + fc1.weight_28_1: + SecretInteger: "3" + fc1.weight_10_0: + SecretInteger: "3" + input_0_0_1_11: + SecretInteger: "3" + input_0_0_9_2: + SecretInteger: "3" + input_1_0_8_4: + SecretInteger: "3" + input_0_0_12_2: + SecretInteger: "3" + input_1_0_3_14: + SecretInteger: "3" + input_0_0_9_3: + SecretInteger: "3" + input_0_0_3_11: + SecretInteger: "3" + input_1_0_4_8: + SecretInteger: "3" + input_1_0_12_9: + SecretInteger: "3" + input_0_0_0_6: + SecretInteger: "3" + fc1.weight_4_1: + SecretInteger: "3" + input_0_0_6_14: + SecretInteger: "3" + input_0_0_8_11: + SecretInteger: "3" + input_1_0_15_15: + SecretInteger: "3" + input_0_0_5_4: + SecretInteger: "3" + input_1_0_5_14: + SecretInteger: "3" + input_0_0_0_0: + SecretInteger: "3" + input_0_0_12_1: + SecretInteger: "3" + fc1.weight_27_0: + SecretInteger: "3" + input_0_0_15_7: + SecretInteger: "3" + input_0_0_4_10: + SecretInteger: "3" + input_1_0_3_5: + SecretInteger: "3" + input_1_0_0_14: + SecretInteger: "3" + input_1_0_12_6: + SecretInteger: "3" + input_0_0_9_14: + SecretInteger: "3" + input_1_0_2_7: + SecretInteger: "3" + input_1_0_10_6: + SecretInteger: "3" + input_1_0_15_6: + SecretInteger: "3" + input_1_0_6_9: + SecretInteger: "3" + input_1_0_5_0: + SecretInteger: "3" + input_0_0_8_8: + SecretInteger: "3" + input_0_0_10_12: + SecretInteger: "3" + input_0_0_7_3: + SecretInteger: "3" + input_1_0_14_8: + SecretInteger: "3" + input_0_0_8_2: + SecretInteger: "3" + input_1_0_8_11: + SecretInteger: "3" + input_1_0_12_3: + SecretInteger: "3" + input_1_0_12_8: + SecretInteger: "3" + input_0_0_9_5: + SecretInteger: "3" + input_1_0_5_7: + SecretInteger: "3" + input_0_0_1_14: + SecretInteger: "3" + input_0_0_6_13: + SecretInteger: "3" + fc1.weight_18_0: + SecretInteger: "3" + input_0_0_7_14: + SecretInteger: "3" + input_0_0_8_10: + SecretInteger: "3" + input_0_0_6_8: + SecretInteger: "3" + input_0_0_10_6: + SecretInteger: "3" + input_0_0_2_5: + SecretInteger: "3" + fc1.weight_23_1: + SecretInteger: "3" + input_0_0_8_1: + SecretInteger: "3" + fc1.weight_14_0: + SecretInteger: "3" + input_0_0_15_2: + SecretInteger: "3" + input_1_0_13_10: + SecretInteger: "3" + input_0_0_1_15: + SecretInteger: "3" + input_0_0_6_0: + SecretInteger: "3" + input_0_0_6_12: + SecretInteger: "3" + input_1_0_12_13: + SecretInteger: "3" + fc1.weight_19_0: + SecretInteger: "3" + input_1_0_5_3: + SecretInteger: "3" + input_0_0_5_3: + SecretInteger: "3" + input_0_0_15_11: + SecretInteger: "3" + input_0_0_15_1: + SecretInteger: "3" + input_0_0_2_0: + SecretInteger: "3" + input_0_0_12_15: + SecretInteger: "3" + input_1_0_10_0: + SecretInteger: "3" + input_0_0_9_13: + SecretInteger: "3" + input_0_0_2_4: + SecretInteger: "3" + input_0_0_15_12: + SecretInteger: "3" + input_0_0_11_1: + SecretInteger: "3" + input_0_0_12_12: + SecretInteger: "3" + input_0_0_14_1: + SecretInteger: "3" + input_1_0_4_7: + SecretInteger: "3" + input_1_0_10_4: + SecretInteger: "3" + input_0_0_4_1: + SecretInteger: "3" + input_0_0_8_3: + SecretInteger: "3" + fc1.weight_4_0: + SecretInteger: "3" + input_0_0_12_6: + SecretInteger: "3" + input_0_0_10_5: + SecretInteger: "3" + input_0_0_15_10: + SecretInteger: "3" + input_0_0_12_10: + SecretInteger: "3" + input_1_0_1_3: + SecretInteger: "3" + input_1_0_5_5: + SecretInteger: "3" + input_1_0_2_4: + SecretInteger: "3" + fc1.bias_0: + SecretInteger: "3" + input_1_0_7_5: + SecretInteger: "3" + input_0_0_3_4: + SecretInteger: "3" + input_0_0_0_8: + SecretInteger: "3" + input_1_0_7_0: + SecretInteger: "3" + input_1_0_6_6: + SecretInteger: "3" + input_1_0_13_12: + SecretInteger: "3" + input_0_0_4_5: + SecretInteger: "3" + input_0_0_11_3: + SecretInteger: "3" + input_1_0_10_10: + SecretInteger: "3" + input_1_0_11_13: + SecretInteger: "3" + conv1.weight_0_0_1_0: + SecretInteger: "3" + input_1_0_5_4: + SecretInteger: "3" + input_1_0_7_10: + SecretInteger: "3" + input_1_0_8_9: + SecretInteger: "3" + input_1_0_7_14: + SecretInteger: "3" + fc1.weight_11_0: + SecretInteger: "3" + input_1_0_0_13: + SecretInteger: "3" + input_1_0_3_10: + SecretInteger: "3" + input_0_0_8_12: + SecretInteger: "3" + input_0_0_14_6: + SecretInteger: "3" + input_1_0_1_11: + SecretInteger: "3" + input_1_0_11_9: + SecretInteger: "3" + input_1_0_4_0: + SecretInteger: "3" + input_0_0_10_7: + SecretInteger: "3" + input_0_0_3_2: + SecretInteger: "3" + input_0_0_5_14: + SecretInteger: "3" + input_1_0_13_11: + SecretInteger: "3" + input_1_0_4_13: + SecretInteger: "3" + input_0_0_10_3: + SecretInteger: "3" + input_0_0_15_13: + SecretInteger: "3" + input_0_0_0_4: + SecretInteger: "3" + input_1_0_15_14: + SecretInteger: "3" + input_0_0_2_13: + SecretInteger: "3" + input_0_0_11_11: + SecretInteger: "3" + input_0_0_10_14: + SecretInteger: "3" + input_0_0_14_13: + SecretInteger: "3" + input_1_0_5_2: + SecretInteger: "3" + input_1_0_1_8: + SecretInteger: "3" + input_0_0_3_0: + SecretInteger: "3" + fc1.weight_17_0: + SecretInteger: "3" + input_0_0_10_15: + SecretInteger: "3" + input_1_0_5_10: + SecretInteger: "3" + input_1_0_7_12: + SecretInteger: "3" + input_1_0_9_8: + SecretInteger: "3" + input_1_0_6_7: + SecretInteger: "3" + input_0_0_2_7: + SecretInteger: "3" + input_0_0_6_11: + SecretInteger: "3" + input_0_0_3_14: + SecretInteger: "3" + input_0_0_10_4: + SecretInteger: "3" + input_1_0_4_3: + SecretInteger: "3" + input_1_0_4_9: + SecretInteger: "3" + input_1_0_10_3: + SecretInteger: "3" + input_1_0_12_11: + SecretInteger: "3" + input_0_0_4_0: + SecretInteger: "3" + input_0_0_4_7: + SecretInteger: "3" + input_0_0_13_3: + SecretInteger: "3" + fc1.weight_7_1: + SecretInteger: "3" + input_0_0_14_15: + SecretInteger: "3" + input_1_0_14_6: + SecretInteger: "3" + input_1_0_15_11: + SecretInteger: "3" + conv1.weight_0_0_0_2: + SecretInteger: "3" + fc1.weight_28_0: + SecretInteger: "3" + input_0_0_0_3: + SecretInteger: "3" + fc1.weight_21_1: + SecretInteger: "3" + input_0_0_3_8: + SecretInteger: "3" + input_1_0_14_3: + SecretInteger: "3" + input_0_0_13_5: + SecretInteger: "3" + input_1_0_10_15: + SecretInteger: "3" + input_0_0_0_14: + SecretInteger: "3" + input_0_0_8_7: + SecretInteger: "3" + input_0_0_5_15: + SecretInteger: "3" + input_1_0_13_0: + SecretInteger: "3" + fc1.weight_6_0: + SecretInteger: "3" + input_0_0_4_4: + SecretInteger: "3" + input_1_0_9_15: + SecretInteger: "3" + input_1_0_15_8: + SecretInteger: "3" + input_1_0_10_7: + SecretInteger: "3" + input_1_0_1_4: + SecretInteger: "3" + input_1_0_12_5: + SecretInteger: "3" + input_0_0_4_6: + SecretInteger: "3" + input_0_0_9_15: + SecretInteger: "3" + fc1.weight_26_0: + SecretInteger: "3" + input_0_0_6_10: + SecretInteger: "3" + input_1_0_1_15: + SecretInteger: "3" + input_1_0_15_5: + SecretInteger: "3" + fc1.weight_29_1: + SecretInteger: "3" + input_0_0_1_6: + SecretInteger: "3" + fc1.weight_22_1: + SecretInteger: "3" + input_1_0_11_4: + SecretInteger: "3" + input_0_0_0_11: + SecretInteger: "3" + input_0_0_2_3: + SecretInteger: "3" + input_0_0_10_10: + SecretInteger: "3" + input_1_0_11_7: + SecretInteger: "3" + fc1.weight_25_0: + SecretInteger: "3" + input_0_0_8_0: + SecretInteger: "3" + input_0_0_12_11: + SecretInteger: "3" + fc1.weight_31_0: + SecretInteger: "3" + fc1.weight_1_1: + SecretInteger: "3" + fc1.weight_5_1: + SecretInteger: "3" + conv1.weight_1_0_0_0: + SecretInteger: "3" + input_0_0_3_6: + SecretInteger: "3" + input_1_0_1_9: + SecretInteger: "3" + input_0_0_14_10: + SecretInteger: "3" + fc1.weight_21_0: + SecretInteger: "3" + input_0_0_5_0: + SecretInteger: "3" + fc1.weight_9_0: + SecretInteger: "3" + input_1_0_0_5: + SecretInteger: "3" + input_1_0_5_6: + SecretInteger: "3" + input_1_0_14_12: + SecretInteger: "3" + input_1_0_11_3: + SecretInteger: "3" + input_0_0_6_2: + SecretInteger: "3" + input_1_0_6_4: + SecretInteger: "3" + input_1_0_8_15: + SecretInteger: "3" + input_0_0_5_2: + SecretInteger: "3" + input_0_0_3_10: + SecretInteger: "3" + input_0_0_12_5: + SecretInteger: "3" + input_1_0_13_5: + SecretInteger: "3" + input_1_0_3_11: + SecretInteger: "3" + input_0_0_11_9: + SecretInteger: "3" + fc1.weight_8_1: + SecretInteger: "3" + input_0_0_7_10: + SecretInteger: "3" + input_0_0_9_10: + SecretInteger: "3" + fc1.weight_7_0: + SecretInteger: "3" + input_1_0_7_7: + SecretInteger: "3" + input_1_0_12_15: + SecretInteger: "3" + input_0_0_1_7: + SecretInteger: "3" + input_1_0_5_1: + SecretInteger: "3" + input_0_0_14_3: + SecretInteger: "3" + input_0_0_5_1: + SecretInteger: "3" + input_0_0_0_12: + SecretInteger: "3" + input_1_0_6_13: + SecretInteger: "3" + input_1_0_8_5: + SecretInteger: "3" + fc1.weight_23_0: + SecretInteger: "3" + input_0_0_7_4: + SecretInteger: "3" + input_1_0_0_1: + SecretInteger: "3" + fc1.weight_14_1: + SecretInteger: "3" + input_0_0_6_4: + SecretInteger: "3" + input_1_0_10_1: + SecretInteger: "3" + input_1_0_13_7: + SecretInteger: "3" + input_0_0_7_1: + SecretInteger: "3" + input_1_0_4_6: + SecretInteger: "3" + input_1_0_8_14: + SecretInteger: "3" + input_0_0_11_13: + SecretInteger: "3" + input_0_0_12_14: + SecretInteger: "3" + input_1_0_8_7: + SecretInteger: "3" + input_1_0_10_13: + SecretInteger: "3" + input_1_0_13_4: + SecretInteger: "3" + input_1_0_15_13: + SecretInteger: "3" + input_1_0_12_10: + SecretInteger: "3" + input_0_0_2_1: + SecretInteger: "3" + conv1.weight_0_0_2_2: + SecretInteger: "3" + input_0_0_14_2: + SecretInteger: "3" + input_1_0_3_8: + SecretInteger: "3" + input_0_0_12_8: + SecretInteger: "3" + input_0_0_6_15: + SecretInteger: "3" + input_1_0_9_10: + SecretInteger: "3" + input_1_0_12_4: + SecretInteger: "3" + input_1_0_14_10: + SecretInteger: "3" + conv1.weight_1_0_2_2: + SecretInteger: "3" + input_1_0_14_7: + SecretInteger: "3" + fc1.weight_2_0: + SecretInteger: "3" + input_0_0_2_14: + SecretInteger: "3" + input_0_0_4_3: + SecretInteger: "3" + input_0_0_12_3: + SecretInteger: "3" + input_1_0_9_12: + SecretInteger: "3" + conv1.weight_1_0_0_2: + SecretInteger: "3" + input_1_0_10_14: + SecretInteger: "3" + input_0_0_8_14: + SecretInteger: "3" + input_0_0_6_3: + SecretInteger: "3" + input_1_0_9_9: + SecretInteger: "3" + input_0_0_7_6: + SecretInteger: "3" + input_0_0_0_2: + SecretInteger: "3" + input_0_0_1_5: + SecretInteger: "3" + fc1.weight_6_1: + SecretInteger: "3" + input_0_0_10_2: + SecretInteger: "3" + input_1_0_2_13: + SecretInteger: "3" + input_1_0_12_1: + SecretInteger: "3" + input_0_0_5_13: + SecretInteger: "3" + input_1_0_14_11: + SecretInteger: "3" + input_0_0_14_5: + SecretInteger: "3" + input_0_0_10_0: + SecretInteger: "3" + input_0_0_15_9: + SecretInteger: "3" + input_0_0_0_13: + SecretInteger: "3" + input_1_0_6_15: + SecretInteger: "3" + input_1_0_9_3: + SecretInteger: "3" + input_1_0_4_11: + SecretInteger: "3" + fc1.weight_24_1: + SecretInteger: "3" + fc1.weight_9_1: + SecretInteger: "3" + input_0_0_15_0: + SecretInteger: "3" + input_1_0_6_14: + SecretInteger: "3" + input_1_0_13_6: + SecretInteger: "3" + input_0_0_2_11: + SecretInteger: "3" + input_1_0_2_3: + SecretInteger: "3" + input_1_0_6_0: + SecretInteger: "3" + input_1_0_4_14: + SecretInteger: "3" + input_1_0_13_2: + SecretInteger: "3" + input_0_0_3_7: + SecretInteger: "3" + input_1_0_3_1: + SecretInteger: "3" + input_1_0_7_9: + SecretInteger: "3" + input_0_0_1_1: + SecretInteger: "3" + input_0_0_0_15: + SecretInteger: "3" + input_1_0_10_11: + SecretInteger: "3" + input_0_0_15_15: + SecretInteger: "3" + input_1_0_9_7: + SecretInteger: "3" + input_1_0_13_3: + SecretInteger: "3" + input_1_0_2_10: + SecretInteger: "3" + input_1_0_0_15: + SecretInteger: "3" + conv1.weight_0_0_0_1: + SecretInteger: "3" + input_1_0_2_12: + SecretInteger: "3" + conv1.weight_1_0_2_1: + SecretInteger: "3" + input_0_0_6_5: + SecretInteger: "3" + input_1_0_5_12: + SecretInteger: "3" + input_1_0_12_2: + SecretInteger: "3" + input_1_0_1_7: + SecretInteger: "3" + input_1_0_4_5: + SecretInteger: "3" + input_1_0_8_3: + SecretInteger: "3" + input_1_0_6_12: + SecretInteger: "3" + input_0_0_4_8: + SecretInteger: "3" + input_0_0_5_11: + SecretInteger: "3" + input_1_0_0_7: + SecretInteger: "3" + input_1_0_8_12: + SecretInteger: "3" + fc1.weight_20_0: + SecretInteger: "3" + input_0_0_0_9: + SecretInteger: "3" + input_1_0_10_5: + SecretInteger: "3" + conv1.bias_0: + SecretInteger: "3" + input_0_0_11_14: + SecretInteger: "3" + input_1_0_10_9: + SecretInteger: "3" + input_1_0_1_12: + SecretInteger: "3" + input_1_0_3_0: + SecretInteger: "3" + input_0_0_5_10: + SecretInteger: "3" + input_1_0_15_3: + SecretInteger: "3" + input_0_0_15_8: + SecretInteger: "3" + input_0_0_3_12: + SecretInteger: "3" + input_1_0_13_9: + SecretInteger: "3" + input_0_0_5_9: + SecretInteger: "3" + input_0_0_11_15: + SecretInteger: "3" + input_0_0_0_5: + SecretInteger: "3" + input_1_0_2_14: + SecretInteger: "3" + fc1.weight_17_1: + SecretInteger: "3" + input_1_0_3_4: + SecretInteger: "3" + input_1_0_9_6: + SecretInteger: "3" + input_0_0_3_1: + SecretInteger: "3" + input_0_0_13_4: + SecretInteger: "3" + input_0_0_3_5: + SecretInteger: "3" + input_0_0_15_6: + SecretInteger: "3" + input_1_0_14_15: + SecretInteger: "3" + input_0_0_11_8: + SecretInteger: "3" + fc1.weight_13_1: + SecretInteger: "3" + input_0_0_13_10: + SecretInteger: "3" + input_1_0_6_5: + SecretInteger: "3" + input_0_0_10_9: + SecretInteger: "3" + input_0_0_13_8: + SecretInteger: "3" + fc1.weight_3_1: + SecretInteger: "3" + input_1_0_15_9: + SecretInteger: "3" + input_1_0_9_1: + SecretInteger: "3" + input_0_0_5_7: + SecretInteger: "3" + input_0_0_9_6: + SecretInteger: "3" + input_1_0_6_1: + SecretInteger: "3" + public_variables: {} +expected_outputs: + output_0_0: + SecretInteger: "3" + output_0_1: + SecretInteger: "3" + output_1_0: + SecretInteger: "3" + output_1_1: + SecretInteger: "3" diff --git a/examples/multi_layer_perceptron/tmp.json b/examples/multi_layer_perceptron/tmp.json new file mode 100644 index 0000000..fe56b96 --- /dev/null +++ b/examples/multi_layer_perceptron/tmp.json @@ -0,0 +1 @@ +{"program_id": "NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main", "model_store_id": "a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c", "model_provider_party_id": "12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ"} \ No newline at end of file diff --git a/examples/neural_net/network/compute.py b/examples/neural_net/network/compute.py index 39b2493..f4997d8 100644 --- a/examples/neural_net/network/compute.py +++ b/examples/neural_net/network/compute.py @@ -116,7 +116,7 @@ def __init__(self) -> None: self.linear_1 = torch.nn.Linear(4, 2) self.relu = torch.nn.ReLU() - def forward(self, x: na.NadaArray) -> na.NadaArray: + def forward(self, x: np.ndarray) -> np.ndarray: """My forward pass logic""" x = self.linear_0(x) x = self.relu(x) diff --git a/examples/spam_detection/01_model_provider.ipynb b/examples/spam_detection/01_model_provider.ipynb index ec0c1b6..14ffcbc 100644 --- a/examples/spam_detection/01_model_provider.ipynb +++ b/examples/spam_detection/01_model_provider.ipynb @@ -932,7 +932,6 @@ " Dict[str, str]: Resulting `provider_party_id` and `model_store_id`.\n", " \"\"\"\n", "\n", - " print(model.export_state_as_secrets(\"my_model\", na.SecretRational).keys())\n", " secrets = nillion.Secrets(\n", " model.export_state_as_secrets(\"my_model\", na.SecretRational)\n", " )\n", From bda7c500332687cc7e0d8743b78e2936c19c6fd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Cabrero-Holgueras?= Date: Fri, 14 Jun 2024 11:18:26 +0000 Subject: [PATCH 2/4] chore: linting and code ordering --- examples/complex_model/network/compute.py | 8 +- examples/linear_regression/network/compute.py | 8 +- .../01_model_provider.ipynb | 307 +++++++++--------- .../02_model_inference.ipynb | 86 ++--- examples/multi_layer_perceptron/helpers.py | 74 ----- examples/multi_layer_perceptron/src/my_nn.py | 6 +- examples/multi_layer_perceptron/tmp.json | 1 - examples/neural_net/network/compute.py | 8 +- examples/time_series/network/compute.py | 8 +- nada_ai/nada_typing.py | 17 +- nada_ai/nn/modules/relu.py | 10 +- tests/python-tests/test_model_client.py | 3 +- 12 files changed, 256 insertions(+), 280 deletions(-) delete mode 100644 examples/multi_layer_perceptron/helpers.py delete mode 100644 examples/multi_layer_perceptron/tmp.json diff --git a/examples/complex_model/network/compute.py b/examples/complex_model/network/compute.py index 0c4c07c..fd9a743 100644 --- a/examples/complex_model/network/compute.py +++ b/examples/complex_model/network/compute.py @@ -15,9 +15,13 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client + # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, - getUserKeyFromFile) +from nillion_python_helpers import ( + create_nillion_client, + getNodeKeyFromFile, + getUserKeyFromFile, +) # Load environment variables from a .env file load_dotenv() diff --git a/examples/linear_regression/network/compute.py b/examples/linear_regression/network/compute.py index be9eda8..cb50706 100644 --- a/examples/linear_regression/network/compute.py +++ b/examples/linear_regression/network/compute.py @@ -15,9 +15,13 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client + # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, - getUserKeyFromFile) +from nillion_python_helpers import ( + create_nillion_client, + getNodeKeyFromFile, + getUserKeyFromFile, +) # Load environment variables from a .env file load_dotenv() diff --git a/examples/multi_layer_perceptron/01_model_provider.ipynb b/examples/multi_layer_perceptron/01_model_provider.ipynb index 4b703b8..e5cd3ce 100644 --- a/examples/multi_layer_perceptron/01_model_provider.ipynb +++ b/examples/multi_layer_perceptron/01_model_provider.ipynb @@ -37,9 +37,19 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/vscode/.local/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Importing plotly failed. Interactive plots will not work.\n" + ] + } + ], "source": [ "import json\n", "import os\n", @@ -50,7 +60,11 @@ "from torch import nn\n", "from torchvision import transforms\n", "import py_nillion_client as nillion\n", - "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_recall_fscore_support\n", + "from sklearn.metrics import (\n", + " confusion_matrix,\n", + " ConfusionMatrixDisplay,\n", + " precision_recall_fscore_support,\n", + ")\n", "import matplotlib.pyplot as plt\n", "from PIL import Image\n", "import numpy as np\n", @@ -83,7 +97,7 @@ "metadata": {}, "outputs": [], "source": [ - "# !kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip" + "!kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip" ] }, { @@ -96,8 +110,8 @@ " def __init__(self, root_dir: os.PathLike, transform) -> None:\n", " self.root_dir = root_dir\n", " self.transform = transform\n", - " \n", - " self.classes = ['Non-COVID-19', 'COVID-19']\n", + "\n", + " self.classes = [\"Non-COVID-19\", \"COVID-19\"]\n", "\n", " self.data = []\n", " self.targets = []\n", @@ -105,7 +119,7 @@ " for class_index, class_name in enumerate(self.classes):\n", " class_dir = os.path.join(self.root_dir, class_name)\n", " for filename in os.listdir(class_dir):\n", - " if filename.endswith('.png'):\n", + " if filename.endswith(\".png\"):\n", " img_path = os.path.join(class_dir, filename)\n", " self.data.append(img_path)\n", " self.targets.append(class_index)\n", @@ -117,7 +131,7 @@ " img_path = self.data[index]\n", " label = self.targets[index]\n", "\n", - " img = Image.open(img_path).convert('RGB')\n", + " img = Image.open(img_path).convert(\"RGB\")\n", " img = self.transform(img)\n", "\n", " return img, label" @@ -136,11 +150,13 @@ " def __init__(self) -> None:\n", " \"\"\"Model is a two layers and an activations\"\"\"\n", " super(MyNN, self).__init__()\n", - " self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n", + " self.conv1 = torch.nn.Conv2d(\n", + " in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1\n", + " )\n", " self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", "\n", - " self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n", - " \n", + " self.fc1 = torch.nn.Linear(in_features=8, out_features=2)\n", + "\n", " self.relu = torch.nn.ReLU()\n", " self.flatten = torch.nn.Flatten()\n", "\n", @@ -167,7 +183,7 @@ " transform=transforms.Compose(\n", " [\n", " transforms.Grayscale(),\n", - " transforms.Resize((16,16)),\n", + " transforms.Resize((16, 16)),\n", " transforms.ToTensor(),\n", " ]\n", " ),\n", @@ -190,132 +206,132 @@ "output_type": "stream", "text": [ "Starting epoch 1...\n", - "Loss after mini-batch 100: 0.718\n", - "Accuracy after mini-batch 100: 11.250\n", - "Loss after mini-batch 200: 0.708\n", - "Accuracy after mini-batch 200: 11.312\n", - "Loss after mini-batch 300: 0.699\n", - "Accuracy after mini-batch 300: 11.000\n", - "Loss after mini-batch 400: 0.691\n", - "Accuracy after mini-batch 400: 74.875\n", + "Loss after mini-batch 100: 0.506\n", + "Accuracy after mini-batch 100: 87.312\n", + "Loss after mini-batch 200: 0.489\n", + "Accuracy after mini-batch 200: 87.812\n", + "Loss after mini-batch 300: 0.459\n", + "Accuracy after mini-batch 300: 89.875\n", + "Loss after mini-batch 400: 0.463\n", + "Accuracy after mini-batch 400: 87.688\n", "Starting epoch 2...\n", - "Loss after mini-batch 100: 0.681\n", - "Accuracy after mini-batch 100: 90.375\n", - "Loss after mini-batch 200: 0.674\n", - "Accuracy after mini-batch 200: 88.688\n", - "Loss after mini-batch 300: 0.666\n", - "Accuracy after mini-batch 300: 90.062\n", - "Loss after mini-batch 400: 0.661\n", - "Accuracy after mini-batch 400: 87.562\n", - "Starting epoch 3...\n", - "Loss after mini-batch 100: 0.651\n", + "Loss after mini-batch 100: 0.433\n", "Accuracy after mini-batch 100: 88.875\n", - "Loss after mini-batch 200: 0.645\n", - "Accuracy after mini-batch 200: 88.812\n", - "Loss after mini-batch 300: 0.637\n", - "Accuracy after mini-batch 300: 89.375\n", - "Loss after mini-batch 400: 0.631\n", - "Accuracy after mini-batch 400: 89.250\n", + "Loss after mini-batch 200: 0.424\n", + "Accuracy after mini-batch 200: 88.500\n", + "Loss after mini-batch 300: 0.418\n", + "Accuracy after mini-batch 300: 87.875\n", + "Loss after mini-batch 400: 0.411\n", + "Accuracy after mini-batch 400: 87.500\n", + "Starting epoch 3...\n", + "Loss after mini-batch 100: 0.384\n", + "Accuracy after mini-batch 100: 88.938\n", + "Loss after mini-batch 200: 0.373\n", + "Accuracy after mini-batch 200: 88.938\n", + "Loss after mini-batch 300: 0.382\n", + "Accuracy after mini-batch 300: 87.875\n", + "Loss after mini-batch 400: 0.386\n", + "Accuracy after mini-batch 400: 87.250\n", "Starting epoch 4...\n", - "Loss after mini-batch 100: 0.622\n", - "Accuracy after mini-batch 100: 89.562\n", - "Loss after mini-batch 200: 0.619\n", - "Accuracy after mini-batch 200: 88.000\n", - "Loss after mini-batch 300: 0.609\n", - "Accuracy after mini-batch 300: 89.750\n", - "Loss after mini-batch 400: 0.605\n", - "Accuracy after mini-batch 400: 89.000\n", + "Loss after mini-batch 100: 0.365\n", + "Accuracy after mini-batch 100: 88.250\n", + "Loss after mini-batch 200: 0.369\n", + "Accuracy after mini-batch 200: 88.188\n", + "Loss after mini-batch 300: 0.363\n", + "Accuracy after mini-batch 300: 88.250\n", + "Loss after mini-batch 400: 0.354\n", + "Accuracy after mini-batch 400: 88.375\n", "Starting epoch 5...\n", - "Loss after mini-batch 100: 0.601\n", - "Accuracy after mini-batch 100: 88.062\n", - "Loss after mini-batch 200: 0.587\n", - "Accuracy after mini-batch 200: 90.688\n", - "Loss after mini-batch 300: 0.587\n", - "Accuracy after mini-batch 300: 88.688\n", - "Loss after mini-batch 400: 0.581\n", - "Accuracy after mini-batch 400: 89.125\n", + "Loss after mini-batch 100: 0.345\n", + "Accuracy after mini-batch 100: 88.875\n", + "Loss after mini-batch 200: 0.369\n", + "Accuracy after mini-batch 200: 87.625\n", + "Loss after mini-batch 300: 0.353\n", + "Accuracy after mini-batch 300: 88.625\n", + "Loss after mini-batch 400: 0.365\n", + "Accuracy after mini-batch 400: 87.688\n", "Starting epoch 6...\n", - "Loss after mini-batch 100: 0.574\n", - "Accuracy after mini-batch 100: 89.188\n", - "Loss after mini-batch 200: 0.572\n", - "Accuracy after mini-batch 200: 88.312\n", - "Loss after mini-batch 300: 0.561\n", - "Accuracy after mini-batch 300: 89.750\n", - "Loss after mini-batch 400: 0.559\n", - "Accuracy after mini-batch 400: 89.000\n", + "Loss after mini-batch 100: 0.386\n", + "Accuracy after mini-batch 100: 86.312\n", + "Loss after mini-batch 200: 0.348\n", + "Accuracy after mini-batch 200: 88.812\n", + "Loss after mini-batch 300: 0.353\n", + "Accuracy after mini-batch 300: 88.375\n", + "Loss after mini-batch 400: 0.340\n", + "Accuracy after mini-batch 400: 89.125\n", "Starting epoch 7...\n", - "Loss after mini-batch 100: 0.553\n", - "Accuracy after mini-batch 100: 89.000\n", - "Loss after mini-batch 200: 0.549\n", - "Accuracy after mini-batch 200: 88.750\n", - "Loss after mini-batch 300: 0.543\n", - "Accuracy after mini-batch 300: 89.000\n", - "Loss after mini-batch 400: 0.536\n", - "Accuracy after mini-batch 400: 89.375\n", + "Loss after mini-batch 100: 0.378\n", + "Accuracy after mini-batch 100: 87.125\n", + "Loss after mini-batch 200: 0.337\n", + "Accuracy after mini-batch 200: 89.375\n", + "Loss after mini-batch 300: 0.353\n", + "Accuracy after mini-batch 300: 88.000\n", + "Loss after mini-batch 400: 0.356\n", + "Accuracy after mini-batch 400: 88.188\n", "Starting epoch 8...\n", - "Loss after mini-batch 100: 0.530\n", - "Accuracy after mini-batch 100: 89.562\n", - "Loss after mini-batch 200: 0.525\n", - "Accuracy after mini-batch 200: 89.500\n", - "Loss after mini-batch 300: 0.525\n", - "Accuracy after mini-batch 300: 88.688\n", - "Loss after mini-batch 400: 0.520\n", - "Accuracy after mini-batch 400: 88.750\n", + "Loss after mini-batch 100: 0.349\n", + "Accuracy after mini-batch 100: 88.312\n", + "Loss after mini-batch 200: 0.370\n", + "Accuracy after mini-batch 200: 87.375\n", + "Loss after mini-batch 300: 0.333\n", + "Accuracy after mini-batch 300: 89.312\n", + "Loss after mini-batch 400: 0.364\n", + "Accuracy after mini-batch 400: 88.062\n", "Starting epoch 9...\n", - "Loss after mini-batch 100: 0.509\n", - "Accuracy after mini-batch 100: 89.812\n", - "Loss after mini-batch 200: 0.506\n", - "Accuracy after mini-batch 200: 89.625\n", - "Loss after mini-batch 300: 0.511\n", - "Accuracy after mini-batch 300: 87.875\n", - "Loss after mini-batch 400: 0.498\n", - "Accuracy after mini-batch 400: 89.000\n", + "Loss after mini-batch 100: 0.340\n", + "Accuracy after mini-batch 100: 88.875\n", + "Loss after mini-batch 200: 0.346\n", + "Accuracy after mini-batch 200: 88.875\n", + "Loss after mini-batch 300: 0.356\n", + "Accuracy after mini-batch 300: 88.062\n", + "Loss after mini-batch 400: 0.375\n", + "Accuracy after mini-batch 400: 87.250\n", "Starting epoch 10...\n", - "Loss after mini-batch 100: 0.471\n", - "Accuracy after mini-batch 100: 88.500\n", - "Loss after mini-batch 200: 0.436\n", - "Accuracy after mini-batch 200: 88.125\n", - "Loss after mini-batch 300: 0.393\n", - "Accuracy after mini-batch 300: 89.438\n", - "Loss after mini-batch 400: 0.369\n", - "Accuracy after mini-batch 400: 89.688\n" + "Loss after mini-batch 100: 0.355\n", + "Accuracy after mini-batch 100: 88.250\n", + "Loss after mini-batch 200: 0.358\n", + "Accuracy after mini-batch 200: 88.062\n", + "Loss after mini-batch 300: 0.358\n", + "Accuracy after mini-batch 300: 88.000\n", + "Loss after mini-batch 400: 0.346\n", + "Accuracy after mini-batch 400: 88.625\n" ] } ], "source": [ "accuracies, losses = [], []\n", "for epoch in range(10):\n", - " print(f'Starting epoch {epoch+1}...')\n", + " print(f\"Starting epoch {epoch+1}...\")\n", "\n", - " incorrect, correct = 0, 0\n", - " current_loss = 0\n", - " for i, data in enumerate(trainloader):\n", - " inputs, targets = data\n", + " incorrect, correct = 0, 0\n", + " current_loss = 0\n", + " for i, data in enumerate(trainloader):\n", + " inputs, targets = data\n", "\n", - " optimizer.zero_grad()\n", + " optimizer.zero_grad()\n", "\n", - " outputs = my_model(inputs)\n", - " loss = loss_function(outputs, targets)\n", + " outputs = my_model(inputs)\n", + " loss = loss_function(outputs, targets)\n", "\n", - " preds = torch.argmax(outputs, axis=1)\n", + " preds = torch.argmax(outputs, axis=1)\n", "\n", - " correct += (preds == targets).float().sum()\n", - " incorrect += (preds != targets).float().sum()\n", + " correct += (preds == targets).float().sum()\n", + " incorrect += (preds != targets).float().sum()\n", "\n", - " loss.backward()\n", - " optimizer.step()\n", + " loss.backward()\n", + " optimizer.step()\n", "\n", - " current_loss += loss.item()\n", - " if i % 100 == 99:\n", - " accuracy = 100 * correct / (incorrect + correct)\n", - " accuracies.append(accuracy)\n", + " current_loss += loss.item()\n", + " if i % 100 == 99:\n", + " accuracy = 100 * correct / (incorrect + correct)\n", + " accuracies.append(accuracy)\n", "\n", - " print('Loss after mini-batch %5d: %.3f' % (i + 1, current_loss / 100))\n", - " losses.append(current_loss/100)\n", - " print('Accuracy after mini-batch %5d: %.3f' % (i + 1, accuracy))\n", + " print(\"Loss after mini-batch %5d: %.3f\" % (i + 1, current_loss / 100))\n", + " losses.append(current_loss / 100)\n", + " print(\"Accuracy after mini-batch %5d: %.3f\" % (i + 1, accuracy))\n", "\n", - " correct, incorrect = 0, 0\n", - " current_loss = 0" + " correct, incorrect = 0, 0\n", + " current_loss = 0" ] }, { @@ -326,7 +342,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -335,7 +351,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACHoklEQVR4nO29e3wU9b3//5q957JJCAm5QALhIggCKiqC90IRyvHg9acefoV6b9Wj1JZzoN+DvXD4RtRSW/SHPZ5aab2gtlpstbZKhUpBKTcFRO4CgVxICNlNNnuf3x+7n5nZzV5mZmd3Z3ffz8cjD0gyOzuT2Zl5z/v9er/eHM/zPAiCIAiCIHSMIdsbQBAEQRAEkQwKWAiCIAiC0D0UsBAEQRAEoXsoYCEIgiAIQvdQwEIQBEEQhO6hgIUgCIIgCN1DAQtBEARBELqHAhaCIAiCIHSPKdsboBXBYBCnT5+G3W4Hx3HZ3hyCIAiCIGTA8zycTifq6+thMMTPo+RNwHL69Gk0NDRkezMIgiAIglDByZMnMWzYsLi/VxywOJ1OLFu2DG+//TY6Ojpw0UUX4ec//zkuvfRSAKFI6Yc//CFeeOEFnDt3DldccQXWrFmDMWPGJFzvc889h6eeegptbW2YPHkyVq9ejcsuu0z2dtntdgChHS4rK1O6WwRBEARBZAGHw4GGhgbhPh4PxQHLvffei7179+K3v/0t6uvr8fLLL2PmzJn44osvMHToUDz55JP4xS9+gbVr16KpqQnLli3D9ddfjy+++AI2my3mOl9//XU89thjeP755zF16lQ888wzuP7663HgwAEMGTJE1naxMlBZWRkFLARBEASRYySTc3BKhh/29/fDbrdj/fr1mDt3rvDzKVOmYM6cOVi+fDnq6+vxve99D9///vcBAD09PaipqcFLL72EO+64I+Z6p06diksvvRTPPvssgJAepaGhAf/+7/+OJUuWyNo2h8OB8vJy9PT0UMBCEARBEDmC3Pu3oi4hv9+PQCAwIFNSVFSEzZs349ixY2hra8PMmTOF35WXl2Pq1KnYunVrzHV6vV7s2LEj4jUGgwEzZ86M+xoA8Hg8cDgcEV8EQRAEQeQnigIWu92OadOmYfny5Th9+jQCgQBefvllbN26Fa2trWhrawMA1NTURLyupqZG+F00nZ2dCAQCil4DAM3NzSgvLxe+SHBLEARBEPmLYh+W3/72t+B5HkOHDoXVasUvfvEL3HnnnQlbkdLB0qVL0dPTI3ydPHkyo+9PEARBEETmUBxljBo1Cps2bUJvby9OnjyJbdu2wefzYeTIkaitrQUAtLe3R7ymvb1d+F00VVVVMBqNil4DAFarVRDYktCWIAiCIPIb1WmRkpIS1NXVobu7G3/5y18wb948NDU1oba2Fhs2bBCWczgc+PTTTzFt2rSY67FYLJgyZUrEa4LBIDZs2BD3NQRBEARBFBaK25r/8pe/gOd5jB07FocPH8bixYsxbtw43HXXXeA4DosWLcJ///d/Y8yYMUJbc319PW688UZhHTNmzMBNN92Ehx9+GADw2GOPYeHChbjkkktw2WWX4ZlnnkFfXx/uuusuzXaUIAiCIIjcRXHA0tPTg6VLl6KlpQWVlZW45ZZbsGLFCpjNZgDAf/zHf6Cvrw/3338/zp07hyuvvBLvv/9+RGfRkSNH0NnZKXx/++2348yZM3j88cfR1taGCy+8EO+///4AIS5BEARBEIWJIh8WPUM+LARBEASRe6TFh4UgCIIgCCIbUMBCEARBEITuoYCFIAiCIAjdQwFLFtl3ugf/+/FR+APBbG8KQRAEQegaxV1ChHYs/9MX+OToWZxXY8fV51Vne3MIgiAIQrdQhiWLnHF6AACdvZ4sbwlBEARB6BsKWLKIw+0HADjD/xIEQRAEERsKWLKI0+0DAPR6KGAhCIIgiERQwJIlfIEg3L6Q2JYyLARBEASRGApYsoQ0SGGZFoIgCIIgYkMBS5aQBilUEiIIgiCIxFDAkiUc/WKQ0kslIYIgCIJICAUsWUKaYSENC0EQBEEkhgKWLOGQalioJEQQBEEQCaGAJUtEalhIdEsQBEEQiaCAJUtEZFioJEQQBEEQCaGAJUtEZFjcfvA8n8WtIQiCIAh9QwFLlpBmVfxBHh4/TWwmCIIgiHhQwJIlos3iHGQeRxAEQRBxoYAlS0TrVsiLhSAIgiDiQwFLlojOqJDbLUEQBEHEhwKWLBGdYaFOIYIgCIKIDwUsWYIFKBwX+T1BEARBEAOhgCVLMNFtjd0GgEpCBEEQBJEICliyBDOOq68IBSzRXUMEQRAEQYhQwJIF3L4AvGHflbqKIgDUJUQQBEEQiaCAJQtI9Su1ZeEMC5WECIIgCCIuFLBkAVb+KbWYUGYzh39GAQtBEARBxIMClizAgpOyIjPsNhMAEt0SBEEQRCIoYMkCzDTObjOhNBywkOiWIAiCIOJDAUsWYBkWu80EuzWcYaGSEEEQBEHEhQKWLOAUMixm2MMaFioJEQRBEER8KGDJAtIMi1gSooCFIAiCIOJBAUsWYKZxZTYzSq2kYSEIgiCIZFDAkgUc/aLotkzSJcTzfDY3iyAIgiB0CwUsWUAsCZmFklCQB1zeQDY3iyAIgiB0i6KAJRAIYNmyZWhqakJRURFGjRqF5cuXR2QG2tvb8a1vfQv19fUoLi7G7NmzcejQoYTrfemll8BxXMSXzWZTt0c5gFPS1lxkNsJoCI1sJuEtQRAEQcTGpGThlStXYs2aNVi7di0mTJiA7du346677kJ5eTkeeeQR8DyPG2+8EWazGevXr0dZWRlWrVqFmTNn4osvvkBJSUncdZeVleHAgQPC9xzHqd8rnSMV3XIch1KrCT39PjjdftSUZXnjCIIgCEKHKApYtmzZgnnz5mHu3LkAgBEjRuC1117Dtm3bAACHDh3CJ598gr1792LChAkAgDVr1qC2thavvfYa7r333rjr5jgOtbW1avcjp3B6QhmWsqJQS7MYsJDwliAIgiBioagkNH36dGzYsAEHDx4EAHz22WfYvHkz5syZAwDweDwAEFHOMRgMsFqt2Lx5c8J19/b2Yvjw4WhoaMC8efOwb9++hMt7PB44HI6Ir1zB0c+6hELxItnzEwRBEERiFAUsS5YswR133IFx48bBbDbjoosuwqJFizB//nwAwLhx49DY2IilS5eiu7sbXq8XK1euREtLC1pbW+Oud+zYsXjxxRexfv16vPzyywgGg5g+fTpaWlrivqa5uRnl5eXCV0NDg5JdySpS47jQv+R2SxAEQRCJUBSwvPHGG3jllVfw6quvYufOnVi7di2efvpprF27FgBgNpvx1ltv4eDBg6isrERxcTE++ugjzJkzBwZD/LeaNm0aFixYgAsvvBDXXHMN3nrrLVRXV+OXv/xl3NcsXboUPT09wtfJkyeV7ErW4Hk+QsMCQOLFQgELQRAEQcRCkYZl8eLFQpYFACZOnIjjx4+jubkZCxcuBABMmTIFu3fvRk9PD7xeL6qrqzF16lRccsklst+HZW8OHz4cdxmr1Qqr1apk83WB2xeEPxjqqioTMiyhf51UEiIIgiCImCjKsLhcrgGZEqPRiGAwOGDZ8vJyVFdX49ChQ9i+fTvmzZsn+30CgQD27NmDuro6JZuXE7BJzUYDh2KLEQAELxYqCREEQRBEbBRlWG644QasWLECjY2NmDBhAnbt2oVVq1bh7rvvFpZ58803UV1djcbGRuzZswePPvoobrzxRsyaNUtYZsGCBRg6dCiam5sBAD/5yU9w+eWXY/To0Th37hyeeuopHD9+PGFXUa7C9CulVpPQum0ne36CIAiCSIiigGX16tVYtmwZHnzwQXR0dKC+vh4PPPAAHn/8cWGZ1tZWPPbYY2hvb0ddXR0WLFiAZcuWRaznxIkTEZma7u5u3HfffWhra8OgQYMwZcoUbNmyBePHj09x9/SHI0q/Iv0/dQkRBEEQRGw4Pk8G2DgcDpSXl6OnpwdlZfp1X9t08AwWvrgN59eV4c+PXgUAeOkfx/CjP36BuRPr8Nz8i7O8hQRBEASROeTev2mWUIZhZZ8ySYallES3BEEQBJEQClgyDDONY51Bof8z0S1pWAiCIAgiFhSwZJhYGRY7+bAQBEEQREIoYMkw0aZxgKStmUpCBEFEcfKsC5sPdWZ7Mwgi61DAkmGibfml/ycfFoIgovn313bh//3VpzjU7sz2phBEVqGAJcOwDEtZkSTDEi4J9Xr9CAbzommLIAiNOHWuHwBwrLMvy1tCENmFApYM44iZYQkFLDwP9Hkpy0IQhAjLvHb2erO8JQSRXShgyTCxjOOsJgPMxpDrLelYCIJg+ANB9PsCAICuXk+Wt4YgsgsFLBlGFN2KGRaO42hiM0EQA+jzBIT/d1LAQhQ4FLBkmFhtzYDYKUQBC0EQDKdH9GbK95LQxgMd+PvBM9neDELHUMCSYRz9AzUsAGC3hjuFqCREEEQY6fXgTB5nWNy+AO7/7Q7c+5vtcPsCyV9AFCQUsGQQnueFC1D8DAu53RIEEUJqdZDPJaFulxdefxBefxDtDne2N4fQKRSwZJA+bwCsazk6w1Im2PNThoUgiBDS+WKdzvwNWHr6xQe1jjzeTyI1KGDJICx7YjJwsJkj//SCFwuVhAiCCCN9gHG4/fD6g1ncmvTBZqwBQIeDAhYiNhSwZBDRNM4MjuMifsdKQg7KsBAEESb6AaarLz9v5o6IDAuVhIjYUMCSQUTBrWnA78ienyCIaKKvB53O/OwUcripJEQkhwKWDBJr8CFDLAmR6JYgiBDOqAxLvgpvIzIsVBIi4kABSwYRbPmt5gG/s5MPC0EQUURnWPK1tblHqmGhkhARBwpYMkiiDAv7GYluCYJgRGdc8zbD4qYMC5EcClgyiFR0G01pOOtColuCIBjsAabYYgQAdOWp2y2Jbgk5UMCSQcRJzQk0LGQcRxBEGPaQM3xwCYDCyLB0u3x5275NpAYFLBnE6Y5tyx/6GZWECIKIhF0PmqqKAeRxwNJfGFodIjUoYMkgQkkogYaFRLcEQTCY6HYEy7DkaVuz1OkWADrInp+IAQUsGUROW7PLG0CA+fcTBFHQsAzLiKrCKAmZDCFDTfJiIWJBAUsGYSWhshgloVJJEENlIYIgAGlJKBSwnHV58/KBholuhw8Olb4oYCFiQQFLBmF12lgaFqvJCIspdDhoYjNBENLp7g2DisFxAM8DZ/vyqywUDPKCQd6YIXYAwBkqCRExoIAlgzgTdAkBgJ0GIBIEEcblDYAPJ1Mqis2oLLYAyL+yUK/XL+zn6CGlACjDQsSGApYMkkjDIv05zRMiiNzi6b8cwOI3PwPPa1euYQ8uJgMHq8mAqlIrgPwLWHpcoQc5q8mAYYOKAADtlGEhYkABS4YIBnn0euMbxwGijoU6hQgid+jz+PHsR4fx5o4WnDrXr9l62XWgxGoCx3GosudnhoUJbsuLzBhSFgrKKMNCxIIClgzh9Ihpz3gZFtYpFD3wjCAI/XLkTK/w/2g/kVRgGRZ2XRAyLHnW2sz+ZmVFZgyx2wBQwELEhgKWDMH0KxaTAVaTMeYyTIxLJSGCyB0OtYsBi5aC+d6oEvLgknDA0pdfN3OH0D1pwhB7aB+7ej152Q1FpAYFLBkikWkcg4luqUuIIHKHQx2SDIuGDxts8KGQYWElobzLsIQDliIzBpdaYeCAIB8KWghCCgUsGUIU3MbWr4R+R11CBJFrHO5wCv939Gv3sMGuGUzblrei237Rn8po4DC4lHQsRGwoYMkQTknaMx4kuiWI3CMyw6JhSShKw1KdpwELy0qVh5sRWFmIpjYT0VDAkiEcCQYfMkqtod9RwEIQuYHbF8CJsy7hey3P3WgNS75mWMSSUGg/a8rCwltHfu0nkToUsGSIZB4s0t+x2jVBEPrm6Jk+SK1XtCwJDegSCmtYunq9COaRINURNbJEzLBQwEJEoihgCQQCWLZsGZqamlBUVIRRo0Zh+fLlEWZJ7e3t+Na3voX6+noUFxdj9uzZOHToUNJ1v/nmmxg3bhxsNhsmTpyI9957T/ne6BhlAQtlWAgiFzgk0a8A2paEnELAErqRV5aEAhZ/kNf0fbKNtK0ZEAMWMo8jolEUsKxcuRJr1qzBs88+i/3792PlypV48sknsXr1agCh2Rc33ngjjh49ivXr12PXrl0YPnw4Zs6cib6+vrjr3bJlC+68807cc8892LVrF2688UbceOON2Lt3b2p7pyPklYRIw0IQucThsH6FTRlOR0mIadusJqOggcunslB0hqW6jLxYiNgoCli2bNmCefPmYe7cuRgxYgRuvfVWzJo1C9u2bQMAHDp0CJ988gnWrFmDSy+9FGPHjsWaNWvQ39+P1157Le56f/7zn2P27NlYvHgxzj//fCxfvhwXX3wxnn322dT2TkeIbc2JuoTIh4UgcgnmwTKhvgxAekS3zO4AAKrC2YczedTazMpoA0W3FLAQkSgKWKZPn44NGzbg4MGDAIDPPvsMmzdvxpw5cwAAHk/oA2az2cQ3MBhgtVqxefPmuOvdunUrZs6cGfGz66+/Hlu3bo37Go/HA4fDEfGlZ9hJmagkRE63BJFbsJLQxcMHAdDY6TYqwwLkp/A2WnTLAhaa2ExEoyhgWbJkCe644w6MGzcOZrMZF110ERYtWoT58+cDAMaNG4fGxkYsXboU3d3d8Hq9WLlyJVpaWtDa2hp3vW1tbaipqYn4WU1NDdra2uK+prm5GeXl5cJXQ0ODkl3JOEo0LGQcRxD6x+sP4quuUIfQlHDAouW564wS3QL52drsiMo+DwmXhM70ejQdJknkPooCljfeeAOvvPIKXn31VezcuRNr167F008/jbVr1wIAzGYz3nrrLRw8eBCVlZUoLi7GRx99hDlz5sBg0LYhaenSpejp6RG+Tp48qen6tcYpQ8PCAha3LwhfIJiR7SIIQh3Hu/oQCPIotZowZogdQJqcbiMyLPk1ANEfCAqlLya6ZUGZL8Cj20UPb4RI/Mf9GCxevFjIsgDAxIkTcfz4cTQ3N2PhwoUAgClTpmD37t3o6emB1+tFdXU1pk6diksuuSTuemtra9He3h7xs/b2dtTW1sZ9jdVqhdVqVbL5WUWONX+J5Emq1+3HoHBXAEEQ+oMZxo0aUiroLxz9PvA8D47jUl6/4MMiuS4wF9iu3vzQsEg7ItkDm8VkwKBiM7pdPnQ43UJ3FEEoSnu4XK4BmRKj0YhgcGA2oLy8HNXV1Th06BC2b9+OefPmxV3vtGnTsGHDhoifffDBB5g2bZqSzdM1ghK+KH6GxWw0wGYO/X2ptZkg9A0T3I4ZUiroL/xBHm5f6tlRnudFH5Y81rAwW/4SixFmo3hvEaY2k3kcIUFRhuWGG27AihUr0NjYiAkTJmDXrl1YtWoV7r77bmGZN998E9XV1WhsbMSePXvw6KOP4sYbb8SsWbOEZRYsWIChQ4eiubkZAPDoo4/immuuwU9/+lPMnTsX69atw/bt2/E///M/Gu1m9pGjYQn93gy3z1PQrc1dvR5FqfXBpZaE3VcEkQ6Y4HbMkFIUmY0wGjgEwh4pRZbYE9nl4vEH4QuE9BtSDQsrCZ3JkwxLtAcLY0iZFQfandQpRESgKGBZvXo1li1bhgcffBAdHR2or6/HAw88gMcff1xYprW1FY899hja29tRV1eHBQsWYNmyZRHrOXHiRESmZvr06Xj11VfxX//1X/jBD36AMWPG4A9/+AMuuOCCFHdPH/gDQbi8AQCJNSxAKP17xukpWOHttmNnccf/bIUSI88isxF/+/41qCsvSt+GEUQUzINlTE0pOI5Dmc2EbpcPjn6fYC+vlj5JhrXEMrCtuTNPbuTRHiwMlmEh8zhCiqKAxW6345lnnsEzzzwTd5lHHnkEjzzySML1bNy4ccDPbrvtNtx2221KNidniFWnjUdpgbvd7jjejSAPmI0cbKbkT6kuXwD9vgA+O9lDAQuRMfyBII6eCZlhMsFtWVFId6GFF4vUlt9gEPUw0i4hrbQy2SS6pZkxpIz5zeRHYEZog6KAhVAHK+8UmSPrtLEodHv+rnBt/q4rmvCDb5yfdPkHX9mB9/a0obWnP92bRhACJ7v74Q0EYTMbMLQiFCizc1eLTiF2zZCWg4BQ+RMIlYz6vIEBv8814mdYaGIzMRAafpgBemSYxjHYBUjL9shc4mxfqDYvtzOAZVVOn6OAhcgch9pD+pVR1aVCBoTddLUYgMgeWEqskVnGYosJxWF9TD6UhXqiXG4ZJLolYkEBSwaQK7gFxEFnhWrP3xkOWAbLDFjqK1jAQk9iROZgLc1jhpQKPxMCFg3OXdHldqDmLZ86hRKJbgGy5yciye18Yo4gxzSOIZaEUntK8wWCaOtxo6GyOKX1ZBpWEmIX5WTUl4eexE5TSUg1DrcPvW6/EPwRyREFt3bhZ1o6VceaI8SoKrXgxFlXfgQsQkkoSsMiKQlpodVxuH3Yd0r++BaTkcPkYRWwmOiZXk9QwJIBlGRYxIteak9pqzccwi/+dhhr5l+MORPrUlpXJmGGWKxWnwwxw0IBi1ru+OUnONzRiy1LvyY7UCx0WEvzaGmGRTCP00DDEsOWn8GOUT60Noui29glIbcvCKfHn7JtwR2//ARftCqbN3f7JQ1YeeuklN6X0BYKWDKAU4ZpHINdoFItCe08cQ4AsO6fJ3MmYOF5Hl19oafGwTJvnHUV4ih6XyCYVNRMRHLqXL9wIT/c0UsBiwyCQV7MsMQsCWmQYYkx+JCRT63N0XOEGEUWI+xWE5wePzocnpQClj6PX/iMj6ouSZqtcfsCaOnux/bjZ1W/J5EeKGDJAA4ZtvwMVjZKdWJzW9i/4B+HO9Hj8qG8WP/Gak6PXzDLkqthqSqxwmI0wJujJbBs8+nRLuH/pBeQx6lz/XD7grAYDWiUfN5Ya64Wpo/CHKFYGZbwucGC+1ymJ06GBQCqy6xwnvGjw+mOyGQp5VhnqP18cIkFG753bdLlT53rxxVP/A0nzrrgDwRhoocg3UBHIgMo0bCUalQHZ4ZL/iCPD/e3J1laH7ByUInFCJtZnlOowcAJWZbWHhLeKmXbMfEpsoNMumTBsitNVSURNzO7ll1CCcrIYoYln0pCA/ezRqNOoaPhgKWpqkTW8nVlNtjMBvgCPFq6qdSsJyhgyQDOGEPM4qGFD4vL6494yvvz3lbV68okTHArtxzEqGPCW9KxKOZTacBCGRZZCPqVmsin/jLBhyX1gEWOhiW/RLcDH+bETqHUAumjZ0IB5shqeQGLwcBhxODQskc7e1N6b0JbKGDJAIpEtxpoWNrDTySsVPv3g505YfXfqVBwyxCEt9QppIgOh1tIl7Pv85n9rQ58JdlftUiHHkphZQ1NSkKJNCz5FLCEBcrRPiyApFMo1QxL2JF4ZLX8stKo8LLstYQ+oIAlA8iZ1Mwo1aBLiJWDmgaXYGR1CbyBIP72ZYfq9WUKQXBboizDUk/mcar45FikqDCfMyxOtw/znvsHblmzBV5/atOURQ8We8TPBadbDY3jYmdYQgF9Z453CXn9QfT7QjPWYmZY7KKgPhWOKSwJSZc9qkGAS2gHBSwZwCFkWOT4sKQuumUBS02ZDd+4INQh9Oc9barXlymYhqVKZYallczjFLHtWEhwO642dOPN54DljNMDrz+Irj4vdp7oVr0enucjhh5K0bRLyBM/K8tKpr0eP9zhG34uIv07xcokaVES4nleKAmNklkSAsTyEXstoQ8oYMkAouhWvjW/1x+Ex6/uYiQGLFbMvqAWALDxYAdcXn275zJbfqUlISa6PUUZFkV8ejSUYblhcj2A/C4JsWnpALDp4BnV62lzuNHr8cMo0TkwWAbV7QumnMURSkLWgQ85ZTYTLGGxby6XhRySkSVGw8BW42p76m63HU4P+rwBGDigsVJJwEIlIT1CAUsGUGbNLy6jVsfS1hM6wWvKbZhQX4bGymK4fUFsPKD+Qp0J2MW3UmFJiA2foy4h+XT1eoTSxtywT4/DndtP7ImQitg3pXAesOzK8MHFA1xQpeduqpqxRKJbjuPyoiwUz4OFwUpCZ1LQsLCAo6Fy4PFKBCsJdTg9BTuIVo9QwJIBnAmU8NEYDRxKwsPN1J4o7eEUao3dBo7jMGdiKMvy3h59dwupLQmxLqGefh/66OIiC9bOPLbGjuGDi2ENX8zP5GlZSJpd/KLVobrMEE9wC4TOXbtGw0sTtTUD+WEeF8/llsFKQk6PH/1edYE06/IZqUC/AoREwOw6dIyyLLqBApY04/UH4faF0sNy3RpTFd6y1H5t+EY+J6xj+duXHbp+glYrurXbzMKFvZU6hWTB2pmnjqwEx3GatZDqlV5P5Of+44OdqtYTT3DLEO351WdY/AFRjBorwwLkR6dQvDlCDLvVBJs5dItS+7lkwUZTlXLjOVF4SzoWvUABS5pxJhGWxYJdpNQGLG0SDQsATB5WjvpyG1zeAP6eQv0+3SidIySFdQqdIuGtLFjAcllTJQBJR0aKLaR6xRWVeVOrYzkc9mCJFtwytJgF1icJrkriBiysJJS7xyuRyy0QKn3VlIU+l+0qP5esy0euB4uUkVWkY9EbFLCkGXbhKrEYYwrLYsE6hdSUhHieF05udhMKlYXC3UJ79dktFAjyOOtKIWCpIPM4ufS4fPiyLTRbRQxYQsFte54Kb9m5xKZ7f3zoDAJBXtE6eJ7HwXBJKJ5VvBadQs6wLb/VZIiruxgsZFhyWMOSwIOFIZ3arAalpnFShE4ham3WDRSwpBmngpZmRipj6s+5fEKHAkvzA8CccLfQh1+0q+4+SifnXF7w4ftHZbHygKVOaG2mgCUZ2746C54PXZBZUDtEg44MPcO6hK4YXQW7zYRulw97T/UoWkdnrxc9/T5wnGgsFg2zmE+lJMQyLIlE+vlVEkoUsKjP/Hn9QZwMW+uPTKEkdIxKQrqBApY0I05qlj9nUpjYrCLDwgS3lSUWWE3iPJ6LGwdhiN0Kp8ePfxxWV79PJ13hluaKYrOqYWOsU4hKQslhAw+nNg0WfjakTBuTLr3CxNjlRWZcOboKgPKyEOsQaqwsjjvrSvBRSqEklGjwISMfSkKJ5ggxUmltPnHWhUCQR4nFKJTHlcBam4+d6QPPK8vGEemBApY041Aw+JCRSh28rUc0jZNiMHBClkWPJnLswit3SnM09cIARMqwJGPbV2HBbbgcBGjjeaFnWPBfbDXh6vOqAagJWMIzhBJYvGsxT0goIycIWKrzoSSUpK0ZSM08jpWDmqpLwHHyyvFSGiuLYTRw6PMGVGtoCG2hgCXNOBR4sDCYWZSagIWlTmM9UcwOdwv99Yt2+AKpGVtpjSi4Vf4kBAB1ZM8vC6dbLIVMHSkGLOLclvzMULGSUKnVKAQsu050o8clP7BgHULRQw+laNEllMiWnyG0NedwhiWZ6BaQeLGoCKRFS37l5SAAsJgMaBgUuq5Qp5A+oIAlzajRsJQKE5uVX/SYaLI2KsMChASWg0ss6On3YeuRLsXrTidsUrNSDxbGUGEAopvStwnYfrwbQT709MiCPEDMyOWrDwsLAkqsJgytKMKYIaUI8sA/jsgvj4oeLLFbmgExW5BSSUjGQw7TsJxz+XT38CEXFtTJEt2qyHAIQw8VerBIIcdbfUEBS5pRYsvPYGllNU63rKV5SIyAxWjgcD0rC+msW4hpWJR6sDBqymzgOAjzYojYMDt+aTkIEG8MXX3enL0BJoIZx5VYQueWUBZS4HorerDEf2K3a1ASkpNhqSgyC12HZ3P0857MhwVIrSR0LIWWZsZIQXhLAYseoIAlzbDWPbmmcUBqPiztCUpCAIRhiH/d1wa/jm5MXSrnCDEsJoNQ16chiPH5NDzw8LKogGVQsQWm8A0wl8sM8WDGcUwXco1ExyInI3fO5RX+LqMSBCxiSUh9hoWd94l8mwwGDpVhvVeuZsWEa6OMklC3y6e4u1F0uVVXEgJC+heAhiDqBQpY0oyaDIvgdKumSyhBSQgI6RYqis3o6vMK4ks90JWi6BYQW5tpCGJsXF4/9rSE9CuXjxwc8TuDgROFt3koMGTGcWzsxWVNlbCZDWhzuAVvlUSwDqGhFUUJMx9a+LCIGZbEDzm53tosZFgSBCyDis0wG0OBtJLArKffJwiSm1LKsIRLQpRh0QUUsKQZp6CElx+wCMZxqjIssbuEGGajAbPG1wAA3tdRWShV0S0ADKVOoYTsPH4O/iCP+nIbhg0qGvD7fPZi6fNEdt7YzEYhaJPj/szKQYmyK4A2TrdyNCwAcnoAotsXEPyiEl0bOY4TvVgUfC5ZCWeI3ZowwEwGKyedPOtKeQI3kToUsKQZ5lqpSHTLSkIKRbf+QFB42ooXsACIcL0NKnT7TBeihiWFDAt1CiWElYOmjhwcs82z2s5s0LUrqf3jcCf++09fZN2ssM/LSkKif8rVY+S3NycaeiglU11CgLS1OfcCTPb3MXAy9lNF5i8Vh1spQ+xWlFiMCPLAibOFnWX5zss7sOT3n2f1+koBS5pxqmhrViu67ez1IsiHxLWJbvxXjAq5fZ5xerDjRLei90gXgg9LChmWekmnEDGQeIJbhihw1O4G2Pzn/fjfzcewUYG4VWt4nh+QYQGAa8aGApZtx85GTHOOxSE2QyhZwCIp5yq1/mc4ZQYsTO+VixObpeWgZB4pLPN3RoHwVugQSuCZIweO44R1HCngTqE+jx/v72vDun+ehFmFsadWUMCSZpKNUI+F2NbsV9Siy56Mh9itMCSYW2QxGfD180NlIT2YyHn8ASGwU9vWDIhzYijDMhC3L4DdJ88BGCi4Zai5MSTjeJcr/G/2LvbeQBD+cPBQbBGDgJFVJRg2qAjeQBCfHE3c5s80LPGGHjKkmVQ1TtUA0Bu+mScblso0LLnYFdejoBlBTSAtdAil0NLMaKJOIXzR6gDPh7SRLOOVDShgSTNqMizsycoX4OFRUDdtS6JfkSKWhVqzXhbq7gtdoE0GTlE3VTT1wjwhyrBEs/vkOXgDQVTbrcIFOBqtJzb39PuEz//Js9kLIiOmH1vEkhDHcUK30N8Pxvdjcbp9aA1n7UZXx/dgAUIPAzZz6LKqtizEAh17kgxLLotuHQpGlqj5XB7RqCQkXUchdwoxs8kLhpZldTsoYEkzaozjSiwmsCypEvFehxCwJI+ArxpThRKLEa09bnzWck72e6QDdsEdVGJJmBlKRl1YdNvudOell0gqSMtB8VLwWotuT3WLQcqJsy5N1qkGVg6ymQ0D5lTJseln2ZUhdivKi5Ofx6l2CvXKaGsGRLfbXGxrFjLPcjIsCic2B4M8vupiGZbUSkKAZKZQAWdY9p4KTXe/YGh5VreDApY04vYF4A3fOJVkWAwGDqUW5QMQ25K0NEuxmY342vn66BbSQnALAFUlVliMBvC8tsLRfEAquI1HjTAAUZu/nbS9/GR3FgOWKNM4KdNHDYbJwOFYZ1/cshULWEYn0a8wUu0UkqthyeUuITkutwylJaFWhxtuXxBmIxezG04prKxUyG63+06HMyz1FLDkLeyCxXEQAhC5CF4sCp7SmGlcLJfbWHwj7Hr73t7WrNrZi7b8qdVGDQZOyLKcprKQgNcfxM6wuDqe4BYQbwydvV7VglEpLZIgpeVsf9ZKj7EEtwy7zYwpwwcBiN/efFiGw62UVDqFeJ4Xu4SSPOSwLqGzfR5NjlcmkTP4kKG0rZmVbhori1VNfo+GlVC7+ryKZk/lC25fQGjrpwxLHsNSwqVWk+JSh11Fp1Ay07horhlbDZvZgJNn+7HvtEPR9mmJ6MGSWoYFAOpIeDuAPafOwe0LorLEkvCmO7jEAo4DAkFeE7t3aUnIGwhmzd+FaViKJfoVKWJZKLaORRx6mFi/whBLQsozLC5vAOzZwZ7EOG5QOCMZ5IFuV25lWcRmBDkaFlGrI8edO9Whh9GUWE1Cmb0QhyDub3UgEORRVWqRJTdIJxSwpBGngqeIaFg6WMlFL5lpXDTFFhOuGzsEQEh8my1SnSMkRWxtpoCF8UlYv3LZiPj6FQAwGQ3CMdCiLBTtOJwtHUtfkhILE95uOdIZ0xxMbkszg2VYlGRHGSy7YjRwgng3HmajAYPCmpquHCsLiXOEkl8bB5daYeAAnpfXEcVKN6M0ENwyBMfbAiwL7T0t6leStaCnG0UBSyAQwLJly9DU1ISioiKMGjUKy5cvjygn9Pb24uGHH8awYcNQVFSE8ePH4/nnn0+43pdeegkcx0V82Wzybrp6Ro0tP6OUud0q0bD0yBfdMli30Ht72rJWFhJs+TXIsNSTedwAPj0WFtyOjF8OYqQyHTealnCGhSUXT2YrYAmbxhXHCVjG15WhqtQKlzeA7ccjx1W4vH5hP+QGLMIARBXzhIQ5QlaTrJtDrnYK9SiwezAaOGE/5Xwuj2ow9DAaoVOoADMs+07pQ78CKAxYVq5ciTVr1uDZZ5/F/v37sXLlSjz55JNYvXq1sMxjjz2G999/Hy+//DL279+PRYsW4eGHH8Y777yTcN1lZWVobW0Vvo4fP65uj3SEmpZmhlgSkveU1u8NCNmYmnL5wd7Xxg2BxWTAsc4+HGh3Kt5OLdBKdAtQa3M0/kAQO8Izo+L5r0hJZTpuNCzDMjFc985+hiV2Schg4HD1eVUABnYLHT3TB54HKksssk0NU+kSkutyy8jVgIUFc3JEt4CyzyXTsGhVEgqtq3C9WPae1kdLM6AwYNmyZQvmzZuHuXPnYsSIEbj11lsxa9YsbNu2LWKZhQsX4tprr8WIESNw//33Y/LkyRHLxILjONTW1gpfNTU16vZIRyhp3YvGrnBiMzuRi8zGpP4NUkqtJsGi/L0smch1aeByy2CiWxqAGGLfaQf6vAGU2UwYV5v8gqNVhsXl9Qs6mMtHhTqTstUpxLqEihMI3+P5sSjtEAJEXYYa0a3cOUKMXG1tVuLDAsgX3rp9AeHc1zLDMqq6MEtCHn8AB9pCD7ITci3DMn36dGzYsAEHDx4EAHz22WfYvHkz5syZE7HMO++8g1OnToHneXz00Uc4ePAgZs2alXDdvb29GD58OBoaGjBv3jzs27cv4fIejwcOhyPiS2+kkmFhT1hyS0KsHFRbblNcZ/zGxFC30J/3ZEfH0qmh6HYoy7CQPT8AsZ35sqZKGGUIv9UMmosFE9zarSbhQpe1kpCMrMWVo6vAcSGBobQlnulXlAQszHNJTVuz8gxLbrY2K32YkxtIH+9ygedDIxK0yNgyWPBzrLMv60abmeRQey98AR7lRWZNWsRTRVHAsmTJEtxxxx0YN24czGYzLrroIixatAjz588Xllm9ejXGjx+PYcOGwWKxYPbs2Xjuuedw9dVXx13v2LFj8eKLL2L9+vV4+eWXEQwGMX36dLS0tMR9TXNzM8rLy4WvhoYGJbuSEUQNi4oMC7voyQxY2sM3mCEqbJNnjAtlsw519GrSHaKUrr5wW7MGolvWJdTT7xNuVIWMaBgX339FilYloZbwU+7QQUVorCwGkD23W9YlVBKnJASEsnuTwqUraXuz3KGHUtg8oVRKQrFasGORsyUh1pAgtyQk0zxOKAdVl2oqEB1aUQSzkYPHHywoQT9zuJ2oA8EtoDBgeeONN/DKK6/g1Vdfxc6dO7F27Vo8/fTTWLt2rbDM6tWr8cknn+Cdd97Bjh078NOf/hQPPfQQPvzww7jrnTZtGhYsWIALL7wQ11xzDd566y1UV1fjl7/8ZdzXLF26FD09PcLXyZMnlexKRnCkkmFRaD7VLsmwKKW82CzUaNkHNFO4vH64faHODC0yLHabWfh7txbQhSUWgSCPbV/JF9wC2rndMqHqsEFFaAg/mbU53HD7Mj+1mQWuiUpCgNje/PdDYllI9GCR19IMSHxY1AQsMucIMViGpSuHAhae50XRrcyHueoyeZk/JrgdpcEMISkmowHDBxeegRzTr0zQgX4FUBiwLF68WMiyTJw4Ed/85jfx3e9+F83NzQCA/v5+/OAHP8CqVatwww03YNKkSXj44Ydx++234+mnn5b9Pix7c/jw4bjLWK1WlJWVRXzpDTW2/AymQ5ErulXa0hwNMwRiH9BMwdoxbWZDXJ8MpbBOoVMFLrzd3+qA0+1HqdWE8XXyzg9mOpiqhoWVhIZWFKGyxCLM8MmGtohpWJKVWZiO5eNDZxAI8vD4A4LFe7Khh1LKUnC6lTtHiCFmWHKnJOTyBgSjO9miW5mBNAsm4s3LSoVCFN4Klvw60K8ACgMWl8sFgyHyJUajEcFg6AnZ5/PB5/MlXEYOgUAAe/bsQV1dnZLN0x1KhWVS7DaFGhbJpGY1XFAfuqHtO5VZLRBLZQ8usWqWcqwPC29bC1x4uy3czjxl+CDZjp9DJCLOVNrcWWAybFAxOI5DQ7gslI1OoWTGcYwLGypgt5lwzuXD5y3nQnoFPnQuKjmvhC4hFaJbubb8jFwsCbHrotmY3GuGIXwuk4zcYG3HbP6PlhTaEER/IIj9rfqYIcRQdCe94YYbsGLFCjQ2NmLChAnYtWsXVq1ahbvvvhtAqDX5mmuuweLFi1FUVIThw4dj06ZN+M1vfoNVq1YJ61mwYAGGDh0qZGZ+8pOf4PLLL8fo0aNx7tw5PPXUUzh+/DjuvfdeDXc186SiYVFaEmJPxGpKQoD4gdyT4ZKQli63jLoK8mIBpPOD5JWDAAij472BIHr6fagoVndcmC3/0HA5qKGyGF+2OdGSlYBFXhBgMhpw1ZgqvLenDZsOnhGEtmOGKNNDiCUhP3ieV/RauYMPGaxLqKvXq/i9sgVraS6zmWVv7xBJSSgY5OM6hx9LgwcLYxQzjyuQDMvhM73w+IMotZowPPzAkW0UBSyrV6/GsmXL8OCDD6KjowP19fV44IEH8PjjjwvLrFu3DkuXLsX8+fNx9uxZDB8+HCtWrMC3v/1tYZkTJ05EZGG6u7tx3333oa2tDYMGDcKUKVOwZcsWjB8/XoNdzB5adAnJ1rA4UysJTQhnWE6cdaHH5ZM1lVYLmOBWS0X/UMHttnBLQsEgL2RY5ApuAcBqMqKi2IxzLh/aHR7VAcspiYYFABoGhYW33dkoCSU2jpNy9ZhqvLenDX8/eEawyFfSIQSI53sgyKPfF0iqnZGitEuInTfeQBCOfn/GzttUEDPP8reVzU3yB3l0u7wxLRDO9nlxLjzrZ8TgNJSEqgtLw8LKQRPqyxSPlkkXiu6kdrsdzzzzDJ555pm4y9TW1uLXv/51wvVs3Lgx4vuf/exn+NnPfqZkU3IC0ZpfTUlIvtMtz/NiW7PKgKWi2IJhg4rQ0t2Pfa09mD6qStV6lCK2NGs3o6JeGIBYuBmWQx296Hb5YDMbBOM2uQyxW3HO5UOH042xtfLFpgy3LyBoDVjw2FgZ+vdEVzYzLMk1Ukx4u/vkORSFS0hKBLdAyAvJZODgD/Jw9PuVBSwKH3JsYd8lp8ePzj5PTgQsbICgkuuixWRAZYkFZ/u86HB6Yl4vWKlmaEWRcOy0hE1tPt3TD7cvAJtZ+/fQE6wBQy/lIIBmCaWV1NqaRQ1LMi2Bo98PT3gGSrVKDQsgOpJmUsfC2qg1LQmVkxfLtnA5aMrwQbCYlJ3mgheLSuEt+7vbzKGbDABBw5IN8ziXDOM4Rn1FEc6rKUWQB/5xOPQ3HK1AcAuETDDVdgqJGhb51wxWFurMEfM4NRkWILnwNh2W/FIqSywoLzKD5yGIsfOZfTpyuGVQwJImeJ5XNEI9mui0ciKY4HZQsTmlqD8bnUKCy206SkLn+rM2HynbfKKiHMRItbVZLAcVCxqFxiyKbpWWWVi3EEOJBwvDLmjQlAUsSjUsQO6ZxzkUzBGSUi2Yx8V+EElnhxAQCkTZuvO9LBQI8th3Wl8dQgAFLGmj3ye27qnRsBSZjcLQuN4kOpZUW5oZTMeSSeGtlpOaGTVlNnAc4PEHs2KEl214npcYxskX3DKqUzSPEwS3FaIz5rCwhsXp9gslgUwQCPKCz49cM7arJQFLscUotMkrQewUUtbarDS4AnKvU0jtg1wyF2ZWEhqZpoAFKJxOoWOdfXB5AygyG9PScaUWCljSBNOvGA2cKn8RjuOEi5YjScAitDSnGLCwDMuxzj5FU6JTQUtbfobFZBBEeqcL0IvlaGcfOns9sJgMmNxQofj1qdrziy3N4o2+yGIUbqyZzLIwDxYgeVsz49IRlUK77eghpaoEh8I8IaUZFo9yoX7OBSz96uwemAtzvLlJYodQ+m6wwkyhPO8UYuWg8fVlskZ6ZAoKWNIESwXLHRMfC7nCW5YirS1LLUtRVWpFXbkNPA+h/z7dsJJQlYaiW0BsbS7EIYhv7QyNtLiwoUJViVD0vEitJDQ0avYIE95mUsfCBLcmAwerTC2PzWzEtJGhUtpolTc/cWKzwgyLW3mGZbBQEsqRgMWtzOWWkciePxDkcTws6E5XSUi67nwvCQmC23r96FcACljSRg/zGlBhGscQhLdJS0KhC1WqJSFAnMiZCYt+nufTIroFgKHMPK7A7Pl/tfkYnvvoCADglouHqlpHjeB5obYkJLrcSsmGeZzUNE7Jg8M9V45EXbkNN188TNX7snNXiXmcxx+ANxAqXynTsOSW2y2z5ZfrcstIJAY/1d0PbyAIi8kw4HOnJdKSUD7r44SWZh11CAEUsKQNoUNIgdo/GtGLJfFFr00jDQsgKsL3ZqBTyNHvhz+s86nUUHQLiJ1ChdTa/JutX2H5n74AADzytdG4/dJGVetJWXQrcbmVIg5BzHyGRUnGAgCuHFOFrUtn4Mox6tr7xQyL/IBF+mBSoqAVOvdKQsoGHzJYSag9RiB9JOxw2zS4JK2eISMGl4DjQpmzfNXH8TwvNF7oSXALUMCSNlIxjWMInQYyS0KaBCwZzLB0hk3j7FYTrCZtPQ3qC8w87tVPT+Dx9fsAAN+5dhS++/XzVK+L3Rhc3oBiLZMvEBSyWtHj6Jl5XDY0LHJM47REaGtWILoVJjVbjIp0A9X2XC0JKTsmNZIMS3R2g5Vo0tXSzLCZRRF2vupYTpx1wen2w2IyKJqhlQkoYEkTqQw+ZJQyDYtM0a1a0zgpTHh7qMOJfm96J+umw5afUV9eOOZxb/zzJH7w9h4AwH1XNeE/rh+bkkV7scUkZCTak8xuiaatx40gD1iMovCZwUpCLRl0u2UlIbkdQlqhpq3ZqaKlGZBkWJy58cSv2oclHEh7/MEB2qBjwgyh9AYs0vc4lqc6FpZdP7/WDrPMGWSZQl9bk0c4VT5FSJFjzx8I8oJqviZF0S1bR1WpFUEe+LItvWUhwYNFY8EtIGZYWvO8S+j3O1rwn299DgC464oR+ME3ztdknoxQFlIovGXloPoK24DUfENYdNvS7RJa/tMNM40rSYPzaSLUiG7VtDQDYsDS7wsIJbB00d3nhcef2oOMdJaQEmxmoxAInokqC4keLOnPCLC2aVaGyjdYOUhv+hWAApa0ofYpQkqZ4HYb/ymts9eDIB9qn9bixs9xnKhjOZ3egKVT8GDRPsNSFxbdtjvd8AXkTwrPJdbvPoXFv/sMPA988/LhePxfxms2/K46QUdGIlridAgBIV2RycDBF+AVZ27UIpRZslYSUq5hKVV4Iy+2GIU27HSWhTYe6MDlzRvwby98qnodwSAvXBuVim6B+IF0pkpCofcojXjPfEPsEKKApWDQQsMiJ8PCLvzVpVbN+uUFHUtLenUs6cywVJVYYTEawPPKyxq5wLuft+K7r+9GkAfuvKwBP/7XCZpO6mWePvE8L+IhuNxWDJzuajRwQiCTKR2Li5WEMpxhUVMSEjxYFAZXHMelvVNo86FO3P/bHfD4g9h1ohtev7qHgF6vXxgqqebaGMsjqM/jF8ri6TSNYwgloTzUsPA8L5khpK+WZoAClrShScAiQ3QrtjRrd9MXMyzpDViYyr4qDRoWg4ETsiz5Zh73/t42PLJuF4I8cNuUYVhx40TNOyPUdgqdOhd2uY2RYQEy3ymUtQyLipKQU9hW5cFVOjuFth7pwr2/+acQpAR59dowlnGymgzqPIJiuDCzwKGyxKJ6urgSmBfL8a4++PMse3u6x41ulw8mA6dq8Gm6oYAlTaQy+JBhlyG61bKlmcG8WA62O1OuVyeCiW61bmlm1JXnnxfLh1+0499f24lAkMfNFw3FE7dMSksb55Akc1viEc+DhcFanTMVsKhta04VwelWQUmoT8XgQ0a6ApZtx87i7pf+CbcviOvGVgs3a7Xmf2pbmhmxSkKCw20GsisAUF9eBKvJAF+Az6iAPBOw7Mp5NXbNOze1gAKWNOHQtCQU/6KnZUszY9igIlQUm+EL8DjUnj5hWWcaS0KAKLzNF7fbjw504MFXdsIX4PGvk+vx1G2T02abLZrHqRPdRrc0M4QMS4Yu9H1eZhyX6S6h0A3Z4w/KDvp7U7hmCK3NGnYK7Th+Fnf9ehv6fQFcNaYKa/7fKULAorakp7almRGrJJTuoYfRGAziEMR8Kwvt03E5CKCAJW0I8zJSyrAw0W2CDEvYZ6S2XLuAheO4jPixsMGHVWnKsDC/hEx1Ch3u6E1bG/Wmg2fwwG93wBsIYu7EOqz6f9IXrADqSkLBIC/sf7ySEOsUynSGRU2ZJRXsVhOYpCiRBk2K2i4hQBweqlWGZdeJbix88Z/o8wZwxejBeGHBJbCZjWgYxI6fus+5WpdbhmAeJ8n8HRVamjPnGcJ0LEfSPATR7QvgizQ3P0jZIwQs+hPcAhSwpA0tjeMSlYTawzcUdoPRiglD0z+5OZ2iW0BiHpeBDEuH043Zz/wdVz35EZb8/nNhYnGqHGp34qFXdmLhi9vg9Qdx/YQaPHPHhTCl2R9B0AooKAl1OD3wBXgYDVxcT6DGDNvzC23NGS4JGQyS4aUyy0JqfVgAUQemRcDyecs5LHhxG3o9fkxtqsT/LrhU0Js0pKhBEgcfqgtYWPeaVAwuDj3MTIYFAEaG26fTnWF54s9f4hu/+Bj/+/HRtL4Pg3WGTtBhhxAAZPYsLiC00LDI6hLq0b4kBEg6hdIU3fsDQXS7Qn+jdBjHAWJrcybcbg+19wpjBtb98yR+v7MFt1/agIeuGy2MCVDC0TO9+PmGQ3jns9NCV8WtU4bh/940MSNmTtXh1LvD7YfbF5AlkGSC29oyW9yAirnddjg9stebCtkS3QKh7KrT7VeQYREHpiqlKnwj70qxS2jvqR5881fb4HT7cemIQXjxW5eiSNJhJQQsajUsbnUeLIzoUiXP82JLc4ZKQkDmhiDuPnkOAPDUXw5gxvk1aS17dTjcOOP0wMAB4+uoJFQw8DwvXChTMo5jGRavH8E4RltsroaWJSEAmBhOCe5vdaTFx4QFKxwHDEqTsn9oBjMsrJ13XK0dV46ugi/A4+VPTuCapzbiR+/sk52pONHlwvfe+AwzV23C+t2hYGX2hFq8v+gqPH3bZFhkThxOlTKbSZhuLNc8LpEHC6Oi2Cy07WqVhUqEy5udtmZAMgBRZmuz0NasKsOSeknoyzYHvvmrT9HT78PFjRX49V2XDQj0Uu3yEjMsajUsof3s9fjh8vpxxulBr8cPAwc0Dh7YSp8uhCGIaTaPY5owjz+I//z953HvA1rAukJHDymNCFL1BAUsaaDPG0BQ8BpIxTgu9FqeB1y+gcI9ty+Ac+EbP5uzoRWNlcWwW03w+oNpqdN2hecIDSq2pE2LwbqEevp9aXcAbQlfWC5qHISX752KdfdfjsuaKuH1B/HSlq9w9VMfYcW7X8S9obR0u7Dk95/jaz/diN/vbEGQB2aePwR/+vcr8fw3p2BcbWafeDiOi9lCmggWsMQT3LL1DhNueukPJLOaYVE4T0gwjlOTYQkHLGdUBiyH2p2Y/8Kn6Hb5MLmhAi/dfVnM7WAZlm6XT5HHDEMU3aq7LpZaTSgKZ+U6HB5hnk9DZXFGu1pYSajd4UnbtcXtCwilL6vJgG3HzuKVT4+n5b0A0ZJfj4ZxDApY0gB7ijAbOcGBUg1WkwGm8M081sWBPfnazAbVTyzxMBg4jK9P3+RmYY5QmgS3QChYZE+r6W5tZtkCdrO+fORgvH7/5Xjl3qm4uLECbl8QL3x8DFc/+RFWvv8lusOC49aefvzXH/bguqc3Yt0/T8If5HHNedVY/9AV+N+Fl2ZV/BarIyMRQodQnJZmRmNl5szjROO47JSEAPkZFmcKols2t8kZLuEp4XBHL+584VN09XlxwdAy/Obuy+IGFKVWk2BDoCbgTFV0GxlIezLeIcQoLzYL16506VhYZrjIbMTSOeMAhDQt6cpMMr2iHi35GRSwpAHp4MNU3Ec5jksovGXloJoym6Yupwx2s0xHp5DY0pxeoyfWKXQqzZ1Cp2JkFziOwxWjq/D770zHS3ddiknDyuHyBrBm4xFc9eRHePCVHbjmqY14+ZMT8AV4XDF6MH7/nWlYe/dlmNxQkdbtlYNSLxY5JSFA1LFkolMoW11CgFgOlpuJ6E1BdFtWZILZGLoGsO47ORzr7MO/vfAJOns9OL+uDC/fMzVpMNGQgltxqj4sgLSDzS0OPczADKFo0t0pJLUIWDBtBC4dMQh93gCWvrVnwLRqLRBamuv1qV8BKGBJC6LgNvWnukRut21pEtwyBMfbNAQs4qTm9HQIMerDwtvWNOtYEpVDOI7DtWOHhLImCy7B+Loy9Hr8eG9PG7z+IC4bUYl191+OV+69HFOGV6Z1O5WgtLX5lJBlSqwlaMhQpxDP8+jzZsc4DlBREhKs+ZXfzDmOE1qbu2SWhTz+AL792x3ocHowtsaOV+6dKsspVpy6rSJgSbEkBEgyfw5JhiWDHUKMdHuxSB8ADAYOT9wyCRaTAR8f6sTvdrRo+l5dvR6hOUHPGRbqEkoDWrQ0M0Kul/0xOw3a02AaJ4UJb79odSAQ5DXVmpxNswcLoy4Dwlt/ICg4Dg+NMUOHwXEcZo6vwdfGDcFf9rXhb192YN6FQ3HF6MFpyZClyhAF5nE8zwtPhPFcbhmZMo9z+4KClqw4K11C8kW3gSAvCITVZFgAoMpuQZvDLVt4+9xHR3Cg3YnBJRb89t7LZDtOpxJwpiq6BaSDOUUNy6gMl4SA9A9BjM7ajqouxWNfPw9P/PlLLP/TF7jmvGrhHE2VfeFu0JFVJVkJ7uVCGZY0oMVTBCNhSYgFLBp7sDCaqkpRZDbC5Q1o/hTBRLfpzrAInUJpbG1ud3oQCPIwGzlZfjgGA4c5E+vw1G2TceWYKl0GK4CyDEtXnxduXxAcJ7aTx0NqHpeO1DZDarhYnOb26Vgwwb2ctmbptqotXwmdQjLcbve3OvD/fXQYAPDjeROErIUcUukUcqbY1gyIHkGnzvULQVMmTeMYI9OcYREfAMSHoHuvbMLEoeVwuP34rz/s1ez8YR1Ces6uABSwpAUtbPkZrAWUeTRIYYMPtW5pZhgjhLfaloU60zxHiFEvDEBM39N8S/iiWV9RlJa5PtlCyLDI0LCwp8EhdmvSbg1WMur1+IUut3TATOOKLcasHBcl84RYwGIxGVR3u8jtFPIHgviP330Of5DH9RNqMHdinaL3YRokNRmWVEW3gFgS2nm8G4Egj2KLUdPhr3IRWpvP9KYl8GYlN6kmzGQ04MlbJ8Fk4PDXL9rx7p5WTd5rbw7oVwAKWNKCFqZxDEHDkiDDolVaMBYXpClgYXX2dExqlsJM21rTmGGRWwrJNZRkWJINPZRiMxuFdadTx5LNlmZAWZeQMEcohW2V68XywsfHsOdUD8psJiyfd4HiDF+joGHpV+QL4g8ERX+qFAKWGkmGBQhpSbKRpWysLIHRwKHPG1A8c0sOsYT8AHB+XRkeum40AOCH6/cJ5fVUEFqaKcNSeGipYbHLCFji2aBrgdApdFrjgKUvM6JbqXlcusoP8S4suQ4LKs72eeH1JzYPZC63yQS3jMYUHVPlkE3TOEBpSSjscpvCNUO0549/Aztyphc/+/AgAGDZv4xX9bBTV2GDgQuZmSnxfZGWvVK5NkaXr7JRDgJC2TDWMaW1jsUn0cXFsgl46LrRGFtjR1efFz/+476U3qvH5RMeHPTswQJQwJIWNM2whDsGogcg8jwvlITSmQ5lAcu+Uw5NXRYz4cMCsJbv0MVViyeRWIjZhcw5bWaCQcUWwQco2VP7KZktzYxMdAplPcOioCTkTME0jsEyLPG6hIJBHv/5u8/h9Qdx9XnVuHXKMFXvYzYahDldSnQsrFuq2GJMabxEtE4s0x4ssd5ba8fbth43gjxgMRqE4yrFYgqVhgwcsH73aWzY3676vfa1hh5GGyqLUF6c+j0rnVDAkgYErwFNMyyRFz2H24/+sEFUurqEgJBNs8VkgNPj1+xp2O0LCDeTdGdYLCaDYKp1Ok1eLKeSTCjOVQwGLqIjIxFyXG6lNGTA7TabpnGAtCQkX3SrRcASL7j8zdavsP14N0osRjTfPDGlMooaHYtWzQgVxWZYJAHPqCy0NDPS1SkU3dIci8kNFbjvqpEAgB+8vUfQByllXw443DIoYEkDznR0CUVlWJgQsrzInNYBcmajAefX2gFoN7mZZTrMRk6ToC4ZQmtzmtxuo11u8wm55nFKdTwslZ7OeULZNI0DIs/dQJLsZK8GZeQqe/yS0MmzLjz5lwMAgCVzxqWst2pUEXBqIbgFQvYA1ZIsSzZM44T3rk5Pp5AguE1ynL779fPQVFWCdocHze/tV/Ve7Lqud/0KQAFLWtDWhyW2hqVN8GBJvzp+guB4q41Ff5ekQygTYrmhaewUCgZ5IXOTb6JbQJzanCjDwvO84gxLYwZKQsw0LlslIWlJOJYtgRQtMyzdLi/8koGlPM9j6Vt74PIGcFlTJeZPHa76PRgNKsYraOHBwpAGLCOqsleKFac2a1sSkrrcJsJmNuKJmycCCE2J33yoU/F7MX0iBSwFitSaP1XiBSyifiV95SAGM5Dbp5HwtpN5sJRkphUxnZ1Cnb0eeANBGA2cMGwxn5DObYmHo98v3HDl6nhYSehUd3/S7INahAxLlkpCFpNBGNSXrFOInd+pBFeDii0wcKFhqVK91hvbT2Lz4U5YTQasvGWSJi3eDSpE01r6U7HM3xC7VZPrrFpGhUtCJ7v7kwrTlXBKQdfd1JGDsWBaKAhd8tbnioYx9nr8QnZogs5bmgEKWNKCltb87GSMLgml2+VWCqtt7j3Vo0mnjWjLn17BLYMJBE+lIcPC3Fpry2wwpSAk1CvsxnAmwcTmlnCH0OASi+yx9DVlNliMBviDfNoGU/YyDUsWnTtZNiGZvoDdZFLpEjIaOMHXiHXvtPW48d/vhkoF35t1nmYC1QYV5nFazBFisEA6m4JbIHR+lFiMCAR5TbOFcudyMf5jdqjM19Ldj8fX70O/V94AzP2tDvB8aLJ9LHGv3si/K6wOYCI7LU7MeKLbTLQ0M86rLYXJwKHb5dPEMVb0YMnMCVJfnr55QvnqwcKoEczj4mdYlF5cgdDNlS2fLuGty5tdDQsgv7VZnCOUWnAldgp5wfM8/usPe+B0+zG5oQL3XDkypXVLYaLbNocbHr+8m6OYYUk9gBwxOBSojM9yVoDjOGGOkZZlIbEkJC9jWWo1oTlcGvr9zhZc9eRHeHHzsaSTu5m/1oQcENwCFLBoTiDIixcfDTUs0TXw9gxqWKwmI86rCQtvW1IvC7F0dbpbmhn1gheL9iWhfBbcAvLM49T60Kh5SldCttuaAfnzhJwaaFiAyE6hdz47jQ/3d8Bs5PDUrZM0nQVWVWpBkdkInhePfzJ6BA1L6g9y/za1EU/fNhmPfG1MyutKFSb61Up4G5BkHZU8BFx9XjWe/beL0FBZhM5eD37ypy9wzVMf4bdbv4obVIqCW/2XgwAKWDRHK3Ok6HX0eQMRtf62DGpYAG11LJ0ZmtTMYLNt2p1u+ALa1ZkB5f4juQYz6WpP0CWkNsvEOoXSZR4ntjVnL8MiTmxOHLCwB5LSFPUYzDzuQLsTP/7jFwCAh68bIzxwaAXHceJMKJkBi0OjLiEAKLaYcOuUYRiUoYeeRIjCW20Clg6nG74AD5OBUzwn7l8m1eNv37sWzTdPRH25De0OD5at34evPb0Jr207MeD6x1qaJ+aA4BZQGLAEAgEsW7YMTU1NKCoqwqhRo7B8+fIIXUNvby8efvhhDBs2DEVFRRg/fjyef/75pOt+8803MW7cONhsNkycOBHvvfee8r3RAax0k8pMECnSmrY0GOrIoIYFECNwLSz6hcGHGbrYVJVYYTEawPOJb7xqyPeSENMKdPZ64opjxSyTsm6NdHcKZbtLCFBeEtIqw/Krj4/hbJ8X42rt+M61o1JaZzyUHj+HBoMP9YgwU0gj8zj2EFRbrk4XZzYacOdljfho8bVYPm8CasqsOHWuH0vf2oOv/XQj3tx+Ev5AEP3eAA51OAHkRocQoDBgWblyJdasWYNnn30W+/fvx8qVK/Hkk09i9erVwjKPPfYY3n//fbz88svYv38/Fi1ahIcffhjvvPNO3PVu2bIFd955J+655x7s2rULN954I2688Ubs3btX/Z5lCS1N44BQOYaZJLGLWiDICyn6TAUsQmvz6dRbmzMtujUYOCHLonVZSGznzS+XW8bgEgs4DgjyYqAZjeoMS5pLQkzIWpylLiFAfklICx8WQMxa+oM8jAYOT906GRZTehLp7DPfIjdg0bCtWU9oXRJSMpcrEVaTEd+cNgKbFl+Hx/9lPKpKrTh5th+Lf/c5vv6zv+PZjw4hyIeCXDlT5vWAok/yli1bMG/ePMydOxcjRozArbfeilmzZmHbtm0RyyxcuBDXXnstRowYgfvvvx+TJ0+OWCaan//855g9ezYWL16M888/H8uXL8fFF1+MZ599Nu5rPB4PHA5HxJce0NI0jiEYUIUval19oaddA5f+4YGM82vLYOCAM05PylkKJrrNVEkIgNByrGVHCs/zeV8SMhkNQvt5POGtGtEtIHVLTY/oti9cEko1a5EKYkkoUxkW8Xpw31UjMXFY+p6clc6D0rKtWU8w0W1nr1e126wUpYLbZNjMRtx9ZRM+/o/r8INvjENliQXHOvvw3EdHAISy59kYHqkGRQHL9OnTsWHDBhw8GBqe9dlnn2Hz5s2YM2dOxDLvvPMOTp06BZ7n8dFHH+HgwYOYNWtW3PVu3boVM2fOjPjZ9ddfj61bt8Z9TXNzM8rLy4WvhoYGJbuSNrQ0jWOURnUKsRtHVak1Y620RRYjRg8JPUmkUhbieR6dGRbdAulpbe52+YTxCPUV+efBwhBbmwcGLH0eP865Qp9LpQELu+F19npkt2EqoU8XXUKxu/yiYb9Ppa0ZgKBVGVVdgkUz0ytIVToPSkvRrZ4otZqE5gctsixqHwCSUWQx4v6rR+Hv/3EdFl8/VtASXTGqStP3SSeKzo4lS5bA4XBg3LhxMBqNCAQCWLFiBebPny8ss3r1atx///0YNmwYTCYTDAYDXnjhBVx99dVx19vW1oaampqIn9XU1KCtrS3ua5YuXYrHHntM+N7hcOgiaHF6tBt8yBDM48JPYW3h1uLaDBuVXTC0HAfbe7H3lAMzzq9J/oIY9HkDgsFSpkpCAFDPzOM0LAkx7cYQu1UTvZJeGVJmxRetITFgNCwALLOZFD85lxebYbeZ4HSH5lRpLQzt00WXEJsnFD9g4Xles7bmyQ0V+N23p2HMEHtaR3YAyu35WZZJC9Gt3mD2+EfP9OLChoqU1iVowtKkiyu1mvDQdaPxzWnDsfdUDy4bUZmW90kHih7P33jjDbzyyit49dVXsXPnTqxduxZPP/001q5dKyyzevVqfPLJJ3jnnXewY8cO/PSnP8VDDz2EDz/8UNMNt1qtKCsri/jSA+nIsESXhNrDN47oMevpRjCQS6FTiJWDii3GjGoLxNZm7TIs+V4OYojzhAZmWNQKbhmNadSx9Hn1YByXvCTU7wuA6ZlTzbAAwCUjKjMydZe1sff0+5KWQrz+oJCNzLeSEKDtEES5tvypUmYzY/qoqpwyvFR0dixevBhLlizBHXfcAQCYOHEijh8/jubmZixcuBD9/f34wQ9+gLfffhtz584FAEyaNAm7d+/G008/PaDsw6itrUV7e+R47Pb2dtTW1qrZp6wiCMs0zbBEdhq0CxmWzAqlmJJ8XwoloU7JHKFMIohuNbTnz3fBLUMwj4tREko1aGsYVIx9px2adwr5AkEhk5fNtmahJOSJf0NnDyIGDoKVfy5QYjWhqtSCzl4vTp51oTxBp4m0JKZFUKY3RlZpMwSxEHRxqaAotHK5XDAYIl9iNBoRDIYuDD6fDz6fL+EysZg2bRo2bNgQ8bMPPvgA06ZNU7J5uiAdGZYyYepr6KQX5ghlOMPCXCVP97iFTIlSsiG4BUTFvaYZljxvaWaI5nEDg72WFP8GjYOVT/2Vg3SeSna7hJJnWKSmcbkifmSwYD1Zhoy1NNutJk0N7PQCa20+kqLbbWevFx5/EBwnzkAjRBQFLDfccANWrFiBd999F1999RXefvttrFq1CjfddBMAoKysDNdccw0WL16MjRs34tixY3jppZfwm9/8RlgGABYsWIClS5cK3z/66KN4//338dOf/hRffvklfvSjH2H79u14+OGHNdrNzOHQcPAhozSqJNSWYQ8WYTusJuFJQm17c1dYcFuV6QxLWO/T0+9TNBwsEUonFOcq1YJ5XKySUGp/A2Yep3WGhZWDLEZD2tp65VBelLytuTcN14xMIbdTKF8FtwzW2vxVVx+CKQzzZA9BNXZbVj+3ekXRX2T16tW49dZb8eCDD+L888/H97//fTzwwANYvny5sMy6detw6aWXYv78+Rg/fjyeeOIJrFixAt/+9reFZU6cOIHW1lbh++nTp+PVV1/F//zP/2Dy5Mn43e9+hz/84Q+44IILNNjFzKLl4EMGE92yYEiw5c/CdGBWFlLbKSRmWDIbsNhtZuGYaNXazPQb+Z66ZeZxsbqE1NryM1inSYvGbrei4Da7JZYyiXFcvMGhWrU0ZwPmdpss4HTkecAybFARzEYObl8QrSnYPhTKNUUtis4Qu92OZ555Bs8880zcZWpra/HrX/864Xo2btw44Ge33XYbbrvtNiWbo0vSI7qNnNgsmsZl3uzngqFleOez06ot+lmGJdMlISDUKXTA7cTpc26MHpJ6R4ogjiuQktAZpwc8z0eULUSTK3U6Hql5XPS6U0EPpnGAeO4Ggjxc3kBMAbBTsOXPvYBFbqeQloMP9YjJaEBjZTGOnOnD0TO9qkukqT4A5DuUc9IY4cTU8ElCWhLy+APC8MBMTGqOhnUK7VGdYcm8BwujXnC7TT3D0tPvE240+f40VB0OWLyBoOC5AgBuXwCd4YyZ2gvs0IoicFyohMM+11qgB9M4ALCZDTAbQ0FYvLJQTmdY5GpYmAN4nmZYALFTKBXhbaHo4tRCAYvGpCXDYhU7DVhrqcVkyIqfARtDfvJsP3pcyl0dhTlCGS4JAUAdE95q0CnEnoQqSyxZf4pPN1aTERXhNllppxAL/Iot4u+VYjMbBfG43CF6ctCDaRwQGhKYTHjbq5FpXDYQS3r9CbUb+epyK2WkBkMQ02Ualy9QwKIx6bbmZ/qV2jJbVjoKyovNQhpYTVlIzLBkviSkZadQoT0JxeoUkgpuU/kspmMIoh5M4xjJ3G61Mo3LBnXlNhgNHLyBoOAPFYuePJ0jJEWLTqFTBWKVoBYKWDQmLdb8LMPi9ostzVnQrzDY5GY1ZaHODA8+lKJlSUg0TCuUgCXsxSLpFNIqaBsWFm5qaR4nmMbpIPslmMfFCVicOgqulGIyGoTjn0jHwkS3+ehyy2hKcQgiz/MF9yCkFApYNMQXCMIVvlCmo63Z6fELLc1DsqBfYVzUMAgA8PdDZxS9Lhjk0e0KtzVnQXTbWKmNVwIgMUwrkAuLmGGRBCwapa/T4XYriG6zXBICknuxsLbmXNSwAPI6hViHY16XhMIZllPn+uH2KZ+N1dPvE7JthfIgpBQKWDSEXXgArY3jzML6OyQloWxx/YSQA/EnR88qMpDr6fchEK5zDyrOfIbl/Do7OC7kJxLLBE0JmbLP1gtDBLdbaUkoNVt+hiDc1LC1uU9HQlbZJaEc1LAA8gLOfG9rBkKNBGU2E3g+5MeiFFZirSq1pH0OVK5CAYuGsHJQkdkIs4bzGdhFt98XEJxFs1kSahxcjAn1ZQgEeXzwRXvyF4RhgtvyInNWTJGKLSaMCiv5951SZ3zHEMVxhVFrjjVPSKv0NXO71VbDEnrC1YMgWhyAGDvDoqfgSg1y3G7zva0ZCAmsm1inkArhbUuBZW3VQAGLhjjSYBoHRHYPHOkIlTMy7XIbzTcm1gEA/rw3/kTtaDqz2NLMmJii8R2j0GrNzDxOmmHRyjOCZVhOn3PDH4g/wkMJYhCQ/SdVJjR1xBkQmMs+LIDESydBhizfnW4Zo1inkAodi5i1LYyHIDVQwKIh6RDcAoDZaIDNHDpUTNCV7YBlzgWhstA/DnfKbm/uyqLgljEhPA8plYnTLq9f8AwplPZDQXQb1rD4AkFBT5Xq32CI3QqLyYBAkEerRsMpWVuzHjIs9iQZllz2YQHkdXkx/U4+i24BUceiprWZhh4mhwIWDREzLNqflGxisyc8gTabGhYgZJI0tsYOf5DHB/vllYUED5YstDQzxNEC6ktC7MJit5ny/gLMkJaEeJ5HW48bQT7kB1SV4vE0GDghS6OV8FZPZRZWBklmHJerGhY2D6rd4YkrNk2HoaYeYZ1CRzuVC/sLrfNQDRSwaMiXrU4AYopUS6IvZkOyqGFhzJkYyrK8v7c1yZIh9JBhYROnT53rR7dKZ9WWAkzdss9bvy+AXo9fSP8PqyiCQYPpu6wspJWORWhr1kPAwtqa45SExC6h3LyZV5ZYUGIJld5OxbAMcPsC8IYftPJZwwJEZljizY6KR6GVmdVAAYuGfHqsCwBwWVOl5uuWBix2m0kXqW6mY/n7wc64HRBSRJfb7AVbZTYzRoRFnmrLQoUojiu2mIRsRYfTo3n6Wu7UX7noqa05WUmI+bDkqoaF4zjhIS1WwMmyKwZOH7446WTE4FDA0tPvQ7dCJ3AhYKEMS1woYNEIrz+InSe6AQCXpyFgkaa2s10OYowZUoqR1SXwBoL425cdSZdnGZaqLGZYgNTLQoU6oExaFtL6aVD08tDGnp/5IempJBQrqPf4xeyDHrZVLYJFf6yApV8slWuRjdMzRRajcE4cVeD31OvxC3O6CulBSCkUsGjEnlPn4PYFMbjEgtFDSjVfv/Rilm3BLYPjOHzjgnC30J7k3UIsYKnMYpcQIAlYVGZYCs2DhVEtsedv0Tho09o8rleY1pz9DItYEhqYYWHt10COBywJSno9BSK4ZagR3rKHoPIic1o0kPkCBSwa8cnRswBC5aB0zPiRfoj1ErAAoo7lowMdQho+Hp06EN0C4sRpta3NTBxXaE9CzDzuTBpKQkwP1KJRScilJ9FtAmt+pl8pthhhzOHsQ6MwXmFghkwU3Gb/WGSCJhWtzYV6TVEKBSwa8ekxMWBJB1INSzZN46IZX1eG4YOL4fEHsfFAYqt+vZSEWGvz8S6X4A+hhEIdUFYjsefX2jOCmcd19nqTBr7JCAZ5QXSrB60XO3e9/uCALhqnJzypWQeBVSok1LAwD5YCyRyIU5vll4QKNWurFApYNMAfCGLHV6GAZWrT4LS8hzRgqS3XT4aF4zjMDnuyvJegW8gXCArBQTZFtwAwqMQiXBi+OK1Mx+L2BQQvkkITx7FOodYetzBAUqsnwjKbWSgZsHKTWlw+fZVZSi0msKSrM0p425vjpnEMaUkvujumEOYISWFut0oyLOTBIg8KWDRg32kH+rwBlBeZMa7Wnpb3kF54mYmXXmA6lo++7Ijrw8BaiA0cUKGDWjYrC+1TqGNhxmZFZiMGFWd/PzIJ+9ztPdUDf5CHycBpWp6UY0AmB1YOMnAQDBezicHAwW6N7cUieLDoILBKBZZpc3r8A7KW4hyh3N5HubAMy/GuPmF2WjJaCjRrq5Tsn815AGtnvnREZdpU8KU6LQkBwKRh5RhaUQSXN4BNB2OXhToFwa1VF50CFwwNO94q1LFIO4TSoVXSM6xLiLkt11XYNNVdNFRqYx7HgoASi0k3x4hp0AZkWHK8pZlRZDEKouxoHQsLWApFdDu0oggWkwG+AC9bk9VCHiyyoIBFAz49yspB6dGvAJGiWz2VhIDIstCf98QuC4kut9nVrzAmhDuF9igMWARxXAGmbqPNCrW+uCbSQSjBpSPTOEY88zhhjpCOtlUtzPE2+viJgw8LI2AxGDg0DVYmvC1UqwSlUMCSIoEgj21MvzIyjQFL+ILGcUBVljUgsfhGuFtow/4OePwDy0J6cLmVwkpCRzv7FIk8C9mNsjqqFKl1+rpBo06hXh2ZxjHi2fOLc4Ry/2Yez/yPtXPnuy2/FCWtzW5fAJ29oQc6ClgSQwFLinzZ5oDT7Uep1YTxdWVpex8muq0qtcJs1N9hu6hhEGrKrHB6/PjH4c4Bv2cnZLYFt4xquxW1ZTbwPLC/Vb7wtpBrzWU2E6wm8bOnddCmmYbFq7+sRdySUJoGpmaDeBmyQmtrBqQBS/JOIfYQVGIxFkzZTC36u/PlGKwcdMmIQTClMZCYNKwCXx9fgwevHZW290gFg4HD7AnhbqEYJnJsurFeSkKAOh1LIav5OY6LKAtp/TdgpU7WhaWWXg9radZRhiV8s44uCeX6pGYpDXHM/wqtrRkQhyAek1ESapFcU/SiudIrFLCkSDrnB0mxmAx4YcEluOuKprS+TyrMCc8W+uCLdvgCwYjf6cWDRcqEeqZjkZ9hKXS/BGmHmtZ/AxbMnnP5Bnx+lKAn0zhGmS22eRzLuOhJb6MWVtKLDlh6Ckx0CygrCRWqr5MaKGBJgWCQx7Zj6fVfySUuHVGJqlILevp92HqkK+J3ehh8GA2z6Jfb2uwLBNHaE764FKCGBRA7hQBgWIW2F9hBxRah6+isyknagNSWXz9BgKBh6Y/uEgobx+VBSYiZ/5061x/Rziv4sBRSwBJubW5zuJNq5E6dI5dbuVDAkgKHz/Si2+VDkdmIScPKs705Wcdo4DArXBb6c5SJXKdO5ghJYSWhQx29cf1jpLT1uBHkAYvRoEvhcyZgviscp323msHACZ+PMymUhfTcJRQ9ADFffFiA0FBWs5GDL8CjzRHyK+J5viBLQhXFFuGznKwspPVcrnyGApYU+PRoKIswZfggXQphswEzkfvrvnb4JWl9lmHRU0motsyGqlILAkEeX7Y5ky4vHf+uBy+ZbMC8NmrLbLCYtP/Ms0CQibTV0Cf4sOhIwyKUhOI43eZBwGI0cEKWgJWF+n0B+MPZlkIS3QISi/4kAUsh6+KUQnfZFPgkzfODcpGpIysxqNiMrj6v0O4NSNqaszz4UArHcYKORY7wVhDHFXDqtjacYWlIU72dBbQsI6cGwThOR0FAUtFtHpSEgIGdQqwEZjJwKDLrJ4DMBGwI4rEkOpZCtkpQCgUsKuF5PiOGcbmG2WjArPHMRC7ULdTvDQhper34sDCUdAqRuRPw9Qk1uHXKMDwyY0xa1l+tQYaFfdb0lLVI6nSro21NBRawtIQDFqngttA6YEYKM4XitzZ7/UGhfEai2+RQwKKSo5196Oz1wGIyYHJDRbY3R1fMDpvIvb+vDcEgL5SDLCaD7i7MzEBurwzhLY2AD5U2nr5tMq4cU5WW9bOAtiuFgEWfxnGxu4TyyYcFkHQKhYN70YOlcPQrjKaq5J1CbT1u8DxgNRl0VS7XK/lxlmQB1h10UUMFbAWW6kzGFaOqYLeZcMbpwY4T3bCE9T2DSyy6e8pinUIH2pzw+oMJdRlSDQuRHkQNi/qSkB6N42KVhAJBHn06zAalApsHJZaEmOA2P/ZPCaPCrc3HOvvA83zMa5901Ifero16hDIsKmGC26kjqZ05GovJgK+PrwEAvLenVdLSrL8niGGDilBeZIYvwONge2LhrejBQqnbdKGF6FY0jtPPTZKVhPq8AUGM3ucVy0P5omFpjDKPK+QMS+PgYhi4UMYvXtcbDT1UBgUsKuB5Hp8eI/1KIuaEu4Xe39smnKx6EtwyOI6TpWMJBnmcpgxL2qkKdyGl1NYsiG71k/mUlnxYyYqVgyxGA6wm/WxrKrCSUIfTA7cvIM4RKqCWZobVZBQebo7EKQuRLk4ZFLCo4OTZfrT2uGE2cri4cVC2N0eXXDWmCiUWI1p73Pjblx0A9JlhAeTpWDqcHvgCPEwGDjV2/QVe+YIWXUJiW7N+shZmo0EYFcBu4vnWIQQAFcVmwVOmpdsliG4LMcMCiI638bxYCnk2mRooYFEBs+OfNKwCRTryetATNrMRM84PlYU+3B8KWPRqtjZhKGttjm/Rz9woa8ttaZ0ZVeiwz8jZPk+EW6oS+nRoHAeIWRZWJnHmkQcLg+M4DJO0NgsalgLzYGGMDM8UijcEkVxulUFXXhVQOUgecy4IdQuxG4+eBh9KmRgOWPa3OiLM7qSQB0tmYO6gQR4451KeZeF5Xsyw6KgkBAzsFMq3lmZGYyUzj+sXNSwFWBICgKYkGRYS8itDUcASCASwbNkyNDU1oaioCKNGjcLy5cvB8+KTEMdxMb+eeuqpuOv90Y9+NGD5cePGqd+rNJOpgYe5zrVjh0SYRenJll/K8MpilFpN8PiDcWvNlLrNDGajAYOKQzc3NWUhjz8oOKvqLcPCyiJCScidfyUhQNSxhDIshTdHSMqoBG63gSCP1nPMg4UCFjkoOlNWrlyJNWvWYO3atZgwYQK2b9+Ou+66C+Xl5XjkkUcAAK2tkTNk/vznP+Oee+7BLbfcknDdEyZMwIcffihumEmfJ/Hpc/04ebYfRgOHS0ZQwJKIIosR142rxnthAzm9loQMBg7j68uw7dhZ7DnVg7G19gHLtJB9dsaoKrWi2+VDZ68HYzHwWCSCmcYB+tKwAGJJyClkWEL/5sMcISlsCOLJsy4hi1SIbc2AmGE5cdY1wDah3eGGPxjSxUmnoBPxUfQp2rJlC+bNm4e5c+cCAEaMGIHXXnsN27ZtE5apra2NeM369etx3XXXYeTIkYk3xGQa8NpEeDweeDxiJ4HDEV9/oCXMf+WC+rK8S+Wmg9kX1AkBi15Ft0BIeLvt2FnsPdWDW6cMG/B7oaWZSkJpp6rUikMdvapam1k5yGY2CJOf9UL0PCFnAWRY2DEoL9AMS22ZDcUWI1zeAE52uzAq7H4LiA9B9RVFuvus6hVFJaHp06djw4YNOHjwIADgs88+w+bNmzFnzpyYy7e3t+Pdd9/FPffck3Tdhw4dQn19PUaOHIn58+fjxIkTCZdvbm5GeXm58NXQ0KBkV1TDykHkvyKPr40bgmKLEUYDh7py/d7sWWvzvjidQqfCBk+Uuk0/qbQ29+nQNI4RbR6XrxoWwZ6/u7/gu4Q4jovreEuCW+UoOlOWLFkCh8OBcePGwWg0IhAIYMWKFZg/f37M5deuXQu73Y6bb7454XqnTp2Kl156CWPHjkVrayt+/OMf46qrrsLevXtht8dOCS9duhSPPfaY8L3D4chI0MLmB11G5SBZlFpN+O09l8HR7xcm/eoRJrzdd9qBYJCPmMbM8zyJ4zIIE2er0bCwDIueTOMY9mjRbZ5mWFhQ3+vxw+0LlegKVXQLhCz69512hDuFaoSf05Rm5Sg6U9544w288sorePXVVzFhwgTs3r0bixYtQn19PRYuXDhg+RdffBHz58+HzZa4PifN0EyaNAlTp07F8OHD8cYbb8TNzlitVlitmb0BdjjcONrZB44DLiXBrWymDNf/32pkdSlsZgNc3gCOdvZh9BAxddvV54XbFwTHQddZonyBBbZq5gn1efTZ0gyIN21WCmIZlnzTsNjMRtSUWdHu8AgC6EJtawbEIYjRnUItZBqnGEWfosWLF2PJkiW44447AAATJ07E8ePH0dzcPCBg+fjjj3HgwAG8/vrrijeqoqIC5513Hg4fPqz4temEtTOfX1tWsDXZfMVo4DC+rgw7T5zDvtM9EQELu7DU2G0JZw0R2iCax6nXsJTo0B8puiTkFNqv8+9m3jCoGO0O8fgVcoZlZNySEFklKEXR1dflcsFgiHyJ0WhEMDjQu+JXv/oVpkyZgsmTJyveqN7eXhw5cgR1dXWKX5tOmOB26kj9ZwwI5VwgGMhF6lgodZtZUhmAqFfTOCCGD0seGscx2EwhIDSJuJAHxDK32+jWZrquKEdRwHLDDTdgxYoVePfdd/HVV1/h7bffxqpVq3DTTTdFLOdwOPDmm2/i3nvvjbmeGTNm4NlnnxW+//73v49Nmzbhq6++wpYtW3DTTTfBaDTizjvvVLFL6UMQ3FI5KC+5II7jLRPHUeo2M6QyAFGvpnGAtK05qiSUZxoWAILbLVC4glsGE9129nqEYDUY5IXBhw3k7SQbRWfK6tWrsWzZMjz44IPo6OhAfX09HnjgATz++OMRy61btw48z8cNOI4cOYLOzk7h+5aWFtx5553o6upCdXU1rrzySnzyySeorq5WsUvp4WyfFwfbQ/bKlzVRh1A+Ip0pJB0HTy63maVK0LB4I46DHFiXkN48WACJcdyADEv+3dClGZZC9WBh2G1mVNutOOP04OiZPlzYUIHOPg+8/iAMXGjcByEPRZ8ku92OZ555Bs8880zC5e6//37cf//9cX//1VdfRXy/bt06JZuRFbaFsyvn1ZTq1rGVSI0xNaWwGA1wuv04cdaF4YNDT0anyOU2o7AuIW8gCEe/H+XF8m/ofTrWhQgloTwefshokGQjCz3DAoR0LGecHhzr7MWFDRXCQ1BtmQ1mmk0mG/pLyUScH0TZlXzFbDRgXF2ojV5aFqKW5sxiMxuFzpnOPmVlIbFLSH8loTKJ0y3P83nrwwKIbrdAYQtuGaxTiAlvSb+iDgpYZCL4r5B+Ja+ZICkLASEPFioJZR5WFupUaB6n6wxLONMQ5EPZlXzWsNTYbbCEMwfUUTmwU4g6hNRBAYsMelw+7G8LPXFTh1B+MzGqU8jRL95YSHSbOcTWZmWdQnrWsFhNBuEm3uH0CFPM8zHDYjBwwvlSyB4sjOhOoRbBOZvKzEqggEUG//zqLHg+FCXTkKr8hln07z0VEt6eDF9YqkotBd2amWnUdgrp2TiO4zghm8Km9HIcUKxDzxgtYJ1CVBISO4WOdfYiGOSpJKQSClhkIM4PouxKvnNejR0mA4dulw+ne9yUus0Sg1Wax+nZOA4Qy0Knw5+rUqtJURdULjEpnK1kN+tCpqGyGCYDB7cviDaHeF2hrK0y9PcYokOYYRzpV/Ifm9mIMTV27G91YO+pHuoQyhJqzeP0bBwHiMJbdsPKN1t+Kf8+YzRmjq8RyqyFjNloQOPgYhw904ejZ/pIF6cSyrAkodfjx97TYf0KdQgVBBfUhyc3n+oRLyz0JJRR1JeE9GscB4gDEIUMSx4KbhlWkxEXNlTAaMjPDJJSmPB2x/FuuMKBdT0FLIqggCUJ2786i0CQR0NlEX24CoSJw1inkINcbrOE2oDF5dVvlxAgClBbe0IalnwU3BKxYa3NHx86AyA05JN0ccqgsyUJ5L9SeLDW5j2nejAk3F5LqdvMUm1Xp2Hp9ei3SwgQBahihoUEqYUC0/LsOnkOAF1T1KDPs1pHCAMPSb9SMJxfZ4eBA844PehxhWzUqSSUWYQMi1O+hsUfCMLtCw1i1WuGxV5AGhYiElYSYu3sdE1RDpWEEuD2BbCnJeTHQRmWwqHYYsKocPrWGwjdAOlpKLMMDgcs/b6AoEtJhssXEP6vVw0Ly7B4/KHPFZWECgdWEmJQmVk5dLYkwGY2YuvSr2HniXNoqKQPVyFxwdByHOoIDbssLzILYkkiM5RYjLCZDXD7gujq9crKmLDAxmTgBIM2vRE9VyefRbdEJFWlFtitJjiZESU9BClGn2e1jhhcasXXx9fkrVcCEZsLJK2Y9CSUeTiOE8pCZ2TqWKSmcXo9X6NdXynDUjhwHCc43gJklaAGClgIIgastRmgclC2UNoppHfTOACwWyMzLPk4R4iIj7QsRBoW5VDAQhAxGC8NWOjCkhUUByw6b2kGYpSEdLythPZIXX/pQUg5FLAQRAzsNrNwcaHUbXYQBiDK7BRiJaFiHQcB0SUhPQdXhPawktCgYjMdexVQwEIQcfjGxFpYTAZqac8SSjMszDSuVKcdQgAGiLdJdFtYXDaiEnabCdecV53tTclJ6GwhiDgsvn4cHpkxBlaTfm+A+QzLsHT1yQtY9G4aB4izhBjkw1JYDCmzYft/zdRtF5veob8aQSSAgpXsUWVXZh7n8uh78CEQCqako3Uow1J4WE1G3Xax6R0KWAiC0CVKS0K9Oh98CAAGAxchtCXRLUHIhwIWgiB0iXIfFv2XhIDITqHoNmeCIOJDAQtBELqEaVicbj/cEtv9ePR59V8SAkR7fkDf2SCC0BsUsBAEoUvKi8wwG0O1/q6+5DoWlmEp1rFxHCCaxRWZjTCR+JIgZENnC0EQuoTjOAwuCZWFumSUhcS2Zp1nWMIlIRLcEoQyKGAhCEK3VNnD5nEyAhYmutWzcRwgloSopZkglEEBC0EQukXoFJLR2uwKa1j0bBwHiG63lGEhCGVQwEIQhG5hJSE5nUK5YBwHiG63ei9dEYTeoICFIAjdoqQklAvGcYDodksBC0EogwIWgiB0S7VgHie/S0jvAcuM82twYUMFbr54WLY3hSByCn2f2QRBFDRMw5KsS4jnefR5WUlI3xqWpqoS/OGhK7K9GQSRc1CGhSAI3SLXnt/tCyLIh/6v9wwLQRDqoICFIAjdImpYEpeEmOAWCBmyEQSRf1DAQhCEbmFdQt0uL/yBYNzlXJJykMFAk3AJIh+hgIUgCN1SWWKBgQN4HjibwJ4/V0zjCIJQDwUsBEHoFqOBQ2VJ8rKQaBpHAQtB5CsUsBAEoWvkCG8F0zidu9wSBKEeRQFLIBDAsmXL0NTUhKKiIowaNQrLly8Hz/PCMhzHxfx66qmnEq77ueeew4gRI2Cz2TB16lRs27ZN3R4RBJFXyAlYmGlcsc5dbgmCUI+igGXlypVYs2YNnn32Wezfvx8rV67Ek08+idWrVwvLtLa2Rny9+OKL4DgOt9xyS9z1vv7663jsscfwwx/+EDt37sTkyZNx/fXXo6OjQ/2eEQSRF1SVJne7ZaZxVBIiiPxFUcCyZcsWzJs3D3PnzsWIESNw6623YtasWRHZkNra2oiv9evX47rrrsPIkSPjrnfVqlW47777cNddd2H8+PF4/vnnUVxcjBdffFH9nhEEkRcMluF2y0zjinVuGkcQhHoUBSzTp0/Hhg0bcPDgQQDAZ599hs2bN2POnDkxl29vb8e7776Le+65J+46vV4vduzYgZkzZ4obZTBg5syZ2Lp1a9zXeTweOByOiC+CIPIPcWIzZVgIopBRdHYvWbIEDocD48aNg9FoRCAQwIoVKzB//vyYy69duxZ2ux0333xz3HV2dnYiEAigpqYm4uc1NTX48ssv476uubkZP/7xj5VsPkEQOYhQEkrY1kwaFoLIdxRlWN544w288sorePXVV7Fz506sXbsWTz/9NNauXRtz+RdffBHz58+HzWbTZGOlLF26FD09PcLXyZMnNX8PgiCyT5U9eYaFGceVUpcQQeQtih5HFi9ejCVLluCOO+4AAEycOBHHjx9Hc3MzFi5cGLHsxx9/jAMHDuD1119PuM6qqioYjUa0t7dH/Ly9vR21tbVxX2e1WmG1WpVsPkEQOUi1grZmMo4jiPxFUYbF5XLBYIh8idFoRDA40DL7V7/6FaZMmYLJkycnXKfFYsGUKVOwYcMG4WfBYBAbNmzAtGnTlGweQRB5yOBwSairz4tgkI+5DGtrpsGHBJG/KApYbrjhBqxYsQLvvvsuvvrqK7z99ttYtWoVbrrppojlHA4H3nzzTdx7770x1zNjxgw8++yzwvePPfYYXnjhBaxduxb79+/Hd77zHfT19eGuu+5SsUsEQeQTbJ5QIMjjXL8v5jJ9VBIiiLxH0ePI6tWrsWzZMjz44IPo6OhAfX09HnjgATz++OMRy61btw48z+POO++MuZ4jR46gs7NT+P7222/HmTNn8Pjjj6OtrQ0XXngh3n///QFCXIIgCg+LyYDyIjN6+n3o7PUIVv1SWJcQiW4JIn/heKlNbQ7jcDhQXl6Onp4elJWVZXtzCILQkBk/3YgjZ/rw6n1TMX1U1YDfX/+zv+NAuxOv3DsVV4we+HuCIPSL3Ps3zRIiCEL3VCUxjyPjOILIfyhgIQhC9yRrbSbjOILIfyhgIQhC91SVJJ4n1MeM4yhgIYi8hQIWgiB0T6KJzV5/EN5AyFqhlES3BJG3UMBCEITuEUpCMTQszOUWAIqprZkg8hYKWAiC0D0sw9IVI8PS5w2VgywmA8xGuqQRRL5CZzdBELpHGIAYI8NCgluCKAwoYCEIQvewDMuZXg+iraNE0zgqBxFEPkMBC0EQuocFLF5/EE6PP+J3rEOIMiwEkd9QwEIQhO4pshhREs6gRHuxkGkcQRQGFLAQBJETxOsUYiUhmtRMEPkNBSwEQeQE8TqFWJdQCXmwEEReQwELQRA5gdgpFBWwUIaFIAoCClgIgsgJBgudQvFKQqRhIYh8hgIWgiBygnj2/KxLiDIsBJHfUMBCEEROUM1KQtFdQmQcRxAFAQUsBEHkBHEzLNTWTBAFAQUsBEHkBKytuauP2poJohChgIUgiJxgcEmckhC1NRNEQUABC0EQOQHLsPR5A+gPBykAdQkRRKFAAQtBEDmB3WqCxRS6ZEl1LC4vdQkRRCFAAQtBEDkBx3GolkxtZvSyDAuVhAgir6GAhSCInIG53XZJzOOoJEQQhQEFLARB5AzRrc3BIE8lIYIoEChgIQgiZxgcZR7n8oniWzKOI4j8hgIWgiByhugMiytcDjJwgNVElzOCyGfoDCcIImcQA5aQhqVXYhrHcVzWtosgiPRDAQtBEDkD82JhXUIuMo0jiIKBAhaCIHIGsUsoFLD0UocQQRQMFLAQBJEzVEeVhFxemiNEEIUCBSwEQeQMg8MBS0+/D15/EL0eKgkRRKFAAQtBEDlDRZEZRkNIXNvV5xG6hKgkRBD5DwUsBEHkDAYDJ5na7I3oEiIIIr+hgIUgiJxC6sXS5yGXW4IoFChgIQgip2CtzZ29HlF0a6GSEEHkOxSwEASRU1SxklAvlYQIopBQFLAEAgEsW7YMTU1NKCoqwqhRo7B8+XLwPB+x3P79+/Gv//qvKC8vR0lJCS699FKcOHEi7npfeuklcBwX8WWz2dTtEUEQeU1khoW6hAiiUFB0lq9cuRJr1qzB2rVrMWHCBGzfvh133XUXysvL8cgjjwAAjhw5giuvvBL33HMPfvzjH6OsrAz79u1LGoCUlZXhwIEDwvdks00QRCyYeVxEwEIZFoLIexSd5Vu2bMG8efMwd+5cAMCIESPw2muvYdu2bcIy/+f//B984xvfwJNPPin8bNSoUUnXzXEcamtrlWwOQRAFSPQARIDamgmiEFBUEpo+fTo2bNiAgwcPAgA+++wzbN68GXPmzAEABINBvPvuuzjvvPNw/fXXY8iQIZg6dSr+8Ic/JF13b28vhg8fjoaGBsybNw/79u1LuLzH44HD4Yj4Iggi/xECFqeXjOMIooBQFLAsWbIEd9xxB8aNGwez2YyLLroIixYtwvz58wEAHR0d6O3txRNPPIHZs2fjr3/9K2666SbcfPPN2LRpU9z1jh07Fi+++CLWr1+Pl19+GcFgENOnT0dLS0vc1zQ3N6O8vFz4amhoULIrBEHkKCxgkRrHFVOGhSDyHo6PVswmYN26dVi8eDGeeuopTJgwAbt378aiRYuwatUqLFy4EKdPn8bQoUNx55134tVXXxVe96//+q8oKSnBa6+9Jut9fD4fzj//fNx5551Yvnx5zGU8Hg88HjEl7HA40NDQgJ6eHpSVlcndJYIgcowOhxuX/d8NMHBAtd2KdocH7zx8BSYNq8j2phEEoQKHw4Hy8vKk929FedTFixcLWRYAmDhxIo4fP47m5mYsXLgQVVVVMJlMGD9+fMTrzj//fGzevFn2+7DszeHDh+MuY7VaYbValWw+QRB5QGWJBRwHBHmgwxl6aCHRLUHkP4pKQi6XCwZD5EuMRiOCwSAAwGKx4NJLL43o9gGAgwcPYvjw4bLfJxAIYM+ePairq1OyeQRBFAAmowGDikOdQiw/TBoWgsh/FJ3lN9xwA1asWIHGxkZMmDABu3btwqpVq3D33XcLyyxevBi33347rr76alx33XV4//338cc//hEbN24UllmwYAGGDh2K5uZmAMBPfvITXH755Rg9ejTOnTuHp556CsePH8e9996rzV4SBJFXVJVacLbPK3xPXUIEkf8oClhWr16NZcuW4cEHH0RHRwfq6+vxwAMP4PHHHxeWuemmm/D888+jubkZjzzyCMaOHYvf//73uPLKK4VlTpw4EZGp6e7uxn333Ye2tjYMGjQIU6ZMwZYtWwaUlgiCIICQ8PZge6/wfTFlWAgi71EkutUzckU7BEHkPv/+2i788bPTAIAisxH7l8/O8hYRBKEWufdvmiVEEETOwdxuASoHEUShQAELQRA5B/NiAahDiCAKBQpYCILIOaolAQvpVwiiMKCAhSCInKPKLpaESqkkRBAFAQUsBEHkHFQSIojCgwIWgiByjsHSgIVKQgRREFDAQhBEzjG4hLqECKLQoICFIIicw2Y2wm4LZVZIdEsQhQEFLARB5CSsU6iUNCwEURBQwEIQRE7ChLfFVBIiiIKAAhaCIHKSYYOKAER6shAEkb9QLpUgiJzke9ePxYWNFfiXSfXZ3hSCIDIABSwEQeQkQyuKsGDaiGxvBkEQGYJKQgRBEARB6B4KWAiCIAiC0D0UsBAEQRAEoXsoYCEIgiAIQvdQwEIQBEEQhO6hgIUgCIIgCN1DAQtBEARBELqHAhaCIAiCIHQPBSwEQRAEQegeClgIgiAIgtA9FLAQBEEQBKF7KGAhCIIgCEL3UMBCEARBEITuyZtpzTzPAwAcDkeWt4QgCIIgCLmw+za7j8cjbwIWp9MJAGhoaMjylhAEQRAEoRSn04ny8vK4v+f4ZCFNjhAMBnH69GnY7XZwHKfZeh0OBxoaGnDy5EmUlZVptl69QfuZXxTCfhbCPgK0n/kG7edAeJ6H0+lEfX09DIb4SpW8ybAYDAYMGzYsbesvKyvL6w8Xg/YzvyiE/SyEfQRoP/MN2s9IEmVWGCS6JQiCIAhC91DAQhAEQRCE7qGAJQlWqxU//OEPYbVas70paYX2M78ohP0shH0EaD/zDdpP9eSN6JYgCIIgiPyFMiwEQRAEQegeClgIgiAIgtA9FLAQBEEQBKF7KGAhCIIgCEL3UMBCEARBEITuoYAlCc899xxGjBgBm82GqVOnYtu2bdneJE350Y9+BI7jIr7GjRuX7c1Kmb///e+44YYbUF9fD47j8Ic//CHi9zzP4/HHH0ddXR2Kioowc+ZMHDp0KDsbq5Jk+/itb31rwLGdPXt2djY2BZqbm3HppZfCbrdjyJAhuPHGG3HgwIGIZdxuNx566CEMHjwYpaWluOWWW9De3p6lLVaOnH289tprBxzPb3/721naYnWsWbMGkyZNEtxPp02bhj//+c/C73P9ODKS7Wc+HMtYPPHEE+A4DosWLRJ+puUxpYAlAa+//joee+wx/PCHP8TOnTsxefJkXH/99ejo6Mj2pmnKhAkT0NraKnxt3rw525uUMn19fZg8eTKee+65mL9/8skn8Ytf/ALPP/88Pv30U5SUlOD666+H2+3O8JaqJ9k+AsDs2bMjju1rr72WwS3Uhk2bNuGhhx7CJ598gg8++AA+nw+zZs1CX1+fsMx3v/td/PGPf8Sbb76JTZs24fTp07j55puzuNXKkLOPAHDfffdFHM8nn3wyS1usjmHDhuGJJ57Ajh07sH37dnzta1/DvHnzsG/fPgC5fxwZyfYTyP1jGc0///lP/PKXv8SkSZMifq7pMeWJuFx22WX8Qw89JHwfCAT4+vp6vrm5OYtbpS0//OEP+cmTJ2d7M9IKAP7tt98Wvg8Gg3xtbS3/1FNPCT87d+4cb7Va+ddeey0LW5g60fvI8zy/cOFCft68eVnZnnTS0dHBA+A3bdrE83zo2JnNZv7NN98Ultm/fz8PgN+6dWu2NjMloveR53n+mmuu4R999NHsbVSaGDRoEP+///u/eXkcpbD95Pn8O5ZOp5MfM2YM/8EHH0Tsm9bHlDIscfB6vdixYwdmzpwp/MxgMGDmzJnYunVrFrdMew4dOoT6+nqMHDkS8+fPx4kTJ7K9SWnl2LFjaGtrizi25eXlmDp1at4d240bN2LIkCEYO3YsvvOd76Crqyvbm5QyPT09AIDKykoAwI4dO+Dz+SKO57hx49DY2JizxzN6HxmvvPIKqqqqcMEFF2Dp0qVwuVzZ2DxNCAQCWLduHfr6+jBt2rS8PI7AwP1k5NOxfOihhzB37tyIYwdof27mzbRmrens7EQgEEBNTU3Ez2tqavDll19maau0Z+rUqXjppZcwduxYtLa24sc//jGuuuoq7N27F3a7Pdublxba2toAIOaxZb/LB2bPno2bb74ZTU1NOHLkCH7wgx9gzpw52Lp1K4xGY7Y3TxXBYBCLFi3CFVdcgQsuuABA6HhaLBZUVFRELJurxzPWPgLAv/3bv2H48OGor6/H559/jv/8z//EgQMH8NZbb2Vxa5WzZ88eTJs2DW63G6WlpXj77bcxfvx47N69O6+OY7z9BPLnWALAunXrsHPnTvzzn/8c8Dutz00KWAqcOXPmCP+fNGkSpk6diuHDh+ONN97APffck8UtI1LljjvuEP4/ceJETJo0CaNGjcLGjRsxY8aMLG6Zeh566CHs3bs3L3RW8Yi3j/fff7/w/4kTJ6Kurg4zZszAkSNHMGrUqExvpmrGjh2L3bt3o6enB7/73e+wcOFCbNq0KdubpTnx9nP8+PF5cyxPnjyJRx99FB988AFsNlva349KQnGoqqqC0WgcoGZub29HbW1tlrYq/VRUVOC8887D4cOHs70paYMdv0I7tiNHjkRVVVXOHtuHH34Yf/rTn/DRRx9h2LBhws9ra2vh9Xpx7ty5iOVz8XjG28dYTJ06FQBy7nhaLBaMHj0aU6ZMQXNzMyZPnoyf//zneXUcgfj7GYtcPZY7duxAR0cHLr74YphMJphMJmzatAm/+MUvYDKZUFNTo+kxpYAlDhaLBVOmTMGGDRuEnwWDQWzYsCGiDplv9Pb24siRI6irq8v2pqSNpqYm1NbWRhxbh8OBTz/9NK+PbUtLC7q6unLu2PI8j4cffhhvv/02/va3v6GpqSni91OmTIHZbI44ngcOHMCJEydy5ngm28dY7N69GwBy7nhGEwwG4fF48uI4JoLtZyxy9VjOmDEDe/bswe7du4WvSy65BPPnzxf+r+kx1UYjnJ+sW7eOt1qt/EsvvcR/8cUX/P33389XVFTwbW1t2d40zfje977Hb9y4kT927Bj/j3/8g585cyZfVVXFd3R0ZHvTUsLpdPK7du3id+3axQPgV61axe/atYs/fvw4z/M8/8QTT/AVFRX8+vXr+c8//5yfN28e39TUxPf392d5y+WTaB+dTif//e9/n9+6dSt/7Ngx/sMPP+QvvvhifsyYMbzb7c72piviO9/5Dl9eXs5v3LiRb21tFb5cLpewzLe//W2+sbGR/9vf/sZv376dnzZtGj9t2rQsbrUyku3j4cOH+Z/85Cf89u3b+WPHjvHr16/nR44cyV999dVZ3nJlLFmyhN+0aRN/7Ngx/vPPP+eXLFnCcxzH//Wvf+V5PvePIyPRfubLsYxHdAeUlseUApYkrF69mm9sbOQtFgt/2WWX8Z988km2N0lTbr/9dr6uro63WCz80KFD+dtvv50/fPhwtjcrZT766CMewICvhQsX8jwfam1etmwZX1NTw1utVn7GjBn8gQMHsrvRCkm0jy6Xi581axZfXV3Nm81mfvjw4fx9992Xk8F2rH0EwP/6178Wlunv7+cffPBBftCgQXxxcTF/00038a2trdnbaIUk28cTJ07wV199NV9ZWclbrVZ+9OjR/OLFi/menp7sbrhC7r77bn748OG8xWLhq6ur+RkzZgjBCs/n/nFkJNrPfDmW8YgOWLQ8phzP87yKTBBBEARBEETGIA0LQRAEQRC6hwIWgiAIgiB0DwUsBEEQBEHoHgpYCIIgCILQPRSwEARBEASheyhgIQiCIAhC91DAQhAEQRCE7qGAhSAIgiAI3UMBC0EQBEEQuocCFoIgCIIgdA8FLARBEARB6J7/H9Q3KGFiB5I9AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -356,7 +372,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -365,7 +381,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -387,13 +403,13 @@ "y_pred = []\n", "y_true = []\n", "for i, data in enumerate(testloader):\n", - " inputs, targets = data\n", + " inputs, targets = data\n", "\n", - " outputs = my_model(inputs)\n", - " preds = torch.argmax(outputs, axis=1)\n", + " outputs = my_model(inputs)\n", + " preds = torch.argmax(outputs, axis=1)\n", "\n", - " y_pred.extend(preds.tolist())\n", - " y_true.extend(targets.tolist())" + " y_pred.extend(preds.tolist())\n", + " y_true.extend(targets.tolist())" ] }, { @@ -405,10 +421,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "precision: 87.848%\n", + "precision: 91.286%\n", "recall: 100.000%\n", - "f1: 93.531%\n", - "support: 1482\n" + "f1: 95.445%\n", + "support: 1540\n" ] }, { @@ -422,9 +438,9 @@ ], "source": [ "precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred)\n", - "print(\"precision: {:.3f}%\".format(precision[1]*100))\n", - "print(\"recall: {:.3f}%\".format(recall[1]*100))\n", - "print(\"f1: {:.3f}%\".format(f1[1]*100))\n", + "print(\"precision: {:.3f}%\".format(precision[1] * 100))\n", + "print(\"recall: {:.3f}%\".format(recall[1] * 100))\n", + "print(\"f1: {:.3f}%\".format(f1[1] * 100))\n", "print(\"support: {}\".format(support[1]))" ] }, @@ -436,7 +452,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -445,7 +461,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -517,7 +533,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpr0ektdn9\n" + "/tmp/tmpsl1rnkrg\n" ] } ], @@ -564,7 +580,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -597,7 +613,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -605,8 +621,8 @@ "output_type": "stream", "text": [ "✅ Program saved successfully!\n", - "action_id: 17da6b3d-16ff-401d-8223-f84001e87065\n", - "program_id: NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n" + "action_id: 880b4727-3763-4435-90ce-d5a66c5693f4\n", + "program_id: 5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n" ] } ], @@ -635,7 +651,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -645,7 +661,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -674,12 +690,11 @@ " Returns:\n", " Dict[str, str]: Resulting `provider_party_id` and `model_store_id`.\n", " \"\"\"\n", - " \n", + "\n", " model_secrets = nillion.Secrets(\n", " model_client.export_state_as_secrets(\"my_nn\", na.SecretRational)\n", " )\n", "\n", - "\n", " secret_bindings = nillion.ProgramBindings(program_id)\n", " secret_bindings.add_input_party(\"Party0\", party_id)\n", "\n", @@ -702,7 +717,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -710,8 +725,8 @@ "output_type": "stream", "text": [ "✅ Model params uploaded successfully!\n", - "provider_party_id: 12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n", - "model_store_id: a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n" + "provider_party_id: 12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n", + "model_store_id: d6002305-15f9-4e76-b5aa-510560f89e75\n" ] } ], @@ -736,12 +751,12 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# This information is needed by the model user\n", - "with open(\"tmp.json\", \"w\") as provider_variables_file:\n", + "with open(\"data/tmp.json\", \"w\") as provider_variables_file:\n", " provider_variables = {\n", " \"program_id\": program_id,\n", " \"model_store_id\": model_store_id,\n", @@ -752,7 +767,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ diff --git a/examples/multi_layer_perceptron/02_model_inference.ipynb b/examples/multi_layer_perceptron/02_model_inference.ipynb index 59acf1d..f9f5e38 100644 --- a/examples/multi_layer_perceptron/02_model_inference.ipynb +++ b/examples/multi_layer_perceptron/02_model_inference.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -83,7 +83,7 @@ "True" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -98,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -112,24 +112,24 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Program ID: NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main\n", - "Model Store ID: a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c\n", - "Model Provider Party ID: 12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ\n" + "Program ID: 5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n", + "Model Store ID: d6002305-15f9-4e76-b5aa-510560f89e75\n", + "Model Provider Party ID: 12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n" ] } ], "source": [ "# This information was provided by the model provider\n", - "with open(\"tmp.json\", \"r\") as provider_variables_file:\n", + "with open(\"data/tmp.json\", \"r\") as provider_variables_file:\n", " provider_variables = json.load(provider_variables_file)\n", - " \n", + "\n", "program_id = provider_variables[\"program_id\"]\n", "model_store_id = provider_variables[\"model_store_id\"]\n", "model_provider_party_id = provider_variables[\"model_provider_party_id\"]\n", @@ -155,14 +155,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "test_image = transforms.Compose(\n", " [\n", " transforms.Grayscale(),\n", - " transforms.Resize((16,16)),\n", + " transforms.Resize((16, 16)),\n", " transforms.ToTensor(),\n", " ]\n", ")(Image.open(\"data/COVID-19_Lung_CT_Scans/COVID-19/COVID-19_0001.png\"))" @@ -170,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -179,7 +179,7 @@ "(1, 1, 16, 16)" ] }, - "execution_count": 14, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -198,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -225,7 +225,9 @@ " Returns:\n", " Dict[str, str]: Resulting `model_user_party_id` and `images_store_id`.\n", " \"\"\"\n", - " secrets = nillion.Secrets(na_client.array(images, \"my_input\", nada_type=na.SecretRational))\n", + " secrets = nillion.Secrets(\n", + " na_client.array(images, \"my_input\", nada_type=na.SecretRational)\n", + " )\n", "\n", " secret_bindings = nillion.ProgramBindings(program_id)\n", " secret_bindings.add_input_party(\"Party1\", party_id)\n", @@ -242,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -250,8 +252,8 @@ "output_type": "stream", "text": [ "✅ Images uploaded successfully!\n", - "model_user_user_id: 37Qew8NyqKYEjVCeDNMohPKKj4VSMxZMxRCYV6Snm8wvs1nJxRkynyUKMrXVk8Vkz2eoKpz8BaA58nGdA1SLyJAq\n", - "images_store_id: 00ecd070-3878-4bfa-a4b8-92b11975221a\n" + "model_user_user_id: unDxCapdG2Dp7w2FwajbBWEF6wrinZp1ArKPvqeMxGt32WbkoXcZGQcSJHwDUMvKr4AG6zQnW4GGDaBcCFqtsu3\n", + "images_store_id: 3465b7fe-062e-4528-9fc3-e20bdff86008\n" ] } ], @@ -282,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -332,25 +334,25 @@ "\n", " return {\n", " \"compute_id\": compute_event.uuid,\n", - " \"output_0\": inference_result[\"my_output_0_0\"] / (2 ** na.get_log_scale()),\n", - " \"output_1\": inference_result[\"my_output_0_1\"] / (2 ** na.get_log_scale()),\n", + " \"output_0\": inference_result[\"my_output_0_0\"] / (2 ** na.get_log_scale()),\n", + " \"output_1\": inference_result[\"my_output_0_1\"] / (2 ** na.get_log_scale()),\n", " }" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'compute_id': 'e814f72b-55e8-49dd-b68c-4060516357f3',\n", - " 'output_0': -1.10308837890625,\n", - " 'output_1': 0.5345001220703125}" + "{'compute_id': '42b1bcc4-fa08-4260-aa2e-213fb9702f10',\n", + " 'output_0': -1.40350341796875,\n", + " 'output_1': 0.935302734375}" ] }, - "execution_count": 32, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -377,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -388,11 +390,13 @@ " def __init__(self) -> None:\n", " \"\"\"Model is a two layers and an activations\"\"\"\n", " super(MyNN, self).__init__()\n", - " self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1)\n", + " self.conv1 = torch.nn.Conv2d(\n", + " in_channels=1, out_channels=2, kernel_size=3, stride=4, padding=1\n", + " )\n", " self.pool = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", "\n", - " self.fc1 = torch.nn.Linear(in_features=8, out_features=2 )\n", - " \n", + " self.fc1 = torch.nn.Linear(in_features=8, out_features=2)\n", + "\n", " self.relu = torch.nn.ReLU()\n", " self.flatten = torch.nn.Flatten()\n", "\n", @@ -407,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -416,7 +420,7 @@ "" ] }, - "execution_count": 35, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -428,16 +432,16 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([0.1628, 0.8372], grad_fn=)" + "tensor([0.0880, 0.9120], grad_fn=)" ] }, - "execution_count": 42, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -448,22 +452,24 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([0.1628, 0.8372])" + "tensor([0.0880, 0.9120])" ] }, - "execution_count": 43, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "torch.softmax(torch.Tensor([result_inference[\"output_0\"], result_inference[\"output_1\"]]), dim=0)" + "torch.softmax(\n", + " torch.Tensor([result_inference[\"output_0\"], result_inference[\"output_1\"]]), dim=0\n", + ")" ] } ], diff --git a/examples/multi_layer_perceptron/helpers.py b/examples/multi_layer_perceptron/helpers.py deleted file mode 100644 index b7f714a..0000000 --- a/examples/multi_layer_perceptron/helpers.py +++ /dev/null @@ -1,74 +0,0 @@ -"""Helper functions and classes""" - -from typing import Dict -import torch -import py_nillion_client as nillion - -from torch import nn - - -class MyModel(nn.Module): - """Fully customizable model""" - - def __init__(self, model_name: str) -> None: - """Initialization - - Args: - model_name (str): Model name to be used as prefix for secret names. - """ - super().__init__() - self.model_name = model_name - self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4) - self.pool = nn.AvgPool2d(kernel_size=2, stride=2) - self.fc1 = nn.Linear(8, 2) - self.relu = nn.ReLU() - self.flatten = nn.Flatten() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """Forward pass. - - Args: - x (torch.Tensor): Input array. - - Returns: - torch.Tensor: Output array. - """ - x = self.relu(self.conv1(x)) - x = self.pool(x) - x = self.flatten(x) - x = self.fc1(x) - return x - - def export_weights_as_secrets(self, precision: int) -> Dict: - """Exports all current model weights as quantized Nillion secrets. - - Args: - precision (int): Desired precision for quantization. - - Raises: - ValueError: Raised when unexpected layer is encountered - - Returns: - Dict: Model weight secrets. - """ - weight_secrets = {} - def return_data(result: dict, name: str, array: torch.Tensor): - if len(array.shape) == 1: - result.update( - { - f"{name}_{i}": nillion.SecretInteger(round(value.item() * precision)) - if round(value.item() * precision) != 0 - else nillion.SecretInteger(round(value.item() * precision)+1) - for i, value in enumerate(array) - } - ) - return - [return_data(result, f"{name}_{i}", array[i]) for i in range(array.shape[0])] - return result - - for weight_name, weight_tensor in self.state_dict().items(): - result = {} - return_data(result, f"{self.model_name}_{weight_name}", weight_tensor) - weight_secrets.update(result) - - return weight_secrets diff --git a/examples/multi_layer_perceptron/src/my_nn.py b/examples/multi_layer_perceptron/src/my_nn.py index be277f6..4e9b730 100644 --- a/examples/multi_layer_perceptron/src/my_nn.py +++ b/examples/multi_layer_perceptron/src/my_nn.py @@ -1,4 +1,5 @@ import nada_algebra as na + from nada_ai import nn @@ -8,7 +9,9 @@ class MyNN(nn.Module): def __init__(self) -> None: """Model is a two layers and an activations""" # Input size (1, 1, 16, 16) --> Output size (1, 2) - self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4) + self.conv1 = nn.Conv2d( + in_channels=1, out_channels=2, kernel_size=3, padding=1, stride=4 + ) # Input size (1, 2) --> Output size (1, 2) self.pool = nn.AvgPool2d(kernel_size=2, stride=2) self.fc1 = nn.Linear(in_features=8, out_features=2) @@ -16,7 +19,6 @@ def __init__(self) -> None: self.relu = nn.ReLU() self.flatten = nn.Flatten() - def forward(self, x: na.NadaArray) -> na.NadaArray: """My forward pass logic""" x = self.relu(self.conv1(x)) diff --git a/examples/multi_layer_perceptron/tmp.json b/examples/multi_layer_perceptron/tmp.json deleted file mode 100644 index fe56b96..0000000 --- a/examples/multi_layer_perceptron/tmp.json +++ /dev/null @@ -1 +0,0 @@ -{"program_id": "NhjEBNWqnAVfYvsp4atCjstZPtSKnjx1nQF9Z95zw8vocEztByKoGZbyhY4Fs6F38RWJuLgFniQkzZTqN4vimXr/main", "model_store_id": "a301b88a-5bf5-43fc-b2cd-3ce3c63bab2c", "model_provider_party_id": "12D3KooWGzPps56nqg5VxtsKjfiGMBR4gPoPybjKJ5fjoNZgNqgQ"} \ No newline at end of file diff --git a/examples/neural_net/network/compute.py b/examples/neural_net/network/compute.py index f4997d8..7353e11 100644 --- a/examples/neural_net/network/compute.py +++ b/examples/neural_net/network/compute.py @@ -15,9 +15,13 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client + # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, - getUserKeyFromFile) +from nillion_python_helpers import ( + create_nillion_client, + getNodeKeyFromFile, + getUserKeyFromFile, +) # Load environment variables from a .env file load_dotenv() diff --git a/examples/time_series/network/compute.py b/examples/time_series/network/compute.py index 6f0febd..4606547 100644 --- a/examples/time_series/network/compute.py +++ b/examples/time_series/network/compute.py @@ -16,9 +16,13 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client + # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, - getUserKeyFromFile) +from nillion_python_helpers import ( + create_nillion_client, + getNodeKeyFromFile, + getUserKeyFromFile, +) # Load environment variables from a .env file load_dotenv() diff --git a/nada_ai/nada_typing.py b/nada_ai/nada_typing.py index f3133b3..e389f37 100644 --- a/nada_ai/nada_typing.py +++ b/nada_ai/nada_typing.py @@ -4,12 +4,19 @@ import nada_algebra as na import nada_dsl as dsl + # pylint:disable=no-name-in-module -from py_nillion_client import (PublicVariableInteger, - PublicVariableUnsignedInteger, SecretInteger, - SecretUnsignedInteger) -from sklearn.linear_model import (LinearRegression, LogisticRegression, - LogisticRegressionCV) +from py_nillion_client import ( + PublicVariableInteger, + PublicVariableUnsignedInteger, + SecretInteger, + SecretUnsignedInteger, +) +from sklearn.linear_model import ( + LinearRegression, + LogisticRegression, + LogisticRegressionCV, +) __all__ = ["NillionType", "LinearModel", "ShapeLike", "NadaInteger"] diff --git a/nada_ai/nn/modules/relu.py b/nada_ai/nn/modules/relu.py index ddd634d..b4e1f27 100644 --- a/nada_ai/nn/modules/relu.py +++ b/nada_ai/nn/modules/relu.py @@ -3,8 +3,14 @@ from typing import Union import nada_algebra as na -from nada_dsl import (Integer, NadaType, PublicBoolean, PublicInteger, - SecretBoolean, SecretInteger) +from nada_dsl import ( + Integer, + NadaType, + PublicBoolean, + PublicInteger, + SecretBoolean, + SecretInteger, +) from nada_ai.nn.module import Module diff --git a/tests/python-tests/test_model_client.py b/tests/python-tests/test_model_client.py index 4621c5c..73d6563 100644 --- a/tests/python-tests/test_model_client.py +++ b/tests/python-tests/test_model_client.py @@ -10,8 +10,7 @@ from sklearn.linear_model import LinearRegression, LogisticRegression from torch import nn -from nada_ai.client import (ModelClient, ProphetClient, SklearnClient, - TorchClient) +from nada_ai.client import ModelClient, ProphetClient, SklearnClient, TorchClient class TestModelClient: From 19260512ffd9879492c0bd12911ef1138b47b267 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Cabrero-Holgueras?= Date: Fri, 14 Jun 2024 13:28:25 +0000 Subject: [PATCH 3/4] fix: various small fixes --- examples/complex_model/network/compute.py | 8 ++------ examples/linear_regression/network/compute.py | 8 ++------ examples/multi_layer_perceptron/README.md | 7 ++++++- .../multi_layer_perceptron/requirements.txt | 7 ++++--- examples/neural_net/network/compute.py | 8 ++------ examples/spam_detection/README.md | 6 ++++++ examples/spam_detection/requirements.txt | 5 ++++- examples/time_series/network/compute.py | 8 ++------ nada_ai/nada_typing.py | 17 +++++------------ nada_ai/nn/modules/relu.py | 10 ++-------- tests/python-tests/test_model_client.py | 3 ++- 11 files changed, 37 insertions(+), 50 deletions(-) diff --git a/examples/complex_model/network/compute.py b/examples/complex_model/network/compute.py index fd9a743..0c4c07c 100644 --- a/examples/complex_model/network/compute.py +++ b/examples/complex_model/network/compute.py @@ -15,13 +15,9 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client - # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import ( - create_nillion_client, - getNodeKeyFromFile, - getUserKeyFromFile, -) +from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, + getUserKeyFromFile) # Load environment variables from a .env file load_dotenv() diff --git a/examples/linear_regression/network/compute.py b/examples/linear_regression/network/compute.py index cb50706..be9eda8 100644 --- a/examples/linear_regression/network/compute.py +++ b/examples/linear_regression/network/compute.py @@ -15,13 +15,9 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client - # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import ( - create_nillion_client, - getNodeKeyFromFile, - getUserKeyFromFile, -) +from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, + getUserKeyFromFile) # Load environment variables from a .env file load_dotenv() diff --git a/examples/multi_layer_perceptron/README.md b/examples/multi_layer_perceptron/README.md index 13f8b36..58f922f 100644 --- a/examples/multi_layer_perceptron/README.md +++ b/examples/multi_layer_perceptron/README.md @@ -1,3 +1,8 @@ -# Text classification +# Multi-Layer Perceptron Demo **This folder was generated using `nada init`** +To execute this tutorial, you may potentially need to install the `requirements.txt` appart from nada-ai: +```bash +pip install -r requirements.txt +``` + diff --git a/examples/multi_layer_perceptron/requirements.txt b/examples/multi_layer_perceptron/requirements.txt index 1c717c5..d856d0f 100644 --- a/examples/multi_layer_perceptron/requirements.txt +++ b/examples/multi_layer_perceptron/requirements.txt @@ -1,6 +1,7 @@ -nada-dsl==0.1.1 -py-nillion-client==0.1.1 scikit-learn~=1.4.2 pandas~=2.2.2 python-dotenv~=1.0.0 -requests~=2.31.0 \ No newline at end of file +requests~=2.31.0 +torchvision~=0.18.1 +matplotlib~=3.9.0 +pillow==10.3.0 \ No newline at end of file diff --git a/examples/neural_net/network/compute.py b/examples/neural_net/network/compute.py index 7353e11..f4997d8 100644 --- a/examples/neural_net/network/compute.py +++ b/examples/neural_net/network/compute.py @@ -15,13 +15,9 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client - # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import ( - create_nillion_client, - getNodeKeyFromFile, - getUserKeyFromFile, -) +from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, + getUserKeyFromFile) # Load environment variables from a .env file load_dotenv() diff --git a/examples/spam_detection/README.md b/examples/spam_detection/README.md index bb10405..3b8c35d 100644 --- a/examples/spam_detection/README.md +++ b/examples/spam_detection/README.md @@ -1,6 +1,12 @@ # Text classification **This folder was generated using `nada init`** + +To execute this tutorial, you may potentially need to install the `requirements.txt` appart from nada-ai: +```bash +pip install -r requirements.txt +``` + ## How to run this test: 0. Make sure all the dependencies are installed. diff --git a/examples/spam_detection/requirements.txt b/examples/spam_detection/requirements.txt index 3833648..d856d0f 100644 --- a/examples/spam_detection/requirements.txt +++ b/examples/spam_detection/requirements.txt @@ -1,4 +1,7 @@ scikit-learn~=1.4.2 pandas~=2.2.2 python-dotenv~=1.0.0 -requests~=2.31.0 \ No newline at end of file +requests~=2.31.0 +torchvision~=0.18.1 +matplotlib~=3.9.0 +pillow==10.3.0 \ No newline at end of file diff --git a/examples/time_series/network/compute.py b/examples/time_series/network/compute.py index 4606547..6f0febd 100644 --- a/examples/time_series/network/compute.py +++ b/examples/time_series/network/compute.py @@ -16,13 +16,9 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))) import nada_algebra.client as na_client - # Import helper functions for creating nillion client and getting keys -from nillion_python_helpers import ( - create_nillion_client, - getNodeKeyFromFile, - getUserKeyFromFile, -) +from nillion_python_helpers import (create_nillion_client, getNodeKeyFromFile, + getUserKeyFromFile) # Load environment variables from a .env file load_dotenv() diff --git a/nada_ai/nada_typing.py b/nada_ai/nada_typing.py index e389f37..f3133b3 100644 --- a/nada_ai/nada_typing.py +++ b/nada_ai/nada_typing.py @@ -4,19 +4,12 @@ import nada_algebra as na import nada_dsl as dsl - # pylint:disable=no-name-in-module -from py_nillion_client import ( - PublicVariableInteger, - PublicVariableUnsignedInteger, - SecretInteger, - SecretUnsignedInteger, -) -from sklearn.linear_model import ( - LinearRegression, - LogisticRegression, - LogisticRegressionCV, -) +from py_nillion_client import (PublicVariableInteger, + PublicVariableUnsignedInteger, SecretInteger, + SecretUnsignedInteger) +from sklearn.linear_model import (LinearRegression, LogisticRegression, + LogisticRegressionCV) __all__ = ["NillionType", "LinearModel", "ShapeLike", "NadaInteger"] diff --git a/nada_ai/nn/modules/relu.py b/nada_ai/nn/modules/relu.py index b4e1f27..ddd634d 100644 --- a/nada_ai/nn/modules/relu.py +++ b/nada_ai/nn/modules/relu.py @@ -3,14 +3,8 @@ from typing import Union import nada_algebra as na -from nada_dsl import ( - Integer, - NadaType, - PublicBoolean, - PublicInteger, - SecretBoolean, - SecretInteger, -) +from nada_dsl import (Integer, NadaType, PublicBoolean, PublicInteger, + SecretBoolean, SecretInteger) from nada_ai.nn.module import Module diff --git a/tests/python-tests/test_model_client.py b/tests/python-tests/test_model_client.py index 73d6563..4621c5c 100644 --- a/tests/python-tests/test_model_client.py +++ b/tests/python-tests/test_model_client.py @@ -10,7 +10,8 @@ from sklearn.linear_model import LinearRegression, LogisticRegression from torch import nn -from nada_ai.client import ModelClient, ProphetClient, SklearnClient, TorchClient +from nada_ai.client import (ModelClient, ProphetClient, SklearnClient, + TorchClient) class TestModelClient: From a36d775f19901cdf9f8194442e024ac116096cdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Cabrero-Holgueras?= Date: Mon, 17 Jun 2024 16:42:47 +0000 Subject: [PATCH 4/4] fix: various suggested fixes --- .../01_model_provider.ipynb | 197 ++++++++++-------- .../02_model_inference.ipynb | 44 ++-- examples/multi_layer_perceptron/README.md | 2 +- .../multi_layer_perceptron/requirements.txt | 5 +- examples/neural_net/network/compute.py | 2 +- examples/spam_detection/requirements.txt | 4 +- 6 files changed, 132 insertions(+), 122 deletions(-) diff --git a/examples/multi_layer_perceptron/01_model_provider.ipynb b/examples/multi_layer_perceptron/01_model_provider.ipynb index e5cd3ce..20c44a7 100644 --- a/examples/multi_layer_perceptron/01_model_provider.ipynb +++ b/examples/multi_layer_perceptron/01_model_provider.ipynb @@ -95,7 +95,20 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset URL: https://www.kaggle.com/datasets/mehradaria/covid19-lung-ct-scans\n", + "License(s): Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0)\n", + "Downloading covid19-lung-ct-scans.zip to data\n", + "... resuming from 331350016 bytes (767065127 bytes left) ...\n", + "100%|█████████████████████████████████████▉| 1.02G/1.02G [00:30<00:00, 21.3MB/s]\n", + "100%|██████████████████████████████████████| 1.02G/1.02G [00:30<00:00, 24.9MB/s]\n" + ] + } + ], "source": [ "!kaggle datasets download mehradaria/covid19-lung-ct-scans -p data --unzip" ] @@ -206,95 +219,95 @@ "output_type": "stream", "text": [ "Starting epoch 1...\n", - "Loss after mini-batch 100: 0.506\n", - "Accuracy after mini-batch 100: 87.312\n", - "Loss after mini-batch 200: 0.489\n", + "Loss after mini-batch 100: 0.541\n", + "Accuracy after mini-batch 100: 88.938\n", + "Loss after mini-batch 200: 0.516\n", "Accuracy after mini-batch 200: 87.812\n", - "Loss after mini-batch 300: 0.459\n", - "Accuracy after mini-batch 300: 89.875\n", - "Loss after mini-batch 400: 0.463\n", - "Accuracy after mini-batch 400: 87.688\n", + "Loss after mini-batch 300: 0.487\n", + "Accuracy after mini-batch 300: 89.500\n", + "Loss after mini-batch 400: 0.471\n", + "Accuracy after mini-batch 400: 88.375\n", "Starting epoch 2...\n", - "Loss after mini-batch 100: 0.433\n", - "Accuracy after mini-batch 100: 88.875\n", - "Loss after mini-batch 200: 0.424\n", - "Accuracy after mini-batch 200: 88.500\n", - "Loss after mini-batch 300: 0.418\n", - "Accuracy after mini-batch 300: 87.875\n", - "Loss after mini-batch 400: 0.411\n", - "Accuracy after mini-batch 400: 87.500\n", + "Loss after mini-batch 100: 0.442\n", + "Accuracy after mini-batch 100: 88.688\n", + "Loss after mini-batch 200: 0.441\n", + "Accuracy after mini-batch 200: 87.562\n", + "Loss after mini-batch 300: 0.404\n", + "Accuracy after mini-batch 300: 89.375\n", + "Loss after mini-batch 400: 0.403\n", + "Accuracy after mini-batch 400: 88.938\n", "Starting epoch 3...\n", - "Loss after mini-batch 100: 0.384\n", - "Accuracy after mini-batch 100: 88.938\n", - "Loss after mini-batch 200: 0.373\n", + "Loss after mini-batch 100: 0.381\n", + "Accuracy after mini-batch 100: 89.500\n", + "Loss after mini-batch 200: 0.383\n", "Accuracy after mini-batch 200: 88.938\n", - "Loss after mini-batch 300: 0.382\n", - "Accuracy after mini-batch 300: 87.875\n", - "Loss after mini-batch 400: 0.386\n", - "Accuracy after mini-batch 400: 87.250\n", + "Loss after mini-batch 300: 0.380\n", + "Accuracy after mini-batch 300: 87.812\n", + "Loss after mini-batch 400: 0.376\n", + "Accuracy after mini-batch 400: 88.312\n", "Starting epoch 4...\n", - "Loss after mini-batch 100: 0.365\n", - "Accuracy after mini-batch 100: 88.250\n", - "Loss after mini-batch 200: 0.369\n", - "Accuracy after mini-batch 200: 88.188\n", + "Loss after mini-batch 100: 0.369\n", + "Accuracy after mini-batch 100: 88.562\n", + "Loss after mini-batch 200: 0.352\n", + "Accuracy after mini-batch 200: 89.312\n", "Loss after mini-batch 300: 0.363\n", - "Accuracy after mini-batch 300: 88.250\n", - "Loss after mini-batch 400: 0.354\n", - "Accuracy after mini-batch 400: 88.375\n", + "Accuracy after mini-batch 300: 88.375\n", + "Loss after mini-batch 400: 0.372\n", + "Accuracy after mini-batch 400: 88.062\n", "Starting epoch 5...\n", - "Loss after mini-batch 100: 0.345\n", - "Accuracy after mini-batch 100: 88.875\n", - "Loss after mini-batch 200: 0.369\n", - "Accuracy after mini-batch 200: 87.625\n", - "Loss after mini-batch 300: 0.353\n", - "Accuracy after mini-batch 300: 88.625\n", - "Loss after mini-batch 400: 0.365\n", - "Accuracy after mini-batch 400: 87.688\n", + "Loss after mini-batch 100: 0.340\n", + "Accuracy after mini-batch 100: 89.625\n", + "Loss after mini-batch 200: 0.362\n", + "Accuracy after mini-batch 200: 88.438\n", + "Loss after mini-batch 300: 0.365\n", + "Accuracy after mini-batch 300: 88.312\n", + "Loss after mini-batch 400: 0.369\n", + "Accuracy after mini-batch 400: 87.938\n", "Starting epoch 6...\n", - "Loss after mini-batch 100: 0.386\n", - "Accuracy after mini-batch 100: 86.312\n", - "Loss after mini-batch 200: 0.348\n", - "Accuracy after mini-batch 200: 88.812\n", - "Loss after mini-batch 300: 0.353\n", - "Accuracy after mini-batch 300: 88.375\n", - "Loss after mini-batch 400: 0.340\n", - "Accuracy after mini-batch 400: 89.125\n", + "Loss after mini-batch 100: 0.354\n", + "Accuracy after mini-batch 100: 88.688\n", + "Loss after mini-batch 200: 0.366\n", + "Accuracy after mini-batch 200: 88.312\n", + "Loss after mini-batch 300: 0.342\n", + "Accuracy after mini-batch 300: 89.562\n", + "Loss after mini-batch 400: 0.365\n", + "Accuracy after mini-batch 400: 87.812\n", "Starting epoch 7...\n", - "Loss after mini-batch 100: 0.378\n", - "Accuracy after mini-batch 100: 87.125\n", - "Loss after mini-batch 200: 0.337\n", - "Accuracy after mini-batch 200: 89.375\n", - "Loss after mini-batch 300: 0.353\n", - "Accuracy after mini-batch 300: 88.000\n", - "Loss after mini-batch 400: 0.356\n", - "Accuracy after mini-batch 400: 88.188\n", + "Loss after mini-batch 100: 0.373\n", + "Accuracy after mini-batch 100: 87.812\n", + "Loss after mini-batch 200: 0.348\n", + "Accuracy after mini-batch 200: 88.938\n", + "Loss after mini-batch 300: 0.338\n", + "Accuracy after mini-batch 300: 89.438\n", + "Loss after mini-batch 400: 0.350\n", + "Accuracy after mini-batch 400: 89.062\n", "Starting epoch 8...\n", - "Loss after mini-batch 100: 0.349\n", - "Accuracy after mini-batch 100: 88.312\n", - "Loss after mini-batch 200: 0.370\n", - "Accuracy after mini-batch 200: 87.375\n", - "Loss after mini-batch 300: 0.333\n", - "Accuracy after mini-batch 300: 89.312\n", - "Loss after mini-batch 400: 0.364\n", - "Accuracy after mini-batch 400: 88.062\n", + "Loss after mini-batch 100: 0.352\n", + "Accuracy after mini-batch 100: 88.938\n", + "Loss after mini-batch 200: 0.354\n", + "Accuracy after mini-batch 200: 88.438\n", + "Loss after mini-batch 300: 0.341\n", + "Accuracy after mini-batch 300: 89.500\n", + "Loss after mini-batch 400: 0.373\n", + "Accuracy after mini-batch 400: 87.812\n", "Starting epoch 9...\n", - "Loss after mini-batch 100: 0.340\n", - "Accuracy after mini-batch 100: 88.875\n", - "Loss after mini-batch 200: 0.346\n", - "Accuracy after mini-batch 200: 88.875\n", - "Loss after mini-batch 300: 0.356\n", - "Accuracy after mini-batch 300: 88.062\n", - "Loss after mini-batch 400: 0.375\n", - "Accuracy after mini-batch 400: 87.250\n", - "Starting epoch 10...\n", - "Loss after mini-batch 100: 0.355\n", - "Accuracy after mini-batch 100: 88.250\n", - "Loss after mini-batch 200: 0.358\n", + "Loss after mini-batch 100: 0.358\n", + "Accuracy after mini-batch 100: 88.438\n", + "Loss after mini-batch 200: 0.367\n", "Accuracy after mini-batch 200: 88.062\n", - "Loss after mini-batch 300: 0.358\n", - "Accuracy after mini-batch 300: 88.000\n", - "Loss after mini-batch 400: 0.346\n", - "Accuracy after mini-batch 400: 88.625\n" + "Loss after mini-batch 300: 0.360\n", + "Accuracy after mini-batch 300: 88.625\n", + "Loss after mini-batch 400: 0.340\n", + "Accuracy after mini-batch 400: 89.062\n", + "Starting epoch 10...\n", + "Loss after mini-batch 100: 0.351\n", + "Accuracy after mini-batch 100: 88.812\n", + "Loss after mini-batch 200: 0.347\n", + "Accuracy after mini-batch 200: 88.875\n", + "Loss after mini-batch 300: 0.370\n", + "Accuracy after mini-batch 300: 87.938\n", + "Loss after mini-batch 400: 0.342\n", + "Accuracy after mini-batch 400: 89.250\n" ] } ], @@ -342,7 +355,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -351,7 +364,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,7 +385,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -381,7 +394,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -421,10 +434,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "precision: 91.286%\n", + "precision: 89.389%\n", "recall: 100.000%\n", - "f1: 95.445%\n", - "support: 1540\n" + "f1: 94.397%\n", + "support: 1508\n" ] }, { @@ -452,7 +465,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -461,7 +474,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -533,7 +546,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpsl1rnkrg\n" + "/tmp/tmpqbvm6we8\n" ] } ], @@ -621,8 +634,8 @@ "output_type": "stream", "text": [ "✅ Program saved successfully!\n", - "action_id: 880b4727-3763-4435-90ce-d5a66c5693f4\n", - "program_id: 5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n" + "action_id: bbdc0628-2272-4405-a63a-7ddf1c238e48\n", + "program_id: 3tkrMbd2fQYTX2MSK31drWKepcmYYbE1MKEQUGRrkdAP9kPCaiVMYaMWUd5xkeeZjaxYFq3bKd1Rhki77oqGVQTR/main\n" ] } ], @@ -725,8 +738,8 @@ "output_type": "stream", "text": [ "✅ Model params uploaded successfully!\n", - "provider_party_id: 12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n", - "model_store_id: d6002305-15f9-4e76-b5aa-510560f89e75\n" + "provider_party_id: 12D3KooWAcTbAaa6LGoCvgB1BPSedAME2ynaEwPLnLYusBDjmSzM\n", + "model_store_id: 4b2b1ebb-b3d5-4811-a980-ac858fd6c0cd\n" ] } ], diff --git a/examples/multi_layer_perceptron/02_model_inference.ipynb b/examples/multi_layer_perceptron/02_model_inference.ipynb index f9f5e38..f4d6c8e 100644 --- a/examples/multi_layer_perceptron/02_model_inference.ipynb +++ b/examples/multi_layer_perceptron/02_model_inference.ipynb @@ -119,9 +119,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Program ID: 5GnDBJ4brQtS7U3YsUdweoKUfbN7t9CNDaZ7AnVLarwWcRNfQUwr1Ct2aTQsMhhvjb1xeYPfiKAahMz7i5D85ZUd/main\n", - "Model Store ID: d6002305-15f9-4e76-b5aa-510560f89e75\n", - "Model Provider Party ID: 12D3KooWQLbKxRFoa3rcA8do1R2o96yhgxGnJS5RbTr3ZJwQiQay\n" + "Program ID: 3tkrMbd2fQYTX2MSK31drWKepcmYYbE1MKEQUGRrkdAP9kPCaiVMYaMWUd5xkeeZjaxYFq3bKd1Rhki77oqGVQTR/main\n", + "Model Store ID: 4b2b1ebb-b3d5-4811-a980-ac858fd6c0cd\n", + "Model Provider Party ID: 12D3KooWAcTbAaa6LGoCvgB1BPSedAME2ynaEwPLnLYusBDjmSzM\n" ] } ], @@ -252,8 +252,8 @@ "output_type": "stream", "text": [ "✅ Images uploaded successfully!\n", - "model_user_user_id: unDxCapdG2Dp7w2FwajbBWEF6wrinZp1ArKPvqeMxGt32WbkoXcZGQcSJHwDUMvKr4AG6zQnW4GGDaBcCFqtsu3\n", - "images_store_id: 3465b7fe-062e-4528-9fc3-e20bdff86008\n" + "model_user_user_id: 22K41jnxYNoDDck5ZPgZyAG6Lv52G7xjVHVnfvLovYGCMFUsBB7yYRCaeebnDFh9qEW8ki7a7hbjSnNwBUWNkdmv\n", + "images_store_id: e057d84b-cea0-4a63-8946-bef676759739\n" ] } ], @@ -284,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -334,25 +334,25 @@ "\n", " return {\n", " \"compute_id\": compute_event.uuid,\n", - " \"output_0\": inference_result[\"my_output_0_0\"] / (2 ** na.get_log_scale()),\n", - " \"output_1\": inference_result[\"my_output_0_1\"] / (2 ** na.get_log_scale()),\n", + " \"output_0\": na_client.float_from_rational(inference_result[\"my_output_0_0\"]),\n", + " \"output_1\": na_client.float_from_rational(inference_result[\"my_output_0_1\"]),\n", " }" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'compute_id': '42b1bcc4-fa08-4260-aa2e-213fb9702f10',\n", - " 'output_0': -1.40350341796875,\n", - " 'output_1': 0.935302734375}" + "{'compute_id': '67557c31-d7db-4cd3-bb77-e1029011cea7',\n", + " 'output_0': -1.665313720703125,\n", + " 'output_1': 0.876068115234375}" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -379,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -411,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -420,7 +420,7 @@ "" ] }, - "execution_count": 13, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -432,16 +432,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([0.0880, 0.9120], grad_fn=)" + "tensor([0.0730, 0.9270], grad_fn=)" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -452,16 +452,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([0.0880, 0.9120])" + "tensor([0.0730, 0.9270])" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } diff --git a/examples/multi_layer_perceptron/README.md b/examples/multi_layer_perceptron/README.md index 58f922f..5dfe1f8 100644 --- a/examples/multi_layer_perceptron/README.md +++ b/examples/multi_layer_perceptron/README.md @@ -1,7 +1,7 @@ # Multi-Layer Perceptron Demo **This folder was generated using `nada init`** -To execute this tutorial, you may potentially need to install the `requirements.txt` appart from nada-ai: +To execute this tutorial, you may potentially need to install the `requirements.txt` apart from nada-ai: ```bash pip install -r requirements.txt ``` diff --git a/examples/multi_layer_perceptron/requirements.txt b/examples/multi_layer_perceptron/requirements.txt index d856d0f..b82219d 100644 --- a/examples/multi_layer_perceptron/requirements.txt +++ b/examples/multi_layer_perceptron/requirements.txt @@ -1,7 +1,6 @@ -scikit-learn~=1.4.2 pandas~=2.2.2 python-dotenv~=1.0.0 -requests~=2.31.0 torchvision~=0.18.1 matplotlib~=3.9.0 -pillow==10.3.0 \ No newline at end of file +pillow==10.3.0 +kaggle==1.6.14 \ No newline at end of file diff --git a/examples/neural_net/network/compute.py b/examples/neural_net/network/compute.py index f4997d8..2a558e0 100644 --- a/examples/neural_net/network/compute.py +++ b/examples/neural_net/network/compute.py @@ -116,7 +116,7 @@ def __init__(self) -> None: self.linear_1 = torch.nn.Linear(4, 2) self.relu = torch.nn.ReLU() - def forward(self, x: np.ndarray) -> np.ndarray: + def forward(self, x: torch.tensor) -> torch.tensor: """My forward pass logic""" x = self.linear_0(x) x = self.relu(x) diff --git a/examples/spam_detection/requirements.txt b/examples/spam_detection/requirements.txt index d856d0f..a2efa38 100644 --- a/examples/spam_detection/requirements.txt +++ b/examples/spam_detection/requirements.txt @@ -2,6 +2,4 @@ scikit-learn~=1.4.2 pandas~=2.2.2 python-dotenv~=1.0.0 requests~=2.31.0 -torchvision~=0.18.1 -matplotlib~=3.9.0 -pillow==10.3.0 \ No newline at end of file +matplotlib~=3.9.0 \ No newline at end of file