diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..092c457c16e5d8d585b1f3c4084f49457ea38d28 --- /dev/null +++ b/.gitignore @@ -0,0 +1,164 @@ +wandb/ +train_logs/ +slurms/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..5c1f70196fc3170daf0a5eff7cbe344559d57a08 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 MedARC + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b951243d8e1ace7b45097bac2fe05db7b1bdc94f --- /dev/null +++ b/README.md @@ -0,0 +1,12 @@ +# MindEyeV2 + +In-progress -- this repo is under active development in the MedARC discord server (feel free to join us and help develop MindEyeV2!) + +1. Download all of https://huggingface.co/datasets/pscotti/mindeyev2 and place them in a folder. You will need to specify the path to this folder as "data_path" variable. + +2. Run setup.sh to install a new "fmri" conda environment. + +3. Activate the conda environment with "conda activate fmri" + +4. Run Train.ipynb or Train.py (they are the same code) + diff --git a/src/Train-with-memory-Copy1.ipynb b/src/Train-with-memory-Copy1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f17cf99136fe3ff796273081d080380e3044fbb7 --- /dev/null +++ b/src/Train-with-memory-Copy1.ipynb @@ -0,0 +1,1668 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-09-06 17:33:22,756] [INFO] [real_accelerator.py:133:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 4046787\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,062,786,436 total\n", + "1,062,786,436 trainable\n", + "param counts:\n", + "1,127,216,516 total\n", + "1,127,216,516 trainable\n", + "torch.Size([2, 4096])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,hidden_dim))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "model.memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=4096)\n", + "\n", + "utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,127,216,516 total\n", + "1,127,216,516 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [], + "source": [ + "# params for wandb\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"clip_variant\": clip_variant,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if True: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|█████████████████████████████████████████████████ | 1/12 [03:39<40:15, 219.55s/it, test/blurry_pixcorr=tensor(0.1669, device='cuda:0', dtype=torch.float16), test/loss=34.3, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=1, test/test_bwd_pct_correct=tensor(0.0781, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.2109, device='cuda:0'), train/blurry_pixcorr=tensor(0.0751, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.0217, device='cuda:0'), train/fwd_pct_correct=tensor(0.0281, device='cuda:0'), train/loss=37.3, train/loss_blurry_total=32.7, train/loss_clip_total=4.66, train/lr=1.58e-5, train/num_steps=196]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 17%|██████████████████████████████████████████████████████████████████████████████████████████████████▌ | 2/12 [06:58<34:35, 207.55s/it, test/blurry_pixcorr=tensor(0.2539, device='cuda:0', dtype=torch.float16), test/loss=28.6, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=2, test/test_bwd_pct_correct=tensor(0.5625, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.8438, device='cuda:0'), train/blurry_pixcorr=tensor(0.1564, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.2590, device='cuda:0'), train/fwd_pct_correct=tensor(0.3288, device='cuda:0'), train/loss=32.2, train/loss_blurry_total=29.5, train/loss_clip_total=2.62, train/lr=3e-5, train/num_steps=392]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 3/12 [10:16<30:26, 202.92s/it, test/blurry_pixcorr=tensor(0.3035, device='cuda:0', dtype=torch.float16), test/loss=25.4, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=3, test/test_bwd_pct_correct=tensor(0.7969, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9453, device='cuda:0'), train/blurry_pixcorr=tensor(0.1978, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.6079, device='cuda:0'), train/fwd_pct_correct=tensor(0.6057, device='cuda:0'), train/loss=27.7, train/loss_blurry_total=26.6, train/loss_clip_total=1.08, train/lr=2.92e-5, train/num_steps=588]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 3/12 [13:33<30:26, 202.92s/it, test/blurry_pixcorr=tensor(0.3354, device='cuda:0', dtype=torch.float16), test/loss=23.7, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=4, test/test_bwd_pct_correct=tensor(0.8516, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.2186, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7068, device='cuda:0'), train/fwd_pct_correct=tensor(0.6488, device='cuda:0'), train/loss=25.5, train/loss_blurry_total=24.8, train/loss_clip_total=0.664, train/lr=2.7e-5, train/num_steps=784]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 4/12 [13:33<26:45, 200.72s/it, test/blurry_pixcorr=tensor(0.3354, device='cuda:0', dtype=torch.float16), test/loss=23.7, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=4, test/test_bwd_pct_correct=tensor(0.8516, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.2186, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7068, device='cuda:0'), train/fwd_pct_correct=tensor(0.6488, device='cuda:0'), train/loss=25.5, train/loss_blurry_total=24.8, train/loss_clip_total=0.664, train/lr=2.7e-5, train/num_steps=784]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 4/12 [16:51<26:45, 200.72s/it, test/blurry_pixcorr=tensor(0.3601, device='cuda:0', dtype=torch.float16), test/loss=23, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=5, test/test_bwd_pct_correct=tensor(0.9141, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9766, device='cuda:0'), train/blurry_pixcorr=tensor(0.2681, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7239, device='cuda:0'), train/fwd_pct_correct=tensor(0.6569, device='cuda:0'), train/loss=24.5, train/loss_blurry_total=23.9, train/loss_clip_total=0.542, train/lr=2.36e-5, train/num_steps=980]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 5/12 [16:51<23:18, 199.85s/it, test/blurry_pixcorr=tensor(0.3601, device='cuda:0', dtype=torch.float16), test/loss=23, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=5, test/test_bwd_pct_correct=tensor(0.9141, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9766, device='cuda:0'), train/blurry_pixcorr=tensor(0.2681, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7239, device='cuda:0'), train/fwd_pct_correct=tensor(0.6569, device='cuda:0'), train/loss=24.5, train/loss_blurry_total=23.9, train/loss_clip_total=0.542, train/lr=2.36e-5, train/num_steps=980]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 6/12 [20:09<19:53, 199.00s/it, test/blurry_pixcorr=tensor(0.3562, device='cuda:0', dtype=torch.float16), test/loss=22.5, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=6, test/test_bwd_pct_correct=tensor(0.9141, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9766, device='cuda:0'), train/blurry_pixcorr=tensor(0.2861, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7283, device='cuda:0'), train/fwd_pct_correct=tensor(0.6599, device='cuda:0'), train/loss=24, train/loss_blurry_total=23.5, train/loss_clip_total=0.49, train/lr=1.94e-5, train/num_steps=1176]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 58%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 7/12 [23:26<16:33, 198.62s/it, test/blurry_pixcorr=tensor(0.3687, device='cuda:0', dtype=torch.float16), test/loss=22.3, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=7, test/test_bwd_pct_correct=tensor(0.9609, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9688, device='cuda:0'), train/blurry_pixcorr=tensor(0.3105, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7268, device='cuda:0'), train/fwd_pct_correct=tensor(0.6540, device='cuda:0'), train/loss=23.7, train/loss_blurry_total=23.2, train/loss_clip_total=0.468, train/lr=1.47e-5, train/num_steps=1372]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 67%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 8/12 [26:45<13:13, 198.50s/it, test/blurry_pixcorr=tensor(0.3850, device='cuda:0', dtype=torch.float16), test/loss=22.1, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=8, test/test_bwd_pct_correct=tensor(0.9531, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.4414, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9725, device='cuda:0'), train/fwd_pct_correct=tensor(0.9727, device='cuda:0'), train/loss=21.7, train/loss_blurry_total=21.7, train/loss_clip_total=0.0512, train/lr=1e-5, train/num_steps=1568]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 9/12 [30:03<09:55, 198.34s/it, test/blurry_pixcorr=tensor(0.3928, device='cuda:0', dtype=torch.float16), test/loss=22, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=9, test/test_bwd_pct_correct=tensor(0.9531, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9766, device='cuda:0'), train/blurry_pixcorr=tensor(0.4688, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9726, device='cuda:0'), train/fwd_pct_correct=tensor(0.9724, device='cuda:0'), train/loss=21.2, train/loss_blurry_total=21.1, train/loss_clip_total=0.0565, train/lr=5.83e-6, train/num_steps=1764]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 83%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 10/12 [33:20<06:36, 198.06s/it, test/blurry_pixcorr=tensor(0.4014, device='cuda:0', dtype=torch.float16), test/loss=21.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=10, test/test_bwd_pct_correct=tensor(0.9531, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9922, device='cuda:0'), train/blurry_pixcorr=tensor(0.4910, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9740, device='cuda:0'), train/fwd_pct_correct=tensor(0.9741, device='cuda:0'), train/loss=20.8, train/loss_blurry_total=20.7, train/loss_clip_total=0.0697, train/lr=2.59e-6, train/num_steps=1960]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 92%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 11/12 [36:39<03:18, 198.41s/it, test/blurry_pixcorr=tensor(0.3962, device='cuda:0', dtype=torch.float16), test/loss=21.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=11, test/test_bwd_pct_correct=tensor(0.9453, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9922, device='cuda:0'), train/blurry_pixcorr=tensor(0.4988, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9733, device='cuda:0'), train/fwd_pct_correct=tensor(0.9733, device='cuda:0'), train/loss=20.6, train/loss_blurry_total=20.5, train/loss_clip_total=0.103, train/lr=5.79e-7, train/num_steps=2156]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [39:58<00:00, 198.36s/it, test/blurry_pixcorr=tensor(0.3967, device='cuda:0', dtype=torch.float16), test/loss=21.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=12, test/test_bwd_pct_correct=tensor(0.9453, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9922, device='cuda:0'), train/blurry_pixcorr=tensor(nan, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9736, device='cuda:0'), train/fwd_pct_correct=tensor(0.9737, device='cuda:0'), train/loss=20.6, train/loss_blurry_total=20.5, train/loss_clip_total=0.119, train/lr=1.22e-9, train/num_steps=2352]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [39:58<00:00, 199.84s/it, test/blurry_pixcorr=tensor(0.3967, device='cuda:0', dtype=torch.float16), test/loss=21.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=12, test/test_bwd_pct_correct=tensor(0.9453, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9922, device='cuda:0'), train/blurry_pixcorr=tensor(nan, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9736, device='cuda:0'), train/fwd_pct_correct=tensor(0.9737, device='cuda:0'), train/loss=20.6, train/loss_blurry_total=20.5, train/loss_clip_total=0.119, train/lr=1.22e-9, train/num_steps=2352]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===Finished!===\n", + "\n", + "saving /fsx/proj-fmri/paulscotti/MindEyeV2/train_logs/test/last.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=8, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory-cat-trial.ipynb b/src/Train-with-memory-cat-trial.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..03d14de0498e4f59d327adfd5a5bdce8d1d0fb4b --- /dev/null +++ b/src/Train-with-memory-cat-trial.ipynb @@ -0,0 +1,1893 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train-with-memory-cat.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-21 16:54:11,852] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 650840\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_mem_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,071,175,044 total\n", + "1,071,175,044 trainable\n", + "param counts:\n", + "1,135,605,124 total\n", + "1,135,605,124 trainable\n", + "torch.Size([2, 8192])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,8192))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "150,481,920 total\n", + "150,481,920 trainable\n", + "param counts:\n", + "335,601,664 total\n", + "335,601,664 trainable\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.out_dim = out_dim\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.memory_compressor = MemoryCompressor(in_dim=model.memory_encoder.out_dim, num_past=15, output_dim=4096)\n", + "\n", + "utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "251a1d93-40b9-451c-8d2f-2196f8a8ec1d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3edca702-e148-4f2d-82b9-1c42bca5f73f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 128, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231021_165517-ic3pwlix" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run test to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/ic3pwlix" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "---resuming from last.pth ckpt---\n", + "\n", + "Epoch 0\n" + ] + } + ], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if True:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load('/fsx/proj-fmri/ckadirt/MindEyeV2/train_mem_logs_cat/test_mem_cat_r/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " #optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " #lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif False:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ca96ce1e-fa2d-48eb-8c57-5b9fb86a8f52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+       "│ nnnn++                                                                                           │\n",
+       "│       ▲                                                                                          │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "SyntaxError: invalid syntax\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[91m╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\u001b[0m\n", + "\u001b[91m│\u001b[0m nnnn++ \u001b[91m│\u001b[0m\n", + "\u001b[91m│\u001b[0m \u001b[1;91m▲\u001b[0m \u001b[91m│\u001b[0m\n", + "\u001b[91m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mSyntaxError: \u001b[0minvalid syntax\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nnnn++" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "480bf0f9-e450-4abb-9ff8-9c5912ca500d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "checkpoint = torch.load('/fsx/proj-fmri/ckadirt/MindEyeV2/train_mem_logs/test_mem_cat_r/error.pth', map_location='cpu')\n", + "tensors = torch.load('/fsx/proj-fmri/ckadirt/MindEyeV2/train_mem_logs/test_mem_cat_r/error_tensors.pth', map_location='cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "775317fb-901b-454e-8611-9d0ee104c7d2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(checkpoint['model_state_dict'])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "ef28c894-5dc7-4d55-b1ee-78e39c2dd868", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "# Assuming you have the 'image' tensor with the specified shape\n", + "# image = torch.randn(64, 3, 224, 224) # Example tensor initialization\n", + "\n", + "# You can create a placeholder tensor for demonstration purposes\n", + "image = tensors['image']\n", + "\n", + "# Function to plot 64 images\n", + "def plot_images(image_tensor):\n", + " fig, axes = plt.subplots(8, 8, figsize=(16, 16))\n", + "\n", + " for i, ax in enumerate(axes.flatten()):\n", + " ax.imshow(image_tensor[i].permute(1, 2, 0)) # Permute the dimensions for proper display (assuming the format is [channels, height, width])\n", + " ax.axis('off')\n", + "\n", + " plt.show()\n", + "\n", + "# Plot the images\n", + "plot_images(image)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "1f440ab2-f316-4f29-9db0-94eaee2210c0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ttt = autoenc.to(dtype=torch.float64).encode(image.to('cuda').to(dtype=torch.float64)).latent_dist.mode()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e4039e4f-f1a1-4f12-9ba4-d128a15a44e9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([64, 4, 28, 28])" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ttt.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "bb7ae48f-45cb-4bce-aa7a-d067d63b188f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0, device='cuda:0')" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ttt.isnan().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "07a96717-cad5-4595-b7a8-cf2fb6fd6099", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 4.6166, 1.5668, 0.7028, 1.9033, -1.7032, 3.4360, 0.2725, 1.5986,\n", + " -1.5558, -0.1755, 0.8096, -0.2239, -2.2972, 0.3213, 1.1966, -0.1671,\n", + " 1.0937, -1.5774, -1.3411, -3.4571, -1.2606, -1.1182, -1.1425, -1.1460,\n", + " -0.7740, -1.8035, -1.7735, -1.9468], device='cuda:0',\n", + " dtype=torch.float64)" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ttt[29,0,0,0:50]" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "ffcdc33c-4cbe-4628-ba5f-ec0d84450874", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,\n", + " nan, nan, nan, nan], dtype=torch.float16, grad_fn=)" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tensors['blurry_image_enc_'][29,0,0,0:50]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "953225db-5df5-4515-b48a-857b23479717", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "nan_indices = torch.where(torch.isnan(tensors['blurry_image_enc_']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b85cc42-f3e3-4fbf-9d55-4018dc480bb1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ccc = 0\n", + "for idx in range(len(nan_indices[0])):\n", + " print(f\"({nan_indices[0][idx]}, {nan_indices[1][idx]}, {nan_indices[2][idx]}, {nan_indices[3][idx]})\")\n", + " if nan_indices[0][idx] == 29:\n", + " ccc =ccc + 1\n", + " if idx == 12:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "7f48e5a6-5a24-4d0a-beaa-61e16f87dc3b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model has NaNs in parameter: backbone.upsampler.mid_block.resnets.1.conv2.weight\n", + "tensor(48)\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def check_for_nans(model):\n", + " for name, param in model.named_parameters():\n", + " if torch.isnan(param).any():\n", + " print(f\"Model has NaNs in parameter: {name}\")\n", + " print(torch.isnan(param).sum())\n", + " return True\n", + " return False\n", + "\n", + "check_for_nans(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "b884da56-9bdf-4f2e-b2f0-af1ac86be72d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13\n" + ] + } + ], + "source": [ + "print(ccc)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "83b8d3a8-42ad-49b4-839f-32273477c36c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voxel\n", + "tensor(0) torch.Size([64, 15729])\n", + "image\n", + "tensor(0) torch.Size([64, 3, 224, 224])\n", + "past_15_voxels\n", + "tensor(0) torch.Size([960, 15729])\n", + "past_15_times\n", + "tensor(0) torch.Size([960])\n", + "embeds_past_voxels\n", + "tensor(0) torch.Size([64, 15, 4096])\n", + "information_past_voxels\n", + "tensor(0) torch.Size([64, 4096])\n", + "voxel_ridge\n", + "tensor(0) torch.Size([64, 8192])\n", + "blurry_image_enc\n", + "tensor(0) torch.Size([64, 4, 28, 28])\n", + "clip_target\n", + "tensor(0) torch.Size([64, 257, 768])\n", + "clip_voxels\n", + "tensor(0) torch.Size([64, 257, 768])\n", + "blurry_image_enc_\n", + "tensor(3136) torch.Size([64, 4, 28, 28])\n", + "clip_voxels_norm\n", + "tensor(0) torch.Size([64, 197376])\n", + "clip_target_norm\n", + "tensor(0) torch.Size([64, 197376])\n", + "loss\n", + "tensor(1) torch.Size([])\n", + "loss_clip\n", + "tensor(0) torch.Size([])\n", + "loss_blurry\n", + "tensor(1) torch.Size([])\n", + "loss_clip_total\n" + ] + }, + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:3                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│   1 for key in tensors:                                                                          │\n",
+       "│   2 │   print(key)                                                                               │\n",
+       "│ ❱ 3 │   print(tensors[key].isnan().sum(), tensors[key].shape)                                    │\n",
+       "│   4                                                                                              │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "AttributeError: 'float' object has no attribute 'isnan'\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m3\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1 \u001b[0m\u001b[94mfor\u001b[0m key \u001b[95min\u001b[0m tensors: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0m\u001b[2m│ \u001b[0m\u001b[96mprint\u001b[0m(key) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m3 \u001b[2m│ \u001b[0m\u001b[96mprint\u001b[0m(tensors[key].isnan().sum(), tensors[key].shape) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m4 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mAttributeError: \u001b[0m\u001b[32m'float'\u001b[0m object has no attribute \u001b[32m'isnan'\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for key in tensors:\n", + " print(key)\n", + " print(tensors[key].isnan().sum(), tensors[key].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, train_dl, test_dl = accelerator.prepare(\n", + "model, train_dl, test_dl\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " if True:\n", + " break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " # reshape past voxels to be (batch_size * 15, 15279)\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " #print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " #print(embeds_past_voxels.shape)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1)\n", + " #print(embeds_past_voxels.shape)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + "\n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print('test')\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + "\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + "\n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " #print('blurry_image_enc', blurry_image_enc)\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + " #print('clip_target', clip_target)\n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + " \n", + " print('information_past_voxels', information_past_voxels, information_past_voxels.shape)\n", + "\n", + " \n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " print('voxel_ridge', voxel_ridge, voxel_ridge.shape)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " print('loss', loss, loss.shape)\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": 0,\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory-cat.ipynb b/src/Train-with-memory-cat.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1c9fcbf045ab99f443628b4ac31d740a54bcc621 --- /dev/null +++ b/src/Train-with-memory-cat.ipynb @@ -0,0 +1,1755 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train-with-memory-cat.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 3732719\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_mem_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,071,175,044 total\n", + "1,071,175,044 trainable\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n", + "torch.Size([2, 8192])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,8192))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "150,481,920 total\n", + "150,481,920 trainable\n", + "param counts:\n", + "335,601,664 total\n", + "335,601,664 trainable\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.out_dim = out_dim\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.memory_compressor = MemoryCompressor(in_dim=model.memory_encoder.out_dim, num_past=15, output_dim=4096)\n", + "\n", + "utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3edca702-e148-4f2d-82b9-1c42bca5f73f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:1                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ ❱ 1 nnnn                                                                                         │\n",
+       "│   2                                                                                              │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "NameError: name 'nnnn' is not defined\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1 nnnn \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mNameError: \u001b[0mname \u001b[32m'nnnn'\u001b[0m is not defined\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 128, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231015_224404-lbkf7608" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run mem1 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/lbkf7608" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:34 │\n", + "│ │\n", + "│ 31 │ │ │ past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_s │\n", + "│ 32 │ │ │ past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 │\n", + "│ 33 │ │ │ │\n", + "│ ❱ 34 │ │ │ blurry_image_enc = autoenc.encode(image).latent_dist.mode() │\n", + "│ 35 │ │ │ │\n", + "│ 36 │ │ │ if use_image_aug: image = img_augment(image) │\n", + "│ 37 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/accelerate_utils.py:46 in wrapper │\n", + "│ │\n", + "│ 43 │ def wrapper(self, *args, **kwargs): │\n", + "│ 44 │ │ if hasattr(self, \"_hf_hook\") and hasattr(self._hf_hook, \"pre_forward\"): │\n", + "│ 45 │ │ │ self._hf_hook.pre_forward(self) │\n", + "│ ❱ 46 │ │ return method(self, *args, **kwargs) │\n", + "│ 47 │ │\n", + "│ 48 │ return wrapper │\n", + "│ 49 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/autoencoder_kl.py:258 in encode │\n", + "│ │\n", + "│ 255 │ │ │ encoded_slices = [self.encoder(x_slice) for x_slice in x.split(1)] │\n", + "│ 256 │ │ │ h = torch.cat(encoded_slices) │\n", + "│ 257 │ │ else: │\n", + "│ ❱ 258 │ │ │ h = self.encoder(x) │\n", + "│ 259 │ │ │\n", + "│ 260 │ │ moments = self.quant_conv(h) │\n", + "│ 261 │ │ posterior = DiagonalGaussianDistribution(moments) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/vae.py:141 in forward │\n", + "│ │\n", + "│ 138 │ │ else: │\n", + "│ 139 │ │ │ # down │\n", + "│ 140 │ │ │ for down_block in self.down_blocks: │\n", + "│ ❱ 141 │ │ │ │ sample = down_block(sample) │\n", + "│ 142 │ │ │ │\n", + "│ 143 │ │ │ # middle │\n", + "│ 144 │ │ │ sample = self.mid_block(sample) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/unet_2d_blocks.py:1247 in forward │\n", + "│ │\n", + "│ 1244 │ │\n", + "│ 1245 │ def forward(self, hidden_states, scale: float = 1.0): │\n", + "│ 1246 │ │ for resnet in self.resnets: │\n", + "│ ❱ 1247 │ │ │ hidden_states = resnet(hidden_states, temb=None, scale=scale) │\n", + "│ 1248 │ │ │\n", + "│ 1249 │ │ if self.downsamplers is not None: │\n", + "│ 1250 │ │ │ for downsampler in self.downsamplers: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/resnet.py:650 in forward │\n", + "│ │\n", + "│ 647 │ │ if self.time_embedding_norm == \"ada_group\" or self.time_embedding_norm == \"spati │\n", + "│ 648 │ │ │ hidden_states = self.norm2(hidden_states, temb) │\n", + "│ 649 │ │ else: │\n", + "│ ❱ 650 │ │ │ hidden_states = self.norm2(hidden_states) │\n", + "│ 651 │ │ │\n", + "│ 652 │ │ if temb is not None and self.time_embedding_norm == \"scale_shift\": │\n", + "│ 653 │ │ │ scale, shift = torch.chunk(temb, 2, dim=1) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/normal │\n", + "│ ization.py:273 in forward │\n", + "│ │\n", + "│ 270 │ │ │ init.zeros_(self.bias) │\n", + "│ 271 │ │\n", + "│ 272 │ def forward(self, input: Tensor) -> Tensor: │\n", + "│ ❱ 273 │ │ return F.group_norm( │\n", + "│ 274 │ │ │ input, self.num_groups, self.weight, self.bias, self.eps) │\n", + "│ 275 │ │\n", + "│ 276 │ def extra_repr(self) -> str: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/functional.py: │\n", + "│ 2530 in group_norm │\n", + "│ │\n", + "│ 2527 │ if input.dim() < 2: │\n", + "│ 2528 │ │ raise RuntimeError(f\"Expected at least 2 dimensions for input tensor but receive │\n", + "│ 2529 │ _verify_batch_size([input.size(0) * input.size(1) // num_groups, num_groups] + list( │\n", + "│ ❱ 2530 │ return torch.group_norm(input, num_groups, weight, bias, eps, torch.backends.cudnn.e │\n", + "│ 2531 │\n", + "│ 2532 │\n", + "│ 2533 def local_response_norm(input: Tensor, size: int, alpha: float = 1e-4, beta: float = 0.7 │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "OutOfMemoryError: CUDA out of memory. Tried to allocate 3.06 GiB (GPU 0; 39.56 GiB total capacity; 33.04 GiB \n", + "already allocated; 752.56 MiB free; 37.34 GiB reserved in total by PyTorch) If reserved memory is >> allocated \n", + "memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m34\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 31 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_voxels = voxels[past_behav[:,:,\u001b[94m5\u001b[0m].cpu().long()].to(device) \u001b[2m# batch_s\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 32 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_times = torch.Tensor([i \u001b[94mfor\u001b[0m i \u001b[95min\u001b[0m \u001b[96mrange\u001b[0m(\u001b[94m15\u001b[0m)]).to(device) \u001b[2m# 15\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 33 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 34 \u001b[2m│ │ │ \u001b[0mblurry_image_enc = autoenc.encode(image).latent_dist.mode() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 35 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 36 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m use_image_aug: image = img_augment(image) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 37 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/\u001b[0m\u001b[1;33maccelerate_utils.py\u001b[0m:\u001b[94m46\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m43 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mwrapper\u001b[0m(\u001b[96mself\u001b[0m, *args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m44 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m, \u001b[33m\"\u001b[0m\u001b[33m_hf_hook\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m._hf_hook, \u001b[33m\"\u001b[0m\u001b[33mpre_forward\u001b[0m\u001b[33m\"\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m45 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m._hf_hook.pre_forward(\u001b[96mself\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m46 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m method(\u001b[96mself\u001b[0m, *args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m47 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m48 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m wrapper \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m49 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mautoencoder_kl.py\u001b[0m:\u001b[94m258\u001b[0m in \u001b[92mencode\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m255 \u001b[0m\u001b[2m│ │ │ \u001b[0mencoded_slices = [\u001b[96mself\u001b[0m.encoder(x_slice) \u001b[94mfor\u001b[0m x_slice \u001b[95min\u001b[0m x.split(\u001b[94m1\u001b[0m)] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m256 \u001b[0m\u001b[2m│ │ │ \u001b[0mh = torch.cat(encoded_slices) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m257 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m258 \u001b[2m│ │ │ \u001b[0mh = \u001b[96mself\u001b[0m.encoder(x) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m259 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m260 \u001b[0m\u001b[2m│ │ \u001b[0mmoments = \u001b[96mself\u001b[0m.quant_conv(h) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m261 \u001b[0m\u001b[2m│ │ \u001b[0mposterior = DiagonalGaussianDistribution(moments) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mvae.py\u001b[0m:\u001b[94m141\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m138 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m139 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# down\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m140 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m down_block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.down_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m141 \u001b[2m│ │ │ │ \u001b[0msample = down_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m142 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m143 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# middle\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m144 \u001b[0m\u001b[2m│ │ │ \u001b[0msample = \u001b[96mself\u001b[0m.mid_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1247\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1244 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1245 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, hidden_states, scale: \u001b[96mfloat\u001b[0m = \u001b[94m1.0\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1246 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m resnet \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.resnets: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1247 \u001b[2m│ │ │ \u001b[0mhidden_states = resnet(hidden_states, temb=\u001b[94mNone\u001b[0m, scale=scale) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1248 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1249 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.downsamplers \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1250 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m downsampler \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.downsamplers: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mresnet.py\u001b[0m:\u001b[94m650\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m647 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mada_group\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mspati\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m648 \u001b[0m\u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states, temb) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m649 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m650 \u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m651 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m652 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m temb \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mand\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mscale_shift\u001b[0m\u001b[33m\"\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m653 \u001b[0m\u001b[2m│ │ │ \u001b[0mscale, shift = torch.chunk(temb, \u001b[94m2\u001b[0m, dim=\u001b[94m1\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mnormal\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mization.py\u001b[0m:\u001b[94m273\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m270 \u001b[0m\u001b[2m│ │ │ \u001b[0minit.zeros_(\u001b[96mself\u001b[0m.bias) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m271 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m272 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, \u001b[96minput\u001b[0m: Tensor) -> Tensor: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m273 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m F.group_norm( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m274 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96minput\u001b[0m, \u001b[96mself\u001b[0m.num_groups, \u001b[96mself\u001b[0m.weight, \u001b[96mself\u001b[0m.bias, \u001b[96mself\u001b[0m.eps) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m275 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m276 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mextra_repr\u001b[0m(\u001b[96mself\u001b[0m) -> \u001b[96mstr\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/\u001b[0m\u001b[1;33mfunctional.py\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m2530\u001b[0m in \u001b[92mgroup_norm\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2527 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m \u001b[96minput\u001b[0m.dim() < \u001b[94m2\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2528 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mRuntimeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mExpected at least 2 dimensions for input tensor but receive\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2529 \u001b[0m\u001b[2m│ \u001b[0m_verify_batch_size([\u001b[96minput\u001b[0m.size(\u001b[94m0\u001b[0m) * \u001b[96minput\u001b[0m.size(\u001b[94m1\u001b[0m) // num_groups, num_groups] + \u001b[96mlist\u001b[0m( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2530 \u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m torch.group_norm(\u001b[96minput\u001b[0m, num_groups, weight, bias, eps, torch.backends.cudnn.e \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2531 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2532 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2533 \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mlocal_response_norm\u001b[0m(\u001b[96minput\u001b[0m: Tensor, size: \u001b[96mint\u001b[0m, alpha: \u001b[96mfloat\u001b[0m = \u001b[94m1e-4\u001b[0m, beta: \u001b[96mfloat\u001b[0m = \u001b[94m0.7\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.06\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m39.56\u001b[0m GiB total capacity; \u001b[1;36m33.04\u001b[0m GiB \n", + "already allocated; \u001b[1;36m752.56\u001b[0m MiB free; \u001b[1;36m37.34\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated \n", + "memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " #if epoch == 0 or epoch == 1:\n", + " # break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " # reshape past voxels to be (batch_size * 15, 15279)\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " #print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " #print(embeds_past_voxels.shape)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1)\n", + " #print(embeds_past_voxels.shape)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + "\n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print('test')\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + "\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + "\n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " \n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory-cat.py b/src/Train-with-memory-cat.py new file mode 100644 index 0000000000000000000000000000000000000000..bc2dfd63678367ffc09a0b4a21f981e6bc89ad0b --- /dev/null +++ b/src/Train-with-memory-cat.py @@ -0,0 +1,1056 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[3]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +# from subprocess import call +# command = "jupyter nbconvert Train-with-memory-cat.ipynb --to python" +# call(command,shell=True) + + +# # Import packages & functions + +# In[4]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 128 #128 + + +# In[5]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[6]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[7]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # Example use + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name=test \ + --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \ + --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[8]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=240, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + + +# In[9]: + + +outdir = os.path.abspath(f'../train_mem_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[10]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + + +# ### check dataloaders are working + +# In[9]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + +# # train_images = np.hstack((train_images, test_images)) +# # print("WARNING: ADDED TEST IMAGES TO TRAIN IMAGES") + + +# ## Load data and images + +# In[ ]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[ ]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + +clip_seq_dim = 257 +clip_emb_dim = 768 +hidden_dim = 4096 + + +# ### SD VAE (blurry images) + +# In[ ]: + + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# ### MindEye modules + +# In[13]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[14]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +print(b.shape, model.ridge(b).shape) + + +# In[22]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + self.upsampler = Decoder( + in_channels=64, + out_channels=4, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[64, 128, 256], + layers_per_block=1, + ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + b = self.blin1(x) + b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + return c, b + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((2,8192)) +print(b.shape) +clip_, blur_ = model.backbone(b) +print(clip_.shape, blur_.shape) + + +# In[23]: + + +# memory model + +from timm.layers.mlp import Mlp + +class MemoryEncoder(nn.Module): + def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15): + super().__init__() + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.out_dim = out_dim + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.final_input_dim = in_dim + embedding_time_dim + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.n_blocks = n_blocks + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim))) + + + def forward(self, x, time): + time = time.long() + time = self.embedding_time(time) + x = torch.cat((x, time), dim=-1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory encoder +# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512) + +# device = torch.device("cpu") +# memory_encoder.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_encoder.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15279)).to(device) +# rand_time = torch.randint(0, 15, (2,)).to(device) +# print(rand_input.shape, rand_time.shape) +# memory_encoder(rand_input, rand_time).shape + +class MemoryCompressor(nn.Module): + def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15): + super().__init__() + self.num_past = num_past + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.final_input_dim = in_dim * num_past + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, output_dim, bias=True) + self.n_blocks = n_blocks + self.num_past = num_past + self.output_dim = output_dim + + def forward(self, x): + # x is (batch_size, num_past, in_dim) + x = x.reshape(len(x), -1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory compressor +# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768) + +# device = torch.device("cpu") +# memory_compressor.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_compressor.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15, 768)).to(device) +# print(rand_input.shape) +# memory_compressor(rand_input).shape + +model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.memory_compressor = MemoryCompressor(in_dim=model.memory_encoder.out_dim, num_past=15, output_dim=4096) + +utils.count_params(model.memory_encoder) +utils.count_params(model.memory_compressor) +utils.count_params(model) + + + +# In[24]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, + {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# In[18]: + + + + + +# # Weights and Biases + +# In[25]: + + +# params for wandb +wandb_log = True +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + + wandb_project = 'stability' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=model_name, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # More custom functions + +# In[26]: + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + + +# # Main + +# In[27]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[28]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[29]: +no_more = False + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + #if epoch == 0 or epoch == 1: + # break + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + # reshape past voxels to be (batch_size * 15, 15279) + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + #print(past_15_voxels.shape, past_15_times.shape) + + embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + + voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + loss_blurry_total += loss_blurry.item() + + loss = loss_blurry + loss_clip + + + print('voxel', voxel.shape, voxel) + print('image', image.shape, image) + print('past_15_voxels', past_15_voxels.shape) + print('past_15_times', past_15_times.shape) + print('embeds_past_voxels', embeds_past_voxels.shape) + print('information_past_voxels', information_past_voxels.shape) + print('voxel_ridge', voxel_ridge.shape) + print('clip_target', clip_target.shape) + print('clip_voxels', clip_voxels.shape) + print('clip_voxels_norm', clip_voxels_norm.shape) + print('clip_target_norm', clip_target_norm.shape) + print('loss_clip_total', loss_clip_total) + print('loss_blurry_total', loss_blurry_total) + print('loss_clip', loss_clip) + print('loss_blurry', loss_blurry) + print('train_i', train_i) + print('epoch', epoch) + + e = utils.check_loss(loss) + if e == 'NaN loss': + no_more = True + print("saving ckpt") + save_ckpt(f'error') + # save all the tensors + torch.save({ + 'voxel': voxel, + 'image': image, + 'past_15_voxels': past_15_voxels, + 'past_15_times': past_15_times, + 'embeds_past_voxels': embeds_past_voxels, + 'information_past_voxels': information_past_voxels, + 'voxel_ridge': voxel_ridge, + 'blurry_image_enc': blurry_image_enc, + 'clip_target': clip_target, + 'clip_voxels': clip_voxels, + 'blurry_image_enc_': blurry_image_enc_, + 'clip_voxels_norm': clip_voxels_norm, + 'clip_target_norm': clip_target_norm, + 'loss': loss, + 'loss_clip': loss_clip, + 'loss_blurry': loss_blurry, + 'loss_clip_total': loss_clip_total, + 'loss_blurry_total': loss_blurry_total, + 'train_i': train_i, + 'epoch': epoch, + 'model_state_dict': model.state_dict(), + }, outdir+f'/error_tensors.pth') + + print("Error with loss here") + print('voxel', voxel.shape, voxel) + print('image', image.shape, image) + print('past_15_voxels', past_15_voxels.shape, past_15_voxels) + print('past_15_times', past_15_times.shape, past_15_times) + print('embeds_past_voxels', embeds_past_voxels.shape, embeds_past_voxels) + print('information_past_voxels', information_past_voxels.shape, information_past_voxels) + print('voxel_ridge', voxel_ridge.shape, voxel_ridge) + print('clip_target', clip_target.shape, clip_target) + print('clip_voxels', clip_voxels.shape, clip_voxels) + print('clip_voxels_norm', clip_voxels_norm.shape, clip_voxels_norm) + print('clip_target_norm', clip_target_norm.shape, clip_target_norm) + print('loss_clip_total', loss_clip_total) + print('loss_blurry_total', loss_blurry_total) + print('loss_clip', loss_clip) + print('loss_blurry', loss_blurry) + print('train_i', train_i) + print('epoch', epoch) + + + + + + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + with torch.no_grad(): + # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False) + blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + print('test') + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + assert len(image) == batch_size + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + clip_target = clip_model.embed_image(image.float()) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + print(past_15_voxels.shape, past_15_times.shape) + + embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times) + embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + + voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + axes[0].imshow(utils.torch_to_Image(image[[0]])) + axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + axes[2].imshow(utils.torch_to_Image(image[[1]])) + axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + plt.show() + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if no_more: + print("not writing more") + if ((epoch % ckpt_interval == 0) and (not no_more)): + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/src/Train-with-memory-rr-dropout.py b/src/Train-with-memory-rr-dropout.py new file mode 100644 index 0000000000000000000000000000000000000000..447262de97922daf4aa8c0002269385b15ffca6b --- /dev/null +++ b/src/Train-with-memory-rr-dropout.py @@ -0,0 +1,1040 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[ ]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train-with-memory-rr.ipynb --to python" +#call(command,shell=True) + + +# In[24]: + + +#get_ipython().system('nvidia-smi') + + +# # Import packages & functions + +# In[3]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 512 #128 + + +# In[4]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[5]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[6]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # Example use + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name=test \ + --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \ + --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[7]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="memory_cat_rr", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=240, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + + +# In[8]: + + +outdir = os.path.abspath(f'../train_mem_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[9]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + + +# ### check dataloaders are working + +# In[10]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + +# # train_images = np.hstack((train_images, test_images)) +# # print("WARNING: ADDED TEST IMAGES TO TRAIN IMAGES") + + +# ## Load data and images + +# In[11]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[12]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + +clip_seq_dim = 257 +clip_emb_dim = 768 +hidden_dim = 4096 + + +# ### SD VAE (blurry images) + +# In[13]: + + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# ### MindEye modules + +# In[14]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[15]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[16]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.75, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + self.upsampler = Decoder( + in_channels=64, + out_channels=4, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[64, 128, 256], + layers_per_block=1, + ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + b = self.blin1(x) + b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + return c, b + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((2,8192)) +print(b.shape) +clip_, blur_ = model.backbone(b) +print(clip_.shape, blur_.shape) + + +# In[17]: + + +# memory model + +from timm.layers.mlp import Mlp + + + +class MemoryDropout(nn.Module): + def __init__(self, p): + super(MemoryDropout, self).__init__() + self.p = p + + def forward(self, x): + if self.training: + mask = torch.zeros(x.size(0), x.size(1)).bernoulli_(1 - self.p).unsqueeze(2).expand_as(x) + mask = mask.to(x.device) + x = x * mask / (1 - self.p) + return x + +memory_dropout_percentage = 0.75 +memory_dropout = MemoryDropout(memory_dropout_percentage) + +class MemoryEncoder(nn.Module): + def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.85): + super().__init__() + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.out_dim = out_dim + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.final_input_dim = in_dim + embedding_time_dim + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.n_blocks = n_blocks + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim))) + + + def forward(self, x, time): + time = time.long() + time = self.embedding_time(time) + x = torch.cat((x, time), dim=-1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory encoder +# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512) + +# device = torch.device("cpu") +# memory_encoder.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_encoder.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15279)).to(device) +# rand_time = torch.randint(0, 15, (2,)).to(device) +# print(rand_input.shape, rand_time.shape) +# memory_encoder(rand_input, rand_time).shape + +class MemoryCompressor(nn.Module): + def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.75): + super().__init__() + self.num_past = num_past + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.final_input_dim = in_dim * num_past + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, output_dim, bias=True) + self.n_blocks = n_blocks + self.num_past = num_past + self.output_dim = output_dim + + def forward(self, x): + # x is (batch_size, num_past, in_dim) + x = x.reshape(len(x), -1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory compressor +# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768) + +# device = torch.device("cpu") +# memory_compressor.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_compressor.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15, 768)).to(device) +# print(rand_input.shape) +# memory_compressor(rand_input).shape + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) +model.memory_compressor = MemoryCompressor(in_dim=model.ridge.out_features, num_past=15, output_dim=4096) + +#utils.count_params(model.memory_encoder) +utils.count_params(model.memory_compressor) +utils.count_params(model) + + + +# In[18]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, + #{'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.time_embedding.named_parameters()], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# In[ ]: + + + + + +# # Weights and Biases + +# In[19]: + + +# params for wandb +wandb_log = True +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + + wandb_project = 'stability' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=model_name, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # More custom functions + +# In[20]: + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + + +# # Main + +# In[21]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[22]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[23]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + #if epoch == 0 or epoch == 1: + # break + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + # reshape past voxels to be (batch_size * 15, 15279) + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + #print(past_15_voxels.shape, past_15_times.shape) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + embeds_past_voxels = model.ridge(past_info_full) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + embeds_past_voxels = memory_dropout(embeds_past_voxels) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + #print(torch.cat((voxel, positional_current_voxel), dim=-1).shape, positional_current_voxel.shape, voxel.shape) + voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + loss_blurry_total += loss_blurry.item() + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + with torch.no_grad(): + # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False) + blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + print('test') + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + assert len(image) == batch_size + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + clip_target = clip_model.embed_image(image.float()) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + print(past_15_voxels.shape, past_15_times.shape) + + #print(past_15_voxels.shape, past_15_times.shape) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + embeds_past_voxels = model.ridge(past_info_full) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + + voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + # transform blurry recon latents to images and plot it + #fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + #axes[0].imshow(utils.torch_to_Image(image[[0]])) + #axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + #axes[2].imshow(utils.torch_to_Image(image[[1]])) + #axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + #axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + #plt.show() + + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + with torch.cuda.amp.autocast(): + with torch.no_grad(): + wandb.log({"gt": [wandb.Image(utils.torch_to_Image(image[[0]])), wandb.Image(utils.torch_to_Image(image[[1]])) ]}) + wandb.log({"preds": [wandb.Image(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))), wandb.Image(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) ]}) + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/src/Train-with-memory-rr-mlpmix.ipynb b/src/Train-with-memory-rr-mlpmix.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dc8c91e6d4d502bb5567e458d369978f45448b60 --- /dev/null +++ b/src/Train-with-memory-rr-mlpmix.ipynb @@ -0,0 +1,1869 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[NbConvertApp] Converting notebook Train-with-memory-rr.ipynb to python\n", + "[NbConvertApp] Writing 36255 bytes to Train-with-memory-rr.py\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "from subprocess import call\n", + "command = \"jupyter nbconvert Train-with-memory-rr.ipynb --to python\"\n", + "call(command,shell=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4c43b571-3921-4e54-9638-020627b90435", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sat Oct 21 02:40:21 2023 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 NVIDIA A100-SXM... On | 00000000:10:1C.0 Off | 0 |\n", + "| N/A 28C P0 71W / 400W | 39197MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 1 NVIDIA A100-SXM... On | 00000000:10:1D.0 Off | 0 |\n", + "| N/A 26C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 2 NVIDIA A100-SXM... On | 00000000:20:1C.0 Off | 0 |\n", + "| N/A 26C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 3 NVIDIA A100-SXM... On | 00000000:20:1D.0 Off | 0 |\n", + "| N/A 26C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 4 NVIDIA A100-SXM... On | 00000000:90:1C.0 Off | 0 |\n", + "| N/A 26C P0 52W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 5 NVIDIA A100-SXM... On | 00000000:90:1D.0 Off | 0 |\n", + "| N/A 25C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 6 NVIDIA A100-SXM... On | 00000000:A0:1C.0 Off | 0 |\n", + "| N/A 26C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 7 NVIDIA A100-SXM... On | 00000000:A0:1D.0 Off | 0 |\n", + "| N/A 26C P0 52W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| 0 N/A N/A 3878223 C ...3/envs/mindeye/bin/python 39194MiB |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-21 02:37:49,986] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 3878223\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"memory_cat_rr\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_mem_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "66,527,232 total\n", + "66,527,232 trainable\n", + "param counts:\n", + "66,527,232 total\n", + "66,527,232 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "time_embedding_dim = 512\n", + "\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "time_emb_test = torch.randn((2,1,time_embedding_dim))\n", + "print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,071,175,044 total\n", + "1,071,175,044 trainable\n", + "param counts:\n", + "1,137,702,276 total\n", + "1,137,702,276 trainable\n", + "torch.Size([2, 8192])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,8192))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "335,601,664 total\n", + "335,601,664 trainable\n", + "param counts:\n", + "1,473,311,620 total\n", + "1,473,311,620 trainable\n" + ] + } + ], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.out_dim = out_dim\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "class TimeEmbedding(nn.Module):\n", + " def __init__(self, embedding_time_dim=512, num_past_voxels=15):\n", + " super().__init__()\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + "\n", + " def forward(self, time):\n", + " # time is (batch_size,)\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " return time # (batch_size, embedding_time_dim)\n", + " \n", + "\n", + "#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15)\n", + "model.memory_compressor = MemoryCompressor(in_dim=model.ridge.out_features, num_past=15, output_dim=4096)\n", + "\n", + "#utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,473,311,620 total\n", + "1,473,311,620 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " #{'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.time_embedding.named_parameters()], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3edca702-e148-4f2d-82b9-1c42bca5f73f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 128, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231021_023850-j853zpva" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run test to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/j853zpva" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:34 │\n", + "│ │\n", + "│ 31 │ │ │ past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_s │\n", + "│ 32 │ │ │ past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 │\n", + "│ 33 │ │ │ │\n", + "│ ❱ 34 │ │ │ blurry_image_enc = autoenc.encode(image).latent_dist.mode() │\n", + "│ 35 │ │ │ │\n", + "│ 36 │ │ │ if use_image_aug: image = img_augment(image) │\n", + "│ 37 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/accelerate_utils.py:46 in wrapper │\n", + "│ │\n", + "│ 43 │ def wrapper(self, *args, **kwargs): │\n", + "│ 44 │ │ if hasattr(self, \"_hf_hook\") and hasattr(self._hf_hook, \"pre_forward\"): │\n", + "│ 45 │ │ │ self._hf_hook.pre_forward(self) │\n", + "│ ❱ 46 │ │ return method(self, *args, **kwargs) │\n", + "│ 47 │ │\n", + "│ 48 │ return wrapper │\n", + "│ 49 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/autoencoder_kl.py:258 in encode │\n", + "│ │\n", + "│ 255 │ │ │ encoded_slices = [self.encoder(x_slice) for x_slice in x.split(1)] │\n", + "│ 256 │ │ │ h = torch.cat(encoded_slices) │\n", + "│ 257 │ │ else: │\n", + "│ ❱ 258 │ │ │ h = self.encoder(x) │\n", + "│ 259 │ │ │\n", + "│ 260 │ │ moments = self.quant_conv(h) │\n", + "│ 261 │ │ posterior = DiagonalGaussianDistribution(moments) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/vae.py:141 in forward │\n", + "│ │\n", + "│ 138 │ │ else: │\n", + "│ 139 │ │ │ # down │\n", + "│ 140 │ │ │ for down_block in self.down_blocks: │\n", + "│ ❱ 141 │ │ │ │ sample = down_block(sample) │\n", + "│ 142 │ │ │ │\n", + "│ 143 │ │ │ # middle │\n", + "│ 144 │ │ │ sample = self.mid_block(sample) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/unet_2d_blocks.py:1247 in forward │\n", + "│ │\n", + "│ 1244 │ │\n", + "│ 1245 │ def forward(self, hidden_states, scale: float = 1.0): │\n", + "│ 1246 │ │ for resnet in self.resnets: │\n", + "│ ❱ 1247 │ │ │ hidden_states = resnet(hidden_states, temb=None, scale=scale) │\n", + "│ 1248 │ │ │\n", + "│ 1249 │ │ if self.downsamplers is not None: │\n", + "│ 1250 │ │ │ for downsampler in self.downsamplers: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/resnet.py:650 in forward │\n", + "│ │\n", + "│ 647 │ │ if self.time_embedding_norm == \"ada_group\" or self.time_embedding_norm == \"spati │\n", + "│ 648 │ │ │ hidden_states = self.norm2(hidden_states, temb) │\n", + "│ 649 │ │ else: │\n", + "│ ❱ 650 │ │ │ hidden_states = self.norm2(hidden_states) │\n", + "│ 651 │ │ │\n", + "│ 652 │ │ if temb is not None and self.time_embedding_norm == \"scale_shift\": │\n", + "│ 653 │ │ │ scale, shift = torch.chunk(temb, 2, dim=1) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/normal │\n", + "│ ization.py:273 in forward │\n", + "│ │\n", + "│ 270 │ │ │ init.zeros_(self.bias) │\n", + "│ 271 │ │\n", + "│ 272 │ def forward(self, input: Tensor) -> Tensor: │\n", + "│ ❱ 273 │ │ return F.group_norm( │\n", + "│ 274 │ │ │ input, self.num_groups, self.weight, self.bias, self.eps) │\n", + "│ 275 │ │\n", + "│ 276 │ def extra_repr(self) -> str: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/functional.py: │\n", + "│ 2530 in group_norm │\n", + "│ │\n", + "│ 2527 │ if input.dim() < 2: │\n", + "│ 2528 │ │ raise RuntimeError(f\"Expected at least 2 dimensions for input tensor but receive │\n", + "│ 2529 │ _verify_batch_size([input.size(0) * input.size(1) // num_groups, num_groups] + list( │\n", + "│ ❱ 2530 │ return torch.group_norm(input, num_groups, weight, bias, eps, torch.backends.cudnn.e │\n", + "│ 2531 │\n", + "│ 2532 │\n", + "│ 2533 def local_response_norm(input: Tensor, size: int, alpha: float = 1e-4, beta: float = 0.7 │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "OutOfMemoryError: CUDA out of memory. Tried to allocate 3.06 GiB (GPU 0; 39.56 GiB total capacity; 30.94 GiB \n", + "already allocated; 1.29 GiB free; 36.79 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m34\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 31 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_voxels = voxels[past_behav[:,:,\u001b[94m5\u001b[0m].cpu().long()].to(device) \u001b[2m# batch_s\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 32 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_times = torch.Tensor([i \u001b[94mfor\u001b[0m i \u001b[95min\u001b[0m \u001b[96mrange\u001b[0m(\u001b[94m15\u001b[0m)]).to(device) \u001b[2m# 15\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 33 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 34 \u001b[2m│ │ │ \u001b[0mblurry_image_enc = autoenc.encode(image).latent_dist.mode() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 35 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 36 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m use_image_aug: image = img_augment(image) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 37 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/\u001b[0m\u001b[1;33maccelerate_utils.py\u001b[0m:\u001b[94m46\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m43 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mwrapper\u001b[0m(\u001b[96mself\u001b[0m, *args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m44 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m, \u001b[33m\"\u001b[0m\u001b[33m_hf_hook\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m._hf_hook, \u001b[33m\"\u001b[0m\u001b[33mpre_forward\u001b[0m\u001b[33m\"\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m45 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m._hf_hook.pre_forward(\u001b[96mself\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m46 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m method(\u001b[96mself\u001b[0m, *args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m47 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m48 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m wrapper \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m49 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mautoencoder_kl.py\u001b[0m:\u001b[94m258\u001b[0m in \u001b[92mencode\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m255 \u001b[0m\u001b[2m│ │ │ \u001b[0mencoded_slices = [\u001b[96mself\u001b[0m.encoder(x_slice) \u001b[94mfor\u001b[0m x_slice \u001b[95min\u001b[0m x.split(\u001b[94m1\u001b[0m)] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m256 \u001b[0m\u001b[2m│ │ │ \u001b[0mh = torch.cat(encoded_slices) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m257 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m258 \u001b[2m│ │ │ \u001b[0mh = \u001b[96mself\u001b[0m.encoder(x) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m259 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m260 \u001b[0m\u001b[2m│ │ \u001b[0mmoments = \u001b[96mself\u001b[0m.quant_conv(h) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m261 \u001b[0m\u001b[2m│ │ \u001b[0mposterior = DiagonalGaussianDistribution(moments) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mvae.py\u001b[0m:\u001b[94m141\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m138 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m139 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# down\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m140 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m down_block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.down_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m141 \u001b[2m│ │ │ │ \u001b[0msample = down_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m142 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m143 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# middle\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m144 \u001b[0m\u001b[2m│ │ │ \u001b[0msample = \u001b[96mself\u001b[0m.mid_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1247\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1244 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1245 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, hidden_states, scale: \u001b[96mfloat\u001b[0m = \u001b[94m1.0\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1246 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m resnet \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.resnets: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1247 \u001b[2m│ │ │ \u001b[0mhidden_states = resnet(hidden_states, temb=\u001b[94mNone\u001b[0m, scale=scale) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1248 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1249 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.downsamplers \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1250 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m downsampler \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.downsamplers: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mresnet.py\u001b[0m:\u001b[94m650\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m647 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mada_group\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mspati\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m648 \u001b[0m\u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states, temb) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m649 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m650 \u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m651 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m652 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m temb \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mand\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mscale_shift\u001b[0m\u001b[33m\"\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m653 \u001b[0m\u001b[2m│ │ │ \u001b[0mscale, shift = torch.chunk(temb, \u001b[94m2\u001b[0m, dim=\u001b[94m1\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mnormal\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mization.py\u001b[0m:\u001b[94m273\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m270 \u001b[0m\u001b[2m│ │ │ \u001b[0minit.zeros_(\u001b[96mself\u001b[0m.bias) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m271 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m272 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, \u001b[96minput\u001b[0m: Tensor) -> Tensor: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m273 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m F.group_norm( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m274 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96minput\u001b[0m, \u001b[96mself\u001b[0m.num_groups, \u001b[96mself\u001b[0m.weight, \u001b[96mself\u001b[0m.bias, \u001b[96mself\u001b[0m.eps) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m275 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m276 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mextra_repr\u001b[0m(\u001b[96mself\u001b[0m) -> \u001b[96mstr\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/\u001b[0m\u001b[1;33mfunctional.py\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m2530\u001b[0m in \u001b[92mgroup_norm\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2527 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m \u001b[96minput\u001b[0m.dim() < \u001b[94m2\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2528 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mRuntimeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mExpected at least 2 dimensions for input tensor but receive\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2529 \u001b[0m\u001b[2m│ \u001b[0m_verify_batch_size([\u001b[96minput\u001b[0m.size(\u001b[94m0\u001b[0m) * \u001b[96minput\u001b[0m.size(\u001b[94m1\u001b[0m) // num_groups, num_groups] + \u001b[96mlist\u001b[0m( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2530 \u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m torch.group_norm(\u001b[96minput\u001b[0m, num_groups, weight, bias, eps, torch.backends.cudnn.e \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2531 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2532 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2533 \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mlocal_response_norm\u001b[0m(\u001b[96minput\u001b[0m: Tensor, size: \u001b[96mint\u001b[0m, alpha: \u001b[96mfloat\u001b[0m = \u001b[94m1e-4\u001b[0m, beta: \u001b[96mfloat\u001b[0m = \u001b[94m0.7\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.06\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m39.56\u001b[0m GiB total capacity; \u001b[1;36m30.94\u001b[0m GiB \n", + "already allocated; \u001b[1;36m1.29\u001b[0m GiB free; \u001b[1;36m36.79\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " #if epoch == 0 or epoch == 1:\n", + " # break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " # reshape past voxels to be (batch_size * 15, 15279)\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " #print(past_15_voxels.shape, past_15_times.shape)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + " embeds_past_voxels = model.ridge(past_info_full)\n", + " #print(embeds_past_voxels.shape)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1)\n", + " #print(embeds_past_voxels.shape)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " #print(torch.cat((voxel, positional_current_voxel), dim=-1).shape, positional_current_voxel.shape, voxel.shape)\n", + " voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print('test')\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + "\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + "\n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " \n", + " voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory-rr.ipynb b/src/Train-with-memory-rr.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dc8c91e6d4d502bb5567e458d369978f45448b60 --- /dev/null +++ b/src/Train-with-memory-rr.ipynb @@ -0,0 +1,1869 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 26, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[NbConvertApp] Converting notebook Train-with-memory-rr.ipynb to python\n", + "[NbConvertApp] Writing 36255 bytes to Train-with-memory-rr.py\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "from subprocess import call\n", + "command = \"jupyter nbconvert Train-with-memory-rr.ipynb --to python\"\n", + "call(command,shell=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4c43b571-3921-4e54-9638-020627b90435", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sat Oct 21 02:40:21 2023 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 NVIDIA A100-SXM... On | 00000000:10:1C.0 Off | 0 |\n", + "| N/A 28C P0 71W / 400W | 39197MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 1 NVIDIA A100-SXM... On | 00000000:10:1D.0 Off | 0 |\n", + "| N/A 26C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 2 NVIDIA A100-SXM... On | 00000000:20:1C.0 Off | 0 |\n", + "| N/A 26C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 3 NVIDIA A100-SXM... On | 00000000:20:1D.0 Off | 0 |\n", + "| N/A 26C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 4 NVIDIA A100-SXM... On | 00000000:90:1C.0 Off | 0 |\n", + "| N/A 26C P0 52W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 5 NVIDIA A100-SXM... On | 00000000:90:1D.0 Off | 0 |\n", + "| N/A 25C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 6 NVIDIA A100-SXM... On | 00000000:A0:1C.0 Off | 0 |\n", + "| N/A 26C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 7 NVIDIA A100-SXM... On | 00000000:A0:1D.0 Off | 0 |\n", + "| N/A 26C P0 52W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| 0 N/A N/A 3878223 C ...3/envs/mindeye/bin/python 39194MiB |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-21 02:37:49,986] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 3878223\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"memory_cat_rr\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_mem_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "66,527,232 total\n", + "66,527,232 trainable\n", + "param counts:\n", + "66,527,232 total\n", + "66,527,232 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "time_embedding_dim = 512\n", + "\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "time_emb_test = torch.randn((2,1,time_embedding_dim))\n", + "print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,071,175,044 total\n", + "1,071,175,044 trainable\n", + "param counts:\n", + "1,137,702,276 total\n", + "1,137,702,276 trainable\n", + "torch.Size([2, 8192])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,8192))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "335,601,664 total\n", + "335,601,664 trainable\n", + "param counts:\n", + "1,473,311,620 total\n", + "1,473,311,620 trainable\n" + ] + } + ], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.out_dim = out_dim\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "class TimeEmbedding(nn.Module):\n", + " def __init__(self, embedding_time_dim=512, num_past_voxels=15):\n", + " super().__init__()\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + "\n", + " def forward(self, time):\n", + " # time is (batch_size,)\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " return time # (batch_size, embedding_time_dim)\n", + " \n", + "\n", + "#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15)\n", + "model.memory_compressor = MemoryCompressor(in_dim=model.ridge.out_features, num_past=15, output_dim=4096)\n", + "\n", + "#utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,473,311,620 total\n", + "1,473,311,620 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " #{'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.time_embedding.named_parameters()], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3edca702-e148-4f2d-82b9-1c42bca5f73f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 128, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231021_023850-j853zpva" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run test to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/j853zpva" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:34 │\n", + "│ │\n", + "│ 31 │ │ │ past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_s │\n", + "│ 32 │ │ │ past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 │\n", + "│ 33 │ │ │ │\n", + "│ ❱ 34 │ │ │ blurry_image_enc = autoenc.encode(image).latent_dist.mode() │\n", + "│ 35 │ │ │ │\n", + "│ 36 │ │ │ if use_image_aug: image = img_augment(image) │\n", + "│ 37 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/accelerate_utils.py:46 in wrapper │\n", + "│ │\n", + "│ 43 │ def wrapper(self, *args, **kwargs): │\n", + "│ 44 │ │ if hasattr(self, \"_hf_hook\") and hasattr(self._hf_hook, \"pre_forward\"): │\n", + "│ 45 │ │ │ self._hf_hook.pre_forward(self) │\n", + "│ ❱ 46 │ │ return method(self, *args, **kwargs) │\n", + "│ 47 │ │\n", + "│ 48 │ return wrapper │\n", + "│ 49 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/autoencoder_kl.py:258 in encode │\n", + "│ │\n", + "│ 255 │ │ │ encoded_slices = [self.encoder(x_slice) for x_slice in x.split(1)] │\n", + "│ 256 │ │ │ h = torch.cat(encoded_slices) │\n", + "│ 257 │ │ else: │\n", + "│ ❱ 258 │ │ │ h = self.encoder(x) │\n", + "│ 259 │ │ │\n", + "│ 260 │ │ moments = self.quant_conv(h) │\n", + "│ 261 │ │ posterior = DiagonalGaussianDistribution(moments) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/vae.py:141 in forward │\n", + "│ │\n", + "│ 138 │ │ else: │\n", + "│ 139 │ │ │ # down │\n", + "│ 140 │ │ │ for down_block in self.down_blocks: │\n", + "│ ❱ 141 │ │ │ │ sample = down_block(sample) │\n", + "│ 142 │ │ │ │\n", + "│ 143 │ │ │ # middle │\n", + "│ 144 │ │ │ sample = self.mid_block(sample) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/unet_2d_blocks.py:1247 in forward │\n", + "│ │\n", + "│ 1244 │ │\n", + "│ 1245 │ def forward(self, hidden_states, scale: float = 1.0): │\n", + "│ 1246 │ │ for resnet in self.resnets: │\n", + "│ ❱ 1247 │ │ │ hidden_states = resnet(hidden_states, temb=None, scale=scale) │\n", + "│ 1248 │ │ │\n", + "│ 1249 │ │ if self.downsamplers is not None: │\n", + "│ 1250 │ │ │ for downsampler in self.downsamplers: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/resnet.py:650 in forward │\n", + "│ │\n", + "│ 647 │ │ if self.time_embedding_norm == \"ada_group\" or self.time_embedding_norm == \"spati │\n", + "│ 648 │ │ │ hidden_states = self.norm2(hidden_states, temb) │\n", + "│ 649 │ │ else: │\n", + "│ ❱ 650 │ │ │ hidden_states = self.norm2(hidden_states) │\n", + "│ 651 │ │ │\n", + "│ 652 │ │ if temb is not None and self.time_embedding_norm == \"scale_shift\": │\n", + "│ 653 │ │ │ scale, shift = torch.chunk(temb, 2, dim=1) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/normal │\n", + "│ ization.py:273 in forward │\n", + "│ │\n", + "│ 270 │ │ │ init.zeros_(self.bias) │\n", + "│ 271 │ │\n", + "│ 272 │ def forward(self, input: Tensor) -> Tensor: │\n", + "│ ❱ 273 │ │ return F.group_norm( │\n", + "│ 274 │ │ │ input, self.num_groups, self.weight, self.bias, self.eps) │\n", + "│ 275 │ │\n", + "│ 276 │ def extra_repr(self) -> str: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/functional.py: │\n", + "│ 2530 in group_norm │\n", + "│ │\n", + "│ 2527 │ if input.dim() < 2: │\n", + "│ 2528 │ │ raise RuntimeError(f\"Expected at least 2 dimensions for input tensor but receive │\n", + "│ 2529 │ _verify_batch_size([input.size(0) * input.size(1) // num_groups, num_groups] + list( │\n", + "│ ❱ 2530 │ return torch.group_norm(input, num_groups, weight, bias, eps, torch.backends.cudnn.e │\n", + "│ 2531 │\n", + "│ 2532 │\n", + "│ 2533 def local_response_norm(input: Tensor, size: int, alpha: float = 1e-4, beta: float = 0.7 │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "OutOfMemoryError: CUDA out of memory. Tried to allocate 3.06 GiB (GPU 0; 39.56 GiB total capacity; 30.94 GiB \n", + "already allocated; 1.29 GiB free; 36.79 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m34\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 31 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_voxels = voxels[past_behav[:,:,\u001b[94m5\u001b[0m].cpu().long()].to(device) \u001b[2m# batch_s\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 32 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_times = torch.Tensor([i \u001b[94mfor\u001b[0m i \u001b[95min\u001b[0m \u001b[96mrange\u001b[0m(\u001b[94m15\u001b[0m)]).to(device) \u001b[2m# 15\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 33 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 34 \u001b[2m│ │ │ \u001b[0mblurry_image_enc = autoenc.encode(image).latent_dist.mode() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 35 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 36 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m use_image_aug: image = img_augment(image) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 37 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/\u001b[0m\u001b[1;33maccelerate_utils.py\u001b[0m:\u001b[94m46\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m43 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mwrapper\u001b[0m(\u001b[96mself\u001b[0m, *args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m44 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m, \u001b[33m\"\u001b[0m\u001b[33m_hf_hook\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m._hf_hook, \u001b[33m\"\u001b[0m\u001b[33mpre_forward\u001b[0m\u001b[33m\"\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m45 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m._hf_hook.pre_forward(\u001b[96mself\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m46 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m method(\u001b[96mself\u001b[0m, *args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m47 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m48 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m wrapper \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m49 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mautoencoder_kl.py\u001b[0m:\u001b[94m258\u001b[0m in \u001b[92mencode\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m255 \u001b[0m\u001b[2m│ │ │ \u001b[0mencoded_slices = [\u001b[96mself\u001b[0m.encoder(x_slice) \u001b[94mfor\u001b[0m x_slice \u001b[95min\u001b[0m x.split(\u001b[94m1\u001b[0m)] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m256 \u001b[0m\u001b[2m│ │ │ \u001b[0mh = torch.cat(encoded_slices) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m257 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m258 \u001b[2m│ │ │ \u001b[0mh = \u001b[96mself\u001b[0m.encoder(x) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m259 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m260 \u001b[0m\u001b[2m│ │ \u001b[0mmoments = \u001b[96mself\u001b[0m.quant_conv(h) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m261 \u001b[0m\u001b[2m│ │ \u001b[0mposterior = DiagonalGaussianDistribution(moments) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mvae.py\u001b[0m:\u001b[94m141\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m138 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m139 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# down\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m140 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m down_block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.down_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m141 \u001b[2m│ │ │ │ \u001b[0msample = down_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m142 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m143 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# middle\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m144 \u001b[0m\u001b[2m│ │ │ \u001b[0msample = \u001b[96mself\u001b[0m.mid_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1247\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1244 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1245 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, hidden_states, scale: \u001b[96mfloat\u001b[0m = \u001b[94m1.0\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1246 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m resnet \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.resnets: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1247 \u001b[2m│ │ │ \u001b[0mhidden_states = resnet(hidden_states, temb=\u001b[94mNone\u001b[0m, scale=scale) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1248 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1249 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.downsamplers \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1250 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m downsampler \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.downsamplers: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mresnet.py\u001b[0m:\u001b[94m650\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m647 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mada_group\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mspati\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m648 \u001b[0m\u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states, temb) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m649 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m650 \u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m651 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m652 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m temb \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mand\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mscale_shift\u001b[0m\u001b[33m\"\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m653 \u001b[0m\u001b[2m│ │ │ \u001b[0mscale, shift = torch.chunk(temb, \u001b[94m2\u001b[0m, dim=\u001b[94m1\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mnormal\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mization.py\u001b[0m:\u001b[94m273\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m270 \u001b[0m\u001b[2m│ │ │ \u001b[0minit.zeros_(\u001b[96mself\u001b[0m.bias) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m271 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m272 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, \u001b[96minput\u001b[0m: Tensor) -> Tensor: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m273 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m F.group_norm( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m274 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96minput\u001b[0m, \u001b[96mself\u001b[0m.num_groups, \u001b[96mself\u001b[0m.weight, \u001b[96mself\u001b[0m.bias, \u001b[96mself\u001b[0m.eps) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m275 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m276 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mextra_repr\u001b[0m(\u001b[96mself\u001b[0m) -> \u001b[96mstr\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/\u001b[0m\u001b[1;33mfunctional.py\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m2530\u001b[0m in \u001b[92mgroup_norm\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2527 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m \u001b[96minput\u001b[0m.dim() < \u001b[94m2\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2528 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mRuntimeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mExpected at least 2 dimensions for input tensor but receive\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2529 \u001b[0m\u001b[2m│ \u001b[0m_verify_batch_size([\u001b[96minput\u001b[0m.size(\u001b[94m0\u001b[0m) * \u001b[96minput\u001b[0m.size(\u001b[94m1\u001b[0m) // num_groups, num_groups] + \u001b[96mlist\u001b[0m( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2530 \u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m torch.group_norm(\u001b[96minput\u001b[0m, num_groups, weight, bias, eps, torch.backends.cudnn.e \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2531 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2532 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2533 \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mlocal_response_norm\u001b[0m(\u001b[96minput\u001b[0m: Tensor, size: \u001b[96mint\u001b[0m, alpha: \u001b[96mfloat\u001b[0m = \u001b[94m1e-4\u001b[0m, beta: \u001b[96mfloat\u001b[0m = \u001b[94m0.7\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.06\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m39.56\u001b[0m GiB total capacity; \u001b[1;36m30.94\u001b[0m GiB \n", + "already allocated; \u001b[1;36m1.29\u001b[0m GiB free; \u001b[1;36m36.79\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " #if epoch == 0 or epoch == 1:\n", + " # break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " # reshape past voxels to be (batch_size * 15, 15279)\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " #print(past_15_voxels.shape, past_15_times.shape)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + " embeds_past_voxels = model.ridge(past_info_full)\n", + " #print(embeds_past_voxels.shape)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1)\n", + " #print(embeds_past_voxels.shape)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " #print(torch.cat((voxel, positional_current_voxel), dim=-1).shape, positional_current_voxel.shape, voxel.shape)\n", + " voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print('test')\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + "\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + "\n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " \n", + " voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory-rr.py b/src/Train-with-memory-rr.py new file mode 100644 index 0000000000000000000000000000000000000000..e6ce7c37500152a4e1a1ef101469c3b31ee3d14e --- /dev/null +++ b/src/Train-with-memory-rr.py @@ -0,0 +1,1018 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[ ]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train-with-memory-rr.ipynb --to python" +#call(command,shell=True) + + +# In[24]: + + +#get_ipython().system('nvidia-smi') + + +# # Import packages & functions + +# In[3]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 512 #128 + + +# In[4]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[5]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[6]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # Example use + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name=test \ + --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \ + --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[7]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="memory_cat_rr", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=240, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + + +# In[8]: + + +outdir = os.path.abspath(f'../train_mem_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[9]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + + +# ### check dataloaders are working + +# In[10]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + +# # train_images = np.hstack((train_images, test_images)) +# # print("WARNING: ADDED TEST IMAGES TO TRAIN IMAGES") + + +# ## Load data and images + +# In[11]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[12]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + +clip_seq_dim = 257 +clip_emb_dim = 768 +hidden_dim = 4096 + + +# ### SD VAE (blurry images) + +# In[13]: + + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# ### MindEye modules + +# In[14]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[15]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[16]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.25, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + self.upsampler = Decoder( + in_channels=64, + out_channels=4, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[64, 128, 256], + layers_per_block=1, + ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + b = self.blin1(x) + b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + return c, b + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((2,8192)) +print(b.shape) +clip_, blur_ = model.backbone(b) +print(clip_.shape, blur_.shape) + + +# In[17]: + + +# memory model + +from timm.layers.mlp import Mlp + +class MemoryEncoder(nn.Module): + def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.25): + super().__init__() + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.out_dim = out_dim + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.final_input_dim = in_dim + embedding_time_dim + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.n_blocks = n_blocks + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim))) + + + def forward(self, x, time): + time = time.long() + time = self.embedding_time(time) + x = torch.cat((x, time), dim=-1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory encoder +# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512) + +# device = torch.device("cpu") +# memory_encoder.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_encoder.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15279)).to(device) +# rand_time = torch.randint(0, 15, (2,)).to(device) +# print(rand_input.shape, rand_time.shape) +# memory_encoder(rand_input, rand_time).shape + +class MemoryCompressor(nn.Module): + def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.25): + super().__init__() + self.num_past = num_past + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.final_input_dim = in_dim * num_past + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, output_dim, bias=True) + self.n_blocks = n_blocks + self.num_past = num_past + self.output_dim = output_dim + + def forward(self, x): + # x is (batch_size, num_past, in_dim) + x = x.reshape(len(x), -1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory compressor +# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768) + +# device = torch.device("cpu") +# memory_compressor.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_compressor.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15, 768)).to(device) +# print(rand_input.shape) +# memory_compressor(rand_input).shape + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) +model.memory_compressor = MemoryCompressor(in_dim=model.ridge.out_features, num_past=15, output_dim=4096) + +#utils.count_params(model.memory_encoder) +utils.count_params(model.memory_compressor) +utils.count_params(model) + + + +# In[18]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, + #{'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.time_embedding.named_parameters()], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# In[ ]: + + + + + +# # Weights and Biases + +# In[19]: + + +# params for wandb +wandb_log = True +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + + wandb_project = 'stability' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=model_name, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # More custom functions + +# In[20]: + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + + +# # Main + +# In[21]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[22]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[23]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + #if epoch == 0 or epoch == 1: + # break + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + # reshape past voxels to be (batch_size * 15, 15279) + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + #print(past_15_voxels.shape, past_15_times.shape) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + embeds_past_voxels = model.ridge(past_info_full) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + #print(torch.cat((voxel, positional_current_voxel), dim=-1).shape, positional_current_voxel.shape, voxel.shape) + voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + loss_blurry_total += loss_blurry.item() + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + with torch.no_grad(): + # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False) + blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + print('test') + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + assert len(image) == batch_size + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + clip_target = clip_model.embed_image(image.float()) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + print(past_15_voxels.shape, past_15_times.shape) + + #print(past_15_voxels.shape, past_15_times.shape) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + embeds_past_voxels = model.ridge(past_info_full) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + + voxel_ridge = torch.cat([model.ridge(torch.cat((voxel, positional_current_voxel), dim=-1)), information_past_voxels], dim=-1) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + # transform blurry recon latents to images and plot it + #fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + #axes[0].imshow(utils.torch_to_Image(image[[0]])) + #axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + #axes[2].imshow(utils.torch_to_Image(image[[1]])) + #axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + #axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + #plt.show() + wandb.log({"gt": [wandb.Image(utils.torch_to_Image(image[[0]])), wandb.Image(utils.torch_to_Image(image[[1]])) ]} + wandb.log({"preds": [utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)), utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)) ]} + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/src/Train-with-memory.ipynb b/src/Train-with-memory.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7be52d26d04476f9e6890dc2226743eb9b268b94 --- /dev/null +++ b/src/Train-with-memory.ipynb @@ -0,0 +1,2002 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 30, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This application is used to convert notebook files (*.ipynb)\n", + " to various other formats.\n", + "\n", + " WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.\n", + "\n", + "Options\n", + "=======\n", + "The options below are convenience aliases to configurable class-options,\n", + "as listed in the \"Equivalent to\" description-line of the aliases.\n", + "To see all configurable class-options for some , use:\n", + " --help-all\n", + "\n", + "--debug\n", + " set log level to logging.DEBUG (maximize logging output)\n", + " Equivalent to: [--Application.log_level=10]\n", + "--show-config\n", + " Show the application's configuration (human-readable format)\n", + " Equivalent to: [--Application.show_config=True]\n", + "--show-config-json\n", + " Show the application's configuration (json format)\n", + " Equivalent to: [--Application.show_config_json=True]\n", + "--generate-config\n", + " generate default config file\n", + " Equivalent to: [--JupyterApp.generate_config=True]\n", + "-y\n", + " Answer yes to any questions instead of prompting.\n", + " Equivalent to: [--JupyterApp.answer_yes=True]\n", + "--execute\n", + " Execute the notebook prior to export.\n", + " Equivalent to: [--ExecutePreprocessor.enabled=True]\n", + "--allow-errors\n", + " Continue notebook execution even if one of the cells throws an error and include the error message in the cell output (the default behaviour is to abort conversion). This flag is only relevant if '--execute' was specified, too.\n", + " Equivalent to: [--ExecutePreprocessor.allow_errors=True]\n", + "--stdin\n", + " read a single notebook file from stdin. Write the resulting notebook with default basename 'notebook.*'\n", + " Equivalent to: [--NbConvertApp.from_stdin=True]\n", + "--stdout\n", + " Write notebook output to stdout instead of files.\n", + " Equivalent to: [--NbConvertApp.writer_class=StdoutWriter]\n", + "--inplace\n", + " Run nbconvert in place, overwriting the existing notebook (only\n", + " relevant when converting to notebook format)\n", + " Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory=]\n", + "--clear-output\n", + " Clear output of current file and save in place,\n", + " overwriting the existing notebook.\n", + " Equivalent to: [--NbConvertApp.use_output_suffix=False --NbConvertApp.export_format=notebook --FilesWriter.build_directory= --ClearOutputPreprocessor.enabled=True]\n", + "--no-prompt\n", + " Exclude input and output prompts from converted document.\n", + " Equivalent to: [--TemplateExporter.exclude_input_prompt=True --TemplateExporter.exclude_output_prompt=True]\n", + "--no-input\n", + " Exclude input cells and output prompts from converted document.\n", + " This mode is ideal for generating code-free reports.\n", + " Equivalent to: [--TemplateExporter.exclude_output_prompt=True --TemplateExporter.exclude_input=True --TemplateExporter.exclude_input_prompt=True]\n", + "--allow-chromium-download\n", + " Whether to allow downloading chromium if no suitable version is found on the system.\n", + " Equivalent to: [--WebPDFExporter.allow_chromium_download=True]\n", + "--disable-chromium-sandbox\n", + " Disable chromium security sandbox when converting to PDF..\n", + " Equivalent to: [--WebPDFExporter.disable_sandbox=True]\n", + "--show-input\n", + " Shows code input. This flag is only useful for dejavu users.\n", + " Equivalent to: [--TemplateExporter.exclude_input=False]\n", + "--embed-images\n", + " Embed the images as base64 dataurls in the output. This flag is only useful for the HTML/WebPDF/Slides exports.\n", + " Equivalent to: [--HTMLExporter.embed_images=True]\n", + "--sanitize-html\n", + " Whether the HTML in Markdown cells and cell outputs should be sanitized..\n", + " Equivalent to: [--HTMLExporter.sanitize_html=True]\n", + "--log-level=\n", + " Set the log level by value or name.\n", + " Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL']\n", + " Default: 30\n", + " Equivalent to: [--Application.log_level]\n", + "--config=\n", + " Full path of a config file.\n", + " Default: ''\n", + " Equivalent to: [--JupyterApp.config_file]\n", + "--to=\n", + " The export format to be used, either one of the built-in formats\n", + " ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'rst', 'script', 'slides', 'webpdf']\n", + " or a dotted object name that represents the import path for an\n", + " ``Exporter`` class\n", + " Default: ''\n", + " Equivalent to: [--NbConvertApp.export_format]\n", + "--template=\n", + " Name of the template to use\n", + " Default: ''\n", + " Equivalent to: [--TemplateExporter.template_name]\n", + "--template-file=\n", + " Name of the template file to use\n", + " Default: None\n", + " Equivalent to: [--TemplateExporter.template_file]\n", + "--theme=\n", + " Template specific theme(e.g. the name of a JupyterLab CSS theme distributed\n", + " as prebuilt extension for the lab template)\n", + " Default: 'light'\n", + " Equivalent to: [--HTMLExporter.theme]\n", + "--sanitize_html=\n", + " Whether the HTML in Markdown cells and cell outputs should be sanitized.This\n", + " should be set to True by nbviewer or similar tools.\n", + " Default: False\n", + " Equivalent to: [--HTMLExporter.sanitize_html]\n", + "--writer=\n", + " Writer class used to write the\n", + " results of the conversion\n", + " Default: 'FilesWriter'\n", + " Equivalent to: [--NbConvertApp.writer_class]\n", + "--post=\n", + " PostProcessor class used to write the\n", + " results of the conversion\n", + " Default: ''\n", + " Equivalent to: [--NbConvertApp.postprocessor_class]\n", + "--output=\n", + " overwrite base name use for output files.\n", + " can only be used when converting one notebook at a time.\n", + " Default: ''\n", + " Equivalent to: [--NbConvertApp.output_base]\n", + "--output-dir=\n", + " Directory to write output(s) to. Defaults\n", + " to output to the directory of each notebook. To recover\n", + " previous default behaviour (outputting to the current\n", + " working directory) use . as the flag value.\n", + " Default: ''\n", + " Equivalent to: [--FilesWriter.build_directory]\n", + "--reveal-prefix=\n", + " The URL prefix for reveal.js (version 3.x).\n", + " This defaults to the reveal CDN, but can be any url pointing to a copy\n", + " of reveal.js.\n", + " For speaker notes to work, this must be a relative path to a local\n", + " copy of reveal.js: e.g., \"reveal.js\".\n", + " If a relative path is given, it must be a subdirectory of the\n", + " current directory (from which the server is run).\n", + " See the usage documentation\n", + " (https://nbconvert.readthedocs.io/en/latest/usage.html#reveal-js-html-slideshow)\n", + " for more details.\n", + " Default: ''\n", + " Equivalent to: [--SlidesExporter.reveal_url_prefix]\n", + "--nbformat=\n", + " The nbformat version to write.\n", + " Use this to downgrade notebooks.\n", + " Choices: any of [1, 2, 3, 4]\n", + " Default: 4\n", + " Equivalent to: [--NotebookExporter.nbformat_version]\n", + "\n", + "Examples\n", + "--------\n", + "\n", + " The simplest way to use nbconvert is\n", + "\n", + " > jupyter nbconvert mynotebook.ipynb --to html\n", + "\n", + " Options include ['asciidoc', 'custom', 'html', 'latex', 'markdown', 'notebook', 'pdf', 'python', 'rst', 'script', 'slides', 'webpdf'].\n", + "\n", + " > jupyter nbconvert --to latex mynotebook.ipynb\n", + "\n", + " Both HTML and LaTeX support multiple output templates. LaTeX includes\n", + " 'base', 'article' and 'report'. HTML includes 'basic', 'lab' and\n", + " 'classic'. You can specify the flavor of the format used.\n", + "\n", + " > jupyter nbconvert --to html --template lab mynotebook.ipynb\n", + "\n", + " You can also pipe the output to stdout, rather than a file\n", + "\n", + " > jupyter nbconvert mynotebook.ipynb --stdout\n", + "\n", + " PDF is generated via latex\n", + "\n", + " > jupyter nbconvert mynotebook.ipynb --to pdf\n", + "\n", + " You can get (and serve) a Reveal.js-powered slideshow\n", + "\n", + " > jupyter nbconvert myslides.ipynb --to slides --post serve\n", + "\n", + " Multiple notebooks can be given at the command line in a couple of\n", + " different ways:\n", + "\n", + " > jupyter nbconvert notebook*.ipynb\n", + " > jupyter nbconvert notebook1.ipynb notebook2.ipynb\n", + "\n", + " or you can specify the notebooks list in a config file, containing::\n", + "\n", + " c.NbConvertApp.notebooks = [\"my_notebook.ipynb\"]\n", + "\n", + " > jupyter nbconvert --config mycfg.py\n", + "\n", + "To see all available configurables, use `--help-all`.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[NbConvertApp] WARNING | pattern 'Train-with-memory_cat.ipynb' matched no files\n" + ] + }, + { + "data": { + "text/plain": [ + "255" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "from subprocess import call\n", + "command = \"jupyter nbconvert Train-with-memory_cat.ipynb --to python\"\n", + "call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-15 21:57:10,361] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 2525880\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_mem_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,071,175,044 total\n", + "1,071,175,044 trainable\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n", + "torch.Size([2, 8192])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim*2, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,8192))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a34204d0-d268-41ee-8eea-042525262c47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "150,481,920 total\n", + "150,481,920 trainable\n", + "param counts:\n", + "335,601,664 total\n", + "335,601,664 trainable\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "# memory model\n", + "\n", + "from timm.layers.mlp import Mlp\n", + "\n", + "class MemoryEncoder(nn.Module):\n", + " def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.out_dim = out_dim\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.final_input_dim = in_dim + embedding_time_dim\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + " self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim)))\n", + "\n", + "\n", + " def forward(self, x, time):\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " x = torch.cat((x, time), dim=-1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory encoder\n", + "# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_encoder.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_encoder.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15279)).to(device)\n", + "# rand_time = torch.randint(0, 15, (2,)).to(device)\n", + "# print(rand_input.shape, rand_time.shape)\n", + "# memory_encoder(rand_input, rand_time).shape\n", + "\n", + "class MemoryCompressor(nn.Module):\n", + " def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15):\n", + " super().__init__()\n", + " self.num_past = num_past\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.final_input_dim = in_dim * num_past\n", + " self.lin0 = nn.Linear(self.final_input_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, output_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.num_past = num_past\n", + " self.output_dim = output_dim\n", + "\n", + " def forward(self, x):\n", + " # x is (batch_size, num_past, in_dim)\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " return x\n", + " \n", + "# # test the memory compressor\n", + "# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768)\n", + "\n", + "# device = torch.device(\"cpu\")\n", + "# memory_compressor.to(device)\n", + "\n", + "# # count params\n", + "# total_parameters = 0\n", + "# for parameter in memory_compressor.parameters():\n", + "# total_parameters += parameter.numel()\n", + "\n", + "# rand_input = torch.randn((2, 15, 768)).to(device)\n", + "# print(rand_input.shape)\n", + "# memory_compressor(rand_input).shape\n", + "\n", + "model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.memory_compressor = MemoryCompressor(in_dim=model.memory_encoder.out_dim, num_past=15, output_dim=4096)\n", + "\n", + "utils.count_params(model.memory_encoder)\n", + "utils.count_params(model.memory_compressor)\n", + "utils.count_params(model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,621,688,708 total\n", + "1,621,688,708 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "3edca702-e148-4f2d-82b9-1c42bca5f73f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:1                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ ❱ 1 nnnn                                                                                         │\n",
+       "│   2                                                                                              │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "NameError: name 'nnnn' is not defined\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1 nnnn \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mNameError: \u001b[0mname \u001b[32m'nnnn'\u001b[0m is not defined\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 128, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231015_224404-lbkf7608" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run mem1 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/lbkf7608" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=model_name,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:34 │\n", + "│ │\n", + "│ 31 │ │ │ past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_s │\n", + "│ 32 │ │ │ past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 │\n", + "│ 33 │ │ │ │\n", + "│ ❱ 34 │ │ │ blurry_image_enc = autoenc.encode(image).latent_dist.mode() │\n", + "│ 35 │ │ │ │\n", + "│ 36 │ │ │ if use_image_aug: image = img_augment(image) │\n", + "│ 37 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/accelerate_utils.py:46 in wrapper │\n", + "│ │\n", + "│ 43 │ def wrapper(self, *args, **kwargs): │\n", + "│ 44 │ │ if hasattr(self, \"_hf_hook\") and hasattr(self._hf_hook, \"pre_forward\"): │\n", + "│ 45 │ │ │ self._hf_hook.pre_forward(self) │\n", + "│ ❱ 46 │ │ return method(self, *args, **kwargs) │\n", + "│ 47 │ │\n", + "│ 48 │ return wrapper │\n", + "│ 49 │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/autoencoder_kl.py:258 in encode │\n", + "│ │\n", + "│ 255 │ │ │ encoded_slices = [self.encoder(x_slice) for x_slice in x.split(1)] │\n", + "│ 256 │ │ │ h = torch.cat(encoded_slices) │\n", + "│ 257 │ │ else: │\n", + "│ ❱ 258 │ │ │ h = self.encoder(x) │\n", + "│ 259 │ │ │\n", + "│ 260 │ │ moments = self.quant_conv(h) │\n", + "│ 261 │ │ posterior = DiagonalGaussianDistribution(moments) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/vae.py:141 in forward │\n", + "│ │\n", + "│ 138 │ │ else: │\n", + "│ 139 │ │ │ # down │\n", + "│ 140 │ │ │ for down_block in self.down_blocks: │\n", + "│ ❱ 141 │ │ │ │ sample = down_block(sample) │\n", + "│ 142 │ │ │ │\n", + "│ 143 │ │ │ # middle │\n", + "│ 144 │ │ │ sample = self.mid_block(sample) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/unet_2d_blocks.py:1247 in forward │\n", + "│ │\n", + "│ 1244 │ │\n", + "│ 1245 │ def forward(self, hidden_states, scale: float = 1.0): │\n", + "│ 1246 │ │ for resnet in self.resnets: │\n", + "│ ❱ 1247 │ │ │ hidden_states = resnet(hidden_states, temb=None, scale=scale) │\n", + "│ 1248 │ │ │\n", + "│ 1249 │ │ if self.downsamplers is not None: │\n", + "│ 1250 │ │ │ for downsampler in self.downsamplers: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/resnet.py:650 in forward │\n", + "│ │\n", + "│ 647 │ │ if self.time_embedding_norm == \"ada_group\" or self.time_embedding_norm == \"spati │\n", + "│ 648 │ │ │ hidden_states = self.norm2(hidden_states, temb) │\n", + "│ 649 │ │ else: │\n", + "│ ❱ 650 │ │ │ hidden_states = self.norm2(hidden_states) │\n", + "│ 651 │ │ │\n", + "│ 652 │ │ if temb is not None and self.time_embedding_norm == \"scale_shift\": │\n", + "│ 653 │ │ │ scale, shift = torch.chunk(temb, 2, dim=1) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module │\n", + "│ .py:1501 in _call_impl │\n", + "│ │\n", + "│ 1498 │ │ if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks │\n", + "│ 1499 │ │ │ │ or _global_backward_pre_hooks or _global_backward_hooks │\n", + "│ 1500 │ │ │ │ or _global_forward_hooks or _global_forward_pre_hooks): │\n", + "│ ❱ 1501 │ │ │ return forward_call(*args, **kwargs) │\n", + "│ 1502 │ │ # Do not call functions when jit is used │\n", + "│ 1503 │ │ full_backward_hooks, non_full_backward_hooks = [], [] │\n", + "│ 1504 │ │ backward_pre_hooks = [] │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/normal │\n", + "│ ization.py:273 in forward │\n", + "│ │\n", + "│ 270 │ │ │ init.zeros_(self.bias) │\n", + "│ 271 │ │\n", + "│ 272 │ def forward(self, input: Tensor) -> Tensor: │\n", + "│ ❱ 273 │ │ return F.group_norm( │\n", + "│ 274 │ │ │ input, self.num_groups, self.weight, self.bias, self.eps) │\n", + "│ 275 │ │\n", + "│ 276 │ def extra_repr(self) -> str: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/functional.py: │\n", + "│ 2530 in group_norm │\n", + "│ │\n", + "│ 2527 │ if input.dim() < 2: │\n", + "│ 2528 │ │ raise RuntimeError(f\"Expected at least 2 dimensions for input tensor but receive │\n", + "│ 2529 │ _verify_batch_size([input.size(0) * input.size(1) // num_groups, num_groups] + list( │\n", + "│ ❱ 2530 │ return torch.group_norm(input, num_groups, weight, bias, eps, torch.backends.cudnn.e │\n", + "│ 2531 │\n", + "│ 2532 │\n", + "│ 2533 def local_response_norm(input: Tensor, size: int, alpha: float = 1e-4, beta: float = 0.7 │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "OutOfMemoryError: CUDA out of memory. Tried to allocate 3.06 GiB (GPU 0; 39.56 GiB total capacity; 33.04 GiB \n", + "already allocated; 752.56 MiB free; 37.34 GiB reserved in total by PyTorch) If reserved memory is >> allocated \n", + "memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m34\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 31 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_voxels = voxels[past_behav[:,:,\u001b[94m5\u001b[0m].cpu().long()].to(device) \u001b[2m# batch_s\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 32 \u001b[0m\u001b[2m│ │ │ \u001b[0mpast_15_times = torch.Tensor([i \u001b[94mfor\u001b[0m i \u001b[95min\u001b[0m \u001b[96mrange\u001b[0m(\u001b[94m15\u001b[0m)]).to(device) \u001b[2m# 15\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 33 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 34 \u001b[2m│ │ │ \u001b[0mblurry_image_enc = autoenc.encode(image).latent_dist.mode() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 35 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 36 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m use_image_aug: image = img_augment(image) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 37 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/utils/\u001b[0m\u001b[1;33maccelerate_utils.py\u001b[0m:\u001b[94m46\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m43 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mwrapper\u001b[0m(\u001b[96mself\u001b[0m, *args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m44 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m, \u001b[33m\"\u001b[0m\u001b[33m_hf_hook\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m._hf_hook, \u001b[33m\"\u001b[0m\u001b[33mpre_forward\u001b[0m\u001b[33m\"\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m45 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m._hf_hook.pre_forward(\u001b[96mself\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m46 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m method(\u001b[96mself\u001b[0m, *args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m47 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m48 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m wrapper \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m49 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mautoencoder_kl.py\u001b[0m:\u001b[94m258\u001b[0m in \u001b[92mencode\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m255 \u001b[0m\u001b[2m│ │ │ \u001b[0mencoded_slices = [\u001b[96mself\u001b[0m.encoder(x_slice) \u001b[94mfor\u001b[0m x_slice \u001b[95min\u001b[0m x.split(\u001b[94m1\u001b[0m)] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m256 \u001b[0m\u001b[2m│ │ │ \u001b[0mh = torch.cat(encoded_slices) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m257 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m258 \u001b[2m│ │ │ \u001b[0mh = \u001b[96mself\u001b[0m.encoder(x) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m259 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m260 \u001b[0m\u001b[2m│ │ \u001b[0mmoments = \u001b[96mself\u001b[0m.quant_conv(h) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m261 \u001b[0m\u001b[2m│ │ \u001b[0mposterior = DiagonalGaussianDistribution(moments) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mvae.py\u001b[0m:\u001b[94m141\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m138 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m139 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# down\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m140 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m down_block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.down_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m141 \u001b[2m│ │ │ │ \u001b[0msample = down_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m142 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m143 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# middle\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m144 \u001b[0m\u001b[2m│ │ │ \u001b[0msample = \u001b[96mself\u001b[0m.mid_block(sample) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33munet_2d_blocks.py\u001b[0m:\u001b[94m1247\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1244 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1245 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, hidden_states, scale: \u001b[96mfloat\u001b[0m = \u001b[94m1.0\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1246 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m resnet \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.resnets: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1247 \u001b[2m│ │ │ \u001b[0mhidden_states = resnet(hidden_states, temb=\u001b[94mNone\u001b[0m, scale=scale) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1248 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1249 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.downsamplers \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1250 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mfor\u001b[0m downsampler \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.downsamplers: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/fsx/proj-fmri/ckadirt/diffusers/src/diffusers/models/\u001b[0m\u001b[1;33mresnet.py\u001b[0m:\u001b[94m650\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m647 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mada_group\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mspati\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m648 \u001b[0m\u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states, temb) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m649 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m650 \u001b[2m│ │ │ \u001b[0mhidden_states = \u001b[96mself\u001b[0m.norm2(hidden_states) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m651 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m652 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m temb \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m \u001b[95mand\u001b[0m \u001b[96mself\u001b[0m.time_embedding_norm == \u001b[33m\"\u001b[0m\u001b[33mscale_shift\u001b[0m\u001b[33m\"\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m653 \u001b[0m\u001b[2m│ │ │ \u001b[0mscale, shift = torch.chunk(temb, \u001b[94m2\u001b[0m, dim=\u001b[94m1\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33m.py\u001b[0m:\u001b[94m1501\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1498 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._backward_pre_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1499 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_backward_pre_hooks \u001b[95mor\u001b[0m _global_backward_hooks \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1500 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1501 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ \u001b[0mbackward_pre_hooks = [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mnormal\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mization.py\u001b[0m:\u001b[94m273\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m270 \u001b[0m\u001b[2m│ │ │ \u001b[0minit.zeros_(\u001b[96mself\u001b[0m.bias) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m271 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m272 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mforward\u001b[0m(\u001b[96mself\u001b[0m, \u001b[96minput\u001b[0m: Tensor) -> Tensor: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m273 \u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m F.group_norm( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m274 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96minput\u001b[0m, \u001b[96mself\u001b[0m.num_groups, \u001b[96mself\u001b[0m.weight, \u001b[96mself\u001b[0m.bias, \u001b[96mself\u001b[0m.eps) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m275 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m276 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mextra_repr\u001b[0m(\u001b[96mself\u001b[0m) -> \u001b[96mstr\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/\u001b[0m\u001b[1;33mfunctional.py\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m2530\u001b[0m in \u001b[92mgroup_norm\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2527 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m \u001b[96minput\u001b[0m.dim() < \u001b[94m2\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2528 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mRuntimeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mExpected at least 2 dimensions for input tensor but receive\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2529 \u001b[0m\u001b[2m│ \u001b[0m_verify_batch_size([\u001b[96minput\u001b[0m.size(\u001b[94m0\u001b[0m) * \u001b[96minput\u001b[0m.size(\u001b[94m1\u001b[0m) // num_groups, num_groups] + \u001b[96mlist\u001b[0m( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2530 \u001b[2m│ \u001b[0m\u001b[94mreturn\u001b[0m torch.group_norm(\u001b[96minput\u001b[0m, num_groups, weight, bias, eps, torch.backends.cudnn.e \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2531 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2532 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2533 \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mlocal_response_norm\u001b[0m(\u001b[96minput\u001b[0m: Tensor, size: \u001b[96mint\u001b[0m, alpha: \u001b[96mfloat\u001b[0m = \u001b[94m1e-4\u001b[0m, beta: \u001b[96mfloat\u001b[0m = \u001b[94m0.7\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.06\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m39.56\u001b[0m GiB total capacity; \u001b[1;36m33.04\u001b[0m GiB \n", + "already allocated; \u001b[1;36m752.56\u001b[0m MiB free; \u001b[1;36m37.34\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated \n", + "memory try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " #if epoch == 0 or epoch == 1:\n", + " # break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " # reshape past voxels to be (batch_size * 15, 15279)\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " #print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " #print(embeds_past_voxels.shape)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1)\n", + " #print(embeds_past_voxels.shape)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + "\n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print('test')\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + "\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + "\n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15\n", + "\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " \n", + " print(past_15_voxels.shape, past_15_times.shape)\n", + "\n", + " embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times)\n", + " embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1)\n", + " information_past_voxels = model.memory_compressor(embeds_past_voxels)\n", + "\n", + " \n", + " voxel_ridge = torch.cat([model.ridge(voxel), information_past_voxels], dim=-1)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train-with-memory.py b/src/Train-with-memory.py new file mode 100644 index 0000000000000000000000000000000000000000..d2734608ca94cea8903d858cf42cfb1a40ed2eb5 --- /dev/null +++ b/src/Train-with-memory.py @@ -0,0 +1,978 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +# from subprocess import call +# command = "jupyter nbconvert Train.ipynb --to python" +# call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +#from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 128 #128 + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[5]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # Example use + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name=test \ + --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \ + --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[6]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=240, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + + +# In[7]: + + +outdir = os.path.abspath(f'../train_mem_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[8]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + + +# ### check dataloaders are working + +# In[9]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + +# # train_images = np.hstack((train_images, test_images)) +# # print("WARNING: ADDED TEST IMAGES TO TRAIN IMAGES") + + +# ## Load data and images + +# In[10]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[11]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + +clip_seq_dim = 257 +clip_emb_dim = 768 +hidden_dim = 4096 + + +# ### SD VAE (blurry images) + +# In[12]: + + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# ### MindEye modules + +# In[13]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[14]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +print(b.shape, model.ridge(b).shape) + + +# In[15]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + self.upsampler = Decoder( + in_channels=64, + out_channels=4, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[64, 128, 256], + layers_per_block=1, + ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + b = self.blin1(x) + b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + return c, b + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((2,hidden_dim)) +print(b.shape) +clip_, blur_ = model.backbone(b) +print(clip_.shape, blur_.shape) + + +# In[19]: + + +# memory model + +from timm.layers.mlp import Mlp + +class MemoryEncoder(nn.Module): + def __init__(self, in_dim=15279, out_dim=768, h=4096, num_past_voxels=15, embedding_time_dim = 512, n_blocks=4, norm_type='ln', act_first=False, drop=.15): + super().__init__() + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.out_dim = out_dim + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.final_input_dim = in_dim + embedding_time_dim + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.n_blocks = n_blocks + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + self.memory = nn.Parameter(torch.randn((self.num_past_voxels, self.embedding_time_dim))) + + + def forward(self, x, time): + time = time.long() + time = self.embedding_time(time) + x = torch.cat((x, time), dim=-1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory encoder +# memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=hidden_dim, num_past_voxels=15, embedding_time_dim=512) + +# device = torch.device("cpu") +# memory_encoder.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_encoder.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15279)).to(device) +# rand_time = torch.randint(0, 15, (2,)).to(device) +# print(rand_input.shape, rand_time.shape) +# memory_encoder(rand_input, rand_time).shape + +class MemoryCompressor(nn.Module): + def __init__(self, in_dim=768, num_past = 15, output_dim=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15): + super().__init__() + self.num_past = num_past + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.final_input_dim = in_dim * num_past + self.lin0 = nn.Linear(self.final_input_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, output_dim, bias=True) + self.n_blocks = n_blocks + self.num_past = num_past + self.output_dim = output_dim + + def forward(self, x): + # x is (batch_size, num_past, in_dim) + x = x.reshape(len(x), -1) + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + return x + +# # test the memory compressor +# memory_compressor = MemoryCompressor(in_dim=768, num_past=15, output_dim=768) + +# device = torch.device("cpu") +# memory_compressor.to(device) + +# # count params +# total_parameters = 0 +# for parameter in memory_compressor.parameters(): +# total_parameters += parameter.numel() + +# rand_input = torch.randn((2, 15, 768)).to(device) +# print(rand_input.shape) +# memory_compressor(rand_input).shape + +model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.memory_compressor = MemoryCompressor(in_dim=model.memory_encoder.out_dim, num_past=15, output_dim=4096) + +utils.count_params(model.memory_encoder) +utils.count_params(model.memory_compressor) +utils.count_params(model) + + + +# In[17]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, + {'params': [p for n, p in model.memory_encoder.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.memory_compressor.named_parameters()], 'weight_decay': 1e-2}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + + +# # Weights and Biases + +# In[ ]: + + +# params for wandb +wandb_log = True +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + + wandb_project = 'stability' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=model_name, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # More custom functions + +# In[ ]: + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + + +# # Main + +# In[ ]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[ ]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(0,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + #if epoch == 0 or epoch == 1: + # break + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + # reshape past voxels to be (batch_size * 15, 15279) + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + #print(past_15_voxels.shape, past_15_times.shape) + + embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times) + #print(embeds_past_voxels.shape) + embeds_past_voxels = embeds_past_voxels.reshape(voxel.shape[0], 15, -1) + #print(embeds_past_voxels.shape) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + + voxel_ridge = model.ridge(voxel) + information_past_voxels + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + loss_blurry_total += loss_blurry.item() + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + with torch.no_grad(): + # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False) + blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + print('test') + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(15)]).to(device) # 15 + + assert len(image) == batch_size + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + clip_target = clip_model.embed_image(image.float()) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + + print(past_15_voxels.shape, past_15_times.shape) + + embeds_past_voxels = model.memory_encoder(past_15_voxels, past_15_times) + embeds_past_voxels = embeds_past_voxels.reshape(batch_size, 15, -1) + information_past_voxels = model.memory_compressor(embeds_past_voxels) + + + voxel_ridge = model.ridge(voxel) + information_past_voxels + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + axes[0].imshow(utils.torch_to_Image(image[[0]])) + axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + axes[2].imshow(utils.torch_to_Image(image[[1]])) + axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + plt.show() + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + diff --git a/src/Train.ipynb b/src/Train.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f9f0ef92f2a33621f9e3abcf58c70373b41a296c --- /dev/null +++ b/src/Train.ipynb @@ -0,0 +1,1741 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5e43a1f7-61eb-4263-bdb1-4ded8a9a7e1a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fri Oct 13 22:48:03 2023 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 NVIDIA A100-SXM... On | 00000000:10:1C.0 Off | 0 |\n", + "| N/A 51C P0 132W / 400W | 27097MiB / 40960MiB | 96% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 1 NVIDIA A100-SXM... On | 00000000:10:1D.0 Off | 0 |\n", + "| N/A 44C P0 83W / 400W | 23793MiB / 40960MiB | 94% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 2 NVIDIA A100-SXM... On | 00000000:20:1C.0 Off | 0 |\n", + "| N/A 52C P0 88W / 400W | 24079MiB / 40960MiB | 99% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 3 NVIDIA A100-SXM... On | 00000000:20:1D.0 Off | 0 |\n", + "| N/A 45C P0 83W / 400W | 26575MiB / 40960MiB | 97% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 4 NVIDIA A100-SXM... On | 00000000:90:1C.0 Off | 0 |\n", + "| N/A 30C P0 51W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 5 NVIDIA A100-SXM... On | 00000000:90:1D.0 Off | 0 |\n", + "| N/A 30C P0 51W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 6 NVIDIA A100-SXM... On | 00000000:A0:1C.0 Off | 0 |\n", + "| N/A 31C P0 69W / 400W | 2331MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 7 NVIDIA A100-SXM... On | 00000000:A0:1D.0 Off | 0 |\n", + "| N/A 29C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| 0 N/A N/A 3432550 C ...vs/mindeye/bin/python3.10 27094MiB |\n", + "| 1 N/A N/A 3432551 C ...vs/mindeye/bin/python3.10 23790MiB |\n", + "| 2 N/A N/A 3432552 C ...vs/mindeye/bin/python3.10 24076MiB |\n", + "| 3 N/A N/A 3432553 C ...vs/mindeye/bin/python3.10 26572MiB |\n", + "| 6 N/A N/A 3500952 C /usr/bin/python3 2328MiB |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-13 21:53:25,590] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 3505062\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 2 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-5', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-5 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 64\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": {}, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,062,786,436 total\n", + "1,062,786,436 trainable\n", + "param counts:\n", + "1,127,216,516 total\n", + "1,127,216,516 trainable\n", + "torch.Size([2, 4096])\n", + "torch.Size([2, 257, 768]) torch.Size([2, 4, 28, 28])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " self.upsampler = Decoder(\n", + " in_channels=64,\n", + " out_channels=4,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " b = self.blin1(x)\n", + " b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " return c, b\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,hidden_dim))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,127,216,516 total\n", + "1,127,216,516 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2cfbf30b-0da6-487d-84e7-c43b39116d9e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"for idx, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\\n past_images_indices = past_behav[0,0,0].long()\\n past_voxels_indices = past_behav[0,0,5].long()\\n \\n print(past_behav[0,:,5])\\n print(old_behav[0,:,0])\\n\\n # look for that past voxel index and assert if its future voxel index is the same\\n for num, i in enumerate(behav):\\n if i[0,0].long() == old_behav[0,0,0]:\\n print('aaaa')\\n print(future_behav[num,0,5])\\n print(behav[num,:,0])\\n \\n print(behav.shape, past_behav.shape, future_behav.shape, old_behav.shape)\\n print(past_images_indices, past_voxels_indices)\\n print(behav[0,0,0], behav[0,0,5])\\n break\"" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# tryal of getting the past and future images\n", + "\"\"\"for idx, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " past_images_indices = past_behav[0,0,0].long()\n", + " past_voxels_indices = past_behav[0,0,5].long()\n", + " \n", + " print(past_behav[0,:,5])\n", + " print(old_behav[0,:,0])\n", + "\n", + " # look for that past voxel index and assert if its future voxel index is the same\n", + " for num, i in enumerate(behav):\n", + " if i[0,0].long() == old_behav[0,0,0]:\n", + " print('aaaa')\n", + " print(future_behav[num,0,5])\n", + " print(behav[num,:,0])\n", + " \n", + " print(behav.shape, past_behav.shape, future_behav.shape, old_behav.shape)\n", + " print(past_images_indices, past_voxels_indices)\n", + " print(behav[0,0,0], behav[0,0,5])\n", + " break\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "aebcd3dc-a0b4-4fb7-8aea-eb0173d86f3f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"for idx, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\\n past_images_indices = past_behav[1,-1,0].long()\\n past_voxels_indices = past_behav[1,-1,5].long()\\n\\n # look for that past voxel index and assert if its future voxel index is the same\\n for num, i in enumerate(behav):\\n if i[0,0].long() == 50755:\\n print('aaaa')\\n print(future_behav[num,:,5])\\n print(behav[num,:,0]) \\n assert future_behav[num,0,5] == past_voxels_indices\\n \\n #print(behav.shape, past_behav.shape, future_behav.shape, old_behav.shape)\\n #print(past_images_indices, past_voxels_indices)\\n #break\"" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"for idx, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " past_images_indices = past_behav[1,-1,0].long()\n", + " past_voxels_indices = past_behav[1,-1,5].long()\n", + "\n", + " # look for that past voxel index and assert if its future voxel index is the same\n", + " for num, i in enumerate(behav):\n", + " if i[0,0].long() == 50755:\n", + " print('aaaa')\n", + " print(future_behav[num,:,5])\n", + " print(behav[num,:,0]) \n", + " assert future_behav[num,0,5] == past_voxels_indices\n", + " \n", + " #print(behav.shape, past_behav.shape, future_behav.shape, old_behav.shape)\n", + " #print(past_images_indices, past_voxels_indices)\n", + " #break\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0048a460-7112-4a16-b80a-9145b61e21e1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"# plot results\\nfig, axs = plt.subplots(2, 2, figsize=(10, 5))\\naxs[0, 0].imshow(utils.torch_to_Image(images[10520]))\\naxs[0, 0].set_title('Original')\\naxs[0, 1].imshow(utils.torch_to_Image(reconstruction[0]))\\naxs[0, 1].set_title('Reconstruction')\\naxs[1, 0].imshow(utils.torch_to_Image(images[10521]))\\naxs[1, 0].set_title('Original')\\naxs[1, 1].imshow(utils.torch_to_Image(reconstruction[1]))\\naxs[1, 1].set_title('Reconstruction')\\nfor ax in axs.flat:\\n ax.set(xlabel='x-label', ylabel='y-label')\\n ax.label_outer()\\nplt.show()\"" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"# plot results\n", + "fig, axs = plt.subplots(2, 2, figsize=(10, 5))\n", + "axs[0, 0].imshow(utils.torch_to_Image(images[10520]))\n", + "axs[0, 0].set_title('Original')\n", + "axs[0, 1].imshow(utils.torch_to_Image(reconstruction[0]))\n", + "axs[0, 1].set_title('Reconstruction')\n", + "axs[1, 0].imshow(utils.torch_to_Image(images[10521]))\n", + "axs[1, 0].set_title('Original')\n", + "axs[1, 1].imshow(utils.torch_to_Image(reconstruction[1]))\n", + "axs[1, 1].set_title('Reconstruction')\n", + "for ax in axs.flat:\n", + " ax.set(xlabel='x-label', ylabel='y-label')\n", + " ax.label_outer()\n", + "plt.show()\"\"\"" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb stability run test\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'test', 'batch_size': 64, 'num_epochs': 12, 'use_image_aug': False, 'max_lr': 3e-05, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 2, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231013_215512-xdaajut2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run test to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/stability" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/stability/runs/xdaajut2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": {}, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "resume_from_ckpt = False\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif False:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|█████████████████████████████████████████████████▏ | 1/12 [04:18<47:18, 258.03s/it, test/blurry_pixcorr=tensor(0.1444, device='cuda:0', dtype=torch.float16), test/loss=35, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=1, test/test_bwd_pct_correct=tensor(0.0156, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.1250, device='cuda:0'), train/blurry_pixcorr=tensor(0.0878, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.0287, device='cuda:0'), train/fwd_pct_correct=tensor(0.0370, device='cuda:0'), train/loss=36.8, train/loss_blurry_total=32.7, train/loss_clip_total=4.05, train/lr=5.43e-6, train/num_steps=391]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 17%|██████████████████████████████████████████████████████████████████████████████████████████████████▎ | 2/12 [08:14<40:53, 245.31s/it, test/blurry_pixcorr=tensor(0.2324, device='cuda:0', dtype=torch.float16), test/loss=30.1, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=2, test/test_bwd_pct_correct=tensor(0.4219, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.6406, device='cuda:0'), train/blurry_pixcorr=tensor(0.1499, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.2161, device='cuda:0'), train/fwd_pct_correct=tensor(0.2720, device='cuda:0'), train/loss=33, train/loss_blurry_total=30.3, train/loss_clip_total=2.68, train/lr=1.57e-5, train/num_steps=782]" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAACaCAYAAAA5H/n3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9V7BtyXnfCf4yc5ltj72+ritvUEChCp4AAYIAQQGUKMr09Kg1IY0UCk1ER4cUE5qIfuiJiZjop3mcB41ca9SSKLFFUSRFikZNJ8K7KgDlfV3vjj/bLpOZ85CZy+xzbuGWANx54E2g7ll7mVyZuTL/+f9MfimstZZ76V66l+6le+leupfupXvpz0yS//8uwL10L91L99K9dC/dS/fSvXR30z0CeC/dS/fSvXQv3Uv30r30ZyzdI4D30r10L91L99K9dC/dS3/G0j0CeC/dS/fSvXQv3Uv30r30ZyzdI4D30r10L91L99K9dC/dS3/G0j0CeC/dS/fSvXQv3Uv30r30ZyzdI4D30r10L91L99K9dC/dS3/G0j0CeC/dS/fSvXQv3Uv30r30ZyxFd3rj//yPfxmhDLvbc3SeoVLJNBug4gHrgwlpp4NUEbFQbO9LpCw4ezJFoyjLnI6K2RuBkZYj/YJ5llNYgTBTrI3p9vuMZ5Ysl8zmOTOdkh49QqwSrBAgwFqLqEokkIARFotAARYQAgwgAGtBuiP3nABhRXXs7rdgBRaLsAIrLdaCQCCwGAEyXMc9K4ASEBikexxrC6QFrEEK/DsVRoC1i2UAK5QrrC+fROBvo4rMbamuW2GxViCEASQYjbAGicSgfelc/Yy0CCsxwiKsK7n0LWeFwAqBsK4FjW9DYQ1Yl2d4q0C4nG0otG+zUDQrsMD/9Nc+fqfd6EdOD3ziL9Cb7RDHAiUj4igiThIiGRFHMVJJhFRESqCURCmFUAqERAqq7ydEVYt2srf9cTD5/A7eL1r34L/Nu2fQaNl3ea1t/1O/47Bn7qAutnl0u/eKdg1E45/D61VXyxXVLp4BUY8lqnsax9ZircUYgzUGYy0WizUWrTXaGPKiINMlmS4pS8U3vvp7tynNjzedP3OCB86eYtiF77xwAaUUUkqklBhjEAKWl4b84s/9NF/8+c9w6dIV/vH/8stYadjYnrO81KUsNPuTOWVp0LrAGIGxmvWVPpPJjP3pnLXlIaU2FKXmL37xc/zMpz5Er5ty5epN9nZukc3mAMRJynBlhfUjx1g/epRhL+HKpSusHb2PX/nV3+Dilatsbe8jpEQJsBiElEgrEFLys594ktcvXOPytU0sgm6nA9ZS6tKhmAIpJB/90OM8+/xrTCYzTGmx1iCloCwLtLZ85pMfBpPzW7/3VRCKKFZYXVIa/z0BY923FEiEFFjt2iuKFFleIoVwY1hAWTiUjeKYbprwwOkjvHP5JutH1wHLx595ksfuP8Zbr7zK88+/ihFgtEaqmDRNEAIGvQ5xHDNcPcoTTz7GyiDhn/zr/8Tb17YQ1qKkIIojhv0em9t7WG3QwuGGUhIlJYN+h7OnT/Dt773MEw+eZmtvxGicYYzGWJACpBA8eO4Uv/Mn37krfRDgsY99CrN5E2MKlIiQSpGmKbGKiFTsccHjYCRRUYSU0uE/+G9iHRb68WatdfOSdfOtS9aPVxGyrMdtCweEm9L8merYHwghqv/CvaKaFBvZVb/Dc42XLQJOE7P8XH5YaqJPfUeN14fjoKiIROs1rWsLL2gf1vU78HSjzkI4zuC/i7WNudZ/A2sMutTosqTUBqFACYX0OU5nc+a6pLAls0nO91763qHtsJjumAAWuWV3XKI1rC132J/Nue/0kPnYIlXM3igi7UpOrglkbNjZK5lOFdsTzbAvWVsXxBHs7GUY0SHLNJtbIwo9BzsjHUCaRKyspCwv9ZFKMMlHzOUSpUiwQOSnDN8kWAHSyqp5HQHCdyz/dYQjMKbVGU178hEWkAhhkFhHkgDliVkgi9JSdbJI1F1JIrAyriZKYQO7tP6DFghUPV0KHNEypStLIKYy0E6qeoaySKQnrAJrDcgIISQWA8TVBGox7j2OxUJFeD0JtY7sOWKYEVuLlco9KyXWRo5wW7DGooTFSvx7fOGt8OUxtyUAP6nUtSOWe4qkkxJHsSOAUeQn4YgokkgZIaVvTyGQ0g2TMBjFbQtdCwd3lBqocts8G4DYxIpDudaBk/Y2p+0hd737Pe+WrLW3Lb84cOGQNrKLd7SvW969SUVbrPB9Vzjw88IU1mKMRRuDMQZjoSw1pS7J8xJTxu9eyR9jyouc3f0RZ0+dRimIY0VZGgqtMVqjlGQ2yxzmiA6DpXW0zhDZnO3dGf1uijEwmToSkaYx/U6HbifhvmND9scz+qMJg16H8SxnMp0znYyYTSfEKmJ3ewuwSOmExrSbkiQp1lqK+RSdKnyXZ3Wlx2y2jC4tKoqw6DCnYYw7KIo5kZCkSYq2liRWCBlBnhNHEYNOSpLEPP3U09zc2Gd7Z4dsXmCMJVaSrCjAGGKpiSQ8fP4+LIIokghrHXm3DitKoyvyIZXCakukJFIJCq3BeAxGUuoSgDRJ6HRizp85Tr8Tc/T4UdZXluh0IpSUCDRC4CdRkBikcPlGSpJEClNkFPmc6azkg4+f49TxVfIsC9I7UlhOrQ0Ig9ka0BaMtS7ffMaDJ9bpxJK1QZ9Bt+Pa0BqUVFijSaK7a1BT8z0GHYlK+sRRQhzHSBUhhUQIiVQShHRjWAiPibKaD6p5sxrjosGxDjIa4UlgJRA2sA0RrlOBYc3tmnkdFBrDfZaD19pFEa1TQeFDc747+NAh6d0F/3eRgw+A2w+dKjyWBeVVmMMPoqJt/Wn+CHdJT9SN9RioDbp0x724T18KrAXdL39Yqap0xwSw1Iqy0CRScGtTo22frUhz+mhCP5Vs7mnmecJsDns7U06fGdDpKEbzCeNZzP6kJJsaBn1FvyfIpxYhIopS0Uk08wyy3DDPNd2BpJMmCFvAZA+5tIZVEYH0gUFYifLartDOEukAQFicHlA6aUW46VdYgRAWgUVaTyYrYcN4zaHwGj8v6VjrWbj0RFEgJBhBUIqBFJ4cesbu1GuuQwtQVhG6rCut8m9yesvQ7SXSf3QNtvTnwgALHUlg0GCLqk4I6esuMUJikFgLCh1qhBCGUrq6ISTCCCDGYEAITxstGFuVQQmLEA4wjFRoDNII11amdDBtAzG8O+nE6pCegiRNSTspsXJaPymlBzenWZAV8IX2WwSlZgrCgifJh4Bf+NF+7iARuz2ANRlR6CyHZnPw2QaZe1c93h1pDg957l1effuT7bawB8oQyGuT2DXvblLi9uioOZ+ptBBCgJDSaQCNQWuDLEqUiUDkyPiOoexHTrowTKdzkiQFpAd5SSdSyCSh00mRUqGUoNA5yyvLdLt9unGf7s4t5kWJwJLnGQKLjSS6yDBKI+2Q1UGf1eESJ08dBeu0defPnUTrEqMN2XTCYHlAnmVeYwNJkqBURFkW5HmGsSCM5hc+90nyvKDUoK0mjlKQikhKp22LFNYKlLTISCJVjECjSyiNdYKe1ZTG5fvX/tLPow2U2qDLDFNqikKjrUEXBVqXPPzooxhtsFZjSqetxRqMLpw215jqHB7zpHCaKGssWKcVxRqscdaXKIqRiaLXTTh6dJXYa111kfl8DAqJ9eNeSUEnTYnjCINlUpaUxrjynT/B/aeOcH1zm5Veh06SOOleKk8kI6ywIKUnmE4DKlWMkIJIRahIEkUxQhqSJPHziLprfRBgeZjQtR1UEpPECUrFCAlOpHLzmxDSCQoE4iGo+IdHLC/vt9IBKlbNk22SV2nyG4Ki0/I1cjmMEIbrC+Su/nmAhjYK8V+b7kAotot3HaLiW0iH0Li2AN5UTFYa1gamB11NI7NFch60gkIKYhWjlMRoy3xeOAWXdQJTkRfo4idAADs9y6ooWF1J2N+dom1JOuiyuT1n2oE0UayvReTzHKNSLl7OeOD+Lt1UEcsSjGI2z8hygVEpxgruOwGRSijzKdOygChlZ3uOLTSjosPSIKLfixFiwjxaJi+l79qqwl0lhKN6nvQJvLZMyIqASUAZd2Bw5lHHCTzZEQJpLcqbRF0/a6h1qi9sCfo45UmFldYrBSUIU5E1R0jdADNCViZYR7hqEmorimcQlZZNArGrYyB5XuOGFJ4oOjnZvUE5wMcAJcJkDlYNKKXqcRN6obFg3fNKCPCmZKxwpmkcGFqFL59xpwCtvLlYOs2nuHNF048l9ftdOlhSr5WIo9gBjnRg58BHum/qJd9FNXwNSs3Ci1pCa91+cOAv8rlDrt7mnv8a9LK3/Xmw6Q/qGN+VY97m291eQ3r7ZO1iwextsrcN7PMmp9uQx6Y5J9xnpUMAa52Gw3ptTxzfPe3L0dUhvV6CLnLOHF8J8h5xHNNJFL1OBxVJepFkOrecPrHEM08+yngy4ux9J1EqQkmBMRqEqrBISkkkI1ScECeSotD0Bn3WVpfo95dIkxQpYTTeAQVZVgCGeJ6xt7fPaDxBKUkcObxYXz9G1BkgE8loss/e1j733bdKqS1aG7QtISswvp0dhI3R1pAXGWWhvXbYXdel03CWRUlRlBRFRpHnlLrE6JL5dIqxljTtkJcFpigw2lDaAlNorNYY6wie8URQ2Jr8OVx07i3uGxuM9u4tUiGVYjqZU0wmqNgLfFZw4eJNtvbnzgSvXT0GpWF7b0IcSZRUdAcrXLlwhVhqFBBJSCRMJmOmExzJtWCNoDQWY2VFrl0fUygZI6Vw5lSlEECklCOnShJFd08IAUjThNQqVKQ8/jnFCLJ2VhIqaJ9q8+tBrT4HLQaVTNxCxQPPtrX3h1hXgjS3MJc276vyXCR9h5JAbgtQhxKxhTt++D11kd9FpF9447trFAFqg6GotYI05HvBwlzqWGOz2aSS1SxljEVISRxHWCuxhXWcR4CK7lwQueMee3PDUMxHbGx16KYJJ4/FdJMZs5HBEDErE2abJaePxSihmcwNWabYHQtiaXjwdEIxM2S5psgN0zyhzMcoCZOJYq5nCClZXomxtmR1qFGRJFUlCMtSPGVD99BVl/PkC4ty4k3jU5lGh/eNKcEK4/xeDpFmHIg7dX9g4iJ4Ewrhx4e31YfOEYi8NM5/MGRs/X3+Y7nyGUcdvVnYDVRT5SU8CQxjxQrhKZ6o6tQaPd6/TwAG7UiPFc50IyOMEEhjvenbgrWVv6IrovUmbunB1jr/QlsivbnGmbC8pkY4raWydZmC9vBupiiWREAcR8Rx7Ey/Qlbm3uCrEtqp8k6pxU8/GB1ALg7yJu+7Dfw08mud8X/tIffcCYg0k20Vyzb9WhooUWmgm3m1RMmgPRONX00wOuS9h5xpmnsaJw8e3zbLJhkUXvAKx2EQhSI3JosG+XA/vZ8S3tdLAEq4viDv3uT74fedQykBWvPUI2cpisIJfFKglMMSJWE6mbK3s8MjD52h2+uhsxlJJ3Km1+CTKh1x1UajjUUo6Y5nBZPRiGw6IxtPEdEmFoiU5MKFa6yuThzh7Hbp9TQS6MQRQkr6gz5mvs/ujTcYDvr0BgOOrAw4sXaWKE2dKdCU6NIghMTghKUoiRFKIYiQUYQQCoMFnVNkM8ajEc/94GVef/VNpvu7FHlGMZtii5KiLLBakxmwxpBZi9EG4ycr4887RUYQpC1SQqwEsRQoGVxdLFb7XmODtthgpcICyltZnGbL+TIeX+46odXnHyUxUkb0uzH9bodevwfFFC0sSarodjrOH84abwqX5EXObD5nNs0YT3PGs4zZPEdrjcEJHL1uysrykBPHj7K2tsZweUi30yftdInju+eGAA4LpZFIrw0F6ftTjYXt8XsbbVbQskMDtML81h6DIdXmXv+PqOlV7WrTvkcc+rdJKg9qBBeh59Dyv9vZdnVum5r4WJ9ovvzdNIH1SwLSBguHPQwfQ/3DM+HlUnjMwytjbPXZrMfGps+mMbrqv97NFiUVcbfzLjVtpzs3ARd7xJFlPJ4SWU1ZJuwVE4ZLHVb6kr1pyVzH7I4tWW5YXuqyPDTsbhvmBeyMFftzyepQsTKAIk9QcoUsH1GIFYScUGSa0Z4iNzGzecF0blgaKrSOGA41/bWUkY68mdWbXQEh/STpFz9YDAiQ1vhvaGn0RIQImjOqj2Bl/QHr6dKZVR1Z8s8Hcd8DjRRe3e4HQPhonqcjcM9L/6wNZt7K7zB0rDBUAwMNSzcCI3SkrRqU1g10R4JxWrnQk4REYVxHkRaMBOk6j2zWjagGZCHBEz8bymANWIEWxi8X9+2KxQiNuo3D7U8yRVFEIiCOIi99R5XGz2Gea30h6q97GBE7nJsd9G8LhsomLrb70u3LKg7e7g5+CAE73H3P3ua8fy58i4OssEGoWKjbj5aasn9Le2fblK95f0Vu/bENBDEs8ApdmJCH8P5jbmwZY1EKnKeXBa1RShHfRe2L9GMwy+aIJKmAGCtRQoGFrCiY53M2N64TR0+ipNMo7exOyPMMaxXz+ZTxZEae504jpzVKCYyxFIVGCEtRarR1ftadOKKTSgYD56umJBirSZKYXr9Hp5OSpDGryyscO/Yg66tL9Po9VNwhToeIuIdQMVY68qqziVukURYIQKnE+RZHMSqKENJZA0yZk4+22Nq8QaQiRqMJo719ivkMkWdQlBhdYLQlN5bCGkoEpQFtgg+g++jG1gKAEIJEgbACJSUyEljCpCbAan+/w3DrmDNWehzTAiGdJkQIhRQC7XFPSYkSgiT2PsJSkCaJw4wwX1hJWTqi6nycI5LEEucGpQqUcJrCINBHSpImMf3+gJX1dY4eP8Ha+hrLS0v0+z066Z1PvD+OpGREJBRCOR9o4a03QkqnIcIpJVpuFEGr1jQtLvjlOX4RTLvhZE0kWwL2AqlrvqcmhOE5Gu/yzywI7FUuPwSXD8fQJr4fotG87d2NdzSF7wOM8JAHD73HYVWlwfPk7fAH67Zvf4vG/Z4FWr84Dj9fWxoL5azw55qE+oenO0bNeHoVEUeY6T7TmWQjOotK+mgZI2xBt5uyvKTQRc5kFrGxI4hiGK4o+qUkkpaSHtt7M0rmdPrLDGPDzqYlkpaiMGhlkB1FrCVSwiDV6FyiREGWpUR7m3SGa2TEDv6FxIrguWc9+dKORnnzriNRNehYvyjEBmrtn1Y0dWy2nk/DNOS5X/ALdOZZl4UIKhV/o/WsXhI0a6FDBmpZT2/B608SViJbB3DWrYQzVcfwH9YGZ2dbCSj1Ihfhia+XQHxZkKaqZ3O1sEWCCCuIHZk1DTWR8OpOt9AmdCrvsxPWXd+WlPxkklKKSApUpGrfv6YGsEaa1kCoYWdBsKP+0QKmxrVaYdUAqMYtPyy9lwEZUiBGrXP1hcOfud373/Pbb5cOy8kuHNpqXLRI4KLPi2jfGzJYtMw7DwUv+BiDkRatg3QdU3oydjfT2+9cBiFZ7nfRnYilfpc0iel2UmQUUxjodVPmumRre4diPiWKBf1+ytb+iHw2ZZ6XTCdTptM52niNu3VYaCyU2tW99ARKGKclM0agyxxdFthYYbUmz+bkubOgSKGxxvnl5YVG5SWxzRFMkDi/P4F0ZErEGKvBOi0gwpEIJWOsx4cwdzkh12lbI+WELkfKoF4g5gTlwpMOU/UA971M+J7+w0oRNBvuWVmNvYCKoAQEwdPDnneacfinApHxeUtrq9WuwrpGFEqhVFQJxFYI50BvDKVxUR4MAmMMhTYY611epCOSFoeLURyRpinDlSWGS8v0BkN63Q5pEhNFkkj9+EbanSQVxURWIiPnmyhRrq9Ip1gQ3nJlglbJN35o8mAhq71xbUXympJrCw4DYasw8xBy1yCZbdLXPhd+tzH3MLxsvCP8bvxpkcFDydsBibjxrsNuPQxPWo3y7qm1avjQArWKVRe9EeXE6XGq7xUuuHFbvQaMi4YivEVQ2/cW2++OCeDv/savIYDh0jL3nTvH0qBLt5eSCdgfaaZTTRTPue+4IIoMe2PIs5jtXYGQhnMn4egRyWwcY4xifywp4ojO8ipkc4odxfJaymRmOXk8YTK2dBLBdC7o9STjqaEbG/LZPrKz6qUdp2ELIVQccfKN1uzwwgb4qUDGVFSI6isE5V6zg8nwNSq2JZANDWJ1u6VS4dogGXn1uRC1KjiYH4UHFbx2MGg1nZZO+sUtztuvWsmMB0yHY3U4FxEKY33HEU47YtvhZVxWwr/fOhMuuBXNnsupakDUdZHhZxMqrG223l1LQikiqYhUVIXeqPxaRIP8BQK8MIAqebOJIYvE7oAk2kKfBQJ4sBUOnHlPjLEJFOKQ84ed8zDzLjyoqkuYKd8lLcLV4W9cuNps6CCw+AdsM5OFgeMesfU1D8A1ENZjKQhWQliEBCldFAClJErcPR/AeV4AuNWlVgOWoU3Jy5LcQKEN3U7MZFpyJhkw2t8nn83YuLXJ9sYWk9msCp1ijK8X1oWCqfqbmwGsLZGenLiQOE47WJYlWZ4RC8lsNmc+n2ONJYkGaOsWXpTa3Seloiw1kcydi4jymn+jvUndrdK1usT4CUZEMWivcatM9IIoSUhTR3jKarx5P2HP0KSUiNJ432XXF0zoFx6vhDVYoZzAK1wkAodn4Tu7sFfWExQ3lr0g798rhfPDs0KgPDlBKKy1KOHMYhIXBSCNI9I0du46gLDKvcd4fyrr8hIqIopCNAG3gEJ64TiJE4bDPsNel35HMexGdNPEuaFEKSJK71ofBNxCIyu9BcTPVYcQmNp6UdO86ncDB1vuFg3Ia5GzKgfRuiZE8/riszWxbF9fwOIDL2prJutrNYiIRlkDzoRzzXZo/2yjW8uPsVkgmvfbhWf9U7YWcpqMTrS+w22AuYGJbkyI1jNOh+VNvqaRl60tJ0IaJL7/+/7+E9EA7u9sI4UErXljPGL72jVWjx3lyWc+zPLxs6i4w6hQ7Oy7ZcrLA0W/nzGbZOxNFZt7JXkZsbLcpVdO2ZxNgZTJPGU2seTasrkP1iqKLYHRCZO5Zp4p9jNnON2faKJ4QjJI6a30CStz/fxQhwFqztceMKSV1WcW+PiAgf4L9zlF6AyNXtqcmyp1t8WFRmmSOWH8RBX0bO351vrMZNDKgTdF+MUjVnoNpgNBp1+ztQlE1OWoygaVr6HCVuWpQsFIWnEP3XNeXSypVjsLbCV0SxrnROj67rpTtnpSa+qV0nczSVnHXFMN8neQAPrqLpavBVgHid/hx83fh0iB7/6z7meHXjxwM8EPpC2ZNgHKn7Ktp35o3vU9jTrc5pnbZdU638JRUUm+9YTT8GPB+9GKmtwd1HI2kLwBjtV38iJx0D4JqZwgJC1K3r0VmHmeA4LtckwnjdifzNlNY/BRCLTRJEnEoL9Et5OwtzdinmVcvnadvXFGmZdVvWszd4iTp5BKIIzxQC+Q0k80xq2KLnw8sEIIpCqZz+fMplNMWTIc9Cnzwi3W0NqtuNUlUhZInSOLyAlvMnKkzxRoHTR4GiEtpizRgFQuVqnxplclFXGkSNIUIWOQChlFYLVbrSvc93a+ddoPR1P5T4PvDwIv5opqMZmiIcxaCehK+GyaEEVYsOI1iFJKF2tVSC+UGpSMQnfEYomVQMYRMo5RMvgfOv9GYfCxJY1bySwEkVIkkXLe0V66VlFCt5s6f8KOIkmcaRkZObM6ilLfpQ7okxHO7w/rCIIJbW1FVfegPXftJ7xA1lA9NbhP0/0WGkOv5v/+ntqyFZ6xDXyrLWUhD5dJHaavSXQaeFedEjWBEqIFB/WBbfzb5naH0a3DzgVy2rrjEALdzKMuefv9B55pEocfmiwhVnCA+MoNK/yq2iE0Ogjh/fp9Ho6JKKT8CRBAazWdbhdrLboo2Nra5OaN67z58iscPXUfT37045x/6P3oMkHbhMs3Ms6eTOn2InpDFwNvNo/Z3tFMhSGWGeurMZtbOQjBch/2R3PSTkypIzqpYVZoBh0YzQTDvou90ksF090tuj2JSHueUDltQNAWuI5WEy0RNHGNr6EEVSdGuI4pjWgRGhEIGUESlRi/6tA5Tvum9z4iQcppEigZylBplQT4xRNu8JgqeEBYjFERGCGQwhBWCrvpr5Y33DOevDaEBOHDwDhGF0ajgBDk2Q9IGZ4JErV15LPWjnpzuVeuCBlA3LjjdxksP7GkIrCG4PdXgZsnsEEqq5CIRZMFLXJXA1794RdDGjRTM6/2cwdJ1aG3vStLq5HWBgkwXAmvbQDcgWDWt/0Ui3X4IcW409SoegD6JqYGgSZMOkFAqp+3vq/adn7+MLg+ECaORkzLoK132qEfT3XuNBlv9pyVFm3crD+Zun7mcMgSRRFLg2VWVwZMJ1MQsL0zwlgfx7PyD2pMQLYR68tP3CHIsLEuLp3WBqkEZVE6k29RkGUZ49EYudQHXIgmrQt06f7WpkBTBYM2usSUObrMMaVbWqdVjLSxM6t6baTTsLvxFSlJt5ugbYkUbgGHxjj/Yy90OiJnvD8eWOtCqyicP1+wIghACU3k+4wJTEL4hWYCFG4cuGML0oW5imRw6XGE271TO5wUIJV/znUVVBwCISuiyAV4ttpghKAsNcJaIgs6VqgsJ5ICazST6YyilD40jSVRkjhJEFGCJqIwgkhbpLZQaqy9u6uArVAYY/w85OcF6f3PmgSiwukwd1To5zNqZkp7MC2wLze+bWP+CvNLjU+LAFMvuvN5iDqv+taD5uL6ra3c3r1RKkyytwPgd330gO9yA2JbrbaokWlBcVgEUs/Ph0KzrW1qi/eI1rEXfKuc628oRT0/Ox9ZgxR33g/v+E4p3Soo6SteFCXWGvJizoW3XuP1l1/kocee4APPPMND73sakQ7Z35uS6Yg4lpw5EYMomcwMRkvGeYLYKej2IIoFqVD0eykCyzzTLC11GM/carrhADppTFYY4k7CykBT6AnIDgbVmMTdSlukdBox3CSSZyN0kdNbPoLwayVcaAH3EWQV368mPxVdE/XHFBjXYLXznfe/c59OVoNMgF9B5xZnyKo/Bu8W4aVlTBgQLiaWK1PtAxMcO6su4J+x1TvrcV4RROvqErSR+N1NKgk9EDvCqmdbdzIRJiFzoJNL3yaOBAYQvptTbyC3IT6cl37x5qEKRBogJ2pgCaUPB4eSu8ZNB3+37343gDlIstoQdjhXa1xpMr7qT6hDe1VtnQ4SqTtLt3ngTvJxjPvwx23tW1TVrcmXmzUJl0X7h4Cqk9tg+lhUfQqCKvyupODfJoFC26rMSoAxQRg0GONidZalodfp0ut2MUajtSaqQjUIymq3E+9zZrUPjeLIDEik9FoS40KSFLqE0oWtiqKI2XRCkkQUZY42YIwz/+Z5SVlalCoZxk54Mjp35Shd+BZt3MIJaUpHsowE7bTs1mgwzswthAs9olTkFt758ksvjFlhQAmsdiZ6yhClwE9ZosaQgB3GexNLEcRcCAJyiygIgZUu/FYIaNxUO0nhdzTyGjyDIFKWKFIkceojBgiE9x82UiKMQcapC8djHdYKY9Bl6UNsJMjCmYmllKg0JY5TLAptFbkWyBIoLIYSfXf5HwKF0V5wUG6HDxscLcMfjyFNQ2e1+LCBiaL5DLWG7wCuNbWxLWCs/fhqc6+ovmNLAdK85l96EKPb+LqIxT+8cd4bHtTzQgugDnnnQr7isONaEBaVEiKklgRf322rZjyQXfXlPJF2pDssrgp31HxH/CQ0gMHXSpclQgjiOGae58znGVobjLFcfOt1Xn3peU6f+S98+Kc+zQc+8iGMSSkLxfYIRhNYGUr6nYQb1zOmE8U867A/mqD0xAfbTJhOJ+yMJEJp5nOcxCYUnY5g/0bG6mrMZJIzLMd015bqDuM7VZBGiyIjn+yyu3MLk++ztHIUI4MvoPsYoUMHbqWsqiY0QTDNerLUWIzh3uKAr9qGDvwuGtI3rkAIhQ2A5p2q3fTmw8LIBiH0BNKIeoeNanGIp4HGqQn8dYvypgyLD06NwHsAem2ok+SV8AtKKigI5fWdptLQBM0NVTvUMBsC49QE2b7HgfajJqmUmzaU888JQV+F9wGrJo2F3y41SIW/2IrPVJ+ufwewOnhba8A3ReVDW+QQMK3TQS2eE9oXnIm9JF/78IQ/DdJ44J31wYG3L5Lid0vNvFp8z7aPvJ+XDX6ljdVvP2yxRmWCakjSdRtY77/lxoMLdGxqJfBd7IZSeWHDWG+KdAs0pHJERCnJsJsy7MRY7bZLWx4OuP/sSQpdsr8/YXlpgJKCUmt29vbJsoK80M4fTbit0SwGpXzYGOOA3QU792TJB1+ez2euDHFENpuSD3JK7XYKMKWGCDppByEERpdOhjQuJl/tWmR9kObSCX/BLKcUWO3ej6XX7TJcXmHr1k0ipSjiCKk1VprKbBf8kVTAUeO0eJEKGl93g/JwLYSoXFWq7mKr+c4Lm86XL5AV5yIpfV+j3qdIKpQ3B8dRTDd1QbmFkAgVIaUj6WFFpWtPb+IWoAtVLwYJREhCJ4mIpHK+m6VGa0NRGpJSY6LCRUq4u1DotJpa+O0ufZ/0A8JWPKNBzASE1b11OBEa8FgLaDKwxzCnNEneAeK2SOzeheg1cLC9switQXxAOP8JDPD/uhwbRHRB/9E2ZHjUOgzzmgviwv32QHYO6ywuPqe/IfjrYsNCUbcrkmMOjfUHd5jumAAmceJjb7lAk9PpBK0NSsaUZYZbuq8pioLr167w+//xV/nKH/0+z3z8U7zvQx9F9I9jsoRtLZGrirQrGXZLdvcnRCgmM8vqSsx4XNCNC7auXWb71tusnnqMYyeOMpnNkVFELCzZVBNLRb6/S9oVRN2Bc0OWfmWt7+Sxkty4/gYFhmy0jbBuz0TX0EFTFxrakwMRds8Iy+gN9TZs4aO5Z2XtGOc/ot82yK9Etn7ASccWESLIwp6gNehgKFNlTrZNUkjlPyGb9wv8JBQ+pjuodvXA+RyG7exkQ1vZVDCZyqTW8B+s+nnw46pnZlFd+eGT+o89Wb/C0Dr/h2rSIABcTbDxA4iaMoE4XHvWHjQNUOLggDpMMj6Ymm14h1Vr/FuTveYpWwFF7dDdeLpm6q1yLL7/dmBan76zErd54GEk9rC6LJa7fqbWtftvCYS9MAMAmlDPhvZHeOH0bqVIgBXSxdoUrmwqcjuBJImikyQMeh2OrQ8dEVGWXjfixIkjKCW5ubnH+sqASCkmszlFqUFMgZyy1FiUA32R1D6+3iQs0GBVFQpeKAXGoouMMs/I84xsPqPIC7eVmkiIfXzAoDEwfos114SKsBq09hkzGGGgzLE2RlhNoUsKbYmihE4S0++moHv0kphcADkY7XZr0qWmKFxoFWkN2m9ZF/mQVXjtvSIs6nFaTWMArAuqH/qDbZBEP74L60zGBucKEuILIiQqAiMUk1lOv99D7U+ZzkvivRFx7ELFuAUw1mlbhddgSun8AEtNmc3J8py81EgVoeKUqJM6zWJZMt7fQRvDaLRPknTodFKiyIXg+dBd64WOpxtD5XaAjykpKkHQC1C2xkbrzeuhfd0DB0d88NfFz0P4BThNc+6BOH9VXoH0uYnswGpg/zcQeyzVvSGnYOGq5pmWlcFV4CCy2UN/iQNXxCHnDj7fflq07zmEAFa5NAXYxok2XtZnqkPReLaSfuoxgP8brIG2ai9vFhaiEhLvNN0xAXQbeIOVkm6vR295GZPnjEcjZplx26N5scMYzXxWMp5M+L3f+g987ztf52M/9dM88tRHieU6s6zD7p6imJd0ugVR1KWbRJw4ljKaSfZubiPsDmU5pZfm9PsRw76gKA29jmReCIZDyWxuEZNdShRpr+t35wgTh1tDOxuP2d29RG+4hkGhRCB3gQCGYAeu1V2b+7r6ziz8oKn8Ov2AczDmBpLxHyCs2g2pIn0iAHhNnwTC+eWEAeHJRjUAGh0sxB6r7rVuBTRBOmj0yFCfoBZ2PUfW5fB1guCA7cpmhfEEypFAv5leoFLURKpeGXg3J17Cu0XDp6lB8mrQ8sByyIBuCb2NH+6TBWDzRCsA2wKxat67ULR2CtL2Irls31QftdkeDYiu+lsLuG3rjsPxy78yfLfW6duVqwKbZhvW/evQ1zSl2haKNerV4Kht7WYbpCvNBGECalbQ1uNLhGILuIurgKVSfoWp05QIoeimMUeXe3TTmCiJSaKYI2tLaFvSTV0w4v7SCsNhBy1ihv0eAiixdLt9Cu3iCEaqwCAotdNqKWFQSpKKiDzXJJEiVk5LRenMtBhDqS2TWcHW1h6zDEbjOb1uFxknCOlEw+BL6LRYJUVZUuYu0DE6hzJHUDo/QzRKGGJlUdJgVITQMfvjXW7duMF8c5tiNieblUyznPGsdNvNGUOunQbNNr53pASxcGbZroJhIkiExZaC9bWYM0clpbGU2jCzjgQOUsX6csrRUwNW73+Qo6efosy22L30ffau7bC3P2N3N6PQkum8RJcaa0pKk7FVFKhyQrEFK8sp+7cKRnOH74W2jDNDblw/i5Tb0ziNJP1I0kkcwR90Io4fHXDq9FEGZx6i3z/OeHST7cuvc/PCm7y9MyMvLNMCxjkIqfhLf+t/vGv90M1iIUwQCGsqDd1tsWFx0PlzlXLDNka6beChO3CzViAeTQARojEcRXVNLBy713oBW4jquVZ+wTITZsUKHAKQHVYZWhj07kkcSnoPzaPSKizcXRVBHHKSepJZzM+272v9bN5qqwmoEppqq33zAVML1sKRP6l+AgTwC3/tbyPjhEh26XV7bN26xrNf+UN2r1wly/2elMycr6APP2CMQUrJ9atX+L3f+g985xtf5emPfZJPf+7zdDtdtI3Y3pmhUKz2LLc2Mrpdw3g0ZzKzPPTYx0gGEds7JVE3osgMnUQymwumcxcZvtOTdBgjOhFCxr7LONV+kc9BWMx0G5KYW9de5dTpR6tQMMHBOBCbakWNJ2vK1mTMIry51k+C/jkfAMHt9uG/VugvBrzZuNnb/KQG0DIbBCdPr72zhnpLn3B//ZLmfouNbP3l2rQj/URu/UsDkazLY+r8aZTVkylhIfLhGOp6+oldNMt0d5L1O554KuC+YbV8vm7bdqlqgmy9871b0Nw4H9q9Ih+Nx35YWhAOa5pfS9uLty6Wrk2QwsGC1qxF/g6ah2/L/4IvXiUxhiya2s0GyFevWMyx3bi2+Vzj8FACeKjmz7bwscZM27guKtALRNIYf+yCZBL+d7eSiqLKLyyKYrdqNHHhVXIDs1lJUWaYi5s88PAa01lBmnZ4/fULTGYZWVZWjvpFljGbZ5RljtFusUMioZfC2kBy/uyA4w+cQcZQ3LxCNimYTTJGk4JiWrC/WzCZGa7vlWTaYI0mUm6SjoRkVkJWCCLh3CaEcAvyVnqSODIMezFrw4SVvuTksQ5J5Ihivxtx4sSQM6fWOHH2KPH7PwHDLyGKlylf/lVe+e7rXL6yy9UrYza3BW9dzZnOBXMtmBcGg2GaQ+HN5L3YEknBcldwZKg4sRwxnWtevprx808d4eMfO8Lu3py9vSl5ppFKMBzGHFvvc+bBU3Te/wVY+otQvoJ9Y8rNV1/j0hXB9WsFk7llb0czG7uFOXluEKWhm0QIYZnPLLosONaNOXm0x94o5+Jmwc5MI4COkCzFkqPLMYPUcmwlBSFZO9bj8SeO88DHP0z08F8CcQLyFyhf/B3eeelt3riwxeZ2we6eZXeiMeLu7gVsG/NACDfWtCpBGFPOshMwohKwGvjWUKgv0JOKni2Kj4f/ahGl24CnOORQHP6eA9aXw3M8cNG2oap927sUa9GlqVIULJ5tvqt53jYv18TRVucbLjw07gv/2oNfr43tovpYxphqzYK1bmeuOrjbnaU7JoBPf/YvMN64xs7br3Ljzef4+te+wdUrFzGmAOHDGFiLNTDTM0AQRc68UJYFZVkym11i4+YtvveNr/FTP/N5HvvgM/T7fW5tzEilxqgO03kE8TJazEDFZNOMJJ1C3kGXOeNcsjRMmGaSTqTZ3y5Ij3XYvjxi/dw5Z1iQUOQzNjcu0umn7O/ewlrD0WwHYTVCKpp6sqrrhXALnhyGiUdU0etF6xn3oUwdUkaEwSYA43xc/D2VukIE7aNf2m09jQnSkQ3XIax2dX4Aot1DwKvk/Qpl/3xF/ISbFEMw6qbwdDB0S2P0E5br2yoEg+9uRA2TdFOdfzeT88sRYIWPaejKXwlb4du1iEUg1y6HYP8Og0x49a7jvLYBAsHjDP/pDgzXKjVoOg2adgCwbkdTmmSrNvXWTKt1LpDDJhlfzPx2TDMIDYudwffdA0TSN5yoWeG7V6alCWzfaFu3tfMJvqiLsF3dF4ieMZXvmg6Lgezd7YaDZM58VlJkMJtotIbSGK4D2juMREpw4+Z1Vo6ssTseszroMdm5xnRng2E3Io6gEyt6A0GyYsly5xV8ZEmxvBxz8lSXB86v8NCHP0T68F9HiIzytX/B7tsXeeviFleuaTY24MaWRhvNoKNJShBCUlpBXrqJQElIYouSwq1uBaw1aAtCW6Q1HOkbjqzHLC9BkRu6/QgpDJkpKKzbz1cU4DaP7FLmhuk0Y3d3xvZ2xpWNObszyyQzaGMpfEjAzFiMBm3d7iad2NIp3f7IO7Fxe/FmltJYRvszLl7YZXe3REoYLsWoCFePQiPRWHKsmWKmO0wmc3Z25mxtW3b3CvbHmv2JZndmGM8tWWER+w53c52TKsn6AFbykkleECUSOXeLb+al60dJBMJE7EQFaSxYKhLSRKL6XR8SZx9mG8x3NtneGTMdG6b7Jdt7Obszy8zcXSxEKhDKaXhl01weRlBTgSCb/KSeA8QiVDQVADUBEoQ5ZsEfMORfzUnVAZXvYGUOPiS/RXNy43r9807btUGsDiOZd/CkWDzRbIzbPFVfsQsZNSxli/Omv72VQQP+xMI53/IuxItx7ea+uZvPrHIxg7UVPxkN4Otf+X12r73Fyy++wMWLl5nPR6TSIBRkpSVJJLqE0jqp3VqcA7KyfpGIAUrKIiefjfit/+0S3//aH/KRT/40Jx97hnyek/ZTYixnzvQxRZdeRxBHCcNhRJ6XHIkURsb0uhFaS/r9DuNJhpKSfT1H6AIRu84upWWycZM82yKNNLPZFvsbb5Gfeohef+3g5xQW4UlT6LiioSlzq3FdyAOBaCy4WNQ9eL8WrI+zZyty0ewgbkeSxtLuaq6vB4fw5aqW9fuIzPV1652vHeGEEAxUVObL8IStQgU0SF51S3PSFRX5NaZ031CAUrGPQi6qzniAdNyFZK0Piqu12xfauNWBtuEkUWtHoUna4RAwEaL65vVdtdxctYqtfx3AI9skxovX2ofitr8OJz1VFg2NX1gsVB3XPPE27234y3hy75qqIY9WfbUFowfyblbvwKdvEL4WOW1oMFulajFCX8fq/fX1oEEMQmY9veGB8MAs9hNNf+OTQ67fnLC9VzCewtZYc2NsmWsotaEwFmslZVGSzzN2d/Y4snwcKRXz3GCsCzWSRJppDGkkKLRhkAjSSKLzElOWGK2J7JwoyRFyCTp9JlnB5u6MmzfnbGwV3Nw1bI9KxnPYy5zgh5CU2pl7hf8t3EJepNROKDclqRLEsmB/LFnqR1gdM94rKLVBRRLLnOXhhCNZRqecg51Ats18NGF/knNrI+PyrTmb45K8tGSlI+aFtpQWcu2+krYGq50QvTNxmqhJrlFYSgPXN2aoFzJefGOMLmHQlaytFAjbY9DP2B9N6Mx2UZ1rMLvObG+Xzd0pe3sZo72cjc05+zNLVsI0M0wzQ6FdHOvSur8msWxPLZ2tGXuTkmlhyTKDRtCJXY+a5JpuIskLTRRFaGAyLdi/eZM0fQkVKcSV55jujVBSM+hDUShyrbBWQ373+iA4/z+jDVZoghtQoHwtAatJhirY8WOoIQC61JAAbZiPLGFLORHYo7D1mhGBt3qJ1nvCdmhh3gvh2WqnRKpyV2K6n3er41ZdGiRyIR0QMd9FTq3JVZ3Zu2FZ82/AnMW3igOP/PCJ8YDVouKabSncz9gL5Lp51c13LiSefE/C8B0TwGe//HtcvniR8e4WCkPXGj8/RC5SunGrwKwVPoK8xShF6ZfUSx+mXAi3xY7QOVtX3+CPfu1t7nvwu3z005/liaf7bG2M2L25z/7NDcbjnKUerJ7+CGnSgbCaC0EkJIWwUO4RRTFLnR6jvW2Wjh5BWEsSKZaWV/ne17/KbLRHf2mJ8fabTPc+SL+3Uq++bXyIitD5ASL8twDAa+bc/cZrBcMaXb/6Brefrn+ABk0iRLyvWJddUAS7ng7CEUc/I1Y0xDbe19RGVtotQfXx3V7Bjc4p6hq6+41f2OH9AityYf3/La+/9H32N68jdIYaLnP85DmUhH5/jd7SsivH7QSjn2ByXKABCJ4cBBDCGgcyPn5ZSyPln601r3U2rSEVpDd/rZXBbX43pddGtjRFOudb2vjWi+JD06zbJHyB9ITu0/heB6209hCGughcjfou1L19rtlGTaS07d+3Ib2301aGPtYqMjVRrcekqF4tbAA4gQ4Tkf/mVXiYu5T2RnM2dnO29kpmuWY/g1kJ00I44ocjqiUlWV6ysbXN+TPH6fX67M4scS6IpCZWljS2dCMAQyojej3low4Y5nlBtr9Hmm1gkwhdGkbjjN2tgo2tnFt7JZOp07pp369L4zWjRlR+yWE1rrZu5WAkDRqLRpCVkq1xgcayO8mR1iL3BKsrKd1IMJ1MGe/vMti5hLV/wPjCc1y7eJXJ/oRiniOsIQZKYelIS2md5SC2lo4KUQ/clp0BDfdmAK7MaSR44c0xb1+SaON8BQsDmbZM84ydXc3NWwXnNv4jx0/+KYnUXHhzg7ffnnHtWsGtbc32xEWqyXLLPBcYq1DCzU/GgpQWjGWeWd6+OSc30gsObl/5mRbMtGWUw9a8pLdn6CYFr98q+N7r+xz7kwucWP8jjq7HHF1LUVHM3m7GrVs5N3dKRpOCnZlllL8X49uPIQkLuLBqxhgEftGf2yzbC3RNNUVY/VxnYbC4sFpUWBmQqSJclVAdSEggTk2tXYNcNrV/1CZqd98Pv+YPq4zbcFaTtnr3LKr5LqQfBgdNdKt41w955gD7PEDEqtMLmbdxvV3I2re79Vzd/NUjBq8B9DcZTLU/trH+W+J8Qu803TEBfPOl7yG0Jvb7JLoCuBWk1rhYV9aAVW6lVQBn6Vd0VZsXA7NCMxcw04KO0hSvPc/W1Xf4wXce5dqbr2NtCUKydO4p9MYVvvWHv8vHfuGv8MBjj5PEXco4BuUCcBbjEaI/JOoNWF7r+cYylNmMzZvXmU5mjPemdHtdtjYzBsNVR6CsHzANGSSQrmreornSyFOoinx59WtjeLnVv/W9i/5xovFRa4LRXJDic1tYAQWi3pc3nBWB+7t/XKSIJgDVxDBodwSiMg1jcUQwqKgDicKSZxN++9/9K65fucrqseMsPXCeM7s7vO/0GUxeICNBtz+o338Xk7Si8muUDVOCC/tSBXl0KwNDSzQcQoQnEc2Ci0BIAvGrRmTjE4bBXjlG0wjH455r5dn4tyYyDbYoghDQ6DGCReGPSgiweK0x1Ftm1W+ooNsLL03ptkn+qv4k6l+toh9GEpsVk83fTWDzvxtEr2UCboHdIc9VxT4MvEQ9SWHd8xassViMu/aePF9+tPTmlSlXNwtGmSHTMM0s4xJyLcFqXxdDqQVZqRmNZyipOHtqjR+8YJkVllhatNZkhSWLYBDDZF7y6jsTTh+JeeBsl9W+QuV7bHz9n7KxM+baW7e49M6Mi1dm3NzO2ZvBNHfEpfB7gkbKYqwkipy/b6QMsRSURjDXbqHoIHauOWERy619w8Y4p6Ms3VgwTCXCWHop7G4JrkW36KYvYXieSxdvceHSiOuX50ynzpfR4EzKUklia/1qX0eypPBdSiicZtKSa6epjAVEaLSNKK2gl0iSSJIoF0jaaJhmsLtTEl3cZRCDHMQo6SMB4PYG76eQF849QBmLyQ0GFeJEo3y74PcMHwhX79K4UF4usIWLMZhGkl6q6CWSXqIYpIqlfsL6eo+zp5c4fm6dbJSxP96i1xN0525/5gKDEXd3KxAJ9Y5Isj4HbkFm023ELo7JAN4BS2Xz6UYSbSyphdEGviyYdCtSd+B87TbUOh+OG3/DXOgOG0DW5E9Nn2bR5la3m5ea+Ffh54LJ+ZAHGi9/9xmvOXc0SfVh+Fq1rbXV92vKyQRNaJWMXykfyh0slo3vbH9CBFCURcWPAEorKAuLVa441oYdIT1Y+5FfLTpwFmof8d1Na4Vx+UxLw7Qckb3yA2xZIpIOnaUj7O9u89ij7+fC6y/w2//wf+bM2Ue4/wMfZ/nkQxw/tspgqUNkS5JOCjjNnfQdP01ShDVsbWyTTeDoEUVv2CXP5gyGjn4J38hCBO1Da1z4Sdq0P7sVCKvJxmPn1zIceokrrMlq6k7qz2dDjwtcT7QHpPXkrv7ktShQaxrdYAjxCCGEhQmcwq8IsxUPqv4JMmHFD3xhqneFASFwYRDmGUVRMs9zlpTASnf+1ngDIQ2dzlmUSN+TuvnHkQRB41OH0rEWrA7yjz+7WK6WligMSl97Uefj2rsGHuHJWosWHVrntmR3wLJym1sPPb/g91YRnmAGXRjw2PrxQ9/XKH8LaJukNtQzvLtJEAMZpm65QOqafX2xWuLQs7SIdWj7+p2Bw9qDz1of/sNqJ/EaJwUb63fOuEvpq29m5CWUWpCbepcO119c5UIcSlNo8rwkiiMevf84317y9kYl0aVhf5oxyzRFCVkh0bogVfDa63sIaRkMYmaznMsX99i4OWcyKSi1Iz7dxJDGgiS2zErQRpCXzt+vowSxquOMlkbQtQKQpLEjQi5osvtGkXSaQuV3CymFw2cVR3R6PQarRzBCk9wcU+gRhXUmXuO3gAvbCrnNgiRKuGMhndZCSrdns0WQFS74vpIWbaDXSRmmMEhhue/MqSpSrK1ELK3HHFnvsbaScN+JVaSU3NrOiDuK5eWUONLM5wW7+67cc1MyLVyQaCMESlkS6WKFIlxosFQ5rJ17/0QlJLGCOJL0Esmgo+inEcO+ZG0l4cSJHqdPDzl77gjdlT63RjPiNKLbM/Qmhnku6Brtt2a7e0lUcWCCEB9Go22Ny0pF0RwitsaEEGqoKRS2yJE8SOYI1+rSNE6L6nelrGjijWhgaxgzNO6tilHPbdWFmnfSPKIqdZsIHmizA3fXrlb1JHj4c5Z2GzWIQkX4KgWprefyetppzhGNFy0KvTXZqMrUdE0LMSytbd5c2SKx9s6F4TuPXR6IP27QlKX1/lfhWr1YwAqvGRQCpaT32WqsTqkmLD95I9m3UMwsTzz4CBevbXP5wg0Qiqs3Rzz+wU+Tv/EHXHjz+1x76wU+9NGPsn//x3nksQf40FPn2S9L9gtFYXxHlwJhYWV1lSSS9FeH9HoKKfbRxQRlazNqmKIkUGQZcep2IwnL0IUvtXVcEGsMb37rm7z8O/8ZYQzPfOlL3PdTH0dGbnVdZfLF1h/Neq2eaCwGqbQ/te9V+FN91qo/hkk5dMO6s1WDrrUThn9qUS1uw2APckOD0Vd/BUU2oygLjPBBqWOYTveZpDF7m9dQSPpLA1aXTjRiTt2lZDz5MwajfXv4Scdi3cRGAJNm/etBe0DeC4S4Gtw1kFR7aVZX2maPZv6HEcNFctN45QIRDO+sT1a+c4Hw1dJCKDSVxrjRd1rmU1+RSuvZEDhqX5v2opm2n2Sz3erXv9tXXyynPXBcX2+bwNsZV8811KLVJFT5Ar4b0/7JJCkkkbIu8LNxxMtaRzJUJEikM7NaY5CmcKQuiYnSIaMyQuvShR6xhm4EaRTTS6GTKFYGirW1hCPH+hw/eYz1k/chKMnNFVQ8Ikrn5HrOXOckiSWNBRujEj2zlCUoBbGETiRJYsi9X16sBKUVGCuI/UpfKwRJLImUc9nRWqCQ9DqSOJIYKxw51W53DFPm5FlOJEEJSRIrkshpMwth0AEjw94fsh6HUrgFKdZaosg4Tb6PqqAUpIlAKJjnpXtWa0YT6C8pjDUkaUQUSWbTGdNphoBKu1hoQ166UDglLk5jHAky44L3u+3RXJ/RxqCVC/qMEC4smHCLdmLl9mdPIoEL3yVJlKLbUaSpIlKScjxnPC6ZZ5osL8mLgnnuFp5MirtrAhbeBGhK4yxiOPcq6YloCA+IoFqo2BKCRQOzrA+u3hiPFZ8UDX/vJvg1SdoCqXPngjbQx+kM9wTLSaUVbFwTVFarYBmriKyoSl7/DRhpF67U03sLZg8Imy3y2dC3NcmVaORcT5NNZtdoLP+ziW3N+1qH4Xp9XhwodF2RevV2UFII73ZX8wAEP5mdQCygcRKf1mCNwIciBe9/ED6WiJSPtg653yvTfWjp2altLUqolrNHXS7fGrOzN/Y1kpRZRlZoOmc+Tn7hT1hbNXSWNEuDDh/70IN004SBKTlqcm6OFXu5oMhLMqs4sr7GqZNHsWYLJQzD5eMsD5YwOkOpuuqi2nfThr02Wp1HCOFtrJrXv/IVfv9//RckRtOJYr79a/8bH4skZz/xUe90vSifhEmvQVbwmpxARvxHrZ+TjUnO+MsOvIwxKKlI4tj7ToWNel1PkNU7azKKf74uW60JrL9ucLAXzKYTtC4A79RdGhIVk82m6GzKlXde5vixk4il43fafX58ya8AdkKQWwQvpap2SKiIXFNSo9b+vfvQEHW7NAGiwXwaTXhAoxjGdBMjD4LAbaoFrT5QrQ63zd+Lx43rC8/XZaokhLoMLfCq7w5AHOJgLlzhQO6VmrldwUPLWgF1/ds2//osWllWhV0oaasgXvP7HsweP2o6OTBMCkVpnN6+0JZpCUpa4lgQS0ilxBhLmU8QrDLLZlgZU1qB9tpKo0t6kfVmW0cgtXaTyTwruLm5y/HtLkePLtHvxsSx6+Fau+bU1jCd20ozXBrnFoGETuIEQCUkShg0IDQk0ltqrPMFNgDCYXpelGhc2Ji80GTzkvlckWc5psixVlMazWymyYoSMETSVoHrwwAQQlYL19x2mK73REIxN9Zpbq3TzEmUC79lPYGNnMIgjtwK4vncMpuWzrybxNhpRpYZstwwnxsmU81kDvOGz6NQoI0LFJ/GEiWF37LP9R1rBFpVYiKREkSRI71KCEcCY0mSuA0LpLREyplat3dG3NqcsLuXM5loZrlgXroVz5m5uxpAP9uDFNWe0dKTqjCuQnDgiiXYWuwPhMJaU8XwrRduNF4RiJoQddD1ljm3xshKQPN/KyittIWLkrBtEE2LtcLrLw6Zw1gkhXVubmfAoCFrlKeJwY0nDvA3HybHNO9qMk7RnBuaWCoaZaeZ6+KXWkhNHKwXZYZduWpSV5fUUBN8QdjwoS6jWPgWd5LumAC6jchrgKrf2pYaAMLWabbhLxW2OHJVCtQoVNAdZ1lGnu34CO8RK2tH+Nznf44z9z/Ka+9sc/nmszz4UI9p52k+/+GH6Xe7VdN0YzirLBev3MSkq3x3vsyt7z3HMJUUegVd7KGzfS69+RxnHvwwg+FaTQp8uaI4cgS16pA0mL3lyttv8Ie/+iuUxQyEpCwMZrTP61/7Giefeh9Rb0AI8VItNgjfo2oiEfpTlYRoqoqFp8TeoVNrvvrdr7M93kUkCpFE9JKUo8tHuP/kGZZ7SyipnD+Ul3bdZ1lYYCBw+3pCFUqjoge+ntYa5tmc3a1brPc7pKYPAnp5zro1dA0kK6ts3rrGxo3LHDt+jjju3GkX+rGkQ+f5SiXuCaBs3HgAb3zLHOr30YCVJgiFvtB8IADj4ksah7VDwMIbDqvEAqlra/0aJuBAgCriZA9woiBNt35Xnc7S6oAVXizUZLF9Wtk1x++7EK8WOz30hgP3NrwbqvdWwOrbIPicGWO9E/t783v5UVNhZMvHSgkXsLkW5hwZsUIxy3LWpOTGtS2iKPUTlMFovN+t9K4wEBeGOJbMC0NeQJ4bprMMIaHbjZ1mCkMUO4I0LxsCnzcJlUCCoDAGa7wp2reVtcKtUPY+IsIKytK4LekMZIUL9DLNLL0sRkqnLbTWUhYFQlqKvKTIDba0FIVBWxfGpfD9NCz2q/ZHsrgdKyQUxjiiWYZv5UJllcYyy5yG0C1kgFJDWVrKwpIXBmMEeW7YG82ZTDTZ1BHGQkNRSDAaJSCVglIYIiWJIkOknIk+IgTnEsS44PcanHbKk/JSGxIZUWrLvDDIWcneXoGQgl5vRq8z5tr1PTZ3Z+zt52ztaLZGhnEOmTbkxXuYeX8sqZ4x6lMerPyYseBWwnhGYQMxxPmMV79FM8vmuAxzuZ+/TWMXKz951HOZqDGx0v4Ft4iDmr5KA1iRUw5A6YGyNSfTBmkKGNmcuusiigVyFKxEjRf5l7T2G1+0oB04aNBIS1U398pD6a4vc03GK7ebygpT16POs/G2hiAdnGTCfy5vwXuwAL8HAqgFWouqvq2K2dp/repktioyYvGcgHbTuju11Qjjmb60HD12gus393jj7f+CjtZZW05IVh/iyfc/wAPnTxJFseeiEVYXRJHh/OnjXN2asPHGGxTzKYkoiZKSyXTOdGLY375Gcd8Y+iuNhhVVI3r8atUtdJbnvvplrt28zjCKKTEoJUiTiNH2LWa726x2JHa+RyIMOzs7DNeOQ2+N0jQ0KDbY8muJoe60AoSpzHFZPuFb3/8233zpB0yyGUpKVleXGa6vcmu0yYVbF3hg/STnhyvM9vexxnDs1ElAkmUF1hRYq5llmvFkxmg0YW93B2yJwIV6yOcGFXeI44giz8hnI7Y3bvKxDz6KLg2TaU4cKY5RMB1PmWT7UOZsXrrKhfh5VtbWgU/daTf6kZOfX6tPZMGHGPKDQ1gwoiWjtIHFg49dFFtoDOAGkoQ+DDVIhdO3SU1APNQH7kClmlTK1qOZg38bkEMAC39UY5FD/QOg5MrmenPbX4fWufZxfe4AIi2Uv3GiTUoXTNmtejWftYsyfygjLTJcEWAbfEGtXw13d9I017gVBm7P2dLitUuiFsKkRRlLNp0DlqvXN3n04dN0E0GeGTJtnanSQOJNYqVfTFfkmqIoKfKS/f0xRbnKcNih21N0Ok4zJWyBKZ0W0Bj3bO7XIGTCUJSuJSPlmrgwkGvjzLwSrNBub10Jaub2580yA9YwngtGOcyMZXtSsje2bGxrsPDWhV1ubORs7+bsjDWjTDPLDEUYT96p3QCxcKuNwZlcpSiwFr9i0SUrLL1Io6QgkZZuJIgjwaATk88dUc4mlr3NW7z8/Da5FszmlqJMkMKyOuhybM1FhihLTT7LKLISjGuXTup8+6x1GsOtUUlROi1kppx5u7QWPTfkgFGS8cgtrhDCcvGK08x2vnOVXkcgrEIb6f0+JePcsDUtfRvfPSHENZ4XiIyuRqeLCesJQlOx0MCUMHyVUvXczCLhCTjYIHAV4RMVyLUsXuHe6ri60D7fIoJNQVS0/oY6HsING5N181y4y9Y/qQldJSQeIvw3yyersFI1ifORb6rnFx5eKEbDutHAdtEoUyigK209v7S4QVAiNT5LRQKtxVgXcN2FRnPbvBr/vztN74kABr84QqHDRyTIGsJ/MAULhagCPPil6+Fs67Nai5AuZpTR8PYbL3L54hvEcUzSXebUKVDd43zko48TpwOnxZEumEmpS4SKiCIw02vMXvwTLr/zKkdPrtGPDEeXTpBEEUtph06ZkW9doihKOr0es1lBr98BETEtNf1ez+mUhaIoCuazGQAX3nyN3JSUJsJIi8QSlzM2dq7yx//8H/LEBx7jgfed4+b2LV58+S2eePIDPP6Bp4gHa2RGMZ1nXL12C+03VtdaMxlP6PW6HDl2nG63iy5Kcl1y5doV/uQbX+HGdI9cCnRRoDoddrZ3KTAsrS5jbMmzr3+P3//K94mAk0fXOHf/GWQckc1z8rzg6tXrHD9+hE4nBV1y89Y2/aUlhv0Os9Jwa2OD/b0pQiWUAna3d8mKgk4Ss7Z2lPFkj+XhkFkh6aSCzc1bHFkfYLMR3//Gf+H+hx6+487240iu77uV50b4nU0QaGO8RGXbAzx0sQVptRp04c5AMg5I1Q1y1iIrd17mCksOPL4gYQYzDPXfGsTax+376zo1pdODONUmf20zTn2uKnMFyO81NQG4dXDATFIVpYKCGhOqLRn9aVc0icBteSUtWCGr2Jx3K/WSCATMS0tugh+ZIA/ltYYIQTcWxGbKbJ6xu79Pv5+yNhzSEyWdRJHEHtytYZbnYCzjuWW2mXNtv+TlKzP6L445+eyIPCu5fHXKja2MvYlhNDNMC+eeYTzBK3zsv+C26vqy9v0imMfAhKgA9RxPiCsqA56Lko6Yk0qLkjskhJWzLnyLti7aV/0ljV+EB/icpN/pyIrGtnlQBcjHt5mMLYm0iEgQWQEosqJkMgMhBfPMIHbc95VRhJDOl7E0kMaK9Thinmsmc0uRFRS5xlqHrx0jiZV3R8ots9I687Bw7VBop8W0xvU77ReXOecSd04KSZxLoqkljTRKGjqRW/LYw6Bi5/N4d9cAh+TNsjIMn4a1oKElCjNwBXdCuC0A8fBYubo0mE4lb/lgww1S5DNplmKBxNXXW7tWVSSHCnea/oHh/lCwps9eE5kOmFsbmk13JURMWMQvUd0b6lCRqkbdA+4038/CMwsFaxal+at9tDCHtIl323u7uSWmaJRFIFq+7tb68G9C+IVYP4FA0AejMwgqx3uCBk1ghWwQ8ybQh5nX3eP3cTrIcIXAbXhuMWWOTCK3PF/vcvJoxGhnk1dfeo0nnnyS5dU1hLANvwf3jtNnTvHomqDYX6b7+Gfp6jHjS19DZLt0Vs6wvz/l5vWrvPbyCzz4wIMMl5eQWH7w/Eucu/9Bzj/wIEmnQ5p2iJUiNQUSw9MffJwLr73CZjFm0O2zNxmxBSzNU/JyznRrg1tXr9A7fQKNYOPmJdSzE06cOU3c6/PyS2/x5ts3OXX/wywNegglGW/eIpNQbN/g9JlTXHrnAm9fu8affOcH7O7tsfLwWQq/6XmSeu2CsczzDGsNaSdGnl5n9uYlXnr1Fi+9/gZlWTKfl5Rl4U3DYK2T+MtSc/TESWaTMcNhn2c+9AwPPvkRzj/8KFk+4yv/+x/RXx7y5T/6Q86cO8P29hZqBa5evcTysIu1c6ZTOHpsnYFNue/+h+64s/14kvf/C5ux+gEogwo/TGYNCdTNsQ0obC3RPSBb+nsqcc+D2eEmhnezPDbf3+J6gcgd+r76uEkI6yDIC8SvKW22a+AtDKJxxk3NNbA1JeYWpHngdAh62NBvZ+obYpHktghcmIZsq0Hqx4KvGIhFsKkF5lYeliAQNG66C+nKHrgoIwqLE0KUcAsPUmWJlWUpsTx4rEe/F3G5yNne22cy2uORc8usD/t0eh1Qksk4Z3tnytVb++zsZkyyktm4JNearBTsTnNG8/1KhrHV/9xEqirTlV8hjfejIpiHvCmOGsOD+VqElaCVzYl6QVFYNWstXSxH/CKVMyc6vHMz59peiRCO9ATiYw3Vwg4pdNU2sXAuRDLEIxXOl2m1pxDWIIV1fnfK0o0lKoKsKNnOCnbHgI8WIYTTdmgjMNZSWEEaCd5/f4+N7TnXd00VhNr4gFlKulXRqZRVN40j6EaSeaGZFU5fIr0pzoiwupxqAEcKugYK5erYSyRSQyxcDMc4Uq7O78H5/seRAnGXQlZuRGEutNb5X9Ykyq2UN8YcME+6cWQ8CT7wlsAQG6TOn/OkyfGUZvyLBpaIsBjRkzwbfP48axAhjl/9WDsH/8uG6d1WxWoNef/bUt9jD83v3Rq0PrQLf6mr0CiLf2zh950ne+BI2ID/NU6LVj0EdSg60W4DX4X3Igzf+SrgQ1IgI9WmagJsWHFVzZDNBxYL1iZ/odpSRlhjiBPFqSNrnDp+hPHuLkv9CRf29/id3/htfu8//icef/ojfPqzn+b0qfVqUYfRGqUizj3yALPxiCLbpOyssWtTdLmPjWFjd4svf/Vr6GzK9ijn/AMPsrIyZO3YSVbWjrN+5kFU2E7Fuk3MhRQ89tRHOPvc87z+2uvs5jMsbl/QXFvmc0Ou5my8cZHtd67xsS/8DH05Io1Ktq9d5OLVG0ymJR/5qS8xPHqUNOnw5oW3Of/AIzz5xEO88IMX+Zmf+3m+//wLbP3p19m8+QdoY8jGE7RxIQ52x2M6wx62KOgbg0kTTBpz7vRptIHvfuc5jAUlFWkEaRwjRMRkOsHaiE6akJclt25t89//93+Hj3/iaUajgg88/QyIkul4xrNf/iqjnR3+wT/4v3LyxDH29ib8u3/3K7z22pu87/HHeeShJ/n4pz7Ms889x+kza3T7yz9KF3rvyQYThOs/iDbJqe+rIUkIEEq2SFb1/AHiEEjIYoYNs2nzbGM1+R0nf3vzqZootSlZFUi/MdHXZWt4Gf6QIrQXJ4nW38WiHfpL1AeLJNi/oLpvUYtab69XLwhoPd8ktp64NjOvJhELNux4aZwPk/HE2NxFE/CkMKgSb9Z0iz+QbocaXQri0hIjuLY9ZZB1eW3/OkVpKfZuMBnv85Z1Dm/GWLJcM5/m5FlGmXuTpHE+e9LASgT9niNPwjqy5UDeECvBctcRls2JJdO1RhEspVHoxqQYluoFE5Xzb3X3unbGb/8Y/Brdgoiugn4Mg47k6DBid6/k5p7rm2EPdAnoqgu4yd0F73b/aevj8QXtgACMZhCHcDIQxZIkEuSldlvIaUtB6B6SCJyvoXVBrQ1OUzeZGcoCisJQWEeAjbAuALYJJNUQS+mIpoB5npMVfs8CISjD4r/wPuEWfUgh6ChFFEEkBGks6aeKDgZlDanysQ4b+HC3kvUuB9roKvRXpdHyMTIr9g8oJZFS1P7fXsNU0cEgZSymprm3YQ4OFgVZjf0ai5r+dvVv0RzWIfP63wWzct2ezeeaD7cZYGO98KH3tGlvXTfxrr8Xnml95Preppm65X50CFNtCuLtsi0K4h7z/OkwNrFhDNf+4kEQNjZE+rizdOcEsDFpVfUTwi8sCH5t7mq9p2d40ITe6c6EWgQPkaACtt5hV8Usrz7AQx/8FO/7wAdYX0q5+NpzaPVdxDhhOp4yn8/5F//i3/Krv/af+dzPfpIvfvHTPPLwOVQUEQnL0WPrvCYh2r7AaxsvcfnKOywv99ifvsLLz7/NeLxPpCKU2uDWjWt8/gtf4rlvP8vlt94i7fU598hjBHkba7HGOUw/8sQHuPDWBXSRI4RgmuckUpJ3UvZKTc+UrKQd3n7h+3zi81+km06Zj7e479xDHD39KFFnyMqRdVSUIM15jq0vkcQJnU6HtNPng08/wz/6Z/8M4gI1LchHI2SvR5IklXRfZhl6MqNr4QP9I/QjyTvRddZXV/n4Jz7G+fP38Tv/6T8zm2VYJCePHwUZUWrD7t6En/nQR/gbf/Ovs7u7zfq6ZNDrsLczYnlpwFMfeIJr1zb4+Z//cxw9ts7Xvvo1Xn/9TWazGZcuX+bEiRPs7s75wbPf4szDD/PsxTf4v/zN/+7Oe9yPmEJHt8Zi0G5fRL8S0fXJOl4SNAiWDFrBBSAKTjO3SRUwNUU0PMjYA3fertTvmv8BEnjYU4dm0fQlXZyADkriB44DMLuTTY53+LsWyn27VOuf6pudYqkGEQEVu22vTq9zDoQ4aEAD8BmcP0+ISX83VwADqKJwqObAC4ulQLgoCcKtAjZzy95IceTR93Hi3AkePtnj7ee/yebY8PblTVTop9KQCIilJRLSk9vat1MJgZDW6xrrUPNYt/uSLtz7FIJYOG2WBjAu6LupENuFRKnNlAJ8cO2mcGH8t1E4YiuEpfBdSQnD9d2CuQ8Ja2xofx8hwgalfGOhgX+VpCbMUrq8jbZkUhIrJxgspdBLBRPrCKHGjfOgPTTCf3+L//aaEsm1zRllaZzmL+yT6rWakZAkUrDUkfQTiVQCrGV7QjWZaVvXIUQ1c+vIrPc31lgjscot7okiBVojratLJ1UkkVj0evqJp8rMa2zwh8CImtgFpAr3ae18G6WLx1OziWZqkq4Gu2kZWK31AYldhZt9Kph6m2SUBdwVwhHR2/nbtU3LdRkOpIPc6oBgvYhbi3VsvPQAEeQ2v6uSigNnGtjWfE+dAvk7FE/9MxUBrszudYVMWNBDgwQiWovS3ku6cxOwb1Y3OGqTr2wwb01jF4WqWuGJsPo1nHN+gjVzlkilSOIeSbIOssubL77EjSvbHD35MCfOfJRr6hm29KsYfRGhdpjMNxlNN/iVX/kN/vRPv85f+qU/x1/8pS+w1E/oDYcM+imzaUa2cZm337iAjCIX78/HUVgertEZDPn5L/08v/0ffp3p/j42H/O9b36VU2fOESUJxmj3n9aMpjN+6tOf4cu//7vMiowQvqY0ls3JGEuPURzRG0+R5YzJ3hS9tsqR+86xunyKJBIkVnPu7GmuXdtkPh5xYz7mzPkzLhK9Uti55sb2TXrKMMgyNnbGxJFCJwopJfONPbLrW6ycOMn9jz1KPMvIACG7LK8d5dz5B/jkJ5/mxo1Nnv3eSwgZsbQ0ZHt7l61bG3zoQx/hH/zf/gfWj6xz9epV1teP8c//l3/O5Ysb/D/+n/8jf+fv/h2+/fVvM59lPP/917h1c4PpaIQ1mr2dHW7cvMnlG9uceOiTWDVjvH39vfW4HzW5juc7f71CrTY2OgSw1pG+yj0gjMwGMaxW81tqTV6z6xKu2/b7WwVpjrkwMOvbReuhGpqqf214sj14K0fixjtaPoLVJcvt+U+zZNaXoBmuvIlTi9LnIpY0KV0b2ZoY1apho60qXKj++vajNlm6ejfKvgDCNpRisR3ucpLWTbZWWIQB4VcAG+odKmaF4NTKKstHz/Dk+97P7jvfJkliTh/rsbGxxXSeO3KhBdqvfrWCRtgUMNYtXjCN9jGhP/h+HQnLascRx3EG8xKnQRSufVSI1YozCQayAxDMb+2Ohy+Huy+KJOsdwSP3pQxTyfVRSVEapA+tYoygbOQhhY+xh0VISJTg+FByY+z8AfsdwdGhi1ow05ZEOZ/KtYHi8UeXSLsRL7+8w+7Y+TnuZ2C0q4OxYKWPG6gky10oStBSMDeKfkcw0W6cSyGJJfRiyZElxcP39XjfB88wPH2ay99/hedfvslk7rSfsTCMZyXX9w2zwtKLXbDqUeHNyUIjbIkSgm5s2Z5mLMWw0pGITsTKsuLMmSGnnnzsJ9zz2qnJPw4fCf5jelIRNOmm1N6HrAGIYTSZ4FJiGhhEg5g0CFsQINscjjqosq33/oUKeSwG61XZQteCuQvlRSPfmjQeBnL2tj/aJ2qMb+CJbZTb32Bb1xcZXAMzF0iZWLRfH0gNXPWhbhbL2Z4hbLWG78DUcYBdNic09/sQ3nnbdMcEMDjbN/eYDe90kp4AIcEKpJI+Yn/daUI/CFKz9K+3GKSM6XWX+eQnf4GHHv0I3d5RRuMZ4/GYOEnpDvpEkWKapZAc5eJbp7j26teJ1H3My0sYa7hy9Rr/6J/8S7761W/zt//2/5Fnnn6U5WMnyC5c5OnHHuLVC1e4ubnHyuoyqytraFPyhc9/ng9+8qeZTvYZ7e0iTcn+zg57W1vM5xPsfMJbr7/Kd7/5LVbXVvnwRz7B0uoaD7///Xz/G1/n/NoqpS25srPP3Fou7OyxMZ5x3yBhZdjl5a/8F+7/yE8xKwSff+I4x0+s8dpLrzCZZozHGf/sn/5jHjx3mr/1d/8OsXcqNkaT5zlFbsiMoMxyxHSGsJpyNCPf2IZ5xq285FZvwMpwSJSkfOozn+Xmxi2+8Y1vM51PmGsQUUKadEk7Q3K9SS9NeeaDHybLCv7zb/8uSZKyvn6c1197k/tOnqbX6wCCSCqee/ZZ/uk/+Rf89b/+VwHopB0eefBR3vfkk/zqv/lVnv7kZ7ny2pvcvP7Oe+huP4YUwMSb5SXN2FdNokMtHdPorw3QOswlgcNOLxZhoSzhbGvAsvAjlC2ATYMINYmNbVxvryZrP9fiUy3qdbDwh2n/Fh2va/NLqyWambSkc3HIuepWmnVtljvUxdU4YFmIz1ZBWqW+tX7bu8ZOBu05y7ffu5HgH3/Sxk9mgaM2fBclTnIX1hKvn8GqiMlol8uXLmGtoGPhweNDru7sYXVJXuDNd34W90vcu9KipSUra3OnFP4fK4iF85k7shTxuZ86hpWWbz67ydVtzWhuHTlDEEuHw6PC7QZiNZTBTEho0iCcSyLhtHOJhOUETi9JPvXEGr/0Nz7L4OgaX/8Pv8MffOUm2zp3iy6MILcQ+THViWCYOO1jEkmGCTx6MqG34cKpPHwi4cmHu8zmhpu7Fm0F60c6PPPUSZ78hb+CSjs8/+u/zBuv3eDy1Slv39RMpgZrNdq46vdjyfpQcXItYmdfs5tBMjd0pWSvdKtbpRR0YsmRpYT3PbLGxz92htOf+auwdD8PHf9XrK5+j2vX97Glpszm7OxotM3ZzTRLMWxPc3ZKQe63rrM4304wxMIySBUryzFnTvd5//vXeeypR0if/qt3rxOCG7/SEydRLxRo+92JlqIvKGC0MQjPMmzIq8rXPSOl86Os3tUCh0aMv9CbWlaEw7SBzXOihUuA276zGk++wKEajXzrB9oHBwLl/7DmE6L13wEm29iStZ1nu1CLWHk4CodrC2X0fyuSa33L2poE15yvNr0HN4VqO1rp3S6odyG6k3THBPCxc/dz7epVJmVR2ZkXY6kZ2XTwcAUEQxRFGGtdDMGqIYyfuBO60Rqf+9xf40PPfJ6i0ExnGltqjElYWTrGyZMnGA56CKkojGH/fffzzvse4rtf+xXeeeM6RTkH4yLZP//iK/xP//f/Fz//hU/z6Q8/TJm/SSeO+OyHn+AHVy7RV2t89FM/zRtvvcl8fx8z3WPn1gYf+/jH+M5X/pQjnR7JfMS3v/UNTp8/zQvPP8srP3iW+8+c5tiXvogoc4oso6dijsWK1UHEej/hxmjGzdEMtGYv06z3JMl0n53XX+Xhc2dYW11hNptTFCUvv/wmV65ts783YWl5jdFoxPbWJs9//0VeevkVJlsTZnOYRAkCi96boDZHDJKUIukxzjVZWXLp6mWGK8v8d3/37/Kpn/ksxhq+/OUvc3Nnm93nf4CQik6/T2lKVpYG7GnD955/iedffh6lZzzy2KP821/9Tb7//ef5pV88A0jyfM6bb7/FCy++wCOP3E9e5ERJynC4yuPve4oz5x8gTgp23v4B+e4mSXmX7R6BKBlnQhLeTycAixskzuFbVucOwsFBgTFQqdqvos3f7KGYsrhbx2G5i4Ufi0DYekerOLYigdUikEVi2Li3WdFaIFwktQ3i1/q7cG2h8LVZ11a4VW1JdLBZKoLRqEyrjbENU33DVakCwiD9W1vb5ZqZBvZSF+aQUvxkUikkqYRUGfrK0I99WBC8kAx0YstTT72f6zNFohLn/xZHHD15DCPgQ88MKPZu8cYbc/bHhlHmdpLQxuHqsSWFUvD6pnW+b0gSLImUdFNFN4ZeKvng40v8+f/TL7B89hwn/+W/4lvfvMWFmzNGM2flGMSWaWG5PnZhSqalYK5FFRfQfY3aLylWkm4s6CrDsb7kybN9nn76BGee+ABq6TgnTn2dM8dHjApLMjLszwzjEoI2XkmJDS4ZwmnQ5oUzJRsL00Jzayt3ZcklKpGUwvkPlkZjswlaSuLhMsOjHU4kAkNEGieoKCaKI7qdlKWeYrkXsTYp2ZoZCq1R1jLLjZ8E3Y4o3a4kWumznfcYXr9MMp2xu5+zb3pkiaU0BeNSsR8roiOGVWNJFWxd20IVzkLVSfFb20m0hZuZ5tIMekeW6ZsBb253yd7aZ9V+gyc++1fuWj8MZE/6weOEYX9FulXOlabPm4aDEKzwROIArjVF6IPvazCxBblPVNfbPnyC4P4VxngwCbdIYNNc3PwbsrgtpWIBg2zrz20fqR4NZvSwS1etKKhevlgGUde92SYtTA05NeeQBYJa++vWKeBwNT+E9xEIa+MTBJIY2rbx+07THRPAv/4//C2e/9qXee4bL3JrY4sZBuIIW5buhVJhq4J7ALcAkrP3nwUsb755qVVNsMTRkPc99Vne/4HPMJ2WXLx4gaXVI4BgZ3sTXeZYXbI0XGGwNGS41KdDweOP3M999/09/vgPjvD9b/4aoLHWoLVlNBrzG7/++1z6zpf54umS2coZHjx5is/94n/LybOPUORzljuKtLvGqfU+77z+Cv2lPnMDb27sUK7cx+71y7zw1svEccR9jz3AsZUjLA1TijynyOdoSjYmI8pSoeKIx08eYW9+jRJY6vfYyzImRUmv3+PxRx8hjhW2UFy+fJErN6bcf/+j/KX/5r9FlAXPfe9Fjq0O6PY6PP/yG2SlwVgFsYuJxd4YFXfo9RM6/SHdOGZ5aUAxzzh9/0N87JOfotN1AZm/+MUvorXm4id+it849ut89StfZ2Nrk3I25+zJU7z1yrPc2tnlIx/7GM++8CLXr9/gwQfP881vfo1bt/4Gq2vL/OZv/TaTccZg0Oc3/+PvsHbkGEIInn/ped6+epHz589z9vh9jCfrvPzC83fc2X4cyQZJSOL9SKquVBGjQwxbdVrQYIXjWpgRC2CyOJjs4rhu3BvG9iLhaf3Tup+KbNYm3/rxBtkK720RnQAQjXIeIpVWQOz/BDBpnjj8/oYEHN7mHj4UnGtS6kA17IfZKpStc66DxtYhvZp6BWxDGWCbOdVaU3ugTX7yKfM+eqVxCxhCOJTQ9xSSPlDsz+h0BvQ7KcsnTzOI4Ge/8Cn29ka88sIP+NNv59y4eNU9KWwVyiW3sDkuSCVkKAaxII0subWY0pBGEPUUx9Y6LC8l6HwfU+6TpBHpIGIp60EKt7ZGzGaWUQ67ucT6gNNlaf3iB0sagfBRBpSw9GJNHAk60oVHubo94/mXrrH6p7/H2XPLnD6R8/M/u8rxFwpefjPn2rbm1gRm2vkhaUoKLckskJdsGcG1/TkAXWV5azsneSentJJx4Xwc03jCr31th0d+7wb9tMPasWN8/Kf/HGeHK3SHKywtLTNcXiUZrBGny0RRF6Qzj1tTYsoZZT5Fz8bMZ1OybMZ8nvmNBeYUeca8mPPqmxlKXGA8P4o6MWD9aEFZFkwu3aDDEmcjZ7maTqbMtl9FUqInc6LIfZv9qWFvWjKbO/L8YHSS2A54/Y2C7OUJpvwGv/zZu9oVaeJTkINaxKwtFx4U2CoYehcROQxHG36KxvaTC4wEHwtT4ASMEODYj+MQT+9w/KwdVFrYY6GljTsktTDgANa2k2jgl/CrwxctIQtPNP60rx+8XbSPGzDbauuAaWEv3WDZqpkpgUqFP2G3neb81Bayb0fdb5/umAD+83/9b/jzv/AlPtA9wkt/8IdMdc7F6bzSvljpoFuCi0nUYKPj8YQ4ihBSeqbtPrYkYmXlJB/+2Jd49eXXOH/+IYqyYLS/y3C4hpIR+3s7rC2tUKYD9vdHYC0bt24g0iX6wyWe/siXuPj6N9jfvYzWTqtorcGYkreuZxTdXZZ3rzHN38/+zffRP/UkR48f5cn3f5BydJOvfuWbXLt0ma8+/yKzUtMbDLg12WZwE3Z3d8n2J5x99AGyI0f4je9dZ37pNV55/TKJsdwYz7k+NiRxzP1xF60t68dO8ZHPf47NG5fYuLXFhz7wfuIkxgrBeDIly0q2trboda4wmY4oJvucfeBBOp0uv/brv8O3nnuWndEIlcakkUBs76CLkszC3r5lFsesLC/xwP3n2dze5alPfAKEW4Eo/TY9UknuP3+ev//3/j5f/HN/jt///f/Mc9/+LqPdPT7xyY/y4qtv8cwzT/PlL/8xQkiWVpZIuylZlvPGG29w4YIzV+3sp1hr6fUHWOv2PjVlThqnXLp+nX/wD/4+k1uX30N3+zEk6xYAGO1jv7l4vASgsNZggoRWSaDh4SAmeUJzG+2Vf5H/40Zui1I2BmFzW7ZFYnhghxxf/nYmtsqjGTS01u6FfNuayeY9B16yIL22pUl/ZVHyXpRkW6cakHLYueqaaDR5LQ2HySKgmJukRFXnGhsPmYT8jBEw3YJfDEUtvVvL3SSBngOTW8VuZriVw7GO5GMPCKJE8fblkqtTy/T55zj/+JNYdYJuqpgbya2tKecfeYTB8jI6GvKvf/k3yPOCGGcOzQVoKd3OHNoSSctYW5SMODeURMvLvHN9mw89fZbPfO4ZrBJ855V91CsvsDlb49QHTvDY6gmm2RL/8pd/k+2NPfK8xGnnYGg1RQJWQmShnwoiaYmkoZcohh1YTiXDNGE4iBn2JadWFTsXLhCNQKUxZaEYpDGn1hzedlLDaKYptGRcaDLjgtkXpTMlGxG2KlN0lGTQidEoVoeKYS8mUpAmsHJtA4vhyPoqw+XjDJeGDAbL9IZD0v4aqruCjIYIkYJUCCzGlEgZo2Tkt4RUCCVRMiJSbv/eTClypSjymKLIkFFBnEJkUmSRI1REWYIwmiIvGY9nzHPL1n7Brd05s6xAG1Aychob4fzYIpVSaukovxQgfqSgGu89WevnOjdGpBBUK2A9IbBNrKhC/LBADBsso5k97TBtVbDzIMVB/T6oxrsQVDEDq/Hf0GJV+VZaQOpx3tgytRkWvvLP84unWtgXcHShbRZF2IqHLuBjKOkibrbboomZ70IYHfM9hCwexnrrOSCUuQV0oWQB/z2pDu4nQdCGekGWqdyF7izdcY99+dW3eeWVf0i/k9JT8NAD93Httct0rCLL5y62n/+41giiKEWpmMFwACJCWEGvPyDPCwQWXRqwCiETrt/c5MqF10h7A2bzOUVhMEiUtOxs7rK9tEVWFnS6Xa5du8JkMqO/BqWISWSXhx79DN/48j9CYDimuvxU/whXszG7RnNhL+H+1T6zacHOs3+CXTpDGj9IRsLuzoiyyMjmY25ubBIlCcOjR5CdmNIa0l6XvZtbXL10FZV2mBnD7ju3OHH6AbavvsbefIbVlo4tuDmZcd/xExxdWeb6q69z+sFzrPdTpLWcOX0f1sDu9j7nz59ne2/C7/3+7/Lxj3wIISRrayv81m//Dlc2d3jrnbeIu870G4+n5HnuOoHRZNmMIs+wuuStNy2D1XWMtXzja9/gM5/9DEkSk+UZUiqUlERRxBNPvI/HHnucnZ0dLl18hxvXL/PwE5e4cnmLY8ePcmvzTcqyJI4j3nz5FX7z3/97Nja2sEC/36fX7zGfi2qSnU6ndNKE8WjMPMt54P0fvPPe9mNIAcyMtW4PZyvc9kTeB8KBWg0SFWPxvi/1eQ8qFSrYavDa1tvEAsFoL2ioADSQM2rSBj7vBsA25fVFQlhrs25P9mzjPc1rtW6sqmojCGoD6AIwt4hg05wj2gDnH1rEs5CvbZ9+11Rp74KvS4WnttE2ti6P9xuq4uVb/Opv6yMQ2Gr1290kgKPSC7pYcuMms60MvnnJYoUmy6DUimSyx+7uBldvXmI4XCLb2eGlF1/k+tXLDFeP8P4PfID3PfQcly6+Q2bcggZh3MILZMSstHRiSSQlJ48O0GXG8ZUUHa9y4swpdrf3iPZH7O3uUtoZO8awsh4z2Z9izAqf+eAZInGK1964wsbmvm/XFKXc/tmomE63T7/fZdBN6CeKxMf7G8Q5y0uSpUGHYbdEMOXC9oRbNydcv5Fzc6tgf2aZ5JZpAfNSUBqBtlHlp5TGJVJCFMckceRWoApJpBRCwNNPrHDk2CpWuF1AerNtZFfRXV8iUtIt2osUSkV+aBqwJRqJMMaPdbeaQEiFVTEyiomiFB0ZlC5RWhFpidYRczOlNCWlyQlxaGXlt2nY3ZtzfXPMC69e5sq1TfIymOl8cF1rAYnRJUJCP9V0I0svjbFGkBV31x0m4IExFiFrsmdFHQTZYd4CKagC5C1g3cJgbi0C8b9pYGb7dlEb/ZpmXCGqbSgDiapIoI/A4Kwvtg4V1SQ6FfC4krSiCSxyqgUMsIccW2xd/4A1vs3amYnWHzcPmPoVByxJDaXDIUL4YeVrWooqzG5gYYtHivbc4B6rv09zN5f3goV3TACNtQhtme6PsXHEa29eI9eaKIkZJksY4MSx4+xsb5BlGT/z2Z/iZz79KR559BH2dvd5+ZW3+OZ3vs/jjz3K177zA3ZmkNqM8fYEa2A6GXHz5mWSeEAhLNloH2VLRvs73LzVYzicY/KcrZ0t0sERjqbLGKUYb+2SDk9z6uR9zOd7HCssPzsYsNodYlPJtXxEHJ/n5gOP0Buuo4Rgd3uX1155lbjYpZOknH3gfvj6s5SlpjAlURk2lwYhJfvXN9jo9ZjNJsRFgs4zMtGhkJZIlkgFW5M5719d5ktPP8iMhO+/cZHPHxlw6aWXGC7/Hd55+wr33XeK6XiXvb1ddrZvMZ3NOLG2wqWr13jl9TfZGO2iEoXQJUpbOkur5KMxqQStNaUBLSST6ZSsLHn/6ft5/fV3+JnPfZrpbMp0ZknTlE4a1QPNWpRSHDlyhPX1dbT+IJcuXeLb3/wu+gcT9POvMR5PGS71+Z3//Y944+o18jzDGENR5Ghd0usPXB/QJdZa5jPJbJox3h+ztzO+487240keCIRAKoGSbgN3N2AsYVNvG0ZPY2AHH5gwQCsNoA3ZNghceFdQzYfXN03FokGBmsSscX9N0BrEsXqnJ6wVqNjmQ1WeQbvfXOxQ39IoazgKixJCPVtkj4akvkjdmkSw0TaN4za+ecp2G7O6a+MFILaNC4331OSvrk0rwGrjm1bf2rfh3SaAaeK2IRNS0APwG7SPjSWSks5AcbSnuG+lRJW7fPNbz/GhJ+5nd3eCWo/RCAbDNT7w8c/yf8gMf/Sb/4b9acZ4XqBLS2EspRUoJUkjgbRu+zIbd1k/cYxzvQ7lPGPj+pwj8+sspXB1O+PXvrbNuSMJH3pmjfVTPU6c66EkbI5mbG1P3ApjiVs8JS1CQZwooiQi6vSQiSBKIqTKMUKiZUxuLeN5DmXBbAKTqWE01cxKKKxwO4JY53dby1oCISWxjIiEAT9OpZAIparQH29cGHHx6gxrLVEs6EaSbk9xRhhOC4nbUQpv6tVgCozO/VZ7YZmkCVIRCEdslZJEkcSUCq0UOkooJyOuX3+dUueUZe78TlUKWK5sjPjWi+9w9cYuO7tTtDb14MFtNalU5GVE198imfDGhRtcSRSDbkKvk1De5a1AKh9AKaqIBzKQLVOBGi2IqLhfQwJbYEotFGs843yr/dhtYEdL09Y835DB27bplnSKw4Cg7TtcqGzHhreLRT6I0wv1aeL3gRtaTwVCGIJqh37tgbQpHDew2xgXk7QuZ02CDzbIQrlF9QiiLXrXv2ydlwgtIMQh5nRxSB1vn97TTiAB1KdlyXw6R0hJsrzC408+yfraCt1uh9/+7d9BYHj04bOossROppy7/zx//LXv8fTTT/KJj36Yr33zOY4cf4C9q29RFgVKKfJ5zpULb3LqzBNIA3GSsLs3wmCZZXP6S0tsbF0lm2tEZ40bVy+zkh2lLA1SDRksn8Ymmv7coEqNlCldGdPRMUdUl+5jj7JhIu574H6mow1+/d/9az710acQKLrDFCVcjCchBdPRhNWj66RpgpSCcj6juHmDzd19OmrAaHeX2WQPKQS94YD5bIIpMkecdMn9Z8+wNZrSR/GXv/RFLr3zDr3+kOGwhxDw0osvkmczvvKVP+aJB8+yObOM9raxeeZiVvX65FlJLCIMgtIYIuHiVYHb+9FYwaOPPcYXf+HnOH3mFFHkfDB3dnbB7nD8+HHiOF4YkIIoirn//vs5deoU60eX+dY3n0NYQ1mUXLn0JtevX6vu11ozn8/dVnxJAoAxmqJwZUg7KVeuXb3jzvbjSA3MqDRCVtaSpRCyAkM/G7nbrXNCb2XS5CFeWnbHB8S4+p4mINIefAHnDiMkbfIXSKyXdIUHwOYrhfAEtTbBtE3EjbxbZVx0lw6gdXhqgdSCBFxJnweyu42Dtmg9uaBBaJjRb0OWK1rZfLFtxgYUNegKNxmDqCIT3K20vjp0QYaRLl6estVkkSaKTqJY6ih6Swm9ruDWVPPcy+/w0LmTIGOipEd/OGRp9QQ//YVf4tILf8hokrE/yZnONaNpzmSaYa12ZF4opDIYa3j1retY3IK3SFmWO5IoFhS5Yjo3XNrI6b16hc7VXR8cu2S6P3UmIutiwZVCI5UkxpDlBVblFHbKVAn6HUVkxkR6wu6WptuRKAllrtnbnXFrI2Njv2Q/g7kW5AZmhcVYEXRx/vuVjvRJp8EVInd/pXABmYULdD0rXWiaREIPGHYilk5JxvOc/dllzpx5iE7XheGSusCI3Jk6tWq4ERinHQSQLpyYVM4UXJRuDI0nE7Z3RygJwmrmkz3ysuTizYx//7sXmcyKxrhsbFAgDHjrlhvvBimc/+Hrb12jl0Z84bNP8Vf/8i/S7/fuYi+kIn/O9O1jLFpPwkRYBFLXR4gFDGmmIFB5obYVLQAWcEDQBMNFAbMd8+9dCEnLsiA4YGJtYEtLWK3ur+9rsbFQn1DEhqBvFxA7TBFVmav3NEKMWar+VfM7UZcxCB6ythYFP8hA3Kq5ojFpiNZJCGbrcL42jS+UkyAAu7ifwa9S0Bx/d5bunAAai5TO3wHc8WB5CRUppITNjS2ybE5RFFhjuH7tFm8/9322PvAM6+ceZT7P+eCnPsLbb73NZz72PpJzT/PL/+/v+n0sBd3BMjdvvMbqkTMo3WNpaYXN2VVEFFPmJePdfdLuKlsbbxMPM4zRzGcrdHpLJJGiv3qOG0f2KG7OyHYjxtmEOF1ilOfs3bjKus0Y9AdIqVlfXWWp3+cP/vTraC3o9lOMMVgpUVFEnKbsbtzi+H330ZGCtWNr/MxHHuUPf3CBSEZk8zm6LEm7XabzGbP5jE6k2NqfcWtzh5P3neH8sTVeefFN1IW3iLsdPvrRj2DR2LJkOp2wP9pjnncYT6bsjXLy2QSbZxApdmdTjIGRhd7SEtl0jDAaTB1a5/S5s/zSX/nLnLjvhOtj0pmKJpMJcRwzm8+IoloT2E6SNO3w2c9+DmM0v/4r/5Yo22XbRrxUFBAAwA+o6XTayEdgrCbP53S7Hb72ja/wf/7bf/POe9yPmIIWzFiD0HhUk9Vgt8JQ+ZUEgJGikl4rMwXQZkZNvVbwRXGnKiDQ3uRoay3jopk2lBEaWddva5Akf+8Cm6toUrXPan1f/Y4Qh7N+Z/V80/zcrFcDxw+AeyjfIQB+e+q4UDdxWC388SHkN0xELRIdvqGFytcH52/V1GL4Vmdxr+C7ldLIYSBCIEyJkl5boHA+qQKy0rA5KunkgpVewsWNMbc2tjlx/Cgy7iCimCyf0xkss1cOuHR9g71pwTw3ZFlJ5l1lSmPQ2lBq63ZHiiR5UVKUrsrSWhJPStLImVKv3NhmdGWP0goSJcgKt0BOYP2+sZJUCZLEEs3nJFFBHE8QQLebEisBWpIqSSwtZZYxyw1Hl/uUaUrU03RjTWIgKwxRqdHaopFYbxJXwhIJgVKQRG4HjU6sXCy9TszVzRnFKCPbyRASloCTWFajiHx3n+9852tM9rf5pb96H0uDHkbnyCLCAkU+w1qnHZQSVJI6DaFnOUH2293bYfPWFeZzzeWrV9jemiIxFNmcvb1dJpMZf/DsLuNJ0bIOVH1TOMuXkhHgfcutQSmFsZonHj7L2eMD7ju2xM1rFzAIPv3Fu9cP3Q44FqxG+NXj1TCwjqximjJljYuIxg4e+L7keV3YYcTV118XTUEsZHjIzwPY0sBi/07XBxvhuxrSZP1YG39aQiFBmDEVtthmxQnUriaoNaYdTpCMMRVxCwrKgJuLAmqIbViVT4C1muB/L70SonHZlaRm2L7MIecAeg38ts0ZqamlCG8VICRhxbuos31PWPieAkELBCHEjJCCYjrB5jOe/da36CRd0l4HazQn13pcuvA2f+HP/yLLq8e4eGWD8+fOI5F0O3D18kW23tlH567ieV7Q6a2hdcFo7ybD1bMEu5cxkOczRtaQdvsIGbstlGb7LB89j7EGayIitcb4Bxd5Wyh+O+7yi7LPipWUkeT1yS5H336LM48PiGPI5nM++P6H+ee/8iLaCrq9lKIoiZMEow1xGkOp6I7HPLG2RBTF3Lyyy/HhkNffukxZFCRJRLfbYWdvB2M0Wgt2pnOu3dzkkcmYlX6XN04eZXewxOefeh+RtEwmY55/8QVu3LjBaLRPtyyxOmN3Z5P5fI7VGmOhLHKiOIEoQfW6FPOpI39oDBalIj77cz/P/Q89QKQijNbs7++zPFxifX2Nm7duMRqPwcLy8nLdsZrf02sDf/ZzX+D4UsL3/tP/ytdevu4ApbnXoH92Op2Spqmf6N22SZsbGzz//N1dBXxgtq96vTh4mwcGYXC7hkAjLEIAgvDswqiptFdt4hKAqOmHF4pRbdvWKEPtf+OfqKIN2NZ9zffZ9isXSGZNSN09DX/BQ6pTAadoQEeNze8BLNp+ebX03ZRQb0cWm+BWV6SGtbotai1oLXA0w1VU5A/n+1T7AN49/6sb26NWm0ssSEEExJGkG0uMgEgp+p2INE45s77Cte0dNrb3OH7yBPuTMdeuXuTk6QfoDQaM9idMZjmzvAShiKQLnBxLiUoidFlw4fqIp544z6W3bjDdnmAF9K1lKFwZuqsRaSrQpuTsiQ4m6iGUC4oscZNTpARxErM87LCyPKTTS+ikKZ1uAtZipCRJUjAF0pSYfMbu5ha7+zMefXiN8WjO7vacbFZQZpr9ccbOtGCS+314tdNKxNKRwEQ58tdLI5I0RkjJ+tEVtNkhz3Z5QMyJhEBaywrQE5brV26SmpKlpS6RitHaoMsCIefIMuON7/4xN6+8DcZy8uGneOijP+fImv8+RVlSlCXz6ZQTJx9if+cWFy5d5MSJ43QiRT6ZMhiu8YdfeYXdPV2RkBBvstZE2Xa/lgJbaIRSGGuIIkVeauJE8Y3vvMYsK/jbf++udUM3/g5CnyN21mKqejkCF4QmsGDq9qKJM/6eVigXEQTHQwvhy9CkhzV5qxbo+WSsBa09Ma1N1241rmw83TALB+myYa4RQqBUcBFoiJvWLjZHQ1BuCN2itriEcjRT2GLSGlvhUeMljUbxbS49FlqL9mTwQJzDZi62PWc0wbj6t5pbGsReNOpQCcJ4sm4XrC4/PN05ARRUrNdKQalzUpWQKsG0KDh99DgPnT7Gymd+mluXX+Xm9phJPmP34kVefe1Vlo/cx6n1iLW1FdZWunznT57HaAtKYY3AigiQbG9fJu4eoSgLojghKjRlPmV3b4vB2kkQEq0zJpM9iqwAKzAy49jxB+nmkMead8jYnktO9ZZYSVL2zJiffuox/sn/91/y6usXeOKpD3B21TWqigRl6SUAHPkRkaS7PGTnxi0yYTm3tsKp9XWe6Kc8MOjx/KVrFCplNBqjyxKspdCauSm4tTdjb2/EmbNrnFhf4+wDZ7l+6S1WhgNG4wnPP/dtimxOEifsjXaZTscU8wkPPPAA4/GIzc1NokghpUVFglu3bgISEcdIK7FFyX33P8AzH/0om5sbnD59H3k2R+uS//LdZ/nZz3+O48ePs7e3R7/XbxCLxe/p6h9HMY9/6FNcePMdbnz5/1ONdOElQaAyJYfl87rUnD51iu8//wOee/Z776G7/XhSRU+FAzspXCxAJ6VKBzqiSXREBQLV7iFNHxlYIFS2Bkr/wgBHQT9fAWRDohMh7/8fcf8dbFeS33eCn8w85trnDR48CqhCobztLrZvNpveNEVJFGUpjXYot6PQxoz+2AhNTExsbCg2QqPdGW1opJlVSDOiRFKk6JtkN9neVZdHFaoKKHjgeX/9MZm5f+Rx9wHdQond0KkovHvPPSdPnjwnv/n9+Wwyi2xi5yr9kqTlE7VCDvPfbQaSRV+qBPCAM3eF2DnlhygHqBgrUXDkoph6BVgKAMzGafyeKu1UFglbBZq7vFw56Sxxs9TKjPesbLvoenFclTiL4sAC8ASV53SngPP93A5P17P+uQcrpauzGviShi+oBR79SDBRF0y3fNoNxdJ8yPIOfP3lNxCex8MIwlqDTnePU0s++uwMKxtddrqZqdTifFyVMy1N1QTDXo9DM3XMRo14p4sAUuFMp1PAu9ogM61fEASE9QCpZFYiTaOkwpeSIAwIwwAvUIStFmHgoTwPYVOnVdGaWi0kjS0qDBFBHS0N2ptEtVp4SZ/1/U329mN6Q00/0oxSTZrVIjbWzTKFxfcEKrUcCgPaNYWUHkJ5+IHC9wQN6+ZwEgjasXE1iL0aT33gebbWLpNqjdaaJE0QwmkZV65cYXP5GiZOCRtzmHTAqL/PrY0tOt0uV9+5yNNPPEsQhnjKBR/OTs+wdPgIemWd3a+9wu2gztbqlkuH416zsS33dbN5mgFr0TpBeR4Wi+97BEFIHAtsallZWWMY37930HWSzJ/TYZ4EZGb2dbzJluS2YCu2IC5jCderk3lcgi2/VElhwcVKn7nC7zwjTWPXrgiMxf5CwMsvYUr5MBM0C3m2eu1qJ8eIZ0k9q06DjgCPY0iOwTm5HLMYVTWVnigwpxjz7H5sZQwKfM3WjbIIgR0fz+pWWWPG76HsS7Hm5MdWAngK4bfoX66mu/ftfcStZ0Wns/+sEESpduY1VWcpPMxzDz7D4z/xg3zxD36LhSjma1/5KmkU8d71FWbnlgjTdW7cXGV+foFuJ8Lz6xgBsYCg3kCg6O1vMDmzR5rEGO3sHGF9kp3tm8hODazCakkQtjA6ciHwCPBnaEzOoU0fqWBZWU43LT0bEk63+Mrr55k8vsgRoRmkAzpRQBCG6KyIvMhG0VqDTlIQAuUH3F7bZHt/wOXVbfqjiJGB2IARKgu9NoVklWjYGgzZ6w45EQQMdjb4P/7lv0DV6pxebJEkMau3b7K7t4sf1Pmbv/g3OfvQSZaOLHLo0BG2Njbp9nq8+dZbvPH6a3zr26/iKSc1J8ZNjompaX7hz/8FfOGSrY5GQyyafr/PyvIKr7/yCk8/9zw7O7tEUTT2ssdxnGnx8lxN7uUO/Bo/+DM/zx9/7SVevfx7xAmAAz2nKfQyfyL3kjXqNT71iUf53c/+Dmmavo/X7XuwFdKoKEwaZSqBA0BUkIlSe5UDTKHJy8AvB6Uyh7odI0UlIeGO7wcjhKvksRz/UrItUilUwajSjsz6eKfmj6qgWMHgAipKwnWXcbvjY8FdBXdNzlWRTm2+aNgDv1cA/DtqAPMbyIHMljQZqPgXV/sgimdU+r24JjQO/GS2Ohh7sOPf361Z97EWklSjjUFJSeBJJhsezZoPAjQaKQWxFvRHms3dAbNtn488PsM3X3yZtZU1nn++z+Rki72r19jqDOgMEgZRQqIFSEWr5lMPHQGRSjFZU3hC06wpR/5wyfdD40zko1RiU4v0INWalu/IY6cbcXGlQ2JclQzlufQoDr2kMyVqQ6pdHtWaJ/jZTz3GQycXMQY8XyGExpOSoNVgOLJ8/vU1lndHxfteKkXKZMN+pgEVwmJVwJGFECEU1lpnFvYkdeHcOWpSUBNghKXVajAaDej1NUmakuoUoQWJAKsNyWCEkQIrFGmSYqIRg84eO2s3WV3d4N13LjIz2eSBkw+gTUJiLVYYTJTQ++o3GOzucqOzRk3VMAxK4Q4KbASwxmbCJa4PGa5onTLRbhNHMSh3z3GcMhreZyysEKq8pK7AfbYyowOiQB2qvoDjzeSiq8yOPUAEqyROFDuqp5dEEJCeKq9ZdFMUpK4EDHdQHs1fiKtV60wJahT8CsjTSY1t/zk4UMrkHARAWwVdMXY4OT4VKFaMVbHilBz1rt2qCuIOgmV2npBijDfm7RZaRWu5m9wy1p973O6ZAJYaC4OwCiwY6Uy006Hkox8+x8KJE7z4h9/g+u0V/sbf+lv88r/7d9y49g6dTod+f0jN9ugMely5voNUddI0RvgSk2p8v4FUPlqP6HbWiJIHAYXRfQeAePT2lgnCWUTXx683SXVKoDWg0FrwwAt/mX7/NVi/zOpCiz+YanHh1i6X37tC/M57NNp1tlfWManlSrvB4tGjhKHixtXb5CHe8TALbglDxNQk0eYuw1HMzmBEkvngYXFRYTl7zyaW1pr+KKLb6YLyGfRHvPX2ReIkZntpnr1BhFAS3/eZm53hnfNvkg6H+EENqwWBkBw/fIRnn32af+tJXnn9gkv9ksTONIvl9OElusvLvNXvc/ToEQbdHoeWFrh6+Sppanjt299mYnIKKwVbG0OmJibwA59RNCKJU3w/QMrxxVoIQXtikr/5d/4O3371da5cvZ6ZgnF+R74PQBInSCmYW5ij0xmyur7zvl+4P+1mM8DQWfZdKwRWmqJYhB1zeimlqVJgrAAQ4xN1fP5nk6wgLKXGyZrMP8aUaveSzLl/DuBGfqXKjgq54+A13KKY32tV81f6J+X3UX2OFepXkYzHzTl3218dgArY3vUBHPguDhDPKru8i3RbgmpeuqrcJwqCKSoAP25KqViQy/l34Brf720/Mpk/rvOR0jqhVfOZ910EqsWlF7FIjNWMUkVnO+byhS2kEPRjuPjeVdY2tqg3amysrdAbpERprgGxeEpy+tAkU6024Hxca6FHmqQESuLCO0ArS83AEBAYkqy2cG65ksItrlvdmESDCnwC3yVqNUnMcBQVASLWWrSxSAwra7ucOT5HGLYwogtW4vseE5Nt4tjVzI0SJ/yWaeXc8/c8QS1QBErhSYXBYIXED4JsAXOpbmpS0hBwvOlx8qTkxqWEHpKhSNjeXGN3a5vRcEQy9BCpwagEnWqOnHsa/9Zl9teWCet1kmRELazTIGHz+ltMTdWJkoTuYIhQkjSN0WlKfOUq0ZVrXI1jfCXY6AwrHKPUrlQFDqWUWxswSKkwRiOEJPR9kjhGeh7WCobDEaPRfQ4DRhTzIJ8rTggVpVCV785vqPhjuVNgq2BYlbXkda9tTiArv1WsK67alybPPOH5XtFU7q4x5osnS1KjCuJdCtPZGzWGMTk65ULGweG4O2hVbiUnXd8VMFxDIhd8c4GdA+tFoaWsYPKBVr5zxzKwy56fsKV3kKyoG8dE+Yo1ryTYIo8Tyfpq/lNDMLbduwZQgmcktZrECwN6g5jQk7RrAfVmwNtXb/HZL7zK9cEAzD4/srrKg8dPcenCq/iez/zhB7m9vUq/O0QQIpVHkvbxZQOdGJQK8OuTmM4NBr1thsMBQa3GKBrhBa5GbZIMsexTm5hj2N+hNpimVqshjWE0HCDqpxls3kAlhq3UsN1Jubm8xs7mNtZCd2fbOSlb6HX6jKKYD33kWYb9If1eH7DU6g200YSNGvPHDqOBZDBif20TM4oxSYq1xgW7ZLmk8gE31nmauQhUSbPV5IUPv8Cw18UXmuP1OiGavUHK1PQUw6jPlWtXSeIBJ04usXTkNEYoeoMBf/hHX2B+fpbhYECSxsRRzGgU8cjxk+g4gcGAJIp5952LHD6yxNzcLKtrX6UuDV/47O8zNT1Jd3ud+OM/yLlnniOKIpd7kVLjVTWbCeDRRx7jr/61v8o//sf/L4bDoatwYF3dyDAIXGCCNjx29glUbYjV+VS8v1ux7GcvfmmezqTYnOBWSEmpWMrFzopfWYXEQeU7B33tDtyrcLWIK2rDA+eW+1y/S6nvjjJq+TEFKXNBK1ZWzylaubPP5GTx4GBVEa+i6Sj+qY4fFbAdp642Z2jZxUS1gfLACvc+IBmXHRojgFCuNY7IZSS0Qk5LHxj3b55K3uQ5Aa1FifvnA3hjbQ9jLZ6n8JTnfJjDhBPzDaQ19KOUeKRJlUbh4SlDaiSJ9RgNY3rDBF8pkq0d50udWvqxC/YotNlAP07ddbIo8Xrgo9OE0FNYC0uB5OlTHu/eSFgZgUgh1ZKhsKRJXu1DEPge7Wad3ihxCZQze6HylBtxqwvTrcS9zt1exObqbWrNKaxV9IYR66ubXL+8jBZ5IKDrqCcESFcJJPAU7VqApzIzsDRYnCZSChdRrK0gUBJfQQ1Bry7ZbiiE0ggLw5FBDi1+MImJBsR9ia55oHwsAY2FM5w4dA5pnVm4s7mPUJaZ6SUee+hx+sOIZDjg5W98i9r0IU6cOIrtDwlvXEdP1Yk7hgkhiU1SWEIq2YGBbJZl6U506pJNW5sCFs/zUVIwGo1Q9Rrd/pBolJDc5zyA7tnZwm9bIrLIX+v8nqv5AK112JKbhXMsyXCkJDI5PlYvk+FMhRgXP1UIkrU2y/EoXNqyJEFJlZkqs4NzRigEmGyeZwUMVJYfcrz9A+4pd8OdQhgUd8EbSonRdZVSV3mXtoqfxtsqxdXq0ORrUOaLmAHj3Vu/k2znBL6KhYWEe0DAzRY6N+esWycULim+0wjm6wHjz+4/sd0zAZwMYJRCqCw1P6E1oagFDeLYMEoifu9b3yCxCj9oMOknfOE//ibb3T4PPPQ4l66uYpIYpAc00BaMGZCaCGkCUp2i/JB6fRKsRacD+r09JqcWMAiCehtrQUpFku6jwhq9zjr7G9dot+cIQ4/BsEvNUxyefIATZ5+n1hR0bv4Jo7lt+lt77Pf77h12tjis1cSR5drVGyAEzWadYRwz3O/jhYq4OyBNYk6cfYBRt8eh6TZvvv5eNuQa49jP2JZm5FIby97+Pu1Wg8Z0g4nWMYIgwAJKGowMuHpjhaHvgU0ZxRHr67s8+HCTzfU1bq+vOe2o1bRbLUKlubW2wWSrTaPVcJnuhWRiYoJbt2+xv9dhb38XnaakytLZc3kGAxOzu71DkiR09vep1WponQDCOXpTEonc1PvzP/8X+PKXvsxXvvL1DPAEVhuMttTCEASEjQaHj51ibuGrbG5s3vvb9j3ZbIYZoigF5xLMkvO6UlX+HVVDpVSZA0JB7iomyvHLHhSpq+Zeiu/Zp5KsFQTTjJvLyKd9SdBySboKNoUUWtmTHU4BInfe3dgvJawfBPiS3GIpzDCVyzD2pdLguKbv4GFVTeAdPxeNVAlgfj+FnG1zunonqJtsjEwF+Mx9DAKxQhRlmQSZMKUNU4GmM4xZ3dEgBFMNyULb48KtfYbax8MnTw8hhEUpd2MyiyI2QuB7Cl+BtQKjnae+VVnaFylJ4oSaB56AMFDUmz4EmsZQ4xsYWotOLJHOxNPMRcbzJJ6SaAQIQ5l+yGmMXGS7G3EpJXt7A77y28vMzU9y4tmTDEYpt67s8Oa3rnHk5ALCWnwlCD1BK/RIrYsIVkK48mwWPJmXA9QYUyO1oiTvVhOYlKaEZNdwc6gQQYPg5HGOPfggz3z0BdrtOZpTEwgE2ljAd6RW1ZzPr3HvQj/S2bhOsnjiaYRSoFMePD1gb3eT/s4qM1GEifeIAsPp+Rr7CTTkgLHKNJX31xqNlJ7DYSmxRjvxUqoMK53FRwhLEmuSVJPY+1wJpCq4FZiWf6/O7WzmF0Kmm+9l4INw88eSKTUyoXlM4M1dhuy4AJiRSyEkXpbs25E5SZrqLIo6S80jsyCPihWmEIoL5ldqBUuuV3owHgSWkquJMUwbH6fsnzG4vJOaFXh8F/C6w9Sb7XMEPBPcKuNZvk53w8Jx8ndwd7E/J4FCOJW+BFOx/Voc/pmsD4V/9vtggPf8xs63NHEqEFKhpEFKw0RLEkce3cQwjA21WsCRiTpTvs/RuVk+8skfY/HUIf7kC39Cv3ub06dPcOHCLiZ1eeSsSbAmJdEpgTY0WtNoDCaNGfY7zM4dQSnfmWOlQKDAJKSjAc2JGXbX3qO9cJoZbw4w1MIGqTnMkHlsEjDq+Ryp1RgdOcz5966QpmlGEDJru7Vsb+4wMTlBu1VnuB0R90fU6m1qjRrDTo/pqUl+9MPPMduq89+9+78QRTG582j+YI3JSIkQzDRriMDj5s1bRDri4XMnOHRoijRO0QbiaMT0TJvOuyMGg5RGLWBu8jAPHA1QwxUmG21evnkRdMKZM2eYnp5ivq34/Je+hUkVSvlIIQiVJAw8zjx0BmMMt2/ewleuespoNCSJh2ijaU5MEo1GxFEEQBzHWEuW18/dQJrG+H6AEJLZ2Vn++t/4Rd544006nS5SOtNPEAZ4yiMInP/TiVOP8XN/7mf51//q39zzy/Y92ywO1HIileUCzCeFm0cZlSiE2YMTuKpTohA7c5BxuFZOpHJOZoBqq6bZ70T+bCGhH9QMHgxeKIMqyulbjegaCzrJ+1ho9fJtXNtZ9L4gl1XgLtHQlU+sgHHR9/Luq1hVYpRrZ2wR4q74OTbi4sDOqma0PNK17Rau79Ta2JO9b9sDx4+ztr6J1ilKSXwUwhpuL3fZ7SYsR4appk88EvR2h+wPE0aepd70sv46Py0AbZ0mLQwUMgHfF3jSER5jLBiD8pwZUktFGic0pXL+ct2Er7+WkJpy7UgNBILMRcIWUYaFr67V+J7LV6O181PUukqe3ZgPRglRdwTaUFubYDAwKBExihI6nT6t0EcIiRQaaVy+Ql/iqoxkfSHXrmV37dwnnHP9zEST+rQmWDjBzV7EXqB44OnHWXjkIa4vb/GtCxv85KfPklpnErOAQWCMxpPZOygk4KpGGZPgwk4CBBKhQrzWBHPNWaaGu3SjHvvRgHqgXC5CzxKq3J+91IK5rhq00fhZNQCLwVidkT+X2zD0FNakSGkZDGMSY0iZ+r69c3ffMv+/LN9iHgQiswdQ+O1BsV4dnCsOLyxkaXWMNcW7k9fJdcfl54tMgWIrhM31xQkQkGsLc9/xwg/RuJrTzhRsqx0Aa4pKINkMKQSt72auzfhnto0xqHLL+VaFXFU8I8v9xWIxLgRXLS/5T0Wgn3BJzsevmJO3A9sBwnfQHcYJlLZcqkROfEt/9hxn70byDlr17mW7ZwLoKYHvuV5IJZFA4EuMFohU0pio8+gjT3Ls2BK9Wxd48/zb3Fq3/D//+f/ID37yw7z7ztv4okbqtOhYE4NNsDrBYl0Js6COMC6Nwai3RxxHSC/EIKk1Zhj0NxDCY9DZYmJxiWi4SdzdQbcm2d+8jfRDFhdPMkoihibh/DvvYuPrTB07zNTiDJu3NzIJBfdUJWAMOxtbRHECUjLo7uKFTsM0ShJqjQaLM5MM9/YxpvTxEIJMo6aJ4xgBLLZbHJ1soEzM6u3bMD9NqmP2tjuM4oitvQFvXbzF57/8TdJEI4HDi4fY295lnSELS8c4feohjl+/weUra5w4skiSKA4dnsUPGvRGPTxPIZRASNjc2OLBRx9mMBi4hNXJEOX5WGuIoyGBX2N6YY7d/V1SnbJ2Yy1L+VDPJqYbiziO8H2X6FlKyUc/+nEef+wcr776Ok574LL3S+U0BTsb6+yu3OInf/yn+PjHP/K+Xrg/9WZziccRgMzaXpLCfALJEqzcA8v/VpK8ugYL4lVO0HFyln+uagltcUpFUqP6vbKJfDJX2NkdBLTsTUkmM3JbIZtVeCsIZUWGzR1JSq0AY+S2oH0ZmOegnmtTD6YvsJV7u3MrwX/MNFNdaIqxssXzyT8Xj6QKgkX/cm3GnauWIPfFze7f3HHI93X7F//zP+att9/lG996mdfPv8nGxibSGFZX+vgSCEOkkGhj2dzpu8jRpsVWAqa0tai8sgLW+cwFslx7pKsIYoRAYLBGoCREiSZsBAQI6liGBvruCHwDiQFPOSJYZnTKIkWFBm1oKNd+ZAV9nACgM7ImskUwSg01IIo1+90hoyRFGvcORmnqFnKd5A8Ek5kBk0QjJPjSmfOchtblK5PA4YU5zj75FMfPPMoXX3yHTqfHXDRiKWiACtjvJTxw/CiPnnsIpPM11yZxZ0sJJs3y3bm8bSZNnCuAMWC089sVbq0SwmLSlNHWKunll1FIYqUIfYUyhhNTDS7t9xAy04DiSJA2Gs9TmY+nAWsyM597y5qNGg+emqc3GFCrBdQaIfPzc/TTqe//y3dgq1oLHMnOp4UtnqUFVy6z0HDlR+dtlPPbaTcVhUk4l8Wo/M3woiBImZ+yNoYkjjPi6N45JSXGGJctA4ElLTSA+TzPtYauLRzhxhFHmR9bCMBlxw/i4XcZpINo69oqZeADm+Ag6uUR/+OawMq4U/o33tFUpR/jH8qFQjAu5IvqYTlGZ+NgMitCrg4QuHXbkAvj946G90wApZAYo/E9i7QW5QVImxB6dSYn2jz7wo8R+m3WlpchSumJmHcuvclrr19g7tAM61/ZZacb4vLVpBgbY22KxfnU6SQljmOkcAW3o6jL/v4erfY0AkFreomd7fdI0z5p0nemAD9h9drn2LwVMBrsMrfzFO3Jv8rO1m0kEbu9bYRvscmIqflpNm+vF4ALoITgYy88xVtvXmJ1exedSR6jTh+JJJieJB6MWF1eZ29vhyRNyW0/SmWBMMbgeR4KWGzUaNYUve4eER46jel0I1r1OmEYMt3S7Oxusbe7T+gpGvUaZ88s0G4HjIQiiobsbl9hupnwNz7TZrr9FkHrON20hfI0yveQysdTHkJIdnd2iEYD+r0OAL6v6PUGSGFJ45hgcoZ6o87O3h6e57OxsUEYhpx9+GHSNMnKJinnz2gNeR6mVqvFz3zmZ3jr/Hm0sUSjAbn/gRSCwXBAK/CYnZljbn7mnl+278WW0YlCQ2UoNQRVIuZyB9vqHHV/cgIoSskOSjLFwX0ZeTIVU4o98LngInm/yNuomDOqZmlgvMZZ8engzZaSvOtQlvcy+2vLcShZbQ7yJQhUoHOMnI1J9Qf25aQujzAuDylbK+7/gNRZNd+ILEWPyEz2WcuFRiIncYWnny2BMB/H8f6ND1SuwbmfWz1QvPD8szz/zJNsb++xvLLCa6++ypXX3ybe22U0HOF5GlKLROIDsZUFmZf5mFtwGlR3Yx6i8j7lmuNs4bYWhCROnJ+xlYKRhPVmjWSU0E5SAuvcT4yEOMvHp/JOl69yRggs/YELLssXEJtpIyUu6jUXtuIoJU40oXCkMk0tkdFEaVZHVwq0NW6xlqU22VoXrKIkTE60ee6FFzj9+HPU29MoT/LRDz3LXmdIdxihvDphEDDZbuLmkcakiZunBowwoC06HiJrYUH6jM7wQLvgDGM0UvkgJNakjPa26Z7/EmKUohJY3x2xMDPBZD3g2HSKuNnPFVaZZSd315CkaZoRGVUcA7A4P8WJk0eZnJ7BEwlShUzMHWdna+v+vIDFJrLa2LkK2JWCs8Y9KCPKh27zeSQOEJ9sPuWWDQPYtPKilJLcGAQUM7nANVG8x8YYNy+NwSq3xthKe7kWtcBFmScXLi0vuVnTWddsVi+YQitY4v3B7eCeCpEtRsL13yDGrAsltJQ73XVs1g7l4FXg1mZMtDy2HLiqqbwkeaX1Jr9ulbZVfaLLJSlbV0Sln8W1sueTC83vQxq+ZwKoM4ldpxarLMqmSGNAKZLhPlfPfw0VTrC7tcmRlibwQlrNgM5glY3tqwQ1iEcdrEkwdpSZf112ems0QgYMez1cmgBNmgwZ9rrUG9MYY2lOzjC7cI7N1dfQOkL500wvPsbKe3+I7ykatYD9zVe5efEQ+xtXSeIug946Vmmk76Gk05y5iWAR0lKfnOTwsUM8ceYI//yXP8swTgru3+/1mVqco9Vq8t6N26ytbpKmNvNjUEip0FmErDGGtu/R8iRGa4YRTJw5y5fPv8Pl6xv8pZ/9IWana65wvISmpzi3tMjE7DS1ZotBpNnvR3zh668j5XlmxCYz3Ve4JSzHzi7TfLCHNYYwCAkCH5VJRsqT7OzscO3KFWZmZhkNXcLoUZIwGkXMLSzi+SGe8hiNRoyGI7a3dlFSkSQxUiqkrLl0BgdIwMMPn2NiYoJOp0sSR/R7HYSYJGgG9IYDkv6QsBbQ27+/oFelNVWBKw+PL9KVUOFYd5N1C26YvxP5cVX6Brn5tKz5WyVXGckDCifEYuKXnRvL52cOgEvlU0XB6PpaLKR2TBMIbsEugWCslXJ8/hMDOTaWdzmkcDDP+nIQWfLxqWoNxwRjcMKdBaurqTaq5LP6/0HTe/5kqiDnhtCQ+wK6Ppr7GARy8dWv4wUByqvhK8VMTfKpH3iMT//A00SpYWWrw/Lt61x44wLX+1exaQxAmieIlQKTRbJb6e5Zisz7yrr70sa4dDcGFAKDwApJYiwEHlYJbgcBD/3cx/j6l16jdnsTPyuLa6xAaxDWafhzk6mbImWetsSVFUJkwQJSSXzlMEwb55OojUWnrjJJ4AUYHMlMjCQ20iXBNtk8kNbV5c5WLqUUk606P/3pF/jBj7/A/JGTGFV3uV+FQHqCyckm7amSjRhrnM+x0aQ607yZFKRCJxHCCtLUVTaxxpmEpVTo1ODXQ2yWi09IRTIc0LtxATnsg3UBW3FiOH97wEcfmObMREDTg25iC/OZMSlCUJA/IWQxL0WWEmY46PGtb7+JEJZHzhxhMDK89l5EMlrh/m5ifC7lJsMKGcsno8UyhpWFYGXH0mVZ7FjOvGx3Ze4WjLFAO2szX08p8JRH7pMrhBN6UuM03yLDLCNyVwA3vq7KmCj6m5NVlSc3vAupEWP/2PG/OR7m68CBusPjHFGMfSwJYQVNxwTS8pycvrkYkAqaVjSaBy0qjuRW+lthslVOXl1nZE4gCzLpIrILDK+6Ed1FIP9u272ngdGmeDkUgjg2TE1K4lSwMNPmb/zdn+Poqaf53Gd/j1e+8sf04h4b6/u89uKXIPIQ+BitMTYCo3FqdQs2xaQxqtHG+QE4Z3mjE5JoSGIMAYBQTC2cQuuE/e1r2GTE/NIH6WxeIR2tMDnjs7m+waXX/hWpcbUjw3oNY2HU6TMajgozFwikUkwcmufC5Vvo/b6TcAOPWq3G3t4+vicIpaUtDXv7+6xvbmExBJ7v8k+lztamlIevDLM1n1bdZ38QMbSCqJewePgYlzfX+Pr1VU6uRWyIOkc//AKndzqkm3vUJ9tsbO/iSZ/eaMjuXpeZqQlUrY/ZN4xiS31myFa4Rq87YGl+CU+60nu+p5hfmGdhcZFvfvVrHDl2nCjReGkKScpo0CcMA3Z3d0jTlL3dPZTyWFiYx1hDGhs8zwIuiXSu/cu3k6dOcebsQ7z87VfwfR9rwJceSxPTHD20iJSCifYEW+u37vll+15tTtGQg56lql3LtRCl4qpSNq3gbd9NShyXmgswGYsStGNN2Mrf6iSslhc6SOpyqftOLeSdpK4EdVEQ3bLnZCQ1NwbJsfPGBq16TvXvmGaSErAKELqjNfdzrumrtpM1PH61csHIgw3KKGZ3nWqfqsRynJy6+zbZ3RpjMhMj7wv0/rTbztY2SRJTqwVIT+F7isD3kSrAV4qlqTpHF5/hg88+zfL16/zav/ttBt0uliyYwTpnbi3Bs87dxFqXykhYC9b55aUWUpPZ9K0bCW0MUgm0EOhE8+5b10j2es5HPHt1rYVEawQuj52nXJlIX1hS0kxxUPrq5YRBCYEq5o179to4M2iqU4wKssfgZlQehJNrZKwGJV1wyPRUm8/8xKf54AeeZunQnHMxsRZpUrRRWCEx1ss8FnKx3M0ZrTU6dfaYFI1OYjw/JI4jgqDmzL35JBESawzKc+uLF9YQRiOFc22xWzdRyiM1EaPYsN9PeHm9y+HJOucWG5xsebyxMyIPhNE6yUySqpxruWYFqNcUw+GQfr+PFIK5mRkSW2N/fxehR/ftHaR4bjIT5N2zlNn7BE47S+4vWSEd477D+a/5vTpNcOkjR0laxuZ7qeXPv+fCqfIUXoVa2Kyv+V8qbVtsRhIrECVyv8asrJqgcu07cah6HXeRKhaM4+V3H8/ylql8LP7aA98rxNhmJLWycmTnlDjnnkDpclTtahWCixQ+NneBGRfq8/WjCACxLo+nISto8T5k4XsmgKmxKCVd4lPjSrnsd1OEn3Jyboof+MACqnmcX/ylv0coJV/44udI05RLb99irtEg6Rl6vRhrDKARCibrLYapRJgUz1OOaLj7xJK6AJHREFqTJHFMv9fBmAAhA3QaERvN3LEPsXH1j/CUJtaxS2RaDzFacfT4AlMzE2xu77Jya6tIZiyFpDUzSdCs8cGnHuKh+Sb/6J/exEpFkqToVFOr+TQ9QStQ7G/tsrK2Q76ySanwfYXWGmMNszWPhWaIsZpI1WjONXjrtdeZWlzgwx94ECUFl7b7tP0Ro4lFfvBjH2axFuF7PmS5pdxiKvGadfauvc2Vl9/FGs3GesTTTx3jb//VjzDoQTqyeFLgBx71ZoNWq8VwMGD55i20EaANUQaUvUGPq5cuMj07x/bmFr7yaLVbzrfFaKyRdDv7RUkd9yI6SXh2do6nnnqK1155ndQaAj/g+KElTs8uMOkHbO7sMBr1ESa697fte7JVpdJc6s2lrYyUFFqIcqt+t/lMrSQevgNWsmMKLlQhSPkELkrvZGTOZJq6PCK11OC5E+9GAt1xFbOxrYBIBYxywaVqos1xtCDBlTspjjlA3qq7S752QArO2ypVBncboQMNlgRwfGE4+EUWBNDdu8kHitwE7Nb1vK1y4O+K4zYnjd95Yfheb81Wm9Gwz3DQQycpjVYDU2tQr3skWJLhDt5wH98LOHxkFi/zy1VWZc9aIIVFumUjS8BsCk2KFA7QEcIRE0d3ERiszkxXQrAwSoheeY/DOK3ctpT5UJLqLEKQ7LlYQ8MXBEpRU26xqHngVQZVCo0CEmGR1iDI8wlKhDVYUjfYxlUpCWTpThFrS2osnufxgScf4q/9pZ/l4UcfxViXJmen20WnKRMTghCBIizyxinPw5g0V+sWvmQupYlEa4sRCca4Ba6o/GM1nu+TxjEqCEnjEcJaFwVsLcneGnbQg9RCIrBJSjqMSeOY3357lf/q0QV+4niTa3t99pKMQMmS+OXBfp6AhUDRbvpsJglJ4jTwD546zqGFGa6sGkIvcqbn+7qVQqHMSHuBhqUEnB9ZokF1zhYtlUJybirOVWh5mpySpBzAoOx6udCrU11UjyovIgo8qQrsORm1tnLdKs5VsKjsa066xjdrbaExHPvx4GLwHUezHJCDIm8mp5bXHYNWURk7cDV6S1JYjG1xvs3uOcc7U7mrnACKggRW8bpMi2Xdu159BDAuzN/Dds8E0Ped1kspRRS5RKdpP8YPEmYnFZ68iRd8Ek94zM7O8+QTj9Izdfb7A6Yna/RGI7T2sCRIYZlpT/Dk8bO8vnzb1bf1FEEYunQINlfte0TDDqmZR8caIRT11jRGd9FpDFbSmDhGa/Fpdna/TZpaZmab/MiPP8f84iStuZA4BS+UvPjH7/K1L7+L0a7wd2NyAt/3qNdqBKGLgG00auzv9QCBFIp6LaDRCHj2I09itOZL39zDKoXR7uEJAQ0FD0w1aAY+u8M+W7uGR+d9Ak8y2ttj88ptOhMTDPp9pnt7iJsdpp94lObhQ3hS06gphIXEaIT0QAV0GjVaU4vE25t0dxSed4iFmWmWhwM0KZ7y8cOAsFZzucgCj60NZ36wVpDEEUGjhR/Uscays+1SxDTaNa5deY9uZ4/hcIAUkonpKR544My4mhonRf7kT/0Uv/kffpVkGLB06CitiSa9aMjEoTbNE4e4vH0bJpr3/rZ9T7YK6bJu7tgslYM1NtMgV0wg+YS2B9og43/jdldKBuYSVpgcbA6o10sydycRdP3gDoTKTXBjZNTaEuzyhKtUj6sSR3PAxaSQB4uuFwAO48+0CqBVIK78loN6kRut2u7dbgbLwRs9+B6VvSxuODvPlsBW/ObMkd8dsKtE142RqTyX+7HVm02U5zGKYrZWNgh2dqnXQ4JaSHNikvbkFL7nI5Vi5dYa22sbLm8LWXSucI7caWoR1qCNyTRQjhSqTAWghKs6Ya2HNs5fKc3Mr0JJWggWBPgWekDTGqxRaAuJdkmd/SwXoDGGJFOzDGIXNBKnltQIEDLztwKsM+OmJjfEOZKmtckEXkfCkBKN8++z1qX9sAI+9eEn+L///V+kMbWI9AIMHkoFKM+n3+2wsrxOe3KCqYlJDJZUWzwrEDbNcNVp95IkIk5dvV2lArcmJAmE9cq89rEopPSd1s5zftdezfkRjva2SEcJaaIxgxQieHCiznZfc6034pUbO5xshfyZw3X+YHXAViJcmhzcOAQKpmqKo1MhU42A27FB7sekaYJGcP32Cq12nX5nSDTsU6mue9+2g8KitVnE6Jh/2PjsHSc3B/RcOSYWJ4gx8MzPLS0X2SSuuqRAFmFehCNnOJPpwCpWG2eazjC2TFpYwUWHB4WsnnO7gwyNvN+lwPidBuwupxZ9/w4yputTddSq45OvJ5V3x4hynA6OXmGtKRJMV+j5weUIZ+6t+ggWSossCt4NUYaK1t5xb99tu2cCaKx1UaBA2JA4txbnyzIzOcsb397mzPMbzMwfx6sFfOAHPs7/5e//97z80mv8v//nf4I2LoBCSkujUeeTP/gDnDp6nPbNI7y3rrFKID0fl94wxdoEKSEd9jFRRHtiChV6DAd9JutnQXjEgz2CxgTt9mkG8Q7D3gbnnj5MN9nCGwiaqs1oZCCFww9N8MjmMVZXttnf7+N5kiB0/m/9vkJJSaNeZ2V5s5BklHRJVMNaHZM6s3Lq5HcH0J5kOgho1wMirfng8z7feBVmJyLqJzWx1RixzeragK3VbToamrWEzvFdXnt9mbXtLu3pSbqdHtu7HfY7A6Io5sMffJSf/6W/w413bzIYWOqzRzm6eJrbN15B4bLTNyYmaTRaCKmYmpllfXmZZugxTBKMTjl16hwPnXuYSGt2d/bwlKTf7dLvdolHI5aOHSUMQxq1OvV6445FXwjB2bMP81f/yl/jt3/1PzA12eDI4gyPnJ7iD774EqNun+TaRWYffRie++T7eOX+lFvG/EzmS+fAJJvSxjoQEbk9oTr1SiCy1Wl+QPtWSGb5b7Z0yr9bVyAjUrKSEltWQePg8TkI5J/z6+THlxLx2N9qfw4cn0fR2gJDTAkgxSMVB/4tn3eFS1JK98XAVQT9cYl/bKu2Nbb/4L4K2bR3Hp9rwaqdKkzBsiTj2Eok3PsEvT/tJv06ylgmp6dZX1lh0Oujk4RGmkAaEXU28b2AsNnkxo1NYp0ilIe1TlMnsvQ2xjgpvhoV7ck8Ktf5XQ/jBGs95xsnLEZIRsbQaAQsHJnF85XDVQ3B1TVMaomN8++zGoxvUQgwhjhNXelMkbt8uIogFjJzbhbsh0Xj8B6dBUBV5pnJiSouGlsIi68kP/KhJ/hv/+5fpDExhU0T4iRGBg2CehMv8PF9Sa3eYHNzg450LiouAA0wGq3T7FqeM7GqEClduttAeYzShLrM636DyoI+RGG39vAC93ucRMSxodMfkvZThrsjhntDh69H2ny6XePF69u8vDri9EyLv+IZtkYpHS3QStDwJG1fISdqiCYkWtLuanY8n0FiiY3ACMvK1WukRjDbqhepfe7fJkosFM4NuRQSnX9sKbuV+FASL8ZwaFy4LffnViFRnpAJs3luQBDaheJ7viuFaFJNavSYtrE4UeTRvVS0gQesDtn9labn8viia1VuaseAquh7AWwFv80/iLFjDhJiWzk3b/ogiS7OFaUGMN9n77iVu9koyquMdz2/bmnytbhE32M9raxJZbDe+xOE75kADiNLGDiWn2qL70u0kGgtGAwN//pfv8Zfrn+UJ56fJY1TEj9y0apxlz/7cz/Nm+fP83uf/RKnTp7iiUfPcvrUUT72yY9z+J2rXPv1FYQVKM9374cVOH9ADVbS72xSqzfwPA+BJYlGeLUWlhRMwtTcIqNOwPR0g9FOn8lFjyDeYevtIR2jqbUDpIBjj7RozwfcvLpN0AwRaKRNMemIWj1wZghrefzcada3tvA9p2nrDwd8+JkHeP3ta/T7I1KTIAUorYhT4chYe5Zvv/0u3WjI1v4MZ08prl7pE5hpjjcVtVqHrc6IqXaLQCrOHFvgIy88hgo89ve7pCZgv7tPt9Pn+Q99mLmjC5x89CN860tf55WXzvP4I2CiEUpKlBQ0JyfwwwABbO/uMUwtgdVgY1r1kMOHD1Fvt9lZXnZJTX0FUrFw+DDHT55kcmqKIAiZmJwsEnQefJk8z+eRJx7nla9+hbA5hadGXLl6kwcfOMYPfOyjvH7+Cttvvva+Xrg/7VYERWTiWi612cy3KlevjxE7UYJAnmuqlGTd8TloVs8dI30VYfeOPmUI4fBRjE/msWOgpFKVBgsQzImdKNq0Bfo4/9uqJtIWIGbJXIWz5qsS6fh1S9PzAcizlSNs9YdynMebq0IgBdrlZg+3qwLcdw5bKfnbXOtJxYTxHYCu2p/q3ns083wvtrBeJ89j5vs+SX6/0sMPGvi+JDWG1y/e4ktfOY9ODcKzgCsfKCVgnRkYYVHuDwLrqmoIl8bFWkscG6zOAkayur1apySh4tpMg2GthpKC/e4IJtuIzX0SLTJNoSEwFp311WapYdzCbbJnZUufIYNLqYQLInGaQ0itW4hzH2oX5WmKwMBmo8kv/ORH+fFPPs9g5QarX/s92uGQQAmQPnEwTeP0C9TmT4OAOIpQykNKiEYxqTaYVBMnI4w2+H5Ivz+g0fJR2hFRncYu84O1pFZiUoP13A1JqTDWBYZ4MmBrc5OdjQ281NDpjdjbHpLEhroULC5Oc2RpAlmrcWitx+XtPX7resxE3WdCSaZrinYADT9gcnGeBz/9KW5deZs3X3kdH0vDcy+fbyGxjgR6Kk+LMo6j92cTd/6xmZxczNeq+0S16gQHSFTZ6kGLST7nCtHVirF5mF8rSZLx9aQ6Vwuhr0JMizqCGU6PYUAhCZZtWVvirKn8cAfRK+hbpR8HKFyOeaJKlMumqmdUx6+gbWJ8T07YcjiqZlAQlN/vkJ0r/zuBtnJblec3ZhLH4YfNXDUKEvo+t3smgIkGPTLOmdiDVBhSk1IPFb1RzIsXr/LRlRXM65L3bl5lcnKKJ0dddtdv89ADJ5mbbvDWhff4O/+3v0Q/3kYOAkJlGSiBS1YvEcJpAHNJw9gEvzbBsLvNcGqOwK/hB3VMGjExkdLrNKi32/hKcvT4A5w5HbN2bZ0Pzbb4xMNNXrnW51+9vYfoSjY39vj4px/n7KNTzB1d5eb1Aa2JEN9XNFstarWQfn+IEJbDh2eJ4iHr69scP3UEqTweffAEE+0G3d6QNNX4noc2ht4oZq8/5KMvPILf0CxsX+To7B7tIOTMQ8cQzPNf/8P/K3vvnOf6eyvceu89dD3g+InjCAWjRFHzDdZoYuXzrbdu0I8STj9wiqefe4bZ+TlW6g3W1jYRSDypQEjakxMuAaUVDPoDtDZE0QiZjAhCn97eDru7e4wGAyYmJvA8j7nFRSamp5AWdjfXmZ6eJVxYxBENV1OZ4kV12+zcPF6twUIrYHD+LTYHMc8+8zArv/058Bt0o8F/xmv3n7+VE8zN0oIrCFECSz7JDkqflQaEtSVZyQGoODZru6LVMjYnkBRgYiuoUZCyrIU7EjxX97kvY7JmuX98X36tMe5ZkXbLXpfXGZMTc9Cp/JapCiqAfJCk5ch2F0g5IK6K8RMr7854IM74Vl0VKpqFLG2FrT6Kon1Lnu3C5DQ/fw7cXxNwLQxRQuBLxdLhIyyPhnieIgxDhFLcXt/hpXeuc3N1h8FgSJi9GyLrtBSZ5i1bMPJFSEoJxpl5Nc7BfxC7aNic/FhribWFxDBxcZ0wTfGMYRLBdmpQAhKckK6NI2kSWbgZSJzfnsmGVNjyXRdSFEXptdFFwLrMxlqnGivI0tNQuAQ9ceYIx/whX/w3/4azc0Pm5hUi8rF+gFA+cneFvdtvYhafofXYjxBFI4Ty8DxJv9txpmQhGAwGGG0J6wFxHNMQLr2MrxTxsIvB42svDWlNWjrdiCW7zZlHjuA1GyBAeSHCGkbDEUL6NOaPIIMagejQbDY51KpTDxUqbLKz1eXmTpcpJenECdc7LhHx4ZrgTCtg8eRhHvjED9KYX+DJpUPcvr3BcHWNeghWWmQqwAp0FkpjrYuavp9b/sxcwARZEFHmd1bVAJKbUrPPOYXI5lXph1fOe5EJKeX8zQTV6jQr2nONlUSIsdx+sorDotJm9k6OWyLyvpX+jfn3Axe+Y7NjuFLsqX6t/MlGpsAaMX5Atq/awhiRJRN2oYyaPrje5PeXY9gBPnsXVMyeW9avwpxd9b+srh/lnYzD372/h/eeBoa81qBlGAuUskjPvYCehFY75Nd+5VfY7m6xub2BVDVefPU1Pv7880R2n5nDgl6/wy//xr+h/oDh1LEzvND6CMHsAoYbWATWU7g0MO7RxaMerdmT9NY6DPZ3ETPzGFJ8X3DkWMdN8maEEXVGexLrp8zP+aiNPd6Jh3x7GLB4bAGlBA8/epQ4NZx8ZIbNnVVeOL7Ie2/0mZlq0fDBV4rhcOQSuCYpSRTT6QwZ9odsdQZcfvcawyjFUxZtpEvuKiyJSXl3bZeju3v0dJvdnmUYDYjjiCi+zAMPHgXdpnnyER45+hCnnjrLtTdeZvWlV2BiiqH1OXZ6CeO3aU8EnJiZRiSGldVbBOdjPvFDnyHd3mT5xjpCuckqpU+92cSZOq0ziWhNFKeYUUQ9hGTQZePmLWaXFpmammZuYYFRNOLiW2/R29ygEUjEw49x5ORprNVZYmgyk0s54R559DH+7n/7D/mtf/b/5alAsJN6PNjbJR0O8bWlsdu555fte7GJ7H5z8Cu+S+GGg3x/gV+lIFWFg0ySyrVOOXiMSY2VU0SF8BXEI5t5+YSEyneHDGNzUeamlPynSg3NTLwtpNy8LFuVZFY6T9nZUnIe+5kK8aqAUOkkDnkicDcc4zStjNa7C1DloH2QqFU+Vs+xdx4x3tmMjAqLM/OWA1g5ShRoLTImbmwWBWzuLwEMa3XnwxdFzM7Ps7N2k9sbe7xyaZmt21t0Oj32PEW9FoJ12Km08/WTwqnZpCjLYknh6qAqKUm0xmqDtE6iz4MrTBYrI6wk1a6kWn27SysbqRToC1yyZGvQOislZ12lDESZOgcY04hI4bRoKThrgXDvoMYtSMZkVTgycq6tcL6AFozWrHdGUJ8FtUwcdYkjkMpDWvBslhBYjBi89y229wzmyEMov06aWtI04fq1yyweOk6axqRxRJrW0MJDZ9pAgSWKYjpDQ7MleffiECEHHI6uMozWqH/oQ6AUymqCMGBh6TBCCva31gnb0zT7HeK+pLObsif7rNkenX7Mzkgz7fs80VYcSzWNms9kq8bsmTMsPvMUfrOFSWOMV+MjP/TDfOlzf8jNlQ1cUmqBtJm/upsQKHl/NYA5eRpPqSTI5AvyYIR8nhYcpICFfAJXxUjuwJJxwniQ0IgCg6r5O2VhDxfVhkoMqpiAc4LjrjFOpsp7Ewf6UunvgSuN77sD0SlxlWJ8qprCg1t1/bDF8dWLVLRvomIJ+g6Mb6wiVIb7xSgVF3M4V/X+q1YDKRURZOuGvfPZ3cN2zwRwf+TTDCw1ZVCKrKyZxfc0jXoN5SlWtjfZ2N7IEjrHvP3em9hWn4U9y6kHJnjg8Sbru10a+/Nc213n/+z+T0zWjtNq1Jxp0/PxvIA06SOwpHGXwK8RNFrEowGy30Upw+RkD5MuE7b3mD0yix+E+KJGNJjnVj9i8OQpXuruc+nSBnu3NziytISVfaYnp1lf3gTr0WzWOHYKdnt7dDcMtVqdOHZRbicPT3H9+m2sidnZ3WdicprGdIt6GLKvwfN8pJIkSYr0Q44/+DCd3pC97U0Wpg1vX7YcPRRw7txxdK3F/+9f/EuOzAi8wCcZDdnZ2me3p2l5mng0gmuK9myb2zdvcXQw5FowYGbhGKPhPp/7zX+N/9IN5NRhxOQkQkga7RaNZjNLh2A5c/o0t6/fJIpjom6H3p7m1LGjBAJOP/gQN2/e5MaLL9Ld2SLtdwhDj/bhJVQQFr4cLgns+DPPk6CefuhB7OIcn72kYWuLhh9xbiqg04348uXb7++N+1NvueQjyaNfK1SnIp1VwMSOa9AOTMuxOXNQYiwmvi2VVFACkmvLZmCb+URVCFxOcPJeVylNIYVm4Fk1M6iCZNriOTu+6dT+FpxGLCeNd4DcAQKYoUbVjODKK2YahAO+OA7TLULIEozzdnPp+AC232mGteV5ucSa+yxVULSgmnkfx55ExQ8mQ7icxIyNxX3cfu83f5vd7oDmqEvbJLx4fZVX1vvEw4g5k1LzJEZkwRLCmWOVtWjtSqUZBL6vCHxX+3cwctWQpARhsjrXAlyohiTV7l4TnF9gYgzaE0RAaMFIF+iKBYXT5BjriGMRRZwvTIKsrm5ZNiofbyUFBulqtSMQSmaawmyElcgS8dpCi2i05eK1FS53BeceeYro0pdIhgbf19R8iZIKsATKQ6qI1Xdep1mfY3r+MFIphv0e+5ub9Pa7LB45gtGGUZxSa00QRzH1ZttVehHOP3EUrXPyZI1o11IbRkQrXfzL15CnThK2Ws4M7zuBNk1SaE6j7W2iOGF9rce+0CQkaGHxA4+g5uMJWArqBJNNDj31LO0jS24dimOCIEDKgIUTZ/jxP/Nn+a1f/w1urGxkZdccCzYWtBDvK/3G92YTY39Kga2c52OH5X8rhLA8oHSLGZfUKuSsIGH5T5X2q5q74vrVxioETpRt5pU+yubGCSBQQEVVH1f6QVNaWapWmIpAWBVAx37LcfCAtrF60jjRK8fjoMm1IGUiJ2wWrCx6bCvXzLuQr7vVlgqrQNValA+fzVOaZesC1TRj1fXh3hHx3jWARtIdQRxIQmPxPWdisEIQGxgkEbfWd1xOPz8gCBU//eeeYn/Qo5Ns8tblfR744CzqTcvuXp+ZSclqusfazioLD3wIvbfFzNKQm4FHoqUbPK3Ro4haY4JBf5dADPnQhyeYXhQcP3GGy5dvcvrEHEo1WN5YRvhQnxVcuHiL8+/eZOVmH+X7JPsBxhty7mlBENSYb0/y8pdvs7Xc4cbVdX7pv/4lFhb2WVnfZUFIBpsDmlYSa0lnf0CSJjy8tEDoOQlaKZfaQAg4fuIkqdb0+yNWt3bpK8MDh0PeeS9lwtvglatfZHkv4uRMEy2h3xswPTXBqSPTpFsRN5Y3SFLN4zPTPDfV4Ppine3ldV5/44/Y3x8yP9Hg2NJRzp6YQOKk+/pEm6AWFjmSms06vh8wFIr+MKLlO6K5u3KL17/yRTY21ul39hxgSQ8xOYnv+YS1epaDLKtsUkyCCjQIQbPR5Gf/wl/gf3j7Iv39EbOzk8zNSbZlk/fsxj2/bN+zLVv4TRZtW/TWgJXZpJIuE30OHndIgNVPd4h1JamqXDK/RPGlmHR5S1Ugql4uM51Upe88xYQYO8yOAcN3+r/sWwaJuVRdNDT+oSBnBdZWgdW6/Jx5P4XIEo/m7ekKMSxF0LH35ICwe5AGUvm5SjlyppmPmzCVdDZVs3BxqC0WltIKnjkR3e2i36etce1lrt7e58zxCc7MNvj8cESSpE57aQRCu/sxxkAWHUsmFNQCRWQV9VAx3faRAjyMCxQhpdXysEhUVm5TGEuS1drNo52T1GI8RWwhVYLEFwSpKUriWZx2LjG2NPUKUUT5gsiCNzJtqjsjS9HlBtIFDLvjlHT5AZUSZMw0sxQkGCBOYn7tdz/H3//rf46JoM4w6lCzgTMpCoHvB2gd4ylFr9Nn98YtHnziWXrdPfa315HSsL2+SlB3AWlRkhI02k4wAbAGpTyWDk/RaDZ48ZU3Obx4CNU6idjcIN3v4RsNwtWyVZ4PSUIcJXhHH2b9/AX0cMS+idgz4IUenmdpBhZR87FKoppN5p54ksaxY6RxglQuqbGQKtN2SqaWTvJjP/1T/PL/+SvsdvpYIbFSYVFOo/tfQANYTIixOZ8LWOMGzLFQqWK+2vF9lLhXGBcK7mKzqSbGT8g/5+9TRcjMAaOs5pEJhVmuQitK4lVo+aum5oJ0lYSvekdjsM2B64ryyHxIRHbNsd02f+9LECu/HRjbiimdyh9bHJePg6hgVzZvsnXGZlr/6tpTnFoVim1lXCift8jwxMVKZH6AtqymdNCn/7tt90wAlXSq7iiFUZIlWvZ9ptqKmaMP8WP/7H/klS98kfO//M+R0S4Li03+/f/xEktPfYDjP/G36e9vs7y9S7z1a+zubrN0aJ6JUCFqlvWdr3Pq0CUatSbLj7hSPxtrCfWaYGp6k7BxDJ2sE9Q3WF9/gxs399jcatHfHXH1nVsMOj3qYYO97YTHnp4mlYpma4pBp8fSUkgQQLM9QasxyVsvXebJDz/Esy8c4dr5Bjcvr/CHf/BZhJBMTEwy2Z5kq2d4vjHNqcWQf3Nzhc6xowQPhISBl4Gie5tOHD/B0aNHuHb1KqNhj/mWz6irCWo+zx4KePHdHvMnnmXuyQXe+ernUUlMvdXg5rXL7K3WmA4aaAm16Ul+4m/+GXp7Xea05if8gNnJKd54+Y9Zu71PI5jBjkZ4Xh08QWtyEs/zXPkmoNvpQBpD1CMZ9GgdPUYcjUiTmL3tNbQxIBRIH+0pgrCGtYKw0STz+CFOYgK/VgGFUqKzWM6dO8cnPvkxfu3GTTozpxk0R7y3O2BN3ceVFzdZjTWIbDHL3KbcZtwC4Mop3KkVy4nFmE9dhcwVE7S6L79u9s/dQac85qD0Vchx2ZBWzcgH7mz8twK8M9+tbFLnEJqTnrF2KtcoMapCArMPuYQqKmbI6jHVNguSa0r1RpXMVX3+cmKYX7Y0MZdmnCKqr/ra2Eo0LBXpN+9rdmxuVSrIdAayhbL1Pm3PnpjB14b+IOGCGdKLIgIFscWlf7AWkKTaZHPUPRSDoB56TNYDpPI4cniK7n6fUWKQWuAp509mjMH3PfzQZ9RPiVOBJ4x7v4E01aSeZKRg8+gMydEjeOcvMtOP8CqCik6z1C7YzI8vF5oUUmYl6SrvvbPsWLQoFzRjLYEfoGxCzfddwIPNigJYsiTTil5/wP/+q7/PL5wNaNQto4GmXjOE0kcpaNUaCKMQ/h6rt6/x+rf+hDAM2VjdIBoOUGnK/s1biGOH0fhIL0RbV/MXBMrzkAhmp9v84Eee5bXzl/j2fpcnZpc4tDBDWG/heR46L3HpeXhBQPvwMdYeeYqd117BaydMpgmpTEEKgmadcGaB+uICqtmiffykc4WREqE8EIJUawIBRgqQisOnH+GHf/xH+L0/+AIiAR+JkB7C81HePS+n36PNTQiHSdmMLDCqanXImV0pTAkoAuKyH0tcGyOOJeFgDCeyczNBTeR+xVCSMAGlmRmoYEXJo8SY0Ff4dmdlR8fMxdzt70HCxhjOlrddcac5iN/loXfdisT+ubBqShJ55ziWuOVIbsV/r3I/46tmJX9jPi7ZGjD26MrbdbtFaSYuSJ99f0LIvQeBpCmuILYDdqlCVGOa1Eq8IGDxxBk+9NfPMdzexl/9LKtbktlJSWfhY7y7cYjOrXXSpMfcIz/C7Hvf5qkHn+HVS1+iE21ydHGeb37tMsePHKUXrfPsE2eRU5eZWUg5egQW5/fZulHnxa/G3NpdZmmxhTrRRMcDwiihLeZ4+sM/xWtvvcfld77N3t4efq1GGEh6qx02bu5w6vGj3HrzNlOzE+x3dpmYnuLxTx1l/liTi5+7yG4cszQ7Tz1QpFYRTLc57sNELaDf75KmLhmy833SHD28xMmTx1lbW6VWr5EmCYIuQvpcWTbUQsvs/ARL8/MMlWbQ6zLdDDD4HFtc5Cd/9ic4cvgU00uLrFz+NqMggfkF6tuXOPrAh0hHGzz45POoxgp2CNvXtphuC8KwzfzhJdpTE9RqIVJKOjvbeCYiGfaIo5jA89A6BQ1pkmKsQXoKKT38MCjKPdXqLl9WFEWkaYqSHkLkr4SkqhKXQnLi+HFkvcZlT8P8Md67+Ta9Xv99vXB/+i2DNGtdWoxMqsOK0vHZZk7MuTYLW1SMKM69W9M5WSEnN5VL5pIbFT++uzUhxFj7ebBJQRzvIJcHyGA2yfP6mNVnUKanKTpbiozV/leE0wr8VoTiHJhyIlhKmlXCVuB5OQQUy4qt+JONd6B6xfJbFZ2rXwtTR2WhOXB+vs6M7RclIgpjxs033+/NGg7N1hglmhv7Q1q+z7m5GW5u97C7e1lpNIu2pVIoN1kJqZDKI/A9BqOE1e0B27sDZ1IttKEO2IexJvQ9Jo9NuVQn1uWmjLUlEYIYQRwETE/Vua0kM8KlG8yjdWNtSLO+CCkxWbJphCnMWNWFXeLM+nnpLCkVUjhztUw8lO+jhBM6ZfW9xNWH39rc5FvS44FHa0QjXZRsEyIkCBQgWJgOWd217K+v0Wg0ke9cZmplG5G41DSjZh1v5lBW6jDTiJsU5XkIQAloNnw+8MzDXL2+wu3OkCPHlvACD+1Cl9HG4ClFa6JN0GjT/PSP8W67Tn9nCzMcYaWHatTRvk9r9hA66tBstAnCgH5nn9CvobEIY7IyfBYyf1NfeTz+/AtcvrbMN156080LpRBp6lKg3NdN5DP5jinjHhI5XGZSkztuXHDjAEhQAb4qdoiS2BW/lEQvB8xccZ8faDnYVsGGijsoCN2BPplM41/kAixRtej0HUL6gds4iAslbpfayDGfvIqFpRQsbUG4KM7lwL7yc45VtnJunqrL9SAXpss1YJwA5gT5YN9L4d8Wa92d9/5+sPDeS8FZg29wyYqR0JhCnvoEZv2bJHHK2uo29sgxlv7K36Fz+SPMDEPE8m38pRN0dvaZPjbH1JHnMdubPDZt+JOvfo6t1U1SLN3NDZ764TOsXtrj+IlTHD+1yJWbN3nzKytcsKscf+AaH/nUI3zs03W+/OsR2xvwzmsjRoMhpxoeH3jmQywsHKVzRrCz8x6Ti5btjT7tmQZKC9gfkIwiJqYbHH9gkZWddaLBFv1Bl/ZEg3/0S5+iPTHH7W/8CWdON7m80+Bde4b+zi56eRkpfbY6QxLrfGOmp2Y4efIU3W6Xvd1d5ubn8f0GazfWiZOEyXaNP/n2Do+eDHnt/Bts7m9x6tgRnn7qUY6ffohjS7M88dwHuHZ9Fb8m+PJLV3j7V77I7n6fWhBw4vhrfOQDx7h8s8cgmWb55g2iZMShuQl8q7DfepHT29ssHTlKnCR861svsnLjBr3OPiIeQRxhjSE1BqNTLArP81F+QM33MaMRIKg3Gi6lROKSY6dpAtgsqqwycYUr7/PMc8/RaDf5yoUrXNnqEMYJyX2swZr3pQwAyf2lRFaDNE/HkBGoonC3LQidE6xshXhQEDryPWOScAUYKlt18uXtFNcZ6zCloGzLyXkn5uZSLRUz8AEfjyoY2Qp45WBrD0rCB8C3ShArfRFZ8umqQ3bu+yeyxLI5uBegJIRzKaiM4cHnVCV7xahVpPBxSTcjKuQL2oFzxyT6cX+XXCq/X5s20GqGhDphRkPdN8zVJZ/5xT/Lr/7q79C7vYEw1rkjZO+qxWJNyl4XBjsDtwxoN3fydzofQmNdGTQFhBKSVCNxkZ4KF41rlCKwlqlra3RurHPMuFyAynOjKJWHySKBjcksUEajtXObMBVSnWsoTBZRqrBOszdRJ9YJIgwwg6GrzDFRI06NC3jIzqvqHG51U7b6liM1SxK77AbKWjyvhtWGM4cavLHR5/LF95jdGXLo1jat1OBpGE6GDDf3EPNLQBZIIlxRAC+ouWcunDDqkXLm9DHOeh6e7xXmsbwslkbQaLZBCOYWFzn1xDNsbayhrUYKSRwn9PtDkmhAq9miMTFJnDrNoF9vkMYjlN/AWEsSp3gqwfNCrAe+X+PZ557hnfeu0R8lOJO9QkjFfd2q8zJ/lplgJ3IwELk4YSlnr8jmfEmHqlupMcyv48BrTNuf/1shfzk0yIpZeozEFKbRKvaMC51j5439zc8vrz/e58rnijWh6m98ELOrw1jeZ0lthRy/jh07uKqFK/td9kUU7+TYMJGjXEbIcyzMr115JPnxdyX4xamZRrJaCu5uN/kdtnsmgEIGhI1Z7NxZkmAe2hOY4TbGpCSDHjcuryBNCzUzy554iI31LWpyhr1v/hZBTyDmT7K5uc5CLaWzf4mJlqR24gjt6UUEKfubKWfOPcT67Rt8/etvMznVZuYJSzS0XHxtm0bnIv/gL36Sv/zf/TD//T/7A7Z2JBMzLTb3d6G/zNql1/Eb85x98BF2dy/Rrm/w5KOTTE22+cbXbnLuqZOMtiI6e/vUa218P8XDo7+xy/7NdR759PPEgy4LzRaDnQ6Hj23xxd1rvPCxF2hOTfDrv/V5bt5cp9lscub0aXyrWVvfxPMDtrd3aNYbHFpc5MbGJkuzNSxDCEMePnOWz5z9UT724acJgpCXX3kDWWvw5c//ERurm0zNznH64Sd48MnnOf/G27z+yuts7e3yystdrJ3j7RvXEIC2rgZoI9D8i3/6T/BweRgTY+gOBiTGsDDZYmGiSTLsYeI2KR7GKoIgxFcKYWKSQYT2p1B+naAWMhqNGI1GhGFImqbOZGXdouF5XkEKwHL48BIf+MDz/Pt/9ytcfO8ivqeKShn3b3PTQuZEkBKIjMlLaEHm8JRp0R3BsIX/RP5SM0b2xslVdoi4CwjY8ZlaOfMu2920aiXhLLRpWc1VF9FqisjWXKNZdqskPzkBzO8/71ZpiakCdaUf2c4cdHKyX5hbEAihK4NU0SrmJptcI5A/g1zVNYZV4/dcfX5VQkfxLEspuLr2FGOf+XxWx6wwz6j7RwCtp6gpAYngxJIivNnl3dV9fqI9wd/723+d//Wf/W8k/Q6xctG+KvSRJqUmDTEQxWm5FBcmL4qULOV4WaLUEGuTkT9XAcRqjQ0ViRJMCMtcbDEK+r7Ey7R+cWpItMZot6IpJYm100VLCle+LCo5E6aEyAJBXJk4f8IliJe+73zdlE/SqGMM1NIYp9OzYI2rRSxhLxK8uhZxeCYkTnRWNUQgpEejPsHxQyGHb4x488oyqpugjKUpoGYt+8ISxAN85bR9QmXpcoxFSc/5atkMn6zFUwopXZ3jPOAG64xiaZrihyE6iQHJ7KGjhLUGUTTE6IRoFOGrfaRokWjNxOQM+3u71KYWMDrBC+uEjSaDbocgCEgMeIYi9+HJB06zMDvN1dvrWGtIEBid3rd3MH93ynmYpYFBIKXzD3PVKCr0vIJ942bIMTQqSVtG7MTYYaW5tiAs1XaEqOyrkrrq+14Sv7vnysuvW5Ko4pp32wq8qOJk9edxQlto/Exx6Upfx8ek2u74p2oQXJXkluh+90T7BztebdHtEjnTzLhrjqFSlAc5f+iMRIrSI7x63XvZ3kcQiEFLhZYT2MZhfGnQO28ihWB/r0e8u4ywZ7HbHWZqhuXLX0FIg7l1i2Rilv1bF4m2r6AmY46ciZhamGNx5gRKRbz+5hucffgEF158l8MPanbP7/PA84d45x3DU49N8iNHF/ipjz7DXL1N0u3yj/6rj7P65k2m2gGra3Uem1pnb7LBq7dXORNo0qDHsx89TqvRRtXrnPHq+HNN0qcaaBUysTjPKI7YXBmx89Y3uPat85yuSRY+eIatjQ6f/9o1HvtUwLcvrPLnf/Fn8GoN/v2v/C71WsjxkyeZn51h78IbxNs71Bbn2Rul9E0XP22SxoZOH4JgjnZN0dvvc+rEYaQQdHc2mJtuUWtOsdlZpj45Qy0QHD92hMWjD/CZn/4M337pFf7p/+d/YflWjA46rK6scvrMAyg/YKIdoLt7jLpdYu18ihJrSa0LTKkHIa0wBGPQaUxqNdpYApES65EDSs8j0dNI32XZj+M+UkrSNGUwGNBsNvE8D6VcaopSMyGQ0uNnPvMz/Mff+E2SOCGK4/sf+WYtYDDWOYgbKEq6WW0xzjmwwkJKk1p+ehF0ICpzckydV6FzOUpUTJP2roAwLmGO5QGsmilyQppLpRXzw9jfssVMWKxA0bharLLPUuTyunPgsNVSa+XtFJpDd5tV83bV6JDx6mwcSrlAFM55UsoCrKuk9EA3DtyvLaXufBGoLkimHNsxe0e2+Fmy1EjvA/T+tJsnPazU4FlaoeWDx2r8y5e6fP7zn+NHfvjT/IN/+N/wH//jb3B9dZOd3pB2y0diGY4ilFXsZMEZLvK+sthWxiSP0E40pNqQZsHYSgqGiSGxEAGJgEMWBsCeMHnFOSyZDJSRgDAM8DwfgSHIEhdLYfGzz9o4zZpQEmMhDHwOLy1x5IggUIatThfphRxeauOpgKi/i7C6JODGpWNSWG4OYWVP81ALbCoQQoFQiCAg8Go8eXLIH79yE2nhaGxpC4FScLyb0BsOwHO+o0o4VxUpQUiF1ombm9Zk1XacUGdxqXZ8qRBCIjTEicZaCMMaFovvCeYXF9HaMBh06Ozt43keozhhqtHE83yaEzN4vseg16Veb2aLrMIKJ+ha69LRENZRfsCTTz3Fu9d/H5AI4xJU/5fYKjSjOonuQtLGpDPGTqt+qQrId1gRDpCaos0Kgapq+ir9GvtcXFcUfa5qukphtLzG2DWp4J5w5CfHPiGKX7M/JZ6UJFZgc4Xt3dxOqruzNsaaKm610pcD2r4DR1I+jLxvotydtVIl1/nHMS1o5bS8VUFekUUg5IEynv+J7d5LwemUaH+VoP8nNB7+OJFuAK6CtgjrLB1aZAtIgxr1uZRkMyYaroKaJb2+iT+V4tdrNOwmp48/xpe+8BWu1d/GDyTbqzGzDctsU3Lu1GnC5CrthYh/+NEfYGFfcHpG0VtdIT50lNXX3uXyt67imwjv5Byz001qU3M88mDIY89MM1pZZeVl8HsCP+ozMVHjR587DYMO9UNN+iPLhU6P3/39r/OBhw7zxEeeYOXCZa5u9zncjfji566iRMSZ4wm6Kfgf/h//hJ/8xFPMtkOWlo6RJinXLr3LcH2d0KvR3dzGy6Jy27UG+7uK7T2D8AXvXNrl2IOT/Mqv/hYvPP8kD5xc5PybV4jiS/z0n/2zCCu48tartKaXCJstfv93fp9er8sHnnue86+fZ3dvH4NlNIi4fvMiJ47M07l9i1g7iVuTESCpaDUCDk/WmazX8L0wM/8kaGuJRxA02ySqgfBraOlqi+YaFN/3GQwGpDottIBCpGitMufS8qU6e/YcH/7oh/js733WRcfd5+z3uUbMhcHbwm8plxadlCQLECzNu+MzSFRaLJRSVeCroguAKH06KmdW/o6biseqV4hKyo0qGHOntJYTvoIcgTMlukbLa9qqace1V14jv4GKtq+C9Pl4VLV6UJIoJ51/5+dqK/3Oo5lzMptf+W6QKvL7K8ahYJEUhLhkQpX+j2shqkS78Lm8E3G/b1uSGqRSTtgQloePtDjydp8vvH6FZ1/4KJ/5oR/n6Scf5vLli1y6sUJ3b5u4u8vNtU2u3d5kdxBhEdQ8wVxLMdHwyKV4rV2CZW0FIAk8SbMWAsaZZZUgHSYkNiUQgvnYEgBKu2T9QeaM7yJXLUJ6SAxz7RqNh5bQFpSUBIFPo+bT9CVBzcMPQ0LfR5KircRTPloF6FQjdMpEIyD0fRJcX6cnGyzOhMRxQpIYBqOUONYYnaK15sJ2yqklFzgopEQLkUVIa45Mt3lgsU076jAhYhrKogRYDOnmPtYXSCyB77R9QqpSELLOrIxwGq4w9FEIPOGVbhPZO6RNSuCHSGuQvk9YawACz1d4qs5w1EV2ekxMTmO0xfNDtNbUGgI/8ImjAWGjiRUC3/PRWqNUgDWGSGtSC3EK2NT5WH5H4ev7tYmKu0jma5w9e5GXxaQqdFJo2t3nqkyV4+C4X934xMoESMbJWo5X1Rx+ebBXiQTj5+UCjgsUdwyoyC2aX8dW8ajsw93oVdmNUnSu/lCIsaZ6bDGKlX8P/C7KRsbgP1sP8rKOd4ybEEUwW7Xnd3bavavFM8nHsoBEQf6vycezeN6Mp4LJmns/WPg+wpYMsXUqcNPZAVawegTSEg/7XL+yRaJ6mJar1vH4j32It/73/xXVrKFTaPUG1OLL7Jk+Fy8m/OjPnWFqsk47mOXX/tWLPDJznDWzx+WX1thb7vDJmWPMvLPF+qVtag8tcuu191Cj1zj71Ekef+Ek4XSN9rGjGG2IV2/TfXuT1vERQcPn6NMtdt++zPLqkN39JRZSRf3hh9j4wpvU5mZ5sK74hFdj/tItnviFU7z64RNce/ECy6vXOXFO8ehPncab2uSTnznN/Mt9jp1a4oemp/j6Vy4SGWdi2RIehxZm2V9ZY9bzsMby/CdeYOnKLVZv3+aBMw9Rn55k9fZlNq5f4TeuvMvJB8+SJIr19TWWl1eI+3vE3V1++uf+Eu2pad545wa3b93GExH7nX1GcUSaJGzvbGGtYX91jXiUuHJOAoRQTgtmDdEoJlCSVj3E9z3n8J0ljzVSYvExMkQKhbWCrZ1tNtbXabaaaK0ZDAYIIdChzspVSZIkwTsQ2dZsNvjoRz7CV7/8dTa3tv4LVD/KtUaF2JQJqiLTClRNlBQLa+krVwEQgTO7iUxLmM9wmzvDW/KQ01yPOG6TrJC8DNjG5t4BrLrDt+bgfVXaHQOzMQ1iAWV3/HYn6yrhbFwitxQmFih8XWRmQqueXurzbHnvlXGsKuXutnCUJh93TjXnVSmo23yVooLWxf2UZJGs36bC0e/3ogv94RCPgIQIUfOZnAh4/EiLd97aZ21g6EcJE1PHefS5Izz6nMEKiU4jBtu3efnb3+T8hYt0e30m6orJlnRlNbXTWCWxptMbsd+NGMQJaWJJUu18HKVF1AO294eAJRCCunVCTyjAszABBRGQNksSb136qGYtyMptCjzPI6zXaDcD6vUatdDlclVK4vJHWyINaRoj0gHHD00yGFo6EURJgo5jPB0Rpym9WBBHMVYbwJBqy7ujlMd2LLNzEo0LMBHWwwCT9ZCffeEU3+pdZsdClOVNFL5iqGBWQOA5CwTGke180TMu+SXaCpSFaDhylUKiCG0MvucjPQXGoq3G+IbAVyjho5SHBcJaAysUvWEPI31urW4RJ4YTRxYQInHXQxDQREhQUmGtRkofKRVJmoAQrKyuk6aZ2Ve7oJ/7uzk/Nfd/BncuDL04Iq9glOOYofT3dRzjzjrad6ctmUBZmfuloJn1ZSwgTWSQ4SbwHZU8TG6FsQVWV6y/pZcN49eoUDn311YExww/Kmg5BifliXbMXaZQENxNbD2oGAAX9VtKoNm+uzz8QiMoxq1N+dVslgOw8nzydcjtKolvSVEpRGSTuwjl7kKFteneX8R7JoCedPmshDIk3VWCRkCeR6q3t8f2pdfQJsSbP4QZdVmYMNTECnPpKs0TDdrNmHqgaLYXWLs5YPXSgP6U5vrFZdrNBq3OJn/roXmiqYC3XzLw6j7vDdcZRSmXbm7yY586R33Gp2WHmA7sXlphtLzF4afPEk9NcOPV65xbPEs0tMiNfYLZadTNGP3OCoOpJth3qQtJLd7HWoUZ7vAfv3Kb3fokH/rYM+y/cZFGrcOpRzxqzevYcIH2xDQPfWCBft9y/ZurdDduIFSNURxz+sg8ndEArVOOHznE5tY2b1+8wuOPP8nxh8/S7w+Zmm5x8UKHvc4AJQ17u0MMgp3dXXZ29/CEYHF6gm//yR+yt7FCXWmMjtkf9en3B0RJgq8E/e4eTQvJKMJYi7YWhJOKtXWJghNgmKZ4ngvgsGQJSlON9l1WfaFTpO85R3Ap2Nvfo1YLM0dx46L+pFuM3IQ1aO2As/rq/tCnP82v/MovM4oG7Ozc30ogrig95AJolRsclNjKrcJSqhO12J0THCjLH1UAKIumGwcSW+aTyg7LwaRK3sb7I8b+jBO8/PPBvo9dcvzLAfOMPTAYecKbcUir9iPTWmYrVxFHIcSB+xh30HaHiLHBrxLAcdzO7ysjf3d7VrkZ+G6iq62OSan5rQziXcfq+7n1RzGhACsSdMtDasHxuRBPenz5Gy/y8z/7k0g/QKKdBl35SF1jWhp+5Md/io987BO8df4VXn31NVI0Ji7TtaTGYKyPJsXahDQL5rLGYpxTF1s9zUzbshkIUqTz55OCgYGBtaCzBcJoBlFEoiVSCWQSY0WKAEJfEqUpWjcYxYYwiPE9gee5ihZWSIaxyxE517T4UyFJUzNYHbAzSAmV87lLjMLqFGMFGoHVIvM7lHzz+j4PHptkGomwrsqTCnyI4fSRWVo/Uef1mztc62m08AlqHtu9hA8phed7WGNQIq/1mwf7SDcWwpL2h1y9cpn5hUWmZ6bwPI8kTfAKAcqQpilhECKVeyGlUFjpYYkQwufFV17lpfPv0u8P+KFP/AAf/cDTWRCMwgaaVKdgDUma4vkWazU61UTDPsvL684VCpe7Uer4vr6HuXlQSkEe8yZzQogtvTOKeVJlE2UQyLglgVIAdVehnGPfTdiq+OtV/oeKn2Lehqi0VBEQC61ipvETOFcAIeUdv49tBY7bse/uVnI3mnH3nMJqkCkTcteWcfwVjDVZuY7TXlbIaIWslfeV38fBcayOZmUwBJlCIr/Nitl87DxbjKewY4OZYe+9C8XvIwhEoqRAenVscAqt9/DELlYb6l5M5/LrJDdv4LWajHZW2Wn59NZuI/wR6ze3WFya4s/8zE9x+sxxfvnKv+X3f/USS6dr6Ejz9MwMMydPcfO9Ffxel5Y3QaMdMrMUIAOPz72yzmBlhYXpJUzQYnLGsL/XYuO9VSanrlE7Os/UQw1S2aExNQ0zZ+hfvsXEk0fodhNe/KPL9DtXeeTTz3F2ocbw2i1mlSUcxvzmv/8Wb796i9MWmp7AM84cYUg5GWh2tkb4YYvnHzzF0doIm8TMTbWI4oRf/uO3CAOfqZk5BqOE7e1dpEwZDDTNRhOTjHj60RP0T8wQp4atjmZ7cwudxMzNL3Ly0CwLU3XajZC67PLMqQmeOPYQWM215UWur2zx6ptXGe3tQ+oka41wWeete5G1cdoBrdz+xGpqFqf9y4id1vkEtwilSLQmCGuEYYgF4jgmTVNqNY/hcEij0chKw7nIYGcSdg4T1lqmp6d5/vnnef21C98VEr4fW678s8ZisxyAIvtHGCeJWZEXDIcSFkoAHKeGFQmy+LGq7q+cn0toFRy9ax/zjlbm/Nh1bEmWvqMPoC1/c9s4wOR3M64AtONgM+avc9DpOydRtpDWi6z8RVoVUYzY3e417+uYY3d5wXKc8q5U7rv6WdjibrLvlXs8cNO5mShXbORAfvcefn+2VBvMKEYQoeMQ5Sue+fCnmHrrj1lb32J1c4f5Q0ukBnxhEUiwAlWfwqYDWrNNnv3gRwlCn0tvv8Gov4mwhuEwQceGOIpJ45goShmNUuI0dVq5bBCOHpqk1giwjzbpWoEfKIK6x9b2iOFmF7uyT933+MDhBk05YiQUYQATLY/3onlUWKPZ8Gk0W7TabYLQx8/SRGFdQmUpBElqSJIYzybEowHdaERQ95m2I6xOsSbFUymhSpFxikkNkpTDU4JGzdLdGbHdH3HMaNApWmqE9FAyxFOGw3OKo0uzbPZj3tkZshr5dPQuypPOimHSwg851SlgXfm/7H3yfUmjFqL8gLBWJ/Q94sT5CWpt0FqTZoEownPtCOl8C6PBkJsrW0zPz/HEY+cY9IcMRynGghd4+EFAHEV4wDAaEgZ1V/9dpyhPsXz7Nl6yxfOnm1yLj6BR6O7afXsHy835vuXVUsZITYY1VVIgwAXl5HO1kFMLye6OK4ybdkVlnxjbVzljXFAc+z0jRTIP8rhTqLzTf7BC/soul/hcIXbVv3cjXDmmyMJ0VZVEx9uoYszYJQvCVvbfigPkq4K3B/OsFkOcLzK2xO3C9FtcvOx4zn2tkO4cAcJKZEZgJS4wTr4Ps9y9J4LOpDIxfYZITGATjdVDUjFwyUPXb7Hfu4AVBmxK68hD1GoeP/uZH+FbX3qFv/f3/j7PP/Ms3d11ZmWLhx6c47EPT3D7/A6nuhFPetB87CwXv/0uatSHVovjTyxw4/wGn/jAKVrTHnqY0Lu6hq41OHpmEb3UIEAzWN7BT/uMdtew07NIv0G7VUNevUaj1kZ/YIFvfmmE5yXUTh9hvZ/ApUu0F5qcWphkpiYIkllGw3VGfUlvPSChRrC+xeEd2E4l793s02zNE3duU6vV6EcpR44dxm72uHbjFo1mg+FgwMraFs16m3q9RprE7PeHrG72WN/cQwjJoNdlcmKCh47Ncu70EkcOL+Apic4Kq9frNQaDEa16yPrKFoO9fUyiXWqDzMSpbVaH0xiENQRhwOHFWeqNGqkWTkNonRN4nr/XCoXwfKQQxKkmqNXxPA9jDFEUobV2TtGjEZ7nEQQBSimXH1CV0cDWGjzP59y5x9+3uvl7s2WECSpkKSvEblwQyBj5q6JFRnCKCV2ZiFUCmBO4nFCJOyZ11fSZA0YOGuPgM3b9yqeDQCpEtd2cAJoM3A3WGnRFxV/hbeMAXDKwcdgdw+hMeswSNbtayrKQOHNwHpfU839s0eBBYn2w/cqhRRt5dvtqip683TIZN2PPptqRasqeqgR9P/MAWinY3e8xOxmSxoZwconZxz7JiZOXuXDhXW4tr/LII2dxGfp9Aunq7WINIpxCpzFeTfLE0x/iwQcfZmXlKq++/CKxGBF6KU0VI7yIoJYSRQmjOCZJ3fikRhCGmvnZCU4dm2OvMyTwFI1myPpgGRkkQAdtDIsPH2Nuykf6Pkppwlqdm6/uYaVLWaKUn2mPsnmRvVc6SdAmJU1Mtt+QGknGwbBCZYIWzoRnNe6L5EOPtTh70mNzK2GnJZmeCJBCIrHoKMavtTFGIJR2WkMNC60ak2HKSn/AVOrRIEZ5AcIawOUdNEbjCYm0kFpNqDw8T3HizIMkaeoqpyiFZy1p4tJZCQRJmhLFMZ5Xw1cSYQXD4ZD9bp8vf+2beLUa7WYbqWBxcY69/Q5Hjx7GGUtdGp1arUmtVmc0HBBHI5r1Or1ul93tbW4bwVqvj8Gn4SX37R0ECkHYCFNYKVx1CHImWAhHVZQuyEY2Se9EC1viytg8ZJxIFt+r+HNQCKwSo4p2MKs0I2S5L7+nsk+VdmCstnvRpfIfStcZCkG7QOicWFVvpsCnElGqJNSZ1SvkcJzHjq98oux7TuByEdqKauGB6mCWfcyPzftZPKPiQu6JFNcUokz1kwvY31Vcv/v2vghgvdlC+06DlOJhxSS1Wp9AKKY8jWiNeOyJRbxQcO3ta9iGIRoO+Fs//yMcn/YYRUNef+Ndbu6u8uwnJpnY7/Fjx6a48I1lvvm51+knmq0oYTSMeejsEqc2Zzh69jD12SnSzoALX79AeKiNbM0wP79EcChluLuDUSn1I4/A7ir7K2uoMMXvpwg5RRA0UbWEJ594gIc/8QzGT9kRghc+8wxzr13n9pbhIz/+AYIJy2BlFULNzfN7mOYct2/u0Lu+zvrWCCUDHv2pv8QGD/P5P/4S0bBLe+YIh1SXi5feI6yFzM3P896lK3zohQ/iBx6H2i1kz+fllU129/qMhgMmJmo8enqJ+bkW+70R7U6XVj10Ged9n/M3Vvidz73M7eV1gkSTWJeOozbZojeMQAiSUVTY66SQPHn2OFNHjtNWFrpdUpuirO80OZnWJFdxa2PQQK1WQynlFpXMjyVJElKd0Ol0mJqaQgiR+SZpbBYy5UzFgnPnzjK/MM/1Gzfv+WX7Xm4OnCp+eRVkqALEeDAGVUZWHGSzFt2fzAFXVEhQybSKa+dgUGj0KgTuYJLnUvIsej42RV20YVXazftlx//aPBt97vibS4pllvoCUKpEsGKScTV/ZXFfJcEtTTSyAsgHBysf09Lx2JbITD5u5Y1UgbwYh+pzyVW6lPdN+a2ywxYnjy1oeaP3UQ7Z7AwhtmgDUQpLj38aHTQ5++ADvPra6wwTl1vT9/1ivOI4oR4qtMm1eRK/PoVSHudmDiFkja9/5UtEQ41AupxywvniKuWhrcZqgZROoz+KNVs7PQaDGGMMal9l+f6cdSA1lqurQzpDgyBCKIHnp0SpSxNitMBonfn5quwZGvLky8bggi8saCOc2wjOPzCNE7ROETg/Y6SPkJZD7Zif/qmHWFqaZmt5masX15hJas4fWVpElhbHKIkQIUmaYJKU/STFYFmYbLNQ0/RW3yaJu9QmZ+jPncbYrA3fub0o5YNQGCRCgtHaCbD1OmAx2ha+b8JakiQlip2Z2iQpu/vbKCn5yR/9FFbA9s4eF955j5WVFc6ePoHveYwGPYy1hGGNeqNJEkf87h98gW6c8vEPPM2NlR2GacwHz7SRIuCtm1EWuPNfaqsAlLXFdLnrls1FUd1RtFGdcTmwlZJcNWACKN02xgTEqlBLqR3L2y2k1xzXMkGiImgXeFnJXFAV/GzlkhWjAuOfKiMgKkSQO8la9fBc5sxBfox45hcV2XiI8pixoaTs193eipyqlQQwG9vinFLZ4Iak8oxyLeWB+ymrot/7e/g+ooA18ShiuPc6snkYFc4hvRApAg5Nws9/NMCeeJiPP/0zfPHFbX7howMefOgML74z4Kmzp0k3LhBvhFx49SU2bm3SflPxwdmA2zeW+emnF+l2Uq7d3uAjT53k5l7Cow8eodYIaDcMJjSMrOamrvHjZ49DAElnh1rbJ/XahLUOwfIlRvi0m3VCPWLj4h7r633O/MSTLJkBD3/kWYZrq9j1bZ548CjB7CyLZob5UUp7QeB5EfWjddT0FKbRYFL5PP7gIbQ4x9Y7t7m+PaSX9jg+McXkaMizx9t8c6vLu+urpHHMsaNHmV88xESrzWA4JKz7dLsdnnn8EU4dnuP8OzfojRLevnyT5fUdtvd6nHvwKMntEUcXZmk0m/RGCb/zRy9x9fptfCHwtEDbFBEGHDp6hEvvXSUajHAqY4sfKE7NzLDX1/R7HRbTmDk/IEktnrIgJEJYrPQQ0kcAWhvSinQGLt9fmrrovcAPMMYyGAyYmJiA7Bzfz/NvaZTwefjcIxw+vMT1G7fu+WX73myWQjtncX4YlnFSU2jAK5nTyeduqQEs8bqqKaxcqarROzC3xr1kxNghVH/JpewCaLKeiArlqpCtQmK3VCZ6DgLOfFXc4IFj80CXPEdg0YsK8az8U0q3FQkTMkfxMdtyhfjlR8lSizjWTHlShRhTwa1y5Ma1n+46uam4RM+xpYOq6F1oXRl/Ht/vLR7FNELPlUk79DDy0MPUGg2OHzuCEIIL77zLpz72IaeREp6rBmM0iMAFcwiXMie1Arw6Uhgeeuw5mu02l956kzfPXyCSCYGnMNqgtMYTgshqjAZrLMORpjNISBKNrwRJnBIlafG+aWO5crvH+naMFyh8z8PzDL4fojyBBuJUo+KkSPye55Fzmj2JEBJjU7c8KYWQmQBpymdikECCryznjkuuXrxC0p/n9BOPMTPZZv0bmyhE5qvkfPmkdX6N+50OUaq5dHufK9sDji42ee6ZcyRhyFa3h7l9GU+1aAetTMvnyrMpT+F5nnvmWf3oJEmw1rpqHFZgYwsmdfk1tXZmexMRRzE6NSRpwvT0BI1Gk6OHl3jogRPs94fMzc+SphGjKCKoN2m0G9gkYWX5Ni9feI/nnnqSb7x6gXfOv8PFmxEvXelyqCGYmwp5+Gj9vr2DgCMgsiLYuZ0ZBtqspjcU6Z9K0azAwmLOwZggNwZ3d5gUD7qTUMzTqjtIjjWFMFrRBo7nAcyPLzFqTCgtO3zwqjjszvC3IlTa7G95LxWMz2VJewA3CqgXlbPK/RUqXFzvbrrVfITuDICrHpljmaXwH7SUf/NnNSZU3IGwY7Kv46zfSXi/+3bvBNAa0jTB2ATbvYlMBqjpM6B8otjj+Q//BGpyju7abTpXX+Ff/94t/vbf/SVm2wu8cekmxycWmIkNf/kHHuIzRz/GS1+9yFc3e7Rbdaa3drm0mfLw8VmWTh1i5d013n3pAsNZwex0nUPH2rSPHub503W6232mjs3heSDDNrO+JW2B3tXUQsXutX26/RCxcIxDSxFx5BE1TyAl9JbfozNqc3ZuElH3WTojiTcNV3/3myyeXsSqkNE7EdMnZxBek+31Hr5JmGqHTHcFurvG7vJbPDPZRXVGTHQ9pup14pqHb1KkTuju77G7t8ODnOLSm6/zbZPwFw8pCObY7fUY9Ib0GFKvh3S7Xdr+BNdubzDZrvPKhVtcuX7b1dq0EGEJraQbJbxz4R2XENW6HGHH203+3gunOTSI+VZq+YKJEUGARZIaiLVGWBf1hvIQSiJS7Ry1pWBjbY3NjUMsHnJll4IgKLRKud9Nr9ej3W5n6WIc+TPaoIXmtddeY2V1rahmcL+2aqSTkxxFKYnJzI+t8C8ZJy7FVjVjZBHA4zhQCZ0oMXEMGMpj838rvxV/KgmfC2Gv1OKZKmDl+01+b1VzcIUIFqcc8L0b86kpASXvls3bpPxOEZiRnXtAcqyCtZJZVKaUY1h8B+2qgk9Fcr4Dkg4QTAd6ttJgCdi53uHAYyqvUUXB+7C1ah5hoPA8ha3N4Ncb+IGbz77v8dk//Bwnjh7hZ37yR6kFgXvOQrjEzEjIMgkIpVAqKDRjR089wcLCMQ4fPcYff+6P2drZd++Gcfk8TVYKTgM+0G4E7Hc1rXoISrK51cvcBSxaa5ciQhiE8ApHekOZJsUag9GuWpAUHlYKrJBIIZy7D4I0Fc63T7jgkFoYkKQGrS2kMdakpMZSUwmeMQy7MdtrG6SjbxDs+8hUIfAwwxjaLWycYgd9BsmA7b0ev/bKKjf2DaeOLrC5HfKr/9s3Wd7uMooipICl+Td47omzfOjDH+Xw0SNYJQn9EK1NFtgh8IOQwFPESUSWKRwlHWm1SqE8hcCZhpM4otZoMIoSrl69yolTpwiUpN/vMTszC8YyiiLCRpNWq42OBnT3trl56xaTkxOkJuXy1Wusbm45n2wj2Oxrukk8Vi/7fmy5AJbndBS4aGuZl4DLSFSZQPjO8w+wEorcmmMC5N0+izv+LYkbBaZUyVwh9OYEEFwGApETprzP+flUzrmj5yX5KvDsTl/q8d8pzytwtGqRGR8kW/0whj2iIKV27DRRPXxs7RinzBVEzK0ftnJ8hajm6GfJxyafvdXOjZPY74sJ2Bjrwt9NVlB8sIHHgGiiycbOJDvbMYO9Tbxhh7npKT7w/DTPPXGCfmefixsLICDdWqa2cQu5u89jJ6ZYWJrj3COzGJnywtDwm7/xFruvXUcrzRcu9miT8qMvhPRGXc6Fu7z04hoNc40zSyGNlk+tXSPRktFOB4ZDZh9fYubJR4j3B1z+8jXagUe7XWNmaQYRJ3iTx0k2d0nlIQJPIZuz+PEWx547x82vvoOvDad/8gV2Ll3DEx6TxxfR6x0ax5Y40kx5aHqe+uFzmNE5vvxvX+TC9WWOqwAwiK1Vbm2ss7LXoT45yfFDs/zA06e5cX2D1/d7qEMhm5tbjEZDwjBgNBpxe3kLa6BeV3R6fd559xph4JMmCZ7vcez4IS5fX8EOR8XCLYBASB46ssSi9kh6A35wQjKIUm7ZOrLZQmtDrCHwASMRXuCSmQrQaUoqDTtbW6yurIC1TE5Nsbu7h/Ik0WiE7/lMz8xkRel9lFJOks4WlzhO+OVf/nfcuHEDy/0FvZwQCZEnaC4ZgCBPDG0rc6hgXqVEWkyRHBmrM64Es3IeiaL9OzRSFQmtWt8jv9LY94ycKcBaV73AGlNMbokAZYs+j4f2U9kPecqFwgRsylQvd175IFCXZNFpeqrm4cq+/HazzzYXm+E7Q0xu84YDY0OmcMhodKZ5sDZvstQu5qNdsYqTJyQXgqwkbmnmtvnY3qctCD2adZ/2RI26H+EpiR8GbGxtE0Uxo1HEm2+/ww9/+pMgJ0i1xgrpnpF07hiptgSewgofKyRpPEQKDxW2OHP2caTy+fX/8Gv0+y4noLYpWmfETkOcxPQGCb6nEMrS7Q9JkxiB0xAbbOYl4sy72oKXP8eM+Gmt0cYrxlVKVaQ9UcJirMDzFGHNR6Qppua5oIiBBpPgiRRrNVonaB2zvGFIU41OA5Qy6NuCelpnNNijkSo8FYIYord32PVj/uDCBvHkUc4dCfjqty9wY22X2LgyeHm098Zun0s3Nnj78jK/+Ff+PKfPnC6EH2eqdvgjhSRNNEooV81EKoRyM6HXG9DrdWk0akxMTiKFYnn5NgKJsJJRlFBrtvD8AE8Ims02SiniQY9Bb48kjXn74jXOnT3L/t4ecZzywScf5/f++AsuStuClZYovY9SSL7l2v7S3spBkSufsc6fzB7AsO9sv2CslUpj4gCJIW+zurfEoru1Wf2pwK3qhL/r1Stm5ey83OohbI4DttB42qr5+jts4yOREcf/JJaMo+rY5zHSd7erHBB88305GN5lvO5UPNzte1UZce/bvUcBAzpJswgiF3Oukz69rubGVpcnkhGHDx/FDn2kqnN74HP+0ipL0xPozg7Tao/F5DrN6S16qsWNr93iq+evc+Er0IlSHn72LB/84HH+w384z9W9EUNjObsYsL0VkQ4Dpldj5s+dpiW6tOspjXYLO3mY+kyNnbdv4Q/28U4cxas18CYmePwX2tCToCWqVcdOTDA3cYzbr/wmo9e/zk63w/ShJiKYQq9vc+WtdTxiDj15k5H2mZ4PufzqRQZvr3H46GXC44dA72Jqh5GNNmeeP0P7lWVur+1yJJT0E41vDVtK4Mcjvv7Nl/iZH/4gj55d5NINxcbGFru7e1jrUgvYxHLt9jrb+33azZD5mUlibXjk0VPs7vb49A88wssXrmERLsItVHQ6faQQyLDGS9sdbg4THhCWj8saJ47OszvySS0k0kMCqXFJX4X0XK1Aa9AWRC0kioe88fLL7J06hRd4COXTaNQRQtBoNAlrNdqtFv1+D4AwDAFLkiS8+eYFrl69WuQuu59bTgaqFMcaVz8V7YDY5rkP8oRKVAhIdYKIA8EcFakxNy3nE/rglK8SzAJC7xiMckKP/+YalUKA5915XsXkSqYVzDV4RVs59yxI4kHJrzSxFMTV5kSpSvYqZpkqTczaKyXpg/BiD0jFMKY3uHMdKu7tDgCztoj8LbWA+TPM+2WL3aXZN+/a/X0J68dOMzs7ycyxIzSWzlGv1xBC8vCZB2g264xGEe9ducbubofDi3POPKkNQjlhJdUGIb0i7U6SRI58KYlLptLgzMNP8MEXrvOlz38enaSkGBTavdPC4ouU0WAPKSQ2EkzFfSbaht1A81a2llidMhr1iSJ3oVazQb3eyIhAgrABSiRI62EjifI9pB9gPR88D2MlAktiUhQy03hZJxB6HnFsiI0lsdAfJqxYyyDS9Iaabk8zG3kMI02trukb8LdTrLaEdcn6XkTj1LN4acyv//6X2B8MSa1xid3J3ttMOzOKNS+/dYXar/8O/+C/+TvUajV339aS6BSkJAgDVFFVxfUzz4Iw6O4x6HVpt47g+QEbG9tMTs8jlCPSWsPURAusZTDs0WhMopOY0bDvoqC9Gvv9EXNK0aiHdLodDj12Gs/zidPI+WlKyTC9f0JIdptYsmBAsjiQLCKYPBG0KA8uxN6xeXk3fVEhZbpnUSEmhctNMT8pSWdmebAIEJrCP5tS+C3KleWpXTJTcXFswRsruJVtVfJ3R3dz4TjvO+OYe0eEsD0AG9UxKYo/3UmNC2gqWF4+LnchfAf47N3IpsPaA4FthYN5OV5jYzAGn+UXIcR4arJ72O6ZAFpMVtQcbGYO8D2Fp6BWb3CoZVjb6XD68AIPnjlB76vvcGNlSJxOcPPWbXTvJtHqt/BUyusrmtPHpxkaj199cY0t3+fvPxLTGI7YiQTHT8xz8lCDWd/jYx8+RasREs4e4lh3i3T5HaJ+xLDnc+3Ke8jOBk/+zAsERx5wtW6Xlxksr5P2hySRJk48vNYE7dkmsTb4aUL/xgZbE9Nsv77B4mKCDRucPDvH5KFJ/v/E/WewZEl6ngk+7keGvlrkvallZVaWVq2qJdCNBgE0QOwuMRyC5JBLGpcz3F2u/EHbP2O2NmbLIW1muGvk7KjlDBUUIbqJRgOtS+usyqzU4t68ebUKHUe5748jIzILqCK6k56WNyJOnOPH3eP46+8n/PvMWpWZ2Sof/NaPufjuBud/7jzWqQX8/T6yXMFwxxClOgcfqfHMp9fZ/ncf4qkI05a4CBbLdbR0qEyM8fI7Nzk4XSXUEcurW7S6HkLHu98MI/ar8IKQ7taA/VYfy5Ts7uzz4nOPMNlwcGyDybEqtuuyvrWL6zhgGISA3+vRHQxYMgze7PY5EFksTs1iqIhQC2zbjsFaCoSKIJIEUbxLzRQ2ENJt97h08RK1xlhiSpC4bgnTcqg1NqiUSximCWhsyyGMFJvbu/zuH3yTO3fWKFfq9Hq9T/TA/SRKZkZIPpGCDqmWMj0z94sDSHe9FudOboWNKUVGKoYm2SjkFAhJ+rFwmi7+SevJCFo+QaUUWZuG6kxOi8OySPJ0ng8wcRSI39DGkCFqmgxTaipPFo7U3DwEGUV+PNploBhHsRg/MW/3nyKtFln0kO9RXm222CTfSWQSbyvx+xTZEpIQY5WA+cMjgYde/AbTs4uMTc1iu2VCFZvvP/X8syz+zh9w9dotbt68xfLKPY4enE1CM4BAYZes2FQoIfADDFMidYS07Xg8pQUGIEPOPvFpfviDl2jt+fR9TRRE+MnO/rpjUKmO4wU+bsVlujGN49rozQ7y4i6h0gz8AM8LsA2wDYUyBdp1QViJti/W9EZBhBeGGEpjRJLAUAgRxGnWoji0SxR4BIM+3YFPEIYEQRj3Q8Ta571ORBRq/EDgBQrPj6iNN2g4NqHycepV9vdazJ6cRgYmu50G/a7H7/zhDxgEIaYREzqlcgEgDVUsiF2Q3nn/Kh9cvMSXv/g5BIJIx/PdMCQqDJO4dzk2SCkIg4hSycVKXFwGnk+316dWsejsb+H195DSpBM1MW2bwSDEcUr02028fgfbcTAtm5/78md564NrzM7O8pUvfJb5iQol16Xb9wiVou/D+kMOiQr5nE+tzwKSwNsUsKKAQ8kcEg+cq2TCZ/o+5ncxtoIohGgqaPvSPxkLSoTPnM0Nkbx4F7DKBVSRZnMq4GMi4BZNo2m7UlFUp7iatVlnfdRkA3C/K81QRTonsNlfkZ8nCtWic4I1QgCLYJnhbvbV/VpWUWhrwp1zAVwXrxr26Yvl3dwNahhUP3n52ATwhcdP8cH1u/FOVB0n5zYigWlL/O6Aam2G/cDl+vIGu9dXmZ04zL31bf7olVdYuXETY32Nnz1f4VNPHeIrByIWzkyzdPEy0yePc+mWz9pOj1NHJvk//t3PcejQJKYx4N6HW4zVbKQl8XfWkWYf6+ARbAmRXaP73gp39/rwe69w/PwC4+cOwlgD1ZN851tvsXSvybgDDVtSnRrnxCMHmTkzx86FJazqPlPPPkHrw9ssPjPG2FfPY9Tq9NbvEWz3qD95iC985TzjlqY0W8OcOQfCQCsDpVr4myt0V+8SdDt0lcbDwHYNHp+aYKnd5cbVq/jC4spVQaQEbqVOaJQI+000ERaA1vR7fZAGqu8zNzPGZL1G2RS02l1caXDq2CJLK1ss1Co8cvYQr394l+1W7OsTRYowCPAHsNfpySey0QAA5oFJREFU4hgOi5MTCAVKGqATc30UEEmJpxSRUvTXNvnw6h1CbWLZZaSxQbfXY3FxgUHfZ39/D9t16A/6aBVh2xazs3McPnqYK9eusrO1w/TsQcrVOnduXv33evD+fCVHhcT1L5Eki2QphoHUbJ0fScoQMStIiEWyMoKN+TwcBc372yeGESAhdLm5NdNiFhnafbXonNzonD7mMJn766THYn9tMVKfGG5PWk/c8WwRGTolZ7EP7qsofBgSkUel79E6CoA7IloPYeqQmTrvK0JkJn4pQGmB/vfDvn/vcvTM05hWHAg/UCoOfJwQlWeefIxrN+6glOKHP36Z5554BMs00RIG+02MXg/TNPGDkJJTIt7xG5uFY+WKABEHTR6fmufzX/oiv/O736Hd7xAoiBSoSNDtBWi9T6gFGoOxep1WR9H1zWQncJzJo+aWYpO1a2LaDpEGP1CgvdhMpjRJFBjMkHj1kQYQoZQmCny8QY9eb4AfxCFp/EDhB4owiPDDkCCM6A8i/BCCQOMF4AUmB6RPrSFxSzamY1CfKKN92Nzscbdb5/f+6Ad0+x4YILRINjipbOoZBX8zIQQ9P+S1N97iy1/+Qmb6VVFEFHisrK9i2S6VahXHdTFNiyAM6HZa+F6AYVmEYYjX7zM+VmXQ2UNgoFRIGAVgmIRKYDlluq0dvH6f+ImMs6OcOnEUbzDg4vVlxienGG9UKFkmgjgYvxAC03jIaZES0hCb72PhKZPPdEEwg6KEVhQLP6raB0CaGKpvVGiM+WSBtWkxpBUbsi486Ib3dyyzVmSawvyrrIspsdMqdXnIyd/9JLB4DaODU3gpkMFRiCtqFYdGqojlCVZnxDIhjjoluTmhvH98kteUpI+27yM1fCmuJm35mOVjE8DTB+vcWbbpD3yU1hhA3SkThR6317d46cIlphsVNnclYVlg7q+wfuMGV196Gz3wGMiIH172uHOnyafOz7N9b43fud5lYaxKyYO/+BdOMH56kZ3tgGDjLu6BKQ4/uQBhxN5OF+lqwuaA6vg47vw8olLn85US8oUF/vC/e4krv/EBT5xbZvbsAtNPnuf5v/gMN/6rV3hz3eeJJ47w1K98ltlgmbHnjlM9VGf99et4K7dZ+Mw57COL6K0ltt96n/11n8XHF5k43mB80ibc7NK7voJ65xr9pk9pcRo5NUF1vspnfv4RagsTXHjlLre2uuwGEUuru8hSieMTY1zf2WOvN6BaKROGAZHS+GGs7hAChI4QQqJUgBKSTreHY5r0Bz2qlQpf/NQZri9vMTtRZWFuilDBa5fvEju3aFARWseLh5EuItJEJhsbtDDQ0qDvB+xu7LLfC9hrDnCqdUqVMlNzMxw6eoSS63Jv9R7T05NxbDAhqdUqdHodlu8ss9/c55FHT7PT7nPs5FG6/T773R6eH96XKu6nXXSqCUrNoMT5iA0BQhZCmKTEIZFyVYFEFSXG1IzyIA1SzDtyJ+EHzb2CzJpfd5/ZYxh4UnOt0jo21YxWkpKy9H2hreiUGMZHVRGQHqgFK7Sl+EqRYMWO5MNgdD9xG4au4aP3jUWqCYCPxKMhipq0fShRix4+eSjbUiolx7kQH3yDn1KxHBvDMOPdpUGcB9Z2HKq1Gk8+do7f+Ld/QBDAq6+9weavfYPFuTnQ4JTK7O5s45bK+EGIKQRhAKVSicwkJAyQIs5+0W/zuc//DIZb4//5D/+/hGG8saPX91GRxpaabtenIQVbFQs7hL1BAGGERrLT7CCp0vcVnV4EDOKhFGCbklLJxLYktiUo2SYlR1KpVbFNA0NEhGEfS2iqbkBnt0XZNBiv2yjh4oexMBkGIZ1uyO31kNZAESkIIo0fhtiHbTq9gH4U4kUayxY0t9rcdQ7wndcv0e75hEojdaxhEjoVkuLfW4tUsxU/KUorVte32G+2aNTivL4aTcktEQ16tFr7eJ5HuVxBhT5b924SRYra9AK2beNU6gSDPvXxcSYnp/G8AaE3wPcDtjZWMXSEYQwYDBSW48auN66LIQRRpHji8Uc5cfI4d5bvxr6XEsqmZhBJTAmOfLjPoUBkmJeS+GwzBXFavuJ8FKl0XCRmqUkkBSkxpIfLMDB/DyMzd7hFqfA28p8C7uTf58Je0eSbCnzDm09G38SlKBQXSV8mNBcF+6KmT8MoORyqlCLGjb7Gdx2NCzjapqFxy17jBaeofBUUcgGnFWRtEgX3wOLvMJK1pGAfHzUb/2nlE2wCEZRLNrJjIIRGGhLTtej1PfZ2dvjN332JLz39KPNTExhGiZJqoXZvM7voMlau0drucXu5zc2e5vabazz/xDyfOdvg4KzFP//hNi9d7fCpiQ6/8c/f4+c/PYMYdIgwcScbOFITBRYijOhtbNC9t4aQgtt32xh+n5kJh5NPPsPsgTIfvHyT1v7LTDxyjBe+dpi/8cJZaosL7Lx1ndqJKXQQUpmYZ+5TE+i9NtbUUaKVm7Tfv0JrtYfvRQz2+lTGayAqyPka5YkxwlaLzvUdOus7hE0PYZ7C8m0+dXKKsdk53v2nP6DV9aiULUxlYgiLo406fhTSGQyQSqBU7DOnpYMvDGwBUer0LCN6fY+Jmh/H6JNw6dZdVrd6VEourmUSqTjgafrsSGnilssoDEqVOk61QRw1MA7hoNEMwoDVpQ16fnxfyy1RqVWYnJpiYmqCOF2SR7/fp9Vs47gOy8vLjI83mJiY4MjRI8zOzdL1+rz50ms8dvIwx47OcXNtm81Bk+kjRz72w/YTKam0l2gK4vAHikhJRBSniCKbC9kMQwiRmFxz81A69TL/vyFsKYJPPvGKpw1TIXLfvMTfRqkCEA31IeMveVGF9hbqGJJKM4Aj+06P3n90uBJwSUPDCFEwDMuhXmZ9jcdIJp9HGj4CdMUWDI2HfsCxYt9HHHCKBHkY4lO1w6g/YpLuUKmUwd/X959WCYMAx3ERloWhkoTbWjPWqPPpT73As888zauvvclg4HPz1jKLB+ZRkSLwPJTSeIMBkYZ+v4dhmpi2hQwkpmUjDQOJkURcEJhuneee/zRPnf8+F6/cAaDb7eP5EZOOweHOgBKg231sFe8OrhgwQMZp0EyBbVs4lhkLjICQEss2aVRK1Gol6hULx4p3+paqJWzTxBsMUFTQkaLT2iXU4JgubrmMMGzo+wz6PhqNlBrTkPS8gI4WhEriKej1BAv1Eh4egRfg1F2UWea9W21WtpoEUYx98e5mst/RMGQSiQAiEfvzQewT2OkO2NveoVx2MEWSgk2alMtl/H6cPnNvf4/mxl1a+1tUGlOUvF6cyjSKaDa32Vn+kPrYLHalilIRS0srfHDpMp9+4Rkce4La2ASO4yLNONe6YRnUShUc22Fs0KPi2vzwx68S9LtYEjwFpmnQqFgP7RmMhyslOfHcF8RaozSAsS5s/x0VXoUusJAiuUoFrUzhVtRsFclZfixnlIXvh1lmfm6B+A0J6qSfh3uYvUvxZIjQFb/TIxBQwEedCs8qE/YL7uH3YeB9SCKGKdVQyBq4zwJxn0Jg6DXtY974TKmRfq+LVxYaqvO2pOtDqkzQOsnyrB/Q/j+lfGwCuNfzMG0zCTMAfhhC2WG65rK7vcPWzh53767x1JlzTOoB070VvvjiFF7Xp+9HfP+iYn+7T1Qr8/VPH+GFE3WmZy1WdwN0uMnFG+sY+6u8v9Ln04Npxt0KZrmEkOBttVm7eY+ly5tIIXBdwdSpRY4/t8A7F/d57pkDOFUL6UyyEJYJ99Zx6hUOhh1mSorr731ItHwP47EXkI2zBJ0u7/+73+XcU8cRgc/Oyi7b2yabK32OnJ3HcE12t7pUOx6218ScHseZmGT8hEOwu0t5rEpQnyBc22ftB28z8cQZnj8+yaUbu/SlpNXpo+mjDZNJ2yYI+gz6HQId77QLfI8gshDlMqYRIf0BQikM06RULnPz3jY3V7bZ2O0S6Vg6X5xt0KiWcW0DKQS2W6Uxs4CO4sCspu0gpZ3syY0fJSkkvX6XUJlIw0IbJoZlIQ0Dy3WQhollWezv72EYJgcW5rm3ssbJk6dZXJhlbGycmZk59lp7fPjqj/DbW7T2SxxbnEKW57kbtjEwPsHj9ucvD5LW8kCjMcFJ51A2yZMUcWHid5IJgzx4ssdCaQGscjQkd8vNtYc52BRI4CipLKJNIrGn9yvcodCtApnMQD7+ddNNIYgiIJKYYPLbDnPa4X5JMpUBFIEjZWDZLuNCizKtoyoAT2EEh9UNBeKbAnBB26lHfAAhG+vcDEJMRAv9hBT8yJKgF4f3YZR+f4BbKuOUSlhCEEYR3mCA3+2Cinjs3CneePNdOt0u71+6wgvPPIFhmhn5isKQnhdvDCmVS3EObtMBIQmDIBZQhMS2XaRlY6qIz336Oa7dukev289M4KYUzAA20ClJav04p7CbOI9rpfH8gCCCMIxDyIQJ15J9j17PY7fVo14xMAkIQoWQBqZpoRTMTTdwXUGzE7C77yPMClVpYRkW++0uN5e3CMKIUCm8IBZ4IiEYBJpQw/punyNS4E6W4hzDSnK3rXjvxgbtQZD9zvEc1WgRm33T43EQ7CSjkdYEUTwHOu02g26fKh7u1hJCeThel5lBmxCba12H5c1txus1Sm4FGYWUy1WCQZfB/gZ+a5PB7ipGeYzd9oDvvvI+j50+SBSGaB2HPBISKpUqjuNgWiZRGNDrtOgP+uztN/nXv/0tdtoDpBBYhsQ2ZTa2D7MMuXGQp8YUKs1vGwtIRTNqtvEiOa5JPyeWI3TB10/fd798h21REI1LESuh4MKRagKzYwXTbvGcwrXFUuSQOVYNC8KjAviQwDxqKdGF65NzCi/5uekYDzWm8L+Ao8NkOR0NnffrAYtXvvmtcKnO1x2RubgkY1S0XecmoYKQPEqE//TysQngH770IaicfRqmiW271BwbMa7o9rrMbdxi/ff/F8T8Ah1vnR83uyirxNnnDjNzcoJfqtZ44vGDeK0eW1s9+qV53n3zNr/6peNMT5eRQvLiX1qk0nBAmggVQhRgzx+ievIEi48uYTgWV5rQ3O+zWJljZ+k6nUYf99whKFkceWoaLefo70XcWfeYu3WHQcvm4gdbzD0/YHo2YP3Vl7h9ZZVDCyUst0utZNH4+gscCSNo7bC73MQJFKWZcXbXN7A3blAac3EqdUrj40ShZumHf8iM7LJwSII14LMHTZyOyZV9SWi4dDodur0+Ck3FMgl9n1CBihSCKCZn3QG1sQoRHlJDuzfgyvImna6HQmDZFn7gEwQB33r5QyqVKgEuYzMTjM8eIZIGgTdA99qYhkWo4qwephnHA4y0oucFSKOEoSEAkAaN8fE436Vl4Pt99rb3OXL0GPPzC4yPT7K4uIjneZimiTA0vj/g3t1bRF6PQbdHEIaMuTaLh2a5fe/h5r9MQSMOXkuyWMa5HYXWaCnvE3dTslTkYiI5HkcU0SMAES80H2VRHd5FN2LmTMAtzcc46sA7dBPIN9ClxDLFz+QeQ+FNkmwsRdDNN3yM+rXc3/ChYclAUCT8L5eKh7WWBUJbGIOsHcW+jQxYDmqJqTbNVxUzulzyzyvIxgKG+Wlmlk4XDk0S71GideL8/5BKFIZ4gwGOW8KwLAzDQgjBQAgM0+RXf/kb/It/87u02x3ev3SZVqtNvVbNpHSlNb1OBxX4lCoOG+srGNKgXC5TrtRwS2W00Ni2g+f5qEjywme/yOvvXOJ7P3odoiROqIJIgNQCEcZjZKKxkzGTOt7E4amQMIrY6/TZ7wxQOtaAV2wTL4wo2RLbiMfXEIJIxYP/+KkZzp0+iJAmoZJ0un2mxioYlsVeq8PqXo/UYJha4Z1s4ZVc2VfMW4qDToBlSlrrHS50bW5tNImUSogEhYdAZGGcDMhIgmkKlIJIa+qmYGLpHaytN5Gmj6n6mI6NFVkINGYgWGj7/LPvXubFz3+eyUZIqTJJ1NuntXYLb3+DMIjzGHd323zv7VuMjTdwS2V6/Q5i3yAIBlQqNXrdDqZlJunyLCqVClsbO/yj//q/5c7KPYIk44gpFVKGdB+qGFIcttyyIXQy13QOg0MCEzqfhZk0TCaUZcJzXvv9pKYIeEXTLUnaMxG7lRRJZ/p9isMfOV3zCU9uzi7cB4Z8C4uCa/46TP7uI0ZD3+X1jB7KiW2qnytgdmEI9APHKRutwofCp1QSFoU0cEOv8Y104VhqzckbmvzmpDFhBSJJhfpxy8cmgDW3RLPbT0xn0Gg0CMOQng4p1WpsC4O3mz6roeDvP+cxd+gY+vIWxyYc5hccLm5oVjptrl68hdIWzzw2y+xYyKFvnMIuVxjsNAlaHfzL12j7Hqb2KY87iPFpdi7dpN/pY0/PMHVwlpd+cIXdW+u8+rvvUYpC3l3bYubSNh0dMTFf4dSXHyHc81jbjnj/zQ0+vD3ALkdsv/Em0Z2r7LY9PvULj9Df6iNLFubsPNbUNMHeKmvfu8TEqcP0BiHNDz9EzNVZfWWNxrSHVQ5x5izMqUmOHZtGTxxH9jqI2hTnTy5w7msmW3fWef/9TV67N0VbukSmwX6/z739FstrG3R6g2xh88MB7bam5NiIwEOoiEHQj1XUUuAH8e8chhH3NvcZGzeZmT5IZJQJo4jA68fpnywXLAdfB4ShDwhMS+AHEV3fQ8oqkRIY0sS0HErlMkIKSiWXrY1tarUas/NTbG1tMjk1TaQi/CBItBMC2zZYWVmhtb/HqmXzzHNPsdJeZXy+ji8ebv5LSAhgsjhIIbL/QoskF7AYQpiUqOScTWcTKwOVIVJHNlnvjy9XIHx6SHE/SoeySarTvw+QbP+02Tpq0hgydaSgnvmx6MI5Dy5DOS/va2eG/6OtyCVbMfpNOrbDWoCij+KDGxLfrDD6pMMT744bBjyR3jslq0nfRb7CffS9fgpFGBLPi7NKmJaJNAxs6SKkge95NOo1Hj33CK+9/hY3btzm7toGJ1wXqSPCMM5OYdkmmzt7BIGHN+hx+NhxSpUqlmWDFERhQLvdwnHL+BF0Pc2LX/wKPWXz5o9eotvu4ilQQjBuSf6TX7K5/l2PV3c0ptaAJFCaMNRoI4klqOJfMw4cDCpZoINIJ5qsJE0ccSq5VrONZdgEocAPNf6+R6PSx9Ahg06LKIq1ilpDlGpelMQxDUzg4mabzXaf/215Alf7dJTgw3ttel5AGEWxpi35DVOLpCDZHS9FQmJSbZHGMU2mbU24dAV9eIy2a9Lf2cN2TZyyiw6gZFeZnSjzHz0xzW+++SYbd0o8d3yCceGzvtOjHwn6QUS33efD9TY7HY8DUw2Onz7H3MJBTNNAmgaVchzcW+s4UDaRorO1wr/7jf+eKbnNl89N8oPLO3QHIUprfBVx5sDYw30OSYVhkQvDaVYJGedwjkEyJ11a5/NG5JLXR98jnXwFgTf9WCQniSpxmPANkbec1KWC7ZCVZUQ7mRLNlFyONIr4ucsJbK4BTL9LcRFGMbNIGkmHIMOY/DYP4If5+4yHZeiefbpvDLPTc7wbTu2W/z5CDw1u/pl87OJ3caYXldZflKY/ARx+bAL4a194mjdvLnN3p00UBBw6fJC93X0My2bgBZhumX2lOTnpUK/YTJgRX//MBJd/tML3ruxwtwNffGaWmbEKynTZu7vP1VeWCIIBvb5HxwOkIHBsTp5e4Ikn5jCma+jQ4/aGZmG2TnWsCkGLTz/TwHh6DAeoVyxc20JVy1y53ubNG3ucdo5gHJvl8BddVl95hUefnOHiq/e4drlJ+3aXQcPmM5PjHH50FmfxBLg24b2r9JaWqT12Bvv4IaySze7bFxiYFSpnj9G5vUx/dRt5bQejXmVs0qUuNK4tCXdXaG0OuPHWOp2uw5f+r/+A5+1JIqeGCgbsbW7SjeB/+I1/y+///jcRUYTQcWiIcDBAlKoEUiOCPsWciKlWSBoy3uAhJNpw0ELghz7oOJirNCwEMg4VUbYBSRQK9nxNW1WpKZ1ptIKgj+97zE3OopSm0+1z5swpWq02SmnGGg26nS5uqUy1UmG/0+Li5Q+RhmR6ZpZOt8+/+/afYE+V2eju0t7Y+fhP20+spFJeksCeVE2eSH7JJMiJWnJVOn+GtA55nQ8MoqqLk7XwVVFDxohDbn4KQ4GTdRF489uOtCID6mIb8jYWLhsif/fP+/vgSOddeNAQiIRkDePtMFAV69XFdwVJuyg5DxeRCr33fScKdQyDcLrMFCX45CXJppL6QD2sIoTED0N6/S6mbeK6sRnXtuLc2UYU8dWf+RJvv3uBbq/H9Zu3OXr4ICoKCMIQPwiQhoEf+LRaAbZt0m23cR0XWRNIJel1ugTC4uVX3sa0LMYnGqzvdtjc3uexZ57h+z96iYD4WVeR5taNkLV+LI6YyYhGGkKt4kUkGVvbjMN3SamxTIkyNAYa01CUzdh3OIg0fa3xI4PLl26x1/EY+BqBZG2jTWdP0fPj+tN5o3Vsqu2rCD/UlF1ASzb7IT9cG/DctMn1bsggjINgay0II40QOnGHiEmelHGGFdOQCFItkgRDUyuXWWxUuNdq07zawx4rIwiZqZUpV+o4ykJ7HuFWkxMOTFQMtn2fN+9s87eeH+dg3WR7p02r6+EbEafKEssoU65tMulvMjv7FP1Bn8tXLjPWGGdyYoJyuUJ3f4vtnR02791ldXsb03QxDI3BbgI5mjAUbLeih/YMFh5GijNapxOsKM3pfB7lRd8/PcmrykhOWk8BO0g/ikJI/SIrekCVBe7CgyjR6Ieh++hRzEyxQI0QuWEMGQ0Pk7qtFAXe7CZCU8xpkGv8EkKZV1MQ/skE0lGCPKRRENkqMTwwww3If48RuBeFr1MX98xylf7TOttp/EnKxyaABw8c4In5BdaF5J/+xrdobu9hAlG7Q22swc88t8h/fLxPsLPD3XfvsGNEjC/WeWtJMTE7zudOT3PqTI1XfnSdd99aY6MZYNmSM8fHOXpgjLmSwVMvnsKdngPbwVteYv+D61TmXZ74whE273oYZhmr7vLswjyRHxG12vjNbQwd4O90eXqhyuzkHDdeu8apR/u8+DNHeX97iSOPLyBaERwuc/G1LUpr27x8u4n95ZPM1Op07lxj8rFT1H/2q+h2m70byzTvrrN2Y4fpsRKHnjlFp1Zl4plz7F+6xr0/fo2wNIYsH8IYK6GikMZ8g4UTDi/9wWXWfRfV2aY0LhibX2D66FGU0pS++W20jmL2rkJcIVCWQae1GxM9FI4hccsuYRiCSHO/CkzDYmJiErdWJ7LKqHYLP/KwpcWg28UqGXSlzZ3mAKQiIEJpkzjQhCJQEWgoVysYhhlvorm9xOzsLKVKmVs3b/Hoo48iDUmv16deb6AB3/N4/+pNZqbn2d3dRBqCVqdDZ3OdZrvJoNv9ZE/cn7doHQd4Jdb+KZGSB5EFgiZxGs/ncwJSIp3Y8TEtUlBIPpNKtLooLme15PN6FDxzqXhIfEs/Fo8VZ/Ro1+7r6hATyulWgUA9iAgWhuq+Wke9DVNfk+L3o5rHvIpU31f4mw4V6VDFA5GamYrtBp2YodILhwl5uhtuKJ9A8jtkJu6s18lNs2sfvPj8VIo0CH2PwWAQzyUhsW0HKSWOU0JrzTNPP8nJE8e4fPkaH169yec/+2kMrbh4+SYXL1/hC59+hlKpROAPsIVkf7+JbTsYpoGKNF7g8z/9q3/LI48+Rr/dQSmfxniNMPR58fOfY+D12FtfxTUk3maLN9+NNVGK2CcwHfVIacxkd6oAwkjjBQGGITCNOJSUIE6d5lkaM1mbfSXotTzWVlsEtkFYdTGkprPXpdvqMyjnqSNJ7ps+D4FWtPs+kW3hIHn5XpNu6NLERkkx5F6hdbyMSxFr/ixDYppGoo004kD2It7Pujg/yeTp0wxuvcX8ZJ35Y9N4HQ/V9WlGbcJIE+x3iPoRWAZV5XHk/GO4ts323jIHxx2qiy5RFNLr9oj8IMvEE17/E9SjTzO/eJrG+CQ3rt9gd2+Xe8t3OH7yNOOh4s233ufHFzeYqrt02n16XogmXoyl1mzsNh/eM5gUrRRaxFgn4wMZqMUxMnMCk+20FzlS5SSvyPzSygtEqIBjDxYQ4/cpBghZmL8i1/QWw1+leWtF8r7YtrTqYZ/Ckb4XcSkVAjOSN2wSLrrH3BcPEAr91iOH0lBbo5CfEj0KAJjcW6Vt/6j7FDAwKTKn0gW/wELfVX6btIZ8I0hu4v6kgvDHJoAT67sYSnNYCv7vT59lo+fR9ANK42McrgWcqva4dWWb/Z7J+aePMr1QZ2+zzWlTY1csjkwPaC5tsnZvmzPPHeE//vQ8vfU25qDH+HSN0uw0lakJlDDxt9eRtk1ltoHjCrb2Q958+SrPP3EUu7JIb3ePzcu3efeDbW6vdzk2X+Kxp6c58tgYSxfXcZTDmeOTUHI48eUnuPPKVRbPVbm3vM/f/tuf4f1vvcbyxQ38vRbvvn6V1tU1fvaJ04QrF+jc2OLGe3t0eh3mF6oYpRKyXmf84AJqsMvy6x9w9bW7LJwJmX72DKoHZmMBvb3EVHePL/zMAnY5xJMGjhPTEEMa9L0+QbuJhSJMflytFJYA13bQpsUgiHfVRSrfyiFF/BipSNFp7eM05jEsiSnA7/tE0sSynCSRO4QYqAikBkmIUAFeEKClgZQChaZUttnd3UMpwezcNDdu3qRRq1OtV+l1eyCgXCnT63RpNneZqkrciXn6vX0MKdjZbzM+Po2wbDyn+okeuD9vSRcZlEYlYf8U8R+R7qRNwaxIGpL5WtwkkoJFXGcqo+VSX0oEY0xLJ+PIDrciodRJQ/QIaIgcSornF1X6Q1WmNSczvuioXGxl5ruYgd4QLRxGrKRynS0CKdnL25r04iNAqqj3+4hzs66I/JXR9ucrvxAxVxf5pTkJFIWfMRvI4fHLLhoimT/94pYqeH5I3w+JVBdhmIDAMA2kYWCYFuPjk8zOTrO0dJd33/uAG7duc+3aDS5fu8Hc/Azbey0OzIwTSiPODELA9vY6QRgwNjZOrVLjr//lv8gffe/HWG4Vw3A5vDDDP/6H/wWONPjsp76A1+8QNTf5l/+H/wdbqxsYAuxAxzFGk1810hozXSBJf3+F1pLUkd+QeRgRKZLkjlrjRSEijFAyNglnO64VECmMRKBKZaVIxFrCSClCBe1BQBgZ4Fq8uTZgvCpxKpXs/KKAotBEIQhL45oCy7UpOQ6mKYlCTalc5sShA/SjiI49Redui2v3biDDACsUTE9VKI+XaTTKGIaP73lsbjZ561tvMDdW4vgjJvuRmfg+21imhWka+L4fp5CLAjZe/3dUZo5iOw4nT55k4HncuX6Fpds3aYxN8vKbl7BMScV1UQOP0DXoeGGcXVmDZTzcXcAJz8kXf/L5lMuoekRDNQJdGTEqIt8D5pJmSBWls4o0qdUg91HTCJX7BMbEMMeEWGmZbwbJYTDHw9gcmhLQYfKTNUnnb7JnOxuLAjYVXouYpgt9z8ZzpMvZickzW8TrbAyFGB7UImcewq/0tCI+xz2M0uEtiLLphriUKKdrRkZwh1ntEBn8uOVjE8Dd5j6NehW7XGJSu9QBTwjMyMeOSux0G4jJGY4sBjhlm401n529OtKQlC2Tpdt7tPwKn/n8KQ4em+XupsdYpYQ7U6UxPw0E9NdX0MrAnaphTi+w++F11r77Gsstwc69Hm9s7nB6fZvTv/CzjJUXOD6+Qu3mTZ5+bprpxTpKVDl7osOPv32D9es2Ywd7tJb3WDx/lNKExB68z+SYScVwmTFDaHWpzUxybV/Rv7ZE/dQxaocOctwogSMId1rMPHcW7Q8I7i0jywbemIFu1Lm7G/FsvcJA2Gy+9hZTRycJezYTdkB/sIuha/FGAE2sHej1OFgWfOrwFAuHp3nzxibLq/sEkYbBANtSVB2brucR+BGWbSIERFEYJz43Hbr9HlNSYAiFZTuYYYsg7BFGCmkYSdL4EENKVBgQRgF2yUaYLloLhJRMTU0iTYvefptTp0+xt7eP7wWU5ypoDYOBh2O7QLyD8NFHz/Anf/Q7NA4dpVqr0e12qNdrCMOmXp+gRftjP2w/iSIESewrGcd9FkkC9FhNwLAEJ4q8LXkdmY3FcPP5XTJtoSB3sM7JYHaD++9VqEqTSOUF/4ycTI7Ulb3PL/4oIM52ucEI4BVNFaMkcLSP9986vXaYDKaAIpL7jsrCRdhPP+usnQ/sQOFtOmaC/H/aryKY5r9Zen1sMkyDrT5MDaDtOJiOy6DXo68CRLsDQuK4Dvghmzt7fOvb3+HDD6/RbnXodntc+OAyW9tbzM7PUnJdPrx2k9mpJ5HSIAxDhBRxhqO+lzzP4LgVfvFrX2Z5dZOJyUkWFw/EliqtGBMSQp9wMEHp/CmuRAGDbp+n213MKB/ComZAZO4MST7iMEp+PYkSgjBZhSIhCBVEOl7AJQKpi0HV46dLyjh7R5p1Ig0tIoQgUgqFoB8oQhVQL5nsdTwOjI0lbVCFeZX/zD0/xDJgvFFmamYCy5IgTY4dPkRnawPPNhg78QiBF/LB977L2QmLmZrLWLWGLEv2tptEvYC97oA7ez08PM7WAwZNi62BgeNIHNfEkBLDsZL89qBDRfPKB7iPXKI+fwSAwB9QrdUIgjL7e7tcu3kdUwoiHTGIwDANxgyJRUjLi3M7P8wSE/Z001m+mUAIPXRSRjpGwTA7Z1jYys25+v5z0/PvY5Qiu3/hUP5afCNSHC5eXrgy41PD74smVE3e5gzCKR4k4arD7iMpWkBRkzmCz4W+ZRaf1BIhsrdZ54phYIYIZlpbDsoF96SRvkCeDWVol0lKAwucU6frTa6Bz3ryCWHw40fx7Q6YPdBAWTZahXSaLQIdIQybSAuEAWO1KsFuk629DuvdkPHDc9i2RSBtqE7SkIAtuH5lh3vXVzg6rTny5AG010ZYFna9QdgNifZ3GSzfYeDZOOdP8eTRaY61Apbeuck7r91lbPEDDj5/numD5+m9cApfWLQHbXpX3uXerQ0On5qjdvQIA7/P1CMHsVyH1777AWKry2wv5OALx7hwa5tFx2ZmvsZf/wdfJNxus/PuTUzVRro2lh1QmZ2CwCfqNTGMCO11OPfMGOZmm7uXW7QvXyMcH+fu5XtcvnCbyakaZvND5r4yjZo/DyRmyjCkXrb4e792Gv0VF2e8xn/3zav89//ydbZDga8FOvQxopCSbTFQEeEgxLbM7CFQUUi5VKFsWygR4tgGwdQk4d4+dFpoKZCWjcRESkXodfD7HWxRQlUsFAZCg+nYbG1uMzs7i+26LN+9x8LCAuMT47RaLXzf59Sp03EA1XqN3a01piZq/NW/+uusb6zy27/1m2xt7bLV9HCtEqH78BZestGAoY0gCKQhkwD0eaqwApsgJXXxV4XJSEEILtwlM2UkVY241OSNSdoyujP4IxufvRkhOKOXpCBbkGbvey2YOUbblV4b15tR0fubUvhc5J9FSpeW4v1TaTO/b9GEnnzWheuySgpgNXr/1CysR4BfpHJvDMRKq6wt6a/3MDWArU4faVggDDSagR8S7re4s3yXl15+le9+/wesrW8QhRFaa1SoeOnV1/j7/9nf4Ucvv8ri4hzTU2OEJCZaJGEQAjDwPTa2NtBa0RiHcqXGiWNHCQOf5vY25WqNcr0eLxZKEgUmj3zuBf74vYtIwNNk1gDQEGm0lf4ysfk1HSrTkESpRpg4k0IIGKlWIlnttNZEUUSkY1OnQWzKF1plC6/MHmWd5LgWWVgUjSJUGtuC3d0WlmEQJdlTSEiMkTyAWmuavRA29pkdr7F4eJHzj57nzqUPaYYRfr9HxzSoVhuc+fyn2XvvXXqre+zvdpmqO0gUCsX31vsIBM83BLXI49aKh2kKSpag4hiU3DgINiRB5YVk4LXx3n6Tw5+ux4Kl0LilEm7Z4N133saU0PMD1ne6eEGE74eJD6rCNiS29XAJIBALwTKJcYpONoHEc1+l/uQJW0oxQchRoSkh7kN4kYJegagVNxp8BMZlu1HTwPKZlq9AGUdMwjlRzHG3cGqx9sJ3CeokGFA0fw5ZRciFoKxocrTImdyfWUZQlsy1duhoEe+KpFVmPRgWgnXh2wJuZ+8FGZSnmlYhspSZIiHTIqlDRepj9iYuH5sAVqXBoBtSbUT0Bx4hEsM1CGyXyvgErlvHMCJauztoFTF1bB5LaKLQo9vqYWHhlFz2tqHrlanNnWVPagZXDWbmJbUxH+3v0FpeplyrUj9xiJnJOUQQMNjbwl+9xfrSFlfXfCZevkh1osTEo48Q+SE3b6wSWmVqlYNUzlWx7m7jzEyy/OYFmrc2mCn1+fCVZR49UkGWTKYeWeBnf/UxpqoRfr/NznX4vd96l0MH67z4xQPgCnor20weKrF7+TKu3yWcHGf1Tz7k0GdmmT0zid/2ufz2XR7/RoPTv/oZLr9yle7WLrOHD7OztMbY1CMQ+LFtX0UQeIhIYUYeW29v89WnjzPY6rK073FpeYulrR5eEGJEIeOuQ0/BwPcxTRPTiFMW2aaBP+hhlaqIMMB1HMLGGMq245A5poEpBdrvERmCIPQJI5tQKRBxSqOB5+M4DhOTY1y7fINavUap7GBbNgPPp16rU61WCAKPcrnE0o1bzM/Po3XE008/he/1Wbp1i9/7wx8QCInt2p/gcfsJlGzGFQkGaKUy4iClACEzUCmaPbMr0gUn0YHoIbArEMACIInhSvKbi5HPafnTxLEC8bufuuSavIzMDdWfaOIK2phRwEvHKLssq7BwbkEqHj4xd+6Ou6Hz8wqmnGw37mibRwh30cCcd3h4AUpzk95PTIe1ryM4nvsUPsTy9/7+/4WnnnwS13GwbYdbd25x/foN7q2t0Wl3E7+s4d/t9p1l/ud/81v83Jc/y9T8JN9c/RGzYpxz5ZOYkY/r2AgJWkGv22M9XCcII2ZNi4E3wPcCnFKJskg2hGGipUQbNk8+/ThfPHKI9Vcv4EQiDsWSBPyOYkkhG3ppCAzAElB1Y3/PmNRByYrNugLoBBqZBFtHxbt8g0hh6TjzjtKxuVErXfSdz54bpdOQYfHxSMd+fp1uj5LrEoSx77ApwDJEHOxZ5PExe17IlSsrfO6Zc2wuLbG6uo5hWAz6EYZpIHSE7bg4x46jl5dwHIEnoScVGwEwXuLpmk8l6LHtBWgvjP2qtcY1JK5lULUNbKlynACaf/gdnIMnkKbAdhwOLBzm5sV3+OY3v42IIoJQs9vu4VgGC3UTUwpsE8IIooedCg5yQXAYvmIrSUorUn+8pJ/xDutUG1yYh6PzdcTdJcvDLYqYMTJjxfC9IG5fBncjhLKIs1n0hqHmjNwpbWO6oY6CBSLZ/JJuhhjCwyHSVxBmM3+EFJYKLi5DvoIFLC02q0gC7yOvOSaKB/l9Pwh/k3FL0p/fN5bp5+zrDPyTdWyopX92+dgEcGAabG238XoBWgts08KplnDGJpg6dBRjdoHO5YvsdgdMj9UwbBu/46HCPt2dFo2ZGSJH0u0HWE4JaYJpW2zd26S1rRGOwrQMjp97grlnzxFh0/7gddqXLuJOlri222Bbd6hMhLx/s8XEDy9wXMPy1g57O3ts3vOZnnNZ3vD4+fM1pG2wvLLPhz+8wq//755moSzpb+5z7dVlFs7UcLttfBxCYeKWXH7h1z6DM9hi8+YOc49OYy4cYu/9WwxkBWtuEr2/xviTUyz/0TKNU4eZPf8sntIEO5JGvcX5M9M0Jy1k30UfmMQJNpCeC+E0BA5ec5/dq9dYOD9F78IdJg4e4O/8+qfZvXCJXuUQt9QEq5sDZuddbq9t8Bu//T7bPYf9fh/DEpjCZGp6OpZwQ4WSJlorSiWHKAjQYYRjxA9aaJhUxmexa2PYUUQUxjYhQyu67R6LBw9w+84yKhJMTDYwDIOt7W3KpSpj4xMgYnCv1R021peYmjlAt9tGIHjqqafZ217lC595lh+++i6e+CSP20+mZOtZRlbiY0ppNAqUQEidE4oh0CGZ+Pmkz/RHQ/5uIvs8PEFHyEzymmfaKHLCHMlG/f1SDjrEBHMROTk6MrYjvi6Z5JsBAEVUGJZ6s5qLZC6/WwqI94W9uQ8EhzV7On1XQNf7AHPkc2HUCp9jc24O5+lJuiCk56tcqgsQQ2P5cMo7777L2++8ky0QMvGvBYFSqWkzT7OitcLzBrzzzrt86rkn8Cua79x5mRPmIc6fO4XXHyAlSB0RBEEcLFpFuP0ezb1dhGFRqlSp1GpYlgWhAiMiCjoMNpcx8fnS/+rrfOvdK2gvwNEqDgRMGgw49z6NE5fEo9z2BEoL0AopJa1IJIu8ji0ArsBJfjul4h3XoRBYaCLAi4q/7fDCrnV6b0ALtIK+HzLwI0zTZLJeiTWpIiadipgEahFrJqWQBFrzzT94hfVIMTlWp+xIGhUX0y7H5lYrxJ1ooGtn2Wi3cSyJYQrKQciJpFl+ELDf7CEDD9lrE3Q6dIOQjq/Y8UK0VphaYcqYNHls8vYPf8Cx8ycxDEF34zp33vkxcrDD0UmbpaZmfszl3JzDVEXQ9zXdADbbAfvhQ9YA6tTni/w/pFng0FLnGqWi8FtkQgAPRpvkjHw+5i4dowbMkTaR4l3xu4IwLZK4nQkBzLCxoBkERlwECvcsQHDGf4YwsDAuxc9pHwrHCy+FOvXI6/19za20I7heGMehtqeLVGEDoSh0YDj3r0h2+4qhcZMiJqz55g+V/tTJZqZk4f5p+ACG7hhRv0vQ8fCFyXi1TNmsYEQwaHbobF6ivXqDku3SmD5AMOjS7/fwmn3a/YDxUhl7ehqj1SHotgmDuOOW69ILB7iOiZI11tcs7Je+x+1ba7RaHs99/hDVUyd45uoOLzwNN78bstat0fb7vP7tl1g4OcEXXjyObZd5961tLnz/Ap2jZZTfZ7cH+/sGzZ0p2lMhb7/xAecrt5ifOcnMU2fp73W59AevM2Ytce4v/wJ7wTgzxxQGfeoygoXnaFhVOqvL3HnX4+iJGsajB9jfV9TnAtyNJS5fUqy9ehdT+VROH8XXcDJQjB2borv5OqsvfZdKRVM5VEMsLOBttxg7ewrXNbEdyeTZQ1S3OxyZK6Efm8GQBsan5plqwP/rn7yBLLn4MpbEOp0etZoFdAi1RBsWUdjFFiAdwaC9Q+D1kYaJNG2ELAGSMPBBKWQIs7NT+L7P9sYOBw8v4Ac+cmAQeIoD8wcpl8t4voeKFI16hdNnz7K106HRaLC5ucHExBTnzj+DFpeYu3GH/vLqx37YflJFZKt/8jn9n3iyax1nJUjlQwrfZ3okMUz+hidtUZROpqEYRR0ozGRS5pcBjyhAlobYIyqXrO8X/wrHht5Bru0c1vYNBWwe+n4U2DJIzrs1OqgfSaLyPuRjldav8zNS4BfDlxbOKCwgw2QzBcLc16WgEaDwmyV/h/EtWbw+Pub9uUtK8qTMg32nMcmklMnnuL/5e0Gn0+Vf/Ot/y8/9wpf5xtSLnJs9Tthr4w36DAYDXNug225RqtSwlUUQaHp9n2q9HB9zHKQhwRD4/Rb77/0updb7hO19dHCM2a8+x9rqNs7KJuLeNnGe8HTcReYzFiYBpEWksoVR6ohIyeSR13HgZTX8HOs0rJwuELxk10GuDdaZpkgnv7FtGYRKE3gRUkAQBliWyXijRrPdwo/ia01TZu00hMaLNLf2urjVEr1+j07LZ3kl4n1jjeMHZzkxP0bJUBiWi+2YmKaJFArLsjAtC6RJpDSVyQjXEOgoREcK3/Potbu0m22UUth2mevXb1BSEbYh2bh1mQOLNUwR0Nq4DuGAs7Mua03FRj/i4KTLeEmw2opYbynagabnK2qVh6wBzPz/ZO73V4iDpxMhICYYkFEKmbrLJPVoNVIvBUAcxqXs+7QMkUuRXRL7qOX/MyG4WEHW5GK6ykLVWn8EJhWJXYJHmWCTY2IRl4qNL4jcSXtF8esiUj74voXVIjYD5+tJoXdDfYzvk95AD5889H7YNzwjgunvl5BmnWUISfqbaGv1J1TIfGwCWHEcuv6AfgSWtDHKY/T8AWGoGXj36AcRnV6AUIpQGPiRRGHguGUGpkGgJNWZYyhnG8O7TT/oYyiFNiR26FCtuDhjVZr3tvkXr64xPevwF/7COapHFunevky4tMfYs49w4MkKs6tN6qcepb25Qd0OEAPB6nqfP/7jq9zsh6xtNFm8ucrXvnCAzz9/gPXX7/HZr5/j+BNTuPduUT06C27A2qXL3L3Z5uYgoHbofaY+/Tz9zevc2+9w5NQchrTRgQe7exx79hnc8Sr7P3wL0Wnid/psLzWpW4p7CxV++IbP5w94PPn1J7j2w0tU6yYTxxdgMSLq9tjZNYncMs7hM4gwRPtdVt6+xNbdNl4QUR5vUz4yx3xdUnICnjg0xWMnZlDNLqeOzfDycgftWvT6bXqdFp7XxynXiLAZ9LsINJZdQpsOIZJw4NFpb1K1LVyjjCFsbLvE3OI8Vy5f4/DRwwhD0e302Fjf5vTpRzBMievatFotqtUSpbLLufPPsHx3lWq1wt27dzFNk1Z7j+npaU6fOsTy8t1P9MD9uUsKekl4CJlMWCklUguUTBbkVGpNwVCnPms53StKlKLwRqTErwhgFBPVp8Qkh5FRTphXl3+fzXVRPJKfO1xGNGm5sMh9RK/4fsjsW2jMSAM/8ruMoxU7kkvQKhm+IfNIsrM6c+Mu8ueUFSYgVbxvQdbPBOnU5XnIF0ikY5dKxvf9giPvf7pFSpkIGOk947gPQqTed4VFWCuyFH5ac/fuCv/y//ebfO5Tz6CeXWCt3WRraxfHcTl6eB4VhbRbLRpVi3LpOOVajVqjgWkYWKaFEJKw38W/9seM+7cwSg46cthvXccYq3HtjYvYXR9DQKhBR/G9lVYFv6v42YuUKmhXEgKLiDXoxARPJu1WOh7/SGu00BgaDAGRTAWkdHSSWZE8L65tISX4QVSYs5J+f0Bbacq2TRAGaKWxE1+2MNQgRBLoVmGbAikMtBBECMIg5OLVZVbWt3n62DSTDTCEiR+FWKaBsGJtomEILMembBqgPBAuICgJg/GFOMec5brMzB/ljf/y/01T+JRNyaDbZ/DKG9RswWRJUXElZdektdWjXjaZqJr0o5B2KCmVJE4pzls8O17+6T98hSJIsXDEBzAJoq0EOUnK3EUEMnGbyLLKZ+4VOoPHjJOMwBRAMRXHkMUjI6MU8DN5XxCmh15F8XNW0fB5+Y1JpI0RmNIpDxoigENCq9ZDEPHAUDDZuOa3y0LDZqMXn1FAWcRH1FOs7z4SKvJvsiwuxfVnaHHKVqehe6UhstLxlUIk8QE/ui2j5WMTwJlGFTnu0qjV8LVJx6px9+ZV6mGLhZkDqP0+m3tNelJQWV9n3LEJPYUpwBybpy8cGtLEqk4gyysYvQFWYwJr3MQQCpcBg2aTsN/iqeOPML5QR0cWu2/cpOUZbOxKDlbHuB3uc/NHb/Jsq8uh5x5hb3WbiRPnmauWqb+8zOMOHJypEmxuUT+5iO41Ua6ms77KMy8+ive+j6yW6d+5TFfCZ75xjN/9X25y6eX3eXqsQeOJ09x6+U+oBBGNxUnMSgUl6rhIrJmDqJN9Xv1n3+JkD1Y2YMLu8swjk7x2c8Cb793j2FyZJ37uMW59/31UZ5exE2fZjyTv//gSSzsdfv2v/AzLrTZq4TOIF57COxPQ77fxhKBlKFpSs7j/Nguqxf/tuWka88epTZf5xaDE//6/eo27m3sM/DCW4swWhmnhOA5hGLGzvUkQBURhHN9KCoPS1DxaKpRUSMtgZWWNarVKY7xOu90BDCqVGpVKBdM04lAPCLa319narjPWGOeoZWMYBir06XWbdNpNDGliGArjYfs9F8hKER5yiY9sp1YqMQ1dnEqJFMChUK0oTDggI46xP1V0n4kivSr+zNDnDEAYIX+56D10r6EODhGdIoQUzRz5+foBn0dLpg9NAaTY3NHTM7I2Cl1Df0hBubg7VOthiHygFJy8z7R+6e+VSrzZbXJymB4UCbCnTtEUrnk4Jda4aB1l5k5RIPVKpRqVdNdsHihca0270+EP/+SHvPP+h9QrLiXHZXpyDENC2XW4c+MK07NTVKePcuDwERCgVISKIvx+l+6NH1PaeQtpxxon23EYc/dwPrzIqXu77JCmUisIDbnkkRcxLJxAtp4k7Y3JhI4KpF2IvG6dE73Rkj0HWlOzDfaSXMRCiDhKgdagFUoIXLeE1x9gG7F1WydpHtGJRlXH9420TAS6AIjYbfVY3+0xM1HHMCxsy8Y0BFpHBMEAw3ZwyyUkISp0wJBxoGnbBRHXVa2OUamNESjNXsdHAKYBxmYPFFRtODTl8Cs/9wynXhgjUgaObaK0YOCHgEJF8Y7qMHi4WZGK2JU/g3FJNeipn9+Qz2/yYAghClyuKHgVi7jvsUnvnaGfKM5XcvKXngjppM2FVSny3azoZCevyM6Nhb37zak5IhYyLD3gbxE5s2dfFIlg8gCP4mSBJ2brSSZoF/og9PB5Rc42MkBF0phbjB8EuinBLVY8XFd8qSjgf37iA+D6zywfmwCahk/FtunpiMMvPMfNK2uUjDjqfS/0qVQUR+dqbLQHbGw26RuCibKNVR+nsrCInphid3uTkjTp7Qb4vkGwso4gonroGKUDsxjXP8AIA5Sw2Vwf0F3ZYWYMxp4aJ9zZw5yqsbK5y55V4e71bbT6kFNfO48Yt1CXP+CFOUlUrTJ5sk5tahyzaiDaFue+cgZ/e4DApHLsKN7OFt1dj0cem6a33uLAYZeZOYe7b7zFzIlJnnzxFMZEgw9+/1W6ex3WL69yZLLME39TcPDxEzz2K1/kzd/+Pl//K19g4hFNd2WJv0KJlatdLl3aYm93j2rF4Y1vXaTRuMnUyUM89egxHiu5LF25zOs/vModdZGv/md/Gy+IEHaV/f0diELCepnNqSepVHbxXv5NVm4tc+YrJzhz8jT/8D99gRv3BvzJu2tcXNqm5xtMz84zNjmO0CHvvfMWg35EJC1UkiHESHb6SSFw3DI7O3ucOnWUTqfDrRvLLC4usLi4iCEFlmXj+wHVaonf+q3/iVu3jvPpz3yGxYMLRGGAZQh63Ta1WpXAD1leuos/6H+yJ+7PWbSOff1iEMmlJ41CKYGOgwGSmiCATJKMw8YUTQC506weEnWHEa9A+YbNnmkC1IyEpKcV7jFiXhi+YJQIDpMmPfIhI37pQFCUZIdBqniMwvnFKu9DCz3ac1I2N1RSMI5NDukCk5Pe9I1+wD0ynyIx7OunC2CcO3WLbGdwZtrQI8Rdq+z9wyq5cGGgVDH7gxoe8xFynB1N+ru2vslaMo6mIXnpzfcYbzTo9TpEUcQjl+7wN/9KwKNnH0E26ixd+4CVt77L8eoGVt0iUhaWIbGkRbVSZfFkidvvCYyBxkhcEFX2WEti82z+vGiSTRdaJztD49VJSpGlFNMivs40JEGUawwlIJNNK+miP6xUFgih8cKQimNy9kiV62sDdtsKw4jJlwgj+gOf0lidbr/P4088xdvvvo8k3nRiGyCkIFQaGQaEiY+vSlLaTU1OcObkHPNTksioI0wLw7QAjVIRZbeEZUjCQCAtEyElhmmhlCZUAaZh4VYaOG4ZLQT9QbwTOw6pEj+Pnb6kNVCcWjc4c3YGGQkGOiQMAnwliAKfwcCn0/MYDPyf5GP2ZxetY98vBSrN/0v8m6RCUsrf4ty8ucYJ4uNxqLLUfJ+UorRaOFhEqCzQe4F8aGLCr1Lylc0TctBI/oo4D2FmHk6fq/SEAqX802TkjAjl73NrRfonFUbyTySYU+xrPqaFSws3HN4Yl/G00caNLCFFwTQlo0X3neJ36fepBjAmegWzb9qGzBqjSOIhxD66KdZ8AhXgxyaAKvIoj9WZPfUoUkscGRA1W+wrj/bSCobvYxoGJcuGUDM9WaFRqVKZPkDjM8/T3Nhn58ML3FvbYG9jjQONKr7j4Hf2CW8EmM1p6q5B35BIr4/T83AaBsasz36rRX2qBKZkHMXTL0wzffYowgRzyubO915iwizz1C+8gDYUhu6huj5KaZrrbUrTEyzdXOVEzcSdrBF2V6gfbaBbFrWjJ/nyry+yc2GdlZtbfPDtHxMeXOTkzCT1isvUo2cxT2xgrGxx98evsxiEHDozS/DVZ1CWxWBtH+m5PP75Y5x4XtLZbnLzg02OnJmn/pxk+/1lStN1nHKf/dffY+zMYW5FFh9evMTOP/xv+NwvfoXK5DiHxm0qtkFr8x5GKOh5Hse/8SK3v/sK0qixe3OVE5UaNEy+HZmYZo2ji3MI02S/2aS5v0Ol2uDF5x6nKnsoBYZh8NaVPVqd2IF7f7/Fk0+eZeB5bG3tIoUdp64yJUIaOE6cy3Rx8RBbm2v81sV3uHH9Bl/52S9jm+D1e+w39/nww6t0OgNu377DwHu4oJdNdKEzv6t4gosR6U0PL8YChAI1FKE+OTcBgVRCyy4R+blD6vkCahQ1O3lmhLwdKvVjyRkhUDRQD/Usb30RfAoAF78UFvHC/dMG6eyy4ToTWTsD1xyrkr4VQGtoMciaPwyEutiWUaI31J7cDJWngSvoYVOEzrhmbgKSFHxdEpKuZXyG0ioxxY6O30+36Iz1gBAGWhcC76HJv43bNaqNTbWGyddodJIiLqQ/2KJWKdHr+7z93kX29v4Z/6f/9G8yZkV8+PYb2J0VDj03g/JMlAnKiJO/m5bFwvEGpYlN5OoAKyFg2WJMbM5NSUCcDzgl4hIj2cEqiQWlosVMoDGlgUjybIvkWdEkxu/kt1XFgGjJQ6sErO0HzEyW+NrTc1xe8dnY8+l6IS0NYaRot7tUSiXcWp2Tp45jGAZLy3fp9QYYyTlGZIAWlByXqYkS83PTnDp7nrOzAbWSphuN43lBHKtQhQgVYUmBkAbCiNCGiUYQhHFbDdPCLdeoj08gpCDSglCnsfTySayI09NZthU7RRomkafwBj4DLyDwA7yBj+9HBOGIL91PuWRPviYXlApa8XRuaWKyHs/x5HenwMmEzLKEjNZdfKOHrivq6fO5nl2U8RBdIEq5f2jcFj2Ew8UwM6mQCDFuDxOtYv2jGMwQ5sTfD6NT7uKTHcjJWdbH4jU5KsWkuoDhSfvztWOkD8U7Z20jI6tFppmZdlMCmCKxSARtEQfYzvA0+wc6jQD+CWHwYxPA/a1dIhkwLkI6612uLa1Be49QSHrdHiUN0jCp16tMTlSpTlRoHDpM5fijNLdXCXt9Brsb7KwtUfa7KMfA6ffwbInSAYNOB9WNNx84A0AELDx7kFfeu0iw2+QXfu5RsGsorbmxssduaYJnfukpbn37NV7+k5u88MJRThg9dLCHKlWQxx6j3Wpx5+o2s0+f495uyMnyOKsffIBVL1FqlmicPEHU20CvrnL14hazz53gnR98yOFwk97hOdqrWzz57FkWHjvLje++w8SROS5+cJcxeZNqvUL75k3CGYfm5h6HggGlsVnG6+O88OWDCEtQ63aYfuIIKtKUj57le99fY/Nfv4bhjvHFpw7zb169yJUr1/iVL57myOPzzByaw1y9y3Q1wliYZ3B3n/LMONHEHJ3bN/n911p88+YATzicffQ8G9sbNJs7LC8t4Q88WvstLMPms08c5di0y27Xxwv3AE2kImzLYGJqip2dXQzDZPHQGNVqBUMKbNvEMCRbu7soDhJFEc29fd54/XVu37yJlOD5Pn7g0+30AIMw8gmjh5v/Mgef3MyQ++qRAUVm/kql0IS8FBVt9+9qS/VTmtQEWszGMUyghlslkgU3MzAXiFNRkr2PZCaveQ5wTTGyPg+4W9L4ZBwe3CKyIMmFMRm6d5EAjhxLb1vQXGU7zwpAm5PsImFN+0Dh+LDWMj3rvjbkyoD4u6IpKZGAhcjzYBZ/R60+IfL9OUps4o01Ko36ODWtkK1dVoUkINVAP7hkz1Thc7EIEQsNY7UKe50eN+4s8a9+8/f4pc8/Gv/StWl6vR4120IpM3lWJKZpUSuXGD9UYm19gBm3EAORZcsRAgwhiKRIwueIeOe1IE4Jl/gQxWmn4t/WMAQ6BNsyMYMw8zMykBgiNy2m8yeTcxAImfZJsNsM2dxTHJhucGTBxsPCKteZnl/EtMtsb+4QKVg4MMflSx9Sq5QxTZOyYzM9Pc7pM6c5dfQQ+1vbbGxv0OqHXHrnTQ49dxhzrIE7UQd6BP0uKooJoLDKKGkgTAtT2ghpYBgmpmlhOw4lt0y9Vqff6yWa3KJgJxNyDEJKHFuiVYjS0O32YtLnBXiex8DzCPww0yA+vFLAwSHhLSEpCT4UyRJao2SqYU841si8LHCS7D6jgowonJMRumK7HiBI59hcFMIFWYiUUSJIjgv5T5N8EMW2pMqAAu4XobOwTgz3ifzk4vmafOwKw1PEteG/onA4J2L5N8MIm8+RvF8F7puR+CIBzOn2UCPzNQPiHxTFCKT8qeVjE8BOd5/W7RZ7W3tYQrCxtYvh+WBoOv2QUGss22ZBKSxbYjgm5tomfu8i/b1N2nstNte2OeAqfNum3dlGO3VK1Qq2KwiNAZ4ycIVFT/SozPeZOmYir5m46x7uWA0QWBrefrfJL71Y44M/ucQTz53hvbc3uHv7HodPncY9chZfWmxfXeLKd6+x3zUwhGLcVdx6+21u9D1Kty0++/kF7r39Dr07K7x8oUdna8DxzwumDk8wP1Pl9vcvsH59k8aNu+xfNfnRH13luWd2aQ0s3MVJxom4udPizg/WePZnH+UHf3yPR89XWDwzwd72Jldfvsj4dIlOz+aZ/+jnabe2ubS9z5eePcNxrXn664+z7nV59rHTPPv0QX7rn/whBxs2X/u15ykfPcXO5jbv9iIuvN+kf32Z1c0+G5FDeXyamVoV17WYnJokjCIOLR6i5w1oti5y4+YVHNvAefoU6xv7sVSMROrYV6jT6eF5AaEKEaaBYZoIw8B2LSzb5O7SElHk0RsEYLgIIfE8D6UiOt0uQRBiGAZah/EuyOgTPG0/gSKIQ0TEoTfiCSPJN4FEIkomU5wpJGddxWmYmhAf7L80hF46J2Kp5mfIv00USYzIcmDeR9ySCZ353DyAs2Waruy+ZOiTvy9Kudz/+b7zi1g+zEwySTT/kOCXLvQ7J6YpmVOF++qRcws1p8NDBlsj5pIMlFMA1Cm8FwCzQOzjdUJn5Df2E4v9ydIduQ+jCCFwHIep6SNUKy6uYzK4FXLUG7Ab+OyhUcLIVkmtCsJHoQwtqKk5DOgPfE4cP8hO6w4CzRvvvs/8RJnTC5OUGpPstK5RrwRYkY+lbEwzwjQEju2ycLTOh2824w12JGwZgWPFecVNLYl8RbkkCITJ3gC0VhhSxDFESYdXYUuBoUAJgW1bdD0/zk2OwJRQNkyUjuJQFFrEu4bTfhV2Cseb8yVKCywzNlt7/YB6zcMZbHB84TjPnTpLr+/Rbvcoq0OsjjtoFVKtlBBAVbfZWv6QpdU9Wt0+GA6O49LzTIyuomw18TttdOghhMBwXKxSDS1MTMvGNC0sy8S0bRzbiXEPgSEkgR8iVYRrJMGvNZlLiCYO82MZkn63S7fbZ6fZRWMQhCFRGOJ5AZ6v8IKHLAwLiRAyxj4R+wBmm0BI6LiQQ8+ZRkOS/zjVxhXJYz5Xs7vk34kRrpheV+A4RbNves1wncNEbzgQdH7t0A3Stxm30pnEnJGzNAZg8tsVLSgF7pscITs3Hxg9/PYjlrV0V/8wAy6uB+SbqkVuM8nJWrJmpWr05HqZMdes2fE1qUaXHAclJAkPYrKX1qeEiLf3f4LysQlgz/expaK3B0JauGg6kSIKIiwitFYMQkWzL6hFFdr7+wz8HuP0Mbd22dsd0A88okEXicQPI9wyuKbEtBzMWgPXUIgtHx15TEzEo/HosQm83g7YJlpFzBkBB8csNpZbzM47yFJAqQJ+U7CxI9C769x44xYNG1bW+5x64gTdpkfTM1m9vsPhs7M0pixuX1jm8oUVPvv5wzx7dpyrv/MBC0cXufreOi9/+xqRChgzDXqbOxx67gS//Jceo+RG0ISpJx5je2mNI2VwKyZzh0pMzJzAiiDq7zOwbS7tKmZtgy9+7Rn8QZO7b1xE7reZHJvj8KOH+fD1i/y9/+QL1A8cpHn5MosLdVAWy03Fm7//AS8v91nZ7tLpD7CtgGqtQqnsUC6VWFg8wL21DbY2Nwkjxfr6OtVKmbOPnGV7e4trN64hTEmn1SMIFVJaaDSBH3Hv7iqVSolqycW1LMpuCddx4o0h9Qa/8qvf4P0P3sbzBszOTfP5F19gd3eTK5dvE2qBHanYZBIGIASm/XDNHqQSUUFiKjiZFEAlmXDpHE0DBmcTd4gWxRM3rSMjTnl8vPT8UdNA5sCc3TOfsGl7hpr+gO5kb0V6B4g1eOnBBKxEgngiJw86IUUZEUvaWiSA6YmpfmY0g0i66g8HTNWF68jbkL6neN6oz2MO+GK000OkJx14nX2ONRJ5PMBc9n0AWS+apB5ikdJgbGyMTz9/lu2dbQb9PurgApYpcT2f+mBAEEWsrm+gIh37WYlYgCia74c0IUlJSdP15VVcUyDRoHy+88PXeG+8Qa3s8qlFwWRd4lYMAtvA1AZSx36EU9NVjj0xyUTZRFQcymWbWr1MpVqnWp+mWhvDrdcp2ya7vQ7/4B/9Nutbe6DiGIFolez41WhTo2W8Q7jsWNg9iSVl8pxpBqHCD1MyUZAh0lUpmVhKazSSnq8pRSoROiW2YWGYNqGK6Hb22N5rsbm1x8rqGvvNNlbiyGhbFnUDoiig3ekxCMKY8FZqaMvGrtYh8LHdEqZVR0uJ6ZSw3QpCmpiWiWVZ2LaNacWbRbyBjxbghyFRGFAyIqo29HyNPzKPpCEJfJ9OFLDXGtDp+4SBJtIKrSP6A0XXi+j0eg/xKYQ4ZEjRCpLOt9QakWvRM4FtWAbMMDIlVqNZO7LPBZI3NOP0yJvCtcWbFDfMDVtqciAfIonZscIcLxLVFAqT5yzHvwytMiKndNFFR+UCyohA/FGkT9/3l5zJDY3LSBUjHzKkzGE8F24TIpwRv+LYJcQ8zm8Q/+Iq6UN8mc7GXcBw+MU/o3z8TSAWRNKi2/SxjQGTrsdkvcR212dzp4NCMghhuzmgMd7DsWz2dzoM/ACz2WF5s41pKrpaYxmSVtNDa4vyeA1RqmMtnCBcvUGp6nDh8hILp8Yg9JlsRAT1CGGXAYXXVzz1+TMc+cIZ7FJI+/Y1Th/V7K6UmD95DNwOoWxhO1UWnq4ycXgOw2/zqadnMN3jlGdrKB2yu7xBdG+FsjGgNDMJz81TqTYoTYzTGtzBlppHvnCGM7/0HEZN4Dl9WksdZGhiRx5j4z6tVsT0WJXmzS0qlkZWGvSUwHbhZ772LGFvn6ULV1Aba3DwNL/8V3+Zd155jSePRTz1zBPUTxyhc/06g+1NGqeP8NqdPn/8qse1u5uYtoVpmhw6vIgW4LpWbP8Xkvfeu0TfG2BYBit373HoyFEef+w8L730I4LAw3Vsbl6/wYlTp5DSo99XICSua3L06CFcx6XRaDA2No7rOpRKDhPjdTa3tlFKc+nSe+zvbWFbNt//3o8YeB6mZcc5jQ0LwzQARbfbxe92P/7T9hMoWscSli7MF611LPWpeJqpwswbpQ2ZoigFxZR0FUjeaOaKIbL5ILqRgAy6oAEogFVmyh0he3rk3PsqLXQ6a1+6OKekbfRY2oeR74fbVGxmoVe6+H3h5JQhjyJLwRScIppSeaqxguw9XGtadboIDN2XbFHLF7D8pNz3JR7zFNzVQwxIrrWm0+ly4YOLbG9v43senu+jtUpi44E0QCdx9oqSyCjpK/oDZjvOpaTvR5hSo4WBUNDuBwyCHcqWJGpaPHG0TGOsTMVxCE0LLSQIg8n5cb70d74E5QbVUgm35OANegi7TqU2jkEYkzxgejBgfOw7rKzvQuG3SmQKDKnQlklkgGmILN1bYEowJYaO4o1ViISuxzgjkodJ6/jpNwyZPO+CIAL8iFAJAi0xTAMVKQbegMD38IMQw4iPaw2eF8WayTCk3x8w8AKEIdFCYVuSe7fvUKtUOXb+KQxDxsGvSbSRUdw+w7KxTAvXdTANg8APGfg+k1NTWIbA8306/ZB+CMHoYyRiAqiikHY3YHe/QxTBIIjQ2iDQmkEY0fcGROrh7gKOtaxk/4VOzfqpwJgToqEuZc9eOu+L5IOC0BeDVDGjxUgD7n9b2B2bkTvNkOVDj1Y2BEjD5uz72l68e4o/meAaa9ujJGf1kDCctSdljPoBNeZ9ud/9pjBAabeK4zV6bLTBKQwk61Qm4CftKu7Gzn+HYYNxnP5RZJXFgrzK+p2thff36CPLxyaAMpQsbbSIhGS8LDlUd7BsGwwboojVnT49P2TD8wmU5thkHdOAzesd/FARIhA9jzCMQAi2uwOU61DrddDlKhUVYdYn6d/bpVKrsbayTX11F2+nw50Pd9kx32bu9BrNvTZ9z8K9uoRyBc3ugN/+/jaznsmhc8vMf+oYFe2w+/49Dhw7RGVyguamxze//R5HFyd54VeeQowtYCuD8vw9/vilNY55sxiBAX6bxWeO0rp3l2CrT2d/H7+1T2fDY/N33+bwpx7l1pUdyuMO17c6bL53j1Nnp1C+wdKmj9+6y/zRGkFksnG3yerSLtbYDOe+8gzjZ46zdHuTfeVg2AfoEbH+3de4fHub3/uwz429PR599DwvfuFzXPgn/x9sXWJm7hCmYXDo0AKbWxusrW5gSpNHzp1hbWOd27fvxH4y1RrvX7xIpVLmxIlThFGE7wdEGqYOzLK+so4OIjY3t7l46TJPPfVkEqVfg1AICXv7+ywvLyMAy3LwPY/AG9DttBFCYhgG0owDrNq2jWUadHs9+v2Hvws4C3Iq091ouU+TLs7bog9ZgchlsxEyVMomX0H0ys2XIq9vqDUZTcnaltafYVyxLeTvh++fdy7TtxVIQSyBJyCgY4kvA7fsdZgkZuLgfbcR93O5bND00NCkVHgUSHN/wLSTw33P/qZtSnfqFvqXHChckdHtfOCSdhZal0nEOulzHnLl4RWtFd1umxs3eoWWiaHfICowiQctwg/6LtUKyoQURjpO36h0RJzYRiIQrHUCXn5/h2OHJmmUK7GJ2TDRMs4D3h0EvPzmRY4dmuFLLz6Lr23eeP0CX/ri81y9u0+l7HJsoUHJsTl+ZJYPr92lOOZojTQktmlgVMv4RpxSzjQklmkSNVxMKZjSAi+IkDIJ35I8m5l5S+s4wwnJZwyCSCONmNiGShEpRRj2IRT0uj36PY8wiLJwVEEQENmSIArpDgaEYUjZdggjjUSyudOk+eob+H7IY089TW18Ao0gikCpONOHYRhYphm3XUU02y3q9QaNWplBf0C33aHvR4SRyoS/YqgNKSW93oB2Z4A3CFCA76vY2iYkoTfAFBGOa/1kH7Q/o+iMAMakQmW7l4l9O4vzOpk3UiSuMSlqJYLwkLUBsvmp0UPBDoYwTQ+9DBUx/Cc7mnKw4RirBWwWOQI8uM/pa/Hm+cYIhMAwjCHQKOJL3qLhTqTL4dC9Rr/P7lGoKGl4HoB5VMouNICi+1BqcUnIqy5ieKbzi7uRkOIEZeK/SmW7gBUxDmrkA/vxp5WPTQDXtge0+oqyVOwpA7sME45JtW4ReB2ae5KmVjQDn+7OLvu9PgvVGqaE0JAEocbr9/GDiN0gxDRM/O19DBMWfEXVLVGrjtHe77EwVufSjQ3++Nr7VIl4enEcShb/6rcuceGtdR49EeG7PgePzmENLO5tC2rK58qbNxg7XGfJH+PahcuEPljVOpXFMb7yy0+w+f4NNr/3OhOPnaO6cJAPZ47RkIeYna3TVAM2PrzB/OPnaDwzD6UyzcDEb7bZXG0z//RJOvtdWttNOssGsl5j7ECVhafn0UaVKWHg7XdxLZswGDB1LmD1X77H7k6TV771CrPvXWNfwcUP7rHU7rMXOqxs7tEJIgLTZWZmnseffYYf/PDHhKHi4OFZfG/AwpEjdPsevhfy6ONPMNEYw3UNXnntFe7cuoNpWrT3dhgfnwCqmLZFv9MmUgGDfoAtBWONGs09j8NHDnLnzh3eDEO+/nM/x8TkOLZtUa/XsR0Tx7ZxHAfHKWHZLjqKnZqVUgRRiAoDGMSmrDT7gSEfLujFodcTIqTvP54ROhH7wgxZYEeEvcwkmppWMwqSs6ecqxUJIQyjwGj9uaSZ7XrjvtOHCVpS99C5RVNtKpV+gte0lwy9LSz02b1TqTNxyC4AVjpKKchCMtTp59RcW2Ro2XmpWBzT9IwUjrRLFKKtiqyOfCGO+UROOlPpXMbqpyTUyQMk+Z9yUSpCCCPhOkn7Mw1H2o9hgvegHcFFLWDsX5ufM1Z1qNiaCEEUqHizhoY3l9u8sLTL7EwDV0gsw47rURHTU5P88jfOUS5VcGybet2ku7NJz4P3Lq8zNVHn5MFJtFZ89unTXL2yjG3b2KaBaUosCZoI39foKKJUsjEtm2rFAaUxDQcpBHUrjtGnlMYLFV4QojI/wDj/b/p7K5WnhsvWbqURWmMIhdBx+jmVaEC11kgUhjDjJ01pPD9EqQhDxttQvEEXLIv97oAf/OhVLl/4gKMHFzlx7hzTBw/ilMqYlp3ggCAMQ1rtFuVKmfGxGmhN4Ad0Ox3CxLoiVL6RJQ1xJKWg1w8JIkWoQqJIooSB65bodts4joWUDqb8BCvvT6JomUxGnaqXyFJYxlOTlIBkZlcRE4thCBDZ/BGZeDUi1KWwoPPPhW+HiGH21CebEnLhN3FDSc5N4VpInWSySI4XmkVWT5FgjbYnaXemOkxxJ+54Sg7TNqR1pGQLXZypI4SvONxD4SLSYdeJgJ4PaNqu3HfvQaCfZ+5N3V3STTlF/Ciucdm6lPmip+b/wnefsHxsAri018e1LXpegGsbbO73CAcRc/MNbMvFsj0avkFTWiigOwhoyh6TjRoq0vhhQKgEW35AO4rQYcieL+l6Hhv7PXZXt5manGTSEBw56tBRVb756jZ/+7kyz3/xDKUnnuJOdIk/fmmF5QH0r9+jt6/52q99ji+8tcFhN+Tu7T3q37nAk7/8NHderrK03ESry8xvNJh+8jRjX32el/6H7+Je+RGYJlfW+hx49lmmF+dY3trjzjv3eGJmjetvL9P2A0588XkaJw+h/BuMT9RQAcyemUVFmupYg5X+Pjvv3aVr1IGQyoFZrl++xeLxKZZvdAHFI4/P4knNO6/fRM3Pc29sho2lPoYVoiITYdp4Aw9DSqZnptje2cKyTbqtFgcPLnLt+hUMTP7GX/+rvPnOe+w12yxduM7U2ATb5U0OHzkIQnLm1CnGJ8b4/o9+zMnTpyEICALFxPQE12/cptO6SaNe58knH+PCexd54403OfPIaSYmxmLTlQoQSBzHIQh8gjAiikJIYm8JKYiiiDCMEjOVgSEMJmdnPvFD9+cpQhu5JFskXHlgqmzR0SpPeA4PIICFmGhZPUUtVX7X5G+OcDG2ihyPNKT5lTR6eCoWJeH7eePIvB1eJLNOZYA3TChyIGOEXKRANQTzw3Wmx9NTC1K1eMB5Q/41WU0jhE7ff/4wCSIjTCkwpoQ1/aVE8cTCdRk3TF+EQGQGyP8wResoC0UzGpPxQWU0kLgQceBoreNwI6PnVF2Lk3NV+l7AXsen3Q9QCvb9kNev7PHU+YPUajbScLBNKx5HrajZBjsDST+M0EaJG7shn/JCym6ZvdYAbRjoEM4cP4oRRgRhF2UIHNNAmQa2beMYBsKycF0biaBilthpDYhUHILH90PQccaRMFIEoc76oiDO7ZsQOjOJ3SmTrcGhUrE2UApMQyQLn8pCysTaTpWY+AW+Hyb3U6gwYmysTMm1EcY4q+ub6Chirztg5+IVLl66wtz8HAcOH+bgsSNMHziA67ooBLV6g1q1ihDQHwREWrG7v0+SmRRDxAusSkkCYJsGnh/geSFBEPfJbcS7h6VpYlkGBuKhE0ChZbZJIIWYGBsh8ytLBNchrR/kYUMK4l0yBGRnisL7gvCXAqAg556kZHNEIL4v6FRG9JI6M4HpAZg7ioEUxNAM8wqCVfI+znqTtvOjkKFA5gq3GW3Fg0zJ2eVAEkhz5GDS/Iy4FrBxiHjHJ6ZCbhL7vLCOpeM8jOFCGrkwrOMnVUqJQiKi4SBUf1b52ARwvd1CIyjbJofrDlUBnuex1+zSsCwCLyAS4Bpx4M5+FLHRH1ByTCrlKhJNSyuaXU2AwNZxhzuDkHthk2azy4Fmh8+dOU5YFzw5U+GfPj6LZZbRooS/ssy5RptHjte50+wzr/vUast0N1s4s/NcvXGd1W2f97+zwt86VOUrv3CCvR2Xt79zgdZOC7tcZer5SZ7/33yB7Q+W2N5uc3pasOsN6O22GJOSwAXv7j7Hv/o5Vj+4inf3JvLcHGOHF2heus4ffOsaar/NWEnwyHNz3GhLLFWiPKZYeGSB1V7EO/cGHHq8xs6921zc0xx+bobZaZfOsskNa4oebWzXIIgiSrVyElogYmd3h+vXb1Kp1piYCDl85CDrG5v0OwN+7utfox+GbO3tcuv2bRZnZvi7/+e/xT/+R/+Y5TtLPPvCC2zv7nDtxk3On3+M0At47oUXuLO6iuNW4h3bpqDZavLcc88yOzuDZTm0223ckkO55LC31yRUmntrq/zRd74X5xM2DKIoIgrTAKkCyzQKT7FkYeHAx37YfjJFkO5+EyKObSaTf6mmKJfECibCBKmyXWdDbGP0FqNTjrTC7HWUjIkEZXMH5xHJ76MI3333H9GUDZl2c21lcRNIcVNHbkIebt/w7Yp/40HIAscmh7Lv0uOF71P3gSIJHOlCUaQelaPz+xfMJsXF5AFwmjVKF+pMtUpKEysZ/wOU4Z28ckgDOEqAh/3/4p6mhMkwzCFhJS1re31KpoXQPqHSGELEsekMgzeXuvzqVo+5eRfLtHGMElK2EcrHLVlUHYcw1NTH62jLwTAFlXKJm1fvcOtukxMLY0xOTzE7P81es41lShxDIA0jzjksYmqtdayRMy2HRsOMoz5EGkvGz1sYKcJQY5ixcBhFmkBFGBkBTHQdIg1QLVFRokGVsTBnyNTdIEp0GfFfjUAagkirOBA1giDSBKHPjHDRZZfZmWmazRYqipgOQ9qmzVqzw8b7H3Dh4iVqjTHOPnqOw8eOMT4+QVu1iVQcUFoaks21TRp2KkwoIiXpB4qIWLtcce3YdYn4WauOjRNqSRAqXNvENMwEex62GJLgIDrxbY5jOqbhd2SaYzfFDnQmeGnSTDpF4jfi4pKQj/ixFMOTMy2jcz3ledk0HxZ8c2KZbwbJT0vnR6EBjOJAcp8HYLFOMCo2iavcP3jIXPygIgrf5/hUXB7yhAPFrufEE5Hi8ANY5P13SsZ0eP3IvqMQPKZAAovkffRfjIUq/u4ThMT62ATwSuhREZKxgULt7HN0vETdErRaHaTtEkWKtuezFwSJ6h8GkeLOfpcDSjNesuO84TpW+0daAxIzMT855RInTh5h34fmWonqqTkMF8KBBimRjs3+QNHqhrS2+txtKcqY8KNLPPmpM/y3d7botJvc8+G9d9Y5+vxpvBtrPPn1T/PS772B/c4S7lgD+8gCgQu3r63gTE8hG3Xe/v4HyG6TwSDk5qtXcCfvsnjmII25CnvL96gcO0Hj2SexXlqnuemx45hs7pjMPn6M7722yt6Fa0zf3sGen+HCjQ73fuMam4M6/uED/DdvNen2VukrG0o9Ov0epmXhBwFyIBGGoNaYZGJ8nKnJCcbHx/A8j6Xlu3iDgFMnT3L52g1efuUVlpeXmZ6c5Nd+7S/xzHPP8Ivf+AX++f/4z3nv7Tc4cuwk83NzhGHIpz732ThEimHT6vQZ9H2EkKytrXLjxi1OnDhGrVYDoF6rUak4fO/7P+DlV15nZ2uPveYWg34PrUFFMfAZpoFWmjAMY5BXCtctUylXPvbD9pMoIjF7FCdEJpEWCB6QA11+FsMfUmPikAid1Ty0ozW5aBSssvIAAXb0c1GDmF32wDUjB6wioBQJxSjJKPrX3a89TMAxAYjh2+RmBIgjAItCVoHkbjkhRSM1WZJ5pXXmbzSkQ0jaXjSYD491fu+PVJgV+5+qKWWO01rHpsWiR+J/iDK68Ge5o2Xat9zEG0v78QqdCiemaSbnqCFyiIYwCpmsSurlCp1+SNvTDIK8riv3ujz2pIMQEtO1MST0+h67TZ96PSJyTMIowBCK/b0epmszPjHO1dsbTI9XqVSqnD2zyOWr92JNArG5OQ4InWooI8IwpOdpwkDFWQeUwgsTD6QoNvfqJDB3nJ0i2U2sVMzODZLsIbHJFykRUsaxCqVAJQQrff6kFKgwXifCMCSU8WYRQwqCULGxN+CIdhATNmNjNo7rMH7lGj/f2icca/DBmTNsNyYIhGBvZ4fLl6/QG3gcOX4c24x9JR23TOj7ie+zivuMQEiNY0p8FZNZxzJRoY/WAstxmZiZ486dJVzXQcrYdOy6diIcP7widEJahRqCm9i0nswPHafgg1wQkwUcSude+tTllVMQ+kRBeLm/HTo5PiRPi9FzM1BO4LNA7kQRF0bm0kf1PetV8U0Bu6VBYSaRmoH1CBlMhesHCvxZO4eQLXmfC+ZpWKysR2IYjWKMy+sofs6Xo1jTLcjHPIe9lFjm2l5NvgEu3liS9u8jBuwjysePA6gVba3YFYrtfsSa59GQkpptMWn1aHket3oBoYCSEPS1po9m1/fw2opAVWiGAX6k8YVCIrCFxjYlh6fG+PT5Y0w2xlmPJJsSeu8OkDQxax3GNiTONcl2t8+huQqPH5/iUMOkOlajb1vs3lnlK+cneXu/yVPTZU4edLA3V/jwTo/puSYv/vLzvPq997D/+A2Of/5Z5k4fZ26lxXhjjN224ublVWYfO8hjn3mc/dUW/+N/+W+Zf3+DL71wkMkXz7J+4Rqnzp/hq18/T2t7gGc73AtNrm9FfLgjWdXT+EtgrffQzgFubkeEYUC55CNEmdAxGAw8on4P0zbpdjt4g3iDhWEY9NwuntfjD7/zR0ghabWaeH7A1MwMly5fotdpI9B86rlP8df++l/j6eeeJgoDfv7n/wJXLl7m0qWLbG+u0u3s4fkRb771FhroNLugTKanp1GRYmxqjE63RRAEVCpler0OvV6P7Z1Vfvu3fod+30MIyeGFOUzlsLq2TrsXoYm1AVGkUZGm7wcEYYDrlgtanIdTUhV5SmR04visFHEoC5Gkq8q9jdMrhybz/dM5LkUXuNSJ+j6iWawiBa0h9CtUnwKeppDOLK1E5GxGjFxaAKpcMzeqFcwJ0qiWbpSAIWJNKcU1qogWOm/zEA7rNHVbAjvJMMZ6hzjnrBYjBOwjH4nCWQUTr8y6N5zfOdUS5EOcwWfKXbPE9w9T+xJFUZyjVghGTbpFc1ZxeFPzbnxeXIdIHdbJPw/tCkbjB5qVfZ+xwCWMZEy+koXM17C0GxJpCdLCtqvYlkXP7xF5Hre3PMbqBu1uRGNsjN1mm9NHDgGKM8cO4JTiPLmz01O8f3GZSAXZZiNDCqQ08riWhcUuE4vigGRoqZEqthAECJROUi4mGus4w4ZCipiMRDqOXWeasRa/ZBv0ohCZ/t6JSSz1IQ0j8EIVP3FK4UcK17aoOjbWZJ1QGUwIiVhepbeyyqLv8xe6bW4dP87tx5+iNTPN1uYag36Pvb1dpsYsHjk1i5AG99b6RLofxxZNJoEAzKTfIeC4JpZlIpVmduEghmVTrdUwpUCpdMOMwjAfshpayzjygSLzV8zmhyrgTTaPioJt4TWrML421xomt8nIyv1zrICuIweHUwPmMJRi2LBmMZvP5Ljwp3Y9XQdIX3NMLFpCcnl3uM/Z0aQNQ/3NRoIsZmJ239GOizwuX6Hr+UnZelFcIFJtd47rYmRdia0hw6Q4i4iQ4rRI0zuS/b4CwUdoFR5YPjYBNETMSEMB+xqaGiI/wPQGWElibY3A1LCjNNWyzbHxBguNMmO2hbRM7ixvcLcVoJXGlII2JmNjE3ztM4/iWiZSGDxy/gla26u07oWIlTXUfo+B6CKEpj5X41deWKA2XkWWXXZWWvi1Gu74GE8cnuT5LzyO0enhlGtYdLi5f4E/+eElfvZLZ/naLz7GN//1mzS/f4FPT5U5/9kzvP6tC/zxh7s0l/d46uQiT+sQU/Z55LEDnJmA6oRNxQr53jurXL3SJpiZ4updxRt3V1DCpOf5BKFG2BUc14nzQ/Z6CCmJwoB2GKK0JoyiZJdO7EdnWTalUgWBxjQNJienWDi4wMrKMlOTk7Ra+9iWye7GKoNOh7FyhZ/76lf59b/x15iYmkJoRRD4VKtlvvDlL1CpVNjf3WVlfY0PPnyLVrsDGur1cSzTpttpYgibMAywbJNOp41lWRw8uIDWIZcvX6bb7aJVbIqybItjh08zPTfDneVVtrf3aLXatPt9lI6zBgD4gYcfeB/7YfuJlGQDiFJJgNl0sRS5CQCd7Ih7AC8TKRsrrmuQ+RkXpdPkio+GPVGoWwsecGJ20lC9udj34C6mbGwEgIcIIOkpBR+VB77moFtcAFK4yvm7zvofg09Bo3cfT8y+yToyJJGLvB4KZw5/FMMnkwRHLYBXmoIv5vKJHJz85jJRcQidpNt7yOa3KMmAI6XMglAP+ZKS/twpqSPzfVQq9vfLP+eav1xjmIayUHQGASXbivtKelyAjuj7CnSMndIuUW9M0kt820qWwDIERAZjExO0Oj32Wj5vXVhirFxicaYKmBw+vIAQ7+RtFXHjc21DTr6FkGgZE9F0806c7jDXsKSjoFRu4hZSxEIaMSk0hIFlGFimgW1K+iJOG4eQIFS8uMlksxkKhAlKoEJFoBUTZRdVKVOt1jENG8N24Gs/w9vzs2xfeJ/Hex0eu3mdk7vbXHvmWW4sHGRnb4/Q6xJ5Fr3mFjPzs5x/ZI5/9F/8PV55/X1+9NJ7XLp4k1ariyE1hpQYSqHCOPWbtBxOPXKO27fucGhxHikFvh9gSI1racKHnAqOdLHXGhLCJwXZ5qhiYPkhb5SMVBSwLZuGBYFqiJAUzJsj+JMTJz2EA8NYmgJsrgEszo8MUosCVQFn85f471AqxYwIjuBj2pZCO4fapu9fH+47v9ChIdxLMUtm7Cvva1ZvSpzzG2Y/yShcjTDo7DdKfwvy+8SWBU0cCDp2WxAy3ogi1Mcj0Gn52ATw3Fid250+fqSIVITScSBMT2ssNGOGwbRlMlt1ma+UOTU7wUyjRqPqUHYdbNflM8cO8puvfcDbqzsEWmBKgxMHZqhXaih/gB+FtDo9vL6PWS1Tr1ocfmKaytHj9NY6BIZgvxNy6b0tNgYRzcDEGLOh0qHzVoeeH6KVItSbWCJi6y6oqM7O61t85rNVVmfnWbm5RvWdFU5/9Vma1QZPfXaMmbEyC1MVGq6Pe2ScX/vbL9LeaLN8fY233te8tGmztLWJsjvMHjnGQNo4tkvZLrO3u4spBbZlx6YdIRgMBvT6A0DheR7SsJmemSEM4tRBhpQEnk+tXuPcuXMsLB7g1tISvW6fHb2DYShsqanVahx96nF+/he/wbnHzlEqlwh9jzAIePut11m+dROB5uCBSXb397h6/TbdrkfqFCtFvF08ijwM22TQH2CbNmP1Buh41938gTnura6QLj5Kw/Ubd7h5+yozM2MgTQ4fPYofDFhavker3WEw8ImSGGee9/AJYDYDEw2DFnHoDCFih/N8HuYiYtEUfF+VhT/ZLrrsS51zkmzm66GX7EOGLkXSmIKGSJlVBgCjkQOGudj9UmIR3IYCQaeLb3qvom9JAhwyIVNDbStghci2oKWtTUmdIEct8mOFnuXjlzU+rTRbPLIzi4tFIZdzenrR7D6MiTngD5X7Tnw4RSY7VVNzaJEIQpGQ5oQ8Gz1RJIPJjr4kw4YQgigKC+FtJF4YZq4YGrJ4lxGKZj/OIazsWGNXqU8wpvZZ3VlhW3vM62mMss309AT3ltc5d77OzPQY2/tdNIJAGSweOogwQISxKVcIUBKEVghkYuYnfvZUiI4iUEl4EE0ckglBpGJ/wCF/JNJsIIIgitCRRhsRwrAwTQPDNLBtC8uKkIaBIQWGlPHCqnI/xDCI0EEYj40Gr9djq9fBX1mlWi9TLpUol23c0wvckj2a71zmqc6Aw9EOT/3wB8ydOsWFRx6hX2tgOA5Xl3b54OptFuYmmJ+b5UsvPs0XX3yW1fVtfvzSq3zvB++yv99je7fPraU1pJCce+oJpOkwNTVOtWLjB5qdnT3m5iZA+bT3H34g6KH/IiXrBfFqiPkx9O0oT8i+GSKLCenI6Az5HP6z7I0fpRUb7Uax0qHjOu/Q6HkFmMlhPsfGIU18dueC+TnFYApjVLCHxykSU9Kok3PTcRMJH0srSJeGoYWCdL7ft6akmJCtHwUgzhlo1uahTopcSMyIYsZSxQNG8U8vH5sA/t3PPMrF3Ra/8/5NtrsDhFJEiRP+sUqZz85PM1sRaE9RwWBMhVjdPpFQOJUyrlOlVm/wa2f7HCm5vL7WwrZsnjl2EKSFH7QJQ8XqpXcouzYTRp+Jwx63NrqsL3ncbQludgRr+4LItvGCEMcqIdoDkAF+FGYpicJQo0WEEGVEpcpyoPn+H25gWjal6iK3P1DMrF+h1KjTMATNrsuqL3hzeZd+z2fQHdDpKu61wbN8/NIYkwfqzB0+xuLhI1y4cIHrN29SqVZxyyWiSNFstbBtO0tLZRoGpmVjWSahr0Bput02pjQYn55m4eAh5hcXqTaq7K6t0G83qbgmvc42wcDj+KEFDi/MsrAww87WCivLFVzXZWtnHwS89frr7G5uMjU+Tqla49vf+Q6GabF48AC3bt0kfbSkNIiiGIjnD8zgeT2EANOQGDLe1LG7u0cYBaAlQgl6gx6t1jb37q1mvmOGaTA1Nc7YeB2pJeWSw8rqOt1O5xM+cn/eIhOtkMjJS/a/KNEmvm2JP1sqm2YmtkwiExke5HSuIJEOAVaugteF84bjWRX9BBm6tghIuc9eTqCynXhJHt8hQVGkBDJ+zcLLJCa79PrRXLOiAHaki3j6pc5fs3uNEMvhUmh/dqQAsg8+PW97gfUKPTyu6YuGRNOV9Cf9NiETiNT/MA8tkgP+wykp+Utf0/9FM+5wKTx36ZEC+Us3gMTfK5SKst9RiNgXLtWkpbEu03Ev2SZ2FGf5MU0DQzrUK2UGzU12IodOv06tFFCvulztdHjt7cssr+2hDQslFI6tmZueZKxaYqMfb/TLrb4iy8ySjrnWECkVu4MkJC9INH1hFCXRA1QWpDu1fDRKDl6oafVCHNegZMYbMAxpJEKCwjSM2C9QmAgZIEVE6vukwpCKjvAEBIbEDH1u3r7LggF4FbpOhfrEOBs3b3F4ZwV5tMKbW7AZwSPdHgffeYexG9d5+6knWTl2hIEfcnPZ4+bKBkcOeZj6KidPHGZ8Ypy//Gvf4Nf+15/n2rU7/Of/+f9Md6Aol0yefPIZLMugMTFNo1bGdU1OnTuK7gc091vcvLn203707isx3sjcZJ5qBAuCVgwbRcHsI+oiF+5i4TP5MwIhaczALFbiRzVOF7BhhHRmGUbEMJYPScjokapygTKb81m3isRWZ3BTaMAwtyrc5j7s0HmbU5eE7BRReB3SXBYxsSAg6+EVJFs3kk9FLBZDJ6Xm3Lx9OvtR8j5nWXuGxuXjg+HHJoD1ep0vLc7QKFv8zmtXWekPUEoxW3L52smDHLAlwtJEtsAR///2/vNZs+2+78Q+K+29n3Ty6dw334sL4CIQgECQhERpKImipLGs0YytqQnlcnnKLpdrbJfLVX4xf4P9yu/8ejxjy54iPSNpJEoiqREFggSR08XNfTuc7pOftMMKfrF2ep5zGmiMiNYLnlXVfZ6d1w7ru76/rDGZQeIZpCmpr1g+fkKSZYzHG3zu9i1ub+6CMtzMxohUQmVYnJzx3rSgXGgOT05ZVpKKhNJbyiCRWmO1oao8QRrmVYGvYiSU0RqlFVXwCC3RMiGI2jxkQImYuiTHcKQzZktDcbrE6AQllzQReFIalkVgZ2eH5Jrk6MkRWiakmebJkyPu3X/AfDFHS8ns/IyiKLh5+zaEwHQ6pbIWW1kg5sgLXjIcRV+au3df5LXXX+PR4SPuP3ifD977IaGsGGSam7sTXn55n4OH8OTwmOnpjHd94P0HBzz+h/+Uwkqu7e2zu7fLtWs7vPf+e9z/+BF/+2/9LR4enXH31nVMmqG0weXnBO8oncB5RwC8ryiLir29faQSZIMUk2iePHnMhx98gK0qlDSR1AuJMYqy9G1SV+89T56cxG9eSjYnI7JBxvHJ6TN/bH82TRCdj+Lv+PGLLuLL+ZYRit4gbSU/epIbHRj0ZNXelXr7N2vqc65jaJygaQGxf73mHC3QSdFGP14E455/XxzVrSTcdyS+oAls9umfI7RbWAWbDoba+18jUX1fk7YvdNfs/11nfuv3DvGb6WBx/TlT9z20xHDlOa9xxQ4H/VP78Its8fOJbi99v72VigRNrq41QtjgTONGoWT0g4sVVEJr+o01XuPNVs6xKKNW0PlujpcCXr+1TWYMWItAYESCVxvspgFJjry2x9a1LRazU47PlvwHf/dT3LpxwPXdCUZIlBDodMjG/j5/+M13cXUgR/M9O++iAFmTPReaEmjdrNpMls0z8CszLGRGM8mG+BBYlh5pYCDqDBo1noR6TEsZ/SK1lDgp8T5E8uIcSfAMEZRJilhapAqMDNy8e4ej8wXWFRx8cI8bwqJDhRtoHgVF9sZtlqdTTu4fc/JHX2cxkGR3X+VTn3gB6zyHh8ccHx7y/e98QDJQ3H3hNm998hb337vHv/tXP8VwtEHOiC9/9St8/OBjlFZomTAYJoyHKQ9OPyZ3gsOjx8/l+2u/pRBzIAhRuxCImAwYEd+XDw17uGRssyYoskowiLvEfWvTfft/f6iFp4+8FkP6g7gvtTcEqydIN/uI/t/e7xikI7uUKS356SFc87vXt+hf3PLZ1b73fbPrvq3BX728ZmlpUums4JNYEcIjxNc79djeynxUd6rBvj6+t++g15PYj9AqETzRN9/3xuCztmcmgCIE8sWcV2/v87dePubgPOft2ZKXru2wIwMuE2R7O2w6wRCFCAIpAlYb5irBC0uxOEcEifSe2+MRg8mI+fwMgUFrSZZlFKcVf/LwCUUAoTShdhYNSuItCGERSuGtxVqH8w4pFbPzAmurGF2GiCYTSQssvs4xFQtngzKaqor1bGVbUFuAkJg0Y5nnmMQwO5/hfdSA3bh5i+kyZ1kUCG0YjUbsZRmD4YD5coE0hlTFHFoNodjZHWMSRfCOEEp+/MNvgndUZcHpyZzp2Rl3bt8in0z45g/eY7aYEbzk/PEDjk5PCSGQmYQXX3qBQMnx4X0WixOkkrz25ut8/yc/ZjQc8san3+KFuy8ihePozhjlS/7RH77D2byEEBgOhwyGKXm+pCgKlouCqvI8eHSPDz74gMp6hJEIr/DeY5Th+p0drHVkaYZUimWec3x0TFlWnJ/PEFJQFf8Wyh/1v0vRjcFGM9jm9wNoBr5onNKhw4n1SayTPAWd1mMVDHpi5QXw62hkIx13yi3R7i/cReLZd/NoNvQNoaE7fU9CjP1tQblXEL25v9Wot9A+MwJdLEq7sv55AXkax/DVJlaeZe+x1OcN9Kuk+Ha/lTmAVdNSS58bLcYKCezNKII6SIFa6/78IjC11iuaDNEDXtmYzOq/wXf9DCFgTMLm5gZlkbPM8+gPSPdcmvevlaq/oRjhWQJSKYSKpBEhSI0CrakqS4rFiUDwjmEyRKYeN5tx9u7XyZMv4XEYGZikgr/0hTsoYQhCcZbDOPXcffE2T06neGJgDyLq2mUsQYISII0gqd1cZP2OXPveiH5oxBWNa5QWitFAM0oFcydo0nIEumARYwwmSUkSjdYaqSqkEoQqfjfeeqx1jEJgJCW5UohEI0JJUeR875t/ivUJN4aet25pzu/NSIzg7qtbzM8WPD485ZtCUu6NeCcXuO/+iGv3D6jSMWF+jptPefTwCbd3J8xuvMA//qff4ts/eJeqsHgneOHGAqUD2WgDpQzXr+2xMR4wGWWAYDabcT592CbOf26tSYqPaEdaQ6WDFMhaSAm+iwSuD+y0gp2YGzetJIJfFSQb8vHTCGBfqGzANqxCSb1fD9saPGotHM1w7/VPrAFW6KGBEL1+9PGv/tsKZk2HV5jpz7QedOdpDuk9K9F7PL2925mkxddurmrxrT5pC91NJ0O/d/1dA8h+F5rE36ImmnUi8wsWiKe3ZyaAw40NinKJKHLGo02GUrO/uYE0GpFqxhsjsqAZGxNzAVYek6ZIbSgLFyOskoyz8zlKa4aJYKgg3R3z6OiEXARSk/CV2/vMzmd863RKLmNovtQKLQxVZZFKYMsyJikGqrJia2ub0TDj8NEjqtJilCJfLqJvjlJopfEipjTJkjRKuTY6MkutcD6AVjGVAeDtkuX5EYiA0hqlFHkIfDg7hLocU+Usi6lnmaRIFf3PZBAYo9FpgtKaAFTVOVXuyMsCqRR5UTI7nzGdLQg+sDUZYauKH7z7HlVZslgsan8swSBLkQJu3brFtet7ZKnh5OgQ5ytOZwuUztjY2Obhw8eURcl7733EZz77OSZ7L1AevtMmYkXEepfGJGxubYKQeBdABP7Fv/gfmM+XeB/QOsUojXOW63sb/J2/+dd4/c2X+f/+9j8BoZjP5ty4tku+zEmNIhtkZGn6zB/bn0WLg60/gIgkQUaKIkWMdG00LR0o9IZUG6Zf7yPWr9DSsnavvsTWs7B0ZK9t9TE9gtDf1AY1rN9ThOro3xV6mq1Ws7Su8aMnJTbG5O5s62S0n2cq9PsgVg/p0cCV3y0A0+URa7P60wUBdIeEHuldRWS/smP3JpqrtpRQ1M9P9IzlgZrgN31ont3za//5f/LvoJUiVp4VOHRN2EALgdaKLI2pXcqqghD98zySdDhia3uHoigoyxwBJEkMiFAykJhY/k0JiRQVoLA+4LzszPmESJQEJNWU0/Nztjc3SZ1gfnYAw23SdJNBtSA/f8T5d77G4ULxS2/e4Otf/xZBxCjaLMmQJmFznHFjIPm7v3oHYxTjkWGUKbJUMkgkiRGkicQoidIS7x3eeYrCUpSeovRUpWe5sOSlo/QevMf7+J055zg4KSiCiNrv9r3GHINSatIkprJRSsScdkIiRUxKU5QWl5dI78lEYIjngVUYJxCPHrMhFnz2xWu89eoWuoLvnwRO7xVsJGfkpWBrJ8GezlgUgbwoWZYlZ6fnpBJu7G5y85f/Evq0QBQVk5FmokY8efwBziq0VPzwQ8uLr1zj/sN75IXFo1AmZWNzi9HGJs57vv2tb7M5ed5Y2MOjmkCFfkRr/ZylVhcw51LWE5r3Um9v8a6HiQ0M9I9puBkdenZ4KVrf3pYY0uFi8x3UC6uYc/lN05C8RhvX3nt9X+HC/qso07mWdMAXtXb9xxK6c66equue6O5j3WSy4u7RI3b1E129u7CaLusi9tZreparblNtSQrxJYQ1i8PPas9MALeu7XPy6BGns3PK2u9DKonHQ77ATCERAXRJGWJIvM1LKidYVpaArYsZS7LxADUekKUpepCxf22Xo6NjZPBcS4f8T9+4zWemM/7r773H/VlOmmUIJRkMRmSDESZJohYrz1Em4Xw+ZzAckG1uopZLrKvY2t3l7OgYozXpIGGZFygtCcL2VOBxwvUhkrcQon9R5aqYvV5rpFbY2lzjBYTg6kheg9KGNDEoJdAyglVwUVMak6FadF2DUgjFyfEZs+kcgkNLiVAS5x2VK9nf3WYwGPDw0SOcdXVBdE2SpGxsbbHMS8rKUjlQFirrOT075Oxsyng8wRjN0eETvvaHX+PVV19mN02xzhHqrOgvv/QSBwcPuXfvI/7W3/x3SbKEP/6TP+GPvv6n0azkHUWxQEpTVwKRXL++z84440ufe53f/YNvxP2CBwnH0znzh0fkef7MH9ufSWveU2RDNCPLO4/w0fez1UT0C8nSvPNmwPbWtySlR5JEAxA9gKpV+6359qe01qzRXqzdsLYoVvq3Kkh2ZoCVKhx9EGwoUN8k1zcLt+fq/e233rkukrU1prt+GrF2UtHcUZ9s080Y9fvogHbl5fQikrun1p9Q2oCUEDX6bbABoKS75OZ+Me2rn0wZJIGQT1najHSyjRCCygugMVvG+tnWZwhkaxYKIiDlCT6JNWq1SSBYUllgZIVJDN7aaDGwU7QZUnpFXqVU1pEXOa5aEkJgUVaczAqqcs4rt+9wY2+PYTpicfiE0XbCPK84OT3Hnua8e2jZ3L/G1GpeurHH7u4+ZjiJef9sxdbmiF96fcxolJJmCYPMAB4RHFmqkCL6N3rvqUpYFtGvWQmBCoLcAYnAVjE4RSoZa3ULQe4cvjd5SSHroCQVtexSYX20JBgjkSqav4WIOf+KwuELS+kr0hBIpWA6KxmPDI9PFixFyb84uMcffucJb24pTk5z3tzM2N4Zc3g4w5cwDnBnY4zNS767BCMdlpIPDo7xR2dc/8qvYzaGyOVjxrlj+r0f851/eZ/zQ4lKJJ/93Gd558dvkwwy0icJy8WU4TBDZUM8irOzc+6+sP/cvsGmhSDiHEaogxZCjASlERo70bARyprUPq0m6Sksp9ke0400m8PaOF0DlRUhsD+CO1LYF6ZF7QfQt3y057mMyKz1dQWmLhWSGwLWbGseRd2vZlk0wm1HFrtAOOKza28l9jMIui53/62hWgOTHaEWF7b37r9/j8300zvPyrVal4vaJ5c6LdHPUZHmmQlgkAkiUeDg/vmMTAs2tcIXS7CBpVvitadIFSaJ1SWKoqQsLblzVM4SSs/u/k4c9EYxlwI1zUknGaPJgOnJGS73JIniU3dv8x+lGf+3f/F1jo4Oo0+MOkEbQzYcUwWHqyoUARkCYaqRJmawNzJq3wajIdZa0nSAd4HKlYQQfWqaD0GpSACtLwmI1rEbIZgvl0gZpXHvYqK5pvKAD5AYjVK1D6LRSBEoy4o6Q0RMwiniB+nr6DhJlHiVUozGQ0ajAcPhkMo5lNbs7e6QJBl5viAgUNqwXC7RWlNV0QyUlyXBx9Q8riywZRYBE8/Z6SHf/s6UQaqprK8JoGYy2eD111/hO9/5AfP5gpOzU/7Rf/fPmc3m9dclsDanKKKE//5HD/m//z/+K0bDlLKyLJY5J2fnhOBxzmKtr7/pZ5c2/ixaownqzJuB6KQSNVL9RAQtQapHfqdACRdGYQ8yuhHcDkCxAlwC2iS5jQnwAli1Y7mRdC9uvPjoRCudrnYsrGBtJFBR69wRtH5wywXaWZ8qtAjYs0DQImiDkK30GlY44NpTavFzBdD7VLoGr+4+n/at9ETvHhFt31XvWu2kJmJ6kAasfxYh/7Nsxj6KlSysJdEewxHeWrQLuHa+FQidoOugDikFimgCxjmcD6RmAyUh2ArtLNILEjPEC4tSjtLlSGdJhUHpnMrO0SzwGmJRDEfpl9w7m/Lw4Igvf/J1bg0nlEcF0ixYVAVWKRZB89YXPo/OhixJmIwSBpNNgkpIpMCWS/AO4SOmFj5gixKpwKiAdzHXmRQeFzzOQp47qsJHXHPEUm1VfDdGR+1dXjlAxnQq9STnW0oSamFaxDrxVQVCkyUJiamYjAZoEVjmOZWDRek4954xHshRwWNkxtHcMZUeW4A/mfPug0CiNG+nMz4/y9FakyYCHTxzKdnZ1NwYjXgynRMqyJ3j7T/8PR6+/x63P/E6G+EeZm+XvV34a7855uu/O+O6EQyl4MH9B4zHA5bzGbduX+f9DyQffHCPwyeHLOZTXrx747l9gwCrNXKJGEcvJY/oj9zQjivRVGgR/UC6jrzE5R52PgVPLkqUqwRuxWmkT5DWSGBzJtHfeU1mbnVm7fkj1vUMExGbV+zN1Ed2xSK7QLseeIUeZvUE2Ob5rQifPTYmestrnI329pogkN4UIaDnIrN6kGiJ3cqD6wn7q4GIzeEduQ2s6Rd/antmAnh++JjKCxQSIRwZBu0kAwW+EpzklixTJEIQihw9dwTlyIuoCXPWMTaKwjuCThlhGJiUosyZTwXYCCSIQJYMCCrh5a0N/vqd6/yDtz+gqEq8BIqc2WyGVAItBSrUmc2NgZlFaUVuPbm1SB1Te57PZmip8d7halLmau1BjC6ME3okdl0izBBAC8i0jg9WCJZ5iXUek2gqo9FaIYSMEm7wdToSWX/k8YXVLqtIKUiNZjgcMpqMydIUQSRpSgiqsqIso6+g9yBkzLknpahzTpUkxjCfzzFJitIaZ3OmszNGYUxZOZRSlMUSZ6N0HWr/qL3dPUbjMS+8+CKLfM5/+V/+vzk7m1HmC0RtzAJHURYYkzGdnfLu+x8wGo0YjoZ4azE6+k26epaTcjWy8fm02vG5AbqmqoAICOmjv3JPwm1715TUabjGmsp+pfVG8Cpv60AyNFK2oCOB9AjxujmjJym2zr5PGafrWrhO49cntmvboOfr0uzXA/2WQV0infa7KUQLWt1ksDqR1JjZrln50wfo8NQnzCpUhpbjrra+2Tqes//MhJRR+OPpz/IX0rwlxho5VFgScotz8bOTMqARBClRVDG1iYlluZyt0KFE6RRpUiQWGRxCOYRUJAlIUVL5CiUFqQalo+nYVhU68SgUeEvwBQqNqMDPAx88nPJf/ZOvsxMSbqcpX/3LI8p8CSrhMKQUpebWzgbKOu4/KXh0fMjJ2Ywvf+4VlBQUpWU5ryD4eB0pMCZmCtBCo6RjufR4HN4LwKKUINGKsioRxECo0nms80gUQQSMtigcQta4GqCpeBLqOuNn8yWh5wCvlWZzkrK3M8T5wNk0p3Se8yBIgMIGxibu7aQgNQlGBT4uPSp4Mud4MI1R2U+KilwuGW/ukp9O+eKNhNuTJfsvbjN78oSPrGdWwuH9B0wffsRuZvn0r2wxvGF5+fVNpu+XfPi25ez4gFmlyPMZZ+dnDFJNouHhw1Om58ecTacU5fXn+BE2pCj6ZMaxKyHEIBDwLQY1I62FPBmJUkvC+hjeDuf+mPfdQO5r19b2b0frmrDcrIt/atbU4uGayfISdxpW1nTItCan9gREWhLVEt9V/5T2+JaXhjrWpb7XVdxaE8r7Um3zW/TxrH8vTer0aG1suIXo9/Upd9l3uemT9eDXzd01xZWC4GvFwDO2ZyaA+UcfUAiNtSWbyZCtwZDbt3fJ7IKzh0fcOys5z0vM0qMNKFkhjWBZeZaVJxMSsoSycmwLz8QWzO/PKHzFcG8LqySj4YRUaZxRsCgpljl/9bXXubO9yX/z7be5X+bYAEaqWElESco6ytW5mEfKBUHhPNZbkqAJzuOsA+3qJMYWoSS2TsbqvEdIGU2KvtFcdBO6dZ6FLxEIvJC4IKJp1hiUkkilCIE2gKQp9dQEJEhASRHLpm2MybKsBcGijMCpVCxbY53DeY8KsdandQ4pQ0wv42ysAxoClbUIpbE2SuTeeWbzeUxOG8C5CucsX/mVX6Uocr79p99lY3OLvb19fvKTd/njP/4m01lOkg2orAURE7PG0k0xElopQ1UVzOYzqqpkOBi05mwpBMt8GQNtnrMGEOrxJqHx+5cChGxH8Aq4NJqhRlu4mgamm3RWYGcNhFY0WKL5RoDQpCGp/dpCc7ZeH1piSPusepfmghi7wok6JLoY7dv97RPCtSeFENHktpL8ucGu0O9he9HV++hta12BmuvSSZ3t9h4B7bSNoQWrcNm5V4hpb/IQ3d++r1BTfCmOsfDcE0FnWYKvKqyXKKVJ0wFSaxAx4CMEEEpBLXyF4MBVOAJJNgQUyiSx5m5QVHmOcAXCK1wo0SEnWBXfW1givYvlMLxjmCpckASxgUpACUk1XzBI4PsHc37n4Qn/0Vs3+OxiyqLMWVSBrz2Y8+qk5O2v/ZDCCm7d2OX+w0Mm44wqRLOR81Gg0zoKq95DWXlcZfFFxWikEbiYhFsqlDTYUDHPK4oilnvLkkBAUlnFIreU1iF9rCAkERjpsRDLxNUBfGVZUVUO62J5SR9A6lh5YzQY8OpL8P79JwRi+pcz77FSMVRQCcGtXc11X/LyvOD93YwPkk2kzTkvPUVVkCUpC+t568ufYW9Dw2LJ/vQeJn9ElkoO9nfxpUfMcmwQnPmM739ryW5SkHx5yBe+eh0rnvD44Alq6xrBOrw940ff+z4fvV2RuIKp1ZTzEw4f/dtIAxPHhpQ+VmQJddR0y8V6BK8dSw15bHCpzZW1iksNvXhqknvWxvslJKy3X30yOgxqyEpDYPtktHf9pqM93FkVjqGf+6/dvgrq60+uW9V1AXoEbcWU3J657mMtjLb5U8UFmtj1vX/rK2fs1q32ro+EPZ9oKeo8tz2iXfvZxvRJcpWIP0N7ZgK4LCt8NWfhFTubY8bZACU1lQskyYCNieLekzNcCi/tXyPRktPzJYsixwtQSmKEIAmB2ek5XlXYsuTo5IzJwyM29jdIX7hFMtpmcXKfsLQM5lGF/5W3XmeUDvi//uGfMC8rvPcMlUFJGJsElCQEcEJwvlxiiSCVmoTCl+xsDmO+KQnOWs4WBVKCjUISSkmcF3VZMVoNUuNU60JdsinEjzTJ0viypQKhovap/qBlfawUAiUVw0HGeDImSVO0MYCoo4/rQefpiIGUmMS0yYxFZGRIEfVzTcWArgC4pMmc75palcYgRKAqLaPxiFffeIMiLzk8POLNT7/BN7/9fWbTOVoPcNa2SWdj4EEMPiirAiUVtp7YiyJGWA+yAcZohITBIMVaR1GUz/yx/Vm0lkSEDis8sT7tRSEsVl1ojmvy5PVJyCqRia3larUg0HdYboCtSTtTb2iP64NbaP+PgCv6+/cBsU+K+hjyUwW5nrG44ZDtKUJP6u2BaFtYnJV1K8trv1dIaLem/XupBjj0zyVW7qMF2dDbqbPNX+hJiEOASPtqoBX1PdcTmaAWwJ5TM4nESY0JASUFQhZoaVHGIAg46whBkWVZ9McJEhk0zgu8K1A6QRmFEA5bLFGUBKFwNtR+yiMI0Q8YV+B9idIaoxN8VUYsUxoCpMMNNrcLdncLBirntV3D6zcnLKqSWV4xF5pXPvNJbu5tcvf6DiZJGY2HfOHN2wzHAw6XjrG0CBn9iudTC5JoYVECowJKwGJeUJYOITQulAQpKHNPnlu8hcpWzMto8q3qJNajVGEkzMoSKQJDE7AuvtPKeqoqZnKwLlBVVZ0Kp6muIpgtLR99dExVefY3MzY05MuS1CQsvEfrhLGYcstWvLwjWEwdZl9xXkx4LeS8tTFma3PE8rhi++xj9Lniw6MzFp/5LOnNTXAzXs5GzGzGwz/914izCpxgWUoeI3l4LtnatuzdGXLwUUKo6wU7W+KqU2a5RlVTlnnBbO54fPDouX2DANEfenX0dn6yPVLSkK16j7CuLl8bw93Yb3DvEty8MOxrItIqUBpBugFl0fWjJwG3/og9UtP2ttlv/WKXQOXqM+h1MKwuh/VjL8q5PYRb3bC+NnSX7NaKlUP6J+1x2p6A3LyrtXton1n/vmJeu9qNImJ783sFOeXa+/0p7dkJ4HxKVXjuzytG25sgHcFW+OUCYQSbOuXjI832/jab17cZJgO2NgsOj0/54METXFVQisBoUEdquhIlYTvVuJM5wiSYvcDpow9hdkyiFdoF1NY+o5lkMc+ZOo+XiqAkSaLZnYxIlGZmLYfzObOyJNbXFISguHljl6PDY1574RZH5+dsjRLuXN/g0dEpb398zpOzOW3UYS0aBR+lVV8zDCEFic4AKIoCYzQh+Ejm+j4UIqZGSIxBG8NwNCRNE1Jjai1hkzjWt6ZTrU2b8b+fLyyaSCLTlyI6lQchYp4fG7V8MWpXY62sfYxkLAclBd4LlFa8/aMfUVWOF155iccPjvjt3/5HzOeRKHpvqWygrHKU1CilaUpPIRpyWZPgxtl+scAYQ5alKKUwpieNPKcW2iAQXw8cH8GirkwSRKwZuhpcUd8H9EzA0Jcg+6jiCTXpiK2TRbv3FINBZA/oup1XjL/ikt8rXesv9ICg7mxLttqUCj0Jtf6vAaKOjIWLAL3OcvuIEbrnwxrQX3i7fT4n1u69r1Xor+n1ub186Lxy2g41zK594vWYqFfVpWc703ZNxIGW6D+PpvUAIRzBeyrnGCYpStUPRiqMUXhf4YspKInUCeBQsv5+JEgiE3Khzn+HjeZipWLKKgJKCVwwCKHQQhKohdTg8PmcYBXDyTXOz3IKZRmnc164tUGeZbz94UMGw4zFjZdQMvD+ex9wdHLKMEv4la98gclojPWea0OFd2BLx2JRxYA1CYlRoBxCQ0kAJ2IKL1M/aw8hKiUpq4BzgVTJOviN+LIEaBUobcC6wCCTnIcoyM6XOem5ZnvLslguqGxBVZWUpUNKjfNwdHzO+/efUJQlNzYH7I8TzmeK06Xn8czy8o1Nrg8kw61NvneacTAYMDCOvdRxW4z53LWE8TjheFoiEdx77z4phuqPvsPW7evkn34dtXeLSTZg+9f/Moc/+QHzg1Py0wW+gm/8SeDjA83RvTMYzdm5toFzOYnwhGoeSbOPbjp5nnP2nHOiNl+8D00AXF0YmIjhrak9NBrz5qgeDvUzKly4QEdQ+pq2p3akvUg3bjtf4O66jZteY40RfYGwL8SumafF2uVCjWlh7XfX/YsC5SqrWyfDoSOMvZ1XDhEr3VznaKzu2uwczfId7605x9N9gOp9VlNkdRVIiJgqfPtuuhycUQv8rO3nIICed05mHFXw5nYgSwzSVphEMV2WnE8t2ShBpQllUbG/dw10SpgXPJAKV9aJSk3KRipIlUaOBiyqHJsmjJIR6cmM87NjoEICDxdzBsMU0oLffXIIWqJ9jGKaOYdf5MyLgjKE2tQlGGQZ8yJHhcBsWXD7+h7ZaEBW5MymOQ+C486NbZxTHJ0v40MElFQEwIXGJBoTTysZtYt5kaN0LGAe845FzaE2BiEERmsm4zHD4QBbB3QYrakLYCJVE6ETA01cXR9Y9cghQJZlOBd9+ZzLa5NvJGFFUaC1IRDNKmmdaqJ1gJe0Zam0VpydHfPh++/EvIVBc3KyQAiDQGJtiSSS2KrKkdKglQEh2+TRbYLbmlA57xBWsFwGRqNRrGCgnzMB7IFInHCjhBprIYIXTa6x1dxXDRisVOro/W7V7bJbF5pBR0Nq1qTV9dYnf5cdt3bdFQLUSIIrBDXecWjKPLXbe1q4PjCLJgWEWClfJwi130/X0YZXrWrnGjZ42c114Br6yz2J+aKmr3fO9XP4/rtZPaYBwDZdTf3P964V6CqBrF36F97e+7jE+RAtBy6gla3xQJMNTaxgUUW3EiFj8JY2BmUEg3SA9wKTaoQIuCBweQrCoYro11BVjiDqihhK4F2Fjn4OeD8kIChLgR5sME5uYe58ll33A7KPKoavvsyTRCO85fDgiH/4//lDHhxOYwYB60h0TN/01V/+ElrFQDIhTSTYQhCCQ9cisKxTKzkbcAKyLAbIFcsK68A6ia39tiFQlj6akoVAi4CWCu8cDsX7Rzkv7htSGV10zqYzposKL2qhGMfpzDJdVFzb3ca5kgcHJ8wXBcvC8t7DGY+HhmUVOD5bsCgdr929QXGusQHk5ga35JDZIsefnZPkZxwtU06UZvv2DU4/fMyBN9yfLyjdHHk+Z+fREzZuX6f4tb+G/8RfZHzjM+RH73D87jfIP3qf+RQevjvj/qMFyfYB461dgrdUVCgbSLMMGwSVVAhRcfLgeZuAV3OAippo9QX5UCsyItEKPRCirjbUGjYvEMEGH0Ttgy6a8Vi3TlC8KASu/+xjZy3a9QTInlZw7ZgV9xsuyUfawFWNDS0ZajaEPjkM3fLaCTqitWrhuNDqPndKgPU+N/3pMLG940aWbZ35+oh6CUkNQJMHuZkzpIDG7YUmD2DP3xGeTiwvac9MAC2eD88XvLC3FbVStmBpLcJa5PaE2ekZKosDviwdFQaRJvhhyf6tirPDE5auxKuEKnjm5zOGXqLCkHmVY6eHmOwGT4SnMpqBDJwsc05PTrlfTQh7+3xycxNrLd46grM8ePgIpTW7oxEm0RACRgoWT3KCCxwdn6ECfOrNTZQrqVLF1nbK2XSJNgqt6plFgDExD6BWmiSNiZx9AGc91laMRjHStigqhqMMrWIwR8xiL+oAk8CyKCLBK8volygFMqg6UDWSQa1itLIUMeVBMxlKKbGVjc6cISp3ldLYymISg3aGNEloyk5Foqhjtn7v61CT+GFY6/A+MF/MYwUBm0dwcHFSUqFOlo1ESEUIPqZikArv6uhKESeC+K3Gz8vaaDKez+cMh0O0fuZP6M+k1cqfFbIQAjG4J/gYuSXawm9EB+aGavXJY+jVeqxPVP9ZSfUiu+NE/6L1Gbv/u7aqAVslgt0RHSisHyhq5A2NJFiTvn5Jop4esNeX0LvXHqtq6idf0PJ1D7QFradoAuserUrYrG6/8EyeIol2itA+WV4NVIm30j2cIDpTR3zHnWO04PlGAZ/IN5Aa5tMpVeUYZAMGWcJ4tAGpwZgErSVayJhOCkAqpFakg03mRUklAs5aPBJnchCyDgKrsDisc4igCJVDSI0OgJRIFc/vU5hsbDE3CWY4wJ0UmGsPWXqFFAnJcMAPDz/iB+89RAlIBgM2Jxl721vcublPUIZl6QCHUglKReuB0QKlJUkq0Uagm9cj6xJ4IpqpyxJ8cEgZE+z7OqADIeoANkliIC8lx/OSwgW+89GM6zuSwWjMsqg4WRTM85KDo3OUEpQ2+gEiYqL/k9NzyrKkcrECymu3XomT4Ecf40+nqOCYnzgOzkFvTNgNBSO/4KycMvQlJw8DWiUMxBm7OxO2T3L2tzb4/fvn3LMV5mzKzaJgZ/YP+N53Xmb58osUw5LHP3qH4SDh1iclW6OEd38Q+PDjc87PzwBQoUAJsEJgkozZckaaaj6893zrokd4ELUQLGq8lm3S8dZNJQR60l97dCPkryaDvygABuebWaDZsSMyFwTjDp3Fyhiu0WIFriKZoX9YWMfE7no1+1oVFMXqzxbuvMA3Mect6Vsnj2skL3T30v+1LuC2ArjwCN9xiP5B/RknHuY7sg6d7yMd3nfXX7ux+kDf0t+w2lURCXpMrh76t/Az2zPP3i7RzCSMN0cYo6gKixaC2emcqnIsvQWhCAKcVCxKy+Z4l4qHbO5sszybclItOV8s8MZQFBJZLpDTJamGM2H48aPHaO1ZmEBpHe+eL3hgPScLR1ASLUEohROCT3/qNQbZgMVyUUfaKRIJT45O4uNTURN0fD7l3Q8eMFsseeXmJrdv7PPOux/hrCU1KYkOoBQ3blyPSaGbJLx1KaTjoxO2N8dkgwEnZ6dkWYbSMUu/NobFYhlJmrVIIVnmS9I0xRiDCz5qELERYEVMPt341LpmQqsTVgfn8E2+oTg6sdbW+QLjB2TSaH49PT3FpAaDwQWLKz119alIJG2MJHbeYbTBuoI001Qzi3cWCLH+r3e182hs3rk2NxNcdK4PxHNiYT6fkyTJs39tfyZN9KTH0PptCiUgRCfYtt4sAWJdg1q5FlbYWd+/rV3XaJR8wAa7aqps+UoNQq1UvEbyej6D3bWeRhQ7iOibozuwWHekXtX+hfVjQ/++Aqt4IFaAqbn6yv9CIOrM8qud7RNBLvm9CpL9e12vgRv/+i4htO86L0XzfmtfVxGl3j75a+v/1vNHWLvGL7q9/f0fIaQkXy4Bj5aGNFHs7O6ysbnB9u4mjx4d4KsKgccH17p0+KDxLkQtuy+RSqNEtApUVRXHloAmd6AMnoCjrALLoqKoPNdvXMOMRiTpkLOzGR9+/Iizec6rt/d4fL7gbmaQQfFLb72MVIbtyZjXX3+Rtz79Khsb18h9wuNFxNgtp9kbR0ETKVGyNis5j/OCJNNI4UlTE02KkpirMHhkEUArtHW1f2sgIOsUG7GCycGZZW4Dk5HBaMeHByck2ZLd7Q1eunOTPF9y794BlXXoJCHVhnsPHqFCoCgrtNKMh5L93R1ee/kOx0dH2L1tXp3A2E1ZZAPKQcrAL9m2Zyxn5ySZ5OxY8HpmKLBspJ6je6dkVrM/mvD33pzwrYMF758tMULzgpd8+fB9HtvHPLh1m4PBJtOjE4pZSX4jYf/2gLkTfPToAdev3WIxW5AomC8tw6HF25JqsWBje+u5fYOx1USsHXqdbxj1NxW1Yr43LkWPfHUERayedjXXn+i7b3S407gHtfvRYUj80yNsTS5B0Uef7jgQLUZHl9/6ur0ydM099uCN9k+DCc0565tqXC5WhP/+sZfAxkUsWVu+4OPS/L0EI8Pajj2u2NxD3/rdYjA9HGzXEcl9U/GJ2ioSalLamEt+DresZyaAj8uSgU5BBExqSGTATgtKYXh0MGW4NcLXSSmRBrG1g5UGQcbHDw7Q2QQ5z1lWjlDBvhmh5jGdi9/a4MBaTo7PmaiUnVHGe+eeJzsbPK5iTiqVGJQUSCGQRvHw4JDSVjUxEuAshQjM84IsSciXOSEEKgtvf/iQv/grn+NPv/UDKilJBxM2TcFoMCe3gTSL6WhSmSClYpEXaBUfzXg0ZDQeRQ2bUkilIlhpRZ7nhABSQsBR2ZIAFGVJVTlQogZ9T6JiKpmisi15FCHEVDD1RKeUimkfnK2DOSQ+2OjX56JJU9Dks4t+N9ZapFRoHfPzaWnq6Nj4SZVFEbWyRUmSCEyiyPOYxqIol1TlHESsWyzqMnox119J46zR5kYkRltDjFj+eaWNP4sW778pNaV6GqAmKKKO7BFx325w9WCuHm2tz2UPSVZ8V2BV4uy1aKYNLVFvTrvyf+hpqVow7C3TI4nrF+lp4po/rTmHHpFqf4cL4Lb63Hr/t9L25ft25whrq7r3fTkdvLiqffYXiHavD82P5jX4nl9Pu1xPbq0WtHu2gYCQz08DeP/BA4zWJFqhtKCiwFUSpQXOVRw8+JhsMGT/5g3SdMD777zNchbrc3tE9Fetv2EfYpYAIGYroPP/9T7qMJpkyFVVkVeOLJPc2ppwdHhElinyfIktK4ajAcMNRekUeINLdvnsF66h9BCZCT44kWwGz86YmOzZKSZZ9FnUWjEaGGxV1ZgVq35UzjMYKBIjY/UlHzMbaCVwRmEtKCUYDhXDgYiVQKoASI5njsOl4mBaMF2UBCHRSUJVee49PKZ0kl/7yuf5rb/2F7n//gdUXvD46ARbObQxbBQVWxsjTo+PGQyHTIYDHt0vyRKBkCNsCLA9oXCBxcxxqsFMtigPF9yXgUlpeWV/zHA8wSdDJsJDqhnpAa/e2aWwgXKcYU+WbA80yIrze+8gkwlyccovj/cZHnhOHhU4L3l0esShC2xNhlRlgbM5vpzi5QCdjZlsTZ7bNxibBxG/pdbs26Y2C3jhO35SC6vtuBOtKN0q/uo9a0xrqRQ0xQpr4tivpd7Hlf6alu21a8XKustMv3Jln54mcB07ej9Wf/epbGjdhFqC2O+RaKe3lRNHOL8E95oLi/69UOMPtbtU99y6eaF7joKLN3QRG0WPnMZtvnHDCnWql1ZDRHsDMS9t45727Fj4zATwrLSUpeN8VjE2C0wiqfI582VBUQTEeU6yM8AricPhi5wyzDk6esJoe5Ojh48QBkY2cHh4yu6O4zwEflJZ7mYSdzxndzPD24AeDLhpHYul58NyTuFi/qdgDEZFoKysJTOa5TKPWexk4MnpOZWN6VKoTWYIqJxnej7n1Zduc+/RCXsbI3bG0XdPK0GSmBh9V0s0znm8j6lUhoMhSMFsNo9mQaXAxaz4zkcyVBRR9R+EIE0TpJQIFD4EtJIIGdcbrVgscirrcXhKW5GXBUrGFBImMWij8c5jvCfYOIATao2J9+RFEc2uIpqddZ2MuqoU88UC5y2KBKGiutgHi7W1v5It0ckAiui0nucPqWweNYDKIYOO5mvvCN62PoCNv0MThdx8nN77mEbmubcGwZpB0FRTDT1wa1ojE69pM/uSW68IeH9Te6WWBIru3K1kFv8Ta9uA1ev1AY3uWPE0IBLx/a1G4sV7bnnemmatD3TNeVb+1r8vmlj6+4Te+p/B7nubV4TmtgxcvFhDOFfAbuX51yDZPDfVSLGN/wvdJAcQfHuvbfqdpxHZX0BrXAji+5bI2gSX5wW2sjhrsUFw8sMfUxQ5sh+iXVsBmkClEDyufjaNNC9EzObvfSRT1sXSay4ItJLkiyUET5ppPn54zMNHh4yGA4ajEQ7Ncl7UefgkgyxlMkjwBAZaMFYeGSChQiYGLw1CKnSiY0SzMTGdSFSbxJq83lNVFZJQJ8IXMV2VFAitsNZHMkv0bXQhag+nhWdeWA6nJVJo6p2QSmCk4vjklP/2H/8+/2w4YHM8imbgyjJf5BRFSZYY7t7cYZwq9jYSyvkxtizxGISSeBF9xUsCx0XgeJ6gRcVWmpEXnm/kFY9OC97YmEerSLAcnObc2hxxZzxgf2cLfW2L6oUdEhkw54fcGg6x0y3ubJ1wrRJoqUkCTG3FrJSEo1MeHS/Z3NogExZdliA9wqTEis3Ps8WBJYSIihSh8KFx22lSbse5I2YoFz0Ne5+adOQOeviwKt/S7r7Wg5XVfYzrHdjP/9fftkoEL16gJVs9bG71kaHDlNUa7+2j6T+m1XXrN9SO59Xzd894lSPXnV89k6Cdi0J/zuh1oqGhHfz1/LVhxRwvQ7/L3dzW2YBqt6dALO3a2/Ks7ZkJ4CKvEMIxUIJQBZauoCoKcicoQ6ysYYKn9A5pRhRHBxRCEnzF8sFD7gwG5MWSPWvxmeD9fAmbkr3NATqv+NHhnMd5zpfu3maiU0yaMxCehwvFd5cFs6JE65h7L0kTClFyfj6jLAqCUVjvI3FzvtVSAW1qlbN5zidfvcvHj885W1p2Ngf4IMgGGYPBkCA9AUlRWZI0gbrUndSKoiwIITAaDbHWYbRCa01ZlqRZSlkUJFnG53/pC3zh17/CeDzCFiVaxoALpRSDrU22NzexeIILzE7PuPf+hzy49zEnx0ccHx/x5PAQ6y1FkeOCp8wrBDBIE4aDDFdWVFWFMQYA7x1ZlrZmWCVlnUvQteRXSoWr07WMJxOU9CTGYB2kSYat5rG2p3VIGUlffH4d8euTwH5rSODzbo1/i2jc+0LAU0fCyT4b8CtmVQDR2DZ76y8QJhpg6qKJm8G8AlQtKDX79P7Gk3REr4dgq+fsrrceCdfca9vLlj91/nkNRjUmme4+1lC8D3R1n9efzfrPy4Ck15sVUG1qadIQv+4prfgSdpdsALF/mh7wRubdfsdN9G8kSl1apCYH4Gp94V9s01TgLFVeEaTEaI1TAVssCMEhBdjlSa05F3ghUJH7xKAJotYsEJBBEkQMugqBmCxWeJACZyFY20S/IL1DBHCLGceHx7xz75i337nHYrFkd2eTk+NTSlQMjilzKgxZKMirc7JBhiwNIndYtyQsIUs0DyqDGAmqosTWZkElA0qCMYLUgNGSNIPgIASBNAJhFK4E6wJC6RjrFkASyDJFkVuWZV2iqtZcKB1r68o6l5mt67lb5zhfFCznM5I0+iP+0qdf4/DwCLynrAIP7h9wfWDZNYFcDAiDDVSwTGdLjKynVqUoHZx4gRpLlqZiNMn408fH3ExS3p8u+fFRziQ95vp4yCevnbB9sAEbY84OHpMOMm7swfj+h7yMQ2cZAY+WKRNK9oaapQ+MpOWHHz3EyVgrOSDIC8uyeH7lCGPrNOMh1AEJssHppnxbIOpso2uTq7WDjetKozkXxA+w72XW4lPol0GjJUu0R/bcZBrFS92nZp++z1tjCQE6d6MexvZx9fLAhr7gWz+HFfL39OVmZVhbWMWly5d73KxtrULkEmK8Ol+GlT+X7H1h11o/WysJmjKkkWM2WkFPMx/G0Pt+ZoRnac9MAItSkAodpTQ8ZVFResU0gB6kZKnBWQHG4sSSs7MSnTsmiwU3lObxyTmLyvITQI0NSgeUyRjYwC/tbHL3ExnvzJdc391kns8oSjDS8Jv7W+TylO8cnkefOispi5LxjqQsC7I0iRJnXZ8XAot5rCuplSbNMkyakFeWYEuU8JzPl5wtxuzd2GNnd5ckTRhNhmidYgcZ+XLBzsYOrqwIIjCfzjDCMNgZ8/7773Ny8IT5+Yy7d17gpVdfpihyXnjlFf7Of/ofkOuCw4cfohmRmhg4IpUiSIUfSIaDMb4qmby0wUtfeg0lEwYiQTjB7HzK8cFjvvVHf8KDhw85nZ5TTGfMZjNmsyl5OQUhGIoogXvvGQSw1rdm5dI7rI+VRSJpi+liTk9PyQYpXjomk5Tj44IsnZDnZwjhVgaSrAdlP3I2eF/PyeLyb/g5Nd+oSeq+xmg3Ad5HU2EIrQp/hRRRD8hm/6ZdpjGr1zfnaI+lR3JoJMZaTyfW/0KToqVZt9KP5vfKfxeBbaVbK+bfvp9gQ46a5XXfv3j+DtBXaG/vntd/9kCrkYDrE7empB74xkeydt61h9u/r/VdOg1hXyqvAVZ2ZLiN7xa19g1+LrPHv2n72runUequvy8pJFr2pPu6GIPsTQ66tjYIIaPPX63JjZ+qq99tJIpSgQwxHZVWIGuNzrTwLKxEqzPMT46YLmPNYCMDvpixOD/DBhFzoKaSPCTMvUBkBukrEqNZKIf3c8qqrAMsAo99oDx7hE7SGJgSIiH1ASonYhaLUoL3OC/RiULrgLceW3lknTdQ+GimCkJSKgXKMBwIbu4qCgd5ZcnzMvo1B8+EkmUVKAOkSYIeDCnygldfusN4mFBNJgglGBrJRMxQ2zeZz5ZUoYDjj0m1YEtlLAixQonJSEOsVKXIyDJHoTRsCj6cTTlYlnyw8JRzsI9O+R8eLhHhMSEEvrRv+JU39jg88JydO8KNDR5XBTIIdsYpOyS8sD/mGx+e8OlrQ1Rp+fFJxWwONrjWNP48W5cOqYVEJI3QXuM/dbqQlhD2SBPdmGoV1KvUaEV/tTJs26T7fdGtA4pO8K2v1UsmHYNDalz1UWMWNWwdrsIKYq38vgSmO7wKq31dJ4i93bp+tf1evfdu3x7A1YJza/pdf1Cre65uWttn/aGuKATo3k2DvdHjSNRxCvEZ+jq4RAhZZ3q4qKj5ae2ZCeDhImczSThdFiTLnPFwg8NqTu5iMIPaNGxnCZUtOXl8j02ZcddrfDLg9x8e8O50xsw5bu4MuRkG+KVjw8EdIZC24JXPvIX6+B4MJKe5xD0+Q/hABtxOUr5T98M7hxKCs/mCQZZgBhlSKh4dPEZKSZokLBdLtFKMRyN0mpBkKVprtrdS9nc3+OKXfpnx/hZHg8Crb32aG6Mtrk028cA/+9q/Zmtvl1/+yle5tXmdeVUgvCdRio9nT/i9b/wB+cEZW8mYr37xq7z04ossXEGpHYWvmAggz1kcP0Eu5jyZnSGTAdsbG1T5HFuOybIRRT7HZo5sKJBGM0gGjCfbjG5t8sLnXmeUTcgwFPmSg8cHPL7/kB9+8zv87j/9J6SJQUhBVViCEEglycwA6z3LqsR634WN11LDeDzGO48UEmM8oa59HLWEtfk7NOSk0/rRfIhC4p3rJtp2jn7OdDDEiLRGPR6IPlSyTtQdcDSli6Ijve8N4kb27fV5TeO2vr6LbKMbiOvQ+DQ/PlYBQvR2Eiv7N87Yonfd/j3H//rvFGrS1+7fJ4+d/8slrG61n/17F+s/GwJTg3yAdpa7FNUuKRNX27ibdAUXL7Qm+dakemUGkVEKbmprR1+h5rzNcc8Oev+mbVb6WIWnFsJa81Z7v6skP4SAkhKtJEbFv74mkCLERMtCxL9KxhKXkVhCqgSSgPOWxzOHMQlKODK3pLLxuST46J4zneNsRaoFuTQIBce5Z7a0TBdLvBCMBkNMotEqRk4rrRkPM/ZHBXuJwEuBtYI0iZkBlrlnJAS5c2gpyAaGIAIuytjoROGqQPAylqGqa6PrypIaxWgo2d4ckA1Scq+ZLh3LZY5fzvit62eINAYMfu1Hno+1YVmVLOYzZrOE8ShFasneJGN3vIErA7Op4+DwnJNZwdjOUc5yd8+QzwLDvS0Ks0kVotXn4HTBGy9u4+0ALQoeFRnj3MdARCk5nC+IKKHYmww4mVdcuzHmqDzh9999xERL3ry5gahKljJQFZabQ8V8UbGbKD676zn2gXMrWM7bAffcWhPyAfXnJ2izIDRyVBwfqzkDhBBx3mgP7JqAWpCuSQahRSfW9rww5Bqzbv9kfRLXW141D68eG3o3dHFY13uEpg+dINXgp+jhIrUg3uzXrQu98zf+e825mzsOF/q6cj/xDE08Df3TN8e1+N/DwtVTiVaobueB0IO02gLSEE6pohnfx1qUCGSd/iyeP7ifDwefvRZwUXBrNAQtGOsxZ84yGg5Yns8IrkKoDbQSjEwGx2fcNVAOEn40fcTDs1OWucMawenpArkseWl3g7tbI4ROeLx0ZNpgvKCcVuzc2EC5QHm2wBcFZ/NFNLnaKpaBkwpnK6SSLBdLqM2sSimqsiJJYk47pRSqNq157yhcyv/p//h/YOelO/yrb36Dt7/9TX78/e/z8osvszsZ8bU/+Bqj7S3+8t/+m5ycHXN75wZlVTEejghS8XJyi5/s7fODsyeMbm0ib4w4kQW5W6B9NJ1Ohht8/sXP4DeOmJ0d8cVXtnh88IgqzDn3FYvzc1TpGY5GlMs55XwKwwkhG0T/OwHTYsHE5wyzCbuTCS+MXuTOS3f58l/8Vf6T/+x/yff/9Fv8y9/7Pf7Z7/5TiqrEZAbrPaI2Tc/znCAlWgisD/G9jEYcH5+wu7tLwKMTB3aEMQNstVj5uNcnrwgYoSWKTUBDvcPP9cH9GzdRB8IoiWzT+NT9ClESEkLU2dCjaNwOpL56v0eOWikyhN7grf+2z6TtwAVAWNlXdKDS4d0qceubhp/aepJn6HUy9Nf3xN/QSrmh15/2FlfO+1OXf9Ymcfn2VnsnuufYWbQvnunSJK3tUncDEdQjoDdO4oFYqiyaQSLB9/75md+GwrHAU/kG7ruEtiIEXE948u2ziClOnBcoJ5FSYqRAiFg/XEsRtZkhHiMBVUdfuuBZWnBB4SvH3Z2U82WMUFfERMtFlfMvv/U2y7yqLQJRU5elhskoY2M0ZHt7g72dbUbDEePRkCzTSKXR0jMSU3RVUc7mSOGxzmGUIk0FeeEYD+tcpnWFEqEEqTQkOBgmlKXFlj5W+iCmitkcaZbOMkgl+xON1ClLUozRuFAxdQsG1YLJaANz/gRzlrMoLSeznEE2Z29LsJkOGGWG0WjINMxAp4y3dsiZkp8u2M4MB26D8V7KcjYlC+8z2dzGmV02JwO0cIzHgmXY4U1ytpMlByeKD04dhRVsjzLK8R7fPjzlf/PlPY5PC15LC/7occ7eUGOOHecfe96bOY4Wlq1UMBgGxkPJySFspvDG6xkP3s2ZbJvn9g0ChOCgdheI6chkjQ+Cxk+2yQsIPdwQkeR1vs092lJjp6yzJ7TCJ5eP1O5XH+NW55G+x1sj4K37AK4LyP39WTvLKpHrljs3mdCCUx/rL0xV3W6XysnrrTNIrJPa/o/uHB2Z7WFd3zSzLqCvHdwZq7ok0qHph4onkaGJBK5xMHhEeHYsfGYC+MaNfV7c28LgybKUrIJlvmSYGKyTsCxJDYijJdKkHCrPkTti6vNYFo4ltgoIkXB3OOITd3YYb+4QRGB5eMbBj37C7PyYzevbVAuHQWJSw3FVclhZKmdbZryZab50Zx/pLN96cMLjsoqBE0pFSVub9uX6EMiU5o3XXufv/f3/OTdevsuTYs6NF67zG7u/jjaKD++/z8cfPyYzmk984TNcu32bslqyyKN/XPCOkUoZpkN+47N/hZEa8OjwAR88+IBPvfoWSsQoOu88mVdsDbYQ6RbpcAK24NVPfJbTk8fsVnltSlXMl1OkzlCJwVceV82pEk0pJGkIzM4POT19wny4SZqNSZMMowwmkXzm1/4Cb/2FL/B3//5/yD/+nd/mu9/9DgcHB3VNY0FRlCydY5CksbScB2M0UgkODh6zu7tLmkqWi2OM0diq87USoSm5FdoPPoRozvKykbRotRytT91zalG71dNY0hCC6PQs6hEh6kipJk1BI8lK2ZC0Pgg1J191zm2ktmbwXfTxq8Gsv/6n7NdcrE8M1+5uZakB5z5OXO4LSKcNq38/5ZT/IwhgB/2dtiG077+VktuPok/82lXd2RqS2j/f2r3FE4rWTNT410QfOV/nfGTF//R5yiHTwmODI4TafFX73cjaxcAjESulZLoAqioInAhI6XBKkkhBklB7McSgEBFA6JiaKQA2BOZFU6tXMTCSs2W8aS8EhEgg8TAexDRVWku01tENJonVe9IkQ9eViqQ2CG1AKZQKDBODm2qSREfy4D1JKmNBj0FDBjz4WGkoMzFC2DmNCAGtBUIYlI/ZCTyBvQ3FvATq+sgEy8gostSSpQrnhzixR2lSPv/FW9w9nXFyPouBND4wWywYD9K2NJxSCi1jKTqhJPvXb+OnTzCZoXSBc5lircQdLdgtCiapopgNMXILPRog3A4jD/u+oPKW06VDSsOnfvNvUkwX/P53/inbMkcmgS++usN9fY3vz5eknHPjC2/y2lCw8/iHbP/qZxnsTzj6aMn7v/uHKCvYGdk26f/zap6Ai4HACOcRMuJeXceqR/zW/u8k3l7C+GYcdzgiEHW2BVFXF+tRtBVtVg9Lm/9bzBNrpKnByx7hpCcc09+3wZhVctjfM/TxpQWK+F+7Lawd0GNgIlx0aVrJktCQzHpu7EjpmhC/YhPuX7M7+wrmrbPP+rmL/nOV3brQAGn96HxN9mJQVo2FtbLr58HCZyaAL9/aZSgkSiqUMUwS2JqM4OSMk9MzBqdL3GzOSCc8WM55z1q0rQjBorXj+kZCkmW8eX2fT7z1Sa7v7mCMYnH4kNPFknw2hXTA49Mz5OmcZCAYDDOOReBwWcYSbUIw8I4v7m7y+ZvX2MoyPrlxwp98/JBvHZ3j0ow85Li6rFlTdWNnZ5P/+D/+97nxxqscHD/muFgwSDJu3XmJHz24h9jc5skffZdP/vIXeflTn0AODEVRMHMlBY4RIESscTlJx3zlrV/h/uE97h8eYKuCVGtSFDezHUYqRSBwrmQw2sTZiiQdcn24GWvv2gIpFfP5OWWe4z3kywXaW/TCkXjHVppgpSP3JeVihnUVy4UkHUSN3cJrMpVw45W7/K/+9/9bHjx8xDf+9df5zne/y+MnRzz46D4PP77HcrlAWI/Q0WXj2v4+P/zRj6mc5fbNW6RpTnFe9EgeMWhGClKjWeQxzU47Nr2vTVNxhWtzBj6/Zn1AhzoABI8QMVGuFI36vBHTumTaff8R34hQIRpQpGgIYQ9MeoRNUJteA3UZrj7p6dWPboCNVYm4o5J9iVk03PJCC+swsTaaVyJ/+5Lu0whg3PFyqrkmjDZgGdb3W4fI0NLStXXdiVdIa28h9HdexeuVfvRrj/q6Wk9D8iMoNnn1GmL5/BhgvJREiEAmBUPpWXrBwsYI2QtpJNb65kMg+OjHG5QAZIwUhqglDALjAiMjUSZeq/CBUZayNVSMhwm7egOEJMsyJpMhWkps6ZCq5P7jcwCkViilkcoglYlETChK58iIAQFGBAIWowVBSYJSmMTU+Ufju9BKkGqJDZHcGaMxRkAVo5N98KjarK1EJGoueCZjxR0cZ0uBUdFNQ7QaW0ANUSi0StjeiibfW9e2qGzF4dE59x5WfHxwTFnk5PsTyspxNl0wX5Ys84q7L97kxc98go/vPeD09IxZ5cgLQV4IPj4pqcoY8HFj64xXro0YTCbIwRZJqNgOZwzNGWdH5wymD7nx+V/lWx9+n/m9e8wdbCWaV77wEr/+d/4Oi7f/lMpa5OyU7JVNFo/uUz45Ybi1wef++k2Of/IYlw8wzzkLTNT8CEKQ1GIHAtlGzPck24bBrGBh28Q6QnVj0IXQ+vsJGqF/VYBuCEyDu811wvqgbs5br4jXEKyAb6DX744M9XEx9FFrBWNWCW4fV1b5Vuh6t46v7cPtr+huoNH0X0DAFfJ5ATFXBPb+nax0Lj6QFctOs6H1K6cjfqG/r2B1+RnbMxNAk2VolbCZDZDOEXxBagxZnvKGG7OsptyvBL93eEThSjKpuLaRsb23wTB33BwoJnsjtgYj3nzjTXQmKR7c40lekFtLlcAgFczOQdo5u6MtVJpSFJaZrXA+sJ0lfHZjxM00IT+bs7SBLDN8/sZNPnX3Bn/w4Ak/KZeRyGiNVoobN/b5z/93/xmf+uSbzGczKh9IkwRvNIfLM3ZeusOHZwd88pe/zEsvv8pwZx+0JJEKJwK5LTgpZ1gCA50xiGnXubF/m82NbYIrmQjFrh6S6gEqJgVkuZgiKRhu3I6TFQKZJCidxMhlYdja30aImH5BSoWt6/zOZ2csZqfoxSnCOmxeIhJN8AusKXHJAJ8KEBobAjfu3OKv/nt/m6/+T/46s2KJQOHygscf3ufdH73NBz/6CR++/z7z2YydJ4ecnp5zdHzEeDSKLgb1ZBoI3Njf5td+6TX2tsb862+/x7d++F5bZ/VS59LnN+8CcfKMQQAySrwxB0dbFzcqYWpfMSVpAzF6eNgX8LpI5m5wthKrWF1eNfWu/m2k4lY6pke6+qaQ3iP8ac66K9qwdl3v/xDWwGYVeVqofNr7uQyhGmn3sp1FvwpJD5t6/jarBLQLIloB4rb/dJOCED3QawCtJ/U23asnnRY2m8f5FDL9i2rxG4uTauGh8rI3Z10+Vi4EI9XNeo8r45QmAaQgSRMm4xEb4wG3b17n2v4+t194ib2dXa7vbzEcGI4OD/jwg/eYns948PCI6fSExfSMT3/iLjKZ8PDRQXSTkDGfn1QKD5SlI0kNzjkqV5M2FdBS4rUGoxDCkiQx5VYIHqUiqTVIshSC1AQRov9fkyxdxOpDgVg9SQhBqgP724bRQDLLAzaAF5oyJIRg0KSxxrn1GMq6lrpAq5TNyZDT8yXOBw5OFhydLQg+JsMurWWeF/yLP/4+v/Klt/j3/vZvIaVmWeTM5zmz+Zyz03MOT845Oj3j9Oyc7xxPGZ2XDGXFwM+4NrQszhVs7fLir/5Nxq98ipvJOyyXX8TOHxM2PsVokKKXM2Y/+QEqydj83JfZ+dxX2SvOOf3BH+Cf/IjJ/luM72g2jz3nP/zTX+Rnd6FZINZykijhY6BU/MCAGF0OQIhpYi4Kcx3GNRG7QrSfcE9n17UmEr/Fn5qwNeSQVhvYZFDokc4ATTRwn+u1pKoPzPUBa4bfdodLCdY67vR3qvu7StrWnkW9LvSucwG3RBT8O0K7GhRyeZ9W7+CiqTqs3F1/T9F2PeJNkwi6qe+8+uyJyoqfAwufmQAOswwjM3ZffQt38oj8+AHqcMqODzgz4IGec29+zv4wIQhNWVry0nN+njMZZvggyQ8XyAGcfuNP0KOEEsv8fMZ8WbC1NSFfVEzShJAmLJYVlZ3zaL5kMxvwF+7u8tm9PfRsjlQJRVWx9B4pFUkKe5MBvzUa8+DojGWIJg1C4IufeI1NDYcHB+At1eHHPJweI/b2mbzyCmcnT9ialfzqX/oNDmdnjMZj8nxOWVa4coHGky+nOFcxlwoDeFthhGBLZkySTYZmgEkyQHF6esJoNOLs6IhBZhhtRqfo6FTryZennJ8ekmZDqiJhOEpq37oYqp+kCSbdZ3N7D2crvLNYVzGfnrJcnkPloJqTL6acaE0ZLEIYRqMtRnrAYJzE640C17a2+PznPoOznny2ZLlYcP/+Qz6+d5/zx094/6MP+Ee/89ucnJy1g/no5Jx/9a130QJOz+ftYI7f8iVRtc+ZAbo2Hx5t5nMpRJ0Is9amqFAPvGYorzA7RG+IQ5wAVwdr7x57INkf9O2i6JYaX8M+8Wv3bDFjlQS2Z1sbtBc0fz0y16VcWV3f9v0C0HGxhQuXvGwXVqTfp7xr8ZSldVNw299elzp/xu69rD7sUFey6+T+NvefoC6I/nyjgIWSRC2CjJWPQiC4eLNS1MnqZRz3TYJyUfv5pVlKajRGSTY2JgyyhEFm2NqcsLu1yfW9TTa3thgOJ4w3drhx50Wkt5wdPebsycccv/cuj5ZTbFWg5zOWj484OphyfG7ZHKVoKbh16zoHTw6j9iYEqsphjKMqKwpdMqg01rh6PFjkSKCFi1nshEAZDd7ig0RqiVSgQkAZhXexDroPkrJy9bsVuBDTxlROEFxAyYBAoYxkNJAMCzg6D+RBIEPAW0fpC0ySoiRt8m9Xk4HBQLO3PaayFYvgKIqC+bKsS+VFDaISgq/98Xc5Oj7j+s6EUWbYmIwZjYaMhxk7m9eR6hYCGf3C0wEhCMrljPl8zuHBY3ZkwtZ4h0FQ+Jf/HkMq5Ok93OYNtDvBzkqu/8rfwH79d5BKcfr4mPHGkMlrX0Z++tdADEg9yGrG6NUvPbdvEGpNEHFshEYgpROSmgID/drhq+bX3p8eLF0QrHrErBtmvVG/YlZd2y5oR65ofvfMuhfoUVPep0eF+kI1/WPW4ahvVu4LhaG3rlmMfKp3D905mqniArHr32ZPyA/1jxXTMaum5XUyCP39A11RgWaZ9rm21L2tfBWDyqLfX890LALCrz+Un96emQCWy5zN29fZe+MViu/PKe9rrJVM/ZIjAW4z4boeMp87iqoCqcm958F5wfxszqd2NrixM0D5isf3PgIkXgkSBRvjMdJBZgxBeIoyoEZDTk5m5MHzm595hTu7WyTTHD8csrAu+qFsDMmkopiVqCC4liR86dY1/vG7HzI7n7E1HPDWJ1/l5quf4PzwCdv724wmI24uFswSKIqKF8SY0ed/Fe0122bEwCc8On4I2rA9rRBGkWZD8BolJK4sSHXKKJuQphvR37D9SgIbkwmzs0OOH93nE5//ldpHLuB9Rb44ZXp6gBAaYwzZIEWIGOEXfBONa6GOXlXaRCdtMgajzVhyyBaUyynFcooIgdliyaKYUpzPKE0SC5OrhNHGFsM0I0GxpCTbmyDcgFdv7fLWl38JqTWL01N+/P3v8t1vf4+qijm5Kut49PgofnDNB9gEWVymsXmeqhdislkfwLlYlkrWfo/Cd5VSGvTqJFjRDsCL3e0cnPvJOzsS1wdIsboO0cNSsbK8Tv66trq8rhXsNnTfVHcP9e9GOxbq9a1jZu8Slwi3/+O4umhBbdWXZxX026cYuq3t30Drz9cAY5fzsH43DbGnM/12JC/U66P2wbuotY1lFUOsfPAc85FnaYpJ6vQvWpPoWApOa0maaMaDlO3NMdtbGwwyQ6Ilqp5QRqOE0WAQ6/MmiizLGGYZVVlQ5jlSCoQocLOSBw/f4973/gCFg+BwZUkIDp2YWtiwZEqS+ZKyqhA+UJZz5oVha2PE8ckU8FShZLmMz9l5jwgBowSZHiJlwAhBCDH3Z1QsSIxKkCogg6urSNTRy8LhgMQYgoD51BFznUJMgqsIylFZH6ueBIHWsGEUlZe4haD0Hllr68tQIZKA1gpkgvAeqQQqSLYmGYtFircV3gdSF2LZzBCogJHKMFoyPZvy8METvLMkiUZrE6s21YTcaM3GeMh4MiDLUkaDFKM0Rhs2Bprln/wOSwS28ARtMOkAOXlANhmTjccYoahuf4J5NSDMlnhbkivJ0AzBeUQoEcsZ5vobz+8jBFyDhR6UB0LDzmpCUQuHjfDUYV/nJ7YqjHWthZ5GMKtJTcfNGnLSte784sLKDufWhOcLgNwIyx16r51xZb9+h5s+X8br+jd7AcYuucDKMxGX7RNaIrty/l6/mp7355fupB3JC+1xPeE4QGNaufBeBATv8d7hXMREZ2MqKR/8Os/8qe2ZCeD05Byp7vPO/++32Z0u0YnhcQKPrSUVHiMkG4MEaSs+XhS8M53zpCzYTTWf2ZrwQmJgEcj2x4zSAUoZzs4OwUIVBNe2JqTDIdPZjOL4nFAVSB348P4xn3rhOqoAqwwygHSODAE2IFNJVVTo4ZBsOOYvfvZ1vnn/Me+enPBrn/8UH7//DmfHX+LaC7fY3NrBB0+Zl4wWc2xRkts55XLOw5P3cbZguZhz8PE7aJOxuX8LWy0Zbe2TZkOGwy1uXLtLsn8DLbMa1KMSvpmipVYgJNfvvEQyGBIreDiWizPy+SkhRB8ZSUxb4lsfuwDB451AyFiY3QcLRPNwICCVItUjTDJgsnUDCOx4F2lPcLHGrxAIpchDDdTKkCjNvCrQKqHyHovH+wI1GfIf/i/+U378f/kvcNYS6ioFzUiJE7LvPuZmcm8chp9GXn6BzRETvcSYtzgQJL6tXSsan7yWEzWkqRGsug6vgl8/0q0bQaIV7+JQXiWGfbAKq8utHaWRPEV3whak+oj0tBZ699L1tSNafcZ1eaTbytEXwOGSi/dAccUU3Z6reXLNE15bXiGBYlXy7b+XldXNsX0Q7GtmQzteYrJTgY/qN0Tj8/Sc2v/5f/332d3dZndnKyaHd56yWFLkC2azGcvFElvmMRenUkgiMauWJZ6AoojJ2XNLde4595ayLLC2JNE65iO1MZm7SaKmUUqJUA7h5shlybwIFN4jFYwzgXCOIDXTXIKJYwIR/cSaAB1bRUEz0YayqKhMjtGCRCfEwAHRVgLyQaBFDP6QXhBErL6UmgTv47gjCLa2xxRVLH0ZnEbIQJLK2qG4rpmuFFJCagSJUbiqrhxSJ3FsykpqI2tiH8tiZmnCzb0NyqKkKC2p0bHovY/fgVQypp2RkiTRuMqDVHXt5fr7CZ7SVTw+PuXB42Py0lJWRcyaIASJSRgNMwZpTI3jvceIBKUlw8mI4XBIKkAag3jnHmk25DRJUFLH63tYzHJG+zdQkwn85t9+bt+hj58/IkRSrPC1idV3GnXRlX9rhfh2PD8NeNbHZmyd31yHeR1Biv7R9Y4r2Nq0SB47lO2W+3NJRzZ7R7bn6857kbGF3u/2z6V4+NN+99hb74Qh9DfXG1dKeHR0b+WSK49yTcClnl9X/B+h98IudDJucjHZu/Nt9SAfRD1VC/zPIQw/MwF8/+CUz+aWRCXMhkM+nB4zTz1aBPzCURQLPjyrOC4qdve2+dQkZTwc8Kr03N4agNQMtiZs7m2RiASMJltmfOu77zI8KVmmE9LBFoN0xHxYUc0WfOPRMfnZnMXpnKWH4WiAUhofSrLxkK3trag54wwZLMvZApVJBkZA8HziU6+Qn5/yz377HzCebHLj7h2Gw5T5dIatSiQWbyuKYkFe5AQR8+vNzs+ZbBlsHqhKydbda0gJG5MJw8kQoQIhWLwXEFQEeaHbwZUYzeD6TWy5oCwXVNUS7xygyIaT6JgtJXiHdbGWb2PCikmXa9OKaLzLogSOEFhrKUvLcJhFIEailCYEhRAaawtcUaIIpFqjRCBBkZkhCElQgcJVSCGpguc3fv2v8N98/rP88R/9Mc7FVC9xku19cM3kLoj9CN3y85t2Y3P1xx4nijrat01AG7UKsjeG+6TkMoJHfx8aea1rfeFvBQPoVPPdPqG3fp1o9oCvf8UoGl7oy4Xe9dCsH1TRLcd1/d8/FfwurLwEsi85RXudn3Li1e6FtWU6YnfZOS/4FAZax+gQoKH+ARQSZCzbKGVyaU9/Ee3lu9exZcH50QNOHlfYssAWOcGWFEUZiVYsm0FVVZSljQFTIYCo0zR4Dx60kRijSIVA48GWuLIAHMOBQgdPvnBUPjBIPRtJCaljPDDkpedsWrDMYslJa0Frgw+OIq/QKibul1JhjKmDNzTDVKOlJDjBZKKYpFFzrpXCG4H0OiYBEXX1iCAwJiFLBGkikTZiktZxuzAJWjoqG6hswFZgtMA3qUSIJFDrmqQQExUHHzWSQSoSU7tyaE3wHqMEQkvGgzGToebhkxnz5ZJlUVGVPtZA15okMQShKMoSZ12sBhVigIuNuYIiEa4TxQ+HHu8H8ZvyIUYyW8vcVlgX6y57HxPuy0dHhCbwyMegQpMkZKlhkCUkJiHRGu8cyb0PSIx66jfzi2g2SKwTSBdLgQkRfQJj4FqICcnr8dNg0IrhpsbM2DosW/Wd62/rY9oqGrbnbA7qESWxurGn9etryy5TJlyiehNr29f6uk6+eNblPgFclWcvAcH+htXn1x7Ww/QOCpt9GobaizRpJyjRLofes2vT+URqUxPB6DrmPcigEDJaGrV6Zlr37ATwS1vbqCLnbVHyo4NHOO8ZpJphpnEecuu4sTXhl3Y20UowOzeMTMLmGDav7aG1IhmN0Tu76LwkEQ6nhmzub2KkYqkF7vAJmQYdKgqATCEHCRsDQ9AJNggq6yLrFQYlUqpiTpCCEkcSLIu543xRIn3g5Vdf5fDgCY8+usdiNuf0+AgpPFqCMQqTZSRpFsFIjrj14suMxhO0UQwm22id8uKbn2E8mVDmc7QymGyItRVlsUTpFKVk9F+RURMYCCRZSr44paoqgndMz48ZjbcZjrdIkhTvA3keHZyRCpPE3Ibeu1pK63w3vHfgXV2yJ5qTtZFR41enXJB1mgUhJEkyIARHVZUQGuCL0rKSkSQmQtc0xbN54xa/8Vf+Mt/71reYL4uaVEXV/Hrt3/ZvqGlOuEiYftHNBYv3JcFHTYWUscxU9F4GiEEilwJKr6stCDUg2Nc8tfuGriZvg2mILiVArd1rfLz6hzaCrrgAsmvQeamYukLvmm52a/vkaKW7Yf3glWPiH3HJPpetWO/B09vl23vPI6ytbZ3EV49deWcrCgABPqZdCSiCUwivkD5qyQMBr3+qGvXPtH34w2/X4O3wtsRW0VcXV1FWFc56JAGjY2Jn4wVGwtZmVlfQcOSLkrKC4APagbWBvPRIrRimkvFIMxoECJZMxvrkiQkoW+FcYKACOg1kiSJNDN96aMmMwhYLpIxl1lKlSVKNMYrMaDYmGaOBYTwwbIzAJI7rO4ZRKiHEaiZWKIQAYySJASNBaomWkkEiYsJnEa0OEqL21TlKK8mlxweLQON89BXsvvVAkggSHVhWsTxeE7kPMT9iVdo6Ujhqd2MiacVrdzd57YVtHjw+4/HRktmioKyiZSV+TxKXDbtvJQQqFyitpbIOWzmsc5SVw9oodDeimnYOF3Q7adsGB0Lt7xZCxFlfH+s909mS4/M5wbmI4XUQjHrOGRG8r/ChwgWHa3MCxtQ9BKJGqNawtQlqVvhK36Tb4DzdDi3mXC42twf05oh2DIfepZoHWl+n707U4lLPKe8yNx36uNXXlomLu3SttyJcXLxkr9Ud16P5V04tLqztVAK9Yy+5UNf9TjXQEE+x8rvXjxDPLqTAufqdBoV3CuVMrP1N1MqL5NkFkWcmgF946/P8Nz/4Fr/zox9TEdBBkAnB2CjeurPLi/v7UJYI6dHOsjEy3NyNxcnHN+8ilUaOh1RmhFs8BOlZLkoGVYA0YHQApTmfLtEqli+7ORpyc2uTjdGIbGMDFQJn53NMakhSHYuiL0q8E7gq4LTnbDrnYDYnINm59TKvfuqXePTBewhlOH54L9YT1hKtBc5VyFBy44U7DDe2cU5zcO8j7n7yM1y7/QpaK8YbWwBko/jXE51vZR05K4SmLBcoKRFSoerkxN5VVMWCk+NH7OzcIMmGSG1iLcYAVVlgq5Iiz9m/9QJBx1chRDRphBDqhJyidfZ0rqxTSHic0FFzqGLKmUgaJVVlSZKEJFUx56AQeO8i2NYF3hvyVl+Qv/Gbf4O3v/2veO+de7z94QGzRVGnf1krBxfWq4P0vurn1Fxd67gRmGJnGtDxNRmssaHVoPZNFf0fzT2E3uDso9dadG+zRvT/NhvWI4F7x9fr+63Zp49nF7b3O933WhZxQg0rEnBHSFdeyZqgvtKLVURb26GbEH7aa165XFhdf/FeVsGy3TN0xFS01w0XzyIk3kmcFSTCgPcUlcPLgM6en/bl5NHHMfWJCOhIP1FSoBTo4BDBMhpoJkNFEFAuCpSWTIaBzDh8FShFRenA2UCWSAonKJxAGzDKMxg4TCrxVUBrsGWF0RInJMKBsxapBKNMgjAMhp6BkRRVydbGmOubCYNUsT1O2RhrxoOEdJDEoLlEkyYyah+Viz6+xKheLWMtYYEn+Fj3NzOQaoVWgsp6hIta2srVNbiDBAVGKIRUOBc1gWUVCZrRkixVVEEwGnhKF1hU0cyMVDEVkxRY71AhCuexwq5HK8NwmDEZpcyWJdNFoHQeqCjKeB1RJz1uAiGkACMFSaKRg4QQ4vMKCArroqavJoTOWioX/UmryqKJ5SZ9x2uQKmDQhCQA0UJibVULhzE5trMOZ59zHkDnak2zIKYlAhFkpCEikqx+wuWuHm93cxEnOwG/P/5XeNtaE622qr9SrMHHGhY2C73DLgjqPbDp/9+cfx2QGli5DPJ+quR6mbx7YX4Ql2y7rHUbQ7/XDWQ/zdS+gond3wtdaywgyObBE5N+C/ASI0wUcLzFCxiKXwAB/C/+4J/zweETdCK5mQ24dm2bu6ngJZWS7mwz2Eix51NGOHQiGWdDktEOav82YWub2ckp0/c/ws5PYx1M53FHc0BgfMbYaMx4xJEvKUuBlQGpo8+HThXCSMqzJbrOBxiMYFktccGRDjMcjiWBpXUsqpKtrW20krzyiU/w1he/gpSwnJ0QgsBWBU/uf8i7P/oew1Rx55U3UckAIRSvfPaXGU62SIyhLJcobeqPLiYjLfIcvEeZJL6I2tTjvSW4GJELAVuVVGWBd4H5YobUaQRDM4yF0UVgvjzn8f17aKXY3LtBmg16gyWahIPwrcM7SJSMgRDBR/t/ox4m+AiowcUSccFTVg6pokklSRKE9K12D4jmjQA3b93mzU9+htdeuMUXjk745vfe4e33HnI6W7SD3PcIYZuOIzQpVJ5f85XD+oCtI6KCis9IKiKhqp3LRU2SiI+zbv3o2e7/dTToD8EezHQUJawCl+gBU5MiQLTRbM0x4SLA/Ayk6jY/RdNHH0N669bP+7NUeJdddI2Zdglj+ZmMsMPLp6Fmr19iFfC6/FZxuY1i9NHB2XuN0QmpSFjac6zLgUhcnlcbqBwJZCmoOulumiVI4QjBo6VGKYdJoi+bH8aJUCcebDTtqEQxqM08BM8olUy0JLgKWwUIKQSFLapYb1cJhNSYUYKoHIoUIT0mhXePcmaLwHhLcHMzIx1kbGeQqkCSGrI0kj0JJEqgZMRQo6KWTYqA0gqLonBRkDRaAzHaUIoYaOVC1NSYJN51aiTWJeSljRjlonlXEJAyoHUUZqWAgESrwDCTUWu2gIUVOAQIhRIqFrn3gbKy8Z36+vvxnoDHu/hxeS9xXpGXJQfHU87nS7JEsTUeMhlkMTm2IJbUqwNYRBAIJUm0INFgvWaQ1t+Ujabgwlqq0iKkwPuAtXZV2JPR2mPLitxHQhlEQBItKj+H5e3PpNnSUxFLBUoB6JiAW/pI9mLS+4YINmlDwiqmXSa9NYsNA6ybWP/Vx7t2dW/k98hne/4+Zl44sVj7c5FgrnT1KbgWnrrw049b0xKs9q+tyiFWd2fljusNUTwPiEtUr5dcdIXFdsuBPvmrZ6xGIx0c3htSnWCUplwsIhZKjZa/ABPwwHn+nevbDDeHfOrNW3z+05+lWjrOP7qPHm1wfn7GyfwJR2fn7O/vUsgE9m4g84p8usCVnuKowM9mVFVOKWFPDTCjMUmm2ZlMMLf2OV8smedzROVYzkuGQ4OvwOcVZb5EuMDm9V1GGxNs5Vj6Oa6wmExjNsakyxyBJBkM8K5kfn7GcGOLIDxmmOIqx7vf/xG//w//O978zGd4/XNfYWt/j7PzGTvXbjEYT0AYpPCUxTyaT2WUR6NZQOC8xjlPOlCUZYEUkrJYAgGjJd55iqIgeCjynCQdYK0nG6VRQ1VH66RJxrVbL+C84/zslG2dIJxDmwQhI6gIoTBGr5gAA74lnsVygbclSmuEjBFw0Qk4ZufXWmJt9JWz1kWzhm/KBEWiOcwyPv+Fr/DHv/+PmYwnfPUvvMWbr97i3Q8f8t0fP2C2KGLqjcZ0F5oyXOG5pt8AYg1WSiqnoi+EkAQpkD4m5vXBxwTggg6YetL8qv/cJX9XxmkcxGJlr4YMrg970UrFHe8Tq0DYAMxTk/Ott94Vw7Ms99ZdJuFetvAUrd3qCvHTNnK5pNzVH+3vvkZdoSV7HRFcSTcUeqDnIFiLRlH5ivnsmGW1QCdDqipd7+AvrO2NXU2aJKL57lweBbxUgIrjy1YeXzp0ohFSEGysGCKEJB0IQMY8gEUZy8A5hy0d1tdRwy56dBmtYx1kL+vyUBLnKhZnJbmTfONdzWigGWQJUke3mHGm0CYmgg54nAdZB08IL9tJxTqHVgGXW4SIfoBS+Uj8lMBoGGQZRgm0jpV0KuvJbXw5BoHShrJylGVBWbo4HjGoqB/EoSh9JI2J8YyGAfCwdOQ+ah8jeQRkLKlZAkbr1tIghWoT0IcQmM5zvvbtt3nw5LSN+NXa8Nart3jp1n4M0BDUlo9AndQQZKgTVhN9h6UkqEgKpVI46zFG4339LESdnUFInLV44RBJVExMMsXuKLC/NcRLWObPMRSdqNW0Io8BcDaG8SgRUEKA8MgQc6XKRkkAtEnK+1xrDfNWmU1YGeqX0hhxCRauKNH6RJCOVLe/iTi7cvJ2Q8+wcbEqyNPaz4oJu0y4Xrn2hb3Xrnrhwa3OCKFHJtd4dK+Pq/PPasm+cGEfgYjWL6CqAsF6EqlYFjmz+TGlrdBmSFVmT7vtC+2ZCeCtDAZSsWMd9qzgbD5DnywIKuPg8SMOHj0mdQXjbISrFCbbhJ0dFI50a58nT96OKQXyErExoJgumNy8Fn1hfODJdMGWT0lSg1GSpVuS5wVJYnj48IitvS1UVTIej8EH8kWOdBVJEAQZgTRDkE3GGCXJspTvfv2Pee31T7A4PcQkKSY1/PEf/HP+2W//I/auX+Nzf+mvceNONE8n44JiMWUYNgjBk5fzqD0LdbLhUBdolwlmOKDIc0IgOlyGOBhjVYxYJ3M42uboyccQJIPhJsdHByAUJk0pi4oQPCYdoEJMM5MNx5FMhWheEMK2ZuZGq+VDp8Gz1uKqEm/jubz3qFpbGIIleI9SGudi2gglJdoYvHO4UNXllRSizleGTvgH//0fslgs2N4YsbM1ZjTe4Fe/OOHex4e88/EBy6LoPtd6ED/P6EsA5yQWU1ctAYmqIx1FdNqJjxAv+iaHxocvdFqty0hYo8ljVYJdE/VYQyrawX+Z+beVgvsnuOQUTVvB2wZAen4iNLcQLtne20fU+/T7Hlb3of88Vs5+QQG4MmGs1xNoeyK6Y3tPoNd6yWwa0he6Y+Kqbnuz7H39zwXwDi8szllsEwFP9KF7Xs3UdbGlVARRkzoZqMoKjwQvcDhEiNoz6yTeuugzFgI6MQw3U0wiSAdDrFJUxRIhBHqYMcgGaOGxlSPbGFJZj82rGEjmBclowNkpPDrT/Oh8zLmdoVTFeDwin00ZZhqpUvAe50qk1Egfq3aUPjAQhtILgtUkRhJ0JAaDNAq61kp8CCRSMUgMw0zVpTZpCaxRAuehqCqC8xAkSqcYoukXoq91UcVnE3w0NUutGAhQMqBUYFoIciepPFjnCTZq9hvfumGmKQuHSqIQ7L3HOc9PPnzE4fEpWgusi/nw8nLB99/9iOEg5fbeBgKBUbVrDK42bSuUqM2nIvqUCmzUMDtPlqa1i0n9joluJz7YGK3sPM5bhonh5lbG3obhlZsJGomjem7fIEBlFSUJAteWPkfGesBSiVUNXSO894hZMxb7glozGldHU4c+q+sbktbHzHpLCyCixd2mOklTVWmdVHXW3f6VOnelLpvhWlsTPC8Vdi8IoP1dwurxl+4VL9K3hLR0tD4k9PZbEawv4O4qAV1Pf7Xe/Q7HY4S89wFvA/iACxbrLJUL2CDAeZb5s3+Hz0wAX90bcv90wfGiQB8e8sM/+gZ7OiORKcNxwkQElgVUGaiBYb59E20ls2QM5wuQMNrcxIc5ZfC8sncd40ucFhxNC/zpOeV8ic40tgoczgvOl0tcolCDFCcDw50tNrc2SFLD2XRJkBLpqvhBeYVwjrFSvHh9l3tPDskGGchAkmisrfjhn/4xb3/ne3zic1/gr//7/zP2b96uk7qC1p5ZvqDM55hsSFksyAZjZExw1UovUsXfSVprHITE2hLrPYlOafyyssEY5wK3XniD4B3nJ8fk85yN7V229m7gnCNfLlEmYzDewJgmIXRNQkKgKhcxWtfFyB7f88FTUiOoE8yaDIRsk6lqneFsSXCWqizx1uBNWluy44DStb8ONYmbTs9IEsX9B1OeHJ7G3IRBAII0UThfrfChi5P782nBWoQKMQO+l0jfEVJJk/cqDrVoqvW0ANZItC3jCReGZHuPgrXaj/Ei8RRd8s0aFtpAklVS1knezSBfw8zL7/EpCy3AhLXllT8XDljZ56fTpFXwezqOruj2+vJq+zJWobqHmi3xq6eeHsCF/nbihOFrDaGvtWPeuejzGqij9iXeK8r5c9S+iKhtsVVM02RSRXBRUCwWjuAFg42UJFHRXSTRSBKEiqlZVGJIsgSpBFJJ5guLlBnKSJyD0iqWLgZS+EWFUgnj8Q5mvMOSXfxon703drkx2uLXhhN8cPzeP/nveeeHb3Nje8AoVYTynAoQLkTimCiECjFozQaEUlFTGRTOyRjFW8k6b14MaEhUTNtijMGJGGnsAa0FVWWZFw4ZQChJUVnKoqKs6hQVPn5LPiiEr2twSxW1g8HXmsWYLsZOK5ZF9CuMWahiHlTvPOezgvmyQEsXfe98AA+Pj08pHIzGQz7zxuv84Ac/wi0W3Lh1iw8fHnH3+jZpnS/RuwgSzoeYYkbG4BxCwIaYTcA6h6vN2JWrCaAQuBC3NemHpIDUJGyNE/Ymiq1htAoliWBZmOf3DQK+KgkqTv7C1l6TKqCpA3RkTJfVuMM05K6rxtETABuYu+B7S7vcytPN6kuFWrGCq/3KPY27Umh3DrWguka6RE+bdmlC06afrEALF39ejpXr7SmX+KkrxZrGr79v6K/vC+3tU2cFjEMXaR63hAsTRBON7kP8nm1h8U5S2ipqsUVGCA5rBcvZs2PhsxuLpxUvbo75cD7jnYdTXt3ykFUMhjnLBVgjefNTt9BOU2RjFlmCkApPyVaimZ48JtscMVWGYpljnScdRCl4mRdsTTSuWFDmkjMbePvwFKUUD49PeOPlWwyNJF8WFFuCSTZCn5Xk1lF5gTKCBPCVJ/GBW5MxP/j4MR/cf8T3vvZ1vvpbv8X09Ih3vvunvPDG5/iVv/obbOzsoVRC9JrwSAmjrR2kMXjvqMqCJBmiVARQpQ39qU7WRCo6/9o65YImIGoTrmB7/xbj8SaPHz5AqQSCYzY9QygTiZo0bO5uoEwEjqhpDNiyRMmo5UvSlCovWtLgXFVLpzHy12gDiBrkPNPzOePJBkrFyTGRClcWeGtjuhqp2r+xnIzHO8edW3f4G3/jb/Ff/z//Xzw5PiFCRvQzXOS2/XyhR5Kes/YP4LwM6CRDiRIvJFZEfyPpQTjq+s8gRfQ9avwj6x4Th2RHQFrMqqVkAdGkUmtaI3h2g72zYvSHv6glXTrMWjH79pf7IjKXYtKlEi4NLepY+MryCvlaP7doj+734dK3t671/BltpYJoj/x1T6eTkNvdeiSwqVLQJHluons8IWpyW1It8cLjQ0VZFVHDYQKhAhEktnp+rgjjrSECKAuH9QItoSw8eQ54w3CSoFOJkGAGg4hP2QhkQjE9IvgMZ25SyoxkvMnp6X1y4jlCMGSTLaZnC0gytm9dQw53uPP5v4CzjqPHHyMJeFvi8pyT2ZwfvP0+3/rO26Qa9GgPXx4RygqUQgqJIuYJjOqsgLdR6PVK4IVDaw8StFYYBamKTuZSgZaKoTEUVKRJ9AWMZRglhbXRN9ArtLYEr/E+p7AuaiqCwCFjNLCr09+ESJaDBwWkWmCEx1eWKkRxjRDPryXM5gWPnszBpSwXFWURI283JxkHx+dopbh9+w4ffPAR1pXYylOWDoRCipg/NQRwPprTBSCEimS8sjgb08P4OjjPupgou6ng4nxH/gICHzyZFOwOYHci2BwpVHAUecyy8DzbWQnKDEhkifAS70PUbra4J1CBHh6GlggK0RPh62jnVkBdkXsbpUOHNm3C/BUy2CeC/XmiBcyedq+nQLgQOLK2IFaVDatEa5U0rom/PXk8Pov1M6xeSvQvyerCRQK44sMY1veJuFfDXO0j3nseK/Nmg3mh5o7xd+f3VwvHIrR3J1X0r7VYinIBUmGDxXmBIqMKz46FIvzbmMWv2lW7alftql21q3bVrtq/tfZ8Pfiv2lW7alftql21q3bVrtq/9XZFAK/aVbtqV+2qXbWrdtX+nLUrAnjVrtpVu2pX7apdtav256xdEcCrdtWu2lW7alftql21P2ftigBetat21a7aVbtqV+2q/TlrVwTwql21q3bVrtpVu2pX7c9ZuyKAV+2qXbWrdtWu2lW7an/O2hUBvGpX7apdtat21a7aVftz1q4I4FW7alftql21q3bVrtqfs/b/BwrxiVhxBjg4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 3/12 [13:40<42:20, 282.30s/it, test/blurry_pixcorr=tensor(0.2869, device='cuda:0', dtype=torch.float16), test/loss=25.2, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=3, test/test_bwd_pct_correct=tensor(0.9062, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9375, device='cuda:0'), train/blurry_pixcorr=tensor(0.1698, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.5580, device='cuda:0'), train/fwd_pct_correct=tensor(0.5771, device='cuda:0'), train/loss=28.2, train/loss_blurry_total=27, train/loss_clip_total=1.15, train/lr=2.59e-5, train/num_steps=1173]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 4/12 [17:34<35:04, 263.04s/it, test/blurry_pixcorr=tensor(0.3413, device='cuda:0', dtype=torch.float16), test/loss=22.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=4, test/test_bwd_pct_correct=tensor(0.9531, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.2198, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.6947, device='cuda:0'), train/fwd_pct_correct=tensor(0.6494, device='cuda:0'), train/loss=25.1, train/loss_blurry_total=24.5, train/loss_clip_total=0.663, train/lr=3e-5, train/num_steps=1564]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 5/12 [21:27<29:26, 252.40s/it, test/blurry_pixcorr=tensor(0.4060, device='cuda:0', dtype=torch.float16), test/loss=22.3, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=5, test/test_bwd_pct_correct=tensor(0.9844, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9688, device='cuda:0'), train/blurry_pixcorr=tensor(0.2578, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7294, device='cuda:0'), train/fwd_pct_correct=tensor(0.6666, device='cuda:0'), train/loss=24.2, train/loss_blurry_total=23.7, train/loss_clip_total=0.521, train/lr=2.98e-5, train/num_steps=1955]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 6/12 [25:22<24:37, 246.32s/it, test/blurry_pixcorr=tensor(0.3933, device='cuda:0', dtype=torch.float16), test/loss=22, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=6, test/test_bwd_pct_correct=tensor(0.9688, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9688, device='cuda:0'), train/blurry_pixcorr=tensor(0.2854, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7421, device='cuda:0'), train/fwd_pct_correct=tensor(0.6723, device='cuda:0'), train/loss=23.8, train/loss_blurry_total=23.4, train/loss_clip_total=0.446, train/lr=2.92e-5, train/num_steps=2346]" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAACaCAYAAAA5H/n3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eawl2X3fCX7OObHc5d235l6ZtW8sFpcq7iJFiiYtmVSPLS89PW4P3LBheIBGoz0DN9B/9GCAQf8x6H9mMMAY3trw2JZbbVmWZMla3JIsi7tIVZEssvYt9+3lW+8aEWeZP84ScV8m5SRE5vyhPIWsd2/ciBMnTpzz+31/u3DOOe63++1+u9/ut/vtfrvf7rc/NU3+/3sA99v9dr/db/fb/Xa/3W/3271t9wHg/Xa/3W/32/12v91v99ufsnYfAN5v99v9dr/db/fb/Xa//Slr9wHg/Xa/3W/32/12v91v99ufsnYfAN5v99v9dr/db/fb/Xa//Slr9wHg/Xa/3W/32/12v91v99ufsnYfAN5v99v9dr/db/fb/Xa//Slr9wHg/Xa/3W/32/12v91v99ufspbd7Yn/4z/4eYSy7O8uMHWFKiWzagWVr7C1MqXs9ZAqIxeK3UOJlA0Pni4xKLSu6amcgzFY6Tg2bFhUNY0TCDvDuZz+cMhk7qhqyXxRMzcl5fFj5KrACQECnHOINCKBBKxwOAQKcIAQYAEBOAfSf/LXCRBOpM/+fAdO4HAIJ3DS4RwIBAKHFSDj7/hrBaABgUX6y3GuQTrAWaQg3FNhBTh3dAzghPKDDeOTCMJppMzcjvS7Ew7nBEJYQII1CGeRSCwmjM4/n5UO4SRWOITzI5dh5pwQOCEQzs+gDXMonAXn+4x3FQjfs4uDDnMWh+YEDvgf/urH73YZ/Ynb/+sf/n+Y3LxOVdfgJNZBrnKElEhknGWklEilEEIipPRPIwQIgZT+5Qsp8UsrrKr4ObwoIW7/B9x+HBHeJbefK7vnyvAXhPgBspfornDfXOdz+4tLv/kPd/ouukd+YPOXHj3P/YCPcYE6HH5Pxt/9b+7I+g3jCuOTQmBxYS8L/zfNu383QkhUeg/grEVIgXM2dSmlpK5rLBbnLFvHTvCf/6Wf+08+64+iPXzuFI8+eIZRH771vfMopfx6kxJrLULA2uqIP/9nf5Iv/MxnuHjxMv/gf/55nLRs7y5YW+2jG8PhdIHWFmMarBVYZ9haHzKdzjmcLdhcG6GNpdGGv/CFz/FTn/oQg37J5Ss3ONi7STVfAJAXJaP1dbaOnWDr+HFGg4LLFy+zefwBfuEXf4ULl6+ws3uIkBIlwGH9fnECISV/5hPP8sb5q1y6eguHoN/rgXNooz0VUyCF5KMfeg8vvPQ60+kcqx3OWaQUaN1gjOMzn/ww2Jpf+62vgFBkucIZjbbturDOYl2gSFLgjJ+vLFNUtUYKgVR+X+rGU9ksz+mXBY+ePca7l26wdXwLcHz8+Wd5+pETvP3qa7z00mtYAdYYpMopywIhYGXQI89zRhvHeebZp1lfKfiH/+Lf8c7VHYRzKCnI8ozRcMCt3QOcsRghUUqhlERJycqwx4NnT/HNb7/CM4+dZedgzHhSYa3BOpDCr+vHHjrDb/z+t+7JGgT4O//d/5n59i0WVR32ot87OE9jcGCtRTcaqSQOUEoipEJK5feT83vREfieEFjnsNalPWtt2KORNoUNLiIP7dBPf9xzDxnOj38R6cwlGhkvdZ1PXWqUKJlzt/fTOYc7fF7u4MjB0I84Mr5Eb4UgTMoPHnfnc6Sjt9XWECLQST/H8XchPR+WUqCURAq/J5SUSKkCXVFpGNYarPX0Dpz/HYkUgrquaaxGm4atjeP8P/6f/9PRWbhju2sA2NSO/YnGGNhc63E4X/DA2RGLiUOqnINxRtmXnN4UyNyyd6CZzRS7U8NoKNncEuQZ7B1UWNGjqgy3dsY0ZgFuTrkCZZGxvl6ytjpEKsG0HrOQq2hR4IAswJLI6pwA6eTSYhD+fYUX40B4AGOXFqdNQM4fdIBECIvEeZAEqADMIliUjojeyETLliUCJ/MEIISLO8OFhdsgUMtAw1mw2o8lAlMZYSfpOeNYPLjx43fOgswQQuKwQN4BANbfx6NYTwz8gwMeEApnAzCsyJ3DSeWvlRLnMg+4HTjrUMLhJOE+YfBOhPHYI8Dkx9+2r12ij6WfZTikf0NC+seXgiyAPik9EZdCQABeMgC+OL8JkB8BfbFFUHIUtHUBSwsKYRkgtoSwBYAunQu2vWd7w6V2OxSMzd6ZpnE76Vz6fpQAxk9LHd0BCEa678KqTIJKJMhpR7Y9hPUXQaII68fLFw5J2iIBHPibWAMIf7YIgNA654WwyKycwwBYv/6M0Uz2D7lXrW5q9g/HPHjmLEpBniu0tjTGYI1BKcl8XnmaI3qsrG5hTIWoFuzuzxn2S6yF6cyDiLLMGfZ69HsFD5wYcTiZMxxPWRn0mMxrprMFs+mY+WxKrjL2d3f8HEovNJb9kqIocc7RLGaYUhFkHjbWB8znaxjtUFmGwyTh2Fr/oWkWZEJSFiXGOYpcIWQGdU2eZaz0Sooi57kPPMeN7UN29/aoFg3WOnIlqZoGrCWXhkzCEw8/gEOQZRLhHNZ5sCgAbf39cQ6pFM44MiWRStAYAzbQYCTaaADKoqDXy3n43EmGvZzjJ4+ztb5Kr5ehpERgEMIDMQRILFL4fjMlKTKFbSqaesFsrvngex7izMkN6qqK0jtSOM5srhCBgbNgHH7tCaCe89ipLXq5ZHNlyEq/5+fQWZRUOGsosntrUNu+fpVcG5QKNDsIVNYGgC8F0klknoX1IpEqgguJEFmX+iwpRghAJQLD9DstXeu2JdATP3ZxYRKUl59hCTy6pQ9LXSXq0rmNiAO+rbVjvq11aW4cTtQc3flUf37nXv7x/fPceQxdEHg7RBWpH5H4jxeExVIfOI01TRqeQJBlEVxL/66dxliHUoK8KDAmw9n/tNAf210DQG0UujEUUnDzlsG4ITuZ4ezxgmEpuXVgWNQF8wUc7M04e26FXk8xXkyZzHMOp5pqZlkZKoYDQT1zCJHRaEWvMCwqqGrLojb0VyS9skC4BqYHyNVNnPKL2AXmKZxEBW0XELR90hMA4fB6QIkLjFgETZYQDoFnKOAJqH+HNmgORdD4edrgAZOHYATQJyRYQVSKgRQBHPrzg3oNFxaIcoplyUaFO3m9ZVwQMrFFA06HYxFsBMLkBBYDrknPhJDh2SVWSCweEClMfCKEsGjpnw0hEVYAORYbGG6AntalMSjhvNYKsFJhsEgr/FxZ7cm0i8Dw3rRhv0cvgDshPAg2NkhWHQAnpJeMhJREva0H2Ny2edMmXtLo+WMybtIE9uKmXe4nXiOEpCtZpus61y9J07DcZ/zQyhfds34Qhmuh1x3FX391AmZ3PMUtnd1R6x0BkcsaPX9K977LUm46t6uhdB2oGD6LcJ7r9C+Cdh/n12h6f54I4KTy2iQDja5uf64fUzONZTZbUBQlIAPYlfQyhSwKer0yMFlBY2rW1tfo94f08yH9vZssGo3AUdcVAofLJKapsMog3YiNlSEbo1VOnzkOzjPzhx86jTEaayzVbMrK2gp1Vfn5ElAUBUplaN1Q1xXWgbCGn/3cJ6nrBm3AOEOelSAVWdgfMlM4J1DSITOJVDkCg9GgrfOCnjNo6/v9q3/xZzAWtLEYXWG1oWkMxllM02CM5omnnsIai3MGqw3GWnDWMzNrsdamYwSaJ4VngM46cF4rirM4660vWZYjC8WgX3D8+AZ50Lqapgr9WBQSF4Q9JQW9siTPMyyOqdZoa/34Hj7FI2eOce3WLuuDHr2i8NJ90LZIkeG8aiYATK8BlSpHSEGmMlQmybIcIS1FUQQ+ou7ZGgSQzpHnBVmRI1QGDowxaGva7WsNUvk5FkH6tdZijFkSPL0FhYhu/LUdgSu2oBCjvfQoqPvBYuvSOeLIOXewfNx+Uvd4yzej5k0IkUjZUTzX0hhamVYc+THQ5qVnPEIuI90/ejTqm+JJyVoZO7zt6bqA1vn9emTAIjyTVzy4RDtbbWGr2IhYxjhLXS+OTtgPbHcNAHsDx4Zo2FgvONyfYZymXOlza3fBrAdlodjazKgXNVaVXLhU8egjffqlIpcarGK+qKhqgVUl1gkeOAWZKtD1jJluICvZ213gGsO46bG6kjEc5AgxZZGtUWvpJwWV6K4K2oII+gRBWyZkAmASUNZ/sHjzqGfWcTUIpHOoYBL167OzCtKbcUR9nAqAwUkXlIIShE1gzQNSv7KskMkE6wFXC0JdgngWkbRsEsj9M0aQFzRuSBGAokz6HYEKC8gCGmErT1YtKKU6kk54EOvA+euV8AxW4k0HTgRjulQ4FXU11h8CjArmYuk1n+LuhY0fScvzDKEbdK1xeM2qsS4APoWTIjynQQtvfvBq9I52rwsAj6j0oaPxQ2Ci+r8DDO9kAm5Bnk3gjyPn3XbfdMug+Y1A8mgLh9zRA0eo05Ip967A4R17WbpLl0i1Z7R9Jebglk3CjpZ5OGuXgJ11ttUwRJeDYCYREMy9vh8ZiJwxNvVlrV/51gaBTIjgdnFv2vGNEYNBgWlqzp1cj/IeeZ7TKxSDXg+VSQaZZLZwnD21yvPPPsVkOubBB06jVIaSAmsNCJVokZSSTGaovCAvJE1jGKwM2dxYZThcpSxKpITxZA8UVFUDWPJFxcHBIePJFKUkeebpxdbWCbLeCrKQjKeHHOwc8sADG2jjMMZinIaqwbooNIGwE89EmgrdmCXNhNFew6kbTdNomqaiqWu00VijWcxmWOcoyx61brBNgzUW7RpsY3DGYJ0HeDYAQeFa8OfpondvcXhLhzXBvUUqpFLMpgua6RSVBwboBOcv3GDncOFN8MY/x4q27B5MyTOJkor+yjqXz18mlwYFZBIKCdPphNkUD3IdOCvQ1mGdTODaYZFCoWTuzXVZEECBTCkPTpUky+6anf5ImsNimgpjNVlWIKXy4N9ahFQQ9prWJpjrAx0MbhYiCMV+72qkDM8cRVHRAqK0f+O9k0mzq+lyy+CJjmBMK/ym0zv3Ia2zOwvAS/gqCvlpHuI943GRQNiyvOtu76zTvArE3QZql02+R8bd6duDyyN0sgOmib1HZVGiecv0XAh/TjQRC2G9UKOUF4iFNwc7axL/sTYqiKDIi9sf7ge0u16xN7YtzWLM9k6Pfllw+kROv5gzH1ssGXNdML+lOXsiRwnDdGGpKsX+RJBLy2NnC5q5paoNTW2Z1QW6nqAkTKeKhZkjpGRtPcc5zcbIoDJJqTQIx2o+Y9sMMAGCCQL4wqHCCmhfh01M2b8jj16csN7vJb7fLnMPiDu4h4V1aOObCu81MJokZoT3La33H4wdu8iQ/Ml+fN5sJ4NZWDgJ0qa+wmtM0osTIkA8kZ6plYgCsQwM02JIvh8yA5lhhUBaF0zffrNGf0U/RBdM3DIQW4cQFpxGBnONTUDFeUaFQHXNdUF7eC+bwJt6hJJImSOEfwq/91oiJKM9qEN0WumtQ4g6kmS7HiJRaulUmIpWbb/02N2tviQILo08mU87GkIX/opOX0fnNI37Dh13CVwkfy7exyW58Q640C33dxTQtVemmyS9nTtyLIK5I7+n39JxTwRFOBZN4s6211oHmFarbLVtBZjuyFwLspfH/eNvH37vQyglwBg+8OSDNE2T1pxSnpYoCbPpjIO9PZ58/Bz9wQBTzSl6mTe9CunXsfRmQ2ONF2SU9J/nDdPxmGo2p5rMENktHJApyfnzV9nYmHrA2e8zGBgk0MszhJQMV4bYxSH7199ktDJksLLCsfUVTm0+SFaW3s/Saoy2CCGxeE231yQpBBkyyxBCeWcDU9NUcybjMS9+9xXeeO0tZof7NHVFM5/hGk2jG5wxVBactVTOYY3FBqBuw3EX373fsUgJuRLkUqBkdHVxOBPfc2TJFicVDlDByiKlF6ClE5xc63uhNfSfFTlSZgz7OcN+j8FwAM0MIxxFqej3egHw2GAKl9RNzXyxYD6rmMxqJvOK+aLGGIPFm08H/ZL1tRGnTh5nc3OT0dqIfm9I2euT5/k9W4MAucpQ0gVw7Glaliu09lo+8P57UkarhOgAPLe07z2bcIluRuHMuWUgmPhaV3CO7kadXfqDuUK8d8d60tE6CnH06khbl+BeApWiS9zvRIQ5IhiTYFg7znS7ltAs3010roy/L6PTpRF3SPiyZfzooJafMwJQKbyJt53XBCOTP/RSP1KlPpRSZNnda6Lv3gTcHJBnjslkRuYMWhccNFNGqz3Wh5KDmWZhcvYnjqq2rK32WRtZ9nctiwb2JorDhWRjpFhfgaYuUHKdqh7TiHWEnNJUhvGBorY580XDbGFZHSmMyRiNDMPNkrHJgpk1mF0BP1cCQvCDC/5V0tkAeJYXqDctRXgQJla2L0Gk1eTNqh4shetFu3Hiy4qo3GtxXOrX+8j562W4Nnk/Jb/DluES751AoSRpIp0HbR50Bi1mAsF4rVzUQwuJwksNSAdWgvRMVnafjawlyEJCAH4ujsFZcAIjbAgXD/OKwwqDct0FfG9aDKQgMIMuk+j6rDgTiEyUdPH+PMHpjGja7s5hC/ziORB9KFMASdLsEc5pAWVUPi5Lhr61c9855qLZokMMIvAM946Hl/xwEpg7ep9IYjpgsXN+vL7DAjq/t9Ln7WDxTueKDsBrf3NhsEvO5bYLFru9tkQ/gsPYT/ThTdrGNPBIJuM1gbmpe+d/JcN4q2qBKAovjTsLTqKEAgdV07CoF9zavkaePYsK2pW9/Sl1XeGcYrGYMZnOqevaa+SMQSkvzTeNQQhHow3GeT/rXp7RKyUrK95XTUmwzlAUOYPhgF6vpChzNtbWOXHiMbY2VhkMB6i8R16OEPkAoXKvJTcGU019kIZuEIBShfctznJUlnktEg6ra+rxDju3rpOpjPF4yvjgkGYxR9QVNN5XyRpHbR2Ns2gE2oKx0QcwAnxB6wsrKBQIFxzfM4HDBFAmwJlwflhtHjnjZNhLRiCkC6Yw7+9rAt1TUqKEoMgz8sxrXMui8Bq7yC+cRGsPVL2Pc0ZROPLaolSDEl5TGAX6TEnKImc4XGF9a4vjJ0+xubXJ2uoqw+GAXtm7Z2sQIMsyhDEd4dCDvTzzwUj+kA70PSI47zMd59//hWSKj9Jt0Lzju72Dn3AHQJG2Zmh3smMcQUnx6G3C7m3SXjrm6aXsnLvc9RI76gzsKBhLAvdRDJbu1x7vaifdHZ6rC4LbZ3Gd31taKZKCIgLg5QfwfDw8i4txCi0a8Xu+9YVOAw1BISDRWlPXDXfb7hoA5rMriDzDzg6ZzSXb2YOoYoiROcI19Psla6sK09RM5xnbe4Ish9G6YqglmXRoBuwezNEs6A3XGOWWvVuOTDqaxmKURfYUuZFICSulwdQSJRqqqiQ7uEVvtElFjsR6M6+InnsugC8TJIPAxJGd7x5EeW1d+6IE3nuj1bG5tJgSew7YL/oFevMsYYGFlRROdAE8SLpRjq0sEUJDEgwLUDAsEucJnPMBC95P23XASXR2dgkftEEuIgDfIONEcCFtes5utLBDgogRxB7MJv9R4YKkEcaSlmskFMFU3OXn96CFkQaVt2s3svR+P9YF6VfEzeMSeG4Jn0wBNyBa3zIiuOtohqOkKpePRdAn0jXhfh2A2Eb9LpuBE4hMGz8Sva5Z+Mj3cO+jrcVTLXg6GgjSnrdExY/0cZvIHK5OqK4Fd3FOAyHyBMtrdfwx4ddx/CcDVA/R5F2/oq4jdHf8LXuJ409wv503IYiZrKS8d/5X77x7CYRkbdjH9DJWh33KIqffK5FZTmNh0C9ZGM3O7h7NYkaWC4bDkp3DMfV8xqLWzKYzZrMFJgSzWOdpoXWgA1/XAUAJ67Vk1gqMrjG6weUKZwx1taCu58ENwpuGmsZQNwZVa3JXI5imiEGB9GBK5FhnwHktIEIhgqnTBfrg322gWUKQ5xmZyoIA5byMmFxXvKDcBNOW7QgkIpyVsIoQSWBK4IUoWEWqCEpAFDwjgwyiL054FyBoAYh0PthFSolwJggHCqWyJBA7IbDG+yFq67M8WATWWhpjk4uCDBGZDk9XsjyjLEtG66uMVtcYrIwY9HuURU6WSTJ1B4TzY2xKKq8yV979BUBYh3UmmHa9y0xXq598lKMQm1w48O5FQSPdBUupHaE/UdPluxF3Ik8/sB2NAL7TxV2TrAtILip/4u9+6B1R+A5j7HxrBdzE31n6cvT7H9eWaFiHhv4ga0TXvN5FmSL0kRQOYU90j0faG+ljV/gWiGBN9P3Fd3g37a4B4G/+yi8hgNHqGg889BCrK336g5JKwOHYMJsZsnzBAycFWWY5mEBd5ezuC4S0PHQajh+TzCc51ioOJ5Imz+itbUC1oNlTrG2WTOeO0ycLphNHrxDMFoLBQDKZWfq5pZ4fInsbCOEhm/eI84DOAyda1J+0KS6Sn0Rk7FE8L1r03X1JYTvQoi2B7GgQ0+lhA+E8gYmbK0Z/xncvkhYjgK2gHYwL22uKZAhuiY65IZKZ8I49HWvTuYg4GL8ihPSpNnDL6WV8VxF8OG/CBR/RHBaTiouN9llk/BoBFSTGf6+bDBKZo30oD2stzkVn55aoSCk7Z0bC06YoiJ9FBFwdkJbMwAnU+Y5lAoBdALesHbwj+GMZXC5Jgelz7DN8/k80Ed57oj8dMLVkHl5GlktAMT575+zOjHXWQ4ehO1yIFo/ESHRAmovBlf7c6C9Ed6wBCAazYHtr5x3uO2YOv5VcSIHgAVJUeEcHaHsPTcCLIGEXmfIACsfIldRaU1tojKXfy5nONOeKFcaHh9TzOds3b7G7vcN0Pk+pU6I/o8D5VDDxXXgnIJzTyABOrLW4oB3UWlPVFbmQzOcLFosFzjqKbAXjfOCFNv48KRVaGzJZexcRFTT/1nS05hZndCs8ZXkwxYuWoQlBVhSUpQc8Om204CccEJqUEqFt0ngggnd2YGBemLY4obygIJw37wYGH90DnGv9Yr2/VBDk0z70fnhOCJSI+1ThnEMJj40kngaUeUZZ5t5dBxBO+ftY/w6E830JlZFlGVkmQ2of74ojhaDIC0ajIaNBn2FPMepn9MvCZxvISkRW3rM1CGHtS+8CE99T8tl0wTrVpf1SJUAfX0eyhAQeEil83H4tn0sbmuhbvywos0RwbuOPkSotk5a2dYBo19AKXnj3rLJL5/xaSEF7d6SVbul+DnC2ozRIPM22c3Jk8IlW0/KIOE9SRrq+fEsv7Ma/R8ZMp28h0nlJ0xh5eBy4CxataPUMPM1rySPfjta+KLDcfbtrAHi4t+vt0sbw5mTM7tWrbJw4zrPPf5i1kw+i8h7jRrF36B1P11YUw2HFfFpxMFPcOtDUOmN9rc9Az7g1nwEl00XJfOqojePWITinaHYE1hRMF4ZFpTis/BI/nBqyfEqxUjJYHxIjc+Paixq6loFCREjSyfReBbSq7sQ0o/nXtRdHwNa+P8CDLifjRgpgTtgWwdM1A8fbiMDcRFrg3hQRgkecDBpMTwS9fs21JpDOhkxjo/XJUHHRCQ/tvFTAUt5Df531hFSSop0FLgndweic5iGydPww/XwLgbBtpPS9bNralhAAQliEy4LDovVBAkkd3zrJdv3F6GzeBM4jmetKlx3m0/r+dUBd/E36qCybmJD373TQuVYc6Ut01odIgDD6fSwD1jCipbluKdsS9ukAraXmun+6BPZO57k7fu8GcgCJWfuF0Om5A2DvJA0vBQ6JkN8vRHILAdbpkGfT99hKtP4cD1LCbg1R687eu2j0uq4Bwa6e0CszDqcL9sscQhYCYw1FkbEyXKXfKzg4GLOoKi5dvcbBpELXmvZNhN0W3pt1wZ/L2kD8BVKGuQ4AuNEGozWNEEilWSwWzGczrNaMVobouvHBGsaEiE+NlA3S1MjGa4SEzMK8N5jkc2kQ0mG1xgBS+VylNphelVTkmaIoS4TMQSpkloEzPlpXeBcYz6BMwGm2s7+Ci4wAFwT3GEym6AizTgImCZ+toEUAlf6YDAKAFXhrkPOCoJJZ2koOR64EMs+Qee595ryo65UA1oMCHxRjMcKnkioy5b2jA/NXWUG/X3p/wp6iKLxpGZl5szoKbe7RAgzNP7NJwMY5D8Kt8fPtNfImzBfBwVakNDHLIC5c4WJ6qtiOuKjEviLACfyq+2OSC/wprWDoOtiqS8ySSTQA+xaNtuDzyJiO4q5labf9nugQ7vaARRf4fgSwkb93P9Pu1OXx0gKzTn8BkRGF4ijxtFHBJKYZA+C6fYoOCu1S565QbxpPPxwe9MVzXPCzVfLuaeFdA0DnDL1+H+ccpmnY2bnFjevXeOuVVzl+5gGe/ejHefjx92F0gXEFl65XPHi6pD/IGIx8Drz5Imd3zzATllxWbG3k3NqpQQjWhnA4XlD2crTJ6JWWeWNY6cF4LhgNfe6VQSmY7e/QH0hEOQiACp/3KoIlR8if1zIqIVrtFQRNVzDPIvw7kVYsARoRARlREpXYkGPKO05HhuiJUVzAXQAV8fgSsAjBE37dW1oXztZJN24SKWyS8DrB4Gk/xHt5xhnGHdLAeEQXFqIQ0Im4BB/wYiNCFR4QimC6iUvfJ8cO/UYHYWGTieHO4tyPrxlrwGiS6S8M34UIbA8QWmAkYtR0BGeRESlBNGNJ1QGJkfAEgChFvLZLMCORiKg8mF2Sps8irEhh+l3Ql1ZU1MSKjoYsSdKtZNlG1do01Ykg3XHqj4LCDvnq0vEA2lJQ0G1ALd6s3UdLv7nlcUT/viTIh6TN3WhBG3MddICjn0aJUNGcHAa4RPMdzrRaAIkIedocXioB+UPkvvqTNhvMnnPt/HoEpjP/Xj0dcmRZxurKGhvrK8ymMxCwuzfGusBko6mn6wPsWg13nKuYZNg6n5fOGItUAt1oL3g0DVVVMRlPkKtDwKdoMqbBaP83ahpsSCmjBFijsbrG6BqrfWidUTnS5d6sGrSRMXemkN4Hrt8vME4jhQ/gMNiQPN7vPw/kbPDHA+d8ahWF9+eLVgQBKGHIAgCxyZ4YAs0EKKKm2edkRfo0V5kMmsCwr/09jaeTAqQK1+G7VLn0kbuZd5BXSuKMxQqB1gbhHJkDkytUVZNJgbOG6WxOo2VITeMolCQvCkRWYMhorCAzDmkcaINz9zYK2NiWBni652mPczaQe2+EXzJVhn0qAiiPmqUWrEQmssxhlojNUfDVbSnEteWHPg1Z22fsWiydJ5bv0vnQ3rlDwLrm1KXvd6aL8V53Gn7SwkUfvTgVhGlJ4LS10rhw4e0sULTTEPtO9B2fUONI6rQo4OAcNtxLKZWSQuNIFg4pRMjX69pAHxesiSF5d6RJd9PuesWmJJLh7TWNxjlL3Sw4//brvPHK93n86Wd4//PP8/h7n0OUIw4PZlQmI88l507lIDTTucUayaQuEHsN/QFkuaAUiuGgROBYVIbV1R6TuY+mG61Ar8ypGkveK1hfMTRmCrKHRXWkgeD4KqXXiOEZUF2NMU3NYO0YIpiOfGoBP+ky5fdrwU+CayJ6IYDA+glrne+C/114Of6O+FUdJExnISQqFrTeLSJIy9gozficWH5MrQ+MT/Ycrwvo1oZrO/15sNlKHiIAPxFAoIugWPiYWeFixFGUJVrzqYxg8YjaMXjQ4UFgJMJ/HDX40TclPftwnd0cYsF9mLxzCGnThvWn+DFHIiSiiVFEph3AYCJQYumfP3Y7+EvmB9mVSCNwbAGeEDEJdfwulwhkHFsLfm6f09sDS7pmBmhTHkQBoRVOWuEj9n0ECd5GMJdBYyvBu3SfCMaWaZ9I50ViHO/mEkWNZhHPhIJS2b+DYK4nCmzCM+Lk79nRbrbSd1iP91AQif5tEmhMECLxZkhrozBosdbn6tTaMuj1GfT7WGswxnQi9QTaRs11MOE4E1KjeDADEildYupSKBqjQfu0VVmWMZ9NKYqMRtcY69NEeIdwjdYOpTSjPMPn46v9OLRP32KsNyFJqz3IshKMN4E6a4JKyd+/LH2+QSHblSaDX5kTFpTAGefpmPbv33b2X6QhkXbY4E0sRRRzIQrIcV79dvOMT8X9KqMJJo4hVDQKGjyLIFOOLFMUeUme5z5CWwpUprBSIqxF5qVPx+OCIGItRntwnecFsvFmYiklqizJ8xKHwjhFbQRSA43DojH3Fv8hhE/snVKXSYF1KqRA88ExPt9fELaiJlWIkGqpva4715E2LQuFoqUH4a9vR3aeu9NubBUaRG6aSF/La5dYSftq2x4inz4CTpeE8XBBFCa7zkKJXXXu2dL121v7vIG2uuA0Fecy3i4gRS+73YkOtb1HX8YlwJpu1ioinANMG83tp0p4OkG0DliidsYPwff7w3DkHwoACiH85hCCPM9Z1DWLRYUx3h594e03eO3llzh77j/y4Z/4NO//yIewtkQ3it0xjKewPpIMewXXr1XMpopF1eNwPEWZaUi2WTCbTdkbS4QyLBa+fI0Til5PcHi9YmMjZzqtGekJ/c3VdgElpu8BQNNU1NN99vduYutDVtePY2X0BfSzntB3WF/KqQTfBdE0G8BSVNNGqTVEIKYydOklyDC5Ap+mJJqsZLteAlgNAJ82GtR5c3Kc97SIPQy0OA84wvhVMGU4QnJqBCJWihCkABElQkAJrSY0SjjRgT8JiDG4IlV4IJwfE+N0JKE7gJUfZ/PE2kvvLjyXEF5QaE2JPr2Fcx0wF9ZvIBnpKQSC5L8WI7aCH1p6WZEgLs3EMumLG1d0wGTX96+Ls/z4REfSdIGBhtEdIX7+mvhh+XgCWiJElCeNXSAyEcMn4NY1Oxzt67av7ZEInJd+O+LPF4GoR43JZ8/ZkCYpPHsCb4FYJXqYtJ1xr0Ww7jDGpfFG0J4iHe8IYn98LWmMrUtgP5cCqTwQUUoy6peMejnO+HJpa6MVHnnwNI3RHB5OWVtdQUmBNoa9g0OqqqFuTCq7lWWebigV0sZYH5TlQXIASyH58mIx92PIM6r5jHqlRhvr07BoAxn0yh5CCKzRHnhbn5PPtosy5FjUXvgL1hGnFDjj749j0O8zWltn5+YNMqVo8gxpDE7asG69/51woCIdtV77kSkvaMZgoLh3hRDJVeWoIscrpzpCFPF8Agj0NCzVKZIKFczBeZbTL8uQ/04iVIaUHqSn9SdlompKgGlUGwwSQJCQ0CsyMqm876Y2GGNptKXQBps1PlPCvSWFfj0o5QEx0u8Ra4gMSTjI8ty7EBDyTkJKIuxwSdMUeVpXCAaW8UmiDi7t1+TjFs8KQMbRCkZhtEcE50ibw28RAIb930WZR7d2EqA7wK0Vhttr/HpqiVy8X+vb3Z4YLS1xNAiSmXyJBgZunPDfUf4X56tDy+I8pZ+dW/7bmaVoSRQiJGrv9N8+o019mkBvU/0GvDvS3ba7BoBFXvg6i0KCFMxmU4yxKJmjdYV3SjQ0TcO1q5f57X/7i3z5936b5z/+Kd77oY8ihiexVcGukcgNRdmXjPqa/cMpGYrp3LGxnjOZNPTzhp2rl9i9+Q4bZ57mxKnjTOcLZJaRC0c1M+RSUR/uU/YFWX/FuyFLP6EyEJNcSa5fe5MGSzXeRbgGJbLwzhM3IUk7QiBErJ4RoJKwtGXY4jv218rWMc6/QBfKBoVIZA+uQk5ACylJcCrl1cLBOKZkTnZdUEjyb5Td8wWBCcWX6T+kqh6EnELhOWVHW5kyjDi82tnFp47aM9+nCIAoQh5I26mzwe5dM8abgK2wgILO+4Lor+SSFNVq7TqRv536vDHYY1nbJ3FBUIjRvyb1066ZoxrDKFm2gSQx4o6le7SmaJau62r+jn4HjhDjzkHXJSzLYKgrAcd+74D7Oi2Oq9NHIsZh7S2989bsmwh2h3h3HqbdcwGYRiBotE2EMmr/YsQo1psapfDvzVqL1l5Pn0zKQnAvV2EmwAnpc20Kv29V5iuBFIWiVxSsDHqc2Bp5IKIcg37GqVPHUEpy49YBW+srZEoxnS9otAExA2qftBflkzKLovXxDc8qMOAUEm9xEMpHgpqmQtcVdV1RLeY0deNLqYnCJ0+XMqRj8ebf9j3FJOl+rThfQsTvL13jXI5whsZoGuPIsoJekTPsl2AGDIqcWgA1WOOrNRltaBqfWkU6iwkl67KYbsk5wFtp/PL3Wk0b1CsuqBejlrjdP/7SxnmTmCUIejGQSEhUBlYopvOa4XCAOpwxW2jygzF57lPFOIcvcym9cO95mvR+gNqgqwVVXVNrg1QZKi/JeqXXLGrN5HAPYy3j8SFF0aPXK8kyn4LnQ/dwHRKWvwnBQQSab23IJ2utr1plSVWRomWCQM+stZGF0Q0IiTzR84IWxJF4QStYt+NpeeoPHHIAjnaJRrgAyBLTWaKvXd7r+4juIvG3ZVpMp+v2u0v+4UfbH0cLI2jtDGyJNkcw2cGvia8u9dQ+Wnq+KDF0fROjPiqNN7gpeZdgl/hReuZgjYjBLUISKr/cXbtrAGjjhEtJfzBgsLaGrWsm4zHzKiy0gHqtNSzmmsl0ym/92r/h29/6Gh/7iZ/kyQ98lFxuMa967B8omoWm12/Isj79IuPUiZLxXHJwYxfh9tB6xqCsGQ4zRkNBoy2DnmTRCEYjyXzhENN9NIpy0E8F5F2YVIlkPpmwv3+RwWgTi0KJCO7iW+vmZwtSb3zWuBCD/T7Z9YPp2JMxT6hseCkxard9obEyhGtfPKFfhPfLERFeBbAQQFeXU8fcY+lc5yOgvdtLR2xGpOeJfjB+d8l2HOGZIDpgB4YsQuLPAAJDMb0gH7swQj/6Zb+Se9es0ThjMEFLaWUrYcmwGb2PhR+Xl4YEQthgbhdg2iAQG7WDkHwchQg+fEKEknktQGvpQYfoBGAZrz9q/j0aNBJ3uYgEhvZ7d40kjncHKfC2FqXNdF4kkLejxuXVcod29OCdpPIO6HNLx7umadeRctv1LDp391G9NjAtm95jlHydc2RS4YxF6+j8TAKAQoUURfcQAUqlQoRpYKxC0S9zjq8N6Jc5WZFTZDnHNlcxTtMvfTLi4eo6o1EPI3JGwwEC0Dj6/SGN8eacTDVYBNp4rZYSFqUkpcioa0ORKXLltVRob6bFWrRxTOcNOzsHzCsYTxYM+n1kXiCkFw2jL6HXYmkardF1HYSqGnSNQHs/QwxKWHLlUNJiVYYwOYeTfW5ev87i1i7NfEE118yqmslc+3Jz1lIbr0HrKFXIlCAX3izbVzAqBIVwOC3Y2sw5d1yirUMby9x5ELhSKrbWSo6fWWHjkcc4fvYD6GqH/Yvf4eDqHgeHc/b3KxojmS00Rhuc1WhbsdM0KD2l2YH1tZLDmw3jhafvjXFMKktt/brJlK9pXGaSYSbpFR7gr/QyTh5f4czZ46yce5zh8CST8Q12L73BjfNv8c7enLpxzBqY1CCk4i/+jf/+nq1DD95siJLtBEQF8ICzCBNodij1Fq1E0WrU0j2IQXOxRQNCq6yAO1GMpIxYAotHz2lNv0vS6NLHCKq6V3Y0h5E+RtoQ+3KkjBZHaVoUO6EFs5EutSOjS56Wx+aODrI7RtGZryjchlOixi/Rwh80c6HrxFtaK2H0J5fhhhFsa61DoGN4dyIOM87RjwEA/vRf/ZvIvCCTfQb9ATs3r/LCl3+X/ctXqOpQk5K59xUM6QestUgpuXblMr/1a/+Gb339Kzz3sU/y6c99nn6vj3EZu3tzFIqNgePmdkW/b5mMF0znjsef/hjFSsbunibrZzSVpVdI5gvBbOEzw/cGkh4TRC9DyDwxPSElTb0A4bCzXShybl59jTNnn0qpYKKDcQQ2MhKsANaUa8GYQwRzbWBc4bqQAMFX+/DvIPFsC8mU1b59lyQ3lswGkWGHJetsMPV2tkbHNthVn3e6DT+3ph0ZJKvogxWBZDse2/ZPZ6wBRQsHWUjH0D5nWNyiO6Z707wE50GDDMmrCdKRFeCCOVdKP2CXSrd00h2EFoRRpLUhCKgNs5EqpkwIO1qKjg9a1EYETWMsw2MImpZAGIKfjRRyKZ1FAnyiA4U6INGvwSMQLRCVowKsi9JOB5DRGfeyRrAL/bqTsUyIjmDOzrmRwcR7L2sXl4+5zi8dE4iJpeBas3HU8Pj6zmBNMFVJgTVeoyRVa/b1HflgiuhvFq+5F01lWfILy7LcR40WPr1KbWE+1zS6wl64xaNPbDKbN5RljzfeOM90XlFVOpn7m6pivqjQug7WO0chYVDC5ork4QdXOPnoOWQOzY3LVNOG+bRiPG1oZg2H+w3TueXagaYyFmcNmRII4ciEZK6hagSZsEjlEyYLBOsDSZ5ZRoOczVHB+lBy+kSPIvNAcdjPOHVqxLkzm5x68Dj5+z4Boy8imlfQr/wir/7RG1y6vM+VyxNu7QrevlIzWwgWRrBovJ/SrIYmmMkHuSOTgrW+4NhIcWotY7YwvHKl4mc+cIyPf+wY+wcLDg5m1JV/36NRzomtIeceO0PvfT8Nq38B9Ku4N2fceO11Ll4WXLvaMF04DvYM84kPzKlri9CWfpEhhGMxdxjdcKKfc/r4gINxzYVbDXtzXw+3JySrueT4Ws5K6TixXoKQbJ4Y8J5nTvLoxz9M9sRfBHEK6u+hv/8bvPvyO7x5fodbuw37B479qcGKe1sLWEiR6EQsn2iDqT4Gv1lng2+lCEEhgdZIv588yU+e6XfEb11wFptbEgo7QKdDs7q0zR9og0+We4z8seugRKKVieXEdGVLgmQEly0H7crIUX2RfokAMgrhadwk4JUQbRpk93P7sWsKTpG98VTRDhlEus/SHIaeUhe3KVVaHt+tliSlt0nGBOvWOh8QJL3bk7XL9/nj2l0DwOc++79jsn2VvXde4/pbL/K1r36dK5cvYG2TULWXPGBu5oAgy7x5QesGrTXz+UW2b9zk21//Kj/xU5/n6Q8+z3A45Ob2nFIarOoxW2SQr2HEHFRONasoyhnUPYyumdSS1VHBrJL0MsPhbkN5osfupTFbDz3kDQsSmnrOre0L9IYlh/s3cc5yvNpDOBPyIbV6sjTdMd1CAIciLsqUvV4sXeMXgW1TyogocXjkrkR7TlpeImofo5kyMNWoTXLxd7wEF33ZulG3aZGFYA7RLpoE/IRfMDEZdWeP3SF1SxcQuGBudikFg//VkkUg6W8e9sYdKMaPsUX/h+jFKcJz+lcQ/R/CRlLeQR5HkJ5EK63eBsQ65t1kbvLz73Gm9+OMvrAJ/HX+eqd5G/xrCGYmlQQhF5Igi9aDviWQLkIml74vTW9XaG3FEP8MR4hYZ7aOgF5x5G/8JtIebv1kuvdbvr4LG5fv2ZGyrV2ioRFsI0HFOqu0RA/n0FojCP5v1tI0JmgCHXVlAwiUKc2PsCKlBZLi3nngrxQLFnNNU8F8ajDGpye6BpjgMJIpwfUb11g/tsn+ZMLGyoDp3lVme9uM+hl5Br1cMVgRFOuOqvamnGOrirW1nNNn+jz68DqPf/hDlE/8NYSo0K//U/bfucDbF3a4fNWwvQ3XdwzGGlZ6hkL7PaCdoNZeJ6IkFLmvIJDJ1g/TOBDGIZ3l2NBybCtnbRWa2tIfZkhhqWxD43w9X9GALx7ZR9eW2axif3/O7m7F5e0F+3PHtLIY62hCJpHKOqwB47y2tpc7etrXR97Lra/FWzm0dYwP51w4v8/+vkZKGK3mqAz/HI1BYnDUODvDzvaYThfs7S3Y2XXsHzQcTgyHU8P+3DJZOKrGIQ493a1NTakkWyuwXmumdUNWSOTCB98stNc8FxkIm7GXNZS5YLUpKAuJGvZDSpxDmG+z2LvF7t6E2cQyO9TsHtTszx1ze29pod/bIW+m8uZsbQI9CGmEVMj9JxEhoMgtmW0jPaOTKD/2nmgbXXASzomkJ/KkJXp2hHYs0R93++FIhzvfu5aR9lkj/YnI7Y+b7zsA0SNniCVKdvt9ktYxXt0FgGFeuj56SxabI9WPImg9KqhHut+xAZLUPq7lRUJ1EIf1gp53EwlOYcZibEuT77bdNdV848u/zf7Vt3nl+9/jwoVLLBZjSmkRCirtKAqJ0aCdC1oYvAOyciFIxAIa3dTU8zG/9r9e5Dtf/V0+8smf5PTTz1MvasphSY7j3Lkhtukz6AnyrGA0yqhrzbFMYWXOoJ9hjGQ47DGZVigpOTQLhGkQOYgQNTfdvkFd7VBmhvl8h8Ptt6nPPM5guHn70hEugYlomhMdTZmPxvUpDwSiE3Dhjkx4UM3iQp49B6Jrig1nhajGKJm0+QY7Nv4wrqgtiBmZ299dcL72gBPCKanSSbthfB/tKkxKo3ReCwIj+LVW+3coQKk8gSAR+4QfbrX9CJoLTupxXo0F6bzvUYJQAYwJRDCVh3lYpj/+XBvAdUo2GoQZHCr4Uhht2v7wpaNkiLQD0v1siKa0wW/N4dPWSOGj8bxvhiBFWLsoucfD/p4uOPzHvn27E/H0gkk8ZVmSXNYW3tGEu0T/uvfx3yMojsC4qzhO5O0O798F5hNPjhKpCM/of/LuD53OvLDY+Bx2eZ5hjaExlrKX45ylaayvfiD8MxprvCZCOG/GvEftr39yxLUbU3YPGiYz2JkYrk8cCwPaWBrrcE6iG029qNjfO+DY2kmkVCxqi3U+1UiRGWY5lJmgMZaVQlBmElNrrNZYY8jcgqyoEXIVekOmVcOt/Tk3bizY3mm4sW/ZHWsmCziovOCHkGjjzb0ifBc+kBcpvZlPW02pBLlsOJxIVocZzuRMDhq0sahM4liwNppyrKro6QW4KVS7LMZTDqc1N7crLt1ccGuiqbWj0t7y0BiHdlCHfHTGWZzxa3Vv6rnUtDYoHNrCte056nsV339zgtGw0pdsrjcIN2BlWHE4ntKb76N6V2F+jfnBPrf2ZxwcVIwParZvLTicOyoNs8oyqyyN8XmstfN/beHYnTl6O3MOpppZ46gqi0HQy/0SnNaGfiGpG0OWZRhgOms4vHGDsnwZlSnE5ReZHYxR0rAyhKZR1EbhnIH6ni1BgI5VgSAgBikx4hXhvwvhqyT51nGvwAXfwODxHvc6oa+gxvL8RiaTa0yfdmeQ1/IVz3e6Py9bF5JJOPUhlr92AeARoLV8JksAK0G2zjURPt2pLfXVHUP6LNKgu6bsLg8VaRD+r2sZeri8OxFeCxOvTaqoQBe9wqKjlLAtTZfCC8gmHIt+u4JgIQnv+27bXQPAF770W1y6cIHJ/g4KSz8kjHRkPlO69VFgzomQQd5hlfJSvfSl3SI4klIgTM3OlTf5vV96hwce+yM++unP8sxzQ3a2x+zfOOTwxjaTSc3qADbOfoSy6EGM5kKQCUkjHOgDsixntTdgfLDL6vFjCOcoMsXq2gbf/tpXmI8PGK6uMtl9i9nBBxkO1tvoW6LupAPowksS0EnTFVTr/smCVjDG6HoNniCYJDtvPkXcxkUR37rrhmuHFeQ8qJEd54YIOlznfl1tZFJ/C3Ah35JzLvn4+Y3QPqE/34bAjuBvcMRPy+F44+XvcHjrGsJUqNEaJ08/hJIwHG4yWF3z4/hPCWE/hmadxenGP7UItZbxgS9KuOD/55meRSBNjLZWgfgIpFIJ7kgpiHmZuqYQpRRNo9Nxa7XX4ukQpCDskuavm5xYSuFTb2Txnj4S1DQmVa7w95YpfNFbjCWN9UEtmEhoo8Sw5OG35GsX31k0E7gYHEEroXej4ej0E2+e2EPQjHaZRNooHRDqq3XI1Euci9ZPNeSyw1P8bsWPeB5xrLEXB0rKDgjMcc7R1NqnTTHO162VAmuET2CsvAajWznkx90Oxgu292t2DjTz2nBYwVzDrBEe+IX51miqWrO9s8vD504yGAzZnzvyWpBJQ64cZe7oZwCWUmYMBipkHbAs6obq8ICy2sYVGUZbxpOK/Z2G7Z2amwea6cxr3UyYd23xgMvGQBqRonGN82UdM2kxOAyCSkt2Jg0Gx/60RjqHPBBsrJf0M8FsOmNyuM/K3kWc+x0m51/k6oUrTA+nNIsa4Sw5oIWjJx3aectB7hw9Ff2ZZJunEziY+/dtnKPMBN97a8I7FyXGel/BxkJlHLO6Ym/fcONmw0Pb/5aTp/+AQhrOv7XNO+/MuXq14eauYXfqg1+r2rGofSoUJUJSZAdSOrCOReV458aC2obgLOnrys+NYG4c4xp2FprBgaVfNLxxs+Hbbxxy4vfPc2rr9zi+lXN8s0RlOQf7FTdv1tzY04ynDXtzx7i+d8nIIQhaNoi9VqcAOE8CPZ2PoMsJk7RFxrapr0wIWIR277sIUFwbCJdcSjpA63bhtO0nnB2JQwKUgtZKFRURSbPnXMc6FV2hItjqoM2u60x7OjFV6rIgfHv7wUCw8ymCOtGdm/AstAqUhOc6dLJrqYkkNuZxTWA9/t491UUcAc74dxWtiyJ0bB2YpmmteiH2Iubz/WF98u8aAL718rcRxpC7NiGtxUeQOutzXTkLTqngBE/yf/IPLok6mnljWAiYG0FPGZrXX2Lnyrt891tPcfWtN3BOg5CsPvQBzPZl/vB3f5OP/exf5tGn30OR99F5Dson4GwmY8RwRDZYYW1zECbfoqs5t25cYzadMzmY0R/02blVsTLaCJKRxadTEJ1F49LbiS/oqJq4BV8uJEDtagFNpx866LHzNQk1UQLoBqREqandWPHcVJc3HhUdqUaEd7GUYLIFhjE1iEAk0zAODwSjaj8sKIejrqb8+r/651y7fIWNEydZffRhzu3v8d6z57B1g8wE/eFKe/972CLA81MffFqc8EXno1kXi3Z+/akAuKQK9UGlRBuTQvyNaSVfIbxmMWrsHKS8bO3+l8GZPmhcZYhEdj76Kiq+hJQ0ukFJ5f0LuxF26XM0NYdnCxrEuJFbSTZc6M/y40hCQzgsWqnxSK6WztzRueD2tiRxd/5/9CPOazZ1rRMhSms1AsfgqyekCOlFoqncpydJIkf4LUZjKynJ8hzdNFTzBSrzOS2aOmpQnY+Udf4d4SRSKYy8dxrAty7PuHKrYVxZKgOzyjHRUBsJoTIDzqKNoNKG8WSOkooHz2zy3e855o0jl15rWTWOKoOVHKYLzWvvTjl7LOfRB/tsDBWqPmD7a/+I7b0JV9++ycV351y4POfGbs3BHGa1By6N9U4RmXJYJ8ky7++bKUsuBdoKFsannVrJvWtODGK5eWjZntT0lKOfC0alRFjHoIT9HcHV7Cb98mUsL3Hxwk3OXxxz7dKC2cz7Mlq8SVkqSe5ciPb1ICu5qQmF10w6auM1lbmADINxGdoJBoWkyCSF8omkrYFZBft7muzCPis5yJXc5wJ13rFGKcWwhLrxgQ/KOmxtsaiYJxoV5oWQCWBF+OfW1rvY+8QWPsdgmUkGpWJQSAaFYqVUrA4LtrYGPHh2lZMPbVGNKw4nOwwGgv7C12dusFhxb0uBWOOjrL3fVwiCsC4JWxEAYh1OipBb0rtOECxa1vhgyWU0FahE4IO+mEhEL11CEIlF6zbUpUctqQn8KgJBlmlai1laHtgqYkR768QPo9rjKAhbHn/MqtG60SRYeuS+8fpli0a0fBx9hq6vtuikSouAN/URhXbXPbg0MZ3Rxkti+jITQKbPdxkvl6rlV9ZqvN4h+EP7/PJkP4Qr6l0DQKGbhI8AtBPoxuGUfyjnCAERYTBh56egAyRgQsZ3D08a6/uZactMj6le/S5Oa0TRo7d6jMP9XZ5+6n2cf+N7/Prf+x859+CTPPL+j7N2+nFOnthgZbVH5jRFr4SwYGRQi5ZFiXCWne1dqikcP6YYjPrU1YKVkX9ZIrwcIdolFf95cCbA2XaRATiBcIZqMvF+LaOR9w/B0cKsLoCMl4l2/kRn4SQJwaWI4iUQietoGv0WkInptupjge/TujZ1QsvvXag24jqbxXXGF9+Jv05XC6pFRdNoFnXNqhI46Y/fnGwjpKXXexAlyuVNdA+a0QbXaBzS+7S4WM9U4IIPjrUmOMoGP8EAnq21YINfZegvOkQLJ5LZ1dhQ1SMmUhUCY6JJ2NKYkBhWhd+lTyVhtEm52qy1Pm1EzHtHMEs7sGhiZRFo83LlZZk0WWKJ2KZFkoCT/96CedeesCT5dn3tlsjOkt04SOa0az8R6I7knlogQFmWpfta6zBGY01MR+AXlEla1KCxw4VgBN+3yH3gljU+QbK1BmugLAqvCexEyeP8nOIcjfHR9da5cM29Y75feaui1qCNoLZtlY7Wj7T1p7KNoa41WZ7x1CMn+eZqsDcqidGWw1nFvDI0GqpGYkxDqeD1Nw4Q0rGykjOf11y6cMD2jQXTaYM2Hvj0C0uZC4rcMddes1Nr7+/XU4JctXlGtRX0nQAkZS5T7rdM+TWVSa8pVKFaiBaePqs8ozcYsLJxDCsMxY0JjRnTOG/itaEEXCwr5APhJUr4zzHYIO4Xh6BqfPJ9Jb0Lx6BXMiphpYS1oTenqkyxuZ6xupVzbGvA5nrBA6c2kFJyc7ci7ynW1kryzLBYNOwf+nEvrGbWeKZphUApRyGDCVT41GCl8rR2EfwTlZDkCvJMMigkKz3FsMwYDSWb6wWnTg04e3bEgw8do78+5OZ4Tl5m9AeWwdSyqAV9a7A/RPTlj6w5aJPABa1dALjR/1tlnpZ0d3F0V/Emxq7rU+vaE7X5XnAOvoCh2oQvjrKs8Yw0UwQ1V/oeuZeIlKYFTYkfdsYmRHt8GZW6NhFziwrvINImaX2ZP3W/dDFZ+EkISRaUBF2gF7tbvo9LFqXbbp1oLp2buCVa3AWHLjLfJNz7fmW0KAnVKSRA8gFUKsc6bwEQUVMqf7g1ePee02GNOfym0dr5+o/RahZt2viISp+oV6CUZ4bWxEDt9JyeaQeUe+igmTueeexJLlzd5dL56yAUV26Mec8HP0395u9w/q3vcPXt7/Ghj36Uw0c+zpNPP8qHPvAwh1pz2CgaGxaaFAgH6xsbFJlkuDFiMFBIcYhppijXmlEjS5VAU1Xkpa9GkqJ3Yni5x4I4a3nrD7/BK7/x7xHW8vwXv8gDP/FxZKaS5OKv7GwqF7R6MeFSYKzRmy5ujvgnLoIEyuKExY1F4sutZsqJdovHhMZHVOBeIwsRZkYQuPRSEDTVnEY3WBGSUucwmx0yLXMObl1FIRmurrCxegrhjmyAH3ez1pd9En79pTp1cfRCIKVqg1/Az3VI0eKFkmgCav0sIrgmquGD2VKGyKrkD2hMCizR2oTjLcFz1iXQUteNr54TNq81BkSs9uA3k9ca+vKKumlCJOwR0bT77bZ3GtfZsjARpcYE+5b+3E4yoUss4+e43joElZYxxHO75o94mTVRQ9o+qwqAuqkbWgofmIzwvo/W+NQktRAUed5WHtK+8pAKgWU4n4zXZ7mVSxnzf9xNCkmmfAlBaT3wcs6DDJUJCunNrM5apG08qCtysnLEWGcYo33qEWfpZ1BmOYMSeoVifUWxuVlw7MSQk6dPsHX6AQSa2l5G5WOyckFtFixMTVE4ylywPdaYuUNrUApyCb1MUuRQB7+8XAm0E1gnyEOkrxOCIpdkygNzYwQKyaAnyTMfzT6vvB+m0b50XF3VZBKUkBS5osi8NrMRFhNpZKz9ERIQE8CgT9buyDKLdG1WBaWgLARCwaL2gUDCGMZTGK56IaooM7JMMp/Nmc0qBCTtYmMstfapcDQ+T2OeCSrrE4oLKVKVBGMtRvmkzwjh04IJH7STK1+fvci8NUAgKZSi31OUpSJTEj1ZMJloFpWhqjV107CofeDJtLm3JmAZK3gIgRKqNSF2rG44r3zIQr3yYB/upH7xoCFZD0RLQxM9CbzJESbXX5VoQEsPWlDklgTRwAmTuaOTYLlD6paxmlgSPFPkLkdwXOSZ8TeO/CaW6d9SP937pWtcAmh+7iJtE0vXi6BhSRk2Iq11iUN3oG54X4H/iI4vf/ek5D4T8hi3IN7jjuiP351XISRKQXR5sm4ZTP+n2t3XAgYMXuIzhqBt8RId1tKx+iMyFbKtQ21jMWrvI5dMeJ2ghOSAmvW5dHPC3sEkTLhEVxVVY+id+zj1+d9nc8PSWzWsrvT42Iceo18WrFjNcVtzY6I4qAVNramc4tjWJmdOH8fZHZSwjNZOsrayijUVSrWPLlLdTRdrbaQX4+JLt4A1vPHlL/Pb/99/SmENvSznm7/0v/KxTPLgJz4anK47GyvMnAf3kdmFY8HfQUSU12HsvnZi3CxtTVVjfTCNkooiz8PiDwAoOPzKdM8WjMJRpt1qAtu32/qJzWdTjPFM2jp8xnuVU81nmGrG5Xdf4eSJ04jVk3e7fH5kLcLrWF8yrqC0hsJ5MTu+DKkZJCSO0XV2jk2IlikGqJhMxjhvXlfKl5uLTQVi69Xx1peaSknDBUq1MEcI0QoJEYyGsQspybLMVyDo+Hd0tW+t31xnLjqS5BKxXQJ+XUnzj2tRNg9QOKzNyGDiGXeauzjGlGg2pMHxyeH9uov1KZX082eMB3RGa2xIyptnGUWe+9+1pqorwEdyF3lOXVc0VU2syx3rgAvn7qkP4OkVy7RRaOv19o1xzDQo6chzQS6hlBJrHbqeIthgXs1xMkcHdwXwOS0HmQtmWw8gfcUTwaJquHFrn5O7fY4fX2XYz8lzv9KN8UvDOMts4dLa0Db4bkroFUH7IyRKWAwgDBQyWGqc9xGz4f0ZA3WjMfi0MXVjqBaaxUJRVzW2qXHOoK1hPjdUjQYsmXQpcX3UYviAAb+OfDlMv7IyoVhYn9TWOq+ZkyiffssFAJt5MJ9nPoJ4sXDMZ9qbd4scN6uoKktVWxYLy3RmmC5g0fF5FMrXyZUOylyipAgl+wKDtgIToioF3u8wyzzoVUJ4EJhLisIXLJDSkSmJkpLdvTE3b03ZP6iZTg3zWrDQPuK5svdeA+j3etcM3AKY5Pfrwn5TikwpVJYRKZMKNCkVBsAHEuhG09aa7fqQx0u7gCiORqRBJVoTNf130pSlh+icepvA2dKgJTAYweptE9JVmogOj7j9vKND8sNqQbCgBYtpSLeBVhGnONHpdIsIIoNA3j5rR+mS3LPimARBieu5XFRYhPGqkAXB2FAtLPgANtp4RbBsed7dtLsGgL4QeUug0gOItCzaBxdt4AIQ1JauM5cRGvlv8XNVVdTVXsjwnrG+eYzPff7Pcu6Rp3j93V0u3XiBxx4fMOs9x+c//ATDfj/0Yenn8KByXLh8A1tu8EeLNW5++0VGpaQx65jmAFMdcvGtFzn32IdZGW22VrAwrizPkgq9faPxi+PyO2/yu7/4C+hmDkKiG4sdH/LGV7/K6Q+8l2ywEuaidYbvVtyIT9/ZP+H+XWlBBEjsNTvWGL7yR19jd7KPKBSiyBgUJcfXjvHI6XOsDVa9n1lQzUfTW1K7t7f1dT2hkxG9kyYkOP0uqgX7OzfZGvYo7RAEDOqaLWfpWyjWN7h18yrb1y9x4uRD5HnvbpfQj6T55KcuOJUTXA8EiFAGTrSBMF51l8iGf7c+uzV0tX7SgxYrbSKaKpRKMo1GBWd2o3VKQ6KkREqF0d4PLs9zmqYJwE9hgpnYm04crmmTrEazchaCRGLOTBE05h0LP4B3qcCltZh8VcICjknaoSuFBjLYAYaJYsZDgdDJMGfR3JPK4LF8bgTCzkSfFP+j7ABYb6IJK1mI9j3gExBXxpHlWQJveZ77CkK114BmSqCkZ1RZCCIz4Z9/rx5UekFSYsCP5x6m4GhsqKoR5loJn7C5FeY8GHFCMa9qNqXk+tUdsqxsn8EQ/G5lcIWBvLHkuWTRWOoG6toym1cICf1+7jVTWLLcA6SF7gh8QeOrgQJBE6pDRC2QnzPhI5SDj4hwAq2tL0lnoWp8opdZ5RhUOVJ6baFzDt00COkDcpra4rSjaSzG+TQuTaAnMdgvZV9z+FSdEhprPdDUcVH5VFnaOuaV1xAKPKDUBrR26MZRNxZrBXVtORgvmE4N1cwDxsZA00iwBiWglAItLJmSZJklU14rkgVaZxHk+OT3BrwAF0C5NpZCZmjjWDQWOdccHPigo8FgzqA34eq1A27tzzk4rNnZM+yMLZMaKmOpm3u3BsHT8VgbVtBG2Frb1kLvWhpwJGDnNen+O4Fexgh9F4TSFGiWNH1tSYBWsOwAMtp9n/QXUQMbLV4JI3ZAUdIetvQtWrMiHaOjMHGd67qsOgK+8GO4D0RY2WHCiXe039uxtfikE6iZ8vy5xF+XniX23gG/XQvUkjWq+w7p/tb5d2QcsciB93+Oc9rGY7QKI3fHaic/qN09ADQCE3MMcQRRu9Z/LS46PwY/6eLoMdF9FW1/xhmE9bBESMfxE6e4duOAN9/5j5hsi821gmLjcZ5936M8+vBpsiwP7yXDmYYsszx89iRXdqZsv/kmzWJGITRZoZnOFsymlsPdqzQPTGC43koUCbbFNCrLzxaX94tf+RJXb1xjlOVovManLDLGuzeZ7++y0ZO4xQGFsOzt7THaPAmDTbTteD646GvRMtF2EXsgE7XWVT3lD7/zTb7x8neZVnOUlGxsrDHa2uDm+Bbnb57n0a3TPDxaZ354iLOWE2dOA5KqanC2wTnDvDJMpnPG4ykH+3vgNAKf6qFeWFTeI88zmrqino/Z3b7Bxz74FEZbprOaPFOcoGE2mTGtDkHX3Lp4hfP5S6xvbgGfuttl9CduxjrQxpfoE1lwQicQP4kQFpfemfB+eUIgZUi9IgQIE0wcrtVoiWX/F9Op6mGMV723nwWL+RwhJUWeI4RgsVi05lztg0yaplny3UjBHzgaramqKoAnlUzMRyXISFoSoA+/S8BJb3KOCV2Xo4b9n24Kl7jGoiNxK1V3CKd1GHT4csSYIIK/opKJ3nsab6nrOkUhS9EyiRiha0OKG5ylaer0frTzQLksCg90rcU5X+4tzo0LNYWtMeFZHbqxPlBH+vHcSZr/cbVZbfARBv59awepDnMUwqRDWUc1WwCOK9du8dQTZ+kXgrqyHggLyC0UobyTDsF0TW1oGk1Taw4PJzR6g9GoR3+g6PW8Zkq4Bqu9FtBaf20d3CArYWm0XzGZd5mksVAb6828EpwIqY0kqLmvz1tVvnrEZCEY1zC3jt2p5mDi2N71gU5vn9/n+nbN7n7N3sQwrgzzytJEFyBf/xIL5MJHG4M3uUrReE2Va2v3OuEYZAYlBYV09DNBnglWejn1wgPlauo4uHWTV17apTaC+cLR6AIpHBsrfU5sej8zrQ31vKKpNFg/L73S+/Y55zWGO2NNo70WslLevK2dwywsNWCVZDKO+fEcFy57zWzvW1cY9ATCKYyVwe9TMqktOzMd5vjuGe+PpAV6IqXwuW2t3xMyVP0QBDDmWm2SUD45dNPo5JcZW7R4RCxhQ4J7IPnuR1evxLPiXo9DimDQS+ZeSI4+2VKmDAWic35XxvzBz3qEGt2JdgXhvev2IoKGI/HX7t9ud0f77JjEl0YXxxG/LtHbSK07oLWjjU0Yja7ATguO0982aFAK5cF7AOfR79xa4wsNhD4yPM1xkLIz3E37oQBgN4u3w7VmoqWHBiEU7RaPDxon1HV+a7G7/+oQ0ueMsgbeefP7XLrwJnmeU/TXOHMGVP8kH/noe8jLFW+uk95Oro1GqIwsAzu7yvz7v8+ld1/j+OlNhpnl+OopiixjtezR0xX1zkWaRtMbDJjPGwbDHoiMmTYMB4PgW6RomobFfA7A+bdep7YabTOsdEgcuZ6zvXeF//BP/h7PvP9pHn3vQ9zYvcn3X3mbZ559P+95/wfIVzaprGK2qLhy9aZ32sRHAU4nUwaDPsdOnKTf72MaTW00l69e5ve//mWuzw6opcA0DarXY293nwbL6sYa1mleeOPb/PaXv0MGnD6+yUOPnEPmGdWipq4brly5xsmTx+j1SjCaGzd3Ga6uMhr2mGvLze1tDg9mCFWgBezv7lM1Db0iZ3PzOJPpAWujEfNG0isFt27d5NjWCq4a852v/0ceefyJu15sP4rWan984I3fXyF1Ssr5F9aVtaEQvEBIkwCgB4omLT0fydshL0L4SLko3YadK2Vr3i3LEmMtVVUlR+dYYi5pwKRKfn+xioWSiizPKIt8SQKFYILGBc1Nh7jQkaBTQvAgPcqOpu0ICe2agoOQ3ckebxNx8oEUrSQquK2rTqctMG0dpeMNWP4cnsHVXqtujEQI6aOAY9QigHXUeEbmTR748mYOhPS+gMYYjNEoJVBZhlMumZHvtR/qoMhAwEI7ahv9yAS1i76YlgxBPxfkdsZ8UbF/eMhwWLI5GjEQml6hKPKQVsNZ5nUN1jFZOOa3aq4eal65PGf4/QmnXxhTV5pLV2Zc36k4mFrGc8us8e4ZNgC8JuT+i1mA/FsyRO1xYuzR7BTWRHxPMSuC5/OanlhQSoeSexTEyFmfvsU4UuJZ30I1ncAjHBIZKh35GuahbB6kBPmEOZO5o5AOkQkyJwBF1Wimc//+F5VF7Pl3LLPMpwFyXmtZ5oqtPGNRG6YLR1M1NLXXkhhj6FlJroI7Uu2Ya181wces+PyLJmi/IOQs9E+TYIMUkryWZDNHmRmUtPQyHxA2wKJyb424tzHA+Gho5c3tUkkMPkAw0o0IAyRRs+/Xaa68mwWuE5BFC96WNVid7+l4+CBabVykk0tCNV4bGd06nHWIrJM66gc+WVdTd+QsEQFf66aS+op4JGksXfrbdQ9aovXpPvGn5blofSW75mSREHA81gWAuKjZi1+6z+NSXy2SbrETYe+K9F+8PNy/E7yT3of1uZa9IByLIdxdu/so4NuEG+El4KSd8CDPCUl7+zu8SOfP8SAwagc7vQqBL3jusLpGFpkPzzf7nD6eMd67xWsvv84zzz7L2sYmQrQpJKKa9uy5Mzy1KWgO1+i/57P0zYTJxa8iqn166+c4PJxx49oVXn/lezz26GOM1laROL770ss89MhjPPzoYxS9HmXZI1eK0jZILM998D2cf/1VbjUTVvpDDqZjdoDVRUmtF8x2trl55TKDs6cwCLZvXES9MOXUubPkgyGvvPw2b71zgzOPPMHqygChJJNbN6kkNLvXOXvuDBffPc87V6/y+9/6LvsHB6w/8SBNKHpelEG7YB2LusI5nyRXnt1i/tZFXn7tJi+/8SZaaxYLjdZNq9Z3XgrT2nD81Gnm0wmj0ZDnP/Q8jz37ER5+4imqes6X/7ffY7g24ku/97uce+gcu7s7qHW4cuUia6M+zi2YzeD4iS1WXMkDjzx+14vtR9FSwECHyES/iSgN0TEvtKYGL3x4/ySLT9nYJUNdwtHJkA9J1d7Vzk3rGqlUG9ARdqpubBsJp3UiWMYGBmo0dVOT5zl5IIxRleZ9mNKTJvNNV1xMufZopcfYrDVobZbTrCRwZxONSqaNlqIdAW5HyOMStRYpeWwkSCbmUUSk5z1KJL2GRidw25WQIzE02muOZNCIqVDntg6+gCkgpG5AtP6Y3nx17xzwLx+AzzLi80lK4UFNnglK5ciVY7VwPHZiwHCQcamp2T04ZDo+4MmH1tgaDekNeqAk00nN7t6MKzcP2duvmFaa+URTG0OlBfuzmvHiMDCFwFgS1fXg089BiIjGm9LaEK/4PloaHs3X0dmcuH6hNXHFqFnn6OM4FoJUzp3q8e6NmqsH3iRvaIGPszHq2CGFSXOTC+9CJGM+UuHf8cZAIZxFCuf97pSjn0tUBlWj2a0a9idAyBbhtfsCY72fWuMEZSZ43yMDtncXXNu3KQl1LICmpI+KLjuarTyDfiZZNIZ5490WpBAI58tJ2uApEvdDpqBvoVH+GQeFRBrIhc/hmGfKP/M99EONTfjyVWE1eCE1st34vD4vLGmfW2OTRi6pcDp7vjUnitYDKoItB90gw66511nrc6wGuuXiePC/+7yoHSHzBz9VSyOWjvrmhWRLo02nvN3RefGBLCoA3OgiFWm5iMqj4O4SQReyrRMfUUvHK3GZfoaropDTWmnCGLrYL+w5ax3dXMFt0El7OAI/gQxpzEhCrk96b7HWpyZzgYRba0PwoUL+EHlg/kT1kyIYSYYtgTdLRYoTUW264Hbc3QV/nmA5pMxw1pIXijPHNjlz8hiT/X1Wh1POHx7wG7/y6/zWv/13vOe5j/Dpz36as2e2UlCHNQalMh568lHmkzFNdQvd22TflRh9iMthe3+HL33lq5hqxu645uFHH2N9fcTmidOsb55k69xjrWrc+SLmQgqe/sBHePDFl3jj9TfYr+c4fF3Q2jgWC0utFmy/eYHdd6/ysZ/+KYZyTJlpdq9e4MKV60xnmo/8xBcZHT9OWfR46/w7PPzokzz7zON877vf56f+7M/wnZe+x84ffI1bN37Ha5gmU+/wKSX7kwm90QDXNAytxZYFtsx56OxZjIU/+taLWOcd7csMyjxHiIzpbIpzGb2yoNaamzd3+a//67/Fxz/xHONxw/ufex6EZjaZ88KXvsJ4b4+/+3f/L5w+dYKDgyn/6l/9Aq+//hbvfc97ePLxZ/n4pz7MCy++yNlzm/SHa3+SJfRDNxMLoBOSOHuShiBE/wqBDTZhKWI1EJfMH36dRWf5sMlTSpbAZuXyZl52dA7MIqV48dK1sTYIIrIDPkmEQgSAKIK5UxvDYj73KYQiQ4akzetWAyGagpNJOB5utXmpQDgkTWU0wdIFy7L93O2v1SLegUAnibsFxFZ7MO3NSC3RDxMcAAZtRZNYSk9435WUYiIS53AbpSTO2GROd9ZSFBnWOuq69lRVCnRT02iPOGSmOBoN/uNs08aiNMGs6YM/CBpeowW5duQIru7OWKn6vH54jUY7moPrTCeHvO28w5u1jqo2LGY1dVWh62CStF7TLS2sZzAcePAknAdbfpVaciVY63vAcmvqqEyrUQSHtgqTXouPzY1CQwKHMXE6njwH99jg1+gDIvoKhjms9CTHRxn7B5obB57exxroEjBh0UQwEl4VMgBAhY+yDSeBNazkMZ0MZLmkyAS19qmAjHE0xO0kycD7Gjqf1NriNXXTuUU30DSWxnkAbIXzCbBtBKmWXEoPNAUs6pqqCTULhEDH4L94P+GZrxSCnlJkGWRCUOaSYanoYVHOUqqQ6zCBlnvbYhaAqNmPWzjsOqJGzFhfpBDZqbltbdKmJmAWzYpdgTe4OiS/Yt81iCOARwpME5Pqiw5N8TSp0XGtRYBJK3QuPxVJZdT5IYLM2ISUKJW1wmZ7laeLznofx3AbGfJA+ju41mUlJasEZ/zaA5FoZavx7MCaCKyXhOZ23NFdp/WtbM2+t6+TYEmJUfPOS80xsEp2xiGlJFMZxhqMjatWIFXLc9zR7v+YdvcAMErzdJC4ECGwoF1oSXPRPi4Q/K84OlnBQyQwWOGCw67KWdt4lMc/+Cne+/73s7VacuH1FzHqjxCTgtlkxmKx4J/+0/+FX/ylf8/n/swn+cIXPs2TTzyEyjIy4Th+YovXJWS753l9+2UuXX6XtbUBh7NXeeWld5hMDslUhlLb3Lx+lc//9Bd58ZsvcOnttykHQx568mmivI3zTuZaW5585v2cf/s8pqkRQjCrawopqXslB9owsJr1ssc73/sOn/j8F+iXMxaTHR546HGOn32KrDdi/dgWKiuQ9mFObK1S5AW9Xo+yN+SDzz3P3//H/xjyBjVrqMdj5GBAURRJutdVhZnO6Tt4//AYw0zybnaNrY0NPv6Jj/Hwww/wG//u3zOfVzgkp08eB5mhjWX/YMpPfegj/PX/6q+xv7/L1pZkZdDjYG/M2uoKH3j/M1y9us3P/Myf4/iJLb76la/yxhtvMZ/PuXjpEqdOnWJ/f8F3X/hDzj3xBC9ceJP/03/1X/4QS+5P1oy20GjopClAqJAF3vpEwkr6xM/4XHVLNS6lV5O3kKPdMKKTTiSmd/GmsijpRV9WRxZAT+ylyDO6IMlaD2IEMUK4lcpi0EeM+vUStEtg1YVcbF1H6ZbokoBbIjlSkuVZiMJtaxUvae46QKDViN7eZ2odyawFn22OPxHqu2rdBOIVJNUuI0zjcKnPtN+d7dCJ9nfdNJRF4d+Dc77skfb5Q4sixxiNcTZoTw1N6ueHIXt/sqaaxlO1DhNsED5LgvBRwHbhOBgrjj31Xk49dIonTg9456VvcGtieefSLVTU2khLISCXjkz4HATWujRlSgiEdMTaNTHVPM5XXzKNv59CkAuvzTIA1if+tYli+5QorZkyvgNogT2hxKUHa0r6yNkmvCYlLNf2GxYhJawNa8oFYGpdMDuKdn3acCtJC5il9H1b46ikJFdeG7lawqAUTJ0HhAa8ect5AGxFZOwEjb9BI7l6a47W3mXA2iDwBOkrE5JCClZ7kmERc4c6dqckZmZc+wwxq5kkgCvh7+OsxCkf3OOr0hik88/SKxVFJo56Pf34W9fKEXP5iQg+2o0vBCGQzYO3mKJJ+SSQvqRiuKbN5dyCNxuD0MLas5FWxXFE7Zdpzb8xiXMKfNOmRT7pJkf2bEcT3UK58C30q5QKuSXVUh1e1+lvSeju0JcERoNQTABnyR1GtPfpPn/XT9xfLzugsQO8030CTHbx2s4zLD0jgRy79Dn+izlj0yyEtSWVTJki8izzFX2spw+xrKlUdy8M370JuMW1qXqGQyA7S8Egliainfz2rBb8eT/B1grlM/oX+YCi2ALZ563vv8z1y7scP/0Ep859lKvqeXbMa1hzAaH2mC5uMZ5t8wu/8Cv8wR98jb/4c3+Ov/BzP83qsGAwGrEyLJnPKqrtS7zz5nlklvl8fyGPwtpok97KiJ/54s/w6//ml5kdHuLqCd/+xlc4c+4hsqLwSWZDotnxbM5PfPozfOm3f5N5UxFTj2jruDWd4BgwzjMGkxlSz5kezDCbGxx74CE21s5QZILCGR568CxXr95iMRlzfTHh3MPnfCZ6pXALw/XdGwyUZaWq2N6bkGcKU/hkkIvtA6prO6yfOs0jTz9FPq+oACH7rG0e56GHH+WTn3yO69dv8cK3X0bIjNXVEbu7++zc3OZDH/oIf/e/+2/YOrbFlStX2No6wT/5n/8Jly5s83/7v//3/K2//bf45te+yWJe8dJ3XufmjW1m4zHOGg729rh+4waXru9y6vFP4tScye61u15sP5LmwAW9dwhKI0X3Ch+l3tQenMcM95FwSOXz/xHmOgKzLM8x1uKcz/GnQ4BGUZYopdCNpmkaskyR5wUOx2KxIM9zVOYjVbXxrLmqa/I8Iy8K6qomRgjXdZ00ddD6+yGED3xytt07QuAaDQF83k4rwzmRsUPydYw/e/rjGWsEcEBgenH+oimwvSwykqW7dcBgjDDrQjdnHcKZ1K8QLaiIzxofIkXHJ2AYtQEeVFttmE6nlGXpzb/GUBY5WkfTuT/HOgOoVBv4NrP1j7FJ55mlEw5hQYQIYBuYhgXmjeDM+gZrx8/x7Hvfx/6736Qocs6eGLC9vcNs4dPZOCMwIfrVCTppU8A6H7xgXUtjbWAs0QUiE46NngeOkwoWGq9BDEBAxVyt+JQsEewAYQ3595JawA4xsCrLJFs9wZMPlIxKybWxptG+tGFjHNaKEDLUMlcfeO8QEgolODmSXJ94f8BhT3B85LMWzI2jUN6ncnNF8Z6nVin7Ga+8ssf+xPs5HlZgjX8G68DJkDdQSdb6XhY0UrCwimFPMDUewUohySUMcsmxVcUTDwx47wfPMTp7lkvfeZWXXrnBdOE1UrmwTOaaa4eWeeMY5D5Z9bgJ5mRhEE6jhKCfO3ZnFas5rPckopexvqY4d27EmWef/jGvvOXW1T4JKZC23f9pD8a9HcEBbcJ3E/LKJbOx6Grd2sDNmBLFxu9BeAxyYxIul3zvnOgAvU7fYXy3YwQS/Wi/xz9tv8YYhAEjTAJmrTm7HZMQARDFqgi0RROiVs4jGJHqr0ctKpAsG96/248tmcw7ZFb6MjLtg7kIwEnBa8sCsFgCrhFTRXzVCuyuMy0ykElvEVFKYbWl0boTACeIOQ9/GEp41wDQ+56LpRqzkQl4Sc8zVpxHoLE+XbKlBzofpWYZbu+wSJkz6K/xyU/+LI8/9RH6g+OMJ3Mmkwl5UdJfGZJlillVQnGcC2+f4eprXyNTD7DQF7HOcvnKVf7+P/xnfOUr3+Rv/s3/A88/9xRrJ05Rnb/Ac08/zmvnL3Pj1gHrG2tsrG9irOanP/95PvjJn2Q2PWR8sI+0msO9PQ52dlgsprjFlLffeI0/+sYfsrG5wYc/8glWNzZ54n3v4ztf/xoPb26gneby3iEL5zi/d8D2ZM4DKwXroz6vfPk/8shHfoJ5I/j8Myc5eWqT119+lemsYjKp+Mf/6B/w2ENn+Rt/+2+RB6diaw11XdPUlsoKdFUjZnOEM+jxnHp7FxYVN2vNzcEK66MRWVHyqc98lhvbN/n617/JbDFlYUBkBWXRp+yNqM0tBmXJ8x/8MFXV8O9//TcpipKtrZO88fpbPHD6LINBDxBkUvHiCy/wj/7hP+Wv/bW/AkCv7PHkY0/x3mef5Rf/5S/y3Cc/y+XX3+LGtXd/iOX2I2hCtNKXjKRBhLD41jwbN3I05VtnsTqSPtDh+rquYbHwqVtCFF9R+Mje2XSKUlnQrgmqqmK+WIQcjI7ZfE6eZ5RFmbZxURTUdU1V1b6gvDHMZrNEUPIiP0IACMSozWtojUXkoi05F/ZMJCBdiTJqIZum6XQY/0SCECVVWqIa++uAO1gGe8m30bZ9tbdoNaPtPV0i9PEJhfCasRYxtuaQRNgDMdZ1Q5nnSOkBdpFnCKBuGpSSaKPRTYOMBLBpfBSwlEihuVfN2ADYIm9J6a5CqUbn6WS+dQ6nMqbjfS5dvIhzgp6Dx06OuLJ3gDOauiFU7gkvPwg3fekw0lHp1twpBSllUS68z9yx1YzP/cQJnHR844VbXNk1jBfOgzMEufR0eNz4aiDO+LWfwHt4D36JSTLhtXOFhLUCzq5KPvXMJj/31z/LyvFNvvZvfoPf+fINdk3tgy6soHYhClFAL4NR4bWPRSYZFfDU6YLBtk+n8sSpgmef6DNfWG7sO4wTbB3r8fwHTvPsz/5lVNnjpV/+ed58/TqXrsx454ZhOvPCmfejhWEu2RopTm9m7B0a9isoFpa+lBxoXyVFSkEvlxxbLXjvk5t8/GPnOPuZvwKrj/D4yX/Oxsa3uXrtEKcNulqwt2cwrma/MqzmsDur2dOCOpSuc3jfTrDkwrFSKtbXcs6dHfK+923x9AeepHzur9yzNQgBuCnl3QOkDAoYm4CeIAZqBroYwF4WwZIMuTsSn/bHXNAmWemCm00U/MJ+Df9L0CUCRmKqF5HoS1dzFlu6VzoQ/9cBjEdbtFAE+mGj9o5g5nV+DmTQDorOfZLPXnxOEeejpV1SyhTMldBtvF8wx3aTzUcXoeT9fEQIbWlcLNTSjnl550UgGelxEOpDeqKoMPP+hC7wKQ/clcwwVqONpdba4y2p+GHCke4aAD790CNcvXKFqW68ql+QkubGZlP4ceQyHtRkWeaTF5oOcyH6TBX0s00+97m/yoee/zxNY5jNDU4brC1YXz3B6dOnGK0MEFLRWMvhex/h3fc+zh999Rd4981rNHrh01cYwUvff5X/4f/6P/EzP/1pPv3hJ9D1W/TyjM9++Bm+e/kiQ7XJRz/1k7z59lssDg+xswP2bm7zsY9/jG99+Q841htQLMZ88w+/ztmHz/K9l17g1e++wCPnznLii19A6JqmqhionBO5YmMlY2tYcH0858Z4DsZwUBm2BpJidsjeG6/xxEPn2NxYZz5f0DSaV155i8tXdzk8mLK6tsl4PGZ35xYvfef7vPzKq0x3pswXMM0KBA5zMEXdGrNSlDTFgEltqLTm4pVLjNbX+C//9t/mUz/1WayzfOlLX+LG3i77L30XIRW94RBtNeurKxwYy7dfepmXXnkJZeY8+fRT/C+/+Kt85zsv8XN//hwgqesFb73zNt/7/vd48slHqJuarCgZjTZ4z3s/wLmHHyUvGvbe+S71/i0KfW/tHp6IxUCiZUISN2EEWCpo+kAkf0GBN0+0Eb3efw9gUBQh/UZN2etRlCWLxQLdaHq9ksFggNaapm4oypzhUDFfLFjMFyHJs09aPOj30UZ7Rt7vh9EFwaljVkjSYdYhxNAGN+BQrnVSTvJdx1wrnE8pswQAo1YtXiSW7+uJkm0l9864UlAGUXBtxxVzWrYYcVl674K+pQjhzjtK7YjZwxNsR7VYUJYFmZJUi5osU2TKUlW+PJjRhkZrn17CeM28yBRS/oncmX+opoWklFAqy1BZhnlIC0LUKUAvd3zgA+/j2lxRqML7v+UZx0+fwAr40PMrNAc3efPNBYcTy7jylSSM9XT1xKpCKXjjlvO+b0gKHIWU9EtFP4dBKfnge1b5z/6PP8vagw9x+p/9c/7wGzc5f2POeO6tHCu5Y9Y4rk18mpKZFiyMSHkBI3v068CRK0k/F/SV5cRQ8uyDQ5577hTnnnk/avUkp858jXMnx4wbRzG2HM4tEw0xc6mSEidjSTivQVs03pRsHcwaw82d2o+llqhCooX3H9TW4KopRkry0Rqj4z1OFQJLRpkXqCwnyzP6vZLVgWJtkLE51ezMLY0xKOeY1zYBn1xCvy/J1ofs1gNG1y5RzObsH9Yc2gFV4dC2YaIVh7kiO2bZsI5Swc7VHVTjLVS9klDaTmIc3KgMF+cwOLbG0K7w1m6f6u1DNtzXeeazf/merUMpZfK3F9LXb/ZgRICzSfMekwnHgIJobbLOZ0mAKOyJjlYrKmw8iFNBAdSaO0n5/cI3///bNPEBIIqOwLf8vyNWQxJROgIbQz/LwK17kQ1aPGtMCDbrXLPUUzQYiTZNF23fqVJUAqYt2I3P4XlN624Tg+xEFNYD4nTOoRzdJ0/jjVpHG/LyektKWzoUF3PchghuBNoYb7KO2VSCT2cuQoJ5sZza5z/V7ppq/rX/5m/w0le/xItf/z43t3eYYyHPcFr7iZGqo50IorEDkDz4yIOA4623LnZegT8vz0a89wOf5X3v/wyzmebChfOsbhwDBHu7tzC6xhnN6midldURo9UhPRre8+QjPPDAf8t/+J1jfOcbvwQYnLMY4xiPJ/zKL/82F7/1Jb5wVjNfP8djp8/wuT//X3D6wSdp6gVrPUXZ3+TM1pB333iV4eqQhYW3tvfQ6w+wf+0S33v7FfI844GnH+XE+jFWRyVNXdPUCwya7ekYrRUqz3jP6WMcLK6igdXhgIOqYtpoBsMB73nqSfJc4RrFpUsXuHx9xiOPPMVf/M//C4RuePHb3+fExgr9QY+XXnmTSlusU5D7nFgcTFB5j8GwoDcc0c9z1lZXaBYVZx95nI998lP0+j4h8xe+8AWMMVz4xE/wKyd+ma98+Wts79xCzxc8ePoMb7/6Ajf39vnIxz7GC9/7PteuXeexxx7mG9/4Kjdv/nU2Ntf41V/7daaTipWVIb/6b3+DzWMnEELw0ssv8c6VCzz88MM8ePIBJtMtXvneS3e92H4kzXUJhmsLhtPxS3HROBrq/4Z1KIQ30+FozRnKE/ZGa5rpjF6vh+yVaN2QS0lZltRVzWQyxdoxKlNIIVkErWG/30P1lAclQUtlKy/0GGsxi4UvHZc0Zr51sFkq3r4kdXInYpqmAJzP7l83TTARiLTt/A28RjS6P3aJr9feyXYyj0jdzkVAGGBBAoek+Y33iH9FZAydZyCAbdE9t6NhFC0ZSE0qSV177Wmee3M8zgP4xXxBlglMMDGpUHPZpdRA96ZVwUdPWx/AENOhRBClkAyB5nBOr7fCsFeydvosKxn8mZ/+FAcHY1793nf5g2/WXL9wxV8pXErlUju4NWkoJVQoVnJBmTlq57DaUmaQDRQnNnusrRaY+hCrDynKjHIlY7UaQAk3d8bM545xDfu1xIWE01q7EPzgKDMQIcuAEo5BbsgzQU/69ChXdue89PJVNv7gt3jwoTXOnqr5mT+zwcnvNbzyVs3VXcPNKcyNNxEaNI2RVA6oNTtWcPVwAUBfOd7erSnerdFOMmm8j2OZT/mlr+7x5G9dZ1j22Dxxgo//5J/jwdE6/dE6q6trjNY2KFY2ycs1sqwP0pvHndVYPUfXM8x8wmI+o6rmLBZVKCywoKkrFs2C196qUOI8k8Vx1KkVto43aN0wvXidHqs8mHnL1Ww6Y777GhKNmS7IMv9uDmeWg5lmvvDg+bHsNLlb4Y03G6pXplj9dX7+s/dsGSZgRQAH0VTrsZxMWnoHIUk+wXoSgZ28TeMfBeOYPSCCqFj7NwqhLqxFoJMqJYLDDkiLhK5LGxJAEnH4/sekVXQJtCURP0aQO5YykrjOOVmI+BVFARBSR5mkjWOpv3BxSIxuEanAgA3WGhlNwB2BtjvuBH0FQEgl1gFvS3PSsbYk70kV573zJOHcjm3Ln6NdqqYUwW6S85MpvF0Ld9vuGgD+k3/xL/nPfvaLvL9/jJd/53eZmZoLs0VSLbugKpZ4ptM6MAomkyl55p3UnW0jgSQZ6+un+fDHvshrr7zOww8/TqMbxof7jEabKJlxeLDH5uo6ulzh8HAMzrF98zqiXGU4WuW5j3yRC298ncP9SxhjU5ShtZq3r1U0/X3W9q8yq9/H4Y33MjzzLMdPHufZ930QPb7BV778Da5evMRXXvo+c20YrKxwc7rLyg3Y39+nOpzy4FOPUh07xq98+xqLi6/z6huXKKzj+mTBtYnPc/RI3scYx9aJM3zk85/j1vWLbN/c4UPvfx95keOEYDKdUVWanZ0dBr3LTGdjmukhDz76GL1en1/65d/gD198gb3xGFXmlJlA7O5hGk3l4ODQMc9z1tdWefSRh7m1u88HPvEJED7QIEozUkkeefhh/s5/+3f4wp/7c/z2b/97XvzmHzHeP+ATn/wo33/tbZ5//jm+9KX/gBCS1fVVyn5JVdW8+eabnD/vzVV7hyXOOQbDFU8clMDqmjIvuXjtGn/37/4dpjcv3fVi+1E0ax3CmCD5RqYvkpZKhvRCzrrgrOujbIXuOPJ2Vf0GpFLkmfcDnM/nZHmOEJK6qhLIGw4HGGOo6yakFvC/T6dTer0+/V4ZAJdPd2KMQQUtVV3XKQ9gNB3Ev0c1dEsE2R9IBMJYF3d8+pvnGYiQMDlKkakaDEtSvjG+WoIICVlTwInogLyUVqEl6tGEkUw8dCTiMA4hfPR5jFjrkkhrXXA8b0FwW62AEHXt740T5EWBbhocvlKICEC+KHKMbshyhTU+iCDLs0785r1pkWnVTrFfWW7WcKIn+dijgqxQvHNJc2XmmL30Ig+/51mcOkW/VCys5ObOjIeffJKVtTVMNuJf/PyvUNcNOd4cWgswUvrKHMaRScfEOJTMeGgkydbWePfaLh967kE+87nncUrwrVcPUa9+j1vzTc68/xRPb5xiVq3yz37+V9ndPqCuddDOwcgZmgKchMzBsBRk0pFJy6BQjHqwVkpGZcFoJWc0lJzZUOydP082BlXm6EaxUuac2fT0tldaxnNDYySTxlBZn8y+0d6UbIUI0cCKnpKs9HIMio2RYjTIyRSUBaxf3cZhOba1wWjtJKPVESsrawxGI8rhJqq/jsxGCFGCVGFdaKTMUTLzpj+pEEqiZBaqyUgqpaiVoqlzmqZCZg15CZktkU2NUJnP2GQNTa2ZTOYsasfOYcPN/QXzqsFYb3ILjmU4LJkq0UZ6yC8FiHunhYZWUPMAr5sAP65Tvz8jiDPW4JxAOG+ZixYTITx4l8InZu9aGFLATRToIJgxaSW4ruzV1dDR9p9G1NGqiaBVjHRiyV7QebYoqHZ1jV3PlSXtnmj7VkpRFLk3ZwcgmO6VzhOdPjqWi0gTbYe6pHPD70GQjuT4NkkaWivPD/g9moYj8GtZgv8vBvUJIchU5jNOhGT6DgfSW1adscG9zgYeeHftrlfsK6+9w6uv/j2GvZKBgscffYCrr1+i5xRVvfAmORET2QqyrESpnJXRCogM4QSD4Qp13SBwPprTKYQsuHbjFpfPv045WGG+WNA0FotEScferX12V3eodEOv3+fq1ctMp3OGm6BFTiH7PP7UZ/j6l/4+AssJ1ecnhse4Uk3Yt4bzBwWPbAyZzxr2Xvh93Oo5yvwxKgr298bopqJaTLixfYusKBgdP4bs5WhnKQd9Dm7scOXiFVTZY24t++/e5NTZR9m98joHiznOOHqu4cZ0zgMnT3F8fY1rr73B2cceYmtYIp3j3NkHcBb2dw95+OGH2T2Y8lu//Zt8/CMfQgjJ5uY6v/brv8HlW3u8/e7b5H1v+s0nM++jhkBYQ1XNaeoKZzRvv+VY2djCOsfXv/p1PvPZz1AUOVVd+fxHoTzXM8+8l6effg97e3tcvPAu169d4olnLnL50g4nTh7n5q230FqT5xlvvfIqv/qv/zXb2zs4YDgcMhgOWCza6NfZbEavLJiMJyyqmkff98G7Xmw/imZ9Cn6QPueRt2LZpPJ3iJQqwOKQATSJkAIgpUUJxEzGmq3a+hJlygO7WK+3rmvm8zlCSIoipygKtNZIKegHk/BiPmc2m5EEGyUTQUGIO+YH65pXI2GKGrSulJokeykpcpVKOgkplhyUjTHedKzwglAYg0SFChoSlechgs/hZCS8ipiWBej4T0aAKFI1veTcvKTqIxDLWA1k2U9GSrFcf9S11+A8SLfWhmhXiW4ajDHkWUjpY0I5L+sjEbM8C+l3CHkFgwlY3DsN4FiTfKzqsO52KvjGRYcThqoCbRTF9ID9/W2u3LjIaLRKtbfHy9//PteuXGK0cYz3vf/9vPfxF7l44V2qENwurA+8QGbMtaOXe5+t08dXMLri5HqJyTc4de4M+7sHZIdjDvb30W7OnrWsb+VMD2dYu85nPniOTJzh9Tcvs33r0L8RUaKU95NC5fT6Q4bDPiv9gmGhKEK+v5W8Zm1VsrrSY9TXCGac351y88aUa9drbuw0HM4d09oxa2ChBdoKjMsSsChzjZSQ5TlFnqUyg1lIQ/LcM+scO7GBE74KyGC+i+wr+lurPpI/y5CZ8qk+hNdA4TQGibA24ASfGEdIhVM5MsvJshKTWZTRKKPIjMSYjIWdoa1G25qYh1Ymv03L/sGCa7cmfO+1S1y+eotat9obmdI7SazRCAnD0tDPHIMyx1lB1dxbdxgbwIV1MWWUF8ZajdeyMKmUCkJWFDZTNWifwiWkaorWhOgaE/2r475buj9dYZEl4TEJgoGOpb9A+6ebNSR0njRlsXXpZyt4+itaUNkq6IKbi/H+gUrJYIXpgk1asOpIazbSNxvAn+0+S1AaRM2qPz1E0h8ZY8R7bYRvCz67YLBN3ROuSSmxgjZRWEB2fAS9gk1KhcNirO704e981K/7j2t3DQCtcwjjmB1OcHnG629dpTaGrMgZFatY4NSJk+ztblNVFT/12Z/gpz79KZ586kkO9g955dW3+ca3vsN7nn6Kr37ru+zNoXQVk90pzsJsOubGjUsU+QqNcFTjQ5TTjA/3uHFzwGi0wNY1O3s7lCvHOF6uYZVisrNPOTrLmdMPsFgccKJx/JmVFTb6I1wpuVqPyfOHufHokwxGWygh2N/d5/VXXyNv9ukVJQ8++gh87QW0NjRWk+mQ0NR5bcnhtW22BwPm8yl5U2Dqikr0aKQjkxqpYGe64H0ba3zxuceYU/CdNy/w+WMrXHz5ZUZrf4t337nMAw+cYTbZ5+Bgn73dm8zmc05trnPxylVefeMttsf7qEIhjEYZR291g3o8oZRee6MtGCGZzmZUWvO+s4/wxhvv8lOf+zSz+YzZ3FGWJb0yW5JilFIcO3aMra0tjPkgFy9e5Jvf+CPMd6eYl15nMpkxWh3yG//b7/HmlavUdRVSlNQYoxkMV/waMH6xLeaS+axicjjhYG9y14vtR9E8IJK+5m8IAnEiSrrh96Dhir4aiOgXKJLE5o+FqK7gM9EEc2qWZ6F0mY+sddZirKWuahaLykuVrqGufUWQ0WgUmJEXbGLNTGN0u9fvoJVf8pVLJobohxKlTN+60n6ch0SohPe9siY4gAsR8mGqoBn2IC/OgzEWpSQ2RB93pXRvMrG00vAR5+WOZjASuJiYNGr4WvOF/71uGoTWZCES22N2/35sKP9WGUMWTC/GBD8/fP6yTEmKMqepNXZpPH4cnqndO+ZbFkVwvBcMwCePFZKJdWRS0ltRHB8oHljXKL3PN/7wRT70zCPs709RWzkGwcpok/d//LP87yvL7/3qv+RwVjFZNBjtaKxDOx+dWGYC6Xz5Mpf32Tp1gocGPfSiYvvagmOLa6yWcGW34pe+ustDxwo+9PwmW2cGnHpogJJwazxnZ3fqI4wlIY2GQyjIC0VWZGS9AbIQZEWGVDVWSIzMqZ1jsqhBN8ynMJ1ZxjPDXEPjhK8I4vy+isJLFFhymZEJC0qEnHoSoVQyQ755fsyFK3Occ2S5oJ9J+gPFOWE5KyRCRP8069ON2QZr6lBqL7p22FbDItrkv1kmsVphlMJkBXo65tq1N9CmRuvaZyZTJeC4vD3mD7//Lleu77O3P8MYS8qcDCFbQBaU3V4TnsmCN89f53KhWOkXDHoF+h6XAomAxJeCEzgX9lYoYybi3qZNop5lOVHYFFIkmuEiiIxKHBcSscfvRA9q0u93Kjm25Psb7hmTLbcVKgLEiYJlF690XUTaUztY9nZiKjp9pTF0zrHW0dQNWZalFClJ19gVul2YJyl9jhLb0UAuaTFbetnVOLZDj89/BwDoWFpbHsCzpOGMgnYLoEW6NI4/glApVUgKHVQaEcDfZfuhKoHEh5ppzWK28FqJtXXe8+yzbG2u0+/3+PVf/w0ElqeeeBClNW4646FHHuY/fPXbPPfcs3ziox/mq994kWMnH+XgytvopkEpRb2ouXz+Lc6cewZpIS8K9g/GWBzzasFwdZXtnStUC4PobXL9yiXWq+O+ZqgasbJ2FlcYhguL0gYpS/oyp2dyjqk+/aefYttmPPDoI8zG2/zyv/oXfOqjH0Cg6I9KlPA5noQUzMZTNo5vUZYFUgr0Yk5z4zq39g/pqRXG+/vMpwdIIRiMVljMp9im8sDJaB558Bw74xlDFH/pi1/g4rvvMhiOGI0GCAEvf//71NWcL3/5P/DMYw9ya+4YH+zi6srnrBoMqStNLjIsAm0tmfCKL3A+LY0TPPX003zhZ/8sZ8+d8SZABHt7++D2OHnypDefHVHHZ1nOI488wpkzZ9g6vsYffuNFREiYefniW1y7djWdb4xJ6U6K4FdhraFp/BjKXsnlq1fuerH9KJqUymuphC/VF3TnCBVU5pFaSFL5I2gBYGTWsLyhEJI8+JQplfms9cHPQso2jZExGmOsT1niHHVVU1ElsKhUW6GiKPqtRC6WJeCoUfXuCsER2BqSxSD+3iF4bVRbGPIRaTqZaYO2wtci9g7/smPmAcds5tPaRFOGDSAupjoAD+wiqPNjsi1RTMJsm0pBhmoLIo6t87zWGKoqVvSQpHrB4XopBFXd+KoNRZ4eqyx9KqbZ1PtcWmOQmb+PlDKkXmm1EfeibW2MfJJhPKNQKlYjkpSFolcoVnuKwWrBoC+4OTO8+Mq7PP7QaZA5WTFgOBqxunGKn/zpn+Pi936X8bTicFozWxjGs5rprMI5b7JDKKTymf5fe/uaFzSMIFOOtZ4kywVNrZgtLBe3awavXaZ3ZT9ELWpmh7Pgw+UwBrQwSCXJsVR1g1M1jZsxU4JhT5HZCZmZsr9j6PckSoKuDQf7c25uV2wfag4rWBhBbWHeOKwTURcX+I/2oC8GX4na/5XCJ2QWPtH1XPvUNIWEATDqZayekUwWNYfzS5w79zi9vg/2kabBitqvHdOmPfIa7JgozacTk8qbghvtV+hkOmV3f4ySIJxhMT2g1poLNyr+9W9eYDpvWs2T6Cb/tV7lIiL4sb4SkbO88fZVBmXGT3/2A/yVv/TnGQ4H92wNQshwkCmfjkhmXgiL2j/XVgURohv16lCZj663zpHnWZsHL7wfaz09TXlORRCSQwnBMDFpHFFQ7WrVUlR70JS1mrauGbhFdhEXRQ1WwkhdcNT9e2S7i84HsTQ2/zem4JKmK2yTQG2yCoXfVKYoyiy5z9wmwYf1EP0fkzvL0dZ16TlSjSQ+a9TgxXyOcU7DHYh1geP1KRAkBINIGWoSWQfSa9jvtt09ALTRQdQzXSklK2ur3ilewq3tHapq4VMzWMu1qzd558XvsPP+59l66CkWi5oPfuojvPP2O3zmY++leOg5fv7//UehjqWgv7LGjeuvs3HsHMoMWF1d59b8CiLL0bVmsn9I2d9gZ/sd8lGFtYbFfJ3eYJUiUww3HuL6sQOaG3Oq/YxJNSUvVxnXNQfXr7DlKlaGK0hp2NrYYHU45Hf+4GsYI+gPSz+hUqKyjLws2d++yckHHqAnBZsnNvmpjzzF7373PJnMqBYLjNaU/T6zxf+PuP8OtiTJzjvBn7tHxNVPi3ypVVWWll3VhdaNRhOEbhDkgBwqkMMdyh3arM3wjzXj2NjY2hptzTjcneEuh9wZGjkzIAEOCYAkBNkAWgEtqkt2lq5KLd7Lp9+7+kaEu+8f7h4RN6sJZhu6c6O78t53b9zQfvw73znnOyNG4xH1SLHbHbG1s8/asROcXlngnTcvoa5dJm7Uef7557BobJ4zHA7o9g4Zp3X6gyGHvZR0NMCmE4gUB6MhxkDPQnNmhsmwjzAaTCmtc/zUSb7wc3+MI8eOuMHjy/sHgwFxHDMaj7wI8nROhlsktVqdz372cxij+ZV//s+IJgfs2Yi3soww6YeHdzgcTlHgxmrSdEyjUefr3/w9fuEv/vl7fuD+0IsQlYk/FIEUX/lwqwDjqoCllzWIfDVw1UAFhrfwmvy20zQjzVIAbxxxhjUASiGKHLXQ4HwymZTXuXBtQ9K1LMBZEeelCBR89/yRqXs2nUdDxaDa6r3yYNMaXeTmZr7yXvtjDcZDCOHSMYQowKFA+DZrIURu/TWY1tz6EHMpS25gylkmAAJfqVYAXheyd/J0DtQJIV2/ausSnOPYdQMajcYkSUStlrj8TCXJ8gyBQgjHJumAmu/TUou84yEEwuQoGeSHcPmMAia5YaeXU08Fc82E69t9trb3OLK6jIzriChmko6pt2c5zNvc2NjmcJgxTg2TSc7Ep8rkxqC1IdeO6YwjSZrlZLl3YKwl8aCkFrlQ6q07e/RuHZJbQaIEk8yxugL3DAspqSlBklii8ZgkyojjAQJoNGrESoCW1JQklpZ8MmGUGpZnW+S1GlFT04g1iYFJZohyjdYWjSxSMZSwREKgFCSR66BRj5XT0qvH3N4ZkfUmTPYnCAkzwBqW+SgiPejy0ktfZ9Dd4wt//Bgz7SZGp8gswgJZOsJaN8lJCSqpOYbQj4HghBwc7rOzdYvxWHPz9i32dodIDNlkzOHhAYPBiN9+5YD+ICvZ9jAR4+6jsS7/EnxuufU6bFbzyAMnObna5tjKDJvr1zAIPvVj9+0xLBZrwRrtHD1JwY4X5+GdN5feAdkk9SBZonPtAKEIIU2IIvcmhIARLq1E+3FbaIH6a1UCOr94OxSYvwDJCuUFv457CQAq7KoCzKrspbdJBYAUpb0pDhJbsHnBYQ+HFimFCaLyRb6k8NW0lPbNlz/r3J2zEHnRMq6aRlRgU22n7Hfxvji08hgDEHY2E4TXqTUVQIjwIVwbroaL2FhTSXOqAEYHzl1LSOv7cd89lfxBy/ckBO3Ca/5vKciGA2w64pUXX6SeNKg161ijWVtocuPaFX7qJ3+a2fkVrt/a5vSp00gkjTrcvnmd3atddOoMd5pm1JsLaJ3RO9ykM3+yoEyNgTQd0bOGWqOFkLFroTTqMrt82oeQIiK1QP8717kiFP82bvDTssWcleSR5P3BActXLnPi4TZxDJPxmKcef4D/5Z+/ibaCRrNGluXESYLRhrgWQ65o9Ps8sjBDFMVs3jpgtdPh/cs3ybOMJIloNOrsH+5jjEZrwf5wzPrmDg8O+sy1GnywtsxBe4YfefJRImkZDPpcfPMN7ty5Q6/XpZHnWD3hYH+H8Xjs2tBYyLOUKE4gSlDNBtl46MAfGoNFqYjPfv5HOXP+LJGKMFrT7XaZ7cywuLjA5tYWvX4fLMzOzvoHc/qpCGzgD3/uj7A6k/Dar/8Tvv72hq8ussUdD78dDofUajVvJFxi7M72Nhcv3t8qYJeaETocFGfjwqFYpGeqw9/uR6LQ+JOyysi5SVX4dmxG62K9ItdClcUV1roJORg8IQR5rpHS6f9VvTkqg10KWTCNwXMLVciW4O2Wg37Kna28LRm/EkDKUMnnQWakFFE9JkuzshG7NwpZ5sBdHCdFsUaaZlhrinZWUiWl3pWfUGu1hDA7OKw5PQEUhSPFTaoety17XPrrFikFquKne7ZV+2sphWAynqCkJE5iMg/GQ0jbChDCkuWZy2UUAu6jDMydvV5x7wAkFqQgAuJI0oglxk86rXpELa5xYnGO9b19tvcOWV07QnfQZ/32ddaOn6XZbtPrDhiMUkZpDkIRSXdPYilRSYTOM65t9HjykdPcuHyH4d4AK6BlLR3hjqExH1GrCbTJOXmkjomaCOUZV1xuaqQEcRIz26kzN9uh3kyo12rUG4kbA1KSJDUwGdLkmHTEwc4uB90RFx5YoN8bc7A3ZjLKyCeabn/C/jBjkPo+vNpllcXSgcBEOfDXrEUktRghJYvLc2izTzo54KwYEwmBtJY5oCksG7c2qZmcmZkGkYod+MgzhBwj8wkfvPwlNm9dAWNZe+BJzj//eQfW/P3J8pwszxkPhxxZO093f4trN65z5Mgq9UiRDoa0Owv8zu+9w8GhLtkgW+38A67HbglSkAKb6aINZBQp0lwTJ4pvvvQeo0nGX/wv7ttj6AqrjPbdVoKUVHA+i8HqARlY7ToMqUg5Jt87gnmelQyg8D27w/Ntq8PZF4FMzSXTzR+mQqKUaTihi1LJvPmlYMKCmbIF01dNJSntqUQFEOYLJNy98ytVDFHJSLr3rjAo8pfnLmYuOK+Fg112NnIgzSKEKR6ysN8irH2Xw16coz+eadAW9BLL/L/imGwovDGho6PbD5U2diFVE1dtG0LcudFFEdS9LvcOAN2s6m6SFOQ6paYSakowzDKOL69y/vgKc5/+JFs332Vzr88gHXFw/Trvvvcus0vHOLoYsbAwx8Jcg5e+fBGjLSiFNQIrIkCyt3eTuLFElmdEcUKUafJ0yMHhLu2FNRASrScMBodkkwyswMgJK6vnaKSQxpqrTNgbS442Z5hLahyaPp988iH+4T/+p7z7/jUeefIJTs67h1lFgjynSDJHWEQkacx22L+zxURYTi3McXRxkUdaNc62m1y8sU6mavR6fXTuRCgzrRmbjK3DEYeHPU6cXODI4gInz55k48Zl5jptev0BF1/9NtlkTBInHPYOGA77ZOMBZ8+epd/vsbOzQxQppLSoSLC1tQlIRBwjrcRmOcfOnOWZ559nZ2eb48ePkU7GaJ3zlZdf4Yd/5HOsrq5yeHhIq9kqafMP3U93/nEU8/Czn+Dapavc+dr/x7tP3hv0Iz+EkoPno3PN8aNHef3id3j1ldfu+WH7fizO24WiaamgDP9YVwzhH1VfBOLbHvnQpvGvUvo8N1kaSSqDOo5USctXdm5hqk9vMHhBjT6wZEWFbzgWn48T+5ZtxdfWok3JilUrg8NvA2tJ+NgbvxDmUZEqGDvtNbCazaZLX8jyYpu1eg0sTqpGu7BZs1kvwrtTIWQc6NVGe709QygWCT2Hp29M6ZRPpR1AcWx3mUispegFHEJURlusEERxTJ6mZFlGrRY7sVfhWvtpq9G5cetaF56qirT+oJej8w3KydaxLkpJkljSjAX1JGIwEcw0BPPtmE5TsbZc4/YefP3l7yCiiIcQ1OpNur0DzqzF6AsLrG/12Ov5UKkFqXxKgRTM1QWjfp8jCw3MVp10r4cAcuFCp3PAu9ogPeuXJAm1RuKkiaxjcZVUxFKS1BKntZgoau02tSRyLJB16Q1Wa+r1GnlqUbUaImmgpUFHs6h2mygbsHm4zcFhSn+kGUw041yT6zIc7+RwLHEkULnlSC2hU3d6jUJFxIkijgRN/wxkiaCTGteDOKrz1PPPsXPnErmX8sjyDCEcy7h++TLbt69i0pxacwmTDxkPDrm5tUO31+PKO+/x9BPPktRqRMoVHy7OL7B29Bh6fZP933+FW0mDnY0ddHhs7jKShYOILJwrrTNUFGFxDHWS1EhTgc0t6+t3GKXfA/XyfVhc32zPyPtcsJIFFYjCrDmnSkrpsYZw9o0q2xRAiiu0ErjOMcLbyMJh9WDP+nEegKOUwqfMhPCqzz8PfclxNjgAvZIBDMn27rgCGKrEFApbEWySG/cGS14wi1KWAEkU2lN44qQMtQZA7xxgLxytyqhG+OFUXjaimBP9lxWge7clnFZ3qIK7gpyrgs/qdbXBqReIKCoYTzfnWc8A4plp4YkE7bqDSN+RRJRdUe5l+R7cZjcZBCbQCsEk164bg2qwVjvKRx54hsd/4of58m/9GiuTlN//2u+RTyZ8cG2dxaU1avkm129ssLy8Qq87IYobGAGpgKTRRKDoH24xu3BAnqUYL6Zba8yyt3sD2a2DVVgtSWptjJ643o8IiBdozi6hzQCp4LaynGtZ+rZGbb7N116/yOzJVY4JzTAf0p0kJLVaWenkkbi1Bu0nGxUn3Lqzze7hkEsbuwzGE8YGUgNGKN8L0xReUaZhZzjioDfiVJIw3Nvif/1H/xBVb3ButU2WpWzcusH+wT5x0uAv/cJf4sKDp1k7tsqRI8fY2dqm1+/zxptv8p3XX+Nb336VSDmvOfOhyJm5ef7Uf/IniYUTWx2PR1hc+6z12+u8/sorPP2R59jb22cymRQPnLWWNE09i1d6YxZI4jo//DM/z+/8/ku8eunXSTMISqDCT7rlBCtoNup87jOP8m9/898Urc3+/7FIr2RfhIMDa+w9KCkkoV1fsHIydNi27rfCiEIRH+smzjKh3VfGhQEdKoNC6qH3sI11HhiUrFBhFO1dFH8F3LmkeIGSLm9QRD7/7j/AAEJpKwMwzPKc0Wjk5F6EM7YBTBpTFoIUPwYPQH1q98AVu7jzKEFe6YX7n1YOw+1aTK1TkCZUDCUhi6Wy+8oGBV6z3goPkAOud8atliRF1WKcxEzGaSE1Y4IRjxR38Y8/8KXViLEWslyjvfFNIslsM6JVd4yrxrGZqRYMxprt/SGLnZhPPL7AN198mTvrd3juuQGzs20OrlxlpzukO8wYTjIyLUAq2vWYRs0BEKkUs3VFJDStuhMdz3Hi+zWvdTnOJTa3yAhyrWnHDjx2exPeW++SGceiqsjJo7ix4xhkow25djqq9Ujws597jAdPr2IMRLFCCFekk7SbjMaW3379Drf3xyUL7G9BEXoTEHsGVAiLVQnHVmoI4Rj1JBLUIklDuPFRl4K6ACMs7XaT8XhIf+CKgXKdI7QgE47FyoZjjBRY4do0msmYYfeAvTs32NjY4t133mNhtsXZ02fRJiOz1um7TTL6v/cNhvv7XO/eoa7qGIYFU0V49sKkHaSkhHOaAiDQOmem0yGdpE7+DUGa5oxH99cWCt9YOaRhWBvsujumwOoL3LhSvn+uFSGsKstzDpybCEUgrnd0CYhK3HI3iCkGvMvpKNZVUYQ2ukzFMRYVVdrOieAeMj2Cq5umBFnFmqJMUTHGFGFdCoBUtUHub5ebXYo+F/fZlutIUTrxRW/zwrCJgh388Of4QsTy4O8GrtUPQzi36LRUvZ9+/fLaBH0/sNJ9ro0GLYpue4jwJoDxHwAADAnp1hqEdU2kjXQh2vma5JMff5iVU6d48d99g2u31vmLf+Wv8Iv/7J9x/eo7dLtdBoMRddunO+xz+doeUjXI8xQRS0yuieMmUsVoPabXvcMkewBQGD1wBpCI/sFtktoiohcTN1rkOifRrieo1oKzL/wZBoPXYPMSGyttfmuuzVs397n0wWXSdz6g2Wmwu76JyS2XO01Wjx+nVlNcv3KL0Is1HfnilloNMTfLZHuf0ThlbzgmM6FiB1cV5m9sQOlaawbjCb1uD1TMcDDmzbffI81SdteWORhOEEoSxzFLiwu8c/EN8tGIOKljtSARkpNHj/Hss0/zv0eSV15/y0m/ZKkLzWI5d3SN3u3bvDkYcPz4MYa9PkfWVrhy6Qp5bnjt299mZnYOKwU7WyPmZmaIk5jxZEyW5j78dxdLIwSdmVn+0l/7a3z71de5fOVaKTRpDHHskvKz1BUVLK0s0e2O2Njc47twQT/QpRycFRHTyiAOpgEZufw7W3pzMuT7Icr8lIKxc4vT7FM+t1UW2y8ApgXXss/9IuQIhmKLwPRhXUP7YFTD5IgoDai2BptZUpM5kAiEKuXC86wwuK71UTiggEllUaSi/TOslHRTu4p8lZ8sGPyC7QvXSwk3uYHP5ZOEnpIlaC291ykWT5Rh3MKwfuh+BcNdWarhKcprM7UtAePxxMmBeHZBSEE6mSATZ7aMtYjg4cv7xwAeTozPx3XaW1pntOsxy7Hy197Ji1gkxmrGuaK7m3LprR2kEAxSeO+DK9zZ2qHRrLN1Z53+MGeSl10AIiU5d2SWuXYHkFgB9VpEnuUkyil95YBWlrqBESAwZL63sB++SF81vdNLyTSoJCaJfegoSxmNJ0WBiLVOa1JiWL+zz/mTS9RqbYzogZXEccTMbIc0dT1zJ5mD3t59KsB/FAnqiSJRikgqDAYrJHGSFGMjiiR1KWkKONmKOH1acv39jD6SkcjY3b7D/s4u49GYbBQhcoNRGTrXHHv4aeKblzi8c5tao0GWjanXGjTJ2L72JnNzDSZZRm84QihJnqfoPCe9fIXJ5atcSVNiJdjqjgpHxGtuFM9feEyV8jJJmErFpaQWx2RpiowirBWMRmPG4/tbBlw6vZTyLuE8PhT5EY4hFNK3e8PlCntWzoqKeH41JOnvbAjTFlERz9gFZktKWfwuaNe5/ulRkfYipULnuQtTelskpCye1cLO2RA69iCtYltc97EAVt2+olpURHKKIgvvgE+BoQKMuW2GqEOFqCvyo4X1QtmBAKxco6qVc8ftj37Kwf1wsRzWek3FMq887Ld6/u5+uvW1qRTF4G23KEF2MW5zjRGUZMY9LvfOAEqIjKRel0S1hP4wpRZJOvWERivh7Ss3+c0vvcq14RDMIT+6scEDJ8/w/luvEkcxy0cf4NbuBoPeCEENqSKyfEAsm+jMoFRC3JjFdK8z7O8yGg1J6nXGkzFR4nrUZtkIyyH1mSVGgz3qw3nXucEYxqMhonGO4fZ1VGbYyQ273Zwbt++wt72LtdDb2/XtVqDfHTCepHzsE88yGowY9AeApd5ooo2m1qyzfOIoGsiGYw7vbGPGKSbLsdb3IQ2iw/4SGWtcsr33rlrtFi98/AVG/R6x0JxsNKihORjmzM3PMZoMuHz1Clk65NTpNdaOncMIRX845N/9+y+xvLzIaDgky9NCguSRk6fRaQbDIdkk5d133uPosTWWlhbZuPN7NKThS7/5G8zNz9Lb3ST99A/z8DMfYTKZOO1F7qbvywfw0Uce48/9+T/H3/k7/w9Go5HrcGBdiNKxMc4Df+zCE6j6CKtBfA8P2/dnCQx0wA9+MPuRVwiTG3xvR1kxBCWzJ5UPRxT5JAKES7jNdE4+zgvDAxXD5/4qDKeSjsWzQBLJArhNOQff5RyK/JrSVywGs60YhmolXjUZenpzohjzhTdvXdgvjuMCwLoj9xjYlsxknIR1TGXd6eTm4rkptlFSkn4uKAHcFAvov6yAdcfw2fBNsZ9QfxwAYBRH6CzDaPcMOi8+YjKeIIQiCONbwNxHHcDrdw4w1vo2dZHLYa5lnFpuIq1hMMlJx5pcaRQRkTLkRpLZiPEopT/KiJUi29lzudS5ZZAan3ReXrtBmrv9CMdRNbwQds2nJ6wlkqfPRLx7PWN9DCKHXEtGwpJnoduHIIkjOq0G/XHmBJR9qy8VucIoV23sALUfJfT6E7Y3blFvzWGtoj+asLmxzbVLt9EiFAK6A43cTIyxliRSdOoJkfJhYGmwOCbStSNzsjGJksQK6gj6DcluUyGURlgYjQ1yZImTWcxkSDqQ6HoEKsaS0Fw5z6kjDyOtCwt3tw8RyrIwv8ZjDz7OYDQhGw15+Rvfoj5/hFOnjmMHI2rXr6HnGqRdw4yQpCYrIiFTeav4celti86d2LS1OWCJohglhesG1KjTG4yYjDOy+6wDqHMDWvv20RI8i248eFD+QZK4AhaFwggNXhdUSEGeZsEnBkSZZ+btgBCiEkK92w5S2B4htP9TFtqCIBhnoRMSvkhForO8qFAOVa9AkQZd5fvcNj0bJiCAtymrKnzRmy/Sk1IV85spmDbL1E8qfxQ2xxsxY0BI3yAx2NwwF4jgpNsPHZMznlXbTgWUWsrNVfrZV78Px1rQjF4TFOFDwAYhFXmWkYZiTT+3KRWUJIyPct3bcs8AcDaBcQ41ZanHGe0ZRT1pkqaGcTbh17/1DTKriJMms3HGl37lV9ntDTj74OO8f2UDk6U+UbuJtmDMkNxMkCYh1zkqrtFozDrUmw8Z9A+YnVvBIEgaHc+yKLL8EFWr0+9ucrh1lU5niVotYjjqUY8UR2fPcurCc9Rbgu6N32W8tMtg54DDwcA7SNbPR5p0Yrl65ToIQavVYJSmjA4HRDVF2huSZymnLpxl3OtzZL7DG69/gMss0xiHfqaW3INLbSwHh4d02k2a801m2idckQCgpMHIhCvX1xnFEdiccTphc3OfBx5qsb15h1ubdxw7ajWddpua0ty8s8Vsu0Oz3XRK90IyMzPDzVs3OTzocnC4j85zcmXpHjidwcSk7O/ukWUZ3cND6vU6WmeAcInelB5ECPX+/M//Sb76la/yta993Rs84VTGtaVeq4GAWrPJ0RNnWFr5Pba3tu/5Yfv+Lk5bzAFB4wexLAAgUAhiC+8ZlQm+wodLfWWvDIUUwnUFsbG3TcZr3JlyjFMKOxdGbJoWK42J/7tYqVhPFMYhfFZl5kqUVq4fXqq2d9q7dOdVdBsRlkjFlfvrrkEAeQZTyORo7Yx3YEVLz7+cBKpsQMHgUW1ZVD1SUZ42wdnwBxw+U6I0+N4bDtBZegOrtSaKYufpG+16MCcRcRyTpplL/xBBfP7+Tb6hOXxgj4RwY2Qu0XRHKRt7GoRgrilZ6US8dfOQkY6JiMt7ISxKhefIOS5GuNysWIG1wif5g1Ve9kVKsjSjHkEkoJYoGq0YEk1zpIkNjKxFZ5aJ9u6pT5GJIkmkJBoBwmCtIGjaudCh8ffATSgHB0O+9q9vs7Q8y6lnTzMc59y8vMcb37rKsdMrCGuJlaAWCdq1iNy6imAlhGvPZiGS1t9jjTF1cisIee3GahKT05KQ7RtujBQiaZKcPsmJBx7gmU++QKezRGtuBpeKYYHYgVpV97mjDrQOJr7dl5hl9dTTrqhL5zxwbsjB/jaDvQ0WJhNMesAkMZxbrnOYQVMOCYn4gaUHBz0cOxY5Oywl1mjH7HpwEUUu4iOEJUs1Wa7J7P3tBFK1J840iTCYKixm6UCGqEUoAlFSkiSJa5lmtCM0NEX0p7Qv5XaqrBXekStz5SCU5wWwJ5UiS7MiT9loi/Q5ux/O8yuPuUBb5REU35dGxI8/6Z4r6YWbbdG0vLJuYA3D+wo4pkIUlDl/eHNVtdthS5ai3LbKEIRvK3YvRJiK23P3xoqf+t8Fxq/cWREosX47cYwnMAwhXG+V+z5c93td7vmJXW5r0twlmyppkNIw05akk4heZhilhno94dhMg7k45vjSIp/47I+xeuYIv/ul32XQu8W5c6d46619TO7yk6zJsCYn0zmJNjTb82gMJk8ZDbosLh1DqdiFY6VAoMBk5OMhrZkF9u98QGflHAvREmCo15rk5igjlrFZwrgfc6xeZ3zsKBc/uOyqmzyCB0fz7m7vMTM7Q6fdYLQ7IR2MqTc61Jt1Rt0+83Oz/NGPf4TFdoP/+t3/kckkLWlpf5eMzz2QQrDQqiOSiBs3bjLREx56+BRHjsyRpznaQDoZM7/QofvumOEwp1lPWJo9ytnjCWq0zmyzw8s33gOdcf78eebn51juKH77K9/C5AqlYqQQ1JSklkScf/A8xhhu3bhJrFz3lPF4RJaO0EbTmpllMh6Teg22NE2xFq/r504gz1Pi2OW+LS4u8hf+4i/wne+8QbfbQ0oX+klqCZGKvAgynDrzGD/3J36Wf/KP/+k9P2zfnyUMUFHcAzeASosV6HWXW2aRPjem0HSyFhNEpK0tc+SE8Ers1hsEVWoG+m2GUEgwcu7L8sisKNu8iXCcFYNzlxkquUJbNbJUgGGRnXOXoaXwKsu/zRQzp70lKgBcNV9TUDQhr64TQiDFdQrh4uJ3ISQxbaxLACjKc6p8ViwVBFvcN1sB8YAVLq9OqQij8yJUk9TiUuxaqjKB/z4vZ0+e5M7mNlq7LgMxCmENt2732O9l3J4Y5lox6VjQ3x9xOMoYR5ZGy5nbkJ8FoK1j0mqJQmYQx4JIOsBjjAVjnCalNWipyNOMllQuX66X8fXXMnJTPjK5gUQ4CQusLeapIlfXui4rINHa5SnqqQvp7t1wnDHpjUEb6ndmGA4NSkwYTzK63QHtWuwdLo30LcZiiesy4o8FWwIRCBJFjqlZmGnRmNckK6e40Z9wkCjOPv04K488yLXbO3zrrS1+8vMXyK2TurGAwYUxo9A6ULiWZgaJMRmu7CRBIBGqRtSeYam1yNxon96kz+FkSCNRToswstRUiCaESTcgQIM2mrjIlXXJ9tKzp1IKx8KaHCktw1FKZgw5cz+wZ+67LVJJUNLlnyEKBzII5EtvM7DufRQpfydAJapwDlWkiETkmcAyn1qbkhkOjL0JbBV+rEei8AcDkA6FaVjhJXMMWep6pVvjmC6niuCO26UOVkCbCHl6LpwZQsrSdz8qpahKkFX1lwN2LNYJ2y/NsN++f2eruw6i1WG77hhF+YPi+Kad+nKpRlsKux4c6KrTXvm+BI6VOSz8KfCNayrbLSaI6vYpGgHc63LPADBSgjhyJyyVRAJJLDFaIHJJc6bBo488yYkTa/RvvsUbF9/m5qbl//4P/jt++LMf59133iYWdTcHWbAmBZthdYbFuhZmSQNhnIzBuH9Amk6QUQ2DpN5cYDjYQoiIYXeHmdU1JqNt0t4euj3L4fYtZFxjdfU042zCyGRcfOddbHqNuRNHmVtdYPvWViFW6yhFwBj2tnaYpBlIybC3T1RzOV3jLKPebLK6MMvo4NB3O3CLEHhGzfV6FcBqp83x2SbKpGzcugXL8+Q65WC3yzidsHMw5M33bvLbX/0meaaRwNHVIxzs7rPJiJW1E5w78yAnr13n0uU7nDq2SpYpjhxdJE6a9Md9J96rBELC9tYODzz6EMPh0Fd8jlBRjLWGdDIiievMryyxf7hPrnPuXL/jJR8afqJ31yJNJ8SxE3qWUvLJT36axx97mFdffR284XDVUs7I7G1tsr9+k5/88Z/i05/+xD0/bN+PxRaAqQRu1QqvkIzrwIyfbENbNBXunUBZty1hZKmAr00JKKXPxwr7MHcNzGBNKpS9pTrhEXZ21/uwnYqLXXib5aYDoJti/MK5QgEu3SEULucUKCwdlDLnrwhPVPIAQ9FHZSdTXmiVTQi0XZEQHdYTzqEqjGX47Yfd5w+/r1wG4a+hNQ4QKs8WaGMwHnDluZM7kMKClN/9uv8Al3/4P/wd3nz7Xb7xrZd5/eIbbG1tI41hY31ALIFaDSkk2li29waucrRlsRUArq1FBRkLrMuZS2R5LaTrCGKEQGCwRqAkTDJNrZmQIGhgGRkYuDWIDWQGIuWAYKnoFPQbNWhDU7ntT6xggJvstA1Mjru/k9xQByap5rA3YpzlSOMmqUmeI4TE6Ky4ccaHvrJMIyTE0rV7c+FDicCFl4+uLHHhyac4ef5RvvziO3S7fZYmY9aSJqiEw37G2ZPHefThB92AtaBN5n4tJZgcK7zmmbWYPCuE1EtJFDdXCWExec54Z4P80ssoJKlS1GKFMoZTc03eP+z7AgqDq+5yPXOjSPkcT9dlxnUlcc9Yq1nngTPL9IdD6vWEerPG8vISg3zuB//wVZYApkKeWrAbblgGZrxkhJzMksv/y8dpCaCg4rD6jQeGX7hoE9F3H1/GVPX+cHu3LidN4MLnKoq8uLsgrrvoisvpDcUhXhdUqQI1hergwukNNtHf62DnbMV4BOBTPS9R/cyf31T3j+q/FQe7BH4Fgix/U0R5wnW6675U399lV+8mKqrgr7DD3jEWlbkFU56r0aYo2Au2OnRqco7SvXvG9wwAXc9OTRy56iAVJUibUYsazM50ePaFH6MWd7hz+zZMcvoi5Z333+C1199i6cgCm1/bZ69Xw4lp5hibYm2OxeXU6Sx3CfjCNdyeTHocHh7Q7swjELTn19jb/YA8H5BnA+f9xxkbV7/I9s2E8XCfpb2n6Mz+OfZ2biGZsN/fRcQWm42ZW55n+9ZmYXDB5Yh96oWnePON99nY3cc9spJxd4BEkszPkg7HbNze5OBgjyzPCRS78g+rMYYoilDAarNOq67o9w6YEKHzlG5vQrvRoFarMd/W7O3vcLB/SC1SNBt1LpxfodNJGAvFZDJif/cy862Mv/iFDvOdN0naJ+nlbVSkUXGEVDGRihBCsr+3x2Q8ZNDvAhDHin5/iBSWPE1JZhdoNBvsHRwQRTFbW1vUajUuPPQQeZ65EKlSLp/RGoL2Ubvd5me+8DO8efEi2lgm46GfRJx3MRwNaScRiwtLLC0v3PPD9n1ZqkxZdTBBUSbvbgxO5FNQ6tR5rw5ri4miaO5unPcXEuKFLzKx/h6HgVYuwS0rDqt8UzGiAZQKpg3Dh34HpbEToQ2TKn9nXUi6WnxijC7AcGBYystSCdlQ2qkq0+HOwBagK3wfDFAIL2BMeRD+gD6UA0jFOH7oLMXUnRIF+BWlsSuMoqXq1RtjUDJIHlhsbrDSYnKNEK4bi7Hus/u1NBLFC889y3PPPMnu7gG319d57dVXufz626QH+4xHY6JIQ26RSGIgtbKo/AvVme4S2IJdiAJLRnBgrA/zeEdDSNLM5RlbKRhL2GzVycYZnSwnsS79xEhIvR5f0ROggvEtgLEMhq64TECRBiGlY2Ry7eStXLebnDTT1IQDlXlumRjNJPd5m9IVILk2Wl62wgM/AygJszMdPvLCC5x7/CM0OvOoSPLJjz3LQXdEbzRBRQ1qScJsp4WbEDUmz/z49Tme2qLTEbJeK7vnaD/xeTFxYzRSxSAk1uSMD3bpXfwKYpyjMtjcH7OyMMNsI+HEfI64MagwWA4xO8dLkue5Z55UsQ7A6vIcp04fZ3Z+gUhkSFVjZukkezs79+cB9IsDvcanwYSB6V/Cvfb2S1p3n4QWU5Ip4Ryr7clKJ9EDCmsKLc9qfjKUDmS1ojfo84X86jzXRCrCWsto6Dr6xHFcPIfC66RmaV7aM29jQvei8voLX218FxgTYPz9EVJQlvUVR4qfFP7Aa1paJndNCrMXfP275hxx94/9WC19WxvMccXJDuCVEsAV7/1mCkc/rF5F95X7EIBxxW78R05xarlnAKi9ode5xSqLsrnTWFOKbHTIlYu/j6rNsL+zzbG2JolqtFsJ3eEGW7tXSOqQjrtYk2Hs2Id/nTq9NRohE0b9Pk4mQJNnI0b9Ho3mPMZYWrMLLK48zPbGa2g9QcXzzK8+xvoH/444UjTrCYfbr3LjvSMcbl0hS3sM+5tYpZFxhJLKJ+v7CU9aGrOzHD1xhCfOH+Mf/OJvMkozf30tg/6AudUl2u0WH1y/xZ2NbfI8eFPKh6Bchawxhk4c0Y4kRmtGE5g5f4GvXnyHS9e2+NM/+yMsztdd43gJrUjx8NoqM4vz1FtthhPN4WDCl77+OlJeZEFss9B7hZvCcuLCbVoP9L0sRo0kiVHCATEVSfb29rh6+TILC4uMR04wepxljMcTllZWieIakYoYj8eMR2N2d/ZRUpFlrtpVyrqTM6g8ykIIHnroYWZmZuh2e2TphEG/ixCzJK2E/mhINhhRqyf0D++v0fNHCIRcPCchIgGUYxqczgHToQNEkQdYJuG6bQVjFbbs8qOc1FGRU2FLY1DCNlkO8PBxNf2iYhSrznWwJmE8l8Ud4TcVz9yPOyEFSsTFZ4FpC2GDYtJ1K0wZ8eAxl8nItmgkH46pyqI6MFnJR0QgpMvBKc4lGNtwvP4qFF52AVoqzxVUDLAoX2z4PFwRUbkO7thce73gKbt7qXNDpnVRhHO/lvde/TpRkqCiOrFSLNQln/uhx/j8Dz3NJDes73S5fesab33nLa4NrmBzJ2SdW108a8a4Vns2hOuEc0qEdWE2bQwax2IrhJM6EpLMWEgirBLcShIe/LlP8fWvvEb91jaxLwQ1VqA1COsY/hAyFR4ohBaHWaHbZr3uoCRW0guiu5xEbSw6d51JkijB4EBmZiSpkW6iNf55lNYXXkFwkmfbDX768y/ww59+geVjpzGq4bRfhUBGgtnZFp258pkw1ricY6PJtWfeTA5SobMJwjpA4foDC9++UKFzQ9yoYb0Wn5CKbDSkf/0t5GgA1hWKpZnh4q0hnzw7z/mZhFYEvazMczUmR4gSGAkRtPMcsJECRsM+3/r2GwhheeT8MYZjw2sfTMjG69zPxdko/LWvzPp3MU1lKLQSMfAFQiqK/Dj19sJ5rIXj7J5N5RysACpNBSxap1cZ9DyFl6IKNhfcc6V1ThTHhc1K08xHZnx+ZV4pDKHsGhL0+gQVp7OwOYS6vtJ5BifgX7Gj1d9Ob0IU4C6cj9uXZyBFae9Kx1ZU1rcUveWp4LOCZAosnv+2sIWisL0BxLnLH2zo1F12967CABb2NdhaUznPyjney3LvMjDaJxwKgUKQpoa5WUmaC1YWOvzFv/5zHD/zNF/8zV/nla/9Dv20z9bmIa+9+BWYRAhijNYYOwGjcbS6BZtj8hTV7IA1WOHCXkZnZJMRmTEkAEIxt3IGrTMOd69iszHLax+lu32ZfLzO7ELM9uYW77/2j8mN6x1Za9QxFsbdAePR2D9M7gpKpZg5ssxbl26iDwfOw00i6vU6BweHxJGgJi0daTg4PGRzeweLIYlipz+Vu1JzpSJiZVisx7QbMYfDCSMrmPQzVo+e4NL2Hb5+bYPTdyZsiQbHP/4C5/a65NsHNGY7bO3uE8mY/njE/kGPhbkZVH2AOTSMU0tjYcRO7Q793pC15TUi6VrvxZFieWWZldVVvvl7v8+xEyeZZJoozyHLGQ8H1GoJ+/t75HnOwf4BSkWsrCxjrCFPDVFkASciHdi/sJw+c4bzFx7k5W+/4rw1A7GMWJuZ5/iRVaQUzHRm2Nm8ee9P2/dhcWEDNxlKqfyMGTze0BLH/a182yuXczUt+FkwwUJ4WYSqB+wGmLVgVfC0qp6vW2MK/EEY/dNuYRUAieqK5UuV3avmc9x15gTG8W4gWuAsIabsTDhPpcoCmCI/paCDQpFIMOhmattMvQ1Gq3re5cQQLlAI2Uxdlru3ZcvfhvsFuPygSh6LFI4dzDxjLaUgN5o81xgDSS1xuljf9Zr9YJa9nV2yLKVeT5CRIo4USRwjVUKsFGtzDY6vPsNHn32a29eu8S/+2b9m2Oth8cUM1pGqWkJkQ3ca58QI62ZhrQ25hdw4O+PIHadLKZVAC4HONO++eZXsoO/agFpPnlgcMMaF5yLl2kTGwpKT++e5zNULAEEJgSrmFfcgaePCTbnOMSrx987NWsY6CZ5QzGM1KOmKQ+bnOnzhJz7PR59/mrUjSy7FxFqkydHG9fI2NnI4pHDLva6b1kUIMUejs5QorpGmE5KkXhRluYviQogqcvNLVKsjjEYKl9pid26gVERuJoxTw+Eg4+XNHkdnGzy82uR0O+I7e2NCIYzWmQ+X+17DfnAFONOoK0ajEYPBACkESwsLZLbO4eE+Qo/v2zMIzil0tsuNbZfpUYZNPWxyxcwWVFT2Rg+/h7I7EgQr494bIwsWrmo3bFDH8s9uGMNKycJZM2EcK+W6a8WORY2T2Id7pYu6yKJ7eyngbAOgcc9EcczFS2k/q1XzZV5gBRBWgG8BptzKpZm2VNbz1yz8Nswnd6Gqu0PMYTPh+Ks5fu7F+jFcsZtQXDsspTagnf5tOL5qoZvwzp7n/Yo8WWlt2Z3kHpZ7BoC5sSglnRyD0WDgsJcj4pzTS3P80PMrqNZJfuEv/w1qUvKlL3+RPM95/+2bLDWbZH1Dv5/6k9AIBbONNqNcIkxOFFVoYQGW3BWIjEfQniVLUwb9LsYkCJmg8wmp0Syd+BhbV/49kdKkOnVCpo0aRiuOn1xhbmGG7d191m/uFLlQUkjaC7MkrToffepBHlxu8bf/3g2sVGRZjs419XpMKxK0E8Xhzj7rd/YID6GUijhWrkOCNSzWI1ZaNYzVTFSd1lKTN197nbnVFT7+/AMoKXh/d0AnHjOeWeWHP/VxVusT4igGry3lwoSSqNXg4OrbXH75XazRbG1OePqpE/zVP/cJhn3Ix5ZICuIkotFq0m63GQ2H3L5xE20EaMPEG8r+sM+V999jfnGJ3e0dYhXR7rQ92NBYI+l1Dz274h8s7wkvLi7x1FNP8dorr5NbQxInnDyyxrnFFWbjhO29PcbjAcJM7vlh+74slYneVAZL1ecNAz4YkbIRuijWA8Azqc4QyiomKQxCCJG5PLOwJ3nXK1NArwpFqjIwJT4UU0DPGRhXwOOwpilCN+V/d4UKwrWY2q8tAOA0HirPumow3fxZSRquADjrJ3bjKCVEUS0ZzkVMGdKSYQgJ09O3rbh0wUAGvTJResOA65Hp75fOc5COdYmiiPFkQhxFBWOqdYbJ3DncP/gHrXaH8WjAaNhHZznNdhNTb9JoRGRYstEe0eiQOEo4emyRyOflKusT7xFIYfEy5V6A2fcntZ4N1D41IbQncyUQWO2KIYQQrIwzJq98wFEcK7cbNN2AXDtw5ogeAdbQjAWJUtSVCw/XI4gqD4oUGgVkwiJ9UY4jCyXCd14IfohUgsSHexGQaktuLFEU8fyTD/Ln//TP8tCjj2Ksk8nZ6/XQec7MjKCGQFFzTKd2vWiNyZ1/Yxz7maUpJjC92mJEhot4Gi/O7ORrQscYldTI07HTb/PC5tnBHeywD7mFTGCznHyUkqcp//rtDf6zR1f4iZMtrh4MOHDR5qLKNzhGCEEkYCVRdFox21lGljmG6oEzJzmyssDlDUMtmrjQ831cnKSZLQxLwe4FR3bKGSx/F2yjhULRoGoXJG57SAculFdMKM3tlBUtQZ82rueusUSR9F07NHGSVHKoDSqOsLpSCGJdE4u7neXSOQmgLHxXnlT1/ErnvnI+VQawAH3TIWu/BXfuQvjxGbYfnvEK6Cwu6HTucUVKstxi8CHKXXhbGNI9ygKbwsEOjnyF8bO2YpcFxfGDt5lGFM7597LcMwCMY8d6KaWYTJzQaT5IiZOMxVlFJG8QJZ8lEhGLi8s8+cSj9E2Dw8GQ+dk6/fEYrSMsGVJYFjozPHnyAq/fvuX620aKpFbzjekDtR8xGXXJzTI6dTk/jfY8RvfQeQpW0pw5QXv1afb2v02eWxYWW/zoj3+E5dVZ2ks10hyimuTF33mX3//quxjtGn83Z2eI44hGvU5ScxWwzWadw4M+IJBC0agnNJsJz37iSYzWfOWbB1ilfCsadyOaCs7ONWklMfujATv7hkeXY5JIMj44YPvyLbozMwwHA+b7B4gbXeafeJTW0SNEUtOsK4SFzGiEjEAldJt12nOrpLvb9PYUUXSElYV5bo+GaHIiFRPXEmr1utMiSyJ2tlz4wVpBlk5Imm3ipIE1lr1dJxHT7NS5evkDet0DRqMhUkhm5uc4e/b8hzwcKQU/+VM/xa/+H79MNkpYO3Kc9kyL/mTEzJEOrVNHuLR7C2Za39MD94dditwoaRCeHAGK6l0rXChCIl3YQhjPIk2HSWQBGkJYXyA8UyZ8Sx1n8KqemmesAm8PxToFaBSlXl9pLSgZuLCx4oQojECZ21g4u4X2XVjZeuHjKvFWxqiY+jw8o8UcEULDfkUR9h3CzP4ZcEnG2ouR+v36/ZQguzwNEVzbwsOuGt1pMxsWUV6MynbKcxG4MH2WZgUoVFIyGY8dblSqEJ+1xn7XffyglkarhYoixpOUnfUtkr19Go0aSb1Ga2aWzuwccRQjlWL95h1272wVSfTaAztjLXluEdYVuIQuDhKL8rmrSriuE9ZGaOOYnNyHX4WStBGsCIgt9IGWNVij0BYy7URkYx/qM8aQ5W7fw9QVjaS5JXfqsd7JcNdfCUFuQlmAA2laG+/w+twzKdG4/D5rHctsBXzu40/wf/2bv0BzbhUZJRgilEpQUcyg12X99iad2RnmZmYxWHJtiaxA2Lxo8YWFLJuQ5q7frlKJmxOyDGqNEh0QY1FIGTvWLnJ511Hd5RGOD3bIxxl5pjHDHCbwwEyD3YHman/MK9f3ON2u8ceONvitjSE7mXAyOf45TBTM1RXH52rMNRNupQZ5mJLnGRrBtVvrtDsNBt0Rk9GAak7w/Vim0jqCffH2SFhQwrGCXpoca0BjPbixfv0SOBa5dH57LnXEeNbaxzsqNiqM7EJGC9eZSErFJM1Q0lWaZ1nu5lhcODfPcpRSjuX1Fb2uYK+0tQWAK0BscMBdyoI73xIMFe54OI8QGp5iBoJ3jKfLq5bYPe3God+i13ywkQV0tCUwDde7vBwBAZbbLkiFamTHVmx9cQ/9vGJKC13yzn4b2nGzjsAJmr4hZ7UE6KZ6TP+R5Z4BoLHWVYECtabEpbU4hmRhdpHvfHuX889tsbB8kqie8PwPfZr/09/8b3j5pdf4f/4PfxdtXAGFlJZms8Fnf/iHOHP8JJ0bx/hgU2OVQEYxAgXkWJshJeSjAWYyoTMzh6pFjIYDZhsXQESkwwOS5gydzjmG6R6j/hYPP32UXrZDNBS0VIfx2EAORx+c4ZHtE2ys73J4OCCKJEnN5b8NBk4vrtlosH57m5A3paQTUa3VG5jchZVz5x84Ax1J5pOETiNhojUffS7mG6/C4syExmlNajVG7LJxZ8jOxi5dDa16RvfkPq+9fps7uz0687P0un1297scdodMJikf/+ij/Pxf/mtcf/cGw6GlsXic46vnuHX9FRQOFDRnZmk22wipmFtYZPP2bVq1iFGWYXTOmTMP8+DDDzHRmv29AyIlGfR6DHo90vGYtRPHqdVqNOsNGo3mVBgQ/4BfuPAQf+7P/nn+9S//H8zNNjm2usAj5+b4rS+/xLg3ILv6HouPPgQf+ey9P3F/6KX0CKUM/SydNIgIxkxOD9IwX0hZaj0V3qEHa67IALQ1mDyEWkU5MCuetrs+xeEQpAPcat5gBpdPlMc9zQ2Gryu5K0IUa4XXADaL3DopK4n9dmqLwaBML8GgVI+l/G3hNVYmExUpIr+X4jsPGAvdtLvR5rQ1dfsN4NGWCcqBoirzEZkShZaIQp/Q5NbpZ1oHQCyWer3OJJtgrEUpJ10R+hXfr0XGDZSxzM7Ps7m+zrA/QGcZzTyDfMKku00cJdRaLa5f3ybVOUJFWOuYOuGTy41ncMJ1Ebh8PVeV6/KuR2mGtZHLjRMWIyRjY2g2E1aOLRLFLg1Cakiu3MHkltS4/D6rwcQWhUMCaZ577cSQ8uE6grhJxbGFUkivdOrsPdoDAmGLidcEoIrrjCSEJVaSH/3YE/xXf/0/pTkzh80z0ixFJk2SRosoiYljSb3RZHt7i650KSquAA0wGq1zv6/IhVhVzUs3GRIVMc4zGv7ZsAKUL/oQRdw6Ikrc92k2IU0N3cGIfJAz2h8zOhg5+3qsw+c7dV68tsvLG2POLbT5s5FhZ5zT1QKtBM1I0okVcqaOaEGmJZ2eZi+KGWaW1AiMsKxfuUpuBIvtBlL8Bx+ZH8gSAFHV4XMDyuczWpe3C44tDT28TYUlC4U/IZTobJ57b3z3HeFZMbdpZysd0HCSUTZ3aQWhK5G1LqKX55q4lmC19lqArsDTdVTxz6DWFNYkgD1biVJQ2sWCwQs53aK8EEJMn5cwVSbQ29fwG4GbKwqvnRJ0BvsugwsuijESDGZh+wQeC0yhwIIo8HdlyiQXuXo+9zfcK/z5I/36d6cDmQBefUGiB+fBrmpf9PW9FIDA9wAARxNLLXHx+lxb4liihURrwXBk+Cf/5DX+TOOTPPHcInmak8UTV62a9vjjP/fTvHHxIr/+m1/hzOkzPPHoBc6dOc6nPvtpjr5zhav/ch1hBcqLvgrrTtQKDVYy6G5TbzSJogiBJZuMieptLDmYjLmlVcbdhPn5JuO9AbOrEUm6x87bI7pGU+8kSAEnHmnTWU64cWWXpFVDoJE2x+Rj6o3EhSGs5fGHz7G5s0McOaZtMBry8WfO8vrbVxkMxuQmQwpQWpHmwoGxziLffvtdepMRO4cLXDijuHJ5QGLmOdlS1Otddrpj5jptEqk4f2KFT7zwGCqJODzskZuEw94hve6A5z72cZaOr3D60U/wra98nVdeusjjj4CZjJ0+mhS0ZmeIawkC2N0/YJRbEqvBprQbNY4ePUKj02Hv9m0nahorkIqVo0c5efo0s3NzJEmNmdnZDwlHBoAVRTGPPPE4r/ze16i15ojUmMtXbvDA2RP80Kc+yesXL7P7xmvf2xP3h1wK+rsysIFycAa2jyB9IcucMv+bUvAzeItOTysY0xBGK3PyKEBQkStTUPBlAUaB2mTpiRcgR+Am+8rhBtA0lY8Yjl9MhzWDcZqCfHcBQLfF4H2WBuRDsgnhJKGwf9O5keEzyvfh78r3VYBbMnDBWFNZrzzpMkRVGsnQncd1MCgZW2Ncx504jhDCuH61uXVhv1yTa41Q0YfY6x/0Ums0CO3y4jgmC+cqI+KkSRxLcmN4/b2bfOVrF9G5QUQW10LQ4Lo1uTAwwqKsJyewrquGcDIu1lrS1GC1Lxjxlela52Q1xdWFJqN6HSUFh70xzHYQ24dkWnim0JAYi/bHar00jHP2XHWxELao8MTg28MKPy87Zia3jgkMOdROxNcUhYGtZos/9ZOf5Mc/+xzD9ets/P6v06mNSJQAGZMm8zTPvUB9+RwISCcTlIqQEibjlFwbTK5Js7HPF6sxGAxptmOUdkBU56lTfrCW3EpMbrCR8TmjyjHW1hDJhJ3tbfa2tohyQ7c/5mB3RJYaGlKwujrPsbUZZL3OkTt9Lu0e8GvXUmYaMTNKMl9XdBJoxgmzq8s88PnPcfPy27zxyuvEWJqRe25jC5l1IDBSoajs3nOvvn9LsCSCu0yDZ4Js0eElUETWjxeXh1e2HwQoQgbgnGL/bFRZJace4QqGwPUYDtW+wQZbY0nqTvhcxbHr2awNUim00U6I37rWdNggtO8Lbu5qixmAKT6igRal6SlAX8WGyTL/MSyB5XT7K7cpKlSdrfzCFVZQ7EcK6W5vxU7+h8zONBwsHf+p3OnCOa6mMvkjsNaBXF/4ETq7FJIxpmT7/KxUnOT0Wf/Hl3sGgJkGPTYumTiCXBhyk9OoKfrjlBffu8In19cxr0s+uHGF2dk5nhz32N+8xYNnT7M03+TNtz7gr/1f/jSDdBc5TKgpy1AJV74tJEI4BjAkkRubEddnGPV2Gc0tkcR14qSBySfMzOT0u00anQ6xkhw/eZbz51LuXN3kY4ttPvNQi1euDvjHbx8gepLtrQM+/fnHufDoHEvHN7hxbUh7pkYcK1rtNvV6jcFghBCWo0cXmaQjNjd3OXnmGFJFPPrAKWY6TXr9kfNsoghtDP1xysFgxCdfeIS4qVnZfY/jiwd0khrnHzyBYJn//G/9nzl45yLXPljn5gcfoBsJJ0+dRCgYZ4p6bLBGk6qYb715ncEk49zZMzz9kWdYXF5ivdHkzp1tBJJIKhCSzuyM64RhBcPBEK0Nk8kYmY1JajH9gz329w8YD4fMzMwQRRFLq6vMzM8hLexvbzI/v0htZZXgIQbRiOqEuri0TFRvstJOGF58k+1hyrPPPMT6v/4ixE16k+H38Lj94ZfiwRcUHlAYwIUZC3nzPlSMEVMendYBRLpXWQwh7+n699WhXABDD2BCnl5gTi0lYEIEod+KPlYFnBaebIUlY2r7VVNUbrgwIBXwNsXAhV8FIBeuiWdKC9ZPiLuMRAnGwvaL0EIR/vFglQqjWN1vOLficMPBlYAwhKYILIMtvihAKJQgOISWsjR17AGuOACbY5HkmcZqVxQh1P3rwlCv1VBCEEvF2tFj3B6PiCJFrVZDKMWtzT1eeucaNzb2GA5H1Pz1DB1PnG6aY2cKgy18KoJxYV6NC5cNU1cNG8CPtZZUW8gMM+9tUstzImOYRbCbG5SADOeka+NAmqQUznVtwXyw0lJI8oSJ0xfQo40uJn0XWnM6clYEx4giJeiJ88c4EY/48j/9p1xYGrG0rBCTGBsnCBUj99c5uPUGZvUZ2o/9KJPJGKEiokgy6HVdKFkIhsMhRltqjYQ0TWkKJy8TK0U66mGI+P2XRrRnLd3ehDW7y/lHjhG1miBARTWENYxHY4SMaS4fQyZ1EtGl1WpxpN2gUVOoWou9nR439nrMKUk3zbjWNVghOFoXnG8nrJ4+ytnP/DDN5RWeXDvCrVtbjDbu0KiBlRaZC7AC7UtprHVV0/dzKdj5Kmgrnqcwln041DOBonB+KZko6QS1g1lxw7LMDbZh3Hv7FAp1bFpGjYSUDgjKcvxO0rSwCVEU+WfPd1MpjgCn/4ez11K47iFVMeMiWlP5oHBORXWlae3S6f/C78LzLqe2544mRIRCFXH5dyFtE5xgQVU550NLaacrud7BYS9eqySBv77GlvfSO4aB8QbnfNni3EVxw0qg/L0t9y4Dg0Xi6P9RKlDKIiP3QEUS2p0a/+KXfond3g7bu1tIVefFV1/j0889x8QesnBU0B90+cV/9U9pnDWcOXGeF9qfIFlcwXAdi8BGCicD404lHfdpL56mf6fL8HAfsbCMISeOBcdOdN0gb00wosH4QGLjnOWlGLV1wDvpiG+PElZPrKCU4KFHj5PmhtOPLLC9t8ELJ1f54DsDFubaNGOIlWI0GjsB1ywnm6R0uyNGgxE73SGX3r3KaJITKYs20om7Cktmct69s8/x/QP6usN+3zKaDEnTCZP0EmcfOA66Q+v0Izxy/EHOPHWBq995mY2XXoGZOUY25sS5NUzcoTOTcGphHpEZ1jduklxM+cyPfIF8d5vb1zcRynoGK6bRank3xeskac0kzTHjCY0aZMMeWzdusri2ytzcPEsrK4wnY957803621s0E4l46DGOnT7nwgPGiSCHbhnh4Xrk0cf46//V3+LX/v7/m6cSwV4e8UB/n3w0ItaW5n73e3zk/nBLCUxcqAr/4JfctxtI3qQhDBgRRKHxTcP9qwifBWEpUXhk1WL8MM6DNAAeBLrIrzcUAcQJX115F0NZDHw/2Ms8vvJ1WqqlCsTK76evRbHlDx3rh2xTBaA5L9LctT3hrlhABtM7Aey0wQvA4a77UwK58gPh2YkCZgfsFyYcX2iDN3aun6cz0EpJrFKFbqVUijSfYHC9eLWo5sTcn6VWb7gcvsmExeVl9u7c4NbWAa+8f5udWzt0u30OIkWjXgPrbKfSLtdPCkezhUq9kDOqlEtDybQHtdY9UaG4wktRIqwk1671VWO3R9tdYnJgIHBiydagtW8lZ12nDESosShn+XA/pHCTcg4uWuDBugaEdfs2hGpQ18vXaxBjtGazO4bGIqjbpJMe6QSkipAWIus7Q4gxww++xe6BwRx7EBU3yHNLnmdcu3qJ1SMnyfOUPJ2Q53W0iNCeDRRYJpOU7sjQakvefW+EkEOOTq4wmtyh8bGPgVIoq0lqCStrRxFScLizSa0zT2vQJR1Iuvs5B3LAHdunO0jZG2vm45gnOooTuaZZj5lt11k8f57VZ54ibrUxeYqJ6nziR/4IX/niv+PG+hZOlFogrc9X98VM6ntowfV9Wwqnkim7IZAlK0YZ+cBWCz9KcBWc49DpB1yoFxGiIsFOuWXadIipz0JnLHDPmNNntMSx6w5iKXV0g80VFmSksMb4rjVlB5DgUIZjDYBI4L0V/10Z5Zk+bxHW/ZATXkGRttw2eGDs1wtzjtY+FUZUrl+YRKjatApxUCUm7nLgqw5/Af6giChP8Xl+N1LKog2li5L69DwrK3PXvS/3DAAPxzGtxFJXBqXwbc0scaRpNuqoSLG+u83W7pYXdE55+4M3sO0BKweWM2dnOPt4i839Hs3DZa7ub/K/9f57ZusnaTfrLrQZxURRQp4NEFjytEcS10mabdLxEDnooZRhdraPyW9T6xyweGyROKkRizqT4TI3BxOGT57hpd4h77+/xcGtLY6trWHlgPnZeTZvb4ONaLXqnDgD+/0DeluGer1Bmroqt9NH57h27RbWpOztHzIzO09zvk2jVuNQQxTFTrgyy5FxjZMPPES3P+Jgd5uVecPblyzHjyQ8/PBJdL3N//IP/xHHFgRREpONR+ztHLLf17QjTToew1VFZ7HDrRs3OT4ccTUZsrBygvHokC/+6j8hfuk6cu4oYnYWISTNTptmq1UIFJ8/d45b124wSVMmvS79A82ZE8dJBJx74EFu3LjB9RdfpLe3Qz7oUqtFdI6uoZJaQY07z2z6njujoTj34APY1SV+830NOzs04wkPzyV0exO+eunW9/C4/eGXIiQbEIMHFwXmqICUQtKkMkCF1zCQwWhSAqbATFkRqoO9FlX4bcWjxP9dEnDWby8AI1Hsk7ANIYqcr2C8CgNSBXl3edrGK+WH/QSDHHJ4psI2hZG2ICRKyaKy8W6DVTCEBes4PYmUV6VyjQIFO8Uillew6t2Wn1HZdskmFjNKOAd8uMO3+AJnFKPY9RHVWqPi2PUCzl3ukJIuud3eP/zHr//qv2a/N6Q17tExGS9e2+CVzQHpaMKSyalHEiN8sYRw4VhlLVq7VmkGQRwrktj1/h2OXTckKZ1P51IWwJVqSHLtrl2GywvMjEFHgglQs2CkK3TFgsIxi8Y64FhUEfv7bwW+r+609AdYlBQYpOvVjkAo6ZlCfwOVqDzDHlBqy3tX17nUEzz8yFNM3v8K2cgQx5p67FghsCQqQqoJG++8TquxxPzyUaRSjAZ9Dre36R/2WD12DKMN4zSn3p4hnaQ0Wp2g1Y4UkvFkk9On60z2LfXRhMl6j/jSVeSZ09TabReGj92YybMcWvNoe4tJmrF5p8+h0GRkaGGJk4ikHhMJWEsaJLMtjjz1LJ1ja24eSlOSJEHKhJVT5/nxP/bH+bV/+a+4vr6FxEluYFwepBbivj6D7r5N2xj33gOUIg/Zf2qhWiksRMjlnE7ZqBrLYrxX7OcUvhFQ5kSXtlGqIKzvLEcAnEHUuays9aBGlADW6Z2KwraF3Ozq4QWmVQqBsC7FByMwsnS+3TGFeSF4+iWYCqcRtjuFgQvwWOBCQCLVdF5etUBweru2cJDDhyH9p+p0l2WIgYgQ3j7612ArweUsUuYXFud11wxGuGf3uNw7A2gkvTGkiaRmLHHkQgxWCFIDw2zCzc09p+kXJyQ1xU//iac4HPbpZtu8eemQsx9dRL1h2T8YsDAr2cgPuLO3wcrZj6EPdlhYG3Ejici0BCuxWqPHE+rNGYaDfRIx4mMfn2F+VXDy1HkuXbrBuVNLKNXk9tZtRAyNRcFb793k4rs3WL8xQMUx2WGCiUY8/LQgSeosd2Z5+au32Lnd5fqVTf7yf/6XWVk5ZH1znxUhGW4PaVlJqiXdwyFZnvHQ2gq1iCL5PE0zhICTp06Ta81gMGZjZ5+BMpw9WuOdD3Jmoi1eufJlbh9MOL3QQksY9IfMz81w5tg8+c6E67e3yHLN4wvzfGSuybXVBru3N3n9O/+ew8MRyzNNTqwd58KpGSTOu2/MdEjqNe8hQavVII4TRkIxGE1oxw5o7q/f5PWvfZmtrU0G3QNnsGSEmJ0ljmJq9UahAaWUoqTIK1O7ELSaLX72T/5J/tu332NwOGZxcZalJcmubPGB3brnh+37s3jjMG21CmPmiaySeRKVX3pQVww2KqEv68FboWsVwEoJ/qZAml8Kg1iATv+BEFPDsvBiq4dt8blLFIO90IKqHLOKIqLKtqrVZGVujjcUolT5L9YN7ZOMKQzIFMALxpswOfjfhk4UJaosvqtqc5VGtORDCWGnyvWfBn3+nI3FCFOwgiL8pPCcLVlqXEs4rUknE0TsjGGudbnPKuv4A16aV1/myq1Dzp+c4fxik98ejcmy3F13IxDaPTfGGN+rFX+vXMu3iVU0aor5TuwkbjCuUIScdjvC4oE7IIwl8712gx5blltMpEgt5EqQxYIkd+xteOaMdYUgRahXiKLKF4TPKQ/MtcWxv2VZfe4ncGNBSacPqJQfHyJECjIMkGYp/+LffpG/+Rf+BDNJg9GkS90mWM+MxXGC1imRUvS7A/av3+SBJ56l3zvgcHcTKQ27mxskDVeQNslykmbHFRUAWINSEWtH52i2mrz4yhscXT2Cap9GbG+RH/aJjcs/M9ZpApJlpJOM6PhDbF58Cz0ac2gmHBiIahFRZGklFlGPsUqiWi2WnniS5okT5GmGVMLlsEvl2U7J3Nppfuynf4pf/N9+if3uACukT6/wPcPvMwNYOlSVv/HjFoo4fwB52gs7FzhIQB5syZTMUwnAAJ9uY729mvI3qaKkwt5qz9JZn5+pS7vkM08RReGEKP4VlfeBUZVKTduQYrclyCsKGP0YM+HZrYLSu9hBhAdlwaGhPIfqNaB4705cCucYQelQT4lwV+9P1SmuRHOm/7474kOAed4nDgLlptIGzxTapwEi5rnBhFvxPVQj3TMAVNJR3ZMcxpkXWo5j5jqKheMP8mN//7/jlS99mYu/+A+Qk31WVlv88//1Jdaeep6TP/FXGRzucnt3n3TnX7C/v8vakWVmagpRt2zufZ0zR96nWW9x+xHX6mfrTkajLpib36bWPIHONkkaW2xufofrNw7Y3mkz2B9z5Z2bDLt9GrUmB7sZjz09Ty4VrfYcw26ftbUaSQKtzgzt5ixvvnSJJz/+IM++cIyrF5vcuLTOv/ut30QIyczMLLOdWXb6huea85xZrfFPb6zTPXGc5GyNWhIVnhNYTp08xfHjx7h65QrjUZ/ldsy4p0nqMc8eSXjx3T7Lp55l6ckV3vm930ZlKY12kxtXL3GwUWc+aaIl1Odn+Ym/9MfoH/RY0pqfiBMWZ+f4zsu/w51bhzSTBex4TBQ1IBK0Z2ddToVnqHrdLuQpTPpkwz7t4ydIJ2PyLOVg9w7aGBAKZIyOFEmtjrWCWrOFz/ghzVKSuF6ZfUvPzmJ5+OGH+cxnP8W/uH6D7sI5hq0xH+wPuaPu38TrFltMYlVPDrhrIAnwEgPKVw7iwV8JdCsA0J1tMXmGAhATBl+x3eDm+4nQG7ZpHDbtgdnKv1NfeQNSMmL+42B4pjZaNUalsXWq9RTEnDEand3tpZbGtsBtomJyLWUItRKSKMGqwCG00oBlHrxVj68KBCunWL6xYfvF0VAEYnyXhdC7tBCClgJMEIL2TmGmwaeKGK2dMO19BIDPnlog1obBMOMtM6I/mZAoSK1rR+XU/yW5Nn6M+skJQaMWMdtIkCri2NE5eocDxplBakHkJxZjDHEcEddixoOcNBdEwoD7vyuAiSRjBdvHF8iOHyO6+B4LgwmRv7wG0HlI4rc+j8/rSQqFlL4lXQHurY/sWLTwzpBwjlUSJyibUY9jV/BgfVMAixeZVvQHQ/7nX/4N/tSFhGbDMh5qGnVDTcYoBe16E2EUIj5g49ZVXv/W71Kr1dja2GIyGqLynMMbNxEnjqKJkVENbQVeyRDlc8gW5zv88Cee5bWL7/Ptwx5PLK5xZGWBWqNNFEXo0OIyioiShM7RE9x55Cn2XnuFqJMxm2fkMgcpSFoNagsrNFZXUK02nZOnXSqMlC6nVDgnIxFgpACpOHruEf7Ij/8ov/5bX0JkECMRMkJEsc9TvX9LNX2kjIB4W+HHmSm6dtzlrFECBeHHHYSwfl46uj4Ma6ubnzoGB+7cdkptQW19Nbs2PgJhXN/1SvSkChyrFiO81xWAFciOECkITp/1ttzovHC6Q763taUt0pSOYrD5HvVR2K+KfQ2FkdMg0B+hLO3vhxcR7kxxsQpSoADYpb0P88r0xfXg0paH6JhVdw2MsQ7WWzC+J7ZSQU7HcndThz9oufcikDzHNcR2N1yqGqo5T24lUZKweuo8H/sLDzPa3SXe+E02diSLs5Luyqd4d+sI3Zub5FmfpUd+lMUPvs1TDzzDq+9/he5km+Ory3zz9y9x8thx+pNNnn3iAnLuEgsrOcePweryITvXG7z4eyk392+zttpGnWqh0yG1SUZHLPH0x3+K1978gEvvfJuDgwPiep1aIulvdNm6sceZx49z841bzC3OcNjdZ2Z+jsc/d5zlEy3e++J77Kcpa4vLNBJFbhXJfIeTMczUEwaDHnnuxJDdg6s5fnSN06dPcufOBvVGnTzLEPQQMubybUO9ZllcnmFteZmR0gz7PeZbCYaYE6ur/OTP/gTHjp5hfm2V9UvfZpxksLxCY/d9jp/9GPl4iweefA7VXMeOYPfqDvMdQa3WYfnoGp25Ger1GlJKunu7RGZCNuqTTlKSKELrHDSu+soaZKSQMiKuJUW7p3rD6WVNJhPyPEfJCCHCI1EOVnBA59TJk8hGnUuRhuUTfHDjbfr9wT0/bN+vJRBL4q4RWM1zEf6YXSUwhXHwW6DI2hOlkQiBWwmISJahCizlGJ3OycvzvACIJWizlT2FN6F4ojRC1WMJSMz6fRTbtKFXAqVB+W7XxIa2RNPgS/hWSlWP1R2nP57CKKni+AP7GTzVsNOQGWmtLaVopo+CMPkEj7xqsKcO3BaHUej4OWMfGAkKplAqSSxcx484SbzguylC9FgnOHvfFms4slhnnGmuH45oxzEPLy1wY7eP3T/wJZPWTYJF1wQPqqVCqogkjhiOMzZ2h+zuDx2YLcI+7ukcpZpaHDF7Ys5JnVin/ZVqSyYEKYI0SZifa3BLSRaEkxsM1bqpNuT+WISUGC82jTAlE1LSPi5JX+CZO8fySeHC1TKLUHHsRYHLVlvgngtpLTvb23xLRpx9tM5krIuWbULUSBIFCFbma2zsWw4379BstpDvXGJufReROVmQcatBtHDE54CG3KgcFUUInLZdqxnz/DMPceXaOre6I46dWCNKIi8F5LqXRErRnumQNDu0Pv9jvNtpMNjbwYzGWBmhmg10HNNePIKedGk1OyS1hEH3kFpcR2MRxvg2fBaXS2mJVcTjz73Apau3+cZLb7jnTylE7lqd3c+lYLLcXyXj5L50Y0eWrHzZ5qwEfrLKFokQIo6w4NJPcoMOBW/g2sN5YejgTdogB+PHvTHu+QhtNF0qjkM0VpRgq2oTCspBBDsZAJxFGIEVIf/dseMBhBWpLSI4t+7zaYHr4GSK6p4qTnT4rSybBkzZ6KpTW6a4VAF4EbrFEpKly0hOpTvL3Y7qFDMYSIxyvpHeGQvkxt2FLRJRVGpXb/29LvfeCs4aYoMTK0ZCcw555jOYzW+SpTl3Nnaxx06w9mf/Gt1Ln2BhVEPcvkW8doru3iHzJ5aYO/YcZnebx+YNv/t7X2RnY5scS297i6f+yHk23j/g5KkznDyzyuUbN3jja+u8ZTc4efYqn/jcI3zq8w2++i8n7G7BO6+NGQ9HnGlGPP/Mx1hZOU73vGBv7wNmVy27WwM6C02UFnA4JBtPmJlvcvLsKut7m0yGOwyGPTozTf72X/4cnZklbn3jdzl/rsWlvSbv2vMM9vbRt28jZcxOd0RmXW7M/NwCp0+fodfrcbC/z9LyMnHc5M71TdIsY7ZT53e/vcejp2u8dvE7bB/ucObEMZ5+6lFOnnuQE2uLPPGR57l6bYO4LvjqS5d5+5e+zP7hgHqScOrka3zi+RNcutFnmM1z+8Z1JtmYI0szxFZhv/Ui53Z3WTt2nDTL+Na3XmT9+nX63UNEOoZ04pJpjfHenCKKYlScUI9jzHgMCBrNppOUyJw4dp5ngC308qoPlIoUz3zkIzQ7Lb721mUu73SppRmZuM+JL9N82vQiKAYKuHBQGJYwDbyMV7kXVnovGadxZSuJ8sHAlZsvvUxvjKIoKjwvrX2P0sIwlMc8xbhR3WBYpSz3D2ES973vN2wp5BvuHt8fCnUXWocue3HaG7VTRkZUrlsAd+GYq/kuhbEOoKG4PrYE44WLPP1a5iqFWSTsx1+nIOTsj0sKQeg3FXr+IoO2mSGKI6eXlbnOE8Zqn2t2fxZtoN2qUdMZCxoasWGpIfnCL/xxfvmX/w39W1sIY7HSh5i8zpo1OQc9GO4NETjB7XCZSmfDpQUInCJqTUKWayQSKV2dvs41RikSa5m7eofu9U1OGKcFqCJ3R6SKML4S2E3IYI12ieyiDOVVJ2Mj/QSLdczeTINUZ4haghmOXGeOmTppblzBg/9dlW+42cvZGViO1V3o3hqNspYoqmO14fyRJt/ZGnDpvQ9Y3Btx5OYu7dwQaRjN1hhtHyCW1wBfSCJcU4AoqbtHRzjHLiLn/LkTXIgiojgqJn9jXRcVjaDZ6oAQLK2ucuaJZ9jZuoO2ToIkTTMGgxHZZEi71aY5M0uaO2YwbjTJ0zEqbmKsJUtzIpURRTVsBHFc59mPPMM7H1xlMM5wIXuFuI/PYFjEXe+n7aLlu1mL0tWl6DhTJFoSHD33PxVHxNKNbWOmh3/ZIq7sbFSEYymfaSkDmPNHEExFRe/PMV6lHQs2NnwXpLtcW3bXEacAcFVQ5H9szN2h3yoDWAXP/pyts/TGlmDNipKbtBWtv8AgSiGnv/d27cN239+K4nrZIkx/dwi4jLKUDjKE79w8U6bzuHtlilSdoE5x78/hPQNAIRNqzUXs0gWyZBk6M5jRLsbkZMM+1y+tI00btbDIgXiQrc0d6nKBg2/+GklfIJZPs729yUo9p3v4PjNtSf3UMTrzqwhyDrdzzj/8IJu3rvP1r7/N7FyHhScsk5Hlvdd2aXbf47/8Tz/Ln/mv/wj/zd//LXb2JDMLbbYP92Fwmzvvv07cXObCA4+wv/8+ncYWTz46y9xsh2/8/g0efuo0450J3YNDGvUOcZwTETHY2ufwxiaPfP450mGPlVab4V6Xoyd2+PL+VV741Au05mb4l7/229y4sUmr1eL8uXPEVnNnc5soTtjd3aPVaHJkdZXrW9usLdaxjKBW46HzF/jChT/Kpz7+NElS4+VXvoOsN/nqb/97tja2mVtc4txDT/DAk89x8Ttv8/orr7NzsM8rL/ewdom3r19F4ASKpRI0E80//Ht/lwinw5gZQ284JDOGldk2KzMtslEfk3bIiTBWkSQ1YqUQJiUbTtDxHCpukNRrjMdjxuMxtVqN3DfkdqEiCnATjMbRo2s8//xz/PN/9ku898F7xJEqFNPv1xIYI2tNRXjdFAPMAQqvJWfxmlABuwRpEVdd6l2qIoRrmdYBDN7kFHFlq+CsND5SSs9SVKRfPnRt/sM5IAXQEi4J2q895SFXtzEV4rU+F9B68dfcFOAiGMjAZE4dkZ3ecnVPHw5LhM+mJ5DypcpGVM+8CHJXLqwt7lfV2IVX6cGrFAKda5QU6MyxVphQnRiBxVUMFszC/VlspKgrAZng1JqidqPHuxuH/ERnhr/xV/8C/9Pf//+SDbqkylX7qlqMNDl1aUiBSZoX169IRSikOmxxr8AyyQ2pNh78uQ4gVmtsTZEpwYywLKUWo2AQSyLP+qW5IdMao91FVUqSaveES4pUPl+V7NkEIXwhiGsTF884gXgZxy7XTcVkzQbGQD1PcZyeZ8esYzsPJoJX70w4ulAjzbTvGiIQMqLZmOHkkRpHr4954/JtVC9DGUtLQN1aDoUlSYfEyrF9Qnm5HGNRMvJMkrdP1hL5bjCRlEXBjasyFeR5TlyrobMUkCweOU6t3mQyGWF0xmQ8IVaHSNEm05qZ2QUOD/apz61gdEZUa1Brthj2uiRJQmYgMhTah6fPnmNlcZ4rtzax1pDhw5D3cQl2I3TuKJwqU4lYmLKXrhBBb89vYIoQswUgMtYgcExquWIYso5NtoGN8hS361gkC3Yw8I5hCZJOoetSYLOmAGP1X38shWCy37fW/hzDkVUBXfF3CfzsdwGABfAT4q59lgSBqKQLuTUqDOvUtqb3X7X9IV0o5DpPsQK2BIDhfXHfwiQEFMUkQY9RO8UDHVKR/P032mA8EQH3Hg35HopADFoqtJzBNo8SS4PeewMpBIcHfdL92wh7AbvbZaFuuH3pawhpMDdvks0scnjzPSa7l1GzKcfOT5hbWWJ14RRKTXj9je9w4aFTvPXiuxx9QLN/8ZCzzx3hnXcMTz02y48eX+GnPvkMS40OWa/H3/7PPs3GGzeY6yRs3Gnw2NwmB7NNXr21wflEkyd9nv3kSdrNDqrR4HzUIF5qkT/VRKsaM6vLjNMJ2+tj9t78Ble/dZFzdcnKR8+zs9Xlt3//Ko99LuHbb23wn/zCzxDVm/zzX/q3NOo1Tp4+zfLiAgdvfYd0d4/66jIH45yB6RHnLfLU0B1AkizRqSv6hwPOnDqKFILe3hZL823qrTm2u7dpzC5QTwQnTxxj9fhZvvDTX+DbL73C3/t//Y/cvpmiky4b6xucO38WFSfMdBJ074Bxr0eqXU5RZi25dYUpjaRGu1YDY9B5Sm412lgSkZPqsTOUUUSm55GxU9lP0wFSSvI8Zzgc0mq1iKIIpZw0RQkeBFJG/MwXfoZf+Ve/SpZmTNL0vle+GWMQJjBCgkDBC1NJoK0MLmFK41Wl9ENulBvMslinQkS5yadi/MJyd84eQkCeQ5a5SSmISlcBXvEbZ3GrNH3Vgw1/hzWnpFqKY/IGzJ87VHGanxS8p6iLELXxdqQ4OQpAWHE1C/ARtl3dP35l4Sf+wpBTspR+HQ9lirml2EcFWFrrQI8tWL9w/BIhrRdNlmX7NB9+csG4HGN9zpx1hST3a4lkhJUaIku7ZvnoiTr/6KUev/3bX+RH/8jn+S//1n/Br/zKv+LaxjZ7/RGddozEMhpPUFax54sz3IRYZQjC+dsixJVpyLUh936FkoJRZsgsTIBMwBELQ+BAmNBxDot/xgUIJLVaQhTFCAyJFy6WwhL799r4fFYlMRZqSczRtTWOHRMkyrDT7SGjGkfXOkQqYTLYR1hdghAPNBSWGyNYP9A82AabC4RQIBQiSUiiOk+eHvE7r9xAWjieWjpCoBSc7GX0R0OIXNqGEi5VRUoQUqF15p8b48TWcQyrm/IssVQIIREa0swVV9VqdSyWOBIsr66itWE47NI9OHT9pdOMuWaLKIppzSwQxRHDfo9Go+XBicIK5+ha6+RoqDVQccKTTz3Fu9d+A5AI4wSq7+dSaMZZWzivhRNc+lju/ghcn+QCKOKBnClGawFyvJ0oHb4yDcVaipZkgO/kAVmWEcZ90PGzeNkSb0Nd+zdTRJhcGzpRONU27MVjHovbV+WMS7sbWEQc6EcEPVa3FXdW5Su2zE/8bo55+Vmwa/6crc+xnnJpS1yGtR/qvlHOI9MOt7VBB7VyLpW5oQSE099XN2qDoQj22v9d/uR7c4TvvRWczpkcbpAMfpfmQ59mopuA66Atag3WjqyyA+RJncZSTradMhltgFokv7ZNPJcTN+o07TbnTj7GV770Na423iZOJLsbKYtNy2JL8vCZc9SyK3RWJvytT/4QK4eCcwuK/sY66ZHjbLz2Lpe+dYXYTIhOL7E436I+t8QjD9R47Jl5xusbrL8McV8QTwbMzNT5ox85B8MujSMtBmPLW90+//Y3vs7zDx7liU88wfpbl7iyO+Bob8KXv3gFJSacP5mhW4L/9v/2d/nJzzzFYqfG2toJ8izn6vvvMtrcpBbV6W3vEvmq3E69yeG+YvfAIGLBO+/vc+KBWX7pl3+NF557krOnV7n4xmUm6fv89B//4wgruPzmq7Tn16i12vzGv/kN+v0ez3/kOS6+fpH9g0MMlvFwwrUb73Hq2DLdWzdJtW9bhh+aUtFuJhydbTDbqBNHNR/+ydDWko4haXXIVBMR19HS9RYNHSLiOGY4HJLrvGABhcjRWnmPrfTSLlx4mI9/8mP85q//pksYvs/q90UCr5TegJWMnGMxXA9gYV3wtPDkgJAjV1Y9l15c4XhRtIksvD9ry5ynQnalhGEV0GhIs8xVA1QAXTjucnF7CjksNlzfYPhsmWdYDvTqz8sBX4FZfkcU21VSompJJcwQQJ4tdAAtU6czHY4oJoFyv+FcS8Nd7nfah7dFa75pABjeuuMpcn38+QgbZFDKfJxIyaIThjDuBpkP9Ty6++8f3JLlrqOB8TqcDx1rc+ztAV96/TLPvvBJvvAjP87TTz7EpUvv8f71dXoHu6S9fW7c2ebqrW32hxMsgnokWGorZppRAey1dhV92gpAkkSSVr0GGBeWVYJ8lJHZnEQIllNLAijtxPoTLyXhKlctQkZIDEudOs0H19AWlJQkSUyzHtOKJUk9Iq7VqMUxkhxtJZGK0Spx/Vp1zkwzoRbHZLhjnZ9tsrpQI00zsswwHOekqcboHK01b+3mnFlzhYNCSrQQvkJac2y+w9nVDp1JlxmR0lQWJcBiyLcPsbETZ09iD1AKIXM3xqwrK8UIqNViFIJIRIQirTApapOTxDWkNcg4plZvAoIoVkSqwWjcQ3b7zMzOY7Qlimtorak3BXESk06G1JotrBDEUexkiFSCNYaJ1uQW0hywucux/F77cP1hl0IwztshW07/YdxVialCA7USWg0s29QPhd+0Z/qKjQSjI6YZPMR0bpu1ToJIStcdJDCQea6LCEyxui1ZvlIbs8Ls+eN2xxkAJRUWr7oOJdtX/X3lFKi8Vm1X4XKL0ENEFNcnaA4WMDHMG1Ts+rQJ9qcWrpstzrmwh/4l/F2A3xCuuqvlaLDL0j/3U/NFWE9QtMC71+V7KFsypNZR4Ka7B6xj9RikJR0NuHZ5h0z1MW3XrePxH/sYb/7P/xOqVUfn0O4PqaeXODAD3nsv44/+3HnmZht0kkX+xT9+kUcWTnLHHHDppTsc3O7y2YUTLLyzw+b7u9QfXOXmax+gxq9x4anTPP7CaWrzdTonjmO0Id24Re/tbdonxyTNmONPt9l/+xK3N0bsH66xkisaDz3I1pfeoL60yAMNxWeiOsvv3+SJP3WGVz9+iqsvvsXtjWuceljx6E+dI5rb5rNfOMfyywNOnFnjR+bn+PrX3mNiXIhlR0QcWVnkcP0Oi1GENZbnPvMCa5dvsnHrFmfPP0hjfpaNW5fYunaZf3X5XU4/cIEsU2xu3uH27XXSwQFpb5+f/rk/TWdunu+8c51bN28RiQmH3UPG6YQ8y9jd28Faw+HGHdJx5to5CRBCOcFja5iMUxIlaTdqxHHkEr69eKyREkuMkTWkUFgr2NnbZWtzk1a7hdaa4XCIEAJd0wXzkmUZ0V2Vba1Wk09+4hP83le/zvbOzn3vfiS94jxK+onBh3/9wJHB8OH7yrpu9X7w+fADvg2ST14OxQRujJVgULgdTpNgwfDgGYjSYXWfxgHeVdxwEYyl34QHUYHNMMaQa13Q+2VIuAoEP3wtgrdbNfyVL10oRCkiz+S6fXvjqNykKqYQYNUD9Xv4EBAMRp8PHVNp1Kf/DpMTxWtpuYQHmwGmu/Ck9K2ibHHdlFJOSDnys5PxLf2URJsy6ft+LIPRiIiEjAmiHjM7k/D4sTbvvHnInaFhMMmYmTvJox85xqMfMVgh0fmE4e4tXv72N7n41nv0+gNmGorZtnRtNbVjrLJU0+2POexNGKYZeWbJcu3YHmkRjYTdwxFgSYSg4Z/5moDIwgz+GbauMMPJcTj5qFY98e02BVEUUWvU6bQSGo069ZrTclVK4vSjLRMNeZ4i8iEnj8wyHFm6E5hkGTpNifSENM/pp4J0knq2xpBry7vjnMf2LItLEo0bi8JGGGC2UeNnXzjDt/qX2LMw8bqJIlaMFCwKSCIXgcA4sE1gGnFGTVuBsjAZjV2nkMkEbQxxFCMjBcaircbEhiRWKBGjlCtuqNWbWKHoj/oYGXNzY4c0M5w6toIQme9MIUhoIaRrdWatRsoYKRVZnoEQrG9setFiQLuin/u5lADIzf6h2rwMW5brFQArgJ0qCPTgu+xp7sd3EODzqGdaZNg/Y/7eFAiEkEMnXW5vqJgl2N+qM1yGd8utUqzjQrkU9rMAhlXgJ8TUORWh3sp2qNi+sI9p3Fa1jf64wnZFBVhCgbaEqHxWMI9/wL2qzEvTrIHfTjEf2JL5852CrLUIr62IFUgkNuikhltesbk/kCrgSDo9K6EMWW+DpJn4i2PpHxyw+/5raFMjWj6CGfdYmTHUxTpL+QatU006rZRGomh1VrhzY8jG+0MGc5pr792m02rS7m7zVx5cZjKX8PZLBl495IPRJuNJzvs3tvmxzz1MYyGmbUeYLuy/v8749g5Hn75AOjfD9Vev8fDqBSYji9w6JFmcR91I0e+sM5xrgX2XhpDU00OsVZjRHr/ytVvsN2b52Kee4fA779GsdznzSES9dQ1bW6EzM8+Dz68wGFiufXOD3tZ1hKozTlPOHVumOx6idc7JY0fY3tnl7fcu8/jjT3LyoQsMBiPm5tu891aXg+4QJQ0H+yMMgr39ffb2D4iEYHV+hm//7r/jYGudhtIYnXI4HjAYDJlkGbESDHoHtCxk4wnGWrS1INwErq0LlWXAKM+JIlk09zbWJYzr2KnqC50j48glgkvBweEB9XrNJ4q7cn0XctN+sBi0doaz8ijzI5//PL/0S7/IeDJkb+/+dgKpLlOSLAXIK5kpxwiGMVZ1+fyvKt7itFtaMQsVQ1lFPRZKhstjkvCN0yMsd1YCv4r5lDhRalGGn62/D1objNY+n8MWr9Pbs4X9KD68y/VT0oFkJZ2gdzDG0+Fo/3NKw2MLwCdK4eowMRTrM3U9p/YcvFaKurjyGpdflkAxAGpfuOTuJ0VvWteByDiA4gGMtZY8066IB5DcP09kME6pCbAiQ7cjpBacXKoRyYivfuNFfv5nfxIZJ0gc44GKkbrOvDT86I//FJ/41Gd48+IrvPrqa+RoTFrKteTGYGyMJsfajNxfE6cB5p7hnb5moWPZTgQ5Tj5HSMHQwNBa0P7yGc1wMiHTEqkEMkuxIkcAtVgyyXO0bjJODbUkJY4EUeTFtYVklLrq6qWWJZ6rkbU0w40he8OcmnJh+cworM4xVqARWC183qHkm9cOeeDELPNIhHVdnlQSQwrnji3S/okGr9/Y42pfo0VMUo/Y7Wd8TCmiOMIagxKh169PpTDSa0da8sGIK5cvsbyyyvzCHFEUkeUZUcGQu64StaSGVO5JlEJhZYRlghAxL77yKi9dfJfBYMiPfOaH+OTzT/siGIVNNLnOwRqyPCeKLda6doST0YDbtzddKhROu1Hq9L49g1A6a0UEocokFUO1dE+dzQp2wk59NxXVCMxexca49IsAiuTUmBaiKmnsXkyoDJ5ScQ7VwuG3ZcPdu4FWwG0lsKuceGhJVCKyyvvy1IOtE/auz/wHpW0K/5RXDFHJc64uAV369e+WOp3aqL+GYYVKNiMVItU36A73swIAKXM5q87y1O783FPkwxN+e2/L91AEIt1EEjWwyRm0PiAS+1htaEQp3Uuvk924TtRuMd7bYK8d079zCxGP2byxw+raHH/sZ36Kc+dP8ouX/3d+45ffZ+1cHT3RPL2wwMLpM9z4YJ2436MdzdDs1FhYS5BJxBdf2WS4vs7K/BomaTO7YDg8aLP1wQazc1epH19m7sEmuezSnJuHhfMMLt1k5slj9HoZL/77Swy6V3jk8x/hwkqd0dWbLCpLbZTyq//8W7z96k3OWWhFgsi4cIQh53Si2dsZE9faPPfAGY7Xx9gsZWmuzSTN+MXfeZNaEjO3sMRwnLG7u4+UOcOhptVsYbIxTz96isGpBdLcsNPV7G7voLOUpeVVTh9ZZGWuQadZoyF7PHNmhidOPAhWc/X2KtfWd3j1jSuMDw4hd561RjjVef8waOPYAa3c55nV1C2+O0IAFGXugFCKTGuSWp1arYYF0jQlz3Pq9YjRaESz2SwGfO7114IEkLWW+fl5nnvuOV5/7a3vNkR+oIvWGnSOy+mQhaHAWte2yg8845kRo0VprCi9IxUYMBxKdKDH55PZEqsU3lTFO/wQkKQcmFWzWiz27k+nt1HATW90lJS+z3PJvJX5hG4vFl8MEXZx13UKXrJLnDZOkuOutYqkcSgEqIPw81QuSjDQoryOf1CcIdjIMsG7sq1gDyvo1Wrj159mAEUkytZwVrruFnmOlQbjWT93ae2H7skPcsm1wYxTBBN0WkPFimc+/jnm3vwd7mzusLG9x/KRNXIDsXBtubAC1ZjD5kPaiy2e/egnSWox77/9HcaDbYQ1jEYZOjWkk5Q8TZlMcsbjnDTPHSvnrhbHj8xSbybYR1v0rCBOFEkjYmd3zGi7h10/pBFHPH+0SUuOGQtFLYGZdsQHk2VUrU6rGdNstWl3OiS1mNjLRPnySqQQZLkhy1Iim5GOh/QmY5JGzLwdY3WONTmRyqmpHJnmmNwgyTk6J2jWLb29MbuDMSeMG7NaaoSMULJGpAxHlxTH1xbZHqS8szdiYxLT1fuoSLoohsmLPORcu/ZgxhecCAFxLGnWa6g4oVZvUIsjl4Lhn3mtNbkvRBGR74YjXW7hZDjixvoO88tLPPHYwwwHI0bjHGMhSiInNzSZEAGjyYha0nD933WOihS3b90iynZ47lyLq+kxNArdu3P/HkJKwBAiEcW4NRUM4HP8AvjzndMKkBKwTFm44fvN4irIC1AphK+QlVhfZCBC8Y31KTWVQVgFelPRhwrbFuxgNdw6FZ4ubI476OJ95biLbVW2Q2V7iLIghO9yPFR/g3CFWLaycQoL6HcW9jcNWj9kfzwrGOyaR8XhxpX3rnBWShBYtHrjrlcrnO6pydGhYCSkjhiwQhTA+16XexeC9l6ZmD/PRMxgM43VI3IxdOKhmzc57L+FFQZsTvvYg9TrET/7hR/lW195hb/xN/4mzz3zLL39TRZlmwcfWOKxj89w6+IeZ3oTnoyg9dgF3vv2u6jxANptTj6xwvWLW3zm+TO05yP0KKN/5Q663uT4+VX0WpMEzfD2HnE+YLx/Bzu/iIybdNp15JWrNOsd9PMrfPMrY6Ioo37uGJuDDN5/n85KizMrsyzUBUm2yHi0yXgg6W8mZNRJNnc4uge7ueSDGwNa7WXS7i3q9TqDSc6xE0ex232uXr9Js9VkNByyfmeHVqNDo1Enz1IOByM2tvtsbh8ghGTY7zE7M8ODJxZ5+Nwax46uuBwn31i90agzHI5pN2psru8wPDjEZC48qCVYnMimEys2CGtIaglHVxdpNOvkWjiG0Lok8ELfVyhEFCOFIM01Sb3hJDSMYTKZoLV2SdHjMVEUkSQJSimnD6jKamBrDVEU8/DDj08BiPu2eO/IWi+MicV4EEwYcMb4HMByCYM2hEGc/EHJSOkpT9jnfVjXjN7YYAinXMmKx01hgAoD8Qcu3y1PIxg4WSRJC98J4e4ikdLBq1T7FQDRMcLGuEpJZ3fKz0JFmsW9lqDOC4gGwyulv9bG/75M+HfXU1YPnZBI7r8sQF7J/EHQdSsAYOV+KqmK3D9X3anchCUkwncpwN9n55woFxamFIW9X4uVgv3DPouzNfLUUJtdY/Gxz3Lq9CXeeutdbt7e4JFHLrgUAxuTSNdvF2sQtTl0nhLVJU88/TEeeOAh1tev8OrLL5KKMbUop6VSRDQhqedMJhnjNCXL3bXPjaBW0ywvznDmxBIH3RFJpGi2amwObyOTDOiijWH1oRMszcXIOEYpTa3e4MarB1jpJEuUit019zIfAUjoLEObnDwLvWANuZF4DIYVCiusT0OxCKs9FSL52GNtLpyO2N7J2GtL5mcSB+ix6ElKXO84iQ6lHWuoYaVdZ7aWsz4YMpdHNElRUYKwjtt1DJQmEhJpIbeamoqIIsWp8w+Q5bnrnKIUkbXkmZOzEgiyPGeSpkRRnVhJhBWMRiMOewO++vvfJKrX6bQ6SAWrq0scHHY5fvwovgwCbQz1eot6vcF4NCSdjGk1GvR7PfZ3d7llBHf6AwwxzSi7b88gBJ/Kj0lRjs3gKBoPMgQCbylDkySgHPdhawWYwYKQPvRtCzAkhZMkCmyj9vniCFk4mBWIV+TOfRgAhrzDMkc7fFfYI4+pyly+YFvvBoQlYCzPqQR1LmdOlDaicky2oODK34bjCIUsSFGoEoRrXgI//0/V9IgAzN18Uc4wlHZRlmWHxRQanPtK5GVqajUW651eY4QrhPT3VBvnGLnCFMH0Af3By/cEAButNjp2DFJOhBWz1OsDEqGYizSiPeaxJ1aJaoKrb1/FNg2T0ZC/8vM/ysn5iPFkxOvfeZcb+xs8+5lZZg77/NiJOd76xm2++cXXGWSanUnGeJTy4IU1zmwvcPzCURqLc+TdIW99/S1qRzrI9gLLy2skR3JG+3sYldM49gjsb3C4fgdVy4kHOULOkSQtVD3jySfO8tBnnsHEOXtC8MIXnmHptWvc2jF84sefJ5mxDNc3oKa5cfEA01ri1o09+tc22dwZo2TCoz/1p9niIX77d77CZNSjs3CMI6rHe+9/QK1eY2l5mQ/ev8zHXvgocRJxpNNG9mNeXt9m/2DAeDRkZqbOo+fWWF5qc9gf0+n2aDdqTnE+jrl4fZ1/88WXuXV7kyTTZNZ5W/XZNv3RBIQgG08Kb0IKyZMXTjJ37CQdZaHXI7c5ysbggVDw3sCV9mugXq87FsyzKuAquXKd0e12mZubQwjhc5M0QVvIhYoFDz98geWVZa5dv3HPD9v3YwmJwChVsHiFDIhvdWSoGITih1Dw6MEoCZcLKFVEzReVQEX2Rbi8mqq2k7h7wOO2W1Tdatclp6xE9vstNumMk/RdSsJrtVilasDcr/22QrNw/90U9K54o6GPsQLuZhEL5Fo5lupn015p+Kc0TgZb5CqG1+L7YIynL025Xf/qrqvPC/MGVvkCHVkYYQrPWgjpmO6qvxGuo5AFOL1fy3Z3BKlFG5jksPb459FJiwsPnOXV115nlDltzTiO/TNgSdOMRk2hTWDzJHFjDqUiHl44gpB1vv61rzAZaTddSwXCeOHbCG01VgukdIz+ONXs7PUZDlOMMahDVQjwWgu5sVzZGNEdGQQThBJEcc4kF0hpMdqxCS7PV3kAZwqQbgwux9aCNsKljeDyA/M0Q+scgcszRsYIaTnSSfnpn3qQtbV5dm7f5sp7d1jI6i4fWVqEl8UxSiJEjSzPMFnOYZZjsKzMdlipa/obb5OlPeqzCwyWzmGs30bsxrtSMQiFQSKk6wajtSZqNACL0bZwfoS1ZFnOJHVhapPl7B/uoqTkJ//o57ACdvcOeOudD1hfX+fCuVPEUcR42MdYS61Wp9FskaUT/u1vfYlemvPp55/m+voeozzlo+c7SJHw5o2JL9y530s5rkLecbBWxaj2YKTq7JVIMKRp3DXmrSkYQERwIksHz1oQUpBnrmuILGxnJfHDM1TeU/Bj3ydrGz/Gja1U0Zb2qWpnA9MlEBVGsmpbRflinVMSfmz8DwIbWDCLARZ7WykLx1tWnO2AQim2VwDaCigtlilbendeYBXQ+bC0FcUVcxssLvYUcCwY3OLvu+eT0AnEXafQxeRelu+hCliTjieMDl5Hto6iakvIqIYUCUdm4ec/mWBPPcSnn/4ZvvziLn/qk0MeePA8L74z5KkL58i33iLdqvHWqy+xdXObzhuKjy4m3Lp+m59+epVeN+fqrS0+8dRpbhxkPPrAMerNhE7TYGqGsdXc0HV+/MJJSCDr7lHvxORRh1q9S3L7fcbEdFoNanrM1nsHbG4OOP8TT7Jmhjz0iWcZ3dnAbu7yxAPHSRYXWTULLI9zOiuCKJrQON5Azc9hmk1mVczjDxxBi4fZeecW13ZH9PM+J2fmmB2PePZkh2/u9Hh3c4M8TTlx/DjLq0eYaXcYjkbUGjG9XpdnHn+EM0eXuPjOdfrjjLcv3eD25h67B30efuA42a0xx1cWabZa9McZ/+bfv8SVa7eIhSDSAm1zRC3hyPFjvP/BFSbDsffqLHGiOLOwwMFAM+h3Wc1TluKELLdEyg02ISxWRggZI8CFAwsPyj1SURSR5656L4kTjLEMh0NmZmbA/yaOg/6WRomYhx5+hKNH17h2/eY9P2zfjyUMTpfj6MAHeF2zyHttyg0AWQAfKoPCga7QVid4sMbaIhG/4ogRQgfTRuBuw+o9ZCmIVFK05fHQqfhdBUVOgb0qcxeO11g7FeKtEGkVsDMd+imPyb35D4HV8DujdbFuOJeCUQjXwH9WNXgCV0Qg4grK9utWhUpL5q88B++f+3vmeUMT8nT8JCOMU/5HgHAJzwHQS99b1/gwnw1h4O/B6/3DLuk4pVmLXJu0Iw8hjzxEvdnk5IljCCF46513+dynPuYYKRG5PEqjQSRFTpSUktwKiBpIYXjwsY/Q6nR4/803eOPiW0xkRhIpjDYorYmEYGI1RrvrNRprusOMLNPESpClOZMs99fJoo3l8q0+m7spUaKIo4goMsRxDRUJNJDmGpVmBePs+8X4+dppuhmbuydJuRxSbQzalNfaIIGMWFkePim58t5lssEy5554jIXZDpvf2EbhQ2vC5fJJ6/IaD7tdJrnm/VuHXN4dcny1xUeeeZisVmOn18fcukSk2nSStmf5XHs2FSmiKHLPq3HjL8syrLWuG4cV2NSCyb2jol3Y3kxIJyk6N2R5xvz8DM1mi+NH13jw7CkOByOWlhfJ8wnjyYSk0aLZaWKzjPXbt3j5rQ/4yFNP8o1X3+Kdi+/w3o0JL13ucaQpWJqr8dDxxn17BoHSIODsYtEDuIB0lICp+ImXXCoYM98dJNBrBGHhUhbGVZOLogtM2IW1IFTIGSwPKzhvpQl1NvRDRRZ+ZVFZ78MpJndl4v0HmP4iF++7fV1hBaeKSUKBirUYq4u0J/H/I+4/gyxZsvw+8Oce6urUmZWVWbpeVT2tRevu6Z6ZngGGMwNidzkkASxJLGCgAJdc+YG2H9fWbLGAkctdI5fCuFwCJEYAI7pH9Ez3tHhai9K6slRqcXUo9/3g7hGR1QOg2tBdjGevMu/NeyM8hB//n/8553+KSJEondDi+pTXu8rolaEN9t2DcoCVe+XseGFvKRcdXfms22XxN2HTunRF99LZXG11AJWJNjzk9vAAUCuyLEXpFN1bQaZDvKmT4AXEic/LX/hLeBOz9Fbv0L3+Af/dt27zd/69v81Me55PLq9wuDPPdKL4Nz93il9b/jLvAWVTgwABAABJREFU/egSP9ro027Vmdrc4fJGxpnDMyweO8C9i6tcfO8coxnBzFSdA4fatJcP8vKJOr2tAZOHZvF9kFGbmUCTtSDfyalFHjs39ugNIsT8IQ4sxiSxT9w8gpTQv3uF7rjN6dkJRD1g8aQk2VBc/4O3WDixgPYixhdipo5OI/wmW2t9ApUy2Y6Y6gny3io7d8/ywkQPrzum0/OZrNdJaj6BypB5Sm9vl53dbR7jGJc/+5h3Vcq/fsCDcJadfp9hf0SfEfV6RK/Xox10uHFnnYl2nQ/O3ebazTum16aGGE2kJb045cK5C0YQ1U7Gw+0m//5rJzgwTHg703xPJYgwRCPJFCR5jrAtffB8hCcRWW4StaVgfXWVjfUDLBwwbZfC0MmFUOTd9Pt92u12oSOntA1Fi5yPPvqIe/dXS8HhR7TluYIsQ0uBkE6GRJWTxUjFG1bJNyEu1+ReOO/OGgOlFUmSmiKYItQhCvbATfgix8a+ogAcziOGfZZRlJVwolhMqzICdr8VZk6wz0bYXe1zgau+NcVQHNNY8f7/WWTYvtCEdp8v/lgZk/6xz1fogb9gnFg20xSbeNJ2RqicghmkKvepNJnKC4NWwnOb8ydNhbsWxigrpY18h/TIsS2qlAkRCu/RVgG3aj5R6OH7Hro2TVBvEIRmPgeBzx/+8Xc4srzEr/7lb1ILw+LZSvPcACarJCA8D88LC2Zs+dgzzM8f4uDyIf7sO3/G5vaeuUcqL8I8YDKwAqDdCNnr5bTqEXiSjc1+Ie+T57nRSxQKIXz77Nveoe6JcSxuniGFb8C0ld/xAx+BIMuEye0TJje1FoWkmTKCvFmCVhmZ0tS8FF8pRr2ErdV1svGbhHsBMvMQ+KhRAu0WOsnQwwHDdMjWbp/f/OA+t/YUx5bn2diK+Mf/1Vvc3eoxjmOkgMW5T3jpmdN8/gtf4uDyEtqTREFkesx6Zr4GYUToeyRpbJCANnqJwvPQnofnewhMaDhNYmqNBuM45fr16xw5dozQkwwGfWamZ0BpxnFM1GjSarXJ4yG93S1Wbt9mYqJDpjKuXr/B/Y1Nk5OtBBuDnF6a7HPYHsXmpmoVM2lV4dCMppJNh3GAp/ys6xRU/aKw8wmsTBim+4yb8rmt7C3IPAuginxcKEEc5ev96TEly1/YYycF43rwyurfocRfDpDxz/T5qiCzAKBuX/Z3pTR6n3C3qIxTlL3jHWjdlwteDSlb56YyHuf074PjuiKZVUHmhW1177nezQWDbZciCwIdOHd2VBUpOtpoYtoORA+7PTwAtA3ZsQZbD9fxGRJ3mqxvT7C9lTDc3cAfdZmdmuSVl6d46ZkjDLp7XFqfBwHZ5l1q67eRO3s8dWSS+cVZHn9iBiUzXhsp/unvnGXno5vkXs73LvVpk/HN1yL64x6PRzu8984qDXWDk4sRjVZArV0jzSXj7S6MRsw8vcj0s0+Q7A25+oMbtEOfdrvG9OI0IknxJw6TbuyQyQOEvodszhAkmxx66XFWfnSBIFec+MuvsX35Br7wmTi8QL7WpXFokaVmxqmpOeoHH0eNH+cH/8M7nLt5l8NeCCjE5n1ur69xb7dLfWKCwwdm+NzzJ7h1c52P9/p4ByI2NjYZj0dEUch4PObO3U20gnrdo9sfcOHiDaIwIEtT/MDn0OEDXL15Dz0aF8+HAEIhObW0yELuk/aH/FxHMowzbus6stkizxVJDmEAKInwQyNmKkzeRiYV25ub3L93D7RmYnKSnZ1dPF8Sj8cEfsDU9LRtSh/ged6+HLIkSfmH//AfcevWLVw5+qPatNKWRRHlBHKTqch5wSy4aYInS2pfa0WeqWISmYRZwDUahwJkISoU/n5qjfLNivfmvq3dXipfcUasarzs60Kbiwd2T2m4qh58CSQrQtMFQP1xj/OfZQqqHmzBF2gwOmrYMVUqhvcZ24rxAlA2Y0pBpkujKqpf08YkUhm7LK6NKNsuaW1ZCftJ4Rhb4XbyYwvDvlvwCLYw8mnWA9qdGvUgxvckQRSyvrlFHCeMxzGfnb/AL/z810B2yPIcLUzLQSGNg5HlmtD30CJAC0mWjJDCx4tanDz9NNIL+O3f+k0GA6MJmOuMPLfALockTegPUwLfQ3ia3mBEliaYTjTShOqN9wfa5A37BeNqgF+e5+TKd1F5WyluZE88YbQWfd8jqgWILEPVfFMUMcxBpfgiQ+ucPE/J84S766bYKM9CPE+R3xHUszrj4S6NzMP3IhAj8q1tdoKEPzq3TjKxzONLIT969xy3VndIVF48HwrN+s6Ay7fWOX/1Lv/rv/a/5MTJE1TlgRxrLoUkS3M8YarelfQQnnnW+v0h/X6PRqNGZ2ICKTzu3r1jwI6WjOOUWrOFH4T4QtBstvE8j2TYZ9jfJc0Szl+6weOnT7O3u0uSZLz67NN868++Z6q0NWipibNH+RRC1SFzofvSBlEwR6WDaMEVWCunnL9apIcUn670/63symJF90t5vsU9KT5dwFA3QAptu8LGUtpIG17O90U9xL757pg4Q87tB3Ulu/iAo+7MRmVsAishJT1cSNfZQ3vkCuO3P72l+nOfA/9jzGUxkH3X0L0obO6+8bovVIBj8d3KyVRucNUs6x/75V+8PXwVMJCnpleiSRbX5OmAfi/n1maPZ9IxBw8uo0cB0qtzZxjw6eX7LE51yLvbTHm7LKQ3aU5t0vda3Hr9Nj/69CbnfgjdOOPMi6d59dXD/NZvfcr13TEjpTm9ELK1GZONQqbuJ8w9foKW6NGuZzTaLfTEQerTNbbP3yYY7uEfWcavNfA7HZ7+jTb0JeQSr1VHdzrMdg5x54N/yvjjN9judZk60ESEk+RrW1w7u4ZPwoFnVxjnAVNzEVc/vMTw/CoHl68SHT4A+Q6qdhDZaHPy5ZO0P7jLndUdliLJIM0JtGLTEwTJmDfeeo9f/YVXefL0Apdveayvb7Kzs4vWRlpAp5obd9bY2hvQbkbMTU+Q5IonnjzGzk6fn//cE7x/7gYaYSrcIo9ud2DYkajGe1tdVkYpx4XmK7LGkeU5dsYBmYZU+kggU04KxEfnppgh1yBqEXEy4pP332f32DH80Ed4AY1GHSEEjUaTqFaj3WoxGPQBiKII0KRpymefneP69etFyPRRbp4v8bQ03pnVoFIaq3IvbeWvAarS81BakY6NSr10rYq0yZnwZFCEAVQxwUrFe6gAo6phrWx/Ye5Z1QhUGMDirUqeiShmufvlQbe2ghgfOJa272k7jn3gsxj3P2/MD4C7ikHTULBJLiz8YxXJ1THpyo7Eg+9ThH8d2DUfKxlOl5UjhElY91yLKenZBvTms3meW6fDsFRaCMMkPsIHsX7oBDMzE0wfWqKx+Dj1eg0hJGdOHqfZrDMex1y5doOdnS4HF2ZNeDJXhlkRmixXCOkXRYFpGhvw5UmMmEqDk2ee4dXXbvL9P/1T8jQjQ+GR4zQfApExHu4avcRYMJkM6LQVO2HOWUcg5Bnj8YA4NgdqNRvU6w27KKcIHeKJFKl9dCzxAh8ZhGg/AN9HaRMeTFWGh7SMl6n4VL5PkigSpUk1DEYp97RmGOf0Rzm9fs5M7DOKc2r1nIGCYCtD55qoLlnbjWkcexE/S/jtb3+fveGITCtbrGAXdquDNk5y3j97jdpv/z7/0d/9d6nVaoVOZJpnICVhFOLJ8nnKlS5UEIa9XYb9Hu3WEn4Qsr6+xcTUHMIzQDrPYbLTAq0Zjvo0GhPkacJ4NDBV0H6NvcGYWc+jUY/o9roceOoEvh+QZLHVJpWMsn8GJfUz2rQ1VCUeqzDsbq7mJhriWvW5aeqcXGchzFV3hQV2frsOm3bSOpUEISDLDVCvSlRpC7RcHp05RMm6VVNI3Oby+lz/cillkRe8L0wsjDsqDI1dNSLFcWSBTSyEqzCB7nTLCJCwOeMVAGm7lhgwaJhw6TRUqxqGojwDQySUPYTLnMfK4BytoN3SYD5T5GMW0SdrjktftzjFAoQ6ZrJo82P0Pk1o32L8nyAa8tAAUKPKnqk2HBD4Hr4HtXqDAy3F6naXEwfneezkEfo/usCteyOSrMPK7Tvk/RXi+2/jexkf38s5cXiKkfL5x++sshkE/IdPJDRGY7ZjweEjcxw90GAm8PnyF47RakREMwc41Nsku3uBeBAz6gfcuHYF2V3n2V99jXDpuOl1e/cuw7trZIMRaZyTpD5+q0N7pkmSK4IsZXBrnc3OFFsfr7OwkKKjBkdPzzJxYAK/3WJ+ocVnv/0jzn60xtO/9DTBqSWS3RGy0cSrTSLqHQ493ualz6+y+YfniVWOH0pqCJYbHbSMaE5P8saH1zg01yLTOSv3NugOYoQ21W+ezVOL04zBxpjd7ojAl2xv7fLlVx5nZiIiCj1mJluEtRqrG9vUogg8jwxIhkMG4zG3PI/3BiMO5gHLswt4KifTgjAMjbGWAqFyyCVpbqrUfBECGYPekHNnz9GemMRVn9Zqdfwgoj2xRrNRx/N9QBMGEVmuWN/c5nf/4FvcvHmfRrPDcDh86Iftp7EZNs8sltJJueS6YJsEBvSaatEcT3oEdd/KQig8TxIEJk+vTL51z7hdOK1B2o9hqtl85QTTzsstGMMSyDmDQ+FNmq0Ig5gXhYdb2gGxz/0rwWPJfICh/x3wc/1RneFXlcH/OFB0nxMPDK0EhNWSlOp39n+/khhe2UVhvQojpov33ZnvD4nYa4UoKn9dCymhQYY+aZKV5ytMFbDWlYb0j9AROfzlX2NuYZnJ2QXCWoNMmQXgc6++zPI/+QMuXb7OtWvXWblzl2OHFmxeDggUYT0woUIJaZLi+RKpc2QYmqsjAxNzkxlPPPd5fvD91+nuJIwSTZ7mJLayvxN5NFtTxGlCrVljbmKOqBai1/vIs9tkSjNOUuI4JfQg9BTKF+haDURg2T6zUOdpTpxleErj5ZLUUwiRmpBSbqRd8jQmHY8YjBPSLCNNM9uT2TwDO/2cPNMkqSBOFXGS056aYCIKyVRC1Gmxu9Nl4bE5ZOqz3Z9gNIj5J3/0fcZphu8ZQKeUu5fCuWIIzLP+4aeX+OzsOb7+tS8hsBX6ysxplWVoQSH5ITA5uVmaU6/XCGyKyzhOGAxHtJsB/d0N4tEOUvr08z38MGQ8zoiiOqPeHvGoTxhF+EHIL339i7z/2WUWFhb4xle/yOJ0k3qtxmAUkynFKIHVRyyJqq3Sv5mLsmILNNhn0uUFCk3R49eZFikqXYiK+K1jVUUBbsoiQhs6xcpoaQhDv5h6BqhUGcjSVhSt4azNcRX/+1QP7L1zXUXK8KsZcZXl21f9K4w6hVKK3DLIbjzuC87GIkpbU1hzZ48tADUpULqUzhKleoSz9aZwxP6UVjuzsp7s1we0z7IoX+27Xi7O+wDlWk3lE1b8Xkt3jaULghXmVSGQthDyYbeHBoCvPXuKz67cNpWo2jTn9nKBH0qSwZhWe57dtMaVlTW2r9xjYfoId1c3+ZM33+TO1Wt4q/f5haebfO6Fw3zjYM7SmTlunb3A3GMnOHc94f7WkFNHZ/iP/r0vcfjwDL435u75DSbbITKQJFurSH9EcOgooYQ8bDP4+A63d0bwe29y4uklpp48BJMTqKHkO99+n1t395iKYCKUtGanOPn4IebPHGDrk1sErV1mX36O7vkbLL80yeQvPo3X7jBcvUu6OaTz/GG++o2nmQo09YU2/vyTIDy08lCqS7J+h8G926SDPgOlifEIax7Pzk5zqzfg6qVLJCLg4iVBrgS1ZofMq5ON9tDkBJgbPhqOQHqoUcKB+UlmOm0avqDbG1CTHqeOL3PrzgZL7SaPP3GYd87fZrNrcn3yXJGlKckYdvoDIi9ieWYaoUBJD7QNd+YpuZTEyuRNje6vc/7STTLtE4QNpLfGYDhkeXmJ8Shhd3eHsBYxGo/QKicMAxYWDnDk2BEuXr7E1sYWcwuHaLQ63Lx26Sd43H4KWyXmui/vTVlwoW0PWTBdDWyFYBRGhKFJ7PWksB6zNSrS0fl2Ysr9eKKAdH8BQVdO5koYoOJ1Ojaj3Ik7hgN++6BW+dp+Z194Yd/nRMGCKK3QqjSILiRkHc39x7X/iOIPbrzu8rpr6q51ySY4I+occI2pKC0ETKsHKO5Q2f/SAb/i2lnDWw0z78vTyRW+76Fyt0gJAt9DS+tRZ/b6VK73o9iOnXkRPzBC+KlSRvjYApWXnn+Gy1dvopTiBz96g1eee5zA99ESxrt7eMMhvu+TpBn1qI6p+LXMirZ7EUY0eWp2ka/83Nf4J7/7HXqjPqkyel8qFwyGKVrvkmmBxmOy06HbVwwS31YCm04e7VrdhKxrPn4YkWtIUgU6Rggzb6wKDH6GecilBxgh8jxNiMdDhsMxSWokaZJUkaSKLM1Jsow0yxmNc5IM0lQTpxCnPgdlQntCUquH+JFHZ7qBTmB9fcjtQYff+5PvMxjF4Jnn0RMShMLNcO+B+TRMMt5+932+/vWvFqFflefkacyd1XsEYY1mq0VUq+H7AWmWMuh3SeIULwjIsox4NGJqssW4v4PAQ6mMLE/B88mUIIgaDLpbxKMR1p3E8ySnTh4jHo85e2WFqZlZpiaa1AMfgRHjF8K0LPyfY6tk9kGRklOxYBVQUeSluRCmpZf2p7uUTp+AouBACEEQmkIcrbQpyFLl3C+Y2ypQogqwKmOtMHGGuTQdlwqWUgqKfrxKFTZ6H5tnYwG5LTpzOYnlOUIZdjZs2T7wZ383oM9U23ueZxnMMm/bSWpVJXGENsf2LFOqRKl5Wg2G7N9KR3ifMkMFMLuH34T0RQkCLUDcF+mp4katbVeQn8wTfmgAePpQh5srIaNxgtIaD+hEDfIs5sbqBq9/co65iSbr25KsIfB377B69SqXXv8APY4Zy5wfXIi5eXOPzz29yObd+/yTKwOWJlvUY/hX//JJpk4vs7WZkq7dpnZwliPPL0GWs7M1QNY02d6Y1tQUtcVFRLPDV5p15GtL/NF//ToXf/MznntyhYUnlph7/mle/Vdf4up/+ibvrSY899xRXvgrX2QhXWHylRO0DndYfecK8Z0bLH3hScKjy+iNW2y+/ym7qwnLzy4zfWKCqZmQbH3A8Mod1IeXGe0l1JfnkLPTtBZbfOEvPU57aZpP3rzN9Y0B22nOrXvbyHqdE9OTXNnaYWc4ptVskGUpudIkmS4fRJ0jhESpFCUk/cGQyPcZjYe0mk2+9rkzXFnZYGG6xdKBWTIFb1+4jUlu0UYXzdLynltEpI8UZoHUwkNLj1GSsr22ze4wZWdvTNTqUG82mD0wz+FjR6nXaty9d5e5uRmjDSYk7XaT/rDPys0Vdvd2efyp02z1Rhx/7BiD0YjdwZA4yX6sVdzPejMJ7sqCPSgmU8XTrHBwBKFh/5y+oef7ZDorehw7w+YAoMvBpZyLoEtZiX05cfs8tEpOCBSSLSZlwqt4rwIXXqgCxQdOsjCepWm2AFcWClLlZHdgs2Ig9ANGphxbaXBKTT9R3U1RkWuYBFUwM67zisuhdNfeGSR3SdzCYcZrgJvQuty/O7NCGNUaYuEKQCzLiyB17BCO/TVVwbkqF6Yfuxk/4y2IQjzPN9WlqekDG0YRrXab5595kt/8p39AmsJbb7/L+m/8GssHDoCGqN5ge2uTWr1Bkmb4QpClUK/XKTQShWd0wqSHGvX40ld+Hq/W5v/69/4rsswUdgxHCSrXhFIzGCRMSMFGMyDMYGecQpajkWzt9ZG0GCWK/jAHxub6Cwh9Sb3uEwaSMBDUQ596JGm2W4S+hydysmxEIDStWkp/u0vD95jqhChRI7FFOFma0R9k3FjN6I7NfUlzTZJlhEdC+sOUUZ4R55ogFOxt9LgdHeQ775yjN0xMz1htgIvQWFaIgkUxOM86BFpxb3WD3b0uE23T11ejqdfq5OMh3e4ucRzTaDRRWcLG3WvkuaI9t0QYhkTNDul4RGdqipmZOeJ4TBaPSZKUjbV7eDrH88aMx4ogqpnUm1oNTwjyXPHcs09x8rET3Fy5bXIvJTR8zTiX+BKinyD5/qexFThDlI5fcbVsda+xb9riermPVXJsGFpTtZqaEkworQtWVWtMr3hbIZsmpe5hNS/Tgb6C8cM6unawLjJSDccaR8TIDEkpTXqicKBNoHOjfKHtmLUoc4B93wO8Qq+1cnruahROdSEzZUGfYyHNOZjOWUqULUJN/rGHZ1nQUorLrB95bpUoiv06T7oE224xqRbY7a8ELj8vrC00hEMZ3TGTwf2uClk3TYXptWy8/NkUgQga9RDZN/So9CR+LWA4itnZ2uK3fvd1fu7Fp1icncbz6tRVF7V9g4XlGpONNt3NITdWelwbam68d59Xn1vkC09McGgh4L//wSavX+rzuek+v/nff8xf+vw8Ytwnx6c2M0EkNXkaILKc4doag7v3EVJw43YPLxkxPx3x2PMvsXCwwWdvXKO7+wbTjx/ntW8e4d957Qnay0tsvX+F9slZdJrRnF7kwOem0Ts9gtlj5Heu0fv0It17Q5I4Z7wzojnVBtFELrZpTE+Sdbv0r2zRX90i24sR/imCJORzj80yuXCAj/6L79MdxDQbAb7y8UTAsYkOSZ7RH4+RSli9MtAyIhEeoaCgrLXMGY5iptuJ0eiTcO76be5tDGnWa9QCn1wZwVM3VaX0qTUaKDzqzQ5Ra8JqtNtcNzTjLOXerTWGiTluUKvTbDeZmZ1lenYa0y4pZjQa0d3rEdUiVlZWmJqaYHp6mqPHjrJwYIFBPOK919/mmceOcPzYAa7d32R9vMfc0aMP/bD9tDYnmVKIJEuTLySFzXmEihelCcOAWhSRpKkViQXlKtkKpg3z0ybUqEooowqg3OakDdzfCwNgjYlrvabNh7Fm0ea6GMENabUHC2CnVSk/YPaMoKyMM0yfJrehnzzPTQ9hV6BDaXT2hWvNG6V5f8A+FCEg+2CVXjwVA+Suu97Xr9iBQufJliCvvKZCO4+9mv1jQ/UV8AcUOUUCVSw6qVYEfohGkSaprWQV5Jm2kj9/cX7mz2rL0pQoqiGCAM/J3WjN5ESHz3/uNV5+6UXeevs9xuOEa9dXWD64iMoVaRyjlCYej8k1jEZDPN/HDwNkKvGD0AjQ4lnFBYFf6/DKq5/nhaf/nLMXbwIwGIyIk5yZyONIf0wd0L0RoTLVwU0PxkjTBs0XhGFAFPjGYcQ8a0HoM9Gs027X6TQDosBU+tZbdULfJx6PUTTRuaLf3SbTEPk1ao0GwgthlDAeJWjMguN7kmGc0teCTEliBcOhYKlTJyYmjVOiTg3lN/j4eo87G3ukLo/MtXS0dIZhYzyEgFyYfD4wc7w/GLOzuUWjEeEL24JN+jQaDZKRaZ+5s7vD3tptursbNCdmqcdD08o0z9nb22Rr5TydyQXCZgulcm7dusNn5y7w+ddeIgqnaU9OE0U1pG8q0b3Ao11vEoURk+MhzVrID370FuloQCAhVgaETDSDR/cQ4uacQrmesZQ5gGhnO6wDJirz2rHsBmUAxvYgbN9zbcC4woXUAYSNJmnSPC1Ent049juyJegymqwW4LtjU8m7s+hVSomyaWamFanZg2PVyvBtFYBZu5Kb/G5PSqsHVgK+8mcZ5XBjTpNsH2h2eoAIm4OsNJCDyAogWOoEyn37UirfBxDdTkX5ocL2O8e44Codu4e96Bqbf21tpl3L3fqklbb6htoCQMtSijIU/rDbQwPAnWGMH/rFwJIsg0bEXLvG9uYWG1s73L59nxfOPMmMHjM3vMPXvjxLPEgYJTl/flaxuzkibzf45c8f5bWTHeYWAu5tp+hsnbNXV/F27/HpnRGfH88xVWviN+oICfFGj/vX7nLrwjpSCGo1weypZU68ssSHZ3d55aWDRK0AGc2wlDXIdlaJOk0OZX3m64orH58nX7mL98xryIknSPsDPv3D3+XJF04g0oStO9tsbvqs3xlx9IlFvJrP9saAVj8mjPfw56aIpmeYOhmRbm/TmGyRdqbJ7u9y//sfMP3cGV49McO5q9uMpKTbH6EZoT2fmTAkTUeMR31SbYBBmsSkeYBoNPC9HJmMEUrh+T71RoNrdze5dmeTte0BuTbe+fLCBBOtBrXQaN2FtRYT80vo3Aiz+mGElKENAJjHTgrJcDQgUz7SC9CejxcESM8jqEVIzycIAnZ3d/A8n4NLi9y9c5/HHjvN8tICk5NTzM8fYKe7w/m3fkjS26C7W+f48iyyscjtrIeH99AP209jc4ZDW+/MnG3JLlVzTkwuoGI8GoM2eSvS80ovzhmWKkqx89pIkFjIVAmLFgEF4+biWQmdIIys1ysK79fk15TyAQ5pGrwoy8RhTSFjIqWTjhHFBC99c8r9Uua/5UqR5xmZDXfnFhTuA4Dm4hTXqNzKPReGmZIVLJOxy+/sD1+UDGV5fuVnBc6YOeZRF/ewYEGr11WXYsZaadOtJjN6btIzGnAqMx6650mUcK37Hh0CHI3G1OoNonqdQAiyPCcej0kGA1A5zzx5inff+4j+YMCn5y7y2kvP4fl+Ab7yLGMYm8KQeqNuJG/8CIQkS1OzcAtJGNaQQYivcr70+Ve4fP0uw8HIMAOALwXzQAj065L2yPQUrjmBWaWJk5Q0hywzK0tm1wY5ihkOY7a7QzpND5+UNFMI6eH7AUrBgbkJajXBXj9lezdB+E1aMiDwAnZ7A66tbJBmOZlSxKlxDnIhGKeaTMPq9oijUlCbqZsew0pyu6f4+OoavXFaAggoBIE9BwrAhuZsRyOtSXPjjPR7PcaDES1iahu3EComigfMj3tkhFweRKysbzLVaVOvNZF5RqPRIh0PGO+ukXTXGW/fw2tMst0b8903P+WZ04fIswytbYqIhGazRRRF+IFPnqUM+11G4xE7u3v8T7/zbbZ6Y6QQBJ4k9GVxbR/VVs3/LZg791rZvyvXCQS0rA6wkntMmY8rHMFQer/WkbNhbt9He7roLuSkb5QqbTCODYSK7dKYuv8HvU9sFbIqwq6+75XOcQE0q062/Z5jA4trYVlCVeZHO8tS2CCc0y9srrG5Oo5RrDKZoAtGzx3DDboaSXHXxV1Edx+q51p1jN0OnWNe7KeyDkkLxl2FtnBJhZ40TF9uAWM16mTtwk9iCx8aAP7R6+dNEqI9gOf7hGGNdhQiphSD4YADa9dZ/f3/AbG4RD9e5Ud7A1RQ54lXjjD/2DS/2mrz3LOHiLtDNjaGjOqLfPTeDf7qz51gbq6BFJIv/2vLNCcikD5CZZCnhIuHaT12kuWnbuFFARf3YG93xHLzAFu3rtCfGFF78jDUA46+MIeWBxjt5NxcjTlw/SbjbsjZzzY48OqYuYWU1bde58bFexxeqhPUBrTrARO//BpHsxy6W2yv7BGlivr8FNura4RrV6lP1oiaHepTU+SZ5tYP/oh5OWDpsIRgzBcP+UR9n4u7ksyr0e/3GQxHKDTNwCdLEjJl8poEuQFngzHtySY5MVJDbzjm4so6/UGMQhCEAUmakKYp337jPM1mi5Qak/PTTC0cJZceaTxGD3v4XkCmTFcP3zd6gLlWDOMU6dXxNKQA0mNiasr0uww8kmTEzuYuR48dZ3FxiampGZaXl4nj2Ij9epokGXP39nXyeMh4MCTNMiZrIcuHF7hx99H2v8QxfgUA1AUj6NgtN9kz3CJi+lRqCy780C+9YPe/tmFz7TLcylySamTBGU3nBToPO0sy19MbNIX2m6YEU8bTdbpkZrEFrIaWOUKeKWuEwDFb5e/mM8qGEhxz4sYSBhKCwDCYritJxVA7c6iqBsIdq8pm6vJ4Lr+mGmZXFWNa2ZE1YMXL/WBQ6+IzbgwO/pXdP0TBeAZ+gClQMB01sjQjz3J83yMIAxsa1Ja1UI9UBzDPMuLxmKhWxwsCPM+MdSwEnu/zV3/91/iH//h36fX6fHruAt1uj067hZHYMezysN9HpQn1ZsTa6h086dFoNGg029TqDbTQhGFEHCeoXPLaF7/GOx+e43s/fAdyqxOqIBcgtUBk5lr6aEIA+77OFbEyzsFOf8Ruf2wrQgXN0CfOcuqhJLQyO54Q5LaVzrOn5nny9CGE9MmUpD8YMTvZxAsCdrp97u0Mccu8Iz6igpmQXNxVLAaKQ1FK4Eu6q30+GYRcX9sjV4qixZ8dL9j8Um1SjNwC7/sCpSDXmo4vmL71IcHGe0g/wVcj/CgkyAMEGj8VLPUS/svvXuDLX/kKMxMZ9eYM+XCX7v3rxLtrpnuFyhhs9/jeB9eZnJqgVm8wHPURux5pOqbZbDMc9PED3+pbBjSbTTbWtvj7/9n/h5t37pLajiO+VEiZMXgQ3PysN2dsKs6lQRaWcbPzUStd2KYC9Glt24oZx8C9p7JsP1BydtAiLa0deyXwPQ9hU4CcI6udHbDbPrZPlK9LMGfnvRSFQ6+tsDEqo3BOrQ0ttAyrXnEFeLm/uShLYauESyEpWceCgayMUbruIIXjK4pzz7KMxIa9fUsmFNfY2VEhKmOo3KpKJKYcvi6uWfHoOLBnr125oLjz1Ujp4QtZ7ENpjciVyUVVri/zw20PDQDbtTp7g1FhaCcmJsiyjKHOqLfbbAqPD/YS7mWC//iVmAOHj6MvbHB8OmJxKeLsmuZOv8els9dROuClZxZYmMw4/GunCBtNxlt7pN0+yYXL9JIYXyc0piLE1Bxb564x6o8I5+aZPbTA69+/yPb1Vd763Y+p5xkf3d9g/twmfZ0zvdjk1NcfJ9uJub+Z8+l7a5y/MSZs5Gy++x75zUts92I+9yuPM9oYIesB/sIiwewc6c497n/vHNOnjjAcZ+ydP4840OHem/eZmIsJGhnRgQB/dobjx+fQ0yeQwz6iPcvTjy3x5Dd9Nm6u8umn67x9d5aerJH7HrujEXd3u6zcX6M/HBfhtSQb0+tp6lGISGOEyhmnI/MwSUGSmnueZTl313eZnPKZnztE7jXI8pw0Hpn2T0ENgohEp2RZAgj8QJCkOYMkRsoWuRJ40scPIuqNBkIK6vUaG2ubtNttFhZn2dhYZ2Z2jlzlJGlq2QlBGHrcuXOH7u4O94KQl155gTu9e0wtdkjEo+1/WVSIysoMsxMXtMk58Tw8IfE9WeS9CJvYSxEGMVVdjvJ33mI10dfMvf3Awhm3wmDmijTPLPNW8cBsgca+MUqJEDlJKorzcOEJBwKLyjw7ArcLV+VrwJMqDHuuVQHKwDAXiFJMWUhhKvakLMO0hef4gHF1J2kPKhyAsx56NexbbX3nNMOUqghy22slXbVcxcMGlzytyZXp0uAWJmnvgVamP7AGdJIghCno0UrhBca4Z2mGsqytEa99NJvwJHFsukr4gY/0PEJZQ0iPJI6Z6LR56snHefud97l69Qa3769xslZD6pzMsplB6LO+tUOaxsTjIUeOn6DebBEEIUhBnqX0el2iWoMkh0Gs+fLXvsFQhbz3w9cZ9AbECpQQTAWSf/tXQ658N+atLY2vNSBJlSbLNNqzWoLKQHBTgQnKsiiplQoJPNsmDtNKrrvXI/BC0kyQZJpkN2aiOcLTGeN+t8h/0hpy7RgnSeR7+MDZ9R7rvRH/m8Y0NZ3QV4Lzd3sM45Qsz20xlqg+ctYBEKU+ZrEYayLfZy7UZLcuoo9M0qv5jLZ2CGs+UaOGTqEetliYbvCvPzfHb733Hms367xyYpopkbC6NWSUC0ZpzqA34vxqj61+zMHZCU6cfpIDS4cM++R7NBtG3FtrI5RNruhv3OEPf/O/YVZu8vUnZ/j+hS0G4wylNYnKOXNw8pE9g8WmQQjXtaOc1gJZgjFpmHXPVlo79t1l6RlbYqqpEX7RIShLM1SeF46sPRw60wUAKx288l4BxXynsC0VEGgd1irIcvdePMj8VXxKpDARWensb4l9y9G5f3OklOZ+ur6+FdRonN4Hji+s8oBrCYe0ESFhW2v6xhYrm36TZoV8DVVbX42WUGFGoSwkrDCE1TxAsACwygo6p9wCe2W1mAv2E/Z3RfpZMIC/8dUXee/aCre3euRpyuEjh9jZ3sULQsZxil9rsKs0j81EdJoh037OL39hmgs/vMP3Lm5xuw9fe2mB+ckmyq+xc3uXS2/eIk3HDEcx/RiQgjQKeez0Es89dwBvro3OYm6saZYWOrQmW5B2+fxLE3gvThIBnWZALQxQrQYXr/R47+oOp6OjeMcXOPK1GvfefJOnnp/n7Ft3uXxhj96NAeOJkC/MTHHkqQWi5ZNQC8nuXmJ4a4X2M2cITxwmqIdsf/AJY79J84nj9G+sMLq3iby8hddpMTlToyM0tVCSbd+huz7m6vur9AcRP/d//E94NZwhj9qodMzO+jqDHP7b3/yn/P7vfwuR5whtpCGy8RhRb5FKjUhHZjJXJo3GJO+acKFEexFaCJIsAW0WYOkFCKSRimiEgCTPBDuJpqdatG0Cv9aQpiOSJObAzAJKafqDEWfOnKLb7aGUZnJigkF/QK3eoNVsstvvcvbCeaQnmZtfoD8Y8Yd//GeEsw3WBtv01rYe+mH7qWwPeG3uOglb2eu5BOIKsHGyCMImx7qQBkKgjMR6xQFT+62K1vvmk2OtnOp6nCSmKEW4AgVjSJRNynX6UcXfcHqE5TGcNmHBSCqHopylKL3G6vulxyus0LWTZVHkCKRQ+45V5PNo5yG7EZVW1hioymsoxuZAr9YCIZQFmaLoCyyEpAhbW0NX1jibN4z8UckRBNq3BtVW8lX+qpQqG9Jr49lqpUjiBG0BvPO+9+Xe/Iw3ISRJljEcDfBDn1rNhHHDwOQveXnOL/78z/HBR58wGA65cu0Gx44cQuUpaZaRpCnS80jShG43JQx9Br0etaiGbAukkgz7A1IR8MabH+AHAVPTE6xu91nf3OWZl17iz3/4OikmbKpyzfWrGfdH5nmwnAy5hkyryoKiCX0j3yWlJvAlytN4aHxP0fCNk5TmmpHWJLnHhXPX2enHjBOjs3l/rUd/RzFMzP4d42QcABipnCTTNGqAlqyPMn5wf8wrcz5XBhnjzIhgay3Ico0Q2sqWGZAnpemw4ntmAS6cNU/TbjRYnmhyt9tj79KQcLKBIGO+3aDR7BCpAB3HZBt7nIxguumxmSS8d3OTv/XqFIc6PptbPbqDmMTLOdWQBF6DRnudmWSdhYUXGI1HXLh4gcmJKWamp2k0mgx2N9jc2mL97m3ubW7i+zU8T+OxXYCgLBNsdvNH9gxCCb4Ke4a7H3bOOj9Pm+tbgAalEFa2xBRglGHcqkMobY6uY7dcdEXa9BVXgW/Ct6UwvcVWuNzDgm3Tld8pe9YKa78o8re1BZ0lsHUnKh3q4QG8Vb5dfDbPMsP2OgZQGOKgbA7glUVHCJNOLE2nHhdlEa7toXTJVQa8mhxV9YDd+YttkHZOt/uEQ+n7IjEUtnMf2rabc9qdzf8xdlGXPbBF0VfpX7w9NAA8dPAgzy0usSok/8Vvfpu9zR18IO/1aU9O8POvLPNvnhiRbm1x+6ObbHk5U8sd3r+lmF6Y4kun5zh1ps2bP7zCR+/fZ20vJQglZ05McezgJAfqHi98+RS1uQMQRsQrt9j97ArNxRrPffUo67djPL9B0Knx8tIieZKTd3ske5t4OiXZGvDiUouFmQNcffsyp54a8eWfP8anm7c4+uwSopvDkQZn396gfn+TN27sEX79MebbHfo3LzPzzCk6v/CL6F6Pnasr7N1e5f7VLeYm6xx+6RT9dovpl55k99xl7v7p22T1SWTjMN5kHZVnTCxOsHQy4vU/uMBqUkP1N6lPCSYXl5g7dgylNPVv/TFa5+bhVxk1IVCBR7+7bX0xReRJao0aWZaBwEojCHwvYHp6hlq7Qx40UL0uSR4TyoDxYEBQ9xjIkJt7Y5CKlBylfYzQhCJVOWhotJp4nm+KaG7cYmFhgXqzwfVr13nqqaeQnmQ4HNHpTKCBJI759NI15ucW2d5eR3qCbr9Pf32Vvd4e48HgoR+2n8amlII8x3hK1roJjbAhQUXZg9YTztMz3xXWABgDJwvjhCi19Zwnqx6YiO7XMk/OALlaFBWhXKXNApZbgVFc/2G7f2nBj9vTjzft1oWEh2FWnEE2k9yFfLU1BI75U5aVc7beAaJc5eS56+BSGqtqmKbwtIshVMCm8yYrx8OFgCvWyRXSlJ69u+b7r6HSpoVYlSE0oN0jikLjdReerzRMhDJFPGmaghb4YYDIRSF+K4Uge8QtuJAeWRIzHo/NXBKSMIyQUhJFdbTWvPTi8zx28jgXLlzm/KVrfOWLn8fTirMXrnH2wkW++vmXqNfrpMmYUEh2d/cIw8jkOOaaOE347/7Hf8rjTz3DqNdHqYSJqTZZlvDlr3yJcTxkZ/UeNU8Sr3d57yPDRClMTqBzanKl8WV5T7NcE6cpnifwPVVU1HtSEAca34LqRAmG3Zj797qkoUfWquFJTX9nwKA7YtwoW0dij+sel1QreqOEPAyIkLxxd49BVmOP0BZfqWK+aW26yEhhmL/AM6yNYSNNW0EhTEBzeXGGmdOnGV9/n8WZDovH54j7MWqQsJf3yHJNutsnH+UQeLRUzNGnn6EWhmzurHBoKqK1XCPPM4aDIXmSFqkR2ZU/Qz31IovLp5mYmuHqlats72xzd+UmJx47zVSmeO/9T/nR2TVmOzX6vRHDOMO4W6bv+Nr23iN9DJ1jWyZ36LJTkgYX99UapMayqgZ4KZVZO2gYPorUl4o7bG1WFWhKq7HqWH2jcWmcOBMdLFNBSsdyfwgYy/TjxJ+tA+8iF4UNqbKJziG1QM+B00otBs53LS7HA9fKmSJlwSHahJhLdtIxj2V0xh61UF9w52XYRb/oKa8Lu1VZKx60rcXfyzCxdnbSAeaClXSYXlj7KyzzafM6C5unCwLE7Ub82Lryz94eGgBOr27jKc0RKfg/v/gEa8OYvSSlPjXJkXbKqdaQ6xc32R36PP3iMeaWOuys9zjta8JmwNG5MXu31rl/d5Mzrxzl3/z8IsPVHv54yNRcm/rCHM3ZaZTwSTZXkWFIc2GCqCbY2M14741LvPrcMcLmMsPtHdYv3OCjzza5sTrg+GKdZ16c4+gzk9w6u0qkIs6cmIF6xMmvP8fNNy+x/GSLuyu7/O2//QU+/fbbrJxdI9np8tE7l+heus8vPHea7M4n9K9ucPXjHfrDPotLLbx6HdnpMHVoCTXeZuWdz7j09m2WzmTMvXwGNQR/Ygm9eYvZwQ5f/fklwkZGLD2iCASGxRjFI9LeHgEK99hppQgE1MII7QeMU1NV59rhCJxYp8kd7Hd3iSYW8QKJLyAZJeTSJwgiHLTI8FC5mfCSDKFS4jRFS8+wNWjqjZDt7R2UEiwcmOPqtWtMtDu0Oi2GgyEIaDQbDPsD9va2mW1JatOLjIa7eFKwtdtjamoOEYTEUeuhH7afxqaUQue5DXuAAUjO6Nk8PuUkA+y8UlZfrwgDPzDJS2rNGpEyCRi7P2dAqsZC2rL8MApsErA0rJVv80+0MkUn2nYlccDQMX3WoKJdsrG2ALTMC9RFc8/9oE/jwF8p06KqYVph9mkWOK+y4KpiHM7bLFg+e40Lx1op58pbQVkDtqUsGYBqArljHgphU7uPorl8FWXvA9ypu7L4NmfT93yTcC7NeYZhZAokhDRJ+VZ7T0uJtB7+o9pq9SZxkjFKMnI1QHg+YApUpOfh+QFTUzMsLMxx69ZtPvr4M65ev8Hly1e5cPkqBxbn2dzpcnB+ikx6NgSesrm5SpqlTE5O0W62+bf+jX+VP/nejwhqLTyvxpGlef7B3/u/EUmPL37uq8SjPvneOv/of/t/YePeGp6AMNVGY9TemVxrfHQZRdIGshjdNXPRPBsSNoDaNnfUmjjPEFmOkiYk7EL8VnwNT9jlxy5kuTDsQ64UmYLeOCXLPagFvHd/zFRLEjWbJZtUzDEDAvMMRKCp+YKgFlKPInxfkmeaeqPBycMHGeU5/XCW/u0ul+9eRWYpQSaYm23SmGowMdHA8xKSOGZ9fY/3v/0uBybrnHjcZzf3be5zSOAH+L5HkiSmhVyesvbOH9KcP0YYRTz22GOM45ibVy5y68Y1JiZneOO9cwS+pFmrocYxWc2jH2emDaKGwHu0VcBGO1LtY8icXJVyIKG4zpRYL7P2Rrj5ryoeH7iCDHN3ZWGjrPuJqIBCzzOiqcKXxt4JzyI0G6dxYMbl3kEp8i4t32/BZJEqYu1jwR5SCla7KEY1rxpRkbEpwOJfgARFFY6V4NJcA7GvE4hZG2QhgePsdTWfsTi+vS7F0UR55LKIz9nJfZxmYa/LL2gDBKvfEQKhSse9kJrB9PYWer98zE+yPTQA3N7bZaLTImzUmdE1OkAsBH6eEOZ1tgYTiJl5ji6nRI2QtfsJWzsdpCdpBD63buzQTZp84SunOHR8gdvrMZPNOrX5FhOLc0DKaPUOWnnUZtv4c0tsn7/C/e++zUpXsHV3yLvrW5xe3eT0r/wCk40lTkzdoX3tGi++MsfccgclWjxxss+P/vgqq1dCJg8N6a7ssPz0MerTknD8KTOTPk2vxryfQXdAe36Gy7uK0eVbdE4dp334ECe8OkSCbKvL/CtPoJMx6d0VZMMjnvTQEx1ub+e83GkyFiHrb7/P7LEZsmHIdJgyGm/j6bbJL9MYdmA45FBD8LkjsywdmeO9q+us3NslzTWMx4SBohWFDOKYNMkJQpNvkOeZaXzuRwxGQ2alwBOKIIzwsy5pNiTLLdBQuZGKkRKVpWR5SlgPEX7NhO2kZHZ2BukHDHd7nDp9ip2dXZI4pXGgidYwHsdEYQ0wFYRPPXWGP/uTf8LE4WO02m0Ggz6dThvhhXQ603Tp/YSP3L/c5tTXhfRwLQkF2jTA1srkAtrYh2H0pUHD2hoVmz/oBHj3FYJUjIJb2ETBFNpcNsqwhQvdOoOLzhHSq4AlA9wRMB7FhdHSlIbEGUBXyODEZAsHz9lprQowqAuub/9WDeWCQNpm8EDREcC1dncsoQvvCPd9NzaE7ftdMqpmXLlljUo2UOkS5Dlwt0/zCqvrWri8Zc5PwRDYTzqQoZUmSzOCwHTOSBPTH1vleVGdraywudIa7ye1fP8SWxhF+FGN8XDISKWIXh+EJKpFkGSsb+3w7T/+DufPX6bX7TMYDPnkswtsbG6wsLhAvVbj/OVrLMw+j5QeWWZyieJBzGgUIzGALKo1+Ve++XVW7q0zPTPD8vLBoqPDpJCQJWTjaepPn+JinjIejHixN8C3kUgXvivCeC7NANuP2HY6EEiUEGQ5IEwlb6Yg1wItTF6t1NXiH11hYWxtp8YAfPtc50qhEIxSRaZSOnWfnX7MwclJSlmQkglxy/UwyQg8mJpoMDs/TRBIkD7Hjxymv7FGHHpMnnycNM747Hvf5YnpgPl2jclWG9mQ7GzukQ9TdgZjbu4MiYl5opMy3gvYGHtEkSSq+XhS4kWB7W8POlPsXfyM2uPn6CweBSBNxrTabdK0we7ONpevXcGXglznjHPwfI9JTxKQ0Y1Nb+dHujkGtnAQKe4NwD5qCorrLapSKe5zFY/MMFzmOdHFXK4co/IMOAcyV6WEi5TSdJCRwqw7Qpgqb0rWUAhh5FvcZ6TAlYVZ2Fkcy52iwphx7VJk9kVL9tucqjnYl5dopVg86RW6ooU9Unb9kMIewzzDBSmAM1dVEOgcoAoFaH86EGdOw9lctc/ZLsZIeQ9cEYgx8+b9gg3ERXdUGXpHm0p5DAmQ/yxCwAzGLBycQAUhWmX097qkOkd4IbkWCA8m2y3S7T02dvqsDjKmjhww4RsZQmuGCQmEgisXt7h75Q7H5jRHnz+IjnuIICDsTJANMvLdbcYrNxnHIdHTp3j+2BzHuym3PrzGh2/fZnL5Mw69+jRzh55m+NopEhHQG/cYXvyIu9fXOHLqAO1jRxknI2YfP0RQi3j7u58hNgYsDDMOvXacT65vshyFzC+2+bf+k6+RbfbY+ugavuohayFBmNJcmIU0IR/u4Xk5Ou7z5EuT+Os9bl/o0rtwmWxqitsX7nLhkxvMzLbx985z4BtzqMWnAQNYVJbRaQT83d84jf5GjWiqzX/9rUv8N//oHTYzQaIFOkvw8ox6GDBWOdk4Iwx83NKs8oxGvUkjDFAiIwo90tkZsp1d6HfRUiCDEImPlIos7pOM+oSijmoGKDyEBj8K2VjfZGFhgbBWY+X2XZaWlpianqLb7ZIkCadOnTYCqp022xv3mZ1u8zf+xl9nde0ev/Pbv8XGxjYbezG1oE5We4TUCyYk4fme0X8TRpNSWMAntBVctvbBs1VfjgEsii6kQAqvCDvsl2opC0OqeXqlJ116sianxhgGs5iCthWaWKOgMQm6QRgUsi9F6LcAhEZXU6mcJDV9baULlVljZ0UeMJW5ZoV3YWFtAaKyFrks1rCGyY2lYhVd6yVh3VXz3VLvDxvmMSeqy7FUlBwKVlRIpFfm/RVG0h3MrRQVxqcU8aZyz9z1Fzb3TxktuzAkV6oQhc7zDI2sNKWnvE+PYOv2R0gvAGFaEY6TjGy3y82V27z+xlt898+/z/3VNfLM3EuVKV5/623+4//g7/DDN95iefkAc7OTZNgQLZIszQAYJzFrG2torZiYgkazzcnjx8jShL3NTRqtNo1Ox/gzSpKnPo9/6TX+9OOzSCC2t6hwNXKNDizoxla52/vne5K8CPmbStEM8OxSnFunSWuT9J5rE+r07CIkrF6cuWflgieFAF8UsigaRaY0YQDb210CzysYXIS933aqaa3ZG2awtsvCVJvlI8s8/dTT3Dx3nr0sJxkN6fserdYEZ77yeXY+/ojhvR12twfMdiKMmpzie6sjBIJXJwTtPOb6nRjfF9QDQTPyqNeMCLZZXDUIyTjuEX/wHkc+3zEhaaGp1evUGh4fffgBvoRhkrK6NSBOc5IkK9IvQk8SBo8WAJb8lrv4upgLlhgzNR6qlHMqiStr37SuABhtHdgyJ9AVl7lNqbIQTQiTpmH2J1GpAX25LY7Iivw4UTrblWO7FJDS/joZrMpnKxES4b7rigBtOFtDwTA6k/XjEKsci9baAH8qRYXCagDac/GkZy5rpQdw4bhTAuiCQMBdJucIm99VET3SFYazHFEJrst5KVzuJOX9Kgr43KEKR05ZZ05ZgGxzGR9ye2gA2JIe40FGayJnNI7JkHg1jzSs0Zyaplbr4Hk53e0ttMqZPb5IIDR5FjPoDgkIiOo1djZhEDdoH3iCHakZX/KYX5S0JxN0skV3ZYVGu0Xn5GHmZw4g0pTxzgbJveus3trg0v2E6TfO0pquM/3U4+RJxrWr98iCBu3mIZpPtghubxLNz7Dy3ifsXV9jvj7i/JsrPHW0iaz7zD6+xC/81WeYbeUkox5bV+D3fvsjDh/q8OWvHYSaYHhnk5nDdbYvXKCWDMhmprj3Z+c5/IUFFs7MkPQSLnxwm2d/bYLTf/ULXHjzEoONbRaOHGHr1n0mZx+HNDG1WCqHNEbkCj+P2fhgk1988QTjjQG3dmPOrWxwa2NInGZ4ecZULWKoYJwk+L6P75mWRaHvkYyHBPUWIkupRRHZxCQqDI1kju/hS4FOhuSeIM0Ssjw0OVLCtDQaxwlRFDE9M8nlC1dpd9rUGxFhEDKOEzrtDq1WkzSNaTTq3Lp6ncXFRbTOefHFF0jiEbeuX+f3/uj7pEIS1sKHf9p+CpuZNNi1wyrVS5cYK/Gt5ItAE1hBWZQrYrCJxgXFX05m553qwpssq1qVLnuUGtbMjsN2ozDrR5kz4sYohJEFqdVDlNL4vlcxaKVhMT8BvMK4liFfUxyRZZkVDceOSZUhYCpMj2PgKuECgTALwT6W01wvw8S5/8zmjiGg0q3DhZqqRk0VrJADmiXoq4REin2WjOC+G2rH7EZhmFsPIXwC3xSI+L6PstfBVTqXeUWPEv7B3/2P/w+88Pzz1KKIMIy4fvM6V65c5e79+/R7A+Pli6r5hhs3V/j//ePf5pe+/kVmF2f41r0fsiCmeLLxGH6eUItC04JQwXAwZDVbJc1yFvyAcTwmiVOiep2G04/EN5XdXsjzLz7L144eZvWtT4hyYaRYbFgsd56LvRnSE3hAIKBVs7mp2siu1AMT1hVAP9VI25YNZap801wRaFBCGvFZOx+qGZiO8VC6UpWKkXCRAvqDIfVajTQzucO+gMATRuxZiKKP/TDOuHjxDl966UnWb93i3r1VPC9gPMqNjJLOCaMa0fET6JVbRJEgljCUirUUmKrzYjuhmQ7ZjFN0nJm8aq2peZJa4NEKPUKpCodFA3t/9B2iQyeRviCMIg4uHeHa2Q/51rf+GJHnpJlmuzckCjyWOj6+FIQ+ZDnkj7oVXJHuQTGPChZQW9bdgolCz9PaHhdWNe3cVAm6LMBSWqOcnij7baEDIkoZp0UI0MqIJWeVaLKUTji5BEoPhnrdWIzQsizseCn3UgFD0jkxGum50HBpQ90VqL4uWUK7D0FlPxRREHM5bWGKhjx3BT2l1Fb1WI4hdf5nma9deMBWPkhWCvHcPNTFeZS3zoF3AwCL9BxHPJRIsJDxKvulGwdGIUpt2YfcHhoAjn2Pjc0e8TBFa0HoB0StOtHkNLOHj+EtLNG/cJbtwZi5yTZeGJL0Y1Q2YrDVZWJ+njySDEYpQVRH+uCHARt31+luakSk8AOPE08+x4GXnyQnpPfZO/TOnaU2U+fy9gSbuk9zOuPTa12mf/AJJzSsbGyxs7XD+t2EuQM1VtZi/tLTbWTosXJnl/M/uMhf/3dfZKkhGa3vcvmtFZbOtKkNeiREZMKnVq/xK7/xBaLxBuvXtjjw1Bz+0mF2Pr3OWDYJDsygd+8z9fwsK3+ywsSpIyw8/TKx0qRbkolOl6fPzLE3EyBHNfTBGaJ0DRnXIJuDNCLe22X70mWWnp5l+MlNpg8d5O/89c+z/ck5hs3DXFfT3Fsfs7BY48b9NX7zdz5lcxixOxrhBQJf+MzOzRkPN1Mo6aO1ol6PyNMUneVEHgihyTyf5tQCYXuSMM/JM/Mwe1ox6A1ZPnSQGzdXULlgemYCz/PY2NykUW8xOTUNwhj3didibfUWs/MHGQx6CAQvvPAiO5v3+OoXXuYHb31EvK+30M9+c8UNAm2BQLnIKKweoGuDpDSK3E465xXrsvevBYUFjV6EudgX+nCvcWyV8xalwC8YRNuSz+aB+Z5fLCoqz4tcwGoyslN4L4WsKwwkGE9cCKTvE4ah7QRigZ89VwcC3Tlqu+AXOXpaWx0wKxNTWBxwIaQi18Su2MXv7uTdZ80HbEN4XTFGZTFA8TRUFqRqa7kqIHSkhfOqi31i6YvcVBz6vk+apJY5NcygJ72SucgfbfXlhx99xAcfflg8H9Lm10IlvGXlNQC0VsTxmA8//IjPvfIcSVPznZtvcNI/zNNPniIejTGZCjlpmhqxaJVTGw3Z29lGeAH1Zotmu00QBJAp8HLytM94fQWfhJ/7X/wy3/7oIjpOibRC2OKAsmWUGY5yAsEIerFAmZgaUkq6eekE5bmiXRNE9j66YqNMCAI0ORDn7vGorlB2sawsVGiBVjBKMsZJju/7zHSahkkVBnQqDAjUwjCTUkhSrfnWH7zJaq6YmezQiCQTzRp+2DDh1iCjNj2Bbj/BWq9HFEg8X9BIM07aYSVpyu7eEJnGyGGPtN9nkGb0E8VWnKG1wtcKXxpgELPOBz/4PseffgzPEwzWrnDzwx8hx1scmwm5tadZnKzx5IGI2aZglGgGKaz3UnazR8sAmhxATdFIxdktpUGLYs6jDdNcdB2qAD6V2y8XrT8obEAQ+GX+rgvdWoCksbnAuaKMNO9/Dkoe+oGKX2sXsQCmtJOq1HZ1TrvWaGu0RNEeTqAyXdi7wn5Y264KJQc3DFGMTQhAVQCocCk4ljbY1+rNnkNhm3Vh44xp1mBTiQLft1JUJatpwGG5rtiDFOSFu2KUb1cYDveGsYXaVVnZkTh9VgQ2LI7NRbWFkA+5PTQAzGqT5KMBaT8mET5TrQYNv4mXw3ivT3/9HL17V6mHNSbmDpKOB4xGQ+K9Eb1RylS9QTg3h9ftkw56GAZWE9RqDLMxtchHyTar9wPC17/Hjev36XZjXvnKYVqnTvLSpS1eexGufTfj/qBNLxnxzh+/ztJj03z1yycIwwYfvb/JJ3/+Cf1jDVQyYnsIu7see1uz9GYzPnj3M55uXmdx/jHmX3iC0c6Ac3/wDpPBLZ78N36FnXSK+eMKjxEdmcPSK0wELfr3Vrj5Ucyxk228pw6yu6voHEiprd3iwjnF/bdu46uE5uljJBoeSxWTx2cZrL/Dvde/S7OpaR5uI5aWiDe7TD5xilrNJ4wkM08cprXZ5+iBOvqZeTzp4X1ukdkJ+L//5+8i6zUS67H0+0Pa7QDok2mJ9gLybEAoQEaCcW+LNB4hPR/phwhZByRZmoBSyAwWFmZJkoTNtS0OHVkiSRPk2CONFQcXD9FoNIiTGJUrJjpNTj/xBBtbfSYmJlhfX2N6epYnn34JLc5x4OpNRiv3Hvph+2lsRRjAUe/CgRET3sq0Bp2XOWdWAwvL8GHb/TgtQacNqCkBoQtDFBPfgivHURl5A/O9om+tEEjPI89ycqWI46Twx014xOolCmFlFFRhWAtirvK6LALRZLlj2VwadjXMayd9rshVvm/hrZg9CjZROyBmQXDF2BRSDVCE0R1IxFVuiv3FJiX4xKG54tjF5hjCynhd4xV3XGmBuLTG3LMLQK5yPGV0vNI8Jwg8lBJFRfEDHOMj2RzIqy5q2tIw7tlxDkT5u6DfH/AP/6d/yi/9ytf5tdkv8+TCCbJhj3g8YjweUws9Br0u9WabUAWkqWY4Smh1Gua9KDKV5J4gGXXZ/fh3qXc/JevtotPjLPziK9y/t0l0Zx1xdxPTJ9w5MiUTlFkBaeGeKwz4zJUtkBImpyhX2A4JdrGy66rUFYBnUxTKIqkyLcKB+zDwyJQmjc28TLOUIPCZmmiz1+uSWP1M3y/zsTyhiXPN9Z0BtVad4WhIv5uwcifnU+8+Jw4tcHJxkrqn8IIaYWSKhqRQBEGAHwQgfXKlac7k1DyBzjN0rkjimGFvQG+vZwuMGly5cpW6ygk9ydr1CxxcbuOLlO7aFcjGPLFQ4/6eYm2Uc2imxlRdcK+bs9pV9FLNMFG0m/8zMIDOLbPAHts3tmwZCWjwbbjW2E8LpMrpSsFe5ZU8v8KAuJw4bP9f8wddhIPdc14hAxwD7hizKjMmRFEBLChBmJSmgKhgKy2QKiMmPy5RIz2Byt372j6j1oHcd6msfYfSlovKGHAMpZm/npQUShEVps99xytYPUfeKVtIbdN08qyw/+76ltbqASfb7cS+V43FlKtOGQJ340CWTGGeG6Y2d0zFQ24PDQCbUcQgGTPKIZAhXmOSYTImyzTj+C6jNKc/TBFKkQmPJJcoPKJag7HvkSpJa/44KtrEi28wSkd4SqE9SZhFtJo1oskWe3c3+Ydv3WduIeIv/+UnaR1dZnDjAtmtHSZffpyDzzdZuLdH59RT9NbX6IQpYiy4tzriT//0EtdGGffX9li+do9vfvUgX3n1IKvv3OWLv/wkJ56bpXb3Oq1jC1BLuX/uArev9bg2Tmkf/pTZz7/KaP0Kd3f7HD11AE+G6DSG7R2Ov/wStakWuz94H9HfI+mP2Ly1RydQ3F1q8oN3E75yMOb5X36Oyz84R6vjM31iCZZz8sGQrW2fvNYgOnIGkWXoZMCdD86xcbtHnOY0pno0jh5gsSOpRynPHZ7lmZPzqL0Bp47P88ZKH10LGI56DPtd4nhE1GiTEzIeDRBogrCO9iMyJNk4pt9bpxUG1LwGnggJwzoHlhe5eOEyR44dQXiKQX/I2uomp08/judLarWQbrdLq1Wn3qjx5NMvsXL7Hq1Wk9u3b+P7Pt3eDnNzc5w+dZiVldsP/bD9NDZpFdiRXqllhQvj2Go1awRzoU3lGxTgxNSD2NCxFsaLE8Iq0VvZCekVxsKFKMAlNGMMLEZ/LctylMoKuRWqExSssbGdKizA0sJo2gnbqq5wAXE4ShWaXG5fBXNYYRFLgGkqUE1bPgf2KqALisKUfZp5BVB0YJCSpVOU+Yw4U+Sqjcv9Fh5qxXAV/woH2KXNu6xU8bkhKF2wmjovQ8muUtkVGiAEYWAKo6RnRM5NeKpk2h7VZmQ0qobWsasu+84uRtqB7lK+5/btO/yj/+9v8aXPvYR6eYn7vT02NraJohrHjiyi8oxet8tEK6BRP0Gj3aY9MYHvebY7iiQbDUgu/ylTyXW8eoTOI3a7V/Am21x+9yzhIMETkGlzD8HlbNk7Y5M1c8sgGIhnASzCMCSWuZB23CYDwlQVa2GKbjwBeZGb5a6Off7t81ELA6SEJM2LcKAUktFoTE9pGmFImqVG7keasFlm2R2JQKEIfZOzq4UgxwiAn720wp3VTV48PsfMBHjCJ8kzAt9DBIZN9DxBEIU0fA9UDKIGCOrCY2rJ9JgLajXmF4/x7v/j/8WeSGj4kvFgxPjNd2mHgpm6olmTNGo+3Y0hnYbPdMtnlGf0Mkm9Lonqho1emGr87B++ymb9MVzaSjHXKw6guYf2ebV4zLGETtLFMGeljXBIRWVl+DO3DJYQwgqAl3bJvJcXjqYQxq5JFxJ3zrr9XReOpijyraW0ERRpCpKKkDG5OU5uf9rwqXue88xEfMoQrCw7JFX+cc5JAW4Lt0YUNt8BP9cTuFqoV1J05kdq9QWl7brhiuOqidDix+xSCcxK3F1x1gun2/2tBMgWZTpdahwsNGsFxoa6r1aB+L9ge2gAOD/RQk7VmGi3SbRPP2hz+9olOlmXpfmDqN0R6zt7DKWgubrKVBSSxQpfgD+5yEhETEifoDWNbNzBG44JJqYJpnw8oagxZry3Rzbq8sKJx5la6qDzgO13r9GNPda2JYdak9zIdrn2w/d4uTvg8CuPs3Nvk+mTT3Og1aDzxgrPRnBovkW6vkHnsWX0cA9V0/RX7/HSl58i/jRBthqMbl5gIOELv3ac3/0frnHujU95cXKCiedOc/2NP6OZ5kwsz+A3myjRoYYkmD+EemzEW//lt3lsCHfWYDoc8NLjM7x9bcx7H9/l+IEGz/3SM1z/809R/W0mTz7Bbi759EfnuLXV56//tZ9npdtDLX0B8doLxGdSRqMesRB0PUVXapZ3P2BJdfk/vTLHxOIJ2nMN/pW0zn/4n77N7fUdxklmgInfxfMDoigiy3K2NtdJ85Q8S61gp0d9dhEtFUoqZOBx5859Wq0WE1Mder0+4NFstmk2m/i+VyT9bm6usrHZYXJiimNBiOd5qCxhONij39vDkz6ep/gJus78lDcHFko/SwqjKadsqENaD9cBOABhVeFdr8mS7bP5KKKSa2IOg+u0CTbvqTAEuvjd9Rk2BzHgsJioD3iPhbesSqFmUZn5Qvg4sOWqJYsQbCXsqmxhRqEDWIA+KtbHWi6J7Sdpc4bQpcGp+JzOigjfXEvhGEBMqJqKjpuTlMldKNoykNU9Osd/X9WcHZbQGm3b+qFB+wYMYr14d9+CIDDK+1lW3HsXhlfwEwQ8flqbxLQxyyuLoBkXuPZaYORW7GJjr6HWml6/zx/92Q/48NPzdJo16lGNuZlJPAmNWsTNqxeZW5ilNXeMg0eOWkCco/KcZDRgcPVH1LfeR4ZmgQ2jiMnaDtH5s5y6u80WrpUaxTOMXXD3bY7BqPzFkbjafl5Igc4rC5cQ5b51CfQe3DTl39uhx05WthzzbI4Z2jSwr9XqxKMxoWei26bPt9mB04YUQpBraedcCuRsd4esbg+Zn+7geQFhEOJ7Aq1z0nSMF0bUGnUkGSqLwDNsvR/WwKZftFqTNNuTpEqz008QgO+Btz4EBa0QDs9G/JVfeolTr02SK48o9FFaME4yQBWOYJY+2q5IJYNf2gddvDafKa4fZdW2YwDN81F2IUJo04PWMdyBT57lJsTpBeSZcbo8r1wnYD+YlE7UvlJdCxj7asGUrHTXKG2DKPKoHwzPmu9XbQKFFIonPZQqQ8zONlTwmnW8C0/WvWlZR6c1acZbONnVa2nH6H4KYWySmwNKK6T08XxrE6tRETsmbW2yIyPKPD1dThY0TjxbFJO3vJeOFVV5aWvFX0A6Pzz8+wkAoO8lNMOQoc458torXLt4n7pnVO+HWUKzqTh2oM1ab8za+h4jTzDdCAk6UzSXltHTs2xvrlOXPsPtlCTxSO+sIshpHT5O/eAC3pXP8LIUJULWV8cM7mwxPwmTL0yRbe3gz7a5s77NTtDk9pVNtDrPqW8+jZgKUBc+47UDkrzVYuaxDu3ZKfyWh+gFPPmNMySbYwQ+zePHiLc2GGzHPP7MHMPVLgeP1Jg/EHH73feZPznD818+hTc9wWe//xaDnT6rF+5xdKbBc39TcOjZkzzzV77Ge7/z5/zyX/sq049rBndu8deoc+fSgHPnNtjZ3qHVjHj322eZmLjG7GOHeeGp4zxTr3Hr4gXe+cElbqqz/OJ/8LeJ0xwRttjd3YI8I+s0WJ99nmZzm/iN3+LO9RXOfOMkZx47zd/791/j6t0xf/bRfc7e2mSYeMwtLDI5M4XQGR9/+D7jUU4uA5t3FuDZSj8pBFGtwdbWDqdOHaPf73P96grLy0ssLy/jSUEQhCRJSqtV57d/+7/j+vUTfP4LX2D50BJ5lhJ4guGgR7vdIk0yVm7dJhmPfoLH7V9+y/MclWUmlCt9I1NhK1PdOmequCRBIflShhj2AT/Xf1KX+knKAh6X7Kwtu2UajJtZ7fK7BC5xWYAoK9O0BhFWGEAHTF1OjjAgqlygNUUeHo79MiNy0gFFzgelkXE5gHqfwXLOYpXlcwu93mcdinBCAfLKZHEjw5IW5KRGWwkDVYSYjW0qd2jyIu2L4m17HV3bukJWxkJsBzQoK/I825FC2PPPs9wK0pr8P3MJJb5vAKB+xDmAZVjIQ6nqsR/skezAX4HAzLvanNf91XXuWwfF9ySvv/cxUxMTDId98jzn8XM3+Zt/LeWpJx5HTnS4dfkz7rz/XU601gg6AbkKCDxJIANazRbLj9W58bHAG2tTJI+t7hZgerLYinnsc4UtutBOh9I8q1IKy46Dtvm0vidJ85IxdE0TytbZguqpm6IqTZxlNCOfJ462uHJ/zHbPtBzTaESWMxon1Cc7DEYjnn3uBT746FMkpugk9CiqSWWWkimNKTwy+5+dmebMYwdYnJXkXgfhB3h+gHGechq1OoEnyVIDZoSUeH6AUppMpfheQK05QVRroIVgNDYOhrTSUmhNfyTpjhWnVj3OPDGPzAVjnZGlKYkS5GnCeJzQH8aMx8lP8zH7F2/7ogEUDqDLAZTWMTT2z/SGLyr7i1Cq+Z5jZ92b2uZC+75XtPwzMkwmOhGGPlmWl7mveY4MTAjXtwBfSmNfim4bdt5KIawqVxmCdUV5smKvq1GUEgeKAvy5grog8Ip0gx/3cfY7Oa44q3D87VzMc5Mr7tI5CsBXAYB25hTOHIKizZwGK9RsO0K58y3weMn0FXSEOyddjrNoqm1BfdHVQ2OaHQiNLvIwjS02a5YonocfIx7/OdtDA0CVxzQmOyycegqpJZFMyfe67KqY3q07eEmC73nUgxAyzdxMk4lmi+bcQSa+8Cp7a7tsnf+Eu/fX2Fm7z8GJFkkUkfR3ya6m+HtzdGoeI08i4xHRMCaa8PAWEna7XTqzdfAlUyhefG2OuSeOIXzwZ0Nufu91pv0GL/zKa2hP4ekhapCglGZvtUd9bppb1+5xsu1Tm2mTDe7QOTaB7ga0jz3G1//6MlufrHLn2gaf/fGPyA4t89j8DJ1mjdmnnsA/uYZ3Z4PbP3qH5TTj8JkF0l98CRUEjO/vIuMaz37lOCdflfQ397j22TpHzyzSeUWy+ekK9bkOUWPE7jsfM3nmCNfzgPNnz7H19/6ffOlf+QbNmSkOT4U0Q4/u+l28TDCMY0782pe58d03kV6b7Wv3ONlsw4TPH+c+vt/m2PIBhO+zu7fH3u4WzdYEX37lWVpyiFKGlXr/4g7dvnlQdne7PP/8E4zjmI2NbaQITesq31DgUWR6mS4vH2Zj/T6/ffZDrl65yjd+4euEPsSjIbt7u5w/f4l+f8yNGzcZx4/Y6OGgQ0WXyW7aArYKn2WMD2ZiunwstKvq1SaPTDvx28r8w01at7BVPEFRTnSTBFyRELCJwA6UuYmd5XlhoJVL3tVmoRJ24TXe+X7/zcl2uAKQIqxIqcvmQrLVcRcspa7IPFR37dBnSWcWQA0wldOOWXBZ5ujKvq05FCWrUzCo4sH7YsYnlDAt3KAC/qxRt9e2yEF0i4MFoE4rLwhClMpM8YKx2AW4f1SbrnRNEMJD64rwHpr9whklMHfbvnwpC9ZNi7iM0XiDdrPOcJTwwcdn2dn5L/nf/ft/k8kg5/wH7xL273D4lXlU7KN8UJ5xJPwgYOnEBPXpdeS9MYEFYKpYeEw41+VKSenC8WaR8Wy4ToLLpCgeF4HGl6b1VXF/7eNj1yT7HO676+a5FXB/N2V+ps43XzzAhTsJazsJgzijqyHLFb3egGa9Tq3d4bFTJ/A8j1srtxkOx3j2M17ugRbUoxqz03UWD8xx6omneWIhpV3XDPIp4jg1c0JlCJUTSGFCe16O9nw0gjQzY/X8gFqjTWdq2ujXaUGmSyW6YvyY7j5BGJikSM8njxXxOGEcp6RJSjxOSJKcNHu0XLRSpghEocscQDfuvIwIGF1JM1eUEHjSuXTm7j6Yv+fy4Uy3DJC+JEsyI3JuFSnyzBTz5FlmKsstgAuDAG31WKVnH6QqmyfK/e9j+VxUhnLu4363gE+69o+4OUShpiBlWRBSfM/8QuXEiodaK0WWV8TNCxskLWh1aREUgBTM3JCexJO+GYOdC0V/emyYuso4CgfjdOHUol1ltS6AG1ZhoroEaNfGUesCKOpC/UHbtUgUTpEDtA+7PTQA3N3YJpcpUyKjvzrg8q370NshE5LhYEhdg/R8Op0WM9MtWtNNJg4foXniKfY275ENR4y319i6f4tGMkBFHtFoSBxKlE4Z9/uogSk+iMaASFl6+RBvfnyWdHuPX/mlpyBso7Tm6p0dtuvTvPSrL3D9j9/mjT+7xmuvHeOkN0SnO6h6E3n8GXrdLjcvbbLw4pPc3c54rDHFvc8+I+jUqe/VmXjsJPlwDX3vHpfObrDwykk+/P55jmTrDI8coHdvg+dffoKlZ57g6nc/ZProAc5+dptJeY1Wp0nv2jWy+Yi99R0Op2PqkwtMdaZ47euHEIGgPegz99xRVK5pHHuC7/35fdb/p7fxapN87YUj/OO3znLx4mX+ytdOc/TZReYPH8C/d5u5Vo63tMj49i6N+Sny6QP0b1zj99/u8q1rY2IR8cRTT7O2ucbe3hYrt26RjGO6u10CL+SLzx3j+FyN7UFCnO0ApnI2DDymZ2fZ2trG83yWD0/SajXxpCAMfTxPsrG9jeIQeZ6zt7PLu++8w41r15AS4iQhSRMG/SHgkeUJ2SNmX1xZvbadPUAjhE18tsBLWbmUTGkjLwEGK1SkBozhc8DQMhaOBSn4N1GAMwcEnZF1IEBIK5cgbAWbcuX9AiENoHRFAxZPGc0/e908zwkzl8xSeQwLcYXlb+z5KlvwAhbgPRCyKF5XrpslgYrzdsC4CM1od7Y2T1GpsruK9ZCLMHNxQSlc68LgmkGVLKQ9L1MkI4p7ARRGUiuNzlXBkLrG7QKxr3uK8dKVua7KaF9pISrn/mg2E/4yYHeiM0VbK2R3m3tCkjotxX/Gd13OVPV1dRPCMM2T7SY7/SFXb97if/yt3+NXv/KUWeDacwyHQ9phgFI+riDJ9wPajTpTh+vcXx3jmxHiWQ5B2X17QpBbbUyNMJITAtvPWhhHyFY4am3y6HQGYeDjp5nRNQU8JF5RgFW4A5VHQhThKSEE23sZ6zuKg3MTHF0KiQkIGh3mFpfxwwab61vkCpYOHuDCufO0mw1836cRhczNTXH6zGlOHTvM7sYma5trdEcZ5z58j8OvHMGfnKA23QGGpKMBKjcAUAQNlPQQfoAvQ4T08Dwf3w8Io4h6rUGn3WE0HFomt0QIWjuReWM3olCiVYbSMBgMDeiLU+I4ZhzHpElWMIiPanMSUa4veWE3VHk/nG1RxV3RaNeDWUpQropX2/tX5te53D7XOSTLjJSOFJI8txXrQpCNszL069iwgmE0dtr138WCpSoQdK/R2OKK0pHUYPJYRZlv6CI3ph+vKO6RwAH20m4UDKmuVuNSOo5if1923P5E2RXEsY4F4EIa5q8AfSXz6vhYR06YQ5W5hyVAtYC2yLtUVs6nYre1s9uiqPTGsYkWVCqtyLUmTXKUBaT+z0IIuj/YpXujy87GDoEQrG1s48UJeJr+KCPTmiAMWVKKIJR4kY9/f51keJbRzjq9nS7r9zc5WFMkYUivv4mOOtRbTcKaIPPGxMqjJgKGYkhzccTscR952ae2GlObbAOCQMMHH+3xq19u89mfneO5V87w8Qdr3L5xlyOnTlM7+gSJDNi8dIuL373M7sDDE4qpmuL6Bx9wdRRTvxHwxa8scfeDDxnevMMbnwzpb4w58RXB7JFpFudb3PjzT1i9ss7E1dvsXvL54Z9c4pWXtumOA2rLM0yRc22ry83v3+flX3iK7//pXZ56usnymWl2Nte59MZZpubq9IchL/3rf4led5Nzm7v83MtnOKE1L/7ys6zGA15+5jQvv3iI3/7P/4hDEyHf/I1XaRw7xdb6Jh8Ncz75dI/RlRXurY9YyyMaU3PMt1vUagEzszNkec7h5cMM4zF73bNcvXaRKPSIXjzF6tqu8YqRSG1yhfr9IXGckqkM4Xt4vo/wPMJaQBD63L51izyPGY5T8GoIIYnjGKVy+oMBaZrheR5aG90n8ke38AIFNVGsoRUu3ZMCT5RtysznVSnsjJl0nvdAKLhitHS5U6oAULswsfUWlbaG1hZ+qFyTJkbCw/OMiGieGSPk+UYCBgG+bwoZRGA8SGVDNHaw5U9t2vwYOQRK9s8ZG8vMVXX4CmhWhHTdylxpEWXzBt1nCnav4nlKsT8J2vS4DSukYQkEnTea56b6mUp3EWcCtbbMYkXstLyXep+hdexsnhv2wXMhYQTSgzzLUFmO8Ew3h1yYBPH9Tdl/tpsQgiiKmJ07SqtZoxb5jK9nHIvHbKcJO2iU8OxjZENyVPKhitPX+/bpFofROOHkiUNsdW8i0Lz70acsTjc4vTRDfWKGre5lOs2UIE8IVIjv5/ieIAprLB3rcP69PVNgh7AJkoIoMH3FfS3JE0WjLkiFz87Y3E9PCqMhiiNtFKEUeAqUEIRhwCBOTG9yBL6EhuejdG7yMLUwVcPuvCqVwtI6WkoLAt+EreNRSqcdE43XOLF0gldOPcFwFNPrDWmow9ybitAqo9WsI4CW7rGxcp5b93boDkbgRURRjWHs4w0UjWCPpN9DZ6bjjhfVCOpttPDxgxDfDwgCHz8MicLI2D2MvUiTDKlyap4Vv9YU3WY0RuYn8CSjwYDBYMTW3gCNR5pl5FlGHKfEiSJOH60zvC/c53yrignZ7+gaIOIYNjBz14EU15EDTLqKm0+m7WKOEEboOs0ytIYgDIucx1q9jrJpGnmeF2DQtYx0ADPPTUWe218RshUuPUegUo0Q+T4A6YCetG3n7OkVALQ4X3eilNIwwu7f2TFjf0sKu7xGBgQaVlwWTmjxiWKchgjIs4z0wf7JxbLhxlA6Q27gJf1g/pEW6Lp2eyV0pDxX50QXAFgWeeDmGRboQJBrbOX3z4ABHCYJoVQMd0DIgBqafq7I05wAww6MM8XeSNDOm/R2dxknQ6YY4W9ss7M9ZpTG5OMBEkmS5dQaUPMlfhDhtyeoeQqxkaDzmOlpcxJPHZ8mHm5B6KNVzgEv5dBkwNpKl4XFCFlPqTch2ROsbQn09ipX373ORAh3Vkeceu4kg72Yvdjn3pUtjjyxwMRswI1PVrjwyR2++JUjvPzEFJf+yWcsHVvm0servPHHl8lVyqTvMVzf4vArJ/n1f+0Z6rUc9mD2uWfYvHWfow2oNX0OHK4zPX+SIId8tMs4DDm3rVgIPb72zZdIxnvcfvcscrfHzOQBjjx1hPPvnOXv/ttfpXPwEHsXLrC81AEVsLKneO/3P+ONlRF3Ngf0R2PCIKXVblJvRDTqdZaWD3L3/hob6+tkuWJ1dZVWs8ETjz/B5uYGl69eRviSfndImimkDNAYL+Hu7Xs0m3Va9Rq1IKBRq1OLIlMY0pngr/zVX+PTzz4gjscsHJjjK19+je3tdS5euEGmBWFuW/5kKQiBHz7asEc1hCq0ZQDBeIjWoywWUy1MkosUeMIzBkRUvEdZyQURxZ7Y7w2W7xVhMW0pfY0tgDBhEj8IyFVOlpoOAcZLNJ5z4VHbpGopbWs5r9JaA7vTKntmDYJL4C4BoOnnKoSb7/tZN/OzBIKy+IxnQJbWhZEvKnKdF6tcToy2gEwVYVzn3VaB6F+0SWd4q1dUsO+1qBjbEgSWArJYkC0L5lMRhgZ05MrImZjWaK4R/aPZpPSYnJzk868+webWJuPRCHVoicCX1OKEznhMmufcW11D5bpwQBxwhv1M4IOMoNKaKyv3qPnCNMRSCd/5wdt8PDVBu1Hjc8uCmY6k1vRIQw9fe0ht8ghn51ocf26G6YaPaEY0GiHtToNmq0OrM0erPUmt06ER+mwP+/wnf/93WN3YAWXbD9qOMhptinJsi65GFBAOTV6tebQ040yRZMoRKoWD5Jydfc4SkmGiqefKOp2S0Avw/JBM5Qz6O2zudFnf2OHOvfvs7vUIbCJjGAR0PMjzlF5/yDjNDOBtttFBSNjqQJoQ1ur4QQctJX5UJ6w1EdLHD3yCICAMQ/zAFIvE4wQtIMky8iyl7uW0QhgmmkRX5hSGsU+ThH6estMd0x8lZKnNadU5o7FiEOf0h8NH9gzah6W41kUY143d0GFY2QETeXBFIM5OUsqzVPMAtdZIXxa2wIR6c5C2ICsztiEMwyKS4Qc+WikC3xRseYFvvutYOsvclSHdHw8BOyBUBW9FqNeZ5KJ7k0CIoGJHSoZwX44hYn/3IqjYdAB33cx7prhfFS003f61NsA1z7Ny7lbG55w9Mza9b8zVmG6ZklEZjwWWhfxNcXvtaG2lvbYgVxd2VSJERalBWMriJ0iHefgikAByGTDYSwi9MTO1mJlOnc1BwvpWH4VknMHm3piJqSFRELK71WecpPh7fVbWe/i+YqBNh4buXozWAY2pNqLeIVg6SXbvKvVWxCcXbrF0ahKyhJmJnLSTI8IGoIhHihe+coajXz1DWM/o3bjM6WOa7Tt1Fh87DrU+mewSRi2WXmwxfeQAXtLjcy/O49dO0Fhoo3TG9soa+d07NLwx9fkZeGWRZmuC+vQU3fFNQql5/KtnOPOrr+C1BXE0onurj8x8wjxmciqh282Zm2yxd22DZqCRzQmGShDW4Oe/+TLZcJdbn1xErd2HQ6f59b/x63z45ts8fzznhZeeo3PyKP0rVxhvrjNx+ihv3xzxp2/FXL69jh8G+L7P4SPLaAG1WlDkUH388TlG8Rgv8Lhz+y6Hjx7j2Wee5vXXf0iaxtSikGtXrnLy1CmkjBmNFAhJreZz7NhhalGNiYkJJienqNUi6vWI6akO6xubKKU5d+5jdnc2CIOQP//eDxnHMX4Qmp7GXmBasaEYDAYkg8FDP2w/3U2UjJ3QxQR301siTZN739tHiLsk6AIoWaV7Bx7NLvYbiMLLqwBA8ycTrvB9l1+o8f2QRqNeGAwnDeMWRLdQKtstQmVZEX5xBykreu1ItbZVX2XYt2D8dDnMquyL22ygr9i/dhQPpSHUbtHW5j2TT2OqG7WufM6Bv+r3q5bMSYJAaSCd91qEVio/rcGqeroF4FSV/aIK7zi3hQCmFRzo4u4+OgCotabfH/DJZ2fZ3NwkiWPiJKEokFEgPayMjgND9po9APqq+VfuvgopGSU5vtRo4SEU9EYp43SLRiDJ9wKeO9ZgYrJBM4rI/MDkVgqPmcUpfu7v/Bw0JmjV69TqEfF4iAg7NNtTeGQG5AFz4zFTk9/hzuo25YNkOQgNnlTowCf3wPdE0e4t9SX4Ek/nJicKYZ8yZeeE3Y82IUcT1jNzLM2BJCdTglSbto4qV4zjMWkSk6QZnm33qDXEcW6YySxjNBozjlOEJ9FCEQaSuzdu0m62OP70C3ieNOLXWDYyN+PzgpDAD6jVInzPI00yxknCzOwsgSeIk4T+KGOUQfqgPyNcykZGb5Cyvdsnz2Gc5mjtkWrNOMsZxWNy9WirgJ0QtMk60JUcYcA6RhbNW6fdOKJKlCAhrzhPJp+vLAARNpSKdcLyzDJ3UtgcOhu9UBqlcyNgnhmFiixJ8XzLHjpHO8eEanUJnuwvRfGHE4CWDhRC5af5x/ypEkbG2RMTplXufXeMHJwlLBg9SnvjHJfS1gsEuZ2ylfxIYVtoVgpmqqkOumIPCzKS4qvFeIs4k3O0lBFez6ztlxbElSwk5h4r82yXBIAqQvvGccSsEfJnwADKTHJrrUsuJFMNyeFORBCG4IWQ59zbGjFMMtbihFRpjs908D1Yv9InyRQZAjGMybIchGBzMEbVItrDPrrRoqly/M4Mo7vbNNtt7t/ZpHNvm3irz83z22z5H3Dg9H32dnqM4oDapVuommBvMOZ3/nyThdjn8JMrLH7uOE0dsf3pXQ4eP0xzZpq99Zhv/fHHHFue4bW/8gJicolQeTQW7/Knr9/neLyAl3qQ9Fh+6Rjdu7dJN0b0d3dJurv012LWf/cDjnzuKa5f3KIxFXFlo8/6x3c59cQsKvG4tZ6QdG+zeKxNmvus3d7j3q1tgsl5nvzGS0ydOcGtG+vsqggvPMiQnNXvvs2FG5v83vkRV3d2eOqpp/nyV7/EJ//5/5tQ15k/cBjf8zh8eIn1jTXu31vDlz6PP3mG+2ur3Lhx0+TJtNp8evYszWaDkydPkeU5SZKSa5g9uMDqnVV0mrO+vsnZcxd44YXnCwoZYXKqdnZ3WVlZQQBBEJHEMWk8ZtDvIYRhzKRvBFbDMCTwPQbDIaPRo60CllLaBeABT0mBEsoCBEohzzwvvUohELZrg8hLj7Sctc57ftBDtH+sMFWmylEVYZPKtEaPDepxoWYX1nTATjxgGaQUxkvHqfVbbSldCQFrvwIMdQE2lCqLQ8z+RMkM2GuzL0euWOcffO3+1xYEmryyYqSiZBareYD7gKgFfIWhEw8eq2QliyT1/bo6xbV0RTXm+osCAEogxxTU5Mpcc5Wrn0j9/l9201oxGPS4enVISXU5w2xOJK8giX9efmL1b/sYDK3JtWnfqHRuJY1MKPx+P+WNT7c4fniGiUbTXEPPR0vTB3wwTnnjvbMcPzzPz335ZRId8u47n/BzX3uVS7d3aTZqHF+aoB6FnDi6wPnLtylvIKBNi7DQ9/BaDRLPtJTzPUng++QTNXwpmNWCOM2R0sq3aBDoYvFGmwp9WThXHmmukZ4Btpmtbs+yEWSC4WDIaBiTWY1HEKRpSh5K0jxjMB6TZRmNMCLLjb7d+tYee2+9S5JkPPPCi7SnptEI8ty0KtPayJYEvm/GrnL2el06nQkm2g3GozGDXp9RkhvB9QqgcM+qlJLhcEyvPyYepyggSRS5AIQki8f4IieqBT/dB+1fsDkNTTs9igp71zVCOIcCQW5btRV20Hb1kMLo+jmg5Sp7lVamMbR9vtPUgkfbQ9epKyiVl3YzN2u7Ssyx0jRBSq+wzcYpNPZYU8kFFBKtLKdlc/lyN053LyrsmPlZ0bV07S7dJsqWglVbXjB1zlwJgaAUoC9Cv7YXcBGmtpehmmZTADrh0oes6yRExSJUhlCiTET5K64YriAknLRXbnL7XMMBB/RF4SRrQKFMabAVbrdFX9nDpyI8NAC8vzmmO1I0pGJHeYQNmI58Wp2ANO6ztyPZ04q9NGGwtc3ucMRSq40vIfMkaaaJRyOSNGc7zfA9n2RzF8+HpUTRqtVptybp7Q5Zmuxw7uoaf3r5U1rkvLg8BfWA//G3z/HJ+6s8dTInqSUcOnaAYBxwd1PQVgkX37vK5JEOt5JJLn9ygSyBoNWhuTzJN379OdY/vcr6995h+pknaS0d4vz8cSbkYRYWOuypMWvnr7L47JNMvLQI9QZ7qU+y12P9Xo/FFx+jvzugu7lHf8VDdtpMHmyx9OIi2msxKzzi3QG1ICRLx8w+mXLvH33M9tYeb377TRY+vsyugrOf3eVWb8ROFnFnfYd+mpP6NebnF3n25Zf4/g9+RJYpDh1ZIInHLB09ymAUk8QZTz37HNMTk9RqHm++/SY3r9/E9wN6O1tMTU0DLfwwYNTvkauU8SgllILJiTZ7OzFHjh7i5s2bvJdl/PIv/RLTM1OEYUCn0yGMfKIwJIoioqhOENbQuUlqVkqR5pmZ/GMnYWIWZk8+aqOnDLNide1MFaouq1aFW4gNSEJITK9gmwfiWZkLKZC6TEy2FJb1Cl1/3QeAXbHAlwygeSWsKDUU1gCMoK39hPEcHePm0FaFQTN/KTxTFxZwmzFELpahCnZFCoH25H4j4oCZds3cKUDhvrCtLv1ddwyjvI+VbSlD18IxQ+ZKmHFW2T97DCpgrdqRpBhXpbCk/FnCqOJ3a9jMsaTjHk3FI6bS1ojbulzGh3yAfoqbUjlCVFrSUeAeuxVnBbD/2rtPOObCvu/ZloFum2xFNENNjiBPlVmsNby30uO1W9sszE9QE5LAC81+VM7c7Ay//mtP0qg3icKQTsdnsLXOMIaPL6wyO93hsUMzaK344ounuXRxhTAMCX0P35cEEjQ5SaLReU69HuIHIa1mBErjexFSCDqB0ZhTShNnijjNcDn2WtuuBNZZKATEqeB9W8XqCYXQhgVRlgE11asKT/jm2VOaOMlQKseTpgwlHg8gCNgdjPn+D9/iwiefcezQMieffJK5Q4eI6g38ICwcvSzL6Pa6NJoNpibboE3e7qDfJ7PRFaHKQhbXgkxKwXCUkeaKTGXkuUQJj1qtzmDQI4oCpIzwfwLm5aexKa0QymgpoitVwcpeZDvXSqfVScIY0OUJbTpvSFnYTZfj5tmuRk7QWWCK3aT0TNpLbiRlnDSV21xaiYt8FMU1zp6VJhEnJSiFA3wUop5FaFpI2+u2wgY64GXlWkxRi92pMA6Hk2Et87pL+6L3vaHs52x6kM1xzUVuLI9w64ZX2PB9dtnR4s7+OpYSNyY7LreKOFBbsZmOm0SAVhI8Iy+j8hydV9J1LDuq8tzaeGVyVYV1eLQT/n745/ChAeCtnRG1MGAYp9RCj/XdIdk458DiBGFQIwhjJhKPPRmggME4ZU8OmZloo3JNkqVkSrCRpPTyHJ1l7CSSQRyztjtk+94mszMzzHiCo8ci+qrFt97a5G+/0uDVr52h/twL3MzP8aev32FlDKMrdxnuar75G1/iq++vcaSWcfvGDp3vfMLzv/4iN99ocWtlD60usLg2wdzzp5n8xVd5/b/9LrWLPwTf5+L9EQdffpm55QOsbOxw88O7PDd/nysfrNBLUk5+7VUmHjuMSq4yNd1GpbBwZgGVa1qTE9wZ7bL18W0GXgfIaB5c4MqF6yyfmGXl6gBQPP7sArHUfPjONdTiIncn51m7NcILMlTuI/yQeBzjScnc/CybWxsEoc+g2+XQoWUuX7mIh8+/82/9Dd778GN29nrc+uQKs5PTbDbWOXL0EAjJmVOnmJqe5M9/+CMeO30a0pQ0VUzPTXPl6g363WtMdDo8//wzfPLxWd599z3OPH6a6elJwyapFIEkiiLSNCHNTL4DNuQmpLBivE6A0sMTHjML8w/9sP00tjJc6Sab2wx4KVoEOS2zSp6fybnzbL6FrND5zpOUP0aMOeAHVYmYEjApJ1pcMUjV7xevK4u/S2ouz2k/MBOoQqYA53NWWT2nN6f3i0C7o+6b/nr/e0VeDA+cqN4/RteEXOu80iHALeBun6WRszYaByf3sZyGLzWfr36uGgaujEXgkqLtvgpZEmWNmwHrvi9td4iqEOyj3bTOrTdeuS7/HDRavS7uuXE5llJ6P/aZVi3gsQMtRnHKTj+hN0pRCnaTjHcu7vDC04dot0OkFxH6gWV+FO3QY2ssGWU52qtzdTvjc3FGo9ZgpztGex46gzMnjuFlOWk2QHmCyPdQvkcYhkSehwgCarUQiaDp19nqjsltK74kMYU6mTZSLWlWkSbCMBIupO1bMOKY3UwpwwZKge8J+7ypQlLGsJ2q0DhLksweT6GynMnJBvVaiPCmuLe6js5zdgZjts5e5Oy5ixxYPMDBI0c4dPwocwcPUqvVUAjanQnarRZCwGickmvF9u4utjMpnhDmGHaOaCD0PeIkJY4z0tScU23CVA9L3ycIPDzEIweAzgZW55NzIh1QMl03yiiFyydzjopzgDVlKNgw0BYEWlvj+T4iN6DI9wwIfNCGVVl/d9/tgcuQrisuk26Mlf+dTYB9ItHY8ym6CJUnXfm+PVDleIVdr16y4jdROuu6sFr7IkLuV601WZZZUFvKXkkX4bHAz1nvgg0sj7T/nhWOdzkq5/j/hQ6iruRtCvDCwI5do4TRZRQCsEyuJx++O8NDA8DVXheNoBH6HOlEtATEcczO3oCJICCNU3IBNc8Id47ynLXRmHrk02y0kGi6WrE30KQIQm34jP444262x97egIN7fb505gRZR/D8fJP/4tkFAr+BFnWSOys8OdHj8RMdbu6NWNQj2u0VButdooVFLl29wr3NhE+/c4e/dbjFN37lJDtbNT74zid0t7qEjRazr87w6v/qq2x+dovNzR6n5wTb8ZjhdpdJKUlrEN/e5cQvfol7n10ivn0N+eQBJo8ssXfuCn/w7cuo3R6TdcHjrxzgak8SqDqNScXS40vcG+Z8eHfM4WfbbN29wdkdzZFX5lmYq9Ff8bkazDKkR1jzSPOcerthpQVytra3uHLlGs1Wm+npjCNHD7G6ts6oP+aXfvmbjLKMjZ1trt+4wfL8PP/e//5v8Q/+/j9g5eYtXn7tNTa3t7h89RpPP/0MWZzyymuvcfPePaJa01Rs+4K97h6vvPIyCwvzBEFEr9ejVo9o1CN2dvbIlObu/Xv8yXe+Z/oJe55JfM2cQKog8E27MfP0SpaWDj70w/bT2DzPA983jcSl6ZhhuHGQwiPwPJS2FcFIpF+W80spQHpIabtciDLp2NiC/flkD07hquPoDIZjCSmYH1H83TFmLiHZbUVbNkrNwn14yR6kUJWH/QweLvHX/ayGZJ0R0aXLWz2XAuHq/SdkXxe4usSTFaOk9x+vGI95rxqGqURO9r3nKhf34Xe9/7MCx0SaK+gq5ZSNbeU6RSiJQKIQeFLheQ9tyn6q2/5K3mpRzv7rZv4uKj/NYu0Ak+f5xQJe3e7vjKj7AUInZErjCWEyID2P924N+KsbQw4s1gj8kMirI2UPoRJq9YBWFJFlms5UBx1EeL6g2ahz7dJNrt/e4+TSJDNzsywszrGz1yPwJZFn2Q5bMGWklQwj5wcRExO+UX3INYE0z3CWK7JM4/k2NJ9rUpXjFQDQVhcLJ1AtUbllUK0z5kn3XORuKcZxzdIT5FoZIWoEaa5Js4R5UUM3aizMz7G310XlOXNZRs8P+f8T92fBtmXXeSb2zWY1uzv9uf3NPhMJINGDIEFCJCVKIkVSvcsWQ1UKuakoh+2Q7XA4wg9+qxe/uPzg8IvDERVRjqiQXSopSFcVZZJiJwoEQDSZCSQykcj+tufe0+6zm9XMxg9zzrXWuQmyEiHiemXk3fvsZnV7zjH/8Y8x/nHvbMHBq9/lle+9xmxzi0+89EmefOYZtrd3OHfnffGWkjy494DNPIYDcVgnWbcOS3D6JmUeUpcIeVbTrW2Ml7TGUeYarXTHSj3WTfS2J4QJ0+vR9sgAZqUIV5YksIKDpToJk1Ck5PuOHgOaTmsVGSgXikEibZerKGyvZMf6XUxnCP/IpEiOCOw29ELgKbyZQN8QCMqLr4U99CAozaHh58LfF7/TdVpKNjwZZIhpOb6zM8P/u7DzBWDYX6eHKMZv0y3v7n2yu8PwcQcyO6eXgU0HOnWGgV0UUZFBKeJPFM7b2qgra0OkREicS+L5/hEL8hdvH9lqvmFqJkKyVTnc0SlPb4/YyATz+QKZl1jrOK8bTto2Uv9QWcd7p0uuOc/2KA99w32gqUPTYomON6wYj3ju+ac4beDs3ojpC1dQJZjKh64PRc5p5ZgvDfOHa27NHWM0/PFrfO7LL/J/f+8hi/Mz7jTw8rfv8/RPf4z6rXt87ld/lj/5zW+Qf/t9yq1N8qeu05bw7pu3Kfb3kJsbfOsPvotcnlFVhrf/9A3K3VvcePEmm1cmnHxwh8kzz7H5U58j+5P7nD2oOSo0D440lz/zDL//tbucvPIm++8ekV+9xCtvLbjz/36TB9UGzZPX+L9+84zl6i5rl8NoxWK9QmcZTdsiK4lQgtnmLjvb2+zt7rC9vUVd17z/wS3qquWF55/n9Tff4t999at88MEH7O/u8hu/8Y/44pe+yN/5e3+b/+I//y94+Vvf4KlnnufqlSsYY/jyX/kKUoJQOfPFmmrdIITk3r27vPXWOzz33DPMZjMANmYzJpOC3/+DP+TfffXrHD084eTsIdV6FaIINhg+pYM0gIlFC9Y5ynLMZDz5MYbbv/8mUuuwlIwMcXLJLpQRDEIEfsmrHOS/pJ60XVWa6DmxR/iyC4yeGPydDEViK9LzBADDlzwXjEcCOlLExPkh+0dvGNIZdCGJsK9uavvIg0Ux0AT4egYq7eNHsHYdexo93/5Se+D3ox67P3tgObxXqVl8CvldYBkZQOh0boNQ2wWQODhmAoKC0A0EQWD9nOzCHek+fRhBP77t0YW/W3wShqVnkbswO3Thea11/ExiVfrxYqxhdyrZGE9YrA3ntadq+329cWfJpz9XIIRElzlKwmpdc3zWsLFhsYXG2BYlHKcnK3SZs72zzQ/ePWB/e8pkMuUTL97g9R/cCcCAEG4OgtCJoQxt+Fa1x7R9B5rahJILb0O4N/Ww9jEvNSj/OPAxrAVIGUK+JBkmgjCxiwALH9pbSSlwJqwTxhiMDMUiSgpa4zg4qXjKF4idnK2tnKIs2H7jTX5tforZ2uS7L77I4eYOrRCcHB3x+utvsKpqnnr2WXIdciWLcoxpmpj77MI1IxDSU2hJ4wKYLTKNMw3eC7KiZOfSFd57733KsgghUxF6qAfn+HFvntSjXNCHVYVP4VnRzZHOViWGyg0YQHcxNzkVYglBkB1xHudalNKY1oR2fTFMKWO4WEkVC9tsHDvhe2oQZZFKRnAa73Yc7h0zGI/fPU/vJ/AUr+XCfE8AsevE5LtrDIV4yT7SOeqpK5SUapBvTDrYwNb3Dnq6z53+n+id2j4qAkn3r7eB4aA9UCX83T0HUNF8+otGMaZOOOtwxnXi0cP/EA5jHNaHKmOlBvfmv2f76DqA3nHuHcfCcbi23KtrNqVklmfsZivmdc07qxYjYCQEa+9Z4zluaupzR+smnJmWxnoaESpdcuHJteTJvS1+9lPPsLu5zX0reSBh9Z0KyRl6tmDrQFK8KTlcrnniyoTPPLvHE5ua6daMdZ5x/N5d/vqndvnW6Rmf3x/z/M2C/MFtvv/eiv0rZ/z83/9p/vT3Xyb/3W/w7C/8FFc+9ixXbs/Z3tzi+Nzx9ut3ufzpm3z65z7D6d05//n/+V9x9dUD/trP3GT35z/B/Vfe5IVPvcgv/+qnmB9W1HnBHaP54UPL948kd/0+zfuQ3V/hi2u8fWgxpmU8ahBijCkUVVVj1yt0rlkuF9RVKLBQSrEql9T1it/+nf8vUkjm8zPqpmXv0iVee/01VotzBJ4vf+nL/NP/8T/lC1/6Ata0/Nqv/TpvfO91Xnvtexw+uMtycULdWP7sm9/EA4uzJTjN/v4+zjq29rZYLOe0bctkMma1WrBarTg8ust//S/+Jet1jRCSJ69fQbuCu/fuc76yeAKwstbjrGfdtLSmpSzHPNq54ie9OefABs8nCR7LWKDgHKAGsyfYOKQAGQVThVL4qFEm/LDarDcqHSEWJ3bSFQwGJIWPoxB1XOBJnmU0FN2WPMIfhXaScYEI5AZvJVDXnVHP7PWFF8PHyK4NGaghABw2evf98z4XJd3ggenyfriznvUbnk98P+l9hTeiYb94QRcfvO+q4HqwmTzg8F/af2JprbM0tY3tKhTehYrGBLwf12YfKSxKmxCpYOgiEAe68G74XNJCE1EIvP/7QlUwnqb13D5t2GpLjJUBfMWx2Xh4/9hgvQSZkedT8ixj1aywdc27D2u2NhTnS8vm1hbHZ+d87KknAMeLz1yjGIU+uZf393j1ex9gXRvFuQMo61midEl9lxOBiCmpAi890oUIQYvA+RiC8x4vUocNhxSJwZWxyCj0VB7lipU1ofpRJJBMV+hlLNQmtEf0ztFYR5lnTIucbHcD4xQ7QiI+uMvq9l1uNA2/vjznnWef5d3PfJ75pX0ePrhHtV5xcnLM3lbGx1+4jJCKO/fWWL8Oczq6gALQ8boNUJSaLNNI57l8/SYqy5nOZmgpQh9aJcm1Q+nHm4bQ9wH3nSPY59nShdOVkDhnkahQjEFMN5BgrUESUlJSVXHqbGSJ4cWueC1p78kgbeVsACZ1jda6U1QQUmBbg9KqE40O7KOEqBforENK1YWKbeyrncLI3g30QUXvSCcAKCLilcgONPmu2xLdd/pCk2GYONyrtjUQylOD7ulAF1aIJPUie1tE59P3YfVk3kXKUmbAJAQHb2AhSLmBF8xj5/By4TipCxTREUZG9jSK9PtU+iZkUB2IjOZFQPsXbx8ZAKpIKxsBpx7OPNimRdcVmYhNuhFoD0fOMx3nPLO9yfXNMVt5hsw0731wwK15G/SBpOAczdbWDr/ycy9RZhopFB//1GeZH95lfscgbt/Dna6oxBIhPBtXZvyDn7nObHuKHJcc3Z7TzGaU21t89sldfvoXP4NarCjGMzIWvH36Cr/3R6/xN//aJ/iVv/Np/pt//mec/cEr/OzemE995UW+/t++wu9+/5izD074/PM3+II3aLnm45++xos7MN3JmWSG3//2XX7wxjntpT1+cMvxjVu3cUKzqhta4xH5hKIsQn/I1SqWw7ecm6AHZ6IcSKhOs2RZzmg0QeDRWrG7u8f1m9e5ffsD9nZ3mc9PyTPN8cFdqsWCrfGEv/XLv8w/+Z/+U3b29hDe0bYN0+mYX/ylX2QymXB6fMzt+/f47ve/yfx8AR42NrbJdM5ycYYSOca0ZLlmsTgnyzJu3ryO94bXX3+d5XKJdyEUleUZzzz5MfavXOK9D+5yeHjCfH7O+XqN88TekNC0NU1bf+TB9pexOefBuuCB0nt6STfEmn4SeCEQznYioxD6Y0oR8wJl73kCfSFH+Ct6konNCeEL51zQ+rOGVDDRGaT4vUfBiE+vd+HS/tXeIH0YwiST0oVdfbIsMdRLXxXcvTYAdxfecwNrMzA4fX5Q/3YXlh5iNn/x+4/C/uR1D/f96B3okHX8fI+J+9BPl5/ZtWSSncOfiQy8w3qDj4yvBbw1jz38ZqP+WWIS0jWFrV8c0sLVka7ex+b1avB3z/z1jGHf9m9RtYzyLBRcdL+5AG9ZNw58sJ0yH7Gxucsq5raNMkGmBFjF1s4O88WKk3nDN195n63xiBuXpoDmySevI8S3+3MNVEW/UJHGYliIvAxAVMR2fM77AM668Re2wBpF8CBDviwEUKhiukamFbmWrEVoGxcmpQvzUsZiMxwIDU7gjKP1jp1xiZuMmU430CpH5QX8yt/gW1cvc/jKq3xmteDTb/+Q548PefOLP8Vb129ydHKCqZfYOmN19pBLVy/zqY9f4T/7P/0zvvr1V/njP3mZ1773NvP5EiUDc6VcYF7qqkFmBS98/JO8+857PHHjKlIKmqZFSU+Zhc40j3PzPog3JpiRCqxcBICkHGLvUGJQeevBeYsKkDt2zaCzic4FMefU+zdV2XrvI9BwSBmYwJDPLGNkKP3uDqkUbWVii0iBa3wnkE9kFaW0na5fytlLIe2+U1GS7hpEazqnHYwP6Umis+nBsei6jkQw1M9MkZ4kH5ukRuBxcW1LNlGSKMqBaevnhqAvDhlEkoAgiZXWlfBjkU7kYiGe74/vXMdWDs/VRzAvu+hBcL5ST3qS6yIInV1+DE3UjwwAP7m1wbuLNY0NC6DzQQiz9p4Mz5ZS7Geay9OSq5MxL1ze4dLmjM1pwbgsyMuSn3vmJv/V177Lt+4e0XqBlornrl1iYzLDNRWNNcwXK+p1g56O2ZhmPPnZfSZPP8vq3oJWCU4XhtdefshBZTlrNWorh8mCxTcXrBoTkuf9AzJheXgLnN3g6OsP+bmvTLl7+Sq3377H9Nu3+dgv/xRn000+/5UtLm2Nub43YbNsKJ/a5jf+k5/n/OCcD354j2++6vmTBznvP3yAyxdcfuoZKplT5CXjfMzJ8TFaCvIsJ+U0VFXFal0BjrqukSpn/9IlTBtaBykpaeuG2caMT37yk1y/cY133n+f1XLNkT9CKUcuPbPZjKc//xl+7e/8PT756U8yGo8wTY1pW771za/zwTtvI/DcvLbL8ekJP/jhuyyXdTfAUpWWtTUq11TrilznbG1sgg9Vd1evXeHO3dukxcd5+OFb7/H2uz/g0qUtkJonn36apq14/4M7zM8XVFWDjTIedf14AaBSGjHIAQyK/Q7hwuTQkVEJ4KafSi4CG++jX+Y9wokQpkufcoPsFxmMVNfntyNCdDSyrl/gEjjziT8Ybj3wG4I8f8GiDCZ8J7dy8b2uarZ3L3uwl74tUkinMx2dserMSQKTKQSbQg5p/52mxOAKEqj7kSBrwD6SPGQPsUo5OsyP3pFHAO/QUNIvBCRwmI4UWAN87Dsb2/8pr5Dq8YbfkqhuCocOgSAMw2k9gE9wKi0efZV2b9iFEFhr+uptJLUxXSqGh6h/6LE4ztahh7DLA2M32dhhy51y9+g2h77mqt9HjXP293e488F9PvmpDS7tb3F4usQjaJ3ixhM3EQqEIUpPgJMgvEMQuznEMeKdwceSw7RWJX0y60I+YKj4dR3r7KItamNVo1cWoTK0ViityPOMLAuhRCVjgr1MJxF+Y9NafGvCvfFQr1Y8XC1obt9lujFmPBoxHueUH7vOO3LF2bdf5/OLiiftEZ//oz/kygsv8MrHP856tokqCn7w/jHf/cG7XL+yw9Url/lrP/8F/urP/xR37x/yb//kT/n9P/wOp6crDo/XvPP+PaSQfPLzn0Xqgr29baaTnKb1HB2dcOXKDriG89PHLQSdHAYiy5XmVUon6Pzibr6lzkUCEVk4GQv9wniUaQy6JD0U1pAknxUYz5AHLmUIAetM4qzqqrchViTLULGKlORK9uxZ9Cyc910xiRdDENWfv/AiKD4Q1ACim0S0DKjYnzgV9PU3gw5Apoeh05rCuZ2tVL3d6UK/id6j31FiIGUXAhbRxHdGsnPAXWTwhgCws2vDk4PQJlMF29anHflOMxHn8am0mUHXEO8+fHEfsrh//vaRAeD/8ude4nvHc/7lq29zuKwQzmFF0OV6ZjLmK1f3uTwR+NoxQbHlDNlyjRWOYjKmLKbMNjb5jU+seWpU8vV7c/Is54vP3ASZ0bTnGOO4+9q3GZc5O2rNzpM17xwsuf9+za254O2F4N6pwOY5dWsoshHivALZ0ljTtSQyxuOFRYgxYjLlg9bzB799gM5yRtMbvPtdx6X7bzDa3GBTCc6WJXcbwZ99cMx61VAtKxZLx51zqLOGZrTF7rUNrjz5DDeefIpXXnmFH779NpPplHI8wlrH2XwelNFjyEorhc5yskxjmtAia7k8R0vF9v4+128+wdUbN5huTjm+d5v1+RmTUrNaHNJWNc8+cZ0nr1/m+vVLHD28ze0PJpRlycOjUxDwza9/neMHD9jb3mY0nfGvf+d3UDrjxs1rvPPO290gkFJhbRgsV69doq5XCAFaBaHkTCuOj08wtgUvEU6wqlbM54fcuXO3o6KVVuztbbO1vYH0kvGo4Pbd+ywXi4882P4ytlDIEQxGjzgGoz9ONCmDlpPSkovyK+F7yTNN3iQAj3iLkPTY3IABCf/rTA+qNgd6UXRYavD3AMR1BkB0Bts52wHKYVi1B3eDMxrMbR+tS+chD8N1ovc0O4+zewShug/Rwa0YPunKnR+9Bs8jYNd3Bq7Txh4sSD51TBmecRKtZXCPBmxg2Ef8XVw08ym3h6h5JgJQDXmHA8P8mLYE/rruLPH/YRj34uYvhHbhIvhLBSDhfRdFv323LzeorvXRiUljY5Rrchu6/GitULJgYzKmOnvAkS1YrDeYjVo2piU/WCz42rde54N7J3iV4YSjyD1X9nfZmo44WIdCv34YiQj8RNfBwPvQ/cbaHuS10REy1kb1gKhR6ZODJNgcFdTGM18ZilIx0iEfTEkVWREXukZIiRQaIVuksHGMCZwxTLylFtAqiTYNb797i+sKqCcsiwkbO9scvP0OTx7dRj494c8ewgMLH1+uuPntb7P11g/51uc/x+1nnqJqDG9/UPP27QOeeqJG+x/w/HNPsr2zzT/+jb/Hb/wPf4E333yP//Q//X+yrBzjkeZzn/siWabY3NlnczamLDUvfPJp/Lrl7HTO22/f+0kPvQtbyof2Mac4FGiEHDEhJcKBVx7hZV9MQG8f0zgMbGu0WyF+H9h1axGE4hHrbLQSISe0d2c8bdsihcS0bciJdHQi0kr3wFCrkCOY8ufy+HsHpyYyYL7PlUtgKzmBPUN4kQnsTJZ1nSHoKoZdBHPhasPzR0BdeCYGx4r/pzzF+J2B642LYGwoCZN6+V7wegd2Mq1Vojtmsr0incHFdKPuaB5hfQfYneuVGbzwkbX1XV608B+dif7IAHBjY4O/duMSm+OMf/m1H3B7XeGc4/Ko5Feev8m1XCIyj80FhdBkZYbEMSoKCteyfvCQvCyZTjf4zPVrXN/cBZVxtZwiCgltxurkjHfOa5qV5vDklHUraclpnKHxEqk1Rme0rcPLjGVb49pQ/ZJpjdKK1juElmiZh4RU7xEZKBGkSyoyjnTJYp1Rn67JdI6Sa1KivpQZ69qzs7NDfkly9PAILXOKUvPw4RG37txluVqipWQxP6Oua65evw7ec35+TmsMpjVA0MjzTjKehFyamzef5Lnnn+P+4X3u3H2X9955Hd+0jErN1d0ZTz+9z8E9eHh4zPnpgred5927Bzz4736X2kgu7e2zu7fLpUs7vPPuO9y5fZ9f/7Vf497RGTevXSYrSpTOsNUc7yyNDZ6cB5xraeqWvb19pBKUo4Is1zx8+ID333sP07YomQVQLyRZpmga1+XIOed4+PAkTEQp2ZxNKEclxyenH3mw/WVsxlh8YyIDGBMPQmws5GEkmQkpkN4iTWiRpbTuQNuwUmzI7iVjAgnEDfPyBiyg97TGAjZO9gFfJXoDlSzGMPALfZ5YCgsmw6aVHH6s9/JIAGwADBOD5EPYIgCEgTi0T2HfuAc/qNJN3uiA2RNxse+eQ2eYh8CxA4CD/ST2YHjqEVumGzB4/5G/fbxvw+8iOlArEZHdDR510MwOoMJZcDIWJfwYRu/fdwtrS6pkTCHeR+9RYvYuAsJkZ1IaRUiQT03qw/fSopxYhtZaVo2J6Qd0wr9SwPPXtimzDEzIZcpEjlMb7BYeSYW8tMfWpS1Wi1OOz9b8B3//E1y7csDl3RmZkCgh0MWYjf19vvqdt7F+wGx7sM4GBzKCPZscosHvl7iNPmc2/ZLhnTLTzMoxznvWjUNmMBKpXSARBISxL2VgdbSU2Fh8IIQHa8m9Y4ygyQvE2iCVZ5LB1Zs3OJqvMLbm4L1bXBEG7VvsSHPfK8oXrrM+PefkzjEnX/8Gq5GkvPksn/jYExjrODw85vjwkNdefY98pLj5xHVe+vg17rxzi7/91z/BeLJBxYQvfeVnuH33NkortMwZjXOm44K7p7eprODw6MFjGX9pSykC3gbiw8cq+QTkJCIwR7FdWABmqcNEFHxPYVlixxaiAH10wkxrEC6CxUGhyIXCB+/xPoy/sPJF2yZFlA2jL7i7wJyJLu9OKoVWilzJDhAhLioLJDuRWslBCDcbYyIrF9NFCLnBffQDUhSmy9P1j+x1ADgHPF0HCnsqcQhGwaVCxMEakhBgB2STk5qOMbD/XaqH8x2oSzgyHdUTbbXjwtxL9h9PdMjo0jE+6vaRAaDwnmq15Nnr+/za08cczCveXKx56tIOO9JjS0G5t8OmFYxRMcHeY3TGUuU4YahX8+CNOMf16YTRbMJyeYYgQ2tJWZbUpy3fvPeQ2oNQuqNqvZI4A0IYhFI4YzDGBqpaKhbzGmPaAAxI1DOdYXFRYyr0YAWVado29LNNSf1JBTwrStZVRZZnLOaLzpO5cvUa5+uKdV0jdMZkMmGvLBmNRyzXK2SWUaigoZUG0M7ulCxXeGfxvuEHr38HnKVtak5PlpyfnXHj+jWq2YzvfP8dFqsF3knmD+5ydHqK954yy3nyqSfwNBwf3mG1OkEqyXMvPs9rP/wBk/GYFz75Ek/cfBIpLEc3pijX8NtffYuzZQPeMx6PGY0LqmpNXdesVzVt67h7/xbvvfcerXGITCKcwjlHpjIu39jBGEtZlEilWFcVx0fHNE3LfL5ASEFbP972R8noDQWHiSwBhMXXeYfyiiDkEJLQrbW0bYvKQkcAFRPcvYgradxSgv2FApAu2Tp6Y/QTOk31Toagm+wDncEP8VNDQNDnJ/ZL5hBY9Z9OYM8623nLw/ZwdHeAgefpP/R+D0yJ0doYavCDAHayagNPtN/PI/scerliYP4uLBAf/k76W3QmS5B+ju4aohVMWlfpniRT+ej+HscWGsqH533Iqk+7QAyEbB2d0+G9J8tyNjc3aOqKdVWFkBqdH9GFhlIPVXzIz2oI+UZCxS43QlBkQRKpbQ0FBis83lnG+RhZOOxiwdnb36DKv4jDkknPrBD8/OdvoESGF4qzCqaF4+aT13l4eh6qCMMpBOmQEAdECZCZIE+CufH3tel3gtiSLLwQU7vQQjEZaSaFYGlFP6foi0WyLCPLC/Jco7VGqhapBL4NC6QzDmMsE++ZSEmlFCLXCN9Q1xXf+863MS7nytjx0jXN/NaCPBPcfHaL5dmKB4enfEdImr0Jb1UC+903uHTngLaY4pdz7PKc+/cecn13xuLKE/zr332ZV77/Nm1tcFbwxJUVSnvKyQZKZVy+tMfGdMRsUgKCxWLB/PxeJ5z/uDbnHMIGIWhBL/oewARdsYBABBAoJS46yFmuEUISQq19oYOIlbERtZEJ2eUI2tTq0PdAsE9V6MWfO6AVhkIHuoLItI/HjV/yPto0F9ZjwphQsR94r9kqO+3AoWMllAoEhQ3Ms49jrwNNg61zVC+8Hq1uAogRdnlEh+WGiSyClM8bCSNU75B3l9QLUydA2hECnf0d2K1HnicrnO6j86GXu4+pJt36lPRgZbKrItrFnwAAHG9sUDdrRF0xnWwylpr9zQ1kphGFZroxofSaaZYFLcDWkRUFUmc0tQ1pinnJ2XyJ0ppxLhgrKHan3D86oRKeIsv5mev7LOYLXj49p5KhNF9qhRYZbWuQSmCaJogUA23TsrW1zWRccnj/Pm1jyJSiWq+6ZFStNE4ESZMyL8JANmFgS62wzoNWQcoAcGbNen4EIghgKqWovOf9xSGpKqi1htW5Y50XSCUQwiO9IMs0ushRWuOBtp3TVpaqqZFKUdUNi/mC88UK7zxbswmmbfn+2+/QNg2r1SrG/QWjskAKuHbtGpcu71EWGSdHh1jXcrpYoXTJxsY29+49oKkb3nnnAz716c8w23uC5vCtTogVEfpdZlnO5tYmCBkpbM8f/MGfsFyucc6jdUGmNNYaLu9t8Hd/9W/w/ItP8y9/83dAKJaLJVcu7VKtK4pMUY5KyqL4yIPtL2NTSuK7HEBFQjMpUVnFyjIlg4J8qupCDDT/oucUQo3ygn5WcPpkB4RkmvsDu9EZl/j6UNpjaPh6Oj8tixfBI4AxfbJ/B4qGEzgumJ3bmjxQKQgBnT9H+8kP9jM0PHGfDIAl0APAQd6LeHRf/s8BgOICpL14Et0hB99JHm8C1MOqaegyfdK/SdzbeYuSMjL7QXi7A1nqYrD5J7n9s//or6GVInSeFVh0BGygRdBOK4sg7dK0LfiYL4WkGE/Y2t6hrmuapkIAeR4KIpT05Flo/6aERIoWUBjnsU5eWES01kgBeXvO6XzO9uYmhRUszw5gvE1RbDJqV1Tz+8xf/RqHK8XnXrzCN77xMl6EKtoyL5FZzua05MpI8vd/9gZZpphOMialoiwko1ySZ4Iil2RKonQIQTnrqGtD3TjqxtE2jvXKUDWWxsXihMjcWms5OKmpvYjJ8T0D5L1ESk2RBykbpUJeLl0hkKVuDLZqkM5RCs8Yx12jyKxA3H/Ahljx6Scv8dKzW+gWXjvxnN6q2cjPqBrB1k6OOV2wqj1V3bBuGs5O5xQSruxucvWnfx59WiPqltlEM1MTHj54D2sUWipef9/w5DOXuHPvFlVtcChUVrCxucVkYxPrHK+8/Aqbs8drC9PEkx3Y6OewE75LnRiGTRP7Frro2K73LyQHa+DI+dA5RMb8vSwKQCfGSkVAZ1uLUKm4JJakJLYv9f2NwEXJwDiGoSAHNncYdwj/JsZbimGk5aItT8yf1gqd6QvmJzFwYbedsX7EyY33rnsq+r9E4uAuWErEwMETsQD2IgPYw0WizU/2L9m0Ye61x8fI/Y/KII+/YTyEUip03AN8zIFGhN/IeYH0fXj/o2wfGQBuXdrn5P59Thdzmpj3IZUMhcjViuwccuFBNzQ+lMSbqqG1gnVr8JgwFpyknI5Q0xFlUaBHJfuXdjk6OkZ6x6VizN974TqfOl/w//reO9xZVBRliVCS0WhCOZqQ5XlgsaoKleXMl0tG4xHl5iZqvcbYlq3dXc6Ojsm0phjlrKsapSVemPgbhdCCd7F9ik8FAp7WtrGaSCO1wsRwjRPgvY2VvBlKZxR5hlICLYOx8jYwpUEM1aBjD0ohFCfHZyzOl+AtWoaettZZWtuwv7vNaDTi3v37QVMphi3zvGBja4t11dC0htaCMtAax+nZIWdn50ynM7JMc3T4kK999Ws8++zT7BZFFIsMybRPP/UUBwf3uHXrA37tV/82eZnzZ9/8Jl//xrdDWMlZ6nqFlFnsBCK5fHmfnWnJFz/zPL/3x98Kn/MOJByfL1neO6Kqqo882P4ytiAErQhiYQkABq0xJVUAfsSm3V50wCAtOmnOO+8RLgGr3ttKj2kBCkK1/etD4+CT9zYETV1IOXX05QLbFT/VveH9gCHr6L7eEHZ8Wmx51oEtMdjnBU/10S0Bt/iVHwEGh6Fh0d2SIXikv0+D9/pK1fBGqgDtq5If8ba7cxcIJfr76QdX7Ptqt6EUhPcEYW8BVjhwAh9ppkeFtn/S21c+XjDKPb46Z21Kitk2QghaJ4AUtgz9s40rEVGqIiS7e6Q8weWhR63OcvCGQtZksiXLM5wxIWJgztHZmMYpqragNZaqrrDtGu89q6blZFHTNkueuX6DK3t7jIsJq8OHTLZzllXLyekcc1rx9qFhc/8S50bz1JU9dnf3ycazoPtnWrY2J3zu+SmTSUFR5ozKDHAIbykLhRQ2AgdH28C6DnnNSgiUF1QWyAWmDcUpUkmcDL9lZW0MyYX7F6q8BQIVcgulwrjA/mRZ6rAQfvfWOOra4mpD41oK7ymk4HzRMJ1kPDhZsRYNf3Bwi6+++pAXtxQnpxUvbpZs70w5PFzgGph6uLExxVQN311DJi2GhvcOjnFHZ1z+mV8g2xgj1w+YVpbz7/2AV//tHeaHEpVLPv2ZT/PWD94kH5UUD3PWq3PG4xJVjnEozs7m3Hxi/7GNQaALq/oYZZBE5k9E++d8LCzoc9qGIUnnPc6YPo9N0PcPFklrFOTAOQ2Oh0TooGghhUSVijbJvnhFKmRLwDHkEHqyWKjlBcERCAe84DynxzTveyatD9Fe+Nxg3nsSay26gpAEGJN9EYPPDqx5vH7RF10AXMhg7hDeYC252IEoMYV+aF8H30v2vrO/iWzwHqG4YEf7CuLA7goHyTXuKptFLzQjRCr6/PFs4UcGgF7miFyBhTvzBaUWbGqFq9dgPGu7xmlHXSiyPHSXqOuGpjFU1tJag28cu/s7YdJniqUUqPOKYlYymY04PznDVo48V3zi5nX+cVHyf/mDb3B0dBhCZeoEnWWU4ymtt9i2ReGR3uPPNTILCvaZDOzbaDLGGENRjHDW09oG70NOTVqLlQoTwbgG37ENYVFfrtehmEAE3SJIyc0hVJhnOuRNCBl0ooSnaVqiQkTwhkRYEF2sjpMEj1cpxWQ6ZjIZMR6Paa1Fac3e7g55XlJVKzwCpTPW6zVaa9o2hIGqpsG7IM1jmxrTlGHQ4zg7PeSVV88ZFZrWuAgANbPZBs8//wyvvvp9lssVJ2en/PZ/+/ssFss4PgXGVNR18PDf/eAe/7f/xz9nMi5oWsNqXXFyNsd7h7UmMlePd+GFKFBqbQhbppyJ4A6FBtpxwqmYGB2qxGQsHAnMUXLs+jnaT9KO6RqCsA+Fd0UnIppaAomBR9p5fz4+Dm/RgOVL2LFHc/2HeqCVYF2Y5EMPOXnt0Dna3XUMIeTgCNHIk1xI+kT/dFYDL9wPWL8uTJGAXg9ewXcFLIn1TJ9L33EXgKfvAKmHmJoRjLbqgLeP4eC+3ZIbXlOKl4rBbh/Tlpn7If/QGHLtyDjCGYO2PilvAAKhc3Qs6pBSoAghYKzFOk+RbaAkeNOirUE6QZ6NccKglKWxFdIaCpGhdEVrlmhWOB3y3RGWxq25dXbOvYMjvvTx57k2ntEc1chsxaqtMUqx8pqXPv9ZdDlmTc5skjOabeJVTi4FplmDswgXbGrtPKZukAoy5XE2FPNI4bDeYQ1UlaWtQ09YZwmt2towLjIdfsOqtYAMcipx4UzlVGH8WKwVoU9824LQlHlOnrXMJiO08KyritbCqrHMnWOKAyqUd2Sy5GhpOZcOU4M7WfL2XU+uNG8WCz67qNBaU+QC7R1LKdnZ1FyZTHh4vsS3UFnLm1/9Q+69+w7XP/Y8G/4W2d4ue7vwN355yjd+b8HlTDCWgrt37jKdjlgvF1y7fpl335O8994tDh8eslqe8+TNK49xFPYElRg4eb2/5i98bmirBcQijWAzhVCk7kJdgZPwXYtDZ3utTeuaTtsvaVgqGZydtjWBhYu20kWhaWtcJxYtpERpFZwkJTqg2TFjcAGpBTsR7ZEQUaeS3gFnmC8b/rfOh/F8ASw+cu8etcvpuB2M7P36ZKI7e53Yvygd3o3oPq7d7ypeQ7KJXYVxBOvJTsoBidDfjQDwnAgpGN4HsW0i8+p7xZrhUS/89v9920cGgPPDB7QutNcSwlKSoa1kpMC1gpPKUJaKXAh8XaGXFq8sVR2YMGss00xRO4vXBRMyRllB3VQszwWYYEgQnjIf4VXO01sb/M0bl/kXb75H3TY4CdQVi8UCqQRaCpSPP1eWwSJ4IZVxVMYgdRhc88UCLTXOWWwEZTZKFaQSeCHFIIlSdAucFlDq0HLMC8G6ajDWkeWaNtNoHXSQQkNu17MXIg1ngYxZPlIKikwzHo+ZzKaURYEggDQlBG3T0jQhV9CFDi9Y60IehBQ0TUOeZSyXS7K8QGmNNRXnizMmfkrThknZ1GusCd51qFZU7O3uMZlOeeLJJ1lVS/7L//K/4uxsQVOtEDGYBZa6qcmykvPFKW+/+x6TyYTxZIwzhkyHvEkbV7mU0/E4N++jDmEKcSRay0Hk5oHQ4tu7oJtmks6VipVw8TcSYsjYJe8NhrOqxy3RZ4zWIFR9mhDmsj1A7AyLH3iC6RYNrFAXloEu4b4HXoFdG1w1vYFJBjDtUvRGKX65x3NDZJTOpQdfwxyZ3uSkvJX46iB0OwSEQ6PXn6+IRRqiu0dpH2JwDh347S8t/GbO45yJ2n+iPx/aWCjgUQKcMDgv8Vbi1SNJ2I9jcyYWHFqUX+Mrg7VRcFx6NIGVUbRB2iQDKQLTpn2D0gUyK5AYpLcIZRFSkecgRUPrWpQUFJqwWBIqLHXuUChwBu9qFBrRglt63rt3zj//nW+w43OuFwVf+cUJTbUGlXPoC+pGc21nA2Usdx7W3D8+5ORswZc+8wxKCurGsF624F04jhRkWVAK0EKjpGW9djgszgnAoJQg14qmbbpx3FiHsS7kRglPpg0KGwA9ohsrQV4k5DGdLdf4LocXtNJszgr2dsZY5zk7r2isY+4FOVAbzzQLn7ZSUGQ5mfLcbhzKO0pruXse8n4f1i2VXDPd3KU6PecLV3Kuz9bsP7nN4uFDPjCORQOHd+5yfu8DdkvDJ7+8xfiK4ennNzl/t+H9Nw1nxwcsWkVVLTibnzEqNLmGe/dOOZ8fc3Z+Tt1cfoyDkK5yNgCjHmikHEARn8dSKowNLTBTSolSCh07cwSyUHaEhYhMWprHiehwMfSrtKJt2sjSmi7kW9d1BIYR5CBQStKsW7JMh7aiDSFkjEBpGTUx+16/CayKCzYurKHJ1vXMYMAj3omOEU0agL3NfGSdGjihXVhlsPV2MNnowfuit/MdAzjwrrtK4At7IrJ9IjrD7pH3w+/orO8/G3cqE1sb3wsFf4Fh8t7iCP2ZjfF4ZCSdfgK9gKsP3qMWGmMaNvMxW6Mx16/vUpoVZ/eOuHXWMK8asrVDZ6Bki8wE69axbh2lkFDmNK1lWzhmpmZ5Z0HtWsZ7WxglmYxnFEpjMwWrhnpd8defe54b25v8q1fe5E5TYTxkMkhY5krSxCpXm1rSeEFtHcYZcq/x1oU2UtpGEWODUBITxVitc6HVjaeTnRj+6MY6Vq5BIHBCYr0IodksQ0VA4X3KCZDdYE0UtiSwUWU5ZrIxpSzLzgjWTTCcSoU2MMZarHMoH7SWjLVI6YO8jDWhD6j3YcIpHdu/BC98sVwGcVoP1rZYa/iZL/8sdV3xyre/y8bmFnt7+/zwh2/zZ3/2Hc4XFXk5oo0VVEqo2LopVEIrldG2NYvlgrZtGI9GXThbCsG6WodCm8fMAEop0UUOUuKFCosJqZw+MHL4MDGlJ8jARKAnVZ/cG/oriu78XWcouDABOze786/iy/F9F9Xvh8xeFBqkNyL0gCd9u3ffOxmQ/v/krfc5hD4aie41BtW+yeh/iPMbgDnRZ9Z1gfCYF5NyUrqK39htInzGd/ejM9Bx/xfBf0iG7oBndwcSDr3onXYVhR2eFd1jx1C6pNAvQqVf+p2iNqNxwSB66blwKj/hrSxzXNtinEQpTVGMkDrkH4XuBoTk9Oh8eW/Btlg8eTkGFCrLg4isV7RVhbA1wimsb9C+wpvQRUH4NdLZ0A7DWcaFwnqJFxuoHJSQtMsVoxxeO1jyW/dO+McvXeHTq3NWTcWq9Xzt7pJnZw1vfu11aiO4dmWXO/cOmU1LWh+YIOuCQ6d1ZFsdNK3DtgZXt0wmGoGNebUKJTOMb1lWLXUdUjDKPCxCrVGsKkNjLNKFDkISQSYdBsL4igV8TdPSthZjgyac8yB16LwxGY149il4985DPEH+5cw5jFSMFbRCcG1Xc9k1PL2seXe35L18E2kq5o2jbmvKvGBlHC996VPsbWhYrdk/v0VW3acsJAf7u7jGIRYVxgvOXMlrL6/ZzWvyL435/FcuY8RDHhw8RG1dwhuLM2e88b3X+ODNltzWnBtNszzh8P7jlYHxca4iJd73TFRnWnzHnYV/ncfGPFqVdCwjQEthxU4aK34rNAdQnaOntQpdQDyMxmNsag1qQ8FdluXdXFUxL9B7yIscZz15zBn3BLUJ6z3WBF44hXkTGLwY6h0UVkjR2TQwvTPvkjPYC8qHyxqEj6Fj71KP8YG1p7PSPljGR8O53b2Ja8rQ9if903TOF/YbgV/CF8mRTpETwcBeus7CYny8nsgWStnbfeddiISJsK6l1pg/jin8yABw3bS4dsnKKXY2p0zLEUpqWuvJ8xEbM8Wth2fYAp7av0SuJafzNau6wokwGDIhyL1ncTrHqRbTNBydnDG7d8TG/gbFE9fIJ9usTu7g14bRMlD4P/PS80yKEf/ZV7/JsmlxzjFWGUrCNMtDQ2oPVgjm6zWGYKSKLKd2DTub40idgjWGs1WNlGBir0OlJNaF/BwBHYsUBr0IoE8FvSohBHlZhIEhFQh1YXCmfIpUyTQelUxnU/KiQGcZIGL1caz9S8wVIKQky7MYTiTmqIUWSh66jgGpP2rwPoJyvk29KrMMITxtY5hMJzz7wgvUVcPh4REvfvIFvvPKayzOl2g9whrTic6GfK4wsJq2RkmFicOprkOF9agckWUaIWE0KjDGUtfNjzHc/v23FGr10Uj4OJnShO50qCLg8VE001qLN4OpIQVC9gCD5GVGsJPaUPUAkAEwS+MDQMSWdMQZ3IO+mMnS72cILOOWSD3r+vvfybcMQwrpgx2gSzcknoMY5s2Iwf5/VC5eume9kUr9LVO4iHQ9A9ZuGNbtQr8JgMZjiMFXB6I6nXXrgtPd/eXCeyIBdKG6VmNShnHtfGAfjA/pGkpL8A6LvXDNP+ktyyVWarJ4PkLWaGlQWYYg9C32XlGWZaii9RLpNdYJnK1ROkdlCiEspl6jaPBCYY2PecoT8CEPGFvjXIPSmkznuLYJtkxp8FCMN9jcrtndrRmpiud2M56/OmPVNiyqlqXQPPOpj3N1b5Obl3fI8oLJdMznX7zOeDricG2ZSoOQIa94eW5ABmFarQSZCqzralnTNBYhNNY3eCloKkdVGZyB1rQsmxDybWNl6KRQZBIWTYMUnnHmMTaMr9Y42jYoORgbtOSCFE7qriJYrA0ffHBM2zr2N0s2NFTrhiLLWTmH1jlTcc410/L0jmB1bsn2FfN6xnO+4qWNKVubE9bHLdtnt9FzxftHZ6w+9WmKq5tgFzxdTliYknvf/lPEWQtWsG4kD5Dcm0u2tg17N8YcfJDjY79gaxpse8qi0qj2nHVVs1haHhzcf2xjEAghVK06wiJoiULCGFIJwPWV6KTIRSANEETnKrJ+qi9+E7HbS2/7etFpKcJ+qrqOz3t2K81r70NnFK1DD+ewXCqaug195b3D+NgiTjyilJDMxXBKD5i6pP8p6NeDeNadjJCMoDaty53dpHd6h8cb3NXwd+oSFS6ejr3ujRVdSPeCzmw6Br3djM97Bnxgj0W/SqRe2iJeryOG5Onta2DKJYhge5wIf6u4PDjch9aYv2j76ABweU5bO+4sWybbmyAt3rS49QqRCTZ1we0jzfb+NpuXtxnnI7Y2aw6PT3nv7kNsW9MIz2QUe9XZBiVhu9DYkyUiy8n2PKf334fFMblWaOtRW/tMFpLVsuLcOpxUeCXJc83ubEKuNAtjOFwuWTQNQgiUEnivuHpll6PDY5574hpH8zlbk5wblze4f3TKm7fnPDxb9oxIpHuTfpKLC56QglyXANR1TZZpvHcBzD1CU0sEeZahs4zxZExR5BRZFlnCJBzrutCp1llXRj9cuLvSfBEAinMh/OwQeBNYvlC1qzEm9nmUMrSDkgLnAkX/5htv0LaWJ555igd3j/jN3/xtlssAFJ0ztMbTtBVKapTSdNWooqe2EyBx3uFXK7IsoywLlFJkmXysCy+kHEA3YJmSYryPciaD/DknwLlYVdhBjzg/w+eMC8DQdfvzcZL1BufDLGcEKZ1UQR/GSJ5dh6R8Cu/2x/wQW5VYsAvhhgE7Juj3l/bj/AA8+e6c0rVL2RexBBzfA7UE+zoBaYhVuWEBGRqovqCD/p4nRjKOl6FsTmIA02O6pz2I7O9Dd53pLHzULvPgXQvehyIJwpzwgFMCJ1wcw2EBkyRP//FsWo9i2MnRWss4L0IDdg9IRZYpnGtx9TkoidQ5YFFJf1KCJCAh66P+HSaEi5WKTEFo6m59hhAKLWRgJIRHeIurlnijGM8uMT+rqJVhWix54toGVVny5vv3GI1LVleeQknPu++8x9HJKeMy58s/83lmkynGOS6NFc6CaSyrVRsK1iTkmQJlERoaPFgRJLyy2I7REfTnLDStx1pPoWQsfoOYHoVWnsZ4jPWMSsnchzm8XFcUc832lmG1XtGamrZtaBqLlBrr4Oh4zrt3HlI3DVc2R+xPc+YLxena8WBhePrKJpdHkvHWJt87LTkYjRhllr3Ccl1M+cylnOk05/i8QSK49c4dCjLar7/K1vXLVJ98HrV3jVk5YvsXfpHDH36f5cEp1ekK18K3vum5faA5unUGkyU7lzawtiIXDt8uA2iOLHRVVZw9Zk1Uj++dT/q5ik/iyL5jxKyx6EwzVDgIb8UogUw2pLOSMfd2yMIlsBfZr8hADkOlKc8vfcc6R6Y1xlqwDqUkLkbrVFe5Hx1Xmdj/PtogeIRNG0RJhrZj6JynfHsh3OCzF7dHLG38VyTfOFJ87sInfXcu6TzC97x1/doy/H38RaB5MQw9SJ1JprxzyulZzsG9T2uSi3pLPvzUgMe6KGEGuEf1b/6C7ccAgI63ThYctfDitqfMM6RpyXLF+bphfm4oJzmqyGnqlv29S6AL/LLmrlTYJgqVZgUbhaBQGjkZsWorTJEzyScUJwvmZ8dAiwTurZaMxgUUNb/38BC0RMdY/8Ja3KpiWdc03kfWQDAqS5Z1hfKexbrm+uU9ysmIsq5YnFfc9ZYbV7axVnE0X+NFEmQNvV6tTyHRIDytogRFVVcoHfoMhm4fgTnUWYYQgkxrZtMp4/EIEws6Mq2JDTCRKrbRGaisO+c6ej1VE5Vl2SXYWlvFkG9Y8Ou6RusMTwirFFFqomv+LOnaUmmtODs75v133wq6hV5zcrJCiAyBxJgGSQCxbVshZYZWGQjZiUcnyZRYKhDU4I1gvfZMJpPYlu0xA0DrwNhQAYqPYDUajm5WhIVJJIAgQi6VzrKYe0KyLPF5us7OTWTwpH+ejE9ncIaVZj0Dl4yGhwsGoAN1QwrvQ3N1yNb1IDc8ib+FGHiWg2cpXIsPBUjGGoShM6hdno0PgM94G+SABgzeRcDXH9MP7m/yhDvPtAO2g+925zUAj6I3gj78dPQhczovWUmF1hqQGNPGvM1wTc54UOG3CuGTWFnrPnQjf2LbO7cbrAt5UdZ6tDLRHmjKcRY6WLQhrUTIULylswyVCUbFCOcEWaERwmO9wFYFCIuqQ2V721q8iB0xlMDZFi0FCIlzYzyCphHo0QbT/BrZjU+za79P+UHL+NmneZhrhDMcHhzx3/3XX+Xu4XlQEDCWXAf5pq/89BfRKhSSCZmBSMyORUcXOBSWeazxWAFlGRb9et1iLBgrMTFvGzxN40IoWQi08OjYKsyiePeo4sn9jEKGFJ2z8wXnqxYXtegkltOF4XzVcml3G2sb7h6csFzVrGvDO/cWPBhnrFvP8dmKVWN57uYV6rnGeJCbG1yTYxarCnc2J6/OOFoXnCjN9vUrnL7/gAOXcWe5orFL5HzJzv2HbFy/TP1zfwP3sb/C9MqnqI7e4vjtb1F98C7Lc7j39oI791fk2wdMt3bxztDSooynKEuMF7RSIUTLyd3HHwJOczfpl6Y57EPnQPAxGhXDsSFPVXa2rwtoJAA1YMp8BJNDJz/lBSYn019gAMM4d9ZFZk90xEJRFGFdk0EnN6wvMeKS0lMGx7kI6obOsaeLnsXPJNs7vIZkczqndMDE9UB5eDdT+HlQkZzQYBcdEl11enfOyeYLPtQ7fRgt6tnA/qDhEKpbIXyXOgR944EU1u6F5aVQ0cYHkXYhUz6t6L7zUbePDAANjvfnK57Y2wqslKlZG4MwBrk9Y3F6hirDhG8aS0uGKHLcuGH/WsvZ4Qlr2+BUTusdy/mCsZMoP2bZVpjzQ7LyCg+Fo800I+k5WVecnpxyp53h9/b5+OYmxhicsXhruHvvPkprdicTsjz0aM2kYPWwwlvP0fEZysMnXtxE2Ya2UGxtF5ydr9GZQqs08iHLgg6gVpq8CELOzoM1DmNaJpNQaVvXLeNJiVahmCMkp4tYYOJZ13UAeE0T8hKlCKXxrvuFg4aYSu15ZBfzl1IG5XUpIuPhUSo03c7yDG0zijwn5VwEoKiDWr9zsdQkgDVjLM55lqtl0FMyVZjSNixKykexbIKenvcuSDHIQNmHQRcWgjCew/A1JoSMl8sl4/E4LtSPb1NKgQpFN6F6LXYKoDcWyZOSMuRFOMAbh7ENSqtQsa0Gbd8iKBGJ/RPpnd437GdpBDlhhITXUrg5zt3OU+0+3325e/gQC8hw2l6wJBde67zCgf3qzi8dM7JiqAjMIrvn3SBfsGs7F7/qh6AsWNDe5+yfJY8z3aJAlibDPLzcFBoPIMJHDzb+FY4ZpSBEdIqCPIiKEiHJI08esUR5h3UmSob0K9dQa/FxbCfyBaSG5fk5bWsZlSNGZc50sgFFRpblaC3RIjanB5AKqRXFaJNl3dAKjzUGh8RmFQgZi8BaDBZjLcIrfGsRUqM9IfdRhf27AmYbWyyznGw8wp7UZJfusXYKKXLy8YjXDz/g++/cQwnIRyM2ZyV721vcuLqPVxnrJnSzUSrv+qlmOoTW80KiM4EmggQZw1EihKmbJixAUgaBfRcLOhCJmZXkGVSN5HjZUFvPqx8suLwjGU2mrOuWk1XNsmo4OJqjlKAxIQ8QEYT+T07nNE1Da4Me3HPXngm/+Ae3cafnKG9ZnlgO5qA3Zuz6molbcdacM3YNJ/c8WuWMxBm7OzO2Tyr2tzb4oztzbpmW7Oycq3XNzuJf8L1Xn2b99JPU44YHb7zFeJRz7eOSrUnO29/3vH97znx+BoDyNUqAEYIsL1msFxSF5v1bj7cv+oU5R3TYB3CnBxZBsFtJgUMifNKU9MFmdN7eo7aO3sikl3xaqwTWuAs2N0UlAhPoYjFI1CU0LqQuIGL1arKtF3m4C/5xlGaTYnhCydb0zNyHubzo8A7yGYe7SPaHwR76N+N5XACVF5nK4Y3qmLlH7TGP2Hjft33z8fyT03wxrSYtP8nZHwDIaE8Ts5vAp4fQq1lEdvDHCId85NXb5pqFhOnmhCxTtLVBC8HidEnbWtbOgAi9/qxUrBrD5nSXlnts7myzPjvnpF0zX61wWUZdS2SzQp6vKTSciYwf3H+A1o5V5mmM5e35irvGcbKyeCXREoRSWCH45CeeY1SOWK1XsdJOkUt4eHQSbogKC8Px/Jy337vLYrXmmaubXL+yz1tvf4A1hiIryLUHpbhy5XIQhe7ysELo7vjohO3NKeVoxMnZKWVZhv6GQqCzjNVqHUCaCdWL62pNURRkWYb1LjCImGBgo6p6whg2+QRRsNpbGwQ808QTIfk96AUGUJYVIfx6enpKVmRkZFhvsI3rysKlDAyfc6GVU6YzjK0pSk27MDhrAB/6/zobBVfD5qwdtNoZDMA0jgn7xMByuSTP84882P4ytizXSF8ETUaSkj2pBSZKiNg8HBSgk7cYAZLH0bQ1wsjOSw3Oou/z/oYGpbv8PgQRHgbGhWHV6sArJHqQH/LILnqGFw7VGY0L1qN79OlaEjM32Htn2C54zfTG0iePHoSW/WvQMXvdnrrDpCfpCL0H3d234WuDz3WGMRm5ge1MBqx7uQs9hwKEtBwk/TJrDIiQhA6BWE/V9oEUeHwx4DdfewMhJdV6DTi0zChyxc7uLhubG2zvbnL//gGubRE4nLeklA7nNc762M2lQSqNEgEAt20b5pYIY8p7j/QOj6VpPeu6pW4dl69cIptMyIsxZ2cL3r99n7NlxbPX93gwX3GzzJBe8bmXnkaqjO3ZlOeff5KXPvksGxuXqFzOg1WwsVtWszcNjiZSomRsSWcd1gnyUiOFoyiyMNckQavQO2TtQSu0sR2I8KTfJITFDs4MS+OZTTIybXn/4IS8XLO7vcFTN65SVWtu3TqgNRad5xQ649bd+yjvqZsWrTTTsWR/d4fnnr7B8dERZm+bZ2cwteesyhHNqGDk1mybM9aLOXkpOTsWPF9m1Bg2CsfRrVNKo9mfzPiHL854+WDFu2drMqF5wkm+dPguD8wD7l67zsFok/OjE+pFQ3UlZ//6iKUVfHD/LpcvXWO1WJErWK4N47HBmYZ2tWJje+uxjUEgOk4igBbPQDA+ApcBex9kWVKvYAlRpDsFhIXwMe+vz2fvqvj7I3ZRIWuD/IpLkzXaudStAuI6QZ9qEtJ1RNcxBOjOLZhnETsnhbkd2DbZ9RmXyUB2FcH9tXb2M3qzAoFwqTgzuZN0gK2zXR0Ai3ZxuLPkDGMHtyA52Rc1FekANZ3N+9DmueCIE88hsZ0XcwPj/jtQGI7T9aX3Uf9UqgDwbagGD1f2E+gF/KBpGOkChCcrMnLpMec1jci4f3DOeGsS1PkdIDPE1g5GZghKbt89QJcz5LJi3Vp8C/vZBLUMci5ua4MDYzg5njNTBTuTknfmjoc7GzxogyaVyrOg7SYEMlPcOzikMW0ERgKsoRaeZVVT5jnVusJ7T2vgzffv8Ve+/Bm+/fL3aaWkGM3YzGomoyWV8RRlkKMpZI6UilVVo1W4NdPJmMl0Ehg2pZBKBWOlFVVVBQ9FgsfSmgYP1E1D21qIYrfOO3IVpGTq1nTgUXgfpGBisqpSKsg+WBOLOSTOB6HOoEMY6pJSCNBaH4CnVGgd9Pm0zII+chyJTV0HVrZuyHNBliuqKshY1M2atlmCCH2LU9uyoPXXdB5ip40IsdorVCy7waL+uLamMcimxUsRO4GAkB4lQjK0jHSFIGiPJS3PlAviSVVULibr+663KnTc1gXPujOoYUekkG/Xr1aIHgSmUHCi8JP1SgYyQbYLLGB89QIYTOfhO7DXxWVFD7GSxRgEgkmhi2TI5TAELGWUJeoONTBqg9fiCV3IB2SY6xce7eC8hh6tH1zg0NB2vYpjwn+sdwn9TOJjYG8HXneSoxAO7wOzmQxkd61/4aj5y93u3L1LpjW5VigtaKmxrURpgbUtB3dvU47G7F+9QlGMePetN1kvQn9uhwAbqvekiPIbMYncGgv0+b/OuSBMH8WQ27alai1lKbm2NePo8IiyVFTVGtO0jCcjxhuKxipwGTbf5dOfv4TSY2QpeO9EsukdO1OC2LNVzMqQs6i1YjLKMG0bbVbo+tFax2ikyDMZui+5oGyglcBmCmNAKcF4rBiPROgE0npAcrywHK4VB+c156sGLyQ6z2lbx617xzRW8nM/81n+1t/4K9x59z1aJ3hwdIJpLTrL2KhbtjYmnB4fMxqPmY1H3L/TUOYCIScY72F7Rm09q4XlVEM226I5XHFHemaN4Zn9KePpDJePmQkHhWaiRzx7Y5faeJppiTlZsz3SIFvmt95C5jPk6pSfnu4zPnCc3K+xTnL/9IhD69majWmbGmsqXHOOkyN0OWW2NXuMozAQB86lVnC90yqiBqokOEpeBnskw0KFta7rhx5y9iK4kmEyDnPeUjRlwM11x3DOdDYGEugRnXRZWBtDhEwIEaJPwzBvajsXKi7wnpDi4UFKh/VhXVURGPbdN6K9TABMDPcrEI8Yg0dZOpEcy+7/VDA4KP6L++pA8PAWiHRj6YBsD4KHtjgRAn6wRxFtV8/2pQrroQl3lgiYZecYQ0rTGObM+Fjg82iA+aNtHxkAnjWGprHMFy3TbEWWS9pqyXJdU9ceMa/Id0Y4JbFYXF3R+CVHRw+ZbG9ydO8+IoOJ8RwenrK7Y5l7zw9bw81SYo+X7G6WOOPRoxFXjWW1drzfLKlt0H/yWUamgqFsjaHMNOt1FVTspOfh6ZzWBLmULgYvoLWO8/mSZ5+6zq37J+xtTNiZhtw9rQR5noXquxgeC1o7QUplPBqDFCwWyzCxlAIbqg5t1OOp60D9eyEoijxUVBL0lrQKifhFkZNpxWpV0RqHxdGYlqqpUTJISGR5hs40zjoy5/AmeNE5wXNwzlHVdQi7ihB21lGMum0Vy9UK6wyKPFSI4XHeYEzMVzINOh9BHZLWq+oerakCA6gs0usQvnYW70zn7aWJkqqQiYPWORdkZB7jliYssQI6YQDnE72u+pZvrp9kCSUIEVp1SZl1Xpt1oRdlKskffiseNczzBJTopWWStyqEDN70AAziByEGkfYj6At8RAzXiv4YcevCth2zEu638y7KtLhH3k/3Z3DO9OfcsYEkrctkfIisWzies677bT2+l5cZgjh6ANixf77jJxkygeHPngHsX4+/V/yui6A3MRYpuTzlzAIIpXrgLjzehJo3h7sAan/SW7pn4WeVYSgKQVXVmNZgjcF4wcnrP6CuK2TfXgVE6q2a5HccNjkmPvlcSe4hgCljQ+s16wVaSarVGryjKDW37x1z7/4hk/GI8WSCRbNe1lGHTzIqC2ajHIdnpAVT5ZAeclpknuFkhpAKnetQ0ZxleBkL9UTIXfaxT6skAngfkvuVFAitMMYFMEvIbbQ+sIfntWNZGw7PG6TQxA8hlSCTiuOTU/6bf/1H/JvxiM3pJISBW8NyVVHXDWWecfPqDtNCsbeR0yyPMU2DI+TyOhFyxRs8x7XneJmjRctWUVLVjm9VLfdPa17YWIaoiDccnFZc25xwYzpif2cLfWmL9okdcunJ5odcG48x51vc2DrhUivQUpN7ODcti0bij065f7xmc2uDUhh004B0iKwgdGx+fJuISgYihko7J9PH3tnR7kgCk5RsQ5ZnEOevUDpEu3DRAY0pGsn2D8BgZ8tIvbnTZ6INGLDx3gVGMZJVQOgi4j2xA07qRdx/ri8midYhqmHgo4pDzJEbakaGqMePCtGKjkFMeXspLMwj1wJpeg5Dxj2gTLa7v/Hps+mPaPcuRFEe+fhgV8lR7hBp3Fz3WqhB6PLS4/0VPvroXbKhx/mYr68iQI4FpB91+8gAcFW1CGEZKYFvPWtb09Y1lRU0PnTWyLyjcRaZTaiPDqiFxLuW9d173BiNqOo1e8bgSsG71Ro2JXubI3TV8sbhkgdVxRdvXmemC7KiYiQc91aK765rFnWD1kF7Ly9yatEwny9o6hqfKYxzXXl7YqmATlrlbFnx8WdvcvvBnLO1YWdzhPOCclQyGo3x0uGR1K0hL3KIre6kVtRNjfeeyWSMMZZMhyT1pmkoyoKmrsnLks9+7vN8/hd+hul0gqkbtAwFF0opRlubbG9uYnB461mcnnHr3fe5e+s2J8dHHB8f8fDwEOMMdV1hvaOpWgQwKnLGoxLbtLRtS5ZlYcA4S1kWXRhWSRm1BG0HfqUMCux13TCdzVDSkWcZxkKRl5h2GXp7GouUAfSF+9cDvyEIHG4JKDzOTWmNMDK0P4rhATlYPL33ofiB2BpJ9BNQCIFQ4QUl/QXhUKliH0mRzA+QAJ3oJ3svIJ2Kb4as46N5KTHPsJuvj7BkHjA+jIkIjLrvP2J3BEHeQAsdz2UI/D78b3/cQLP5oXFKrF5k6gSE+4IkENU9W9eDzD7E5AYMYFc97T1e9M8vnvvFa07AMoHGtPAkJlD4vgJRiD5Ub71Fa41wIlS9pTZ9rjeUj2PTtGANbdXipSTTGqs8pl7hvUUKMOuTyJyLTsnfEeT8ILBmHo/0Ei9sx7YECSMHUmANeGO68j7pLMKDXS04PjzmrVvHvPnWLVarNbs7m5wcn9IQuiy4pqIlo/Q1VTunHJXIJkNUFmPX+DWUueZumyEmgrZuMLEHuZIeJSHLBEUGmZYUJXgL3gtkJhCZwjZgbAARUaISiacsFXVlWDcOa8MYEVE8WMveQTOxn7uxlvmqZr1ckBchH/Fzn3yOw8MjcI6m9dy9c8DlkWE381RihB9toLzhfLEmkxG2KEVj4cQJ1FSyzloms5JvPzjmal7w7vmaHxxVzIpjLk/HfPzSCdsHG7Ax5ezgAcWo5MoeTO+8z9NYdFnicWhZMKNhb6xZO89EGl7/4B5Whl7JHkFVG9a1/fOGzE9m6+xxD8YgOWSBzXJRMSHGjpLZiAWOATCgw9zvwpbRGRMDm5FsXX9oGYFiCMcGLdPeBqukj9vJscQiSBW6arWteQT0iR5ACrpoFCLkzKe1PyHRLmwrE+gc2uiLa1Vnv1xvCy/cxsG/Fx4fMWIdCB6AxK7oL60RIt3jHhS6xD763s4n25deZ/D7pdzHcBDZfT5ocCanOaXHhA+GELAkZLz/BELAdSMohA5eGo6mbmmc4tyDHhWURYY1AjKDFWvOzhp0ZZmtVlxRmgcnc1at4YeAmmYo7VFZych4Prezyc2Plby1XHN5d5NltaBuIJMZv7y/RSVPefVwHnLqjKSpG6Y7kqapKYs8eJyxPy94VsvQV1IrTVGWZEVO1Rq8aVDCMV+uOVtN2buyx87uLnmRM5mN0brAjEqq9YqdjR1s0+KFZ3m+IBMZo50p7777LicHD1nOF9y88QRPPfs0dV3xxDPP8Hf/yX9ApWsO772PZkKRhcIRqRReKtxIMh5NcW3D7KkNnvricyiZMxI5wgoW83OODx7w8te/yd179zg9n1OfL1gsFiwW51TNOQjBWIjIWDlGHkxMxtVZRuMsxoXOImFQBrmY09NTylGBk5bZrOD4uKYsZlTVGULYbmAG2j4M6i4pVQQWIDFJPy7N/Je5SakgFq0kwOOSwXMe49pggJL3Se/5Er1lhA8t46JIaOeIDY3GI4AiGaQu109Eo+iDMZSRBRSJAezYwMh0iR5WDu/10FB0hFlnIFIPzotgr8/+i9/5UWX/g+PFr124oke7gAw/2DGHggvGNP3y8hEAGC7D97/FBY84sov0oFAkwx91/sK5xWN40UFpD9EhCcUfDo9yg/7OUb8x9f98XNvX3j4NLEu8B1JItOzD+yLIdHXJ616AjtEGIWTI+UthLA9ESRhPAIpShXssEWgFMhr189qxMhKtzsh+eMT5OvQMzqTH1QtW8zOMF0EDtZBUPmfpBKLMkK4lzzQrZXFuSdM2scDC88B5mrP76LwIhSmRVXAeWhtzahsJzmGdROcKrT3OOEwbZJakEggXZUmEpFEKVMZ4JLi6q6gtVK2hqpooJOyY0bBuPY2HIs/RozF1VfPsUzeYjnPa2QyhBONMMhML1PZVlos1ra/h+DaFFmypkhU+dCjJSgofOkMoSsrSUisNm4L3F+ccrBveWzmaJZj7p/zJvTXCP8B7zxf3M778wh6HB46zucVf2eBBWyO9YGdasEPOE/tTvvX+CZ+8NEY1hh+ctCyWYLztQuP/f92inU7gxUWlidBzmfBe7Hwl2xYhA6OcogNJc67bvOhkWS6ApGQTvIidJ0IBE6JPFzLGBvKhabuirosVtsFudqwYfmBnCAoO8XutNbSYTh+yDwcLML4Dox++Hz1g66Hyo/ZucF2R1Ru44f13ehZh8B1PKgBMn/vR24fZvgErENce30WsAsOZrK0LIN2HV5zrcymFC7m6IGJryGRnfwIA8HBVsZnnnK5r8nXFdLzBYbuksqGYQW1mbJc5rWk4eXCLTVly02lcPuKP7h3w9vmChbVc3Rlz1Y9wa8uGhRtCIE3NM596CXX7Fowkp5XEPjhDOE8JXM8LXo3n4WzICThbrhiVOdmoRErF/YMHSCkp8pz1ao1Wiulkgi5y8rJAa832VsH+7gZf+OJPM93f4mjkefalT3JlssWl2SYO+Ddf+1O29nb56Z/5Ctc2L7Nsa4Rz5Epxe/GQP/zWH1MdnLGVT/nKF77CU08+ycrWNNpSu5aZAKqK1fFD5GrJw8UZMh+xvbFBWy0xzZSynFBXS0xpKccCmWlG+YjpbJvJtU2e+MzzTMoZJRl1tebgwQEP7tzj9e+8yu/97u9Q5BlCCtraBEFkJSmzEcY51m2DSe2BiJNIwnQ6DeX5QpJlDh97HweWUHbsTPJoEusXBmQY6M7aPjdL0L/3GLfA0/Yn0AFSn65VdkZJiF4UM0LZGI5IYCPuNF1LB7EubiK4nBH09CAweXaBgXSDsHASUO12fPFAH9qi63zh7WiqYqJzX2ThO9vTne0QUCaD6h81Yxdf63Dl8KwGDB0DkNexdkO2j8H7RLBKPx58f4IdEOz24bm4L9e3CQu5SymEDkRJIxFlf7wPUkBC6oF2419kfP/yt0XjQhee6IT1cg9+wGJcZCCUlGglyVR4dBFACh+EloUIj0qGFpcBWEKhApNtneHBwpJlOUpYSrumNWHBynEhPed8iTUthRZUMkMoOK4ci7XhfLXGCcFkNCbLNVoFBltpzXRcsj+p2csFTgqMERR5cLLWlWMiBJW1aCkoRxleeGzwsdG5wrYe72RoxxWFfXVrKDLFZCzZ3hxRjgoqpzlfW9brCrde8LcunyGKUDD4tTcct3XGum1YLRcsFjnTSYHUkr1Zye50A9t4FueWg8M5J4uaqVmirOHmXka18Iz3tqizTVofoj4HpyteeHIbZ0ZoUXO/LplWLhQiSsnhcgWEbOG92YiTZculK1OOmhP+6O37zLTkxasbiLZhLT1tbbg6VixXLbu54tO7jmPnmRvBevm4RyGRKhMXJkAng4KPjkhg8vCQ6kVE53xCG1UnlEzyMP3uk83sYVMPn8L3A3MVcgplVJvo14jWhOLH4V0ZFs51zvejADM6z4EVSzY1HN06j/AOSyADQvu65DD2RxqSd/21hC1JqHZM3pDtiw7lhR0M7ExnlqNHfQH8PXKr+rXxAvIb2MXe7+/VFwbf8J5eniGeqQwyMCnWJFU8PRO6cqV16KNuH70XcF1zbTIGLZjqKWfWMBmPWM8XeNsi1AZaCSZZCcdn3MygGeW8cX6fe2enrCuLyQSnpyvkuuGp3Q1ubk0QOufB2lLqjMwJmvOWnSsbKOtpzla4uuZsuQohV9OGNnBSYU2LVJL1ag0xzKpU6E+Y50HTTikVqkJ9yKepbcH/7n/7v2HnqRv8u+98izdf+Q4/eO01nn7yaXZnE772x19jsr3FL/76r3Jydsz1nSs0bct0PMFLxdP5NX64t8/3zx4yubaJvDLhRNZUdoV2IXQ6G2/w2Sc/hds4YnF2xBee2eLBwX1av2TuWlbzOapxjCcTmvWSZnkO4xm+HIX8OwHn9YqZqxiXM3ZnM56YPMmNp27ypb/ys/xH//H/hNe+/TL/9g//kH/ze79L3TZkZRb63cbQ9LKq8FKihcA4H36XyYTj4xN2d3fxOHRuwUzIshGmXcVfuQdV3XCNQNAL3wHFLvk+DdLHuSWgJwKzKiMwEIQCJOmJeXIeKXTHaIZz9p33Kgb5ID2DJTpWJwG4TqpkQPfLgRHrPdvE9aXQpeheS8foN9Fbk3ioLjQwuNAE5B5lAMMu+5y87jU/fL87UnffUthgaIAuWhz64wyYvSF4617j4utJOH3IUw6vsQ93JBAYgS0enwoJPUjfs6adwZMySo4okv/hIgPsh/t8TNtYWFY4WtePk66az3vswHlK+Zbep1xTgbIhIT+TAiFC/3AtRcgl9OE7ElCxM5H1jrUB6xWutdzcKZivQwsuRRBartuKf/vym6yrNkYEAlNXFhmzScnGZMz29gZ7O9tMxhOmkzFlqZFKo6VjIs7RbUuzWCKFw1hLphRFIahqy3QctUxjhxKhBIXMyLEwzmkag2lc6PRBkIrZnGjW1jAqJPszjdQFa4rQE9a3nNsVo3bFbLJBNn9Idlaxagwni4pRuWRvS7BZjJiUGZPJmHO/AF0w3dqh4pzqdMV2mXFgN5juFawX55T+XWab29hsl83ZCC0s06lg7Xd4kYrtfM3BieK9U0ttBNuTkma6xyuHp/zPv7TH8WnNc0XN1x9U7I012bFlftvxzsJytDJsFYLR2DMdS04OYbOAF54vuft2xWw7e2xjEIiZr6IjAcL89jjhkfgQ7cDjbbCBnt5shxxx0SmGGGvx1vb2XCQUIwZ/wwXHNq0XcVLq2AM45PUpsk77Nmjddbm8on+8UMgl+313Nv7RMGs8lxBuDvn6w88HUNavT6I7v6G3n6DtEHBy4Rh+uM8L1z/Y06MoM4VxP2TLB2DQ9+DxIqIUgzWgJzWcD3nCoUtOb+9D6kzsux11Uj/0U32E7SMDwBeu7PPk3hYZjrIsKFtYV2vGeYaxEtYNRQbiaI3MCg6V48gece6q0BaONab1CJFzczzhYzd2mG7u4IVnfXjGwRs/ZDE/ZvPyNu3KkiHJiozjtuGwNbTWdGh5s9R88cY+0hpevnvCg6YNhRMq9ILVOuvWVuc9pdK88Nzz/MN/9D/iytM3eVgvufLEZX5p9xfQmeL9O+9y+/YDykzzsc9/ikvXr9O0a1ZVyI/zzjJRBeNizC99+q8yUSPuH97lvbvv8YlnX0IJ1bW8KZ1ia7SFKLYoxjMwNc9+7NOcnjxgt61iKFWxXJ8jdYnKM1zrsO2SNtc0QlJ4z2J+yOnpQ5bjTYpySpGXZCojyyWf+rmf4qWf+jx//x/9Bv/6t36T7373VQ4ODiL7JajrhrW1jPIitJZzRO07wcHBA3Z3dykKyXp1TJZpTDuYPGkxF4kRjAuzEDiZPBUGQOzxBj6ECu33UssfF/MqQnM8ARKUiPkn9IAkfrtjRKXo5V/CWz2461jQ+K2uY0YHBgfhYCEHQLAHgBcMwyMG88LWMWGQQF94ll7s3fuOZSOFHi+CtaHP/qH71u0vGsYB4Psw+BsANn406IOYd9k9HxonBsZqcI2PgsB0xo8IQQecHu9pBOkqFk9IGcBf2E9QAEhtDB/Xdl6HNlbeRzmKGApPSdhBa21wPqIvoGq9wAqPlBarJLkU5HkYfs6FaxEehJbdL2+8Z1mnXr2KUSY5WwPeh1ZQPgBIHExHQaZKa4nWOqTB5KF7T5GX6NipSOoMoTNQCqU84zzDnmvyXEMsNMqLUFojRrG5vHfgQqehMgsVwtZqhPdoLRAiQ7mgTuDw7G0olg0xZQPwhkmmKAtDWSisG2PFHk1W8NkvXOPm6YKT+SIU0jjPYrViOiq60J9SCi1DKzqhJPuXr+POH5KVGY31zGWBMRJ7tGK3rpkVinoxJpNb6MkIYXeYONh3Na0znK4tUmZ84pd/lfp8xR+9+rtsywqZe77w7A539CVeW64pmHPl8y/y3Fiw8+B1tn/204z2Zxx9sObd3/sqygh2JqYT/X9cW9enQiT1hvhGwhRSoYQPRVIiVNw641BKd/qoSgXAk1IYPHRh5JTSAHQsW7KTQ1CW1oL0uVTR70mgz4MM41kKeXFfnW3l4rFkkk2ib+km+rSQ8CijNIzgw+ZWXPwOg/33EK87/kXg2APNwe0MtkrQXXvftLw7JMKn9XDgnNM/pJ30KTPEau4+nzqlgwT7F649qDeEHcjoLYdYSdD7DYVxqYDnJ1AE8vS1XcZCoqRCZRmzHLZmEzg54+T0jNHpGrtYMtE5d9dL3jEGbVq8N2htubyRk5clL17e52MvfZzLuztkmWJ1eI/T1ZpqcQ7FiAenZ8jTJflIMBqXHAvP4bqJjI5g5Cxf2N3ks1cvsVWWfHzjhG/evsfLR3NsUVL5ChvVx1MF4c7OJv/hf/g/4MoLz3Jw/IDjesUoL7l24yneuHsLsbnNw69/l4//9Bd4+hMfQ44y6rpmYRtqLBPCYGudY1ZM+ZmXvsydw1vcOTzAtDWF1hQorpY7TFSBQGBtw2iyiTUteTHm8ngz9N41NVIqlss5TVXhHFTrFdoZ9MqSO8tWkWOkpXINzWqBsS3rlaQYBcZu5TSlyrnyzE3+Z//r/wV3793nW3/6DV797nd58PCIux/c4d7tW6zXK4RxCB2MxaX9fV5/4we01nD96jWKoqKe1wOQF7ylTAqKTLOqgsxO51HEJtSJAbOdZuDj20Q82a74JCJSFy2OpW91FoBsZLwGbJ9whJZaMoG8yBJ3E7Y3TolfRIgQTomGJYV7Oz88gT+Rwqw9S/ijvM9u8xefdMAvTvL+1SHL1bNuPQDs30vhkN7c/Qiv1z8CFjs7NTRCA+DHxVBwHx5O7yaA5zug113TIOx7AVgOjGL6TCep42241y7ktBlnAgjsvGF5AdA+zi2cd5ByKKVgLB1rJ1iZUCErhH/k8xf/dt7jXcjj9bH4RsbvWBeqfTPrmWQSlYVj1c4zKQu2xorpOGdXb4CQlGXJbDZGS4lpLFI13HkwB0BqhVIaqTKkygIQE4rGWko81nky4fEYMi3wSuKVIsuzqD8a7q5WgkJLjA/gLss0WSagDdXJzscWXz7ocCoV9FRnU8UNLGdrQaYCYy9iXqtzgBqjUGiVs70VQr7XLm3RmpbDozm37rXcPjimqSuq/RlNazk7X7FcN6yrlptPXuXJT32M27fucnp6xqK1VLWgqgW3TxraJhR8XNk645lLE0azGXK0Re5btv0Z4+yMs6M5o/N7XPnsz/Ly+6+xvHWLpYWtXPPM55/iF/7u32X15rdpjUEuTimf2WR1/w7NwxPGWxt85m9e5fiHD7DViOzxqsAgRGDc+r975srFqBcuVZc6iJ2RrDN4RNeKLc3gxH4JpeLr9AAJOpA5TBOKbwSmW4i+NVz8TsqRddYFiTPvAjMZgaGIvdp9AmzReiUHUggRnSnR26jElOMH36Ev+OuAkABSq7p4k7q5GPOy077Td9Lr0YZ/CNI/am7S4in66xUM7Gh3I6MtTB2Los2zNlrx7p5FuzxkHF34Lb0UodDT2UgzJEmzCNVFtDU/RlekjwwAs7JEq5zNcoS0Fu9qiiyjrApesFPW7Tl3WsEfHh5R24ZSKi5tlGzvbTCuLFdHitnehK3RhBdfeBFdSuq7t3hY1VTG0OYwKgSLOUizZHeyhSoK6tqwMC3WebbLnE9vTLha5FRnS9bGU5YZn71ylU/cvMIf333ID5t1ADJao5XiypV9/tn/6j/mEx9/keViQes8RZ7jMs3h+oydp27w/tkBH//pL/HU088y3tkHLcmlwgpPZWpOmgUGz0iXjKJm0ZX962xubONtw0wodvWYQo+64oP16hxJzXjjeuehyTxH6TxULouMrf1thAjVWFIqTOzzu1ycsVqcolenCGMxVYPINd6tMFmDzUe4QoDQGO+5cuMaf/0f/Dpf+Tt/k0W9RqCwVc2D9+/w9htv8t4bP+T9d99luViw8/CQ09M5R8dHTCeTDsiIOAGu7G/zc597jr2tKX/6yju8/Po7oXrqkUF5cXA/5m0wQcPhXdRKjMAohjKUCDlJOGI4pO9kgehDuSQDMWT+fBTW7gyTHBgb23tniBByScnASYQUGaFkAkHExx/NuDGotn3EXRx8bgi1hjf+IgMYb9GF9ztc6y/6wt0J+IufT/u7mGc3YO5SCHYA8voCkB7wJUPeVyHHR3ERAPbn3ReBQBqboaNO69te0kEpbBvf9wNg+xi2QPR58ILaQevS2IBErf6oivn++/17xjlsExYNCSAFeZEzm07YmI64fvUyl/b3uf7EU+zt7HJ5f4vxKOPo8ID333uH8/mCu/eOOD8/YXV+xic/dhOZz7h3/yBIQ8ig5ydVKARoGkteZFhraW0EbcqjpcRpDZlCCEOeB8kt711giYQnQ1IW4KXGCx/y/7zpFmpjQvFI6hBRaM/+dsZkJFlUHuPBCU3jc7zP0BShUtU4MprYS12gVcHmbMzpfI11noOTFUdnK7wLYtiNMSyrmj/4s9f48hdf4h/8+t9CSs26rlguKxbLJWencw5P5hydnnF6NufV43Mm84axbBm5BZfGhtVcwdYuT/7srzJ95hNczd9ivf4CZvkAv/EJJqMCvV6w+OH3UXnJ5me+xM5nvsJePef0+3+Me/gGs/2XmN7QbB475q9/+yc57D60JZMVCfFOU5No45zr82v7an1CDpkAY00XCQmsnY2drXw0kUMoM2DtUiGJDMAuMXrOuU4CBnomyseGCNa4WMCRWpYqjA2pHSF8TQemhHBRHiYwEwlYCQHYgUOdSLuBr48YSNSInm0bsnU9QEx78v2OSAcagN+0bw/DOE0Huv3AnnVHoftcb+sSERHuj8yimkW0n+kWhPvWF9B5D8qBdW3UDw1MYAi3p98kOeQ/gSKQcVmSyZLdZ1/CntynOr6LOjxnx3lsNuKuXnJrOWd/nOOFpmkMVeOYzytm4xLnJdXhCjmC0299Ez3JaTAs5wuW65qtrRnVqmVW5PgiZ7Vuac2S+8s1m+WIn7q5y6f39tCLJVLl1G3LOg6ivIC92Yi/NZly9+iMtQ8hDbznCx97jk0NhwcH4Azt4W3unR8j9vaZPfMMZycP2Vo0/OzP/xKHizMm0ylVtaRpWmyzQuOo1udY27KUigxwpiUTgi1ZMss3GWcjsrwEFKenJ0wmE86OjhiVGZPN9AOHMFW1PmV+ekhRjmnrnPEkj7l1gU3Ki5ys2Gdzew9rWpw1GNuyPD9lvZ5Da6FdUq3OOdGaxhuEyJhMtpjoEaNpHo438Vza2uKzn/kU1jiqxZr1asWdO/e4fesO8wcPefeD9/jt3/pNTk7O0grP0cmcf/fy22gBp/NlZwTSgPzwQvZ4EaAgyN24WA0WZkwA3TEDBR+NkPe2N3zJUIl+AjrxyOTuAGH8Rwy93mAmkyEJ3mMQV5A+NeBORi96saSwcGIT+zAyXMCBPwKweVI7wAT8OkAl4ntxsg/BVb+H3tNMT4QXvXEf3lN/4RuD8Gz/6B95PbGBDJ53BSoMwkeCeA/6c3TuQnDpAohMHnwnq+Cj0HoydPFeOgfehb7c1jmQj0+PUqR8K4IMkfUeb8O1J9FtGWWK5ICN0FJQlAVFpsmUZGNjxqjMGZUZW5szdrc2uby3yebWFuPxjOnGDlduPIl0hrOjB5w9vM3xO29zf32OaWv0csH6wRFHB+cczw2bkwItBdeuXebg4SE2jpe2tWSZpW1aat0wajUms3G8G+REoIUNKnZCoDINzuC8RGqJVKC8R2UKZ30Mw0ua1sZFUWB9kI1prcBbH2SWUKhMMhlJxjUczT2VF0jvccbSuJosL1CSKOUT7qVAMBpp9rantKZl5S11XbNcN7FVXmAQlRB87c++y9HxGZd3ZkzKjI3ZlMlkzHRcsrN5GamuIZAhL7wY4b2gWS9YLpccHjxgR+ZsTXcYeYV7+h8ypkWe3sJuXkHbE8yi4fKXfwXzjd9CKsXpg2OmG2Nmz30J+cmfAzGicCDbBZNnv/jYxiAEa6QQmDhfJOCt77t5CAhS4iF64YOnhCVo6kkpsVE3zkTpMDFg3hIg6SETA4CWOosMWasA9lI6THhNdCHb1IPY+2AHnQ/5gT5+zpNSPnwXWepDzdHJe8TP60Cc7M6iC/3CwM500Zz+c9FCQ3rNDz4XndS0eT+waQM7++dCrcGyGOxezxCGJ+HvQK6YR+x3f5y0xgoBDouKbWIDDo9dRRwYG35H6y3W/AQAYLOu2Lx+mb0XnqF+bUlzR2OM5NytORJgN3Mu6zHLpaVuW5CayjnuzmuWZ0s+sbPBlZ0RyrU8uPUBIHFKkCvYmE6RFsoswwtH3XjUZMzJyYLKO375U89wY3eL/LzCjcesjA15KBtjSqmoFw3KCy7lOV+8dol//fb7LOYLtsYjXvr4s1x99mPMDx+yvb/NZDbh6mrFIoe6bnlCTJl89mfRTrOdTRi5nPvH90BnbJ+3iExRlGNwGiUktqkpdMGknFEUGyHfcOAebMxmLM4OOb5/h4999ssknSTnWqrVKeenBwihybKMclQgRKjwSxPSewOxxZnSWUjSpmQ02Qwth0xNsz6nXp8jvGexWrOqz6nnC5osD43JVc5kY4txUZKjWNNQ7s0QdsSz13Z56UufQ2rN6vSUH7z2Xb77yveCLhPQGsv9B0eDwSo6D6UnzIb0/+NjXiBWcCXA4yIwkyEPixSGlRBCsxlShd/GDc43gZHk/TIEgInl6661ly5IYC4lLsv4XpKACdIEMoSKU5zYD+9Pn9wLvafXe4hD0CYQPrXoi0BrYL6GavDdZy64oI8Yq3T5w7cHYPACjPcDMDiEgb6DfPGr8TUx+E4HVvuDDvsOM/hOEpn2bjCM/LA9VQh5pA4GLrYX8w6cDbIkzobv28c4DMuiIMuj/IvW5Dq0gtNaUuSa6ahge3PK9tYGozIj1xIlws8zmeRMRqPQnzdXlGXJuCxpm5qmqiLDWWMXDXfvvcOt7/0xCgveYpsG7y06z+IiZyiVpHQNTdsinKdplizrjK2NCccn54Cj9Q3rdRh71jmE92RKUOoxUnoyEdgf4m8BkkzlSOWR3kanJVYvC4sF8izDC1ieW4LWKYRELoVXljaKdOMFWsNGpmidxK4EjXOh2EdA41tE7kOLP5kjnEMqgfKSrVnJalXgTItznsL60GrMe1pgokoyLTk/O+fe3Yc4a8hzjdZZKBCLgDzTmo3pmOlsRFkWTEYFmdJkOmNjpFl/87dYIzC1w+uMrBghZ3cpZ1PK6ZRMKNrrH2PZjvCLNc40VEoyzsZgHcI3iPWC7PILj28QAt5LnOtTUog6jrJLbQlzyNk4zxOo8um3SvJJIoisD74THuPfaT7Ki7qmdE5aygX0sQmCiMfrZbLijuJ+AEJlvPd9nmAHdiLz170u0zp00W3sCAjRO9zp9QCShiCKnkF8BFwNxWKF8HgvGNSjkNQy/OBz/W/Q7Y4ecPYVyf3b8TdISfRdamQwwKGPcjQSA1vYF4y4mB7j6dOMohQVGkTQHCV1RvuI20cGgOcnc6S6w1v/n99k93yNzjMe5PDAGArhyIRkY5QjTcvtVc1b50seNjW7heZTWzOeyDNYecr9KZNihFIZZ2eHYKD1gktbM4rxmPPFgvp4jm9rpPa8f+eYTzxxGVWDURnSg7SWEgHGIwtJW7fo8ZhyPOWvfPp5vnPnAW+fnPBzn/0Et999i7PjL3LpiWtsbu3gvKOpGiarJaZuqMySZr3k3sm7WFOzXi05uP0WOivZ3L+GaddMtvYpyjHj8RZXLt0k37+ClmU06jb+muHHkVqBkFy+8RT5aEyo4LGsV2dUy1O8DzkyEhUWtS7HzoN3OCtCY2cpcN4QJqnC45FKUegJWT5itnUF8Oy4kPXmvQ09fkWYzJWPhlpl5EqzbGu0ymmdw+BwrkbNxvzGP/0n/OD/8H/EGoNPvR3TkPWC5OOkUwyDvvO1PjQhfuKbCInBzgUx50ByRFbNeYQYVkuBj9qsUsqoG0dc0OgmXAjR+9gGSNBfVrKsicXqvVE6L7d/PUQ+fJzDQ2Mluns3uJALbOqF8G8XronPU7j0QyHgi4wsaeoPjdyFY/r+PDpP9NHjD14cPBuygUPwlz7TsZH9Cz1A7ELBw2sYesPDM/V40S8i1lm8cN0C5n0Af9aAaXzMJVM/ltH7993+9//JP2J3d5vdna0gDm8dTb2mrlYsFgvWqzWmqWIKgkISgFm7boKWIXUQZ68M7dwxd4amqTGmIdc66JGawMhkeUz2lhKhLMIukeuGZe2pnUMqmJYCYS1eas4rCZkL2oEiOUzhvpo2OJq5zmjqljaryLQg1zkiMkWpE5DzAi1CLph0Ai9C96UiyyP76sALtran1G1ofemtRkhPXsTeYiL2TFehervIBHmmsG3sHBIZ/NRWUmfB/jgXukWURc7VvQ2auqFuDEWmA7hxMYSoZJCdkZI819jWgVSx93Ica97R2JYHx6fcfXBM1Riatg6qCUKQZzmTccmoCNI4zjkykaO0ZDybMB6PKQTILEO8dYuiHHOa5yipw/EdrBYVk/0rqNkMfvnXH9s4VLFy3KbF36dVyAXGKnpWQoKSqnNiXapeFwIdW7V55yJgHhYQ9PYrAbwEhoToKLcLbB8Xvi06cJSAoRehdCFp0shOUDoknCZhdxkripNo+IXjDBjJ3nlNrGe4D2ogV9Zzf/359YUS4bUQ0REkBrAvNBEdRoRks3rgecGkEgtg0l4HoLA3qcM0mn5uenkRPAbMN8jLFCqSHIDrczG9UDgr8Sas10LlXWvJj7J9ZAD47sEpn64MucpZjMe8f37MsnBo4XErS12veP+s5bhu2d3b5hOzgul4xLPScX1rBFIz2pqxubdFLnLINOW65OXvvs34pGFdzChGW4yKCctxS7tY8a37x1RnS1anS9YOxpNRrGBqKKdjtra3AnPGGdIb1osVqpSMMgHe8bFPPEM1P+Xf/Oa/YDrb5MrNG4zHBcvzBaZtkBicaanrFVVd4UXQ11vM58y2MkzlaRvJ1s1LSAkbsxnj2RihPN4bnBPgVTDyqUODhzzTjC5fxTQrmmZF265DXhqKcjwLidlSgrMhDyOq45MGnouhlSHoiLmHxhiaxjAel7EdoUQpjfcKITTG1Ni6QeEptEYJT46izMbBS1Ce2rZIIWm945d+4a/yrz77af7s63+GtcHrComlabCm0evjZErJ9/5H45qf8CaEjFpIceL69A8x4dkNAIfDJacqeavxsS86E/11iA9Dph4K9sahC+cOAGBfBJJCvckpSPv4sBEa3rwElJIT2OWtJMD0Ix/DTvrPEopbBtiu4wIGxxIX/h6ck3/0Q3Rh3QtVuz8S/A3e9wmcMvgtBuf9I0Fnf7f6M4qvpNZ+PrJ9Ftra4dYehMRIiyof30h8+uZlTFMzP7rLyYMW09SYusKbhrpuAtAKbTNo25amMaFgynsQDuFt8GAc6EySZYpCCDQOTINtasAyHim0d1QrS+s8o8KxkTdQWKajjKpxnJ3XrMvQctIY0DrDeUtdtWgVhPulVGRZFos3NONCh4XfCmYzxawIqQxaKVwmkE4T2omHuWS9IMtyylxQ5BJpwnjWOrwvshwtLa3xtMZjWsi0wKG6XzZ0c/AoQojQx77x1jm8VORZrMDXoTVZpgRCS6ajKbOx5t7DBcv1mnXd0jYu9EDXmjzP8EJRNw3W2NANyocCFxOFjxHE/tOe8djh3CiMQ+dDJbMxLE2LsaHvsnNBcF/eP4pt0sJnpRRkeU5ZZIzKnDzLybXGWUt+6z3yTP25Y+YnsQmdhXx878ENKvHj3ykvDwjCzNFehS4dwdC0xsTIU9inE9Fj7iahGPw9cGixfMg2JkA4BI6E8WfxnVi7Tz2HhcRh49wO+oEu1jbbmBvoMB1whQFJJnrh6mF0JkmwujaenwjoLYCqPuJDAlDed3a8u7R0XUJc2H+4zPTZtG86uzlk/mBgMwd2MJEEiH7tShGTsGRcJBhSmlHa0TCaYr2nNQJXe4QN641VFlF+9DH0kQHgF7e2UXXFm6LhjYP7WOcYFZpxqbEOKmO5sjXjczubaCVYzDMmWc7mFDYv7aG1Ip9M0Tu76KohFxarxmzub5JJxVoL7OFDSg3at9QApUKOcjZGGV7nGC9ojQ2l0yJDiYK2XuKloMGSe8NqaZmvGqTzPP3ssxwePOT+B7dYLZacHh8hhUNLyDJFVpbkRRmMkZxw7cmnmUxn6Ewxmm2jdcGTL36K6WxGUy3RKiMrxxjT0tRrlC5QKuabycAEejx5WVCtTmnbFu8s5/NjJtNtxtMt8rzAOU9VhQRnpCLLg7ahczYOSBkHeqrkshFQBN5YZzIwflFyQUaZBSEkeT7Ce0vbNuCT4QvecvACNbnQnae4eeUav/RXf5Hvvfwyy3Xd9XhMOR5dztwFVioOdj8AGI9p89g+5JE8zC5PJGlfBWOfqt6cTQUL8TsMCqWi5+cH+Kw3YGnfXDASyeClty94vuIR4NXtN7mRQ5A1ZAEHgPqRKtJhgKPfn7hgeML3uwt45Pv9IdIT0R1siEIH19A999059eAvXWcPOntmMH7Wp8feeIWHHrwOGcB03zuXJ/2mvheoFQgsAbhokSO1pHKO1ixRP6obyk9oe//1VwixUoszDaYNubrYlqZtscYh8WQ6sDSZE2QStjbL2EHDUq0amjZ4+dqCMZ6qcUitGBeS6UQzGXnwhlKGasE88yjTYq1npDy68JS5osgzXr5nKDOFqVdIGdqsFUqTF5osU5SZZmNWMhllTEcZGxPIcsvlnYxJIcGHbiYmFghkmSTPIJMgtURLySgXQfBZ2Mh2EEJm1tIYSSUdzhsEGutCrmA/pDx5Lsi1Z92G9ngyOVQEfcS2MbFSWOC8iELSiudubvLcE9vcfXDGg6M1i1VN04bISpgTEluO44EisLGexhhaYzGtxVhL01qMCU53GHICbS3W6zgVBMb3ifghAhly6qyL33WO88Wa4/kSb22w4RFE/DjMy1/G5r0NVbdShl7aMS/aW4cQMRcQh7cWpVScnz7oRMYYp1SyU68J1x3vTJ8DE8zKI9eW+vF2uqK+m8QDUAUQurQEMOqjYHQ8z1R0Ej/vSML9fRg3tPoMAsdSJKmbqNpgzOA8B513fJ8vLOI1i2SvegMdndsE2gbvxeM753o729k2uvGR2tDFb9DZxnh+iSHsjjy09/FzvRmP0Yx4rumzcrD39F4Cjs4JnJFoSpQuqJ2hdisy9ROQgfn8S5/lX33/ZX7rjR/Q4tFeUArBNFO8dGOXJ/f3oWkQ0qGtYWOScXU3NCefXr2JVBo5HdNmE+zqHkjHetUwaj0Unkx7UJr5+RqtQvuyq5MxV7c22ZhMKDc2UN5zNl+SFRl5oUNT9FWDswLbeqx2nJ0vOVgs8Uh2rj3Ns5/4HPffewehMo7v3Qo9BbVEa4G1LdI3XHniBuONbazVHNz6gJsf/xSXrj+D1orpxhYA5SQ8OoiDMUp/CE3TrFBSBt0lFQaesy1tveLk+D47O1fIyzFSZ1gXBknb1Ji2oa4q9q89gdfhpwgMV+zLKJOmUghrWttECQmHFTowhypIzoiYh9a2hjzPyQvVleQ7Z6O+Xb+Q9gu84Fd++Vd485V/xztv3eLN9w9YrOoo/9IP2IveUs8MfQht/IS3kPt2sYJLxhwlIUXUsJJBETqet9Jpooet+2aKEojBhKXHWBfB4BAIDgBK57HFnJp4nORtD+BZvO89v3XhbAZsWPrMRR2p8PwCEA/P4r++++iPBOWPvCS6fYof/YHupWE+4ODvIQM5+Hr0Z/vvdovD4Nr84Hl6TKGOC9dGZBBCqz3vQshDWYlSoa1h2za42Lv2cW0n928H6RPh0YTQt5ICpUB7i/CGyUgzGyu8gGZVo7RkNvaUmcW1nka0NBas8ZS5pLaC2gp0BplyjEaWrJC41qM1mKYl0xIrJMKCNQapBJNSgsgYjR2jTFK3DVsbUy5v5owKxfa0YGOqmY5yilEeiuZyTZHLwD4qS2qlpfPQq7cDDi70/S0zKLRCK0FrHMKGHM7WBo054SUoyIRCSIW1gQls2gDQMi0pC0XrBZOR+/+1d2a/kpxnGf99W1X1craZM7bn2HGCndgmxHGUKCJAxAWbEnGL+Gv4fxCIGy5YgkREcoFCrARIHMcMNrEd22PPetburqpv4eL9aukzNhqkeHIx9dz0Vl1dVV311vNuz0sTEqtW0sxoI9eKVvgYMEmcc0lMRqxxzOcVO4uS83XD2SrRhAi01I38juo60vP1qhU4rSgKi54VpCTHK6GofZBIXyaEwXvaINJCbeuxkDXZenOANgmHJRUJkAyJ922eYCHi2MH//4rvfxVImZgprXLEVthBzClWTZIuXWe3ZuBKlgd6qzRwvf7aHkpeRg5ot2B/CY8zHPQZsO5a7vQQ6CJ048yJok8jKzPYUvLvdOSqy4yZkXh0T9ZG27Tlg4/DhP2bl+1u93K0890eKSANGaP+WH/c8e+I33h7BhPXL6cUfXBFdnogj4Y02OJRpoRMfkcctyez0SdIFp0MzixovKdOHuUstnxoWvfwBPAvvv9d3r5zG1torlcznnjigM+Uis+ZkvLKAbPdEn96xoKALTTLak6xuIK59jRp/4Dz+8ec/eJd/MWxCNiGSLh7AShcrFg6i1suuBsbmkbhdUJbqfmwpUE5TXOyxmY9wOQU63ZNSIFyXhEIrEmsfWDVNuzvH2CN5rkXX+RLX/sGWsP6/D4pKXxbc/v9d3jrjdeYl4ZnnnsJU8xQyvDcl3+b+c4+hXM0zRpjXUf30VpRbzYQI8YVyE06ZDbuSUE6ciHh24a2qYkhcbE6R9tSjKGbywWrEhfrU269/0usMewdPkVZzfqTsm+hVzHXxQixEVUTITqxv9gSpCgGNQUZEZciTRvQRlIqRVGgdNwKp6ec6r1+9DQv/ebLfP7ZI7569z7//tqb3Pifmxyfr/oLII4IYd/ZlUZ6fI8IKWR5FrErozmTncGQ9JKWHvlsSAZjMPDegfhcrvPoMTIQvWEYGypZ0UAG8zLDdMjOiHb+4eCldhvTG4rOMIwLkjvJgDE5HYUqO89xWN9lK7X9+hODZJfXs/XB9nEbtnlEDEdkdFjucq3fyBvuH8fesCyiRpwXGJ2vEqU12qCSweFok0J5j7XSgfqoMDMbNFCVYHLdY1kVaBVIKWK1xZiAK6SWLc7lLLBFBC/HxRSGWW/sI4tSs2M1KbT4NkEqIRl83cq8XaNQ2uIWBaoNGEqUjrgS3rq74XyVWO4rru9VlLOKgwpKkyhKR1UK2dNAYRRGiw11RqJsWiWMNXgMdRBH0lkLSKG+ViIwHxIklXCF7HXpND4UbBovNirkDlASWies1b3sR0JjTWJeaYmarWDlRVAJZTDKoLTcJJvWAwYb838aI4nYNzPEqAnRsGkaPrp3xunFmqow7C/n7Mwq6e5XWdy4cw6TQhlNYRWFBR8ts1JGOEYvqeDae9pGRqPFmPDeD06gopc48U3LJmvpJZXQSEbFPPx991eCFEV3UhpqOhkqpGlCSeZDW9lmZcjyLGI3jBnMhTjOH1NFOwoSZPpF97DtGA82dJwx6e1jLo3Ro3tPbzP7tOfoeznF09nKvjyq/y09olwjF3tEWunsfx/h63QH1cjEDrZ2bNf77zMmv+MDI+vUPdkbRtV1W7N1W8wqBtZe8lJTkgh6REScU+oFsXtq3d3f87YLR4wkp3DKok2JCZZ6VYP2aGex9lMggLMQ+YMnD5jvzfniS0d85be+TLsOnL77Pnaxy+npCfcvbnP35JRr165S6wIOn0JvWjZnK0ITqe/WxPNz2nZDo+HQzHCLJUVlubKzgzu6xulqzcXmAtUG1hcN87kjthA3Lc1mjQqJvSevstjdwbeBdbwg1B5XWdzuknK9QaEpZjNiaLg4PWG+u09SETcvCW3grZ+9wff+/u946eWX+cIr32D/2iEnp+dceeKI2XIHlEOrSFNfSPq0K5TNBCNESwiRcmZomhqtNE29BhLOijZSXdekCPVmQ1HO8D5SLcqekMQUKYuKJ46eJcTA6ckxB7ZAhYB1BUrbTGwMztmtm70U+QrxrNcrom8w1qK0dMCRpUGsVVir8V5ONBnQTTao+TRTmnlV8ZWvfoNXv/eP7Cx3+ObXv8RLzx/x1js3+el/fcD5qpYu2kxSunFVidRfnI8MMYgWEhZU7COmqhum3Rk1hVi4oMaR+DFF6UPtqv8C2wZh9L4af6n7/DIh7KN+0BcRp+HbHZ3aEld4IKK3/XwgTZ1O1nAWfCJx24qg8eDzjw38XVrPsLGdY9p/8HHHMo3e36KIY5L7ifu4vb/jY61H5D7kki58wKIJNAQ2SMffoxvDdbgMmTRpVJRzL4aNOHilAiPXl28jsQnYwspN1metL6UpZwrQogNYNzIGLgR8E/Axdw0HqWNy1sr0k6hzx7QmhJbVScMmaH70lmUxs8yqAm2lLGZZGawTIehEJETQuXlCRd1Hl30IWJMIG49SUgeojei2aaNwFmZVhTMKa8Wxan1k4+XPciiMdTRtoGlqmkYEazUOk5N6AUMThTQWLrKYJyDCOrCJcjMX8ghoqf9qAGdtn2nQymyl+M4uNvzgP2/wwe3jvuPXWseXnj/ic0fXpEGjcxBVIosagk5ZsBqpk9OaZIQUamMIPuKcJcZ8LFSuNVOa4D1RBVQhgYmdynB1kbi2PydqWG8enRQRgIox14tL+lCIEZmA5Gk5XRozDHamr6dN+XXczvSQpWGGJE8XfRv/+thAIGSmJ2IMSgjdSmJu+kndb0gaWBy+UaduZ1P70XU6z7cdCN0WKZfF6UpaFF3aNm9j79V3OzMySIr+c6VUXz/YO6tbGaEhEierkPq8bkXdVJZOH3Ury5ajrd2tYEgPpzzVaHxPUqN9JY8CTiL/kvc3pIiPieQ3OB+IBDw1iSY3Zz18LepDE8CjCmbacMUH/EnNycU59v6KZCo+uvUhH314izLULKsFoTW4ag+uXMEQKPevcfv2DZEU2DSo3Rn12Yqd609ILUxM3D5bsR9LitLhjGYd1mw2NUXhuHnzLvuH+5i2YblcQkxsVht0aCmSImkxpBWKameJM5qqKvnpD1/l8194kdXxHVxR4krHq9//Lv/8t//A4ZNP8Mrv/zFPPSPp6WJZU6/OmKddUopsmguJnqWuLT3n5HWBm8+oNxtSAmus3Jy8z3UHMidzvjjg7u33IGlm8z3u3f0IlMGVJU3dklLElTNMEpmZar7McheSXlDK92nmlMPR3YWglDSDhLYhellXjBGTo4UpeVKUkT8hiGyE0RrrHDEEQmrzeCWTyZMGW/A33/lXVqsVB7sLruwvWSx3+d2v7fDL9+7w5nsfsa7r7vzvL7rLhfyfPqR4PiS5OSqdpCug27AR4RqI0zjtoIYZwAmRlMlL93xHdUnUod3+copgK5UhKx4elRo1YuQbUO+9dT/8oGD7QJs64pQfu/Rvl7bptvmTSNSlNfbbvUXyRkby0uLbBPMyNbwc5Ru9n8ZLDGw1jY7jNuEdooHjdFN3EyCf713nZ4iRGD0mOepwwTo0BNUCEMOjC7+4PBdba0NSmdTpRNu0kn6LikBAJYme+aCJXmathpSwhWO+V+IKRTmb442hrdcopbDzilk1w6qIbwPV7pzWR/ymlUayqCgWM06O4cMTyxunS079Oca0LJcLNudnzCuJDBAjITRobdFRpnY0MTFTjiYqkrcUTpMsKJWYleLoei/6ioU2zArHvDJ51CY9gXVGESLUbSsam0ljbIlDUr8gtdZ1K8cmRUk1a2uYKengNyZxVis2QdNmLbPkE0mlvrZuXlmaOmAKcYJjjIQQ+e93PuTOvWOsVfggrQObZsXP3nqX+azk6cNdFApncmlMHpmlMBgFMQSS0iRR0pNoWohUZSmd5yn147dCCMTkpVs5REL0zAvH9f2Kw13Hc9eL7JC0j+wcBCAFccZjR3TkeoodsUPuHdFL2UxPBhnkqFRHSLI96zM6fQhLslz9NcnwONhLervbLzGK3HfCzGr0O0ohte1q1OWbCaJW9B2wnYyDyuvsyN1Wdje/seXsqiFD0jvjw4fbj6Pv9EuN9rd32sVjp4vJPWhVh/eBy4ZzIKYdKe6IYLcdKeX/Mrm6RowAAAfGSURBVF5aWyIG+uMUU6QNgeRzdJUanxqiCugEbfPw5+FDW83nD+e8f7zi3qrG3rnDz//tRxzaikKXzJcFOyqxrqGtwMwcFwfXsV5zXizhdAUaFnt7xHRBkyLPHT6Jiw3BKu6e1cTjU5qLNbay+DZx56LmdL0mFAYzKwk6Mb+yz97+LkXpODlbk7RGh1ZYcjSoEFgaw2efvMovb9+hmlWgE0Vh8b7l5z9+lRs/eY0XX/kqf/Jnf861609nUVewNnK+WdFsLnDVnKZeUc2WfTt6d/C1kedFWeY/VeN9g4+RwpZyoiSoZktCSBw9+wIpBk7v32NzsWH34Cr7h08RQmCzXmNcxWy5i3OdIHRmCSnRNivp1g3S0deN2wEw2qLyyW1dBUr3YqrWVgTfkIKnbRqid0RX5ky2XBg21+uQSdzZ2QlFYXj/gzNu3zkWbcI8PaMsDCG2w3nK+FJ/tPC+RRPE4PXjwDrjAB3RGlLCnQh3GmZKxlGofZRqYNtMbD3fIpGMHwfit7Xcpe93q9+KQD7wJG1twtjA9h5ndgOFVElaozc6SYzFsIrL/1F+d0TsBmM2OgSMEixbpG5YXmxXXq4jdd0qeiaYttYtRc1DN29PjtPIm2f473oOmaSju6vvbMMGFRRJgykspISvA48MSkRTfCsyTa40pCCOYr0KpKiY7ZYUhZFykcKiKVBGpFlM4SiqAm2kCP9i5dG6wjhNCNB4wzpII0VctRhTsFxewS2vsOYqcXGNwxeu8tRin9+b7xBT4F/+6Tu8+fMbPHUwY1EaUnNKC6iQJ+MUBmWSNK35JOO+TCQlQwhaunhbnXXzpKGhMCLb4pwjKOk0joC1irb1XNRyw1FGU7eepm5pWiFaMcqfF5PJ4/yUjKLTCp1ijixKrZo/a1nXUlcoKlRyzcYQOT2vuVjXWB2k9i43d926d0wdYLGc8/ILX+D1198grFY8dXTEOzfv8pknDyizXmIMEg0LMWX5KGnOISV8kjmsPgRxMEK+uSZJ8YUkn3Ujt7SC0hXsLwsOdwz7c8kKFYViXT+6KLQgklQWekYLeVBZA08PHqY2SACjT1mmLPcydMd2MMqMynoGmzaU3aiev3TLjEngdlZkO0vSdRtfzroMBHCwn+N07MDXhtToWJd2m7SNt5tLhHEUxbtko8dNL2OMMzldR/CDTu/2fUK2b+wI52OXXw/TqAYbTx4UMVZ0UN1/o0b/VD52Grn9taFFpShTf5REudvVw0eiH95tPmv57N6Sdy7OefPmGc/vR6haZvMN6xV4p3npi0fYYKmrJauqQGlDpGG/sJzdv0W1t+DMOOr1Bh8i5Uy84PWmZn/HEuoVzUZz4hM37hxjjOHmvfu88BtHzJ1ms66p9xU71QJ70rDxgTYqjFMUQGwjRUwc7Sx5/b1bvP3+h7z2gx/yzW9/m7Pju7z50x/z7Auv8Dt/9IfsXjnEmALRLpMh84v9K2jniDHQNjVFMccYMaDGOkYhplxrRi7+9VlywZJQOYWrOLh2xHK5x62bH2BMASlwfnaCMk6ImnbsXd3FODEcnQCmbxqMlihfUZa0m7p3GEJos3cqnb/OOkBlIxc5O71gubOLMU70sbQhNLV0TBnpNu4epaEiEkPgmaNn+Na3/pS/+su/5va9+2S/g5hgtfGMmcngsHxc1OnTha4qaGpQCq1dTvGIflWngt/XtqhcP5KV51VPnIaLs8tgj83g2Nvd6oZ7wMCMHrNxGr6bL9zeOg4O34gpbZGmwSQNDC2Nl+sN7zbBGozI6EB1J8wWHqTt2x7sCH0AsIvYjX9gW+5g/PlYz29Yx9ZCo4/F0en/Ly6dU7lGRp5GVIgEH/B10++7U6C1hfDoShGW+3MU0NQBHxVWQ1NHNhsgOuY7BbbUKA1uNhP7VC1AF9Rnd0mxIrjrNLqiWO5xfPw+G2QdKTmqnX3OTlZQVBwcPYGeX+GZr3yd4AN3b70nxf2+IWw23D+/4PUbv+A/fnKD0oJdHBKbu6SmBWPQSmNQqBDkrhES0WdhbaOIKmBtBA3WGpyB0igSMgHEasPcOWpaykJqARNSdlF7L7WB0WCtJ0VLjBtqH0TlJknXttZIZ2oKkIQspyiTe0qrcCoSW0+b8uzVJOu3Gs4vaj68fQGhZL1qaWrpvN3bqfjo3inWGJ5++hnefvtdfGjwbaRpAiiDVqKfmpLoSXbnv1JGyHjrCT7mWauynA8ilN1NcAlxIH8J6UattOLqDK7uKPYWBpMC9UZUFh4lVOlQTci2yUnjjFIyMzungGM3azZ0HaSDbYrjC7Q3TqCTGZxPRk1tvV3Vo+v/kt3sCNfIwe6XUWok8j5KK3eOOQP5U2rbme4zLjCyw/Tr3TLNaSBu/TLjb1wigVu1fyNiONwG1LDi8dqy77r9C4OD/EnGtW+Sy4d8cJgj43S4RGwTxEQIvt8nrTWFMQQfaHxNiJ3AO1hdPrDH/xdU+nXcxSdMmDBhwoQJEyb82vCIK/gnTJgwYcKECRMm/LoxEcAJEyZMmDBhwoTHDBMBnDBhwoQJEyZMeMwwEcAJEyZMmDBhwoTHDBMBnDBhwoQJEyZMeMwwEcAJEyZMmDBhwoTHDBMBnDBhwoQJEyZMeMwwEcAJEyZMmDBhwoTHDBMBnDBhwoQJEyZMeMzwvy2r/FOUz44+AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 58%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 7/12 [29:15<20:10, 242.10s/it, test/blurry_pixcorr=tensor(0.3928, device='cuda:0', dtype=torch.float16), test/loss=21.9, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=7, test/test_bwd_pct_correct=tensor(0.9844, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9688, device='cuda:0'), train/blurry_pixcorr=tensor(0.2900, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.7413, device='cuda:0'), train/fwd_pct_correct=tensor(0.6758, device='cuda:0'), train/loss=23.6, train/loss_blurry_total=23.2, train/loss_clip_total=0.427, train/lr=2.83e-5, train/num_steps=2737]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 67%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 8/12 [33:09<15:57, 239.47s/it, test/blurry_pixcorr=tensor(0.4207, device='cuda:0', dtype=torch.float16), test/loss=21.7, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=8, test/test_bwd_pct_correct=tensor(0.9688, device='cuda:0'), test/test_fwd_pct_correct=tensor(1., device='cuda:0'), train/blurry_pixcorr=tensor(0.4053, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9851, device='cuda:0'), train/fwd_pct_correct=tensor(0.9863, device='cuda:0'), train/loss=21.7, train/loss_blurry_total=21.6, train/loss_clip_total=0.0345, train/lr=2.71e-5, train/num_steps=3128]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 9/12 [37:03<11:53, 237.72s/it, test/blurry_pixcorr=tensor(0.4331, device='cuda:0', dtype=torch.float16), test/loss=21.4, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=9, test/test_bwd_pct_correct=tensor(0.9688, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.4543, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9845, device='cuda:0'), train/fwd_pct_correct=tensor(0.9851, device='cuda:0'), train/loss=20.9, train/loss_blurry_total=20.9, train/loss_clip_total=0.0405, train/lr=2.55e-5, train/num_steps=3519]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 83%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 10/12 [40:56<07:52, 236.30s/it, test/blurry_pixcorr=tensor(0.4392, device='cuda:0', dtype=torch.float16), test/loss=21.6, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=10, test/test_bwd_pct_correct=tensor(0.9844, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(nan, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9864, device='cuda:0'), train/fwd_pct_correct=tensor(0.9865, device='cuda:0'), train/loss=20.3, train/loss_blurry_total=20.3, train/loss_clip_total=0.0442, train/lr=2.37e-5, train/num_steps=3910]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 92%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 11/12 [44:49<03:55, 235.41s/it, test/blurry_pixcorr=tensor(0.4302, device='cuda:0', dtype=torch.float16), test/loss=21.6, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=11, test/test_bwd_pct_correct=tensor(0.9688, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(0.5210, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9855, device='cuda:0'), train/fwd_pct_correct=tensor(0.9857, device='cuda:0'), train/loss=19.8, train/loss_blurry_total=19.7, train/loss_clip_total=0.0519, train/lr=2.17e-5, train/num_steps=4301]" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [48:43<00:00, 243.63s/it, test/blurry_pixcorr=tensor(0.4312, device='cuda:0', dtype=torch.float16), test/loss=21.6, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=12, test/test_bwd_pct_correct=tensor(0.9688, device='cuda:0'), test/test_fwd_pct_correct=tensor(0.9844, device='cuda:0'), train/blurry_pixcorr=tensor(nan, device='cuda:0', dtype=torch.float16), train/bwd_pct_correct=tensor(0.9863, device='cuda:0'), train/fwd_pct_correct=tensor(0.9863, device='cuda:0'), train/loss=19.4, train/loss_blurry_total=19.3, train/loss_clip_total=0.0491, train/lr=1.95e-5, train/num_steps=4692]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===Finished!===\n", + "\n", + "saving /fsx/proj-fmri/ckadirt/MindEyeV2/train_logs/test/last.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_blurry_total += loss_blurry.item()\n", + "\n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=8, replace=False)\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == batch_size\n", + " \n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + "\n", + " loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " loss = loss_blurry + loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " plt.show()\n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABOC0lEQVR4nO3dd3xT5eI/8E/Ska60rE5a9ihQirKLyKaAgCA4QRT9iYrAhYteFBCsohTxyhcVRXHgQMSBKFegDKFFRqGUVVbZUKClULp30/P7o22aNLtNTtbn/Xr1dZNznpzzNOGaT58pEQRBABEREZFIpNauABERETkXhg8iIiISFcMHERERiYrhg4iIiETF8EFERESiYvggIiIiUTF8EBERkagYPoiIiEhUrtauQF2VlZW4desW5HI5JBKJtatDRERERhAEAfn5+QgJCYFUqr9tw+bCx61btxAWFmbtahAREVE9pKWlITQ0VG8ZmwsfcrkcQFXlfX19rVwbIiIiMkZeXh7CwsKU3+P62Fz4qOlq8fX1ZfggIiKyM8YMmeCAUyIiIhIVwwcRERGJiuGDiIiIRMXwQURERKJi+CAiIiJRMXwQERGRqBg+iIiISFQMH0RERCQqhg8iIiISFcMHERERiYrhg4iIiETF8EFERESicsrwUVBagS8SLiHtXpG1q0JEROR0nDJ8LPnfGcRuO4eRK/dauypEREROxynDx4HLdwEAhWUKK9eEiIjI+Thl+BAEa9eAiIjIeTll+CAiIiLrcbrwUaGoxI3sYuXz4SsS8N6WM1asERERkXNxtXYFxPbSD8lqzy9kFuBCZgEOXMrCZ5O7o2VTbyvVjIiIyDk4VctH4uUs/H0uU+u507fyMO+3kyLXiIiIyPk4Vfh4ck2i3vOHrtzDhM/2I+VGrkg1IiIicj5OFT6McfR6Dp76Un9IISIiovpj+NCioLTC2lUgIiJyWAwfREREJCqGDyIiIhJVg8JHbGwsJBIJ5syZozwmCAJiYmIQEhICT09PDBo0CKdPn25oPa1u7/k7OHkjx9rVICIisnv1Dh9JSUlYs2YNIiMj1Y4vX74cK1aswKpVq5CUlISgoCAMHz4c+fn5Da6staTdK8Iz3xzGw6v2W7sqREREdq9e4aOgoACTJ0/Gl19+icaNGyuPC4KAlStXYuHChZgwYQIiIiLw3XffoaioCOvXrzdbpcWWll1k7SoQERE5jHqFjxkzZmD06NEYNmyY2vErV64gIyMD0dHRymMymQwDBw7EgQMHtF6rtLQUeXl5aj9ERETkuExeXn3Dhg04evQokpKSNM5lZGQAAAIDA9WOBwYG4tq1a1qvFxsbi7ffftvUaohKAom1q0BEROQwTGr5SEtLw+zZs7Fu3Tp4eHjoLCeRqH9ZC4KgcazG/PnzkZubq/xJS0szpUpERERkZ0xq+UhOTkZmZiZ69OihPKZQKLB3716sWrUKqampAKpaQIKDg5VlMjMzNVpDashkMshksvrUnYiIiOyQSS0fQ4cORUpKCo4fP6786dmzJyZPnozjx4+jTZs2CAoKws6dO5WvKSsrQ0JCAvr162f2yhMREZH9ManlQy6XIyIiQu2Yt7c3mjZtqjw+Z84cLF26FO3bt0f79u2xdOlSeHl5YdKkSearNREREdktkwecGjJv3jwUFxfjlVdeQXZ2Nvr06YMdO3ZALpeb+1ZERERkhxocPuLj49WeSyQSxMTEICYmpqGXthk6xsoSERFRPXBvFyIiIhKV04QPQRCMLsuWDiIiIstxmvBRaXz2ICIiIgsy+4BTW1WuqDS6bE3Dx6ZjN1BcVok2/t6WqRQREZETcprw4eZifCOPRCKBolLAv38+AQBYNel+S1WLiIjI6ThNt4uL1PiBHBIAlSpjRApLKyxQIyIiIufkNOGDiIiIbAPDhxYSCaA6OYa72hIREZkPw4cWDBtERESWw/BhDGYRIiIis2H40EYCCNC+MMitnGLltN3Tt3KRdq9IzJoRERHZPaeZamuKug0dqs/7LdutUf7qstEWrQ8REZEjYcuHFqUVlTBhNXYUlRmeinvyRg5iNp9GblF5A2pGRERk/xg+zGDa90cMlnl41X58e+Aq3t1yRoQaERER2S6GDx1UFxmTGNhpbv/FLHz1z2XcLSg1eN3zmQUNrhsREZE9Y/jQoVyhEj6MKP/ulrNGtYAQERE5O4YPHbacTDf5Nceu55i/IkRERA6G4UOHhPOZFrkulwwhIiJnx/Chw/bTt5WP3/nLtEGiZRWV5q4OERGRw2D4MEJusfHTYz9PuIQOb25Dqze24GJmvgVrRUREZJ8YPsxs2bZzysevb0yxYk2IiIhsE8OHBVUo2P1CRERUF8OHBZ24kQsAuJ5Vu//L1axCa1WHiIjIJjB8iEB1wGpOUTluZHMzOiIicl4MHyIoq9P9klLdIkJEROSMGD6sKDOvBLHbzqp1yxARETk6hg8rWLz5NIrLFJix/ii+SLiMRz8/oFGmpFyBvefvoLRCYYUaEhERWQ7DhxXcyS/F5wmXkHQ1GwCQma+5Id2rv5zAM98cxhITFzgjIiKydQwfFvbn8ZvYe/6OxvE0A4NOt6RU7S2zLvG6RepFRERkLU4VPj6d1F30e87ecFz7CUH7YSIiIkfnVOFjdGQwkhYOs3Y1iIiInJpThQ8AaOzlZu0qAAB+P3bT2lUgIiKyCqcLHxIJN7UnIiKyJqcLH1JmDyIiIqtyuvAhkUhw5p0R1q4GERGR03K68AEAXu6u1q4CERGR03LK8GHrMvNLrF0FIiIii2H4sEEVCi4CQkREjovhwwa5cFQsERE5MIYPG8TZwERE5MgYPmyQlOmDiIgcGMOHDWL4ICIiR+a04aNNM29rV0EnRg8iInJkThs+hnYKsHYVdLqZU2ztKhAREVmM04YPwYZns/5rwzFrV4GIiMhinDZ89GzVWPm4kY3sdFvjWlaRtatARERkMU4bPkZ0CcJnk7sj4T+DcGzRcER3DrR2lSAIApZuPQtFZcObZdbsvYSxn+xDbnG5GWpGRERkPk4bPiQSCR7qGoyWTb0hsZHZJfsu3sWavZfNcq2lW88h5WYuvv7HPNcjIiIyF6cNH3VZO3+sjr+E7CLdrRR5JeV4Y+NJHLh416TrlioqG1o1IiIis2L4sBHvx53DxcwCnedX7DiPDUlpmPTVIdMubMMDa4mIyDkxfFQbHRli7SqgqLRC57m0exyESkREjoHho9rYyGD89nKUVevw1b4rOs+pdgttOnZDhNoQERFZBsNHNYlEgp6tmli7Gkb5988ndJ4rKVeYZbYMERGRpbhauwJkLMMjYovKKtDt7R0Ia+wlQn2IiIjqhy0fdiC7sAyHLmcZLHfyRi7KFQIu3y0UoVZERET1w5YPO3D/kp0axwRB0FifJLuwTLOcxWpFRERUP2z5sFNX6rRuFJVVYPqPR61UGyIiIuMxfNipIR8m4Gx6nvL5jWzuhEtERPaB4cOOxafesXYViIiITMbwYYJNr/SzdhXUSCTAvcIy3MxhqwcREdkPDjg1ga1sQFdj/8W7WLbtHADg5xf7Wrk2RERExjGp5WP16tWIjIyEr68vfH19ERUVhW3btinPT506FRKJRO2nb1/7+lLs1aoxAKBjoFzjnCDY1tyRfy7UbjKna3qtrdWZiIjIpJaP0NBQLFu2DO3atQMAfPfddxg3bhyOHTuGLl26AABGjhyJtWvXKl/j7u5uxupa3tdTe2H/hbsYHB6A8EVx1q6O0WyrTYaIiEg3k8LH2LFj1Z6/9957WL16NRITE5XhQyaTISgoyHw1FJmvhxtGdQ0GAIyJDMZfJ9OtXCPjFOjYlI4NH0REZGvqPeBUoVBgw4YNKCwsRFRU7YZs8fHxCAgIQIcOHTBt2jRkZmbqvU5paSny8vLUfmzFojGdlY/9PN2sWBPD3t1y1tpVICIiMorJ4SMlJQU+Pj6QyWR4+eWXsWnTJnTuXPUlPWrUKPz444/YvXs3PvzwQyQlJWHIkCEoLS3Veb3Y2Fj4+fkpf8LCwur/21jQjn8PsHYV6sXGxsgSERGZPtulY8eOOH78OHJycrBx40Y8++yzSEhIQOfOnfHEE08oy0VERKBnz55o2bIltmzZggkTJmi93vz58zF37lzl87y8PJsMIB6uLtauQr2w24WIiGyNyeHD3d1dOeC0Z8+eSEpKwkcffYQvvvhCo2xwcDBatmyJCxcu6LyeTCaDTCYztRpERERkpxq8yJggCDq7VbKyspCWlobg4OCG3oaIiIgchEktHwsWLMCoUaMQFhaG/Px8bNiwAfHx8YiLi0NBQQFiYmIwceJEBAcH4+rVq1iwYAGaNWuGRx55xFL1JwPY60JERLbGpPBx+/ZtTJkyBenp6fDz80NkZCTi4uIwfPhwFBcXIyUlBd9//z1ycnIQHByMwYMH4+eff4Zcrrlglz2oO1azmY/9dQ8VlFQgM68E/7frPCb3aYmI5n7WrhIRETk5iWBjS2Dm5eXBz88Pubm58PX1tWpdMvNL0Pu9vwEAJxZHw8/LDavjL+H9uHNGX2PeyI4IkHvgtV9PWKqaBvVu1QSHr94DAFxdNtpq9SAiIsdlyvc3N5bTw99HhgEd/DG4oz98PasaiV54sLVJ12jZxBuju1p3zEtN8CAiIrIF3FhOD4lEgu+f7612zM1FilNvj0BhaQX6LP3biGvY/lobX++7gh8PXcP6F/oiyM/D2tUhIiIHx5aPevCRuaKpt33tWaPPkr/O4PKdQvx3R6q1q0JERE6A4aOeXF2kOPLmMK3nZg9tDzeXquaOHi0bi1mtBimrqLR2FYiIyAmw26UBVGe/hAfJ8efMB3AtqwjtA3wwbUAbFJRUINDXA6UVCivWkoiIyLYwfJiRzNUFHQKrphX7yFzhI6t6eyXc8J6IiEiJ3S5mItEzqtTWB5wSERGJieHDTPTlC3vJHja14AsRETkshg8iIiISFcOHmejrWtHXJWNLbGyxWyIiclAMHyKwpehx+U6BtatAREROjuHDTPS3fIhXD0Pe2JgCADhw6S4+2H4OD330j5VrREREzoZTbUVgS90uReUVAIBJXx6yck2IiMhZseXDTOxlLQ999eSIDyIiEgPDRwN1C2sEAHi8Z6hR5TfPfMCCtTHMhhphiIjISbHbpYF+mtYHZ9PzcH+YfezhwuxBRETWxvDRQF7urujRsonR5a09m/XEjVw8ueagdStBREROjd0uVvDXrP4Yf18Ifn6xr1Xun3j5nvYTHPRBREQiYMuHFUQ098PKJ++3djWIiIisgi0fImneyBMuUgk6BsmtXRUiIiKrYsuHSOL/MwiKSgEebi5Gv2Zynxb48dB1C9aKiIhIfAwfInFzkcKE3AEA8PN0s0xldBA46IOIiETAbhcbxihARESOiOHDhll7Wi4REZElMHxY2Z8zdK94ym4QIiJyRAwfVlazPLs2Yrd8sKWFiIjEwPBhwwSR08C2UxnYlpIu+n2JiMi5MHzYAG937dNgGnm5i1wTYPqPR/HmH6dEvy8RETkPhg8bEP+fwfjh//XWOO7uYp2Ph2uLEBGRJTF82AB/uQwPtvfXOP5k7zAr1IaIiMiyGD5smNzDDYvGdLZ2NYiIiMyK4cNGRbVpCgB4NqolPn+6u5VrQ0REZD4MHzakX9uqwPHSwDZY90IfAICrixQjI4KtWS0iIiKz4t4uNuSbqb1wJj0P94U2glQqsXZ1iIiILILhw4Z4uLmge4vG1q4GERGRRbHbhYiIiETF8GHnxt0XIur9SisUKCqrEPWeRETkWBg+7NwL/duIer+e7+5C58XbUVKuEPW+RETkOBg+HMD7E7ua/Zqf/H0BpRWaASO/pKrV42pWodnvSUREzoHhw84JEPBErxZmv+6HO8/jv9tT1e+lsuGcBJyNQ0RE9cPwQTp9+c8Vteeqm91+9c9lkWtDRESOguHDztW0QDRv5Gnxe6lkD/yafMPi9yMiIsfE8OEgNrzYF9MebG32625NSVd2t6h2uxAREdUXw4eDCGvihYWjzb8J3Ss/HsX9S3bieFoOGD2IiMgcGD7sxKpJ92s9LogQCXKKyjH+0/3IKy63+L2IiMjxMXzYiTGRtYuJtfX3tkodPtl90Sr3JSIix8LwYUfmjeyIyX1aYOP0fspjYk55zWXLBxERmQE3lrMjrwxqBwAoq6i0ck2IiIjqjy0fdkii0tghxpiPGlmFZaLdi4iIHBfDhx0ytqOlibe7We+79/wds16PiIicE8OHHZKoNH3oG/Ox//UhcJVabkzIV/9cRnEZN5gjIiLTMHw4ME93F6x7oY/y+ZDwALNe/90tZ/HfHamGCxIREalg+LBDprRl9G3TVPm4a3M/vDW2Mxp5uZmtLoeuZGHN3kt46KN/kFPEMSFERGQYw4cdkjSgJ+W5B1rjw8e6ma0uggAs3XoOZ9Lz8MVebjZHRESGMXzYIYmJ6SOsSdWmcyMjgqpfb766qG73svtsJgBg8Z+n8Mw3h1FZyQXZiYhIE9f5cAI7/z0QWYVlyp1vTQ0v+lSqpI/U2/kAgO8PXgMAJF/PRq9WTcx2LyIicgxs+XACHm4uyuABmDZmxJC0e0U6z1Uo2PJBRESaGD6ckNSMLR+FnGpLREQmYvhwQuYc80FERGQqhg87F9zIw+TXmLPlg4iIyFQccGqnds0dgMJSBZr5yEx+LaMHERFZk0ktH6tXr0ZkZCR8fX3h6+uLqKgobNu2TXleEATExMQgJCQEnp6eGDRoEE6fPm32ShPQLkCObmGNdJ6fM6y9znOuLtZp8MrILcE9bk5HROT0TPoWCg0NxbJly3DkyBEcOXIEQ4YMwbhx45QBY/ny5VixYgVWrVqFpKQkBAUFYfjw4cjPz7dI5Um3zsG+Os/1aNlYlDqo7ribX1KOvrF/o/uSnaLcm4iIbJdJ4WPs2LF46KGH0KFDB3To0AHvvfcefHx8kJiYCEEQsHLlSixcuBATJkxAREQEvvvuOxQVFWH9+vWWqj/Vg4sFN5tTdeVuIdYlXkO5ohLX9UzJJSIi51LvMR8KhQK//vorCgsLERUVhStXriAjIwPR0dHKMjKZDAMHDsSBAwfw0ksvmaXCZBx3V+t0rQgqi44t3HQKAFBSrkC/ts3UyphzoTMiIrIvJoePlJQUREVFoaSkBD4+Pti0aRM6d+6MAwcOAAACAwPVygcGBuLatWs6r1daWorS0lLl87y8PFOrRCpmDWmHs+l5eLC9v1Xuv/hPzTE+R69no3/72vBRKQAuzB5ERE7L5PDRsWNHHD9+HDk5Odi4cSOeffZZJCQkKM/X/YvW0F+5sbGxePvtt02tBunwanRHk1/zWI9Q/Jp8wyz3/yFRe9CUqMyxqRQEuHDODRGR0zK5bd7d3R3t2rVDz549ERsbi27duuGjjz5CUFDVpmUZGRlq5TMzMzVaQ1TNnz8fubm5yp+0tDRTq0QNtHRCV4teXxAA1WEmqvvBEBGR82nwwABBEFBaWorWrVsjKCgIO3fWzmYoKytDQkIC+vXrp/P1MplMOXW35ofE5SbC1Ns9qZnKx5WVFr8dERHZMJO6XRYsWIBRo0YhLCwM+fn52LBhA+Lj4xEXFweJRII5c+Zg6dKlaN++Pdq3b4+lS5fCy8sLkyZNslT9qZ785TLcyS81XNBMPk+4rHxcKQj4Oek6dp3NxCdP3Q8PNxfR6kFERNZnUvi4ffs2pkyZgvT0dPj5+SEyMhJxcXEYPnw4AGDevHkoLi7GK6+8guzsbPTp0wc7duyAXC63SOXJfIaEB2D3uUzDBetBW7fL6xtTAAA/HLyGaQPaWOS+RERkm0wKH19//bXe8xKJBDExMYiJiWlInUgEyydG4rlvk/D6yHAAwJopPfDVvitYtu2cRe6nOui4UmXIR15JufJx8rV7uJlTgoe7hVikDkREZBu4t4uTGhwegHNLRiq7PFxdpGjn72ORe+2/dBfe7rX/1CpV0sehy/dw8kYOIkMbYeLqgwCAdv4+6BzCsT9ERI6Ku9o6sbpjLQZ19MeADv6YObidWe+TX1KBjLwS5XPV2S6Hr97Dw6v2q5W/fq/QrPcnIiLbwpYPUnJ1keL753sDAFbtuWix+1QamGnLmbhERI6NLR8kutIKhbWrQEREVsTwQaIrrdBc6EN1Txg2fBAROTaGDxKdoKVfRbUrht0uRESOjeGDRKdtzId6ywfTBxGRI2P4INH978QtjWOGBqESEZHjYPgg0X2yW3Mmjer0W3a7EBE5NoYPsjnMHkREjo3hg2xCJZs7iIicBsMHGbR4TGeL30NQm+3CIEJE5MgYPsig7i0bW/webPkgInIeDB+k1foX+igfu6jsSGsp2qLHsevZWPznKeQWlWs5S0RE9op7u5BW/do1Uz4WIXtAUFn0tKYR5JHPDgAASsoVWP5oN8tXgoiIRMGWDzIopJGnxe+h2u0y5+fjKCytUD6/kFlg8fsTEZF42PJBOu2aOxAl5Qo08Xa3+L3yStS7VjYevWHxexIRkXUwfJBO7QJ8RLvXwA/i1Z4v/vO08rEIvT5ERCQidrsQERGRqBg+yGQfPXkfmoswDoSIiBwTwweZbNx9zbH/jSH4+cW+1q4KERHZIYYPMsqaKT3g4SbFZ5O7K4/1adPUijUiIiJ7xQGnZJToLkE4/fZIuEg5/JOIiBqGLR9kNH3Bo6cFl2CXiLHKGRERiYbhg4iIiETF8EFERESiYvggs7DknrTJ17KxdOtZC96BiIjExPBBDTKxeygAYNqDbSx6nzV7L0MQLBlxiIhILAwf1CD/fSwSZ94ZgfAgucXv9Vuy9v1ebmQXYcfpDIYTIiI7wfBBDSKRSODl7go/TzeL3+ub/Ve1Hu///h68+EMytp3KsHgdiIio4Rg+yCwae7tjTGSwRe9hqGXjlR+PYs3eSxatAxERNRzDB5nN8M6BFr1+VmGZwTJLt57DpTsFFq0HERE1DMMH2Y07+aUaxyorNVtDnlubJEZ1iIionhg+yK7cyS9FhaJS+fx/J29plLl+r0j5uEJRCYWWgEJERNbD8EFmozoko7GXZQag9npvF0Z/vE/5/OSNXJ1lKxSVGPhBPEas3MuZMERENoThg8xGtYVh3H3NLXaf1Nv52Hv+jsFyN3OKcTOnGBczC1BSXmmwPBERiYPhg8xGodK6MGdYewwJD7DYvT76+wIA9daWuiSo3ZBOsOgarEREZAqGDzIb1a6NRl7u+GZqL3QO9rXYvTLzS3D+dr7OMubeDPduQSne+d8ZXNBzTyIiMozhg8xGoaVno1uYn/LxhPvN1xUjAOj93t/Yd/GuceUNNHwUlykMXuPVX07gm/1XMGLlXqPuSURE2rlauwLkOCq1fMMveKgTmvnIMCYyBIVlFfj92E3R6qPa8qEve3z89wWs2Hke3z7XC4M66u4qSrlZNbiVk2eIiBqGLR9kNs0be2ock3u44dXojugYJDfY+mBuEpX0oS0Y1Vix8zwA4M0/Tlm8TkRExJYPMqNBHfwxf1Q4uoT4GS7cQKYGmct3CpFVUIqhnXSvwmrompyuS0RkHgwfZDYSiQQvDWxr7WooqY43Hf/pfgDA+ml90K9tM+tUiIiIALDbhUQlXstBhaJS62yXSV8ewvR1yaLVg4iINDF8kF0yFGP+teEYkq5maz237VSG8nFRWYXBex27no3+7+9GdlG5KVUkIiId2O1CohFzyMTWlAxsTcnQWyb52j1MXH1Q+fxmTrHWcs99m4QcBg8iIrNh+CD7ZIYkoxo8NC8vYNr3R+AtczVqDRAiIjIewweJxpwNH3klhrtL9Pkh8Zre89fvFWHX2UwA5l8plYjI2XHMB9mlK3cLG/T6RTrW9Cgpr2rlMLSQ2LzfTqCSq40REdULwweJRrWnpHerJtariB7aenO0HfvlyA2jl3a/mJmPLxIuKYMNma6yUsCz3xzGGxtPWrsqRGQGDB9kFc890MraVdAq4fwdAMYtKFZYalzXz7AVexG77Rw+2X2hQXVzZmfS85Bw/g42JKVZuypEZAYMHyQa1S90Wx1H8bIJa4CY+jscvZZj2gtIScEuLiKHwvBBVqL9m/uzyd1FroemnKIyI0ualj4ELUNub+eVID41E4IgYGtKOk5Vb15HROTIONuFRGPM365DwnXvKiuWJ9ckYv5DnYwu/3PSdby+MQVrpvRAdJcg5fGNyTewOzVT72v7xv6tMabk6rLRJtXX2fRZuguLx3TB6Mhga1eFiOqJLR9kFVIb7XYBgHMZ+Xj2m8MGy0klwLaUdLy+MQUA8OIP6l02r/56AltOpiufCwJQXKZAuaJS7Zi5nU3PQ8zm07hbUGr+i9uA23mlmLH+qFFl/zp5C/N/P6n2nhOR9TF8kGhUv2gDfD2sVxEzKamoxPQfjfsSBICiMgU6LY7DwOV7zFaHg5eysGr3BbVpv6M++gffHrjq8DNDVu46b7DMzPXH8NPhNPxyhANViWwJwwdZxX1hjTB9UFs08nLDu+MjlMdtdSCqNuUV2v+aLiytwO28Eo3jKdXjOW7lltR72m1JuUJt4O5TXybivzvO488TNzXKnr6VV6972IuVuy4Y3bpzJ98xW4GI7BXDB4mm7oDL10eG4/jiaPRurb7mR4dAHzGrVW/avvgqFJXo8tZ29Fn6t97XLtiUovPcGR2h4VZOMcIXxaH1/K24cDtf7dy1rCIjamwbKisF5JeYZ68cY5e+F3NfISIyjOGDbIoEEvz+ygPWroZRYred0zhWYOTaH78f1WypqPHQx/+gQlGJVm9sQas3tqCierzChsPXlWWe+zZJ7TW28OVaoajEs98cxoodqWrH7xWW4dM9F5GeW4yyikp0WhyHrjE7cCO74YHJ2Cm4xqzbQkTiYfggq1PtaZFIAB+Z/U7CkpppJG27hduUjxdvPg0AkKj0Sd3ILkZmna6dknIFdp25rXwu9vftrrO3kXD+Dj7efVHt+OwNx/DB9lRM/vIQZm84htLq7qrNJ241+J4VOsLHtpR0fLPvivL5mXTH7oIisjcMHyQeJ/jjU2rCoBVj/xpff+g64lMzNa4995cTas/DF8Xhhe+P1F6/gW94bnE5FJUC/rlwBwOW78HBS1l6y5eU146BWajSrfTPhapl6C/fLcS2UxkNqlNdulo+pv94FO/8dUb5fNfZTCRfyzbrvYmo/kwKH7GxsejVqxfkcjkCAgIwfvx4pKaqN7FOnToVEolE7adv375mrTQ5rpqv16d6h1m1HmIwZdHOqWuTNAbjnjXw13xDWj6uZRWi29s70HbBVkz5+jCu3yvCU18morJSwMd/X8ABLfvaqIadHw9d1zhvCcfTsnExs8CoshNXH7BwbYjIWCaFj4SEBMyYMQOJiYnYuXMnKioqEB0djcJC9R1GR44cifT0dOXP1q1bzVppsk+mfBcuGReBn1+0v9BqytgCU8ch1O3RkRhoZdF19fTcYsRuPYtrWbp3Bt50TPuYlE92X8SKnecx6atDWLv/ito5S3bz6Lr06xtTMGxFguVuTEQWYVLnelxcnNrztWvXIiAgAMnJyRgwYIDyuEwmQ1BQUN2XExlU84Xq6iJFZGgj61amHkz5/jV1u5K6YcNQD4+2MFChqERU7G4AwM9H0nB8cbTW15bqmEb8ecIl5eO3/3cGvVo1QURzP61l//PrCbw+Ktyk+hGRc2jQmI/c3Kp1C5o0UZ8qGR8fj4CAAHTo0AHTpk1DZqb+JabJOZj6ZePp7mKZilhQ3Smw+lSa+IboCxuHrmiOx7hbUIoR/7cXBy9lKaekZhXW7luTU1SuMeW1slLAC98lYXX8JWhTt/Xljsp047q/zq/JN/DWn6d1V9oIFYpKfH/wqsGulXuFZVgdf0nr+ipEZHvqHT4EQcDcuXPRv39/RETULhI1atQo/Pjjj9i9ezc+/PBDJCUlYciQISgt1b7IT2lpKfLy8tR+yLn4y2XKx3W/X7+Z2lPcyjTQxNUHjS6rOiDSGHUHnKoGgcTL97S+JvV2Pp76MhGdFsfhyNV7Gu9v15gdyC2qDSAJ5+9g11ndfywU6llXQ1uUunTHuPEYuqw/fB2L/zyN1349obfc7A3H8H7cOUz5+pDR1y4pVyinMRORuOodPmbOnImTJ0/ip59+Ujv+xBNPYPTo0YiIiMDYsWOxbds2nD9/Hlu2bNF6ndjYWPj5+Sl/wsIcf6Chs9I1+6KRlzs2Tu+Hv2b115iqOiQ8EE/1biFG9US33sRBmXVbIyQm7qq7bNs5rRvxHr1eOwvE2HVKautQS9sYlvwS3df7YHuqznNAVSvM7nPGtZrWzKg5f9u4sFNSrkD4ojgM/7+9RpUnIvOqV/iYNWsWNm/ejD179iA0NFRv2eDgYLRs2RIXLlzQen7+/PnIzc1V/qSlcQ8GRxUg172fS4+WjXWOHZj2YGsAwITuzS1SL3uRW6zeRVJSYfoS7dqmAhv7BW+Itmh5M6dY72tq9qS5lVOMFTvPIzO/tttk2vdHEJ96xyx1U1VcpsC7W6pana7cLUTcqXT0f383jqflmP1eRKSdSQNOBUHArFmzsGnTJsTHx6N169YGX5OVlYW0tDQEB2vf/lomk0Emk2k9R46lY5Ac746PQLCfaZvKtfH3wbklIyFzlepdGdTZ5BSZtkS5AO3h44fEa1hSvb+OqWNAr94tBDpWPS4ysdVE1ZSvD+HSnULsPX8Hf8yoWuH273qGosNXtHdBAcC+C3fxdJ2umZfXVW0O+MJ3R3DkzWH1uicRmcaklo8ZM2Zg3bp1WL9+PeRyOTIyMpCRkYHi4qq/bgoKCvDaa6/h4MGDuHr1KuLj4zF27Fg0a9YMjzzyiEV+AbIvT/dtiaGdAk1+nYebi86ppe9P7NrQajkNc+/bF/O/M7hwOx/zfjuBmP+ZNoYFqA07l+5UTfs1R+vD41/oHnezePMpnefK6tGSRET1Y1LLx+rVqwEAgwYNUju+du1aTJ06FS4uLkhJScH333+PnJwcBAcHY/Dgwfj5558hl8vNVmkiVa5SLtRrjNzicp0zbHafu40vEi5jQAd/k6/bkHET5YpKuEjFm9V0+Y7utU0MrZtCROZjcreLPp6enti+fXuDKkRkKlcXfmkY42JmASZ9qX02yPPfVi3LfkhPl4UlhC+KQ+wE22i5YvYgEg//ZCS7NLlP7QwYNxf+MzZWqgnrkIhl/u8pas/zSkwby2IuzB5E4uF/tckuqbbBuZqwk2wjLzetx9sH+DSwRmQukTE78PCqfaLfV3Uw7vWsIsz77YTR+8YQkWkYPsjuuZgQPnSVbOztbp7KkFmcvJEr+j1Vx3w89+1h/HLkBh77nJvREVkCwwfZla7Va4EMDQ9QHjMpfLBjn3RQ/adRM/sm28TpzERkHIYPsit/zHgAp98egXYq3STGho8vn+mpcyGzfm2bmqV+ZL/u5GvfAoKIzI/hg+yKi1QCb5krWjb1xltjO+OjJ+9TCx8Bct0L1kkAfPhYN43jCx/qhOmD2lqiukREpIVJU22JbMlzD1StsFuuqET7AB+0bOqNmIc7o//7e7SWrxQEtU3sajzROwwyV/vbQZeIyF4xfJDdc3ORYvucAZBI1Md0PNYjFE283fHF3ssAgEpT1w4nIiKLYLcLOQSpVKIxmLRdgA/mP9RJ+VzXInkG1s4jIiIzY/ggp8GWDyIi28DwQU6jZl+TZ6JaGlV+RBfTN8AjIiLDGD7I4Q3o4A9fD1cMrl4b5K2xXRDWxLO2gI4WkUaeXHiMiMgSOOCUHFaQnwcA4LvneqGiUlDuAeMilWDvfwZj0peH4Ooiga+n9v8btA/kkutERJbAlg9yOF8/2xMvD2yLsZEhAKpmwNTdfE4ikWD9tD74/vneyoGqLw5oo1bG18MN2+cMEKfSZBN0DUpOzchHRm6JyLUhclwMH+RwhnYKxBujwiE1sPKpRKI+Q2aBysyYGh2D5GavH9kubdnjRnYRRqzci76xf5t0rQpFpZlqReR4GD6IiKpVakkfZ9PzTb7Ovgt30XFRHNYlXjNHtYgcDsMHkYqN06Nqn9RpOIlo7ovz747CI/c3F7dSKu4La2S1ezsDbZ0u9dmK8JUfk6GoFPDmH6caWiUih8TwQaSiR8smysd1v3Q6BMrh7ipFaGNPNMT8UeF6z3/waKTOc71bN9F6PMjXo0F1oiraWj7qsxEyd08m0o/hg0iHRl7ap9qqfq3smjsQvVtpDwS6vDRQ/yZ297dopPNclxBfrcfXT+uDiObaz5HxuNotkTgYPojqWP5oJKb0bYmh1euCaFD5q7ZdgA9+ebm2q2bJuC71uqdqa4q+L8AWTbyw5V/90UFlGvDnT3dHG38f9GxpWgiqrxZNvES5jzVoe++l9WjFYMMHkX4MH0R1PN4zDEvGR2jOlqn+Ymrs5abztU28NXfNNcbW2Q8aVU4qkaBLiJ/a7rwjI4I1yr0W3aFe9TCuDha7tNVp63ap16APFfkl5Q27AJEDYvggMtFTvVtgRJdAvD+xq1mu9+KANvB2r13oTCIBXhrYRmvZmr+otX5HqnxJurpY7v/ajjyeob4DTkvKFdh+OgMFpRUa575IuNzgehE5Gq5wSmQiDzcXfDGlp9Zzpn4v/7/+rbHgoU6oVNn1rqm3DG5S7eGhpgvA0NgEb3cX0ypCAHQNODX8ob79v9P46XAaBnbwx9zhHZBTVNvaURNIFJUCyhWV8HDjZ0PElg8iC0qJidZ7vqYLQyqVYPPMB/DLS1Fo7K0+0HVURJDycXj1omeClr/RJSp/o4/tFlLfKhtkSr76/ZV+aOZjP3vkCAJQVKbeemHM7/vT4TQAQML5Oxj36X7111dfYNRHexG+KA7PrT2MdYnXEJ+aibhTGeaoNpHdYfggMpIxEyHqflHJPdwQO0F390xkaCO1x9qm0g7s4K98XNOdMqlP1c68vVo1Vp5Tfa3MVf9f13/MeEDt+TdTtbfk1BXR3Bevq0wVntqvld7y3Vs0hr/c8tOAWzTxwqQ+LUyeeVSXIAj4cMd5tWOKOq0hikoBJ9JyUFymwL3CMoPXXLv/Kk7dzMX52wUAgD2pd/DmH6cwdW0SXl6XjLsFpQ2qM5E9YrcLkRm4u0hRpqhE95aNNc491bsF/jp5C/svZimP7fz3ABxPy8GYSM3BonVpa6YfGxmM8CA5WjatnXkyoksg1kzpgU7Bvga7f+oOmh0SHqi1nJe7C4rKFMrXbJ7RH1KpBMcWDUcjLzfkFpfj2wNXleU3Tu+HiasPqF1D134p5nJs0XBla1FJuQLhi+Lqfa0rdwtxPC1H7dhza5OUj6vCSSo+i7+kPLbyifsMXvdfPx3TeS6nqBwebi747/ZUjIkMRs8GBigie8CWDyIj6fs+P7Z4OA4tGIpAHYt9Seq8un2gHI/1DNM5nmBkdVdL80aeGBkRhLb+3niqd1jt9SQSdAiUq7VwSCQSRHcJQlgTL6PGnrxUvZHezy/21VlGNTe8M652BlBjb3dIJBK1tVA6B/uiR8vGeLpvC8M3NyOZW+1/xjzcXBq0CNwjnx3Qe75SgFrwAIA5Px83eN3SCn37vAj4v53n8e2Bq3j084NG1LJhuOcM2QK2fBAZSd/f794yV3jLdP/faWREEPZdvIvmjYz7Yoxo7od/5g1GMx8ZPNxcsGvuQJNmmRizNsX8hzrhjVHheq+rOgDTx0P/fy5qSi4ZFwFfDze09ffRWx4AXKUSVFQ2rGWkbrCzJK1TcY3gomd+siAAFzML6lslkxxPy8HE1QfwanQHvDKonSj3JNKGLR9ERgryM27swuCOVWM0HupaO1B0Uu8W+P753vhrVn+j7xfWxAue1bNWTJ3eaih81HyHGrqu6ldtWGP9i4u5u0qV15w3MhwTe4QCAKYP0r2i66IxnfVes00zb7Xn2gbw1v0VGrr8vT4VivqFj/qGFnN7848UKCoFLI9LtXZVyMkxfBAZsPa5Xni0RyhmDjbuL8WPn7ofHz91Pz54tJvymFQqwYAO/hozWSzFXAuBqX75twvQ3pLx4WPd0KKJF/6rY0+acfc117kZXxMD70d0lyC1525GrF/y4eP3Ibqz9jEsxjifoXsX206L6zee5EZ2sc5zAowbzEzkSBg+iAwY3DEA/32sm95uFVVyDzc83C3E6PKWIJFI8O9htauctmnmjf8+1k3PK7R775EITOweio3T++ksM7FHKPbOG4z2gXKdZcK0tEY82iPUYCtF3SnF2hpq6h5r3sgTa55Rn70zpW9L5eM2/uqtKXXla1kozJI2HE7D3vN31I7dLSjFa7+ewNHr2Wa9l400wBBxzAeRo5o9rD0evi8EEgCtmnmjXFGJ1349AQDwkhm30FUzHxk+fNz00GKMCd2bi7Za6pLxEfgh8RoAzYHDjbzc1BYFE9s3+69oHFv85ylsTcnAb8k3cHXZaLPcZ9eZ2zh9K88s1yJqKLZ8EDmw1s280aq668TNRYqPnrwPyyZ0RYAIa2+oeqZfK/h5umFyn9qZMIJQNeC0xtN9W2Dm4HbYOL12o766g0kFAWqb6hmjbpdP3cCzZFyESdcTw+U7hWa/5gvfH9E4duhyFl764Qhu5ujuFqqRX1KOl344gi0n0xtUD0EQ1Fb0JefE8EHkRMbd1xxP9tY+FfbrZ3vC3VWq1j1jaLEyYzXzkeHoouF475HaBdcEoWp6bg13Fxe8NqIjeqjszlu328XdRYrfpvfD8onax5do0zFId3eQrapvi1BBaQV+SLyGzPwSg2XPZeThiTWJ2H76Nv5T3SKmz6d7LmH76duYsf5oveoGVAWPJ9ckYvQn+6BgAHFqDB9EBAAY2ikQZ98ZiUd7hGLhQ50wd3gHo2f4GKPudFN/uUxz52AtZg2pGui7cXoUpFIJfD3c8FjPUAwND8DYbiFGB6Ql4yPg5+mGFXW6kWxxn7ziOku8G7tQ26I/TmHRH6cw6ctDBsuOXPmP8rExLR9ZZliJtVwh4NCVezibnoerWeZv3SH7wTEfRKRUExCmDdC+q645fPd8b9zOLTG6ReLV6I6YPbS92k69EokEX0/tZdTra7LFlL4tMbl3C0ilErRs6oVrWUXV520vfVytrhsAlFYoMObjfQgP9sUnT92v93U7z9wGYPq6IXXfgdIKBR759ABkblL8+lIUXF2kRq0dY4hqS5btveskJrZ8EJGoBnbwx+O9wjSOq363PdEzDO4uUjwb1QoA1IKHqWrWHwGgbGnZNvvBel/P0g5dzlJ7vnLXBVzILMD/Ttwy+Nr6fqHX7eb5Zt9VnEnPw7HrOfgt+UZ1mdrzWQWl2HXmtsldJ6oNOGINNibbxPBBRDZB9avo/UcjcfqdEQgxckVYfVTDRw0v99pGX1v7DnxiTaLa89V1lnOvIQgCyvQu217rYqbutUsAzdBy+U5ty8mt3KrxI6phYdRH/+CF74/gh4NXjbq/NuZai4bsE8MHEdkkYxYUM0abZvpnx9jrl+DM9cfQ4c1t6Lw4Dnfyq8djqPwupRUK9Iv9G1/9cxnDVuzVe626ASzp6r3ac9X/q/o+ZVbfb0d1N48ht/NKMH1dMg5cuqtyXTt948ksOOaDiBzST9P64uKdAkS1bar1/GM9QnE8LQeDOgaIXLP6i912FsM6BaJXqybYklI15bWoTIHPEy5h0ZjOyC+pHaja8c2q1Vjf3XLW4HUv3SnEih2pkLm5VA8GrR1zUjPWoyEtRPN/T8Huc5nYdiqj/hchh8LwQUQOKaptU53BAwA+eKwbBEGwq7EHXyRcxhcJlzWO70nNxBGV1or6+Hj3Ra3Hb1dP212XeF3v65Ov3cMfx27hPyM7wtfDTe3cjewijfJ29LaTBTB8EJHTsqfgoY8lFiWrUW7kuJKJqw8qHy8Zb3jhNgd566meOOaDiGwCv4xs06/JN/Dc2sNGl79yVzMIaVumpG7wK6uoRHxqJgrr7K1TUq7Amr2XMGxFAs5laC4Pn1dSjqSr94xeC0UbYwfukvkwfBCRTXCUVghHtCf1juFCehgTCz7ckYqpa5Pw8rpkteMPr9qHpVvP4WJmAZ5ck6ixNPv4Vfvx2OcHsfHozXrV7dj1bHR4cxs+3JFq8msFQTBqNVnSxPBBRET1YswuwzpfW+f5j4eqxpT8c+Gu2vHzt2un/eYUlePfvxxXO3+5uqXFmHVQtKkZkPuJjjEv+sz77SR6v/c3tp/mQFpTMXwQkU2IaO5n7SqQiQShaj8ZbV0el+8U4IXvknDserbW19YNKcZ2m/x5vH4hQxfV++4ycupwjV+rF2BbueuCWevkDBg+iMiqdvx7AD54NBJjI4OtXRUy0fnb+Yh4azv+teG48lhN99nL65Kx62wmHvnsgNZg8UFcVTfHqZu5uJlTDNXeFENdGcnXslFSrjC4eJoxVGumbedfsgzOdiEiq+oQKEeHQPvbeZaAuwVlANS7PPZdqBofknavdrM6bW0avx+7idnD2mPMJ/s0zr39vzNYMi4Cjb3ctLyyKtgE+Xog5Wau3nuoKilX4NVfTmBgR3/0bNkYBy5l4YleYVoHw5qqIYNdnRXDBxERmU1NC4baLsY6vpt/TkrTenzLyXRsOZmOx3uGaj0vCFALHkBVuNhw+DoGdQzQuhvzhsPXsSUlXbk4W81rTN2fxlIy80sgCECgr/l2krZlDB9ERGRWq+MvoUBlyuxlLdNvAeAzHfvW1PjlyA2tx7UtiX/4yj0cvnIP/nIZkhYO0zifU1yucezI1WyNEFMfDW34qFBUovd7fwMAzi0ZCQ83lwbXydZxzAcREZnV+3HnLHp9fTNqlPvcGMFWpskWlSuUj3OKNEOSI2L4ICIys59f7IsZg9ua9JrJfVpYqDaOx1yb0kmNmBe8/+JdXMwsMFiOTMPwQURkZlKpBK9Fd0Rbf2+jXxMe7GvBGjkWc61HZyh8nMvIw+SvDmHYigS95VJv5+P9uHNIudHwLhxnwfBBRE7Pz7NqVsUkM7Y+SCQStGpqfPjg+q7GM/RezdlwzLjrGLjQ6Zu1y7lXKPQvwb46/hLGrtqHJX+dwQfb69/tJBi1Hqx2haUV+O7AVdzKKTZc2MoYPojI6e17fTD+fnUglj7SFVFtdO+EqyrIiFkJgzr6GyzzYPtmSJw/1Kh7UhVDS/H/Ub0QmaGZLNrGVygqBbz6ywnM/z0FCpWRpD8d1r+rb42v913Bp3suobRCYbiwiQpLK/CfX08gPjVT6/l3t5zFW5tPY/yn+81+b3Nj+CAipyf3cENbfx8AwLoX+hj1miGdAnSeq/nOmtSnpdbzU/rWHu8S4qd1aijpdtOIv+xv5RSj7YKtaPXGFvx6JA3X7xVplNHWytB2wVZsPHoDPx2+rrbJ3QWVcR+KSkHnyq3Ka2vJPcasB6JvPMvq+Ev4NfkGpq5N0no+oTqUZJow6NZaGD6IiFS4SCVIfnMYlk+MxOEF6i0Sb4wKBwD4y2VGX0ubsd1ClI+1fQFyj72G67dst/Lxf347id/rsfGcasvJ9wevIbe6pWT59nN45LMDJl3r631X0Ou9v3H5TgGWbTuHHw5eVZ7TlUnuFpSq1SE9V//snLqXKSqrwBcJl7TuNGxtDB9ERHU09ZHh8V5hCPD1QGhjTwDAB49GYtqDbfDVMz2xbfaDRo/R0LZKp8xV8z+9qoEjaeEwPPdAq3rUnExhqCHit2T1dUa+PXAVWQWl+CLhssFr/3WyajGzt/48hfm/n8SSv87gbkEpHv/iID5PuIRFf55WqYjqw6onydey0fPdXXju29pWDjcX/f/q6v4+y+NSEbvtHIZ8GG+wvmJj+CAi0mPLrAex4cW+mNg9FC5SCYZ1DkQzH/0tH64qXxK/Te+ncV41aIzsEgQAGNYpEAAQHiRHMx8ZfGSWWwOyWyg38QPUu1K0OZehvndMZn6JwZkvNRb9cQr7LtzFdwev4afDtSu55hVXqJX758Id7LtYu5Pv5uO3kFtUju+rW0b2nr9T+9qS2jEqT61JRGqG/r1tEi9nAWj4ImiWwBVOiYj08PNyQ18tg1C1dY28NKANrt8rwv1hjZTH2vr7QCKp/QKI7hyILiF+6BDoAwkkuL9FYwBVy2qfjImGlwirW7praXkhw9JzS5Bt5CJgxeUKPP31Ib1lCksrMOXrw2rHYredw99nM7WOA9qakqF8fPByFkas3Iulj3TFpD4tUFqhQEZebbdMakY+Km0xdVRj+CAiMoMm3u6Y/1AnrecS5w9F4uUshDTyRGSoH1ykEmyfM0Bj1oavh/aN1Mztv491w8AP4kW5lyPZfU77LBOTqHzkqgNaVR2+eg8Pq4wL0mfBphRM6tMCS/46o3Z8xMq99a6iGEyKv7GxsejVqxfkcjkCAgIwfvx4pKamqpURBAExMTEICQmBp6cnBg0ahNOnT+u4IhGRfRrQvnYa7edP90DcnAd1lg309cC4+5qjV6smkLlWtWwYmi5qyT9aW5qw/giZlxH77dXLukTjpgLbCpPCR0JCAmbMmIHExETs3LkTFRUViI6ORmFh7Uja5cuXY8WKFVi1ahWSkpIQFBSE4cOHIz9ff98UEZE9Gd45EN8/3xuHFgzFyIggBMjNO122IYtNke0qKde/WJk2n+65qPe8MYuKfRav/xpiMyl8xMXFYerUqejSpQu6deuGtWvX4vr160hOTgZQ1eqxcuVKLFy4EBMmTEBERAS+++47FBUVYf369Rb5BYiIrEEikWBAB3+LbYHuIuW4DGdWorLZ3AfbU1FWoTu0PPb5QYPXWx6XinMZeQbLiaVB/7pzc6vWsW/SpAkA4MqVK8jIyEB0dLSyjEwmw8CBA3HggGlzoomInNlz/VppPb5kXBe15z9N64vFYzobvJ6Hm3H/uV/wUDiOLRqOmLFV13SRSrB2ai+jXkum0bcC644zt9Wer0u8prOsMYuuAcDoj/cZVzER1Dt8CIKAuXPnon///oiIiAAAZGRUjcQNDAxUKxsYGKg8V1dpaSny8vLUfoiInF1jb3dcXTYal5c+BM/qGTB/zeqPKVGtlGWa+cgQ1bYpnu/fWu+11j7Xy+iF0aQSCRp7u+Ppvi2x8on7kPCfQcq1Tsi8VBdCM+SdOgNK60NRKaC0QqFzoKuY6h0+Zs6ciZMnT+Knn37SOFd3IJUgCDoHV8XGxsLPz0/5ExYWVt8qERE5HKlUgtNvj8DlpQ8honnV+hzzRnYEALw/savB1z/WIxSDOwbg86d7oF2AD9ZM6WHUfV1dpBh/f3OENvaqf+XJ5nR8Mw5d3tqOzHz9q6VaWr3Cx6xZs7B582bs2bMHoaGhyuNBQVWL5dRt5cjMzNRoDakxf/585ObmKn/S0tK0liMiclZSqQRSlWkSrwxqh7PvjMTQTtr/u6r22uo//LqE+GHX3IGIrl7UTJdOwb4NqyzZhVd/OWHV+5sUPgRBwMyZM/H7779j9+7daN1avamvdevWCAoKws6dO5XHysrKkJCQgH79NFf5A6rGhPj6+qr9EBGRfp7uuhcjW/f/ajfHk+rYX0ab/3uiGx5o16xB9SL7kFVQZtX7mxQ+ZsyYgXXr1mH9+vWQy+XIyMhARkYGiourBrtIJBLMmTMHS5cuxaZNm3Dq1ClMnToVXl5emDRpkkV+ASIiqtXMxx392zfDv4a2h79chtlD2xv92kfuDzVcyAI6Bsqtcl9ndibduuMrTVrhdPXq1QCAQYMGqR1fu3Ytpk6dCgCYN28eiouL8corryA7Oxt9+vTBjh07IJfzHxcRkaX897FuWPLXGXz+dNWYjrnDO+Dfw9obXMysRjeVJeHrqs8uuxHNfXHqpnFfcB56WnHIMZkUPgQjltyTSCSIiYlBTExMfetEREQmerRHKCZ2b64WNowNHssmdDU4FsRUk3q3RML5TGw/fVvr+Tb+3rh8p2qByk5BcpxIyzHr/cm2cW8XIiIHYWzYqOvJ3i3MXBP9rSWdgn2xbfaDuJFdhOzCcpy+lYsNSZxs4Ey4hB4REVmEBPrDUGhjL3QN9cPEHqHcadfJ8NMmIiK9dK31IZfpbzzX1frRMdBH7bmbixTLJtSuWbJ8YqSW13DcoCNh+CAiIr083FxwYnE0Tr09Qv2EgV6e9loCw+iuwYh5uIvGcbmHm/Lx471qF5vs26YJds0dgD9nPoCkhcNMqzjZLI75ICIig/y83DSO6cseEgCvDGqLgpIKfLP/ivL4Ww93RiMvd43yQ8IDMLF7KLqF+dW5jgTtAqpCjIdb7ayY8feF4I/jt0z7JchmsOWDiMgJvTSwDQDgqQYMNu0U7IsuIdoXhgzy84CHmwsWj+2ME2/Vbjaqa9Kki1SCDx/vhmdU9q4BdHfdSCQSPP+A/j1tzMHP0w3NG2nf2ybIQjsaOwOGDyIiJzRvRDj+N7O/xi65pvjoyfvRxt9H4/hr0R0wsIO/8rlMZTCpu4tpXzv6Zs0sHmt4N9+GOrpoOHq3bqL1XGNvzRYcMg7DBxGRE3KRStA11A+uJoaBGvNHhSPIzwOVdZoyGnm5YeYQ9cXNPNxcsPzRSCx9pKvJX9iGZszMHxVu0vVM5SKVYNqDbbSeq9/EZgIYPoiIqAHqLj7ZREe4eLxnGCb1Mb2LJ0Au03v+pYFtTb6mqXw9tQ+PrOeyKgSGDyIiqoeaL97KytpjPVs2xhfVy7s31JfP9MTQ8AAsGN1J7Xj/6o3vJtcjyNT44FHNqbyBvjJ0C/XTUlr34m0MH/XH2S5ERGSymu4Q1W6X36Zr3728PoZ3DsTwzoEax797vjeyCksRIK8d7Ll9zgCMWLlX63W+mNIDL/2QrHYsrInmuiWHFlRN4231xhblsdFdgwFo714J9JUZ7BKyZTIrL+rGlg8iIjKZsuXDiD2/zMlFKlELHgDQMUiOM++MwMH5QzTK17SUmCqqTVOseKIbAEBap4lj3H0h2PqvB83a8vFMVEvzXcwOMHwQEVG9zRsZDncXKWYObmfVeni5uyLYT3NKrLfMFf/MG4zE+UOVx3zqrMy6a+4Ajdd1b9kIMteqdUXqhowh4QFo6iMza7tHoK8HerfSPqvGEsSNjJoYPoiIyGSu0qqv3g6BVa0Or43oaOUa6RbWxAtBfh54Z1wXvDSgDSKa147tiAz1Uy5ipkq1S6VuyGhbM71YS9PHu+MjjKrT8w+0xsbpUbX3kOhuRRpp5h2HAVg9fXDMBxERGe3/9W+N+NRMPNqzdgn0+k7XFVvdBcyAqvBhiOr39PKJkcrw4ulW+3t/+UxPNG/kiQrVEbio2pMm9Xa+xjXrrlEigURn+AgPluOB9s2w6I9TAIB2AT64mFmgtezUfq3Q1t8bi/48bfD3sib7+BdDREQ2YdGYzvj71UEaXRe2aFinAJ3n4uY8iFlD2uGNUZ20nu+qEkpUM8EIlVaIpY90RZtm3lj+aCSGdw5E5xBf+HnWLkO/ZkoPfDLpfqPrW6mjNUICCR5UGbuya+5A5eOmdaY2xzzcBVOiWuEtERZgawjb/9dDRERkoujOgfhcz7Tf8CBfhAdpLg2/898DcOpWLqJVZtoIKm0fEpU/2dv4+2D3a4PUXt+yqTfeGtsZTbzdEV0dVH55KQqPf3FQb32legaQeMtc0KqZN/5+dSCa1NkXRyKpbV25L6yR8vhzD7SGl7sLXt+YgiXjI5StJraCLR9EROQwapZCnzG4HaT6vtF1aB8oxyP3h6qt7aHa8mHMFZ97oDXG3ddco076SCRA7ISuasfefrgLBnTwx9N9q2bCtPX3Ua4Q26aZNwAguksQvnu+N+YMa481U9TD1hO9WuDqstGY0tf2ZtKw5YOIiBzG+hf64F5RmcZ03IZQ7Q3RteBYQ3UIlKNTsHpLzLP9WuHZfq20lt/wUl/sOZeJsd1C4OXuijnDOlikXpbC8EFERA7D1UVq1uBhaX/N6o+z6XlqG/EZI0DugSd61X+VV8HK013Y7UJERGRh80Zqn4oc0dwPj/UMs1iLSo0X+rdWe646PsQa2PJBRESkh4fKUuSu9RhHAgCvDGqH5XGpBsuNuy8Efx6/hYe6mndtj/kPdcKYbiEoLVfAW+aqttaJNTB8EBER6dHUR4aFD3WCu6sUHm4uFr3XsgmRGBMZggfaNTXrdV2kEqu3dqhi+CAiIjJg2oA2otzH091F64Z6joZjPoiIiEhUDB9EREQiqOn2GNzRtJktjojdLkRERCL4+tme2JKSjnHdmhsu7OAYPoiIiETQ1EemdXM7Z8RuFyIiIhIVwwcRERGJiuGDiIiIRMXwQURERKJi+CAiIiJRMXwQERGRqBg+iIiISFQMH0RERCQqhg8iIiISFcMHERERiYrhg4iIiETF8EFERESiYvggIiIiUdncrraCIAAA8vLyrFwTIiIiMlbN93bN97g+Nhc+8vPzAQBhYWFWrgkRERGZKj8/H35+fnrLSARjIoqIKisrcevWLcjlckgkErNeOy8vD2FhYUhLS4Ovr69Zr02G8f23Lr7/1sX33/r4GViWIAjIz89HSEgIpFL9ozpsruVDKpUiNDTUovfw9fXlPzwr4vtvXXz/rYvvv/XxM7AcQy0eNTjglIiIiETF8EFERESicqrwIZPJ8NZbb0Emk1m7Kk6J77918f23Lr7/1sfPwHbY3IBTIiIicmxO1fJBRERE1sfwQURERKJi+CAiIiJRMXwQERGRqJwmfHz22Wdo3bo1PDw80KNHD/zzzz/WrpJd2rt3L8aOHYuQkBBIJBL88ccfaucFQUBMTAxCQkLg6emJQYMG4fTp02plSktLMWvWLDRr1gze3t54+OGHcePGDbUy2dnZmDJlCvz8/ODn54cpU6YgJyfHwr+d7YuNjUWvXr0gl8sREBCA8ePHIzU1Va0MPwPLWb16NSIjI5WLVEVFRWHbtm3K83zvxRMbGwuJRII5c+Yoj/H9tyOCE9iwYYPg5uYmfPnll8KZM2eE2bNnC97e3sK1a9esXTW7s3XrVmHhwoXCxo0bBQDCpk2b1M4vW7ZMkMvlwsaNG4WUlBThiSeeEIKDg4W8vDxlmZdffllo3ry5sHPnTuHo0aPC4MGDhW7dugkVFRXKMiNHjhQiIiKEAwcOCAcOHBAiIiKEMWPGiPVr2qwRI0YIa9euFU6dOiUcP35cGD16tNCiRQuhoKBAWYafgeVs3rxZ2LJli5CamiqkpqYKCxYsENzc3IRTp04JgsD3XiyHDx8WWrVqJURGRgqzZ89WHuf7bz+cInz07t1bePnll9WOhYeHC2+88YaVauQY6oaPyspKISgoSFi2bJnyWElJieDn5yd8/vnngiAIQk5OjuDm5iZs2LBBWebmzZuCVCoV4uLiBEEQhDNnzggAhMTERGWZgwcPCgCEc+fOWfi3si+ZmZkCACEhIUEQBH4G1tC4cWPhq6++4nsvkvz8fKF9+/bCzp07hYEDByrDB99/++Lw3S5lZWVITk5GdHS02vHo6GgcOHDASrVyTFeuXEFGRobaey2TyTBw4EDle52cnIzy8nK1MiEhIYiIiFCWOXjwIPz8/NCnTx9lmb59+8LPz4+fWR25ubkAgCZNmgDgZyAmhUKBDRs2oLCwEFFRUXzvRTJjxgyMHj0aw4YNUzvO99++2NzGcuZ29+5dKBQKBAYGqh0PDAxERkaGlWrlmGreT23v9bVr15Rl3N3d0bhxY40yNa/PyMhAQECAxvUDAgL4makQBAFz585F//79ERERAYCfgRhSUlIQFRWFkpIS+Pj4YNOmTejcubPyi4nvveVs2LABR48eRVJSksY5/tu3Lw4fPmpIJBK154IgaBwj86jPe123jLby/MzUzZw5EydPnsS+ffs0zvEzsJyOHTvi+PHjyMnJwcaNG/Hss88iISFBeZ7vvWWkpaVh9uzZ2LFjBzw8PHSW4/tvHxy+26VZs2ZwcXHRSKyZmZkaCZkaJigoCAD0vtdBQUEoKytDdna23jK3b9/WuP6dO3f4mVWbNWsWNm/ejD179iA0NFR5nJ+B5bm7u6Ndu3bo2bMnYmNj0a1bN3z00Ud87y0sOTkZmZmZ6NGjB1xdXeHq6oqEhAR8/PHHcHV1Vb43fP/tg8OHD3d3d/To0QM7d+5UO75z507069fPSrVyTK1bt0ZQUJDae11WVoaEhATle92jRw+4ubmplUlPT8epU6eUZaKiopCbm4vDhw8ryxw6dAi5ublO/5kJgoCZM2fi999/x+7du9G6dWu18/wMxCcIAkpLS/neW9jQoUORkpKC48ePK3969uyJyZMn4/jx42jTpg3ff3si/hhX8dVMtf3666+FM2fOCHPmzBG8vb2Fq1evWrtqdic/P184duyYcOzYMQGAsGLFCuHYsWPKacvLli0T/Pz8hN9//11ISUkRnnrqKa1T3UJDQ4Vdu3YJR48eFYYMGaJ1qltkZKRw8OBB4eDBg0LXrl051U0QhOnTpwt+fn5CfHy8kJ6ervwpKipSluFnYDnz588X9u7dK1y5ckU4efKksGDBAkEqlQo7duwQBIHvvdhUZ7sIAt9/e+IU4UMQBOHTTz8VWrZsKbi7uwvdu3dXTk0k0+zZs0cAoPHz7LPPCoJQNd3trbfeEoKCggSZTCYMGDBASElJUbtGcXGxMHPmTKFJkyaCp6enMGbMGOH69etqZbKysoTJkycLcrlckMvlwuTJk4Xs7GyRfkvbpe29ByCsXbtWWYafgeU8//zzyv+O+Pv7C0OHDlUGD0Hgey+2uuGD77/9kAiCIFinzYWIiIickcOP+SAiIiLbwvBBREREomL4ICIiIlExfBAREZGoGD6IiIhIVAwfREREJCqGDyIiIhIVwwcRERGJiuGDiIiIRMXwQURERKJi+CAiIiJRMXwQERGRqP4/G6N9d/7MlHwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1259fce8-3af3-43d3-bcb2-944c7ec94177", + "metadata": {}, + "outputs": [], + "source": [ + "wandb.finish()" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train.py b/src/Train.py new file mode 100644 index 0000000000000000000000000000000000000000..c55e4bfaaff73b08b42ceb448640742661415962 --- /dev/null +++ b/src/Train.py @@ -0,0 +1,761 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +# from subprocess import call +# command = "jupyter nbconvert Train.ipynb --to python" +# call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 128 #128 + + +# In[ ]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + +### Multi-GPU config ### +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + +# In[ ]: + + + + + +# # Configurations + +# In[3]: + + + +# In[4]: + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=240, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + +# In[5]: +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[6]: + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + +# ### check dataloaders are working + +# In[7]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + + +# ## Load voxel betas, K-means clustering model, and images + +# In[8]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# In[9]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + +clip_seq_dim = 257 +clip_emb_dim = 768 +hidden_dim = 4096 + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# In[10]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[11]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +print(b.shape, model.ridge(b).shape) + +# In[12]: +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + self.upsampler = Decoder( + in_channels=64, + out_channels=4, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[64, 128, 256], + layers_per_block=1, + ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + b = self.blin1(x) + b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + return c, b + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((2,hidden_dim)) +print(b.shape) +clip_, blur_ = model.backbone(b) +print(clip_.shape, blur_.shape) + + +# In[13]: + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + +# # Weights and Biases + +# In[14]: + + +# params for wandb +# params for wandb +wandb_log = True +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + + wandb_project = 'stability' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=model_name, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + +# # Main + +# In[15]: + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +resume_from_ckpt = False +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif False: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[16]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[17]: +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + voxel_ridge = model.ridge(voxel) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + loss_blurry_total += loss_blurry.item() + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + with torch.no_grad(): + # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=2, replace=False) + blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == batch_size + + blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + clip_target = clip_model.embed_image(image.float()) + + voxel_ridge = model.ridge(voxel) + + clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss = loss_blurry + loss_clip + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + axes[0].imshow(utils.torch_to_Image(image[[0]])) + axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + axes[2].imshow(utils.torch_to_Image(image[[1]])) + axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + plt.show() + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) \ No newline at end of file diff --git a/src/Train_MLPMixer-Copy1.ipynb b/src/Train_MLPMixer-Copy1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d3d83bf4f93c0d70f8cda7169d15d8296d5902d3 --- /dev/null +++ b/src/Train_MLPMixer-Copy1.ipynb @@ -0,0 +1,2266 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "#from subprocess import call\n", + "#command = \"jupyter nbconvert Train_MLPMixer-Copy1.ipynb --to python\"\n", + "#call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-11-03 11:37:15,856] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n", + "Setting batch_size to 128\n", + "[2023-11-03 11:37:18,062] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-11-03 11:37:18,062] [INFO] [comm.py:594:init_distributed] cdb=None\n", + "[2023-11-03 11:37:18,063] [INFO] [comm.py:625:init_distributed] Initializing TorchBackend in DeepSpeed with backend nccl\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "# ## UNCOMMENT BELOW SECTION AND COMMENT OUT DEEPSPEED SECTION TO AVOID USING DEEPSPEED ###\n", + "# accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "# global_batch_size = batch_size = 128\n", + "# data_type = torch.float16 # change depending on your mixed_precision\n", + "\n", + "### DEEPSPEED INITIALIZATION ###\n", + "if num_devices <= 1 and utils.is_interactive():\n", + " global_batch_size = batch_size = 128\n", + " print(f\"Setting batch_size to {batch_size}\")\n", + " # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + " os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + " os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + " os.environ[\"RANK\"] = \"0\"\n", + " os.environ[\"LOCAL_RANK\"] = \"0\"\n", + " os.environ[\"WORLD_SIZE\"] = \"1\"\n", + " os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "else:\n", + " global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"] \n", + " batch_size = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "\n", + "# alter the deepspeed config according to your global and local batch size\n", + "if local_rank == 0:\n", + " with open('deepspeed_config_stage2.json', 'r') as file:\n", + " config = json.load(file)\n", + " config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + " config['train_micro_batch_size_per_gpu'] = batch_size\n", + " config['bf16'] = {'enabled': False}\n", + " config['fp16'] = {'enabled': True}\n", + " with open('deepspeed_config_stage2.json', 'w') as file:\n", + " json.dump(config, file)\n", + "else:\n", + " # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + " time.sleep(10)\n", + "deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2_cpuoffload.json\")\n", + "accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 418110\n", + "device: cuda:0\n", + "Distributed environment: DEEPSPEED Backend: nccl\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda:0\n", + "\n", + "Mixed precision type: fp16\n", + "ds_config: {'bf16': {'enabled': False}, 'fp16': {'enabled': True}, 'zero_optimization': {'stage': 2, 'contiguous_gradients': True, 'stage3_gather_16bit_weights_on_model_save': True, 'stage3_max_live_parameters': 1000000000.0, 'stage3_max_reuse_distance': 1000000000.0, 'stage3_prefetch_bucket_size': 10000000.0, 'stage3_param_persistence_threshold': 100000.0, 'reduce_bucket_size': 10000000.0, 'sub_group_size': 1000000000.0, 'offload_optimizer': {'device': 'cpu', 'nvme_path': '/scratch', 'pin_memory': True}, 'offload_param': {'device': 'none', 'nvme_path': '/scratch', 'buffer_size': 4000000000.0, 'pin_memory': True}}, 'aio': {'block_size': 26214400, 'queue_depth': 32, 'thread_count': 1, 'single_submit': False, 'overlap_events': True}, 'gradient_accumulation_steps': 1, 'gradient_clipping': 1.0, 'steps_per_print': inf, 'train_batch_size': 256, 'train_micro_batch_size_per_gpu': 32, 'wall_clock_breakdown': False, 'zero_allow_untested_optimizer': True}\n", + "\n", + "distributed = True num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "\n", + "# set data_type to match your mixed precision (automatically set based on deepspeed config)\n", + "if accelerator.mixed_precision == \"bf16\":\n", + " data_type = torch.bfloat16\n", + "elif accelerator.mixed_precision == \"fp16\":\n", + " data_type = torch.float16\n", + "else:\n", + " data_type = torch.float32\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: CUIEjK9AY8_interactive\n", + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=CUIEjK9AY8_interactive', '--subj=1', '--batch_size=128', '--no-blurry_recon', '--no-depth_recon', '--hidden_dim=4096', '--clip_scale=1.', '--blur_scale=100.', '--depth_scale=100.', '--max_lr=3e-4', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug', '--no-ckpt_saving']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # create random model_name\n", + " model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10))\n", + " model_name = model_name + \"_interactive\"\n", + " print(\"model_name:\", model_name)\n", + "\n", + " # global_batch_size and batch_size should already be defined in the above cells\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name={model_name} \\\n", + " --subj=1 --batch_size={batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=4096 \\\n", + " --clip_scale=1. --blur_scale=100. --depth_scale=100. \\\n", + " --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output depth reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=100.,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_scale\",type=float,default=100.,\n", + " help=\"multiply loss from depth recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=120,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=4096,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "# train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..1}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 2770 2770\n", + "---\n", + "\n", + "194 24960 24960\n" + ] + } + ], + "source": [ + "test_vox_indices = []\n", + "test_73k_images = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy())\n", + " test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy())\n", + "test_vox_indices = test_vox_indices.astype(np.int16)\n", + "print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices))\n", + "print(\"---\\n\")\n", + "\n", + "train_vox_indices = []\n", + "train_73k_images = []\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy())\n", + " train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy())\n", + "train_vox_indices = train_vox_indices.astype(np.int16)\n", + "print(train_i, (train_i+1) * batch_size, len(train_vox_indices))" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15724])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r')\n", + "\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").to(data_type)\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").to(data_type)\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768 #1024\n", + "# hidden_dim = 4096\n", + "seq_len = 1 #2 #32 " + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# if blurry_recon:\n", + "# from diffusers import AutoencoderKL\n", + "# autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "# autoenc.eval()\n", + "# autoenc.requires_grad_(False)\n", + "# autoenc.to(device)\n", + "# utils.count_params(autoenc)\n", + "\n", + "if blurry_recon:# or depth_recon:\n", + " from diffusers import VQModel\n", + " autoenc = VQModel.from_pretrained(\"/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae\", torch_dtype=data_type)\n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "120c8eee-9834-437d-bb60-b38faef50138", + "metadata": {}, + "source": [ + "#### downsampled images" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6d1ba8dd-64c2-4ac9-947e-725b7f2e3e50", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30]].to(device)\n", + " print(input_batch.shape)\n", + "\n", + " downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " print(re_upsampled_enc.shape)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "6390a3a8-2bef-4e81-9b82-e154d26a1e1d", + "metadata": {}, + "source": [ + "#### MiDaS depth" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f35573e2-95bf-463d-8937-68ad4c2c3c20", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " from controlnet_aux.midas import MidasDetector\n", + " \n", + " midas_depth = MidasDetector.from_pretrained(\n", + " \"valhalla/t2iadapter-aux-models\", filename=\"dpt_large_384.pt\", model_type=\"dpt_large\", cache_dir=\"/fsx/proj-fmri/shared/cache\").to(device)\n", + " midas_depth.model.eval()\n", + " midas_depth.model.requires_grad_(False)\n", + " midas_depth.model.to(device)\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ba3f9207-b98e-45da-baa6-5cfcfb2ae958", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30,31]].float().to(device)\n", + " print(input_batch.shape)\n", + " \n", + " midas_emb = midas_depth.model(input_batch).unsqueeze(1)\n", + " print(midas_emb.shape)\n", + "\n", + " prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max()\n", + " print(prediction.shape)\n", + " \n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " midas_emb_size = prediction.flatten(1).shape[1]\n", + " print(\"midas_emb\", prediction.shape, prediction.min(), prediction.max())\n", + " print(\"midas_emb_size\", midas_emb_size)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) \n", + "\n", + " if blurry_recon:\n", + " prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1)\n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215\n", + " print(\"vae midas_emb\", prediction_enc.shape, prediction_enc.min(), prediction_enc.max())\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "66,506,752 total\n", + "66,506,752 trainable\n", + "param counts:\n", + "66,506,752 total\n", + "66,506,752 trainable\n", + "torch.Size([2, 1, 15724]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "time_embedding_dim = 512\n", + "\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "time_emb_test = torch.randn((2,1,time_embedding_dim))\n", + "print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "ee763515-4853-4c5b-9265-ec5aa1bde971", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "num_past_voxels = 15\n", + "seq_len = 1 + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "824,409,280 total\n", + "824,409,280 trainable\n", + "param counts:\n", + "890,923,712 total\n", + "890,923,712 trainable\n", + "b.shape torch.Size([256, 4, 1024])\n", + "torch.Size([256, 257, 768]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768):\n", + " super().__init__()\n", + " self.seq_len = seq_len\n", + " self.h = h\n", + " self.clip_size = clip_size\n", + " \n", + " # Initial linear layer to match the input dimensions to hidden dimensions\n", + " # self.lin0 = nn.Linear(in_dim, seq_len * h)\n", + " \n", + " # Mixer Blocks\n", + " self.mixer_blocks1 = nn.ModuleList([\n", + " self.mixer_block1(h, drop) for _ in range(n_blocks)\n", + " ])\n", + " self.mixer_blocks2 = nn.ModuleList([\n", + " self.mixer_block2(seq_len, drop) for _ in range(n_blocks)\n", + " ])\n", + " \n", + " # Output linear layer\n", + " self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True)\n", + "\n", + " # low-rank matrices\n", + " # self.rank = 500\n", + " # self.U = nn.Parameter(torch.randn(self.rank, out_dim))\n", + " # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank))\n", + " # self.S = nn.Parameter(torch.randn(out_dim))\n", + "\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + "\n", + " if blurry_recon:\n", + " # self.blin1 = nn.Sequential(\n", + " # nn.Linear(out_dim, 4096, bias=True),\n", + " # nn.LayerNorm(4096),\n", + " # nn.GELU(),\n", + " # nn.Linear(4096, 4096))\n", + " self.blin1 = nn.Linear(h*seq_len, 4096)\n", + " self.bgroupnorm = nn.GroupNorm(1, 256)\n", + " self.bupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128],\n", + " layers_per_block=1,\n", + " )\n", + "\n", + " if depth_recon:\n", + " # self.dlin1 = nn.Sequential(\n", + " # nn.Linear(h, midas_emb_size),\n", + " # nn.Sigmoid(),\n", + " # )\n", + " self.dlin1 = nn.Linear(h*seq_len, 4096)\n", + " self.dgroupnorm = nn.GroupNorm(1, 256)\n", + " self.dupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=1,#128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def mixer_block1(self, h, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(h),\n", + " self.mlp(h, h, drop), # Token mixing\n", + " )\n", + "\n", + " def mixer_block2(self, seq_len, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(seq_len),\n", + " self.mlp(seq_len, seq_len, drop) # Channel mixing\n", + " )\n", + " \n", + " def mlp(self, in_dim, out_dim, drop):\n", + " return nn.Sequential(\n", + " nn.Linear(in_dim, out_dim),\n", + " nn.GELU(),\n", + " nn.Dropout(drop),\n", + " nn.Linear(out_dim, out_dim),\n", + " )\n", + " \n", + " def forward(self, x):\n", + " # make empty tensors for blur and depth outputs\n", + " b,d = torch.Tensor([0.]), torch.Tensor([0.])\n", + " \n", + " # Initial linear layer\n", + " # x = self.lin0(x)\n", + " \n", + " # Reshape to seq_len by dim\n", + " # x = x.reshape(-1, self.seq_len, self.h)\n", + " \n", + " # Mixer blocks\n", + " residual1 = x\n", + " residual2 = x.permute(0,2,1)\n", + " for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2):\n", + " x = block1(x) + residual1\n", + " residual1 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " x = block2(x) + residual2\n", + " residual2 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " # Flatten\n", + " x = x.reshape(x.size(0), -1)\n", + " \n", + " c = self.clin1(x)\n", + "\n", + " # low rank linear to out dim cuts # params by nearly half compared to full linear mapping\n", + " # c = (x @ (self.V/100) @ (self.U/100)) + self.S\n", + " \n", + " c = self.clip_proj(c.reshape(len(c), -1, self.clip_size))\n", + "\n", + " if blurry_recon:\n", + " b = self.blin1(x)\n", + " b = b.reshape(len(b), 256, 4, 4)\n", + " b = self.bgroupnorm(b)\n", + " b = self.bupsampler(b)\n", + " \n", + " if depth_recon:\n", + " d = self.dlin1(x)#.reshape(len(x), 1, 32, 32)\n", + " d = d.reshape(len(d), 256, 4, 4)\n", + " d = self.dgroupnorm(d)\n", + " d = self.dupsampler(d)\n", + " \n", + " return c, b, d\n", + "\n", + "\n", + "class TimeEmbedding(nn.Module):\n", + " def __init__(self, embedding_time_dim=512, num_past_voxels=15):\n", + " super().__init__()\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + "\n", + " def forward(self, time):\n", + " # time is (batch_size,)\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " return time # (batch_size, embedding_time_dim)\n", + " \n", + "\n", + "#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15)\n", + "\n", + "model.backbone = BrainNetwork(h=1024, in_dim=1024, seq_len=4, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((256,4,1024))\n", + "print(\"b.shape\",b.shape)\n", + "with torch.no_grad():\n", + " clip_, blur_, depth_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape, depth_.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "fa7aa4ab-64af-45d4-8ed8-259043c16c29", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b.shape torch.Size([256, 2, 4096])\n", + "torch.Size([256, 257, 768]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "\n", + "voxel_ridge = torch.randn(512,4096)\n", + "voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim)\n", + "print(\"b.shape\",voxel_ridge.shape)\n", + "with torch.no_grad():\n", + " clip_, blur_, depth_ = model.backbone(voxel_ridge)\n", + "print(clip_.shape, blur_.shape, depth_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 2339\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,825,253,952 total\n", + "1,825,253,952 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size)))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "5d600d8d-6a0d-4584-840e-c89521ff6364", + "metadata": {}, + "outputs": [], + "source": [ + "seq_len = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "7f8eef14-4806-4d11-af12-a36e4acad4df", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "voxel_ridge = torch.randn(512,4096)\n", + "voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "c578b861-2eb8-4b1c-8b2a-61268b9e9bef", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 4, 4096])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "voxel_ridge.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "3c937d01-eea5-4bad-906a-36d07b3c30a4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([0., 1., 2., 3.])\n", + "torch.Size([128, 15, 17])\n", + "tensor([ 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n", + " 1., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., -1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,\n", + " 0., 0.], dtype=torch.float64)\n", + "torch.Size([128, 3, 15724])\n", + "tensor([ True, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, True, False, False, False, False, True, False,\n", + " False, False, False, False, True, True, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, True, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, True, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, True, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, True, False, False, False])\n", + "tensor([[[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.3796, 2.2207, 1.7715, ..., 3.0859, 1.5938, 0.6274],\n", + " [ 0.3513, 1.1621, 0.0634, ..., 0.7300, 0.2314, 0.1820]],\n", + "\n", + " [[ 0.6987, -1.0283, 0.8228, ..., -0.0037, -1.2510, -0.5884],\n", + " [-0.6133, 0.8877, 1.2207, ..., 0.7803, 1.0908, 0.8496],\n", + " [ 0.2534, -0.0533, 0.3386, ..., -0.4102, -0.5864, 0.3982]],\n", + "\n", + " [[ 0.2139, -0.6875, -0.3225, ..., 0.8423, -0.5718, -0.0623],\n", + " [-0.3418, -1.8799, -1.8477, ..., -1.2676, -2.4707, -1.8398],\n", + " [-0.3765, 1.1113, -1.2715, ..., 0.5498, 0.0262, -0.4839]],\n", + "\n", + " ...,\n", + "\n", + " [[-0.9604, 0.2109, -1.0596, ..., 0.2092, -0.7017, -0.7466],\n", + " [ 0.8960, -1.1387, -1.4111, ..., -0.3269, -0.2957, -0.5659],\n", + " [ 2.4707, 0.8105, 0.7910, ..., 0.6099, 1.0049, 0.3572]],\n", + "\n", + " [[ 0.8110, -0.8374, -0.8813, ..., 0.2411, 0.5176, 1.0039],\n", + " [-0.0218, -0.6675, 0.0044, ..., 0.2050, 0.2045, 0.7485],\n", + " [-0.3379, -1.2100, -0.0176, ..., -0.4167, -0.3860, -0.1342]],\n", + "\n", + " [[-0.2690, 0.8086, 0.2878, ..., 1.0840, 0.8159, -0.7021],\n", + " [ 0.3433, 0.2678, -0.9961, ..., -0.2805, -1.2490, -0.7988],\n", + " [ 0.0687, 0.5952, 0.0823, ..., -0.0443, 0.6401, -0.4092]]],\n", + " dtype=torch.float16)\n", + "torch.Size([128, 15, 17])\n", + "tensor([ 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0.,\n", + " 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., -1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0.], dtype=torch.float64)\n", + "torch.Size([128, 3, 15724])\n", + "tensor([False, False, False, False, True, False, False, False, False, False,\n", + " True, False, False, False, False, False, False, True, False, False,\n", + " True, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, True, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, True, False,\n", + " False, False, False, False, False, False, False, False, False, True,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, True, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False])\n", + "tensor([[[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.3796, 2.2207, 1.7715, ..., 3.0859, 1.5938, 0.6274],\n", + " [ 0.3513, 1.1621, 0.0634, ..., 0.7300, 0.2314, 0.1820]],\n", + "\n", + " [[ 0.6987, -1.0283, 0.8228, ..., -0.0037, -1.2510, -0.5884],\n", + " [-0.6133, 0.8877, 1.2207, ..., 0.7803, 1.0908, 0.8496],\n", + " [ 0.2534, -0.0533, 0.3386, ..., -0.4102, -0.5864, 0.3982]],\n", + "\n", + " [[ 0.2139, -0.6875, -0.3225, ..., 0.8423, -0.5718, -0.0623],\n", + " [-0.3418, -1.8799, -1.8477, ..., -1.2676, -2.4707, -1.8398],\n", + " [-0.3765, 1.1113, -1.2715, ..., 0.5498, 0.0262, -0.4839]],\n", + "\n", + " ...,\n", + "\n", + " [[-0.9604, 0.2109, -1.0596, ..., 0.2092, -0.7017, -0.7466],\n", + " [ 0.8960, -1.1387, -1.4111, ..., -0.3269, -0.2957, -0.5659],\n", + " [ 2.4707, 0.8105, 0.7910, ..., 0.6099, 1.0049, 0.3572]],\n", + "\n", + " [[ 0.8110, -0.8374, -0.8813, ..., 0.2411, 0.5176, 1.0039],\n", + " [-0.0218, -0.6675, 0.0044, ..., 0.2050, 0.2045, 0.7485],\n", + " [-0.3379, -1.2100, -0.0176, ..., -0.4167, -0.3860, -0.1342]],\n", + "\n", + " [[-0.2690, 0.8086, 0.2878, ..., 1.0840, 0.8159, -0.7021],\n", + " [ 0.3433, 0.2678, -0.9961, ..., -0.2805, -1.2490, -0.7988],\n", + " [ 0.0687, 0.5952, 0.0823, ..., -0.0443, 0.6401, -0.4092]]],\n", + " dtype=torch.float16)\n", + "torch.Size([128, 15, 17])\n", + "tensor([ 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., -1., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,\n", + " 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,\n", + " 1., 0., 0., 0., 1., 0., 1., 0., 0., 1., 1., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,\n", + " 0., -1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0.], dtype=torch.float64)\n", + "torch.Size([128, 3, 15724])\n", + "tensor([False, False, False, True, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, True, False, False, False, False, False, False, True,\n", + " False, False, False, False, False, False, True, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, True,\n", + " False, False, False, False, True, False, False, False, False, False,\n", + " True, False, False, False, True, False, True, False, False, True,\n", + " True, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, True, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False])\n", + "tensor([[[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.3796, 2.2207, 1.7715, ..., 3.0859, 1.5938, 0.6274],\n", + " [ 0.3513, 1.1621, 0.0634, ..., 0.7300, 0.2314, 0.1820]],\n", + "\n", + " [[ 0.6987, -1.0283, 0.8228, ..., -0.0037, -1.2510, -0.5884],\n", + " [-0.6133, 0.8877, 1.2207, ..., 0.7803, 1.0908, 0.8496],\n", + " [ 0.2534, -0.0533, 0.3386, ..., -0.4102, -0.5864, 0.3982]],\n", + "\n", + " [[ 0.2139, -0.6875, -0.3225, ..., 0.8423, -0.5718, -0.0623],\n", + " [-0.3418, -1.8799, -1.8477, ..., -1.2676, -2.4707, -1.8398],\n", + " [-0.3765, 1.1113, -1.2715, ..., 0.5498, 0.0262, -0.4839]],\n", + "\n", + " ...,\n", + "\n", + " [[-0.9604, 0.2109, -1.0596, ..., 0.2092, -0.7017, -0.7466],\n", + " [ 0.8960, -1.1387, -1.4111, ..., -0.3269, -0.2957, -0.5659],\n", + " [ 2.4707, 0.8105, 0.7910, ..., 0.6099, 1.0049, 0.3572]],\n", + "\n", + " [[ 0.8110, -0.8374, -0.8813, ..., 0.2411, 0.5176, 1.0039],\n", + " [-0.0218, -0.6675, 0.0044, ..., 0.2050, 0.2045, 0.7485],\n", + " [-0.3379, -1.2100, -0.0176, ..., -0.4167, -0.3860, -0.1342]],\n", + "\n", + " [[-0.2690, 0.8086, 0.2878, ..., 1.0840, 0.8159, -0.7021],\n", + " [ 0.3433, 0.2678, -0.9961, ..., -0.2805, -1.2490, -0.7988],\n", + " [ 0.0687, 0.5952, 0.0823, ..., -0.0443, 0.6401, -0.4092]]],\n", + " dtype=torch.float16)\n" + ] + } + ], + "source": [ + "pp = None\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " #optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()]#.to(device)\n", + " image = images[behav[:,0,0].cpu().long()].float()#.to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()]#.to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(seq_len)])#.to(device) # 15\n", + " \n", + " print(past_15_times)\n", + " #for past in range(1):\n", + " # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\n", + " \"\"\"\n", + " #if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + "\n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + "\n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + " past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\n", + " \"\"\"\n", + " for p in range(seq_len-1):\n", + " print(past_behav.shape) #128, 15, 17\n", + " print(past_behav[:,p,-1])\n", + " print(past_15_voxels.shape) # 128, 1, 15724\n", + " mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1])\n", + " print(mask) # 128\n", + " past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :])\n", + " print(past_15_voxels)\n", + " pp = past_15_voxels\n", + " \n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "5c7eb009-9fcf-4e35-9e1b-c0ca6418b6b8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0., 0., 0., ..., 0., 0., 0.], dtype=torch.float16)" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pp[20, 0, :]" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [], + "source": [ + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'mindeyev2'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"clip_scale\": clip_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " \"train_url\": train_url,\n", + " \"test_url\": test_url,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if True: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using /admin/home-ckadirt/.cache/torch_extensions/py310_cu117 as PyTorch extensions root...\n", + "Emitting ninja build file /admin/home-ckadirt/.cache/torch_extensions/py310_cu117/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ninja: no work to do.\n", + "Time to load cpu_adam op: 3.0333330631256104 seconds\n", + "[2023-11-03 13:59:08,078] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed info: version=0.9.5, git-hash=unknown, git-branch=unknown\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading extension module cpu_adam...\n" + ] + }, + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:1                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ ❱ 1 model, optimizer, train_dl, lr_scheduler = accelerator.prepare(                              │\n",
+       "│   2 model, optimizer, train_dl, lr_scheduler                                                     │\n",
+       "│   3 )                                                                                            │\n",
+       "│   4 # leaving out test_dl since we will only have local_rank 0 device do evals                   │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/accelerator. │\n",
+       "│ py:1178 in prepare                                                                               │\n",
+       "│                                                                                                  │\n",
+       "│   1175 │   │   │   elif self.device.type == \"xpu\" and is_xpu_available():                        │\n",
+       "│   1176 │   │   │   │   args = self._prepare_ipex(*args)                                          │\n",
+       "│   1177 │   │   if self.distributed_type == DistributedType.DEEPSPEED:                            │\n",
+       "│ ❱ 1178 │   │   │   result = self._prepare_deepspeed(*args)                                       │\n",
+       "│   1179 │   │   elif self.distributed_type == DistributedType.MEGATRON_LM:                        │\n",
+       "│   1180 │   │   │   result = self._prepare_megatron_lm(*args)                                     │\n",
+       "│   1181 │   │   else:                                                                             │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/accelerator. │\n",
+       "│ py:1505 in _prepare_deepspeed                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│   1502 │   │   │   │   │   │   if type(scheduler).__name__ in deepspeed.runtime.lr_schedules.VA  │\n",
+       "│   1503 │   │   │   │   │   │   │   kwargs[\"lr_scheduler\"] = scheduler                            │\n",
+       "│   1504 │   │   │                                                                                 │\n",
+       "│ ❱ 1505 │   │   │   engine, optimizer, _, lr_scheduler = deepspeed.initialize(**kwargs)           │\n",
+       "│   1506 │   │   │   if optimizer is not None:                                                     │\n",
+       "│   1507 │   │   │   │   optimizer = DeepSpeedOptimizerWrapper(optimizer)                          │\n",
+       "│   1508 │   │   │   if scheduler is not None:                                                     │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/__init__.py:1 │\n",
+       "│ 51 in initialize                                                                                 │\n",
+       "│                                                                                                  │\n",
+       "│   148 │   assert config != None, \"DeepSpeed requires --deepspeed_config to specify configurati   │\n",
+       "│   149 │                                                                                          │\n",
+       "│   150 │   if not isinstance(model, PipelineModule):                                              │\n",
+       "│ ❱ 151 │   │   config_class = DeepSpeedConfig(config, mpu)                                        │\n",
+       "│   152 │   │   if config_class.hybrid_engine.enabled:                                             │\n",
+       "│   153 │   │   │   engine = DeepSpeedHybridEngine(args=args,                                      │\n",
+       "│   154 │   │   │   │   │   │   │   │   │   │      model=model,                                    │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/confi │\n",
+       "│ g.py:769 in __init__                                                                             │\n",
+       "│                                                                                                  │\n",
+       "│    766 │   │                                                                                     │\n",
+       "│    767 │   │   # Pass a copy so that user json is unmodified, e.g. for logging                   │\n",
+       "│    768 │   │   self._initialize_params(copy.copy(self._param_dict))                              │\n",
+       "│ ❱  769 │   │   self._configure_train_batch_size()                                                │\n",
+       "│    770 │   │   self._do_sanity_check()                                                           │\n",
+       "│    771 │                                                                                         │\n",
+       "│    772 │   def _initialize_params(self, param_dict):                                             │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/confi │\n",
+       "│ g.py:942 in _configure_train_batch_size                                                          │\n",
+       "│                                                                                                  │\n",
+       "│    939 │                                                                                         │\n",
+       "│    940 │   def _configure_train_batch_size(self):                                                │\n",
+       "│    941 │   │   self._set_batch_related_parameters()                                              │\n",
+       "│ ❱  942 │   │   self._batch_assertion()                                                           │\n",
+       "│    943 │                                                                                         │\n",
+       "│    944 │   def _do_sanity_check(self):                                                           │\n",
+       "│    945 │   │   self._do_error_check()                                                            │\n",
+       "│                                                                                                  │\n",
+       "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/confi │\n",
+       "│ g.py:890 in _batch_assertion                                                                     │\n",
+       "│                                                                                                  │\n",
+       "│    887 │   │                                                                                     │\n",
+       "│    888 │   │   assert (grad_acc > 0), f\"Gradient accumulation steps: {grad_acc} has to be great  │\n",
+       "│    889 │   │                                                                                     │\n",
+       "│ ❱  890 │   │   assert train_batch == micro_batch * grad_acc * self.world_size, (                 │\n",
+       "│    891 │   │   │   f\"Check batch related parameters. train_batch_size is not equal \"             │\n",
+       "│    892 │   │   │   \"to micro_batch_per_gpu * gradient_acc_step * world_size \"                    │\n",
+       "│    893 │   │   │   f\"{train_batch} != {micro_batch} * {grad_acc} * {self.world_size}\")           │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "AssertionError: Check batch related parameters. train_batch_size is not equal to micro_batch_per_gpu * \n",
+       "gradient_acc_step * world_size 256 != 32 * 1 * 1\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1 model, optimizer, train_dl, lr_scheduler = accelerator.prepare( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0mmodel, optimizer, train_dl, lr_scheduler \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m3 \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m4 \u001b[0m\u001b[2m# leaving out test_dl since we will only have local_rank 0 device do evals\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/\u001b[0m\u001b[1;33maccelerator.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mpy\u001b[0m:\u001b[94m1178\u001b[0m in \u001b[92mprepare\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1175 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melif\u001b[0m \u001b[96mself\u001b[0m.device.type == \u001b[33m\"\u001b[0m\u001b[33mxpu\u001b[0m\u001b[33m\"\u001b[0m \u001b[95mand\u001b[0m is_xpu_available(): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1176 \u001b[0m\u001b[2m│ │ │ │ \u001b[0margs = \u001b[96mself\u001b[0m._prepare_ipex(*args) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1177 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.distributed_type == DistributedType.DEEPSPEED: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1178 \u001b[2m│ │ │ \u001b[0mresult = \u001b[96mself\u001b[0m._prepare_deepspeed(*args) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1179 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melif\u001b[0m \u001b[96mself\u001b[0m.distributed_type == DistributedType.MEGATRON_LM: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1180 \u001b[0m\u001b[2m│ │ │ \u001b[0mresult = \u001b[96mself\u001b[0m._prepare_megatron_lm(*args) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1181 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/\u001b[0m\u001b[1;33maccelerator.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mpy\u001b[0m:\u001b[94m1505\u001b[0m in \u001b[92m_prepare_deepspeed\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1502 \u001b[0m\u001b[2m│ │ │ │ │ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mtype\u001b[0m(scheduler).\u001b[91m__name__\u001b[0m \u001b[95min\u001b[0m deepspeed.runtime.lr_schedules.VA \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1503 \u001b[0m\u001b[2m│ │ │ │ │ │ │ \u001b[0mkwargs[\u001b[33m\"\u001b[0m\u001b[33mlr_scheduler\u001b[0m\u001b[33m\"\u001b[0m] = scheduler \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1504 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1505 \u001b[2m│ │ │ \u001b[0mengine, optimizer, _, lr_scheduler = deepspeed.initialize(**kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1506 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m optimizer \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1507 \u001b[0m\u001b[2m│ │ │ │ \u001b[0moptimizer = DeepSpeedOptimizerWrapper(optimizer) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1508 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m scheduler \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/\u001b[0m\u001b[1;33m__init__.py\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m51\u001b[0m in \u001b[92minitialize\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m148 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94massert\u001b[0m config != \u001b[94mNone\u001b[0m, \u001b[33m\"\u001b[0m\u001b[33mDeepSpeed requires --deepspeed_config to specify configurati\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m149 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m150 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m \u001b[96misinstance\u001b[0m(model, PipelineModule): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m151 \u001b[2m│ │ \u001b[0mconfig_class = DeepSpeedConfig(config, mpu) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m152 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m config_class.hybrid_engine.enabled: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m153 \u001b[0m\u001b[2m│ │ │ \u001b[0mengine = DeepSpeedHybridEngine(args=args, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m154 \u001b[0m\u001b[2m│ │ │ │ │ │ │ │ │ │ \u001b[0mmodel=model, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/\u001b[0m\u001b[1;33mconfi\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mg.py\u001b[0m:\u001b[94m769\u001b[0m in \u001b[92m__init__\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 766 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 767 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Pass a copy so that user json is unmodified, e.g. for logging\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 768 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._initialize_params(copy.copy(\u001b[96mself\u001b[0m._param_dict)) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 769 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._configure_train_batch_size() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 770 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._do_sanity_check() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 771 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 772 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_initialize_params\u001b[0m(\u001b[96mself\u001b[0m, param_dict): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/\u001b[0m\u001b[1;33mconfi\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mg.py\u001b[0m:\u001b[94m942\u001b[0m in \u001b[92m_configure_train_batch_size\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 939 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 940 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_configure_train_batch_size\u001b[0m(\u001b[96mself\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 941 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._set_batch_related_parameters() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 942 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._batch_assertion() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 943 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 944 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_do_sanity_check\u001b[0m(\u001b[96mself\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 945 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m._do_error_check() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/\u001b[0m\u001b[1;33mconfi\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mg.py\u001b[0m:\u001b[94m890\u001b[0m in \u001b[92m_batch_assertion\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 887 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 888 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94massert\u001b[0m (grad_acc > \u001b[94m0\u001b[0m), \u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mGradient accumulation steps: \u001b[0m\u001b[33m{\u001b[0mgrad_acc\u001b[33m}\u001b[0m\u001b[33m has to be great\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 889 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 890 \u001b[2m│ │ \u001b[0m\u001b[94massert\u001b[0m train_batch == micro_batch * grad_acc * \u001b[96mself\u001b[0m.world_size, ( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 891 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mCheck batch related parameters. train_batch_size is not equal \u001b[0m\u001b[33m\"\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 892 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mto micro_batch_per_gpu * gradient_acc_step * world_size \u001b[0m\u001b[33m\"\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 893 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33m{\u001b[0mtrain_batch\u001b[33m}\u001b[0m\u001b[33m != \u001b[0m\u001b[33m{\u001b[0mmicro_batch\u001b[33m}\u001b[0m\u001b[33m * \u001b[0m\u001b[33m{\u001b[0mgrad_acc\u001b[33m}\u001b[0m\u001b[33m * \u001b[0m\u001b[33m{\u001b[0m\u001b[96mself\u001b[0m.world_size\u001b[33m}\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mAssertionError: \u001b[0mCheck batch related parameters. train_batch_size is not equal to micro_batch_per_gpu * \n", + "gradient_acc_step * world_size \u001b[1;36m256\u001b[0m != \u001b[1;36m32\u001b[0m * \u001b[1;36m1\u001b[0m * \u001b[1;36m1\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model, optimizer, train_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, lr_scheduler\n", + ")\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "469e6313-425f-45ed-875a-ecd5df343e31", + "metadata": {}, + "outputs": [], + "source": [ + "def add_saturation(image, alpha=2):\n", + " gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :]\n", + " gray_image = gray_image.unsqueeze(1).expand_as(image)\n", + " saturated_image = alpha * image + (1 - alpha) * gray_image\n", + " return torch.clamp(saturated_image, 0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:1                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ ❱   1 print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")                          │\n",
+       "│     2 progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))          │\n",
+       "│     3 test_image, test_voxel = None, None                                                        │\n",
+       "│     4 mse = nn.MSELoss()                                                                         │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "NameError: name 'epoch' is not defined\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 1 \u001b[96mprint\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33m{\u001b[0mmodel_name\u001b[33m}\u001b[0m\u001b[33m starting with epoch \u001b[0m\u001b[33m{\u001b[0mepoch\u001b[33m}\u001b[0m\u001b[33m / \u001b[0m\u001b[33m{\u001b[0mnum_epochs\u001b[33m}\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 2 \u001b[0mprogress_bar = tqdm(\u001b[96mrange\u001b[0m(epoch,num_epochs), ncols=\u001b[94m1200\u001b[0m, disable=(local_rank!=\u001b[94m0\u001b[0m)) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 3 \u001b[0mtest_image, test_voxel = \u001b[94mNone\u001b[0m, \u001b[94mNone\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 4 \u001b[0mmse = nn.MSELoss() \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mNameError: \u001b[0mname \u001b[32m'epoch'\u001b[0m is not defined\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_depth_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + " test_loss_depth_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " optimizer.zero_grad()\n", + " \n", + " #voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " #image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + " \n", + " #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15\n", + " \n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15\n", + " #for past in range(1):\n", + " # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\n", + " \n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + " past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\n", + " \n", + " for p in range(seq_len-1):\n", + " #print(past_behav.shape) #128, 15, 17\n", + " #print(past_behav[:,p,-1])\n", + " #print(past_15_voxels.shape) # 128, 1, 15724\n", + " mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1])\n", + " #print(mask) # 128\n", + " past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :])\n", + " #print(past_15_voxels)\n", + " \n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + " \n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " voxel = torch.cat((voxel, positional_current_voxel), dim=-1)\n", + " voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2))\n", + " voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim)\n", + " #unsqueeze(1) # bz * 2, 1, 4096\n", + " \n", + " # past_voxel_ridge = model.ridge(past_voxel)\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1)\n", + " print(voxel_ridge.shape)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " loss = loss_clip\n", + " \n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item()\n", + " \n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False)\n", + " # random_samps = np.arange(batch_size//5)\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean\n", + " pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images)\n", + " # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " # loss += (1 - pixcorr)\n", + " blurry_pixcorr += pixcorr.item()\n", + " # utils.check_loss(pixcorr)\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " assert len(behav) == num_test\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()]\n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # random sample of 300\n", + " random_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == 300\n", + " \n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15\n", + "\n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " voxel = torch.cat((voxel, positional_current_voxel), dim=-1)\n", + " voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)).unsqueeze(1)\n", + " \n", + " #voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + "\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss = loss_clip\n", + "\n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " test_loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + " \n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " pixcorr = utils.pixcorr(image, blurry_recon_images)\n", + " loss += (1 - pixcorr)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " test_loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " print(\"---\")\n", + " \n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/loss_depth_total\": loss_depth_total / (train_i + 1),\n", + " \"test/loss_depth_total\": test_loss_depth_total / (test_i + 1),\n", + " }\n", + " \n", + " if blurry_recon: \n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " \n", + " if wandb_log:\n", + " logs[f\"test/recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " if depth_recon:\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " if wandb_log:\n", + " logs[f\"test/depth_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + " \n", + " progress_bar.set_postfix(**logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f2690877-a431-44e8-a2ca-61f4b7397070", + "metadata": {}, + "source": [ + "# Retrieve nearest neighbor in the training set using test set data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b6b8feb-391d-437e-a5d9-a2088f1b1149", + "metadata": {}, + "outputs": [], + "source": [ + "annots = np.load(\"/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "612ac5aa-6f0f-45ad-809e-03df905d184c", + "metadata": {}, + "outputs": [], + "source": [ + "ii=2\n", + "all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices))\n", + "with torch.no_grad(), torch.cuda.amp.autocast():\n", + " for batch in tqdm(range(0,len(all_indices),512)):\n", + " if batch==0:\n", + " clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " else:\n", + " target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " clip_target = torch.vstack((clip_target,target))\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " voxel = test_voxel[[ii]].to(device)\n", + " image = test_image[[ii]].to(device)\n", + "\n", + " print(\"Original Image (test set)\")\n", + " display(utils.torch_to_Image(image))\n", + " \n", + " clip_target = clip_model.embed_image(image).cpu()\n", + " # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1)))\n", + " \n", + " voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + " clip_voxels, _, _ = model.backbone(voxel_ridge) \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " print(\"clip_voxels_norm\", clip_voxels_norm.shape)\n", + " print(\"clip_target_norm\", clip_target_norm.shape)\n", + " \n", + " sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), \n", + " clip_target_norm).flatten()).flip(0)\n", + " picks = all_indices[sortt[:5]]\n", + "\n", + " print(\"\\nNearest neighbors in training set\")\n", + " for ip,p in enumerate(picks):\n", + " display(utils.torch_to_Image(images[[p]]))\n", + " # print(utils.select_annotations([annots[int(p)]]))\n", + " if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0]\n", + "\n", + "print(\"\\n=====\\npredicted_caption:\\n\", predicted_caption)" + ] + }, + { + "cell_type": "markdown", + "id": "1473ddaa-5f2b-4448-9194-c7b0801d05db", + "metadata": {}, + "source": [ + "# Feed into Stable Diffusion XL for reconstructions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70e50e0d-c44f-4d56-939a-2943535e1747", + "metadata": {}, + "outputs": [], + "source": [ + "from diffusers import StableDiffusionXLPipeline\n", + "pipe = StableDiffusionXLPipeline.from_pretrained(\n", + " \"/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f\", torch_dtype=torch.float16, variant=\"fp16\", use_safetensors=True\n", + ")\n", + "pipe.to(\"cuda\")\n", + "pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "479e6994-3eaa-47d2-89a3-422c464fab36", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = predicted_caption\n", + "recon = pipe(prompt=prompt).images[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dc48e1b-5842-4a29-963a-6469d943a72c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "print(\"Seen image\")\n", + "display(utils.torch_to_Image(image))\n", + "\n", + "print(\"Reconstruction\")\n", + "utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224))" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train_MLPMixer-Copy1.py b/src/Train_MLPMixer-Copy1.py new file mode 100644 index 0000000000000000000000000000000000000000..dec90a10385f0a2f5e98bb6f614a4a087f87fdde --- /dev/null +++ b/src/Train_MLPMixer-Copy1.py @@ -0,0 +1,1352 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train_MLPMixer-Copy1.ipynb --to python" +#call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# ## UNCOMMENT BELOW SECTION AND COMMENT OUT DEEPSPEED SECTION TO AVOID USING DEEPSPEED ### +# accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +# global_batch_size = batch_size = 128 +# data_type = torch.float16 # change depending on your mixed_precision + +### DEEPSPEED INITIALIZATION ### +if num_devices <= 1 and utils.is_interactive(): + global_batch_size = batch_size = 128 + print(f"Setting batch_size to {batch_size}") + # can emulate a distributed environment for deepspeed to work in jupyter notebook + os.environ["MASTER_ADDR"] = "localhost" + os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) + os.environ["RANK"] = "0" + os.environ["LOCAL_RANK"] = "0" + os.environ["WORLD_SIZE"] = "1" + os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + +# alter the deepspeed config according to your global and local batch size +if local_rank == 0: + with open('deepspeed_config_stage2.json', 'r') as file: + config = json.load(file) + config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) + config['train_micro_batch_size_per_gpu'] = batch_size + config['bf16'] = {'enabled': False} + config['fp16'] = {'enabled': True} + with open('deepspeed_config_stage2.json', 'w') as file: + json.dump(config, file) +else: + # give some time for the local_rank=0 gpu to prep new deepspeed config file + time.sleep(10) +deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2_cpuoffload.json") +accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' + +# set data_type to match your mixed precision (automatically set based on deepspeed config) +if accelerator.mixed_precision == "bf16": + data_type = torch.bfloat16 +elif accelerator.mixed_precision == "fp16": + data_type = torch.float16 +else: + data_type = torch.float32 + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[5]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # create random model_name + model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + model_name = model_name + "_interactive" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the above cells + # other variables can be specified in the following string: + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name={model_name} \ + --subj=1 --batch_size={batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=4096 \ + --clip_scale=1. --blur_scale=100. --depth_scale=100. \ + --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[6]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--depth_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output depth reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=100., + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--depth_scale",type=float,default=100., + help="multiply loss from depth recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=120, + help="number of epochs of training", +) +parser.add_argument( + "--hidden_dim",type=int,default=4096, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + + +# In[7]: + + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[8]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +# train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..1}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True) + + +# ### check dataloaders are working + +# In[9]: + + +test_vox_indices = [] +test_73k_images = [] +for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy()) + test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy()) +test_vox_indices = test_vox_indices.astype(np.int16) +print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices)) +print("---\n") + +train_vox_indices = [] +train_73k_images = [] +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy()) + train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy()) +train_vox_indices = train_vox_indices.astype(np.int16) +print(train_i, (train_i+1) * batch_size, len(train_vox_indices)) + + +# ## Load data and images + +# In[10]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r') + +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").to(data_type) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").to(data_type) +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[11]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) +clip_seq_dim = 257 +clip_emb_dim = 768 #1024 +# hidden_dim = 4096 +seq_len = 1 #2 #32 + + +# ### SD VAE + +# In[12]: + + +# if blurry_recon: +# from diffusers import AutoencoderKL +# autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +# autoenc.eval() +# autoenc.requires_grad_(False) +# autoenc.to(device) +# utils.count_params(autoenc) + +if blurry_recon:# or depth_recon: + from diffusers import VQModel + autoenc = VQModel.from_pretrained("/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae", torch_dtype=data_type) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + +# #### downsampled images + +# In[13]: + + +if blurry_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30]].to(device) + print(input_batch.shape) + + downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest') + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + print(re_upsampled_enc.shape) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# #### MiDaS depth + +# In[14]: + + +if depth_recon: + from controlnet_aux.midas import MidasDetector + + midas_depth = MidasDetector.from_pretrained( + "valhalla/t2iadapter-aux-models", filename="dpt_large_384.pt", model_type="dpt_large", cache_dir="/fsx/proj-fmri/shared/cache").to(device) + midas_depth.model.eval() + midas_depth.model.requires_grad_(False) + midas_depth.model.to(device) + pass + + +# In[15]: + + +if depth_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30,31]].float().to(device) + print(input_batch.shape) + + midas_emb = midas_depth.model(input_batch).unsqueeze(1) + print(midas_emb.shape) + + prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max() + print(prediction.shape) + + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + midas_emb_size = prediction.flatten(1).shape[1] + print("midas_emb", prediction.shape, prediction.min(), prediction.max()) + print("midas_emb_size", midas_emb_size) + + if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) + + if blurry_recon: + prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1) + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215 + print("vae midas_emb", prediction_enc.shape, prediction_enc.min(), prediction_enc.max()) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# ### MindEye modules + +# In[16]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[17]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[59]: + + +num_past_voxels = 15 +seq_len = 1 + 1 + + +# In[73]: + + +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768): + super().__init__() + self.seq_len = seq_len + self.h = h + self.clip_size = clip_size + + # Initial linear layer to match the input dimensions to hidden dimensions + # self.lin0 = nn.Linear(in_dim, seq_len * h) + + # Mixer Blocks + self.mixer_blocks1 = nn.ModuleList([ + self.mixer_block1(h, drop) for _ in range(n_blocks) + ]) + self.mixer_blocks2 = nn.ModuleList([ + self.mixer_block2(seq_len, drop) for _ in range(n_blocks) + ]) + + # Output linear layer + self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True) + + # low-rank matrices + # self.rank = 500 + # self.U = nn.Parameter(torch.randn(self.rank, out_dim)) + # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank)) + # self.S = nn.Parameter(torch.randn(out_dim)) + + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + + if blurry_recon: + # self.blin1 = nn.Sequential( + # nn.Linear(out_dim, 4096, bias=True), + # nn.LayerNorm(4096), + # nn.GELU(), + # nn.Linear(4096, 4096)) + self.blin1 = nn.Linear(h*seq_len, 4096) + self.bgroupnorm = nn.GroupNorm(1, 256) + self.bupsampler = Decoder( + in_channels=256, + out_channels=128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128], + layers_per_block=1, + ) + + if depth_recon: + # self.dlin1 = nn.Sequential( + # nn.Linear(h, midas_emb_size), + # nn.Sigmoid(), + # ) + self.dlin1 = nn.Linear(h*seq_len, 4096) + self.dgroupnorm = nn.GroupNorm(1, 256) + self.dupsampler = Decoder( + in_channels=256, + out_channels=1,#128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128, 256], + layers_per_block=1, + ) + + def mixer_block1(self, h, drop): + return nn.Sequential( + nn.LayerNorm(h), + self.mlp(h, h, drop), # Token mixing + ) + + def mixer_block2(self, seq_len, drop): + return nn.Sequential( + nn.LayerNorm(seq_len), + self.mlp(seq_len, seq_len, drop) # Channel mixing + ) + + def mlp(self, in_dim, out_dim, drop): + return nn.Sequential( + nn.Linear(in_dim, out_dim), + nn.GELU(), + nn.Dropout(drop), + nn.Linear(out_dim, out_dim), + ) + + def forward(self, x): + # make empty tensors for blur and depth outputs + b,d = torch.Tensor([0.]), torch.Tensor([0.]) + + # Initial linear layer + # x = self.lin0(x) + + # Reshape to seq_len by dim + # x = x.reshape(-1, self.seq_len, self.h) + + # Mixer blocks + residual1 = x + residual2 = x.permute(0,2,1) + for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2): + x = block1(x) + residual1 + residual1 = x + x = x.permute(0,2,1) + + x = block2(x) + residual2 + residual2 = x + x = x.permute(0,2,1) + + # Flatten + x = x.reshape(x.size(0), -1) + + c = self.clin1(x) + + # low rank linear to out dim cuts # params by nearly half compared to full linear mapping + # c = (x @ (self.V/100) @ (self.U/100)) + self.S + + c = self.clip_proj(c.reshape(len(c), -1, self.clip_size)) + + if blurry_recon: + b = self.blin1(x) + b = b.reshape(len(b), 256, 4, 4) + b = self.bgroupnorm(b) + b = self.bupsampler(b) + + if depth_recon: + d = self.dlin1(x)#.reshape(len(x), 1, 32, 32) + d = d.reshape(len(d), 256, 4, 4) + d = self.dgroupnorm(d) + d = self.dupsampler(d) + + return c, b, d + + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) + +model.backbone = BrainNetwork(h=1024, in_dim=1024, seq_len=4, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.backbone) +utils.count_params(model) + + +# test that the model works on some fake data +b = torch.randn((256,4,1024)) +print("b.shape",b.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(b) +print(clip_.shape, blur_.shape, depth_.shape) + + +# In[70]: + + +voxel_ridge = torch.randn(512,4096) +voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) +print("b.shape",voxel_ridge.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(voxel_ridge) +print(clip_.shape, blur_.shape, depth_.shape) + + +# In[64]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size))) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# In[49]: + + +seq_len = 4 + + +# In[57]: + + +voxel_ridge = torch.randn(512,4096) +voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) + + +# In[58]: + + +voxel_ridge.shape + + +# In[55]: + + +pp = None +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(dtype=data_type): + #optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()]#.to(device) + image = images[behav[:,0,0].cpu().long()].float()#.to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()]#.to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len)])#.to(device) # 15 + + print(past_15_times) + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + """ + #if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + """ + for p in range(seq_len-1): + print(past_behav.shape) #128, 15, 17 + print(past_behav[:,p,-1]) + print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + print(past_15_voxels) + pp = past_15_voxels + + break + + +# In[54]: + + +pp[20, 0, :] + + +# # Weights and Biases + +# In[66]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeyev2' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "clip_scale": clip_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + if True: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # Main + +# In[67]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[68]: + + +model, optimizer, train_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, lr_scheduler +) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[ ]: + + +def add_saturation(image, alpha=2): + gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :] + gray_image = gray_image.unsqueeze(1).expand_as(image) + saturated_image = alpha * image + (1 - alpha) * gray_image + return torch.clamp(saturated_image, 0, 1) + + +# In[65]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_depth_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + test_loss_depth_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + + #voxel = voxels[behav[:,0,5].cpu().long()].to(device) + #image = images[behav[:,0,0].cpu().long()].to(device).float() + + #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15 + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + + for p in range(seq_len-1): + #print(past_behav.shape) #128, 15, 17 + #print(past_behav[:,p,-1]) + #print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + #print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + #print(past_15_voxels) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) + #unsqueeze(1) # bz * 2, 1, 4096 + + # past_voxel_ridge = model.ridge(past_voxel) + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1) + print(voxel_ridge.shape) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item() + bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False) + # random_samps = np.arange(batch_size//5) + blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean + pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images) + # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + # loss += (1 - pixcorr) + blurry_pixcorr += pixcorr.item() + # utils.check_loss(pixcorr) + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()] + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # random sample of 300 + random_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == 300 + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + clip_target = clip_model.embed_image(image.float()) + + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)).unsqueeze(1) + + #voxel_ridge = model.ridge(voxel).unsqueeze(1) + + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + test_loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1))) + pixcorr = utils.pixcorr(image, blurry_recon_images) + loss += (1 - pixcorr) + test_blurry_pixcorr += pixcorr.item() + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + test_loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + # if utils.is_interactive(): clear_output(wait=True) + print("---") + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/loss_depth_total": loss_depth_total / (train_i + 1), + "test/loss_depth_total": test_loss_depth_total / (test_i + 1), + } + + if blurry_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + if depth_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + if wandb_log: + logs[f"test/depth_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# # Retrieve nearest neighbor in the training set using test set data + +# In[ ]: + + +annots = np.load("/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy") + + +# In[ ]: + + +ii=2 +all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices)) +with torch.no_grad(), torch.cuda.amp.autocast(): + for batch in tqdm(range(0,len(all_indices),512)): + if batch==0: + clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + else: + target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + clip_target = torch.vstack((clip_target,target)) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + voxel = test_voxel[[ii]].to(device) + image = test_image[[ii]].to(device) + + print("Original Image (test set)") + display(utils.torch_to_Image(image)) + + clip_target = clip_model.embed_image(image).cpu() + # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1))) + + voxel_ridge = model.ridge(voxel).unsqueeze(1) + clip_voxels, _, _ = model.backbone(voxel_ridge) + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + print("clip_voxels_norm", clip_voxels_norm.shape) + print("clip_target_norm", clip_target_norm.shape) + + sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), + clip_target_norm).flatten()).flip(0) + picks = all_indices[sortt[:5]] + + print("\nNearest neighbors in training set") + for ip,p in enumerate(picks): + display(utils.torch_to_Image(images[[p]])) + # print(utils.select_annotations([annots[int(p)]])) + if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0] + +print("\n=====\npredicted_caption:\n", predicted_caption) + + +# # Feed into Stable Diffusion XL for reconstructions + +# In[ ]: + + +from diffusers import StableDiffusionXLPipeline +pipe = StableDiffusionXLPipeline.from_pretrained( + "/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f", torch_dtype=torch.float16, variant="fp16", use_safetensors=True +) +pipe.to("cuda") +pass + + +# In[ ]: + + +prompt = predicted_caption +recon = pipe(prompt=prompt).images[0] + + +# In[ ]: + + +print("Seen image") +display(utils.torch_to_Image(image)) + +print("Reconstruction") +utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224)) + diff --git a/src/Train_MLPMixer-Copy2.py b/src/Train_MLPMixer-Copy2.py new file mode 100644 index 0000000000000000000000000000000000000000..14aaf5af12d29d705ed96de2f543d4c10b592b48 --- /dev/null +++ b/src/Train_MLPMixer-Copy2.py @@ -0,0 +1,1275 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train_MLPMixer-Copy1.ipynb --to python" +#call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# ## UNCOMMENT BELOW SECTION AND COMMENT OUT DEEPSPEED SECTION TO AVOID USING DEEPSPEED ### +# accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +# global_batch_size = batch_size = 32 +# data_type = torch.float16 # change depending on your mixed_precision + +### DEEPSPEED INITIALIZATION ### +if num_devices <= 1 and utils.is_interactive(): + global_batch_size = batch_size = 32 + print(f"Setting batch_size to {batch_size}") + # can emulate a distributed environment for deepspeed to work in jupyter notebook + os.environ["MASTER_ADDR"] = "localhost" + os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) + os.environ["RANK"] = "0" + os.environ["LOCAL_RANK"] = "0" + os.environ["WORLD_SIZE"] = "1" + os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + +# alter the deepspeed config according to your global and local batch size +if local_rank == 0: + with open('/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2.json', 'r') as file: + config = json.load(file) + config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) + config['train_micro_batch_size_per_gpu'] = batch_size + config['bf16'] = {'enabled': False} + config['fp16'] = {'enabled': True} + with open('/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2.json', 'w') as file: + json.dump(config, file) +else: + # give some time for the local_rank=0 gpu to prep new deepspeed config file + time.sleep(10) +deepspeed_plugin = DeepSpeedPlugin("/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2.json") +accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' + +# set data_type to match your mixed precision (automatically set based on deepspeed config) +if accelerator.mixed_precision == "bf16": + data_type = torch.bfloat16 +elif accelerator.mixed_precision == "fp16": + data_type = torch.float16 +else: + data_type = torch.float32 + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[5]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # create random model_name + model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + model_name = model_name + "_interactive" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the above cells + # other variables can be specified in the following string: + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name={model_name} \ + --subj=1 --batch_size={batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=4096 \ + --clip_scale=1. --blur_scale=100. --depth_scale=100. \ + --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[6]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=True, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--depth_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output depth reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=100., + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--depth_scale",type=float,default=100., + help="multiply loss from depth recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=120, + help="number of epochs of training", +) +parser.add_argument( + "--hidden_dim",type=int,default=4096, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--seq_len",type=int,default=2, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + + +# In[7]: + + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[8]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +# train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..1}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True) + + +# ### check dataloaders are working + +# In[9]: + + +test_vox_indices = [] +test_73k_images = [] +for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy()) + test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy()) +test_vox_indices = test_vox_indices.astype(np.int16) +print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices)) +print("---\n") + +train_vox_indices = [] +train_73k_images = [] +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy()) + train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy()) +train_vox_indices = train_vox_indices.astype(np.int16) +print(train_i, (train_i+1) * batch_size, len(train_vox_indices)) + + +# ## Load data and images + +# In[10]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r') + +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").to(data_type) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").to(data_type) +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[11]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) +clip_seq_dim = 257 +clip_emb_dim = 768 #1024 +# hidden_dim = 4096 +#seq_len = 1 #2 #32 + + +# ### SD VAE + +# In[12]: + + +# if blurry_recon: +# from diffusers import AutoencoderKL +# autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +# autoenc.eval() +# autoenc.requires_grad_(False) +# autoenc.to(device) +# utils.count_params(autoenc) + +if blurry_recon:# or depth_recon: + from diffusers import VQModel + autoenc = VQModel.from_pretrained("/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae", torch_dtype=data_type) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + +# #### downsampled images + +# In[13]: + + +if blurry_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30]].to(device) + print(input_batch.shape) + + downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest') + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + print(re_upsampled_enc.shape) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# #### MiDaS depth + +# In[14]: + + +if depth_recon: + from controlnet_aux.midas import MidasDetector + + midas_depth = MidasDetector.from_pretrained( + "valhalla/t2iadapter-aux-models", filename="dpt_large_384.pt", model_type="dpt_large", cache_dir="/fsx/proj-fmri/shared/cache").to(device) + midas_depth.model.eval() + midas_depth.model.requires_grad_(False) + midas_depth.model.to(device) + pass + + +# In[15]: + + +if depth_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30,31]].float().to(device) + print(input_batch.shape) + + midas_emb = midas_depth.model(input_batch).unsqueeze(1) + print(midas_emb.shape) + + prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max() + print(prediction.shape) + + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + midas_emb_size = prediction.flatten(1).shape[1] + print("midas_emb", prediction.shape, prediction.min(), prediction.max()) + print("midas_emb_size", midas_emb_size) + + if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) + + if blurry_recon: + prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1) + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215 + print("vae midas_emb", prediction_enc.shape, prediction_enc.min(), prediction_enc.max()) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# ### MindEye modules + +# In[17]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[18]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[24]: + + +num_past_voxels = 15 + + + +# In[25]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768): + super().__init__() + self.seq_len = seq_len + self.h = h + self.clip_size = clip_size + + # Initial linear layer to match the input dimensions to hidden dimensions + # self.lin0 = nn.Linear(in_dim, seq_len * h) + + # Mixer Blocks + self.mixer_blocks1 = nn.ModuleList([ + self.mixer_block1(h, drop) for _ in range(n_blocks) + ]) + self.mixer_blocks2 = nn.ModuleList([ + self.mixer_block2(seq_len, drop) for _ in range(n_blocks) + ]) + + # Output linear layer + self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True) + + # low-rank matrices + # self.rank = 500 + # self.U = nn.Parameter(torch.randn(self.rank, out_dim)) + # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank)) + # self.S = nn.Parameter(torch.randn(out_dim)) + + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + + if blurry_recon: + # self.blin1 = nn.Sequential( + # nn.Linear(out_dim, 4096, bias=True), + # nn.LayerNorm(4096), + # nn.GELU(), + # nn.Linear(4096, 4096)) + self.blin1 = nn.Linear(h*seq_len, 4096) + self.bgroupnorm = nn.GroupNorm(1, 256) + self.bupsampler = Decoder( + in_channels=256, + out_channels=128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128], + layers_per_block=1, + ) + + if depth_recon: + # self.dlin1 = nn.Sequential( + # nn.Linear(h, midas_emb_size), + # nn.Sigmoid(), + # ) + self.dlin1 = nn.Linear(h*seq_len, 4096) + self.dgroupnorm = nn.GroupNorm(1, 256) + self.dupsampler = Decoder( + in_channels=256, + out_channels=1,#128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128, 256], + layers_per_block=1, + ) + + def mixer_block1(self, h, drop): + return nn.Sequential( + nn.LayerNorm(h), + self.mlp(h, h, drop), # Token mixing + ) + + def mixer_block2(self, seq_len, drop): + return nn.Sequential( + nn.LayerNorm(seq_len), + self.mlp(seq_len, seq_len, drop) # Channel mixing + ) + + def mlp(self, in_dim, out_dim, drop): + return nn.Sequential( + nn.Linear(in_dim, out_dim), + nn.GELU(), + nn.Dropout(drop), + nn.Linear(out_dim, out_dim), + ) + + def forward(self, x, idx = None): + print(idx) + # make empty tensors for blur and depth outputs + b,d = torch.Tensor([0.]), torch.Tensor([0.]) + + # Initial linear layer + # x = self.lin0(x) + + # Reshape to seq_len by dim + # x = x.reshape(-1, self.seq_len, self.h) + + # Mixer blocks + #print("x shape ", x.shape) + residual1 = x + residual2 = x.permute(0,2,1) + #print("residual 2", residual2.shape) + for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2): + x = block1(x) + residual1 + #print("xblo", x.shape) + residual1 = x + x = x.permute(0,2,1) + + x = block2(x) + residual2 + #print("xblo2", x.shape) + residual2 = x + x = x.permute(0,2,1) + + # Flatten + x = x.reshape(x.size(0), -1) + + c = self.clin1(x) + + # low rank linear to out dim cuts # params by nearly half compared to full linear mapping + # c = (x @ (self.V/100) @ (self.U/100)) + self.S + + c = self.clip_proj(c.reshape(len(c), -1, self.clip_size)) + + if blurry_recon: + b = self.blin1(x) + b = b.reshape(len(b), 256, 4, 4) + b = self.bgroupnorm(b) + b = self.bupsampler(b) + + if depth_recon: + d = self.dlin1(x)#.reshape(len(x), 1, 32, 32) + d = d.reshape(len(d), 256, 4, 4) + d = self.dgroupnorm(d) + d = self.dupsampler(d) + + return c, b, d + + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) + +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=seq_len, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((1,seq_len,hidden_dim)) +print("b.shape",b.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(b) +print(clip_.shape, blur_.shape, depth_.shape) + + +# In[ ]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size))) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# # Weights and Biases + +# In[ ]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeyev2' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "clip_scale": clip_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # Main + +# In[ ]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[ ]: + + +model, optimizer, train_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, lr_scheduler +) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[ ]: + + +def add_saturation(image, alpha=2): + gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :] + gray_image = gray_image.unsqueeze(1).expand_as(image) + saturated_image = alpha * image + (1 - alpha) * gray_image + return torch.clamp(saturated_image, 0, 1) + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_depth_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + test_loss_depth_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + + #voxel = voxels[behav[:,0,5].cpu().long()].to(device) + #image = images[behav[:,0,0].cpu().long()].to(device).float() + + #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15 + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + + for p in range(seq_len-1): + #print(past_behav.shape) #128, 15, 17 + #print(past_behav[:,p,-1]) + #print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + #print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + #print(past_15_voxels) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view( seq_len, int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2) + #unsqueeze(1) # bz * 2, 1, 4096 + + # past_voxel_ridge = model.ridge(past_voxel) + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1) + #print(voxel_ridge.shape) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge, idx = train_i) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item() + bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False) + # random_samps = np.arange(batch_size//5) + blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean + pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images) + # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + # loss += (1 - pixcorr) + blurry_pixcorr += pixcorr.item() + # utils.check_loss(pixcorr) + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()] + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # random sample of 300 + random_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == 300 + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + clip_target = clip_model.embed_image(image.float()) + + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(seq_len, int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2) + + #voxel_ridge = model.ridge(voxel).unsqueeze(1) + + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + test_loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1))) + pixcorr = utils.pixcorr(image, blurry_recon_images) + loss += (1 - pixcorr) + test_blurry_pixcorr += pixcorr.item() + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + test_loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + # if utils.is_interactive(): clear_output(wait=True) + print("---") + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/loss_depth_total": loss_depth_total / (train_i + 1), + "test/loss_depth_total": test_loss_depth_total / (test_i + 1), + } + + if blurry_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + if depth_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + if wandb_log: + logs[f"test/depth_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# # Retrieve nearest neighbor in the training set using test set data + +# In[ ]: + + +annots = np.load("/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy") + + +# In[ ]: + + +ii=2 +all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices)) +with torch.no_grad(), torch.cuda.amp.autocast(): + for batch in tqdm(range(0,len(all_indices),512)): + if batch==0: + clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + else: + target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + clip_target = torch.vstack((clip_target,target)) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + voxel = test_voxel[[ii]].to(device) + image = test_image[[ii]].to(device) + + print("Original Image (test set)") + display(utils.torch_to_Image(image)) + + clip_target = clip_model.embed_image(image).cpu() + # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1))) + + voxel_ridge = model.ridge(voxel).unsqueeze(1) + clip_voxels, _, _ = model.backbone(voxel_ridge) + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + print("clip_voxels_norm", clip_voxels_norm.shape) + print("clip_target_norm", clip_target_norm.shape) + + sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), + clip_target_norm).flatten()).flip(0) + picks = all_indices[sortt[:5]] + + print("\nNearest neighbors in training set") + for ip,p in enumerate(picks): + display(utils.torch_to_Image(images[[p]])) + # print(utils.select_annotations([annots[int(p)]])) + if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0] + +print("\n=====\npredicted_caption:\n", predicted_caption) + + +# # Feed into Stable Diffusion XL for reconstructions + +# In[ ]: + + +from diffusers import StableDiffusionXLPipeline +pipe = StableDiffusionXLPipeline.from_pretrained( + "/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f", torch_dtype=torch.float16, variant="fp16", use_safetensors=True +) +pipe.to("cuda") +pass + + +# In[ ]: + + +prompt = predicted_caption +recon = pipe(prompt=prompt).images[0] + + +# In[ ]: + + +print("Seen image") +display(utils.torch_to_Image(image)) + +print("Reconstruction") +utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224)) + diff --git a/src/Train_MLPMixer-img.ipynb b/src/Train_MLPMixer-img.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..6d63f353fd2ea703d89b49d358bd997d5e3ded1c --- /dev/null +++ b/src/Train_MLPMixer-img.ipynb @@ -0,0 +1,2228 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[NbConvertApp] Converting notebook Train_MLPMixer-img.ipynb to python\n", + "[NbConvertApp] Writing 53671 bytes to Train_MLPMixer-img.py\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "from subprocess import call\n", + "command = \"jupyter nbconvert Train_MLPMixer-img.ipynb --to python\"\n", + "call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-11-06 01:14:35,497] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "\n", + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 16 #128\n", + "\n", + "import os\n", + "os.environ[\"CUDA_LAUNCH_BLOCKING\"] = \"1\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b8da928c-ea86-4959-86ee-dde55c07e58f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 1849460\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float32\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "\n", + "# set data_type to match your mixed precision (automatically set based on deepspeed config)\n", + "if accelerator.mixed_precision == \"bf16\":\n", + " data_type = torch.bfloat16\n", + "elif accelerator.mixed_precision == \"fp16\":\n", + " data_type = torch.float16\n", + "else:\n", + " data_type = torch.float32\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a7b0548c-fc95-43d9-94a7-d3e53176c736", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accelerator.state.distributed_type" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: mPo0n5r22f_interactive\n", + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=mPo0n5r22f_interactive', '--subj=1', '--batch_size=16', '--no-blurry_recon', '--no-depth_recon', '--hidden_dim=1024', '--clip_scale=1.', '--blur_scale=100.', '--depth_scale=100.', '--max_lr=3e-4', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug', '--no-ckpt_saving']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # create random model_name\n", + " model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10))\n", + " model_name = model_name + \"_interactive\"\n", + " print(\"model_name:\", model_name)\n", + "\n", + " # global_batch_size and batch_size should already be defined in the above cells\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name={model_name} \\\n", + " --subj=1 --batch_size={global_batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=1024 \\\n", + " --clip_scale=1. --blur_scale=100. --depth_scale=100. \\\n", + " --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output depth reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=100.,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_scale\",type=float,default=100.,\n", + " help=\"multiply loss from depth recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=120,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=4096,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--seq_len\",type=int,default=2,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "# train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..1}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 2770 2770\n", + "---\n", + "\n", + "1560 24976 24976\n" + ] + } + ], + "source": [ + "test_vox_indices = []\n", + "test_73k_images = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy())\n", + " test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy())\n", + "test_vox_indices = test_vox_indices.astype(np.int16)\n", + "print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices))\n", + "print(\"---\\n\")\n", + "\n", + "train_vox_indices = []\n", + "train_73k_images = []\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy())\n", + " train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy())\n", + "train_vox_indices = train_vox_indices.astype(np.int16)\n", + "print(train_i, (train_i+1) * batch_size, len(train_vox_indices))" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15724])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r')\n", + "\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").to(data_type)\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").to(data_type)\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768 #1024\n", + "# hidden_dim = 4096\n", + "#seq_len = 1 #2 #32 " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e1c6467c-fd57-4a4c-b5bb-f13fcb36d5b7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "clip_model2 = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=False, norm_embs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "50211450-8b0c-4a7a-87c4-64c109a4242b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#out2t = clip_model2.embed_image(torch.randn(32,3,224,224))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d7c01109-4bb9-4763-9477-460beeb6a949", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#out2t.shape" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# if blurry_recon:\n", + "# from diffusers import AutoencoderKL\n", + "# autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "# autoenc.eval()\n", + "# autoenc.requires_grad_(False)\n", + "# autoenc.to(device)\n", + "# utils.count_params(autoenc)\n", + "\n", + "if blurry_recon:# or depth_recon:\n", + " from diffusers import VQModel\n", + " autoenc = VQModel.from_pretrained(\"/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae\", torch_dtype=data_type)\n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "120c8eee-9834-437d-bb60-b38faef50138", + "metadata": {}, + "source": [ + "#### downsampled images" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6d1ba8dd-64c2-4ac9-947e-725b7f2e3e50", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30]].to(device)\n", + " print(input_batch.shape)\n", + "\n", + " downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " print(re_upsampled_enc.shape)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "6390a3a8-2bef-4e81-9b82-e154d26a1e1d", + "metadata": {}, + "source": [ + "#### MiDaS depth" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f35573e2-95bf-463d-8937-68ad4c2c3c20", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " from controlnet_aux.midas import MidasDetector\n", + " \n", + " midas_depth = MidasDetector.from_pretrained(\n", + " \"valhalla/t2iadapter-aux-models\", filename=\"dpt_large_384.pt\", model_type=\"dpt_large\", cache_dir=\"/fsx/proj-fmri/shared/cache\").to(device)\n", + " midas_depth.model.eval()\n", + " midas_depth.model.requires_grad_(False)\n", + " midas_depth.model.to(device)\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ba3f9207-b98e-45da-baa6-5cfcfb2ae958", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30,31]].float().to(device)\n", + " print(input_batch.shape)\n", + " \n", + " midas_emb = midas_depth.model(input_batch).unsqueeze(1)\n", + " print(midas_emb.shape)\n", + "\n", + " prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max()\n", + " print(prediction.shape)\n", + " \n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " midas_emb_size = prediction.flatten(1).shape[1]\n", + " print(\"midas_emb\", prediction.shape, prediction.min(), prediction.max())\n", + " print(\"midas_emb_size\", midas_emb_size)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) \n", + "\n", + " if blurry_recon:\n", + " prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1)\n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215\n", + " print(\"vae midas_emb\", prediction_enc.shape, prediction_enc.min(), prediction_enc.max())\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "16,626,688 total\n", + "16,626,688 trainable\n", + "param counts:\n", + "16,626,688 total\n", + "16,626,688 trainable\n", + "torch.Size([2, 1, 15724]) torch.Size([2, 1, 1024])\n" + ] + } + ], + "source": [ + "time_embedding_dim = 512\n", + "\n", + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "time_emb_test = torch.randn((2,1,time_embedding_dim))\n", + "print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ee763515-4853-4c5b-9265-ec5aa1bde971", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "num_past_voxels = 15\n", + "#seq_len = 1 + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "740,666,432 total\n", + "740,666,432 trainable\n", + "param counts:\n", + "757,300,800 total\n", + "757,300,800 trainable\n", + "b.shape torch.Size([1, 2, 1792])\n", + "torch.Size([1, 257, 768]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768):\n", + " super().__init__()\n", + " self.seq_len = seq_len\n", + " self.h = h\n", + " self.clip_size = clip_size\n", + " \n", + " # Initial linear layer to match the input dimensions to hidden dimensions\n", + " # self.lin0 = nn.Linear(in_dim, seq_len * h)\n", + " \n", + " # Mixer Blocks\n", + " self.mixer_blocks1 = nn.ModuleList([\n", + " self.mixer_block1(h, drop) for _ in range(n_blocks)\n", + " ])\n", + " self.mixer_blocks2 = nn.ModuleList([\n", + " self.mixer_block2(seq_len, drop) for _ in range(n_blocks)\n", + " ])\n", + " \n", + " # Output linear layer\n", + " self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True)\n", + "\n", + " # low-rank matrices\n", + " # self.rank = 500\n", + " # self.U = nn.Parameter(torch.randn(self.rank, out_dim))\n", + " # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank))\n", + " # self.S = nn.Parameter(torch.randn(out_dim))\n", + "\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + "\n", + " if blurry_recon:\n", + " # self.blin1 = nn.Sequential(\n", + " # nn.Linear(out_dim, 4096, bias=True),\n", + " # nn.LayerNorm(4096),\n", + " # nn.GELU(),\n", + " # nn.Linear(4096, 4096))\n", + " self.blin1 = nn.Linear(h*seq_len, 4096)\n", + " self.bgroupnorm = nn.GroupNorm(1, 256)\n", + " self.bupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128],\n", + " layers_per_block=1,\n", + " )\n", + "\n", + " if depth_recon:\n", + " # self.dlin1 = nn.Sequential(\n", + " # nn.Linear(h, midas_emb_size),\n", + " # nn.Sigmoid(),\n", + " # )\n", + " self.dlin1 = nn.Linear(h*seq_len, 4096)\n", + " self.dgroupnorm = nn.GroupNorm(1, 256)\n", + " self.dupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=1,#128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def mixer_block1(self, h, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(h),\n", + " self.mlp(h, h, drop), # Token mixing\n", + " )\n", + "\n", + " def mixer_block2(self, seq_len, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(seq_len),\n", + " self.mlp(seq_len, seq_len, drop) # Channel mixing\n", + " )\n", + " \n", + " def mlp(self, in_dim, out_dim, drop):\n", + " return nn.Sequential(\n", + " nn.Linear(in_dim, out_dim),\n", + " nn.GELU(),\n", + " nn.Dropout(drop),\n", + " nn.Linear(out_dim, out_dim),\n", + " )\n", + " \n", + " def forward(self, x):\n", + " # make empty tensors for blur and depth outputs\n", + " b,d = torch.Tensor([0.]), torch.Tensor([0.])\n", + " \n", + " # Initial linear layer\n", + " # x = self.lin0(x)\n", + " \n", + " # Reshape to seq_len by dim\n", + " # x = x.reshape(-1, self.seq_len, self.h)\n", + " \n", + " # Mixer blocks\n", + " residual1 = x\n", + " residual2 = x.permute(0,2,1)\n", + " for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2):\n", + " x = block1(x) + residual1\n", + " residual1 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " x = block2(x) + residual2\n", + " residual2 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " # Flatten\n", + " x = x.reshape(x.size(0), -1)\n", + " \n", + " c = self.clin1(x)\n", + "\n", + " # low rank linear to out dim cuts # params by nearly half compared to full linear mapping\n", + " # c = (x @ (self.V/100) @ (self.U/100)) + self.S\n", + " \n", + " c = self.clip_proj(c.reshape(len(c), -1, self.clip_size))\n", + "\n", + " if blurry_recon:\n", + " b = self.blin1(x)\n", + " b = b.reshape(len(b), 256, 4, 4)\n", + " b = self.bgroupnorm(b)\n", + " b = self.bupsampler(b)\n", + " \n", + " if depth_recon:\n", + " d = self.dlin1(x)#.reshape(len(x), 1, 32, 32)\n", + " d = d.reshape(len(d), 256, 4, 4)\n", + " d = self.dgroupnorm(d)\n", + " d = self.dupsampler(d)\n", + " \n", + " return c, b, d\n", + "\n", + "\n", + "class TimeEmbedding(nn.Module):\n", + " def __init__(self, embedding_time_dim=512, num_past_voxels=15):\n", + " super().__init__()\n", + " self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim)\n", + " self.num_past_voxels = num_past_voxels\n", + " self.embedding_time_dim = embedding_time_dim\n", + "\n", + " def forward(self, time):\n", + " # time is (batch_size,)\n", + " time = time.long()\n", + " time = self.embedding_time(time)\n", + " return time # (batch_size, embedding_time_dim)\n", + " \n", + "\n", + "#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512)\n", + "model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15)\n", + "\n", + "model.backbone = BrainNetwork(h=hidden_dim + clip_emb_dim, in_dim=hidden_dim + clip_emb_dim, seq_len=seq_len, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((1,seq_len,hidden_dim + clip_emb_dim))\n", + "print(\"b.shape\",b.shape)\n", + "with torch.no_grad():\n", + " clip_, blur_, depth_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape, depth_.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "fa7aa4ab-64af-45d4-8ed8-259043c16c29", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nvoxel_ridge = torch.randn(512,4096)\\nvoxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim)\\nprint(\"b.shape\",voxel_ridge.shape)\\nwith torch.no_grad():\\n clip_, blur_, depth_ = model.backbone(voxel_ridge)\\nprint(clip_.shape, blur_.shape, depth_.shape)'" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "voxel_ridge = torch.randn(512,4096)\n", + "voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim)\n", + "print(\"b.shape\",voxel_ridge.shape)\n", + "with torch.no_grad():\n", + " clip_, blur_, depth_ = model.backbone(voxel_ridge)\n", + "print(clip_.shape, blur_.shape, depth_.shape)\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 18718\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "757,300,800 total\n", + "757,300,800 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size)))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "5d600d8d-6a0d-4584-840e-c89521ff6364", + "metadata": {}, + "outputs": [], + "source": [ + "#nn++" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "3c937d01-eea5-4bad-906a-36d07b3c30a4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'pp = None\\nfor train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\\n #with torch.cuda.amp.autocast(dtype=data_type):\\n #optimizer.zero_grad()\\n\\n voxel = voxels[behav[:,0,5].cpu().long()]#.to(device)\\n image = images[behav[:,0,0].cpu().long()].float()#.to(device).float()\\n\\n past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()]#.to(device) # batch_size, 15, 15279\\n past_15_times = torch.Tensor([i for i in range(seq_len)])#.to(device) # 15\\n print(past_behav[:,:seq_len-1,0].cpu().long())\\n past_15_images = images[past_behav[:,:seq_len-1,0].cpu().long()]\\n \\n break\\n \\n print(past_15_times)\\n #for past in range(1):\\n # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\\n \\n #if blurry_recon:\\n # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\\n blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\\n\\n if depth_recon:\\n # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\\n depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\\n depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\\n depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\\n\\n if use_image_aug: \\n image = img_augment(image)\\n\\n clip_target = clip_model.embed_image(image)\\n assert not torch.any(torch.isnan(clip_target))\\n\\n if epoch < int(mixup_pct * num_epochs):\\n voxel, perm, betas, select = utils.mixco(voxel)\\n past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\\n \\n for p in range(seq_len-1):\\n print(past_behav.shape) #128, 15, 17\\n print(past_behav[:,p,-1])\\n print(past_15_voxels.shape) # 128, 1, 15724\\n mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1])\\n print(mask) # 128\\n past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :])\\n print(past_15_voxels)\\n pp = past_15_voxels\\n \\n break'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"pp = None\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " #with torch.cuda.amp.autocast(dtype=data_type):\n", + " #optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()]#.to(device)\n", + " image = images[behav[:,0,0].cpu().long()].float()#.to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()]#.to(device) # batch_size, 15, 15279\n", + " past_15_times = torch.Tensor([i for i in range(seq_len)])#.to(device) # 15\n", + " print(past_behav[:,:seq_len-1,0].cpu().long())\n", + " past_15_images = images[past_behav[:,:seq_len-1,0].cpu().long()]\n", + " \n", + " break\n", + " \n", + " print(past_15_times)\n", + " #for past in range(1):\n", + " # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\n", + " \n", + " #if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + "\n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + "\n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + "\n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + " past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\n", + " \n", + " for p in range(seq_len-1):\n", + " print(past_behav.shape) #128, 15, 17\n", + " print(past_behav[:,p,-1])\n", + " print(past_15_voxels.shape) # 128, 1, 15724\n", + " mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1])\n", + " print(mask) # 128\n", + " past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :])\n", + " print(past_15_voxels)\n", + " pp = past_15_voxels\n", + " \n", + " break\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5c7eb009-9fcf-4e35-9e1b-c0ca6418b6b8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#pp[20, 0, :]" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeyev2 run mPo0n5r22f_interactive\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'mPo0n5r22f_interactive', 'global_batch_size': 16, 'batch_size': 16, 'num_epochs': 12, 'clip_scale': 1.0, 'blur_scale': 100.0, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar', 'test_url': '/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar'}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231106_011703-qm896vre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run mPo0n5r22f_interactive to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeyev2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeyev2/runs/qm896vre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'mindeyev2'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"clip_scale\": clip_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " \"train_url\": train_url,\n", + " \"test_url\": test_url,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, lr_scheduler\n", + ")\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "469e6313-425f-45ed-875a-ecd5df343e31", + "metadata": {}, + "outputs": [], + "source": [ + "def add_saturation(image, alpha=2):\n", + " gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :]\n", + " gray_image = gray_image.unsqueeze(1).expand_as(image)\n", + " saturated_image = alpha * image + (1 - alpha) * gray_image\n", + " return torch.clamp(saturated_image, 0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "43e126bd-5320-4512-91c1-cdcb67a622f0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#b = torch.randn(1,2)\n", + "#b.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "264b34ed-8214-48d2-871f-0a7413526ac4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#device" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ff64dc04-6082-4b87-979a-224868db57e1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#past_15_times = torch.Tensor([i for i in range(seq_len-1)]).long() # 15\n", + "#past_15_times.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "00d5e5e1-0e22-409a-9f5f-5eeeb6b00620", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+       "│ nn++                                                                                             │\n",
+       "│     ▲                                                                                            │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "SyntaxError: invalid syntax\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[91m╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\u001b[0m\n", + "\u001b[91m│\u001b[0m nn++ \u001b[91m│\u001b[0m\n", + "\u001b[91m│\u001b[0m \u001b[1;91m▲\u001b[0m \u001b[91m│\u001b[0m\n", + "\u001b[91m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mSyntaxError: \u001b[0minvalid syntax\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nn++" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85af68da-dd37-4d79-aca1-49f67e5bbd98", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mPo0n5r22f_interactive starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:307 │\n", + "│ │\n", + "│ 304 │ │ │ assert (test_i+1) == 1 │\n", + "│ 305 │ │ │ logs = {\"train/loss\": np.mean(losses[-(train_i+1):]), │\n", + "│ 306 │ │ │ │ \"test/loss\": np.mean(test_losses[-(test_i+1):]), │\n", + "│ ❱ 307 │ │ │ │ \"train/lr\": lrs[-1], │\n", + "│ 308 │ │ │ │ \"train/num_steps\": len(losses), │\n", + "│ 309 │ │ │ │ \"test/num_steps\": len(test_losses), │\n", + "│ 310 │ │ │ │ \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1), │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "IndexError: list index out of range\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m307\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m304 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94massert\u001b[0m (test_i+\u001b[94m1\u001b[0m) == \u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m305 \u001b[0m\u001b[2m│ │ │ \u001b[0mlogs = {\u001b[33m\"\u001b[0m\u001b[33mtrain/loss\u001b[0m\u001b[33m\"\u001b[0m: np.mean(losses[-(train_i+\u001b[94m1\u001b[0m):]), \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m306 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mtest/loss\u001b[0m\u001b[33m\"\u001b[0m: np.mean(test_losses[-(test_i+\u001b[94m1\u001b[0m):]), \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m307 \u001b[2m│ │ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mtrain/lr\u001b[0m\u001b[33m\"\u001b[0m: lrs[-\u001b[94m1\u001b[0m], \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m308 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mtrain/num_steps\u001b[0m\u001b[33m\"\u001b[0m: \u001b[96mlen\u001b[0m(losses), \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m309 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mtest/num_steps\u001b[0m\u001b[33m\"\u001b[0m: \u001b[96mlen\u001b[0m(test_losses), \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m310 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[33m\"\u001b[0m\u001b[33mtrain/fwd_pct_correct\u001b[0m\u001b[33m\"\u001b[0m: fwd_percent_correct / (train_i + \u001b[94m1\u001b[0m), \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mIndexError: \u001b[0mlist index out of range\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_depth_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + " test_loss_depth_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + " \n", + " #voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " #image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + " \n", + " #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15\n", + " \n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " #print(past_behav[:,:seq_len-1,0].cpu().long(), behav[:,0,0].cpu().long(), past_behav[:,:seq_len-1,0].cpu().long()[0])\n", + " past_15_images = images[past_behav[:,:seq_len-1,0].cpu().long()].to(device).float()\n", + " past_array = [i for i in range(seq_len-1)]\n", + " past_15_times = torch.Tensor(past_array) # 15\n", + " #print(past_15_times)\n", + " #print(past_15_voxels.shape, past_behav[:,:seq_len-1,5].cpu().long())\n", + " past_15_times = past_15_times.to(device)\n", + " #for past in range(1):\n", + " # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\n", + " \n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + " past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\n", + " \n", + " #print(past_15_images.shape)\n", + " \n", + " for p in range(seq_len-1):\n", + " #print(past_behav.shape) #128, 15, 17\n", + " #print(past_behav[:,p,-1])\n", + " #print(past_15_voxels.shape) # 128, 1, 15724\n", + " mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1])\n", + " #print(mask) # 128\n", + " past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :])\n", + " past_15_images[mask, p, :] = torch.zeros_like(past_15_images[0, p, :])\n", + " #print(past_15_voxels)\n", + " \n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_images = past_15_images.reshape(-1, past_15_images.shape[-3], past_15_images.shape[-2], past_15_images.shape[-1])\n", + " #print(past_15_images.shape)\n", + " past_15_embeddings = clip_model2.embed_image(past_15_images)\n", + " #print(past_15_embeddings.shape, 'uteho')\n", + " past_15_embeddings = torch.cat([torch.zeros(batch_size, past_15_embeddings.shape[-1]).to(past_15_embeddings.device), past_15_embeddings], dim = 0)\n", + " #print('tuhet', past_15_embeddings.shape)\n", + " #print('yepe', past_15_embeddings[0,:])\n", + " #print('yepe', past_15_embeddings[17,:])\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " \n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + " \n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " voxel = torch.cat((voxel, positional_current_voxel), dim=-1)\n", + " voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2))\n", + " voxel_ridge = voxel_ridge.view(seq_len,int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2)\n", + " #past_15_embeddings = torch.split(past_15_embeddings, seq_len)\n", + " #print(past_15_embeddings, 'ttt')\n", + " past_15_embeddings = past_15_embeddings.reshape(seq_len, int(past_15_embeddings.shape[0]/seq_len), clip_emb_dim).permute(1,0,2)\n", + " #unsqueeze(1) # bz * 2, 1, 4096\n", + " #print(voxel_ridge.shape, past_15_embeddings.shape)\n", + " #print('yepe', past_15_embeddings[10,0,:])\n", + " #print('yepe', past_15_embeddings[10,1,:])\n", + " voxel_ridge = torch.cat((voxel_ridge, past_15_embeddings), dim=-1)\n", + " #print(voxel_ridge[:,0,-10:-1])\n", + " #print(voxel_ridge[:,0,10:20])\n", + " #raise(\"uehot\")\n", + " # past_voxel_ridge = model.ridge(past_voxel)\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1)\n", + " #print(voxel_ridge.shape)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " loss = loss_clip\n", + " \n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item()\n", + " \n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False)\n", + " # random_samps = np.arange(batch_size//5)\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean\n", + " pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images)\n", + " # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " # loss += (1 - pixcorr)\n", + " blurry_pixcorr += pixcorr.item()\n", + " # utils.check_loss(pixcorr)\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " assert len(behav) == num_test\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()]\n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # random sample of 300\n", + " random_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == 300\n", + " \n", + " current_past_behav = past_behav[random_indices]\n", + "\n", + " past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279\n", + " past_15_images = images[current_past_behav[:,:seq_len-1,0].cpu().long()].to(device).float()\n", + " past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15\n", + "\n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + "\n", + " past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1])\n", + " past_15_images = past_15_images.reshape(-1, past_15_images.shape[-3], past_15_images.shape[-2], past_15_images.shape[-1])\n", + " print(past_15_images.shape)\n", + " past_15_embeddings = clip_model2.embed_image(past_15_images)\n", + " print(past_15_embeddings.shape)\n", + " past_15_embeddings = torch.cat([torch.zeros(image.shape[0], past_15_embeddings.shape[-1]).to(past_15_embeddings.device), past_15_embeddings], dim = 0)\n", + " print(past_15_embeddings.shape)\n", + " past_15_times = past_15_times.repeat(voxel.shape[0], 1)\n", + " past_15_times = past_15_times.reshape(-1)\n", + " time_embeddings = model.time_embedding(past_15_times)\n", + " past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1)\n", + "\n", + " positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device)\n", + " voxel = torch.cat((voxel, positional_current_voxel), dim=-1)\n", + " voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2))\n", + " voxel_ridge = voxel_ridge.view(seq_len, int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2)\n", + " past_15_embeddings = past_15_embeddings.view(seq_len, int(past_15_embeddings.shape[0]/seq_len), clip_emb_dim).permute(1,0,2)\n", + " print(past_15_embeddings.shape, voxel_ridge.shape)\n", + " voxel_ridge = torch.cat((voxel_ridge, past_15_embeddings), dim=-1)\n", + " \n", + " #voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + "\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss = loss_clip\n", + "\n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " test_loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + " \n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " pixcorr = utils.pixcorr(image, blurry_recon_images)\n", + " loss += (1 - pixcorr)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " test_loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " print(\"---\")\n", + " \n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/loss_depth_total\": loss_depth_total / (train_i + 1),\n", + " \"test/loss_depth_total\": test_loss_depth_total / (test_i + 1),\n", + " }\n", + " \n", + " if blurry_recon: \n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " \n", + " if wandb_log:\n", + " logs[f\"test/recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " if depth_recon:\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " if wandb_log:\n", + " logs[f\"test/depth_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + " \n", + " progress_bar.set_postfix(**logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f2690877-a431-44e8-a2ca-61f4b7397070", + "metadata": {}, + "source": [ + "# Retrieve nearest neighbor in the training set using test set data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b6b8feb-391d-437e-a5d9-a2088f1b1149", + "metadata": {}, + "outputs": [], + "source": [ + "annots = np.load(\"/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "612ac5aa-6f0f-45ad-809e-03df905d184c", + "metadata": {}, + "outputs": [], + "source": [ + "ii=2\n", + "all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices))\n", + "with torch.no_grad(), torch.cuda.amp.autocast():\n", + " for batch in tqdm(range(0,len(all_indices),512)):\n", + " if batch==0:\n", + " clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " else:\n", + " target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " clip_target = torch.vstack((clip_target,target))\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " voxel = test_voxel[[ii]].to(device)\n", + " image = test_image[[ii]].to(device)\n", + "\n", + " print(\"Original Image (test set)\")\n", + " display(utils.torch_to_Image(image))\n", + " \n", + " clip_target = clip_model.embed_image(image).cpu()\n", + " # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1)))\n", + " \n", + " voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + " clip_voxels, _, _ = model.backbone(voxel_ridge) \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " print(\"clip_voxels_norm\", clip_voxels_norm.shape)\n", + " print(\"clip_target_norm\", clip_target_norm.shape)\n", + " \n", + " sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), \n", + " clip_target_norm).flatten()).flip(0)\n", + " picks = all_indices[sortt[:5]]\n", + "\n", + " print(\"\\nNearest neighbors in training set\")\n", + " for ip,p in enumerate(picks):\n", + " display(utils.torch_to_Image(images[[p]]))\n", + " # print(utils.select_annotations([annots[int(p)]]))\n", + " if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0]\n", + "\n", + "print(\"\\n=====\\npredicted_caption:\\n\", predicted_caption)" + ] + }, + { + "cell_type": "markdown", + "id": "1473ddaa-5f2b-4448-9194-c7b0801d05db", + "metadata": {}, + "source": [ + "# Feed into Stable Diffusion XL for reconstructions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70e50e0d-c44f-4d56-939a-2943535e1747", + "metadata": {}, + "outputs": [], + "source": [ + "from diffusers import StableDiffusionXLPipeline\n", + "pipe = StableDiffusionXLPipeline.from_pretrained(\n", + " \"/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f\", torch_dtype=torch.float16, variant=\"fp16\", use_safetensors=True\n", + ")\n", + "pipe.to(\"cuda\")\n", + "pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "479e6994-3eaa-47d2-89a3-422c464fab36", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = predicted_caption\n", + "recon = pipe(prompt=prompt).images[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dc48e1b-5842-4a29-963a-6469d943a72c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "print(\"Seen image\")\n", + "display(utils.torch_to_Image(image))\n", + "\n", + "print(\"Reconstruction\")\n", + "utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224))" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train_MLPMixer-img.py b/src/Train_MLPMixer-img.py new file mode 100644 index 0000000000000000000000000000000000000000..df6bc3dc2ed51c16b80df96d751b05a2ad43a2f1 --- /dev/null +++ b/src/Train_MLPMixer-img.py @@ -0,0 +1,1444 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train_MLPMixer-Copy1.ipynb --to python" +#call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 16 #128 + +import os +os.environ["CUDA_LAUNCH_BLOCKING"] = "1" + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +#accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +if num_devices <= 1 and utils.is_interactive(): + # can emulate a distributed environment for deepspeed to work in jupyter notebook + os.environ["MASTER_ADDR"] = "localhost" + os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) + os.environ["RANK"] = "0" + os.environ["LOCAL_RANK"] = "0" + os.environ["WORLD_SIZE"] = "1" + os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# alter the deepspeed config according to your global and local batch size +if local_rank == 0: + with open('/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2_cpuoffload.json', 'r') as file: + config = json.load(file) + config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) + config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + with open('deepspeed_config_stage2.json', 'w') as file: + json.dump(config, file) +else: + # give some time for the local_rank=0 gpu to prep new deepspeed config file + time.sleep(10) +deepspeed_plugin = DeepSpeedPlugin("/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2_cpuoffload.json") +accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' + +# set data_type to match your mixed precision (automatically set based on deepspeed config) +if accelerator.mixed_precision == "bf16": + data_type = torch.bfloat16 +elif accelerator.mixed_precision == "fp16": + data_type = torch.float16 +else: + data_type = torch.float32 + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# In[5]: + + +accelerator.state.distributed_type + + +# # Configurations + +# In[6]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # create random model_name + model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + model_name = model_name + "_interactive" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the above cells + # other variables can be specified in the following string: + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name={model_name} \ + --subj=1 --batch_size={global_batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=1024 \ + --clip_scale=1. --blur_scale=100. --depth_scale=100. \ + --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[7]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=True, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--depth_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output depth reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=100., + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--depth_scale",type=float,default=100., + help="multiply loss from depth recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=120, + help="number of epochs of training", +) +parser.add_argument( + "--hidden_dim",type=int,default=4096, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--seq_len",type=int,default=2, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + + +# In[8]: + + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[9]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +# train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..1}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True) + + +# ### check dataloaders are working + +# In[10]: + + +test_vox_indices = [] +test_73k_images = [] +for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy()) + test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy()) +test_vox_indices = test_vox_indices.astype(np.int16) +print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices)) +print("---\n") + +train_vox_indices = [] +train_73k_images = [] +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy()) + train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy()) +train_vox_indices = train_vox_indices.astype(np.int16) +print(train_i, (train_i+1) * batch_size, len(train_vox_indices)) + + +# ## Load data and images + +# In[11]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r') + +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").to(data_type) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").to(data_type) +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[12]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) +clip_seq_dim = 257 +clip_emb_dim = 768 #1024 +# hidden_dim = 4096 +#seq_len = 1 #2 #32 + + +# In[13]: + + +clip_model2 = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=False, norm_embs=True) + + +# In[14]: + + +#out2t = clip_model2.embed_image(torch.randn(32,3,224,224)) + + +# In[15]: + + +#out2t.shape + + +# ### SD VAE + +# In[16]: + + +# if blurry_recon: +# from diffusers import AutoencoderKL +# autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +# autoenc.eval() +# autoenc.requires_grad_(False) +# autoenc.to(device) +# utils.count_params(autoenc) + +if blurry_recon:# or depth_recon: + from diffusers import VQModel + autoenc = VQModel.from_pretrained("/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae", torch_dtype=data_type) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + +# #### downsampled images + +# In[17]: + + +if blurry_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30]].to(device) + print(input_batch.shape) + + downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest') + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + print(re_upsampled_enc.shape) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# #### MiDaS depth + +# In[18]: + + +if depth_recon: + from controlnet_aux.midas import MidasDetector + + midas_depth = MidasDetector.from_pretrained( + "valhalla/t2iadapter-aux-models", filename="dpt_large_384.pt", model_type="dpt_large", cache_dir="/fsx/proj-fmri/shared/cache").to(device) + midas_depth.model.eval() + midas_depth.model.requires_grad_(False) + midas_depth.model.to(device) + pass + + +# In[19]: + + +if depth_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30,31]].float().to(device) + print(input_batch.shape) + + midas_emb = midas_depth.model(input_batch).unsqueeze(1) + print(midas_emb.shape) + + prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max() + print(prediction.shape) + + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + midas_emb_size = prediction.flatten(1).shape[1] + print("midas_emb", prediction.shape, prediction.min(), prediction.max()) + print("midas_emb_size", midas_emb_size) + + if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) + + if blurry_recon: + prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1) + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215 + print("vae midas_emb", prediction_enc.shape, prediction_enc.min(), prediction_enc.max()) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# ### MindEye modules + +# In[20]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[21]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[22]: + + +num_past_voxels = 15 +#seq_len = 1 + 1 + + +# In[23]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768): + super().__init__() + self.seq_len = seq_len + self.h = h + self.clip_size = clip_size + + # Initial linear layer to match the input dimensions to hidden dimensions + # self.lin0 = nn.Linear(in_dim, seq_len * h) + + # Mixer Blocks + self.mixer_blocks1 = nn.ModuleList([ + self.mixer_block1(h, drop) for _ in range(n_blocks) + ]) + self.mixer_blocks2 = nn.ModuleList([ + self.mixer_block2(seq_len, drop) for _ in range(n_blocks) + ]) + + # Output linear layer + self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True) + + # low-rank matrices + # self.rank = 500 + # self.U = nn.Parameter(torch.randn(self.rank, out_dim)) + # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank)) + # self.S = nn.Parameter(torch.randn(out_dim)) + + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + + if blurry_recon: + # self.blin1 = nn.Sequential( + # nn.Linear(out_dim, 4096, bias=True), + # nn.LayerNorm(4096), + # nn.GELU(), + # nn.Linear(4096, 4096)) + self.blin1 = nn.Linear(h*seq_len, 4096) + self.bgroupnorm = nn.GroupNorm(1, 256) + self.bupsampler = Decoder( + in_channels=256, + out_channels=128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128], + layers_per_block=1, + ) + + if depth_recon: + # self.dlin1 = nn.Sequential( + # nn.Linear(h, midas_emb_size), + # nn.Sigmoid(), + # ) + self.dlin1 = nn.Linear(h*seq_len, 4096) + self.dgroupnorm = nn.GroupNorm(1, 256) + self.dupsampler = Decoder( + in_channels=256, + out_channels=1,#128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128, 256], + layers_per_block=1, + ) + + def mixer_block1(self, h, drop): + return nn.Sequential( + nn.LayerNorm(h), + self.mlp(h, h, drop), # Token mixing + ) + + def mixer_block2(self, seq_len, drop): + return nn.Sequential( + nn.LayerNorm(seq_len), + self.mlp(seq_len, seq_len, drop) # Channel mixing + ) + + def mlp(self, in_dim, out_dim, drop): + return nn.Sequential( + nn.Linear(in_dim, out_dim), + nn.GELU(), + nn.Dropout(drop), + nn.Linear(out_dim, out_dim), + ) + + def forward(self, x, idx = None): + print(idx) + # make empty tensors for blur and depth outputs + b,d = torch.Tensor([0.]), torch.Tensor([0.]) + + # Initial linear layer + # x = self.lin0(x) + + # Reshape to seq_len by dim + # x = x.reshape(-1, self.seq_len, self.h) + + # Mixer blocks + #print("x shape ", x.shape) + residual1 = x + residual2 = x.permute(0,2,1) + #print("residual 2", residual2.shape) + for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2): + x = block1(x) + residual1 + #print("xblo", x.shape) + residual1 = x + x = x.permute(0,2,1) + + x = block2(x) + residual2 + #print("xblo2", x.shape) + residual2 = x + x = x.permute(0,2,1) + + # Flatten + x = x.reshape(x.size(0), -1) + + c = self.clin1(x) + + # low rank linear to out dim cuts # params by nearly half compared to full linear mapping + # c = (x @ (self.V/100) @ (self.U/100)) + self.S + + c = self.clip_proj(c.reshape(len(c), -1, self.clip_size)) + + if blurry_recon: + b = self.blin1(x) + b = b.reshape(len(b), 256, 4, 4) + b = self.bgroupnorm(b) + b = self.bupsampler(b) + + if depth_recon: + d = self.dlin1(x)#.reshape(len(x), 1, 32, 32) + d = d.reshape(len(d), 256, 4, 4) + d = self.dgroupnorm(d) + d = self.dupsampler(d) + + return c, b, d + + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) + +model.backbone = BrainNetwork(h=hidden_dim + clip_emb_dim, in_dim=hidden_dim + clip_emb_dim, seq_len=seq_len, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((1,seq_len,hidden_dim + clip_emb_dim)) +print("b.shape",b.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(b) +print(clip_.shape, blur_.shape, depth_.shape) + + +# In[24]: + + +""" +voxel_ridge = torch.randn(512,4096) +voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) +print("b.shape",voxel_ridge.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(voxel_ridge) +print(clip_.shape, blur_.shape, depth_.shape)""" + + +# In[25]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size))) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# In[26]: + + +#nn++ + + +# In[27]: + + +"""pp = None +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + #with torch.cuda.amp.autocast(dtype=data_type): + #optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()]#.to(device) + image = images[behav[:,0,0].cpu().long()].float()#.to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()]#.to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len)])#.to(device) # 15 + print(past_behav[:,:seq_len-1,0].cpu().long()) + past_15_images = images[past_behav[:,:seq_len-1,0].cpu().long()] + + break + + print(past_15_times) + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + + #if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + + for p in range(seq_len-1): + print(past_behav.shape) #128, 15, 17 + print(past_behav[:,p,-1]) + print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + print(past_15_voxels) + pp = past_15_voxels + + break""" + + +# In[28]: + + +#pp[20, 0, :] + + +# # Weights and Biases + +# In[29]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeyev2' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "clip_scale": clip_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # Main + +# In[30]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[31]: + + +model, optimizer, train_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, lr_scheduler +) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[32]: + + +def add_saturation(image, alpha=2): + gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :] + gray_image = gray_image.unsqueeze(1).expand_as(image) + saturated_image = alpha * image + (1 - alpha) * gray_image + return torch.clamp(saturated_image, 0, 1) + + +# In[33]: + + +#b = torch.randn(1,2) +#b.to(device) + + +# In[34]: + + +#device + + +# In[35]: + + +#past_15_times = torch.Tensor([i for i in range(seq_len-1)]).long() # 15 +#past_15_times.to(device) + + +# In[36]: + + +#nn++ + + +# In[ ]: + + +#images.shape + + +# In[94]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_depth_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + test_loss_depth_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + #voxel = voxels[behav[:,0,5].cpu().long()].to(device) + #image = images[behav[:,0,0].cpu().long()].to(device).float() + + #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15 + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + #print(past_behav[:,:seq_len-1,0].cpu().long(), behav[:,0,0].cpu().long(), past_behav[:,:seq_len-1,0].cpu().long()[0]) + past_15_images = images[past_behav[:,:seq_len-1,0].cpu().long()].to(device).float() + past_array = [i for i in range(seq_len-1)] + past_15_times = torch.Tensor(past_array) # 15 + #print(past_15_times) + #print(past_15_voxels.shape, past_behav[:,:seq_len-1,5].cpu().long()) + past_15_times = past_15_times.to(device) + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + + #print(past_15_images.shape) + + for p in range(seq_len-1): + #print(past_behav.shape) #128, 15, 17 + #print(past_behav[:,p,-1]) + #print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + #print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + past_15_images[mask, p, :] = torch.zeros_like(past_15_images[0, p, :]) + #print(past_15_voxels) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_images = past_15_images.reshape(-1, past_15_images.shape[-3], past_15_images.shape[-2], past_15_images.shape[-1]) + #print(past_15_images.shape) + past_15_embeddings = clip_model2.embed_image(past_15_images) + #print(past_15_embeddings.shape, 'uteho') + past_15_embeddings = torch.cat([torch.zeros(batch_size, past_15_embeddings.shape[-1]).to(past_15_embeddings.device), past_15_embeddings], dim = 0) + #print('tuhet', past_15_embeddings.shape) + #print('yepe', past_15_embeddings[0,:]) + #print('yepe', past_15_embeddings[17,:]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(seq_len,int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2) + #past_15_embeddings = torch.split(past_15_embeddings, seq_len) + #print(past_15_embeddings, 'ttt') + past_15_embeddings = past_15_embeddings.reshape(seq_len, int(past_15_embeddings.shape[0]/seq_len), clip_emb_dim).permute(1,0,2) + #unsqueeze(1) # bz * 2, 1, 4096 + #print(voxel_ridge.shape, past_15_embeddings.shape) + #print('yepe', past_15_embeddings[10,0,:]) + #print('yepe', past_15_embeddings[10,1,:]) + voxel_ridge = torch.cat((voxel_ridge, past_15_embeddings), dim=-1) + #print(voxel_ridge[:,0,-10:-1]) + #print(voxel_ridge[:,0,10:20]) + #raise("uehot") + # past_voxel_ridge = model.ridge(past_voxel) + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1) + #print(voxel_ridge.shape) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item() + bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False) + # random_samps = np.arange(batch_size//5) + blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean + pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images) + # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + # loss += (1 - pixcorr) + blurry_pixcorr += pixcorr.item() + # utils.check_loss(pixcorr) + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()] + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # random sample of 300 + random_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == 300 + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_images = images[current_past_behav[:,:seq_len-1,0].cpu().long()].to(device).float() + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + clip_target = clip_model.embed_image(image.float()) + + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_images = past_15_images.reshape(-1, past_15_images.shape[-3], past_15_images.shape[-2], past_15_images.shape[-1]) + #print(past_15_images.shape) + past_15_embeddings = clip_model2.embed_image(past_15_images) + #print(past_15_embeddings.shape) + past_15_embeddings = torch.cat([torch.zeros(image.shape[0], past_15_embeddings.shape[-1]).to(past_15_embeddings.device), past_15_embeddings], dim = 0) + #print(past_15_embeddings.shape) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(seq_len, int(voxel_ridge.shape[0]/seq_len), hidden_dim).permute(1,0,2) + past_15_embeddings = past_15_embeddings.view(seq_len, int(past_15_embeddings.shape[0]/seq_len), clip_emb_dim).permute(1,0,2) + #print(past_15_embeddings.shape, voxel_ridge.shape) + voxel_ridge = torch.cat((voxel_ridge, past_15_embeddings), dim=-1) + + #voxel_ridge = model.ridge(voxel).unsqueeze(1) + + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + test_loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1))) + pixcorr = utils.pixcorr(image, blurry_recon_images) + loss += (1 - pixcorr) + test_blurry_pixcorr += pixcorr.item() + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + test_loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + # if utils.is_interactive(): clear_output(wait=True) + print("---") + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/loss_depth_total": loss_depth_total / (train_i + 1), + "test/loss_depth_total": test_loss_depth_total / (test_i + 1), + } + + if blurry_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + if depth_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + if wandb_log: + logs[f"test/depth_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# # Retrieve nearest neighbor in the training set using test set data + +# In[ ]: + + +annots = np.load("/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy") + + +# In[ ]: + + +ii=2 +all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices)) +with torch.no_grad(), torch.cuda.amp.autocast(): + for batch in tqdm(range(0,len(all_indices),512)): + if batch==0: + clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + else: + target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + clip_target = torch.vstack((clip_target,target)) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + voxel = test_voxel[[ii]].to(device) + image = test_image[[ii]].to(device) + + print("Original Image (test set)") + display(utils.torch_to_Image(image)) + + clip_target = clip_model.embed_image(image).cpu() + # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1))) + + voxel_ridge = model.ridge(voxel).unsqueeze(1) + clip_voxels, _, _ = model.backbone(voxel_ridge) + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + print("clip_voxels_norm", clip_voxels_norm.shape) + print("clip_target_norm", clip_target_norm.shape) + + sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), + clip_target_norm).flatten()).flip(0) + picks = all_indices[sortt[:5]] + + print("\nNearest neighbors in training set") + for ip,p in enumerate(picks): + display(utils.torch_to_Image(images[[p]])) + # print(utils.select_annotations([annots[int(p)]])) + if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0] + +print("\n=====\npredicted_caption:\n", predicted_caption) + + +# # Feed into Stable Diffusion XL for reconstructions + +# In[ ]: + + +from diffusers import StableDiffusionXLPipeline +pipe = StableDiffusionXLPipeline.from_pretrained( + "/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f", torch_dtype=torch.float16, variant="fp16", use_safetensors=True +) +pipe.to("cuda") +pass + + +# In[ ]: + + +prompt = predicted_caption +recon = pipe(prompt=prompt).images[0] + + +# In[ ]: + + +print("Seen image") +display(utils.torch_to_Image(image)) + +print("Reconstruction") +utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224)) + diff --git a/src/Train_MLPMixer.ipynb b/src/Train_MLPMixer.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..90061426ad0b234c137d6119b6be1e490f44f708 --- /dev/null +++ b/src/Train_MLPMixer.ipynb @@ -0,0 +1,2476 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train_with_autoencoder_MLPMixer.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-28 20:46:20,021] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import string\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c0267850-3785-4be6-b134-b2a52bf55113", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "utils.mixco" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n", + "Setting batch_size to 128\n", + "[2023-10-28 20:46:28,070] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-10-28 20:46:28,071] [INFO] [comm.py:594:init_distributed] cdb=None\n", + "[2023-10-28 20:46:28,071] [INFO] [comm.py:625:init_distributed] Initializing TorchBackend in DeepSpeed with backend nccl\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "# ## UNCOMMENT BELOW SECTION AND COMMENT OUT DEEPSPEED SECTION TO AVOID USING DEEPSPEED ###\n", + "# accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n", + "# global_batch_size = batch_size = 128\n", + "# data_type = torch.float16 # change depending on your mixed_precision\n", + "\n", + "### DEEPSPEED INITIALIZATION ###\n", + "if num_devices <= 1 and utils.is_interactive():\n", + " global_batch_size = batch_size = 128\n", + " print(f\"Setting batch_size to {batch_size}\")\n", + " # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + " os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + " os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + " os.environ[\"RANK\"] = \"0\"\n", + " os.environ[\"LOCAL_RANK\"] = \"0\"\n", + " os.environ[\"WORLD_SIZE\"] = \"1\"\n", + " os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "else:\n", + " global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"] \n", + " batch_size = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "\n", + "# alter the deepspeed config according to your global and local batch size\n", + "if local_rank == 0:\n", + " with open('deepspeed_config_stage2.json', 'r') as file:\n", + " config = json.load(file)\n", + " config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + " config['train_micro_batch_size_per_gpu'] = batch_size\n", + " config['bf16'] = {'enabled': False}\n", + " config['fp16'] = {'enabled': True}\n", + " with open('deepspeed_config_stage2.json', 'w') as file:\n", + " json.dump(config, file)\n", + "else:\n", + " # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + " time.sleep(10)\n", + "deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 1896724\n", + "device: cuda:0\n", + "Distributed environment: DEEPSPEED Backend: nccl\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda:0\n", + "\n", + "Mixed precision type: fp16\n", + "ds_config: {'bf16': {'enabled': False}, 'fp16': {'enabled': True}, 'zero_optimization': {'stage': 2, 'contiguous_gradients': True, 'stage3_gather_16bit_weights_on_model_save': True, 'stage3_max_live_parameters': 1000000000.0, 'stage3_max_reuse_distance': 1000000000.0, 'stage3_prefetch_bucket_size': 10000000.0, 'stage3_param_persistence_threshold': 100000.0, 'reduce_bucket_size': 10000000.0, 'sub_group_size': 1000000000.0, 'offload_optimizer': {'device': 'none', 'nvme_path': '/scratch', 'pin_memory': True}, 'offload_param': {'device': 'none', 'nvme_path': '/scratch', 'buffer_size': 4000000000.0, 'pin_memory': True}}, 'aio': {'block_size': 26214400, 'queue_depth': 64, 'thread_count': 1, 'single_submit': False, 'overlap_events': True}, 'gradient_accumulation_steps': 1, 'gradient_clipping': 1.0, 'steps_per_print': inf, 'train_batch_size': 128, 'train_micro_batch_size_per_gpu': 128, 'wall_clock_breakdown': False, 'zero_allow_untested_optimizer': True}\n", + "\n", + "distributed = True num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "\n", + "# set data_type to match your mixed precision (automatically set based on deepspeed config)\n", + "if accelerator.mixed_precision == \"bf16\":\n", + " data_type = torch.bfloat16\n", + "elif accelerator.mixed_precision == \"fp16\":\n", + " data_type = torch.float16\n", + "else:\n", + " data_type = torch.float32\n", + "\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: 0qiAxQoaKN_interactive_bsl\n", + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=0qiAxQoaKN_interactive_bsl', '--subj=1', '--batch_size=128', '--no-blurry_recon', '--no-depth_recon', '--hidden_dim=4096', '--clip_scale=1.', '--blur_scale=100.', '--depth_scale=100.', '--max_lr=3e-4', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug', '--no-ckpt_saving']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # create random model_name\n", + " model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10))\n", + " model_name = model_name + \"_interactive_bsl\"\n", + " print(\"model_name:\", model_name)\n", + "\n", + " # global_batch_size and batch_size should already be defined in the above cells\n", + " # other variables can be specified in the following string:\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name={model_name} \\\n", + " --subj=1 --batch_size={batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=4096 \\\n", + " --clip_scale=1. --blur_scale=100. --depth_scale=100. \\\n", + " --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output blurry reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_recon\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to output depth reconstructions\",\n", + ")\n", + "parser.add_argument(\n", + " \"--blur_scale\",type=float,default=100.,\n", + " help=\"multiply loss from blurry recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--depth_scale\",type=float,default=100.,\n", + " help=\"multiply loss from depth recons by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--clip_scale\",type=float,default=1.,\n", + " help=\"multiply contrastive loss by this number\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=120,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--hidden_dim\",type=int,default=4096,\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir) and ckpt_saving:\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "# train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..1}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 2770 2770\n", + "---\n", + "\n", + "194 24960 24960\n" + ] + } + ], + "source": [ + "test_vox_indices = []\n", + "test_73k_images = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy())\n", + " test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy())\n", + "test_vox_indices = test_vox_indices.astype(np.int16)\n", + "print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices))\n", + "print(\"---\\n\")\n", + "\n", + "train_vox_indices = []\n", + "train_73k_images = []\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy())\n", + " train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy())\n", + "train_vox_indices = train_vox_indices.astype(np.int16)\n", + "print(train_i, (train_i+1) * batch_size, len(train_vox_indices))" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15724])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r')\n", + "\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").to(data_type)\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").to(data_type)\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768 #1024\n", + "# hidden_dim = 4096\n", + "seq_len = 1 #2 #32 " + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# if blurry_recon:\n", + "# from diffusers import AutoencoderKL\n", + "# autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "# autoenc.eval()\n", + "# autoenc.requires_grad_(False)\n", + "# autoenc.to(device)\n", + "# utils.count_params(autoenc)\n", + "\n", + "if blurry_recon:# or depth_recon:\n", + " from diffusers import VQModel\n", + " autoenc = VQModel.from_pretrained(\"/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae\", torch_dtype=data_type)\n", + " autoenc.eval()\n", + " autoenc.requires_grad_(False)\n", + " autoenc.to(device)\n", + " utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "120c8eee-9834-437d-bb60-b38faef50138", + "metadata": {}, + "source": [ + "#### downsampled images" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6d1ba8dd-64c2-4ac9-947e-725b7f2e3e50", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if blurry_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30]].to(device)\n", + " print(input_batch.shape)\n", + "\n", + " downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " print(re_upsampled_enc.shape)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "6390a3a8-2bef-4e81-9b82-e154d26a1e1d", + "metadata": {}, + "source": [ + "#### MiDaS depth" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f35573e2-95bf-463d-8937-68ad4c2c3c20", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " from controlnet_aux.midas import MidasDetector\n", + " \n", + " midas_depth = MidasDetector.from_pretrained(\n", + " \"valhalla/t2iadapter-aux-models\", filename=\"dpt_large_384.pt\", model_type=\"dpt_large\", cache_dir=\"/fsx/proj-fmri/shared/cache\").to(device)\n", + " midas_depth.model.eval()\n", + " midas_depth.model.requires_grad_(False)\n", + " midas_depth.model.to(device)\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ba3f9207-b98e-45da-baa6-5cfcfb2ae958", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if depth_recon:\n", + " if utils.is_interactive(): display(utils.torch_to_Image(images[[30]]))\n", + "\n", + " input_batch = images[[30,31]].float().to(device)\n", + " print(input_batch.shape)\n", + " \n", + " midas_emb = midas_depth.model(input_batch).unsqueeze(1)\n", + " print(midas_emb.shape)\n", + "\n", + " prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max()\n", + " print(prediction.shape)\n", + " \n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " midas_emb_size = prediction.flatten(1).shape[1]\n", + " print(\"midas_emb\", prediction.shape, prediction.min(), prediction.max())\n", + " print(\"midas_emb_size\", midas_emb_size)\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) \n", + "\n", + " if blurry_recon:\n", + " prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1)\n", + " prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half()\n", + " prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215\n", + " print(\"vae midas_emb\", prediction_enc.shape, prediction_enc.min(), prediction_enc.max())\n", + " \n", + " if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1)))" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,409,600 total\n", + "64,409,600 trainable\n", + "param counts:\n", + "64,409,600 total\n", + "64,409,600 trainable\n", + "torch.Size([2, 1, 15724]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "950,287,384 total\n", + "950,287,384 trainable\n", + "param counts:\n", + "1,014,696,984 total\n", + "1,014,696,984 trainable\n", + "b.shape torch.Size([2, 1, 4096])\n", + "torch.Size([2, 257, 768]) torch.Size([1]) torch.Size([1])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768):\n", + " super().__init__()\n", + " self.seq_len = seq_len\n", + " self.h = h\n", + " self.clip_size = clip_size\n", + " \n", + " # Initial linear layer to match the input dimensions to hidden dimensions\n", + " # self.lin0 = nn.Linear(in_dim, seq_len * h)\n", + " \n", + " # Mixer Blocks\n", + " self.mixer_blocks1 = nn.ModuleList([\n", + " self.mixer_block1(h, drop) for _ in range(n_blocks)\n", + " ])\n", + " self.mixer_blocks2 = nn.ModuleList([\n", + " self.mixer_block2(seq_len, drop) for _ in range(n_blocks)\n", + " ])\n", + " \n", + " # Output linear layer\n", + " self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True)\n", + "\n", + " # low-rank matrices\n", + " # self.rank = 500\n", + " # self.U = nn.Parameter(torch.randn(self.rank, out_dim))\n", + " # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank))\n", + " # self.S = nn.Parameter(torch.randn(out_dim))\n", + "\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + "\n", + " if blurry_recon:\n", + " # self.blin1 = nn.Sequential(\n", + " # nn.Linear(out_dim, 4096, bias=True),\n", + " # nn.LayerNorm(4096),\n", + " # nn.GELU(),\n", + " # nn.Linear(4096, 4096))\n", + " self.blin1 = nn.Linear(h*seq_len, 4096)\n", + " self.bgroupnorm = nn.GroupNorm(1, 256)\n", + " self.bupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128],\n", + " layers_per_block=1,\n", + " )\n", + "\n", + " if depth_recon:\n", + " # self.dlin1 = nn.Sequential(\n", + " # nn.Linear(h, midas_emb_size),\n", + " # nn.Sigmoid(),\n", + " # )\n", + " self.dlin1 = nn.Linear(h*seq_len, 4096)\n", + " self.dgroupnorm = nn.GroupNorm(1, 256)\n", + " self.dupsampler = Decoder(\n", + " in_channels=256,\n", + " out_channels=1,#128,\n", + " up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " block_out_channels=[32, 64, 128, 256],\n", + " layers_per_block=1,\n", + " )\n", + " \n", + " def mixer_block1(self, h, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(h),\n", + " self.mlp(h, h, drop), # Token mixing\n", + " )\n", + "\n", + " def mixer_block2(self, seq_len, drop):\n", + " return nn.Sequential(\n", + " nn.LayerNorm(seq_len),\n", + " self.mlp(seq_len, seq_len, drop) # Channel mixing\n", + " )\n", + " \n", + " def mlp(self, in_dim, out_dim, drop):\n", + " return nn.Sequential(\n", + " nn.Linear(in_dim, out_dim),\n", + " nn.GELU(),\n", + " nn.Dropout(drop),\n", + " nn.Linear(out_dim, out_dim),\n", + " )\n", + " \n", + " def forward(self, x):\n", + " # make empty tensors for blur and depth outputs\n", + " b,d = torch.Tensor([0.]), torch.Tensor([0.])\n", + " \n", + " # Initial linear layer\n", + " # x = self.lin0(x)\n", + " \n", + " # Reshape to seq_len by dim\n", + " # x = x.reshape(-1, self.seq_len, self.h)\n", + " \n", + " # Mixer blocks\n", + " residual1 = x\n", + " residual2 = x.permute(0,2,1)\n", + " for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2):\n", + " x = block1(x) + residual1\n", + " residual1 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " x = block2(x) + residual2\n", + " residual2 = x\n", + " x = x.permute(0,2,1)\n", + " \n", + " # Flatten\n", + " x = x.reshape(x.size(0), -1)\n", + " \n", + " c = self.clin1(x)\n", + "\n", + " # low rank linear to out dim cuts # params by nearly half compared to full linear mapping\n", + " # c = (x @ (self.V/100) @ (self.U/100)) + self.S\n", + " \n", + " c = self.clip_proj(c.reshape(len(c), -1, self.clip_size))\n", + "\n", + " if blurry_recon:\n", + " b = self.blin1(x)\n", + " b = b.reshape(len(b), 256, 4, 4)\n", + " b = self.bgroupnorm(b)\n", + " b = self.bupsampler(b)\n", + " \n", + " if depth_recon:\n", + " d = self.dlin1(x)#.reshape(len(x), 1, 32, 32)\n", + " d = d.reshape(len(d), 256, 4, 4)\n", + " d = self.dgroupnorm(d)\n", + " d = self.dupsampler(d)\n", + " \n", + " return c, b, d\n", + "\n", + "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=seq_len, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "# test that the model works on some fake data\n", + "b = torch.randn((2,seq_len,hidden_dim))\n", + "print(\"b.shape\",b.shape)\n", + "with torch.no_grad():\n", + " clip_, blur_, depth_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape, depth_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_steps 2339\n", + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,014,696,984 total\n", + "1,014,696,984 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size)))\n", + " print(\"total_steps\", total_steps)\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeyev2 run 0qiAxQoaKN_interactive_bsl\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': '0qiAxQoaKN_interactive_bsl', 'global_batch_size': 128, 'batch_size': 128, 'num_epochs': 12, 'clip_scale': 1.0, 'blur_scale': 100.0, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': True, 'num_devices': 1, 'world_size': 1, 'train_url': '/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar', 'test_url': '/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar'}\n", + "wandb_id: 0qiAxQoaKN_interactive_bsl\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.15.12 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231028_204841-0qiAxQoaKN_interactive_bsl" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run 0qiAxQoaKN_interactive_bsl to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeyev2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeyev2/runs/0qiAxQoaKN_interactive_bsl" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wandb_log = True\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " wandb_project = 'mindeyev2'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"global_batch_size\": global_batch_size,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"clip_scale\": clip_scale,\n", + " \"blur_scale\": blur_scale,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"ckpt_interval\": ckpt_interval,\n", + " \"ckpt_saving\": ckpt_saving,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " \"train_url\": train_url,\n", + " \"test_url\": test_url,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if True: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-10-28 20:48:51,902] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed info: version=0.9.5, git-hash=unknown, git-branch=unknown\n", + "[2023-10-28 20:48:53,263] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed Flops Profiler Enabled: False\n", + "[2023-10-28 20:48:53,265] [INFO] [logging.py:96:log_dist] [Rank 0] Removing param_group that has no 'params' in the client Optimizer\n", + "[2023-10-28 20:48:53,266] [INFO] [logging.py:96:log_dist] [Rank 0] Using client Optimizer as basic optimizer\n", + "[2023-10-28 20:48:53,267] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed Basic Optimizer = AdamW\n", + "[2023-10-28 20:48:53,268] [INFO] [utils.py:54:is_zero_supported_optimizer] Checking ZeRO support for optimizer=AdamW type=\n", + "[2023-10-28 20:48:53,269] [INFO] [logging.py:96:log_dist] [Rank 0] Creating torch.float16 ZeRO stage 2 optimizer\n", + "[2023-10-28 20:48:53,269] [INFO] [stage_1_and_2.py:133:__init__] Reduce bucket size 10000000\n", + "[2023-10-28 20:48:53,270] [INFO] [stage_1_and_2.py:134:__init__] Allgather bucket size 500,000,000\n", + "[2023-10-28 20:48:53,271] [INFO] [stage_1_and_2.py:135:__init__] CPU Offload: False\n", + "[2023-10-28 20:48:53,271] [INFO] [stage_1_and_2.py:136:__init__] Round robin gradient partitioning: False\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(64409600, False), (950031116, False), (256268, False)] \n", + "[2023-10-28 20:48:55,761] [INFO] [utils.py:785:see_memory_usage] Before initializing optimizer states\n", + "[2023-10-28 20:48:55,763] [INFO] [utils.py:786:see_memory_usage] MA 7.68 GB Max_MA 7.68 GB CA 7.71 GB Max_CA 8 GB \n", + "[2023-10-28 20:48:55,764] [INFO] [utils.py:793:see_memory_usage] CPU Virtual Memory: used = 72.0 GB, percent = 6.4%\n", + "[2023-10-28 20:48:55,940] [INFO] [utils.py:785:see_memory_usage] After initializing optimizer states\n", + "[2023-10-28 20:48:55,941] [INFO] [utils.py:786:see_memory_usage] MA 15.24 GB Max_MA 26.1 GB CA 26.62 GB Max_CA 27 GB \n", + "[2023-10-28 20:48:55,942] [INFO] [utils.py:793:see_memory_usage] CPU Virtual Memory: used = 72.0 GB, percent = 6.4%\n", + "[2023-10-28 20:48:55,943] [INFO] [stage_1_and_2.py:488:__init__] optimizer state initialized\n", + "[2023-10-28 20:48:56,073] [INFO] [utils.py:785:see_memory_usage] After initializing ZeRO optimizer\n", + "[2023-10-28 20:48:56,074] [INFO] [utils.py:786:see_memory_usage] MA 15.24 GB Max_MA 15.24 GB CA 26.62 GB Max_CA 27 GB \n", + "[2023-10-28 20:48:56,075] [INFO] [utils.py:793:see_memory_usage] CPU Virtual Memory: used = 71.99 GB, percent = 6.4%\n", + "[2023-10-28 20:48:56,078] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed Final Optimizer = AdamW\n", + "[2023-10-28 20:48:56,078] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed using client LR scheduler\n", + "[2023-10-28 20:48:56,079] [INFO] [logging.py:96:log_dist] [Rank 0] DeepSpeed LR Scheduler = None\n", + "[2023-10-28 20:48:56,080] [INFO] [logging.py:96:log_dist] [Rank 0] step=0, skipped=0, lr=[1.200000000000002e-05, 1.200000000000002e-05, 1.200000000000002e-05], mom=[(0.95, 0.999), (0.95, 0.999), (0.95, 0.999)]\n", + "[2023-10-28 20:48:56,081] [INFO] [config.py:960:print] DeepSpeedEngine configuration:\n", + "[2023-10-28 20:48:56,082] [INFO] [config.py:964:print] activation_checkpointing_config {\n", + " \"partition_activations\": false, \n", + " \"contiguous_memory_optimization\": false, \n", + " \"cpu_checkpointing\": false, \n", + " \"number_checkpoints\": null, \n", + " \"synchronize_checkpoint_boundary\": false, \n", + " \"profile\": false\n", + "}\n", + "[2023-10-28 20:48:56,082] [INFO] [config.py:964:print] aio_config ................... {'block_size': 26214400, 'queue_depth': 64, 'thread_count': 1, 'single_submit': False, 'overlap_events': True}\n", + "[2023-10-28 20:48:56,083] [INFO] [config.py:964:print] amp_enabled .................. False\n", + "[2023-10-28 20:48:56,084] [INFO] [config.py:964:print] amp_params ................... False\n", + "[2023-10-28 20:48:56,085] [INFO] [config.py:964:print] autotuning_config ............ {\n", + " \"enabled\": false, \n", + " \"start_step\": null, \n", + " \"end_step\": null, \n", + " \"metric_path\": null, \n", + " \"arg_mappings\": null, \n", + " \"metric\": \"throughput\", \n", + " \"model_info\": null, \n", + " \"results_dir\": \"autotuning_results\", \n", + " \"exps_dir\": \"autotuning_exps\", \n", + " \"overwrite\": true, \n", + " \"fast\": true, \n", + " \"start_profile_step\": 3, \n", + " \"end_profile_step\": 5, \n", + " \"tuner_type\": \"gridsearch\", \n", + " \"tuner_early_stopping\": 5, \n", + " \"tuner_num_trials\": 50, \n", + " \"model_info_path\": null, \n", + " \"mp_size\": 1, \n", + " \"max_train_batch_size\": null, \n", + " \"min_train_batch_size\": 1, \n", + " \"max_train_micro_batch_size_per_gpu\": 1.024000e+03, \n", + " \"min_train_micro_batch_size_per_gpu\": 1, \n", + " \"num_tuning_micro_batch_sizes\": 3\n", + "}\n", + "[2023-10-28 20:48:56,085] [INFO] [config.py:964:print] bfloat16_enabled ............. False\n", + "[2023-10-28 20:48:56,086] [INFO] [config.py:964:print] checkpoint_parallel_write_pipeline False\n", + "[2023-10-28 20:48:56,087] [INFO] [config.py:964:print] checkpoint_tag_validation_enabled True\n", + "[2023-10-28 20:48:56,087] [INFO] [config.py:964:print] checkpoint_tag_validation_fail False\n", + "[2023-10-28 20:48:56,088] [INFO] [config.py:964:print] comms_config ................. \n", + "[2023-10-28 20:48:56,088] [INFO] [config.py:964:print] communication_data_type ...... None\n", + "[2023-10-28 20:48:56,089] [INFO] [config.py:964:print] compression_config ........... {'weight_quantization': {'shared_parameters': {'enabled': False, 'quantizer_kernel': False, 'schedule_offset': 0, 'quantize_groups': 1, 'quantize_verbose': False, 'quantization_type': 'symmetric', 'quantize_weight_in_forward': False, 'rounding': 'nearest', 'fp16_mixed_quantize': False, 'quantize_change_ratio': 0.001}, 'different_groups': {}}, 'activation_quantization': {'shared_parameters': {'enabled': False, 'quantization_type': 'symmetric', 'range_calibration': 'dynamic', 'schedule_offset': 1000}, 'different_groups': {}}, 'sparse_pruning': {'shared_parameters': {'enabled': False, 'method': 'l1', 'schedule_offset': 1000}, 'different_groups': {}}, 'row_pruning': {'shared_parameters': {'enabled': False, 'method': 'l1', 'schedule_offset': 1000}, 'different_groups': {}}, 'head_pruning': {'shared_parameters': {'enabled': False, 'method': 'topk', 'schedule_offset': 1000}, 'different_groups': {}}, 'channel_pruning': {'shared_parameters': {'enabled': False, 'method': 'l1', 'schedule_offset': 1000}, 'different_groups': {}}, 'layer_reduction': {'enabled': False}}\n", + "[2023-10-28 20:48:56,090] [INFO] [config.py:964:print] curriculum_enabled_legacy .... False\n", + "[2023-10-28 20:48:56,091] [INFO] [config.py:964:print] curriculum_params_legacy ..... False\n", + "[2023-10-28 20:48:56,091] [INFO] [config.py:964:print] data_efficiency_config ....... {'enabled': False, 'seed': 1234, 'data_sampling': {'enabled': False, 'num_epochs': 1000, 'num_workers': 0, 'curriculum_learning': {'enabled': False}}, 'data_routing': {'enabled': False, 'random_ltd': {'enabled': False, 'layer_token_lr_schedule': {'enabled': False}}}}\n", + "[2023-10-28 20:48:56,092] [INFO] [config.py:964:print] data_efficiency_enabled ...... False\n", + "[2023-10-28 20:48:56,093] [INFO] [config.py:964:print] dataloader_drop_last ......... False\n", + "[2023-10-28 20:48:56,093] [INFO] [config.py:964:print] disable_allgather ............ False\n", + "[2023-10-28 20:48:56,094] [INFO] [config.py:964:print] dump_state ................... False\n", + "[2023-10-28 20:48:56,095] [INFO] [config.py:964:print] dynamic_loss_scale_args ...... None\n", + "[2023-10-28 20:48:56,095] [INFO] [config.py:964:print] eigenvalue_enabled ........... False\n", + "[2023-10-28 20:48:56,096] [INFO] [config.py:964:print] eigenvalue_gas_boundary_resolution 1\n", + "[2023-10-28 20:48:56,097] [INFO] [config.py:964:print] eigenvalue_layer_name ........ bert.encoder.layer\n", + "[2023-10-28 20:48:56,097] [INFO] [config.py:964:print] eigenvalue_layer_num ......... 0\n", + "[2023-10-28 20:48:56,098] [INFO] [config.py:964:print] eigenvalue_max_iter .......... 100\n", + "[2023-10-28 20:48:56,099] [INFO] [config.py:964:print] eigenvalue_stability ......... 1e-06\n", + "[2023-10-28 20:48:56,099] [INFO] [config.py:964:print] eigenvalue_tol ............... 0.01\n", + "[2023-10-28 20:48:56,100] [INFO] [config.py:964:print] eigenvalue_verbose ........... False\n", + "[2023-10-28 20:48:56,100] [INFO] [config.py:964:print] elasticity_enabled ........... False\n", + "[2023-10-28 20:48:56,101] [INFO] [config.py:964:print] flops_profiler_config ........ {\n", + " \"enabled\": false, \n", + " \"recompute_fwd_factor\": 0.0, \n", + " \"profile_step\": 1, \n", + " \"module_depth\": -1, \n", + " \"top_modules\": 1, \n", + " \"detailed\": true, \n", + " \"output_file\": null\n", + "}\n", + "[2023-10-28 20:48:56,102] [INFO] [config.py:964:print] fp16_auto_cast ............... False\n", + "[2023-10-28 20:48:56,103] [INFO] [config.py:964:print] fp16_enabled ................. True\n", + "[2023-10-28 20:48:56,103] [INFO] [config.py:964:print] fp16_master_weights_and_gradients False\n", + "[2023-10-28 20:48:56,104] [INFO] [config.py:964:print] global_rank .................. 0\n", + "[2023-10-28 20:48:56,105] [INFO] [config.py:964:print] grad_accum_dtype ............. None\n", + "[2023-10-28 20:48:56,105] [INFO] [config.py:964:print] gradient_accumulation_steps .. 1\n", + "[2023-10-28 20:48:56,106] [INFO] [config.py:964:print] gradient_clipping ............ 1.0\n", + "[2023-10-28 20:48:56,107] [INFO] [config.py:964:print] gradient_predivide_factor .... 1.0\n", + "[2023-10-28 20:48:56,107] [INFO] [config.py:964:print] hybrid_engine ................ enabled=False max_out_tokens=512 inference_tp_size=1 release_inference_cache=False pin_parameters=True tp_gather_partition_size=8\n", + "[2023-10-28 20:48:56,108] [INFO] [config.py:964:print] initial_dynamic_scale ........ 65536\n", + "[2023-10-28 20:48:56,109] [INFO] [config.py:964:print] load_universal_checkpoint .... False\n", + "[2023-10-28 20:48:56,109] [INFO] [config.py:964:print] loss_scale ................... 0\n", + "[2023-10-28 20:48:56,110] [INFO] [config.py:964:print] memory_breakdown ............. False\n", + "[2023-10-28 20:48:56,111] [INFO] [config.py:964:print] mics_hierarchial_params_gather False\n", + "[2023-10-28 20:48:56,111] [INFO] [config.py:964:print] mics_shard_size .............. -1\n", + "[2023-10-28 20:48:56,112] [INFO] [config.py:964:print] monitor_config ............... tensorboard=TensorBoardConfig(enabled=False, output_path='', job_name='DeepSpeedJobName') wandb=WandbConfig(enabled=False, group=None, team=None, project='deepspeed') csv_monitor=CSVConfig(enabled=False, output_path='', job_name='DeepSpeedJobName') enabled=False\n", + "[2023-10-28 20:48:56,113] [INFO] [config.py:964:print] nebula_config ................ {\n", + " \"enabled\": false, \n", + " \"persistent_storage_path\": null, \n", + " \"persistent_time_interval\": 100, \n", + " \"num_of_version_in_retention\": 2, \n", + " \"enable_nebula_load\": true, \n", + " \"load_path\": null\n", + "}\n", + "[2023-10-28 20:48:56,113] [INFO] [config.py:964:print] optimizer_legacy_fusion ...... False\n", + "[2023-10-28 20:48:56,114] [INFO] [config.py:964:print] optimizer_name ............... None\n", + "[2023-10-28 20:48:56,115] [INFO] [config.py:964:print] optimizer_params ............. None\n", + "[2023-10-28 20:48:56,115] [INFO] [config.py:964:print] pipeline ..................... {'stages': 'auto', 'partition': 'best', 'seed_layers': False, 'activation_checkpoint_interval': 0}\n", + "[2023-10-28 20:48:56,116] [INFO] [config.py:964:print] pld_enabled .................. False\n", + "[2023-10-28 20:48:56,117] [INFO] [config.py:964:print] pld_params ................... False\n", + "[2023-10-28 20:48:56,117] [INFO] [config.py:964:print] prescale_gradients ........... False\n", + "[2023-10-28 20:48:56,118] [INFO] [config.py:964:print] scheduler_name ............... None\n", + "[2023-10-28 20:48:56,119] [INFO] [config.py:964:print] scheduler_params ............. None\n", + "[2023-10-28 20:48:56,119] [INFO] [config.py:964:print] sparse_attention ............. None\n", + "[2023-10-28 20:48:56,120] [INFO] [config.py:964:print] sparse_gradients_enabled ..... False\n", + "[2023-10-28 20:48:56,121] [INFO] [config.py:964:print] steps_per_print .............. inf\n", + "[2023-10-28 20:48:56,121] [INFO] [config.py:964:print] train_batch_size ............. 128\n", + "[2023-10-28 20:48:56,122] [INFO] [config.py:964:print] train_micro_batch_size_per_gpu 128\n", + "[2023-10-28 20:48:56,123] [INFO] [config.py:964:print] use_node_local_storage ....... False\n", + "[2023-10-28 20:48:56,123] [INFO] [config.py:964:print] wall_clock_breakdown ......... False\n", + "[2023-10-28 20:48:56,124] [INFO] [config.py:964:print] world_size ................... 1\n", + "[2023-10-28 20:48:56,125] [INFO] [config.py:964:print] zero_allow_untested_optimizer True\n", + "[2023-10-28 20:48:56,125] [INFO] [config.py:964:print] zero_config .................. stage=2 contiguous_gradients=True reduce_scatter=True reduce_bucket_size=10000000 allgather_partitions=True allgather_bucket_size=500,000,000 overlap_comm=False load_from_fp32_weights=True elastic_checkpoint=False offload_param=DeepSpeedZeroOffloadParamConfig(device='none', nvme_path=PosixPath('/scratch'), buffer_count=5, buffer_size=4000000000, max_in_cpu=1,000,000,000, pin_memory=True) offload_optimizer=DeepSpeedZeroOffloadOptimizerConfig(device='none', nvme_path=PosixPath('/scratch'), buffer_count=4, pin_memory=True, pipeline=False, pipeline_read=False, pipeline_write=False, fast_init=False) sub_group_size=1000000000 cpu_offload_param=None cpu_offload_use_pin_memory=None cpu_offload=None prefetch_bucket_size=10000000 param_persistence_threshold=100000 model_persistence_threshold=sys.maxsize max_live_parameters=1000000000 max_reuse_distance=1000000000 gather_16bit_weights_on_model_save=True stage3_gather_fp16_weights_on_model_save=False ignore_unused_parameters=True legacy_stage1=False round_robin_gradients=False mics_shard_size=-1 mics_hierarchical_params_gather=False memory_efficient_linear=True\n", + "[2023-10-28 20:48:56,126] [INFO] [config.py:964:print] zero_enabled ................. True\n", + "[2023-10-28 20:48:56,127] [INFO] [config.py:964:print] zero_force_ds_cpu_optimizer .. True\n", + "[2023-10-28 20:48:56,127] [INFO] [config.py:964:print] zero_optimization_stage ...... 2\n", + "[2023-10-28 20:48:56,128] [INFO] [config.py:950:print_user_config] json = {\n", + " \"bf16\": {\n", + " \"enabled\": false\n", + " }, \n", + " \"fp16\": {\n", + " \"enabled\": true\n", + " }, \n", + " \"zero_optimization\": {\n", + " \"stage\": 2, \n", + " \"contiguous_gradients\": true, \n", + " \"stage3_gather_16bit_weights_on_model_save\": true, \n", + " \"stage3_max_live_parameters\": 1.000000e+09, \n", + " \"stage3_max_reuse_distance\": 1.000000e+09, \n", + " \"stage3_prefetch_bucket_size\": 1.000000e+07, \n", + " \"stage3_param_persistence_threshold\": 1.000000e+05, \n", + " \"reduce_bucket_size\": 1.000000e+07, \n", + " \"sub_group_size\": 1.000000e+09, \n", + " \"offload_optimizer\": {\n", + " \"device\": \"none\", \n", + " \"nvme_path\": \"/scratch\", \n", + " \"pin_memory\": true\n", + " }, \n", + " \"offload_param\": {\n", + " \"device\": \"none\", \n", + " \"nvme_path\": \"/scratch\", \n", + " \"buffer_size\": 4.000000e+09, \n", + " \"pin_memory\": true\n", + " }\n", + " }, \n", + " \"aio\": {\n", + " \"block_size\": 2.621440e+07, \n", + " \"queue_depth\": 64, \n", + " \"thread_count\": 1, \n", + " \"single_submit\": false, \n", + " \"overlap_events\": true\n", + " }, \n", + " \"gradient_accumulation_steps\": 1, \n", + " \"gradient_clipping\": 1.0, \n", + " \"steps_per_print\": inf, \n", + " \"train_batch_size\": 128, \n", + " \"train_micro_batch_size_per_gpu\": 128, \n", + " \"wall_clock_breakdown\": false, \n", + " \"zero_allow_untested_optimizer\": true\n", + "}\n" + ] + } + ], + "source": [ + "model, optimizer, train_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, lr_scheduler\n", + ")\n", + "# leaving out test_dl since we will only have local_rank 0 device do evals" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "469e6313-425f-45ed-875a-ecd5df343e31", + "metadata": {}, + "outputs": [], + "source": [ + "def add_saturation(image, alpha=2):\n", + " gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :]\n", + " gray_image = gray_image.unsqueeze(1).expand_as(image)\n", + " saturated_image = alpha * image + (1 - alpha) * gray_image\n", + " return torch.clamp(saturated_image, 0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0qiAxQoaKN_interactive_bsl starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n", + "│ in <module>:119 │\n", + "│ │\n", + "│ 116 │ │ │ │ │ # utils.check_loss(pixcorr) │\n", + "│ 117 │ │ │ │\n", + "│ 118 │ │ │ utils.check_loss(loss) │\n", + "│ ❱ 119 │ │ │ accelerator.backward(loss) │\n", + "│ 120 │ │ │ optimizer.step() │\n", + "│ 121 │ │ │ │\n", + "│ 122 │ │ │ losses.append(loss.item()) │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/accelerator. │\n", + "│ py:1815 in backward │\n", + "│ │\n", + "│ 1812 │ │ │ # deepspeed handles loss scaling by gradient_accumulation_steps in its `back │\n", + "│ 1813 │ │ │ loss = loss / self.gradient_accumulation_steps │\n", + "│ 1814 │ │ if self.distributed_type == DistributedType.DEEPSPEED: │\n", + "│ ❱ 1815 │ │ │ self.deepspeed_engine_wrapped.backward(loss, **kwargs) │\n", + "│ 1816 │ │ elif self.distributed_type == DistributedType.MEGATRON_LM: │\n", + "│ 1817 │ │ │ return │\n", + "│ 1818 │ │ elif self.scaler is not None: │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/utils/deepsp │\n", + "│ eed.py:176 in backward │\n", + "│ │\n", + "│ 173 │ │ # - zero grad │\n", + "│ 174 │ │ # - checking overflow │\n", + "│ 175 │ │ # - lr_scheduler step (only if engine.lr_scheduler is not None) │\n", + "│ ❱ 176 │ │ self.engine.step() │\n", + "│ 177 │ │ # and this plugin overrides the above calls with no-ops when Accelerate runs und │\n", + "│ 178 │ │ # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabli │\n", + "│ 179 │ │ # training loop that works transparently under many training regimes. │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/engin │\n", + "│ e.py:2053 in step │\n", + "│ │\n", + "│ 2050 │ │ │ │ │ and self.quantizer.any_precision_switch()): │\n", + "│ 2051 │ │ │ │ self._take_model_step(lr_kwargs, self.block_eigenvalue) │\n", + "│ 2052 │ │ │ else: │\n", + "│ ❱ 2053 │ │ │ │ self._take_model_step(lr_kwargs) │\n", + "│ 2054 │ │ │ │\n", + "│ 2055 │ │ │ report_progress = self.global_rank == 0 if self.global_rank else True │\n", + "│ 2056 │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/engin │\n", + "│ e.py:1960 in _take_model_step │\n", + "│ │\n", + "│ 1957 │ │ │ │ # https://nvidia.github.io/apex/advanced.html#gradient-clipping │\n", + "│ 1958 │ │ │ │ master_params = amp.master_params(self.optimizer) │\n", + "│ 1959 │ │ │ │ clip_grad_norm_(parameters=master_params, max_norm=self.gradient_clippin │\n", + "│ ❱ 1960 │ │ self.optimizer.step() │\n", + "│ 1961 │ │ │\n", + "│ 1962 │ │ if hasattr(self.optimizer, '_global_grad_norm'): │\n", + "│ 1963 │ │ │ self._global_grad_norm = self.optimizer._global_grad_norm │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/zero/ │\n", + "│ stage_1_and_2.py:1733 in step │\n", + "│ │\n", + "│ 1730 │ │ │ │ │\n", + "│ 1731 │ │ │ │ # Step 3:- run the optimizer if no offloading │\n", + "│ 1732 │ │ │ │ self.start_timers([OPTIMIZER_STEP]) │\n", + "│ ❱ 1733 │ │ │ │ self._optimizer_step(i) │\n", + "│ 1734 │ │ │ │ # Step 4:- get rid of the fp32 gradients. Not needed anymore │\n", + "│ 1735 │ │ │ │ self.single_partition_of_fp32_groups[i].grad = None │\n", + "│ 1736 │ │ │ │ del single_grad_partition │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/zero/ │\n", + "│ stage_1_and_2.py:1638 in _optimizer_step │\n", + "│ │\n", + "│ 1635 │ │ # self.optimizer.step(fp16_param_groups=[self.get_bit16_param_group(group_no) │\n", + "│ 1636 │ │ #else: │\n", + "│ 1637 │ │ # self.optimizer.step() │\n", + "│ ❱ 1638 │ │ self.optimizer.step() │\n", + "│ 1639 │ │ self.optimizer.param_groups = original_param_groups │\n", + "│ 1640 │ │\n", + "│ 1641 │ def step(self, closure=None): │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/lr_schedule │\n", + "│ r.py:69 in wrapper │\n", + "│ │\n", + "│ 66 │ │ │ │ instance = instance_ref() │\n", + "│ 67 │ │ │ │ instance._step_count += 1 │\n", + "│ 68 │ │ │ │ wrapped = func.__get__(instance, cls) │\n", + "│ ❱ 69 │ │ │ │ return wrapped(*args, **kwargs) │\n", + "│ 70 │ │ │ │\n", + "│ 71 │ │ │ # Note that the returned function here is no longer a bound method, │\n", + "│ 72 │ │ │ # so attributes like `__func__` and `__self__` no longer exist. │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/optimizer.p │\n", + "│ y:280 in wrapper │\n", + "│ │\n", + "│ 277 │ │ │ │ │ │ │ raise RuntimeError(f\"{func} must return None or a tuple of ( │\n", + "│ 278 │ │ │ │ │ │ │ │ │ │ │ f\"but got {result}.\") │\n", + "│ 279 │ │ │ │ │\n", + "│ ❱ 280 │ │ │ │ out = func(*args, **kwargs) │\n", + "│ 281 │ │ │ │ self._optimizer_step_code() │\n", + "│ 282 │ │ │ │ │\n", + "│ 283 │ │ │ │ # call optimizer step post hooks │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/optimizer.p │\n", + "│ y:33 in _use_grad │\n", + "│ │\n", + "│ 30 │ │ prev_grad = torch.is_grad_enabled() │\n", + "│ 31 │ │ try: │\n", + "│ 32 │ │ │ torch.set_grad_enabled(self.defaults['differentiable']) │\n", + "│ ❱ 33 │ │ │ ret = func(self, *args, **kwargs) │\n", + "│ 34 │ │ finally: │\n", + "│ 35 │ │ │ torch.set_grad_enabled(prev_grad) │\n", + "│ 36 │ │ return ret │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/adamw.py:17 │\n", + "│ 1 in step │\n", + "│ │\n", + "│ 168 │ │ │ │ state_steps, │\n", + "│ 169 │ │ │ ) │\n", + "│ 170 │ │ │ │\n", + "│ ❱ 171 │ │ │ adamw( │\n", + "│ 172 │ │ │ │ params_with_grad, │\n", + "│ 173 │ │ │ │ grads, │\n", + "│ 174 │ │ │ │ exp_avgs, │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/adamw.py:32 │\n", + "│ 1 in adamw │\n", + "│ │\n", + "│ 318 │ else: │\n", + "│ 319 │ │ func = _single_tensor_adamw │\n", + "│ 320 │ │\n", + "│ ❱ 321 │ func( │\n", + "│ 322 │ │ params, │\n", + "│ 323 │ │ grads, │\n", + "│ 324 │ │ exp_avgs, │\n", + "│ │\n", + "│ /admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/adamw.py:56 │\n", + "│ 6 in _multi_tensor_adamw │\n", + "│ │\n", + "│ 563 │ │ │ else: │\n", + "│ 564 │ │ │ │ exp_avg_sq_sqrt = torch._foreach_sqrt(device_exp_avg_sqs) │\n", + "│ 565 │ │ │ │ torch._foreach_div_(exp_avg_sq_sqrt, bias_correction2_sqrt) │\n", + "│ ❱ 566 │ │ │ │ denom = torch._foreach_add(exp_avg_sq_sqrt, eps) │\n", + "│ 567 │ │ │ │\n", + "│ 568 │ │ │ torch._foreach_addcdiv_(device_params, device_exp_avgs, denom, step_size) │\n", + "│ 569 │\n", + "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n", + "OutOfMemoryError: CUDA out of memory. Tried to allocate 3.54 GiB (GPU 0; 39.56 GiB total capacity; 26.52 GiB \n", + "already allocated; 2.00 GiB free; 35.94 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n", + "\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m119\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m116 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0m\u001b[2m# utils.check_loss(pixcorr)\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m117 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m118 \u001b[0m\u001b[2m│ │ │ \u001b[0mutils.check_loss(loss) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m119 \u001b[2m│ │ │ \u001b[0maccelerator.backward(loss) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m120 \u001b[0m\u001b[2m│ │ │ \u001b[0moptimizer.step() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m121 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m122 \u001b[0m\u001b[2m│ │ │ \u001b[0mlosses.append(loss.item()) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/\u001b[0m\u001b[1;33maccelerator.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mpy\u001b[0m:\u001b[94m1815\u001b[0m in \u001b[92mbackward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1812 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# deepspeed handles loss scaling by gradient_accumulation_steps in its `back\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1813 \u001b[0m\u001b[2m│ │ │ \u001b[0mloss = loss / \u001b[96mself\u001b[0m.gradient_accumulation_steps \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1814 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.distributed_type == DistributedType.DEEPSPEED: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1815 \u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m.deepspeed_engine_wrapped.backward(loss, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1816 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melif\u001b[0m \u001b[96mself\u001b[0m.distributed_type == DistributedType.MEGATRON_LM: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1817 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1818 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94melif\u001b[0m \u001b[96mself\u001b[0m.scaler \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[94mNone\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/accelerate/utils/\u001b[0m\u001b[1;33mdeepsp\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33meed.py\u001b[0m:\u001b[94m176\u001b[0m in \u001b[92mbackward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m173 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# - zero grad\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m174 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# - checking overflow\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m175 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# - lr_scheduler step (only if engine.lr_scheduler is not None)\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m176 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.engine.step() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m177 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# and this plugin overrides the above calls with no-ops when Accelerate runs und\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m178 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabli\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m179 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# training loop that works transparently under many training regimes.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/\u001b[0m\u001b[1;33mengin\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33me.py\u001b[0m:\u001b[94m2053\u001b[0m in \u001b[92mstep\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2050 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0m\u001b[95mand\u001b[0m \u001b[96mself\u001b[0m.quantizer.any_precision_switch()): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2051 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m._take_model_step(lr_kwargs, \u001b[96mself\u001b[0m.block_eigenvalue) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2052 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m2053 \u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m._take_model_step(lr_kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2054 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2055 \u001b[0m\u001b[2m│ │ │ \u001b[0mreport_progress = \u001b[96mself\u001b[0m.global_rank == \u001b[94m0\u001b[0m \u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.global_rank \u001b[94melse\u001b[0m \u001b[94mTrue\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2056 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/\u001b[0m\u001b[1;33mengin\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33me.py\u001b[0m:\u001b[94m1960\u001b[0m in \u001b[92m_take_model_step\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1957 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[2m# https://nvidia.github.io/apex/advanced.html#gradient-clipping\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1958 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mmaster_params = amp.master_params(\u001b[96mself\u001b[0m.optimizer) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1959 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mclip_grad_norm_(parameters=master_params, max_norm=\u001b[96mself\u001b[0m.gradient_clippin \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1960 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.optimizer.step() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1961 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1962 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(\u001b[96mself\u001b[0m.optimizer, \u001b[33m'\u001b[0m\u001b[33m_global_grad_norm\u001b[0m\u001b[33m'\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1963 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mself\u001b[0m._global_grad_norm = \u001b[96mself\u001b[0m.optimizer._global_grad_norm \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/zero/\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mstage_1_and_2.py\u001b[0m:\u001b[94m1733\u001b[0m in \u001b[92mstep\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1730 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1731 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[2m# Step 3:- run the optimizer if no offloading\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1732 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m.start_timers([OPTIMIZER_STEP]) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1733 \u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m._optimizer_step(i) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1734 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[2m# Step 4:- get rid of the fp32 gradients. Not needed anymore\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1735 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m.single_partition_of_fp32_groups[i].grad = \u001b[94mNone\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1736 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[94mdel\u001b[0m single_grad_partition \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/deepspeed/runtime/zero/\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mstage_1_and_2.py\u001b[0m:\u001b[94m1638\u001b[0m in \u001b[92m_optimizer_step\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1635 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# self.optimizer.step(fp16_param_groups=[self.get_bit16_param_group(group_no)\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1636 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m#else:\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1637 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# self.optimizer.step()\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1638 \u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.optimizer.step() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1639 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[96mself\u001b[0m.optimizer.param_groups = original_param_groups \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1640 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1641 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mstep\u001b[0m(\u001b[96mself\u001b[0m, closure=\u001b[94mNone\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33mlr_schedule\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mr.py\u001b[0m:\u001b[94m69\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 66 \u001b[0m\u001b[2m│ │ │ │ \u001b[0minstance = instance_ref() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 67 \u001b[0m\u001b[2m│ │ │ │ \u001b[0minstance._step_count += \u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 68 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mwrapped = func.\u001b[92m__get__\u001b[0m(instance, \u001b[96mcls\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 69 \u001b[2m│ │ │ │ \u001b[0m\u001b[94mreturn\u001b[0m wrapped(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 70 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 71 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# Note that the returned function here is no longer a bound method,\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 72 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[2m# so attributes like `__func__` and `__self__` no longer exist.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33moptimizer.p\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33my\u001b[0m:\u001b[94m280\u001b[0m in \u001b[92mwrapper\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m277 \u001b[0m\u001b[2m│ │ │ │ │ │ │ \u001b[0m\u001b[94mraise\u001b[0m \u001b[96mRuntimeError\u001b[0m(\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33m{\u001b[0mfunc\u001b[33m}\u001b[0m\u001b[33m must return None or a tuple of (\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m278 \u001b[0m\u001b[2m│ │ │ │ │ │ │ │ │ │ │ \u001b[0m\u001b[33mf\u001b[0m\u001b[33m\"\u001b[0m\u001b[33mbut got \u001b[0m\u001b[33m{\u001b[0mresult\u001b[33m}\u001b[0m\u001b[33m.\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m279 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m280 \u001b[2m│ │ │ │ \u001b[0mout = func(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m281 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[96mself\u001b[0m._optimizer_step_code() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m282 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m283 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[2m# call optimizer step post hooks\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33moptimizer.p\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33my\u001b[0m:\u001b[94m33\u001b[0m in \u001b[92m_use_grad\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 30 \u001b[0m\u001b[2m│ │ \u001b[0mprev_grad = torch.is_grad_enabled() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 31 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mtry\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 32 \u001b[0m\u001b[2m│ │ │ \u001b[0mtorch.set_grad_enabled(\u001b[96mself\u001b[0m.defaults[\u001b[33m'\u001b[0m\u001b[33mdifferentiable\u001b[0m\u001b[33m'\u001b[0m]) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 33 \u001b[2m│ │ │ \u001b[0mret = func(\u001b[96mself\u001b[0m, *args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 34 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfinally\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 35 \u001b[0m\u001b[2m│ │ │ \u001b[0mtorch.set_grad_enabled(prev_grad) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 36 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m ret \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33madamw.py\u001b[0m:\u001b[94m17\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m1\u001b[0m in \u001b[92mstep\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m168 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mstate_steps, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m169 \u001b[0m\u001b[2m│ │ │ \u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m170 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m171 \u001b[2m│ │ │ \u001b[0madamw( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m172 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mparams_with_grad, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m173 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mgrads, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m174 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mexp_avgs, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33madamw.py\u001b[0m:\u001b[94m32\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m1\u001b[0m in \u001b[92madamw\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m318 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m319 \u001b[0m\u001b[2m│ │ \u001b[0mfunc = _single_tensor_adamw \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m320 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m321 \u001b[2m│ \u001b[0mfunc( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m322 \u001b[0m\u001b[2m│ │ \u001b[0mparams, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m323 \u001b[0m\u001b[2m│ │ \u001b[0mgrads, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m324 \u001b[0m\u001b[2m│ │ \u001b[0mexp_avgs, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/optim/\u001b[0m\u001b[1;33madamw.py\u001b[0m:\u001b[94m56\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m6\u001b[0m in \u001b[92m_multi_tensor_adamw\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m563 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m564 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mexp_avg_sq_sqrt = torch._foreach_sqrt(device_exp_avg_sqs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m565 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mtorch._foreach_div_(exp_avg_sq_sqrt, bias_correction2_sqrt) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m566 \u001b[2m│ │ │ │ \u001b[0mdenom = torch._foreach_add(exp_avg_sq_sqrt, eps) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m567 \u001b[0m\u001b[2m│ │ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m568 \u001b[0m\u001b[2m│ │ │ \u001b[0mtorch._foreach_addcdiv_(device_params, device_exp_avgs, denom, step_size) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m569 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mOutOfMemoryError: \u001b[0mCUDA out of memory. Tried to allocate \u001b[1;36m3.54\u001b[0m GiB \u001b[1m(\u001b[0mGPU \u001b[1;36m0\u001b[0m; \u001b[1;36m39.56\u001b[0m GiB total capacity; \u001b[1;36m26.52\u001b[0m GiB \n", + "already allocated; \u001b[1;36m2.00\u001b[0m GiB free; \u001b[1;36m35.94\u001b[0m GiB reserved in total by PyTorch\u001b[1m)\u001b[0m If reserved memory is >> allocated memory\n", + "try setting max_split_size_mb to avoid fragmentation. See documentation for Memory Management and \n", + "PYTORCH_CUDA_ALLOC_CONF\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "l1 = nn.L1Loss()\n", + "\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " loss_depth_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + " test_loss_depth_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast(dtype=data_type):\n", + " optimizer.zero_grad()\n", + " \n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " for past in range(1):\n", + " past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device)\n", + " \n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " if use_image_aug: \n", + " image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + " past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select)\n", + " \n", + " voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + " \n", + " # past_voxel_ridge = model.ridge(past_voxel)\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " loss_clip *= clip_scale\n", + " loss = loss_clip\n", + " \n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item()\n", + " bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item()\n", + " \n", + " if blurry_recon:\n", + " with torch.no_grad():\n", + " # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False)\n", + " # random_samps = np.arange(batch_size//5)\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n", + " # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean\n", + " pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images)\n", + " # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n", + " # loss += (1 - pixcorr)\n", + " blurry_pixcorr += pixcorr.item()\n", + " # utils.check_loss(pixcorr)\n", + "\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + "\n", + " model.eval()\n", + " if local_rank==0:\n", + " with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " assert len(behav) == num_test\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()]\n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # random sample of 300\n", + " random_indices = torch.arange(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == 300\n", + "\n", + " if blurry_recon:\n", + " # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215\n", + " blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215\n", + "\n", + " if depth_recon:\n", + " # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128)\n", + " depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32)\n", + " depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half()\n", + " depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + " \n", + " voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + "\n", + " # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1)\n", + " \n", + " clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006)\n", + " test_loss_clip_total += loss_clip.item()\n", + " loss_clip = loss_clip * clip_scale\n", + " loss = loss_clip\n", + "\n", + " if blurry_recon:\n", + " downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False)\n", + " re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest'))\n", + " re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215\n", + " \n", + " loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc))\n", + " loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_))\n", + " test_loss_blurry_total += loss_blurry.item()\n", + " loss_blurry *= blur_scale\n", + " loss += loss_blurry\n", + " \n", + " # halving the batch size because the decoder is computationally heavy\n", + " blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1)\n", + " blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " pixcorr = utils.pixcorr(image, blurry_recon_images)\n", + " loss += (1 - pixcorr)\n", + " test_blurry_pixcorr += pixcorr.item()\n", + "\n", + " if depth_recon:\n", + " loss_depth = l1(depth_image_enc_, depth_image_enc)\n", + " # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc))\n", + " test_loss_depth_total += loss_depth.item()\n", + " loss_depth *= depth_scale\n", + " loss += loss_depth\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n", + "\n", + " utils.check_loss(loss) \n", + " test_losses.append(loss.item())\n", + "\n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " print(\"---\")\n", + " \n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " \"train/loss_depth_total\": loss_depth_total / (train_i + 1),\n", + " \"test/loss_depth_total\": test_loss_depth_total / (test_i + 1),\n", + " }\n", + " \n", + " if blurry_recon: \n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " axes[jj].axis('off')\n", + " \n", + " if wandb_log:\n", + " logs[f\"test/recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + "\n", + " if depth_recon:\n", + " # transform blurry recon latents to images and plot it\n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n", + " jj=-1\n", + " for j in [0,1,2,3]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224)))\n", + " axes[jj].axis('off')\n", + " if wandb_log:\n", + " logs[f\"test/depth_recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\")\n", + " plt.close()\n", + " else:\n", + " plt.show()\n", + " \n", + " progress_bar.set_postfix(**logs)\n", + " \n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "35cc1be7-bf76-4ad1-8c6a-de52bd013bf4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sat Oct 28 21:13:17 2023 \n", + "+-----------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |\n", + "|-------------------------------+----------------------+----------------------+\n", + "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|===============================+======================+======================|\n", + "| 0 NVIDIA A100-SXM... On | 00000000:10:1C.0 Off | 0 |\n", + "| N/A 33C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 1 NVIDIA A100-SXM... On | 00000000:10:1D.0 Off | 0 |\n", + "| N/A 30C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 2 NVIDIA A100-SXM... On | 00000000:20:1C.0 Off | 0 |\n", + "| N/A 34C P0 54W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 3 NVIDIA A100-SXM... On | 00000000:20:1D.0 Off | 0 |\n", + "| N/A 30C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 4 NVIDIA A100-SXM... On | 00000000:90:1C.0 Off | 0 |\n", + "| N/A 36C P0 53W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 5 NVIDIA A100-SXM... On | 00000000:90:1D.0 Off | 0 |\n", + "| N/A 35C P0 72W / 400W | 38467MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 6 NVIDIA A100-SXM... On | 00000000:A0:1C.0 Off | 0 |\n", + "| N/A 33C P0 50W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + "| 7 NVIDIA A100-SXM... On | 00000000:A0:1D.0 Off | 0 |\n", + "| N/A 31C P0 51W / 400W | 3MiB / 40960MiB | 0% Default |\n", + "| | | Disabled |\n", + "+-------------------------------+----------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=============================================================================|\n", + "| 5 N/A N/A 1896724 C ...3/envs/mindeye/bin/python 38464MiB |\n", + "+-----------------------------------------------------------------------------+\n" + ] + } + ], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f2690877-a431-44e8-a2ca-61f4b7397070", + "metadata": {}, + "source": [ + "# Retrieve nearest neighbor in the training set using test set data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b6b8feb-391d-437e-a5d9-a2088f1b1149", + "metadata": {}, + "outputs": [], + "source": [ + "annots = np.load(\"/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "612ac5aa-6f0f-45ad-809e-03df905d184c", + "metadata": {}, + "outputs": [], + "source": [ + "ii=2\n", + "all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices))\n", + "with torch.no_grad(), torch.cuda.amp.autocast():\n", + " for batch in tqdm(range(0,len(all_indices),512)):\n", + " if batch==0:\n", + " clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " else:\n", + " target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu()\n", + " clip_target = torch.vstack((clip_target,target))\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " voxel = test_voxel[[ii]].to(device)\n", + " image = test_image[[ii]].to(device)\n", + "\n", + " print(\"Original Image (test set)\")\n", + " display(utils.torch_to_Image(image))\n", + " \n", + " clip_target = clip_model.embed_image(image).cpu()\n", + " # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1)))\n", + " \n", + " voxel_ridge = model.ridge(voxel).unsqueeze(1)\n", + " clip_voxels, _, _ = model.backbone(voxel_ridge) \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " print(\"clip_voxels_norm\", clip_voxels_norm.shape)\n", + " print(\"clip_target_norm\", clip_target_norm.shape)\n", + " \n", + " sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), \n", + " clip_target_norm).flatten()).flip(0)\n", + " picks = all_indices[sortt[:5]]\n", + "\n", + " print(\"\\nNearest neighbors in training set\")\n", + " for ip,p in enumerate(picks):\n", + " display(utils.torch_to_Image(images[[p]]))\n", + " # print(utils.select_annotations([annots[int(p)]]))\n", + " if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0]\n", + "\n", + "print(\"\\n=====\\npredicted_caption:\\n\", predicted_caption)" + ] + }, + { + "cell_type": "markdown", + "id": "1473ddaa-5f2b-4448-9194-c7b0801d05db", + "metadata": {}, + "source": [ + "# Feed into Stable Diffusion XL for reconstructions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70e50e0d-c44f-4d56-939a-2943535e1747", + "metadata": {}, + "outputs": [], + "source": [ + "from diffusers import StableDiffusionXLPipeline\n", + "pipe = StableDiffusionXLPipeline.from_pretrained(\n", + " \"/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f\", torch_dtype=torch.float16, variant=\"fp16\", use_safetensors=True\n", + ")\n", + "pipe.to(\"cuda\")\n", + "pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "479e6994-3eaa-47d2-89a3-422c464fab36", + "metadata": {}, + "outputs": [], + "source": [ + "prompt = predicted_caption\n", + "recon = pipe(prompt=prompt).images[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dc48e1b-5842-4a29-963a-6469d943a72c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "print(\"Seen image\")\n", + "display(utils.torch_to_Image(image))\n", + "\n", + "print(\"Reconstruction\")\n", + "utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224))" + ] + } + ], + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/Train_MLPMixer.py b/src/Train_MLPMixer.py new file mode 100644 index 0000000000000000000000000000000000000000..4debaaee941b3d424509951c986b789c3cde776c --- /dev/null +++ b/src/Train_MLPMixer.py @@ -0,0 +1,1275 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +#from subprocess import call +#command = "jupyter nbconvert Train_MLPMixer-Copy1.ipynb --to python" +#call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import string +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +# ## UNCOMMENT BELOW SECTION AND COMMENT OUT DEEPSPEED SECTION TO AVOID USING DEEPSPEED ### +# accelerator = Accelerator(split_batches=False, mixed_precision="fp16") +# global_batch_size = batch_size = 32 +# data_type = torch.float16 # change depending on your mixed_precision + +### DEEPSPEED INITIALIZATION ### +if num_devices <= 1 and utils.is_interactive(): + global_batch_size = batch_size = 32 + print(f"Setting batch_size to {batch_size}") + # can emulate a distributed environment for deepspeed to work in jupyter notebook + os.environ["MASTER_ADDR"] = "localhost" + os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) + os.environ["RANK"] = "0" + os.environ["LOCAL_RANK"] = "0" + os.environ["WORLD_SIZE"] = "1" + os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +else: + global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + batch_size = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices + +# alter the deepspeed config according to your global and local batch size +if local_rank == 0: + with open('/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2.json', 'r') as file: + config = json.load(file) + config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) + config['train_micro_batch_size_per_gpu'] = batch_size + config['bf16'] = {'enabled': False} + config['fp16'] = {'enabled': True} + with open('/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2.json', 'w') as file: + json.dump(config, file) +else: + # give some time for the local_rank=0 gpu to prep new deepspeed config file + time.sleep(10) +deepspeed_plugin = DeepSpeedPlugin("/fsx/proj-fmri/ckadirt/MindEyeV2/src/deepspeed_config_stage2_cpuoffload.json") +accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' + +# set data_type to match your mixed precision (automatically set based on deepspeed config) +if accelerator.mixed_precision == "bf16": + data_type = torch.bfloat16 +elif accelerator.mixed_precision == "fp16": + data_type = torch.float16 +else: + data_type = torch.float32 + +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[5]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # create random model_name + model_name = ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + model_name = model_name + "_interactive" + print("model_name:", model_name) + + # global_batch_size and batch_size should already be defined in the above cells + # other variables can be specified in the following string: + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name={model_name} \ + --subj=1 --batch_size={batch_size} --no-blurry_recon --no-depth_recon --hidden_dim=4096 \ + --clip_scale=1. --blur_scale=100. --depth_scale=100. \ + --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug --no-ckpt_saving" + + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[6]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=True, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--blurry_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output blurry reconstructions", +) +parser.add_argument( + "--depth_recon",action=argparse.BooleanOptionalAction,default=True, + help="whether to output depth reconstructions", +) +parser.add_argument( + "--blur_scale",type=float,default=100., + help="multiply loss from blurry recons by this number", +) +parser.add_argument( + "--depth_scale",type=float,default=100., + help="multiply loss from depth recons by this number", +) +parser.add_argument( + "--clip_scale",type=float,default=1., + help="multiply contrastive loss by this number", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=120, + help="number of epochs of training", +) +parser.add_argument( + "--hidden_dim",type=int,default=4096, +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--seq_len",type=int,default=2, +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + + +# In[7]: + + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir) and ckpt_saving: + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[8]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +# train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..1}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=True, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=True, pin_memory=True) + + +# ### check dataloaders are working + +# In[9]: + + +test_vox_indices = [] +test_73k_images = [] +for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + test_vox_indices = np.append(test_vox_indices, behav[:,0,5].cpu().numpy()) + test_73k_images = np.append(test_73k_images, behav[:,0,0].cpu().numpy()) +test_vox_indices = test_vox_indices.astype(np.int16) +print(test_i, (test_i+1) * test_batch_size, len(test_vox_indices)) +print("---\n") + +train_vox_indices = [] +train_73k_images = [] +for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + train_vox_indices = np.append(train_vox_indices, behav[:,0,5].long().cpu().numpy()) + train_73k_images = np.append(train_73k_images, behav[:,0,0].cpu().numpy()) +train_vox_indices = train_vox_indices.astype(np.int16) +print(train_i, (train_i+1) * batch_size, len(train_vox_indices)) + + +# ## Load data and images + +# In[10]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +# f = h5py.File(f'{data_path}/betas_subj0{subj}_thresholded_wholebrain.hdf5', 'r') + +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").to(data_type) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").to(data_type) +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[11]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) +clip_seq_dim = 257 +clip_emb_dim = 768 #1024 +# hidden_dim = 4096 +#seq_len = 1 #2 #32 + + +# ### SD VAE + +# In[12]: + + +# if blurry_recon: +# from diffusers import AutoencoderKL +# autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# # autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +# autoenc.eval() +# autoenc.requires_grad_(False) +# autoenc.to(device) +# utils.count_params(autoenc) + +if blurry_recon:# or depth_recon: + from diffusers import VQModel + autoenc = VQModel.from_pretrained("/fsx/proj-fmri/shared/cache/models--microsoft--vq-diffusion-ithq/snapshots/3f796fb49ee559370dc638dea1d8116af131d993/vqvae", torch_dtype=data_type) + autoenc.eval() + autoenc.requires_grad_(False) + autoenc.to(device) + utils.count_params(autoenc) + + +# #### downsampled images + +# In[13]: + + +if blurry_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30]].to(device) + print(input_batch.shape) + + downsampled_image = nn.functional.interpolate(input_batch, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest') + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + print(re_upsampled_enc.shape) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(re_upsampled_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# #### MiDaS depth + +# In[14]: + + +if depth_recon: + from controlnet_aux.midas import MidasDetector + + midas_depth = MidasDetector.from_pretrained( + "valhalla/t2iadapter-aux-models", filename="dpt_large_384.pt", model_type="dpt_large", cache_dir="/fsx/proj-fmri/shared/cache").to(device) + midas_depth.model.eval() + midas_depth.model.requires_grad_(False) + midas_depth.model.to(device) + pass + + +# In[15]: + + +if depth_recon: + if utils.is_interactive(): display(utils.torch_to_Image(images[[30]])) + + input_batch = images[[30,31]].float().to(device) + print(input_batch.shape) + + midas_emb = midas_depth.model(input_batch).unsqueeze(1) + print(midas_emb.shape) + + prediction = utils.resize(midas_emb, 32) #/30).clamp(0,1).half() # 30 is roughly prediction.max() + print(prediction.shape) + + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + midas_emb_size = prediction.flatten(1).shape[1] + print("midas_emb", prediction.shape, prediction.min(), prediction.max()) + print("midas_emb_size", midas_emb_size) + + if utils.is_interactive(): display(utils.torch_to_Image(utils.resize(prediction, 224))) + + if blurry_recon: + prediction = utils.resize(midas_emb, 128).half().repeat(1,3,1,1) + prediction = (prediction / prediction.view(prediction.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(prediction)).half() + prediction_enc = autoenc.encode(2*prediction-1).latents * 0.18215 + print("vae midas_emb", prediction_enc.shape, prediction_enc.min(), prediction_enc.max()) + + if utils.is_interactive(): display(utils.torch_to_Image((autoenc.decode(prediction_enc/0.18215).sample / 2 + 0.5).clamp(0,1))) + + +# ### MindEye modules + +# In[17]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[18]: + + +time_embedding_dim = 512 + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1] + time_embedding_dim, out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +time_emb_test = torch.randn((2,1,time_embedding_dim)) +print(b.shape, model.ridge(torch.cat((b,time_emb_test),dim=-1)).shape) + + +# In[24]: + + +num_past_voxels = 15 + + + +# In[25]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, seq_len=2, h=4096, n_blocks=4, drop=.15, clip_size=768): + super().__init__() + self.seq_len = seq_len + self.h = h + self.clip_size = clip_size + + # Initial linear layer to match the input dimensions to hidden dimensions + # self.lin0 = nn.Linear(in_dim, seq_len * h) + + # Mixer Blocks + self.mixer_blocks1 = nn.ModuleList([ + self.mixer_block1(h, drop) for _ in range(n_blocks) + ]) + self.mixer_blocks2 = nn.ModuleList([ + self.mixer_block2(seq_len, drop) for _ in range(n_blocks) + ]) + + # Output linear layer + self.clin1 = nn.Linear(h * seq_len, out_dim, bias=True) + + # low-rank matrices + # self.rank = 500 + # self.U = nn.Parameter(torch.randn(self.rank, out_dim)) + # self.V = nn.Parameter(torch.randn(h * seq_len, self.rank)) + # self.S = nn.Parameter(torch.randn(out_dim)) + + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + + if blurry_recon: + # self.blin1 = nn.Sequential( + # nn.Linear(out_dim, 4096, bias=True), + # nn.LayerNorm(4096), + # nn.GELU(), + # nn.Linear(4096, 4096)) + self.blin1 = nn.Linear(h*seq_len, 4096) + self.bgroupnorm = nn.GroupNorm(1, 256) + self.bupsampler = Decoder( + in_channels=256, + out_channels=128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128], + layers_per_block=1, + ) + + if depth_recon: + # self.dlin1 = nn.Sequential( + # nn.Linear(h, midas_emb_size), + # nn.Sigmoid(), + # ) + self.dlin1 = nn.Linear(h*seq_len, 4096) + self.dgroupnorm = nn.GroupNorm(1, 256) + self.dupsampler = Decoder( + in_channels=256, + out_channels=1,#128, + up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + block_out_channels=[32, 64, 128, 256], + layers_per_block=1, + ) + + def mixer_block1(self, h, drop): + return nn.Sequential( + nn.LayerNorm(h), + self.mlp(h, h, drop), # Token mixing + ) + + def mixer_block2(self, seq_len, drop): + return nn.Sequential( + nn.LayerNorm(seq_len), + self.mlp(seq_len, seq_len, drop) # Channel mixing + ) + + def mlp(self, in_dim, out_dim, drop): + return nn.Sequential( + nn.Linear(in_dim, out_dim), + nn.GELU(), + nn.Dropout(drop), + nn.Linear(out_dim, out_dim), + ) + + def forward(self, x, idx = None): + print(idx) + # make empty tensors for blur and depth outputs + b,d = torch.Tensor([0.]), torch.Tensor([0.]) + + # Initial linear layer + # x = self.lin0(x) + + # Reshape to seq_len by dim + # x = x.reshape(-1, self.seq_len, self.h) + + # Mixer blocks + #print("x shape ", x.shape) + residual1 = x + residual2 = x.permute(0,2,1) + #print("residual 2", residual2.shape) + for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2): + x = block1(x) + residual1 + #print("xblo", x.shape) + residual1 = x + x = x.permute(0,2,1) + + x = block2(x) + residual2 + #print("xblo2", x.shape) + residual2 = x + x = x.permute(0,2,1) + + # Flatten + x = x.reshape(x.size(0), -1) + + c = self.clin1(x) + + # low rank linear to out dim cuts # params by nearly half compared to full linear mapping + # c = (x @ (self.V/100) @ (self.U/100)) + self.S + + c = self.clip_proj(c.reshape(len(c), -1, self.clip_size)) + + if blurry_recon: + b = self.blin1(x) + b = b.reshape(len(b), 256, 4, 4) + b = self.bgroupnorm(b) + b = self.bupsampler(b) + + if depth_recon: + d = self.dlin1(x)#.reshape(len(x), 1, 32, 32) + d = d.reshape(len(d), 256, 4, 4) + d = self.dgroupnorm(d) + d = self.dupsampler(d) + + return c, b, d + + +class TimeEmbedding(nn.Module): + def __init__(self, embedding_time_dim=512, num_past_voxels=15): + super().__init__() + self.embedding_time = nn.Embedding(num_past_voxels, embedding_time_dim) + self.num_past_voxels = num_past_voxels + self.embedding_time_dim = embedding_time_dim + + def forward(self, time): + # time is (batch_size,) + time = time.long() + time = self.embedding_time(time) + return time # (batch_size, embedding_time_dim) + + +#model.memory_encoder = MemoryEncoder(in_dim=voxels.shape[1], out_dim=4096, num_past_voxels=15, embedding_time_dim=512) +model.time_embedding = TimeEmbedding(embedding_time_dim=512, num_past_voxels=15) + +model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=seq_len, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim) +utils.count_params(model.backbone) +utils.count_params(model) + +# test that the model works on some fake data +b = torch.randn((1,seq_len,hidden_dim)) +print("b.shape",b.shape) +with torch.no_grad(): + clip_, blur_, depth_ = model.backbone(b) +print(clip_.shape, blur_.shape, depth_.shape) + + +# In[ ]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(np.floor(num_epochs*(num_train/num_devices/batch_size))), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(np.floor(num_epochs*(num_train/num_devices/batch_size))) + print("total_steps", total_steps) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# # Weights and Biases + +# In[ ]: + + +if local_rank==0 and wandb_log: # only use main process for wandb logging + import wandb + wandb_project = 'mindeyev2' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "global_batch_size": global_batch_size, + "batch_size": batch_size, + "num_epochs": num_epochs, + "clip_scale": clip_scale, + "blur_scale": blur_scale, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "ckpt_interval": ckpt_interval, + "ckpt_saving": ckpt_saving, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + "train_url": train_url, + "test_url": test_url, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # Main + +# In[ ]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + model.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[ ]: + + +model, optimizer, train_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, lr_scheduler +) +# leaving out test_dl since we will only have local_rank 0 device do evals + + +# In[ ]: + + +def add_saturation(image, alpha=2): + gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :] + gray_image = gray_image.unsqueeze(1).expand_as(image) + saturated_image = alpha * image + (1 - alpha) * gray_image + return torch.clamp(saturated_image, 0, 1) + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +l1 = nn.L1Loss() + +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + loss_depth_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + test_loss_depth_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + with torch.cuda.amp.autocast(dtype=data_type): + optimizer.zero_grad() + + #voxel = voxels[behav[:,0,5].cpu().long()].to(device) + #image = images[behav[:,0,0].cpu().long()].to(device).float() + + #past_15_voxels = voxels[past_behav[:,:,5].cpu().long()].to(device) # batch_size, 15, 15279 + #past_15_times = torch.Tensor([i for i in range(seq_len - 1)]).to(device) # 15 + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + image = images[behav[:,0,0].cpu().long()].to(device).float() + + past_15_voxels = voxels[past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + #for past in range(1): + # past_voxel = voxels[past_behav[:,past,5].cpu().long()].to(device) + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + if use_image_aug: + image = img_augment(image) + + clip_target = clip_model.embed_image(image) + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + past_voxel, _, _, _ = utils.mixco(voxel, perm=perm, betas=betas, select=select) + + for p in range(seq_len-1): + #print(past_behav.shape) #128, 15, 17 + #print(past_behav[:,p,-1]) + #print(past_15_voxels.shape) # 128, 1, 15724 + mask = past_behav[:,p,-1] == torch.ones_like(past_behav[:,p,-1]) + #print(mask) # 128 + past_15_voxels[mask, p, :] = torch.zeros_like(past_15_voxels[0, p, :]) + #print(past_15_voxels) + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) + #unsqueeze(1) # bz * 2, 1, 4096 + + # past_voxel_ridge = model.ridge(past_voxel) + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1), past_voxel_ridge.unsqueeze(1)), axis=1) + #print(voxel_ridge.shape) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge, idx = train_i) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_clip_total += loss_clip.item() + loss_clip *= clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)), labels, k=1).item() + bwd_percent_correct += utils.topk(torch.abs(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm)), labels, k=1).item() + + if blurry_recon: + with torch.no_grad(): + # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode() + random_samps = np.random.choice(np.arange(len(voxel)), size=batch_size//5, replace=False) + # random_samps = np.arange(batch_size//5) + blurry_recon_images = (autoenc.decode(blurry_image_enc_[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1) + # pixcorr_origsize_nanmean is computationally less intense than utils.pixcorr and uses nanmean instead of mean + pixcorr = utils.pixcorr_origsize_nanmean(image[random_samps], blurry_recon_images) + # pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images) + # loss += (1 - pixcorr) + blurry_pixcorr += pixcorr.item() + # utils.check_loss(pixcorr) + + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + if local_rank==0: + with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + # all test samples should be loaded per batch such that test_i should never exceed 0 + assert len(behav) == num_test + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()] + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # random sample of 300 + random_indices = torch.arange(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == 300 + + current_past_behav = past_behav[random_indices] + + past_15_voxels = voxels[current_past_behav[:,:seq_len-1,5].cpu().long()].to(device) # batch_size, 15, 15279 + past_15_times = torch.Tensor([i for i in range(seq_len-1)]).to(device) # 15 + + if blurry_recon: + # blurry_image_enc = autoenc.encode(2*utils.resize(image,128)-1).latent_dist.mode() * 0.18215 + blurry_image_enc = autoenc.encode(2*utils.resize(add_saturation(image),128)-1).latents * 0.18215 + + if depth_recon: + # depth_images = utils.resize(midas_depth.model(image).unsqueeze(1).repeat(1,3,1,1), 128) + depth_images = utils.resize(midas_depth.model(image).unsqueeze(1), 32) + depth_images = (depth_images / depth_images.view(depth_images.shape[0], -1).max(dim=1)[0].view(-1, 1, 1, 1).expand_as(depth_images)).half() + depth_image_enc = depth_images # autoenc.encode(2*depth_images-1).latents * 0.18215 + + clip_target = clip_model.embed_image(image.float()) + + + past_15_voxels = past_15_voxels.reshape(-1, past_15_voxels.shape[-1]) + past_15_times = past_15_times.repeat(voxel.shape[0], 1) + past_15_times = past_15_times.reshape(-1) + time_embeddings = model.time_embedding(past_15_times) + past_info_full = torch.cat((past_15_voxels, time_embeddings), dim=-1) + + positional_current_voxel = torch.zeros((voxel.shape[0], time_embeddings.shape[-1])).to(voxel.device) + voxel = torch.cat((voxel, positional_current_voxel), dim=-1) + voxel_ridge = model.ridge(torch.cat((voxel, past_info_full), dim=-2)) + voxel_ridge = voxel_ridge.view(int(voxel_ridge.shape[0]/seq_len), seq_len, hidden_dim) + + #voxel_ridge = model.ridge(voxel).unsqueeze(1) + + # voxel_ridge = torch.cat((voxel_ridge.unsqueeze(1),voxel_ridge.unsqueeze(1)),axis=1) + + clip_voxels, blurry_image_enc_, depth_image_enc_ = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + test_loss_clip_total += loss_clip.item() + loss_clip = loss_clip * clip_scale + loss = loss_clip + + if blurry_recon: + downsampled_image = nn.functional.interpolate(image, size=(8, 8), mode='bilinear', align_corners=False) + re_upsampled_image = add_saturation(nn.functional.interpolate(downsampled_image, size=(128, 128), mode='nearest')) + re_upsampled_enc = autoenc.encode(2*re_upsampled_image-1).latents * 0.18215 + + loss_blurry = (l1(blurry_image_enc_, blurry_image_enc) + l1(blurry_image_enc_, re_upsampled_enc)) + loss_blurry += l1(torch.var(blurry_image_enc), torch.var(blurry_image_enc_)) + test_loss_blurry_total += loss_blurry.item() + loss_blurry *= blur_scale + loss += loss_blurry + + # halving the batch size because the decoder is computationally heavy + blurry_recon_images = (autoenc.decode(blurry_image_enc_[:len(voxel)//2]/0.18215).sample / 2 + 0.5).clamp(0,1) + blurry_recon_images = torch.vstack((blurry_recon_images, (autoenc.decode(blurry_image_enc_[len(voxel)//2:]/0.18215).sample / 2 + 0.5).clamp(0,1))) + pixcorr = utils.pixcorr(image, blurry_recon_images) + loss += (1 - pixcorr) + test_blurry_pixcorr += pixcorr.item() + + if depth_recon: + loss_depth = l1(depth_image_enc_, depth_image_enc) + # loss_depth += l1(torch.var(depth_image_enc_), torch.var(depth_image_enc)) + test_loss_depth_total += loss_depth.item() + loss_depth *= depth_scale + loss += loss_depth + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item() + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item() + + utils.check_loss(loss) + test_losses.append(loss.item()) + + # if utils.is_interactive(): clear_output(wait=True) + print("---") + + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + "train/loss_depth_total": loss_depth_total / (train_i + 1), + "test/loss_depth_total": test_loss_depth_total / (test_i + 1), + } + + if blurry_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image((autoenc.decode(blurry_image_enc_[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + axes[jj].axis('off') + + if wandb_log: + logs[f"test/recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + if depth_recon: + # transform blurry recon latents to images and plot it + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + # axes[0].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + # axes[1].imshow(utils.torch_to_Image((autoenc.decode(depth_image_enc_[[0]]/0.18215).sample / 2 + 0.5).clamp(0,1))) + jj=-1 + for j in [0,1,2,3]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + jj+=1 + axes[jj].imshow(utils.torch_to_Image(utils.resize(depth_image_enc_[[j]].view(1,1,32,32).clamp(0,1), 224))) + axes[jj].axis('off') + if wandb_log: + logs[f"test/depth_recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}") + plt.close() + else: + plt.show() + + progress_bar.set_postfix(**logs) + + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# # Retrieve nearest neighbor in the training set using test set data + +# In[ ]: + + +annots = np.load("/fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_annots_curated.npy") + + +# In[ ]: + + +ii=2 +all_indices = np.unique(train_73k_images) #np.hstack((test_vox_indices[ii],train_vox_indices)) +with torch.no_grad(), torch.cuda.amp.autocast(): + for batch in tqdm(range(0,len(all_indices),512)): + if batch==0: + clip_target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + else: + target = clip_model.embed_image(images[all_indices[batch:batch+512]]).cpu() + clip_target = torch.vstack((clip_target,target)) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + voxel = test_voxel[[ii]].to(device) + image = test_image[[ii]].to(device) + + print("Original Image (test set)") + display(utils.torch_to_Image(image)) + + clip_target = clip_model.embed_image(image).cpu() + # clip_target_norm = torch.vstack((clip_target_norm, nn.functional.normalize(clip_target.flatten(1), dim=-1))) + + voxel_ridge = model.ridge(voxel).unsqueeze(1) + clip_voxels, _, _ = model.backbone(voxel_ridge) + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_voxels_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + print("clip_voxels_norm", clip_voxels_norm.shape) + print("clip_target_norm", clip_target_norm.shape) + + sortt = torch.argsort(utils.batchwise_cosine_similarity(clip_voxels_norm.cpu(), + clip_target_norm).flatten()).flip(0) + picks = all_indices[sortt[:5]] + + print("\nNearest neighbors in training set") + for ip,p in enumerate(picks): + display(utils.torch_to_Image(images[[p]])) + # print(utils.select_annotations([annots[int(p)]])) + if ip==0: predicted_caption = utils.select_annotations([annots[int(p)]])[0] + +print("\n=====\npredicted_caption:\n", predicted_caption) + + +# # Feed into Stable Diffusion XL for reconstructions + +# In[ ]: + + +from diffusers import StableDiffusionXLPipeline +pipe = StableDiffusionXLPipeline.from_pretrained( + "/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f", torch_dtype=torch.float16, variant="fp16", use_safetensors=True +) +pipe.to("cuda") +pass + + +# In[ ]: + + +prompt = predicted_caption +recon = pipe(prompt=prompt).images[0] + + +# In[ ]: + + +print("Seen image") +display(utils.torch_to_Image(image)) + +print("Reconstruction") +utils.torch_to_Image(utils.resize(transforms.ToTensor()(recon),224)) + diff --git a/src/Train_diffusion.ipynb b/src/Train_diffusion.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ef834ea87d4c2c03cb53a418ca8310de6c15b4fa --- /dev/null +++ b/src/Train_diffusion.ipynb @@ -0,0 +1,2712 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 16 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 1575109\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=test', '--subj=1', '--batch_size=16', '--n_samples_save=0', '--max_lr=3e-4', '--mixup_pct=.66', '--num_epochs=12', '--ckpt_interval=999', '--no-use_image_aug']\n", + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=test \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-4 --mixup_pct=.66 --num_epochs=12 --ckpt_interval=999 --no-use_image_aug\"\n", + "\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 16\n", + "batch_size 16\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c12edeea-1f34-4856-8ef1-29425d0bf15c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2770, 1, 17])\n", + "torch.Size([2770, 15, 17])\n", + "torch.Size([2770, 15, 17])\n", + "torch.Size([2770, 3, 17])\n", + "tensor([[6.1809e+04, 1.0000e+00, 6.0000e+00, 3.0000e+00, 2.0000e+00, 3.8760e+03,\n", + " 4.2000e+01, 0.0000e+00, 1.0000e+00, 1.2732e+03, 0.0000e+00, 0.0000e+00,\n", + " 1.0000e+00, 1.0000e+00, 0.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n", + "tensor([[5.6867e+04, 1.0000e+00, 5.0000e+00, 4.0000e+00, 4.8000e+01, 3.2350e+03,\n", + " 3.5000e+01, 0.0000e+00, 1.0000e+00, 1.0091e+03, 0.0000e+00, 0.0000e+00,\n", + " 1.0000e+00, 1.0000e+00, 0.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n", + "tensor([[5.0755e+04, 1.0000e+00, 1.1000e+01, 5.0000e+00, 3.8000e+01, 7.7870e+03,\n", + " 7.7000e+01, 0.0000e+00, 1.0000e+00, 1.1329e+03, 0.0000e+00, 0.0000e+00,\n", + " 1.0000e+00, 1.0000e+00, 0.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n", + "tensor([[1.9436e+04, 1.0000e+00, 6.0000e+00, 1.0000e+00, 1.4000e+01, 3.7630e+03,\n", + " 4.2000e+01, 0.0000e+00, 1.0000e+00, 1.7038e+03, 0.0000e+00, 0.0000e+00,\n", + " 1.0000e+00, 1.0000e+00, 0.0000e+00, 1.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n" + ] + } + ], + "source": [ + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " print(behav.shape)\n", + " print(past_behav.shape)\n", + " print(future_behav.shape)\n", + " print(old_behav.shape)\n", + " print(behav[0])\n", + " print(behav[1])\n", + " print(behav[2])\n", + " print(behav[3])\n", + " if train_i == 3:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 2770 2770\n", + "---\n", + "\n", + "1561 24992 24980\n" + ] + } + ], + "source": [ + "test_indices = []\n", + "test_images = []\n", + "for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + " test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "test_indices = test_indices.astype(np.int16)\n", + "print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "print(\"---\\n\")\n", + "\n", + "train_indices = []\n", + "train_images = []\n", + "for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + " train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "train_indices = train_indices.astype(np.int16)\n", + "print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# train_images = np.hstack((train_images, test_images))\n", + "# print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "param counts:\n", + "64,430,080 total\n", + "64,430,080 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 4096])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "# model.past_ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "# model.future_ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "370,276,116 total\n", + "370,276,116 trainable\n", + "param counts:\n", + "434,706,196 total\n", + "434,706,196 trainable\n", + "torch.Size([2, 4096])\n", + "torch.Size([1]) torch.Size([2, 8192])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim//8, bias=True)\n", + " # self.blin1 = nn.Linear(h, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " # self.clip_size = clip_size\n", + " # self.clip_proj = nn.Sequential(\n", + " # nn.LayerNorm(clip_size),\n", + " # nn.GELU(),\n", + " # nn.Linear(clip_size, 2048),\n", + " # nn.LayerNorm(2048),\n", + " # nn.GELU(),\n", + " # nn.Linear(2048, 2048),\n", + " # nn.LayerNorm(2048),\n", + " # nn.GELU(),\n", + " # nn.Linear(2048, clip_size)\n", + " # )\n", + " self.blurry_proj = nn.Sequential(\n", + " nn.LayerNorm(out_dim//8),\n", + " nn.GELU(),\n", + " nn.Linear(out_dim//8, blurry_dim),\n", + " nn.LayerNorm(blurry_dim),\n", + " nn.GELU(),\n", + " nn.Linear(blurry_dim, blurry_dim),\n", + " nn.LayerNorm(blurry_dim),\n", + " nn.GELU(),\n", + " nn.Linear(blurry_dim, blurry_dim)\n", + " )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " # b = self.blin1(x)\n", + " # blur_out = [self.blurry_proj[l](b).unsqueeze(1) for l in range(patches_per_image)]\n", + " # blur_out = torch.cat(blur_out, dim=1)\n", + " # return self.clip_proj(c.reshape(len(c), -1, self.clip_size)), self.blurry_proj(c).view(len(c), 4, 28, 28)\n", + " b = self.blurry_proj(x) \n", + " \n", + " return torch.zeros((1)), b\n", + "\n", + "model.backbone = BrainNetwork(h=1028, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=2048*4)#4*28*28) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,hidden_dim))\n", + "print(b.shape)\n", + "clip_, blur_ = model.backbone(b)\n", + "print(clip_.shape, blur_.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "592037e2-d833-4008-a735-93710bb61108", + "metadata": {}, + "source": [ + "### Blurry recon diffusion model?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "fbfaf67f-bc54-45ad-8762-b16fbac00f47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "1,140,258,820 total\n", + "1,140,258,820 trainable\n" + ] + } + ], + "source": [ + "from diffusers import UNet2DConditionModel, Transformer2DModel\n", + "\n", + "# diffuser = UNet2DConditionModel.from_pretrained(\"/fsx/proj-fmri/shared/cache/models--stabilityai--stable-diffusion-xl-base-1.0/snapshots/f898a3e026e802f68796b95e9702464bac78d76f/unet\",\n", + "# subfolder=\"unet\", variant=\"fp16\", use_safetensors=True)\n", + "\n", + "diffuser = UNet2DConditionModel(\n", + " in_channels=4,\n", + " out_channels=4,\n", + " norm_num_groups=32,\n", + " encoder_hid_dim=2048,\n", + " attention_head_dim=8,\n", + " block_out_channels=(2048//8, 2048//4, 2048//2, 2048),\n", + " )\n", + "\n", + "utils.count_params(diffuser)\n", + "\n", + "from diffusers import DDIMScheduler #DDIMScheduler #UniPCMultistepScheduler #DDPMScheduler\n", + "timesteps = 100\n", + "# noise_scheduler = EulerDiscreteScheduler(num_train_timesteps=timesteps, prediction_type=\"sample\")\n", + "noise_scheduler = DDIMScheduler(num_train_timesteps=timesteps, rescale_betas_zero_snr=True, timestep_spacing=\"trailing\", prediction_type=\"sample\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b8b3028d-e54e-42cb-a86f-8e48797ef5a1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 4, 32, 32])\n", + "torch.Size([2, 4, 2048])\n", + "--\n", + "torch.Size([2, 4, 32, 32])\n" + ] + } + ], + "source": [ + "bs = 2\n", + "num_embeddings = 4\n", + "embedding_dim = 32\n", + "\n", + "original_image = torch.randn(bs, num_embeddings, embedding_dim, embedding_dim)\n", + "noise = torch.randn(bs, num_embeddings, embedding_dim, embedding_dim)\n", + "\n", + "times = torch.LongTensor([5])\n", + "\n", + "noisy_image = noise_scheduler.add_noise(original_image, noise, times)\n", + "\n", + "encoder_hidden_states = torch.randn(bs,num_embeddings,2048) # (batch_size, num_embeddings, embedding_dim)\n", + "\n", + "print(noisy_image.shape)\n", + "print(encoder_hidden_states.shape)\n", + "print('--')\n", + "out=diffuser(noisy_image, # The currently predicted embeddings\n", + " timestep = times, \n", + " encoder_hidden_states = encoder_hidden_states, # Hidden states of the embeddings the denoising process is conditioned on\n", + " ).sample\n", + "print(out.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "408b5aae-9697-4ab6-bc39-aa97db5b488e", + "metadata": {}, + "outputs": [], + "source": [ + "model.diffuser = diffuser; del diffuser" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "1,574,965,016 total\n", + "1,574,965,016 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " # {'params': [p for n, p in model.past_ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " # {'params': [p for n, p in model.future_ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + " {'params': [p for n, p in model.diffuser.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.diffuser.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": {}, + "outputs": [], + "source": [ + "# params for wandb\n", + "if local_rank==0 and wandb_log: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'stability'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"clip_variant\": clip_variant,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if True: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": {}, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": {}, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")\n", + "\n", + "# noise_scheduler.alphas_cumprod = noise_scheduler.alphas_cumprod.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test starting with epoch 0 / 12\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/12 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAAB4OElEQVR4AZ29BYBdxfU/fq4/97dv3eKukIQECFCc0kKLlCotte+3wq/u9q23tNSV0pYChUKLF0vQhCTEdSO7WZfnbtf+n7kvu9ndLJT+Jzdvr8ydO3PmzJkzx4ajmdJ8og+eR/M6aPEaUlpIr1JxkOZ+cqasb+CenchLlCUqWpkVorOI9hAVznj3uk5a2Ew+kepkcpjEVYkziXgyJFK8ZKg0HKcDh2hXkqrsNm8jRSF3hSoZyg6RGZ9UoEzkIZo3i5aeSwsvI2eA3B5SRRpOUiJDf/g1xbcQK+V0ElmRJFi/OEHKE+Hzr528ZDuPzjuPNqzraI7Uz29d7hLrSBNMvVzMRivJkdxYtFIqF9Oyz7O2sXGNrHgVzlnMltVstlzIjfT0xHp68NUZkkZUGSTVRkKWuApxdpID5LJqNEPuSbeu96y6P7urdmMhUYQI4NYt6MeIeqwHC4iGZoI+HuYSpHmIwzsADUeizkCi6xQIULKfCmnKJ2hzkspWmQoZRSpxVEJtk0SToY+iADnA0qdQRwM1OEjkSNEokaVKlFKDlB2ZBn28gWJqqdYHKOB1oY+8GdKBRFXU0xA1TqiIgiaZhmHoJl81zIpmlnWjZFCFeFXgNY7neZPnBV7SBInjBEmQ7TZl5g7giMZi5PdRpUS8nfQQ8V565he07uPjlbT+Llx8buuswHveffNNb3/rb7/y4ZAv4JVDP7r6kbb2po+LFL6QMipVS1RVKZoiI0pjeYb1q4n2E52cUtKpi+MZWjtIpp84D9kcJAFnVSpk6JUXqLfI4D5qwa1idUDJghnO0VlTUNkqzCDCIJh/KTWdT0aQAIeRAvWnaM8o9SWoitGBpk/A/HRl0HQcAD0K+M9JHaVSnMyMwjvtYtEhSHaDK+i6ZmqagX9VXq9I6YQumhWXI+N0CE6nQ0Iem87zJDlsnDKpA4B2zTx5RPKo5DGJF6hUpUKJFJlkH3E8NZ5/NdEjVqXsn/zib6+9dvXczjqHXbLbPTcRhbxuU1dNI50eHdwIaqMxtBV5KuepUqYqT/kKeawOcBBJFlHKnNHAbqJ/xqkxTk12GkHfWxlqUAL0VQyRcVKGmwD96wBpVged/w6a/RbK8pTOUqnIyFffCB2O02je+ryXKDG5BugQHKgaOgAFY9yii/9TQskZKmTTRZ+9qiYkU9T1rGpm1HJcKxW0ilouVnt74+lEdz5vOl2+gK/F6fCRoXOGWiilsoWM+JNvkUeigJ1RTK5MZonyAzTaQ6VRctpJQ2VkEhx+Q1iaiq2odcC8+TectXh+fcRlUxSZFziTW79kVilXVA2jWKjoh3dtrG/YOTriMUjlGOh5jgS0qMpAhoQikWwWKM8c5P0W+qVKZLfggQyABH6B4zhBMSgE3fD66aJz6LofkeymbJ5SoxSNU75EowkaTVE2x6Y0AhZErBJRqI9W1i3cePYlC5atqKtrLsXTRrlQKpUqaiY0q6Vz3Zq6SKOTp2K5fPk7bjj4xFNTPq2SUKJKqpqzZzO+4ZKWVUspw8zr5TxfEUWypRLJw4djMrfV6T6q2BS3M+hy+NyiUyE+n8wc27NfPGelR1YJHxDVrJEno0AlnRxVioK02YmXCcVwfIfJN+/Y0WN92263OewOmyxKPGHC4TmOfD5fuVKtomPNSiExFGpeUBwdEU0yDQYyHLpGmnYKo0AZgGnoAAABFGlaarWmDeDhBOgBIhxAf/wC8QG910kYNKvCdOMnyF1HZZUqVSqVqVwG+KiqsfrIQAiRDIx31AA1Q2fmaPfA4eSuw29fuew7u/f1TiodNfzU//vgjZ/5cktj29b7Hr9+zUfmR+Y+cOcvJrJIYBYE4jVTL6nlTDafTZVTcUPLSzzvcdU7HYGB/j0xzH56UYgVQXZE8YTI8U7ODqAaI5XjA6o4a/4sM2ZyRlErFnU0ELQJoAf7gfEHJsNDJtpUXl3V6z9067esDxvEl2QHbhu6oQqibGpklymWimm6CdrHFRMLz175852b9TyVeYZumAbyRUphtFrvA7I16PvO6IDl4yBGDyEhZ43+sC607gD9a6yUdXXqJ0A0l2j9BXTZ+6llPgWWUpqoO8fmaD7K5nAdqMCT3UlBifwm65gTI5RKWWNwvKBeoh/v3jd+deovvjXw4pPlKzZSY9uv3/POf7NpiCXgx6xOCoS4hmazISz7ecVe5tKHunc/NxI9QZJALUvpoqsWDMdjL2yu9gyTVrZQECQBTWLdzhAvZLEJoqjb1Gq1XKqW0xo4BECNS2N4kCyS5CTRTYb5zlhq+b2PvMq+zFJlcOz42Nhwsk3mZV43dY6kcmZsrA+g1qmiVkg494KzRsEyjVJGorQ1kWBKH6qB0OJYMAg8VjOAiBmLFLuJnAKN6Iww4Ck6ACiPXxwtRL0W22p9ffrP995Fb76JGjcQ767NniB4RgMKCVLMD9wkEXDPk6oz9OcENhpOnKSDKPHk9KJOXa89p/2KS5a3tr93yYol3oAgKR7ZBsA7xqGPbMDJOg81BMz57d7mtmBdfbPf49338DP/vo/QrRg3b62j2UvP+dv3vjWYpTTw7oxhW0+EAyAR+/dvS/WYff00epISfWSUKWzQ7DCZNsaJS8ZZpcpVr+yLPr9laKK+8aFtLzz/tKYuaWtrwDTQGAgd3jlYDQ+ie/kquVWutCLkJ4r2UUymuE65Mo3kCAOxloA+ADeqFLZ4xzVET1xGhSBpa6jCU8pJq0foy+2/WX7RdcAOu5yY27iwrlO5OLTQ6fbM6licSHF//vMvxwujL/6NvngPbe766ALwIIKGcRkr5H85WHwpWxaUygXBPYsb0qGiUzQcUqEjkxE+cPMrvkYq7Z0oYNJJ6Fb6wUJa0tpb5+7lpUJJu3RsbAEnODhudWRR86SMdgxik2SDJK1kM1SPKPgc/guvfde3fvtHdICT6ILLrnYr3pNRSgOD0GAgPoAN1LcSmhy0bhTQAYd2maPHae8e6uphrDSwbwlKz5FSRz432SrNStUmyZ6FCxe/uOnp8Tpox44e9nopm4rZFDnmcffgKzH2CUywXjJTuT4geL7AQJ/BCNBOT5vADuTBgTagVpcQPfluyq+nxiaSWyjJk8NFq6Kdl579EZaJqH8k1bm6xekM2JSAKMkFtbL+/DdN7gCWyVh84Z0Lli/0NzUIvFl69LkEDXmpxUnt1Lu+/8PyWL3uEsHKORo/8JmvUZQuedPN9++9k704Jd1AN62msI1sgBnmLm1A5/t0vdmsGlqZrxb9FtEAiJBsaC9Hpo61IZ6WkKFaybV1nDOH6AgRxt/Cs1aVjCEMO7YYqR14DS3SGejbLAKQro2Aj32frWImpy5gaJykDLkNCtZlG+1Rl79pw4Y3NbfN27lr50P33g06vH3LC8cPv2qXTFOvGEWMMTo6qYhHX/jlOif1F9goH7WWb+nxp2+zvu21vt0B4iOR9gOKoMpYMYBSZ8mfo9mV5TXoHz+y70c//q5PqtdVGY3RZTOVVzft76brP073/2l8BumkljaqpPfGpb1lkcocffc469yGAC2ak5hz83fPA07I55H26Nu+Sc+NLL/2G/ff83/j1Rn/61hNt7+Pgjp5sLwTQEjJ1KJldbvAaflyYyG7PJWLEN1CtIUIpYe8DKp6mfJpyqTiAa/XxkmVbOVn9976p2/efuX7325vcGbMl1IyVQFvwL3M+hTryoBO6wu0tMwGg1KbA6ZBv1YjQHS/SvkucmW3Lcw2LV1zcTBSv2HDRevXn3/RxVcdP3L04Ufu7Tu6Z7z60/9uOp7/2uf/90s/+NWw9enJj1dY9cE4Q8oQvaXv89f5XriWtp2QGNHH6MWUPlJOs8dEf/rT70Z6B9KAOieqVORksVrievMuwrxDC4h2skyCh+pEsmM0u0lQSAPWvcg6faSRRk7ShfPovPbl5O/q2UP//DWy7/3nN9hb09Kvvks+FzlV4itkVKnMZu0kx+8Qi8eyJ9qHDlw1p27RFavrn9iJbngWCAj+EAhRoVKK0g5KOJKC7s4HxlqXL/n0X7/maagviL1ZGhYWWvTHQVyRXCY5DVoi0JteZYKZonWgGzDcpqd2EKIGOjbCpDfccGHk6RfK1dmz53nb2nx1zbYl1BSwLy/GlX8nB4ZitRE5vYQKsIMrS2dA/8vW8MRTTGJDFgosavj+WDXRQqEjtTIKlCnSU6XN3yP62Xc+//0f/2ZK0cC6hjaqBzcXYvBKWw8X+ajdRbKN2OISbCYml6PWA3yhh7ZfRPlF8fiLx2ddwm4uPJsO77CeTv154kn62FvZkr1QoIoB7prAXPMl6vrlVZFtS+fR4eSdi/8EkUawqTfRfzEdM8FYslV6TiBRIJstRbo9UpcMBPKexgYSNE3Kc4Jt2SqK8TRqJ0ceiw0KCXRhyTWX8kA1+/gyaIYO2DiXfH53AfOmRaZjuWh/d9TpyBWyKBj1soliIOxpa64LR2NxhrZnJPRwdHjXrHFITDxfZnEIgBA6AKgENMZ5Rg4O13KULGqVp36TsqPJW7/yw4kXT50AuaMxciRIBu8N7LFSRCG/BKrsEbWcTKZ9co0SLL8uHvrrv05lzo2cOpn25x8/obPaaG4DmUVQf/aQM2jgZUdiW4NMOYWGRNLStCaUcC0hp4ORSqPCOKuKRKUCW+2X7IVqqagZRcgNDK7K8TpWCB1N1JGiGNj6NNlN8grUNuC2UR5ABwRC1qJyhg74wu//tH3zNnn77wEQJCxlDhw+ms8G5y09T/JG9LJglF0BLjy3LigeYrxNt0XQrbzsx09MbBcf2XvB12994pu3T9xnj5b7PHsxZBl3D2Di2MRxmNCAXAdXWb2NQZenRI5u+shVk188fV4t0rGj5K1QFcMBjZhFy/xOH78mXO20qaZPPiHxL5zODRQ49L926Vdf/82pewMD7AStH+++03k/98lT51csJXeOTp4MB+jsCI0USXASn6WjKhlHaHmQAi4yeqmI74ukZqkM4mdQNZeJBLv9kcaA3zCEqshBgBleM0dwhvS8n9IxaszShbzc9EICzTctylQ/zmqfrgPOPnnzamdb5/xz5LWhB3bGkznrYYEGRwaP7/n3Sd4I+W1cNVfVkymvUWjE6AMptPh0/KJdgKbXmluwKKgLN4R9UjqnGlYelwOzqJpwUVOe1SBqMaN1FtK/6Y/U30Nb51t9kqH6ZOfwHhT2WilFublkc7Np4NqW6xaqnbZSu78ctvlcfm+0IE/pgOQTX5HpV5NLQv0UhgKSSmqteZOf4vyJ/bUbQiMNtFIyycQBNEB6F40eo/2DtCpGGYxRa23Pl0lJUjZOsQDZ+UNOTwvv4UEg8YokKs1Su6tuiF9X3jFC7VXqTOheScfSNaOBzcxmvhzb+p3wlBFw7Y1t137ivd35PqdPufIDN/B/e/yFoX5gq0xjHB0ffnm/O+2K1LtIKqjabjM/IMvkLLElVWAcpYAWqC2AZ/DkDYSD4YjNXtVVPVdMz25reLgiqa6xRL54jBgBR29dD8mBh/jz513V0LKGXLGSbKZbpD6P3q9AILKfnpkGHOuygUKLqTFAc+b84srhszsERdZkR9Km6B67UipOAap3baDOQI0mpXYGfYWnsECFk5TKTHo09XRsmAo62RLESwzZsUTt7qF9Fhd0wlo8TowiTxbcClb7uuTa5/C7vVWHQ8bCsOoyPaBIG3xH5jvInSafnfOsX59Y9nIepNKktu/kO6dNwqsvOzsupVWzEDF9zXPr5y+ds2uoP8uGTEWndI5OxE8GJN0t2ouG7YSmZbCwrEEcv7XaAPQ4WIVF8jl8LqfbNMtqVVX1qk1291WLRY4DGR62WEgg4m7Mi6vcHfMvbXEF4pzSp6mZik9NOitU10rca3RAiUISdSq03nfZgkFbfZrEEsk50dSL0X177js1AFqIrt1I7/ziZ4smajcpORn/4cOcYSNvB5WOUrk06emkUwxTNQ1RPhlg+QWSoowrQeuAFO8m+uOknLiPQ4zSgoGRVDojgO0tKZJTEyBK5kSPEJLtcUcFAoMQ5yv5d7zM9zVUotE6NrNM5oIW0MjcfE9lk4f3RLRAoM697G1zX/r3JgCLYxRvIE8PjhR2CEcCLt70NHRJsmoDbmEKrDB0LlqTKmqF5iousgfrgvVNkUi9ouQg6pBETlDsr/Z15zFXjVcdJyk/Lb/uGm/DvCqvuCp2STD744HSqLNMdc3UFmJyzNvGs0/8TdPh39JhSK4pUU+5CmNIcv00tpc+9u+JPKAZ9LPn6eHn//fl1P/86Os3fPab97FnYTZBQcrbbKd6O3kbaeV8iBpdf70nf/pN6wyAxsgWwLGBL7UG64h1X7d+Af13Wjj0rEVCa+/2E219SZ+/MgqJhz0g8k5FkJySwNvMuQI3n7NLYAwry2Vh25/9UbnAVCT8+ac7oI7qP0/PGM8pmlhX8R0vYHZX3bz70o+cdf9vX8Xi1qCyRgMlGiijCQZ5sVKLUAUPMLhilIYAyBoEwBoXeMUINTXNiTQ3Nzc2QC5YLlc0vZrKpGPpaq2uE7+ds+vqZrWgEME0wCfwFXs1J5dKksZyaBEKxyeyznRyx410wmJ20f013nNarl6iVx64atEtBfqm9aSe0ZMmkeplahEopBBwqM6Z/+D3L4smG/5059OPx4aaiDqsQYy6Av6cNavtmFYu0SDRGvKuplbMEVXInDiVD2Yds0SzHCynHeWYy25zoieYMpEaea6DxDAfzNGs/bn1BytHD1QGi4CVwjpglVX2ChpVaDRZlnUarOYrRbbG44s0n6e3t9Zv6R8F3C2gsPkTye0kf5h4D0EkXaijgd1sbCIDqusXyN9GdZ2rnKFAS1uTVinkslw+r+ze32W9OuXnwmXzJIWriiWB0+0ldykGWWq1mhY4VpjhZ+xym4P6AN8Z05NsdvwP6ZWXutY7ur/4Tvre3azFC3NUB/m5weRRkCQ7OIoUydPT505G/29l6we227anu4FMaCaa7BYWz1l/8c4dr0bLLx+ayuxhKLip0Dinud7vMhwOyIaqAYPzy86Im7fbqgWfHucMOcOrFc7n4uQVnNlicgWhqSq1nuxuK45laCDHOlg8xbVgmCXYoKoalMDtHLs0snR4L50TMm39TFwhW+MFIHFgeAYoFA7KAZMXqi5bHnQVYxh9gEOxkdNjc/jroYbx+b3Qmhd5zY0qzpTaQ4rBQQau8ZwIhrecUSsFo1I2OSawNdzkjdCsm65c+vzg7j37hs4s4D9CH6+4G5vFP3Vv24TpnsI58qkEwZALzcHiQWIiHahDzGLOzFTMHO9VtCZyS4TaADsbNnz+212HR1payqHjOz1UTk2qATqgRJorYC83KgLw0c7bPXbTpSgeu6iIJq9ADA7RKyeapmnnuQBvRky+qMn1ul0s2bBuoNEcE76JjHYAwcaI0MU2C43RAYB3LxHI3hBmm7Hff+7aNoft0W/cg7xtcygS8S9esdI5O8Q5oWyu5k4+FdqkQjCCToQsQK6j1tVvX3T2OwRZWrF00ZanH8hkC51zV9ILr0yqPztFX85qxdAt8aaN0/nEaDUxqCZGBTWhYnaHTj5IdYto7Xvev2hDYcOv/vbnA90nYt3qtEL+4+WKq164/fuMV6ZdDOs5SK1dJEZIwIIanJZle1HMjuk5QYNGqcTPwjKU5knUPGvrd20rW+W/H/DN8iX/MVLtf+iwBSqMjABDfyZ5LvXn21bM1Xw+QbRXgzbVI/MOQeRMUTKgYuHydtgCSJEmiQ/xZoATA5x3sdHgi0NQ5qBjljhApD4L6BlrIpestQG+kBg3YbDa96Ef/vPqua5vP/hVIaZh5S3adEddmAsqnKBiyWeGxNb5D0lFykI66KW3fPS2C6/7VKaYRb+jS5BmRejndz72qzvus65O/8xHj8vRshEUq4aUr4welUf71cQwr+vQQ1MdhX3kaaGVdmf94rbmt1yZatr36l3GpteU458uePyshda9g17ew1aLINkoE3SNz5GUJzuGKRgb4L5OZSgps2q1pGpYGUBoQxmlyW//0Eb/ulZAwrUiFFTaG4eWdKYGqrldIA0Y66wjWQdwB/OjfbsORFYsCvubW2zN5QjHSwJWzZKZEoslgy+YtmolNhAtPFYxFVPiPAG/e3YDOqDXZFUaZiMAaK5bk056HP3xEdR0anrkWF78xv9dc9nihZ2NbsHHu2Qz3KHLQZ6322e/96W/9jz2wP7aG3/+4KcJx6SkuKm9Y849f73rpve8e9JtOh/g6O8uCGTXh/S4f3S/NtZrJotMoAPJjpvcLRSp94WgT3Ny5eWLFwv2yvbES8egZkTFZ0rrvk5L3rzQ3rzYJrhtUthT3PaN/3l+aZSZwxQt8oiXbCChJvkyjBNVINA3SEuQnqZSiY1gkP4SlfLrvHM+ex0yA8q6VxWaRM+cUHjF7OzeTD4bxRoKj3RyFx3uaL2tKMvpseyJTO/BcnFOblb3oa7U8FDkZOy957eoF9ryJ557cXT7UIUSaIZASYg4y7TQR8U6Gu1jY4hRXvZZHKgjztHpZ0C/1tjhERro7m3ymgrjzjpMu5+TI7JQzznqJqBfyzntt6kZU7V58ZWXT7vfjusTeV1I6hXTGKPiWK6UR9GQZ4KDLlsq/Yq4AqpcXdN5SbZ7Q36hmWOYMzq+7phUIgjaBz/+dvLMy0kRh8HZCwGe682Nks/DyDnah/lJthgPXGIBD723hDkAyFclo8SQsNZu0Di9Kei0e1A26wDwAwJx0Pb4FVvEW7VpWHJAvUZOn2Z3ld0+wW7TJRgeaJTKff+RP+47+RRevJbkT57zpcH+kXz/7mSBRvIUBYWAugkKUUiQqkxJicWgAzLqixd7BuPZ40AE1BE03kEuzp2PaaxSU1N/nI4fzTulQ80timduk+x4e1BaLcpsSL5Omj+XPvax/6eZ6kh28PPf++oPvvId0hllClm6RuMe4gMDgpyolIPxaihXdGFNpbO6FStyVV1jlpcIKQ36jlLZKPMu3b2owqZnfBIDlyHiqfSTH9Ls//3sPqlJlTB/uoNVR70Z2jK215snLcv4DHQP4Itf8As4wPm0AejoCjAclqQETUe10Gb0hOGDPQ2AjzVaMV8u5rW8ajOMoI1rCYh+SSz5eFM2HX5NcRS9darLL9mcqq4fP3LggAV9vLiW5GS4Whl4OjWgdkXpWIriENjplFdIUsgHRlEjXx3ldRI/ue4z6UKponmERXWiscIo2rIxNdWT/eoz57LaTUopTBoDhMV1oVCZd86RZr0Z6lYk1BTIxYA6U/rhr2+58PzrB7S+J+07tkiHhI3N+qZ+ZIwTvZ/oJRBZMNLMjEiOU6pAAsahDisWj5pr17NzVDFs2kqmXc6PuR4a9jyNKZQREVQF6DKpAz71Q1iX/GjRDe+Yz8+ez7thhTboHHu8vwuLfv4QU0JVrLHtspj6AFGjSiGMLInXBAM6dJDBKgBvZUND9PwQEDKbSUfjyZHh/kwimSqlS6JWcStVaJCcvpLg1d0RwebEmhXcTy5biI8Nj7364AQA3vmem9LFBMxVygka66HhNAGlQV8wvFo81Owi3mTCVJhlickn0tGR9GipsP7GC4tzG8Ezynmbs1xspxt66b6JEnGCl5NZio0yaXl8sL+dR0NYQi9c76G/TwJH7X4b0Ue/Xbfu/GsSWulV/sTxdPfRzIBeBOqeShmiHxB9w2p2mtKjzFDBUSAZ2hCTl7NO26jC5U2s8sbyzj/HlzwKkUC4QE1OGkpb3X5svCD8RX9uodjG0WBzqEk21SpsA/v0IVoRpVlBtmpG7YDd6AAMAnSiA68Ikuhu4cHImQOuMNPCQiYhgRHXSRo5ljq25/Enn4NiJpnN5QvFaHRkNJWMVspFiCRc/rinRQ91MjGpAHZygB5/hJJbJ2rzJyGct5tmzlTSJj9ClThjKjFuawlWM2BYIKAEG4YkPt/z/BgNdZEReWJtQ/M8o6TqJcNUS/W0oLf2xvgvCCiwQ4OZSZkKqgogjT+hlavp75snrmoLflp9Ll11/bvLGhc3MyPl0ThDpATl0I+n091En7OmnhiBV8lBzgl7DBNmMSqX0bhoWc+WyiPmXjP0qEMhFwz3eGrnaKjZImGni7HORkktFPRK1YAFpiY154U5J0iBJuTt73ft+xOgj0GAGjPKYjXE4DgT7IFLMOQBfNIHYlUmPk3VLNBTHdqz95XnnzFd3pJmlMqVVC4VreTHBL4oOnJCHTPXYcNfpMFBeuFZSj5nlcp+lhGd+55rqtBNFDkjo5oJdhO4P5GclrKHUXsgGop4lHajciCq/8zeedPQReViLhfTU5khjgn2xfGZib0uWfWGKSwoV6ma5UzM10Apls76AL1zkNIwE8PCzsfWCqE2uvD9Hyi6PftGdoxVi4dTY8d3dek7e6ir9sbp358SLSfGFO+iHkg7LBmMu1DoSxwc3F+10by9LW/evGEuLbKGms0S4+TaaD8weVraRfpISvFpkk10CV6t17b5abpiNilrVorLnhXTcSFarE22AAfw0a5WYZpJoZDZ2SJ0tgslQ6zm/PGi0Tuacdr++N2v/3b/iGJ1mFaDAtraAEIH2YuDND/tPEFdx2jsNOLXqnPP+67hlIw8wMmjaX20zOUYcwNI1dJFkNNhesUShCcVZjI4AerV0iv0zHnDe9L50lg2fnhwyzH68/iTU3+BOzrjB8iAbBZGGVgRWClfOSYto3WrobQlHiZ3dViL+fMm9+t770tyUtnmg33pWFo/sX+Itk0rkl3eB1bIWnWgnRadA87g6KXSC0z4u4wWLaLzrBkb4MAnw0RdbtoPlJmW4tRyVGp1y+fbO9baGq943/nRYxS6TFA1iQsFQW84bqg6UonD2NuCZDCNBXjB5GYZs0zbJWsN3c2ZWVspJcUGi4c6nr6N1RWD5nTCF49jDoGU5iXq33SappzOwc5ePnjyAofkPMGpiaFUJZdhI/t0WtzCjOxBS1EJzAFY8QPHT6fdJ34fK8f2Jl46fWv8DK84XaT4SQyQ7KeWxYsNsaKnt5aLj1133e1PbqUPnku7dRiqUKJKuVIK0ITIG8XbXClwSljjlIHcMyWMv5dnun/qXgOt8cDwbYmfmmHOJ9BJiY74UPrIDO+0p+tW6QvOcTTddM2FuzGmwOGoerxvCObiJMmG3VNyxdABqqW2a1AhmTgpGLa8Nqi4ARMfkErwU6XxOB9dW6bfzvAB3AJEYWnz2unDO/debrEIaO5Ji7ev5XURfe1SRoxUVB54BBE3CCJGwOSi9g39Mzr5etI51qb2ANmCpITJU0/Bzvb48M9P9vxgbLAI6CNBOjR6hBIpS0WHGgL6mDHAz8O8DrIVXOYmFffGT00wrIqDmgWmjNdFiqHGGkb1TB1Qr4TneVv27Nr2rMVo4SNqlJLDR0zNEGAQzokGRFe8XjTYrJjGPFLm5QqHVZhCT5rmORwHu6SYScM2WzgYcPed0gfOUNcOSxphAZBRGAANBaJfa+nf4yeT/96wnhrCVMKqm03/zPgchwkuaCITzl4L+nyQXAEKd9LiVXT9DRcpHn3ToU0j2cdScSqMDzBuIY0dJq00qdNRNHq7QHYfBfzhpJrJZdEz/11qSVPIaHfysyQKcoyWdqNbxw4Ro05npPqC55IV10y+3XOAyr7t+TxXMjjV1CqSqTqY2b2tSn0CRTjM0b2vdtFP/nbo5OAhmNFDlXhOhL680r9s4wWDWzdFRzFZTElziGZbHIDHmhTRB6gTYJC1lEvjwJjySu3ivEVk4ygYJpdLlu0uXhQ4RRJFGApbM+nCebTj6Ayv1W5FGmnuLPrGF77jbRPu3fuF4hi5ZOKC5AQbFiHHUirup/Bi0jAU8tZKBpUCylvJH6Tf3v6XN197bTade/bppx959NH773/w1LM38Afqb0rbjIDEQWDHgU+JYWg/9quZ3/zOd+6Y9gCZPQP9Oc6p8TJW2NUqDEfZ4jYrUhpLSDtEZY0/eyU+ePvp97qIbn2Jlm9Y75vdOjwydrTraGx0eGggXssB4gFkR0L7ADvF4nCAZsBrey3HTL/LrvVX7CkfGBuPGAiGFG+Yl5ymgkMR3/E16t5DOx6d6b3xexvXh256y4d+c+cv0qHRlhXk8UpNja1BZ5PNbhh82bd85ze/QbYFFgsGlOi3ugGVwmHQvHmrzzprvSQ5AgH7je9677XX3dizd8fOY4DMG0pDh6m791CQ93qUBlOKJ8VjLz5tIdsbepuN6QDMpIWCzhcqWApUyIQYANolsIDgQ2DuUO8ZRIWnpnQxU9/YpPicza3tLc3NsZGh7U9v6hpOIBe6x8Y8CthiAtDHgVZimIAQDU8thF2hi+qJVrjFc1J52PPAjFzTvOKY4XDBPcmUXWW4Nf3reSq/eOarU+4c3Rm/+f7vlty06HJqNwWHPRDxzW9wLnOIXlMsiSH18g/sKwctTgWVBBWSLMRAi7HUdnl1TuA5JvDn0DWJ+J6ZoI83nBZdnvJhXAzS0DFt0L3P7+nFqrG/RM/ePT3L61y3iczUjmECEB/VsUwZkB/wAo8AiYdNbjqF0pNKQU6Hx6PbdUmxF/N5LC+CTgAcbWOpbMmiRi3JEjoDrcQxQ3KBPXdQg4cWhir+g7AggkFWNgOLCr1UGIKZQu9IbKwcE/8j9FH07p1W+UmqdJNyeXPI1zk78LZZ2psUw6/DfJU2xi66egvI4FnWxAtYAvFUCzHK9PLW3X+57x8dLQ2ZVGrn1pf27HgZzTszIXt6yt2Qtbpltx76LY2szVTETDJB2+9lfMgl1hx8wGLSHdYvKHIrzFQWUqS9YdnZGxaetSEYhhbQLjukmy/cOFiyfHUqBCvWnEUuwOEHFFq2lHzL7jtrKb36ypRvu93+do+nP9M7oI9wJsSzFVslB1QG0Cen6tQV1uRH9N4ltKSJImD73Q1yLhI+WJCZxZcepeNj9MX3FSzosDcwSP6bVCSF83tcTY3yMpfZBK0JhFYufalNOPtfsJmcb9URTUSpgCjQbBPgmvrDXfcsbouUCpCd94wNjryB78lEnUQbWmghT7m+F+566IX05LfeQ2viNPYD6l1rgUCyUWMLtS2ct3DVyob2jllrz1fq55Dk4wUZ/MZ57+bvexaei5TPUBKYgbYDTyr0dIU2/4oWbSX/JbT4HXRw2MKeLCMlN3x3bSAqiAkdXj3pKPNURGtwNFmrxIjlrJCZXKFp553UccO7x4IVh90d5NxHCx9YN4+NfuasUEcJfkruN9QBjcAysE0+CANaxGSrrdzm4hsFyJgtmWFZ1/qE3ag5IyJA3DrrAxiW/acmrLETJxrcMBzXZUXy+h2FBHrm9ZOtmdwd1NlKszVmpeZN0rcnXjifuLm0PkDZ/0f3SKuUmEuSZIcXFkgtLfWNcwOhFkiKq4USb5MExRAkzy2fvWMwfvP+ARo+jXanCtMKtO/lScsQvwVgibo16oYhTo788DC0aCqmXEAQgwDQA2m5wkOGxU09UpuRJyoHo+bDX90x/O9fzgolnUrVmz86+DcIY00fNVvThsfP5I6Tk+hqZoLn4in6NvnRqfOPX7hm4dzVuwYOHB8dU2RFTcultA5bZaynwd0DR7LKyZM1OgrcR7JbdUR9u06VQPCagV+sINhsNtPncSaKFhaOPz3jL5TJGAICB2ENB24ryTQApxNWZE6qq5CrkRr0RtmURV6y2b1Qh8NiDL7AZimXAa4JdlVQoPa1K+53bFx9c1GhvfHThcxwFoSXqEXX8W2ca+QYIPEok30B6CCb6AMgjmItxdgZ1pvl6cWsPx/6TPmsumUn47sy7S20/7t0MovBzLewzvOiDwTScTYpiSuWMT1cbJBGR6iQn/TEOv1Qe/grn9320s3PtPHtifDmTDF6Yls0GYd8/A8NC2ZF5f4B4eTv1b+NAdlBjLutOrqs6So2mVVXXTab3SZKbqep+VucSmx/377pnzp1Dce/EPmCvN0PP/RyTi1h6N89OW8LzXNQG3w+WqVZYodHMQs6JxmKzeDkaCKTyJWqfUMaL5hgtAWxvr7prIvfduX785fmEx/t+tIvn7j7z9+ZXNikc4AHCugL6ewL6d0wx6i09GbCt9+2+5XfM+jXUsbi74A9dmZHwFjuaeld14TLuR3uoD0z/47Tj9bT1qfpkw4CIYHvs9u1lMm9xpO4YQUVijQIT343dR1mLlSTU2fH9WAlhVEY0WSLw0q32BffFa/KdOcfn2TI0Dcp73vgGWWxCCWif0z+BMsT9HrtTsUh8LxeFZ1Spyw4dsJi/7SUaqIgoBv0kT6Pw9uElUpJKyToGPrgdHJQq0Bu+M7Kst8baSlkh8vwC+XMfK40GDueL5bGUulcsQRplSRLbn9kYDR/5XXXk9PfufC2bzXfcki44NVvnS7t9NmVtOgjdP1CugYDOP1TLr+65PjRrujuaYMVnQHUmjFFePKLjmJ6W64S81xHWQChlrbQiJPOg47mEvrGEnW5q+3Ika+XKff3x3573/deEtedTZkMtTYTVlt22GH3UP/Y+JsQk/VthXz8CB05Tkd66GSfZg3jqoUJp3NZZ3+1JjH07lfP4Mtcgt/rcbkdXhFWIJridvEON5zR9IM9O6YVwuZvyU7Ounp/S2vE7fYWwD0cm5LJpGbNEqIYcK51hZyFlKhX4CJUzGd6BgZGk6megeFUxmRW/hLsU92ZChdu6WjtaHc6bKZZ/6F1n4x94me9P59SJrtopeYwofrCyC2wUqq0/fiarz2SeuiMbK99w2ajTI4G+2Oqi265mn4y0QG1V7ZRdRt9CcLHa3Ye4Y9GMyMtqdKHfF6xob7ebivIdnhHmtkEC6gwOMakOLW0v2dftQ+z6ZExOpGYUf4ynpP93b+Wcg6qbJ58D+et/gZRgDhSNOFdAJEAsMiQJcXvhD9Ycfo4BmrbEaMgaAs2OkJ+R6VshJgdHkb/qQSBdxkuECIHzSaPQnUOS1yhCu66kssVMplMImUmobTAtAlDIz0HJ4ZUKhkKRxyYgQxqdiw5t625d+q8gqLhadtkMnsTNbsuN+uvDx19YfB74598Y3/R5al8wpZltlVQNctvpuqj09/82Xlce9lfKpZ8ZXc8oQn5ojh7/rXlTLVYTXd2jDXXdR/ePfz8q6df20HGfX/4xYt0F1QlydeUFVn5/fW0/xDttyZiSE05GBbzs+rr2xoCNrsjl89qOjROHG/oYrUiFCsa1CbwFz+jA4Jk6wh4Vy4JL13bGG4NSKI2d9Hnfv7LH/7j4Kk+8C2eN5QSYMKTHlMj+LJW4dQKEyyrJa1YKGXz6epp6gzxTt/A4Gg0HoqkfUG/iQnGPufqOZ+/q+Pj08xbOuqpFcOzSDu8H3iHdBoCb/wM1oP7+vODNjLdVK6ja98KF0E6dpiS22hehD4PK0ZlnjvpFhKiWDUNnncJmgDfDZv7GpmXXBTzBo6mE5sMYeS0HMf6+Lf2f2LqvHBGlVojlIuxkAATqZLCadDlVXgVlrmYDlURokhYFzAbUAMdUNLg3Acbmok3Jk7qyD2nqW7FwsaWZY1cnRe+WIva1v6088tvffqZQ0eP/urRfl9nXbS7gP5MjChLxqp6pqRVS4aBL/AOj03MTEihThWZSCRKRWjwVAwJjhftNndLaOGtH7/g9m89N3nt95lzqM1O+3vOumXJaQTkwEFiSsNoemNpyzPUDl2/n5QyudzUVk+zGilwJa1K09yBVkG1m4gEw8mCagqqILClRRbxBBZDLgJsNCk6GCv0x81p35oMfbBnbosXrreCniyw5oKHxsa2gFs+IwHiMBkHesLdB674uoBxCfMUgsYWwUv4Kicxufj05CJHXSgQbolIQaehCAaohsbbPO7W5lCukApSv9aQHx5OjurRlEM7tvtgQBrJm2rRrEo6v7C+qTUcHujblZvUiBxmZIw9NBE6GUTecbpEUbzq7M9E/rTyyaHf7Uvm0xm64U20znaHnmm5aMkltQrdcgONCRQbomzUinSQYQw3rPWgRse6T4SIZIRcPrp8Lax6+X2j3UO9mKnM/lHqf4DQbY2XUt0sCjWS00YBGDpXKG5WJKMo6aKk8mVR022loluF2xM6QEK4DTi8g4COxhDvYDpEJq7B39dZq0EvViJEKy3uGBQHVkf7ZpqVIf3lNNWEbwCMqxlfCIUaM5aDdN6AQRpnyozdn54AI0EUYd7HqYh6AP1uWc9nSul0MpkCLQcPoMrZhJnIaOmEmD14fO/6TqeuVk2Y8cMmTecaPN4FKzy9u7MT0xisujEM4fAvIlyPAHWeyJuK3xNcLJ7rrmvcaI70O1+8oeViwVx5eKCnVpvf/I5cQXpxB1XyEKASB04IxUFZj3UAbP4dpPL0/kuuXrz4xt3berhsxd/YaKs7K3niUCq5ByWYGYrtJUiP7H7mWJCrUlYlNwLXMK9uSYYuV4D1K2Yuns2MJfOIUlHy5WOvbH1198700e7pEJm4DllAXwybDmb3woycgGc+ojdbHP9zE/nGT2SIvkpFaN3QxSARWFTBZhIm6EwwpnKmxjtFLwqZNr5hHqiXyqnhEdWMVbmkquay0Z4DB3c99uyBwyeY2L0nf+xI7miiNDyY7Xo4e/JfTY3R2DCk/FUmcPbCFfdT//MZ7ae/eOpQbLwilM9ldYwlhRMRYAR22IYetEseb7BDXGgKgub4sN8Ubhv99C+S/7pyB33SuzpY2gkznqYImXkW5wWLuCLPlmaw9AQbB3795lu+dmI4fLzvIC9VmyGSHA1V8lrUrg/U8b3RA2hT9RgdgwAjQA5okWCBUoGvWdqRTzuSfm/B4SwLogpJgqQoTjHEnztRUbbcBlAnEigEDlAq66avJvCyHBxRn6IlicUTBwSuRGd2wBhMPAqpkpRyIDqJwwkfeJ7cPCdDRythKaGCMPFXu5d15wb2TBJIBlocx83Dx+5/taANJ/JjhRz1gQ2bROKeeumhrhNoZK5WzQe6h5tsFIyBmlaV1pgrFPv577+GsDTLGmgsSVBANrgp6PHbJQUzXpGqcS2TqxT6cgN9xb7jpa6Rat9ux/NSuDQGUhuhx7P0eHTn3BFqSJN7gFSYiGeYmb4jxyKH2Q3W2KUSLC3fdejIQ7Iuw/C76MoafoO3Qe5g8nq9r05UYZYrYQzJopavVtIj0lg3sB0BeGCbPZbqKKc67V6PpDTbgkFbO/c+y9/54Cmgd1jL8JPUkWBSHZA6dAkgPUJiis6u0puI1lkjIABen2eCdSTU/HEi8Gx5K/vkHgSCI6cLr4gURJwcLsJxsG3iTAPzMkYCZgitZFZyYglcjWkXw/UN/floqhTvjRcml3Oqdq/952uzaHgp/fFfr51jCXFvcpkuiAIgk8SUgGWCJTUBWWm1DrQF3Zy2Vpe7md+BdIR1QC15rLHebkEHEDj73V/f376kf+RQOZkpFPN6DoFj4IvFGw6db+BsHqmhvQ7eQSWPPSqWXyps3TFwDx3VmTy7n9pUWt8stoUDb198TWvT28UP0a2X074bTmEw+LpmhvbNVaEuhw4AtQAbgBUNBC2OQeb5BXE/NEroYchgGDuFCDVOWrfW+6M5rT1j1V/dfxT9NZE0a/yAyKCTMBeDsONAS3mDUWMcOHXgnoa1PQTbCEJkw/QAy+7/Cvr43Ak33fM60EcOqGIQvQnlAqXwWdQMbcGJYp3jEgcYHtQ+bclUjpOammgHI3143moNdy+mg7u+2fKBfyK0y9HMiFg2wdkhq2iTeJ/NUe/0+lwtLU3ogaLTJelVPwz5pPnMQg8J4WOgJ68zqVVqu3KdNpATtXM+3AJrqANnWV/rtmhyx6Jldbb6k4aY1mi0Wtb0LElZCh5jAQqlCnQcMF2ShKBfX7VAX9zpWtScP7r/8F0P7j7A6j851VrKfpnc1EBoIcWAHzOcBKGhwSgwOVjZiTAwQ1A9MbJgfiw5EnE4Oa7Yx4DxX6R79v6nzMACgBC/SLoFepBW1Ay/qDToGR5hCEct25MdM5SG57I1ZuyWwil6x7XHUVLoMt1mk4Ju06bYAx5ncyAyu87jc7d2NHoDwZQkY2T7uII9dnbJG0UgF0AB7OmcjXPXLlkidc4SWsEVzXEGX/WMfxCDpJ687SsXuYVAnS6mVBqpqqPl0piZL/mdNjmLwHBYQUna7LnqJWvKMCZLprs2Pbxvz97dB6lreLyYSX8xW+DA6laQyoJm6HJFkyuiJkkmxJ0CYpNIiuhD5JUG17xVLbHdlVDCPeaoGxx+KQYwjadOkZrCFMtQ17QeHs8ww1+/JT6eTfSo9RCwBvojoTYoGeOg1gG4ieGJDkAGkKCC1QFWxmk/QPygdbjHuQ+cHIg/2U5rRZciKg6Xzet1h0PuRpfXYXcGdd6erbIActWyzQtT4MAKssdbm2Ib54YuOnfDnPBsXQxx9ozocbaI1dElKIt9cCnszldetbCjmUwPGGtYwLjL5CuXg2ax4KnoQtZlRjqSiqMrH0s98liukKiUioloqq+XxcNLTKuyhTIgapgGEQdU4hBEbdjkgBUejofwEnwhlCb2Fk9o3fff6lzYqDxxJKE2FpP8WDX5/MGXYuOl1RNdNptWzWVWX/dvp0N6pH9obPzhDH/bNtDX/vcLb1nzYVXiL/jpsq7acgvABQ7XugFAxyV6At2Ac5zUkmD1zdD45dS/DVaYmZbxlZBuvb2YhDaKqaqdx9I+45GjSsUpqUl7IpUtK1xcNVKaWi5EI2UzJLe7lYbZXm3NPFtLXatN8ZFZNuS0KIBXIXRRLaH8us7ZPrdcNgSHDl0chwgwVc6s6tB9ObHa9O890Z/JpiuVjKHDA7ugVdUMXMURyxNtOyOhyfPcFPCwyA5QyCG6DovBYGZ0ruiAuVZJEkIN637x2bqNC/mSYNywNpQviTHNeXi7/vfTZQGVA/DpdZDdTdde1LTQffnPf/5HoO/MSaK7vvvHlcuugy7GqKrF1HguvABwA8SgIzWg4yRrzQE2qtP4aB4rPotM5cZfmfrXadEfvDTRiRJmhea5Qcg/+IKuwd4ooSaEvFit2qV8knkRYFVewhxJZZdYlRXZK4l1btPj4Hjw5joCjZZMxI2AsYCvFF9K4ZeZnHWpvSmyqsMdgOuO6VV1pcxzVU1RKrZiJZbr7frXMwcASDQEqwispTBXAqwIMJJJM5SaMS0IshrDywKRO/dljGGq9luU+F1nix/4/CfPuuScslZwVUDVbFxQ0F1cNruvP/4Cs6wbTz6o2hzktcF5zt/eENlwxeXt3rqte7ff++im8Syn/yJWx7qz3ykqNiYRE+z9D6VPPQNYceqx6DduNdKShgvmHgr3Dw6/+6ovvW3depuA5XThvr0//8z3bzv1yqQ/mLCbrQPjAHBHN6CC6+/4qX33Ttu2FzNmXoU3aLqSjvYnDxpJ3uwStZiTE/w+BRLHcDAUtrkdNreNDzg1iUc03QyHiK4ConqkRGm4mx/przKsEMMRft15cBiK8ylDyCPSq1Q1JbNAqWgm3t+b3XwCYIZ0GisLxL0DNsPKDt2AsIQ40CsYypOHAVDmwyCacKSWqQIRlYO2jZ1q021foRMl7R/7b8u4b1vUsVQKvpdT5x779e1dWw7vPzECajaBuHgBrYUjkck74LYk2H1uu3jx2ctaRCG+dccziOsxNQHF19ntb3//RasvvfTB7T87XRBGwKCllEJxdloanLf/g88dsN599YG3f+Idz9DaBeQO39D55b8cfNd7F6+YWipibzGb1JBVgLQ05Fw0b97yjcvef+tJ8ae27i0cPCZKhp5K6PFyCT4dpA2TOmb3h+fOksyAy+/y63Y3wilAElDB0qg4aBRkUVfEk0YlLqYzxwvGMGK1OimyoC3uESujveks4kYZqqap6Xw8Odrftfvlrq7i+9d70gU9XyoAnS0jJ1IRZxT9AaNoSx9sG7etQ3U7LXdnB2AXI7udIkFmiTeRPv1tUtpo1TJaPZdK4XTFdlgyM7G+Y8d7Rg73Mqn3REeiX5EgD4C3vabAthBLS9nrtC8ONa4L+6Z1gN9CzxGTbr9j0+gdZ4wPwBt10Nmx/4dHJyqD+LoEu4mtYLv1+16Q7svnn/7LLyqH9vzxZ3dvrlQwsu3WagZtCcDHcmmb/O63hq96q2v++WgvpPkSlKHVilSu5qtpo8Tyly1+SisDypwdqieZh7eAVNINTc+bxUp1bEyOi3ze1AuFdFRMqIisl9TIBcdNictWC2oyishAhqoixkM1lRhLDPQMdRWLQIGgVwDXyHElSK9VA7HB4OYBoTw0wxiVaBpGAD6Pk3Zr2YJhCzhi3YMYjIjTCYesyanSR6N1lEN8JERTqRQELls2q1mNCf7Tk/KhTPQBbHs1TTYMCDNQA8zGAmLV+eETOym5AI7xUQh0x/kkMjaeby8xbw1MTVOSjTR43qVYzAndCQbYkT7m4PsvXFaf2NGHXkOXZS2Ymu6gEGmxzZ5va5uDXkGCgI+HGBZCJk7ndMSpZZSEtZpVm4NICwoLmI5gYYMoughaUjHKerVgCimEGNaqsUwCK9xSDwdyo/sRrEjPRJOaGR/TKlohX8hWisXY2EC2wBg2pCvWbhwcKJxMjGTyqYHY0Bify8DfDI7OsI6AkRPHRCXNFdb/QA1UIj+OcApIVpxKU8DFCux5lfqvoMUL0vlcwglFDadlKkwoMZn+oNdwQLVilgTdJpoaIgSLDsUverJ+t7vV8pQHrNusbkM9AXSAAHgwA/TZN8+EPlbqDQTFZwnCQixx4Ea8Xdv1C0ivG2yM7AAhkLqsRl3hgdd3i2/R2Q4lZN2GPEWCxkIFby1AeQ1jF7Z+KVhLC6xvEMYRKii1UimCUMAJD8H99FTeSGRUxPMrIpbq6DCkoUqx7CtRQnRxRjYBxyY4zGYzpXiiwpT+eK+WZoOqLL2gOVyZHR3MZBNdQ8ePOA8N2kehT0ZYZkC8LUgNCh3Yx/QcAH0NFkC1nEXEAfwqandGev4wrbwsr3DHXWbcvpjzHqXmMTbkgUppi6wFLLJrB6PG22Xew2lhTeUNn4NzhbxiXb0lmLq8hX47wJqNj6LjccyYUEmUjCqhIlO6J+Ck4ijBVAPejkb6TY1fHupnUhZUuIoXAFEr7SU6yGebnXzEFxRYCCGW9GJc1TOmAcEJy1fre8ANFzYJQ6JaKuQycPvHmhMkvapWSrlcqZwuGhUV6jPKoQPqGiEGKDdUbaVqLpoaq2qFKCViVumTf+DZJATaXBLvCLQiPHFz47yGcN3BEzti6dFirrCyMzTPK1XjqVf2MTcAgK9WQSAvUu0XADoz7foHnfgEmJNezuiNb2D0Cl7U7iO0DISLwhLV2ck2i1rqU+d4oytc8BD0txljzlIgiUidCPOXIvrm1+bf/q0uVBiN/48p4qR5s2Wv1+9raRkuc48exeTpZy7CxZOMykDKbD61xDQHC6TZqABrbOfpDkDhu/KJJXpmrsi6GKgJYsvlUkBbvWDC5LRGioFqaDsggAg96WSsWLDlchkJziyQV+i6isAlZQTtkTR0R56hgdjqcOo2GhL8cbA7GqKlw8R/htRQB20u/GMEU4ZE1+UJN8zjlmSKKcVuN/zxdeedq/YchLOlncqjZ7yNik6MpDMeMpllfSML8I1JpQhEwnwLmxwmdSkgeDgsJJxwC0o7nCcdzopDdrvUUafZltGZTgn23nR4a9eBNwZ9DKbOOb7lK1eGwvXhznll3j6Yf2EbC207xiYAFT2oeSEtg7cmhJduSitUQdUnJXg6po2UADkWxhn0M6B9+iAiW4BeQbYI72GgGqCPAzmq1Wq+kJNAgKpVBUCD3AX/ILWD2RPsZEUbVgvQmIqzFswRgjmn6o93Db5AiaFpw9P6vBuMwhxErcuJBQPLAHgUG4I92Lbk4nmLY3osvKqp+MzDRtIrG9U3r0k+uH1Sla3T14E+nv/6fXT7LnJgmQa5OSwRDUZMgGMmbL+o16BQhZrLiP87nBWqmoTA40frzYBZqnLVonq1g7797PTPvdZ1uMW9aPUFKy+4KFLfFmmbMxZNeR5+pcksD+WjjJ+zREIRi1lV0iTA28dJydpAHi/xgEknSwdATnCjXEZ8LCFd2FmFpLrAZilYqiG7y1psAIHg3xkdjWGKlhW72+30eOAXoDiQOKeBzTwwHxTTpdyomL4Yzl1pW0uD7du/7xn/0uS/KPE92FnkbDKHjsG5BMIzqKlUxWHoTql9YcOiS3Kbf2XmwGSJnOSYM6f5T2L1/Vuik0uonS9Y0DH/3I1m14MPvYjRPiml6NbOSZfW6XwLj7xUMWkoSjsrNNpFW0SIV/L+xpGOWb3thl4+UDnZW5z+4utch5o7OhaeNXfphlB9vWxzP7PpxWR0WM2MUWV4Auswe+HCC14P+07AnBaNBzKPY1CmkV7mMsUq3K0RJ27I7WodTW5FvHnElwL6w94dU0atA9ATLAFTVUQMK8JoJuB1h4L++lCYxRFSET/JdLhGssdHxWQlVBCrm74d+krtnTN+39NMb/sh1S2h6kM7pAJi5SoQ4uiii2y+qhHjTj6vHt1fTg5WEhlDy3GmOW+O/cV1647Zmp8cg8CTZLsdzIA7ELA53bLN0XxO/d4Xv5e0iAaqG7ZcJB+ZUK+Mf71rkmGjxekMsCcgjq+SeIQ+aK4pp7MvHjrRTXQj0d/H33qdvwBj66zZqzesb2hpFnll585tTzz+r+GB3hSjuNrEi0CNtMXCIoYNZCX+FrK9icWAp83WFL+Gnl1IB6XfLtav+8OJL3yjfQuiA2PThfoyucENKgS1kweE3JJaT5SJEzjmlZJxDs4xbi/kdnaPL5OOD9215Sp8q/LBdz01+uA3JmefdN4GAJ1HzqUkNECkvF9QW3VNwZYBKoRPlZKJHTz4Sj46UMjEKvkkp5cR+AcrVlkRFIfNH4DETTAlEWODg4+ZoIBbFm0+oA9oGnDEa+3ms2kc+iDoJvt0yHqoM0udkgX3SfXBqYa4C8n+xEgybSHmBRctfGLTYQAO6RIr8DXK+eeUYC/sUWdL+KKNFzeEIqVMpqpWX3hu09DQYD7Pwqmxx+MJfBSuUTA8QSUHeRqobTX1NJO63LLhXYAQm/Rg4BcfpV8MFenmwgmEfwD1D0DSBW2lZAVhwcrGkjCNF3nqbxUGw9lkUtbzWXt0d9Q8Fv2Yp+FAdkQ8a/TBaVknX17op7nXkjmLKUW58JHK4HChGNJMoWh4KiZXVAsVMFrJaLlQQMBfTEEuOxeMIL4L3J9gCOooQcFiR0hz3nTaZckhI0gSj4g2zIwaHbAGYd0sdMNk5rMG75DcqUJzCGaIiTgycy3/4cn1qZ3HMtGhISgpWPrUpsPff8ua0MPb29fAFmFdrjfe99fjIOVHrYlEX4cgPUscwQ673d11eOfJ7j0uu4PnpH3bt48O9GdzxVqBE7/oACQZ/qBBuA6Q70KadyXpEXoKOp9bLOP7elZn2AqiAZ/S53x2eeNTm4exPQ4usR6CwXg4SZLJBNfTkjet11UHF6QynfzCDRdfRR2De3Zvb7KaPy3n6Uug6kIIsTuZPzFSMUC9uUwuDQxiutZUiWDQgUUALKsrCDBgMJON+og5z1V2KgFdgvjSiQhSkNSKUAQrLoVzKDYR8Vbdlo8ymvo7y8YC3ebAmFBouGGZ1xTyuZzOSCT6k1cg94OJwRmpVMFWHewtYKuf6PfPbv/ijy4MGfniUW/m7leGLdcOVBmP4iUzPnK0OjrKYwzaFZ/X0RBpcDtDMlfm0IyZEuKb1i8nTzM1XUbhi5bC3MEkTxPBmvjV++qtERm3amxQ0/DKsy/dteQtBDsZY2xP4m+f4XYd51j4F3KdpmrsG26i9/G0YcGyuouv0bPx6PGjlUpOqrO5dad46VordEqFxo5Mstm1aoYGsPBMRUT+YGvdAwfppcMEAW+5yvaDimfZJkkYbsAikA4X8Fqjzj6I33Ltpl2SXAqE/uC/FLZUh+zAySk2BJ3hdCnAtukBlV9kNQSBk+RzZlWV+mrVmUwVoZkEpwyjDVhv6C311J+ZDiV4y3rIHWKEAvyf24qC+OIjJ1o2XOl+5dGEzqIDjVqrLVg+5nOUMUArgaLMnsfQHCF32eWtXnKeN9La+vC/unpjU4pvdNKKi8/acMVKf6vPvzpUCSJ2hQhgNlGTi867j25lczR63kc7L0o6qt7GO7mFAv3ovKNtrVe2fffK9PGXSy8+4RjNPvF/v5pc7hzQxnND4bPnqYVjxVSuLJerMM5xigI0OWBmFagTqkaknupHp3jhAIkQFoJLkTlGiFLxwnZ66SCWCizOPKAC7Juc0pbABHWLlSCNQL9JoglhDdN8QVQh86KNx1Bglv/L5tPml1nsaHQbpBeOxWTW1yG0XS4nFItmSSob2JIFzgG6kUYnn5FaF7KQgSIYObhcV8mBuEs2qaIb/X09LdESpne8A7QAepchFUCkAPgyWCsjuKYyMwY94xG88x3lZRd4r1h+1Y4D0a/+ZsfER5auWXfupW87Z/0ap89RtpfGKIm4GJgUsOgbhj85GlkbsFX62dEb7/rn03iIdczqh+Zd56frL/oDzwldu6I7Hr/TmCjROvGgCLsHFkpauVTBhgRYEQAroZWFJEk3nFaw44rpqrQECA78h8bfRgOwyPHcQwMFemk3vTQ4tdQzrvDecSBHN12q2e0OryNn2Dgb3EsxfSC8Pgwg8QPdpN5HV85iAMJ6Xmwkbp6t4onkqx4ji4k6bWgVBCk1K2YRmqRiCgMrP+lDyy6kD9ww/8Tek1l3Bbbc1aIoyti/wlYVxd3DfaPVDBD0pDUoOTBNeepFJGoLV4BMHkjbID2cNdbAVSJaGtvLuEW5fiV3/TMX/PvlzsUb3nnRRethN8i+hi3AIOYyMnk6kaZRjYpR6v4+uC2f1bfI8m+6646nmcABw9DGSN4//k3/uOeDk2p6+rQTQdsQlxPGw2O9uiBXTQEmWsyaQZZ1OwIImiI6AJO4BkGIq4Jpsn2MBexDSmLXqjTdea918Ro/V1238sorrnnisW3PPPN8GXI7ePRhB6asce7chaNdJ2TJzsEWSuSwCYciSe5wnb26T1lO8H9mVnFwV2gnY5aj6Mw5dNnIySZUX5Izj42gwFxUMb+fgv43P9uy+djAosXeT93yvqGeKGWEpDsnmOViBnFOHCxui2lmK2pOR/gxRiQwCIpWIEIMsomEytljlomVmAObD64BxjxgN0sDz739uq82LbpgIicUVljrQMIPaU2G0dqx5xljNe4n+WtrD4F0TRZhMbHOiVennHgtPnsO5Nh1FBcqejkjhVwexeuUA6LsigQbFa8b5pKwA4HBJgQcsB2GG5kOZpYvnBJpoT2vlR554C8rN2x8efeLP7ntlzte2sEIk5WAE5/84W8f2vjmK978XrOMCGRVLB0lEGCJSxWjA08/Aqd7PxAbekon2eaCQ3RWwxlo9NxG2p5S+WY1NVSACg6hPxgXimGI6fpHA4cSR3RuTDeHQ/U7GpuaZAkm3cWsyFcqPIzsYG+K4C1JSxYLQKMPrPdqNTr9m2Ptg3oH0zzbgYHJKBGf0SXYvfNPZzIx+KpVVU8Y0QIfU+WxKjfCAROSdJ1b7nqhegAsEWicZOE+QI8Dw23F9H2GWokAerfIdCFY+ZZNI2Vmg5y36HOPVfqEtB4/8VJ8eITZmFgJRJcFw4BxF0Q+4H8wvF4/XXXVex585t6tr2zJYnPMcehPvHLHn//xf5/93O5Dh8ZxUPj0//vUrZ/5uL9hbsr2uAwUU1i8I5uPBK/i9MNSS7fzZc6Tr6glwZ1NFmICiBSgmGI0CABVbE0QS6hYWSgOO5JNd9p5zY7KMjsl7OGHvekQ8BvQx8CdEfqoG+CG9iKip2XIwyoL0MFSlpdt99371/UXXdRc12RoagkiM1UtSckqxkBVBRfdIraefSxxbrjlHz/sZu+AouHDsiVfRQfYLR3IHlbgRIqAHYEeG6sz+DswO2SNr5ZHTuwcHjTS2O+hQpDFqZjirfqDSjNNC1qH2Q9LXWOimNc46T58/JVdL29+5smBkYF0dOzMXI/e/+epN/XbfvojHNtfesTV9FO1j6pOtlWkP8SL9bocKQm8AxNqQMo7GhKj+WhlLlX2UmkLE1PSK6wkh9Pzzjdf+JeHnyx6hhVl1OWAtlXRXDBvhIRIh5cGn8UWGqwDXmfUIgNoFuwCmG2ZxnwYsOCC5Pn2n/zimz/4OvuKRAVY+mLfRa2Ys41oZsEGhV65fX7v0u8uuMX1VgjSrE4DxD2Mu+RD8L4it5/4Vjrxr9Mtbod6PUIhbKoikagwL+Udu/Mw9YWwE8iBHkTfYQih7zAtoSIQ1THU4GDEjDFqwJaUJeS4fGPz0hWLnR4B+4ydOHly8ws98OVDwqaIdz38m2iiD3aveRYUZ4Z0jjUuNwlnxVz+YilZMnOkDq4592svf+uCKv+cH7wRKudURLtmV7DfiQYOCtXS7VG3HXpK4jBRu2hoDxWsDsAH7n508928nKmM2IS9IFCCrIo2Nn1pnA6Hg6KoHxKoH1TltRMaDBDbgMGAAYgvVrCg4fYFNejjPbBMIAX79m73+BASzx4pLnNWfC6pxbskwGgC6oc+BFuKkxDczhAim+DD4A2yMEwnJn13/TyaF2YR72HUHovS0WEWGRdDGm+D+rqtnDjH12HBj1pgREK1CM4I1moczKmRrrrwrFVnrT3v/HMbm1pgkYj9QbPZsXPPf+mjH/0Znh7v3hWPduuFolbKs3ZMTRhWZ1sOBKu++dSvvv7mqQF29m742uncb7mh9OFvZhvDJScVEIcdIX2DVuuK6IkIFS5ChDzquf10fpxFmhsO7f5X/+BTRQ0rZnAQ0GQZ8NNLg3TopxRYU16YdIEdqnCwKR43QRRwYBcM7DU8nhYItPxC+bd/XoMdN53Ntqvnfmvuhs9aubGkQLw4a3IH9KHl9pAXcZPCbM9SDxxkEYjjUko9xQqav4QuOZdSvYwjHxymg1HWN4AJBo/P6gCc4EAHAO2hrsSSB6GCDWxxi/iBsH8fy7FSnE633eHkeWhied3gDfBJECOgt6wUjY6W4EMKDadRYmLxqekKLKEtS0r/pQ0BhFDFppSvkR6+j95zdeZkbxXBBVUaxQIDNUMzgSNeMA+NbA06LZWxiwwmK+yMDDs7jTM0XtUgmTJzVTVmYee0/JMvGXuDULkITAqMA+MHaSVM5fNbannw0QVLMLVWAQfs5+hMqwf3/QOb6daSWXGc4kwAOZGtPzBSsesVXDBg/o2Qdis3sIznnEu/upXscAsoEjZM6Y4ylhJkB0RFs4hPDfr4BUDRAWKgaqhGFTYSzriW7WfEpzaDjQyPhvoHI5GThUJOwDbFphpLdD/9lNXFcMfbtyMdG9WKWUnPN2IAFglawzDR+UQXYwL/8KX6unltV35RkGLzL1w81ottgMZUrEpnSvFjdE0HNbyF7n8o7bcyKDXoww4HcWVW0N4z3qqkeEH3pbK8mi8X8nB5K0PyfqRrIGHl/O4PfnjhW667/fFnjx/v2fXb701+G0v3/igL/gd9LCYD2HMABNiDBGnJQsplWdS1EFw9MkwQbcgedEXvgX8vWns5kEJwMIKDwJ2sGxBd1YctTCngJZeT4OsGn/CrrqI53XTrBjq0jbq6WfyJFyqMIUZClzHqZ/2CANZGw6kOaD7AFhPgFtHsBja1tD9lLQOGew8jQmg52+v2OMBclNTiq4hgftAqD8KoI/ui0f5yKQ8nb6xIEcYOPFSWo10CzWmlZc3PmI6BYLVDc65eesWq0ZGsrWv02MF+9WgvqSClM6SRh5mbzYpxOSIGgd2a51pQrTlT7DX9n4eRaLwkSXpFjMcy/YODiVTixMn0RKGf/djHfvTyrhIfFH0arb+Stjw+8Qg99Mo2Gg5QE1hDhbyIGAYRJqgy8D6KoO9MBI2lmCJgDe8UTJj9S8dPvjxnwTo55BOC9Ic1q7pX7tpWZvtKYO8y+B7VOdiy3CGTDeGfQrTu3fTiPVQepCc309aJr1ptCVjEx2c1CjQMIwAJ9UGE8lOrdrQ5RG8KX7FBfuIbmAVCDlKqfYmTfYMqDaVoCIo6EObxdPD4nngBmk1rOy1os2F7zuZyZrb+BPY2e9GoO3FYy9wePudGW4sphD1mu8jNddFLLnru1fEypv9NWTynx8KwgsUHo69Qq/Wb6MQRKnlBdxgNDVYpWRQ5p8sU7KlC+XhP7ynB9Hh5iVKlzDaugCc33+B2j4zfr/09UKUDo9Q4ysYrhkLRQV159sSDjWUw8rD5lFty29ttNgcE6vi1OWXsiYYMeHrFB3fVCpn8e/O1dNk7KITQKPPcI/W5g130iy1sYE0k4Hu95VQB3A/AwBMAB92Dit+CPFMwgzbhFyNCumJBohm+XOxjfuzwAdEA27SWytCbToI+ik4haEGR7UIM3ywIxMFZw/oTB3KNlehAjELQKB7rn9PcWxBcJZu9qCtVBEN3Dk5Ua/rJTUB51JB56qM+GesAzQJJDLqYBSz22sU5RhsbsFi2g4XiEF4Urm3senIqq9itCSwulbDQyscnP5o4j1oSjiyanT91D1tp2CyNisuFPZeDit3lcPjsDqWlrdmAJ2YZwRZca8Ku7bHxF8bLuvOfhMNKuY99jn65ZfzB+F+fJZd1g/5AEuwjhEkbrrBAJseILsQIALKjN1CT+rNuiDdBWQRVOHYjgFsP4msxnsElsa2cxtLjPkFWudEkk0Sm0Wl4Ew53GFMWa4F9OxGXbmyAlATtKJoN4j/H1lyQVMIDEPIiQI80Ol6rSX9dtPrXG1eu8ngq2YJyZNRiAuD4l86xeQwcllCkAPx7YCRiMEMu7CSmwiLfF0LoNZg6MbfvqckpwBGn9JWPXlvrq6kPT12hj7OTHqD+kVby1AmNsxfWtSx0B9oQqsnmdLn9sFXbfe9nbskjHIlG77qabio3fPLuaYPqdEF//eHpc5yB1Hgtm6V2kQXUwe7Peo5uT5zKA0S/6473wvUIye5bdV7PHHuukjSLBvCOoTP2CENUI9A4G9vcDzXeNnzqTfxB/O/T4lAmxGAuGOgMmBbAQCmBb+AAGqNz/S9SaB652qkKBtD62uliwO06mj5y5crFkTqHWs3ah3P5Q8eymXwpCSsPTeE5H4ilrHh1vpKAlrsCRwUYe9SnF1aXzGp0OzyTo/dOlBquA1mdOR07mZnbAZhMT8vBPlz5Jk9dkyc8xxVusbtCEPLB4CMYku96161CjG2ekRilnduAhaegv5Zo4zkL5y9e5A3VITCR5exnd4RWX/H+t9RKB6mZb6n3ZrVSayspTooP0XcmwXDsyb9WF3SI8bNXyy57zAZB/3CuVKyUmI4uBjVhCdODLsH1Q6dGCVsETukAyBJgWvQfEnBsKwhtmdr3sX3MKjLTJFj9xF5cBvVeE/fWSxd31LslMJLFfFLf81h6uCus6ZgEFYSggdofth9lt3+MS4yUs9C/5aIFKasMOkZXzjnbjjbBTvi/SV43Buz0JABJ/XT22ks9TbN4Z7OoeHkJWiRBQmja4nCxn7A1WTpGcIQHOUuOvw381fqOJoxyye11IAoGvF8lR8Z7aoh/FEGNNZrTRuFWRJKi9k465/PjbxJdCSXSqy/oi2bLalUsuu3YPqKMwGiVaiafK2DYWylX0DRNEAUdOhnsb+Sb2lLcBDV+Q+moRaYc2NcbBmjYX8/SV0XgOBCh9raQy++EskDVwAtHuzPHt6XMjBvmlLLHwWswaUSrRHjU53RHPFciRL2Mq3AIhU1lrpiDRXgul3pDdRjPpFXR/9MTQAlpAbpcdjpEl5vHLuJsjc7BhzcZ7QebB10ItqQHXDCk2ageT3AVgn0sb7C9A8CBiIKhj0djyvk733N9uCpvd3ipY9nCO75wePwl9vd3+/a6FnQCFw34B+yEdwuiU5dAgIvYbmoi36FuOFboC2ZZumlmi0IrOmlPz6nnoQBNrFAmXpn5pM/yO4S4QkbIsHF+OIR93hoQB7Yzz4WSmiSU9bH0X7/0TOI4tOe8zxeAwE0wbXBoMk2xYsj5VIXgsgR/Z+wwVCzt3LuH06uPP3D/0RPRmT/6GneNCujr9GTDus9OJ45tneuxRfxNnF3E9kccnKhFuevl+1MZgmUyXgPoJ48AjH/mb2jj4KLMK4iBbzmCQ4xspb/Fevbc1XPjTTe4RduXrvnLkUnfjPcdVVrn2Jj0Ta8KZXHgxMCkp6dPQeoOnqTzN7q9fsXPY58s49yz4hMdEPS4+iYYiNMvvfbZDms+AnXDSJJRd43FoEfMFKcd4uFKeeie7z4f72Kv2wSbywF9lIdzwJtY1CFw1iFK55koBkiII6cd2LPt1WefK77RMXiqViHMSNVxDJpUUz/7Ku19+cGR/kPrryzVz14vOSLQFegmd/i5x7E6g4QDcMWXQVMnEtohyjzYVMnulKHshu0N2/Xh9Ag7lKWv/va+ifw4CRDd9pVP7n7lqbF/3gGjrNH+sZODxzH+XjMdTmPqaKhrmc/LIUM0VilH6b5Xarnr3diLrgsweaMJ9U2P58VrQKfuXor0JhL71eX6bV8/PZ80NQVC9Z5AHbaEIuyWAPco4AmMXHLYCAtTfAYRV8rJYUCDsV4uMKlgIUQKh9jehxuuetutX3uwyYKUZGVA82QGXiZigRKiNNo7XolTf8MwjfExEpQYRWTfA+nSbQtX7J+3eKPbVy97In1H04gdV7a4YXT3afpgLVAEl1tx+RGYD/ZOgL4i8AUY8712wvi/+ds/m/b89TqAZbU3KnWLbEojtBhNgt1Jr9TGmNOOZWONBZ1SrWmlT1wKFupPr90YCf8qe56dyMUgFfALXrfgdiCyAJVh18dQDw7EkLbAUtRgljfYgouhI4MsOiAC9zE4IbbRwqXzN647n+jBBriCQtEN8gyJKbTQ4KOwVwxc18FoDI+e/pi18l+OL9YDmRnzxtRkIwOcYzv0R/X17c3ti2GDhDrjAP5MS/i6pBiKXYSxvGyzYbbEplIVzBj/ZfoPHeBtuKxzxbU2yYcZo7E8dMEF9zz2HLAX0nk/HArkEbYqQv1QSt6CCmjMtATQz2Z7qDH52nYIkaz8E3nWAYVzE1e0rAMhXuLeQMXtLuiyrHL2qgmLR3cTwsfx4ZLXl8O2CVArj4HJZUtKIPuSdmqGs825b1p86TubZl/lo09EFCYake0sRj9Aj18eqiZo/3k6vOXvEx+7AtzI+0KQAKezmRiM8ZnujrIFMxU/OHpi0OZyr1l7Hiw+kdAEHBhSk1OQ9Vy4cXabw9+o2L2YMxAMRD85ODnPGzkH6F4vNc9ZVYcYnFZyUdjhbK4xAnaHa25b89gI5BRMaIPKga5ULP4VsCmPFwk0WQmxKE8rOyiI2GNHGNQmAZy2WPK78ezU6aUWW7/LhlBODaoCk0sfImSoWqhBdpQR1MuLwJdgPdXEQUZ/HACBg5YuoFlLVy654n+C8y+SbJ7Zdqb0AJOGdQwUNMwvylrMQ+oJA4e7795d+9aXzhM2XHGl0+mvGlosPmj2dlX7x3TsjV2kQpyyQ2lRTI/svwcqLQ80o5YNUivCBahMYFUjvGuuXrRg7ZrZq892hBo42QY7DqNaGk1OGWET7XqdE/GO3/z64KGjm7c8u2/PoTPzQUUzcTPevev5zafySHZ757yFwsFBDNIA9EEegqU1ZkXs3Y0Xkha5xEkASCpRaxMtWEb19a10pN87tQMOWy5DGAevWJ/xVNnerE7VcBtDVd5V4eH14ywIs0OmuySzgBKIL5KPH0cfo2sxpOrdtHxpQ/Pay/1zznXYPcl4KeInb4mOFphaGxWAIBwSJIiqsG4vWJ+eA5lzJ81Zf7ktOFux2bCgMWVPpSznY7uNYgJB3+D0acLrzaQcb+YFOucD1y55x5Wh9ms33fT/7t3+5xr0UdnPPnKIHjk0l/40R6Zwiw9xCuARU7JM/icg9kZOxHd+4OZCMn/tiRt+8O2vPvbkpmnvjPYdG+ttPH7s4ODAsT/9/qeQ/9QS1h0+VygVcOhKEQo5xSnD+Qwux0qWraKRgKFAPoAJe8e6vRRsaXPMW1CifkANgxcQnJwA/dpNxCWBHZgNdnYQrxqgamDxQMeZXZfDkKF9dzrUNGLZWmNOAWOlUDjcrNTNtynoa4qny5KT5jfQ5hE2naAOIOuoBoYpzlEv/DYEyR8EyXaa2GcW1IznYbOq2H3wv+S4SrWSR5xcjGV0AN7Eplhdz+0r9yFg0d3PvboZXTgtdQPVsDjpTqOlICYTQ39atte5FGGvEIjYNkRCG/797E9vvXi28WzfLtqxgzaDUYRB3Xs+mp7xbVlonDvXXN5XTvRhI0WHXSpWYyMjmZNxFooETZ1gGBD5qKFV8Z13g+/8VfO//6RcJx3oVrtT0+PPoUvWw0kc8VhL5ML2pqDIMBhRoiU+b5cMh+Jym7LNzvnJ/eqzx32WaimE4eUnx9w1FJ4L2xdUc9+zv2trITFHLSPM8k4ftwhCH6C3GjAlIF69h0wllFVlnwb/DkRPEbCZFUlho+zO5mJQH6LmgKYEgEJprplj3f0j3XCirKDbLdSaAg58osc68AmPhXNTHr+BCxHYgcrV0pWXCoieWA+0hfp4P9vd8+j4o4m/qFwkIDtl+5JFy/2pdGrY6xfyir0EBWFfLIPgEtlxKgkcAlT8ddS2aF3w3Hd7gvXn3HTB4Fii6Bmk40nEg0lZuDlR8haiLzRTMwg3BHDQisByRAFawafe9EpyWXRCkTW48yXkb7I6oA0yXrBBnmYEYKwVsunPP9qwONh1ILFyDpWPM0qIQQRQggyC0YRjC0zBShwXzZeGE1kpkPUjfBbWGdXKcCy1/1gfQkCh8hg6wGXAGvXHrAbqhXOgNo7XSegJvDsBydfJOfEIu2IEsS8LSp9I9tJTlTTT0sHGhqHAxAOrb90W4xFp8bTNWbBi1TpEKG8KuqJH/Lue/knYSNa3NoyM0ggiGY+/hTqhDYFWZ/OK84PhxSC2HZ2LZPcofPThIAWLD0+R0mm2vKylB353vV3oqQ7sFJNsswnmLwY3IAH6Jr7R5++MzE+n+n/5nXtbLQ1NAAIcRGLykulMeBTW8HQVvtZCdCgGgQU0p7OxJVqVIJ01bZZQHQpIRLd08SNJozSWUHw98G9Me9JAkmwqufuVV/Z0M30HWu0Z7wMMBeA1mgAQoS04XichJ0bkRCehekGL4qGQnjNeeyut2Ep7oojlT11TOiAzwpZLuQTb6h4jo5bQDagWmhgWafbiWRdeffWcRUsvuvKtTrv04uZ//vPuXxzcQZetpfMjmdGh07Kq8beh3/DYghEQX9TH7vVhqDjcXqfX6wvksakfFFIenRpaHJ/82MfMUv8rO9LLFy3vWHqkFKuACsNkA+pZt8ONNVGJ6CPXvxWlNGMIYmAhTC3MiuAWYeQFcPuwFrz9q2o5h1hZkNRiygW4kcAIwfQMensAEmGkd5zAVtUsPfz8AZ/X6clmIckZGh4+doKF/wCsMb4xAgA1vAG448BNpBoyWacz/ADcTgtKtcKRAxxaA/bSdjBxeh+sgKa+BP+cX/7P1zdt2fHo9n0sBBMSDFhnNa1+b5lxXf0JtpvXHsu0Dx27d9f2ptYmSYKZs55PDx/dte34gZfX+G8+PNFFGOnbqKmxuK069TtWA0KBiBxpwQOobl2AO/aaTvv8WT+Mz0qlqr+gSnbh5g/cemTPodt+/k80ALAEZ3L1m+lTt9SZo1HArql540hZumLpShQyC1pvjmaFyAb9AnZhg7lGbkiQ9VR07MOf//ZFjcwXBSJXWJ5j1QzYQUOHiVZ2k8Pb9tDWvsn1+8vD2+qhZi9RtAZj6xlagCbjAMbgtwYc9AdQu35qpOZaUcCGNusMIE5bJKt2H+/On2Vvbmt0S65ND+2r3Zz4vb/84v0/ebF2Kf7wSx/82vf+WLv49kSWSSeLV62ZdDXz6WGssLbO8CgGuKcTvLUVdSEbFWTR5rR5PM6g36dWqmUomu1lDIuHHn7xLw+9MPE+nG6fw+50mfKHbvlCx/JLWzo3zncCIIypvRoybISDxAapMtvBBhoLLf/IcN/5zXM/famd2YAAgkBb4EYNiJCl83567hDe7psof+JkdAJjJ25ZSxngLwpBCYA7TnBgMtg7KQ9O51vYYLcGR+7UbHFaRYIXw/5Ae1t7KZWd+t70K34C+tOf/JfXXaMzvFBAuKTHB3pefgxIVoIDMiKVwZPPDrLkdPucXkSxCHhb2jrunQT9WilJTA9J6YWXDmx/8kkIgSKRJtxPQonQTk3YRCtCnjB2GSEey67UumvP/jSeRi3uC9SSGdzDDRQ+tYhqh/1CZ4D8DFWduAVaVxsS+MUIkC3y67TGxEQenAD0tZGBNgLGCUtWOpEBA0K22yDe+Otjr07cnPGkNshmfMRunr+eQgKbEsAfDJ9kNpqvldDnM6ZXR+jAK1vW/m9ZK8aYGTAsgEUs2+GtJCOaKKij26GcQbqsdXVZT6dyfQM9hbK+r+tEPZTURE/20v8stsT12LIPGjaZeo6N7UizLzd2suiQMLo2oT4CYtY01QLVjbG9fP+rhPqgI2u4jxcx+nBg/AHKEylj9YHNMoZMW2KYyR9hFTC1gUHEkJ14Y8qJm4U/RMBiz2t0wCr6/R9o3QqE3VgyOnwAkmOs72HaCG+k4y9S1wt0394pxeFiaPqNU9e98GK8f+i6j9+tphPlMsILwigZEyPb+Rs2mLDpNGvT5dTXgUHprNrXPxhPZH/3oy994qv/p2N70lzO5/H8/TH61yXU0IQVLKkKXfP1Hrz65x+tI7UXXuiGqIMF0hAbFlZbupnPlJeJbam8XixVEvHY2Ah8d1lQgjP3Xpj8faB2bRDgJggRDnTAKqKnJ2XCV0fGOZ/8OOc98ZxHl2Tyd+xIvBZensts1+Y6EISczXroayR0upucYbrms/TjD7BpPY6Zp/HAQ8+yzeJZnRDzJ0itl1PLRlqxk77wnYnPMcY8efpq+hnqd/Dhu5S6lqzLga0VSgXof6rYmUErI4xFITkWm/6CdZ1Kw+akT7EpJU285M03wLnDYVcK+Vy1bLzlvAtefHr3eqJ3/y/L+r1PX+ZwZk095PTBk8qEol5DlAYdrstqRVMRqFkSqzZZhS2bDy66mD8gnEAM0VqrZ/q2H4ZDDRSATXqcEkkWLAcIGwlb88Ok/CBWA5Mup53uOzBzzAFk81vrGD4yoKou8cqrSIHKDXw3gk0vo4uupItXeQwKwKRuPuwmga8qm2JkWP4AEWAIBEWOncKr6d5P0Tt+wj4KKrnA6oDd06pgXS611k17X9gaWryk6vPDRSRbLiTTqVhspFwsplJFjjs5y0ndhekvxyr4LkZCMZ0/+NzzmxHrlIdykrnjKp/8zuc+K4seh+fLn/5cu2vv/PlNWPNqiOrEUAlOtCwWo2DAyZvZywB/ZbaNIUL3UBmGJzC9QnAMha3Y8YUZ0/4k4fDAwjlMZ102q7Hek0Iw1rF99MSM2We4iXo8g/55jbTGRu2LXfWtbTKiNK9rIwf2sYd7TJBmb6B1qzCVNxvkzVHvKYsP2HCjLAwBMNSWMSWz7ebJO+tU8T6rD+bMtL1apyVzd2IwpVRtaFQt5HVRzhSLyXhidCQDB5gkRBeI/VjP1qjHU2zSY1CbWu9Ytjw8NOzII+QICJdgcjrmEGRxuDzfue22b3z5w39/4KmbblxqMpcWE08xzwD3ER4JCZZB2FwYcmIsA2F3jC0MsPKAbgDcN4p4rQ6ofR/UYzhGjz3SzQWoY354YYIuctEmDOc3kF4b+Ozlsp36RrE/2QFYHogXzGbKWhiVVNzU1M5WEJAGitR7eoTmSEgw0GMHdnQJDmbZCt4A/62Ev5h/XFYQaXwYGIcBi2GhWAyJDIwTKZem6O7hAs9i+w0l2YaQ8VNvW38GT12gl2dMO3fu8gQDELgj1IKiMA8NSZHcleqJE933PvAc5vNLr1z93rfOlkCIEFMN8aQqBVXLaWoVznsskJKJuR/jguEN9O04YHrIpKPjTZjxoxbKsXEA49Hq1tgwT8vcwKieTTPmnnoTAHmdBAcNOJseRyBcuSRCXghpLTAFLjtM4NQJCPYxkz2edQYKip5g9gyshxB52YoTh1kTmzrC07GWAEq8B4gjf6u1lFegDBHZCgjR4pCwOIKIsZBltmDD1nHqzTf85/iJo4FMHTZh8rh9bi/CvusK4pfJNmjOXR6f3Sa9svXYX/7wl3se/OqCDthrxU0Qf4wsHBwgmGYSfdUwEbIcCmhQUcTzw/4nVlSQ16mC3ZoWayMSPZU0aEemJ/06L7zhRyMWg4shKGMDh+IQ7LPZdurYqTm/i5wRcnYw7Jdg438OPb+VfvM1uuUzlOWpYGAjH2ZCDDnlSD89/uDpD6IDwJCB1ACxXKBVkMJbW5GgFFiBi3BbzbEeGv3/BX18JptJgPQj6iVk7rIslCUJEY7tDhvqCe9v7JSIFfT7P/Lhm977vjt/+93/+dS3JmrmDNK7rqvkEcwKexZobE7Bdp7wV4GdOqa210loSIs1lNkUYnGcJatp6I/U67w2+RHoAF5OT7516hz38AQQBtDEEoQnlusMon5gHyrEJ27vYAQfScRzUPZh6j1MOZn1QTzFbN5TSeo5yB5NpKo1R+AtnICwKtCvQs5rPYY8BwI1BAPTZ64MfeQ97/n013/c3XXssis3TBQ47QSUBx7fsqjA45J5ROoq3AI0FZC06LrFJuKVFzc9+Y8HH5j8LkKRHdxJUAVhFCICFn6B/uAjmFvi5HxTz+ssLsVr4RP6Fh0AYKF1+MUBzMX5f06518wCUCChZJQjjh5j3tjpPItBmT5J2APiunmktFP2ED27mS677IZf/OR7cxZ2vmZh1oOspahEcaeGLfAdNuuAO3bQrVMyhvfGv98DEnfXujdNKyc6MmyY9vpGMGa1FLrl0lvnzY0EI55sMT482p1MxoYG+jNaFjsOYHouqykuVTDKDljt6IWkOmvuvl07jx459L4P34ytCsYLmfJ3y07idtPsNoKyzAT9gU8AIqFAYjop1zoL2cHmAb7AmxrqAECANYYCbhYs1gAnaGDAWpFNfr1WEtDVh1GO/+Ep9vSTvnPqFIDC6/gcChcT/UybOArzI5Px8sWDJDTRnOV0w7tY7kcfuzs1OrCgjo6AyrxuQqE4ipb8JANWVyVfm+tf2/PbeirP/eMnS866COTie/Nm/elo93GrnDVc4PJ33iDmxcCcCejTzie28w4zFU2//MzLL27d1DtwtFTMwl8OwnwX82cp1d6dqMjd/3xq4vx1Thr8TDuPGEwYASJUlSVKwgOY6PZ3YLddio9RbpTSI4wOl8GPwEUXUg3oJKrsLez/iZpXLAILqDkswIHYJiwJxMRHAf1lRBcsoff98sMZv7Rm6S8nHs14UkOWBVAfZeNsd0OAN20VCsr49x+fEmE/9a9/j/R1YWeTT33609/+5m19gO5rJ4xTVGIu1m4BeiJJRzHtbc8juwedEW7EyfBAt6Nj1tXEHR0ZzupSe+cCcMGz5qyZXOTss1ux56fTJYeCXjh+FbVsSS/oBNd5CJWZrvC/TYKPvnXrYg5B3aql/OjY6DFz7xG2aEd7f/dJgpgR8x+GFnyMID5CAMKCi+2agegMcAmwg3HInSIUwC0gLH7RTHQDBgcKmZwwMtDIC9/sDa+8gsu/MvlR7fzayzakMumTx471Jqq1Oyjw+7+8R4TiDQmdjGsc6Bmc10AN74x0p1xNRwVTC4SEvjM8EMNBaq+jV4+wEs61sAMYek9yOom0Yn1Ssa+fsYJuyKg82OOds0sgxykWWOB0kmyQJEBaJ4PbRGQNHfEz2Y5syGigmkDD/zZ98VPnNobaS8Vhs1IUq1zaOYKm1VrXvpDxaTA8URA2FAs0aKGx0LEip4FrgN+DYn0RZAcAwS9QE9AH6AFrQOkUFK0K1YgVSFPj2RdXeIeqnZhWz8vPWTarox2GtxDBZ7LdOcs1CoQu3IgNj63SXRb+YlgdnvTqTZ/6yN/u+oLHtCWyo6EmxLNL4uEshZa20bvW49cuqfZ4JvuKR9u7ne6Y9OLk0zIu4EIINu7IURNBg/wBH6IXYGMkh3MMhG9qwkLJBg2kU3F7YRjK+HjMncjCllEWaa6hyNSXZrpCs+oYwFbN29DmXZoudVXK6YzNloxCZccAinT7V+jHT1NlgM0H2B7JgTU2rDpg/eVijkpYNheTbA7AAdAD4qgAugS/SBjr7knmHU6L+q85nxo3fi8X/ZWw/YHDj9Kdf6V7NyNKBv3yts+cteLyvmMDgyMjHraXtnyyt69SLsLRAQWLW8IsokV3ySr4jJ8Xnv1xW2R1WjVkX/muW5pXtfNOrCrhHFnJVFOl3uOl7h76VdfpfVPPKIDBzyxniwYCEAyZsALh7Q6E/atg4UEjw8PT8iNKew08NqbDxWTJZBFoPHoRFQQgHNZ8OO2tGS6BUOgrA5ZMIWdLU1gJlPOjx7VsvcTmSYZHQLUY/fqD9KFvQGnKeDbmvYBdYlyMJ2xY2XlsR9A4MNYRivfEIaZhgw+gB6Bxji7psfQzqAwqhs5osxZAF//s2xr3wOC3b8deMeF306f++M3PeS7B1i06VP+GPt/vbB0JQkaYyeeLZTWdzaa5dHRkRNwUs6rzGj+P/V1bvHDb585zfea8NSqiX3MVHTtqGHnsWpcaowNHCUbUXa/x7sTtbFdXPDxLHyoqJZiVSDB0wP5gLJJ9ooZPExmp91Dc6ZEyiAqVq8imy4NAoSz6IARoPIL9gA6gMwqns7/2Wdqa00IUC346Gb3EM7aiMbBhqXsx/PD8lA1ZyAs4vrSTNl9Fl6ykD36WBbtC3GfNA3cg23e/3NNNPcdBZ+LTPwH6c75CCytMQQbkyFu/i5aJF/3108nEqx9c/vABqzP+uJoCF8CjB3iGSJAqTGDkYJ3braws5vqHRk/2D1Wxk11ZO374BKrxeilaob5j5HgTDI5OQHDMw10V0gTEQS5RKkWj2Nf69d5mzwC1zMnD2TlLVexPjQjLOgRlUJUicKmByKjT0u79x9oaQ9lCPppN6qIKUS3cmkBh5fFpBW/gskZDpr07w2UzdQWBsU+PvPp05OCfbz7vW/ZgQ4iwlQwbTGg5RidKe2o3qd+kt78TkRKYWdyDvy+DDmOU4OmZCQPxyQrI28obb75RXsGH1qwxg/ZIkztR2HPZsh8MWS8AJqVe9AyGM1hLRDKDjhXxJpg3gd1nCwY80E7DGwEOIEePHPkPHcAIRYEOH6fmlSMG9h80WJhZsGvQvx84RnsyU+dQ6/OY2zrdTdi71skb5eyx/jLt/8FfE0+dKDQ0ljg7AmNwqoLNf/SiyZeB0FPSTR8+37q2wQwQuxFhD9xI0B/xq3anVi1ms5ncyeOMDV/oocuuvfy6H/3yiUefeff7PzKliNrFeXTO+2jhEpo9h4bK9Iqb4j1jd37jw//86NsX2Y/6S8zCsDxpPbW/i4a+yroE7d0zo/Zy/Bv4+k4XPKpaMoePlkek3NHhpFTatPXZ7TuO16Bfy9izhSLDg7pwiFN8PFcnlV0qzE6zpeGDx/p7TmKuZ6FcJeHZV156jQ7AbcxWFsnLIQjh8zTfpTlhu4qtmAqwYKXuQeo6ycIzjYzX7OYbr0eMWBiSO+Dd4vYgPpBbcTqdjg2PP3t42yMP7d3q2wth35sNm5KShUJRz0f1GCQbM6cyuMGvfeOmumAlHhvoG9j+8qHk3l4WJ62WjmWpf+e/L4/HbvvyJ6YXEKBz3ktvegstXs08eJ3gOO00ItAgPnWINu/bUeejehuzAR2usHkFKIADhAU5PTztgRHD9BJPXf89snbdOWsgAzF5IYPQAdhaQVX5Z/ZuP7b5m1Z3Tn4PFJM/MMwlujmE9jIHclFtzyuH9x85cefDuydoBmhDY8g3UwcssMjYU6xAVA6pK01PvkAhmS1ekjBYUymWZYxw3pqa1ixsb5q9cDSRYiba2MYVduVSGREQEGdOLnHabNfwNtZPmLh29GJ7OQxMG9tPjxESINwMCRFI/nb3Z7GJl15O+4PiWNalG8lUYQpRwJ5BbQvWTns5eB6ddyFd/k6aPZtxKaBXFasJaUA6yhbrf/13/40qNTlotZu29LP615giEKpr38zMEV94bFqRpy53XnxrXWcDC8DGCtSNSllMjOrF6ODxF+4/A/pt4C+b/cbuuNpzQDP4vpH8X/69/e8nppcMMtgXT5/RAahLGwx1aGSOtZ5GIyyxCWxVSrCvRwgEtAoeIwbbyA1W4E31DYuWnz04GkPNsOMDLPI1CdRe1eHahX1JTKfgC/ktBs7ieABFfBejH+UiAT4zpPOWLhF0eALDowvrUeZ6AvEf8xD+T6mjldpbqb6OOYfKVg8D8vgezCwYtqPBo0xEisiNCJQVtvZURAfgCMHYayOVhkXhMVxNTy7olEJhTXFgM0YoFXRwZyZaXzWqhaip90/NfkN72+KgoLEd9AoI1pouac/v7T0T+hMvTe2AFmZrMR+q4Ag1OGj3w2xxLEEfQNAPMBc5iJfzNkJoD63JOXfhee2zFpRL5a7uE6ViFSJ32LmKmlY1KxwY/jKgjx0rzWBh3iVsAznMFo3WGggtRHlIGAEztDZA3kUrm7lqVlAQuRubUEKbwpdAfJD9PyVbmYVtgD+03foGSgfkk/iNn6Lr8J9FUJYEjB7hMAPxIjZfsWbjZgUxHFf4Ll4u3nbnmR/x4eOxmByyw3mTbX8GMQU6MZ+qRocOWOKDiVeuX7N4Pkw1teLBZIwbTg3HehGo5tEZWmm9ITrAdU3qAOAM9vKZw8JWtHgIgQU6bbTvAaa/hhSlgj1ZAyQ32VvmrPf6GyPhTmxD1d3Tk06myskSFLyM1+K1igKPKr6CrRWxqIWkks/L0ewAs2VbYREhVB3EB5QHLAbGwYxJR7Aqu24qCHGGfWg18M3xVHrGnNNvvvwAGUfp3VcxZh8Nw2fQ1RgNzC2k91Rm8JoZWMBDNKSytRqGJHJKEJS+uEd4s/b2MO2Nnco58WcQNmqHXp3bauPFABw6WIy3SqGailbGIBqekhqwuR22lqoUEtHkWH/+6QqjfK+ZYFdNmf8PS6kNa54v1vIAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|████████████████████████████████████████████████████████████████████ | 1/12 [01:27<16:00, 87.35s/it, test/blurry_cossim=0, test/loss=0.904, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=1, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.521, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=1.37e-5, train/num_steps=152]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n", + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|████████████████████████████████████████████████████████████████████▏ | 1/12 [02:29<16:00, 87.35s/it, test/blurry_cossim=0, test/loss=1.15, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=2, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.417, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=1.87e-5, train/num_steps=304]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 17%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 2/12 [02:30<12:08, 72.89s/it, test/blurry_cossim=0, test/loss=1.15, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=2, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.417, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=1.87e-5, train/num_steps=304]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDzzx+3i/S7u2i1/T208SgvbjKOGxwcFSRkZHuMg8cV2fwy8Hw3PhpvFfi6/ujp0JaWC0klxHJGgOXfnJG7OF4+7nkGuG8a/EzVfGkX2e6jjjtwchQOc5pNU8e6tr2lwaDCFit5AsRVR1GRx9K8qrSrckYUoKKvq30Xf1+YKHtHeW50fxD8aw+ILbRdcsI/KhLPG8Gc7GRhx07rtP41meJvENqfCUlmfmuL3ZsUH7qqwYsf++cD6n0rIg0+IyWmh3dzDBZwyGe5kmlWMs7AfKNx/uhenr9KueNtH8PLbtqena1DLdMRvtxcLOZDkDIIJK4GSc5z7VVChFSi/Nu/z0MVCUZ2l5nPeFrOzvNajTULhLe2wwMjttGdpwM+5q9F4E1zUNTe2020NzGDnzgwCgepOawLGxudRu0trWJ5ZXPCoMn1r1vRfGI8E+GJ7ExK9/KSxZj04wB/P867HUhTqXk9+h3cs501GK26nI3Grv4d0efw1cRA3MW5XZTwd3zfyaszQfDCapaT3F7ewWCLjyWuZ0hEvXO3eRuxgfdzjPPUVk6hPc6jezX04Z3kbLtjivWvEur+Hde8GaLCDFmEMCobBXkVz4zEezcVFP3uq1sYyoylHkbafdf8E4SK/sNHiNrp87XjFiWZVIAPT056dqsaL4aufFmqNJes1vbKjcrjOcHHX3xXXXWk6BZ2UNtpEYkndRuKksSxqT+wNZ0rR57wzizcLlUZAxP+FefLFNpxo6SfVnbg8to0nzVXd+Zztr8Kbp/DWpa7d36QW1lbySkFB85VSVXJPBYgL0PWuX8L+FNT8W6jJaacinyYzNO7OB5cYIBbBOT1HA55r0Qa1qd78Oo9AvbqCSLUrppX+QLIIIym3AB6NKsnP/TIjvxS0PVLfwB4r0e7U5s7tZbO8Hfym2c9D904bA67cd692MZQjy1WuZb21X4HLWivaNQWho6p4vuPA3hPSvDlvF5qRtOdznnBKt6erNXm2vaxJrTW7yKgYbmyp9cDB/75/WvT/HcngvV4RNNqE809vloorVWVpMj7u5l2qDgc4JGOhryS0jthdCS6lVFVsiNd3PtnsKyU4t8y1sbSqVaVF05q0X5fMrfZ2Ay3AropEsx4asHMipKFcOCfvHee3rjFRNaR6xLtsAjTH+J5G4x3JY4AAHU1Y03wtaanA08uuIzBtoWC3Zs/i23H5GlUqQjDmqbGuErqlzOEL3VtfkL4rstF0iNbPTGEkjcu5bceD+ldV8OvC2kXN9p11eTDzPOB2lsVzvw90LQNVvp5/Ec0yWsS/u4422+YxB6n0HFQy6Bdpq/lxagkVqJPklB5UeuP/r0YmEqtowdv62ObCyjSTc9WVfGepWmu+L7q9sigt55SEVFxtVWKL155RVb6sawLiHyJdmc8Zqxb2Nx9rsw0Tqs8iCNscNkjpXR6j4Ou4pleXKKCN+R0Gea0c4w0MJSsnKR0Oi+D9W8OeH59WuIJILhow7IyDcoz8oP6Ejj0PSuZ1rxVealdITp9jAV4Zo4Ml/clicH6Yr6Fbxf4Y8UeG7mF7lYrmYbHtQ2ZF9x7e9eP+L/CS+HdOXVrVxqFq5Ks2wqIW7BsHv29cH0ryqMoTqtys5PX0Pcw9SniMLHlfKltpvpd/M6LR9XsJtB+z3AiwyEMp9K8sj0ezk8WR6ZLqC2lnLOI1upRlUyOC3oMkAnsDmqEMup3jN9ljmcL1ESFgv1xXUeJPFmmXehW+k2/hSO1kiQqLi6ld5FySSV6c5OckkdsYrXB4L6tVlyy+LddjzKlaEnodXqGhaj8NUW78hrlhkiXblV/L61j/wDCyV1p1tNVBggkIV5FGdo9a6n4Y/Eq00PwvBp2pujhSQvmH+HJrC+MWlaLPFpvijQI1SC8d4LlUPyiRQCp+pGfyrSWXU5Pmkr369v0KqVqjdx+v/DzUk0uHXvDGqQarpVvC2596xmFQS7feOCMsxPpXAW962p3Mb3k6g253Rpj7xP/AOoV7D4UCx/s+azbxSB5Hhn4XkkkdBXm3w206ObxAdUu7WG5sbBGZ4ZvuyuylUXHU4J3eny4PUVpToSUXGTu+j69TOGJtUXMrpGXdSmTc3PTGRT7TQ1u7u3hfcqSSKrMOwJxmux8Qa3pWoX0cN5o9la2wI3PaIY2C9T04P4g1rN8UPDZ0K80Ky0WKJZ4HSKYAlhKVOw5Iz97FQ1UWkDurYiFa1kcLrPhabSd8cBfb396i8E6hDH4l0/Tb5f9DubtIpHVtrJuYLnPTAzmvSdN8OT+I9FE016fmBGABXlmo6G2keKzYSXEYCSK3mFwMZ59eKzw+Ip126UwxmG+rK8Xrszsn0OygkSFTJCHOFWJssfXAOc/lxWD4s0jT45ra10S/v7+9fPm2rQlmAAzkEKuenTB+telapqOj6LrF5bTXcSzQkKVZuQMbh+jZ/H2rzW88YPZeO4Nd0iKGaW3QqgkUsjkqynIBB6N69qq9WWMsrqKXyfqfPOVR4hR6JHtHwo8UeF5/BtnoWpyW1prVofKktrobHdtx2FN33jgDgcg9uRnhvHI1jxD4m1NNHltzpNoqC7vWcCOJiOm7+I9OFBOeMZqjbeJ9L8Z7W8c669pbxvlLGzg2Ifdm5Y9uM1e8WT2I0e10zwxC9t4bhbzmlcMGnkbGXIbnA6Afj6VnjqXLXhW0vayv52fz20XmdXM5Rkoxvoc3pH2Tw3eMr3BdrjkSyjYWXJAOMnH5mvUfC8C38xtL+FZ9KvAI7qKT7jrnIJ9MHBB7YrwzxLcy6jexzLERbwwiKMDnaASeT9ST+NammePvElt4f8A7EsliaEq0fm+UWkwe2c47+lXQwjlNV5O8uprhqspQ5Y9T6C8Q+JPDFhp6aZprWMNtEDsit1CIM+gAxWNY+JPB83hS+h1LU9OEbGRZYJJ13MNoyAuck/QZryaTSdLsL5bW61BXkBAY7x1rL8cjTNO1OPTNEJNlDCvzMclmPJOfrmtMPh1OtPEPe1jtr4GFOLm3t/wDnrN4owxnhlkU/d8uQJz75U5FaWr+Ibq/wBIt9MWCG1sYZTMsEIYgyEYLksSxOMDrj0Aov8AWVm0bRrc24321s8bODjdmaRh/wChV1XgrRtJl05vEWuOqWVtIAkb/dkYdj6jOOO9ejf3bXFThGpBxjLp2OY0LxNq+hWU9taqXs7g7mRlON3TINamn+LJ4oWilhWNXYtx/n2r2y11/QfFeh3sa3EEtqI2FxufaEXGSxJxgDrntivAL6w26ncW1tIlykTYEkMiyKR2O5SRXJOpfTYzjQor3pO7LmpyrqMLlCMY5bPA+ppngLSrPU/FH2e7Y+WsLsjDgbuB/U1izWtyZVi2MeeBj1rtvCvh4XIe3glPmtxIw/lWUqkaFJzk7o1pWjUVRdGW/ENrFpO600/XFSSQYEXmDJJrmtL+G3i3XZGNhpjzjPzSeYoUfUk1L4u8CX/h2RbkM0sDn5mI5U10nw71bxJ4fge7stTaKGVgWt5I1eOTbnrnkdf4SD71lRr0FD21OS5X2Hi8TPFzvJGj8TPhJNpk9/4ibXoZI55WkMc0XlkEnhQdx3Ht0FcJoFjHpUtxfXqF1S3kKrjGTtOP1xW23hWPR9OuvEfjG9f7QmDY6cZ1+0Xbk43HJJVF4J45H4Z6yw8M2fi3w5Je6bdFoJonQcDcj45VhngjI4+hHBBp18ZKEYzirxfXc5qCpThKdV2Z4rp9ut5qdrbyPtSaZEZvQEgE17H48aC38IXnkOuR5YAB/wCmi1wupfD/AFfTh5kMErsnOQO4rn9S1e9vV+zzyEopyR6mteTDYxqfNdx1QYPF0nRqJddPzOw8BWlvrNw0NyoZT8pB7giuutPhno1j4igB1IWsNywjijnccyH7oUkgkk4GOetcd4bmfw3oo1bZuaRsQq2QHYEA8+gyPzrvNe8HpeeILbWdS1GdxbMjJEoCqoU5x68nqev6V5NSrVoY32qlan+fy/UvDZdUjPnpOzOB8ceFrrw/48ht7uGRYZyhjkI4ccA4NHxP0XT9IvdNa0n3z3EBeSP+6AcAn68/lXpfizxRZ67DHBJ5ckqsDH6hs9q8d8RX10fFsNxqVs6iBowIpF25RTnH48170MRTqRvB7muKU6cXGpu3dmXcaPqsGmJeXFnNFajhXddvU/410TWlzf8Awns5rYbls9SuFnQHkqUiZWx/wJvyrf8AiL4wOtaFFbWliUtpCDJKTnbgggfnXFaH4gOl6Vf2JXK3Ukb7ifu7Q4PHvuH5Vrhp06urdkzmwsk5WbsmmN8Mauum3VxBPGJbS9iMFxGTjcp9D2IPIPqBUsF3r/hSSVLGRo4LpiqzRxpJFchSRlWwQwGexOCfWuk03wtYal4Lm1WKNxfTRyGMA8AgkYx74/Wrnw9v77w54Z8WW8qMhvrMpChGT5gR8ED6sBWdSUIO03ozJatqLvY5TS9Uea+EepyKjyNtDlNu0n1AHT8PzrVtLjW/AvjVLfVLRrdpGVyjEMrIcgMrLkMM5GQTyCOoNcRGrz3CKCSzsBmvRPij4y/tq7tLCAgCwlldXUfeEscLH8d4kP40qlGhK9O1kyozklrsdr4p1aDWNGdDghkNeTReJ7nTbM2UQSRFyEcnnHvT7DxTqD2E2n/YUu5JEPluoO9MAknA4IwM/hVHSfD91ealbR3SJaWzyL5kt3MluuzPzYaQqCcZ4HNcmCy+nQpyp8ml9HcXNJP3TGJJOScmuw8IfETU/B9hcWNtDFPbzSebsk42NgAkEeoC/lXRah8KrMDZo1/d3uCCbmWIRIR6BOW/EkfQ0eIfh7ZeG/DMWquj3Rs7iN7mJ3KrPGzBSuRyOwyOnNKpj8NzRpSfxaL+vUiycbp6HR6P8XrK7tc3VrHHdDPyFjz9OK8uuYtEvtduJZppdPsSWkJUCZs4J2qvy5yeB2GRk45qRdS0DU/EGnRw+HoNMs2uYxMY7uaR9m4Z5diBxntVn4naHa+HvGs+n2d4t3EkSN5gYE5Izg4Jwf8A6x71VHBwpTcoNq5FKn7G/K9GJq3iaHVbWwsNP0aezt7WNIYw9x5xbD7iWOxeSSe3p6V6N4j1aW8tGiRlUsuOabps/hi58O21xFeWqy+QN8bSAMrAcgg81y+vaff+IHW100GQOQoCDO4+lFWnQaaqL0KlicZRqwnSkklvco6x4G8XiP7TFot7JEBu8yGMsMeoIrjtU1XUdZvTdandS3VyQFLynJwOgrQ1/wAIaz4amEWp2jREgGtPwv4Qm1+CdrZWZ41JwBk8An+lbU1GKXLqd0JTzKq58y8+x3Xw68DeINW0pDfadJDYu23zJ8Idnc4PP6V51qMHh8W7xWMhOCSJnf5398dAOpA6jOCWxmmeHNV1Bbp7Ftcu7GzljdJQkxAIIIIxnHc1n6xp9np86LZail7GwyWVNpU+hGT/ADqIwjGbitG9TjxEnU5YJtJf1qek+GNSW1+G8csaPKbZZfMCKW2Hex+bHTgg81xlpqepeILw2kG1JJjtUD3qLRfAviXXgr2elXCWp5a6nHlQqv8AeLtgYqDXdPi8M62tvp+rx30kQDG4hQqqt6DPXHrW1aDqLpdbE4anGhJy3u22bOt/D7XvBtvHqWoWuYFI+cEYBzgZ/OoE8bRxae8aaTA14chZ3OQnvjHJqj4i17XtctNPm1jVDdoyM0MfA2AMV5AAGeKr6VrNrpaxONJt57lDu82Yluc5HynjisKWHlOKeJs5Lte3/B+42nNSXKloel/CHwe2oRXniXUopOT5VmzZUMefMfGORyFB6feHUV1Ximxt7XTpJGGAg6/WvPbf40a5GyiS2geMHkDg4rpoPEUHjnR75hiGK2CeerdSWJ2gf98k/h71vKvX+sU4xTt37FUY36nMeCPiPPpun3OmXsazlYJXtJGOCHCEhG9QSOK1/EHjOx8V+FbjTIWaG4uTECrofkxIrHnp0B71hfDDwxpWpaul5rd/HaW8b4TzJFQMce556jp61q618P7vR76ZrFZZrRCSknlNgj/e5H45rirZdSq1I1UtYu6++/5muBo0Zz5arsjip/DMloJGiZ52TO3avJ/CucbduO7O7POa6IeLrm3uC1vBCyg8eYCc/kRSaz4m/wCEjtoIb2xtYrmEgRXURYFU5yhBzkZORzx26nPVS9ovj1Fi4UfbP2D0/ruYKtvCxs21c9ew+tel+ELTxLplnDdWNi12qNuD2bLceWe27yy20+xwazfDPw6/tp0kkvVMJbH7rB/XNei3Pg5fC1hcX+jNMt7b20rwsPmbfsOP1Nc1XEQm1GGuo8RlinRlHEytpp1OA8ea/qeq5t9RUrdjAMb8OvI+8OoP1o8Ia3N4c8O6szXos7ieJkjRkJZ8qRxwcda4LE1rOGkjdHBzhwQa77WNM1DxB4ag1Cw0y4kWFMSGKMsMA9a6OXk0vvrc8/AJYKSp01o7nE6fo2oarMI7K2eZicfLXqXgfwro2hXP2/U5YrvWLZw8dsX4tyOhZepOeRn06d68/sdZ8Q6bZT6LZNLax3h2zIECs/bBYjIH4gdc1WktNU8M3dvcuESRlJUpIsi9wQSpI/yKqE5+0vJq3RdX6nZKEUtE/NndePoPEXiPUjdRO8sKrjYrhRj06ivPodNASV7pygiJBVcEnj16VrL4s1+7t5IYcMMYYxx5IzRo9lBLo12tzKI5WZgFJ+Ycen1pV69S7lLbTYttVGpW1t8tDJnWyuPLjs45RMSFVeu4noKq3FrcWF00F1A8MyY3RyLgjIyMg+xFS2F2+lavbXiKGktZllUHoSpBH8q7XxT4h0jxLZ29x/Z8cuqvCRLOGZTHyQBgEAnA75q23DzRg/e9Td8Kz6Tqvg+6iu9B06XaCPMFsquPo4AYH8a8s1CJY72URxeXHnhQSQB+PNeo/Da5VPh74rHl5nstkvP91gf6qfzFYPglZte1vUIntYpovsMwLvGCI3ZCEbPY7iKWGhKVVwezOxxpzopt2d/yRymmaDqOsI8lnD5iIwVjuHB9KTVNEv8AR3CXsPlkjI5qHTdRudKvo7u0laOVOhFdBqmqS+JlFxdzhrhuHY+o78CvTo06FWm4pPn9dGKlSoVaLtdTXnv+H6nN2ts93N5adcZourSW0kCSKRkZGauAjRdUAEi3CgAl0DKpz6bgCcdOg5B+taF9qFjrTW8CxyJJvwCfQ9q82o5052a0IVKk6Tu7TQ/wzbeIVie70Z5Y2DKqso4JLBe/1r0CPxb4m8HatGnimUX+nXkTLHMUVTGw/wB0c9hg+oIPBpmp6mfAXh2yUWT+bdOREsgKgquCx/VfzqnpXiCw+JWpwaJ4kmi0nSot1zLd/aFjKlVKqAzjaMs4659PcefhqlatUc3BKLe/U4q9Su60YRfuJa+pR8S+LdF1WxuFihTzGX5euc13+ifFLTbDQYNBt9PkVmdYnmJOwBnAJ6ehrgPFXwi1Dw7N5kE732mNsMd9HGAjBsdcEgcn15qW+1nTZPtJhdJEhAeRozkD5gB+tJUlSl7OlfW9/K9jbDxpSxC5/L8TuvFK6bqmmv5ZTzguUYHnNeRa5ZXrWTSSKTHGM5x0r0HwnrHw1ntRJr+s3UF35mBCYpNmPXcqkfqKxvidpN/ceO7zRNItyulWyxCMhuG3Rq5Yknnlu3oK3o4X2Ot9D0q1ek7wjds4Pw9c3UN8Y7YDdKu3JGQp7Gu/8IfBLXtZt5NR1WQaZaICY+VkebGc4w3AyOp69vWsvRNJs9A1SK0vJ830w3qu0428856dj3r1Rn8WS6FLDoco8iRCPmQEenFXUxVOGstmc6wsnSUr6o+fzo0t54nGj2J86WSYRIfU9yfYc/lXYr4LufCuv3mn6liSPYjw3KKQkikHP054we4NYFpJqXgLxGZruxDXiKSm48DPU16VovieDxKzXXiG5s9NzZR/Z1nmWMSDzZwxBYjP3QKnFzcsM3T12MKa5anv6HnmrXVz4X1uG/0i48qWSJ42+VXVlIwysrAhgQehBq74f+Ij+HLSaKx0XR42ucGd9kxZyM4/5aYHU8ACrfjG1064RjYTwXSr/FbyrIAfqpNcao0uSHEi+XJ/eRj/APqqsBiH7NO2qLqR5W2tUzLI5wCDV9bDVbW0N4bC6S1GCZmgYJz0+bGO4/OtTSPB13reo6hZWk8fmWnALjAc84Ht0pt14g13T/D83hG9QR20bj91LHiSP5t+AfQk55z7cV0e0ldOk+33GMqVSnFTeiZlNFdanKHgtZXAAX5FLDP1p6xahoV/aXktu8MscgliLr1KkH/Cu+0KKDR9EtvtEiBgu9yTjGecfhnFS3M2g+LLW8W7u5obLTIDdS3EEe7DF1jROePmL/pUvExrSdne+4ThOLvPRnL+M/iBrPjkWQ1Zo2Fnv8rYgX723PQD+6KqR6Xpdvp6HVHu7e7I3FUUHg9OCPTHfvXX/D7w3omoX810M3BtmUx726E55x+Fdb418EQ65Yi5tgyXcIwABw656H6cmvIxOaUqWIWGbaXV3/4fQ6sNh1OMpS7aHlJ8ZalZ+FbnwvYXb/2RcNvkjkAJzkHjPK8qOBx19ayNNaSQzWaD/j5UKfwIP9K9f8I/DyDTFGp6gzCS2kS5AIHSNxJj8duPxryzVvEE2peKpdZliEczyBnUe3Br1Y1Iy5owd2kY06EaNWLq/DdX9OpXvtBv7EgtA7IRncBnFbug+J7xbuOK6YNsRIlJGCFVQqj8ABVG48WXL8IgI77q7rwL4Z8KeJNBm1rWtct9JuY7h4TDLMi7wqq25QSCfvY+orSMXLD/ALx2kb4mFCNd/VnePzMbU5mvvFds6f8APsgOP996+i/CEYj8LWy98H+dfM+oa5pFl4yl/s+drrTEVIorrYVLYyS20jOMsR64GfavW7L4hW2jaAElZcopI565rxcRzUXHmi3dDVOVeDUHszhLu+XUfjZJHq1qZ7CKbY8K8YUJxyPfmuX+IOoSa142vrma3SzAKxxW6nIjRQFUfiBn8c96nPjEw+I7vVbiyYNdFZFByMrjAI9qydcu316W61lrdLaM7FG6bmR+B8qn73ygZwMDAyRkA9eFhWhKMXG0VFdtyMUqbhpK8r/gej6F8P7jTfBN7FfzyRpqyRSXCoADGiNvXB55I6/XFZ3iX4S29ipk0nUJJVC52SgdfqK9cgB1b4T2V7LIqNNpUal8E5kZAoAA5Zi5ACgEkkAAk15Rr2razpM8llehY50wHTIbbkA4JBI71pJ1aWr1ud2WYWjiYSTa93o9/X/P5H//2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 17%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 2/12 [03:32<12:08, 72.89s/it, test/blurry_cossim=0, test/loss=1.24, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=3, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.394, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=2.69e-5, train/num_steps=456]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 25%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 3/12 [03:32<10:14, 68.23s/it, test/blurry_cossim=0, test/loss=1.24, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=3, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.394, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=2.69e-5, train/num_steps=456]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAACPYUlEQVR4AW39B7hl2VXfi66cdg4nh8pVnZO61epWRAEhEEjCgDEGGwy2L/f6Pux3zcUGX9skR3DAgANBJCEQEigLZanVQa3O3dXVVdWVTk47r71X2iu839jV2O9936vuqjp1ztprrTnnmCP8x3+MqX71eprGSa5ZhZIpiqoUBX+ofMXvv/ql8uu1HxR8T36qKFxX3LxG/ua3/Gt2IX9x2ey3XCk/lLtyi1zuePPO8lG5anbf2e34gdxCnvDa9+UxN/8x+0su/58XyCXc9+YFs4tUJX/thWYvJ5+dPUBRdHmKXPo/L7/5Pq99g1dXCk3JpkmWqg5DkIlQFUPeudD12VspilZMTVM3dLXaVH/lu99+bG0h58fx5N33rVuWpzj2dJrl5bn2yeNZqvXLDw7tVsYVGo9m2PIIXkDNZ1/IhMgzNTUz8ixXVF0reHle+bURy6X8vvlLplBG+z+/x9ez/2UUr82z/Hj2CfkW45I/GPXsI7zm7G8Zz//6/s2veLvXPnjzov81Q7Nn37zbX91IbiMXyEdv/qkpigxutog8jX/OfnHBzRvNPsm35Cl8a/b4137ExMw+yj9n9+TdikwvdCaaaWPe+GzOj3KZv0IxNeYuiqeOZfR8fX65FafRwA8alhHG8Xgc2bXq4X5n+c5K58ZePBxM732wsDStyIpMBs0zZhM/Exn+LZIii5BmipHzqNk7vHbdXw3h5ij5l7y1XC7j4K/ZfPHnzZkQueLNZ3/KVa+N8ea0zKbm5v3kz9fueHPAfEK+kNvJrWcflfvPLuIbMmk3/yn/uPlR+ffNh92c0JtPu/lwNZefzj4oH735Gf567aFyw5vvzITyEFXJZo+X78tgCj3t7+eqq1Xq2ezTchMGW8gEcuNSkZqWNk7VOM9Lhe53x6cXWuWmk/pRw/Q6o/5osm+4bhYl3Y0LqyvLu1GkljNmWhWpmL3bbJZ5Ns+9eWdeQtM0Q8bEW8rDWGNFY+1nv25OhQzg5jzIj+QHs2/w52w2ZKhc+Nq45W+5ht/6zS/lZ/9zoDJ9/Ezjv9lHZrebPWt2zeyj/HP2Sbnwtfn8X5fd/ErVZreRD8pg9Nc+N5t85pLPs3RcInf4X8+Wb86eNRvtay8ql8y+aajF4cFGde4EgywynswkyOV8np3CFxe/9dgDb3ooLNTptMjjdG21mSZBtzMqOeYkjmoVXbW9YaIsNZqnjx0vonHPc6comJla4WU0mV2RndkL/c/3l5UwFA0ll/EU5ne2YlzEJ1QRKRmqDJPvyN8yoNkkypXyHV5ttlwaO3X2PRFo+Yk8QpSffH1zvRnJzdXln/JBuYyf3/w1e8zsS77NN+VV5fbyjNlTbr78bO74xs0Vl4n+/7qN3OOmGeMr1AYX5wzrtc/I42Td5ZXlDvw1ezm1yHPmSddUU5naynQ6mwJklg/I/7IUMnueEtkMMkNtG4aupwnvpntls5jEyjR2yo7uelESOEY66h2Ew4m6ZOvyIKb85pzzYdFmTAv35JvyQrP3MFRtZhfEPBZMJC+fc5HMlki8kaUpMiYfFFGQN5qpxJtDYUjyhcys3E5mbvZP+VKeMVOyN6dLPirflIfOFltUwew6viN/3/x1c37+6v3khjKbs4/x9eyn8g3uJD+TO8z+Obu1/ENuNfsHVzCzXCZj4k34k5mYDVuGyvc0biNmgLeUrR8nEX/LdfJj+SXXyzPlG0USJDJ/mHPFsIrJZFRxnDTPXNvSbWM8GevZVNX0PI1VvajWrN0k1Gxv9jryeZl87iITlc2eKZPJ2/BN41izSINsMMmjXMt1WTZXJKLgeezvTDdmgpOJpMsEiOqU95qJB0ZGtM1NUZHHyC9uix2Tv/lKBiBDkI/K4+WpN6/iSTKRsoXkr/9/v2Yj59MsL3/KLWaXyqzMhlaInDB3MpaZWdOK1LVU5iVIDUXFvBWmkqeMXt5F/tdwOW7OijyvEP3CEvFzVR8cdIy85DbX2RB4JfK0QjWYOH6sqNNoEqN/+F4+NXLT1HTXdNJpqGZTx3EUyxoMfXmNVPFsL416cZqUuYUpS8rdjUxHzGV55c1lnmQG+aJQDCOTTbDUcKJEGfkRCul4y7H1DPkJpsV2L45VM9fQ6QxblpEZlF0ko+Y2rM7Nm8pkMRx+ILOt6vJT/imbTa5gpmazP1tNnnzzVWajnF3Jxf+/v+Tmf/UduZWI7OzW3J0BYN9kAIhTxdA8R8+y4miSnWqbDZMZ0wNFfXk/zkU4NJmE1wRAFcdvdufZvUUMZwPSEatUMRlvScZgyHKieuRz8hzErCQeqKqmBfOS6sxOGoYDJNbV7TTN4olfqrjMxmjka/rEKpL771y0dW0cRamqjifcx9zrIcRiGkUeZ9pI/mYHDMKM4RRhrGpGpeQm0/zGIJ6rWi4jzvNjDRvl0/WTeFrYrpnnapxmaV5kmsYcIDpMMJM9WwUZi64pKQuvTPnBVOHpFpLI95l9xiJSn7NVtamimzjeyMRMvmUaXvuPm8qXIuWzJbg5A0y6jiTlimdqJduwkClDxWlnlpDGJE2NipmrusUyI8A5m7i4d8n2I+VKDxWKiZUhi7SLH57OREgUq5gJ0YeaqxVamh/s7x43E08Xn5OFyNRsHGi25gwZpKl6ZmFHSs1R9DguuxrKYTgeEydkWeLZNvccJdOyqtnlqjLpZWwYz67ZDguXmXkcp5VFK4qK/WEcYXe5vQxTVsDA7iBavAw+a5iI08VIhmGRmXwnZ5oIPRzbNIzCtjRDV6aphm2LpsyvHiXMtjotmHYmV0SfO/IuVVOt22agWgejKeuE4kSM9DxbrDAQbZDk/VRPM8bPt+UzMuX8kj3Cf7Nvz9STfFOWoXAd3iJHf/LjaZbqlkbQxKcdS2f2GQ/DsrlSZFpGxYzxShVHma+oh+Mp06xrmoWrwm7XrShmBNlyy0KQ+dAgVNIwrzfLynB8pmo6LgaTV0H5qGGpuHp1fOOwc6LVKMLhYGLWDadmW0yXYcikWLw04zBVna9z1bOsZBp7lhsZZpxq/jh3bcUyNMPUvExxKvpUsff7mYReMiymnAXAtqAYWVFGqOViejMljZVBPDUNzWQbq1mGsBVaOTPRMmmaEmDUXUQ4QyAHUdaZpPJJNOpMfMu2EufF5jhCZPGvUTeyAw11pak3jJQ9VGUaRnGf2yh4H/IeMmuMmCURyWBJxKzwTb7gnuybLJkyUja7oeO2GVmcGyrCQOzKVTqTy2a15D76NCMAkrvNVk5ZKBWNksmPWEC+7QfTzjhlqdYWsHT4NLLTSmYRWsrLhnr8xOmvfPPF97zlHnYJP0pyxdDUtVWv1l5/9gvn5281FuvuOBpP3Qh9pKhJrWYbsWpbDgadOUJxa66SjtPcLLIwC/RimqpT1tIodMPEiDAgJqPiaLxklmQOqtNMDeQnS9EM2dTkAuSeJdAZD4YryYpY05h7o0B61DBmRpEylCreV171uPM0TAuGxk91beYt5dkwJpRHYRhifWY6H9URJ9lGV92W6eN5uWsanl5E7N54yrbKRJ0pUxZKrOlNG8U3WFMxmZ5lsCmZLhTBFEuYIM6FidJQ1Bh7jzpUM1aSTXg4zLAujsXiaBHGF6UtqivllqahOKaRT03dMV18nmjqWowdeVLw7FWT3RwzygfvuOX81d1zp5eVfBqrqp3rKPBCT5bKnlUyyum0brtaxu5XeY8wCqqWMY1iphIxGYwn7aLqladZHKlmgVFBgKZo7NRMigQ9nysZe8eTCJnNqxZmpKWawV7WUiVWcys1U/AOMW8ifLI9ZPvLtpfniWFiGliA2eeVYojqwbzLmrHxkV7edCazsilTkWpRLogqn5w5RnLnmYQbBlpBVFaB+2BneWZZojuKhKdzLc+Wf/FIHsgtIi6WfS6qjPnmC9YCtSKOgdyaS/AlEJ4MF519IXKTI3qIOHOFvUIONARlLE5M4WgKojjBRwp4Y8QPmzF1S2owirV21J8Uzz6zvXhsWU00xdTZeGGiJKazOS5OK5VRd2BW7Ea9xLhYv2kkTq6CJsiTKAnzJNHVfhTolmU4kRIzQtGQahBhZ0SFYlkSBHsmaOgGcfbZ07wc78E+QeLyqUw7u1I3GKgMnj0681gYh6bLiHk0Znbm16GTZ0vFEOXHBvuVISFTokBYPLYFX8yE+6YJRGZnM3vztjwBqWel5Bd34tZyPXtPVl7kf7YCM7cFn5iLWXmUIIttoRp5B1FwIhpMq1yNpsqRdtF5zHnOXpOXwQmVkXGVwRX8DF0mWlZNEnwi3ketug6CVdiOV7aiaXjbHSe39wbsMEsv+7uH2IPdyTg1i6uXz+9td6dJ3Kg3igyVqJeqJTPLTAsJxG+1ZKupZpIFySiKXviM21geTjXVa0wNU6+u6paZosqJ+NA2Gv4teyg3tILdjUejTcbKI5/4Z+/94X8XhpMiTyzHjKIARZEUGBduPc3TqWI6sQg2gEiimqaS4p2iCkVsGSoyOZt2tBf6wZpNCndm1kSzEE8YRTJVbfQPYiELJyoL28VMytoaGBstNWbKjMkUuzTbCPyFouDO8l9WgFeaeIEs+cyJv+n1yLJyL7SlfIhfzDQrgg/Gh/ialZS1DdMpWksUs7xcQdSDp4ln8YNvu7fseVzycVWJgnGOwWPLqTn7KUySmxubDc40qqY2DRMnj/7Od79BTZRhmsTjXjpNdJPJjfF5i2xSJImpGZ/7yG/+yDsfKk3Y6gK4qVjfJMWA6k4lyvR08bYws5Jbvr3rtAyMQ9ny/METFat47iu/Xm2uHnXCO1//cBjwSlZ3/0L72N0KNsxWTFfLw8QPD/xrLyzf9dZRd2Np/uRULZl6zMCmsh9Ug/kWixLKDNgF04WHDqKbx8wNjm6AIOIYZhnyKVNeYANwaE00h7gBLJiKJmJ6DEIoZhMdI/sBF0DcDb4ssI2CHLAcMu2zgID7y85KkUCka7aPuEBWUREwWcSfNdZ4A9k3YoX4PxOnHvctKRqVlukaSZwZjoZiyFkh9Biink21Umk6nliW4xklFBsvrlgsnI1V5PEWBr/RLDtukiaO5XYOj5S4cMvW0VbXzPA+jdEwqrebSTSxK+14FOiOPhwEaJfyYNudxttPB8l9P6T1RtPD3sjSW83WsbITVmrlb//A24pw3JovlVpu++SZwk5Hmx9fWho99lv/MI+s/a3f23j1t4Nr5w82nkiUCCQceWKw7Fkbw6gWtqmYtmt7tsPmcW1Vn7ievbP5PFCLYpWikU/0iPnO9PGov4nfpihmOs6mkykeZpokGOWpYjB+XAXR8KJdFBw3/i3/swlyBasQxTlmFnwgyvJxnPpxOplmUVoEaT5OsjDNw4zYnq+nxGNxpk6w+DlzrvPxKTYvmwbICRZS1zHs+AKei8eu2FrZNByBxkB8UMvTxDIJZYoon8TZJMOTjxMtDrEMeqziNvBamm1U6xXL06tVB39AT1XLtv1R0N3drTS9IB5WWzXcqkq1VLW9xblWtVLFJU8NS2+fHqEGzYw1nw73Hr90/rNHe5d3Lz5//gtfNnUPS42f5zqVzt7gwle+uPnMo5ntX/j6b4ejCwRkr7z6kXDz8ZrSzAcxA0GFYhhwJ1gJBZtuIESIKNo2OXjyJaCqV7/2G+UiG3f3Xnnmzzv9S0WEvdf39jdRgKIDxR9Vjo42y0RBGREChpn/0OXitzFN/APZlvXgD5QISLpgDIhzgZaffUB+wv83dRW+B4pxCihx86O8oDgkKCXZV/w/A0swfSjJxHZyB8BlymBNrIbtGbam41rapnlzD/EKbFHxCHBxQYLQRLozSSKskGEakzCaBAmhFkbbQvIcKxwPTx5bmm8tuCWnVm/YlqXneRhPgiCchJMoJIszLdJpnBg1K9cePlN58MTc1z77YVeP+jsXXO9gZ3OjXKnrem64Ck7MyVPzUa0dKv39669uHn7kW3/x2PPfPDq8cqVUKr70yM+H46c0NjA2uLAM1ZkG8eGrl8PgENMUFtN223zspT/96If/9d7W49eee+Qbn/nFV5/5o5e//l89Wzz6W9Zv3X7xOTU4vP7yV6498wVk8M/+y68S4aC10GaJzCwKRMyypKgwXOwHZjARv5JwnFmNAQYK1hAPCB3L9eJisx5oO9mVIgESwPF6JhiaStSJQWFMmCWCA+SV2IKP6SJr2ciy4sa80Zo3m61qvV1NMjz9ioaLZqNRVNuxbc8k5shdsWf1uouD55h52bVMXfEcmXpdI+iySqWKXtg6rq0/5e1jNiurxYsVCRd4ZQ+HZUqoVa2yj40PfeTjb3/3m9fW5msLzmSrk/Wqx07f8YkP/dP3/J1/kY616eBoY/uFk4tLS+WzTz/38qd+ofdrv/O/G6bqev290XkniL7255ff8RPnyNMRD6ETBuH2C5//jcZZqzOM3/v+f//kx37j7jt/cOr39+2lRz79C3GeVb3q9vZVK41jvfu1j/3nt/7I37v81Fe7nW/tX//65d2zFS9/4cnP3HrHW1PNRSiD4LBUryoxxl67/thfNm67p1xpYbGZdFwP8TpYqpsWFUMjsDrLkpqmNc2AzIAUcPMkHLgZv0jkhamWjCNhY8KKaphP1QbBaM5Xa831yXCM045jML9UQT7Xlte5eDDsD0ajcRjUq5UMo5Hny023vbpSWJVqOyaownK4XoOYQIvGEhoqdq4kAgbksWkbYcRWHJbLFdl+Oqo9LHBbM1MvjOHUwUsyrrz8O/7gI9GkU+6u7+3u1yvdK8/+TtVStp//tby8crQ1ml93t5/bzk7c/cu/+It/9Js/n2nXHHNcmsy99zt/8zNf+fTpO53BpScW7/rOCRm7KLjx5U8Yi3q8oc9Vzu4cTb7w9f8RHW6trzyY2L1muYpUD/0N1XR0rdLbvdQtxl/+0188vHr+zMkHVKVuDcyL115ZVz688dQf3fHWv48E7V17SZ3qdlw6/oH339j7xKXBX9z/xp+vlWrj0dErzzw+v3bvsePrU4nAQacsbAUuKp7Z6Oio3G5NpoRaLqYddY/8sgoGSpWwjH2E6cZzE1glch1FCYOD3Wlnp4N2S6ZTy3OydC8KQs8rBcEYQx+HIRtia3MTnUZkoSeNzUai5KboSd9feMNtZjHm+mAQTI7pZhxqPCqKRsMJdpDoJY1tP5sCoQrckJi4mER5U7II5nSMQOD8vfDCK027OeweHBwe+X5wsrnAFrnxwjMvf/WjTrzV23t+ZXXhxPGTFzYvJi0ctGocGrvXNlePPdzbfXn78pOHWxuea/h+1PTKb/3BH03CsaLueOYrl574+aZRqzSX5o613bQapqNSo1xeKlVd69HP/n5n45l63nnpyS+W5+uj7l7FrAxHO+3FRS0z3/zXfnjk7+7feKVc9YaDaxvXHr9w8eP+sIdH9cW/+I9Gybpw/SWrrLI5CXAStBG2hxECT4lzpSXT0LScNNP3d4/EFLAvADHQa4U6ONyV6BoHDHc8YQtZ2OiQ35oGnAm6Qr4lFRODqEyDiEVMSbWLRgReSFkyI8xiMEZPB5nEP7eqOLCewxNsy0CoxVuY4t7rSjptLrVtzwXNIPQiukrxIaYRsMk08nXDKpcXCMTGSWR4ln1saU1VO+CMtx5barru/vb1XpEeW1tO9q6df/Wp02unimzkWJVu73q8/8TR/pFb9kzTbS0o8+2a5t31wOvekyRa/9KHn/3Kn9/y3h/uXHwqW71bNdennYv+eLNaU25c/cKpYw8MtqvhYT/GZXWjx5/6N16zrAba+qn7/EmvMPPhZFDS9CQp9XePvM+7N/o36l4UD7LV4w+devCNL7/w+Wycx9bkzlvfxT5+7tGvXnj0c8v1Y3c/9G1oVQkJci3SAhtw0Gharrl74cny0vpTX/qT9//YT2YBmx5MqzC0bP+VZ0rz78XO27odTA62NjdOnTwpoVs4DHMvDHHBzBgRVjXPJTLIUS8sHVY0iH0QF/LvZmE1K7ZgZyrGoShZxIIEZTZBgm4aVceKi3ivNzC0aR4nw/4EV6Lilo78IdsRT4lMhcUmiXHKuplZqukolI39UZjs7LzcHRzu7eymitOq1na2rz757DfRWiXF2tnqbB91gjSJ9ker9aV3v+dHStY8ezPqKk713Ojw4uPf+I8f+tV3Xn/x8908eOorv3WU+hP/wo1LH+x1nvZarXinVMlOXrv26t7k1UnUBTZvlVdUtVsy0wjHYHgwOuqHk6GtlNSBl4zTg41relY/u3zr/uHR7o1XX37pK5ee/YyTj/rhBd0adLa+2Ll8eKqxcNftDx/uHvrpVdnCaIks6exv/M5v/NzewZ4Sdz/x3/+5YQe9ixc6G5eBnJJJkE3GndHFob87TSbj0aQoJt/8y9+56/XHrzz9RyZaQjH8ZGLYxFKJZZi4LVMSZERxQP4IdZ7gYGOHEHPLBkMVcMO1DdvWmNUiFmQkifF7laDfY9vEwYRNg7rHq6qVXZy6qlvCnJhsI1AGJSVSk6AyTUIwqpVqyz+MyovrQWwtnDhllkqjrn9usaa5c9c2tpaX18bh0frJ20BcR9N0M25/8nf/XW8ne9f3PFhqKo898Zsoleu7qVvxwvF+vVzp9vuLrebgMKqXW4WbWIXetXxVy6ZxSrgHnhXm6cH2JctbnE4rljWuVJrgCiAgw8Meg19oLCytLWxsfrYTjAjCFo/PGwo+h3PhwvPH1m6ZTkKncqj3X9l8+ZELl16qtmsf+lc/dzFc/o//5pdeuPDKWx98+Ge/8eVRp/td3/3m/f2tlz/5a93J9d/+9Z/9kX/9Kx/65V8wncXvfOc7D688mr/3R199pXf/UuX6c5/56lx+/alnJkUMG8LVyajk0ZRpgfmQOw5hS+4Hk5nbmttkZHhPZGaa1MvrjmNFownKMA4T0PecD6GtsrjsVSaEawqYW6gbdhyEvUF/vj2XpSFOQpyEWTbVFTtLk0qpERg2gJQW5PFEASoNW5V6GkQN1spuWrYzHU8XF4jiIsD3DKxpEh5tXF1cNNdWb9NLyvW9XV43Tadm2XNt8h/qNDWPupMoiDy3imc8LQiG00kc+qNoMgzbjXrZw03DCqZu2cnxQeCCuXaQdlQTE4UHUZSchpGpZVt3qrbpmCRb+4PgqNM/2DsyotLutV2foHFs/4//+itXNq+5RJy5dXT9+RMts6lF//af/szOi1+tesb+xguf/dPfitT043/29cO9vd0b1/a/+ex45+jUyUq5tB/2dra/8c34xjOPfvSnnVLxzS99cnDY13G5XCtJAoIHj/wizr/YRggQoHcScbuuE4QRtiGOE/5NWiJD5wpobFiOJRG+pniYQYGF2RluvV4FWOJCUOtWsynIE3E4pkpVPa+Cd1apVPLpxMRuKbbRXKnnXqxrzouvvvC6ux9QrETPS2/+wf9r75tfn8TBUe/o6s6gfqJFaFqdW3/+K482Ti884N6llzUQ5nK5LthJrjZKoIHGfLPe6eY7W9uLjVaQptEowpMpVSu66QSptr+7065X2gvNzc7BKAwK3ADXdD3HD4EilFLT0BzzcBjkEybCX1qZ9wfDWql5sN1vNMn5HJ24d2XSGwwm2lu+/81/+N8+Sxh60B04dftX/8FPeY3l13376j//+R9iMwFS3dgMSm4tJikP9JxP/+Tf/nO3Yj3+Zx9JLtW6neCLf/mz7ZX2MmFKnDfKWI2cCBU/yq44o8FIphB8kgASlDhLPQ/ninxIgf7GdyIHg1dDnCY+fSYoMgnEQqlj8wXcxMFN/fG46PWO4jDwSk6Kr4yJwv3NUvQbZiIYB07ZQ/VaPETzcMwMZdIxA7/wWu2GdrTjryyQwYk+/Ms/PXdmpbO73Wwv3H3X3f3tl3avP/vd73tfcdRvH7+9v/3M5tZLpqXudw8btdpcez4Iw1rNy4t4btm2IGXgpMUpWaxas/HShRvlkt4slGPHFzq7HYIb09ba5YWt7esrpYU4zXFPR+OgZLujQWe+0ToaxhW9lIynNc/tDPrAvxOlVzhm1ivlfcVTrC996TMlCzeGpFhiKsUf/dZH/uUv/tNb8sUrkVmyvWAUYcNwVZq1ZqIUAXs3zaMh8a09zsdpKWlUKm093Xh1u76gD/xrUb/tmquq6iINlVKdWAlJhZuQRGhq3Xac3tE+gCK6GrQRcEd8qaKolmqKl6KsGvV2uVweDwdg0GgtoBKB7ROFVAtqF+sB3AVWXi+VUD4shOYQSGte1cvisaFG07Skjbcmdu7sbd4Yh10l7+L5bVy64DZK169tHR6R+ll4+eUnllfPLqzc/sLTT04mVz//2B9qc0ePX7iRREAmGKdSrzcol5xplMZBQF4nT8xnLr3Mcg8nwbgXHl9ZWFtaeOHiC0E3qhjV0CdTpli5fsctt2DghoPeTncXQAlDV1LLve7E1exqtTQtooPDcbXamEzCfAyMVOn3elZD30s6Ck9S8l53bNr4HuaTT/32t7/nxBe/8eGaET949tgc8EsYOK47GvX73U5MfKQrJXS8kVnTgeclZtm+dmNrQsCkMLolt9IQEILMvutMp6FD8pAxhHB8JpKT8X2vgivcr3l117FbC4tuuWSj+lNwhRjvcjzsRXFiuSWi7jAGMPZIvskvr6zrFr4vpoFVFB80w0Wbir+WF6NhP4xwg02Jim2vFiVWxbUfeNs9wbg/7I7AXY9Gh6Rw5hYXiRsQz+3t666eb1x+tdBbq1rJStXTp04BKRJQZYlf8WwF/BmmRskbBWPdI4esj4MQJDbIwnq1GoZ+szlf8mplqEy61Wq0PQtkUFtbWnKtCrgi277keF6N+2hHI/8QyzUczrUXhqMBmAJxqxpDSouW1uvETkEnK1Vs0lpEw5ZT0kwbgLdUrzPU83s7RONMGcneFLzTkvxllKXdgd/rB1vXk2RsjPbG/m4/SNJbW3OmYk/xXiS7XxC11qpVQeGE6mNapYrBMBxrEoSVei1KA7zV3ngoOIcAOQD7Go4RQDRfoI7AKEBMDBi9eaHbdoSOxeHhGlWPxgEplDggU8baTglXHZsdopYNJR1cNXLHnoSBpSWvPP1qY36h3Fy2a9mit0IgDb4Z7nROnFi9en3vysHkvrd+lzvfmOxNr264TukI+OrkLeudYVJx6nE47vvBoN8/trRMquO+Wx7e299dX16d5pPLGxdWlubmakuKl/cOfLdm1svVzWvXq2kV8BqYZmV+hY+XyuWjw0G5aZZRIPjCWTnXE13R8QfevH7PUdIBefG27TfMn3n9PORMVFzW748yNekHI6e1YCmlTn/RIhQwWmBFahAMxxOnVLLKjZ2DoxGKvozH7gWTxJrm7cXjpVr7iZcOyWWXKs0RUP98czwIkbzxZDI3t9hsrxxsHUXxUZLEtVKDRBCKh2DXBc1NkjLLo5rswjjO6tAegOc0UFGWXEtCWBgEcUR/RGk4HPi1AEVZwkDxcfMMI5yNhhbuqGZ/80M/U7ixkY8Pm+BKCrfWwS3i8CDXS0Ye1+eXmqvW5ZeuHRyED7zxLXffvfT8Uxtf+Phv/9AH/v6VG7ubm5dY6rmSoIbTeEKaY67VhBVz0J2UPMsfXLPs4rC3cWx17vjKccJL3bXjnGxuXC/06XA0N9fo90bVGoFLaXdvx7WcRHL4WDEAT9V29SzScEzbtx2PNrq24p8tN3EAkbUSNCjbG/l9w3XWXCdDTNRF3JNyyTWW2uN0modET0YcTysecL169y2nTi03p5Mj3XRNqzFJB9mYB2hRHAOnsolDMIMxvmUxAc/D/fBOB2i9bDhdIO6e6w1kmymeHgRJm4hX1YIiXF2ojgejklEC/0OAdgYjwJA8LkZB5meNTjrwBXESZDgh0W7aCfinqhP6TUG3J77lVsJoxM2Gwx1UtDGF+gCDY07L+9NskvujTBmnABLdyTPXO2lZO16uO889+bWVY28cb+/91u999BN/8qHd7lOpWoEz0D08yIra2pmFi89fJiVXr8jO2trYW2q10BpO2d7ZO2Rna+oU5kDvxhFmc6BZ9TrhZWq5zigdTg6VWotlNDpd34DqPZw267UEbamptUpltHnoqJVqrR0FsaE7YDX5VBlnYxwJ27aSybRm1EG+AK2jeJhqFqJpEuKm42E0bdcbqF0/Gcd5M7MbMW4yaYckN8iJa2D+ejzle9NKuVayyZEpo2hAxFt25wfDw1J1Xs+16zvb5jQK45EZWyfrznJND3zSKUTCtcTAn+nrNQs7jSdjOl4UhvMNPBASlfXGKaNiE9VDmqslQQCClObAgxEoaQJ10ZiimhSl5I96jVZdq1TdOA4ck8A/n/hAanmrWS2Dwo4aRa+qxlbc7x8edQCB1dL0s5/+8IlmcedcAwoqAABpSvT30X4H/Y0jxCMrlapt634UgPFHoRaMgAA0ssSGmQfBCPITDBxQSUu1Ujaqj7SCmqRl1Sjrmp0AmkiQiQdVrVqCHE9TeDWwX2VeTb1saDUPDe2Q9CB4lWyNjqEhTwUqagqCQwIOpIdJgmiOYgYK9oM8GJtpwtjgDZJYBfZh+QldCXGB3EEoJY4tQNVGuP++3yWRJLQvy4Soi8LHKcSw2eUK0AO2HeQHJS6qX7PCQZgEqM9ocNgZHHSHB53QP1SSgYdrORpyRZGGAlJbZhkLR+Bi2kLygYjBq0r0jRDkRnme4G14cNRPQ1h9zGp0FPeHkyPNrFYJXuuxvxe84b6HCLjn5u5Yn1/8xrMX0njtx//unSRdz5w8OZhClZkcDq5jRQkbAS8rbgVYdqU13/Wjfjy0E2BFZ9CdNhdWpkq2P/bjYQaqBUR81IvxGhac+tYoHE+SultZrK2QkkTVbFw7ZP7n26tcSTob1oRbkFlVR0VUJ6fFBlFIjyJ76CXYY3o5d8DCmEoAg3ESAzcMI2UKBgRKERxNrSqSChYK6xCXnPQIyB0qGuxaFZYT828vtpfQRAbBKlgmQkFo60/R9aRlGnWmtGClbA+Vjxth4P9BzFqoS3hEkkcyqk3JewpcPU1smxygS0xNgiJVI9t2QG5Qw3ESC3WB2QeONaCmqbIAu9eP4kirV5uKNlhbOwkpC092/djZ/d0emHkR5qzb4nzj3gcf3tz60//+e5+fb6y/8Z57n3z+ynd9v35le8R9TQ1ktTJJ4+3RHiJSKnlj1Ft/YhueV680FuZICG1yN2Q7UW5fXt0e9ACqkC+86Xga9geTWs0BdU6MsBdNGSrAZskFL9TCpBNO9Hxe6D9HYaDXdC1uJULLQ3yzS7tbb7zzLuJskt4UWMFYJEeLlLe9WnOpFVoBibk4Q1fPp4YDQ4TUiTm1E4gEqGcirRjvU1I0dnVdJgTvRVEcEOOQ4pdQi/tGL+wf9BItA3GzlGj13DFJd0NKiBL8vGqtLrkHYSyANJvBBKA/h8DILkmF26M4LqkxcDpyBFm1XB0OR2R0JP8DFktOQzcqnrt+fAlaQ25WoFcC0qSdg6PV9bJjap2j/bly9cbe9skzD7x6vvfFzz/RbH7tUx/91vLxOT/uv7BxZdLrQJnRtVEQ5rXVU5Viw8ncbvfQreK2hmkA20n5W3feEm4l8XCCuN5Wab+4tZWXStrUXK+s74z2yW6XmssH3S1mlV0djXIzNusra2rYg7fT7RzVtBqbtuq4JxbacEhG5VqRTFxzpKeGaVcDQ+8fBh5uNY4hjCdd64370ArJWKHbDw6Oyg0uzMi4w2ssLc0xd6nVVqKJpTULjX3ThfIQ9fadcnXqNhyzwT5Q8ym22kBVDrpFmvT8CUiVj4kpitrcMr4ZoUAcToe+X9WNJI1w92c+NDo20+GQ2hXKN8hNguHh2lpOxbCAqU2gfx6FgdLYyGQuUJ2QnU2LwKlzdIgXFLMdDA/VBLMCSheJpTRP9FCB8u71/f7exo1b1x+KtcrymVVTFFjW7+788Pe8C0Jmubzq1LVp0dMzN/SHK0urwOeFViUHfnezeub5jx6Zr2+bAUavmyT3VpbG7UU4UfWpMWgvvlQvX23OmbH2PUu1ftDN5r1Gbu9HSqtUHaBN6ssLquVBoKstF5HT0rOWCyql52Oz5NipzVTpF6ZKd+JTHNeAn5MUA1BKzyYOJDOyurSQqCNomWkIrJk+9hefPxqk9vHbzy7k4xH0iNDMJ7fMLaTTCSSJx57fWjx9hzmF85N0x9mpitMkUM3SeqsN2wpXvORUMNxAP2Q/dVPxymWAQuy9wKVS5yVkDIICoq7Qn4ixIksnRRwh1D0y0NyWHWzZJSwPPAXJWucB/ts0mg4KIFi4nJq6t3/ttjtf19/vZcUwN2pmJSCG9KrGwdH+mx98OI+dcyeXn2qt9Pp7RCko8N/76Jfvf8//PS2cuBcMg67mlij3Y3Unhxk79GDSP1O5ezC5Wyk3MqMd5qYyHALZQ/6Oeto4jmyzOHzucPKO6vdPveorVz3FnOa9Rrm27Nb0CR6iYYmRbFeLqKvu9+fHG5q+PMj2JmHbTIYnSoAcxUhvEo6+EG0qJcfV1hZLH33uBasWfuC+s0Vs7wQ36s3GYXCwZs/Zdr49Vnd4j/GwVbMvH/QhHdUV9VQ1NGE3xNanL+8/rFWUaAicc6MXOOvzddKhaUSoOAoGfhzBbzBXltruXEQNBVNoO6Cf1JZiJ/gnthB6KAsUjiY43GSEQIg0eHP4JLhgQiZMTAv8p6vDZQ8Sgwx6qg4Gfr1S0W3ViLlRnjabSwcHgzwpRgM8kag36HpWo+LWhqHvh+PFhcZOb7ff79Qr5Z2jHRZs/9Ubup0/8djzUWYvrZ076ZxZPGN1D/dTj5UNrd3+RaXykaLn+jBr7M39/l2rJ55++fnlcTTq9IyKdXF3uLyw7F278bhbujp/33J/cPnK+bNnzpxeXtm+cX1xeW3rxvlyNausniaKfeqPP+itL2Zz9v3veuPP/Kun33GpdajpzZMn6ufOhjdebBuVqTW3P29+oVu6X21gZpjxg8xbqC3ddeK26OBKXoTlqlMcRlUkzS/GhdEqleLByIEFFERKWjLsShT08EiqraaekYtKLPK6BhlzImhwYnj5ZZQPyEQCxivRX06OF5AYvjVCV6rUAa4BelnXBAqflyip98g3zlcWG57ugqDMryzC1SWyUbJh2W4VaeyHkHrVs81TUZQYrbk6RJru1i7aZXmpvbBY2/LdcJLBwiK11LBL7K+d6y/deUdgmcaLrzxTqc7f2NoHxUcUXnrqQC+5rzy3+df/6/tvu/2O3d3Do4POxsbe3sbjw/50fC1U55Ph3uCZC8/fc/akmoaqU97qdd507u5JHmLZyBicrGXzLVWvnoiySS1Pvvd9H/jQ7/7GUqv8yrOTs7cez/vXtFHYGWZryrG5fu2h4O7Ff2Ck3ejqOLnj5Ble0rz9bU6pirO+cNppNpW+MdkcxxWgg7k3nb/0wWbNbVpzmVrycuO2cmlJmQKWtgu1lhJCJEMmK68WqXFcnS7rVkhVQTY9WYUSnvXjLAq4hFDHLtesKaiXVyVTUraNSoskJwCpMPpIwni1EnUykFuQd/ZBkfpG3gRFUhpz9uKiv7FhNayN/iZVBmWvmqSl652jwob4lMchCHTasKfGZNRPVWDhMjHENIQqj4/GTGmN5SruHI+Z+MnRELtdGuwPl1ZW9/b6C+3W7sYOvnezYU+mSqnV+OIXv/qVrzzmj0OSomOQrHh4rDV/aX7xxNrcpctXbjt7mrpBMlMkv3Z2D+FoJv1pYw1SXtRTNacluibudsylk5/5xEcmYALh8My52223Sjag7jaW6vVTxxe2vvniixfdVA8X3Zo7UVbLcxsx9j6qVJOG7ly9/krbMpM4wKgYlaTXfYoMqzpIyusYxPj+uxZQ1B6xUJYttRbRNn4Z10lo32QrHjpzvAZFoWY6JWdiVhwLX9a0PdAhE6SzNxqRpcB9B0UDRwNyIJjIioi4hQwZuDR4BvUTUDEm4wkhlqrHFAQUQdC5sauMh3GPnHO2trrQKry9fjfvD1rLy+MkLJmu01QDH7gqs7EllTrBWVzWdNPKTp64Zf2BM8lghz2ztLxw6alL3/ttr9s9uO5H2S5w18AfDxW9rDhG1bbKcZ50DvqeSd0BQBU8MwPNaA6C9tbGqSDc/OaV7tiaq9pf/9PH5k7Vbmxv33PnHReuxXPG6o1Bdlfbabe17Wvja2x7s5361jOXX+p1RuNB0dkbLm4uBr203Bi95TvufWJjT1ld/Pu//8iPvedN3etbtYXKG0dFN/S9Wu3awZEzfywfr3va5bEzXzRso5ScbBndLjCSps6tjbQ28ZlRsg/9xC1rgR+57Tpag3cdHuxXWu0KeLG91O+PAXWgepskZ0oQWhS7ktp2sthqoNyhNKC7dQOvFmo7tXiYU+I9SImUboOIpH5Sarzn77EWGqXvaf6d7yRhAdUVKBGQaDoZ9KLAr40jv9ONirRKxNsZF/F4mA3B7yCWFuN+x/WMZvuU6q11dl88unTtS1+/uLBy7OSJoR/Ez24d3P/mN8FfmpufP3Pm1Pzy4jfI5MVUlUU9qJOa0mjPHfqTZqPB9+CN3dkq/nqx8f26Pzq5UJoAduQHEMWm7rCpPjcuPTe3/OWNSZoN+9sHnzuI9rVowVjEQP+/vu/txnYzOWlEUa84HJWb5f2eWVA//YkPfd9db8z7m7/0kyeq97xBaawj5+FEvb16OnezJwcTVS3rQ+dg/LTm2QkBRUNdPvG2tWqxu7f3zu/6wVE3BpbMpqmHpsDZR+w10ockCkbV9Xv59whFTDjTijpRaC1mg7Ag0oDJm7UXCyUA1nfmlGtBfvkQpSNpMvhqYNawlQrqAMgrTSB2oq6tt+IaJCgWwmRoKqQqwQImhLwkCsrtpYpxTEI+MGzJMhfS14AcV71htBfKBRS8wBkNw+7BtdcV3Wd966BjP/CWd0IwsSCDFaVoPLr93Inf7Y4sCAVBio4RFqrjtZrrbhnGJFoQsgNONvmAtLffq951qpu7EA3VwYYHLXJxIR0fTm39wJn70o71WNhPKRoZ++XmsbVj9Xceb//JI4MfWVzSHntiPGm6z++Yo34x1rK3vaXdiWJJRUKdHpfLa9b5x7ee23p2a+/937k+zpx/dCM8c+7sjy5UhtdHv+9f8SdZZVQdzBtl0988eX3rmcMV3fjSJz5ZFCtWntRr1fYSkB9dMQwB6HUtwYsHdLDBZtJWpTKemOvu0ijzzTLVTnoUjKB4gi8TPeMqgZDAc/QMDxhaalFhdOYRhOIgRatJtMWEfv5TH4lTuIbQipMsHsx7tT/6048QH9qatr3vWyVnrlX3CbcSWIpRc6G9trhgVuYNsr44tZNhRFbaWqpqXv3bvu1960tn3Uo9HHfxA7d7PROKozd31Dl84PV39Tp+f0hxWmJRCRUnrO5Rd4+nEOcSa5BpkEj++qvtN56JKsebjduswRgU3cJ0dkf58Tstv3v05LdOnb5jUkyvc5+eNa0lp+44XQkS/bnncccmoQ9fR6vW7C9+atKYH8fGl59/4vubsVZeCqque+xBq3G9/9zudHntB8/c+5+++sdaq3ho/riy6xx2L6v1OTKBG5iRZ563nFWi293O1sQfgEEElxE74DY4CjqRWn2uHsdFvS4utafmjUar2989sXBLzw/XT6yMQvRTRsqmpFLqBQAn6V8gCMk7UiQByVeyYQlQEt/kZxol3uF452D4+je+tdPtElaW5htRL8AJnUQp+fAphTbQLGW1yWtq/jAkprlyddOp9Y363CIk73arTCKi342OxsPdb77wYv6X8ZHz/Plnb3/TWy/1+j/6rtctNJubWwdUlE2Dgin1yu6w0/vaX34+AsJWjSDC0gBckCCbEMdTJ/XMKHSL6URX43I0Xok3Lm5NyvVRP7vnjvWFlYXMsA5lSuvqYdw98sPw4qOpEsXlh9aqbat+lFKeYkS5c+VoFHLN2+5/ZKgslzWfdOerT03L0YcW7BePnv7+u7aTWvClq50Xw7BpLBWZ62fBc5sx9aYLbr56/zkg4Ghj6+Urr5x4/b2PXrq8s7V/cn0dv/zVS9dX11vXz19/25vurdfcbr8H2gRzttS6tNI+9tj5Z9aXl27cuIoG7/YHXtOmnmnUmbz+4Qc2rlxPx5PlpYUvPftkjUSz58IrveXYwvMvXfpr3/OB4Sj584998vTpk9cuXzlx5myj5OERt2teTStdrsRN1hQapB4YmlWqlarl5tgvwkzIXCS7srmVKtazpLi1Umnh7T8w7u48cPtbc2/8l1/+urF5GZxupVq59vXnquuNaeIqStIj6dys4RoZblyyYbM2hYMJ5QVdC8oIoVswcTQrLGyBLR96Z991mxO8X10lp0Ghi9QECiea0ldwcuBNoTWRrKT0qk7xE0GLaa6yDob6XoVyD3wNUCIQexjnsEiEi0Xx87v/8XgKqymaaG7xyxUzDGB8UHg2gTiWWY2w1228XvmB91UCU/u2B/o7G5dhzANtXjy+AER5tuE8+JaHbz13ipAv8JOLL56/9sqVa/1Ljlut3HrHeHyx7Bprp05uXt0dDCf+EMgx6R107n3gfoADdRjOLaxFhXX9/At2Hl/Z3XCrnjkqAdweHna6+/tvf98HGlCqzVIaKSN7ejLrkjvW3GZMwMB4sUVWaZrsOrZrfPcP/uywOy4Z4HH61uZuue55dnv+/rvNEpW43k/83R8LyefkVN5o5055UA0EqkDjRTPGH2heboHfAUgJdRl3DdQRJwzGujABpuE0hMlHmB5Fpjkh5QT0RCiuk6uGDgVJWWp2oTJQ+MniwdemCKUg0QstV0gi8CCDSTEebFSqED3cKCC4hHWjqBUT1bt5ZcuMQpJDwIcwNXuFV2lUB92d5LDfahq7Qzfzw61Ll+2K+m3f9h3f8b43h+dWwwDITL33nlvLFc+0pCLJ379eK+vTunnP6bc9+9lq6Y6mbpXbjbmKqV156bm2XemEw6W15ivR4NrLL184/9LFjd33vfd9y2trhlluuLUdt3bslnu6ZGY09Wjnqm5Vp2rYmmttPPfNYats2UpCOYdXzxonIqECN3NzRHWf7ZUJV22yGl7ZWGi3q+W6f9Qt1xfP1o9fu/As0vvH33gy7fvveffDC5TkWzYOMDwZPgMICxolhUcsA0xri7Qlsg68CCpF2QlzA11B+DF8SWSHogQMxMMlaw2wzOyzUCwWiS9J3wuuDMtPirmouzBA/cVpQIpJrriTeFpyZpluoxwEyu7OPt/fu3bk1gp/lBauunnQGW4Ey6tepVnd3AqX11fVUb+JDBxrQkA/uXx8sN1bX6xRnQDHh41v2FnNceMwWl9ZI8jw4+TyNx8Pbtw4PWceZR23hEvQNEoVyy13D/ZPL9fuWHhbe671ge94CyYY9Ky723vxdQ9c7/WvP3ceSsrarbfBH2jWK7isLz75dOMnfgw6Yjj2Iao7jkEdvT5UEowcWeXBqEJNKDyXUdDbuQ4Jtb6wahPIqmo06Ku9YR/6feewB430ypXn1ufK//6/vty6sxpvX+1fH/2bX/vnDZigIObgf3Dr6BpluDAYmD9WAh4KFpeZhbeK5WQemVOmXdQPCWvLjqRCZTIO+zZwoRSQwOzzWJmj/f50GlAd45VJ21KeXyQYdEArBUeaNUE5kQ83qwDxLmkY4HaqVyT7jRqSAsmUxg0Egn6l1AQTJvs381NIC8IBJd1FpQLFoxI3kSkneW/RxUQoITi4iTRmAEEDtIRUQHomBMnUO8GA6lWJRqyiE3QdPJ9uXGavUQGrpsMQikbXydPP/e6Hnr/8wk/9+N8/e2Jx53DHK9eNWra7NfniN17+h//sp04/9AZsoBR/81SSQ1HqulDVKccYfehXf/NvvPnez/35nz70d7/bmjtVUSrXr1378Dee2Hx2W52EffKQiV5cDCrPf/KDD77+9V96Krh46YtAtRXLOfmGt+w9/7ETKwtNf39uNDjx4EOTKtPQtDLLmVteu+s70fxIM6Itk45mFiKAUVA30h288sePfut3f/cnn/y9SUrRepkQ8lsvfPMf/9S//p7ved/P/pMfj0Yh9kGwWTBGEsEzop3p8MaQkAEfSSdN9cyXOk6LZCTWQi7lAQkqHw8mTcdjaur6Eq2z3dhFTLh80CQHTiWEjkJkp7ItVUmBsa01tCf+u3wLFFtHh8aEW5JAI6yYldglFMyyB1UKZviU0KZh6o4FuUwzS/JmRQ5JuV2195OJDfI8nWpxTAXMYDzo9mJrqWTU3ePHb6cwRocur2YldoP4SdGLj2/OqX7DM7/1hS+4t5zOK03Vqala+eXHrqnD6cRSkr2D+PzW+B1vWH/l0a99/PNff+Wg3wtDcsnqZPi93/GB9eHQeebFX3rxG//lZ36iMfzTqpZN3NPuyv3zb/4JghsSjrPMHeA4ul2LlPFv/fV/2O/GZ0rNSX/6t7/0a4f9IwLmZnvZn/Rfubi7CCV6vQ5zAG0BqRWXjvib3cMkwmxUbWX72t7xkytwLF5++qlb77un08OZcg4PupB+HUeNfcmny8jI8FGFx6xQn0p2t0biN6mW3XEYR4QJECAhgcDGlrYUMNqYaDY9Zawgw6bnVdmMUnpTFBSG+mMug9cOt1yfAutg4VLhOElBAB+jPhTKjFmF06tBH0KpWvBtTdJpVCRTvaP5psoD22VYFAOc9iZkGThjdqyM1SyBK7a2VnNBGkx9WtJu0aPd8eRomnc7hXLJN65duzYJ/C8+8vJzz57v3fhua9r5zLcuWLDLgDXUogKVw79Q8dpBy1bm3GQ8PtxN9ktaPPLPnK5iZjUYNI4x6seDcBDFwcgfX9/pn/7J73nl8mHvsy+ZU2Nqpf/sn/3SwXC77daqdUoeYq+1rMelu+49bZv56x+4d2VlFfa8VFjnehaP/vb3/1D/IHr06Uf+4tOPvv0731yrV7/wtaepY79y8WqUxc2VBcIoIyP7oaPrQI1tqwQU7IcjyqrmavN+b1xfWmwfr6FkgAQggJOVLZfhcLEHDMx4jGswifojyBHMH3ERWwtsB8OPAwHnPGdljcLTZ01BCGptl7wZS1hQk6PZRLEsKGtihxAhwoRmEfDf0oSOfbT2IFeSVtCS5hhvH8sY0UXEMRdA/OJJUXXhsAy60Zad1t0SpC+7YVXvJUC2y3/2ia999SuPHimDJz6bvfXNt7/uTBoYJS1rUXtaWgqVfDxQX1i6M/zb63ce6SP39EN+Gp5bWio8jwpFmhWA41fRhSm1JeR/7L5PuBngqv6PN/8w1WhanFXo8LLQ6B8cNo7Z+1de2H3saTDep58mD2X9/gftD/7BBz/6sY9fu3RV8ZavXXzs8tWehQDGUaU935qbI8f+E3/zB1pui25ub3/rgz/9T36alCwbBUpmFCY4MywHLjyUusXVxmgwSKdFe7FOQEIuhdo/KjaRdIssCIpKCs2ZO3Fn+R9xTzBg4oSh7ohCpJZDetLMMpYsKvkX0Xq8AdoN0oqUnIn2wv/AAbEoxPDYDXSsETAayi0F2XHmNOtS4EH6LALDgOKuFHD7IFx3D4h4htKPADovniga0SXRZxnb1MA4E91ziddrjVNe/dSPf99Pzi8e8x0P79eBerK9/fRnn7zirY2dYbDXMhJyFJNoL77NqNRPTe2yddvinbQyut67uLq8TmeHejM/7O+MB1LB7JJSceNzd5+Bfa0eP3bi5Op9Z+/6N7/+of3O/m0L57C1/niys7/78b/4pD8OUEYMuO/H1dhINfNn/p9//pePvfOe++5Ya9qnbj/3vu96//GFtf/yn39jvj3/fT/01yAC1SGepMXHPvQnf/oXH3nTGx9+9fyrv/vh/yEkCWk7hQERRp34L/AQMCxSoUfpChVN2GCZWKZGruMtIfZjOFlYUrU4FIJ74kDnnRH9UeByTBKq3zHfuMDQqKivxAmg94MBCoffJm4138Ltxj3AwKBX2QhGDl5P1IKXzQ9l5VmqaoPiNTKcmYkrAq/GLIFlGe22b6nDjI5p2bTeGFXyoz/+s491Mwqs2reeuZv6XX/rm05S73d2yu5tvnpQO5FevPyJN932XVr/AnW0xNamMcihfQ21w16Hh/Gk0YQWFwrJcn2oDXujpx5/uZN0437QbC/B5zh39u619RMYx3BCCkmjxtOwvEnQ0SByaDjnMGNJz1rEXl/9y89+4eMf8cgGq/pffO7zcP3CIPhr7/s+Nv9UTXdu9P3B5HX33nH3fXfMr53EIRwOw5FohMihBsg1IVXbtTJAMRYGMSbhi2WFQ4gsM23sohFcFUCVrNi/0Q+iYNj3fT/rj0gDSyLTog9UCnWTmmYWS/gWdPpgFwi1RephpmGQec1FYBgWEHqEDkAMX11AU4qM2TYaS4sxl22HdlMoyhQODrQBuh8hFjm1+5AQ9Gi42HJA52iyNAwOtjvq8aXW3QvH02Rtf3yIN2CbtUrtMCt1DfXGkdoaBjVbvW17O1572wOFTXY00ojZcg1iZb1eCydTP4wJxaT3De0dY4WmFhhJoPPdg60bh9QLtucXFuKImuc+2x2qHk4jHpAIJX6skbm4Rga1Bdmw16nO100q+lhkirPSDMaO45U297uXr177/d/9PYI2CLh0TJ1fXrvzjQ+vzq+sH1sGI1RJZ1QMP0zGo/HmlQ28YjJVLAfIPWA5OCfKnlWn9IJAm1Iwy1ap8rYr6HpLL6lL7RWANxxhfzC26U9zMGZOyzXy/3oZnjeBCvEVrCPW0pbKQPLrMCfwwOByYVdyUl8E/4CpaUL2ls4AaC+CIdnds1HyEdACOALiPRKdDHrxq5shjnjX94d53htNdrrmvt/rDF44OuqSBbt9zrzar7XMhztmc/4W09j9gjG/HETtAJ+NN02hPeFw6YcbZJSPaHnTgodbrfYnR1QqL5Zh7yTf/Tff+6WvPjE5CKMhNShmBiclUf3BiLg3DnOItmxXShInY5/3mvNKMexzI6E9ACYQ2YedoBslzGaDEpIsOOPqj379G08/+wyszE63Qx4qf/7pv/zyX1JkipaAbgRJHQ/u5fMvQHz79f/wXwaj4Xyrvb13SLrmH/3jf7C8tPTIN5745iNPUtHwugffesvZVbik1AwxH1vXrn/r0S9/5nOficdde3Xtn/7Crx9vnoKNgiMphdp57nqwEnBfYZ2wm7AFKB6qB6gkoLcWxRCk6TUUHbaEVD2gM59j72Ds8dUwHXyWvTgJB7DhgSnoKtY5HBif+dy3DvZCYpCiO+32usbxM/HBwdXDvYduvy9IX5z32p34qpkddFS/tv5d2cWrw9Ept6RfpNXZI8+eet17FG/654/8zsGL6ac/+ecn72zX6mUlPPjV3/7sS1tpaTK6fhTVVO+Nr39wrb0UvB8YnW1t6hWwCsjIkKCmwJA73aN7Hrz3NGScyUjBuykbLz3/FOH2+onjSDfFQETThleR4izaoh4dTbo7h3RFsAy8HEwupHgo/ak6xoJUq/BFwN/toT+OCL2o+VayazeujYMRVCK883/3r/4VzwXYuPbq1dOnz6yvWnfcsvzrv/7hY+ut+YV2vTT38IPvILx83R3n3MVTUqTQvbxzYCEcpaoH24P6M+KTkNY38LloSiOU1pytj5ln0iF7wT6yPY/yrwK6Ujfoj3usRkUKIHDp6VWkVUsNug1Rx7m9f7XqLbM4xtvvfcf3/q27qvVlIOyf+zv/++GTr1THIV1BNr/x3LHFBUXxm2snvcl09+rl/sarlNASfwH+OIN+HPUh5mW9aTkPQvPidLwxp9T3ge8vbwe0PBuno/2DKZBTHL5y8cb17c1poFfqLWKjzChOnTx28aXLYHGee3jm1MmlpTU2yo0rEJDD5VrzzuX1o4PD9ROnzWoTW4m/ATg3lspCUrrtSZTsDRKIfczptasXwpCGk8kwCNjply9c+/H/7R+M/RGePbthMokWFlqter3lldDdiPzK3NyIiFvV544dN2s1Q/eW6036K52/dH3vQ384VtJqa35l+dizL19P90dbr2zc99CtBYi/D/X41nd/4F249wQr8wrdIpKQpiEoETphjftT1+Fx0sQgIulPWINL65h2WrNohQO3xmzMtYnaWCNK5xSdtnT6qTPLUFYGvbGxtnZsapdi+qg9vXX9+efL7ZOa6ZGGdXUV6H5upfbQw29qu5XHP/3fbnvL3ywNgwtbO+l02CfoS7vEUDQlohC5vDwX2KWD4WTiY4PtUyfXdsdjdiHNXQKfHmp2y3GfPL+ZZAcQoSNBtAnUJyT9R/3x+sm18UgMtleqUN3f7/evvboDK39+/fQmLxiPTlQaNcem0crROB33+zaGwbYJu6IILe1jpeh9gRMHFfDBB+6DCr+xu8kEUAVMHOu57rlzZwfdPm6KWWDM5oGvBDmjsxslvuAcqnrU8c0FY36xbkBByeEzxu32umnOv/7BOgVCCyuNse+fvu0+2hPDtuVxVCWAr1BShrtJu2LsAU0myOXvbL60eeGVhbU5y3BrrcWyV6wuLYrjIDmwwrZptQAXL8A9gWEmlZhEknNzxvWr19TdnWN3LP27X/rp1FgK7Hv7xW4y8i0FRhvldck7hr3dw43G0i1Xn/1io3nP9cE365oLBTRqPECw6DTLcPJ3nk8co3nhpe7BTq9LrVFvUtLcw7RUqWnjw1GtXtm4EZEFd0t0hUnmluavdvaKGOf9qLu9+/qHbo1HA9ivkMu0jP60epybJUt93xvvoW4DW854x5OgO3Umg2G9QZ4z+cYnP66F0UKrcbi7M7+yxv4gv2/pxlG/myXUIyqUu3AH6p4ITRvNWqvVIsNOyKZSDUi8RFpLSej+9ur1ozMnDz76J7+iwEXKYgCyVC/1ulv19dMkTwrKlHk6Dgw5RmEq0eEEm5ePeuNxT1+/84Tp2o88fxlIkIrhUW9gT6NLl57/xqM9iX4cnVYTRHkkR6LpFB5jDc4LfRcdwDu3WWtY5fkHHnjw8vVtY8+YV0b71UPvo88+WXZPd/1nivoRQen+1lGehe2VyS/9wu8uHV8GHcNFzJSvL7VumRSTfhFoN771Q+/7zv4LV67+pw8+mzef7lwAUKup5QEkTlgD4wHNbzpgdPR8wvG1S+1aDJWYCnNLEtmGU6qstkovBr4GO7DV8Ce0gaFOyBhlwdlTy4cXtx7/+CP9ycCzMX9TXMfQLjUr1bxs9qsL3/P3fvSvVbze5v7Xnnq5/6VH/NEERUCmrzfq1do13L+Dgz4cZ+kKl6aU3lHN7h8GIPWepCGBhkhHelAYG/MnTq+c+sQvf7/18otb9VuON72Ke+z1P/59r3z66/PH1lfvegsiwzTS4WHj5a1zD55W4ELh9NRoZVLqHR0SuMxXDDd1OwHFqdhU7fX3PfT7f/ghp+LBzQLxRTlijiHs+n7Hxx6A3ZsmNa2t9iJZs1NnTuENG9/97m+779zxKGtAMBmHVwrvhhI6mUoXOjDKopYld73+7bct33bj4iunHjznOfXnnn8OLnx5pRw/eql3ZSOrndBO1y9964XulTHBpq/mB8U2sQyxz4e6z6uHvvvH9wEgj5RweGVveGEnHkdLZsV73XwldFQQz3Tyhz/9G5nd39vvd/ub6+a6cfLYUfdGMgydYmI2usJIn8aj2J8/Sr2RuTfJl977wxTDL9cXtpJsbWkeUI1sLZzAcrUK4VLYwZg2vfr4C9fg5kobZ9hTWVpy7Xtfd9/+jeupoZJ4IJ9DjYANx+H6486m+tC73v9kn9L4cLcf+889ne0cvnj+kToO/eKZdHo5Ppj+1n/8+C/+wX8ebm7WFlY8SlAdneoHcEeKV9/5kz9wYu0uT48ffMf91bWGU6V6L8V7xDWF163Z7Gkp1kAhYzT4jRfy4Bvv/cSffMKi7m9GVlSOwlEn2KXGjEpeHCkCcMqyJZhOpweDVz/4Fxun5pdgwX/72t+L+i8ViVl3F6USJdMW9o9vvzRaLn1vUAtu+F80PEwSHuYQ/4yoaqNhL1Rr33j1CcJMw0qWFe9q9ypNRjp+b+trL9Ui+BIH9ZX160DkxPEwM5TwReW88SIJMGXn/ncgMGVtTku9cSg8pcQq++MBo9Mc9fyF85vXN3d2O+duPY5MkZMg0iIOHZHHgRlcaiDoTrW09+oBkanrlCU8pX/VUR/9O8PXSAtn5nTSGR7uXz5cOVft6Y0PfutrJSX4rvW7r+xuL5TrjfapPOzuPHWVtGNzfuncieTo6Nrg8itLp06DjUcB8TOKTLjmb33jXY9+4YVaCQjjnlq5fPrUsStXNoFcBTwl7JZ+0BIJwbciJgbaIzQokwMyKfuGEh0Ztz7U2h1MVk7NUdbcnHcAPIgPgpQn6Ebs+N04NLOL2shs5v/jM/9JS7S0nxCog2B59dJH/sXDPuWGnp0millWXepoPdrbKbgr1DgQ/MRe5eLhKxTC27H3TBGmHqXJTFFIekTzUnryT/tblA6rSsVFaKGms+hmQEew0plaZT9vpsNPffxTZ+5/+2Kr6mlUJtNn5LAU+FcuvHDq9NrxhXmQ0UyfAo9hjveSw4sHOw+/4e0mitdTuiicaum93/c9hwcDiX7pKzzo0cg3phZjGMBgGuwdFGp96por93/b9uHO//WW++bLJZaLoDcMA9dp3Hj5lbXVk4GRWMvEpKTqKrXVOyGyB9CqSpW0D/aqXtztPPfkk5e3r7/9299NHUC9XH/5pcuUnhA2A4Mg8UgG9WQlt5JifaTHwSyQTs1jZ0+DbGRZaJRXrNvo06PpJIoXV+ao+NnrDB46fuazn396faW6cOd6GNG4OEM7MlZIT55n0kkcZJ3OrBE7K5hOYGRRX5Ua9NiBKUOQvkCnMjY52nY6kiIa1Ryb+DnmNCD5oZZLZeCSsT/m3RyX3p+HOVRz6pJArgLKLSnjQG1E863jwfjL7/6+b9/YfEk1jlsry2+59U2XXnjl5z726fffslaCYRz1Pf5gt6YqlrA/iG85sXz5uUefOn/x9jP3rd26BHeeqmodxr6LN0Q1m9lcaNCxauB2KbTv8xr1+eWH1i997HcCNa3LDYNJf0I3pJwAGVy8KL727NP333rv6NUDgNaF5YUnvvKZ9VvO0WHgznN3+niRNCerVeNhV0vdpltHhVx44RIqhomFl8JsEB8gzXmsHHVGtWoFVDWjjRoKcaq869u/a4ZTFMapU00opXThZaeiGAEa77n79NTP77hngX6k2DHPbAwGIVkYcSAKv6w1SaQf9g5XFubxdSnNOKB/Sq3mJ3mjtAA79OJz26bSpFZQR8ihuqc00JQsMcloWs2SNJe1oXbFzOnvxc6Ez54CbhZEXXaMi6jjamQ/9HM/w+4teXS5pYRn4e3N4ydOnPrcF79IuHn1W49eqL8Jktm5XFtrad366X6S0k64ttLwh7tAC9Wa+eKVy4unFwH2ycTgd5A0m/j+U49+zXCcVXbO+sKg22nNNS6d/6rx/v/z/r/zk4//yr89ANzW43ppsR+O2+VaNkg3g8H+vv9U74trt5xoaVGhxZvf+tSD7/gAXLa542eUQUfKCnNsORMzpJ8rJmHrxjbwnF2vjcMx9hU9gQoCAQePGo9Dkq2Ew6TLQESALBqV5uFOB22p2pX65QvnT547RScn0kmUEVPj1WrQv6+K13U0OCRrTE6uVG2kNCXifjRTDbXuKG236HcZHA775UyHSb+70YNqXa5UQV1AG0AMSSbSzQ8VTBqQ8l0o8XgFkjLLCIUtNg4anDxOAswoRwjhHQH10vsbOgE+Gy0ObC4fKOPf/9IfPL19yi3UpeVV8JsBJY1W4rScZae6rkYmMD11qItzBxtHdq1+ebdPpF9QUbe/r5P4digRi6G0LSwu0+KDNodZ0kS0kAz8eM8tJWm93xuXGxYpl+29HVoZB75yefMG2Nzx9VOUOq1ZLtxwUqG2swSSQwrUgkt0GLNjXae2F4XKdFxnJIp+BMMVLoihQv/gGzQXxAzTA5RR4gbT8S6JIQhNMdF00QypghrjExRGMPRLXqNz5DeqldCPwfIWVxaHncn1qxsLc0tzjdY45AJgmeDk0nxENSb6VIy88uqrPYR7OvFGA3hBAHAaoTmbiYnGUrk8lnijZOCNwWnsd48adEljLqAGEjfScUHyjThbGZwOR+JKcGA0pgbkQKhEwQgFDjS/BUHJnOS5Ky+BDSn7V2g3VNe9w8de+NrS/H9TewuddO3NDyY3vvSei4uvV1t2o3S+OvfM008ojbzfj972uvvAJne3dln+IinhJub5RE/Cq/vhSsvs+vuSaOz5T2z7d5UXjyh83PNvP3cWQ7Tm1s7WtDe99W3bKMAk27n0iuIqXolS09xEccekuqSbeQLprCAPf+7YmQe9crG4tIbmgT1LuhP+W4lu0rrU542GZKvgp7MjUmYSbaumDhE4WtQol83KtFg7cXrjlT3ycMdOLBAuvHrlWrXUPHtyffOaT5XA3Fz1lcs3lueX/P4hlYk0YHjdm8+88NK+2HrQFhoF5xaBnnSyJYNOLoh9mNP4lB6rOp1sbEoYAbzI92IL4TBHMdFJ1S0XNNonES89FAgqSWKweCCT7FPwRA2OPrejEJfNZGtuqknjfC3W65n+5Sf+gpYa6ZWN5VP3vP0td5++7aTizP/AT3//B/7G37tr9Zbro5e8XN17+RVamn7y95/+iX/0T+p1DwyzulAW2rNeoSu0Qig7rVfqq1POW1CCv/tP/48rf/jb/n5+qSif0MKwf1VztKuvxjcGnzy53DRdyEiUdwyblPzt7eVz816lNAn3yA9PIix8UtYGWXBjY5AAY9x67jSMPFgYTDeZ8FS1X738PC2KdrcO+wNK/4foDAqh3HoJ60CNjxEOMEtT9ehwaWkdH5oEU6c/PLa6ROao1fJefvxIby2Np0fz1aVef1ieNktlrewwJ5P5hhlaJn3ju1SwMn9U1htaybTxn6CC1KFt0eW0Uu4eHtEoAWPBcQKCOwvLiLgSfiw4RUh4R3Z2Knk+IxyP2KYCxHsmKgK4NEPzIisJW5mEFNIknS7QYHhLwL0ossPrL/7p9vnpp2kcGv4/v/uvMe+7ly+V55pnb7t3tzeyORpBVXf3r0FjHnf3G6Wl8dAn1dDxu7tbO825W+46cS4fq1CFfu2X//0t9TmnMa6Ok40edb6wrGvOw355ED+1tTOtL9lt7ZmvfykYjK0b26fbC9/10IOlibnVPZhq+YZsBdidzv6VzcQ4ml+YJwOHoYMLXy7TnxoRAjb25hYW221aBjSXVtc7R72CenBiJRzCUX9w7JaT118O6rX6aISGiqGkWVW13xkexL1h5FP5S3+HQa/XqMwJYdIIbJX+T1pI1bLl1ea9LgrUdZM+KSe6lIRmyay1WzS6o7veaNBn2wmLjWgJ6NwiRiY8gqXFaQYRUCfZEwSBXRlRY1wro47IMuK6weiCdQQKJ1x8ggjp3En2f0qVMNXF0r6WfYLnTaZpQikWdoNmbORYIsz98MaN7avXqksLVEe7mvFffvlftVaWahSRT8nE5qunj/HoSM8ef+TrtIz6jve+s1YtG7XT5xbmfvMPf+Xh9zz05RefWX3dHU9v7DSK+LQylVPaGif/4PFnfnL1tt7W7sHB/pxut1aX/9H3LV3qXD3qxD/1W3/iTcctS62WKl2SOoc9WmlRlw8n7aVnn6LjBQhxGMQ4/tgButn0XjhPT52F5SXcsrAfGuduPYEaOXXrCdtJvThyPWvUzzu9gK5DeK1vem9zYvpTv2d5U6fe6ncHcNio4KA1VLNRGrKbaECojObWWgfqxJrCw6fdwxyxBnH4MOhH0jxA2kmR/YClLWpe6sqlswf6CelIIG6RRWRxyMuKgyQxFSG7/AWLloADbSQtp9FEKcYJ8uKEdMg0AxWjRILQxsW3wNcxsNkzM0IFL5QQMiKTSAIaNV5ZnL/1zLne3o3xCIxvfG3nBYJN7CT0cFq4qZN/5LTO7ky7/8effeadP/T+b2s99KkXf+d3PvfiLe+4u7+7+SOfe/67775/cPlTa+70X/7dn7/7wVOmNnnxyW/e+dAbb3Sv6bNGrA2snG5n9rpm3fCPAkDQSprT455aYSjNrku0BlcTi9+I/WnVSarVWhgXz77wYtUu9QaBcYhOmqZhf9IctZbWa93h0MKPOmZBJkuz0E3jugeF12k0544O+uurJzKln4UoOH15ubH57GazdvLkidZ8q56MJnilMBEnxAVRMewNp5CH8e0pcpbTn5g0CB8RqSFJlkK0wi2HS5bgwzh0CyFcxFuC3wXmBabPxqATS9kRmY2x0wmyjP6BmAzhlc4zEk8KWwwbLp22gXfYJ4Tv5JikSwOyzxrwNVXMm0dHW1/8LCCANBxFOUPQY3kNQE1tefW4QRI9yW7Njctq7esfe+Kr2dfyVoU6gM99+OsPvumeN91ae9cb3rf1rScu7by4+ob1P/j0p0+fO/Evf/XXhptX1NEGFY9P7R7ohk+zmrRzqQYRtrCRp+6gb0Am3wOkQ8pRFqx4cbD5KuQaP/dPf+c7Rr2+mtfg6N161zq8CrNcL6dehbe+cP4yjZOqc424j7rIaHW33GwdoUZS42hCG9nlg/4+jg1lxxdfvdyaW1pdWnNK+B2OZU/b69rxE4ublzc0dfnp5y8bVbNmlEIYnlFW81qjSDpaSDaUBnJMAwXlOJik3oFKaIBH0m/G0jVUO9JB9tHdtDQTUoOUY0HiL4NNkomCPsItEG9ZUXRURFEUeWQ2QQjBhNmXaYfoIPl4to4QTpA+3D/KwiX8QJmyJSFE0uyKBroTn7xOhfX4jh/+oc+89HOOUev5vj1ID2j+31Qfv/gCn/0Pn/rXhUXKr/HIS984Uy697vhig1ouvXLFPI0jvTd6YX2pEVwh2efvPfPk/e99P2026DxHf6gDdewHCCB9KtMwmKSTUa6D5jaBwKxKKfEn3WKwde2q8DtJ8jumSlKtTsm67e7s7Lv1Vrjfb5NGICil3XwSU08winoW/auCbO/a9VajzDAO9v2+r6ystYiqYT/2upu2SUw1One2ffrsqW986XlKHeCe0AqBeIDKCAYN5QBiNLaC8yUQDiQZeoijoUbYEkA2Br3mnBIRAzRFDmSgGgIGIa4uGwKXSqi8+HAwNXEu+QjJb8G4sC78TJh5MOfoEEjVrmwR8rSCBBBhaBRzyarim5FJRHlJ9paEYhJcu/ziPbfefe3aBrHHKAlmS2jUWm1oKxAAiOAc1ox84WRQsdUNf/CVF15+6Mb+EJ/mYB+z/dff/f5Xrx1+avOTi7b6rTEZ15y+4zj+ZBpKJ2p7BwYsvWoFLJyItkTShvenwwnlNN1en0Ui0ym1B4hIGI7rNSLJgPc6sbZC6B7XG3ScODigXCKvNeu0HaHumQqJWB/M2W34VYZT3HbPcdoQXXr54r2vuytn04y05kobw0trzDzZffM7TkTBAO2uFc7W9ohuMdvn+xwz0c/GqhXf8/qzrq5vXT+A+sH70cwbzCN1iELwcfIm3T/Al6OQt6SxOhsC9hx0DwE6qfyiDQOaCi4vRhlZl6TMDPOSGSdkZyHYVxRrEfQT9cCagqRCUQ6TT6MadgNXZA6J/rH/4T/72Lv+2/fe9aY39WH8ylEaLqn31Xn3xOqJvUv1KwdPjPERYV7R0YDUU1E7nLj7m9eXzp02WzWTDYnnfnBouK3LT2261YX15drCffex8p1+b/fgaL5RB3ADbgmDIZ2xHZalUd3e2a82qnNzy4pd9PZ2sIU2pxZAeqQVfJxiv0wSf6Meap6Msrq8OF9MdM5UItrYijqH13baJZd2UAvLbfpDQfF2i/DuW8/S0i2tEXAT+dKNTDPLFVr/9TvSuJaKLJaDuNoPglN3Oxt7+7c0mxV3dRzubVzvrK7cSmdFFQxQGrFVGaeoKbhgUx8ppkgxDCN0BStB2wLIIgSuEzwHOFYocWSW7lOW02zTzJd3nsjiYehF2cmKQcJBxNg6RN3AErIBGIYnpwPKmSGE56n29re/67N/9qXveeebf/PiRUfOr9ITP7gWjq9udY96A3oTLZB46Pv1WnPojyDM6Hl84sTp809faJWrFBdpa97i/Akre2xjh4pa5cv/4D+lJSUaSVstvVVbu/eOxuLC4p13rD189hCyJ2eADUKTegS1+NBv/vqd73krrhykEJ0kNe3eaJ8h3YXyfNAbUXcp5/cgMsPEJDmJw5Cmi45eX57DSpcqFX9Mi8uw2x0PR6P55oLd1drVejAa5yeMww1O5ogSWscqeaXUkrap9OSr6uwMFHe9uhQNRvv7V9rNRnP1OCry2Ln5PqdrBXSI0Kg+pFsTTeDpoxRxDBj63TE5M6LWrhJMkMaBvUz/F9A6tHySTRbII9L+Szc4qoIGRKh5KRsVUglxhUEXLjrHsUHACMWwox8EpTXlwECIF3SioSwiKS8u1v/kD/4cxLgMM2NKeQJbEBq20p5bwGRNXbVRWfoXP/tPvvW1R55/+cVXL+8q8+6xc+udzU7b8no3hq985VtgbuR0Y6sSVJqc8JGWk0yJSlM9vvSqceny5W98ubd9VDrYH9HU+9Tt/sl7a7d7wxpNOf1S2TD2j3y7VKaQo1LH74bWocNvD/2kPxoSWAEHUYMGniBt52gJSzFQs0o61OZoielkvjrH8WIcRsCaTSKts72/PejWvOpSsxTjXMacEkC4adWb3u7OnvBnxrmvBCU4Bnk+OuBMj6R2zG2Wa6HfKywKgWD6KhDGGD9zgYIiTEZv0kGU9D0JJxobMmsc5DHmzLQ4WVhpsmkIPvgxnHAJC1CX0sWBIbgu5fBCrrJAH9nm4vjAiyNXgomQFm+YAhCt6NHHn/jbP/pD//bf/CeUGswSXQ6wg8ornpJQ24u0DCeXRMRu56lnn6Ep7rETc6MLL1967MJTXzmvjX2jqVaLGhHiNfr9VLI5CzMP5mPpEzla0j+Kp64ycH1rfeV+76yNz1fkgy9+nQaepYDTQQW8U9/5E7fDPaUQH3hybXVODnahb4hOgybCVlfaypgcHTBBs2LYIjp7ONTS4siTDIL5ROFROUpRPETUlM7aBQo2h6qFocV15zAJC+CBfCR+os5hdxEHErmDficYxoCUIFlBkQXDEbVz0mUEzQ4FhxdQC2q+kXfcWcm0QIbOKW7w5+ZbeEQ+UCEFZoW1emrFT+h1OaQvDlXgvJJQU8Ff4PnSc4HenLZNbzFuK500UEwofgGbxBIQmxCJQCzhIB6AnaNBOF9pHlElYFkw1FZPnTjaHtB9ESE43NxanHcrc+svPP98Zb5Bbe+b1PXXzy2/0jnAOlCJcDlMbhgdCTbxouXYJowqiUub7hynS3N0l/Ug5RbaGCCSUGaqLgJmUWzM8ZNt/dLwuvqWv3U3vETCGEFK8dA10CK6OOaLc/Mc8kAh4E1GEY42V3QGEzbucDSEREagMeyP8bzpT0QbUwji7HvcBpjZk3GMJq6UKpBwhwddFEIW0UYEdcJ/OsAsd805T4qVo5QioL+nOI97h7SZrtExySs7UkAmpD5hOHnNChqSNi7i7UJ5Jdvdk/7/SAYKk5qIWQmjUW/O02ULngClGyA9KS08efuiGPg+ZBKY5mxo2tqSbGGNKZfh0Zx0QikAJo0ORKy3VDrRet62SF5j7YH1ORPuHQ+85a//8N/8D//xF5545jm2ZTQY/+cf+39vfeX8B699RZ9TtlMgFN6ErYczQOAhBZRsNfpv8C3cD76HK01bPzqpg6+sLCyVp+XjRrvn91+Mt1u3LKjv+LHXAUmQvQFXY6viRojrlqdQFMgHyH2p4YOCQ00M7csh44ltpkMOwRv0Dg0qEqAunxBqMUZDLWjrzVIBNkwxBKYkZFkdMM7hMIC8yK6e+nQdSUh/8nFBGmhjRutNaq7o6YANZMvEsBCFGwpxAflnRTFUkyFmWSOF4A8i9DU9lJijkFR+Bv1Vo/stEmgk2Ax0lzuh54KkivP9o76te1JFw8shnFJgB47J/oRmGnE4T8y7EMBxLqOw/HIbnAssFleAjFYUNWz9//6pn/nvH/rNVq38zMvXMA8EkpyIhDNHbhPPMqajBhxF9D4eFxm+WaEDX0s8LwoQB0xwRgnsmRoGAJadKjXVbZXn3/ydb3/p4osoO5AwCsdyKGOzk3PIe1EmRAmyQksLUb6SYkYzMenw9xC3lGVAwYmdwp/j0Cpas8AHNUkjyfW0GGdaRc9yqA9d29KYOAsD0uY8ISnD42gL2ixgJClqnODS4yQT4vLqrM3IH7AStUaZBufg+SyzTWvEaToJOY1CPBmAUzaS4UkJEkJB+7Zmuwn1lPQ1OR6J1VDlYzyKQAKBaVErwdsx4IYIKZolEgVEsYZG/o12JzQYJoaQ+ADqBqqbMdJphunSCmGLq251sfX4S1ezovTChavw3PmUzIxNF3TapAExUEis43Mhn7MZZnlnbFHDTKYRxwsADWP3OdZP4n/0HkQppNWkzis/DA9GqX7j/JH6ph+8nUoH/J36QnU48LGdBND0brp5thqZAxI2qHMEmcHRpYgdxUtgyITLLFXmMVUNLCGun4T7lpwrIVYR+IEiHb6DKMGSpMmhyAITjrLMoYN2Bl2hdc7KHFjJ8XgyN98e9wdjYLwQatQ8KAKCiw7CGspxpTj2FAP1CMnAVomTCsigMBnh+VO8TrNUko6Tke+5lc7OHjlbuIDINMcXkkCPJiE+EoEXswDMAFUdn4E9LE4R/QK98pjzaEslAo/xNORYKs4lCZlVpiDCL8AGoU2wx0QhEvCxDHCtGZ5ItLwexGdc2ym4P7W1TAOCKB8h84U5kiogrmf+ZoskbQAVtifIHPj7tz/wbvXNf/NO1C05mygKiVUoHKU7wWg8BqnBiZYeUUwE88+Oo9QN5NlQ6G0ODIUs8x8iJXaNaimpq5JmIvwU+WfrSZhKg0RybsA2CY0vHERNrqWwhGIdTlEQhQaDhgyboHfQ86VmWHoBEHdI9pjkGxJKgSrvL9qftc2hEVmQ0FGJJBgIzSxYyQg+6kVafKVU/bXpIX541COCGo1doFzCknKJyIyFpcfP2J+QpSafTgABZARxGlo5xzETlWJFAU4EuxGXGGEjquVDkZw2mOkRNYDE1hJsi9TLaFHKWVyxyggnfhd7HWQFT5JEE4vCbSReKfBrSfRLJ2lqpUT3kZhxNFpm0lCYvtszywOLj4I1Nh7wS1lgEhAehhRMwPZ0ZkGWQpOD1Fk9SpZL3mwvayrt3BECmVS0PI+ECc+mQEnNeqIy+1gROGviRZLEn1UDiCEVNjIngiCRdHeiuRzygYpEaJhudow47AwwDDjDizUCcyQ+RxPimyF1HElHrOqhLmCd3myThBwySFxY+hNzcgtExDIsR5KCddoqsYfZpswKQgf0ZIJBYrTDYNrvjKiOARihhJbTkWpVILVicDiSS5lcFTreBCGkxz7zwtQ7tOsWgARvS4bMLLMMeOEQheHlz0YIkphAAOBHyAdnolHDwYIhH/QfI0OJjNDOx27S2BhrSkc22rbTvU7sLsMRN1mkmFw/94UaAG4Md4XqBaSTwA4Zl1M7YD5RKc86kn2UJiMoTRxnJhG7w6V8ATUHF4x7cB9EEtcH5YU/PtswIKxQNqiv5lgncbORLSYFBcX/7GgRNfmQ+BDclrfi2aDriCpRMdKKgaEoyaUBXkpLUdpos+cJpsjzpJNBwPuzT4RJCCEvjuk5TyUfqkOaIAHVGTQIoSUicY02ICpk39O4t1YmAqg2q7jW1LjRCVinGmC+xHEjEj3IVMj52ThVjA8sgXeUdxPglg6/IGc08pZTnnb3dmWxTJdoCaCbnUKLX3F/5Wo8w1mD00zOTiDpxxl8qBMSsXwcacVFkVUVVceqktpCaZLAFHNFmAk1kLuImmHu2BPsOzYCm4vJIlXFq/A4YJaJT5jG6Di/Dls+e0XuKPM4m1Zq8ymTx0HmgMYwxJ8jp8iksDloVU4Xy4huJaCMdJsRM8H+pzUbXQwIjYnIOTWLyEmpN2rsMPYHiUwgQoJhaVjOiRREz3AQOBihXjp2eh01nMdRqQwUMUH6OAKAuJKujKMtX6UxaJCH/YjcB0EGxm8yGlN8QdfWUZ/qBKI4tbFYx2uVyAjNJ0dcgmbhoAtXIAaItxW34sA5rlCPCb237Lbn6geHu8wSYdYdd58ej0e8LZkOxt0DdpaS9aJcKeOSSJMPddofdcs122uQRUtac/MoXhQ8GT8URgEdn7wrewJggMSjoIvINF4ex9/ihEwzjngaDn165pFyZgGI4CR1DuCfTKWVSyhbRHSjSIxoDLybGRucHgoJEyqQMHRXVCHhq1TqiuJBy0g4wOWYC0lCoCuhGOHSweSVk0gxAzyLB+FKUYTNnyKVwk2muR/rj6SoJfr1UkLMbeEcaBTh1uR6YJCYzoqZW9bbXoUuujACylaLxQbCA6QZjf1GU/eHPkEDxhkz0E+OynI6kmRRaAZPriEc+pQ34pRwCdofbYfaZMf40RCJLXkl1NT6ylJCt3gKGbRofX2Oy9ZPLWxdP2Qt0R8pddIzyaN9nlNxKdkUpTItbr3n1se//k31jT98G94ecjobMOf6zX5Mxo8xi22TUIIvMKouRboINfOLJyInfMB+LrMhCD1w8+F/6wIWWEFKmMSJHTCU5BfJB64EGigDgtM6FrUCtkRtMZGVHLTGHEVBMCFPBJu8AvqWxBCEyBmgSdFLdHeoVGhVEMrK0bJ2liqQvl5cQZ0EpULgnTZgHlTAWCwh7ikKW0wf5hl3UyJkOTwWOgknpXC0D5G55xKU0nSHyIN2Vb1BSBEwBwcSIUYKVQSc+wj93WVG6J+FpqLGC/ata9qDvi+pBoq7hqHQI5ADAernHcoyoN1zXsvwyKs1UJ39Id0xTUp2IEuSZmfqCktOWeVW6Tg5vniq1+te627ByEdIpYZMrMpM9IR5MEt5I0HMPvgibBMWHvlllyHUYoLAg2neIcODhcdMCLCFPqdUKZ3lUaR1PyYfa5yKtLaaDb5mWtD7PEXsFc9jRyOfqlLjDI7WnNgumgYbQDHiIaCAxTTRf9ZzMPU8F6eEfzK1GCEY3xhGuQfhWEGBNd4MeinjpBecKBaeV8QM0hdISAA0mnituW3E46hex9On3IxIkCQtHhFBCU4LPUZQEUvL8+xbr0LJNX0O8fqpNKDTSACbBkZmda5MuwZ6TcKZEIhEAyUzsSiEtVuH2xNOcaFNdJUDNcagAI25Jpa0Ua+KzSJt1ajjEWDeFuYXr129sntAW3OHA1rVN/yNs2gaidNo/IMZBjUUlY+rjkfFqW/IGugmlppkg0QA7ApxEqWijhpck5gLFwMtzLuKLyN1QTkHcnEcET1x0F/SHABXlS5SdKmR+vHZmbfkxcAMJP0hED5GF9wGOeBuYngVlVIZLmZP8GqQ/ZFoPo7NY8ORigG3Q6wZDDZDFob3JUi2LVLeqEoOt6ANiYQhOEKw3VAZ0vGKRuEWZKhqtTKhWyXAnJyHJHx1LTU5i8U0KFKbOd/4o2lcIlOlq7Wl6g5dkkx77ANwKWjgGXAi+VRpAkP1BQEd/D46NHklNWItqG6xYHKCobUX5vc26C4v6GFm0rkFMgHnjdkcyQJYiOG0qvbh3i47QCPuZyPDIJsB+kIjBMtFslHNYgzoAziTdD5L+I7KwWCg5sQXEhYY2w9AFAUI0gf1GFUpDq/MGvMiDharxZccSUzohqzBZIGez0rIZsJzYMOCv/JQZpPvEN+CgKIJ2Xb1eh0tgXTIU6TYlAfDtR8zfBaWt61w0qS4cDNfhX5HUGs5rhL6PvgJwk8bAuaa4aC7cnrcCL+DA3TIkJOh5kgqkAzmMZj4jUabtEml4VKsSCdvDgzmvKbD0eDGjS0krYiUW8+uV6wSDaLBbGDt4alopE5TX2Xyk3Fhcj4JqhKfxlpozNFfgjKIYe+Io0U4B7RSc4j5LVjdCuVxqlYHDE9Te7rboeRMVR/8gdNMARQFeGfMrShl8hVseUZF26OZzsUEiHsuDhV0WlosMF2MVOChGQwixbd+OGH6IPSgz1heZFbwYdQagkQEKWLN7pFkr6wcthcmCzYBggjFEiTgsGCiYgAOMDlsCNLBxSSYCDqPPgFoQYmLLcG3Q9zJ5gsHX9wvaR5gsMI4+6wF103S0GZAeH44S2xI7giFDS1FnTplGRg8NjSuhsNJtDT8o7M23Xtwqomp8RSwc3TrRkKLEQgtxRTgy5ZJ9RoRCP4W20tOMeRd4by5zubOjWZ1znFKeGssCrBpu9xAtR51e7Raby42D7cPOS4FrILTvHFMIw5w8NwhZz7QcIcKlhFRHq+AP5YCLgnIwwIwPIbIDGM8cU8Qbf6NykPZsyfE7aF4mHhKGvfC85EQDLC6XKsQNGCRgU1ZQ0n0YEA0O2V30Twtp5u4S30sa8JastC4O/hKgl5BU4OnweyDo4NkiKJDKQlOwH7BRPGfSDxxFF8AjeSclBmJd0aTkSBm+1J4y6OkmzZijJQVnuBNqANuiffPPiW7DwA6z1d5OmTucRAIzOltQwsNniwRCPvfFn8cgrpHBSnlBRy+5Gl5k0PEgok0dsHmIYPQPEoep7iVal4cRHONBdYMZxlREzJoFLlLXjqSDse89LA/Wju2tr/f6fkjvA6adVUdezAc4sIxCZPRROAQbCzBFPUiiCGahjNgCSrROfJOlilUTnH58UXZTUgczgaxK3oFGoiFjmaKZEOAMklkK/gocRShEyoYR98AVAVimHXoR9FzT9liwoxjE3KZTbSJbkEfiF3hJ9hpwY0NnCDkBQ0m+J2G1cNrxjrSCAlaIYKIT5zoKexTbI5sqJA40bIwPTMrBipBcQyWyZZYXc51JCyTZvVoWjo0sHeJatCLeAkIlrwYOoq1meJMO3JMd6ZBaoKZyjg3j/DroSLR1tXmJAuYoIAZ7OAJ7TKlS7TUrzH1HKF9bKmGluTGvB7rUS7V9vYOONqsYns0g+dECxeINwmWS3OTXAKU/tD3qthOhFtCMKgTAbEMRyTiz7Et8OfAhTF6SB7yhRoVPQJLnciMEwPgTFGpz3MkLAIKFc8WN5GyXomwWAuiC1UZIxMcp4dXL44ssTTwFPcHGGHO0xGpGBo9i68lLhPajKXmWSgf8g2sE943qhErD1QiDYAgU+RkxuR8ZHw3n8b4LjYWsROA2mTF2AG4OGAk6BmALOZew5hxVgD/xHObwl0R/FscNtaMUiVUD6vBTsU+5S4daICUOcGGAJ9cAzvOMmutGo4s80MBAumakgXpDViUWBcvDvRX54Q+ttrS/FzMkmT59avXUR0cVDTqDuqtKsIB3ZP0KrqCTuBsb0c3Gm5FSVQCQJu5ZQcS73IL8RRp71TMYDW0Nng9g2bFkXdRR3BABKmF00jEIFIHyR+3k14CHr5gjvYgEi5BHSCvSWwGoQ3GNDslmxJ9zxxBG7QARsbMPEBiQrPzc8wN9TuUC8ga4gmKH+nSnZE4MeEVgYBYDkAtaaqh0FUC1whMmzp1zWqjxlA7EpAToHX6XUJ7idulGRoalNvTNQBQmkoF9AGSSfLfqGp1hH849eGRw39BgqhipHoSDYy5JWMDZZxohv5ZI06QR3VieIgQITYmhpyLATKGcEw4TdjilEaabsgp8qhD0BGma4JnTBt5YWaMBv5SvYLgks0/e/b0xmiPZcY9J6+P0licm+twQu+oJ3EAPg8zKAMUfYQ+gbAv5Rv8QoT4EoElW8qycxnvhODPzoVEWnFmiKPR+4SpIoM4y8i4xGXi+TARyNssLURPijh06K+mUlULnVDoclCGmCRmkz2LzyOQEwRr+GssiMB5REszAA4Hl3w6XrucKi7ZGTbMbIJxhdFpYvDpbMXBNzhLbGdx4cGExUuQ4JnhigvNb+6uFJyaOopHPB19C2UTBcIwZ4iN+GRENNwPbiA97GjpgJjBjuF+s20KXEq/TXakUq9VkBSqXwlu5WV1cwjmSEE/qeial3D8gqovrSySWUPRT8IR0QBtAWboENwz+K0YJ3JwjBkfg65PcYjPwJSh0xFIrpuifui+C1BLy7vMSjmtfFY5xQdR6GiJKI2QGinTliIZkMsQHxgwGtOLCKA4IP5h2vgpKoJthN2Txg+yZyjyZ0eji5hKFWsGr4IWA7IbGC597ECKBX5gYnH5pCMjFEQIv9ScEAVCOWSBMQzsyll4QeJTeruxygL4ysBYR06VkYIIZJo1AFLHPMAjInVGTEDaHN+U7CAzgfTpmdntDhDeudb8aDykbLGtt6qcnzCO8HRwZCl6EG5npsdqBCMOrpJN5QhMJo8uUjEHQA32/JX1dSgDORwZYKWRz1qfPXlmMB4eHh2iRVg/6uZJTjBU1GhU9E8sHCP8F4cKM4RfgsQxGpEe6fEJkBVBmWZIGNLMTwo/hVPJLlCghBjqsnPMi8mv02Nf+t8Rs6CLyRDRN2+GjlGiIX3WuCmqwGfcbBqAM1OnmAxRkzRtSFdrVoQaFh/RwrPE6rCr8AVJibD9opAzHmhRSdsg1WPD5FQPG25GHaJKDCUOx2vpT5qtgKmRUGCmQYBFWbI/cGPQltJ3TPxkMJwMIYSlMTMwuPB5HQ8HdBNoDOWjFCTgSjQO5Jw20jcgtSMOmJUOFIBtNJpn18lBqyntN3G66NElCaqAam8CgGiCjaTPEc2b+SyLPQJmCkOSd2O6ck2oGOU/ABLn4Ojw1PFjAHr1ah3oQlqqic9BjR0uBoVh0O8IxKlLpX0NkXCRNarlmaYWdZeqseayqCot0jkBJtB7ODekkcnhi2EkjQ1lxDU91SMRKasJQondDGRCAWHtMl0WJWTFSsOnowk/u4ukK6UInABG2T95MZA7kgTomVLJ9ZMQH55ZY2mJPlAEFOXi/4JP4LpxUksWSiMVVBbdFaj0o+cBbjS8ColLOUwH3oZJQYdkagnbxNJIe0zSYLARwR1lq0B2gbkic4q4EX4ITCKxJ5sXGzveAn4LgNZ7/QEHEnFOk2OUlUihw9iomKBj+oPuXL0d9PsOfGF64VVqWDJ6uOF8OxUrp5qDMF7vzzWb4HOigqVLAbnZolVrsDHx91hmaAkUUXAWC+9DWA64CLiEXqJb9YyvSVwi7ib6jfaOLDHwGs3uGTLZrBlbB0QCPYexopRfAAnwREIc2i1jMQVXIQcE8UBAHxFMUe847EQuCB1uBHoJy0K0hAdMXz18DHI+yARdRlAL+AOIv6QNyAOgN2iKTLjFFsxyT6/acYlq2WyCwNHZjN9KqVzhzdFNGDAJMnBsMrprkxYgQBQ3gKeAZLHPcLOo2WI4NFWDoYHfwdYn3BHjAZzHQZTkP3CSIAYjcjQEmbV7DvHjYLqTxNctdi0tpCM/lM5MLK/BwREN7CWBoeN6ONEmTT7R71C+OVebHkfMvmb0e4NEjASJfhIXsmHBHCVKIcp/8PuPIX1QURj9lJHJWNEZZJAFpObsDhj8+KNEH8QDTDKIDQEx8BTvyGIyt6hzplLCZFFaCtEcgZVEQHh1ckJa5NRhXSHPES4/SgFohZoC5I33IYNAp15WCE4QHqycdklsgSdLFhPYGdcIPAPMQXgs+GM4ERa1beCaDJ48Dm14QCawOrwA40EkeCMaJ2HASZwx/oTWJG6ZIkB8dvGIeC1+MzTIVyB0MN0RMc6WI87izFYcOtONd8nkFGM4wA2XWkNOfGHibKsyZgpxYokVXPx8XkSOCUXPsHjlCuj3jAiNiWANkGGlaJLX97yj4QCYi4CRHUz+B1+GrgUVAgbq7EY+YIi4+Oh+XAWxgXAVcbwpGxXgDIhUZhWNgaBjuBAmEQ8Je2XPkiKngk7WgKEAXhDm4DqjlXCHkF4XrxQv0PJaNZqh0C42HZG4EeiVd0WBQK4X/wXRwU/Bd5FORqw4EaGQKuDQEG0wUZL9F92BJyqeFXYZFAr8G63F3NHGR6L2GRFxZglQU1gzPAWKEEOyDxXXw8IxEEndsP3xpnFyGLSE2BgBgRfpa4XPxP7kT5KFYCnkWoi2fZLVhCu0bXA5jSmhNRk7nj5cTg5cQac+LeWY1GnGCeKeao+DBF3PqZScUBdFeOpOkFFqDBTNgU0cPArtgr/FJpDRI6cC+stqKICYjJE4FpsXEKYQf+FhcD4Ap6dLMpKmej6Gk4/hqzJfKApkSI6qAgomOEPwNI0ONMgjk4BbetOJRCKZRFJWnKGHFJJvxO0nG8zGxOMkFEDXy2nUaco551hIhJLuLYABwDKE3Ow2bkt1hkwmm5H1Jt1PhofrQPp0rVyGsgYFiNOsONrWJROIymIDktrhhcRvzCWdwgvStAbyL101yG/IKcHcBNeNvEkY8rIswHg4gWBBIOPqHDxAVgeZY5cTvuWeFBD4u4f7+wcdLmYLIbe1MjXAMXACyorhQGSX0NHQOMyd3BlybLkGdV302x3RqKLfF3RnmjXnGygoUHpcRtZJ3gOcSs7WS4SkhyOPHiRaF9690AGAuSQsmok7zjGTLoAawQV2WPKg8IKQ5Znc8nB8ffSJ5DdJwIrGBVMSbBnZuom1IQf4DugMNBggF1lyHGRsOGuJ4wtlgY/zff7J2FlGIfRTFh2TwcA5sKCNoOnZmuggdqUEDRpoK23wkAN0uOgUiYOItUS3CL2RrSROPdUdAc6ylK7zYgxKNg1n3IJwCXoiRZsoAHxKcZhBt9h5lTIbFPifu6IWKrUqTH0Sc0S8zDITA87OuPHUMadoZnwO9AGKAe+LhUfRofFrCIXrAgRhlqNhCChCO9VGHayMQzGlFJ4EDo/m+EYBydnyArpxDEi9wbWk+GZom6CWkqcR/Aem0E28woC0PAtNlVLJIbGOSkDDEvVgNiBPsNNBBQRC7HVx8eSdJciTeI0NxXrQ+osdhhplQvkhaxklcuSQVLAKDC29PKknxVdBCDifjICLR0MUQhrw63GTKOsYQ4llDYhFAgiWLggZ3T3wX8n+E9fwosKhnIUt6Cr8J1RKSiMUBsYJV5yVI3ZL6g/C6QS8kP+gZeIUAORSH0gwRaNx8IG6V9092jdLNfpqwCObBNJ3SCJyp6DZO2sMn42+AwZnH2kUqnSQN4JH5AA1g8AhlBzUyNFI+GkINbk2KoCqJY+hI/BvvuPE6rFqvRwdHc6DvJikFFAr2E8yc+RCbbuM/mI38aLcSwJLso/lcqSOsQSsPFsNzggPJpQiGGHCkR+IE8iXaHWBMUUVELXHObASyD77RYQdwcFrCicEZkyVCr+ePYi6x4nCkuO7EBPPmEEYUbQZ6Sp6adgSr/Mkqv0nY4JCyOsEsXi/7ESh7UF7kiQaTCGICA4gFUYJGJEtQxRMaXUMy0fcOMJd4h3ae2Phs7q3SqMKYg6cVdQv64B6ptvflG7jFD6IQcRKmYNJr4LU1PBZC5rzZkHWaDSjdMzyY1btKqkubdQdlctVPEAy9Ryriw3FnmpuzmFPnHSBKWViGsuLQTjAK5HwsBw8/eqVZ1/NTq3W9/aekcACkVQ9yAp0HeJsLpqF9+kqNtOcyZQZh41imuMxRKcINEq4jMToCBRTDl0qxGkRVAddgKjbJQwwO4FGmgJn1mqcbguGIcUReNkTukUSakC2EJptVm812GjoFnQg/7PVMK3IgZgcYkCVeM2muIrm3SBoCR0taQddAKJhnojvOIsFgpeAB7wAzFf8B7QmUQWxCUxzCkVqNvBElcYHbHkIqR7QD0dFSgyO50xbvByfm2dCWhErZpr9rs97cGaJ45ZGdIBitUolvj8YQYbi2DFgEyWUuglxFUGXQK8lzRBDBIlIJpNxw0egGJoWTTjp1OwCTdFWiKISAm66meJxcM71kNJInORS66VeVLr1LMiz9NdlO4v8IsGCFyJX/MYyA1GQxsQaYwLQogimJGxRj0Cb+I7ICd9CUWGj6IwF14GwCK47s4pAoZ+ZWBQogjlzOaj5Ej4pD6DrMMVA7EesMgqQqIv9gVjhCotAoMtTxhTh+QgEK7lLlSoP3AREFT2DfuMFga8Y+k2vh/eDmij8XDjFlGwwSZwgCCM8o7SYMFJ1adkBvgWxT+rYGecUm4/jj8chg5CRgBqIa81ww4icAY4cx6FSX0vuRRLmEm2D3FHMRZcvCTDw6LSAk8DKoFQGhY505SFOYq8LNSOHo+cCCkk2hXRRQb0tlglVj3HCtRmAkNC9kJ75hoLJArQiM4WzjWEFHGXv57BFCIlNweuFHovzRwbJozZecYAaUq9UBaIBKeTcefQmsScLzRLwrWEwgp9EzI13wSuWcAQZLi18KtRXkGKjg0qE0WMZsNooEKfMjLCljPFkWC/PEcyRYWaszCOIeKnqQBshBmNfAQ6TVev6Q3oM4NQTqkAMw1U2wX4YNv0nCBqxkpR6kbif2RQqvwjHsN2RnCxLQ3/AYMEBacTOTsBEWdL+m6bkAFCS57ZKqAnslBhogEUsGOCHPAuCHUqQ2I7tQjQjXM0YhYL9o6ccHBtAPUwIHiKuISCF8KLB5zFLqjYIRh5WhWPL4rDoB06lnLtsnpwM6eWXrosqwVcBNWOJZO+jw5FnEt8SCct5xqhpmiHSF50SLToscX41k8H7SQYDkAobym9MIaeJNVucdDbvtAV1o5V4qrdLS3mkQPJAisAhEElYH/AL+C9IxrsH+2IsIYpIGINfpw1wSfH+pbUsqkVwfOJP8dRthwIO5AUEZL62gEohxQpsiKCCsYWCD8lJvuhAenw6ZhX3hPy741ZonT4ds+hAOrTYI9gEcsrp3kdaH/0mOK0QU/H+tHwC41n4gBXOHIR8nfRaZbtZriKe2F5YJ2zMlC4yUcQpL6SDyg3Ym1NQQvLLvD6pWIbGjE+g1FOaQk5HdLc2iemZpgxHAb1LyM4i70gjrF/2PNRVRfIX2DM5ZALTxDjlFz4czrAkXkW5S2qXfc/R6zAkpc3GBCumB4MRxpdNDe4P/SkoksPDo50b27Rsruj1sDDNWp1owarWJ+P0iIaPJO1jQo0AUJNaVSqzJ+EYDAq9jxmHACtbPM3o8cnUoMeobMGxAyHH+2YBMCytdguKiJpoTm5I1RrECHZ7pFbsKhOXoYN9OvUH1M3ClVfHCmd0TkeRJgGQQf0MCQpgUQt7ABjBSRs4umFCmyrwHFpI59LjS7J+Q/KFs0MIWDnWFfkltUInMFQCj3Pp5shZxq0qGRRZVNENCsmfSE0GoeBriK6cmiHIkk7nTck7oXN1rVapoMOpARpoYyGlQUEJYodkTg9TIpC66He0PwYKjBQ7gKbDWRPUEW2ZcloClk0SU3jiAogDvAC5oEQwnTghxP2IERW+8SSMSLbhydN8k50DnhTSnlMKtfA7bYGRUWWssXDP0KySixWtTkUYybSKiymEnoYbyvmbWHOwf0IQsRy4eDyEV8QOS5RHgC7WBAeOuIFSDirLaF8KbsTZoh4bVS5DrDHKoqpBMCDw4Dlix8S14z2ZIHQ0z+YyvDkB2dEFkvbEJ8bzhqGDl+xOJhMcOUI52JooaLAFTu/g/ugoEVDBuUltUM8jZA7iDCZNTCbBEJkDkx4xkKB0/GRcbzw+0BRxioA9+LBaLLWb73rwjTgCAEomGIZsHz9A3ISnjhspWLNgSVRmYyfFTNEhBtwqp+yNSSesF64c1vjmQmATue2gv2fYeCg4UWPHK4eDATsL7oNUZHA+g1S4VIlEmHpq+QhMkN8wlqCM7k5kcicdv9po4kShfEnPjsSqQIm1iabBqpEHgkHO7qVBLe0iEQnkxpVi1T4JeX6Kv6FlnKqNqQHqAe8HNQOzwsfBmaZ8kcOtM04fxmhx/hwgKRIldbUifiw0B+OQY2n2aboEq5mYQ9FQ6wyKyMh2KESXo39p19/t9AlGR0G/0pCCd1w/OaLNc2eQn1FyypwoiKZA4Flv+LykZKCWMQpYiXKIDV4Fm4Jmq52DG5tb4CiC+9Hak7QJy0lwhLJgr4sjLDEaqW3hB1IfGc1qj8DsyWRhOQgp2SJ8Ht4y3VIIDVlhPngUHXqVqldtMqFi/VCnaBIwS7tCyg9QCkQSGcDNZWqoda1V5Nxdp9Ab5TobnX7DlgkrBE/PbFZauuaWrTqCSwwPng7LDIUDlkGgAB0DujjHe4HdWyj0XE+DDFsF7ZJKCSgLSCt+d6alFJ5gelhCtD3WkgGCf7ApIZhg9mR54qRWnQPTwByePHEShB09jNeDS3STPweEAhjXH/YlbYpYRGkZLiLN/xLOZ6Cj5Jg1BI3Fng2O+vImfr7eWrz92C11jmeFXiW8PcknNpYrqI1aCYjIwG6ojSrlO1ITIRAKewRfQlMo4EW94J6zxxEZ1AIZKzw5cj2D0bhe5XSQGbVkhmDgGnA+DBgMLQ+kNCMJ3ayOOoZQhVGSs/5IhRExcWIR4Rf7UnxojjatoK45+JfuHOTWPAXYh4hmwD3wLEG6QDXYtMD69IaTvUD3JtQp6XX6LBUwGCm+TMX9QC1qTpEAFpEWFOYKKWRqj0BmcFlE+QhOkCIroipp55jHDbc6mIxJUJGKosyEChyAqJbdxGElvpUO8vs5Qa+/s2cm4iDClwc57HU7VkTswFnaUdEWNvfcUsPfASgjLEoXOa0+dXr5gRJpq/NzZPiLokf/rd60D6Lf5ITuoUrjRHwnvxvUm63RZEBe4eiwMze/gL8MVkAXw9fyvSgZBsN7Y0AEASZpDtJE0RVtTTgVoVTGZoj/JvCDpGTRq6wBekjwAw5mpLUM7GzwYw5cUVwd4o8kDcS7gNgkChM3DemGl1dtYErIOAJRYQDJINFvh8fBfCCNwXoTB+DcgGfI5oOBAaYvHGnoUYLg831xX9CLbL0SMS1aAH6+oIISavGnZEf5X0wOup6okNUA4WAzCqqa5j6hVsxq4uoVQThOafYbjrkG9UFLajJZaB5iDo8WKJw3M3WysjVAXKnSJX1i0BqTyk9Y8gQeRgSlH5mnSsek01EggibnKInjykzOIiGPDQhKw9CI2xBulAfgApgYHxdeG5DsNAPpATCMgC8G/SHKF6+eQNlFvdG0K1FBMcH3+QCIB2E6vQ9IGKEZ2X0kJ8FHkPpqqW6iTWBRJHF7oU01Emd3ZJMIkwu9CebuLI8mcwqZk1kDJUP2CT0IZAj66GU7Q01dTJrUJ5E8YP+CdHKN1DlKyhSvAjvHCgWThElXLbXeqPJKMGKYeqmUdixqFYYjuJhKt9Njd6BYUDXsPkBTP+gTCACUNKtlFFS5aqMcQieRDG3JYxPRfL1kGzigNLKDebjT2S01OZGDTGTBwZMNzxuzcKN43Ilcti56h8RH2ZwkPi0yKZwL87hH6wcYMdI/FTGWYhPcFWHlGJyMVsNQo1sAXqF8S5ZCmgcCGnK+p2bgVxJ0Y83YjJhpYhvA6zwqmFnMZjbhkKgyvael/bjQhRwNv4meMjhoU2q4g1F/KLIckm/GpdTkLBAScSyOYYQjDt5oAIRBDEUiaObJ+XLSWpGMKgAIvemDpNuleVpa0GMJJkJ/XLVrmFZYwhQ9kwjjnKheTw54B5DGZUL0YbJgzuJBtLqwjoigaghShZCRpWWtRpIUWAEbTRt/idcNLYQ/gqDYIF4q3WhBX0bKZJBOEppwTKck9+tGhZRQzfG2t7sTSo6nFKRMvao3gZ8EmEoIDURDR5Uxkg6DSIgjCC3VxgA4kuSmFpZ6Y8rFFYcDXUHbA58pZleYcBGRM5ij8B8IMPEQCWtKZY+tDXm5wEYRhePP1auNucWlklMBRakU7Yq+kGcAjxz9HFN8C7fQRHQyqTvUc05L6qEE0Dwx6oEGcCFwFKdiBvgWEN9YMKJ8HF4iCerrPbtEbEW4hXON5YT/il4C4ZICFEm1M3eJV64SeIMI4gmw9QLuGZGjYamNIZU5nKnllVER4uIxtWPal3g2R/ASHxPMTH2eSOtMnxo8o4SDaddljgSXqFRB0QKAQZICICbgD1C76G046uKXcVYNYgeERa9VmpaQiwO3squwHej0GRNz4C/gjCCUnOyFMhPhrdOpS3QTHi0EQdyDAc6bUUUZkLnEUqLKaLkA+sBhueR2OeStVecsTGc46IL2cDIo2jgYheQpMS+CMyLtHP4m9UoyH4QbQsw1gAiRdEYsuV22OJA0wowqwOFwcXcrWknUASpUQF2ySsIgQu3iJCDp3Af9jp0gQytTIwUNbD12Jo4voZ3UGmIjMTkzWizXS7Ya8QQSZ5BsU37CSmCGECUJyInjpVKN3NQE5540hCfd3LFdsDJp28uOF0qvHL7MNNGWhnAMZIgFIzqY0b8YpkFKFPWYpaQUuL845dBb4xDyIbocDW2WXHBWlB3BJpA704GZp7wDS8PcHVteQZyhCZAYwHhj5/iCvCbFmhMYPdh/Ic5QPM8sSVEFYk7gxCSBvwCooEUJxUnVkWVDAso4uRxIAApZLdMgQFBcOox5NI4LIQm7Zq3QK7RKoTMGEAKF3FgketqK3SV0I6EobQ0AeQuaYBeRz8vj/pPJBUiimSUQgeYaNMxooE+wH5wkhkfBLqZEB59KNCKLhNUkn+A57WabmIuBIuwz885GE1SKUjpS25JmgadFuRNOkoF2rrtkw9n08Ig9xFWDW4TGY3bRuNwh5MjM0S4pFkq+/MEhn2UqcUNZBRw9jAE4Jd1MOHmNHTzo+XJnJpGGU0gvvnYc2GViI8WfDjmuF/x8MO5V8RwddyiJGlJ1LtIFhxwwBqNJLzzN4+i2sHDB0ZAdDekGTLp+sMnyCusHHSMEHFJFUG4k2gACIM6KMVSdATrRRQyREhbHrdh0fIJ0BC7DjE98yER4qy6Ciu6n3Bm/OA4m0NMGfbo80+ZZ5zRzvALwk6pTkr760p2A4h6LYyPwJQgimxVOtltdnl9tVpq8iziMKEeSLexrihTgIZa8YTBMjJTh478QJbFB0DwoD2H4aFLvQHiJ/A57AZuIQB18pN5qAvQL9wQ0yR/Cx8H24uXSz6nuNQ3VoXuqT00kwAZiSMQQF2UOEDHa4AWIEBlS2pjhHNNQsllekACcUoRGWRg+tC2izwRRKwlbw4o4NOf4Mepe/aMBdpmoCMAUPYW8S5SI5fGDeqk8165HVC8LnwHnVaCd5fkVDF7IYgBp8CyEV1xFwYxZPA6GQPtA5/7/AMhuNW5NsYtBAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 4/12 [04:35<08:48, 66.08s/it, test/blurry_cossim=0, test/loss=1.19, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=4, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.404, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=3.81e-5, train/num_steps=608]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n", + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3kUuKQUtO5NhaXFJS0XCwYpcUlLmi47CYFFFFFwsJRS0lFwsJRilpKLhYSkxS0UXCwlIaWkPSi4rCg0uaaDS5qLmthwNFJmjNFwsOzRmkzS5oFYKKKTNAWFpKM0ZoHYKQmgmm5ouFhaSkzRmi4WFzTSaQtTS1K4cou4etLuFVw9Lv96i5tyFkMKXNVd+Kdvp3FyFjNLuqtvNKHouLlLG6jNQb6PMp3Fyk+aTNQeZRvzSuPlJS1N3VCXNJvpXK5CYsKQtUO+kL0XHykxamlqhMnvTTIPWi4+QpWOp2upWcd3Z3Ec9vKMpJG25WHTg1Z80V86eGPF+u+B/EEOk635kdlJKDNFOd2xW48xG54B5OMg4I69PdjeLu2g5Y9OKiSaN4JTNfzh60vnD1rMMwHelE3vU3K9maXne9Hne9Z3ne9KZwCAT16e9O4eyNDzvejzves/zvekM/vRcPZmh5oo80Vn+f70nne9Fw9maBm96b5tUfO96TzvegPZl4y00y1SM3vTTN70D5C6ZaaZeKpGb3ppm96A5Dyz4qeH11LQP7Vh3fadP52qmS8ZIBz/u/e9Mbqq/DHxjFcaV/ZeoOi3NioNsWb5pIucoPUqAfwxx8pNdvdpHd2k1rPtaGeNo3XJG5WGDz+NfO2pWN14Z194VfbLbSB4ZQM7gCCrAH+XPQjtXRyXVmY1J8k1NH07HeebueMrg4xnn8P8+op322T5sRg7euD+PSvJfCnxOa6mjsdSiiSZvuzKcCRuy4PQngA5xn0rtItbll+cA4IB2kbfzyOfyFR7Jm8a0JLQ6s3RxyrD8v8apjUknnEiyEovUYwQDnnBwe361hLrsUlwke7JbIzg9QASOnofXtXP6jei8mRIgArSAoykgHOPmyOn8Jyc5IwMYOH7Fh7WKO/m1VPsbypIeh2Mq5zxwfbOe9WUupHP3QB7151YXtrPc7Z5HMWCEEiMflGDty3QHJJBHYY9a3bXWxNcSRSzIg6oGx0yAeQfUj8xR7Jh7SJ1YnPcijzzWOl+pyxZRGBy+eP8ioJ/EGn21zDBPcpG824LuOBkckH04z19KXsmP2iN7zzR59c5ca7Gslq1vLDLBIwDtu9QCMfgd3Tp6Vet9RtrpN8EyOD6H2B/qKfsmHtIljVdZt9H0u41G7crBAm5sDJPYAe5JA/GnWeqWuo2qXVncRTwOMq8Thh9MjuO4rifGGg33inULaze7FtpEKCSQpy8shJGMZwMKBgnu3Q9uO1E6l8L9Xjn0mSS50a7KmSKcA5ZcgqWA4ODkEAfRtpp+xdrmUq9pbaHtpmNNM3HWua0TxZpviC3EtjcKzfxRNw6fVa1ftHFL2RXtkzkY75CkjG5eSVDuVAQ3U57Yyc56YxwPc8P4y06KWwkvSGJtwqRMpwCC2MEH69un4mo768eG9Ie58llYgFkyNpPX8Pm6+uD0rL8VazLfwwwrKrW4dn2qRyexOPbP4k11y0R5XtHLRnLA9q9C0Xx7HJZva6szRuSCZ0zhznOTgHB4HTg9OMV55nBHFAODzWSdioya2PVrq8a9eK6iuY5MgsGQ4O0qVIHOOu0ZHem3N6kt6CjosVu6JGyk4DNjP4AkfTJ5GOPNre6227wNgpywB7HA/ngCpoNTdZXLEDzAwc4GPm6444zwKvmQ3Nnot3q0dxFDdxxyW/lTLjaRhWOB1HQAnPXBwPWoTqcEgAeVoCDJEUDBwwJOWyRkHO38APw4Ya1OIDul3sWJILHnn16/qOlMg1CQl2djgnoDj/PT9KfNElzkeky+K5dP06MybXmlEgEq4O1skAAYxjO0d+DXC3Ou3ckEUVyfPHzOrMcFMkhhx2PPXNI/iOULJhELuQ284O08D09FUf41ivJu27iO/PfrSk10BykzUttXuVubOUyOHt5CyBeecADg564A+g71v6Tr0yXUeZ2SMzgJvfJUZB3fhtHp6Dpg8QX5HHapIpnV1w5UDPX361KYrs9n1HxLGdIkhzh5Ynj+XB2ZB2HjrngDHrj6VtQudO1PwqU1K5CoQJHzJjlmOD746gew7ZryiTUrtTjzGXCFMY/hPbH41Wa4kbduYsGxknrVc5fOybUbMWF40SSGSMgNHJt271PQ4r07wz4/gudNEOq3yQ30eRvlUbZB68AAHtjPPXvgeVSTtIiB+Qq7R9M5/rUTDPIGATxUJ2EpNbExvLh3DPKzEdNxz6f4CkkuZZU2u5ZewPb6VBTgBg5P0pXZNhKDRQetIYZ4xSU44+X9aUBTGx7igBtLuPHPSgDK54pKAFJ9qOqg+lKVwSDx3pOBxn9KAAHg0AkAgd+tGflPIozxnv70CA9euaTtQDSUDFzmjtQDjtQSKAAnJzSjOMgdKQEil5H40AIODQc8UoGTQBQAh5xR2NGKU5xk0AIOeKVQOSaSlxzQAmaM+1GDRQAZoPWiigBKKdgkdKTGaACkpwUkHHakYEHkYoA//2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 33%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 4/12 [05:38<08:48, 66.08s/it, test/blurry_cossim=0, test/loss=1.13, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=5, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.396, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=5.21e-5, train/num_steps=760]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 5/12 [05:38<07:34, 64.87s/it, test/blurry_cossim=0, test/loss=1.13, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=5, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.396, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=5.21e-5, train/num_steps=760]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCxZXlndLuimimLkL+6mDBSezD19q1IUcbVChugJP3sE4zj2/TI9K8Ou7fU9CaOeVRbTA7oysyhwfUAHP6VvaJ8Ur2zZItSt4rqLhS6qEYLuy2R0bjgDgVuqv8ANoZOnbY9Uk8tVSTy5HiGVwpCkH0J78n9KWOfzrnDpKBtwPkzz7mqGm69o+qQyz2V2tyg2hlQkFBnB+VhkZPTIGccE09ppHmdYi7xhc7l7HJ4xnsBmrUrO6M5LozV8unBKjtZN2VMcoBPV8/5x0o1C8WweAPjErqmTwBlgCc/Q1t7RJXZz+zd7Emyl2VZ8ujZT5xcpW8ujy/arOyl2Ucw+Uq+XR5dWtlGylzBylXy/ak8v2q35dIY6fMFiqY/amGP2q55dGyjmQrHyxcXMtzO000jSSOcs7nJJ+tQk8D0qaW3ePBYfKwyCDkGo0RnKKuMscDJAH5ngV5qR6kh1vczWk8c9vK0csZ3I6nBU+1dlpfjPXLm/eZtVaFo4ndQwHlsQpIXbjaS2Ao75IrjrO0kvbyK2ixvkbALdAO5PsBk16BYeDtPs7vEmqFm5A8y3wCCMdA3v1zW1OjOp8KMpSS3PXfCDXPiLw/Dql2kMTO58oRoQMDg9Se+R7Y71zvjWSNtcsIklAZFJcFSpHzEA8/Qn/6xBrAk8R+JvA/lGxuI73RzlmR0DIjHjHBJQE8jDYyffFWbzxDD40j+0aYY7PVB5ccdnLIreY5dhgFwAeNhyMEHOeKyrRqQXJIcYqT5ono6uHUMMcjPBqvqN9FpmnXF9PnyoI2kbHUgDOBXl19DrWm6Xe3+oTiO93qtxGfLZZFICoAU6YDkkKcdiK2I/GVtq8MOj3FqtvFf2zpcTRsB5Y2ybsDHXCjA6/N376c7tcj2aua3hHxtH4lmuYJooradGBjQSbt4OeOnUf16V1cckc0YkikWRD0ZWyPTrXzNbhoriIxgSt1dTwF69D34r2zwnbrqmjTXV9ab4YhvTymwHlOAoxgncSFPHHr6Vn7aSNpUIbo67IPTms6TxDpMN21s94vnKcMqqzYPpkCsfUNY0ebw74nvxDEYZrARW0jgZOXnjRlU8jJUcdtoJrxm01OS2TKBWZc8noB/WtOdnPOm/sn0NHq+mTD5L+3yBuIMgBA9welP+32RIAuoSSCww4PA6muMs/hjqPiDw+NYaOKd3Xy47UNsLqC2XDEgdScZ478jg8ro3g63svEVrDr+m3FqrhkQXcDrG0hBCljkfIGxkjtx70e0ZSpK2p3PjDxBbQeHrqOyv0F66qIhE/zH5lzgjpwTWZ4X8SOFtobi5DxvhXaRtzB8ZH55q2+s+FL7S9O8RalbfYVs7mWwt9PiBJkiZVD7yAM4V2Y/wkMVwSc157o9zczThYkWS7nuGdLaFmjRHUZBUKQCCWYBQM/KACM0nN3uP2UbHFW2fOVdgbLAbTnB9q7vS7GDQ9KnvblIv9Ls3I8ofNAd+wrhgTyGAOCCDx7VzNvbq8ghRC0jcKoOMn6mu7XwlqnhO71CzvrfdYXIjhe9Ee8BHbYCQCduCSQM9UXnDAHKE7o3nG2hjaze6VdeJLZNKsYoIgXCsse1yvlDlsAckluvPHbnMMOpvcafBM2MqSjn3yMn9a53Ry39t25Yk/eGT1+6a0dMj8x7uybgeawB9DyB/IV6WG+GxzzOiikF9pt7YEeYzKVQE8fdDA8Y74/Kq+i6zYaXpdpfyqr3Ftco8UCMU37DnGQcr064PPY1k293eaTC9wbcOF+WQNx8ueDnp/ER+ApddvtR1KwsQ1i8VjGsjwn5mGMgNz04wPT3rPGqEuVyeqNcPXqUlKMNpKzJ/FniP+19ZvJbSSL7DPLGQkYJAKoF+8yqxzjPIH6VlPJb7k+0TSQFk+VipYDk84A9aistPlbRLy/O4RxuoB6ZOcH/ANCrSSeQ+CNT4UrJJGhJzkAMp457kL27VyPawlvcx9Mu9us20zu8gE6kknDMN1e2P4l0jRfB+p6VBL5NwNsttDGCDv4IYHGAAwHHsa8N0qIvexSYJEbBsAV61D4iuIPD8+l2rQCVnIjMrgGQuBkAHjgc556jgZBrCpZSTN4axaOWXwx4k1rT4vIhint7NCmWuIo9gyWKtuYYwWY8+tcxo1r/AGtrNnZl2RJ5F8yQJnYnV2A77VBOO+K9Q0XStRtbHy7zRZ5Fz5isl1DyeuVAUknp37cVSsdEWz1SC8t7N1tXh4laTcrSYCFV56AD3PXJ6Zft48yj3IVNpXPbtIl0jwvpWmabay7bHYz27PIxyAQ0jO3f7zN9QRiuju7Ww1zS5LW5SO6srqPDKTlXU/SvHvE5ewlsbAKyPbWqpjr878kf+PYrv9Bvvsy2Fg5CpbR7HboDkY/n/Otb62Jtpc8M+LnhOTwhf2Vta+a+kzGSeCRyCVkIQOhI9NinOP4vY1yGiXVzaXa38B2NZA3IcjgFAWAPbkrgeucV9T+PNFTxT4C1SzRGklMTTW4jALGRPmUD6kY+jGvnnwHpK3us/Z72E/ZZ45IJQxKZBQhgDjqFYn8jx1ptgjj9Oaaa/hSJd0hYBPrnj9a9Sttf8YT6/q1vqVtELW9j8idJWGY4vnCKm1gSfnySATjBxXmOiTbL2x5AXzlYtjk4Pf6V22q6q2uII7azurm9s9qM8UZbKM3y7gBnqfb6nOBVPD0+RucrM5q9et7SKpxutRbSa103Qp9KubKK0l8zKtNwySFlZiCx4yqhcKccDnJ55qysrxr+W5hjV45XMkREqEuAx5AzkjrnHTB9DXTRwy6U7abfQG21OPY0aCSEF1LKflUHGSvQNuKkZ4AwN6ytJLl3lEU07BlZI5pEIBDNkA8AHaEIJxz0OQccjx7w10tdbnVQwtWvY5s2EMrtDdXKwrNhSpDEdM8EfLjHr1z36Vc1DUrqG/WIhp0bHnK8IVFOTwQBlTwcgnjaMd67Kw0+3EUs/wDZ726HPniLevzZ+XgAljjnI9fXgNvdNgR4RBo8c7SbCTO4Xvx9cenB471xVsfGvLmq3fbY7VllaN4xaOKu01CPTdRt7DTbm4F3uIeKBnOCNp4C/LwB1HrXNyW7weGNQsWjKyoVlk3FSQDsIxg98fh3r068jvzrN20Fsbg2kmVL/L5rOvQZPzcsRyevpWR4ptbSfSLhjIRdSkOQ80ckkhBA2MUwMgZAwOdufU1pTxqdRRe36kvCONLmb979DzbSVhtdPnlnQOWaPCfxDDZ4+oDCuyivdO2rBe6TBNetIyC4WRjHH0YHarENlmIwCuNuMjqOeRIbi9a13sFcjDbcHJwD69MdM9q6KLVJvCbC0tBaKSp3u8fmSFySrFXxkLwMAEck8Guqcbu5zp2R0DacuoWq/Z/C4WeSIlB9vRWWReuQ654JU9e/J5q/DPcapq1rZXdubKYTKotGYsY1J65J5BO4jHHYdKyL3ULrX7a6nvbCwtibZkimlf54QMlWMg6Y4OOOnNeV3F5cwpPbGSIbgqSeVtIYKMDDL144yDzRFWdxtnu3xCupLLxtGwHOI2UkcDaoP48gfnVqx8QxvfQW1lbhyzqBJMMsDx0HTtXiPhVMSyyYwF4/P/8AVXpfhV3OtWLbdxFwgVfX5hVXdylFcup9CAADA6DtXg3jSxTwZ4ohtYJfs+lzIssOEwEBYKy7sHJHJyQSAV4Pf2i3vPMmbOVyw4PpXDfGzQU1Lwb/AGsis1zpZ3KqjO6NyquMfgpz6Ka0auZQnyO9rnzDbpNp1/5cvyyRP82CCARzx2Ne2wa9a2EBv4GmuJERFilih3eYHbOwjBAJ3ZBJAxwPugVwd54RtnuI5YbrYW/1i43AfTv6dTXQ2enw29nFp8khlEG4HIGVBPQA8d+v/wCquSvVuly6s78Pgpcz59EWJtSfX1a6+xF53YuUE21mk24+b94piBWNRjZzjOR1rTsNLurq5nu5b/NqjcQTKsgXB670bYpIIyBnt6VV0mCJZY9kEVuyElFA3OTyOpKrnAGAQe3NdHcedawusM88jIhcovliLd1+Zto2/iwryajd9Ueuo8qSiJHKjQRLaTRSW6Mxl+zgPhevOFfJ64GQTUMl00d/Ba6fppuxwUf7SR5R7kocngdyfQelMtlhnk+2Rnzt7sVuSShBGfl8tQDnOcg/zqSbEkE129+VmMMhMqrlwYywX5QQeuBgDqpz3rFA+5pJJchYJL1Yo2iYh5FBOcYxjPrnHrx71PbG7khC3dy/lyFdrMmx1weCSpHJ46emMVjafdJDPJZXsMqsJSWe4cZAYZBA75JAwPqTV11uFF5JARFcqDEFVFBb5cqOM7Qc9M988UXaJaTPLfHGiLpusi5tlkjtrgbo0eXeyYAU87iSMg46fpxzuqeIJZ7NoJEYO4XcflwcNnJ4znoOp6fn7LLBpup6SjamsPmMXV5Qkb4AzglgDgnA54xms7xb8KdJt/CNy+i2M0+q+cohklucELnLdSFxtB68162Er80bS6Hl4ujyyuup5ZDfyanbRaezgRSPmT6evvjrjjp1FUr3Slt4nvImD2yEBVL7yTxkFgAOM+1UJbS5sp3trmGWCZfvRyKVYd+h9q0dH80yPFyEIDMCO/au+KUtjgcuXc19Fv8A7XHO8kKrcFgXlXgSccfL0BHcjrx6ZPTadq0djdRFDvmVwwQdc59e1cqlw1uWJjbI5rR0TNzqKSFgxHJJ6d+T6AVp7NJjdZyV3ueoDx9rL3Jxotv5y4O0X65PA6Ar1x2qt42+IOr3/hK70xNMS0mnXy5maUSFYznPBUAEgH1wDkY4IteGbT7RFNGAziXdkuOSCOpHv6egFcf4ibV9O1W41f7GY47pVeLdFvQIBsUn0IAB+uM9appIxGG5sLCxguIp3kudzDPTGOhIx7/pVvSpU1WZlmlRY2bMlw/3sD/P6VwMOt2tyGE0irnkBuMUyz1g29y8cchkSQ4yBntj+tcDg9j3/axaTTPSGvoiyiIbkyRuBx/n9K0bPbcwf6RHJK0LLGgYEbNx6jnBPOTkHjFeVWXiC6i1NPLLTMzgKm3knpXpWky3vnwst8LdDJ5ktu0QZuOCA2cDIUc4PfFcuJh7mp0UpqWqLkcFruvog5tG+0+XbSGRTsYqEDYPPLH/APVxUiaTpgg0yzLRtFbh2h2N8pBPzM3U9+MnnmudkuvEjW8skGnrMbe7Z4XeMpKg8wOMK2MjKg4xnA966KHVDCzPeqyWtyFJjmHFqwBGCD0U9cnjrjrXC4NK473di1eXE9vGk9vOXx8v2dlDb+QF+bsSSMZ/2vpTpNXtxJE0yloY8CG6iRhtDDgjqDwTnHoeM1QlvXRGh1Bre1lhcfZ0SQFZGJyCSQPlzg+x46ii2Wz0exuFs55EaBlLmR1jChiOQWG3/wDUM4BFQotj0IJHl2xMt/b27xrIrxuNmTng89sEkcN1HpWtcarqMVmbBsFY4WdRKzPEQqkqXfHA9ckYweDise48U6WjXccl0WV3DRptBUcDPzKCODz/ACrntQ8YwNvKKJULl0tpYtsanOOdpG4Hr6dsd66aVCtfRMxq16Fvea0O30vVIdXsInuUltUKAS23kiZWB74Veh9wv9a4XXPD+gaTzpGsR+bIxBhdvNUjIxjaNy4yfvZz+HNNteu9asbpdSkkcYVbcDAWP5gx4A5yARk9s1oaJos2pzppej+bIbkATTrH8sIzncW9OvHGcYHODXo0MLKm+bmt6HlV8TGouVROQm3yTmFLlRKG2hXiwM+mRmtHw+shuJY3jGCQrdueuPxOKs/2fZ2EE+n30/2KVJwHjkPLHdzyEyvyheM/lmrXh2KJPEBjs7qK6h3ja/lsA4wOAAQcjOOO/Y16C7nD5Hd2uqHRtDk1WbezrIjSKg5VNwHv1z/nFVdd+IHhi68N/wBmr5kxWHZFHGjgI20gAs2DhePXOKrfEXWrSz0q/wBBtVnlv5RCXCIAsG0q+Rxk5UD169eMV5DJqFxOSC4aRwASQMt2pT3GkdDrHhvT3v45YQI0JzJGnAP09K1dPisLW2G1lXb0XFRx6kJRcXKkHc2xeP4QOn55p9jbQz6dKzDDIWIIHPT/AD1rznKT3PpIxhDWK3LlpYQXGorqQhBuEBUPz05Hbg/WqOvanq2mSGWKcrbYxvWLmLnoxxnr0P4VJb3MkcSxJlTn5Rzz/jzxTdV1N/7MuFkjP79TGNw4GQR1x160o6ytuKtBRpuV7HKyavvk8yW5Exx0lDNn2Oe1RjV5gS4aMN67cVWexAj8xZgRjBBU5B598U3T4YpLwwtA0skg2xqDzuPQfj0+pFdmiPBu29zctvG2qwRxRB7BkiXagktY3wPQFgSKff8AjKfV0Uagls5QYTapAUdwADgdB2NYN1pkYnUxygIyBh8v4dM+1RPpxjGfMyD7UKMFqkglOb0bNN9TgkZjGyxqeioGwv5nP/66T7TDkYRpiSDj7q/l1qnb2qFwvzNnoFFbdrpl2ysYNPuWHU7IWb+lWZNkcF1clGYxqvHyDdgD6+vXvXQ6N4z8Q6Nb/ZoL6JLQBgIEhXqRjdv+9nPPXsO1c95kKsYnO1x95WGCKVnVyNpUgZPH50MDT13Wx4ouTdalK0cgG2NVHyxj8ckjk9/55p3gWQWVytzcusMEUxaSR/uqAFyMdec44/AZrn5l2scYIPNSXeqTTWrQkIke7eQgwGO0DJ/I/iauAmLrOsJ4h8RTX93P9iguLgFpApk8lPujgYJwAOnXFUtS+xC7iC6mbxNufN+zbD9Mk5z+dY8kmYWXORioYpjH8pGUPUUOw0el/wBk3FvpSzMu1JDkbiFbP069qpzXrpb+REBEMY8xjz+HYdf/ANXFWli1DVFe5uNSggSMY8iKHCqvbqcjPBzgkgg9K0NG0CxmvFZBJO8fIeQ4OeMcHjqfSvNZ9KtrkGk2cP2UXkt159yRwjcDGeOv+eaTWo5X0Uw28a+YzCNI1A5yR2x9T7YzWxJJDLeLapGEQcM5GTn/ACPWqWoQQrqMIWUkRAsg/Ajn9aS3uVUtyOPc5uPwzdTWJZpgLhQSIsDB9BnPWrPgLwrLr/iVTJMLa3s3WS4ckBwecKoPclT24/IHqoomltOT985xjrzWx8N9LsNQTXLyW6kt5obxt20gFVwMMTjpnPeuiE3LQ8fE0I00mtCx/wAIfp0Qgh0uwQBpABNcQrM0UY53MWbHXPCgk8A4rtYfCmg3WnrDc6PZSRrkIWt1J598defao7Hw9/awNxLqN5JZjIg3naWH97HHG7P1A9639O8N6XaYkjiaRgxKvI2ccY+hrRN9EefKnrfmM7w94I0fQkYW2mWyEEhZxEPMKnqM9e571o/2NaMnnpKyZ5Utz+NaibbeJIlXA6YzmqT3Ci5ZZOEQgIc9Mjp9eap2Eqa6jG02VrYxZSWNhgpKvyn8Dn9a5q/+HHhvUWL3Ogx28zKVEtmTFtP97ap25+oNdpazNLuO35QcAg/0qdmHHzAfWheQcltjwfV/gvcCJ/7I1i3nKklYrhfLb2GRkE/gK4y9+GPja0QO2gNIoyD5c0bkehCq2T1PGK+qNwOVI4+vWnAAjAwR9apNjsfCf2fBlEkiRMn8Dhsk+nA/niqzLn617D8aPDul2PjK7u/7QW3ubyJLkW7RMVb+EncBxkox57mvJHQqcHGcdiD/ACpjsf/Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 42%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 5/12 [06:40<07:34, 64.87s/it, test/blurry_cossim=0, test/loss=1.17, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=6, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.389, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=6.86e-5, train/num_steps=912]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 6/12 [06:40<06:24, 64.12s/it, test/blurry_cossim=0, test/loss=1.17, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=6, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.389, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=6.86e-5, train/num_steps=912]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDFubRdK0nU9C0K2ksLYStFNIX3zXOACGd8DqD91QAM9Mkk+ZxeFNZuL0WtvZvK5PBUjGPUnsK+kvElpYKC7sqSOM7QRlz0/PpXjHxH0XxXopRb+28rSblFkU2r+ZExHZ2wOQT0OB0x6187lOPr4xynFWT7/p3NJYmjWfLBfCXNH8P6b4H1DSbrX7qJ5tQeRY2jcNHBsA5Yg9ywHoOSelW/Hd4kyeVGQcis/wCHVj4V1jwjr1v4kAM1l++sD5zIVeRCGIAIDf6tOuenvXH6dJ5l9bWQJETzohx2UsM/pXrSpTSu3d9T0cDXpwu57F7QtEi1XW7WO7n8i2D5lfvt9vevoLW/GttpHgi5s/Dd5bRX8Nvi1Zx5m0j2PBJGcZ4yRniuL0f4daDr8c0X2+axuSh8mRXDKGwcbgeo9sj615PcaL4hs9Ueyms7kyxvtYopZT7hhwR75rn+sV60FGFblgm3ay1el73OTEvD1aiqUlrse0fC3X7ZfD15e+IPHVtK17kmzupl82FhkFuTuOQBwBiuG17x35d3LBC0cihiAyEkNz1HHSrOneDdIhthJr+tJp0kgyscdtJcMfrsyF/E59q8wmljk1AycmLfx/u5/wAKrDpVJOS2/r+tl3OZ0Ywa1PZvB17Fo8v/AAlGsxMLOzR5SAOrBSFUZ7ltoHuRXlPivX5PE/ia+1mWMRtdSF/LBzsHQDPfAAFfUF/oGh+L/h3caXp1/ClrdQr5dzE4YKysGXPtlRkemeleES+EB4I1yGz1uayuLmeETQvA5dANzAjJA54/lVZPWc6bhOyc2n3stNH533R10KMMXiY0YyUfX+vuHaJqkv8AwiUWmQxlGKsCR1OSas6DoltYahbT3L75RKrE9AvP+fyrM8QeIfsb2y2XlMAG38dao2V5r+uShdN0+a5f0hiLY+uOldWJpVaNV0000nuejjqs41lRpvSCS09Nz0P4hz2Ol6EZJSrTzgpbxEn5zxk8dgDn8h3ryHQ4bi71+xt7aMyTzTrGqgdSxx/Wrur3moa/rca6lIkLQotuCxXEagk9R15LH8fSvSfDN74J8F2EklpfxXmsSoVNwzZ2AjGFA4HWsqlWNGnzSjdvojzKU6kq0ZJ7M6631a30+wZ55RHHGhZyx4AAyTXgPiHVpfEevzXoiK+YQscY5IUDA/xr2Lw/rng6+kuYPEt3bpZyRlSkjkbgQQcbefyrivEdr4J0HWU1Hwdrc95sO4WdxbsyZJOQJPlOMHgYJyOTzXmZFgJRc6ii+Z6fqdWZSpSxMU3p1fqYnha7knvnkvfENtYpGQ3+m+axlJz93arenJOOor27SvEovtLfQdXe2lgKZiljlWRJEJIyrqSrDIIyCcEEdQQOAsvhHb6hPtS+mjXODgA07x14PXwpoWnaVpj3E8oMtw7j7xL7VxwOmEGPx9TXq1atOhiHhvtHjYOdHEQ56L0OQ8W6Nb6d4v8A7P0PfKsiKRHGdx3HOR+XNSjTLvRh5k1pNHIOcuhGKteDdJ1i0uZLz+y7ssMYYwt/hXZXfxRj0xG0/VtGeTcvKOChIP1FZVcTVTdKEbruelVyxzwyrc9r9DzeG+1bVb0WNtP5Qk6u2QAPcgGtG4sP7OhlEvjOye9j6WtvDM5J9CzIqj86oz67DBeyahpti0UEn3UkcNtPvjnFc/C3n3W6ZyWcklj3Jq/q1SP8SHKmk1dau/X0PPhDkg4rR+Rvf8JjqcAMQaGdfWRD/Qite30zRb7S4LG/k+w6vEvlyQzBo3VgSoHzAAkgA4HrXGXVm8EmACynkGrUwubvT7eWYSPI7/Z4ickvtC4H4BlH0xVxpwjH93pc6KdN2afRHolno8fhSzaITl5H+diT09KZ4l8I6jqvw8Pjn7bH5FrOY0g28vEXEZcMD1EmRtI6AnPavPL3UtUmTy7uaXHTDLt/pXY6RqY1fwdY6BPdkxW/mKkOcbd7lj/OubD4R0ZOtWd5dzy8Nl8qWIlWqO8ncwNO07wze2W+/wDElzaXmP8AVtp5dc+m4P09zim+HdV8S7TouhT3JS6fLQQxhsk8Z6EjgVu6h8N5YdPa4tJZJJMgJGQPmJIAH61yt0Nc0cpa3D3tsI87E8xgq5OTjBx1rSjWjUcuWpdvo7aelkn+Z6cpOMktn5G34p+H2teGntluI5rq4nQyyLDA7CJc4G5gMZPPHUAAnqKxNL09X1CGK/P2aJnG6Rlyyj2HTn3ruvDPj6P7CNMvo25OBJ1xn1rWvvAkGqj7WlwwjIySorKpjvq7Uavz/pG9HDVJr2iWht2vw08Kaz4InbSkle/hbJuXmLu+egPRe3YCvMIfAWqTa+mkoNsro7qWHUKpYj68V6D4a1WDwL5qpOXt5R++WRhkgdD7YzXI+NfiAb/Xra60N/K+zjPm4+8x9iO39a7FmrrTX1WOnnsvn6mtSnSdOU5K3bX8P+CegfDzUJ7+ITyt8xY5xUPjzxJpNr4oNrd3SLNDboGXBOM5bBwPQg/jU3glYrTSkdPmw5DHGBnr/WvPfiBo99rHxC1GeCIskoiww9okH9K5cyxNCfEFZwXLFJ6vrqtvLsePhsrq4CEpVLK70S1t9x0fhrXLnXdf2WgVNKh4LkfNK2PfoBXT+LBotvo87ao8fl+WfkJ5b2FeWXPh7W/DXh+TUIp2jRGGRgZGTjP61iaTY6t4v1iKwieS4nlOBnnFdFOvGrFypu6PRpStG3czoZ4TC0UpKpngdeKhaNDKqwMz59q6rXvh/qXhbX20/VI2MYRZElTAEqkduvQ5H4VTe0t7COe6ghbdGgIV2yOoH9a9Ovmvt6UcPOKbirKWvNbte9vwOWlGHteVyKQ03Vb5AIbaWRR6CuisdWPhHw1FZ3tk5vbi4kmWNjtKxlUUN0PUqw/4DWz8PZvEmpxXU1npBuraOQL5qxHarYyV3Zx0wfx965XxbcT6r47lS6TYwkjgKA/dAABA/HJ/GvMrUIVI8s9tz0IVXCftKe+yPQNB8G2/jKGWJpmieRMheMg4yOK43RvCOoaf46i0y9RomjkwT/eFQR+LNV8P+J4LvTnAlgdWCFch/Y/XpXovxQt9Wm8SQ63p9rLHtjV2wm7YcDg/SsoTmqSjLqdGMnVxtey3R3t1oq6Los2oTt/o9pGZ5CR0VPmJ4+leSXPiGH4j+II9KtbVbK0UMzXEpy5AxjgcDn3Nd1F8QrbWPg5r51SRIr1bOa3KqD8zOu1CB7swHtXmPgfw/qMLvc+Q6lyAOOgFefXw9CjB4h/H0v3PnsRzYSusRPWcdl0319dPkczdGLSdduLQpxBMUJ9cHFexrrtrbeCriWGRfMWBioz3xWDouheCvF0N1LdG4GrLNK10UudhVd52sqkEbdu3J5wc9OK57xXJp+lwPZ2F8s6bcAbgTW9aCqqMX8Wlz24Zi46T2bukcTNcXd+7SSvJLj7xxkD8qr7G/umvRvAPxY1nwhpsWh2lpay2z3JlZ5FO9Q2M4we2M816jq/jrWLrwbeahoujfbtTd1gjeCy87ycgkyMADwAOM8ZIzkZB9JSjFqOxycvNHnZxfwb1Y3iavYXDqWIjdV7kfMD/AEpPF8ms6Vqj3elp5qOAT+73cjj+WK5v4W+HW1PxhGsjzi3SJ2mWJynmLtPykg8qTjI79K9x1i2fy2WNTv6e9eNjKaniFKKTto162OyhRduSozw27ufFOsWcv9tXTW9uVwIDCqs478YyB9atfDLWLHwjrc1zdSK1w20Qq3AY88Z7Hmui8RaTKun3MvJkSMtsAyeOefSvI9QtrhZWMoVNoztZwD+WcmuuhG6cI2j6JG+OjhI0OTDu81u73tfy2PoDV/EulfELFpO8NtqcGPsqqxInDfeTJ4DDAI55zgCuJ8TeFrnT9OkJt5nZgOAh6ZFc58LtOs9W8Z20N5KysCHiGepFXfiR4HuvDHjW4kdnmsL2RriG4cctuOWVvcE49xg96yeHSxHNKpqrXVt/68jwMJgZfWIVG7y+6/qaPhT4x3nhDw8uiW+m2k8KOzLISwYbjk5xwa4TVNT8/XpNUIV5pZPOKq2QCcEc1n3FlLAScb07OK2PDHh/U9Ve8ubKznmjtraVmMak4JjYL+v8q9i8KmiVrnpWrRm48vvb/d+Bb8H+ILvT/Fkep29pDJeg/u3KFvKyCDgHjJB6nPtXtOoeMfEN1o08F3KIxPGUKGJVJBGD2zXz9o/iDVPD87PYXBiLH51IyD+BrbtvHF/d6hEdRKshYBii/wBKykuWN0YKUpTu9z0C08JLeeCL/T45CtzfSwxqxGcfvU7Va0bU7/w9ENM1UD7VCcOXABPftXQ+GEkE8U85EccZysZwS556+mOD/nnC+LujXk0cXiLS1LiFdt4i8kKOj49uh9AAexNfM4jELEYhUJ/C/wA/+CaYimudKerPHfE1hLpPiC8ii8xIJmLRkZAdGO7Hvg8fhWz4U8O6WUGoa7N5cSnKwk4yPU1s674wW00mzsrnSUnkMeRKzlcc/Ss/xHZWV9oHh64tb1UvdSeTdZkgmNFO0MfTLAgZ64PpXsxVarQWtl1ZljsJUU/ZxdnpfvqZfizXLK41crokUcFkqru8sf6xh3J74HA/H1r1v4Z/ELQ9A8MTnUbyKGRjlVZuWx6CvDtc0O70C9S2vFwzxiRT2IJI/oah02NY9WgW5+0RKJMOYYQ8i/7qkgE/jXRRw8Jwg6b0XXcnldNezn0Pbvhlonmx60mShmtGgDDtuBFY11oGqan8IdIZ2MIIXzS/aJWIXjvwFNPef4i/Dmxuby40K3W0O0STSEOo5wPuv6mue1fx14w16zs7S7hjs7ApujWO32iRc43ZbJPII444NeXgsFmUsTUVJJ83Lbytvp6foTWqVayapr3jeufEenaT4YWxtg02yHy3Zz2xgk+przzxfEqayki5xNCsnIx3I/pW9a+G9R16OSCBjHYxANK6jmWQnge+Bz6D8RWVrXgy70Wa3ScsBcZ8vcB82Mf41vSpU8LiXSnP94r3W5wYDJpYevKMJXld83ncz/D2tDQtRivUiBmjbKtnoK+i7r7N8VPh3b3kQH2hCy7VOdrgjI/IA18+z+D9Rt7dp5InWNRksV4AqvpXinXPD6mLSdVuLaPduKxngn1Iq8bg3XXNRdp9/wAT1qmHrUJKU9DU8R6Dd6BqptJlaN0UEAjqD3r1b4T+LtG0K0a21S8t7Lz5M75XCrnGOSelcVH4tt/EthaP4gSK9u4VKGSTKP19Vxx3xXL+MIbWN7OSzJ8lwwwTkgjGf51tSxPtadOhUhy1I7vo7fjr5nNQx85OpQm20+/l/XzPSfjD4Dgia71+zUxLGoaU/wAJ6Afia8etNOuJ18xEYY5BxXpvjfWdO0/4a6P4a0+dZFWFSQGydxId2P1Yn6ZxXXaB4R0aTw1ZXGP9dAr7t3qM1VKpH2d72Vz2qNOjOslibppdP1PJoPiLq0Kqu2PI7iprv4qeI7rT5rI/ZEimQxsRFklTwRySOntWza6ZoGi/ES6s79ohbeUDmV8Ak5J/TFReNtN8DqIP7Blja7l3Flgn3qMY6jnHf9amVHDtKTjc5J0KjrezUrvuUbG8HiTwzFFcQedeaePJ3BT80Z5Qn3+8PoorjbtLq2vS0yPHKCCMjHTpXp3wZ1HTtK1zVLW8g+0NcRJ5aE91Jz/MV03jPSh4j1q1N5bLaaPCwLRRDBkHfLda9SONw1Sl9XldSiui0fa/5eRzYzGVXKFNxu46Nr9Ti9Y8W6X4i8MadHKqR6xF5kfmZPyIwAbjocjI56c9+RX0XwPDfAPJcEgnsRXqWrfCfwlqehMmnWS2lx5X+j3MMjNg9QSCcN6HPOOhHWvMNBtIdFfN/wCLbOzhByqPZ3LlvyjwPzrzlSxUcK4YKVkn+ZFLFYfFzftLpnofxe8WajqvgW5sn0iayC3ELO7ZZXTnocDBDbRj3qpqemW0Xw9jbVIp4zpsO+KWFNzAEjKlf4h6cjByScZrS8X+PPD+seDtXs4bmOR5LWRUGed2Mj9cV0GieFtM8PWUGo3zm81ZF3o8rkrCcfwrnGeepz7Yry8pzbERj7bERcZRv+S8jrwdCWFpydabc+mmr/S3f8jl4FHg/wAO2trfqkN0yedcIW+67YJU89VGFOOpXNec/EzxEmq6/pFxbMDFBZrjB4J8xyf6V2XjDwDdeINO1HWrQPmGJ5fLQZD7RkgD14rxt9Z1NtKi0p72f7BESyW28hASc5x3555pZXQp4irLGyk3KTd9O/8AXQ4qUZUak53u5O523jH4n3PiXRv7LtdPgsLRgPMCMXeTBB5Y9Bx2FcK9tE1nby25ZnIKzKSDhgxxgem0r+Oa77wD4XsrvTk1S6xNKzsEQnhMccjue/PtXK67pUnhXxE9sC7QEB4mYDLof8DkfhXuYbG4SVeVBpuy/Hy9D0K1Cq4Rq1NE/wAL9To9C0zwpZeC5L7VLiebXpJWEFkj7UReAGcgfU9RVnTfDkPivR9Uff5M+nWzXEWMbWAySp/Lisuz8OLqEIvbW9SZT1xxj2x2qukmoQ6tNY2hkaEEIyRqfnOO/rzXm1KsalRum9V36HNTpupjVCj8OzZykoYSlWzkcV6VoVjd3OnRQXLNCUQKN/GABxXF6rC1he4ngaOUcmORSCPqDV3VvHOq6tLvfy04wdq9a3xFKWJpLk0Y8bRlS5oRfvFDxNZfYdfmg8xZEwpVwcgjA/rmqtppVzqN7BZ2C/abibOyNcAnAyevsDXUReG4dT0y3vLueRbmSPcdjDbg8jjHoRWdpc8ng3xdp+oIRP5L7hkYzkFSO/Y16f1GvQowlU7L8jGNCrCEXM6D4c3+n+DfE1y/iWN7WRUVVV1ORnOeB+FeneLtasdd05ZNHnjmgkU7XQ5B5/8ArVR+K3hZPF1ppl9pVoV1KNG89lcFCpxhT6sD7jGSDnPHkL+G/FWj3VtaJBcxNdTrFCFfCvIxwoznGT7+ntXFU5W3GLXMdNKjOFqk46HpPhjxR4s0fV9P0y60WWfSfOUPcCM4WIt8x3DjgZ4rF+N/iuPX/EsFrDxb2cO2NfduST+n5Vk3/wAQvEGjM+kQzwymAbGneL5mPrjoK4m+vrvVr97u6czXMpG5goG7AAHAGOgFcWDo4rnvUso9lfV99dvT8CKlPDU5TlSTvJ38htz5yHbIeDXtXhjxv/bWmQHVNyOihHaMj58cZ56dK8RmOZTS28k8cq/Z2cSEgAJnJPpjvXXiMP7alyXsZRnJ6ydz6o/4WXoek6Q0MFjcyhEOFLqN31NeHaq9nrtzPcpArzSZICc8/hWLNql3b6bc2V8GS7ZcAOMHaeoI+mam8GTf8TJYSM5YYrLDSq4OhO6UraLTb0tYyxspUoc8Fquhp6ZY+I/DVvpE1hDPLJqRcy2bRdCrYBJ7ZXnPGMHPFaXxXlgmu9O0+LMl1CDwoyTvxxj8B+ddhe+IjaeKLvSyFUQJABkckNDG38yaz/E3hBtYMvi6w1AW93psBuHR49yv5Q3gj0OB6EHjpXkKsnj4SqK29n3b2v5LZfiLDVcbUoOE3opP7ru36Gf4U+Hmrabpr3uoE2zP83knBIA9ea5FvEY07XHulj3ATbsDvjj+ldr4U8c3nim5FprF3bW0JO2QxxkFgewJJA+tdlr/AMMtG1XRnbT0AREzG0bZwR+NXCU/rFT6yr3/ACPUpp0aaknqzC8Wf2Z8SvhvHq9hDJ/adg5EIPynkrvQ54Ixgj3HXk15baeBtXuLK6upLdokgTcOM7j+dew65dad4S8DbLEo1tGpWPY24Od3PI68mt/4dS2nizwHcTRgeYxMUqA8q3ofwwa1o4qrCg4UY6Juze+ivb7jKrRSblJnznZ61d22nfZSV2wnagxggEkkH15z+f0qBZzNL9pnfMi/cHp712njzwLd6Exa1sbqczvvcxxs4iVR1bGcZ3d/7prhdM0jUtavkstNsp7q5c4EcSE49z6D1J4Hevbp42pi6MfefL0E6ko2jLWxsaX431/w+7nStRltt5ywUgqceoPBrpLjxFrvjXT9N1W7uUivNImc200EaqWlyj72GMcYQDjHHua85dCh2EEHuCK6jwhrY0C4MeoWrS6fdnDc4K44yp9elehhqcVUSqq6W5thKtOeIX1lXi9P8jntTuJ7rUpp7pFWdzlwowM4q9oTSWEx1Q2xkihBAYjjOKueLU0+51cz6W7tCygfOMGtG61ix0/4dRaLGN9/NKzSN/dXcDXLVfLUfI72ZniMG6U5JaxXX8jovGPw48PaF4eW40/WTqF+MmVlZdg5GAoH+J/CrPwR8NWF1fX2ragis9sVS2LHAUkHccfQivKbXUJ7bKh2MbfeUnrWlb+KtRsoDb2LCBGPOBk5rLCqVOTdR3RMKlKMVZao2/iZAt38SNVFku6BDEu5eR/q1z+uas+FJLbSrhJGiiDhgdxHP517hbfC7RrLwzJp6LLJPJE5a6c5YyEH5vTrXzJo9ld67qC2a3DIGGWbrgfSuGXPiuaL91P8UzWMqcn7ibkzqvF2owz63e69HdL5tywCQjHRQEX9ADVfSfFmsarZXWhFkS0u1CTSKvzhdw4Bzjnp34zXL65o154f1i40u/CC5gI3bG3KQVDAg+4IPr61NoN/cWl4sNrZtdTXDqiRx5LuxOFCgA5JJ6Y5qlg1Cmlu1tfoZUqqjO0tI9T1LXfhVologTw5rN2bsKSUuirq57AMoXH5GuLbxB428FJPp7zzWkdwpVlZVZWBHO1uRnnsa7LR7u/sPE/9m66tta3qnHkpdxTMDzwdhOD7Hms/4wsPJ0sA9Wkz+QrD2r+sKjUite52Tw0Hh+dPueYE3Oo3qgLJPczOFVVBZnY8AADknoK9a1D4f634P8CC8sL+b7WSH1CCJ8Ag8Ltx129O+d2e2K868MeIV8M6kmoxWEdxdxk+XJJIwCAgg4A4yQT1z7Yr2bU/Gkes/Du8v0ZVDIOPQhxkVrjqqpQUWrptJdrnkrEPDvmR4FPPJPKXlZmb1Y81peHtdu9BvjcWkhjkYY3CqhimvnlumG1c/ex1PoPf/PpWno2iNe5YohVTyWVj/JhXZJLks0a0qkvaKfUqXUn2qczMME8n0r0HwHa6F4jWHSNUZdjScEPtKnrwaboXwwvPF90bawkjtYUI8+cqWWMc9icknGMVkN4dfwt41m0C4mEskM4QuBt3AgEHGTjIIPWop1Ve92rm2ZV5U4tRV27P5no+p/D7wLYXHktf7ZP7rXYzXn/xD8KWmlW1td6WA9uMiVzJkjoB36ZNVPFGlaRZo0sUWJTyTvY5P0zVHQdJstcvIdNWYwi4YIHBJCk9CRnmssNhVh1UxFaveK6f5biwsauIvGb6d/8Ahz//2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCxZXlndLuiminL4XMUwYKT2YevtWpCjjaoUN0BJ+9gnGcdeP6j0rw67t9T0Jo55VFtMDujKzKHB9QAc/pW9onxSvbNki1K3iuouFLquxgu7JyOjccAcCt1V/m0MnTtseqSeWqpJ5cjxDK4UhSD6E9+T+lLHP51xh0lA24HyZ59zVDTde0fVIZZ7K6W5QbQyoSCgzg/KwyMnpkDOOCae00jzOsRd4wudy9jk8Yz2AzVqVndGcl0Zq+XTglR2sm75THKAT1fP+cdKNQvEsHgD4xK6pk8AZYAnP0Nbe0SV2c/s3exJspdlWfLo2U+cXKVvLo8v2qzspdlHMPlKvl0eXVrZRspcwcpV8v2pPL9qt+XSGOnzBYqmP2phj9queXRso5kKx8sXFzLcztNNI0kjnLO5ySfrUJPA9Kmlt3jwWHysMgg5BqNEZyirjLHAyQB+Z4FeakepIdb3M1pPHPbytHLGdyOpwVPtXZaX4z1y5v3mbVWhaOF3UMB5bEKSF242ktgKO+SK46ztJL28itosb5GxlugHcn2Aya9AsPB2n2d3iTVCzcgeZb4BBGOgb365ranRnP4TKUktz13wg1z4i8Pw6pdrDEzufKEaEDA4PUnvke2O9c741kjbXLCJJQGRSXUqVI+YgHn6E/h6EGsCTxH4m8D+UbG4jvdHOWZHQMiMeMcElATyMNjJ98VZvPEMPjSL7Rphjs9UHlxx2csit5jl2GAXAB42HIwQc54rKtGpBckhxipPmiejq4dQwxyM8Gq+o30WmadcX0+fKgjaRsdSAM4FeXX0Otabpd7f6jOI73eq3EZ8tlkUgKgBTpgOSQpx2IrYj8ZW2rww6PcWq28d/bOlxNGwHljbJuwMdcKMDr83fvpzu1yPZq5reEfG0fiWa5gmiitp0YGNBJu3g546dR/XpXVxyRzRiSKRXQ9GVsj0618zW4aK4iMYErdXU8BevQ9+K9t8J266po011fWm+GIb08psB5TgKMYJ3EhTxx6+lZ+2kjaVCG6OtyD05rOk8Q6TDdtbPeL5ynDKqs2D6ZArH1DWNHm8O+J78QxGGawEVtI4GTl540ZVPIyVHHbaCa8ZtNTktkygVmXPJ6KP61pzs55039k+ho9X0yYHZf2+QNxBkAIHuD0p/2+yJAF1CSQWGHB4HU1xln8MdR8Q+HxrDRxTu6+XHahthdQWy4YkDqTjPHfkcHldG8HW9l4itYdf024tVcMiC7gdY2kIIUscj5A2MkHpx70e0ZSpK2p3PjDxBbQeHrqKyv0F66qIhE/zH5lzgjpwTWZ4Y8SOFtobi5DxvhXaRtzB8ZH55q3JrPhS+0vTvEWpW32JbO4lsLfT4gSZImVQ+8gDOFdmP8ACQxXBJzXnuj3NzNOFiRZLue4Z0toWaNEdRkFQpAIJZgFAz8uARmk5u9x+yjY4q2z5yrsDZYDac4PtxXd6XYwaHpU17crF/pdm5HlD5oDv2FcMCeQwBwQQePauZt7dXkEKIWkbhVBxk/Wu7XwlqnhO71CzvrfdYXIjhe9Ee8BHbYCQM7cEkgeqLzhgDlCd0bzjbQxtZvdKuvElsmlWMUEQLhWWMK5Xyhy2AOSS3XnjtzmGHU3uNPgmbGVJRz75GT+tc7o5b+27csSfvDJ6/dNaOmR+Y93ZNwPNYA+h5A/kK9LDfDY55nRRSC+029sCvmMylUBPH3QwPGO+Pyqvous2Gl6XaX8qq9zbXKPFAjFN+w5xkHK9OuDz2NZNvd3mkxPcG3DhfllDcYXPBz0/iI/AUuu32o6lYWIaxeKxjWR4T8zDGQG56cYHp71njVCXK5PVGuHr1KSlGO0lZk/izxH/a+s3ktpJF9hnljISMEgFUC/eZVY5xnkD9Kynkt9yfaJpICyfKxUsByecAetRWWnytol5fncI43UA+pzg/8AoVaSTyHwRqfClZJI0JOcgBlPHPfC9u1cj2sJb3MfTLvbrNtM7vIBOpYk4Zhur2x/EukaL4P1PSoJfJuBtltoUBB38EMDjAAYDj2NeG6VEXvYpMEiNg2AK9bh8RXFv4fn0u1aASs5EZlcAyFwMgA8cDnPPUcDINYVLKSZvDWLRyq+GPEmtafF5EMU9vZoUy1xFHsGSxVtzDGCzHn1rmNGtf7W1mzsy7Ik8i+ZIEzsTq7Ad9qgnHfFeoaLpWo2tj5d5os8i58xWS6h5PXKgKST079uKpWOiLZ6pBeW9m62rw8StJuVpMBCq89AB7nrk9Mv28eZR7kKm0rnt2kS6R4X0nTNNtZdtjsZ7dpJGOQCGkZ27/eZvqCMV0d3a6frmlyWtykd1ZXUeGUnKup+lePeJy9hLY2AVke2tVTHX535I/8AHsV3+g332ZbCwchUto9jt0ByMfz/AJ1rfWxNtLnhnxc8JyeEL+ytrXzX0mYyTwSOQSshCB0JHpsU5x/F7GuQ0S6ubS7W/gOxrIG5DkcAoCwB+pXA9c4r6n8eaKninwFqlmiNJKYmmtxGAWMifMoH1Ix9GNfPPgPSVvdZ+z3sJ+yzxyQShiUyChDAHHUKxP5fWm2COP05ppr+FIhukLAJ9c8frXqNtr/jCfX9Wt9Stoha3sfkTpKwzHF84RU2sCT8+SQCcYOK8y0SbZe2PIC+crFscnB7/Su21XVW1xBHbWd1c3tntRnijLZRm+XcAM9T7fU5wKp4enyNzlZnNXr1vaRVON1qLaTWum6FPpVzZRWsvmZVpuGSQsrMQzHjKqFwpxwOcnnmrKyvGv5bmGNXjlcyRESoS4DHkDOSOucdMH0NdNHDLpTnTb6A22px7GjQSQgupZT8qg4yV6BtxUjPAGBvWVpJcyPKIpp2DKyRzSIQCGbIB4AO0IQTjnocg45Hj3hrpa63OqhhatexzZsIZXaG6uVhWbClSGYdN3BHy4x69c9+lXNQ1K6hv1iIadGx5yvCFRTk8EAZU8HIJ42jHeuysNPtxFLP/Z726HPniLevzZ+XgAljjnI9fXgNvdNgR4RBo8c7SbCTO4Xvx9cenB471xVsfGvLmq3fbbQ7VllaN4xaOKu01CPTdRt7DTbm4F3uIeKBnOCNp4C/LwB1HrXNyW7weGNRsWjKyoVlk3FSQDsIxg98fh3r068jvzrN20Ns1wbSTKl/l81nXoMn5uWI5PX0rI8U2tpPpFwxkIupSHIeaOSSQjA2sUwMgZAwOdufU1pTxqdRRe36kPCONLmb979DzbSVitdPnlnQOWaPCfxDDZ4+oDCuyivdO2rBe6TDNetIyC4WRjHH0YHarENlmIwCuMYyOo55EhuL1rXewVyMNtwcnAPr0x0z2rootUm8JEWloLRSVO93j8yQuSVYq+MheBgAjvwa6pxuzBOyOgbTV1C2X7P4XCzyREoPt6KyyL1yHXPBKnr35PNX4Z7jVNWtbK7tzZTCZVFozFjGpPXJPIJyRjjsOlZF7qF1r9rdT3thYWxNsyRTSP8APCBkqxkHTHBxx715XcXlzCk9sZIhuCpJ5W0hgowMMvXjjIPNEVZ3G2e7fEK6ksvG0bAc4jZSRwNqg/jyB+dWrHxDG99BbWVuHLOoEkwywPHQdO1eI+FUxLLJjAXA/P8A/VXpfhV3OtWLbdxFwgVfX5hVXdylFcup9CAADA6DtXg3jSxTwZ4phtYJfs+lzIssOEwEBYKy7sHJHJyQSAV4Pf2i3vPMmbOVyw4PpXDfGzQU1Lwb/ayKzXOlncqgZ3RuVVxj8FOfRTWjVzKE+R3tc+YbdJtOv/Ll+WSJ/mwQQCPTsa9tg161sIDfwNNcSIiLFLFFu8wO2dhGCATuyCSBjgfdArg7zwjbPcRyw3Wwt/rFxuA+nf06muhs9Pht7OLT5JDKINwOQMqCegB479f/ANVclerdLl1Z34fBS5vf0RYm1J9fVrr7EXndi5TztrNJtx837xTECsajGznGcjrWnYaXdXVzPdy3+bVG4gmVZAuD13o2xSQRwM9vSqukwRLLHsgit2QlkUDc5PI6kqmcAYBB7cmujuPOtYXWGeeRkQuUXyxFu6/M20bfxYV5NRu+qPXUeVJREjlRoIltJopLdGYy/ZwHwvXnCvk9cDIJqGS6aO/gtdO003Y4KP8AaSPKPclDk8DuT6D0plssM8n2yM+dvditySUIIz8vlqAc5zkH+dSTYkgmu3vysxhkJlVcuDGWC/KCO+BgDqpz3rFA+5pJJchYJL1Yo2iYh5FBOcYxjPrnHrx71PbG7khC3dy/lyFdrMmx1weCSpHJ46enSsbT7pIZ5LK9hlVhKSz3DjIDDIIB65JAwPqTV6RbhReSQERXKgxBVRQW+XKjjO0HPTPfPFF2iXFM8s8caIumayLm2WSO2uPmjR5d7JgBTzuJIyDjp+nHO6p4glns2glRg7hdx+XBw2cnjOeg6np9c+yywadqekq2prD5jFw8oSN8AZwSwBwTgc8YzWd4t+FOk2/hG5fRbGafVvOUQyS3OCFzlupC42g9ea9bCV+aNpdDy8XR5ZXXU8shv5NTtotPZwInfMn09ffHXHHTqKpXulLbxPeRMHtkICqX3knjI3AAcZ9qoS2lzZTvbXMMsEy/ejkUqw79D7Vo6P5pkeLkIQGYEd+1d8UpbHA5W3NfRb/7XHO8kCrcFgXlXgSccfL0BHcjrx6ZPTadq0djdRFDvmVwwQdc59e1cqlw0BYmNsjmtHRM3OopIWDEcknp35PoBWns0mN1nJXe56gPH2svcnGi2/nLg7Rfrk8DoCvXHaq3jb4g6vf+ErvTE0xLSadfLmZpRIVjOc8FQASAfXAORjgi14ZtPtEU0YDOJd2S45II6ke/p6AVx/iJtX07VbjV/sZjjulV4t0W9AgGxSfQgAH64z1qmkjEYbmwsbGC4ineS53MM9MY6EjHv+lW9KlTVZmWaVFjZsyXD/ewP8/pXAw63a3IYTSIueQG4xTLPWDb3LxxyGRJDjIGe2P61wOD2Pf9rFpNM9Ia+iLKIhuTJG4HH+f0rRs9tzB/pEckrQssaBgRs3HqOcE85OQeMV5VZeILqLVE8stMzOAqbeSelelaTLe+fCy3wt08zzJbdogzccEBs4GQo5we+K5cTD3NTopTUtUXI4LXdfRBzaN9p8u2kMinYxUIGweeWOP8OKkTSdMEGmWZaNorcO0OxvlIJ+Zm6nvxk881zsl14ka3lkg09Zjb3bPC7xlJUHmBxhW6jKg4xnA966KHVPJZnvVZLW5CkxzDi1YAjBB6KeuTx1x1rhcGlcd7uxau7ie3jSe3mL4+X7Oyht/IC4bsSSMZ/wBr6U6TV7fzImmUtDHgQ3USMNoYcEdQeCc49DxmqEt66I0OoNb2ssLj7OiSArIxOQSSB8ucH2PHUUWy2Wj2NwtnPIjQMpcySLGFDEcgsNv/AOoZwCKhRbHoQSPLtiZb+3t3jWRXjcbMnPB57YJI4bqPSta41XUYrM2DYKxws6iVmeIhVJUu+OB65Ixg8HFY9x4p0tGu45Lossjho02ggcDPzKCODz/Kue1DxjA28oolQuXS2li2xqc452kbgevp2x3rppUK19EzGrXoW95rQ7fS9Uh1ewie5SW1QqBLbCETKwPfCr0PuF/rXC654f0DSedI1iPzpGKmF281SMjGMDcuMn72c/hzTbXrvWrG6XUpJHGFW3AwFj+YMeAOcgEZPbNaGiaLNqc6aXo/myG5AE06x/LCM53FvTrxxnGBzg16NDCypvm5reh5VbExqLlUTkJt8k5hW5UShtoV4sDPpkZrR8PrIbiWJ4xgkK3bnrj8TirP9n2dhBPp99P9ilScB45Dyx3c8hMr8oXjP5Zq14diiTxAY7O6iuYd42v5bAOMDgAEHIzjjv2Negt7nD5Hd2upnRtDk1WbezrIjSKo5VNwHv1z/nFVdd+IHhi68N/2avmTFYdkUcaOAjbSACzYOF49c4qt8RdatLPSr/QbVZ5b+UQlwiALBtKvkcZOVA9evXjFeQyahcTk5fdI4AJIGW7Up7jR0OseG9Pe/jlhAjQnMkacA/T0rV0+KwtbYbWVdvIXFRx6kJRcXKkHc2xeP4QOn5k0+xtoZ9OlZhhkJIIHPT/PWvOcpPc+kjGENYrcuWthBcaiupiEG4QFQ/PTkduD9ao69qeraZIZYpyttjG9YuYuejHGevQ/hUlvcyRxLEmVOflHPP8AjzxTdV1Nv7MuFkjP79TGNw4GQR1x160o6ytuKvBRpuV7HKyavuk8yW5Exx0lDNn2Oe1RjV5gS4aMN67cVWksQI/MWYEYwQVOQeffFN0+GKS8MLQNLJINsag87uw/Hp9SK7NEeDdt7m5beNtVgjiiD2DJEu1BJaxvgegLAkU+/wDGU+roo1BLZygwm1SAo7gAHA6DsawbrTIxOpjlARkDD5fw6Z9qifTjGM+ZkH2oUYLVJBKc3o2ab6nA7MY2WNT0WMNhfzOf/wBdJ9phyMI0xJBx91fy61Tt7VC4X5mz0Citu10y7ZWMGn3LDqdkLN/SrMmyOC6uSjMY1Xj5BuwB9fXr3rodG8Z+IdFt/s0F9EloAwECQr1Ixu3/AHs5wevYdq57zIVYxOdrj7ysMEUrOrkbSpAyePzoYGnrutjxRcm61KVo5ANsaqMrGPxySOT3/nmneBZBZXK3Ny6wwRTlpJX+6oAXIx15zjj8BmufmXaxxgg81Jd6pNNatCVRI928hBgMdoGT+X5mrgJi6zrC+IfEc1/dz/YoLi4BaQKZPJT7o4GCcADp1xVLUvsQu4wupm8Tbnzfs2w/TJOc/nWPJJmFlzkYqGKYx/KRlD1FJ2Gj0v8Asm4t9KWZl2pIcjcQrZ+nXtVOa9dLfyIgIhjHmMefw7Dr/wDq4q0sWoaor3NxqUECRjHkRQ4VV7dTkZ4OcEkEHpWho2gWM14rIJJ3j5DyHBzxjg8dTXnM+lXw3INJs4fsovJbrz7kjhG4GM8df880mtRyvopht418xmEaRqBzkjtj6n2xmtiSSGW8W1SMIg4ZyMnOf/retUtQghXUYQspIiDMg/Ajn9aS3uVUtyOPc5uPwzdTWJZpgLhQSIsDB9BnPWrPgLwrLr/iVTJMLa3s3WS4ckBwecKoPclT24/IHqoomktOT985xjrzWx8N9LsNQTXLyW6kt5obxt20gFVwMMTjpnPeuiE3LQ8fE0I00mtCx/wh+nRCCHS7BAGkAE1xCszRRjncxZsdc8KCTwDiu1h8KaDdaesNzo9lJGuQha3Unn3x159qjsfD39rA3Euo3klmMiDedpYf3sccbs/UD3rf07w3pdpiSOJpGDEq8jZxxj6GtE30R58qet+YzvD3gjR9CRhbaZbIQSFnEQ8wqeoz17nvWj/Y1oy+ekrpnlS3P41qJtt4kiVcDpjOapPcKLllk4VCAhz0yOn15qnYSprqMbTZWtmiyksbDBSVflP4HP61zV/8OPDeosXudBjt5mUqJbMmLaf721Ttz9Qa7S1maXedvyg4BBqdmHHzAfWheQcltjwfV/gvcCJ/7I1e3nKklYrhfLb2GRkE/gK4y9+GPja0QO+gNIoyD5c0bkehCq2T1PGK+qNwOVI4+vWnAAjAAI+tUmx2PhP7PgyiSRImT+Bw2SfTgfzxVZlz9a9h+NHh3S7Hxld3f9oLb3N5EtyLdomKt/CTuA4yUY89zXkjoVODjOOxB/lTHY//2Q==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAACalklEQVR4AW39BYAc15U2DFd3FzUzDfNImhmNmCw2cxxD4thhhx3wBnY3DBsGO7GTDTqx48R27JhRki3ZYhxJo2GGnmbuLuyq/p7b4+y/7/u/I2nUUHDr3HMPPudcw9cefE6SBMZElQr5UF3AZDLIUjmfFCxuZ2tD08zEmMPjp1mDplRYjq7qBkUscU6rrmpyRTVUqrSpqld1Y1Wva6xXK1peonM5vWLmq0bawJhwWUqvVg3VKkUZDBRVparkN3lX+4MPyQv8GKq11+Qr8oFOjq+dsHze8uc4dvkzXMZALoNjyG9yXfKm9pvCgHAVo4HcGVczkiuSe1Rrh5JXeKsv3w+3rd2ffEdeGclAcHeDQSe3qB2ID8g9KINRr+i1UdUeYXkkOEEn1yKHGPELp5BHxG1xd3yAS5HB1a5PLo23uo6r1EZDxm3MVwSKMygVmbFymVR+biZidjhcbjdt5C4OXFy9tkdUVZqjWRtnc9oqjFHTq9l0tr2zPhgOFAUpXxJ4qyVbFGKJeEVT6wMuu8vCcpyJocmTYHDG2kOSW5LRkeEZjPifPB2GvDxg8rAYLXlKfF47rkY38ppQlQy89ljLr/EOs1r7Tb4ir2tPX5tqcm18h9cGgwmXXSYeDq5dA4OpXYgc884n79wXowIxcQNcDQe9cxFy59qlMDw8itFkovHXaKTJHY0YpNFIPjHRNPkET0TuqJNT8BeTiBkg3FLF45GvyLBwDaPRaACr4wVj+Ppvn5ALOmNhMJegrjvglHTKqJgSi9FA0G23WQ0sm0xEGuvrCgWxSldZQlcDy/GRZIQ2GkRJamquk4WKYtKcHC+L2ujUnCfcYvP6ZSOj6xqYrUYMDA7/kznHaAj1aiQhvwkpCMnIB7h4jcbkPf7WSE8+woe1hyCH1l6+cwY5a/mnCqY2GI04klyqdjnyBe5FaIBnA7HI5UBicvHaUSAK+ap2A0KfGseQgRJK1c4yGGvLl0wIjsLxNZaugn6Ei8mJOrkuGTZZMqA/GSsISNiuipPx8OSvrpHrkRnAMUYNYyBfk4NoOZN3OR35YqG5IWC3eUqlksPNTFyYdJjNpVKmoku0kbZbGapaSSWWQg1+B+c20vpSPKlrWlNLo1qR672+smzIFTOCVFIqFaedNggJmlUYV73E0JoGkmEM5A+ekQyDcCZGD2KST/Efho/X5AVYdpnoy+OtHQJygNsI4ck8kHd4UXv62jXI6fgxVE14RShFSEEmrHZhcm0sAkIhchD5WT6c/A8xsTwefFQ7Btcmw6gNBdfAsCt4Q+5XmykMH2dVIH+rJoxp+bIQMviDQeHOGlZ8TSBRFIQvjibH468JM0MTWVWbHnxcYwLMCkXhY0MimhHLOYfdHknN2KxmrWQKtTbyBloQRJY2ZTI5g8aOLkywLO3x+MtZycpaeTNvsdvjS7FqRRZzGVU1UTRjhNipyD5/wG6xWXja7fcMRxOygQWzGDVCEDwlXSNkjcy18deoVPuOMA/hIxAM7wnDvkPw2jMQliFUxi/yf43UmK3aR2Q2al/UmBcvyWOTb5Y/Bxcu34XQlUi9Zfrif1CNLBlCKXJTvIB8qH2Al1UICPIfRlQbHy5C5h1XhbR559KENWrH4wMytSA0Llq7OwUGJbTHufiNO5FBEBWCH92Iecd55CnodL7U2dXW1rb12FvHabMlniuYdNrM+k02t1BKWXyuTDa9fsNanFEq5UvFcmRxqbOrled5E8OMX1h0eKypfF6vVEwsDd6rqArN2aIqZbHygWye5iwK7SISD89NBkJmvvao/0MEPB5+COnJ14QoNRKRpybjxxhr59U4mjxM7QvyXGRh4z15Sb4kL8CzeEHkcO2H/IfXWAG1lbN8OdyjNo24Dlkm5Cxy0/+5LuRY7aQak5L1QTgBFyGXINQmvI2zwMREfpFX/zqXvCDPQfgaj0zmj5wDRYiTa0+Bo8lLMgL8EGYwUBARSwYtND8xxfBsfaO3kC2zVRmyfmJ6JhT02x32UH3YYbXx7c2jIyO6phhM1MLiIkMb3f5Q78bNkfkFuxl3VasGTZJli9miyFVJKle0it1sMeka73SqVapiwJqt4DlBKDKA2tAxWvJ++QFqv40UDKra3OArwiD4R56TvCQ0rf1aPouwLaE1DiBXhGyr0R3XfOeD5eNrV6gdRA4kX9bmFTetDeGdmVseDi6DP+RiZCIJmcDRRGjia1NtZSyfju9qAp98/s6/2jG1XyA9kV3L39SGTRPOxNVqAyCDrT318o1wXH/3imQqa7Dz27ZfvnpldyyRlSnz+p07aQNdiC5ZvY5stqjIcn19GHf3+N2ZRHZ+bpHoZ3cI3CqVcxML016Hx8ybRaFsYFisXbOVN7FGnijhakkz8g5HWYfm0dmqEXYRKEWeHv+WqfXOOyKqQX4cUZMH5IAaMd45EtQmlFmeHvJg5DR8QI6qvSCXXb4g+ZJcHP/IesKL2kH/v1/kAMJ9tWPwskYgcpHa9ckptbkgDL0s5vANYdrapZZv+6/7185651dtILgbnhqjq12ePAQ5F78x0to1/nXf2mfVKq1KZZuFWPOjR/dNnzsSTQpr3nfLFk0+M3C2t6vTxtGzhVw4CP1sN/Gm86dOupwQ8WaH3SkWi/F4orury2W1S0oOMsflc2PZlcsazxLejGaW3Bang+E5tSSouslsByNAti+Lc0JAIo7ID+FzaCYTGSOYDeq0xoN4gzkhBxByLROcHE0OAo3wSe3D2qMuTwx5WkLuf/0mr3Aufmqzs3w7fEguUKMI+Yr8EAVUO3fZjsJUkndEty6/ql1z2SIiA6i9xSG4DiHxO+eSY8mjwEolT1ejOw7Ch4TlyHHEOiLXJFNB6ID/DD0dbUpF5bFyIEbgPvFsXJZXNG689kMfmovEWtuaO1pbpsfHwOCgS0MoGI8li/lyKp2UVc0bCNtdXpvZJEq5RCKNgZkMmsnISqLAmy0lqWzmeE2VoLETiqGhdSVlgPrSatQgY8ejLD8mnqImvd95MghYEA2PSw7AoPEtRlt7BhgZZNZqX9UohGOI7V573tojkgfHcxG7i9zjX7xIrrV8T6JUaz/kHHIiGURtILUvyL1Av9rZZJKX5xRH4hMiDGunYljkq+XDaueTm5G/y5cip5OX71ydjLdGdEg2otiXVx8xnDGmFW2NFV1jq5xm0FRKxVm0wZjLyYrVaqK5e7/4g/TSnCfg37Z719TF8ZaO+nRqSVPUiZkY1kFH16pENqeWxYoq+RsCI+Oj1YoeCgaLQtHMsJKm5pPZFV2tuWLeZLKx3oDO8ER6ksFgiJA3REZQcO2oKk8bZVHSWTMe0gRzDoYqDiT0r3EMeQQ8M/lLngBWFYZO9GXtmQktaj/kK0IC8v6dz2rvyWUwg+Q10RbvzCcZB14un1qb5nfOIfTFp7UZqxG69oZcszak2pe1q4GEy2eT78ir2lt8hf+Xb4aPyBfv3Jp8SOQT0RG4CnkguiLLiqbpEAE0Ba8JNrqkywbGIGcyJpp98JufLIjixz7y2RmP99LQqERV5EJpy2UbUnk5l8+zFibEu4Siye1uGhwaY00cyxtTi/O0iS3oBXfQU2ZpSQHP8uGQP5JMOoKNFYqCdValNBov4AzCaNClXCoZCLvziVl3Ux/mg6EoBcJ7mWrLYybrgAa5iYKDGYeh41GWH5M8878elnyIv+SLGjGIxAObkcdaJkSNpjgG5+Py+J8cSL7CAeQiyxciHnTtsjjonRlaPnz50NpRy58TuxMfkoPJRQhNySXIb3IH8gVek/GQQ2o/5ABiLxDXAkvdEHJ5TDyRTHg+WVbxjahqgkaZjRxYsWJUVVkzUTCqKMQifvSTB5eSGc7hqmogutMfdFwaGhNLQt+a3kQ+D1EGy+foS8/6WtpaW7tzhRRHm+1WO65J0yyIPZ9KNbQ0V0wcdAHeQsVBJgqFuCrnZSE+dub89ls+hQEjiFExkfFh1HgGMlCyamuPQMhJRr9ML/IheYe3mBiQbfmgGr3J4eRQciT81drc1T7CMYQyNSKQr3EJomrAjnhNLvWv2SA0JB+Ss5b/kfPILfC39jHkJPEhyDogtCaDXJ6Y2p3J8MnVlo8l59Y+JrfHX4gCfGs02p0uiraUNUqkjCWKLRSrRo0zUgi2FbVKGUuDM3EUA80Ohyv67//x8VU9ne0tLeCrYiGztLhYVxfEo02OjCqSKAtFcLtKVRcX5sq5TGR+sVAsJZPJWCwxPDK0GJltbQpFF2cZyDiibzFewh0+r0fIZnSlIhbTZgsiKrVx1UaN6SFTRP7gYJCMcDRmjrihsNYhNXAYfsgrHILH0ogyIS9wfWL/E8KQ3+SB8QmOJ+qhFg3DI5BPapclv2vmP35jgdXISL4l1F4+m1yGvFq+MvmKXJkIcXIUhkYGQIZCxlObHnJNTDNe46DacbXjyRs8Yu1ByDn0luveHfA3MnZrppTSTdTspYGjL71sglqAKyfCmRNxEESTieNZmlbLwgdvuq4sCV/8/Ff6tl12+uyZ9dt26LqllE9XjVwpmzIzTpuJ3nL13sXZpYaO9lwiY7bZhKLk9bo4lsklUzCZlqYmG9q7K4TQhGrpyFJucUbUsliBlVyes9gJfXB/kBXEqsWS8Lv29Hgm0PFfbwh98DzkifEXpMN3+CEEwK/ag5oIecjz1w7Bm9r6Wb4EER4gH7QJqEaMLXKd2tlYdERKg5xEStde4czaEIwm4sWSkWEVk9MJHxMBjqMImXExckYt3PPOXJChkG+NFWPVpFXw4BCl5Ea4ENji2z/7m1DK4XlPvfHKwLn9RCEadNZgwuRW9GqFYXRFBUvgMfAJW2M+KBKWYQqy9O/f/kFzx8qRC0M+N2812hKJjGx32a1UfX1TLp33NQUK6aLFYtUNmiZroaa6dDRmMdJWpycriyabR4PppUluLnfu7Zcy+XhyZr61d0/v9lsgdXBnTMAy0+EJCQ3xB6+W6VHjKDIoMotkxDXyvUMBnEgs+RprwrwGncFAhFaEvuQHFyHLgZAFpFz+Av4reY+l9c4X5Np4gyl45wjcpuae4ah3pp38R8ZQOwUvyWXBMTUCk7c1o5twC/4QW0PDvBE+qR2Ic2txfNpTlc+ffvuNt/eZ9DKuBOLqRmMF7lJtfAjCmcyMLEsYG0Q2pUGlYvpMmDwLQ//6O9/AYTuvvqHrAx/IJ8X6lT5NVBrbg5lYrDnswBRzfpcuyKzVolmNUqEoCsWipHhNBrPVpRoMjBFR68rbL76qqlPRSJoxmCxsBdYwBRsAT0vpUAYYBQnvYlh4SYZUGxZhWrwmR2lQJKCsXsGzE82CAzH4GjPXzsDjEArhcEIKQjzyX00EvvOWXIV4hzVdQ4hM1EWNZoT0uD9+E6rW1Cbe4274XZtEcmMYE+Tq5CjyCy+xOGprm5yA8VGKAisDHpeiamaH08q5oBBrEQ+iPuhf/+5nqWRMr8gw4WtzRiL+MNZxS03VIK7JiwqeAmMio4SZhPHAdEK2BYNlaeP+/S9GE+VPfPqOspyKjA4/8eczolRoae342Oc+L6kGmTVhQAxDU7RusXMqo7M8r4EpGUQHdZ42NbUGz7x1QigIHM0IRYHnTKJMGBRkxTKE/q+x/TLLgt/Jo+MxyadgCTA4RgEuJx+A45bXKo5ani2MHQeDYCATRo0z8Ento9qU4CiifPHVcvyHXLl2IGFVQnsyaWRKQFjyQ2hAzieronYo+YXzyRXI97WXeo0jCAORgYMh9r/y/ODFkxYLEwgGVqxb77fVeRtbjTTJbuF7OhWZwoE01kMt9lrVKrSJwXNXke0CQyG8JlPIOOC+FRgnuCCuTEJ+VbVCOFTCB0bjyOD+X3xnQOd4VVEqtFkt5nG9T9/zgf51W/79i99OFPNVvWxx2tqD3sGzA0aDz8hwuAgisRBBRrmYzUuqqtaFQ7lCQpMUhmZ0VdfAJRBEFbA17oyJgOEKGhPJC4JiJau4MeFXPDgOwKcYNJkKzBJYmMR8a6unJnDxlhAJk4pv8I8QpkavGgmpWnqFHICIFlkeNUlBdBDYDYcS8hIFQzi6Rn0yBHINfINja/fBb3y2/DUGTvgUa6GCi4yNnMlklhTBUR8OyenE5PyixenjeYuBg4BEMK62aEwVQwVhhEqFXA/XwcI1gXOJoQBZUVGI5qAZBo9LoqzkIWpkIAPA0Ih0UwwI4umZUpGj1XAg7PE6oiPZkcGhj37kfStXBXlj2dy88jMf/XTfhq0XL4yGOwIFuF00kpbGdEnmqoxaVcBnqojTjbCj8AhGRYUNBC7hTZyiVgjxyV0xcZgErFb8YGVSmlR6++WXGd6y58YbobhBBzATxokBYzI0omlxMZCOkIvMEH6DlPiL7yFga2TDI8HeI3GfmvLDVOMHHMhU1aqJlY26uQI5Q1Qzphd00RDdxxlEGi8Phwh/MkPkD8ZcW3A1IY+opSoUDBrDmSgWxIaA1eXBt17lrcGVe3cxCJlilpBiwINAlJmweqBmKSND1BixQGr2Et4h6YbIJpYAYUUTkdGY4FpUWyNcCQZbWFxKp7Nmxqqq+vTk7PRE9Gv/+a1kMsUbFaVQ7mxv+trXP8qaeIbh1/X3WBUh6GLdXNWMgLXdKhmLTr8tl4uv6l0RW5qE+2HSVQ7PA6fMYKyoFcL1NR0GcUgWKkwJ3FOjytNjP7nn/eeeferC04/8/lvf4EjAtaIid2vAhIE3avoARMRbSgV/4WlJTgsERJ4IF9SwBCu0Dq9DYygYKSAdpC5mAdYuaEHCt7gYYorkRAMGA1FBphZrDTNKSFBFxJQIJawWkAzXMVUVGleuQNaqrE6ZKWMml1OUMux4rSJmc1kssXhyoVSMY+5zCrGVyUCJ9CecodNgG0wGyI8lioclhMbtwFW4IxkPVjtZtqA+ITw5B2Y4/oeYEkUpkUhKpXJTc0sw6F3T219RFNZmg38nVzQqb0WEFUKANTONzT6aknhcWBZ62jpttMFB81bOGpmbcZgtmizohCMxAiIuSPwHdyZyHyubcB0hBmVgKeMff/cQHDzQDkmfQnLapIDFiGqArMHzEG43GGg8CeF5/MOkQLiDk5elFA7BJWtsTexGnEWeVQHsoFIuqCUFc8ZgVSASjdWEOcHkk7vDgcc4SFzLCBriymTGsH4IMSAG4EcSWhqxflnYGOUs8Ay0DianylBuCLJQFMeYaQNblkRE3ojwxwBBF5hJkC4IXhPC1iYBM4vnJJfDqCF8MFbwDu5I6FJTTLg13sJuJ3lOXAX+MtHT83PToYBvfGzCauEyibSlrm7vle8yVDkybzQ8VqooZspC8u0XXr/pA5+599++0dhitXn4ckGq93llWbA5vAomTNM5lq1UKkiiYVRYWGQqsNAhDEDLilaYHSpPTzOc1cSyYlVFPvrt5/6y590flnBUhbIYZIxcISOC9qjpA8KqoACZVEwonppcjUhR8gPqYYk/+cITS2IC82ICkYysxW23V80rOlZ2NKyoFstIeTBWC03IZlAVcgqniZlMFnRlICaMRitjxjBBHFUQsoXM28PDdFVs9vlATqGi2kzm9FLS5teCXoeml19/5q/X7b7K4MS1EBIiwp0QlUhOQlIsLSxQXWc4CFVdlcngMf1EoNZGjNuQD0AKIu9qXEXe4T3EGrwtq40p5PLhxuaKJFpYyzMH/qmKVXi7GmEOsGxV0MrJeHxhMXHgicfLFFZotc5rMXN6x5ormhrX67TVSuvZnGj3uKsVyBCDqsH5YCkTsDAkbIvw9sk3nn/hV79DXgIhkIlCossXXtke5oPNV123I9C99vAzf07OxW769BcUxoZB0STYJ1YkBJlUYBEESWE5xsSZoSTBdhptlnKxx/78aMEiZWBqW0xOp9XOWjz1QSFWlKGNYqowNbWqvWv95r5L4xNUhdZMNtrONHmc4KjDJy+s39S7prv5yFsHZEFgLNZYqsIy+snjZ+xmM2+jVbGcVgW701dIFrbs2IDI+/Hhof6untbuFbAzyRAwm/gHJQvqg9FAUsJu+B/0ImoHwgKkry3imujBQVATOAp/iBQir8hqwC+sJBPHxSOR/g09xbwS9vk8Hs6QlnS7AxPKIk0Py6paRmabEgQ3za5f2z8dyXCMHk9Mepxei2rQctG/P/7S6MTw3R+6Cxfubmp54i+PbrzyWo7lfHV+qATazLkcrtuvuPqfv/qNIAsMZUJUvKgr54fH2KHx2PAxs9N31Y61ulV78bffu/XT9x09MiAWckujQ/29vSZfsG/VurnJiydPnO1fvba1o370zNRjrz5TrqiIJRpb/DpjyuUKDHlyOK85I28oFgu9PQ0H334FYvT4wFG2XFhIxCoGM2xr6MSyBECIdng/ggkWQVZ37doZ9nvuv/8nH/rQB8oVfXJ4MpYe27BqPcsyhUKstbPBoNF7t2xI5DIVsdxU1wCFgSVJ/oC9l1+BjstUhegBn1dqYou8hGBd/iFDI/9gh+BIEJ2gHEB9KAPILJMpkUy11a9Y0b/rtVdf6+ltnJudu+bWu/77kcdbmz2CkIeMqhow5mogWF8uRXKSkCun9qztsZrtrR3+xo7+C2dPJ+JLHY0N2za0DhwbfObJP7vD9T2d3Q6fB9OuamqlghVpLBTKOg1dacqLsqKbaIsVAtvMGixmW3IxhbBQnd/nrlKRS6fb/W7JaigX672tXSvXrGFN5uJFKVVWPvjJjzGUdtVV9t8+97TOcQgI60WVdyPpbhQxzZwhXyxWEEJx2kAbM7SyUPHxtrRY8joDggGGAEWzzmq1SFdlm53z2N17NmzYvm3Pnqv2lgvpH/78y1dd/xEjT//ov374Xz/8Tmd766233B6LJ2KLS9MXB2Jiyc5ZDh98nawAaHaIfzA8pBjRUsQKrrlzhMbQPFAvSOvih5Af34HY0BIgNVFJZLaIzoDsInYU5HXVBJNGo7Lxqcl3337r7NBEyN+iKrF7br/dYJRX9XX88IEHKyKFVJzDFbR5is2hQFnSv/WT3/T2rn/u1Xip8FdXsJ6STXZe+8iHvy6W1A9/+b/OD7xRphkpl4PXC4bhcVNTtZjP2C3WSkXBKk+LqZJk9HGMatBTJa1v55XzOXnl6l5WKVK+5vNHTwbDwW995b6nnzkUCgQOvP72XXd88NzJC0aeQfzXaTMLimgxsVVRhDVM8RUrZ8ECtZhNTqlaKegUy6gl2WZx9HZ0WXXjto/d8cijj0czJakk+by+lS3tYwtjDp/v+9/9dk/f2qXIottvBZ9MncmWI0v3fe7e6264ur4h+P0f3c97vTkZ3KN8/osffuPIUVaurNuxHoqcUBb/ahJlWaSDzDULqCZaiAquhQ8JyaG0QHailgkbw/Yh0l/DRaC0WNgQFl9H5/rrwx3XWIPXzhddRw6ML8yLpTJkElcVZTzGyPnpK/dc/e3vf7+5rSObTTV0Nhx+9dj111958zXXK4hjqFXObknHF71e9j33frJ37Tq7y/rC838aPj3w+MN/gH3FmIzFXEHQ9GQsBQv9uz//UUGoluUy8AOCXozqpVhVXZTlkxfeeuOl/af3vZqYmKwU1ctvvvP993zW4Grce90185GczeNNZNJeoGtMBjvLTU5MWlgGxo+qSxVKwVNSOdm0lIucHLh46Ejh/Bg7Mi0uFU1WR06rhNb3PfDsC5tv2ENZjT07V3MOuKMJQAGtnGP7Vddee/N7123dGo0kvvKVr27atveF/c9a7VQo1Gi2OP7w5z/YLQ6DarRVtf/+7YPAYrVt7v3FN35FG1mAGjSYeEQWwf2CPURCQaAuFDFWHgn9wuMgGgBf0hA6ROsSXU14HoYv2B+zZfnpQ69VNNPI6DzHuuGyeTxOzs7m84LTTJdFw9nDL4wP/11RZFqRrXb+wlvn1qzc2lTX+vSz98erST03e+e7eu795kXgWjjaSiFvJovJqcnd27etX7P+D3/7h9Pjmlicf+LxR+54z92/eehXgYaG42+89dDv/8RYXQxvhJ6/c/fufYcGFhZjol7NMJKDsvb3r43lCjl5cqHCXFcfujQ40NHV/tgj//zWT7/9tW/9NJpYtLudc7NT6cSCOdRmNLBGXSZrXzfyEleendXKZb/HyhgNbp11+zyFivFbP/vFmv72e+/5/PVX3DR24TxrdubzktXqKhfyK1c23/mRj09G5Xu/8rnPfeG+155/+arrrlc1be2aTZft2vuFb/7os3ffETRZJ8aGrda67//g3vt/9sjQ6bNP/+X59t42o5HhNY2GlQACIxUAC5uoX3gAoD8R/CA3kTxEOsGZUWBF0EQmETGEecALKA7Tl/7zpyOT2Yuj0WSeKgo6cLypkjA3GQGvzcTFREna+q73rb/8PZLBVIGfBN9aN9pMfH4p8fX7fnDdZde7vU6NKq1f024xm2E7aZIYbnRxVn4hGWlpa6CqcITJedOz8dlIuZgrJ6IJvycwszBlNlO0mXf6PEeHxwpiuj3QyFCMhbNQHB/NCAaTa9dlOzWjMnzymZ7eVrmiO52WwdOpN149YKD5+ZmlfFmw2DxHTxyXNVVF3MNQZQ2MHInSSsUCiqgyAsL+kN/n9W/e0L9n92a/P/jA7x+KxyLRXFJUquWSQkx7mJ605ef3P3z4+PGbrt370gsvA7Pmr+9WKwrsm6X52Mt/f+rkm/tXd/Z7Hf5qJhF0aJFsIp5M3XzbNTDJjGZ/Y/vKdfZwGFYvx/Mk34HzMB1w+4waQiEQ8ybicUDbmd7/vk9XYJNBHUHYE78I/E93b9g5MkeX8gp8vezSQkXLTg4OJmbnMonM/PRcyO9tCbtUmW5bf8vu276ar1hVQFV0BRAjRSsffvP4sz97SLxw3sG0NtTXHXzj9b8985cjF1/ubGqKLiZaOjqsgfqcUKooMrxSE2eJFfOaWJ6fngbtLt+6Zf/vfxX2eQ1GZnoyK1VtaUZwNQRWtzewjEkzW3inWa2k1m7a/JlPf6Oqm17a/yZDR/7ta3dLenHLji2AFTe2dgMq8LuH/1GL8xggB8TIEp9Nd7vNdXYKWJG8WGrt2TAWz33x3s8C6wD4X30w9MsHfvXqq6/s3runqjO5kiEvG5M5sVDMPPa7n1eFvDMYRJj9v395P+j34pP7r9x7jcNc/c4Pfpw1lHir3dba8IMHn3XZgza3zxcOuTavobOJ2Zik7ty1flSgFDFDMBUSsI86iYAiTUmzGDpWAJQ1fj/33N8YDiFqogoQmCORlSp92eY7x0bnPF0cBJjDaSkJpbnxUaazU1GKCIsuTM3YXU6nL2ihudXrd/T1dD/y04+YNAlhKswqzq94fPf/9EC58LR7x8bE3LywNH98IhKV+E2rO0qC8cQbxyEliYXGwp3UR06/bLZawk0do5Mjv3v054zJuZQ+UVVMMI3MfEhUc3S13OhumI2kC5nFFe2AOQm7drZqnC2bzefTwp3vuvqBxw9ZrU5Oz4xMz1yaipw5cGJxKVXLfsC0rnBwcE3VeD4H/06BiVetnrt49IMf+6wJssnAkDVPVCbkL/PLn/4UL2LJ/OFTx/a9+Dww/WKu8LeHH3XbbKWK5mitlwXxT8//KVfK2CmgpFiCXID7YKKSCZ2h2YpoKOTE73/mU3RVkTFXh988DZb2uO0IhALFJopkBhBIIgFRk4E1WcL1ge9+9zvf/MZPNYMUjy7JFcXKMsVMnma5QiYpi7FMxlapmhgSSzMFXLxUjBporphLAqaSy8ZEMe92BYrzUrjZZ9DCVGVSr4pNvPGzZut6pIlc7IuSeLBa8Pobk6mlTDF9+MBbrIWvlqTZaFararRqUFQ4DphyVZSE2OSUxWI5+tpJEyuuXrM+sjAVi2KyUxxP49kKkcidl2/5/SPH5unhnht2rd24XpB1r8OdWoyK5X6DTDnsFRvFsu6W//jG15bmo1QxVbUwgNTTVQaaWKqaaM1cKhsQu+F4R2I2/Z0vfe3d17xNGXgSE4SlwdDE7K79hPzO26+/Fn9hGf/nf3z9R7/8c0dnEwasKuLZ4cjwwCWkVAuFIswqzSjDAYR/W6Eh9cHN6lJswm0jbAgUKhYxkTEyHEREPtWKzer0erzQwKyBd/L29773zoce/GUsnjUw+m233vqtb3/zoV/+8lOf+XzQF7DxNgmhY0WLL81BegEmL8PbpKqqLCJYWRZLsKBsNk4VRcDrMLJSTqxrakLsL1y1fnJVH22zT1iYOY7Ku2yxjHRm4G2YcRvXrOjuWzE2PrN31974whQy1JQBZAGDarlcrlwu2cw0b2FyuYyBtl0cGRmbmCfxKGNVkpWyIC2mUsl05POffH9Pe1tJEkr5IscDWyAISvnAq0ex7FRBHbp0qaGpPpku6ogYw8LQNbPNAgejZlYQGDNxVZAYMtLTC7OYdrzHclhajJ45cyGZTL9D/uVJqBmRgPB86pMfv3zP5Rxnx2AqUqUsyQglgG8Q1yBalKjNWm0AfF5VQfAoubAINwN+KRIwCLCYIHYqUF40LYqma69eX5TlUlmamZ0R8nkIoN/8/Eeuxr5QXRNvNl+2c+sjf340Gkt+6suf/Pa//6RSlRFfS0WnrbzF51uD/LAGRaErLEmxU4V0vJShsJjK5WJLVxdsg+tv+9jjvzprZ+REPBusVupamjiXXSu17unetWft5vl0QawY97/2usNp/05kJhJZQggPSbJKUeSx9m1MOl1yG1SD0e4KhdKxbFEqQV9lc4IJCR+bWdEqGQvv9njM5ljfmpBk87CaKObgnJvWr2h+9vUjiWwK6/YHv/prQg2o+ZJBLfN01cZbC6mkXC6ZYYFVGKT2EUBFPQyCA1u2rfvjw7/JFwB7ZfyhUCAc4iCE/8+f5flo7ej862MPf+e/fjA2OnTp7ODFM5dgs4D/EMovSRUzxyGkDfFtYLEOjHlZTKVKL/3jCAI+kPiQOgSpAINGkDQzb3j9jQNHDp986/BFxuqL5uSN2/b+8lv/Ud/oBsr85ttuiKWyk+NzK1aufegnD9MGs46IPW8X8+lsdC4eWSyooiAJ8BaWEhHMuy/ggWWFgFNXW52qyBAhM5FMtlxJauXXYvOKXkUsxRoKLin0WyeOjKO+wG5Hcg6Gb7ZczuaKsqQiK4Pn4HiEuj1m28q+9T2tTY3doToXywtFfFNVVYrhGeIuShVNoWTF0LjqMrfHUVdX19q04eBbx/BktEJdufPqaDLBMBwQxFJRpwsJo1REGBWoQEnKlYUy5tditiNsSYwuRPtNhpbmxn888yigrpHZ2NCFcQTTsRqXlpK1+Nf/OQk19cCzxv/67lf/+7cP+P2+i+feqjm1QBtCmSJQi0vWLEyMEQOt6qHO9qdffg4WDwmzVhA0NyKGiEkCSgtyG1qvarEZ7/nYZ7av3nDP3e/+8VNv6w744cZpoE0i86Mj0+PzC6l8RquWEQhVDZYC8lpiHL4VQj0M58Ctism4WpVxXdZmnZyaiqVSSknA6lMqxlDjuhylL7GCwlEW3ShYPHd99P1es3vX5Vd89tMf+vpXP+8JBEKBBvgXWPz4pStVBXgxQUotjhuVcgmCSMyvb2+47abNV2/t5xBOxBG1sATi/Ui9vnF4f0mE11E9cvKQP9BAmfj5WOrY2WOSJMEL8YV9BVnQSkm7UbfC+oSYKKU5g9Fls0i6ougKyRVUK8Wi8Ndn/5HLF7B8oQKtDtvI+CzHM+fPX4Sk/n/OAeYE0degJ/jr3/9m8NIQBg7bDR/Kkrxs1qMUTIS/LWsMTbf5Q4DqYEahA0gQmThYxP9COMFk4g0Nja1X7r16RWfgzo98CJlM1soeOXxwemLy0Mtvvv3GMb1aaPC5KETV4LaRtBq5BoxpoZTBfENikjWFLAerl4olI8sDNCSV5FJJFYpypaqxFh9rtSnIoRmZrJTJsuWHfv1gZHECI/7q17+zbctVDeFGyLF3/HKktfWKKBTKUh5KpcqwcEaUqkEApE7TDp4dVkiaBvdH4gSxEUjXaiEjVZBxA+CrmIZ0hmlXyGbPDg5iCbI0iyg/V+emPdYiIAYOl9HjjAtmXUKk3VQWRRLWgoFpMKEEopCFfQHlBZSO1rmiBWF2pJ08HlTB0VgjJHn+fy+Dd96vWb0KkceatV5L7poAiq35VKAvVeUAjdKpHZt3RuJRpNbIOSTAA2NDR5oXIf8qZW88P31p3e5tkxNL2dTixvYOtZyLDJ6PzWcff+SR7Zfvhrp79aXngRQCqxA0KSUbOD6VSVK0w92xWihnVQhyo15KRozmeoMdKVBVLBVYm7GkGP3m8PpNe//22PNWM3eeUlY6Wn4xXjieTTsNImdS3nPXe/G0UOcBl7soylBYQMlAPeF5FI3u6Gi+cOYU8vmTgnTu0sxysYrRxMNygCWKxL+JeDBcOlsAIFsxZFM58Vs//J6fo1b2rTl09JTF7l4ZsjY2e1evXe3ytDY31lssdrOd8ba6XUxLLqW6ODOCzwzFKhXpvs9//r8fenDr1k03v/tdiJ5Xq9KBV14YGxm86d23nTlzPhwOo6h0WfqDdYH3AVP/7+k49NaBrZsv0xWoYhWZHyg/LA8oF5I8qVSKUhl1pQSDaeVpQBNMqmIxwSFGYgfRdr2pznvPhz588MjrcGfgrR1781hT2C3kimY739K9EglHr7UJDqHZzCD6aKQ1luYNRiQjJamYYqqo3COxbY53C/lsVVbA+QCNysWCVCi5zS6TzYSiAdoShuu03+T+Skk7eeaoYXJWipVo0SgLVbEkK6ViJp3weV1VFRaWjAGictPjD/P2AG/3yirFmVF+wJDkNaYLYcRalhR6DG8gRhGaKsjaQqKExZHKF5dK8lunLki5vIVRu9s8kxPjj/39mWhRLldMKUFeXMx+7v1fWDbxXW6HxW6pwAPmDfVtzT4rG1vMnTkx7HC7ssmc2+OD6ZKaX3j6z3984pFHhi9NEPajYNonId7/N/Xxurm5fveeHQyKvGoZXQ4hQwvHgV6a8Ybrd99xw8af/+ZBHIa8OBxACnkexBmNDEu820o1ARd2dM7AWH768x/ExgZvv+1Wl9+1dcv6kdFoMZVUFCWZRkC/UkFGCdknTVCwqmzmqkgpUjmdiTKokxEK8DpKOSzs2bxSttrd87H5Vf2wkasmVZ9PJxs2X+Gqs95x49UtjtA3P7l31iAZzRYVXIvlCD4hVohmNnM+nwuoDI5hGBYhqlJscfRd1++CrbZ207p7P/w5mOwYPOQnLotgCdYB1oqZ53iOSZTLZVndubLxoZ9+b2FmGnxYkgrPv/LWqcGxXEZs7FixMD87NjqoaPrpw2dvv+XOhqYLq9f07tv34ub1G7PxpMVhLZYSiHEvzM26nK61m1aNjIwgYAeNvzA57XWzkcXZXCZBUZ0ytJqmFAoln8/9P+YpZgOvH/v7o9/8+nf/8Lvfk6JpJBuMCF7CTVLPnx1dt6Ll5huufuvI20TZcgzCbMiAITprspNch1mXkZSVy/l8NlFoampa0dPq9Vpuv/1mIKXn5hbiiYyRIfiJ5YgESXCTLAAmDwpFU8tllmPBEDSC/tALelEuZXibq5jPQkJAHcG6a2lshMDzWMKHD134+6kLjM+tgsmRZiZJnVruDZ6EKsdiGTA0It+CjOobCba5kM+kI1E4GZhFGFr4wZPivhChNRlL8o1gRpfNLImIvipweRMLi3KpKOdzdC5eHwhWNIPL7eV4WzgYDvtCAaf3lpuvT6enYBoYinpFouaWZinG5PEHAWVANbrVwmu6jNmdnZ0FJpNkZhGUVTUnyXUR5Bi0TqkoiJL8fyyC2npAFOcTn7iHmP8wBFVEXwA0ZGiec1gdgyfOXnHdHkBNjHYLah5Zu5WHLLJA/1Zkh5kpSQ6V8vAcah0VB8cH7Y7/+q8HW8MonbSh+AtrXBZhBhD3AnkcuA/Q9GazFb4GaFTMJZDQNZpYl6+OoqwVSZMLMZvZa9AlKFGT2YEKstjS/MbedUqW9XjXNZuDM0NzNrMTBjOxBgDy0WC2QhlRbpcd81DBnCmY1xKQqR5PiKYt11xxky4zkLxwfMnCJ55SDdoBwUfD6+JU+IOwcHUqV2KrDAktmsy24cn4i6/vI/5NSUouzvzz8UcL2VRVlRLRKNLP7//wtt2tQ01rmTuuutMdcoTrAoi32F0Of8DbsWKFCAMgJ1g5M2ytwcjFuWQc4SmzmYWJAd8zurgklmHFQsq/8yPDA6gtgqamepfbjrlBPTfi9sQUpaoZUWrduD2Ri/7H1z+PLgQmVF/jSzg7HNQI8s0mw+pVfWfOj1d5DQUyA2fe3n/04t4dV9//wIObNrYWDywAri6UYVdh8ZB4ELAuWDtIucHtq3K2ilwSxDKEsgmxYrNPKsyihnJs4lxTY9vwuafd4T5RkbZs2glbSS1OTx47fWFgH+wyHma8TpBIRKoCe4HxVNTmhpaGYOjYufOoTUe2S6uohbxwKnYaVTvw8vFUYAbwPrGvEVGH7caxiqA2d3ilUt7scyM1NjGX3GFiTp65MDw+oeQrZUEBYB6gmjvedWNLY73TYrK4fBZ/aCEy8+IfvnXFzh3N20L/+Puzs9OpNd1ryrkigg7wsJE4rMgS4GEOs0tBVlpNwUw1MaxcZRdn54L1QXRkSKfT3d3tNY2AHGIFA/7XXFDf+s43vvGf3yIuAAQEnB6bFTUZJSkHmOxnP3MvcRJg7WFmsMqI9kIgSKoMze175LG/PfPck488/Hj/6tVnTp9oba+bnlr42v2fffnAIQh/QC4oA8AACoPoBHEeVJa3kxidXinmUw4vKrYpNtzq9zfElKwkp8VMqXnD3tHBUyyfSsUuvpk+DrcDGhzl4AZVIrgPDQYAJAoJsyLEB7+wrrFDKItYsgR1QXJ2SCUpcIR27thlM5tRLkhC6AQdA+pDBpmAF8Y0OQJWtL4oC6YgGMIILILx3k/dt2NN3607tn39J78usAycaAfHPvKXhxw89CI8Xyu6BKxpaUxy5ZHZv9rD7YeHpzZ3N/pcrCIKQLVaOCZc575wfiiVSIlKGnVBsEARDmrp7ikXCkaOHjp/mmds8NtKQhkoEOLl5goul+t/JuDO97zvm//5HSgnE42AD5a0ajXzbt71+vPPvvu290GBUSjxRXwPcwDrD6IdYhfyAA7ypq3bula22ewWmLLFUg5k511upOgJZhTeAqlwAemIvgQJEAEGEYBEJoFDpGlgfKma2+lRyxWbzYP1J6nlYPNqgJOMwEBoCgfQDHSSJkM6QitghcIlxKkwaTAPIK7Ngeitvau7A5IUq2F5GkrlkiwBCZLKFQogeC2+AtufrECeZXEXm80M3BUCjShMQxh1enpu5Zpef2vgzMBAX1eLyx8siYV0KVssKhlRcLrtRNRUqNzEgAV1EHbm5eOZjnpq4MyCrPMQhZhZl8MJOysyH1d1GfYGQD5YndD9To8DOUCIUwHKXpIxbhRDIJ4GdlCwXAAj+tcPdC9UBB4NMgnawMyyTpcdxsU1N70P9YhYY8B/gvYUCpXUqoCnMls8V23evWn7pmR06e7TR6+++qbv/uAbTz3296XIzD//8BJwJUDkagK8e1oxVBgFc2aFdACGg2GsJlNZU6RatgD4kSL6eLR396t6eXFubnrsYlPXhlQirpRnEHo3oYxVlddu8Y3NVTIXyl4HguFVCVYzifwbYJy1d7Q01DcAaaPJWPdgZ+K0Y3jQY06Xp7PTfODNtwAQhsuKacCq13JSXcgGIBQHNYA6NTRdyGQawubc/NHmK/7t7enpUCO3GjLUrLkdXkMUUURrqZzVgXv0ep97/YgpyA9LM3dsjK6yZpUbPqvSnqyahX+5btt6ULOoCJIqcERDwaMsGGmms6l5IRaBcQA3HOEPhwvCmwMnSZC/ZeF/zCHMAiTPhz/8gSf+/iQsRnB6qDmAMLxaEYTiPO9pBP8TL7YKqQtxDq+fABSNfksLrVcDnkB8KfqZz3x8c//ah//0O6fLzDFu3ujkDXbcwWr2OWCDqiXWCssRoWJcnCU8A11cg1ggDkmcS4uT4f1dKzYF61fBb+vu7aP5YLkcoZVsc13lk3cEvn5v/fo+7qrNjst7uo0ABiLcQZucLmd3R5eFZOs0r8MHZDe0AyQRQMVWq5lluFwmjWQ0lh/sbPheAPTxZoOZ1kNed3tXq6RmE+npDWsdR88da2/b/aWv/uzA4aGz50ajF+dmR6IqwPZ1LsFRkVyVNJtkqdhnbtlcPn3GMXtiXZP5I1/6hcuczSfnsaTsZktreysJHzNcg9PNM3CZDPMLc12r2tE2wGuHmkEKy2j3BmgLf/Lt1yZGh0eGh9E75V/cT/7HZHz9m1+DjYsOAwjkoRp7bWvdzPSCw2KJLYyhUl5GCIhjabEChx/grCprrI7Gz6EGyYQ0oJQ7tO/lHRs3WG32tw+/+aH336ObwA1KwMf947m/3PepPX5HawF5aRaKRYAda6Q4GOMAYMFEQcjGF2pE8AvyOxD2xqMpB/FxDG3rrh4+mL7nKzdaucXzB16qa975obv3FI3My+ff3hrsa1Ea5hITo3NRBshVPJvT/NlP3vXjB3+Pgg0ajiKCiTQ/OTVi5hyAGCGVSIIo5MfAGUzh5hX5VO7ipZFWNBXxmgcuDO3YdcOpsWkzC3Y3z8zMWayjxe62w395jcSDSdhLhU0Sj6V7V67cs/eKxrZd6a0fKxx6MJZD3RVUjgRNC8sAc8xwxpJaKFWKLo7xuv1dazYMT0y1tTThoerbOmaXImzcpAlAyRgaGxtC4fD/ngC8tlj4yPxsQzjQucZpcXssfj+qqmfGZk0MOnIgqwleYo0sy8miTPAOKuw+IZ+KIIQ+OnJx/+uvfufb3y4KAoLci/NzCDJnE+pKX0WMTj74/d+5PK73/ttxh7+myxERJgvACKsRl4NXBelpc9gykjA9NyQV4LZJiBpEp2ZWdDX2dRuqGcm8tn4qtSTEjNWurt3tHRwXMsX9Dj83sZiC52LSjSgDqTCUrMuw3CGsseRd/gBAlwF/UFJUBBpJjIX4A7CfQU2ua2Xv4JkMVsz63Zc/8evfbe5jy4OSz27xOJyX3dBWKiEMm+5d0aFzDIbIyVVRKw9dmmxx+VpcXQeefUVkTinzstHshZCtoAaCYtF1weyhFFmEqiFxSgSyaADDADwp5HM5yEW5JHr9frhRrYHV9fU+xFprI/q/poBat34NS+n3Xrnm+XMT6XzRZ3flirlqRUAsCO67VhRUkwkAR2LJlaWyqViYip155JcPx1JFqPXI0lw5n3YGtC996a7nz14sz9u+eN/lwxdfb++0+gI70Z8D3IkUpg6Quc7BRhLUCmdidV0QxSImzOp352aT9U1eZHWNFuvK9S2FuUMnX57Wi9WlucyTh4ufuO+yqeePbeprDoamDo0N5ZMybBo4rk3BzoKUOn9mAPZZSZJsRrgwVhXK0aDPzy95vL5CIUf8NwRZoMT5apOHuXpd8MLxfM/6huzI2R2Xbbx6294bd9zus1OyVpg8c9LXWN/oCaiCdSyZMrJifHZM4V2enZtnz8wHe+xfvuyThw6fW9IaKsQRhdIxeOrsdjsCpkYRtMZtKpV8XsTSGzo1CLOvUCYCcNXq/nxBtFqsidjs3OzoFVdfiwn4///55S9/+eNffP+3z51VM2I/HDpeLWcB35+gSXCS2OQEuI4MELGCTHQxiSYQ1TdencibqQZ/8Prb7k5lC1//8pXZKj80eLKjt+nQWXphKqEaG+vbkc4jOH5Wq1hohyJWbAZO0VUeokLXcql4uDGINH69O5TKz3C0ZGPMSvxcb2/nwOxoR0v4IzeFO7YZjqbhpPEXjg4mUyu7Ao25YAnhBJRcRvW5+aW5RDqGOLzbxq8OOAcyCOeSeHm+nCgX8ySGWNM50F0Wm3VuYeGIy1gFwrTqe/K5A/AispHfdW3ZdvN1t6pFqaPVcfe/fe+jn335nluv8LOnhofOX3Xlx6dSQnvDyi9++t7IJTHhLj3/xJudG1dxnBUyAL6UxexBABVJQvj0gB1ieZdKOafVOjc2vPfWO412TyGTHz59TAJIQoA7XG7qXlsbz//Wwe/MBW+zf+sbP1gd7OxZG57MiTua2CMPH/1K5DlgqZGeJCUmqJUQSQDY6A6Zq1TpO//xkLneQ3NmBLQyxVxzS1gqt8XltDncfj5RPTb99pXbNxXNllfeOGV2+xizVRcVYP8LWUG3uG2iqLN5jWMpWS3nATlVw/XDtHa2TYnA/lXWr3NUzFdst5TH8gePq5XGzokDL3XXh0WXL5FUjL7WiblRSVSnDh9ZvWaVklYTC6kKOk2IIjqmdXgDspSLz89bnVaYSROT07XwhYG38Cv6+imlVM7D+HSODi90rduGHFEkVr6l94Z7PvXlpcR8g9v4tX//9iP/+Obpwz9jDcWx0WgjOi14XHj28+Ox6cjPUBTds3q7zeEijg60vdnc1loPNwMer9PtK42JJkXPLqabuh2wnvP5sg3h1unRsckh1EAYdaMnCNwqHGASHvl//xiMD/zjwZf+/NfJxSN9fF3znjW/vOuvkKHgHkQA4NYiIaNWgAPXYAS6KqaV5YwZmd3UYpp3WKo8n46Vbr/u6onRaajaTZsuAz7nwL5zibisGXIU3C85nhaSGpUTM5PJXEwE9kSDq1asUEs2Z1Rlzta3dN183fVrNrZbFK2j0TpwPmXyhZlw4NCZo00BJzAEqYrRbKis9K11WJ2s1QEfSyvNoXSwoiCAwckVw1vDM6NTg4VMrCwjXqoCa0G4v2ZmIH+L2IDL6RNhAWjy+ORoPDmcLU7PRKYPvvZcdH7SzNK33nj7henhoiRKRsOVN96ybmM3KcswsOkyKUZATqwqiBwNOwQ5JDiECNJYbRYX9CpYlOc5eEkygkFFcgc4/6OnjqUX5ibGhjSxZEJ7H9gClBEx2mXS/z+lEL7avHH71PiC0e1NO3z5ZPK9//EAXcOzkwmowIgFcpuz5WT2xnve98ZVdzEXzu4afFp9683+d1192/b3fO+NX+8/f2DPR65Jnh85+MzT7b2N11y1++jbBzdsX1tYOscp4707TXnaCv+3wenwN9j//MfTDe071jXJULxP7q9sMmmfePWthdjSdz9658UhZXQ0C9ABw3blhDOGakshU+juDMnGzHef+e6my3pWBTRv3VXfe/ENKrXQBk2pC+9f4brl8pZ7/qmcvXD+w++/y8gZH/3LIHw2+H+4ypr+leMjU13Xbz985Gw+U4a8/sLtNwOc/MSjRwanBqw+D1qrPfLkY50dva1hoCebaIvl7nu+LGYHHUarvaW3ajNHjr/41GuvpjNxM+pnNRlzYuHQWEG32d0QENlCCooYKDSAAfBWKQJjMn1ycYxiicOnEG+UkSuVQOhf9g9JvBDm+L9+LFaHwBpNKWrgxOD2ken9X+ggCRkEAgCAQ5pI5sxcXZesSTOsoZ01Xb9u7Y/ns/07eybM7X87utTReqedrbzL3jTte6lJdVk3cn9//J/Ixpz8r380dPGLIxLcjO//8f7Hf/cHKTPLVLUvfmTNmbnhE5Niz7qVoZUdkbJwWf/mCffcg5OL2wrNX/v2J7/84Ct17pLN6r/+jm2Hzk/J+cWSpe7a2+vFTEXtaM2m5Ge+fVObO9jFGqYzCeGxX8QG4xpVL0uFS4ODjY1Nfpc/kc5bKKnOY5+dmzRqKFgCcp9BCswTcD730uGFpWjA0SQqur8uxBrp1NxE48qmtb2XFzLlmQvnN/e2AyN153vuNBZLeUFq7bnsy/17nnvr4CO/fvKqXdtlUe1r5dwOk4zIK810tDYm58OXBuZRYAIMMn4QO0P8EZleOP8gPalook1unwtfwSYjQS2kaBj07fk/pgDvfvarX3zqgx+PW4zn272InQBxg0VWySCK7goDPlUQykgwsqJ1Mhrt8Fg/fevW3/zwqd65S04xdtDk8XoKf3rz3yzbt3dGcp3Nnau6Vq1es+bCkTObd3VRZbmxLpAdfP2qa9ctqQZuofDbh1751d1bX52Rzj799HSw2Wmxf3Z7k3XbihORuKt+w3PPj3g7WtKlMtXRfHBwrs5smFjIqy2ufe/+4C9++fqkc7WwMGQ698jgG1OeL3Qr55jmu2+1i2X6/omt9ba6huYCJGChwFaqvX3diNtl5pNtDV3pVM7tCgPzKIvFybiaSFXtfnCiyWU3dnd3ffBH352anLJa7c6ukJ5r+eDH71Ny89W/Cwt5Ktyw4vXnX7jiul1PP7evPuA1adHF+YX9hfR9930KgSpwO2uiQgGXlWFbQkHE/hC2QsABfiH68SAlAgiR1YYCENlsMxMLwWBEyITcGJ4n1BcW6f9aDP39G+ZjWbfTzrnCkcQSDbw0pqV11cYoQh8MVxZSEHysarqQr3gYrYs3e1d3xQ+85aJyNqPWWpD4D3xVml/64tevPHj45LHJ15KR+K3vvSYvZVWjdn58MjMdKTanJXqVi618/It3CGNz6zeGe2TP2bS+aKgmEtVEYcFpNT77xm83dux6V0tHemlwUJav2XXz0oUz3d1J78b2h16/cMFqUtJTu1ubAocdI2cpthhsWOEsjw4bOaXdG9y6bXeRKr51ZlhFWRJSNmZ+Yg7RfGrHxu37Tx4k6xkVQrJaRHrGSOey8X/+7imrr5IvK5HYVDK2YG7pVkSZNdBf/ex/MMasnFcffvOlY8eP8B53V88m77FBlObA+ehe2fbIX16AZEYjEx3IJCR4EbuCY2a2wHdDVhm2MGQMbqfIKtDR0BT4ElOCcA8a2KL1jtlqRVyI4CuqOpzq/70Q7EhE04xqqkLLGGxWXhCV+p4r3TbL3MIlOMOI5PVed8+rDespq+GmrZ4NsvrN3zzDLiw12dhAIX+yuhhmLYtvvvLhT1/TuX5rsVJ89eG/zkvFG7dsGZueVKS4XKh+5N3X1efinZWStz5sq2s1qBnWYo+l6aVXX+nd1U3bWI3xJJJLykKkbn2/zniF/FKFMju8LOdlk4vqECUMnBllXet6m8q+lx4P7eqnLCsu/eHJN89Sdz/58+mxBb0SOjIyuO/SSc5kbnBZUBeHtmqSkIcJiHaNsqbks0XOTAEG2RrotDncC4l5X8i3dV3n+WNn1u7ey5MWwNXp0alQ0M0xhvqe5suuuAupeqDj3E5nOZXiDWqWJOKrKLxFOghRGqZSaWr0IHaK9lVOeAZIbyEcqaM3oZXgAeHrWE2Aan/yq19F8hUOGpL7HMdbbTaCkKrqTofjf0/Af//2d7/9wyNID0OCkQJ6q9NcSk0uzTMOJ1MhCBDNypjqDOrSYEns9X5zxrzjw5/Pvvp04vRr+VKByswFA44Hnv/mCxdjpcg5r99+/sLCU3/6dcI6ZY20XOE0pH7131fVe+elueKRYafbI8yPzo1Efa2hulV17lvXc26bzgXkpZRvxTpDzyaEcfIDBx11oaqaXzi/4OLclqJgK4xYmBYhM/3W9MEbw+uFwch5w4XLT73Z88Jzs9kXt2wWH3u1YHeGeIpwHsBlUFoMb5YksT5Y1xzyxaUcUNCMqt+4ZfNCrvTww//d3b9haGhk3779qF3r2X3jay+/jrDa4dPHgAfesKorgiCKYJI5oPbSlCKgObNqQCxaJoB8mEP4Af+jIKdYdNoBU1WRd0FbQ8CWK6pWRHkzSgmh9BGOMlK4gtHrhzsqSxKChkAKwE9EzvR/Ux+v7/nYx1/df3jg7FlSDwyIhA2OvCq7sPYU3WfhjHourCYaNGODmoz84oFrrDn6sYfkc/ul+CRPq6u27Eyr3H2f/IF54bA9k3T5LZ/b6R84eFr76wFt/6uBIsNW0H46Z8wbgFXLCMLk2+fdLofFyubOjow+dTi6/2J1ZF5nJHluSIvNWcopBxs899ir+x98YeDA2NBLJ0zX3rjqlo+rsr/AjO4oGHKTF08kYpFC4OiXPkUnC/qR6fxrwzds3PWe628K+bwAk9Tv2ImFCOQtwrqiXCwj3l4orOpoNTgth06ccti5JaEQSUUqxooLctdu//nPf/L0089cvHDBhl7YJmpqMffXp462NgexegB4c7EoVKqKIDhSpEgz16pPgQGHVQpkrdcVRMARaheJFVmV4C6AX2kHvNCqghC8oTo8MpJKJnOZLOZNkmQch9SYKIj/1wSg+PU/v3gf2loJJaAQdASRwESYb+CgSN4VSfoSmkKnp3l52JsbPfSDz9PjB81aspTP+StlPjZQWDxbSQsXxhYvDgy9deDtrKi98cZTMVbOTs35YyNPnNTyhUww4LfYXW88ehQ9XE8fPNZ0/ZXpTKF96xr/7g1FB0/Vd6JqTi1lM2cGi9GZplbv2h2d8rSw5vrNhUoBSMLjjxzQx5fqm1u6+7Z591z9u6cTPz449lp03BnIVjs7I2d/m5h4pK/dlUoXpobPCrl5lP4BGwoxnQd0w1S12xy7d+xE/9NUIXPbjbdt2LK1rj4I2LYgCol0siAJ9b7Ahr6u1vpQb0fdh6+96r3vu5mzoBGqikbZCH6TAnbC/MTawQ+SdSAlhLzF7gTSCnID76EeQDFoYHIgFgDJAwDPgtbnMiLSMIHA/hAyEDA4GFoB2uJ/pgGvNmxZmy/kcSqYHt2YaLOzs2jMWYpiQVUdfv8ioFBnnvDJhYtTEw6c3NfNCCUqsZg2Z77+kf+48fE77//JNy9On6Gs0l0bLk/Nn7r8shxjdm5fv27m/IXf/vH90eMnFbez/+PvXfNBIfLyU/1b21/40H09t1zp3dRXnJxKHh+99Mu/rtna57lmNxOKp0+8LftMLa1127f0s74wJRUqbN66mgpyVu+m93CMmLn0xOknbkgH15uVRcaox6oB6ehso717OpN11vvUmUiMN4HNgIIABEAx+HzA7WYKa9atkzKlyGJsdnoyISgInSqwNkuFrp7eu++620Xp8egkoudCOm2pVppcjt9+7XN/+8uz+wcGkShjDBaKEqDkYXKi1BjeHqo1DA4GEK6KhKAkoubAFwDVqAK9S9qNqRrLmTWl2rGiMxpPA1QORY0MBcoI0W4YyBRRFGx2G3JKJCWDeYOpSlV9QR+8H8DT0SoLlSkZ3VCXN6XNvBW9IeyjpztJwscwhAY18dSmW2/4tw9/8Ud/e/qO61s8vpBQXMwl5uPDkeMjmYOP3v+e3fxVre2+TD6Ry/HBUH54yN/Vz7Cm4tCEhTPUr9uJAIdjZY+3LUwBGtPeWm93NVy9S0PNbm7WHQ6G2tfjKeOzcc62SDE+SzAoX4x9YWtnIORmtAXY15sq7Sb79siLT06Op+gV3KnF4bCr8w8Hj7gMqY7WtQWXNDKXb7f7pgUZUTMZbYzM6FnKZ6OpqZnx7pXNhwdiyMgXSyqiOYFgqI2mc5OjMm+FPEJkG8mZeEL70fe+R/EAryE9S0DYklJAtxA0LULmt8qBPRlOcDkLmK6CAcpdQzcLVLRzyEcA2oqkOOA8kqah4SBwP4FQUAEW12gSFNS0lTkVaBSsJ5L1Qvoe8CzSBwFTUNG/8u//9qPv/hzJP/R7QYGpmTWx/mAA+DIcsWHTnhu3h3xyKmM0z89PxxYz7/7kPX7ey7IoabbppsoP7/7AN3/363/e+74umKys2c87qZC9p55JFPmOlV3nD+xDOaY9WAdQoN9imZuJd+/eYPZagF5H2YdJkmNz00YZQSd/tlhu3r2lNHhx5sSFUO9658qWipFDYQH8E8g8ef4cym7quvs1VztylMS+LqVsXjeiCZSDlc8e9e+9+p//+W06vPL+507K/rCYQ6GRQbHoTeHmrWv70AdiZOhiyaJu6du1uBh76tmXvG57a0MjtEXI5/a7rH5fMBJN/P2ZF0lKHMBGgkdnEJKB2wy0LKQMT+v3bbpmdn74hanZ0Ord69udyEBUFXTZQSybI2VTBpu7jgd0mOYZuzuw8/Ir2npWiIIQy8Cad4rlEu5ld2KugTxBoSImgyBZSHJJp1576c3Pfv4+xIIQt4QyhsWqEO0BSEhF8ehFMyU//+b+93/g/bHp2MYNm4Roqqk57HHCoLJF0bn+XPT433/TEg7Fl+SR6fiBt8e7+povDiwNnx+//97fB3zhhvoOn98TrPcrpdLKjWv8azZbGgOc18kgqe1yh9dumF/KnT92qbUjPPXUq8mxsfrOekCDaHSkLqXNrGqsiMBrmLmQ3d0hljXNaEZhVF6U3IFAKVOGiY2GXcffOPPc7158cyT6wJNvpkzGUqGM5LRULiF9MjU1Obs4K1P6ZZdtCLvC05PzbmeA8Cz66wDuiNorTRNlOZXPnTx31uywQSiDJkgMkqYmJCqGsiCwAVOnWnZy1Kda12ygjKcuHqNNqAAB/AlMT3LeUATE0id1QiizAAV1tIDJ50s0a0baHCIRXA9BBDAHaiaAdlBQMQBYElQBQRdRa7f3AlGCajCsCBSFITkM2UXDTsAiQKvcK7rD/evWa7Tgclmy44uUxVlhDK6gR0pO1nc0NzGM38ErYyekPH/uxIkde6948a+P5w2mpVJBXqL2bA+EG91mi93X1Mw7WCOWMzoeMPyxvx42Vcq6R29ftzG8shXFq8JSWizk0cgJCCGj0ZZdWqRycXdLvWSvRzLKYLEmjx1QU1Loyjte/tqXW/raVu7YPH1+oP+2GxD8Ami2GFOZcFjIlm/63J9tbl7LVrNiSbGanG53f1fz8NDQjrX9fz346o61V0WXIgBIA6DmdjnNDF3nAcSEw74T03PzsD+sDGr2JkoyRYrkUDdNgjPIK1VvWL/x/NK8y2j4yRV3HV0cnXeZC9k8enOB3KinQwKXwJDctLNqNVmQYDd1rVu3ct0Wdzg8eO48ylKAVYL4gTvhtDttNqvDDkSWFUAu6GckCoN+n9nmIoUB0Ow8Y4G3TDB9PNSVsd7Jvu+6XZrFHlmcu/qWW1bXuePZzFuvn2pa5dfGZ316vH1Fw4GH/vjmGWrNGteNt++9ePTglps2T56bn8tWH39qxGWmtqww+Cr8mruvpCU1v5S0uBhv2AedZgk2ihW0gVio0k6EOZWcFO7ewri8iriUmx1XJxMT5y/Ub+5o6l4XT06KSYhO2dbg4F1OY7GSiKViL7zmWNXRvqU9mRE1O4vwSbBnA5Wfv+t9v5u1WZoMVpWl8pQRoXkzW0X15K716+dgKmUTDGd+bv8pxMKANUP8oNHtM5jl+FIKScm6js7zA8d/+I3vHTl2dGDwIiJIQONhkQHoAEAtlh1rpsNl6cmv/+i359+qoh2VrpcLgt/jlRTR6bCr2CmhiumAV25v6+tg7A1Wt9vnsBTKaWDdiZkD6EOV8XpRdORCbazVahm8OP7nv/zppddfS6aSZKqR44YaIbByUqlZtbr9jf7Aj/7zE5dSafS2unj+/FUb1wFIFC8z7NK05eC+ZDlua6W7XOEtX/m32PDkPx55dGEw/6OnfvDCd75p5Fjvzs2t7T28jZGj03q+xFktEDtKLsv7GxePHrj01nS1o+HmT92VLms2iyU6cuHlHz6f5ai6Vqq8SF1+c29uNi/msq3N5q67rj/2yGtNa1eH+jaibYA6N6QuZaw9XUImpxslS+sa4MeR+ARa1unk5148+niEO/jGYaxlBGR0xpiT8Ew81KCkVVb1dA1NjyUjaWz8QcwSmgk4fcjO5QolgyZHFhM/+OGXf/OTX7e2d4xMzkAcubwe1AzkgVsoFRjWgow8jBebLl2zfouCNYJiClWzWW1QwnaPCVh5BvwP2amg7IMavjSaLyGFKrgDVkg8pIewQUkIxa7NzmQsndP1LRvXZJLZ2YW5SHIBSBY64PGiTwxKwyDdiDIm+hqNtaZnRidddR7kn2JTE+cbXXe/555vff7TS0NHrqAp1Urlk0pmfOoPV34mLlKfvPfK0wf3f+yOr7SFqFu2+531bs4oM8C56LTNa0MMXUwVaF8dGmrYO9Zd3rKK61qRTcZUtJhGb6MCv2tXy8GlKNrQAaplrOY23bJDiE9n4irdvMcfvuBraiyn4jA0lFQxNjPR2VsX8BWzS6XM2cPOlqAh3LJ05tT08IzL7zQOFayAsts5ZOJgzheyQMpABFShEo8eO4nNJcBrhKUpBqldYHVNMgrmTB5XMGDzjZ4+t2bVSlfAaeaIhWMPwuHiXn1tHwGUAxpX85NyIuDxXEXVCcgWQQqgVGgeZhIiFSVA3QRxMZpxtTa2tXR50Jnt/KCXJDUsBoqLLhWBSUwuJlC009vZK+pCwBsYODZAob2zxWL40Y//86///eeZWAaWLIIbgBZxLi/6bm9ZUXfNhj49X3C1uo787WWPRX7iXPau1a4DF3Nr7NRPfnFzyhiiivLk4CULbetd1+jpXlmMRnKzk1p0XrU7/D1bDIxHkjPGqgDjzGqxoZDzredfCGF1dTe88qe/b+1GmUyb4muPzgyJXMvs8VMb9mxt7q7PxoouM507f9bcv0MuDheykrd7bfbEETFXDHV3unxhhORVgB3tvDw/6+xab5w4V+FpLbxeLU39/seHjqZlCpQyannSucKUR26vBB9BxIOhlhDqD9E7SGGeNfPIv+oy4m4djY1tbe2pSAFQ3dPnTvT0r4qgV0g6NTE1jzw3oBkIL0Nvc6xl+8YN2CMEcTUsCALbgsdnCQxPDzF2D1YbREn7yl6e4zrbO0tCfn5mqrt3ZTDcCLDAzMgEEtq5XGLt2t7fP/qHTZvXxRaT50fHgck0vOfdG6PR0pkLk8htILkL9QMj0Ia51vPvv3mnHIu6G5quumHX0tH9c0+/2XfD5tPTVT2VTkxMwRm54xPXjI1OrL1sVXF6qZicKyymbJ627g/cZOd4ymzJXXg7O3x+cCCFx3cHqHBrz64PvS+XilAGMZ/LsvlKKrKUnRmpD5snE8YV73q/PewFVVBGUEEVembKtnJDaSlpdNsH//y3zs56Lhz0dbapJnSSSNNOizCzUJ1NubZuzmWmKGHB2nXZq7997mQ8NY9doQQbvGLwOSzqpKlaliqZYh6lnyAbPFKWgF0AZEUcQgcCAZGyLRu2oJPY7OySoAoNda17t22dWxzPi+UjpwYQ9aGqgPAxLGMN+FxNfj9n0jmgDwBfYHhUpI0vzMEVZqxuJANCwSbUQ69Y0QYb5+23DzU3txXyWdy2f/1anrM2BHyQ8Yf2P4PyxdaO1hMnjoaCK948dMSwsqcRin92bAH0B7YPaD9gz1AuScnJ69c1fmDPlqbM5LFIOj66YLdX5mJUkaJ8Daw0qWzY2YyGXIW0Xt8Y3nTZhhI64MxP8/2rPOFGE+pSS3I1Pgl8VcngHH7tVaOtuJhSzAY6iCLVpnamvs7mozTOP3j0yNzAaH1js7/N42CBll5hrFrGD510hAxN/ZdlBo4p2Zy1uSu6uOiAXeQC9JEeefqfrds3e7Ze7upihEsDRq41e+50bnY2Jhj3LyJLIM0uSbrbKSlcEbBIHVVTWklBnREAnQg1woBEuhBGHw9mQ3EnKpZqORVEBASJ1m0mpt7tbawPwAw9O7TY3LEKUEQ0bqzIuo0zWE26haUAO8GWXxDuZbmSEJCMQYoTSSDe4/PXh1ra2utGx0eRMli/YVNJKLajy47L+9QTT29Z39PR3faFL34ek7d7x6Z8Omk0mUPBetps4Isl2cLzCgoqK6hF4bF9j2Z2o0vT7MQc1e5IlCMFiW7tW9XV4LZNL4rZdCBstfqzrrB/9kLertL9e3cAsGmsCwR9FjXopMw0wcrraqlCZeez9b3+LbdcM3nyVVlhYKpdPHcW1aChfKS6Zg1nKSQn0haTC612SpnS7OhFlJ2VUjNyCUUM9gI9bu/yViWk4rE2us3hxkq5KIzPrLr9emswwBjl3InB3NI8G1QNfR2hDS0hg7m1UIVdOD4af3Pf8PGhWbmcg8NqtjB5kjuptWMmhgZia3hU1UrzmBWsCfTLqkABoXjUAEWkxVLxjpYWeEU+bx1Qq0AfGYxwUlG7Cq0msQh1wrmCcuHoXDqLlAPgQ2BZqAUncBl2S2QpIghlv88PvHTvutWaqGO5r+lbzVkZu89ZLouodM/my02trShxgttj+MI9d09FosdPn0VpEkdak1Xt5nogfRgvby0Jd3fyO/ub8/FZVWSigkQVl/qaV01NTG24drVn5YZyarYQi3NW++TpYYemALmXUrT5yayBBWresPLaG4J+bubsW9NnE552c3vvxqY1WwEgLKAyrbo4enRBqAj9V2wePzvSvvPGyaMHfB7xxIHRddfsOvj4wQ2Xr+nqW2NtckmRebRzN6DJmtmvlDXx+BHFFTRrE0B8KVSdKMSEpZI1HGja3iekM/n0EsBgShw1HLJsahyZXGjY3X/5R75Y0bmpwaH3fuQeUsgAD4J07dLNtF00Av1gArCUgOxRWojYGJYJadhprKsLG60B0ruGhjmKEhzogYoTEDsDIvgy+tTF0mgTpdKs3Qh7gzKZzZbuzu5wY+PQ8CXMx7o1a/P5QveqFUBxQXvIYqG5pXFmZubB3/yK4R2k9YUsf+jjn3vh6b/SsalxOMr//rl/+/OTf+lvazlx/ny+lFqLrTJ4Cp25Ohq3JWTK4m5Il1JBW2jF5nohX7hsw678XP6PX/85nAdvc8hjYnp3rLRArdnZ7s4Vm3IKenBDc0mF9MihQ8097faQo6W5y9q0KRNdKMUB3JCGBpasYZ+aWaKDtmomnrh0xN1SVy4bUolhdF3fddPOlu274oePWNs6KJeBbvHmx0dLx48i1Fy3caOHzYvHTSpvsXabL/41vm5LsJiIFNMe25r1fKrJqJZip872XLHb1n79VRxdEiiUY/JedySNQBOCLljYQDDrcDnzasFrq8NmIAZYf7W2FYiqQTyhaAmWal6suGFQoUwBqwCzg8oiUgTEwKuCYVMWq3lJZhgUySG4IiN+p4qKL+BDstoXCPT1rjp14tjGLVss6Lxd1Rt9zvPTc2q1+eV9b6BsB30tA2joISvf/87XgdWkt7pcvN3SKEa+c9m2ofMXrEygfp1no5s38BVjf6MuiVY6uHBp2AkV2Nwq5TITI7nhp59HbL1/bd+q9R0keABn12rOT07oQpXWZlAXx7IGRVL58pJQTPh7b+KTytDRs+6JpUwyqYlUw8aNfTt2U0quklygZfuq698VPXHe1VAN3fl+TStw7gYxkvjT1753930fz54+f/qFp6/44r97u1u9q1qlhUj2wEF67TrrzquQ/7I4Oam0NLVkMqSV7jBSOpDVxdzi/MoPfm7izBhl5oAgQd9EA42G7owSKZGOeDTpwovqHp4yYoOQcnkx7HMnsEMgCY+R8ABpSYXKKvTWtFgAeCcRi2IZUX+Y52WqIqRlKFs7qv6RykbEA6EiQHl0E3wwq8eG/qAOm6dn1cqJqTGfP+h2eTLIWqORqmbqCLUPnx8FdCrkCyGGoSkE+kcqZxChazHpTjRfXJzHbjur65v6mjirnzEksshrAm3ptNeVxbIduA5H+PyZGZNVKmsVq9t32d5NCHAgbZdbTNuo2OCZI5e9+12elr5UZDI+lzM7VLT/PHc6Mr1EbSmJKCBpam2MpobMVlvzqmZbt78cjTKs1emwaYWUJRCSiwK8ELGoUtHc5BzqAEuymZsbndUujrs9dZy7RVw8W56NTJ1C5b4h2NKkykXGzChoF97VqHHe0dnxwOBcc6uMnSGERETNT5YKCFEbUSuL3rCopUffk0whx1ZVWq4WeeSfkP5AQa4KTHU2nyaFikZg0UiEn7hOpEgE/RR5zArEErQ2GjaieIBGu1jUAGlatox6bxlOLfERwOGkPhBCCLwqtrV2lIUipH9LS6eEBmElqbW1HteA1TU3P8mbDL0rOofHxpAvQccOqCMYPYbnP3QTKUoycuj8JEmoRyebpBpEuqW1Hns4oOU5agDdLl+VGPOkY0wqk0KQzxeyZ/IlRpca6oPdO3oV+PotLWo25bCAVhPnT46zFvnKD90FgfmDL/+sb0vbht3bveAog5CeX6jynsnhSxoJrZb71m+wGc25Ut5av+b0kWdO/PPSrR9Z4zYpjz4x7Gzy79yxwdOyYfLEc51t/WxbWEnlhGKUZRwsba2IlUp6QjdJeWO70d9XH+ZNwnDi9EXAnmwhX3vXqsqOj5U0ymFwaj4rartGDv6zt1lNxNIf/+gvxiSqhP1BEAgzVNF7MmhuG0qcZTgPqtkYGyJ2ONzZ1NWmKDRpk2kC+kIW86IZfWZR42UiKGA0DgNQlAN+mOEh0xDWRQTH6/Vu27Ru31vHeItzw8Zt4G5/KFAX8PtcZtSZP/rE0yt7etet6/rxd3+qaBLqbWAB5MtlOg/QNQKE2LKENiBahwAfb7KyHps7VBcdn40uzBtRU2UFsxgLKQnxVJSj0mgAJxusyG1TdC4lDRy42NrRZppbNJZSF8fPeFZtvu5TGwEGKCcSbz7+7OWXd714eDzY2kO3tBgR30blf5VZsXeHoBj+8YM/rbri1tGnT8l0ypSkfN6u7rVV/2U3oHtEW4Rmad+FQ+eawrNiJpU2+0PNYVNdw5Ef/2H9tTd7V68pDi9aLF5zW9Ponx6P6xcqdsGypt/u86xz2MYSqWefee2GnR+zWjzYXQihLljtKIJVZqeqWeGxB26fzjo//f1H40Wg4qpJOVumh7xhM3bHWRlYNzx/TqUQ+69HESdy7UDswGBCNYtAWsNKKHDCEqHM2uzcEqoU0AGIpS1ICgAU53Z6+/p6XzvwRl1zVyjcIBRzKE4B6B/hT4SgvX4betJetWs9gECf/MQnj5884vU4n372RbAAnUYpmhE9MOlCCXULRtReuoKurt4+NC9r41dii05SXGMyw/0ryOWyUm2s8yNgzqOQhjbBPCHFYroemYsalgTUTndc9y4tKwy89GIumrDazB099VPZ7FXXrhg49GLHu9+dGRscGpxYfe1OKUf98Jt/CiKqkc/btzYOHYi9/cAL2zejd4MpMzWDiM3WzX1ydMa0/r0ARsnFRZuZnz91or539a3/9aPi+Gjk+d8npmLb3n+DZA8otqCzz2vOOZTEeLlhVVGttiAIvte1OHikZcvVKsuhsABRzpbGhurY8MDwQn2jr5xdfO1PXzMZsEFIpYCdbUZGn3w7+vKR8yXxUtBpzhX0sNuFx0LDMkSVYb8CMcibsRSMxXySh1vG8oH6QAVlRyhGE4sWqxMJfKfbf/bMJUSdm5rrWaOhVAY0CTleLBQqlU1BHwxcGnrf+29Hs9iOTpRpUOgSEQzAfUM+vxbQQOhaQD95swViyeZyj49Mzs1MX7p0CanMUCjc2tbocbkQS0Fr0yrK8uCNVE2kAx+ifNgCiyYNq4pZNZcAisk6fuLQzIVhiLVgfZOF8bhZiz4+11znXIzOWeu9bW1BYPmmz51RbBQfpDx1LcH23qWpic4mRF/onnX9kYHjCJ+CEwKhvszYvD3QiNoLszvs7242WhCliqlIIjpa67q2lJN69cKxzdtWuWOF0O4VumicPTkwcPSM0eKijE1n//brC3/5ZSWTg+MqyeWl2alUJNO/ZUPb5s2b7rzNoMFhG6azs04xu66v+dPvW8EUKQX17jLq78wWsw+9uCCk0R0PcgeagAD3aWMw4EI6A2ljgHBRl4OyOPygdAVoIZyWSmVcTi+0OToawdhFoQqi4sg6QBmg06MziJ1qoc9R36w1Y+GOTTWG69G4w/CFpnaXx75y2waWFMAnJRFAZMrmDcYicVkot3Y0hOqbkFkGEs2EvmgSUOCM1+9Df/pUJK6IbCqWaGh3l7LJdIHyu+y6umDQZ/d89GPSQgLNs86+ua9zU6NV4b7/4HM3XLGhYW1feSISnx85cGph/c1bmxzt3RtcudOvvH4yLjP8DdfeUonNlN2sM1B/6bkXFLMvG8nbm73brugXIhkNhcdhB1/XCcukIsSwasvjk7MzRVO1ZKpAZCqpvHto6ERo1QqXlXrtxPz1OzvbduzN5Yvq+JlJ0Q1raP2ujSVRjL51JNDd4g02zV0YKBRngMV30o7mHZuSC8L9D+07paSBDMlydg96AyFMiXY4KIcz6CjGgEtdRdsE0rmFQj8DGw+EVgXqGKlrCHfku5KJbF9vN6wJJNRKJaWzu6O7vROhjONHT95w9eaO7tazJwaaOpsBGABuLhlLoAD/q9/5geEP19yOwpbmngB6DBslJYWGgOjcm0NmHJ3Ny/As4jMLzuZ6dG+yUqaO1maoCrkqzIwsusMhNCDAKnQwqFrKZvKQSyraZ9lDS3Bt0XbZE7Llogsc8KoideTgixuu3cnZm7Ri0uSSfvLVJ7a32KHJV+5Zw+M9IgYsvTgXdXnctpA3f+5UuGfbwqmT2aJ4fmLU7mB37L4OgRxAP7HEUG8cbmiAP2v218vZyHOPvR5w8OvWdBRk/fv/sa//CuS6aUtz53okamJxndaKnv7mDlthLjoObPXA4u1fusfm9MjJjFCOFhZSaDLSUNdURtVEIeN0aEb0V25s+eAn/pkCThglSvCCUcRFmtOQRiyIYyNdBidZETQGAQNIdLMN5RXrN162lIz1969DpgXhBACFrA4XUAGAcGETu3Q80tvbbYaosJu8Xp+Arj7JBHAnLW3dv/r1rw0vfPz9IqUFm1rNYW7p0ChqZYoK2s8VeETrLZZSKotyU3/IA0HTcNn6ltbGhTfPJIvJUMfq1MhgOZbWaLQYd8EMA1wZWwRZDKXVN+wWoxcxzPEjp9bt2ki7vReOnTt67sTGq3eu6ttjg4+TGJR4za4DuuQTI6mpSKpj82q1KC4tzHfuWJUeWnRSnBZqNFVFk0kZGhymkkX497d+4o7sXLKcKGAFLMaiocZgqLsbBT0n3nizuJRcfe02farIlOPBcO/JwTNLkaXmZiaeKKzp7Sk3bEs//XDV49rw5X/bvvNrgKjt2MB87YffQXPNUnbObPVyPo/kt1Qnx7KCbGZcZvGoKWO+eGLmgfFEklnV2rYqm076XHb0eoWhWcihsD5pUHWny4ZKKbFSZcwuiKCWtk6/x1eRizaLDebqZTv2IAmGCoPZ+YXDB/ft3b5mMTK9+8rtiPXAiNzWvw2+8JGBIw89+FsjEq45APvKVa/bg1hhQZAQOxQrMrrG54piIpvAvsxofoK27YHGOnTENNvcDGufP3+SFE4bqKIqIK3BmjmAMrAPiWKsvPHPhxHhQoPQSDKD9D0cnFQ6f2ma8vh8EyfOj775rC4UfA4/Y+Ow/W3e4Ghf0xmNRoSiVhduNKi0M9Q5MAR404ynaeXY8NkNV91WVCqRhZwkQkdBTObLctrjgr7Qnn/0H0a7dcWKbgNt8XlDrr7eiteHuGZnT9sNH7yya+euzbvWRlO5xWJp5Z3vatuxMR0Xv//Fd1+21srxroe+8NXht4576xoBCAFagUPD3pY1jGYxZAWjFiiUxU3X3HhZ/a7du981ObOINNmhY29LAJ9QlRXdrVdee/W6DVuw6QNAVyhbAvURA1BkIF9g79AQ+jCUyqIAfwJdz4DX03Xx1df32UNum5VmOHFmZvIPf/jTFz5734P3P4AaW3ry3JCFNWUL1UUlPzYwwNjYhWKc0Q1pocSirN/pQADQajB1d3bGp5ckW2LowkVZztkY1uamNLfJiB2zIY6LAroBooupZInpeZHWJJPZ5A06saUDbcGGCPGPv397h8smsk7O0jAwOtxdb6lKbjWW869vYfyeS194qH5l88qta6QcQqjPXXXbusxUtTw/m5wYz4eGE8noTTfvPHTo8N7rbvjH3w7YHHxvs3cxOl+Ry28/+WKn2x27MDffPOgOeg2MmV/bnQM2LaV4rZpn6wd1bt/UpflffP9o71pq/RUSomO/eq26rqdhy017HJr+9pN/K8LuujjrCtW13ryWc4adgpirdjzwxtClxD8TlDuYp3WTesXVV7/87DMjF4fQUn1iSHKGwv1dbYFQI5w4RCCwW6wHDeL9XrQJDoe82BgKDhM6k1hX9CzNRh12/4WBC4paHJkd/9XPf4dqOiQgUVKHOhiSGbbAv1MqVc6YFqLZMylsF1/GWkDWmWcVZMZQlVwULEmuu6V1anDE3hg89caIIggI4eVF9OlE6ycgokqIXyGkGmj08mzwwqXE1msuQ987qqh1NXXx7hCyd/VNAdEwPPDKKDJNkhZ84K8Hv/VA5/RfTtR1+RvqKhefX+DdYrCO1dVi5MKC09w8eTJWtTJqemndzmsFeY7SysGWltf2n5nwDu+84Rq/uYpCM/HY0b6uZswNFXDedt+79r14OBjz55amlEOvW2hzQrLdec0N0tQIb3bxjuTnf/8xg1xwb9nx71fe++5ed4+jyk2kzkVnN92x02Z1i3supzTXM/88FCmOnc9XUdMjYjPNqt1pZ4xmqdkVOvLG6wj4NIbaJNjhAKygXwow53b4Dkw+PS4XcqHelZlsDivU7myWsoLV4vQEQ4ffeGt170roXuSzjaq7jI52wKSgMSMWEtooorUHAJCoRrJ4nfA1BKkCvIVYBMadlLqrcKyxhyGChfkSkBiOJSdWqZpMoJQBeTiaMaP3ckUTzaxVysv1jUywtSleiDEy49WhTmhloSoXU55+j9Fen12YSSYr26+4m5vTnnr411fcIHT4qa6+jc69cdadDXT3KpLhsis3F5CEWpwpKDmKg5dbhQYrxqMI3lp1D7Y/QY+peFZ4c9+LvMN56+03Z+OxrnV9FldgQ5jJLMazieym7eucDo9u2YRymaEXXg82NMbj48mLxYaVoab1PbRQSI0uHH/2a6GAf/u1u+vQRxA43tI1F4+dvHB2cMzoPZ+YR/c0wBP8wTpU3IK6V99089iFs9ly7o039pk5CwRpU3u3WszwsjxVRAnUOHblgHficjhgD5XzOQdvbevshnPqqnd4A8F0Prtx6xqA2OOx+WRWaAgG1/S1A3Z4/PBRoNBJXwZAgUymVCwGyAgq/9AYDVUIVUCrYSTBFAGuThTLRdTcS5VEMi8ZtFg8tzC/BMA1oI/xNKghxnIiWrjBzMLA5yMLBZGSafccOnGmSTMVBwoZbAw6NiLmk4ymivG0ocHfvqHNElrdFGTVvMwEGuBaPv7tXysCdg1FcSsdam7cvHtzXVtHIBTCLpacLQh87NiFEz3tnYpe9gYAEad8Dgfck8X5CV9rnSpkxHTRGfQjxKnJRmRSUVJoyJW71q3w8M62W+8Mb10rZzQ7b5y/OHjm+KDR5vrwfe/xWCzl9CIY6dWDA0+cnmY27j4zvWDjXS6PB2ZOKVtABcftt34IJaexONLhE8H6EGq1Ye/39/Wv37q1vbUltpCCusOGyU67A61cUVWNRqTAg2bTKfhG9fV1dfWhpoamZCLm83s9bgcwoPFk8uTxU4gaoe8lEpx2mxXZr1KhCEQRLXE8qGkoK1BwdpZF601aw2a2ZHMvEekk3ahUqyPxFIqm3ZotmU5jYyRBQzWSebGYQoIcFSGegNnn7YTpCzYrG72vHTjIymaFDQz+6q2Pf/jaTLUyv5h769XX3nO3ddW2d4uV7OyocuIvf1x73W4zs+LiuQOF4mv3fPXjvtbmMrqyZvJALyE3BfQxUuCRi/HSdG7l3r7ZyWi4zgpAGV0R8UxWR/fR5/c1BNwn/nL66o/fAUzs4Jun5i4tbLh+e6FYRiNfWilPHTqWS8qXLgwKb7616/It63Y3WNZ08ZL1kWMz52ZnhlOXZNrVumJt595d/L79QMahlSRoum7zlvFLF1478NzKvr4TJy/UI9aONteysmZ1P8AfoZau+Ylp3RFY2RmamZvPGWSUWlgsNrBvSzi8ceNmnxda0SiWlZNvnaxlCNrqA/ViTkyj2MBEn84eQ3IBse9cNoc7IkUKpUnPxqOkOTm6tTvRsomFp8FUFDSK81r4ZE4vGsmOqly+aFIlc4iBfEQDTyGHctAiqkDofMlsMJ4bnG8pGzY0BYu5VLWh4ejpmaIwm0yPXLens3HdlvSTj8WXqLQ1nf/Z742scSant1+962+vvNWyrSezELv5g+tGByZzCzNoZFbl7VJJGJlcbO/peO3UgL3E9qyu693bV0jKyeNv969aj6x329qNS4sTYKGeq3fpxaVr++9B3bFN5oyC0HJjD9Ch9mCbwxpHE/SKA3Ufo8NV4y5bU2o+OV+OzU4lDlwS5LoOqtqYpabDTudVV24F7gexBDQlpXXj9j073ty3v625RZDk6YsXP/exT/324V9ds2fT8OzsRz7xrudfn/AF/O1dTZNTUVjtsMPODZyD7G5objbI4oWhS28fO3nHHbetWrGic0XPhz/+oWgcbVPpPKwhDi0xEahHpBO1ZKQsFZY0abJDCiNVeiZXQqjVaqQLZQUGLdpkcmgXATQjRTpIY6MTxM4T2SRp6JE2eBxudLxUUAcHB4Wxp5Bm1LEcKqnxqZIg++zsxk3t/asaGCWL/m72cHV2bL/RZWTc1FKM2tzvPLwIBqfOPfHW6gD1xj9fvfrdNzLG5sxceuzwEbuNabnqGsqjZAYHDjw24F1t6wx129Dy0+IQqlPo0xCs70Agff7iRVeXD9tcpcvSSw+9etn1V3R2r2Sd3vDajejvRWloTZaOZAoLx6fC3YFIdOmuOz84cXb0TFYLrrz+mddfMTksSmIR/Q1oFdvxpk8dOxwNhuoaw4kocL4d0xNT733vHZlUYmjgYlnKPv3K4z/6+X/99ld/Qp/ZX/7iyQpL79jz8zMnnynn51lKvPa2G+raw2++cpB3OtAJtt7d0N7aHvBBRloripAsF2CdJoTcj79/v9mMkI0MNB3ytET5kq5NaPFGGgShqS8dK5Z5GD1AvFQNhVIZyWZ0l8aCBPAPRIftqytohyBZzVZBEEitLMCjLBcXsyjlRDdqoOqL2Zzbys/EF1kuhKqRIqrM6LTdhp3Y7LIBQ+sym8f6GhyupsYe2hZP5KYWymhwE8vJw6Nzq1e2hJu6x0/sX7GiL33xjKu986YPX9f09Pmky2MzofcnvBa0F4uE2pr0dMxoMWViE951YTWHJi3GK3o2TR2eXxga7ty2MRopzeYvrNmzCZu/HB8+t+fKu1449MrJseRu92S54j6ysFiJnAYsrlAoIOAP1Dnsd0A/lzIRBBZRWYGuvNh52mvmBgcHEZEZnZ4P+T3hIH3TlWtef9WhTaouX8jp4nLZCxs3r2jxNoZ8KS05f/XOviMHjgJggZAkkHSoCwBcDrsNIFiETWYe/NUvh2fG0Eheg/dFWqki5QnexxwgJ4fiMlJRAH1vcLAWLBCzrqPYqc7M+qy8222X4fygtVlBzKP/J1o3SzIccYLyNDLYohxYKyBUAWMkuXc4YJq6c9WK63fsjl4cbQnRnWtCwxeG/N761k5v3mD49WPPnLhQuO1GXx8Ctf3rDFXnkUsnT54daPS7FxcWPnr3B4KN7OJU+k8PPPvuq3o6VtdZmtpYB3/okb/0b9st8Y1HT77tp5h1W6/LRceTyRm+6jr0m30feupexchER4ZXrGo8O29anJs6NYxO/uaRwUlnW1gzNVWUCKM75jNJo16EXkOVCoJlFQNivVaECgCbBRS2s7sLYTZV1GcX51rb2jRJC9UF52fmyOZtVRo4iuef/INkUP759+cOHD2GLhXFRBSOQmwpDpB3QzdQsGajLk1cHHN5w3WhcHt754qO5sWpxZtvv9bhcHzu3i+Qcm8aW63EoRzlchJtjdCgC64cogZYAUjZgn0BuTTYWLQaU5Fg4ySlip6fiHUA6k5RyyXfdgDFse9fpeK0sD6bDUp8diGOeYFJi/5rWE9I3DUxlS/e/UGJkgADpREnW5hrX+FA4U1zy4q0sBhs66RUdX5xFua5v6sjnyjqBsXlqi/IVd6izczPRwZOr127qqIwRwYOTZ3L/ud/Xp1HbYTJfuLAuWi5UrWb5mZjnZ2tu9aFXb7mt//xXNu6Dp+niXKE/vDoodGlAtUYBHga7U9RqlfIgtxAHhoShbzTakMiHZsKokUdSQGCdbBlhKxwjJUHWNzCaFJ1/Yb+gXNn0AkVO0IgS+52uWC3xOPxD7/vlsuvvpFFz2iezWRyjz3812f++Y/6OufkXC6fhx6kyP4HBGdn9Phc3as2ZVJJvy+0dnXP3u2X+cJu9JPadfmVNgv2hjE6Xe7urnYA5can4zSFNkvoe6aguBpIFpC1E6VUbTYXMsVlluwOY0HXdQC4jRpCrx6DZjVQq4KBvsZ2G3J6yPRaAIfBpFmBOH1m//GBJAGWujn2mx94N9JLAH4gUOULBiITww6m6Gm0SAa339aInI7GVy/FM4cHZikr8TnQ2n4pV0Qvb/S/ycrGYpWymNBlsnRVt01LJ2OX5u68fV3zmpaRUxdeuzRla2x1YzNik7aqqaFjA9QsbATx2785tgB5ajHnoimbyY5tF2xuNymMxpYDQKirBGVeJLlc1LbXwN80dksiRTQMGvLWhdBcPBgKwshGvoVH+14bQl459F/AMX396774759HJAGZeMRTABwvFvKAzceL3G9++sUzg+OpZI4z27HwgTQHig3lSjt3XYnOFsCY9K/q7mwMuwM+ZAE+9LFPIl+F/g+ZVApBF5fTgh6BULQXhwdiSQFKBThlh411+qz0V2+++fjg2Atjg6TrP8JLwGDoVbta7XHb24Hwd9jQdZ1sTckC3YW+QyiZNWILhVuu2rv41NM5RWvx++AZQr8A042uCaThZl2oEtVMkjchifsGj72xME2S4wbe72lGL0VUiZh1tbe1P1sBnB8deSTwZgWBC7v9WFaiqWDzhvZLgp3JBHquv2PNx8MqhZyxNTGrwh9hLWxkqXzw1Ikc8OWhxmgy5g+AmiIKWNBcCYAU4JaRo0UsLJOWvT43OsdiF0sUwqHyDiB9VdbDdf5COu8B4scfHCuMoc1XZD7lQtmG3bowONS/vveu99yeTxfx3sIaEksLsGJRvk6p3Fw0iaAbilhxHyhQAn6kgdYC/YmyRDAJjfpqu/MBW05jQ03i6KJEGw3VUASPqgFg8DMpeAXtLR1o/hldSqGLSSoRKaeLhmffeysImlENv3n7UIwUZ2gBTb+zvcmLhu96hff7kYLBPtBAA8BsQhIU7b8VwIBl0eJxChULnOiWkA+oDkDq0Dhk0W5Mz+czVSSmuCV021CqNhZuJMWxdsmAskIRC6CjcwU6lIzEojBkAVcC6hL4ViLnFDwaYwao0WFGCFhF1XgxQVeRILJ5fO4VnlauYhopLfq99t7+zpFLY8VYIlMurtu4HSjwP/7t75AeAOyjLB29tpEQxTRA8QG+QGCFqON1WEsp6bIt20WlNDwxBFQIvg0EglAD6Arus2MbKr5YLkSjcTSd1mT0/XA+cP8P/vDnx3/+o689/Od/XhgevjAwjCACklxYWCqFWj4y3dCpPSvW+bFRldUe9gU/8J7rIAF/9ZvfvvzqvlpsDv2FssBVIJ8DJgUTo1wAC1GBEsVmUz63jDDAU++9FQpZQccmRnvgjYGMKN/W3dTmBJgC1qYJdicycoiF82aUWGAKSEdJuSznNQGdXvGInM1GlQB0cctVdT6V/O83j5pc2EoSrQtN2DcS0VBaZRDEh9kHBDaC+CQOhdw3Q6OxJXQ70hcouUK/LuBRMTeinjWILNQJh5UGCpJ+vgB+o6DUjG6PgN9YLIg4GgnyDmoCLeUQhQVj6zpSHHDj4WSi4gpbDiDKAiAVdou0OR2wu90QUArpITW3ALwtnCLs7VhEtBhxvfaOHmTqL144Q9mwZSY2CBJqeAU0QqrvXtVJmu9WKafXLmZyiZywrmcbeDqVHz9x4kJWKJJZrmhX7rrF5Qnkc9ijxXXdVTs7uprvvPuDuVyWNJWlqWw6gaAaMSeRmoY/Teq7USpDNnrG+EN1PsNLH7gLux5LQMIn0QevGo9nQwyp5OftDmzN6/MCMGujbKjSRxOvsgbEaLJEehqSsJ6RpdDpzIQtOAHvgxUBzJ7CmX//1pvQdEAxITCrI5to8WCPXFCzgMgD0pMGlOOib2kRZWxYbainhVVGit0INtAgobBcxu5PMM8IMJz0xcSF8EIjG4GaaJYF+B8l9f6gIiBlm1dVkRQ4oJoOT4sQDmAMRnQ1QXk0yh1gZuCfhmfJ5lJY5YokAcmPmk/STgDeUKXq9/vR1KtUKjrcUGyQwYgr0k4zmhOagXcAAgWXQltKoDmx/teuXDs+PdbX3XP2wjnUCB144wQmANj1DRt3JWO5vv6VG1atbOlq+/kvf3Xh4jkUoHMWC+DBAMH1rF7xpU99FpbFufNRdEQ5dezZbAH1I5ys5aFkSLdOSVSwNMxumyEWcZs0UiYDwB62Pzbo6FUEUxVuKoxZ7L0CYYZCcRVKLBgAYobsKIEktc0KBQccDvpmwb7o9rsHUmk4gXjNWX2IKKATl8kOupuApxDRgw31syasYRXeHJr7QNEB0o3FpQpAphpJQQeKDhH+R8UYYDOYZ+ztgeysRHpfqOjTKStCLg1wM+ozTCxa9SFri8AhDckoCjJIBZwmSh1RigGDTiyJ0UyawK5gujCkuzekHOiPKmsfNsBxOHgUiJp5eE9kj2cNTU/BTzBb4SowpC8QmVvkRqBwjXOJCATOxdHxcGsrsHUom9FFHdF49AEFG4mIxWtCY0NwZGSYRfWSLIAxMHaszonpKdpCDRwZ8IXXL6XnJmcmspkMNk/2BewEJgwOgIYi20mDIxXVZibt1FHXqisIXLMob7NZrGa3E3OJLpvQM4wD4REKpR1WI+V0o7uKpEoFq5FXsDEEynTV3PWr+xIH3hzKJpI59PCLYC1BdmHzK4B/8diQDJB4HIBQGB32lqyYeJsNIRHyMfAdBkhwVHzCrkSJI+Il4GUQk5Stw6LQYasCAEAmEDUAVWhCPDm4DJEUnEweGNOFH+CfgaIGc4DVsXwI4ArXA0YBhTNIMFZdXpctbMdBkCAsfhiUyOtgJiDRcBYugB4EOovO/3iL48n1kHyKRBYxs3BRl1JRp81uQk8Z6C1dd3l9mKGgz11f3/zZL90HlVMqF4isIZYjxlPNLEVvufkOm9XjdD2P3qucDdBTuOxyfj4FgUnr2G0bosVQWSrF0HlOLSPzBPgqA6JgYx8YavmKmJzJkI2YzZyCSUV3lYpqQRcVq91EaaGgrSBmGcYW8LSOj45ZsbdCpvClPdfkK9WPvfgkqvUB34PbVxJJySBsVaxNzAea+2ObNcSjaLNSyiVZOxrXg+wk20qKaVFyTQoQEb8C/UECiCIodJj12AwJyEeofAIzJ7g04lgS7x60t9nsYACQDB/AbYSCxLnkW4LtgX+DRrMMEB7YQQUfYgyQoyQkQ0oisYunYEXbDWBAAEozGOAMY8JQpYSO2KSwFJYVSfbCRiCnwQxZimMrvxWpSMzsQmM2lFm6PI7At/7ru1CWKBhXFYlBQQoaRZC2KsA3wlWVSqaCkpJcAEiXygTtAoaD+AWjACVvC9oyabQZiza39zoCHjtnxeYMKPLnKD2VU3jkIDGtJlNJEQjXFos17YJpBMbYkoyWnJ6GbBKpdjbY6C+mcyY0i+H0spL5wY03fP2fLxnR36LWNBmbgZE7ws8DNhZIKXA3CvsLIoR3OZnBFilIKoPM2L0BlAKCl6wUUo0FXayDrGALfIAPYU6Ap8HSIB40NLA7WDfoSwJSQgmQGAO4GDWZAN6ROcX2wCZ/wA8xDoKSvsMQjkCIEtGHKxABiDVHLoWsiYqNWe3gEvzFfclYAZyGewMRBBtNVNG4DPfAosIfxJ9QHVaRMzBt2pqaD558E1+JcKDROBhUIoyB+ki0AsILpJAhYEsAlsLswUzzdux8hDpZlK/pRrONhR+GBgkQSm6LNeQKiIrAuh0yTtElX0vDik2rLW5nsaDarZBZ0KYookI5NGL+0lISxfGF6ck57CKLPR4rZdkG+Dk6bBuM6G7a5OECDg9kw3JLarR5Q79MNHKxYXtewAnMfG23RfI8wNthltqwtYgThdRhj82JYRMuJoMH3QkeDXd8h10JUAysCE4lpMJ8oGsYfuMUwlSEOhAVCPhg+qrQhP5AHfQzWX0QuOigREiCSxLMDy5QCysSkoItamy2jGUDJB1WPJYrgOsYBS5AushhIeI9IgUmlvd40LHtXTbejvtkcunIUhSMjv4FEEqE5WERE5MVi4c0+sC9cQVYG9hOBOYcCQwh+0KULQ9zkIBPz49c7OzodpjMM8OT3pAf4U9YCJlEqRQtqI2i2ePo8Ptz6RiMU2JogDSIAMGGBS9VOQTfsVU5tlWHyE9TMFit2M2A7AZn0IvYKRjMC/4C86hMwO8lg8K2bHKZNzBQgBIp5GRWtwcR5E8posfriqaSbe0rc0MDSk1i4XmB/gBfQ95ABEFgEEFMcMz4CwWgeD0+wq01gYuwGhYBDgGXub0eUkwNSsDBRDkXUc34kkE0AnMBdwlEgM7HeAAuwUYJMHUxH2Qp1OYbjA8DDPY7qmhEAXYisVbAsJgYHIVKiIXFU/VNu1CkzRn4V954AcXFtTa8sFxweQMpyIFPSxYBujGjhwfhFLKoDahZK2FBQfWgsBVMgJ5apXJGRBtA2mxaTKTQ3T5XyKMhNUI7EG0iwhkmo9/pAloFgDE5Xzai0NZILy0sNTeFUD+IwKS0uGCwWwPrVyejcWCJKuqkHvTyJssLS2W63mPNYUuZssaIqNcREfoiFhB65KBu2YqEG0pPQMq8kO9sDeciYqihjmX1+NKIy2rKSahZQeIUDEsglAR/TCCxWDzgcYgFUlDodLjwqGSBgDtp9CdGlhD7N2BiEPdRaiwLgxO8RiojoU/AFqTLPflByysYOYTB0XQI04Du3JgfFDvCdiIXB8l5FhWWWExYH1iMkGCQjbgNhAw6+GYqsQP7XkQ7iP2H9pHRYUlC0aB7E1FQmCcIUagAQAjJUoAtQFDUZOWR9YTMAIaHGYG9S+d1JVpIAqODhQGnHGDHdCYFFLaEOD8auju9QlZwe8xChVrR33+mcAK1s6glZ6t0JSm5OD6dzDS1h6Ox6OTR4zTcBbtPNTp1a/3RRPJQOY+lam20hSwhq4tbWkjATCRuDo2sA2B6ALqjMQSao0uziazVE9vQuOaJQy9duWdXYwAdZeSB8QRoZ7V4oUFgkqK0HKsMNf+QgqRPHjAhMoSyGZIcLAwxBvwgpAHZ0gahWxhdmABQywi/TGLsdrAeggaYPXyE6cGqAjHAlSQur4G9SRtqzC7618LqJ2FjGEgcA5ChlbOD/5FZxSZ3mAOcVjOLgesFxrmaL+WgvTAuABPQqBlPBeQcMdxRgYbGftinHhNCWAjUJiITaxe/sQKwNkrFAoHuxuNpTAgaZFSRUlFRdoN+Swyw3zwPzFcViF10+cdCDPuDqaU4xosZRcQRHxnAZOWiA5W12IzOxmM3BoRGEZNh7d6LseRsWTVJVYirslBBp81CKo/ttzo7O7H0oPTMKBWFm4zSFCT8KA1bl549P54XEoaqdGrgjAU7TxO1p9rsgDZBWZjxDAgAQIdDhkPFwv5B7ysoNARIIJcglMmUYBtOXA57lOOqWDRQgjgL2Q0UxsAC1hCNRjc3EriCvsU2XLA1iQ0F6UZUGoH04B2IS97BkKi1NSGEQnQHbgrkFyYTo4bvBD2PaYN8MVR5lieqGpWoZAcMCBqyrQIGBftLR8drbBINOYjhYbmCm8gKqP2uqRxkJeBX0XPzQNxDTnMYQQlhI7VSxGYAnBkpGawDuxM1AXQylrR7XWn0TkGuj2WzZRm4XknUwCocX02nlUWlKvMi9oK1MfzI7OyCxxnJlXTEJAGmyCbzSaPL56gUALAswIrHkyKeRLq0wMcheCsDNk/jne6ZdHxDd8d4Vkjm87zDZbOV4dniOUtinrNweAQiUrCDGp6DRnPrQiAchrSEQCQSlgJYuAzPRSFeA3QUfHPIBNKCA3TCeoLdSjQw+JMEfMl3EOg2mwOfIDIBv5c4yYoKKsM5hT5AQIkIX5oFSoS4cBBZKLeEHEMBKXaSkySQDz2eULYHnC7DAWRWslgbsKEyZpFsZIqphAJBFgxNRlFFg0muLTn0oSMrgDg6hMdQaUyLmpgtlZBLg1eCVQPhBEGJkWOIcBIw5YiA1/lRB8YEvF6kVX3YKsBh6LT7SqnURDEG3DBdtdbtWl+YRd1HvCnkD3ssXqPrZGTqvJpDYI1UvQJtICJ1KXV3tY6PT+P64CLE7VEKKggiWd41j3d4cuLp73z2o79+NJWMNIS60fcOHVKI5wXhK0IhstiEEfLayTtSsaSLdZaBp4DuA6FYAzxn7EgLNoKDHQigKYOT9zjwHB6/C676qlWdKLOmOUs2lkTnBWyrEZ2ax7asaHtjIo4YB7EObYnHxyUgeSplop9RAwIhBkeVNKMkpjDMb1JhyRCdQLaSQJiBt7FE5GPDJZaNxSdQgoLyXPA78Z1r+pxwfc3nIKSHjCN+JVQasSEwB3hNszZL1VwtG9AwHE4TKWEuS4gxWFBggZn3BbxoYxZPpZV0smLR0E0fI2t1heN56ezoeFOrCwrF7vTJC7MTpyY6Qj6zuVEsyD568V0bAnOnsnHspA1xayRdxsFP2KoWHg0eFPIBQhGWHm6BvjAYF7Qib3bOZrIwqGikyK0q4pdY6zAzgn5PXb0fe9lh2O07+ktJ8fS5c8lSTk2h1RSABQhrMxa7A7I/5HNtvPpd7/3I+4hTaWZha8WzZQhMxCzQnCDg8zf0t62/ehsA5S6Tud7q1rFNsVYZODv86qv7Tg0cz+YygCUjqYnG+WCsoppF2Wm6XGKRoEJxvdMhZxC9gZiFt0hcDUmQPG5nBlAEFoBnlEcgjMEj6UkqlmrGK2RZTfRATBKZjWVAisdr/hc+J+qYZEaRxJBVKwrrrDwa/4NboX+QBHdYWISEWQgiSXU4nYvpiNPrjyeWouUCbctHxTwc46KoB1z+Br8PcberL9+EQnSxrNZ1dCzNDOtluScYSgAOtOzyqBImooyIKGQgEdCE8qhCI4uchegiC9Tu8WC9W1DcpBkRDd66sn7Nnsu7e1unR0Ybe9tQC4FgxqYdW50mLlkqxeIZl5o4NDRz8LVXxIzwyXvu6VzX1+D0wqZRGC1lyKXRuQGoKXSHkmWz3V4SgbgoWa2YJ72ItgfYiVwt22gHjNQ1m3s2b12HWBA8o3Nnzz356NPHTh6FB4YQFmD/IB2sGGgidEmEGoUlRliH2DyIsZttVksyrQc8bmDIkBbGk+Er4uDiN5mHGteD08HvUPn4j2gCfEs+IUoZvz7gM7g8QeRE3A4nNDeMFCBTMpksdgpxWjivNQzsI8VIdYG6P/7j78gRGR2cbKhYUTKmmh28uWdFr8NgCHrM01PzPk8Q5yJdadILAzNDs1b3kUQJCgkUh6+FdD9q0Eh8gMQ/SFNIDAKCmLi/6PxFNgwo33rleltrl9Fuu3XvtcRgDvgOHDs0OTLhdDtCXR2X7dzkB0RYd6bVImtggzR/Ij+BNvS809rq9Gyq74HczRmwPZAzCExNdqmQy2L/+mwmh55V2PQYmxUhFme3ks4m2KVOxD5PSDCxFvgbcqFcj80+DAYzalYrpGkf4uRzS9GPfuqecrIMGANCe6StN01nsnmE0+E7QbnyJoCpndPTZHvv7vXrZy5NAqqeiM2R4gzYP2QCiN0DOtfkEHHgwfWgOqyG5ZnAV4YvddfDhsMW1U47tg9FGAQGqCrkJWvYA6/X7fMj4nz80j6kYNze8NhUFKF+o0SFwvbNq9Y1t7aVgSTOZmBIYzckOS+iUw7rdZQLOSAavvni4aLDAR5ChATh++t6W6fm4otFmbJDVWKPMhjKLDYFseoMCrA5mt27ecePf/FjWOnpcuaHTz61a0XHgbHheGIScTs9t/SDP/xjcHBMcZhXoezYaoOwxLSpTGUwd/HC0nxXoG2NHftdNqMhls+CnUMF+MtY4DDpEZOT0YId/cCE7Hw0BoPTjCo86FnAdUxo/kOiUOhymMsmXIGAz9FqNZjxiZ1FwyFSE3/irdM//fWvsbMltDbZ7RpmA7aUwzZxoCwUJRKPFtv02CSCBejlPHxxGIjNigEsSrqLkhwjpgF8hjwjjKtaBAUrYNn8IlfAzHxvc1u1YgqEm5RUqljGvtFcrlggth3NOj32eCRayORsIbOO3n7IIvC8HeG4rHbFbTc50YwEYVihlF6IlIrl2jaV2GJLRl+BdDaW0dUfn58lnG+QbRRz9baNzYrkcDoMDu9Tx8+MJaMIJaF8FRk9GDBVWIpc5fUXj5YMejdKKkzVb76y/6a9Vzk9+uDh/YuLs3uuuakAzKvDBmOiO+CzkO0iqjKKhCpV7PlTqAhHB0+tbV/rhcEPnkY2zmon1h/cAmJ3oycbwlZEyRLFh9gRxlSVC0IW+yGjqhTdwC02J+90wXFGYwLIDfiJcM4wQ0arx6HQ2L0B3bum40uvP/fyyOjE2YtDpcwSKZNHST1623i8s8PDqBfzesMWBpuIIkCM5izE/UUTQcwlafNKEBIkqF4TS2AMsgCImoASFooSthHEfhmrV6+aHI+A3Mj0Y7dIROLlUgHpTcRzdEFDQ2VMO+LltM3Z1OmBBkmpih0C3IKykqgROX00cEEQHd2ZLBZZcRTh2JjMds5QxzFNdm89ljRw8qTk2Hrz9i3//cIzJWCwkUfBiCAsfeav/PArjJVGWfzf9x0+E5u+4doNLRb2+7+7/+jLL33iQx+rs3ZKVAoGVRlNQGD+A0RjtiMzoSO0KVZ9jLOe95vhCkPR47Gw/ysgaCYdSddAXTNkOaKRCDfgkfEVFA9CY9jv1W3zuvxAtMMs0eKpaAL7a2kSiyIwOGJAIsOf0Dhk8o0mO8Q27H+P0/vFL9wLVr44OXvg9VdefP2ldDKRyWcZpQyUKEz2slAKtnqkFEKrYhUNyJTqlXt3uMgGrNNnLg3nS2WoX0QyMA1YBLCvYI7CsjZ8LtzVs3X9mjWdiXS6r2vV5AAyu0exV1Yph/gEk9KzPs4FmYTEH+k25XDE5vMhnzUEvdwWsjkaSvkUEj8KcPISklMk32h1uRVNHEnFf3v80meuucKownak8pJmNyLviuwFa9TEKm/97nPPIqmIDVxh2T392j9sFi8YDg2lB6Ox+kAgFk+yShH72UZSi3dvumJmPkv7sK+kxnstAc6GXVtFVXJwdmykyxtpyBM7sWXR5JAjEWqEy6r6wuQlzmINN2KXBgTR4WTBeFQKyLhn88G6BiPvBFQctg3xIdC+AFoKChYRZ+IcCQupOeRtWTPaiwHZwJHtEnWTFdvzwFeCRMFeRKRvI0K62NLTipje/Fx0fikycPbUwbcPHjt0AZ4ZTDISA6GIu4OoE5Ao8NERqoAcIouSGKD4FretGh69+1aTlWnqRJcFOjIeWbw0hXbOYFckidFHVjFrfMUAb5mzWrH9nFgUHAyHgGXY64Hvnyzn69s6y6UCzDLUxMJ2owSJs7NAlL58cbSvq8/qNFFlLGqtWBadNpRq80iqEMll0tNG/uHX9uV4Bh7+/T//BgmgebxW3hFdiLB+ty0cQnzRFgoEnX7ULyM8Aocg4A9hz6fWlgaUNYuygAqyEGd3OxygHTJzeE4oPfhrNdmTw04f7d1d2I8Wdg42H1VLRa1cgHcVaGwlehHGRi0uA2sGEGQjsJnQkAQwSxYksi4keoM9/qrafGwOziNwjFWaIuUqyEUbEeXFfq02gjVC0hhbMSIsAJOzQqFnwfs/fM/+1/fVLgZhT6aXBIeg8Ig3TH5B9EM4ETFEbCADnUvMebxh42LWWJDy5457LazI6rksbFwNu3KinmN0MYUiZUosuSqGm/budGDruVLBEXAAImejfLB/K5JuttHFbDlcV494uySURrGn8Hx0LYqNBQ3RMUTNIVCxixaYEyy2EImjGCNQ72gLBs5mkz3N4filWQhvdDty8sbA+rUoS/DWh5p5y+TQiCxPoNNwCTOoCmlDtZRRE03OslAwwdSpb8kHm7PYa8Tuqm9o1pDYB5PhkSGCNLa+qRkRNdQyKAr2081nkum6prAV7hASaqQ3B+gLRx6+J6SzDdTHD7wkUIeIiJrXisnkjGxbsA2xHWLXE6uStIbAfKAsy8ATFY2ULY8uQhSEnow9jOCZP/rXhz/1mc+88MzLJCIOsBjy5BrSOyA9MQoQ4yN5CBJlxzCJLKLDKKZe0SCNRF/b/7egze212pD2xY6CkYW0zWZJziUEAXqE6umoW9va7kI1gmB0+oMmJzZS42MLsa6OjsnJGcQRwQ6FYh4ZB4MFkOAyZ+MgmRDqpDgbnhn5dNRTonNZIVeGFGYtGF4FpVGwhHo7W1Y02Qr54tyxo+l6D5RM0O0dPXUcQPZoIsUihpYvhUMBB3ASybSjoR0tqZFIgGPU27+Od3mHh4ZRF9bQ2EoeD9MLGQQTy2JB6A3TDfyDDC0HDCwSMshzgekqIqLoLCK7EnBDmC+dxG8QXSISg6RliGKEl04CBSR/RzxYZHxMPDA2JBKEUIqOnSx8Mvqro/U2sM94DBLjQz0ytnFw4GIf/NAHX3lhP8JOWBngOPg6iO3h8oTooD6CpJgB3AYMghRhfb1n5PCpo88fNnr58yNpnso66hhZ0AQaHXyV5ubG7Zt7C7EsNtC0u8zY9BotEO3Y8VknQWbMfDyeBIIPdZxQRJBzkORpKZkrJHx24JkkhHQFuQQOATIHlCnmchgE+jYiLlFFjycS1GJCbu/UxELQ5wq1hFJJbPqWTM1M23k9myu7kfC0e0B9kQU4rso3NybK7IYrbubNDkJr0IYyrFi1lkSbSQANpjnISEG4IEOAdjaosCpkUjBt0LQT3i1UBUL2sL0IJKCUQUUHQkugPZHEuBB+SIKBpD9BHpCcIP2QwyHbkMBwB6YGuBVE9BAthWmH5rmwk0jGoLZ4iPTDaEiYvFLZtXUvjsQXqGuFDQRPlkQgiFOGK0MG4WDcDquMjJb+2tfuBx/GKcqRogpo5UPpW1WlvbGjua5ZLxe9Dmtmdskom/vXbdAcDAV7HXhXHU0b0fypiNFiD3POZcWeCd1dzejpEI8uwput99dxDjc2f8KuCgikE6WEhgbAYyITKUuQ1hg0PCAgv0C7nu2XN/e0mRne6nGTLUbQ/8LMnXr7dEMH8dgaGls2XLZh+uDFtj09AO3w1hCqEAnPIrgGYAt4CPpOkrHCQCwEUGF9EqQHlAyiMawpsjDf3tZQ66jAIvNIIkvoKFkqQjy4bE6iAIivBEaEnCbsD7KTUk/Ap0plcDVidJgSfAmTFDMOAwIMXYMBYJ5IdgFmDMQLTscMQaXD3CJiRVPv/fiHBk+dOzM2ArAnDoVRgFVERBioDqW/HI3AzSGCrAFGSqt7OzpWhOzNwXqfLxSLRxai0aaOBkxfJhpx1rULkSXU7JlxO+z3gNghzS+MzU3ODWM7SppjXdZgx/o2xPpZt4Ydwxf1BPobG9DdrqrD1URmGgAXh8sFox/VP8iAZpdyFmxUQVWXMmn4nIAX0u4Gq92HPtgdPW4z8ETYy08prG5f3drZVkF/AsrSdNl2bBbN8B48DjpkQzYQhiJZe4rkLTAZJJ5BwhsocUYEEBmEmpWB4KeazpYAXUQJEkQTyevrKOtkR8fPt1R1uy+IXm+1LD92dABxQSBwOOL7GtlchIg06FA4vogHwpEm+6VWKXQ+xrJAkApRD4RXK0DqLLM0PsEEc5wFB9940w0+m/3y625IxTMvvfrC2PQEyVQjPA62qJnKtWvXFsLmLTt7e9b19PV317dUjVIsNYfu0GGvt5TIIBVDQVSIZc5uyxSkooleSGRKZXF6fk6uiOjwR9IpqgHx+th8hEj5vGKzOODuA6mC4DDQpJjuSp5ktmgwkQFIDw1AVUTjMO4EmixjNqtVb9BuZc3Y6BhNsVFphXjx0NljaDfU1r9JV2xma0CC41lLVYA+qgAsLxwOiB8N7IonIETCgsCEEMcLmWBNQh4U34LUAG9bHcloBGVP2XQa+BXkBRTsVy2qTY1NDFqqoxK6JKANChKfRDiQH8KkNb5G6BM/cBehq0nDUTAxwkpkmzLkX2SC1yecj+weEruAn/EWJBlBBERVIZd8wTBtZbGMsMnN7Xfetnr12mKhhFxF7SbEUiBSjggCis5ODk0OxzasCs5ExLomd6i+69Lxg5Bzk6NTTovTYsXmkIytbbWnqwWontYb1iaOvAmxg8egLMBiwZNXYnOTbatWzU2OI3UD77BQzGqwjg1GaF3gynRJt7rtwGqDONgePleQUQ6HiDoiA6j+qPKGV59/+aq7380ywdTcks/peuzhp9B/4j++/kkB+0T56wwGAo5hLS6U70PpwUfiEcVAApXkMmEn6kAkQhrASCE+DgpIiB2D7IuKtUI0DMt0tHeWZRWYdQEBVGSYIad1bMxmAzjT7rEg9UsSVPghSUSsJEh8QlqSM8CKAeFhM6CoHg1zIX3QbRfCDWBK4kHBu8Z9sE82+SHnwguqAQkwiQ1NzT//2QNoJQP9D+4DIqKzvaOtve3kqeNYTrUpxuUJ+xgjRvbmr3/iiadfTbGJlJKPR4ZhJceiyc7mBuzvg10naauzmErTViRG4MgUKrRbQyU2dDxwitBRIa/FZksk4xgiWjhhywLUDKYE5PPTRL0ZKUfQBcsIclQgDcRo0nbBqFo4i8PF2t2Qy9LYuVEqnXHQFOdkH/vrn0124w133aw7/FSlRFfiyNzJZNu0FGp0sfslyjSJ7lIR6sGm9ghjoHAIvg4WIwQvGKOIhv8s+tkaqmYYj7KUL6WT6SVcMy/m54YHzTYjkopQjJJUQniBUBgZYHioiDJzHPQzPOVCNo7dEjPJaD6doNCzhlJRuEimFVufFgtAVULcY0O9YiGLnCLmnkw/sROJJVVbQDgS3E1wGAKWCnBSefgfciQ6f/T420APgOrEWST0J6vt/wPSV9zsxLx6GQAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 6/12 [07:43<06:24, 64.12s/it, test/blurry_cossim=0, test/loss=1.08, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=7, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.397, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=8.7e-5, train/num_steps=1064]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 58%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 7/12 [07:44<05:18, 63.79s/it, test/blurry_cossim=0, test/loss=1.08, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=7, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.397, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=8.7e-5, train/num_steps=1064]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCpFpaH5/LhU+uwZ/lVpbNlGAwA9qbG5BIMjdamDqB99z9TVGSRC9kSeCP8/hUTac5/iB/DP9Ktl17O1AJP/LT9TRcqxTGmnPUfh/8AqpP7P5+8M/h/hV8IzHAlX8z/AIUpt5gM71/D/wDVSuOxQ+wN/eH+fwprWWOC4/T/AAqy5ZWwZf50wnP/AC1U/Wi4WK/2QZ++KX7Iufvj/P4VOP8Afj/L/wCtSjkffT8v/rUXCxELVjwr/wCfyqT7LIB9/jr/AJ4peR/y0/LNODesjmncLEYs3zkOAfXH/wBalFsy/wDLQfkP8KlDrnl5KepVj8uB9RRcLFdoHYY88/TP/wBaonssgBjkewH+FaPktjon5f8A1qikikUAkJ+BpXGQKrf31/GrCI+OBGfqKbs/6ZfjxTshBnYwHtQJD/KkJ5SLrRkYOBCKjFxF/dY/X/8AXQJY2bhEx6Ec0iiZDkZ2wketRSuwwA6L/uk0kc0f3NuSemQBmnuuQQI1H1AoAgAcnPmRH/e//VTTKifeEB/3VpzRS9vJ/ED/AApPJl6+XbkfQ0AR+YH6CNR/u0BsfxD/AL5qYRS5/wBXB+VKYpMY2Qj/AD9KAIckn/WKPwpwVs/69Pzp4hmHVYT+H/1qmCDHzQJn/ZAoAgEcnadfzNSCKX/nqn504vGn3oDj/dFIJ4e0afgKBCFZB/y2H/fRpjpIV/1mfxNTiWJhwg/IVHIwIwFYfTimBAFc5xKQM9CxqVYZ26Sj/vo075B/yxJ564FODoAf3b8d1ApsURFtbgf88W+o/wDrU/yXGN0UP4f/AKqqF5Gb5LpwP9piKeILpul0Dn/poakomfYnHkMR7AEU0soH+qkx7f8A66ieC7jUs1wMD0c1CJlA+eaY/T/9dAifcnXyG/74FQPJvP7t/L+vH8qFcytiOaTn+8anW3lA+ZYH+o/+tQBAkdwSCLiNh6FzzU7sIkzIrD3jPFOMTLyYLYfT/wDVUMkNy/3TGg9AT/hQMFvLYcFZG/3uf609vMkGYTGi/wC9VdbadTnfbt9Rn+lTKdjbXjtsn04/pQADzY2BlmVl7ruJzUy3Ftn/AFQ/75FIV3fdjt/+BH/61NMM2eltj2H/ANamIf58JPyoo/Co5JU44/KpPKkA5W3+oH/1qgljk25/dCgY07/MOJsDPQsal2yhdwlGP940zzYyceUc57qKBNGOsZH4VTJiPW6twoDRhm7kKKnXy3AKQJj8KgDRuMrBx9BTwUXpbn8Mf41BQTW08jfuzHGuOm4ioxZXI6m3b8M/0qddjLnyCfrj/GpVVFGfs/HtigCFbSYIcpCT69/5UotplGX80/7jUjX1rG2GimyOwH/16Y9zHcbRAkiH34/lTEQtLGj7XN1x2JA/rTmmiKbhHPt9R0/nUotLkHc6wuPQ8n+VRyzQj5fIlj7dMD+dIYgMTR70ib6jGabGY3YjDk/7RFSJGfL5jXnoYjg035EPMMh92AP9aAH+UcfKifif/rUqxuv3vLP40n2iFfvROPw/+vSfaIP7h/IUwGysAcDKfTpUTv8ALj5PxqVmWTlNoA67hUMgIX/ln+VMA3jOMsKcHTHKs3vjNAdMdMnPU005J+VgopslDWlRjhGkU+3Sl8qfPEykejuaApHeE/Uf/WqRUY9FtzUFEZjuMfLcRp/usQP5U9Ibwji9XP8A10b/AAqdIv70MJ+n/wCqnYjXrbJ+QoAr/Z7oAlrqPcOp3H/Co/3y/evP++SaslgX+WKHB7MP/rVYVF/it4f+Agf1FMDMInkcKl7Jk9ixqYWN8xybgMPRnPP6VLcywRkBojG3UFQM1WNxG3+rmugf97/69ICy8bIuCki/9cW4/pVdhIhH+kOAezsc/pS7XZtoluQ3v0/nT1tLhTl2Vx/tc/zoAYiySc+cjfUk1KIZB18v8v8A61BlgjbDwEH2UU8SRv8AdUD/AHqYCbCR92I1BOoC9FHuaskjoPLB9jVaSN8ZLZA7UAPRQR0U8+lPwqj5kQ/zoWNj6VKsR2/MiN796YIbsUjPlKfpioneOPrEy+4AqV4JH4j+T8cVC1pc9PNX/vo1IFVpTnieVfxP+NOSVRgtNOw+v/16JY3jOGmiB/z7VGC3/PeP8j/hQBb8+BlwN6k9CMA1GBMxAF3+bmmRvg8yQv8A74J/pUxuI0b5o4f+ArmgCaO3mx84ilHq/J/lUjw4jJ8qNOOqdR+lU5LlXI8p3jHpjA/SgO/U3GR6Ek0ANZ5P+flx/wACNIkjbgDPOR6Kf/r1Obi2248vn1CCqxkBPySlf+A4/lTAuoYyB+5kY+rgGpBE/wDzzh/KqAMvX7V/48atxvtUbxK59c5/rQMmZVVeYAT/ALIBqtKRjhXH04q0SMfcb656VWkSTHDt+JpCHc9jj8aQiTP+tx/wI0oZBwQTTvNhxjyuf90VQIRYpg2TJlR2DGoZJ4skb7gH2b/69SOfMP7tkX68GozDL/0wP1H/ANakkMI2SQfLHE5/6aDn+RoMUnaG0H/Af/rVBIkqg8wr7qOf5VGskgODKjf7xaq5REzRynjFsh9h/wDWpy20+4FmRx6Hn+lInzDLRwN/u04OjZVFKn2bH8qVgJyYlODa59wgxUgVWXK2yD/fAFZzRzoCWmkx/ssTTVnXp59x+f8A9eiwF14ZT0jtx9B/9aoxBKD0iP4f/WpBII0y7M4/3yTR9qg/uP8Al/8AXp2GSMY41zJEn/AQKjM8Z+6ZV+hpVlik4ERP1ApzBMcRbT6gCkA3LdQ02PemvICPvvn60hcjjzJB9aaWGwlju/pRYRZ2O3KsuM9zSGKY9HQfjVdLmPHP6UrXkAHK5q7EpkjJKCMyRn2PP9KYwkHaL8qha9tiMgAflUbXsHq350BclM0WPmjyfoKPNiPSE/8AfIqq13Djg49ximC4TP8ArWx7mlcZOz7m+Vtg9Bx/KrEKjYDhH9261AssRTfsBUdyKPtUAAwCv0wKdwLoH+w2PQNxS7Y/+fdPyFUxcxbdwL4z1zSNdQ/35F+jUmwLhQZ+WGMfXFRtHIf4YR9F/wDrVAtxGekkn4tSGeMniR/zpJjuPIdGwZCPp0pw3n/lt+ZNMSaMcsxYe9SfaIMfcH5CmIlVHAO4o+e+c1HKpAJ2pimGeI/dJH0qpc3UapncSQe/9KajcZ//2Q==", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAABsrklEQVR4AY3dWc8kW5YmZHNzM5/dvyEizjmZ2dU0UyFu4Acg7rhBAroZhJBQqxkl1AgJfmxdNlR35RAnIr7BZ3fziefdHpmVVVnV4BHh4YPZtrXX8K5hr23e++f//H+dVcOXt29Po+aHD5/Gw+FtX80m8+58up4u1666bqvXr8v/8D/6d1/f1rfjdbAYvS13o9H43/7zX374Yf6v/u/fHY+HutcbVr3dqesP27/8q9dR2/5b//5Py+Vmv++ePzy+fn37N/7Rj//Pv/zt4+NDXfemo8Gtug7a0a3uNcPR18/vP/zq4+RheDgcu/N5uzv2qlvVayaD0XG96S4dKupB0+sPrrdr3e/1bo0TP32aL9+Xm/Vu0LZt0/Sr3na3787XyXh0dcblVNW9y61y/LBtu+Op6tUGb/rN8dA1TX2+Xa/X23DQTiaD8/Fyu1xPpz3abijrN+fjqe3X/brpNe3temvbuldXXXe+nHuz6eSnx+n+uFkf9m8v6w/Pi6fn6Xqze3/b1aPBbDzsTt12tW+GA9PsD/q/+d3raNBMJuOq2x+2+2uHlhPSTudr12sQ3Myf59dvu08fH57m49l4MmrGg4fh42y+Xx/OB0dVy/3q06cPHx5/GPVn58v10DtfmmGvd/3y8rW77PeH/fV2Gwz62DQcD5rp5B/+m1hwrasWi+t6UPcG48nsdPHNfI+67vD6erpWl15VX6/VaDLZbfafv/66HfcxCJt83mDpoH8+nKpT1W/72HPp9U6na932r73r+XC59Xu/+fXgcjzdiKTXO59OhV198iaLc9cZpj9oLuer0+uqrq4k2rtcr82gvZrzoD1fLv2mxobBIONcTqdb7+xg7L5WtX9NP89VXd/Ol8EQK5ter0bW/rjd79+v15OpHM7d4dvubTvo9/pd9OR4vhybfr+7Hk9Yez3Ve3SZkJG8PVeOow7YfzlXt3Ovh4Rbs18eZ02v6l3q67nbbYdt7+TFsSWo5ft687Y/rLw99f9i3O/XHdY21Xq7H46adlj5fLftaurar1vUtnV1PFPE6+l2OG6PFypz6dfry+nSrY+7y7Hf9K+XK4rqKkp+u/a21N7go95hfbz2r9ceSuoTTetQWPW8p6tVhc3n662+YuKNktaXenfaV7cLAVS3W+9WuWTdN3iFDTnidjtuD3TYLPoE4GIuV9/I2Le909FBGJoBj5f6xFbO15pQzsa+oe1WXU616zqmh4TjsTp33rXN6Xw6H45DKnG6duymbczFMbfz+RopdtWgrfeHa8Q+ILDqeDjfTv3+4WBQbDd9TENmJN274lzTXc+782VS9y+XS3utL9X5yEDPp8/v387H8+t2e95fELv+V395a2qKMBwNelXVXk+DS+94ZVgnqOBvzJQgz4MjXehuBzaNQddbH09O1+OR6E7tsEWF0/uYjwU1vT7f6mp/PNUtFjMJ0yTI1uwvhysGEQI2hOfUOOLpVdcq4EBlsOGa0Zpb/3K99DCkumLIpSKY/HM6nCmXK0ZAnVvaCMBiSRHvrddSnhst75yba9+YZo/BmKtzaYO/0ZeiNt3thOBzJITUK/UaYmv/Uvdv3fFStf2uPo8u7fp6Hl77VA+njtcrKlHsmkztSmgYXaZCBLjdnM8dOZ/pf69+p4iu1V0uq+q3nz/vut1uf6abiKy6OhY4aAebdjKcGG4yHEw6aHnu940fQ6dN/WOfLvTOdX00akVB+0XVQCh+1Bdqe4UKNa2NXhaW9+Fcly/pHu7Ug9vx3NbDLoRlVEQHQXr9wqC8wKG2N4pkqj6mXOre8dZhPIM/Q8kgTkW81SWcumE0WHFoHygxQOZEvhkbPpyPXMqVu+ud8DoWmK/gVSTFaozT69fE69PgyYVgo1geEC7yPfe4lrYDMAa+1rsGo3vHGmpGhJgdA71cGkbshFBAPWJohrnUFzQF/y7trb9tu9uxNwAzt+Vq/fPyG5g7dtfdsasurtxrY16DcTPgmCHb7tYNuiMFGVbw0QyNyfT61z79oTYYgM+cQT86RBz+p+AVMzU75wUrUM+dHC8nymiuRMyab1X/XO9PzZFRZOjg0IUy0yLq7AXbanodnoZJdX0CEFdugJqDrR4zpxK0IFiU0z3FtzAqeIYWdBbcumAZzp5iJ6wtUJVHhFeuE/13PST6zCe3GkgZHe+iKcFGiuR9vIlP+CdOhzk6Dm23c9/0IjHQWrcuH4g10btdFsJq5guUjszgcuq3+27Xg1en2+++LZfL3Ym0rvW+62ACJg6qYXtud6O4Lf6AawK7fA5uV6KQQCEtKzzqsRmwVD4BF/C1gHU0P4rnBBONLmFheGBu1OyG9lh8BARAyPl2bQozAkW40KPSrCYDHy6sjMZFF30JzEFCANlxV3IFskKaCCCP/O/aJ0eGG1UVxUQd441cI/TI3xfe59p5mE0wjGhxGob4tiAnJPeIKjkvJiGciNgYcd2EZnLmFON3aX0CCOwxbOV17CqTjn2iCVA2Yj9j8+iDcXU9dr1hc9yC7I5EOl6jShACXJu6YeuUs7k25yvgbowXXbpe91eRG/WOotcF4vMCopEPN4TWXiUoyOx4U/AfpM6zKRAcg8EXLjBH0PQwBUG03Rw48f4dqgyJ4jKYywZSKrpLBODhLgF8d0yYewn3fFoUN1K4v8fo+N7QUSTBzwdzfECxi5CcFGrinphuZALYMhJu+srlcuWc5hgi5MbBSA7C1ZbuXcUynsLmi0DwrmhB1ri9EjXc3QeqneK8azMaD8b4tGg/NOP9eNjchufbcnKI+hcUqTHXDKiRq5sgH9KJO3uVgC8g2qsO3bF/K7YQtMG24LbDcUKEmMnHMcZIhCxR0gAz7puFqOZM94NImV/4wnPe7YQfNdfD+QhPsM11fZtDKFDcOKu5NbARXplHhgTlRYj4F7cXvXR0LE6ME+rpY4AGayPOwFfRfeQ5gfEJmMgsapBvothkw05iYbf4IHpcYJRk8A9NxS3c+tRMssLHZxZQyWVyFUwOucjo94LKA8pkHtEcul85jQCW396X+2513q6G404Q0w52t+t2u9nudgepByQ4U2GsrkfTMTdgSCI5dFdRMJzB+NlCDEVCRUhemAhYyiPTwXRk0I2QFm0KTb6LdoWjUVpnsm5fRCxizKCCV7da6nQ3FpqVczJ7/wdbMv+M2d3OIhZzLgSYLhEVM48d5dqmKj7LKUSbk0RBRYi+cz1zI8ly5fvgzsJ4hxQJocqZsYbAz52uSC6YlMnkKOHFtUBuJUTyeYTNuOkaAgrEGT4qQsa3aoA7k74015UDQf/ef/DnfSnXYTvqJSISqK0P3UCCtNzuD92uO0lNoZlpDwcSSbCSC4TDUdwI/3w+mUOswfRoiBCiSP7Or0wwShAuhx4zNr1M8q7RfBXdyRQzGUKhxDDNSJfzsO7LbpsoqwGigjmzDML0XCWJ0000bCjoStYiFf9jWjiIUoMZ+8Tgo/OgoT73sVGgUOSZA43swiXOwUnvvUVrMQj5UkzAWFA0BmyU6DBDzssEV1Go4hGIJPN0KfpuGGbAUwYzWyfd+twg1GIqp+jENcbI5d0auamJ7bttvx12EoRTxQFEbrkoFYPv6GOF4EKEnWsElTNjjqBJ9nATeUXpIlLfxCVnWmAjY5TnqEnUx0SlsWGiL5BvDmKMxvg5JUJl177iXjAj+SI6E+RH0868+d1gvCsjwB6xjpNMPGrc46c8hYbBlc8Nh5xdFB+ktmYughoa20Fil8Kvpol+8XW8a2jDcNiZqUOYhuldMmI+LlbAwYTT0aDoQriKxXwh1WGu0fqiKGQZ78eHiQwxtuh/eBmfhTEZkR40osIYFAnJBEgpjL7KGKXpiSKJW+RlUHraaw1tsAxNo9mDVFMypnYwEE051bXC1wKIMdnAQlgXdpEcyovzucbDZg6OCMp25uhFee2UZJjCi2hBJnjxMgpLfOZ2bWLMLC946vNItInGCRDCl7t7ENjLukWF0izcJN+g28lAFKvEvEU9CgkYz3gJkgAjfPgcUVKB6LwL0INMhITJs00hoWh/FLzEQD2FHR6REppBCBC6FdgK3SFRqkEpWYjvbsPivqRvuEAzmkN38IWAn6maDE5gV2bKbvreFWgp+BDkUc0ANf7528avjKeDc3cSavrI/M0irLyzAs/iG9iKK4Q4AsjbAkLYHY75m/e+DItzqrcowQDqGM2IehBDZh9TTq5BqmhEQgK0hhnH3pXriupnsBuR+E8diTGFl87N56ElGBdUdMU8x3rQ4LOYqudQyzLkx6iOPEJb+ThzCYXhZGw155mSj52Ro/z1z8h5gU/FE9bMorm2bDXERhw5BpMzqMAVJgFISNKpHogn+v3T7nKWgBG8YDqaU3INF3HJBAt08poByzxS7WnFISVquxNr6tH7iIRlIskMi/ZQ/yKhMvti1YXYsIpJFMojkBDHkJIMRNlzroKDmByry3B5wnEM4pxczIHYlWCZlpsVlvcCdAWeDI7eYj2w2HAm0VPQyjHIZBStZww8RwJF0oEzNBi58Ds0hzhfxzpv4X9MmVmEO4Vyupt8IDYZicbl+I7XCs236thUIx9nGjAifhrFgSYC4LhPO3VFsNNLoH8+7ztlGCjSPwaUoFDCsrhFuJhToxZwOVFaJpRJ50UUJ5gYKwnpRB0IDylmJyxmyZEDHci3ZW6kmElgfqoNETepBi4gEA6eijigOWGcej2xr0HNGx6SrOFjEKAakbF1o/bEyKQnb0yltLo05VodOI39xOjwy0WgEJkRBZ07yRrj8kw5vk4YxieF+HvGnok4sEASoIXUCQlxIqOZaL4NXJlbVM8MiebWZN6YhCrcHyfOSGjBNNEe6Ag2xJKUpG+im/jlaLdESunsfNyn+BeOuIT5i66ipLlo/G1CYyM7hUgyNZSYFT66IgUpGuNb4XVOMFMsV99UyHdaTsW94BNiTSATYZtkEHUpuAy0cT8Opbod5NEmGJPMB4ZAGZfZSvkJz6lOxP88R4UN1/VTMaPkqRBgQYqyVZPCHauuGqbAwmIXbBfaQIYcxlIURsz33BRVQJbJZT60NQSIkA3uX2KOkIaQTC7TC1kFFBM0FL61sV0fE/9hGBON3qWg0LhwwQja0Gt++5ufB8eTmqeVDexsmiZW2TSr9c6ERNnGGE0H0dMkdvVoJNsAy1SIMuWPCiGHHAEiiDAidtwLj0UA2B8biYRoWtzMHeodzBpj2/HRRdmdE8vISE4m90ZRyQRpH445JhXGqFxYcnUNzItcmjZmikV4AlANAncdRG8aSwimMxqIuw9dtAo50jcvHI7nqptxbbELdOfjQEoqE0gO1GB8NFWoQGdp7/nWDuKFMBENxIPFYX7eOyoFaudRzbM1ofrqWBH/EfrHZHEh1zFeZIYWavHjL384L3eXdU8Kpnru44eH2Xq74zQsLJkMYat+hUmJnqkpTvb6KsYpIGOnNRMVPbRG9Yi5aFY4GZSACb5JLBj4cnLM/A5jd8Y7xd9yWNEzr03MFEItCyoflogvNkzqyAgixpk6pBihUqaD7wYfphqST6ssEwFYmKE8qbBKNyR2ho/6sWPoiGF5ZNElJwVXvKQXSWu9Y+f8CS6Hdywj31MoRV98d0AY7dvy19tQHeqdGaTHuqqn+E9gHFjQgXjLFEJt+euk5vmHp9t4wmEPBsM47KpaWmHbboGjpRJaYZ7hOnhq5XCNdB81Vg/YPx3PZKLqnqInXiIzWhvNwHq+Jlac6EqoF4RMuB2oAjtozPiozsHlrAB0kM+BFN/oCMowgUOvlUk9O8SfIgOiBXqcfZ6dBkKxyQsMMoXYSNjsIqmCOIkixz6jSmLOOjoEoMTn4QgqGF2s3YCcixcO59RwOmZC6pxwaEcOpsQCnBd6yVPhq5/58rbO82Rmau8wZE+bm0rxEpOiQhGUf5l68/mvPk+uPcW3kdXgzDkFvJN85p4wgNGi3hIDFxwY04zMJNqSGoXcI6FVSawRXWCF8n0XcOyH72CQ/keUr+W1mBE2o7kwEy0hKc4gM/RlbAxHQiLdw1iaW9TQGCWAibZG8OFuKRIb0CUiGaJRFk19LJJwujl5Ia0J5hswuSSdwHKsiFkAbacXoMO+m0qX42gk+gBUHGSugryUrShirouAYvHlqt9Vj5QBDzEDsUCwle+Yf//cD6pzKzcLzEZVMiqTNUr48fEXH6pN18xGDPt4sWR9th776acPw+Vot9+ygcFVvZ7/yqQjwEQAiTDNikFY5GIXRopBixddMVMpnAjdmWTYGZHAUugMWRxkUr7Cnu9fFs3K+EY1EyxQXXENWU/hUhhEx6OFSrOULr4pQE4IgL7EG3Q6zBNWn+VcgjoLUKYcCE+GLDAhxsAJkabIT3EFHVlCQAq2yqUidtcGNexYJgw8LIGbYjQ9AvZ/MMfrEm7IhsgsZGCP4YKu7KJIXtARSEFhVqHFian5W20uhk9y7TDeuDnujy3BWQ6orIZEtRnTsTse9jvrn/5aSScVQ/MeuBc9S8E4+Mxv0yYluwRQ4T9A8BzzD2LclSTqBnzDixJ+QYQcGoFkPiUYos7MyZsoExjBGqAXbUp8nYMdLYAxM4IAIf4j/qyleXVR32EsYICdoiA8jCT4Ady33Jjr5U982LmfZR/4iocITo4AGzMrcVG0ytnJn10GClBqtPUq7qTMLyyOUVugumo7yAqZyabQ3+sdJKRiZfw1AzpyivaZvZhKi0mJHsSBWTmN/nJpuZQqnjk7Aa/5MmdZdraqu+uO+h0OwlFLidFfvkrBO+UgD7MPzPWOlzWCGAUmMabYc0ybrkYiLmL+TF+MVMLczMfrwsNw1fcOjjGY5B1Pc63w27/C9sQ8YSif5rAUqB1bTlFiS57oYWErJCVAAT98Lg3wKoM7NyUGalvwgUCsDhGCPhrSxnRaFeP2FgGmHxVlduwxZmISlM7KtaGtZFD3Pj45L9GY85Nk59KE5aK+j1AjU5FtSGCFIkcW4HyG7LCykJKE2OUQC6ya3fHQ359wO+PjFHphtLzMw4KvAmkyXx8KocNrsEVPozamRZL+NFbFU1cK+hSlS0UZHoQxCU7osj/oaNuhqBgDXQDnSnyH/AjYv4CNkQvnyTLfY7WCUIKWyNb47MhXhnS1AaG4DJvXIyDbT5CIHRma1EXS5IAjKdaW5gXDUTTfo1lWTdlj+R2INhFrWMlzRLHGS1ENQkVAVByXbwQDGZShou/n87A/0JeCEsjuexclQsRmMklXE5GZuyoWYyYyAovZZ/FSZBqlClQx2vS/DLTktPUoimmgpIapgNZjXgFROpTO+oPuOhG4CFW4gz/YoxWi6Dl+pFEjUiYQsogghQ8pX6vZWSsa4iujDgdZikHwybeRQ6iODhWAuafoQZpYZuSSI0IaxMtI+cpFfC4vcxlsdZE4tH5rKEUtgDCctsjJtVXPzi0NwBSm1s58kgpNrOWiKYhkEiPRkQim6mmMMjgywyOHCYoK/Ywk3riqtNHAboppIFSpG7NJ31KxKIIZ0fqBoPCCC4Yiraz/lcIltGibFpQctkcQNhoN2BgCiCuRQS4Z+yZ1HHZ1rBWm+P4OFUl1HEPxBbrRNSIT/AHQ6GEE7szwja4aSO6FvbFG03e0gZ3hDSWjzzBFKBuzT2SXy4vzWuIJr8vRfExAJ17FFCifZhhNNCzA4MbsBuPB2dK9uVXtsWid74IW8CDF9xjARQcQsOrSKBeY6BxPC72JWDH+ym0UOKAQuHO8HXXauTCacY2ymUK6GZA4wquohTOM4fzj4UiCwccAj9OD+enuyiPCE0GYYgfYQQ2T1EmgaUxLR/wQ7mAk7XFSGZ+nD0PpDFbFIwkQuAbCJiAr9x1rYWlcSJhkEtjC/IrxEj55cYIpCmV2Gequw9h5d0ZYUMyQhSZsBzk690yOyRS0ppXxTgnkU6lPLchVCsKQcICIq8xcQT/mKoAfXLSleUJsxhWG0nTM8qizOKVjxSCEbeSod9JyQ+mbQwslMRbhJkP00iNJmZnQOMfm7a300JlnP91QFhvOSUOcqGvPWcPRsOheknIfI8u8EthkFoo31mB6Q9VnOirI+e4L1Km49ISoNAP2NRq9KB5anK2wzPoO28PpYJWJrmpM4ZW1Z7IwlBX1IyEyU9gIicbOhIQFTC8ixD4Dw1OCgBdwjlqIxMgkfiPiUWptxzIKoWRCcMOYrkChGbZWh1LVCK4YII6VPehwaIe11swIXOfh+TzQ4HVi6s1tf0rbaPS0aAmmH47sJ4xFRq8+WjcNUFYnDWTp7UiiRBGgb2K0zCnBEx1wfALfpGaFVywcwsXSqz06qRtTE3dYv8ojano4HBKh4qNio+OHZQA6nzpIGBrfoutUAkqBYuLpHWQIsr/4c71qUpb5fFydrsvV6nsjVL8ZToe3DWM5yYRTSIKqFIwXSv4PmUohxeTVS1kdfjFUawPYzsYoj9CC9QCaQwfFkHeotLGkquMICOGs8+YYmcTJhXUZRJOd5iZWog5oiCAT1xVVykHbajSdWKb2+XQ83m02usxyugrb7QD8jenc1quxbKeEQIm4m2HWyZPC+9AFA7YB0ShFeOQjVBBz4NRwhg/uoTQWnpe5uGh+s9qCHbNF5J37+ldBbeTjlCiz1rZrRG2ke0+qwWLb0UuUEBW8Ajh8Q7fXKNgbSaG4cSkiC0FFpO8DQ1TX8Wg4nU2ihrstCqUCXFewhVIF/ngVr3Kki0SXU9Iqp0b2ocrMooZISxhDy0+ia2Kh0LRK0wt5mAMdYKIsyclctNGT/rQWCe8qfGP7kDKNIMKF1BHVpahY/6IbO/1mYJ6lWOO+6a8+W55LdK1oVXcuLRwfWIYMlaZmWYpQXYhtJ3lESpIk5ADOEB1vlNCQhxcw+jxVHTISLJT6qcxOm2dcXGKCpGloFgoYSr3gwlJvbaXuGRY43YWYTlwdGGBh4UWZPqQ8D9uhYEFq1mjLIoDYftgmF6Ql6RxOV3fbDWIv0misBKOZR8QAHZK/sGFsTGgTR4imiCKTMMPUUXybqkSOIQRMzRxTR0t04rMcb9RBVKnEWdbpoq5kPGwHmku1SRvPZFJ4MlWXEUT168NuT06DZnCExQowlAyntEaTaCddK7oC92FWB68Cd0YZNC3FpxfRnHA/zs+rYggRBdPwVWZQSKOMrhL6A9cBEwIDxrLz+HGDh/tSHFGICDtWJuhhC06RcJhdLuUNcdFiE8aIosG6PBmHr3SQN5v1WtOw4CHmF2ZVuiH2+yMzh6dxibRBzmMI4yL7vgpDjwtAu0Rx405v0o8rOoyHFb8z+Su7ScQm+eJEgoymbvFZl4KGpCxpymExwnT8r6eea4wr1pe12wcluw6qMKBBPWJq0hgO8bA7VgKVY29/MH/xtbHTxqtR73bYaR9OczyxoBVtRHviMBGUGbPywFqAiO7GasNEbGHWcOnOJ/OFe864iwp9hXuRR5n/3VhMgmGYsgo+bqrhCINYA2Ry3ehcAin5XSKIYmLBI5cAGXxFzpGvHE/NZD6eDLLW1BFCfK3dEHqz3i+rq87x9Wa7JwWAG7UhhEB9/o8D91czrs8FmH0Ix7lzBmgIBWnnbzQdD0pkTYlc1ZFORdNwXO82x8G0HU/bjo9TciI2ayUcpEOZIZ7iWCYQKKbjZIMTNiL4nuJQ6el8IhrRrOo74HDdnvX++mOdoNc/kD8RIpXmCjRhJg9GodEW/YxDjTpgFLYEU7A7rIuHHY2Gv/8yZISpopXUr3lqHeWhDGHteGg+zkJaehvIVmObSglU79WjyTCGImTSLe7UjtvqjUWfujCa3vG4G9u24RjVtFCptSLd7w4MLQjxwldASNM7tAqBxT/lRR7lGS9pF0kkCgUsApjMCuzSgdMhxTB0R4mJLe6aM08Ye0oNh4qE74f90ZRi0UllrBVWdjcQpguwv1gtgGEZFxslhufuPBwqD4YRJ+WQUbMVHegXa4bd5a0/FnGeRnV72HOVdmrAwSRKhkdUBJWSTgpwJolmtCcjS3AWxjsy2h73nzptHvdZkhKjAAZsoCzMZNLO0vdnSuYmvnJ8ZBkGsm28SITnROYr3BYi6KZVhLJApNMN+PjI5GVpTnAcBOMw4qV919pskW+pYXQDnTaWMLHoCQsIu8tzpF8sI6MDHNgpsYj8pIj0uNTRgmx8YyUuxuQkXwl1PasRXihysme0k1Y2U6AjmtrLbhm+xw4htmQPAQ41tU1Ik/EAprkEnJE33Y7dYNKmS/WiW9LKazWZDCHnYNZK36fT0UnfcaTIB/XNHr+sjmXzBWsrSi6+9AqCYwJ2F1oQFapoZPTJx/JarMCn4LoF204bDqtKI2LYDhpv9xydxrSj9nA6tdysYJIiimt7l4HIlNPO6mnWzOPYMFilgjuRPLEoVBQfwV50yen2TIga7aM+abRN750oL9ofpYhURHl5QaMoWGxNfhz6RDvkREFc3lp8lIs6pOtCLueS4YXIjVXsd/uM37aqf/R6qFLmfQECQkcF5uWK0Qqj90a2FnXn0XiISJGS2dY2fNjzNWg0l6XOLWftrsPJ8GTfDly1I2ikmpL1YZpj1qVUGQi+W0ZhOnKK80U6rL6LJbLBdCf25EbRSAQV8IpXNlwxESbM+Zf30Y8IL/Ms48FbOjiwJ0A/QBrWW/kg38PSaFg6rfinRMPNZrn5ttxwwzQribMM+3R6t0EA+icFYDHkxF/AaNCGpPyL7oc+bE9am2WOxj4pVnIvyyQtYE/jgRpQwvzIIwiWq7oGb8XZzCQE5tDvz9opC7AilJ1W0T4o1A1FQmwZlf2y5itatTwyGRHkcDx0wOZ9HezCl+QsIjfnSYQv2+XGaYKf7c4EuuFgMJoOMY55K/CeN1toScxRnUiFvSURw3rne+OByJhDMQjKjmfFl+JCAYbsVhDJybbLOTALrCfUrIfDITYakjTFYNdDloYYKM0PHGddJjmT4jZTRzDLs1hTagO9ajgaJYpiVo5B9Dg9QjcpgFTOXx409IasiMGLPCxUes0apMR47mQa75Kl5MmVqiiE4wmHaRqzRYaBRET+o29ASWpD9wh5v905JkCU+Vfq4UJHQ9ZNh2bS5QwdQ1P43ISK4t0urQF8AZYdbG0ctj7nkw6+ORyzHsLx6N8+pPqvdsCo0UANmDxFvFs/tptC6GEyqM3AycRixdGbBEWsJ5JxjCAFD3BYVAzQtSQlpCaRGLbagTZBAxAwW0dwkt4y8ciO9UhFS12Hk2m5XGJ6+vDYPlX7wwFLmDZyrcijJ+LvU8j0QycAztYDLgissKNQYhoRAyeGXWSQrNCHXHqEE5wXqCXwyHxYcTswHTE1BlwG41GEc+wYh0uZbOrAFv+jDVZ4NGNkOfWw3VFASWPX01mSkrQpyc4xEC2DbHdNmCtZYwPYAZ0lnencQWG/spwB2e6SC9Pi+oNwwqLApQkYJxwuIWpeYG8m4XRklr7A4I401myIJ8PibopbDkt1wFfWLXkLb13d5VgwStBDzWW8Q3FRHJ44MtUbaCqcSM7ALXF1xyMLTlAl8BpB4dFAZBSzTz934Se4CKoUspgtQBACsr6w8feSQLK/Ca7xJc6KDCIbh1BXIab1p6QUYOMI6hiSCyM/hWFn0QyFHdUg6qOqAtkp30it7UgGxZMLFnRDGVz4lGrwXTGLk4y5xxn0pakdRibfoNsJ/k5KRnAcTPnKnAIOnB7frU8//hO7sRPBWfemJ9GU8JfO0NVMKoZJk0Fs0DaXAv+sPEYTSM0zPjKRhP+Oh/jYzCfznLqwsu/VI77YOBnTRcplYqk50A6ZzU4LEFiDj8IMCriyDfXYLZcrEYQ9p5iW4IrH9cwqjUMAovvk9tGWWDQGwDS9KjG+fARecvx9nSgH9HabrSMB5Wa5hg1xQbtgWslUY+zT6RiUAH5MwJCHnz6WAlwgGc10LQcVnY0m3qrNZjsZjcKn2zXbfVPt6hN5XwhLDCV4TyR7viyGC7pJJDb9FBivRrN4QMEbFqAyBAeUAiY4Ew3ESBf1wnflteskbBREBDtjPU4nFxKNVV+vk+nIKUZLUJ0qRZaCaQ19H48HI3Avw2gk/o0EgTxaYYeCFfkaCN3qnhhqbsXOXCiy8loUnZ6LcJMrZvQ4q9VIxg+eMDJ1G3RSmuzfDkUpOHSHrmWPp5T9wLE5CoEpwelUttXbjkzT+PUL3RmbDfETr1BU/mLSrrZZr0ajSZKFw3E0GW83G8/KjsSctTrhwfWy2wWjcJa3tpu5GWcz8265VshavbwvnhfEJq3HZUusWVQo2Zn4fb+zvJfFFowOH8kwqSJnm2yUbeECTh0OCtri8nTOEcBdx/0XhUjBSnyRI40iP4+Xww4oc6XNCQq6fTedDQEri281IErvyA4wGIugg3fKW1XlvgN2C+NXuUjq49FP6AYchckXWyEx524B5dlxnINxmKfipci6iM4OVJrhdT5PPYq+nLfby3w+pcsmTKRwTgQJkRA7nU6315uyB/0VAmzWW1QNLhazLiFGkyZFBo9TcaeqVI3FQhq6k9sNWNTI/vTusAu8qGalUpZqM+3v9luadLXQ2iczechhP5qMbPsZDkdtnc22RkiCHIPIw/zEHtxgUX2rzeKiik4IwxKM0+uCQiSFa7G/OJL7jvvz5ZBGwsHQVokrbXCoobwVunuL2tgPlliIkMS5EKNQeBPvaJsQSzEM2k87vFQE9Qc3SNIons0qBA7KGBkm7+4u4T5qoP/Q3ejvXna9B+dsKulW6fV1AeOSP6XD9+Ckkrp92UpmCQZSfHB3CqpH9/Pdrbff7kEq9wVhtGMIeyjXyd5ZPYe1jMHQceRwDF8YNTKOIggLT4cjPUazMQXQVEENgGoPh2PBhYsyHdMJ9JmQhg6uNfaMHz5IDsMYqLMLUEFJuiiIxUQ04b7nvC7AEzAxM3QYxa0gkggTipUF5XuTsvF2f8haFrcU3IqsIZskxuAXpRflMLeBKEaQpNkYt+NxMh0Tl0tOxqzwulptHAwNIqmksuXBxFWVlVaIFVFJsc0RGqYkKwrUUVF8Riz5HFQRjRTh9XqQoT8aXlTK+v0gsrhTUfPm1iD0qd5vt5PFYjYaGXV/3DPKaTVdr9eTyWS1XtPcorMiwtT7FFEWP34yt81qPZ/PJrPx++vy0w8fd5vdZr2ZTow0l8iMxqOvX77N5rPnD0982353mM5nq9dlMvLUPvrzxYzukzvFMK+i6enbMLcSOyXM47RE66km40NgI6lCXFmsJjzRRgXeRboCGZ9EiLeKUrkiqeGofIZWm6P9kEOXodv9ajScNBbLTlXz9evX63pnDIMTsRN0Ji5XGxSITYkkF6E0dxHspYDyg/gKvia+ATXBejH4iJkl7NsdrdYe9oingACPbmUMbb2X3bEeDWlEo2rTb7arjY1/vMXsYV73F46xBkQhzMjJbouBfJVZylpgOiEJbESnF+8vbzQGdtlOiDHU/2BES06BIzd3gEv1dr2hodyD8Mt/HAb7cBVuGQP33YEhslAPDALciR1ZCe9Vkq+4wEgn/wCLc+lxUNzcqVsYHIFkuTAetdmfDtAD+WwWCNFNYgC2TDyUFTYUN0Fhs87Ah/ICqpJbBrUGwLvtWjy0TTWaGgfETVjEWtA+LCx8zDOjEP4na8unjqNO7M3BgW+3aUlCo1AuNpftNaL+0XzKN0lDvKQpAZlUVOKlmSfLNZ3t+wron9IZX63FYNvd8/Pj6X01mU1xxyrm9XiYzCYWf+ggzmIfmHYhQ3EJgAiGiKncwYVxgwgWEIXgMGi3VaqEWAN4Gx0F94TBvl3RRzqnUwngsdw4IykhuDBTR1CFRAv++Gv1gmATPMOG4BUy+GrBk3PV+KGRJGZE44W6yevQI6gzUmBCdB0DAeyy2wBpBFz/O3/+j37xqx/n02lAAyV2CFuvChYp2qT0ymx6Q2qeaktM4f6IQahGJDVLs4jac1mygK2KpzRXcDBbLFBC1xT6wTFwjPvFJ2iiXqbPd783eSVXoCFUGMhEFDLdX4TPOJ0Xi8WB83xcIOywWt/lH92rZbZ7OnW0lBTs1QaSkgVWrlZruqrdg0fBMuuI4/EkDh8NAX2iOqrQETMqkiWUWhNIJg+nsBt8CTD2wOCBxRANyaDYTTNoGNMBlXiD+94KAYlFlJWm/ojjttvvTIQIN4dDeh/dpSc1Ky+1D9hPx0tRw4TUkUF6cM+9/+a//U+um8PQDoDUuE2v//Lt7X21eX1f487b23KT9dvf893/mlk8CC+qUXDQc7J28doAdwBkrpLUDxY6urgB6Y4IYXto59OU0uSrx266WKi3KSuQohFAJe2iRJDLyOZM37fr9fTxYTqff/v2ooCOHwIhMRKjgUvmT7u1HJQyNbghP+vw5+lisnzfPD0/QaqPnz5ut2vr2zNWKB3ZH4xjjNVy9fD0iCMpMbUJrgqu33idRA3XwCmXNrZMVEJVEZ1VFLBOou70BOvIpvT2wDSdh7UTSQVvxmNe1CdWfUcofJjPIx2c6/XthHfzoYQqtv0CLGJxGjdFKWER2bm2SYoZ9pvSpC4K+mPuh/V3XSwJgegI60dJLPG6lqOWmCGnqCACRBVTPTnkIRd1Ii+92dJNYgIs7N2Lp4d5LLZxi6yBBffV+8qi2lBcpx41GkENHlgScN3tmTZtMn9CY87Lt5UCR3A8KXUlnDV/uol3GCpnNh1h+mG3ld5DI4I3WJTdPUZs9hfIY3pexBQINQFGsaSsLBnnchm7/1bKt8GsVL/t0ezXswmhpCdXtuFaFIWdIYkftbYBWWi62I3uuxaGAVmXM0O+F1anOpT6rpA3dck6KnM+qX4ul+tvX1/eXt/dwmpbPAGEVYYyxN94cAmG5Yj8Ne90IwnpxzRfYOeqFhFZt4KOj5UeczQeTUYQTuep5Qm+Aelouw/AbMmbphxPh5dvL6QWdrsdx+ubaAxP3l5et8v1ZOEeZa80LsqVlpD9eBQPjE2WiCkdex4O9HiH4BJD9zbrJUe92W5F5sPJQKkDDZzQHTfG0wmsz2O/44FwUDzDCIhNQR7UoxwfaJgUlRlzVU6knSligbCdTezKxktVW1Ix2c1qg6/T6eS4Oy6mU+ejzThxD5JQbTXar7nVNKylRB87D85LOXr1ZDoF5fgqWRV18wBmHh8bN/s3HybICefsiJdsw8gsdNgTFR8YGRD3bJxv2QEUEswxhe129vyU4MHt2UQgl5NqGnA3zMPT4iSKqeuHxezhcUbfwEL7uFivN4lPlKwBDQ2SgKYqWW03O5zFLMUTKQ+oDEo0/ddv39xQjPsHSaPxmHFk10lfjLujjCkKHQ68I2yhpNyp2eE7F2JMhhJYSyTWTcbj5ftKmgJps239lnpqIgX5SjJwt3LYKRAQ1cwC0Gj0+r6cTmcQaZqU8/TwME/+ry7UpPDn9PjvVO9Td/Eu0U8Yl7yv93/8n/99t9qtt1v6LPwH4t9eli+vb+/LNUWQ0WRhJDlDOYv6EwnOF+aHxX943N0ARkM3ZfEuBTIQIfqePywEVwD39a9+J++azRfbvUAtodRkMdu9vsnvBg/TDvhgSpO74IisaMPsw0NcYl0vHmabpb38dvO3fOFsPnc7HXbw6YdPXz5/mT8+bFYruAEx6BPPtlq904LFw/z15RXAUlGCsZoL96Lvt9tkNmPr0gVSIWYB0vxxLjSA1caxRpIFZ6iiGsG8JjEsW/sozoePzxyzjXIsBxul40Z4fHr48uUbZ7NbmeZCdjIcWwmKXi4WU/hKrpIcHBR9qgtJK1K8S6tNv/725eX97U1vBG/OrrKUX5jM56DAE46H+9H68vhTm7h/4iKpkqaxkG26qx193W+29Ms40xkOroJU+z1mCfVlq81YtfKSStWd+8PRp1/96knS1NQfPn0cP2BcYyZXFRl7vWKvSVZpPQNdzGdxvccAvdDt4WGxF1OJl/bunnPhPNJk36VH2gt6MJ9NzWc6GXOJLMaUFEjopTGFW4kkT9fHp0dzZS7T2ZjqgTUSVRsoYW7q+BqW317f6LXYJAbkUdezxRzjkE1V6RzdvJsUzGFqAE4KLBvabTfRd4sXZeWdrrMnAUvdHXCEslO14oTDuJTmE56X0BgQR93vWu/ZJf4QjBaJfLcGmUEK1GZwUPpSe7vuD5IANrhfrVbfvtEmdihHZHwSheF8cc7SVdxR9/o2fFio4qy267fXV05PAXb/8vL+vkSXMbdv72yCA18tN1Lr1es7drs7okhmPBvuAELKBgoAbuGIbv2mid+5stlsSkJ3Ry3/EFOR2fPjE+EBJZk2jeHtSWJfXB+HTMbkPRmNBQgOo4jcEowybzGusIUJRjKjkdlbH93sd6oGJiUK0GuD4wDA4IuHBSogMpBStZVLx4yU6LIWTCjZoeYwtyik5ZinZiL0iB/lnTErVaHIP3lGWEzB/UUF+Iqf+5NHJATfsHgAem72WWIDk45OXBs31BR7yG6MFaW1GFANphPiT2uNMGy9scKEp+4VYiTFcNdKw2unC3osqOUz8RSwUBskY1crqU7uPeLFwII7egp20DaejkG2e3CiRyYTI1ALPJ0UMAybpLp3e399w+unx4fcl2ezeXp8jGcWlSkYEJR8iqB2B0msIhFqfYvnYlmRGIGJFCnnZJq4U9KD12JG0B8JsdHuAJqsxfM0Ah47ZzySLmelCO7kBiCAxnovX9z73/+v/2507e12R6DvPpXO4QDelmvxMv/jvHiAJKd/88EIyOOO+xxr1gbSgW22jBodbNtFaQr7JU8U4A59Qj7rTvqroNSrHcCpddvN7PF58+2lmc88rEhLpYvvtcCUvdaGTjir2FL11C3oOJerVOLgzWZDyOAG+1kYz+mUp4/PinrifdVvDXTUCD8tED9//LBavpvJxx9+/Pz5MwUkA2epAzw+P+L86+u7CIK/hWk0h+nKxo2P0YZ1OYJhFvOHOcRIkK2fg0ZfAdpsvd7CLtkPVTA7jofMCHtmW0q/9zB0I8K22sMxqaflpqxYSFnqw+YgoOb0Zf/ZF5bkMH28d1OgvxzA3/HAb8xI8CGqSVlPpMXQ4rKySCLW7rwwNwrFppBOBbrgiVkHwdWlBedsxDHj+WLz9jpYzAU2728vamTWDcSUIjwxhjZVKDp6eiSJyXy+XYsXrB8cp7OpmCTxm/GnU5QSs6CI7pPKeDra77cq3va7iYsFRZRj/f7u0kB19f4+Gbm5LUx/57cRyaRy60mL6yWQ3W33ytbsebc9YMW9cAtqZBhYJAxj7WbPDnB8vlgI/PGd/YEaCVRAb5AKXaqVKqzSrNPxDtEl4da2ZruxJc2qhrS//c2Xn3/+Iq4wgVTQMMV/gIKbD4//Dv7f3UBchTxbIU/1Fn9VkOwwO+zFpfwevxJDPmrjv222G0i3eH4Eu4Du/cs3LaDbl7cN9B9YndbX17rxrrtDtQO82JkSvdt9fQVix+Vy9rSADw9PT+BC2UWgLFLkwZI0QpvRmE7R4ofHhQBYYSdxuTpM/H+CdyUWTASu/CRezydj5jWbzZ09gbKj4fPHZzM9HvdGEDIGTBUSLhdtg/QGDDBibV6zknmx2iiNBiRefTqxqE4kk4n7Nfe3m71FLxuYZEIFdcg6CK/hBvoL8S2MxfQtpLqETTJ2TwbM4gPSWECd6SBFC0IQcQD7TwAf+MTy7v6gHJOQsTq7sZboQrc4iHEP4fU2flw3fV1vVyvyhAOEIQWzA7M/HlDSdjpVBsr135Ycw/o3v5tSc/nyaKQoePj6uRVgfPlG05IQ7QzzrkCxeHpC32a3f39bwnGRNV+NmofHeeK8fo01kg36hOOH/VYRWJUR6MFL1SYRN9OBJxI3p1MQ8CUINFHn3lerKK/KUjqiLLSl8+g4WbiVtXJFGh1wRrlXuYYOOUZI7RbWMIoGuLRVdzFewv/zFW0Olijxw6CYVsAToBJWi6gFtsT+P/1v//WkV7M4EuNkzEQ2bHRFafq1szpsz+QuPRPZ5PH3PeRwGjfHtEBan0UkhnNYbpvpKFUaQSFNVAwhA842MXDtVtKKrwgazaaNkkO6zc/7n78MPn7sXpeTjx9l7ZufX0bPDwwZyewyxQDO7X3dPj8x5OkCHK2F7UoDWTPwYjJkYXTn8VFkKSG4CCxWrysxYq5VqjQUj6v71Z/9ilHK8zlS42cNSvdYSXRhmsGtcSntZfD5BGpKmZ8gZEnTpAg0TNHXJcSsLIsNQXwabZpBb3ssxgKhq8U/aDwbTUQJH5+fBGmsP1qPW5ebgpU1idxPefm64nZfXt7cj/z9/R2thCkrEN4VbXZ7vn8t980saVO2U+E+w/dgRkpDUPzh8ZHiMwZZDy0YKZEOhovHh/XXr06xdEJym2+voof9+3r20y9Q//wPfgUcNr/97fjh4fD1C2rn05kNNieNhmr6s6lgbZDGWOvdzXQ8kkmpzywABEc8mWAEC5D6CR9BEENMnvUwDy6L7oYjDlPqkCD7dAF3JCc7wzvcYA9mTRL7/U6TAJ/gIAYRY3a+nLztW6qDIAoPvBE/JSDGLhaTlobUBzUF6/GOb0htIysHSW/BJp1neRCOwPgqSQMC6pfX969fX7j7dflnMWHn4vJXDa5UqGTSf5/ef/8cKLlFjxrlZAypg55ZMrMuqjS/X3759vj0jAKpo+PNXG6l7qSvAuC1/PbmoE1lv9kRF8ntvn6DglbTpp9+EmU9/uLPFtLXzVoxZzQYz58/6LkERtPhGIyC1Le3t8eHB8Hh6/JNFxl5zx5nqVXMJgo1/MTD04OZMXaBNeYyPgZK4URHvL1YT7yR2pENfseAUokqIh2hhUuwD9MxOyAjjWKId++ipEHMHjyQpFcS4K2/5ax0q8fcdQpNRrmtZykayoIEAlwFTy9jcGvuuFirr/JVnpOEE71QM4oqcA77uZB7xaewmgXeHy7s770u7UNNmBZkgJV7hOuU3/G6XExEL4LWK7xer6wbn1ZbkseF9du7kD1pZ7+3fHtLFPHTL7q3V4ValDx8+vjt6xelYzHSHo63zerri0UJ2SEK19++ud02xr29fsUI82FqSH17VRQbarBhwZbdOQkEiOI5WwrBBLkc5aOE7eq2iQ7dbG0iNBe8W9djJVRN5Cr1Wa222AJCfWQKeKokI3fCTWicBBAjs3xftk955Z7ZUrDoebVarhkZPCzyuwnVBADMVP2JHYvrLVDzOtl+E4PDu2vvf/hf/okyua9VRfWDchpv7+9y0NeXd+7Jh2IAniCliHjcv+cxKr00pTkyC1K6SDkMRR2Z8LZrFyL0NO10G3fBufXnk4ubEVmzU0vBBUtgXTf96dP285dqNktBUm3y0I1TH1SKOXASm5+/SgWGi5ldCLuXN85U6Wb9uiSzx8cngsGv4NuYr2O45/liSiqqWJPZSG0y+fBFMWAvY0IJiP3w4eNquSwRwclZoMOFgORmt1NQA7xi0Ljo/WG+IDaDdQCOCAC/YRO5qQiNR5bCQErq0smzlJjGq7fVjz/+4BYDoqfFfG6JkjMYNc2cg7J2ezx+/Phxs1uXDX1ZMJCituedoqTQld0fCEAGb7VE9ATIYJan7Bv81z80k0MhseByM5yNLfxXo9gn7nu2cpibpy+mVgjkrBBKe11c6Nvyov5lGUA17fPPDfbMZzQq+jVb8Feff/3rH//BP/z588+Gnj4/WePVezF4WPBj5jl7XNCbBLjRJ3XmoZAPngi9cAP4ZMJndgPEh3I9MAK+nz99wEcc5y6opCRAjACRXNX0AQDyaHpCHQGl/QebbIX0XtDJHEFNioxq5ppcxracivs5ErHWEGxnSanqpwB+vj09P6qB2F2uUWc0GwGUbOPJJu/cEgJ703AFJv7Jf/Ef03AkMzAzoUrxBdvdWmKS23RApD+qxP19YhCkjFIzxhGHiM1x3Ium3FOx3CasN3140I5hqc+tQFKjpp6CmYg3WFvadcx2K5D98ONHybhifJBuMvHrDNMPT5ySyJ2twhYqz1swKXUE1kwf8VE9fL3aPC0Wu7KxkKp6rAvyWDDBtbeXd5GVBMLK/fJtY2lhOpqIRgGtGr1EXZ6l3AZqGKGA8IcfPzJ6RYXivcI7b7kBzpiwLUcyBWta1InzMg8hQHZqENXpwphGlnJVEG9K1nZsiEh0y/Ue5gttS4i3K1pVg0Pxcw9HOTSioRupwmvF7rxTnNux4v8f3MfpZG/JabudlfHSvsgA+tWZBej9sQNKJPfyXlhdoCzbPSzqcgzrq4TAZvbV+/bry2QyfXh8ePn8RTo4enj++Gd/VinIKBS7Z0i2SiXSUHUhSE5KNifiNO3jZjeaTcS73DX8pelIwGhnhSn99EO4FrUlsyRWqqRtP62wkyTAYF5mgBZI5bqOoddTJejbTZNLbEtFVqUPzXYiZRlymHCzaYRJo+EY/ujodsxwOnE8Xi6y9hkHQN5CtXDmlh+34cKNaRmSCFEuG6DufMA/9nMMWevgJazqXc6v7+8SY4sMiifl/tFW3bJ7qCh3MYGsZMTjc4NGpH0GOu7SGyvaW39dDRcmf8qaiZpBFtD9cos5D3csva4ePn4kcknfebuf//CR4Z/X64cffjxabXxd9Yuaa0cU1Gq88Ks5qi0PH58xiOViBKyFTtwvByNBkWRyv7p9hhix20lllVUooF/MSbe6at3ExiaL44FE645cBQVPoa/WEbLHTfQLCYlNwDNbzOA9veSIVFFJEU9Tfhvx565tVUuLahZSWLlwMxB0ufhxoiyNDYZPD4/y7oyd+uBRH1BOzY/4jEBYViagAvSbjq0LqnPYM4OWpGMsyOUhIPQkjJgequKnxQGuWPheND2v0rFxrxHlK8eTRzZCJRmxNlYdV6lGmPzmbXnWYaQ1Oi7qMphNxP7Lr9/s/xMOqe0SudUTGdry29fD21Zu/DifKkiMZzNAO/30UWuD8NQi6eH1nfLK42i6q+DG+2+/JKoaWDHe28ZNJnCfQRdXfLQKJMpGk1UcJNtuwuZoLldHlvpTVHVUkChjihHBn3WgmfNIN2zWDpmCkFzpgm5GYWudVROTTewvmE4rUWWFRzQFHh8eHlmbTMolsNj0s/lRe1Y2DmSnpqRECUBoXuqifCvcDWsbJQQZIZqUbfgrfJLZS20oF5H4LCXk1Bp+/7i/JoPk1aTFNrJ9Tknjr+XkDP01u3OvNLOo/BGYXr10E3mgTn3i5VVSZv59WeN4BLfpIKG/fP788Ze/tEJ32693KuGjOUXea2ez8Wi3G81nbNUA6MryTq2mv+EbLdxV66zcWmoRVtI60Sd9xymBN4uxLoqhwpsSyPPP47eXF7SAfnPYva9oLQfrFA8Sxc24dMlB1jUHesg+/vABSrMYupR56/ppIyFM1G/AXZZFaVCvfyvd6ryLiFmtxNECDRglf8Yi9QulPVmEq4cRcqLPv/3y8vLibgV6s2A/rjMFLTHxkAl5w7S//YBIpU5MiryQOI1tUisvZOL3DqLhXKVeEG69sW5no/Ddw7d2j0oUDcABQs/ZWMJdKnHrw2b//MMv3pZLM3z48Zc8quUnIc706cG64EhtU0HYvotTmp/Ei9ZnpK+sWHIrUpp/eJLICFX5EpMENSDAAQZXJvFWUkb+KJXzs+/54kG7Jiz2rRTaJ24Yn0qniuZmx3pKQqDkJwhS8TY5nXrR07gcFbpBVvTGbHmsBdpmjVZ/FydEJFaQCZvoaXEWXNWU0qaW41MilI7oDkrvVtX7Z//jP54mXlA/uokiSJckvn57KWvC3QZFJ5ondmSGf1qZK3LB2LuQpMRB2mTFLFEg1E7ZxnDzukZCgK9uBIJSUN6Jb2ibtMhFYe382h+fPjwrDgtae6OxzoBg3GgCFHQ463DiJ61lCvyfnp+Tx1rdlmrNx+ulEhjlOiqy0BrIwCSLq8hODWGobnw8c0WkiBedToRMwjFSlpIKJKLHiqzklFY7MgXDagICO2LjX/kbX4k1KW1W51PXuzdCm7tb/gs1ryqjcYbe2LJnUSp9gldxAfuwy22KsqSN7iQqkZxauGBEqjLZMOZTkKRqYo2Vgatc8pngxdjhp8oazmPx32kKOSBMz+MPL7x2wqCXMFYiNjXbaq8cdqlmz4+bzb7andrRWPt4K1kdatw4USJFBQ0T06cP27fX4eKBTojz7J+XFItnGBN8INrX15fcgwGktO3r56/aHaNQWbPR9JB947qDZ4uAOyPwIQ1wuo5VIrQqoIbjBTtXS2Cysl9GnBqnXofN1sF09u6ZXZE6soZ+7sSehk7pVZ/yxDKEQ3SZm/QxDNBxlBIx0B64P8VYBid+uCzmGsu20OxhBGzzG28JRoNRtojlIUezmd1KdoqdbMvCsexbaxRNSf+gKoZUGBb+6YpYYfjffpJgTQfdFtNP7UwPVvK34Xx8XO/9NA3u22iawq87FukPFL8LkIft5uXNDil2jXMTpebebfr0JBI+rjRXu+n14O23v45lKblIg19fhTLzp4e1EjTG4UF2G9jlas5HKJ/d4ZXIdhtEHMY3yI+E2+XeDeLALNUxCPDF3KEBF8puQDm+4LYiIjGbtdN1TkBtAIVNuTFR+gwT9YtdDIKJg9rqni2bGmeyFSIKaFtSiqnyA/J1z7R69jBDYul+pOUnaa/BBXGiFwI2SsOcOyvdbouG0VZtlKZ32/heGpS6kJ10f5vPf+/7bC89j+aj3HFocxpMeeYT7mvIk/FGGO3gcNh4oXDk2YIpahTtGK8+zunjk9mu35az5wc9/yZaT0bX3aayF3uU2Dm9TZMJtVXptDOITwF0UnVwpAAlOEktz0ohqI0ZZyUmmzh4PJ0g15vCJ4HhJzS3aIfdTF1gxSAUgEfNqBTSs3s50cVFLxe/FSuhqhhd1liyiYG3dXF11YP7dRGJ3e7DNpGe6IA5xuzyU4nh0qFsiCEtN3PJCrY4Jd2NaGap3BsKev/sf/4vLe9bW/Cd8gi1sib8+i4r3MIPioiJYjiyYvfplIZKFIkiACb1OPgk9BQcH2/9KdxLZ/1i/oARgAJHsrKRc3QYFK8NPmlRcmaVxfxEZgj960c9eno4LJfjx0dpodWxsrMl/vDD0/Pr+xt0pptCTIu3CVjKrh6sdECUUtuhIheMiHtkzGSYNerglUcr096JOSn7erlRN02lbKBWuFYEkax5TQbJ1yhCWW7Dbl6KwqbtLPwFODEIX3uL+0QlqmFW8mpw4SIqzaTHpWOFuVoITSOqzqBTjklfEFPWs4HO2iIx/M2u/WhC0O7OCAxzqkc+ilMoLC/f/YH1d38LY5Qc5DjpZBB66o9sK8kzQ9Y9KRTIjxJo9z6KHix0aKEJ3TJQi9emGjHAqLleFTG2liyJQux3NqPvEIAK84RySJsw2KUZ4YVlzq9fvljRpURyY0UxLLDWyHZZrUnDcdVAWIt9JmYQrDclE/EtHEjZOZC1w2dcI0fWTtZEJSA2Xec4FCIQhiMBSASThvicXdIjtsHD8z2Ru3G0OOQjncVxuS2tlazQu/RjcAcG7aXvOvmdjhCt5NwHiuUBRTz1xQ/1pOeycFmaU0AudhitIuY/kgJWF/Mqh5anQ3SNQjczv4NX2feednuYzkJwtrbd1xrA0DKDaPnx+WlN2d5XVmxtlXOMvUhMAdtoRbdhEL3xh0f1Vw4pptaIta1I7gRLMCGdPBKlpnn99mKeEjH2rq9JJkW09E4UeCgx0v6wEeNrhUiWsE34T495WqLFL46R+0Vb+GiZJbfx0kubeQq+gjZKF0l6cy2TKl7a17FlUxMcmTKHSlEpMmlFDNZ3z6dEeBJraRYwCSYlydXEHdD3z4yS5hIW60ne5+fZFEPhZFnqLlxTzGOqAmFZu90aTtfR8//xMKR7Zmy624zVBya0ZyJW5whzaKdj7cJeaLDVkGPjCKpZ/fvXb9aEaYOC8+vXb3oWGbjJL798kYjnjmMaN5yYVHVkWSuDFKYYljBQL+pwwzv6yuvKXwEvdVaD0lvMvYsm0hhUVofcCwcuI83hrpK0n4LrQdXqY1GIAZXNEPRZZUCTAAt2JFdI8UsMehyPs3UOp0SrlkzAil+/s/+BrvkKiGM0uwTI6TUjp9zaUmt7NhDSfxovDY9Oy4I4j+xjtUmk7f3Tf/qfua9m0Q6hlba4Slnjm3rQcsNDbna6aC+pf1mdMy7dBz73R4D9+0te6LxLI3t/3l42p/60YVL0k4oFlEFB2fl23YGXseTifppdpWdmEbcE7v5gVr3hk+pbWiI10Kmi0DiM405jsTZNCivL7hq2m7Q+aCEeyq4c8wxEEJ7a1OGoTkChuSKE095kiMI+dThMkYE3CQFgi9gdmvuE/ov0mQglsKUx1d3S1CV4dWEQgUsFiKxzDRWchV4ElhqwJchOA0724cxmgTI2gHIFBsf4ZWchoE1i8hVhP+MgFz5AESUG2Iyq2YPlvlS34mLSuh5sDbOLM4j7SoJBtQv3fW2iXmd5Ls8OI1jcr6f9i9sljXEga7Y+T6PK8aRWJayYT2aaR3FfQ5yvJF/hftN/+PhkfQ7LWgu7T4ve2Ja4+vHBsvGCZmEwjwdMiABVMDQhY7kPlrCd8ud1ImWd/vpO92JtsJn2k7EoJeE1mYWgRJDphoXnCS79tICsLdVMNkPJy36Esn1VYmu0skYPz3mFiWBEeY5jp7xeB7Ws5RYUCv6IQ+hAugZcx3osnuSnC5CBv4ThvTAMr/KXnQnEirVFq0BsinHKJyAosVtAzkxEaGSbcAVfaU+atb4r+90CysRKpTrXy29L+drNQQCRCbPu2/Zcu5MPNzAZWmJzjIJajIhtHg/tZMzvwRmxo8RbZcfiutq3LJhsGD4um6f6SUmmGuGZWFx6hUr04KxAHg3qtSxgPp97VlNh37IBfBDdS8coO+5gJfkEuPUE5vSyfYPvTYFTMpWbECtnYTE1Iows57qvubKVIhqC/TxsfDiNC9iJLyCZRd3ELvGjUgc3v8FBt0uJFrI5lKMzWpXdSESeLeBxMkSgIyga7vws98eg/CThxl3DmKj7cBRrlYDpYDQ2ZpRncwhgieuILDwEDoyKl/0DbCjtuBwiU7kLzHlNRzg+jAAabMvtxYaLSXC8dPq5nU49tqWywLptFzJSapJ9KX7w4tDqM1QjK63h6kIIJbn3t3dNUcpbrMWKqfgdv9CjHpcimvA/S0w4QHOuUrn5Yq64ZXuTWQhY6ZTxWbIr8CpwzIdgJ8aRPXsAKg/xAtgkLYqdOCVsqKwgYl3QzlCgIAMFE8NioEKu2iFy02IW4IapuWMflWY2Tuc5QhNXmtt35qaFAAo3qUUQJyQDGJFcbpt+hLt0U9cxV4xiuCgR0M1v/n/8+N4jVJhub2DIdDFSUJDRyoqu7EbNeqBdtgcR/WTqDtvw5A4I0PA8zRZcN8jkD7mK6S8fNUZEIajhaIE7+V0wYubTPNAJ//q5tRPZeksSHACVwMrcclEqIAYfD8F6DrbqIMy/XhXvtmvhpigld8mksLRYmlkcfLPfZWKRom9tUSJYndK3aj5HPckas1GY1JZi053xkyu5o5rMBgJlo3buN3LcX4Jj5W5o6j3gxTSNCdZAkl6msUK0Oq7tYYzAff44/mzU7YvFmVFTOjTL/q3jadNsAZnvZ4sdGSZsSDBT63cIGMV8i5oHb8qDamVLwFWRgNqJCyV75hBbTVl0KP4PIDxqrrLMHTWN3aWpzz7Vs7P80QBBweV6hBenJPIJBAuBEjVSKDyF196bA2KKMl3t0Ujqjpt6ZgNBicclv6Uwrrtk6BxFafTNZmMj3BVZ66qYxzgETHriG2TncoblTkI5tvMlWbiGHqhkA1IZGlYCJCaWRossKYo7eXXWkW02ia/QBkIgT1KzWJqpx73TOYtveAYMFaht0oI2CSpymB/wtIGu3JtLJMq32LwsBg2QW12JDyDFRKyJffyfl6nQlJsEgvN80gcwiaZjv7E+9Us5CwvE67GtYbmjTKqEg9bdDBRy8RY0+RUqiCnTEeOrDVg+E7dgI144nXi8hQkkwQNH2ownXd3Z40lyCv14zdIgailZiQVtE4P7BGdXbEKvODMKkcXjsZHxK4a+2yXiKA5QFocRNCa6aYVWrjAcKIq4EEuRS7FpgYMhzSa9b7erIttIbSf733HBByw/N0CJgKlgDCN783DJPPhpVX1XtV8mKIqTCWUEiyr0jCcNQgSVvhUsJBIMDNO5CYaQEiG4zZKasMntz1zCwHE8yAomm37cAE2MyvMhuY0ZLby5S0huPuFu6NaP7hsNlQDTS0NN7J3bYgf5pO9d5aQ80jJVmBK9LnxMP7N9DWXVMzOFsbC7oLYWEkLiq4NI2cZ1pNYmnKjFJm97/FzLfY2CXVltva9wOT+nJ63JnjIogfM0FJ/Q6uLGTDSV3mQabb5xpyariJIP4137cnJAZFNP0D8MwkY6kG+tzrk+zcOojBctTqMcx4EqqJiGzeCSnWN8aXy6Y5r1arcS5mMjS7RYoqKlJPLOppXhcu+qtcaMP/IBsRaP3H6+6o+zez9Qv3Fzpab8LDoiW3fkS0kLP/D9fU3qqfi/rtrHmSgFEG/tv6CW0+neC0Xm3FU/KIIZuG9KOZ03g87rbemhi9h5FStTdTtMgnQWy7oxrg6Tw+OHZx1NGAbxLZjI0WDC4Zi1jQSpARAsCj/M+fnjU1FQXEo3bhIChQQLW+3psk6EIf6FFTQKB1Qi3GUz22ADAnTdT92fdN7xczo7iVcc5RIE7IDogfUfjq34rZi+jiBzo+HiDq23qdS6s45lOPXKvRowO0nRttXtkV9DAaLC/yi5QckcIyyzjtrJuloXrpcnUgueUQDbFopXIsZxGsH77kYdXbLQw3PKQK3JWJUcmkynJopuTXOxztgn5xz1H2tPu3KkEX/Zye7uEQHWYYJ6KNDq6bRrSkbNTqdjjLRsKhlDbaJgNysZjtLvZn/ofErbxrqv9+4vNMrKD7cbVUx3U0mX7BneUTSam2PGuUEOwMQh5CifxAMDV8tzuZNt2pxwBCOoce6JkbsWngQcRw10boiZJNkV7LouMyJQa43Zk+LXcmFB8j5lCT6S48zdo13Dj5zHe8jatAFBB1zqNaOZiE9an/su+MThqC6LGFlS6Px4Xe4KDN7CN/hEOhhEGfJ6mDtjGB0MElSKvaXzUtcjnbge9edygzppsih32e5kh3SWDep0tS4/Xiz2b8vh4wMocZgGljheLj0KKLqfGdySTparxhMaxEkFOnIbuJSgvQXSpqHyPp2JRxP5lfvopkuOliUygw/prAkwei3EzIrmbo8Rnk3TEmxCo7KJNWpeLCVomVgZEMXrurR0gRhtdSd428rzFY5asja7FJUFILTWI299QxrMIoN5kAeFTu2ocTuqRIaotk/JZ25bmNtMnM8qD8rlcfpV7hHAxFyPEfpFCa1iuRNzMCvCzO6CXNYHKTW5mFjVr+y6AQ6ldxkUMx0LYWxWjKKASe5pxqLmihB2KFhuRJAIz06KqR3biU1DX/oGVB1ie5wQu4lpZ2e2FDhxn69M1Qs+iwoDWiQk3OYhBTDcrLuN6jrxswli+VIGKOUXn2NtJup0RRl8uq8vJuxWJlHpZM2ns7McF62/MF0BVdYcSgDhJozdZK69xTBuKptd9iqj3dW6njI1nvjHw5lFEQk2JDqMDSXFVYnOXdcIAIF8rnMP5tuOpXtV7z//r/5Tix0PTzMMt0EANWpBn3/+uio1SEHeZmclpEjy73wiMQ6J+THk9CGZUfqHSc9/4XPf1ju/6BQvllaUhHG4SVUUpC9smCPFciI3cxzHuLSDQ+vkEKmtG1BrCQbpPcF84mejFtMTDLtW4nENd/r3rloPYkzmmvtWaBtJlqTVh5ckHtaDkkQb9DPO2X25lGAT7BN2IsIS+KKYojlEr4ECk+MtW4/qJG5WpM0vdYcCKOmcuOamCZTFBzmruF+1BsvdSv1JD2636ciuGUuCMRBlOPuixqNGQgqvDdV8+OnJPjmlDDHcIVF8f6IfSVDofZkkvN12mezf/QjHuYU8pVaTO/YMElXAuHyKMCqn1H1BEtZHT80Ji0wiFbqEagxcqSDJoY8hr89xOfcUcPtXLE75jA/wuSZ1rswNWcVITC17TQVaPLwNIH5dIT+TweNbFWmZFa4Pp7nZA6TC/eLV4GeWiQppfRWxKCnZBCtivHescEkEowUoW+GaWlW1W70vMzBLXyZwhHgWB0wiKhV3y1tkXYv/CBOYK99R1s5SJXKBku4SfHBOIJqJu2YieMVuYJlF7UYXLzsZiFv1v9LO+PQ832sh4XPo5IH/+uE1344AnDUqzUpqgsy8zpwZsY/SzA27vDeKp2ydSKSIMIle+bHNwARVta+hVIB1ZhsX9ygLIpwqUeKBxWn6atkNEyCSACiXEyFxaAEElyVo3InIs/AUSWQ0jqDcqBfvwrEQrEMkzpCIUtDTuqob6qgHPYkbDjLHaTu4HZIMaz/hyQUtajvmZU7+BhyRaIDYbOZn1nibjjfRbW6vkJKMaaMI06wJCxH96FJu0xzKsjApqQs9HEDgu87+Sp+W6Ny8WI6QWbYCvOJP8giDk47l+W4bOMcOsx0lKUTYipqkQe7Zbh9CwA3bU+zz7NCS5bucIRBXbN/rIAO6nIFZmnlTVaVR0ynD4eHJKf4pd1POZJyZoCIRnnsOplbsqllrC0T0rKPRjSAD7t7hxa8Flni3kJ0IFZnRGO8hDg9WLE9HrYjejknhd269rJYJzsriHRLjJktqggB5nChBiBUDijwYd1Ew39GrDG7kSDpWKGHirphPwNkYuJOO2ub9bV02MmcvgOKDcSwHv640FerSTbeiyd/zADBQkCAgGFOKHieRiYkLya12CnKySCKPJ1EXiEbjIN2yj4vKg3+uNCoTCgNUuGcTnRQJH8fZdnoSxRMhXgv5Z1mqtbQylBVjk4RebHEPgUwp9QwNsCPrDqI40wECfbENNdWDbdtNZBtgxGvTCo+85lgxwdswK+zJFylTy6Qi7dwrUlegrSUifZ0TjXu7uR/15iqsche36KhoE0xkO3e6jiEFvEGLsr/5YhoQ0c+aH240lo4bww/dBynWYG1OYdNaLT/vNlWm07g51w+6ty+CeE45v7yCICpoxSiQmG0O6V4gYyZvCD/ZlNICHaTouQtA9HcYh04VyjKkZvwUsOgfv5tpx9flln5+4sLwV+sQVCfcN5e4xDyrZ/EV4CU/kFGddNfuoFbuqjHlHhSsmDqBBjHvJRerMRazFlMKxrUm8LYneTxxlysfqGNHJYU0HL4F8dhaokPi98fBJMHsI6HYC8YxPBOM34IuIFygJSy065CEuKFOrCcuKou9tqHySJylr8rApVwI8V0yw+VfRi2/0aPi7pIka8hYWPzNzT7Wop7k36vtbXO8RRBqwhz7flTYvWbmltAnj88PlnWYNuNWzAZ5gWklaJzwN/ATvbMBSNCq9uRL9xozapQ6K1ApbBQIdnRiQc6L4iDRBi7kAkruV8hgJkQC1hPDRAGyezmy7nITN5ruK1LEJGdZRQHu2D1dWKhKyCM6sn0GKkmD6SPzY+GwQbFB3MWNmGDi5VT8DYBM4IA6pGXtjPXAb8+cFVlmTc3MsHs22F8s4U2yeW08Ze6RoeKaKNodIxTRojsGuHu1eF4SSeoB19IfAkBlDlSshFUqqMA+t5TqTfTn2MoqnsUWHdiJh7yKwZazkZaIVYU2GzBtrVHnSsVVLRLuU3w6pLOocAq3UgQ9u8uqUllv2OoHhU4JBqhByRPM3EW9joVSGW+D6VTCgp8Hd4ovmU2Su3i1y0XjiXvHJewrwavO/ftoJpzA35G9ev2+g4AUgas0JrWiNDJ/4oeltuy6enpPp2OTiU/Uv+FWaSw71pyw3FOUmM5HZFA0oVOUOhletkmJtRKkhomiMLeRkLrplWG9/iSaI0eOxik+CttTmVdAye5lksmsnAu4M6xOkb6719B+DtmR4MPsmv1q4w51r+9fKClXhg9M/n0JgXOrZ7cCcW+l7UanmLYqW/oTt4T4/KZUEMUFhB24STLKtqkI5c6l+Vk85dU4H9oEucwNHUakL164cNmPmLf6LJPZZ4ctRig1QluqOn9ShLg8uwnPfq/UY7opdo6y8VgfwXA+M3sqn1ohx7DLJtCI55I6oIKzMoM5J55WdcivNkZbyTiiANYWvBKc5OrxhaRzSYnNMSbFoYhIkknYHqOQjrNqDiWBUvBhsxGSkzE3MUcS5kBXAmACimeUlBs/KbSSp8mTcVbrDmzSNK2Jcu8Lu/LlhR9/+vBpOP2Lv9jx0wrRLBE/KTdDsk8srKNjIUveJDzX+WhjTfCHljUz25EJwQTSs5dlXoXl3CLD9VMYofkULGau8hXIirVCWlQ7pcCFph1qnoQg9nHVvZQfisn0qkoOpXkEIwgOYcIRR6hd2WIG9+isg4NCnLwqfJyR68UxCU6wMkxJX0kKfHAVF6VvFJei8Da2suMsZqMs1eTgpdg/Zmt5S27PZgAOdwq1QINpxopbcUpUu/wQVYKadOMGmhJtmm+00u9qJwDNDQ5yU39UIDK1ZwJNC6gmGr/sZxSWVX/69LzerVSyIKbUzjpf7CopR3TX+GKy6E6w0yNtdcVso8xQjAppcnV/H4bqVswM1PVZOlIMGIrKySg0KPJcMUFulM9nmRD9cMVYa76TLqjN5QcYmZXFUWU1lxPUFCQJfrMq/hza+ET/kdPATiJ9eaTKmh0JodZe1FQSYpqKMzqZXQtBTRa8AsC6AqiY35eocQaT4qMKVaHRmP6izb3q3dpQGEprFH5UgjiNKJwLqEP7y2smGi6loMAc3QBBUWEIWPbvuqdhX51Mj4LymE61+XSIXSyFiIm/+Rf/8l9MrPfeggDuMGIQ9AglRSDn8yZNpMpP2dadgj5lYBDymAAOGrA+9RnTwBpeJHcs9GyScNALqbFeGBSzJRKFec5mr/F79JxtZNblrPKCEiIDiylzDMLN3dNWlhU+LBLas/hAnELx2D2xpNBwXMEYqrQ3NOcuiKEPLglkebKUlHO/xIRnwQ1RYxyPRRIk+6R8ygf7WQXWjZp7ZoC/CYq4Aq9SsySQ8ltUqVFEOShRYpaAkFw6bhio6Z1Qc4g1OSY/m4MD6WAt9yYjWL9gN+6JOHTgH0CouziLLJrj+/r122rxnFunukMG7gtG7Ppvp7YQpYeSi3QyYkQJJeFzydzx1r4/1qBB1SjKCLQXmxxktjk4yV2M1YB4TPup+DB3lkkDRWAB9KZfKAG8I0iO1H1uUeE+YWqMS5YjrWUKKx0Z95nbEmYfr7bvrCKYjX/KEDGxwBoHRofcPQMi0N3ciUBXbFyOOxm7xUCcU0AMYZhcCgnFPYf1LFjRVziWTwoTDeKKZp1aQZZ7LcnltxeTnpb1yFwf0qoNxKT5tqrTGQ64eGz3L2QiqXdpPFSaVBeZ9DXKVtX8+cFZ7N4tgjKMmgVUYDoIdeNcwwFR+b1ScIJFv9SYGmSiaVQlIrDNXPuRX+Yut4BUFXRbFyVuSVn0xQ/0YKxbI7OYxNqx13sMG5+ShWzCSC0MKKM6mp5/VzedEbbzpfEw5bNEStlkEtXmAlBg6vr2TNug+ChszfZYjptClOYqkwkgD9I4TrRsOtbGEFhSPG1qnNgKo+OdEhgKE6LvsVzmHFFlGSDTTj/LxW/4BTozsyhZWiOiUS4SPvBUxdQzB7gDVDKmPyLP5Bs+TBNRkZ3YiwaRkm28XJEfHpSlyYdG7fOPT5wzPRqmzio8GrhvQdXvrHT41fjmJqiwGyvFSwgiHWV72AqA6ChabUGhy+hGELVFkAmJlfJdOgGD7ow88lMFoZ/FcrmxqEzJTosjZ7OWDFMA9hdbAkTJ20UjSZScFd8j/M8PVdDErKSTAXP0cdEPN0ZLm63R2ALkwXSTysJAirNpBmn91mruoRGYCGgaqLCRQ2OjlAujTQqG07nkzEAyzg56+9RLjM1yBQCiba6LQvt9oG0ZJjJzb3Og5FtfRxUYojFVQcyssXTR79YwwsoX9QhzXCnuwhsEATOH3BixFKFOP89OY8P1ZhkBprvBa/Ck1BLCJjSlQNRKTEIAnadiyM2ceodrfh00BahEakbGyjDUHL+nLmaRBojclieMzUb7rMYErFCi0fX+iwI0KTeH18OjGzDDgUoOVid2WX6II3NF8iVoQpZLp6DCq9+rQ4mRsiZMKpy2nIPbYMiMkrbgKExHcxqfEjsMcIElGCz3UVDnT+5NSImOvssVteVDpkC7RefBmRAQlDNlTXBRNTYOLhzrCtbpZIomlR/xk4rlB4rgmgtZ+hJVjta/e7nWuWeph5RKYqRPQZuaFlfxtQIhh+Y3Gg0bvC2xVOaQkA87S81ve6AUNMWfQHfumU4984MEsZUYeaTCIbu8v5jLSK52+Wb+kYjgJ0dkYSCej6CM5StaTwPcAdQ97EQ+vkrO7PYS+ZWUVINFvE5Pgo82AijpaClL2A6U7RIQiinSNUv5xeDicooEcr0iOTfQo9sujac+zNTMSyWaxpz2HEMiooKCSaawNjflSqYr3k+XJ69ohuLVpJZZIcBg/t/YDJwYU+JBIG3z6Xgyy49bQPjUgBNnDh4/fHhfvTIZUMl2DGQ0BBQWo1aUYY7hFBnIxOiyD+N2yNVrZsD7J3NAus+C7IbAHXjjzKiMSykHSePTbIO2kOefqxRwkmMbjg4YxuHx0pxegbhUKxFmW7pnc/abbYiOaw9V+UdYBeeUmIJLwfjsfRhk05JLZn0RBuWHoeNbiwX6v2A/ZGO2KZMQgKEyIKWi7qHWCQRDFiiKhOIromdeJjuGNJQw73NeQNirjFQiLGiTNji9ixpbRPNhoN9PyznT+eg6rrbHlCLc2m+UX+RdJ5GwDGpshwgCRbdckZU5y7fabfGrJGLxBLAiausyGG2ZQkzQ2Pkv6SsgmLBSNJTAGsF+dN4vkeMsyHESNLhklV5AZQzhO8XC8Yg4IUoIysoB3GcXzjKWg3XesF0ISRT8RFHoaIaZ4Y4jwiHvEt6kUjXP4mK50WTa7mhAihC5XsKt+KFcLg4gvI4GJXQIu2O/+T/6gvbwJO0n0SXnYoqgBX/ol3dY6XN6d392Ia9L7mMwb3IzFKISKmddBcQNx/DMAHGQtZUyU4ZhvcadnBcfPmhBEAky1ZtSXWkB97Okey2xNQgGvtlapQClfYl6mDReooIi4IvAK4qP2vKVMaTqEIuUgp3YE3PK3IRv+SoHZPYilDgAz9E6k81TUnvsQLtPUZjwwXaaONWcJpMalv7kRHARqclSC8eGr5TBf5D6km4ItZNEYilyhP8khZNRHZeL6+5beAJisWnTyHdmEFNxgHHDYI+EN3nt47gxZhBJ5EuK4it5WK7s4RP0oBCwyL5icX7n3COGYlpSwwg7+VSYgytut3Dcr6X7+UYPGhIlODTNjwN1+2RoeiqQAwRzlzD5BY3h03iCYrOx1/A31WikhfVeCxoy3TALdcn3kv2WzzLZ4AeGUCgW4EU+CmuTFphl3gq4woloqGthGwtMyhOzjvWU5TcTSpgEW2McYViUPfKkngqCdCwnRsxoZOccOH2/YwWKLS2wQCtdznVNn5uqQYyB2ER5YXl0OShXQglXdGguRwyY4i2RILTYgZexgNgza/Yz7vS955nAkcwfR4UTnhuM7pSbRdjEOXmm/urA1xO8jQpQW0Wf3Eqyd7C4mnUcI0p8op85ovYjhZlvEDAU4460wwxd4zKU/iZEywWxBcsyHUchTGTNIyWRDsMjgLATg8KhQG0yx3DcI+aUP5lRLCMKmPdoVG0WvSHU7fjlKMGHKGkOc5RLpnsxi36u4kNNgcYzqDzbBcM9/CtBi8sJ8CLgO/iUU4L2sYC4MYe6ijFz8fwfjft+gI8S2AtDI7kAcTA4lhvQFyA5w9I/NTcx0ZKxIlIcTMpm/oyhee/Z0XjGT7s0esNwuI1v8KMaSfIlljjEk0eFw/GMEEYbLMQhKTKI2yfV0EM75YFqeGFw5Hm/aGGMSYvvbIsKv9lQZut11D/ycmQeeWP4qKFnn+WiCZtd0lmuRuVTlsi1AlFg06VzITx2fDZhUkhU5nSnpKLohaNzpAFS7XBF5W5zCk9RQinoSq6fI02qMD/xWCyg1NLLZQiY0hvEVehlUliFUmMGnQr4IMQBrm84T/nPbAo1YTvjlNN5oUcLgu57P6lN5fa2Q04sv4FlV1Fdvc2UMvtpSYw/LPPCUKN8/1tCglAWdHNS1mjw5u5eTc4FTCSXM2Et8ZlPnESYkK8zUKktkNn9EQuIJeSscmYuleQrZxW23j83Un6wKT2BOOUYI+QUIHCXXCQenSBf81ZGjXuIphTDv59SzihTQWJOIL9yjhdF8AbPybgcYWYshMRVR65EFfFEAByAOquvCxTR9PKD7jEYhpAv7pZULkEPVCdq1Vdq5LLqRoGx4YNeUTF7q/Yz0BeNwq4aHJvhvk1aZME2ri9qVuSYGaOVRkTjs3PBikjcStxFSX1NSfyEvxFbIgcExxyQhKGmF3MPixh5tDJXzOOOQ/eTHOCTMD//5di7CpuP99FJ/ydyMTOHRQSF3YWbZQhPZRAfZ7MqGQoXHImNOTf/XLaQkf8J37NRQidCvQQjMYLEEY7gXvPGR/7mKVyIRia7L2+JDFloRZPvCukZ0/cuiQa2ZL0UvxgObVCYEfE11XGaZVpbPFnSYGXt3n3fBT5u9YLsyzS1LawkACPH8goPOPtcyCeZppKRs6RB9JV07xZPGmFSOtqL7jjO8ZlL0X8vBu4hxRuVs3zshfPz29CBinzwh0nc+fWd19xbmWPEGMbgXXELmX+IC4m+Kpx2KW4zS5UlOAltZWCHeeEohxZ1cFo5K5/lutF7PAcREtgwVBxdlDlScAUsj5anbJ89dyUDankjm1XTsU9qAeeQIg+INaQRHSOAf2l8MozzDdN8/cvleP7YLPoTp6KCUMjIyo09dZxHfVbNEDtQbzRl8emu+c6tJrDOjzNLvc/27ys2h4MkUTQm/MwkTS+IbwJFJXAbyWYXWeV7/zyFtz7JAIU3zigvypt8GzRwjAkRqfaK8t4hPjHTckAJW/OqJFW5msABJNj9cZOW1SqBtDXa4TR/8xZRmBTbjKpidEakEzjjtWg2ns+HjgjiJYwv94HGJ1P3flg2NCQg53KRArGiE4Tn63uKF5wyaoq+wjZLEyowWVcQXeNN82HcPrpjSbNxnAIcCnlkU8LxrLcKSfV2+kYxy6237PNPczu+ojm+gcziw6zGmFN4H3Q2B2Sn4OxXlOFdKcWEy4GAohc0pMzd83dBhPkRQRGHp8LvIr/7kTDWFfxgmTThUqt0SvyJNUeixGnxe1Zm8knOzvnmhzrBflmMYfO+CdL4E2UsRPgoTI+2FFPCJZZ033whpYhnDStxhIJHtzNtUJMls7jtxH6wpcw4hhJFoe0Waoo8vAO0dDDAiyn028/6MRIqXStM9Zpf/rBYtIqifn4j3+IDyaCFPrnDFdYxQsSaVsoDqe3hHQXNp6RY1KbYV3jpbUphqAmgJ2jJEY4xaDgVpYDghmIRSE3VMwwo30bTaG2K1YUrf/QMLr0zy6hm4nG8R2L4YvUFj7QRJ5ChHDE4Uy3RYq7pyrm3j0vzdz4IGQV2hFU0pojL2BmoBFMUEKCFXiIP5hZoT7XJNcPERCmRiBizGAmBJBQiIddMydo0MR1whY13PTC28dFrrXkxnSi8yXnVp2hs87BYzwddOypsw3acac5NfiGexyfl8fkokzKQOpfqr1vDmUI0iy6hGLGZERlrt+PqXMq8wvXYhJRM5oEhIKNoWhyRfMizs4LP4UgYbiDP+fd7/rsM7iAjIWR+Ktnx0dKwMOoR6YcDfnn87m6cjHoHlv9Cl1Nyelk0z+UyiIMc4FEQEp2FN7JxH2KRAUSxeFgUONwOsoT1UngaBe+KtpOEy3hWqYM3Ia5AISWOXpbDjFFIxmc6V0pbzHQyHhx5Te7oZAWo0wK0GfUtxpU1TwlCru0aF2WL86Cv/1oNphBerosnphBBmzU9MQ32iuHeZ6sCxefGcQYvOXzOoykBSMKikObs4Eb4GOL8y3Dlyafx2t75l+PCSn/z2pyKcBKDG9h8c8V02lAXR9AvnzsqJlFG8CrDFGO98wbBZfDvVww+h0x/St4txsBOI4J6t0ljaQk/sT525rKeAwa5cPgeIfsbzAkcl2+N7I/P89ajvCBOTGUsWVOw3qK/Z+LC9jHVCqzd1S870V0V3dzKWDHYJIrAYYeb6qTtuiBeNCU//2n2YaDwnJMo5l0mnCtnuuaCAwDBWwfkFzSTIWCD7yTGLMc3TgncIBEjE4maUmRscnm+c9BZjsybfEHTPEV1HVm4UIZK1JERCysdGAaEkqhx5OBPya3yIRru5+drF/rDM3cS8iJMNpCW12h/op0omAGQh8VIhsQh4H6RMDrDFxlk+HyQRwh0mPEyyb48vPyfAd26WOkja5aK2PiojYqYC8MwNycXjC2Zci6JSlqbCyLXJBPPEADqkeZ6HGH45Ej/HExExsHpMrsYYo7PNwSWWYdreZEBw33XDBCWuRN/Ga3wrszS8VHoQNl3DS+yiKI79356ru68Ox1oKmz1VMbOu3x9Hzg4TUW885+ncB2hxU8VmnJctPCu0YWzJlZUpShlmXPe5iIRjLHLc+gp5OcKuVykYKY45QPfBpSAEx723dZsq7BJL4WXNk+CJnBPm1mAw1IZlymn6BphZCT2l//MpChoYWhYTxgipQjjrtCum7eBh4SiRTz8QHEfmaYvC2Mw3KBIYyw+D2oFnEJx3md25V2O9r4cGu0oRBSSwj3qU4jK5+WwwqfvR5Uzy/GeytdFlhmt0Fhst2jM/SLlmq6Ej0yKTQW8I2dTL+pLeXEw5urSxfjD6HyI8vA+VJQLlf8iVxcy0SI+YrUHmtt0S+xsEqbxPqd2+cOzsAVdGzqpTDNGl8wjrj8CiDGWa2ROrlBGxUvc1+4fo8gn+S66mgNiH4ltUBLQ0jPikJDtwPsQ908KjVF/1y3xg8uZdRGA4wvlzskVysDODQeKMjjsuyKGLC9zfd+bUF6XR2F8ePL7h0w9ykMlcumYJr/kPI8Azv348DJ/XfLO/ShvGdtzYc4d3Lx2EmnFYlw6PCq4B5xRjPUoufM/19BCLrZPEqasLnETZoUdcZr/L8LSutuHsxSuAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 58%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 7/12 [08:46<05:18, 63.79s/it, test/blurry_cossim=0, test/loss=1.11, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=8, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.398, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000107, train/num_steps=1216]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 67%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 8/12 [08:46<04:13, 63.42s/it, test/blurry_cossim=0, test/loss=1.11, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=8, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.398, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000107, train/num_steps=1216]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDz4WSXU00n9osquRlEi4OBjpuwemfqa6GW0gk8F29vNdTFLO7ZxKiLuLMuejZ9K4wQPEfnDLz/ABDFdvplvayeAL8m63oJ45ZCoz5ZBZce/wB5T+NcjkdFjm54tI8wn7TqA/uhCoA4981qaHrVho91M9vHcOZomiIdlAwRjsO1Y93a25jRoDdMzDODbvj88YNatp4K1+fThqcWnv8AYxn967BensTmpc49yuVnd6DcfbJk2sqs5/LFdLdfDqz1q+k1G5lBuJdu/DnHChemPQf5zXmGh67a6PeIL25SMA88E/yFekWXxV8LQR7Xv5GP+zEf60otbicWiVPhPo3CSIjBeB87cj3xj1rH8b+HdI8O21vcPpsdzucsCsjRlWAUA5yewH5e5rfh+JmkTOGggvZg3QhYxn83qj47mvPEHhxJ4dHvUgjJYyPJBjt6SVEqtNPdDUJ9UeWXWt6S1m1n/YK/Zt+/Z9rfr9ev4e5rGN1oW7jw/jPpeyVBdzojsjRygj12n+RqtCBLllBwvJ3ED+tWpK1y3DU1Q+jkkjRiM9vtclWrfUbezSRbLT1tzIpDESls8Ed/qafD4c1CSVIlEBZwMfvPXp2ra1T4eaxotrFcXctmEkUsNsjHH1+WsPrEO5fsujOcszMXWJXYKx5zj/Cuku9PtdTEUt/ZpLJEmxCJHXj/AID9a51JUsrlDJPA2OflLf8AxNasnidbcIDahwwG0rKD/StOe+qFyFO5s9Jsn2nRUfjtdzD+tdDofhLTtYgDDSo4kB6SXk5P1GGqjZWF94ovYo7S2VGY4+eUYrqpLy/8Gr9nu9LM5AyWinXFL20b2b1E6b7HjTrcT/flL/Vq6bRS48Japp4AzKGk6/3Njn9ENcVEZsdHA/3G/wAK7TQ7G5bT4JrOf/SVklDBZlAUPGoUgE9cMffjB9tXG2hN09TJ08+ROpclVznOK9QutXUeDoEi1LAG/MZVRtOR3NeU6u+oQXklrqc0hnjwCpfeACMjBGRjB7VlMqs7eTudQOTsIP5Vy1cL7Vpt2No1uVWtc075raS4y86Nk8/OOKiBsFZcSoR/v1pt4JuZNDt9RidW8xnDpkZQAA5Iz0OT+VcvLakPiPdIMdQpramoSVoy2MpOS1aOostTt7ZkjS7QRbskbhivQdT8U6afCcVrHrFqxO7MYuVz27ZzXjMGm3UsgCQTEE9RGT/Suwk8JNF4ahuEuYGuJJGzE0ioy4A5O7GOp/KufEUKXMm2bUqk2noYU89s8pIljYeu4GlElngbXTOfWqT20sUpRxnHdSGH5itC0sbB5Ss13PGmeCtuzE8e1dEkoomN5M2tLls2uEd3JORzk123iK/0++062gtppZX8vbtJbrnp/Kud03wXa6zpcR0TUJrvUR809sbdohECePnfAP4VdT4R+MZCGa0VQOf9fH/Rq4p0PaTUlfQ29ooqzOPuLF2c7YjgepqD7KsYCuu0g+tdinws8RxXAF7bvGndhLG3H51c17wDYWKK1lqF1KFjy/mIowa35nHRma5XqjC8Py6dBdxtczlFDc4Y1veKdT0idQLKZ2ULjOSxzXCara/2TciN3AOM/ORn9K1vCzWWreetzctGsW35kQnrn29qmdFt+0s2XCpH4bnKwW8TkRrIrMemEPP61u6bMbLy5hKqiIliNpwwxyOvXjj6V1d/4F8PJcEW893YTZyI94kjA9sjcfxauO8R6LJoV1Gn2wXMUyMUcDaeODkZOO3c13uV3ZM4VGy1R0HjLXtE1qDSbm1uLc3ccLQ3CNBIcANlD1HXc3HPSufh8yKMXtq8A2qzKyxEcgH1PqKwC6dCR+dbdtKP7A+U9CV/Nv8A69KorK46bu7DG1nUZLm3M8xXy2yuAOMg1Zu5IPtYa+viJWAJPlE8dO30rO1RUhMbLIr/ACAttBAB9OafrODfRk4x5Q6/VqiCTtodGJj7OVkdHp2p6F5kcSavcCWVggCwYHJwOStWtdthBY3k0t7Pst5dmdqf3EP93rlq85hUrcxn0YVp3l1LLZwK0jEYfIz1+VRz+QqZ0EppoiFRuDv0IftVqxOJ7sn12J/hWnHB5WnJfW9xMJAflDhcdccjFU9A8P6t4kvfs2lWbzMCPMkxhIgc4Lt0HQ+5xxk17To/w00my0/7FqVy95KoOSAYlAJzkDOevfODjpWlSNtERTnaV5bHL/DvXL2zvTG7mVpJIo9rDIVWPOMd+le23fiSe1urGCGyeaOd9skiqxEQyBk4HHUnn0rmbHQNP0OZ5LNihkX50CRqrH14UHjnAzjn6Voo5DH2NRGDWq0KrThOd4rQtX+sfa7mW0G1XRTk4+h/ka8V8feILzTbdbKC6juTdqweZV4TBGQvPPUc+/416pqc5i0mdnAYKuQG5GT0/XFeIeLI0u7V1z/pFvJvRByXVgA2Ppx9MVN0qsebb+v1Lp0nKjKS/r+kcOcsxZjk9ya3/Cgi86dbiIyRyKSF8xlGVUkZwRmueHmykpHG7E9cKTXT6P5FlpztPFO10ucAMFUKwxjGMk9a9CT0scMU73Os8W+JbgzRzWGnmZ3V2V5MkhFwWJROnBJ68AE1wd/qV1qc0c11JucIVHygADk44+td7eWgm0h9SjsvPewZZNhbClSwV1b2Ksciu5v/AINeF75DJYvd2ZMeI/Km3pyOD82Sc8dxXHRlzRu9zsxMVCfKtjwKW3WNlDzQknrtcHH1rUsdv2BoxIHXzRyPqK6nXfhQ2ibmke4lj6LKHUI5x9OPofSuZFgdPUxIGI3buSCe3+FVOSkrGUItO5U1+UyWayFsgt/eyR+Hak1lwZ0yf+WeP1NJrNpLFpzs5T5du4K2T1rVn0f7S0Tzp/s/u50P6Ampg+VK504tqdRuPb/M5mLm4j/3x/OrtwpFnBkH7rn9P/rV11r4Usvkk2S5Bz/rBTdX0yENym4FThTxj8jVymm0zmjomu5a8A61N/Zq2NvO9uschLpGxXcx/iOOuQAOSfu9hgV3Vz4lm08lL2ZCPLLRl+pA4PPccr+deZ+HtIu/7RFzp1m3lwsvnFGJG0nnqefXivQ9b0OPXtKSORhFMjBkkIzt59PpXn1J+zr819Gd9GEalLlkreZd0XXDq9wjZQjOG28jOM/1rTkl1FLiNoYy0LAkjg/MSAARjPTnII756AVyvg/TLrSZngulA3O2xg2QwwOR+Vd1G7LCGRN5/u5xXfGXMkzjrRjTqOMdUU9fsZL3RryKHcZTHuRQOpXnAHqRkV5LqGmX16VhXTWVx913UoV+ma9xDYkXgYrL19TbW/m29n9onzwgbbn8e3f8sdSKiVJSlculiJU4uKOO0XwnaxWU1teFppJhiSXoU9Nvpjr/AD9K4vxJoVzoOom1kcyxsoeKUDAdfpzjnIxXr+nwmeKNxGyhgGYEYI9uf8+1cZ8RbyK9XSYrGaG4fZLIREfM+UlQCNvbKsPqDVKPLsQ6jm7s69vBRg8L6pp0DtcT3UWM8JvxyAM5Az0zUPws8QPqXgyzW4Ys9rK9q7N145X8ArKPwroU8TaNZwBrvVrGKI8pJJcIoYe2TXlul+MNIsfG2tQaD/pdlqTx3EQAMYSTH7zAbBOclv4emOnNaxglGyMJTcneR7OywahA8MyJLDJlXRhwa8O+I+hReHdcYQo0dlKgkhJywHHzLnuQe3XBFej6drh3bioVJHzjdke/T3zU2v6HceMbaewll22kmBG4VNiEfx/3yR0xwDzk4NJxTHGVj5+1i+tLnRpRCTuIHZsE7gT1+lWbG/XepwMZ9as+PPCNx4LuW02WUXMEkQkhuQhTeO/y5OCD2yeMHviuJuHLJGfqaShdWNqlo2ad7o9Ws9QRlHyg+waqep3glZljhJaNfmAYd682QsqHIOfXmtO61SaWOZGCnzFwePQmk4W0IVnqdJoniGa0vDYq3lpO+1sjpkYNdX4n8TPY6G7KY2SRMcNgsT2GOfXOOcA9DivG45nhlWRGwykMD71d1fV59VtrXzQv7gsPlXHXH+BrGeEUqql06m0MVy0nHr0Fj1rU4kijtr2a3ji+4kDlAOfbqfc5Ne4/DfxFd6/4ckk1CQPc28zRM+0DeMAgkAY7kceleC6fB9ruEgDYdzhQe5r0fww0uiWq26ymaBpWkdYmU7mwBwe/QD04rorSUI3SMKUXOVmz2G4vreBgHmRJDjCFhnJ6cVVuby3LfaJ5cxwocMJD365A4Pb9a8w1rW0m1C0vLe3KT2xOx2JYfNgEEDgZA/lV4anZyxOy3MmWPKFxjg/T+dcn1mKim0df1OTdkz0aZJ73Tp4bdzbTyxsiyY3GMkYDY7kdcV4j8SYL+LV7CS+kzO8LJsfb5mBIx3kAnAYscDtjHY17Pb3enf2E2oW3l+R5TS5JwBjO7Pbgg9u1fPHiDVZvEOvSalLIWmkCkhUwAAMAAemBXVB31RxyTWjMUwT+UJTFIIsZD7TtxnHX6gikt7mS2uIriFtssTh0bGcEHIpGmkKhDI5UDAXccAVHXQYHZWPxH1S2iMc0MMjbCqyKNhB7MR0OOOMDpXq3g34m2V3pY83ZFfbghh3dCc/MPUfyJx7187YrS06L92J4yyzI/wApDYGRg+lZzhppoaQeup7L8VbddR0BtRcCSVB99jggEqDjHGeAK8PaNngTYpYg44FfRPhq5fXPCVrdTKEcSFHCnOMHH/1/xrVf7TaaoI7diLNUgJBwNoLy72yQSeAo7dOorhwtSUU4y1aZ24pRfK47WPl4Kw42mrMwIZv90/zNd5488NWdv451XYdqySiblz1cBz29Sa5650+FDkOCMYxk/wCFdjmmcsVY5Yn3rXtdEur6KJ7NRIJSQVZ1Urg9ycA9OtEltAv/ACz/AJ/410fhrASFVGBvPH505zsrolR7mNd+GtR02SEzQgSMeUEikrzx0Pp3rc0ex1C31GGKRo7dJSCVZlbd144PB+uK2/ER26guevFZ0LmXVV2ylJFIaNgoO1hyDg9ajnutRqNnodSmnF2CyZfAxjGadN4Ytmsp5XtzGUicqwJBBCnkDpxVjSfEV1mOG7itlnGQyZwSe2Me2Ogrf1K7W88Kam8Qb7S1nKI41XcSdpxjHXms1yvRG0lUhZu6ueKaN4gvnKaXLKGtbp1hZSOVVjg7ccA811d5oOi2qtsubw8AbfMXgf8AfPvXn+koU1S0lPAjmVsH2INdpcJLPF5zK21+R6Y6fzqpR10M1NtWY3/hVCkn/iegY/6dP/s6cvwkUkf8T7/yT/8As66K38Vl5Bm3QDPof8a0h4kjikOfLZF7rkZ/SuP2uLX9I39nROPX4P7nAGuHbn7ws/8A7OrA+E72q/JrjMDk4+xj/wCLrpT4sjI/1Yz9ab/wlsRkRDEcMQuc468elHtsW/6Q/ZUUXfDU9h4f0MaLeXYMu8ktIvl79x7DJ6D37Z71q3k8jxvCNOa9ifaJp3vFt40AYEZOd2MnsDn8a5G8urO/1ZJIifOtSQ4DBl+dSMdOoAP51f8ADq+IJTH9sk0tYYn35hidnPXPLcDg449aujTnz80uu46tSDp8q3RV+IGmyaz4gtLiG8hgVrJBmOPzgx3PyG3LxjHbtXKzeCrkx7jrw+n2MD/2au38YknWLZg/W3HT/easn5hAdu7P0qK1ecJtJip0oygmzhLjwtPG2Dqm7/tgB/Wr2hW/2PUre3Z94DYLEYz1rWuoWTMjAYUEk1zEOrH+0vPO1AGJBwSB9cc/kK2pVJ1dyKkIx2O18XWp+3NJEpKIoyR2rk47pbe8jnO7AYZ29fSrlx4mnu4ZlVR+/XBOQdoHqOtVVsZ4hbBzkklpEwCBwccjuOv/AOqt7csdTOLuzS/t63mug0hIZTny9hUscdc4Bx/hkYNXLLxZ5awW6M2+R8LMXH3c4wxbA9TnngYrNW3tvtaSNGrvjjnp+ZrWtJLqSTE1xbSWrABklAHGOmQc1yNpO9j0OWU6XKpadh3iKZr2+tvPtYLuMRE/bURg8R5xyp+YDGeeBXdNJozeHrmdvJWeGNhEvOF7IMdwOBXmzweRczwWRYw4YPDuVlTcvPPXocA81RfWPM3Rs+12IJBGDjOa2py5lZnDODi7vQ4rc8rHYWYjpjnNWoNK1iUBotOvXGeqQOR+gr2eXVdUmyJrt8HOQFAzVeNDLkvLK/YYqXjoLoNYaXc8xtdD16dwi6ddKc4/eIU/9CxWmPCGtFUa4S3hTOdz3KMeOeikn9K7qWxVcMWYIezHrVqHTzJ+6to3mJGSsYLdPzqHjr/DEv6t3ZwX2ObTVkih1JGZgGkWGM446csB6mr+ialdeYFe5ZgT3Cgj8QAa0NY0yaDVV8y1kjRogokYYBOckYPORwfxp2m6NZRMGOS2exNbe3SSckZOnrZGrJAZwkzPKzHvJIzn/wAeJ4p6WzbDySDzyOlaAhiKIqcAfjV5LBhEDsHP615dafNJs64K0bHK3dmJonjzgOCv0rCXQLKKVknhJZxhjvIyMexruLmBFY5GCKzr203IHUZIFbYepZ2voTUjdXOWl0NLOZry1yyk7niwMfTjtWdcXqXF7DDn7NDnDSFdwX3IHJH+fauuhnRGCvjB61jeKxp+lhpjES3IVBnDH69BxXoKST5Wcsl9pFAwTIwWO6sLqM/3rgRH/wAibaavh0X+oQOr2olDAhftUTdOcZRz6d6ZpzWWp23mxxbHH34w+SvJAz+R60+TTYD/AHx+NVyJMTlJo6mXw5f3Cyp9ugEKkIzxISXUdXwWyre2SCc84AznX/gG5uxPOVUOMLHtkDGU4IJ52hQCAQCD1PPSuY+wQhz82MdOKtWumXl0+2C7eNM9S5FLkhDXYTnUno3c/9k=", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 67%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 8/12 [09:49<04:13, 63.42s/it, test/blurry_cossim=0, test/loss=1.36, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=9, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.435, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000128, train/num_steps=1368]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 75%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 9/12 [09:49<03:09, 63.27s/it, test/blurry_cossim=0, test/loss=1.36, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=9, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.435, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000128, train/num_steps=1368]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAABVQUlEQVR4AVXd2ZokOZKmZ989IjKrunt433z48Pp4xtOZ6WZlZYTvzvf7YZ41o+aupgoIZIdAAF3s+v/6P//v//H//L9/vv1xc/d49XF9/3B/e3t3f/tw83n99vLxcf3x/f7Hzf3Ny+v7x/Xtt/u7t4/P97eXm6ubq6uPq4/Pq+srf5/7fn/7UKzN9c2nko/3z/ePSm5vnF+Bt7u+ub658X97fVreaHx9ff15d3f3qSiQYK6vr25vr993+v7+trKr27vbj4o+Pz4+4IhwpB1c3cJ4e3P9efX6+oocBAO7irNQXt1p+/np7+394+YW87ZP2N7fYfwkCXzv79j+uEL85vru5lbTG62vr+5ubwkC+ObuVuX157UvrTu+/nx7e4dLE83vOrgl6S0sVx9vz+93D7fvb59UCkNi3d58vn28vL4+Eerx/p+/ft398esfT88/v//2+HmLyXukb+9urjF5d3vzcPV5Q9o3pD7Tz/vbzTskeLv+dKAy4duo+5OCbjQgEJgP/N1ef0y70xXqmIuHbVSQkRIxXhNgaDIsMIpgxb6hvaXNq1re4JHOafgexZurykHQEtVeXb07uL2HLneIHE5i7jqLXb9lic8Pls8VwMfPJ5YBXFG4ZgAS5fMwAw3bdHr9cYuNe+KmxChSwOcnlrXAy0S7vn53MFnsPlN6poPr8QOJW59k4UP0en179cgVHh5/v+PU/6DSmzstrlItx/b39vqWrq+w/fHJJuPm4/0V3+QBhQWV8Usx8fyJAcBaX/GB5NJNAoy/dEWOekdt8D1Wkz2pSbNvh8ckulkAtaoiBMjMfDuduYK2hRGGAKksDx7y8DrFbOUa1Hfa1P6LHKc/GMZYZIJ+P/Ad2tDV7ADki+eY+PTAV5EMrPrrD7TnF1cfr+Q/ilKgEcWwys0NjeoIGHut9Oru6ec/vv94vH28e6MvUt5ev+kd6TRm6qFvxZK0ioy+R1JMwhLjtSA15XzA9hYl1e9cP5jjo+kUsmkibY0uayTquE7IKQ6+tQG6qrhIYzgZnXDGNPBiWAfQgUl65/F0tlQHuU5abcHyJkMQe43szt9UNEy58ylLorw7+exrMh879TnYsA8TcWOSmT/0V9qrzVimGj1C4Dr9qLIb0RiqW2FctGace+bXSW7+fP71/b6+IHjCzUpFRHp8E/XuNBOz63DxPp0XPz6oOf7iEM3gr/Rn9Bx1FtsIMALQinKkwElKNYMSZ7Cb/Sg0QZXqbLmUs5kB+TDWRPH6ACjVlcTBuEgljhSK71E+59isMat+8iHmWHn99NIxgocoFYI7ET4mNX+nTZxWOxxDmsuPdAwoZh0bvUHedigXhz8UaWrYQC1WNUXqhFMtqPe9Xn738UnvP65vH3F3c3+H4dvP9wfDLn1pfnf/+Rap2yuQbXhPZpqIzZjwn8eLX7f3Y0FN59Xe3A0uDpIC97jRAgMpuKClmPo4R2EnTSfHSIS8Depp7kv4UI10SA+QNpGo4akNxFZtXJ/91xn1U20V860qCZcfZPjZFHdTYNgUxmJ+42Q0axz+nV9gLnUxosTwUrdmh/sG6UaRj6t3IzQCVP/wfv1q+H69unu7ehKR7q5fVd6+39I0bzxiYPPl+UUBsd6uX0PznhcqAPH5HltHnyn11qih5wiK8Sh9unk3rjyHUe0kUJ50wtU73PGlvGoDKMM28Ma9Iw7jrM6jhy98g2Gco+KLuq+wsIgwx7uZx64AbL5/DJb+C9NxcLa+IcpgUpK34uiqkJt/1XzESDOt5nLb6kmBns6sMKsUYXE8AlnQ2PBx93b3+fL53cn79fvN+6fALh8M0MmbwPDxdn31Umi++3y+v7155AoQiGN0ExKpj+jPqakPpw01sqyPu4+Ht6s3DGsvhQNJSzfp8vPby2N4b19Jzsa3N7dvN08cIPj8N81zGrLe0DyDcnd2yuFu3q71MsXvd3McyUZSQZJLbjQ+8sORc2lOmKO2MKQObYQ/J9NtagBLpIqoLGPu+ygwHAeSFMmQbcOcmw6Sl0EodoYxJvscz4EISOR9oZ5c52OIpK6LAm9vWZcLvgk9b6yBMv+UW+d4oyRevL7fXctx75/u739jZrZ6k29ioqGdlrnYe8GiBnKom/f3Z3TfksceS/HCS0n4Ku39kP/mT1jVWZKfeCBAB1ympHpWoy8U8ldI9Kj4u8ImdFE7g/3r1Vttax3cwTNEdRSbmtRi30nqCA2M2ypZvAc29NsnSQrtRN9qoOmAJcO8Jgo2JmU+sAdyTBwT1y8bmqBfkzxyUvAlUsqO7m/uMfJx86qXXr183H88vl29NPd5/3gV+g08H1d3XFaGKWB83nx7vtLA8Pt6f/N898GXP+5v74QRg4S8exzmodeyVf3g+tp8AXwdtPGr7Pi2MUSfMkUqNBRPS6LSsA5URjQlfilzKqM0IqjdmHhkBkg9BCP2vEwlupO36NQ0aoEiDKFEtKCnj24wnJ6iFeGQZDw2p8pVKcSVtlkq16ncbuJzxndiiNEYcIBQicmC6uQY/KGsW4QjVt/fSsiTZIVo3cl+JIW0ovjhnuO/vN9P/+/fHr8JJ8+/3vR5wacsJ+t9PAkfH1f3r074pnSmZBSCQk/Y45Zfvzhw/iqkHSVRwuqXKw1Ov9F+cxZ12tS/i1IaJGfK8p8X2fV9GQeyJxNP9WFAqO5gmCgWd0TEHc0eUNkUwEO9JaZjBcaqLioPptOj6uhDepoeftqfgndjYoxGaWDFtHjdVlA6Jh9np02NC3LjmSXG8cfV7a8y/W8bLvUI8t28vb9ggSPqIC+mz82TP6RIAo7AZfQs2t58GjdTSfnIWI567uyLVP0hte7KzQlS0MUrfR5/cEIdx3ODLxNNgJzxBOgJE43ZIPdP651Pq1efKQF8yh4vEVztSoYqemIgR10mB0C3MHWPRKqIZIzVLQ6HnRRQZpcgKghz/zs7JeMu+qdytY7jP36rxsu+0uXXSSiK0Ixxd2t3/U0Humt5ZB50fXtvEFZRrmFiJfN5l/SI7+YBzYr1+tx04TdN6bC6lVqqDkN05n0jjYBPyygQrCrmYgFrdBGD/uAru7e+oaq5XInOsIUvb/c9g3XswPzjkFHBLlrf6J7Zk36XojtO1JBogENMZGZxSboXRoeSDEM694kANuN2G+TJUnnnl694g3D8x9GRtXTZSfOoiRiuglIbfAm6WT2MLTms+v7uzvpBgUsAt6rz8PCA7/IX6ebby7P0JG/HDw7puGUQBggj5JQ/AvjiTNiw/LDwfGF6JA9Vmml2BgzdIx5tH9aJC7Ke0pc49m51zJjj7/5xc4vMQlnVp109L2ifFNLYP2nsUl9x5LN8+em5481oWkqjv+vPx8fHlg3xkomiVd+7u773CV8qOweZBas5zYwRjfCrRbTmka9Jyl0Hz5XGZUOOrXbJegrBJN9pcenjhor3b98fY3w4cP1ff/yqC0biynIjlG8vpRUjbdqK7s1G2hYtmqofhs8BxdFGLI4qwojOu4u5LFvgZrcppcp4SxDbDjszM3grW7pIfjxIc2gJBpiL3D/cMajjiwEWwcOSOivWMxr/ZzmYU0ewn68vrze37y8vF13E9jZ1miVLLGTvtvnZWo5SCDK8k3S0LfhQ12+GKRdh18pHt8IdBKdxRm1AiYO0xwYR5G0c+P7O+t1DSw5m4YvpQ9vqXEsRBfCmBK0Gnu4nUuQJcZXNG6ryOuTTV1IlQzx8cYsZHFZ0OKx11lo2guqbWY6lpw2/MY6V0Jv6YKLxFbMgPl4fHh8sE17i+CT8IlfsysatJcYdWmJ9DNmOJdfloW75sIiUp6oehlrgVrT8Gj+VoFvzIi2GUjdOKeoSiJI9BIulE03JfCGaX7KmA6Qg5h8ONGlVR36IPevSVKG4Dtm0ysLyi4nP9dXPX79eXiTbBlADRmYuBB39OYudNjLDP9uGeaTmXztOBkhe8tCUUqBDOTyJndmatHUx4H+P+18wUGGmbolW/FnFvxPHP8PUsJ9w250Qt1lPKohC7M0PCikAR2U9rIoi2IFwtqO1mIh2jFwpuBPR+vKpx4xiFolK9LeL3LYoX8oP8GEE3Pwi77p+LZDzpAbflhO6CLHeYGmIw+eID3f38GdvGmIYBoh0o288+p/lckYbnF0nKYiBGR8kjsWO0/S2ljTKXi8VgjIm7M0VbDEUjT5nYy2kQivDmo0MSq+v+QWFLDWYAthoUsdK045ITlUxE6vrASjp7Q8PqEVvfH4RvCiah2cqPl5chRsufmMou5//TZ5a+hzZqj/b17ezg3vFCbANqnWdeFO/dCL8h0p52ouMfelMTaxSmKU1TMJm0Jb5tNDv7+I58CwXAtG4BkpWswT7cESIgeQL4Rm7d1bwptzJVSP0oxbJ9gkffBMrfYL9d9aO/wUTVNAFjDnDBggFWlSRTPscaZVNivoRrUJ4uuCF3pDFEjZHeB06auNo5GDTd+ITqqU3Q8Hzag22r/g5eNrXWJXvYux4/VLBBTbgtafWIOWkYt/j9d3T8zPFg+Lax/Va6ikh6iIaUGPH3LLjT70UbEyj5FLMIZsiDgsTcwRUgWHGsZUacR4gvc09E2GRrSSLaTm8sNkiaOzVAPLj5wfH5/Xj/aMOLNBHbooYqeCZPwRF3mGooKuVkUgVIarROB9lZ8rtUtn9/UOFE/TgHHhNDtSUPNXvaIiToDNUj1E67vMXD9NUIAXkieR4s88uguKxFT+5vpEh1ppaMz3k7A95udFR2nx/zCaK7Qh2eNk+dA7+YlHLmPO1Mti00WNCMjkP20wfu5s3jaWgp32NUw80MQ65vSuhQljX8lSN3liJG0C5hWmi4TZ3rjoGMszGjtieEuJITdv5hgvaGBzFSuulIzxRD3XFh/81VDa4Q8gx8j5cqONo1IcCuWA7jgcfHUiQH6WemL65f726vnSBLkMVtSgk6laEtE0HI0gUHCkooWhFgazLs+r5pYOYi3YMsZc26a2mkBpmhsguuMnWrjzJ0JRWXfF3rOpsEZ3w7c9BMart+fmZhA5msUPQYalZbaEceQ3LnW5uHx/Ko07hX1VqY9Tm4OPz5fkZPn8rVlltX//rNhEq2EES43/UODgpqPb+bqPbIEoq/9qwmYMchRRfxH/kRBstv337jiDOJ1HRT43ZVINw8p3Y1cpiFsAuxKxbJHFCtEXw1DQrU+U8Zeofg9loto35yxYws8VRrpbxTy2I8X/xcWhVoYNM6A39bmLA+UaLDfJ8KKj+9eIWuZiHLK5eY+3q9vkZIYNqhnZxe5xc9Jv5c55v378rsSV8irEtF9k4lHm3seek8x0vRLnwnBAxCkMkd1oAXcclyYCtPeQiaq0zC85yUlk3ck+/niATPu3Rnh+Ae3e7hBnVFu3CbjkIKqoSr5mraSq9tBGpyzuhVnXbtNM60oj9xdfhaZkP5qkChTgNR+Y5nDk4x5N4jY/wyQaY3YMkOl9T1i0BV1fPMl9RlDvirY0es0CoSHhlfUsqZZ6ZaRHPc7O4psG0qQttOhXj7u8leCY/MQbN4fB0o+S1btzkYPgvEoUTdtu/JDmcD0MknJ6S2n2+1edwXcTP7mVDl5kNk8SQFSPlQGlc5QBhqE0JrD0NJ4AyYPX8yFx9UofeVZe0SVhbcjDlBRl7Ijgf/ra7aGIokObNaxvAUcaYDNv/wnRVsXkMNjgzGssq+ayc5wx5Uz8Sc/f8HbwPlWEUvuZY6S7/GE9AOvPPr0B8PJW5HUZWt/pg4vaLQ+cBH6UT6kwYW/2YFU+1JlFpDUP/hcGn7e21daq8Id1W5kS34j7xkUE4yi0vVj0ow1Rty9wtDigiRCc33zh9XI1M/IFrPLTEJINvHqkMc+MqH4Ne+f/47/8zmgXsGqE2fSZj7IzNc5giqtuX3djV6sBpXUy6N4UZWIvPGnOCElATYMgPkR/fv3NSxq8g1Qc22jUcUTv4VgbdKWrftoq/wNNRJxeu6nZo+fv550/eMI0XovPBsAJM8FotI/r28PD47UHFQNKYGvrCyIvb3NYDDLSyoPrgMnf8mI4yCFS3GzoWcsbf/AZcJxAxny0LmONUcOUobkmeAQ4nAnqrGhPsIm2j+cWnTu+Jv5kmLgh7UctgjnTCOrQRDURseH/59YsCXl5fWCISl5pPd5zBUHgxGty3lMp/NBlfKXK9YrtYLhtp23BwFKfwL42vVbKd5qlWozz3pCpjBwf0daxQil1+DAO3rQsaAzCwdqrSg8IWd0V4Fu3SkBCkSRsRU935O96wvnOEn5FjYdFGvHnteKhTW60PexVTCO2S34HmqpV2MJ6rnZ8aaVuyXWY1sMHEy4FL+INteuoER/W6tya0FNenUBnCFJ0pWgHs0unLi1FUv1TEOcKKft4Qdgc2SJyc4zHQ7hwEtW5kNwHzuXSbNH11pHnwWy79UkZsbDGNWfknWhxIoWhTi/T0UfB0l0nX6j+WBeWj4dp3PNV/z/Wf8p8YaHAXWa06dE/R3DjAtkmhbOpixbFn5/yywUBLszT6a4INrneR5hKc5khTSNgC4zADJJ0RNk11Hab7GDDklhtX9IylOkEsHhvP8Bm1pqnbSoC+crpbI8Nh4Iu1ZAB0uA1J9vBFv5pMFPvKN4LuclOOdelVgYairSZb1u1g14L0SNhuv1Gigpixq2PgAisNuTKZMZQWbQrDJ9q59Jh9XILkaalv8wA+9e3b46F2+K7Rhc++4ic07WHfWd8HOA1XXHfiu0jrSVL+y4g57RzWVKE40WvKwYelg7sHo8EDDEBo1lgn3YiLyLRNBtMu51Fjof/4j3//iyUxATkeMQrjdiH7q7nkw+EG0yMMjEPUypq0cA4xSvWAkNi2B9Xp/HXBLihj4T//+CcMpAVWdjAJ31r6Sj1leH9tCfH56XKG6+7Lg9xdJJjJBXHM7S6WPxyt+V9Np+5a/6s4zFMKraEEt+20HX+t8VpE8ydmaLgtQrZzEnyyYabuM1mrLR27uXl6ehIK1/XO4kwupmGBuL4TMVmHVb7v37+HKR103WbfxZN9omBh/vAWi1/DSuSy4Jguqf3ibKPGisNZi7q/bV61EQJoczT5oTtFuqn7jT8gWUbEuN0AFXYkJAwbLtJvTNq9C9Cf94ZjA5kx4s7dc5exxaSitRdNJ0PMETkmM37SK89OGVcV3EeCrhYJiIdPzYeksasJkjgi0x9HIUiHbeHo086gNr1FJIpF/A0kX3OuKCZP9VASG3kHkS/xawBMUqGjwpK6jtUdtQJOLmfjGZZlbeit76UpApAOZolQfcg2NpP6MjwU94anKga4v2/ObJZ+9XkvcXcc47v7tkvHu/XCdUfchG3bYaMbkBRnWPcm5R3xhglZBU5jK4kTJk3VnO2GoP1CR036EEQDV0R/uay4yzsrXRsMNZXgzgFmiTKXshoiZQstv/Kc9CjhilRygunW1QHDBdrW3DW3g87UwXJv+SjLGQBTmU7d6qnREc9tVFeajcfCbgObwu6KP/4efSvYS5JqxA/rPTAk9YUX126NsZRz5kzmbBwwhIr4KyVjp9D9+Ai3a8NJlG+4Jp8m3BeU90JLvfWA+EChVaRXc2aYdGhXsTwbUF9pvhHpBbWYTklJV9nxlqlt4lXozPG3799++/27CUbnuP9i36naysove3KhC0ZpKLS+lYc+8VNP+Goczu8/vt8zmYl8rIfmQLZU9/Hx66cbbVJ22gwioZ3Gum2owE/0sNVxtw/RtjNbfvzmyvPdw7colM+cyrULyWY8B74EmYHGKqj5wiHTsPT09Atj8jcVGdAKigFBCNI4hdjyCHa0mtFSi+GZ8xZzQE8FAObyyTBHIOaRIHdgTMwkQggTKcyJ28hPrfzx+4/I/SUh4IEc4uVppCSEi9EJGJ5DIoATCyoecto8hFiMmvkm4JQY/sGPDf4NGbz2Zozwjnq95MgrAj5863GPzMY+W6RUqzvy2cdHl7AuC/JabyH9whP6PsCwlOLh7zpXnMMm1pNOugCT0RuwY8I8PT9JI+XFVnXKBBjgKJ+etLSzOHLr0yKSewvfuVhaoN+iTTIVUiiVVGg4u+gzugijofLgoggN8z+V711Dl/XTCL6xOSUtIkOTpeCq/z4+PLK3mWIRg3wprOgXE/vQCDyVurbX5aaMFO3RqdS2Xp18jnt4yLi2aBk/ZQQqtODRAojLhsWh+wcuGcJ1a7XPv56dYrdNXnshkAEOdcXDk+zH6DgPLnVdP0zxcyn+W9icSWQd9xZJLTV3dc5KFyyTP17l1jo0/JjVsW8fCkQWkTGdRXhmavBXE4xgiSoVYrQpcZz0QT50iDNYx+mBpiwIdwHx3l2pUye3FiHORahZDSqNOJ6LzjLUuiSQiGZ0Nwo/5FUNFHAmm/slqpp5lFyuZ42J7KGyhgYXJz2AReUbtxvMLrWBmN3gCPzxDJhxjMni4bBo2IiyXjdDT/mh17Hi+Qi+0HhskdehtpPJBk8EUOOjjsuTdYIMQL1J4wtPgO7uWgl11d4IwnhX789vrV11iX8qidXpPQ9gp7vb33//LU+KK2jSzjBN+8FkJNuTHvj0J1uRx9+oDsN9bamKPyKoLV4yA2ZCGtUouqWJWV5yBM2ow0D7t7//DbKMsW2cTbUhjhvNdBIg6C7IQCbgdANeau4rV+EX4clA8W9Dsyvb67UNjHP88VPdGcwxpQnmEhyyRkv3LjeKMuYf//ijoBSz+KopX5V4QvXeSCdQSTNXVQCIIc+wfT66d+7d3XOFuDer2jjSFYrkBrGWG+EUT9PfWMYi70hZ424aG7LxFfpV4I/OpR0iZoWKdx9E19MLAcWbkORNGiTw8zM2AV/62TTczblux0JFlpPGcss5glYatwt3/wk8Qp896CDKj5nhz1cLSlnWNFvQu3olL2HXSUTuliSfnnRavda1pJYC0/GXpZPdedqfrbirqNnCWLaC09OmJq0MYKrY3WmZucfKesLxizA4QYbBdWSSx7JO8XZ79+J+qdzw5hEj8ocSJ6KJBl050ANOUhw7mQnIxQNSQp0DtsJC45r4t+mPZdPmTVjTaW5iTjgi7zR2YRu2dJJMOW8rOWu7MTZ9aR7BPN6WwQHYmCnME8zpOQCeEQywcRFXB9qeLVPV2kTtjA1ABOfbnqi8eb35/sOCZiNn+E/cz9FDTha6wEX4Ke1MceSM1FeJOx5yEcvlwrnIYfE+BsZwpJ2VhDYBunhurXK+2JUTlMuaU4g6Sj/d2dutlxc1Gw4MX4/rp8fexEs1aS1hvjYU3Q3A9ebBePuqQ6WFpvSoEVIqNrYf/UDmAGpbFXPJ5LlQqfygau+wFGSqPGHhS2Vzgg1MHAHksdtxz1RPsyilrnjxF+Ppkw66IvLnr1/fr749PHLF6rc5KgOkgV3kviBhaEfHSUtMYrT7HXCeANzc3HDCcUAjjvB/X0+ox521IOx0h6NaKnkp/XnVe+szqSJGUY2vzHfE9jV/iOEj2ijEbAfY5d3fv3/7/W+/hWManWyJiUNObYjrMg5Ma3FR+dxkEqSdo+tzWsuLFSckxgpr6earW0R9V9AuzIydGAKQjoKM3UbU5JiAI59mFl5iNR5CJXFvHNYLjYcBRB5BmYwtuuGOmeWExWlKnAQlVKaf9d2PKxeEL5p7zbSaELq51buHgmo/gnETV2Vv5u7CddO0qX4KLEhjv+MIix+F/otIC4VxkpKmzwRwzLYpPAP2feqm1nlfkSr3tJEnFiLhmO+AAuPYX8lCAIsGgQ1eCS/TIi40iDdeUsPRCgrTih0V3p0Cz88iCIxDdVRuWiOsrC91InqrOpvmYd3J5SuUGGvcmldKKBdOMTK4rUO4tbSw5nYsY0ls8nTppwSHh8dbV8Rwp0V/8eukHnLv9kH32d1cvcn8KKk0KY0BBanljsdTwpbkJvJfW8eTaQZInp3Fq5TVoMQ1iBR83puOKci0MxYiMYYOllBnpIM+ub+AYtimapwciAOgAvy4an0muRrOP//cDLlWyC6e4APNhD9EkyPCvB7WeW6nsSk0T3CZGP9jdJOSXmowH+pyu7zEHnQom6ZoWWgq2JYR/PzzSfSpowTSWLIxAHQOhF+Fsu36xToYfI9Te7WFaZwdwHniv8QmbSpIF/3ZQrc2X8kGjfOCDVfNHKOEx3RfWgVegChDnYihmDp8r/N0/q9PzPenpMJhioFLZwo3n0Cf+eUBxIK2vlIO1g2KMat+vMa3lXcmyMdWE950oXC6pJ5t0Sp6OK/rwP22hXv4SULLrrF0TeDadWPEzI3Kgl6KOiB5WHcCrC+NeBd99/RvqoLW/8hL2jwqZR2pdfYYoKQ5MjNOrL5s88qiuYMxzk06iG26CeTAO5PKuufN81EemJpvUkj2ns19IWGWUN5pS+wxFHlbp7NHlZE9MB1nOdX0TAWXDwK8Ll4aBk090/M4tCD4/ceP30WleWqlU3S6njgZdN0iCbZFnsYXak5B+4heFjHjBRK2b5ztTiq4+P7zz18AUXKr37fHnlhd/u3pEYMKhZoJAzVUh+wisoPsK8d6tyQh5tdXECjNaLUvZSC+cHNiQg24D+ypXdMm3eP57JvL6E5Xdw8Wgtwm0d16YTlUO4G8OEkVXcBDJi8OKDEPX+crQWOGT2nfGeKD6UCRaCyJvPYU3KMHJU43ZxPqEPePh149PoSl5tRU90M0ZogtcqBtt0wlBrchNNO0zG5DMfMV1OoEs0sYw+fPisuzJyMnladgMk1Pjr0/9+wG9KaRHp1kl24AKsPuiccpI4kSqNISMrM0g3BP2k18bg4ZOftXjQtUTj+YKmIhRSQGPs616cK6LKhFkXGdcncjv+tYNT4hwnc8IJ0k2fpr+zpKXWpzsJ7mvyxFNLO9zK1gjRuygIoBd2OChdXaCq05GADjMUaSQiXTVnFz45599cHKsL0roCWzl/Rf9CuCBTwe03xTtBtduQRk5fkjQ3rm7tdzd19bPtC4pawEysiRNgm3fmXM9cTkmLRriBHtL4IfHqLz0BPYHng1UW6IB5lmx1/2dymBRCwk5Pmuf6QgtE03UvFYB2lLBlt3ADRFoVzDjnvEyupOWD0jVmSj1K7PaIa8EoQwImOGUGoh+XLumJl5UHdjSfheTHTrOmrMPJQEsxkfJ7AYDoNRVRmjxVm8lR3xCFNC6smYZScNObj94qIemb1waNuFHVdpEf7tx49w1LmyqD0nM59OF5lgPTBUrgWBuHpyk4DVGrE8u1uOoBNW2oiRx+NGq431nqxxP6kJwgP0D7DGaWyJL5YHLMVYunJ3wol2eMPfcpi//e1b2XGqTXekBf/LhUOumnqlVy06/Pt/+3fsHU+vdbCZPxEdO7GvG9VIydwwXSv59fxr9XPJWYY/fvv27e9/+1sakLVpms9OiUOt2X/9138pOhZXNUHnm6BXioxZNwxp4PZGr40JW1oHFHepoEBVgQT+zz9/ko757TW0Wa74/m3XPPDd4MSp6o5su3sPE/nPnz89VvX09PPj+T1c8qjg0kBb9As+HiF+S+8uJz2/uwWOG0z568iNEikl0Glrcb/HwBJcxs5Vw9cd2YRx2WT4416tvbY+5FDg4F82WADES6AfV89Pzzl1zVIneN1Zx8+IW/jDnuOjIvTAlGeutVPMVZjfTEFnXfEvaaNeeeTSc6pulXv4LNlflBJCPDfjO5hP39DDSAuFnEeMV0gJbjEQaXajTZ7GP0OeM4y7nt28trhhDLh1y4PV5dEWyBZIRiEuEjgqW7J2kFj4FFzmOke3SGMsjQBPDFi6zej9169fYvTCBb6UFwPTBjVY28hDa6gJDClcCJqvVJ6I7XOym+sfP36Mw4Z5NVWMZhrPN8ZBXaTaIcxFgWA5C19s291aIoy2DDcXufQAzAQtW+rRgVbJtWlku0g0qhey0UATJMLClq7Gz9AhspyWGfGEF1aRaIFxVcP8IKvFbHtN6xAiu2se3+9N24wYMDQIky7IKSRJiSFygZ5ACiiPSHWXoLOYT/WVH9rxDRJH5J2mBrPi2mRZXrxOx40JvAu2R5XJerbk17fWO8bIITgEZzeuJDthrlnJJieUcm/TvOy7ztBGa7GI5e5JvqQG4G2UpdBoyTDxxWmt2LRidnjA8hgBOqv4rl1qmiXucyY0qbvLn8o9Kpub9pYxMap15KTWosQhuUqgrBC5DOmiV06WAdJ+cJjTpeVHS7O8vQc+XC01GCt2pPbpbzE4CWOCiCtTOgGSeVCH4TWKCtiO1RoVZP14gsD/BPRVVhLqCupSB//Brbni4TgMBxPPNh26dRGRiTZuXUioTw4eSE3CCu3wAzldcC03Xlz9/Pm0C0oLYuvkOK0bjeGL4M7iVUyzThOlzMorb2R6v8/D6avVCFtCNlCyS3mwhoKuofCfv35eucHDOP7mDQaA9ABeEGPxFbTrfNN7PM9maW4CMDyZHSZVtoCTTho5LhqMcsAhW7MpsoJGwFrZiRcScze+tNTsLJ+ZqkPylUNVkAGmuPjs9oXsUnw4hVFK7OE832qd2cdHpNJYXztOrB0PdzoK0c01V5jzSr+nxvI67giqTduhCAmSISiYpFWWypmE1qeXLpTeW0dOqfa1nmcJiCOfbR56o6Bx4/XNm2yeSrz4t6gySeKlPoEENnMC2q3piHYEdeo5TCVe2t+Zw/wryAL+RQehOAqNaYX+CVrhUGt8yUGMB0UnxJoHiQyLDy0jEmYULSsqPORYgrNHR+wWxxZAnEKc19ZC3TgOprIquzhRfnRJQ/9lGyboYpn9soiGk5hJ87BceBj+sYLXi4qdZj/QEmHQ4kt1seGsWlXRNoheJh8ui966pHL9DQAbpIoWLvBJO+dA81cDDFVaPKo4nU65aQhuloyDmW10eEEht/9xGPMTObQOLqpd3gNFA3JcjrVUlV7TW1zTkNUIhzRCHREKJHHaWvpvHf71tb5IUb9iL4UJPpY67MMz0OSBUN4sm0KvLW9aNS3XG7DjWxx34UW1YakgHjs8gf529QmKAojGYZiZ5S8hQiDS3Q9PsdNfLriD2HMQn9JNrThAEiWUl6XcuCRJZVhYFnTYwq7Brdk4Od274h2hLg70qFjEoxlyCDSDPH182W6ngaXaOE5zfUGUQQoFR/XUpzAVfRnKIV5rbN3i5nrPUl19v+ckdTEbxgPv/2tb+SlKi2hdeZ2EjVO14XP4Pr2gQh5s6nxahjCe8b9RYm0hfvr1jPxJ6jGaxfOGQyb2DKctc6bbvPpQKUhOxleXnRQdd7lMOKagjHTCypUYNa14a2iKvHu8vfIiUj0gK21bw96XaD00OvoXxbUwsdyMAQYJUUi9xIfpjTkxi6MJHB5gG4Tnfc6dZr0sY4vjrnK4UnFuGZ9GcpVtQgphiXJa0VsqY5Z/dcPMOXVGDO1DkRe6h+fXk4t/0s4Cgrb+rBm4MxDZYGN1DKXfjmnE94ms8gLH2sze8Zq+QNU4zjlRaGzGoYTKUqtNuoNxCDalXUNSiEv3j+4d6EYQ2LPS3avLY1Yb3L2umRhaKjYHjRmpVIo3AFO3O2aooi4xp0qiVBVeY/8OcvbAY9SX40Cc7is5qu5sBY0BD5/3VkUZQFN9RC2MqWv9oCCQ4Os3Xyq4RHKYvrwFVsKw1riIAUc/vqdvGjwBDhuIFk9St8b+6sGdnpIuerSMagI/xVLPctMACx+A/5IvgMJAPTsmB4Jz35OxNj5tO8Sa2UJ4BqRt6RMJwhEH4Gw9ilSbuVooeqeeNesGFAmtUUtzClkM6cExUuX7F6whgzq/P/zNJ7LzSucaYY9EBPFNqui3YJ4r9Rhe1VN6CjhxMr0B85WfehMC7rUPh/1EcuxbdMBLl5+KwpP2ZDupYZzZj77aNLNtHKFvDqXDWbLtxTfqHBt9zp0vjQP501fnTYwQQWDuMKwhJJAi3wwpJJjTAWia04pAKMIilExIUe60MCPrcmy3JsZQ2gKBI2AFEd7ofdM3n9+5usVpF9AKgYbf5lluyk9LCMfg1DK/wOmJ11VFMPZCz7z4y3bnc2rGtqH+4DGRN7/vNdUXYTChVXwl8MFTk4xfF+t4f11L+efPnwLxcUyNyDORdHpoAt7RqPPs0/Dwo+aCJobriHsYL6LZvv4B1XE5/qFc+5AnXHsl87cUAT7lSPSfX597tmKUm4BtjIazq6LjrZVXrq+PKKitSaAVUF4gOW2N1JUFd+fK2rpbNM9ETq5jED1j00yF+WyGcMRRoxxl0lukGSmOpymdxlxf3AIjY0jqlWPxxBx4GG/3wyFZBwKypc/yNJ5kr2S7lJnwZ6uwC9RJvwvo8yD4QMz7XE4dfDptm+7gDEH/iuek1eoRYy13USkZs7IKsSBu0TRd756Uc01Ng3DOTsOTlmeTKy9Baj1myHC/ux9bqCgRkoaa/n54hqpGAfWd8b1ArguX79de3WccFp7ToRVkRr9s6DfgjGlfCWirk+L4LDBMTTF6bnoIiNLXJcHkkceBD/PzoJAb+j0ydv+AQ1xqbk880Jo2UH2FclVHk9PwxbP5RUxBHS4dXvZQB6U7Kerku2h56s9BQtJ/l4xaxF3r4sZwdOq+HdfGe9QLU21zgPATSeKkimgo2gOfjKWk1iMbnGhtulqMNP3tclOKKhh0vcvr8fhcL+kLY1He/UjzNDtLHMSQivL8siCoyBO7gPEB0fGUww1O2E9YeqvL2KLVl32HV0/vzzc3r8SrKwhruDOBCpnKQYS2Y+yAsRXkRo8t1v8Ko+SsjHqcxEPMOxC8FGiIMXShPwtXLrBAfNg4XAFfo5onRT31sp4MV3NgDnAS5alvfOmLzXJRjnThucmgPK6H+ReXxldLE2k+UeKqv6h3rJDUaFVFLShh2pLR6lRvDjx+3LGrGX1nU/cNskLeR7y6ebKHMOUeQsO4lxCtdxzlBDO4L4cq1MwiPRf28vMFbVjikYt51jcsOZ3tgoasGWq2V02QRYCjPs00CHq53fdv39yfqsoHTjrsIsSeU1SgvPS2sLABBBC8GJ0R4dFZ63Tpq7W5AmnVyRDX3c3wE8PQKgFGMd8eH7q57/bHeFB4Jfqbifz8808weQAa/XWlfqc0kLACdMOvsNKL/ThIRG2JKAOl9pp3b8RsJw4U2fyNo8MU4KM54WLqG5fNN3Pv7l7WRVIF3DoG7MmmdGrmTdbTtRvdGaal1urS3dSvwdFP7I3aaTs251NhB+7DVa7Mn0m14fbMOFt4SHNppo3sM1YWhmqf7At73XL3kA3wImqYbfNu3yYT+kWBLh1632fxBqJGPKDbYIOpywCQZr7RmeNPHJStSoQ4pZDzjYy7/X9MUtjpB97f6i6r+lHx3zXOLt6vfxRMj0SEFxmFMHjO0lWeEsNGlovK4uLIXAWFXvSfn/doY2xmmTGbPzo+7FW1fnzcFHWyVfmlc7RqCm8dNe3WJGSXDg7zKbLfgd1S/sa4mVY21eNKqMYCzSqn1e5G/bL88QQACeINHi4CG4YXsiI9ouEdW05TwApDYJswSTVB8Vz9LmpCkjLE/Nc30SYU2Jz0hv6bFxMw+YxViT3/3rKqCJV5juEuQh5TpIfRgD8dJHAX4VLoUuitKOXmDpAfodkjHpMNU8eRHMfJ+cwxUyhNnVFxnpvOqWMtL9pHffO0uTMXKWRN9iS3DR/T7WAlkXfayq/K4rJzEWYRr8da1QFsRDkKDdGaJF1H8Gs7dsd12qGfjCp8Vb0BDCwCB8malk53EMJIw1QI0mBbRzVuPjCapoh71g0l4qWIAxoSaE+zvvwTe2zSZlQINUXUM1ZeD9DTx/cJ05fyw9nYiCxaqX06hqE+dDYj2CiOszHttHCZGSnLPoONNc3/Ym5SpaZTMkk7bRttX3imQzHmz21LwxQAyxJpBSsLarCsoaazKIco+S7TEXltJ+U3dgpTG0tSumrQGBB4XYqxuSQgapKgKzXpQ+UXy14TYT2iTK5rBx6S3FOSZpvLYVDCcMDaJMLZ1kvitPLWY/rZpVyr6gTNAI60YAYB9MghaIbQasjEI24NTtYPoo70vynuoov57O5kKCmAwIsxctiRC+Zg8RWHF34Po/GwowF1WI+az3frgMFviW9SznkTgY50BUuV5ymgwFrs6Gs+DkEoEu7A8noJ0rxn5KufUwr8ja7ioecRWmR0+229/MhtXzgxaFMDEVgdWnORNLnZYEwdiUft6I5d+OGwrN04Yz3rbeNwWjgI1xvwkikb+m56bYLmTTrK/8O6jon3L3eethZ2jEnHDU9VWlu/HBv1jwQZh3az/NHRShUdFknp6AJ7UWJ1PfFx72aTlDu06feySU3TTL2eztPTKrDcusUMR1nl4scQkq6Wsmk4ormRNoWlhOvlPoYdF6g77zFVec+w0jgxFu73nLCYppnGOtAhiHo9szWlthQhwzM8CZw63FSJmqFMAv7gdzo8CrR0sDUGy3Ae91kGTfdDmEItIAzVX1nKnukNedvJnfKf2Ubz3Wl/cTjlOn1gGxu1ia3EbXNCUQ40Pac72DGvADCcq54pWa0M/Iv0eKBTKLYSU8iGFKjvWAIgpujuz6R0pScjrZH85aIjzaNPrcDzivpGDu2rTlXKH35EAZga6cde5HFlvG8paWNKKOrpgkUqQWNOinyzwN6e8W49/I9//OwayoRSmHXzh+I+X3dfIjIFNCtrbge4Pk8fNsBOqDhrHflnt83iL3IlXUcXCiKEy9kh4SdKwTNfTM1JyKc0qCR3jE/bZX9aX8paLINf7UWPrk/NUaYmWH20R7LvQxTeVJUKI4CCY6F9qxTffvth0dnizoXemsYxYHokZjoriHlDkJ7soZobaqAtY0AmOHt5wLoLVfcyr17cP0tP8As38RT42Gg5r5vdOLIjZMY37o7Uye8E1ayL06/Qb7IT0Ch/Nent1joS6cBL6qvdRpeUperiD8sIcv1pN5XN/ZemNxfJv45MBBYl0lRA2OMSeqBv2Bo5qcsWJ90zwQE8RbiSDKwu/hsLgyu67MBMibXqesPjDpRUD3T/x0hj/YIhJLR15MwihaIjmnIGaKPPDCXrqNI93FR/a7pGt8urEowZ7CddNiBncc//2mOuz25vStI01NvvTiZAKuc1Gx81qsFpkw7CxvH1dXLedmM3BPU8s5vCm90cdqjTUdvB0RFtpBE2TJ+zbTp0rPdDPC+WhvmENkWO2bzpFDCJGSJQ0SRB16xb+9fvGcFRCGfsWo9OtKYA5dFZ51FbWaYvYG/xpd82OM1FiRrHBBRFm7ba84KtYopvkLXyKXNviReWWhfld2Fg8g2fVgjVOu58pdmbj8ff5CQLIGKhu8xmjWSdCQtEWSoOtIdfxY5CNjvxmQAcS4OplVzkr32Q9ue7Q4WaRSJHU5LsSTaPBdhtgXg5lm9f6IA54kjHgB1psZWd3OhYUvv52etuK4vsGXM0rC2TNEdqawT2uev1eR4n422bLY+/Rt2E84BASw4ladY5tI75pJvOGgMi0R75bmbL2i2VtTDonyobSeYUqfdrCIrt0yz5i35DmqRu9MCZ8yRZB9xTEVbsu3mV8GDEhhDExNilKYvVDVctS+jX8eTFcL883vAEaj4QPWg1jlj2pjlYFMzfFpehO6wEMdwzPcEhbl8ZXbRyUDhqPLAQ22rzzVZwX97waRh8fPyxcYKYuKrN0EGy7dDJjaO92wlYUTc6wa01pfgu9NlbOADo/uW37opiFCjjpjEgRUKfM6HUqfzRhVvB9rXfjEmPAt4Wjo6/XHi5+NGEjIkpArCX50HjEwM7oigp0NXVT7cuTww16SnNbTESK1wQMZAwvTy9Fmy2AmEff0NI3U7Iv/E/8aaXyqq3haKMYrIHWejw1/+JgWO36bPnJtzCpb6ghOIZBtYh49pspsYAtE2XZ4tkxmstKM4iulDjzI8nZU5+vpAFVCW52KJFjiZWr+5PJ8XrEzft2k0Tsbgf+/R/IdMKqFWJMhw+WRTpCnHvJAwgHtryvk3iMTBN2rWg5+HI7F9HPqJLy4RHaXLXNA9bpIIAQmKw7hiFLkejAsIAyzYQKOX4R7/dD6tMYc23xb4T5NyZAh/CiowiBnN7ggAPem2Gv6b5ORVnoRAmL5HAOQ624NGDuqeXuqiSG+I1/JSsCViAvcAu2IyubctK7mRwNGAAWuCEGbSAw7Mqlrzv7ve7Vc/PG7Wih3oX4mkguEUULetPc5CqdaWRBB11AcsFgPe356eX5Z+wAAqVnqitcRO7NfGE+O4ZpY8vIXkjpdffDjygyQ4tc0Srim3rlJcjmLsh4IQReLOHwCXFuudivC8GD+xuU3PXZmvdEyEb2KCL9xGMm1k3shk2lBUBSoVG5u52XiACOtMDTEgTnJCRq3dQ5onGrcwCDjLf4UDRf7g6KX/79NtiPTXVRTy/XLgX+KgJpr+uw2ggC8r+Tfb9ekiE8kFoU/102nLTprH3tz9+a018tRlPfR2h1DSbV+SRv4eH3//eulOcMvLizMjufKU0tQWMw3IrFuMqpcBxVlrEZbxAj9lI2Pj41PGPX3/kicfhVW9zw/5vv/2eh8ff/hN0/1OM43HYVAlXpO50oQUQlsRMF3hhHsZpp94mpFx6m0H74OipNGPkUfpllBqtaWwKlOy+uj3918/nl59+XoavdWNWfnEQe8YPGaufd/2CZ25QSPlyxZB1oSaFBF81F+j3x7B81AoV/s9zqI7damCr60AyNzm0ND9KocAwNIAYb00oAZVVpfqMl06kh912GdFWLMJwBoJOW8XUsaTwR3exqF0atItInmhPMU7iTlXyXgKSg7QbVFtOWqux4KVtArrMfA6IcONmUBmgpw3XtPI1je4Ih7vBbMsGXWY7FPNkWugn78rsDMXoXd4XpEZTejITEwDKJQWvpBjrCFBL6qhgvCq69kqZRncvAupO27icLM14KUrJ51Ng8bzwt1h/sfeYrIJU1G9jxUdudfr7aRMDXU8+ecUxCBqTswp3ARFDL5AyeoffqKZjTYQOezmJVm2UEyc7mi2p2GaXb1aVxaqO2RQ6YUMFvM+/NiRyElsNlylUOXvgJvtWnUYUC/tVldHm0N1UQmC3nAha3AtE8CDy7qJvSvYt1+0GrsuwrC1TjL/DHTMcHtKfgEjDF77HWcGghDbWx0/DwJFJ4Rjcd8C7R8iLQb5ZKYpXJdNFwwAgGDg5PR3tjN1qGlFqXTkaeTfYwdN7b0pEBoLLVww7PNcnTgQHFhODIZtDfsCKHGVhY/jiJi2Hpk8sRa3vtoAOCepc8xxRYLTP92nt1U0S4FV7Pk4mxCjFj5jfRCzK45MVoqMf1Q9NfwzZ3y11zj3R1CWmTZKMLKjRzmVQPVggyEODCNlURPiFqc7aSKAEPJ79n4RFqC0XPC3OIDF4kHrA5a6Qc49JOikOCBGxZLu++vGb3yPtEHrXZv/zf/yno0wzYEzF0PhR/sMNo3e3v355r5zqGM9hqOPe+y2+14Gl6lvNjVn6tOK5lAwKzQHTSYaYzTooUrAb0QWtk42u/2U74aQkUGz/+3/8+9Wt3z21FtSPNECuB8CSWkMNjaMWUessSPGUbI8JApdDFkqB8vb6RHEj9g3oHcSPLebqAROp6v1PFblY5bgpU7oWvqTbE0djFYGufTZGyGZwk71JbReIsm06GK1AJBbw+bQYV/dHwl4beAaG9zlEvM27vM3NpGZhSgkkox3sSWlalri5Y/IY9d8NR7vCUSrJVBrNBddP8zZA4wohh0dE7s9QKqXoYqFH5lq271Zd2VL5CO2JEefmISz6G97iRpyDmKWNGhkDXkKkgu6tyNYYJ0MK6vdy9Y4NGZWnIB4kLqfuJOxzUWyRJLHwp6HwPVp6/Xplk4T0gYOjfIfgLaD+4/0PE1Zm4LmpbIBg5rqdEHfPyXbvXi6c8isf7RmMu/W26lRvW5T5C6BIAVRK/fTnL+hJU/qA1WljF1mp6OKphD6+En64oRmmuB3/4EtL1cZiyYILZontOe07VtG/riVEbCTmNjil63gtiRpSZqgl6XOnSk/I2Gu2ohrmeF7kP2qPWq4WwvxiN/7E3bTl4Ay2h18EJ09vhQVui3zLsZS/XpKLFKY6OU+7Z/axMhTz6jSCOZD6kges1djm+eiqazgB6fvuoV86aViOWDza4c3BGHRy7fZeyxLGcyhe3uuaQYWljniOD/BKNTlE0q2jMB4e44Iv80sFLf2KHyDq7hbYnt7en5fec2JgCB8NNga4GnCjvzSZ7C9FQlIXi5NGZu4VNTL/eu5iWXDMbcKcMPHRDIB770ZEtJPywmc4YBl38evTsT/opwsH9OZshqyyccaNFJ5U+PzwbC5CCvyl5vlBWDxY8P3Bq0lXoe1lQ0zlMaSM3rzsz8+fCM1CoTkAR7ijBeH0795DN/dXEucx2HbAQrlmdpe6vpPY98J92pg4uS1BKKtE+Vwhu7n6/tu3j8ebfhNECNrtwWOTFCFui7ClURjrqIlLBh07vOW1GdZWFpHeIi+oM1pZcxEz1ICn1XnwAk2oYyz5C23wHq93uiB20F66Mdi0bSt09nUEH0XagNKAdzR1e++2Ru+HiGLqz/zr8mhxmcUk9w45HkLMZWVoO2gSk3IbJUUHN6n0tsqUgfyYDF+AAz/A8DhTK9rx66QqSmO1FCrMyWeLaedt19dPv35ajKMdb+srhxOCClXz2/pKt4547vIhJ4xcEvk2AhGBASOCLS/41pUvb9uafQD1JGaUDowGk43pjkeP27lqthB2piCkR+iCNndhzBVq7gBPxOxqwJkKG45LKqqyv3AJ7AxKlWSqRbFSb5mVmVpqn7KEl/Lur22Q7RSMVFNTqfCRIr7p0QbfmucZORAWx+i8bxGijkKbViVaTbjuHfMwqUd5lypzTY5r6cHSgveRCbUt1feETAo8oZ/LeG2uUUHwnnMQ8eaqN1CwGbLrIFTiQx3aTTkhiPv4THiF5NS0JjM+HlrYIySoNKHGzQANwFApF7FCQnd1mmOwJF7v60YdjxlFNkIMF3KVl+4RmWlmbaeuw1oE/TNeTTcTrLsoDU/4DnDmGbtHjIsB8gP1l22tdj5HSrZJR+tKXRIDpwCq5JgjJsDEt080D4b1ns17M+F3U7M3Cz0FFurGTIYNQ7KINV12L4Nyw3ovsL/9fvc4mTO8jzFduoYYIZQn3JTaodGm1xNYIPmG3uGy+ti1qsrkg1el/W75qmdOQ6lxtTGuLKZq9uvnrz//8WfHKaqUXHc8ShzkxDvirl1NUVyc5AqiAgjbFH2JC+f0TJTAFzO2gcTqMEQvu1Rw6FywH0dQ3vn2QKbB9FDbsOg8bVCYCRct9noTKdrHnSviDCBENaXfA18xWLQ7PiGIYFqMLeK8fbouRAT0IjyljK/geXw8RL99Rcfm7lRYiCBh44Gck+b/goh32qhbk7rJhVAuVd5aZogg8Y99DKUDbUNt74wz1T23fXnxQk5amPSF7wAQcA9kyOUU0+xUOkyzR1cf4duVmdE7K265U+oJX9M9WDEpc+VbjvFrfwLy4tuGxmY2KWZuNPLpFqBd8mPIBYDpcFfNNJpAWzGeYx9x0fzYVRqvlOBuhfKKsglNhA6m4T2e4Syd5NARNyxbJgSUf7dIVgCe6mp1NATQViaVkA2QV14pfvP62++/8ZRRqKsR9GCw3r6wA0+MCq/jqPtBAGEyjeauTbaT2P8gdwiWQmPBFo9hqZBZpBCnOS1PrTUbYJgsJJKl5ehtYUtlB5NBdHIVRVqRRd0g72CO33RJeLBIjiT+WXBdgZosxhm4DQExgffzPALLN7PonmjTNMkMDW60IrkBmHiBj494nDdfLFGrfDTGkqzJM9U4WwefPKlkUkd1ClkPzQW+RIaCvXSCI2AE98CMXK3RPykb1R09e0sbdOFM3Xkchrc8eXQz16pvDbmq8W0fD81FTiTEs8GuSy5tZx9icNnjzspg18vGcOvSVIwJrXzjbv0ywytJqiyRQKsUW/NYaxnhtuuKsWc9rp5ef3rJh5uGPIvRFKP7gnAVY1AA9Lel9rdeBVJXv7HG8liYqPfpEZLTqMbAX8rr9pWWIrQYExKJTjUmbuiP6OM1JSAWRd4QipxncpiF/s///M/JExBIuRa6D4/fiyKUEQ9RX0BD7JBbONuLjCbF8ZP2YcfmBi2CLKTKRm4ff3gpffNh8sUNmPKyLTM0m6lvvb+8/+PXP9Qeii2Jd3sAuSDWinztantQzKWc5hhwJlJhAVH2ptcuKsSMZJc6bjwnfAany4XNlGLRLWduWLZIg1R3ellzfnIVt5n0YstYinBkcTGF9pU6pkslju0N9dwLVKoA7y/ucJUGi07zp8sXVjfvjWRqSXVM4sBZ0Zf+e1dYL/4SmrBIRCu7cvAhjHY0xtRFQftCMyRzZSwcsK4qLqYfWoclOClLh4M5ZvHekFYnlj0xGZci6Uq2z/vnPIfno1HQ2vJW+jg3LnaziZZu9pF6vnFgWWV3F2aIPSmP7+Oj6rgLgvpMthSWfLVE3CJkQsRYFOI7tduSjPJ4jUgIAJdO4zLYnGvLC+md8BoKNTKZo3BfSZDiAp/mi9TnIOlWWMrQ7ePXQoGl3RThEd/NgC7LPulsSDB/cB1GaTAe2b1zxBgSpJkp7UzHKhKl42y6TVHgVcn1HLiGxdh6jV74V3esFVZSb5C2fPDcKcof8n0SDBGfa/6KRIbokkz3Y+t2i/RTYsM0WA5kqQ3JzXsu/oJftLYPCmFfSeqwx0vzm62qlZh2KXhzy64Vt+IqD7sYg/xHyAJ6CFPVkRPaOUElQx8zhDtaOY4mOmpINDEazi50Zz6QXyqPL8epeobjNnryGN5+bjHGQ5yl2tdjtZEUTpEX6ZI97uhjCD5ezmWP8DFClCiu1+w/gEvd6TtcqYYGHCQvIQrIpoC0aDrUMEdFH7eWJl6evZ6+7eST0Fmpg/5eV7zVVxi4mQtiqZgLOKKLGEVqMmBFX+5toJGbB3TbS/FU+ffvjWPUlYiEOT06qdITpjs4oqQI25cr9V2TL9h6z6JveYt+sI5XOKOOA3oaA3OgsMlg84z1hw1nmatxslU5G9VovlaIBUiu9KWL9O1smGODWumyowuXYwsUobuowF/vvRrwsd6Gs0DDt1Y8mtYMh9a6P724tnmMl1f2EumWUuQ6h+PUDNYPaNy6Gh8CPWYIk7DfdDtDay+JZhOBZ8R42HHktD4Jk4pBTSG6pNEtMefWijjbVjssTU+knQLTA6G+6juNDj+aUyIBUsda04sSsvcpvoDzwZMFBpX6+t3D3kvBe7Q53UXxzUu/w2Hr/oqcOIQpvh6QdJ3jZtRYMbsl1FgM6yyRvmolIrn+UwfwvNHuEyf+ES/YdQIjGIUKT1e9Vs4os7lWSup6AHLS0NyGxAY8IQiCoUcgKjaLXfWNkq3NDEAsVoiAXLLHmctWh2TKC2mWMWEpg0TKUrDopFESq543kYXZqMke2KW9JZFd7frKpoKHh1yNkDJrdl24gAYyGqLclBjpMOuEKDL/eUd1mNWpmcVUeXGmMWupUAmRGt4xpwvLxdA9k2PYJEdMDjl/uNh2MmjTDcXWatAyBMqc1TMJhl19gWsOBhbKG7/K9nb3kDN/FxK2zt88IE0DFeWRgF93MY+9smg0pgnoL5sYPgqU1DyblDMlUwV8zD6TqCPfX5bAOx1TXTXhP9FzpTlKtqDB3NMvProhMC4UtoAj6Qx/YLAeD1QAopxIq9EZSD/eKwTLrPLVKMZc9T719BZumZMB0sSWbPmui/0YGs3JniwJlRQiwPSe92TczJN52wE+Eg35jZvvf0xqrUtnpoQhqbeoqbmWBsP7379/mOB531HjWQ+rShUPQt/wsotfy35i9OvPe0r1ygPoMKGkZJ/HpReM5t2HK6S6Fa4LDrGGAXtb4m/jETzc9WirOirzR7XZq3/m6Ymqu9u//e4GnlIOte4u/fXnr/WhkFzQ4U/RcfbRcJrBjF0FurtvXpEZ1Q01Y0At6lLV9YbLlX0hVhPyvz4VWWzH5VmVquHfxDaRlUf6a0uzsH9FKceTVUluN8VnXeBQFUT40lSyRy5uij7uI7Gu1usg0MpLpJhztCbC3PTW6CZsA3zECUzKChrRhW/0Dk8z8zSj6vn51aybY4LQqOL924GzzyV5x1JASKrM0dexZPfmnD0H6u7wubsr7D++vfmNSYbfIyiHMDTJVwqQhJqHc/x3dkgryrJrkUx14HqFFzHIX/+XLR6Vx8kixbQmdmUtv4a7oNG6MPWGL5SOBl3JNLsqhRehz1eQXw0GXvystZ2flNTr8iGWT1vSnlQUHIVsgH3r9QjNE/Ykh7oC/4wU3nXSLyWrHEdlhxCYxHFkesB9HFSXDuyLPKNCA63s1/fD2WKAkxymVorJO8sUIIaziD+/DKWMCko6Bjza64ZK1pUmCYRlStWvUxudODtU+pn517hDaAbsZeLcDLIY1mQpwxYeNqIZWw4PkyN5LlIlVvJsl58fJBPRoT8dIiMdlqaomk/uZl+Engd+GSDotca+gYo45sGJkO+rW0/tCOXSrPkOy4Z0fBWFX/3oUi/cEMC7UpZMFw4dRDLL9w4UAcdVz3E9zYcD8BEp2ArGvzK3qlvJknp6p36/X5s7d+kK0KUBGOo86s6nMTmeGtg3Nh5+Jd3aZHvwPdzS6kJIml+WL2m7B+7rd2S1qdWWHhyGN8ynPHaPh1WY+13M0HhaaJ3yMoEatzofPKPGoXOEXpREotaCMv+0X59wkHbuH48DWqyKUrQK0HEASxHA8UGP3QsdLFKPZZkuui0SgJ8YDCPOHFmN2BZmy2fOlsLi8q9dbGIjiRmsQ455+okupoSmyFd4WoyCpjyqh2pSSh2qLTU//rB2Wp/A7Jy+tja0pC7/+OOfnaLUwE4r3UT+/fdWc8dQkCmnk2wwwJ1nhopTRRCpovruU+04D05vVqCC6kd7qnZt8fnqxm3Z7y+m1rLR5gGlqPkbXE2flvMbEVoYrVFpfmNRXMdKiCuu5IxRWYi60W5zFy05uHdsJUCww7OmTjxIUgVUCxwdhhPCCKymvTZRm7d+idsg7DiGuZWOujimOfi2OmrOSylhjCNauPhC0/lxom3lVJNW+2hmJu/P75d6tUu+NhNm9y7pbFC98BgKNLRNFeN5xJCzjZMYj3bszrhyECENmDmJH0oQEXcWsBQ4NEUCwXhYGaRfmRr/iLMiZLilaJ9sU0+xHwyS86k4SteZw+foINn8jzExL54mhsZj8JSs+KvucJ6OohZ8X0cwXCelGLnSenZmS9yBIszp8FNJG5nU1hviOJTjBYvdHOWFM/WgAc6kGtRYSNHxe1LH2OZ9DsYp67J6SJ0onUNSHzy4Or1Y4y92jyKKHmOvzEqSHCF7SxIxWg3XYIB4FOUhlHZlsK4m33wLxNIpE7DAflEj/EuuIl38n5HSyqXHNSgYr1PZVAsIK6hdtB6jMBRXUmwspJn8NeYmylpvV1WAp1j1yGGhTu8/tsoVYwThrw18n7WOT0fbTVBHzm0ilTX6H9+0ZgPhyxbwtAyGil1goQ5rBm7zuPn13PDmFfcuPOyO0oBDlZYcY7QeccqGP94zlMpPP8jXV6EpsMKvTsR/loaqOCug6UZ1i5kSMb3xi/8eq3Ar16dnHmAYzQJO3TbKDkcsvjtp+xdrTqabY6SqYjZez453ONZAua5fLTutPmfP0m0rX+PVnX6X/64aiWViYWF7wJqMl+NrF64u1C8MRxbikTMha8ksa/Teuobqf/u3v5Mtpx+r7CNDNdj8/PNXi1Errha2aI3DMNPVguBGI6hkl49+Qybp4H+7un//8ePRRfl+csIcaENrXpVtNLfKeHNfbzElkLdef5g7dwXH/AwxlxZSJEAWgHmOjhcu2Wg9LeFmbHDPdXANqpkgcTue1k/GfXeqYfKIuUx0rUMyTJpczBr2wM6u3ubjmnPeK1bUospwoRjyEa7gbE3KQGTPnO3YLo5qn7O/bSwGk6sC4KPztHj2b+bcU0u3j81QmiGXBHAFmogi3tpn00PcDQ1D1Q/C5fHu57DKgiCWm7a/EqwsaI6GxWzBRibs9GqdFIOPflhSWm1tQrMeHuCcckDJnB4sBtSlhFi9klBL0pHgRgkpZ9KZgOjlOGvi39pqbDo6KuFpR1m5bvxflHtR2M6wlw1XB7Uj2wxBR71Pih5abxNeOcKM1nwko/o/2l/+NtLOa0XF8ESuLmIz+wWsMF0nVEf4hgfOMcCxj/fFPAr46qb7zYFiKt1jgRjDCKlRA7ZmVVB49rqLbfCrLnYW8nfVqh4TH9C7T8shO/zyI/ZxcPfihRqFclZxRSTlJuYup6dbeuEjpo8SKtQUJRP/cutKD2bmcP3pPF5Q1828Ga+ySutWDqZ6Op3aYb9Uf7UONl0fuTJHTS1AFQeEb+3pgdipTVT1KrA9lFtWGEOhOwZDICuRa3NpDgxnmou2pGrTSdLOgZLNj03NWvWPnLD/+dNxCa3Xz8YP8cOFgzDmrNB3iaAfZcNGP6Dj163qFJ/35sZRpnGY8CEniAWt60y3brT0ZJ+Mkln8rui9tROK7okBY9LuUsmCDfKRk1PvBiNK3zNOSeDh/Xs/v5xds6lekrUA145i8sHoO1l5ug+Z3UVdmlRgi1MinRNccmLH1z92O1TufCmoJes0hG1ccarlaR5lhRVFCkKHqe+ribCfjWshVpisl0Gh6icHvQbRy0268FV71IiVc4csNMpOOdRrr4Af6OW0TkuzhjxB0Hj7eHy78/b6ez/3U/iySGTO5IUTiLYskI276nLzfq+2azKZx81ZfbuQRl/9DGj5d9FqwkF05adrULo1uWvSUKuJUWxFFVixQGCsOxe707ajL2WmmpieXttPkIkXiW0zWFCpDzHN63BcQ85W7zmQ+VCJ+/RdVzlaOvtonAJH670hREEhlIep9JYN2l9fPf6Gff2slcnUnIfPbgn5hT0GW/WL8/Hmmz7pMeer7/jVJOx6mYfXJCIgmux1lTTphe0tPjjSXzSxUoC4Ofusx/tZheM3dLxcW4Vf9MpnLxbQt7QyyNjXQSlXf+rWFiEI6itXfjA2hcmCE58d4nRuWP+eW00WxxhYQQBfPSANnVL4o+IEHFHtM2eNsJTw7Y9qa1LL9CggLJI453cjs6DQkkZz41JUQBRdL6Yt7TLy+80fIZ9PxsRsAhSKaM+cxFG8SjiCiTtTukbyeQbViUJIt/zsXrDX7hLtjZdFOgZACw2NciQVkGy8dhHz5u79tbdmearG7XRvHp70+xpCkBuLJLN1BkOgZMpSo24/LRSFBCp6MU6bXdbvcvkxP9WZh9eBOC+fOdqMOMVR3dTWqSoR+aLrrPsv/dJrUmqCKCR4rqi2MwufwK6rqvXFbE/rAadSNTvwFfKvVg2kUhSpdh72wu26gmvZvree+8UP5RbwM6mUqaQw6pDbNmLAhYdj8PXwswbBIxnKvczXt1oJyqbB314/rLO3aOHy/NUrOl27SfZSJQvVggkj/HzpNwa+Faa6dswvOLOb5d72CpvZ7Obp6v1FfExeN90LXv3OOZkLjnWGpJOl5KRTRX0ld6uDR7GFHdBfP10xfSgmjMbrKOmz3tymLaZ9TewOOhwpPT21Ttl2BIBkY0XKCpuTOkEMQViRF1YZvcVnnpTiOtLNuYrh/erzx+03Gnvy4iqLwj24RqLpMi6nfWIUWgtFmhboi10qBZOxnAKGsHf/yMrw7xF50eL2zbsg3vxigVeZuluaBjJy3arfCng3RRdQPE78rTH45skl4odrPvthLfvmTcB1p2Am4jKte9WNXER4tOpr3aTXTKRwenE3TPojnU5gFTOxIczS+HCN00LAKwR+Yk7h0aBKB5Tr/+zJtdzEaTATvcqj0KySv8wQFZ+G5Hake2Qrdc7lHysc+tSyrsOkSyVUxUJXjvsFBWu53FQSHWJzA1JCwTKnw9qncLiJGMP15Jws/io9YDTTHVm94ase5LF4Gjarert9eP+bW3RZ5NlY4DqgoGaU50LuXhBdPt++39w/6YCv3PvNPReImJVZoL5/6Y32P9J4LBPphX9/eO6yS4FK+Cp+bvzWXpFB/OnWhHquG7jzONWE6f6nLjoVo9xMGfe1S85iFV1MiPntWqzfYBLuyU2jNDOvG8pordHxTdf7EIVoHU6L0E87WToqtN+CoGPEqHnu2y2DSOQhBQd1dVCtdY90aSufGDYtx4ud6gbYJlkd2DnQsPEyTz1pCOe+a676fvdw/ePq9ju9vLy/0G8hCLSEVT8Qg0zOXOUXIbp56O36pdsOtSRKjh017zpgEU8S6DafP6zrydTYAzTess0MnrvEQrMzXCbJFNjARhmWU6YsfXUaKetQwgapDXT6rFl7timxqaSC1YatJt2yF/5MUDX1aeoZx0GTCd1FJ5UhzXcrbH8hQ7RX78TxuwmcFXPmTR8u8CF5cCBjOMUoLRzq40ylLePYI1q6WbpC5OAA4wm+XpxXzrqI58eC5OwvL3+8vz798fb09//j3+4AGSrvPlyE15ovs4bXNHmW1cSqDvjx9gQgZiig6zSwopIYyKYkVXp7PpL3GKWCVL7wBFQI4nR1BUzpjZ3Uc880OKwbkOGJCFH6yseSAh6aCl163jaFJ+XRKNA0kOKFuzm4M7hm8ZAslBSoLtuQQZu2GOPoMOqNEvmbtlxvvrnakV6vHxdj7BzNKNQMV2x8sasgA+SyWS5WGerdjcXP/+3uP1pTkyy+eYrUICxh8KsitCdWiSaxcG4USB2YlredJ1gSKqapv/6YMGHGiC+6T8tbplRl0FY4J61RzuZMSS8q2jEEOuGaQ+ZFpgfnQQzbbHuJEmE6kI464b+dnxP7aNnCqRd3Ov/IL5PnhJoTQRKhhjEYlaIG5ZQZypvrkW5pXpIGBjfptqHZPopazCmm4aGo+MSjOJjUjSYNqaDpZC0dan39858/771vBC72eX/8r//+dCf9N3DKFt68oKu7S4xEqHgFdHzW9co9jrskmmLnsPU1YTF9vM+5aAxT4R6R7BTskZd30Vu6O1439eWksNsu3/8yANkrh2CudQAGPOLZprIF45pDu2CEGcIHOGMoHxqcq6DLsi8DQAftGSwtm/gbmPheWaYRvsBZu3SxbyT8pbmdX0LlTrITqBogHBG0Us1qa4NLqVS/X3V1/z/f/j/rYm6le+f9z6//P9POEbGPJwPxAAAAAElFTkSuQmCC", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 83%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 10/12 [10:52<02:06, 63.15s/it, test/blurry_cossim=0, test/loss=1.39, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=10, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.52, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.00015, train/num_steps=1520]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n", + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3bcHFvL2I/mKkb7g4/iH8685k1e5SbyRLMqnheThfSo4tdmikC3N/IFJ/jmx/OnyaiudBZTxprCoW5DEc8etbct3Ch2tIoYjPWvMJdaEkhceY2eSccmo1uPPL5DDpweM0pwUnuNXXQ9I16dRok2GB+7+PzCvNJyDq0cp7kHinylxMSI5G/wB1ciqzR3DzIRby8f7BxUuKStcqO5vFKqXa/NH+NaA5GSMVUvRh4/xqWtCRI/u1OhwtQp0qVfuihRHckHJp/Sq8jlAvOMnk4qxAN0W7duyxGT9B/jSvrYZa8OzrFpetTFuTdGP8o0P/ALNWf4kkEurw45xEf5EVk2V+8EepW584h7ouAsLMBmKMdQP9mrMswublpfmxsCgshXvnuBWqXUyk+hRl+SJ27BSa8+8Qxg+K70Jykb7cj2UCvTF8sCUSDKvDIg/3mQhf1Irye7vU/ti8M25S77t4GRyM11Ya3PdmFS/LZHvfyjooH0FRTvgL0pu/3pk/+rz6GsGzcjLUm6mZorNsofmjNNpakY4VVvR80X4/0q0Kq3vWP8f6UANQ8VKPuioEPFTKeBQgHlVfAZQfqKmQiOIgYCrlgAO/+RWc1xc7n8qFWVWK981bjm82GcFSrIhznjtU88WyrOxm6W4ksnlHV5pM/gxX/wBlqZ+tZnhy5j/4R+3aRiGkaST7p/idm/rVyW9gHRi30FVzx7mLi29hl06pbszHGCCPwO7+leN3j+beTODkGQ4+gr1W/mW4gY8qiq3XuSMD+ZryVMsq57810UZJ6olxaep9AfbrYLuD/wDjh/wqOTUYnjKqrknpnApFt4QhQIdp6jcf8aUWkABxHz7kmuZ+18jf3Co2olGwYv8Ax6li1EyTrH5ajcQPvZIqVFQHPlpn1wKnDe9Soz6sd49h9FJuozVkjxVa96R/j/SpwarXh4T8f6UMCJTVhDwKrA8VNGeKUQYyO4jt5ZEmym5yysRwRUvmIYr2VSCpUc/gBUoPFU9W8u10G/lRQu2Esce1Tyv5FXRS0uzjg0ayjZASsCZz64FTkKnCqB9BUxGxQg6KMVAx5q0ktjBtsxvEE5isL1s/dgyv1+Y/0FeXRDO0V6F4pmxp1+R1UFPwKqP6mvPozhc+nNdNLYSPegakQ1ADUqmsjQrgYYj0qQGmScStSg1BRJmjNMLBVyxAA6k01ZUdiqsCR1xU3AlzUF2fkQ+9OLYqjDcu2RMRvBIJHSgCwhBGM81KgwBTTDkA8H+lOUMoHGRSTAmWquuL5mgXcXeVPKH/AALj+tWUqVo0ljMci5U9RVCM525qtPcRW6hpXCg9OM1cfRzGv+iSsqj+BhvA5ycZOenHXA44rD1NHSEnUYWg8ncWZCWTaADktjgcjqAc5xRcnlOf8Ry+bol3KP4yD/5E/wAMVxSnER+ldb4idV0ieNDkKEX8iK44P+7ORn6V00tiT3oGpEaq+4AZJxTGnJyF6etY3LLEpBk4PbmmioFbFSb6kohvc5ibaWAJyAO3FW2UJA5jxnblcADPtUJeoxtT7oA7VPLq2O+hK7c5rPbAmcA98/nz/WrTNlTVOT5bgk/dYAg579CPyAqiS/Yy4mSN/uMcc9q2j5acD9K5yB8XEX+8P51tgs5+RS2PQZqkiWRPtSUhRgdqmj5GajNtK8mX2oM9Sw/lVqCNY1Kht3Oc4xUlCqKeVVwAwzVZ9RsYpGjkvIFK8ne4X27+4q7t9PyNPcDmda8D6dq0UoQyQPKdzGMgZPYkHjr1xjPrXmus+ANX0tibZJLyFQDuRMPycY2ZJ6+ma9wHFPIDoVYZBqotx2Fvuck0hc89uwpQajp2agok3Uu6o6dGjSnA+6OpoAUuKMO3RTVhIFXp19amWOkIp+RIVPQVBLFcY2KikMRkkjGMj+ma1gnFDJ8p3DC+uelFgIdH8gIFaGMXCEgM3O78DwK1nMkh+Yk1zNlcxXCGa3nSVPMbZLGeDg4yD36V0NjeCdQGwsi9QD+v+f8A9TadgTLKWUrYO3HPfipXtJo/uYce3BrRiIlQMOPUelSSxbPrilYZyaPL/wAJCfOt5kRE2o7DCcgEnOevb8K2WXgEcqe9UrjR0l1aS8kmYb1A2qMEEDAOfz7d6khsjZzBoZ3MJ+8hAIP41SBljGev50bSPesR7MpryW9pd3EZKFxucuEZgwJAbr278Z7ZFdCkTpGvmuGkC4ZlXaCfpk4/OqEcTSgVjXfinTLdf3TvcP2CqVH5n/69UJPEuoz5+yWKopHVssQfrwP0rNySNFCTOqCE9BTtMuIGurm0MyGcMHCBhnaVH9Qf0rhLw6rfqPtczlP7oAA/IcVD9iiikRoy6TIQQxOCDUe0RXsvM9VER9KkEeBk8VwFr4j1eJwktz5ierIuV/Tmtg6leTR8ythh/DwD+VaJp7Gbg1udJPc21opM0yg4yBnJP0rFvmfWLd4w7RQOjL8oGcEYPrWeLaeR1LKw5wKtvd4vBZxYAC5Y9z7D6cfnVLQmxDo8BtLQ2jSBzC20OF2g8A9PxrUicq6upw6nIPpWZburTXJVgw83qDn+Favo2ec8j9RVR2EzpNNv946BXH3kz2/z+VbAmWVcjr3B7VxkTlXV0JV1OVPpW7ZXa3EY42SqORnp7jPX/wCt+ScewJl+bnnHaqjMUPFSxidFZZZPOH8LbQrfjjg/gBUbozA4XH1NTYZn2ukW0V+b2GSZHLZKB/lH3s/gdxNbXm7hhvzqqgZFwEHuS3/1qGZvYVQHi0UUUTDav4VrgdlGDVQrbxjO7ew7Lzn8ana62tgrgev1rllrsdqsPAdT8xJ+vFQTxO8oAwBjkk1ZWdG9uKHzNH0PHtWd2mW4pogtrcC5VeSN2c4wMV1yokMChVA+grlll8uZXC5CnketajawXRAIcFTuB8zv+Vb06kUtTCrSk3oaoAMgLffwdvt6n9a5rz7jTLq4EMq3CSNuO8ZGfwNR32p3ty7wyOEhYAbUGN3rk9fX2pqMCoIBPFOpU00FTpa+8aOmXUt2J5psCRpeQPZVH8qtx3Mhv3t1AAjjSQse+4sMf+O/rWbp7Y8//rp/7KtXE3LfPPldrRomMc5BY/8As1awd0jGas2bIYAnFWIZWR1dGIdTwax7K4knEkjlcCSRAFGPuuy8888AfrV9ZAMEdPetDJqx09neJcR4wFYdVz09x/n/AOtZZa5iK4aNw6HDD3rbt76OWDduVdv3ge34f0/pSasNMsHAGTwKgllVF3MQq/3m4/L1qhc6qAf3YBYdGPb+n86yri7aVi8jc0WC5//Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCj4d8eLr3g9bO+ht7J7NTEvlEhJF67sHOD2PJyfyrzHV9J0xL55BrtsN53bAjuR7ZAxXRfDbQ/+Eo1KWD5ktoMZVe+c9fyqx8U/COkeFzCIJiLqYbhFuySM9cV5sK8VinDqd9V0JQ5abu1v6nR+Fta8Kf8Ia2kW85uHjiZZLeRWRn3E5OcdOT06cdK8t8TQada3XlWVosGRnAd2x/30TXZfBP/AIRSLXru48SXKxzKqpZpIG8tid24sQMDAA6kDmuc8b6hpviTxbfajpMJg09nCQR9PlUBc47bsFsdt1OhgaeHqyqRk9Xdq/UqlGDoOEYe89bv16G38Ktafwxqgkv7JBp2qDat0/DIU3AFR3BYlTx178EV6R8QPGkGl+GTc2lvBdSySKkazKSg5ySQCD0HrXnfiPWNFtvhx4Qs7OeKbUrZZDNEjZaMeaWw3pnJx9a7yy0vTPHHg6S234ilUNG6nlGHQ/mK8PN8PRp4unjZp2ur28v6/A+dxtWtQxVOC+FuzfmjD0jRvEHxbsLK41S6hstIhL+Tb2sO1N/K7jliSe3J47Yyc8Pf2urfCX4iRyQbHuLP95bySplJVdCCcZ/2mH1FenwLc+E9F0LRbXUFSys5muL1jjMnz7lX2A9vX2qv41vdI8X6Pc3SzQXDwx4BjkBKEdK9D+3P3sOSN4vr89NDbHZnRw8YU/ibtey2vpv+n/BKD/F7UfE+hSLewQxSKxQiIHBGAc/zrx/VpDLqty5BGX7+ler/AAh0u1uPD2ozXcKsRc7Rv9Ao/wAa5z4gw2UHizydPjjZZLZZHCHI35Zfw+VVralmMamPnQ5duvTodKxTc1hFF33/AK+89G+FXie3t/CVlaySKrx7lx+JqL4h6g9x4ttLiLmEWcalscbvMkOM15v4G8WW+jeIrNL+BEtPMAdnONue5r6K8YXBh8D6vqOhXJjmS0WRJrZ8HCsSSCPbNctanU+sSjKyja/rvt6dfUyqYf6ynRl7t2jz74m+PIbbwnZ6fDIhu7tCxQHlVBABPsTn8jXhsOn6ksKanCpCq29ZVkUMCD1xnPWuv+K1jcrrOk6lcs0lxqGl2805OM+aE2njtnAP41r/AA/8L2+tW8EV9N5dspJfnBI5OPbPSvRknhYp7uTPSwmEvFwbdoq9zsNV1qDxn4e03V7m2W3u57XEyoSAHDEEjPY4yPY968tudQk0u6ktLk5TPyORgMK9B+IGq2+kW58soAF2xqOnsBXjh1DUL+d40aSR5zgxRgnd7Y71hl+AlWqzdTSL1+fka1aipRUY7nrHwYsJbO11HUbK5hvGOxTHEHXY2CcEuo557ZFUvGfw+8Saxpv/AAkd6yy63NK5ubNWAWOIYWNUOccAFjzzu9Rz1nw8m8P+C/DlzY3HiGxnnluGmYhghA2qoXqc/dJz710J8Q6ZqxMdteQS9sI4Jr52pmWIp5hOrTjeDe7T2t+H/ARwrA1oVJOz8/I+Y7dpdMuttzBJGw5KOpU4/GqSAs6qDgk4r6U1D4fWHiO1leTKSJhkYdcgg4/HGPxrgdA+HMGsXbCEn92+Dg19Lhc0w9eTinaWh0qDly029jrfFPwi8HwaWbi0mu4LhIxys4YORjkhgf0xXO+HvDupx2LWGlX0ixknkgE816PdeBvt9nKNW1Sa2i2kBYioc+4Jzj8q8I1nV9c8IarPpVhrxuIAARKI1yQR0OQSD+Na1I+1vSklfezDFUKEmrvnXV26m34viu9P0qSxmuPOm2/NtwT19q47QvDV7rG+SBJAYzxhM5NZU91d30uZppJnY9Cc5NaGkafYS6nBBqU7Ro7gELxjPvWtPCVaeHlKLtbd2/DpccI4f2iVGH3u2v8AXS5Nq2heIBebbrTbx2C/KVt2wR7YFMtdOutOkjku4Xg8xNwEqlSBkjv9K6X4k+FW8LSabJbNKLa4RgpJ4BGP8a4yyliku1F7M6xMNpk5Yr/k1WFqfWKUZSe5NKtOlX9pV1fqT3ts95dgwAOzADAI5NdrpPifWPBHhS60K6syTfqzJHMDwjDbwO4JDV5+0zW10TbzBwp+VwOv4GvU/hno3/CX65Fc61KZHQARE8YABxx/nrSx1PD/AFe07t3Vl/wTrpVKdZzqcvvWv5f8OV9F8B+IvH1o+qXmpRpLCAogkX95tA4OOMCktpbvwg0trcgB+2e9dP4q1e08N+IzZ6ReLK8aglkOcEjpXm3inWJ726SWc/Meprgp1qleUedWaf5DwGLnSbVVbi6guveMpAtnYvNao/8ArQmEDY/vH+VRmw8R+CpftOnahNbNKuyV4XKLjIwHPTGT34rYX4oz2+nQ2UNtGsUKBEVeAAKs6Tqaa0slxq1xbW0H3fKmkUGQEc8E8Dkduc1pXx+MUvaVI2ivvZ52Or8k3U39P0Jbz4a3Oj2FzOL37VKilgoTGcdutQeDtQsZLqIOVR0fJyea9Y0zTZ9ama3YlVbO446CvCPiDoDeEPGc9jFKxwiyq3Tr/wDqrLh3M5+1l9Zjz3XVaedtLXHlOf4lL3o+6zu/FPjbUtFSVbCVQrLgHGa8+8MeJ9Y0vUfNtrogM2XyAc1lJqc166w390/kE4JCAmu00iPwXaQhpLXVLp/9qVUH6CqeHo4aMlyXcn0X3fcelhKH1iuq0Nl00ua3ibxg91YfPrMkLsp3CK38wn25IGa8u0+0l1bV7a0Us0tzMse7qeTjNelJZ6X4lu44ND0pLCWM4E9y/wBpDsR90o42/pkce1RR6Gfh7qEGoaxok8bYKrcRsXiTtkYzyc9CfpVwqOlRk4pufTz7HJxBiJU5P2cdlpFW3+Wn6nrd5pnh7SvCOo2el6RZxH7HMIysYLlthwdx5Jz71833miX1jcC6uU2xhwzHPQZr25PGfg6+8JajONcjGom3lWK3kVkO7acdRzmuS8OzaV4ij+yX8q+Y7bcbsbhWeUY+phMBUo42Eptu6d9VpbVf5nFlVDG4qCqysrO9tb9OhF42+J9r4r8IjSRpkYddpWTeSUII5HFeVLE7MBg19B6L4O8IHXr+2ttjQQWiFmMhPzZcscn2x+VebeKdPsVjeXT1wAeADniuuiqWHjyp2b76+R6s6EKrula3RX/VtnF3FoYIkkJPzkgcemM/zFdb4H1uS1W7tvMCMU+Q98dDU+jaPoer+BLhL68a11W1u3ktwBkSo6oCD9CmR9TXLWljZjV/s17qf2KHaf8ASRCZADjgELzg9MjP0rStSjXpunJnNGp7KrzxVl2Ln9rjTfEwvTEl2kbZaNmID8dMil8Q+KF124jddJtLWJCD5aM7bvYkt0+mK3/D3hPw9NPeT3t/LqFpDY3M37hGhyyQuwILDOQQCMjGQM5HFQ/EXwTYeE/FF1p2m3M0sEQQjz2BblQeSAPX0q4xgkvIwnVdWbszP0650/VHMS6TZaeNu1/sxlYyA+pkdyvp8u3IJByKzNdS2tp1t7WIIgGT1JP51Z8IWzy+JLVdpKbwG47V9F6tpvhGz8PyXGpWOmny4yfMmiViPpkVjXxVKi7Pc3hBziopanmSfEHx94R8Q2Q1bSo7dJcn7M8O0Sr0OGyTx7Gua8ezat4v1++8THTZLexEcYJZgRGAoBGeM/Nnt3r1v462PnXvh6/xmG1+0CVgfultm3P5GvNfEHi4aloS6BpsAEMuBLIerEEEAenIriv7KrGNCKfd9F3672OCnQqSrKFKPunE6fYWl3Igea9xnnyrZW/nIK9x0v4leHPBGjCz0TwzcOMbnkubhRJI3qxCn8hgVlaF4S03T/D8b3d7FHcYLMME4/Kn2PhPQ9cimaTW1ULwEiiZmP54ArKeaxnU93RLr/w57sMHGNN3u113t+B5vZ+JtStNTfUrdGkf7Q1wd4BJYtuOcAD8gPpXqCfGfRfEGjTaZrVgY1uIzHInLAg+4FefrAPC9xJa6rGY1kO6F2UjeM449s96qWFvp114ktyjRmOQlW2vnB7V6kqlOpBW2PExdLkreyqlWfw9pBlka18QweSPurKuH+mMjNRz6D9g0y4votTRjEFIRVwWywHXPvn8K6vxb8PJI9Ok1LTIppWjA3RRoXLAkDIA54zmuY0jwPrGpRmeSxuoYAcBmiI3euM0/axp0+apIu3I/dZ2/wAFdGk1+XXmnuzFGIFhDEfeZw38sfrXPeKtMvvB/ieCy1IMbVyG3gfeTPzEe4rK1LUbjw3epp+kXDwJCqvIQc75DySc+2Bx6Vr+MPEx8Y6Po3nFftkAkDEe+3/CsZw5qkav2X/ludVOrVd4J6hrcOnxM/8AYs5vLfAxMowpOASPwyOvNcLL5jTnep3k9MV6D4e8BamNMbUk1I2xb/lh5O5ZAPX5hWUVj0/WFnvYEaaM/L1Cj3x6/wAqrC1KftOW913KqwvT5no0dsmlR6V4F1KdwUleymUA9soR/WvKb3W9R1G4a4u7nzZWABYooJwMdhXYeKfGy3+kmwtsHzRtbHYVnXXhAz2oNgCZ1GAhP3/xPSvQxjwtOpGNJfF+Zz4HLakqVWtS0UdX+P8AkUtN8Ry6TpH+iiJb0zH96VBO3AxwePWu58E+GJvifDNc67qV0UgfYqxbVHT0xWfoHwfutWtw91q0VpIT/q1i8z9dwr174deCrnwolxapdpPGzA7tuO31rx1icEsU6Mf4l30d/vsbUJqUJTctLaeZ5J4z8V3uorIly+VKkEYrkNGkvdQ1K1stKsGudQmOI41Pfn8gAMkk4AyTwM1q+N4p4tgZGVc88UfD7xZq/hSa+n0zSmvoZQguNqH5AM7csAdo5P1x7VeXQjSw16UV6aE/2g6i5qOiPQdb0W+0XwjPPqU8ZulhJZIR8gP1PWuf8D+Jrew0+KXzIIJt+2WSRgCSD6npwR0rqI/F2k+M9GdtWtZseYY3s4ZMbgAD8z44BzjAGfcV5Z450q2stVS402yNrpsqARxB2dY2HVdzEk568nuccDA4sNhJSjKFX3W3dWM8uxmKo+0+s+9F7K+hv+JvGkdp48ur+Ax6krMGMiTDDfKMYYAjjp+FOn1Ow8b2JluNKWGVGKCVZMuvHrgZ69DXF6FYpqNx9mWBpp2PyxoCWYewFeu+EjoGl2CaVdPBaakkhElvcN5cm5uV4bk5BHSox6pYZKUIt1FbVN3t3MsXkSxSWOg1GbdlZu6+Wxx+pXd1p/g6WwuLpppFGFds5ZdwPv06fhUnhf4pzaJoCabPAJfK3bH7kE5/rXf678O28Z6rotvAGhtFM7XVyq5ES/Jj8TggD+gNR6l8CfC6KY7LWNT87HDuY2UH6BQT+ddeEhTzDCKdVb3/AAbRU8JKnFKck3/X3HillHP4h1eSMR77mbfKFX0VSzfkAfyq5o1pDB4itor9xDAGy7PwABXr3hb4R2vhPXodeute86C0WQtGbXYG3Iy8tvOPveleefEnT0l1T7dYMHtQuGx2Nd1RRTUL2vod1CUZUJWXvR2/ryPW9N1DSdYspY9Ku4Z4rcASeW2dmc4z9cH8q8W+IM6LrZhiYE7QWI7Vj+G9dvPD+pG7tQ0kLLsuYgcB4yeRnBwfQ9j6jIPTeItc8J6zYTx6N4V1Ge+IUtqVxcsGi5Bx5aZUjAI5NZ08LGlU5r6I4J1Hbmkyj4K0iy1SOcXIDOrjAz2xXoraULKzlmQk4AA9smvHSwtrRJLVpIpNx3EMQQeMV2OhP4mutEmvbzVWjsFQssciK7SgZzz1HTrWc4VY4iNaDVk1o/0OulWvg6tG7SqJr81qej6Hb3LaTPf+asccbhFyfvMew/Oujs9H1mWylni1iKCUqdqMmQT2yc18522qa/rk0cSXUghhfdtTAVCe+O5OK3JvE3i6O6jsbJpZpHIVUji3MxPYAVvXUfa+2UVzd2c2Hp06VBQTd0cnq+qarfzf8TKZ2f0IAH6V3tr8QbXTPg8vhbRrEi/uHk+2zkcnLA7+BydoC89AornPHWlS6ddwGSNkDg4yKu/DAQx61cXUv3okGwH1OeaVGpCVBThovIjKXDFqKS0lf5WucxousXGg6klzGu9QR5sLHAkX0PofQ9q98sm8OeMfh/fXcQKWjI8dwJvl8h1AbknjjKtnp+tcJ49votd1nSNF2rvmmUNKBlo1ZgOP1/KqnjO207w14WtfD9tczsHme5MBkyXYhV3vjHACgDjse+TWNetB1IU7Pml2/MjG16WFxMcJduUuy2MDwZqK+FPFsesSR/azYbwsMDbhMWRl++uQAN2c8+mD2brur3ni3xHPqc2jwtc3JUNsEirwoUfxccAflVTSbjUP7Pu2srFZYbZRJMyqTsBOMnnpVnS/EeLqKOSADcwG5W6Z9q66NCk8R7We9rX8t/8AgnqYXC4Wo4qtUav5fLc9L8P+KP8AhF20Twlo8KxLdySzXrBi3myMNq4DZ2jCDgH/AOvZ8Z+N9R8OX1pYWUKXN9cnhOpHIAGB1JJry3Wr+8s/F8U8DPBdQYRTjlTkjv35roLqG68L3en+LRC1zc21yrsZyWDD0Pp9exr2cVRjVdV4eyUdl36ixlOKrThT0jF/h+b+Z2Hj+z8ZyfDS5u9RRII1liNzEmM+WTj/ANCKVyHwogh17W20nUx5toIy5UnqADkE17p4c8c+HvH3hu9S5ZLe3lhaG7ilk27FYbT83Hr1ryKR9A+HXiSddDluNTjkjAa5cgbAf4QAvJ9W756DFfOxpzxNB8t207NtWszjkq9OlKpTg5NLZde3keo+Jba1XwbeeHtGtbe2ilt3hjiijAVd3U49eSc+teaN4Z13wV8P7+abVoYrdCWRWttzb3wu1Tu7nHY45OOtamkfEzQpb2N7ufykB53ZOP0rO+KHie28dfYNL8PyGe3gJklZQRl24A59AD+dcOHybHurJTacZO72d7dNdj57De1xr/2tcqv8LS6HmF/Cp0axWEnG+R2LHJLHaCfyUVueGdSa4ubbRbmULa3DeSWPVQ3H9a2tf8Iv4f8AC9h9r4d1c/Nx3/8Ar1wKM1veI6nKqwIYdq7pQ54yp31Vz62GLw8q3KtL2T7HT6ZdaZ4Zvr2wuLrIWX5ZNpO4Y9gatr49Tw7qiX+jxw3N1tOx5AdqZGORxnr0rBTQo9V05dUF8FZp2heMR52YVSpJz/Flsf7h/Dp9G+HugXfg/XNRu9RvX1GziZraKAoiM2wldwIJIyOxFOVCm6fPWlp16K+35mdZ2qOFNadPQ3viTMnijxDb6TpFsbp7SN5biSPJEWR8oJ6ZOK43wJpGsXk1xqFtbIbGJvLnkaZE2HGcYYgnqOgr6D8L6BZAXs9oqlpmAdl5zgYFfPT6Jqtt8U7nw9aRuLma9KeWR/Cfmz9Npz9K8zIpc9P2UotQS0fd31/H8DnU5YNWobq7+89P0yx8KxXS6rqVs02p26kQsrsRjB4wDjPJ5P8ASvN/GMulzLc3eoo51i4UGCOFiI4hnaBzngAZ9yT0zx6fqvh2bw3p7zXA3qiklu1eJ30p8Ra01w+EjACKB3HP+Nd9DL6dTFOrCq29Fvsl08l3HGXPU9rOC52rX7HS/CrxfpfhO51JNYg3W19GsbMQSABuyMD13VR03QLBfEMOpWkxk0qG4EqE9wpzj9MV6H4J8D+F9Q0m6k8QKPs8cbOzmUoEUAknI9MZqXx74EtfBXhIR6VJPJaxoxLzEFiSckkgAd/SuvN4Qou1Cd72T+f9aHTS5IyUJpadTjvEOqaR4j8Z2+p3LBWVl3kHAODxmvcX0LQNZ8HPBd7ZbKdOcNjOD2P1FfMGkQaXfOTqOsJp6A/eaJpD+SjNdFqXj9tJ0qHQNBvDe2cCEfbJYTHvLMWOEPIAzjn8q4oRrUv3dG7e2t7etwzCMJ006bSf6Eur6XaWOqzWukubewgheaZgS2ML8oye7MQoz3cdqyNO0rXWhgubjTrn7PdZ8mfyzsfBwefY1e8HLc+JILzS03CaeSN55SfvKM4GOwHJ96+g9U8V+H/D82neFYYw88kShE6LChyAzE9yQeOvrjjOqxCw9OVNzvKKuysHiq0ZwhB81uh8t+JfD15o1ykksDrDMNytjgHuK7D4b2f9maPd63eIUikcCEvxuCZyR7ZOPwNd38Vr/RLDw7HHPLHPNI37qGN8M+CM84OOO5H+FYejrD4ot7a6vgkWnbPLtrZQVEoXjYo/ug9T35Gc5IjKcbUxFDnqx5XqvUyngIY91faTUIrXzd+iRyvjLxFq3j25t2EXlabACkRx9/nlvfnj8K2tB8J+HU0GWO9t5pZ5M5k84qw9hgY/SrXi+4S0dpXYFyMkk9a5TSvHD21wNkUTMCCu8Z/Su+LoyjyNfMMNg6UZRpfizXtLCz0W3vbS0jumtbtVEqyyBvunKsCFGCDXKQeJbzQNWu4opFntZB5cidA4xwc9iM12/i74i39x4RNrO0K3N38saIoDLH3cjsD0Hrz6V5lpNzbWsz/arOG5DKQqzFwAfX5SKeCy6OJrOjUqLln32OnHyWHkqcUuaPVa/p+h3XwY8XanoPib+z4AJbG75miYdCAcMD2rqPGFyukfGuw8WWyHa6obhWOQG2GM4/4Bt/GvM/AviC28Pa2bm6TMRXk9xjNdrcavbeL9FudYTKz25V7i3zkxqCMn6AAnPoD6GpjWo0asVXT5JOza6X0ucNGPNON/69T0Lx54ptbrwpeNGVbMLY5r5/GmXWo6la2emqWmmlWONenJPUnsB3PYVu61rsM2nTwI64ZOFHer/gHVobjxhYlkRNiytn/tk9dOXvL8Jh8Y53k2rxk1bVJv5a29UetmOV0qdaNOlUTt0O71TR4dB8BalZ3uswRyvbPGZnRgpJGOignvjgGvOtY+Ies6v4WbRdS121uolXarQWr+ZIM5wzMFAHuASf1rV+J+rC6sxAkgIJGQPYiuJtvBmsXXho69HEn2Q7vLUt88oU4YqB2BB64zjjNeFhFTqUva1nu9L+Wx5+NSoTSfYnj8IFvBEniSS8WMA4SFlA3fNt4Of6VzFdBpf2vxdr+kaLcXaQW8kyW6dFSJSQDjPU46AnJOB3rvfifpnhXwjFHp2k6Tb+ey43yMzuOepJNbPFToVY0anvSm21a2iOB3WpwHhHxHL4Y16K+Qbo/uyr6rXq/j6TQtY0mDxPpt6E1VLcKVVgQ4ByDg9xmvDkLsx2ICfTaDQZpXVY9zEDgLXTLDU5VHUtq1Y2pTdKftIOzNnRxB4l8U2Vv4g1n7FazvslvJFyIxg4HoATgZPAzk8A11XjHU7PSZoYPD93LPHbxrGs7gDhcAAKBgAD6knJJJJrgZI3vL/wAu3to0eRgqwwMWXPTgkk/rXfeGvDM1pGv9uWVxCgfPEbP8v/Ac1rz04Ll0XkROUm+eV2znLRPEPjS8MEaS3TIu5ykfCL6nFd1ongDwlbWm/XNQP2nPKGXYF/KvXbbxP4E8E+HHnXUbWMsm7yQT50p7AJ97qeuMV8tXst74j1S5vFiPztuKg8KOwrgxVGpX0p1OSPVr/M2pynUmlGPMz1G60n4aaLY3F/HdLc3cSloYDMzbm7V4/d3T3d09w4AZjnA6Cnw2TvepbynywWAZsZwPWusi0bQ4Exvlc/33FKlGOD1lOU5PruXU9pNWatY//9k=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAAB+5klEQVR4AbW9B5wcR5U//jpOzrOzeVe7ylmyJEtyzjmCMZhkg8npwBwcB0cycBzBHOYAkxzIyQnnbMuWJVk5S6tdbc47OXXu/n+rVyvtSjLn+30+/9JotmemurrqvVevXr1U3PvOff9569e87cvXy1q2e9emQnFieKBnsPfInu2b9u+jXWU6bbn9flqyjgSLBJOMXrr3PbSvctqKM7785IM0ey7FFlNAoAgRRyQSGURqPznjVHyQ8t13+OatrmmNtq9fFK9NbNnXfdPFywWiMFFuRkvsw9EJrS0pW47j/sLxtlLu2VEc7e7e9fLEvm7rdTNwcOIa6jzlPjrn6qZPfO769nmpYCAoCpzH65Fkr8AJkiMRN5b8/h2UIuKJJJqTaP3MOV9t9c9uo5RMWq68xRo+uPFPvzryhn50K/VmqW9m63/+8Q3Xffo7Am/377v2led6x/rIqFI5R2qBbI04nkQveSPEcaQDbhpV8iQGasPLzl/gC/jKwzmtXLE1kzM53uJsnWzA5k3K0haK2qyT5JAdpMZ1tO/FN6k67evrLiZ/FOMiP5FMZBJpRECct4YED0XnUkPqat8irxT1BaNcWNA+fuXtuHuxC/1TERCSHaBQwGiIbHIq1XJmfLycyVYVXXG4nEdVqDTt4ScuvQYnGjYZhmNoti3anGg5FqDCc+TnQ1R06SLAhmZhdFWDFy1ONB3esHktlx1SC7pWoEKWsieaPHb1+x8+euNnfsmRJ5I8vyHeq49SRSFFI6dEluISnJ+9czKJDnEGg4C4opEaZwdsS9eqOfTDcniHl0XZJ4c9wZRGA6c8hOjqD1MqTn6ORJFsmfggfe7b9INbqTJM6X00uI/G9rKmv3XKrfEwg7vl0j6QOwn9AsDnI8tHze8gbc94wNukaOXdm3vec/NHFUoniK4h6nLxNHPADf92z8jb1weSYVOSSOJ1UenODHRX8xNj2WJGq5ZrhhUSTukC+6Jc4JSKqVYMUVREQRKAREfkMRaHc0AIEwz0k9ShhiualjfUvOHz8rzKV/tGundOjNLYKKP90imtPzVI5XQlUZOKpr7YPPsfvJ6vlikQoCMlyqbJNsmrkQm4eQmPQxH8JH7s7p/S3T/d/ptf1s0XJUvlTZXndI9EiUiyqWGkYcAenvmY9RfQxWclQjxJoilKFY9ATVybtt3MvFrSy8Vcv54ZoR46LeLonUvpV89RopEAdBACMIExqERVIsWgt0fwpFuOP81DkTNp1Zl86hNLl1T6R67P/eFhooeO/0zD93/pp/eLi+vmeOriwtkr6NwzhirjPUq5mBnNVXNFjavkKHSi+rSrYk4r5rVyuQoGKsmiYzseEIMj20AYQD/oTk/0T6RxLT2WH0ry4RrZLwnVgc7tPR193Uepp/c0LHHyCe85s/2Bzd3JmjiZvOQh2aRojOavoL5hKhdJwoTgye8nXiKeJ1NiTJiV1R/66O7bPiVcoMgG57PKFs83Ruqruv/Cy0LpYqWs6IYJrmTV1QUXLQ0GSl6/XRL4gl9I1ph16T+XzYPV0oShVK1qhQyFMkQvTrY78737IF3SRM86DAEgf4yx7EK/WKENf5hR9cxFDQ11889qXrG6oclz6UV6wHf25suWPLfhoafunVbvLjJbRw9HRkncvSkW/mQjVcZNXS9mC1qhqvpLGba+nKbks5XsSCUe523V6/HIFLQNXbRAlYIZ8HhJAWW6M0BhfGMo1xPl5JTsDwjl3a9sPLqPMIph4OlNyrO99MPPXPjlX39HrxQcgziLRA7ESuvOpd076Mhe0jRSoiSIeByZmAHH20k/15dcboseyWebgs1luMjC1csSybnjRUXXdTBZQ60M9B3pO3QkM6AHQt45awOeMpnDjj6sqSVFMxzN4EDIZZ12HG/0dBcv7CdzCQVdBIBTAUjpftr68oyq7S11c2a3L5rV1pRqNhpruYgo+5fEGkSagQDc0jd1W2x8jJfsjGNgMSiZSsWGgMDo+TRFM9RiJVcoG5wUNAysJKKPvGBAomhIHLi1uwbgVvdVMtJFLa6YeUfP9x6m/qM0UWE4+idl37a+amabqdmWRUxEcNi77GECyM69hDXGBvmLJMpkYVk+0dDwqPykJNYJfIrbdHQkG63T+np2bD586Ej3vr5RcInp5VePsE+Pf86byMb1vK9a5koVTlWlStWcsOgkroWasxfF37t6zqGugxNm+e67ybyW2udRJEiBCAU4yvVQBWx+WjnnjKa5i5fNa1zij7WoYdkXF7h4mJ+74j8uo28/N63eictcX+++ZKDCmaQUS5ZKYo508rkz7USlyatS1ewZ3WOH/fFK2OuVQxEhFJICQcEnapadb+JpEPdBNsA84KhPP+Kv6q2qqBx5fPvvqN/lmWjHS7SC6P3XUrKZqliTM7R5Hx0Yojxu7SWlb5eSk4wqSJcsnTidBJ1ifprTQjv7KZ9hcBf9JBhTCHgPe1a2tD9ijsi7zcPjdrF/tHO8SodcaIJOT1u+/t/qF85xaiW/qAQDijegWJalfoVGXOKZccfv/v73e35w5y61XLJJ3080l7oiBAg1SNQog1sSg9W0smiOPmf+rEA8RXLQUY9wQoh4LUDcir8S3XR6BlfQRhMJclTiQVkWBUXyxfKnZdVYAwfHM5o3E1XJH6CIQxGBEgJEINLM5quW0Ho//XmYtoikSOTx5kK20Jzr/ux5hd5pPcQlwNI/SDmVwB8UhTweauQJ4tVl51O+c8JUfIbumLoBcRNsGRUwD5YvIq4m9dSOcdwerpKnSph9tJColWicJsaF4bGMkg6SJZLXTyGO6oqMDgBRLJWnFnAPfaPccsMVYo1opSrljK0MYnb+A0xleuUmPrysac0FZ17fOdSTU/rZClB2GZBMBYiwAapfTiMX0ejGEzcFGzf5G78heULcxNH0n86u/dcbvEEga4EaJfoJ0f1EmMszp0K5ncyzidddwKhkKtSCTv+SUotXKCP9nGPbjkkQdxzHE6jmq5AvqWJQjKdwEzXOpaZA2GfPjSrn3nT+j88517nBT5EQ40b5/IiaGblv0arcid6xK7QNCQJSplikqkWaQbxDoSDdegX/vg+8r6//iGUYpGccVdGrKqCvV0lRqbOLBvzvv/HixalApXPPX17q2ygC+kl32Qc/Hy8oWZGkGAlBRhSiwh5jF0GpTDjG804quLGWVoauupxvCRr5jFeP7n39fg9olU2sY9MGV4maqCfgb2pti0cS/ZjE4FBo0cuo3vCRhyiWoNmLaXRa61ywyPsErNLZv9xT2kk14qO4Jqqz8Taf6DyiOHZi7mvqLrmVQmuZZAzRogKhpkqY/r6HsNYZ0WjUMnWR5w1Ht6w85yfNS1VwAC+FQ1TTRvNmUQNdKtjrxcqZ+fofa36aUOjVr3P9RxJLb35y1uUrHf00CzrQg/5gr4COyrgWiQvQtW+/Ac/lOC/He2xbskwTXMHUGAJslfb3C5XYwEs9WdwToNW+QBNDQNiVCA9SdRwyUxPVLaBYXZ2XC5om3zZqDw1X+rogjRnb3QVzarzs7/vopjOe/17NJe3Hv3z9/bckSS0TtnFsDQuw7SQtWDhfEoT5C5a1N80f1AZHchOMtADBBOk86zp2mS3XUeAT9NyvGOK8MeJiZPqa9i6p39JJmbNonZfwDI5GMbOSAqWvcKctJuAf6PhWt7GZGhZQNUBKwIULMYH+jMfp9RvM+qDFc5wk8JqVtsKmliDFTxUwQ5v8HgrWUROd4ad3e6zzZX+iv+UCB2tj+MferXTk9cyWrW//+tW7k8uvUvc8dXyYuPATkyNEg/FOD0AvEBekle9YEw7OrSoFwQlxgLuiaFWuWCiVCpRP04791G+t5sa1KiNmrsA4iyiiFUBjizuQM5dRoJ1SK2vr6lvDUtSxxYZRqXawEoj2Rfom+jpzoN3jpZno3EfunA59tBOmgWby5NxNNBAQcrf0s5vrcVcsEmtK1ctd7r52zF3i8Gy3RIjqvdT8AUK9gRGKBoiPkZ49urWTzbzDTUzq2O2SG7gXBsywOodoCTG0dE62QS1JqvVSycuWz7LLBKuYZusw2/p1E1guKaateEjlyEEraHec1BzxKhWAqCBE9qToRNBwUDjXsYkzF9gJQjeLTkYrTyx422fq9zw1dOxR7E/cJVzMb79IwQhBmm1obVz/wc/megdkLK1S1bYrispXFLtQoLEhuv8wIwt3EHiee8n4gAQOxnY3uARPOHM9RedTfEldNJ6KCHG2YZ6QQ/6imi4YWUzrGWywhihybRtr0y0m0VcuvG4B1R6hUcAIDQIBXhfOYYM1b3J6qdLbN4DHu8vE1S7mAUeXmqIYz3Lib6bGHqqXsHusP3TfOaNn0f4wTdwKKJDBMUKpdSuze1DwGDxgqsR9bNFCQTXgACAHGjC5KadUcsrcKI16SEEv8Zt6bE0r19GRbnpjNp11yxuRoCZwpsCJEjVJPvKJFTHBKvKhoGgUam+Y1/L18BDD27ECooniJVCdn2qTgWgyMe9z39YLEva5HOexHI+mCRA58kUzl6bdDProS737YJATCnCAnnr5P09CH9/EyWkiB6NPRfiEn48ExEjYG/f7oaoih1P1jHvf9DfnaDdGNFke+dtvv//K4yVKS1PTM+CyID8wUckzoKgjAyP70z1udQzkMNEQu8ZPLtwIGoXELMaRm9rBuEtDCUrfQNbV5MRpXKVuV+ZPH+8t7uTdl9se3qL4xLGmJlubbJZzBws5Qs/TQp1kkFD+GPTZfaNsAvUfpqE0WHyHw2fRG5M8ElNz1QMgGB3v8YIQg0khwSbdiQJwhoBgiWo9VJ9oSLQvET11nMFxluDYvIUFGC/wf4NtTnew+1IuC9dcyRgUibbRUywcx0uMvLMpOLspVDdblmt4CglMoKvo/PDeA0f/djB7vOLkBVr63vzFTUSXfPLd1Y995uZ33obvoV/yumDB+PECjQIfyuFnRgceevT5b/3+vs4TjdznboJXUTmI6ZKE3kahMV8rVCBs5XjyoJSJkBVkWCmXqOsNl6Q9NNpAbfVuG7Y7xdB9YBi8BuOz2LPwYsNyx4ohCnsZmlAFPVmZiy0Xcv9zogfuVZF2/4qebqRFt3+6OfKKaT8oiUOShalVFzuH6C6Kp5rCsZTjiZ2/6AN9Bwc6aALAAyxrXOGlKUB10Ugo3ixGWuz+CsRY0r22ppuKqFZ5e5QzsuJvD+FBgBObTi79oNO4QE/RL+80BKCXcQpE62S5QRQDomjykKGK2169/+n/3nlSr9nHgqs1QTNdv3340a19kzXuJ3qbCyuAAMVx30c6qanlJvdy2ls/0SNM09a7lnrlgsVkYiY89Si0I09WmRzTjyWsXKGhCaI9RJuJqThM6vkg1b6HfKDqDiqWKcgxKW4xUZtOxTxBq1EQqL9A/b00PkG1rzBkRNh6j2oxjxW9k0afI2XjtI6AVf3x8+Qv0RVnPbR+fb0mXDucJbm2PXxNKkrjZyxf4RE9O7YfKCUzIaptIGw0GfTrXDR4sdzlK3YmbQnRUn68avI5XtDMgDo6W1e6Ovy19z7f64J7cNoDAbM4Xp9fcsmSFXPFEz+USRISDh+2OIdE3eB6Cs7Ar+596WcbWBWMARCfXkBfeWLLVEZVs6PHEIAKD7viQdglOkApBClo+m3TrzEfNlMmSjtTxqhjBCqEZvI58uk0V+flakzDVlIh4wDRg5hHU3f+iMZ+xK4BhXcQXUkNQTqjk674zgc/9dwkwqcq4u+we40pFWUvqGR07PyuIXucuo9Mq4bLX3+Dnif67rtHF93162JjC1At0ZULa37bFFjYta1v/183DXV3YOHGuEC9aA1D0zD38ljJTV9e40TFyOc1LWyogl31OCNNrZl3dO7e5KoX7ZmPMn634muX7foEOms889I0BBhk2eQqMGyOK6jUkc0d/Jk7VHQH9HpSASFgMuJVACrArKaVsrsATn6xxF05p/048xKU0UPFIkFyyI3RSB9ZpqsmFGVZD3FmAIpjiCsnoD/t7gl3hpl05jglBmnnllOgP1mXc2c7qM5hrApbTNEkZy3RSQhA5V6iHX+ieZ8nrW4zgBGhQv1SynUVO5y9/Uf2j2SOlNlixBZ+PArDN9Avi1RmWtHxR+QMW3F0RVBVQVUc0zzaduF59PK0Hk9d3rH7k2/n7jprwR117R3TECDSqJypkY82e2Hpev7AuP2rr7E71p/9+c2v3zV174m/6AF6gzHliGbFoDQ58dP0q69ePH/Nhz92bck6um3Po8++1DMydABImywiJXdRQybgkXTNNPITVMiTXyLLT1ZL2BFDvB0TFUccqALFpy2vMFPBo/i1xxUsT1sHpArog2whxaHDAB0Ui7HTViX6FdEFj1G48SlDIF+BkkH68SNfFf3+iRJonZEB0IkCkp5EADhkrkTBLCxeeZPSWoUvVz3Vqjg+ms/0SXfSBqLlLgN1b5t6S7MdevcvD38Kksg0BNTRUIziocEI9QwQ3X0b0dPsjvsf+cyC1GkQUHHHDHLIgsNiU/8m5fzv3uOZ2xbi5TOuuenmT3ykkhl7fvOLL+zZNVEow/ojSJJU4mEOMi09oBYSVAqQELLlqCJygi4roq8S8GSrLuBOPCDMlEkMFiNEO91ZCDp4s4IeAgF4QTUJ9TtsXKBdDBstdJ7uHv9GCmN7WKHsM/TyXmYL8paqJRfimOZ4hdwVJeiuWNhVKDA6ZvKWMeLo/ZWclctKWIoOq5kXqNui1073hBnfTUPAxdQSp6BsbCgw6Zi2s3qvji+sRP7r6z987zf/9Q8z7nM5YNadjBGwxq7MSb9OflyKlb6mVudhcfU7fFGQJZ/f31Jb297cFggqpokNDy+KgizDIMWJgiHYOQ/lPRw4dTVbNWFd0VTVh73StNbnEX0sSEKSumton019aSqUUHtajWmXjc1xeyAL6ANcGtszsS26Rjb0LrWnIAAwBbl6IOhsoD6TniLa5QoauHkNUct8+eyLro9Fgh5HL/R1Kvt2OSUDjYIFFfK2WilypXRuTBw1sQOv7qTuw3RwWkdoQWsg1eD1B9XSUXq9u3L8J3HNomUf+M4n5szqfKbprtogjWJzaFKNlzquZbvJ2ppOrM1nXzXnu5EP/fuHf3P8tskLECYWIjS2wznR4vQ6WOwt4qEFc2zY2gwO+inLhBFXBuVDyoLYLgheryccDMAqHvRbQU5OVClsKlau0qUXNa1o63bImqEmuhDLLyRUCGxJJhpEfAyc6TdDQF19YSDrZxIBTOKYpo4rgFvgS7i33V2rMIoEUbMrO+AbUPtrJmOoeJWnBrPy3fEv3/FLww5jppZz2bHO5pzoqY70G0N9psqUcYatCpW8YnqKxGWp2AURbap4iNYuamhfI/t9NjqgNniPdFcujSz/U2EPqojbDu7dduPHcHXzB+nKeyHFstEq9fTRe6GfAtcTS9RhN2QXnR+/7/e3btlY+NUvH51qmUlBeHUf/3zKRQ1JDix/MLtaqlMoapm8XinqFZ2zCTQPm5zs8YXD/sbaaCggNqeEVDAh5oNOPmvvKyXSfb5uuy9PI6UZvGIZVvUG0pqotoXpFbCk5gxKx6j08imPh+y/4ozebcMNVI4TtrdBqJ8zJFSZkRzbj8paqnrIqaPQcmpuprjk9Qlrmh947Rf7Xe6KSV3AhMDjLqKuudlea/jsRedDpVzMp5PJxERILgz0ju98vdzdk8vZnKZz+a5xKnfQcAep4+4m9JKG1vpF0XnnhqTkqGKPmbZaVA0hTy3n0J827vE3c+9edfYJFnRBK81219Wou8iA2aFgtjqOYNsK78mE63pWrAp/+YvnpMeVIwdHN2wdAjlNltDpdKX4yaGoM9BLhQCvC06hoGfGCtVCYXRMKRV0w+IEWOt4SeaDoUIqJDUmIrys6xN5c3icf3XAv80GrNtciXuBa5ePwXQK+XkVGeeTmKL5bTSrjqC3gfbgcD317afI6x/FnIJW2IHFD6pny25LxObEdguF6lFbfYypzuLwRrDZOhzA/tZLIT9FeVpgBs9PnrUqeFZMXzVy9LVfYFqjmNDSz6WaG9izPDG6f99/lRz+koVXxmMpS88HG2tMoWKlk4XMeCkDJog7qjp173S7+vm5ocs+f4XUwCmOUqYjZWNI12DXZW1mY7T0Mjr3avrxvzu/Gdh4AgFzV0dEKnvICjOHCWAa4INgxXMViauQCFbnHU7EK1yTkwzJCW9TS21k8MhIZ09uQKeWQHOugoWY3eiamm2erADb6nmdnQfsALiQZeYq+Yl8WsuPZYfSWSUXEkSfaPOBMPkCmuSTSRlzrLFdxrO9zi4Se9gcfo7oDXeZdQHC3v6M/zvc1/GvWl0UzSJunOqP/FLkPCIX52BZlTwS/Elk+WAOdDzWRCv9hE1FpUqaxSRIcCEpCE0PiVDKDZbNWd0hLkXDr04aitgKP38xNd/ot5sNw2OAW4pmZcOBe7Z1/uHaZbeHbV+m0l9QR8sw/ctVWJmgagZbAzfD+8NfPXvd9e05Y2iiMsEZVdsA7Ss6TMEGlQwqQhozSTXomm/SE1+fJgVFWsEqAXRICNBkaDa7Bg1ZtqNzlgSy4XlOkvVAQISUake9sGP5TSUV8f9l61AqFhBUQ2eKFMh7DmYP7LFY0wI+v5XJ2gXZNjW9VKqmi6pa0tKFQwc6DulGsia4dPW8SDSmS6F8xShXy8obmaOPMz3/g1Or33E4n/YCYAoFSAXVZNlWZWQIfQb5jpxUOUWXYapkKQcB1AZXhH2b6Wtt+EcBaDkqj9FET/9Axd82sPfFlLuqoYWV631CMqn4y7ZgGJYGCBhmSTeNNzqeaPe1VfPjlUq2pFcUx1KBANdLqkj0qfXJRStErdqtW1lDL+iWoqGOaxED0FWgQSWNY73Epv3sb0AumCoNixuwF+FZn6DSY2QCHGDZ5A1DcmTo03lZhYTIG76ARwhL3rq4x2qIJKIxIGDxEqUv4tct0VA5QeP9jAVwYS/fFPaVJzIyZpNhmIrq5EqCVbQr5ZdBDFCFjZb3P7GTnpjqwf/x7yqieevJs5AUkUaydNhkO7bTlVYfmUUqgtjhnaZTQSfTcDdlOoUK5BmmXCd1PqM/6uz1NNGfzwDTb6JF51Hr6kVmnVzxaKpTTStj+Yqp58sVs3x05I0Rc7+A5VhRqrlMXqWyQ6YA9LBVPjI73b/zNb6WK8hW3mE7NVTIVyhdYWv1uEITDpWh2fWRVEeeOdUTCDBoB6gXpgjMTQyDx1KFxR3vGiRymzNhyrcFgef9EifCsgdjj+j3+uFX8L1PQiAZNZwa3RDhZODh5ZAoe0Qh4fG2efw+SZRh/IdtlTy+aLSm1rv6lvU3SeK1139sX0/pdPD659/5wNiupniTjxZe7jQsUOTGjC6oIxP0Yp4e6zvtvdVR6mlLtNQtrxfHxo1Dlm6DKeGFUp68AZibRB4geA6ElgupfnG0cX6TWN+aF4yCPtw9rB8Y6i1m4cDCNp9Z2LyYQEdGkeCAB+YLDg2irofsdADafxt6koqPigKBKxSwyQfaVcagsjZlfaRHqCJT2wrSsC9/9r3UWEvWzZi8bHfHkWk6RaPELJGYpRxs3HAYs8uc4YGilcCEJBMOLZxX88tGpLYqR/l3rKA9e7Te4UE9LwtmQyLQlIzF/bK3KRRrkVKimDSZGIRdbyBy9SorDJQPhDPdf7/3SwNj2qW33DkJgrfwvhgDbKDZ88luoWwCixmXqYuWE41h8iTbE1E1P/DYC5NgPamxCY0mBjKFBaG6ZW2LKOzQgDk+eFKdYx/riJZyNCfoj4frQ61rpYbrwqJq2z1i+e7dw91FLBc6KJIt0BDWwanNMukgbTAWl3GFiPZ3sd0aCBzzsgKGaFPRpoJNVZtplxTY2+vorHNpzhrqhh0fcEldx1RLMJACMMAuLJzQX6uQZqHnA0KAA3cfz9ma4Lq5gIEKIGgsnyFdiip82BMKhIKNJYIdUdclLRMKNSYTgbA/WBep8cuNDtfg8JLuFbllLUKyznbycrViw2injAvmxBfev+QHv9t/emCc/O18WD5iVMfRGMZbVUpKeoKMXEBOct6oR0g0xIseKgA4py3Y2HYPdK2LJ2vjyVw5/2YIWDCLvFls2LA79An+Nq9nHuztjiDzJVUZIy3PrJiACezvAAbgY7IdABmo5CoqgIYJ0C6q8KSC1YAFufIh6MLG6owXoFmldSvpUIk5bKE1MXGYTY1CJ43vgQYGpjgqj5CcZvVEnnistVDKwyEEUptsYC9PvCHyjizpwXBVhrwHHkOzIk370o2suXimFI8V5rdHw5FoKDWfAgur/FzTw+tJrzfCKVqvTxsSJ45q40eU8cNKdqJSPnBaeJ3y5ftaaS0Iy6CRA7S1g7aD1sZeo5ZG8q6NmPE5kq95ueptkfs7QURvUvbu3IEXIzffm9TAdpejahu8UWTRDnmlOnBjB4JTetvWR7aP76MiwA2nBbiiwq8NOg137QXJKhzbjYKfjrpcBHSLZbnsCkUnnoRvLQo00KfuocFBCsDqB0UyEDD6NebH2ePOoJx7f8JtC5PR624RIRWI55MwhzzLbCfpcQICXCnJw4uO130ucDUGC3+nRVWH6iRaLu0P+WeHwpw3xRmxCA+rM7ibzVf7ewP5nbY6rGT3pUd2dB0+2DOu79l6oodvduWl6y6gj2SZ+9NQP72kTCpJXHXmRS9T9aNeIzbLE18VD4QvO+fZzpferJmp7/Pu7nHq04m/Ar2zFU5dpIdhzLI1paxlOxXJ0/3MFw+/sXHns5QdIRWECP/iGvICNJD2LNI5MgAN0KXGJsG4qxrAQnJqmZWkBUtoxyD99JPMMR0uMkbepfKfuo60uA66rl6gLNXd/oHNoNk4MzsIqQ1nORvClUu85csVu6Zke6GBzgtcVuHLfJhpx7vgbXKEJgZpNEttOWoX/9FQ01oHkShpOM6oowtmVhDG4BL2mmr05tNbdvRNvHKQOvppU/HUrrJvFrXSWesXN7fOD/gbG4du2f2r9S/ShjTlFaahOVYw08fHqOoVhHC97D1DCNXf+oU/22Pd97zFSTXVzuTfGot6JiA9lGBZq4foX8pWdv2xt2fn9ldKA4M00MV8LPgKhQWqQYhD7TJe9MPlRFWyealfL8LXGqyK4eDU8i9X0d1PUW+ael9hII1k2DKEBXwccwTEvddVZ4JGBfdW1ADogQzgGDMVvlAirRfpehtKl6M5PbddCe2HgdiolPNGGXMQ8l05S0eOUn6AxVmMpOmoSl0e0nN9HvPVyIQjcjnHCFp5vzQyxud7TLjdjU8c7qWN+2coGI73e/UZnrOubrv1I9fU184VhTAcN60u/45fgSPCKT/PGPC0AloxeEEWAh7eZ1Eyfub8a2/vvueOaTXe8iWYdQ6WRIkDQ9e5kqpz3FB1sKsEt/JigbFyPIsBxySsz/WpeSSFLEsvldO24fgCPWBKM7vGHnzHdXTuVdd9+mOP4ToGqHopjkgI2VcqKnBxmCzibndhAB3XuaAHJiabEukMlVp4emeAboTXBRYPB+wvvXy85hclszSWzqYNyluM8XWZtKuDSq8dU8k/P0LOYWqL0fq2rjPrupLRVpFPSUaN2G9oBzcO5pT7Vfr9saef5s8vX756TjjMUcBgMnQVuorwXK9FywepaDJD/owConGwuvEw4mKXm3Pi5abr6L476IMzar2lDyDHPk3xy1TDcc1QQMrFoXQRMwxWT/jxAPouvVKwTE1zVp57xW2BcC2iKTJjg12HNuulPxXhlZ+hn//L0gvf9526tgXReG3X7u3vv/iyvz/22Jr2+ZenEmJANh2ngilTyOVHuzMYnFvEM10dN0NAE/HzmHY7t4VNAjjw+skfIV+C+bwwK1U4RV6zRSinTC4Ay8kAHItylFHoQJ46Oo5BH22CM2yr0nCVuCGqqcfGpE8I9Ely0q6ouRHlYfpn0E8spGgYtm04raYhvMLRFkIXIkLyjFuij3jNKFFwy52va7w50viMo27j9g9qr/2zjR0QFnfHiwGi3bxLtVO0yITAvSVKDTkrZlHEQ8USkzhlgY0ftI9qwAHwvGPjTs15VnXEXDazb9f2nVsPVqY69Ym799Hd1+ETFtiVlGhtWDF/jjdam5S8EnZ/pm3AW1TPm4MVOOweK+K//JwKHKnAB/wPIFdVYYij/CPo35ifxXJ14aXTHG89Cdi8QezSPTYnmRB+oXUdp3yRClh6sBJPK2ATaA8jVLOktDCxwaoJKo3NQ+fJ7aJ1t7BIE5u/+PXvTLvj2GXTjWC123EjR9CpydjAo6my5e2jT4doXo5udzX2rxE9D4bR6OrLCp8kof0NroFRQGUvEyheP7Vd9xuf68cAmcLrclesdvjmTzMr49FbCnRWjvlawcMQH+FWLnuZ9JhzR5Qh+uuG0b9u+J+Z9538CSiBmMp5fE4gAJ0j0zyZjmA4FgNX8Tj0cZvIn0OyziI3IOJh3wtuBwNI3yP4aRB6ZJk6w3jJtSExBL28T7cMHTsxL1N9wMIE32uFLU0nlRpXfMIIsdZji4jQHK5iesbLijY0IQqZTOHnW3930i2TH6Nns7WODZthELORUaUt7AeJJJxZfpql0jo/3SYyU19nnO4eoF4JAO0mfzfjnAVXNDqlO6xtkDymD9Y29ApiC0AfcdWWp3ajBCEQC47GpiFYGwgBTgqgA/Tq/1RUxMLoJm/aUKeZjuWYBv5pelU3ZnRQLM0j7MwBSkwu2BZshao+yl1OuWcdH3UX6XUdFGPLNZVmLt8aEypVn0f1Bi3N66iq465NXHFGx5pcX+uEO05MrNwAebIghsGxMdpeYQvvo6dx8z3WQsNVtM0FE2Bku9IBOtuCdf1CZniBBAJdq1EIKuMXGLlZPcNbs9QLuKMyoAmYai6dyu5qCXihBbxQAi7cW6fIArfgm/b6wAMjM2BxrBPAbT8lw5T0wopBDva6OUb+/9eC2EhEQYVFWRM9llfVTBXRO9ViCcqL6U2Jo+5sxxRTfaQJTEOoREh4G3X2MXJK2vsLJJRMM6U0pwtL62VRLGSgz6uCImkIHqlwDMZ4jhe/O0jAQnL5Qx60PM6oD/Q85PqwnH7Ek/d/ixmhDPdecAlcZF2YCqDf1UOm08hkZ8yISFoIHJRTHZyxFyqgydEkmeqb4QAXIfLjuaAocDLRFU3QAdaIS8VADAYrkhxofDuN/O54z6df7MhRYph55IEcu4eot8Isw//XUoCUXMmYPrAKUYIiB/ZWUzRMTKcZRezTyQPVEjbTEpkiOYiRgoI37nrzqJTuBXvfM0h9yUpT/9DyWVoqbhYc/4Tp90ArAi25LLFwSa9zDBBRl8NOznRABMMGHDFgAAPkCegfYstgJDvDyjvVof9gHBw1gTz0EsQL4OL2eWiT/7VsLHI4npcNj39CdDoF36DeOBiaYAspbqlx8b2KT7TOWgrX6jLUxKWKqRm6jUkIQSajU6VEGtoHWwM1QOmbWt4wtaWb6sDU32GiZ45SaYRgzTs4JaZP/fhW/+ZxozkKlUXI74s0hCPBBNT5arm5Yai1q7cvM96HHTToTISeCKZKwAi6C0RQOlgtPMxxntFS9NjDspTHCyaFaq6u3uPIWhmzxeE4AToJkQJeCrqRBLIrYOBW8AS844VvMD9AepNlAjusJvrwj57XlKPvvfWWqa/dv+9m74A7XgAQ4I6CXgUmGXf5Ea/ZIyCkVIBgUJU8w6JT0BJWuJGMNOOfTTW0a5xmn7GopWk2T4FCVs1PVCxFL5dyGqzctlYhs8CiKBgd4B0dW3VZK93rPuZ0b6NwvKsybI27t0yvgnGp0z+/yTUGUmFKOc32wN0/PGdOSzQcbaxJhsKCELE4VfGOjVS2vCQimjaAGeCQjtXGjRmTeYqFXYs1ng+KRZfd0kv7e6v7j5uAAZqQO5ii+w4arCc6H9tpuBevhYKS/G0NYqpJjNaJcoAPt53ZvmD+4R99+su733HzmUDL4vPOXtA2v2Po8P4XN9FviK5nhI8HllycAW2zXBf0dqJ1WD/f2Mvze+0wiY0UirjR3rArJgRxdp1HbvcHGmcvPuerH/78qisurG9q8grh8lA5M5Ap5wrp0a5KzvCOFEfzwCYbijm1MCxfc9GN512z59V93W/i0rTfpQDA8XhBE7VYIRw4/3ONtXHDMTMTReiC3qyUwRXNkilokbivqSWeTETrGmJCVDS9Dm/BJWSkcbYt5hA6DIkJVOoGSfk4qvdRqo7Ec2lbA6VBCS+dvv2Ky1IiCFQjuhgBExeJ8oIwt7Kem93KJVrI63GkJO8kbCkKNapZ6Vf3/j7+0O7/qaGvKnTQoa7e19O5jrZVi9/9g4//adU9mCYgzKw7XaJuFMyHQKT0Pd5aUi72nbXtE+ggIkk9aym8DIHoLCDC8luylBRT5/uTC9VKdPb8+fXNDfWzG73+mF2r+UV9mB+xKOPzFA0b0rUt5dmUArjQFF6caX773q8+8Iu/dzy/a7C/byDfV2axXDMKaEJwCcLnrvMr1y5YfeWNYLCvvvTiuvMv6uvtuv0jtw90HylNjFmKA+Uobgc/PF7YhGNeIDr8IcIBRAUanF/TZBNSJ9RoQtAGJ0eUPjNRM24OliNTiqProjSbbzi/bXjPPPrOESq8CQLwmFmuWH5OiBaspVhbSvDK5rgpFEZsrds0FD1bUEB4g3Aac7UUZbaRiZxF//bRlc9meze8kTOd0vDw0SKUI3e57G4xw2R6DuNdH8MlbKEwMcPS5PwEAysCZCql9pNUw5yIoZ3FBBQiDd7mlYLQOtp5UIzFfIGALxiXEjHHWy1uPaLxHba3hw+ofNSCTVvMM7iLLngwdwf3bF98xXWfvuPDP1d+5O+yA712qVgYHM2kXb73uQ/fdtHVl3U99UhltB83+VJzJ2R5CK5kgQQa+P1995974UVz2ue0tbfZarWEyAKlpKbLMAxgBqO3lvsU4A+Q9opqyFMNeoo+meexaYfR3LY54Nqo6GVNhDgPGy/zEHEowLNgwbnSVTHnXFn4s1Wzd3aCuZ69WQG2R4g2lWj8BczNYTzPA3aBR0I7AHi5SvPJ3oC0QQ5Y4cU1l/kjwfMWzLP9nX1DOZhND07sZwZ4UNqQK0Wuo8EGaprXargmCEFMa84ARoUWUMWXYfKJv5nJowhm5oUwz8cs1crBMwQiHHY7CMJDsgzOKlR6VGvActKOoGPxQBYAFjCNdQ4dc9eAsc69zWesgjDdXBefGPV7/GHNsvzerKxC2qK//e2BhReuP+eDH8mPDhcq5a17uvf3doi+4Fh2AtB45onHJ2GCpA6yxPs8gmHCw4ntnNkwXd4ACICZYxMqS4YoaBJf5TkPOseCg7HoGoqoaE5eFxGbGQDgbGiNuWavf4WnLWV91a+u4/0XL+R+s7zxV/8EAcOu+/Fhd71ocycploF6B55VDFgYJ0YCqkfBO9o5+9bbRg0Vhr75LfMXr74e/u8DpdGfvPK1bTsqjA9vdV2r3fqLG/qufbcwpx1mTLpIohdcmsLMyGB4m2iWQXIz0Ox4ErW5o5nMUGfX/sNa0SwWlBrTlHm7ON4xPPq0YeosVh32E05FO8gTEsixjqEgF8OGZx453NcNG0YO+SCUNCdmJUmRJcdB2Ckk8AK9590fZVURyxeiRHtDuC5WG6kplFGbBvIF9hM6Y1mCDZcFC5SNPTMmL26fnGT4FI9QMoKIK2hsh2CX5fS8UPaIKiL0y1w55xzo2f3lPWJCrovzfMAJBTlrNvmXcSsC5lwPrA1c0qZl8JL8X0vRhUvKFXtQHS/bfaEfQAAGg49PEC17+y1HNVOQvYGqZ36gKRSCrxSfSLXevfBPfzv33n/seKzn390ZMPm8YXr8h8ee/BuXpvyumA8Ej0PNso2i26jZoAoX3tWxpZDJjQz1jw2PDfb31jQlPR5++9P3pYd0E4okON9BtIMx3qE4IkEQ0AtXJ6Qz8SMqpj97ULE4GdvVsgo+ouqqCtc9kPCMAiNiXM4l9GJDcXBWOVBj7slsRAUNrKZcnBjsqeRH7eqEbZpwm8CuCGpLpkUBHwtQc4IScZjxMl7hgFmcsEyRL4D5qMJwVhksv3onUxqKKachSrbXy8flaoPI+zjEbMCPDzZHH8c7QxjuWyigB1AWFuQGuFHePrf1334jhRu4QMwyraMbvvT9G+43Gmf1leAnIMKmjNgXhGPAdQe+FqJXjjq+9y7914sXvv+bDXduv27vqU9Lu1+B9lGOuA6dHa7E1fo0Db3xig5vGFWrKukiZfp7j9bOSsAw1d3xUhbhRpOGQ+DANaxCfDIQwsd8zWDbhihpauWCyYlI3aNUjXJZwS6vrLqPmfbGRwMUl+2kZNRa1Gqo9covGt6F35+994mKPpiZ6KxUhqC0gNMvQCAgsBsLqs0sNqkGap5NUYSFtMIruDheKYplkrNU6aOdD9Nf++kV9ymiD66zjinaugwDs5nXhQEOfj2QRx0fzMOjk+Oe1qHTXoLGwccw9GW3nrH0N9tlJtAeK1viyYcgz9Q2YHxqFU+Rc4VSRddDmBjg44xxI6WIp0auuWblVdsv3EsvT935Jn/B9zDYUaw98GEd7+CZpxvkCsTYwHiYqapZtcLBYAsPHFhrwc51QAaPciiI2Gs/2xxDAMSOB1k0oKRill2Ik4YFpxJg4mT4g4P7QuSVOR8kMM4ScZ80zCY27TnwiLdRro+HHUXUbBNLKSy4GA5oFwiWfdS6mNpmUSTCPJcQuTSeYYrO3FE6upl+2c9UXpNFNMZ26mk+PWHu6qbfHcCznnzsge8n7S+XBDgdb9uxeariP/0bRzYIonf94sNLPvqr6RUB3I+c9wMfeFSuWlANWeYlCR702u79+1cmljDzquyFaCDaAnLfnJ0664bvX/zomhent3Da65Ep36sjbG0+VsJYaSp5ExYiuxoGL4YuAm7VZSoh8xScGDhq91Hj/BqfzZu6Va7qFc3RwKRMx7AsbJkxMxALUplq7dhfxIhGmj3RkDcck5HUyoqElaB4BOz9G1/77/tOqjv94/khuvla2rCXDu6lniOUyTCXPIZtrBAGo9QW5g6cQCSa+Nv1tsulT9y+rPEr33z3V65ZdUmWXlCeOfH9P7m6DME9DstfNb1Am5suPPC1/zr7+z8dGi+VeKxwMK+I9uh4+v77/pwVLo82xmKtkUDIFxCws+GgO7whdl33T/btfX6cHp/e0lu6LmLPnBCbZycaWhrmrKfhcbZJrmSYYaGM1QigPkoXXt1atHwwB+Zz6ihiurIFG2leKhVAp1SaFoN6/IEwTYgtIW9jSp6b4uvqjMZAUVL2/+9soWeINh+gzv00DIVtF7MlYWkBV4jItHTJvMvPvqC1tnFh4wKvHMBKeXKZuJc+cYg+EXlhyTtP/skfjrbXzvL747HamlQ8FA9HRNEXaWmduzq2ddPPZHXEGHs6O7qrq8PJjFHnXhoZoyFkRhNIFRpBechMBYZhGeWxvs6eoSMt85rbVjYnWmKpZE2A9wY9kMj0a2suP+vGbOfifZW+EtINwBFphe/c4YlxUCvSuiGfF0I6QsFQe/vsb/3n1DI91c11l6+df956OGqsjn+S8/2s8yCVnqa+ARZfhfH32fQBgVt60SVOVOrf2t3z+N80uGpDD4+tKFIJuCLDVEvH/woyNYalOS2+lW2exrDqh3tbhhlP/pfSr9J4B42N0PgITZguz3LvqBOFZa2Lz1t6Zl1jQ6CxVoT76mlaYgs8E0j23zPjx7l+6izm9xd3z/jW/YA5dWMrU2AgxQdsKNB7IRDCgkUJDpiMYUJsh1ocCcEgvuMbNgClr9rR1zE01l/Xlmyur4t6QqlI1ANZWFBlcuZE2ySv7OODkujNd9uCx4dwZSAAcRwQvP2BQBB5qE4ps+fP9oZiGueXYitaVywj/96jh+jAwAnB5vWd28696Z2D4wc3vnifjikDlm+y9RM8BXIL69vJbSL3RNjPJxLeZNDxyUikBFo+mU+dfM/k5zxsVrAJQMk/7XeZl2s90ZQ/7vNjafFBFhAf+QrlBCac3fW9KTVPo6vlCbjduZWEWbQoSfOSxN9Dna8eawx7riZX5oHk0wiHqQa21GCng3aYEQtueDrzF4MPJoCN6S8IBtwVwfIFzjIQ2oDAKreU9ypde+FyMIAsXjVh8geRRZBF/HlDfG2kNhVtCURjw4OKajNvU1GwEVWAJQ6ak9xUC8dHh/42zFlqml7EC/PynKYVH66Zd9AU7ukaov3dx2r9+mUauvVf33n9DQjghnk9DNEZ1meIfT6CbQM4wNo+szTNEpYvCMFJMe43YSLloMJhKTXeQhnoY9EuWIGmF2hm5snhQCTCh/223wejj3j9F14qK5bs1doXff/KW10At7tu+Vj2A7RyNsUbaWWQagPyy93HGvO6aRraoJmCa7mfwgitBtSw+4W90iYZBk6o2x0WgwyhGLIU7M8BD/miQsjHfM5sJ1iK+QYHplEmWATjNgxzxghz2RjV7O0ETc7IZO9DfqG+rklG+ppQ0OvzIdFYDmLmzHLNJSsHe3K8XBQDHl/A8AZrBN/qFRd+7Jq+Xzx+54mqTx2hp37wKOjm+x/ienZgY8o8MJHHrR4LQ4UOwjnlRF2sklevazszGgzKNvJzWuBUimZOZManVXnTy76jLIb3JG7VUNXbmSzuMSXRkQUH6Tgosh56KWRXaV+DR09RODy/Gml2HS1tollhmiXP8Vm8MHgE3Q25AcoLBWpsp3CM2QPgdgvoQ+ZjvqQaSRrbZ0IWhsOwxlMEbpEgNMmMhD2xWFSWvVhvK2pIDHNjlXFlWJ2UPCBtN9RG/FASVsuQx4UxKkCKnxpdqWqVuvumPp3+77LVF//lwRfhT+9BsM2s2JJlTdGwN+BdufKKFfE7d5+ErgLRR3/j/PgGYXbEQg4fJPPwiSAyCkxQmQV5sSLLH7z+imsDEcRT2ZxjcKqE3D8lNTcweHSyB5DuwKrfrAye8kMdM7KoqbKBaQRRGNPJtjWwDXg2GZDbJV8ju4V32SFSFgYoFqSYj2o8DT7Zj0wxgD4mKRAQh8ifRBYgCsDjG7CGzR3g1tyND2JwmZsIZGxmUGbowTdMJ+XATRop8SSPF5NAlGDHxJKmKNi5D7FtJbamgXA4KPGWXzZV1TSqCCYCi36LJRqWDnYeKZXyyFAFPlfMNySiAbsuJiRFnw9bomni6rQWP/uodZWHbrmEeS8jbw02FGCk9YVJBHAXXLzGF4JsZyChFyKnJdPWFUur6iW4hLhlofu+c/LDW3gHwqIAu65C8MXeg8d6YiNuGbth6KrgdRKYjWuhiWIQWnhq8lIDcnB5E7FQTDnUefCvCugCzCfh7kIRPVI7i/lJwFkI7VRBCbA+YMcPtoP0LcCVj1QYywSEcLKUMLxWCEh2wC97PB5R8sg+KRcoFmHxi07ADgBH4FAsWFPfFA8FeAfKYy1ZP+rr7t3Uw4STf17kAK1d3HjT2z7203t+1tk3Olm5eVfQsTnYQM5Y1ugJRJvn0cEjpy6wrO5TGj31JP3XmVCfs/QamIjzddJCtPryT1d1DZpk01AdTedLjqnImYn0RGF4pLcDN55D9F7XanWI6KuTT/2n76DuWa61XC8MGaWMqQiS7vEYcFBnIgojUlkGfVMwTuEgY9wxiyJIHGL7lL39L/1IySExg+vehXnUVEtNCyjRzHS7mElQrPL4DWo+2O/hwxti+RugCMRiEGilX/6EaW8QQKFX0sipgxAijrM5hJ1hYwnOBVTF2ALIe6QwUr4ka7BZ4GwznqqNxmr5wJFdB3I5dO6UEvVRbSPFE9QYp/a5df393cehj7oDE+Utb+wvltSwj69NZBIhlkwCjAPMcHrBgGexjtOXtrK8betBNkzJSmsvuqKrY5svnA7Bpg4tmurD6q9peu/IkbGJ3sIEI/pvQfoAixdpjsS83n6gnN6sg0dEXWXl+a59aT5EEm1MK0zoRd6Gs5alMR0G4sHw4j1yE/RjwAF28AXix5i3RM9rg4NPUbqLecGD+eBJy+pozgqatzLkbWhl/AobydJ4eTynTjDRE0uVbzbSJH1YSJzvqVthjf7+1qe+d2gf21f17h5tbK7THUg03hyvDQrjQwjoxPPCTMFWsEq8gGi9uB8LLsZn19bUNMQbm1rmjTzw8CZ8Mb2sXMJ4RRAiQJhi8Pfzca9s3DW9Aq67jvYIPNcQ44vxLitPtZCsYMTGD1Bz+am9ja6/PlrXfF3FsLMDI9nevq59XX3dVIbktqRm36H9ot9jmpUBo79ozZelBpvatWK2e3jbyEjPZFzoAqhURTZXNB9dKMGlzXdZX+V4H86+wH/pe6tL5xFc7aIIjcDSOMYke7uPSuGQvkinuCJGEKnLeLXlMIKEAF49YzZ1wyENO2YYkIZYnhhlJxUHmG8eYquAzBjsZXMJbufB+fPlVAOkcoDKrtbxdf2esVED8Uzeuf4V7ws03AzRU5vYYOzdBDqVRgladMyV3kO7I0vmG6o/LZvD3oyN/DwANtqVMb1gpYBMzsseJAnGIuJxvNgD8AIkRJqBgJoapufCVIMUh9nGdtccHN0zxwc/eYHdbaFUzGSynJZBEAt6Cs0uUnXKIfKEad48ampod2RH4sxgSCqFxXBKahWNffvgyFQDnqhrFQwZilTbOegRhlSxZGb1XPZoKX+MywVd5wEY5pC82S/K9Zb48bqF94wOp9ZevnRR+Lw1HXMWvFZbz0RB2MxBU1w7Uv+Qg6XZruUbklygToylsLMU4X9pO5LB5UnadvX76OGHaRSBHyNkv0qZCRKKTBQB4YBVxT3U3kTzzqKmuRFzdNgY2c8VVTRqDFO1h9RRlrEwKByS1385PedHCoLjZW9EK4dayavSZXuoNUcdXfRgV8cRQGiNqzwC+aN14CBORZVG9ME2p80jxQUsFDKCavwxPlI7C4ibVrx0/a0URepfRszsbg0RWMZQbjA/rRK7ZMLMyHBPlzkhlCsQeiAWe5jUEK+lKKS75SRH2xB6AQBCNhCSIX/FK0WMhL9+3+igaULSF2xeN5RSGRnuwDes3aUqN55GgBd+cjX+gAh2jOg8uJYvEDS4cxbM2nzt92LCWFKYkCJpywqXzSJEwSgQD9+6EHMvcLwxcCwxnBS9rQGpBuILVt9dCEpw6Bknf/cZzeRbSfdvJ+UIY0EooE48yONiOyXxTfE6Ky302OVIahhbGFhZ4brE95HewbSs2N3Avm+NkXVTWqsjPilj7+JZ7hWWBJp+eNaDX3/8h0+yNlnZ5r4mr4GGNoaGg+OdcxpbksmAxIVkIQjRyxcMBkP+xx7+U8eh/UdHDouJ3IVXSmKwgk2e7ShmxSzkMx1bcmMH8/AfObWoRXOkb1jEDqPCaCiMGeOnZCNbPGK151hSDP5qnOQYPo8Y8Iqx0Lgj5WVL8hl2CXIKUn6yeQ/NHUTGXIU1D3Y9WZbDzoH1D9hDu7wfme9tUdi5/G2jnFhFrIRVHdYb5PJKsbwlZGvjkNEFiiPUF0tdJegRSiB73rEkSxEMW9TpYiuHhYHKnTSxm2VKWqXR5jEm8OCFiSayHN8hmcNeMAJqmUC6UTsg6eZ4rOTRmAQpIF8C0tQWMGHZLeJRCEV1pjfgaV1vx99lL16oF5793vpP7IxTw200soicK12nIyAWxP0ydkRuQDAU/Yeqd730+JXv2L5s+cJ4LCHwIXuE1zXr8edf6O8ZEAK0cJXvbP+qUDiCGGA40zgRxF1XS1ty/UPsuSnXowIwwgs98bsGnCKowV1lQEMgQySCbZoLHLSKsXbFK9uwmYnQTSHNK2fV1kUbglKx05NHGKmJ/bYK/7My5dGcWwCKuigLS1JLzFUJykM45jg8jz0UJlI5HP9907xxBMzbPt4Kxcr1EZ3zqmENGQwjuylQBnvglJBZqfci8Dp6SPRWbLlOVXixkDVFBGr2UK6XcuOEjNdRiQl/UZf8JUIENRYSnyQJCsAuy0g1aQhIuAxZkWlWoe3BCBWsFq6MAWoOXTnXPPMMuxYKf8spW/7h3cN//yGCnLyYiUgMgBrg6oA+CsjnYsQkEvPP+Y6bZhIZWv4+8saukds/eK4XtGk6yFtdrJSgGQeme7tB9QhUgGIJsgNy4xkOr8GFtlRmjcVccpkEFzCLF9gD+gaWgRceCykPO8dIsjUQbeGxs4GbF+uiDRUhNlpyOJzLVn2yCJUTcIjoFwwQm8HjxQvDZK0bblih2jx2Bl7030GgkOSBu5saqxvH7l+HG6ij2ULV8VStYJVLOqokW3P4arei+20lZVTjshX0VAyvnBW9dqkcF3seZ/mjoLzMjrHsiuU8VYoM+klamiTfOO2CoU2A+GgExZ7mYFkZjh2Amb/isWTEhrujHPHTQT/tz9O7iC648+pc6UlsiuSDzMTPNx/MlKLqYDd2ZNC9IDHTMcEeGAZ3mywgrVuJrptCAzZNXcgPUUzJXgAX8f1qqVxNM1h2lqBe7+WEBuQXtzkVo85WM+PdNNrL1G0J1ygEnIL8wZDwwpd4Rx+BAHwZqqP6hank7LWeYNySokgdgvx6usPBJdAKBXGcAOcRPAHokRCezuw54+jktJJsZUs3XNX9vK+mGhjv8YLvI0Gf4RWdmNA7eymLrcaUghOYZRU5oex4K1qdJca5YqpiL8MmztDksuJh8b4CbNMKkjzlM5o4vJMdsIHNXTFH+QmmyIQoFiL6Le37CN0QprVKMjKcPrfgWFXa3jPxg/SzpSWLaeViv2cuVZeQUkM4tSDfyczzSxOkvfBkOI44ejIkKiHnUXDMq0V8Xr83X8WWGGmi7Rjzu2eAmaRPQLbi0n4OWVaRBpDo39igh3bsqVl1qVFB/l9Ly7tmLXyboVefHC5Xh/0pRtLQbU+kqWczDWMD6E6q5S6gAy7Uhl09AaAPMOJXrOmQnepnLfRGUrzgR1wNSBV+9raADJNe8EvemgA7lpmXoIIVZQydnFlqU1RXH5LhGSFHPYY8GkSWJErmVbhmCPXh/niSbeR0RcQBDHA05+H/AFcMSTTAkXxlrVQuw3iKNFqQh8C1YIBTxwvFQ8N5MTPEQo3hs4vjBWA/glWoZDItEsqv6NH30Kf+mP4fom8f7wyc9lvXN9e9P3l0cU+PmM8UWXDSpPfwTRnafYikVjKwMsvsVBIK53E+gi8S5KtVxHgeAJ42EP38eGNu9o2rXCYN0gVrihD9iBH7ywdoaQm+nbYBZYV6ov7rsAOXyI9YEkggcG4apt6+Y7/2u1v09ULQy6If4F9pA6doFe/ANXJkB5KzPMHZuh1kYU+YvQh/FqAQ4LHzQNyKIACS+Kginn2kcOKJx6+Q3SOMcwQkf9ATwXEOugzup3ExneMNoc42cVKDpYoGW10F24DTpugNNNWGUtFAZagvq1Q9/ggfkRO1DfWN9ckkPAckU/P+9HePiiy3NxIj4wX8wYwHvYJ1TBuFZ49jJsz0Jv/3P10VWx8equ/VPV6YXiHvMxrDyy0wJ0tFlsAZ5m9kE7erFbkKpbSADAHjpxsVI3+0AFaNVWGSU+ACdNsAcwIIRoAQAmvtiWJQ70E3EACOA+DVU9CfrLAbDnpW+SKqK7GsGBXOdYcBKeMJCC+1xYhieLHrZglVoJyCSxSU2yLHwxUF/WfqABvubcjHfdrCRop0GcgVIILmYUhxJLYMg6OoQrAQc+AybHqQ6tHCM6Dc44IeeeW85ppo4vChPiwxfuwxI9Ha1uZ4bcobjQjMO4H/0HXLRMS4KmB5cKszCfId0s8h8B6UOll6Z0L/QPrBXZEdeTENBTPUdEE7XQZ4AES83PL+IXqkjhnoIbo6YVLlOM/VyKHGXSMjh49VmfnnkMspQPuGyykAMxBtkF0f6t8bKs0uIB/DFHaP3Ynp6c5QAOSkornpVL583/dGP/VDX/VImhnDGbcronmOMqXQro50wZ5QoVcWpZa22gvWtEmSoVfLSJqGkEfTMHBayOHuk1o99nEkQ0u4qgfzhAtLIlKBVyWcKuMryb6C6LfnWDtS1dWiXo1YZS+nRyThwln1C+YuLfRk63K+qITjD+qFaMCL6GMJRuoyFmvTtprnGHAUZb6h8B5WoD0G5QrMkHK8HMcEVoUec88ucBABMfhY8SLIXJRB/MLk+KaoZh+8xqIsFy2+Bmy3vg5e+ufjrZ3+Iu5KMGgUYdHQocKvBqlAYUUIlZSusQpkdaDkLRf0vbJ2Tu25S6TOQLGS0fOdWTflMlxgX9q2f/jZLUVw2Kly8dZfeuRyOa/qJVvJWeW0OTaIsKipn2f+HcLZPSNDfE0sIHOyjdTmEx6uyvFVGC0x49vkTY3ZG01LQ25wL2emOO/quU3FzuH8liOV/owQE4WaqoDTmLLwSITDCfRghuYgU16/iAUTUjR2dOAeWEWQ3mAngDez/PWeu9a9+7IuY4/uzSCvD05cwDts3eAuedAhKHQKZ1e006dOT+rHWgSJT6dc70paWcu8aKAFq8WiDYkcHgwIfopR7Rz62j0j5Zk9eSufoL70XXRJ0r8jmplQep3Owa59Ng1Am9KXP+n2/7zzN9/8yjtL2Wph3CiOiuW8rBYxe6em88zamIggwIySawvmgguIb2KCANI/sHUemXaDtLiyvVePihZsLEhuEC32ZF7/xV8GeoacYq5hTl2jVC8HfN4JKOUdx2tABsOhTBoNijiXosIzvg8uVBYpc4I+Tjx/zcVr4IFk1agClOJgmcjjxHIlYMq6Lvfg4CBSvCPuMHrirpOugq4VE++yy3WwcgO4t57DLJqAPtJWIGGlD9ngkeoJ6BSpKcSsnrjEC0SZO6m5N/8I2hKbm+2jwzghLDoWwaxKz8T68VtfemLbu25aJxiaVuIc3Qe9YsBbn4oNTBQ07IFnFKwQWHWGaBgZDSFJ7GPze2kjXBwoVAtvDHaYWkTtkpRZMHwbOAnFK//5139+9R9/LTk4qoDOkFq1uCbDllfyCD7T9igGx5LYK0KveCjONJ05mWWWgA0wPU3kmOzBe8nz18e+P3vu4khLWElVdH/W4hWNL1QRdgKrCoKEqvTsnh+vXvi+fOFoXfzMGf2e+oBOXObqY6OuSSfiyjt+7DaWEba44PhQiTDFFiYIEIl3HLVXw2QicCaAAl+ALLFMYEUdO7HkT7U+86/pDzqL6oS+ki0FYFTAj6dM6RM3fOS2//njr+5wcoYkROIx/oMfet9ll10Zr62pKPoZ5587CJcKFibJ+8Ki0JSPPM+yb6EPg+SmRBw6ln884ZrHa+ftqDSVq4qEqJzn/vjQiWdAE36kby0hzZ8XwpslQgNbMRwq2ZQH+xrAMU5wR8UyAJJGeMwpDPcPpC368RNrzn5q5VnXwBdMqc9pnkouMGBmrEv186+pu23d924rlvoO7HhguKf7tk/yD/zsJOJhPQFaY+7uGjAFz8d7yAU1Eq/AnQ9eUwhywsxgHZDIwBU23x52QACQFEZCwcvvbPjy7U7IywXC2IOXByeU8aGdzz++4ZGHDhQ6xt0wWZ+b+XAOLNVzWuXhot3EWzbT7J2eoUwDz3s/8qNNm54TNX9j66xUax0kHU0zswPjg9DRx1JMmYnNWUxMRqDNw1LCCMKd7SeayLjesZjcYS68efO2Ez9MXcHzuUcB3VYMo1qqOFk4TOD4CPdXEdFGUOYgfxDyaOE8i2NKgqk7J/8eHKSDf7V/+9fH6gXm6eiPkbeF7v2vlyJy4/BIx913fbxU6uaoADtwc2TFzCRvJxoCIABYj/vCBYga10A8JgAbEkzK0FU4jFkwFSPme82xw23O+upDtXe+Dd+h4PdStqzapi8RXTP/xjM+dSOyAVpoC2dCCsj/J4b9gTj8bS0k0J7Q4qPmEmPVmPfpw2revd19Q0spt6XRye/Q5nVnXfaXvS+Xc11PPPPMXx5/8KWnnzlWHZwxEYW6ueD3JDgW34ubpSkuerzJr169uOmM1SM6v2UHONPJpSHhb2iqgaUPcla1gJAAIz+NRGFCZBptCwsrwokxErzevIBHVbopFqdGsWGkY/RvO/+WLWVkqyiLFQfaE/j9QDVbT8rIaZrYB2OOO+7JJwAHGAk24U4rm3bQ10MnhuEx/zq408IJBWlwmNVJavjm2443Vyxky4NIPAf7p4FsjthVQiUEdSFug98Xz1KRQpAz8+MjemG0Wh3Li9XalqabDncNEKEDw6yhGheAmDDHEICvJqCUWnYhO8qoDw0AI1MFbAHOdYBX1OvmK2CL3UlUesdZyXnnXqziEERH16FfOKU0NdUHgz5kljPwOzICQ4M2rZaIBE46jMBQSSPSHLMIgHnz0lrjMaE8sezh/tzjz/1DV4vMFQVStIj0Ncw6w4v6h26a+z//03lqGwdcyzjoHczH60Jfl+m/vkA3vo2W3UglrMNeNyYd5iCeyUXM2YJuXbbxZ5M0kStmtbGiNU5Vo1JFvAviTLBy4ChPpFhj+MNGlscGCQqKkeGuwSOb1OH9MNWZStoMm/PPTtQNWrm+fJqC2BG6VHaCi4RdRsew0Yf/06A/OQZUrEIGUEuwrrhbFNPlqEBgHdHnP7Uq3LhMQxIlkJ9qgT6mD3zV4vZ4IhYLB7DnMw2vpio410TVFaRzggAE551EI4n1Lcy0ZAEqPMsnx9jz89MbYdeP/eTXlkeHx+G2XbsOHTyQT2fhcpQZ7A7EwLpBtSwSBETL9pWyWONtuu22zAN/Q4Kfk9v5IayvRBf+kAKXUjWGs0XoH/PpHw8fi8s4D4egfJOa2siGr5EPwV2Lr3EewCxBKaTTvoOgETlt5ypSWeV08GfERfA4RwAMCzIZtMPYpyL7sa5v27zhyK7npEoPfNGjTKdvCjEc38g39sEsDB+BE+VmMKM26ug5ZcToaNIVvDa6q22RLTJammXaBZ7ecBtYRXTBfBh5ZE0rwzvahHZQVyql9PHW60I0pxkaRW+AhSZZmoaIUsTMI0gG+TDYyrfuUvrSnTeIDVgAYQLLs7wOTMKY3kG3sZJW8so4UUkfv+cXr2/Z0jt8DMkPPLrtA2+bn2isEwTB4/V5ZI8gs+QIHr/QPn/uOReWP/TJPx2LjzneKaL/Ivr0J6DRmsVc/mi/S0zHfn4VbklfP3Z9EcjA2c+7P2dHBqROO59TVAtaK7isKDiLiuVIIcmQDSSWBUVDsWYJPMKClULuN/f8sPNgpi5MjUlaHMfhQcRj3nl8DZdRy3NsfAkYIDbd27J4Vim8RaE9z2342/MXHHvu2k9T7CeXPMNCctyymOiL7hKv0QPn0cc3n1AMoG9oSx3upBq4A8ZxBLCpIEajfOxGRIvOrYsFHWQs9HuZygL6CxEaIkvyAlp+raaZvvD1Kzn/p8VMD8vYNHiIBjEBu9wAlONtIAzhH08F5SC+QJLbYqUwPgEUnSj3P9zxwXdIbQuTXhx+y/xNeOj9PUEOZqyYGH/Xe/1/+cUpswDzXYg61AAnbR0KVlecO9Hi1NVLLqvFaNRdgzjIFylHS2rZcowKJBRE3jKih4ONJdo2+A5jKVA+wjhMel/vkdf3MiIaRzB4llJzmG8SIgPgLFQfbzj/8ur7r/rgFTde3NrsMehQmF7x0IZ5a6aeCup+mruRPurygd3Mj0Jzz7rBOyJwPSegj48lNi+pkk7Dp81GmBIvCRYH767jJYjMZjgVCPnm2FrFdssIVvCIUNJRJEyt9RTwI+1yj/jMv7u6LUyt05XLrrty8utiMbN3y2v7DjM2Ob3c9/f9X/lEU/u6hR4+IIi8x+9IfsEbYHaN97ztE7t3/vDw1unV2TWIQaKQl4TtO/lb7rpp02tHJD4c8uAUupime1VfnRVvferzV6Pm0Lmdzo6wds9A1s7A7Q7HHcPVVRdNTVLh0V+F4hL7QrZE4CBghGA5yZjvjjs+ffx56OuOLhaAjlDDVMSZt+TMJZdfX9cyD+nOq8zO8YpNz2M57O08fgdI0Hnk395Bn3Xx/2N3wro/4qSl7F+mVXP3hoNYzLYhG/WElJxAcj1fsnZhK2NooBtMuahH80lVhJZLAvO0ESEF4ZQKuF3yWk2QWiOkdD4+lHlcZBGKb1K+uRpLElvqxvp2Pfn73z72j+dPW/E7P3/mp/VNq846G6xZkB3wIrgEwWAX9bdcc8XKw1t3nXSXVBzjQunEOzazbCiH97MtluqKoqBquZb8N3562bsiuahiKH/YiGybW9f3ClYMKn+R6R4Rq4ow+6EjA4P9nd1H1Go1FvIHfJ540o8Qitnz5oznZjxtPzRxvRRchLO6K3MvWhhIxMaMo4IEj/EOnUYLLp//+8C0W/yusfptLjcGb/DRBxVmsoOEDafj+ezcmmMl5PZ6OE/+nWzP6MchS7Gx2atrvKWJw3uYQsFPBRwSJ4N5OCA6CAmGzcGOpGMFdorUtZ0e/DP9YetpxX73ESsQkLWdDv7Xd2tvvOoPX/jYk49vR3ffrHzqq7/51md6rr7hOm9trY7cODCjYFKKQmvLwnjjruzQifu+/1X6+Hed3z26mTERvCZm7lNVY3PxnnWj1LGMlB/CTPmzCHXOyr8jGAmKPq8AhT1Als0+9uST+w8AtqzgfNLmWZ4meFI3h2fDEeeU0g/9fpnOisEQHzHYHmiEt3NlGkPKKUAeAnNXE1Z/d78XZ9qShjaan2B+R8tfo4cuZ80dxubOpqBGi1z1CUaDij5XfZ53Va3wiYJGgF9E51w/P8iVXzWU1/ZSpWxHtQzP68z2A0ZkYrzYtCiVMj23g7ZkmPYdRXTfT/MGyHQih/NPvnbV0dG+zYeyp6ky46v/+cmLh3e/+t3fP1DSJKxILD7OsuEGDM/14wj4ly+lXtw7/uw/XIc0UL0xE/rMg8y/zm3Vv50OMJGwI4+UOUYZy4bs8ePQdwQYlMva4cMHjz+7aSHOytUWr6VEKtDe4vv85y+8666Xj/86eYH8tgEM1faU+YoKzzBbLZlqTmSZpsZQI0J0HkNAMkSraqglSLP9DMSHnmMyOcCNnubhUIRj590FHIAD+VuukgokBAgq7jvyV3sivtpIsCmoYCKVhqgSrvIIYeH9FnZJOlTeODe+imV0Y+ZEB0XkA2ANAMCjJ77FFR6MziFjyObf/DzmdmLGz6d8wGD++KqxofU9r/c/UUCEKNPYQQmeuu3dV+2Zv+NPf2Ajvfu/UIvtv6xeRv3HC6gJA76WWj5Fn8eXGCEcUb+Bc1bY2VW4riTWpkI1SdwzPpbpPNJhYt/slvp59NFvxppb2huj53JSa1Sc88X/+Nhdd7VO/nr83cmw/JJFhzviGUv7xkwcUCBkhknrd+k32EzLW2khz1wN57J9Wl07LQ2UGr911wN4DIAOOkFOWKzagHXShTU/9b3mDgfVUCe9l6xcd6Ay0e5GGj86RjobdBEvAHAJHENbCPbzFw8f7xe7ENmpHQUX2Gh+cMZvAESXi+oE0Q1Ua8Wcci43xPIlM9llYkbdYx/QACRxL07ekrlyQbn5hu8dr9Uo0LpZUbi9yeh1xRZyzEcU+e2jFKpn8cyRubSsmRaAskAP+T5sXJ+cvNdSPMlkHTNUVJXe3p7tm3ccb/MX94bPXvuvtjXbsM+AJRpapUA08ZGamlcnJobdSrr7nsIxcXKoxzNxyJfOC4iZwHHzUE7wcNcD4OpFBveVDLj1dbQOh4WFKPrY77eA8KuuvsQBcUo+JaRZHhsnxfpcmAAxeKF9vIAP4KA3S6VXj5b2kY4zz2dqDHNEr+HVf7zjJy5EluPE734un4wAfIv+YWIAKE0N4SsuuzaxoB0uQsyTVLGrhws/uvc/f8by4c8oHk80r/Z8884vPfiHEzhCDpkLm5ub5YjgIMuDxxQsL+/Fvi1CwQDLf5JEgsAw1cJUCGJABG8RngEscp4V2R/D6rVna9dAz+grG17qGDiGgA++hy445+uOfotjwpQuOZaP42Dpoo/vHN/QDKcRNpMAF0y4SAzZl+qGdPF1AUCHNybYSQ08SAy+H07cTYw8586jtRAOfToc1nxbXtj28E83V9yBAw0e0EQgzpIgtAwjPxs78BBddBvHO14oeM+CKJ+hsSOMc4CG3mLByc0usoADXAjuM2feWnLHUBdGyBDOzkFIJ4yYHNzw5ZD63vPPdzY8/t8z64cS/Kc+9rkXnyxi5MCf7K5XiMzwSd6gHRAtUXBk+J3JCNNmR9uHBObNjtyEzMkT+3kAHofSmyzkGwNhpezR/vLXZ3dvGsxkcyO5jMuH8U5XXYtFIsXzQYgYOPwWUrYNZzaJGhp9dS50gEvABRNbaKB8g6fXZ+8joQDdJnucT+LCHqoJkRoyo2Fxkd9Z6LVqPXbcywkdm46Wx5liDLSPFwic94YtGZk64BOpsAxwiH2zGF3iBRzjHZWBqswAsz3guRj7Wywi476AOyZb2MU1LmYW9ACjXDCvQYIDjI5gHihr4Imua0ZJET0xpM5FovWp8vGt9N2uazdqJXkhRXqYwZLlVMXhiDBIix4fDizV4c7jCBWY5yZV0SyQCQpQQApuBRgUBgNvzwxjyMfKD3/3wCI6q927vE6InB1O+mxfpTr8G/vDXZuqF988YfATgpSCd7Ep4qgg2XayKa7xO8+9cPdll+iuHFEL8L2TXmq74NFgI2QZdwuFoMiKpOG8vJLE6yknlJKQaWcBwoARFsjZ1TeeGy/m4yLTGjHy93n8YqwFi4Co6oJSdrg0y1iMo8NcXg/4oAANgHsvjgdwHxBwv3wrb9AIuOjDnMEFqOV0ZW5TU6Q2bMOBAon/bBRHZfAvDIwO/cCFvvfzZP4nM1Teg9vhuncu8YNUF6eDT+Az+qbuJRzhMnaui2tMKUA54XI+iDCzaE6Kav2EEFC4R6dsGh2hXcPHZvZkb4766ZxENOmDQ7ZTH9LrjfLKGF35pZ88lGj+yk23bybfPMO/yKQmh0PAXRwz+exLL44fHBr465kHnaHcR2+/89CldFRj0brw3uFrmBEc2lQbRz/pmqzJXscnNkp8TOL9vCi//vqB0cEk1nk3cVglEorEkZK/pcUWy442ZuFwLYcH8CvY2SIFNDyskEzShRzGCehnXOlojosPjBRwxfdAEqAbRL6QwBnXffrt3/7uZzEwKIKj0OYyQwkmDGZ+xJ1sk0Oe+R6vrzEdzWD2bFFj1ny7rJbHRoffdWDzZEXzh9MABgCcT/YL2EPMbMVdTtCVrmlfu+eVHEXnFhPdRHOuJJxjM4FA/o6pBcCti2SCqjeuBrBNtn0BuOCofKowN0f04S8ovTv+vuZcOuMiHEW93JHPs+kq19eXFi5saP/GYEvvgZuv+yzFHkS+B0oFmKSJJCFILBMKQxVghT1mwFFq+EoikvVjE2lBnfabv+xWjVY5EPFWov6g0bo02dAYb569AFsHu9yhlrgJyx7FfPW4QEP/ChR2z9UGCAF94AAXGNHTm5/84cfvLXoNBF2xs0dl5nnk9UTWn7cGQEDUjTq6HasPmLA7A8B5MG3AyU5XEPRoK2AOmsGZsJZCwNcUFUe+HKuLQx9Oumsn0edO+op9nKT66QiYrAQWBkw2UddZVIohCQnzeB+Yfj/HqYIHJ3bAl9BBzh8nYsoFsE5WHvoLlQYpDJf/wB65GWaNNcfnMUbjbNmy4pCSTZTHg0jlDugD9FGoqyiCRCYRLRorBKWj+YA3b8dC2EBafflC11EEDSQ5DxSdfCRh1zTXJpsisbqkAztiv1MxjTT8SEBkvEu47koNp0KwO4AQJF9wERAEOOucAM5VcpBzUmeeWsxsgSxdVbUAHcqWYnnz2IEXvEwn3e7eWusuxUAG6GpmAaZ1pZxTMnDzhssdLAcCHCoK6p82bjpWcQlbR7LT77p1+ocT19fW0KoVjQefh4fHacqzRG+nzfX07gaWD2sKu25FIVzwJpRASPf4FRGnDMb5tv5Z+9yfDmOnupH5VV4xSGdetc3bzBVixI3klL/EqjvN7B9GV7KEPekqWd00tiOgKgFMY8AiQP54MZIsyt7xQPQlKaJyEkxWFbgIHpBWRRaEIrlAoqa5RVx4ZqqxITx7RR3yMGZGike4UZxuwXoHogPnAMQAIBzXgAyTFXYc6JjLcICM8fyDMo4HQLZK5A6B8OLosBYh5uzIgT0rF23g9U4hP3pZbUG8siliKYUuk7oxc2ad5thUoEYr4QiqIHK2wehkQ6VqcRAFHnbHjzcxyuTYEwh4k2mEmuuvPGf+u67/3YpnLvvBi1N3n/iLceWDb5ifsWb/pzyXRRCcKHJz1dtS9YYVf6Tq8yl2uzxXi07X4r9wgGKPU2uUIuf2GRe94dsNnwqYE0dGmKlbaiQcnMItJqOtMvZQpafK6BUFQh1yn3mKnL8Ih1kLgLRcwa1OWLMOqfX8tcnoLF/j0samhmisJqj7rf3+oyWbKY9Z8gO0Ibg4ABowISCLVKkP0bUuHzGQau/mB6786t2//dofpXAckaIWwrwZbsz9e7fdcPlGvpqHA+fcFInXYHX3sQbfaKHXFxI0AAsyrGXexWTJFSLVnFaJK5a3DAZgCRiYYLoRfe4w6MKLmdrgWPnH1MXp/sZWrrMXn7tk+bpfDw5/+M+HTqqCUdTckvB/3qBr5Wu+OfKzZ45J00BoXZsUbbeiETOcqvijBWzzlrd5vW/UqcVjcwm+411pkv5W2/PxrzksV3+sj5CtLqvSmMgy0WLHByrxrKO6Io1sJX2EPbvMoiFYwRMARXBmDBolX1hd8voDYpOoNPuEOSEp5MNZSn2l0eJR94jNjW6tyTfc2sAIVwYW0jSI3a/bCgD4WiddN/el27567c+/u1USyjjy1g36sMaGq5mOcjKKZN7UmGLx2D5EXNWDBSO4N0BSmBLu5izizi08Bf3Sy4ahwnMP8cUWkm3ghU3U8V5cch5TEyaIzsRXN7jb+eO/TbtIYU8Qa7U9CSnasvSat6HHJ5UwJvTcgC30cL7h8Gzt7KmfW6CoCInBgBQMiYEwH4hwwRifbA5cd+O1k1VqIuL8xbWQWno3Fo6SfYh2HKbXNtOmvbQ77R4fBe9qkB4SMvgwCcjTPNXy1F82RJf2wQTwUqy4Ytaa1ZQFs13BZ+UEdUwodhaHWBR959RNk39xawy6OorGWbQeWkEBaFSgEVzoH/9oX6eblYKNLFHIYlR1lAL877JHt5t6lvnj+iIkNtAsTk3y8o4xieqRWghZCSCqwQ3P7RFawWzqN/O+nC+Z9IleDpG+8E6NJKVnf3JR+KrB1KwBhG5cyOYzvfESk12em0tpeIU6tKGTfosZNFWQD80brvFAPe6Nzrvquu9c/J1HXjwRfof5vwz5AhZxVvpXUvawJ07XnME0vRVQ2HKaO8vb0OANxD2RlMcfBSnLUkq++ePvW3DmPK40gvOPD+161MjQg/vUWcyDCMcZQKuyeIRGF1OohVkAkTIOnkegc3M2c/3ybmUgepMS17Rmy4nhKCozGyjsN/Qex8or3b979m+nelnWraK/375cXbAHPmp9QLifjmxiOAQmQE+7/krhxLc+8bl33PfAmIqUOLpZnpjI0cg3fkFvP5suvJwlg0DcINZWMWBwYWSHGUDaL5a5XfHgNAOGA7SF0g3aTBe8rfXYiglett3h487yK99pz77fpqMggiaiP3yWvng3/eAbNPcINV4AXwaq+xv99rETg7Qo5hzNcs19iK6SOem8y8+rVF81NjNKAfSBvxWryFsdN944DLViLk+ROK1cwI6BijYh+ZpTk5A8CaRU8fmCPhuHZvBWQ7QluNwe6Hh0tKvDM1GGY/0RgYbh3Igo6tCPv1a6ExLFXsrB7zLFDq/AqonAcisJ9w9BXG6xY+pPXxrr45GA44fApaoTWsfQgKEWD3W+bt85A2dXtL67rSm1+vxWx9MQrdYgsLB+tbVyTn8p223ZA5p6mMYy5nh37x7Vx73+/gvaf/7wuFrW0zQ+7j71rtcp6XEDPTXayyOnetEZf4MyD7AfETGPI137J2Hv1t4P+45erbMsLzzrodmWcbphudj1dXHO6CTsOl6iDQ/Shy+g2XHKD7MgSCFLV02DPprB3ur1BzYs7+9NntNkR2ycO9I6S1o0YeSrhHxgUAnNnkcTB7M4qASGmjx0uYVj6T4QaeO1xz1SweON+pHTDtlJEf+AeHzixujoqHdXNjBse3XkUq5EnEyWvv7fX33i70/QJqyoAYQ9HKS+FkrBAAc1BSxnvtqSECqfx9GeI+7YTn1bvbgmENCcqpYp4hjAQeRlHR4afnAbE/Ldskq6IRmN1oUjPsGTR4TmcDFYgGWUw4Em6gjOGttvaeNmsd/S0oID6wucnYa93tFbFwdf3lTcPO1x//4SCwuCWTIH5/1ilnY8cezHWCMTqqbLo/3uJzRmI+IDaT5gHeVUMzfK72eRb0j38OpGarue+fYOpWV/RpeeoMc2TXsUuxSRwnnrga6qmVmhDvpq+Vxx3NJ4loIVyVZAC/BDkVg4sZJlASPFNJUKLFgB8gAiYe3KGMt/ZUZh3ID7AyQxBJMjK3eRjipGxrDLsEgiRyUclcEwr/rQhz76uW+hPdfjNJ6jLM6CjzLHX6+TFPla1QOFJ5zrx2kif1In2cdF8+bGLBEHGTvFijWaL3aPjBzpdrUStIq7JCRHPP6gz4tzxtjMxZEMqm7KyNoH51LEMugqzu2EogBehixUAxKvm3IExoCYR5rddrIJHCQqDvZChUEbnqTNf2SPv+UsWncNdUKsOcg+ovzklz96++XXYNpO9A3t6e/rGhkx4WJnjtldcqm/0xBKvDUOXTniwZDhbnQ8we3r/hSlJ++deo9gaUaU8oM08EpHR21HGSs2TP0y0iIgZhHbI0TwQm5A3o4RyuO0KETp4FRqrB+I3+chBFMw2BtMviaYRWfWggqvFQleqTDzvDyY35DPDVRzqpoxS1nm3fX+my/7zee/3V4X15BrS/Rdc/1lAwePpl96sQbxc7NDQisFG1U+Qgtq6aIU/RU0V5jq4+TfVWvef/Y56dHRYllJ9+eGjnSNvLiVxsBl6TNrP1XOm0ySQYBgkMdEhBuSXXFUUZfgWIgFBilGMg5f5ZAFBdn9EEEI+oG3K9R2CGYuFDJlrAynFHHsdYLo8Jsfsl9+/CU6/20s8kRM0vynqcNd8TdVGuaUxcOK9vvBvDBSjSDpmkEhO+RzZstV+CrCqc7wImsmw7lZrpp/OTnX7lmu0+YsOD+O08AYO4nNnR1lkst0+9xQpEYIYiFAsCNiBZHgq4+MMjsyDSwQTAQihX+Uys+BtLc0T/TFVpyv+AIDwq4cdQ9kN471dxWPVtR+M9dH6TQtaZnz7vd88b0fvhHRL7FITWNj29e+831brz79x/vKnfsSle7aZKWmYdyB7JGi8+fTATjGgNS2uIILBze8yM++8815g073ESTlHq+O9Zq7kfTHWUDJj73z47l0GeFj0NeyLOcI/wLRYWeLWO6ywUmIrOAdVfBVwrXIxCMwHwldRE55BfiqGJqiFTt7qTvPgHxSET39FCjRpbMoGqMLb6RUE8u5AV+DVRceQ8Bf7vjxX244Hxt3tpIJ5hIOaeMt2GeDEpydvAj1QRYshzNFnJlNVr6Q3zhTMcHRFfVU10itCBNHKu0KTexgi+7L6AcIQvLVRBHui2yHKkvzj8MJM+A87k4TCAAFgfZEkCn0jo9RoXtk0Q0dWXu4l14sKxOZkYHS4VxpB5WGubEuB6dkv+eLn+s+tC8WDKZtq7Gp9eb33oKsdo4euvKdtyGTvd75jGg9LXMH8XzwvYUOVFbMvW0/njGCPUjd1z/wpVv1GutXmxr6J9J2wVcq9Gf6uv704v79e0dHsx5V83mYMI9kqCy/CZggzuSBwyI8YqDPFeRgVVy8Ykl07fl8vEbAc52SNbjHHB7qf+Olfxx5+cd5Fq7jFqB6hbt5mw2+IeJMaUyVFatpziIKIf8Pdlk+JrUFa45VZ54AB33UnKJG7BnCKs4GhkUGsx0zUIAnCjtFAGHNHGPAGk7iOn6be7FiFtXDKQTh6QkEMfiabL4sVbQtLgJQIYy0fxJcCJiCEvNUc88hAOixBoGrTfYY8wBLWQ47qSMIBx/MyXLJHFOUvDqsaf1OaYgrjbET8GDSqYmvfuPZX2CZQK+ampvPWbcOj0CquoA/DAc1beGF1sR2BAhhRwDXxwiEtyg1pWh/HXvYVRdffcuFb+O/8Yp/ayFVhbs/S4Hra795aHAA+XQRicf8f+AAxjItIXgecddlJBDEdghbI0ATvsVtCxtqrlloxeCZE7Jt2USW0UhcwCHmqvBa33Hoo0c3En3NpavF+IADWxmTTaSoAYmaA5hcQaQU8wZGfUBAfFLDkKMjL7NTWJU11LxYSsSRxzToEYPIZirgZFuEi0OPLGi6hrTKHYOjaPR4aaFbl1IUatimoGfW6sSCtYnYPPrXxUu3bzjn7f929tmtNavObkYACbzusS2EHIlJAM4PiIMoJVc8xXBxjVcVfUHY8GDHyDhysQ2Xy+rwweLAfnvkKNN/Y4V9103/XXxt85GjWz2yE/X43/eed89BXC9WEYRWICMduhpZljVysgoXShMISNi0JErVBEOAZvkfXPUR+SNPCa8dwrqPcUM9Pkapy7/3oSOH9gng8iELjj0STBk81MEIBLbg1w13NwsnbdrxCCesrVs67+UCvXCYb5Rw2rUdD+hRjRcUZAp5+rnBzcchwi4arqDl3/oAzVprPHxYEpG8QvdQArnF6kjyLhP5BnL83kBnY9M+5sWdnbo1jYwjw5Sc1x7g6/x8yiP6kXIRpndYQnSkuFJGJyYy6Vzv4SlhDeIEfXcJpeKiEYgoyXnp1Bl8w7lCdAnVtsZa1p41dNs+n2yXR546umO4mO8F4CHyVxCj6T7Q65q/QaTgP8AEVmhMAr9LewM7iof3F8dGqggYOn54wqVrPpAqcVtyzzhJ21/hEE+xctUStMROe4KmAfMaGzT1J1X5SZ3lTDPhGoY8C/UytfhpsUzvP+cW3zu+45rv8EBs2SCFWfM3/WjXnud1UUWCc97CedbwLoEdE1njciWtoGDCItbIQrxL4qz95Qk6hPxUSZLDFEISQG8gWZrvV+YFSxL3vbE9U0Cc/LvjGdrxzP1Lv36/fDcexmGPiOUEhtpgXPCvcPg2C9Ztsb6x9SAl2Cp4oujGmgX+K5aFkY8JWdSQEVEpI9+1Be1qNpPu6ekeH89k8xOov47ei7QkcRJjnmKgiQ8EzVCtA9clHloOpGt0S11qiYlDJj3FGmVPNttZVnDQNdv3ll1wR4E/kdacwcgitlDwLl8bWHiGHAzv2NZ/5/f+MNnC8XeIUfu2bR0MbFx+GfG+ajJciK+E6XMEAaPwmEcSI63YP/7rW33ya+pNPiG0GrKsT9gvCSWk2YfNrnCA3nP3vY0kLKJ6NyqnVPBdk/zbZzfueQYGKBxNb+igZfBd1bYQbV2sqGO50ni+bEHsFkoUKg5sowmEoEdIQKKbWqReI7ml0mqMrrWuqr3j2/95vJ9TF2AS27BH+SYyyDEKg44UHJyl/Igi8sym2TalBMeXCK1Oxd8Yn7qJ/fWLNyyoPXN2BIKVjhQwRQMZ2hxTQyJWNzHPRL6Ux9m6AoUlucohL5xdQGQIjvDjEQPi9XAy8jyUCSobsFwWqAssyqoU88VrfVG/hMPFJSb5YAaA5IH5WJTqF1C43RNbe5k4a2GlMDawa8cdH5w5m93uISq4RAfCFZrrD/tTuqdVjS+JqHwfMjWaZgAZUZ48p71xH839N8yYlbx3leNEHDFkSq+aWTVg1G95YQTNPM0O6BiUmTtbWfrFbSNRVeh3sOFgOTlgvIZTGHNA1SHm62apqluTZ43hYLadLFa6H5pVdB5bRpkF24kgG/GCWa9u3fH8CV86t6/sDYMDXLvclCXYiOksz4/j0yXMNHkhZy/36k0kLZ1bW/+Os37ws8c3Hr/v0utWfOKWixWwVbssVA5oY8N9XZkJrjreV8yN9E/gSBokWJCFSDhU8iOSo+gnw+dN+XGwbUi0oorqURCQ68s6aqTxhWffds3VDwPxPq42kFqdmP1yWRkBtrAADLkcH/Mgmab+vyN6UNulP77tLaQyLsL/JlgMLaXa1Vj05TFhkyOUVSX6kcjVF7hGMgVmk5ICZzHZDlnW2UXtaOdm8z1f6psc4Pdcg93tVFp+31Mv6LuOPrGvrRZpHAOOiANhcaS7YhtlAzuOynixUM7mKJ1hPBPkAuwhZ0kdmU3MAFnGeYSwNpiLb7HO5N792e8eh960i35iR4ZArETEn0/s3ENSlaKNZqxeEQSmCZWkMA51CASv+eDVqZ/9+/rjd/70A+81xVYT1lKhIiVHvJ4jTfqQLKSHjk5gHccpZTD6+HwBaGYzwniJE2G1wokJcijOBb1KAAltVaViV7K5cvjQtR98pNhbCHgikpOUfKlIsy9YIivKCEN3nzdM9BdcKMcf/pYu0giqgd8M4l5FT94c8RqB11555ai7DWnGiLeT/uouSu2CzzL25ZVB6x3fnNHsb4n+Y8Pmh7sOvPDcEyGvJ+qPJfgA4kIlDRH/ilEuVAq5Alyj8kg9zQ4qByWjQEw47L7Oc6UWJMRdtOi9g63d13/2+9NbT0Kd485vDG3SW6tA4KWLxVs/zBpaHKFPff3o2z8JYxH8vd2IfHy5cO30JoLRFlgHENfv2uVjltcnh4xYVEtF0gFJ82GPzna3CNK3c6UC0lJkYTyqycmJJpPpjyHncBpUgkV99+GHsLYf6P1Se/vXI546+Gd5QuNQf+ZhDp7+vP/79TgygKKJ+SwBpaqXFaGQP9qfcE21ECbEnRR9iPgUkqNZ/b3039tPfsAnPn3HK50Hf/+n+5FgFoxrf9dRT7wlKYHkKuVsBicyjaVHcEwB9CUwjk9Cf3oTr7oPgp61++Bvxg8e+wWyw1J4Ps4nPk7pHG0Drk6U14AUUXU/7y7Qo3+gq98+4a3VeUjAbvGwoKMTxVCryLwBxIMHMekaw4SbFYK5PNgKQmaOCmKNgSByJ6cqGVOtVizbLwoVOEsGYIxDACDEhqph58dGwf7opYd/Eb+9Qap5jyPu0vUeKOAmRk886//tKt1P1TF2ICOyUYE0sUNZsOSCMnWJ7rqCwVjIdz9CYwo91Ammf1IRv/Sl/7jimvORSgOxDiUca1Ks+DJmm5+HbqdYSReyhUKRighwdFOhn3QzPobcGYtJDKAD6343eUgMQcKLkeMQp0W7uVBOvm0EfTtWnthJ3/3X777vI/ayC9/DnNrdr6+87LKnn3tuskZ170v+doRjeR0H3kEZDltfuFsjnznPkhNLkQuKyjK9WO9UYW740eQtQxPZBoRuehu8FAhyms9BroXRQh/78SvfoO//4Gu/ffJrwRAOiKW925FKYPKm//f3wkHa+xo1wQrcWEJ6TNuJX3TeJ7/9/uGNv3sKM+CPMr3UQ7tcU8mpz/joJz6wdNmsKy65ev7COS+/+kqlWMqMjR3Kqkldk1hsAvQjTB8KpghRDbj0uEhN4JySWTR3ATOizG1isUY4qBybUV5lukDIEUgR1bCIpVHf/TANjc10NWCd2H4CAfj0s78fHsv996flptnzFwVDMSS8+eZ3v3kcAYO/faF2ts23xXm4wjg5XilwGVPPWdWqjaQ1g9JHSF1C+TDRO10G7vI6cLt0RkCOqqCKvgaDBT44zNKWu6VQoRsuOHaNP5fQ8cgg98t5rrGp6oY3nqj1v1zt+gfNXkKesydqmizsZ0S///Kf3ldY85OOvbs2vrFp74FCCXPjlPKN73wDjl2PPPhYa3PTV795J3aUuXxpdCStmcaRmZWxNZHhwYPsQ/XsfJg1q2n1ObRgLtPmsghNV6LBuZCI1xSRJz05WwymVH3vjv1dO/bS/tzMttxPMxCAvh083PPGlk3YZiQTDUgUb2jmuYuufO0g8J3a/Vxo/lldcRxw5XNscEYlr48aSsEoZmgQTcfPYhtWVjAFH2BH47lr6H985rq2trrauOULiGIsqAes5rWQdGaUL74zdcE67eDdhbFeFkyKcunttOp8ZlVCpvL7votIlxn1/9kHlbb8EamC7Npz7GiDleeL0JksXLZONfg9R3oFsXAq8+4fGvSFo0grhdyXP77np7lSGacxlYo6oH/qgyAiJ5DHoo7a51NdA521juYuZUnfsbODxyy0XdDvw4de5Nr54BwxsAp5rkY2vfzKK7QRIDpdmYEAtwKnKxBXqlVfydA9RWRhbm2cfTBh0II0hTJ7Xwu2T9ghHekRbb1iIVlN2YImoFipYdI7qPVYuZToAsjW/3Jj+7XXr7NVBcmvHQRzSTjPef2KNXc8sWn36KZ8fqQGh6v5rFi275Wn73x5b+7YLgx00FRHdTES48gP5u6Jp9p9K3+HD1NvksYbKrV8NReagCeopdk+bxC5ltwd8cltpBpqoWLu6jr6xpYduYki4g90dvTvMWo6qTYiC+vrCQlBU7WUrGHJY7FQsoxGrt4fajIYV2AD8OCke+gJnDGzONS9P3fkpHk0rdGTEeCPI58aD+giEgh6v/6BgUS9b15DjTVcP0xzDzxhJqPb5Boc96ppAvLpQQcqKJ3INLeMKc+QKMu1hebZA/4DCPju97+kjO8HYRgwW1RMta+jWqw+/rdNX37JrcKqHSvoB+7V3U8R5F1qormB+Xyq14d87KdjGlP3neavjVj9jVQnddhr66vZEA5YQ9a/TDaNDYCEdMpI0TmzeDlpfGTk5z/7aTZdGMmOZ3M5BWNHGuBTCnp4yeXRhUvhm5P1wDLtpXEkDOtiHQQKcGQCRAk4myCTvKB18HYnp9vFCXrtRXr+zeWLGQhoivK1DU3+QBgZ7mEJ4Xm7kpvA8Wb+ufmqVEr36bv1Mxe/loomMlJNRQt32sJeTDvmKOC0hqEtd90b0WKBEcRZf7zjXbmxAz4th5xXelVTctXxsfTwWP5vr+ZPGdoMFTboKxFrEXhfx4T2FzCfV06t/r9/8/rLwzJtHx3K47wsVUEauMrI+JAb03qae1P19evOW18tKUhXqRowGkN/h5wVAbNSmayN6Q1n3fd86Px33nZTHNSYfXTnwVeGx2jwDaZArFbZyUxIfwJ9IjKfAHeQxGzDho+fWiZk6P8nZQYC5rS2NjUgrj7gQdZggYeix672e5x0IIFkOc5YX9Ki9ZHO2kRn3hOaKNebxdgQ5xkMDeFMoOewYQNp+Vw7fqvrvHTGBY6k5RC5y86yL5WQ42F0aAQn6e4Gtbx5ARavuDGkllg+0G884vrh/NP6b9YSiKDzwJGhwVHwElXVVIiVFZbY5c3Kllc3e2oiyUDch9NFgiEoaLhIAGqUVCwU8PsaGxub5y295W3X1DUvJqHiq216veeVziy9vpUmkGoSD8Ms+KeAPum5iGOQ4CIAfjX9B4Ae51MgwhSqDzRpqDnL6kVYvSTFJW/G8VXDiifKmIzJsvzBJmTz8JYLOBCBB9tc4Szkkj/kBJBMwCdCEoTKCsd0IY0CAguUSqWQ/1/AuWQZjiksdRbpKUilL03ZBKZ6ufaL7LQLL0JhKsyQVzxMSDk7eTYUzPQsJFiiliQ7O/Q1jcqgTbWIQ+1xBDjUBpqr5oMiGgp8ZHw/tWgTBcMbCogsdTJ8Ob2SPxULtjU1RWPRtrkL5s9blmyZDwMIJH7eU18VuXHV6Rsn5qkLrveWC/KnxrBisnPimTP+CQSgYeRCCyCqFSc/c45ZHBsr3KelXg3AQGbUcmYhGzpnvqJEmWyTA3l5sv2Rajfn6wDQAXEcT414BxhuAHqo6zxkBqNebWwCFkFEeJrlgl7MwSwKm9c/L56l9MArlH725Fo/fY3ecQ4LuEK05oEuQqjb3hBl81QECNzD8WB6nfSi6UDv3AJv1vLMZgCoX3z189Bifvobd52WELBAJIOhCA4O88Dw4Z/TXL984ZJkoq599vLahoiHOfGwEhNrxjlnBx7dN/nF//4O3oDTzWbhbD2oTN20x0hPU4Wm/Pit6BzivpVs1iyXLL8vPfhgJfIqlEyyFx4sY/zwWNV4extBqNjsqq02sRAitRfzjnMVUmm6A97faWoeYzb2uEpxjofFusoYYQWLUdEuFOByAoP6Py/b/3ia3xd8GLm1/sWgvYr2cnmEBg5Qz1Ha/BjR7tNUnvwqPs2WMb3S7V+5a/rHk64NHHMUDQRTEb/PE60PJeamGhY2p2KzWmoSSMMwrXJwI45n2z3ti396WR+mNStZIBzy7YM5QCuAnGPYUavCNASgha79gwilj8ZiRnr0c1994vLbqH09U28jCRDcuZV7j7ayCIxngADFjXIGfeEFgsMs3EGvRV0xRqW6JlrhhxjClzU1bZWxVYMIlNErOlJGimAE//ey6VeXG9YVpvAkjlWHM/rIHjq6959BH0/I/t+fgju00qA3tFwKy8iiz8UlqsWxU3IoGISacXp7L43etevuY9lvjn8/yXghDJ4kP9V66aZLaZnr851DqpoqY1lwfRtDBMj0GYCG0vCu7u7N9PX2H+yqIIfJA/TpxSyRCpaLMO6n1xV2FuYRPAN0PO66w+MCd6GMuPsuzAaORk1K24g5tKuWUXQ0aJQNp6pzVbZBh2HjpHLOzbO+8LlPbtiW/dFnvnvST8c+XklB50rFyulCd7XCkitnRimN5/3/UTT7gN69JjjXi5Pf6zx2wvAk7CD4vnPiYXY1+2+/v4sFQk4riamE5ABInjn6HLsDWEHOEB9H/Tg0CjkS0A5OXIUuTSQcp4lQwhMsCK2NYc1TSHppw8vFYw/8ny/Qf36PLRdmlMwLdj30CjsEUXCBDggA9IoLetx7xNVGgU4CTA/VGaJWobxfz05UcvAxo2yJRks0VqBShVnDC7jBLV98MHHD9e/7yf6f9q3qm/Nrb9eHTyNJbPj8qrR+ocdzqV60R3AA/GE6spe0A1NNnO5vO0fd00A2vcrbz6HubuoaZraHyQL+MHstrZwPTS9IcnafUx0ZfH2gUtj0vF7l6XcXigsXLf38ue9fkFirWTue3vfy+y98mMF4WvkY3BxwQISI6FvqtZirOQqA43WhAa+Pzg4WjwhdBTIq4jxniEzQaJZ51zVxWjvsMgOPkSnoT/705X+j+++i+EK6+Nd041x6m6vqA5wmEQCCxpRCAS/Cl4A+1kIo/pD+WOsb1+FhCE83HCgHx4UR9o7ERkDScQR88tyvP9n3ot9QF0FoilQe+QAN3T/52BPv51+yY6jjj868caSUGgYCOqjUeeLXk65WQfvfTJ3o3ClTDTXPqaGHNp50B80J0q3LFzTNm617opYgrUGOV5j1tKpalnN5Ts9wvg3Sc8+++rHDn9v5ysn34vOlCDFHagN4U9lOARbBKnOC7HNnAKjbgw0mlkl8Ce8TbK1c+yOLM8ee2aBqnv4/ZSyIH5ab0R8AAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDm4NLR2YlFPzH7wz3q6mkoB92Mf8BH+FXIIyP4V61P8qgkofwpXGZ/9lL/ALNH9kr7VeM8I6h6T7VB/dk/z+NFwKg0lfVacNLX2q4LiE9Fk/KpRIh6RyflRcDPOlKf7tJ/ZgHQrWgZ4gcFJAfcVG1zB/cf8qLgUDpvutINM+lXvPiz/qpP++acskZ/5ZSflRcCkulj/ZqT+yx6rV3zY16xSD8KPtMA/hei4FA6X7rTf7OI/u1oG6t/7j0z7TB/dk/Ci4FIaeQf4fyp/wBkKgfdqxJNHjgyioHkGM+Y+KLgPiUn+JuvrVhY2xnBP+81VY1ckkNgfWpRHN/z2GP940AiQx8f6qP8ageMhiRIiey1OIJT/GrD3ORUohbH+qhz/n2oAqKG/wCe4/M1NGju3+tJ9cMakNrMeggH0X/61Rm0usHbKq/Qkf0pATmLAyUU47s2aqPJCxwquD/sCnfZLzHNxn/gZpv2O7HSYfgxoAaYm6hpx/n61Hv2nDSzA/596ka2uV+9cKPq5pgRwfmmgY/7Zz/SmA5Zo+8s5/H/AOvTvOg7tKfyNNMbN/HbD/dH/wBam4Zf+W6fgTQBbQRyrmONf+BYprW0wPDIv0OKrqXz/wAfCj6k1YEyRriXbJ7rzQBWkDqcGcfgSahc8cuD9RV8NHJysB+pUVHLGNvES0AVoZ0GQy557CrSSRv8qxpu/wBoVXgTg/u0PJ61LIdmOEX/AHRzQNE/lTEceUv04pyQzg5LoR/vmoY5UYbAWLnoXPFSrBOMEyx7fRmOKAJHmjj4Zef9k1WluFfHls6f5+tWfk7pbZ+v/wBakKZGRHBj6/8A1qBFH985+W5I9ixFSCC56/aeP981K5VescH+fwoX5x8scH+fwoAj8yJOJd8jevB/nR9otR/yw/8AHBU3lP8A88rf8v8A61L5R/54wZ/z7UARo0U3+rtl+rIAKeI/+mMP4f8A6qjNtcZ4lVR6ByBTDHMv/Lyv/fw0AWwiBSWt0P0ANREpKCIoAjerIBVfy7kn5btf+/hp/wBnusf8fA/77NACNBcDrMAP94014Zsf67P0Y08QzA/NIrfViaSQFRyU/A0AVY0kycSYGT1Jq3HDMRn9y4/2uapxJIScSLjPQmrS29z1EoA9AxApjRZSJu8MB/D/AOtU6xqRzAlUY5PLbEkkjn0U1bRg4+VJx7g4/rSEPaL+7BCPqP8A61QmGbP3YMemP/rUyVJ0BJmYD/aY5qDzf71xL+H/AOugC15ZH3oYvw//AFUhCKf+Pf8AICoPvj5ZLk++f/r0xkkjwzyybfY80gJ3mjBwRKvtux/WkVGflZCR7SGliaOQcQs3+04FK8MpB2LEnuuQaYCnCHaySsfc5FGEPS3x9QKi+zXP/Pdv++jR9luO83/jxoAV5YEOGhGf90VH9ohB5V/pjj+dOFtOf+Wqn6sTT/s8hXBWHPqB/wDWoAYJoSM+WfyFI8kRHER/75FOFtNnhlH40klvMo5f9TQBTgmh5BiJOT/CKuC4iAxsmX/d4/rVCGKUkkPjk9zVtbe6bpNgf7xpjLsZjZci2Y+5UZqOSeKJwH+0pnsDx/Oo1tbwji4/8fNOVhA225V5T2yu4frSAd9ttSMGN2/3gD/WjzYZDhIAD/uimyTQkYW2CnsfLFMSVd4J4HcIuKBEgifOSxC+iNilV4iOYpX+oB/rUyNHJwsbH6jimta3BPySKg9AxFIBjFSOI7lR/s8f1qNbiFTgmYn/AGz/APXokSaJsPcHPoGJqVY3kUMqwsPVhk0wE+0wkcLJ+H/66b9ogPHlOx9wDUhhl/55wD8P/rVC1rcA8SIPoSKAJAUb7sAH1AFNaOTOfMCD0DGomjmXrOB/wM08TRqMOAx9ev8AOgBRFMfuzH/vo02SKYDmTP8AwI0rvj5gxVfRTUTygjhn/E0wKkM8Y6qx5q2l3AvGx8+3/wCuoIYjgjamcnmrCWkzcjyse4/+tQND1uInIVfOyenzf/Xp7W9wxysuB/vmj7PLjpEp9V4P8qgeQxsVeaUEddppATfYrw9Jx/32aUWN2DzLGfxP+FVTOD/y8XI/H/69KrSkZ+2HH+05zQBeW0usY84D6MaGhni5eZiPYk1FDKU5kleT/dY1ZEqzDbGJFb1JwKAGJLCF/eK0jepUGmlWnf8A0eQRj+6Tj+VT/Y7k9JQP+BGont5oQWllcj1Q5xQAw2t1j/XfkxqJsx8SSXGf8+9LlnPyXL4/22xSOsq/euAf+BE07ANM8A6ox9yAaQXVqT/qs/8AARS/ZpZBlXQ/5+lPjt2jB8xEcew5pCIWnizwoA9Aopkk8JXhP/HRU0kkC5BgKn3QVVYhuFK/iuKYxkZO4/Ow5NW4opnBKTcf7xpsewHlBnPoKnEEpOY3Cj0BxVDQ0h4iPNkkP+6TUivFI2BAGPqyik+z3HeUf99Gj7NcdpfyY1NgGtbyE5CQKPQL/wDWpRNbA4MAz/uClFtc/wDPb/x405beZTljC/8Av5P9KBCedCeEjVfqop6yoOS0g/3eKQPEDgpFu9iKVlZvu+Qo/wA+1AD/AJ5R+6knX6nij7NdfxT5H+8arF5EbBuc/wC6xNJ5r/8APw35mnYC2zRRDDwkn12g1XlmifAjXYf90YpYz5h2mWVvbPFSvAWwEjjX370gIfJnPAmUfRiKX7LdD/lt+TmrIiCjDRhj6k5pHAKkIhU+ucfyoAptE8bfvfMf6cj9ahnaPbwjJ+GKleG5/wCe/wD4+aglim2/NIG/EmnYCRCASccZqRJ0H/PQ/jWeLgf38fjTvtKgcF/wqiUzTE0Z48sn8KcJkPAjfPsMVlfa/wDakp4vVA+635UrDuaZYf3ZP++v/r1ESM8iUj0Lf/XrPa8B/wCetRm7Ges3+fxpWC5qbo/+fZD9QKUPH/z7L+QrIN0D/FMKBcj+/NQFzYEkX/Pqv/fIp3mRH/l2X/vkVjfalH8ctKLtf78tA7myGj7W4H0wKXJPSMfixrHF2v8AflqRLuPvLJ+f/wBeiwjTAkzyEx6bjSSuqj/VsP8AcNUvtcWP9ZJ+dRvfwL1Mh+tOwE7XEf8Atn6moZZUIwE7elVn1G3b7qnPris+71JQoKAdaErgf//Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 83%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 10/12 [11:55<02:06, 63.15s/it, test/blurry_cossim=0, test/loss=1.49, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=11, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.725, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000172, train/num_steps=1672]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 92%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 11/12 [11:55<01:03, 63.17s/it, test/blurry_cossim=0, test/loss=1.49, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=11, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.725, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000172, train/num_steps=1672]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train tensor(99, device='cuda:0') 99\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACAAIADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDTnYQPlhxVyzvbS6il8t0YuCAA/AIpdYtMo2B2rh4F1DTtVgjszGYnlA2SnAGeM5rKrSUjoo1XFWPRBeeRcbUibeq8rtJBznnPT1p7PczyiWC2DjGBtb73HB/X9Ku2VrFFJ5wleTLDEZAA6cc4z1H0/WtErmR0CMiEqCCp+bI/MDJ9qy3ehSu0Zmmmext8zWrorZO0AZQAegrjJrcaxYzpIDCs0jSPK8bDyyp4446j/PSvR2hmQLLvUMowQRxXJeMrS2t7qK8Ty5J2GDFIxGRxlgo68Zqt9xxfvWXU84vtKms7h42jfCIHJ29j3PpTrbT3jmUtbsZWcBTGwbafwzn+neushsLiSRzDLN5coy4UAEe3zZPSrenxO17awTx7pDkkkFW7/mB1qeaJs0ktWa1q0sYtfMaVpRGN5lwG59QK6BBkcVi5UzyfeBU4wxGa14H/AHS/SuqB58zzn4kW3kavZXI6XETRkehQ5z+TfpWL4RtYL7xfplvcAmMyF8bd2SqlhkemQM+2a6D4nyb5dGgRWeV5JSoUZJ4UYA9ckVf8HeANRs7yDWNSmNpLCxZLZQGdhjHJBwM56cn6VbsrEok8ZRvBr9jrK5CDZHFO3+qiPJyy9e/t75qj4700+Ifh/LquqWf2TUbJfMjII24LDIHzHIYAY7gke+fSrW1JmuBEHjVCCQE2q5IyduT05rzv4twa5ceHQtjbO+mo+7UDgF1UFWQ4/u55OOmBnAzROakrG9WtOXKpfZVvkcBdSTXGjaXJNbhD5TKkiniRQ3X2Ocisw/Jz+lajLIPCmmss6yRCWVTH3ibg4+hHNZhG7HbJx+FVWu5XfZfkc1PSNvN/me5aoY3YruHSuU1K1RCrqCzZG0epzwK7PWNIkgmPBK9jXI6m8lpMjlljRPmLN2PbrWdTa5pT3Ou0sReRGy7kMYA2gY64JGDWjPqn2dwm0MQMsPY5wSew461zFpqX2mOAxSgR4IkxjAG0c9OeffvXI6z4leHVdVtrVUYTxxxiRmLEAKcjBwP4j2/OuGGj1OxxUmdPqXiu5juGRpLcQMrnKHJl2jpnkZ5HT1rm7nxUJ5giwLCrfONzBjk9s+lchLIR98njpk12Xw+sIr7UVa4h3rEhYEkFSMkDjtzv6+gq43lJIJWhBtGvo2t2VzMTNcxCVVGWA2g/T/69as+rQLDuguIZXttxMic7GI4BGam1rwvpVxZMkUYt5AS6OnZq4630ZbLZaQZnmY8kDlqt4azuzONZSjY2tMnknkUMcu55rqx8igDtWfo+jmyi8ybmdu3ZR6VLdSTXt3/ZlgT554nnXBFqpGcn/aI6D8SMV1Qj3Oab7GBYwt4i+IsV1sL6dpI2JIOUebGTg+xKg+6V6O5ZcbRkVnafptpo9lb2NlEIreIEIoPT/Oa01AbGTis6kryBKyJYZMDGDzUyxo0ZQoCrZBBHBzUYAAqQShRx1oQHg/i3QdI0a51DTbFZIZbW4RkDOWEkUiAjGf7p3D6HmuRk2qWwOAMV3PizXY9WvvEkbWvmLbXkMdpcohPzbEVlP/As1wTgqfLPblq6KqaUX5GdNP3u1/8AI+ndN1nRvE9k02m30F5D/H5bZKZ7MvVT7ECue8UeBIdatCkUxR15QNyM9q+bY3ktLmK4gkeK4ibdHIjFWUjuCORXc6d8ZvFdiuy5ltNQXI5uYQGA9AUK/mc1leMlZl2a1Rdk8PeL9AVof7OlnjUfLLDiQY9Nq81zP2DV7qchrC8MijaN1uyEgE9sD17813kXx3hcgXHh4r6tHd5/QoP51Yg+Liai/wDofhm7uFHUxSFsfklJ0YvW5oq0lo0ctpngbW790S4ia0tlYndIBnJ6kDr2Fek6Jo0Xh+1FrZRSzOw+aVl+916np3NU4vH0j5P/AAimsg9vkXn8yKV/Gevyuq2fg2coesl1fRxBfqAGJq404x1T/Eic5S0sbL6fdXY/fyCJe6ryfzpsv9k+HLRp7m4htIjy0k8gG4+nPU+wrLEnii/2edqtnYruyy2NpvfHpvkJH/jlS6b4W0qwvxqMgnvdRzn7ZeymWT2xngYBxwBSco+oKLEjvtV165MemQvYaWAN1/cRFZZc8kRRsAV/3mGOeAcV0mj6ZZ6NYraWUXlxBixyxZmY9SSeSahNwiMPmAqQXK5++Bik5thypFpjmQD0qwn3aoRyh5CQQR61fQ8Vzyd5FD8mq17cpZ2k91KwWOKNnYnsAMmrGa5j4g3gs/BGqsRnzITBj/roQn/s1XFCZ5FpV5rll4a1iaxjEkcwWSaQ4JikDbgwHes9r7UPFUkl/Jp4E6IPtEkAODjoSO3H8q2dEtdUfR9Vns2RraKHFxEepBB+YfTmuTW9v9C1dNRsG2OnJBGVYehHpXVOXuxIw8kpzjJaafl0LGneGNa1/a2l6bPPGeBNt2x+/wA5wP1rudO+Co2q+rao+e8VsgGPbcc5/KvaX54AwKrSYBwoLOegFYcqLucTY/Dbw1pzJJHYb5FOQ0rlz+vFbgtoYE2xoFA7CtRLS5lmPmL5cQ75BLf4VP8A2fCBymfqaegrmAxAGTxUJO5wNvfha6B9Nt26x/qaSOxhgJKJgnvnNDC5z89yYX2lSCOoIqA3UhPoD7V001pFOAJUDY6H0qqdHtiSSX/P/wCtU2Hc597kgdcn1qI3km084roJNBt3HyO6t2JORWPd6VLASpBPpjoaiUWUmixoV15kTZbJ3kE10kbZWvO7O6l0i/ZJEIhkIPPY111jq1vLCrmZEz/CzAEVnFWBm4K5Px7pM2u6N9ht59kgYShMDEhXkKfT61sSazaovyyrI3ZYzuz+VVoDLqErzSJsYcKM8fT/AOvW0WQeT6TZajBHrTJdfY5LaAia1lXBkQofX2yRXHS7n3Z+ZGYKfoK938S+GLPX7Fll/dXyoywTDOVz2I7j/HivDtT0fUdEvfs+pWzW8iglQTuVgeMgjg9Pw6VrKV4pdiYxak5N7n1FdpOQRAoZj6nGKks7U20WHcPI3LMBjP4VaC7RjrSEgVIxCKYQKGkwcVUv76OwsJruXG2Nc4zjcegH4nA/Gk2krsaTbsiprerRaRZPKxBlKt5SnOGYDjOOgzgZ9+3WuWtPGCw3zI8bTRzT4IjmaXyQcYI+XLZz0HTgYznPP61rlxq92biUKiquFiXjA7jnr1Iz9faqQUbhNlAQ2AcKR3wCDweQfzHvXJKq27p2O2FBKNpHqlvqNtdRLJE4YNuAAIJO04PT0yPzHrUqzxMcbgD715CxaxvFkgc+fbuPKkTIJwMDg8ngjg56+9dZpfi8yz29pq8C/OdpuwSCxP3fkVSOT7gVpCrfRmM6DWsTtwuaGjDLtYAj3qvDIFQSQSLPAf4lOcVcVg65ByK2Uk9jBpoy7zR7e4HKZU8EelUU8OWUbEIZAo6jdkfrXRHrUDRhOV6elVZPcDPj0u3h+6n5mrarj7o/GnYLHjp3NShQKLW2ArzQCXqfmHRqwte8P23iHTHsr5djLkxTAZaNvUeo6ZHeukbpUEqeYmOjDpVIRuGoJZNvTqanaqzKS+ahjGDOOax/EHmta+XFI6s0b4CYJ6DJIyCR9M9a22HFYuoy/ZPKvpQHlt1bAVSA27jtnHbnnFZVG1G6NKaTkrnB2vhe1t7VViRbf5jsWJiwVFOXJ3Mf7ytyQeTx3FC+li0u4utPhvjLauVVs8eYFOV78kZPfqe1d3C9tchUaGICPdGJIl6q3DDAPfjjkcZqPTtD02SQ39xYpPfwHhjKNpHIX5VwoyPbj8K43pbR3f8AXQ7vaRd3fb+keaR3NzOwisdMuLoJF8yxIzBM9DwOg561DFPqEkMrPproQhywyRtZV6ggdQR+BGPf2u41zSrBfJa4iwgwY4QWK+21QT74qSC+g1ewdoBKI5AUBmheI+h+VgD3qlTk9iPrC6op+D7edPDVs925eaRcndGUKqOAvJ5x69/1OmU8mXA+61XQBiop1yh9q7IQUIqKOKUnKTbGEU18CJvwpUbKg0jDKketWiSBT/8AqoyTyRSH73pigsRwO9UArHFQlueDmnOsjAAA4PfHFZGp6o+mxviFZZVTfsMoUHkDr0FAHZsOaY64Y/WpiOaRlyM96Qiuy8VQuYA/atI1VuH2ROwBZgpIUdz6VLKRzt54dt7vcxDK7KVLKex9R0NV7HwtHZxqj3t7MFJxul28E5K4XAI9qZH42tG1aXTH2JKAfKlbciOwBO3kcdBzyD29K2THcBnH9pSfeyPMjTAHGRgAHHB5z3PPTHOp027pXZrOFSGjFhsoID8kYBPWrkZAwK5a8W8e4S2nmuGiHG9blFeQDG7KBB27DnntxWUt3d6jpwhe8LWsiHy7hJdhl+UEZTAPJ80cEgeX2zirhWUldEulJJS6f1/k9z0hX4pk7hYmZiAoHJJwK8Xikn0a782ynkifG3cjYz+HSuw0jRNQvkN3qU8yM54Lsd+38eQPb9KcavN0E4W6nUJewpDnzFIz25qGTVokY5ZFUdS7baih0KxiUALJI3JyzkdTk9MCrklisVo6woqHjoO2ef0zVq5LsVX1NXQEBm3DAKrkfmAaDqVxErBLVmPYgDn+VWIIDjB6diateUqjmrs+4tDBfUNXnQg2SqT/ABLJg/lisS4tdZvrllMUDxlDG+4EAKevKkf5Ndm6bzg/d70mwINoAAFKw7nQGmE44pYpUniEkbBkboRQwpklOeTYcdKoyymtGaMOuCOayLhXiJ+XIqJFI8g1vwlq0GtxXEBPl+cmxlYZJJAz9c46jv8AjXo92JLGSF0AuJYoWJkKEEc5JxkcEEgcnB5qPVbKLUza7naOS3uI50deoKsDjnjnGPxrYIW5jkjmJeKQ/NlsYBGD0Htn15rjVGzbR3xxW3MjMQ3McLs93IZkUDzWhB565CkZ454yecVz1rYMdUWMbka1ZoEgVVVfLCAqNqEg8ySHnkZ6A12Hkq1u9u4Zo2BU564yT1/H9Kh0rQ7S01e41GIytPKR8u4lPugZweh+909ea0hGpfyMJVIu7WjZjW3hSW4u1uLlTDCjA7CPmkGenXiuxS1MjB3JAHRf8asrCSQz9fSpcV0KCRzuTZEI1UcU2QfuzU7cAk9BVRpN56fhVokFAApDzx+lShflqMqM9KYyJ+OgwTULkd/wpLq7ht2+dxuP3UHLN9BXH+KfGA0G23TlI5pUP2e2blpe2WI+6o/XpmpbsNI//9k=", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAACai0lEQVR4AW29BXwc17UHPDs7sMwoZtmWZNmSMTGHucE2bdo0fSm+Mr0yvqbcpmmKadMG2iQNc+I4iWNm2ZItZmmZcWhn9vvfVfp+73vft3Gk1e7AnXPPPfg/5+q+ef/zolBi9VQxnwvU+fR6nSSWcomyyWlvrW+am5qwub0Mp1PlCsczVU0ni0XeZq5WVFFRqEqV1Ve1qkZXtbrGeqWi5kQmm6tWDHyVZnSsHpeltGpVV61SlE5HUVWqSn6Sv2r/4UOa0uFP8kOHI8hX+IbSyPG1E1bOW/kcJ618hsvUjsUxtW9qd/j3R1VNw1VoHe6Mi1VpckWchmvjHuTi5IWvyA3Ivf/9HXlH1y6o4TuMGoeRu+AQciKlo7WKVhsVuRb5BN9g+OR2OA7fr1y1diJF47lxazwIHpq83r2RDsPDVf593SqdU0oUr1MqEmvm08ncwlzIaLM5nE5Gzw+fHV472CNUFIZnOAtvsVsqLK2q1Uwq09ZR7w/6imUxVywbzKZMoRyNxSqqUu9zWO1Gjuf1LINbqhgcXXtIcksMAQ+Gp8Zjkocn1Mdn+ITQE8MnT1kj0b+/Ik9JHpYcRt6++56cVDt45StyYu3pV6a6dnEcSS6Cy64QD6esXJz8uXLzf3/y7n3JwTVikvGsHFQjce1eZKggqI7W6xn8o2mG3JHG+Gkaj4qPGPKJjsZH4EYyPPzDzFTJDOCp8XggBLkIuQYO04HV8YbVfeuPT0gFlTVy5GKq5vTZRY2iZX18OeLzO60Ws47jEvFQY31dPi9UmSoHcmg6jjeEEiEMpCwKzc11Urki61U7b5AEdXxmwRVssbh9Es1omgpGrBEDRMdvwg4YDaFejSTk57vkqH2Ai9eISsiNfzXSk4/wYY2ShHigDv6RI/73qwqGx/PjSPLF/3yJexEagDh4PnI5siDJlckRIMrKsbXrk0/AnWSghBtqZ+no2uIi98M5NeLWJgTErA0AFydLmDwYbk9mHO/JYN+9B+aAXEjTKuQX4TIcQ6sYA87ALFQpRspknTZbrpCrb/BbLM5SsWhzslPnpm1GY7GYrmgiQzNWM0tVK8l4ONDgtfFOEDYcS2iq2tRSh6VT7/YUJV2ukC6LRblSsVtZXTnOcDLraBBZvaqCZJgD8t+KWMAo9WR8ICb5FL8IaWpLg9LXFgoogefBA70rn8BZNcKTRwNxyEziHJxUO5m8xbuqfoX0uBvevPtd7dqYOvxJTgWJanSrvcOVID3ffYuvyQGEsO8OBaTEsCs1StekCZkEDTeraApV1WNMK5eFvMJ/ZPnoqiqhN/mA0ulrtyTCBn/p8cwMGRi+xwGYFjIMTcUxDK3SsUhGKGWsVmsombWYjWpRH2htNNBMuSRwjD6dzupUbnxpimMZl8tXyghmzmwwGkxWaywcrVYkIZtWFJpiOBpipyJ5fF6r0WIyME6vczQSl3QcRkGrZPh4RobM+gqBauOvja/2HWEeQnfybW0p4/Aawcnj4MMaAckPvHAtTBlmC29rJ9Q4mkwwXlgLtd+EloSquhVexntCpNo5uCD5DseTJQNSEOlACAr5UPsAn1UhIMgvoknePYvMO64KafPupUH3lQvgA3JpMFaVrnEXBqHimWtjxU8yMpxJVAheGo0h4T7kayaZLXR2tbW1bznyzlHGaI5lY3qNMXJevcVZLibNXkc6kxrcsB5nFIu5YqEYXg53dLUaDAY9y06eW7K5LKlcrgI9wbGY4ooiM7wlolAms8GXyTG8SWYcROJhrZOnIPfE8lyhco0IeDy88AGhGn6RQzE08tTke0J68sWKEMDga1/gDHxBlBm+I3NQ+41HqtFhZR7IIbUnr75Lo5XLkSkh9yS/cF7tHW66MiTyF+6PC4DuuCZZHysjB+uS9+Snvia4MC/kG/z795jIG/IchK/xyGT+yDmQPysDqx1N3uK2K58QAcioWlhXDSxOzbA8V9/kyqd5jpIg66dm5wJ+r8Vq9dcFbWaLob15fGxMU2WdnlpaXoLecXoDvRs2h5aWLUbcVanqVFGSTEaTLFVFsVRRK1aTSa+pBrtdqVIVHdZspSYZcdP/IQWhF56AjLP2k6ZgUBE2I4TA7xqTYJjkLTmv9oNMCSEcIf/KFcmDQnG9S01y3MqBOL52hdrh5FtygdrVazNGPlm5VG1EhDLkBBwDbiCzWoXoIJOAr5naylg5nRC6NjxyOvl25VV7S9ZuTeyvXJzckKkJn/85lJxLTiM3wi9df/eqRDJDWfmLL7507ZruaDwjVY2DO3cyOn0+Eja7bZlMQZak+vogruXyutLx9MLCkt/vsjoD4FaxlJ1amnXbXEaDUSiXdCyHtWs0G/QcDSGGyS+qeoPNVtKgeTSuSkPLkSWwMnTywCvv8AkYtSYKiA1BWKO2Ev79PcZamyEy+hoJ8cW78/QutWuKb+WCuCp5QFxjZT2RQ2tP++8fKzd99xjciEhnfIZXjTpkCZIrEYZeEXP4hhCdXHOF5ORKOP///cKHtdvW7FLyde0gcg45kwycXIOMu/Y3+axaZRSxZDGR+R0/snd26FAkUV73/hu3qOKpofO9XZ0WnpnLZ+v8PqvFqjfoz5445rD7bCaTzWoXCgWYnt1d3Q6zVZSzJpPB4XFi2ZVKqoHD1Ogi6YjTZLexBl4plhVNb7TiOWGMrIhz8gDEKiAvjA2014gWxYrVV+E9EB4kdHuXAYkS/vcDE/ISipIDyIfkfzwJ+RDH47VyIPlZ+792j5qQWbld7WucVKMFOR4vooBq567YUYTHcTI4oTbtOJSctGIR1W5C/lw5hFzo3XNXVgbRq2S4uHuNwuRrwnLkOIgmoq/Jlcndyfe6no42uaIYsHIgRuA+GbioJK1u3HjVXXctLIdb21o6WltmJyfA4KBLQ8AfiyUKuVIymZAU1e0LWu1ui0kviNl4LAUa6HWqnuZEoWwwmYpCycgbVEWExo7LuobW1VjJVFUlj0vGgyGSYZB3GDoRKP8mCbTUyuPiyVfIDXlUOwd2BJk1MmPvnoqpI5Qgz1t7xNqbmgFTuzL5ihxcO6F2z38ze+2cd09aGQi5Yo0qK8YXuRy5JvkUL/zGqFb+IiQnw8VVV2iJj8mNa8eR9+8etjKk2u1xb4wKQhNf4fr4DMxFRr6qrbGiqVyVV3WqQin4gtHR2awkm816hv/0l+5JhRdcPu9Fu3bNDE+0dtYnE2FVVqZmo1aLsaNzTTyTVcpCRRa9Db6xyYlqpRLwBwrlgpHlRFXJJTKrulqzhZxeb+HcPo01EOWG25PRQ9zXDBHYblTVwNBSWdR4Ix5SD3OO2BOEAmS471IQz4x/OAunQ6DhgSClao9de/B3iVR7NPLBux/W/iaXwUSQ90Rb4H4rgyCUwifkhbusEJSQZuVT8jeZ+dr3tcNqBK0NilwOn//PbP6b+rXbkkuRN7VzcCty85W/8AunkK/JBJAHYiqSJKuqBhHAUPCadDq9qEk6Viel03qG++13PpEXhI9+5DNzLvf5C+MiVZHyxc0XbUhkpVw+x5nYgMFRLuidzqaRCxOcnuMMhuTyIqPn8lre6XeVOEaUwbOGYMAbSiRs/sYK3GMyAJXBGziDMBo0MZtM+ILOXGLe2dQH75mlKBkybIVq5EEIp8CQBrmJgoMZRyYHT1V7TPIw7z4e+U3+1R4Qj09ECKF3jYq1U2o0xTH/Zu0aiWrTQWak9obMDTGDamT791zgUuTU/zmiRj78CS2NA8lIV86tXRh/g+AYRW2q8J6MhxxSe9UmjtwLrAZ20gUcLr2BSCY8nyQp+FqQ1bJKGWkerFihFUVSYXjp9ZTBYv/xz34bTqR5m6Oqguh2r992/sKEUCz3reuN53IQZVaj6fBLz3pa2lpbu7L5lIExWixW3J9hOBB7MZlsaGmu6HkoYj0ZNnxyXTkfU6SsVI5PnDq77cZP4hEQxKjoa4oYTFLzgYjYWaEq5qLGTSv0Ih+SZ8EP2KRQmCsHEYarEYUcSo6Ev1qbO1CgRg5CGTwzjga5cTZRNYTwZKpxCr7CC59j5sjf5CIrL5xHboF/K5+sGA5kHZD7kUGuLB4yAnIYOZtcl/xBjqiNnZwORqp9S9NWu4NiTCWVEnR0keLy+Sqt8jQlqwhQVEpYGryep1g8n1TORv7rax9b09PZ3tKCkRby6fDycl2dH482PTYui4JcLoBscBOXlxZK2UxocTlXKCbiiWg0Pjp2YTk039oUiCzPs5BxRI5gvIQ7PG5XOZPR5IpQSBlNiKiQZybUwQHwmYkPQTiSaAVwNA2mq7mhsNYhNXAYXuQNDsETqaBA7Q35ievXnhs/yQPjExyPN2Sy8FGNbOQuNSKvKM7aT0wGLlW7Dpmidy+Cdyt0xMVW/hEi1t6S8ZIBvDsUXHPlH6aHsHntarWR4HjyBxlbzWsDyzBbr77J521EtCFdTGp6av780OGXXtZXoCs1VYAzJ+BQiCY9b+AYRimV77z+6pJY/tLnvtp30cUnT58avGibppmKuVSV5ouZpIG1W/TMliv2LM+HGzrac/E0lkC5ILrdDp5js4kkTKbwzHRjezfWGondUNVUKJxdnhPUDFZgJZvjTVbiYGkqITCIVZMh+Fl7eggH4hu9+wfeEQrgsfE/Yb8aXcmk4htCOjjL5AchYu0Q/FFbP/hj5XMyM9AmIB+x9sl1yA8ydeQ2RGMS6pFPydXIELDManeEF4ijCFXxGESAk6MIcYlvjUkl4R7yql2mdiJFV+iqXq1UyG1qs4V7gC2+94t/lItZPO+JN18ZOvMG2AIGIa/T49EqWrXCspqsQOZiCPiEI8xHRsixbF4S/+t79zR3rB47d8HjNJhpazyekqwOq5mqr2/KpnKeJl8+VTCZzJpOVSU10FSXikRNNGO2uzKSoLe4VJhequjks2cOvJTOxRLzi609u3u33QipgztjAmqrFndeoWYt6FKjR+1RCVHwhCAAYanag65QACdiXvHQ+B7BcrAhGIjQitC39sJ1Vy5B2H/lC/ivhExYbLVT8ZaQj8Qnas9LblOz1MhBOGLl1vhF3tROwVuyyjDIGoHJnzWjm0w1/tPpVK2CJ6pNJjkQ59bi+IyrKp09eeDNA3v1WglXwsoEX1bgLtVuhSCc3shKkoixQWRTKlQqpk+Pr00s87vvfxuH7bji2q4PfSiXEOpXu1VBbmz3p6ORpqCdxkR6HVpZ4swm1UyL+YJQLuQF2aPXGc0OWadjaUSt1QMvvqooM5FQiqX0Jq4Ca5iCDUDIUDOTyI0Jf5EBkSGtUKBGOMJz4BzwBJi/gmcncRgcSMJh7xIbFyHivzZFhBSEeCskJIRf+ZNchXiHRFoQliSMT0hbuwSOwedYq+R48o6cjfeEvrUDwMYqYYDad7VL4Ja143EJrCRY3bIMK4NiFKmiGq12M++AQiQWHI1p0Jjf/ekXyURUq0gw4WtzRitYBSR2BrNUhbgmbyp4CjJyIo3BVVUd1DWyLQh08gz9xhsvwn37+CdvLUnJ0Njo4387JYj5ltb2j37286Kikzg9BsRC8DOaycorrAZLSaVURMLhFcP6bGr1nXrnWDlf5hm2XCgbeL0g4dkIr2AZQv+D9ciyrJGO8CMZSE04gCXA4HqwHY7BP3Dcylol/F0jFcZOKEZEGaEinG18Qj7CATUqrihfUIpQmJCdvAj58K52Zo3QZG7IiwyEnE/GVju09ubfE0VOxBdajSMwMnJDfKK98crzI8PHTWbW5/OtGhj0Wurcja00Q7Jb+J5JhmZwIENUEom9VtUKo2fx3NVKlQFDIbwmUUg44L4VGCfk0cAtGHBVqWgwV0TcgabHhvf+6vtnqrxBluUKY1QKOVzvU3d/qH9gy3996XvxQq6qlUx2S5vfc/7MGVrnoVkeF2FAOVWkpWImh/SaUhcMZPNxVZRZhtUUTQWXQBBVwNa4MyYChitoTHw0xH3BPwpUMuFXPDgOwKcYNJkKCIuatUqULFbPilFJFlHN8gHnEkoTQhF6kRNhpOEg8DBIoAPHgsOIRiE6iLBb7cyagiEcjVPJ1BE2IL9ra4XcByeDeitfY+A4Ed8SqaObGDuVToflsq0+GJCS8enFZZPdYzCYdDwEJIJx5DqavqKrIIxQqeC6uCbJS+jBuVhLVUVHV2SiORiWxeOSKCt5CEIGokUwVqRdaJ2s46qSli4WeEYJ+oIuty0ylhkbufAfH3n/6jV+A10yNa/+1H98qndw6/C58WCHLy+IVYaFGEoVJb7KKlUZNFAEnE7DjsJ9aVmBDYQ3nJ6XlUqN+LgrnpW49hDZhFk0ShWLB155meVNu6+7njwLoSaZFgwYJ6ugTI0TQVBycm3+yFHkQEI1fY1seCTYeyTuU1N+mGq8wIFsVanqOYnWjBXIGaKaMb2gi0qi+yQ/iZVTGw4R/rVli0uCKzC5hDJgFxaPU87rVJbXU5we91EoTRp551WD2b96z04WIVPMElIMeBCIMj1WD9QsRbNEjeFuGB3+xF96vEictQJWxHKAjMYE16LaKrFEsJqWlsOpVMbImhVFm52en52KfPPr300kkgZalvOlzvamb3zrPzi9gWUNA/09Zrnsd3AOvmpEwNpqFumC3WvJZmNreldFw9NwP/SawoNGqgYZWFEqhOvJLIOx8AxgFrJWIV5Ls+M/u/uDZ5558txTD/35u9/iYWhAcCJ3q8OEgQggBWiBSC38PwX8haclawIERJ4IF1SxBCuMBq9DZSkYKTgeUhezQNaDnlyNJIJZsCNO1GkIuBMzmTw8FgPhcZCfCAeytsgxuI6+KjPkypC1CqdRRopOZbKyXIIdr1aETDaDJRZLLBUKMcx9Vq7FymtTRTQM1iUDtsFkgPwYOR6WEBq3A1eRRYnxYI2QZUuySbV3GC5R7kRMCYIYjyfEYqmpudXv96zr7a/IMmexQGFA/1A5M/QARC1nZBubPQwlGhAZkoSetk4LQ9sY3syblxfmbEaTKpU1wpEYAf5hWcMuwFMTZsPDYlETYlA6jqL/8qf74eCBdkj65BOzegnGM1HdoAeeDEPGCQjJkierSQzMIH7jSWpSCo+MS9bYmtiNOIs8qywLxUopXynImDOCKgDrYTVhTjD5hOfhwOOyJK4FbxJviCQDL0IeY3Qc8SMJLWmsX07PVkoZTcEcg8mpkiDD78cVedbI6riSKCDyRoQ/Bgi6qBAuKgleE8rWJgEzi+ckl6tdm1io4B3ckdAFj0Gei/wJu53W1x4A/jJRZ4sLMwGfZ3Jiymzi0/GUqS54yWXv0VUNZN4YeKxUQUiXyokDL7x+/Yf+89Nf/HZji9niMpby2QaPW5LKFptbxoSpGs9xlUqFAREZHRYWmQpwL4QBZEVFzc9fKM3OsbwZERChqiAffeC5v+++6S4RR1Uok07CyGUyImiPmj4grAoKkEnFhILgNbGBv2ovssaqT7zweLgchxbQg0g0Z0JSXDOu7lzd3rCKKpSQ8mDNJoaQTafIuICOV4V0OiNpGsQzrF8zayQmTFWnlMuZfObA6AWmKjR7PCBnuaJY9IZUOGHxqn63TdVKrz/7yNU7L9fZcS2EhIhwJ0QFScnIMAl6LFBcmIdQ1RSJDB7TTwRqbcS4DfkApCDPRr4hf+AFhqEdZqRwmHw2F2xsqYhlE2d6Zt/TilCFtwvtCQkH+VpWS4lYbGkpvu+Jx0oUVmi1zm0y8lrHukubGgc1xmxmtExWsLpcSHNiZIpKnA9Kr+iQk61WEd4+/ubzL9z3J6fViRDIVD7e6QmuaQ8a/M2XX73d173+4DN/SyxEr//U52XWgkExCPYJQkVEkEkBFqEsyhzP6hH7A0djrhmjmI0++reH8yYxDVPbpLfbzTbQv95fjuYlqMCoUp6ZWdPeNbh57fnJSarCqHoLY2WbXHZw98Hjw4Obetd1NR06+KZUKjEmSyxZ4Vjt+NFTVqPRYGEVoZhSyla7J5/Ib9m+AZH3o6MX1nX1tHR3k7AAhgAi4n8oWbwBo4FVCbvhN+hF1A6kEEhP9Bg+rb1g+5C/aosD04bfZDXgB1aSnudioVD/hp5CTg56PC4Xr0uJmtWGCUViGR6JUi1pikqVS06WG1jfPx9KY7ixxLTL7jYpOjUb+edjL41NXvjgXXfgft3NrY///eGNl12NBeGp80IlIGXqsDlvvfSKp+/7fVkqY1qsDndRk8+OTnAXJqOjR4x2z+Xb12tm9cU//fDmT37h8KEhIZ8Nj1/o7+3Ve/x9awYWpoePHzvdv3Z9a0f9+KmZR195pqQqGDbd4tVYfTabZ8mTU7pKljboCoV8b0/92wde0ajc0aHDXCm/FI9WdEbY1tCJJRGAEPXgG6zVYiqLys6dO4Ne969//bMPf/hDJUWbnpuKpCY29WxgOTafi7Z0NehUZs+WDXEk0oViU7ABCgNLkvwHJl55BzoSahJZCQmpqxCxRY4gghW/8cLQyPAgQMnM4ViShwb1oQwgs/T6eCLZVr9qVf/O1159rae3cWF+4YqbP/DHhx5vbXaWyznIqKoOY676/A2lYjgnlDOl5J71PWajtbXD29Cxdvj0qXgs3NHYeNGG1rNHR5554m+uYH1PZ5fN48K0K6pSqWBF0vl8SWOITZATJEnTO0xmCFIjpzMZLYlQEoqjzutxVqnQ+VPtXodo1pUK9e7WrtXr1nF6Y2FYTJbkOz/xUUS5Lr/c8sfnnqryPALCWlExOJB0pwVMMw+oR6GCEIrdAlIYYSWVKx6DJSUU3XZfWafgMRjOXq0WmKpksfLIEe6+ZMO2i3bvvmJPKZ/68S+/cvk1H9EZ2J/88Mf//eMfdLa33vSeW6KxeGw5PDs8FBWKVt548O29ZAVAs0P8g7UhxYiWIlZwzZ0jNIbmAcICaV2QukZ8IqbwjqhBUKE2W0RnkGAM7CgdzVRpmDQqlYnNTN90683zF6YC3hZFjt596806Wl7T1/Hje++rCHAMRZvDb3EVmoPekqR952e/7+0dfO7VWDH/iMNfT0l6q0H9yF3fEorKXV/54dmht0oMK2az8HrBMAawiL5ayKWtJgsmA6s8JSSLIu3hWUWnJYtq3/bLFjPS6rW9nFygPE1nD58AjOy7X/3CU8/uD/h8+14/8IHb7jxz/BzNsxJwNBZjWRZMeq4qCLCGKb5i4U1YoCaj3i5WK3mN4lilKFlMtt72LnOVvuijtz308GORdFEsih63d3VL++QywQ/+9w++29u7PhxednrMCCZMn8qUw5HPf/pT111/VbDed89Pf21wu3MSuEf+/Jfv2nfoMCtWBrYPQJHj9W+eBiGJhU8YnVhANVITFUzCY1BS+IdfkFPEDMP8w/Yh60TFRaC0OBgMJk9758A1wY4rzf6rlgqOQ/smlxaFYklv4PmqIOMxxs7OXrb7yu/96EfNbR2ZTLKhs+HgK0evuebS66+8RkYcQ6nyVlMqtux2c7d9+uO96wesDvMLzz84enLosQcfgH3F6ulCNl9WtUQ0WdWzP/jlj/PlakkqBXzeslaIaMVoVVmWpOPn3nnzpTdO7n01PjVdKSiX3PC+D979GZ2jcc9VVy6GshaXO55OuYGuYXRWjp+emjZxrKwIiiZWKJnYHVlJH86Gjg8N7z+UPzvBjc0K4YLebMtqleDg2nuffWHztbspM92zYy1vUzQmboQbwlu3X37V1TfePrB1azSU+OpXv775oj3Pvfa01UYHAg0mk/WBBx+wmmwwrCxV9fd/+K3DZmvf3Hvvd+9naA6gBhUmHpFFcL+wjEkoiEwFsX80fED8TaIB8CUDoUOmqOblgOdh+IL9MVumn9//WkXVj40v8pwTEBWX085buVyubDeyJYE6ffCFidF/yrLEyJLZajj3zpl1q7c21bU+9eyvY1RCyy7c/p6ez3xnGLgWA2OmkDeThOTMzK5tFw+sG/zLP/5ldzmmlxcff+yh2957x+/vv8/X0HD0zXfuf+CvLPjWQEPP37571979Q0vLUUGrplnRRpnWrl0XzRWz0vRShb26PjAyMtTZ1f7o35/67i++/83v/jwSX7Y67Qvzs+n4oiHQRus4WpXIKtdog8iX5ufVUsnrMrO0zqlxTo8rX6G/+4tfretv//TdnwO3TJw7yxntuZxoNjtKhdzq1c3v+8jHpiPSp7786c994QuvPvfy5Vdfo6jq4ODmbbsv+fx3fvKZO27zM+apiVGzue5H93z63l/8/cLJ008/9HxbTxtNswZVZWElgMBIBcDCJuoX/A/6k6VAfAK8iHSCMyPDimCITMJKICsEb6A49F/++s/HpjPD45F4jiqU4brwyWJ5cTpkdbnnYuV4UdzynvdvuPS9ok4PBBEsZFjysMly4fi3vnDP1Rdf7XTbVao4uK7dZDTmsllVEoKNTt5kWE6EWtsaqCocYYQq6Nn52HyoVMiWYuGY1+WbW5wxmii90WD3uA+PjueFVLuvkaVYE2+ieGM0gwSHfee2HSotjx5/pre3VVI0u8M8cjL55qv7KMawOBfOl0pGi+vIsaOSqkCiw7vjdKwUijByxQSKKBK8XW/A63F7Nm/o371rs9frv/fP98eioUg2IcjVUlEuIW6F0Atj+tWvHjx09OgNV1/y4vMvw7f01nUpFcQbdeHF6Mv/fPL4W/vWdvS7bd5qOh6wqqFMIpZIXn/zlTDJaKO3sX31emswCKuXNxhIvgN2EaYDbh+twmaHmNcTjwPaTv/B93+qgggBnESoXeIXgf+Z7g07xhaYYk6Cr5cNL1XUzPTISHx+IQUAy+xCwOtuCToqEtM6cOOuW76Rq5gVQFU0uCSyrJYOvnX02V/8Tjh31s621tfVvf3W3n8889Chcy93NjVGluPNHe1mX322XIRDB69Uz5uihZwqlJbm5nKl8iVbt7zxp/uCHjfGOjudFauWFFt2NPjWtjdwCBQaTQa7UVGS6zdt/s9Pfbuq6V9+822WCX3xm3eIWmHr9q2AFTe0dQMq8McH/0WiCNAuOloIhQ2ZVLfTWG/VASuSE4qtPRsmYrkvffozwDroKabeH/jNvfe9+uoru/bspjQ2W9TlJDqRFfLF9CN//mW1nLMH/PAT/3DfvaDfi0+8cdmeK22m6vfv+XFGV+TNVktrwz33P+uw+i1OjycYsG9ax2Ti81FR2b5zcKJMyUKaYCpE2NwaiYAiTclwGDrWADJTWBPPP/dPlkeImqgCBOZqviZz8ebbJ8YXnF2ApOttdnOxXFyYGGe7OmW5gLDo0syc1WG3e/wmhl87uL2vp/uhn39Er4oIU2FWoWAqLs+vf76vlH/KuX0jpq0cXjw6FYqIhk1rOwpl+tibRyAliYXGweDWxk6+DNhj0NU5Pj36p4d/xert4dQxOP8wjYwGv6BkmWqp0dkwH0rl08ur2gFzKu/c3qLylkwml02Wbn/PFfc+tt9sthu01Njs/Pnp0Ol9x5bDyVr2A/5lxVCDYMVyWfh3Mky8avXM8OE7P/oZPYkEsCtaERKYrrK/+fnP8SaayB08cWTvi88D0y9k8/948GGn2VJUVFtrvVgW/vr8X7PFtJUCSoovAWUO90FPJeIIEHEVQZfPCvf85yeZqixhrg69dRIs7XJaEQgFik0QyAwgkEQConodpzcFG3w/+P73v/3tn2s6MRYJSxXZzLGFdI7h+Hw6IZWjmbSlArVIYmkmn9MgFiI6hi9kE4CpZDNRQcg5Hb7Cohhs9ujUIFWZ1qpCk4H+rNEyADfDwb0gCm9XCx5vYyIZThdSB/a9w5kM1aI4F8moVZVRdLICxwFTXhGEcnR6GhC8w68d03PC2nWD4aWZSASTneQR0Wa4fCh0+yVb/vzQkSVmtOfanes3bihLmtvmTC5HyqV+SqJs1oqZ4jhn89e+/c3wQoQqJJHcAKSeqbKyAH8RSQpjsaRD7IY32OLzqe9/6Zs3XXmAog0kJghLA7BAKMXaK+C133rNVfgHY+zrX/vWT37zt47OJgxYkYUzo8ujQ+fBuPl8wcybVFqCAwhOrjCQ+pAeSjg65bQQNgQKVYfoPAQLgCEyIp9KxWK2u11uzDqnM9gN1ve97/b77/tNNJahWe2Wm2/+zne/c/9vfvPJ//yc3+uzGCyightWYuEFSC/A5CV4mwiASQKClSWhCAvKYuEVQQC8DiMrZsv1TU2I/QWr5k+s6dNbLFNmdp6ncg5LNC2ePHsgHFre2L9qVd+qicm5PTv3xJdmkKGmdCLsTq2iZrOZUqloNjIGM5vNpXWMeXhsbHxqEcY0gj8igl5lcTmZjCdDn/vEB9e0tRbFcjFf4A3AFpTLcunNVw5j2Sll5cL58w1NDYlUAak3mB1gNywsPAXMCuTPalFgSF+oZmZ2aZ7YIzUXKLwcOXXqXCKRepf8K5NQMyIB4fnkJz52ye5LeN6KwVTEChw0hBLAN4hv1ux3YkASxCh8XkXGmkssLcPNgF8KXA6ShgjmqBWKNzCMIOivumKwIEmFkji/MF9GyYte9/tf/sTR2OevazQYjdt2bn3ob49EovFPffmT3/2vn1WqImfkkpFZs8Hk8axDfliFotBkzoAUO5VPxYppCoupVCq0dHUpqnb1LR997L7TVlaKxzL+aqWupYm3W9Vi6+7unbvXb15M5gRN/8Zrr9vstu+H5kKhMEJ4SJJVCgJiSbSFTaWKTloBmsAZCKai6YJYhA7IZMt6pmqyGGS1kjYZXG6X0RjrWx8ULS5OFYQsnHP94KrmZ18/lMgkARq+576H44pfyRV1SsnAVC28OZ/AOi4aYYFV2Fpqv4J6GI1it1w08JcHf5/LA/bKegMBXzDAQwj/v18r89Ha0fnIPx78/g/vmRi/cOH0yPCp87BZwH8I5RfFipHnEdKG+NZxWAd0ThITyeJL/zqEgA8kPqQOAWbDoCmLqtGge/3NfYcOHj9wcJg1uSNZccPFe37z3a/VN7qglW+45dpoIjM1Mbdq9frf/uyvjM6gVQ2AHQq5VCayEAst5xWhLJaJAZAIwa7z+FywrBBw6mqrU+CxKgICD5lSJaGWXosuylqVUXXmgD8s6985dmgSfpHVJuIEnS5TKmayBQnrC8Y5pfEGhLpdBsvqvsGe1sam7kCdneXLCFlqVdRKsQZk+aqKiCIdSpJ1jT0XO13Wurq61qYNb79zBMknRqYu23FFJBFnYbMbTWKhyuTjtFhAGBWoQFHKAseH+TUZrQhbwlmC/w+atDQ3/uuZhwF1Dc1HL5ybRDAdtmA4nCSW+P/nhWkwsPR//+Cbf/jjvR6vZ/jMOzWnFmhDKFM9OAMLgliYFQDbRBRsBDvbn375OVg8JMxaQdCcRgwRkwSUlkrQjRoYir77o/+5be2Gj95x00+ePKDZ3EYLPQs8dGhxYmxucnEpmUur1RIiuYCj5wuZnBCDb4VQD8vbEE8uJGJyVcJ1OYt5emYmmkxCQGD1SRU60DiQpbQwV5Z5yqTRZaPzjv/4kNvo3HnJpZ/51Ie//Y3Pu3y+gK8B/gUWPwkxy1UZeLGymFqepGWACDIlIT/Y3nDL9Zuv2LoOFVaahvQOCUsgzScr6psH3igK8Dq0Q8f3e3EdvWExmjxy+ogoivBCPHWevFRWiwkrrZlhfUJMFFMGHe2wmERNljWZ5AqqlUKh/Miz/8rm8li+cGXNNsvY5DxvZM+eGybS5f8zASsfQHD5Xf7f/fn3I+fPY+Cw3fC5JEorZj3qWQT425LKMkybN7AUmodEgg4gQWTiYBH/C/JGjwhUQ2PbZXuuWNXpe99HPrxqYIA3c4cOvT07Nb3/5X0H3jqiVfMNHjuFqBrcNoRL8egIqUPQFtOYPEjMCskZqSynoaSA5gyiIIlFqVhUygUJkBfO5ObMFhk5NJrNiOkMX77/d78NhaYwgG988/sXbb6sIdgIOfauX460NnRvOV8Sc1AqyC8rSMBVqTIgdar69ukLsLcRjkeQlcTFa4CBfEqsCKKmyLlCCtIZpl0ukzk9MoLZ51BIgvq3OifjMhcAMbA5aJc9VjZqIiLt+pIgEJ8fQG6dHiUQ+UxCIsoL4E21c1XL4sIs0k7wMU1IbpFFUguL/f/NxLq1a8DuNWu9ltzVI/VBMg+EvlSVR4Zco7Zv3hGKRUAmcgES4IGxoSHNi5B/VWdrPDs7MrBr68xUOJNa3tjepZSyoeGz0cXMYw89fPGenaKsvPrSC0AKgVVIuoaSdLwhmU5QrM3ZsbZcyigC7EytmAjRxnqdFSlQxP7ynIUuyrTXGBzcdMk/Hn3BbOTPUfJqW8uvJvNHMym7TuD10nvveC+0EtS5z+EsCBIUlg6wdiKPwZlMR0fzuVMnkM+fKotnzs+tFKvQegMsB1iiDNJCxIPhU9k8ANmyLpPMCt/98Q+9PLW6b93+wydNVufqgLmx2b12/VqHq7W5sQ5BAqOVc7c6HWxLNqk4eJMEd53i5Ir4hc997g/3/3br1k033PQeRM+rVXHfKy9MjI1cf9Mtp04NBYN1KCpdkf5gXcwHmPp/z8X+d/Zt3XyxJksQ8sj8wDGGAUUSeURHVwpiCXWlJE9nNjAGZLMU2aRXGcBNkAysao1B990fvmv/4dcrBiO8tSNvHW4KOsvZgtFqaOlePbMw5zY3wSGEXkL0kWZUjsEKRjJSFPNJtqoTRBLb5g3Oci5TxQMVSzxnkAp5MV90Gh16i76o0owpCNdpr9751aJ6/NRhenpejBQZARBdSihKcrGQTsU9bkdVUQHSgzVsczhc3iBv9RmsbkmBtWCgWZYkr8GcCCPWsqQkLwQJiJvr+ZykLsWLWBzJXCFclN45cU7IZk2s0t3mmpqcfPQfT0cKUqmiT5Sl5eXMZz74uVrgi3I4rSarCfJHM+jq21o8Zj66lD11bNTmdKQTWafLA9Mlubj01N/++vhDD42enyLsR8G0T4Df/zf18b65uX7X7u0sirxgauqRekBVF8+DXip97TW7br1mwy9//1uIH4aAS2gKeR54ggArkOBDpRpfnF0YX9Cx5l/86ieRiXO33nKL3WvfumVwbDxSSCYAfUimED+vVEjSFXqjLGNVWYxVgZLFUiodYVEnU87D6yhmsbDnc3LJbHUsRhfX9MNGruoVbTGVaNh8qaPOfNt1V7TYAt/5xJ55nagzmhRwLZYjScoh76IajbzH4wAqAyFhltNXtGJsefw91+zkDfr1mwY/fddnq2B4cBcBSxNXEesAa8Vo4A08myiVSpKyY3Xj/T//4dLcrKhqRTH/wivvnBiZyKaFxo7upcX5ifERCPMTB0/dduPtDU3Da9f17t374ubBjZlYwmQzF4oxPWPEYQ6HY/2mNSgQQrYSGn9petbt5EJL89l0nKI6Jdg6qpzPFz0e58qCAPUxG3j/6D8f/s63fvDAn/5MiqaRbEAhHZaCXjl7enxwVct7rr3ynUMHiLLlWYTZyANAiVuNvMNm1CQoUamYwy1yTU0tq3paPG7zrbfeAKQ0ymNi8bSOJfiJlYgESXCTLABHJCJcglKZ4zloE9TYEMi7VpCKaYPFWchnICGgjgC4a2lshMBzmgIH9p977OQw63UqWIWAV5CkDqKtxDQHKjgaTYOhEfkuS6i+ESEay7l0KhRRJBGzCEMLLxKQIvFzTBpJMRJFplUdFqMoCCCNndfiS8tSsSDDuc3G631+DNbhdPMGa9AfDHoCPrv7phuuTSVnFFiLBa0iUgvheYrVu7x+JOFVqWI2GVRNQihsfn4emExyHwRlFdWOMlIYsCSEoS8WyoKIvOT/WgS1t4jifPzjdxPzHzylIPoCoCHLGFDobhs+dvqSq3cDakJbTah55KxmA2SRCRStSDYjWxRtCoWqI3wm23jeb7X/949+2xpsNOosFRX2FHLpsNaIe4E8DmAV0PRGoxmROdCokEXFNvLVrMNTR+nMFVGV8lGL0Y2EKpSo3mhDBVk0vLixd0DJ8G73QJPBO3d+wWK0w2CGJic6C2AIxF01yumwEpMQcwYBXypial2uAMuYrrz0ek1iEQ+B40sWPpQmABsgPgQfg/Aor8AfhIWrVbNFrsoSIA3Kpkanoy+9vjcvwRYQE8tzTz/2cD6ThOkaj0TUquGDd128q+1C4zrmvZff7gzYgnU+zKXVYfP63B2rVgkwALJlM28ED42EhhcSsYqMPARfLJTge0aWw0IJViyk/LsvCR5AbRE0NdVDrGFuaOhhla6ZotW0ILZu3BbPRr/27c8DmgMcFnLzMKABcyPgFdi/a9f0nTo7WTWobc0dQ6cOvHF4ZM+2K3597283bmzN71sCXL1cgl2FxUPiQRSUjIHlkFQk4XxLBSJfKAGroDc7WKNHzM9rlcrE1JmmxrbRM085g32CLG7ZtAO2klKYnT5y8tzQXthlBkRYNYJEAikxqZgEREBbGlsbA3WHz5zB6gBoR60o+Vz5ePRkc0fr+aHz0P9QfeB9Yl8joq5H1oGTy0pTh1ss5oweJ1JjUwuJ7Xru+Klzo5OTck4tlmXGiDpm6rYbr2tpqLeb9CaHx0TMwbkXH/juZTu2N231P/XP5xdmE+u615WyBQQd4GE31TWoWHOVqs3okJGVVpKABuhZTqqyy3PzvgY/sBOpVKq7u72mEZBDrKCY/t9zQX0XEZyvf5ewAwSEpjNbzajJKIpZM63/zKf+E3cAEAaKC6E3As0A+QWxcmFh78OP/uOp5x5/+MHH+/vXnjp1tLU9ODO99M17P/Pyvv1gSkAuKJ2EiCagVUTrqQpnsJIYnVYp5JI2Nyq2KS7Y6vU2ROSMKCWFdLF5w57xkROcIZmMDr+VOgq3Axoc65hSRII+U2EAQKKQMCviXvAL6xo7ysUyeBwLAjyBhYeYKEtTO7bvMhuNbq+ThNAJKgzUhwzSQ00QXe0zo0CqVNb7wRA0sAj0Zz71hW39fTdvv/hbP/tdjmMRDLfx3EN/u99mgF6E52tmTey61sYEXxqdf8QabDswOru5u9Hj4GShDFSriWcDdc7hsxcQ3xBk5OAMDIAaLNPS3VPO52meGT170sBaMMZiuQQUCLzcfDZvdzj+ZwJuf+/7v/P170M56RkWixWBdbPR4DA4Xn3umZtv/QAUGKXnkEaELiUGKAQ0xC7kAYyPzVsu6l7dZrGYAFAsFGFz64wOF9JhBDMKb4FUuIB0RF+CBIgAgwhQ4dAqNNI0ML4U1Wl3VUoVq8WF9ScqJX/zWoCTaGAgVJkHaAY6SQXsDCBHskIh+HEqTBrMA4hrsVlQ3NHV3QFJitVAwC+UrlgqSmI5nU5mczkQHJqOTJqOrEADx+EuFosR/gcCjShMQxh1dnZhVX+vF/DToaG+rhan1w8PLlXMFgpyWijbndZgnRciNDs1ZEIdhJV9+Wimo54aOrUkaQasQsysw2aHbxpejFU0iYLtj14AeHBGZwcegqMgTstQ9qKEcecLRcTTwA7AMtdCPu9OAXQvVAQJp9a0gZHj7A6r1+O46oYPAP6CFQDygl5VFCop1TKeymhyXb5516btmxKR8AdOHr7i8uu+f893nnz0H5Hw3NMPvASwn45j1DK8e0bWVVgZMtsM6cCZXCxr1utLqizWsgXAjxTQx6O9u1/RSssLC7MTw01dG5LxmFyaI4lm2kgr0votnomFSvpcyW1DMBzRNAl6DxSHcdbe0dxQ3wCkjSph3YOdidOO4UGPwSLt6jbue/sAAQgjUqED9yBQJ9YFLABCAcpo8PsLRXRaSDcEjdmFw82XfvHA7EygkV+7aWOrUXXaXLoIooiWIlBTwD26Pc+/flDvN4yKc7dtjKwxZ+RrPqOwroySgX85cNEgTJS8DMBDGcWfwMiIxTzNsJ1NTUvRsCSUgOqRKcnmoDiGBychCl0qlf/HHMIkQPLcddeHHv/nEyvuYqDZj08UtVwuLBhcTST8By+2Cn8W8oNUZeAD2mtqYbSqz+WLh6Of/vTHN/eve/DBP1ltRp51GPR2g86KO5iNHhtsUKXImWE5IlQME4sjPANdXINYlIs54lya7KzB27V6k79+DRDB3b19jMFfKoVZJdNcV/n4bb5vfbp+sI+7fLPtkp5uGsBAgwWeqt1h7+7oMpFsneq2eRQE94h7BlwXAEMmxHMyqRSS0Vh+sLPhewHQZzTqjIwWcDs7ultFJRNPzQ6usx4+c6S9Y9eXv/GLfQdHT58ZjwwvzI9FFEFH1TnKtopoV5JcnKPCn7pxc+nkKfv8sYFGw0e+/CuHKZNLLGJJWY3m1vZWPcLHLF9vdxpYuEy6xaWFrjXtaBvgtjpMRqSwaKvbpzcZjr/z2jRs1dFR9E75H/mDN5iMb33nm7BxO7taEMi7pG/VYHv93PSizWSOLk0wqJ1ACIjnGJQ6YjFCpHB0dTx2BjVIeqQPxcz+vS9v37jBbLYePPTWhz94twZntiT5PIZ/Pff3L3xyt9fWmgdMmoNiKcOOpSkexjgAWDAhELLxBBpBLMhvX8AdiyRtViOMyraBK0bfTv3HV64z88vn9r1U17zjw3fsKdDsy2cPbPX3tcgNC/Gp8YUIC+Qqns1u/MwnPvDT+/8MlDQDR5EsP356ZtyIjDPLIJVIgijkpUPwINi8KpfMDp8fb23wIHB1dnh0+85rT4zPGjkDemDMzS2azOP57rYDD72G5i5Eh8NIrlZjsVTv6tW791za1LYrtfXu/P7fRrOou4LKEdGOAZYB5pjl6ZKSL1YKDp51O71d6zaMTs20tTThoerbOubDIS6mV8saWLmxsSEQDP7vCcB7FFGHFucbgr7OdXaTy23yeU28Y35iHlkApoysJniJozmOlwQJZiCtwO4r51JhpVQaHxt+4/VXv/+97xXKJQS5lxcXOKMpE1dWeypCZPq3P/qTw+V43xeP2rwI+EEAYtlgAQBNrQIuKBPLV4UoT4vl2YVRMQ8lLSJqEJmZXd3V2LeKrqZE4/qG6WRYiNDV7q5d7Z08H9DHvDYvP7mchOei12iUgVRYCoKJN1jAH1AADo8XoEuf149wCKksxJqDHkC2GTlfiu9a0ztyMo0VM7j70sfv/+PmPq40InqsJpfNfvG1bcUiwrCpvlUdQD0St1OqCmrpwvnpFoenxdG979mXy+wJeUGmjW4IWdgqiEmg64LRRcmSAH+PxCkRyGIYI/CQ+jzS15CLUlFwe71YBy2+tfX1HsRaayP6P1NADQyu4yjt05ete/70VCpX8NocmUK2qpYRC4L7rhbKCiKJsLpgycGIZAr5mcjJh+57MJoogLlC4cVSLmn3qV/68gdeOD1cWrR86QuXjA6/3t5h9vi2oz8HjBCkMDWAzDUeNlJZqfB6TtPKglDAhJm9zux8or7JjawubTKvHmzNL7xz/KVZrVANL6SfOFj42Bcunnn+yOa1zf7AzP7JC7m4BJsGjmuTvzMnJodPDcE+K4qiheaxbJEYg+hZXAy73J58Pkv8NwRZoMQN1SYXe8V6/9kjuZ6B+syFU9sv3njFRZdcu/1WrxVTmJ8+edzTVN/g8lbKlolEkmaF2MKEYnS6dmyaP7Xk77F+5eJPvHPwTFirh76F1QjiOuvQQwYBUxphDHKbSiWXE2wce+HECNIdeT0RgGvW9ufygtlkjkeRPRm/9IqrMAH/39dvfvObn/7yR3987rSSFvqlso6Xy5ns6MgkQ4KTxCZHZZCqI1g7IKyZQgJNIKpvvjKVM1INXv81t3wgmcl/8yuXZav86PnjHT1N+08zSzMJhW6o76BMcCXoKqdWTIwNMTgLrq0pBogKTc0mY8EGP6CV9c5AMjfHM6KFNcqxM719nUPz4x0twY9cH2zfSh1Ja6JoOHd4JJ5Y3eVtzPqKCCeUC1pEW1gML8RSUViPTgu/1uccSsPDBR/SKNYHHqQGEoP5CvNJNVnMC0tLh+w0BYQp5X3i+TcbWuozoT92bbnohqtvVgpiR5vtji/+8O7PvHL3LZd42ROjF85efvnHZpLl9obVX/rUp0Pnywln4bnH3+zc2MPzZsgA+FImowtBbYhUfYUuI7JOAQmRtZvNCxOje25+H2R/Pp27cPKIBJBEGe5wqbF7PVG6xD//vy+Dxfrd79yz1t/Zsz44nRF2NPMHH3zzq+HngKVGIoOUmOhZWiABYNoZMFap4ve/dr+x3sVwxqKiSxeyzS1BqdQWk1KGQPtQvHp49sBl2zYXjKZX3jxhdLpZuMGCDOx/PlNWTU6LIGhcTiV9V5RSHpBTJVg/yqin2+SQ02CXBwftFeOlFxtLE/m3jyqVhs7JN15a1RAUnR7EmRhP2+TCmCgoMwcPrV23Rk4psaUk6TQhiJZKscPtR3+i2NKi2W5u72ydmpqphS90BpNhVV8/JRdLeRif9vHRpa6BrcgRhaKlm/quvftTXw3HFhqc+m/81/ce/te3Txz8OacrTkyEmwJWu8uJ3MjZydhs6Bcoiu5Zu81icxBHB9reYGxrrYf/ZDBydpenOCnoZS29nGrstsF6zuZKVpnOzE5MTJ9HDQQNuvm9yHYQW/P/Ev/ff+voe//125f+9sj08qE+vq5597r73v8IZCixfGDhQXyrcPyBA1dhBDoq+tWltFESq8nllAHICpTARwq3XX3F1PgsVO2mjRcVs8U3956JxyRVl6MqhawUS5UTKpUV0tOJbFQA9kSFq1aoUGGLPaKwp+tbu264+pp1GztMstrWYBo6l9J7gmzQt//04Sa/XSoLWFAGXaXb028z2zmzDT6WWlxA6aAqI4DBSxXdO6Pz4zMj+Uy0JBYkWQG4jHBbzcxAGgSxAYfdI4BdNXlyejwWH80UZudCs2+99lx4fsrIMTdfe8vw7GheFESauuy696wf7NZQlqFjUyUg4atitlgtCzwDkxw5JDiEtNVstpjsMHvAogYDDy9JQjCoQO5AafLEiaPJpYWpifOqUNSjvQ/8KYrmYRTVXv+/UgjfbN64bWZymXa6U1Z3Lp5439fuZWp4djIBFQhxILd5S1birrv7A29e/n723OmdI08p77y19oYrbt3+3h+++bs3zu7b/ZEr42fH3n7uaQiiKy7fefidtzdsX58PneHlyd4d+hxjhv/bYLd7G6x/+8vJhvbtA00SFO8Tb1Q26dWPv/IObOcf/MftF8bVsdF0hTMwXFe2fEpXbcmn892dAYlO//czP9x0cc8an+auu/yHL75JJZfaqqKmlT64ynHjJS13Py2fPnf2rg9+gObph/8+Ap8N/h+8sHX9qyfHZrqu2Xbw0Olcqgh5/fnb3oOmRY89dHBkesjidSEV9dC/Hu3s6GsLejo6mxmT6YMf/YqQGbHRZmtLT9ViCh198clXX02lY4BqwTKEI2ni0ViharE6ISAy+SQUMSJxBkS0kUMrAGMye2J5guKIwycTb5TATH2Bf9s/JPFCmOP/vExmWwkSO0UNHT+/bWx27+c7SEIGgQAEEoGWl3gjX9clqeIcR7Vz+msH1v9kMbN2R8+Uqf2fh8MdrbdbOfU91sZZz0vNitO0gf3nP5+G+X/8h/9q6DIsj4lwbH/0wK8f+/MDYnqerapf/Mi60wujx6aFnoHVgdUdoVL54v7NU86F+6aXL843f/P7n/zqb1+pcxYsZu/Vt130ztlZKbdcNNVddWu9kKko7a2ZpPTM965vc/q7ON1sOlF+9JfRkZhK1Uti/vzISGNTk9fhjadyJkqsc1nnF6ZptTQ7MUVVgPLjXT77cy8dWApHfLYmlKV46wLop5ZcmGxa07iu55J8ujQ3fHZzbzswUu+77Xa6UMqVxdaei7/Sv/u5/W8/9PsnLt+1TRKUvlbeadNLKGlm2A7EKhaD588soMAEGGS8EDszGi0ynFfIo0oF3hTcF6fHga9gk5E0BVI0LPd/5BEo/Yvf/upTd34sZqLPtrsROwHiBouskkHW3hGwewL5cgl1e5xgno5GOpzmT9689Q8/frJ34bxdiO7Xu1yu/F/f+oJl+/b2UKajuXPNqp7+df1nD57avKOLKkuNdb7M+dcvv2ogrOj4pfyf7n/lvju2vjIrnHnqqdlAi91o+cy2ZvNFq46FYo76Dc8/P+buaEkVS1Rn8/6RhTojNbWUU1rse2+881f3vT5tX1teuqA/89DImzOuz3dLZ9jmO262wjz79dTWektdQzPsn1I+z1WqvX2rkApNLybaGrpSyazTESTJGLEwHVPiyarVCxbUO636ru7OO3/y/ZnpGTg09q6Alm2582Ofl7NLWqUUyukCDatef/7Fy67Z+eSzr9f73Ho1uryw9EYu+YUvfBKBKnA7p6cCPoeZ5VoCfsT+CIBXluAXoh8PUiKAEJktKACRjBYjLATE0xAywRJAQAWpPLjrNWPh3cWwrn/DYjTjtFt5RzAUDzPAS2NaWtZsjCAcwfKlctJicrCK/ly24mLUToPRvbYrtu8dB4XondpaEA0f+oawGP7Sty59+8CxY1OvJULRm267siBlZFodmpzOzIQKLSmRWePgKh//0m3liYUNm+p7JffplLasq8bjWjy/ZDfTz775x40dO29s6UiGR0Yk6cod10eGT3d3J9wb2+/fe27YzEipmV2tTb6DtrHTFFfwN66yl8ZHaV5qdwe2XrSrQBUOnBpVUJaEmhojP7WwDLG8feO2N46/XVvPOkVSCkjP0EwmE3vmT0+aPZVcSQ5FZ5LRJWNLNyjF65hvfObrLJ0Wc8rf3nr5yNFDBrejc80m9+FhlOYAlNi9uvWhv78AyYxGJhqQSRqcLBSCsLCqEfVG7RjCr6AobgcrycTx0BT4ElOC0BR0uCSIRrMZXh7BV1Q1ONX/WxZZkYhmQOOqyWzRWcyGsiDX91zmtJgWls4jLoQEUO/VH321YYAy667f6togKd/5/TPsUrjZwvnyuePV5SBnWn7r1bs+dUXn4NaCVnz1gYcXpcJ1W7ZMzM5IUlTJVe+66er6TKxTLbrrg5a6Vp2S5kzWWIpZfvWVvp3djIXVWHcsEZaXlusG+zXOU86G0Z7F6uZ4N5dYli9Q5aFTE7xjoKex5H35Mf/Ofsq8avgPTxw4S33giV/NTiyqlcDB0eE3Lpzg9cZ6hwnZoExBEVH6oasi0Cipci5TQOi+r3dVm7cDnRGWYguegGfrQOfZI6fW79pjIC2Aq7PjMwG/k2d19T3NF1/6AeKJchxAlGhGZdApGZKIR1wNrjf8P+SfKk2NLqPO0NHSYodngPQWwpEaehOaCR4Qvo5Zz5odn/jGN5B8hYOG5D7PG8wWC0FIVTU77IX/9frDH//0xwceQnoYWBUGTqPFbiwmp8OLrM3OwoRAWA647DqdEh4pCL2u78wZt3/kc5lXnoqdfC1bzFPpBb/Pdu/z335xJFpcPuP2Wc8OLz3519/HzdPmUMuldl3yvj9cXu9eFBcKh0btDmdpcXxxLOJpDdStqXPcPMg7LRrvE8NJz6pBXc8mAPKyQ/ttdf6qkls6u+TgnWi0ZcmNmtiWcnr2ndm3rgsOlkdCZ3Xn9px6a+3Lz8+lX9i8WXjk1ZzdUWegCOcVCxUoLdZgFEWh3l/XHPDExKwdoHilet3mTUvZ4oMP/r6rf8OFC2N7976BWHzPrutee/l1ntYdPHmktaF+w5quEIIoZb3MVxAkrcplHeCJOmAUUZhGMllwxwj/oyCnULBbARWEv4TiTtT4QDSpRVLQwXFQ+kgA0lQxm6TdPiAFJVFE0BBIAfiJyJn+L+KTtx/96Mde3Xdw6NRpUg8MiIQZjrwiObD2ZM2DsKyWDSrxBlXXqCRDv/rNleYs88j90pk3pPiMkVHWbNmRUvjPf+JH/OJBaybh8Jo+t8N75u0T6qP71Dde8RVYDgE1KUvndMCqwW2aOXDO6YADy+VOj008dSjyxnB1bFFjRWnhvBpdMJaSNs535tHX3vjtC0P7Ji68dEx/5bWr3/MxRfbl2fHteTo7PXwsHgvlfYe//Al9LKcdnM29Nnrdxt23XXM9cNEAk9Rv34GFmMulENYVpHwJ8fZ8fk1Hm85u2n/shNXKh0r5cDJUoSsOyF2r9Ze//NmTTz0zfO6cBb2w9dWZ5ewjTx5uJRFKwNYoB4dCpSqKDKAZ0bIIhCVQfBXRcsTrGbfdj4AjKctHAYMiQtQAAMjYaMA2ZMB6dNXRsfFkIpFBp1WAvUQJxyE1JpSF/zMB0Lpf/+IX0NaqXAQKQUMQCUyE+QYOiuRdKzoaCMtcao6XRt3Z8f33fI6dfNuoJgCH8lZKhuhQfvm0mhKGJ5ZHhi68s+9AWlTfeuvJKCulZxa90bHHj1Vy+bQf8Sar482HDqOB6Mm3jzRdc1kilW/dvNa7a7BgA+KgE1VzSjGTPjVSiMw1tbrWb++UZ8vrrt2MAl0ppx79+xvaZLihuaW77yL37iv+9FT8Z/snX4tM2v2Zamdn6NQf4lMP9bY5kqn8zOjpcnYRpX/AhiIvnQN0Q1+1Wmy7tu8Ach8g6Vuvv2XDlq3Bej9g22WhHE8lCmK53uPb0NfVWh/s7ai766or3vf+G3gjIm+oklEQ/CYF7IT5ibWDF+YApISQN9nsQFpBbuBvqAdQDBqYHIgFAHkvK3ArkBuATwMTCOwPIQMBg4PR1hwT/D/TgHcbtqxHyzGsMTA96tQYo72zQGdNBSGvKDavdwlQqFOPe6T88MyUDZmavm62XKTiy0lj+tsf+dp1j93+6599Z3j2dNUsfGDDJcnFE5dszTIm28WDA3Nnz/3xLx+MHD0uOx39H3vvujuF5Zf+1b+17YUPf6H3xss8m9YWpmcTR8fO/+aRdVv7XFfuYgOx1LEDkoduaa27eGs/5w5SYk7lcua1lJ8zuza9l2eF1MjjJx+/NuUfNMrLLK1Fql7x0HyjrWs2k3XUe+S5UNSgB5sBBQFomKzzeExsNp1fNzAgpouh5ej87EwcWhfZi2IOSN3Ont473n+HQ6fFItOInpdTKVO10uSw/fFbn/3H3599Y2gEiTJWZ0IwF0oeJidKjbEGUK2hs7GAcKEaBwX0aLgG/tV0Cosuh5gKReV4oypXO1Z1RqDriK2KdKmKMkKOY4BMAaLbYrWQ4neSPiKeHfwEt89TyOQBT0ecD5UpaVQV5vQpJOLRlsM6frLDhoYa1AU0qIklN918zRc/8uWfPPrUbde0uDyBcmEpG1+MXVg+Op5+++Ffv3eX4fKWNm8mD1i90RfIjV7wdvUDRVK4MG3idQ2DOxHgsK3uc7UFKEBj2lvqrfaGK3aqqNnNzTvR4q99ENDt2EKCt4Qoxm3yB6Th6Oe3dKKLHKsuoRxnk9qut24LvfjE9GSSWcWfWL4QdHQ98PYhhy7Z3jqQd4ij8/kOq2e2LCFqJqGNkZGnDcZMODkzN9G9ugXhNb3Jmi8q+rLkxd0YJjszLhnMkEeAMzlt7mhc/ekPf0iRun2EdAkIW5Tz6BaCXgDI/FZ5sCdQqA57HtOV10G5q+hmgYp2nuCo4QOjeQnLiqrKocsbDwL4ZWBxaX0Zjf5LJbSHASwIqwTWDdL3gGeRPgiYgor2ta998cc//CWSf7VKfNqIlntevw/wAxyxYfPu6y4OeqVkijYsLs5Gl9M3feJurwFmisogLKyv/PiOD33nT797+tPv73JwCmf0Guy6oHVNkI0XDR2ru8/uez0aj9r8dQAFek2mhdlY9+4NRrcJ6HWUfehFKbowS0sIOnkzhVLzzi3F88NzR8/5+wYdq1sqNExEHv4JZJ60eEbWpLruftUBulmQKC4Wkxa3E9EEysZJpw9791zx1Ne/xwZX//q545I3KGRRaKSTTdWmYNPW9X3oAzF6/lzZXNnct3N5Ofrksy+5ndbWhgbQI+Bxeh1mr8cfisT/+eyLsBWB3Qd/ssA3oia0guwjwuo6A6N9YdOV84tjL8zMBdbuGmy3IwNRlUmXHdQTkHIrncUJa0DjGQNrdfp2XHJpW88qoVyOpmHN24VSEZrJasdcA3nC8wQaRJAsJLmkUa+/9BYqyhALQtwSswSLVc6mM4AYMBXZpRaMVfG5t/be8cEPRmejGzdsKkeSTc1BRNVtNksEnevPRI7+8w8twUAsLI3Nxt48ONnZ23xuKDR2burXn/6TD4mY+g6P1+Wv98rF4urN63zrNpsafbzbzpqMjMMZXL8B1YpDh0daO4IzT72amJyo76oHkAvrmS2lDZxCVwTsGmHiA1Znh1BSVdqIwqicIDp9vkK6CBMbDbuO7jv13B9f2D8W+c2/3krq6WK+hOS0WCriMjMz0/PL8xKlbd++MeAIzM4sojyE8GyVQqEC8uaIwKO4OJnLHjtz2gjhABleK4cmTU1IVAxlQWADtk4x7eCpT7b2b6DoE8OHEa2HQIEAIRIG4WPSMAMzhXwKyixAQQ0tYHK5IiKYSJtDJILrIYgA5kDNBLwzGXmWSs19gKtcpdZt6wWipGY9QS4h24TsBsPATsAiCPp9l3YH1w0OKnTZ6TSnJ5d0Jht2b3D4XGJyur6juYllvTaDPHFMzBnOHDu2fc+lLzz0z7yeCRfzUojas90faHQaTRZ3U7PRxqEFFI10PWc48shBulKqurT2gY3B1a16ni+HU0I+h0ZOnMtD68yZyDKVjTub60RbPYC9OpM5cWSfkhQDl9328je/0tLXtnr7ptmzZ/tvuRbBLxn+blRlgwEUel//2b9ZnAY1U80IRdmstzuda7uaxy5c2D7Q/+hbr25ff3k4jHK5BABqTgdMVKbOBYgJj30nZhcWYX+YWdTsTRUlihTJoW4aGhcOdKV67eDGs+FFB6372SUfOBwaX3QY85kcenOB3MBGIoHLMgBgMvaqWW9Cgl3fNTCwemCLMxgcOXMWZSnAKkH8wJ2wW+0Wi9lmBSLLDCAX9DMShX6vx2hxECwUZtvAwp2hCKbPgEwfXW/n3n/1DtVkCy0vXHHjjWvrnLFM+p3XTzSt8aqTcx4t3t7d8Mbv/vL2KWrdOsd1t+wZOfL25us3T51eXMxWH39yzGakLlpNuxXDujsuZUQlG0qYnawr6Ebg1eRvFCpoA7FUZeyqXJayQrB7M+twy0IkOz+pTMcnz51r2NTe1D2IzgVCApgjydJoNzjsuoKSiKaiL7xmg425pT2VFipWzuAI+ns2VHOLd7z/TwsWU6POrHBUjkJ0p2TiKZvHuXNwcAGmUibGcqbn9p0wmQErYRE/aHB6aKMUCyeRlKzr6Dw7dPTH3/7hoSOHh0aGEUECGg+LDEAHQLqw7DgjEyyKT3z7J388+04VNZEIDRbKXqdblAW7zapgpwS0qkIHJlT693Ww1gaz0+mxmfKlFLDuxMwB9KHKut12lwsNFpBNMI0MT/7t73996fXX4skE8ac5ZDyhqiGGSKVm1ez0Nnp9P/nax86n0uhtNXx26PKNgwUhGy+zXHjW9PbeZClmbmW6HMEtX/1SZHTyyYceWRrO/eSpe174/nfgVrh3bGlt7zVYGCkyq+WKvMXEGo1yNmPwNi4f2Xd+/2y1o+GGT3wgVVYtJlNk7NzL9zyfMVB1rVRxmbr0Pb3ZuZyQzbQ0G7vvuObI319rWt8f6NtQYQzKwnkllDb3dZVTWY0WTa3rgB+H9wq0rMNumH/x0GMhw9tvHsRaRkBGY+msiGcyQA2KamVNb9eFmYnEcgrd0ohZwrA+uwfZOWCodaoUWo7fc8+Xf/fz37e1d4xNz8JQAalQM5ADbqGYR/ABNV0wXiyaeOXgFhlrBMUUimoxW6CErS49CndZ8L+eK8pCQaNGz4/niigYLTt9ZoQ4kR6S8loAxa7NdjBQVtW2bOoHznd+aSGUWAKShfG53KU8KQ2DdEMoo6avpVR8dm5ixlHnQjlBZGbqXJPzA7fd/d3PfSp8/tClLKWYqWxCTk/NPHDZp2IC9YnPXH7y7b0fu+2rLQHqpm1ee72Tp0VWRV6MsbgtiKELyTzjqdNbHNb2gUua1/BdqzLJaAUtplHeWDDs3NXydjiCNnTAJtFabtON28rx2VRUYZp2eYPnPE0NpWQMDyInC9H5qc6+OmK8hYvp0wftrQFdsDl08sTs2JzTa6fP582Aslt5ZOJgzuczQMpA9lFQiYcPH8fmEghMEpamAFVEQa2ml1Awp3c5/D6LZ/zU0Po1qxw+hxHVZFXK6ofDxb/62l4CKCejIn5SVkCihIfrxcGMQZBCQZM7A8wkRCqKSB+jNi2ScrY2tbV2uXzu4bMjHjsLgaOj+Ei4AExiYjmOop3ezj5BK/vcvqEjQxTaO5tMup/89OuP/OFvc9E0LFkEN5BZ59F5RCxt6a67cmOvlis4WhyHHnvZbZQeO5P5wFrHvuFsv4X6+b03JHQBuihNDZ83M5aegUZX9+pCJJSdn1ajS4rF6u3ZCnkrSmm6WoZxZjZZUMj5zvMvBLC6uhte+es/t3QHmgZaZU97ZG5M4Jvnj53YsGtrc3ddJlp0GJns2dPGdTuk/IV8RnR1r88eOyRkC4HuTocniJC8ArCj1SAvLti6BuipM6iuV4ODSnHmzz/dfySFRLuMjlU50rlCn0NurwgfQcCDoQ0dQvRG3gTPycAZgURG7hdJf3QFwQYWyVAeUN2TZ4719PeE4tFwKjk1s4gUCaAZCC+TZAtr2rZxA/YIQVwNC4LAtuDxmXyjsxdYqwurDaKkfXUvkqntbZ2lcm5xbqa7d7U/2AiwwNzYFBLa2Wx8/frePz/8wKbNA7HlxND4JDCZuvfetDESKZ46N43cBlIF8BBgBFow11rugzfskKJhZ0PzFdfuDB15Y+HJt/qu3XxyjtISqfj0tMZQt37syonxyfXbegozgK0v5JcSFldb9503oAEDZTRlzx3IjJ4dGUri8Z0+Ktjas/PD788mQ5ROyGUzXK6SDIUz8+N1AcNMXLfqPR+yBt2gCsoIKjBU0jOW1RuK4QTttA4/+I/u7nou4Pd0tKEmPQVPx24qzy1p80nn1s3Z9AxVXjJ3XfzqH587Hk0u5ivlsgVeMfgcFnVCXy2JlXQhh9JPkA0eKUfALgCyIg6hAYGASNmWDVvQSWx+Piwo5fq61j0XbV1YnswJpUMnhkjDDPSsQ1yfNfs8jiaf14C4A2nPhC26DKhIm1xagCvMmp1IBgT8jUhErVrVBhvnwIH9zc1t+VwGEIL+gfUG3tzg80DG73/jGUQvWjtajx07HPCvemv/Id3qnkbAWucmFkF/YPuA9gP2DOWSlJS4ZqDxQ3u2NCWnj4RTsbElq62yEKUKFOVp4MRpeeDiRjTgyKewg1hw88Ubi/FMenHO0L/aFWzUoy61KFVj08BXFXX20ddfo8355aRs1DH+uqampna2vs7ioVTeO3zw4OLwRENDs6fNZeMynAtgFdPk/mPWAN3cf3F66IicyZqbuyLLyzZLPeuELcWMPf1068WbXVsvcXSx5QtDNNeSOXMyO78QLeneCBWzqOwMiZrLLsp8QSmhuVO5qEI6ozINdKwhqAlqBMgS1DKheRoqllAPgY5NslYWGc2iZ+ud7sZ6L3pknL6w1NzRAygiIEkVSbPwOrNeM3EUYCfY8gtIsJJUiZdhWaKoEEkgg8vjrQ+0tLXXjU+OI2UwuGFTsVxo7+i2Od1PPv705sE1nd1tn/vi5zD5u7ZvyqUSer3RH6hHaYuhWJRgGABSgjg2TF2DjlGNTpRPz08tUO32WGkpL7Kta9d0NTotM0tCJu0LmM2+rKspODs0aa0w6/ZsB2CTrvP5PSbFb6eMDMHKa0qxQmUWMw293i03XjF97FVJZk10dfjMaalUDORC1XX9vCmfmE6Z9A7OZS2mi/Pjwx4HVUzOSfBaFWuembR2uTTBonJYG93GYGMFxsfk3JpbrjX7vSwtZ4+NZEOLXEDR9XUFNkAhGFvzVdiFU+OxN/eOHr0wL5VQkcCaTGyO5E5Q30HaISMKgAC9hkJzxoBZwZoA9dGTixRR66CI1GgyhpgzvCKPux75ZaCPdDScVNSuIj4jciATnCvYlzyTTWWQcqhIUJ8ADVftwGVYTaFwqFwueT1e4KV7BtZqgobl3t/XBxCw1WMvlwVUlGdypabWVhQ5we3Rff7uO2ZCkaMnT6M0iSetyapWYz1BJLkN6DpwR6dxR39TNjZXEbhwWdTlw70ta2anZjZctda1emMpOZeLxgxm6/TJUVtFNgD6rKiLUxkdVwRyefVV1/q9/NyZd2ZPx11txvbeDU3rLjIYdXlUplHL44eWBLXcf8mWidOj7TuunT78psclHNs3NnDlrrcfe3vDJeu6+taZmxxiaJFCeBhN1oxeuaSWjx6SHX6TOgXEl6yrF8qRcqhoDvqatvUBsptLhgEGU2Kp5Ygk6RvHppcadvVf8pEvVlTDzPkL7/vI3aSQAf0RGFRHa0bGKtCAeaMyGzgjqHm4FsjFg5ZASNF1dUHa5EMpIFCPwESiPhdZc2xRB9gAmngAlxVNCQAGMJyVZknxl9Fo6u7sDjY2Xhg9j/kYWLc+l8t1r1kNFBfNc5KQb2lpnJ2b++3v72ONNuhs/Pvwxz77wlOPMJGZCavV8l+f/cKDjz+0rr312NmhXDE50BhAYVthMd7ReFFcpEzOxnQpGbAEVm2uL+fyF23YmV/I/eVbv4Dz4GkOAifeu301jE2DjevuWrUpI6MHNzSXmE+N7d/f3NNu9dtbmjvNTZvSkaViTKaq4oWzYUudF6gRvc+EBiLx84edLfUocUjGR3OZ0M7rd7Rs3xk7cMjc1k7ZdUyLOzc5Xjx6uExV6jZtdDNZ4ZgeyTBTl2H40fjAZl8hHiokXZb1g4ZkE60UYydP91y2y9J2zeU8UyxTrBnVIc5wehlBTkSMa2VwGuYgp+TdlvpcKQFQIyaGWDuIkFXRNx5YRDYnVJw1g0oBdhuzg8oiyBmsAxJHQ+OHak6UWNjXQFJpEuJ3Cloy+zxIVnt8vr7eNSeOHdm4ZStArNAxjR772dkFudr88t43UbaDvpY+vx+I4x99/1s2q4m5yOEyWE2NQvgH2y66cPYcGuzWD7g2OiGZKnR/oyYKZta/dH7M7nd3NreK2fTkWHbsqeeBSFy7vq9nsIPBdlYgvNmYm5nSsNOeOoe6OA5pC6liKIXLhbi393pDQr5w+LRzKpxOJFSBati4sW/H7qqYVuKLKMBZc80N0ePnbPXaqtvvVCt53t0gLCf++o0f3vGFj2VOnjv5wlOXfum/3N2t7jWt4lIos+8t/boB847Lkf8y2XmxEJoJ07qU3F0XIK186UJueXHVhz47fWoC8CwgSBAZohk0dEcTmiL6GqI5IQQ+qnsMFI0NQkql5aDHEccOgSQ8RsIDCEkgOQJpAwMRgHcSsSiUgBeBeV6iKuUUdgfUW1H1j1Q2AKMIFaG2WtOje4DZZUlnszaLq3fN6qmZCQ92IXQ408hao5Gqqu8ItI+eHdcEOeAJIIahygT6RypnEKFr0as2nqA+sdvO2vqmvibe7GV18UwFuX5JsVvrgFS0mt0uW/DsqTm9WSypFbPTs233JkQCkLbLLqcsVGz41MFtN73H1dKXDE3HFrJGm4L2nyMnQ7NhaktRQAFJU2tjJHnBaLE2r2mydHtLkTDLme02i5pPmnwBqQAfjxUKki6em16KFJNEKS2Mz6vDk05XHe9sEZZPl+aXp0+McGadv6VJkQvovCmjXXhXo8q7x+cnfcPzzW0SdoYQ4qFKbqaQj/J6GrWyTh4pK2T+qmns9wG3Q6oWDBaIeqgBpqowtJbJpaAnoA8RIEKEHxKKyCFgKI0GzArEEsI+aK+A4gHMHdKFCGdmSqj3lhxWJ3wEpDaRCEDSC4UBwOy1tXZA8UL6t7Z2ipKCWqjW1nrkDKB45xenDXpd76rO0YkJ5EswfVBHMHp0z3/4esRgkRnDbqqiiHr0CoD9OoFpbauviAW0PEcNoNPhQU87o5l0jEmmkwjyeQLWdK7IamJDvb97e6+cibMtLUomaTOBVlNDxydQb3vZXXfoFOaer/yib0vbhl3b3OAoXTm1uFQ1uKZGRzQ3z6vl3sFBC23MFnPm+vUnDz197OnzN39knVMvP/z4qL3Ju2P7Blfzhunjz3W29XNtQTmZLRciHGvjGHMFXfVS05pezOnaaV9ffdCgL4/GTw7PTi6ZA572rjXK9o9iVwqbzq56zKjtGnv76Z5mEsz4+H/8CjuxFLE/CAJhuip6T/oMraOJMyzvQjUba0HEDr1N7E2dbbKMCgy9ogf6QhJygtGAqA2aghEUMKp2ABTlgR9mDZBpCOsiguN2uy/aNLj3ncMGk33DxosQhkO1f50PpRhG1Jk//PhTq3v6BgY6f/qDn8uqiHob2E85hA5zAF2jHhpbljA6EZ1nac2gN3Mui8NfF5mcjywt0qipMoNZ6HxSRDwV5ahoUVOVdCbUglJMNikO7Rtu7WjTLyzTxeTw5CnXms3XfHIjwn6lWPytx569ZE/Xi4cm/a09TEsL3FmsSrbKrtqzXZDpf93z11WX3Dj+1EmJS+oTlMfT1b2+6r34Wkaj20LPsYzn3P4zTcF5IZ1MGb3B5qC+ruHQTx8YvOoG99p1+dFls8ltbGsa/+s/Y9o51Vo2ruu3elzrbZaJePLZZ167dsdHzSZXRREBGoTVLtIGZX6mmik/cu+tsxn7p370SKyAbijVhJQpsYI7aMTuOKt9A6OLZxSq7LDVo4gTuXbkDmEwoVS2TFrDitgskOS1jOr8Qths5NABiGPQh4b06nXa3X19va/t21fX3BkINqKvlxF16KhkQaCbZtxeS73HffnOAQCBPvHxTxw9dgihoaeefZHUGaZQikajByaTL4pYf6i9dPgdXb19aF7WblidLaRJcY3eCPcvj56kcrWxzouAuQGFNIwe5gkpFtPU0EJEFy7Dj++4+j1qpjz00ovZSBzKr6O3YSaduuzKVUP7X+y46ab0xMiFkam1V+2Qs7off+evfoaq5PPWixrP74sefPaFbZuttKpPz6AZrmHr5j4pMqcffB+pay2ELEbDwolj9b1rb/7vnxQmx0PP/zk+E73og9cJVp9sCdj73IasTY5PlhrWFJRqC4LglziWRw61bLlC4XjsBIEoJymMnRgbGluqb/CWMqHX/voNvQ4bhFTyAFqPjT9xIPLyobNF4bzfbszmtaDTgcdCwzJElWG/oh2IwYilAA2TxBZpcHp99b4Kyo5EuNgFk9mOBL7d6T196jw69TQ1N8AmBaXKBZTTYKFQyUzS6XANnb/w/g/eimaxHR2tPE9hQxe/D+4b8vm1gAZC12WoKKMJYsnicE6OTS/MzaLdBFKZgUCwta3RZXdAQKK1aRVlefBGqnrSgQ9RPmyBRRI9SiFTycaBYjJPHnt77twoxJq/vsmE2D9v1ibnm4O25ciiud7d1uYHlm/mzCnZQhn8Olddi7+9Nzwz1dkEZ5+B4RwaOlrJhcEJvkBfamLR6muqIgvlDHq7m2lTRUKQCElEW2uwa0sJSNRzRzZftMYZzQd2rdIEev740NDhU7TJQemaTv/jd+f+/ptKKsujkYdUCs/NJEPp/s0b2jZv2nT7zToVDtsok5m3C5mBvuZPvX8VW6Bk1LtLaMdkNBk96MVFOqOQTeXgO8BJJUrA77OjOQDSxqhBQV0OyuLwMlusCNjhtGQy7XB4oc2RHUVAG3VtQP4i6wBlgE6Pdp+LVCcglkSrzVi4EzONwXo07tB9vqnd4bau3rqBQwF8Ii6iYZSRsrj90VBMKpdaOxoC9VB6Sh5Y8DwCM0CBs26vB/3pk6GYLHDJaLyh3VnMIOVOeR1WTVnSafO7/+Oj4lIczbNOv/V616Yms8z/6LfPXXPJYMPA2tJUKLY4tu/E0uANWxut7as2OrInXn79RFxiDddefWMlMldycnZf/fnnXpBNnsxyztrsvujS/nIohb2XnEGboa4TlkmlHMWqLU1Oz88V9NWivgKRKSdzzgsXjgV6VjlMutePL169raNtx55srqBMnpoWnLSsG9y5EVn5yIHDvu5mt79p4exQvjgHLL6dsTWjIG6p/Ov73zghJ4EMyfBWF3oDIUyJdjgoh9Np+WwWzS6qqFwknVsom8lqMRiRMYY65s1uCHfUpifimb7ebsQ0kVArFuXO7o7u9k7o8GOHj1975ZaOrpbTx4aaOluwJyFwc4lo3GF3fOP79+geuPJWFLY09/qDbjctykk0BETn3my+AjlfKgYbm2JzS/bmehT/Wih9e2szVIWklefGl53BgNnqxCq0sfqCnEnnIJcUtM+yBsIOgwttl10BSzayxAOvKlCH3npxw9U7eGsTmtjo7cLPvvnEtharJ2hbtavfqHeIiBjwzPJ8xOFyWgLu3JmTwZ6tiyeOZwvC2alxq43bvutqBHIA/cQSQ71xsKEB/qzRWy9lws89+qrPZhzo78jL2o++trf/Ug/cZFNTx2AwiF2+kd4ruNY1d1jyC5HJ2bGZs6Fbv3y3xe6SEulyKZJfSqLJSENdUwlVE4W03abSFpvW2HLnx59OSvq0LKBTNTphoDKSpK4QdkadKVpsoVy2jNQs/kSbEKTa6cGNF4cT0f7+AYAkgYcAUMhscwAVAAgXNrFLxUK9vd1GiAqr3u32lNHVJx4vCWJzW9d9v/u97oWPfVCgVH9TqzHIh/ePo1amIJezeVhrJryKyQyC356AC4Km4eLBltbGpbdOJQoJf8fa1OhIKZZSGbS4dsARx34wqJIx6Yr91+4uR85hmJOHTgzs3Mg43eeOnDl85tjGK3as6dttgQcUHxENGsLrHOspLydnw8mOzWuVohBeXOzYviZ9YdmOpuT+Bth1eka+MDJKJQrw72/++G2ZhUQpnscKWI5GA42+QHc3CnqO7XurEEmsveoibabAlmL+YO/xkVPhULi5mYslcut6eooNF6Wf+mvV5dzwlS9u2/FNQNS2b2C/+ePvaxWumFkwmt28xyV6TdXpiUxZMrIOo3BYnzYNH5u9dyoe169ua+/JpBIepzWeSsHQzGdRWJ9AgyK7w4JKKaFSZY0OiKCWtk6vy1ORCoj7oljo4u27kQRDPfP84hL6E1+ybf1SaGbXZdsQ9U+Wihet2wZA46Ghw/f/9g80Eq5Z7JdaqrqdLsQK82UxjZ120DmOocGA8Uzc4YV9hvCTyddYh12cjRY03LYunT0OSQC4Q0HBbBUR3MXKxD4kMl3Z9/RfUUeHBqGhRBrpezg4iVTu/CyFWNXUsbMTbz+vlQsem5ez8kDQ5Glb+7rOSCRUzqt1wUZaYeyBzrPnAW+adzWvnhg9veHyWwpyJbSUFQXoKBb74ZSklMuBon71uYf/BQz/qtXdOsbkcQccfb0VtyeTzXb2tF1752VdO3Zs3rE+nMyECqXV77uxbduGVEz40ZduunjAwhsc93/+G6PvHHPXNQIQArQCT/HWln5WNekyZVr1odfNxiuvu7h+5+5dN07PhZAm23/4gAjwCVVZ3d162VVXrN+wBZs+AHSFsiVQ32iwypKMMh64aXgoGEoloQx/Al3PgNfTNOGV11+3BpxWM+STMDc/88ADf/n8Z77421//GjW2zPSZC2g/lMlXl+XcxNAQa+GWCjH0YUiVCxzK+u02zYg2P/rOzs7oTEi0xi+cG5akrIXlLE5Kdepp7JgNcYwGkxUGXUxFU1TLCYwq6I16t9+OLR0YE+AZsY9+cFuHwyzyDs7YcHZirKveVBWccjTrHWxhva7zn7+/fnXz6q3rxAxCqM9ddstAZoYqLc4npiZzgdF4InL9DTv27z+45+pr//WPNy02Q2+zGypdlUoHnnix0+mMnVtYbB5x+t06hEPWd2cTiWxSdptV19Y7NW7vzIWFX/3ocO96avBSsXdg3X2vqQNrGrdcv8emqgee+EdB06eH5x0wNG4Y4O1Be1nIVjvuffvC+djTMdj3WUbTy5deccXLzz4zNnwBLdWnLoh2f7C/u9UXaIQThwgEdot1e1xOrwttgoMBD4LXcKIL2bR5VU94PmKzes8NnZOVwtj85H2//BOq6ZCARLUt6mBIZtgE1S5XqjydKkcyp5K8U1/CWkDW2cDJQLKgKrlQNiV5b3Pr7MiotTFw4q0xuVzWs7qcgD6daP0ERFQR8SugVn2NbgPnP3c+vvXKi9H3jiqoXU3dBmcQUrG+ySfqRodeGUemSVT9v37kre/e2zHz92MN3b76usrw80sGp+Cv4zSlEDq3ZDc2Tx+PVs0scJEDO64qS/OUWvK3tLz2xqkp9+iOa6/yGjUUmpWPHO7rbI4nI5TPfvMXbtj74iF/xJuLzEj7Xzcxxrhovf3Ka8SZMYPJYbAmPvfnj+qkvHPztv+67DM39Tl7bRo7lTgdntv83p0Ws1PYfQmlOp55en+oMHE2Vy1UqgI206xiRzSWNootjsChN19HwKcx0CbCuiSAlWoRGQErfAc2l5qU8ll/7+p0Joc6Gau9WcyUzSabKxA88Ob+/t41KFp22BFJcpbQkgGYFDRmxEIi2wShLAfILpUxue3wNcpiBXgLoYDWYqTUHXu4CNjDEMHCXBFIDBuHBnlVJREvFHPIwzGsEb2XESYxcGYxJ9U3sr6WpkQhWpI4twp1wihLVRHhsX4Xba3LLM0lEsq2S+/gF9Qn//q7S68rd3iprr5N9j1RzpX1dfUCGHbxZZvzaFi/PJdXsmjeUBGq0GCFWKRUEsxVD7Y/QY+pWKb81t4XDTb7zbfekIlFuwf6TA7fhiCbWY6l45lN2wbsNpdm2oRymQsvvO5vaIzFJhPDhYbVgaYNa5hyPjm+ePTZb2GP8G1X7apDH8F6f33hiuGjJ86dHpmg3Wfji+ieBoih11/nBZCKtV5x/Q0T505nS9l9b+5FEg2CtAm7/xXSBkmaKUiT0xPYlYO0fLDZYA+VclmbwdzW2W028I56GwJByVxm45b1aAERiy4mMuUGv39dXztgh0cPHgYKnfRlABRIr09Go2TXMOQDBJRXg6HRcQM1ai4nyjsEoQRsASYmnshBS0di2aXFMG+2iJIYS4EaQDEIaOGGjBEGvhReyguUxDgW0kUtpa+WyzYUMlhY9OBBzCcZSRViSV2Dt21jmzHQ1xTglJzIehvgWj72vfsVtKPUo7iVCTQ3bt65ub61wxcIYBdLg8WPuPDkuWM9HV2yVnL7ABGnvDbb7Pnzy4tTntY6pZwWUgWbH6a3Hi0nkEllkFXNlroGVrkMtrabbw9sWSelVatBvzg8curoBdri+MgX3usymUqpZTDSK2+ffeLULLtx16nZJYsB3Q9cMHOKmTwqOG69+cMoOY3GotNTU/66AGq1Ye/39/UPbt2K3ZWjS0moO4PR5LDaSFdr2PllIBaFTCoJ36i+vi5QH2hqaEolYh6v2+W0IS4diyeOHz2BtiLoe4kEp9WCrrccGpoiZc2IvCFTLutKQFfIVo4zIdKgYjNbiTRBRDpJo4FjQlUtQJlO1ZJIpbAxUllFNZJxuZBEghwVIS6f0ePuQlMksFmJdr26721eMsqcb+S+dz5211XpamV+OfvOq6+/9w5Lz0U3iUp6fkw+9ve/DFy9y8itOje0L1987e5vfMzT2lzKZrPpHNBLyE0B4I2cfngknp9K91zaPz8dCQZR76DqK4Lb7TRbuw4/v7fB5zz295NXfOw2CLzht04snF/acM22XKGUSYjovj2z/0g2IZ0/N1J6651dl2wZ2NVgWtfFi+aHjsydmZ8bTZ4Hu7SuWt+5Z6dh7xuAv6J9PWi6fvOWqfPnXt337Jq+tceOn633uxE9hiO3bm3/vx562N/StTQ1q9l8qzsDcwuLWZ2EUguTyYK2+8Cobdy4GWNDzEYsycffOY6rdXW21vnqEUdKAeGSZU5ljgAlhNg3HpSgdSkKSpOZj0fQGRs4Lo8d7Zk4RP6AjEPe2m0yJLJaga6gWT+fLegV0RhgUfOIBp7lLMpBC+hxzuSKRh19ZmSxpaTb0OQvZJPVxobDp+YKpflEauzq3Z2NA1tSTzwaD1Npcyr3iweArp/LaO1X7PjnKwdatvakl6PvuXNgYmgmuzSHRmZVg1Uslseml9t7Ol47MWQtcT1r63p29+UTUuLogf6eQbRjal+/Kbw8BRbquWKnlg9f1X83a5TMEkeXyy3X9QAdavO32c0xNEGv2Nzl3PiFKr3L0pRcTCyWY/Mz8X3ny1JdB1VtzFCzQbv98su2AveDWAJpSqrR23Zvf3PvG23NLWggPDs8/LmP/+fv//Kbq3ZvGp1f+I+Pv+e516c8Pm9nd9PUVARWO/z2M0NnILsbmpt1kjB84fyBI8dvu+2WNatWda7quetjH47EQ+hsnoc1xPMkEK5CdgAyCosdGSDIf5JYgGPMzGWK8LLNNJMvyTBoM7k8j3YRQDNSpIN0uiJqhmo8gwQm9j3VuWxONAeUUQcHB4W1JpFmhKNPqanJmWJZ8li5jZva+1c3sHIG/d2swer8xBu0g2adVDhKbe63HVjOKSJ15vED/T7qzWdeveKm6zi6OT2fmjh4yGphWy6/knLJ6ZGhfY8OudeaOwOrLL4GymQrV2eKSt5f34FA+uLwsKPLg22uUiXxpftf3XbtZR3dqzi7J7h+owFd61VA29OhdG7p6HSwG7jP8B233zl1evxURvWvvuaZ117R20xyfBn9DRgF2/GmThw5GPEHkNMGQqujrQOZvve977Z0Mn5haLgkZZ586Z8//eV///G+v6YzxXt/9USFY7bv+eWpY8+U8oscJVx1y7V17cG3XnnbYLehE6zT2dDe2u7zeGw2c0UuJ0p51E/Gy9mf/uhXRiNCNthjBWUeoDphfNJ4B7XtQC0KAhMtlAwwelgebTTyaG+IzxEmR58HdEpAAk+poPagXBTNRnO5XCa1slgiHB8TMijlhLYy02whk3ECexpf5vgAqkYKqDJjUlYLdmKzSmjEV99lNE70NdjsjQ29jDkWz80slTQzFctJo+ML/atbg83dk8feQLfo1PApR3vn9Xdd3fTU2YTDbaHR+xOhbyGxHAq0NWmpKG3Sp6NT7oGgkkWrVfrSns2zBxcXz1/ovGhTJFScz51bt3sTNn85Onp692V3vLD/leMTiV3O6VLFeWhpuRI6iRLRPLZLRts8+LWAN/NsOB0iu7NoOtAI+8mhBdnIyAgiMuOziwGvK+hnrr9s3euv2tRpxeEJ2O18Jn1u4+ZVrZ5GnzupJhav2NF3aN9hkA4hSSDp0LrG63J73W4Ei7DJzG/v+83o3MTC5LiKTDvCSeB49OQgFZZkzz4kG2qJBL0OmzVhgRg1DcVOdUbOYzY4nVYJzg9VzeQBNxZQNA49A0cciS8gMLBFuVQSAE8AjJHk3oGKV5Uda1Zds31XZHi8JcB0rguMnr3g9dS3drpRgfC7R585di5/y7XuvvqWrv4BnWY/dOH48dNnG7yO0NLSf9xxp7+RXZ5J/fXeZ2+6vKdjbZ2psY2zG/Y//FD/1p2CofHI8QNeih3YenU2MpVIzBqqjv2/3/vhJz8t02x0bHRVT+OpBXp5YfbEaLakM46OTNvbgqq+qSKH2KoNvRlprQC9hioVBMtQeILMFZJQaP8NKGxndxfCbIqgzS0vtLW1kQ13g/7FuQUU4KFrKXAUzz/xZ1GnPP2P5/YdOUzz9nw8YrAHo+EYQN6N3fpQEYUg4uS5CYebdBBt7+hY1d68PLN8wy1XAcH82U9/npR7M9hqJVYEXraUQFsjNOiCK4fkDVYAUrZopk4glxYO0Qw0v9XzolxFz0/EOgB1RxtkLBV0rQNQHK0PsdONifNYLAG/b345lodaoRl0I8dyQuKuia186Y47RUpkBEWPLMDSYvsqGwpvmltWpcrL/rZObLyxtLxg1Bu9XR25REHTyQ5HfV5GCwB1bnExNHRy/fo1FZk9PLR/+kzm61+/IofaCL312L4zkZJatdIL81Fosx0DQYen+eCTz7Wub3e7mnW2wAMP7x8P56lGNEIErpcHtjyfAbmBPNTF8zm72YJEOrpKoEUdSQGCdbBlhCTzrNkAsLiRBecMDvYPnTmFTqiLc3PwWZ0OdGJxx2Kxu95/4yVXXMehZ7SBwz5tjz74yDNPP1lfZ59eQKMu6EGK7H8AOqq0y+PoXrMpnUx4PYH1a3v2bLvYE3TaHa6dl1xmIW1TaIfD2d3VPnJ2eGo2jlZ7Ogp9z5AVR3sw0nyls6NV12ZxIFNcgsmqVk3ouo4NUmkV+HeXTgWubo3f19fYjnpkQDY4E+AwmDQzEKdPv3HkbCKJALWT577zoZswYchpI1AFcFloctTGFlyNJlHn9FoakdOBFhmJpQ8OzVNm4nOgtX04W0Avb/S/yUh6tGMx6dFlsnR5t1lNJaLnF26/daB5XevYibOvnZ+1NLbA+gKmZE1TQ8eGnjIKehThe78/soSlbDBko0mL3lrhKYvTSQqjseUAEOpKFeVfgF0CZUMwbAQGwaLjBgByLBry1vmFsuQP+GFkI99CCl2tCHll0X8Bx/T1D3zpvz6HSAIy8dj1F+cW8jmovGiB+8PPv3JyZCKZyPJGKxY+dhcAig3lSjt2XobOFsFA3do13V2NQafPg77SH777E6jFBBYynUqCag67qaWxHlno4QtD0UQZzcsRSbVZoLzMzDduuOHo+YkX0MIU+hnhJWAwtKpVqfY4rW3gB5sFXdexnyayEDw62BlQMqtDfOOmyy8JPflUVlZbvF706YJ+AaYbXRNQxeOpC6gRVS+6EdreO3zkreXZPEmOG7yu5hKBwTNGTelt7c9UAOeXZL0I3qwgcGG1HsmIDOVv3tB+vmxj056ea25b97Eg2oJ7A+bEvFKJJ8EBoXBp/4ljWYZB4CiSiHp9AZTAoYAFzZUIIIWoOaCb1FRKcnucSGphF0sUwqHyDiB9gKvQIS6fyrs87jqvfyI/gTZfoaWkA2UbVvPSyIX+gd4PvPdWtJRzYE82ThcPLyPuYg86dAo/H4mjjMtps+M+UKAE/MgArQX615Qlw+eyqA3A7nzAljPxcII4uijRJhs8VtL4Bhj8dBJeQXtLR7DREAkn0cUkGQ+VUgXds++7WUAbPEX3+wP7o8QEVX2qdnt7kxsN37Glh9eLFIwRhcWkfyPaEXOoQZZlNMsQTC57uWKCE90ScCNrAUjd+MT0spVOLebSVSSm+DC6bchVCwc3kjJwNkGHNK4ADm3vXOWoVMeiEWzaiZ7giKNCBBI5J+PRWCNAjTYjQsAKqsYLcaaKBJHF5XGudrVyFWastOQFxLW/c3RkvBhPYPfcgY3b0J/5L/94DNyCVDtYCKAbzAEy6FB8gC8QWCHqeG1gc+niLdsEuTg6dQFuBr71+fxQA+gK7rGaeZuhUMpHIjE0nVYl9P2w33vvPQ88+Ngvf/LNvz741LnR0eGzYwgioMsWFhY2IyGROFLpUu1ZNeANNBrN1oDHd+d7r4EEvO/3f3z51b212Bz6C2WAq0A+B0wKJgYZsRDlkoipcnqckizqnnzfzVDIMjo2seq9bw6lBemW7ibY0sBOIOEDuxMZOcTCDUYeTi8AZlAfUgl1jGV0dcUj8hYLVQTQxSlVlcVk4g9vHdE77GarEWAN7BuJaCijsAjiw+zDjozYJ4LMlCqBT9DYErod4UGUXKFfF/CoEE6CltEJHNQJj0oV+Cqkny8q1CFRDAheAX4DNHEt4gjgHYoWUR3MqwoxBZDigBsPgQPtii0HEGUBkAq7RVrsNtjdTqcTBdNANiwuAW8LhBy2OCgAqI+4XntHTzyaOnfulM6CLTOxQVAZO4yA1xrr67tXd8LDgqKzu60i9rzPlgZ6tqKPQyI7cez4cKZcILNcUS/beaPD5ctlc7jL1Zdt7+hqvv2OO7HTB2YCzTMyqTiCasScRGoa/jSp70apDAwCxHDRENOje+lDH0AjRBFI+EQ6RaOBWibASpyOMVhtuoricQMwa6HMSL+jiRdgBlIiUSQ9DUlYj+Yo1JfrkXwGB6vozqynZd7453fegqYD4oxsMIhsosmFPrioFckj8sCZAI2q+dkF+CRYbainhVVGit0INlAngk6SDBAOSn4A+iB9MXEhvEFTxwqaZnAcwP9G7FrnR21HtZLDkiK1LHCR8bQwigFjoNHVBOXRKHcgWA9gfPAsmWwSq1wWRSD5ybRCMcAbqlS9Xi+aehWLBZsTig0yGHFFxm50kP4H2D0PyxCSApoDn+qr61evn5yd6OvuOX3uDGqE9r15DBOAqdqwcWcimu3rX71hzeqWzrZf3nffueEz8JPQuwzwYDTR6Vm76suf/Awsi6GzEUS+Txx+NpMvGdEgTs0Bz4JxUiIQCnoafZbS0ZBTr8K+RDYRGWWU9hmNHFAycFNhzGLvFQgzFIorZdHn96E4Fn1iwLroY4hWbgbwKq3Bvuj2OoeSKTiBeM+bPeg5r+G5rSiD1mP7ZgE92IDA11No54BRwgeHUgFKGUpeKcPzoKFpgBKGmiFNyACbwTxjbw+cIZLeFwr6dEpIGKUAbkZ9BnYnIthCtArUM5CM0K4gFXLiKHVEqQ8MOqEoRNIpAruC6QI8KTA3iOWinYOoeDw+i80GJYxwPrwnssezip7AenhVMvoLUCzpC0TmtoJoILYbX4iHIHCGxyeDLcBSVVE2A9wnovHoAwo2gr8iqeXGRj/aJqIMBNIVNiTGjtU5NTvLmKihQ0Pu4GAktYDtPTPpNDZP9visBPkIDoCGgnkKcYEbW4yknTqaz2pI+LLc7PSixWQ2Ou2YS3TZhI/O2lxAwhQKRTNN2Z0BtK1WRNWMHYZQ4Y8yXSV7zdq++L63LmTiCQTTqyGsJcgubH4FkYnHJlB70v3CSMoxgJBC7YvFgrVCPkbRsw4SHBWfCH+ixBERGvAyiEnK1mFRAFEL+pImrkC3yaQMgOD00fcVUTpyXVwQax13I/4mAcziBlg+BHCF66EOHYUzSDBWnW6HOWjFQTiRNIjALrmUhu1JgETDWbgOehAAhE5cUax7yH1ypBwKLWNm4aKGkxG7xYrtydEOEsLO4SbxWp/HWV/f/NmvfAEqB227iKwhliOM/mo6HL7xhtssZuAang+H5ngLoKdw2aXcYhJPx2jYbRuiRVcJF6PoPKeUkHnCpkos4kTY2AeGWq4iJObSZCNmIy9jUtFdpaKY0EXFbAWu1e+35IUMy1p8ztbJ8XEz9lZI57+8+8pcpfrRF59AtT7ge5AS2KEFHhCQZ6hTAYXykopt1mCuMUa5mE1wVjSuB9lJtpVBGxGUXAMri152IDz8EDAmFhcgtOBcVGKDyrWdygkuDTxJmJvQHm12oQ8gefEBJCwUJM4l3xJsD/wbNJplgfBA4AsfYgyQoyQkAxOuil08y2a03YDNAlCaTgdnGBOGKiV0xCaFpbCssJ80ZhnxGIaFGRKOxb2uVegUY3CgMZvRZnG4bb7v/vcPQLkymozLIouCFDSKIG1VgG+EqyoW9Xk5KTo8dtgFBO0ChoP4JTuRVzns64YoZzYaaW7vtflcVt6MzRmS+TQQP8msjM7zpEBBry/KZcK1hUJNu2AagTE2JSJFu6shk0gAZO5v9BVTWT1wobxWktP3XHftt55+iUYEDqIVZhmDrY/w6OBroo+wwQgIKeUFCO9SPM2hdQORYTBlwXcs6T2OEZJqLFgzSH+gsRQYGREEzB8WCuQSWd3Q0MDugPHRlwSkhBIgMQbcDXE7jiA7YQti5F6fF1cAQUnfYQhHBglTeKS4AtlfWoKuwqWQNVFko9FK8Ikop0EMhjA+2VwBrIP/sMLRuAz3wKLCf3Z3ENVhqpyGaYP43dvH38JX2JUVzh6hEmEM1EeiFRDeIIVMoU4BwFKYPZhpg9UI0QZcEYZHGy18GWYNmn6Y0W/cHHD4BLnMOW1IgQqa6GlpWLVprclpL+QVqxkyC9oU9bGEGmjoH07EgaCYnV7ALrLAglVKElxMnUzcPHQ3bXLxPjQJRo9pklyrYlsM9MtEIxd0EgVbQfJCQyG2gedBGg+z1IatRewopA64LHYMm3AxGTzoTkQ47vguuxKgGFgRnEpIhflA1zD8xCmE8wl1ICoQ8IG5U+VNJq+vDvqZrD74yuigVINAk1PhRyEkgPAxljlIiboXwmYrWLaV2cVyBXAdo8B8ky5y+Im/ESnAFqIuV+OVl7/HzMMpq6QzKPZBD3wIDA4eHGF5lLASkxWLhzT6wN2gSmFtYDsRNO8mgSFkXzCfBgPMQbKP1dmx4U7UcuiNc6PT7oAPuXif15uOF4uRvNJYNrpsHV5vNhWFcYoENoaBFDwSZ3ggfZVn5BJi1jBEYLCmsN+c0YLdDMhucJSGnchQSounoVHGWWF9XjcZFJDrUgllIFCA2HoN8m5tu9/lNCdlweV2RBKJtvbV2QtDck1i4XmBsAdfk24kSFmBFhDEBMeMf7COZLfLQ7i1JnDRRImIICCfzWan24kPIdhwAt7UVDO0OCuB19CDGuodS4FIamwZhU0qUcheq+LDUDEtZCrR7BErV48qGqGMDXuJtULatmqoGIfCMCwtn6hv2glrm9cZXn7zBZQWAXOFzQ+IxqEgxKC2IR+xCLCFF3p4EE4hi1qHmrUiFhRUj8GAPaKr6KlVLKUF1OMyRv1yPGm2mLO5LNmkSGIg2gQkvLCE7Q6gVQAYk3IlGv3baSa8FG5qCsBORymSuLyks5p9g2sTkVhVwub105rfDYDpC+EiU+8yZ7GlTEkF9hmZexmNYAjWDAa6xWxGwg2lJyBlrpzrbA1mQ0KgoQ4GUSw85jDpsxJqVpA4BWeD9OjGjPmF6CSdF2pigRQU2m0OVLkQgmGUUOdAQ8I24kkhPAwK4kMQOQtgMamMhD4BW5Au9+SFllcwcgiDo+kQpgHduSHB0OgEthPWDiYcYGJUWGIxkXWloRcKtoUgSwSwcKRS0pXovr0vIoHxxv69pLQbSxKKBt2biIKCbpKJdIehToKfaC6EG2E5E0MDP4GBhprBjMDeZXKaEskn0F4ICwNOOcCOqXQSKGwRaS80dLe7y5my02UsV6hV/f2n8sdQO4taco5i1ITo4A2pRLqpPRiJRqYPH0UrLMrqUWi7Zq4/HE/sL+WwVM2NloApYHLwkaU4zETi5jBcNgeYHoDuaAyB5ujiQjxjdkU3Nq57bP9Ll+3e2eBL5EVpaDKOpwICFz3zwIAoLUdaCTX/0Cbw78HIIDFhIoArsbxRio+dDIjUAa4eRjgALDLR4DT8MpG1WsF6CBpg9vARpgerCsQAV5K4vIrYGGlDjdlF/1pY/SRsDAOJZ8m2ibyVNIyHw1gtYw5wGq4ByQiwuypWsWMxZwY8kxRroPU2ngrIOQwH1wW9EaiAsCQyjyxZIjKxdvETKwBrAylEAt2NxZKYEDTIqCKloqDspoLNL4RKxYCmHGoViF34YFiIQa8/GY6R62JfU6BBITfBZKUCOqpjv2eDBfXnHEKjiMlwVvdwNDFfUvRiFX5RqQwkuZxP5lAnDmwLlh4MTSP2ZoLdi9IU7GsL9cybT5+dzJbjuqp4YuiUyWRDYAKjt5AYPZSFEcchAABuhgzH3kmwf9D7Ctch4huqGmIN4lURMTbMCnlOLBooQbIdCjZbIBtz4HLQDbBYiRAjW+fBJcCqIPxJ1gG+w6VxCtnilTAsvsTcEEJBMQANjhbzmMyaJsAJRHZBvuiqqMoiqhqVqLUdMMiZeBzwA2miAt0uYRaITsByBTeRFVD7WVM5yErAr2IWFiO1vSd4jKCIsJFSKWAzAN4IJxymodWOjSjYRDRhdTtSyTQsGlgXmZLkpBlRUMEqGEAqJS9jyzxeQEQYTRfG5heWXbZQFtANuEd8NZPIJWiHx4buOfDXQQI8KeJJpEsLfByCt9Jh8zSD3TmXim3o7pjMlBO5nMHmsFhK8GzxnEUhhx3DsZARnISHC30OAhTyeV8wmM3nIBCJhKUAFi4BciMTrwHqG6V3kAmQ2oROWE8gATQAZgIiC0TBd7BALAAi4gjsmgrgOZxkSC3oZAoJJwYBJaI9GQ4oEegCzHQV5ZaQYyggZTk41SAfb0IrXQQBEdcHyKxoMtfLagazSDYyxVRCgSALhiajqKLBJNeWHHiarADi6BAeQ6UxI6hCplhELg2WGVYNhBMEJUaOIcJJwJRjL786rwv6yOd2I63qwVYBNl2n1VNMJKeKUXKbqrlu52B+HnUfseagt85lctOO46GZs8CYGE2k6hVoA+ytKordXa2Tk7O4Pow/xO3RowJVg2R51zze0enpp77/6bt/93AyEWoIdKPvHfQd8bwgfAUQgcP2FZDXdoMtGU04ODsQ4OAawHTAFvCcsSMt6uHgYPt8bpfDzrtseCCX1wETa82aTp7DfsamTDQxfPYsttWIzCxmS0W0vUGXd6S0EF6EfsXj4xLwGdUS0c8VoQIhBkeVNKOELoXyIN3LNJQ6gYj4C2EGg4WDVEeMC3wZjU2jBAXluZhsLDisOxxHuL7mcxDSQ8YRvxIqjdgQmAO8ZziLqWqslnRoGA6niZQwl0TEGExIHMF59/jcaGMWS6bkVKJiUjmNbLnR6gjGcuLpicmmNgdmzGr3SEvzUyemOgIeo6FRyEkeZvk9G3wLJzIxBbEBEk7Ag4GfsFUtPBo8KFmH8D6RJyVmNQnjQKYZjLb5NMqKgHs1MmYFdf5Y64C++r2uunov9rLDsNu39xcTwskzZ9BATUmi1RT6xCGszZpQxKxKAY9j45Xved9dHwgXI6SAQirFMyUITMQs0JzA5/E29LcNXnERAOUOtFs0O2HRIKA8dHr01Vf3nhg6msmmAUtGUhON8wFILygZlJ2mSkUOCSrsbGi3SekcirxXvEU8AfQ2tjVMA4rA2YollEcgjGFA0pNULNWMV0ikmuiBmIQgxPAR7gDcF94Q3hI5SaQZLDA0oLOA8maUYJJNeaCACnLebuYQEuawS5mo2Oz25VTI7vbG4+EI2mNbchEhB8e4IGg+NCn2ehBLuOKSTYDEC2WlrqMjPDeqleU1fn88lgYzEJdHEaH3sMUucYSIgCaURxUaWeQoq8cIKTS+cEklVEKbJJVGNHjr6vp1uy/p7m2dHRtv7G1DLQRk6ubtW+16PlEsRmNphxLff2Hu7ddeFdKlT9x9d+dAX4PdAwUls2pSl0lF0gQ1RbCaMjoCFQUYLEXEP6EF0HikoMsjzmZmbLhx/+aezVsHEAuC83/m9JknHn7qyPHD8MAQwgLsH6SDFQNNhC6JUKOwxEA9cBD+gw9sMZsSKc3ncgJDZjRbQFmISuLg4ieZhxrXg9PB72Q11M6rkR/viVLGk3/Io3O4/MiJINsAzQ0jBUGbdCpjNhvtJt5tDkLAUaxY56t74Il/IkhH23hJVzGjZEw2Yg+knlW9Nh32DzWiKZLH5Qd+PgfVqOXPzF2YNzsPxYsIZ4LiMA0BtkANGokPkPgHaQqJkZCsBdxfdP4iGwaUbr5s0NLaRVstt+y5CvulFX2ufUfemR6bQiok0NVx8Y5NXkCENXtKKUAZ+RnjsdzUydELvN3c6nBtquuFJoUFbUCBATA1mXA+m8H+9ehhiJ5V2PoM6SbE4qxmdDbBDm1IeqEUEmFAE/wNdFusx2YfOp0RNasV0rQPEm8xHLn7k3cXE6i20JCbROACQhkQRDRYkdHgW0UtF8DU9tnZGcDIuwYHsUM6oifx6AISZcCbwAIm9IXSf1cOEQceGgJUh9VAZnDFy/xydz1sOGxRbbdi+1B4EDBAlVJOtARd8HqdHi8izkfP70UKxukOTsxEEOqnRSoQtG5eM9Dc1l7KFVE7D0NaghDLCeiUw7ltpXwWiIbvvHiwYLOBh5BOQPj+6t7WmYXYckGirFCV2KMMlj2HTUHMGltS0bac27N5+09/9VOIrGQp9ZMnntq5qmPf5GgsNmOEfZ0N3/PAv0ZGJlB9udoasJktEJaYNoWtjGSHz4UXu3xt66zY77IZ2EqPCTuHluEvgw9h0iMmJ2koTZGz5cxiJAqD02hCuJlnANfRo/kPiUKhy2EWOHCfz2NrNeuM+MSKPaprNfHH3jn589/9rphOQVeT3a5hNmBT2Fo2BsRFIJcxWWYnphEs6GzuHB0ew8aOFR1YlHQXJTlGTAP4DHlGGFe1CArovmJ+wSIgdvAPN7dVK3pfsBH7QxaKEpC92OOJ2HYMmuZbY6FIPp21BIwIjiJiCofWinBcRr30luvtaEaCMGy5mFoKY89aPBO25YZFhr4CqSz2IFR+enYenbKQvzFT7JUXbWqSBcAFdDb3k0dPTSQiCCWhfBUZPRgwVViKfOX1Fw8XdVo3o2Jniu++8sYNey63u6vDB/cuL83vvvL6PMG8WsBS3WiIqZEGDxKKhCpV7PmD/hyHR46vbx9ww+AHTyMbZ7YS6w9uAbG70ZMNYSuiZIniQ+yIRksCKV/GXqtp+D3oBm6y2A12B7xcNCaA3ICfCOcMM0SbXTaZ0as0unfNxsKvP/cy9k8/PXyhmA6TMnlAJ4FbcLnnR0dRL+Z2B5EiykvoBI7mLMT9RRNBzCVp80oQEpAEuD+RX0RCkc5xEA0aUy6I2EYQ20n3r10zPRkCuZHpx26RUJ1SMR+PJxDP0cpocmVCqgTxcsaCEk4XrMOkoliR0DKhrCRCk53I0Dytik3RsB4l2VaAY4N9tnldHc82Wd11DMNpPPCmaMp/w7Ytf3jhmSIw2AhfYEQQlh7jV3/8VRYVZTTzz70HTkfnrrtqQ7OJ+9Gffn3oxZc+cddH68ydIpWEQVWC541tslTNbLIiM6EhtClUPay93uAzko5zkGfE7oSxC+Ig6eqra4YsRzQS4QY8Mr6C4kHIAPu9Oi0ehw+IdpglaiwZiWN/LaTqHCh+Z2kgkSVFp/LI5NN6K4QFvC+X3f2lz38arDw8Pb/v9VdefP2lVCKezmVYuWSyWeG6lspFfytauqE5qVBFAzK5etme7Q6yAevsqfOjuWIJ6hcRJ0wDFgGEHMxR4ll8NtjVs3Vw3bpOVID0da2ZHkJm9zD2yipmEZ9gk1rGwzuQgkHiDykOzmaLLuYCHnMAerktYLE1FnMJE/x44ORFbA4F3LtqdjhlVRhLxv549Px/XnkprcB2pHKiaqWRd0X2goN9h67VP3j2WSQV0awQlt1Tr/3LYnIhDZlIhEci0TqfLxpLcHIB+9mGkst3bLp0bjHDuK1wcg3YgYi3YNdWZCFs2HhNRSySQRzHSmxZNDnkSYQaXldVW5o+z5vMwcZuBK0wLqwE5Mry+VQhnfPXN9AGO6DisG2ID4H2BdBSENeIOBPnqLyUXEDeljMiawlkA0+2S9TQAcaEe8HrAKwHDpSIZpV6FUVIiOktLkQWw6Gh0yfePvD2kf2kOggmGYmBUMTdQdQJSBSy9ybhhVpsnBigmAZMRlX38B03681sUye6LDChydDy+RlalwO7IkmMPrKyUTVUdNjoiTebM4WCUABggW9tCAbdLvj+iVKuHs2JigV4xqiJhe1GlUXsLwVE6cvD431dfWa7niphUauFkmC3oFTbgKQKkVx6DQ0xH3xtb9bAwsP/9S++TenNZpfbbLRFFkOc12kJBhBftAR8frsX9csoPodu8HkD2POptaUBZc2CVM4UhABvddpsoB2LNQiBSgLWcMIge7LY6aO9u0uPXBQCC+hvBTArAFKVqq+xtSaWUOWHJQgCoLttmQY2ExoSgaeVQDfcaURvsANqVV2MLiAFBBwjtq1GuQrZXoNGlBf7tVoI1ghQFmzFiLAATM4KhZ4Fd9x1977X99YuBmFfC8KB5lB4IDk8AvhvtfatRAwRHa1jsvEFlztIL2fovJg7c9Rt4kRey2DnKdSNF5EY4ceXkyhSxi7Ljoru+j07bNh6rpi3+WyAyFkoD+xf7JdqtBgKmVKwrh7xdjSOHE+nI4uR9Sg2LquIjmHZVxkDdtECc4J/lpZjXFXx1dvb/L7TmURPczA2Og+Uvd3usfO0b2C9TtV5gPDmTTOjY5I0lRfhgxZKQKPrqoWUHG92lMp5PWf317fk/C0Zvc5qddQ3NKvIjoLJ8MjoJqNy9U3NiKihlkGWsZ9uLp1I1TXVARcH8CRsYGRp4AAiVV2TzhZQHy94SaAOERE1rxWTydNcm7+NxHaIZCOSG+hkzAfKsigDaVuDlK0BXYQoCD0JexjBM3/kkQc/+Z//+cIzL5OIOGlBTWO3YaKJa0YBYnzEKCf2D4ZJZBET7OipX1UvjkVee+MffovTbbaUZeS11dBSGvsyJhbi5TL0CLWmo26wtd0OOpVpu9evt/M2zhBdinZ1dExPzyGOCHZAKSsyDjoTkyuXOAsPyYRQJ8VbqogLMSzqKY0WUz6DAhB0c8Pw0HYfGUR9b2fLqkZLPldYOHI4Ve+CkvE73RMnjglKOpJIcoih5YrBgM8G1GoiZWtoR0tqJBLgGPX2Dxgc7tELo3CgGhpbCQkxvZBBVZIGQGIE0w38gwQtBwwsEjLAxxGwqwCqoBcHsMokkgSBAvoiukQkBknLEMUIL50ECkj+jniwWLF6AzA2JCcAPLOmxw5aEmqD0Hob2Gc8Br5HizEN2zjYcLE7P3znKy+8AYcDKwMcB18HrhUuT4gO6iNISpYeWQmYA6a+3jV28OTh5w/SbsPZsZSBytjqWKmMHcbQwVdqbm7ctrknH83C1rQ4jLQRStaIPQ1hQSHIjJmPxRJA8KFrh8luhZyDJE+JiWw+7rPaUZMDxi9LRXAIkDmgTCGTxSDQt1FDIBGhNBLUYgNOz8zUkt/jDLYEEgksvURybtZq0DLZEhobW6yuYMAvoNcTU+WbGxNFbsOlN8BnJrQGbSjdqjXrSbSZhMFgmhMyQrgQDIvJjAqrfDoJ0wZNO+HdAoiAHC5sLyBDlGIaFR0AT4D2mDOchoFB/CBKAwlJJBN+YTZJ/zBsQwLDHdhl4FYQ0UO0FFVxaJ4LO4lkDGqLh0g/jIZkzyrKzq17cCS+QL4ENhA8WRKBIE4ZrgwZRMygmuuJ21LMN7/5a/BFHOZUkspTFBoTbFXk9saO5rpmtMd028zp+QgtG/vXb1BtLAV7HXhXTbVY7CVIVRUQlxIPTIcqd3c1o6dDLLKM6FW9t463ObH5kwwgOdobkOQ3shiAO8AxFSGtMWh4QEB+gXY92/Y097QZWYPZ5Zqdnjah/4WRP37gZH07lk21obFlw8UbZt8ebtvdA9COwRwgVYjgXLAnWquCh6DvRAmIFRALAVRYnwTpASVD8lb60NJCe1tjraMCJ5HkkB6mjlAsQDw4LHaiAEhMAIxIgvhgf5CdlHoCPlUsgasRo8OU4EuYpJhxGBBgaIQT0GcLZgyCWgT6AnlFYgwkZQxzi4gVVfn0xz48cuLMqYkxgD1xKIyCdwEDUPlQ+ivRCNwcIsjsY8WUsrujfVXA1uyv93gC0VhoKRJp6mjA9KUjIXtdezkURs2eEbfDfg+oqUY+aHxhemHUZkKEi3OYfB0DaxHr55wVf0Vd1uLob6zjyV1RvorMNNJENocDRj+qf5ABzUQyJmxUQVXD6RQi/YAXMs4Gs9WDPtjtPQ4j8ETYLUrO93esbe1sq6A/AWVqungbDHTW4MLjoEM2+IaIUbLlHEXyFkjuk3gGCW8IkM5GEzII4DSi7+RKKlNEwwgAZiGaSF4foXyaG58821LVrB4/er3VsvzY0aEm40kjbg6TRzYXISINEw3HF2Yt6aqJ8lskqsDKJO9GMjkIr1aA1FlhaXyCCeZ5E+Dp111/rcdiveTqa5Ox9EuvvjAxO0Uy1QiPI0hXM5Vr164thM1bdvT2DPT0reuua6nSYjS5gLIzVM0X42mkYiiICqHEWS3pvFjQM0vxNATf7MKChBZmCN0inaLo0BI9uhgiUj6nWNDhWNGJcGjkEvBFGGsF5WCYZzCRDkgP1cLbEY3DuONosqwg7Vh1+61mDpsAk6bYqLTSZPHC6SNoN9TWv0mTLUazXywC4AlDV4SQVsoFKEIiPxHRRbQXVMf/kLtY4cT4QSZYhf1AvoX7DfC22ZaIhLBEsPsqGBfIGBn7VQtKU2MTa7QUUAldLKMNChKfRDiQFxEmNb5G6BMvuIvQ1bUUCkBAEowegAoAXSR4fcL5yO6R3K7RZDAhyYg1g6gq5JLHH2TMPJYRag5ufd8ta9euL+SLyAfXbkIsBSLliCCgmMz0henR6IY1/rmIEGxw1jd0nj+6H1poZnzGjmgQNhxRWEvbWldnC3yT1mvXxw+9BcEiY1cIE7BY8OTl6MJ025o1C9NTSN3AO8wXMiqsYx0NrQtcmSZqZifArkYQB6ZCNi85nOiyiYrrMiqfqwbdqy+8fPkHbuJYf3Ih7HE4Hn3wSfSf+Nq3PlHGPlHeOh3ca1KN75CFLLbNhI9kQBQDCVSSy4SdiF05DZAGMFIwKaA+ESW4LmCPaEYFDcOxHe2dJUkBrAK7uwJbAkMeugPpJoAzrS4TUgyEunghiQhyAGVVIy0Yn8gSzCRpVIAdzwhcX49uuxBuRGZB+6JZGaQR9skmL3IuvKAakACT2NDU/Mtf/BqtZKD/wX2ocOls72hrbzt+4ijSLLUpxuUJ+9AhmrvhWx9//MlXk0w8rRZiy6OYmlg0ge2ULRaDWNIxZnshmWIAARXkQi5fYZxQ0MjYQdgC/c0E3CaLJZ6IocwqnSvlC3jYcrKMfH6KqDeasvkdsIwgR4HgQooD0Tok/ky8yebgrE7IZXH81JgulbExFO/gH334b3orfe0dN2g2L1UpMpU4MncS2TYtiRrdUiaDfXFIbEtBqAc5FoQxUDgEXweLEeYl9FEBDf+ha6GQjTAeEWQowv4M6636nJBbGB0xWmgkFdGjTxSLCC8QCiMDTKwc0o4e+hmeMhpNS2jNlojkUnESRaBkFC4ShV9VS4U8doMH1bGhXgH2XCGHuSfTT+xEYknVFhAuCxISHEYZSwU4qRz8DzkUWTx89ADQA6A+cRYJ/clq+38AwpndIWB+4K4AAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [12:58<00:00, 63.02s/it, test/blurry_cossim=0, test/loss=1.54, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=12, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.777, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000194, train/num_steps=1824]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [12:58<00:00, 64.87s/it, test/blurry_cossim=0, test/loss=1.54, test/loss_blurry_total=0, test/loss_clip_total=0, test/num_steps=12, test/test_bwd_pct_correct=0, test/test_fwd_pct_correct=0, train/blurry_cossim=0, train/bwd_pct_correct=0, train/fwd_pct_correct=0, train/loss=0.777, train/loss_blurry_total=0, train/loss_clip_total=0, train/lr=0.000194, train/num_steps=1824]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "===Finished!===\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_cossim = 0.\n", + " test_blurry_cossim = 0.\n", + "\n", + " noise_scheduler = DDIMScheduler(num_train_timesteps=timesteps, rescale_betas_zero_snr=True, timestep_spacing=\"trailing\", prediction_type=\"sample\")\n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode().mul_(0.18215)\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " \n", + " clip_target = clip_model.embed_image(image)\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_latent = model.backbone(voxel_ridge)\n", + " blurry_latent = blurry_latent.view(len(blurry_latent), 4, -1)\n", + "\n", + "\n", + " # diffusion\n", + " noise = torch.randn_like(blurry_image_enc)\n", + " times = torch.randint(0, noise_scheduler.config.num_train_timesteps, (len(voxel),)).long().to(device)\n", + " times[0] = timesteps-1 # setting first sample to always start from noisiest timestep, so our epoch-by-epoch visualization is more informative\n", + "\n", + " input = noise_scheduler.add_noise(blurry_image_enc, noise, timesteps=times)\n", + " blurry_image_enc_ = model.diffuser(input, times, encoder_hidden_states = blurry_latent, return_dict=False)[0]\n", + " loss = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " utils.check_loss(loss)\n", + "\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # # forward and backward top 1 accuracy \n", + " # labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " # fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " # bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " if train_i > 150: # not using the full training samples because I just want to test whether this code looks to be viable...\n", + " break\n", + " \n", + "\n", + " with torch.no_grad():\n", + " with torch.cuda.amp.autocast(): \n", + " print(\"train\",times[0],timesteps-1)\n", + " ii = 0\n", + " image_enc = blurry_image_enc[[ii]]\n", + " reconst = autoenc.decode(image_enc.view(1,4,28,28)/.18215).sample \n", + " display(utils.torch_to_Image(utils.resize(reconst).clamp(0,1)))\n", + "\n", + " reconst = autoenc.decode(input[[ii]].view(1,4,28,28)/.18215).sample \n", + " display(utils.torch_to_Image(utils.resize(reconst).clamp(0,1)))\n", + " \n", + " image_enc_ = blurry_image_enc_[[ii]]\n", + " reconst_ = autoenc.decode(image_enc_.view(1,4,28,28)/.18215).sample\n", + " display(utils.torch_to_Image(utils.resize(reconst_).clamp(0,1)))\n", + "\n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + "\n", + " # random sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == batch_size\n", + "\n", + " blurry_image_enc = autoenc.encode(image).latent_dist.mode().mul_(0.18215)\n", + " \n", + " clip_target = clip_model.embed_image(image.float())\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " clip_voxels, blurry_latent = model.backbone(voxel_ridge)\n", + " blurry_latent = blurry_latent.view(len(blurry_latent), 4, -1)\n", + " \n", + " # diffusion\n", + " emb = torch.cat([torch.zeros_like(blurry_latent), blurry_latent]).float()\n", + " noise_scheduler.set_timesteps(num_inference_steps=40, device=device)\n", + " \n", + " latents = torch.randn_like(blurry_image_enc) * noise_scheduler.init_noise_sigma\n", + " for i, t in enumerate(noise_scheduler.timesteps):\n", + " input = noise_scheduler.scale_model_input(torch.cat([latents] * 2), t).float()\n", + " uncond,cond = model.diffuser(input, t, encoder_hidden_states=emb).sample.chunk(2)\n", + " pred = uncond + 7.5*(cond-uncond)\n", + " latents = noise_scheduler.step(pred, t, latents).prev_sample\n", + " blurry_image_enc_ = latents\n", + "\n", + " loss = mse(blurry_image_enc_, blurry_image_enc)\n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # # forward and backward top 1 accuracy \n", + " # labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " # test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " # test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " with torch.no_grad():\n", + " with torch.cuda.amp.autocast(): \n", + " print(\"test\")\n", + " for ii in [0,1]:\n", + " image_enc = blurry_image_enc[[ii]]\n", + " reconst = autoenc.decode(image_enc.view(1,4,28,28)/.18215).sample\n", + " display(utils.torch_to_Image(utils.resize(reconst).clamp(0,1)))\n", + " \n", + " image_enc_ = blurry_image_enc_[[ii]]\n", + " reconst_ = autoenc.decode(image_enc_.view(1,4,28,28)/.18215).sample\n", + " display(utils.torch_to_Image(utils.resize(reconst_).clamp(0,1)))\n", + "\n", + " if local_rank==0: \n", + " if utils.is_interactive():\n", + " # clear_output(wait=True)\n", + " print(\"---\")\n", + "\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_cossim\": blurry_cossim / (train_i + 1),\n", + " \"test/blurry_cossim\": test_blurry_cossim / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + "\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "# if ckpt_saving:\n", + "# save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABFCElEQVR4nO3dd1zU9eMH8NfdcRxD7pANMlUEREUE9yRXVJbfyoalWFZaWpnf6puNb+P3LVs23ZWamWZLs7LSTMWRMgQ3KoiCCLLvGHLc+Pz+YBS5ODz43Hg9H4/7g+POe3GZ9+LzXhJBEAQQERERiUQqdgAiIiKybywjREREJCqWESIiIhIVywgRERGJimWEiIiIRMUyQkRERKJiGSEiIiJRsYwQERGRqBzEDtAaRqMR58+fh5ubGyQSidhxiIiIqBUEQUBVVRUCAgIglV75+odVlJHz588jKChI7BhERETUBvn5+QgMDLzi962ijLi5uQFo+GGUSqXIaYiIiKg1NBoNgoKCmj/Hr8QqykjT0IxSqWQZISIisjLXmmLBCaxEREQkKpYRIiIiEhXLCBEREYmKZYSIiIhExTJCREREomIZISIiIlGxjBAREZGoWEaIiIhIVCwjREREJCqWESIiIhIVywgRERGJimWEiIiIRMUyQkREZMf2nS7DlM/2o7ZeL1oGlhEiIiI7pDMY8e5vJ3DvJ/uw61QpFm/PES2Lg2ivTERERKI4W1aDJ7/KRGZ+JQDgrvhAPDqqm2h5WEaIiIjshCAI2JBRgJc2HkFNvQFKJwfMv70Pbu7jL2oulhEiIiI7oKnT4aWNR/BD5nkAwIBQD7x/T190cXcWORnLCBERkc1LP1uOJ7/KxLmKi5BJJZgzOhyPJXSHTCoROxoAlhEiIiKbpTcYsWh7Dj764xQMRgFBHs748J5Y9AvuLHa0FlhGiIiIbNC5ilo8tT4TqWcqAAD/iu2C126LhpuTXORkl2IZISIisjE/HjyP5zccRlWdHp0UDvjfxF6YGNtF7FhXxDJCRERkI6q1eryy6Si+TT8HAIgNdseHd8ci2NNF5GRXxzJCRERkAw7mV+LJrzJwpqwWUgkwO6E7Hh8dDrnM8vc3ZRkhIiKyYgajgGXJOXhvy0nojQICVE744J5YDAjzEDtaq7GMEBERWakidR2eWp+JP0+XAQBu7u2PN/7VGyoXy5ukejUsI0RERFbo1yNFeO77Q6is1cHFUYZXbo3GpLhASCSWsXeIKVhGiIiIrEhtvR7/99NxrEvJAwD0CVThw3tiEeblKnKytmMZISIishJHz6vxxLoM5JTUQCIBZozohrlje8DRwfInqV4NywgREZGFMxoFrNiTi7d/PYF6gxG+SgXeu6svhnb3EjuaWbCMEBERWbDiqjo8/c0hJJ8sAQCM6+mLt+7og86ujiInMx+WESIiIgv1R9YFPPPNIZTV1MNJLsVLt/TE5AHBVjlJ9WpYRoiIiCxMnc6AN3/Jwqq9ZwAAUf5KfHRPX4T7uokbrJ2YPOMlOTkZEyZMQEBAACQSCTZu3HjVx+/YsQMSieSSW1ZWVlszExER2awTRVW4beGe5iIyfVgYNs4aYrNFBGjDlZGamhrExMTggQcewB133NHq5504cQJKpbL5a29vb1NfmoiIyGYJgoAv9p3F6z8fh1ZvhFcnR7w7KQajInzEjtbuTC4jiYmJSExMNPmFfHx84O7ubvLziIiIbF1ZtRbPfnsI27KKAQCjIrzxzp0x8HZTiJysY3TYnJHY2FjU1dWhZ8+eePHFF5GQkHDFx2q1Wmi12uavNRpNR0QkIiLqcLtOlWDu1wdRUqWFo4MUzydGImlIqM1NUr2adi8j/v7+WL58OeLi4qDVavHFF19g9OjR2LFjB0aMGHHZ58yfPx+vvvpqe0cjIiISjVZvwLu/ncAnu3IBAOE+nfDRvbGI8lde45m2RyIIgtDmJ0sk2LBhAyZOnGjS8yZMmACJRIJNmzZd9vuXuzISFBQEtVrdYt4JERGRNcopqcYT6zJw9HzDlf8pg0Lwws1RcJLLRE5mXhqNBiqV6pqf36Is7R00aBDWrFlzxe8rFAooFPYxTkZERPZDEASsT83Hqz8ew0WdAZ1d5Hj7zhiM7ekrdjRRiVJGMjIy4O/vL8ZLExERiaKyth7PfXcYvx4tAgAM6+6FBXfFwFfpJHIy8ZlcRqqrq5Gdnd38dW5uLjIzM+Hh4YHg4GDMmzcPBQUFWL16NQDggw8+QGhoKKKjo1FfX481a9bgu+++w3fffWe+n4KIiMiC/ZlThqfWZ6JIUwe5TIJnxkfgoWFdIZXazyTVqzG5jKSlpbVYCTN37lwAQFJSElatWoXCwkLk5eU1f7++vh5PP/00CgoK4OzsjOjoaPz888+46aabzBCfiIjIcukMRnzw+0ks3pEDQQC6ernio3tj0auLSuxoFuW6JrB2lNZOgCEiIrIUBqOAR1anNe8dck//IPx3Qk+4ONrPSSwWPYGViIjI1s3ffBzbsoqhcJDi/bv74qbenCt5JSafTUNERERXtz41D5/ubtg/ZMFdMSwi18AyQkREZEb7TpfhxY1HAABPjemBW/oEiJzI8rGMEBERmcnZsho8uiYdOoOACTEBeGJ0d7EjWQWWESIiIjPQ1Okw/fM0VNTqEBOowjt39rGr82WuB8sIERHRddIbjHh8bQayi6vhp3TC8qnxNre1e3tiGSEiIrpOb2zOws6TJXCSS/FpUjx3VTURywgREdF1WLs/Dyv2NKycef+uvtzQrA1YRoiIiNpob04p/vtDw8qZf4/tgUQu4W0TlhEiIqI2OFNag0fXHIDeKODWmADMvoErZ9qKZYSIiMhE6os6TP88FeqLOvQNcsfbXDlzXVhGiIiITKA3GDF77QHklNQgQOWE5VPjuHLmOrGMEBERmeB/Px/HrlOlcJbL8ElSPHzcuHLmerGMEBERtdKafWexau8ZAMD7d/dFdABXzpgDywgREVEr7M0uxcubjgIAnhkfgRt7+YmcyHawjBAREV3D6ZJqPPrlARiMAv4V2wWPjeomdiSbwjJCRER0FepaHR76PA3qizrEBrtj/u29uXLGzFhGiIiIrkBnMGLW2gM4Xdq4cmYKz5xpDywjREREV/B/Px3D7uxSuDjK8GlSf3i7KcSOZJNYRoiIiC5j9Z9nsPrPs5BIgA/u7oueAUqxI9kslhEiIqJ/2HWqBK/+eAwA8Oz4SIyL5sqZ9sQyQkRE9Dc5JdWY1bhy5vZ+XTBzZFexI9k8lhEiIqJGlbX1eOjzNGjq9IgP6cyVMx2EZYSIiAgNK2ce+/IAcktr0MXdGUunxEHhwJUzHYFlhIiI7J4gCHhl01HszSmDq6MMnybFw6sTV850FJYRIiKye6v/PIsv9+dBIgE+vCcWUf5cOdORWEaIiMiuJZ8swas/Npw589yNkRjT01fkRPaHZYSIiOxWdnEVZq09AKMA3BkXiEdGcOWMGFhGiIjILlXU1GP652moqtOjf2hnvP6vXlw5IxKWESIisjv1eiMe/TIdZ8tqEdjZGUvv58oZMbGMEBGRXREEAS9vOoJ9p8vh6ijDZ0n94cmVM6JiGSEiIruycs8ZrEvJh0QCfDw5FhF+bmJHsnssI0REZDe2nyjG/35uOHPmhZuicEMkV85YApYRIiKyC6cuVOGJtRkwCsDd8UGYPixM7EjUiGWEiIhsXnnTyhmtHgPCPPB/E7lyxpKwjBARkU2r1xsxc0068sprEeTRsHLG0YEff5aE/zWIiMhmCYKAlzYeQUpuOdwUDliR1B8ero5ix6J/YBkhIiKb9dnuXKxPy4dUAnw0ORbhvlw5Y4lYRoiIyCb9kXUBb2w+DgB44eaeSIjwETkRXQnLCBER2ZwTRVV4Yl0mjAJw74AgPDg0VOxIdBUsI0REZFPKqrWY/nkqqrV6DOrqgVdv5coZS8cyQkRENkOrN2DmmnScq7iIEE8XLLmPK2esgcn/hZKTkzFhwgQEBARAIpFg48aNrX7unj174ODggL59+5r6skRERFclCAJe3HAEqWcq4KZwwGdJ8ejMlTNWweQyUlNTg5iYGCxcuNCk56nVakydOhWjR4829SWJiIiu6ZNdp/FN+jlIJcDC+/qhuw9XzlgLB1OfkJiYiMTERJNfaMaMGZg8eTJkMplJV1OIiIiuZdvxC5j/SxYA4L+39MTIHt4iJyJTdMhA2sqVK5GTk4OXX365VY/XarXQaDQtbkRERJeTVaTBE+syIAjA5IHBSBoSKnYkMlG7l5FTp07hueeew5dffgkHh9ZdiJk/fz5UKlXzLSgoqJ1TEhGRNSqt1mL6qjTU1BswpJsnXr01mitnrFC7lhGDwYDJkyfj1VdfRY8ePVr9vHnz5kGtVjff8vPz2zElERFZI63egJlfpKOg8iJCPV2w+L5+kMu4csYamTxnxBRVVVVIS0tDRkYGZs+eDQAwGo0QBAEODg7YsmULbrjhhkuep1AooFAo2jMaERFZqfKaemzMKMD61HycuFAFNycHfDatP9xduHLGWrVrGVEqlTh8+HCL+xYvXow//vgD3377LcLCwtrz5YmIyEboDUbsPFmCb9LOYVvWBegMAgDAWS7Dkvvi0M27k8gJ6XqYXEaqq6uRnZ3d/HVubi4yMzPh4eGB4OBgzJs3DwUFBVi9ejWkUil69erV4vk+Pj5wcnK65H4iIqJ/OnWhCt+kn8P3BwpQWq1tvr93FxUmxQfi1pgAXhGxASaXkbS0NCQkJDR/PXfuXABAUlISVq1ahcLCQuTl5ZkvIRER2RX1RR1+PHge36Sfw8H8yub7PV0dMTG2CybFByLSTyleQDI7iSAIgtghrkWj0UClUkGtVkOp5F9AIiJbYzAK2JtTim/SzuG3o0XQ6o0AAAepBAmRPrgzLhA3RPpwgqqVae3nd7vOGSEiIrqas2U1+Db9HL5LP4fz6rrm+yN83TApPhC39e0CbzcuaLB1LCNERNSharR6bD5ciG/SzyElt7z5fqWTA27r2zAM07uLivuF2BGWESIianeCICAltxzfpJ/D5sOFqK03AAAkEmB4uDcmxQVibE9fOMllIiclMbCMEBFRuzlfeRHfpZ/DtwfO4WxZbfP9oZ4umBQfhNv7dYG/ylnEhGQJWEaIiMis6nQG/Ha0CN+mn8Pu7FI0LZNwdZTh5j7+mBQfhPiQzhyGoWYsI0REdN0EQcDBc2p8k5aPTQfPo6pO3/y9gWEemBQfhJt6+8HFkR87dCn+rSAiojYrrqrDxowCfJN2DqeKq5vv7+LujDviAnFnv0AEe7qImJCsAcsIERGZpF5vxB9Zxfg2PR/bT5TAYGwYh1E4SJHYyw+T4oMwuKsnpFIOw1DrsIwQEVGrHC/U4Ju0c9iYWYDymvrm+2OD3TEpLgi3xPhD6SQXMSFZK5YRIiK6ooqaevyQWYBvD5zDkQJN8/3ebgrc3q8LJsUForuPm4gJyRawjBAR0SXOVdTijc3H8fuxYtQbGrZml8skGBPli0nxgRgR7g0Hbs1OZsIyQkREl3j6m4PYd7phd9ToACUmxTVszd7ZlSfkkvmxjBARUQvlNfXN27R/O3Mw4kM9RE5Eto7X2IiIqIXtWcUwCkCknxuLCHUIlhEiImphW9YFAMDYnr4iJyF7wTJCRETNtHoDdp4oAQCMjmIZoY7BMkJERM32ny5HTb0B3m4K9OmiEjsO2QmWESIiarbteMMQzehIH+6gSh2GZYSIiAA0HHb3+/FiAMAYDtFQB2IZISIiAEBWURUKKi9C4SDF0O5eYschO8IyQkREAIDfjzUM0Qzr7gVnR5nIaciesIwQEREA4PesxiEaLumlDsYyQkREKNbU4WB+JYCGyatEHYllhIiI8EfjVZGYQBV8lE4ipyF7wzJCRETNq2i40RmJgWWEiMjO1ekM2J3dsOsql/SSGFhGiIjs3J7sUtTpjAhQOSHK303sOGSHWEaIiOzc7027rkb5QiLhrqvU8VhGiIjsmNEoYNtxLuklcbGMEBHZscMFahRXaeHqKMOgrh5ixyE7xTJCRGTHmg7GG9HDGwoH7rpK4mAZISKyY1zSS5aAZYSIyE4VVF7EsUINpBIgIcJb7Dhkx1hGiIjs1B+NQzT9gjvDs5NC5DRkz1hGiIjs1FYO0ZCFYBkhIrJD1Vo99uWUAQDG9uTBeCQulhEiIju062QJ6g1GhHi6oJt3J7HjkJ1jGSEiskNNq2jGcNdVsgAsI0REdsZgFLD9RNN8EQ7RkPhYRoiI7ExGXgXKa+qhdHJA/1DuukriYxkhIrIzTUM0oyJ8IJfxY4DEZ/LfwuTkZEyYMAEBAQGQSCTYuHHjVR+/e/duDB06FJ6ennB2dkZkZCTef//9tuYlIqLr9NcpvRyiIcvgYOoTampqEBMTgwceeAB33HHHNR/v6uqK2bNno0+fPnB1dcXu3bsxY8YMuLq64pFHHmlTaCIiapuzZTXILq6Gg1SCUT1YRsgymFxGEhMTkZiY2OrHx8bGIjY2tvnr0NBQfP/999i1axfLCBFRB2saoukf6gGVi1zkNEQNOnywMCMjA3v37sXIkSOv+BitVguNRtPiRkRE1+/3Yw1DNGN6ctdVshwdVkYCAwOhUCgQHx+PWbNm4aGHHrriY+fPnw+VStV8CwoK6qiYREQ2S12rQ8qZcgDAGM4XIQvSYWVk165dSEtLw9KlS/HBBx9g3bp1V3zsvHnzoFarm2/5+fkdFZOIyGbtOFkMg1FAuE8nhHi6ih2HqJnJc0baKiwsDADQu3dvXLhwAa+88gruvffeyz5WoVBAoeAJkkRE5rSNB+ORhRJlgbkgCNBqtWK8NBGRXdIZjM27rnKIhiyNyVdGqqurkZ2d3fx1bm4uMjMz4eHhgeDgYMybNw8FBQVYvXo1AGDRokUIDg5GZGQkgIZ9R9599108/vjjZvoRiIjoWlLPlKOqTg8PV0fEBncWOw5RCyaXkbS0NCQkJDR/PXfuXABAUlISVq1ahcLCQuTl5TV/32g0Yt68ecjNzYWDgwO6deuGN998EzNmzDBDfCIiao2mIZqECB/IpDwYjyyLRBAEQewQ16LRaKBSqaBWq6FUKsWOQ0RkVQRBwKh3d+BsWS2W3t8PN/byFzsS2YnWfn7zUAIiIhuXU1KNs2W1cJRJMTzcW+w4RJdgGSEisnFbjzUM0Qzu5glXRYctoiRqNZYRIiIbt63xYDyuoiFLxTJCRGTDyqq1SM+rAMD9RchysYwQEdmw7SdKIAhAT38lAtydxY5DdFksI0RENoxDNGQNWEaIiGyUVm9A8skSADyllywbywgRkY3ad7ocNfUG+Lgp0CtAJXYcoitiGSEislG/H2sYohkd5Qspd10lC8YyQkRkgwRB4HwRshosI0RENuhYoQbn1XVwkksxtLuX2HGIroplhIjIBjUdjDesuzec5DKR0xBdHcsIEZEN4hANWROWESIiG3NBU4eD59QAgBtYRsgKsIwQEdmYP7Iahmhigtzh4+Ykchqia2MZISKyMU1LesfyqghZCZYRIiIbcrHegN3ZpQB4MB5ZD5YRIiIbsju7FFq9EV3cnRHp5yZ2HKJWYRkhIrIhf19FI5Fw11WyDiwjREQ2wmgUsK1x8iqHaMiasIwQEdmIQwVqlFRp0UnhgIFdPcSOQ9RqLCNERDaiaYhmRA8vKBy46ypZD5YRIiIbsfVY03wRDtGQdWEZoetWpzMg/WwFDEZB7ChEdutcRS2yiqoglQAJEdxfhKyLg9gByLpdrDdg8qf7kJFXiT6BKvxvYi/0CXQXOxaR3Wk6GC8+xAOdXR1FTkNkGl4ZoTbTG4yYvfYAMvIqAQCHzqlx26I9eGnjEagv6sQNR2Rnfm+cLzKau66SFWIZoTYRBAEv/XAE27KKoXCQYun9cfhXbBcIAvDFvrMYvWAHNmScgyBw6IaovVXV6bDvdBkALukl68QyQm3y4bZTWJeSD6kE+OjeWNzYyw/v390Xax8eiG7eriitrsdT6w/inuX7cOpCldhxiWzarlOl0BkEhHm5opu3q9hxiEzGMkImW5eShw9+PwUAeO22Xhgf7df8vSHdvPDLkyPwzPgIOMml2J9bjsQPd+GtX7NQW68XKzKRTWseoonkrqtknVhGyCTbjl/ACxsOAwBmJ3TH/YNCLnmMo4MUsxK6Y+tTIzEmyhd6o4AlO3Iw9r1kbDla1NGRiWyawShge+Ouq2N6coiGrBPLCLXagbwKzFp7AEYBuDMuEP8e1+Oqjw/ycMGnSfH4ZGo8urg7o6DyIh75Ih0PfZ6K/PLaDkpNZNsO5FWgolYHlbMc8SGdxY5D1CYsI9Qqp0uqMX1VKup0RoyK8Mb823u3+nLw2J6+2Dp3BB4b1Q1ymQS/Hy/G2Pd3YtH2bNTrje2cnMi2/d640VlChDccZPwnnawT/+bSNRVX1WHqihRU1OrQJ1CFRZP7QW7iP3oujg549sZI/PLkcAzu6ok6nRHv/HYCiR8mY292aTslJ7J9fy3p5RANWS+WEbqqqjodHliZinMVFxHi6YIV0/rDVdH2vfK6+7hh7cMD8cHdfeHVSYGckhpM/nQ/nvwqA8VVdWZMTmT7cktrkFNSAwepBCMjvMWOQ9RmLCN0RfV6Ix5dcwBHz2vg6eqI1Q8OgFcnxXX/uRKJBBNju2Dbv0di6uAQSCTAD5nnMfrdnfh87xluK0/USk0H4w3s6gGlk1zkNERtxzJCl2U0CvjPd4ewO7sULo4yrHygP0I8zbt/gcpZjtdu64VNs4ahT6AKVVo9Xt50FLct2o3M/EqzvhaRLfprSS+HaMi6sYzQZb392wlsyCiATCrBovv6tet5M70DVdjw2FD8b2IvKJ0ccKRAg38t3oPnNxyGupbbyhNdjrpWh9QzFQB4Si9ZP5YRusSqPblYujMHAPDm7b075ARQmVSC+weFYNu/R+H2fg3byq/dn4cbFuzAt+ncVp7on3acLIbBKKCHbycEe7qIHYfourCMUAubDxfi1Z+OAQCeGR+BSfFBHfr63m4KvHdXX3z1yCCE+3RCWU09nv7mIO5etg8niritPFGTrY1LenlVhGwBywg123+6DHPWZ0IQgCmDQvDYqG6iZRnU1RM/PzEczyVGwlkuQ8qZctz80S7M33wcNVpuK0/2TWcwYufJEgBc0ku2gWWEAAAniqrw0Oo01OuNGNfTF6/cGi36GReODlLMHNkNv/97JMZHN2wrvyz5NMa+txO/Hini0A3ZrdTcclTV6eHp6oi+Qe5ixyG6biwjhPOVF5G0IgVVdXrEh3TGR/fGQia1nMO2urg7Y9mUeHyWFI/Azs44r67DzDXpeHBVKvLKuK082Z+tjatoboj0saj/V4nayuQykpycjAkTJiAgIAASiQQbN2686uO///57jB07Ft7e3lAqlRg8eDB+++23tuYlM1PX6jBtZQqKNHXo7tMJnybFw0kuEzvWZY2O8sXWp0bi8Ru6Qy6TYPuJEox9fyc+3nYKWr1B7HhEHUIQBO66SjbH5DJSU1ODmJgYLFy4sFWPT05OxtixY7F582akp6cjISEBEyZMQEZGhslhybzqdAY8/EUaTl6ohq9Sgc8fHAB3F0exY12Vs6MM/x4XgV/njMDQ7p7Q6o1YsPUkbvxgF3af4rbyZPtOFVcjv/wiHB2kGB7uJXYcIrOQCNcx8C6RSLBhwwZMnDjRpOdFR0fj7rvvxn//+99WPV6j0UClUkGtVkOpVLYhKf2TwSjg8XUHsPlwEdwUDvh65mBE+VvXeysIAn48VIj/++kYSqq0AIBb+vjjpVt6wlfpJHI6ovaxeEc23v71BEZFeGPVAwPEjkN0Va39/O7wOSNGoxFVVVXw8PC44mO0Wi00Gk2LG5mPIAj4v5+OYfPhIshlEiybGmd1RQRoKMO3xgRg279HYtqQUEglwE+HCjF6wU6s2J0LvYEnApPt+Z1LeskGdXgZWbBgAWpqanDXXXdd8THz58+HSqVqvgUFdexeF7ZuWfJprNp7BgCw4K6+GNLNui/1Kp3keOXWaGyaPQx9g9xRrdXjtZ+O4daFe3Agr0LseERmU1qtRUbjUQmjo9p/M0KijtKhZWTdunV45ZVXsH79evj4XPl/pHnz5kGtVjff8vPzOzClbfv+wDm8+UsWAODFm6Nwa0yAyInMp1cXFb5/dAje+FdvqJzlOFaowe2L92Le94dQUVMvdjyi67Y9qxiCAEQHKOGvchY7DpHZdFgZWb9+PaZPn46vv/4aY8aMuepjFQoFlEplixtdv12nSvDst4cAAA8NC8NDw7uKnMj8pFIJJg8Mxh//Hok74wIBAOtS8jH6vZ34Oi2fe5OQVWtaRcMhGrI1HVJG1q1bh2nTpmHt2rW4+eabO+Il6R+OFKgx84t06I0Cbo0JwPM3RYkdqV15dlLg3Ukx+HrGYET4uqG8ph7PfnsIj645gKo6Hr5H1qdOZ8CuxhVjLCNka0wuI9XV1cjMzERmZiYAIDc3F5mZmcjLywPQMMQyderU5sevW7cOU6dOxYIFCzBo0CAUFRWhqKgIarXaPD8BXVNeWS2mrUxFTb0BQ7p54p1JfSC1k42SBoR54KcnhmFeYiTkMgl+PVqE2xbuwckLPOeGrMufp8tQW2+Ar1KBXl14tZhsi8llJC0tDbGxsYiNjQUAzJ07F7Gxsc3LdAsLC5uLCQAsW7YMer0es2bNgr+/f/PtySefNNOPQFdTXlOPpJUpKK3WItLPDUunxEHhYJmbmrUXuUyKGSO74esZg+GvcsLp0hrctnAPNh08L3Y0olbb9reNzsQ+qoHI3K5rn5GOwn1G2qa2Xo/Jn+xHZn4lurg74/vHhtj9/htl1Vo88VUG9mSXAQAeGBqK52+KglzGkxHIcgmCgCFv/oFCdR1WTuuPhEiupCHrYLH7jFDH0BuMeHxtBjLzK6FyluPzB/vbfREBGuaSrH5wYPOJxCv3nMG9y/ehWFMncjKiKzt6XoNCdR2c5TIM7uYpdhwis2MZsUGCIODFjUewLasYCgcpVkyLR3cfN7FjWQyZVIJnb4zE8ilxcFM4IO1sBW76aDf2ny4TOxrRZW07XgwAGBbuZbFnRxFdD5YRG/TB76fwVWo+pBLgo3tjERdy5d1u7dm4aD9senwYInzdUFqtxeRP9+PTXae5/JcsTtOS3rFcRUM2imXExqxLycOH204BAF67rRfGR/uJnMiyhXm5YsOsIZjYNwAGo4D//Xwcs9dmoFqrFzsaEQCgSF2HwwVqSCTgXBGyWSwjNuT3YxfwwobDAIDHb+iO+weFiJzIOrg4OuD9u/vitdui4SCV4OfDhZi4aA+yi7n8l8S3LavhqkjfIHd4uylETkPUPlhGbMSBvArMXncARgGYFBeIuWN7iB3JqkgkEkwdHIr1MwbBV6lAdnE1blu4B5sPF4odjexc03wRbnRGtoxlxAbklFRj+qpU1OmMGBXhjTdu7819CNooLsQDPz0+HIO6eqCm3oDHvjyA138+xhOASRS19Xrsyeauq2T7WEasXLGmDkkrUlBRq0NMoAqL7+vHPTOuk7ebAmumD8SMEQ1n93yyKxf3fbofxVVc/ksda/epUmj1RgR2dkYP305ixyFqN/zUsmJVdTpMW5mKcxUXEerpgs+m9YeLo4PYsWyCg0yKeTdFYcl9/dBJ4YD9ueW45aPdSDtTLnY00ZRVa7FgywlMW5nC+TQd5O9DNLzaSbaMn1xWql5vxKNrDuBYoQaero74/MEB8OrEyW3mltjbHz383DDzi3ScKq7GPcv34YWbozBtSKjdfDicr7yIT3adxrqUPNTpGoarsgqr8M3MwQjycBE5ne0yGgVsy+J8EbIPvDJihYxGAc9+exC7s0vh4ijDygf6I8TTVexYNqubdydsnDUUt/Txh94o4NUfj+HJrzJRW2/by39Pl1Tj2W8PYuQ727FyzxnU6Yzo3UWFbt6uKNLUYcpn+1FSpRU7ps06eK4SpdVauCkcMCCMewWRbeOVESv01m9Z2Jh5HjKpBIvv64c+ge5iR7J5rgoHfHxvLGKDO2P+5uPYdPA8soo0WHp/HLp629ZY/pECNZbsyMHmI4Vo2v9tUFcPzErojmHdvVBcpcUdS/biTFktpq5IwVePDILKWS5uaBvUtNHZiAhvODrw90aybfwbbmVW7snFsp2nAQBv3t4boyK4CVJHkUgkmD4sDGsfHgRvNwVOXqjGrQv34NcjRWJHM4uU3HIkrUjBLR/vxs+HG4rImCgffPfoEHz1yGAMD/eGRCKBr9IJXz40EN5uChwv1GD6qlRcrDeIHd/m/DVfhP+Pk+1jGbEiPx8qxGs/HQMAPDM+ApPig0ROZJ8GhHng58eHYUCoB6q1esxck443f8myyuW/giBge1YxJi3di7uW/YmdJ0sglQC39Q3Ar3OG49Ok/ogL6XzJ80I8XbH6wQFQOjWc7fPol+mo11vfz2+p8strkVVUBZlUggT+wkF2gGXESuw7XYan1mdCEIApg0KaT50lcfgonfDlwwMxfVgYAGDpzhxMXZGC0mrrmENhMAr48eB53PTRbjywKhWpZyrgKJPi3gHB2P70KHx4Tywi/a583DcARPkrsfKB/nCWy7DjRAnmfp0Jg5Hn+pjDtsYhmriQznB3cRQ5DVH745wRK3CiqAoPr05DvcGI8dG+eOXWaLtZyWHJ5DIpXrqlJ2KD3fHst4ewN6cMt3y0G4vv74d+wZdeTbAE9XojNmScw9Kdp5FbWgMAcHGU4b6BwXhoeFf4Kp1M+vPiQjywdEocHvo8FT8dKoTKWY7/TezFv5/X6a9VNLwqQvaBZcTCna+8iKQVKaiq0yM+pDM+vCcWMin/obckt/QJQISvG2asScfpkhrcvexP/PeWnrh/UIjFfCjX1uuxLiUfnySfRpGmYfM2lbMcDwwNRdLgUHR2bftv3yN7eOP9u/vi8XUZ+HJ/Htxd5HhmfKS5otudqjod9p0uA8AlvWQ/WEYs3PxfslCkqUN3n074NCkeTnKZ2JHoMsJ93fDDrKF49ttD+OVIEV764Sgy8irx+r96w9lRvP9m6lodPv/zDFbuyUVFrQ4A4OOmwCMjuuLeAcFwVZjnn4Bb+gRAc1GP5zccxqLtOVA5y/HICA4ltkXyyVLoDAK6erna3EotoithGbFgdTpD89jxO3f24dixhXNzkmPxff3wya7TeOvXE/g+owDHCjVYNiWuw/eBKa6qw2e7c7Hmz7OoaVzpEuzhgkdHdcPt/bpA4WD+gjR5YDDUF3V469csvLE5CypnOe7uH2z217F1TUt6x/TkVRGyHywjFmxvTilq6w3wUzqhb5C72HGoFSQSCR4Z0Q29u7jj8XUHkFVUhVs+3o337+rbIR8u+eW1WJacg6/TzjWvbon0c8Ojo7rh5t7+cGjnc4seHdUNlRfrsWznacz7/jCUTnIk9vZv19e0JXqDEdtPNMwXGR3J+SJkP1hGLNiWow2/IY2L5rkU1mZwN0/89PhwzFp7AOlnK/DQ6jTMTuiOp8b2aJc5PycvVGHJjhxsOni+eUVLv2B3zErojhsifTr0789zN0ZCXavDV6n5ePKrTHRycsDwcO8Oe31rdiCvEpW1Ori7yC+7pJrIVrGMWCiDUcDWY41lpKefyGmoLfxUTlj38CC8sfk4Vu09g4Xbs3HwXCU+vCcWHtcxYfTvMvIqsHhHTvPfFQAYHu6FWQndMTDMQ5QSK5FI8Pq/eqOqTo+fDxdixhfpWPPQQItdYWRJmoZoEiJ82v0qFpElYRmxUAfyKlBWUw83JwcM7MpzKayVo4MUr9wajdhgdzz33WHsOlWKCR/vxuL7+iGmjUNvgiBgb04ZFm3Pxt6chlUXEglwY7QfHhvVHb0DVWb8CdpGJpXgvbtjoKnTYdepUjywMhVfzxiMCD83saNZtKYyMppLesnOsHpbqC1HG7YYHx3pAzl/Q7J6t/Xtgg2zhiDU0wUFlRcxaemfWJeSB0Fo/SZhRqOA344WYeKiPbjv0/3Ym1MGB6kEd8YFYutTI7Hk/jiLKCJNFA4yLJsSh37B7lBf1GHKZ/uRV1YrdiyLdbqkGqdLaiCXSTCiB4e1yL7wU84CCYKALY2X3cdHc4jGVkT6KbHp8WEY29MX9QYj5n1/GM9+ewh1uquf66I3NGxUNv6DZMz4Ih0Hz6mhcJBi2pBQ7HhmFN6dFIPuPpa5BNTF0QErpw1ApJ8biqu0uP+z/Shu3OeEWmo6i2ZgmCeUTjx4kOwLy4gFOnmhGmfLauHoIOVvSDZG6STHsvvj8OyNEZBKgG/Sz+GOJXuRX37pFYM6nQFf7DuLUe/uwFPrD+JUcTXcFA54bFQ37HnuBrxyazQCO7uI8FOYRuUix+oHByDYwwV55bWY8lkKKmvrxY5lcbY2LenlEA3ZIZYRC/Rb4xDN8O5eZtuUiiyHVCrBY6O644vpA+Hh6oij5zW45ePd2N64BXhVnQ5Ld+Zg2Fvb8dLGIzhXcRGero54ZnwE9sy7Ac/eGAmvTgqRfwrT+CidsGb6QPi4KXDiQhUeWJWK2nq92LEsRmVtPdLPVgAARnPXVbJD/KSzQFuONZSRcdH8R8mWDe3uhZ8eH4ZHvzyAg/mVePDzVNzUyx+7TpVAU9fwQR2gcsKMkd1wV3yQqDu5mkOwpwu+mD4Qdy37Exl5lZjxRTo+TYpvlw3YrM2OEyUwGAVE+rkhyMPyr3YRmRuvjFiYgsqLOFKggVTC35DsQYC7M76eMQj3DwqGIAA/Hy6Epk6Prt6ueOfOPtjxTAKShoRafRFpEuHnhpUP9IeLowy7TpXiqfU86Rf4a4iGq2jIXvHKiIXZ2jhEEx/iYXWX4qltFA4y/G9ib/QP9cBPhwpxe2wXjIv2s9kDEfsFd8byKfF4cFUqNh8ugtLpMObf3ttuN/ar1xuRfKIEAH8BIfvFKyMWpmkVDYdo7M9tfbvgk6nxSOztb7NFpMmwcC98dG9fSCXAV6n5ePPXLLEjiSYltxxVWj28Ojmib6C72HGIRMEyYkEqauqxP7ccADCWh2SRjbuxlz/evL0PAGDZztNYsiNH5ETiaNro7IZIH0htvIQSXQnLiAX5I6u4eRJbR5/ySiSGu/oH4YWbogAAb/2ahbX780RO1LEEQfjrlF4O0ZAdYxmxIM2raHhVhOzIwyO6YlZCNwDACxsP48eD50VO1HFOXqjGuYqLcHSQYli4l9hxiETDMmIhLtYbsPNkwyS2cdx1lezM0+MicN/AhhVFc7/OxI4TxWJH6hBNV0WGdfeCiyPXE5D9YhmxELuzS1GnM6KLuzOiA5RixyHqUBKJBK/d1gsTYgKgMwiYuSYdaWfKxY7V7ngwHlEDlhEL0bTr6tievna7xJHsm0wqwYJJMRgV4Y06nREPrErFsfMasWO1m5IqLTLzKwEAoyM5NEv2jWXEAugNRmw7ziW9RI4OUiy5Lw7xIZ1RVafH1BUpOFNaI3asdrE9qxiCAPTuooKfyknsOESiYhmxAGlnK1BRq4O7ixwDQj3EjkMkKmdHGT6b1h9R/kqUVjec9Fuktr2TfjlEQ/QXlhELsOVo4z9Kkb5wkPE/CZHKueGk31BPF5yruIgpn+1HRY3tnPRbpzNg16lSAFzSSwSwjIhOEAQejEd0Gd5uCnwxfSD8lE44VVyNaatSUa21jZN+/8wpw0WdAf4qJ05YJ0IbykhycjImTJiAgIAASCQSbNy48aqPLywsxOTJkxEREQGpVIo5c+a0MaptOlaowbmKi3CSSzEi3FvsOEQWJcjDBV9MH4DOLnIczK/EI6vTUKcziB2rTbR6A/bmlOLNX7Lw8qajABqGaDhhnagNZaSmpgYxMTFYuHBhqx6v1Wrh7e2NF154ATExMSYHtHVNQzTDw71t5mRWInMK93XDqgcGwNVRhr05ZXhiXQb0BqPYsa5JEARkF1dj5Z5cPLgqFX1f3YrJn+zH0p05yCuvhVwmwb9iA8WOSWQRTN5lJzExEYmJia1+fGhoKD788EMAwIoVK0x9OZvXdDDeeG50RnRFMUHu+CQpHtNWpmLLsQt47vvDePuOPhZ3lou6Voc9OaVIPlmCXadKUVB5scX3vTopMCLcCyN6eGNYuBdP5iZqZJFb/mm1Wmi12uavNRrb3Gsgv7wWxws1kEqA0ZGcUU90NUO6eWHhvbF49MsD+Db9HFTOcrx4c5Sowxx6gxEHz1Vi58lS7DpVgoP5lTAKf33fUSZF/7DOGBHujeHh3ojyd+OwDNFlWGQZmT9/Pl599VWxY7S7pqsiA8I80NnVUeQ0RJZvXLQf3rqjD57+5iA+252Lzi5yzL4hvEMz5JfXIvlUCXadLMWenFJU1bWcVNvdp1ND+ejhhUFhnhx+JWoFiywj8+bNw9y5c5u/1mg0CAoKEjFR+2jadXVcTw7RELXWnXGB0FzU4bWfjuHdLSehcpZjyuDQdnu9Gq0ef+aUYdepEiSfKkXuPzZhUznLMSzcCyPCvTA83BsB7s7tloXIVllkGVEoFFAobHsstaxa23z2xlie0ktkkgeHhaHyog4fbTuF/246CqWzHLf17WKWP9toFHD0vKbh6sepEqSfrYDO8NfYi0wqQb9gdwwP98aIHt7o3UUFmYXNXSGyNhZZRuzBtqxiGAUgOkCJIA8XseMQWZ2nxoRDXVuPz/88i39/fRBKJzkS2jj3qlhTh+RTDRNPd2eXovwfG6wFeThjRGP5GNzNE0onuTl+BCJqZHIZqa6uRnZ2dvPXubm5yMzMhIeHB4KDgzFv3jwUFBRg9erVzY/JzMxsfm5JSQkyMzPh6OiInj17Xv9PYKWalvRyiIaobSQSCV6eEI3Kizr8kHkeM9ek44vpAzEg7NpHKtTpDEg9U45djQUkq6iqxfddHWUY3M0LI3s0DL2Eerm2149BRAAkgiAI137YX3bs2IGEhIRL7k9KSsKqVaswbdo0nDlzBjt27PjrRS4zezwkJARnzpxp1WtqNBqoVCqo1Woolda/W2FtvR6xr22FVm/EL08OR5S/9f9MRGLRGYyY8UU6/sgqhpvCAeseGYReXVQtHiMIAk4VVyP5ZMO8j/2ny6DV/7VXiUTScGBdw6oXL/QL6Qw5j2Ygum6t/fw2uYyIwdbKyK9HCjFzzQEEeTgj+ZkELvUjuk51OgOmrkhBSm45PF0d8c3Mwejs4ojd2X/t+VGkaXnYnq9S0bjqxRvDunvBgyvaiMyutZ/fnDMigr8P0bCIEF0/J7kMnybF497l+3D0vAYTPt6NWp0Bf/9VS+EgxcCuns2bjoX7dOL/f0QWgmWkg+kMRmzLKgbAXVeJzEnpJMfnDw7AXUv/xOnG5beRfm4Y3lg++od6wEnOPT+ILBHLSAdLzS2H+qIOHq6OiAvpLHYcIpvi1UmB7x4dgv25ZYgN7gxfpZPYkYioFVhGOljTRmdjony4NwFRO+js6ogbe/mLHYOITMDp4h1IEITmLeC5pJeIiKgBy0gHOlKgQaG6Di6OMgwL9xI7DhERkUVgGelAW441DNGM7OHNiXRERESNWEY6UPOS3mieRUNERNSEZaSDnCmtwYkLVZBJJbghgmWEiIioCctIB2kaohnU1QMqFx6yRURE1IRlpIPwYDwiIqLLYxnpACVVWqTnVQAAxvbkEA0REdHfsYx0gG3HL0AQgD6BKgS4O4sdh4iIyKKwjHSApl1Xx/GqCBER0SVYRtpZtVaPPdllAIBxPBiPiIjoEiwj7WzniRLUG4wI83JFuE8nseMQERFZHJaRdta0pHdcT19IJDwYj4iI6J9YRtpRvd6IP7KKAXDXVSIioithGWlH+06XoapOD69OCvQN6ix2HCIiIovEMtKOmoZoxvb0gUzKIRoiIqLLYRlpJ0ajgK3Hmg7G4yoaIiKiK2EZaSeHCtS4oNHC1VGGId08xY5DRERksVhG2smWxo3ORkX6QOEgEzkNERGR5WIZaSfcdZWIiKh1WEbaQXZxNXJKaiCXSZAQ6SN2HCIiIovGMtIOmiauDu7mBaWTXOQ0RERElo1lpB38fddVIiIiujqWETMr1tQhI68SADCWZYSIiOiaWEbMbEvjEE3fIHf4Kp1ETkNERGT5WEbMbEvzRme8KkJERNQaLCNmpKnT4c+cUgDAeO66SkRE1CosI2a040QJdAYB3bxd0c27k9hxiIiIrALLiBk17brKs2iIiIhaj2XETLR6A3acKAHAJb1ERESmYBkxk705ZajW6uHjpkBMoLvYcYiIiKwGy4iZbDn61yoaqVQichoiIiLrwTJiBkaj0LwF/LienC9CRERkCpYRM8jIr0BptRZuCgcM6uopdhwiIiKrwjJiBk1DNAmRPnB04FtKRERkCn5yXidBEPBb85JerqIhIiIyFcvIdcoursaZslo4yqQYFeEjdhwiIiKrwzJynZrOohna3ROdFA4ipyEiIrI+JpeR5ORkTJgwAQEBAZBIJNi4ceM1n7Nz507ExcXByckJXbt2xdKlS9uS1SL9xl1XiYiIrovJZaSmpgYxMTFYuHBhqx6fm5uLm266CcOHD0dGRgaef/55PPHEE/juu+9MDmtpzldexKFzakgkwJgozhchIiJqC5PHFRITE5GYmNjqxy9duhTBwcH44IMPAABRUVFIS0vDu+++izvuuMPUl7covx9vGKKJC+4MbzeFyGmIiIisU7vPGfnzzz8xbty4FveNHz8eaWlp0Ol0l32OVquFRqNpcbNEf991lYiIiNqm3ctIUVERfH1bflj7+vpCr9ejtLT0ss+ZP38+VCpV8y0oKKi9Y5pMXavDvtNlAICx3HWViIiozTpkNY1E0vKsFkEQLnt/k3nz5kGtVjff8vPz2z2jqf44cQF6o4Aevp0Q5uUqdhwiIiKr1e5rUf38/FBUVNTivuLiYjg4OMDT8/JbpysUCigUlj0Ho3mIhldFiIiIrku7XxkZPHgwtm7d2uK+LVu2ID4+HnK5vL1fvl3U6QzYebIEADCeS3qJiIiui8llpLq6GpmZmcjMzATQsHQ3MzMTeXl5ABqGWKZOndr8+JkzZ+Ls2bOYO3cujh8/jhUrVuCzzz7D008/bZ6fQAR7sktRW2+Av8oJvbooxY5DRERk1UwepklLS0NCQkLz13PnzgUAJCUlYdWqVSgsLGwuJgAQFhaGzZs346mnnsKiRYsQEBCAjz76yKqX9f41RON7xXkvRERE1DoSoWk2qQXTaDRQqVRQq9VQKsW9EmEwChjw+u8oq6nHlw8NxNDuXqLmISIislSt/fzm2TQmSj9bgbKaeqic5RgQ5iF2HCIiIqvHMmKiLY1n0YyO9IFcxrePiIjoevHT1ASCIDSf0stdV4mIiMyDZcQEJy5UIa+8FgoHKUb08BY7DhERkU1gGTHBb0carooMD/eCi2O77xdHRERkF1hGTLDlWMN8Ee66SkREZD4sI610rqIWR89rIJUAo6N8xI5DRERkM1hGWmlr48TV+FAPeHay7HNziIiIrAnLSCv9fddVIiIiMh+WkVaoqKlHyplyAJwvQkREZG4sI62wLasYBqOASD83BHu6iB2HiIjIprCMtELTrqvjo3lVhIiIyNxYRq7hYr0ByadKAHDXVSIiovbAMnINu06VoE5nRBd3Z/T0F/fEYCIiIlvEMnINvx396ywaiUQichoiIiLbwzJyFXqDEduyGsoI54sQERG1D5aRq0g9U4HKWh06u8gRH9JZ7DhEREQ2iWXkKprOohkd5QsHGd8qIiKi9sBP2CsQBIG7rhIREXUAlpErOHpeg4LKi3CSSzE83FvsOERERDaLZeQKtjQejDeyhzecHWUipyEiIrJdLCNX0LTrKs+iISIial8sI5eRV1aLrKIqyKQS3BDpI3YcIiIim8YychlNq2gGhHqgs6ujyGmIiIhsG8vIZWz5266rRERE1L5YRv6htFqLtLPlAIBx3HWViIio3bGM/MMfx4thFIBeXZTo4u4sdhwiIiKbxzLyD03zRbiKhoiIqGOwjPxNjVaP5FOlADhfhIiIqKOwjPxN8skS1OuNCPZwQYSvm9hxiIiI7ALLyN807bo6PtoXEolE5DRERET2gWWkkc5gxLbjTUt6OV+EiIioo7CMNErJLYemTg9PV0f0C+4sdhwiIiK7wTLS6LfGs2jGRPlCJuUQDRERUUdhGQEgCAJ3XSUiIhIJywiAwwVqFGnq4OIow9DuXmLHISIisissI/jrLJpREd5wkstETkNERGRfWEbAXVeJiIjEZPdlJLe0BicvVMNBKkFChI/YcYiIiOyO3ZeRLY2raAZ19YTKRS5yGiIiIvvDMvK3XVeJiIio47WpjCxevBhhYWFwcnJCXFwcdu3addXHL1q0CFFRUXB2dkZERARWr17dprDmVlxVhwN5FQCAMT1ZRoiIiMTgYOoT1q9fjzlz5mDx4sUYOnQoli1bhsTERBw7dgzBwcGXPH7JkiWYN28ePvnkE/Tv3x8pKSl4+OGH0blzZ0yYMMEsP0RbbTteDEEAYgJV8Fc5i5qFiIjIXkkEQRBMecLAgQPRr18/LFmypPm+qKgoTJw4EfPnz7/k8UOGDMHQoUPxzjvvNN83Z84cpKWlYffu3a16TY1GA5VKBbVaDaVSaUrcq5q2MgU7TpTgmfERmJXQ3Wx/LhEREbX+89ukKyP19fVIT0/Hc8891+L+cePGYe/evZd9jlarhZOTU4v7nJ2dkZKSAp1OB7n80kmjWq0WWq22xQ/THh4cGgY/pRPG82A8IiIi0Zg0Z6S0tBQGgwG+vi3nV/j6+qKoqOiyzxk/fjw+/fRTpKenQxAEpKWlYcWKFdDpdCgtLb3sc+bPnw+VStV8CwoKMiVmq43o4Y037+iD7j6d2uXPJyIiomtr0wRWiaTlQXKCIFxyX5OXXnoJiYmJGDRoEORyOW677TZMmzYNACCTXX6303nz5kGtVjff8vPz2xKTiIiIrIBJZcTLywsymeySqyDFxcWXXC1p4uzsjBUrVqC2thZnzpxBXl4eQkND4ebmBi+vy58Do1AooFQqW9yIiIjINplURhwdHREXF4etW7e2uH/r1q0YMmTIVZ8rl8sRGBgImUyGr776CrfccgukUrvf5oSIiMjumby0d+7cuZgyZQri4+MxePBgLF++HHl5eZg5cyaAhiGWgoKC5r1ETp48iZSUFAwcOBAVFRV47733cOTIEXz++efm/UmIiIjIKplcRu6++26UlZXhtddeQ2FhIXr16oXNmzcjJCQEAFBYWIi8vLzmxxsMBixYsAAnTpyAXC5HQkIC9u7di9DQULP9EERERGS9TN5nRAzttc8IERERtZ/Wfn5z0gYRERGJimWEiIiIRMUyQkRERKJiGSEiIiJRsYwQERGRqFhGiIiISFQsI0RERCQqkzc9E0PTVigajUbkJERERNRaTZ/b19rSzCrKSFVVFQAgKChI5CRERERkqqqqKqhUqit+3yp2YDUajTh//jzc3NwgkUjM9udqNBoEBQUhPz+fO7teB76P5sH30Tz4PpoH30fzsPf3URAEVFVVISAg4KqH41rFlRGpVIrAwMB2+/OVSqVd/iUxN76P5sH30Tz4PpoH30fzsOf38WpXRJpwAisRERGJimWEiIiIRGXXZUShUODll1+GQqEQO4pV4/toHnwfzYPvo3nwfTQPvo+tYxUTWImIiMh22fWVESIiIhIfywgRERGJimWEiIiIRMUyQkRERKKy6zKyePFihIWFwcnJCXFxcdi1a5fYkazK/Pnz0b9/f7i5ucHHxwcTJ07EiRMnxI5l9ebPnw+JRII5c+aIHcXqFBQU4P7774enpydcXFzQt29fpKenix3Lquj1erz44osICwuDs7Mzunbtitdeew1Go1HsaBYtOTkZEyZMQEBAACQSCTZu3Nji+4Ig4JVXXkFAQACcnZ0xatQoHD16VJywFshuy8j69esxZ84cvPDCC8jIyMDw4cORmJiIvLw8saNZjZ07d2LWrFnYt28ftm7dCr1ej3HjxqGmpkbsaFYrNTUVy5cvR58+fcSOYnUqKiowdOhQyOVy/PLLLzh27BgWLFgAd3d3saNZlbfeegtLly7FwoULcfz4cbz99tt455138PHHH4sdzaLV1NQgJiYGCxcuvOz33377bbz33ntYuHAhUlNT4efnh7FjxzafvWb3BDs1YMAAYebMmS3ui4yMFJ577jmRElm/4uJiAYCwc+dOsaNYpaqqKiE8PFzYunWrMHLkSOHJJ58UO5JV+c9//iMMGzZM7BhW7+abbxYefPDBFvfdfvvtwv333y9SIusDQNiwYUPz10ajUfDz8xPefPPN5vvq6uoElUolLF26VISElscur4zU19cjPT0d48aNa3H/uHHjsHfvXpFSWT+1Wg0A8PDwEDmJdZo1axZuvvlmjBkzRuwoVmnTpk2Ij4/HpEmT4OPjg9jYWHzyySdix7I6w4YNw7Zt23Dy5EkAwMGDB7F7927cdNNNIiezXrm5uSgqKmrxmaNQKDBy5Eh+5jSyioPyzK20tBQGgwG+vr4t7vf19UVRUZFIqaybIAiYO3cuhg0bhl69eokdx+p89dVXOHDgAFJTU8WOYrVOnz6NJUuWYO7cuXj++eeRkpKCJ554AgqFAlOnThU7ntX4z3/+A7VajcjISMhkMhgMBrz++uu49957xY5mtZo+Vy73mXP27FkxIlkcuywjTSQSSYuvBUG45D5qndmzZ+PQoUPYvXu32FGsTn5+Pp588kls2bIFTk5OYsexWkajEfHx8XjjjTcAALGxsTh69CiWLFnCMmKC9evXY82aNVi7di2io6ORmZmJOXPmICAgAElJSWLHs2r8zLkyuywjXl5ekMlkl1wFKS4uvqS50rU9/vjj2LRpE5KTkxEYGCh2HKuTnp6O4uJixMXFNd9nMBiQnJyMhQsXQqvVQiaTiZjQOvj7+6Nnz54t7ouKisJ3330nUiLr9Mwzz+C5557DPffcAwDo3bs3zp49i/nz57OMtJGfnx+Ahisk/v7+zffzM+cvdjlnxNHREXFxcdi6dWuL+7du3YohQ4aIlMr6CIKA2bNn4/vvv8cff/yBsLAwsSNZpdGjR+Pw4cPIzMxsvsXHx+O+++5DZmYmi0grDR069JKl5SdPnkRISIhIiaxTbW0tpNKWHw0ymYxLe69DWFgY/Pz8Wnzm1NfXY+fOnfzMaWSXV0YAYO7cuZgyZQri4+MxePBgLF++HHl5eZg5c6bY0azGrFmzsHbtWvzwww9wc3NrvtKkUqng7Owscjrr4ebmdsk8G1dXV3h6enL+jQmeeuopDBkyBG+88QbuuusupKSkYPny5Vi+fLnY0azKhAkT8PrrryM4OBjR0dHIyMjAe++9hwcffFDsaBaturoa2dnZzV/n5uYiMzMTHh4eCA4Oxpw5c/DGG28gPDwc4eHheOONN+Di4oLJkyeLmNqCiLuYR1yLFi0SQkJCBEdHR6Ffv35ckmoiAJe9rVy5UuxoVo9Le9vmxx9/FHr16iUoFAohMjJSWL58udiRrI5GoxGefPJJITg4WHBychK6du0qvPDCC4JWqxU7mkXbvn37Zf89TEpKEgShYXnvyy+/LPj5+QkKhUIYMWKEcPjwYXFDWxCJIAiCSD2IiIiIyD7njBAREZHlYBkhIiIiUbGMEBERkahYRoiIiEhULCNEREQkKpYRIiIiEhXLCBEREYmKZYSIiIhExTJCREREomIZISIiIlGxjBAREZGoWEaIiIhIVP8P5/qE+eLTan8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses);\n", + "plt.show()\n", + "plt.plot(test_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2531871f-898c-44d8-8615-af50c09dff09", + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/accel.slurm b/src/accel.slurm new file mode 100644 index 0000000000000000000000000000000000000000..11bb681d3a9c71c1e7fab9caad3c17bc56a6a476 --- /dev/null +++ b/src/accel.slurm @@ -0,0 +1,38 @@ +#!/bin/bash +#SBATCH --account=topfmri +#SBATCH --partition=g40x +#SBATCH --job-name=ms +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:4 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=topfmri + +module load cuda/11.7 # should match torch.cuda.version + +export NUM_GPUS=4 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=512 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/paulscotti/MindEyeV2/wandb/" +export WANDB_CACHE_DIR="/fsx/home-paulscotti/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +########### + +cd /fsx/proj-fmri/paulscotti/MindEyeV2 +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=test --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=240 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel2.slurm b/src/accel2.slurm new file mode 100644 index 0000000000000000000000000000000000000000..5a77f09e229b364f56f5981ae3eacc335d131709 --- /dev/null +++ b/src/accel2.slurm @@ -0,0 +1,40 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=ms +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=512 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train-with-memory-cat.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=test_mem_cat_r --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=240 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel3.slurm b/src/accel3.slurm new file mode 100644 index 0000000000000000000000000000000000000000..130f69f8b70432ead472a8533913a20ef578265f --- /dev/null +++ b/src/accel3.slurm @@ -0,0 +1,40 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=ms +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:4 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=4 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=128 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train-with-memory.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=test_mem --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=40 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel4.slurm b/src/accel4.slurm new file mode 100644 index 0000000000000000000000000000000000000000..a8a4cb1620aeed99cf6a873f07153bbc4f0616bb --- /dev/null +++ b/src/accel4.slurm @@ -0,0 +1,40 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=ms +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=512 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=baseline_r --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=3e-5 --mixup_pct=.33 --num_epochs=240 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel5.slurm b/src/accel5.slurm new file mode 100644 index 0000000000000000000000000000000000000000..e96b16297caad3dcd4a95e344dd479f497724db9 --- /dev/null +++ b/src/accel5.slurm @@ -0,0 +1,40 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=memoryrr +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=512 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train-with-memory-rr.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=testing-rr-uni_r --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=1e-5 --mixup_pct=.66 --num_epochs=120 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel6.slurm b/src/accel6.slurm new file mode 100644 index 0000000000000000000000000000000000000000..761b0b158bba65eb676b541c8e5d59578402a1b0 --- /dev/null +++ b/src/accel6.slurm @@ -0,0 +1,40 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=memoryrr +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=4 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:# +export GLOBAL_BATCH_SIZE=512 + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train-with-memory-rr-dropout.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=testing-rr-uni_r --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --n_samples_save=0 --max_lr=3e-5 --mixup_pct=.66 --num_epochs=120 --ckpt_interval=999 --no-use_image_aug + +# --wandb_log diff --git a/src/accel7.slurm b/src/accel7.slurm new file mode 100644 index 0000000000000000000000000000000000000000..f501f9e1d459f10bb761edf401f6125ecdde27b7 --- /dev/null +++ b/src/accel7.slurm @@ -0,0 +1,41 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=memoryrr +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=8 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:#! +export BATCH_SIZE=32 +export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train_MLPMixer-Copy2.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=testing-rr-1024-past-5 --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.66 --num_epochs=120 --ckpt_interval=10 --no-use_image_aug --hidden_dim=1024 --seq_len=5 + +# --wandb_log diff --git a/src/accel8.slurm b/src/accel8.slurm new file mode 100644 index 0000000000000000000000000000000000000000..1cedbef47540386f6fefe3d797d91900f5ee0d9a --- /dev/null +++ b/src/accel8.slurm @@ -0,0 +1,41 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=memoryrr +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=8 # should = number of gpus +#SBATCH --gres=gpu:8 +#SBATCH --time=32:00:00 # total run time limit (HH:MM:SS) +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out +#SBATCH --comment=fmri + + + +export NUM_GPUS=8 # Set to equal gres=gpu:#! +export BATCH_SIZE=32 +export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train_MLPMixer-img.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=testing-rr-1024-img-past-2 --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.66 --num_epochs=120 --ckpt_interval=10 --no-use_image_aug --hidden_dim=1024 --seq_len=2 + +# --wandb_log diff --git a/src/accel9.slurm b/src/accel9.slurm new file mode 100644 index 0000000000000000000000000000000000000000..ef25ef433e7170fcef7c1422c49de27a5f6c7ef9 --- /dev/null +++ b/src/accel9.slurm @@ -0,0 +1,44 @@ +#!/bin/bash +#SBATCH --account=fmri +#SBATCH --partition=g40x +#SBATCH --job-name=blip2captions +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 # should = number of gpus +#SBATCH --gres=gpu:1 +#SBATCH --time=24:00:00 # total run time limit (HH:MM:SS) +#SBATCH --comment=medarc +#SBATCH --requeue +#SBATCH -e slurms/%j.err +#SBATCH -o slurms/%j.out + + + + +export NUM_GPUS=1 # Set to equal gres=gpu:#! +export BATCH_SIZE=128 +export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS)) + +# Make sure another job doesnt use same port, here using random number +export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) + +export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l) + +export WANDB_DIR="/fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb" +export WANDB_CACHE_DIR="/admin/home-ckadirt/.cache" +export WANDB_MODE="online" + +echo MASTER_ADDR=${MASTER_ADDR} +echo MASTER_PORT=${MASTER_PORT} +echo WORLD_SIZE=${COUNT_NODE} + +source /admin/home-ckadirt/.bashrc + +########### + +cd /fsx/proj-fmri/ckadirt/MindEyeV2/src/ +# accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT +python train2.py --data_path=/fsx/proj-fmri/shared/mindeyev2_dataset --model_name=caption_clip_0.5_bz --subj=1 --batch_size=${GLOBAL_BATCH_SIZE} --max_lr=1e-4 --mixup_pct=.66 --num_epochs=50 --use_image_aug --ckpt_interval=15 --clip_mse_ratio=0.5 + +# --wandb_log diff --git a/src/blip2_captions.py b/src/blip2_captions.py new file mode 100644 index 0000000000000000000000000000000000000000..044f932c43327926b837a09a5440c7424f9b9ef8 --- /dev/null +++ b/src/blip2_captions.py @@ -0,0 +1,71 @@ +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from torchvision.transforms import ToPILImage #CHANGED (added) + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 128 #128 + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + diff --git a/src/blip_tryal.ipynb b/src/blip_tryal.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..54e097de41588aed6055ac12a9da3f29c98e5294 --- /dev/null +++ b/src/blip_tryal.ipynb @@ -0,0 +1,578 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b76067e6-5fcc-49b8-b501-6fb267f3fbaf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-11-15 13:28:59,125] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7f621354-4f8a-475c-85b0-a9953e43c2fa", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import transformers\n", + "from transformers import Blip2Processor, Blip2ForConditionalGeneration\n", + "\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9553fb1f-aead-4fe6-a775-0f299699a539", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "cache = \"/fsx/proj-fmri/shared/cache/models--Salesforce--blip2-opt-2.7b/snapshots/6e723d92ee91ebcee4ba74d7017632f11ff4217b\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "02b8b258-e375-4857-894d-753b30c84610", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading checkpoint shards: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:39<00:00, 19.77s/it]\n" + ] + } + ], + "source": [ + "processor = Blip2Processor.from_pretrained(cache)\n", + "model = Blip2ForConditionalGeneration.from_pretrained(cache, torch_dtype=torch.float16, device_map=\"auto\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73b22d42-5619-4f25-9a03-18b48ce41e20", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import requests" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c27dd06-e81d-4e62-b889-b13189bf6742", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0e8d4bd9-46f7-400e-a2f1-385ce0fee947", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/generation/utils.py:1260: UserWarning: Using the model-agnostic default `max_length` (=20) to control thegeneration length. We recommend setting `max_new_tokens` to control the maximum length of the generation.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a man on a motorcycle rides down a dirt road\n" + ] + } + ], + "source": [ + "raw_image = Image.open('/fsx/proj-fmri/shared/controlNetData/target/img_t1.jpg').convert('RGB')\n", + "# Convert the image to a NumPy array\n", + "image_array = np.array(raw_image)\n", + "\n", + "# Add random noise to the image\n", + "noise = np.random.normal(loc=0, scale=0, size=image_array.shape)\n", + "noisy_image_array = np.clip(image_array + noise, 0, 255).astype(np.uint8)\n", + "\n", + "# Convert the noisy NumPy array back to an image\n", + "noisy_image = Image.fromarray(noisy_image_array)\n", + "inputs = processor(noisy_image, return_tensors=\"pt\").to(\"cuda\", torch.float16)\n", + "\n", + "\n", + "out = model.generate(**inputs)\n", + "print(processor.decode(out[0], skip_special_tokens=True).strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "55d97d19-b81c-436d-b9aa-9133b701b2a3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(noisy_image)\n", + "plt.axis('off') # Turn off axis numbers and ticks\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "80435e04-b2c8-4ff7-a943-2cf12ab6edaa", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "BaseModelOutputWithPooling(last_hidden_state=tensor([[[ 1.0049, 0.3579, -0.7446, ..., 0.7065, 0.1138, -0.5010],\n", + " [ 0.6211, 0.2981, -0.8242, ..., 0.5161, -0.1115, -0.6606],\n", + " [ 0.0639, -1.0312, 0.4150, ..., 0.5913, 1.2305, 1.5381],\n", + " ...,\n", + " [ 0.9858, 0.6548, -0.8867, ..., 0.8687, -1.5801, -0.3440],\n", + " [ 1.4736, 0.6348, -1.3340, ..., 0.7539, -0.6992, -0.9751],\n", + " [ 0.5811, -0.3328, 0.8052, ..., 0.9209, 1.3076, 1.1465]]],\n", + " device='cuda:0', dtype=torch.float16, grad_fn=), pooler_output=tensor([[ 2.1230, 0.7412, -1.7305, ..., 0.9121, 0.3486, -1.1895]],\n", + " device='cuda:0', dtype=torch.float16, grad_fn=), hidden_states=None, attentions=None)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "enc_im = model.vision_model.forward(inputs['pixel_values'])\n", + "enc_im" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6705ea42-1f00-4104-b162-503029375620", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "enc_im_array = enc_im.last_hidden_state.cpu().detach().numpy()\n", + "\n", + "# Add random noise to the array\n", + "noise = np.random.normal(loc=0, scale=0.7, size=enc_im_array.shape) # Adjust the scale as needed\n", + "noisy_enc_im_array = enc_im_array * 2\n", + "\n", + "# Convert the noisy NumPy array back to a tensor\n", + "noisy_enc_im = torch.tensor(noisy_enc_im_array, dtype=torch.float16).to(\"cuda\")\n", + "enc_im.last_hidden_state = noisy_enc_im" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5f17f46-5d6d-4f7d-b611-567a1b33d3cf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "20a3151d-98a1-43cf-9e40-edeeb35f8641", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a man riding a motorcycle on a dirt road\n" + ] + } + ], + "source": [ + "pixel_values = inputs['pixel_values']\n", + "input_ids = None #inputs['input_ids']\n", + "attention_mask = None\n", + "batch_size = pixel_values.shape[0]\n", + "image_embeds = enc_im.last_hidden_state\n", + "image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)\n", + "\n", + "query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + "query_outputs = model.qformer(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_attention_mask,\n", + " return_dict=True,\n", + ")\n", + "query_output = query_outputs.last_hidden_state\n", + "\n", + "language_model_inputs = model.language_projection(query_output)\n", + "language_attention_mask = torch.ones(\n", + " language_model_inputs.size()[:-1], dtype=torch.long, device=language_model_inputs.device\n", + ")\n", + "if input_ids is None:\n", + " input_ids = (\n", + " torch.LongTensor([[model.config.text_config.bos_token_id]])\n", + " .repeat(batch_size, 1)\n", + " .to(image_embeds.device)\n", + " )\n", + "if attention_mask is None:\n", + " attention_mask = torch.ones_like(input_ids)\n", + "attention_mask = torch.cat([language_attention_mask, attention_mask.to(language_attention_mask.device)], dim=1)\n", + "\n", + "# concatenate query embeddings with prompt embeddings\n", + "inputs_embeds = model.get_input_embeddings()(input_ids)\n", + "inputs_embeds = torch.cat([language_model_inputs, inputs_embeds.to(language_model_inputs.device)], dim=1)\n", + "\n", + "outputs = model.language_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=attention_mask,\n", + ")\n", + "\n", + "print(processor.decode(outputs[0], skip_special_tokens=True).strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "23adef17-7534-4e61-9215-4971ab700411", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 2, 50118]], device='cuda:0')" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outputs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d5049ca-8338-4ae4-9fd2-5f76c5747ae8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69478d63-aef9-447a-b298-6b2bc3bd6f15", + "metadata": {}, + "outputs": [], + "source": [ + "pixel_values = inputs['pixel_values']\n", + "input_ids = None #inputs['input_ids']\n", + "attention_mask = None\n", + "batch_size = pixel_values.shape[0]\n", + "image_embeds = model.vision_model(pixel_values, return_dict=True).last_hidden_state\n", + "image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)\n", + "\n", + "query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + "query_outputs = model.qformer(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_attention_mask,\n", + " return_dict=True,\n", + ")\n", + "query_output = query_outputs.last_hidden_state\n", + "\n", + "language_model_inputs = model.language_projection(query_output)\n", + "language_attention_mask = torch.ones(\n", + " language_model_inputs.size()[:-1], dtype=torch.long, device=language_model_inputs.device\n", + ")\n", + "if input_ids is None:\n", + " input_ids = (\n", + " torch.LongTensor([[model.config.text_config.bos_token_id]])\n", + " .repeat(batch_size, 1)\n", + " .to(image_embeds.device)\n", + " )\n", + "if attention_mask is None:\n", + " attention_mask = torch.ones_like(input_ids)\n", + "attention_mask = torch.cat([language_attention_mask, attention_mask.to(language_attention_mask.device)], dim=1)\n", + "\n", + "# concatenate query embeddings with prompt embeddings\n", + "inputs_embeds = model.get_input_embeddings()(input_ids)\n", + "inputs_embeds = torch.cat([language_model_inputs, inputs_embeds.to(language_model_inputs.device)], dim=1)\n", + "\n", + "outputs = model.language_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=attention_mask,\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "5b1c9fdd-463f-429a-be88-4648e4134884", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a man is standing in front of a building\n" + ] + } + ], + "source": [ + "print(processor.decode(out[0], skip_special_tokens=True).strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "75c88b00-e798-4c2e-ab16-1420bc74d0ac", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:0\"), hidden_state=True, norm_embs=True)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 768\n", + "hidden_dim = 4096" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d51d2020-0e3e-4bf9-ab62-62effb0bf31d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "r1 = clip_model.embed_image(torch.randn(1,3,224,224).to('cuda'))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1315aa5c-e79b-4341-925b-dc4dab017adf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "clip_model2 = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:0\"), hidden_state=False, norm_embs=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b9c32e8e-9090-4547-996a-deeb3126aa60", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "r2 = clip_model2.embed_image(torch.randn(1,3,224,224).to('cuda'))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "f4abd464-9a00-4033-a6b1-8c2f04bee9bf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-0.0036, 0.0279, 0.0389, 0.0313, 0.0268, -0.0454, 0.0211, -0.0201,\n", + " -0.0033, 0.0248], device='cuda:0', dtype=torch.float16)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r2[0,0:10]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "0899fdc9-76a8-4149-9140-3df981d33fa2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 257, 768])\n" + ] + } + ], + "source": [ + "print(r1.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "92ca9005-ff24-4348-af78-a8e03644d893", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-0.0048, 0.0026, -0.0114, -0.0106, 0.0010, 0.0052, 0.0019, 0.0056,\n", + " 0.0210, -0.0085], device='cuda:0')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r1[0,-1,0:10]" + ] + } + ], + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/checking_models.ipynb b/src/checking_models.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..aaa61b6441b88cad7be844c0b58fdf62064d07f1 --- /dev/null +++ b/src/checking_models.ipynb @@ -0,0 +1,1526 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 25, + "id": "ef9e1556-7840-4004-b181-a2c97ac2ab17", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import torch.nn as nn\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "b6f12dd4-f3aa-4981-b604-b72e67229011", + "metadata": {}, + "source": [ + "# DinoV2" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2a604617-b602-4503-b288-e9828684505e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using cache found in /fsx/proj-fmri/shared/cache/dinov2/hub/facebookresearch_dinov2_main\n" + ] + } + ], + "source": [ + "# need to change TORCH_HOME env variable to specify pretrained model should go in shared folder, not home directory\n", + "os.environ['TORCH_HOME'] = '/fsx/proj-fmri/shared/cache/dinov2'\n", + "dinov2_model = torch.hub.load('facebookresearch/dinov2', 'dinov2_vitl14')\n", + "# remove initial image patching\n", + "dinov2_model.patch_embed = nn.Identity()\n", + "dinov2_model.patch_embed = nn.Identity()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "32da913d-d931-4967-a5e8-bd40c21d1ad9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 33, 1024])\n" + ] + } + ], + "source": [ + "dinov2_model.to(\"cuda\")\n", + "input = torch.randn((2,33,1024)).to(\"cuda\")\n", + "\n", + "for block in dinov2_model.blocks: input = block(input)\n", + "input = dinov2_model.norm(input)\n", + "\n", + "print(input.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "febe89c0-06d0-4309-b378-a8d58b99bf4c", + "metadata": {}, + "source": [ + "# eva" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "690204d0-13d7-452b-97af-14d144800e81", + "metadata": {}, + "outputs": [], + "source": [ + "from urllib.request import urlopen\n", + "from PIL import Image\n", + "import timm\n", + "\n", + "img = Image.open(urlopen(\n", + " 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'\n", + "))\n", + "\n", + "model = timm.create_model(\n", + " \"eva02_enormous_patch14_clip_224.laion2b\",\n", + " pretrained=True,\n", + " num_classes=0, # remove classifier nn.Linear\n", + ")\n", + "model = model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "035e3e9d-86c9-4ddf-b760-7b78dded7d2e", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "You have to specify pixel_values", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[39], line 5\u001b[0m\n\u001b[1;32m 2\u001b[0m data_config \u001b[38;5;241m=\u001b[39m timm\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mresolve_model_data_config(model)\n\u001b[1;32m 3\u001b[0m transforms \u001b[38;5;241m=\u001b[39m timm\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mcreate_transform(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mdata_config, is_training\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m----> 5\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtransforms\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munsqueeze\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# output is (batch_size, num_features) shaped tensor\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(output\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# or equivalently (without needing to set num_classes=0)\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1499\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1500\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/models/clipseg/modeling_clipseg.py:1433\u001b[0m, in \u001b[0;36mCLIPSegForImageSegmentation.forward\u001b[0;34m(self, input_ids, pixel_values, conditional_pixel_values, conditional_embeddings, attention_mask, position_ids, labels, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 1431\u001b[0m \u001b[38;5;66;03m# step 1: forward the query images through the frozen CLIP vision encoder\u001b[39;00m\n\u001b[1;32m 1432\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m-> 1433\u001b[0m vision_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclip\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvision_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1434\u001b[0m \u001b[43m \u001b[49m\u001b[43mpixel_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpixel_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1435\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_attentions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_attentions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1436\u001b[0m \u001b[43m \u001b[49m\u001b[43moutput_hidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# we need the intermediate hidden states\u001b[39;49;00m\n\u001b[1;32m 1437\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_dict\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1438\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1439\u001b[0m pooled_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclip\u001b[38;5;241m.\u001b[39mvisual_projection(vision_outputs[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 1441\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m vision_outputs\u001b[38;5;241m.\u001b[39mhidden_states \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;28;01melse\u001b[39;00m vision_outputs[\u001b[38;5;241m2\u001b[39m]\n", + "File \u001b[0;32m~/miniconda3/envs/mindeye/lib/python3.10/site-packages/torch/nn/modules/module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1499\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1500\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/models/clipseg/modeling_clipseg.py:872\u001b[0m, in \u001b[0;36mCLIPSegVisionTransformer.forward\u001b[0;34m(self, pixel_values, output_attentions, output_hidden_states, return_dict)\u001b[0m\n\u001b[1;32m 869\u001b[0m return_dict \u001b[38;5;241m=\u001b[39m return_dict \u001b[38;5;28;01mif\u001b[39;00m return_dict \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39muse_return_dict\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pixel_values \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 872\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mYou have to specify pixel_values\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 874\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39membeddings(pixel_values)\n\u001b[1;32m 875\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpre_layrnorm(hidden_states)\n", + "\u001b[0;31mValueError\u001b[0m: You have to specify pixel_values" + ] + } + ], + "source": [ + "# get model specific transforms (normalization, resize)\n", + "data_config = timm.data.resolve_model_data_config(model)\n", + "transforms = timm.data.create_transform(**data_config, is_training=False)\n", + "\n", + "output = model(transforms(img).unsqueeze(0)) # output is (batch_size, num_features) shaped tensor\n", + "print(output.shape)\n", + "# or equivalently (without needing to set num_classes=0)\n", + "\n", + "output = model.forward_features(transforms(img).unsqueeze(0))\n", + "# output is unpooled, a (1, 257, 768) shaped tensor\n", + "print(output.shape)\n", + "\n", + "output = model.forward_head(output, pre_logits=True)\n", + "# output is a (1, num_features) shaped tensor\n", + "print(output.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54275c4c-e506-4959-92f1-29e584f5ce51", + "metadata": {}, + "outputs": [], + "source": [ + "model.forward_features(transforms(img).unsqueeze(0)).shape" + ] + }, + { + "cell_type": "markdown", + "id": "6546c673-f3ab-4d43-a051-cab20e782bab", + "metadata": {}, + "source": [ + "# Eva02-clip" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "dfbc95de-9af9-4583-98fc-b8061114ef64", + "metadata": {}, + "outputs": [], + "source": [ + "import timm \n", + "# couldnt figure out how to load pretrained model from shared folder rather than home directory using timm...\n", + "eva02_model = timm.create_model(\"eva02_enormous_patch14_clip_224.laion2b\", pretrained=True)\n", + "# eva02_model.head_drop = nn.Identity()\n", + "# eva02_model.head = nn.Identity()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "97e3ea29-ae6b-4bd2-b3d7-17839098a6e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([2, 1024])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eva02_model(torch.randn((2,3,224,224))).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "069b76f0-029f-42b1-85f5-a492ee1cc5d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([2, 256, 1024])\n" + ] + } + ], + "source": [ + "image = torch.randn((2,3,224,224))\n", + "\n", + "input = eva02_model.patch_embed(image)\n", + "input = eva02_model.pos_drop(input)\n", + "for block in eva02_model.blocks: input = block(input)\n", + "input = eva02_model.norm(input)\n", + "input = eva02_model.fc_norm(input)\n", + "input = eva02_model.head_drop(input)\n", + "input = eva02_model.head(input)\n", + "\n", + "print(input.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "90e4e8e7-3dd1-43b0-a305-066a6ec13c2e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on Eva in module timm.models.eva object:\n", + "\n", + "class Eva(torch.nn.modules.module.Module)\n", + " | Eva(img_size: Union[int, Tuple[int, int]] = 224, patch_size: Union[int, Tuple[int, int]] = 16, in_chans: int = 3, num_classes: int = 1000, global_pool: str = 'avg', embed_dim: int = 768, depth: int = 12, num_heads: int = 12, qkv_bias: bool = True, qkv_fused: bool = True, mlp_ratio: float = 4.0, swiglu_mlp: bool = False, scale_mlp: bool = False, scale_attn_inner: bool = False, drop_rate: float = 0.0, pos_drop_rate: float = 0.0, patch_drop_rate: float = 0.0, proj_drop_rate: float = 0.0, attn_drop_rate: float = 0.0, drop_path_rate: float = 0.0, norm_layer: Callable = , init_values: Optional[float] = None, class_token: bool = True, use_abs_pos_emb: bool = True, use_rot_pos_emb: bool = False, use_post_norm: bool = False, ref_feat_shape: Union[int, Tuple[int, int], NoneType] = None, head_init_scale: float = 0.001)\n", + " | \n", + " | Eva Vision Transformer w/ Abs & Rotary Pos Embed\n", + " | \n", + " | This class implements the EVA and EVA02 models that were based on the BEiT ViT variant\n", + " | * EVA - abs pos embed, global avg pool\n", + " | * EVA02 - abs + rope pos embed, global avg pool, SwiGLU, scale Norm in MLP (ala normformer)\n", + " | \n", + " | Method resolution order:\n", + " | Eva\n", + " | torch.nn.modules.module.Module\n", + " | builtins.object\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __init__(self, img_size: Union[int, Tuple[int, int]] = 224, patch_size: Union[int, Tuple[int, int]] = 16, in_chans: int = 3, num_classes: int = 1000, global_pool: str = 'avg', embed_dim: int = 768, depth: int = 12, num_heads: int = 12, qkv_bias: bool = True, qkv_fused: bool = True, mlp_ratio: float = 4.0, swiglu_mlp: bool = False, scale_mlp: bool = False, scale_attn_inner: bool = False, drop_rate: float = 0.0, pos_drop_rate: float = 0.0, patch_drop_rate: float = 0.0, proj_drop_rate: float = 0.0, attn_drop_rate: float = 0.0, drop_path_rate: float = 0.0, norm_layer: Callable = , init_values: Optional[float] = None, class_token: bool = True, use_abs_pos_emb: bool = True, use_rot_pos_emb: bool = False, use_post_norm: bool = False, ref_feat_shape: Union[int, Tuple[int, int], NoneType] = None, head_init_scale: float = 0.001)\n", + " | Args:\n", + " | img_size:\n", + " | patch_size:\n", + " | in_chans:\n", + " | num_classes:\n", + " | global_pool:\n", + " | embed_dim:\n", + " | depth:\n", + " | num_heads:\n", + " | qkv_bias:\n", + " | qkv_fused:\n", + " | mlp_ratio:\n", + " | swiglu_mlp:\n", + " | scale_mlp:\n", + " | scale_attn_inner:\n", + " | drop_rate:\n", + " | pos_drop_rate:\n", + " | proj_drop_rate:\n", + " | attn_drop_rate:\n", + " | drop_path_rate:\n", + " | norm_layer:\n", + " | init_values:\n", + " | class_token:\n", + " | use_abs_pos_emb:\n", + " | use_rot_pos_emb:\n", + " | use_post_norm:\n", + " | ref_feat_shape:\n", + " | head_init_scale:\n", + " | \n", + " | fix_init_weight(self)\n", + " | \n", + " | forward(self, x)\n", + " | Defines the computation performed at every call.\n", + " | \n", + " | Should be overridden by all subclasses.\n", + " | \n", + " | .. note::\n", + " | Although the recipe for forward pass needs to be defined within\n", + " | this function, one should call the :class:`Module` instance afterwards\n", + " | instead of this since the former takes care of running the\n", + " | registered hooks while the latter silently ignores them.\n", + " | \n", + " | forward_features(self, x)\n", + " | \n", + " | forward_head(self, x, pre_logits: bool = False)\n", + " | \n", + " | get_classifier(self)\n", + " | \n", + " | group_matcher(self, coarse=False)\n", + " | \n", + " | no_weight_decay(self)\n", + " | \n", + " | reset_classifier(self, num_classes, global_pool=None)\n", + " | \n", + " | set_grad_checkpointing(self, enable=True)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", + " | \n", + " | __annotations__ = {}\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from torch.nn.modules.module.Module:\n", + " | \n", + " | __call__ = _call_impl(self, *args, **kwargs)\n", + " | \n", + " | __delattr__(self, name)\n", + " | Implement delattr(self, name).\n", + " | \n", + " | __dir__(self)\n", + " | Default dir() implementation.\n", + " | \n", + " | __getattr__(self, name: str) -> Union[torch.Tensor, ForwardRef('Module')]\n", + " | \n", + " | __repr__(self)\n", + " | Return repr(self).\n", + " | \n", + " | __setattr__(self, name: str, value: Union[torch.Tensor, ForwardRef('Module')]) -> None\n", + " | Implement setattr(self, name, value).\n", + " | \n", + " | __setstate__(self, state)\n", + " | \n", + " | add_module(self, name: str, module: Optional[ForwardRef('Module')]) -> None\n", + " | Adds a child module to the current module.\n", + " | \n", + " | The module can be accessed as an attribute using the given name.\n", + " | \n", + " | Args:\n", + " | name (str): name of the child module. The child module can be\n", + " | accessed from this module using the given name\n", + " | module (Module): child module to be added to the module.\n", + " | \n", + " | apply(self: ~T, fn: Callable[[ForwardRef('Module')], NoneType]) -> ~T\n", + " | Applies ``fn`` recursively to every submodule (as returned by ``.children()``)\n", + " | as well as self. Typical use includes initializing the parameters of a model\n", + " | (see also :ref:`nn-init-doc`).\n", + " | \n", + " | Args:\n", + " | fn (:class:`Module` -> None): function to be applied to each submodule\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> @torch.no_grad()\n", + " | >>> def init_weights(m):\n", + " | >>> print(m)\n", + " | >>> if type(m) == nn.Linear:\n", + " | >>> m.weight.fill_(1.0)\n", + " | >>> print(m.weight)\n", + " | >>> net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))\n", + " | >>> net.apply(init_weights)\n", + " | Linear(in_features=2, out_features=2, bias=True)\n", + " | Parameter containing:\n", + " | tensor([[1., 1.],\n", + " | [1., 1.]], requires_grad=True)\n", + " | Linear(in_features=2, out_features=2, bias=True)\n", + " | Parameter containing:\n", + " | tensor([[1., 1.],\n", + " | [1., 1.]], requires_grad=True)\n", + " | Sequential(\n", + " | (0): Linear(in_features=2, out_features=2, bias=True)\n", + " | (1): Linear(in_features=2, out_features=2, bias=True)\n", + " | )\n", + " | \n", + " | bfloat16(self: ~T) -> ~T\n", + " | Casts all floating point parameters and buffers to ``bfloat16`` datatype.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | buffers(self, recurse: bool = True) -> Iterator[torch.Tensor]\n", + " | Returns an iterator over module buffers.\n", + " | \n", + " | Args:\n", + " | recurse (bool): if True, then yields buffers of this module\n", + " | and all submodules. Otherwise, yields only buffers that\n", + " | are direct members of this module.\n", + " | \n", + " | Yields:\n", + " | torch.Tensor: module buffer\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> for buf in model.buffers():\n", + " | >>> print(type(buf), buf.size())\n", + " | (20L,)\n", + " | (20L, 1L, 5L, 5L)\n", + " | \n", + " | children(self) -> Iterator[ForwardRef('Module')]\n", + " | Returns an iterator over immediate children modules.\n", + " | \n", + " | Yields:\n", + " | Module: a child module\n", + " | \n", + " | cpu(self: ~T) -> ~T\n", + " | Moves all model parameters and buffers to the CPU.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | cuda(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n", + " | Moves all model parameters and buffers to the GPU.\n", + " | \n", + " | This also makes associated parameters and buffers different objects. So\n", + " | it should be called before constructing optimizer if the module will\n", + " | live on GPU while being optimized.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Args:\n", + " | device (int, optional): if specified, all parameters will be\n", + " | copied to that device\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | double(self: ~T) -> ~T\n", + " | Casts all floating point parameters and buffers to ``double`` datatype.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | eval(self: ~T) -> ~T\n", + " | Sets the module in evaluation mode.\n", + " | \n", + " | This has any effect only on certain modules. See documentations of\n", + " | particular modules for details of their behaviors in training/evaluation\n", + " | mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,\n", + " | etc.\n", + " | \n", + " | This is equivalent with :meth:`self.train(False) `.\n", + " | \n", + " | See :ref:`locally-disable-grad-doc` for a comparison between\n", + " | `.eval()` and several similar mechanisms that may be confused with it.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | extra_repr(self) -> str\n", + " | Set the extra representation of the module\n", + " | \n", + " | To print customized extra information, you should re-implement\n", + " | this method in your own modules. Both single-line and multi-line\n", + " | strings are acceptable.\n", + " | \n", + " | float(self: ~T) -> ~T\n", + " | Casts all floating point parameters and buffers to ``float`` datatype.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | get_buffer(self, target: str) -> 'Tensor'\n", + " | Returns the buffer given by ``target`` if it exists,\n", + " | otherwise throws an error.\n", + " | \n", + " | See the docstring for ``get_submodule`` for a more detailed\n", + " | explanation of this method's functionality as well as how to\n", + " | correctly specify ``target``.\n", + " | \n", + " | Args:\n", + " | target: The fully-qualified string name of the buffer\n", + " | to look for. (See ``get_submodule`` for how to specify a\n", + " | fully-qualified string.)\n", + " | \n", + " | Returns:\n", + " | torch.Tensor: The buffer referenced by ``target``\n", + " | \n", + " | Raises:\n", + " | AttributeError: If the target string references an invalid\n", + " | path or resolves to something that is not a\n", + " | buffer\n", + " | \n", + " | get_extra_state(self) -> Any\n", + " | Returns any extra state to include in the module's state_dict.\n", + " | Implement this and a corresponding :func:`set_extra_state` for your module\n", + " | if you need to store extra state. This function is called when building the\n", + " | module's `state_dict()`.\n", + " | \n", + " | Note that extra state should be picklable to ensure working serialization\n", + " | of the state_dict. We only provide provide backwards compatibility guarantees\n", + " | for serializing Tensors; other objects may break backwards compatibility if\n", + " | their serialized pickled form changes.\n", + " | \n", + " | Returns:\n", + " | object: Any extra state to store in the module's state_dict\n", + " | \n", + " | get_parameter(self, target: str) -> 'Parameter'\n", + " | Returns the parameter given by ``target`` if it exists,\n", + " | otherwise throws an error.\n", + " | \n", + " | See the docstring for ``get_submodule`` for a more detailed\n", + " | explanation of this method's functionality as well as how to\n", + " | correctly specify ``target``.\n", + " | \n", + " | Args:\n", + " | target: The fully-qualified string name of the Parameter\n", + " | to look for. (See ``get_submodule`` for how to specify a\n", + " | fully-qualified string.)\n", + " | \n", + " | Returns:\n", + " | torch.nn.Parameter: The Parameter referenced by ``target``\n", + " | \n", + " | Raises:\n", + " | AttributeError: If the target string references an invalid\n", + " | path or resolves to something that is not an\n", + " | ``nn.Parameter``\n", + " | \n", + " | get_submodule(self, target: str) -> 'Module'\n", + " | Returns the submodule given by ``target`` if it exists,\n", + " | otherwise throws an error.\n", + " | \n", + " | For example, let's say you have an ``nn.Module`` ``A`` that\n", + " | looks like this:\n", + " | \n", + " | .. code-block:: text\n", + " | \n", + " | A(\n", + " | (net_b): Module(\n", + " | (net_c): Module(\n", + " | (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))\n", + " | )\n", + " | (linear): Linear(in_features=100, out_features=200, bias=True)\n", + " | )\n", + " | )\n", + " | \n", + " | (The diagram shows an ``nn.Module`` ``A``. ``A`` has a nested\n", + " | submodule ``net_b``, which itself has two submodules ``net_c``\n", + " | and ``linear``. ``net_c`` then has a submodule ``conv``.)\n", + " | \n", + " | To check whether or not we have the ``linear`` submodule, we\n", + " | would call ``get_submodule(\"net_b.linear\")``. To check whether\n", + " | we have the ``conv`` submodule, we would call\n", + " | ``get_submodule(\"net_b.net_c.conv\")``.\n", + " | \n", + " | The runtime of ``get_submodule`` is bounded by the degree\n", + " | of module nesting in ``target``. A query against\n", + " | ``named_modules`` achieves the same result, but it is O(N) in\n", + " | the number of transitive modules. So, for a simple check to see\n", + " | if some submodule exists, ``get_submodule`` should always be\n", + " | used.\n", + " | \n", + " | Args:\n", + " | target: The fully-qualified string name of the submodule\n", + " | to look for. (See above example for how to specify a\n", + " | fully-qualified string.)\n", + " | \n", + " | Returns:\n", + " | torch.nn.Module: The submodule referenced by ``target``\n", + " | \n", + " | Raises:\n", + " | AttributeError: If the target string references an invalid\n", + " | path or resolves to something that is not an\n", + " | ``nn.Module``\n", + " | \n", + " | half(self: ~T) -> ~T\n", + " | Casts all floating point parameters and buffers to ``half`` datatype.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | ipu(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n", + " | Moves all model parameters and buffers to the IPU.\n", + " | \n", + " | This also makes associated parameters and buffers different objects. So\n", + " | it should be called before constructing optimizer if the module will\n", + " | live on IPU while being optimized.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Arguments:\n", + " | device (int, optional): if specified, all parameters will be\n", + " | copied to that device\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | load_state_dict(self, state_dict: Mapping[str, Any], strict: bool = True)\n", + " | Copies parameters and buffers from :attr:`state_dict` into\n", + " | this module and its descendants. If :attr:`strict` is ``True``, then\n", + " | the keys of :attr:`state_dict` must exactly match the keys returned\n", + " | by this module's :meth:`~torch.nn.Module.state_dict` function.\n", + " | \n", + " | Args:\n", + " | state_dict (dict): a dict containing parameters and\n", + " | persistent buffers.\n", + " | strict (bool, optional): whether to strictly enforce that the keys\n", + " | in :attr:`state_dict` match the keys returned by this module's\n", + " | :meth:`~torch.nn.Module.state_dict` function. Default: ``True``\n", + " | \n", + " | Returns:\n", + " | ``NamedTuple`` with ``missing_keys`` and ``unexpected_keys`` fields:\n", + " | * **missing_keys** is a list of str containing the missing keys\n", + " | * **unexpected_keys** is a list of str containing the unexpected keys\n", + " | \n", + " | Note:\n", + " | If a parameter or buffer is registered as ``None`` and its corresponding key\n", + " | exists in :attr:`state_dict`, :meth:`load_state_dict` will raise a\n", + " | ``RuntimeError``.\n", + " | \n", + " | modules(self) -> Iterator[ForwardRef('Module')]\n", + " | Returns an iterator over all modules in the network.\n", + " | \n", + " | Yields:\n", + " | Module: a module in the network\n", + " | \n", + " | Note:\n", + " | Duplicate modules are returned only once. In the following\n", + " | example, ``l`` will be returned only once.\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> l = nn.Linear(2, 2)\n", + " | >>> net = nn.Sequential(l, l)\n", + " | >>> for idx, m in enumerate(net.modules()):\n", + " | ... print(idx, '->', m)\n", + " | \n", + " | 0 -> Sequential(\n", + " | (0): Linear(in_features=2, out_features=2, bias=True)\n", + " | (1): Linear(in_features=2, out_features=2, bias=True)\n", + " | )\n", + " | 1 -> Linear(in_features=2, out_features=2, bias=True)\n", + " | \n", + " | named_buffers(self, prefix: str = '', recurse: bool = True, remove_duplicate: bool = True) -> Iterator[Tuple[str, torch.Tensor]]\n", + " | Returns an iterator over module buffers, yielding both the\n", + " | name of the buffer as well as the buffer itself.\n", + " | \n", + " | Args:\n", + " | prefix (str): prefix to prepend to all buffer names.\n", + " | recurse (bool, optional): if True, then yields buffers of this module\n", + " | and all submodules. Otherwise, yields only buffers that\n", + " | are direct members of this module. Defaults to True.\n", + " | remove_duplicate (bool, optional): whether to remove the duplicated buffers in the result. Defaults to True.\n", + " | \n", + " | Yields:\n", + " | (str, torch.Tensor): Tuple containing the name and buffer\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> for name, buf in self.named_buffers():\n", + " | >>> if name in ['running_var']:\n", + " | >>> print(buf.size())\n", + " | \n", + " | named_children(self) -> Iterator[Tuple[str, ForwardRef('Module')]]\n", + " | Returns an iterator over immediate children modules, yielding both\n", + " | the name of the module as well as the module itself.\n", + " | \n", + " | Yields:\n", + " | (str, Module): Tuple containing a name and child module\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> for name, module in model.named_children():\n", + " | >>> if name in ['conv4', 'conv5']:\n", + " | >>> print(module)\n", + " | \n", + " | named_modules(self, memo: Optional[Set[ForwardRef('Module')]] = None, prefix: str = '', remove_duplicate: bool = True)\n", + " | Returns an iterator over all modules in the network, yielding\n", + " | both the name of the module as well as the module itself.\n", + " | \n", + " | Args:\n", + " | memo: a memo to store the set of modules already added to the result\n", + " | prefix: a prefix that will be added to the name of the module\n", + " | remove_duplicate: whether to remove the duplicated module instances in the result\n", + " | or not\n", + " | \n", + " | Yields:\n", + " | (str, Module): Tuple of name and module\n", + " | \n", + " | Note:\n", + " | Duplicate modules are returned only once. In the following\n", + " | example, ``l`` will be returned only once.\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> l = nn.Linear(2, 2)\n", + " | >>> net = nn.Sequential(l, l)\n", + " | >>> for idx, m in enumerate(net.named_modules()):\n", + " | ... print(idx, '->', m)\n", + " | \n", + " | 0 -> ('', Sequential(\n", + " | (0): Linear(in_features=2, out_features=2, bias=True)\n", + " | (1): Linear(in_features=2, out_features=2, bias=True)\n", + " | ))\n", + " | 1 -> ('0', Linear(in_features=2, out_features=2, bias=True))\n", + " | \n", + " | named_parameters(self, prefix: str = '', recurse: bool = True, remove_duplicate: bool = True) -> Iterator[Tuple[str, torch.nn.parameter.Parameter]]\n", + " | Returns an iterator over module parameters, yielding both the\n", + " | name of the parameter as well as the parameter itself.\n", + " | \n", + " | Args:\n", + " | prefix (str): prefix to prepend to all parameter names.\n", + " | recurse (bool): if True, then yields parameters of this module\n", + " | and all submodules. Otherwise, yields only parameters that\n", + " | are direct members of this module.\n", + " | remove_duplicate (bool, optional): whether to remove the duplicated\n", + " | parameters in the result. Defaults to True.\n", + " | \n", + " | Yields:\n", + " | (str, Parameter): Tuple containing the name and parameter\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> for name, param in self.named_parameters():\n", + " | >>> if name in ['bias']:\n", + " | >>> print(param.size())\n", + " | \n", + " | parameters(self, recurse: bool = True) -> Iterator[torch.nn.parameter.Parameter]\n", + " | Returns an iterator over module parameters.\n", + " | \n", + " | This is typically passed to an optimizer.\n", + " | \n", + " | Args:\n", + " | recurse (bool): if True, then yields parameters of this module\n", + " | and all submodules. Otherwise, yields only parameters that\n", + " | are direct members of this module.\n", + " | \n", + " | Yields:\n", + " | Parameter: module parameter\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> for param in model.parameters():\n", + " | >>> print(type(param), param.size())\n", + " | (20L,)\n", + " | (20L, 1L, 5L, 5L)\n", + " | \n", + " | register_backward_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor], Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]]) -> torch.utils.hooks.RemovableHandle\n", + " | Registers a backward hook on the module.\n", + " | \n", + " | This function is deprecated in favor of :meth:`~torch.nn.Module.register_full_backward_hook` and\n", + " | the behavior of this function will change in future versions.\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_buffer(self, name: str, tensor: Optional[torch.Tensor], persistent: bool = True) -> None\n", + " | Adds a buffer to the module.\n", + " | \n", + " | This is typically used to register a buffer that should not to be\n", + " | considered a model parameter. For example, BatchNorm's ``running_mean``\n", + " | is not a parameter, but is part of the module's state. Buffers, by\n", + " | default, are persistent and will be saved alongside parameters. This\n", + " | behavior can be changed by setting :attr:`persistent` to ``False``. The\n", + " | only difference between a persistent buffer and a non-persistent buffer\n", + " | is that the latter will not be a part of this module's\n", + " | :attr:`state_dict`.\n", + " | \n", + " | Buffers can be accessed as attributes using given names.\n", + " | \n", + " | Args:\n", + " | name (str): name of the buffer. The buffer can be accessed\n", + " | from this module using the given name\n", + " | tensor (Tensor or None): buffer to be registered. If ``None``, then operations\n", + " | that run on buffers, such as :attr:`cuda`, are ignored. If ``None``,\n", + " | the buffer is **not** included in the module's :attr:`state_dict`.\n", + " | persistent (bool): whether the buffer is part of this module's\n", + " | :attr:`state_dict`.\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> self.register_buffer('running_mean', torch.zeros(num_features))\n", + " | \n", + " | register_forward_hook(self, hook: Union[Callable[[~T, Tuple[Any, ...], Any], Optional[Any]], Callable[[~T, Tuple[Any, ...], Dict[str, Any], Any], Optional[Any]]], *, prepend: bool = False, with_kwargs: bool = False) -> torch.utils.hooks.RemovableHandle\n", + " | Registers a forward hook on the module.\n", + " | \n", + " | The hook will be called every time after :func:`forward` has computed an output.\n", + " | \n", + " | If ``with_kwargs`` is ``False`` or not specified, the input contains only\n", + " | the positional arguments given to the module. Keyword arguments won't be\n", + " | passed to the hooks and only to the ``forward``. The hook can modify the\n", + " | output. It can modify the input inplace but it will not have effect on\n", + " | forward since this is called after :func:`forward` is called. The hook\n", + " | should have the following signature::\n", + " | \n", + " | hook(module, args, output) -> None or modified output\n", + " | \n", + " | If ``with_kwargs`` is ``True``, the forward hook will be passed the\n", + " | ``kwargs`` given to the forward function and be expected to return the\n", + " | output possibly modified. The hook should have the following signature::\n", + " | \n", + " | hook(module, args, kwargs, output) -> None or modified output\n", + " | \n", + " | Args:\n", + " | hook (Callable): The user defined hook to be registered.\n", + " | prepend (bool): If ``True``, the provided ``hook`` will be fired\n", + " | before all existing ``forward`` hooks on this\n", + " | :class:`torch.nn.modules.Module`. Otherwise, the provided\n", + " | ``hook`` will be fired after all existing ``forward`` hooks on\n", + " | this :class:`torch.nn.modules.Module`. Note that global\n", + " | ``forward`` hooks registered with\n", + " | :func:`register_module_forward_hook` will fire before all hooks\n", + " | registered by this method.\n", + " | Default: ``False``\n", + " | with_kwargs (bool): If ``True``, the ``hook`` will be passed the\n", + " | kwargs given to the forward function.\n", + " | Default: ``False``\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_forward_pre_hook(self, hook: Union[Callable[[~T, Tuple[Any, ...]], Optional[Any]], Callable[[~T, Tuple[Any, ...], Dict[str, Any]], Optional[Tuple[Any, Dict[str, Any]]]]], *, prepend: bool = False, with_kwargs: bool = False) -> torch.utils.hooks.RemovableHandle\n", + " | Registers a forward pre-hook on the module.\n", + " | \n", + " | The hook will be called every time before :func:`forward` is invoked.\n", + " | \n", + " | \n", + " | If ``with_kwargs`` is false or not specified, the input contains only\n", + " | the positional arguments given to the module. Keyword arguments won't be\n", + " | passed to the hooks and only to the ``forward``. The hook can modify the\n", + " | input. User can either return a tuple or a single modified value in the\n", + " | hook. We will wrap the value into a tuple if a single value is returned\n", + " | (unless that value is already a tuple). The hook should have the\n", + " | following signature::\n", + " | \n", + " | hook(module, args) -> None or modified input\n", + " | \n", + " | If ``with_kwargs`` is true, the forward pre-hook will be passed the\n", + " | kwargs given to the forward function. And if the hook modifies the\n", + " | input, both the args and kwargs should be returned. The hook should have\n", + " | the following signature::\n", + " | \n", + " | hook(module, args, kwargs) -> None or a tuple of modified input and kwargs\n", + " | \n", + " | Args:\n", + " | hook (Callable): The user defined hook to be registered.\n", + " | prepend (bool): If true, the provided ``hook`` will be fired before\n", + " | all existing ``forward_pre`` hooks on this\n", + " | :class:`torch.nn.modules.Module`. Otherwise, the provided\n", + " | ``hook`` will be fired after all existing ``forward_pre`` hooks\n", + " | on this :class:`torch.nn.modules.Module`. Note that global\n", + " | ``forward_pre`` hooks registered with\n", + " | :func:`register_module_forward_pre_hook` will fire before all\n", + " | hooks registered by this method.\n", + " | Default: ``False``\n", + " | with_kwargs (bool): If true, the ``hook`` will be passed the kwargs\n", + " | given to the forward function.\n", + " | Default: ``False``\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_full_backward_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor], Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]], prepend: bool = False) -> torch.utils.hooks.RemovableHandle\n", + " | Registers a backward hook on the module.\n", + " | \n", + " | The hook will be called every time the gradients with respect to a module\n", + " | are computed, i.e. the hook will execute if and only if the gradients with\n", + " | respect to module outputs are computed. The hook should have the following\n", + " | signature::\n", + " | \n", + " | hook(module, grad_input, grad_output) -> tuple(Tensor) or None\n", + " | \n", + " | The :attr:`grad_input` and :attr:`grad_output` are tuples that contain the gradients\n", + " | with respect to the inputs and outputs respectively. The hook should\n", + " | not modify its arguments, but it can optionally return a new gradient with\n", + " | respect to the input that will be used in place of :attr:`grad_input` in\n", + " | subsequent computations. :attr:`grad_input` will only correspond to the inputs given\n", + " | as positional arguments and all kwarg arguments are ignored. Entries\n", + " | in :attr:`grad_input` and :attr:`grad_output` will be ``None`` for all non-Tensor\n", + " | arguments.\n", + " | \n", + " | For technical reasons, when this hook is applied to a Module, its forward function will\n", + " | receive a view of each Tensor passed to the Module. Similarly the caller will receive a view\n", + " | of each Tensor returned by the Module's forward function.\n", + " | \n", + " | .. warning ::\n", + " | Modifying inputs or outputs inplace is not allowed when using backward hooks and\n", + " | will raise an error.\n", + " | \n", + " | Args:\n", + " | hook (Callable): The user-defined hook to be registered.\n", + " | prepend (bool): If true, the provided ``hook`` will be fired before\n", + " | all existing ``backward`` hooks on this\n", + " | :class:`torch.nn.modules.Module`. Otherwise, the provided\n", + " | ``hook`` will be fired after all existing ``backward`` hooks on\n", + " | this :class:`torch.nn.modules.Module`. Note that global\n", + " | ``backward`` hooks registered with\n", + " | :func:`register_module_full_backward_hook` will fire before\n", + " | all hooks registered by this method.\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_full_backward_pre_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]], prepend: bool = False) -> torch.utils.hooks.RemovableHandle\n", + " | Registers a backward pre-hook on the module.\n", + " | \n", + " | The hook will be called every time the gradients for the module are computed.\n", + " | The hook should have the following signature::\n", + " | \n", + " | hook(module, grad_output) -> Tensor or None\n", + " | \n", + " | The :attr:`grad_output` is a tuple. The hook should\n", + " | not modify its arguments, but it can optionally return a new gradient with\n", + " | respect to the output that will be used in place of :attr:`grad_output` in\n", + " | subsequent computations. Entries in :attr:`grad_output` will be ``None`` for\n", + " | all non-Tensor arguments.\n", + " | \n", + " | For technical reasons, when this hook is applied to a Module, its forward function will\n", + " | receive a view of each Tensor passed to the Module. Similarly the caller will receive a view\n", + " | of each Tensor returned by the Module's forward function.\n", + " | \n", + " | .. warning ::\n", + " | Modifying inputs inplace is not allowed when using backward hooks and\n", + " | will raise an error.\n", + " | \n", + " | Args:\n", + " | hook (Callable): The user-defined hook to be registered.\n", + " | prepend (bool): If true, the provided ``hook`` will be fired before\n", + " | all existing ``backward_pre`` hooks on this\n", + " | :class:`torch.nn.modules.Module`. Otherwise, the provided\n", + " | ``hook`` will be fired after all existing ``backward_pre`` hooks\n", + " | on this :class:`torch.nn.modules.Module`. Note that global\n", + " | ``backward_pre`` hooks registered with\n", + " | :func:`register_module_full_backward_pre_hook` will fire before\n", + " | all hooks registered by this method.\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_load_state_dict_post_hook(self, hook)\n", + " | Registers a post hook to be run after module's ``load_state_dict``\n", + " | is called.\n", + " | \n", + " | It should have the following signature::\n", + " | hook(module, incompatible_keys) -> None\n", + " | \n", + " | The ``module`` argument is the current module that this hook is registered\n", + " | on, and the ``incompatible_keys`` argument is a ``NamedTuple`` consisting\n", + " | of attributes ``missing_keys`` and ``unexpected_keys``. ``missing_keys``\n", + " | is a ``list`` of ``str`` containing the missing keys and\n", + " | ``unexpected_keys`` is a ``list`` of ``str`` containing the unexpected keys.\n", + " | \n", + " | The given incompatible_keys can be modified inplace if needed.\n", + " | \n", + " | Note that the checks performed when calling :func:`load_state_dict` with\n", + " | ``strict=True`` are affected by modifications the hook makes to\n", + " | ``missing_keys`` or ``unexpected_keys``, as expected. Additions to either\n", + " | set of keys will result in an error being thrown when ``strict=True``, and\n", + " | clearing out both missing and unexpected keys will avoid an error.\n", + " | \n", + " | Returns:\n", + " | :class:`torch.utils.hooks.RemovableHandle`:\n", + " | a handle that can be used to remove the added hook by calling\n", + " | ``handle.remove()``\n", + " | \n", + " | register_module(self, name: str, module: Optional[ForwardRef('Module')]) -> None\n", + " | Alias for :func:`add_module`.\n", + " | \n", + " | register_parameter(self, name: str, param: Optional[torch.nn.parameter.Parameter]) -> None\n", + " | Adds a parameter to the module.\n", + " | \n", + " | The parameter can be accessed as an attribute using given name.\n", + " | \n", + " | Args:\n", + " | name (str): name of the parameter. The parameter can be accessed\n", + " | from this module using the given name\n", + " | param (Parameter or None): parameter to be added to the module. If\n", + " | ``None``, then operations that run on parameters, such as :attr:`cuda`,\n", + " | are ignored. If ``None``, the parameter is **not** included in the\n", + " | module's :attr:`state_dict`.\n", + " | \n", + " | register_state_dict_pre_hook(self, hook)\n", + " | These hooks will be called with arguments: ``self``, ``prefix``,\n", + " | and ``keep_vars`` before calling ``state_dict`` on ``self``. The registered\n", + " | hooks can be used to perform pre-processing before the ``state_dict``\n", + " | call is made.\n", + " | \n", + " | requires_grad_(self: ~T, requires_grad: bool = True) -> ~T\n", + " | Change if autograd should record operations on parameters in this\n", + " | module.\n", + " | \n", + " | This method sets the parameters' :attr:`requires_grad` attributes\n", + " | in-place.\n", + " | \n", + " | This method is helpful for freezing part of the module for finetuning\n", + " | or training parts of a model individually (e.g., GAN training).\n", + " | \n", + " | See :ref:`locally-disable-grad-doc` for a comparison between\n", + " | `.requires_grad_()` and several similar mechanisms that may be confused with it.\n", + " | \n", + " | Args:\n", + " | requires_grad (bool): whether autograd should record operations on\n", + " | parameters in this module. Default: ``True``.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | set_extra_state(self, state: Any)\n", + " | This function is called from :func:`load_state_dict` to handle any extra state\n", + " | found within the `state_dict`. Implement this function and a corresponding\n", + " | :func:`get_extra_state` for your module if you need to store extra state within its\n", + " | `state_dict`.\n", + " | \n", + " | Args:\n", + " | state (dict): Extra state from the `state_dict`\n", + " | \n", + " | share_memory(self: ~T) -> ~T\n", + " | See :meth:`torch.Tensor.share_memory_`\n", + " | \n", + " | state_dict(self, *args, destination=None, prefix='', keep_vars=False)\n", + " | Returns a dictionary containing references to the whole state of the module.\n", + " | \n", + " | Both parameters and persistent buffers (e.g. running averages) are\n", + " | included. Keys are corresponding parameter and buffer names.\n", + " | Parameters and buffers set to ``None`` are not included.\n", + " | \n", + " | .. note::\n", + " | The returned object is a shallow copy. It contains references\n", + " | to the module's parameters and buffers.\n", + " | \n", + " | .. warning::\n", + " | Currently ``state_dict()`` also accepts positional arguments for\n", + " | ``destination``, ``prefix`` and ``keep_vars`` in order. However,\n", + " | this is being deprecated and keyword arguments will be enforced in\n", + " | future releases.\n", + " | \n", + " | .. warning::\n", + " | Please avoid the use of argument ``destination`` as it is not\n", + " | designed for end-users.\n", + " | \n", + " | Args:\n", + " | destination (dict, optional): If provided, the state of module will\n", + " | be updated into the dict and the same object is returned.\n", + " | Otherwise, an ``OrderedDict`` will be created and returned.\n", + " | Default: ``None``.\n", + " | prefix (str, optional): a prefix added to parameter and buffer\n", + " | names to compose the keys in state_dict. Default: ``''``.\n", + " | keep_vars (bool, optional): by default the :class:`~torch.Tensor` s\n", + " | returned in the state dict are detached from autograd. If it's\n", + " | set to ``True``, detaching will not be performed.\n", + " | Default: ``False``.\n", + " | \n", + " | Returns:\n", + " | dict:\n", + " | a dictionary containing a whole state of the module\n", + " | \n", + " | Example::\n", + " | \n", + " | >>> # xdoctest: +SKIP(\"undefined vars\")\n", + " | >>> module.state_dict().keys()\n", + " | ['bias', 'weight']\n", + " | \n", + " | to(self, *args, **kwargs)\n", + " | Moves and/or casts the parameters and buffers.\n", + " | \n", + " | This can be called as\n", + " | \n", + " | .. function:: to(device=None, dtype=None, non_blocking=False)\n", + " | :noindex:\n", + " | \n", + " | .. function:: to(dtype, non_blocking=False)\n", + " | :noindex:\n", + " | \n", + " | .. function:: to(tensor, non_blocking=False)\n", + " | :noindex:\n", + " | \n", + " | .. function:: to(memory_format=torch.channels_last)\n", + " | :noindex:\n", + " | \n", + " | Its signature is similar to :meth:`torch.Tensor.to`, but only accepts\n", + " | floating point or complex :attr:`dtype`\\ s. In addition, this method will\n", + " | only cast the floating point or complex parameters and buffers to :attr:`dtype`\n", + " | (if given). The integral parameters and buffers will be moved\n", + " | :attr:`device`, if that is given, but with dtypes unchanged. When\n", + " | :attr:`non_blocking` is set, it tries to convert/move asynchronously\n", + " | with respect to the host if possible, e.g., moving CPU Tensors with\n", + " | pinned memory to CUDA devices.\n", + " | \n", + " | See below for examples.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Args:\n", + " | device (:class:`torch.device`): the desired device of the parameters\n", + " | and buffers in this module\n", + " | dtype (:class:`torch.dtype`): the desired floating point or complex dtype of\n", + " | the parameters and buffers in this module\n", + " | tensor (torch.Tensor): Tensor whose dtype and device are the desired\n", + " | dtype and device for all parameters and buffers in this module\n", + " | memory_format (:class:`torch.memory_format`): the desired memory\n", + " | format for 4D parameters and buffers in this module (keyword\n", + " | only argument)\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | Examples::\n", + " | \n", + " | >>> # xdoctest: +IGNORE_WANT(\"non-deterministic\")\n", + " | >>> linear = nn.Linear(2, 2)\n", + " | >>> linear.weight\n", + " | Parameter containing:\n", + " | tensor([[ 0.1913, -0.3420],\n", + " | [-0.5113, -0.2325]])\n", + " | >>> linear.to(torch.double)\n", + " | Linear(in_features=2, out_features=2, bias=True)\n", + " | >>> linear.weight\n", + " | Parameter containing:\n", + " | tensor([[ 0.1913, -0.3420],\n", + " | [-0.5113, -0.2325]], dtype=torch.float64)\n", + " | >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA1)\n", + " | >>> gpu1 = torch.device(\"cuda:1\")\n", + " | >>> linear.to(gpu1, dtype=torch.half, non_blocking=True)\n", + " | Linear(in_features=2, out_features=2, bias=True)\n", + " | >>> linear.weight\n", + " | Parameter containing:\n", + " | tensor([[ 0.1914, -0.3420],\n", + " | [-0.5112, -0.2324]], dtype=torch.float16, device='cuda:1')\n", + " | >>> cpu = torch.device(\"cpu\")\n", + " | >>> linear.to(cpu)\n", + " | Linear(in_features=2, out_features=2, bias=True)\n", + " | >>> linear.weight\n", + " | Parameter containing:\n", + " | tensor([[ 0.1914, -0.3420],\n", + " | [-0.5112, -0.2324]], dtype=torch.float16)\n", + " | \n", + " | >>> linear = nn.Linear(2, 2, bias=None).to(torch.cdouble)\n", + " | >>> linear.weight\n", + " | Parameter containing:\n", + " | tensor([[ 0.3741+0.j, 0.2382+0.j],\n", + " | [ 0.5593+0.j, -0.4443+0.j]], dtype=torch.complex128)\n", + " | >>> linear(torch.ones(3, 2, dtype=torch.cdouble))\n", + " | tensor([[0.6122+0.j, 0.1150+0.j],\n", + " | [0.6122+0.j, 0.1150+0.j],\n", + " | [0.6122+0.j, 0.1150+0.j]], dtype=torch.complex128)\n", + " | \n", + " | to_empty(self: ~T, *, device: Union[str, torch.device]) -> ~T\n", + " | Moves the parameters and buffers to the specified device without copying storage.\n", + " | \n", + " | Args:\n", + " | device (:class:`torch.device`): The desired device of the parameters\n", + " | and buffers in this module.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | train(self: ~T, mode: bool = True) -> ~T\n", + " | Sets the module in training mode.\n", + " | \n", + " | This has any effect only on certain modules. See documentations of\n", + " | particular modules for details of their behaviors in training/evaluation\n", + " | mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,\n", + " | etc.\n", + " | \n", + " | Args:\n", + " | mode (bool): whether to set training mode (``True``) or evaluation\n", + " | mode (``False``). Default: ``True``.\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | type(self: ~T, dst_type: Union[torch.dtype, str]) -> ~T\n", + " | Casts all parameters and buffers to :attr:`dst_type`.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Args:\n", + " | dst_type (type or string): the desired type\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | xpu(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n", + " | Moves all model parameters and buffers to the XPU.\n", + " | \n", + " | This also makes associated parameters and buffers different objects. So\n", + " | it should be called before constructing optimizer if the module will\n", + " | live on XPU while being optimized.\n", + " | \n", + " | .. note::\n", + " | This method modifies the module in-place.\n", + " | \n", + " | Arguments:\n", + " | device (int, optional): if specified, all parameters will be\n", + " | copied to that device\n", + " | \n", + " | Returns:\n", + " | Module: self\n", + " | \n", + " | zero_grad(self, set_to_none: bool = True) -> None\n", + " | Sets gradients of all model parameters to zero. See similar function\n", + " | under :class:`torch.optim.Optimizer` for more context.\n", + " | \n", + " | Args:\n", + " | set_to_none (bool): instead of setting to zero, set the grads to None.\n", + " | See :meth:`torch.optim.Optimizer.zero_grad` for details.\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from torch.nn.modules.module.Module:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes inherited from torch.nn.modules.module.Module:\n", + " | \n", + " | T_destination = ~T_destination\n", + " | \n", + " | call_super_init = False\n", + " | \n", + " | dump_patches = False\n", + "\n" + ] + } + ], + "source": [ + "help(eva02_model)" + ] + }, + { + "cell_type": "markdown", + "id": "2f5ac1a7-6f1b-4417-8a67-1b2e32d385dd", + "metadata": {}, + "source": [ + "# DETR" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5c3ade1b-18ea-4368-abd9-53be1fdfb610", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-08-28 01:51:14,033] [INFO] [real_accelerator.py:133:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The `max_size` parameter is deprecated and will be removed in v4.26. Please specify in `size['longest_edge'] instead`.\n" + ] + } + ], + "source": [ + "from transformers import DetrImageProcessor, DetrForObjectDetection\n", + "import torch\n", + "from PIL import Image\n", + "import requests\n", + "\n", + "url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "\n", + "processor = DetrImageProcessor.from_pretrained(\"facebook/detr-resnet-50\", cache_dir='/fsx/proj-fmri/shared/cache')\n", + "model = DetrForObjectDetection.from_pretrained(\"facebook/detr-resnet-50\", cache_dir='/fsx/proj-fmri/shared/cache')" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1d5aa2d7-4868-4751-8d90-7c52be028cd9", + "metadata": {}, + "outputs": [], + "source": [ + "inputs = processor(images=image, return_tensors=\"pt\")\n", + "outputs = model(**inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ae6bafc6-cee4-4e59-b7ba-12efc2a65b74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Detected remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]\n", + "Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]\n", + "Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]\n", + "Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]\n", + "Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]\n" + ] + } + ], + "source": [ + "# convert outputs (bounding boxes and class logits) to COCO API\n", + "# let's only keep detections with score > 0.9\n", + "target_sizes = torch.tensor([image.size[::-1]])\n", + "results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]\n", + "\n", + "for score, label, box in zip(results[\"scores\"], results[\"labels\"], results[\"boxes\"]):\n", + " box = [round(i, 2) for i in box.tolist()]\n", + " print(\n", + " f\"Detected {model.config.id2label[label.item()]} with confidence \"\n", + " f\"{round(score.item(), 3)} at location {box}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "6dcc5934-79d4-4062-8b32-e42b3ebcdc0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DetrImageProcessor {\n", + " \"do_normalize\": true,\n", + " \"do_pad\": true,\n", + " \"do_rescale\": true,\n", + " \"do_resize\": true,\n", + " \"feature_extractor_type\": \"DetrFeatureExtractor\",\n", + " \"format\": \"coco_detection\",\n", + " \"image_mean\": [\n", + " 0.485,\n", + " 0.456,\n", + " 0.406\n", + " ],\n", + " \"image_processor_type\": \"DetrImageProcessor\",\n", + " \"image_std\": [\n", + " 0.229,\n", + " 0.224,\n", + " 0.225\n", + " ],\n", + " \"resample\": 2,\n", + " \"rescale_factor\": 0.00392156862745098,\n", + " \"size\": {\n", + " \"longest_edge\": 1333,\n", + " \"shortest_edge\": 800\n", + " }\n", + "}" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "processor" + ] + }, + { + "cell_type": "markdown", + "id": "db1d89cc-b432-473e-af69-d81c435ac731", + "metadata": {}, + "source": [ + "# CLIPSeg" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "15db14d1-ee4d-4429-9286-054c4498293b", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation\n", + "\n", + "processor = CLIPSegProcessor.from_pretrained(\"CIDAS/clipseg-rd16\",cache_dir='/fsx/proj-fmri/shared/cache')\n", + "model = CLIPSegForImageSegmentation.from_pretrained(\"CIDAS/clipseg-rd16\",cache_dir='/fsx/proj-fmri/shared/cache')" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "4aa225d4-5a3b-4dbb-ae57-dea2872ff492", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'JpegImageFile' object has no attribute 'shape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[38], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'JpegImageFile' object has no attribute 'shape'" + ] + } + ], + "source": [ + "image.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad7e2daf-0c7c-4fec-b29e-9ba47a037c6b", + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import requests\n", + "import h5py\n", + "\n", + "# url = \"https://unsplash.com/photos/8Nc_oQsc2qQ/download?ixid=MnwxMjA3fDB8MXxhbGx8fHx8fHx8fHwxNjcxMjAwNzI0&force=true&w=640\"\n", + "# image = Image.open(requests.get(url, stream=True).raw)\n", + "\n", + "image_path = \"/fsx/proj-fmri/shared/mindeyev2_dataset/coco_images_224_float16.hdf5\"\n", + "with h5py.File(image_path, 'r') as file:\n", + " image = file['images'][0]\n", + "image = np.moveaxis(image, 0, -1).astype(np.float32)\n", + "plt.imshow(image)\n", + "\n", + "prompts = [\"person\",\"animal\",\"object\",\"background\"]\n", + "import torch\n", + "\n", + "# Rescale to [0, 255]\n", + "array = (image * 255).astype(np.uint8)\n", + "\n", + "# Convert to PIL image\n", + "image = Image.fromarray(array)\n", + "\n", + "inputs = processor(text=prompts, images=[image] * len(prompts), padding=\"max_length\", return_tensors=\"pt\")\n", + "# predict\n", + "with torch.no_grad():\n", + " outputs = model(**inputs)\n", + "preds = outputs.logits.unsqueeze(1)\n", + "print(preds.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "131eb5b7-2f16-4a79-8402-edc1a1d8c348", + "metadata": {}, + "outputs": [], + "source": [ + "preds = ((preds[0] + preds[1] + preds[2] + preds[-1].max() - preds[-1]) / 4)[None]\n", + "preds.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2bf99e7-064d-4c22-997f-aa1a35dbab82", + "metadata": {}, + "outputs": [], + "source": [ + "_, ax = plt.subplots(1, len(prompts) + 1, figsize=(3*(len(prompts) + 1), 4))\n", + "[a.axis('off') for a in ax.flatten()]\n", + "ax[0].imshow(image)\n", + "[ax[i+1].imshow(torch.sigmoid(preds[i][0])) for i in range(1)];\n", + "# [ax[i+1].text(0, -15, prompt) for i, prompt in enumerate(prompts)];" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b58b926f-a2b2-423b-b367-18808cf6b4f7", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/deepspeed_config_stage1.json b/src/deepspeed_config_stage1.json new file mode 100644 index 0000000000000000000000000000000000000000..67ae14278888ae970103bd8e241ca766c6b48755 --- /dev/null +++ b/src/deepspeed_config_stage1.json @@ -0,0 +1 @@ +{"bf16": {"enabled": false}, "fp16": {"enabled": true}, "zero_optimization": {"stage": 1, "contiguous_gradients": true, "stage3_gather_16bit_weights_on_model_save": true, "stage3_max_live_parameters": 1000000000.0, "stage3_max_reuse_distance": 1000000000.0, "stage3_prefetch_bucket_size": 10000000.0, "stage3_param_persistence_threshold": 100000.0, "reduce_bucket_size": 10000000.0, "sub_group_size": 1000000000.0, "offload_optimizer": {"device": "none", "nvme_path": "/scratch", "pin_memory": true}, "offload_param": {"device": "none", "nvme_path": "/scratch", "buffer_size": 4000000000.0, "pin_memory": true}}, "aio": {"block_size": 26214400, "queue_depth": 32, "thread_count": 1, "single_submit": false, "overlap_events": true}, "gradient_accumulation_steps": 1, "gradient_clipping": 1.0, "steps_per_print": 20000, "train_batch_size": 8, "train_micro_batch_size_per_gpu": 8, "wall_clock_breakdown": false, "zero_allow_untested_optimizer": true} \ No newline at end of file diff --git a/src/deepspeed_config_stage2.json b/src/deepspeed_config_stage2.json new file mode 100644 index 0000000000000000000000000000000000000000..1bc67291fefd7c0bea45ce145a7686b53e9b7395 --- /dev/null +++ b/src/deepspeed_config_stage2.json @@ -0,0 +1 @@ +{"bf16": {"enabled": false}, "fp16": {"enabled": true}, "zero_optimization": {"stage": 2, "contiguous_gradients": true, "stage3_gather_16bit_weights_on_model_save": true, "stage3_max_live_parameters": 1000000000.0, "stage3_max_reuse_distance": 1000000000.0, "stage3_prefetch_bucket_size": 10000000.0, "stage3_param_persistence_threshold": 100000.0, "reduce_bucket_size": 10000000.0, "sub_group_size": 1000000000.0, "offload_optimizer": {"device": "cpu", "nvme_path": "/scratch", "pin_memory": true}, "offload_param": {"device": "none", "nvme_path": "/scratch", "buffer_size": 4000000000.0, "pin_memory": true}}, "aio": {"block_size": 26214400, "queue_depth": 32, "thread_count": 1, "single_submit": false, "overlap_events": true}, "gradient_accumulation_steps": 1, "gradient_clipping": 1.0, "steps_per_print": 20000, "train_batch_size": 256, "train_micro_batch_size_per_gpu": 32, "wall_clock_breakdown": false, "zero_allow_untested_optimizer": true} \ No newline at end of file diff --git a/src/deepspeed_config_stage2_cpuoffload.json b/src/deepspeed_config_stage2_cpuoffload.json new file mode 100644 index 0000000000000000000000000000000000000000..d701783844adcd5a7fd6a42b95930e2b4ab0e5b6 --- /dev/null +++ b/src/deepspeed_config_stage2_cpuoffload.json @@ -0,0 +1,44 @@ +{ + "bf16": { + "enabled": false + }, + "fp16": { + "enabled": true + }, + "zero_optimization": { + "stage": 2, + "contiguous_gradients": true, + "stage3_gather_16bit_weights_on_model_save": true, + "stage3_max_live_parameters": 1000000000.0, + "stage3_max_reuse_distance": 1000000000.0, + "stage3_prefetch_bucket_size": 10000000.0, + "stage3_param_persistence_threshold": 100000.0, + "reduce_bucket_size": 10000000.0, + "sub_group_size": 1000000000.0, + "offload_optimizer": { + "device": "cpu", + "nvme_path": "/scratch", + "pin_memory": true + }, + "offload_param": { + "device": "none", + "nvme_path": "/scratch", + "buffer_size": 4000000000.0, + "pin_memory": true + } + }, + "aio": { + "block_size": 26214400, + "queue_depth": 32, + "thread_count": 1, + "single_submit": false, + "overlap_events": true + }, + "gradient_accumulation_steps": 1, + "gradient_clipping": 1.0, + "steps_per_print": 20000, + "train_batch_size": 256, + "train_micro_batch_size_per_gpu": 32, + "wall_clock_breakdown": false, + "zero_allow_untested_optimizer": true +} \ No newline at end of file diff --git a/src/deepspeed_config_stage3.json b/src/deepspeed_config_stage3.json new file mode 100644 index 0000000000000000000000000000000000000000..dad4f264d2978c4e9f9ccbdd304e604a67cd1135 --- /dev/null +++ b/src/deepspeed_config_stage3.json @@ -0,0 +1 @@ +{"fp16": {"enabled": true}, "optimizer": {"type": "AdamW", "params": {"lr": "auto", "weight_decay": "auto"}}, "scheduler": {"type": "WarmupDecayLR", "params": {"warmup_min_lr": "auto", "warmup_max_lr": "auto", "warmup_num_steps": "auto", "total_num_steps": "auto"}}, "zero_optimization": {"stage": 3, "offload_optimizer": {"device": "cpu", "pin_memory": true}, "offload_param": {"device": "cpu", "pin_memory": true}, "overlap_comm": true, "contiguous_gradients": true, "reduce_bucket_size": "auto", "stage3_prefetch_bucket_size": "auto", "stage3_param_persistence_threshold": "auto", "sub_group_size": 1000000000.0, "stage3_max_live_parameters": 1000000000.0, "stage3_max_reuse_distance": 1000000000.0, "stage3_gather_16bit_weights_on_model_save": "auto"}, "gradient_accumulation_steps": 1, "gradient_clipping": "auto", "steps_per_print": 2000, "train_batch_size": 256, "train_micro_batch_size_per_gpu": 32, "wall_clock_breakdown": false, "bf16": {"enabled": false}} \ No newline at end of file diff --git a/src/huggingface_to_s3.ipynb b/src/huggingface_to_s3.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..46a747218d47b31ba27c7f8b960063482a0fe381 --- /dev/null +++ b/src/huggingface_to_s3.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cf698d59-1cc2-4859-9c43-9a5d4d924ee1", + "metadata": {}, + "source": [ + "# Transfer huggingface mindeyev2 dataset to Stability aws s3" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "94c7404c-7a0f-4508-a630-954bc9af11fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/shared1000.npy -O /fsx/proj-fmri/shared/mindeyev2_dataset/shared1000.npy\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj01.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj01.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj02.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj02.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj03.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj03.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj04.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj04.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj05.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj05.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj06.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj06.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj07.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj07.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/betas_all_subj08.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/betas_all_subj08.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/coco_images_224_float16.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/coco_images_224_float16.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/COCO_73k_subj_indices.hdf5 -O /fsx/proj-fmri/shared/mindeyev2_dataset/COCO_73k_subj_indices.hdf5\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj01/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj02/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj02/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj03/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj03/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj04/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj04/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj05/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj05/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj06/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj06/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj07/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj07/test/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/0.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/1.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/1.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/2.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/2.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/3.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/3.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/4.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/4.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/5.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/5.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/6.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/6.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/7.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/7.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/8.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/8.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/9.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/9.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/10.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/10.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/11.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/11.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/12.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/12.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/13.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/13.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/14.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/14.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/15.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/15.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/16.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/16.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/17.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/17.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/18.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/18.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/19.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/19.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/20.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/20.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/21.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/21.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/22.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/22.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/23.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/23.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/24.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/24.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/25.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/25.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/26.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/26.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/27.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/27.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/28.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/28.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/29.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/29.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/30.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/30.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/31.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/31.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/32.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/32.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/33.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/33.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/34.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/34.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/35.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/35.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/train/36.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/train/36.tar\n", + "wget --show-progress https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/wds/subj08/test/0.tar -O /fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj08/test/0.tar\n", + "aws s3 sync /scratch/mindeyev2_dataset s3://proj-fmri/mindeyev2_dataset --region us-west-2\n" + ] + } + ], + "source": [ + "import os\n", + "# from subprocess import call\n", + "# PS Note: it's faster to print the wget statements and then manually copy paste all them into terminal than to use subprocess call()\n", + "tmp = '/fsx/proj-fmri/shared/mindeyev2_dataset/' #'/scratch/mindeyev2_dataset/'\n", + "\n", + "hf_base_link = 'https://huggingface.co/datasets/pscotti/mindeyev2/resolve/main/'\n", + "\n", + "os.makedirs(tmp,exist_ok=True)\n", + "\n", + "files = [\n", + " \"shared1000.npy\",\n", + " \"betas_all_subj01.hdf5\",\n", + " \"betas_all_subj02.hdf5\",\n", + " \"betas_all_subj03.hdf5\",\n", + " \"betas_all_subj04.hdf5\",\n", + " \"betas_all_subj05.hdf5\",\n", + " \"betas_all_subj06.hdf5\",\n", + " \"betas_all_subj07.hdf5\",\n", + " \"betas_all_subj08.hdf5\",\n", + " \"coco_images_224_float16.hdf5\",\n", + " \"COCO_73k_subj_indices.hdf5\",\n", + "]\n", + "\n", + "for f in files: \n", + " command = f\"wget --show-progress {hf_base_link}{f} -O {tmp}{f}\"\n", + " print(command)\n", + " # call(command,shell=True)\n", + "\n", + "for sub in range(1,9):\n", + " subject = f'subj0{sub}'\n", + "\n", + " tmp_fol = f'{tmp}wds/{subject}/'\n", + " os.makedirs(tmp_fol,exist_ok=True)\n", + " os.makedirs(tmp_fol+'train',exist_ok=True)\n", + " os.makedirs(tmp_fol+'test',exist_ok=True)\n", + "\n", + " for i in range(37):\n", + " link = f'train/{i}.tar'\n", + " command = f\"wget --show-progress {hf_base_link}wds/{subject}/{link} -O {tmp}wds/{subject}/{link}\"\n", + " print(command)\n", + " # call(command,shell=True)\n", + "\n", + " link = f'test/0.tar'\n", + " command = f\"wget --show-progress {hf_base_link}wds/{subject}/{link} -O {tmp}wds/{subject}/{link}\"\n", + " print(command)\n", + " # call(command,shell=True)\n", + "\n", + "command = \"aws s3 sync /scratch/mindeyev2_dataset s3://proj-fmri/mindeyev2_dataset --region us-west-2\"\n", + "print(command)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30966082-59c2-411c-9b2e-4f4e3f9eb0f3", + "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.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/models.py b/src/models.py new file mode 100644 index 0000000000000000000000000000000000000000..00a25ee158c0d888de6d83855215a6b7fddd7689 --- /dev/null +++ b/src/models.py @@ -0,0 +1,210 @@ +import os +import numpy as np +from torchvision import transforms +import torch +import torch.nn as nn +import PIL +import clip +import open_clip +from functools import partial +import random +import json + +# class BrainMLP(nn.Module): +# def __init__(self, out_dim=257*768, in_dim=15724, clip_size=768, h=4096): +# super().__init__() +# self.lin0 = nn.Sequential( +# nn.Linear(in_dim, h, bias=False), +# nn.LayerNorm(h), +# nn.GELU(inplace=True), +# nn.Dropout(0.5)) +# self.mlp = nn.ModuleList([ +# nn.Sequential( +# nn.Linear(h, h), +# nn.LayerNorm(h), +# nn.GELU(inplace=True), +# nn.Dropout(0.15) +# ) for _ in range(4)]) +# self.lin1 = nn.Linear(h, out_dim, bias=True) +# self.proj = nn.Sequential( +# nn.LayerNorm(clip_size), +# nn.GELU(), +# nn.Linear(clip_size, 2048), +# nn.LayerNorm(2048), +# nn.GELU(), +# nn.Linear(2048, 2048), +# nn.LayerNorm(2048), +# nn.GELU(), +# nn.Linear(2048, clip_size)) +# def forward(self, x): +# x = self.lin0(x) +# residual = x +# for res_block in range(self.n_blocks): +# x = self.mlp[res_block](x) +# x += residual +# residual = x +# diffusion_prior_input = self.lin1(x.reshape(len(x), -1)) +# disjointed_clip_fmri = self.proj(diffusion_prior_input.reshape( +# len(x),-1, self.clip_size)) +# return diffusion_prior_input, disjointed_clip_fmri + + + +class Clipper(torch.nn.Module): + def __init__(self, clip_variant, clamp_embs=False, norm_embs=False, + hidden_state=False, device=torch.device('cpu')): + super().__init__() + assert clip_variant in ("RN50", "ViT-L/14", "ViT-B/32", "RN50x64"), \ + "clip_variant must be one of RN50, ViT-L/14, ViT-B/32, RN50x64" + print(clip_variant, device) + + if clip_variant=="ViT-L/14" and hidden_state: + # from transformers import CLIPVisionModelWithProjection + # image_encoder = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-large-patch14",cache_dir="/fsx/proj-medarc/fmri/cache") + from transformers import CLIPVisionModelWithProjection + sd_cache_dir = '/fsx/proj-fmri/shared/cache/models--shi-labs--versatile-diffusion/snapshots/2926f8e11ea526b562cd592b099fcf9c2985d0b7' + image_encoder = CLIPVisionModelWithProjection.from_pretrained(sd_cache_dir, subfolder='image_encoder').eval() + image_encoder = image_encoder.to(device) + for param in image_encoder.parameters(): + param.requires_grad = False # dont need to calculate gradients + self.image_encoder = image_encoder + elif hidden_state: + raise Exception("hidden_state embeddings only works with ViT-L/14 right now") + + clip_model, preprocess = clip.load(clip_variant, device=device) + clip_model.eval() # dont want to train model + for param in clip_model.parameters(): + param.requires_grad = False # dont need to calculate gradients + + self.clip = clip_model + self.clip_variant = clip_variant + if clip_variant == "RN50x64": + self.clip_size = (448,448) + else: + self.clip_size = (224,224) + + preproc = transforms.Compose([ + transforms.Resize(size=self.clip_size[0], interpolation=transforms.InterpolationMode.BICUBIC), + transforms.CenterCrop(size=self.clip_size), + transforms.Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)) + ]) + self.preprocess = preproc + self.hidden_state = hidden_state + self.mean = np.array([0.48145466, 0.4578275, 0.40821073]) + self.std = np.array([0.26862954, 0.26130258, 0.27577711]) + self.normalize = transforms.Normalize(self.mean, self.std) + self.denormalize = transforms.Normalize((-self.mean / self.std).tolist(), (1.0 / self.std).tolist()) + self.clamp_embs = clamp_embs + self.norm_embs = norm_embs + self.device= device + + def versatile_normalize_embeddings(encoder_output): + embeds = encoder_output.last_hidden_state + embeds = image_encoder.vision_model.post_layernorm(embeds) + embeds = image_encoder.visual_projection(embeds) + return embeds + self.versatile_normalize_embeddings = versatile_normalize_embeddings + + def resize_image(self, image): + # note: antialias should be False if planning to use Pinkney's Image Variation SD model + return transforms.Resize(self.clip_size)(image.to(self.device)) + + def embed_image(self, image): + """Expects images in -1 to 1 range""" + if self.hidden_state: + # clip_emb = self.preprocess((image/1.5+.25).to(self.device)) # for some reason the /1.5+.25 prevents oversaturation + clip_emb = self.preprocess((image).to(self.device)) + clip_emb = self.image_encoder(clip_emb) + clip_emb = self.versatile_normalize_embeddings(clip_emb) + else: + clip_emb = self.preprocess(image.to(self.device)) + clip_emb = self.clip.encode_image(clip_emb) + # input is now in CLIP space, but mind-reader preprint further processes embeddings: + if self.clamp_embs: + clip_emb = torch.clamp(clip_emb, -1.5, 1.5) + if self.norm_embs: + if self.hidden_state: + # normalize all tokens by cls token's norm + clip_emb = clip_emb / torch.norm(clip_emb[:, 0], dim=-1).reshape(-1, 1, 1) + else: + clip_emb = nn.functional.normalize(clip_emb, dim=-1) + return clip_emb + + def embed_text(self, text_samples): + clip_text = clip.tokenize(text_samples).to(self.device) + clip_text = self.clip.encode_text(clip_text) + if self.clamp_embs: + clip_text = torch.clamp(clip_text, -1.5, 1.5) + if self.norm_embs: + clip_text = nn.functional.normalize(clip_text, dim=-1) + return clip_text + + def embed_curated_annotations(self, annots): + for i,b in enumerate(annots): + t = '' + while t == '': + rand = torch.randint(5,(1,1))[0][0] + t = b[0,rand] + if i==0: + txt = np.array(t) + else: + txt = np.vstack((txt,t)) + txt = txt.flatten() + return self.embed_text(txt) + +class OpenClipper(torch.nn.Module): + def __init__(self, clip_variant, norm_embs=False, device=torch.device('cpu')): + super().__init__() + print(clip_variant, device) + assert clip_variant == 'ViT-H-14' # not setup for other models yet + + clip_model, _, preprocess = open_clip.create_model_and_transforms('ViT-H-14', + pretrained='laion2b_s32b_b79k', device=device) + clip_model.eval() # dont want to train model + for param in clip_model.parameters(): + param.requires_grad = False # dont need to calculate gradients + + # overwrite preprocess to accept torch inputs instead of PIL Image + preprocess = transforms.Compose([ + transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC, antialias=None), + transforms.CenterCrop(224), + transforms.Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)) + ]) + + tokenizer = open_clip.get_tokenizer('ViT-H-14') + + self.clip = clip_model + self.norm_embs = norm_embs + self.preprocess = preprocess + self.tokenizer = tokenizer + self.device = device + + def embed_image(self, image): + """Expects images in -1 to 1 range""" + image = self.preprocess(image).to(self.device) + with torch.no_grad(), torch.cuda.amp.autocast(): + image_features = self.clip.encode_image(image) + if self.norm_embs: + image_features = nn.functional.normalize(image_features, dim=-1) + return image_features + + def embed_text(self, text_samples): + text = self.tokenizer(text_samples).to(self.device) + with torch.no_grad(), torch.cuda.amp.autocast(): + text_features = self.clip.encode_text(text) + if self.norm_embs: + text_features = nn.functional.normalize(text_features, dim=-1) + return text_features + + def embed_curated_annotations(self, annots): + for i,b in enumerate(annots): + t = '' + while t == '': + rand = torch.randint(5,(1,1))[0][0] + t = b[0,rand] + if i==0: + txt = np.array(t) + else: + txt = np.vstack((txt,t)) + txt = txt.flatten() + return self.embed_text(txt) \ No newline at end of file diff --git a/src/setup.sh b/src/setup.sh new file mode 100644 index 0000000000000000000000000000000000000000..9da9d6d585bcfc8e94b9fe8e94e8a6dbea795da2 --- /dev/null +++ b/src/setup.sh @@ -0,0 +1,15 @@ +#!/bin/bash +# Commands to setup a new conda environment and install all the necessary packages +# See the environment.yaml file for "conda env export > environment.yaml" after running this. + +set -e + +conda create -n fmri python=3.10.8 -y +conda activate fmri + +conda install numpy matplotlib tqdm scikit-image jupyterlab -y + +pip install accelerate webdataset clip pandas matplotlib ftfy regex kornia umap-learn h5py +pip install torchvision==0.15.2 torch==2.0.1 +pip install diffusers +pip install deepspeed diff --git a/src/train2-tryal.ipynb b/src/train2-tryal.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4e07ae3c0200a88ab05e88439d6256486da9ae74 --- /dev/null +++ b/src/train2-tryal.ipynb @@ -0,0 +1,2409 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-11-19 16:32:39,711] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from torchvision.transforms import ToPILImage #CHANGED (added)\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 2370606\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=captions', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-1', '--mixup_pct=.66', '--num_epochs=30', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=captions \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-1 --mixup_pct=.66 --num_epochs=30 --ckpt_interval=999 --no-use_image_aug\"\n", + " #max_lr=3e-5 originally\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e7807ba9-02b6-4bc0-873c-69869abe4091", + "metadata": {}, + "outputs": [], + "source": [ + "wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "795e2885-bd07-4e27-bed7-181473c06df9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import transformers\n", + "from transformers import Blip2Processor, Blip2ForConditionalGeneration\n", + "\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "23428fb7-2955-4295-bea1-447cebf9f72e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading checkpoint shards: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [01:08<00:00, 34.47s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "'from lavis.models import load_model_and_preprocess\\nfrom lavis.models import model_zoo\\nblip2_model, vis_processors, _ = load_model_and_preprocess(\\n name=\"blip2_t5\", model_type=\"pretrain_flant5xl_vitL\", is_eval=True, device=device)\\n\\nclip_seq_dim = 257\\nclip_emb_dim = 1024\\nhidden_dim = 4096'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache_blip2 = \"/fsx/proj-fmri/shared/cache/models--Salesforce--blip2-opt-2.7b/snapshots/6e723d92ee91ebcee4ba74d7017632f11ff4217b\"\n", + "\n", + "b2_processor = Blip2Processor.from_pretrained(cache_blip2)\n", + "b2_model = Blip2ForConditionalGeneration.from_pretrained(cache_blip2, torch_dtype=torch.float16, device_map=\"auto\")\n", + "\n", + "#Load in blip2 as well\n", + "\"\"\"from lavis.models import load_model_and_preprocess\n", + "from lavis.models import model_zoo\n", + "blip2_model, vis_processors, _ = load_model_and_preprocess(\n", + " name=\"blip2_t5\", model_type=\"pretrain_flant5xl_vitL\", is_eval=True, device=device)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 1024\n", + "hidden_dim = 4096\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "b06f3de2-a8da-4ba0-94f0-99096f738d55", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def embed_images_b2(images):\n", + " images = (images * 255).type(torch.uint8)\n", + " with torch.no_grad():\n", + " inputs_processed = b2_processor(images, return_tensors=\"pt\").to(\"cuda\", torch.float16)\n", + " enc_imgs = b2_model.vision_model.forward(inputs_processed['pixel_values'])\n", + " return enc_imgs.last_hidden_state.detach(), inputs_processed\n", + "\n", + "def embeds_to_captions_b2(embeds, sample = False, temp = 0.9):\n", + " with torch.no_grad():\n", + " input_ids = None #inputs['input_ids']\n", + " attention_mask = None\n", + " batch_size = embeds.shape[0]\n", + " image_embeds = embeds\n", + " image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)\n", + "\n", + " query_tokens = b2_model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + " query_outputs = b2_model.qformer(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_attention_mask,\n", + " return_dict=True,\n", + " )\n", + " query_output = query_outputs.last_hidden_state\n", + "\n", + " language_model_inputs = b2_model.language_projection(query_output)\n", + " language_attention_mask = torch.ones(\n", + " language_model_inputs.size()[:-1], dtype=torch.long, device=language_model_inputs.device\n", + " )\n", + " if input_ids is None:\n", + " input_ids = (\n", + " torch.LongTensor([[b2_model.config.text_config.bos_token_id]])\n", + " .repeat(batch_size, 1)\n", + " .to(image_embeds.device)\n", + " )\n", + " if attention_mask is None:\n", + " attention_mask = torch.ones_like(input_ids)\n", + " attention_mask = torch.cat([language_attention_mask, attention_mask.to(language_attention_mask.device)], dim=1)\n", + "\n", + " # concatenate query embeddings with prompt embeddings\n", + " inputs_embeds = b2_model.get_input_embeddings()(input_ids)\n", + " inputs_embeds = torch.cat([language_model_inputs, inputs_embeds.to(language_model_inputs.device)], dim=1)\n", + "\n", + " outputs = b2_model.language_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=attention_mask,\n", + " temperature=temp,\n", + " do_sample = sample\n", + " )\n", + " text = b2_processor.batch_decode(outputs, skip_special_tokens=True)\n", + " \n", + " return outputs, text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "51b29638-2c81-4e9f-b06d-525fdbac44b1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 2, 6209, 14, 10, 205, 425, 13, 10, 7297, 1280,\n", + " 9, 418, 116, 1437, 38, 10728, 33, 117, 1114, 99]],\n", + " device='cuda:0')" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b2_model.language_model.generate(do_sample = True, temperature=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ec0a34d3-76e0-4a47-a9ab-6131ab2ccecd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "image_test = images[1:20].permute(0,2,3,1)\n", + "#raw_image = Image.open('/fsx/proj-fmri/shared/controlNetData/target/img_t1.jpg').convert('RGB')\n", + "# Convert the image to a NumPy array\n", + "#image_test = np.array(raw_image)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e04876a4-45c7-4015-8255-8574c8f50f14", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"import matplotlib.pyplot as plt\\n# Plotting one of the images (taking the first image as an example)\\nimg_to_plot = inputs_rec['pixel_values'][-1]\\n\\n# Transpose the image for correct display (PyTorch: [C, H, W], Matplotlib: [H, W, C])\\nimg_to_plot = img_to_plot.permute(1, 2, 0).to(torch.float32).to('cpu')\\nprint(img_to_plot.shape)\\n\\nplt.imshow(img_to_plot)\\nplt.show()\"" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"import matplotlib.pyplot as plt\n", + "# Plotting one of the images (taking the first image as an example)\n", + "img_to_plot = inputs_rec['pixel_values'][-1]\n", + "\n", + "# Transpose the image for correct display (PyTorch: [C, H, W], Matplotlib: [H, W, C])\n", + "img_to_plot = img_to_plot.permute(1, 2, 0).to(torch.float32).to('cpu')\n", + "print(img_to_plot.shape)\n", + "\n", + "plt.imshow(img_to_plot)\n", + "plt.show()\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "328a17d0-593b-4d1e-812a-10a3b6efea6a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "embeds_test, inputs_rec = embed_images_b2(image_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "abe5f8a8-fca9-4083-8596-a913bdb57de7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#inputs_rec['pixel_values'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c5f3ca7e-b880-421e-b354-7b6c3df565e9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#out = b2_model.generate(**inputs_rec)\n", + "#print(b2_processor.decode(out[0], skip_special_tokens=True).strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fb462016-78d7-46ea-8058-0d608f17ea65", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/generation/utils.py:1260: UserWarning: Using the model-agnostic default `max_length` (=20) to control thegeneration length. We recommend setting `max_new_tokens` to control the maximum length of the generation.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "outputs_test, text_test = embeds_to_captions_b2(embeds_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6a95fcdf-db87-4c02-9728-09f85605fb1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['a cat sitting on a toilet seat\\n',\n", + " 'a person cutting a pizza on a cutting board\\n',\n", + " 'a sandwich and a drink on a table\\n',\n", + " 'a man crossing the street in front of a truck\\n',\n", + " 'a giraffe standing in front of trees\\n',\n", + " 'three men standing together\\n',\n", + " 'a bird standing on a rock next to a body of water\\n',\n", + " 'two men sitting on a street corner in asia\\n',\n", + " 'a woman and two children playing tennis on a court\\n',\n", + " 'a tall brick building with a clock on the side\\n',\n", + " 'a train is on the tracks\\n',\n", + " 'a man and woman in the water with a surfboard\\n',\n", + " 'a living room with a desk and a chair\\n',\n", + " 'a group of men on a basketball court\\n',\n", + " 'a man holding an umbrella\\n',\n", + " 'a man in a red shirt\\n',\n", + " 'a group of people holding cell phones and wine glasses\\n',\n", + " 'a laptop computer sitting on a table in front of a television\\n',\n", + " 'a baseball player is swinging a bat on a field\\n']" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_test" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9ac69fbd-55db-435b-bed6-5ae9186450e3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#inputss['pixel_values'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "0524f498-c8da-4e8a-8970-d75d2d0f6b8b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#image_test.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5417541b-49eb-4e43-a3e2-d937d9653e04", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "max_lr = 1e-4" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "da0ce190-1b3e-4c12-9e9f-91cbc076d044", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "clip_seq_dim = 257 #blip2 image encoder shapes\n", + "clip_emb_dim = 1408 #blip2 image encoder shapes\n", + "hidden_dim = 2048" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "32,215,040 total\n", + "32,215,040 trainable\n", + "param counts:\n", + "32,215,040 total\n", + "32,215,040 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 2048])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "772,419,072 total\n", + "772,419,072 trainable\n", + "param counts:\n", + "804,634,112 total\n", + "804,634,112 trainable\n", + "torch.Size([4, 2048])\n", + "torch.Size([4, 257, 1408])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " # self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " # self.upsampler = Decoder(\n", + " # in_channels=64,\n", + " # out_channels=4,\n", + " # up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " # block_out_channels=[64, 128, 256],\n", + " # layers_per_block=1,\n", + " # )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " # b = self.blin1(x)\n", + " # b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " # return c, b\n", + " return c\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((4,hidden_dim))\n", + "print(b.shape)\n", + "clip_ = model.backbone(b)\n", + "print(clip_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "804,634,112 total\n", + "804,634,112 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeyev2 run captions\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'captions', 'batch_size': 128, 'num_epochs': 30, 'use_image_aug': False, 'max_lr': 0.0001, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.16.0 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231119_163615-o1xwsqre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run captions to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeyev2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeyev2/runs/o1xwsqre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "if local_rank==0 and True: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'mindeyev2'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4e5de216-5318-4b45-ac02-113f03105adc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+       "│ n++                                                                                              │\n",
+       "│    ▲                                                                                             │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "SyntaxError: invalid syntax\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[91m╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\u001b[0m\n", + "\u001b[91m│\u001b[0m n++ \u001b[91m│\u001b[0m\n", + "\u001b[91m│\u001b[0m \u001b[1;91m▲\u001b[0m \u001b[91m│\u001b[0m\n", + "\u001b[91m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mSyntaxError: \u001b[0minvalid syntax\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b4755749-2d99-4e98-ad98-3df661746058", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "checkpoint = torch.load('/fsx/proj-fmri/ckadirt/MindEyeV2/train_logs/caption_clip_0.5_bz/last.pth', map_location='cpu')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "cd3dc793-5a20-4b48-959c-bc64430c8c02", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(checkpoint['model_state_dict'])" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "0faa2c6a-00da-4b66-b5e5-8c4864768805", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule(\n", + " (ridge): RidgeRegression(\n", + " (linear): Linear(in_features=15729, out_features=2048, bias=True)\n", + " )\n", + " (backbone): BrainNetwork(\n", + " (lin0): Linear(in_features=2048, out_features=2048, bias=True)\n", + " (mlp): ModuleList(\n", + " (0-3): 4 x Sequential(\n", + " (0): Linear(in_features=2048, out_features=2048, bias=True)\n", + " (1): LayerNorm((2048,), eps=1e-05, elementwise_affine=True)\n", + " (2): GELU(approximate='none')\n", + " (3): Dropout(p=0.15, inplace=False)\n", + " )\n", + " )\n", + " (lin1): Linear(in_features=2048, out_features=361856, bias=True)\n", + " (clip_proj): Sequential(\n", + " (0): LayerNorm((1408,), eps=1e-05, elementwise_affine=True)\n", + " (1): GELU(approximate='none')\n", + " (2): Linear(in_features=1408, out_features=2048, bias=True)\n", + " (3): LayerNorm((2048,), eps=1e-05, elementwise_affine=True)\n", + " (4): GELU(approximate='none')\n", + " (5): Linear(in_features=2048, out_features=2048, bias=True)\n", + " (6): LayerNorm((2048,), eps=1e-05, elementwise_affine=True)\n", + " (7): GELU(approximate='none')\n", + " (8): Linear(in_features=2048, out_features=1408, bias=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfeeda32-82ca-4364-bce1-eaa41b4f3e25", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "\"\"\"transform = transforms.Compose(\n", + " [\n", + " transforms.Resize(\n", + " (224, 224),\n", + " ),\n", + " transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),\n", + " ]\n", + " )\n", + "\n", + "def tensor_2_embed(image): \n", + " image_for_blip2 = transform(image)\n", + " \n", + " #Generate embeddings\n", + " with blip2_model.maybe_autocast():\n", + " blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2))\n", + " \n", + " return blip2_target\n", + "\n", + "def embed_2_caption(image_embeds, model):\n", + " image_embeds = image_embeds.float()\n", + " image_atts = torch.ones(image_embeds.size()[:-1], dtype=torch.long).to(\n", + " image.device)\n", + "\n", + " query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + " query_output = model.Qformer.bert(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_atts,\n", + " return_dict=True)\n", + "\n", + " inputs_t5 = model.t5_proj(query_output.last_hidden_state)\n", + " atts_t5 = torch.ones(inputs_t5.size()[:-1], dtype=torch.long).to(image.device)\n", + " prompt = model.prompt\n", + " input_tokens = model.t5_tokenizer(\n", + " prompt, padding=\"longest\", return_tensors=\"pt\"\n", + " ).to(image.device)\n", + " encoder_atts = torch.cat([atts_t5, input_tokens.attention_mask], dim=1)\n", + " \n", + " with model.maybe_autocast(dtype=torch.bfloat16):\n", + " inputs_embeds = model.t5_model.encoder.embed_tokens(input_tokens.input_ids)\n", + " inputs_embeds = torch.cat([inputs_t5, inputs_embeds], dim=1)\n", + "\n", + " outputs = model.t5_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=encoder_atts)\n", + " output_text = model.t5_tokenizer.batch_decode(\n", + " outputs, skip_special_tokens=True)\n", + " \n", + " return output_text\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "636b4684-df9a-4e29-8683-86fb035ba690", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "wandb_log = False" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "0847b380-2edb-4a56-9b33-fdc4c0c3f8d3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "predicted_embeddings = None" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "captions starting with epoch 0 / 30\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/30 [00:17.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " \"\"\"for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " if epoch == 0:\n", + " lrs.append(0)\n", + " break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " # blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " # clip_target = clip_model.embed_image(image)\n", + " clip_target = embed_images_b2(image)[0].to(device) #####CHANGED\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " clip_voxels = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + " \n", + " loss_mse= mse(clip_voxels, clip_target)\n", + "\n", + " # loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " # loss_blurry_total += loss_blurry.item()\n", + "\n", + " # loss = loss_blurry + loss_clip\n", + " loss = 0.7 * loss_clip + 0.3 * loss_mse\n", + " if (train_i % 10 == 0):\n", + " print(train_i, loss)\n", + " # print(batch_size)\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # with torch.no_grad():\n", + " # # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " # random_samps = np.random.choice(np.arange(len(voxel)), size=8, replace=False)\n", + " # blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " # blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\"\"\"\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == batch_size\n", + " \n", + " # blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " # clip_target = clip_model.embed_image(image.float())\n", + " clip_target = embed_images_b2(image)[0].to(device) #####CHANGED\n", + " \n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " clip_voxels = model.backbone(voxel_ridge)\n", + " \n", + " predicted_embeddings = clip_voxels\n", + " break\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " # loss_clip = utils.soft_clip_loss(\n", + " # clip_voxels_norm,\n", + " # clip_target_norm,\n", + " # temp=.006)\n", + " \n", + " loss_clip = mse(clip_voxels, clip_target)\n", + "\n", + " # loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " # loss = loss_blurry + loss_clip\n", + " loss = loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # # halving the batch size because the decoder is computationally heavy\n", + " # blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " # blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " # test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " #Find captions and print next to images\n", + " #caption1 = embed_2_caption(clip_voxels[[0]], blip2_model)\n", + " #caption2 = embed_2_caption(clip_voxels[[1]], blip2_model)\n", + "\n", + " #true_embed1 = tensor_2_embed(image[[0]])\n", + " #true_embed2 = tensor_2_embed(image[[1]])\n", + "\n", + " # print(clip_voxels[[0]].shape)\n", + " # print(true_embed1.shape)\n", + " \n", + " #true_caption1 = embed_2_caption(true_embed1, blip2_model)\n", + " #true_caption2 = embed_2_caption(true_embed2, blip2_model)\n", + " \n", + " # transform blurry recon latents to images and plot it\n", + " #fig, axes = plt.subplots(2, 2, figsize=(8, 4))\n", + " #axes[0,0].imshow(utils.torch_to_Image(image[[0]]))\n", + " #axes[0,1].imshow(utils.torch_to_Image(image[[1]]))\n", + " #axes[0,0].axis('off'); axes[0,1].axis('off'); axes[1,0].axis('off'); axes[1,1].axis('off')\n", + " #axes[0,0].set_title(caption1)\n", + " #axes[0,1].set_title(caption2)\n", + " #axes[1,0].set_title(true_caption1)\n", + " #axes[1,1].set_title(true_caption2)\n", + "\n", + " #plt.show()\n", + " \n", + " # # transform blurry recon latents to images and plot it\n", + " # fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " # axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " # axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " # axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " # axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " # axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " # axes[0].set_title(caption1)\n", + " # axes[3].set_title(caption2)\n", + " # plt.show()\n", + " \n", + " break\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + " \n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3,4,5,6,7]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(image[j]))\n", + " axes[jj].axis('off')\n", + "\n", + " if wandb_log:\n", + " generated_captions = embeds_to_captions_b2(clip_voxels[0:8])\n", + " print(generated_captions[1])\n", + " logs[f\"test/recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\" + \"\\n\".join(generated_captions[1]))\n", + " plt.close()\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "f5b47c76-a97a-48ee-b4b3-051c17aebac4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([128, 257, 1408])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predicted_embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "92d0029f-079f-4710-bf43-bc9e3fd08d5e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/generation/utils.py:1260: UserWarning: Using the model-agnostic default `max_length` (=20) to control thegeneration length. We recommend setting `max_new_tokens` to control the maximum length of the generation.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a group of people are sitting around a table\\n', 'a man is holding a glass of water in front of a television\\n', 'a man is riding a skateboard on a hill\\n', 'a group of people standing around a bike\\n', 'a building with a sign that says \"the house\"\\n', 'a plate of food with vegetables and meat\\n', 'a white cup with a small bottle of wine\\n', 'a group of people playing baseball and one is holding a ball\\n']\n" + ] + } + ], + "source": [ + "generated_captions = embeds_to_captions_b2(predicted_embeddings[0:8])\n", + "print(generated_captions[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "88750a6d-0b61-4943-a7e5-1d675bbb4f8f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a group of people are sitting at a table with food and drinks\\n', 'a man in a kitchen with a large screen\\n', 'a man on a surfboard with his legs in the air\\n', 'a group of people are standing on the beach in front of a boat\\n', 'a building with a sign that says \"home of the person\"\\n', 'a vegetable salad with a variety of vegetables and other ingredients\\n', 'a white cup with a small amount of coffee and a bottle of wine\\n', 'a group of people playing baseball and soccer\\n']\n" + ] + } + ], + "source": [ + "generated_captions = embeds_to_captions_b2(predicted_embeddings[0:8], sample = True, temp = 0.3)\n", + "print(generated_captions[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "d99e7583-0f26-41c1-8035-a1aa3b1c2d55", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def concatenate_lists_any_depth(list1, list2):\n", + " \"\"\"\n", + " Concatenates two lists of potentially varying depths, forming a new list of lists.\n", + "\n", + " Args:\n", + " list1 (list): The first list to concatenate. Elements can be of any type.\n", + " list2 (list): The second list to concatenate. Elements can be of any type.\n", + "\n", + " Returns:\n", + " list: A new list containing lists of elements from the original lists.\n", + " \"\"\"\n", + " # Ensure that both lists have the same length\n", + " if len(list1) != len(list2):\n", + " raise ValueError(\"Lists must be of the same length\")\n", + "\n", + " concatenated_list = []\n", + "\n", + " for a, b in zip(list1, list2):\n", + " # If the elements are not lists, convert them to lists\n", + " if not isinstance(a, list):\n", + " a = [a]\n", + " if not isinstance(b, list):\n", + " b = [b]\n", + "\n", + " # Concatenate the lists\n", + " concatenated_list.append(a + b)\n", + "\n", + " return concatenated_list" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "ed8167ea-a3ab-438a-aa85-f1309047199c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def sample_several(embeddings, num=10, temp=0.3):\n", + " # embeddings shape = batch, 257, 1408\n", + " results = None # Initialize results as None\n", + "\n", + " for i in range(num): # Iterate from 0 to num-1\n", + " if results is None:\n", + " # For the first iteration, assign the results directly\n", + " results = embeds_to_captions_b2(embeddings, sample=True, temp=temp)[1]\n", + " else:\n", + " # For subsequent iterations, combine the new results with the existing ones\n", + " new_results = embeds_to_captions_b2(embeddings, sample=True, temp=temp)[1]\n", + " results = concatenate_lists_any_depth(results, new_results)\n", + "\n", + " return results # Return the combined results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "6700e130-8ae4-4475-a5b4-972fd8b9717a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a group of people sitting on a bench in front of a building\\n', 'a woman is using a computer to make a video\\n', 'a man in a black shirt is sitting on a surfboard\\n', 'a group of people on the beach with a bike and some other things\\n', 'a large building with a sign that says \"the old farmhouse\"\\n', 'a plate with many different types of vegetables\\n', 'a white cup with a bottle of wine and a small bottle of wine\\n', 'a group of people are playing baseball in a field\\n']\n" + ] + } + ], + "source": [ + "generated_captions = embeds_to_captions_b2(predicted_embeddings[0:8], sample = True, temp = 0.3)\n", + "print(generated_captions[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "f0e111e3-6134-4a63-a6d7-17b3441be8c8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[['people are sitting at a table with a bunch of chairs\\n',\n", + " 'several people in the yard with some food\\n',\n", + " 'people sitting on a bench near a water fountain\\n',\n", + " 'a group of people are sitting around a table\\n',\n", + " 'a group of people in a room with several people in the foreground\\n',\n", + " 'a group of people sitting around a table with food\\n',\n", + " 'the people in the background are sitting on the edge of a table\\n',\n", + " 'beverages and food are served at a family picnic\\n',\n", + " 'a group of people eating in a restaurant\\n',\n", + " 'a group of people sitting around a table\\n',\n", + " 'people are sitting at a table next to a tree\\n',\n", + " 'people are sitting around a table with a lot of food\\n'],\n", + " ['a person is holding a newspaper in a restaurant\\n',\n", + " 'the man is holding a cup of coffee in front of a television\\n',\n", + " 'a woman is preparing to cook in a kitchen\\n',\n", + " 'a man working in an office setting with a computer and a man in a chair\\n',\n", + " 'a person is using a smartphone in a restaurant\\n',\n", + " 'a man is holding a glass of water in front of a television\\n',\n", + " 'a man in a kitchen with a knife and a cup of coffee\\n',\n", + " 'the kitchen at the new york times\\n',\n", + " 'a man is holding a knife and cutting a piece of pizza\\n',\n", + " 'a man is reading a book while another is working on a computer\\n',\n", + " 'a person is using a computer to make a presentation\\n',\n", + " 'a man is holding up a box of food\\n'],\n", + " ['a man in a suit and a woman wearing a helmet on a surfboard\\n',\n", + " 'a person is on the ground while holding onto a skateboard\\n',\n", + " 'a man in a beach chair riding a skateboard\\n',\n", + " 'a woman is standing on a surfboard in the ocean while holding a skateboard\\n',\n", + " 'a man is riding on a surfboard\\n',\n", + " 'a man on his knees in a surfboard with his leg up\\n',\n", + " 'a man is doing a trick on a skateboard\\n',\n", + " 'a man is riding a skateboard on a wave\\n',\n", + " 'a person is sitting on a surfboard while another person is riding on it\\n',\n", + " 'a man in a jumpsuit is holding onto a surfboard\\n',\n", + " 'a man is jumping on a surfboard while another is sitting on it\\n',\n", + " 'a man is sitting on a surfboard while he is riding\\n'],\n", + " ['a picture of a man riding a bike next to a bike\\n',\n", + " 'a group of people standing on a street with a bike\\n',\n", + " 'people are sitting around a picnic table and a bike is being ridden\\n',\n", + " 'a group of people are on a beach with a bike and a car\\n',\n", + " \"the world's largest boat race is underway in the bay of britain\\n\",\n", + " 'a man and his bike standing on the side of a road\\n',\n", + " 'a motorcycle is sitting on top of a hill with a boat and a bicycle\\n',\n", + " 'a bunch of people are standing around a large park\\n',\n", + " 'a group of people standing around a table with bicycles\\n',\n", + " 'a man with his bike and helmet in the air\\n',\n", + " 'the sun is shining brightly and there are people walking around\\n',\n", + " 'a group of people standing on a beach next to a boat\\n'],\n", + " ['the home has a large yellow sign\\n',\n", + " 'the building has two small windows and a sign\\n',\n", + " 'a view of a home with a building in the background\\n',\n", + " 'the house has been built in the style of a traditional english cottage\\n',\n", + " 'the house is on the corner of a street\\n',\n", + " 'the home is an old style building with a white door\\n',\n", + " 'the house is in a residential area with many buildings\\n',\n", + " 'the building is white and has a red roof\\n',\n", + " 'the old building is now a park and recreation center\\n',\n", + " 'a large building with a lot of windows and a lot of people\\n',\n", + " 'a large house with a white door and a blue sign\\n',\n", + " 'the house is in a residential area with a front and back door\\n'],\n", + " ['the vegetables are arranged in a square shape on the table\\n',\n", + " 'a plate full of vegetables and fruit with a knife and fork\\n',\n", + " 'a plate of various vegetables with a knife\\n',\n", + " 'a plate with several different types of food\\n',\n", + " 'a plate of food with various vegetables and meat\\n',\n", + " 'a picture of some vegetables and a plate of food\\n',\n", + " 'a close up of several types of food on a table\\n',\n", + " 'a plate of food with a variety of vegetables\\n',\n", + " 'a large plate with many different types of food\\n',\n", + " 'a plate of vegetables and meat on a table\\n',\n", + " 'a plate with lots of different types of vegetables\\n',\n", + " 'a close up of some food with a knife\\n'],\n", + " ['a white cup with a green tea bag and a small bottle of alcohol\\n',\n", + " 'a bottle of wine with two glasses and a spoon\\n',\n", + " 'the chocolate bar is sitting next to the bottle of wine\\n',\n", + " 'a white and black cup and a bottle of wine\\n',\n", + " 'a white cup sitting next to some drinks\\n',\n", + " 'a bottle of wine and a bottle of champagne on a table\\n',\n", + " 'a white cup with two pills and a small bottle of wine\\n',\n", + " 'a bottle of wine and a cup of coffee next to a bottle of wine\\n',\n", + " 'a bottle of wine and a bottle of beer in a glass\\n',\n", + " 'a bottle of wine, a bottle of beer and a wine bottle\\n',\n", + " 'a bottle of wine and a cup with some food\\n',\n", + " 'a glass of wine and a pair of glasses on a table\\n'],\n", + " ['a group of people in white and blue uniforms playing baseball\\n',\n", + " 'a group of people playing baseball in a field\\n',\n", + " 'a group of people playing a game of baseball\\n',\n", + " 'a group of people standing on a field and one is holding a tennis ball\\n',\n", + " 'a group of people in uniform playing baseball\\n',\n", + " 'two men and a woman in the middle of a game\\n',\n", + " 'a group of people playing baseball in the grass\\n',\n", + " 'a group of men and women are playing baseball\\n',\n", + " 'july 15th, 2011 - june 20th, 2012 - june 17th,',\n", + " 'the team is playing soccer and one is holding a ball\\n',\n", + " 'people are playing baseball with each other and one is holding a ball\\n',\n", + " 'the women are laughing and the man is running\\n']]" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "several = sample_several(predicted_embeddings[0:8], num = 12, temp = 0.5)\n", + "several" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "7ced031a-f259-4797-afd7-876fa62cdcfd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[['a group of people are sitting around a table\\n',\n", + " 'a group of people are sitting around a table with food\\n',\n", + " 'a group of people sitting at a table with food\\n',\n", + " 'a group of people are sitting on the ground in front of a table\\n',\n", + " 'a group of people sitting around a table with a person and a dog\\n',\n", + " 'a group of people are sitting on the ground and eating\\n',\n", + " 'the group is sitting around a table with food\\n',\n", + " 'people are sitting around a table with food\\n',\n", + " 'a group of people sitting around a table with food\\n',\n", + " 'the people are eating in front of a table\\n',\n", + " 'a group of people are sitting on a bench in a field\\n',\n", + " 'a group of people are sitting on a bench\\n'],\n", + " ['a man is using a computer and a phone\\n',\n", + " 'a person in a kitchen with a large screen\\n',\n", + " 'a man is preparing food in a kitchen\\n',\n", + " 'a man is standing in front of a computer and a woman is sitting behind him\\n',\n", + " 'a man is using a computer to play a game\\n',\n", + " 'a man is using a computer to play a game\\n',\n", + " 'a man in a kitchen with a large television\\n',\n", + " 'a man is holding a glass of water in front of a television\\n',\n", + " 'the man is holding a bottle of water and a glass\\n',\n", + " 'a man is using a computer to make a video\\n',\n", + " 'a man is serving food at a restaurant\\n',\n", + " 'a man is holding a drink in his hand\\n'],\n", + " ['a man with a skateboard is riding on a wave\\n',\n", + " 'a man is riding a skateboard on a hill\\n',\n", + " 'a man is riding a skateboard on a hill\\n',\n", + " 'a person is sitting on a surfboard while another person is riding on it\\n',\n", + " 'a man is riding a surfboard on a wave\\n',\n", + " 'a man with a skateboard is on top of a hill\\n',\n", + " 'a person in a surfboard is riding a wave\\n',\n", + " 'a man on a surfboard is riding on a wave\\n',\n", + " 'a man in a suit and a woman in a bikini are playing on a surf board\\n',\n", + " 'a man is riding a skateboard while wearing a helmet\\n',\n", + " 'a man on the surf board with his legs in the air\\n',\n", + " 'a man in a suit is playing a game with a skateboard\\n'],\n", + " ['a group of people standing on a beach with a bike\\n',\n", + " 'a group of people standing on a beach with a bike\\n',\n", + " 'a group of people standing on a road with a bike and a car\\n',\n", + " 'a group of people in the water with two bikes\\n',\n", + " 'the bike is in the middle of the road and there are two people on the side of the',\n", + " 'a group of people standing around a car with a bike\\n',\n", + " 'a man is standing on a bike with a skateboard\\n',\n", + " 'a group of people riding bicycles on a road\\n',\n", + " 'a bicycle is in the middle of a field with a person on it\\n',\n", + " 'a man is standing on a bicycle with a helmet and a skateboard\\n',\n", + " 'a photo of a bicycle with a man on it\\n',\n", + " 'a group of people riding bicycles on a road\\n'],\n", + " ['a building with a sign that says \"the old man\"\\n',\n", + " 'a house with a sign that says \"the house that james bond built\"\\n',\n", + " 'a building with a sign that says \"the house\"\\n',\n", + " 'a house with a sign that says \"museum\"\\n',\n", + " 'a building with a sign that says \"the home of the person\"\\n',\n", + " 'a building with a sign that says \"the museum of american history\"\\n',\n", + " 'a white building with a sign on the side\\n',\n", + " 'a brown house with a white roof and a green sign\\n',\n", + " 'a house with a large sign on the side\\n',\n", + " 'a building with a sign that says \"the building\"\\n',\n", + " 'the building is in the middle of the street\\n',\n", + " 'the front of an old building with a sign\\n'],\n", + " ['a plate of different types of vegetables and meat\\n',\n", + " 'a close up of some vegetables and meat\\n',\n", + " 'a plate with a variety of different foods on it\\n',\n", + " 'a plate of vegetables and meat with a green border\\n',\n", + " 'a plate of vegetables with a variety of toppings\\n',\n", + " 'a plate of food with different types of vegetables\\n',\n", + " 'a plate of food with various vegetables and meat\\n',\n", + " 'a plate of vegetables with some green leaves on it\\n',\n", + " 'a bunch of vegetables and mushrooms on a plate\\n',\n", + " 'a bunch of vegetables and fruit on a table\\n',\n", + " 'a plate of vegetables and other items on a table\\n',\n", + " 'a close up of some vegetables and meat\\n'],\n", + " ['a white cup with a spoon and a spoon\\n',\n", + " 'a bottle of wine and a bottle of champagne\\n',\n", + " 'a white cup with a small bottle and a small bottle of wine\\n',\n", + " 'a white cup with a small bottle of wine and a small bottle of water\\n',\n", + " 'the bottle is open and the bottle is next to a cup\\n',\n", + " 'the white cup with a small bottle of wine and a small bottle of wine\\n',\n", + " 'a white cup with a black handle and a pair of scissors\\n',\n", + " 'a bottle of wine and a bottle of wine glasses\\n',\n", + " 'a bottle of wine and a bottle of champagne\\n',\n", + " 'a white and black cup with a small spoon next to it\\n',\n", + " 'a white cup with a small bottle of wine\\n',\n", + " 'a white cup with a spoon and a bottle of wine\\n'],\n", + " ['a group of people playing baseball and soccer\\n',\n", + " 'a group of people are playing baseball in the grass\\n',\n", + " 'a group of people playing baseball and running\\n',\n", + " 'a group of people playing baseball and soccer\\n',\n", + " 'a group of people playing soccer on a field\\n',\n", + " 'a group of people are playing baseball in the grass\\n',\n", + " 'a group of people playing baseball with a man in the background\\n',\n", + " 'a group of people playing baseball and one is holding a ball\\n',\n", + " 'a group of people playing baseball in front of a field\\n',\n", + " 'a group of people playing baseball on a field\\n',\n", + " 'a group of people playing baseball with one person in the background\\n',\n", + " 'a group of people are playing baseball and one is holding a ball\\n']]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "several = sample_several(predicted_embeddings[0:8], num = 12, temp = 0.3)\n", + "several" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccfccd4f-764d-4624-842c-f931676eb43b", + "metadata": {}, + "outputs": [], + "source": [ + "print('test')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1a60e19-c440-4c9c-a634-30186209012f", + "metadata": {}, + "outputs": [], + "source": [ + "def tensor_2_embed_old(tensor):\n", + " embed_array = torch.zeros((tensor.shape[0],257, 1024)) \n", + " to_pil = ToPILImage()\n", + " for sample in range(tensor.shape[0]):\n", + " PIL_image = to_pil(tensor[sample])\n", + " image_for_blip2 = vis_processors[\"eval\"](PIL_image).unsqueeze(0).to(device)\n", + " #Generate embeddings\n", + " with blip2_model.maybe_autocast():\n", + " blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2))\n", + " embed_array[sample] = blip2_target\n", + " \n", + " return embed_array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d39ddada-47f7-4111-92fa-0dd98e8a83d6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec8ed96a-61fa-4c20-8da2-fcd9d0a2ed38", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6228eb1a-e8e7-4500-b7bc-d0c57bcac4c6", + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/train2.ipynb b/src/train2.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ad45b43ea6a1455f75870f32bbce6ae80111ee9b --- /dev/null +++ b/src/train2.ipynb @@ -0,0 +1,1856 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f4d95fac-ac1d-473c-ab96-650f76e6aaf5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Code to convert this notebook to .py if you want to run it via command line or with Slurm\n", + "# from subprocess import call\n", + "# command = \"jupyter nbconvert Train.ipynb --to python\"\n", + "# call(command,shell=True)" + ] + }, + { + "cell_type": "markdown", + "id": "b0f0f4f3", + "metadata": {}, + "source": [ + "# Import packages & functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5bad764b-45c1-45ce-a716-8d055e09821a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-11-19 16:32:39,711] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import json\n", + "import argparse\n", + "import numpy as np\n", + "import math\n", + "from einops import rearrange\n", + "import time\n", + "import random\n", + "import h5py\n", + "from tqdm import tqdm\n", + "\n", + "import webdataset as wds\n", + "import gc\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import transforms\n", + "from torchvision.transforms import ToPILImage #CHANGED (added)\n", + "\n", + "from accelerate import Accelerator, DeepSpeedPlugin\n", + "\n", + "# tf32 data type is faster than standard float32\n", + "torch.backends.cuda.matmul.allow_tf32 = True\n", + "\n", + "# custom functions #\n", + "import utils\n", + "\n", + "global_batch_size = 128 #128" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LOCAL RANK 0\n" + ] + } + ], + "source": [ + "### Multi-GPU config ###\n", + "local_rank = os.getenv('RANK')\n", + "if local_rank is None: \n", + " local_rank = 0\n", + "else:\n", + " local_rank = int(local_rank)\n", + "print(\"LOCAL RANK \", local_rank) \n", + "\n", + "num_devices = torch.cuda.device_count()\n", + "if num_devices==0: num_devices = 1\n", + "\n", + "accelerator = Accelerator(split_batches=False)\n", + "\n", + "### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above \"accelerator = \" line) ###\n", + "\n", + "# if num_devices <= 1 and utils.is_interactive():\n", + "# # can emulate a distributed environment for deepspeed to work in jupyter notebook\n", + "# os.environ[\"MASTER_ADDR\"] = \"localhost\"\n", + "# os.environ[\"MASTER_PORT\"] = str(np.random.randint(10000)+9000)\n", + "# os.environ[\"RANK\"] = \"0\"\n", + "# os.environ[\"LOCAL_RANK\"] = \"0\"\n", + "# os.environ[\"WORLD_SIZE\"] = \"1\"\n", + "# os.environ[\"GLOBAL_BATCH_SIZE\"] = str(global_batch_size) # set this to your batch size!\n", + "# global_batch_size = os.environ[\"GLOBAL_BATCH_SIZE\"]\n", + "\n", + "# # alter the deepspeed config according to your global and local batch size\n", + "# if local_rank == 0:\n", + "# with open('deepspeed_config_stage2.json', 'r') as file:\n", + "# config = json.load(file)\n", + "# config['train_batch_size'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"])\n", + "# config['train_micro_batch_size_per_gpu'] = int(os.environ[\"GLOBAL_BATCH_SIZE\"]) // num_devices\n", + "# with open('deepspeed_config_stage2.json', 'w') as file:\n", + "# json.dump(config, file)\n", + "# else:\n", + "# # give some time for the local_rank=0 gpu to prep new deepspeed config file\n", + "# time.sleep(10)\n", + "# deepspeed_plugin = DeepSpeedPlugin(\"deepspeed_config_stage2.json\")\n", + "# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PID of this process = 2370606\n", + "device: cuda\n", + "Distributed environment: NO\n", + "Num processes: 1\n", + "Process index: 0\n", + "Local process index: 0\n", + "Device: cuda\n", + "\n", + "Mixed precision type: no\n", + "\n", + "distributed = False num_devices = 1 local rank = 0 world size = 1\n" + ] + } + ], + "source": [ + "print(\"PID of this process =\",os.getpid())\n", + "device = accelerator.device\n", + "print(\"device:\",device)\n", + "num_workers = num_devices\n", + "print(accelerator.state)\n", + "world_size = accelerator.state.num_processes\n", + "distributed = not accelerator.state.distributed_type == 'NO'\n", + "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n", + "print = accelerator.print # only print if local_rank=0" + ] + }, + { + "cell_type": "markdown", + "id": "9018b82b-c054-4463-9527-4b0c2a75bda6", + "metadata": { + "tags": [] + }, + "source": [ + "# Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset', '--model_name=captions', '--subj=1', '--batch_size=128', '--n_samples_save=0', '--max_lr=3e-1', '--mixup_pct=.66', '--num_epochs=30', '--ckpt_interval=999', '--no-use_image_aug']\n" + ] + } + ], + "source": [ + "# if running this interactively, can specify jupyter_args here for argparser to use\n", + "if utils.is_interactive():\n", + " # Example use\n", + " jupyter_args = f\"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \\\n", + " --model_name=captions \\\n", + " --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \\\n", + " --max_lr=3e-1 --mixup_pct=.66 --num_epochs=30 --ckpt_interval=999 --no-use_image_aug\"\n", + " #max_lr=3e-5 originally\n", + " jupyter_args = jupyter_args.split()\n", + " print(jupyter_args)\n", + " \n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global batch_size 128\n", + "batch_size 128\n" + ] + } + ], + "source": [ + "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n", + "parser.add_argument(\n", + " \"--model_name\", type=str, default=\"testing\",\n", + " help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n", + ")\n", + "parser.add_argument(\n", + " \"--data_path\", type=str, default=\"/fsx/proj-fmri/shared/natural-scenes-dataset\",\n", + " help=\"Path to where NSD data is stored / where to download it to\",\n", + ")\n", + "parser.add_argument(\n", + " \"--subj\",type=int, default=1, choices=[1,2,5,7],\n", + ")\n", + "parser.add_argument(\n", + " \"--batch_size\", type=int, default=32,\n", + " help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"whether to log to wandb\",\n", + ")\n", + "parser.add_argument(\n", + " \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n", + " help=\"if not using wandb and want to resume from a ckpt\",\n", + ")\n", + "parser.add_argument(\n", + " \"--wandb_project\",type=str,default=\"stability\",\n", + " help=\"wandb project name\",\n", + ")\n", + "parser.add_argument(\n", + " \"--mixup_pct\",type=float,default=.33,\n", + " help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n", + ")\n", + "parser.add_argument(\n", + " \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n", + " help=\"whether to use image augmentation\",\n", + ")\n", + "parser.add_argument(\n", + " \"--num_epochs\",type=int,default=240,\n", + " help=\"number of epochs of training\",\n", + ")\n", + "parser.add_argument(\n", + " \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n", + ")\n", + "parser.add_argument(\n", + " \"--ckpt_interval\",type=int,default=5,\n", + " help=\"save backup ckpt and reconstruct every x epochs\",\n", + ")\n", + "parser.add_argument(\n", + " \"--seed\",type=int,default=42,\n", + ")\n", + "parser.add_argument(\n", + " \"--max_lr\",type=float,default=3e-4,\n", + ")\n", + "parser.add_argument(\n", + " \"--n_samples_save\",type=int,default=0,choices=[0,1],\n", + " help=\"Number of reconstructions for monitoring progress, 0 will speed up training\",\n", + ")\n", + "\n", + "if utils.is_interactive():\n", + " args = parser.parse_args(jupyter_args)\n", + "else:\n", + " args = parser.parse_args()\n", + "\n", + "# create global variables without the args prefix\n", + "for attribute_name in vars(args).keys():\n", + " globals()[attribute_name] = getattr(args, attribute_name)\n", + "\n", + "print(\"global batch_size\", batch_size)\n", + "batch_size = int(batch_size / num_devices)\n", + "print(\"batch_size\", batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60cd7f2c-37fd-426b-a0c6-633e51bc4c4d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "outdir = os.path.abspath(f'../train_logs/{model_name}')\n", + "if not os.path.exists(outdir):\n", + " os.makedirs(outdir,exist_ok=True)\n", + "if use_image_aug:\n", + " import kornia\n", + " from kornia.augmentation.container import AugmentationSequential\n", + " img_augment = AugmentationSequential(\n", + " kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3),\n", + " kornia.augmentation.Resize((224, 224)),\n", + " kornia.augmentation.RandomHorizontalFlip(p=0.3),\n", + " kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3),\n", + " kornia.augmentation.RandomGrayscale(p=0.3),\n", + " same_on_batch=False,\n", + " data_keys=[\"input\"],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e7807ba9-02b6-4bc0-873c-69869abe4091", + "metadata": {}, + "outputs": [], + "source": [ + "wandb_log = False" + ] + }, + { + "cell_type": "markdown", + "id": "42d13c25-1369-4c49-81d4-83d713586096", + "metadata": { + "tags": [] + }, + "source": [ + "# Prep data, models, and dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "1c023f24-5233-4a15-a2f5-78487b3a8546", + "metadata": {}, + "source": [ + "## Dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "81084834-035f-4465-ad59-59e6b806a2f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/train/{0..36}.tar\n", + "/fsx/proj-fmri/shared/mindeyev2_dataset/wds/subj01/test/0.tar\n" + ] + } + ], + "source": [ + "if subj==1:\n", + " num_train = 24958\n", + " num_test = 2770\n", + "test_batch_size = num_test\n", + "\n", + "def my_split_by_node(urls): return urls\n", + " \n", + "train_url = f\"{data_path}/wds/subj0{subj}/train/\" + \"{0..36}.tar\"\n", + "print(train_url)\n", + "\n", + "train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True)\n", + "\n", + "test_url = f\"{data_path}/wds/subj0{subj}/test/\" + \"0.tar\"\n", + "print(test_url)\n", + "\n", + "test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\\\n", + " .shuffle(750, initial=1500, rng=random.Random(42))\\\n", + " .decode(\"torch\")\\\n", + " .rename(behav=\"behav.npy\", past_behav=\"past_behav.npy\", future_behav=\"future_behav.npy\", olds_behav=\"olds_behav.npy\")\\\n", + " .to_tuple(*[\"behav\", \"past_behav\", \"future_behav\", \"olds_behav\"])\n", + "test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "id": "203b060a-2dd2-4c35-929b-c576be82eb52", + "metadata": {}, + "source": [ + "### check dataloaders are working" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e7a9c68c-c3c9-4080-bd99-067c4486dc37", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# test_indices = []\n", + "# test_images = []\n", + "# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + "# test_indices = np.append(test_indices, behav[:,0,5].numpy())\n", + "# test_images = np.append(test_images, behav[:,0,0].numpy())\n", + "# test_indices = test_indices.astype(np.int16)\n", + "# print(test_i, (test_i+1) * test_batch_size, len(test_indices))\n", + "# print(\"---\\n\")\n", + "\n", + "# train_indices = []\n", + "# train_images = []\n", + "# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + "# train_indices = np.append(train_indices, behav[:,0,5].long().numpy())\n", + "# train_images = np.append(train_images, behav[:,0,0].numpy())\n", + "# train_indices = train_indices.astype(np.int16)\n", + "# print(train_i, (train_i+1) * batch_size, len(train_indices))\n", + "\n", + "# # train_images = np.hstack((train_images, test_images))\n", + "# # print(\"WARNING: ADDED TEST IMAGES TO TRAIN IMAGES\")" + ] + }, + { + "cell_type": "markdown", + "id": "45fad12c-f9fb-4408-8fd4-9bca324ad634", + "metadata": {}, + "source": [ + "## Load data and images" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "039dd330-7339-4f88-8f00-45f95e47baa0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "subj01 betas loaded into memory\n", + "voxels torch.Size([27750, 15729])\n", + "images torch.Size([73000, 3, 224, 224])\n" + ] + } + ], + "source": [ + "# load betas\n", + "f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r')\n", + "voxels = f['betas'][:]\n", + "print(f\"subj0{subj} betas loaded into memory\")\n", + "voxels = torch.Tensor(voxels).to(\"cpu\").half()\n", + "if subj==1:\n", + " voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5))))\n", + "print(\"voxels\", voxels.shape)\n", + "num_voxels = voxels.shape[-1]\n", + "\n", + "# load orig images\n", + "f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r')\n", + "images = f['images'][:]\n", + "images = torch.Tensor(images).to(\"cpu\").half()\n", + "print(\"images\", images.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15", + "metadata": {}, + "source": [ + "## Load models" + ] + }, + { + "cell_type": "markdown", + "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5", + "metadata": {}, + "source": [ + "### CLIP image embeddings model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "795e2885-bd07-4e27-bed7-181473c06df9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import transformers\n", + "from transformers import Blip2Processor, Blip2ForConditionalGeneration\n", + "\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b0420dc0-199e-4c1a-857d-b1747058b467", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ViT-L/14 cuda:0\n" + ] + } + ], + "source": [ + "from models import Clipper\n", + "clip_model = Clipper(\"ViT-L/14\", device=torch.device(f\"cuda:{local_rank}\"), hidden_state=True, norm_embs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "23428fb7-2955-4295-bea1-447cebf9f72e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading checkpoint shards: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [01:08<00:00, 34.47s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "'from lavis.models import load_model_and_preprocess\\nfrom lavis.models import model_zoo\\nblip2_model, vis_processors, _ = load_model_and_preprocess(\\n name=\"blip2_t5\", model_type=\"pretrain_flant5xl_vitL\", is_eval=True, device=device)\\n\\nclip_seq_dim = 257\\nclip_emb_dim = 1024\\nhidden_dim = 4096'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cache_blip2 = \"/fsx/proj-fmri/shared/cache/models--Salesforce--blip2-opt-2.7b/snapshots/6e723d92ee91ebcee4ba74d7017632f11ff4217b\"\n", + "\n", + "b2_processor = Blip2Processor.from_pretrained(cache_blip2)\n", + "b2_model = Blip2ForConditionalGeneration.from_pretrained(cache_blip2, torch_dtype=torch.float16, device_map=\"auto\")\n", + "\n", + "#Load in blip2 as well\n", + "\"\"\"from lavis.models import load_model_and_preprocess\n", + "from lavis.models import model_zoo\n", + "blip2_model, vis_processors, _ = load_model_and_preprocess(\n", + " name=\"blip2_t5\", model_type=\"pretrain_flant5xl_vitL\", is_eval=True, device=device)\n", + "\n", + "clip_seq_dim = 257\n", + "clip_emb_dim = 1024\n", + "hidden_dim = 4096\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b06f3de2-a8da-4ba0-94f0-99096f738d55", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def embed_images_b2(images):\n", + " images = (images * 255).type(torch.uint8)\n", + " with torch.no_grad():\n", + " inputs_processed = b2_processor(images, return_tensors=\"pt\").to(\"cuda\", torch.float16)\n", + " enc_imgs = b2_model.vision_model.forward(inputs_processed['pixel_values'])\n", + " return enc_imgs.last_hidden_state.detach(), inputs_processed\n", + "\n", + "def embeds_to_captions_b2(embeds):\n", + " with torch.no_grad():\n", + " input_ids = None #inputs['input_ids']\n", + " attention_mask = None\n", + " batch_size = embeds.shape[0]\n", + " image_embeds = embeds\n", + " image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)\n", + "\n", + " query_tokens = b2_model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + " query_outputs = b2_model.qformer(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_attention_mask,\n", + " return_dict=True,\n", + " )\n", + " query_output = query_outputs.last_hidden_state\n", + "\n", + " language_model_inputs = b2_model.language_projection(query_output)\n", + " language_attention_mask = torch.ones(\n", + " language_model_inputs.size()[:-1], dtype=torch.long, device=language_model_inputs.device\n", + " )\n", + " if input_ids is None:\n", + " input_ids = (\n", + " torch.LongTensor([[b2_model.config.text_config.bos_token_id]])\n", + " .repeat(batch_size, 1)\n", + " .to(image_embeds.device)\n", + " )\n", + " if attention_mask is None:\n", + " attention_mask = torch.ones_like(input_ids)\n", + " attention_mask = torch.cat([language_attention_mask, attention_mask.to(language_attention_mask.device)], dim=1)\n", + "\n", + " # concatenate query embeddings with prompt embeddings\n", + " inputs_embeds = b2_model.get_input_embeddings()(input_ids)\n", + " inputs_embeds = torch.cat([language_model_inputs, inputs_embeds.to(language_model_inputs.device)], dim=1)\n", + "\n", + " outputs = b2_model.language_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=attention_mask,\n", + " )\n", + " text = b2_processor.batch_decode(outputs, skip_special_tokens=True)\n", + " \n", + " return outputs, text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ec0a34d3-76e0-4a47-a9ab-6131ab2ccecd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "image_test = images[1:20].permute(0,2,3,1)\n", + "#raw_image = Image.open('/fsx/proj-fmri/shared/controlNetData/target/img_t1.jpg').convert('RGB')\n", + "# Convert the image to a NumPy array\n", + "#image_test = np.array(raw_image)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e04876a4-45c7-4015-8255-8574c8f50f14", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"import matplotlib.pyplot as plt\\n# Plotting one of the images (taking the first image as an example)\\nimg_to_plot = inputs_rec['pixel_values'][-1]\\n\\n# Transpose the image for correct display (PyTorch: [C, H, W], Matplotlib: [H, W, C])\\nimg_to_plot = img_to_plot.permute(1, 2, 0).to(torch.float32).to('cpu')\\nprint(img_to_plot.shape)\\n\\nplt.imshow(img_to_plot)\\nplt.show()\"" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"import matplotlib.pyplot as plt\n", + "# Plotting one of the images (taking the first image as an example)\n", + "img_to_plot = inputs_rec['pixel_values'][-1]\n", + "\n", + "# Transpose the image for correct display (PyTorch: [C, H, W], Matplotlib: [H, W, C])\n", + "img_to_plot = img_to_plot.permute(1, 2, 0).to(torch.float32).to('cpu')\n", + "print(img_to_plot.shape)\n", + "\n", + "plt.imshow(img_to_plot)\n", + "plt.show()\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "328a17d0-593b-4d1e-812a-10a3b6efea6a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "embeds_test, inputs_rec = embed_images_b2(image_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "abe5f8a8-fca9-4083-8596-a913bdb57de7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#inputs_rec['pixel_values'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c5f3ca7e-b880-421e-b354-7b6c3df565e9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#out = b2_model.generate(**inputs_rec)\n", + "#print(b2_processor.decode(out[0], skip_special_tokens=True).strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fb462016-78d7-46ea-8058-0d608f17ea65", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/admin/home-ckadirt/miniconda3/envs/mindeye/lib/python3.10/site-packages/transformers/generation/utils.py:1260: UserWarning: Using the model-agnostic default `max_length` (=20) to control thegeneration length. We recommend setting `max_new_tokens` to control the maximum length of the generation.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "outputs_test, text_test = embeds_to_captions_b2(embeds_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6a95fcdf-db87-4c02-9728-09f85605fb1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['a cat sitting on a toilet seat\\n',\n", + " 'a person cutting a pizza on a cutting board\\n',\n", + " 'a sandwich and a drink on a table\\n',\n", + " 'a man crossing the street in front of a truck\\n',\n", + " 'a giraffe standing in front of trees\\n',\n", + " 'three men standing together\\n',\n", + " 'a bird standing on a rock next to a body of water\\n',\n", + " 'two men sitting on a street corner in asia\\n',\n", + " 'a woman and two children playing tennis on a court\\n',\n", + " 'a tall brick building with a clock on the side\\n',\n", + " 'a train is on the tracks\\n',\n", + " 'a man and woman in the water with a surfboard\\n',\n", + " 'a living room with a desk and a chair\\n',\n", + " 'a group of men on a basketball court\\n',\n", + " 'a man holding an umbrella\\n',\n", + " 'a man in a red shirt\\n',\n", + " 'a group of people holding cell phones and wine glasses\\n',\n", + " 'a laptop computer sitting on a table in front of a television\\n',\n", + " 'a baseball player is swinging a bat on a field\\n']" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_test" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9ac69fbd-55db-435b-bed6-5ae9186450e3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#inputss['pixel_values'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "0524f498-c8da-4e8a-8970-d75d2d0f6b8b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#image_test.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5417541b-49eb-4e43-a3e2-d937d9653e04", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "max_lr = 1e-4" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "da0ce190-1b3e-4c12-9e9f-91cbc076d044", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "clip_seq_dim = 257 #blip2 image encoder shapes\n", + "clip_emb_dim = 1408 #blip2 image encoder shapes\n", + "hidden_dim = 2048" + ] + }, + { + "cell_type": "markdown", + "id": "5b79bd38-6990-4504-8d45-4a68d57d8885", + "metadata": {}, + "source": [ + "### SD VAE (blurry images)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "01baff79-8114-482b-b115-6f05aa8ad691", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "83,653,863 total\n", + "0 trainable\n" + ] + } + ], + "source": [ + "from diffusers import AutoencoderKL\n", + "autoenc = AutoencoderKL.from_pretrained(\"madebyollin/sdxl-vae-fp16-fix\", torch_dtype=torch.float16, cache_dir=\"/fsx/proj-fmri/shared/cache\")\n", + "# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')[\"model_state_dict\"])\n", + "autoenc.eval()\n", + "autoenc.requires_grad_(False)\n", + "autoenc.to(device)\n", + "utils.count_params(autoenc)" + ] + }, + { + "cell_type": "markdown", + "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0", + "metadata": {}, + "source": [ + "### MindEye modules" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "MindEyeModule()" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class MindEyeModule(nn.Module):\n", + " def __init__(self):\n", + " super(MindEyeModule, self).__init__()\n", + " def forward(self, x):\n", + " return x\n", + " \n", + "model = MindEyeModule()\n", + "model" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "32,215,040 total\n", + "32,215,040 trainable\n", + "param counts:\n", + "32,215,040 total\n", + "32,215,040 trainable\n", + "torch.Size([2, 1, 15729]) torch.Size([2, 1, 2048])\n" + ] + } + ], + "source": [ + "class RidgeRegression(torch.nn.Module):\n", + " # make sure to add weight_decay when initializing optimizer\n", + " def __init__(self, input_size, out_features): \n", + " super(RidgeRegression, self).__init__()\n", + " self.out_features = out_features\n", + " self.linear = torch.nn.Linear(input_size, out_features)\n", + " def forward(self, x):\n", + " return self.linear(x)\n", + " \n", + "model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim)\n", + "utils.count_params(model.ridge)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((2,1,voxels.shape[1]))\n", + "print(b.shape, model.ridge(b).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "3602c333-d029-465c-8fb4-c3ccffdba6fd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "param counts:\n", + "772,419,072 total\n", + "772,419,072 trainable\n", + "param counts:\n", + "804,634,112 total\n", + "804,634,112 trainable\n", + "torch.Size([4, 2048])\n", + "torch.Size([4, 257, 1408])\n" + ] + } + ], + "source": [ + "from functools import partial\n", + "from diffusers.models.vae import Decoder\n", + "class BrainNetwork(nn.Module):\n", + " def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.15, blurry_dim=16):\n", + " super().__init__()\n", + " self.blurry_dim = blurry_dim\n", + " norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h)\n", + " act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU\n", + " act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn)\n", + " self.lin0 = nn.Linear(in_dim, h)\n", + " self.mlp = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Linear(h, h),\n", + " *[item() for item in act_and_norm],\n", + " nn.Dropout(drop)\n", + " ) for _ in range(n_blocks)\n", + " ])\n", + " self.lin1 = nn.Linear(h, out_dim, bias=True)\n", + " # self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True)\n", + " self.n_blocks = n_blocks\n", + " self.clip_size = clip_size\n", + " self.clip_proj = nn.Sequential(\n", + " nn.LayerNorm(clip_size),\n", + " nn.GELU(),\n", + " nn.Linear(clip_size, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, 2048),\n", + " nn.LayerNorm(2048),\n", + " nn.GELU(),\n", + " nn.Linear(2048, clip_size)\n", + " )\n", + " # self.upsampler = Decoder(\n", + " # in_channels=64,\n", + " # out_channels=4,\n", + " # up_block_types=[\"UpDecoderBlock2D\",\"UpDecoderBlock2D\",\"UpDecoderBlock2D\"],\n", + " # block_out_channels=[64, 128, 256],\n", + " # layers_per_block=1,\n", + " # )\n", + " \n", + " def forward(self, x):\n", + " x = self.lin0(x)\n", + " residual = x\n", + " for res_block in range(self.n_blocks):\n", + " x = self.mlp[res_block](x)\n", + " x += residual\n", + " residual = x\n", + " x = x.reshape(len(x), -1)\n", + " x = self.lin1(x)\n", + " # b = self.blin1(x)\n", + " # b = self.upsampler(b.reshape(len(b), -1, 7, 7))\n", + " c = self.clip_proj(x.reshape(len(x), -1, self.clip_size))\n", + " # return c, b\n", + " return c\n", + "\n", + "model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) \n", + "utils.count_params(model.backbone)\n", + "utils.count_params(model)\n", + "\n", + "b = torch.randn((4,hidden_dim))\n", + "print(b.shape)\n", + "clip_ = model.backbone(b)\n", + "print(clip_.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done with model preparations!\n", + "param counts:\n", + "804,634,112 total\n", + "804,634,112 trainable\n" + ] + } + ], + "source": [ + "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n", + "opt_grouped_parameters = [\n", + " {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n", + " {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n", + "]\n", + "\n", + "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95))\n", + "\n", + "if lr_scheduler_type == 'linear':\n", + " lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n", + " optimizer,\n", + " total_iters=int(num_epochs*(num_train*num_devices//batch_size)),\n", + " last_epoch=-1\n", + " )\n", + "elif lr_scheduler_type == 'cycle':\n", + " total_steps=int(num_epochs*(num_train*num_devices//batch_size))\n", + " lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n", + " optimizer, \n", + " max_lr=max_lr,\n", + " total_steps=total_steps,\n", + " final_div_factor=1000,\n", + " last_epoch=-1, pct_start=2/num_epochs\n", + " )\n", + " \n", + "def save_ckpt(tag): \n", + " ckpt_path = outdir+f'/{tag}.pth'\n", + " print(f'saving {ckpt_path}',flush=True)\n", + " unwrapped_model = accelerator.unwrap_model(model)\n", + " try:\n", + " torch.save({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': unwrapped_model.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict(),\n", + " 'lr_scheduler': lr_scheduler.state_dict(),\n", + " 'train_losses': losses,\n", + " 'test_losses': test_losses,\n", + " 'lrs': lrs,\n", + " }, ckpt_path)\n", + " except:\n", + " print(\"Couldn't save... moving on to prevent crashing.\")\n", + " del unwrapped_model\n", + " \n", + "print(\"\\nDone with model preparations!\")\n", + "utils.count_params(model)" + ] + }, + { + "cell_type": "markdown", + "id": "983f458b-35b8-49f2-b6db-80296cece730", + "metadata": {}, + "source": [ + "# Weights and Biases" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "0a25a662-daa8-4de9-9233-8364800fcb6b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb mindeyev2 run captions\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mckadirt\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wandb_config:\n", + " {'model_name': 'captions', 'batch_size': 128, 'num_epochs': 30, 'use_image_aug': False, 'max_lr': 0.0001, 'lr_scheduler_type': 'cycle', 'mixup_pct': 0.66, 'num_train': 24958, 'num_test': 2770, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}\n" + ] + }, + { + "data": { + "text/html": [ + "wandb version 0.16.0 is available! To upgrade, please run:\n", + " $ pip install wandb --upgrade" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.15.5" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /fsx/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20231119_163615-o1xwsqre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run captions to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://stability.wandb.io/ckadirt/mindeyev2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://stability.wandb.io/ckadirt/mindeyev2/runs/o1xwsqre" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# params for wandb\n", + "if local_rank==0 and True: # only use main process for wandb logging\n", + " import wandb\n", + " \n", + " wandb_project = 'mindeyev2'\n", + " wandb_run = model_name\n", + " wandb_notes = ''\n", + " \n", + " print(f\"wandb {wandb_project} run {wandb_run}\")\n", + " wandb.login(host='https://stability.wandb.io')#, relogin=True)\n", + " wandb_config = {\n", + " \"model_name\": model_name,\n", + " \"batch_size\": batch_size,\n", + " \"num_epochs\": num_epochs,\n", + " \"use_image_aug\": use_image_aug,\n", + " \"max_lr\": max_lr,\n", + " \"lr_scheduler_type\": lr_scheduler_type,\n", + " \"mixup_pct\": mixup_pct,\n", + " \"num_train\": num_train,\n", + " \"num_test\": num_test,\n", + " \"seed\": seed,\n", + " \"distributed\": distributed,\n", + " \"num_devices\": num_devices,\n", + " \"world_size\": world_size,\n", + " }\n", + " print(\"wandb_config:\\n\",wandb_config)\n", + " if False: # wandb_auto_resume\n", + " print(\"wandb_id:\",model_name)\n", + " wandb.init(\n", + " id = model_name,\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " resume=\"allow\",\n", + " )\n", + " else:\n", + " wandb.init(\n", + " project=wandb_project,\n", + " name=wandb_run,\n", + " config=wandb_config,\n", + " notes=wandb_notes,\n", + " )\n", + "else:\n", + " wandb_log = False" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4e5de216-5318-4b45-ac02-113f03105adc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\n",
+       "│ n++                                                                                              │\n",
+       "│    ▲                                                                                             │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "SyntaxError: invalid syntax\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[91m╭──────────────────────────────────────────────────────────────────────────────────────────────────╮\u001b[0m\n", + "\u001b[91m│\u001b[0m n++ \u001b[91m│\u001b[0m\n", + "\u001b[91m│\u001b[0m \u001b[1;91m▲\u001b[0m \u001b[91m│\u001b[0m\n", + "\u001b[91m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mSyntaxError: \u001b[0minvalid syntax\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n++" + ] + }, + { + "cell_type": "markdown", + "id": "5b0ae095-3203-4eb8-8606-acc2db6ccf20", + "metadata": {}, + "source": [ + "# More custom functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "827ead88-7eb3-47cc-82da-31565063b927", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# using the same preprocessing as was used in MindEye + BrainDiffuser\n", + "pixcorr_preprocess = transforms.Compose([\n", + " transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n", + "])\n", + "def pixcorr(images,brains):\n", + " # Flatten images while keeping the batch dimension\n", + " all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)\n", + " all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)\n", + " corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean()\n", + " return corrmean" + ] + }, + { + "cell_type": "markdown", + "id": "d5690151-2131-4918-b750-e869cbd1a8a8", + "metadata": {}, + "source": [ + "# Main" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12de6387-6e18-4e4b-b5ce-a847d625330a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "epoch = 0\n", + "losses, test_losses, lrs = [], [], []\n", + "best_test_loss = 1e9\n", + "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n", + "\n", + "# Optionally resume from checkpoint #\n", + "if resume_from_ckpt:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "elif wandb_log:\n", + " if wandb.run.resumed:\n", + " print(\"\\n---resuming from last.pth ckpt---\\n\")\n", + " try:\n", + " checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n", + " except:\n", + " print('last.pth failed... trying last_backup.pth')\n", + " checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu')\n", + " epoch = checkpoint['epoch']\n", + " print(\"Epoch\",epoch)\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n", + " diffusion_diffuser.load_state_dict(checkpoint['model_state_dict'])\n", + " del checkpoint\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare(\n", + "model, optimizer, train_dl, test_dl, lr_scheduler\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfeeda32-82ca-4364-bce1-eaa41b4f3e25", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "\"\"\"transform = transforms.Compose(\n", + " [\n", + " transforms.Resize(\n", + " (224, 224),\n", + " ),\n", + " transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),\n", + " ]\n", + " )\n", + "\n", + "def tensor_2_embed(image): \n", + " image_for_blip2 = transform(image)\n", + " \n", + " #Generate embeddings\n", + " with blip2_model.maybe_autocast():\n", + " blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2))\n", + " \n", + " return blip2_target\n", + "\n", + "def embed_2_caption(image_embeds, model):\n", + " image_embeds = image_embeds.float()\n", + " image_atts = torch.ones(image_embeds.size()[:-1], dtype=torch.long).to(\n", + " image.device)\n", + "\n", + " query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1)\n", + " query_output = model.Qformer.bert(\n", + " query_embeds=query_tokens,\n", + " encoder_hidden_states=image_embeds,\n", + " encoder_attention_mask=image_atts,\n", + " return_dict=True)\n", + "\n", + " inputs_t5 = model.t5_proj(query_output.last_hidden_state)\n", + " atts_t5 = torch.ones(inputs_t5.size()[:-1], dtype=torch.long).to(image.device)\n", + " prompt = model.prompt\n", + " input_tokens = model.t5_tokenizer(\n", + " prompt, padding=\"longest\", return_tensors=\"pt\"\n", + " ).to(image.device)\n", + " encoder_atts = torch.cat([atts_t5, input_tokens.attention_mask], dim=1)\n", + " \n", + " with model.maybe_autocast(dtype=torch.bfloat16):\n", + " inputs_embeds = model.t5_model.encoder.embed_tokens(input_tokens.input_ids)\n", + " inputs_embeds = torch.cat([inputs_t5, inputs_embeds], dim=1)\n", + "\n", + " outputs = model.t5_model.generate(\n", + " inputs_embeds=inputs_embeds,\n", + " attention_mask=encoder_atts)\n", + " output_text = model.t5_tokenizer.batch_decode(\n", + " outputs, skip_special_tokens=True)\n", + " \n", + " return output_text\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "636b4684-df9a-4e29-8683-86fb035ba690", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "wandb_log = True" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60be0d5f-3e94-4612-9373-61b53d836393", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n", + "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n", + "test_image, test_voxel = None, None\n", + "mse = nn.MSELoss()\n", + "for epoch in progress_bar:\n", + " model.train()\n", + " \n", + " fwd_percent_correct = 0.\n", + " bwd_percent_correct = 0.\n", + " test_fwd_percent_correct = 0.\n", + " test_bwd_percent_correct = 0.\n", + "\n", + " loss_clip_total = 0.\n", + " loss_blurry_total = 0.\n", + " test_loss_clip_total = 0.\n", + " test_loss_blurry_total = 0.\n", + "\n", + " blurry_pixcorr = 0.\n", + " test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1\n", + " \n", + " for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl):\n", + " if epoch == 0:\n", + " lrs.append(0)\n", + " break\n", + " with torch.cuda.amp.autocast():\n", + " optimizer.zero_grad()\n", + "\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = images[behav[:,0,0].cpu().long()].to(device).float()\n", + "\n", + " # blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " if use_image_aug: image = img_augment(image)\n", + " # clip_target = clip_model.embed_image(image)\n", + " clip_target = embed_images_b2(image)[0].to(device) #####CHANGED\n", + " assert not torch.any(torch.isnan(clip_target))\n", + " \n", + " if epoch < int(mixup_pct * num_epochs):\n", + " voxel, perm, betas, select = utils.mixco(voxel)\n", + "\n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " clip_voxels = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + "\n", + " if epoch < int(mixup_pct * num_epochs): \n", + " loss_clip = utils.mixco_nce(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=.006, \n", + " perm=perm, betas=betas, select=select)\n", + " else:\n", + " epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n", + " loss_clip = utils.soft_clip_loss(\n", + " clip_voxels_norm,\n", + " clip_target_norm,\n", + " temp=epoch_temp)\n", + " \n", + " loss_mse= mse(clip_voxels, clip_target)\n", + "\n", + " # loss_blurry = mse(blurry_image_enc_, blurry_image_enc) \n", + "\n", + " loss_clip_total += loss_clip.item()\n", + " # loss_blurry_total += loss_blurry.item()\n", + "\n", + " # loss = loss_blurry + loss_clip\n", + " loss = 0.7 * loss_clip + 0.3 * loss_mse\n", + " if (train_i % 10 == 0):\n", + " print(train_i, loss)\n", + " # print(batch_size)\n", + " utils.check_loss(loss)\n", + " accelerator.backward(loss)\n", + " optimizer.step()\n", + " \n", + " losses.append(loss.item())\n", + " lrs.append(optimizer.param_groups[0]['lr'])\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # with torch.no_grad():\n", + " # # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode()\n", + " # random_samps = np.random.choice(np.arange(len(voxel)), size=8, replace=False)\n", + " # blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1)\n", + " # blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images)\n", + "\n", + " if lr_scheduler_type is not None:\n", + " lr_scheduler.step()\n", + " \n", + " model.eval()\n", + " for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl):\n", + " with torch.cuda.amp.autocast():\n", + " with torch.no_grad(): \n", + " # all test samples should be loaded per batch such that test_i should never exceed 0\n", + " if len(behav) != num_test: print(\"!\",len(behav),num_test)\n", + " \n", + " ## Average same-image repeats ##\n", + " if test_image is None:\n", + " voxel = voxels[behav[:,0,5].cpu().long()].to(device)\n", + " \n", + " image = behav[:,0,0].cpu().long()\n", + " \n", + " unique_image, sort_indices = torch.unique(image, return_inverse=True)\n", + " for im in unique_image:\n", + " locs = torch.where(im == image)[0]\n", + " if test_image is None:\n", + " test_image = images[im][None]\n", + " test_voxel = torch.mean(voxel[locs],axis=0)[None]\n", + " else:\n", + " test_image = torch.vstack((test_image, images[im][None]))\n", + " test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None]))\n", + " \n", + " # sample of batch_size\n", + " random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300]\n", + " voxel = test_voxel[random_indices].to(device)\n", + " image = test_image[random_indices].to(device)\n", + " assert len(image) == batch_size\n", + " \n", + " # blurry_image_enc = autoenc.encode(image).latent_dist.mode()\n", + " \n", + " # clip_target = clip_model.embed_image(image.float())\n", + " clip_target = embed_images_b2(image)[0].to(device) #####CHANGED\n", + " \n", + " voxel_ridge = model.ridge(voxel)\n", + " \n", + " # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n", + " clip_voxels = model.backbone(voxel_ridge)\n", + " \n", + " clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n", + " clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n", + " \n", + " # loss_clip = utils.soft_clip_loss(\n", + " # clip_voxels_norm,\n", + " # clip_target_norm,\n", + " # temp=.006)\n", + " \n", + " loss_clip = mse(clip_voxels, clip_target)\n", + "\n", + " # loss_blurry = mse(blurry_image_enc_, blurry_image_enc)\n", + " \n", + " # loss = loss_blurry + loss_clip\n", + " loss = loss_clip\n", + " \n", + " utils.check_loss(loss)\n", + " \n", + " test_losses.append(loss.item())\n", + " \n", + " # forward and backward top 1 accuracy \n", + " labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) \n", + " test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1)\n", + " test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1)\n", + "\n", + " # # halving the batch size because the decoder is computationally heavy\n", + " # blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1)\n", + " # blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1)))\n", + " # test_blurry_pixcorr += pixcorr(image, blurry_recon_images)\n", + "\n", + " #Find captions and print next to images\n", + " #caption1 = embed_2_caption(clip_voxels[[0]], blip2_model)\n", + " #caption2 = embed_2_caption(clip_voxels[[1]], blip2_model)\n", + "\n", + " #true_embed1 = tensor_2_embed(image[[0]])\n", + " #true_embed2 = tensor_2_embed(image[[1]])\n", + "\n", + " # print(clip_voxels[[0]].shape)\n", + " # print(true_embed1.shape)\n", + " \n", + " #true_caption1 = embed_2_caption(true_embed1, blip2_model)\n", + " #true_caption2 = embed_2_caption(true_embed2, blip2_model)\n", + " \n", + " # transform blurry recon latents to images and plot it\n", + " #fig, axes = plt.subplots(2, 2, figsize=(8, 4))\n", + " #axes[0,0].imshow(utils.torch_to_Image(image[[0]]))\n", + " #axes[0,1].imshow(utils.torch_to_Image(image[[1]]))\n", + " #axes[0,0].axis('off'); axes[0,1].axis('off'); axes[1,0].axis('off'); axes[1,1].axis('off')\n", + " #axes[0,0].set_title(caption1)\n", + " #axes[0,1].set_title(caption2)\n", + " #axes[1,0].set_title(true_caption1)\n", + " #axes[1,1].set_title(true_caption2)\n", + "\n", + " #plt.show()\n", + " \n", + " # # transform blurry recon latents to images and plot it\n", + " # fig, axes = plt.subplots(1, 4, figsize=(8, 4))\n", + " # axes[0].imshow(utils.torch_to_Image(image[[0]]))\n", + " # axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1)))\n", + " # axes[2].imshow(utils.torch_to_Image(image[[1]]))\n", + " # axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1)))\n", + " # axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off')\n", + " # axes[0].set_title(caption1)\n", + " # axes[3].set_title(caption2)\n", + " # plt.show()\n", + " \n", + "\n", + " if local_rank==0: \n", + " # if utils.is_interactive(): clear_output(wait=True)\n", + " assert (test_i+1) == 1\n", + " logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n", + " \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n", + " \"train/lr\": lrs[-1],\n", + " \"train/num_steps\": len(losses),\n", + " \"test/num_steps\": len(test_losses),\n", + " \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n", + " \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n", + " \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n", + " \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n", + " \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n", + " \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n", + " \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n", + " \"test/loss_blurry_total\": test_loss_blurry_total / (test_i + 1),\n", + " \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n", + " \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n", + " }\n", + " progress_bar.set_postfix(**logs)\n", + " \n", + " fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n", + " jj=-1\n", + " for j in [0,1,2,3,4,5,6,7]:\n", + " jj+=1\n", + " axes[jj].imshow(utils.torch_to_Image(image[j]))\n", + " axes[jj].axis('off')\n", + "\n", + " if wandb_log:\n", + " generated_captions = embeds_to_captions_b2(clip_voxels[0:8])\n", + " print(generated_captions[1])\n", + " logs[f\"test/recons\"] = wandb.Image(fig, caption=f\"epoch{epoch:03d}\" + \"\\n\".join(generated_captions[1]))\n", + " plt.close()\n", + " # Save model checkpoint and reconstruct\n", + " if epoch % ckpt_interval == 0:\n", + " if not utils.is_interactive():\n", + " save_ckpt(f'last')\n", + " \n", + " if wandb_log: wandb.log(logs)\n", + "\n", + " # wait for other GPUs to catch up if needed\n", + " accelerator.wait_for_everyone()\n", + " torch.cuda.empty_cache()\n", + " gc.collect()\n", + "\n", + "print(\"\\n===Finished!===\\n\")\n", + "if ckpt_saving:\n", + " save_ckpt(f'last')\n", + "if not utils.is_interactive():\n", + " sys.exit(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93e87fde-815d-4452-9915-f5f5dacf7c2a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "plt.plot(losses)\n", + "plt.show()\n", + "plt.plot(test_losses)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccfccd4f-764d-4624-842c-f931676eb43b", + "metadata": {}, + "outputs": [], + "source": [ + "print('test')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1a60e19-c440-4c9c-a634-30186209012f", + "metadata": {}, + "outputs": [], + "source": [ + "def tensor_2_embed_old(tensor):\n", + " embed_array = torch.zeros((tensor.shape[0],257, 1024)) \n", + " to_pil = ToPILImage()\n", + " for sample in range(tensor.shape[0]):\n", + " PIL_image = to_pil(tensor[sample])\n", + " image_for_blip2 = vis_processors[\"eval\"](PIL_image).unsqueeze(0).to(device)\n", + " #Generate embeddings\n", + " with blip2_model.maybe_autocast():\n", + " blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2))\n", + " embed_array[sample] = blip2_target\n", + " \n", + " return embed_array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d39ddada-47f7-4111-92fa-0dd98e8a83d6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec8ed96a-61fa-4c20-8da2-fcd9d0a2ed38", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6228eb1a-e8e7-4500-b7bc-d0c57bcac4c6", + "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.10.8" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "toc-autonumbering": true, + "vscode": { + "interpreter": { + "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/train2.py b/src/train2.py new file mode 100644 index 0000000000000000000000000000000000000000..02c285615c4911f1ff04576fbc6c2d0575032cc0 --- /dev/null +++ b/src/train2.py @@ -0,0 +1,1141 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[1]: + + +# # Code to convert this notebook to .py if you want to run it via command line or with Slurm +# from subprocess import call +# command = "jupyter nbconvert Train.ipynb --to python" +# call(command,shell=True) + + +# # Import packages & functions + +# In[2]: + + +import os +import sys +import json +import argparse +import numpy as np +import math +from einops import rearrange +import time +import random +import h5py +from tqdm import tqdm + +import webdataset as wds +import gc + +import matplotlib.pyplot as plt +import torch +import torch.nn as nn +from torchvision import transforms +from torchvision.transforms import ToPILImage #CHANGED (added) + +from accelerate import Accelerator, DeepSpeedPlugin + +# tf32 data type is faster than standard float32 +torch.backends.cuda.matmul.allow_tf32 = True + +# custom functions # +import utils + +global_batch_size = 128 #128 + + +# In[3]: + + +### Multi-GPU config ### +local_rank = os.getenv('RANK') +if local_rank is None: + local_rank = 0 +else: + local_rank = int(local_rank) +print("LOCAL RANK ", local_rank) + +num_devices = torch.cuda.device_count() +if num_devices==0: num_devices = 1 + +accelerator = Accelerator(split_batches=False) + +### UNCOMMENT BELOW STUFF TO USE DEEPSPEED (also comment out the immediately above "accelerator = " line) ### + +# if num_devices <= 1 and utils.is_interactive(): +# # can emulate a distributed environment for deepspeed to work in jupyter notebook +# os.environ["MASTER_ADDR"] = "localhost" +# os.environ["MASTER_PORT"] = str(np.random.randint(10000)+9000) +# os.environ["RANK"] = "0" +# os.environ["LOCAL_RANK"] = "0" +# os.environ["WORLD_SIZE"] = "1" +# os.environ["GLOBAL_BATCH_SIZE"] = str(global_batch_size) # set this to your batch size! +# global_batch_size = os.environ["GLOBAL_BATCH_SIZE"] + +# # alter the deepspeed config according to your global and local batch size +# if local_rank == 0: +# with open('deepspeed_config_stage2.json', 'r') as file: +# config = json.load(file) +# config['train_batch_size'] = int(os.environ["GLOBAL_BATCH_SIZE"]) +# config['train_micro_batch_size_per_gpu'] = int(os.environ["GLOBAL_BATCH_SIZE"]) // num_devices +# with open('deepspeed_config_stage2.json', 'w') as file: +# json.dump(config, file) +# else: +# # give some time for the local_rank=0 gpu to prep new deepspeed config file +# time.sleep(10) +# deepspeed_plugin = DeepSpeedPlugin("deepspeed_config_stage2.json") +# accelerator = Accelerator(split_batches=False, deepspeed_plugin=deepspeed_plugin) + + +# In[4]: + + +print("PID of this process =",os.getpid()) +device = accelerator.device +print("device:",device) +num_workers = num_devices +print(accelerator.state) +world_size = accelerator.state.num_processes +distributed = not accelerator.state.distributed_type == 'NO' +print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size) +print = accelerator.print # only print if local_rank=0 + + +# # Configurations + +# In[5]: + + +# if running this interactively, can specify jupyter_args here for argparser to use +if utils.is_interactive(): + # Example use + jupyter_args = f"--data_path=/fsx/proj-fmri/shared/mindeyev2_dataset \ + --model_name=captions \ + --subj=1 --batch_size={global_batch_size} --n_samples_save=0 \ + --max_lr=3e-1 --mixup_pct=.66 --num_epochs=30 --ckpt_interval=999 --no-use_image_aug" + #max_lr=3e-5 originally + jupyter_args = jupyter_args.split() + print(jupyter_args) + + from IPython.display import clear_output # function to clear print outputs in cell + get_ipython().run_line_magic('load_ext', 'autoreload') + # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions + get_ipython().run_line_magic('autoreload', '2') + + +# In[6]: + + +parser = argparse.ArgumentParser(description="Model Training Configuration") +parser.add_argument( + "--model_name", type=str, default="testing", + help="name of model, used for ckpt saving and wandb logging (if enabled)", +) +parser.add_argument( + "--data_path", type=str, default="/fsx/proj-fmri/shared/natural-scenes-dataset", + help="Path to where NSD data is stored / where to download it to", +) +parser.add_argument( + "--subj",type=int, default=1, choices=[1,2,5,7], +) +parser.add_argument( + "--batch_size", type=int, default=32, + help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser", +) +parser.add_argument( + "--wandb_log",action=argparse.BooleanOptionalAction,default=False, + help="whether to log to wandb", +) +parser.add_argument( + "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False, + help="if not using wandb and want to resume from a ckpt", +) +parser.add_argument( + "--wandb_project",type=str,default="stability", + help="wandb project name", +) +parser.add_argument( + "--mixup_pct",type=float,default=.33, + help="proportion of way through training when to switch from BiMixCo to SoftCLIP", +) +parser.add_argument( + "--use_image_aug",action=argparse.BooleanOptionalAction,default=True, + help="whether to use image augmentation", +) +parser.add_argument( + "--num_epochs",type=int,default=100, + help="number of epochs of training", +) +parser.add_argument( + "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'], +) +parser.add_argument( + "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True, +) +parser.add_argument( + "--ckpt_interval",type=int,default=5, + help="save backup ckpt and reconstruct every x epochs", +) +parser.add_argument( + "--seed",type=int,default=42, +) +parser.add_argument( + "--max_lr",type=float,default=3e-4, +) +parser.add_argument( + "--n_samples_save",type=int,default=0,choices=[0,1], + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) +parser.add_argument( + "--clip_mse_ratio",type=float,default=0.7, + help="Number of reconstructions for monitoring progress, 0 will speed up training", +) + +if utils.is_interactive(): + args = parser.parse_args(jupyter_args) +else: + args = parser.parse_args() + +# create global variables without the args prefix +for attribute_name in vars(args).keys(): + globals()[attribute_name] = getattr(args, attribute_name) + +print("global batch_size", batch_size) +batch_size = int(batch_size / num_devices) +print("batch_size", batch_size) + + +# In[7]: + + +outdir = os.path.abspath(f'../train_logs/{model_name}') +if not os.path.exists(outdir): + os.makedirs(outdir,exist_ok=True) +if use_image_aug: + import kornia + from kornia.augmentation.container import AugmentationSequential + img_augment = AugmentationSequential( + kornia.augmentation.RandomResizedCrop((224,224), (0.6,1), p=0.3), + kornia.augmentation.Resize((224, 224)), + kornia.augmentation.RandomHorizontalFlip(p=0.3), + kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1, p=0.3), + kornia.augmentation.RandomGrayscale(p=0.3), + same_on_batch=False, + data_keys=["input"], + ) + + +# In[8]: + + +wandb_log = True + + +# # Prep data, models, and dataloaders + +# ## Dataloader + +# In[9]: + + +if subj==1: + num_train = 24958 + num_test = 2770 +test_batch_size = num_test + +def my_split_by_node(urls): return urls + +train_url = f"{data_path}/wds/subj0{subj}/train/" + "{0..36}.tar" +print(train_url) + +train_data = wds.WebDataset(train_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=False, drop_last=False, pin_memory=True) + +test_url = f"{data_path}/wds/subj0{subj}/test/" + "0.tar" +print(test_url) + +test_data = wds.WebDataset(test_url,resampled=False,nodesplitter=my_split_by_node)\ + .shuffle(750, initial=1500, rng=random.Random(42))\ + .decode("torch")\ + .rename(behav="behav.npy", past_behav="past_behav.npy", future_behav="future_behav.npy", olds_behav="olds_behav.npy")\ + .to_tuple(*["behav", "past_behav", "future_behav", "olds_behav"]) +test_dl = torch.utils.data.DataLoader(test_data, batch_size=test_batch_size, shuffle=False, drop_last=False, pin_memory=True) + + +# ### check dataloaders are working + +# In[10]: + + +# test_indices = [] +# test_images = [] +# for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): +# test_indices = np.append(test_indices, behav[:,0,5].numpy()) +# test_images = np.append(test_images, behav[:,0,0].numpy()) +# test_indices = test_indices.astype(np.int16) +# print(test_i, (test_i+1) * test_batch_size, len(test_indices)) +# print("---\n") + +# train_indices = [] +# train_images = [] +# for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): +# train_indices = np.append(train_indices, behav[:,0,5].long().numpy()) +# train_images = np.append(train_images, behav[:,0,0].numpy()) +# train_indices = train_indices.astype(np.int16) +# print(train_i, (train_i+1) * batch_size, len(train_indices)) + +# # train_images = np.hstack((train_images, test_images)) +# # print("WARNING: ADDED TEST IMAGES TO TRAIN IMAGES") + + +# ## Load data and images + +# In[11]: + + +# load betas +f = h5py.File(f'{data_path}/betas_all_subj0{subj}.hdf5', 'r') +voxels = f['betas'][:] +print(f"subj0{subj} betas loaded into memory") +voxels = torch.Tensor(voxels).to("cpu").half() +if subj==1: + voxels = torch.hstack((voxels, torch.zeros((len(voxels), 5)))) +print("voxels", voxels.shape) +num_voxels = voxels.shape[-1] + +# load orig images +f = h5py.File(f'{data_path}/coco_images_224_float16.hdf5', 'r') +images = f['images'][:] +images = torch.Tensor(images).to("cpu").half() +print("images", images.shape) + + +# ## Load models + +# ### CLIP image embeddings model + +# In[12]: + + +import transformers +from transformers import Blip2Processor, Blip2ForConditionalGeneration + +from PIL import Image + + +# In[13]: + + +from models import Clipper +clip_model = Clipper("ViT-L/14", device=torch.device(f"cuda:{local_rank}"), hidden_state=True, norm_embs=True) + + +# In[14]: + + +cache_blip2 = "/fsx/proj-fmri/shared/cache/models--Salesforce--blip2-opt-2.7b/snapshots/6e723d92ee91ebcee4ba74d7017632f11ff4217b" + +b2_processor = Blip2Processor.from_pretrained(cache_blip2) +b2_model = Blip2ForConditionalGeneration.from_pretrained(cache_blip2, torch_dtype=torch.float16, device_map="auto") + +#Load in blip2 as well +"""from lavis.models import load_model_and_preprocess +from lavis.models import model_zoo +blip2_model, vis_processors, _ = load_model_and_preprocess( + name="blip2_t5", model_type="pretrain_flant5xl_vitL", is_eval=True, device=device) + +clip_seq_dim = 257 +clip_emb_dim = 1024 +hidden_dim = 4096""" + + +# In[15]: + + +def embed_images_b2(images): + images = (images * 255).type(torch.uint8) + with torch.no_grad(): + inputs_processed = b2_processor(images, return_tensors="pt").to("cuda", torch.float16) + enc_imgs = b2_model.vision_model.forward(inputs_processed['pixel_values']) + return enc_imgs.last_hidden_state.detach(), inputs_processed + +def embeds_to_captions_b2(embeds): + with torch.no_grad(): + input_ids = None #inputs['input_ids'] + attention_mask = None + batch_size = embeds.shape[0] + image_embeds = embeds + image_attention_mask = torch.ones(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device) + + query_tokens = b2_model.query_tokens.expand(image_embeds.shape[0], -1, -1) + query_outputs = b2_model.qformer( + query_embeds=query_tokens, + encoder_hidden_states=image_embeds, + encoder_attention_mask=image_attention_mask, + return_dict=True, + ) + query_output = query_outputs.last_hidden_state + + language_model_inputs = b2_model.language_projection(query_output) + language_attention_mask = torch.ones( + language_model_inputs.size()[:-1], dtype=torch.long, device=language_model_inputs.device + ) + if input_ids is None: + input_ids = ( + torch.LongTensor([[b2_model.config.text_config.bos_token_id]]) + .repeat(batch_size, 1) + .to(image_embeds.device) + ) + if attention_mask is None: + attention_mask = torch.ones_like(input_ids) + attention_mask = torch.cat([language_attention_mask, attention_mask.to(language_attention_mask.device)], dim=1) + + # concatenate query embeddings with prompt embeddings + inputs_embeds = b2_model.get_input_embeddings()(input_ids) + inputs_embeds = torch.cat([language_model_inputs, inputs_embeds.to(language_model_inputs.device)], dim=1) + + outputs = b2_model.language_model.generate( + inputs_embeds=inputs_embeds, + attention_mask=attention_mask, + ) + text = b2_processor.batch_decode(outputs, skip_special_tokens=True) + + return outputs, text + + +# In[16]: + + +image_test = images[1:20].permute(0,2,3,1) +#raw_image = Image.open('/fsx/proj-fmri/shared/controlNetData/target/img_t1.jpg').convert('RGB') +# Convert the image to a NumPy array +#image_test = np.array(raw_image) + + +# In[17]: + + +"""import matplotlib.pyplot as plt +# Plotting one of the images (taking the first image as an example) +img_to_plot = inputs_rec['pixel_values'][-1] + +# Transpose the image for correct display (PyTorch: [C, H, W], Matplotlib: [H, W, C]) +img_to_plot = img_to_plot.permute(1, 2, 0).to(torch.float32).to('cpu') +print(img_to_plot.shape) + +plt.imshow(img_to_plot) +plt.show()""" + + +# In[18]: + + +embeds_test, inputs_rec = embed_images_b2(image_test) + + +# In[19]: + + +#inputs_rec['pixel_values'].shape + + +# In[20]: + + +#out = b2_model.generate(**inputs_rec) +#print(b2_processor.decode(out[0], skip_special_tokens=True).strip()) + + +# In[21]: + + +outputs_test, text_test = embeds_to_captions_b2(embeds_test) + + +# In[22]: + + +text_test + + +# In[23]: + + +#inputss['pixel_values'].shape + + +# In[24]: + + +#image_test.shape + + +# In[25]: + + + + +# In[26]: + + +clip_seq_dim = 257 #blip2 image encoder shapes +clip_emb_dim = 1408 #blip2 image encoder shapes +hidden_dim = 2048 + + +# ### SD VAE (blurry images) + +# In[27]: + + +from diffusers import AutoencoderKL +autoenc = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, cache_dir="/fsx/proj-fmri/shared/cache") +# autoenc.load_state_dict(torch.load('../train_logs/sdxl_vae_normed/best.pth')["model_state_dict"]) +autoenc.eval() +autoenc.requires_grad_(False) +autoenc.to(device) +utils.count_params(autoenc) + + +# ### MindEye modules + +# In[28]: + + +class MindEyeModule(nn.Module): + def __init__(self): + super(MindEyeModule, self).__init__() + def forward(self, x): + return x + +model = MindEyeModule() +model + + +# In[29]: + + +class RidgeRegression(torch.nn.Module): + # make sure to add weight_decay when initializing optimizer + def __init__(self, input_size, out_features): + super(RidgeRegression, self).__init__() + self.out_features = out_features + self.linear = torch.nn.Linear(input_size, out_features) + def forward(self, x): + return self.linear(x) + +model.ridge = RidgeRegression(voxels.shape[1], out_features=hidden_dim) +utils.count_params(model.ridge) +utils.count_params(model) + +b = torch.randn((2,1,voxels.shape[1])) +print(b.shape, model.ridge(b).shape) + + +# In[30]: + + +from functools import partial +from diffusers.models.vae import Decoder +class BrainNetwork(nn.Module): + def __init__(self, out_dim=768, in_dim=15724, clip_size=768, h=4096, n_blocks=4, norm_type='ln', act_first=False, drop=.35, blurry_dim=16): + super().__init__() + self.blurry_dim = blurry_dim + norm_func = partial(nn.BatchNorm1d, num_features=h) if norm_type == 'bn' else partial(nn.LayerNorm, normalized_shape=h) + act_fn = partial(nn.ReLU, inplace=True) if norm_type == 'bn' else nn.GELU + act_and_norm = (act_fn, norm_func) if act_first else (norm_func, act_fn) + self.lin0 = nn.Linear(in_dim, h) + self.mlp = nn.ModuleList([ + nn.Sequential( + nn.Linear(h, h), + *[item() for item in act_and_norm], + nn.Dropout(drop) + ) for _ in range(n_blocks) + ]) + self.lin1 = nn.Linear(h, out_dim, bias=True) + # self.blin1 = nn.Linear(out_dim, blurry_dim, bias=True) + self.n_blocks = n_blocks + self.clip_size = clip_size + self.clip_proj = nn.Sequential( + nn.LayerNorm(clip_size), + nn.GELU(), + nn.Linear(clip_size, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, 2048), + nn.LayerNorm(2048), + nn.GELU(), + nn.Linear(2048, clip_size) + ) + # self.upsampler = Decoder( + # in_channels=64, + # out_channels=4, + # up_block_types=["UpDecoderBlock2D","UpDecoderBlock2D","UpDecoderBlock2D"], + # block_out_channels=[64, 128, 256], + # layers_per_block=1, + # ) + + def forward(self, x): + x = self.lin0(x) + residual = x + for res_block in range(self.n_blocks): + x = self.mlp[res_block](x) + x += residual + residual = x + x = x.reshape(len(x), -1) + x = self.lin1(x) + # b = self.blin1(x) + # b = self.upsampler(b.reshape(len(b), -1, 7, 7)) + c = self.clip_proj(x.reshape(len(x), -1, self.clip_size)) + # return c, b + return c + +model.backbone = BrainNetwork(h=2048, in_dim=hidden_dim, clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim, blurry_dim=64*7*7) +utils.count_params(model.backbone) +utils.count_params(model) + +b = torch.randn((4,hidden_dim)) +print(b.shape) +clip_ = model.backbone(b) +print(clip_.shape) + + +# In[31]: + + +no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] +opt_grouped_parameters = [ + {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2}, + {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}, +] + +optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr, betas=(0.9, 0.95)) + +if lr_scheduler_type == 'linear': + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + total_iters=int(num_epochs*(num_train*num_devices//batch_size)), + last_epoch=-1 + ) +elif lr_scheduler_type == 'cycle': + total_steps=int(num_epochs*(num_train*num_devices//batch_size)) + lr_scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, + max_lr=max_lr, + total_steps=total_steps, + final_div_factor=1000, + last_epoch=-1, pct_start=2/num_epochs + ) + +def save_ckpt(tag): + ckpt_path = outdir+f'/{tag}.pth' + print(f'saving {ckpt_path}',flush=True) + unwrapped_model = accelerator.unwrap_model(model) + try: + torch.save({ + 'epoch': epoch, + 'model_state_dict': unwrapped_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + 'train_losses': losses, + 'test_losses': test_losses, + 'lrs': lrs, + }, ckpt_path) + except: + print("Couldn't save... moving on to prevent crashing.") + del unwrapped_model + +print("\nDone with model preparations!") +utils.count_params(model) + + +# # Weights and Biases + +# In[32]: + + +# params for wandb +if local_rank==0 and True: # only use main process for wandb logging + import wandb + + wandb_project = 'mindeyev2' + wandb_run = model_name + wandb_notes = '' + + print(f"wandb {wandb_project} run {wandb_run}") + wandb.login(host='https://stability.wandb.io')#, relogin=True) + wandb_config = { + "model_name": model_name, + "batch_size": batch_size, + "num_epochs": num_epochs, + "use_image_aug": use_image_aug, + "max_lr": max_lr, + "lr_scheduler_type": lr_scheduler_type, + "mixup_pct": mixup_pct, + "num_train": num_train, + "num_test": num_test, + "seed": seed, + "distributed": distributed, + "num_devices": num_devices, + "world_size": world_size, + } + print("wandb_config:\n",wandb_config) + if False: # wandb_auto_resume + print("wandb_id:",model_name) + wandb.init( + id = model_name, + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + resume="allow", + ) + else: + wandb.init( + project=wandb_project, + name=wandb_run, + config=wandb_config, + notes=wandb_notes, + ) +else: + wandb_log = False + + +# # More custom functions + +# In[33]: + + +# using the same preprocessing as was used in MindEye + BrainDiffuser +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + # Flatten images while keeping the batch dimension + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(utils.batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + + +# # Main + +# In[34]: + + +epoch = 0 +losses, test_losses, lrs = [], [], [] +best_test_loss = 1e9 +soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs)) + +# Optionally resume from checkpoint # +if resume_from_ckpt: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +elif wandb_log: + if wandb.run.resumed: + print("\n---resuming from last.pth ckpt---\n") + try: + checkpoint = torch.load(outdir+'/last.pth', map_location='cpu') + except: + print('last.pth failed... trying last_backup.pth') + checkpoint = torch.load(outdir+'/last_backup.pth', map_location='cpu') + epoch = checkpoint['epoch'] + print("Epoch",epoch) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) + diffusion_diffuser.load_state_dict(checkpoint['model_state_dict']) + del checkpoint +torch.cuda.empty_cache() + + +# In[35]: + + +model, optimizer, train_dl, test_dl, lr_scheduler = accelerator.prepare( +model, optimizer, train_dl, test_dl, lr_scheduler +) + + +# In[36]: + + +"""transform = transforms.Compose( + [ + transforms.Resize( + (224, 224), + ), + transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ] + ) + +def tensor_2_embed(image): + image_for_blip2 = transform(image) + + #Generate embeddings + with blip2_model.maybe_autocast(): + blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2)) + + return blip2_target + +def embed_2_caption(image_embeds, model): + image_embeds = image_embeds.float() + image_atts = torch.ones(image_embeds.size()[:-1], dtype=torch.long).to( + image.device) + + query_tokens = model.query_tokens.expand(image_embeds.shape[0], -1, -1) + query_output = model.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=image_embeds, + encoder_attention_mask=image_atts, + return_dict=True) + + inputs_t5 = model.t5_proj(query_output.last_hidden_state) + atts_t5 = torch.ones(inputs_t5.size()[:-1], dtype=torch.long).to(image.device) + prompt = model.prompt + input_tokens = model.t5_tokenizer( + prompt, padding="longest", return_tensors="pt" + ).to(image.device) + encoder_atts = torch.cat([atts_t5, input_tokens.attention_mask], dim=1) + + with model.maybe_autocast(dtype=torch.bfloat16): + inputs_embeds = model.t5_model.encoder.embed_tokens(input_tokens.input_ids) + inputs_embeds = torch.cat([inputs_t5, inputs_embeds], dim=1) + + outputs = model.t5_model.generate( + inputs_embeds=inputs_embeds, + attention_mask=encoder_atts) + output_text = model.t5_tokenizer.batch_decode( + outputs, skip_special_tokens=True) + + return output_text""" + + +# In[37]: + + +wandb_log = True + + +# In[ ]: + + +print(f"{model_name} starting with epoch {epoch} / {num_epochs}") +progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0)) +test_image, test_voxel = None, None +mse = nn.MSELoss() +for epoch in progress_bar: + model.train() + + fwd_percent_correct = 0. + bwd_percent_correct = 0. + test_fwd_percent_correct = 0. + test_bwd_percent_correct = 0. + + loss_clip_total = 0. + loss_blurry_total = 0. + test_loss_clip_total = 0. + test_loss_blurry_total = 0. + + blurry_pixcorr = 0. + test_blurry_pixcorr = 0. # needs >.456 to beat low-level subj01 results in mindeye v1 + + for train_i, (behav, past_behav, future_behav, old_behav) in enumerate(train_dl): + if epoch == 0: + lrs.append(0) + break + with torch.cuda.amp.autocast(): + optimizer.zero_grad() + + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = images[behav[:,0,0].cpu().long()].to(device).float() + + # blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + if use_image_aug: image = img_augment(image) + # clip_target = clip_model.embed_image(image) + clip_target = embed_images_b2(image)[0].to(device) #####CHANGED + assert not torch.any(torch.isnan(clip_target)) + + if epoch < int(mixup_pct * num_epochs): + voxel, perm, betas, select = utils.mixco(voxel) + + voxel_ridge = model.ridge(voxel) + + # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + clip_voxels = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + if epoch < int(mixup_pct * num_epochs): + loss_clip = utils.mixco_nce( + clip_voxels_norm, + clip_target_norm, + temp=.006, + perm=perm, betas=betas, select=select) + else: + epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)] + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=epoch_temp) + + loss_mse= mse(clip_voxels, clip_target) + + # loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + loss_clip_total += loss_clip.item() + # loss_blurry_total += loss_blurry.item() + + # loss = loss_blurry + loss_clip + loss = (clip_mse_ratio * loss_clip) + ((1 - clip_mse_ratio) * loss_mse) + if (train_i % 10 == 0): + print(train_i, loss) + # print(batch_size) + utils.check_loss(loss) + accelerator.backward(loss) + optimizer.step() + + losses.append(loss.item()) + lrs.append(optimizer.param_groups[0]['lr']) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # with torch.no_grad(): + # # only doing pixcorr eval on a subset (8) of the samples per batch because its costly & slow to compute autoenc.decode() + # random_samps = np.random.choice(np.arange(len(voxel)), size=8, replace=False) + # blurry_recon_images = autoenc.decode(blurry_image_enc_[random_samps]).sample.clamp(0,1) + # blurry_pixcorr += pixcorr(image[random_samps], blurry_recon_images) + + if lr_scheduler_type is not None: + lr_scheduler.step() + + model.eval() + for test_i, (behav, past_behav, future_behav, old_behav) in enumerate(test_dl): + with torch.cuda.amp.autocast(): + with torch.no_grad(): + # all test samples should be loaded per batch such that test_i should never exceed 0 + if len(behav) != num_test: print("!",len(behav),num_test) + + ## Average same-image repeats ## + if test_image is None: + voxel = voxels[behav[:,0,5].cpu().long()].to(device) + + image = behav[:,0,0].cpu().long() + + unique_image, sort_indices = torch.unique(image, return_inverse=True) + for im in unique_image: + locs = torch.where(im == image)[0] + if test_image is None: + test_image = images[im][None] + test_voxel = torch.mean(voxel[locs],axis=0)[None] + else: + test_image = torch.vstack((test_image, images[im][None])) + test_voxel = torch.vstack((test_voxel, torch.mean(voxel[locs],axis=0)[None])) + + # sample of batch_size + random_indices = torch.arange(len(test_voxel))[:batch_size] #torch.randperm(len(test_voxel))[:300] + voxel = test_voxel[random_indices].to(device) + image = test_image[random_indices].to(device) + assert len(image) == batch_size + + # blurry_image_enc = autoenc.encode(image).latent_dist.mode() + + # clip_target = clip_model.embed_image(image.float()) + clip_target = embed_images_b2(image)[0].to(device) #####CHANGED + + voxel_ridge = model.ridge(voxel) + + # clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge) + clip_voxels = model.backbone(voxel_ridge) + + clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1) + clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1) + + loss_clip = utils.soft_clip_loss( + clip_voxels_norm, + clip_target_norm, + temp=.006) + + loss_mse = mse(clip_voxels, clip_target) + + # loss_blurry = mse(blurry_image_enc_, blurry_image_enc) + + # loss = loss_blurry + loss_clip + loss = (clip_mse_ratio * loss_clip) + ((1 - clip_mse_ratio) * loss_mse) + + utils.check_loss(loss) + + test_losses.append(loss.item()) + + # forward and backward top 1 accuracy + labels = torch.arange(len(clip_target_norm)).to(clip_voxels_norm.device) + test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1) + test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1) + + # # halving the batch size because the decoder is computationally heavy + # blurry_recon_images = autoenc.decode(blurry_image_enc_[:len(voxel)//2]).sample.clamp(0,1) + # blurry_recon_images = torch.vstack((blurry_recon_images, autoenc.decode(blurry_image_enc_[len(voxel)//2:]).sample.clamp(0,1))) + # test_blurry_pixcorr += pixcorr(image, blurry_recon_images) + + #Find captions and print next to images + #caption1 = embed_2_caption(clip_voxels[[0]], blip2_model) + #caption2 = embed_2_caption(clip_voxels[[1]], blip2_model) + + #true_embed1 = tensor_2_embed(image[[0]]) + #true_embed2 = tensor_2_embed(image[[1]]) + + # print(clip_voxels[[0]].shape) + # print(true_embed1.shape) + + #true_caption1 = embed_2_caption(true_embed1, blip2_model) + #true_caption2 = embed_2_caption(true_embed2, blip2_model) + + # transform blurry recon latents to images and plot it + #fig, axes = plt.subplots(2, 2, figsize=(8, 4)) + #axes[0,0].imshow(utils.torch_to_Image(image[[0]])) + #axes[0,1].imshow(utils.torch_to_Image(image[[1]])) + #axes[0,0].axis('off'); axes[0,1].axis('off'); axes[1,0].axis('off'); axes[1,1].axis('off') + #axes[0,0].set_title(caption1) + #axes[0,1].set_title(caption2) + #axes[1,0].set_title(true_caption1) + #axes[1,1].set_title(true_caption2) + + #plt.show() + + # # transform blurry recon latents to images and plot it + # fig, axes = plt.subplots(1, 4, figsize=(8, 4)) + # axes[0].imshow(utils.torch_to_Image(image[[0]])) + # axes[1].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[0]]).sample.clamp(0,1))) + # axes[2].imshow(utils.torch_to_Image(image[[1]])) + # axes[3].imshow(utils.torch_to_Image(autoenc.decode(blurry_image_enc_[[1]]).sample.clamp(0,1))) + # axes[0].axis('off'); axes[1].axis('off'); axes[2].axis('off'); axes[3].axis('off') + # axes[0].set_title(caption1) + # axes[3].set_title(caption2) + # plt.show() + + + if local_rank==0: + # if utils.is_interactive(): clear_output(wait=True) + assert (test_i+1) == 1 + logs = {"train/loss": np.mean(losses[-(train_i+1):]), + "test/loss": np.mean(test_losses[-(test_i+1):]), + "train/lr": lrs[-1], + "train/num_steps": len(losses), + "test/num_steps": len(test_losses), + "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1), + "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1), + "test/test_fwd_pct_correct": test_fwd_percent_correct / (test_i + 1), + "test/test_bwd_pct_correct": test_bwd_percent_correct / (test_i + 1), + "train/loss_clip_total": loss_clip_total / (train_i + 1), + "train/loss_blurry_total": loss_blurry_total / (train_i + 1), + "test/loss_clip_total": test_loss_clip_total / (test_i + 1), + "test/loss_blurry_total": test_loss_blurry_total / (test_i + 1), + "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1), + "test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1), + } + progress_bar.set_postfix(**logs) + + fig, axes = plt.subplots(1, 8, figsize=(10, 4)) + jj=-1 + for j in [0,1,2,3,4,5,6,7]: + jj+=1 + axes[jj].imshow(utils.torch_to_Image(image[j])) + axes[jj].axis('off') + + if wandb_log: + generated_captions = embeds_to_captions_b2(clip_voxels[0:8]) + print(generated_captions[1]) + logs[f"test/recons"] = wandb.Image(fig, caption=f"epoch{epoch:03d}" + "\n".join(generated_captions[1])) + plt.close() + # Save model checkpoint and reconstruct + if epoch % ckpt_interval == 0: + if not utils.is_interactive(): + save_ckpt(f'last') + + if wandb_log: wandb.log(logs) + + # wait for other GPUs to catch up if needed + accelerator.wait_for_everyone() + torch.cuda.empty_cache() + gc.collect() + +print("\n===Finished!===\n") +if ckpt_saving: + save_ckpt(f'last') +if not utils.is_interactive(): + sys.exit(0) + + +# In[ ]: + + +plt.plot(losses) +plt.show() +plt.plot(test_losses) +plt.show() + + +# In[ ]: + + +print('test') + + +# In[ ]: + + +def tensor_2_embed_old(tensor): + embed_array = torch.zeros((tensor.shape[0],257, 1024)) + to_pil = ToPILImage() + for sample in range(tensor.shape[0]): + PIL_image = to_pil(tensor[sample]) + image_for_blip2 = vis_processors["eval"](PIL_image).unsqueeze(0).to(device) + #Generate embeddings + with blip2_model.maybe_autocast(): + blip2_target = blip2_model.ln_vision(blip2_model.visual_encoder(image_for_blip2)) + embed_array[sample] = blip2_target + + return embed_array + + +# In[ ]: + + + + + +# In[ ]: + + + + + +# In[ ]: + + + + diff --git a/src/utils.py b/src/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0cb535a1b34d3b561b58abb828f57a2cf4dd1607 --- /dev/null +++ b/src/utils.py @@ -0,0 +1,368 @@ +import numpy as np +from torchvision import transforms +import torch +import torch.nn as nn +import torch.nn.functional as F +import PIL +import random +import os +import matplotlib.pyplot as plt +import pandas as pd +import math +import webdataset as wds +import tempfile +from torchvision.utils import make_grid +# from diffusers.utils import randn_tensor + +import json +from torchmetrics.image.fid import FrechetInceptionDistance +from PIL import Image +import requests +import io +import time + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + +def is_interactive(): + import __main__ as main + return not hasattr(main, '__file__') + +def seed_everything(seed=0, cudnn_deterministic=True): + random.seed(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + if cudnn_deterministic: + torch.backends.cudnn.deterministic = True + else: + ## needs to be False to use conv3D + print('Note: not using cudnn.deterministic') + +def np_to_Image(x): + if x.ndim==4: + x=x[0] + return PIL.Image.fromarray((x.transpose(1, 2, 0)*127.5+128).clip(0,255).astype('uint8')) + +def torch_to_Image(x): + if x.ndim==4: + x=x[0] + return transforms.ToPILImage()(x) + +def Image_to_torch(x): + try: + x = (transforms.ToTensor()(x)[:3].unsqueeze(0)-.5)/.5 + except: + x = (transforms.ToTensor()(x[0])[:3].unsqueeze(0)-.5)/.5 + return x + +def torch_to_matplotlib(x,device=device): + if torch.mean(x)>10: + x = (x.permute(0, 2, 3, 1)).clamp(0, 255).to(torch.uint8) + else: + x = (x.permute(0, 2, 3, 1) * 255).clamp(0, 255).to(torch.uint8) + if device=='cpu': + return x[0] + else: + return x.cpu().numpy()[0] + +def pairwise_cosine_similarity(A, B, dim=1, eps=1e-8): + #https://stackoverflow.com/questions/67199317/pytorch-cosine-similarity-nxn-elements + numerator = A @ B.T + A_l2 = torch.mul(A, A).sum(axis=dim) + B_l2 = torch.mul(B, B).sum(axis=dim) + denominator = torch.max(torch.sqrt(torch.outer(A_l2, B_l2)), torch.tensor(eps)) + return torch.div(numerator, denominator) + +def batchwise_pearson_correlation(Z, B): + # Calculate means + Z_mean = torch.mean(Z, dim=1, keepdim=True) + B_mean = torch.mean(B, dim=1, keepdim=True) + + # Subtract means + Z_centered = Z - Z_mean + B_centered = B - B_mean + + # Calculate Pearson correlation coefficient + numerator = Z_centered @ B_centered.T + Z_centered_norm = torch.linalg.norm(Z_centered, dim=1, keepdim=True) + B_centered_norm = torch.linalg.norm(B_centered, dim=1, keepdim=True) + denominator = Z_centered_norm @ B_centered_norm.T + + pearson_correlation = (numerator / denominator) + return pearson_correlation + +def batchwise_cosine_similarity(Z,B): + # https://www.h4pz.co/blog/2021/4/2/batch-cosine-similarity-in-pytorch-or-numpy-jax-cupy-etc + B = B.T + Z_norm = torch.linalg.norm(Z, dim=1, keepdim=True) # Size (n, 1). + B_norm = torch.linalg.norm(B, dim=0, keepdim=True) # Size (1, b). + cosine_similarity = ((Z @ B) / (Z_norm @ B_norm)).T + return cosine_similarity + +def topk(similarities,labels,k=5): + if k > similarities.shape[0]: + k = similarities.shape[0] + topsum=0 + for i in range(k): + topsum += torch.sum(torch.argsort(similarities,axis=1)[:,-(i+1)] == labels)/len(labels) + return topsum + +def get_non_diagonals(a): + a = torch.triu(a,diagonal=1)+torch.tril(a,diagonal=-1) + # make diagonals -1 + a=a.fill_diagonal_(-1) + return a + +def gather_features(image_features, voxel_features, accelerator): + all_image_features = accelerator.gather(image_features.contiguous()) + if voxel_features is not None: + all_voxel_features = accelerator.gather(voxel_features.contiguous()) + return all_image_features, all_voxel_features + return all_image_features + +def soft_clip_loss(preds, targs, temp=0.125): #, distributed=False, accelerator=None): + # if not distributed: + clip_clip = (targs @ targs.T)/temp + brain_clip = (preds @ targs.T)/temp + # else: + # all_targs = gather_features(targs, None, accelerator) + # clip_clip = (targs @ all_targs.T)/temp + # brain_clip = (preds @ all_targs.T)/temp + + loss1 = -(brain_clip.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean() + loss2 = -(brain_clip.T.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean() + + loss = (loss1 + loss2)/2 + return loss + +def soft_siglip_loss(preds, targs, temp, bias): + temp = torch.exp(temp) + + logits = (preds @ targs.T) * temp + bias + # diagonals (aka paired samples) should be >0 and off-diagonals <0 + labels = (targs @ targs.T) - 1 + (torch.eye(len(targs)).to(targs.dtype).to(targs.device)) + + loss1 = -torch.sum(nn.functional.logsigmoid(logits * labels[:len(preds)])) / len(preds) + loss2 = -torch.sum(nn.functional.logsigmoid(logits.T * labels[:,:len(preds)])) / len(preds) + loss = (loss1 + loss2)/2 + return loss + +def mixco_hard_siglip_loss(preds, targs, temp, bias, perm, betas): + temp = torch.exp(temp) + + probs = torch.diag(betas) + probs[torch.arange(preds.shape[0]).to(preds.device), perm] = 1 - betas + + logits = (preds @ targs.T) * temp + bias + labels = probs * 2 - 1 + #labels = torch.eye(len(targs)).to(targs.dtype).to(targs.device) * 2 - 1 + + loss1 = -torch.sum(nn.functional.logsigmoid(logits * labels)) / len(preds) + loss2 = -torch.sum(nn.functional.logsigmoid(logits.T * labels)) / len(preds) + loss = (loss1 + loss2)/2 + return loss + +def mixco(voxels, beta=0.15, s_thresh=0.5, perm=None, betas=None, select=None): + if perm is None: + perm = torch.randperm(voxels.shape[0]) + voxels_shuffle = voxels[perm].to(voxels.device,dtype=voxels.dtype) + if betas is None: + betas = torch.distributions.Beta(beta, beta).sample([voxels.shape[0]]).to(voxels.device,dtype=voxels.dtype) + if select is None: + select = (torch.rand(voxels.shape[0]) <= s_thresh).to(voxels.device) + betas_shape = [-1] + [1]*(len(voxels.shape)-1) + voxels[select] = voxels[select] * betas[select].reshape(*betas_shape) + \ + voxels_shuffle[select] * (1 - betas[select]).reshape(*betas_shape) + betas[~select] = 1 + return voxels, perm, betas, select + +def mixco_clip_target(clip_target, perm, select, betas): + clip_target_shuffle = clip_target[perm] + clip_target[select] = clip_target[select] * betas[select].reshape(-1, 1) + \ + clip_target_shuffle[select] * (1 - betas[select]).reshape(-1, 1) + return clip_target + +def mixco_nce(preds, targs, temp=0.1, perm=None, betas=None, select=None, distributed=False, + accelerator=None, local_rank=None, bidirectional=True): + brain_clip = (preds @ targs.T)/temp + + if perm is not None and betas is not None and select is not None: + probs = torch.diag(betas) + probs[torch.arange(preds.shape[0]).to(preds.device), perm] = 1 - betas + + loss = -(brain_clip.log_softmax(-1) * probs).sum(-1).mean() + if bidirectional: + loss2 = -(brain_clip.T.log_softmax(-1) * probs.T).sum(-1).mean() + loss = (loss + loss2)/2 + return loss + else: + loss = F.cross_entropy(brain_clip, torch.arange(brain_clip.shape[0]).to(brain_clip.device)) + if bidirectional: + loss2 = F.cross_entropy(brain_clip.T, torch.arange(brain_clip.shape[0]).to(brain_clip.device)) + loss = (loss + loss2)/2 + return loss + +def count_params(model): + total = sum(p.numel() for p in model.parameters()) + trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) + print('param counts:\n{:,} total\n{:,} trainable'.format(total, trainable)) + +def image_grid(imgs, rows, cols): + w, h = imgs[0].size + grid = PIL.Image.new('RGB', size=(cols*w, rows*h)) + for i, img in enumerate(imgs): + grid.paste(img, box=(i%cols*w, i//cols*h)) + return grid + +def check_loss(loss): + if loss.isnan().any(): + raise ValueError('NaN loss') + +def cosine_anneal(start, end, steps): + return end + (start - end)/2 * (1 + torch.cos(torch.pi*torch.arange(steps)/(steps-1))) + +def resize(img, img_size=128): + if img.ndim == 3: img = img[None] + return nn.functional.interpolate(img, size=(img_size, img_size), mode='nearest') + +def patchify(img, patch_size=16): + B, C, H, W = img.size() + patches = img.unfold(2, patch_size, patch_size).unfold(3, patch_size, patch_size) + patches = patches.contiguous().view(B, C, -1, patch_size, patch_size) + return patches.permute(0, 2, 1, 3, 4) + +def unpatchify(patches): + B, N, C, H, W = patches.shape # B=Batch size, N=Number of patches, C=Channels, H=Height, W=Width + patches = patches.view(B, int(N**0.5), int(N**0.5), C, H, W) + patches = patches.permute(0, 3, 1, 4, 2, 5).contiguous() + return patches.view(B, C, H*int(N**0.5), W*int(N**0.5)) + +import braceexpand +def get_dataloaders( + batch_size, + image_var='images', + num_devices=None, + num_workers=None, + train_url=None, + val_url=None, + meta_url=None, + num_train=None, + num_val=None, + cache_dir="/scratch/tmp/wds-cache", + seed=0, + voxels_key="nsdgeneral.npy", + val_batch_size=None, + to_tuple=["voxels", "images", "trial"], + local_rank=0, + world_size=1, +): + print("Getting dataloaders...") + assert image_var == 'images' + + def my_split_by_node(urls): + return urls + + train_url = list(braceexpand.braceexpand(train_url)) + val_url = list(braceexpand.braceexpand(val_url)) + + if num_devices is None: + num_devices = torch.cuda.device_count() + + if num_workers is None: + num_workers = num_devices + + if num_train is None: + metadata = json.load(open(meta_url)) + num_train = metadata['totals']['train'] + if num_val is None: + metadata = json.load(open(meta_url)) + num_val = metadata['totals']['val'] + + if val_batch_size is None: + val_batch_size = batch_size + + global_batch_size = batch_size * num_devices + num_batches = math.floor(num_train / global_batch_size) + num_worker_batches = math.floor(num_batches / num_workers) + if num_worker_batches == 0: num_worker_batches = 1 + + print("\nnum_train",num_train) + print("global_batch_size",global_batch_size) + print("batch_size",batch_size) + print("num_workers",num_workers) + print("num_batches",num_batches) + print("num_worker_batches", num_worker_batches) + + # train_url = train_url[local_rank:world_size] + train_data = wds.WebDataset(train_url, resampled=False, cache_dir=cache_dir, nodesplitter=my_split_by_node)\ + .shuffle(500, initial=500, rng=random.Random(42))\ + .decode("torch")\ + .rename(images="jpg;png", voxels=voxels_key, trial="trial.npy", coco="coco73k.npy", reps="num_uniques.npy")\ + .to_tuple(*to_tuple)#\ + # .batched(batch_size, partial=True)#\ + # .with_epoch(num_worker_batches) + + # BATCH SIZE SHOULD BE NONE!!! FOR TRAIN AND VAL | resampled=True for train | .batched(val_batch_size, partial=False) + train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=1, shuffle=False) + + # Validation + print("val_batch_size",val_batch_size) + val_data = wds.WebDataset(val_url, resampled=False, cache_dir=cache_dir, nodesplitter=my_split_by_node)\ + .shuffle(500, initial=500, rng=random.Random(42))\ + .decode("torch")\ + .rename(images="jpg;png", voxels=voxels_key, trial="trial.npy", coco="coco73k.npy", reps="num_uniques.npy")\ + .to_tuple(*to_tuple)#\ + # .batched(val_batch_size, partial=True) + val_dl = torch.utils.data.DataLoader(val_data, batch_size=val_batch_size, num_workers=1, shuffle=False, drop_last=True) + + return train_dl, val_dl, num_train, num_val + +pixcorr_preprocess = transforms.Compose([ + transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr(images,brains): + all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1) + corrmean = torch.diag(batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)).mean() + return corrmean + +pixcorr_origsize_nanmean_preprocess = transforms.Compose([ + transforms.Resize(128, interpolation=transforms.InterpolationMode.BILINEAR), +]) +def pixcorr_origsize_nanmean(images,brains): + all_images_flattened = pixcorr_origsize_nanmean_preprocess(images).reshape(len(images), -1) + all_brain_recons_flattened = brains.view(len(brains), -1) # assuming it's already 128 size + corrmean = torch.nanmean(torch.diag(batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened))) + return corrmean + +def select_annotations(annots, random=False): + """ + There are 5 annotations per image. Select one of them for each image. + """ + for i, b in enumerate(annots): + t = '' + if random: + # select random non-empty annotation + while t == '': + rand = torch.randint(5, (1,1))[0][0] + t = b[rand] + else: + # select first non-empty annotation + for j in range(5): + if b[j] != '': + t = b[j] + break + if i == 0: + txt = np.array(t) + else: + txt = np.vstack((txt, t)) + txt = txt.flatten() + return txt + +def add_saturation(image, alpha=2): + gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :] + gray_image = gray_image.unsqueeze(1).expand_as(image) + saturated_image = alpha * image + (1 - alpha) * gray_image + return torch.clamp(saturated_image, 0, 1) \ No newline at end of file diff --git a/train_mem_logs/error.pth b/train_mem_logs/error.pth new file mode 100644 index 0000000000000000000000000000000000000000..592c8120e9eb4f737ca2270944239c5ffc662824 --- /dev/null +++ b/train_mem_logs/error.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c5b11d49c3a54be008689ed7a339164c4740c698ccf562bb069ae274ee9f834 +size 8108517524 diff --git a/train_mem_logs/error_tensors.pth b/train_mem_logs/error_tensors.pth new file mode 100644 index 0000000000000000000000000000000000000000..5845d95aabb395a7c535f38036f540fff3d23781 --- /dev/null +++ b/train_mem_logs/error_tensors.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ef06b797eafcaa4038c81293ce5a4154707134f813b82976d81726e021169fd +size 3534675888 diff --git a/train_mem_logs/test/last.pth b/train_mem_logs/test/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..498f9e4fffa5ed87f49d189c2f6b067284e371ee --- /dev/null +++ b/train_mem_logs/test/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5457bfd8fb50a44c250c8688aa2846ff9bf1ca8c7c03c9cfaff90b565f327b3e +size 16742654526 diff --git a/train_mem_logs/test_mem/last.pth b/train_mem_logs/test_mem/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..7d5440d21b62b0c44178edefc3ddf2885f7ea11d --- /dev/null +++ b/train_mem_logs/test_mem/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e82bf58463b16ffe2049b7788c4de136829f0d6c847335e345630d11e84e2ee3 +size 8066548705 diff --git a/train_mem_logs/test_mem_cat_r/error.pth b/train_mem_logs/test_mem_cat_r/error.pth new file mode 100644 index 0000000000000000000000000000000000000000..946d4638f38c45b8b96a9f9edce032b458a28e58 --- /dev/null +++ b/train_mem_logs/test_mem_cat_r/error.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c9f382fb2f8e97cd96e0408a7c360576e6976bc460b9a84eeac8e9300aebd1c +size 5675977152 diff --git a/train_mem_logs/test_mem_cat_r/error_tensors.pth b/train_mem_logs/test_mem_cat_r/error_tensors.pth new file mode 100644 index 0000000000000000000000000000000000000000..1275e25b63ddcd8a44611ea97af0299d4d19711d --- /dev/null +++ b/train_mem_logs/test_mem_cat_r/error_tensors.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:266bea1afcf992c324d716351890620b14efb515e07a5a95d27721d13170211e +size 3534675888 diff --git a/train_mem_logs/test_mem_cat_r/last.pth b/train_mem_logs/test_mem_cat_r/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..460d633f8166265ae04d059f382a498fa27865d8 --- /dev/null +++ b/train_mem_logs/test_mem_cat_r/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:204b826673307990cea3d376a8ef3fefe54b86e03b0f4adce3d8a5cb23fd6577 +size 5676178213 diff --git a/train_mem_logs/testing-rr-uni/last.pth b/train_mem_logs/testing-rr-uni/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..99665345c74fdaa510b02f9c5129d1bbefb2b12e --- /dev/null +++ b/train_mem_logs/testing-rr-uni/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7923d707f15a4a92ef9375a0712d92f8c8757d8c4f638293aa769253a92a8645 +size 7366600661 diff --git a/train_mem_logs/testing-rr-uni_r/last.pth b/train_mem_logs/testing-rr-uni_r/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..e1242d6c38f3e2b8a9188f277e39a4ef84dd1858 --- /dev/null +++ b/train_mem_logs/testing-rr-uni_r/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0cc116d3e4e4b4dd60b6621c2ee714aae65551f415d746aac71e1c9af4ac9072 +size 5156747353 diff --git a/train_mem_logs_cat/test_mem/last.pth b/train_mem_logs_cat/test_mem/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..e080f49a75193b45133497cfd7a97489af9a48de --- /dev/null +++ b/train_mem_logs_cat/test_mem/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd2bf6184cf12724edd8edb7c06b5748ebf7816dd3d79da156cb16c9d982b12d +size 8108491833 diff --git a/train_mem_logs_cat/test_mem_cat/last.pth b/train_mem_logs_cat/test_mem_cat/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..2c71813c59191b3c7084867a4bc80d9c57fdd241 --- /dev/null +++ b/train_mem_logs_cat/test_mem_cat/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ce45abb1940375178a11fcc4ae753668de37f806c9b0d44ee297f02bb6b1b69 +size 8108491833 diff --git a/train_mem_logs_cat/test_mem_cat_r/last.pth b/train_mem_logs_cat/test_mem_cat_r/last.pth new file mode 100644 index 0000000000000000000000000000000000000000..0413d5f73b86a3fa09f022d660869b2b9e13037f --- /dev/null +++ b/train_mem_logs_cat/test_mem_cat_r/last.pth @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ded3efe8853c42d57e7c63c81d20f1e3c39a86d2c98f68c6f2b0c1923cb49e39 +size 8108490105