GIT_MERGE.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovaMzV0M2e6T"
      },
      "source": [
        "# 2023 \n",
        "## Di Marzo Gabriele\n",
        "## Git-merge, weight matching for interpolate mlp "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZIfh4ct23w-M"
      },
      "source": [
        "Empirical evidence shows that merging N models just with the average of each returns a model with a useless result. A second strategy is averaging the output of each model, but this means that we need to keep in memory all the N models and make them run in parallel. \n",
        "\n",
        "[Entezari et al. (2021)](https://arxiv.org/abs/2110.06296) conjecture that if permutation invariance is taken into account, then all SGD solutions for a sufficiently wide network trained on the same task become linearly mode connected, i.e., have\n",
        "no barrier between them. \n",
        "\n",
        "Simply put: we can train models with the same architecture (even on different datasets), permute the weight matrices, interpolate the weight of each matrix, and get a model with the same performance.\n",
        "\n",
        "<h3> Some useful definition :</h3>\n",
        "\n",
        "<b>barrier</b>: The loss barrier $B(\\Theta_A, \\Theta_B)$ along the linear path between $\\Theta_A$ and $\\Theta_A$ is defined as the highest\n",
        "difference between the loss occurred when linearly connecting two points $\\Theta_A$, $\\Theta_B$ and linear interpolation of the\n",
        "loss values in each of them \n",
        "\n",
        "<b>LinearModelConnectivity (LMC)</b>: We say that two networks $\\Theta_A$ and $\\Theta_B$ are lineary mode connected if the barrier between them along a linear path is $≈$ 0 \n",
        "\n",
        "\n",
        "<h2><b>Main problem, how permute the model for get this property?</b></h2>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EJoNcZu6531D"
      },
      "source": [
        "\n",
        "# This notebook: \n",
        "The method that this notebook implements comes from \n",
        "[Ainsworth 2022](https://arxiv.org/abs/2209.04836) where some algorithms that allows linear interpolation between models with the same architecture is presented. All the work done is based on the conjecture of Entezari about permutation invariance. \n",
        "\n",
        "The paper present 3 method:\n",
        "- activation matching\n",
        "- weight matchin\n",
        "- straight-through estimator\n",
        "\n",
        "\n",
        "Although the last method shows better results (as loss), it's also the most power-consuming, and considering that the difference between the last and the first method is not so huge, the authors agree that the second is the best option for a fast merging. For these reasons, the notebook that i present shows a possible implementation of the weight matching procedure.\n",
        "\\\n",
        "\\\n",
        "Thanks to these methods, it's possible to think about a system made of several small models and merge the contributions of each network, without increasing the loss of the model. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NnndbPH2sdO0"
      },
      "source": [
        "### fine tuning : better exploration of loss landscape\n",
        "Just as note, the question that the paper tries to address is why the SGD solution works well in some problems but is less robust in other optimization settings. Keep reading the paper, i didn't find a answer to this question. Indeed it seems that the paper is more focused on explaining the different merging procedures. \n",
        "\n",
        "Reading online (Twitter, with the huge community of NN students) it turns out that the permuted weights are linearly connected to the other network if the learning rate is sufficiently <font color=\"red\"><b>high</b></font>\n",
        "and you use <font color=\"red\"><b>SGD</b></font>, or the learning rate is sufficiently <font color=\"blue\"><b>low</b></font> and you use the <font color=\"blue\"><b>Adam optimizer</b></font>.\n",
        "\\\n",
        "In my experiment i keep using the default learning rate, also because I discovered these details after a few attempts. In any case, the merging procedure still works.\n",
        "\n",
        "A reference for this particular details: [Stanislav Fort github](https://github.com/stanislavfort/dissect-git-re-basin), see latest update of the readme "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7VaYL9GN3w7Y"
      },
      "source": [
        "# Import lib\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CqXULkJHSXkj",
        "outputId": "46852d88-3222-48af-af81-f98bca1f9a16"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wtphyxhw33FY"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "from torch.nn import functional as F\n",
        "from torch import optim\n",
        "from torch.utils.data import DataLoader\n",
        "from torch import autocast\n",
        "from torch.cuda.amp import GradScaler \n",
        "\n",
        "from torchvision import datasets\n",
        "from torchvision import transforms\n",
        "from torchvision.transforms import ToTensor, Normalize\n",
        "\n",
        "\n",
        "import copy\n",
        "import pickle\n",
        "import random\n",
        "import tqdm\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from scipy.optimize import linear_sum_assignment\n",
        "from collections import defaultdict\n",
        "from google.colab import files\n",
        "from itertools import chain\n",
        "from IPython.display import clear_output\n",
        "\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "torch.manual_seed(42)\n",
        "np.random.seed(42)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# insert path of the folder where there is the dir *models*\n",
        "\n",
        "path = 'TODO'"
      ],
      "metadata": {
        "id": "LZFUcb148T9F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Xbwbv6S2e83"
      },
      "source": [
        "# Dataset and Dataloader\n",
        "For testing the algorithm, I chose to use 3 well known datasets: the Mnist dataset, the FashionMnist dataset and the cifar10 dataset. All the dataset comes from torch vision."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GX7eLPzV6pgM"
      },
      "outputs": [],
      "source": [
        "%%capture \n",
        "training_data = datasets.MNIST(\n",
        "    root=\"data\",\n",
        "    train=True,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "test_data = datasets.MNIST(\n",
        "    root=\"data\",\n",
        "    train=False,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "training_data_F = datasets.FashionMNIST(\n",
        "    root=\"data\",\n",
        "    train=True,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "test_data_F = datasets.FashionMNIST(\n",
        "    root=\"data\",\n",
        "    train=False,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "training_data_CIFAR = datasets.CIFAR10(\n",
        "    root='data', \n",
        "    train=True, \n",
        "    download=True, \n",
        "    transform=transforms.Compose([\n",
        "        ToTensor(),\n",
        "        Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
        "    )\n",
        ")\n",
        "\n",
        "test_data_CIFAR = datasets.CIFAR10(\n",
        "    root='data', \n",
        "    train=False, \n",
        "    download=True, \n",
        "    transform=transforms.Compose([\n",
        "        ToTensor(),\n",
        "        Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
        "    )\n",
        ")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RSx4OuyY62qi"
      },
      "outputs": [],
      "source": [
        "experiment_data = {}\n",
        "experiment_data['MNIST'] = {'train':training_data, 'test': test_data}\n",
        "experiment_data['FMNIST'] = {'train':training_data_F, 'test': test_data_F}\n",
        "experiment_data['CIFAR10'] = {'train': training_data_CIFAR, 'test': training_data_CIFAR}\n",
        "\n",
        "data_loaders = {\n",
        "    'mnist':{\n",
        "        'train': DataLoader(experiment_data['MNIST']['train'], batch_size=124, shuffle=True),\n",
        "        'test' : DataLoader(experiment_data['MNIST']['test'], batch_size=124)\n",
        "    },\n",
        "    'fashion':{\n",
        "        'train': DataLoader(experiment_data['FMNIST']['train'], batch_size=124, shuffle=True), \n",
        "        'test' : DataLoader(experiment_data['FMNIST']['test'], batch_size=124)\n",
        "    }, \n",
        "    'cifar':{\n",
        "        'train': DataLoader(experiment_data['CIFAR10']['train'], batch_size=124, shuffle=True),\n",
        "        'test' : DataLoader(experiment_data['CIFAR10']['test'], batch_size=124)\n",
        "    }\n",
        "}\n",
        "\n",
        "mnist_input_size = 28*28    # W * H\n",
        "cifar_input_size = 3*32*32  # Channels * W * H"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "LHd19f007uOi",
        "outputId": "eb91694d-e6f8-4136-8240-236ca5bb7c6f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "MNIST || label: 4, number of sample in the dataset: 60000\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "img, lab = experiment_data['MNIST']['train'][20]\n",
        "img = np.array(img, dtype='float').reshape(28, 28)\n",
        "plt.imshow(img, cmap='gray')\n",
        "print(f\"MNIST || label: {lab}, number of sample in the dataset: {len(experiment_data['MNIST']['train'])}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "wqsKHfWmdsjl",
        "outputId": "2274a682-0c52-4b7e-81e3-660eca87a539"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "F_MNIST|| label: T-shirt/top, number of sample in the dataset: 60000\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "fashion_mnist_label_mapping = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
        "                               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
        "\n",
        "img, lab = experiment_data['FMNIST']['train'][34]\n",
        "img = np.array(img, dtype='float').reshape(28, 28)\n",
        "plt.imshow(img, cmap='gray')\n",
        "print(f\"F_MNIST|| label: {fashion_mnist_label_mapping[lab]}, number of sample in the dataset: {len(experiment_data['MNIST']['train'])}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "aciJa70beDix",
        "outputId": "76b84b14-7276-4bfe-f255-c5f57a75d2a8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "CIFAR || label: car, number of sample in the dataset: 60000\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAe3klEQVR4nO2dW4xc15We/3Xq0lXd1Rc2m03xJjYvIi1KHksaRnIyzsCxM47GMCAbCAz7wdCDMRwEYyAGJg+CA8QOkAdPENvwQ+KAjoXRDBxfMrZhIeO5OMoAziADWZQs6zqSKYq0eG02m32ve608VClDCfvf3WJ3V9Pe/wc0unqv3ufss89Z51Ttv9Za5u4QQvz6k231AIQQ/UHOLkQiyNmFSAQ5uxCJIGcXIhHk7EIkQn49nc3sQQBfBZAD8N/c/YvRneUyH8iH7y8W31GwudPhsmFMUrSM783A+7HdxdRLj22vw/sZOWYAyOf4PbqQz/GNEqqNJrWViwVqGyjyy6dabwTbzfjYs4it025RW+yQ2amOzW8Ws0WuHXadAoheJFnGjjtyYZF9zS3VsVxrBY037exmlgPwnwH8DoDzAJ4ys8fd/SXWZyCf4a7bRoK2Qo5PVDsXPpv1WviCAoBaPXIBl/kFXMi4By42w2Nstdq0T7vNbct1bsvnitQ2OT5MbTu3VYLtnnGPePH1C9R2bGontR26fZLaXj7zRrA9lxukfQZLZWpbmb9KbTsq/NjK+bDD5Av8GiiV+NwPDvJ+sZtV7M5eGSyFu0RucFYIu+5/+XPqfut6G38/gNPufsbdGwC+DeChdWxPCLGJrMfZ9wC48fZ9vtcmhLgFWddn9rVgZicAnACAYuSzphBic1mP910AsO+Gv/f22t6Cu5909+Pufjwf+VwuhNhc1uPsTwG4w8wOmFkRwCcAPL4xwxJCbDQ3/Tbe3Vtm9hkAf4Wu9Paou78Y62OWoTAQXnmMPfRb7fCK6lKNr2bPzlWpbRx8tXWswle6L81cCbZvG+V9hsrh4wUAdz5GdPixDea40mD1+fA4KnwV/P33TlHbbaMD1FbJ16ht9PBEsH1lfoX22T7GV7qnHriX2iYiYyyTuTLnq+PlyDkrFPjKf6POV8/rDa4cGbn4B8pcnWiT4f/p/36N9lnXZ3Z3/xGAH61nG0KI/qAVMyESQc4uRCLI2YVIBDm7EIkgZxciETb9G3Q30u50MLtE5JqIFNIkgSZjo+GgDwDIRb6tl3W4dLVzlMtylSwsse2eGOX7avF9ZRmXwyrDXIYar3DbtpGwXFOIRK9tGx2itsmRSFBIRIZaIUE+V2YXaZ/Rkcg4xvm+SBwJACBnYWMsQKkTCVppRgKsLBKFOVTm8+jkWm20+b4azfAYPeJHerILkQhydiESQc4uRCLI2YVIBDm7EInQ19X4YjGP/SSVUQa+irg0H17B3bctssJ8x23UViKpigBgz3a+Qr5v54Fg+2REFVghYweAjvN7bUxNKBgPuGBBHLXI6jOMz/3gQOR5EMm5VvTwuSlHAo2yHD8vjRoPGnKSLgwAcgWyVB85rFaTz1WjzvuxgBYAyBk/thZZ4a83+XlukuCwWF5GPdmFSAQ5uxCJIGcXIhHk7EIkgpxdiESQswuRCH2V3oZKRTxwbHfQNnNtlvYrToZzjP2TO7m8dnRqF7WNDfOghFKeyx25XNhWjlQXuXqJSyGzs8vUthjJr7fc4GNskCo5y00+jitLPC9c5pFKPR3+rFiqh/c3s8AltB1DPNjlzj1j1FbM88u4VAzPleW43NhucVurFStRFSk5FqsaRE5nI9KnSSQ2SW9CCDm7EKkgZxciEeTsQiSCnF2IRJCzC5EI65LezOwsgEUAbQAtdz8e3VnmmCyF5YRaJOJpkuRjO7SL537bUeEyTi7j0lXmEbmjFs6fV1vioVBzizyP2AqRpwDg0gIvrfTTs1ymbHTCx91k9YIAzMzz8bP8fwBgkWdFixza4gqf+3fdxqMHD0zwaMQcOWYAaDvZH1dL0Y7IV61I9GDk0kFEwUSdTFY9En3XdCK98aFviM7+z9x9ZgO2I4TYRPQ2XohEWK+zO4C/NrOnzezERgxICLE5rPdt/Pvc/YKZTQL4sZn9vbv/5MZ/6N0ETgDAtgovrSuE2FzW9WR39wu939MAfgDg/sD/nHT34+5+vFKOrIoIITaVm3Z2Mxsys+E3XwP4EIAXNmpgQoiNZT1v43cC+IF1kw7mAfx3d//LWAdzwEhpnWIkwWKJRJXVa1wyuj7Hx1EsxBID8n4dUnKnEYmSWiJlkABgOVJmaG45HL0GAK+eX6K2+Vb4lA4W+PwOZNxWy4fLSQEAnEtetXY4uq3R5udsu/PyT8UZLtktVvh8YDQ8/rzxY27Hyj+1+AUSUb3QjuhyNXL9RBNOsqg3IskB63B2dz8D4D03218I0V8kvQmRCHJ2IRJBzi5EIsjZhUgEObsQidDXhJMd76BeDUsvkfJryBGZZKXKI8pykTpk5RI/7CxSk6tRD0sh7QaXydokUg4AIiXbYJFkjk1+2Gi3w8fdyfPtzTb5GOsLXCrrgEtvQ41wEsvf/c1/RPscO3yE2ubeeJ7amg1eT6/YCUfLdSJyaSxCsBWV3iLRcpFwtCpJIFqPjZFsz5VwUgghZxciEeTsQiSCnF2IRJCzC5EIfV2NhwNOVjrz4KucGbknNSKr0tU6X8mERWzgtlqDrExHBtJs8OOq1njI7+wyXyHvtCI59MgY25E8bR6bj4g6MZLxy+cjew8F2x+Y4ivuf7VwndpGd+6ktv1tfmytRvjY2pGch5HFeERiU9DpxMo1Ra4rEmAVW41nplgOOj3ZhUgEObsQiSBnFyIR5OxCJIKcXYhEkLMLkQh9ld7cgXY7rA2Yc5mBBS1UazwAJVaLpxPZVxYJZmjUiEQSGcaFOT6OFy7yAI5XLvIkel7kudr2bSf5+iIBHMVyidqGC1wCvLfBnxVH9oWlsp9efJn2eT3jqcbvL91GbftISTEAWCKbvL7MS2i1IxJavDQUtzVjNlL+KdaHyYOxPHh6sguRCHJ2IRJBzi5EIsjZhUgEObsQiSBnFyIRVpXezOxRAB8BMO3ud/faxgF8B8AUgLMAPu7uPGSpR6PVxtmZsNw0li/SfmNDYSlkKZLfrUXKIAGrRRPxsKYGia5aqvKoq1cXwjnQAOC8c6kpK/L5GC1wgaXs4ai3ZiRSbqDG7/nvbvB93V3i4//Li+eC7afaXKcs336M2ubbPELwsvMSVSu58LlutXmfeiQirtXhEma7xfP1tdq8RFWN5A2sRyRiFt7mkfJPa3my/zGAB9/W9giAJ9z9DgBP9P4WQtzCrOrsvXrrb/8GwkMAHuu9fgzARzd4XEKIDeZmP7PvdPdLvdeX0a3oKoS4hVn3Ap13PyTQDwpmdsLMTpnZqWqTfw1RCLG53KyzXzGzXQDQ+z3N/tHdT7r7cXc/Xi7whSwhxOZys87+OICHe68fBvDDjRmOEGKzWIv09i0A7wcwYWbnAXwewBcBfNfMPg3gHICPr2Vn1UYLL70+E95Png/l9uvhqKxCjssxlQqXVuZmuUo4WOYRZYdv3xXel/Ox7+aBbdg+Hy6RBAADLS7VDEWSaY41w5+o8pHyT5bjCTN3R66Q11b4GF/ujAbbG16hfUpX+HE98coL1Haqs0xtO/eHl5OOTITHBwDNMr92xsbHqc3Ov0JtpcY8tbWa4XPTjEhvLTAJk0tvqzq7u3+SmD64Wl8hxK2DvkEnRCLI2YVIBDm7EIkgZxciEeTsQiRCXxNONlqOs3PhyKBym3+7bvpKWFrJlbjMcHiCS2gTziPK7tl3J7WNz4Wj7JoXXqd9ttX4GAebPEqqyVVFNAZ4JF2rHJ7H3c7ltYFIAbOr9Sq11Vp8kO8b2hZsHx7mkXLtOfrdLLx07Ty13TvFv619yMLzMXTlUrAdAOY9Uhcvd5naqtf4NqvG5cHiaFgGXIx4Z9PCY1TCSSGEnF2IVJCzC5EIcnYhEkHOLkQiyNmFSIS+Sm+tTgfTi+FonXdt51JZgQgKh8tcxnlvJJnjnuExajty1xFq61z8ZbD98jkuXV2J1GU7VeDTf73AI68q+/dSm8+Exzi4wiW0/AKX5a5HpMMC+DZ3W1iimizzfS1OhyMiAaDVWqC2g7P8mTU6czXYnm/zcXjk2qnnudzY7kRkykhkoZPruzbEIwQvkPpwjUh+GD3ZhUgEObsQiSBnFyIR5OxCJIKcXYhE6OtqfMeBBim9NF3leeH++XB4VfKfGh/+gRa/jxUWeFBC67lnqK0+Eg5Amb9rP+3zaikcEAIAz81GVsGX56jtoUjgx9Hl8Dy2r/IAjuUOL8lUjDwPqjyOB/PL4WXhVjmiXMzxFfd2hy8zX2rwRH+XySXinUgQUocHSmXDXCWB83msRRIrz7fD+elemebz8TOSv3ApclL0ZBciEeTsQiSCnF2IRJCzC5EIcnYhEkHOLkQirKX806MAPgJg2t3v7rV9AcDvAXgzyuBz7v6jteywTSrajLd48IG1w1LI9QIPSrg2xPO0FUj+LgA4akZtKwcPhg3DfBp3kMAfAJiohoNWAOCIcYnnyKtnqK1w/lywPRLPgrFBHnCRH+FzlS2Fc/IBwNJMWE6anuclo0gVJABAMXKpLhE5FwC94AqR51w7sr2lxiy11cD7NXN8HgcmwvOfy3EJcKAS3p7N8HOylif7HwN4MND+FXe/p/ezJkcXQmwdqzq7u/8EAL+dCSF+JVjPZ/bPmNlzZvaomfGviQkhbglu1tm/BuAQgHsAXALwJfaPZnbCzE6Z2amb3JcQYgO4KWd39yvu3nb3DoCvA7g/8r8n3f24ux+/2UEKIdbPTTm7me264c+PAXhhY4YjhNgs1iK9fQvA+wFMmNl5AJ8H8H4zuwfdajNnAfz+WneYI/LEntER2md4NCxNjEyO0z5vTHDbngKXNPbu5ssP5ePHgu3VKzyi7FA+HJ0EAPt5KjwMXuda2cqrvBTSQi0c9VQZ5FLk+RUuGZ2p8bxqpQF++ewl+8uKfO7zkZxrQ3kuzRZbPJKuvRKOcGws88jHeqQsV5VpxwCWcly2bTZ5v8sz4ejHRSKvAUCbTX1EYl3V2d39k4Hmb6zWTwhxa6Fv0AmRCHJ2IRJBzi5EIsjZhUgEObsQidDXhJMGIIewPDGe51FeU5WJYPvANZ6QbyISXbUjz5MX1la4RFVfDkts1RqPNGoNcn0tf3Ga2q5e4rb5BX7cg7lSsP3pJS4B/vBaOEINAC4Zl8oGF/g8fmgoXPbq3ZGIw8YCP2eD4+HjAoAC2RcAVIkcNtPg8tpypDTUSoe7TDNybO0cj9A8OxiWnV9c4ElHryyEz1mrxc+JnuxCJIKcXYhEkLMLkQhydiESQc4uRCLI2YVIhL5KbwCQEemtcte7aJ9t/+IDYUNE8sIT/5eaXnry/1DbKxe51NQpzISHUeeyVkbq1AGAtbn806ryaLNBcHllkcg/f7HAx3hp+z5q23ngMLVdPfsatT1z+WKwfTISoebOj2s+kswx48FmWK6H97dc5ddOvc3HWI9EtlnElpW4pLt8IFwrMLvE+2Rz4ag9i80TtQghfq2QswuRCHJ2IRJBzi5EIsjZhUiEvq/Gd/Lh+8t8ZEl1cXs4mKSyZw/tc+2l16ntxUW+0p3V+IrwAMKrtIsFHjhRW+Ir7mPg/QYjycTG8/y0TTfDq7SXR3hOvp1TfMX9tp27qK00zPPCXa+GAzXmSE44ABiOlPOqtSLJ1SKr8RkJDBoa5IFXpciK9kqHn7Nmm5f6WowE3tSa4W2OVniAzzTzl0glLD3ZhUgEObsQiSBnFyIR5OxCJIKcXYhEkLMLkQhrKf+0D8CfANiJbnGZk+7+VTMbB/AdAFPoloD6uLtfj20rM0O5EN7l8089TftdvHYt2L5nz220T/WVM9S2mHF9IheRwzwLB09YiedHa7a4nDRDJBcAGI9Ib6UGz3V2mty+B3ZxCa0yxAMuZiKlrSb276a27GBYzmue+QXtUx7n8mB5PJyHEADKI8PU1sjC87g8x/PuNUkJLQDIlnmevNYszxk32+SSbgFEwqzwoKziePicNWf5NbWWJ3sLwB+6+zEA7wXwB2Z2DMAjAJ5w9zsAPNH7Wwhxi7Kqs7v7JXd/pvd6EcDLAPYAeAjAY71/ewzARzdrkEKI9fOOPrOb2RSAewE8CWCnu1/qmS6j+zZfCHGLsuavy5pZBcD3AHzW3RfM/uHreu7uZhb8cGRmJwCc6L5e32CFEDfPmp7sZlZA19G/6e7f7zVfMbNdPfsuAMGqBu5+0t2Pu/txlqVGCLH5rOrs1n2EfwPAy+7+5RtMjwN4uPf6YQA/3PjhCSE2irW8jf8tAJ8C8LyZPdtr+xyALwL4rpl9GsA5AB9fbUNZPo/yRFheadZ43q+X/u6pYPvz8Z1R075BLtUMDfBIrtPz4bJL7UgZpJEOj/I6OsRluQEiGQFAtcbfIc0UwvfvUiTKa9v2iOR1aBu1DY3x0lY5Un6rfT2cxw8AJt99jNrakQiwZiSiLFsOR6LVi1yiamdc8qpURqntWqRU1uVrXJUukYi+/AiXdPcfPRhsP/2zl2ifVZ3d3f8WPIjwg6v1F0LcGugbdEIkgpxdiESQswuRCHJ2IRJBzi5EIvQ14WRWLKCyb2/QdltEtqgMXQi2X1ngUUaNBi/vs2P3dmqrN7gEWJsPyydDGY9CmxzlktGOSS5rlZbCMh8ALEUi86okWq4dSfRYr3Pp6sjRI9R2fWGR2pok82FplB9zrsDlwVabH3OjxUtbXVkJS28XnEc+jh4Jy1oA4EV+nb6ywOW1Mys8Wm5i7mqwfc/OKdpncl+4ZNe5F0/TPnqyC5EIcnYhEkHOLkQiyNmFSAQ5uxCJIGcXIhH6Kr3lB8vYce/dQdv2XCS53kQl2J79kicvrESSOR6tjFBboc0j2I5sDyf520Yi+QBgZIhHSS3Ocqmmmo/Uvsu4VNZYCEs8w6M8Qm3bBE/mOFjiUYCx8Rdy4fFfHOHbu3DpHN/XIpf5yoP82nltNixhXq5yafZIZIwjZS6lXo88O7PxHdTWLoUlx3aRR701yuFj9iwyBmoRQvxaIWcXIhHk7EIkgpxdiESQswuRCH1djc8NDGD04P6gbTyS2+v2O8J9Tv+MrzCfe/FVajt1nQdO7B7hq617dk0G20uR/GiW50Ey1uKBH5bnwToohoM7AKC5HF5lHhzh85uP5KerV6vUlnW44rG0HA68+bsnf077LFYjpbcKfMV974Hw9QEAw7ffGWy/Y5Kvjh+4fQ+1TW7jgTy7738ftc0u8EAkZwKQR/LkLYeDwLJI7kU92YVIBDm7EIkgZxciEeTsQiSCnF2IRJCzC5EIq0pvZrYPwJ+gW5LZAZx096+a2RcA/B6ANxNofc7dfxTdWb6AsR27grbRMS5pHKyEAxMadR7M8PTfc+ntGsn5BQBnm/PUtm05LNkNFXgZp9EBXsapFJGumg3e7+oy79eysNQ3N8eDVs5dOM/3NTtLbVMHpqjt4nw4cGUhFw5qAoDtv3EHte246yi1Hb7v3dR2+9G7gu1jO3jwT77I5dJWk19z+UhOxPI8l97QCmtvtXk+93MXfhlszyJS71p09haAP3T3Z8xsGMDTZvbjnu0r7v6f1rANIcQWs5Zab5cAXOq9XjSzlwHwbx0IIW5J3tFndjObAnAvgCd7TZ8xs+fM7FEz4+/DhRBbzpqd3cwqAL4H4LPuvgDgawAOAbgH3Sf/l0i/E2Z2ysxO1SIJCIQQm8uanN3MCug6+jfd/fsA4O5X3L3t7h0AXwdwf6ivu5909+Pufrw0zOuiCyE2l1Wd3cwMwDcAvOzuX76h/cZl9Y8BeGHjhyeE2CjWshr/WwA+BeB5M3u21/Y5AJ80s3vQlePOAvj9VbeUZciTHF7NyH3n8uUrwfblJf6xoFji+bvyGZfKGks8yusNFi3X5jJZTJZrNXn0Wr0ayTPHd4esHM6Tt3B1mvY5dISXeCoN8Xdj56ZnqK18OLzND370o3wc77mH2nZPTVHbtnEe0ceug2YjUk6qxuW1GonmA4A8rygFb/Lru7MSvuayPI/0aw6Gz3MWyUG3ltX4vwUQyh4Y1dSFELcW+gadEIkgZxciEeTsQiSCnF2IRJCzC5EI/U04mc9hhMkkXAnBdD2saTQnp2ifox/kCRvHDvAyQ1df49Fy7fPhfnUS4QUAszGdzLm00snz+7AjovEQSWk+Er12+lw4ggoADt7NI8q27eeJHh/4zfuC7ZOHD9E+sS9d5YtcwkSHl+xqN8MSZt5btE8usr1cpDxYFrFVI9usNsJSX6HDr52dg+ESZoWMR73pyS5EIsjZhUgEObsQiSBnFyIR5OxCJIKcXYhE6Kv0lgEYYmpCKRzFAwC1kXBNt2aHRyBt2ztObSN791LboQeOU9vKfDhp4+I1LmvV5pe4LVJHDRaKPepSLHLJrkgkquGRsFQDALunDlDbwWPHqG3qznfxcYyG9+eR4zKPyJQRtTESdAi0wh29waW35YUFalu4xiP96pGEkyvL/Fw3akQebPCahMVGeHvd9BJh9GQXIhHk7EIkgpxdiESQswuRCHJ2IRJBzi5EIvRVeus0mli8EE4eWYskgfSB8D1pfJzLSU5qngGA57jNMj4lndungu1ZLNIoIjUVIskoSyShIAAMRGTKAdJvoBSulwcA4yN8e8UBLvMhMo91EuWVI1IYAGRtbuuQemgA0GzwxJ1VUqtgZYHX9FuZ4xJak9T7AwBE5DWLJEdtEVunHpPrwpJup80lRT3ZhUgEObsQiSBnFyIR5OxCJIKcXYhEWHU13sxKAH4CYKD3/3/m7p83swMAvg1gO4CnAXzK3fmyKIBWp41rS+Egg8ESzz9mFh7m3MJV2megVKa2oVFeXdpy/P6XIznBChlfcc/yfIqLBW7LR4I7LLL63CCr1k1SYggA6is8WAeRwIpinq/Gs1xo+RZPNphFAmEakXJYy4t8/NXF8Kp7I1LGqbXCV9y9zufeI/2qKzy4plULjyUfC2rpkHFE5nAtT/Y6gA+4+3vQLc/8oJm9F8AfAfiKux8GcB3Ap9ewLSHEFrGqs3uXN2+dhd6PA/gAgD/rtT8GgFfsE0JsOWutz57rVXCdBvBjAK8BmHP///l4zwPYszlDFEJsBGtydndvu/s9APYCuB8Az1rwNszshJmdMrNT9SX+OUkIsbm8o9V4d58D8DcA/jGAMfuHlbO9AC6QPifd/bi7Hx+ohGuzCyE2n1Wd3cx2mNlY73UZwO8AeBldp/+XvX97GMAPN2uQQoj1s5ZAmF0AHjOzHLo3h++6+/80s5cAfNvM/gOAnwH4xmobarfbmCNSSLHN7zs7KjuD7aU8DyRZjJRkmlsKvgkBAGSxwA+isHlEeotJeYVIsE6e7QyAZ3ybbRLIU4hIkbnIOLgFyCIljTpEHix0eKCGRaSmVpP3a0XksBaRFdvVcMklAFiOBMLkItJWPRIIA+f7GxsOn5tORKZsNMO2TqQE1arO7u7PAbg30H4G3c/vQohfAfQNOiESQc4uRCLI2YVIBDm7EIkgZxciEcxjJXc2emdmVwGc6/05AYDX0ukfGsdb0Tjeyq/aOPa7+46Qoa/O/pYdm51yd15YTePQODSODR2H3sYLkQhydiESYSud/eQW7vtGNI63onG8lV+bcWzZZ3YhRH/R23ghEmFLnN3MHjSzV8zstJk9shVj6I3jrJk9b2bPmtmpPu73UTObNrMXbmgbN7Mfm9kver95VszNHccXzOxCb06eNbMP92Ec+8zsb8zsJTN70cz+da+9r3MSGUdf58TMSmb2UzP7eW8c/77XfsDMnuz5zXfMLBKiGcDd+/qDbtTkawAOAigC+DmAY/0eR28sZwFMbMF+fxvAfQBeuKHtPwJ4pPf6EQB/tEXj+AKAf9Pn+dgF4L7e62EArwI41u85iYyjr3OCbjB1pfe6AOBJAO8F8F0An+i1/1cA/+qdbHcrnuz3Azjt7me8m3r62wAe2oJxbBnu/hMAs29rfgjdxJ1AnxJ4knH0HXe/5O7P9F4vopscZQ/6PCeRcfQV77LhSV63wtn3AHjjhr+3MlmlA/hrM3vazE5s0RjeZKe7X+q9vgwgnLGjP3zGzJ7rvc3f9I8TN2JmU+jmT3gSWzgnbxsH0Oc52Ywkr6kv0L3P3e8D8LsA/sDMfnurBwR07+zo3oi2gq8BOIRujYBLAL7Urx2bWQXA9wB81t3fUlWhn3MSGEff58TXkeSVsRXOfgHAvhv+pskqNxt3v9D7PQ3gB9jazDtXzGwXAPR+T2/FINz9Su9C6wD4Ovo0J2ZWQNfBvunu3+81931OQuPYqjnp7fsdJ3llbIWzPwXgjt7KYhHAJwA83u9BmNmQmQ2/+RrAhwC8EO+1qTyObuJOYAsTeL7pXD0+hj7MiZkZujkMX3b3L99g6uucsHH0e042Lclrv1YY37ba+GF0VzpfA/Bvt2gMB9FVAn4O4MV+jgPAt9B9O9hE97PXp9GtmfcEgF8A+F8AxrdoHH8K4HkAz6HrbLv6MI73ofsW/TkAz/Z+PtzvOYmMo69zAuA30E3i+hy6N5Z/d8M1+1MApwH8DwAD72S7+gadEImQ+gKdEMkgZxciEeTsQiSCnF2IRJCzC5EIcnYhEkHOLkQiyNmFSIT/BwLapvhuyqeGAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "cifar_label_mapping = ('plane', 'car', 'bird', 'cat',\n",
        "                       'deer', 'dog', 'frog', 'horse',\n",
        "                       'ship', 'truck')\n",
        "\n",
        "img, lab = experiment_data['CIFAR10']['train'][45]\n",
        "img = img / 2 + 0.5\n",
        "img = np.transpose(img.numpy(), (1,2,0))\n",
        "plt.imshow(img)\n",
        "print(f\"CIFAR || label: {cifar_label_mapping[lab]}, number of sample in the dataset: {len(experiment_data['MNIST']['train'])}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jtNo5HyD2e_a"
      },
      "source": [
        "# Models definition & utility \n",
        "Model classes, utility for dict of parameters, train etc.\n",
        "\n",
        "The models that i choose are 3, pretty similar, the only difference between them is the number of parameters for layer and the number of layers. \n",
        "\\\n",
        "[Entezari (2.2)](https://arxiv.org/pdf/2110.06296.pdf#subsection.2.2) explains that different architectures responde in a different way to the permutation conjecture. This behaviour will be evaluate in the [experiements part](#scrollTo=CxLWE5El9rZM&line=1&uniqifier=1)\n",
        "of this notebook."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JCaKs45f6-0I"
      },
      "outputs": [],
      "source": [
        "class SNet(nn.Module): \n",
        "\n",
        "  def __init__(self, input_size, bias=True): \n",
        "    super(SNet, self).__init__()\n",
        "    self.dense1 = torch.nn.Linear(input_size, 50, bias=bias)\n",
        "    self.dense2 = torch.nn.Linear(50, 40, bias=bias)\n",
        "    self.dense3 = torch.nn.Linear(40, 30, bias=bias)\n",
        "    self.dense4 = torch.nn.Linear(30, 10, bias=bias)\n",
        "\n",
        "  def forward(self, x): \n",
        "    x = torch.flatten(x, start_dim=1)\n",
        "    x = torch.nn.functional.relu(self.dense1(x))\n",
        "    x = torch.nn.functional.relu(self.dense2(x))\n",
        "    x = torch.nn.functional.relu(self.dense3(x))\n",
        "    return self.dense4(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9GyzclSS7Ct5"
      },
      "outputs": [],
      "source": [
        "class MNet(nn.Module): \n",
        "  def __init__(self, input_size, bias=True): \n",
        "    super(MNet, self).__init__()\n",
        "    self.dense1 = torch.nn.Linear(input_size, 512, bias=bias)\n",
        "    self.dense2 = torch.nn.Linear(512, 512, bias=bias)\n",
        "    self.dense3 = torch.nn.Linear(512, 512, bias=bias)\n",
        "    self.dense4 = torch.nn.Linear(512, 10, bias=bias)\n",
        "\n",
        "  def forward(self, x): \n",
        "    x = torch.flatten(x, start_dim=1)\n",
        "    x = torch.nn.functional.relu(self.dense1(x))\n",
        "    x = torch.nn.functional.relu(self.dense2(x))\n",
        "    x = torch.nn.functional.relu(self.dense3(x))\n",
        "    return self.dense4(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pJ1FEfLz9--J"
      },
      "outputs": [],
      "source": [
        "class DNet(nn.Module): \n",
        "  def __init__(self, input_size, bias=True): \n",
        "    super(DNet, self).__init__()\n",
        "    self.dense1 = torch.nn.Linear(input_size,256, bias=bias)\n",
        "    self.dense2 = torch.nn.Linear(256, 256, bias=bias)\n",
        "    self.dense3 = torch.nn.Linear(256, 128, bias=bias)\n",
        "    self.dense4 = torch.nn.Linear(128, 128, bias=bias)\n",
        "    self.dense5 = torch.nn.Linear(128, 128, bias=bias)\n",
        "    self.dense6 = torch.nn.Linear(128, 64, bias=bias)\n",
        "    self.dense7 = torch.nn.Linear(64, 32, bias=bias)\n",
        "    self.dense8 = torch.nn.Linear(32, 10, bias=bias)\n",
        "\n",
        "  def forward(self, x): \n",
        "    x = torch.flatten(x, start_dim=1)\n",
        "    x = torch.nn.functional.relu(self.dense1(x))\n",
        "    x = torch.nn.functional.relu(self.dense2(x))\n",
        "    x = torch.nn.functional.relu(self.dense3(x))\n",
        "    x = torch.nn.functional.relu(self.dense4(x))\n",
        "    x = torch.nn.functional.relu(self.dense5(x))\n",
        "    x = torch.nn.functional.relu(self.dense6(x))\n",
        "    x = torch.nn.functional.relu(self.dense7(x))\n",
        "    return torch.nn.functional.relu(self.dense8(x))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TCkYGhAYUmGb"
      },
      "source": [
        "<h3>Small note:</h3>\n",
        "\n",
        "The training procedure uses the AutonomusMixedPrecision, a technique that I'd like to test for training. It's not relevant to the scope of the permutation selection, but should increase the velocity of training."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5L-nFj6KnM6l"
      },
      "outputs": [],
      "source": [
        "#@title train utility\n",
        "def train_loop(data_loader, model,\n",
        "               loss_fn, optimizer, \n",
        "               scaler,\n",
        "               print_score=True, return_loss=False): \n",
        "\n",
        "  size = len(data_loader.dataset)\n",
        "  losses = []\n",
        "  for batch, (x, y) in enumerate(data_loader):\n",
        "    optimizer.zero_grad()\n",
        "    x, y = x.to(device), y.to(device)\n",
        "    with autocast(device_type='cuda', dtype=torch.float16):\n",
        "      pred = model(x)\n",
        "      loss = loss_fn(pred, y)\n",
        "\n",
        "    \n",
        "    scaler.scale(loss).backward()\n",
        "    scaler.step(optimizer)\n",
        "    scaler.update()\n",
        "    \n",
        "    losses.append(loss.item())\n",
        "\n",
        "  if print_score: \n",
        "    print('\\tEpoch loss: ', sum(losses)/len(losses) )\n",
        "  if return_loss: \n",
        "    return sum(losses)/len(losses)\n",
        "\n",
        "\n",
        "def test_loop(data_loader_dict, model, loss_fn, device, test_set=True, print_score=True): \n",
        "  set_ = 'test' if test_set else 'train'\n",
        "  data_loader = data_loader_dict[set_]\n",
        "  size = len(data_loader.dataset)\n",
        "  num_batches = len(data_loader)\n",
        "  test_loss, correct = 0, 0\n",
        "\n",
        "  with torch.no_grad():\n",
        "      for X, y in data_loader:\n",
        "          X, y = X.to(device), y.to(device)\n",
        "          pred = model(X)\n",
        "          test_loss += loss_fn(pred, y).item()\n",
        "          correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
        "  test_loss /= num_batches\n",
        "  correct /= size\n",
        "  if not print_score: \n",
        "    return 100*correct, test_loss\n",
        "  \n",
        "  print(f\"Eval on {set_}: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")\n",
        "   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3y_edQUb7Fhi"
      },
      "outputs": [],
      "source": [
        "#@title detach & retach\n",
        "'''function for convert raw dict of parameters (numpy) to torch parameters and vice-versa'''\n",
        "\n",
        "def detach_parameters(params): \n",
        "  return {k: v.cpu().detach().numpy() for k, v in params.items()}\n",
        "\n",
        "def retach_parameters(params): \n",
        "  return {k: torch.from_numpy(v).to(device) for k, v in params.items()}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xp9TzDVC2fCK"
      },
      "source": [
        "# Permutation utility \n",
        " \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7kIsnNOJ8Dno"
      },
      "outputs": [],
      "source": [
        "#@title matrix2index & index2matrix\n",
        "'''\n",
        "utility for convert a permutation matrix to the index version and vice-versa.\n",
        "Used to work with the implementation of Linear Sum Assingment in scipy. \n",
        "One could also work with only the index version, which in a real application \n",
        "can be more efficient, but I thought that for an experimental\n",
        "notebook (like this one) the matrix version would be easier to understand.\n",
        "'''\n",
        "def matrix2index(P, axis='col'):\n",
        "  index = {}\n",
        "  if axis == 'row':\n",
        "    return None\n",
        "  if axis == 'col':\n",
        "    for i in range(P.shape[0]):\n",
        "      index[i] = np.argmax(P[i])\n",
        "    \n",
        "    reverse_index = {v:k for k, v in index.items()}\n",
        "  \n",
        "    return [reverse_index[i] for i in range(len(reverse_index))]\n",
        "\n",
        "\n",
        "def index2matrix(index, axis='col'):\n",
        "  len_id = len(index)\n",
        "  matrix = np.zeros((len_id, len_id))\n",
        "  temp_id = {i: index[i] for i in range(len(index))}\n",
        "  for i in range(len_id): \n",
        "    matrix[temp_id[i], i] = 1 \n",
        "  \n",
        "  return matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_nS6fXad8uL2"
      },
      "outputs": [],
      "source": [
        "#@title interpolation utility\n",
        "def interpolate_2_models(coef:float, vector1:dict ,vector2:dict):\n",
        "  '''return list of interpolate models, for testing the interpolation with different parameters'''\n",
        "  assert (coef>=0.0 and coef<=1.0), f'coef val : {coef}'\n",
        "  coef1 = 1-coef\n",
        "  coef2 = coef\n",
        "  return dict(\n",
        "      [(key, coef1*vector1[key] + coef2*vector2[key] ) for key in vector1.keys()]\n",
        "  )\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dWq3RVd09u0f"
      },
      "outputs": [],
      "source": [
        "#@title plot_barrier\n",
        "def plot_barrier(eval_interpolated, eval_interpolated_permuted, coef_vector, title):\n",
        "\n",
        "  train_losses, test_losses = eval_interpolated['train'], eval_interpolated['test']\n",
        "  train_losses_p, test_losses_p = eval_interpolated_permuted['train'], eval_interpolated_permuted['test']\n",
        "\n",
        "  limit_up = max(chain(train_losses, test_losses, train_losses_p, test_losses_p))\n",
        "  limit_down = min(chain(train_losses, test_losses, train_losses_p, test_losses_p))\n",
        "  fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 6))\n",
        "  fig.suptitle(title, fontsize=20)\n",
        "  \n",
        "  ax1.set_title('original model')\n",
        "  ax1.plot(coef_vector, train_losses, '--', label='train', marker='o', color='crimson')\n",
        "  ax1.plot(coef_vector, test_losses,label='test', marker='o', color='navy')\n",
        "  ax1.set_xlabel('interpolation coeff', fontsize=16)\n",
        "  ax1.set_ylabel('loss', fontsize=16)\n",
        "  ax1.set_ylim([limit_down-0.5, limit_up+0.5])\n",
        "  ax1.legend(fontsize=16)\n",
        "\n",
        "  ax2.set_title('permuted model')\n",
        "  ax2.plot(coef_vector, train_losses_p, '--', label='train', marker='o', color='crimson')\n",
        "  ax2.plot(coef_vector, test_losses_p, label='test', marker='o', color='navy')\n",
        "  ax2.set_xlabel('interpolation coeff', fontsize=16)\n",
        "  ax2.set_ylabel('loss', fontsize=16)\n",
        "  ax2.set_ylim([limit_down-0.5, limit_up+0.5])\n",
        "  ax2.legend(fontsize=16)\n",
        "\n",
        "\n",
        "  plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SaWukqNv3MWv"
      },
      "outputs": [],
      "source": [
        "#@title evaluate interpolation \n",
        "def evaluate_interpolation(data_loaders,\n",
        "                           loss_fn,\n",
        "                           model_A,\n",
        "                           model_B,\n",
        "                           coef_vect,\n",
        "                           device,                          \n",
        "                           ):\n",
        "  '''\n",
        "  calc test/train loss and accuracy for a set of interpolated models. \n",
        "  (consider that there is no restrinction over the kind of model, \n",
        "  can be the permuted ones or the original)\n",
        "  \n",
        "  '''\n",
        "  test_losses_list = []\n",
        "  train_losses_list = []\n",
        "  params_A = detach_parameters(dict(model_A.named_parameters()))\n",
        "  params_B = detach_parameters(dict(model_B.named_parameters()))\n",
        "\n",
        "  print('index | coef | test loss | test_acc')    \n",
        "\n",
        "  for index, coef in enumerate(coef_vector): \n",
        "\n",
        "    interpolated_model = copy.deepcopy(model_A)\n",
        "    interpolated_model.to(device)\n",
        "    \n",
        "    params = interpolate_2_models(coef, params_A, params_B)\n",
        "    interpolated_model.load_state_dict(retach_parameters(params))\n",
        "\n",
        "    test_acc, test_loss = test_loop(data_loaders, interpolated_model,\n",
        "                                    loss_fn, device=device,\n",
        "                                    test_set=True, print_score=False)\n",
        "    _, train_loss = test_loop(data_loaders, interpolated_model,\n",
        "                              loss_fn, device=device, \n",
        "                              test_set=False, print_score=False)\n",
        "\n",
        "    test_losses_list.append(test_loss)\n",
        "    train_losses_list.append(train_loss)\n",
        "    print(f'   {index}  | {coef:.2f} |   {test_loss:.4f}  | {test_acc:.3f}')\n",
        "  return {'train': train_losses_list, 'test': test_losses_list} \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IaD9X4EjvdAt"
      },
      "source": [
        "## Permutation calc:  weight_matching & utils\n",
        "\n",
        "The weight matching is the main algorithm of this notebook. The idea is to find a set of permutations that maximize the similarity between 2 models. Considering the huge number of permutation matrixes, it's impossible to run exhaustive research over all the parameters. \n",
        "\n",
        "Entezari proposed to use a local search alg. like the simulated annealing, the reference paper prefers look for a different approach.\n",
        "\\\n",
        "\\\n",
        "Indeed, they tried to find a set of permutation matrix $\\pi$ that satisfies the following optimization problem:\n",
        "\\\n",
        "\\\n",
        "\\begin{equation}\n",
        "  argmin_\\pi|| vec(\\Theta_A) - vec(\\pi(\\Theta_B) ||^2\n",
        "\\end{equation}\n",
        "\\\n",
        "where the $vec$ function return a \"vectorize\" version of the model parameters $\\Theta_A$ and $\\Theta_B$. \n",
        "\n",
        "Developing the solution of the optimization problem for all the layers, we get a SOBLAB (sum of bilinear assignments problem), which is NP-hard and does not have a polynomial time solution. \n",
        "\\\n",
        "The solution for this became searching just for one permutation for step, keeping the other fixed, selecting the best in a greedy way, and iterating the algorithm until convergence (no increase in similarity).\n",
        "\n",
        "In this way, the SOBLAB became a LAP (linear assignments problem):\n",
        "\\\n",
        "\\\n",
        "\\begin{equation}\n",
        "    argmax_{\\pi=\\{P_i\\}} <W_l^{A}, P_l W_l^{B} P_{l-1}^T>_F +  <W_{l+1}^{A}, P_{l+1} W_{l+1}^{B} P_{l}^T>_F\n",
        "\\end{equation}\n",
        "\\\n",
        "Where the subscrip F indicates the frobenius norm\n",
        "\n",
        "From this optimization problem, the paper develops this solution:\n",
        "\\\n",
        "\\\n",
        "\\begin{equation}\n",
        "    argmax_{\\pi=\\{P_i\\}} <P_l, W_l^A P_{l-1} W_l^{BT}  + W_{l+1}^{AT} P_{l+1} W_{l+1}^B >_F\n",
        "\\end{equation}\n",
        "\\\n",
        "Unfortunately, applying this solution the algorithm is unable to converge to a solution. \n",
        "In [this cell](#scrollTo=emjIFlkiZZ6v) it's possible to see the effect of using the equation from the paper for a max of 100 iterations.The similarity level for all the layers never goes to 0 (as it should).\n",
        "\\\n",
        "\\\n",
        "I'd like to underline that the paper declares clearly that <b>they do not use the solution proposed in the paper</b>, but a different implementation (not presented).\n",
        "\\\n",
        "Also, the presented solution is expressed in simple terms (mlp, without bias), and there is no reference to extending the method to a cnn network or adding a bias term.  \n",
        "\n",
        "So, after some time, i developed my \"personal\" close form solution for the optimization problem: \n",
        "\\\n",
        "\\\n",
        "\\begin{equation}\n",
        "    argmax_{\\pi=\\{P_i\\}} <P_l, W_l^B P_{l-1}^T W_l^{AT}  + W_{l+1}^{BT} P_{l+1}^T W_{l+1}^A >_F\n",
        "\\end{equation}\n",
        "\\\n",
        "I have also added the contribution of the bias term, to obtain this solution:\n",
        "\\\n",
        "\\\n",
        "\\begin{equation}\n",
        "    argmax_{\\pi=\\{P_i\\}} <P_l,  W_l^B P_{l-1}^T W_l^{AT}  + W_{l+1}^{BT} P_{l+1}^T W_{l+1}^A + b^{AT}_l b^{B}_l>_F \n",
        "\\end{equation}\n",
        "\\\n",
        "I'd also like to report that any reproduction of the paper code that i found online uses the same base code of the original code, with an easy copy-paste from the main repository. All these projects are just checking the procedure for a new mlp model. It was not possible to find an original implementation or just a test with a non-dense architecture.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pJgo7tRwg4cW"
      },
      "outputs": [],
      "source": [
        "def weight_matching(A_funct, P, runs=100, silent=False): \n",
        "\n",
        "  for run in range(runs): \n",
        "    progress = False\n",
        "    for j in np.random.permutation(list(range(1, len(P)+1))): \n",
        "      A = A_funct[f'A{j}'](P)\n",
        "    \n",
        "\n",
        "      row_index, col_index = linear_sum_assignment(A, maximize=True)\n",
        "\n",
        "      p_index = matrix2index(P[f'P{j}'])\n",
        "      old_gain = np.vdot(A, np.eye(len(p_index))[p_index])\n",
        "      new_gain = np.vdot(A, np.eye(len(p_index))[col_index, :])\n",
        "\n",
        "      # Update P\n",
        "      P[f'P{j}'] = index2matrix(col_index)\n",
        "      progress = progress or new_gain > old_gain\n",
        "\n",
        "      if not silent:  print(f'run:{run} || P{j}; gain: {new_gain - old_gain}' )\n",
        "    \n",
        "    if not progress: \n",
        "      if not silent:\n",
        "        print('---------------------------')\n",
        "        print('stop progress at run : ', run)\n",
        "      break\n",
        "\n",
        "  return P"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y3HdrTtif7Wu"
      },
      "outputs": [],
      "source": [
        "def weight_matching_close_form(close_form_sol, Params_A, Params_B, P): \n",
        "  '''function for test the close form solution obtained from the optimization problem'''\n",
        "  for run in range(100): \n",
        "    progress = False\n",
        "    for j in np.random.permutation(list(range(1, len(P)+1))): \n",
        "      A = close_form_sol[f'A{j}'](Params_A, Params_B, P)\n",
        "    \n",
        "      row_index, col_index = linear_sum_assignment(A, maximize=True)\n",
        "\n",
        "      p_index = matrix2index(P[f'P{j}'])\n",
        "      old_loss = np.vdot(A, np.eye(len(p_index))[p_index])\n",
        "      new_loss = np.vdot(A, np.eye(len(p_index))[col_index, :])\n",
        "\n",
        "      # Update P\n",
        "      P[f'P{j}'] = index2matrix(col_index)\n",
        "      progress = progress or new_loss > old_loss\n",
        "\n",
        "      print(f'run:{run} || P{j}; gain: {new_loss - old_loss}' )\n",
        "    \n",
        "    if not progress: \n",
        "      print('---------------------------')\n",
        "      print('stop progress at run : ', run)\n",
        "      break\n",
        "\n",
        "  return P\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5zQgM3Ztjr_P"
      },
      "outputs": [],
      "source": [
        "#@title define permutation info for permuted model\n",
        "\n",
        "def permutation_model_info(params, bias) -> dict:\n",
        "  '''\n",
        "  Return a dictionary that specifies how to permute the model to get an \n",
        "  equivalent one.\n",
        "  The dictionary will be in the form of {weight_i : (perm_row, perm_col)} where\n",
        "  perm_row and perm_col will be the str name of the matrix to pre/post multiply\n",
        "  '''\n",
        "  len_model = len(params)//2\n",
        "  perm = {}\n",
        "\n",
        "  # kernel\n",
        "  perm['dense1.weight'] = ('P1', None) \n",
        "  for i in range(2, len_model): \n",
        "    perm[f'dense{i}.weight'] = (f'P{i}', f'P{i-1}')\n",
        "  perm[f'dense{len_model}.weight'] = (None, f'P{len_model-1}')\n",
        "\n",
        "  # bias\n",
        "  if bias: \n",
        "    perm['dense1.bias'] = ('P1', None) \n",
        "    for i in range(2, len_model): \n",
        "      perm[f'dense{i}.bias'] = (f'P{i}', None)\n",
        "    perm[f'dense{len_model}.bias'] = (None, None)\n",
        "    \n",
        "  return perm\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vevhZFL4mQIY"
      },
      "outputs": [],
      "source": [
        "#@title apply permutation \n",
        "\n",
        "def apply_permutation(params, perm_info, P): \n",
        "  '''\n",
        "  params = dict of parameters of a mlp\n",
        "  perm_info = {weight_i, (P_row, P_col)}\n",
        "  P = dict as { 'P_i' : matrix_P(numpy) }\n",
        "\n",
        "  retrun new params after apply the permutation specify inside perm_info\n",
        "\n",
        "  the NotImplementedError is there in case you want to implement some other mechanism \n",
        "  to extend the code to convolutional layers\n",
        "  \n",
        "  '''\n",
        "  permuted = {}\n",
        "\n",
        "  for k, v in perm_info.items(): \n",
        "\n",
        "    if k.endswith('weight'):\n",
        "      try: \n",
        "        permuted[k] = P[v[0]] @ params[k] @ P[v[1]].T\n",
        "      except KeyError: # first or last layer\n",
        "        if not v[0]: permuted[k] = params[k] @ P[v[1]].T\n",
        "        elif not v[1]: permuted[k] = P[v[0]] @ params[k]\n",
        "        else: raise NotImplementedError \n",
        "\n",
        "    else: #bias term \n",
        "      try: \n",
        "        permuted[k] = P[v[0]] @ params[k]\n",
        "      except KeyError: #last layer\n",
        "        if not v[0]: permuted[k] = params[k]\n",
        "        else: raise NotImplementedError \n",
        "  \n",
        "  return permuted"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Elepjs-uorQg"
      },
      "outputs": [],
      "source": [
        "#@title generate empty P\n",
        "def get_empty_P_as_dict(params, bias=True):\n",
        "  '''returned dict: {'P_i' : identity_matrix}'''  \n",
        "  P = {}\n",
        "  model_len = len(params)//2\n",
        "  if not bias: model_len = len(params) \n",
        "  for i in range(1, model_len):\n",
        "    P[f'P{i}'] = np.eye(params[f'dense{i}.weight'].shape[0])\n",
        "  return P"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AP6yQx11CDk8"
      },
      "outputs": [],
      "source": [
        "#@title A_funct dictionary\n",
        "def get_A_functs(params_A, params_B):\n",
        "  '''\n",
        "  This function manages the equations for a particular couple of networks. \n",
        "  \n",
        "  It's basically a big wrapper for the context (index of matrix to calc). \n",
        "  Return a dictionary in the form of {A_i: funct}, where funct is\n",
        "  a function that calculates the matrix to pass to the linear sum solver.\n",
        "  \n",
        "  Considering that the parameters of the models A and B are fixed, \n",
        "  the only input parameter for this function will be the matrix P. \n",
        "\n",
        "  TODO: add the checker over the bias term --> for now can manage only dense mlp + bias\n",
        "  '''\n",
        "  A_funct = {}\n",
        "  # params_A contains both weight and bias, len/2 aka num of layers\n",
        "  model_len = len(params_A)//2 \n",
        "\n",
        "\n",
        "  def special_case_init(P):\n",
        "    return params_B['dense1.weight']   @ params_A['dense1.weight'].T +\\\n",
        "           params_B['dense2.weight'].T @ P['P2'].T @ params_A['dense2.weight'] +\\\n",
        "           params_A['dense1.bias'].T   @ params_B['dense1.bias']\n",
        "\n",
        "  def special_case_final(P): \n",
        "    return params_B[f'dense{model_len-1}.weight'] @ P[f'P{model_len-2}'].T @ params_A[f'dense{model_len-1}.weight'].T +\\\n",
        "           params_B[f'dense{ model_len }.weight'].T @ params_A[f'dense{model_len}.weight'] +\\\n",
        "           params_A[f'dense{model_len-1}.bias'].T  @ params_B[f'dense{model_len-1}.bias']\n",
        "\n",
        "  def iterator_over_A_funct(i):\n",
        "    #define funct to call (not first, not last layer)\n",
        "    def A(P): \n",
        "       return params_B[f'dense{  i }.weight']   @ P[f'P{i-1}'].T @ params_A[f'dense{i}.weight'].T +\\\n",
        "              params_B[f'dense{i+1}.weight'].T @ P[f'P{i+1}'].T @ params_A[f'dense{i+1}.weight'] +\\\n",
        "              params_A[f'dense{ i }.bias'].T   @ params_B[f'dense{i}.bias']\n",
        "    return A\n",
        "\n",
        "  A_funct['A1'] = special_case_init\n",
        "  for i in range(2, model_len-1):\n",
        "    A_funct[f'A{i}'] = iterator_over_A_funct(i)\n",
        "  A_funct[f'A{model_len-1}'] = special_case_final\n",
        "\n",
        "  return A_funct\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S_0IVAGKvNq4"
      },
      "source": [
        "#### test A_funct dynamically vs close form solution \n",
        "As reported in the previous cell, my first attempt was based on a close form solution, for a fixed dimension layer. The solution that I develop is different from the one that i found in the paper, first because the paper presents the result only in the form of MLP without bias, and then declares also to use a different implementation of the procedure presented.This cell just checks that the dynamic function and the closed form return the same result. A comparison between my close form and the close form from the paper will follow."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BmAispVipMUd"
      },
      "outputs": [],
      "source": [
        "def A1(A, B, P): \n",
        "  return B['dense1.weight'] @ A['dense1.weight'].T +\\\n",
        "         B['dense2.weight'].T @ P['P2'].T @ A['dense2.weight'] +\\\n",
        "         A['dense1.bias'].T @ B['dense1.bias']\n",
        "\n",
        "\n",
        "def A2(A, B, P): \n",
        "  return B['dense2.weight'] @P['P1'].T @ A['dense2.weight'].T +\\\n",
        "         B['dense3.weight'].T @ P['P3'].T @ A['dense3.weight'] +\\\n",
        "         A['dense2.bias'].T @ B['dense2.bias']\n",
        "\n",
        "\n",
        "\n",
        "def A3(A, B, P): \n",
        "  return (B['dense3.weight'] @ P['P2'].T @ A['dense3.weight'].T) +\\\n",
        "         (B['dense4.weight'].T @ A['dense4.weight']) +\\\n",
        "         (A['dense3.bias'].T @ B['dense3.bias'])\n",
        "\n",
        "\n",
        "close_form_sol = {\n",
        "    'A1': A1,\n",
        "    'A2': A2,\n",
        "    'A3': A3\n",
        "}\n",
        "\n",
        "model_A_temp, model_B_temp = SNet(input_size=mnist_input_size, bias=True), SNet(input_size=mnist_input_size, bias=True)\n",
        "params_A_temp = detach_parameters(copy.deepcopy(dict(model_A_temp.named_parameters())))\n",
        "params_B_temp = detach_parameters(copy.deepcopy(dict(model_B_temp.named_parameters())))\n",
        "\n",
        "P_temp = get_empty_P_as_dict(params_B_temp)\n",
        "A_funct_temp = get_A_functs(params_A_temp, params_B_temp)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ezx1gmMtqsae",
        "outputId": "96c93f3d-62a9-4852-ee21-6fbc68bb47ed"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(True, True, True)"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "res_1 = close_form_sol['A1'](params_A_temp, params_B_temp, P_temp)\n",
        "res_2 = close_form_sol['A2'](params_A_temp, params_B_temp, P_temp)\n",
        "res_3 = close_form_sol['A3'](params_A_temp, params_B_temp, P_temp)\n",
        "\n",
        "res_dyn_1 = A_funct_temp['A1'](P_temp)\n",
        "res_dyn_2 = A_funct_temp['A2'](P_temp)\n",
        "res_dyn_3 = A_funct_temp['A3'](P_temp)\n",
        "\n",
        "(res_1 == res_dyn_1).all(), (res_2 == res_dyn_2).all(), (res_2 == res_dyn_2).all()\n",
        "\n",
        "#\n",
        "# should return (True x3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "emjIFlkiZZ6v",
        "outputId": "c68bf9e8-c0f9-472c-a394-6778919f1165"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "run:0 || P1; gain: 0.0\n",
            "run:0 || P2; gain: 30.609911816361254\n",
            "run:0 || P3; gain: 17.57273136551697\n",
            "run:1 || P2; gain: 14.752125177684789\n",
            "run:1 || P3; gain: 19.71912807343858\n",
            "run:1 || P1; gain: 28.19784539563408\n",
            "run:2 || P1; gain: 0.0\n",
            "run:2 || P2; gain: 30.688136386632777\n",
            "run:2 || P3; gain: 21.184568547356992\n",
            "run:3 || P2; gain: 15.754869957127168\n",
            "run:3 || P3; gain: 20.358585952964884\n",
            "run:3 || P1; gain: 17.171040106252885\n",
            "run:4 || P1; gain: 0.0\n",
            "run:4 || P2; gain: 30.347783217780556\n",
            "run:4 || P3; gain: 21.411520554094114\n",
            "run:5 || P2; gain: 14.836155991639549\n",
            "run:5 || P1; gain: 16.823261303268104\n",
            "run:5 || P3; gain: 20.60877800134421\n",
            "run:6 || P2; gain: 30.515233047871146\n",
            "run:6 || P1; gain: 17.578904500804967\n",
            "run:6 || P3; gain: 21.43161293743086\n",
            "run:7 || P3; gain: 0.0\n",
            "run:7 || P2; gain: 30.74435259063469\n",
            "run:7 || P1; gain: 17.30127931339563\n",
            "run:8 || P1; gain: 0.0\n",
            "run:8 || P2; gain: 14.678017171356931\n",
            "run:8 || P3; gain: 21.421635650364063\n",
            "run:9 || P3; gain: 0.0\n",
            "run:9 || P2; gain: 15.461792349192175\n",
            "run:9 || P1; gain: 16.209944897498943\n",
            "run:10 || P1; gain: 0.0\n",
            "run:10 || P3; gain: 21.1376069206528\n",
            "run:10 || P2; gain: 30.197201292065564\n",
            "run:11 || P1; gain: 17.431548564999584\n",
            "run:11 || P3; gain: 22.375483301753064\n",
            "run:11 || P2; gain: 31.430532914380933\n",
            "run:12 || P2; gain: 0.0\n",
            "run:12 || P3; gain: 21.934008729235952\n",
            "run:12 || P1; gain: 16.752771595827028\n",
            "run:13 || P1; gain: 0.0\n",
            "run:13 || P3; gain: 0.0\n",
            "run:13 || P2; gain: 30.696879758596378\n",
            "run:14 || P3; gain: 20.94901593549223\n",
            "run:14 || P2; gain: 15.34219365751808\n",
            "run:14 || P1; gain: 17.321082516719606\n",
            "run:15 || P2; gain: 14.984690669579408\n",
            "run:15 || P3; gain: 21.261935433768777\n",
            "run:15 || P1; gain: 16.7150321037622\n",
            "run:16 || P2; gain: 30.228269099900242\n",
            "run:16 || P1; gain: 16.21800689018835\n",
            "run:16 || P3; gain: 20.847490924366245\n",
            "run:17 || P1; gain: 0.0\n",
            "run:17 || P2; gain: 30.372938479860924\n",
            "run:17 || P3; gain: 21.650068882756585\n",
            "run:18 || P1; gain: 16.449081402037407\n",
            "run:18 || P2; gain: 31.012680350853998\n",
            "run:18 || P3; gain: 21.333848491623748\n",
            "run:19 || P3; gain: 0.0\n",
            "run:19 || P1; gain: 16.733040438622176\n",
            "run:19 || P2; gain: 29.53218567377184\n",
            "run:20 || P3; gain: 22.214545712830812\n",
            "run:20 || P1; gain: 17.101159207578014\n",
            "run:20 || P2; gain: 31.28704981204202\n",
            "run:21 || P1; gain: 15.88457522372278\n",
            "run:21 || P2; gain: 15.157850695126793\n",
            "run:21 || P3; gain: 21.410793112216307\n",
            "run:22 || P2; gain: 14.615719364452964\n",
            "run:22 || P3; gain: 19.778721883258072\n",
            "run:22 || P1; gain: 16.226584563702502\n",
            "run:23 || P2; gain: 30.32613766652967\n",
            "run:23 || P3; gain: 21.03094505082285\n",
            "run:23 || P1; gain: 17.30269438243073\n",
            "run:24 || P2; gain: 29.876996853403927\n",
            "run:24 || P1; gain: 17.233432344951552\n",
            "run:24 || P3; gain: 22.161689930251967\n",
            "run:25 || P2; gain: 29.879450762189133\n",
            "run:25 || P3; gain: 21.36269302336375\n",
            "run:25 || P1; gain: 17.124684424035728\n",
            "run:26 || P1; gain: 0.0\n",
            "run:26 || P3; gain: 0.0\n",
            "run:26 || P2; gain: 31.110954992956955\n",
            "run:27 || P3; gain: 20.750075429062754\n",
            "run:27 || P2; gain: 15.030823964997584\n",
            "run:27 || P1; gain: 16.33966833398179\n",
            "run:28 || P1; gain: 0.0\n",
            "run:28 || P3; gain: 20.096357157370274\n",
            "run:28 || P2; gain: 30.072260208879694\n",
            "run:29 || P3; gain: 21.116734199343675\n",
            "run:29 || P1; gain: 17.043555733325306\n",
            "run:29 || P2; gain: 30.746656625621117\n",
            "run:30 || P3; gain: 21.161180840123155\n",
            "run:30 || P1; gain: 16.895897342644844\n",
            "run:30 || P2; gain: 30.71005061731353\n",
            "run:31 || P1; gain: 17.59522369910608\n",
            "run:31 || P3; gain: 21.698620010620004\n",
            "run:31 || P2; gain: 30.98171561445516\n",
            "run:32 || P1; gain: 17.329931718593542\n",
            "run:32 || P2; gain: 15.478992337989713\n",
            "run:32 || P3; gain: 21.829919190127725\n",
            "run:33 || P1; gain: 15.858248437806367\n",
            "run:33 || P2; gain: 29.789696684568554\n",
            "run:33 || P3; gain: 21.468470255041744\n",
            "run:34 || P3; gain: 0.0\n",
            "run:34 || P2; gain: 15.464276403710572\n",
            "run:34 || P1; gain: 17.227815491155216\n",
            "run:35 || P2; gain: 14.424025002379153\n",
            "run:35 || P1; gain: 16.29320582722559\n",
            "run:35 || P3; gain: 21.057149390913057\n",
            "run:36 || P3; gain: 0.0\n",
            "run:36 || P1; gain: 0.0\n",
            "run:36 || P2; gain: 30.917439382457164\n",
            "run:37 || P1; gain: 17.30585697465274\n",
            "run:37 || P3; gain: 21.368058393288678\n",
            "run:37 || P2; gain: 30.496703124371034\n",
            "run:38 || P1; gain: 17.17248925495254\n",
            "run:38 || P3; gain: 21.309040494030455\n",
            "run:38 || P2; gain: 30.76074575199351\n",
            "run:39 || P1; gain: 16.763945193588114\n",
            "run:39 || P3; gain: 21.14268912922308\n",
            "run:39 || P2; gain: 30.493268673877537\n",
            "run:40 || P1; gain: 16.891118318875186\n",
            "run:40 || P3; gain: 21.898471672673278\n",
            "run:40 || P2; gain: 30.604821668158706\n",
            "run:41 || P3; gain: 21.717111643865433\n",
            "run:41 || P1; gain: 17.24547698470213\n",
            "run:41 || P2; gain: 30.950548740078165\n",
            "run:42 || P1; gain: 17.681395290888094\n",
            "run:42 || P2; gain: 15.091906509111489\n",
            "run:42 || P3; gain: 21.693783800515746\n",
            "run:43 || P1; gain: 15.718430888571422\n",
            "run:43 || P3; gain: 0.0\n",
            "run:43 || P2; gain: 30.33759513204951\n",
            "run:44 || P1; gain: 16.904617161174713\n",
            "run:44 || P3; gain: 21.09347775685216\n",
            "run:44 || P2; gain: 30.524237921488957\n",
            "run:45 || P1; gain: 17.101564326196012\n",
            "run:45 || P3; gain: 21.021280976346112\n",
            "run:45 || P2; gain: 29.168025877511948\n",
            "run:46 || P3; gain: 21.270959074957553\n",
            "run:46 || P1; gain: 17.28836561931856\n",
            "run:46 || P2; gain: 31.01717796649245\n",
            "run:47 || P1; gain: 16.96305663087491\n",
            "run:47 || P2; gain: 14.195099786920068\n",
            "run:47 || P3; gain: 21.29842739204866\n",
            "run:48 || P3; gain: 0.0\n",
            "run:48 || P1; gain: 15.817663065992523\n",
            "run:48 || P2; gain: 29.90491665184868\n",
            "run:49 || P3; gain: 21.37624266445343\n",
            "run:49 || P2; gain: 15.640592339166412\n",
            "run:49 || P1; gain: 16.712924309900245\n",
            "run:50 || P3; gain: 20.489931142583494\n",
            "run:50 || P2; gain: 30.443195259356703\n",
            "run:50 || P1; gain: 17.421648387320054\n",
            "run:51 || P3; gain: 20.873980883218312\n",
            "run:51 || P2; gain: 30.182270495375608\n",
            "run:51 || P1; gain: 17.163174120775942\n",
            "run:52 || P2; gain: 15.421210798934124\n",
            "run:52 || P1; gain: 16.351335418484993\n",
            "run:52 || P3; gain: 21.52996897270144\n",
            "run:53 || P3; gain: 0.0\n",
            "run:53 || P1; gain: 0.0\n",
            "run:53 || P2; gain: 30.785565255190747\n",
            "run:54 || P2; gain: 0.0\n",
            "run:54 || P3; gain: 21.591706098208057\n",
            "run:54 || P1; gain: 16.20014360915487\n",
            "run:55 || P2; gain: 30.072977238175287\n",
            "run:55 || P3; gain: 21.988255000065074\n",
            "run:55 || P1; gain: 16.854717584177937\n",
            "run:56 || P2; gain: 30.205656562239334\n",
            "run:56 || P3; gain: 21.503556672181954\n",
            "run:56 || P1; gain: 17.858126836754277\n",
            "run:57 || P2; gain: 30.79972153710033\n",
            "run:57 || P3; gain: 21.47866854665682\n",
            "run:57 || P1; gain: 17.4663778641985\n",
            "run:58 || P3; gain: 0.0\n",
            "run:58 || P2; gain: 31.286245368801925\n",
            "run:58 || P1; gain: 16.244599870805533\n",
            "run:59 || P3; gain: 21.61971088440514\n",
            "run:59 || P2; gain: 30.08367073940614\n",
            "run:59 || P1; gain: 17.39247877499109\n",
            "run:60 || P2; gain: 14.908055644744561\n",
            "run:60 || P1; gain: 15.88506605628579\n",
            "run:60 || P3; gain: 21.631941302861208\n",
            "run:61 || P2; gain: 30.306581833428673\n",
            "run:61 || P1; gain: 16.87036207332445\n",
            "run:61 || P3; gain: 21.40031202395107\n",
            "run:62 || P2; gain: 30.382963832346302\n",
            "run:62 || P1; gain: 17.035380089154696\n",
            "run:62 || P3; gain: 21.1746313426084\n",
            "run:63 || P2; gain: 30.554439256569992\n",
            "run:63 || P3; gain: 21.69541884909153\n",
            "run:63 || P1; gain: 15.902172304935817\n",
            "run:64 || P3; gain: 0.0\n",
            "run:64 || P2; gain: 30.768089563166875\n",
            "run:64 || P1; gain: 16.900523470498015\n",
            "run:65 || P1; gain: 0.0\n",
            "run:65 || P2; gain: 14.42327378153577\n",
            "run:65 || P3; gain: 21.77694557967273\n",
            "run:66 || P3; gain: 0.0\n",
            "run:66 || P2; gain: 15.448580519883015\n",
            "run:66 || P1; gain: 17.37894210510651\n",
            "run:67 || P2; gain: 14.907162929722652\n",
            "run:67 || P1; gain: 15.766107163284364\n",
            "run:67 || P3; gain: 21.85587248297033\n",
            "run:68 || P3; gain: 0.0\n",
            "run:68 || P1; gain: 0.0\n",
            "run:68 || P2; gain: 30.278647807148154\n",
            "run:69 || P2; gain: 0.0\n",
            "run:69 || P1; gain: 16.992140684963086\n",
            "run:69 || P3; gain: 21.74138876964152\n",
            "run:70 || P1; gain: 0.0\n",
            "run:70 || P3; gain: 0.0\n",
            "run:70 || P2; gain: 30.55153666601353\n",
            "run:71 || P2; gain: 0.0\n",
            "run:71 || P3; gain: 21.83020689343309\n",
            "run:71 || P1; gain: 17.126663006691178\n",
            "run:72 || P3; gain: 0.0\n",
            "run:72 || P1; gain: 0.0\n",
            "run:72 || P2; gain: 30.473789187338927\n",
            "run:73 || P2; gain: 0.0\n",
            "run:73 || P1; gain: 16.975395355178314\n",
            "run:73 || P3; gain: 21.70960411319771\n",
            "run:74 || P2; gain: 29.850886985103607\n",
            "run:74 || P1; gain: 16.616793477705627\n",
            "run:74 || P3; gain: 21.691298205268797\n",
            "run:75 || P1; gain: 0.0\n",
            "run:75 || P2; gain: 29.835223923276533\n",
            "run:75 || P3; gain: 21.836464261196006\n",
            "run:76 || P2; gain: 15.335145884901412\n",
            "run:76 || P1; gain: 16.908279626918926\n",
            "run:76 || P3; gain: 19.85257704388085\n",
            "run:77 || P3; gain: 0.0\n",
            "run:77 || P2; gain: 30.813680377101722\n",
            "run:77 || P1; gain: 16.900221975721276\n",
            "run:78 || P2; gain: 14.848165169949507\n",
            "run:78 || P1; gain: 16.06637635926891\n",
            "run:78 || P3; gain: 21.55704327796811\n",
            "run:79 || P3; gain: 0.0\n",
            "run:79 || P1; gain: 0.0\n",
            "run:79 || P2; gain: 30.89041646583851\n",
            "run:80 || P2; gain: 0.0\n",
            "run:80 || P1; gain: 17.164392234985808\n",
            "run:80 || P3; gain: 21.397062063285837\n",
            "run:81 || P2; gain: 30.49813467640379\n",
            "run:81 || P1; gain: 16.248000607259268\n",
            "run:81 || P3; gain: 21.711303969556603\n",
            "run:82 || P1; gain: 0.0\n",
            "run:82 || P3; gain: 0.0\n",
            "run:82 || P2; gain: 29.33448310074036\n",
            "run:83 || P2; gain: 0.0\n",
            "run:83 || P3; gain: 21.220040855551872\n",
            "run:83 || P1; gain: 16.81544374322788\n",
            "run:84 || P1; gain: 0.0\n",
            "run:84 || P2; gain: 30.920891260132194\n",
            "run:84 || P3; gain: 22.02543142788479\n",
            "run:85 || P2; gain: 14.799682279235846\n",
            "run:85 || P1; gain: 17.27843640108402\n",
            "run:85 || P3; gain: 20.2750101560421\n",
            "run:86 || P3; gain: 0.0\n",
            "run:86 || P2; gain: 30.64178520434523\n",
            "run:86 || P1; gain: 16.364887626837294\n",
            "run:87 || P3; gain: 21.597939184237866\n",
            "run:87 || P1; gain: 0.0\n",
            "run:87 || P2; gain: 30.35405625296697\n",
            "run:88 || P2; gain: 0.0\n",
            "run:88 || P1; gain: 17.09941491546331\n",
            "run:88 || P3; gain: 21.32919145636077\n",
            "run:89 || P2; gain: 31.316708983434644\n",
            "run:89 || P3; gain: 21.60177002054168\n",
            "run:89 || P1; gain: 16.496283680566517\n",
            "run:90 || P2; gain: 30.082691816905204\n",
            "run:90 || P1; gain: 16.661453632665193\n",
            "run:90 || P3; gain: 21.557298243473937\n",
            "run:91 || P3; gain: 0.0\n",
            "run:91 || P2; gain: 30.69972118490447\n",
            "run:91 || P1; gain: 16.40299873112352\n",
            "run:92 || P2; gain: 14.497656689468037\n",
            "run:92 || P1; gain: 16.166369699797848\n",
            "run:92 || P3; gain: 21.446906083119792\n",
            "run:93 || P1; gain: 0.0\n",
            "run:93 || P2; gain: 29.779906779931867\n",
            "run:93 || P3; gain: 21.114450057559107\n",
            "run:94 || P1; gain: 17.47001755800154\n",
            "run:94 || P3; gain: 0.0\n",
            "run:94 || P2; gain: 30.739528520175078\n",
            "run:95 || P3; gain: 21.79896439739901\n",
            "run:95 || P2; gain: 15.728074006718579\n",
            "run:95 || P1; gain: 16.85689068398859\n",
            "run:96 || P2; gain: 14.875850951367337\n",
            "run:96 || P3; gain: 22.378316202017665\n",
            "run:96 || P1; gain: 16.39329967111729\n",
            "run:97 || P1; gain: 0.0\n",
            "run:97 || P3; gain: 0.0\n",
            "run:97 || P2; gain: 31.524294211118498\n",
            "run:98 || P1; gain: 17.238591106926847\n",
            "run:98 || P3; gain: 21.08325730031346\n",
            "run:98 || P2; gain: 30.816162077826807\n",
            "run:99 || P1; gain: 17.655378703001155\n",
            "run:99 || P2; gain: 15.067154012204814\n",
            "run:99 || P3; gain: 21.631779128362247\n"
          ]
        }
      ],
      "source": [
        "#@title Paper equation test : No Convergence\n",
        "\n",
        "#A_funct paper for MLP no bias\n",
        "def A1(A, B, P): \n",
        "  return A['dense1.weight'] @ B['dense1.weight'].T +\\\n",
        "         A['dense2.weight'].T @ P['P2'] @ A['dense2.weight'] \n",
        "         \n",
        "\n",
        "def A2(A, B, P): \n",
        "  return A['dense2.weight'] @ P['P1'] @ B['dense2.weight'].T +\\\n",
        "         A['dense3.weight'].T @ P['P3'] @ B['dense3.weight']\n",
        "\n",
        "\n",
        "def A3(A, B, P): \n",
        "  return (A['dense3.weight'] @ P['P2'] @ A['dense3.weight'].T) +\\\n",
        "         (A['dense4.weight'].T @ A['dense4.weight']) \n",
        "\n",
        "\n",
        "close_form_sol = {\n",
        "    'A1': A1,\n",
        "    'A2': A2,\n",
        "    'A3': A3\n",
        "}\n",
        "\n",
        "#sample model: \n",
        "model_A_temp, model_B_temp = MNet(input_size=mnist_input_size, bias=False), MNet(input_size=mnist_input_size, bias=False)\n",
        "params_A_temp, params_B_temp = dict(model_A_temp.named_parameters()), dict(model_B_temp.named_parameters())\n",
        "params_A_temp, params_B_temp = detach_parameters(params_A_temp), detach_parameters(params_B_temp)\n",
        "\n",
        "P_temp = get_empty_P_as_dict(params_B_temp, bias=False)\n",
        "P_temp.keys()\n",
        "\n",
        "P_temp_new = weight_matching_close_form(close_form_sol, params_A_temp, params_B_temp, P_temp)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see from the number of iterations (100), the merging doesn't reach the convergence. The procedure will stop because it will reach a maximum number of iterations. \n",
        "\\\n",
        "\\\n",
        "In the next cell there is a check over all the previous defined functions. We can see that the procedure will stop in a few steps, reaching the convergence"
      ],
      "metadata": {
        "id": "obH4zeLzIaiM"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "49ykIBAIiUsc",
        "outputId": "45ac6b23-666f-492a-b927-c0f1785d53e6",
        "cellView": "form"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "run:0 || P3; gain: 3.2144292725980534\n",
            "run:0 || P1; gain: 4.496566487456467\n",
            "run:0 || P2; gain: 0.29520614341560325\n",
            "run:1 || P2; gain: 0.0\n",
            "run:1 || P3; gain: 0.3706299721560411\n",
            "run:1 || P1; gain: 0.41480348798920286\n",
            "run:2 || P3; gain: 0.0\n",
            "run:2 || P1; gain: 0.0\n",
            "run:2 || P2; gain: 0.10047740198398092\n",
            "run:3 || P2; gain: 0.0\n",
            "run:3 || P3; gain: 0.04344483555016154\n",
            "run:3 || P1; gain: 0.3293022481779051\n",
            "run:4 || P1; gain: 0.0\n",
            "run:4 || P2; gain: 0.0\n",
            "run:4 || P3; gain: 0.0\n",
            "---------------------------\n",
            "stop progress at run :  4\n"
          ]
        }
      ],
      "source": [
        "#@title Random test\n",
        "# just a cell for check that all the function works \n",
        "# no train over this model \n",
        "model_A, model_B = SNet(mnist_input_size, bias=True), SNet(mnist_input_size, bias=True)\n",
        "model_A, model_B = model_A.to(device), model_B.to(device)\n",
        "loss_fn = nn.CrossEntropyLoss().to(device)\n",
        "params_A, params_B = dict(model_A.named_parameters()), dict(model_B.named_parameters())\n",
        "params_A, params_B = detach_parameters(params_A), detach_parameters(params_B)\n",
        "\n",
        "P = get_empty_P_as_dict(params_B)\n",
        "A_funct = get_A_functs(params_A, params_B)\n",
        "info_perm = permutation_model_info(params_B, bias=True)\n",
        "\n",
        "new_P = weight_matching(A_funct, P)\n",
        "\n",
        "params_B_permuted = apply_permutation(params_B, info_perm, P)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vs1VRatm8IrR"
      },
      "outputs": [],
      "source": [
        "#@title git_merge \n",
        "def git_merge(A, B, coef=0.5, silent=False):\n",
        "  '''\n",
        "   git_merge funct: merge 2 models after the permutation of the weight of the B model.\n",
        "\n",
        "  Just utility funct, used in the final part of the notebook for testing a\n",
        "  simulation over sub-dataset (merge many). \n",
        "  \n",
        "  It can be considered a wrapper over all the utilities defined above.\n",
        "  \n",
        "  '''\n",
        "  returned_model = copy.deepcopy(A)\n",
        "  params_A = copy.deepcopy(dict(A.named_parameters()))\n",
        "  params_B = copy.deepcopy(dict(B.named_parameters()))\n",
        "  params_A, params_B = detach_parameters(params_A), detach_parameters(params_B)\n",
        "\n",
        "  P = get_empty_P_as_dict(params_B)\n",
        "  A_funct = get_A_functs(params_A, params_B)\n",
        "  info_perm = permutation_model_info(params_B, bias=True)\n",
        "  \n",
        "  P = weight_matching(A_funct, P, silent=silent)\n",
        "\n",
        "  \n",
        "  params_B_permuted = apply_permutation(params_B, info_perm, P)\n",
        "  new_params = interpolate_2_models(coef, params_A, params_B_permuted)\n",
        "  returned_model.load_state_dict(retach_parameters(new_params))\n",
        "\n",
        "\n",
        "  return returned_model\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yTiS04CwJdvm"
      },
      "source": [
        "## Multiple merging\n",
        "In the [appendix (A.10)](https://https://arxiv.org/pdf/2209.04836.pdf#subsection.A.10), the paper proposes an extension of the weight merging procedure for merging a set of N models. This section contains all the utilities for this task.\n",
        "\n",
        "- average_multiple_model : return a new model made of the average params of the input\n",
        "- l2_similarity, cosine_similarity : return the similarity between 2 model params\n",
        "- git_merge_many: extension of weights matching (define in appendix of git-Rebasis). See next cells for the pseudocode"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7oPhogKhA1qj"
      },
      "outputs": [],
      "source": [
        "#@title average model\n",
        "def average_multiple_model(models): \n",
        "  \"\"\"\n",
        "  models : list of models\n",
        "  returned : a new model with parameters equals to the avg of models\n",
        "  \"\"\"\n",
        "  avg_model = copy.deepcopy(models[0])\n",
        "  params_avg = detach_parameters(dict(avg_model.named_parameters()))\n",
        "\n",
        "  num_models = len(models)\n",
        "  parameters = []\n",
        "  for i in range(num_models): \n",
        "    parameters.append(detach_parameters(dict(models[i].named_parameters())))\n",
        "  \n",
        "\n",
        "  for k in params_avg.keys(): \n",
        "    for i in range(num_models): \n",
        "      params_avg[k] += (parameters[i][k] / num_models)\n",
        "  \n",
        "\n",
        "  avg_model.load_state_dict(retach_parameters(params_avg))\n",
        "  return avg_model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "csbPg_CLp30a"
      },
      "outputs": [],
      "source": [
        "#@title calc distance between model \n",
        "\n",
        "def l2_similarity(m1, m2):\n",
        "  d1 = detach_parameters(dict(m1.named_parameters()))\n",
        "  d2 = detach_parameters(dict(m2.named_parameters()))\n",
        "  \n",
        "  distance = np.sqrt(sum([np.sum((d1[k] - d2[k])**2) for k in d1.keys()]))\n",
        "  return 1 / (1 + distance)\n",
        "\n",
        "\n",
        "def cosine_similarity(m1, m2):\n",
        "  d1 = detach_parameters(dict(m1.named_parameters()))\n",
        "  d2 = detach_parameters(dict(m2.named_parameters()))\n",
        "  keys = d1.keys()\n",
        "\n",
        "  dot_product = sum([np.vdot(d1[k], d2[k]) for k in keys])\n",
        "  norm1 = np.sqrt(sum([np.vdot(d1[k], d1[k]) for k in keys]))\n",
        "  norm2 = np.sqrt(sum([np.vdot(d2[k], d2[k]) for k in keys]))\n",
        "  return dot_product / (norm1 * norm2)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The git_merge_many function implements the \"MergeMany\" algorithm described in appendix A.10 of the main paper.Considering a set of models, the algorithm removes randomly from the list and averages the parameters of the remaining models. Then it will call the weight_matching procedure \"git_merge\" for matching the weight of the average model with the selected one. After that, the selected model is substituted for the permuted one. The entire procedure is done until convergence, but the convergence type is not defined, so i test both l2_similarity and cosine_similarity. Both cases return me the same number of iteration.  Finaly, the algorithm return the average of the models in the list.Dettails over the result of this procedure and discusses it in the section [\"Multiple Merge\"](#scrollTo=XnZVLHZE3pDV), at the end of the notebook.\n",
        "\n",
        "![merge_many.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAvwAAAFCCAYAAACNcAkXAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAAmdEVYdENyZWF0aW9uIFRpbWUAc2FiIDQgZmViIDIwMjMsIDEzOjQ2OjIxIIDjiQAAIABJREFUeJzs3T9w4uiW+P1vv7VV6A220EboTda6kbURTGQ2gl8EN7K2aqvQjdBG6EZmI7MZmZnI3MhsBBOZicytX2AmMjcyE5mJrBtZs4nVkdXBFnJ03gD8H9vdPd3tbs/5VHm6jf48R4/UU0fiPI/eiIiglFJKKaWUepX+n5cOQCmllFJKKfX5aMKvlFJKKaXUK6YJv1JKKaWUUq+YJvxKKaWUUkq9YprwK6WUUkop9Yppwq+UUkoppdQrpgm/UkoppZRSr5gm/EoppZRSSr1imvArpZRSSin1imnCr5RSSiml1CumCb9SSimllFKvmCb8SimllFJKvWKa8CullFJKKfWKacKvlFJKKaXUK6YJv1JKKaWUUq+YJvxKKaWUUkq9YprwK6WUUkop9Yppwq+UUkoppdQrpgm/UkoppZRSr5gm/EoppZRSSr1imvArpZRSSin1imnCr5RSSiml1CumCb9SSimllFKvmCb8SimllFJKvWKa8CullFJKKfWK/cNLNj6ZTF6yeaWUUkop9Y0rl8svHcJX742IyIs1/ubNSzWtlFJKKaVegRdMZb8ZL/qEX0+QUkoppZRSn5fW8CullFJKKfWKacKvlFJKKaXUK/aiJT2rRJMJlMvYK5Yl4YwoXfzdsAs45peIKGY6HBM7Lm7hsQYTollEsogMy3GwjC8T22w8JYxTTKdIuWjzRZpVSimllFLfjK/rCX86oe25tEbJ6uXJkKD4Hd999x3BMP4iIcU9j/Kf/oN/KweM0zvBMJuEXH2UTttUv/uO776r0gk/f1zprIdrOxT/+G/86T/+xB//9Q843ogP6ZVkNqIXFDHfvOGN6fFYt5NO8K03vHnzBtvtMJw9tuLXICUa92hVLd68eYNR7j3eJ7MWzps3vHljUW4OmH6ZS0oppZRS6ov6qhL+ZNxl9PYdo+5wZZJmFl2K1peNyXQcrAxknSL2rcfn0cCj2p4sn+qbONXV30p8FsmY9sCkGyak81P2KlkAfv2xy+gDklaz4BJ021QzwLsRnUG0cr141GWcZoB1gk4L79FvOr4GBnY1oNP2WAMu/9alO1u1Xsq4OyTOADmXdtf/4teWUkoppdSX8BUl/DHD7ph3PJWkfXlGuUeUzEmmTZzlZ8kkoBr8xNsXi6pAs+MtbkAMB98vkwHImJgfWtNjgFGsUMpd8nO3wzS9v0LIYGDgVc3FytdSokkXv1ykWPVpdTp0Oi1azQC37NILAWKmgyZusUjZDWi1mgS+T7M7vi7NuiMJGbY8qq6H32zRaQX4vk/VHyxvAN+nzavjMnAqJdb4O73OiAffScRDerGL5yzWfbTb4gFBZ7piQUo0XsRSbo7v3KDG0wHNapHq8luDNBzRdIsUi0W8zpjwKphkxrBZpeg2GXzV35oopZRS6psmX4vTXanVapIHASTXOJL5g5WOZWttsby0d7787EJO9reltlmTxlZdNis12drekZ2dHekfXyzXOZfjvS2p1xuy1ahLfWtPjq82PzuU7XpNarWa1Lb25fTsQLZrJcmXGnLwy6HsXC2r9+VERObHW7KeWcRANi+VWl32TkTkbFc2QGBNto5OZH9rUzbyeSnV92QRxlxO97ekXlvsb+fwTI736lLKr0u+VJf+yVzk4lj2GhXZyG9IZWtfTh92wApzOd5aFzJrUuuf3nx8cSy7mxuysbkr192w0qHUK7tyuJMXyEpl//zO0vlRQyrbx3K0tSaQl53T20svZL+SkczmwZ1zdXG4LbvHV78dSSOHbOyeLXd4KrsbGclW9uVOSxdHsrWek/zW0Z3Pzw8bkt/YkZtm36dNETnZlsr2gexVMkJmQ66av3K6U5H64Yns5BHWtuRYVjvZXheyNTl4pA+PGjmBrJR273SMHG9XZPvkdoN7Usoia3eu63PZr2/KvU2VUkoppT6prybhP96uye7pufQrmWUyvSn7D5Kshwn/6e6GZEDWto5FZL5MwDKyXtuVg5MLETmXg9rtZPVEttcR1mpysMwsz/dKizZzeSlVSpLPLtvon8tFf7ksW5dDERG5kMN6bvHZxq6cXlwsErjrhD8j65Ut2TvoS3396ublKp08uY4/V6rL9t6+9Ovri32tVaSxtSP9gz3ZXFvsJ/9MJjg/O5K9xoZkQSAr+cbBdbI8P9iUzDKezf2n7hwWCf/Z+b5sZhHy95Lr2qbsnc3leGXCP5f9zYxkagd345rPbyW1x9LIZW4SfhE53ckL2dqyP2V53taE9W25nSNfL+vvy9mt359vU5YJ/4lcHNUlB7LWOL5ZPj+SRmVHTuanTyf88yPZbmxJfS0jG3tnq9aQ462GbG9vSCazLo2jmwv2bHdL7m9yvr8pWdZl63gRycXhltT7q/erlFJKKfWpfB0lPemYQVTFcyy8pkcO4N2Y7iM15TdmDHo/cwnYjg0Yyz8viRKTcsEknbQJfvwVsgWKDoBDuZCFX3+kuSzVMK7qYBITfzBhOjtgd6dPx7UwDGNRLnPNxLxa3zAwTfNeOYhFtd0lcH2a1TUA3s6mLI7EwFqWv5vVFp3Aww/Ki+P9NaXQauG7AUExA1wS3hoUvIphmli2g5MFeMcv/+3h9ZYtFX28fI5c3sMvv0edj+XS8tfgly6dq9HJ0YCh4ePZH1AnFA/pDuMnZguKmIwjssXqdYkUTBmOfmWt7FJ4eJSUfe/p8RFPtGmWWzTz8OuwfT0oOR71iD2fwjOHlYxG4HdoNwvMul1WVpkZBsX2iKGb8N+ezzB6fH+W16O3mdDzW0zjCZ2hQ9t/8siUUkoppX6zryLhT0YDUtfFAoxqE28N4JKfe48kWdcsHGuRjt8kxou/XaaLv4XjyaLW/joxN64T/F/HE+5MqGPY2BYYtkuz5VP82LGpV4mkYdwOaeUqsKJ+/Gq7J9N9wCzgtgZMoyMa64ubhOloOZDYchnMYuLZAPe9BqMaFJtNNjJvGXaGxKRMu2Ocpstz3XA569FsNmk2Azy3tWK2n0uiUYem71Is+EyKPaZD/yaJTyKit2A5dwNNoymDlofr+nRG4Z06/OfbvOIQtDbJvvuJTi8EQoZDk8B7rlMihhMbv2hge03K8ZDOo41YuIMR29YY3+swe/S0WXi9Hm7yF9xyD7sdfLmB3koppZT63foKEv6I4WBGNAzwPA/P6xCZucWivw/pjp9Kei28bpuNLISjEVESMhqFkFmn0VrcQKTp1cT9xq08/CoRjx8O5vwWmWW6XZfFXD1PDEB9ju3TcrNc/q1DdzKiF7k0Hz5yfyBTCOh2u3S7PYaTAcGDXDqD7bZoViEKE2zXvfsOBcPEyEAS3z3Xhl3EK6aMxymO69y58Xi+zRum22Lx5UWH0bjHuNik+lwnzXoM45jJYMBgHGNZbx+dPWoRbJHOqEc5/C/c4InpUS2XwM2RmEWq9jMxKKWUUkp9Ai+f8M96jOwe49GQ4XDxMxp3qGQA3jJ8KskCjEJAr1OjaEaMBmMMb8hxNKNXXaSHTsFZlOSk6c2c+cnibxmneKus5BuSJkTR3VsVwy5gk6HolZcJf8y016LVm3zA3Pwmbitgnb/TddsQ+HzwTJVGGd+zSZPkwfcTtjdg6Kd0XZ87r1EwilSLGaLpw1gNw1jMJPSRbV7tv9ncIPN2iB9EeP5zZz1lPEjwOwHVcply2aXVqWM9N3uU7TMcNTCGPv6ytEoppZRS6qW9cMKfMu6Osa+T1CXLxSsvSnUuf+rcSbKuHtiny//OWkWKf55h+z6u6+G6RZxbc1Oa7rJEKI5Y5MgxUfQWWMNvLctVbmWJzxTRALeSzzgijif0BveywCd2krxPA+m9P+8tHPs2f/jDP2G7vevykXg6ISl16fmLFD0dN6n++Xu+/7NLc/REo2lCEt/6pqPQpFXKcGm5NG89Bl/cJK3Yz8rpNSe02uPrcwSXywUm5e6Qtj3Cd2+Xvlj4nSbOtE3z/osEVu3/2TaBJCaK4+vfbb+Fm73EKDe5qeZJF+fj1s0gANGAAR6eY2Pbix/HbRHk/86gM77zrVCaJtfXJIBZ7jHqFIj/Hj95LV0+sUwppZRS6pN6ufHCF3K0U5IcGVnf3L4zhebR3vZypprFT2a9Jv2TCzntb8ra1WcbW3J0fi57pZv1bn4yslbZuZ6Ocn7al9p6TvL1Pdnfq8l6Li/1/dPFrC3nh7K1kV1ul5PS1r6cXIdyJNu3lm32F9vMj7cln7mKrSGH52dyUM8vZ8VB1muL6T3r68sZhzJ5aRyeyWm/dj2lZybfkMOzUzmoLWfpISsb20dydtK/OfZcRXZXzKl5tr8pa1f7WStJrd6Qxs6BnN2epuZkZxFjJi87D6e+WZyBkwPZra1LhpyUtvvXU5XOj7ak1r+et1SO+ttSyi3aW9u8mv1oLmdHu7KZQ8iVpLGcCnV7qyaltexyVp5zOenXZR0kW9qWg9PlsZzvy2YOyVV25PBW0BcnfWmUNqRU35a9/r7s7+1Io1KSze3D5exD79PmXE4P96SxkRWyG9LYO7rul5Pt2s0sQ+fHsr9zdT3lpHJ1/BfHslvJyVqtf3MdyGJGpO2NjMD68tpZxrKWldL2gZzeOU3nclCvPZilR+RCTo+WszdlS7J9cCzn7zX1qlJKKaXUx3sjIvLF7zI+oXTWpVptExpXg3JTkvgt7y5hY/eMadO+WTcOiVIT27Y+vs79ShITxmA7n2BfHyONCcMYLAfHWh1BGofE2NiPLP9qJTFRnID5DcZ+LSX9LeMplFJKKaU+kW884Z/StMuM3QmzbvEmuUonBE6VsBUxeWo0p1JKKaWUUq/cP7x0AL+NiW0ZxJMBo6lJ0TYXT97HA8JCh66vyb5SSimllPp9+8af8AMkRNMp0zAiScEwbZxCkaLzsZPoK6WUUkop9Xq8goRfKaWUUkop9ZiXn4dfKaWUUkop9dm8aA1/u91+yeaVUkoppdQ3TvPJ571oSc+bN29eqmmllFJKKfUKaHX68170Cb+eIKWUUkoppT4vreFXSimllFLqFdOEXymllFJKqVdME36llFJKKaVeMU34lVJKKaWUesU04VdKKaWUUuoV04RfKaWUUkqpV+xFp+W8L42mjKcz4gRMq0CxXMQ2IZrOMIoFrOV6SThiNDUpe2Vs40VDfmEJUZhiORbv1Q1JRJhYOF+o05JwSmwWcazn173ZJiS1HazPGmJKNB0zjdLrT0ynTLXwAYF+A5JwwmQWc3WUhlmgXHUwXzQqpZRSSn1pX8cT/nhCx7UxC00mFKi6VRxzRqfqUCgXKfs9ouuVJ7TK/8Z//Mf/we1Fj+7yy4uZDDq49hvevHlDoRM+umbUK2K8ecMbs0jQm3Ar73xv0aSLa/8Tf/CHxM+tnIaMuy72P/0Bt/d4XJ/WlFb5XykEI97r8OIJXdfmn/4lYJR8xrCSKV23THNqUfU8PM/D88ow9Cl6A8KPOBdfn5hxq0y1E+G4V8foUki7uOWA0bMXjFJKKaVeFXlpF4dSX0MgJ7WDi3sLz6S/mRNyDTm+9dleKSuwJvXD++u/vNOdvABCri6H81VrnMhWPisZkMzmgaxc5T0d1rPCxq6cvdfax7K1hqxvn/yGFj/MxemxnJx/wAaHNclQkr2ntpmfyunZx0Z0KrulnOR3VvXBhRw11iRXO5APCfnrM5fj7bzkSnsrr4vz/U3JrTfk6Ov7p6OUUkqpz+SFn/AnjAOfH34F1lya7v1iAxu/12XTuvtZMEmYzyMG1a+vOMEwLEqVDTJvh3QGDx+lJqMus6JHcbHy+5XiPNbWZ1z7UzCdIh9aJfN0lDEj3+OJL0+e3nrQpD0r0g4KK5aalFtN7FFAa/wNP+YPuwTdGLftY69YbHltfAYEndmXjkwppZRSL+Rla/jjEd3RWwAyhTKr0jAsj27PXiaCKeGgRXu8SKRtv0fbHtFqj5dlLQa226JdTRi0e0wSC6/dwbUhnnRpD2YYJsRpkWYnoGhCNGrRHkakLJOhtEe7NyGiQNDpEhQXNxVpOCAIesTFNoNOlafyWNtvYU3/jR+7XWZB59ZxxQwHKX6nzOC///vhhknIeDQhjCNiHMquR9W5nQInzEZDJmECVgFzRV6ahiMGgzGz1Kbo+njl96zvj8b0RiEpBnbVo2rOGA5nJIBhl/HcAmYyYzicEFtVAtfBeLK9lHg6ZhhZBF7xJoZ4ymA4JY5TjEKRctHBNg0M07xZJ42ZDroMJgl2NaDpFTCIGQdVvB9DHKNDNyzgNqvYpISjIZPEwCBdxFq2Vx0gw95PpIU+5cfuE+0qZfs/6fbG9KruC9wi/XazQY9fjDLt4mPRF6iWTb4f9Jh0epS/ZHBKKaWUehkv+v3CYV2yIIDkGkfvudGxNHKLbTZ2z0RkLseNtUUZTbZ2XUYz369JafdMREQuDuuydr3+ufRLGcnkt2VR2HEqO/nF/rIbNdneO5B+Y31ZltOQq6iOGrnFZ2w8WXJytluRxuFcTrbXBbJ3y5ROtqXSOJL5RV9KIJna4a0N96WWL8nuyeIAzg8bsp5dk/rBVWNnclDfkM29U5mLyPysL5s57pT0nB80pL57LBcicnG0JeuZnNSutz95pqTnXPYrWWFt67p86nQnLxkq0r91CEeNklzt4vH2LuTkYFtKOYRKX643P+tLZb0mB4sNpLGGkCtJfasvJ3MROaxJlnWpNLZkp38g+zsVyZGT+vKkzk93ZWPZp/P5sp/6m1LaOV3uf08264+USc0PZDOzuM5O+juyd3Aoh4e3fg52ZPfgTPYrmTt98G05l70Swvq2nBzvyU7/4N4x7sv23pGc7m4I5GX5z0MppZRSr9yLlvSkya0ZRIz3fZ5qYJp3fy+2mmxkgHdjeuMESBhPTJq+DUQMWj/wK1mcgg1Y2I7J5S8DetPF9ldNm8UmncDFD1zWAd7OmEWLZQXPYyOXZX0zoPxsmYpBodmiknnHqDNYDjhOGfdmlJvlFU+OE0bNgEmhRVBYLLWqXbpuyg9Bi3EKybCJPy3TDhZP1g3bIyhnb3aRjmk1I4pVmzSOSW2Xqv2WHzvDWwOen2Lhtlxyv44ZLas9nKBJOTNlNLkaRTtjnHoEhefaMym4bYJi5k4Ls16HiVmkYAJmmWaQB2z8rk/hulMMys0uLd/Fa7Xx1t4yGS9qeAxzWQJlmNfXy2wyJQojEgDbp+U/cnLShPRyeZ2FQ5qei+ve+vHajBMW10KSvN9A469OSpoAhoWRzugG3r1j9OlNkmXfpcSfc3C0Ukoppb4aL5rw3y7jSJNbKVYyY9gJcMtFisXFT9kN6E0fyVBsn2Y1C7xj3BsRxyNGhkfVBJIpi3wxZdrx8X2f7hSy2ZQ4vLu/65uOm9oS0mVYZrnLNE4IRz7O+xyc5dHyclz+3KUzTSEeMkh8gpUbTxlN3mE59q2bAYOyVyb7dsJ4ljIejkmd4q22b25UAJiNGCcp4WTMeDxmPIkotPr0m8X3Lk0xyk28tb8zHEwXH4QhsZEy7o1IgHQyIKl6i9rw92jvfrtpmnIZhdc3ILZjk3mwlnnrhs7EMiFNH89Mi14VfvgjTrnJMIRi+ZHjNS2sLCRJguUNiNKU9M7PjE4BkvQSLOvO1JXJbEir9b43Ti/JxLIykMYkdsA4vn+MCZOWQ5okgIl9594oYtz1KVoW7q2xJ2k4ouUWqQZdxtEXPhyllFJKfRIvW8NfqFLI/MjfLuFttHhKawKYBbxWDzu2+de//Aqss33SY+VYSwBM3KZL7q8/8HbSo912cILBIvFLU9LLxVq232Pg3U8HP9djToNyq0n+h/9i2BniFUdYwXD1HOhpSpJCcu+Rq2FZmKQkaUwcX4L1+HPnNI5JsKj6PtWPLj4vEAR5et0ek45DMohpDXxa3oBh5GINwe2aH91eMWhRGrTo9JoUA5vZJKbYav+mOnKzOmByaOH73/Onfxky2B0zahZWJP1FqsUMP4QhaaG6YkCrQ6EwpTeDnFtdjrtICcdDZmnIdJjidryVA2G/HibFagFaMyKzg/fgYjMoFGxGnQjW739TZVOtFpnF0Ot0mHpdigYYjotbjXGDYDHQXCmllFLfnJedpcdyaXm5xd9nYyb38lnTuspYFk96n2KUm/jrwOXPDGYFvKubA8vGzgFcEk5/w8wkyYxhp0X3PR5zXh+GE9DazPLur028cZmg/EhmbDg4Nvw6nd2dUz9JSDIOZcfENDNczqY8dgSGZWG+mzC814lpOGH6AfOuO35AMRnR63YYmk08N8Czp/Q6bUamd53cf1R7TsCg52OHI3q9IbE3YtJ89C7uvURhiF3tMInOOGhYTP7To7tyFh8Tt+WzNhsyilbvK50OGCd5ms3y8hMDp+rjlR3eu+Lshdl+i5o5ZTB+5CQkY4ZjqLSaD76piqfgtNo0zSHt68n6I0Ls1QPqlVJKKfVNeOFpOU2q3SFb6xl4N6Ldnd2rnX7kifbKjwsEwQaQoRzcfhJbJPDWAPh10KIzTUjTmGk3oDW5+0T9qnxn1f6nbZc//df3/Kfrs2K2zWtJHJNclyeZuC2PNaAY3CoFStNFE1d/4tBsVcjOegxuJavT0RTTb+NZJlWvTPbXAe1euNwmJoxSSOLFdxQFH3ftLT8EHr1ZwmKWnB7NQbIs3XjPqnTLI6jCj+0p5WaBRb8W+OW/Jzj+rWe8z7a3bPF2pdYkwB+XabWbBIGPW3xYb5/eKqO61V0LxmImnsU3IQlJCmGvxzgFDBu318XLQfLIoRrlLsNmSrc5eFiek87oNsfY3SGt96rZAggZ+C7NlW+ySpn1fPzOZPV3SPGYlhcwXHlzEjIMPJqP3Jkkkxae12W66jhNl97AJWq3eJjzJ0xaLablHoMHYx0SpqlB0bQJ2lXCdndxc5lMSc33LwtTSiml1FfopUcNi4jIxYn0GyXJZbKy0diTg6NjOT7ck9p6RjLZdak09uV0LiIyl9P+pqwtZ/bJ5Lfk6PaMOed9qazVHr7wan4ie5trklluR2Zdav3FbDdnB3XJZ5afr9dk//RMDurry3Uzkm8cyrmInO2VFjMKrTXkaOU0MGdy1N+SUg7JrNdk9/B0OVvMmezVtq63uTg5kN3acv/ZDWn0j+RsLiJyIce7m5Lf2JTt/r70dxpSuz5uEZFzOdwuSS6TkVy+JJXatmxVcpLLb8pW/2QxU87xrlTWMsvZhLKyXttbzH4zP5Ojfl3WQTL5huwfP/1qqflhXTYaRzez3Zz3pVJ5+CKnR9uTCzk93JFKDiFbkZ3DU7kQkfODuqxd9TUImazk1iuyc3Qhcn4se7U1gaxsbB/I6cWFnB40FudmvS77pxcicib9UlbI5mVzObPPYX1N8vVdOTg+lsO9htS2j+Tpd0pdyMleXSqb27J/fCYXF+dyerQnjUpFtvZPV8/wc9GXyvqKmXvmR9JYy0puRd+IXMhBfe2RZSJysiMbuXVprLqY5keytf7YC8IW12IutyaNw5WLRUTk/GhHapWa7BycyNnFhZyfHMpurSKb24ePvFjsSPb2lrMdyansbuRkc/9C5od70l95AEoppZT6VrwREXnB+4270phwFhIlKYZlY1sW9nO1PHd3QBynWI9tk0SEUYrpOFgf8cgyiUJS6+O2fX+LJ9iG9cj8+WlCHKeYtgVpunJ2ozSOSUzrN8SZkqZ3BwWnKY+Wtbxve9GowxAXvwBxnJCmKUk8YzBMaY9a7zcYmpQ4ButOYylJHJMa9rOlX3f2E86YhQlWoUjBfmLDZEC1OKMddlfWsc+GQ0zvC9f3JyOGUxev+vRqaTxjOovBcigW7Mef1M969JKAoLzc/djDadm0fZtCU+v3lVJKqW/Zyw7avc+wcIrWeyZ+K3dwLxG8x7RxfkMxsml/fGTvz8C0npj30zCx7Ku/rz5Ww7KefDHY+8Rwf9dP1bC/V3thF68Z0YkcLLg5BhzSZLJ6MPMjsT3sHgPzZofvvx+nSPU3n9KQEAfvt+7mAyXTFPM9rmXDKlB+5qYAIJ6lWO7N72a1TbNVpD37FmYnUkoppdRTvq6EX71ehgHxAL9q0PSK2CYk0YxZZFFtNn/jDcrnE00GjKcjojhm0B0Ql13cws3tSTgcY5SbXzaoZMIwdnjslQMfZvFW43Z3gk2Zsl9Y3nw5BG2XMNH6faWUUupb93WV9KhXLY0mDIcjplGKaRcoFMtUy84HPN3/+qSPlFV93kYTUsPURFwppZRS70UTfqWUUkoppV6xF56WUymllFJKKfU5acKvlFJKKaXUK6YJv1JKKaWUUq+YJvxKKaWUUkq9YprwK6WUUkop9YrpPPxKqU8sZTZo0hmGRKmF67uYcYTltXDtl45NKaWU+v3RaTmVUp9YRBhZOLYByYzRKMKqVik+9RZspZRSSn02mvArpZRSSin1imkNv1JKKaWUUq/Yi9bwp9GMMFmxwDCxLBvL/HKxJOGMKF02bxdwPlPbaZKAafLaixvSOCQ2HOwveA4/TEI4nRIlJk65iP3aT8gXloQTJrOY5T8pDLNAuerw1V4OSiml1Cv2wk/4U8KBT/G77/juu+8oel2msxmTrk/BMrAKHt1J/GVCSYYExUUcwfBem9GE6ScJI6LnVumGn2JfX6lkxjAoYv1/RdrTlw7mEcmEltchNGDSLuNUe3yhq+x3IGbcKlPtRDiuh+d5eJ5LIe3ilgNG2tFKKaXUF/eiCb9hF/GaPs7yd7PsE/g+zd6YoWfy9pcf+c+q+0USZLPoUrRWLEinNKs+g08Rw6xH728/0+tOrp98vjpmAa/lXZ/TTy4KCX9j54W9JgOjiluo0hlPGXc9Vp36b19CGH7JDDtl2qriTz2GAx/n+lsTA9vtMQxignLAZNW3ekoppZT6bL6KGv6H1RQGTnGZMl7+zOhLPeW/Lw3puS5/+funSM9Txt0ZdinHr8MuI016Plwyoem2mP6m05Ewm4Q3F51ZoFx4nYUm0cCbJlh0AAAgAElEQVTD70VfrsGwS9CNcds+9orFltfGZ0DQmX25mJRSSin19c7Dn6ZXWV0W63Yxfzpj2O4yTkyMNMF027RdGwNIZj1anQmpaQIGBg7NXpWw2WYYp4CN3+tQmHZoD2YkAIWAQau84qYjYuCW+fNPb4EM47aLVwzodqpYyZSu32SIR3fQpPg++WI8ZJD6DLozyt99T3cQ4TXt53qBaDpiFNr4nsV00GM0g2LQwi8YRJMhw9GU2PFoBeVbT6lTosmA4WhGbBSoBj7VZZF6Gk0ZjWOKns20N2BmB3Q8B9KI8XDELI7BLFIsF3AsE/N6vEHMdDBgOI0wnCqe73InT44mDEZT4tTAdp6/QUtmQ4azFBNITYeqW1zG/0jsyZSO6/KXXyw2O12SYpXAdVaOhUijCcPxjDiKwS5S9ZaxJlMGgyHD8JI0GdDpzjAdl6D68Dwk4YTRJKXs2cyGA8ahSdHz8W99DRTPRoymCSQhqePju1c16inxbMwwtAmKMb3uGNPv4BeMx7dJY2bjEVPDxS+EDAcjprGD1wooWzHT4ZDhJMJ2mzTvxLv6vERDj2rwE3HBptOdUfQCytZT5/HxmB8/V3fNBj1+Mcq0i48NiChQLZt8P+gx6fQoP355KKWUUupTkpd2tisbIIDkGkeLz+bHsp3PLD6r7Mnp/GrlU9ndyArZuhzORebHDVkjJ5v75yLn+7KZzcjG3tliF6e7UspvybGIyPGWrIHAhuyeiYjM5bCeFUAo9eVCRESOZWttEUdp73yxj7NdKYFATuqH53IxXwQyP9iUDAhkZHP/Orgnne5uSuNoLiJnsreREdYacvzMpufHfamvI6xtytbOnuwfHkq/tiZkK7K1syO7+4dyuL8lG9mMVPrny60u5GirJtuH5zKXCznZ2ZBMtiR7ZyIXJ32p5zNCriT1rS1pbOZlbXNfzuVEdjbyy/jOZX8zJ7Amlca27J+KyPxEdmoN2T+bi8xPZa+SlUx+R07k6nTtSKm0JUcXi/aPt/KSISv1w0c7Q0qVPTmX5b4rW3L0TOwic7noVyRDSfbOLmT+SN9dHDYkv7Elx1ex7GxINrcp/bNlrBcnspNHcvVDuZjPV+7nup+yG1JrbMnO7q5sVdYEclI7WPTzxUFNcuvL62t+LFtrWdncvxCRCzk92JKNLJLZqMv21pbUNtaktHv65DYnB1uykUFypYbs7Pbl4HBfGvmMZDYasrOzK/2DQznYqUguk5ed06uOf+K8zI9lax1ZaxwtjvPJ9R+P+fFz9eBqlb0Swvq2nBzvyU7/QA4PD29+DvZle+9ITnc3BPLLf4dKKaWU+hK+qoQ/k6/IZikvuQxCJi+Ng9NlMr4wP6xJFoSNXTkTETnfWyTkpT05P6xLFiSzsSWHZ4ss7vTwcLHe6bas30n4RY4auWcTfrnoXyf8V/ciIiJyfiD1fE5y+bocnMvz5seyVdm+TpAv9jclS1Y2Dy6e3Ow6zvyOXOV4i2PJSv3wKlO9kH4lI5naMrs+2ZL1jR05OTuX8/NzOTvZkQ2Qta1F6yfb60J2U+40fVSXbKYi+1efHTdkjXXZXgZ8trsh+a0jOTtf7PO0X1km9HMROZHt9avEVa42kPwTCf98vyKZ9a3rG56Lo6NF3zwT++JGqyL9x7ptfiSNtYxUbsciJ7K1jmQr+8vzfCa7+Vs3l4842V4XcvVbye2JbK9zfS7O9iqS3+wvri+5kH4pI7nG8XLdc9nbWF6Xt/b59Dansr1+N67zvZJw+3jnh1LLZqSy/OD584KsbR1f7+/p9VfH/Oi5emDRr+R35fSoIblMRjL3frK1AznbKwm3ri2llFJKfX5fVUmPWWzSMluU/wYQMpkmGO7N8nAy5R1ANKTlzzDSiDibJRuHRIUyxewP/PTzX/jjH4Zs1Nt0uwHFzxGo5TKYuc+vt5SMu0ytKu5kwgTALFLI/JVxZ0DkNlfWOz/KsDAxwLgqmzAwDbhMYhIgHk+I0iLTyXhZ7mIR9PtczY9pmIt93JnyNE3hMmIWg2cCdgE7M8E0AGLGoxmpNWMyjpYbePT6HpYNzIaMIgv33jymT81yaZQ9yvF/UHZC2r0ezWqZAhA+E/uzwhHjX02qd9Yv4FXX+EtvxCT1cD9k+k3j9vSpBXx3ne+7U2YpeMGYWbAskZpMGceXpPatwQUGZCzrTumL/cw2pgGGcdOiYRqQMW6dagPTuCRMEiB9+rw88Mx5fCTmx87VQyaWlYEoJrEDxnHvbskXKbNZRDpOABP7dY6SVkoppb5KX1XCDwbF9oDmuMj3v1zy9+99WtUZ3fKy/jxZJkdmmdag8yDxGI5jPK/NT7++5ecf/kx5FjGdPlzvy4oZDmIK1ZQwvJrqx6RYzvG3n7p0p026n/CuJIkWNfie77//nOflJkG+yrA9ojl0MaZTkmoLzwFISBIwqlV8f8XcO+OY+PIDg7R8RlODph/wX3906NV6jAf+x8V+W5KSkpIkKbdvOSzbgk8wL5LpLLJUAyCdMWh2mJVbtH2fZNBi/NwOPmabRz1zXn7z+kuPnCvnwY2TSbFagNaMyOwsbhzvMCgUbEadCNavxhMopZRS6kv4KmbpucMo0B40Wc8A/J2/+DfT+NkFe/GXaMbs/rjQcMLMbjGOIo77DTaycPnLiOFnmdIzZtpr0epNnp+/fdZlaLboBgHBrZ9Ot0meXxl0R3zKCXtM2+JyOmR8L7B4MiF6bCOjSHvYoWpOGXR7jGgyGV3NtLL4NuCX0fje9gnTSQimiUnEbPb+R5GGIbHj0ZtGnPRdjFFAMIg/LvbbnAJO5t1iFp7bkcYJGae4Ikn9MEmckCmUKRgJ46BKM/HoeIX3vDn5mG2e8sx5+c3rLzx2rlax/RY1c8rg/gm8bmrMcAyVVvPzTduqlFJKqQdePuFP0+tnr1cz8xiFNoPm+uLDX3/AC8YkgOUGVLLA5U+0WyOiFJJwRDMY8EvYpdmZkmJR9HuMOhuQsRbVIKa9LFOIiWIgDZldveL3TvvLP6+DMzAyAAlxHBMNe4wTSMdNqn/+nu//7NIcPfXkOGHUHuH4K2YBcnyCUoZ3ow6D6AO7jPTRB9aO65G//Imm12ESp0BCOGzSjuxFAn912Lc3iof4QYjXbtEMAnz3dkJqUvWKZH5u4zXHi7cRpxGjVoupaUPBw1275KdO6/rGLI1CYlKSdHWQ6axHb7bYd8Ef0C4vzv1zsRuGgUHMoqIleXijZHm03Bx/H/ZuTd0ZMpkkVFtX73tYnO9HQrsXaHKrn0JGwxi35WMTMZm+JU2WMcRTptEl6a1r6aqTb35/fpvkfkzp9X9WfPTMecHEMhY3KSmQJMYz66+K+fFztZLp0hu4RO3Wg5s2SJi0WkzLPQb+rfmkZgNareFvfreCUkoppZ7wkgMIzo/2pFFaDp4FIZuX2vbBYoDq/HgxSBIEslLaPpJzETk/XMwmwnKWnFxpW44uFgM6c2sbsrm1K/39Xann16S0e7KYnUQu5LCxvphZJ5OT9VJdGpWcZDI5WctXZOsglNP+5nImn8XA36NzkZsZaxYDdytX+zvZkfxyYPHOo4MPz+VopyI5srKxtS8ndwaazuXsqC+N5UxE2Y0tOTh9OF3M+cn+YpaebEm2D0/l4uJUDrdLkgVZq+3J8dmFnB/vyeYaQm5Tdo/OZC5zOe3XZD2z7KPMmlR2juVCFrPPLNpck9reoZxexXTWl0qOm/NARrK5vNT2rvrvTA7q+cWAaZBMriRbhzdDO+enfamtZySTXZeN0qY0tuuSz65Jqb4jh2cPe+aivylrpYbsHR7L8eGu1Gu7y0Ghj8e+2PBAajkku16Rxt6xrBy7Oz+Vfm1D8pUt2dvvy+5WTepXxzE/k+P9xuLcrW3K7uGJnD8y289icHNeNuuLWXq2a5tS758u+2MuJ7sbkgXJrm3I5ta+9Ou5Rbzb/1d+PtiWUhYhV5Gdg5PlINjntlnM0pPJb8nBybnMz45kt5JbXHc7h3J2cS4n/bqsg2RL23J4evHseTnZyUsmk5ON2rYcnM2fWP9CTlfG/NS5etz50Y7UKjXZOTiRs4sLOT85lN1aRTa3D+X+GPfTnXWBWzMPKaWUUuqTeyMi8hI3Gr9NShyGJIaNczVAM4mJDQsrjQmjGMN2sM27z9WTKCTGwrFN0iQB03xycOlVW0kUkZj2nf2lcUiMjW39xjqRzyYljhMMy3q2fCQNB7THNoFnk8YxSZqSJjHT3hirN+D6gWyaECdgWqv7LY0jEsPGMlNSjGf7No0jYqwVffhE7GlCnJp3Bx2vlBDH3H2HwweYtRy+G1Y5DtvYcYppWw+OJ41jUtNaDm5OiGMD65nr4WO2edYT5yWJE4z7nz9zHlfH/di5emqbGdNZDJZDsWA/0lbK4p/i1/rvSCmllPr2faMJv/p0pjSdAGM4o3NvdHM06BG6AdXX+SLaJ10n/FH388z0pJRSSin1hXxls/SoL8/AIKTrudB0KVgmJBGzWYTttgl+h8k+LOvUk4R7E/4opZRSSn1z9Am/gjRkPBwxnkakpkOhWKRaLWL/ThPdeDpgMJgQpgZWsYrnuhR0GkmllFJKfaM04VdKKaWUUuoVe/lpOZVSSimllFKfjSb8SimllFJKvWKa8CullFJKKfWKacKvlFJKKaXUK6YJv1JKKaWUUq+YJvxKKaWUUkq9YprwK6WUUkop9Yq96Jt2//3f//0lm3+19NUKn5726af3e+zTf/7nf+Z//ud/XjqMV+fNmzcvHcKro3366f1e+7Tf7/OP//iPLx3G796LJvx/+tOfXrL5V+v3+j+Vz0n79NP7PfZpJpPh8vLypcN4dX6PN4+fm/bpp/d77dNMJvPSISj0TbtKKaWUUkq9alrDr5RSSiml1CumCb9SSimllFKvmCb8SimllFJKvWKa8CullFJKKfWKacKvlFJKKaXUK6YJv1JKKaWUUq+YJvxKKaWUUkq9YprwK6WUUkop9Yppwq+UUkoppdQrpgm/UkoppZRSr5gm/M9KmE1C0pcOQymllFJKqY+gCf8zooFHtT0heelAlFJKKaWU+gia8D8hmQRUg594+9KBKKWUUkop9ZHeiIi8VOPJpEurNyUBjGqLjj2h2R4QWU0GQx8nnTFsdxknJkaaYLpt2q6NkUzptbpMEoAiQdNg0OoxSy2KfptOUMRctpFGI7rtEZFpkiZQbXXwHGPR/mxIpzcBA6IwJLVdmu0mZQvSaZNC+S/8/RLI5qlUC7itAUHhRbpKKaWUUkqpjyMvai4HmxkBJJMvSaWUlxwI5GXn9FR2N7JCti6Hc5H5cUPWyMnm/vliy8OaZEFgTSrb+3Jyeihb+YxARvLbJzIXETnfl80ckqn05UJETnfyQqYke2cict6XUgZZaxzJXETmR41F22tbcjwXEbmQw3pOAGFjV04vLhb7VEoppZRS6hvywiU9Boa5eNp+SZXuZMbsaI+dvS5e1Kb98ztwCjgGGHYBm7f8tTciBgzDYLGljdfyKDhVWkERuOSXXodJCtNOi7++BbtQwARsxyZz+Td6wxCiGdEl/DoZEwKG7WAD/DphEgGYmMvYMAxM01y2p5RSSiml1LfjH146gCsZ28YGjHJAqwyzls87gGhIy59hpBFxNks2DokA63rLmzTcsi0ywOW7kFkUYUx/BSAet/FjE+IQI5slDiPSVofJUZXYLmLNxvQGI6IvdbBKKaWUUkp9IV9Nwn9fmiwnwjTLtAYd3q90fvHU/5KUhBTzai7NQsBgUF3RyIxO1Scsdhj4Vay//E0H6CqllFJKqVflq52lxy7Yi79EM2bx+22TJvFivvyMQ9G2sO0MAO9m4YOn98nYp/jH/+KvSZVez6dooZRSSiml1Kvz8gl/evPn7ZdbWW5AJQtc/kS7NSJKIQlHNIMB4Z0dRMzCFEgYj2ZcAjkvoGyYVAOXHMAvHZq9kISUaNwh6M74ZTxZPM1PE+IkJZpOuX9fcV0sFEfE8YTeYPaJD14ppZRSSqnP60UT/mTSoTN5B8DltEOzdyvptnwGwy02svDrD//GH/5fAyeY4nZ8nHv7CXsu5WIB78e35Cq7jLtVTMCs9hjtlMhl3vLXP/8L//TGwh05tJoFNjyX9Qzw7q/8qVCmS5ny4u6AXmtxU+F4HvkM8PfvKZaH2FWdk1MppZRSSn1bXnQe/veTEochiWHj2ObNxxMf6//8wFsq9C/GeGlEjIVtrZhLJ02IoojUdHBuL08iwtjAdqzF0/wkYhYbOFe/AyQxYczNOkoppZRSSn1DvtpBuzcMLKfAcyX2hrWY5Wf1QhPbWfF03rRxzLu/F8z761h311FKKaWUUuob8vI1/B8pDmMSAEKms+SFo1FKKaWUUurr9A2U9KyQzBgOp9yk+QZO1adsv1xISimllFJKfY2+zYRfKaWUUkop9V6+6pKe0WjE//7v/750GEqp3yKNmEXp8+u9ShGzUEsOlVJKvayv+gn/H/7wB46OjrBt+xPsLSEcj5lECYZdxK0W0LG4Sn1macigPcFpBxS/+WmuUsLJmEX+bmCXq3cG+afRhPEsxTCANMUsuhQtCAdNxk6bZvED/o+TxoRhfP1uEtMuYOv/sJRSSn2kr/oJ/6cTM3Qd/uWPHaKCw6z5HbY7fPCirU8i6lF1qvSiz7FziCY9gqLJmzdvMJ0qnufhVosUClX87pjfy4PUNBzR9RyMN294YxVxPRe3XKRQrOJ3fj/98HVLmbY7JP79ZD8hmo3oVB3c4bd0ogws28GcdvG9P+K2pndeFmiYNlYyoNkaEZv2dYLu+C2sQYvRBz7oT+MBfvE7vvvuO4IP3VgppZS65feR8IcD2n99CxmHopMQx/AunH2ehN8sErTbuPbn2DnY5YBuq0wGKLaGDIdDRuMpk57DrPVHiv6I30NqYDguzU5AAchVO4yGI0aTKdNemajzRwrVHtFLB/l7F3bpJD7BnTflhQw7A6ZxQhhGpHxLCT+YtgNmlW4zz6/DLuPkzkKKhTJBt4tfLnDzyg8LLzDptSbvf7SGRaHq8iFfCiillFKP+Qbm4f8E4vAmuTddBuEpHcN5fN7+38Is4Hrvt2oyG9DpjomS22mPSbnVo/lE/YNhLJfdWsUsNvELf+E/RwMmqYu7cvOQbjDB7QUPjj0JR3RaHSapS2fYorxMNNJowqDdZpAUabVbuIWU6bBLpzshtgqUiybECYlRoOp7uA9eWpASjbq0hyGm7WCZMWFk47eblK9erpDMGA26dIchVjBk6N+PLqTn+QwiG7fVInCX5ViGseiCW8dqFJq0qh3++GOX3iygZYzotbuMIhOnXMQxIUli4tkM/CEDzySaDOh0BsxSm2LRhjgmMYv4TZ+yfbXzmOmwS7c7IS60GPXceyVhKbOOSzBKcbwWraCKk84Y9Tp0RhFWMaDV8ihaBiQho16b7thYHE81oVtuMrEcbJPFi+ZMB8da/B1vwOh21hwPCAYOvVbxVhf1cP0hOA4WMWGYYDoOFglRGFPuTmg5IeNhl+5gRup4NJs+7nVNSsyk26Y3W7yIzowjIsul1ayy6IKUaNyj3RkSFdoMu9Xrd2PE0wGddo/QCWi3fIrWYv1Jd4ztt+69sM7BaznAjJnB57np/qxmzCgQNC0G3YDuMMYNbt4SEs1S7FX/+AoB1bDJKCnjaRKvlFLqS5OvmG3bcnZ29tt2ctqX+kZOAIGcbGzWZOfoYrHs4kT623WpN7Zkq16Xxu6hnM2Xi452pVGrSa1Wk3r/RM6PdqVWystGrS+njzQ1PzuWw+MzmT8b1FxO92qy2ejLycVHHNNhTTIglf3bG5/KTh4hsykHjwQwP2pIjjVpHK9eYX6wKRmQ3Oa+nN/+/LAulb2zW58cy9Yakt+56YmL4z3ZXMvJxvaR3EQ1l5PdkuTy23J8K9SLw7qs5zalf3uX53tSyiCsbcn98OZHW5LPZoT8zt2+P9+TEkiucXRn/aN6VmBdtk8Wv5/tbkgm15DjO9vuy/b1Mc3lYDMjmcr+Mva5HG+tSyZXl8M7sZzKTj4jkJed+xfBxYHU17MCJenfOS07kicn90IUudiXzdrB4lqZH8hW/WDZ9rFsrWUkv7uM7bwvje07kcvJ9rqQrcnB7XaOtqXeP79pM7MmW8dXoTVk6+DqUA9kM4OU7gR5Jv3NnKw3Dm+d97kcb+clV9qVk1t9cNTICWSltHu3A463K9f9vVxTGvn7/XfnKGR7PXPvGv4GnPdlZ/9CROZyUMsK69u3rskLOdjty9kjmx5vrcvmM8d7frQr9cqG5Dc2ZfugL/UcAkjl9vl64v9bSiml1Cqvv6TH8egERTIAmSLNXo9m2YRkQrNY5D+GBn63S7ddYPaff6ToDogAsxxQTUf8+OOPDLtN/PaAyd9+4ecfu4zCh82ksyGD0MQYuriDp59bptM2rTBg0PMfvtn3oyTMek26v2TIN1tUVz7dTxiNwNtMGXZWl/0Yho233cAc+7id2fW3DoZp4Zi333VswKJHr5nFgOHIJ+m6N/XG0YCgNaPcad8pTTCrHVrOmGZzeBOHYeC4NfLxgM6deuWE0TCl6lpkMHh23GcyZjB5Rybv4xeud/1Aarq0r79JMLi7Y4OiV8V6O2E8u7udUXSprf1Ct3O3PCMajrDcMpnMvcYMAyMDDwI3DSzTXH5DUSBo3//GYMnyaN7+xiOdMEyq1M0RnWF087nj0/JWv4/adFsEVy+aNsAgc6dPkmGT5rhAq1299UZrg2K7TXnWovn/s3f3sHFj6YL3/wMsIL7BQnyxgZiJDVxA3Mgc7ALmG5k3Ei9uIN5IXGABcSJxI3Ej1c0q2IV4I/NGqptccyJxsYFqgR6YAywgTmROsDAnMhtYQOzInEjsyFR03qD0UZJKsmTLrW77+QHqtqrIcw4/qvTw8JyH2WU9muazu2tRjXyi8vI4GWd3Jy40FbXuYP/qJ+pe1VcduqMDGn4csvpDRlqenQlDTavZt945tB2LuqxveRf6IsL52//K72uTeJLgd1PKv15f6O7vLSGEEGKRrz/gR8PQL/+tGbMgq5lE/PMPpyxZ7mxCoengrMJf/xgzmg6zZfVZtHKKR1rW1Ef77O2nhNb1OlrySifwDLq2pR/uGqk7UExa/LH72VmC6jQi8BxM3SQobMZHDVXiLA6K25zSjElGAXqRMhfDXaF7KUXq0PyjT1Q8bDaAZkdE9k9Ms4Ie6IqcP586eDeGJxk4nsVPxZRyuLr+yIcimXBxTdVmFGaEd8fO6quMNE1J4hDXDiitXabFiBuH6UJLlk4Zbg1GB+qypFtxcK8XornEoxf0eUJ+cV1Xk9cO0YPS0MxfZJhY5u3LWdZlGN5PpxAmjGObOk25CB8NC+vW6u8qf6DMC36y3LOhOPNVO3j2KX/Ky8uhN5qGM56S+z3/EoTMX3Nc0Ta0uvHVZcKqWw3bPPvFiYmf9eTp2QV004B1+1mnmQa07S1zbFqy8b/wI7AajghtCyeK8VauLvXx7y0hhBDipm8g4F+kpZj+AIB23suKfnZh8BNlUV1Zesk0MQHDjRhFLjf7UTVcz0Xvp2SlTXjnjN2Wpu2oJglJsugnZdrc7w+3HU+YjB204Se6wcJzzVt7wOu8xgksNCcmtmvStLplAqGGGU3Jt+D3QfDAbEMmlrnE6VlQ0zUtLOlzF1yXdF2H05buSvSj449CzL+kJOUADFSTBje07+zZ10wX13XxwhF53dMWCd61g3TaV6RxTBzHRL7PuLy59adNzjgO8RyXURMwrTL8BW03gxGB/keSdBZu90VG5wdzkzS/lJa8NAkdDTOIcbv82t2QT9HRdqdgGAvOax1dX7o6BwYAAz+bsmsUhEFCveBEGoYe9HvckflVqamxsC9+Nwlil+HsArqtB8y7bmloOnrfLw74h4rzzn/z1quzh31vCSGEEOe+jUm7NwxcdMIvGO8x3NlDv4iBaUI3yaickGzxyIrzCtF0E9fzbx3uoJv3D5N0J2Wa1Dj/NcKPLap0QQ//UJAWPbaekWkDg2HwY5ZQjKcLA1rQ8SZT9hqH2I+xkvu2Z6DvYck469k19dlrsxsmV/SzBdGvj4CxR8QvJsRJTmLr5AQkBtw+EAI0w8S27TuWgCXdIU5TZtNce7ysvLmMFTCOOvxsCoGPd9tx0D1G8TP+fZpQjBK6qUE40dGKO5twzYKd8jH1ZHZXIcuo6DGMv5KnOZ0fLQjW7+ssqO8HergxEbkfTmFRT73mkEwn1Pbv8COLfNHu/9o6nLuawfCvHDUjiAlGf8ckLTBM/e6sOsPAoN1yEdQP9Kezf95+Vjz295YQQohvxTfaw29iW8vA/B/Js8AUsOzbb8vfriXPatzIxxga6vb2uh2rp9UsLGvxz0N7iq04J9vU+cs/+wR5d+P9bjpFj8f4novregTJmA0KktvG9QBoNqNpjt/9M0F8z1SffcG0Aifw0AHT9Vg7raluROs9ddWwZHsLAiSDcBSg/zEhjgvM0P0CvcQ6fuijD/3FMb9gxeSZR3NtjPp1VjhifZgyjsZUTsitlxuajjYfqJ3rBzTtIQNeBoqsJ0wiPNfFdX1GyRbGn1LSu66GPkrH9WyWmpKbN5Zmx27NdRePSzdD8uk2Wh4SXrsVpOkG2tB/VTH/UPVn4/fnaB5xuMYPWUTG7eP3ZwX0DLq+eJiTbmDOvpJmF8MLfYnvLSGEEN+CbyLgH+b/NQBouKOINeC0bWaT3YaWtgNWNhgF5tUVh3t0VnYFeesRejpdUdLeEaU6cUAzWjwU4j7O/9hfBpEG/iRnZ+2v/K/QY3Sl4IZsahL6FqZpzn6sgFFg8Oc0pRrmy+2vBqaGTzbdxWjba0M6Fo3haMmjmNJOmYRn/c12TLI5myR8Zf02Z1KaROlcetBhoD+LXDRvRPzsB6adQ2Bdvn96c0cw8PGezcVvd0zjhOp8e8ouIdcAACAASURBVOaWMfwJeQSZH9yY6zCcp1A1/Nk+LAf888myA9xopOHgWQPVtdm/fVWh3ZggcN7e05uNbjMyAgLLvDiOlj8ievYDWVLcvCC7sbPOC7/2f8AME0Lj5gVgl6dMtU2S0eXlzPVzRHcnTBOb7ofu6llh2Zhd+/GJpDeOzUCdBgSjcvFFZlcwCiLyBRPnoSGPAuLp4lr7MiEMJ4s/d92U2A/JFpY7a1dZDZfj9+fYUcTzYcD4SMDdtx26ZS2+gNVcQn82YL8uZnMmhqaiPtsJs3P8nt9bQgghxHVPnSboLo+SlvP9a7X74jwt57J6vv1SvT4r8vhwWz1fWVMbLw/Uq+3namVtQ+2f5SA8OdpTL85S4rH8TG3tv7mSqvKGD6/V9vMt9er1K7V/eFvizrnF3+6rzfVNtXfwRr17f//UhMdHr9T282UFqKVnW2r/9buLNJgf3r1Uz5dQLD9X2/tv1Hv1Xh3tPlfLz7bV4bu5vH0n79Th9jMFS+r5ziyl38m7Q7X7YkWtrL9Ur6/l+Dt+taG2Ds5fe6/eHmyrZ0uo5WdbandvT+3ubKvNjU21s390cx99OFaHOxtqfWtPvTo8VAf7O2pjfVPtHc0t+f6tOth5rpbXNtX+m9nr7w+21c7RrM73b16prbXZdu0czrb3w7vX6uXmmloCxcoLtfPqSL1bkJpwtl2zNJ0bO7tqb29P7e1uq43nK2p5/UCdqA/q+M2+2lhFsbKuXr5+d5ZW9Z16+WJZLa1uqJdH75VS79WbV1tqbfmZ2j54O9vO4321tff2bDOP1P7GqoIVtb53NU3ih7f7amNtTb3Y3lP7+/tqb3dbbb+cT196ua/evNpSa6CWn++og7dn++jkjXq5vqJWN6+mcf1wfKR2ny8pWFNbB2ftfv9WHe48V0ssqWfbr9Sb46vH/Wh/U62CWlnfU4fzhb0/Unub62pzd18dHB6o/d1Ntb6xe/FZUeqDOj56qTZWl9WL3UP17krj36vDrU11JXOreqt2n2+om1koj9Xr/T21t7Oh1paX1MqL2Tn06iJv64k63FxRyyubC9ZVSr3dU89X1tT20YKD/eFI7aytqGd7b2++p5Q6frWuVlc31cGiD/LbPfVseUU9u5YCValZqsydzedqZXlVrW+/VEc31j9RB1tbV9OkLnC0/Wxxuy+KeaP2XqwoWFKrz1+o9a1ttb6CWlpeVWvr2+rw+Gw77vjeEkIIIRb5jVJKPfE1x62+++47jo6OME3zC9Yy0LctnWZife6sy6Gj7XXM+5YzdFTFlLKsqNvz4Q8a7ii788FbP7+BYdAWprd8iL5t6TXj/vvnq3J2ng0ahmnemLvwyzHQtR3o5sLJ1netN1xLm9okLmOrIF/8FLi7SytyCie4ZY7Jl9KS5z1BcPd8kE9TEbsZfjHB/cju6NuGFgPb1Og70Bd+Xh7xe0sIIcRXTwJ+IcSX0U8Jo54kDx84qXigyguMwP8yT8O+TTclbzyCj0Xkn6AvIqJ2RB6Zj162EEII8THfxBh+IcQT0H0SvyJ54PMchjqnNm6ZKPzFdEzzAfsLBPsMFZOpzViCfSGEEE9EeviFEF/QQDVJad2Y4PYng11dYxjQPnf82IMN9IP2BYZadRRpjhbEuJ+eO1UIIYT4LBLwCyG+uGFYmDr+G/A481+EEEKIz/HND+k5PT29I++1uGFoKScx6YIn1Qpxm2834JVgXwghxNP75gP+//2//zf/+T//56duxq9DV5FPa5pyStFKwC+EEEII8Wvwb566AWKgKaZ0VoBrPnVbPsJwCAKoqhHTxyx3KAiMv+N/DGu88KzFTyJl9tCnvm2of/jr2XOlltk4bJn+vLkbhRBCCCF+VSTg/0L6pqSsL58+quk27qJgdpg9OZSJh2t+o4Gr5pGk6xS/qzHCCbn/kdmNQ0dd5CTjMdPJlN4Pb71IEE9hoK0Kqrm7QLrl4tkya1UIIYR4Ct/8kJ7H11GMXLykxfIDgiAgCHzsIcV3I6bd1aWHMqfUA+JvvJfaDDOyTfgfYUjWfmRhzcD2Y/KqYqIVN/apeEJ9Req7xJWBF5yf/y7kIU6Q0chIMCGEEOJnJwH/oxqoRh5hFZBnIZdZCDVMf0IedURuRNnPLZ9XWPHoo0/f/PoZ+JOcbf2PREFKc59VNItwEjBUEvH/MjSkvk/mTJjGztxdFwMvyUn0MW44RY6WEEII8fOSgP8xNSlR2uGPw4UPDTKCMSEZUVKfvVKT1w6jcNHSt2hLyvazW/rLpLuk+Q5mPSIY1dyrM9jwiT42BEj8LLosZlw7jCN7wbs67ijGnEaMCunmF0IIIX5OEvA/ojqb8BfNxXNu66638VydH7IJJUA1pXVjHjKap0pTqqeKl/qaaTYhqzqa6YRJVtI+chWakzAd2zT/FBCXki7116Mln/yRwfZxbzufTQ/X/Cv5pLjfxZwQQgghHoVM2n00HVX1IxgBZj0haQxsYy7wH3rKziC0TPhrRd2Co3uMR84DqshIO5/Ueuy235Nu44c2fhh9wUo0rFFOWtj8lyDCa/IHXRCJJzLUlDXooUmbJVS6jaldfb8hwDaXOK1LanwecOYLIYQQ4jNIwP9oBoYe0Ay0oSaNMq73T2t+TuRqQE/Xg2a79w96+pJRVOKnGV//ABaTKJ9Q2P+JMPRppsE3sM2/ckPPcAqapkGTE6fjG4u4k4BIA/p+QQ9/Sx4XmEnErTfIhBBCCPFJJOB/NDqGsQRtR29GFN0E+0rP9EBdtwxFD+iY945gB5o8JoxzBjdCzxOSe66pGS5B6NwaLP/P//k/+dd//df7NuRR/Lf/9t/4D//hP3x8QSMgy6ZYQUbRBYQS8f+y6QbGMlR9jxFntIl97bxrqGuo81MwjAVpVHXswMWQYF8IIYR4dBLwPxodx7NhVNPqCcGNiEbDtk2mSQtrEe69A1gN0/HxnYrCcPB8i3vHRJpxZ8/4f/yP/5F/+2//7X1LexSrq6v3XHKgKQe8LPuZg/2BtsiYtjqOF+CYP2fdD9RV5NOK3vQIvavnRTud0ns+9l0nS1+TZSVYHv5tDzwbWsq8oMbCD9yrw3SucPCcJX7fNAy2t2DSuoVtV0xqWPE9rk/rHXoNy3mqsWpCCCHEV079gpmmqY6Pj79oHd9//736+7//+8cp7ORQba4sq/WD97e/v7ys1l/d8v7dhaujnQ21/frks5r4a/H+cEtt7L5RHz5x/ZM3L9Xu4fHDV3yzo9bWX6kbe/nDsTra31Evjz61Rfd38vZA7W6sqeVnO+rNRXUn6s3+lnrxfFPtvnoz174TdbCxprbfXGvu0a7aPrzrXHmvXq0/UztvFmzPuwO18/Lqvj9++UI923t3Z7s/HG2r1aXn6uXxLe+/2VarS8/UlWJO3qqD/VfqYG9TrX+kfCGEEEJ8GsnS85h0n0nm045HFDeSjfeUoxGVOyH7pC5rHTcZoU8S6o8v/EADzTQhsHXMsLicezDU5JGH48dMyk/Jnj7QFAnx5GEtHuqUKHdJE+f+dzOu0QyX4Hr3/NBSZglxFBFFEVEUk19P+N93DKZ5tbe7q8inNU05pWi/fH4Z3fZxXJ9Qyxnn5/tdxwk8/DglCedz3OuYJnTd1XZpboBZ3JXzvqfrdaxFXfaGTXDtjoFpGfTt3eeA5qbk8UAaZzezNw01aVxgpjmjuY78tuqwwhDfHGhbycokhBBCfAkS8D8y3csoJxZZGJBMa9q+p6sL0iAg1VOqz5mAqjmEbkNWPWaLATQs38ENQqxiTHYeBGs2vu8RJinR/ccgnWkpsyltU5I/5GKhL4jHLfFk8bMMFtVT1dcCxWEAw8aeb3JfMooSGiskmUyYTCZMJinBfUaRGM7sack/2wDzik4LGI89muTyAm+oenTnvsfBJrCqmxc0HzUwaBaO9SmpkTScpGTqlUT+iLxq6fuOppwQ+SO6uKCIru5w0/OwNajKBttblL9fCCGEEJ9LAv4vwHBH5EVO7EBbVTRYRHnBNPE+O9uMFWWMv0Rc1DTgJCRhT5Jc5kmvWw37k4ZWm7hhgPegwLFhEmXYSXp7Lvdr2iyhHC4XbssJk2lO7IdM555oXCY5djIhcow77xoMv4QE8U0Dlo3ujYn1nHE+25C6Bcu8ZZ0F7TYDh+auq8Pr6ww1eZozCV2SRTdl7rVvdOwoo5iOcfWOqqwZzIBJUZAGt80/qSkqA1fS8wghhBBfhAT8X5Bm2Lieh2ubnzw05WahOvoXiIu6Cgxbw47H2MWYSQvQ0mDemGD5ZfSU8Yg6nBDd6wKjp5r4uImGe57bdKho8IkCG73r6C8C1Ippa2H2DU1z9edyJMxA35RM8oEgfNoM8bNjAWASjT2qcUI93H4s7MBnyFOK5lq6S8PHG3LKG4F9R51PqKwIb+4KdKha9MBF6wZunLB2iNdNmFTtjXSzi2kYloPne9jmR67euooK7wET2YUQQgjxEJKlRwA91aDh6AA+42BMMC6J0o5e967Gfn1H090e8umm9UmpFds8JG4cxl5FUdyy0NDTdx11XVEWU/784ymrO28un2WgOXgu0E2pcOey+wwMfUtT1zfiWFO3MAxg6GjqihoD70lzQ84fC9C8EbHmMs4MXD1ceOGoGQ6WXlDXNZY5n0lHx/M14qLHnXt6Wd/WVFWHZl+dq6C5Pl6T4BCQX7/o0k0cU6OuahrT5N4ji+6zxWVB546QHD1CCCHElyEBvwBqOs7z9Ws4oxGWPWaS++je1d7ZoW+o69vG5GuXAfSDNJSljm00TO816FzDcgMsdLzoZm98XxZ0znwA6eCaJYYf4N4Wy2smTjDC1nzstCJI79fLP7Q1jXY5X2DoalpsrPv+fm19hpqO+Rz2FtHYJQ1y3Dpe2IY6HdF4FenNXLCzybvRlM4PL8rULY8oNWjtEdOoIJxbrZ7kGFGBVkypPf/yjkKZMB4Cmth7pLtVFbGd4mQBVa4znshzd4UQQogvRQJ+AXUDlnv5uxEwDsa4aUcZXV1UM10C87EbYBFOMsJHKq0uGmx/fvCLThBbhNEELY0ues8X0TSN4fpA/r5mOq0oqo6mnTDBwQtdTKBKfII+pcl9dKAaB8RmTj2a1f/R3+fW15opkyQh631Mz8Yzz1rvjxn5GbelqR/O2r2YTWBNyJuQ+Mr6Gro2XJuzMNCjo/cFueZw9dAPoGmPNzQNh1EWUnU6cZ7dkd9fCCGEEJ9LAv5vXFumJOOMxjZwHR9Lg1kv/xh/MD5j/H5HlRdURcPQZKRZP3uQ1Rcfp11T1CZeci2CtEIm44LJOCK/CFs1nCj5eKYe3cYPbfwwuvGWO2nIi+qiRHfSXEmbep/fz9fXLJ8487nZj28R5/d9vvJNZuDQpBUkH+tF13DTAmfQuPX64REZtof/5asRQgghvnkS8H/jTDdmUi4YKmKE5JPPKdnACUKcIFwQwD6+LvMJuphEm9AEY8YLLiw00yNOvbsL0nS0fpj1mt+n4rag091P7/n+3PUZ6Pvh7gDd8PGGMcXg4M2N79e1gb6Hq6mjFgf7szqkG14IIYT4NZIsPeKrYAQJY6tn8CZMR5/+wC7cEaldMJ7klO3HFx90F/+uMUJfcv2uIp+MKawJiXfXFut4gUlzJUOnQZBG9FlCNq1vz7wztJRZSlK5TEYyzl4IIYT4NfqNUko9dSNu891333F0dIRpml+sjj/84Q/s7+/z/ffff7E6hBBCCCGEeCrSwy+EEEIIIcRXTAJ+IYQQQgghvmIS8AshhBBCCPEVk4BfCCGEEEKIr5gE/EIIIYQQQnzFJOAXQgghhBDiKyYBvxBCCCGEEF8xCfiFEEKc6Wnq9jOLqMjvepjbF9FSNz9vjUII8Wvyb566AUIIgIGubRk0E9OYPTV36HvQ9U9/arAQDzJQpQmNN8a6/lZfUxTNZRCvGTiui7ngIdHNJCLMPCrfxn5I9Q+o4yYTrYpJ+zHxZzz5WgghvlbSw/+16mvykYf5m9/wG83EDQJ8z8W2HfxoQtk9dQMFwNDkxJ6N5QSMJ1PyNCbwHGzHxXFGVE/dwK9OR5WN8Mzf8Jvf/AbD8QmCAN93cRyPYJRRtsNTN/JJ9EXMRI8JrauXmO00wvUnDGf7KggCfLNl5HmMyuu96i1F3uLE8YOC/YfVsZgVjjCyEVPp6BdCiJvUL5hpmur4+PiL1vH999+rv//7v/+idTydt2pnFcXarnp7/tLJkdp5tqRY2VAH75+ybeLk9bZaW1pWz3ffqJOr76i3L1+oleVN9fqJ2va1e7OzqmBN7b6de/HkrXq1taaWllbVxqt36sOTte4JfHijdjbmvifOnLzeUqsrm+pw0XfF8b56sfJM7b39cOW156tb6vUDdt6D67jL2121vn30bR07IYS4BxnS84vTU5ctpmvzGDemtevjQXSXcezyz7/7X6TTjsDvyNMxadlj2A6OqUPf07U1tRFTpB5aXzNNEpKyxbBdLK2n68HyIqLgvJ0DbZmTphOq3iUpEtxrdQ9ljDeq0OyQ0SjENXuqPCVJSzrTJR7FBLYx2wd5wjitMcIRo8hFy0P8SYdlmWh9S92CaZvofUvdWozLFO+ivoY0KvEnEeZF7RWJG1MaFqYOXdPQ6xaWMfs3QcY0MqinGWma02g2YRwTeNbl9k1TxnmDbloYekfTmoTjGNc4P3Q12XjEpNIIJzmRfdagvqGYjEkK8EZjYs9C66eEwb/Q2i9pEufasdax45xxETMMcDmmp6NMx0xqDdMy0LuW1vAZxR7mtX3d1znjdMqgm5gGtM2AE48Jbf2irR8/pjA0BZMkIW80LMfF0jraHkzHJwxcjPN6+4YiT0mzmsEKiOMQ3x6oJmPGWY0R52TB+dG4dnxD91r7P/X46VTZmPGkZjAdHNtA73v6vqVqbZJihHNWmnb+wZivV7cJswp9sPiH33lERk3m6dDVH/+MANAyjUfkg8FskY7BTsiiy61gaMjHCdMOdN1Ap6frezojokhc+mbKZJwybXUs18E6K6erawhzssCgb6Yko4Ry8EnyEe7ZwRrakmw8JusdRuMRvpbjhzlYFgYdTdOjWxYGPW3T4aYlo7Md0hcptTu+2is/VIyj36OF7/ANbjJDRt4YP5oQVDEm0BVThmD+s/gRn1DHnewIr4mZ9i6BjOwRQohLT33FcZdfZw//iXp/fKyOF/y8P/n42ur9K7W5dfhIPVRv1e7atR5+pdSHgw21BOr5/lmX2tsdtbr0TO29m1/3WL3cPbjseX63q9ZYVTvnBR2/UuvLS+r5yysrqaPtVbXEknrx6np33Xu1v7GilllSm4fzW/dG7ayi1q5WPqt/Y0cdnVe/t6XOqzp5ta6WLnq/P6g3u9tqvroPR9tqhVW1/Waung+Hamfr8Gx73qid1SX17OXxWdNeqe3dN5ftfIFa2pzvW/8w63F/tqvezB3Dk9dbam1lQ706nt/MffViCcXqlno9f7xPDtTGxsHFcT1++VyxcD/NrfL2jXp3sQnH6tXGilrbfq0u1/ig3uw+UysvXqr5DtAPb3bUs5UX6uW7+Z7XA7Wxuqa2Xs/Vd89jevJqXbG0qQ4vKjhWhzvP1Mrqpno1v+iHQ7WxhHrxan7D36m9ZyiWnqnd+eOhjtXL9e2L4zvv847fa7W1vKRe7M/v1w/qzd7elbslb3fXZj381087pS6O4dLzl+r4YoWPf0bev3qhVjYOL38/3FLPd95cLv7+UG2urqgXL+fvHnxQ7/bX1erm4ZVzY2llW82tqdT7A7W7f3y51uHsM7yycaCubOnrLbV+vtzRrto6P7/e7alnS6vqvDknh9tq5/KAqsPNZ1fvdpyVtczlOovM2nG+H0/UweaGuuOUvrn+g+v4uDc7a2rj4D5ftkII8e2QMfyPaKgn+LaD63k4jovn+3iOg+v5+L5PmDUfK4EqnWJG3hecqNkxzUpOl9eJvPMuNe1mfYNBOPbnep51tKW5902fwDnlz0V1JRuHprn4Gzp/SlLq+fLqjMoKsJe0a7cdNGBpwfbq6IZ2Ub/hjwhvzCScre/EMZfz9HqmUwg2BvJkOjcB0Ca6sj1zjIA4NC/K01i62sQ2IxrVuMmY+fmAupcwsgriOJ+rR8MOd9nk9wRBRnuxsI5pGmfbOVCVNWBg24u6Nc9WsR3Oh1P3eUxc2IzGHpdraDjjMW49Is7Oa6oZhxP6ICGeH4ttBiSRxu/DMeXFEPX7HVM0WLryu4mfFqR2QRQkNHPL3dh3gObssOu2/JMfMr2YO6JjWPqC4/H5x2/+f+fsKMZdtO7C8lw8C07rguqyAR/9jHRNR99WnE8BMPyEkTMwnG9XHDE1RmSxNVeWhhVNLnraYcFdOWDQfcYX2wiaZhLsbqMXIX5Sc35INd3A0s/OECtkFCw+v3R/RHTRnV9T1ib2tc9XW9f8hIllFExGOUVRzP1MyZKM2jAx+IG66oEBI0q4pcqFHl7Hx9mORV3WH19QCCG+IRLwP5a+JM10kqqhqVNGSUlTV6SjMUVTU9c1RbwwYj0z0OYRCSPGziOH+11FlqakSUzg2MSty8siZy5+uNGWejKhWhR5XJRZUtRLPHOvDUfRdPxRzLMfJiQXs+cGiqzFDx+UswPmLzcs6/YhToZ1ERjT5pRmTDIK0IuUizgYE8u8rQANy7o9SumKnD+fOng3jouB41n8VEzngmjADMime1hlhD+quDkFtKPrTgH9ckjMnQbKvOAny8W53kzNwbNP+VNe0gHUOdMfNBzv5r62XIeVv07Jb4uFbjumCxn4sY/+l4zsY7GVZhHnU7b1KWGQXl4gLKrlCxy/oUzJ2gUB+60MDAM47elvnb978zNiBT5W80+4bsy0GQADP3Bn9Q4lefFXTNdbMCzFJIr9O9rXkqVThmsL6F5KkTo0/+gTFQuC4fnPxYI6L/Zn39IMxo1zse96QEPTeoo0xPf9uZ+AaFIzaAY60Pc9YOC61oM6Kx5ex8dppgFt+zOnBRVCiF82GcP/aCyi1EUHhqJksDygpm51nI+t2pUkUURSmwRRSZqU96xTw/Ij/Nv/qs/oJo7rYqHhh8lF2scrTlumSUynMxuPXeik8fVleqo0JhpqqlbHTUomC7rdNTtktJ4QJjmtH2F2OVMtJDUa0ntu2aeq8xonjNCMmNi2SNOKKHU+645J17Sw5GAsiE91XYfTlm4W71zQ7BHTrML+Tz6hU5P7V9ZC1wFm4+bv0QLa7hQMg5thrY6uL0HT0AFG19GhY+gLtlg3Mejp2gHOL17ueUwX0Uwbg5z2PhmfdJfJNKFxRviRTTVZfPH3OMfvlCYbE9caDD11UWHnowes39P3wJJx9Zh/5DOi2QlFoROFY/7BznkR5+SJOztmXUv7Exj3yzHJaV+RxjEGs7H50yEmuLEJGmY0Ja9s/i4IcOqC6AFbeWHoGTTtxuWXYc7m0/SDzbjumV77nunrmn7I6FnCNh7Qrf8odfSUaULnJ1xMDTmn6bO5Gyy8pBRCiG+SBPyPRTfO/rj0TPMeewL0DVWncT1uvsGw8XyXou2wHQ/3ft2+s2qvz9ZcRDOw7I/kxF4y8Ucpo7NYr83nhqNcLKPjRCO8iUPWuST+bT3BBv4owPjbhLQKiaoKOwrR5vp2v4ihIC16bD0j0wYGw+DHLKEYT/E/4y+/burAMOvtvd4L2vewZLAovjaCjLxy8EKftBzNraxj22vwxx+o6o6b3fY3WjAL6vthQRAz0A+nl+efrqNzS89039Gjoc839t7HdHF5A8bCC6GFrJg8q3D+ISB0Cvzr7z/a8VvCCsek4dl+rXPyh6ze15QNLDkeV27q3OMzYrgjpk1IMQ4I/+lvcYc31KmDdvY8hfOe8I9uge4Qp+lZZ0GPl5W3LKnjTabsNQ6xH2Mln35pe/2UMV2XVSbUjUm8YBaubtsMWU235OBdn6F/T59eh4bpBIvv+gwDg/aQOzpCCPH1kyE9j63NmfTOLFDoWrq+XzCk4zodO5xQ5B5lWoJlYd3z5wHXBg9iBiHueU/nPM3Am0yJ9ZzAn9wawmvuiPh5RzaKSFrvZi/c5ZIYOgw3ItSeQVs0xvt23XSKHo/xPRfX9QiSMRsUJJfjQj6J6XqsndZUN4au9NRVw5LtsfhZPzpuWpDaDSN/RDW3iXYU8XwJ/jzJ7rgMOh//reN6NktNSXPjZJq1a811Z0NFbA935Sfq6mapXV3RLbt412853fOYXtcUBe2qR/CAkVqGnzHdMygin+Tak1G/1PHDDgjs+w8JaSYJxU+rhOPwztD86mekpTx/uIVm4CUF0501fsgmlAC6g/cMmqLi4Y/A0PFDH3245UJOsxlNc/zunwni6cOHsugG+rDge8qOGL0YKPLylu+wjiKr0P3Rg8btP0odAxiOvfj4DD2D/rDvDiGE+NpJwP/I6jRlcN25tIYV9T2f46NZEalfMc4f76lYw3D+n4drsxGTuehvOGXWDajZJNMJTh3jR+WVAGMY+rPqTMKRD38q0YOziY0DcHqjHxHHMWjL8mpvaVfSGM4tafiGm8XQkE1NQt/CNM3ZjxUwCgz+nKZXgu1ZO09v2S8DcHq1u9OOSTZnk0ivHJk2Z1KaROlc+shhoL8SlZlE05yAH64G62ZMlr5g+S9jgmh6MdHzopgmJw7Ti0mjZpgQGjeD3y5PmWqbJKOzqFvzGI9f0E7Sq/MKhpp00mCPkivpCu9zTBdFYn01IkwHwkly2Qs+LF5+6Ie5lzTs0ZTMG/jhyqY85vFb8GqdMMovt2o4X/fK4h1l6uGOO9z9Kek9eq3nPyN1OpqblKxh2QZLun4WlFpEyRZGNWZ0fbz90DCdXk68Xfxx7ZjGycWD2C4/Z2cMn2y6i9G2t19QnN7yumZi6bN0q1eZRFmGU44YLZgw201jxl1INvHuDq67KbEfsjhnwcPr6IoJk3yEHyy+uOnbDt162FwCIYT46j113t3M4gAAIABJREFUmqC7/OrScn44Ulurz9V5tkD14bXaXLmeyu9jZbxWW5uv1Gc/E+vkrTrc21CroGBVbewdqDfHi5c72H6mllhSzzZ31O7entrb3VHbG8/U8srZA3RO3qnDneezZbYP1Nuzxp283lKrLKvnOwfq3ckHdXz0Um2sLqsXu4fq3YlSSr1Vu1v7s9SGJ+/U670XahnU6ua+enM8l3Lx5EjtvlhVa+s76uX+vtrf21HbO/tq0bN2Tt69VnvrKwpW1eb+67N63quj3edq+dm2OpxPRXnyTh1uP1OwpJ7vvFbHH5RSH47Vm1dbag3U8vMddfB2fk+fqLeHe2p9BcXqpto/eneZlvTDsTrc2VDrW3vq1eGhOtjfURvrm2rvaG7992/Vwc5ztby2qfbfXD2CH96+VBs7R9e25oM6fr2nNp+tqOXV52pja0ft7u6o7a0ttbV7oN5d3/73R2pvc11t7u6rg8MDtb+7qdY3dtXrG8f1g3r3alttbGyrl68O1eHBS7W9sa629t9ebs+9jqlSH45fq5dn+3t9Z0/t7e6q7a0NtbG1d2NfH+1vqlVQK+t76vDtiVLq/WxfLz9T2wdvr57TJ0dqZ2PvLF3sYx2/9+rNq82z97Zm5/LertrZWldry+cP2Xqv3hzsqfVVFKBWX2yqra1Ntbmxrl68eKE2dl6q19d3/H0+I+qDer21pp5t7KiXB4fq8NWu2ni+rvbeXE0P+f71rtp4tqZebO6ovZcv1d7urtrde3WR7vXk3aHafbGsYE1t7Oyqvb09tbe7rTaer6jl9VkK0NkyK2pl/aV6fXy1rcevNtTWwbX2v387d6xfXf3snTnafqa2j268fFboa7W7sa62Xr5W796fqJPj2XfL+uZL9eY+2S/f7qlnyyvq2e4duTfvXcc7dXj4Vp0cbam1zUO1qPrZtsijt4QQYt5vlFLqqS86bvPdd99xdHSEaZpfrI4//OEP7O/v8/333z9KeX3fzyZynhn6Hk1/2M3l62V8K4a+pe1AN4zFk05/Ifq2pdeMxZOf7zAMw+UDn66/17W0XQ+6MZe+89aS6NpuNgn3I6fJ0Ld0vY5h6r+8Hs9hWJyD8lfq4vgOHW03m5B669YNHW03oBvmwvkfn9EKhkF7+G6tYtw8oEzvSDHQt9R1Q4eJ7Tx0OGFLnvcEHxv/da86eqaBwzSqyW7chamI3Qy/mNx48J8QQnzLZNLuI7seqD802F9UxrdC002sX8Gm66b5SeODbwv2ATTD5I7MkteXxrjnRbCmm9wzMczP7ysK9mH+6b0GHz0891nm01rxabvViQnThGnv3D5BWjexXfPTmtXVYHgfX+4+dfRTJo3H2G6YFga+d/nB6YuMLhhJsC+EENfIGH4hhPjmmYRjm2Ky6LkRn6tjmg/YjxWF94Cp0eY1+vyD64aKydRmHJmPU48QQnxFpIdfCCEEWBGJk5IWJiPv3reb7kHHjYLHy5pjhhT59dSbHcWkwhnH3O8pEkII8W2RgF8IIQQAuhsTf2JWr9tpjzxPAbiRZ1/HjeKvbZSYEEI8GhnSI4QQ4sJdc01+uT5x7oIQQnwjJOAXQgghhBDiKyYBvxBCCCGEEF8xCfiFEEIIIYT4iknAL4QQQgghxFdMAn7xYH3T0D1qiQNt3X6B/N9CCCGEEELScn4hfVNS1t1FEKvpNq5nPV4u6ifSFwnJEJLcSHY90FYFVXsZtuuWi2ffJ5+3hsGU0cQliWwk2YYQQgghxOORHv5H11GMXLykxfIDgiAgCHzsIcV3I6aP2zX+82oz4sJm5F8L4vuK1HeJKwMvON9mF/IQJ8ho7tF1r9kxESnjUvr5hRBCCCEekwT8j2qgGnmEVUCehVgXXdUapj8hjzoiN6Lsn7KNn6pnOp7ixN61uxQNqe+TOROmsTP3noGX5CT6GDec3msIkBUG9ElK/cgtF0IIIYT4lknA/5ialCjt8Mch5oK3jWBMSEaUfGZI25aU7ecV8WBdzqT38c1rL2cx49phHNkLVtJxRzHmNGJU3Keb3yO0pkykl18IIYQQ4tFIwP+I6mzCXzQXz7ltFLqN5+r8kE0oP6OeKk2pHi0mHujblnbRT3dZSTedMrguVwfztOSTPzLYPu5tkxNMD9f8K/mkuNekXNszKbPq0zdHCCGEEEJcIZN2H01HVf0IRoBZT0gaA9uYC/yHnrIzCC0T/lpRt+Can1JNRtr5pDcmzX6CviQJIrIWhr4Hw0DrO3oMDB00a0SeB5gM1GWLGV1r8FBT1qCHJm2WUOk2pnb1/YYA21zitC6p8XE+0iTNdjFGFQ0uj7GJQgghhBDfOgn4H83A0AOagTbUpFHG9aH6mp8TuRrQ033KOP6+ZBSV+GnGfXLf3K1jmhTYWUNjdORpiRcHkKdM3ZjQuLps02oY13vxh57hFDRNgyYnTsc3anEnAZEG9P390m7qBkZX0oIE/EIIIYQQj0AC/kejYxhL0Hb0ZkTRTbCvBMgDdd0yFD2gY84H1E1OXJgksXNLSsqBJo8J45zBjdDzhOSerdIMlyB0FlwgaDijZBbEdwW15hIAZdViBNeX7emGBQG/bmAsQ9X3GHFGm9jX6mmoa6jzUzCMK5N9uyIhI2LkXStU09Ho6QeQ/JxCCCGEEJ9PAv5Ho+N4NoxqWj0huDGmXcO2TaZJC2sR7nxkbNgEnnFHfKthOj6+U1EYDp5v3T8W1oxb7gboFwF8Oy3BDoGWuh24Of32ttocPGeJ3zcNg+0tmKhsYdsVkxpWfO9Kubrp4t24ggAYGCTSF0IIIYR4NBLwPyIzHLGZhGRFRxAsCLP7gryA9TSeG64yMGgWzkfGr2imx2jq4MQhkzZjcr1n/JPVTDJwS4COtumxbvSu65j6QHtjGJKOPwpZ9XKmbUxs3ix9qDKK/hlx7M6/CqaDvSiuH3oGdAyJ+YUQQgghHoVk6XlMus8k82nHI4obied7ytGIyp2QnQ+QH2ryNGcSutwvU6eOm4zQJ8mj5aofipTc8DhPLDQMzYKUnwaWNVzJ2nNOc1PyeCCNM26sNtSkcYGZ5ozOL2iaKWmWEXsRC7Nvdh2d5SxMayqEEEIIIR5OAv5HpnsZ5cQiCwOSaU3b93R1QRoEpHpKNQ0uhtgMVYseuGjdcP/x6ppD6DY8TubKnumkwA7OH6Zl4lgtVXnzMVm2Z9GWzaIG4SQlU68k8kfkVUvfdzTlhMgf0cUFRXR5+6JuwPd1ug60Bds81BU4EvALIYQQQjyW3yil1FM34jbfffcdR0dHmKb5xer4wx/+wP7+Pt9///2jlz10NVXdgWHh2ObimL5JcCKNvIzvH+QOPT06+iMMexn6HnT9sm19zzD/+8WCU0KvYVSO7sieM9A1NXXTY9gOtrl42FE38fDahDq5PltgoAg96lF5eUdACCGEEEJ8Funh/4I0w8b1PNzbgn2gnuQYUYBWTO8/TEd7nGB/VtS14H5RsA+g+Yy8ismdT/zSMCwHz/duDfahJc96wsiknJZXU5d2ORkxkQT7QgghhBCPRgL+JzXMeur7gnywfvF55614hJFlLBrYc38Dg24yVDmd4cyl6uwp0gp/7PNY05GFEEIIIYRk6XliGm5a4AzawvHsvziaw2jUkaQlUex+YmBuMSoyhmvb3E4ntH7C9Yf5CiGEEEKIz/PNj+H/v//3//J//s//YXNz84vV8dUZBgZNe9Rs+cOweBKvEEIIIYT4PN98D//f/M3f8Dd/8zdP3Yxfl0cO9s+KFEIIIYQQX4CM4RdCCCGEEOIr9s338H+SvqFuz7PVaBiWJU+GFUIIIYQQv0jSw/+J+iLG/e1v+e1vA7L2qVsjhBBCCCHEYhLwfwrdwvWdiyfmCiGEEEII8UslAb8QQgghhBBfsW9mDH9XpoyzGk2HbnCIkwhHh3Y6Ypy3DIARjAmHCeNJSYtNlKREznm2+Z5qMiLJKjrdJQ6fcGOEEEIIIYS4p28i4O+LEOfvfo/x8pgq1shcE9dtqeoE2w+xxv+ef/wLLLeghQG+VfC7f/k9/8XXsLoJLgPVyMX9p7+grb+kSF3aJKB96g0TQgghhBDiI76BIT0t2ej3/Mgylm0CBqalc/qXjEkFcPnEV92JSSKfMPJZA/hrTd0C/ZRx+hdOWcaPIxzLJoh9zCfZHiGEEEIIIe7v6+/h7yuKBmCgSkLCDPoalpcHuqYH53JR7Tzyv0ixOTAMQF1QnQKYWOb1ZYQQQgghhPjl+voD/mFgOJ390wwnZMH1SL3/eBH9wCzrviZPhBVCCCGEEL8qX/+QHsPEXAE4panqTypCM42zFJwd7cevD4QQQgghhPjF+PoDfhyiYBWAH7MRSdUzDB1VGjEqr0bvw/nDc4drRdghwRrAj1RlC0Bb1XRnC8s1gBBCCCGE+KX6BgJ+DSeZsr+xytJPf+If/7//l/9Hd0n1mLGr007HZGcd/z8WCXnTMk2nZxl4GvK0oMNmPN1nYxX+PHKwXY9RrWEAyytQJRn19YsEIYQQQgghfgF+o5RST92I23z33XccHR1hmubjFNi3NO2AblkYnzQWf6BrGnrdwjIG+l5H1z++lhBCCCGEEE/l65+0O083sezPKUDDsOyz8fyaBPtCCCGEEOIX7xsY0iOEEEIIIcS3SwJ+IYQQQgghvmIS8AshhBBCCPEV+0UH/P/9v/93/t2/+3dP3QwhhBBCCCF+tX7RWXqEEEIIIYQQn+cX3cMvhBBCCCGE+DxffVrOvpkyrXTcwMWko266s3d0LNvkk9LxCyGEEEII8Svx1fXwd2V59pRcgJKR+w/87nd/iz9pgYEm8fjtb3/Lb72E6qkaKYQQQgghxM/kqwr4hzrF91Pqi1dMbGsZWMW2dNBMPO+znrwlhBBCCCHEr8rXM6SnmxL6/5U/DxtzL5pEZU84gCZjd4QQQgghxDfoCXv4B5osIggCgiAgrQZopozC2e9BOKEGhiYjPlsmSAraakLkO9iOR5Q1DAB9Qej8A//jR+C0IvEDovwHmiwmCALCMGBU9J/YzJ62Kqmaxev3bUVZNXTDtde7hqadvTh0NVXVcvYbfVtzMZUAGNqahcUPLXVZ0V55r6drzpfvaeqGfu69tq4oy5r2WnvmCqVvKsq6Y5h7rWvqs3oGuqa6dXuHrqYq6xvbe3vZQgghhBDiSamn9OG12lpGAWr94EQppdTJwbpaAsXSpjo8W+zN9ooCFCsv1PbeK3W4v6lWQcGa2nunlFIf1MnBxtl66+rV+xN18kEppd6o7ZVZ+c9fHs/Kf7V+Vta2Orqzbe/Uwc6W2t4/Uu/ev1MvX6yojbM2KvVBvTvYURube+rw7Xt1/HpbPVvbVq9PlFIn79ThznO1zLLaen2i3h3uqu3N52qFFbV19EEdH71SW2tLamX7zUVZR1sraunFvnp/Xvf7I7W3taX2Dt+qt/vravn8vZN36vXeulrmmdp7+1btb6ypJZbV1mulPrx9qTaer6vd1+/U+7d76vnKmnqxuaeOTtRcm7fV5s4r9ebda7W9tqq2j5T6cPxa7a2vnO239+r13rbaerGqWNpQF5urlDo5eqm2tmbb+/71llp9tqveqrvLFkIIIYQQT+9px/Br2o2hNvqCsTears/+YfqMRiF+FOEuA7SUdQ9o6Pr5ehq6oTP7VeN81YdpmHgeE3PEJHKxDB3DcjDPymomHu4YRtkI3zYwvRCnzxhnLegWnm+hLXu4TKnNMZM0xFqatdF0Q0ahRd/UdGftdZMxnmmgA3RTAieiDVNGvg1th6Ybs2xCuoXnmGirFpQVdlZRHxWMnYrYH9EFExLPwrBtrKFF82NcHWCgTly8ic04DXGMga7XMQ3QTA/P1llyPIyiQIsmTGKbJU2/2Hd9EeFENUE6215dt7Ct8wxHt5cthBBCCCGe3q92DL+mAT+d8iXGjrSTiLj1KSPr7BWDYDIlAGhSwrjBnU5xzq8xho5+OL1Yv56WDJZLP7jEtsZQlNS6y+isONOy0NKaFjCArmxwohCNliwIKewJravR5CFR6ZJNfc6vW+qipMdEc0IcXQPXgTal7gwc1zxbqKT6Scc1zkLyKsYf9wRVhNWVJOEYxhmxBdBSFi2mNdA7AYEOVVmDk+AADCWjKMMYt3hnjdCcEdOce5QthBBCCCGe2leVpedxNOSTP6F7/mVAP6dKU/6s+8Te3K2DuqT6afUs4G4oyx9Bc/B9c/Z2UYHj456VpxkGet/OxtkPFdPeJ3I0qFLGfxqwjI4sSSm1mKJK8S56y1vK8gewAoL5xhkurgV9N8DQMBnlaDsZiQvQk48zfjQsKFOSrMWZVEwje9ZD35VMG9Bsj8DSztrf4fguOjAUE/LOIfAWddl/pGwhhBBCCPHkfrU9/F9OQ92AGZoL3uuo6x9Zcjwuk3sOlJOcfj1hZHMWQK/gT0PMs/LKssOJ3csg2DAxqOi7jrJsccMAHWirih+XPNI0xl8UMXcl03oZPw+4En5rNqM0IMozsk7DSCpq+3yJirI6ZS0ak8Q3U5L25ZQKlyyyL+ooGgvPna3fNg0/afYtQ3TuLlsIIYQQQjy9J+7hNy7GxXddDwzUVctscMzAcD5cZ7h93M7lO9osoD7t6NqOYjKdPYDrxqrDjTWvt8kwoGsuM80MbUFRD7M69CU0TbsI3oc6ZVR7ZFmIwSyArnWP8Lw7vyspGhvP6Smm9axMXUenY5rmDF6AdbaorussnXZ0Fwlyeurp5YPE+nLK/9/e/cO2bfd5HH8XOMDczE7mM4Wb1cm8LtYzmTdZz2TeFD1TdFPUyepk3k063GBt1nKIOpkFHiDsFHUyO5ldLnymsFO4hR0Ks+gQZgoz/W6Q47ixkyiJG9nq5wUEAWj++VJePqK/vy8zq0Ov89q3gTqmF0yobAev0yXwzqfzWS9+Xdfn7idlms0+7yxJsTq9s3adJkvIHR/fTpmmFY7jsNKUVGdThc7X9LZzi4iIiMi1sOhVw0/u75g1MLBq1ta3ze6dTbOysmrW1jfNzv6xefL40Nxen03aYWXD3D16Yh4f7pxO6cGsbu2bh0+NMU+PzJ1bK7P9VjfN3vHJ7/Zb2dg1xz8dm93N1dk+3DI7h4/N80tqOnlwx6yvrpudvQOzv7dn9g8fmrP5PI8OzNbGtjk4fmiOH9wze3uH5tG5STgPbq+atTtHr877aM+sc8ts7Z7b7/kDs7O2afYfvXb15w/N3uaqWbm1ZW7f3TV7+4fm+OTVuY/urJrV2w8u1Pz8yX2zd+e22d5YMyusmvWde+dqmn3Gt1ZWzcbOXbO7t2cOHry874dm99bK2YQkY4w5ubdpVlY3zZ17x7PJQM8fmf2tNbO2edfsH+ybvb0Dc/RknnOLiIiIyHXwmTHGLPQbB9DUJWVl4bQc7Kam5uWUnfdVUxY1luvifGwTeVNTVjW2415SS0NV1lgvJ+u8q6q6OTdFaFZnVVk4lxbZUFc1OPOdu8lG9OI2k/Gs577OI/rdPnmQUYzOtdk0FWVt477zg2mo64vTjeqqpMbGdS6pau5zi4iIiMindi0Cv3y4tO8y6RTE55r+q4mPX4woxu0FViYiIiIi14Gm9NxwXrdDORmTnfbY18WUUeoxChX2RURERERP+JdDlZOkORU2jtui3W7N1Q4kIiIiIstPgV9EREREZImppUdEREREZIkp8IuIiIiILDEF/iVW5zFh0ML2BmRn7xmrySY9/HaXMMrQK7JERERElpt6+Jdaw3Q8JI0jin5O0jt9A28dM058Bl3n7YeLiIiIyI2nJ/x/pCojGoyYVosqIKOyugyHHYrRiPx0a5PV2G2FfREREZE/AwX+P0idT4mykiydUiyqb6YooOVhd4YM7JhhPCskL6HlLqgmEREREfmk/mXRBSwr2wvoeSX1CJp3736qIuq4/McPFhvbPq71ht2ahroqyIufefZitmnt7jHlxOf8IVUGTgDg0h92GA1G5EGfApfuB97X29RFSppXZ/dr2R5+R+8EEBEREVmkGx/4qzSl8X3cRRdyJRx64yET7z+p3QHRxH9HWG6osinjUch4GpGOfTpnib8mayzapyewOiEDy2cYOfh2jzd9l/gwFUnYZVj1iCY9WtastnI6IPBhEE8I1EEkIiIishA3uqWnyccEwfisN30ptELi8RbVN13603f1Alk47S6jaUE2qJkm5/Zvcio8XuXsFv2hTzaIwbvKZ+4NWdihl3WJo5dhf1abG0yI+xV9v0+qcUAiIiIiC3FzA381pRd8zT/n75e5Mdx+zGQHvuv1iOda8GvhhWPaVUYDNMWUcT9kkiQk5au97GBIGPi0W1dYbDGmP64Ihr1L/8ridIf0iOiPluprmYiIiMiNsdCxnHU6JpzMZsFbnZCRmzIYRpTOgCju0Wpy4uGYpLaxmho7GDIMXKw6oef9jW9/Blhjc8fH6/43g+aA4elT7vYgYmAnhKOYsgEsnzDq45UJ4TCabXMChgOLKByTVC3+63/a/N//JlQAXo+RXzIaRWSVTbs/ZtxrvWcrTMm43aWJMsL3Ddmn9zh175Glfa4yo1+lPHT510mbB1VM8IYPJ+07/Ns04Lia4H/S6kRERERkwXP4G6aBzb9//4KVjS18uyb/8Sd+ZYP9xzFWr83XRcBRFeHnfVp/neLdz5l2beq4i/P373mxss1hGRPYNjYJPedvfPsMtu8/Jena1HEH5+8/8GLlNg+amACoJj5/+epHWNtgy7Opsx/56RlsHZ4wyjz++s2vsLbF3UGPjp0w+Oo7fmad/cfF3MG9KRLiNCEexjTdIb2OT7fzfl8YmmyA50+whhlZ6F1x3/1VqJj4f+Grao9HkUtSOHjOuSqbmrRy6DUhX3zdcPAkZ+AurFgRERGRP6UFL9q1sGwLeMELOozTEDudEBUtuuUQ75/PYNOjZYHlerh8w/eTKVW3j2NbZ+ewHft0cauFZQHPXl3Bti7GZOvlsbVNL0rpNlMmcU07cLAKG/gV3IAw7OHiMg2/49tnJWleE7bm63+3Wh16rQ69/vjDP532iHiY0h52Cf2ccfu6Rf6GpgYsB6vJGfejC2/utYKYvm8BNZX6+EVEREQ+uWszpWfFdXEBy+8T+pCHvVluL2PCXo7VlFSrq6xWBSVwJUNfLBfXAYuAQTjbdFmn+exLxIu3ztf85ZdfSNN07kt/+eWXfPHFF+8qEC+MGSdtvur26eQRnWs149LGcVagrKjdPkk1eW09cEOelzRJDdi4F35pDfkkJPfH9K5rz5KIiIjIDXdtAv/rmvo0Xds+YTTCW2w57/Tbb79xdHQ09/6ff/75HIEfoEU/GjP1QqK0phNcp8Rv0+54EOaU9ojuhdIsPM9lOiphvY9/IfDPpgz57qeoVUREROTP6doGftdzgV+hzMkr8K75HHfP8/jHP/7xh5y7LjLoxUw+JOxXCaMI+mHnvV+AVecxoxj6o+4b33Pg9kJuj3pESUW3e8kvqU6IE9geDy4uPG4abK99DdcmiIiIiCyPxY/lbF79f75jxgn6bK8CL35gGE4pG6iLKYN+RAGANQuKLyqqsiKZTClxcE9TbVXVQEOelbw4vUBz7lqvX/7Vhjf37cw7AbTOY8Kghe0NyM4OqskmPfx2lzDKLvS6v1E5oT/xGI/f9RKuN7Bd/E77PY9tKJKIpMzJ4oy3Tga1AyZRQDkMSS7sWJOGIZk/Ieo5v9ueRRPi6ZAgiCjfqzYREREReS9mgZ4e75utNQxgWN0wd+49NCfnfn5ytGs2V09/zopZ29ozx09fHnxk7txaOT120+yd/uDJ/R2zBgZWzdr6ttm9s2lWVlbN2vqm2dk/NicnR2Z3c/X0nGtma/e+eXR6zuePD83t9dPrrWyYu0dPzOPDHXOL2bbVrX3z8KmZw3Pz4GDP7G6ume3Dc3f09L45uH/y5sMufEAPzd7OXXP0Hoe8Xsfz5x96rDHm6aHZXt81D+fY9eR439zevm32HzwyT54+NSePjszB7W2zs3dkLpT/+MgcPTHGnNwzWxv75vFHlCgiIiIib7fgsZzzaKiKgtpyabmvP6euKYsay3X5/TTIkrKycFoOdlNTY2N/0r6RlMnEpuuO8QY202KMBzTJhLjVp+fOc46KuNenHMSE3jzFNxRZgdueje9siilR2kA2oegnswk/TU48Sd/yxN6iFfTpvKyvjui0c4bFmPY8JQNNlZPlFTgt2p771nadOg5opyHFZN6zi4iIiMj7urY9/K9YOC3vDVN5bNxLxmRatsvZZsv+sFaYj1EU0Opj+0MGdpthPGTatclLaHXmOUFDPuqTdCZEc4V9aIoJ46zDLDvXZKVDr98my4ekLxO+5RH03Le2Jlkf+WFZjoc/1z1CnhR4wXVfji0iIiJysy2+h38JVRk4HoBLf9ghG47Im5ICd65pQ9V0wLAOmVy2CPay/dMRnU6M23m5LNbG77SxyEkyB//c/H7LtrHf8u/T/SEkJ8l/X5uIiIiIXL0b8IT/pqnJGov26ZNyqxMysHyGkYNv994ZqJtiTHdYEwxr0iR5w04NdV1RFTlpMiX56VdebBwQvT4Gp8rI6HC2XrbOmAzj00XPl7HwByMCd47b/FhlSmYF9K/59CURERGRm06B/6o1ORXnW5Ba9Ic+426Mnw/edTB5WuB6Fvk0vvQlYK+zvQ5dD5zg4ujMOk2o2uGrcZh2m/54vn75Mo1IsillVRGNIyo/IPA+tjmqIem1mXYj2nGCN4rfOO5TRERERK7GDVi0e3M0xZTJaERUB4zG4avFrxSMuxHteDT34tcrqIak5xF3c6LO9WmbacqMJK9x2z6ec33qEhEREVlWCvzLphjjhxajQclo7DKa9i++8EpERERE/jQU+JdOTZGkFFYL3299+glFIiIiInKtKPCLiIiIiCwxjeUUEREREVliC53Sk6bpIi8vIiIiIjec7/uLLuHaW2hLz2elFMunAAAA/klEQVSffbaoS4uIiIjIElB3+rst9An/8fHxIi8vIiIiIrL0tGhXRERERGSJadGuiIiIiMgSU+AXEREREVliCvwiIiIiIktMgV9EREREZIkp8IuIiIiILDEFfhERERGRJabALyIiIiKyxBT4RURERESWmAK/iIiIiMgSU+AXEREREVliCvwiIiIiIktMgV9EREREZIkp8IuIiIiILDEFfhERERGRJabALyIiIiKyxBT4RURERESWmAK/iIiIiMgSU+AXEREREVliCvwiIiIiIktMgV9EREREZIkp8IuIiIiILDEFfhERERGRJabALyIiIiKyxBT4RURERESW2P8DxUxvO+4invoAAAAASUVORK5CYII=)"
      ],
      "metadata": {
        "id": "Ftr_BgU9X0hh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GFbq0L8XBlbE"
      },
      "outputs": [],
      "source": [
        "#@title git merge many\n",
        "def git_merge_many(models, runs=100, digit=4): \n",
        "\n",
        "  print(f'GIT MERGE OVER {len(models)} MODELS')\n",
        "  for run in range(runs): \n",
        "    progress = False\n",
        "        \n",
        "    for i in np.random.permutation(list(range(len(models)))): \n",
        "      \n",
        "      m_avg = average_multiple_model(models[:i] + models[i+1:])    \n",
        "      new_model = git_merge(m_avg, models[i], silent=True)\n",
        "      \n",
        "      #cos similarity max=1, min=0\n",
        "      old_cos = round(cosine_similarity(models[i], m_avg), digit)\n",
        "      new_cos = round(cosine_similarity(new_model, m_avg), digit)\n",
        "      \n",
        "      #l2 norm\n",
        "      #old_distance = round(l2_similarity(m_avg, models[i]), digit)\n",
        "      #new_distance = round(l2_similarity(m_avg, new_model), digit)\n",
        "      \n",
        "      models[i] = new_model\n",
        "      \n",
        "      progress = progress or (old_cos < new_cos)\n",
        "      print(f'sub_run:{run} |P(model{i})| similarity_gain: {round((new_cos - old_cos), digit)} | progress: {progress}')\n",
        "\n",
        "    if not progress: \n",
        "      print('---------------------------')\n",
        "      print('CONVERGENCE AT RUN : ', run, '\\n')\n",
        "      break\n",
        "  return average_multiple_model(models)\n",
        "\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h1>Experiments</h1>"
      ],
      "metadata": {
        "id": "CxLWE5El9rZM"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QtAH5cus3Isu"
      },
      "source": [
        "# small net over mnist, fashion\n",
        "First test over a trained model, the SNet contains 4 dense layers with at most 50 neurons for each layer. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tzmSewmvacFW"
      },
      "outputs": [],
      "source": [
        "model_A_mnist, model_B_mnist = SNet(mnist_input_size, bias=True), SNet(mnist_input_size, bias=True)\n",
        "model_A_fashion, model_B_fashion = SNet(mnist_input_size, bias=True), SNet(mnist_input_size, bias=True)\n",
        "\n",
        "model_A_mnist = model_A_mnist.to(device)\n",
        "model_B_mnist = model_B_mnist.to(device)\n",
        "#--------------------------------------\n",
        "model_A_fashion = model_A_fashion.to(device)\n",
        "model_B_fashion = model_B_fashion.to(device)\n",
        "#--------------------------------------\n",
        "\n",
        "# consider other loss --> hinge Loss \n",
        "loss_fn = nn.CrossEntropyLoss().to(device)\n",
        "epochs = 100\n",
        "\n",
        "optimizer_A_mnist = optim.Adam(model_A_mnist.parameters())\n",
        "optimizer_B_mnist = optim.Adam(model_B_mnist.parameters())\n",
        "#--------------------------------------\n",
        "optimizer_A_fashion = optim.Adam(model_A_fashion.parameters())\n",
        "optimizer_B_fashion = optim.Adam(model_B_fashion.parameters())\n",
        "#--------------------------------------"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_VTeIWR9asUi"
      },
      "outputs": [],
      "source": [
        "train_target_small = [\n",
        "    ('model_A_mnist', model_A_mnist, data_loaders['mnist']['train'], optimizer_A_mnist), \n",
        "    ('model_B_mnist', model_B_mnist, data_loaders['mnist']['train'], optimizer_B_mnist), \n",
        "\n",
        "    ('model_A_fashion', model_A_fashion, data_loaders['fashion']['train'], optimizer_A_fashion),\n",
        "    ('model_B_fashion', model_B_fashion, data_loaders['fashion']['train'], optimizer_B_fashion), \n",
        "              ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0xdDqk2VbzHV"
      },
      "outputs": [],
      "source": [
        "result_loss_small = defaultdict(list)\n",
        "\n",
        "for (name, model, loader, opt) in train_target_small: \n",
        "  scaler = GradScaler() #prevent gradient to underflow\n",
        "  print(f'{name = }')\n",
        "  for epoch in tqdm.tqdm(range(epochs)): \n",
        "    result_epoch = train_loop(loader, model, \n",
        "                              loss_fn, opt,\n",
        "                              scaler,\n",
        "                              print_score=False,\n",
        "                              return_loss=True)\n",
        "    result_loss_small[name].append(result_epoch)\n",
        "  torch.save(model.state_dict(), f'SNet_{name}_Adam.pt')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "is8SYPqApMTg",
        "outputId": "cbc651fb-c937-407d-9ae4-347e846a18b5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 58,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "sub_path = path + '/SNet/'\n",
        "model_A_mnist.load_state_dict(torch.load(sub_path + 'SNet_model_A_mnist_Adam.pt'), map_location=device)\n",
        "model_B_mnist.load_state_dict(torch.load(sub_path + 'SNet_model_B_mnist_Adam.pt'), map_location=device)\n",
        "\n",
        "model_A_fashion.load_state_dict(torch.load(sub_path + 'SNet_model_A_fashion_Adam.pt'), map_location=device)\n",
        "model_B_fashion.load_state_dict(torch.load(sub_path + 'SNet_model_B_fashion_Adam.pt'), map_location=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fBPs7sRtPLTP"
      },
      "outputs": [],
      "source": [
        "#generic coef of parameters for interpolation \n",
        "coef_vector = np.linspace(start=0.0, stop=1.0, num=10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q-SWtjzxAIc-"
      },
      "source": [
        "### mnist"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ul8j5i5bdaSZ",
        "outputId": "d105a0ba-deba-45b0-a6e2-084aaaaf822f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 97.4%, Avg loss: 0.211897 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 96.8%, Avg loss: 0.288618 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], model_A_mnist, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['mnist'], model_B_mnist, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qhius9g_l22d",
        "outputId": "0a4e3bba-0d65-4c43-8ab4-ff46ffad5d86"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "run:0 || P1; gain: 982.4390106535202\n",
            "run:0 || P2; gain: 62.219292408888755\n",
            "run:0 || P3; gain: 32.97991719567089\n",
            "run:1 || P2; gain: 12.073492276879335\n",
            "run:1 || P3; gain: 3.945149566709773\n",
            "run:1 || P1; gain: 4.1647983228778\n",
            "run:2 || P1; gain: 0.0\n",
            "run:2 || P2; gain: 1.4966277913999022\n",
            "run:2 || P3; gain: 0.0\n",
            "run:3 || P2; gain: 0.0\n",
            "run:3 || P3; gain: 0.0\n",
            "run:3 || P1; gain: 0.0\n",
            "---------------------------\n",
            "stop progress at run :  3\n",
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 80.4%, Avg loss: 1.592895 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.2119  | 97.360\n",
            "   1  | 0.11 |   0.1778  | 96.730\n",
            "   2  | 0.22 |   0.3666  | 90.280\n",
            "   3  | 0.33 |   1.4956  | 61.480\n",
            "   4  | 0.44 |   2.9797  | 33.100\n",
            "   5  | 0.56 |   2.8354  | 36.210\n",
            "   6  | 0.67 |   1.4445  | 64.420\n",
            "   7  | 0.78 |   0.5008  | 87.980\n",
            "   8  | 0.89 |   0.2354  | 96.050\n",
            "   9  | 1.00 |   0.2886  | 96.820\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.2119  | 97.360\n",
            "   1  | 0.11 |   0.2018  | 97.380\n",
            "   2  | 0.22 |   0.2127  | 96.850\n",
            "   3  | 0.33 |   0.2869  | 94.980\n",
            "   4  | 0.44 |   0.4856  | 91.100\n",
            "   5  | 0.56 |   0.7726  | 87.360\n",
            "   6  | 0.67 |   1.0819  | 84.060\n",
            "   7  | 0.78 |   1.3496  | 81.980\n",
            "   8  | 0.89 |   1.5296  | 81.050\n",
            "   9  | 1.00 |   1.5929  | 80.400\n"
          ]
        }
      ],
      "source": [
        "permuted_B_mnist = git_merge(model_A_mnist, model_B_mnist, silent=False)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['mnist'], permuted_B_mnist, loss_fn, test_set=True, device=device)\n",
        "\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['mnist'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_mnist, model_B_mnist,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['mnist'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_mnist, permuted_B_mnist, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "tAjsjjE5oibK",
        "outputId": "c5bf67a2-9458-4563-8116-1fda51552efe"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'mnist_small')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Still, here we can check the first requirement for this method: a net should be wider than usual. Although the singular models achieve good performance over the Mnist dataset (accuracy = 97%, 96%), the permuted model gets an accuracy lower  than the original (80%) and the average loss increases.\n",
        "\\\n",
        "In any case, the permuted model lies in a section where it's easier to interpolate the model, as we can see from the plot about the barrier, that disappears. The \"only\" problem here is the absence of a linear path."
      ],
      "metadata": {
        "id": "a7opc4DPioZX"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5TE6fwD5AS4a"
      },
      "source": [
        "### Fashion"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHbKl50CrURt"
      },
      "source": [
        "In this second test we explored the same model over a more \"complex\" dataset, just to see if we get the same result as the mnist dataset. As we can see in the following plot, the result will be the same.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qidAonsJPUe0",
        "outputId": "f34a471f-789e-4f8b-da44-2e60619388bb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 87.5%, Avg loss: 0.597280 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 87.2%, Avg loss: 0.594700 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['fashion'], model_A_fashion, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['fashion'], model_B_fashion, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tm0nlaHmPa9Y",
        "outputId": "7d719106-990e-43d0-92e7-05e7ad612f28"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "run:0 || P1; gain: 1205.5880126059856\n",
            "run:0 || P2; gain: 59.790645862198915\n",
            "run:0 || P3; gain: 44.40863471178899\n",
            "run:1 || P2; gain: 12.767317736634823\n",
            "run:1 || P1; gain: 1.932695494631389\n",
            "run:1 || P3; gain: 1.374046672334174\n",
            "run:2 || P2; gain: 1.1692502982442647\n",
            "run:2 || P1; gain: 0.0\n",
            "run:2 || P3; gain: 0.1414792623098151\n",
            "run:3 || P3; gain: 0.0\n",
            "run:3 || P2; gain: 0.0\n",
            "run:3 || P1; gain: 0.0\n",
            "---------------------------\n",
            "stop progress at run :  3\n",
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 61.3%, Avg loss: 1.223640 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.5973  | 87.460\n",
            "   1  | 0.11 |   0.5918  | 84.050\n",
            "   2  | 0.22 |   0.8763  | 75.130\n",
            "   3  | 0.33 |   2.2341  | 48.510\n",
            "   4  | 0.44 |   3.6950  | 30.140\n",
            "   5  | 0.56 |   3.2877  | 26.910\n",
            "   6  | 0.67 |   1.6323  | 51.320\n",
            "   7  | 0.78 |   0.7657  | 75.770\n",
            "   8  | 0.89 |   0.5261  | 85.320\n",
            "   9  | 1.00 |   0.5947  | 87.220\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.5973  | 87.460\n",
            "   1  | 0.11 |   0.5278  | 87.440\n",
            "   2  | 0.22 |   0.5150  | 86.470\n",
            "   3  | 0.33 |   0.5522  | 84.230\n",
            "   4  | 0.44 |   0.6357  | 80.630\n",
            "   5  | 0.56 |   0.7523  | 76.010\n",
            "   6  | 0.67 |   0.8917  | 71.070\n",
            "   7  | 0.78 |   1.0339  | 66.650\n",
            "   8  | 0.89 |   1.1470  | 63.220\n",
            "   9  | 1.00 |   1.2236  | 61.260\n"
          ]
        }
      ],
      "source": [
        "permuted_B_fashion = git_merge(model_A_fashion, model_B_fashion, silent=False)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['fashion'], permuted_B_fashion, loss_fn, test_set=True, device=device)\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "2Xllv8JpNYH7",
        "outputId": "560aef5e-4fdd-4799-8ec0-6392bddce12b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'fashion_small')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MgDTEfjf3TU_"
      },
      "source": [
        "# Wider net over mnist, fashion, cifar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ACTUDF6Osbrz"
      },
      "source": [
        "As we have seen previously, a wider net shows better behaviour for permutation matching. Entezari et al theorize that it's because the hyper-parametrization of the loss creates a smoothed outline, that helps to create a linear path."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8LSG-f86yJQd"
      },
      "outputs": [],
      "source": [
        "model_A_mnist, model_B_mnist = MNet(mnist_input_size, bias=True), MNet(mnist_input_size, bias=True)\n",
        "model_A_fashion, model_B_fashion = MNet(mnist_input_size, bias=True), MNet(mnist_input_size, bias=True)\n",
        "model_A_cifar, model_B_cifar = MNet(cifar_input_size, bias=True), MNet(cifar_input_size, bias=True)\n",
        "\n",
        "model_A_mnist = model_A_mnist.to(device)\n",
        "model_B_mnist = model_B_mnist.to(device)\n",
        "#--------------------------------------\n",
        "model_A_fashion = model_A_fashion.to(device)\n",
        "model_B_fashion = model_B_fashion.to(device)\n",
        "#--------------------------------------\n",
        "model_A_cifar = model_A_cifar.to(device)\n",
        "model_B_cifar = model_B_cifar.to(device)\n",
        "\n",
        "# consider other loss\n",
        "loss_fn = nn.CrossEntropyLoss().to(device)\n",
        "epochs = 100\n",
        "\n",
        "optimizer_A_mnist = optim.Adam(model_A_mnist.parameters())\n",
        "optimizer_B_mnist = optim.Adam(model_B_mnist.parameters())\n",
        "#--------------------------------------\n",
        "optimizer_A_fashion = optim.Adam(model_A_fashion.parameters())\n",
        "optimizer_B_fashion = optim.Adam(model_B_fashion.parameters())\n",
        "#--------------------------------------\n",
        "optimizer_A_cifar = optim.Adam(model_A_cifar.parameters())\n",
        "optimizer_B_cifar = optim.Adam(model_B_cifar.parameters())\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TZyM1W43Zih1"
      },
      "outputs": [],
      "source": [
        "train_target_medium = [\n",
        "    ('model_A_mnist', model_A_mnist, data_loaders['mnist']['train'], optimizer_A_mnist), \n",
        "    ('model_B_mnist', model_B_mnist, data_loaders['mnist']['train'], optimizer_B_mnist), \n",
        "\n",
        "    ('model_A_fashion', model_A_fashion, data_loaders['fashion']['train'], optimizer_A_fashion),\n",
        "    ('model_B_fashion', model_B_fashion, data_loaders['fashion']['train'], optimizer_B_fashion), \n",
        "\n",
        "    ('model_A_cifar', model_A_cifar, data_loaders['cifar']['train'], optimizer_A_cifar),\n",
        "    ('model_B_cifar', model_B_cifar, data_loaders['cifar']['train'], optimizer_B_cifar),\n",
        "              ]\n",
        "\n",
        "coef_vector = np.linspace(start=0.0, stop=1.0, num=10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NoR8qjnTZ181",
        "outputId": "997c0728-c25d-4309-de3d-aa93c5c9e2ef"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_B_cifar', medium net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [20:09<00:00, 12.09s/it]\n"
          ]
        }
      ],
      "source": [
        "result_loss_medium = defaultdict(list)\n",
        "\n",
        "for (name, model, loader, opt) in train_target_medium: \n",
        "  scaler = GradScaler() #prevent gradient to underflow\n",
        "  print(f'{name = }, medium net')\n",
        "  for epoch in tqdm.tqdm(range(epochs)): \n",
        "    result_epoch = train_loop(loader, model, \n",
        "                              loss_fn, opt,\n",
        "                              scaler,\n",
        "                              print_score=False,\n",
        "                              return_loss=True)\n",
        "    result_loss_medium[name].append(result_epoch)\n",
        "  torch.save(model.state_dict(), f'MNet_{name}_Adam.pt')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m3q33HPlXibU",
        "outputId": "5f9bbac7-6bd5-4585-f09b-8563bd348ea3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 60,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "subpath = path +\"/MNet/\"\n",
        "model_A_mnist.load_state_dict(torch.load(subpath+'MNet_model_A_mnist_Adam.pt', map_location=device))\n",
        "model_B_mnist.load_state_dict(torch.load(subpath+'MNet_model_B_mnist_Adam.pt', map_location=device))\n",
        "\n",
        "model_A_fashion.load_state_dict(torch.load(subpath+'MNet_model_A_fashion_Adam.pt', map_location=device))\n",
        "model_B_fashion.load_state_dict(torch.load(subpath+'MNet_model_B_fashion_Adam.pt', map_location=device))\n",
        "\n",
        "model_A_cifar.load_state_dict(torch.load(subpath+'MNet_model_A_cifar_Adam.pt', map_location=device))\n",
        "model_B_cifar.load_state_dict(torch.load(subpath+'MNet_model_B_cifar_Adam.pt', map_location=device))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QGgUI-hbfQ54"
      },
      "source": [
        "##mnist"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AxZRYW4WfPyz",
        "outputId": "54467648-7e6b-4016-bf91-2e11b1b8cf7a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 98.6%, Avg loss: 0.212665 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 98.6%, Avg loss: 0.218879 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], model_A_mnist, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['mnist'], model_B_mnist, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nO-6PHNGfg2Y",
        "outputId": "22e0c7ff-9861-4fa2-94df-f7fde115f024"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "run:0 || P3; gain: 451.0353301437199\n",
            "run:0 || P1; gain: 3343.7767522898266\n",
            "run:0 || P2; gain: 1195.192184372091\n",
            "run:1 || P1; gain: 51.66090895612615\n",
            "run:1 || P3; gain: 495.30973823547174\n",
            "run:1 || P2; gain: 109.08458525749575\n",
            "run:2 || P3; gain: 77.94914223344631\n",
            "run:2 || P2; gain: 11.466581162332659\n",
            "run:2 || P1; gain: 9.608738873261245\n",
            "run:3 || P1; gain: 0.0\n",
            "run:3 || P2; gain: 4.647542077784237\n",
            "run:3 || P3; gain: 25.342510036724434\n",
            "run:4 || P3; gain: 0.0\n",
            "run:4 || P1; gain: 0.8972917726023297\n",
            "run:4 || P2; gain: 2.4619396433827205\n",
            "run:5 || P1; gain: 0.7327414368955942\n",
            "run:5 || P2; gain: 0.17387695514480583\n",
            "run:5 || P3; gain: 4.549831230157906\n",
            "run:6 || P2; gain: 1.4881607094621359\n",
            "run:6 || P1; gain: 0.3219292105641216\n",
            "run:6 || P3; gain: 2.1880863537621735\n",
            "run:7 || P3; gain: 0.0\n",
            "run:7 || P1; gain: 0.0\n",
            "run:7 || P2; gain: 0.0\n",
            "---------------------------\n",
            "stop progress at run :  7\n",
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 98.5%, Avg loss: 0.101155 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.2127  | 98.590\n",
            "   1  | 0.11 |   0.1161  | 98.360\n",
            "   2  | 0.22 |   0.0887  | 97.700\n",
            "   3  | 0.33 |   0.4142  | 92.410\n",
            "   4  | 0.44 |   1.5157  | 49.160\n",
            "   5  | 0.56 |   1.5793  | 45.960\n",
            "   6  | 0.67 |   0.4943  | 89.860\n",
            "   7  | 0.78 |   0.0898  | 97.610\n",
            "   8  | 0.89 |   0.1093  | 98.460\n",
            "   9  | 1.00 |   0.2189  | 98.570\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.2127  | 98.590\n",
            "   1  | 0.11 |   0.1814  | 98.550\n",
            "   2  | 0.22 |   0.1565  | 98.550\n",
            "   3  | 0.33 |   0.1378  | 98.580\n",
            "   4  | 0.44 |   0.1236  | 98.600\n",
            "   5  | 0.56 |   0.1131  | 98.600\n",
            "   6  | 0.67 |   0.1067  | 98.530\n",
            "   7  | 0.78 |   0.1027  | 98.510\n",
            "   8  | 0.89 |   0.1008  | 98.480\n",
            "   9  | 1.00 |   0.1012  | 98.510\n"
          ]
        }
      ],
      "source": [
        "permuted_B_mnist = git_merge(model_A_mnist, model_B_mnist, silent=False)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['mnist'], permuted_B_mnist, loss_fn, test_set=True, device=device)\n",
        "\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['mnist'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_mnist, model_B_mnist,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['mnist'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_mnist, permuted_B_mnist, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DIr79iSAt55x"
      },
      "source": [
        "From the table printed above, we can see that the accuracy remains stable.\n",
        "\\\n",
        "Indeed, the loss decreased, pointing to a better set of weights respect the original models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 288
        },
        "id": "VA7OzkTWfjIJ",
        "outputId": "60aa8073-64f9-4d85-c019-462d9f19987f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'mnist MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBlypHTzjg52"
      },
      "source": [
        "## fashion\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lXyqkYFgusTm"
      },
      "source": [
        "Come back to the F_mnist dataset, the permuted net shows the same characteristics of the Mnist experiment. We lost a bit of accuracy (1.5%) but the path between the models results is still linear."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zzx8phh0jkS7",
        "outputId": "df0460de-c8b3-49a8-cf6d-ef9f07cfdb6a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 89.4%, Avg loss: 0.971641 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 89.5%, Avg loss: 1.062084 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['fashion'], model_A_fashion, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['fashion'], model_B_fashion, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vLNoWjUcjous",
        "outputId": "65875268-7e5a-443f-898d-08a30dd69659"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 88.0%, Avg loss: 0.442848 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.6183  | 87.430\n",
            "   2  | 0.22 |   0.6788  | 79.390\n",
            "   3  | 0.33 |   1.2071  | 58.560\n",
            "   4  | 0.44 |   1.9680  | 29.040\n",
            "   5  | 0.56 |   2.0848  | 30.510\n",
            "   6  | 0.67 |   1.3961  | 57.450\n",
            "   7  | 0.78 |   0.6810  | 80.920\n",
            "   8  | 0.89 |   0.6803  | 88.030\n",
            "   9  | 1.00 |   1.0621  | 89.540\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.7900  | 89.670\n",
            "   2  | 0.22 |   0.6554  | 89.650\n",
            "   3  | 0.33 |   0.5623  | 89.640\n",
            "   4  | 0.44 |   0.5027  | 89.140\n",
            "   5  | 0.56 |   0.4663  | 88.850\n",
            "   6  | 0.67 |   0.4484  | 88.710\n",
            "   7  | 0.78 |   0.4417  | 88.260\n",
            "   8  | 0.89 |   0.4414  | 87.940\n",
            "   9  | 1.00 |   0.4428  | 87.990\n"
          ]
        }
      ],
      "source": [
        "permuted_B_fashion = git_merge(model_A_fashion, model_B_fashion, silent=True)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['fashion'], permuted_B_fashion, loss_fn, test_set=True, device=device)\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "kQmsKw7ujs1r",
        "outputId": "48a6b0cb-91c4-4668-c5c1-31b208dce11d"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABCQAAAGjCAYAAAD0G8TOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUVf7H8fc3PQESejEQqougIigoYkOkWtefuOoiiq5GsKxgwRJQEEFRRBRERNeOZe0iFrCgKKBUBUUUkdAhkJAAKWSS8/tjhmwSgrRkbsrn9TzzZOacWz53oszJd+4915xziIiIiIiIiIgEU4jXAURERERERESk6lFBQkRERERERESCTgUJEREREREREQk6FSREREREREREJOhUkBARERERERGRoFNBQkRERERERESCTgUJERGRUmRm/zazX8wsy8ycmQ0uw311DexjxCGsMyKwTteyylVV7O+9DLTN9iaViIhIxRHmdQAREZHKwswuB54AlgATgBxgvqehRERERMopFSRERERKz/l7fzrnNnqaZP8mAW8Aa70OIiIiIlWbChIiIiKl5yiAclyMwDm3DdjmdQ4RERERzSEhIiJyhPbOJQCcHXjt9j4Cr/9uZq+a2W9mtjvwWBSYb2Kfz2Iza2Bm48xsZWDZHYHnL5pZi/1kaG9mMwLLZprZ12bWZX9ZS5pDwszOMbNPzSzVzHICeR82s7gSlp0d2E6Ymd1rZr8H1llnZmPNLOLQ38mCbbczs9fNbE1gmylmttjMJphZeEnHYmZXBN7TTDPbaGbjzSwysFy3QN4MM0szs1fMrE4J+z3bzKYG5gDJCMwDstzM7jezqMM9HhERESmZzpAQERE5crMDPwcATYGRxfofBvKB74ENQBzQDf98E52A/nsXNLMY4DugJTALmA5YYLsXAW8Dq4ttvyMwFJgHPAckAJcAX5hZe+fcygMdgJndADwN7AbeArYCXYG7gAvM7DTn3I4SVn0NOAP4BMgAzg1kqQ9cc6D9lpCjHf73yQEfAn8CsUAr4EZgGJBbbLVbgD7A+/h/Fz2BIUBtM/sA/yUqM4CpQBfgSqBuYJ3C7gKOAeYGlo8CTgNGAF3NrLtzLu9Qj0lERERKpoKEiIjIEXLOzQZmB846aOqcG1FskfOcc38UbgicGfECcJWZTXLOfR/oOgd/MWKCc25IsXUigMgSIpwHXOOce7HQsjcAU4Bb8f8hv19m1hR4EtgFnOyc+7VQ32RgEPAIkFjC6i2BY51zqYHlk4AfA8d1j3Nu81/tuwRX4y8E/N0590GxnLWAzBLW6Q6c5JxbEVguEliMv9BzAdDTOfd1oC8E+AzoHSjWLC20nRuBP51zrth+R+EvhPQF3jzE4xEREZH90CUbIiIiZax4MSLQlo//DAmAXiWsllXCOnuccztLWPa7wsWIgOcBH3DyQUS8EogAJhUuRgQkATuB/nsvgSjmrr3FiEDG3cA0/GOMjgex7/0p6fjTAu9bcU/uLUYElsvBXzgIAWbsLUYE+vKBVwMvTyi2/dXFixEBjwd+lvR7EhERkcOkgoSIiEgZM7M6gbkYfjKzXYXml1gUWCS+0OJf47+s4+7AfA7/NrOTzCz0L3axsHiDcy4X2ALUOoiIJwZ+flnCdtLw38Y0Cv/lDAfcN7Au8PNg9l3cm0Ae8L6ZvWxmV5lZywOsU1KGvROLLiqhb0PgZ+PCjWZWLTAfxgIzSzez/MDvaXtgkXhERESk1OiSDRERkTJkZjWBBUBz4AfgZSAV/9kLNfFfUlFw5oFzLsPMOuOfh+JC/vet/LbA5RMPBooNhZU0twOBffxVIWOvvZNWbtpP/972msU79jOvhC/w82D2XXx7P5jZGfjPzOhLYH4NM1sJjHTOvV7Caul/keGv+gpPkBmOvyBzMrAcf2Ekhf/NV3E/JV8uIyIiIodJBQkREZGydR3+YsTI4nNLmNmp+AsSRTjn1gP/MjMD2uKfAPMm4D78ZzcOL+WMe/9obwj8XEJ/o2LLlSnn3Dzg/MAlIicBvfFPXPmamaU45z4vg91ehL8Y8aJzrshknGbWCH9BQkREREqRLtkQEREpW60CP98poe+sv1rR+f3snJsI9Ag0/700wwUsCfzsWrwjcIZHeyAbWFG8vyw553Kcc3Odc/cB/w40X1RGu9v7e3q3hL6//D2JiIjI4VFBQkREpGytCfzsWrjRzDoA9xRf2MyONbMGJWxnb1tJd5k4Uq/ivzThFjNrVaxvFP7bbr4amCyyTJlZFzOLLqGrLI8f9v97agGMLaN9ioiIVGm6ZENERKRsvQzcCUwws7OB34GjgfPxfxt/WbHlewCPmtk84DdgK/7JFy8C8oFHSzugc26NmQ0GngIWm9l/8c+fcBZwKvArcFdp73c/hgLdzGwO8Cf+W5EeC/QB0oCpZbTf6cAq4DYzOx7/WSMJ+H9PMwLPRUREpBSpICEiIlKGnHMbA5M0Pgycjn+Syl+BG4HP2bcg8Rn+P37PxF+EiMU/qeQsYLxzbm4Z5ZxsZquAO4BLgBj8d8t4FBizn8kry8Jk/IWHU/C/X2HA+kD7Y8655LLYqXNut5l1w/976gqcAazGf4bIePb9PYmIiMgRspJvty0iIiIiIiIiUnY0h4SIiIiIiIiIBJ0KEiIiIiIiIiISdJpDQkRERMqUmY04yEXfd84tLcssIiIiUn5oDgkREREpU2Z2sIONa5xzL5ZlFhERESk/VJAQERERERERkaDTHBIiIiIiIiIiEnQqSIiIiIiIiIhI0KkgISIiIiIiIiJBp4KEiIiIiIiIiASdChIiIiIiIiIiEnQqSIiIiIiIiIhI0KkgIVJJmdkUMxte2sseYDvNzMyZWdiRbusw9v2imT14kMuuMbPuZZ1JREREyhczG2Bm33q074Maf3g5nhIJNv1HLlJJOecGlsWyIiIiIl4xs9nAq86557zOIiJHTmdIiFRCZhbqdQYRERGp2vQNv4gciAoSIhWEmbUxs9lmtsPMfjazCwv1vWhmT5vZx2a2Gzi7+CUMZjbUzDaZ2UYzuy5wKmCrQus/GHje1czWm9ntZrY1sM41hbZznpktMbMMM1tnZiMO4RjWmNmdZvaTme02s/+YWQMz+8TMdprZ52ZWq9DyFwaOdUfg2NsU6utgZosD670JRBXb1/lmtjSw7lwza3dIb7iIiEgVFfi8vsfMfjGzNDN7wcyiCvXv9zM2sO5dZvYTsNvMWgXGHNcExg1pZjbQzDoFxgM7zGxSofVHmNmrhV4XXL5gZqOBM4BJZrZr73pmdoyZzTKzVDNbaWb/KLR+HTP7MDBu+QFo+RfH3ewQs4aY2TAzSw6MmV42s7hC/f0DfdvNLKnYvkLM7G4z+yPQ/18zq33ovy2Rik0FCZEKwMzCgenATKA+cAswzcxaF1rsn8BooAbwbbH1ewO3Ad2BVkDXA+yyIRAHxAP/Ap4qVCjYDVwF1ATOAwaZ2d8P4XAuAXoAfwMuAD4B7gXq4f836d+BzH8DXgcGB/o+BqabWYSZRQDvA68AtYG3Atvde7wdgOeBG4A6wDPAh2YWeQg5RUREqrJ+QC/8f8D/DRgGB/0ZewX+MUJNwBdoOwU4GrgMmAAk4R+XHAv8w8zOOlAg51wSMAe42TlX3Tl3s5lVA2YBr+EfI10OTDaztoHVngKygUbAtYHHgRxs1gGBx9lAC6A6sLdI0hZ4GugPHIX/vWpcaB+3AH8Hzgr0pwWyilQpKkiIVAyd8X/IPeyc2+Oc+xL4CP8H/l4fOOe+c87lO+eyi63/D+AF59zPzrlMYMQB9pcLPOCcy3XOfQzsAloDOOdmO+eWBfbzE/6iwQEHEYVMdM5tcc5twD+o+N45tySQ+T2gQ2C5y4AZzrlZzrlcYBwQDXQJvB/hwIRAxreBBYX2kQg845z73jmX55x7CcgJrCciIiIHNsk5t845l4r/C4+9Y46D+Yx9MrBuVqG2Uc65bOfcTPxfbrzunNtaaDzQgcNzPrDGOfeCc87nnFsCvANcav5LWC8B7nPO7XbOLQdeOohtHmzWfsB459xq59wu4B7gcvNfqtIX+Mg5941zLgcYDuQX2sdAIMk5tz7QPwLoa7rMRaoY/QcvUjEcBaxzzhX+IEvGfwbDXusOsP7Cg1wWYLtzzlfodSb+gghmdgrwMHAcEAFE4j9D4WBtKfQ8q4TX1QtlTt7b4ZzLN7N1+I85D9jgnHOF1k0u9LwpcLWZ3VKoLSKwTRERETmwwmOFZP73GXown7EljTMO9vP/UDUFTjGzHYXawvCfRVkv8Lz4sRzIYY1VAs/DgAaBvoL9Oud2m9n2YrnfM7PCY7u8wLoiVYbOkBCpGDYCTcys8P+zCcCGQq8d+7eJoqcJNjmCLK8BHwJNnHNxwBTAjmB7+7MR/4c1AGZm+HNvwH888YG2vRIKPV8HjHbO1Sz0iHHOvV4GOUVERCqjwmOFBPyfy3Bwn7F/NSY5kN1ATKHXDYv1F9/2OuDrYnmqO+cGASn4LxkpfiylpchYJbBtH/4CxqbC+zWzGPyXbRTO3adY7qjAWRgiVYYKEiIVw/f4z1IYambhZtYV//wLbxzk+v8FrjH/xJgx+E8bPFw1gFTnXLaZnYx/7oqy8F/gPDM7JzCHxu34TwmdC8zD/4H/78D78X/AyYXWfRYYaGanmF8180/GWaOMsoqIiFQ2N5lZ48BEi0nAm4H2sv6MXQqcaWYJgQki7ynWvwX/fA17fQT8LTCBZHjg0cnM2jjn8oB3gRFmFhOY1+HqUsoJ/stWh5hZczOrDowB3gycZfo2cL6ZnR6Y++oBiv7tNQUYbWZNAcysnpldVIrZRCoEFSREKgDn3B78BYg+wDZgMnCVc+7Xg1z/E+BJ4CtgFTA/0JVzGHFuBB4ws53AffgLB6XOObcSuBKYiP+YLwAuCMyhsQf4P/wTSaXin2/i3ULrLgSuxz+xVBr+Yx5QFjlFREQqqdfwT6a9GvgDeBDK/jPWOTcLf/HjJ2AR/oJDYU/gn2shzcyedM7tBHrin8xyI7AZGIv/klKAm/FfYrEZeBF4obSy4p/c8xXgG+BP/JNn3hI4jp+Bm/C/j5vwv1frix3Hh8DMwJhqPv7JNEWqFCt6CbaIVAXmv33mciCy2FwRIiIiUsWZ2RrgOufc515nEZHKTWdIiFQRZnaxmUUGbt85FpiuYoSIiIiIiHhFBQmRquMGYCv+0y7zgEHexhERERERkapMl2yIiIiIiIiISNDpDAkRERERERERCToVJEREREREREQk6MK8DlAa6tat65o1a+Z1DBERkXJn0aJF25xz9bzOURVoPCIiIlKy/Y1HKkVBolmzZixcuNDrGCIiIuWOmSV7naGq0HhERESkZPsbj+iSDREREREREREJOhUkRERERERERCToVJAQERERERERkaALakHCzJqY2Vdm9ouZ/Wxmt5awTFczSzezpYHHfcHMKCIiIpWbxiMiIiLlQ7AntfQBtzvnFptZDWCRmc1yzv1SbLk5zrnzg5xNREREqgaNR0RERMqBoJ4h4Zzb5JxbHHi+E1gBxAczg4iIiFRtGo+IiIiUD57d9tPMmgEdgO9L6D7VzH4ENgJ3OOd+DmI0ERE5DBkZGWzdupXc3Fyvo1QJ4eHh1K9fn9jYWK+jVGgaj4iIVB7Z2dmkpKSQnZ2Nz+fzOk6lFxYWRlRUFPXq1SMqKurwtlHKmQ6KmVUH3gEGO+cyinUvBpo653aZ2bnA+8DRJWwjEUgESEhIKOPEIiLyVzIyMtiyZQvx8fFER0djZl5HqtScc2RlZbFhwwYAFSUOk8YjIiKVR3p6Olu2bKFevXo0bNiQsLAwjUfKkHMOn8/Hrl27WLt2LQ0aNCAuLu6QtxP0u2yYWTj+D/9pzrl3i/c75zKcc7sCzz8Gws2sbgnLTXXOdXTOdaxXr16Z5xYRkf3bunUr8fHxxMTE6MM/CMyMmJgY4uPj2bp1q9dxKiSNR0REKpdt27bRuHFjatWqRXh4uMYjZczMCA8Pp1atWjRu3Jjt27cf1naCfZcNA/4DrHDOjd/PMg0Dy2FmJ+PPeHhHJyIiQZGbm0t0dLTXMaqc6OhoXSJzGDQeERGpfPbs2aOxiEeio6PJyck5rHWDfcnGaUB/YJmZLQ203QskADjnpgB9gUFm5gOygMudcy7IOUVE5BDpm4jg03t+2DQeERGphPS56I0jed+DWpBwzn0L/GVa59wkYFJwEomIiEhVo/GIiIhI+RD0OSRERERERERERFSQEBERKeb9999n/PgSpxY4IgMGDKBZs2alvl0RERGpfKrCeEQFCRERkWLKagAwfPhw3nvvvVLfroiIiFQ+VWE8ooKEiIiUOzvfnklyh778Uf9Mkjv0ZefbM72OVKJDnVG6ZcuWdOjQoYzSiIiISGnSeKTsqSAhIiLlys63Z5Jy2yP41m8B5/Ct30LKbY8EbRAwYMAAXnrpJTZs2ICZYWY0a9aM2bNnY2a8++67XH/99dSrV48GDRoAsGrVKvr370/z5s2Jjo6mRYsWDBo0iLS0tH22XfgUyTVr1mBmPPPMM9x33300atSImjVrcsEFF7B+/fqgHK+IiIjsS+OR4IxHgn3bTxERqUI2XHTLPm3VL+pG3LUXk5+ZzaYr7tynf8+K1bisopV+l5XD1sEPk/HKdOIG/J3qF5+Db8MWttz44D7r17zxcqr1Oo09q9YS0SrhkDMPHz6clJQUFixYwIcffghAZGQk6enpANxyyy306dOHV155hezsbAA2btxIkyZNmDBhArVq1WL16tWMGTOGc889l3nz5h1wnw899BBdunTh+eefZ+vWrdx+++1ceeWVzJ49+5Dzi4iISFEaj5Tf8YgKEiIiUq7kp2WU3JGTG5T9t2zZknr16hEREUHnzp0L2vd+GJ988sk899xzRdY588wzOfPMMwted+nShVatWnHGGWewZMmSA54W2axZM1577bWC1ykpKdx5551s3LiRo446qhSOSkRERA6FxiPBGY+oICEiImUm/oOJ++0LiYkqsT+5Q1//6ZHFhDVuUGT5sPgGf7n9w/k24mBcfPHF+7Tt2bOHcePG8fLLL5OcnFzwTQXAypUrDzgAOPfcc4u8Pv744wFYu3atChIiIiJHSOOR8jse0RwSIiJSrtROSsSiI4u0WXQktZMSPUpUVKNGjfZpu+eeexgxYgRXXnklM2bM4IcffuDdd98FKDIY2J/atWsXeR0ZGXnQ64qIiEjp03gkOOMRnSEhIiLlSo2+PQFIHT0V34athMXXp3ZSYkG718xsn7Y33niDq666imHDhhW07dq1K5ixREREpBRpPBIcKkiIiEi5U6NvT08/8CMjI8nKyjro5TMzMwkPDy/S9sILL5R2LBEREQkijUfKngoSIiIixbRt25bU1FSefvppOnbsSFRU1F8u37t3b1566SWOP/54WrVqxbvvvsvcuXODlFZEREQqo6owHlFBQkREpJjrrruO+fPnc++997Jjxw6aNm3Kiy++uN/lJ06ciHOOpKQkwD8p1Ouvv87JJ58cpMQiIiJS2VSF8Yg557zOcMQ6duzoFi5c6HUMEZEqa8WKFbRp08brGFXSgd57M1vknOsYxEhVlsYjIiLe0VjEW4c7HtFdNkREREREREQk6FSQEBEREREREZGgU0FCRERERERERIJOBQkRERERERERCToVJEREREREREQk6FSQEBEREREREZGgU0FCRERERERERIJOBQkRERERERERCToVJEREREREREQk6FSQEBEREREREZGgU0FCRESkmPfff5/x48eXybbXrFnDiBEjWL16dZlsX0RERCqHqjAeUUFCRESkmLIeAIwcOdLzAYCIiIiUb1VhPKKChIiIlDvTpi2jWbMJhISMpFmzCUybtszrSCIiIlLFaDxS9lSQEBGRcmXatGUkJk4nOTkd5yA5OZ3ExOlBGwQMGDCAl156iQ0bNmBmmBnNmjUDICUlhYEDBxIfH09kZCTHHHMMU6dOLbL+5s2bufrqqznqqKOIjIykUaNGnH/++WzdupXZs2dz9tlnA9CjR4+C7c+ePTsoxyYiIiIHR+OR4AgL+h5FRKRKGDz4U5Yu3XzI682fv56cnLwibZmZufzrXx/w7LOLDmlb7ds3ZMKE3oe0zvDhw0lJSWHBggV8+OGHAERGRpKRkcHpp59OVlYWI0aMoHnz5nz22WcMGjSInJwcbrnlFgD69+9PcnIyjz76KE2aNGHLli188cUXZGZmcuKJJ/LUU09x00038eSTT9KpUycA2rZte0gZRURE5OBoPFK+xyMqSIiISLlS/MP/QO2lrWXLltSrV4+IiAg6d+5c0D5q1CiSk5NZtmwZRx99NADdu3dnx44djBw5kkGDBhEWFsa8efMYM2YM/fr1K1j30ksvLXi+98O+TZs2RbYvIiIi5YfGI8GhgoSIiJSJQ/0mYK9mzSaQnJy+T3vTpnHMnj3gCFMdvk8//ZRTTjmF5s2b4/P5Ctp79erFc889xy+//EK7du3o1KkTjz76KM45unXrxnHHHYeZeZZbRESkKtN4pHyPRzSHhIiIlCujR59DTEx4kbaYmHBGjz7Ho0R+W7du5ZtvviE8PLzIY++3Ddu3bwfgzTff5MILL+SRRx6hXbt2xMfH88ADD5Cfn+9lfBERETkEGo8Eh86QEBGRcqVfv+MBSEr6grVr00lIiGP06HMK2r1Sp04d6tevzxNPPFFif+vWrQGoX78+Tz31FE899RQrV67kpZde4v7776devXoMGjQomJFFRETkMGk8EhwqSIiISLnTr9/xnn7gR0ZGkpWVVaStd+/eTJw4kYSEBOrXr39Q22ndujVjxoxhypQpLF++vGDbwD7bFxERkfJF45Gyp4KEiIhIMW3btiU1NZWnn36ajh07EhUVxZAhQ3jzzTc544wzGDJkCK1bt2b37t38+uuvzJkzhw8++ID09HS6d+9Ov379OOaYYwgPD+eDDz4gLS2Nnj17AvC3v/2NsLAwnn/+eWrXrk1kZCStW7emRo0aHh+1iIiIlCdVYTyigoSIiEgx1113HfPnz+fee+9lx44dNG3alDVr1jB37lweeOABxo4dy4YNG6hZsyatW7fmkksuASAqKooTTzyRZ599luTkZEJCQmjdujXTpk3joosuAvynWk6aNImxY8dy1llnkZeXx1dffUXXrl09PGIREREpb6rCeMScc0HdYVno2LGjW7hwodcxRKQMTZu2rNxdwyf/s2LFCtq0aeN1jCrpQO+9mS1yznUMYqQqS+MRERHvaCzircMdj+gMCREp96ZNW0Zi4nQyM3MBSE5OJzFxOoCKEiIiIiIiFZRu+yki5VpKym4GD/6koBixV2ZmLklJX3iUSkREREREjpTOkBCRciU728e3365l1qw/mDVrNUuWbN7vsmvXpgcxmYiIiIiIlCYVJETEU/n5jp9+2lJQgJgzZy3Z2T7Cw0M49dQmjBp1Nk899QObN+/eZ92EhDgPEouIiIiISGlQQUJEgm79+oyCAsTnn68mJSUTgLZt63HDDSfRo0cLzjqrGdWrRwDQvHmtInNIAERHhzF69Dme5JeSOecwM69jVCmVYWJqERGR0qKxiDeOZDyigoSIlLmdO3P4+utkZs36g5kzV/Prr9sAaNCgGj17tqRHjxZ0796C+PjYEtfv1+94sn/4ifuf/oWNueE4oHXDCE1oWY6Eh4eTlZVFTEyM11GqlKysLMLDw72OISIi4rmIiAiNRTySlZVFZGTkYa2rgoSIlDqfL5+FCzcWnAUxb956fL58oqPDOPPMplx3XQd69GjJ8cfXP6gq9s63Z3L2ey/QNS4HgKmZTXnkz6N5fegbXPHI5WV9OHIQ6tevz4YNG4iPjyc6OlrfTpQx5xxZWVls2LCBBg0aeB1HRETEc3Xr1mX9+vXUrVuXGjVqEBYWpvFIGXLO4fP52LlzJ9u2bTvs8YgKEiJyxJxz/PFHWkEB4ssv/yQ9PQczOPHERtxxx6n06NGSLl2aEBV1cP/suFwfOUtWkJeaTuroqbisnIK+a6LX8mFOQ26bsJzzhuUQG3t4FVkpPbGx/rNbNm7cSG5u7gGWltIQHh5OgwYNCt57ERGRqiwuLo7IyEhSUlLYvn07Pp/P60iVXlhYGFFRUSQkJBAVFXV42yjlTH/JzJoALwMNAAdMdc49UWwZA54AzgUygQHOucXBzCkiB5aamsUXX6xm1iz/Y82aHQA0bRrHpZe2pUePlnTr1py6dQ/+tLmcFavJ+vJ7suYsJmvej7jMLMKaNMS3YWuR5cLNMbr6Cvqmd2LYsC958sk+pXpscnhiY2P1x7FUCBqPiIhUTlFRUTRp0sTrGHIIgn2GhA+43Tm32MxqAIvMbJZz7pdCy/QBjg48TgGeDvwUEQ/l5PiYN299wVkQCxduxDmIjY2kW7fm3HlnF3r0aEGrVrUP6vQ45xy5K9eQNXcpsQMuwkJCyHjuHTJe/pDwvzWlxmW9iT7jRKK7tGd99+vwrd9SZP0TwjO4qu52Jk36gSuvbMfJJ8eX1aGLSOWj8YiIiEg5ENSChHNuE7Ap8Hynma0A4oHCA4CLgJedf6rO+WZW08waBdYVkSBxzvHzzykFBYivv04mMzOX0FCjc+fGjBjRlR49WtCpUzxhYSEHtU3flu1kfvYdWXMWkfXdEvJS0gCIOvUEItu0oObg/tS68xrCGtYtsl7tpERSbnukyGUbFhXB6NF9+PzeX0lMnM6CBdcTHh5aem+AiFRaGo+IiIiUD57NIWFmzYAOwPfFuuKBdYVerw+0FRkAmFkikAiQkJBQVjFFKpVp05aRlPQFa9emk5AQx+jR5xS5U8WmTTv5/PPVBbfj3LRpFwCtW9fh2mvb06NHS7p2bXbQczb4Nmwhc85iok5qS8TRTcn5cSUptz9KaIM6RHftRPRpJxJ9egfCmx4FQHiThiVup0bfngCkjp4auHzDEdOjCw2vOpeJNZrzf//3XyZMmM+dd552BO+OiFRFGo+IiIh4x5OChJlVB94BBjvnMg5nG865qcBUgI4dO+pG7CIHMG3aMhITp5OZ6Z9wMDk5neuv/5Aff9yEzwCTdJsAACAASURBVOeYNWs1y5f752qoWzeG7t1b0KOH/9GkSdxB7cPl7GHXx9+Q/e0SsuYsJvfP9YD/DIeIwf2JPv1EmsybRnjLJoc863GNvj0LChN7/lhHeIvGAFx8cRsuuqg1998/m75929K8ea1D2q6IVF0aj4iIiHgr6AUJMwvH/+E/zTn3bgmLbAAKz0TSONAmIkcgKemLgmLEXllZPh59dB6RkaGccUZT+vdvR48eLTjhhIaEhBy4YJCXlkHW3KVYiFGtzxkApNz6MBYWRlSX9sReezHRZ5xIRJsWAITERBHR6si/QYxo6f8nwrcphdAGdZg4sQ9t207mxhs/5uOP/6lbPInIAWk8IiIi4r1g32XDgP8AK5xz4/ez2IfAzWb2Bv7Jo9J1vabIkVu7Nr3EdjNIS7uL6Ojwg9pO5pxFZH4xn6w5i9mz7HdwjqiTj6danzOwyAgaf/k84c2OwsLK9p+XnJ9XsaHPQOqNu4Mm/+jN6NHduPXWT3nzzZ+5/PLjynTfIlKxaTwiIiJSPhzcTHSl5zSgP9DNzJYGHuea2UAzGxhY5mNgNbAKeBa4McgZRSqlhISSL7tISIjbbzEiPyuHzDmL2DH5jYK2jP+8S/qz7xBSPYZaQ6/hqOlPcdR7/7tbXkSrhDIvRgBEtGlBxDEt2D7qGfJ3Z3HTTZ3o1Okobr31U9LSssp8/yJSoWk8IiIiUg6Yf/Loiq1jx45u4cKFXscQKdemTVvG1Ve9S17+/9qiI0J49vm/F5nYcs+qtez+4Csyv11MzoLluJw9EBpKs+XvEVq3Fr5NKYTE1SAkJsqDoygq6/uf2Hj+TdS68xpqD72WpUs307HjVK69tgNTp17gdTyRcsHMFjnnOnqdoyrQeERERKRk+xuPBPsMCRHxSOxvv5KXD7GWi+E4KiSL0dV/oc+WxaRNeo3cdZsByF6wnNSHnyN/x05ir72YhtPG0vz3GYTW9U8WGdaoXrkoRgBEn9KO6n/vxo5Jr+HbsIX27RsyZEhnnn12MXPmJHsdT0RERERE/oLOkBCpAvLy8jmu+r3s2gOf1ZpHpOXvs0z9ycOocWkv8ndl4vbkElr74O6s4bXcdZtZd3p/6o4ZTGy/89i9ew/HHjuZmJhwliy5gchIz+5uLFIu6AyJ4NF4REREpGQ6Q0KkCnv++SX8mh3NXdV+L7EY0XTZe9S4tBcAIdVjKkwxAiC8SUOaLvovsf3OA6BatQiefvo8VqzYxiOPfOdxOhERERER2R8VJEQqufT0bJKSvuTkarvpHbF1n/6wxg0Ia1jXg2SlZ+/lJDk/r8I5R58+R3PZZccyevQcfvttu8fpRERERESkJCpIiFRyY8bMYdu2TB4d3pmQqIgifRYdSe2kRI+Sla6s75awvus17Hr/CwAmTOhNdHQ4Awd+RGW4NE1EREREpLJRQUKkElu9Oo0JE77n6qvbc+qlJ+P25BISWw3MCGvcgHrjh1Kjb0+vY5aKqM7tiDjuaFJHPk1+Vg4NG1Zn7NjufPXVGl566Uev44mIiIiISDEqSIhUYkOHziI8PITRo7uR+tCzWHQkTeZOo+XWb2i65O1KU4wAsNBQ6j54C74NW0l/+k0ArrvuRE47rQm33z6TlJTdHicUEREREZHCVJAQqaS+/noN77yzgrvvPp06KRvZ9f6X1Bx4GWEN6ngdrcxEn9aBauedRdoTr+LbvI2QEGPq1AvYuTOH22+f6XU8EREREREpRAUJkUooLy+fIUM+o0mTWG6//VS2j5pCSO04at58hdfRylyd+wdhURHk/PQbAG3b1uOuu07jlVd+4vPPV3ucTkRERERE9lJBQqQSevnlH1myZDNjx3YnIisT34at1BrSn5Aa1byOVubCm8fTdOk7VOvZpaAtKelMjj66NgMHfkRWVq6H6UREREREZC8VJEQqmZ07c7j33i/p3Lkxl19+HKG142gy5yXi/nWJ19GCJiQ6EuccmV/9gHOOqKgwpkw5nz/+SOPBB7/xOp6IiIiIiKCChEilM3bsd2zevIsJE3qx59c/yd+ViYWFYeFhXkcLqt0ffc2mf9zO7o++BqBbt+ZcffUJPPLIXJYv3+pxOhERERERUUFCpBJJTt7BuHFz6dfveE4+sSFbrk5i89X3eh3LE9X6nE5EmxZsHzkZl7MHgHHjehIXF8kNN3xEfr7zOKGIiIiISNWmgoRIJXLXXZ8TEmI89NA5ZLw6ndw/1xN3wz+8juUJCwujzgM340vexI6pbwFQt24M48f3Yu7cdUydusjjhCIiIiIiVZsKEiKVxHffreXNN39m6NDTiK8VTtqjLxJ16gnE9DjV62ieienaiZhep5E2/mV8W1MB6N+/Hd26Nefuuz9n06adHicUEREREam6VJAQqQTy8x1DhnxGfHwN7ryzC+nPvEVeSip17huEmXkdz1N1Rt5IaN1a+NZtAsDMmDLlPLKzfdx666cepxMRERERqbpUkBCpBKZN+4kFCzby0EPnUK1aBDnLfqPaeWcS1fFYr6N5LqJlAgnzpxF10v/ei6OPrsOwYWfy1lu/MGPGbx6mExERERGpulSQEKngdu/ew913f0GnTkfRr187ABq+OJr6k4d7nKz8sNBQ8rNz2Pn2TJzzT2Y5dOhptG1bjxtv/Jhdu/Z4nFBEREREpOpRQUKkgnv00bls3LiTCRN6k791O7nrtwAQEhPlcbLyZddbM9k6aBSZM+cCEBERyjPPnM/atencf/9XHqcTEREREal6VJAQqcDWrUvnkUe+47LLjqVLlyZsHzWF9V0HkL87y+to5U6Ny/sQfnRTtt83CbcnF4DTT08gMfFEJkz4nsWLN3mcUERERESkalFBQqQCu+eeL8jPd4wd252cn1ex662ZxF51ESHVor2OVu5YuP82oLmr15P+/LsF7Q8/3J169WJITJyOz5fvYUIRERERkapFBQmRCur779czbdoy7rijC02b1iT1wWcIia1GzX/38zpauVWte2eizz6ZtHEvkrd9BwC1akXzxBO9WbRoE5Mm/eBxQhERERGRqkMFCZEKyDnH4MGf0bBhde6++3SyvltC5ufzqXnrlYTWrOF1vHKt7qibiWjdnLwdGQVt//jHsfTp04phw75k7dp0D9OJiIiIiFQdKkiIVEBvvLGc+fPXM2ZMN6pXjyB7yQrCmjQk7rq+Xkcr9yJaNyd+xmQiWiYUtJkZkyefh3Nw880fF9yJQ0REREREyo4KEiIVTFZWLnfd9TkdOjTk6qvbA1Dr5n/S5NtXCImO9DhdxeFLSWPH1LcLXjdrVpORI7syffpvvPvuCg+TiYiIiIhUDSpIiFQwjz02j3XrMpgwoTeWn0fOjysB3ebzUO16Zxbbk55g9+fzC9oGD+5M+/YNueWWT0hPz/YwnYiIiIhI5aeChEgFsnHjTh566FsuuaQNZ57ZlJ2vf8L67teRvehnr6NVOHHXXkx488Zsv38SLtcHQFhYCFOnns+WLbtJSvrS44QiIiIiIpWbChIiFUhS0pf4fPk88kgP8jOzSX30BSI7HUfkiW29jlbhWEQ4dR64idzfksl46YOC9k6d4rn55k5MnryA+fPXe5hQRERERKRyU0FCpIJYtGgjL764lCFDOtOiRS3Sn3uHvE0p1Bl2A2bmdbwKKabXaUSfcSKpjzxP3o6dBe0PPtiN+PhYEhOnk5ub52FCEREREZHKSwUJkQpg720+69evxr33nkFeWgY7nnyVmB6nEt2lvdfxKiwzo86oW4g5qyMuZ09Be40akUya1Idly7Yyfvw8DxOKiIiIiFReKkiIVABvv/0L3367lgcfPJvY2Ehylv0GQO1hN3icrOKLPLYVDZ4dSViDOkXaL7roGC6++BhGjvya1avTPEonIiIiIlJ5qSAhUs5lZ/sYOvRz2rVrwLXXdgAg5syONP3xXSLbtvQ4XeWx59c/SR33QpG2iRP7EBYWwqBBM3DOeZRMRERERKRyUkFCpJybMGE+a9bs4PHHexEaGkL20l9xzhFSLdrraJXK7plzSRv7PJlfLyxoi4+PZcyYc5g58w9ef325h+lERERERCofFSREyrHNm3cxevQcLrqoNd26NWfPyj/Z0OsG0p9+0+tolU5cYl/CmjZi+/CJOJ+voH3QoI6ccko8gwd/SmpqlocJRUREREQqFxUkRMqx4cO/JCfHx6OP9gAgdcyzhFSLpsZlvT1OVvmEREVS575B7FmxmoxpMwraQ0NDmDr1AlJTsxg6dJaHCUVEREREKhcVJETKqaVLN/Of/yzhlltO5uij65D9wzJ2fzyHmjf/k9A6Nb2OVylVu6ArUZ1PIPXh58jL2FXQ3q5dA26//VT+858lfPNNsocJRUREREQqDxUkRMoh5xxDhnxG7drRDB9+Fs45to96htD6tYm74VKv41VaZkbdB28h9p/nYSFF/3m8//6uNG9ek8TE6eTk+PazBREREREROVgqSIiUQx98sJLZs9cwatTZ1KwZRd6W7fg2bqXWnddoMssyFnlCa+oMH0hI9Zgi7TEx4Tz99HmsXLmdhx/+1qN0IiIiIiKVhwoSIuVMTo6PO+6YybHH1uP6608CIKxhXRLmvkpsv/M9Tld1ZH71A9tGPFWkrVevVlxxxXGMGfMtv/66zaNkIiIiIiKVgwoSIuXMxIk/8McfaYwf34uwsBD2/Pon+dk5WGQEFh7mdbwqI2fxCtKfeoOs75YUaX/88V7ExIQzcOBHOOc8SiciIiIiUvGpICFSjqSk7GbUqG8477yj6dmzJfnZOWy64k62XD/C62hVTtyNlxMWX59twyfi8vIK2hs0qM6jj/bg66+TeeGFpR4mFBERERGp2FSQEClH7rvvKzIzcxk3ricAGS+8h2/9FuKuv8TjZFVPSHQkte8bxJ5lv7PzjU+L9F17bQfOOCOBO+6Yydatuz1KKCIiIiJSsakgIVJOLFu2halTF3PjjR055pi65GXsIu3xV4ju2omYMzt6Ha9Kqn7xOUR2PJbUMVPJ35VZ0B4SYjzzzPns2rWH2277zMOEIiIiIiIVlwoSIuWAc47bbptJXFwk99/fFYAdE18jPy2DOsNu8DZcFWZm1B1zK7Xv/hcWHVmkr02betx99+lMm7aMWbP+8CihiIiIiEjFFdSChJk9b2ZbzWz5fvq7mlm6mS0NPO4LZj4Rr8yY8Tuff76akSO7Urt2NM45cpas8H9Df0Jrr+NVaVEd2hDb/0IsNHSfvnvvPYO//a0OAwfOIDMz14N0InI4NB4REREpH4J9hsSLQO8DLDPHOdc+8HggCJlEPLVnTx633z6TY46py8CB/kszzIxGb42n3uN3eZxO9sp49SNS7nq8SFtUVBhTppzH6tVpjBr1tUfJROQwvIjGIyIiIp4LakHCOfcNkBrMfYqUd5MnL+C337bz2GM9CQ8PxbdxK76tqZgZIdWivY4nAb4NW8h4/l2yf1hWpP3ss5szYEB7xo2bx7JlWzxKJyKHQuMRERGR8qE8ziFxqpn9aGafmNmx+1vIzBLNbKGZLUxJSQlmPpFSs317JiNHfk2vXi3p06cVANuGT2L92dfgcvZ4nE4Kq3nzPwltWJdtwybi8vOL9I0b14OaNaNITPyI/HznUUIRKWUaj4iIiJSx8laQWAw0dc6dAEwE3t/fgs65qc65js65jvXq1QtaQJHSNGLEbHbuzOGxx3piZmQvWcHuD78i9qoLscgIr+NJISHVoqkz7AZylqxg1zuzivTVqRPD+PE9mT9/PVOmLPQooYiUIo1HREREgqBcFSSccxnOuV2B5x8D4WZW1+NYImXil19SePrphdxww0kce2x9nHOkjppCSN2a1Lzxcq/jSQmqX9qTyPbHsH3UM+Rn5xTpu/LKdpxzTnPuuecLNm7c6VFCESkNGo+IiIgER7kqSJhZQzOzwPOT8efb7m0qkbJxxx0zqV49gpEjzwYga/YCsuYsptaQqwmpUc3jdFISCwmh7iO3Uf/JewiJKnobUDNjypTz2bMnj3//+xOPEopIadB4REREJDjCgrkzM3sd6ArUNbP1wP1AOIBzbgrQFxhkZj4gC7jcOacLsqXS+eST3/nkk1WMH9+TunVjAMhesJywZkcRd/WFHqeTvxLVoU3Bc+ccgb9ZAGjVqjbDh59JUtKXTJ++kgsu0C1bRcojjUdERETKB6sMn68dO3Z0Cxfqum2pGHJz8zjhhCn4fPksX34jERGhBX35uzIJqR7jYTo5WKkPP4dv8zbqT7i7SPuePXmceOIzZGTk8MsvN1G9uuYCEW+Z2SLnXEevc1QFGo+IiIiUbH/jkXJ1yYZIVTB16iJWrNjGuHE9iYgIxe3JJWfFagAVIyoQ58tj57QZZC/+pUh7REQoU6dewLp1GQwf/qVH6UREREREyj8VJESCKC0ti/vum8055zTnggv+BkDGyx+y/qwB5Py8yuN0cihqDe5PaL3abB82keJnmnXp0oSBA0/iySd/YNGijR4lFBEREREp31SQEAmiBx74mh07shk/vhdmRv6uTFIfe5GoU08gom1Lr+PJIQipHkPte68ne8Fydr+/75kQDz3Unfr1q3HJJW/StOkEQkJG0qzZBKZNW+ZBWhERERGR8kcFCZEgWblyG5MmLeC66zrQrl0DAHY8/Sb523ZQ576BRSZHlIqhxhV9iDjuaLaPeRaXl1ekr2bNKC69tC3JyRmsXZuOc5CcnE5i4nQVJUREREREUEFCJGjuvHMW0dFhjBrVDQBfSho7nnqdauedRdRJx3qcTg6HhYZSf8JdNJr2MBYauk//Bx+s3KctMzOXpKQvghFPRERERKRcC+ptP0Wqqlmz/mD69N8YO9Z/Gj9AzuJfwIzawxI9TidHIvKE/93a0/l8WNj//lldty69xHXWri25XURERESkKtEZEiJlzOfL57bbZtKiRS1uvfWUgvZqvU6j2bL3iGiV4GE6KQ3OObYMfICU28cVaU9IiCtx+f21i4iIiIhUJSpIiJSx//xnMcuXb+XRR3sQGen/9jxn2e8453Sbz0rCzAhtWIedr39Mzo//u0xj9OhziIkJL7JsdHQYo0efE+yIIiIiIiLljgoSImUoPT2bYcO+4qyzmnLxxccA/mLE+m7XkvHSBx6nk9JU67arCakdy7bh/7sNaL9+xzN16gU0bRrH3jlLe/duSb9+x3uYVERERESkfFBBQqQMPfjgN2zfnsnjj/cquIvG9gefIaRmDapfrG/JK5PQ2OrUvvs6suf9yO4Z3xS09+t3PGvWDCY//36uuOI4Pv54FatWpXqYVERERESkfFBBQqSMrFqVyhNPfM8117SnQ4dGAGR9u5isL7+n1uD+hMbV8DihlLbYK88n/JjmpD3+csFZEoU99lhPIiJCueWWT0rsFxERERGpSlSQECkjQ4fOIjIyjAcf9N/m0znH9lFTCIuvT+y//s/jdFIWLCyMBlNHcNR/Hys4I6awRo1q8MADZ/Ppp6t4771fPUgoIiIiIlJ+qCAhUga++upP3nvvV+6553QaNfKfCeFbvwXfhq3UGnotIVGRHieUshLZpgWhdWri8vPJz8zep//mm0+mXbsGDB78Kbt37/EgoYiIiIhI+aCChEgpy8vz3+azadM4hgzpXNAe3qQhCd+/To3LenuYToLB+XxsPP8mtg+fuE9fWFgIkyefy7p1GYwa9U0Ja4uIiIiIVA0qSIiUshdfXMrSpZt55JEeREf7b/m4Z+WfuFwfIdWisdBQjxNKWbOwMCI7tCHj1Y/I+XnVPv2nnZbAgAHteeyxeaxYkeJBQhERERER76kgIVKKMjJySEr6ktNOa8Kll7YFID8zm42XDGHrzaM9TifBVOuOAYTEVmP7fZNKnMBy7NjuVK8ewU03fawJLkVERESkSlJBQqQUPfTQHLZs2V3kNp/pU98ib8t2Yq+52ON0EkyhtWKpPfRasr5ZxJo2F/JH/TNJ7tCXnW/PBKB+/WqMGdONr75awxtvLPc4rYiIiIhI8KkgIVJK/vwzjccfn89VV51Ap07xAOSlprPjyWnE9DqN6M7tPE4owWax1cGM/O07wDl867eQctsjBUWJxMST6NjxKG6/fSYZGTkepxURERERCS4VJERKyV13fU5oaAhjxnQraEt74lXyd2VSOynRw2TilbSHn4Nil2O4rBxSR08FIDTUP8Hl5s27uP/+r7yIKCIiIiLiGRUkRErBnDnJvPXWL9x112nEx8cC4PLyyP5hGTUu601kmxYeJxQv+DZsPWB7p07xJCaexMSJP/DTT1uCFU1ERERExHMqSIgcofx8x5Ahn9G4cSx33NGloN1CQ4mfMZm6Dw32MJ14KSy+/kG1jxlzDrVqRXPjjTPIz9cElyIiIiJSNaggIXKEXnnlRxYt2sTYsd2JifHf5tO3YQt5aRlYSAgh1WM8TiheqZ2UiEVHFmmz6Mh9LuGpXTuasWO7891363j55R+DGVFERERExDMqSIgchmnTltGs2QRCQkZy7bUf0rJlTa644riC/pS7J7D+nH/hfD4PU4rXavTtSb3xQwlr3AD8N12h+sXdqdG35z7LDhjQnlNPbczQobNIS8sKclIRERERkeBTQULkEE2btozExOkkJ6fjnP+SjQ0bdvLaa/5bN2bN/4nMT78l9qoLsbAwj9OK12r07UnTJW/TYss3RJ7Yhqw5i3C5+xaqQkKMyZPPY/v2LJKSvvQgqYiIiIhIcKkgIXKIkpK+IDMzt0hbdnYeSUlf4JwjddQUQhvUIS7xUo8SSnlkZtS64xp86zaz+9NvS1ymffuG3HxzJ6ZMWcjChRuDnFBEREREJLhUkBA5RGvXpu+3PXPmXLJ/WEbtodcSEhMV5GRS3sV078xRH0yk2vln7XeZBx44mwYNqnPjjTPIy8sPYjoRERERkeBSQULkEDVpEldie0JCHFlzlxLeKoEa/zw3yKmkIjAzoru0x8xw+SUXG+Liohg3rgcLFmzkuecWBzmhiIiIiEjwqCAhcojOOqvpPm0xMeGMHn0OdUfeRPxnz2juCPlL6c+/x/pzrtvvpKf//OfxdO3ajHvu+YKUlN1BTiciIiIiEhwqSIgcglmz/mDatGWcdFIjEhLiMIOmTeN45qneXNq5JgChsdU9TinlXVjDOuxZ/ju73vuixH4z46mnzmXnzj3cfffnQU4nIiIiIhIcKkiIHKRVq1K57LK3OfbYesyePYDk5MHk59/PmjWDOX/3Stad1p89f6zzOqZUADG9Tyfi2JakjX8Zl5dX4jJt29ZjyJDOPP/8UubO1X9XIiIiIlL5qCAhchAyMnK48MLXCQkxPvjgcqpXjyjoy0vfSdqEV4g+qyMRLZt4mFIqCgsJodbtA8hdtZZdH3y13+Xuu+8sGjeO5cYbZ+DzaYJLEREREalcDqkgYWYXmdk1hV43NbN5ZrbTzN42M52rLpVOXl4+//znO/z+eypvv/0PmjevVaR/x8TXyE/fRZ3hAz1KKBVRtfPOJPyY5qSNfwnnXInLVK8eweOP9+LHH7cwefKCICcUKb80HhEREakcDvUMiWFAvUKvxwONganAmcCI0oklUn4MG/YlM2b8zpNP9qZr12YA7Hx7Jskd+vJH/TPZ8eSrRHY6lsjjWnkbVCoUCwmh3rg7aPDM/ZjZfpe75JI29OzZkuHDv2LTpp1BTChSrmk8IiIi/8/encfZWP5/HH9d55yZObNvZmE2WyEhIkvaJKQQKUoLqWmTSGnRpvjqR0WlxRJJimwhJaW0KEIqpMUyxoyYGbPvc865fn/MGMYsZjRzzpkzn+fj4TFn7vu67/Oeoc51PudahAuoaUGiBfA7gFLKE+gPPKK1ngA8BQyu3XhCONaHH+7mpZe2cN99F3P//V2A4mJE8iPTsSQcB61BQ+Hvf5O1YqOD04r6xrNrezzaVl3IUkoxe/a15OdbeOyxL+2UTAinJ/0RIYQQwgXUtCBhBvJKHvcATMDJd2F/AU1qKZcQDrd9eyKjR6/liitieO21a0uPp06di84rKNNW5xeSOnWuvSMKF2DNyOL4fS+Qvf67Stucd14wEyf2YMmS3WzeHGe/cEI4L+mPCCGEEC6gpgWJOKBnyeNBwE6tdUbJ96FARkUXCVHf/PtvFjfcsIzwcB+WL78Jd3dj6TlLYlKF11R2XIiqGHy8KPj1T9JmLETbKl+48sknL6Np0wAefPAziooq3plDiAYkDumPCCGEEPVeTQsSc4DnlVI7gAeAd0871x34o7aCCeEo+fkWBg9eRkZGPmvWDCckxLvMeVNEaIXXVXZciKooo5HAR+6gcO9+cr/YUmk7Ly83Xn+9H3/8kcysWVvtmFAIpyT9ESGEEMIF1KggobV+DRgJ/ATcpbWed9ppX2Bh7UUTwv601tx336ds25bI4sWDad8+rFwbv9ibyh1Tnh4ETYq1R0ThgnyG9MatWSSpMxZWuuMGwIABrRgw4HwmT/6WhIRMOyYUwrlIf0QIIYRwDTUdIYHWeonW+iGt9ftnHL9Xa7249qIJYX8zZ25l0aLfmDz5SgYPblPuvLbZyN3wA3i4Y2zcCJTCFBlGyKsT8R3axwGJhStQJhMB42+ncPc/5H75Y5VtX3utH1arZvz4L+yUTtjDkiW7adp0FgbDZJo2ncWSJbsdHcnpSX9ECCGEqP9MNWmslDofCNBa/1zyvSfwLHAh8IXWenbtRxTCPjZs2M9jj33J0KEX8PTTl1fYJnPhJ+T/+CshMx/H77br7ZxQuDLfoX2wHDmGR/tWVbZr1iyQSZMu45lnvmHjxgP06dPCTglFXVmyZDexsevIzS0C4PDhDGJj1wEwYkQ7R0ZzWtIfEUIIIVxDTUdIzAaGnvb9VGACxatZz1RKPVhbwYSwp7/+SmH48BW0axfKe+8NwmBQFbYzBPjiM/hqfEdcZ+eEwtUpNxNBE+/CFN7orG0fe6wH550XnScpIgAAIABJREFUxJgxn1FQYLFDOlGXJk3aVFqMOCk3t4hJkzY5KFG9IP0RIYQQwgXUtCDRAdgCoJQyAHcAj2utLwamADKJXtQ76en5DBy4FHd3I2vWDMfb273Str43XkPY3OdRquKChRD/Vd7W30l+fGaVa0l4eJiYPbs///yTyowZVU/xEM4vPr7iDSEqOy4A6Y8IIYQQLqGmBQl/4ETJ445AILCi5PvNQPPaiSWEfVitNm65ZSWHDqWxatUwYmICKmyXuXgtGQtWV/kmUYjaUPR3HJkLVpG3eXuV7fr0acHQoRcwder3HDqUZqd0orb9/vvxSkdkRUf72zlNvSL9ESGEEMIF1LQgcRxoWfK4D3BAa32k5HsfQMYOi3rliSe+YsOG/bz5Zn969oyusE3RoURSnn6DnCq2ZBSitvgOvxZTRChpZ9lxA2DmzL4YjYqHH95gp3SiNm3adJDLLluIr687ZnPZJZ28vNyYOvVqByWrF6Q/IoQQQriAmhYk1gLTlFIvUzxXc/lp59oBB6u6WCm1QCmVpJTaU8l5pZR6XSm1Xyn1u1KqUw3zCVFt77//Gy+//BNjxnThnnsurrCNttlIengaymgkdOZEmaoh6pxydyPg4dvI376HvO92Vtk2MtKP5567gnXr/mbdur/slFDUhsWLf6NfvyVER/uze/cDzJ8/kJgYf5SCmBh/5s4dIAtaVk36I0IIIYQLqGlB4gngU6AvxZ2B/512biCw8SzXvwf0q+L8tcB5JX9igbdrmE+Iatm6NYF77llHr17NePXVvpW2y3x3Ffk//Ubwiw9hahJqx4SiIfO79TqMjUOqNUpi3LhuXHBBCGPHbii3MKJwPlprpk37njvu+ITLLovm++9HERnpx4gR7YiLG4fN9hxxceOkGHF20h8RQgghXECNtv3UWucA91Ryrkc1rv9OKdW0iiaDgPd1cQ98q1IqQCnVWGv9b01yClGVxMRMBg9eRmSkHx9/PBQ3N2OF7aypGZyYMhfPXl3xvbW/nVOKhkx5uBP01D3Y0jLAZgNjxf9GAdzcjLz5Zn+uumoR06Z9z4sv9rJjUlETFouNMWM+Y86cnYwY0Y4FCwbh7l75362onPRHhBBCCNdQ0xESACilgpRS1ymlbi/5GlRLeSKAI6d9n1ByrKIMsUqpHUqpHcnJybX09MX7wTdtOguDYTJNm85iyZLdtXZv4Xh5eUXccMMysrMLWbt2OMHBXpW2NQb5E/7+/wh99TGZqiHszm/4tQTcPxxVRTHipCuvbMqIEe2YPv1H/vnnxFnbC/vLySlk8OBlzJmzkyeeuJT33x8sxYhaIP0RIYQQon6rcUFCKTUFSATWAYtKviYqpV6s5WxV0lrP1Vp31lp3DgkJqZV7Llmym9jYdRw+nIHWcPhwBrGx66QT4CK01txzzzp27jzKhx8OoW3byqdgWNMyAfC6ojOmiDB7RRSiDG2xkLn0c/J37j1r25df7oPZbGLMmM9lNxgnk5SUw1VXLeKzz/7hrbf6M21a70p31hDVJ/0RIYQQov6rUUFCKTUOeAr4ALgKaFPy9QPgKaXU2P+YJxGIOu37yJJjdjFp0qZyc7Bzc4uYNGmTvSKIOjRjxo8sWbKbKVN6MWBAq0rbFR1KJP7im8n6WHYuEI6lCy2kvvAOqf+bd9a24eE+vPjiVWzceICVK/fZIZ2ojr//PkH37u+yZ08Sq1cP4/77uzg6kkuQ/ogQQgjhGmo6QuI+4DWt9T1a62+11n+VfL0HeB144D/mWQvcUbK6dTcgw57zNePjM2p0XNQf69f/zRNPfMWwYW158smelbY7uasGSuHZUxZVF45l8DITMOYW8r7bSd6238/a/oEHunDRReGMG7eB7OxCOyQUVfnppyP06PEumZkFfPPNnQwcWHkhVNSY9EeEEEIIF1DTgkRTYH0l59aXnK+UUuoj4CeglVIqQSk1Wil1n1LqvpImn1G8Vdd+YB7/vUNRI9HR/hUej4qq+LioH/btS+aWW1bSsWNjFiwYVOV6EKd21Rgju2oIp+B35yAMjQJIe/m9s7Y1mQy89VZ/EhOzeOGFb+s+nKjUJ5/8Sa9e7xMY6MlPP42ma9dIR0dyNU1pgP0RDw8TX3yxX6ZlCSGEcBk1LUicAC6s5FzbkvOV0lrforVurLV201pHaq3f1Vq/o7V+p+S81lo/qLVuobVup7XeUcN8/8nUqVfj5eVW7nhUlB95ebKdXn2UlpbHwIFL8fJy45NPhlX493tS0aFETkyZg1fvbvjeIrtqCOdg8PYk4IHh5G3eTv6Os68l0b17FHfddREzZ25l794kOyQUZ5o9+2eGDFlGhw5h/PjjXbRsWVvrLIrTNLj+iJubAQ8PI/36LaFDh3d4771fKSiw2DOWEEIIUetqWpBYDbxYspq1CUApZVJK3QK8AKys7YD2NGJEO+bOHUBMjD9KFX9CMXRoG7ZsOcLll79HYmKmoyOKGrBYbAwbtoL4+AxWrx521pEu+b/8gfIyE/LqRNlVQzgV/1GDMfe4CF1QvWkY//d/1+Dn58GDD34mn6Takc2mmTjxSx566HMGDGjF11/fSUiIt6NjuaoG1R+JifFn4cIbSEp6jPfeGwTAqFFraNbsNaZN+560tDwHJxZCCCHOjapJZ1Up5UvxMMZLASuQCgQBRuAHoL/WOrsOclapc+fOeseOuvvwYs2aP7ntttX4+LizevUwunWTobf1wfjxG5g1axsLFgxk1KiO1brGlp2LwafyrUCFqC/mzt3Jvfd+ygcfDGbEiPaOjuPyCgosjBy5hqVL9/DAA515/fVrMRrPaWftWqeU2qm17uzoHLWpofZHTtJa8+WXB3nllZ/YuPEA3t5u3HVXR8aN60bz5oF1/vxCCCFETVXWH6lRQaLkRgq4DrgcCKS4E/At8Ll20Edx9ugA7N2bxMCBS0lIyGTOnOsZOfKiOn0+8d8sWLCL0aPXMm5cV2bO7Fdl26JDiRT+dQjvfpUvdimEM7Bl5ZDz1U/4Du599rY2Tffu73L4cDp//jmGgACzHRI2TGlpeQwevIxvvz3M//1fbx57rIdTjbJyxYIENNz+yJl+//04r776Ex9+uBurVTNkSBsmTOguH54IIYRwKrVWkHBG9uoAnDiRy7BhK9i06RDjxnVlxow+mEzO8QmYOGXLlniuumoRV17ZlM8+G1Hl35G22Th6w1gK9x4geufHGAN87ZhUiJpJe+0DUqfMIXLTu3i0P/+s7XfuPEqXLvMYM+YSXn/9WjskbHji4zO49tol/PPPCd577wZuvbWdoyOV46oFCWfkiILESUePZvHGG9t4552dpKfnc+mlUUyY0J2BA1s5zWgdIYQQDVdl/ZGzvkIppWxKKWs1/7j06krBwV5s2HAbDz/clVmzttG//xJSU2XepjOJj89gyJCPiYkJYNmyoWctGGXML9lVY8pDUowQTs9v1A0Y/H1Ie+W9arW/+OIm3H9/Z958czu7dtltx8IG49dfj9Gt23wSEzP54ovbnLIY4UqkP1K1Jk18mTatN0eOjOf11/tx9GgWQ4Z8TOvWb/LWW9vJzZXFuYUQQjifs46QUEo9D1R7GIXWevJ/zFRjjvhEYuHCXdx333qiovxYs2Y4bdvKFpGOlptbRM+eCzhwII2tW0fTpk1Ile2LDiZw5MqReF7akfAPpzvVEGshKpM6YyFp0xcQ+c1CPC5sedb2aWl5tGo1mxYtgtiy5S4MBvl3Xhu+/PIAN974Mf7+Zj7/fAQXXui8rwGuMkJC+iM1Y7XaWL36T15++Ue2bUskKMiT++/vzJgxlxAe7uPoeEIIIRoYmbJRB3766QiDBy8jJ6eIJUuGMHBgK7tnEMW01txyy0o+/ngvn356K/37n1d1e5uNo4PGUvjHAaJ+eB9T46qLF0I4C2t6FvGdbsLzis6EL5xSrWsWLfqVkSPXMH/+AEaP7lTHCV3fokW/cvfd67jgghA+++xWIiL8HB2pSq5SkKgPnKkgcZLWmh9/PMIrr/zEJ5/8iZubkdtua8cjj3SXD1OEEELYzTlP2RCV6949ih07YmnVKpgbbljK1KnfyRZ7DjJt2g8sW7aXl17qfdZiBABK4Xfb9TSaMUGKEaJeMQb44h87FFtOHrqoeqPS77ijAz17RvP4419x4kRuHSd0XVprpkz5jpEj13DFFTF8991Ipy9GCKGU4tJLo1m1ahh//TWGu+/uyEcf7eHCC9+mf/8lbNp0UPouQgghHEZGSNSCvLwi7r57HR9+uJubb27LggUD8fZ2d1iehmbNmj+54YZljBjRjsWLB5916oXWWqZniHpNW60oo7FG1+zefZyOHecwenRH5swZUEfJXJfFYuP++z9l/vxd3H57e+bPH4i7e83+DhxFRkjYj6P7I9V14kQub7+9g9mzf+b48RwuuiicCRO6M2xYW9zc6se/ayGEEPWLjJCoQ56ebnzwwWD+7/96s3z5Xnr2XEh8fIajYzUIe/Ykcdttq+nSpQnz5g04ezHCZuPYLRPJ/HC9nRIKUftOFiOKEo5TdORYta5p1y6MsWO7Mm/eL/z8c2JdxnM52dmFDBq0lPnzdzFp0mUsWnRDvSlGCFGR4GAvnn76cuLixjF//gAKCizcfvtqmjd/nRkztpCRke/oiEIIIRoIKUjUEqUUEydeyqef3srBg2l07jyX778/7OhYLu3EiVwGDvwIX193Vq8ehqen21mvyZi3ktxNW0FGSIh6zpZfQMJVo0idOrfa1zz//JWEh/tw//3rsVptdZjOdRw/ns2VV77Hhg37mTPneqZM6SUjrITLMJtNjB7diT17HmD9+ls5//xgJk78isjImTzyyBccPpzu6IhCCCFcnBQkaln//uexbdvdBAZ60qvX+8ydu9PRkVxSUZGVm25aztGjWaxePaxa87iLDiaQOnUOXtd0x3f4tXZIKUTdMZg98Lt9ANmrN1G4P75a1/j5efDqq3355Zd/mTNH/t90Nn/9lUL37u+yb18Ka9YMJzb2YkdHEqJOGAyK/v3PY9OmO/jll1gGDWrFG2/8TIsWrzN8+Ap27Djq6IhCCCFclBQk6kDr1o3Ytu1uevduzr33fsqDD66nqMjq6Fgu5ZFHvuCbb+KYN28AXbtGnrW9ttlIevgllJsbIa88Jp9wCpfgf/9wlNmdtJnvV/uaYcPa0qtXMyZN+pqkpJw6TFe/bdkST48eC8jOLmTz5ju5/vrzHR1JCLvo2LExH3wwhIMHxzJ+fDc+/3w/XbrM44or3mPdur+w2er/2mNCCCGchxQk6khAgJlPP72Fxx7rwVtv7eCaaxaTnCyd/9owd+5OZs/ezqOPduf22ztU65q8LbvI3/obwVPHyq4awmWYQgLxG3kD2Su+pOhgQrWuUUrx5pv9yckpZOLEL+s4Yf20cuUfXH31+wQHe/LTT6Pp0iXC0ZGEsLuoKH9mzOjDkSPjefXVPsTFpTNw4FIuuOBN5szZQV5ekaMjCiGEcAFSkKhDRqOB6dOvYfHiwWzdmkCXLvP47bfqLUAnKvbdd4d58MHP6NevJS+91Lva13lddjGRX83Hd1i/OkwnhP0FPDAc5WUm76ffqn1N69aNmDChO4sW/cYPP1RvukdD8dprW7nppuV06tSYH38cTYsWQY6OJIRD+fl5MH58dw4cGMtHH92Ij4879923nujoWTz//GYZaSWEEOI/kYKEHdx2W3u+/34URUU2evRYwMqVfzg6Ur10+HA6N974MS1aBPLRRzdiNJ79n6+22Sj44wAAHh1ayVQN4XJMYcHE/LYSvxHX1ei6p5++nOhofx54YD0WiyxwabNpJkz4gnHjvuCGG1qzadMdNGrk5ehYQjgNk8nA8OEXsn37PWzefCfdu0cyefK3REfP5N571/HXXykALFmym6ZNZ2EwTKZp01ksWbLbwcmFEEI4MylI2EmXLhHs2HEP7duHMXTocp577huZh1kD2dmFDBy4lKIiK2vX3kJAgLla12XMW0nCVXdR8PvfdZxQCMcx+vkAVHsLUABvb3dmzerL7t1JvPHGtrqKVi/k51sYPnwFr766lYceuoTly2+q1q49QjRESimuuKIpa9fewr59D3LnnR1YtOg3Wrd+k06d5jB69BoOH85Aazh8OIPY2HVSlBBCCFEpKUjYUePGvnzzzZ2MHHkRL7zwHUOHfkxWVoGjYzk9m00zcuQn7NmTxLJlQzn//OBqXVd44EjxrhpXd8W93Xl1nFIIx8pYuJr4S4ZTdLj6q+HfcENrrr22Jc89t5mjR7PqMJ3zSk3N45prFrN8+R+8/PI1vPZav2qNvhJCFE//mjNnAPHx43nuuSv47bfjFBSUXcQ7N7eISZM2OSihEEIIZye9Ljszm00sWDCQmTP7smbNX/TosYCDB9McHcupTZnyHStX7uPll6+hb9+W1bpG22wky64aogHx7nspGAykvfZBta9RSvHGG9dSWGhlwoSNdZjOOcXFpXPppQv4+edEPvroRiZM6CH/rxDiHISGevP881eidcUjPw8fziAxMdPOqYQQQtQHUpBwAKUU48Z1Y8OGESQmZtKlyzy+/vqQo2M5pVWr9vHcc5u5884OjBvXrdrXZcxdQf6232VXDdFgmJqE4jfierKWfl6jqRstWgTxxBM9Wbp0D5s2HazDhM7ll1/+pXv3dzl2LJuNG29j+PALHR1JiHovOtq/0nORkTPp3v1dZszYwv79qXZMJYQQwplJQcKBrrmmBT//fA9hYd706bOY2bN/rvTThYbot9+Ocfvtq+nWLZJ33rm+Zp9c2mx4X3eF7KohGpSAsSMASH+9+qMkAB5//FKaNw9kzJjPKSy0nv2Cem7Dhv1cfvlC3N2NbNlyF1dc0dTRkYRwCVOnXo2XV9n1V7y83Jg+/Rr+979eFBVZmTjxK8477w06dHiHyZM3s3v3cen7CCFEA6Zc4UWgc+fOeseOHY6Occ4yMwu47bZVrFv3N6NHd+TNN/vj4WFydCyHSk7OoUuXeVgsNrZvv4fGjX1rfA+ttQy/Fg1O8qMvk73+W2J2LsfgVb3FXwE+++wfrrvuQ6ZNu5onnuhZhwkda8GCXcTGruPCC0P57LMRNGlS8/+31DdKqZ1a686OztEQ1Pf+SG1YsmQ3kyZtIj4+g+hof6ZOvZoRI9qVnj98OJ3Vq/9k1ap9/PBDPFpDy5ZBDBnSmiFD2tClSwQGg7x2CyGEq6msPyIFCSdhs2meffYbpk79nh49oli16mbCwnwcHcshCgutXHPNYn7+OZHvvx9F585Nqn1t5gefYgz2x/vay+owoRDOy5qSBm4mjP41f6M9ePAyNm48wL59D1Y59Lo+0lozefK3TJ78Lddc05wVK27Gz8/D0bHsQgoS9uMK/RF7On48mzVr/mLVqn1s2nQIi8VGRIQvgwe35sYbL6Bnz2hMJhnMK4QQrqCy/oj8X95JGAyKKVN6sWzZUHbt+pfOneexc2f1V8t3JWPHfs533x1mwYKBNSpGFB44QspTs8hcvE6Gf4oGy9goEKO/L9pmw5abX6NrZ83qi9aaceM21FE6xygqsjJ69FomT/6WkSMvYv36WxtMMUIIZxYW5kNs7MVs2HAbSUmP8v77N9ClSwTz5+/iqqsW0bjxK9x991o+++wfCgosjo4rhBCiDkhBwsncfHNbtmy5C6WgZ8+FfPRRw9q7++23tzNnzk6efLInt9zS7uwXlNBWK8ljp6Hc3Qh5daJM1RANmi6ykNgnltSpc2t0XUxMAM88czmrV//J55//U0fp7Csrq4ABAz5i4cJfefbZy1mwYCBubkZHxxJCnCEw0JPbb+/A6tXDSEl5jBUrbqJPnxYsX/4H1133ISEhM7j11pWsWPEH2dmFjo4rhBCilsiUDSeVlJTDjTd+zA8/xPPEE5cyZUovjEbXrh99880h+vT5gH79WrJmzfAazSFNf+djTjzzBqGzJ8lClkIASWOnkb36K6K3L8MU3qja1xUWWmnf/m3S0vLw8DCRkJBZ4TxwZ3X6/PUmTXwxmRQJCVm888713H13J0fHcwiZsmE/rtgfcbSCAgtff32IVav28cknf5GSkovZbKJv3xYMGdKGAQPOJzDQ09ExhRBCnIWsIVEPFRZaeeihz5g79xeuu+48liwZgr9/9Repqw9Of/OglCI83Jt9+8bUaDi15WgS8d1uxfOyiwn/4CUZHSEEUHQokfjuI/CPHUqjF8bU6NqnnvqKadO2lDnm5eXG3LkDnLoosWTJbmJj15GbW1Tm+GOPdWf69D4OSuV4UpCwH1ftjzgLi8XGDz/Es2rVPlat2kdiYhYmk4FevZoxZEhrBg1qTXh4w1x/SwghnJ0UJOoprTVvv72Dhx/eQMuWQaxdO5zzzgt2dKxaUdGbB7PZxPz5A2v0pkdrTfbyL/C8vHONPgkWwtUdf3AqOeu+IXrnckwhgdW+rmnTWRw+nFHueHCwJ7Nm9eNkze/04t+Zx06vC555rLbbnDw2atQakpNzy+WOifEnLm5cZT+uy5OChP24cn/E2dhsmh07jrJq1T5WrtzH/v2pKAWXXhrNkCGtGTy4DU2bBjg6phBCiBJSkKjnNm+OY+jQj7FaNUuX3kjfvi0dHalG0tLy2L8/lQMH0ti/P5X9+1NZunQPBQXWcm1r8ubBlptfo60NhWhICg/Ec6TH7QROHEXQhJHVvs5gmIwLvDSUUgpstuccHcNhpCBhPw2hP+KMtNbs3ZvMypV/sGrVn/z++3EAOnVqXLqdaJs2IQ5OKYQQDZsUJFxAXFw6gwYtZc+eJKZP780jj3R3mukJWmuSk3NLiw0n/5wsQKSm5pVpHxHhS2JiVoX3qu6bh8ID8SRe9wChb0zC+5rutfJzCOFq8n74BXPX9ig3U7WvqWyERJMmvmzefCdAacHi9NeQM4+d/vJy5rH/el1FbQYOXMqxY9nlcssICSlI2EtD6Y84u/37U1m9eh+rVv3J1q0JALRu3Ygbb2zDkCFt6Ngx3Gn6T0II0VBIQcJFZGcXMnLkJ6xcuY/bb2/P3LkDMJur/0bjv7DZNEePZp1WbEhl//5TIx5OX/XaYFDExPjTokUQLVsG0rJlEC1bBtGiRRDNmwfi5eVW6Zue6rx50FYrRweMofDvOKJ+WCxTNYQ4C611tTvgFU2nqq9rSNSH3HVNChL205D6I/VFYmImn3zyJ6tW/cnmzXHYbJqYGH+GDCkuTnTvHonRaCizplV9WshXCCHqCylIuBCbTTNlync899xmLrkkgtWrh9GkiW+t3NtisXHkSMYZIx3SOHCgeLRDfv6pfcDd3Aw0a3ay2BBYUnwo/tO0aQDu7lVvrfdf3jykv72UE8++Seibk/C9WXbVEKIquZu2kfL060SsfwtjkH+1rqmvnfP6mrsuSUHCfhpaf6S+SUnJZe3av1i1ah9ffnmQwkIrYWHetG0bwpYtR8pMI5ViphBC1C4pSLig1av3cfvtq/Hz8+Deey9m4cJfq9UJLyiwEBeXXm5axf79qRw6lI7FYittazabSkY2nBrlcPL7qCh/TKb/thXpubx5KDwQT8KVo/C8ogvhi6fJsEshzqLwz0McuewOAh+5k6An73Z0HGFnUpCwn4baH6mPMjML+Oyzf1i1ah8rVvxR4bo5UVF+xMePt384IYRwQVKQcFG7dx+nV69FpKSUXaPB09PEs89eQevWjcqt6RAfn4HNdurv3dfXvVyx4eTjxo19MRic6w1/+pzlpL3yHlHfLZKpGkJU07G7niFv83aif1mOMaB2RlSJ+kEKEvbTkPsj9VlVC/l26dKErl0j6NYtkm7dImnePFA+CBFCiHMgBQkXFhU1k4SEzCrbBAd7lq7hcPqaDi1bBtGokVe9e3G1nkjHGCzbeQlRXQV795Nw5SgCHxtF0MS7HB1H2JEUJOynofdH6qvK1rTy8/OgU6fGbN+eSE5O8fTSRo28SgsUXbtGcMklEfj7y25fQghxNpX1R+yzGqKoU4mJFRcjlIKff76HFi0CCQz0tHOq2ld44Ai2jCzMnS6QYoQQNeTRtiXe111OxpzlBNw/DIOvt6MjCSGEU5g69eoK17R6663rGDGiHRaLjT/+SGbr1gS2bUtg69ZE1q//Byjua7VpE1KmSNG2beh/ntIqhBANhRQkXEB0tH+Flf3oaH86d27igES1T1utJD/0PwoPHiHmlxUYvOTTCCFqKuiJu7HckYTy8XJ0FCGEcBon166qbE0rk8lA+/ZhtG8fRmzsxQBkZOSzfftRtm5NYOvWBNat+5uFC38FwNvbjS5dIsoUKRo3lqlyQghRESlIuIDKKvtTp17twFS1K2PucvK37yH0zUlSjBDiHLm3boZ762aOjiGEEE5nxIh2NdpRw9/fTO/ezenduzlQvLXywYNpJaMoEtm6NYFXX/2JoqLihcKjo/1L1qGIoGvXSDp1amy3bduFEMKZyf8JXcDZKvv1XeH+eFL/Nw+vvpfic1NfR8cRol7TNhupL76DMawRAffd7Og4QgjhEpRStGhRvFbXiBHtAcjPt7Br178loygS2bYtgY8/3gsUb53eoUM43bqdHEURSYsWsmCmEKLhkUUthVPTVitHB4yh8J/DRH3/vuyqIUQt+PfWieTv2EvML8sxyPQNlyeLWtqP9EfE2Rw7ll2yDkVxkeL0BTODgz1Lp3h06xYpC2YKIVyKLGop6iet8erTA7+7b5RihBC1JHDCnST2u4+MBasJHDvC0XGEEKLBCA/3YdCg1gwa1BqgygUzAdq0aVSmSHHmgplLlux22RGyQoiGQUZICCFEA3T05gkU/P4XMTuXY/Cu/7vwiMrJCAn7kf6IqA1nLpi5bVsiKSm5QPGCmZ07N6Fbt0gKCqzMmbODvDxL6bVeXm7MnTtAihJCCKcjIyREvaKtVo6Pfg7fW/vj3aeHo+MI4XKCHhs+Ky8wAAAgAElEQVRFYv/7yXzvEwIevMXRcYQQQpSo6YKZp8vNLWL8+A106hRO06YBeHq62Tu+EELUiBQkhFPKmLOcnPXf4n3dZY6OIoRLMne5kKAn7sbzqkscHUUIIUQVKlsw08trKhUNdE5OzuWCC94CiqeING8eSLNmATRrFlDyuPj7yEg/jEZD+RsIIYQd2b0goZTqB7wGGIH5WuuXzjg/EpgBJJYcmq21nm/XkMKhCvfHkzptHl79euIztI+j4wjhsgIn3OnoCEI4jPRHRH1mNpuIjvbn8OGMcufCwrx55ZU+HDqUzqFDaRw8mM4PP8Tz0Ud7sNlOVTBMJgMxMf6lBYpThYtAmjcPJDjYU3b9EELUObsWJJRSRuBN4BogAdiulFqrtf7jjKbLtNZj7JlNOAdttZI0dhrK7EHIjAnyQihEHSs8cISMt5YSPGUsBk8PR8cRwi6kPyJcwdSpVxMbu47c3KLSY15ebrzySt8K15AoKrISH59RWqg4dCidgweLv37yyZ8kJ+eWae/j435agSKgTOGiadMAvL3d6/xnFEK4PnuPkLgE2K+1PgiglFoKDALO7ACIBirns+8p2L6H0LefkV01hLAD67EUMt9fi1urZgTEDnV0HCHsRfojot47WXSo7i4bbm7G0qkfFcnOLiwtVBSPrDhVtPjqq4NlCh8AoaHelU4HiYryL7MbyJlkdxAhxEn2LkhEAEdO+z4B6FpBuxuVUpcDfwPjtdZHKmgjXJD39VfQeOVMPC+72NFRhGgQPC/tiLl7B9LfWILfHQMwmGWUhGgQpD8iXMKIEe1q7Y28j4877dqF0a5dWLlzWmuSk3PLFCpOFi+2bk3g44/3YrWemg5iNCqioyueDrJr1788+uiXpQWOw4cziI1dV/rzCCEaFmdc1HId8JHWukApdS+wCOh1ZiOlVCwQCxAdHW3fhKLWZK3YSOrUuVgSkzCGBxP87P34yroRQthV4GOj+HfIOLKWrMd/9BBHxxHCWUh/RIgSSilCQ70JDfWma9fIcuctFhsJCZklxYqTBYvi0RWffvo3x4/nVHn/3NwiHnxwPcnJOQQFeRIYaCYw0LPMY7PZGd+2CCH+K6UrWp63rp5Mqe7A81rrviXfPwmgtZ5WSXsjkKq19q/qvrLvd/2UtWIjyY9MR+cVlB5TZndCZj4uRQkh7EhrzdEBYyg6coyYnz9Ceci8YFdS2b7fDZn0R4Swr5ycQuLiiosUAwZ8dE738PQ0lStSnHpsLnlc/nxAgLnK6SM1IVNNhDh3lfVH7F1q3A6cp5RqRvGq1cOBW09voJRqrLX+t+TbgcA++0YU9pI6dW6ZYgSAzi8kdepcKUgIYUdKKQIfv4vcjT+iC4ukICEaAumPCGFH3t7utG0bStu2ocTEVLw7SHS0P7t23UtaWh5pafmkpuZV8TifuLh0du36l7S0fLKzC6t8fl9f99KCxanihbmCY2Uf+/l5YDAUL7C+ZMnuMouI1repJlJMEc7KrgUJrbVFKTUG+ILibbYWaK33KqVeAHZordcCY5VSAwELkAqMtGdGYT+WxKQaHRdC1B2vyy7GS9ZuEQ2E9EeEcJzKdgf53/+uJiioeFRDTRUWWklPzyctLa+0YFH+cX5pUWPfvpTS8wUF1krvazAoAgKKR2AcOZJJYWHZtienmsTFpeHhYcLDw4jZbCp9fObXqs55eJhKix+1rT4XU+prIUVyV59dp2zUFRkiWT/FtR2ENSm13HFTZBgxu1Y4IJEQDZvWmrzvdqILCvHu08PRcUQtkSkb9iP9ESGqx5nerOXlFVVrRMaHH+6u8yxuboZzKmYUn6u4yGE2m3jiia84cSKv3POFhnrz4YdDMBgUBoPCaDSUPi7+Xp3xveE/nzt5XqmzF1/OLKRAcfFq7twBTv3mXnJXrLL+iBQkhMNkrthI8thpUGQpPaY8PQh5daJM2RDCAbTWJPa7F2tKOtFbP0S5yQJirkAKEvYj/REhXFfTprMqnWryzz8PUVBgoaDAWuZrfn75Y2c7V3z85LGa3+/MURzO7GzFi/T0fGy28u9VjUZFWJhPmWNV1TfOVvw4W22kptcnJGSW2XXmJKNRERXlX+nzVfQ8FbX9L+2qart/fyoWi63cuZgYf+LixlV4r5pwljUkRANXdCiRpIenEfrak/gN7YOC0l02TBGhBE2KlWKEEA6ilCJwwkiOjXicrOVf4HfrdY6OJIQQQjiFqqaauLsbcXc34uvrwIAltNYUFlrLFCq6dXuXo0ezyrUNC/Nm+fKbsNk0VqvGZjv1x2q1nfa48nNnnj/XcxU955tvbq/wZ7RaNf37tzztZ67691H17+tsv8+znS/fYNGi3ypsa7VqLrus4t2YKnqeiu79X9qdre2ff6ZUeE18fPlCXG2SgoSwm5wvfyLp/hdAKSz/JuPWLALfoX2kACGEE/G6pjseHVqRNnMxvjf3RZnkZUIIIYQ4OWTdWaaaVEYpVTJlwwR4ADB9+jUVFlNeeaUvl10W46CkZ/fpp39XOColJsafefMGOiBR9WzeHFdp7vffH+yARNWzbVtCpaOA6lLt7IEjRBW0zUbqK+9xbMTjmKIaE/nVfDx7XOToWEKICiilCHx0JJa4ROIuGMSB0Ms53HEoWSs2OjqaEEII4VAjRrQjLm4cNttzxMWNc7piRGVGjGjH3LkDiIkpni4QE+Pv9OsZQPGoFC8vtzLHvLzcmDr1agclqh7JXTPy0ZeocxnzVpL20rv43NyXkBmPYvAyOzqSEKIK1uxcMBiwpWUCYEk4TvIj0wFkRJMQQghRD40Y0c7pCxBnqi+jUs4kuWtGFrUUdUbbbCiDAVtuPjnrv8VnaJ9qragrhHCswx2HYkk4Xu647IBTP8milvYj/REhhBCiYpX1R2TKhqgT2Z98TWK/+7Bl52LwMuN7U18pRghRT1gSk2p0XAghhBBCiHMhBQlRq7TFQspzb3L8nudQJiO23HxHRxJC1JApIrTC44bgul3USAghhBBCNCxSkBC1xpqSxtGbJpDx1lL87hpCk09exxQa5OhYQogaCpoUi/L0KHtQKWwp6SRPfFUKjUIIIYQQolbIopai1iQ/+goFO/YQ8sZT+A2/1tFxhBDn6OTClalT52JJTMIUEUrg43dR+MdBMt5dhd9t1+PR/nwHpxRCCCGEEPWdLGop/jNdWIRyd8OSeBxrSjoeHVo5OpIQoo5YEo9jiggDIPebn/G8/GKU0ejgVKIqsqil/Uh/RAghhKiYLGopap0uKCR5wgyOjXoabbNhigiTYoQQLu5kMSL/lz/49+YJHL1xPEUV7MghhBBCCCHE2UhBQpwTy9EkEgeOIfP9tbi3aQ4uMNJGCFF9Hh3bEPL6kxT8+icJV4wka/VXjo4khBBCCCHqGSlIiBrL27KLI1ePpvDvw4S9N5Xgp++VIdtCNDBKKfxu6U/UNwtxOz+GpNjJJD/2sqNjCSGEEEKIekQWtRQ1ogsKSXpwCsZAf8IXTcX9vBhHRxJCOJBbswgi1s0mbdbi0ukcQgghhBBCVIcUJES12HLzUR5uKA93wj+cjltUOAZfb0fHEkI4AWUyEfToqNLvM5espygukaCJd6Hc5GVGCCGEEEJUTKZsiLMqOphAYr97SZ02HwCPC1pIMUIIUanCPf+QPmsxif3vp/BAvKPjCCGEEEIIJyUFCVGlnI0/knDNPViOpeDZs5Oj4wgh6oFG08YRtuBFiuISSeg1msz31+IKW0wLIYQQQojaJQUJUSFts5E6YyHHRjyOKaYxkV/Nx+vKLo6OJYSoJ3wGXEnUd4swd25L8oQZFPzyh6MjCSGEEEIIJyOTe0WFivbHkzZrMb7D+tFoxqMYPD0cHUkIUc+YGofQePmr5P3wC+aL2wJQFP8vbtGNHZxMCCGEEEI4AxkhIcqwHD8BgPv5TYn6ZgEhbzwlxQghxDlTBgNel3cGoOC3v4jvegspT87Cllfg4GRCCCGEEHUja8VGDnccyoHQyznccShZKzY6OlK1OCK3FCREqaxVXxF/yXCy13wDFBcllFIOTiWEcBVurZrif9cQMuavJKHPPRTs2e/oSEIIIYQQtSprxUaSH5mOJeE4aI0l4TjJj0x3+qKEo3LLlA2BLrJw4oW3yXjnY8yXtMPctZ2jIwkhXJDB7EGjqWPx6t2NpDFTSegbS/Az9xFw382OjiaEEEIIJ5S1YiOpU+diSUzCFBFK0KRYfIf2cXQstNbo3HxsufkYfL0wmD2wpmZQsOcfUp5+A33GSFCdV8CJ59/CkpgEVhvaagWrFW214X/XYEyNQ8jb9jvZqzeBzVbcxlLcJuiZ+zCFBZOz4Qeylm5A26ynzttshM15DmOQP5kffErmkk9LzlnAZkNbbUR+MReDl5m0VxaR+cG6kvuWZLDZaPr3epRSJD/6coW5U6fOrdPfuRQkGjhLUirH73mO/B9/xf/uGwme/CDK3c3RsYQQLszrqkuI+m4RyY9Mx5aT6+g4QgghhHBCJz+xP/km+eQn9kC13yDrIgtojXJ3QxcUUvjnIWw5edhy89G5edhy8jB3aoN7q2ZY/k0m/a2lxYWGnDxsuXno3HwCxtyK15VdyN+xl2N3PIktJx+dlw8lO4iFL56Gd7+e5O/Yw7ERT1SaxXr8BKlT5pQ9aDLifd3lmBqHUHQokeyVX4LRgDIYwWREGQ3onLzi69OzKDwQjzIawGhEGY1gNKCtNgCUuwmDj1fp8dL7nHyqZhHFuyYaDSiTCQyG4ntpDUqVPs+ZLIlJ1fpdnyspSDRweVt+oWDXPkLfehrfm/o6Oo4QooEwBgcQ9t7U0hfz3G9+xpaRjc8NvRycTAghhBCOoq1WbBnZWNMyOfHcmxV+Yp888RXyd+xFlxQWvPv0wHdYP6wZWST2u69MsYEiC0FP3UPg+DuwHD9BQu+7yz1n8JSxuLdqhi0zm8z312Hw9kR5m4u/enkWFzUo7rt4X3sZyuvUOYO3J+6tmwNg7nwhTdbO5vjdz2JNSi33PKbIMKJ+XFJcBDAZUYayqyf4Db8Wv+HXVvq7Odt535v74Xtzv8rPD+mN75DelZ43RYYVT9c483hEaKXX1AYpSDRQhQeO4N4iCt/BvfHs1gFT4xBHRxJCNDBKKShZpyZjwWpyN/xAzpc/EfLSOAy+3g5OJ4QQQohzUTqdIT0Ta1oWymTEvXUzADLeXYXlaFJp0cGWkYW5c1uCniguFBxqfi06t+JP6kvvn5VL9sovS4sC5osvAEB5uON+QYuS42YMJQUDc4+LADCGBhG+eFrZgoKXGWNwAADurZrR/HDl6yW4NYsg5JXHKj1vDPLHs3sHgic/WGZkB4Dy9CBoUqxTbxYQNCm20tx1SQoSDYwtv4CUJ2eRvXwjkV+/i/v5TaUYIYRwuPAFL5L2ynukzVxM/rbfCHvrGcyXyHo2QgghRG04l7UYtMWCLT0LW34hbpFhAORu2kbRoQSs6ZnY0rKwpmdhCg0k+LkHAEgc9BD52/dAyagCAM/LOtFk1WsApL/zMZaEYxgD/TD4+2II9IPTRgoETRwFbm4YA31JeXY2tpT0crlMkWHE7FpR7rjB7EH4uy9U+vMYzB549+tZ5c9cG07+Xp1x7YuqOCq30iXDZeuzzp076x07djg6htOzJB7n2KhnKNi1j4DxdxD0+F3Fc4yEEMJJ5G37naQHpmBJOE7kxrl4dGjl6Ej1nlJqp9a6s6NzNATSHxFCOKPMZRtIeeyMBQvdTHhffwVukeFoq5VGkx8EIGXS6+R8/j3WtEx0dvE6T6aYxsTs+BiAozc9Qt7m7QAYfL0xBPji0b4V4e9NASBt9ofYUjMxBPpiDPDFEOCHKTIMc8c2ANjyClBm92rt5HfmGhJQ/Il9yKsTnf7NvSivsv6IjJBoIPJ++IVjdz+LLigifNFUvPtf7uhIQghRjmfX9kRtXkjmR5/j3v58oHhkl8HsvEMchRBCCHvSNhu2tEysKWlYU9KxJqfhfd3lKDcT2as3kb3mm5JzxX9sGdnlb1JkIWf1JnAzYQpvVFqQMEWFY+5+UXExIdAXo78vxtDg0stC33gKZTJi8PdFuZV/Kxk45tYqs9dkykJ9HWkgakYKEg1E7qatGIMDCF/0P9xbRjs6jhBCVMrg601A7FAAig4lkjjgQYKeuBvfEddV6xMVIYQQoi7U1RaUWuvinSAMBiz/JpP/yz5sJ4oLDdaUNKwn0gl+YQym8Eakz1nOiWdnF28NeZqY31dhahyC5XgKhfsPY2wUiPuF52FsFEDmu6sqfmKlaJ74dZnX1rNtxW0Kb/Sff96a8B3aRwoQLk4KEi7Mlp2LJfE47q2aETQplsAJIzH4eDk6lhBCVJsyu+N+fgzJ4/+P3K+2EvLqYxiD/B0dSwghRANT0y0obXkFp0YpJKfh0f58TOGNKNj9D+nvLDtVbEhJx5qSRpPVr+HZtT15P/xC0gNTSu9j8PPB2CgAW0YWhDfC46JWBI67HWOjAIyNAjGUfDU2CgQg4L5hBNw3rEyW3C+2VLp7ghT6haNJQcJFFR44wrGRk9DZuURv/RDl4Y7ykb9uIUT9YmocQuMVM8l4exknps4l/4q9hL7xFF5XdnF0NCGEEA1I6tS5lW5BmffDL/je1BfPSzuSv2sfRwc/jM4pu1NE2LzJ+NzQC1t2Lvlbf8fYKABTeCM8LjwPY6NATCFBAHj16krkpncxhgRiDPJHebiXuY9n1/Z4dm1fo+yO2j1BiOqQd6gu4vQhZIYgf2zZuRi8PQmb+3y5/5EJIUR9ogwGAh68Bc/LO3P8/hfIXvuNFCSEEEL8Z6VrMSSnobzMuEU3xpaTR9or72E5noo1ORVr0qmvFd4jK5fcTdvw7F68taSpcQh+tw8oHbVQPJIhALeSKdOe3TsQs/PjSjMZgwNKt6GsLbIWg3BmssuGC6hoBVqUIujFhwi89ybHBRNCiFpmyysArTF4mSnYux+UwuOCFo6O5dRklw37aej9ESGchTUjq7iQUPLHkpyGW1QY3tdehtaaxD6xWI6lYE1JA4sVAL/RQwh5aTy6sIhDzfsVj1AICcIYGoQxJJCcDT/UaAtKIURZssuGC9JaU3QwgZRJr5cbQobWZL6zTAoSQgiXcvrq3CmTXid/+x6Cn7kX/9ibUKftYy6EEMJ51XRxSK01uqCwdMel3E3bKIpLxJqciqWk6ODWIqp0p4gjPe/AeiylzD28r7sC72svQymFW7MI3Ns0Ly46hAZjDA3EvXVzAJS7G82OfFVubYWsSzvKtAch6oAUJOqZorij5Hz+HfnbdpP/826syWmVtrUkJtkxmRBC2FfYvMkkj/8/Tjwzm9xN2wh94ym7r/4thBCiZipcHHLc/1Hw1yEaTboXgPQ3PyL/591YktOwJp3AmpyGW4soor5eAEDq9Hcp+GUfGAzFUxxCA3GLCi99juBn7gWjEWNIIKbQYIyhQRgCfEvPh819vsqMFS30KNMehKgbMmXDiVkzsynYvpf8n3fjc1Mf3FtGk7XqK5LunYypaRPMl7THs1s7Uv9vAdbjJ8pdL0PIhBCuTmtN5vtrOfHMGyizB/5jbiFr4SfSWTyNTNmwH1ftjwhRU0WHj1K0/wjWEyd3kUjHlp1LyPRHONxxaIU7PmAw0OL4twAkjZ1G/q59mEJPTpkIwq15JP4jbyi+f/y/KLMHxmB/lNFozx9NCHGOZMpGPWFJSiXtlUXkb/udwj8OgNZgNOJ2fgzuLaPx7tODmN2ry3wKqDzNMoRMCNEgKaXwv3MQnpd2JOnRl0l/+b1qb8kmhBCiarqwCOuJ4oKC9UQ65m7tMZg9yP16G9lrv8F6IqPM1pVN93yCwduTjHdXkfH2slM3cjNhbBRIo/+NrXwEr7aVPgx9/ckqc7lFN66NH08I4QSkIOEg2mqlcN8h8n/eTf623zF3bov/PUMxeHqQvWIjHp3aEPjYKMxd22HudAEGHy8ADD5epY9PkiFkQoiGzr1lNNbDRyveku2R6RTu3Y9Xv554dm2P1hq0ljUnhBD1Xk3XYjjJeiKdgj37TxUTThQXFALH34FbVDhZyzaQ8tRr2DKzy1wXtfVD3FtEUbj/CLlfbS3ZQSIQt+jGGBsFgq24qOB35yC8r7u8dJcJg59P6TQIU0RohSMkTBFhtfAbEULUN1KQsBNts5V2fo+Nepq8b3dgy8oBwBjeCPfWzQAw+HrT9J/1Ne4o+w7tIwUIIUSDVtmnbjqvgPS5KzCGh+DZtT2WQ4kcufxOTDGNcWsagVuzCNyaReJ1dTfcmjaxc2ohhDg3mSs2knLmWgzji0eFeXRsTcbbH5eOXDhZcAib+zxeV11C3k+/cXzU06duZjRiDPLH77brcYsKx615JL4398XYKBBDSdHBGByAqXEIAAGxQwmIHVppNvcWUdAiqsJzQZNiZWSvEKKUFCTqiCU5rXj0Q8kICJQi8vN3ADAE+uEzpHfx6Ieu7TFFhZdZPEc+tRNCiJqr9FO3yDCidywr3dpNmd3xjx1K0cFEiuISyPvhF3RuPmELXsStaRPyfvyVpIdfKi1UFH+NwNytPUZ/33L3F0KIc6ULi7BmZGPLyMKWkVW8VkJ0Y6yZ2WQu/ARbybmTbfzuGIjPgCsp2HeQ5PtfLH+//AJSp84lbMGL5Hz2HYbg4mKCe9uWxaMZwoIB8OzegSZr3ijeZSI4AEOAb5n+p7nLhZi7XFgnP7OM7BVCnE4KErVAa40l7ihuzSIASH5iJpnvrgJAebjjcVFrzD0uQmuNUorQVyc6Mq4QQrikqj51U0YjlCx8ZmoSSvCz95e20VpjPX6idDqc8vTAo0Mrig4lULBjb+lotogv5mDsdAHZ678jc8Eq3JpFYmrapLRo4X5eDMpNXlaFqI/OdeqDtlqxZeaUFg6UtyfuLaPRWpPx1tKSQsKpgoNX7+74jx6CLTuXuAsGlptmFvjInQQ9eTe6oIjUKXOK114I8MXg74vB3wddZAHAFBpUaSZLYhLmjm1o+sfaStsYgwPw7HFRNX87tU9G9gohTpKe0znQhUUU7P67dOvNvG2/Y0tJJ+b3VZgah+B11SWYIsPwvKQdHh1aoTzcHR1ZCCFc3rl+6qaUKrNQsLljG8LnTwaKixW21AyKDiWW7lGP1YotN5/sTzdjO5FRet3JBYezln9B3ve/lBlhYWoWgdHPp9IM5/pmSAhnU5/+Lduyc7Hl5pO1+ivSXpyDLigETi2Im/fjr5gahxQXE9KzsGZm43FBC4KeuBuAw12GYYk7WuaePjdeQ9g7z6KUInX6QnR+AQZ/n+I/fj7o/OIChPL2xG/UYIx+PhgCfEvPu58XA4CxUQDNDn+J8vSocAtKY3AApsiwStZiCK3V35MQQtQlKUicoaIXUq9rupO/fS8eF7bEFN6I7NWbSBozFQBT0wi8r+6GuWs7lJcZAO++l+Ld91JH/hhCCNEg1fanbkqp4j3ugwNKj/kMvAqfgVcBYM3IwhJ3lKKDCaVDoS0Jx8n9elvZ7ZjdTDQ/8hXKaCTzw/VYEpNKp4IU7P6HE8/Olt1BRBn16Y39SVkrNpYZpVTdf8taaygswpZfgM4rKC0QFsUdxfJvMjq/AJ1fgC2/ADT4DukNQPYnX1Ow55+S84XY8gow+HoR8tJ4AFImvU7eT7+i8wtL72FqGkHkZ28DcHToeAp2/lFxprwCsj76HCwWlI9XySgFnzK7O/gOvxasttLRC0Z/H0wxp9ahabr3E5SXucKpuEopGk1+sNLfiVKqtF9ZGVmLQQjhCpTW2tEZ/rPa2vf7zBdSAJQq3noTaDRjAv4jb8CSlFq8M8Yl7TCVdECFEEKI09ly8iiKS6Qo7ii2E+n43TEQgOP3TiZ79abS15bKmCLDiNm14j/nqGzfb1H76rI/ojzc8R9zC16Xd8atZTSm0CCsaZkU/Pon2DTaai3+N2Wz4dGxDabwRliOpZD/02/Fb/htNrDZ0DZdPJIzLJiigwnkfr8TrKfOYbPhM6Q3ptAgCnb/Q+6mrcX31zYoOe9/940YgwPI++k3cr/8EW0rPpe5eB06O7fcz6PM7nhc3La0KBCxYQ4GswcnpswhY96K4p/z5H8PStH8+LcopUga9xJZS9aXvZePF80PfQHA8XueI3vdtyhPDwyeHiizB6aIMCLWzQYgddp8Cvb8gzIXnzN4FZ8PHHc7ANmrN2FNzSDliZkV/0UoRfOjX6NMzvv5XX0sXAkhGqbK+iN2L0gopfoBrwFGYL7W+qUzznsA7wMXAyeAYVrruKruWVsdgMMdh1Y49M3g503Ye1OLt9/09vzPzyOEEKJhs+UXYIn/l6JDiRy77YmKGylFi6Tv/vNzSUGiYvWxP3JS6NvP4Du0D3lbdnH0hrHlzocvnoZ3v57kbNzCsRHl/301Wf0anj07kbXqK5LunVzufMSX8zBf1JrMxWtJfmRGufNRP36A+3kxpM9dQeqLb4PBAEqhc/IqzWzu1gFldkd5ehD21jMYfLzI+fx78rb+jsHsUXpOmT3wu2MgymD4//buPUiysrzj+Pe3O1zlYriqgCxaYvBGgkqQUkCNl5gE1BDFiBGjErHUqJQXJCjxVmWMlGVpFaBQKKiomNJNQFFBJaJrXCGoYEAuK6yiLKIorFwWnvxxzpimt2d2Zjl7enr3+6k6NX1Ov/3O08/2bj/79Dlvc+ePr+WeVbe092/R3L/Vlmy2e/P1kIPfYHZ/zJTvrpqCkqQF0pBIshi4CngGsBL4HvCiqrpiYMyrgcdV1auSHAE8r6peONu8XRUA1+xy0OhPrDoqCiVJGrah/zNkQ2Jtk1uPwIM//0E233sJU7vuyD2/vY27//e6piGwKM3irQlTSx7C4u224d7bVrPm5zf9oWGQdtziXXZk0VZbcO/qO7j3t7fBokVk8aI/zLPoAVuRqSlqzRpqzT3NvIvSjBuxnp9tU8sAAA+uSURBVMG0Sf2P/cgzUrbagp1PerNnG0hSR2aqR/o+B21/4OqqurYN6mzgMGDwAr7DgBPb2+cAH06S6qFzMuNXxrk4kCRpA/E68LGY0HpkV7Z+yuP/sL94u21YvP9jZ5xn0TZbs/neS2a+f+stWTTLOgWZmprX5QqT+lr2ayglaXzu/3lu87MbcMPA/sr22MgxVbUGuBVYa6GGJEcnWZ5k+apVqzoJbofjjyZbbXHf3zMBb6SSpMm17eHPZOeT3szU7rs2n27vvqufzG541iMbwCS/lrc9/Jnseek5PPymi9jz0nMmImZJ2hgs3FV61qGqTgVOheYUyS7mtEMuSRqHrr8dRP2xHrkvX8uSpPnouyHxM2CPgf3d22OjxqxMMgVsT7OYVC98I5UkaaNnPSJJ0gLQ9yUb3wMekWSvJJsDRwBLh8YsBV7a3j4cuLCP6zUlSdImw3pEkqQFoNczJKpqTZLXAOfTfM3W6VV1eZJ3AsurailwGnBmkquBW2iKBEmSpE5Yj0iStDD0voZEVZ0HnDd07O0Dt+8A/rbvuCRJ0qbDekSSpPHr+5INSZIkSZIkGxKSJEmSJKl/NiQkSZIkSVLvbEhIkiRJkqTe2ZCQJEmSJEm9syEhSZIkSZJ6Z0NCkiRJkiT1zoaEJEmSJEnqnQ0JSZIkSZLUOxsSkiRJkiSpdzYkJEmSJElS72xISJIkSZKk3tmQkCRJkiRJvbMhIUmSJEmSemdDQpIkSZIk9c6GhCRJkiRJ6p0NCUmSJEmS1DsbEpIkSZIkqXc2JCRJkiRJUu9sSEiSJEmSpN7ZkJAkSZIkSb2zISFJkiRJknpnQ0KSJEmSJPXOhoQkSZIkSeqdDQlJkiRJktQ7GxKSJEmSJKl3NiQkSZIkSVLvbEhIkiRJkqTe2ZCQJEmSJEm9syEhSZIkSZJ6Z0NCkiRJkiT1zoaEJEmSJEnqnQ0JSZIkSZLUOxsSkiRJkiSpdzYkJEmSJElS72xISJIkSZKk3tmQkCRJkiRJvbMhIUmSJEmSemdDQpIkSZIk9c6GhCRJkiRJ6p0NCUmSJEmS1DsbEpIkSZIkqXc2JCRJkiRJUu9sSEiSJEmSpN7ZkJAkSZIkSb1LVY07hvstySrgpx1PuxNwc8dzbqrMZXfMZXfMZXfMZXc2RC73rKqdO55TI1iPLHjmsjvmsjvmsjvmsju91SMbRUNiQ0iyvKqeMO44NgbmsjvmsjvmsjvmsjvmUsN8TXTHXHbHXHbHXHbHXHanz1x6yYYkSZIkSeqdDQlJkiRJktQ7GxIzO3XcAWxEzGV3zGV3zGV3zGV3zKWG+ZrojrnsjrnsjrnsjrnsTm+5dA0JSZIkSZLUO8+QkCRJkiRJvbMhIUmSJEmSerfJNySSPDvJlUmuTvLWEfdvkeQz7f3fTbKk/ygnwxxy+cYkVyT5QZILkuw5jjgnwbpyOTDub5JUEr/iaAZzyWWSF7SvzcuTfKrvGCfFHP6OPzTJ15Nc2v49f8444lzokpye5KYkP5rh/iT5UJvnHyTZr+8Y1T/rke5Yj3THeqQ71iPdsR7pxoKpR6pqk92AxcA1wMOAzYHLgEcNjXk1cHJ7+wjgM+OOeyFuc8zlU4Gt29vHmMv1z2U7blvgImAZ8IRxx70Qtzm+Lh8BXAr8Ubu/y7jjXojbHHN5KnBMe/tRwIpxx70QN+AgYD/gRzPc/xzgS0CAA4Dvjjtmtw3+mrAe6TeX1iMd5bIdZz3SQS6tRzrNpfXI3HK5IOqRTf0Mif2Bq6vq2qq6CzgbOGxozGHAx9vb5wBPT5IeY5wU68xlVX29qla3u8uA3XuOcVLM5XUJ8C7gfcAdfQY3YeaSy1cCH6mqXwNU1U09xzgp5pLLArZrb28P/LzH+CZGVV0E3DLLkMOAT1RjGfDAJA/uJzqNifVId6xHumM90h3rke5Yj3RkodQjm3pDYjfghoH9le2xkWOqag1wK7BjL9FNlrnkctDLaTpuWts6c9meMrVHVZ3bZ2ATaC6vy72BvZNcnGRZkmf3Ft1kmUsuTwSOTLISOA94bT+hbXTm+++pJp/1SHesR7pjPdId65HuWI/0p5d6ZKrrCaV1SXIk8ATg4HHHMomSLAJOAo4acygbiyma0yQPofmU7KIkj62q34w1qsn0IuCMqvpAkicBZyZ5TFXdO+7AJGmY9cj9Yz3SOeuR7liPTJBN/QyJnwF7DOzv3h4bOSbJFM1pP7/qJbrJMpdckuTPgeOBQ6vqzp5imzTryuW2wGOAbyRZQXNN11IXkhppLq/LlcDSqrq7qq4DrqIpCHRfc8nly4HPAlTVd4AtgZ16iW7jMqd/T7VRsR7pjvVId6xHumM90h3rkf70Uo9s6g2J7wGPSLJXks1pFolaOjRmKfDS9vbhwIXVrvKh+1hnLpP8KXAKzZu/18XNbNZcVtWtVbVTVS2pqiU0178eWlXLxxPugjaXv+NfoPk0giQ70ZwyeW2fQU6IueTyeuDpAEn2oSkAVvUa5cZhKfD37erWBwC3VtWN4w5KG5T1SHesR7pjPdId65HuWI/0p5d6ZJO+ZKOq1iR5DXA+zYqtp1fV5UneCSyvqqXAaTSn+VxNs+jHEeOLeOGaYy7fD2wDfK5dh+v6qjp0bEEvUHPMpeZgjrk8H3hmkiuAe4A3VZWfOg6ZYy6PBT6a5A00C0od5X+Y1pbk0zRF507t9a3vADYDqKqTaa53fQ5wNbAaeNl4IlVfrEe6Yz3SHeuR7liPdMd6pDsLpR6JfzaSJEmSJKlvm/olG5IkSZIkaQxsSEiSJEmSpN7ZkJAkSZIkSb2zISFJkiRJknpnQ0KSJEmSJPXOhoQ0T0lOTLJeX0+T5PVJnt91TBtCkhVJzliPxz03yRtHHD8kSSU5pIv4FrIkT0ry3SS3t8/5T9rjb0tyfZI1Sf5n3HFKkiaX9cg6H2c9Yj2iCWBDQpq/jwFPWs/Hvh6YiALgfngusFYBAFxCk7dL+g1nLE4DpoC/pnnOVyXZH3gPcDZwEPCS8YUnSdoIWI/MznrEekQTYGrcAUiTpqpWAivHHce0JFtU1Z3jjmNdquq3wLJxx7GhJVkEPBJ4T1VdOHB8n/bmyVV17ViCkyRtNKxH1o/1iPWIFhbPkJDmadQpku1pcO9O8rok1yX5XZJvJnn0wJgVwJ7Ai9vxNXgKYpJ9kyxN8uskv09ycZKnDP2eM5KsbE/B+3aS3wP/Oj1/krOSvDLJ1UnuSHJJkqeOeA5HJrmsHXNzkjOTPHgdz3vnJKckuSrJ6iQ3JPlUkt0G4wNeCuw28BxXtPetdYpkGm9IcmWSu5LcmOTDSbabb37XEfvBSb6a5Nb2tMXLkrx84P7N2vlXtHGsaPc3G5pn6yTva2O4q/15fPumT5KjgHto/m09Yfr5J/kGcEY7zTXt8RPnErskSaNYj1iPWI9oY+AZElJ3jgSuBP4J2Bx4P/DFJH9cVWuA5wHnAZcBJ7aPWQWQZD/gv4BLgVcCq4FXAV9LcmBVfX/g92xPc5rdvwFvA34/cN8hwOOB44E7gbcAX0qyb1Vd2f6uo4FTgM8AxwEPAd4L/FmS/arqthme3w7AHe1jVrWPOxa4uH2OdwDvAnYGnggc2j5utk9L3tPO9xHgP4BHtXPsm+Tgqrp3YOy68jtSksOAzwMXA/8I3Aw8mqYYm/Zx4AVtHr4FHEiTw4cBf9fOMwWcPxDjD4EDgBPa3BwLnAs8uZ3jNJrTae9styPb5/p84EYW0KdakqSNivWI9Yj1iCZHVbm5uc1jo3nzrqFjBfwE2Gzg2OHt8QMHjq0Azhox5wXAj4HNB44tbo99YeDYGe2ch42YYwVwF7DHwLFtgVuAMwfm/CXw9aHHPrmd93VD850xSx4WA3u0j3veUIwrR4w/pB17SLu/A80b4xlD445sxx063/yO+J1pn8dyYNEMYx7TznPi0PF/bo8/rt1/Sbt/0NC449u879LuT80w3yva40vG/Rp2c3Nzc5v8zXrkPvFZj1iPuE3o5iUbUne+WlV3D+z/sP350NkelGQr4GDgc8C9Saba7neAr9EsODTobuA/Z5huWVXdML1TVb+j6ZJPL3r1SGAX4JODD6qqbwE/beOYLdZj2tMLbwPWANcPzDtfB9B8snDW0PGz27mHY1mf/D6S5pOHj9V9P90YNJ3f4Tim96fjeDZNjr49/WfU/jl9BdisfT6SJI2b9cj8WI9IY+QlG1J3bhnanz41cMt1PG4Hmu7+Ce22liSLBt7AVlXVPTPM9csZjk1fV7lD+/PGEeN+MXD/qBheC3wIOAl4E/BrmmsTl7Hu5zjKyFiqak2SX42IZX3yu2P7c7bTEWfKyS+G7t+Fppi4m9F2nOG4JEl9sh6ZH+sRaYxsSEjj9xvgXprrFj8xasBQN3227xzfdYZjP2tvT7+JPmjEuAcB3x9xfNoRwAVVdez0gSR7zTJ+XQZjuXxgzimaN9PhN/z1cXP7c7dZxgzGcc3A8QcN3f8r4DqaaztHWbEe8UmStFBYj1iPSL3zkg2pX3cCWw0eqKrbaRaQ2he4pKqWD2/zmP+AJHtM7yTZFvhL4DvtoStpPqE4YvBBSQ6k6bZ/Y5a5t2btbvzLRoxb6znOYBnNtY5HDB1/IU2zdLZY5uoqmjfmVyTJDGMuan8Ox/Hi9ud0HF+muUb1tlF/RlV1M5IkTQbrkf9nPSKNkWdISP26AnhKkr+iOQXv5qpaAbyR5o3o/CSn0ZyutxOwH7C4qt46x/l/CXyl/Qqn6VWtH0CzCjNVdU+StwOnJDmL5rrE3WhWl/4JcPosc38ZeEuStwH/DTyNZiGnUc9xhyTH0CzedEdV/XB4UFXdkuQDwHFJbqdZ8Xsf4N00q0KfO8fnPKOqqiSvB/4duDDJyTQrcu9Ds+jTO6rqR0k+DZzYfhrybZprXE8APj0Q+ydpCp4L2rgvo7nm9OE0K3g/t6pW39+YJUnqgfVIy3pEGi8bElK/jgM+CnyWpmv/ceCoqrokyROBd9BcF7k9zRvVJcDJ85j/mzQd9PcCu9O8Gf9FVV01PaCqTk2ymua6yy8Ct9G8+b65/XRkJu8EHgi8geY6yW8CzwKuHRr3MZoFld7bjv8psGSGOY+neZ6vAl5NcxriJ4DjZln0aV6q6otJnkHzhn5ae/ga4IMDw46ieR7/QLOa9c+B9wH/MjDP3UmeBbwVOBrYC7i9netcmk9XJEmaBNYj92U9Io1Jqma7/EvSpEiyAvhWVR057lgkSdKmyXpE0ny4hoQkSZIkSeqdDQlJkiRJktQ7L9mQJEmSJEm98wwJSZIkSZLUOxsSkiRJkiSpdzYkJEmSJElS72xISJIkSZKk3tmQkCRJkiRJvfs/xMdex4joO/4AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'fashion MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uXTc_HGmkENP"
      },
      "source": [
        "## cifar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K3gpEkoCvSxc"
      },
      "source": [
        "Now it looks clear that the efficiency of a permuted model depends also on the task difficulty, so I choose to test the WiderNet also over the cifar10.\n",
        "The phenomenon that we see is the same as the small net over an easy dataset: it's impossible for the weight_matching to find a set of permutations that create a linear path. The obstacle remains the profile of the loss function.\n",
        "\n",
        "As in the previous test, the result of the permuted model interpolated with an original one is still better than the interpolation between the original models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I3aIG54XkDNh",
        "outputId": "1082dec0-7bd5-436f-d76d-b7bfe24a84a1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 98.1%, Avg loss: 0.071412 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 97.1%, Avg loss: 0.128897 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['cifar'], model_A_cifar, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['cifar'], model_B_cifar, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o6qYO24ckHQx",
        "outputId": "b0f37b6b-9c41-4c2d-c3e1-d409f0ce570c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 86.6%, Avg loss: 0.426789 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.6183  | 87.430\n",
            "   2  | 0.22 |   0.6788  | 79.390\n",
            "   3  | 0.33 |   1.2071  | 58.560\n",
            "   4  | 0.44 |   1.9680  | 29.040\n",
            "   5  | 0.56 |   2.0848  | 30.510\n",
            "   6  | 0.67 |   1.3961  | 57.450\n",
            "   7  | 0.78 |   0.6810  | 80.920\n",
            "   8  | 0.89 |   0.6803  | 88.030\n",
            "   9  | 1.00 |   1.0621  | 89.540\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.7650  | 89.690\n",
            "   2  | 0.22 |   0.6224  | 89.530\n",
            "   3  | 0.33 |   0.5301  | 89.320\n",
            "   4  | 0.44 |   0.4740  | 88.880\n",
            "   5  | 0.56 |   0.4430  | 88.340\n",
            "   6  | 0.67 |   0.4295  | 87.750\n",
            "   7  | 0.78 |   0.4254  | 87.270\n",
            "   8  | 0.89 |   0.4254  | 86.930\n",
            "   9  | 1.00 |   0.4268  | 86.610\n"
          ]
        }
      ],
      "source": [
        "permuted_B_fashion = git_merge(model_A_fashion, model_B_fashion, silent=True)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['fashion'], permuted_B_fashion, loss_fn, test_set=True, device=device)\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "yH-d2p5RkPYz",
        "outputId": "f643badf-2112-404c-e16e-aaa8bbed3449"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'cifar MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CrBj5um3apLE"
      },
      "source": [
        "## cosine analysis "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8odXVfVswRR8"
      },
      "source": [
        "The methodology of the paper has as goal the minimization of the distance between 2 models after the application of the permutation. For this reason, I also checked the cosine similarity and plotted everything as a heat-matrix. \n",
        "\\\n",
        "Here I create a matrix 4x4, where for each row i save the distance between a model and all the other versions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wAfCf7g8ac3-"
      },
      "outputs": [],
      "source": [
        "permuted_A_fashion = git_merge(model_B_fashion, model_A_fashion, silent=True) # reverse model\n",
        "\n",
        "model_to_analyze = [\n",
        "    model_A_fashion, \n",
        "    model_B_fashion, \n",
        "\n",
        "    permuted_A_fashion,\n",
        "    permuted_B_fashion, \n",
        "]\n",
        "\n",
        "similarity = np.eye(4)\n",
        "for i, model in enumerate(model_to_analyze):\n",
        "  for j, second_model in enumerate(model_to_analyze): \n",
        "    similarity[i,j] = cosine_similarity(model, second_model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 440
        },
        "id": "yiDBrpwmya6c",
        "outputId": "a54d963e-d180-44ae-a6d1-7fb0469e2edd"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "label = ['A_fashion', 'B_fashion', 'permuted_A_f', 'permuted_B_f' ]\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(5, 5))\n",
        "plt.title(\"cos similarity between weights\\nRed=parallel, blue=ortho\",fontsize=14)\n",
        "im = ax.imshow(similarity ,cmap=plt.cm.bwr,origin=\"lower\")\n",
        "fig.patch.set_facecolor('white')\n",
        "# add label \n",
        "plt.xticks(range(len(model_to_analyze)), label ,rotation = 90,fontsize=14)\n",
        "plt.yticks(range(len(model_to_analyze)), label, fontsize=14)\n",
        "# add text\n",
        "for i in range(similarity.shape[0]):\n",
        "    for j in range(similarity.shape[1]):\n",
        "        text = ax.text(j, i, round(similarity[i, j], 2), fontsize=15, ha=\"center\", va=\"center\", color=\"w\")\n",
        "\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DSFtXQTuxUzz"
      },
      "source": [
        "From this matrix we see a symmetry in the permutation. This symmetry will also be plotted in the next section as a barrier between the models.\n",
        "\\ \n",
        "As might be expected, on the matrix we find a main diagonal with maximum values(distance between a model and itself).\n",
        "\\\n",
        "We also find an antidiagonal, matching permuted models with corresponding ones. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fjB-UKJ0aJkQ"
      },
      "source": [
        "## On the symmetry of permutation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-_n9Pg9Oksxx",
        "outputId": "2b1222e6-cfc9-4a1b-fe18-3d2524cd3420"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "original parameter, interpolation\n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.6183  | 87.430\n",
            "   2  | 0.22 |   0.6788  | 79.390\n",
            "   3  | 0.33 |   1.2071  | 58.560\n",
            "   4  | 0.44 |   1.9680  | 29.040\n",
            "   5  | 0.56 |   2.0848  | 30.510\n",
            "   6  | 0.67 |   1.3961  | 57.450\n",
            "   7  | 0.78 |   0.6810  | 80.920\n",
            "   8  | 0.89 |   0.6803  | 88.030\n",
            "   9  | 1.00 |   1.0621  | 89.540\n",
            "\n",
            "evaluate interpolation permuted parameters  (p(B) --> A) : \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.9716  | 89.390\n",
            "   1  | 0.11 |   0.7650  | 89.690\n",
            "   2  | 0.22 |   0.6224  | 89.530\n",
            "   3  | 0.33 |   0.5301  | 89.320\n",
            "   4  | 0.44 |   0.4740  | 88.880\n",
            "   5  | 0.56 |   0.4430  | 88.340\n",
            "   6  | 0.67 |   0.4295  | 87.750\n",
            "   7  | 0.78 |   0.4254  | 87.270\n",
            "   8  | 0.89 |   0.4254  | 86.930\n",
            "   9  | 1.00 |   0.4268  | 86.610\n",
            "\n",
            "evaluate interpolation permuted parameters (p(A) --> B): \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.4276  | 87.560\n",
            "   1  | 0.11 |   0.4292  | 87.360\n",
            "   2  | 0.22 |   0.4354  | 87.250\n",
            "   3  | 0.33 |   0.4497  | 87.410\n",
            "   4  | 0.44 |   0.4741  | 87.700\n",
            "   5  | 0.56 |   0.5142  | 88.140\n",
            "   6  | 0.67 |   0.5805  | 88.850\n",
            "   7  | 0.78 |   0.6875  | 89.130\n",
            "   8  | 0.89 |   0.8455  | 89.330\n",
            "   9  | 1.00 |   1.0621  | 89.540\n"
          ]
        }
      ],
      "source": [
        "print ('original parameter, interpolation')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpolation permuted parameters  (p(B) --> A) : ')\n",
        "eval_dict_permuted_A_over_B = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpolation permuted parameters (p(A) --> B): ')\n",
        "eval_dict_permuted_B_over_A = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            permuted_A_fashion, model_B_fashion, \n",
        "                                            coef_vector, device=device)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 717
        },
        "id": "RTLFW4e_7B0Z",
        "outputId": "657087c8-1317-41ab-fa67-3de706e9a6c0"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1008x720 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "max_lim = max(eval_dict_non_permuted['train']) \n",
        "\n",
        "fig, axs = plt.subplots(3, figsize=(14, 10))\n",
        "fig.tight_layout(pad=5.0)\n",
        "fig.suptitle('comparison over p(A)->(B) and p(B)->(A)', fontsize=20)\n",
        "axs[1].legend(prop={'size': 15})\n",
        "\n",
        "\n",
        "axs[0].set_title('barrier original model', fontsize=15)\n",
        "axs[0].plot(coef_vector, eval_dict_non_permuted['train'],'--', marker='o', label='train', color='crimson')\n",
        "axs[0].plot(coef_vector, eval_dict_non_permuted['test'], marker='o', label='test', color='navy')\n",
        "axs[0].set_ylim([-0.5, max_lim+0.5])\n",
        "axs[0].legend(prop={'size': 15})\n",
        "axs[0].set_xlabel('interpolation coeff')\n",
        "axs[0].set_ylabel('loss')\n",
        "\n",
        "axs[1].set_title('barrier (P(B)-->(A))', fontsize=15)\n",
        "axs[1].plot(coef_vector, eval_dict_permuted_B_over_A['train'], '--', label='train', marker='o', color='darkviolet')\n",
        "axs[1].plot(coef_vector, eval_dict_permuted_B_over_A['test'], marker='o', label='test', color='limegreen')\n",
        "axs[1].set_ylim([-0.5, max_lim+0.5])\n",
        "axs[1].legend(prop={'size': 15})\n",
        "axs[1].set_xlabel('interpolation coeff')\n",
        "axs[1].set_ylabel('loss')\n",
        "\n",
        "axs[2].set_title('barrier (P(A)-->(B))',  fontsize=15)\n",
        "axs[2].plot(coef_vector, eval_dict_permuted_A_over_B['train'], '--', label='train', marker='o', color='darkorange')\n",
        "axs[2].plot(coef_vector, eval_dict_permuted_A_over_B['test'], marker='o', label='test', color='darkcyan')\n",
        "axs[2].set_ylim([-0.5, max_lim+0.5])\n",
        "axs[2].legend(prop={'size': 15})\n",
        "axs[2].set_xlabel('interpolation coeff')\n",
        "axs[2].set_ylabel('loss')\n",
        "\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TbofH0ZzUmG2"
      },
      "source": [
        "\n",
        "As can be seen from the graphs above, it makes little difference which model you choose to permute, at least in this case. The barrier will still reduce"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6axxI-c936vG"
      },
      "source": [
        "## 2d projection "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cf-lPqWjxnbJ"
      },
      "source": [
        "Creation of a Gram-Schimdt orthogonalization process.\n",
        "\\\n",
        "The goal is to plot the weights on a 2D space and see the linear connectivity. \n",
        "\\\n",
        "\\\n",
        "To do this, i define a VectorSpace class that abstracts the procedure.\n",
        "The procedure of sampling the loss landscape is pretty expensive. For this reason, I have saved a matrix (loss_grid.obj) that contains all the sample values. \n",
        "\\ Load it for a fast "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qCYHq-GD2Dfp"
      },
      "outputs": [],
      "source": [
        "# procedure\n",
        "class VectorSpace:\n",
        "\n",
        "  def __init__(self, vec1, vec2, vec3): \n",
        "    self._calc_basis(vec1, vec2, vec3)\n",
        "\n",
        "  def _calc_basis(self, vec1, vec2, vec3):\n",
        "    self.v1 = vec1\n",
        "    self.v2 = vec2\n",
        "    self.basis1 = vec2 - vec1\n",
        "    self.basis2 = vec3 - vec1\n",
        "    self.basis1_normed = self.basis1 / np.sqrt(np.sum(self.basis1**2))\n",
        "    self.basis2_normed = self.basis2 / np.sqrt(np.sum(self.basis2**2))\n",
        "    self.scale_factor = np.sqrt(np.sum(self.basis1**2))\n",
        "\n",
        "\n",
        "  def project(self, vec): # AKA vect2point ---> fix notation\n",
        "    x = np.sum((vec - self.v1)*self.basis1_normed)/self.scale_factor\n",
        "    y = np.sum((vec - self.v2)*self.basis2_normed)/self.scale_factor\n",
        "    return x, y\n",
        "\n",
        "  def convert_to_vect(self, x, y):\n",
        "    return self.v1 + (self.basis1_normed * x * self.scale_factor) +\\\n",
        "            (self.basis2_normed * y * self.scale_factor)\n",
        "#-----------------------------------------------------------\n",
        "\n",
        "def deflat_params(flatten_vect, original_shape:dict):\n",
        "  index = 0\n",
        "  new_model_dict = {}\n",
        "  for k, v in original_shape.items(): \n",
        "    if len(v)==1: \n",
        "      num_param = v[0]\n",
        "      new_model_dict[k] = flatten_vect[index:index+num_param]\n",
        "    else: \n",
        "      num_param = v[0]*v[1]\n",
        "      temp = flatten_vect[index: num_param+index]\n",
        "      new_model_dict[k] = temp.reshape(v)\n",
        "    index += num_param  \n",
        "  return new_model_dict\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_axis = np.linspace(-0.5, 1.5, 20)\n",
        "y_axis = np.linspace(-0.5, 1.5, 20)\n",
        "loss_grid = np.zeros((len(x_axis), len(y_axis)))\n",
        "\n",
        "p1 = detach_parameters(dict(model_A_mnist.named_parameters()))\n",
        "p2 = detach_parameters(dict(model_B_mnist.named_parameters()))\n",
        "p3 = detach_parameters(dict(permuted_B_mnist.named_parameters()))\n",
        "model_dict_shape = {k: v.shape for k, v in p1.items()}\n",
        "\n",
        "temp_model = MNet(mnist_input_size, bias=True)\n",
        "temp_model.to(device)\n",
        "\n",
        "v1 = np.concatenate([p1[k].reshape([-1]) for k in p1.keys()], axis=0)\n",
        "v2 = np.concatenate([p2[k].reshape([-1]) for k in p1.keys()], axis=0)\n",
        "v3 = np.concatenate([p3[k].reshape([-1]) for k in p1.keys()], axis=0)\n",
        "\n",
        "vect_space = VectorSpace(v1, v2, v3)"
      ],
      "metadata": {
        "id": "AIk67-zWqvhc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jxvqTZWcokYs"
      },
      "outputs": [],
      "source": [
        "# sample landscape\n",
        "\n",
        "for i, x in enumerate(x_axis): \n",
        "  for j, y in enumerate(y_axis): \n",
        "    flatten_param = vect_space.convert_to_vect(x, y)\n",
        "    params = deflat_params(flatten_param, model_dict_shape)\n",
        "    temp_model.load_state_dict(retach_parameters(params))\n",
        "    _, test_loss = test_loop(data_loaders['mnist'], temp_model,\n",
        "                             loss_fn, device,\n",
        "                             test_set=False, print_score=False)\n",
        "    loss_grid[i, j] = test_loss\n",
        "    \n",
        "\n",
        "file_reference = open('loss_grid.obj', 'wb')\n",
        "pickle.dump(loss_grid, file_reference)\n",
        "file_reference.close()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VbwtW54wt0DM"
      },
      "outputs": [],
      "source": [
        "#the loss_grid params require 30 min to be calc, better load it\n",
        "file_reference = open(path+'/loss_grid.obj', 'rb')\n",
        "loss_grid pickle.load(file_reference)\n",
        "file_reference.close()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f9iZFhOVwj52"
      },
      "outputs": [],
      "source": [
        "log_loss_grid = np.log(loss_grid)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "id": "pSTeCCqEoYRb",
        "outputId": "973ae1db-7abd-493f-e38d-13821f27ca1a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 936x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 600x500 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig, ax = plt.subplots(figsize=(13, 8))\n",
        "fig = plt.figure(figsize=(6, 5), dpi=100)\n",
        "fig.patch.set_facecolor('white')\n",
        "\n",
        "ax.set_title(f\"Test loss weight space cut\\n (log scale over z)\", fontsize=20)\n",
        "\n",
        "ax.contourf( x_axis,y_axis,log_loss_grid.T,\n",
        "             cmap=plt.cm.Greens_r,\n",
        "             levels=20)\n",
        "\n",
        "x_m1,y_m1 = vect_space.project(v1)\n",
        "ax.scatter([x_m1],[y_m1],marker=\"o\",color=\"red\",label=\"model A\",s=300)\n",
        "\n",
        "x_m2,y_m2 = vect_space.project(v2)\n",
        "ax.scatter([x_m2],[y_m2],marker=\"s\",color=\"blue\",label=\"model B\",s=300)\n",
        "\n",
        "x_m2_perm,y_m2_perm = vect_space.project(v3)\n",
        "ax.scatter([x_m2_perm],[y_m2_perm],marker=\"^\",color=\"aqua\",label=\"model B\\npermuted\",s=300)\n",
        "\n",
        "\n",
        "ax.plot([x_m1,x_m2_perm],[y_m1,y_m2_perm],linewidth=2,linestyle=\"--\",color=\"fuchsia\",label=\"LMC\")\n",
        "ax.plot([x_m1,x_m2],[y_m1,y_m2],linewidth=2,linestyle=\"--\",color=\"crimson\",label=\"Non LMC\")\n",
        "\n",
        "\n",
        "ax.set_xlabel(\"Weight direction 1\",fontsize = 16)\n",
        "ax.set_ylabel(\"Weight direction 2\",fontsize = 16)\n",
        "\n",
        "\n",
        "ax.legend(fontsize=20,ncol=1)\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z8_PvEXfUmG8"
      },
      "source": [
        "Very cool part: the interpolation between the original <font color='red'>model A</font> and the <font color='2be6d0'>permuted model B</font> don't result in a linear path, but in a convex path. Indeed, moving closer to the permuted model we should see a reduction in the loss function\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jcOB8AMY3a51"
      },
      "source": [
        "#depth net over Mnist, Fashion, cifar10"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The last test about model architecture and merging procedure was done with a deep version of the small net. The set of non-linear transformations doesn't help the loss landscape to converge in a single basis profile. The 3 tests run over the same dataset and the procedures are the same as before. \n",
        "\n",
        "\\\n",
        " \n",
        "The only case in which we can consider the result as useful is with the Mnist dataset. \n",
        "\\\n",
        "\n",
        "In the F_mnist and in the Cifar10 the permuted model exhibits the worst performance in the original case. A possible reason for this is given in this section.\n",
        "A possible reason about this is given in this [section](#scrollTo=zMgZpQ6ia4JU)"
      ],
      "metadata": {
        "id": "RP08FEWjr5Q2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QV_ozZNtyW2E"
      },
      "outputs": [],
      "source": [
        "model_A_mnist, model_B_mnist = DNet(mnist_input_size, bias=True), DNet(mnist_input_size, bias=True)\n",
        "model_A_fashion, model_B_fashion = DNet(mnist_input_size, bias=True), DNet(mnist_input_size, bias=True)\n",
        "model_A_cifar, model_B_cifar = DNet(cifar_input_size, bias=True), DNet(cifar_input_size, bias=True)\n",
        "\n",
        "model_A_mnist = model_A_mnist.to(device)\n",
        "model_B_mnist = model_B_mnist.to(device)\n",
        "#--------------------------------------\n",
        "model_A_fashion = model_A_fashion.to(device)\n",
        "model_B_fashion = model_B_fashion.to(device)\n",
        "#--------------------------------------\n",
        "model_A_cifar = model_A_cifar.to(device)\n",
        "model_B_cifar = model_B_cifar.to(device)\n",
        "\n",
        "# consider other loss\n",
        "loss_fn = nn.CrossEntropyLoss().to(device)\n",
        "epochs = 100\n",
        "\n",
        "optimizer_A_mnist = optim.Adam(model_A_mnist.parameters())\n",
        "optimizer_B_mnist = optim.Adam(model_B_mnist.parameters())\n",
        "#--------------------------------------\n",
        "optimizer_A_fashion = optim.Adam(model_A_fashion.parameters())\n",
        "optimizer_B_fashion = optim.Adam(model_B_fashion.parameters())\n",
        "#--------------------------------------\n",
        "optimizer_A_cifar = optim.Adam(model_A_cifar.parameters())\n",
        "optimizer_B_cifar = optim.Adam(model_B_cifar.parameters())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K9DzPgt7p_CQ"
      },
      "outputs": [],
      "source": [
        "train_target_depth = [\n",
        "    ('model_A_mnist', model_A_mnist, data_loaders['mnist']['train'], optimizer_A_mnist), \n",
        "    ('model_B_mnist', model_B_mnist, data_loaders['mnist']['train'], optimizer_B_mnist), \n",
        "\n",
        "    ('model_A_fashion', model_A_fashion, data_loaders['fashion']['train'], optimizer_A_fashion),\n",
        "    ('model_B_fashion', model_B_fashion, data_loaders['fashion']['train'], optimizer_B_fashion), \n",
        "\n",
        "    ('model_A_cifar', model_A_cifar, data_loaders['cifar']['train'], optimizer_A_cifar),\n",
        "    ('model_B_cifar', model_B_cifar, data_loaders['cifar']['train'], optimizer_B_cifar),\n",
        "              ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a4ex52swYhmN",
        "outputId": "3112db93-cc5b-4af3-d34f-3b993be4dcb9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_A_mnist', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [12:03<00:00,  7.24s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_B_mnist', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [12:00<00:00,  7.20s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_A_fashion', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [13:48<00:00,  8.28s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_B_fashion', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [15:00<00:00,  9.01s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_A_cifar', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [25:06<00:00, 15.06s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "name = 'model_B_cifar', Depth net\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 100/100 [19:38<00:00, 11.78s/it]\n"
          ]
        }
      ],
      "source": [
        "result_loss_medium = defaultdict(list)\n",
        "\n",
        "for (name, model, loader, opt) in train_target_depth: \n",
        "  scaler = GradScaler() #prevent gradient to underflow (only 16bits)\n",
        "  print(f'{name = }, Depth net')\n",
        "  for epoch in tqdm.tqdm(range(epochs)): \n",
        "    result_epoch = train_loop(loader, model, \n",
        "                              loss_fn, opt,\n",
        "                              scaler,\n",
        "                              print_score=False,\n",
        "                              return_loss=True)\n",
        "    result_loss_medium[name].append(result_epoch)\n",
        "  torch.save(model.state_dict(), f'DNet_{name}_Adam.pt')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L7qtw9NKV1MX",
        "outputId": "7ac5f33f-462a-4802-a18a-d126295ea5f2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "subpath = path+\"/DNet/\"\n",
        "model_A_mnist.load_state_dict(torch.load(subpath+'DNet_model_A_mnist_Adam.pt', map_location=device))\n",
        "model_B_mnist.load_state_dict(torch.load(subpath+'DNet_model_B_mnist_Adam.pt', map_location=device))\n",
        "\n",
        "model_A_fashion.load_state_dict(torch.load(subpath+'DNet_model_A_fashion_Adam.pt', map_location=device))\n",
        "model_B_fashion.load_state_dict(torch.load(subpath+'DNet_model_B_fashion_Adam.pt',map_location=device))\n",
        "\n",
        "model_A_cifar.load_state_dict(torch.load(subpath+'DNet_model_A_cifar_Adam.pt', map_location=device))\n",
        "model_B_cifar.load_state_dict(torch.load(subpath+'DNet_model_B_cifar_Adam.pt', map_location=device))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nr_kgvuhYqNp"
      },
      "source": [
        "##mnist"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V3kJXGzbYqNr",
        "outputId": "293eee22-bfbd-4f4f-fd33-2f7c6f77871b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 97.7%, Avg loss: 0.140404 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 89.5%, Avg loss: 0.317563 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], model_A_mnist, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['mnist'], model_B_mnist, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NGof33PCYqNs",
        "outputId": "1ea09f64-db48-4a08-c3bc-6a5e28d09f38"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 79.6%, Avg loss: 0.809347 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.1404  | 97.730\n",
            "   1  | 0.11 |   0.1509  | 97.500\n",
            "   2  | 0.22 |   1.0886  | 94.480\n",
            "   3  | 0.33 |   2.0188  | 48.760\n",
            "   4  | 0.44 |   2.2768  | 10.280\n",
            "   5  | 0.56 |   2.2253  | 23.890\n",
            "   6  | 0.67 |   2.0027  | 33.140\n",
            "   7  | 0.78 |   1.2603  | 86.460\n",
            "   8  | 0.89 |   0.3410  | 89.450\n",
            "   9  | 1.00 |   0.3176  | 89.510\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   0.1404  | 97.730\n",
            "   1  | 0.11 |   0.1165  | 97.720\n",
            "   2  | 0.22 |   0.1049  | 97.700\n",
            "   3  | 0.33 |   0.1106  | 97.640\n",
            "   4  | 0.44 |   0.1485  | 97.590\n",
            "   5  | 0.56 |   0.2539  | 97.380\n",
            "   6  | 0.67 |   0.4448  | 96.910\n",
            "   7  | 0.78 |   0.6686  | 95.020\n",
            "   8  | 0.89 |   0.8051  | 75.910\n",
            "   9  | 1.00 |   0.8093  | 79.560\n"
          ]
        }
      ],
      "source": [
        "permuted_B_mnist = git_merge(model_A_mnist, model_B_mnist, silent=True)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['mnist'], permuted_B_mnist, loss_fn, test_set=True, device=device)\n",
        "\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['mnist'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_mnist, model_B_mnist,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['mnist'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_mnist, permuted_B_mnist, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "V8K-QqrDYqNt",
        "outputId": "cbba3fa5-588e-4bd5-8366-557f3bcd2ef6"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'mnist MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iPskrDChZuWs"
      },
      "source": [
        "## fashion\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jjRoIBlPZuWx",
        "outputId": "4ce97603-9425-4379-85ee-8494a513d923"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 71.2%, Avg loss: 1.043689 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 79.0%, Avg loss: 0.963108 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['fashion'], model_A_fashion, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['fashion'], model_B_fashion, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sqt0AOyxZuW2",
        "outputId": "d1a4da57-8f67-4b1e-c61a-3a4e27016804"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 34.0%, Avg loss: 1.937755 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   1.0437  | 71.210\n",
            "   1  | 0.11 |   0.8691  | 68.870\n",
            "   2  | 0.22 |   1.4788  | 61.980\n",
            "   3  | 0.33 |   2.1999  | 39.420\n",
            "   4  | 0.44 |   2.3001  | 12.740\n",
            "   5  | 0.56 |   2.2736  | 15.200\n",
            "   6  | 0.67 |   2.0904  | 39.610\n",
            "   7  | 0.78 |   1.3618  | 71.680\n",
            "   8  | 0.89 |   0.8393  | 77.270\n",
            "   9  | 1.00 |   0.9631  | 78.950\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   1.0437  | 71.210\n",
            "   1  | 0.11 |   0.9023  | 71.120\n",
            "   2  | 0.22 |   0.8358  | 70.730\n",
            "   3  | 0.33 |   0.8434  | 69.940\n",
            "   4  | 0.44 |   0.9337  | 68.610\n",
            "   5  | 0.56 |   1.1154  | 66.590\n",
            "   6  | 0.67 |   1.3627  | 61.870\n",
            "   7  | 0.78 |   1.6073  | 52.380\n",
            "   8  | 0.89 |   1.8384  | 40.600\n",
            "   9  | 1.00 |   1.9378  | 33.980\n"
          ]
        }
      ],
      "source": [
        "permuted_B_fashion = git_merge(model_A_fashion, model_B_fashion, silent=True)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['fashion'], permuted_B_fashion, loss_fn, test_set=True, device=device)\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "WMvnxuRiZuW7",
        "outputId": "03ea15f4-711b-496f-afe2-94e05cba3b8b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'fashion MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cDrpq7SVZ-nP"
      },
      "source": [
        "##cifar"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "07BlrAjkZ-nR",
        "outputId": "1193f9ab-9b00-404e-fd5f-d8bf988630c3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 45.3%, Avg loss: 1.313538 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 85.5%, Avg loss: 0.365249 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['cifar'], model_A_cifar, loss_fn, test_set=True, device=device)\n",
        "test_loop(data_loaders['cifar'], model_B_cifar, loss_fn, test_set=True, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xn89yLzLZ-nT",
        "outputId": "5cfa0c0d-0a1d-4406-f11b-fd10969defc0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Permuted model performance: \n",
            "Eval on test: \n",
            " Accuracy: 34.2%, Avg loss: 1.998769 \n",
            "\n",
            "evaluate interpolation original parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   1.0437  | 71.210\n",
            "   1  | 0.11 |   0.8691  | 68.870\n",
            "   2  | 0.22 |   1.4788  | 61.980\n",
            "   3  | 0.33 |   2.1999  | 39.420\n",
            "   4  | 0.44 |   2.3001  | 12.740\n",
            "   5  | 0.56 |   2.2736  | 15.200\n",
            "   6  | 0.67 |   2.0904  | 39.610\n",
            "   7  | 0.78 |   1.3618  | 71.680\n",
            "   8  | 0.89 |   0.8393  | 77.270\n",
            "   9  | 1.00 |   0.9631  | 78.950\n",
            "\n",
            "evaluate interpoalitoin permuted parameters: \n",
            "index | coef | test loss | test_acc\n",
            "   0  | 0.00 |   1.0437  | 71.210\n",
            "   1  | 0.11 |   0.9033  | 71.120\n",
            "   2  | 0.22 |   0.8367  | 70.690\n",
            "   3  | 0.33 |   0.8356  | 69.720\n",
            "   4  | 0.44 |   0.9243  | 68.660\n",
            "   5  | 0.56 |   1.1408  | 66.350\n",
            "   6  | 0.67 |   1.4187  | 57.370\n",
            "   7  | 0.78 |   1.6921  | 51.590\n",
            "   8  | 0.89 |   1.9249  | 42.980\n",
            "   9  | 1.00 |   1.9988  | 34.230\n"
          ]
        }
      ],
      "source": [
        "permuted_B_fashion = git_merge(model_A_fashion, model_B_fashion, silent=True)\n",
        "print('Permuted model performance: ')\n",
        "test_loop(data_loaders['fashion'], permuted_B_fashion, loss_fn, test_set=True, device=device)\n",
        "print('evaluate interpolation original parameters: ')\n",
        "eval_dict_non_permuted = evaluate_interpolation(data_loaders['fashion'], \n",
        "                                                loss_fn,\n",
        "                                                model_A_fashion, model_B_fashion,\n",
        "                                                coef_vector, device=device)\n",
        "\n",
        "print('\\nevaluate interpoalitoin permuted parameters: ')\n",
        "eval_dict_permuted = evaluate_interpolation(data_loaders['fashion'],\n",
        "                                            loss_fn,\n",
        "                                            model_A_fashion, permuted_B_fashion, \n",
        "                                            coef_vector, device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "id": "LMzq5W0zZ-nW",
        "outputId": "10cf5548-72bb-4534-8158-1a96d2d57e20"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_barrier(eval_dict_non_permuted, eval_dict_permuted, coef_vector, 'cifar MNet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zMgZpQ6ia4JU"
      },
      "source": [
        "## possible cause of low performance over depth network : variance collapse"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "snv3t-nvcA8S"
      },
      "source": [
        "in [Repair, by jordan et. al 2023](https://arxiv.org/abs/2211.08403) it's show that the variance of activations progressively decays as we move deeper into the network, with the activations of later layers becoming nearly constant. As in the original paper, I measure the variance of each activation of each neuron, across a constant batch of training data.\n",
        "\n",
        "The procedure for quantify the variance collapse:\n",
        "- measure the variance across each neuron for each layer\n",
        "- sum this variance --> $v\\alpha, v1, v2$ for the interpolated net, and for the two original\n",
        "- compute the ratio ($v\\alpha) / ((v1 + v2)/2 $)\n",
        "- report this in the final plot\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ft5icvoEa3cH"
      },
      "outputs": [],
      "source": [
        "def measure_variance_across_activation(model, sample): #repair problem\n",
        "  activation = {}\n",
        "\n",
        "  def getActivation(name):\n",
        "    def hook(mode, input, output): \n",
        "      activation[name] = output.detach()\n",
        "    return hook \n",
        "\n",
        "  for name, module in model.named_children(): \n",
        "    hook = module.register_forward_hook(getActivation(name))\n",
        "    out = model(sample)\n",
        "    hook.remove()\n",
        "\n",
        "  activation = {k: v.numpy() for k, v in activation.items()}\n",
        "  var_for_layer = {k: np.sum(np.sum(np.var(v, axis=1))) for k, v in activation.items()}\n",
        "  return var_for_layer\n",
        "\n",
        "\n",
        "sample = next(iter(data_loaders['mnist']['train']))[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TggySPwDTsyN",
        "outputId": "d905a3bc-27ae-4303-82f4-310c14189dcd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'dense1': 2022.6581,\n",
              " 'dense2': 3517.4548,\n",
              " 'dense3': 33513.91,\n",
              " 'dense4': 125708.3,\n",
              " 'dense5': 271178.78,\n",
              " 'dense6': 496056.66,\n",
              " 'dense7': 336495.94,\n",
              " 'dense8': 117268.164}"
            ]
          },
          "execution_count": 106,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var_model_A = measure_variance_across_activation(model_A_mnist, sample)\n",
        "var_model_A"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xNQwkU8RSEBP",
        "outputId": "1913cf04-8dca-4c70-acc4-208a16b5f9ca"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'dense1': 2138.149,\n",
              " 'dense2': 4075.8489,\n",
              " 'dense3': 41715.38,\n",
              " 'dense4': 194910.89,\n",
              " 'dense5': 565542.5,\n",
              " 'dense6': 903671.7,\n",
              " 'dense7': 369039.34,\n",
              " 'dense8': 172259.83}"
            ]
          },
          "execution_count": 109,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var_model_B = measure_variance_across_activation(model_B_mnist, sample)\n",
        "var_model_B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lAGmaNMISkeK",
        "outputId": "b990e410-2a75-4755-a520-2a14b93d58a8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'dense1': 1623.1292,\n",
              " 'dense2': 1861.0361,\n",
              " 'dense3': 15333.227,\n",
              " 'dense4': 44236.8,\n",
              " 'dense5': 59791.76,\n",
              " 'dense6': 47597.176,\n",
              " 'dense7': 11345.734,\n",
              " 'dense8': 3158.354}"
            ]
          },
          "execution_count": 111,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var_model_B_perm = measure_variance_across_activation(git_merge(model_A_mnist, model_B_mnist, silent=True), sample)\n",
        "var_model_B_perm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a4l108wvUro_",
        "outputId": "2c55fd8e-1933-4704-807b-0ba0cd6b06fc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'dense1': 0.7801991777577523,\n",
              " 'dense2': 0.49017824221408074,\n",
              " 'dense3': 0.40763981033401114,\n",
              " 'dense4': 0.2759460600357862,\n",
              " 'dense5': 0.14291919015741503,\n",
              " 'dense6': 0.06800916039335132,\n",
              " 'dense7': 0.03216206241998539,\n",
              " 'dense8': 0.021817261224518873}"
            ]
          },
          "execution_count": 112,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ratio = {}\n",
        "for k in var_model_A.keys():\n",
        "  ratio[k] = var_model_B_perm[k]/ ((var_model_A[k] + var_model_B[k])/2)\n",
        "ratio"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zSvTKN9BXCyo",
        "outputId": "fa6e36f9-d461-4f06-b543-a07a0a09c07a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[0.7801991777577523,\n",
              " 0.49017824221408074,\n",
              " 0.40763981033401114,\n",
              " 0.2759460600357862,\n",
              " 0.14291919015741503,\n",
              " 0.06800916039335132,\n",
              " 0.03216206241998539,\n",
              " 0.021817261224518873]"
            ]
          },
          "execution_count": 119,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ratio_list = [v for k, v in ratio.items()]\n",
        "ratio_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "EjbBe7HqDoE9",
        "outputId": "0a816f45-804c-4a00-b108-4093a8a72107"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(ratio_list, marker='o')\n",
        "plt.title('variance decay', fontsize=15)\n",
        "plt.xlabel('layer index', fontsize=12)\n",
        "plt.ylabel('var ratio across a batch', fontsize=12)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aHriP1cyUmHG"
      },
      "source": [
        "The obtained result here are consistent with the original plot from the [paper](https://arxiv.org/abs/2211.08403)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XnZVLHZE3pDV"
      },
      "source": [
        "# Multiple Merge"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AhtESsCyzBk-"
      },
      "source": [
        "## split dataset for unbalance sub-datasets\n",
        "To test the capacity of merging different trainset (so different model) and simulate a federal learning setting, i choose to extract some unbalance subset form the original dataset, then train different model and try to interpolate after the permutation procedure"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VvS80PXq4UuG",
        "outputId": "e24c6a84-1506-4edb-b0b8-17671e498698"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "60000"
            ]
          },
          "execution_count": 66,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(experiment_data['MNIST']['train'])\n",
        "# 60.000 sample, 6.000 for classes\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZMVqO-1ugzJr"
      },
      "outputs": [],
      "source": [
        "# select index of each class, extract 800 sample\n",
        "# lo [0] a fine istruzione serve perchè l'istruzione ritorna una tupla di len=1\n",
        "sample_to_remove = 800\n",
        "indeces_for_class_800_sample_MNIST_train = [\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 0))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 1))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 2))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 3))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 4))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 5))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 6))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 7))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 8))[0][:sample_to_remove],\n",
        "    np.where((np.array(experiment_data['MNIST']['train'].targets) == 9))[0][:sample_to_remove],\n",
        "]\n",
        "\n",
        "total_indeces_used = np.concatenate(indeces_for_class_800_sample_MNIST_train, axis=0)\n",
        "original_indeces = np.arange(0, len(experiment_data['MNIST']['train'])) \n",
        "remain_indeces = [i for i in original_indeces if i not in total_indeces_used]\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_CJMerZP5Aw6",
        "outputId": "509878db-e512-4ad5-ff40-327eec4b1cfb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "52000"
            ]
          },
          "execution_count": 75,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(remain_indeces)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xX5ySH5Im2zI"
      },
      "outputs": [],
      "source": [
        "# shuffle the data for create 6 unbalance dataset, where each dataset has a maximum of 3 main classes\n",
        "\n",
        "unbalance_data_idx = []\n",
        "for i in range(6):\n",
        "  unbalance_data_idx.append(\n",
        "      [indeces_for_class_800_sample_MNIST_train[i] for i in \n",
        "      [random.randint(0, 9) for _ in range(3)]\n",
        "      ]\n",
        "  )\n",
        "  unbalance_data_idx[i] = np.concatenate(unbalance_data_idx[i], axis=0)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MoKdkfEXwwjg",
        "outputId": "6b1fc3ad-3bae-4ee5-c845-a032c0b09cc0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8666"
            ]
          },
          "execution_count": 69,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(remain_indeces)//6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RgRr5UxMq4-T",
        "outputId": "a49a6264-7dba-48a1-b3bc-ae1f6fa31b3d"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "<ipython-input-92-98d7a639060b>:4: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  split_indices = np.array(split_indices)\n"
          ]
        }
      ],
      "source": [
        "# Add remain sample from the original dataset\n",
        "len_extra_data_for_dataset = len(remain_indeces)//6\n",
        "shuffled_indices = np.random.permutation(remain_indeces)\n",
        "split_indices = np.array_split(shuffled_indices, np.ceil(len(remain_indeces)/len_extra_data_for_dataset))\n",
        "split_indices = np.array(split_indices)\n",
        "unbalance_data_idx = [np.concatenate((unbalance_data_idx[i], split_indices[i])) for i in range(len(unbalance_data_idx))]\n",
        "\n",
        "# create list od dataset\n",
        "dataset_unbalance = [torch.utils.data.Subset(experiment_data['MNIST']['train'],\n",
        "                                              unbalance_data_idx[i]) for i in range(len(unbalance_data_idx))]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TgMC8sZlvcWF",
        "outputId": "3f0960d9-c1e5-41da-b348-7e3da2ce82ee"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{0: <torch.utils.data.dataset.Subset at 0x7f4b415be910>,\n",
              " 1: <torch.utils.data.dataset.Subset at 0x7f4b41538fa0>,\n",
              " 2: <torch.utils.data.dataset.Subset at 0x7f4b4a0bb0a0>,\n",
              " 3: <torch.utils.data.dataset.Subset at 0x7f4b42069340>,\n",
              " 4: <torch.utils.data.dataset.Subset at 0x7f4b4a0ac1f0>,\n",
              " 5: <torch.utils.data.dataset.Subset at 0x7f4b4a0ac100>}"
            ]
          },
          "execution_count": 78,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "dataset_unbalance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "CNswHZEewSg7",
        "outputId": "a9ac2c29-8758-4b72-b8ab-eec6b1ea1314"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "#plot distribution of a random subdataset\n",
        "class_counts = torch.zeros(10)\n",
        "for example in dataset_unbalance[2]:\n",
        "  class_counts[example[1]] += 1\n",
        "\n",
        "\n",
        "plt.bar(range(10), class_counts)\n",
        "plt.xlabel('Class label')\n",
        "plt.ylabel('Number of occurrences')\n",
        "plt.title('Class distribution for generic unbalance dataset')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tNlXMZgNziN8"
      },
      "outputs": [],
      "source": [
        "#create dataloader\n",
        "data_loaders_unbalance = {i: DataLoader(dataset_unbalance[i], \n",
        "                                        batch_size=124, \n",
        "                                        shuffle=True) for i in range(len(dataset_unbalance))}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NfZDkoHczF5u"
      },
      "source": [
        "## Training 6 models default params\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9uM9QLiremU2"
      },
      "outputs": [],
      "source": [
        "#define 6 model\n",
        "num_models = 6\n",
        "epochs = 100 #100 by default, but low performance\n",
        "models = [MNet(input_size=mnist_input_size, bias=True) for i in range(num_models)]\n",
        "models = [models[i].to(device) for i in range(num_models)]\n",
        "opts = [optim.Adam(models[i].parameters()) for i in range(num_models)]\n",
        "loss_fn = nn.CrossEntropyLoss().to(device)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lMXGXgutB-0B"
      },
      "outputs": [],
      "source": [
        "#train each model on a different dataset\n",
        "for id in range(1): \n",
        "  for epoch in tqdm.tqdm(range(epochs)): \n",
        "    scaler = GradScaler() \n",
        "    train_loop(data_loaders_unbalance[id], models[id], \n",
        "               loss_fn, opts[id], \n",
        "               scaler,\n",
        "               print_score=False, \n",
        "               return_loss=False)\n",
        "  torch.save(models[id].state_dict(), f'MNet_unbalance_Adam_1e-4_mnist_{id}.pt')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AESuDqTPOH8n"
      },
      "outputs": [],
      "source": [
        "# or load the models\n",
        "subpath = path+'/unbalance/mnist/adam_-4/'\n",
        "for i in range(len(models)):\n",
        "  models[i].load_state_dict(torch.load(subpath + f'MNet_unbalance_Adam_1e-4_mnist_{i}.pt'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5RUmqDzCMIxh"
      },
      "source": [
        "## Eval models over unbalance data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KWPz_epLzNkr",
        "outputId": "1bf2b825-1ea9-4468-b7cd-d097bc24508f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on train: \n",
            " Accuracy: 95.5%, Avg loss: 0.308483 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 95.9%, Avg loss: 0.257431 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 95.8%, Avg loss: 0.280003 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 95.9%, Avg loss: 0.280224 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 95.7%, Avg loss: 0.302238 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 95.8%, Avg loss: 0.270182 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "[test_loop(data_loaders['mnist'], models[i], loss_fn, device, test_set=False) for i in range(num_models)];"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y_cTZ6ngBxXG",
        "outputId": "7f004bd4-2a2f-4dbd-9923-2a0e95412dde"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 95.2%, Avg loss: 0.338789 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 95.4%, Avg loss: 0.280903 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 95.6%, Avg loss: 0.285759 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 95.4%, Avg loss: 0.316844 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 95.4%, Avg loss: 0.295238 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 95.2%, Avg loss: 0.312307 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "[test_loop(data_loaders['mnist'], models[i], loss_fn, device, test_set=True) for i in range(num_models)];"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Average all the models return a ~50% less in the accuracy score"
      ],
      "metadata": {
        "id": "XkfJArUwu-NB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rV9f6otNKFpL",
        "outputId": "933c9168-a317-4e29-c898-282909725470"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on train: \n",
            " Accuracy: 52.5%, Avg loss: 12.244119 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], average_multiple_model(models), loss_fn, device, test_set=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hgfSJVx7EoqJ"
      },
      "source": [
        "## multiple merge [paper style]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2nbZg-Wua8Sn"
      },
      "source": [
        "<h3>Problem :</h3>\n",
        "The interpolation of several models strongly depends of the order of the model selected for the permutation. Sometimes i get a \"good\" test accuracy (92%) but more often i get a result near to 10% (random guess). The convergence comes after ~70 epochs but the loss grows up to infinity. For this reason, I have inserted a parameter that allows me to manually control the number of iterations. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zdeHrZs_F1UZ",
        "outputId": "f0285751-52ce-4d02-f8c7-a8aa4a8e0226"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GIT MERGE OVER 6 MODELS\n",
            "sub_run:0 |P(model3)| similarity_gain: 0.829 | progress: True\n",
            "sub_run:0 |P(model5)| similarity_gain: 0.839 | progress: True\n",
            "sub_run:0 |P(model4)| similarity_gain: 0.842 | progress: True\n",
            "sub_run:0 |P(model1)| similarity_gain: 0.847 | progress: True\n",
            "sub_run:0 |P(model0)| similarity_gain: 0.098 | progress: True\n",
            "sub_run:0 |P(model2)| similarity_gain: 0.78 | progress: True\n",
            "Eval on test: \n",
            " Accuracy: 92.8%, Avg loss: 40.298571 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 92.8%, Avg loss: 38.127755 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "model_merge_many = git_merge_many(copy.deepcopy(models), runs=1, digit=3)\n",
        "test_loop(data_loaders['mnist'], model_merge_many, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], model_merge_many, loss_fn, device, test_set=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TwSJU4DCMWWv"
      },
      "source": [
        "## multiple merge [permutation tree]\n",
        "\n",
        "between models to be ineffective, since the paper itself presents a counterexample to the single basin assumptions, I tried a series of permutations between the trailed models, hoping that by thinking of the permutations as the nodes of a binary tree, I could arrive at the root with a model with knowledge of all the data and with the same accuracy.\n",
        "My methods show a more stable behaviour but cannot compete with the result of the original paper (not the result that i get, i refer to the value that they get with their implementation) \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I4TBEPoQ9jC5"
      },
      "outputs": [],
      "source": [
        "m20 = git_merge(models[2], models[0], silent=True)\n",
        "m21 = git_merge(models[2], models[1], silent=True) \n",
        "m34 = git_merge(models[3], models[4], silent=True) \n",
        "m35 = git_merge(models[3], models[5], silent=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QdAl7F9G-VGH",
        "outputId": "10364e79-b4c8-4375-d82f-129cd5a17489"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 94.7%, Avg loss: 0.282427 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 94.8%, Avg loss: 0.248760 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 94.7%, Avg loss: 0.283735 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 91.0%, Avg loss: 0.400418 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], m20, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], m21, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], m34, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], m35, loss_fn, device, test_set=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "brxYV97u-mny"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "m012 = git_merge(m20, m21)\n",
        "m345 = git_merge(m34, m35)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w4iMMAK2-8JU",
        "outputId": "5614074e-bd43-4d6d-ad00-7dac5a7890c8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 94.3%, Avg loss: 0.266127 \n",
            "\n",
            "Eval on test: \n",
            " Accuracy: 93.6%, Avg loss: 0.296358 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], m012, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], m345, loss_fn, device, test_set=True)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2cKECxGG_I5K"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "mf = git_merge(m012, m345)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GpHsmo6fCKfS",
        "outputId": "4fd919f6-df1e-4d96-ed5a-9b446054cda8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eval on test: \n",
            " Accuracy: 91.5%, Avg loss: 0.341380 \n",
            "\n",
            "Eval on train: \n",
            " Accuracy: 91.6%, Avg loss: 0.331427 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "test_loop(data_loaders['mnist'], mf, loss_fn, device, test_set=True)\n",
        "test_loop(data_loaders['mnist'], mf, loss_fn, device, test_set=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5jujEc-HdKZd"
      },
      "source": [
        "\n",
        "Interestingly, the loss does not decrease, and the accuracy loses a few points, almost as if there is no linear path connecting all the subpoints.\n",
        "\n",
        "However, I also noticed that the selection of the permutation order of the models is a key parameter in achieving convergence or non-convergence of the procedure.\n",
        "\n",
        "<h3> Future work </h3>\n",
        "A possible improvement to this approach might consider the distance between two models to select which ones to permute, hoping that similar models can be joined first, to reduce noise and disturbance in the procedure."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "7VaYL9GN3w7Y",
        "1Xbwbv6S2e83",
        "jtNo5HyD2e_a",
        "QtAH5cus3Isu",
        "MgDTEfjf3TU_",
        "QBlypHTzjg52",
        "uXTc_HGmkENP",
        "CrBj5um3apLE",
        "fjB-UKJ0aJkQ",
        "jcOB8AMY3a51",
        "nr_kgvuhYqNp",
        "iPskrDChZuWs",
        "cDrpq7SVZ-nP",
        "zMgZpQ6ia4JU",
        "AhtESsCyzBk-",
        "5RUmqDzCMIxh"
      ],
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}