File size: 61,322 Bytes
d5bfab8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 |
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "929a1d7b-51a8-44ed-ab3b-8b2a2baa31dc",
"metadata": {},
"outputs": [],
"source": [
"import arc_json_model as ajm\n",
"from visualize import ajm_image_show\n",
"\n",
"ajm.Image.show = ajm_image_show"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "bcc018d5-5c3e-4acc-a9fd-e670d8a21c27",
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import numpy as np\n",
"from torchvision import datasets\n",
"import torchvision.transforms as transforms\n",
"from torchsummary import summary\n",
"from tqdm import tqdm\n",
"\n",
"\n",
"device = torch.device(\"mps\")\n",
"#device = torch.device(\"cuda\")\n",
"#device = torch.device(\"cpu\")\n"
]
},
{
"cell_type": "code",
"execution_count": 109,
"id": "fbaa81fe-7682-4cb3-9f57-fe94d5dd4fa4",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAc4AAAHqCAYAAACN266QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAjHElEQVR4nO3de3BU9fnH8c9mIZuIycqdRBJuChEQFBAMiDdQy2QQdUTUOEai44wTFMrIKGVsYCgGbEu9IYJ1wKrcREFlxIgoIEUlgFHwwkVFUkDQDuxClEV3z++PTvPrNhfyhGzOLn2/Zr5/7MmePc9sL2/OOZuNx3EcRwAAoF6S3B4AAIBEQjgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDiBONK5c2fdddddbo9R5corr9SVV17p9hhAXCGcgMGmTZs0depUHT161O1R6u3o0aO699571bZtW7Vo0UJXXXWVtm3b5vZYQMLy8F21QP396U9/0qRJk/Ttt9+qc+fOjf76oVBISUlJat68eaO8XiQS0dChQ/Xpp59q0qRJatOmjZ555hlVVFRo69atOv/88+vc/+TJk5Kk5OTkRpkHOBM0c3sA4EwViUR08uRJpaSk1Hsfn8/XqDMsX75cmzZt0iuvvKKbb75ZknTLLbeoe/fuKi4u1qJFi+rcn2AC1XGpFqinqVOnatKkSZKkLl26yOPxyOPxaO/evZIkj8ejcePG6eWXX1avXr3k8/n09ttvS/rXmergwYPVunVrpaamqn///lq+fHm1Y/z3Pc6FCxfK4/Ho73//uyZOnFh1ufXGG2/UDz/8cMqZly9frvbt2+umm26q2ta2bVvdcsstev311xUKherc/7/vca5bt04ej0fLli3TjBkz1LFjR6WkpGjYsGHas2fPKecBzgSccQL1dNNNN2nXrl1avHix/vKXv6hNmzaS/hWif3vvvfe0bNkyjRs3Tm3atKm6nPvEE0/o+uuvV35+vk6ePKklS5Zo9OjRWrVqlfLy8k557Pvvv18tW7ZUcXGx9u7dq8cff1zjxo3T0qVL69zvk08+Ub9+/ZSUFP1v5IEDB2r+/PnatWuXLrzwQuM7Ic2cOVNJSUl68MEHFQgE9Nhjjyk/P18ff/yx+bWAREM4gXrq06eP+vXrp8WLF+uGG26o8R7nzp07tX37dvXs2TNq+65du5Samlr1eNy4cerXr59mz55dr3C2bt1a77zzjjwej6R/XQZ+8sknFQgE5Pf7a93v4MGDuvzyy6ttz8jIkCQdOHCgQeE8ceKEysvLqy7ltmzZUuPHj9eOHTvUu3dv8+sBiYRLtUAjuuKKK6pFU1JUNI8cOaJAIKChQ4fW+9Ot9957b1U0JWno0KEKh8P67rvv6tzv559/rvG+6b/vu/7888/1Ov5/Gzt2bNT9z6FDh0qSvvnmmwa9HpBIOOMEGlGXLl1q3L5q1Sr94Q9/UHl5edR9xf+MYV2ys7OjHrds2VLSvyJcl9TU1BrvY544caLq5w3R0HmAMwFnnEAjqilEH3zwga6//nqlpKTomWee0VtvvaU1a9bo9ttvV31/G8zr9da4/VT7Z2Rk6ODBg9W2/3tbZmZmvY7fWPMAZwLOOAGD+p4h/qdXX31VKSkpKi0tjbpsumDBgsYcrUYXXXSRPvjgA0UikagPCH388cc666yz1L1795jPAJxpOOMEDFq0aCFJpm8O8nq98ng8CofDVdv27t2rlStXNvJ01d188806dOiQXnvttaptP/74o1555RWNHDmy0X9vFPhfwBknYNC/f39J0pQpU3TrrbeqefPmGjlyZFVQa5KXl6fZs2frN7/5jW6//XYdPnxYc+bM0XnnnafPPvsspvPefPPNuvTSSzV27Fh98cUXVd8cFA6HNW3atJgeGzhTEU7A4JJLLtH06dP17LPP6u2331YkEtG3335bZzivvvpqPf/885o5c6YmTJigLl26aNasWdq7d2/Mw+n1evXWW29p0qRJevLJJ/Xzzz/rkksu0cKFC9WjR4+YHhs4U/FdtQAAGHCPEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGDT573FGIhEdOHBAaWlpDfr6MgAAYsFxHB07dkyZmZnV/obtf2rycB44cEBZWVlNfVgAAOqloqJCHTt2rPXnTX6pNi0trakPCQBAvZ2qU00eTi7PAgDi2ak6xYeDAAAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAQYPCOWfOHHXu3FkpKSkaNGiQNm/e3NhzAQAQl8zhXLp0qSZOnKji4mJt27ZNffv21XXXXafDhw/HYj4AAOKLYzRw4ECnqKio6nE4HHYyMzOdkpKSeu0fCAQcSSwWi8VixeUKBAJ1dsx0xnny5Elt3bpVw4cPr9qWlJSk4cOH68MPP7S8FAAACamZ5ck//vijwuGw2rdvH7W9ffv2+uqrr2rcJxQKKRQKVT0OBoMNGBMAgPgQ80/VlpSUyO/3V62srKxYHxIAgJgxhbNNmzbyer06dOhQ1PZDhw6pQ4cONe4zefJkBQKBqlVRUdHwaQEAcJkpnMnJyerfv7/Wrl1btS0SiWjt2rXKzc2tcR+fz6f09PSoBQBAojLd45SkiRMnqqCgQAMGDNDAgQP1+OOPq7KyUmPHjo3FfAAAxBVzOMeMGaMffvhBv//97/X999/roosu0ttvv13tA0MAAJyJPI7jOE15wGAwKL/f35SHBACg3gKBQJ23FfmuWgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwMIdzw4YNGjlypDIzM+XxeLRy5coYjAUAQHwyh7OyslJ9+/bVnDlzYjEPAABxrZl1hxEjRmjEiBGxmAUAgLjHPU4AAAzMZ5xWoVBIoVCo6nEwGIz1IQEAiJmYn3GWlJTI7/dXraysrFgfEgCAmIl5OCdPnqxAIFC1KioqYn1IAABiJuaXan0+n3w+X6wPAwBAkzCH8/jx49qzZ0/V42+//Vbl5eVq1aqVsrOzG3U4AADijmP0/vvvO5KqrYKCgnrtHwgEatyfxWKxWKx4WIFAoM6OeRzHcdSEgsGg/H5/Ux4SAIB6CwQCSk9Pr/Xn/B4nAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADEzhLCkp0SWXXKK0tDS1a9dON9xwg3bu3Bmr2QAAiDumcK5fv15FRUX66KOPtGbNGv3yyy+69tprVVlZGav5AACIKx7HcZyG7vzDDz+oXbt2Wr9+vS6//PJ67RMMBuX3+xt6SAAAYioQCCg9Pb3Wnzc73ReXpFatWtX6nFAopFAoVPU4GAyeziEBAHBVgz8cFIlENGHCBA0ZMkS9e/eu9XklJSXy+/1VKysrq6GHBADAdQ2+VHvfffdp9erV2rhxozp27Fjr82o64ySeAIB4FZNLtePGjdOqVau0YcOGOqMpST6fTz6fryGHAQAg7pjC6TiO7r//fq1YsULr1q1Tly5dYjUXAABxyRTOoqIiLVq0SK+//rrS0tL0/fffS5L8fr9SU1NjMiAAAPHEdI/T4/HUuH3BggW666676vUa/DoKACCeNeo9ztP4lU8AAM4IfFctAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwMP1ZMeB0OXvcnqD+POe5PUH9JMp7mijvJ3AqnHECAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAwBTOuXPnqk+fPkpPT1d6erpyc3O1evXqWM0GAEDcMYWzY8eOmjlzprZu3aotW7bo6quv1qhRo/T555/Haj4AAOKKx3Ec53ReoFWrVvrjH/+ou+++u17PDwaD8vv9p3NIJDBnj9sT1J/nPLcnqJ9EeU8T5f0EAoGA0tPTa/15s4a+cDgc1iuvvKLKykrl5uY29GUAAEgo5nBu375dubm5OnHihM4++2ytWLFCPXv2rPX5oVBIoVCo6nEwGGzYpAAAxAHzp2p79Oih8vJyffzxx7rvvvtUUFCgL774otbnl5SUyO/3V62srKzTGhgAADed9j3O4cOHq1u3bpo3b16NP6/pjJN4/u9KlPtxUuLck0uU9zRR3k8gZvc4/y0SiUSF8b/5fD75fL7TPQwAAHHBFM7JkydrxIgRys7O1rFjx7Ro0SKtW7dOpaWlsZoPAIC4Ygrn4cOHdeedd+rgwYPy+/3q06ePSktLdc0118RqPgAA4oopnM8//3ys5gAAICHwXbUAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYGD6e5zA6fKc5/YEZx7eU6BpccYJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAg9MK58yZM+XxeDRhwoRGGgcAgPjW4HCWlZVp3rx56tOnT2POAwBAXGtQOI8fP678/Hw999xzatmyZWPPBABA3GpQOIuKipSXl6fhw4ef8rmhUEjBYDBqAQCQqJpZd1iyZIm2bdumsrKyej2/pKRE06ZNMw8GAEA8Mp1xVlRUaPz48Xr55ZeVkpJSr30mT56sQCBQtSoqKho0KAAA8cDjOI5T3yevXLlSN954o7xeb9W2cDgsj8ejpKQkhUKhqJ/VJBgMyu/3N3xiAABiKBAIKD09vdafmy7VDhs2TNu3b4/aNnbsWOXk5Oihhx46ZTQBAEh0pnCmpaWpd+/eUdtatGih1q1bV9sOAMCZiG8OAgDAwHSPszFwjxMAEM9OdY+TM04AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBg+kPWwOly9rg9Qf15znN7gvpJlPc0Ud5P4FQ44wQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAICBKZxTp06Vx+OJWjk5ObGaDQCAuNPMukOvXr307rvv/v8LNDO/BAAACctcvWbNmqlDhw6xmAUAgLhnvse5e/duZWZmqmvXrsrPz9e+fftiMRcAAHHJdMY5aNAgLVy4UD169NDBgwc1bdo0DR06VDt27FBaWlqN+4RCIYVCoarHwWDw9CYGAMBFHsdxnIbufPToUXXq1EmzZ8/W3XffXeNzpk6dqmnTpjV4QJxZnD1uT1B/nvPcnqB+EuU9TZT3EwgEAkpPT6/156f16yjnnHOOunfvrj17av9f7uTJkxUIBKpWRUXF6RwSAABXnVY4jx8/rq+//loZGRm1Psfn8yk9PT1qAQCQqEzhfPDBB7V+/Xrt3btXmzZt0o033iiv16vbbrstVvMBABBXTB8O+sc//qHbbrtN//znP9W2bVtddtll+uijj9S2bdtYzQcAQFwxhXPJkiWxmgMAgITAd9UCAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAAD058VA06X5zy3Jzjz8J4CTYszTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABiYw7l//37dcccdat26tVJTU3XhhRdqy5YtsZgNAIC408zy5CNHjmjIkCG66qqrtHr1arVt21a7d+9Wy5YtYzUfAABxxRTOWbNmKSsrSwsWLKja1qVLl0YfCgCAeGW6VPvGG29owIABGj16tNq1a6eLL75Yzz33XKxmAwAg7pjC+c0332ju3Lk6//zzVVpaqvvuu08PPPCAXnjhhVr3CYVCCgaDUQsAgITlGDRv3tzJzc2N2nb//fc7l156aa37FBcXO5JYLBaLxUqIFQgE6myh6YwzIyNDPXv2jNp2wQUXaN++fbXuM3nyZAUCgapVUVFhOSQAAHHF9OGgIUOGaOfOnVHbdu3apU6dOtW6j8/nk8/na9h0AADEG8ul2s2bNzvNmjVzZsyY4ezevdt5+eWXnbPOOst56aWX6v0agUDA9dNwFovFYrFqW6e6VGsKp+M4zptvvun07t3b8fl8Tk5OjjN//nzT/oSTxWKxWPG8ThVOj+M4jppQMBiU3+9vykMCAFBvgUBA6enptf6c76oFAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAgSmcnTt3lsfjqbaKiopiNR8AAHGlmeXJZWVlCofDVY937Niha665RqNHj270wQAAiEemcLZt2zbq8cyZM9WtWzddccUVjToUAADxyhTO/3Ty5Em99NJLmjhxojweT63PC4VCCoVCVY+DwWBDDwkAgOsa/OGglStX6ujRo7rrrrvqfF5JSYn8fn/VysrKaughAQBwncdxHKchO1533XVKTk7Wm2++WefzajrjJJ4AgHgVCASUnp5e688bdKn2u+++07vvvqvXXnvtlM/1+Xzy+XwNOQwAAHGnQZdqFyxYoHbt2ikvL6+x5wEAIK6ZwxmJRLRgwQIVFBSoWbMGf7YIAICEZA7nu+++q3379qmwsDAW8wAAENca/OGghgoGg/L7/U15SAAA6u1UHw7iu2oBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwMAUznA4rEceeURdunRRamqqunXrpunTp8txnFjNBwBAXGlmefKsWbM0d+5cvfDCC+rVq5e2bNmisWPHyu/364EHHojVjAAAxA1TODdt2qRRo0YpLy9PktS5c2ctXrxYmzdvjslwAADEG9Ol2sGDB2vt2rXatWuXJOnTTz/Vxo0bNWLEiJgMBwBAvDGdcT788MMKBoPKycmR1+tVOBzWjBkzlJ+fX+s+oVBIoVCo6nEwGGz4tAAAuM0xWLx4sdOxY0dn8eLFzmeffeb87W9/c1q1auUsXLiw1n2Ki4sdSSwWi8ViJcQKBAJ1ttAUzo4dOzpPP/101Lbp06c7PXr0qHWfEydOOIFAoGpVVFS4/qawWCwWi1XbOlU4TZdqf/rpJyUlRd8W9Xq9ikQite7j8/nk8/kshwEAIG6Zwjly5EjNmDFD2dnZ6tWrlz755BPNnj1bhYWFsZoPAID4YrlUGwwGnfHjxzvZ2dlOSkqK07VrV2fKlClOKBSq92sEAgHXT8NZLBaLxaptnepSrcdxmvZrf4LBoPx+f1MeEgCAegsEAkpPT6/153xXLQAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAwIJwAABoQTAAADwgkAgAHhBADAgHACAGBAOAEAMCCcAAAYEE4AAAzM4Tx27JgmTJigTp06KTU1VYMHD1ZZWVksZgMAIO6Yw3nPPfdozZo1evHFF7V9+3Zde+21Gj58uPbv3x+L+QAAiC+OwU8//eR4vV5n1apVUdv79evnTJkypV6vEQgEHEksFovFYsXlCgQCdXasmQx+/fVXhcNhpaSkRG1PTU3Vxo0ba9wnFAopFApVPQ4Gg5ZDAgAQV0yXatPS0pSbm6vp06frwIEDCofDeumll/Thhx/q4MGDNe5TUlIiv99ftbKyshplcAAA3OBxHMex7PD111+rsLBQGzZskNfrVb9+/dS9e3dt3bpVX375ZbXn13TGSTwBAPEqEAgoPT291p+bLtVKUrdu3bR+/XpVVlYqGAwqIyNDY8aMUdeuXWt8vs/nk8/nsx4GAIC41ODf42zRooUyMjJ05MgRlZaWatSoUY05FwAAccl8qba0tFSO46hHjx7as2ePJk2apJSUFH3wwQdq3rz5KfcPBoPy+/0NHhgAgFg61aVa8xlnIBBQUVGRcnJydOedd+qyyy5TaWlpvaIJAECiM59xni7OOAEA8azRzzgBAPhfRjgBADAgnAAAGBBOAAAMCCcAAAaEEwAAA8IJAIAB4QQAwIBwAgBgQDgBADAgnAAAGBBOAAAMCCcAAAZNHs4m/mMsAACYnKpTTR7OY8eONfUhAQCot1N1qsn/HmckEtGBAweUlpYmj8fTKK8ZDAaVlZWlioqKOv+GmtsSZU4pcWZlzsaXKLMmypxS4sz6vz6n4zg6duyYMjMzlZRU+3lls0Y7Yj0lJSWpY8eOMXnt9PT0uP4P+98SZU4pcWZlzsaXKLMmypxS4sz6vzyn3+8/5XP4cBAAAAaEEwAAgzMinD6fT8XFxfL5fG6PUqdEmVNKnFmZs/ElyqyJMqeUOLMyZ/00+YeDAABIZGfEGScAAE2FcAIAYEA4AQAwIJwAABgkfDjnzJmjzp07KyUlRYMGDdLmzZvdHqmaDRs2aOTIkcrMzJTH49HKlSvdHqlGJSUluuSSS5SWlqZ27drphhtu0M6dO90eq0Zz585Vnz59qn4BOjc3V6tXr3Z7rFOaOXOmPB6PJkyY4PYoUaZOnSqPxxO1cnJy3B6rVvv379cdd9yh1q1bKzU1VRdeeKG2bNni9lhROnfuXO099Xg8Kioqcnu0asLhsB555BF16dJFqamp6tatm6ZPnx6X3y1+7NgxTZgwQZ06dVJqaqoGDx6ssrKyJp0hocO5dOlSTZw4UcXFxdq2bZv69u2r6667TocPH3Z7tCiVlZXq27ev5syZ4/YodVq/fr2Kior00Ucfac2aNfrll1907bXXqrKy0u3RqunYsaNmzpyprVu3asuWLbr66qs1atQoff75526PVquysjLNmzdPffr0cXuUGvXq1UsHDx6sWhs3bnR7pBodOXJEQ4YMUfPmzbV69Wp98cUX+vOf/6yWLVu6PVqUsrKyqPdzzZo1kqTRo0e7PFl1s2bN0ty5c/X000/ryy+/1KxZs/TYY4/pqaeecnu0au655x6tWbNGL774orZv365rr71Ww4cP1/79+5tuCCeBDRw40CkqKqp6HA6HnczMTKekpMTFqeomyVmxYoXbY9TL4cOHHUnO+vXr3R6lXlq2bOn89a9/dXuMGh07dsw5//zznTVr1jhXXHGFM378eLdHilJcXOz07dvX7THq5aGHHnIuu+wyt8cwGz9+vNOtWzcnEom4PUo1eXl5TmFhYdS2m266ycnPz3dpopr99NNPjtfrdVatWhW1vV+/fs6UKVOabI6EPeM8efKktm7dquHDh1dtS0pK0vDhw/Xhhx+6ONmZIxAISJJatWrl8iR1C4fDWrJkiSorK5Wbm+v2ODUqKipSXl5e1H9f483u3buVmZmprl27Kj8/X/v27XN7pBq98cYbGjBggEaPHq127drp4osv1nPPPef2WHU6efKkXnrpJRUWFjbaH7doTIMHD9batWu1a9cuSdKnn36qjRs3asSIES5PFu3XX39VOBxWSkpK1PbU1NQmvULS5F/y3lh+/PFHhcNhtW/fPmp7+/bt9dVXX7k01ZkjEolowoQJGjJkiHr37u32ODXavn27cnNzdeLECZ199tlasWKFevbs6fZY1SxZskTbtm1r8vswFoMGDdLChQvVo0cPHTx4UNOmTdPQoUO1Y8cOpaWluT1elG+++UZz587VxIkT9bvf/U5lZWV64IEHlJycrIKCArfHq9HKlSt19OhR3XXXXW6PUqOHH35YwWBQOTk58nq9CofDmjFjhvLz890eLUpaWppyc3M1ffp0XXDBBWrfvr0WL16sDz/8UOedd16TzZGw4URsFRUVaceOHXF7n0uSevToofLycgUCAS1fvlwFBQVav359XMWzoqJC48eP15o1a6r9Kzme/OeZRZ8+fTRo0CB16tRJy5Yt09133+3iZNVFIhENGDBAjz76qCTp4osv1o4dO/Tss8/GbTiff/55jRgxQpmZmW6PUqNly5bp5Zdf1qJFi9SrVy+Vl5drwoQJyszMjLv39MUXX1RhYaHOPfdceb1e9evXT7fddpu2bt3aZDMkbDjbtGkjr9erQ4cORW0/dOiQOnTo4NJUZ4Zx48Zp1apV2rBhQ8z+BFxjSE5OrvpXZv/+/VVWVqYnnnhC8+bNc3my/7d161YdPnxY/fr1q9oWDoe1YcMGPf300wqFQvJ6vS5OWLNzzjlH3bt31549e9wepZqMjIxq/zi64IIL9Oqrr7o0Ud2+++47vfvuu3rttdfcHqVWkyZN0sMPP6xbb71VknThhRfqu+++U0lJSdyFs1u3blq/fr0qKysVDAaVkZGhMWPGqGvXrk02Q8Le40xOTlb//v21du3aqm2RSERr166N2/tc8c5xHI0bN04rVqzQe++9py5durg9kkkkElEoFHJ7jCjDhg3T9u3bVV5eXrUGDBig/Px8lZeXx2U0Jen48eP6+uuvlZGR4fYo1QwZMqTar0nt2rVLnTp1cmmiui1YsEDt2rVTXl6e26PU6qeffqr2h5u9Xq8ikYhLE51aixYtlJGRoSNHjqi0tFSjRo1qsmMn7BmnJE2cOFEFBQUaMGCABg4cqMcff1yVlZUaO3as26NFOX78eNS/3L/99luVl5erVatWys7OdnGyaEVFRVq0aJFef/11paWl6fvvv5f0rz/smpqa6vJ00SZPnqwRI0YoOztbx44d06JFi7Ru3TqVlpa6PVqUtLS0aveIW7RoodatW8fVveMHH3xQI0eOVKdOnXTgwAEVFxfL6/Xqtttuc3u0an77299q8ODBevTRR3XLLbdo8+bNmj9/vubPn+/2aNVEIhEtWLBABQUFatYsfv/vduTIkZoxY4ays7PVq1cvffLJJ5o9e7YKCwvdHq2a0tJSOY6jHj16aM+ePZo0aZJycnKa9v/3m+zzuzHy1FNPOdnZ2U5ycrIzcOBA56OPPnJ7pGref/99R1K1VVBQ4PZoUWqaUZKzYMECt0erprCw0OnUqZOTnJzstG3b1hk2bJjzzjvvuD1WvcTjr6OMGTPGycjIcJKTk51zzz3XGTNmjLNnzx63x6rVm2++6fTu3dvx+XxOTk6OM3/+fLdHqlFpaakjydm5c6fbo9QpGAw648ePd7Kzs52UlBSna9euzpQpU5xQKOT2aNUsXbrU6dq1q5OcnOx06NDBKSoqco4ePdqkM/BnxQAAMEjYe5wAALiBcAIAYEA4AQAwIJwAABgQTgAADAgnAAAGhBMAAAPCCQCAAeEEAMCAcAIAYEA4AQAwIJwAABj8HyidmhRCSWP+AAAAAElFTkSuQmCC",
"text/plain": [
"<Figure size 500x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"filename = 'testdata/af902bf9.json'\n",
"#filename = 'testdata/62c24649.json'\n",
"#filename = 'testdata/a699fb00.json'\n",
"#filename = 'testdata/f76d97a5.json'\n",
"#filename = 'testdata/f5b8619d.json'\n",
"task = ajm.Task.load(filename)\n",
"image = task.pairs[0].input\n",
"image.show()"
]
},
{
"cell_type": "code",
"execution_count": 127,
"id": "8e2d17ed-0262-4915-a6e6-a5459b5a09ab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"len(train_input_output) 3\n",
"len(test_input_output) 1\n"
]
}
],
"source": [
"from color_xy import color_to_xy\n",
"\n",
"# TODO: get it to work with size 30x30\n",
"IMAGE_SIZE = 28\n",
"\n",
"def obfuscate_image(image: ajm.Image, offset: float) -> np.ndarray:\n",
" # empty image with size: IMAGE_SIZE x IMAGE_SIZE\n",
" # each pixel is an array with the 2 obfuscated [x,y] values\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [[0.0, 0.0]] * IMAGE_SIZE\n",
" rows2.append(columns2)\n",
" # assign obfuscated values\n",
" for row_index, rows in enumerate(image.pixels):\n",
" for column_index, pixel in enumerate(rows):\n",
" xy = color_to_xy(pixel, 10, offset)\n",
" rows2[row_index][column_index] = xy\n",
" obfuscated_image = np.array(rows2)\n",
" return obfuscated_image\n",
"\n",
"def onehot_image(image: ajm.Image, offset: float) -> np.ndarray:\n",
" offset_int = int(offset * 10.0)\n",
" # empty image with size: IMAGE_SIZE x IMAGE_SIZE\n",
" # each pixel is an array with the 10 values either 0 or 1\n",
" ten_zeros = [0] * 10\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [ten_zeros] * IMAGE_SIZE\n",
" rows2.append(columns2)\n",
" # assign obfuscated values\n",
" for row_index, rows in enumerate(image.pixels):\n",
" for column_index, pixel in enumerate(rows):\n",
" onehot_index = (pixel + offset_int) % 10\n",
" rows2[row_index][column_index][onehot_index] = 1\n",
" obfuscated_image = np.array(rows2)\n",
" return obfuscated_image\n",
"\n",
"def onehot_image2(image: ajm.Image, offset: float) -> np.ndarray:\n",
" offset_int = int(offset * 10.0)\n",
" # empty image with size: IMAGE_SIZE x IMAGE_SIZE\n",
" # each pixel is an array with the 10 values either 0 or 1\n",
" eleven_zeros = [0] * 11\n",
" eleven_zeros[10] = 10\n",
" rows2 = []\n",
" for y in range(0,IMAGE_SIZE):\n",
" columns2 = [eleven_zeros] * IMAGE_SIZE\n",
" rows2.append(columns2)\n",
" # assign obfuscated values\n",
" for row_index, rows in enumerate(image.pixels):\n",
" for column_index, pixel in enumerate(rows):\n",
" onehot_index = (pixel + offset_int) % 10\n",
" rows2[row_index][column_index][onehot_index] = 1\n",
" rows2[row_index][column_index][10] = 0\n",
" obfuscated_image = np.array(rows2)\n",
" return obfuscated_image\n",
"\n",
"def numpy_image_to_tensors(obfuscated_image: np.ndarray, device: torch.device) -> torch.Tensor:\n",
" tensors = torch.from_numpy(obfuscated_image)\n",
" #print(tensors)\n",
" # cast it to 32-bit floating point tensor\n",
" tensors = tensors.type('torch.FloatTensor')\n",
" #print(tensors)\n",
" #print(\"before\", tensors.shape)\n",
" # change layout from: rows -> columns -> obfuscated_pixel_array\n",
" # change layout to: obfuscated_pixel_array -> rows -> columns\n",
" tensors = tensors.permute(2, 0, 1)\n",
" #print(\"after\", tensors.shape)\n",
" tensors_on_device = tensors.to(device)\n",
" return tensors_on_device\n",
" \n",
"all_images = []\n",
"for pair in task.pairs:\n",
" all_images.append(pair.input)\n",
" all_images.append(pair.output)\n",
"\n",
"train_input_output = []\n",
"test_input_output = []\n",
"number_of_offsets = 1\n",
"for i in range(0, number_of_offsets):\n",
" offset = float(i) / float(number_of_offsets)\n",
" if i == 0:\n",
" offset = 0.01111\n",
" if i == 1:\n",
" offset = 0.71313\n",
" if i == 2:\n",
" offset = 0.91555\n",
" if i == 3:\n",
" offset = 0.51717\n",
" if i == 4:\n",
" offset = 0.330823\n",
" if i == 5:\n",
" offset = 0.23\n",
" if i == 6:\n",
" offset = 0.893\n",
" \n",
" for pair in task.pairs:\n",
" #input_image = onehot_image(pair.input, offset)\n",
" #output_image = onehot_image(pair.output, offset)\n",
" input_image = onehot_image2(pair.input, offset)\n",
" output_image = onehot_image2(pair.output, offset)\n",
" input_tensors = numpy_image_to_tensors(input_image, device)\n",
" output_tensors = numpy_image_to_tensors(output_image, device)\n",
" input_output_offset = (input_tensors, output_tensors, offset)\n",
" if pair.pair_type == ajm.PairType.TRAIN:\n",
" train_input_output.append(input_output_offset)\n",
" else:\n",
" test_input_output.append(input_output_offset)\n",
"print(\"len(train_input_output)\", len(train_input_output))\n",
"print(\"len(test_input_output)\", len(test_input_output))"
]
},
{
"cell_type": "code",
"execution_count": 128,
"id": "45e2653e-3539-4b61-ade5-18a193c93616",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ConvAutoencoder(\n",
" (conv1): Conv2d(11, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (conv2): Conv2d(16, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
" (t_conv1): ConvTranspose2d(4, 16, kernel_size=(2, 2), stride=(2, 2))\n",
" (t_conv2): ConvTranspose2d(16, 11, kernel_size=(2, 2), stride=(2, 2))\n",
")\n",
"----------------------------------------------------------------\n",
" Layer (type) Output Shape Param #\n",
"================================================================\n",
" Conv2d-1 [-1, 16, 30, 30] 1,600\n",
" MaxPool2d-2 [-1, 16, 15, 15] 0\n",
" Conv2d-3 [-1, 4, 15, 15] 580\n",
" MaxPool2d-4 [-1, 4, 7, 7] 0\n",
" ConvTranspose2d-5 [-1, 16, 14, 14] 272\n",
" ConvTranspose2d-6 [-1, 11, 28, 28] 715\n",
"================================================================\n",
"Total params: 3,167\n",
"Trainable params: 3,167\n",
"Non-trainable params: 0\n",
"----------------------------------------------------------------\n",
"Input size (MB): 0.04\n",
"Forward/backward pass size (MB): 0.24\n",
"Params size (MB): 0.01\n",
"Estimated Total Size (MB): 0.29\n",
"----------------------------------------------------------------\n"
]
}
],
"source": [
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"\n",
"# define the NN architecture\n",
"class ConvAutoencoder(nn.Module):\n",
" def __init__(self):\n",
" super(ConvAutoencoder, self).__init__()\n",
" ## encoder layers ##\n",
" # conv layer (depth from 2 --> 16), 3x3 kernels\n",
" self.conv1 = nn.Conv2d(11, 16, 3, padding=1) \n",
" # conv layer (depth from 16 --> 4), 3x3 kernels\n",
" self.conv2 = nn.Conv2d(16, 4, 3, padding=1)\n",
" # pooling layer to reduce x-y dims by two; kernel and stride of 2\n",
" self.pool = nn.MaxPool2d(2, 2)\n",
" \n",
" ## decoder layers ##\n",
" ## a kernel of 2 and a stride of 2 will increase the spatial dims by 2\n",
" self.t_conv1 = nn.ConvTranspose2d(4, 16, 2, stride=2)\n",
" self.t_conv2 = nn.ConvTranspose2d(16, 11, 2, stride=2)\n",
"\n",
"\n",
" def forward(self, x):\n",
" ## encode ##\n",
" # add hidden layers with relu activation function\n",
" # and maxpooling after\n",
" x = F.relu(self.conv1(x))\n",
" x = self.pool(x)\n",
" # add second hidden layer\n",
" x = F.relu(self.conv2(x))\n",
" x = self.pool(x) # compressed representation\n",
" \n",
" ## decode ##\n",
" # add transpose conv layers, with relu activation function\n",
" x = F.relu(self.t_conv1(x))\n",
" # output layer (with sigmoid for scaling from 0 to 1)\n",
" x = F.sigmoid(self.t_conv2(x))\n",
" \n",
" return x\n",
"\n",
"# initialize the NN\n",
"model = ConvAutoencoder()\n",
"print(model)\n",
"summary(model,input_size=(11,30,30))\n",
"model = model.to(device)"
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "32898b91-a8f1-47f0-9a75-ea7917f05f72",
"metadata": {},
"outputs": [],
"source": [
"# specify loss function\n",
"criterion = nn.MSELoss()\n",
"#criterion = nn.L1Loss()\n",
"#criterion = nn.CrossEntropyLoss()\n",
"#criterion = nn.KLDivLoss()\n",
"#criterion = nn.BCELoss()\n",
"#criterion = nn.BCEWithLogitsLoss()\n",
"\n",
"# specify loss function\n",
"optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "24fa3733-aaed-49a8-883b-408aac441ebf",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 90.48it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 1 \tTraining Loss: 0.000441\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 159.10it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 2 \tTraining Loss: 0.000434\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 160.15it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 3 \tTraining Loss: 0.000427\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 146.04it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 4 \tTraining Loss: 0.000420\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 157.51it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 5 \tTraining Loss: 0.000414\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 153.01it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 6 \tTraining Loss: 0.000407\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 164.29it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 7 \tTraining Loss: 0.000401\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 170.48it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 8 \tTraining Loss: 0.000395\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 157.87it/s]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 9 \tTraining Loss: 0.000389\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 158.77it/s]"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 10 \tTraining Loss: 0.000383\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"import random\n",
"#random.Random(42).shuffle(train_input_output)\n",
"\n",
"# number of epochs to train the model\n",
"n_epochs = 10\n",
"\n",
"for epoch in range(1, n_epochs+1):\n",
" # monitor training loss\n",
" train_loss = 0.0\n",
"\n",
" #random.Random(epoch).shuffle(train_input_output)\n",
" \n",
" ###################\n",
" # train the model #\n",
" ###################\n",
" for input_output_offset in tqdm(train_input_output):\n",
" input, expected_output, _ = input_output_offset\n",
" \n",
" # clear the gradients of all optimized variables\n",
" optimizer.zero_grad()\n",
" # forward pass: compute predicted outputs by passing inputs to the model\n",
"\n",
" outputs = model(input)\n",
" # calculate the loss\n",
" loss = criterion(outputs, expected_output)\n",
" # backward pass: compute gradient of the loss with respect to model parameters\n",
" loss.backward()\n",
" # perform a single optimization step (parameter update)\n",
" optimizer.step()\n",
" # update running training loss\n",
" train_loss += loss.item()*input.size(0)\n",
" \n",
" # print avg training statistics \n",
" train_loss = train_loss/len(train_input_output)\n",
" print('Epoch: {} \\tTraining Loss: {:.6f}'.format(\n",
" epoch, \n",
" train_loss\n",
" ))"
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "2ed1d86b-8cce-4ce6-be89-7a2e7a325d23",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAdgAAAHqCAYAAACna18/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABHfElEQVR4nO3de1xU5do//s+IMCDCJAjChAMKCXki8hTmg5hshMxDmZpZ4iHtAB6/j6XtTM2tqJXZwY3ao2iah9yJ2gm3JzCfPAGS2lYEtVBR1FRGQUdl7t8f/ZjHkQEGZi2Yw+f9eq3Xq1nc97qvK4a5XDNr1qUQQggQERGRpBo1dABERET2iAWWiIhIBiywREREMmCBJSIikgELLBERkQxYYImIiGTAAktERCQDFlgiIiIZsMASERHJgAWWyI5kZGRAoVAgIyPDsG/kyJEICgpqsJgeZipGInvEAktEJs2bNw9btmxp6DCIbBYLLJGd+/LLL5GXl1freSywRJZp3NABEBGg1+tx9+5duLq6Sn5sZ2dnyY9JRDXjGSyRhGbNmgWFQoGTJ09iyJAh8PT0hLe3NyZOnIg7d+4YxikUCiQlJeHrr79Gu3btoFQqkZ6eDgC4cOECRo8ejRYtWkCpVKJdu3ZYuXJlpbXOnz+PgQMHwt3dHb6+vpg8eTJ0Ol2lcaY+g9Xr9fj000/RoUMHuLq6wsfHB3FxccjKyjLEV1paitWrV0OhUEChUGDkyJGG+VLHSGSPeAZLJIMhQ4YgKCgIycnJOHDgAD777DNcv34dX331lWHM7t278c033yApKQnNmzdHUFAQiouL8dRTTxkKsI+PD3766SeMGTMGWq0WkyZNAgDcvn0bvXv3RmFhISZMmAC1Wo01a9Zg9+7dZsU3ZswYrFq1CvHx8Xjttddw//59/Pzzzzhw4AA6d+6MNWvW4LXXXkPXrl0xbtw4AEBwcDAA1FuMRDZPEJFkZs6cKQCI/v37G+1/6623BADx66+/CiGEACAaNWokfvvtN6NxY8aMEf7+/uLq1atG+1966SWhUqlEWVmZEEKIxYsXCwDim2++MYwpLS0VISEhAoDYs2ePYX9CQoIIDAw0PN69e7cAICZMmFApfr1eb/hvd3d3kZCQUGmMHDES2SO+RUwkg8TERKPH48ePBwD8+OOPhn09e/ZE27ZtDY+FEPj222/Rr18/CCFw9epVw9anTx+UlJQgJyfHcBx/f3+8+OKLhvlNmjQxnG1W59tvv4VCocDMmTMr/UyhUFQ7t75iJLIHfIuYSAaPPfaY0ePg4GA0atQIv//+u2Ffq1atjMZcuXIFN27cwPLly7F8+XKTx718+TIA4I8//kBISEilghgaGlpjbKdPn4ZarYaXl5c5qTRIjET2gAWWqB6YOjN0c3MzeqzX6wEAr7zyChISEkwep2PHjtIHVwu2ECORtWCBJZJBfn6+0RlqQUEB9Hp9tXdU8vHxgYeHB8rLyxETE1Pt8QMDA3H8+HEIIYyKtznfdw0ODsb27dtx7dq1as9iTf2joL5iJLIH/AyWSAZLliwxevz5558DAOLj46uc4+TkhEGDBuHbb7/F8ePHK/38ypUrhv9+9tlnUVRUhH/961+GfWVlZVW+bfugQYMGQQiB2bNnV/qZEMLw3+7u7rhx40aDxEhkD3gGSySDs2fPon///oiLi8P+/fuxdu1avPzyywgPD6923vz587Fnzx5069YNY8eORdu2bXHt2jXk5ORg586duHbtGgBg7Nix+OKLLzBixAhkZ2fD398fa9asQZMmTWqMrVevXnj11Vfx2WefIT8/H3FxcdDr9fj555/Rq1cvJCUlAQA6deqEnTt3YtGiRVCr1WjVqhW6detWLzES2YWGu4CZyP5UfE3nP//5j3jxxReFh4eHaNasmUhKShK3b982jAMgEhMTTR6juLhYJCYmipYtWwpnZ2fh5+cnevfuLZYvX2407o8//hD9+/cXTZo0Ec2bNxcTJ04U6enpNX5NRwgh7t+/Lz788EMRFhYmXFxchI+Pj4iPjxfZ2dmGMSdPnhRRUVHCzc1NADD6yo7UMRLZI4UQD7wnREQWmTVrFmbPno0rV66gefPmDR0OETUgfgZLREQkAxZYIiIiGbDAEhERyYCfwRIREcmAZ7BEREQyYIElIiKSgdXdaEKv16OoqAgeHh41dvYgIiKqL0II3Lx5E2q1Go0a1Xx+anUFtqioCC1btmzoMIiIiEw6d+4cAgICahxndQXWw8PDovklRyQKpJ6pIuo+1xZzdrR8AcfL2dHyBRwvZ0vyBWwvZ+0toOV/mV+nrK7AWvq2sKdl9dkmOVrOjpYv4Hg5O1q+AHO2JebWKdkuclqyZAmCgoLg6uqKbt264dChQ3ItRUREZHVkKbAbN27ElClTMHPmTOTk5CA8PBx9+vTB5cuX5ViOiIjI6shSYBctWoSxY8di1KhRaNu2LZYuXYomTZpg5cqVcixHRERkdSQvsHfv3kV2djZiYmL+b5FGjRATE4P9+/dLvRwREZFVkvwip6tXr6K8vBwtWrQw2t+iRQucPHmy0nidTgedTmd4rNVqpQ6JiIio3jX4nZySk5OhUqkMG78DS0RE9kDyAtu8eXM4OTmhuLjYaH9xcTH8/PwqjZ8+fTpKSkoM27lz56QOiYiIqN5JXmBdXFzQqVMn7Nq1y7BPr9dj165diIyMrDReqVTC09PTaCMiIrJ1stxoYsqUKUhISEDnzp3RtWtXLF68GKWlpRg1apQcyxEREVkdWQrs0KFDceXKFbz//vu4dOkSnnjiCaSnp1e68ImIiMheyXarxKSkJCQlJcl1eCIiIqvW4FcRExER2SOru9m/zRrb1cID2OC9mi3K2QbzBRwvZ0fLF3C8nB0tX6DuOd8vB5Bt9nCewRIREcmABZaIiEgGLLBEREQykLzA7t27F/369YNarYZCocCWLVukXoKIiMjqSV5gS0tLER4ejiVLlkh9aCIiIpsh+VXE8fHxiI+Pl/qwRERENqXBv6bDdnVERGSPGvwiJ7arIyIie9TgBZbt6oiIyB41+FvESqUSSqWyocMgIiKSVIOfwRIREdkjyc9gb926hYKCAsPjs2fPIjc3F15eXtBoNFIvR0REZJUkL7BZWVno1auX4fGUKVMAAAkJCVi1apXUyxEREVklyQtsdHQ0hBBSH5aIiMimNPhFTtZEEVL3uaLAwrZNFqxtiQbL2QbzBRwvZ1vMF3C8nB0tX6CBcr4JIML84bzIiYiISAYssERERDJggSUiIpKB5AU2OTkZXbp0gYeHB3x9fTFw4EDk5eVJvQwREZFVk7zAZmZmIjExEQcOHMCOHTtw7949xMbGorS0VOqliIiIrJbkVxGnp6cbPV61ahV8fX2RnZ2NqKgoqZcjIiKySrJ/TaekpAQA4OXlZfLnbFdHRET2SNaLnPR6PSZNmoSnn34a7du3NzmG7eqIiMgeyVpgExMTcfz4cWzYsKHKMWxXR0RE9ki2t4iTkpLw/fffY+/evQgICKhyHNvVERGRPZK8wAohMH78eKSlpSEjIwOtWrWSegkiIiKrJ3mBTUxMxLp167B161Z4eHjg0qVLAACVSgU3NzeplyMiIrJKkn8Gm5KSgpKSEkRHR8Pf39+wbdy4UeqliIiIrJYsbxETERE5OqttV1dyBPD0aOgozGd5GzRp4qhPlrWLki6O+uRoOTtavoDj5exo+QKWv16bizf7JyIikgELLBERkQxYYImIiGQgy1XEHTt2hKenJzw9PREZGYmffvpJ6mWIiIismuQFNiAgAPPnz0d2djaysrLwzDPPYMCAAfjtt9+kXoqIiMhqSX4Vcb9+/Ywez507FykpKThw4ADatWsn9XJERERWSdav6ZSXl2PTpk0oLS1FZGSkyTFsV0dERPZIloucjh07hqZNm0KpVOKNN95AWloa2rZta3Is29UREZE9kqXAhoaGIjc3FwcPHsSbb76JhIQE/Oc//zE5lu3qiIjIHsnyFrGLiwtCQv66VUanTp1w+PBhfPrpp1i2bFmlsWxXR0RE9qhevger1+uNPmclIiKyd5KfwU6fPh3x8fHQaDS4efMm1q1bh4yMDGzfvl3qpYiIiKyW5AX28uXLGDFiBC5evAiVSoWOHTti+/bt+Nvf/ib1UkRERFZL8gK7YsUKqQ9JRERkc3gvYiIiIhkohJV1SNdqtVCpVHWe74j9CW0xZ0fLF3C8nB0tX8Dxcna0Ptjam4AqAigpKYGnp2eN43kGS0REJAMWWCIiIhnIXmDnz58PhUKBSZMmyb0UERGR1ZC1wB4+fBjLli1Dx44d5VyGiIjI6shWYG/duoXhw4fjyy+/RLNmzeRahoiIyCrJVmATExPRt29fxMTEVDtOp9NBq9UabURERLZOlpv9b9iwATk5OTh8+HCNY5OTkzF79mw5wiAiImowkp/Bnjt3DhMnTsTXX38NV1fXGsezXR0REdkjyc9gs7OzcfnyZTz55JOGfeXl5di7dy+++OIL6HQ6ODk5GX7GdnVERGSPJC+wvXv3xrFjx4z2jRo1CmFhYXjnnXeMiisREZG9krzAenh4oH379kb73N3d4e3tXWk/ERGRveKdnIiIiGQgy1XED8vIyKiPZYiIiKwGz2CJiIhkUC9nsA5hbFcLD3BIkjDqlUU522C+gOPl7Gj5Ao6Xs6PlC9Q95/vlALLNHs4zWCIiIhmwwBIREclA8gI7a9YsKBQKoy0sLEzqZYiIiKyaLJ/BtmvXDjt37vy/RRrzo14iInIsslS+xo0bw8/PT45DExER2QRZPoPNz8+HWq1G69atMXz4cBQWFsqxDBERkdWS/Ay2W7duWLVqFUJDQ3Hx4kXMnj0b//Vf/4Xjx4/Dw8Oj0nidTgedTmd4zH6wRERkDyQvsPHx8Yb/7tixI7p164bAwEB88803GDNmTKXx7AdLRET2SPav6TzyyCNo06YNCgoKTP6c/WCJiMgeyV5gb926hdOnT8Pf39/kz5VKJTw9PY02IiIiWyd5gf3v//5vZGZm4vfff8cvv/yC559/Hk5OThg2bJjUSxEREVktyT+DPX/+PIYNG4Y///wTPj4+6NGjBw4cOAAfHx+plyIiIrJakhfYDRs2SH1IIiIim8N7ERMREcmA9zB8gCKk7nNFgYVtmyxY2xINlrMN5gs4Xs62mC/geDk7Wr5AA+V8E0CE+cN5BktERCQDFlgiIiIZyFJgL1y4gFdeeQXe3t5wc3NDhw4dkJWVJcdSREREVknyz2CvX7+Op59+Gr169cJPP/0EHx8f5Ofno1mzZlIvRUREZLUkL7ALFixAy5YtkZqaatjXqlUrqZchIiKyapK/Rbxt2zZ07twZgwcPhq+vLyIiIvDll19KvQwREZFVk7zAnjlzBikpKXjsscewfft2vPnmm5gwYQJWr15tcrxOp4NWqzXaiIiIbJ3kbxHr9Xp07twZ8+bNAwBERETg+PHjWLp0KRISEiqNZ7s6IiKyR5Kfwfr7+6Nt27ZG+x5//HEUFhaaHM92dUREZI8kP4N9+umnkZeXZ7Tv1KlTCAwMNDleqVRCqVRKHQYREVGDkvwMdvLkyThw4ADmzZuHgoICrFu3DsuXL0diYqLUSxEREVktyQtsly5dkJaWhvXr16N9+/aYM2cOFi9ejOHDh0u9FBERkdWS5Wb/zz33HJ577jk5Dk1ERGQTeC9iIiIiGVhtu7qSI4CnR0NHYT7L26BJE0d9sqxdlHRx1CdHy9nR8gUcL2dHyxew/PXaXDyDJSIikgELLBERkQwkL7BBQUFQKBSVNn5Nh4iIHInkn8EePnwY5eXlhsfHjx/H3/72NwwePFjqpYiIiKyW5AXWx8fH6PH8+fMRHByMnj17Sr0UERGR1ZL1M9i7d+9i7dq1GD16NBQKhZxLERERWRVZv6azZcsW3LhxAyNHjqxyjE6ng06nMzxmuzoiIrIHsp7BrlixAvHx8VCr1VWOSU5OhkqlMmwtW7aUMyQiIqJ6IVuB/eOPP7Bz50689tpr1Y5juzoiIrJHsr1FnJqaCl9fX/Tt27facWxXR0RE9kiWM1i9Xo/U1FQkJCSgcWOrvRsjERGRbGQpsDt37kRhYSFGjx4tx+GJiIisniynl7GxsRBCyHFoIiIim8B7ERMREclAIazsVFOr1UKlUtV5viO2T7LFnB0tX8Dxcna0fAHHy9nR2nRqbwKqCKCkpASenp41jucZLBERkQxYYImIiGTAAktERCQDyQtseXk5ZsyYgVatWsHNzQ3BwcGYM2cOryomIiKHIvnXdBYsWICUlBSsXr0a7dq1Q1ZWFkaNGgWVSoUJEyZIvRwREZFVkrzA/vLLLxgwYIDhFolBQUFYv349Dh06JPVSREREVkvyt4i7d++OXbt24dSpUwCAX3/9Ffv27UN8fLzJ8TqdDlqt1mgjIiKydZKfwU6bNg1arRZhYWFwcnJCeXk55s6di+HDh5scn5ycjNmzZ0sdBhERUYOS/Az2m2++wddff41169YhJycHq1evxkcffYTVq1ebHM92dUREZI8kP4OdOnUqpk2bhpdeegkA0KFDB/zxxx9ITk5GQkJCpfFsV0dERPZI8jPYsrIyNGpkfFgnJyfo9XqplyIiIrJakp/B9uvXD3PnzoVGo0G7du1w5MgRLFq0iK3riIjIoUheYD///HPMmDEDb731Fi5fvgy1Wo3XX38d77//vtRLERERWS3JC6yHhwcWL16MxYsXS31oIiIimyFLw3WHNLarhQewwRtxWJSzDeYLOF7OjpYv4Hg5O1q+QN1zvl8OINvs4bzZPxERkQxYYImIiGTAAktERCQDWQrszZs3MWnSJAQGBsLNzQ3du3fH4cOH5ViKiIjIKslSYF977TXs2LEDa9aswbFjxxAbG4uYmBhcuHBBjuWIiIisjuQF9vbt2/j222+xcOFCREVFISQkBLNmzUJISAhSUlKkXo6IiMgqSf41nfv376O8vByurq5G+93c3LBv375K43U6HXQ6neEx29UREZE9kPwM1sPDA5GRkZgzZw6KiopQXl6OtWvXYv/+/bh48WKl8cnJyVCpVIatZcuWUodERERU72T5DHbNmjUQQuDRRx+FUqnEZ599hmHDhlVqAgCwXR0REdknWe7kFBwcjMzMTJSWlkKr1cLf3x9Dhw5F69atK41luzoiIrJHsn4P1t3dHf7+/rh+/Tq2b9+OAQMGyLkcERGR1ZDlDHb79u0QQiA0NBQFBQWYOnUqwsLCMGrUKDmWIyIisjqynMGWlJQgMTERYWFhGDFiBHr06IHt27fD2dlZjuWIiIisjixnsEOGDMGQIUPkODQREZFNYLu6ByhC6j5XFFjYtsmCtS3RYDnbYL6A4+Vsi/kCjpezo+ULNFDONwFEmD+cN/snIiKSAQssERGRDFhgiYiIZFDrArt3717069cParUaCoUCW7ZsMfq5EALvv/8+/P394ebmhpiYGOTn50sVLxERkU2odYEtLS1FeHg4lixZYvLnCxcuxGeffYalS5fi4MGDcHd3R58+fXDnzh2LgyUiIrIVtb6KOD4+HvHx8SZ/JoTA4sWL8d577xnu2vTVV1+hRYsW2LJlC1566SXLoiUiIrIRkn4Ge/bsWVy6dAkxMTGGfSqVCt26dcP+/ftNztHpdNBqtUYbERGRrZO0wF66dAkA0KJFC6P9LVq0MPzsYWxXR0RE9qjBryJmuzoiIrJHkhZYPz8/AEBxcbHR/uLiYsPPHqZUKuHp6Wm0ERER2TpJC2yrVq3g5+eHXbt2GfZptVocPHgQkZGRUi5FRERk1Wp9FfGtW7dQUFBgeHz27Fnk5ubCy8sLGo0GkyZNwj/+8Q889thjaNWqFWbMmAG1Wo2BAwdKGTcREZFVq3WBzcrKQq9evQyPp0yZAgBISEjAqlWr8Pbbb6O0tBTjxo3DjRs30KNHD6Snp8PV1VW6qImIiKxcrQtsdHQ0hBBV/lyhUOCDDz7ABx98YFFgREREtqzBryImIiKyR1bbD7bkCODp0dBRmM/yPqPSxFGfLOvHKF0c9cnRcna0fAHHy9nR8gUsf702F89giYiIZMACS0REJAPJ29Vt3rwZsbGx8Pb2hkKhQG5urkShEhER2Q7J29WVlpaiR48eWLBggcXBERER2SpJ29UBwKuvvgoA+P333+scFBERka1r8KuIdToddDqd4THb1RERkT1o8Iuc2K6OiIjsUYMXWLarIyIie9TgbxErlUoolcqGDoOIiEhSDX4GS0REZI8kb1d37do1FBYWoqioCACQl5cH4K9m7FU1XSciIrI3tT6DzcrKQkREBCIiIgD81a4uIiIC77//PgBg27ZtiIiIQN++fQEAL730EiIiIrB06VIJwyYiIrJuClFd77kGoNVqoVKpGuRm//V1A2hTGuqm2Q2Vs6PlCzhezg15I3hHy9nR8gUa9m+5pKQEnp6eNY7jZ7BEREQysNoz2LpyxPZJtpizo+ULOF7OjpYv4Hg5O1qbTu1NQBXBM1giIqIGxQJLREQkA0nb1d27dw/vvPMOOnToAHd3d6jVaowYMcLwlR0iIiJHIWm7urKyMuTk5GDGjBnIycnB5s2bkZeXh/79+0sSLBERka2QtF2dSqXCjh07jPZ98cUX6Nq1KwoLC6HRaOoWJRERkY2R/TPYkpISKBQKPPLII3IvRUREZDVkvdn/nTt38M4772DYsGFVXtLMfrBERGSPZDuDvXfvHoYMGQIhBFJSUqocx36wRERkj2QpsBXF9Y8//sCOHTuq/UIu+8ESEZE9kvwt4orimp+fjz179sDb27va8ewHS0RE9kjSdnX+/v548cUXkZOTg++//x7l5eW4dOkSAMDLywsuLi7SRU5ERGTFal1gs7Ky0KtXL8PjKVOmAAASEhIwa9YsbNu2DQDwxBNPGM3bs2cPoqOj6x4pERGRDal1gY2OjkZ1/QGsrHcAERFRg+C9iImIiGQg6/dgHcrYrhYe4JAkYdQri3K2wXwBx8vZ0fIFHC9nR8sXqHvO98sBZJs9nGewREREMmCBJSIikoGk7eoAYNasWQgLC4O7uzuaNWuGmJgYHDx4UKp4iYiIbIKk7eoAoE2bNvjiiy9w7Ngx7Nu3D0FBQYiNjcWVK1csDpaIiMhWSNquDgBefvllo8eLFi3CihUrcPToUfTu3bv2ERIREdkgWT+DvXv3LpYvXw6VSoXw8HA5lyIiIrIqsnxN5/vvv8dLL72EsrIy+Pv7Y8eOHWjevLnJsWxXR0RE9kiWM9hevXohNzcXv/zyC+Li4jBkyBBcvnzZ5Fi2qyMiInskS4F1d3dHSEgInnrqKaxYsQKNGzfGihUrTI5luzoiIrJH9XInJ71eb/Q28IPYro6IiOyRpO3qvL29MXfuXPTv3x/+/v64evUqlixZggsXLmDw4MGSBk5ERGTNJG1Xt3TpUpw8eRKrV6/G1atX4e3tjS5duuDnn39Gu3btpIuaiIjIyknerm7z5s0WBURERGQPeC9iIiIiGbBd3QMUIXWfKwosbNtkwdqWaLCcbTBfwPFytsV8AcfL2dHyBRoo55sAIswfzjNYIiIiGbDAEhERyUDydnUPeuONN6BQKLB48WILQiQiIrI9krerq5CWloYDBw5ArVbXOTgiIiJbJXm7OgC4cOECxo8fj+3bt6Nv3751Do6IiMhWSf4ZrF6vx6uvvoqpU6fy5hJEROSwJP+azoIFC9C4cWNMmDDBrPFsV0dERPZI0jPY7OxsfPrpp1i1ahUUCoVZc9iujoiI7JGkBfbnn3/G5cuXodFo0LhxYzRu3Bh//PEH/t//+38ICgoyOYft6oiIyB5J+hbxq6++ipiYGKN9ffr0wauvvopRo0aZnMN2dUREZI8kbVen0Wjg7e1tNN7Z2Rl+fn4IDQ21PFoiIiIbIWm7ulWrVkkWGBERkS2TvF3dw37//ffaLkFERGTzeC9iIiIiGVhtu7qSI4CnR0NHYT7L26BJE0d9sqxdlHRx1CdHy9nR8gUcL2dHyxew/PXaXDyDJSIikgELLBERkQxYYImIiGQgeT/YkSNHQqFQGG1xcXFSxUtERGQTZOkHGxcXh4sXLxq29evXWxQkERGRrZGlH6xSqYSfn1+dgyIiIrJ1snwGm5GRAV9fX4SGhuLNN9/En3/+WeVYnU4HrVZrtBEREdk6yQtsXFwcvvrqK+zatQsLFixAZmYm4uPjUV5ebnI829UREZE9kvxGEy+99JLhvzt06ICOHTsiODgYGRkZ6N27d6Xx06dPN9zPGPir4TqLLBER2TrZv6bTunVrNG/e3KgDz4OUSiU8PT2NNiIiIlsne4E9f/48/vzzT/j7+8u9FBERkdWQtB+sl5cXZs+ejUGDBsHPzw+nT5/G22+/jZCQEPTp00fSwImIiKyZpP1gU1JScPToUaxevRo3btyAWq1GbGws5syZA6VSKV3UREREVk7yfrDbt2+3KCAiIiJ7oBC16Z5eD7RaLVQqVZ3nO2L7JFvM2dHyBRwvZ0fLF3C8nB2tTaf2JqCKAEpKSsy6IJc3+yciIpIBCywREZEMWGCJiIhkIHm7OgA4ceIE+vfvD5VKBXd3d3Tp0gWFhYVSxEtERGQTJG9Xd/r0afTo0QNhYWHIyMjA0aNHMWPGDLi6ulocLBERka2QvF3d3//+dzz77LNYuHChYV9wcHDdoiMiIrJRkn4Gq9fr8cMPP6BNmzbo06cPfH190a1bN5NvI1dguzoiIrJHkhbYy5cv49atW5g/fz7i4uLw73//G88//zxeeOEFZGZmmpzDdnVERGSPJD+DBYABAwZg8uTJeOKJJzBt2jQ899xzWLp0qck506dPR0lJiWE7d+6clCERERE1CEn7wTZv3hyNGzdG27ZtjfY//vjj2Ldvn8k5SqWS9ykmIiK7I+kZrIuLC7p06YK8vDyj/adOnUJgYKCUSxEREVk1SdvVaTQaTJ06FUOHDkVUVBR69eqF9PR0fPfdd8jIyJAybiIiIqsmabu6VatW4fnnn8fSpUuRnJyMCRMmIDQ0FN9++y169OghXdRERERWjt10rAS7cJjPFvMFHC9nR8sXcLyc2U2nepJe5OTQxna18ACHJAmjXlmUsw3mCzhezo6WL+B4OTtavkDdc75fDiDb7OG82T8REZEMWGCJiIhkwAJLREQkA8nb1SkUCpPbhx9+KFXMREREVk/ydnUXL1402lauXAmFQoFBgwZZHCwREZGtkLxdnZ+fn9HjrVu3olevXmjdunXtoyMiIrJRsn5Np7i4GD/88ANWr15d5RidTgedTmd4zHZ1RERkD2S9yGn16tXw8PDACy+8UOUYtqsjIiJ7JGuBXblyJYYPHw5XV9cqx7BdHRER2SPZ3iL++eefkZeXh40bN1Y7ju3qiIjIHsl2BrtixQp06tQJ4eHhci1BRERktSRvVwf8daHSpk2b8PHHH0sXKRERkQ2RvF0dAGzYsAFCCAwbNkyaKImIiGxMrQtsdHQ0aupwN27cOIwbN67OQREREdk63ouYiIhIBuwH+wDLmiVb2BfRwsbFddVgOdtgvoDj5WyL+QKOl7Oj5Qs0UM43AUSYP5xnsERERDJggSUiIpKB5O3qbt26haSkJAQEBMDNzQ1t27bF0qVLpYqXiIjIJkjerm7KlClIT0/H2rVrceLECUyaNAlJSUnYtm2bxcESERHZCsnb1f3yyy9ISEhAdHQ0gL++srNs2TIcOnQI/fv3r3OgREREtkTyz2C7d++Obdu24cKFCxBCYM+ePTh16hRiY2NNjtfpdNBqtUYbERGRrZO8wH7++edo27YtAgIC4OLigri4OCxZsgRRUVEmx7NdHRER2SNZCuyBAwewbds2ZGdn4+OPP0ZiYiJ27txpcjzb1RERkT2S9EYTt2/fxrvvvou0tDT07dsXANCxY0fk5ubio48+QkxMTKU5bFdHRET2SNIz2Hv37uHevXto1Mj4sE5OTtDr9VIuRUREZNUkb1fXs2dPTJ06FW5ubggMDERmZia++uorLFq0SNLAiYiIrJnk7eo2bNiA6dOnY/jw4bh27RoCAwMxd+5cvPHGG9JFTUREZOUkb1fn5+eH1NRUi4IiIiKydbwXMRERkQystl1dyRHA06OhozCf5W3QpImjPlnWLkq6OOqTo+XsaPkCjpezo+ULWP56bS6ewRIREcmABZaIiEgGkrerKy4uxsiRI6FWq9GkSRPExcUhPz9fqniJiIhsgqTt6oQQGDhwIM6cOYOtW7fiyJEjCAwMRExMDEpLSyUJmIiIyBZI2q4uPz8fBw4cwPHjx9GuXTsAQEpKCvz8/LB+/Xq89tprlkVLRERkIyT9DFan0wEAXF1d/2+BRo2gVCqxb98+KZciIiKyapIW2LCwMGg0GkyfPh3Xr1/H3bt3sWDBApw/fx4XL140OYf9YImIyB5JWmCdnZ2xefNmnDp1Cl5eXmjSpAn27NmD+Pj4Sg0AKrAfLBER2SPJv6bTqVMn5Obm4saNG7h48SLS09Px559/onXr1ibHsx8sERHZI9nu5KRSqQD8deFTVlYW5syZY3Ic+8ESEZE9krxd3aZNm+Dj4wONRoNjx45h4sSJGDhwIGJjYyUNnIiIyJpJ3q7u4sWLmDJlCoqLi+Hv748RI0ZgxowZ0kVMRERkAxSiut5zDUCr1UKlUjXIzf7r6wbQpjTUTbMbKmdHyxdwvJwb8kbwjpazo+ULNOzfcklJCTw9PWscx3sRExERycBqz2DryhHbJ9lizo6WL+B4OTtavoDj5exobTq1NwFVBM9giYiIGhQLLBERkQxqVWCTk5PRpUsXeHh4wNfXFwMHDkReXp7RmDt37iAxMRHe3t5o2rQpBg0ahOLiYkmDJiIisna1KrCZmZlITEzEgQMHsGPHDty7dw+xsbFGregmT56M7777Dps2bUJmZiaKiorwwgsvSB44ERGRNbPoIqcrV67A19cXmZmZiIqKQklJCXx8fLBu3Tq8+OKLAICTJ0/i8ccfx/79+/HUU0/VeExe5FR7tpizo+ULOF7OjpYv4Hg58yKn6ln0GWxJSQkAwMvLCwCQnZ2Ne/fuISYmxjCmosPO/v37LVmKiIjIptT5XsR6vR6TJk3C008/jfbt2wMALl26BBcXFzzyyCNGY1u0aIFLly6ZPI5OpzP0kQXAdnVERGQX6nwGm5iYiOPHj2PDhg0WBcB2dUREZI/qVGCTkpLw/fffY8+ePQgICDDs9/Pzw927d3Hjxg2j8cXFxfDz8zN5LLarIyIie1SrAiuEQFJSEtLS0rB79260atXK6OedOnWCs7Mzdu3aZdiXl5eHwsJCREZGmjymUqmEp6en0UZERGTravUZbGJiItatW4etW7fCw8PD8LmqSqWCm5sbVCoVxowZgylTpsDLywuenp4YP348IiMjzbqCmIiIyF7UqsCmpKQAAKKjo432p6amYuTIkQCATz75BI0aNcKgQYOg0+nQp08f/POf/5QkWCIiIltRqwJrzldmXV1dsWTJEixZsqTOQREREdk63ouYiIhIBnX+Hiw9ZGxXCw9wSJIw6pVFOdtgvoDj5exo+QKOl7Oj5QvUPef75QCyzR7OM1giIiIZsMASERHJQPJ2dcuXL0d0dDQ8PT2hUCgq3XSCiIjIEUjerq6srAxxcXF49913JQ+WiIjIVtTqIqf09HSjx6tWrYKvry+ys7MRFRUFAJg0aRIAICMjQ5IAiYiIbJGk7eqIiIjoL5K2q6sLtqsjIiJ7xHZ1REREMpC0XV1dsF0dERHZo1rfi3j8+PFIS0tDRkZGpXZ1daFUKqFUKi0+DhERkTWRtF0dAFy6dAmXLl1CQUEBAODYsWPw8PCARqPhxVBEROQwavUWcUpKCkpKShAdHQ1/f3/DtnHjRsOYpUuXIiIiAmPHjgUAREVFISIiAtu2bZM2ciIiIismebu6WbNmYdasWXWNh4iIyC7wXsREREQyYLu6ByhC6j5XFFjYtsmCtS3RYDnbYL6A4+Vsi/kCjpezo+ULNFDONwFEmD+cZ7BEREQyYIElIiKSAQssERGRDCTtB3vt2jWMHz8eoaGhcHNzg0ajwYQJEwxNAYiIiByFpP1gi4qKUFRUhI8++gjHjx/HqlWrkJ6ejjFjxsgSPBERkbWStB9s+/bt8e233xp+HhwcjLlz5+KVV17B/fv30bgxL1omIiLHYFHFM6cfbElJCTw9PassrmxXR0RE9qjOFzmZ0w/26tWrmDNnDsaNG1flcdiujoiI7JFs/WC1Wi369u2Ltm3bVnvrRLarIyIie1Snt4gr+sHu3bvXZD/YmzdvIi4uDh4eHkhLS4Ozs3OVx2K7OiIiske1OoMVQiApKQlpaWnYvXu3yX6wWq0WsbGxcHFxwbZt2+Dq6ipZsERERLZC0n6wFcW1rKwMa9euhVarNVy05OPjAycnJ+kzICIiskK1KrApKSkAgOjoaKP9qampGDlyJHJycnDw4EEAQEiI8Z2Yz549i6CgoLpHSkREZEMk7QcbHR1tVs9YIiIie2e1d34oOQJ4ejR0FOazvA2aNHHUJ8vaRUkXR31ytJwdLV/A8XJ2tHwBy1+vzcWb/RMREcmABZaIiEgGLLBEREQykLRdHQC8/vrrCA4OhpubG3x8fDBgwACcPHlS0qCJiIisnaTt6gCgU6dOSE1NxYkTJ7B9+3YIIRAbG4vy8nLJgyciIrJWCmHB92quXLkCX19fZGZmIioqyuSYo0ePIjw8HAUFBQgODq7xmFqtFiqVqkGuIq6vK8tMaair8RoqZ0fLF3C8nBvyClNHy9nR8gUa9m+5oktcTWRtV1daWorU1FS0atWqyi45bFdHRET2SJZ2df/85z/RtGlTNG3aFD/99BN27NgBFxcXk8dhuzoiIrJHsrSrGz58OI4cOYLMzEy0adMGQ4YMwZ07d0weh+3qiIjIHsnSrq7ibPSxxx7DU089hWbNmiEtLQ3Dhg2rNJbt6oiIyB7V+l7E48ePR1paGjIyMky2qzM1Rwhh9DkrERGRvZO0Xd2ZM2ewceNGxMbGwsfHB+fPn8f8+fPh5uaGZ599VpYEiIiIrFGtPoNNSUlBSUkJoqOj4e/vb9g2btwIAHB1dcXPP/+MZ599FiEhIRg6dCg8PDzwyy+/wNfXV5YEiIiIrJGk7erUajV+/PFHiwIiIiKyBxbdaEIOFTeaqCtHbJ9kizk7Wr6A4+XsaPkCjpezo7Xp1N4EVBHm32iCN/snIiKSAQssERGRDFhgiYiIZCB5u7oKQgjEx8dDoVBgy5YtUsRKRERkMyRvV1dh8eLFUCgUkgVKRERkS2r1NZ309HSjx6tWrYKvry+ys7ON2tXl5ubi448/RlZWFvz9/aWJlIiIyIZI3q6urKwML7/8MpYsWQI/P78aj8F2dUREZI8kb1c3efJkdO/eHQMGDDDrOGxXR0RE9qjOZ7AV7er27dtn2Ldt2zbs3r0bR44cMfs406dPx5QpUwyPtVotiywREdm8Op3BVrSr27Nnj1G7ut27d+P06dN45JFH0LhxYzRu/Ff9HjRoEKKjo00eS6lUwtPT02gjIiKydZK2q5s2bRpee+01o30dOnTAJ598gn79+lkeLRERkY2QtF2dn5+fyQubNBqNWb1jiYiI7IWk7eqIiIjoL5K2q5NqDhERka3jvYiJiIhkYNGNJugBY7taeIBDkoRRryzK2QbzBRwvZ0fLF3C8nB0tX6DuOd8vB5Bt9nCewRIREcmABZaIiEgGkreri46OhkKhMNreeOMNSYMmIiKydrK0qxs7diwuXrxo2BYuXChp0ERERNZOlnZ1TZo0MauTDhERkb2y6DNYU+3qAODrr79G8+bN0b59e0yfPh1lZWVVHkOn00Gr1RptREREtq7OX9Opql3dyy+/jMDAQKjVahw9ehTvvPMO8vLysHnzZpPHSU5OxuzZs+saBhERkVWStF0dAIwbN87w3x06dIC/vz969+6N06dPIzg4uNJx2K6OiIjsUZ0KbEW7ur179xq1qzOlW7duAICCggKTBVapVEKpVNYlDCIiIqslabs6U3JzcwEA/v7+dQqQiIjIFknaru706dNYt24dnn32WXh7e+Po0aOYPHkyoqKi0LFjR1kSICIiska1KrApKSkA/rqZxINSU1MxcuRIuLi4YOfOnVi8eDFKS0vRsmVLDBo0CO+9955kARMREdkCSdvVtWzZEpmZmRYFREREZA94L2IiIiIZsF3dAxQhdZ8rCixs22TB2pZosJxtMF/A8XK2xXwBx8vZ0fIFGijnmwAizB/OM1giIiIZsMASERHJQPJ2dQCwf/9+PPPMM3B3d4enpyeioqJw+/ZtyYImIiKydpK3q9u/fz/i4uIQGxuLQ4cO4fDhw0hKSkKjRjxZJiIixyF5u7rJkydjwoQJmDZtmmFcaGioBKESERHZDknb1V2+fBkHDx6Er68vunfvjhYtWqBnz56VGgIQERHZuzoXWFPt6s6cOQMAmDVrFsaOHYv09HQ8+eST6N27N/Lz800eh/1giYjIHtW5wFa0q9uwYYNhn16vBwC8/vrrGDVqFCIiIvDJJ58gNDQUK1euNHmc5ORkqFQqw8ZWdUREZA/qVGAr2tXt2bPHqF1dRcectm3bGo1//PHHUVhYaPJY06dPR0lJiWE7d+5cXUIiIiKyKpK2qwsKCoJara701Z1Tp04hPj7e5DHZD5aIiOyRpO3qFAoFpk6dipkzZyI8PBxPPPEEVq9ejZMnT+Jf//qXLAkQERFZI0nb1QHApEmTcOfOHUyePBnXrl1DeHg4duzYgeDgYEkCJiIisgWStqurMG3aNKPvwRIRETka3l6JiIhIBlbbrq7kCODp0dBRmM/yNmjSxFGfLGsXJV0c9cnRcna0fAHHy9nR8gUsf702F89giYiIZMACS0REJANJ29X9/vvvUCgUJrdNmzZJHjwREZG1krRdXcuWLXHx4kWjbfbs2WjatGmVN5ogIiKyR5K2q3NycoKfn5/RmLS0NAwZMgRNmza1PFoiIiIbIWm7uodlZ2cjNzcXY8aMsWQZIiIim1Pnr+mYalf3sBUrVuDxxx9H9+7dqzyOTqeDTqczPGa7OiIisgeStqt70O3bt7Fu3boaz17Zro6IiOyRpO3qHvSvf/0LZWVlGDFiRLXHYrs6IiKyR5K2q3vQihUr0L9/f/j4+FR7TLarIyIieyRpu7oKBQUF2Lt3L3788UdpoyUiIrIRtXqLOCUlBSUlJYiOjoa/v79h27hxo9G4lStXIiAgALGxsZIGS0REZCtkaVc3b948zJs3r04BERER2QOr66ZTUcS1txo4kHqmvdnQEdQvR8sXcLycHS1fwPFydrR8K5h7sqkQ5o6sJ+fPn+dXdYiIyGqdO3euym/QPMjqCqxer0dRURE8PDygUCgq/Vyr1aJly5Y4d+4cPD09a3VsW5zbkGtzbu3YYtyONrch1+bc2rHGuIUQuHnzJtRqNRo1qvkSJqt7i7hRo0Zm/cvA09OzTr80W53bkGtzrm2szbm2sTbn2sbaVc1VqVRmH4P9YImIiGTAAktERCQDmyuwSqUSM2fOrNPdn2xxbkOuzbm2sTbn2sbanGsba1sa94Os7iInIiIie2BzZ7BERES2gAWWiIhIBiywREREMmCBJSIikoHNFdglS5YgKCgIrq6u6NatGw4dOlTjnL1796Jfv35Qq9VQKBTYsmWL2eslJyejS5cu8PDwgK+vLwYOHIi8vDyz5qakpKBjx46GLyxHRkbip59+MnvtB82fPx8KhQKTJk2qceysWbOgUCiMtrCwMLPXunDhAl555RV4e3vDzc0NHTp0QFZWlllzg4KCKq2tUCiQmJhY49zy8nLMmDEDrVq1gpubG4KDgzFnzhyz7/t58+ZNTJo0CYGBgXBzc0P37t1x+PDhSuNqej4IIfD+++/D398fbm5uiImJQX5+vllzN2/ejNjYWHh7e0OhUCA3N9esde/du4d33nkHHTp0gLu7O9RqNUaMGIGioiKz4541axbCwsLg7u6OZs2aISYmBgcPHjRr7oPeeOMNKBQKLF682Ky5I0eOrPT7jouLM3vdEydOoH///lCpVHB3d0eXLl1QWFhY41xTzzOFQoEPP/ywxrm3bt1CUlISAgIC4ObmhrZt22Lp0qVmxVxcXIyRI0dCrVajSZMmiIuLMzw/zHm9uHPnDhITE+Ht7Y2mTZti0KBBKC4uNmvu8uXLER0dDU9PTygUCty4ccOsda9du4bx48cjNDQUbm5u0Gg0mDBhAkpKSsyO+/XXX0dwcDDc3Nzg4+ODAQMG4OTJk7V6jRRCID4+3vD/1Zy50dHRlX7Hb7zxhtnr7t+/H8888wzc3d3h6emJqKgofPDBB9XO/f3336t8fm3atMlkbqbYVIHduHEjpkyZgpkzZyInJwfh4eHo06cPLl++XO280tJShIeHY8mSJbVeMzMzE4mJiThw4AB27NiBe/fuITY2FqWlpTXODQgIwPz585GdnY2srCw888wzGDBgAH777bdaxXD48GEsW7YMHTt2NHtOu3btcPHiRcO2b98+s+Zdv34dTz/9NJydnfHTTz/hP//5Dz7++GM0a9bM7FgfXHfHjh0AgMGDB9c4d8GCBUhJScEXX3yBEydOYMGCBVi4cCE+//xzs9Z+7bXXsGPHDqxZswbHjh1DbGwsYmJicOHCBaNxNT0fFi5ciM8++wxLly7FwYMH4e7ujj59+uDOnTs1zi0tLUWPHj2wYMECkz+ram5ZWRlycnIwY8YM5OTkYPPmzcjLy0P//v3NjrtNmzb44osvcOzYMezbtw9BQUGIjY3FlStXzP4bSEtLw4EDB6BWq81eFwDi4uKMfu/r1683a+7p06fRo0cPhIWFISMjA0ePHsWMGTPg6upa49wH17t48SJWrlwJhUKBQYMG1Th3ypQpSE9Px9q1a3HixAlMmjQJSUlJ2LZtW7VzhRAYOHAgzpw5g61bt+LIkSMIDAxETEwMSktLzXq9mDx5Mr777jts2rQJmZmZKCoqwgsvvGDW3LKyMsTFxeHdd981iqumuUVFRSgqKsJHH32E48ePY9WqVUhPT8eYMWPMmg8AnTp1QmpqKk6cOIHt27dDCIHY2FhkZGSY/Rq5ePFio1vgmvv6OnbsWKPf9cKFC82au3//fsTFxSE2NhaHDh3C4cOHkZSUhH379lU7t2XLlpWeX7Nnz0bTpk0RHx9v8jllkrAhXbt2FYmJiYbH5eXlQq1Wi+TkZLOPAUCkpaXVOYbLly8LACIzM7NO85s1ayb+53/+x+zxN2/eFI899pjYsWOH6Nmzp5g4cWKNc2bOnCnCw8PrFN8777wjevToUae5pkycOFEEBwcLvV5f49i+ffuK0aNHG+174YUXxPDhw2ucW1ZWJpycnMT3339vtP/JJ58Uf//736uc9/DzQa/XCz8/P/Hhhx8a9t24cUMolUqxfv36auc+6OzZswKAOHLkiFnrmnLo0CEBQPzxxx91ml9SUiIAiJ07d5o19/z58+LRRx8Vx48fF4GBgeKTTz4xa92EhAQxYMCAamOpau7QoUPFK6+8Uqe5DxswYIB45plnzJrbrl078cEHHxjtM/VceXhuXl6eACCOHz9u2FdeXi58fHzEl19+WWnth18vbty4IZydncWmTZsMY06cOCEAiP3791c790F79uwRAMT169cr/aymuRW++eYb4eLiIu7du1en+b/++qsAIAoKCsyae+TIEfHoo4+KixcvVvn7NDXX3Nc9U3O7desm3nvvvTrNfdgTTzxR6fWpJjZzBnv37l1kZ2cjJibGsK9Ro0aIiYnB/v376y2OirdUvLy8ajWvvLwcGzZsQGlpKSIjI82el5iYiL59+xrlbY78/Hyo1Wq0bt0aw4cPR2FhoVnztm3bhs6dO2Pw4MHw9fVFREQEvvzyy1qtXeHu3btYu3YtRo8ebbJxw8O6d++OXbt24dSpUwCAX3/9Ffv27TPrX4z3799HeXk5XF1djfa7ubmZffYOAGfPnsWlS5eM/n+rVCp069atXp9nwF/PNYVCgUceeaTWc+/evYvly5dDpVIhPDy8xvF6vR6vvvoqpk6dinbt2tV6vYyMDPj6+iI0NBRvvvkm/vzzT7PW/OGHH9CmTRv06dMHvr6+6NatW60+wqlQXFyMH374wXBGVpPu3btj27ZtuHDhAoQQ2LNnD06dOoXY2Nhq5+l0OgAwep41atQISqXS5PPs4deL7Oxs3Lt3z+j5FRYWBo1GU+n5VdfXGnPnlpSUwNPTE40bV74lfU3zS0tLkZqailatWlXqfmZqbllZGV5++WUsWbIEfn5+tY7766+/RvPmzdG+fXtMnz4dZWVlNc69fPkyDh48CF9fX3Tv3h0tWrRAz549zfo9PSw7Oxu5ublmP78MalWOG9CFCxcEAPHLL78Y7Z86daro2rWr2ceBBWew5eXlom/fvuLpp582e87Ro0eFu7u7cHJyEiqVSvzwww9mz12/fr1o3769uH37thDC/H/J/fjjj+Kbb74Rv/76q0hPTxeRkZFCo9EIrVZb41ylUimUSqWYPn26yMnJEcuWLROurq5i1apVZsddYePGjcLJyUlcuHDBrPHl5eXinXfeEQqFQjRu3FgoFAoxb948s9eLjIwUPXv2FBcuXBD3798Xa9asEY0aNRJt2rSpcs7Dz4f//d//FQBEUVGR0bjBgweLIUOGVDv3QZaewd6+fVs8+eST4uWXX67V/O+++064u7sLhUIh1Gq1OHTokFlz582bJ/72t78Z3mmozRns+vXrxdatW8XRo0dFWlqaePzxx0WXLl3E/fv3q51bcSbTpEkTsWjRInHkyBGRnJwsFAqFyMjIMCvfCgsWLBDNmjUz/K3UNPfOnTtixIgRAoBo3LixcHFxEatXr65x7t27d4VGoxGDBw8W165dEzqdTsyfP18AELGxsUZzTb1efP3118LFxaXSOl26dBFvv/12tXMfVN0ZrDmvU1euXBEajUa8++67tZq/ZMkS4e7uLgCI0NDQSmevVc0dN26cGDNmjOGxqd9JVXOXLVsm0tPTxdGjR8XatWvFo48+Kp5//vka5+7fv18AEF5eXmLlypUiJydHTJo0Sbi4uIhTp06ZlW+FN998Uzz++ONV/rwqLLC18MYbb4jAwEBx7tw5s+fodDqRn58vsrKyxLRp00Tz5s3Fb7/9VuO8wsJC4evrK3799VfDPnML7MOuX78uPD09zXpr2tnZWURGRhrtGz9+vHjqqadqvW5sbKx47rnnzB6/fv16ERAQINavXy+OHj0qvvrqK+Hl5WV2cS8oKBBRUVECgHBychJdunQRw4cPF2FhYVXOscYCe/fuXdGvXz8REREhSkpKajX/1q1bIj8/X+zfv1+MHj1aBAUFieLi4mrnZmVliRYtWhj9Q6g2BfZhp0+fNuut6Yq/6WHDhhmN69evn3jppZdqtW5oaKhISkoy+TNTcz/88EPRpk0bsW3bNvHrr7+Kzz//XDRt2lTs2LGjxrlZWVkiPDzc8Dzr06ePiI+PF3FxcUbjTL1emFtga3qtqa7A1jS3pKREdO3aVcTFxYm7d+/Wav6NGzfEqVOnRGZmpujXr5948sknjf5RY2ru1q1bRUhIiLh586Zhn6n/r+a+vu7atavSW9Om5lb8LU+fPt1ofocOHcS0adPMXresrEyoVCrx0UcfVRuXKTZTYHU6nXBycqr0SxkxYoTo37+/2cepa4FNTEwUAQEB4syZM7We+6DevXuLcePG1TguLS3N8AdcsQEQCoVCODk5VTo7qEnnzp2NnlRV0Wg0Rv/SFEKIf/7zn0KtVtdqvd9//100atRIbNmyxew5AQEB4osvvjDaN2fOHBEaGlqrtW/dumUokEOGDBHPPvtslWMffj5UFIeHC2NUVJSYMGFCtXMfVNcCe/fuXTFw4EDRsWNHcfXqVbPjrkpISEildwEenvvJJ58YnlcPPtcaNWokAgMD67Ru8+bNxdKlS6udq9PpROPGjcWcOXOMxr399tuie/fuZq+7d+9eAUDk5uaa/PnDc8vKyoSzs3Olz+vHjBkj+vTpY/a6N27cEJcvXxZC/HV9yFtvvWX4WVWvFxXF4eHCqNFoxKJFi6qd+6CqCmxNc7VarYiMjBS9e/c2ebZfm9c5nU4nmjRpItatW1ft3IkTJ1b5/OrZs2et171165YAINLT06ude+bMGQFArFmzxmj/kCFDDO8MmbPuV199JZydnQ2/69qwmc9gXVxc0KlTJ+zatcuwT6/XY9euXbX6TLO2hBBISkpCWloadu/ejVatWll0PL1eb/gcpzq9e/fGsWPHkJuba9g6d+6M4cOHIzc3F05OTmaveevWLZw+fRr+/v41jn366acrXep+6tQpBAYGmr0eAKSmpsLX1xd9+/Y1e05ZWVmlJsZOTk7Q6/W1Wtvd3R3+/v64fv06tm/fjgEDBpg9t1WrVvDz8zN6nmm1Whw8eFDW5xnw11d1hgwZgvz8fOzcuRPe3t4WH9Oc59urr76Ko0ePGj3X1Go1pk6diu3bt9d6zfPnz+PPP/+s8fnm4uKCLl26WPx8W7FiBTp16mTWZ83AX/+f7927Z/FzTaVSwcfHB/n5+cjKysKAAQNqfL3o1KkTnJ2djZ5feXl5KCwsxFNPPVXn1xpzXqe0Wi1iY2Ph4uKCbdu2GX2OXJfXOfHXCRru3LlT7dxp06ZVen4BwCeffIKVK1fWet2K+X5+ftXODQoKglqtNvn80mg0Zq+7YsUK9O/fHz4+PjXG9jCra7henSlTpiAhIQGdO3dG165dsXjxYpSWlmLUqFHVzrt16xYKCgoMj8+ePYvc3Fx4eXlBo9FUOzcxMRHr1q3D1q1b4eHhgUuXLgH464/Lzc2t2rnTp09HfHw8NBoNbt68iXXr1iEjI8OsFy0PDw+0b9/eaJ+7uzu8vb0r7X/Yf//3f6Nfv34IDAxEUVERZs6cCScnJwwbNqzGdSdPnozu3btj3rx5GDJkCA4dOoTly5dj+fLlNc6toNfrkZqaioSEBJMXUFSlX79+mDt3LjQaDdq1a4cjR45g0aJFGD16tFnzK746EBoaioKCAkydOhVhYWGVnh81PR8mTZqEf/zjH3jsscfQqlUrzJgxA2q1GgMHDqxx7rVr11BYWGj4/mrFH7efnx+aNm1a5Vx/f3+8+OKLyMnJwffff4/y8nLDc83LywsuLi7Vru3t7Y25c+eif//+8Pf3x9WrV7FkyRJcuHABgwcPrjHuh4u5s7Mz/Pz8EBoaWu1cLy8vzJ49G4MGDYKfnx9Onz6Nt99+GyEhIejTp0+N606dOhVDhw5FVFQUevXqhfT0dHz33XfIyMgw6+9Wq9Vi06ZN+Pjjj2v1O+7ZsyemTp0KNzc3BAYGIjMzE1999RUWLVpU49xNmzbBx8cHGo0Gx44dw8SJEzFw4EDExsbirbfeqvb1QqVSYcyYMZgyZQq8vLzg6emJ8ePHIzIyEmvWrKnxtebSpUu4dOmSIb5jx47Bw8MDn332GTZv3lzl3IriWlZWhrVr10Kr1UKr1QIAfHx8MH78+GrXPnPmDDZu3IjY2Fj4+Pjg/PnzmD9/Ptzc3LB3716kpaVVOdfPz8/khU0ajQYfffRRteuePn0a69atw7PPPgtvb28cPXoUkydPRlRUFJYtW1btXIVCgalTp2LmzJkIDw/HE088gdWrV+PkyZNo27Ytfvjhhxpf1wsKCrB37178+OOPleI3S63PeRvY559/LjQajXBxcRFdu3YVBw4cqHFOxdspD28JCQk1zjU1D4BITU2tce7o0aNFYGCgcHFxET4+PqJ3797i3//+txlZmmbuZ7BDhw4V/v7+wsXFRTz66KNi6NChlS5GqM53330n2rdvL5RKpQgLCxPLly+vVZzbt28XAEReXl6t5mm1WjFx4kSh0WiEq6uraN26tfj73/8udDqdWfM3btwoWrduLVxcXISfn59ITEwUN27cqDSupueDXq8XM2bMEC1atBBKpVL07t3bkEtNc1NTU03+fObMmdXOrXhL2dS2Z8+eGte+ffu2eP7554VarRYuLi7C399f9O/f33CRU23/Bh78DLa6uWVlZSI2Nlb4+PgIZ2dnERgYKMaOHSsuXbpk9rorVqwQISEhwtXVVYSHhxs+VjBn7rJly4Sbm1ul33NNcy9evChGjhwp1Gq1cHV1FaGhoeLjjz8Wer2+xrmffvqpCAgIEM7OzkKj0Yj33nvP8Bw15/Xi9u3b4q233hLNmjUTTZo0Ec8//7zhgq+a5s6cObPKcdXNrSonANU+9yrmX7hwQcTHxwtfX1/h7OwsAgICxMsvvyxOnjxZp9dI/P9vvdc0t7CwUERFRQkvLy+hVCpFSEiImDp1quEraOasm5ycLAICAkSTJk1EZGSk+Pnnn82eO336dNGyZUtRXl5eZS7VYbs6IiIiGdjMZ7BERES2hAWWiIhIBiywREREMmCBJSIikgELLBERkQxYYImIiGTAAktERCQDFlgiIiIZsMASERHJgAWWiIhIBiywREREMmCBJSIiksH/B/cLCEtulL5qAAAAAElFTkSuQmCC",
"text/plain": [
"<Figure size 500x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# obtain one batch of test images\n",
"dataiter = iter(test_input_output)\n",
"input, expected_output, offset = next(dataiter)\n",
"\n",
"# get sample outputs\n",
"output = model(input)\n",
"\n",
"output_tensor = output.cpu().detach()\n",
"#print(\"output_tensor.shape\", output_tensor.shape)\n",
"output_tensor = output_tensor.permute(1, 2, 0)\n",
"#print(\"output_tensor.shape\", output_tensor.shape)\n",
"output_numpy = output_tensor.numpy()\n",
"#print(\"output_numpy.shape\", output_numpy.shape)\n",
"\n",
"from color_xy import xy_to_color\n",
"\n",
"deobfuscated = []\n",
"COLOR_UNDEFINED = 10\n",
"for y in range(0,IMAGE_SIZE):\n",
" columns2 = [COLOR_UNDEFINED] * IMAGE_SIZE\n",
" deobfuscated.append(columns2)\n",
"\n",
"offset_int = int(offset * 10.0)\n",
"for row_index, row in enumerate(output_numpy):\n",
" #print(\"row_index\", row_index)\n",
" for column_index, xy in enumerate(row):\n",
" color_index = np.argmax(xy)\n",
" color_index = (color_index + 10 - offset_int) % 10\n",
" deobfuscated[row_index][column_index] = color_index\n",
" #x, y = xy\n",
" #distance = x * x + y * y\n",
" #if distance > 0.35 and distance < 1.5:\n",
" # color = xy_to_color((x, y), 10, offset)\n",
" # deobfuscated[row_index][column_index] = color\n",
"\n",
"pixels = np.array(deobfuscated, np.int32)\n",
"result = ajm.Image(pixels, \"predicted\")\n",
"result.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "789a56c4-e809-462c-8a02-ad6fff0922c0",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.4"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
|