├── README.md ├── mmd_gan_2D_toy.ipynb └── mixture_regression_toy.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Minimum implementation of generative modeling algorithms on toys 2 | -------------------------------------------------------------------------------- /mmd_gan_2D_toy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "authorship_tag": "ABX9TyN8HrbWD4M/SV9fUN/7hhJU", 8 | "include_colab_link": true 9 | }, 10 | "kernelspec": { 11 | "name": "python3", 12 | "display_name": "Python 3" 13 | }, 14 | "language_info": { 15 | "name": "python" 16 | } 17 | }, 18 | "cells": [ 19 | { 20 | "cell_type": "markdown", 21 | "metadata": { 22 | "id": "view-in-github", 23 | "colab_type": "text" 24 | }, 25 | "source": [ 26 | "\"Open" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "source": [ 32 | "import torch\n", 33 | "import torch.nn as nn\n", 34 | "import torch.optim as optim\n", 35 | "import numpy as np\n", 36 | "import matplotlib.pyplot as plt\n", 37 | "from torch.utils.data import DataLoader, TensorDataset\n", 38 | "\n", 39 | "# MLP\n", 40 | "class MLP(nn.Module):\n", 41 | " def __init__(self, layer_sizes, activation=nn.ReLU, linear_layer=nn.Linear):\n", 42 | " super(MLP, self).__init__()\n", 43 | " self.layers = nn.ModuleList()\n", 44 | " self.activation = activation\n", 45 | " self.linear_layer = linear_layer\n", 46 | " for i in range(len(layer_sizes) - 1):\n", 47 | " self.layers.append(self.linear_layer(layer_sizes[i], layer_sizes[i + 1]))\n", 48 | " if i < len(layer_sizes) - 2: # No activation after the last layer\n", 49 | " self.layers.append(self.activation())\n", 50 | "\n", 51 | " def forward(self, x):\n", 52 | " x = x.view(x.shape[0], -1)\n", 53 | " for layer in self.layers:\n", 54 | " x = layer(x)\n", 55 | " return x\n", 56 | "\n", 57 | "# Define the 2D Toy Dataset\n", 58 | "def sample_gmm(batch_size, num_modes=4, std=0.02):\n", 59 | " centers = torch.tensor([[1, 0], [-1, 0], [0, 1], [0, -1]], dtype=torch.float32)\n", 60 | " centers = centers[:num_modes]\n", 61 | "\n", 62 | " batch_data = []\n", 63 | " for _ in range(batch_size):\n", 64 | " center = centers[torch.randint(0, len(centers), (1,)).item()]\n", 65 | " point = center + torch.randn_like(center) * std\n", 66 | " batch_data.append(point)\n", 67 | "\n", 68 | " return torch.stack(batch_data)\n", 69 | "\n", 70 | "# Visualize the data\n", 71 | "data_points = sample_gmm(1000)\n", 72 | "plt.figure(figsize=(3,3))\n", 73 | "plt.scatter(data_points[:, 0], data_points[:, 1], alpha=0.5)\n", 74 | "plt.title('Real Data Distribution')\n", 75 | "plt.show()\n", 76 | "\n" 77 | ], 78 | "metadata": { 79 | "colab": { 80 | "base_uri": "https://localhost:8080/", 81 | "height": 314 82 | }, 83 | "id": "A488u_4tTkh5", 84 | "outputId": "e7f31080-b8e0-4046-e68d-f3be864c1518" 85 | }, 86 | "execution_count": 24, 87 | "outputs": [ 88 | { 89 | "output_type": "display_data", 90 | "data": { 91 | "text/plain": [ 92 | "
" 93 | ], 94 | "image/png": "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\n" 95 | }, 96 | "metadata": {} 97 | } 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "source": [ 103 | "#@title Distances\n", 104 | "\n", 105 | "def kernel_mmd(x, y, kernel='rbf', bandwidth = -1):\n", 106 | " \"\"\"Compute the MMD distance between two datasets x and y.\"\"\"\n", 107 | " #https://en.wikipedia.org/wiki/Kernel_embedding_of_distributions#Measuring_distance_between_distributions\n", 108 | "\n", 109 | " xx, yy, xy = x @ x.t(), y @ y.t(), x @ y.t()\n", 110 | " rx = (xx.diag().unsqueeze(0).expand_as(xx))\n", 111 | " ry = (yy.diag().unsqueeze(0).expand_as(yy))\n", 112 | "\n", 113 | " dxx = rx.t() + rx - 2*xx\n", 114 | " dyy = ry.t() + ry - 2*yy\n", 115 | " dxy = rx.t() + ry - 2*xy\n", 116 | "\n", 117 | " if kernel == 'rbf':\n", 118 | " if bandwidth<0:\n", 119 | " scale = -bandwidth * (dxy.median().detach())\n", 120 | " else:\n", 121 | " scale = bandwidth\n", 122 | " Kxx = torch.exp(-dxx / scale)\n", 123 | " Kyy = torch.exp(-dyy / scale)\n", 124 | " Kxy = torch.exp(-dxy / scale)\n", 125 | " else:\n", 126 | " raise NotImplementedError\n", 127 | "\n", 128 | " return Kxx.mean() + Kyy.mean() - 2 * Kxy.mean()\n", 129 | "\n", 130 | "\n", 131 | "def energy_distance(x, y, p=1, eps = 1e-6):\n", 132 | " \"\"\"Compute the energy distance between two datasets x and y.\"\"\"\n", 133 | " #https://en.wikipedia.org/wiki/Energy_distance\n", 134 | " xx, yy, xy = x @ x.t(), y @ y.t(), x @ y.t()\n", 135 | " rx = (xx.diag().unsqueeze(0).expand_as(xx))\n", 136 | " ry = (yy.diag().unsqueeze(0).expand_as(yy))\n", 137 | "\n", 138 | " dxx = rx.t() + rx - 2*xx\n", 139 | " dyy = ry.t() + ry - 2*yy\n", 140 | " dxy = rx.t() + ry - 2*xy\n", 141 | "\n", 142 | " return 2 * (dxy+eps).pow(p/2).mean() - (dxx+eps).pow(p/2).mean() - (dyy+eps).pow(p/2).mean()\n", 143 | "\n", 144 | "\n", 145 | "x = torch.randn(100, 2)\n", 146 | "y = torch.randn(100, 2)\n", 147 | "dist = kernel_mmd(x,y)\n", 148 | "print(dist)\n", 149 | "dist = energy_distance(x,y)\n", 150 | "print(dist)" 151 | ], 152 | "metadata": { 153 | "colab": { 154 | "base_uri": "https://localhost:8080/" 155 | }, 156 | "id": "ERRsAKTGUArU", 157 | "outputId": "73fc1a54-45f0-4b8a-9001-357cad91ef2d" 158 | }, 159 | "execution_count": 25, 160 | "outputs": [ 161 | { 162 | "output_type": "stream", 163 | "name": "stdout", 164 | "text": [ 165 | "tensor(0.0145)\n", 166 | "tensor(0.0480)\n" 167 | ] 168 | } 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "source": [ 174 | "#@title Training\n", 175 | "import torch\n", 176 | "import torch.nn as nn\n", 177 | "import torch.optim as optim\n", 178 | "import numpy as np\n", 179 | "import matplotlib.pyplot as plt\n", 180 | "from IPython.display import clear_output\n", 181 | "\n", 182 | "\n", 183 | "noise_dim = data_dim = 2\n", 184 | "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", 185 | "generator = MLP([noise_dim, 128,128, 128, data_dim]).to(device)\n", 186 | "generator.sample = lambda num_samples: generator(torch.randn(num_samples, noise_dim).to(device))\n", 187 | "optimizer = optim.Adam(generator.parameters(), lr=1e-3)\n", 188 | "batch_size = 256\n", 189 | "\n", 190 | "loss_curve = []\n", 191 | "for iter in range(1000):\n", 192 | "\n", 193 | " optimizer.zero_grad()\n", 194 | "\n", 195 | " # data batch\n", 196 | " real_data = data_points[torch.randperm(data_points.shape[0])[:batch_size]].to(device)\n", 197 | " fake_data = generator.sample(batch_size)\n", 198 | "\n", 199 | " loss = kernel_mmd(real_data, fake_data, bandwidth = .1)\n", 200 | " #loss = energy_distance(real_data, fake_data, p = 1)\n", 201 | "\n", 202 | " loss.backward()\n", 203 | " optimizer.step()\n", 204 | " loss_curve.append(loss.item())\n", 205 | "\n", 206 | " if iter % 100 == 0:\n", 207 | " clear_output(wait=True)\n", 208 | "\n", 209 | " plt.figure(figsize=(2*3, 3))\n", 210 | "\n", 211 | " plt.subplot(1, 2, 1)\n", 212 | " plt.plot(loss_curve)\n", 213 | "\n", 214 | " plt.subplot(1, 2, 2)\n", 215 | " generated_data = generator.sample(data_points.shape[0]).detach().cpu().numpy()\n", 216 | " plt.scatter(generated_data[:, 0], generated_data[:, 1], alpha=0.5, color='red', label='Generated Data')\n", 217 | " plt.scatter(data_points[:, 0], data_points[:, 1], alpha=0.5, color='blue', label='Real Data')\n", 218 | " plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", 219 | "\n", 220 | " plt.suptitle(f\"Iteration {iter}, Loss: {loss.item()}\")\n", 221 | " plt.show()\n", 222 | "\n" 223 | ], 224 | "metadata": { 225 | "colab": { 226 | "base_uri": "https://localhost:8080/", 227 | "height": 321 228 | }, 229 | "id": "Hma_i3b9UQZp", 230 | "outputId": "f8f37a26-e58f-4747-cc32-5d9aab21ae10" 231 | }, 232 | "execution_count": 26, 233 | "outputs": [ 234 | { 235 | "output_type": "display_data", 236 | "data": { 237 | "text/plain": [ 238 | "
" 239 | ], 240 | "image/png": "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\n" 241 | }, 242 | "metadata": {} 243 | } 244 | ] 245 | } 246 | ] 247 | } -------------------------------------------------------------------------------- /mixture_regression_toy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "provenance": [], 7 | "toc_visible": true, 8 | "authorship_tag": "ABX9TyOUNCSwyi13Rn5zETO/p7LG", 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "language_info": { 16 | "name": "python" 17 | } 18 | }, 19 | "cells": [ 20 | { 21 | "cell_type": "markdown", 22 | "metadata": { 23 | "id": "view-in-github", 24 | "colab_type": "text" 25 | }, 26 | "source": [ 27 | "\"Open" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": { 34 | "colab": { 35 | "base_uri": "https://localhost:8080/", 36 | "height": 449 37 | }, 38 | "id": "YFAYulXThS6T", 39 | "outputId": "ccd39b2c-56cc-484c-86d3-770fa845cd8b" 40 | }, 41 | "outputs": [ 42 | { 43 | "output_type": "display_data", 44 | "data": { 45 | "text/plain": [ 46 | "
" 47 | ], 48 | "image/png": "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\n" 49 | }, 50 | "metadata": {} 51 | } 52 | ], 53 | "source": [ 54 | "#@title Generating a toy data\n", 55 | "import numpy as np\n", 56 | "import torch\n", 57 | "from torch.utils.data import Dataset, DataLoader\n", 58 | "import matplotlib.pyplot as plt\n", 59 | "\n", 60 | "# Define the nonlinear functions\n", 61 | "def f1(x):\n", 62 | " return 5*np.sin(2 * np.pi * x)\n", 63 | "\n", 64 | "def f2(x):\n", 65 | " return 5*np.cos(2 * np.pi * x)\n", 66 | "\n", 67 | "# Generate the dataset\n", 68 | "np.random.seed(42)\n", 69 | "num_samples = 1000\n", 70 | "x = np.random.uniform(0, 1, num_samples)\n", 71 | "U = np.random.uniform(0, 1, num_samples)\n", 72 | "y = (U <0.5) * np.random.normal(f1(x), 0.1) + (U>=0.5) * np.random.normal(f2(x), 0.1)\n", 73 | "\n", 74 | "# Convert to PyTorch tensors\n", 75 | "x_train = torch.tensor(x, dtype=torch.float32).unsqueeze(1)\n", 76 | "y_train = torch.tensor(y, dtype=torch.float32).unsqueeze(1)\n", 77 | "\n", 78 | "# Create a custom Dataset class\n", 79 | "class ToyDataset(Dataset):\n", 80 | " def __init__(self, x, y):\n", 81 | " self.x = x\n", 82 | " self.y = y\n", 83 | "\n", 84 | " def __len__(self):\n", 85 | " return len(self.x)\n", 86 | "\n", 87 | " def __getitem__(self, idx):\n", 88 | " return self.x[idx], self.y[idx]\n", 89 | "\n", 90 | "# Create a DataLoader\n", 91 | "dataset = ToyDataset(x_train, y_train)\n", 92 | "dataloader = DataLoader(dataset, batch_size=32, shuffle=True)\n", 93 | "\n", 94 | "# Plot the generated dataset\n", 95 | "plt.scatter(x, y, s=10, label='Data')\n", 96 | "plt.xlabel('Inputs')\n", 97 | "plt.ylabel('Targets')\n", 98 | "plt.legend()\n", 99 | "plt.show()\n" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "source": [ 105 | "#@title Least square regression\n", 106 | "# It only estimates the conditional, can not explain the uncertainty\n", 107 | "\n", 108 | "import torch\n", 109 | "import torch.nn as nn\n", 110 | "import torch.optim as optim\n", 111 | "import matplotlib.pyplot as plt\n", 112 | "\n", 113 | "# set up\n", 114 | "input_dim = output_dim = 1\n", 115 | "model = nn.Sequential(nn.Linear(input_dim, 64),nn.ReLU(),nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, output_dim))\n", 116 | "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", 117 | "\n", 118 | "# Training\n", 119 | "num_epochs = 1000\n", 120 | "for epoch in range(num_epochs):\n", 121 | " model.train()\n", 122 | " total_loss = 0\n", 123 | " for x_batch, y_batch in dataloader:\n", 124 | " optimizer.zero_grad()\n", 125 | " y_pred = model(x_batch)\n", 126 | " loss = torch.mean((y_pred - y_batch)**2)\n", 127 | " loss.backward()\n", 128 | " optimizer.step()\n", 129 | " total_loss += loss.item()\n", 130 | "\n", 131 | " if (epoch + 1) % 50 == 0:\n", 132 | " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(dataloader):.4f}')\n", 133 | "\n", 134 | "# Plotting the results\n", 135 | "model.eval()\n", 136 | "plt.figure(figsize=(3,3))\n", 137 | "plt.scatter(x_train.squeeze(), y_train.squeeze(), label='Data', s=5)\n", 138 | "y_pred = model(x_train)\n", 139 | "plt.scatter(x_train.squeeze().detach().numpy(), y_pred.squeeze().detach().numpy(), label='Predicted', s=5)\n", 140 | "plt.legend()\n", 141 | "plt.show()\n" 142 | ], 143 | "metadata": { 144 | "colab": { 145 | "base_uri": "https://localhost:8080/", 146 | "height": 631 147 | }, 148 | "id": "tdLSAd5X5EVX", 149 | "outputId": "9b28e62b-43d0-45f2-8fb9-c583a6d6a556" 150 | }, 151 | "execution_count": null, 152 | "outputs": [ 153 | { 154 | "output_type": "stream", 155 | "name": "stdout", 156 | "text": [ 157 | "Epoch [50/1000], Loss: 6.3564\n", 158 | "Epoch [100/1000], Loss: 6.2065\n", 159 | "Epoch [150/1000], Loss: 6.1060\n", 160 | "Epoch [200/1000], Loss: 6.1450\n", 161 | "Epoch [250/1000], Loss: 6.1124\n", 162 | "Epoch [300/1000], Loss: 6.1889\n", 163 | "Epoch [350/1000], Loss: 6.0766\n", 164 | "Epoch [400/1000], Loss: 6.1587\n", 165 | "Epoch [450/1000], Loss: 6.1213\n", 166 | "Epoch [500/1000], Loss: 6.1812\n", 167 | "Epoch [550/1000], Loss: 6.0676\n", 168 | "Epoch [600/1000], Loss: 6.1718\n", 169 | "Epoch [650/1000], Loss: 6.1172\n", 170 | "Epoch [700/1000], Loss: 6.1329\n", 171 | "Epoch [750/1000], Loss: 6.1257\n", 172 | "Epoch [800/1000], Loss: 6.1137\n", 173 | "Epoch [850/1000], Loss: 6.0955\n", 174 | "Epoch [900/1000], Loss: 6.0989\n", 175 | "Epoch [950/1000], Loss: 6.0805\n", 176 | "Epoch [1000/1000], Loss: 6.0457\n" 177 | ] 178 | }, 179 | { 180 | "output_type": "display_data", 181 | "data": { 182 | "text/plain": [ 183 | "
" 184 | ], 185 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR8AAAESCAYAAADEydGTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTtklEQVR4nO2deXgUZdb27+6u9BKSdBaQLXtYVUR2ggoEojKvM+M2MzqKEgZRNDIQUYHZ1FedgIIIeTPKuCQojjpuOJ+OqGRhM2EJiKIgWUkCBCEhG0l3Ut31/VFU0131VKeXqt5Sv+vqC/rpSi29nDrPec65j4phGAYKCgoKPkbt7xNQUFDonyjGR0FBwS8oxkdBQcEvKMZHQUHBLyjGR0FBwS8oxkdBQcEvKMZHQUHBL1D+PgFnWK1WnD59GpGRkVCpVP4+HQUFBR4Mw6CjowPDhg2DWu2eLxPQxuf06dNISEjw92koKCj0QUNDA+Lj4936m4A2PpGRkQDYC4uKivLz2SgoKPBpb29HQkKC7bfqDgFtfLipVlRUlGJ8FBQCGE/CIkrAWUFBwS8oxkdBQcEvKMZHQUHBLwR0zKc/YrVa0dPT4+/TUPCQsLAwaDQaf59GUKAYnwCip6cHtbW1sFqt/j4VBS+Ijo7GkCFDlNy0PlCMT4DAMAzOnDkDjUaDhIQEtxO2FPwPwzDo6urCzz//DAAYOnSon88osAk542PqobGw8CCOnWnH2KFRKMiaDL028C+Tpml0dXVh2LBh6KDVuGimMUBH4YpInXIHDSIMBgMA4Oeff8YVV1yhTMGcEHK314WFB1FW04zW7l6U1TRjYeFBf5+SS1gsFjAMg7OdNM62m9BpZv/98Uw7zraboKjdBg/h4eEAgN7eXj+fiWvQFis27qjE/Nf3YeOOStAW30z7A98lcBHaYkVecSXKa5odxo+daffTGblPh5mGvtcCFXX5bmmxMjjbbgIADI7S++vUFNwg2DzV/JJqvLzjBBgAe6vOAwCWZY6U/bghY3zyS6qxsahKMG5lGNz7WjmmpsQhOyMNlCawnD3aYkV+STWqzrTgjpFaiJmXi2YaDMPg5w6zMiVT8Brue3egrgX1LV3g/GoGQMHeWgCQ/fcSMsZnf20zcbzdRGNvdTP2VjejvKYZby+aGlAGKL+kGht2nMDwSA1+nXaF023PtpvxcwfrBXWaaYABBhsVb0jBfey9HT6t3b3YsOMErFYGOTeNku0cQsb4WKx9x0TKapqRX1LtE5dSDO6Os7+2GRYrg8P1F1z6u04zjYtmi8PYha4exfgouA1tseLDigai4bHnk29PyWp8AscF8JLG1m6XtjtQ1yLzmTiHu+PsrW5GeW0LzBbXA8kM7+tCu2Bw5SYrKwsqlQoqlQphYWEYPHgwbrzxRrz55ptu5SsVFhYiOjpavhNVAMAanvve2I+GC33/Xtq6e2QNPoeM8TnXYXZpuynJsTKfiXP21zb3ecdxFSvDoOZcJ6x+NkLz5s3DmTNnUFdXhy+++AIZGRlYtmwZfvnLX4Kmab+em4IjG776CWU15BAFn7ZuGvkl1bKdS8gYH7iwFK2j1HhvXy1G/+ULjP7LF7h7cxlMPb79cUhtJzrNNI41tfvVAOl0OgwZMgTDhw/HxIkT8ac//QmffvopvvjiCxQWFgIAXnrpJYwbNw4DBgxAQkICHnnkEXR2dgIASktLsXDhQrS1tdm8qKeffhoA8Pbbb2Py5MmIjIzEkCFDcM8999iS+BRcg7ZYsf7L4xj/zFfI31nj1t/KOVMIGeMzITGmz23MtBVnOnphpq0w01aU17bIngdk6qHx+3+W49pnvsLv/1kOEPwenUaFa4YbPT6GxcqgrvkiAP/lbPCZM2cOxo8fj48//hgAoFarsWnTJvzwww/YsmULiouL8eSTTwIAZsyYgZdffhlRUVE4c+YMzpw5g8cffxwAmyvz7LPP4siRI9i2bRvq6uqQlZXll2sKNrjv3tVPfYm8kmq0dbuXd6SCvDOFkAk4Fy6cYstsjtBRLseADtVfAG2xyrICRlusyNywC42X5tdlNc2I0gvf8olJsaA04kvmWo0aWkqN7l6LaGC9q4dNUvRXzgaJMWPG4LvvvgMALF++3DaenJyM5557DkuWLME//vEPaLVaGI1GqFQqDBkyxGEff/jDH2z/T01NxaZNmzBlyhR0dnYiIiLCJ9cRrHAJt+4SpadwTXw0piTHIjsjTYYzYwkZ46PXUnj3wekAHFeUymtbnK6EmWmrbCtg+SXVNsPD0W6iodWo0GMXaFargHHDjVChyzYWoWM/Gvt8HoZhUHv+IrvMzsN66bVdJ352yNk4UNcMwD/Gh2EYWx7Sjh07kJubi+PHj6O9vR00TcNkMqGrq8uWEUyioqICTz/9NI4cOYILFy7Ygtj19fW48sorfXIdwYR9/o4rK6kqAMOi9TjVarKNLZyRIusqF0fITLvsoTRqLMsciXcWT8cjM/u23GI5Qt5AW6z46FAj8TV7w6MCMDUlDvdMS0SkgUK4VoPBUXqkDByA1EERGBylt/2AVSoVUgYOwOAoPTSE5MJOM43RQyKhstt32hURqDnX6ZcSjWPHjiElJQV1dXX45S9/iWuuuQYfffQRKioqkJ+fDwBO5UMuXryIm2++GVFRUXjnnXdw4MABfPLJJ33+XX+G83z3VJ2Hie57ys0AONVqQnpqHK4fMRA5maOwdO4I+U8UIeT5iLHsxpHYduSU06XFky1dkk+98oorUd/SJfp6Ymw4EmPDba4t3duDKH0YEmIHQK8Xz91RqVS2Mguu7MKe305mu338eKYdVw6Nwm3XDkenmbZ5S74q0SguLsb333+PnJwcVFRUwGq1Yv369bZq/X//+98O22u1WlgsjnlMx48fR3NzM9asWWPrYnLwYHDU6vmLA3UtHq2matQqbH1gmuTn44yQNz6URo3fTEpwyObUqAD79JrGC92Ys34n7pwYL0lKeetFEzYRSj3suXNivMNUj3azBvGKSB3AAD93mB3yfzRqFe6emkj8m4uE6ZoUmM1mNDU1wWKx4OzZs9i+fTtyc3Pxy1/+Evfffz+OHj2K3t5e5OXl4Ve/+hX27t2LV1991WEfycnJ6OzsRFFREcaPH4/w8HAkJiZCq9UiLy8PS5YswdGjR/Hss8/Kcg2hwpTkWOytOi9qgFQAKDW76sr9BuQOLIsRktMuPtkZaVieOcrmVj46R+hW1rd0YcOOE8grrvT6eDNf3On07jM9xftAnkqlwmCjHmGU67VdA3Ty3Gu2b9+OoUOHIjk5GfPmzUNJSQk2bdqETz/9FBqNBuPHj8dLL72EtWvX4uqrr8Y777yD3Nxch33MmDEDS5YswV133YVBgwbhhRdewKBBg1BYWIgPPvgAV155JdasWYN169bJcg2hwkMzUzAtJRZqwtfCaAhD5fO/QOXfb8FPz/0COZd+E8szR8kaWBZDxQSwVkN7ezuMRiPa2tokbZ3DZXmSVgJ0lBpH/najRxpAXLBvw44TTre7fsRAgYtrMplQW1uLlJQUp9MuPmfbTDjbIZx+8RkcpVcKUX2Ep5+lp9gvsJxs6RIscnAsmzNS8kCyN7/RfuH58KE0ary9aCriYwyC18y0FVc99SXWf3ncrRwZzqD1ZXikdnGviNLZVsaccb7TrOgChSj2JTtihic9Nc5ngWRXCfmYjxiURo1OEzkGYmGAvJJqUBqNy0vwecWVTnMqEmIMSIobIHnuBLcC9nOHGec7zaJpBRYrK8dhH7BWCA1cCTJr1KqAUnMA+rHxAYCxQ6OcGgx3Uss/OXza6eu/mZQgW7JfXytg9pxX9IBCCtpidUnRwd81jSQCyxT6mIKsyUhPjYNWJLtYqg8sPTXOJwG9KyJ1GBylR4SOglbkLmdhGJtE688uFuMqBC55RVV9ZjEnxBj8ElDui35tfLis6KkpcYLXtBoVaNraZ9yHtlix4asTaO0iJ70lxBh8JmDGeUCpgyIwanAkMRHRHrmW3hV8xyffnupzm/iY8ICbcgE+ND5r1qyBSqVyqPEJFEgeTo+FQV5pFVFSwL54c/7r+7CxuBLthPiRCux0yx8fvFqtgkHrvHOCXEvvCoEFadk9EPDJt+/AgQPYvHkzrrnmGl8czm2yM9Lw0aFGYkbyP0qrYLUyWDp3hM2IOJOg5Ig2hGHhdSkB6e4CgJZSs4mKCkEJ1yKqrxgfV74TiMh+S+7s7MS9996L1157DTExfcte+ANKo8adE+OJr5lpKzYWVzp4QK4Igi28LgXLMkf61d115tnEhGuVYHOQwqkllNU0wyxSv6Wj1LguLc5vCYSuIPsvIzs7G7fccgsyMzP73NZsNqO9vd3h4SuyM9KwbO4IiClb2K989bW4ECgBPi4AreH53Rq1ChcvBZ2DJe8nKysLt912m+357Nmz/TKFLy0thUqlQmtrq8+PDbAez+wXS0XzeTiWzEzDO4un+/0G6AxZz+q9997DoUOHBKn0YuTm5sJoNNoeXDGhL6A0auTcOBrDY8jyDvZxob7m0P6K8/DhAtADIxynVxbr5RWvmvMXvTJA9hrOWq0WI0aMwP/+7//KLp/68ccfu1zn5W+DISULCw/2qVU1PSU24BIKScj2C2loaMCyZcvwzjvvuJxivnr1arS1tdkeDQ0Ncp2eKLdPGCYYi9BpHDyZycni00dfLau7A+cBaSk1VHC0nBfNtNdL7pyGc2VlJVasWIGnn34aL774omA7KWUwYmNjERkZKdn+ggVXmmBSGnVA3Pz6QrYzrKiowM8//4yJEyeCoihQFIWdO3di06ZNoChKIJ8AsFrAUVFRDg9fs3TOSME0pfdS6QQnhdrTKzz3hBgDcjJHBVxfMOByB80e2irogAF4v+TOaTgnJSXh4YcfRmZmJv7zn//YpkrPP/88hg0bhtGjRwNgb0y/+93vEB0djdjYWNx6662oq6uz7c9iseCxxx5DdHQ04uLi8OSTTwq8M/60y2w2Y+XKlUhISIBOp8OIESPwxhtvoK6uDhkZGQCAmJgYqFQqmwyr1WpFbm4uUlJSYDAYMH78eHz44YcOx/nvf/+LUaNGwWAwICMjw+E8/cGYIX0b3EBMKCQh22rX3Llz8f333zuMLVy4EGPGjMHKlSuh0ThfBvYXlEaNCJ0Gbd2Xf5BmmrElcpXVNOMQQSFOpVL5tR9YXzgzMFJHfQwGA5qb2ferqKgIUVFR+PrrrwGwmsw333wz0tPTsXv3blAUheeeew7z5s3Dd999B61Wi/Xr16OwsBBvvvkmxo4di/Xr1+OTTz7BnDlzRI95//33o6ysDJs2bcL48eNRW1uL8+fPIyEhAR999BHuvPNO/PTTT4iKioLBwNb05ebmYuvWrXj11VcxcuRI7Nq1C/Pnz8egQYMwa9YsNDQ04I477kB2djYefPBBHDx4ECtWrJD43XKPKckxKK8VZt5rVEB62kDZpU+lRDbjExkZiauvvtphbMCAAYiLixOMBxr3T09CnpOWIT0uKMT5DQsN7F4P1JcBienADSsADYUBOooovwoApl6Lg+SppzAMg6KiInz55ZdYunQpzp07hwEDBuD111+HVqsFAGzduhVWqxWvv/667XgFBQWIjo5GaWkpbrrpJrz88stYvXo17rjjDgDAq6++ii+//FL0uCdOnMC///1vfP3117aFjdTUVNvrsbGsJ3DFFVfYeoOZzWb8/e9/x44dO5Cenm77mz179mDz5s2YNWsWXnnlFaSlpWH9+vUAgNGjR+P777/H2rVrvXqfvOFwQxtxfFJSjM/FwLxFyTIjsCxzFD49ckaQ96NFDwrD1mCKmq1cP2gdhQW9q9ADLW6/drg/TlXI7vVAaS4ABqgpZcdmr7Tl9JCKTy1WVv85ZeAAjwzQZ599hoiICPT29sJqteKee+7B008/jezsbIwbN85meADgyJEjqKqqEsRrTCYTqqur0dbWhjNnzmDatMs/JIqiMHnyZNHA+LfffguNRoNZs2a5fM5VVVXo6urCjTfe6DDe09ODCRMmAGBlYO3PA4DNUPmLKcmx2HOpMYA9YQE21XcFnxqf0tJSXx7OY7i8H3t5DAO6cUj7EPQqGtzvc7r6OI5rs/Bb9UYsnfsLP50tj/oywF5Cvr4MQN/Fp52XAs+eVLxnZGTglVdegVarxbBhw0BRl79WAwYMcDxOZycmTZqEd955R7CfQYMGuX1sALZplDtwPcM+//xzDB/ueOPQ6QI3+TI7Iw3lNc2Ceq5ATSR0huL5iMBlPZ9racZX2scQr2LdXXvHgPv/B1gGNf0bQBMArVwS0y95PAwAFfvcDk5+9fxFoQd0oavHo0r3AQMGYMQI15Z2J06ciPfffx9XXHGF6ILC0KFDsW/fPsycORMAQNM0KioqMHHiROL248aNg9Vqxc6dO4n5ZJznZb/IceWVV0Kn06G+vl7UYxo7diz+85//OIyVl5f3fZEyYN+V4hRvqT0xNjxo4jz2BJ+v5iMoaw/+pXkKP+oWIV7VBpXK0fBwqFRsCjteSAV6+1YUlJ0bVgCzVwOpGey/NzgGSDn51SuHRglEyHpoK35ul7fS/d5778XAgQNx6623Yvfu3aitrUVpaSn++Mc/orGR7faxbNkyrFmzBtu2bcPx48fxyCOPOM3RSU5OxoIFC/CHP/wB27Zts+2TE6lPSkqCSqXCZ599hnPnzqGzsxORkZF4/PHHkZOTgy1btqC6uhqHDh1CXl4etmzZAgBYsmQJKisr8cQTT+Cnn37Cv/71L1sHVl+TV1yJDZe6UtiHA1Rg9cADbYXVFYLvjH3BxfPA80MwvOOIqNGxRwUAFjPw/GCgjdwux2doKGD2SuD+bey/GrJzq1KpkBw3AGrexZ2TWfEwPDwcu3btQmJiIu644w6MHTsWixYtgslksnlCK1aswH333YcFCxYgPT0dkZGRuP32253u95VXXsFvfvMbPPLIIxgzZgwWL16MixfZLq7Dhw/HM888g1WrVmHw4MF49NFHAQDPPvss/vrXvyI3Nxdjx47FvHnz8PnnnyMlJQUAkJiYiI8++gjbtm3D+PHj8eqrr+Lvf/+7LO9LX/D1oowGyq/6y1LQLzWcRbHQQNEzwDebRDexf7dEjdIT1cCAgW4d2te6vwAb+xErTBwcpVcUDz1Eys+Sm269Ulrl0IcrMTYcu57M8PZUvUbRcJaCjibg2bg+DQ/DAHPMz6PcOhqiZvvFNHZ/AY6z3B9F6ycw2Pg1O93iNwAMmNVVL1CMj7kTWDcWWD9adBMGrNFpZOJwVc8bqEUK5vf+BRvp28SLTNePDowYkBMGOOnQoWj9+B/aYsU/99Q4jKlVwLK5I4Kidqsv+vc37OJ51kvpgwPWUZjf8yf04HK+igUavGz5HXToxpKwL0GcgT0/GFjxExA5RLpzlhKRaWPEJX1nBf/ATbU+rGgQSGZYGUCtCo7arb7on8bH3AnkTQU6nUtQWgEsjn0HRafFI87rLPNhBYVHwj4n/5bXjwZWngQM0d6csSzwp1YqqKBSXfb0FLkf/9CXWJ07jQ0CmeA3n+7S3QrkxvdpeADggYHvOzU8AOsBvWi5F/9vwG/FN1qbzBq8AIM/tWLAwMowuGimUdd80U9npdBXK5xgKRzti/5lfCw0sH4U+iylHD4d+PNZfNPk+kJg3bUrgBueFHmVAdYkumSAfLn4aC+1waebULmv4BpWq3e1f2LGJUpPYdmckUG7tM6nf027Sp4HaCdJdFHxQPY+QBcB2mIlmqgoPfuW2QvGqwCU17aCSf0dlg7bCfXpfcI/ZCzA2hRgdQMQJlx+DQsLg0qlwrlz5zBo0CCfSZwatUB7Zy8Y2tHYWFQqNJ5rQ1yEIrfqKgzDoKenB+fOnYNarXaoaXOHh2am4IOKBoFaYYeJhjoAm/95Sv8yPmLL6Bod8PgJh7hMfkk1UR/36uFGTEqMdqh6ZwB8U9OCb2paoJ6zHktP3wCid2XtYT2vFScEBkij0SA+Ph6NjY0+14xpN/WivVu4tH4WrLGNMoT59HyCnfDwcCQmJkKt9sxIbN5VS5RJZRA68R6gvxgfCw3sXAtYCbkr1z8GZPxZkAks9iFPS2GVCklV7wCwr74LS1fWAWuTyOdiagPWjQQerxQYoIiICIwcORK9vb0uXZZU0BYr/rWvHu/ur0cPr0/ZUKMh6KQa/IlGowFFUV55i2LfPRVCJ94D9BfjU/wssPdl4bguCsh8ivgnk5KiBdIFXAEfqeqdw2JlQGujQK08KW6AzO1A/hRg6WGB0dNoNH4RWntwzhhsPXgGp1odDWonbQIVpg0ZVz8YmJIci71V522+c3yMAUmx4ZiaEngSvd4Q+t8ocyfZ8ADA8u8FQ1xDwI8PCVfD7Av4sjPSkJ4qlDEor2lm2+wYotkldq1IynlrPfBCSkCtgpGyZtu6aWLjRAXp4b57+2ubMT01DtelxSEncxRKH58d8J0oPCF0rkSMf0wnjyffQMy94aqHGy44ly2gNGq8vWgq4qMdtWQc5uWGaOBPDUDideRzMLe7vArmC5bOHYFlc0ZCz1v9CqU4QyDD5ffsrW5GeU0zpqbEhZzBsSc0r4rD3Am0kTpgqIB7PxSM0hYrCr+pI21NlC2gNGqc7xSunk1KinYcuO9jIEnEADEW4KWxbFzKz1AaNXJuGoWHZ49wSJisb+nCxh2VffatV/AO+/yeUAsukwht4yPm9TxRRVzu3rjjhINwPADoKbVT2QJdmDA+s6+mxfGHGqYHFv4XSLqefD7mdiBvQsDUgmVnpGF55igkxLBeXX1LFzbsOIG84ko/n1loMyU51mb0/RJc7jUBBbcAzw0G1iQBRc/LelMMXeMj5vVodES5C9pixT931wrGF9/gvO3x/KnCxobltS3kH+r8j4AwkdYnrfVA3uSA8YCWZY4UrNjwNWUUpIUz+n7T6dl6J3ByD0CbAFMrsPsFVhNcJkLT+Fho4KUrya/FTyEOi+X1qFXO3yJKZGWq8JuTwmlKmB54sgowinRibW8ANo4PGA9IwTdwgeasggMAgMKFU3wf6zF3soaHzyUNcDkITeNT9AxgJrQY0Uay3geBfTXCjgAAUEHo0eXK623dveRVojA98MdvgVmryDtsbwTe+Y3TY/qKX40b4vS5gvfQlxpSchKpG3ac8P3qYnMVkCuiD5QoX7eO0DM+FpqcyaxSi8Z6aIsVR0+T29D2Ne+2n6fzeXNvDUw9hGmUhgIyVgNRIh5Q3W7g9Xl+94Aq6lsdnm87cloJOktMfkm1oBPFhxUNvnufe01A3iTya4nXCTTApST0jE9pLnn8+seIhgdgvwD2tVocrnQFyM5Iw3RCvg/A5sgsLDzo5I/LISqq01gGvDjCrwboeFOHw/NTrSYl50dCaIsVH1YI45INF7p98z73mi4VWhPQG4EF/xHVAJeC0DI+FhrY/RL5tdmrRf9MbEnTla4AlEYt6O1uz6H6FvG7mC4CWFnHTgdJ9HQAb93m9PhyMnaoMEHyzT01yrK7BHDTLX4+GYfsy+wX6lixOxO5AypyfpTV8AChZnxKcsFKgPEYPk30jaQtVkH/Kh2lxtKMNJdXG5xNzcw04/wuZogG/tTI3mlINJT5zfspyJpsq+LnaDPReNkfcYkQgzTdskfWZXZzJ7uwIcbSCvbGKDOhY3y6W4E968ivZf2HPA42o9n+S6Cj1Hjw+lQsyxzl8mpDdkYaci4tkZKcIJfuYsu+E3/tLedtY+RCr6UwbrjQKPaHBDi5EXv/1CrIq9lz8bx4cFlvBP58FojzjT506BifDVeTx40JorEeAIIaLjNtRV5plVt3di4vZusD0xCpF3pYLt3FDNFsyx0SDWV+y/+ZmhJHjEpZrIwy9fICsYWK4dEG5Nzk+o3PbdaPFX+NIPUiJ6FhfCw0Gx/ho9IAjzhvb9vWTZav8PTOPn9qosPz4UY99tc2uxYnGTCQDYwLYPwmxcolvs1Ii3OYgpXVNCOvqMrn5xMqLLouCcNjDAIDdMeEeHkPbO0hjy874lPDA4SK8RFb4VpVLzp35RK7xPpTeTrnpnhFmafaTNhb3ex6nCTjz6zUB5+eDvFyERnhvLppKXGCFcFPvu1bB1tBCG2xYt6mPWi80G2r5TIawpCTOUreljhi3vPqU0BMsnzHFSE0jE/Z/wnHouKdBs3yS6qxYccJWHiCgxov59wVJ1uJ4y7HSTQU8Ngx8mttDX6bfpHOPYCb3QY0+SXVBKVCRt6s5l4TWz/IJ2G6T4LLJGQ1Prm5uZgyZQoiIyNxxRVX4LbbbsNPP/0k/YFIuszZBB1lO8QMwaNzRng153bmMQmq3cXQRQDGRPJrb9/mFwNEuq7hPDkRBdcgffci9TJK1faa2Jyx1nrHcX00cP+n8h23D2Q1Pjt37kR2djbKy8vx9ddfo7e3FzfddBMuXpS4LQu/VsqY6NSam3rIrWESY8OxdM5Ir04lOyMN8TEiP0rGDWnNR8rI06+63awQvo/JzkizVblzHGtqV3J+PGBCfLRgLFHsOyMFW24lx0SnP+LzOI89shqf7du3IysrC1dddRXGjx+PwsJC1NfXo6KiQtoDPVIGRCcCaor99xHnxXALCw8SBbpvnzDMa7eX0qixI2cmpqcIVzMOnnQjiK2LAJ6sZUXP+Ox5yee5P5RGjd9McjTybd20f2qRgpwDhO/BtFSh0oIkWGigUWTRRcbSCVfwacynrY3NpoyNJU9NzGYz2tvbHR4uoYtgJVH/1sz+28cc9tgZkf2645k4Qa+lMC0lTtC/gp/M2CcaCrhvG/m1t+/w5NS8Qkw6dn+teLKcgiOmHlpgfPSUWr68nl0vksd1UbJnMPeFz4yP1WrF8uXLcd111+Hqq8k5Obm5uTAajbZHQoJI4aWXkMoGADc9kz4grQSdaiWn0jtF7AtSv9fnS+9ipSRuG9V+zMLCg+DPUickxsgTaO41AXs2kF8j6Jf7Gp8Zn+zsbBw9ehTvvfee6DarV69GW1ub7dHQQJJA9Z6CrMnQEbp0yv0b8ridSoKIrMHaFJ9Pv0iBZ4+Maj+F73VTahUKsibLc7C3bgcshMWY65YT9ct9jU+Mz6OPPorPPvsMJSUliI8XT6LS6XSIiopyeMiBXkthyUyhm+ukPtRtbh0/VDB2+4Rhnu3s/m3k4LO1x+elF9kZaTDymggqHU1dw9RDw8pLT5icFAO9VqbpTwMh9qk3AnP+Ks/x3ERW48MwDB599FF88sknKC4uRkpKipyHc4ulc0cI4hdTU8jSGJ6g5lmy6Smxnq+khenZJoMkGr7x6dI7pVEja4ZjPzKPjWo/Y2HhQUGi5pQkmQpILTSIXXOnPez3WA+HrMYnOzsbW7duxb/+9S9ERkaiqakJTU1N6O72v5vOtb7hCkJzJNbM5ScbUhq1d/P6MD2gFun9LZbhLRMPz2IDz9GGMKSnxuHhWaHTyE5OSAsdhxqcK2V6zM615PGZT8hzPA+Q1fi88soraGtrw+zZszF06FDb4/3335fzsC5jXxAqdXapLJ0IVohkPu9ex1Yr+4jNu2pRXtOM1u5elNc0Y/MuofC+gpDRg4WrsLLEGbtbgV0vCMejEgLG6wFkbpccaOn3tMWK/JJqHKhrwZTkWFvrYzngvKgDdS2YlBQN2mLBzBdKALCdQZfOHeH+sQcMBG54nDU2fNaPBf52ztvTdgl+f6mCvazxkfP9DGa4792xJmGin5RxRhsvX0MYVF1Szgwc+tU3hesIyQl13/fGftmyc+29KrVKjbySatS3dLEN+IorPU/Mm70a0BGEx6w9Pov98MtEWrt7lb5eTuC+dySpXinjjADY7wCpeULSdX6r4RKjXxmffTXnHUJwZVxfdZkh1fJ4LMaloYDHfiS/5qvGgyLJmEpfLzL2nqI98TEG6ZMLibEelWjXFn/Sr4xPPaGkwheKfKR4z/enWrHh658887x0EWw1Mp/WemCr/JnPfbUTUmDhZFvqzjsmg2o1KqSnxmFHzkzpp6n7NwvHrs/xaw2XGP3C+HBfgjOEZDhftKTNzkjDsrkjHMS42rppbCxyTzHRgfs/ZevY+JyUf+ld7D0bGqVXikzt4GRbGlsdvdFBkTq8++B06fN7zJ0EQXgVqxEVgPQL47Nxxwmido8sbi8BSqNGzo2jER0uXCr32PMK0wNLD7P9yBxggBdTZS29EKvx2lfXgknP7fDcowsxxD7bs+2ErGMpIInN6Y0BtcJlT8gbH7Ee7NNTYuVxe51AWv2bkCDStcIVNBS59MLUBvxDvk6TXI5UYmy44LW27l7vPLoQQsxDHGKUaQrUTlCWnPqgPMeSgJA3PmI92NPTBsqX1i4CSXzrQJ2X8ZP7PiZPv9rqgaJnZZuCURo17pwoXiqjVLqzOs381kM6So3PHp0hzwHVfEEyNTBrpTzHkoCQNz5irq8/Wr+QKsL5XUHdhpt+qQmGdPc6WYXHSAJjHEqhO7D47UOC5XUzbcWWMhkKprtbASvvRpM4PWCnXECIGx/aYiXGHiTLOHYTUk6HmLyHW2gotlKZxJ6XZIv/kATGOGRJngsyxHSjZLnxvXwNwFgcxzQi5TgBQkgbn7ziSpTXCj/o6alxPgk088nOSMPSS1XhekqN6Smx0skpzF4t3vV0/RjZpl9cw0R+/MfKoN8HnUk3FllufKKJhTJN7yQipI2PWNKbRq3ySxkApVFjxc1jUPGXTDw8my2v2LyrVpofqYZi+2uT6OkQV7TzEi6Tu3jFLExPufyjKqtpRsa60n6t8VyQNRnpqXEwGijExxgwIzUWyyUuYAZA/mxVar/LpPZF4E4IvcTUQ+NsOznb1x9TLnu4dHsGwJ6q8/joUCPunBjvfW2ULgKIjAc6GoWv7XoBmP6wbCJSlEaN022O73fDhW68vOMEAGBZpnfC/MECv37w7UVT5b3RWWig/BXh+HXLAzreA4Sw55NVcECwyhWlp7Bs7gi/TLns2V/b7JBuX9/SJV1t1KP7AI1OOM5YgY2kgkN56W993e3rB11uFOkNpWuFUy41FbCJhfaEpPEx9dDYx4v1aFTAob/eiJwbR/u98lpsJYjfN94jdBFsp1ZS3y9B9qu03H7tcOK4vz1NX8Kv+Jfd8JLKKdRUwHs9QAgaH9piReaGXcJCvgCS+hRbCSJVPXtEmB7442G2V709JI9IQpbOHeEQ9wHYZE5/e5q+RBYdJzHEAs3DZdKElpiQMz7kVrRsh4VAybqdmhIn6OkFAJE6DWHUQzQUMICnI20YJN3+CVAaNaYkxziMTUmWqTNDgPLQzBRMv6TyOD01Dg/NlFE6eKfIIkIAVrCTCLlvhTM3N1BiD9kZaVieOUqQ/RofIyxX8Aqal99jOi970em2b087fR7q+FTl8dt/CceiEgKygp1EyBkfZ25uoMQeuOXpccMd83JOtXZLuyzNz/uhTcDu9dLtnwB/6ijZVDJI4Md8PjrUKE+qgbkTaK8XjgeYWqEzQs74kFq76Cm15ALxUsDPeG640C2tuuL43wvH6vZIs28R+N4c/3mow1d5rG/pkme6/39TyeMBplbojJAzPgAwdkikw/OHZqVKLhAvBdkZaYLMYEnVFWc+Iez3dUFesfc7Jg53+jyUoS1W7KuRULXSGR2ElVFK3gUFqQm521JeUZVDSYVX/bJkhtKo8atxQ5C/s8ZhXLIvq4YCaJ52TOfP0uxbhKVzRkKtUjuI9PcX8kuqieU8kk/3xWr10pdKexyZCTnj8/Fhx+zeU63dAefx2PPpkTOCMUm/rPwUA5lTDrh4Vn+CtliRV1SFV3dWCV5Ll6OOkCQaBrD1fUFE4P4qPYC2WPFzh+Odvt3U66ezcY0mXgmIWgVpv6wRg50/V/Ca/JJqbCyuhJknlRkfY5CnvKKNIMmhjQyKxEJ7Qsr45BVVEUoq+AJLgQVf1S5CRyGr4IB0BZnX/N75cwWvERNOS4oNl97wiE25co5KexwfEBLGhxOI37xLGKglqQcGEtv/eD3iYwyg1CpE6Sm0m2hp64JmPQHMfBLQRwOUHji5xzftdfoRYuUykvfkAoBXCPK4Ko1sBcNyEhLGJ6+oCht2nICJIJdKUg8MJCIMWuxZOQfHn53nkCLAQCIpUg3FdrQwtbJ5Pif3AFvv9H6/bsDdHOa/vi8kJTb4YTQdpZavgLmdkLRJaqMUBATXJFEEfpDZHlnuPjKQX1KNBl5ZiEUqLdLGA86fywQnL/HRoUbUt3QBAPZWsT3lQykoze8LMDExBjk3jpbnYFHD2P5sHJSO1fEOQkLC82nr7hGMadQqLJszMmiWeknL66cIfcY8wscrXhycvARneAAJPboAwdRD4+ipVocxFbE/qUQ8XMY2DFBT7L9P1ARNOQWfkPB8QCjTHB5tQM5No/xwLp4xJTkWey55BRw/d5hh6qG977IRMRhoPXn5OcOwcR+Zv7RibYJDRVyeU1DoMDtqJzPEsmGJ0EUAy7+Xb/8+JCQ8H345BSCuLROoZGekIZ4XHDfTVmQVSDBF4pdZWMw+ifuI5Ss1XugKibhPXnElUUFBljBjdyuwJhF42sj+290qw0F8i+zGJz8/H8nJydDr9Zg2bRr2798v+TH4KfzTU2KxdO4IyY8jJ5RGjaQ4YVX7tw2t3u985hPC1jqnDnq/3z7IzkgT6PsAbA1boMibeIOY+JssccYNV18WgzO1sc+DHFmNz/vvv4/HHnsMTz31FA4dOoTx48fj5ptvxs8/S5viv3TOSORkjsL1IwYiJ3MUtj4wLaCzmsUgfWl1YRJo/GgoQM3fj/xzH0qjxjSRH2KgyJt4Q1u3MIF1eLQMLbh7TWwTAHv4z4MQWWM+L730EhYvXoyFCxcCAF599VV8/vnnePPNN7Fq1SrB9mazGWbz5Qzl9nZy3yM+oZLSn52Rhm+qzmGfXRfT+6cT5FA9Qa0DYOY9l5+KenJHVq/aRAcAtMUKU69FMH7RTEt/4/NxaoSvkM096OnpQUVFBTIzMy8fTK1GZmYmysrKiH+Tm5sLo9FoeyQkkBvShSqURo13Fk9HTuYoXJcWh/TUOByqb5UmNyY81vlzmRCL+2wpOxnUOT/5JdXosQi9R0maQPIhTZETCcmGXuLrfCzZjM/58+dhsVgweLBjLdHgwYPR1NRE/JvVq1ejra3N9mhokKGtbIDDeXFTU+JQXtOMvdXN0mQ7X3O343NjvOyqhsDlpoIULwrbbqJ9091BJkjpAjpKLV0TSA5zp1CZACrgvm3SHge+77wRUIERnU6HqKgoh0d/xb69DgPgw4oG7+5Es54AEuzulif3yNrHnYMzpiQPKBjb6nDewfenhMLtS2alep8Wwecf6RDE54zySKX6uvOGbMZn4MCB0Gg0OHv2rMP42bNnMWTIELkOGzLwc2G8XiHSUMAp3rL9npd8tmRbkDUZ0+w6OwA+6O4gA5x3wJeHjdJT8uhGkSrYx98j/XHg484bkNH4aLVaTJo0CUVFRbYxq9WKoqIipKdLP18NNUi5Il5nBlsJ06wXR/pk+qXXUlCrHXN/h8fIsDIkM2KJk9HhWukDzRYaxFXJWU9IexywHp3VyiAhNhyJseH4ow+aa8o67Xrsscfw2muvYcuWLTh27BgefvhhXLx40bb6pSAOadnd61ovHWGFydoDlOZ6t18XOXbGcfXyfAc/lhH4TOF5bxy3Txgm/cHEPheJdXtMPTRmryvFxuJK1Ld0ob6lC2qVWvZ0FVmX2u+66y6cO3cOf/vb39DU1IRrr70W27dvFwShFYRkZ6ThjT01Du6917Vey78D1iYJx3evZxMRZS63GDs0CmU1l703E80WngZTmgTnDeyvbYaVYT3UqSkyqBUCQNn/CcdInWi9ZGHhQUGmNutly/u5yF7b9eijj+LRRx+V+zAhB6VRIzpc62B8VN4WhBqi2SXaen6qAwNsuQ14YLt3+++DgqzJmJZb7JCcF2wB58s5ZTIbTAvNSqDweYScpuINfI8U8E39XUCtdik4wq9PO9tuwu//WQ5Tjxcxmvu2gVSIi8Yy4OJ54biE6LUUstKTHcYmJcaQNw5QfJYLQ+qvRulkaY1Dyk3yhQyWYnwCmKVzRyAnc5StcNZMW1FW04yFhV7UZYXpgetXkF97MU3+1S8V4/x5gJNXXIkNl3JhNuw4gbziSukP0msCyv8hHJepO0VB1mTEx1wualbBNzpYivEJYGwuPk+t6sfTwhwTt8hYDWhEyiteHufdvvug4mSrw/NPDp8OKoXDTw6fdvpcErbewSpP2hOdKEt3CtpixSs7q6ECqw6REGPwyUoXoBifoCCC1/XTCnj3Q9VQwOMnyK+Z22XVeOavFtW3dNm8iGDIdmZ4NwL+c68xdwIn9wrHY1Jk6U6RV1SFjUVVaLjQjbbuXjRc6PbJShegGJ+goIOX0NZhor3/oRqixbV/142UzQBlZ6RheeYoJMQIhf0/OFgf0N4PbbHCyjM2kjYosNDAhivJryVdJ91x7PjkW6EsiK8WARTjEwR09QirpyX5gtz/KRAVLxw3twNv3eb9/gk4UyBobDUFrPdDW6yY//o+nGp1NMqSNijY9eJlzR57ohKAG0TidF5AW6xECWJfZZ0rxicICNcKNX0sVsZ7LyFMDyw7AqgIX4OGMlmnX/zyBI5AXXrnt+HmkCwwa6GBfa8KxykdsPSgLFOu/JJqtHU7fg7TU3zX4loxPkHAgunJgrGymmZpvAQN5Vhwao+MOjJRevKPKVBrvUgdUoyGMOl+qDvXCoPMKrWsAvF8Q58YG+5TIT7F+AQBy24ciWVzRkJPOX5cknkJ933MNp7jc3IP0EGWP/GWOyYIp3uROk3A1nqR2m5nzUiS5odq7gR2rxOOGxNkyesB2CmXfbmOCsCdE+N9qgCqGJ8ggNKooVarBE0RJfMSwvTAkzUgJh+uHy3L9Gvp3BEwGhy9H3UAN3jkt92WrIq91wS8mAowhCk0X/hfQvJLqh1KXaanylQi4gTF+AQJfC9HowZoi0W61SFDNHCDSLW0DNMvSqNG1oxkh7G2bhr3vbE/IFe8+J7awhkp0ngJb91OEAsDW8M1U/rqdQ7h90nlc91zxfgECXwvx2IF8kqqsXGHSL6OJ8xeSR6XqdPF0jkjkRjr2LFDsliWRHDlFAdPtiA9NQ7XpcUhJ3OUNN1RLDQb2OdD6YBHD8gSZAbYa+qlHVdQJ8RHy3IsZyjGJ0jIzkgj9id7ZWeNdNnBGgqY8UfhOG0CchMkL72gNGrcOVEY+wmkjqaceNje6maU1zRjakoclmWO9N5L6G4FcoeBqNcjcxfSvOJKhyYFAHDgpO9XGRXjEyRQGjXR+NBWRlq93blPAYmEhDZzuyylF9kZaQ51RUBgdTSVTVr05XEi0y35gswcpJKQ402+b8WjGJ8gQqwLq6Q/Cg0FLPgPEJMsfE2G0gtKo0YSb+p16GQLNnx1wu+xH9KKkCRB/o4m9r3kozcCj5R7v38PkKXrRh8oxieIWDp3BIYbye64pPkxGkpcJ/jvwySffvET9cwWBhuLK5FXVCXpcdyBy2i2XxGaJkUCXq+JXUEUoGKnWzJ7PYDwJhYfbZC+64YLKMYniKA0alwklFokyKGFfMMKcukFY5F8+sX2qRcaVVLdka8gZTSfau32PtYjVrZyfY5sAWY+nFQL1+G39InZ0nfdcAHfH1HBK/hSpAAQHxMu/TKphgKWVgC5w4XC8+Z21vsxREtyKEqjBrxVaZQYkuETKwlxmYvnyatbAJDxZ+/27QaB0uFX8XyCjIKsyYLShB9Ot3mnbihGmB647jHya+tGSdr1ooOQQXzr+KGS7V8KxEpCXKLXBKwTWZ6PGOYzryeQUIxPkKHXUlh0farDWLuJxtS/F8kjyDV7Jbn2y2IGdr4o2WGuHCrsrKEmFbz6ANpixTBCbO2OieSAv0u8fYdAFI5FBSw9QBgPfRTjE4RkZ6T5rv2whgKyPiO/tu8VybyfgqzJglSCivoLIlvLS35JtUO8x2gIw7I5Iz0vp+huBeoJAmEAsLJO9iCzqYfG3ZvLMOYvX2D8M19h/ZfH/b6SCCjGJyihNGoM0AkLQWVrcauhgHiC92NuA7b8WhIDRBKXP1DXjBvWFvt82Z3/Ho4bbkTOTaM8i6tZaHaKSuKJasniZs7IKjiA8toWmGgr2rp7kVdSHRBZ5IrxCVLun07ovwUZu0Es2AZi4Wn9XumaDvLE5M00g4YL3dhYXOnTH4ukbYN3vchOUfmoNMCAgZ7v1w2+bWgVjAWCbpJifIKUZZmjkEOSI5WrG0SYXlzK85s8SQ7BF5e3x1c/FlYq1Xq5bfCckZ6nMYhJZQBAooiErQzowoReciC0LFKMT5DCLZcmxQ1wGHf2A/aa+R+RWy5bzJJMvZx5GL4SGcsvqcamoirUt3ShoaULak+rvTk9Zn6aAgBADcz/2Otz7QuuKDaSMEUPhJZFivEJciSdIvRFmF6860XeBK9LL7Iz0jA9RXj+w6P1eGhmilf7dhXJarl2iugxa7TAylrZW1MDrCHdsOMEGluFn8vBOv8E8+1RjE+Qw3WDuH7EQCzPHCW/IFSYHkicIRxvrfe66wWlUWPrA9MEMhunWk3YvKvW4/26w6SkaKfPXcLcCewhTLf0RuBPZ3wSZAacG85AKN5VjE+Qw02/tj4wTRqpB1e47xO2iR0fczubz+IF/pLZ4KYoHx/iZTYzbmZed7cCa+KF0y01BeT86NNkQmdxnUAQjVSMT4jgsx7iAOv9LD0M4tenfq/X06+HZqYIsonlvlNzuj0NF7odxt3KNbp4HlibRE4mvOFxnxSNOuAkruOLdsh9IYvxqaurw6JFi5CSkgKDwYC0tDQ89dRT6OkR9ghSkAbux7On6rw8yYZ8NBSQJNL14v+meBWA3ryrVlBHJfedel/NeYGsl1sxNAsNrBfJ59EbZZVEFYO/+ECpVUiIMWCZj9oh94UsPuDx48dhtVqxefNmjBgxAkePHsXixYtx8eJFrFsnsvSo4BWyiV45Y/7HrMQGw6u0b6sHSp4HMp/yaLekc5f7Tl3P83h0lBqPzHbxR9rdyiYSWoWKAwB8Pt3imJQUjT1V523PszPSkHMjSc7DP8ji+cybNw8FBQW46aabkJqail//+td4/PHH8fHH8i8v9lf483uf5HGE6cU7ae592WPvh+9txMcYsL+2WdbpJL+wVR+mdi2G1msCXkglJxICwPWP+Xy6JVn8SmZ8Zo7b2toQG+vchTWbzTCbL3+I7e0EtTcFIlZe65VXd1Vjf10LCrImy6vVMmslcHIv+7CHsQKla4G57ktFcN7GgboW9NIW7Ku7gMYL3dhb3QzaYsGKm8dIceYOXDnU6CBVQip0JfL2HULPj2PGcp9KZXBwU3D+NNJftXJi+CTgXFVVhby8PDz00ENOt8vNzYXRaLQ9EhISfHF6IcGnR844PDfTVpTVNGNhoTydJ2xoKOD+/wAanfC13S96pHpov4J3/KyjtvA/d9dK6v2Yemj8/p/l+OF0K6L0FIwGCumpca4p+1looP4b8mszVwE3PeOX6Zb9FNwej9IGZMQt47Nq1SqoVCqnj+PHjzv8zalTpzBv3jz89re/xeLFi53uf/Xq1Whra7M9Ghoa3L8iBQeOnfGB96ihRJIPGa91f8y9jobGTFslDaYvLDyIsppmtJssaDfRuHKoEe8+ON01b3HXiyB2n0hMB2b5PsDMITrlDuZp14oVK5CVleV0m9TUy1ozp0+fRkZGBmbMmIF//vOffe5fp9NBpyPcQRX65PZrh2NjcaVgfPRgH8UbDNFA0vVsi2V7LGZg93rxnmB9cG1CtEDO9IOKBlZWRIKcJr5xdstYf/uucCwqAVjwmV88HtpiRV5RFQq+ISdkBvW0a9CgQRgzZozTh1arBcB6PLNnz8akSZNQUFAAtVpJKZITtv2wsLUOQxSwkon5H5HHj/zLY++ncOEUaHjr7I0XuiXzfvhdG9zq4nDxrONzlRpYetBvqoR5RVXYWFxJlHuVvfTGA2SxCJzhSUxMxLp163Du3Dk0NTWhqalJjsMp4FL7YZ4eDgB8d8qHQfswPVn18EId8PZtHhkgvZYiJu15m/HMrQiBsSJKT0GjZlfVXrtvous74Z+WWuuTmi0xxAT3E2PDfVN64yayGJ+vv/4aVVVVKCoqQnx8PIYOHWp7KMjH0rkjoKMcP1JdmI89zvu3sdMvvgRq3W6PZVeHRhsEYwdPXsCGr3/yOPicV1SFDTtOoKz2AtpNNCxW4NSFbryx96RrO+g1QWB9Iq7w6FzkJD7GgOIVs3xXeuMGspxNVlYWGIYhPhTkg9Ko8eANjtXfYwZH+VYyM0wPLPwcmLVK+Nr+Vz3yfrb/8XrwbaiZtmJjUZXH0y+Sl+BWcubWO4S5PaRGiz7k9gnDBGNJsTJ0NpGIwDwrBY9ZljkK6amXs4H31bX4RzLzhhWAPtpxzNQKbBjndu1XhEGLycnkDGdPM7lJN0K34iL1hM6iydd7dC5SwN1gjAbHeFMg1HCJoRifEIPSqAUBWr9IZmooYNoS4XjnaWDTRLc9ILHaLk9zV/jdKSJ1GjfjIoRKMLFsbx/AiaC1dbPva2JsOHICMM5jj2J8QhC/lFqQECum7DgF7Fzr1q7E7uBWD8vdT7c5el/R4Vr34iJhvBQGbaRfe2/tr212MIcJMYaAjPPYE7hnpuA5fCkFf0lmaihy5jMA7HqBFd1ykeyMNIHIGAC8trvWrZovLqO5kVdIqnK3Y+rQcc6f+xi+DQ4EsbC+UIxPCMKXUti8swYzXyjxeQsaAMBjP4q/9kKKy/EfMZExE23FBjckRLIKDqCsplkwaSIFa52iDnP+3Mfwp6WBIBbWF4rxCUHsdZ0B9gda39Ll8xY0ANj2MCtFlq8tPcBbt7m8q+yMNExLJk8hXY1rHSa0kVk2d4R7DQF7TcCFGrsBFZBEkJb1IVNT4hy0vAM50MzR/xpE9wO4IOMrpVUw0Y6ejl+Cz4ZoQBfFyqzyaSi71GJmPfDNJlZ+VGcEln8n0DqmNGpMT4vDPoL4uSuBZ9piBU2Yj6hVavdiI+/8htWs5ohO8HmwmbawNW4H6lowJTnWJrDPPQ/kQDOHYnxCEK4q/KNDjahv6XJ4zW8p9su/v1RkStC9yeX1QDe3sXKkK34CIoc4vCTWGqi8uhn0HKtTI5JfUg0Lwfi4ZZB7TUB9Ge98O3webOY6UwDAnqrzKK9pxtuLpoLSeNjS2Q8o064Qhh/HmJ7ixzuiIRr402nxADSJ9aMFMSEx47mv7oLTKSVtseKjQ43E19wyyG/fIRSHH3y1638vEXyDWVbTjDxCYXEgoxifEGbpnJHIudRWJydzFLY+MM2/S6+i0htO4LXjyc5IE5SQcDjzYPJLqgVeoNFAua9n3EBILrz3Q9f/XiJIBlOgXBjgKNOuEIabfpl6aGQVHMA/SqsAAIMitLhzUjyWzvFDHoghGpj5JLvU7grmduD5oWyjPUM0KI0aOkoNMy1ctRPzYEheT2JsOIpXzHL/+gWZ0Wq/FJM+NDMFm4orHaaRbd29Tv4i8FA8n37AwsKDKK9tgZm2wkxb0dhq8qouymtmrRQm6TnFCqxNtuUFkaRDdJQai65LIv513qX2x/bcOn6o+4an1wTw84F0ke7tQyI276oVxK/MtIica4CiGJ9+gJhA1r6a88Rx2dFQwOM/sY0H1RT77+pTwNNtgFFMOpdhm/F1t+KOCcJ8HzNtxbxNe4h5TKQi0gOetAveeqdQr3mqc2lguSBPMYMguccOxfj0A8QEsvjtYnyKLoJdAftbM/sv1+HhkXKhHAcHwwBrk7CsYi4yEoWB68YL3bjvjf0uJVK6LS/baxKK5Ks0His0egNtsRKvcWCE1ufn4g2K8ekHFGRNJgZpz3WYfZ/x3Be6CGBVA1srJYLa3I43f74Tx/X3w4g2h9fKapoFBoiUvRxJmLo55Z3fQFBMqlL5pZ5r444TAmlZgJXPCCYU49MP0GspLJkpXNEx09bAXJ7VRQAr69gWwyKoAOhA47D+YcSCsOxcVAXaYsWGr07g40OnoOHNSEh1Yk5p+p5wEhr39iERb5WTM8anpQ708Zl4h2J8+glL545AfLRwVabwm7rA834A1qOY+1fx0gywBkgFoEL3KHZpH4EBl6eRHx1qwOx1pdhYXImGC92wMI5/N83d8gOaMEWNn+LePiTC1Cv8vIyGsKDIarZHMT79BEqjxm8nJwrG27pp/616uYIhGniiGmLBVBXY2U+CqhU/6hbh3bCnoUUPzrSbBZXrAKBRwX09Y3MnQBMys8UE82WGFNvJSk8OaPkMEsF1tgpekZ2RhuEE7+ejQ42B6f1wDBgI/PU8cL2TaZiKfUxXn8BxbRaMVnGBebd1bl4hiOJHJ/pNLD4pboDD84QYA5bOHeGXc/EGJcmwH0Fp1EiOG4BTrY4lC/UtXcgrqkLOTaP8dGYuoKGAzL8CN+QAeVNYRUQCXBpOhe5R8X09LcH5PFzW9zYyMS0lDmXVrCyICsBvJiUEndcDKJ5Pv0NMaqHgG2nbEMuGLgJ4/BiQ84PoJpwXJPbwGr3xcmqAH8jOSMPyS2UzgdgSx1VUTAC3lGhvb4fRaERbWxuiotxo5qYgCm2x4r439qOsRjgtSYwNx50T4yXrBio7vSbgrdvANJQBjESGxRWSZwJZ/89HBxPKZwTS5+PNb1SZdvUzSALzHPUtXTaZhmWZQSDNEKYHFm2HxdyFM5tuRnzndwB8YIR83KUiv6QaL+84AQbA3io2Kz0oPp8+CAzzqeBT+pKQ8IvgmBdQunAkPLEbGapXQTNsIrTDA8JeEx6hNwI3POlz4bADdS2282cAvLm3BqYez9pPBxKK59MPyc5Iwz9KKmG2kH+SgdbT21VaEIuRPf8SjMfHGFD6+OyAmaq4y6SkaOypulyH19bNqhS89xBhFS6ICM5PQ8ErKI0aE5PIBiY+xhCUAUxnwfLGC92Y//q+4Aio86AtVpRXC+NzJC3qYEMxPv0UsXovMIytNCGYyC+pRrtJfCpSXuunzq1ewC0OkDSrQwHF+PRT9FoKS2alCsYbW03YWFzpcnV4IEBbrPiwoqHP7YIpluVsVRJgBeGCHcX49GOWzhkpWmBZVtMcNJ5Cfkk1GlyQBwmmWFZ+SbWo4QGAOyeK6R4FD4rx6ceINeLjKNjrXjdQf+BMGN4eFQArQ9bBCSS4SvxXLkne8lEBWDZnZFCWU/CR3fiYzWZce+21UKlU+Pbbb+U+nIKbZGekYdmckcTcn9buXrzsRjdQX0JbrNi4oxJz1u8USKQCwo6dDIBN/pSOdZH8kmpsLK4U9FvjmJ4ah5ybRgXtyp09sl/Bk08+iWHD3GxFq+AzKI0aOTeNwvBoA/F1BsD+WnH3319wiXckwwMAkxOjER/jeE0MAj/u4+z8dJQaBVmTfXg28iKr8fniiy/w1VdfYd26dS5tbzab0d7e7vBQ8A3OepUT+uz5HfvEO3v0lBrpqXF4a9E0JPOqv4HAjvvQFiuxqSHH4Cg99NrQSc2TzficPXsWixcvxttvv43wcNdU43Jzc2E0Gm2PhITgD6oFC1yPL4ow/Wq80BVwsRJSe+T01DgcfeZmvPvgdOi1lMDQGA1UQMd9+goyO7tBBCOyGB+GYZCVlYUlS5Zg8mTX3cTVq1ejra3N9mho6Hv5VEEauB5fQ6KEwuwNF7oDL1bCCI2kWgWHWEh2RhpyMkfZVvTaumlsLKrC7BdLsX77T5j/+r6ACqiLTbkSY8ORkzkKS+cEfz2XPW75cKtWrcLatWudbnPs2DF89dVX6OjowOrVq906GZ1OB53OjXa6CpITHxOORp7eD8AKjnGZz/6ssOYqvLeU1Qle489YOIN6oK7FITbU2NqNvEurSYFQqElbrMgrqsL3p9oEr3nc3DAIcMv4rFixAllZWU63SU1NRXFxMcrKygSGZPLkybj33nuxZcsWt09UwTeonVS8c96PPyus84orsbGIvAwtcuqYkhzrUBtlz+WAuv+MD7fCReL2CcNC0vAAbhqfQYMGYdCgQX1ut2nTJjz33HO256dPn8bNN9+M999/H9OmTXP/LBV8hjN1p4K9tYgyhDlUWPt69chZP3IxobTsjDR8UNFA1HQG/B9Qd/oeEqaXoYIsofPEREeh8ogIVvUtLS0N8fHiSW0K/kfMewDYvJ9Wu37gKvhu9Yibbp1qdTQgGrUK6alxtikgCUqjxo6cmVhYeBAH6lpA86yNz0TIRHDmmVXUh2ZdF6BkOCvwmJoS12fTXZUKSE+J8amEJ5fXI4jrqICtD0zrUxRer6Xw7oPTiUHbo6fa/Bp4zs5Iw/QUshEP5NQAb/FJ0kBycjICWK1VwQ7OmHBBWlISH8MADa0mvOvDWM/+2mZiXs+ExBi39pOdkYb8kkr02GkZtZtonyo4cgHmT749BYZhMDzaIGjfrKfUeGhmWlDKm7hK6GQsKUgCt0IEABt3VNp+lHya2oQrYlJir1s8KTEGJ5sdjaBGrcLU5Fi3M34pjRpqlQokbUNfxa827jiBPLvUBX5RrArAw7NHhIRUqjMU46MgSnZGGsprmomJb0OM8vasstctJsVDhhn1eHvRVI9Wgq5NiCb2OvfVFEes3TEARBvCsPC6lJD2eDiUmI+CKJRGjbcXTRXEI1QAwDDY8PVPssVJxMonOLxJfCxcOAVResf7ri8VHM2EdscA+74uvC7F/aaGQYri+Sg4hdKoUbhwCrIKDuDAyRZYrOyEpbHVhI1FVVCr1JJOD7jplljBqD2eTpP0Wgr7/zQXCwsP4tiZdowZEokpyTHIKjiACQlGHKi7gONNHRg7NAoFWZMlqacy9dBYWHgQP55ug5UX/4zUU7hmuBFTU+L6hcfDoRgfhT7ZvKuWOE0BgA8rGkBbLPj0yBkAwO3XDsfSuSM8vnPbT7f4aNQqW+Glt8v83OoXAKz/8rgtBmM/xSuracbCwoO27bxhwZtkOdQoPYVvVmYgwhD8yoTuEvq+nYLXOPMwGi50I++Sp1Lf0uW1BKuz6ZbFyiA9NU7yTp3OYjBlNc1Y/+Vxr6eXB0+S83XaTTRe21Pr1b6DFcXzUegTZ0lwJMpqmpFXXImcG0cLXiN13wRYj2d/bTNO9jHd0qhV2PqAtFnyYjEYjrySalAajVvTS+4699c2g7YwEOlSBIDN2ia9V6GOYnwU+iQ7Iw1WxopPDp8GwK407at1HhAW+0HxV7He3FuDMYMjXe7QIMeKlNjqlz1v7q3FvtpmMAybBc7FZ8Sml86mj3ycdd0IZZRe7Qpuw93VPzrUKBoYptQqLJ0zEg/NTMErpTX4+HAj2k29MPVaYRaRCO2L9NQ4j5fXncEFg/fXNjv1UPgsmzMSOTeNsiUNfny4EW2Xyk8ummmX95UQY8DulXM8OHP/481vVDE+Ch4z//V9fU7HjIYw2w/SG3whLXHD2mKXumBwGA1hGDfcCIuVcSoC1hfL5o4I2mmXN79RZdql4DGuxIKkMDwAcOfEeNlzX1RuVpi2dfe6FQvjGG7UQ61WQaVS4fYJw0JOJMxVFOOj4DHZGWkoqz7fZ7zEG3SUGktmpfok/+X2CcNEtYK8JTE2HImx4X4RYAtUFOOj4DGURo2tD0yzrV6JFaJ6w+SkGJ9NSZbOGQm1Sm1bdRPT/yGhVrGek5gA/J0T40O+VstdFOOj4BWuFqJ6ggriAmFycPlaRjoslZfXtjjtKgEAU5NjcbrNRDS+ibHh/Spz2VUU309BMrIz0pCe6r2xSIwNlzyR0F04Q/TO4ukY1kcRrY5iS1BI3SVU8E28KhhRPB8FyeAKUblpmCerQNyPNZCmKHdMHO4QC+ILcnD9tOynbVZePpCCEMX4KEiK/TSMtlhF2xkDwLTkGExPi8PBugsB/WPljAqXlU1bLA56PJzHYz9tU+gbxfgoyAalUePOifEOmb7pqXHQqFVBtepjb1AB1qhSGo2gRETBPRTjoyAr9rKswWRwnME3RgqeoRgfBVlRfqgKYgT3LUhBQSFoUYyPgoKCX1CMj4KCgl9QjI+CgoJfUIyPgoKCXwjo1S5Oaqi9vb2PLRUUFPwB99v0RBYsoI1PR0cHACAhIcHPZ6KgoOCMjo4OGI1Gt/4moJUMrVYrTp8+jcjISKdCT+3t7UhISEBDQ0PIKB4q1xQc9PdrYhgGHR0dGDZsGNRq96I4Ae35qNVqxMfHu7x9VFRUyHwBOJRrCg768zW56/FwKAFnBQUFv6AYHwUFBb8QEsZHp9Phqaeegk6n8/epSIZyTcGBck2eE9ABZwUFhdAlJDwfBQWF4EMxPgoKCn5BMT4KCgp+QTE+CgoKfkExPgoKCn4hII1Pfn4+kpOTodfrMW3aNOzfv9/p9h988AHGjBkDvV6PcePG4b///a/D6wzD4G9/+xuGDh0Kg8GAzMxMVFZWynkJAty5ptdeew033HADYmJiEBMTg8zMTMH2WVlZUKlUDo958+bJfRkOuHNNhYWFgvPV6x37YQXC5wS4d12zZ88WXJdKpcItt9xi28afn9WuXbvwq1/9CsOGDYNKpcK2bdv6/JvS0lJMnDgROp0OI0aMQGFhoWAbd3+jRJgA47333mO0Wi3z5ptvMj/88AOzePFiJjo6mjl79ixx+7179zIajYZ54YUXmB9//JH5y1/+woSFhTHff/+9bZs1a9YwRqOR2bZtG3PkyBHm17/+NZOSksJ0d3cH5DXdc889TH5+PnP48GHm2LFjTFZWFmM0GpnGxkbbNgsWLGDmzZvHnDlzxvZoaWnxyfUwjPvXVFBQwERFRTmcb1NTk8M2/v6cGMb962pubna4pqNHjzIajYYpKCiwbePPz+q///0v8+c//5n5+OOPGQDMJ5984nT7mpoaJjw8nHnssceYH3/8kcnLy2M0Gg2zfft22zbuvkdiBJzxmTp1KpOdnW17brFYmGHDhjG5ubnE7X/3u98xt9xyi8PYtGnTmIceeohhGIaxWq3MkCFDmBdffNH2emtrK6PT6Zh3331XhisQ4u418aFpmomMjGS2bNliG1uwYAFz6623Sn2qLuPuNRUUFDBGo1F0f4HwOTGM95/Vhg0bmMjISKazs9M25u/PisMV4/Pkk08yV111lcPYXXfdxdx88822596+RxwBNe3q6elBRUUFMjMzbWNqtRqZmZkoKysj/k1ZWZnD9gBw880327avra1FU1OTwzZGoxHTpk0T3aeUeHJNfLq6utDb24vY2FiH8dLSUlxxxRUYPXo0Hn74YTQ3u9cd1FM8vabOzk4kJSUhISEBt956K3744Qfba/7+nABpPqs33ngDd999NwYMGOAw7q/Pyl36+j1J8R7Z/s7705WO8+fPw2KxYPDgwQ7jgwcPRlNTE/FvmpqanG7P/evOPqXEk2vis3LlSgwbNszhA583bx7eeustFBUVYe3atdi5cyd+8YtfwGKxSHr+JDy5ptGjR+PNN9/Ep59+iq1bt8JqtWLGjBlobGwE4P/PCfD+s9q/fz+OHj2KBx54wGHcn5+Vu4j9ntrb29Hd3S3J95kjoCU1FIA1a9bgvffeQ2lpqUOA9u6777b9f9y4cbjmmmuQlpaG0tJSzJ071x+n6pT09HSkp6fbns+YMQNjx47F5s2b8eyzz/rxzKTjjTfewLhx4zB16lSH8WD7rHxFQHk+AwcOhEajwdmzZx3Gz549iyFDhhD/ZsiQIU635/51Z59S4sk1caxbtw5r1qzBV199hWuuucbptqmpqRg4cCCqqqq8Pue+8OaaOMLCwjBhwgTb+fr7cwK8u66LFy/ivffew6JFi/o8ji8/K3cR+z1FRUXBYDBI8tlzBJTx0Wq1mDRpEoqKimxjVqsVRUVFDndNe9LT0x22B4Cvv/7atn1KSgqGDBnisE17ezv27dsnuk8p8eSaAOCFF17As88+i+3bt2Py5Ml9HqexsRHNzc0YOnSoJOftDE+vyR6LxYLvv//edr7+/pwA767rgw8+gNlsxvz58/s8ji8/K3fp6/ckxWdvw63wtA947733GJ1OxxQWFjI//vgj8+CDDzLR0dG2Zdn77ruPWbVqlW37vXv3MhRFMevWrWOOHTvGPPXUU8Sl9ujoaObTTz9lvvvuO+bWW2/1+VK7O9e0Zs0aRqvVMh9++KHD8mxHRwfDMAzT0dHBPP7440xZWRlTW1vL7Nixg5k4cSIzcuRIxmQyBeQ1PfPMM8yXX37JVFdXMxUVFczdd9/N6PV65ocffnC4bn9+Tp5cF8f111/P3HXXXYJxf39WHR0dzOHDh5nDhw8zAJiXXnqJOXz4MHPy5EmGYRhm1apVzH333Wfbnltqf+KJJ5hjx44x+fn5xKV2Z++RqwSc8WEYhsnLy2MSExMZrVbLTJ06lSkvL7e9NmvWLGbBggUO2//73/9mRo0axWi1Wuaqq65iPv/8c4fXrVYr89e//pUZPHgwo9PpmLlz5zI//fSTLy7FhjvXlJSUxAAQPJ566imGYRimq6uLuemmm5hBgwYxYWFhTFJSErN48WK3P3xfXtPy5ctt2w4ePJj5n//5H+bQoUMO+wuEz4lh3P/+HT9+nAHAfPXVV4J9+fuzKikpIX6XuGtYsGABM2vWLMHfXHvttYxWq2VSU1MdcpY4nL1HrqLo+SgoKPiFgIr5KCgo9B8U46OgoOAXFOOjoKDgFxTjo6Cg4BcU46OgoOAXFOOjoKDgFxTjo6Cg4BcU46OgoOAXFOOjoKDgFxTjo6Cg4BcU46OgoOAX/j+g0suh36aqyQAAAABJRU5ErkJggg==\n" 186 | }, 187 | "metadata": {} 188 | } 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "source": [ 194 | "#@title GMM head\n", 195 | "import torch\n", 196 | "import torch.nn as nn\n", 197 | "import torch.optim as optim\n", 198 | "from torch.utils.data import DataLoader\n", 199 | "import numpy as np\n", 200 | "import matplotlib.pyplot as plt\n", 201 | "\n", 202 | "class MatrixLinear(nn.Module):\n", 203 | " def __init__(self, input_dim, output_dim):\n", 204 | " \"\"\"\n", 205 | " Args:\n", 206 | " input_dim (int): The size of each input sample.\n", 207 | " output_dim (list): The dimensions of the output tensor.\n", 208 | " \"\"\"\n", 209 | " super(MatrixLinear, self).__init__()\n", 210 | " self.input_dim = input_dim\n", 211 | " self.output_dim = output_dim\n", 212 | " self.output_flatten_dim = int(torch.prod(torch.tensor(output_dim)))\n", 213 | "\n", 214 | " # Create a weight matrix with shape [input_dim, output_flatten_dim]\n", 215 | " self.linear = nn.Linear(input_dim, self.output_flatten_dim)\n", 216 | "\n", 217 | " def forward(self, x):\n", 218 | " \"\"\"\n", 219 | " Args:\n", 220 | " x (Tensor): Input tensor of shape (batch_size, context_length, input_dim)\n", 221 | " Returns:\n", 222 | " Tensor: Output tensor of shape (batch_size, context_length, *output_dim)\n", 223 | " \"\"\"\n", 224 | " y = self.linear(x)\n", 225 | " output = y.view(*y.shape[:-1], *self.output_dim)\n", 226 | " return output\n", 227 | "\n", 228 | "\n", 229 | "class GMM(nn.Module):\n", 230 | " def __init__(self, hidden_dim, output_dim, num_components,\n", 231 | " base = nn.Identity(),\n", 232 | " sigma_lower_bound = 1e-6):\n", 233 | " super(GMM, self).__init__()\n", 234 | " self.num_components = num_components\n", 235 | " self.output_dim = output_dim\n", 236 | " self.hidden_dim = hidden_dim\n", 237 | " self.base = base\n", 238 | " self.log_pi_head = nn.Linear(hidden_dim, num_components)\n", 239 | " self.log_sigma_head = MatrixLinear(hidden_dim, [num_components, output_dim])\n", 240 | " self.mu_head = MatrixLinear(hidden_dim, [num_components, output_dim])\n", 241 | " self.sigma_lower_bound = sigma_lower_bound\n", 242 | "\n", 243 | " def forward(self, x, y=None):\n", 244 | " x = self.base(x)\n", 245 | " log_pi = torch.nn.functional.log_softmax(self.log_pi_head(x), dim=1)\n", 246 | " mu = self.mu_head(x)\n", 247 | " log_sigma = self.log_sigma_head(x)\n", 248 | " gmm_params = {'log_pi': log_pi, 'log_sigma': log_sigma, 'mu': mu}\n", 249 | "\n", 250 | " if y is None:\n", 251 | " return gmm_params\n", 252 | " else:\n", 253 | " loss = self.nll_loss(gmm_params, y)\n", 254 | " return gmm_params, loss\n", 255 | "\n", 256 | " def sample(self, x, num_samples=5):\n", 257 | " gmm_params = self.forward(x)\n", 258 | " log_pi = gmm_params['log_pi']\n", 259 | " log_sigma = gmm_params['log_sigma']\n", 260 | " mu = gmm_params['mu']\n", 261 | "\n", 262 | " pi = torch.exp(log_pi)\n", 263 | " sigma = torch.exp(log_sigma) + self.sigma_lower_bound\n", 264 | " categorical = torch.distributions.Categorical(pi)\n", 265 | " component_index = categorical.sample((num_samples,))\n", 266 | " component_index = component_index.unsqueeze(-1).unsqueeze(-1)\n", 267 | "\n", 268 | " #mu_expanded: num_samples * Batch * Length * Components * Dim\n", 269 | " #component: num_samples * Batch * Length * 1 * 1\n", 270 | " selected_mu = torch.gather(mu.unsqueeze(0).expand(num_samples, *mu.size()), -2, component_index).squeeze(2)\n", 271 | " selected_sigma = torch.gather(sigma.unsqueeze(0).expand(num_samples, *mu.size()), -2, component_index).squeeze(2)\n", 272 | "\n", 273 | " normal = torch.distributions.Normal(selected_mu, selected_sigma)\n", 274 | " samples = normal.rsample()\n", 275 | "\n", 276 | " return samples\n", 277 | "\n", 278 | " # Negative log-likelihood loss\n", 279 | " def nll_loss(self, gmm_params, y, reduction='mean'):\n", 280 | " log_pi, log_sigma, mu = gmm_params['log_pi'], gmm_params['log_sigma'], gmm_params['mu']\n", 281 | " if y.dim() < mu.dim(): y = y.unsqueeze(-2)\n", 282 | " sigma = torch.exp(log_sigma) + self.sigma_lower_bound\n", 283 | " logp = torch.sum(-0.5*((y- mu)**2/sigma**2) - log_sigma, dim=-1) + log_pi\n", 284 | " nll = -torch.logsumexp(logp, dim = -1)\n", 285 | "\n", 286 | " if reduction == 'mean':\n", 287 | " return torch.mean(nll)\n", 288 | " elif reduction == 'none':\n", 289 | " return nll\n", 290 | " elif reduction == 'sum':\n", 291 | " return torch.sum(nll)\n", 292 | " else:\n", 293 | " raise ValueError(f\"Invalid reduction mode: {reduction}\")\n", 294 | "\n", 295 | "\n" 296 | ], 297 | "metadata": { 298 | "id": "j1UGfEc4vA0V" 299 | }, 300 | "execution_count": 22, 301 | "outputs": [] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "source": [ 306 | "#@title Gaussian regression\n", 307 | "gmm_input_dim = 1\n", 308 | "gmm_output_dim = 1\n", 309 | "num_components = 1\n", 310 | "hidden_dim = 64\n", 311 | "\n", 312 | "x, y = next(iter(dataloader))\n", 313 | "\n", 314 | "backbone = nn.Sequential(nn.Linear(gmm_input_dim, hidden_dim),nn.ReLU(),nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),)\n", 315 | "model = GMM(hidden_dim, gmm_output_dim, num_components, base = backbone)\n", 316 | "\n", 317 | "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", 318 | "num_epochs = 200\n", 319 | "\n", 320 | "loss_curve = []\n", 321 | "for epoch in range(num_epochs):\n", 322 | " model.train()\n", 323 | " total_loss = 0\n", 324 | " for x_batch, y_batch in dataloader:\n", 325 | " optimizer.zero_grad()\n", 326 | " _, loss = model(x_batch, y_batch)\n", 327 | " loss.backward()\n", 328 | " optimizer.step()\n", 329 | " total_loss += loss.item()\n", 330 | "\n", 331 | " loss_curve.append(total_loss)\n", 332 | " if (epoch + 1) % 50 == 0:\n", 333 | " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(dataloader):.4f}')\n", 334 | "\n", 335 | "# Plotting the results\n", 336 | "model.eval()\n", 337 | "\n", 338 | "x_test = torch.rand_like(x_train)\n", 339 | "y_pred = model.sample(x_test, num_samples=1)\n", 340 | "\n", 341 | "plt.subplot(221)\n", 342 | "plt.plot(loss_curve)\n", 343 | "plt.xlabel('Epoch')\n", 344 | "plt.title('Training Loss Curve')\n", 345 | "\n", 346 | "plt.subplot(222)\n", 347 | "plt.scatter(x_train, y_train, label='Data', s=10)\n", 348 | "plt.scatter(x_test.squeeze().detach().numpy(), y_pred.squeeze().detach().numpy(), label='Predicted', s=10);\n", 349 | "plt.title('Training & Predicted Data')\n", 350 | "plt.legend()" 351 | ], 352 | "metadata": { 353 | "colab": { 354 | "base_uri": "https://localhost:8080/", 355 | "height": 357 356 | }, 357 | "id": "ZnNrv2wvvJ6D", 358 | "outputId": "990029aa-369a-46e9-8eeb-7e6147b7d3dd" 359 | }, 360 | "execution_count": 23, 361 | "outputs": [ 362 | { 363 | "output_type": "stream", 364 | "name": "stdout", 365 | "text": [ 366 | "Epoch [50/200], Loss: 1.1436\n", 367 | "Epoch [100/200], Loss: 1.0868\n", 368 | "Epoch [150/200], Loss: 1.0772\n", 369 | "Epoch [200/200], Loss: 1.0709\n" 370 | ] 371 | }, 372 | { 373 | "output_type": "execute_result", 374 | "data": { 375 | "text/plain": [ 376 | "" 377 | ] 378 | }, 379 | "metadata": {}, 380 | "execution_count": 23 381 | }, 382 | { 383 | "output_type": "display_data", 384 | "data": { 385 | "text/plain": [ 386 | "
" 387 | ], 388 | "image/png": "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\n" 389 | }, 390 | "metadata": {} 391 | } 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "source": [ 397 | "#@title GMM regression\n", 398 | "gmm_input_dim = 1\n", 399 | "gmm_output_dim = 1\n", 400 | "num_components = 2\n", 401 | "hidden_dim = 64\n", 402 | "\n", 403 | "x, y = next(iter(dataloader))\n", 404 | "\n", 405 | "backbone = nn.Sequential(nn.Linear(gmm_input_dim, hidden_dim),nn.ReLU(),nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),)\n", 406 | "model = GMM(hidden_dim, gmm_output_dim, num_components, base = backbone)\n", 407 | "\n", 408 | "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", 409 | "num_epochs = 200\n", 410 | "\n", 411 | "loss_curve = []\n", 412 | "for epoch in range(num_epochs):\n", 413 | " model.train()\n", 414 | " total_loss = 0\n", 415 | " for x_batch, y_batch in dataloader:\n", 416 | " optimizer.zero_grad()\n", 417 | " _, loss = model(x_batch, y_batch)\n", 418 | " loss.backward()\n", 419 | " optimizer.step()\n", 420 | " total_loss += loss.item()\n", 421 | "\n", 422 | " loss_curve.append(total_loss)\n", 423 | " if (epoch + 1) % 50 == 0:\n", 424 | " print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(dataloader):.4f}')\n", 425 | "\n", 426 | "# Plotting the results\n", 427 | "model.eval()\n", 428 | "\n", 429 | "x_test = torch.rand_like(x_train)\n", 430 | "y_pred = model.sample(x_test, num_samples=1)\n", 431 | "\n", 432 | "plt.subplot(221)\n", 433 | "plt.plot(loss_curve)\n", 434 | "plt.xlabel('Epoch')\n", 435 | "plt.title('Training Loss Curve')\n", 436 | "\n", 437 | "plt.subplot(222)\n", 438 | "plt.scatter(x_train, y_train, label='Data', s=10)\n", 439 | "plt.scatter(x_test.squeeze().detach().numpy(), y_pred.squeeze().detach().numpy(), label='Predicted', s=10);\n", 440 | "plt.title('Training & Predicted Data')\n", 441 | "plt.legend()" 442 | ], 443 | "metadata": { 444 | "colab": { 445 | "base_uri": "https://localhost:8080/", 446 | "height": 357 447 | }, 448 | "id": "jmiz-iUChbF6", 449 | "outputId": "34fe49ad-eeef-4f5d-a711-36ec44af5b3f" 450 | }, 451 | "execution_count": 25, 452 | "outputs": [ 453 | { 454 | "output_type": "stream", 455 | "name": "stdout", 456 | "text": [ 457 | "Epoch [50/200], Loss: 0.4920\n", 458 | "Epoch [100/200], Loss: -0.6785\n", 459 | "Epoch [150/200], Loss: -0.7278\n", 460 | "Epoch [200/200], Loss: -0.7442\n" 461 | ] 462 | }, 463 | { 464 | "output_type": "execute_result", 465 | "data": { 466 | "text/plain": [ 467 | "" 468 | ] 469 | }, 470 | "metadata": {}, 471 | "execution_count": 25 472 | }, 473 | { 474 | "output_type": "display_data", 475 | "data": { 476 | "text/plain": [ 477 | "
" 478 | ], 479 | "image/png": "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\n" 480 | }, 481 | "metadata": {} 482 | } 483 | ] 484 | }, 485 | { 486 | "cell_type": "markdown", 487 | "source": [], 488 | "metadata": { 489 | "id": "DE96a4cGvHbs" 490 | } 491 | } 492 | ] 493 | } --------------------------------------------------------------------------------